public int GetItemCount(Noun itemType, InventorySlotType slotType, Observer perspective)
{
int stack = 0;
if (slotType == InventorySlotType.NORMAL)
{
foreach (InventoryItemData iid in items.Values)
{
if (itemType.IsA(iid.EquipmentInstance.gameObject, perspective) > 0f)
{
stack += iid.EquipmentInstance.CurrentStack;
}
}
return(stack);
}
foreach (EquipmentSlot es in slotData)
{
if (es.SlotType == slotType)
{
InventoryItemData iid = GetItem(es.coordinate);
if (itemType.IsA(iid.EquipmentInstance.gameObject, perspective) > 0f)
{
stack += iid.EquipmentInstance.CurrentStack;
}
}
}
return(stack);
}
public InventoryItemRemoveEvent(Entity entity, Inventory inventory, InventorySlotType slot, Item item)
{
Entity = entity;
Inventory = inventory;
Slot = slot;
Item = item;
}
public Item GetItem(InventorySlotType slot)
{
Item result;
items.TryGetValue(slot, out result);
return(result);
}
/// <summary>
/// Get the object which is in oCreature's specified inventory slot
/// - nInventorySlot: INVENTORY_SLOT_*
/// - oCreature
/// * Returns OBJECT_INVALID if oCreature is not a valid creature or there is no
/// item in nInventorySlot.
/// </summary>
public static uint GetItemInSlot(InventorySlotType nInventorySlot, uint oCreature = OBJECT_INVALID)
{
Internal.NativeFunctions.StackPushObject(oCreature);
Internal.NativeFunctions.StackPushInteger(nInventorySlot.InternalValue);
Internal.NativeFunctions.CallBuiltIn(155);
return(Internal.NativeFunctions.StackPopObject());
}
protected virtual void Reset()
{
id = (uint)((Guid.NewGuid().GetHashCode() ^ DateTime.UtcNow.Millisecond) + int.MaxValue + 1);
nameId = Guid.NewGuid().ToString();
avatar = null;
inventorySlot = InventorySlotType.None;
stackable = false;
}
public void ResetValues()
{
this._imagePath = "";
this._index = -1;
this._indexSlot = -1;
this._inventorySlotType = InventorySlotType.None;
this._equippedInSlot = EquippedInSlot.None;
}
public Inventory this[InventorySlotType inv]
{
get
{
int num = (int)inv;
return(base.ReadObject <Inventory>((this.ListStart + 8) + (num * 0x10)));
}
}
/// <summary>
/// NPCs only have their default items which may always be used, so no invalidation
/// takes place.
/// </summary>
protected override IAsda2Weapon GetOrInvalidateItem(InventorySlotType slot)
{
switch (slot)
{
case InventorySlotType.WeaponMainHand:
return(m_entry.CreateMainHandWeapon());
}
return(null);
}
public void SetWeapon(InventorySlotType slot, IAsda2Weapon weapon)
{
switch (slot)
{
case InventorySlotType.WeaponMainHand:
MainWeapon = weapon;
break;
}
}
private bool CheckIfEquipmentSlot(InventorySlotType inventorySlotType)
{
switch (inventorySlotType)
{
default: return(true);
case InventorySlotType.Inventory:
return(false);
}
}
public int GetItemCount(Noun itemType, InventorySlotType slotType, Observer perspective)
{
int itemCount = 0;
foreach (InventoryContainer m_container in m_containers.Values)
{
itemCount += m_container.GetItemCount(itemType, slotType, perspective);
}
return(itemCount);
}
public void AddToInventory(InventorySlotType slotType, EquippedInSlot inSlot, string imagePath, int index)
{
InventorySlotInfo newSlot = _slotsInventoryInfo[_itemsInInventory];
_itemsInInventory++;
newSlot.SetValue(imagePath, slotType, inSlot, index, _itemsInInventory);
_infoItemsInInventory.Add(newSlot);
if (newSlot.InventorySlotType == _inventorySlotShow || _inventorySlotShow == InventorySlotType.All)
{
UpdateUISlots();
}
}
public void SetValue(string image, InventorySlotType inventorySlotType, EquippedInSlot inSlot, int index, int indexSlot)
{
if (_itemImage == null)
{
_itemImage = this.gameObject.GetComponent <Image>();
}
this._imagePath = image;
this._inventorySlotType = inventorySlotType;
this._index = index;
this._indexSlot = indexSlot;
this._equippedInSlot = inSlot;
UpdateSprite();
}
public void EquipItemFromSlot(InventorySlot inventorySlot)
{
Equippable newItem, oldItem;
InventorySlotType inventorySlotType = inventorySlot.item.inventorySlotType;
oldItem = (Equippable)equipmentSlots[(int)inventorySlotType].item;
newItem = (Equippable)inventorySlot.item;
inventorySlot.AssignItemToSlot(equipmentSlots[(int)inventorySlotType]);
if (onEquipmentChanged != null)
{
onEquipmentChanged.Invoke(newItem, oldItem);
}
}
/// <summary>
/// Disarms the weapon of the given type (WeaponMainHand, WeaponRanged or WeaponOffHand)
/// </summary>
public void SetDisarmed(InventorySlotType type)
{
var m = type.ToMask();
if (m_DisarmMask.HasAnyFlag(m))
{
return;
}
m_DisarmMask |= m;
SetWeapon(type, null);
}
/// <summary>
/// Rearms the weapon of the given type (WeaponMainHand, WeaponRanged or WeaponOffHand)
/// </summary>
public void UnsetDisarmed(InventorySlotType type)
{
var m = type.ToMask();
if (!m_DisarmMask.HasAnyFlag(m))
{
return;
}
m_DisarmMask &= ~m;
SetWeapon(type, GetOrInvalidateItem(type));
}
public void UnequipItemFromSlot(InventorySlot inventorySlot)
{
Equippable newItem, oldItem;
InventorySlotType inventorySlotType = inventorySlot.item.inventorySlotType;
oldItem = (Equippable)inventorySlot.item;
Inventory.instance.Add(inventorySlot.item);
inventorySlot.RemoveItem();
newItem = (Equippable)equipmentSlots[(int)inventorySlotType].item;
if (onEquipmentChanged != null)
{
onEquipmentChanged.Invoke(newItem, oldItem);
}
}
public IWeapon GetWeapon(InventorySlotType slot)
{
switch (slot)
{
case InventorySlotType.WeaponMainHand:
return(m_mainWeapon);
case InventorySlotType.WeaponRanged:
return(m_RangedWeapon);
case InventorySlotType.WeaponOffHand:
return(m_offhandWeapon);
}
return(null);
}
/// <summary>
/// This method will load the inventory panel, this means:
/// -Create many slots as the maximum and adding them to a list, and do the same with
/// each inventoryslotinfo of each slot
/// </summary>
public void Initialize()
{
_inventorySlotShow = InventorySlotType.All;
int numSlots = InventoryManager.Instance.MaxItems;
for (int i = 1; i <= numSlots; i++)
{
GameObject go = _contentSlots.transform.GetChild(i - 1).gameObject;
go.name = "Slot-" + i.ToString();
go.SetActive(false);
go.transform.SetParent(_contentSlots.transform);
_slotsInventory.Add(go);
_slotsInventoryInfo.Add(go.GetComponentInChildren <InventorySlotInfo>());
}
}
public bool AddItemAmount(Item item)
{
bool result = false;
InventorySlotType slot = item.ItemInfo.InventorySlot;
if (items[slot] != null &&
items[slot].ItemInfo.Id == item.ItemInfo.Id &&
items[slot].ItemInfo.Stackable == true)
{
items[slot].Amount += item.Amount;
Locator.Get <EntityManager>().Recycle(item.GetComponent <Entity>().Guid);
result = true;
// TODO: trigger Event
}
return(result);
}
public void SetWeapon(InventorySlotType slot, IWeapon weapon)
{
switch (slot)
{
case InventorySlotType.WeaponMainHand:
MainWeapon = weapon;
break;
case InventorySlotType.WeaponRanged:
RangedWeapon = weapon;
break;
case InventorySlotType.WeaponOffHand:
OffHandWeapon = weapon;
break;
}
}
public void Init(InventoryWindow window, InventoryCell inventoryCell,
InventorySlotType _slotType = InventorySlotType.PrevSet)
{
_window = window;
_cell = inventoryCell;
slotType = _slotType == InventorySlotType.PrevSet ? slotType : _slotType;
actionButton[0].gameObject.SetActive(true);
SetupFromCell();
if (_cell != null)
{
_count.gameObject.SetActive(true);
_count.SetText(_cell.amount > 1 ? _cell.amount.ToString() : "");
}
else
{
_count.gameObject.SetActive(false);
}
}
public bool RemoveItem(Item item)
{
bool result = false;
InventorySlotType itemSlot = item.ItemInfo.InventorySlot;
if (items.ContainsKey(itemSlot) && items[itemSlot] != null)
{
Item itemToRemove = items[itemSlot];
itemToRemove.transform.SetParent(null);
itemToRemove.gameObject.SetActive(true);
items[itemSlot] = null;
itemsDirty = true;
result = true;
entity.Events.TriggerEvent(new InventoryItemRemoveEvent(entity, this, itemSlot, item));
}
return(result);
}
public bool AddItem(Item item)
{
bool result = false;
InventorySlotType itemSlot = item.ItemInfo.InventorySlot;
if (items.ContainsKey(itemSlot) && items[itemSlot] != null)
{
throw new ArgumentException(string.Format("Slot already occupied by {0}", items[itemSlot]));
}
else
{
items[itemSlot] = item;
AttachToInventory(item, inventoryContainer);
itemsDirty = true;
result = true;
entity.Events.TriggerEvent(new InventoryItemAddEvent(entity, this, itemSlot, item));
}
return(result);
}
public override void Read(StreamHandler Reader)
{
Caster = Reader.ReadPackedGuid();
CastInvoker = Reader.ReadPackedGuid();
CastId = Reader.ReadByte();
SpellId = Reader.ReadUInt32();
Flags = (CastFlags)Reader.ReadUInt32();
Unk43 = Reader.ReadUInt32();
Unk43_2 = Reader.ReadUInt32();
TargetData.Read(Reader);
if ((Flags & CastFlags.PredictedPower) != 0)
{
PredictedPower = Reader.ReadUInt32();
}
if ((Flags & CastFlags.RuneStates) != 0)
{
RunesBefore = (RuneStates)Reader.ReadByte();
RunesAfter = (RuneStates)Reader.ReadByte();
for (int i = 0; i < RuneCooldowns.Length; ++i)
{
RuneCooldowns[i] = Reader.ReadByte();
}
}
if ((Flags & CastFlags.Ammo) != 0)
{
ProjectileDisplayId = Reader.ReadUInt32();
ProjectileInventoryType = (InventorySlotType)Reader.ReadUInt32();
}
if ((Flags & CastFlags.Unk0x04000000) != 0)
{
Unk0x04000000_UInt32_1 = Reader.ReadUInt32();
Unk0x04000000_UInt32_2 = Reader.ReadUInt32();
}
}
public override void Execute()
{
base.Execute();
MapManager mapManager = Locator.Get <MapManager>();
Inventory inventory = Actor.GetComponent <Inventory>();
Item itemComponent = Item.GetComponent <Item>();
if (inventory != null && itemComponent != null)
{
InventorySlotType slot = itemComponent.ItemInfo.InventorySlot;
Item presentItem = inventory.GetItem(slot);
if (presentItem != null)
{
inventory.RemoveItem(presentItem);
Entity itemEntity = presentItem.GetComponent <Entity>();
mapManager.AddItem(itemEntity, Item.CellTransform.Position);
}
mapManager.RemoveItem(Item, Item.CellTransform.Position);
inventory.AddItem(itemComponent);
}
}
public static EquipmentSlot[] GetEquipmentSlots(InventorySlotType invSlot)
{
return(EquipmentSlotsByInvSlot[(int)invSlot]);
}
/// <summary>
/// Finds the item for the given slot.
/// Unequips it and returns null, if it may not currently be used.
/// </summary>
protected virtual IWeapon GetOrInvalidateItem(InventorySlotType type)
{
return null;
}
/// <summary>
/// Rearms the weapon of the given type (WeaponMainHand, WeaponRanged or WeaponOffHand)
/// </summary>
public void UnsetDisarmed(InventorySlotType type)
{
var m = type.ToMask();
if (!m_DisarmMask.HasAnyFlag(m))
{
return;
}
m_DisarmMask &= ~m;
SetWeapon(type, GetOrInvalidateItem(type));
}
/// <summary>
/// Disarms the weapon of the given type (WeaponMainHand, WeaponRanged or WeaponOffHand)
/// </summary>
public void SetDisarmed(InventorySlotType type)
{
var m = type.ToMask();
if (m_DisarmMask.HasAnyFlag(m))
{
return;
}
m_DisarmMask |= m;
SetWeapon(type, null);
}
public static InventorySlotTypeMask ToMask(this InventorySlotType type)
{
return((InventorySlotTypeMask)
(1 << (int)(type & (InventorySlotType.WeaponRanged | InventorySlotType.Cloak))));
}
public static bool HasAnyFlag(this InventorySlotTypeMask flags, InventorySlotType type)
{
return (flags & type.ToMask()) != 0;
}
public override void Read(StreamHandler Reader)
{
Caster = Reader.ReadPackedGuid();
CastInvoker = Reader.ReadPackedGuid();
CastId = Reader.ReadByte();
SpellId = Reader.ReadUInt32();
Flags = (CastFlags)Reader.ReadUInt32();
Unk43 = Reader.ReadUInt32();
Unk43_2 = Reader.ReadUInt32();
TargetData.Read(Reader);
if ((Flags & CastFlags.PredictedPower) != 0)
PredictedPower = Reader.ReadUInt32();
if ((Flags & CastFlags.RuneStates) != 0)
{
RunesBefore = (RuneStates)Reader.ReadByte();
RunesAfter = (RuneStates)Reader.ReadByte();
for (int i = 0; i < RuneCooldowns.Length; ++i)
RuneCooldowns[i] = Reader.ReadByte();
}
if ((Flags & CastFlags.Ammo) != 0)
{
ProjectileDisplayId = Reader.ReadUInt32();
ProjectileInventoryType = (InventorySlotType)Reader.ReadUInt32();
}
if ((Flags & CastFlags.Unk0x04000000) != 0)
{
Unk0x04000000_UInt32_1 = Reader.ReadUInt32();
Unk0x04000000_UInt32_2 = Reader.ReadUInt32();
}
}
public override void Read(StreamHandler Reader)
{
Caster = Reader.ReadPackedGuid();
CastInvoker = Reader.ReadPackedGuid();
CastId = Reader.ReadByte();
SpellId = Reader.ReadUInt32();
Flags = (CastFlags)Reader.ReadUInt32();
Unk43 = Reader.ReadUInt32();
CastTime = Reader.ReadUInt32();
byte hits = Reader.ReadByte();
Hits.Capacity = hits;
for (byte i = 0; i < hits; ++i)
Hits.Add(Reader.ReadGuid());
byte misses = Reader.ReadByte();
Misses.Capacity = misses;
for (byte i = 0; i < misses; ++i)
{
var miss = new MissData();
miss.Read(Reader);
Misses.Add(miss);
}
TargetData.Read(Reader);
if ((Flags & CastFlags.PredictedPower) != 0)
PredictedPower = Reader.ReadUInt32();
if ((Flags & CastFlags.RuneStates) != 0)
{
RunesBefore = (RuneStates)Reader.ReadByte();
RunesAfter = (RuneStates)Reader.ReadByte();
for (int i = 0; i < RuneCooldowns.Length; ++i)
RuneCooldowns[i] = Reader.ReadByte();
}
if ((Flags & CastFlags.Unk0x00020000) != 0)
{
Unk0x20000_Float = Reader.ReadSingle();
Unk0x20000_UInt32 = Reader.ReadUInt32();
}
if ((Flags & CastFlags.Ammo) != 0)
{
ProjectileDisplayId = Reader.ReadUInt32();
ProjectileInventoryType = (InventorySlotType)Reader.ReadUInt32();
}
if ((Flags & CastFlags.Unk0x00080000) != 0)
{
Unk0x80000_UInt32_1 = Reader.ReadUInt32();
Unk0x80000_UInt32_2 = Reader.ReadUInt32();
}
if ((TargetData.Flags & SpellCastTargetFlags.DestLocation) != 0)
DestLocationCounter = Reader.ReadByte();
if ((TargetData.Flags & SpellCastTargetFlags.Unk4) != 0)
{
uint count = Reader.ReadUInt32();
Unk4_Count = count;
Unk4_List.Capacity = (int)count;
for (uint i = 0; i < count; ++i)
{
Vector3 v3 = Reader.ReadVector3();
WowGuid guid = Reader.ReadGuid();
Unk4_List.Add(new KeyValuePair<WowGuid, Vector3>(guid, v3));
if (guid.IsEmpty)
break;
}
}
}
/// <summary>
/// Finds the item for the given slot. Unequips it if it may not currently be used.
/// Returns the item to be equipped or null, if invalid.
/// </summary>
protected override IWeapon GetOrInvalidateItem(InventorySlotType type)
{
var slot = (int)ItemMgr.EquipmentSlotsByInvSlot[(int)type][0];
var item = m_inventory[slot];
if (item == null)
{
return null;
}
InventoryError err = InventoryError.OK;
m_inventory.Equipment.CheckAdd(slot, 1, item, ref err);
if (err == InventoryError.OK)
{
return item;
}
else
{
item.Unequip();
return null;
}
}
/// <summary>
/// NPCs only have their default items which may always be used, so no invalidation
/// takes place.
/// </summary>
protected override IWeapon GetOrInvalidateItem(InventorySlotType slot)
{
switch (slot)
{
case InventorySlotType.WeaponMainHand:
return m_entry.CreateMainHandWeapon();
case InventorySlotType.WeaponRanged:
return m_entry.CreateRangedWeapon();
case InventorySlotType.WeaponOffHand:
return m_entry.CreateOffhandWeapon();
}
return null;
}
/// <summary>
/// Finds the item for the given slot.
/// Unequips it and returns null, if it may not currently be used.
/// </summary>
protected virtual IWeapon GetOrInvalidateItem(InventorySlotType type)
{
return(null);
}
public static bool HasAnyFlag(this InventorySlotTypeMask flags, InventorySlotType type)
{
return (flags & (InventorySlotTypeMask)(1 << (int)type)) != 0;
}
public IWeapon GetWeapon(InventorySlotType slot)
{
switch (slot)
{
case InventorySlotType.WeaponMainHand:
return m_mainWeapon;
case InventorySlotType.WeaponRanged:
return m_RangedWeapon;
case InventorySlotType.WeaponOffHand:
return m_offhandWeapon;
}
return null;
}
public static bool HasAnyFlag(this InventorySlotTypeMask flags, InventorySlotType type)
{
return((flags & type.ToMask()) != InventorySlotTypeMask.None);
}
public void SetWeapon(InventorySlotType slot, IWeapon weapon)
{
switch (slot)
{
case InventorySlotType.WeaponMainHand:
MainWeapon = weapon;
break;
case InventorySlotType.WeaponRanged:
RangedWeapon = weapon;
break;
case InventorySlotType.WeaponOffHand:
OffHandWeapon = weapon;
break;
}
}
