public static void Write(PacketDirection dir, byte[] data)
        {
            if (Config.PacketLog.Enable)
            {
                string header = "";

                switch (dir)
                {
                    case PacketDirection.ServerToPhoenix:
                        if (!Config.PacketLog.ServerToPhoenix) return;
                        header = "Server->Phoenix";
                        break;

                    case PacketDirection.PhoenixToServer:
                        if (!Config.PacketLog.PhoenixToServer) return;
                        header = "Phoenix->Server";
                        break;

                    case PacketDirection.ClientToPhoenix:
                        if (!Config.PacketLog.ClientToPhoenix) return;
                        header = "Client->Phoenix";
                        break;

                    case PacketDirection.PhoenixToClient:
                        if (!Config.PacketLog.PhoenixToClient) return;
                        header = "Phoenix->Client";
                        break;
                }

                string packet = BuildString(data).Trim().Replace(Environment.NewLine, "\n").Replace("\n", Environment.NewLine);

                Trace.WriteLine(packet, header);
            }
        }

        override public IdentificationStatus Identify(int OpCode, int Size, PacketDirection Direction)
        {
            if((OpCode == OpManager.OpCodeNameToNumber("OP_ZoneEntry")) && (Direction == PacketDirection.ClientToServer))
                return IdentificationStatus.Yes;

            return IdentificationStatus.No;
        }

 public PacketAttribute(string name, PacketDirection direction, SessionType sessionType = SessionType.None, bool authRequired = true)
 {
     Name         = name;
     Direction    = direction;
     SessionType  = sessionType;
     AuthRequired = authRequired;
 }

 public Packet(uint Opcode, PacketDirection Direction, byte[] Data, DateTime Time)
 {
     this.Opcode = Opcode;
     this.Direction = Direction;
     this.Data = Data;
     this.Time = Time;
 }

 public PackerHandlerAttribute(PacketHeader methodId, string name, int size, PacketDirection direction)
 {
     this.MethodId = (ushort)methodId;
     this.Name = name;
     this.Size = size;
     this.Direction = direction;
 }

        public override void ExploreItemPacket(StreamWriter outputStream, ByteStream buffer, PacketDirection direction)
        {
            buffer.SkipBytes(4);    // Skip type field.

            ExploreSubItem(outputStream, ref buffer);

            outputStream.WriteLine("");
        }

        public void ExploreItemPacket(StreamWriter OutputStream, ByteStream Buffer, PacketDirection Direction)
        {
            Buffer.SkipBytes(4);    // Skip type field.

            ExploreSubItem(OutputStream, ref Buffer);

            OutputStream.WriteLine("");
        }

        public void ExploreNPCMoveUpdate(StreamWriter OutputStream, ByteStream Buffer, PacketDirection Direction)
        {
            PositionUpdate PosUpdate;

            PosUpdate = Decode_OP_NPCMoveUpdate(Buffer.Buffer);

            OutputStream.WriteLine("SpawnID: {0}, X = {1}, Y = {2}, Z = {3}, Heading = {4}", PosUpdate.SpawnID, PosUpdate.p.x, PosUpdate.p.y, PosUpdate.p.z, PosUpdate.p.heading);
        }

 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 TORCapturedPacket(int id, TORPacketType type, byte[] data, CaptureSession session, PacketDirection direction)
 {
     _id = id;
     _type = type;
     _data = data;
     _session = session;
     _direction = direction;
 }

 public IPPacket(int index,
                 UInt32 resourceId,
                 PacketDirection direction,
                 IPEndPoint localEndpoint,
                 IPEndPoint remoteEndpoint,
                 byte[] bytes)
 {
     Initialize(index, DateTime.Now, resourceId, direction, localEndpoint, remoteEndpoint, bytes);
 }

        public override void ExploreCastSpell(StreamWriter outputStream, ByteStream buffer, PacketDirection direction)
        {
            UInt32 Slot = buffer.ReadUInt32();
            UInt32 SpellID = buffer.ReadUInt32();

            outputStream.WriteLine("Casting spell {0} from slot {1}", SpellID, Slot);

            outputStream.WriteLine("");
        }

        public PacketViewModel Create(PacketDirection packetDirection, byte[] packet)
        {
            Contract.Requires<ArgumentNullException>(packet != null);
            Contract.Requires<ArgumentNullException>(packet.Length >= 16);
            Contract.Ensures(Contract.Result<PacketViewModel>() != null);

            var packetType = this.packetInspectorService.FindType(packet);
            return new PacketViewModel(packetDirection, packet, packetType);
        }

        public void ExploreCastSpell(StreamWriter OutputStream, ByteStream Buffer, PacketDirection Direction)
        {
            UInt32 Slot = Buffer.ReadUInt32();
            UInt32 SpellID = Buffer.ReadUInt32();

            OutputStream.WriteLine("Casting spell {0} from slot {1}", SpellID, Slot);

            OutputStream.WriteLine("");
        }

        public PacketViewModel(PacketDirection packetDirection, byte[] packet, Type packetType)
        {
            Contract.Requires<ArgumentNullException>(packet != null);
            Contract.Requires<ArgumentNullException>(packet.Length >= 16);

            this.packetDirection = packetDirection;
            this.packet = packet;
            this.packetType = packetType;
            this.timeStamp = DateTime.Now;
        }

        public override IdentificationStatus Identify(int OpCode, int Size, PacketDirection Direction)
        {
            if ((OpCode == OpManager.OpCodeNameToNumber("OP_ZoneEntry")) && (Direction == PacketDirection.ClientToServer))
                return IdentificationStatus.Tentative;

            if ((OpCode == OpManager.OpCodeNameToNumber("OP_SendAATable")) && (Direction == PacketDirection.ServerToClient) &&
                (Size == 120))
                return IdentificationStatus.Yes;

            return IdentificationStatus.No;
        }

        override public IdentificationStatus Identify(int OpCode, int Size, PacketDirection Direction)
        {
            if ((OpCode == OpManager.OpCodeNameToNumber("OP_ZoneEntry")) && (Direction == PacketDirection.ClientToServer))
                return IdentificationStatus.Tentative;

            if ((OpCode == OpManager.OpCodeNameToNumber("OP_PlayerProfile")) && (Direction == PacketDirection.ServerToClient) &&
                (Size == ExpectedPPLength))
                return IdentificationStatus.Yes;

            return IdentificationStatus.No;
        }

        public static string LogPacket(IPacket packet, PacketDirection direction)
        {
            var memory = new MemoryStream();
            var stream = new StreamWriter(memory);
            var type = packet.GetType();
            var fields = type.GetFields();
            // Log time, direction, name
            stream.Write(DateTime.Now.ToString("{hh:mm:ss.fff} "));
            if (direction == PacketDirection.Serverbound)
                stream.Write("[CLIENT->SERVER] ");
            else
                stream.Write("[SERVER->CLIENT] ");
            stream.Write(FormatPacketName(type.Name));
            stream.WriteLine();

            // Log fields
            foreach (var field in fields)
            {
                var name = field.Name;
                if (field.Name == "PacketId")
                    continue;
                name = AddSpaces(name);
                var fValue = field.GetValue(packet);

                if (!(fValue is Array))
                    stream.Write(string.Format(" {0} ({1})", name, field.FieldType.Name));
                else
                {
                    var array = fValue as Array;
                    stream.Write(string.Format(" {0} ({1}[{2}])", name,
                        array.GetType().GetElementType().Name, array.Length));
                }

                if (fValue is byte[])
                    stream.Write(": " + DumpArray(fValue as byte[]) + "\n");
                else if (fValue is Array)
                {
                    stream.Write(": ");
                    var array = fValue as Array;
                    foreach (var item in array)
                        stream.Write(string.Format("{0}, ", item.ToString()));
                    stream.WriteLine();
                }
                else if (fValue is string)
                    stream.Write(": \"" + fValue + "\"\n");
                else
                    stream.Write(": " + fValue + "\n");
            }
            stream.WriteLine();
            stream.Flush();
            return Encoding.UTF8.GetString(memory.GetBuffer().Take((int)memory.Length).ToArray());
        }

        public override void ExploreItemPacket(StreamWriter outputStream, ByteStream buffer, PacketDirection direction)
        {
            UInt32 StackSize = buffer.ReadUInt32();
            buffer.SkipBytes(4);
            UInt32 Slot = buffer.ReadUInt32();
            UInt32 MerchantSlot = buffer.ReadUInt32();
            UInt32 Price = buffer.ReadUInt32();
            Int32 Quantity = buffer.ReadInt32();
            buffer.SetPosition(68);
            string Name = buffer.ReadString(true);

            outputStream.WriteLine("Item: {0} at Slot: {1}", Name, Slot);
        }