public static void RegisterHandler(PacketId packetId, PacketHandler handler)
        {
            if (packetHandlers.ContainsKey(packetId))
                throw new Exception("Duplicate packet handler");

            packetHandlers[packetId] = handler;
        }

 public MinecraftClient(Session session)
 {
     Session = session;
     PacketQueue = new ConcurrentQueue<IPacket>();
     PacketHandlers = new PacketHandler[256];
     Handlers.PacketHandlers.Register(this);
 }

        public static void Initialize()
        {
            m_LHandlers = new PacketHandler<LoginConnection>[0x20];
            levels = new Dictionary<int, PacketHandler<ClientConnection>[]>();

            RegisterDelegates();
        }

        public PacketHandler OnBlockChange(PacketType p_type, string CustomPacketType, ref PacketReader _pReader, PacketHandler packet, ref ClientManager _client)
        {
            PlayerBlockPlacementPacket _p = (PlayerBlockPlacementPacket)packet;
            BlockChangePacket block_change = new BlockChangePacket(PacketType.BlockChange);
            block_change.Metadata = Utils.GetMetadata(_p.BlockID.s_short, _p.Direction, _client.id);
            //block_change.Metadata = 0x00;
            int X = _p.X;
            byte Y = _p.Y;
            int Z = _p.Z;
            int index = 0;
            int temp = (_p.Direction == 0 ? Y-- :
                (_p.Direction == 1 ? Y++ :
                (_p.Direction == 2 ? Z-- :
                (_p.Direction == 3 ? Z++ :
                (_p.Direction == 4 ? X-- : X++)))));

            if (_p.BlockID.s_short > 255)
            {
                //SendBlockChange(block_change, ref _client, ref _pReader, _p, true);

            }
            else//This is a item ID
            {
                SendBlockChange(block_change, ref _client, ref _pReader, _p, true);
            }
            return block_change;
        }

        public static void Initialize()
        {
            m_GHandlers = new PacketHandler<GameConnection>[0x20];
            m_LHandlers = new PacketHandler<ArcheAgeConnection>[0x30];

            Registration();
        }

		/// <summary>
		/// Constructor
		/// </summary>
		public Server()
		{
            m_disposed = false;
            m_handler = PacketHandler.Instatinate();
            m_thread = new Thread(new ThreadStart(AcceptThread));
            m_thread.Name = "UOExt server thread";
            m_thread.Start();
		}

		public static void Configure()
		{
			m_Real6C = PacketHandlers.GetHandler( 0x6C );
			m_LastTarget = new Hashtable();

			PacketHandlers.Register( 0x6C, 19, true, new OnPacketReceive( TargetResponse ) );
			EventSink.Disconnected += new DisconnectedEventHandler( EventSink_Disconnected );
		}

 public ReliableUDPConnection(UdpClient sender, IPEndPoint destinationep, UInt32 cid, Connection owner)
 {
     DestinationEP = destinationep;
     ConnectionID = cid;
     Sender = sender;
     Sent = new Dictionary<UInt32,UDPPacket>();
     Owner = owner;
     Received = new HashSet<UInt32>();
     OnPacketRecv += new PacketHandler(RegisterPacket);
     OnPacketRecv += new PacketHandler(OnPacket);
 }

        public BidirectionalStream(NetworkReader from, NetworkWriter to, PacketHandler packetHandler)
        {
            reader = from;
            writer = to;

            handler = packetHandler;

            var rStart = new ThreadStart(Run);
            readerThread = new Thread(rStart);
            readerThread.Start();
        }

        public Program()
        {
            try
            {
                _handler = new PacketHandler("127.0.0.1", 25565, HandlerMode.Client);
            }
            catch (SocketException e)
            {
                Console.WriteLine(e.Message);
                Console.ReadKey();
                Environment.Exit(1);
            }

            _loginResponse = Login();

            // Subscribe packets
            _handler.Subscribe(Packet.Handshake, ShakeHands);

            _handler.Subscribe(Packet.Login, p =>
                                                 {
                                                     var packet = (LoginResponse) p;
                                                     Console.WriteLine("Entity ID: " + packet.EntityId);
                                                     Console.WriteLine("Map seed: " + packet.MapSeed);
                                                 });

            _handler.UnsubscribedPacket += p => { };
            _handler.Subscribe(Packet.Disconnect, p =>
                                                      {
                                                          Console.Write("You were kicked: " + ((Disconnect) p).Reason);
                                                          _handler.Disconnect();
                                                      });

            _handler.Subscribe(Packet.ChatMessage, p => Console.WriteLine(((ChatMessage)p).Message));
            _handler.EventMode = true;

            // START ACTION

            // This starts the server joining chain of packets
            _handler.SendPacket(new Handshake { Username = _username });

            while (_handler.IsActive)
            {
                var line = Console.ReadLine();
                if (line == "exit")
                {
                    _handler.SendPacket(new Disconnect {Reason = "This is ignored anyways, so eh"});

                    _handler.Disconnect();
                    break;
                }

                _handler.SendPacket(new ChatMessage { Message = line });
            }
        }

 public MinecraftServer()
 {
     LogicHelpers.Register();
     PacketHandlers = new PacketHandler[256];
     Handlers.PacketHandlers.RegisterHandlers(this);
     NetworkLock = new object();
     Clients = new List<RemoteClient>();
     Settings = ServerSettings.DefaultSettings;
     EntityManager = new EntityManager(this);
     LastTimeUpdate = DateTime.MinValue;
     NextChunkUpdate = DateTime.MinValue;
     PhysicsEngines = new List<PhysicsEngine>();
 }

            public bool RegisterHandler(UInt32 id, PacketHandler handler)
            {
                if (true == FHandlers.ContainsKey(id))
                {

                    return false;

                }

                FHandlers[id] = handler;

                return true;
            }

 //NO LONGER NEEDED.
 public PacketHandler OnSpwanPositionHandler(PacketType p_type, string CustomPacketType, ref PacketReader _pReader, PacketHandler _p, ref ClientManager cm)
 {
     SpawnPlayerPacket p = new SpawnPlayerPacket(PacketType.SpwanPosition);
     p.X = cm._player.position.X;
     p.Y = cm._player.position.Z;
     p.Z = cm._player.position.Y;
     p.BuildPacket();
     cm.SendPacket(p, cm.id, ref cm, false, false);
     int i = 0;
     for (; i < base.ModuleAddons.Count; i++)
     {
         base.ModuleAddons.ElementAt(i).Value(PacketType.SpwanPosition, ModuleAddons.ElementAt(i).Key, ref _pReader, (PacketHandler)p, ref cm);
     }
     p = null;
     return _p;
 }

        internal static void RegisterHandlers(object source, ConnectionEventArgs args)
        {
            PacketHandler PRequestSubscriptionData = new PacketHandler(Process_RequestSubscriptionData);
            //PacketHandler P = new PacketHandler(Process_);
            //PacketHandler P = new PacketHandler(Process_);
            //PacketHandler P = new PacketHandler(Process_);
            //PacketHandler P = new PacketHandler(Process_);
            //PacketHandler P = new PacketHandler(Process_);
            //PacketHandler P = new PacketHandler(Process_);

            (source as IonTcpConnection).
                AddHandler(26, PacketHandlerPriority.DefaultAction, PRequestSubscriptionData);
                //AddHandler(, PacketHandlerPriority.DefaultAction, ).
                //AddHandler(, PacketHandlerPriority.DefaultAction, ).
                //AddHandler(, PacketHandlerPriority.DefaultAction, ).
                //AddHandler(, PacketHandlerPriority.DefaultAction, ).
                //AddHandler(, PacketHandlerPriority.DefaultAction, )
        }

        public static void Initialize()
        {
            m_Target = PacketHandlers.GetHandler(0x6C);
            m_Target6017 = PacketHandlers.Get6017Handler(0x6C);

            m_Equip = PacketHandlers.GetHandler(0x13);
            m_Equip6017 = PacketHandlers.Get6017Handler(0x13);

            if (m_Target6017 == null)
                m_Target6017 = m_Target;

            if (m_Equip6017 == null)
                m_Equip6017 = m_Equip;

            PacketHandlers.Register(0x6C, 19, true, new OnPacketReceive(TargetResponse));
            PacketHandlers.Register6017(0x6C, 19, true, new OnPacketReceive(TargetResponse6017));
            PacketHandlers.Register(0x13, 10, true, new OnPacketReceive(EquipReq));
            PacketHandlers.Register6017(0x13, 10, true, new OnPacketReceive(EquipReq6017));
        }

        internal void PAGE_Add(HttpListenerContext Context)
        {
            if (Context.Request.IsLocal)
            {
                string Header = Context.Request.QueryString["header"];

                uint HeaderID = 0;

                if (!uint.TryParse(Header, out HeaderID))
                    HeaderID = Base64Encoding.DecodeUInt32(Encoding.UTF8.GetBytes(Header));

                PacketHandler Handler = new PacketHandler(Process_DYNAMIC);
                lock(this.fHandlers)
                    fHandlers.Add(HeaderID, Handler);
                RegisterHandlersToExisting(HeaderID, Handler);

                Context.Response.Redirect("addform");
                Context.Response.Close();
            }
        }

        /// <summary>Constructor</summary>
        /// <param name="client">Client socket with connected client</param>
        /// <param name="ip">Client ip</param>
        /// <param name="port">Server port</param>
        public Peer(Socket client, Server server, PacketHandler handler)
        {
            m_disposed = false;
            m_socket = client;
            m_server = server;
            m_buffer = new byte[65536 * 2];
            m_sendBuffer = new byte[65536 * 2];
            m_bufferPointer = 0;
            m_handler = handler;
            m_connected = true;
            m_AsyncSend = new AsyncCallback(OnSend);
            m_AsyncRecive = new AsyncCallback(OnRecive);
            m_sending = false;
            m_chunkSended = new AutoResetEvent(false);

            m_socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReceiveBuffer, 65536 * 2); // this should be enough for every packet
            m_socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.SendBuffer, 65536 * 2);
            m_socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.DontLinger, 1);
            m_socket.SetSocketOption(SocketOptionLevel.Tcp, SocketOptionName.NoDelay, 1);

            BeginReceive();
        }

        public override void UOExtInitialize(PacketHandler hndlr)
        {
            m_libraryList = new LibraryList();
            m_pluginsList = new PluginsList();
            m_initComplete = new InitializationComplete();

            hndlr.RegisterPacketHandler(0x00, 0, new OnPacketRecive(UOExtPacket));

            for (short i = 0; i < Dll.Dlls.Length; i++)
            {
                Dll.Dlls[i].Header = new DllHeader(Dll.Dlls[i], i);
                uint offset = (uint)(Dll.Dlls[i].Header.DllSize);
                do
                {
                    DllContent dc = new DllContent(Dll.Dlls[i], offset);
                    offset += (uint)dc.DllChunkSize;
                    Dll.Dlls[i].Content.Enqueue(dc);
                } while (offset < Dll.Dlls[i].Size);
            }
            Dll.UOExt = new Dll(Config.UOExtPath, true);
            Dll.UOExtGUI = new Dll(Config.UOExtGUIPath, true);
        }

        public RemoteClient(IMultiplayerServer server, IPacketReader packetReader, PacketHandler[] packetHandlers, Socket connection)
        {
            LoadedChunks = new List<Coordinates2D>();
            Server = server;
            Inventory = new InventoryWindow(server.CraftingRepository);
            InventoryWindow.WindowChange += HandleWindowChange;
            SelectedSlot = InventoryWindow.HotbarIndex;
            CurrentWindow = InventoryWindow;
            ItemStaging = ItemStack.EmptyStack;
            KnownEntities = new List<IEntity>();
            Disconnected = false;
            EnableLogging = server.EnableClientLogging;
            NextWindowID = 1;
            Connection = connection;
            SocketPool = new SocketAsyncEventArgsPool(100, 200, 65536);
            PacketReader = packetReader;
            PacketHandlers = packetHandlers;

            cancel = new CancellationTokenSource();

            StartReceive();
        }

 public void RegisterPacketHandler( char packetcode, PacketHandler packethandler )
 {
     if( packethandlers.Contains( packetcode ) && (PacketHandler)packethandlers[ packetcode ] != packethandler )
     {
         throw new Exception( "Trying to register duplicate packetcode " + packetcode.ToString() + " by handler " + packethandler.ToString() + " conflicting handler: " + packethandlers[ packetcode ].ToString() );
     }
     if( !packethandlers.Contains( packetcode ) )
     {
         packethandlers.Add( packetcode, packethandler );
     }
 }