public Log(StreamWriter stream, ProxySettings settings)
 {
     Stream = stream;
     MemoryStream = new MemoryStream();
     MinecraftStream = new MinecraftStream(MemoryStream);
     Settings = settings;
 }

 public NetworkMode ReadPacket(MinecraftStream stream, NetworkMode mode, PacketDirection direction)
 {
     ProtocolVersion = stream.ReadVarInt();
     ServerHostname = stream.ReadString();
     ServerPort = stream.ReadUInt16();
     NextState = (NetworkMode)stream.ReadVarInt();
     return NextState;
 }

 public NetworkMode WritePacket(MinecraftStream stream, NetworkMode mode, PacketDirection direction)
 {
     stream.WriteVarInt(ProtocolVersion);
     stream.WriteString(ServerHostname);
     stream.WriteUInt16(ServerPort);
     stream.WriteVarInt((int)NextState);
     return NextState;
 }

 public void ReadPacket(MinecraftStream stream)
 {
     EntityId = stream.ReadInt32();
     LevelType = stream.ReadString();
     GameMode = (GameMode)stream.ReadUInt8();
     Dimension = (Dimension)stream.ReadInt8();
     Difficulty = (Difficulty)stream.ReadUInt8();
     Discarded = stream.ReadUInt8();
     MaxPlayers = stream.ReadUInt8();
 }

 public Proxy(NetworkStream client, NetworkStream server, Log log, ProxySettings settings)
 {
     Client = client;
     Server = server;
     Log = log;
     ClientStream = new MinecraftStream(new BufferedStream(Client));
     ServerStream = new MinecraftStream(new BufferedStream(Server));
     CryptoServiceProvider = new RSACryptoServiceProvider(1024);
     ServerKey = CryptoServiceProvider.ExportParameters(true);
     Settings = settings;
 }

 public void WritePacket(MinecraftStream stream)
 {
     stream.WriteUInt8(Id);
     stream.WriteInt32(EntityId);
     stream.WriteString(LevelType);
     stream.WriteUInt8((byte)GameMode);
     stream.WriteInt8((sbyte)Dimension);
     stream.WriteUInt8((byte)Difficulty);
     stream.WriteUInt8(Discarded);
     stream.WriteUInt8(MaxPlayers);
 }

 public override void MessageRecieved(RemoteClient client, byte[] data)
 {
     if (ServerPingReceived != null)
     {
         var stream = new MinecraftStream(new MemoryStream(data));
         var eventArgs = new ServerPingEventArgs(
             stream.ReadInt32(),
             stream.ReadString(),
             stream.ReadInt32());
         ServerPingReceived(this, eventArgs);
     }
 }

 public void Connect(IPEndPoint endPoint)
 {
     if (Client != null && Client.Connected)
         throw new InvalidOperationException("Already connected to a server!");
     EndPoint = endPoint;
     Client = new TcpClient();
     Client.Connect(EndPoint);
     NetworkStream = Client.GetStream();
     Stream = new MinecraftStream(new BufferedStream(NetworkStream));
     NetworkWorkerThread = new Thread(NetworkWorker);
     NetworkWorkerThread.Start();
     var handshake = new HandshakePacket(PacketReader.ProtocolVersion, Session.SelectedProfile.Name,
         EndPoint.Address.ToString(), EndPoint.Port);
     SendPacket(handshake);
 }

        public static MetadataDictionary FromStream(MinecraftStream stream)
        {
            var value = new MetadataDictionary();
            while (true)
            {
                byte key = stream.ReadUInt8();
                if (key == 127) break;

                byte type = (byte)((key & 0xE0) >> 5);
                byte index = (byte)(key & 0x1F);

                var entry = EntryTypes[type]();
                entry.FromStream(stream);
                entry.Index = index;

                value[index] = entry;
            }
            return value;
        }

 public override void WriteTo(MinecraftStream stream, byte index)
 {
     stream.WriteUInt8(GetKey(index));
     stream.WriteInt16(Value.Id);
     if (Value.Id != -1)
     {
         stream.WriteInt8(Value.Count);
         stream.WriteInt16(Value.Metadata);
         if (Value.Nbt != null)
         {
             var file = new NbtFile(Value.Nbt);
             var data = file.SaveToBuffer(NbtCompression.GZip);
             stream.WriteInt16((short)data.Length);
             stream.WriteUInt8Array(data);
         }
         else
             stream.WriteInt16(-1);
     }
 }

 public static ServerPing DoPing(IPEndPoint endPoint)
 {
     var client = new TcpClient();
     client.Connect(endPoint);
     var stream = new MinecraftStream(client.GetStream());
     var ping = new ServerListPingPacket();
     ping.WritePacket(stream);
     var response = PacketReader.ReadPacket(stream);
     client.Close();
     // TODO: Handle old pings
     var pong = (DisconnectPacket)response;
     var parts = pong.Reason.Substring(3).Split('\0');
     var result = new ServerPing();
     result.ProtocolVersion = int.Parse(parts[0]);
     result.ServerVersion = parts[1];
     result.MotD = parts[2];
     result.CurrentPlayers = int.Parse(parts[3]);
     result.MaxPlayers = int.Parse(parts[4]);
     return result;
 }

 public override void FromStream(MinecraftStream stream)
 {
     Value = stream.ReadInt32();
 }

 public override void FromStream(MinecraftStream stream)
 {
     Value = ItemStack.FromStream(stream);
 }

 public override void WriteTo(MinecraftStream stream, byte index)
 {
     stream.WriteUInt8(GetKey(index));
     stream.WriteInt32(Value);
 }