public static void PredictBallistic()

in Networked Physics/Assets/Scripts/Prediction.cs [48:191]
100 lines of code
20 McCabe index (conditional complexity)

    public static void PredictBallistic( int numFrames, 
                                         int start_position_x, int start_position_y, int start_position_z,
                                         int start_linear_velocity_x, int start_linear_velocity_y, int start_linear_velocity_z,
                                         int start_angular_velocity_x, int start_angular_velocity_y, int start_angular_velocity_z,
                                         out int predicted_position_x, out int predicted_position_y, out int predicted_position_z,
                                         out int predicted_linear_velocity_x, out int predicted_linear_velocity_y, out int predicted_linear_velocity_z,
                                         out int predicted_angular_velocity_x, out int predicted_angular_velocity_y, out int predicted_angular_velocity_z )
    {
        // convert network format values to fixed point for prediction. fixed point ensures determinism.

        long position_x = ( (long) start_position_x ) << FixedPointIntermediateBits;
        long position_y = ( (long) start_position_y ) << FixedPointIntermediateBits;
        long position_z = ( (long) start_position_z ) << FixedPointIntermediateBits;

        long linear_velocity_x = ( (long) start_linear_velocity_x ) << FixedPointIntermediateBits;
        long linear_velocity_y = ( (long) start_linear_velocity_y ) << FixedPointIntermediateBits;
        long linear_velocity_z = ( (long) start_linear_velocity_z ) << FixedPointIntermediateBits;

        long angular_velocity_x = ( (long) start_angular_velocity_x ) << FixedPointIntermediateBits;
        long angular_velocity_y = ( (long) start_angular_velocity_y ) << FixedPointIntermediateBits;
        long angular_velocity_z = ( (long) start_angular_velocity_z ) << FixedPointIntermediateBits;

        for ( int i = 0; i < numFrames; ++i )
        {
            // apply gravity

            linear_velocity_y -= ( FixedPointGravity * FixedPointDeltaTime ) >> FixedPointFractionalBits;

            // apply linear drag

            linear_velocity_x *= FixedPointLinearDrag;
            linear_velocity_y *= FixedPointLinearDrag;
            linear_velocity_z *= FixedPointLinearDrag;

            linear_velocity_x >>= FixedPointFractionalBits;
            linear_velocity_y >>= FixedPointFractionalBits;
            linear_velocity_z >>= FixedPointFractionalBits;

            // apply angular drag

            angular_velocity_x *= FixedPointAngularDrag;
            angular_velocity_y *= FixedPointAngularDrag;
            angular_velocity_z *= FixedPointAngularDrag;

            angular_velocity_x >>= FixedPointFractionalBits;
            angular_velocity_y >>= FixedPointFractionalBits;
            angular_velocity_z >>= FixedPointFractionalBits;

            // integrate position from linear velocity

            position_x += ( linear_velocity_x * FixedPointDeltaTime ) >> FixedPointFractionalBits;
            position_y += ( linear_velocity_y * FixedPointDeltaTime ) >> FixedPointFractionalBits;
            position_z += ( linear_velocity_z * FixedPointDeltaTime ) >> FixedPointFractionalBits;

            // quantize and bound position

            position_x += FixedPointQuantizeRound;
            position_y += FixedPointQuantizeRound;
            position_z += FixedPointQuantizeRound;

            position_x &= FixedPointQuantizeMask;
            position_y &= FixedPointQuantizeMask;
            position_z &= FixedPointQuantizeMask;

            if ( position_x < FixedPointPositionMinimumXZ )
                position_x = FixedPointPositionMinimumXZ;
            else if ( position_x > FixedPointPositionMaximumXZ )
                position_x = FixedPointPositionMaximumXZ;

            if ( position_y < FixedPointPositionMinimumY )
                position_y = FixedPointPositionMinimumY;
            else if ( position_y > FixedPointPositionMaximumY )
                position_y = FixedPointPositionMaximumY;

            if ( position_z < FixedPointPositionMinimumXZ )
                position_z = FixedPointPositionMinimumXZ;
            else if ( position_z > FixedPointPositionMaximumXZ )
                position_z = FixedPointPositionMaximumXZ;

            // quantize and bound linear velocity

            linear_velocity_x += FixedPointQuantizeRound;
            linear_velocity_y += FixedPointQuantizeRound;
            linear_velocity_z += FixedPointQuantizeRound;

            linear_velocity_x &= FixedPointQuantizeMask;
            linear_velocity_y &= FixedPointQuantizeMask;
            linear_velocity_z &= FixedPointQuantizeMask;

            if ( linear_velocity_x < FixedPointLinearVelocityMinimum )
                linear_velocity_x = FixedPointLinearVelocityMinimum;
            else if ( linear_velocity_x > FixedPointLinearVelocityMaximum )
                linear_velocity_x = FixedPointLinearVelocityMaximum;

            if ( linear_velocity_y < FixedPointLinearVelocityMinimum )
                linear_velocity_y = FixedPointLinearVelocityMinimum;
            else if ( linear_velocity_y > FixedPointLinearVelocityMaximum )
                linear_velocity_y = FixedPointLinearVelocityMaximum;

            if ( linear_velocity_z < FixedPointLinearVelocityMinimum )
                linear_velocity_z = FixedPointLinearVelocityMinimum;
            else if ( linear_velocity_z > FixedPointLinearVelocityMaximum )
                linear_velocity_z = FixedPointLinearVelocityMaximum;

            // quantize and bound angular velocity

            angular_velocity_x += FixedPointQuantizeRound;
            angular_velocity_y += FixedPointQuantizeRound;
            angular_velocity_z += FixedPointQuantizeRound;

            angular_velocity_x &= FixedPointQuantizeMask;
            angular_velocity_y &= FixedPointQuantizeMask;
            angular_velocity_z &= FixedPointQuantizeMask;

            if ( angular_velocity_x < FixedPointAngularVelocityMinimum )
                angular_velocity_x = FixedPointAngularVelocityMinimum;
            else if ( angular_velocity_x > FixedPointAngularVelocityMaximum )
                angular_velocity_x = FixedPointAngularVelocityMaximum;

            if ( angular_velocity_y < FixedPointAngularVelocityMinimum )
                angular_velocity_y = FixedPointAngularVelocityMinimum;
            else if ( angular_velocity_y > FixedPointAngularVelocityMaximum )
                angular_velocity_y = FixedPointAngularVelocityMaximum;

            if ( angular_velocity_z < FixedPointAngularVelocityMinimum )
                angular_velocity_z = FixedPointAngularVelocityMinimum;
            else if ( angular_velocity_z > FixedPointAngularVelocityMaximum )
                angular_velocity_z = FixedPointAngularVelocityMaximum;
        }

        // convert fixed point values back to network format

        predicted_position_x = (int) ( position_x >> FixedPointIntermediateBits );
        predicted_position_y = (int) ( position_y >> FixedPointIntermediateBits );
        predicted_position_z = (int) ( position_z >> FixedPointIntermediateBits );

        predicted_linear_velocity_x = (int) ( linear_velocity_x >> FixedPointIntermediateBits );
        predicted_linear_velocity_y = (int) ( linear_velocity_y >> FixedPointIntermediateBits );
        predicted_linear_velocity_z = (int) ( linear_velocity_z >> FixedPointIntermediateBits );

        predicted_angular_velocity_x = (int) ( angular_velocity_x >> FixedPointIntermediateBits );
        predicted_angular_velocity_y = (int) ( angular_velocity_y >> FixedPointIntermediateBits );
        predicted_angular_velocity_z = (int) ( angular_velocity_z >> FixedPointIntermediateBits );
    }