public void ReadStateUpdatePacket()

in Networked Physics/Assets/Scripts/PacketSerializer.cs [205:347]
112 lines of code
8 McCabe index (conditional complexity)

    public void ReadStateUpdatePacket( Network.ReadStream stream, out Network.PacketHeader header, out int numAvatarStates, AvatarStateQuantized[] avatarState, out int numStateUpdates, int[] cubeIds, bool[] notChanged, bool[] hasDelta, bool[] perfectPrediction, bool[] hasPredictionDelta, ushort[] baselineSequence, CubeState[] cubeState, CubeDelta[] cubeDelta, CubeDelta[] predictionDelta )
    {
        byte packetType = 0;

        read_bits( stream, out packetType, 8 );

        Debug.Assert( packetType == (byte) PacketType.StateUpdate );

        read_bits( stream, out header.sequence, 16 );
        read_bits( stream, out header.ack, 16 );
        read_bits( stream, out header.ack_bits, 32 );
        read_bits( stream, out header.frameNumber, 32 );
        read_bits( stream, out header.resetSequence, 16 );
        read_float( stream, out header.avatarSampleTimeOffset );

        read_int( stream, out numAvatarStates, 0, Constants.MaxClients );
        for ( int i = 0; i < numAvatarStates; ++i )
        {
            read_avatar_state( stream, out avatarState[i] );
        }

        read_int( stream, out numStateUpdates, 0, Constants.MaxStateUpdates );

        for ( int i = 0; i < numStateUpdates; ++i )
        {
            hasDelta[i] = false;
            perfectPrediction[i] = false;
            hasPredictionDelta[i] = false;

            read_int( stream, out cubeIds[i], 0, Constants.NumCubes - 1 );

#if DEBUG_DELTA_COMPRESSION
            read_int( stream, out cubeDelta[i].absolute_position_x, Constants.PositionMinimumXZ, Constants.PositionMaximumXZ );
            read_int( stream, out cubeDelta[i].absolute_position_y, Constants.PositionMinimumY, Constants.PositionMaximumY );
            read_int( stream, out cubeDelta[i].absolute_position_z, Constants.PositionMinimumXZ, Constants.PositionMaximumXZ );
#endif // #if DEBUG_DELTA_COMPRESSION

            read_int( stream, out cubeState[i].authorityIndex, 0, Constants.MaxAuthority - 1 );
            read_bits( stream, out cubeState[i].authoritySequence, 16 );
            read_bits( stream, out cubeState[i].ownershipSequence, 16 );

            read_bool( stream, out notChanged[i] );

            if ( notChanged[i] )
            {
                read_bits( stream, out baselineSequence[i], 16 );
            }
            else
            {
                read_bool( stream, out perfectPrediction[i] );

                if ( perfectPrediction[i] )
                {
                    read_bits( stream, out baselineSequence[i], 16 );

                    read_bits( stream, out cubeState[i].rotation_largest, 2 );
                    read_bits( stream, out cubeState[i].rotation_a, Constants.RotationBits );
                    read_bits( stream, out cubeState[i].rotation_b, Constants.RotationBits );
                    read_bits( stream, out cubeState[i].rotation_c, Constants.RotationBits );

                    cubeState[i].active = true;
                }
                else
                {
                    read_bool( stream, out hasPredictionDelta[i] );

                    if ( hasPredictionDelta[i] )
                    {
                        read_bits( stream, out baselineSequence[i], 16 );

                        read_bool( stream, out cubeState[i].active );

                        read_linear_velocity_delta( stream, out predictionDelta[i].linear_velocity_delta_x, out predictionDelta[i].linear_velocity_delta_y, out predictionDelta[i].linear_velocity_delta_z );

                        read_angular_velocity_delta( stream, out predictionDelta[i].angular_velocity_delta_x, out predictionDelta[i].angular_velocity_delta_y, out predictionDelta[i].angular_velocity_delta_z );

                        read_position_delta( stream, out predictionDelta[i].position_delta_x, out predictionDelta[i].position_delta_y, out predictionDelta[i].position_delta_z );

                        read_bits( stream, out cubeState[i].rotation_largest, 2 );
                        read_bits( stream, out cubeState[i].rotation_a, Constants.RotationBits );
                        read_bits( stream, out cubeState[i].rotation_b, Constants.RotationBits );
                        read_bits( stream, out cubeState[i].rotation_c, Constants.RotationBits );
                    }
                    else
                    {
                        read_bool( stream, out hasDelta[i] );

                        if ( hasDelta[i] )
                        {
                            read_bits( stream, out baselineSequence[i], 16 );

                            read_bool( stream, out cubeState[i].active );

                            read_linear_velocity_delta( stream, out cubeDelta[i].linear_velocity_delta_x, out cubeDelta[i].linear_velocity_delta_y, out cubeDelta[i].linear_velocity_delta_z );

                            read_angular_velocity_delta( stream, out cubeDelta[i].angular_velocity_delta_x, out cubeDelta[i].angular_velocity_delta_y, out cubeDelta[i].angular_velocity_delta_z );

                            read_position_delta( stream, out cubeDelta[i].position_delta_x, out cubeDelta[i].position_delta_y, out cubeDelta[i].position_delta_z );

                            read_bits( stream, out cubeState[i].rotation_largest, 2 );
                            read_bits( stream, out cubeState[i].rotation_a, Constants.RotationBits );
                            read_bits( stream, out cubeState[i].rotation_b, Constants.RotationBits );
                            read_bits( stream, out cubeState[i].rotation_c, Constants.RotationBits );
                        }
                        else
                        {
                            read_bool( stream, out cubeState[i].active );

                            read_int( stream, out cubeState[i].position_x, Constants.PositionMinimumXZ, Constants.PositionMaximumXZ );
                            read_int( stream, out cubeState[i].position_y, Constants.PositionMinimumY, Constants.PositionMaximumY );
                            read_int( stream, out cubeState[i].position_z, Constants.PositionMinimumXZ, Constants.PositionMaximumXZ );

                            read_bits( stream, out cubeState[i].rotation_largest, 2 );
                            read_bits( stream, out cubeState[i].rotation_a, Constants.RotationBits );
                            read_bits( stream, out cubeState[i].rotation_b, Constants.RotationBits );
                            read_bits( stream, out cubeState[i].rotation_c, Constants.RotationBits );

                            if ( cubeState[i].active )
                            {
                                read_int( stream, out cubeState[i].linear_velocity_x, Constants.LinearVelocityMinimum, Constants.LinearVelocityMaximum );
                                read_int( stream, out cubeState[i].linear_velocity_y, Constants.LinearVelocityMinimum, Constants.LinearVelocityMaximum );
                                read_int( stream, out cubeState[i].linear_velocity_z, Constants.LinearVelocityMinimum, Constants.LinearVelocityMaximum );

                                read_int( stream, out cubeState[i].angular_velocity_x, Constants.AngularVelocityMinimum, Constants.AngularVelocityMaximum );
                                read_int( stream, out cubeState[i].angular_velocity_y, Constants.AngularVelocityMinimum, Constants.AngularVelocityMaximum );
                                read_int( stream, out cubeState[i].angular_velocity_z, Constants.AngularVelocityMinimum, Constants.AngularVelocityMaximum );
                            }
                            else
                            {
                                cubeState[i].linear_velocity_x = 0;
                                cubeState[i].linear_velocity_y = 0;
                                cubeState[i].linear_velocity_z = 0;

                                cubeState[i].angular_velocity_x = 0;
                                cubeState[i].angular_velocity_y = 0;
                                cubeState[i].angular_velocity_z = 0;
                            }
                        }
                    }
                }
            }
        }
    }