public void OnGotInventoryItem(Common.Item.Item item, bool end)
{
if (item != null)
{
List <ActorPC> list = chars.Values.ToList();
if (list.Count > currentCharIndex)
{
if (item.SlotID == 255)
{
lock (list[currentCharIndex].Inventory.SoldItems)
{
list[currentCharIndex].Inventory.SoldItems.Add(item);
}
}
else
{
list[currentCharIndex].Inventory.Container[item.Container][item.SlotID] = item;
/*if (item.InventoryEquipSlot != Common.Inventory.InventoryEquipSlot.None)
* list[currentCharIndex].Inventory.Equipments[item.InventoryEquipSlot] = item;*/
}
}
}
if (end)
{
currentCharIndex++;
LoadInventory();
}
}
public void OnItemBuy(CM_ITEM_BUY p)
{
if (map.GetActor(p.ActorID) is ActorNPC npc)
{
if (NPC.NPCStoreFactory.Instance.Stores.ContainsKey(npc.BaseData.StoreID))
{
NPC.NPCStore store = NPC.NPCStoreFactory.Instance[npc.BaseData.StoreID];
foreach (KeyValuePair <byte, ushort> i in p.Items)
{
if (i.Key < store.Items.Length)
{
Common.Item.Item item = ItemFactory.Instance.CreateNewItem(store.Items[i.Key]);
if (item != null)
{
int price = (int)(item.BaseData.Price * store.BuyRate) * i.Value;
if (chara.Gold > price)
{
Interlocked.Add(ref chara.Gold, -price);
item.Count = i.Value;
AddItem(item);
SendPlayerGold();
}
}
}
}
}
}
}
public void AddItem(Common.Item.Item item, Containers container = Containers.Inventory)
{
item.CharID = chara.CharID;
OperationResults res = chara.Inventory.AddItem(container, item, out List <Common.Item.Item> affected);
if (affected.Count > 0)
{
CharacterSession.Instance.SaveItem(affected);
}
if (res != OperationResults.FAILED)
{
if (item.Count > 0)
{
affected.Add(item);
}
switch (res)
{
case OperationResults.NEW_INDEX:
SendItemUpdate(ItemUpdateMethod.Add, affected);
break;
case OperationResults.STACK_UPDATE:
SendItemUpdate(ItemUpdateMethod.Update, affected);
break;
}
if (res == OperationResults.NEW_INDEX && item.Count > 0)
{
CharacterSession.Instance.CreateItem(item);
}
}
}
public void SendPlayerEquiptStats(Common.Item.Item item, Stats extra2 = Stats.None, bool all = false)
{
UpdateEvent evt = new UpdateEvent();
Stats extra = Utils.FindStat(item.Synthesis);
/*
* if (item.BaseData.PrimaryStats.ContainsKey(Stats.MinAtk))
* evt.AddActorPara(Common.Packets.GameServer.PacketParameter.EquiptMinAtk, chara.Status.AtkMinExt);
* if (item.BaseData.PrimaryStats.ContainsKey(Stats.MaxAtk))
* evt.AddActorPara(Common.Packets.GameServer.PacketParameter.EquiptMaxAtk, chara.Status.AtkMaxExt);
* if (item.BaseData.PrimaryStats.ContainsKey(Stats.HitB) || Stats.HitB == extra || Stats.HitB == extra2 || all)
* evt.AddActorPara(Common.Packets.GameServer.PacketParameter.HitBase, chara.Status.Hit);
* if (item.BaseData.PrimaryStats.ContainsKey(Stats.AvoidB) || Stats.AvoidB == extra || Stats.AvoidB == extra2 || all)
* evt.AddActorPara(Common.Packets.GameServer.PacketParameter.AvoidBase, chara.Status.Avoid);
* if (item.BaseData.PrimaryStats.ContainsKey(Stats.CritB) || Stats.CritB == extra || Stats.CritB == extra2 || all)
* evt.AddActorPara(Common.Packets.GameServer.PacketParameter.CriticalBase, chara.Status.Critical);
* if (item.BaseData.PrimaryStats.ContainsKey(Stats.DefCritB) || Stats.DefCritB == extra || Stats.DefCritB == extra2 || all)
* evt.AddActorPara(Common.Packets.GameServer.PacketParameter.CriticalResist, chara.Status.CriticalResist);
* if (item.BaseData.PrimaryStats.ContainsKey(Stats.ParryB) || Stats.ParryB == extra || Stats.ParryB == extra2 || all)
* evt.AddActorPara(Common.Packets.GameServer.PacketParameter.ParryBase, chara.Status.Parry);
* if (item.BaseData.PrimaryStats.ContainsKey(Stats.PrcB) || Stats.PrcB == extra || Stats.PrcB == extra2 || all)
* evt.AddActorPara(Common.Packets.GameServer.PacketParameter.PierceBase, chara.Status.Pierce);
*/
if (item.BaseData.PrimaryStats.ContainsKey(Stats.MaxHp) || Stats.MaxHp == extra || Stats.MaxHp == extra2 || all)
{
SendPlayerHP(true);
}
SM_PLAYER_UPDATE_LIST p = new SM_PLAYER_UPDATE_LIST()
{
Parameters = evt
};
Network.SendPacket(p);
}
public void OnItemBuyBack(CM_ITEM_BUYBACK p)
{
if (map.GetActor(p.ActorID) is ActorNPC npc)
{
if (NPC.NPCStoreFactory.Instance.Stores.ContainsKey(npc.BaseData.StoreID))
{
NPC.NPCStore store = NPC.NPCStoreFactory.Instance[npc.BaseData.StoreID];
if (p.Slot < chara.Inventory.SoldItems.Count)
{
Common.Item.Item item = chara.Inventory.SoldItems[p.Slot];
if (item != null)
{
int price = (int)(item.BaseData.Price * store.BuyBackRate) * item.Count;
if (chara.Gold > price)
{
Interlocked.Add(ref chara.Gold, -price);
chara.Inventory.SoldItems.RemoveAt(p.Slot);
OperationResults res = chara.Inventory.AddItem(Containers.Inventory, item, out List <Common.Item.Item> affected);
if (affected.Count > 0)
{
CharacterSession.Instance.SaveItem(affected);
}
if (res != OperationResults.FAILED)
{
if (item.Count > 0)
{
affected.Add(item);
}
switch (res)
{
case OperationResults.NEW_INDEX:
SendItemUpdate(ItemUpdateMethod.Add, affected);
break;
case OperationResults.STACK_UPDATE:
SendItemUpdate(ItemUpdateMethod.Update, affected);
break;
}
if (res == OperationResults.NEW_INDEX && item.Count > 0)
{
CharacterSession.Instance.SaveItem(item);
}
if (item.Count == 0)
{
List <Common.Item.Item> remove = new List <Common.Item.Item>();
remove.Add(item);
CharacterSession.Instance.DeleteItem(remove);
}
}
SendPlayerGold();
SendItemBuyBackList();
}
}
}
}
}
}
public void SaveItem(Common.Item.Item item)
{
CM_ITEM_SAVE p = new CM_ITEM_SAVE()
{
Item = item
};
Network.SendPacket(p);
}
public void SendItemUpdate(Item.ItemUpdateMethod reason, Common.Item.Item item)
{
SM_ITEM_INFO p = new SM_ITEM_INFO();
List <Common.Item.Item> list = new List <Common.Item.Item>();
list.Add(item);
p.Reason = reason;
p.Items = list;
Network.SendPacket(p);
}
public void OnGotInventoryItem(Common.Item.Item item, bool end)
{
if (item != null && chara != null)
{
Common.Item.Item newItem = ItemFactory.Instance.CreateNewItem(item.ItemID);
if (newItem == null || newItem.BaseData == null)
{
Logger.Log.Warn("Item or BaseData == null for ID:" + item.ID + ",ItemID:" + item.ItemID);
}
else
{
newItem.CharID = item.CharID;
newItem.ID = item.ID;
newItem.SlotID = item.SlotID;
//newItem.InventoryEquipSlot = item.InventoryEquipSlot;
newItem.Count = item.Count;
newItem.Synthesis = item.Synthesis;
if (newItem.SlotID == 255)
{
lock (chara.Inventory.SoldItems)
{
chara.Inventory.SoldItems.Add(newItem);
}
}
else
{
/*chara.Inventory.Container[newItem.SlotID] = newItem;
* if (item.InventoryEquipSlot != InventoryEquipSlot.None)
* {
* if (chara.Inventory.Equipments[newItem.InventoryEquipSlot] != null)
* {
* newItem.InventoryEquipSlot = InventoryEquipSlot.None;
* duplicateEquipSlots.Add(newItem);
* }
* else
* {
* chara.Inventory.Equipments[newItem.InventoryEquipSlot] = newItem;
* PC.Status.EquipItem(chara, newItem,true);
* }
* }*/
}
}
}
if (end)
{
CharacterSession.Instance.SaveItem(duplicateEquipSlots);
duplicateEquipSlots = chara.Inventory.CheckDuplicateSlot();
CharacterSession.Instance.DeleteItem(duplicateEquipSlots);
duplicateEquipSlots = null;
CharacterSession.Instance.GetQuests(chara.CharID, this);
}
}
private bool BaGuaSuccess(Common.Item.Item p, Common.Item.Item s)
{
Random r = new Random();
int percent = r.Next(1, 100);
switch (Math.Abs(p.BaseData.ItemLevel - s.BaseData.ItemLevel))
{
case 0:
case 1:
case 2:
case 3:
case 4:
if (percent <= 90)
{
return(true);
}
break;
case 5:
case 6:
case 7:
if (percent <= 60)
{
return(true);
}
break;
case 8:
if (percent <= 30)
{
return(true);
}
break;
case 9:
if (percent <= 10)
{
return(true);
}
break;
default:
break;
}
return(false);
}
public void CreateItem(Common.Item.Item item)
{
long session = Global.PacketSession;
createItems[session] = item;
CM_ITEM_CREATE p = new CM_ITEM_CREATE()
{
SessionID = session,
Item = item
};
Network.SendPacket(p);
}
public void ChangeBaGua(CM_BAGUA_SET_CHANGE p)
{
chara.SendRemove = false;
while (chara.StillProcess)
{
}
foreach (KeyValuePair <ushort, byte> i in p.EquipItems)
{
Common.Item.Item bagua = chara.Inventory.Container[Containers.Inventory][i.Key];
if (bagua?.BaseData.ItemType == ItemType.Bagua)
{
OperationResults res = chara.Inventory.EquipItem(bagua, out Common.Item.Item oldItem);
if (res != OperationResults.FAILED)
{
if (oldItem != null)
{
PC.Status.EquipItem(chara, oldItem, false);
List <Common.Item.Item> list = new List <Common.Item.Item>();
list.Add(bagua);
list.Add(oldItem);
SendItemUpdate(ItemUpdateMethod.Move, list);
PC.Status.EquipItem(chara, bagua, true);
}
else
{
SendItemUpdate(ItemUpdateMethod.Move, bagua);
PC.Status.EquipItem(chara, bagua, true);
}
}
}
}
SM_BAGUA_SET_CHANGE r = new SM_BAGUA_SET_CHANGE();
Network.SendPacket(r);
PC.Status.CalcStatus(chara);
SendPlayerStats();
UpdateEvent evt = new UpdateEvent()
{
Actor = chara,
Target = chara,
UpdateType = UpdateTypes.Actor
};
evt.AddActorPara(Common.Packets.GameServer.PacketParameter.HP, chara.HP);
//evt.AddActorPara(Common.Packets.GameServer.PacketParameter.MaxHP, chara.MaxHP);
map.SendEventToAllActorsWhoCanSeeActor(MapEvents.EVENT_BROADCAST, evt, chara, true);
}
public Common.Item.Item CreateNewItem(uint itemID)
{
if (items.ContainsKey(itemID))
{
Common.Item.Item item = new Common.Item.Item(this[itemID])
{
Count = 1
};
return(item);
}
else
{
return(null);
}
}
public static void FindSynthesisStat(Common.Item.Item item, ActorPC pc, bool add)
{
switch (item.Synthesis)
{
case 0x05:
Interlocked.Add(ref pc.Status.HitExt, (add ? 1 : -1) * item.BaseData.SecondaryStats[Stats.HitB]);
break;
case 0x07:
Interlocked.Add(ref pc.Status.CriticalExt, (add ? 1 : -1) * item.BaseData.SecondaryStats[Stats.CritB]);
break;
case 0x09:
Interlocked.Add(ref pc.Status.CriticalResistExt, (add ? 1 : -1) * item.BaseData.SecondaryStats[Stats.DefCritB]);
break;
case 0x0B:
Interlocked.Add(ref pc.Status.AvoidExt, (add ? 1 : -1) * item.BaseData.SecondaryStats[Stats.AvoidB]);
break;
case 0x0D:
Interlocked.Add(ref pc.Status.ParryExt, (add ? 1 : -1) * item.BaseData.SecondaryStats[Stats.ParryB]);
break;
case 0x1A:
Interlocked.Add(ref pc.Status.MaxHPExt, (add ? 1 : -1) * item.BaseData.SecondaryStats[Stats.MaxHp]);
break;
case 0x20:
Interlocked.Add(ref pc.Status.PierceExt, (add ? 1 : -1) * item.BaseData.SecondaryStats[Stats.PrcB]);
break;
default:
break; //Shouldn't be reachable
/*
* case 0x01:
* return Stats.MaxAtk;
* case 0x02:
* return Stats.Defense;
* case 0x03:
* return Stats.Resist;
* case 0x13:
* return Stats.CastTimeB;
*/
}
}
public void OnItemBuy(CM_ITEM_EXCHANGE p)
{
if (map.GetActor(p.ActorID) is ActorNPC npc)
{
if (NPC.NPCStoreFactory.Instance.StoresByItem.ContainsKey(npc.BaseData.StoreByItemID))
{
NPC.NPCStore store = NPC.NPCStoreFactory.Instance.StoresByItem[npc.BaseData.StoreByItemID];
if (store != null)
{
Common.Item.Item item = ItemFactory.Instance.CreateNewItem(store.Items[p.BuySlot]);
Dictionary <Common.Item.Item, ushort> items = new Dictionary <Common.Item.Item, ushort>();
ushort total = 0;
if (item != null)
{
Common.Item.Item add;
foreach (KeyValuePair <ushort, ushort> i in p.ExchangeItems)
{
add = Character.Inventory.Container[Containers.Inventory][i.Key];
if (add != null)
{
if (add.Count >= i.Value && add.ItemID == store.Materials[p.BuySlot])
{
items.Add(add, i.Value);
total += add.Count;
}
else
{
break;
}
}
}
if (total >= p.BuyCount * store.MaterialCounts[p.BuySlot])
{
foreach (KeyValuePair <Common.Item.Item, ushort> i in items)
{
RemoveItemSlot(i.Key.SlotID, i.Value);
}
AddItem(item);
}
}
}
}
}
}
public static void EquipItem(ActorPC pc, Common.Item.Item item, bool add)
{
Interlocked.Add(ref pc.Status.AtkMinExt, item.BaseData.PrimaryStats.ContainsKey(Stats.MinAtk) ? (add ? 1 : -1) * item.BaseData.PrimaryStats[Stats.MinAtk] : 0);
Interlocked.Add(ref pc.Status.AtkMaxExt, item.BaseData.PrimaryStats.ContainsKey(Stats.MaxAtk) ? (add ? 1 : -1) * item.BaseData.PrimaryStats[Stats.MaxAtk] : 0);
Interlocked.Add(ref pc.Status.HitExt, item.BaseData.PrimaryStats.ContainsKey(Stats.HitB) ? (add ? 1 : -1) * item.BaseData.PrimaryStats[Stats.HitB] : 0);
Interlocked.Add(ref pc.Status.AvoidExt, item.BaseData.PrimaryStats.ContainsKey(Stats.AvoidB) ? (add ? 1 : -1) * item.BaseData.PrimaryStats[Stats.AvoidB] : 0);
Interlocked.Add(ref pc.Status.ParryExt, item.BaseData.PrimaryStats.ContainsKey(Stats.ParryB) ? (add ? 1 : -1) * item.BaseData.PrimaryStats[Stats.ParryB] : 0);
Interlocked.Add(ref pc.Status.CriticalExt, item.BaseData.PrimaryStats.ContainsKey(Stats.CritB) ? (add ? 1 : -1) * item.BaseData.PrimaryStats[Stats.CritB] : 0);
Interlocked.Add(ref pc.Status.CriticalResistExt, item.BaseData.PrimaryStats.ContainsKey(Stats.DefCritB) ? (add ? 1 : -1) * item.BaseData.PrimaryStats[Stats.DefCritB] : 0);
Interlocked.Add(ref pc.Status.PierceExt, item.BaseData.PrimaryStats.ContainsKey(Stats.PrcB) ? (add ? 1 : -1) * item.BaseData.PrimaryStats[Stats.PrcB] : 0);
Interlocked.Add(ref pc.Status.MaxHPExt, item.BaseData.PrimaryStats.ContainsKey(Stats.MaxHp) ? (add ? 1 : -1) * item.BaseData.PrimaryStats[Stats.MaxHp] : 0);
if (Utils.FindStat(item.Synthesis) != Stats.None &&
Utils.FindStat(item.Synthesis) != Stats.CastTimeB &&
Utils.FindStat(item.Synthesis) != Stats.Defense &&
Utils.FindStat(item.Synthesis) != Stats.MaxAtk &&
Utils.FindStat(item.Synthesis) != Stats.Resist)
{
FindSynthesisStat(item, pc, add);
}
}
public void DecomposeBaGua(CM_DECOMPOSE_BAGUA p)
{
Common.Item.Item item = chara.Inventory.Container[Containers.Inventory][p.ItemSlot];
if (item != null)
{
if ((item.BaseData.ItemType == ItemType.Weapon_AB ||
item.BaseData.ItemType == ItemType.Weapon_DG ||
item.BaseData.ItemType == ItemType.Weapon_GT ||
item.BaseData.ItemType == ItemType.Weapon_ST ||
item.BaseData.ItemType == ItemType.Weapon_SW ||
item.BaseData.ItemType == ItemType.Weapon_TA) &&
item.BaseData.BaGuaPowderCountWep > 0)
{
RemoveItemSlot((byte)p.ItemSlot, 1);
AddItem(item.BaseData.BaGuaPowderIdWep, (ushort)item.BaseData.BaGuaPowderCountWep);
}
else if (item.BaseData.ItemType == ItemType.Bagua && item.BaseData.BaGuaPowderCount > 0)
{
RemoveItemSlot((byte)p.ItemSlot, 1);
AddItem(item.BaseData.BaGuaPowderId, (ushort)item.BaseData.BaGuaPowderCount);
}
}
}
public Common.Item.Item AddItem(uint itemID, ushort count = 1, Containers container = Containers.Inventory)
{
Common.Item.Item item = ItemFactory.Instance.CreateNewItem(itemID);
item.CharID = chara.CharID;
item.Container = container;
item.Count = count;
OperationResults res = chara.Inventory.AddItem(container, item, out List <Common.Item.Item> affected);
if (affected.Count > 0)
{
CharacterSession.Instance.SaveItem(affected);
}
if (res != OperationResults.FAILED)
{
if (item.Count > 0)
{
affected.Add(item);
}
switch (res)
{
case OperationResults.NEW_INDEX:
SendItemUpdate(ItemUpdateMethod.Add, affected);
break;
case OperationResults.STACK_UPDATE:
SendItemUpdate(ItemUpdateMethod.Update, affected);
break;
}
if (res == OperationResults.NEW_INDEX && item.Count > 0)
{
CharacterSession.Instance.CreateItem(item);
}
}
return(item);
}
protected override void OnGotInventoryItem(GameSession client, Common.Item.Item item, bool end)
{
client.OnGotInventoryItem(item, end);
}
public override void OnDie(ActorExt killedBy)
{
if (npc.Tasks.TryGetValue("ActorCatch", out Task removed))
{
removed.Deactivate();
}
if (firstAttacker != null && npc.BaseData.QuestIDs.Count > 0)
{
ActorPC pc = firstAttacker;
List <ushort> already = new List <ushort>();
foreach (ushort i in npc.BaseData.QuestIDs)
{
if (!already.Contains(i))
{
already.Add(i);
}
else
{
continue;
}
if (pc.Quests.TryGetValue(i, out Common.Quests.Quest q))
{
try
{
Quests.QuestManager.Instance.ProcessQuest(pc, i, q.NextStep, q, npc, false, true);
}
catch (Exception ex)
{
Logger.Log.Error(ex);
}
}
}
}
if (ShouldRespawn != null)
{
ShouldRespawn();
}
AI.Deactivate();
Map.Map map = MapManager.Instance.GetMap(npc.MapInstanceID);
ActorCorpse corpse = new ActorCorpse(npc);
if (firstAttacker != null)
{
corpse.Owner = Party.PartyManager.Instance.GetPartyLootOwner(firstAttacker);
}
corpse.MapID = npc.MapID;
corpse.X = npc.X;
corpse.Y = npc.Y;
corpse.Z = npc.Z;
corpse.EventHandler = new DummyEventHandler();
if (firstAttacker != null)
{
uint exp = (uint)(npc.Level / 2 + 10);
Manager.ExperienceManager.Instance.ApplyExp(firstAttacker, exp);
List <Common.Item.Item> items = new List <Common.Item.Item>();
foreach (uint i in npc.BaseData.Items.Keys)
{
int rate = npc.BaseData.Items[i];
if (Global.Random.Next(0, 99) < rate)
{
Common.Item.Item item = Item.ItemFactory.Instance.CreateNewItem(i);
item.Count = npc.BaseData.ItemCounts[i];
items.Add(item);
}
}
//corpse.Gold = 200;
corpse.Items = items.ToArray();
}
map.RegisterActor(corpse);
npc.Status.CorpseActorID = corpse.ActorID;
Tasks.Actor.CorpseDeleteTask task = new Tasks.Actor.CorpseDeleteTask(npc.BaseData.CorpseItemID > 0 ? 20000 : 10000, corpse);
task.Activate();
foreach (NPCDeathSpawn i in npc.BaseData.DeathSpawns)
{
for (int j = 0; j < i.Count; j++)
{
short x = (short)Global.Random.Next(npc.X - 15, npc.X + 15);
short y = (short)Global.Random.Next(npc.Y - 15, npc.Y + 15);
short z = (short)npc.Z;
Scripting.Utils.SpawnNPC(map, i.NPCID, i.AppearEffect, x, y, z, 0, i.Motion);
}
}
firstAttacker = null;
}
public void ComposeBaGua(CM_COMPOSE_BAGUA p)
{
Common.Item.Item primary = chara.Inventory.Container[Containers.Inventory][p.PrimarySlot];
Common.Item.Item secondary = chara.Inventory.Container[Containers.Inventory][p.SecondarySlot];
Stats stat = Utils.FindStat(p.Stat);
if (primary != null && secondary != null)
{
if (primary.BaseData.ItemType == ItemType.Bagua && secondary.BaseData.ItemType == ItemType.Bagua)
{
if (primary.BaseData.SecondaryStats.ContainsKey(stat) && secondary.BaseData.PrimaryStats.ContainsKey(stat))
{
Dictionary <Common.Item.Item, ushort> update = new Dictionary <Common.Item.Item, ushort>();
Common.Item.Item add;
ushort total = 0;
bool pass;
foreach (KeyValuePair <ushort, ushort> i in p.ExchangeItems)
{
add = Character.Inventory.Container[Containers.Inventory][i.Key];
if (add != null)
{
if (add.Count >= i.Value && add.ItemID == primary.BaseData.BaGuaPowderId)
{
update.Add(add, i.Value);
total += i.Value;
}
else
{
break;
}
}
}
if (total == primary.BaseData.BaGuaPowderCount)
{
pass = BaGuaSuccess(primary, secondary);
update.Add(secondary, secondary.Count);
RemoveItemsBySlot(update);
if (pass)
{
Common.Item.Item remove = new Common.Item.Item(primary.BaseData)
{
Synthesis = primary.Synthesis
};
primary.Synthesis = p.Stat;
List <Common.Item.Item> items = new List <Common.Item.Item>();
items.Add(primary);
CharacterSession.Instance.SaveItem(primary);
SM_ITEM_INFO r = new SM_ITEM_INFO()
{
Reason = Item.ItemUpdateMethod.Synthesis,
Items = items
};
Network.SendPacket(r);
/*if (primary.InventoryEquipSlot != InventoryEquipSlot.None)
* {
* PC.Status.EquipItem(chara, remove,false);
* PC.Status.EquipItem(chara, primary,true);
* PC.Status.CalcStatus(chara);
* SendPlayerEquiptStats(primary, Utils.FindStat(remove.Synthesis));
* }*/
}
else
{
SM_COMPOSE_BAGUA_FAIL r = new SM_COMPOSE_BAGUA_FAIL()
{
Code = 0x148
};
Network.SendPacket(r);
}
}
}
}
}
}
public void OnItemSell(CM_ITEM_SELL p)
{
Dictionary <ushort, ushort> items = p.Items;
List <Common.Item.Item> shouldRemove = new List <Common.Item.Item>();
foreach (ushort i in items.Keys)
{
Common.Item.Item review = chara.Inventory.Container[Containers.Inventory][i];
if (review != null)
{
if (review.Count >= items[i] && items[i] > 0 && review.Container == Containers.Inventory)
{
chara.Inventory.RemoveItemSlot(Containers.Inventory, i, items[i], out List <Common.Item.Item> updated, out List <Common.Item.Item> removed);
if (removed.Count > 0)
{
SendItemUpdate(ItemUpdateMethod.Sold, removed);
}
if (updated.Count > 0)
{
SendItemUpdate(ItemUpdateMethod.Sold, updated);
}
uint price = 0;
foreach (Common.Item.Item item in removed)
{
price = item.BaseData.Price;
item.SlotID = 255;
}
CharacterSession.Instance.SaveItem(removed);
foreach (Common.Item.Item item in updated)
{
Common.Item.Item newItem = ItemFactory.Instance.CreateNewItem(item.ItemID);
newItem.CharID = chara.CharID;
newItem.Count = items[i];
newItem.SlotID = 255;
CharacterSession.Instance.CreateItem(newItem);
removed.Add(newItem);
price = newItem.BaseData.Price;
}
price *= items[i];
Interlocked.Add(ref chara.Gold, (int)price);
SendPlayerGold();
foreach (Common.Item.Item item in removed)
{
item.Count = items[i];
lock (chara.Inventory.SoldItems)
{
while (chara.Inventory.SoldItems.Count >= 14)
{
shouldRemove.Add(chara.Inventory.SoldItems[0]);
chara.Inventory.SoldItems.RemoveAt(0);
}
chara.Inventory.SoldItems.Add(item);
}
}
}
else
{
SM_SERVER_MESSAGE r = new SM_SERVER_MESSAGE()
{
MessagePosition = SM_SERVER_MESSAGE.Positions.ChatWindow,
Message = "Bug fixed, better luck next time."
};
Network.SendPacket(r);
}
}
}
if (shouldRemove.Count > 0)
{
CharacterSession.Instance.DeleteItem(shouldRemove);
}
SendItemBuyBackList();
}
public void OnItemSave(Packets.Client.CM_ITEM_SAVE p)
{
Common.Item.Item item = p.Item;
ItemCache.Instance.Save(item.ID, item);
}
