public override void Serialize(NetworkWriter writer)
 {
     writer.Write(this.netId);
     writer.WritePackedUInt32((uint) this.stateHash);
     writer.Write(this.normalizedTime);
     writer.WriteBytesAndSize(this.parameters, this.parameters.Length);
 }

    public void AddOurselves(ClientPlayer player, NetworkWriter nw)
    {
        player.currentVessel = this;
        player.ChunkI = WorldToChunkI((Vector2)player.transform.position);

        int rangeT = (PLAYER_CHUNK_RANGE * 2) + 1;

        nw.Write((ushort)ClientMessageType.RequestChunk);
        nw.Write((ushort)(rangeT * rangeT));

        for (int i = 0; i < rangeT; i++) {
            for (int j = 0; j < rangeT; j++) {

                Vec2i temp = player.ChunkI + new Vec2i(i - PLAYER_CHUNK_RANGE, j - PLAYER_CHUNK_RANGE);
                if (!((temp - player.ChunkI) <= PLAYER_CHUNK_RANGE)) {
                    VesselChunk temp2 = chunks.TryGet(temp.x, temp.y);

                    nw.Write(temp.x);
                    nw.Write(temp.y);

                    if (temp2 != null) {
                        nw.Write(temp2.version);
                    } else {
                        nw.Write((uint)uint.MaxValue);
                    }
                }
            }
        }
    }

 public override void Serialize(NetworkWriter writer)
 {
     writer.Write(proxyId);
     writer.Write((short)packet.Compression);
     writer.Write(packet.Length);
     writer.WriteBytesFull(packet.Data);
 }

 public OutputMessage(NetworkWriter data, int connectionID, int channelID)
 {
     Data = data;
     ConnectionID = connectionID;
     Type = MessageType.Reply;
     ChannelID = channelID;
 }

 public override void Serialize(NetworkWriter writer)
 {
     writer.Write(this.netId);
     writer.WriteBytesFull(this.payload);
     writer.Write(this.teleport);
     writer.WritePackedUInt32((uint) this.time);
 }

 public override void Serialize(NetworkWriter writer)
 {
     base.Serialize(writer);
     writer.Write(Polyline.Count);
     foreach (var vector3 in Polyline)
         writer.Write(vector3);
 }

 private void PostInternalMessage(short msgType)
 {
     NetworkWriter writer = new NetworkWriter();
     writer.StartMessage(msgType);
     writer.FinishMessage();
     this.PostInternalMessage(writer.AsArray(), 0);
 }

 public override void Serialize(NetworkWriter writer)
 {
     writer.WritePackedUInt32((uint) this.oldConnectionId);
     writer.WritePackedUInt32((uint) this.playerControllerId);
     writer.Write(this.netId);
     writer.WriteBytesAndSize(this.msgData, this.msgSize);
 }

 public override bool OnSerialize(NetworkWriter writer, bool initialState)
 {
     var serialized = base.OnSerialize (writer, initialState);
     var time = animator.playbackTime;
     writer.Write (time);
     return serialized;
 }

 public override void Serialize(NetworkWriter writer)
 {
     writer.Write(this.netId);
     writer.Write(this.sceneId);
     writer.Write(this.position);
     writer.WriteBytesFull(this.payload);
 }

 public static byte[] Serialize(INetMsg msg)
 {
     var networkWriter = new NetworkWriter();
     uint index = GetMsgIndexFromType( msg.GetType() );
     networkWriter.WritePackedUInt32( index );
     ((MessageBase)msg).Serialize(networkWriter);
     return networkWriter.AsArray();
 }

    /// <summary>
    /// Server: Serialize the state over network
    /// </summary>
    /// <param name="writer"></param>
    /// <param name="initialState"></param>
    /// <returns></returns>
    public override bool OnSerialize(NetworkWriter writer, bool initialState)
    {
        writer.Write(serverLastState.state);
        writer.Write(serverLastState.position);
        writer.Write(serverLastState.rotation);

        return true;
    }

 public override void Serialize(NetworkWriter writer)
 {
     writer.WritePackedUInt32((uint) this.connectionId);
     writer.Write(this.address);
     writer.WritePackedUInt32((uint) this.port);
     writer.Write(this.isHost);
     writer.Write(this.isYou);
 }

 internal void InvokeHandlerOnClient(short msgType, MessageBase msg, int channelId)
 {
     NetworkWriter writer = new NetworkWriter();
     writer.StartMessage(msgType);
     msg.Serialize(writer);
     writer.FinishMessage();
     this.InvokeBytesOnClient(writer.AsArray(), channelId);
 }

 public override void Serialize(NetworkWriter writer)
 {
     writer.Write((ushort) this.peers.Length);
     foreach (PeerInfoMessage message in this.peers)
     {
         message.Serialize(writer);
     }
 }

 public override void Serialize(NetworkWriter writer)
 {
     writer.WritePackedUInt32((uint) this.oldServerConnectionId);
     writer.Write((ushort) this.peers.Length);
     for (int i = 0; i < this.peers.Length; i++)
     {
         this.peers[i].Serialize(writer);
     }
 }

 public override void Serialize(NetworkWriter writer)
 {
     base.Serialize(writer);
     writer.Write(_instructionBase);
     writer.Write(_variantReplacements.Length);
     foreach (string replacement in _variantReplacements) {
         writer.Write(replacement);
     }
 }

 public override void Serialize(NetworkWriter writer)
 {
     writer.Write(ChannelId);
     writer.Write(SenderUserId);
     writer.Write(SenderUserName);
     writer.Write(Message);
     var json = JsonWrapper.SerializeObject(Timestamp);
     writer.Write(json);
 }

 private void Awake()
 {
     this.m_PrevPosition = this.m_Target.localPosition;
     this.m_PrevRotation = this.m_Target.localRotation;
     if (base.localPlayerAuthority)
     {
         this.m_LocalTransformWriter = new NetworkWriter();
     }
 }

 public override void Serialize(NetworkWriter writer)
 {
     writer.Write((ushort) this.scripts.Length);
     for (int i = 0; i < this.scripts.Length; i++)
     {
         writer.Write(this.scripts[i].name);
         writer.Write(this.scripts[i].channel);
     }
 }