public static void HandleSetStatPoint(ZoneClient client, Packet packet)
        {
            byte stat;
            if (!packet.TryReadByte(out stat))
            {
                Log.WriteLine(LogLevel.Warn, "Couldn't read HandleSetStatPoint packet. {0}", client);
                return;
            }

            if (client.Character.Character.UsablePoints == 0)
            {
                Log.WriteLine(LogLevel.Warn, "User tried to set stat point while not having any left. {0}", client);
            }
            else
            {
                // LETS DO ET
                switch (stat)
                {
                    case 0: client.Character.Str++; break;
                    case 1: client.Character.Dex++; break;
                    case 2: client.Character.End++; break;
                    case 3: client.Character.Int++; break;
                    case 4: client.Character.Spr++; break;
                    default:
                        {
                            Log.WriteLine(LogLevel.Warn, "User tried to set stat point on unknown stat {0} {1}", stat, client);
                            return;
                        }
                }
                client.Character.Character.UsablePoints--;
                //Program.Entity.SaveChanges();
                SendSetUsablePoint(client, stat);
            }
        }

 public static void EquipHandler(ZoneClient client, Packet packet)
 {
     sbyte slot;
     if (!packet.TryReadSByte(out slot))
     {
         Log.WriteLine(LogLevel.Warn, "Error reading equipping slot.");
         return;
     }
     Item item;
     if (client.Character.InventoryItems.TryGetValue(slot, out item))
     {
         if (item is Equip)
         {
             if (((Equip)item).Info.Level > client.Character.Level)
             {
                 FailedEquip(client.Character, 645); // 85 02
             }
             else
             {
                 client.Character.EquipItem((Equip)item);
             }
         }
         else
         {
             FailedEquip(client.Character);
             Log.WriteLine(LogLevel.Warn, "{0} equippped an item. What a moron.", client.Character.Name);
         }
     }
 }

        public static void ClientReadyHandler(ZoneClient client, Packet packet)
        {
            if (client.Admin > 0)
            {
                client.Character.DropMessage("AdminLevel = {0}; ClientLoad = {1};", client.Admin, ClientManager.Instance.ZoneLoad);
            }

            Handler4.SendUsablePoints(client);

            if (!client.Character.IsDead)
            {
                // Just logged on.
                client.Character.Map.FinalizeAdd(client.Character);
            }
            else
            {
                // Reviving, not readding for this one!
                MapInfo mi;
                if (DataProvider.Instance.MapsByID.TryGetValue(client.Character.MapID, out mi))
                {
                    client.Character.State = PlayerState.Normal;
                    client.Character.Map.SendCharacterLeftMap(client.Character, false);
                    client.Character.Position.X = mi.RegenX;
                    client.Character.Position.Y = mi.RegenY;
                    client.Character.Map.SendCharacterEnteredMap(client.Character);
                }
                client.Character.SetHP(client.Character.MaxHP / 4);
            }
        }

        public static void TradeAgree(ZoneClient pClient, Packet pPacket)
        {
            if (pClient.Character.Trade == null)
                return;

            pClient.Character.Trade.AcceptTrade(pClient.Character);
        }

 public static void SendPing(ZoneClient character)
 {
     using (var packet = new Packet(SH2Type.Ping))
     {
         character.SendPacket(packet);
     }
 }

 public static void SendPartyMemberCordChange(ZoneClient client)
 {
     if (Program.Entity.Parties.Where(c => c.CharNo == client.Character.ID).Count() == 1)
     {
         Party PartyNo = Program.Entity.Parties.First(c => c.CharNo == client.Character.ID);
         foreach (Party party in Program.Entity.Parties.Where(c => c.PartyNo == PartyNo.PartyNo))
         {
             using (var ppacket = new Packet(SH14Type.PartyLoginCord))
             {
                 Character Pcharacter = Program.Entity.Characters.First(c => c.ID == party.CharNo);
                 ZoneClient otherLiveInfo = ClientManager.Instance.GetClientByName(Pcharacter.Name);
                 if (otherLiveInfo != null)
                 {
                     if (otherLiveInfo.Character.MapID == client.Character.MapID)
                     {
                         ppacket.WriteByte(1); //unk
                         ppacket.WriteString(client.Character.Name, 16);
                         ppacket.WriteInt(client.Character.Position.X);
                         ppacket.WriteInt(client.Character.Position.Y);
                         otherLiveInfo.SendPacket(ppacket);
                     }
                 }
             }
         }
     }
 }

 public static void TradeLock(ZoneClient pClient, Packet pPacket)
 {
     if (pClient.Character.Trade != null)
     {
         pClient.Character.Trade.TradeLock(pClient.Character);
     }
 }

 public void AddTradeRequest(ZoneClient pClient,ushort  MapObjectIDto)
 {
     Log.WriteLine(LogLevel.Debug, "{0} AddTradeReqest {1}", pClient.Character.Character.Name, MapObjectIDto);
        TradeReqest pRequest = new TradeReqest(pClient.Character, MapObjectIDto);
        this.TradeReqests.Add(pRequest);
        SendTradeRequest(pRequest);
 }

        public static void ClientReadyHandler(ZoneClient client, Packet packet)
        {
            Handler4.SendUsablePoints(client);

            if (!client.Character.IsDead)
            {
                // Just logged on.
                client.Character.Map.FinalizeAdd(client.Character);

                //Handler27.SendGameMessage(client.Character, "GAMEPLAY NOT FINAL :: WELCOME TO OSMO, " + client.Character.Name.ToUpper(), "Universal_2");
                Handler9.SendUpdateHP(client.Character);
                Handler9.SendUpdateSP(client.Character);

                if (client.Character.Job == Job.Crusader)
                {
                    Handler9.SendUpdateLP(client.Character);
                }

                Handler14.SendPartyInformation(client);
            }
            else
            {
                // Reviving, not readding for this one!
                MapInfo mi;
                if (DataProvider.Instance.MapsByID.TryGetValue(client.Character.MapID, out mi))
                {
                    client.Character.State = PlayerState.Normal;
                    client.Character.Map.SendCharacterLeftMap(client.Character, false);
                    client.Character.Position.X = mi.RegenX;
                    client.Character.Position.Y = mi.RegenY;
                    client.Character.Map.SendCharacterEnteredMap(client.Character);
                }
                client.Character.SetHP(client.Character.MaxHP / 4);
            }
        }

        public static void SelectObjectHandler(ZoneClient client, Packet packet)
        {
            ushort id;
            if (!packet.TryReadUShort(out id))
            {
                Log.WriteLine(LogLevel.Warn, "Could not read entity select request.");
                return;
            }

            MapObject mo;
            // Try to see if there is a map object with this ID
            if (!client.Character.Map.Objects.TryGetValue(id, out mo))
            {
                client.Character.CharacterInTarget = mo;
                return; // Nothing found. Just return lawl
            }

            mo.SelectedBy.Add(client.Character);

            if (mo is ZoneCharacter || mo is Mob)
            {
                client.Character.SelectedObject = mo;
                SendStatsUpdate(mo, client, false);
            }
        }

 public static void TradeReqest(ZoneClient pClient, Packet pPacket)
 {
     ushort MapObjectID;
     if (!pPacket.TryReadUShort(out MapObjectID))
         return;
     TradeManager.Instance.AddTradeRequest(pClient, MapObjectID);
 }

        public override void OnClientConnect(Socket socket)
        {
            ZoneClient client = new ZoneClient(socket);

             //  ClientManager.Instance.AddClient(client); //They register once authenticated now
            Log.WriteLine(LogLevel.Debug, "Client connected from {0}", client.Host);
               // ClientManager.Instance.AddClient(client); //They register once authenticated now
        }

        public static void TradeBreak(ZoneClient pClient, Packet pPacket)
        {
            if (pClient.Character.Trade == null)
                return;

            pClient.Character.Trade.TradeBreak(pClient.Character);
            pClient.Character.Trade = null;
        }

 public static void DeselectObjectHandler(ZoneClient client, Packet packet)
 {
     if (client.Character.SelectedObject != null)
     {
         client.Character.SelectedObject.SelectedBy.Remove(client.Character);
         client.Character.SelectedObject = null;
     }
 }

 public void RemoveReqest(ZoneClient pClient)
 {
     TradeReqest Request = TradeReqests.Find(r => r.MapID == pClient.Character.MapID && r.pToTradeClient.MapObjectID== pClient.Character.MapObjectID);
        if (TradeReqests.Contains(Request))
        {
        TradeReqests.Remove(Request);
        }
 }

 public static void SendError(ZoneClient client, ServerError error)
 {
     using (Packet pack = new Packet(SH3Type.Error))
     {
         pack.WriteShort((byte)error);
         client.SendPacket(pack);
     }
 }

 public static void BackTo(ZoneClient client, Packet packet)
 {
     using(var iacket = new InterPacket(InterHeader.ClientDisconect))
     {
         iacket.WriteString(client.Character.Character.Name, 16);
         InterServer.WorldConnector.Instance.SendPacket(iacket);
     }
 }

 public void AcceptTrade(ZoneClient pClient)
 {
     TradeReqest Request = GetTradeRquestByChar(pClient.Character);
     if (Request != null)
     {
     TradeReqests.Remove(Request);
     Trade pTrade = new Trade(Request.pFromTradeClient, pClient.Character);
     }
 }

 public static void SendTradeRequest(ZoneClient client, ushort ObjID)
 {
     using(var packet = new Packet(SH19Type.TradeRequest))
     {
         ZoneClient otherclient = ClientManager.Instance.GetClientByObj(ObjID);
         packet.WriteUShort(client.Character.MapObjectID);
         otherclient.SendPacket(packet);
     }
 }

 public static void TradeRemovitem(ZoneClient pClient, Packet pPacket)
 {
     byte pSlot;
     if (!pPacket.TryReadByte(out pSlot))
         return;
     if (pClient.Character.Trade == null)
         return;
     pClient.Character.Trade.RemoveItemToHandel(pClient.Character, pSlot);
 }