C# NetworkReader.ReadInt32方法代码示例

    public ClientVC(NetworkReader nr)
        : base(new Vec2i(0,0), 0)
    {
        this.data = new VesselTile[VesselChunk.DATA_COUNT];

        index.x = nr.ReadInt32();
        index.y = nr.ReadInt32();

        version = nr.ReadUInt32();
        tileCount = nr.ReadInt32();

        for (int i = 0; i < tileCount; i++) {
            //read in vessel tile
            Vec2i tileI;

            tileI.x = nr.ReadInt32();
            tileI.y = nr.ReadInt32();
            FloorType floor0 = (FloorType)nr.ReadByte();
            FloorType floor1 = (FloorType)nr.ReadByte();
            WallTypeMask wallMask = (WallTypeMask)nr.ReadByte();
            bool wallNode = nr.ReadBoolean();

            VesselTile tile = new VesselTile(wallMask, wallNode, floor0, floor1, (uint)VesselTile.FLAGS.NONE);

            SetTile(tileI, tile);
        }
    }

 public override void Deserialize(NetworkReader reader)
 {
     proxyId = reader.ReadInt16();
     packet.Compression = (VoiceChatCompression)reader.ReadInt16();
     packet.Length = reader.ReadInt32();
     packet.Data = reader.ReadBytesAndSize();
 }

    private CharacterState serverLastState; //SERVER: Store last state

    #endregion Fields

    #region Methods

    /// <summary>
    /// All Clients: Deserialize the state from network
    /// </summary>
    /// <param name="reader"></param>
    /// <param name="initialState"></param>
    public override void OnDeserialize(NetworkReader reader, bool initialState)
    {
        CharacterState state = new CharacterState();

        state.state    = reader.ReadInt32();
        state.position = reader.ReadVector3();
        state.rotation = reader.ReadQuaternion();

        //Client: Received a new state for the local player, treat it as an ACK and do reconciliation
        if (isLocalPlayer) {
            SendMessage("ServerState", state, SendMessageOptions.DontRequireReceiver);
        } else {
            //Other Clients: Received a state, treat it like a new position snapshot from authority
            if (initialState)
            {
                //Others Clients: First state, just snap to new position
                transform.position = state.position;
                transform.rotation = state.rotation;
            }
            else if (networkInterpolation != null)
            {
                //Others Clients: Interpolate between received positions
                networkInterpolation.ReceiveState(state);
            }
        }
    }

 public override void Deserialize(NetworkReader reader)
 {
     base.Deserialize(reader);
     int count = reader.ReadInt32();
     Polyline = new List<Vector3>(count);
     for(int i=0; i < count; i++)
         Polyline.Add(reader.ReadVector3());
 }

 public override void Deserialize(NetworkReader reader)
 {
     m_id = reader.ReadNetworkId();
     m_parentId = reader.ReadNetworkId();
     m_childId = reader.ReadInt32();
     m_position = reader.ReadVector3();
     m_payload = reader.ReadBytesAndSize();
 }

    public override void Deserialize(NetworkReader reader)
    {
        base.Deserialize(reader);

        byte setType = reader.ReadByte();
        switch (setType) {
            case (byte)0: _actionSet = new SinglePanelActionSet(); break;
            case (byte)1: _actionSet = new ReplacementPanelActionSet(); break;
            case (byte)2: _actionSet = new CodePanelActionSet(); break;
            default: throw new Exception("Unexpected Action Set ID " + setType);
        }

        _actionSet.Deserialize(reader);

        _x = reader.ReadInt32();
        _y = reader.ReadInt32();
        _prefabIndex = reader.ReadInt32();
    }

 public override void Deserialize(NetworkReader reader)
 {
     base.Deserialize(reader);
     _instructionBase = reader.ReadString();
     _variantReplacements = new string[reader.ReadInt32()];
     for (int i = 0; i < _variantReplacements.Length; i++) {
         _variantReplacements[i] = reader.ReadString();
     }
 }

    public override void Deserialize(NetworkReader reader) {
        //Get the no of inputs received
        int count = reader.ReadInt32();

        //Prepaare list
        if (inputsList != null) {
            inputsList.Clear(); //Detatch prev elements
        }
        inputsList = new List<Inputs>(); //Detatch prev mem

        //Build all inputs
        for (int i = 0; i < count; i++){
            //Create
            Inputs input = new Inputs();

            //Deserialize individually
            input.crouch = reader.ReadBoolean();
            input.jump = reader.ReadBoolean();
            input.move = reader.ReadBoolean();
            input.pitch = reader.ReadSingle();
            input.rotate = reader.ReadBoolean();
            input.timeStamp = reader.ReadDouble();
            input.walk = reader.ReadBoolean();
            bool[] wasd = new bool[4];
            wasd[0] = reader.ReadBoolean();
            wasd[1] = reader.ReadBoolean();
            wasd[2] = reader.ReadBoolean();
            wasd[3] = reader.ReadBoolean();
            input.wasd = wasd;
            input.yaw = reader.ReadSingle();

            //Add to the message list
            inputsList.Add(input);

            //Check if is the last input and register stamp
            if(i == count - 1) {
                stamp = input.timeStamp;
            }
        }
    }

    private void ReceiveSetTile(NetworkReader reader)
    {
        int location = reader.ReadInt32();
        byte tile = reader.ReadByte();

        if (hosting)
        {
            SendAll(SetTileMessage(location, tile));
        }

        if (world.tilemap[location] != tile)
        {
            audio.PlayOneShot(placeSound);
            worldView.SetTile(location, tile);
        }
    }

            public override void Deserialize(NetworkReader reader)
            {
                name = reader.ReadString();

                var isNull = reader.ReadBoolean();
                if (isNull){
                    value = null;
                    return;
                }

                var typeName = reader.ReadString();
                var t = System.Type.GetType(typeName);

                if (t == typeof(string)){
                    value = reader.ReadString();
                    return;
                }
                if (t == typeof(bool)){
                    value = reader.ReadBoolean();
                    return;
                }
                if (t == typeof(int)){
                    value = reader.ReadInt32();
                    return;
                }
                if (t == typeof(float)){
                    value = reader.ReadSingle();
                    return;
                }
                if (t == typeof(Color)){
                    value = reader.ReadColor();
                    return;
                }
                if (t == typeof(Vector2)){
                    value = reader.ReadVector2();
                    return;
                }
                if (t == typeof(Vector3)){
                    value = reader.ReadVector3();
                    return;
                }
                if (t == typeof(Vector4)){
                    value = reader.ReadVector4();
                    return;
                }
                if (t == typeof(Quaternion)){
                    value = reader.ReadQuaternion();
                    return;
                }
                if (t == typeof(GameObject)){
                    value = reader.ReadGameObject();
                    return;
                }
                if (typeof(Component).RTIsAssignableFrom(t)){
                    var go = reader.ReadGameObject();
                    if (go != null){
                        value = go.GetComponent(t);
                    }
                    return;
                }
            }

    private void ReceiveLockTile(NetworkReader reader)
    {
        World.Avatar avatar = ID2Avatar(reader.ReadInt32());
        byte tile = reader.ReadByte();

        if (avatar != null)
        {
            Debug.LogFormat("{0} locking {1}", avatar.id, tile);

            locks[tile] = avatar;

            if (avatar == worldView.viewer) OpenForEdit(tile);

            if (hosting) SendAll(LockTileMessage(avatar, tile));
        }
        else if (locks.ContainsKey(tile))
        {
            Debug.LogFormat("unlocking {0}", tile);

            locks.Remove(tile);

            if (hosting) SendAll(LockTileMessage(null, tile));
        }

        tilePalette.Refresh();
    }

