public void Equip(ushort slot, InventoryItem item)
{
if (slot >= list.Length)
{
return;
}
if (writeToDB)
{
Database.equipItem(owner, slot, item.uniqueId);
}
owner.queuePacket(InventoryBeginChangePacket.buildPacket(owner.actorId));
if (list[slot] != null)
{
normalInventory.RefreshItem(list[slot], item);
}
else
{
normalInventory.RefreshItem(item);
}
owner.queuePacket(InventorySetBeginPacket.buildPacket(owner.actorId, inventoryCapacity, inventoryCode));
SendEquipmentPackets(slot, item);
owner.queuePacket(InventorySetEndPacket.buildPacket(owner.actorId));
owner.queuePacket(InventoryEndChangePacket.buildPacket(owner.actorId));
list[slot] = item;
}
public void AddItem(uint[] itemId)
{
if (!IsSpaceForAdd(itemId[0], itemId.Length))
{
return;
}
//Update lists and db
owner.QueuePacket(InventoryBeginChangePacket.BuildPacket(owner.actorId));
owner.QueuePacket(InventorySetBeginPacket.BuildPacket(owner.actorId, inventoryCapacity, inventoryCode));
int startPos = list.Count;
//New item that spilled over
for (int i = 0; i < itemId.Length; i++)
{
ItemData gItem = Server.GetItemGamedata(itemId[i]);
InventoryItem addedItem = Database.AddItem(owner, itemId[i], 1, (byte)1, gItem.isExclusive ? (byte)0x3 : (byte)0x0, gItem.durability, inventoryCode);
list.Add(addedItem);
}
SendInventoryPackets(startPos);
owner.QueuePacket(InventorySetEndPacket.BuildPacket(owner.actorId));
owner.QueuePacket(InventoryEndChangePacket.BuildPacket(owner.actorId));
}
public void Unequip(ushort slot)
{
if (slot >= list.Length)
{
return;
}
if (writeToDB)
{
Database.UnequipItem(owner, slot);
}
owner.QueuePacket(InventoryBeginChangePacket.BuildPacket(owner.actorId));
normalInventory.RefreshItem(list[slot]);
owner.QueuePacket(InventorySetBeginPacket.BuildPacket(owner.actorId, inventoryCapacity, inventoryCode));
SendEquipmentPackets(slot, null);
owner.QueuePacket(InventorySetEndPacket.BuildPacket(owner.actorId));
owner.QueuePacket(InventoryEndChangePacket.BuildPacket(owner.actorId));
list[slot] = null;
owner.RecalculateStats();
}
public void RemoveItemByUniqueId(ulong itemDBId)
{
ushort slot = 0;
InventoryItem toDelete = null;
foreach (InventoryItem item in list)
{
if (item.uniqueId == itemDBId)
{
toDelete = item;
break;
}
slot++;
}
if (toDelete == null)
{
return;
}
int oldListSize = list.Count;
list.RemoveAt(slot);
Database.RemoveItem(owner, itemDBId, inventoryCode);
//Realign slots
for (int i = slot; i < list.Count; i++)
{
list[i].slot = (ushort)i;
}
owner.QueuePacket(InventoryBeginChangePacket.BuildPacket(owner.actorId));
owner.QueuePacket(InventorySetBeginPacket.BuildPacket(owner.actorId, inventoryCapacity, inventoryCode));
SendInventoryPackets(slot);
SendInventoryRemovePackets(slot);
if (slot != oldListSize - 1)
{
SendInventoryRemovePackets((ushort)(oldListSize - 1));
}
owner.QueuePacket(InventorySetEndPacket.BuildPacket(owner.actorId));
if (inventoryCode == NORMAL)
{
owner.GetEquipment().SendFullEquipment(false);
}
owner.QueuePacket(InventoryEndChangePacket.BuildPacket(owner.actorId));
}
public void examinePlayer(Actor examinee)
{
Player toBeExamined;
if (examinee is Player)
{
toBeExamined = (Player)examinee;
}
else
{
return;
}
queuePacket(InventoryBeginChangePacket.buildPacket(toBeExamined.actorId, actorId));
toBeExamined.getEquipment().SendCheckEquipmentToPlayer(this);
queuePacket(InventoryEndChangePacket.buildPacket(toBeExamined.actorId, actorId));
}
public void RemoveItemAtSlot(ushort slot)
{
if (slot >= list.Count)
{
return;
}
int oldListSize = list.Count;
list.RemoveAt((int)slot);
Database.RemoveItem(owner, slot, inventoryCode);
//Realign slots
for (int i = slot; i < list.Count; i++)
{
list[i].slot = (ushort)i;
}
owner.QueuePacket(InventoryBeginChangePacket.BuildPacket(owner.actorId));
owner.QueuePacket(InventorySetBeginPacket.BuildPacket(owner.actorId, inventoryCapacity, inventoryCode));
SendInventoryPackets(slot);
SendInventoryRemovePackets(slot);
if (slot != oldListSize - 1)
{
SendInventoryRemovePackets((ushort)(oldListSize - 1));
}
owner.QueuePacket(InventorySetEndPacket.BuildPacket(owner.actorId));
if (inventoryCode == NORMAL)
{
owner.GetEquipment().SendFullEquipment(false);
}
owner.QueuePacket(InventoryEndChangePacket.BuildPacket(owner.actorId));
}
public void SetEquipment(ushort[] slots, ushort[] itemSlots)
{
if (slots.Length != itemSlots.Length)
{
return;
}
for (int i = 0; i < slots.Length; i++)
{
InventoryItem item = normalInventory.getItemBySlot(itemSlots[i]);
if (item == null)
{
continue;
}
Database.equipItem(owner, slots[i], item.uniqueId);
list[slots[i]] = normalInventory.getItemBySlot(itemSlots[i]);
}
owner.queuePacket(InventoryBeginChangePacket.buildPacket(owner.actorId));
SendFullEquipment(false);
owner.queuePacket(InventoryEndChangePacket.buildPacket(owner.actorId));
}
public void RemoveItem(uint itemId, int quantity)
{
if (!HasItem(itemId, quantity))
{
return;
}
List <ushort> slotsToUpdate = new List <ushort>();
List <InventoryItem> itemsToRemove = new List <InventoryItem>();
List <ushort> slotsToRemove = new List <ushort>();
List <SubPacket> AddItemPackets = new List <SubPacket>();
//Remove as we go along
int quantityCount = quantity;
ushort lowestSlot = 0;
for (int i = list.Count - 1; i >= 0; i--)
{
InventoryItem item = list[i];
if (item.itemId == itemId)
{
int oldQuantity = item.quantity;
//Stack nomnomed
if (item.quantity - quantityCount <= 0)
{
itemsToRemove.Add(item);
slotsToRemove.Add(item.slot);
}
else
{
slotsToUpdate.Add(item.slot);
item.quantity -= quantityCount; //Stack reduced
}
quantityCount -= oldQuantity;
lowestSlot = item.slot;
if (quantityCount <= 0)
{
break;
}
}
}
for (int i = 0; i < slotsToUpdate.Count; i++)
{
Database.SetQuantity(owner, slotsToUpdate[i], inventoryCode, list[slotsToUpdate[i]].quantity);
}
int oldListSize = list.Count;
for (int i = 0; i < itemsToRemove.Count; i++)
{
Database.RemoveItem(owner, itemsToRemove[i].uniqueId, inventoryCode);
list.Remove(itemsToRemove[i]);
}
//Realign slots
for (int i = lowestSlot; i < list.Count; i++)
{
list[i].slot = (ushort)i;
}
//Added tail end items that need to be cleared for slot realignment
for (int i = oldListSize - 1; i >= oldListSize - itemsToRemove.Count; i--)
{
if (!slotsToRemove.Contains((ushort)i))
{
slotsToRemove.Add((ushort)i);
}
}
owner.QueuePacket(InventoryBeginChangePacket.BuildPacket(owner.actorId));
owner.QueuePacket(InventorySetBeginPacket.BuildPacket(owner.actorId, inventoryCapacity, inventoryCode));
SendInventoryPackets(lowestSlot);
SendInventoryRemovePackets(slotsToRemove);
owner.QueuePacket(InventorySetEndPacket.BuildPacket(owner.actorId));
if (inventoryCode == NORMAL)
{
owner.GetEquipment().SendFullEquipment(false);
}
owner.QueuePacket(InventoryEndChangePacket.BuildPacket(owner.actorId));
}
public bool AddItem(uint itemId, int quantity, byte quality)
{
if (!IsSpaceForAdd(itemId, quantity))
{
return(false);
}
ItemData gItem = Server.GetItemGamedata(itemId);
List <ushort> slotsToUpdate = new List <ushort>();
List <SubPacket> addItemPackets = new List <SubPacket>();
if (gItem == null)
{
Program.Log.Error("Inventory.AddItem: unable to find item %u", itemId);
return(false);
}
//Check if item id exists
int quantityCount = quantity;
for (int i = 0; i < list.Count; i++)
{
InventoryItem item = list[i];
if (item.itemId == itemId && item.quantity < gItem.maxStack)
{
slotsToUpdate.Add(item.slot);
int oldQuantity = item.quantity;
item.quantity = Math.Min(item.quantity + quantityCount, gItem.maxStack);
quantityCount -= (gItem.maxStack - oldQuantity);
if (quantityCount <= 0)
{
break;
}
}
}
//If it's unique, abort
//if (quantityCount > 0 && storedItem.isUnique)
// return ITEMERROR_UNIQUE;
//If Inventory is full
//if (quantityCount > 0 && isInventoryFull())
// return ITEMERROR_FULL;
//Update lists and db
owner.QueuePacket(InventoryBeginChangePacket.BuildPacket(owner.actorId));
owner.QueuePacket(InventorySetBeginPacket.BuildPacket(owner.actorId, inventoryCapacity, inventoryCode));
//These had their quantities Changed
foreach (ushort slot in slotsToUpdate)
{
Database.SetQuantity(owner, slot, inventoryCode, list[slot].quantity);
if (inventoryCode != CURRENCY && inventoryCode != KEYITEMS)
{
SendInventoryPackets(list[slot]);
}
}
//New item that spilled over
while (quantityCount > 0)
{
InventoryItem addedItem = Database.AddItem(owner, itemId, Math.Min(quantityCount, gItem.maxStack), quality, gItem.isExclusive ? (byte)0x3 : (byte)0x0, gItem.durability, inventoryCode);
list.Add(addedItem);
if (inventoryCode != CURRENCY && inventoryCode != KEYITEMS)
{
SendInventoryPackets(addedItem);
}
quantityCount -= gItem.maxStack;
}
if (inventoryCode == CURRENCY || inventoryCode == KEYITEMS)
{
SendFullInventory();
}
owner.QueuePacket(InventorySetEndPacket.BuildPacket(owner.actorId));
owner.QueuePacket(InventoryEndChangePacket.BuildPacket(owner.actorId));
return(true);
}
public void sendZoneInPackets(WorldManager world, ushort spawnType)
{
queuePacket(SetActorIsZoningPacket.buildPacket(actorId, actorId, false));
queuePacket(_0x10Packet.buildPacket(actorId, 0xFF));
queuePacket(SetMusicPacket.buildPacket(actorId, zone.bgmDay, 0x01));
queuePacket(SetWeatherPacket.buildPacket(actorId, SetWeatherPacket.WEATHER_CLEAR, 1));
queuePacket(SetMapPacket.buildPacket(actorId, zone.regionId, zone.actorId));
queuePacket(getSpawnPackets(actorId, spawnType));
getSpawnPackets(actorId, spawnType).debugPrintPacket();
#region grouptest
//Retainers
List <ListEntry> retainerListEntries = new List <ListEntry>();
retainerListEntries.Add(new ListEntry(actorId, 0xFFFFFFFF, 0x139E, false, true, customDisplayName));
retainerListEntries.Add(new ListEntry(0x23, 0x0, 0xFFFFFFFF, false, false, "TEST1"));
retainerListEntries.Add(new ListEntry(0x24, 0x0, 0xFFFFFFFF, false, false, "TEST2"));
retainerListEntries.Add(new ListEntry(0x25, 0x0, 0xFFFFFFFF, false, false, "TEST3"));
BasePacket retainerListPacket = BasePacket.createPacket(ListUtils.createRetainerList(actorId, 0xF4, 1, 0x800000000004e639, retainerListEntries), true, false);
playerSession.queuePacket(retainerListPacket);
//Party
List <ListEntry> partyListEntries = new List <ListEntry>();
partyListEntries.Add(new ListEntry(actorId, 0xFFFFFFFF, 0xFFFFFFFF, false, true, customDisplayName));
partyListEntries.Add(new ListEntry(0x029B27D3, 0xFFFFFFFF, 0x195, false, true, "Valentine Bluefeather"));
BasePacket partyListPacket = BasePacket.createPacket(ListUtils.createPartyList(actorId, 0xF4, 1, 0x8000000000696df2, partyListEntries), true, false);
playerSession.queuePacket(partyListPacket);
#endregion
#region Inventory & Equipment
queuePacket(InventoryBeginChangePacket.buildPacket(actorId));
inventories[Inventory.NORMAL].sendFullInventory();
inventories[Inventory.CURRENCY].sendFullInventory();
inventories[Inventory.KEYITEMS].sendFullInventory();
inventories[Inventory.BAZAAR].sendFullInventory();
inventories[Inventory.MELDREQUEST].sendFullInventory();
inventories[Inventory.LOOT].sendFullInventory();
equipment.SendFullEquipment(false);
playerSession.queuePacket(InventoryEndChangePacket.buildPacket(actorId), true, false);
#endregion
playerSession.queuePacket(getInitPackets(actorId));
BasePacket areaMasterSpawn = zone.getSpawnPackets(actorId);
BasePacket debugSpawn = world.GetDebugActor().getSpawnPackets(actorId);
BasePacket worldMasterSpawn = world.GetActor().getSpawnPackets(actorId);
BasePacket weatherDirectorSpawn = new WeatherDirector(this, 8003).getSpawnPackets(actorId);
BasePacket directorSpawn = null;
if (currentDirector != null)
{
directorSpawn = currentDirector.getSpawnPackets(actorId);
}
playerSession.queuePacket(areaMasterSpawn);
playerSession.queuePacket(debugSpawn);
if (directorSpawn != null)
{
//directorSpawn.debugPrintPacket();
// currentDirector.getInitPackets(actorId).debugPrintPacket();
queuePacket(directorSpawn);
queuePacket(currentDirector.getInitPackets(actorId));
//queuePacket(currentDirector.getSetEventStatusPackets(actorId));
}
playerSession.queuePacket(worldMasterSpawn);
if (zone.isInn)
{
SetCutsceneBookPacket cutsceneBookPacket = new SetCutsceneBookPacket();
for (int i = 0; i < 2048; i++)
{
cutsceneBookPacket.cutsceneFlags[i] = true;
}
SubPacket packet = cutsceneBookPacket.buildPacket(actorId, "<Path Companion>", 11, 1, 1);
packet.debugPrintSubPacket();
queuePacket(packet);
}
playerSession.queuePacket(weatherDirectorSpawn);
/*
#region hardcode
* BasePacket reply10 = new BasePacket("./packets/login/login10.bin"); //Item Storage, Inn Door created
* BasePacket reply11 = new BasePacket("./packets/login/login11.bin"); //NPC Create ??? Final init
* reply10.replaceActorID(actorId);
* reply11.replaceActorID(actorId);
* //playerSession.queuePacket(reply10);
* // playerSession.queuePacket(reply11);
#endregion
*/
}