internal void Write(NetOutgoingMessage Message)
        {
            ChunkCoords.Write(Message);

            Vector3i BlockCoords = ChunkCoords * Size;
            for (int x = 0; x < Size.X; x++) {
                for (int y = 0; y < Size.Y; y++) {
                    for (int z = 0; z < Size.Z; z++) {
                        Vector3i BlockAt = BlockCoords + new Vector3i(x, y, z);

                        if (!Game.World.MapGenerator.Exists(BlockAt / Sector.Size)) {
                            Game.World.MapGenerator.GenerateSector(BlockAt / Sector.Size);
                        }

                        Block Value = Realm.GetBlock(BlockAt);
                        if (Value != null) {
                            Message.Write(true);
                            Value.Write(Message);
                        } else {
                            Message.Write(false);
                        }
                    }
                }
            }
        }

 public void Encode(NetOutgoingMessage om)
 {
     om.Write(this.MessageTime);
     om.Write(this.Id);
     om.Write(this.EquipmentPosition);
     om.Write(this.InventoryPosition);
 }

 internal override NetSendResult Enqueue(NetOutgoingMessage message)
 {
     m_queuedSends.Enqueue(message);
     if (m_queuedSends.Count <= GetAllowedSends())
         return NetSendResult.Sent;
     return NetSendResult.Queued;
 }

 public void Encode(NetOutgoingMessage om)
 {
     om.Write((int) Value);
        om.Write(Text);
        om.Write(Row);
        om.Write(Col);
 }

        /// <summary>
        /// Send a message to a specific connection
        /// </summary>
        /// <param name="msg">The message to send</param>
        /// <param name="recipient">The recipient connection</param>
        /// <param name="method">How to deliver the message</param>
        /// <param name="sequenceChannel">Sequence channel within the delivery method</param>
        public NetSendResult SendMessage(NetOutgoingMessage msg, NetConnection recipient, NetDeliveryMethod method, int sequenceChannel)
        {
            if (msg == null)
                throw new ArgumentNullException("msg");
            if (recipient == null)
                throw new ArgumentNullException("recipient");
            if (sequenceChannel >= NetConstants.NetChannelsPerDeliveryMethod)
                throw new ArgumentOutOfRangeException("sequenceChannel");

            NetException.Assert(
                ((method != NetDeliveryMethod.Unreliable && method != NetDeliveryMethod.ReliableUnordered) ||
                ((method == NetDeliveryMethod.Unreliable || method == NetDeliveryMethod.ReliableUnordered) && sequenceChannel == 0)),
                "Delivery method " + method + " cannot use sequence channels other than 0!"
            );

            NetException.Assert(method != NetDeliveryMethod.Unknown, "Bad delivery method!");

            if (msg.m_isSent)
                throw new NetException("This message has already been sent! Use NetPeer.SendMessage() to send to multiple recipients efficiently");
            msg.m_isSent = true;

            int len = NetConstants.UnfragmentedMessageHeaderSize + msg.LengthBytes; // headers + length, faster than calling msg.GetEncodedSize
            if (len <= recipient.m_currentMTU)
            {
                Interlocked.Increment(ref msg.m_recyclingCount);
                return recipient.EnqueueMessage(msg, method, sequenceChannel);
            }
            else
            {
                // message must be fragmented!
                SendFragmentedMessage(msg, new NetConnection[] { recipient }, method, sequenceChannel);
                return NetSendResult.Queued; // could be different for each connection; Queued is "most true"
            }
        }

 private void SerializeStream(NetOutgoingMessage netOutgoingMessage)
 {
     //send our position to the server
     //this should only be happening on an object that is ours
     _serializer.vector3 = transform.position;
     _serializer.OnSerialize(netOutgoingMessage);
 }

 public override void SendMessage(NetOutgoingMessage message)
 {
     for (int i = 0; i < connections.Count; ++i)
     {
         SendMessage(message, connections[i]);
     }
 }

 protected override void WriteData(NetOutgoingMessage Message)
 {
     texture.Write(Message);
     byte[] data = GetBytes(texture.Texture);
     Message.Write((Int32)data.Length);
     Message.Write(data);
 }

 public void Encode(NetOutgoingMessage om)
 {
     om.Write(this.Id);
     om.Write(this.MessageTime);
     om.Write(this.Health);
     om.Write(this.MaxHealth);
 }

 public void W(NetOutgoingMessage om)
 {
     om.Write(Uid);
     om.Write(X);
     om.Write(Y);
     om.Write(SpriteId);
 }

		// on user thread
		private NetSendResult SendFragmentedMessage(NetOutgoingMessage msg, IList<NetConnection> recipients, NetDeliveryMethod method, int sequenceChannel)
		{
			// Note: this group id is PER SENDING/NetPeer; ie. same id is sent to all recipients;
			// this should be ok however; as long as recipients differentiate between same id but different sender
			int group = Interlocked.Increment(ref m_lastUsedFragmentGroup);
			if (group >= NetConstants.MaxFragmentationGroups)
			{
				// @TODO: not thread safe; but in practice probably not an issue
				m_lastUsedFragmentGroup = 1;
				group = 1;
			}
			msg.m_fragmentGroup = group;

			// do not send msg; but set fragmentgroup in case user tries to recycle it immediately

			// create fragmentation specifics
			int totalBytes = msg.LengthBytes;

			// determine minimum mtu for all recipients
			int mtu = GetMTU(recipients);
			int bytesPerChunk = NetFragmentationHelper.GetBestChunkSize(group, totalBytes, mtu);

			int numChunks = totalBytes / bytesPerChunk;
			if (numChunks * bytesPerChunk < totalBytes)
				numChunks++;

			NetSendResult retval = NetSendResult.Sent;

			int bitsPerChunk = bytesPerChunk * 8;
			int bitsLeft = msg.LengthBits;
			for (int i = 0; i < numChunks; i++)
			{
				NetOutgoingMessage chunk = CreateMessage(0);

				chunk.m_bitLength = (bitsLeft > bitsPerChunk ? bitsPerChunk : bitsLeft);
				chunk.m_data = msg.m_data;
				chunk.m_fragmentGroup = group;
				chunk.m_fragmentGroupTotalBits = totalBytes * 8;
				chunk.m_fragmentChunkByteSize = bytesPerChunk;
				chunk.m_fragmentChunkNumber = i;

				NetException.Assert(chunk.m_bitLength != 0);
				NetException.Assert(chunk.GetEncodedSize() < mtu);

				Interlocked.Add(ref chunk.m_recyclingCount, recipients.Count);

				foreach (NetConnection recipient in recipients)
				{
					var res = recipient.EnqueueMessage(chunk, method, sequenceChannel);
					if (res == NetSendResult.Dropped)
						Interlocked.Decrement(ref chunk.m_recyclingCount);
					if ((int)res > (int)retval)
						retval = res; // return "worst" result
				}

				bitsLeft -= bitsPerChunk;
			}

			return retval;
		}

 public void SendMessage(NetOutgoingMessage msg)
 {
     if (InnerClient.Status == NetPeerStatus.Running)
     {
         InnerClient.SendMessage(msg, NetDeliveryMethod.Unreliable);
     }
 }

 public void WriteType(NetOutgoingMessage Message, AttributeTypeID Type, object Data)
 {
     switch (Type) {
         case AttributeTypeID.Float:
             Message.Write((float)Data);
             break;
         case AttributeTypeID.Int:
             Message.Write((int)Data);
             break;
         case AttributeTypeID.List:
             Console.WriteLine("Engine unable to serialize list objects");
             break;
         case AttributeTypeID.Long:
             Message.Write((long)Data);
             break;
         case AttributeTypeID.Rectangle:
             Message.WriteRectangle((Rectangle)Data);
             break;
         case AttributeTypeID.String:
             Message.Write((string)Data);
             break;
         case AttributeTypeID.Vector2:
             Message.WriteVector2((Vector2)Data);
             break;
         case AttributeTypeID.Bool:
             Message.Write((bool)Data);
             break;
         default:
             Console.WriteLine("AttributeSystem Unrecognised Type In AttributeSystem Type: {0}", Type.ToString());
             break;
     }
 }

        public static OutgoingMessage CreateOutgoingMessage(int opcode, byte[] data, NetOutgoingMessage packet)
        {
            OutgoingMessage com = CreateOutgoingMessage(opcode, data);
            com.EncodeTo(packet);

            return com;
        }

 public void Encode(NetOutgoingMessage om)
 {
     om.Write(Shots);
        om.Write(Hits);
        om.Write(Misses);
        om.Write(ShipsKilled);
 }

 /// <summary>
 /// write to the message
 /// </summary>
 /// <param name="message">message to write to</param>
 public void OnSerialize(NetOutgoingMessage message)
 {
     message.Write(X);
     message.Write(Y);
     message.Write(Z);
     message.Write(W);
 }

 public override void Write(NetOutgoingMessage msg)
 {
     msg.Write(Id);
     msg.Write(Cards.Count);
     foreach(string value in Cards)
         msg.Write(value);
 }

 public void Encode(NetOutgoingMessage om)
 {
     om.Write(this.BlockID);
     om.Write(this.X);
     om.Write(this.Y);
     om.Write(this.Z);
 }

 /// <summary>
 /// write all the serializing objects to the stream
 /// </summary>
 /// <param name="msg"></param>
 /// <param name="towrite"></param>
 public static void WriteParams(ref NetOutgoingMessage msg, INetSerializable[] towrite)
 {
     foreach (var arg in towrite)
     {
         arg.OnSerialize(msg);
     }
 }

        /// <summary>
        /// Converts the packet into an outgoing packet
        /// </summary>
        /// <returns>Returns the specified IPacket as a packet</returns>
        public virtual NetOutgoingMessage ToNetBuffer(ref NetOutgoingMessage netOutgoingMessage)
        {
            //TODO: Find a way to write the packet header given the HashCode of the class name...
            netOutgoingMessage.Write(GlobalPacketMap.PacketCache[GetType()]);

            return null;
        }