public NetworkPacket(Hash publicKey_Src, PacketType type, byte[] Data, Hash token)
 {
     PublicKeySource = publicKey_Src;
     Type = type;
     this.Data = Data;
     Token = token;
 }

 public OutPacket(PacketType type)
     : base(type)
 {
     writer = new StreamWriter(stream);
     Write((ushort)0); // Will be replaced w/ length later. (Will be content size).
     Write((ushort)Id); // Writes the id to the packet.
 }

 public static void Write(this Buffer buffer, PacketType type, byte[] data)
 {
     buffer.Reset(0);
     buffer.WriteByte((byte)type);
     buffer.WriteBytes(data);
     buffer.WriteSum();
 }

 public EventData(PacketType packetType, PluginHandle target, BotEventHandler eventHandler, BotEventHandlerAttribute attribute)
 {
     Target = target;
     PacketType = packetType;
     EventHandler = eventHandler;
     Attribute = attribute;
 }

 public SystemEventPacket(EventType eventType, string message, Connection client = null)
 {
     Client = client;
     packetType = PacketType.system;
     this.eventType = eventType;
     this.message = message;
 }

        /// <summary>
        /// Fire the events registered for this packet type asynchronously
        /// </summary>
        /// <param name="packetType">Incoming packet type</param>
        /// <param name="packet">Incoming packet</param>
        /// <param name="agent">Agent this packet was received from</param>
        internal void BeginRaiseEvent(PacketType packetType, Packet packet, Agent agent)
        {
            UDPServer.PacketCallback callback;
            PacketCallbackWrapper wrapper;

            // Default handler first, if one exists
            if (_EventTable.TryGetValue(PacketType.Default, out callback))
            {
                if (callback != null)
                {
                    wrapper.Callback = callback;
                    wrapper.Packet = packet;
                    wrapper.Agent = agent;
                    ThreadPool.QueueUserWorkItem(_ThreadPoolCallback, wrapper);
                }
            }

            if (_EventTable.TryGetValue(packetType, out callback))
            {
                if (callback != null)
                {
                    wrapper.Callback = callback;
                    wrapper.Packet = packet;
                    wrapper.Agent = agent;
                    ThreadPool.QueueUserWorkItem(_ThreadPoolCallback, wrapper);

                    return;
                }
            }

            if (packetType != PacketType.Default && packetType != PacketType.PacketAck)
            {
                Logger.DebugLog("No handler registered for packet event " + packetType);
            }
        }

        public PacketOut(RealmOp op)
        {
            type = PacketType.RealmPacket;

            Write((UInt16) 0); //size
            Write((UInt16) op); //op
        }

 public Packet(PacketType type, int length)
 {
     Length = length;
     Type = type;
     _Writer = PacketWriter.CreateInstance(length);
     _Writer.Write((byte)Type);
 }

 public void OnCreativeInventoryAction(ref PacketReader _pReader, PacketType pt, ref ClientManager _client)
 {
     short slot = _pReader.ReadShort();
     short item_id = _pReader.ReadShort();
     short Quanity = _pReader.ReadShort();
     short Damage = _pReader.ReadShort();
 }

        public void DeCrypt(ref byte[] raw, int lenght, int offset, PacketType type)
        {
            Logincrypt crypt;
            if (type == PacketType.ClientToLoginserver)
            {
                crypt = this.clientCrypt;
            }
            else if (type == PacketType.LoginserverToClient)
            {
                crypt = this.serverCrypt;
            }
            else
            {
                throw new Exception("Wrong PacketType "
                    + type.ToString() + " for " + this.ToString());
            }

            if (this.staticCrypt)
            {
                crypt.staticDecrypt(ref raw, offset, lenght);
                this.staticCrypt = false;
                if (raw[0 + offset] == 0x00)
                {
                    Console.WriteLine("Got Initpacket");
                    handleInit(new Bytebuffer(raw));
                }
            }
            else
            {
                crypt.decrypt(ref raw, offset, lenght);
            }
        }

        public void EnCrypt(ref byte[] raw, int lenght, int offset, PacketType type)
        {
            Logincrypt crypt;
            if (type == PacketType.ClientToLoginserver)
            {
                crypt = this.clientCrypt;
            }
            else if (type == PacketType.LoginserverToClient)
            {
                crypt = this.serverCrypt;
            }
            else
            {
                throw new Exception("Wrong PacketType "
                    + type.ToString() + " for " + this.ToString());
            }

            if (this.staticCrypt)
            {
                crypt.staticEncrypt(ref raw, offset, lenght, (uint)new Random().Next());
                enableCrypt();
            }
            else
            {
                crypt.encrypt(ref raw, offset, lenght);
            }
        }

 protected PacketHandler(PacketType packetType, string sender, List<string> recipients, object data)
 {
     PacketType = packetType;
     Sender = sender;
     Recipients = recipients;
     Data = data;
 }

        public void Deserialize(byte[] Data)
        {
            List<ProtocolDataType> PDTs = ProtocolPackager.UnPackRaw(Data);
            int cnt = 0;

            while (cnt < (int)PDTs.Count)
            {
                ProtocolDataType PDT = PDTs[cnt++];

                switch (PDT.NameType)
                {
                    case 0:
                        ProtocolPackager.UnpackHash(PDT, 0, out PublicKeySource);
                        break;

                    case 1:
                        byte _type = (byte) PacketType.TPT_NOTHING;
                        ProtocolPackager.UnpackByte(PDT, 1, ref _type);
                        Type = (PacketType)_type;
                        break;

                    case 2:
                        ProtocolPackager.UnpackByteVector(PDT, 2, ref this.Data);
                        break;

                    case 3:
                        ProtocolPackager.UnpackHash(PDT, 3, out Token);
                        break;
                }
            }
        }

 public int GetPacketsReceivedFor(PacketType packetType)
 {
     if (m_packetsReceived.ContainsKey(packetType))
         return m_packetsReceived[packetType];
     else
         return 0;
 }

        public void AddPacketHandler(PacketType packetType, Action<PacketReceivedEventArgs> handler)
        {
            if (!_packetHandlers.ContainsKey(packetType))
                _packetHandlers.Add(packetType, new List<Action<PacketReceivedEventArgs>>());

            _packetHandlers[packetType].Add(handler);
        }

 public ServerOperationEventArgs(int SenderID, PacketType PacketType, byte[] Data)
     : base()
 {
     this.senderID = SenderID;
     this.packetType = PacketType;
     this.data = Data;
 }

 public NoPayloadPacket(PacketType type)
     : base(type)
 {
     packetBytes = new byte[3];
     packetBytes[0] = (byte)((int)Type);
     AppendChecksum(packetBytes);
 }

 public void OnDisconnect(ref PacketReader _pReader, PacketType pt, ref ClientManager _client)
 {
     GridServer.player_list[_client.id]._client.Close();
     GridServer.player_list[_client.id]._stream.Close();
     GridServer.player_list[_client.id] = null;
     _client.Stop(true);
 }

 /// <summary>
 /// Default constructor
 /// </summary>
 /// <param name="agent">Reference to the client this packet is destined for</param>
 /// <param name="buffer">Serialized packet data. If the flags or sequence number
 /// need to be updated, they will be injected directly into this binary buffer</param>
 /// <param name="category">Throttling category for this packet</param>
 /// <param name="type">Packet type</param>
 public OutgoingPacket(LLAgent agent, UDPPacketBuffer buffer, ThrottleCategory category, PacketType type)
 {
     Agent = agent;
     Buffer = buffer;
     Category = category;
     Type = type;
 }

 public ClientPacketHandler(PacketType type, int length, int minimumLength, OnPacketReceive onReceive)
 {
     _packetId = type;
     _length = length;
     _minimumLength = minimumLength;
     _onReceive = onReceive;
 }