//.........这里部分代码省略.........
                {
                    Type type = (Type) reader.ReadByte();

                    if (type == Type.Tilemap)
                    {
                        world.tilemap = reader.ReadBytesAndSize();
                        worldView.SetWorld(world);
                    }
                    else if (type == Type.Palette)
                    {
                        for (int i = 0; i < 16; ++i)
                        {
                            world.palette[i] = reader.ReadColor32();
                            SetPalette((byte) i, world.palette[i]);
                        }
                    }
                    else if (type == Type.PaletteEdit)
                    {
                        ReceivePaletteEdit(reader);
                    }
                    else if (type == Type.Walls)
                    {
                        world.walls.Clear();

                        foreach (var wall in reader.ReadBytesAndSize())
                        {
                            world.walls.Add(wall);
                        }

                        worldView.RefreshWalls();
                    }
                    else if (type == Type.Tileset)
                    {
                        int id = reader.ReadInt32();

                        tiledata[id] = reader.ReadBytesAndSize();
                    }
                    else if (type == Type.ReplicateAvatar)
                    {
                        ReceiveCreateAvatar(reader);
                    }
                    else if (type == Type.DestroyAvatar)
                    {
                        ReceiveDestroyAvatar(reader);
                    }
                    else if (type == Type.GiveAvatar)
                    {
                        ReceiveGiveAvatar(reader);
                    }
                    else if (type == Type.MoveAvatar)
                    {
                        World.Avatar avatar = ID2Avatar(reader.ReadInt32());
                        Vector2 dest = reader.ReadVector2();

                        if (hosting)
                        {
                            if (connectionID == avatar.id
                             && !Blocked(avatar, dest))
                            {
                                avatar.source = avatar.destination;
                                avatar.destination = dest;
                                avatar.u = 0;

                                SendAll(MoveAvatarMessage(avatar, avatar.destination), except: avatar.id);
                            }
                            else

    private ServerVC ReadChunkRequest(NetworkReader nr)
    {
        Vec2i index;
        index.x = nr.ReadInt32();
        index.y = nr.ReadInt32();

        uint version = nr.ReadUInt32();

        if (version == uint.MaxValue) {
            return (ServerVC)chunks.TryGet(index);
        } else {
            ServerVC vc = (ServerVC)chunks.TryGet(index);

            if (version != vc.version) {
                return vc;
            } else {
                return null;
            }
        }
    }

 public override void OnDeserialize(NetworkReader reader, bool initialState)
 {
     if (initialState)
     {
         int stateNameHash = reader.ReadInt32();
         float normalizedTime = reader.ReadSingle();
         this.ReadParameters(reader, false);
         this.m_Animator.Play(stateNameHash, 0, normalizedTime);
     }
 }

 public override void Deserialize(NetworkReader reader)
 {
     Result = reader.ReadInt32();
     JustDoIt = reader.ReadBoolean();
     PlayerID = reader.ReadInt64();
 }