public void PopulateScreen(SocketClient Client)
{
foreach (SocketClient nC in Players.Values)
{
if (Calculations.GetDistance(nC.Character.X, nC.Character.Y, Client.Character.X, Client.Character.Y) <= Constants.ScreenDistance)
{
Client.Character.Screen.Insert(nC);
nC.Character.Screen.Insert(Client);
}
else
{
Client.Character.Screen.Remove(nC.UniqueID);
nC.Character.Screen.Remove(Client.UniqueID);
}
}
foreach (Entities.Monster Monster in Monsters.Values)
{
if (Monster.HitPoints > 0)
{
if (Calculations.GetDistance(Monster.X, Monster.Y, Client.Character.X, Client.Character.Y) <= Constants.ScreenDistance)
Client.Character.Screen.Insert(Monster);
else
Client.Character.Screen.Remove(Monster.UniqueID);
}
}
foreach (Entities.NPC Npc in NPCs.Values)
{
if (Calculations.GetDistance(Npc.X, Npc.Y, Client.Character.X, Client.Character.Y) <= Constants.ScreenDistance)
Client.Character.Screen.Insert(Npc);
else
Client.Character.Screen.Remove(Npc.UniqueID);
}
}
public static byte[] CharacterInfo(SocketClient Client)
{
int Length = 74 + 0 + Client.Character.Name.Length + 1;
Writer PWR = new Writer(Length);
PWR.Fill((ushort)Length, 0);
PWR.Fill((ushort)1006, 2);
PWR.Fill(Client.UniqueID, 4);
PWR.Fill(Client.Character.FullModel, 8);
PWR.Fill(Client.Character.HairStyle, 12);
PWR.Fill(Client.Character.Silver, 14);
PWR.Fill(Client.Character.CPs, 18);
PWR.Fill(Client.Character.Experience, 22);
PWR.Fill((ushort)5130, 42);
PWR.Fill(Client.Character.Strength, 46);
PWR.Fill(Client.Character.Agility, 48);
PWR.Fill(Client.Character.Vitality, 50);
PWR.Fill(Client.Character.Spirit, 52);
PWR.Fill(Client.Character.StatPoints, 54);
PWR.Fill(Client.Character.HitPoints, 56);
PWR.Fill(Client.Character.Mana, 58);
PWR.Fill(Client.Character.PKPoints, 60);
PWR.Fill(Client.Character.Level, 62);
PWR.Fill(Client.Character.Class, 63);
PWR.Fill((byte)5, 64);
PWR.Fill(Client.Character.RBCount, 65);
PWR.Fill((byte)1, 66);
PWR.Fill((byte)2, 67);
PWR.Fill((byte)Client.Character.Name.Length, 68);
PWR.Fill(Client.Character.Name, 69);
return PWR.Bytes;
}
public void Handle(byte[] Data, SocketClient Client)
{
Enums.ConquerAngle Direction = (Enums.ConquerAngle)(Data[8] % 8);
Client.Character.Walk(Direction);
Client.Character.Screen.Send(Data, true);
Client.Character.Map.PopulateScreen(Client);
}
public void Handle(byte[] Data, SocketClient Client)
{
uint NpcUID = BitConverter.ToUInt32(Data, 4);
if (!Client.Character.Map.NPCs.ContainsKey(NpcUID))
return;
Client.Character.CurrentDialog.Handle(Data);
}
private static void LoadItem(SocketClient Client, uint ItemUID)
{
using (DataTable dt = Database.ItemDB.GetDataTable("SELECT `ItemID`, `Plus`, `SocketOne`, `SocketTwo`, `Enchant`, `Position`, `Durability` FROM `items` WHERE `UniqueID`=" + ItemUID))
{
if (dt.Rows.Count > 0)
{
DataRow dr = dt.Rows[0];
Items.Item item = new Items.Item(Convert.ToUInt32(dr.ItemArray[0]));
item.UniqueID = ItemUID;
item.Plus = Convert.ToByte(dr.ItemArray[1]);
item.SocketOne = Convert.ToByte(dr.ItemArray[2]);
item.SocketTwo = Convert.ToByte(dr.ItemArray[3]);
item.Enchant = Convert.ToByte(dr.ItemArray[4]);
item.Position = Convert.ToByte(dr.ItemArray[5]);
item.Durability = Convert.ToUInt16(dr.ItemArray[6]);
item.Loaded = true;
if (item.Position == 0)
Client.Character.Inventory.TryAdd(item);
else if (item.Position < 10)
Client.Character.Equipment.Equip(item, item.Position);
else
{
if (!Client.Character.Warehouses.ContainsKey(item.Position))
Client.Character.Warehouses.TryAdd(item.Position, new ConcurrentBag<Items.Item>());
byte spaces = 20;
if (item.Position == 10)
spaces = 40;
if (Client.Character.Warehouses[item.Position].Count >= spaces)
Console.WriteLine("Inventory full, yet adding items. Something went wrong.");
else
Client.Character.Warehouses[item.Position].Add(item);
}
}
}
}
public Team(Network.SocketClient Owner)
{
this.TeamID = Owner.UniqueID;
if (Members.TryAdd(Owner.UniqueID, Owner))
{
Owner.Send(Packets.ToSend.TeamPacket(Owner.UniqueID, Enums.TeamPacket.Create));
}
}
public static void LoadSkills(SocketClient Client)
{
using (DataTable DT = Database.CharacterDB.GetDataTable("SELECT `ID`, `Level`, `Experience` FROM `skills` WHERE `OwnerUID`=" + Client.UniqueID))
{
for (int i = 0; i < DT.Rows.Count; i++)
Client.Character.LearnSkill(Convert.ToUInt16(DT.Rows[i].ItemArray[0]), Convert.ToByte(DT.Rows[i].ItemArray[1]), Convert.ToUInt32(DT.Rows[i].ItemArray[2]));
}
}
public bool Insert(SocketClient Client)
{
if (Client.UniqueID == Owner.UniqueID)
return false;
if (Players.TryAdd(Client.UniqueID, Client))
{
Owner.Send(Client.Character.ToBytes());
return true;
}
return false;
}
public void AddMember(Network.SocketClient NewMember)
{
if (Members.TryAdd(NewMember.UniqueID, NewMember))
{
byte[] Data = Packets.ToSend.AddToTeamPacket(NewMember.Character.Name, NewMember.UniqueID, NewMember.Character.FullModel, NewMember.Character.MaxHitPoints, NewMember.Character.HitPoints);
foreach (Network.SocketClient Member in Members.Values)
{
Member.Send(Data);
}
}
}
public static void LoadItems(SocketClient Client)
{
string file = "C:/db/Players/" + Client.UniqueID + "/itemkeys.dat";
if (File.Exists(file))
{
using (BinaryReader br = new BinaryReader(File.Open(file, FileMode.Open)))
{
uint count = br.ReadUInt32();
for (uint i = 0; i < count; i++)
LoadItem(Client, br.ReadUInt32());
br.Close();
}
File.Delete(file);
}
else
{
using (DataTable dt = Database.ItemDB.GetDataTable("SELECT `UniqueID`, `ItemID`, `Plus`, `SocketOne`, `SocketTwo`, `Enchant`, `Position`, `Durability` FROM `items` WHERE `OwnerUID`=" + Client.UniqueID))
{
for (int i = 0; i < dt.Rows.Count; i++)
{
DataRow dr = dt.Rows[i];
Items.Item item = new Items.Item(Convert.ToUInt32(dr.ItemArray[1]));
item.UniqueID = Convert.ToUInt32(dr.ItemArray[0]);
item.Plus = Convert.ToByte(dr.ItemArray[2]);
item.SocketOne = Convert.ToByte(dr.ItemArray[3]);
item.SocketTwo = Convert.ToByte(dr.ItemArray[4]);
item.Enchant = Convert.ToByte(dr.ItemArray[5]);
item.Position = Convert.ToByte(dr.ItemArray[6]);
item.Durability = Convert.ToUInt16(dr.ItemArray[7]);
item.Loaded = true;
if (item.Position == 0)
Client.Character.Inventory.TryAdd(item);
else if (item.Position < 10)
Client.Character.Equipment.Equip(item, item.Position);
else
{
if (!Client.Character.Warehouses.ContainsKey(item.Position))
Client.Character.Warehouses.TryAdd(item.Position, new ConcurrentBag<Items.Item>());
byte spaces = 20;
if (item.Position == 10)
spaces = 40;
if (Client.Character.Warehouses[item.Position].Count >= spaces)
Console.WriteLine("Inventory full, yet adding items. Something went wrong.");
else
Client.Character.Warehouses[item.Position].Add(item);
}
}
}
}
}
public void Handle(byte[] Data, SocketClient Client)
{
byte Type = Data[22];
switch(Type)
{
case 74:
{
Calculations.CalculateMaxHP(Client.Character);
Calculations.CalculateMaxMana(Client.Character);
Client.Send(Packets.ToSend.GeneralData(Client.UniqueID, Client.Character.MapID, Client.Character.X, Client.Character.Y, 0, Enums.GeneralData.SetLocation));
Client.Send(Packets.ToSend.GeneralData(Client.UniqueID, Client.Character.MapID, Client.Character.X, Client.Character.Y, 0, Enums.GeneralData.ChgMap));
Client.Send(Packets.ToSend.MapInfo(Client.Character.MapID, (uint)(Client.Character.MapID == 1036 ? 30 : 2080)));
Client.Character.Map.Insert(Client);
break;
}
case 79:
{
Client.Character.Facing = (Enums.ConquerAngle)Data[20];
break;
}
case 133:
{
ushort new_X = BitConverter.ToUInt16(Data, 12);
ushort new_Y = BitConverter.ToUInt16(Data, 14);
double jumpDistance = Calculations.GetDistance(Client.Character.X, Client.Character.Y, new_X, new_Y);
if (jumpDistance <= Constants.ScreenDistance)
{
Client.Character.X = new_X;
Client.Character.Y = new_Y;
Client.Character.Screen.Send(Data, true);
Client.Character.Map.PopulateScreen(Client);
}
else
Client.Disconnect();
break;
}
case 142:
{
if (Client.Character.Silver >= 500)
{
Client.Character.Silver -= 500;
Client.Character.Avatar = BitConverter.ToUInt16(Data, 12);
}
else
Client.Send(Packets.ToSend.MessagePacket("You don't have 500 silvers.", "SYSTEM", Client.Character.Name, Enums.ChatType.Top));
break;
}
default: Console.WriteLine("Missing General Data PacketID: {0}", Type); break;
}
}
public Character(uint UniqueID, SocketClient socClient)
{
this.Owner = socClient;
this.UniqueID = UniqueID;
this.Screen = new Mapping.Screen(socClient);
this.AttackHandler = new Attacking.AttackHandler(socClient);
this.CurrentDialog = new NPCs.NPCHandler(socClient);
this.Inventory = new Items.Inventory(socClient);
this.Equipment = new Items.Equipment(socClient);
PacketWriter = new Packets.Writer(102);
PacketWriter.Fill((ushort)102, 0);
PacketWriter.Fill((ushort)1014, 2);
PacketWriter.Fill(UniqueID, 4);
PacketWriter.Fill((byte)1, 80);
}
public static void LoadProfs(SocketClient Client)
{
using (DataTable DT = Database.CharacterDB.GetDataTable("SELECT `ID`, `Level`, `Experience` FROM `profs` WHERE `OwnerUID`=" + Client.UniqueID))
{
for (int i = 0; i < DT.Rows.Count; i++)
{
DataRow dr = DT.Rows[i];
Profs.Prof P = new Profs.Prof();
ushort ProfID = Convert.ToUInt16(dr.ItemArray[0]);
P.Level = Convert.ToByte(dr.ItemArray[1]);
P.Experience = Convert.ToUInt32(dr.ItemArray[2]);
if (Client.Character.Profs.TryAdd(ProfID, P))
Client.Send(Packets.ToSend.ProfPacket(ProfID, P));
}
}
}
public static void Handle(byte[] Data, SocketClient Client)
{
Client.Crypto.Decrypt(ref Data);
if (Data.Length < 4)
{
Client.Disconnect();
return;
}
ushort PacketID = BitConverter.ToUInt16(Data, 2);
Packet handler;
if (packetHandlers.TryGetValue(PacketID, out handler))
{
if (Data.Length >= handler.MinLength)
handler.Handle(Data, Client);
else
Client.Disconnect();
}
else
Console.WriteLine("Missing PacketID: {0}", PacketID);
}
public void Handle(byte[] Data, SocketClient Client)
{
Client.UniqueID = BitConverter.ToUInt32(Data, 4);
if (Database.Methods.Authenticated(Client.UniqueID))
{
Client.Crypto.SetKeys(255, Client.UniqueID);
if (Database.Methods.LoadCharacter(Client))
{
Client.Connected = true;
Database.Methods.LoadItems(Client);
Database.Methods.LoadProfs(Client);
Client.Send(Packets.ToSend.MessagePacket("ANSWER_OK", "SYSTEM", "ALLUSERS", Enums.ChatType.LoginInformation));
Client.Send(Packets.ToSend.CharacterInfo(Client));
}
else
Client.Send(Packets.ToSend.MessagePacket("NEW_ROLE", "SYSTEM", "ALLUSERS", Enums.ChatType.LoginInformation));
}
else
{
Client.Send(Packets.ToSend.MessagePacket("Nice try buddy <3", "SYSTEM", "ALLUSERS", Enums.ChatType.LoginInformation));
Client.Disconnect();
}
}
public static bool LoadCharacter(SocketClient Client)
{
using (DataTable DT = Database.CharacterDB.GetDataTable(@"SELECT i.name, i.class, i.level, i.experience, i.spouse, i.rbcount, i.hitpoints, i.pkpoints, i.mana, a.hairstyle, a.model, a.avatar, l.mapid, l.x, l.y, m.silver, m.storedsilver, m.cps, m.virtuepoints, s.strength, s.agility, s.spirit, s.vitality, s.statpoints FROM `info` as `i` INNER JOIN `appearance` as `a` ON i.UniqueID=a.UniqueID INNER JOIN `locations` as `l` ON i.UniqueID=l.UniqueID INNER JOIN `money` as `m` ON i.UniqueID=m.UniqueID INNER JOIN `stats` as `s` ON i.UniqueID=s.UniqueID WHERE i.UniqueID=" + Client.UniqueID))
{
if (DT.Rows.Count == 1)
{
DataRow dr = DT.Rows[0];
Client.Character = new Entities.Character(Client.UniqueID, Client);
Client.Character.Name = dr.ItemArray[0].ToString();
Client.Character.Class = Convert.ToByte(dr.ItemArray[1]);
Client.Character.Level = Convert.ToByte(dr.ItemArray[2]);
Client.Character.Experience = Convert.ToUInt32(dr.ItemArray[3]);
Client.Character.Spouse = Convert.ToUInt32(dr.ItemArray[4]);
Client.Character.RBCount = Convert.ToByte(dr.ItemArray[5]);
Client.Character.HitPoints = Convert.ToUInt16(dr.ItemArray[6]);
Client.Character.PKPoints = Convert.ToUInt16(dr.ItemArray[7]);
Client.Character.Mana = Convert.ToUInt16(dr.ItemArray[8]);
Client.Character.HairStyle = Convert.ToUInt16(dr.ItemArray[9]);
Client.Character.Model = Convert.ToUInt32(dr.ItemArray[10]);
Client.Character.Avatar = Convert.ToUInt16(dr.ItemArray[11]);
Client.Character.MapID = Convert.ToUInt32(dr.ItemArray[12]);
Client.Character.X = Convert.ToUInt16(dr.ItemArray[13]);
Client.Character.Y = Convert.ToUInt16(dr.ItemArray[14]);
Client.Character.Silver = Convert.ToUInt32(dr.ItemArray[15]);
Client.Character.StoredSilver = Convert.ToUInt32(dr.ItemArray[16]);
Client.Character.CPs = Convert.ToUInt32(dr.ItemArray[17]);
Client.Character.VirtuePoints = Convert.ToUInt32(dr.ItemArray[18]);
Client.Character.Strength = Convert.ToUInt16(dr.ItemArray[19]);
Client.Character.Agility = Convert.ToUInt16(dr.ItemArray[20]);
Client.Character.Spirit = Convert.ToUInt16(dr.ItemArray[21]);
Client.Character.Vitality = Convert.ToUInt16(dr.ItemArray[22]);
Client.Character.StatPoints = Convert.ToUInt16(dr.ItemArray[23]);
return true;
}
}
return false;
}
public void Handle(byte[] Data, SocketClient Client)
{
string CharName = System.Text.ASCIIEncoding.ASCII.GetString(Data, 20, 16).Replace("\0", "");
ushort Model = BitConverter.ToUInt16(Data, 52);
ushort Class = BitConverter.ToUInt16(Data, 54);
uint AccountID = BitConverter.ToUInt32(Data, 56);
if (Model != 1003 && Model != 1004 && Model != 2001 && Model != 2002)
{
Client.Disconnect();
return;
}
if (Class != 10 && Class != 100 && Class != 20 && Class != 40)
{
Client.Disconnect();
return;
}
if (Database.Methods.ValidString(CharName))
{
if (!Database.Methods.NameExists(CharName))
{
if (!Database.Methods.HasCharacter(Client.UniqueID))
{
Database.Methods.CreateCharacter(Client.UniqueID, CharName, Class, Model);
Client.Send(Packets.ToSend.MessagePacket("ANSWER_OK", "SYSTEM", "ALLUSERS", Enums.ChatType.Dialog));
Client.Disconnect();
}
else
Client.Send(Packets.ToSend.MessagePacket("You already have a character created.", "SYSTEM", "ALLUSERS", Enums.ChatType.Dialog));
}
else
Client.Send(Packets.ToSend.MessagePacket("Character name has been taken! Please choose a new one!", "SYSTEM", "ALLUSERS", Enums.ChatType.Dialog));
}
else
Client.Send(Packets.ToSend.MessagePacket("Invalid character name!", "SYSTEM", "ALLUSERS", Enums.ChatType.Dialog));
}
public static void GenerateItemKeyFile(SocketClient Client)
{
List<uint> ItemUIDs = new List<uint>();
Client.Character.Equipment.GetItemList(ref ItemUIDs);
Client.Character.Inventory.GetItemList(ref ItemUIDs);
foreach (ConcurrentBag<Items.Item> WH in Client.Character.Warehouses.Values)
foreach (Items.Item item in WH)
ItemUIDs.Add(item.UniqueID);
if (!Directory.Exists("C:/db/Players/" + Client.UniqueID))
Directory.CreateDirectory("C:/db/Players/" + Client.UniqueID);
using (BinaryWriter bw = new BinaryWriter(File.Open("C:/db/Players/" + Client.UniqueID + "/itemkeys.dat", FileMode.CreateNew)))
{
bw.Write((uint)ItemUIDs.Count);
foreach (uint ItemUID in ItemUIDs)
bw.Write(ItemUID);
}
ItemUIDs.Clear();
}
public NPCHandler(SocketClient Owner) { this.Owner = Owner; }
public void Insert(SocketClient Client)
{
if (Players.TryAdd(Client.UniqueID, Client))
PopulateScreen(Client);
}
public void TakeDamage(uint AttackerUID, uint Damage)
{
if (HitPoints > Damage)
HitPoints = (ushort)(HitPoints - Damage);
else
{
this.Target = null;
DeathStamp = Environment.TickCount;
HitPoints = 0;
SendScreen(Packets.ToSend.Attack(AttackerUID, UniqueID, X, Y, 0, Enums.AttackType.Death));
SendScreen(Packets.ToSend.SyncPacket(Target.UniqueID, Enums.SyncType.RaiseFlag, 2080));
}
}
public Equipment(SocketClient Owner) { this.Owner = Owner; }
public Screen(SocketClient Owner)
{
this.Owner = Owner;
}
public void Handle(byte[] Data, SocketClient Client)
{
byte DataType = Data[12];
switch(DataType)
{
case 4:
{
uint ItemUID = BitConverter.ToUInt32(Data, 4);
byte ToPosition = Data[8];
Items.Item itm;
if (!Client.Character.Inventory.Items.TryGetValue(ItemUID, out itm))
return;
Client.Character.Inventory.Remove(itm.UniqueID);
Client.Character.Equipment.Equip(itm, ToPosition);
break;
}
case 6:
{
if (Client.Character.Dead)
return;
Client.Character.Equipment.Uneqip(BitConverter.ToUInt32(Data, 4));
break;
}
case 9:
{
ConcurrentBag<Items.Item> Items;
if (Client.Character.Warehouses.TryGetValue(Client.Character.MapID, out Items))
Client.Send(Packets.ToSend.ViewWarehouse(Client.Character.CurrentDialog.ActiveNPC, Items));
else
Client.Send(Packets.ToSend.ViewWarehouse(Client.Character.CurrentDialog.ActiveNPC));
break;
}
case 10:
{
uint Amount = BitConverter.ToUInt32(Data, 8);
if (Client.Character.Silver >= Amount)
{
if ((Client.Character.StoredSilver + Amount) < Constants.MaxMoney)
{
Client.Character.Silver -= Amount;
Client.Character.StoredSilver += Amount;
}
else
Client.Send(Packets.ToSend.MessagePacket("You have reached the max amount you can deposit.", "SYSTEM", Client.Character.Name, Enums.ChatType.Top));
}
else
Client.Send(Packets.ToSend.MessagePacket("You don't enough silver for that transaction.", "SYSTEM", Client.Character.Name, Enums.ChatType.Top));
break;
}
case 11:
{
uint Amount = BitConverter.ToUInt32(Data, 8);
if (Client.Character.StoredSilver >= Amount)
{
if (Client.Character.Silver + Amount < Constants.MaxMoney)
{
Client.Character.StoredSilver -= Amount;
Client.Character.Silver += Amount;
}
else
Client.Send(Packets.ToSend.MessagePacket("You have reached the max amount you can carry.", "SYSTEM", Client.Character.Name, Enums.ChatType.Top));
}
else
Client.Send(Packets.ToSend.MessagePacket("You don't enough silver for that transaction.", "SYSTEM", Client.Character.Name, Enums.ChatType.Top));
break;
}
case 27: Client.Send(Data); break;
default: break;
}
}
public void Handle(byte[] Data, SocketClient Client)
{
Enums.ChatType ChatType = (Enums.ChatType)BitConverter.ToUInt32(Data, 8);
string From = Encoding.ASCII.GetString(Data, 26, Data[25]);
if (From != Client.Character.Name)
return;
string To = Encoding.ASCII.GetString(Data, 27 + From.Length, Data[26 + From.Length]);
string Message = Encoding.ASCII.GetString(Data, 29 + From.Length + To.Length, Data[28 + From.Length + To.Length]);
if (Message.StartsWith(Constants.CommandOperator))
{
Message = Message.Replace(Constants.CommandOperator, "");
string[] msgData = Message.Split(' ');
switch (msgData[0])
{
case "life": Client.Character.HitPoints = Client.Character.MaxHitPoints; break;
case "dc": Client.Disconnect(); break;
case "money":
case "silver":
{
if (msgData.Length < 2)
return;
uint Silver;
if (!uint.TryParse(msgData[1], out Silver))
return;
Client.Character.Silver = Silver;
break;
}
case "learnspell":
{
if (msgData.Length < 3)
return;
ushort SkillID;
if (!ushort.TryParse(msgData[1], out SkillID))
return;
byte Level;
if (!byte.TryParse(msgData[2], out Level))
return;
Client.Character.LearnSkill(SkillID, Level, 0);
break;
}
case "forgetspell":
{
if (msgData.Length < 2)
return;
ushort SkillID;
if (!ushort.TryParse(msgData[1], out SkillID))
return;
Client.Character.ForgetSkill(SkillID);
break;
}
case "item":
{
if (msgData.Length > 2)
{
uint ItemID;
if (!uint.TryParse(msgData[1], out ItemID))
{
if (msgData.Length == 8)
{
Enums.ItemQuality quality;
switch (msgData[2].ToLower())
{
case "super": quality = Enums.ItemQuality.Super; break;
case "elite": quality = Enums.ItemQuality.Elite; break;
case "unique": quality = Enums.ItemQuality.Unique; break;
case "refined": quality = Enums.ItemQuality.Refined; break;
case "normal": quality = Enums.ItemQuality.Normal; break;
default: return;
}
byte Plus;
if (!byte.TryParse(msgData[3], out Plus))
return;
byte Bless;
if (!byte.TryParse(msgData[4], out Bless))
return;
byte Enchant;
if (!byte.TryParse(msgData[5], out Enchant))
return;
byte Gem1;
if (!byte.TryParse(msgData[6], out Gem1))
return;
byte Gem2;
if (!byte.TryParse(msgData[7], out Gem2))
return;
foreach (Items.ItemType ItemInfo in Kernel.ItemTypes.Values)
{
if (ItemInfo.Name == msgData[1])
{
Items.Item Itm = new Items.Item(ItemInfo);
Itm.OwnerUID = Client.UniqueID;
Itm.Bless = Bless;
Itm.Enchant = Enchant;
Itm.QualityChange(quality);
Itm.Durability = ItemInfo.MaxDurability;
Itm.Mode = 1;
Itm.Plus = Plus;
if (ItemInfo.ID >= 730001 && ItemInfo.ID <= 730009)
Itm.Plus = (byte)(ItemInfo.ID - 730000);
Itm.Position = (byte)Enums.ItemPosition.Inventory;
Itm.Loaded = true;
Itm.Save();
Client.Character.Inventory.TryAdd(Itm);
return;
}
}
}
}
}
break;
}
default: break;
}
}
else
{
uint Color = BitConverter.ToUInt32(Data, 4);
switch(ChatType)
{
case Enums.ChatType.Talk:
{
Client.Character.Screen.Send(Packets.ToSend.MessagePacket(Message, From, To, Client.Character.Dead ? Enums.ChatType.Ghost : Enums.ChatType.Talk), false);
break;
}
default: break;
}
}
}
public void Handle(byte[] Data, SocketClient Client)
{
byte WHKey;
if (!Kernel.WarehouseKeys.TryGetValue(Client.Character.MapID, out WHKey))
return;
byte Type = Data[8];
switch(Type)
{
case 0:
{
ConcurrentBag<Items.Item> WHItems;
if (Client.Character.Warehouses.TryGetValue(Client.Character.MapID, out WHItems))
Client.Send(Packets.ToSend.ViewWarehouse(Client.Character.CurrentDialog.ActiveNPC, WHItems));
else
Client.Send(Packets.ToSend.ViewWarehouse(Client.Character.CurrentDialog.ActiveNPC));
break;
}
case 1:
{
uint ItemUID = BitConverter.ToUInt32(Data, 12);
Items.Item Item;
if (!Client.Character.Inventory.Items.TryGetValue(ItemUID, out Item))
return;
ConcurrentBag<Items.Item> WHItems;
if (!Client.Character.Warehouses.TryGetValue(Client.Character.MapID, out WHItems))
{
WHItems = new ConcurrentBag<Items.Item>();
Client.Character.Warehouses.TryAdd(Client.Character.MapID, WHItems);
}
byte MaxSlots = 20;
if (Client.Character.MapID == 1036)
MaxSlots = 40;
if (WHItems.Count >= MaxSlots)
return;
Client.Character.Inventory.Remove(ItemUID);
Item.Position = WHKey;
WHItems.Add(Item);
if (WHItems.Count == 21)
Client.Send(Packets.ToSend.AddWHItem(Client.Character.CurrentDialog.ActiveNPC, Item));
Client.Send(Packets.ToSend.ViewWarehouse(Client.Character.CurrentDialog.ActiveNPC, WHItems));
break;
}
case 2:
{
uint ItemUID = BitConverter.ToUInt32(Data, 12);
ConcurrentBag<Items.Item> WHItems;
if (!Client.Character.Warehouses.TryGetValue(Client.Character.MapID, out WHItems))
return;
foreach (Items.Item I in WHItems)
{
if (I.UniqueID == ItemUID)
{
Items.Item removedItem;
if (WHItems.TryTake(out removedItem))
{
Client.Send(Packets.ToSend.ViewWarehouse(Client.Character.CurrentDialog.ActiveNPC, WHItems));
removedItem.Position = 0;
Client.Character.Inventory.TryAdd(removedItem);
Client.Send(removedItem.ToBytes);
}
return;
}
}
break;
}
default: Console.WriteLine("Missing Warehouse Packet: " + Type); break;
}
}
public void Handle(byte[] Data, SocketClient Client)
{
Client.Character.AttackHandler.Handle(Data);
}
public Inventory(SocketClient Owner) { this.Owner = Owner; }
public AttackHandler(SocketClient Owner)
{
this.Owner = Owner;
}
