public void WriteStateUpdatePacket()

in Networked Physics/Assets/Scripts/PacketSerializer.cs [63:187]
98 lines of code
8 McCabe index (conditional complexity)

    public void WriteStateUpdatePacket( Network.WriteStream stream, ref Network.PacketHeader header, int numAvatarStates, AvatarStateQuantized[] avatarState, int numStateUpdates, int[] cubeIds, bool[] notChanged, bool[] hasDelta, bool[] perfectPrediction, bool[] hasPredictionDelta, ushort[] baselineSequence, CubeState[] cubeState, CubeDelta[] cubeDelta, CubeDelta[] predictionDelta )
    {
        byte packetType = (byte) PacketType.StateUpdate;

        write_bits( stream, packetType, 8 );

        write_bits( stream, header.sequence, 16 );
        write_bits( stream, header.ack, 16 );
        write_bits( stream, header.ack_bits, 32 );
        write_bits( stream, header.frameNumber, 32 );
        write_bits( stream, header.resetSequence, 16 );
        write_float( stream, header.avatarSampleTimeOffset );

        write_int( stream, numAvatarStates, 0, Constants.MaxClients );
        for ( int i = 0; i < numAvatarStates; ++i )
        {
            write_avatar_state( stream, ref avatarState[i] );
        }

        write_int( stream, numStateUpdates, 0, Constants.MaxStateUpdates );

        for ( int i = 0; i < numStateUpdates; ++i )
        {
            write_int( stream, cubeIds[i], 0, Constants.NumCubes - 1 );

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

            write_int( stream, cubeState[i].authorityIndex, 0, Constants.MaxAuthority - 1 );
            write_bits( stream, cubeState[i].authoritySequence, 16 );
            write_bits( stream, cubeState[i].ownershipSequence, 16 );

            write_bool( stream, notChanged[i] );

            if ( notChanged[i] )
            {
                write_bits( stream, baselineSequence[i], 16 );
            }
            else
            {
                write_bool( stream, perfectPrediction[i] );

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

                    write_bits( stream, cubeState[i].rotation_largest, 2 );
                    write_bits( stream, cubeState[i].rotation_a, Constants.RotationBits );
                    write_bits( stream, cubeState[i].rotation_b, Constants.RotationBits );
                    write_bits( stream, cubeState[i].rotation_c, Constants.RotationBits );
                }
                else
                {
                    write_bool( stream, hasPredictionDelta[i] );

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

                        write_bool( stream, cubeState[i].active );

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

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

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

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

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

                            write_bool( stream, cubeState[i].active );

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

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

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

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

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

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

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

                                write_int( stream, cubeState[i].angular_velocity_x, Constants.AngularVelocityMinimum, Constants.AngularVelocityMaximum );
                                write_int( stream, cubeState[i].angular_velocity_y, Constants.AngularVelocityMinimum, Constants.AngularVelocityMaximum );
                                write_int( stream, cubeState[i].angular_velocity_z, Constants.AngularVelocityMinimum, Constants.AngularVelocityMaximum );
                            }
                        }
                    }
                }
            }
        }
    }