public void DeleteItem(Item i)
{
switch (i.itemType)
{
case Item.ItemType.Coin:
if (this.Coin > 0)
{
this.Coin--;
}
break;
case Item.ItemType.HealthPotion:
if (Potion > 0)
{
this.Potion--;
}
break;
default:
//Ca partira dans l'inventaire normal
break;
}
OnInventoryChanged?.Invoke(this, EventArgs.Empty);
}
public bool AddItem(Item item)
{
bool canAddItem = GetRoomForItem(item) > 0;
if (canAddItem)
{
List <ItemContainer> itemContainersWithItem = _itemContainers.Where(x => x.Item != null && x.Item.Equals(item) && x.GetRoomForItem(item) > 0).ToList();
if (itemContainersWithItem.Count > 0)
{
foreach (ItemContainer itemContainer in itemContainersWithItem)
{
if (itemContainer.GetRoomForItem(item) > 0)
{
itemContainer.AddItem(item);
OnInventoryChanged?.Invoke(this);
break;
}
}
}
else
{
foreach (ItemContainer itemContainer in _itemContainers.Where(x => x.Item == null))
{
itemContainer.AddItem(item);
OnInventoryChanged?.Invoke(this);
break;
}
}
}
return(canAddItem);
}
public bool addItems(Item[] items)
{
//Check for pre existing inventory cells with the item type
foreach (InventoryCell b in inventoryCells)
{
if (b.items.Count > 0 && b.items[0].itemType == items[0].itemType)
{
foreach (Item c in items)
{
b.addItem(c);
}
OnInventoryChanged.Invoke(this, null);
return(true);
}
}
//Add to empty inventory cell
foreach (InventoryCell b in inventoryCells)
{
if (b.items.Count == 0)
{
foreach (Item c in items)
{
b.addItem(c);
}
OnInventoryChanged.Invoke(this, null);
return(true);
}
}
return(false);
}
public bool addItem(Item item, int amount = 1)
{
//Check for pre existing inventory cells with the item type
foreach (InventoryCell b in inventoryCells)
{
if (b.items.Count > 0 && b.items[0].itemType == item.itemType)
{
if (b.addItem(item, amount))
{
OnInventoryChanged.Invoke(this, null);
return(true);
}
}
}
//Add to empty inventory cell
foreach (InventoryCell b in inventoryCells)
{
if (b.addItem(item, amount))
{
OnInventoryChanged.Invoke(this, null);
return(true);
}
}
return(false);
}
public void clearAll()
{
foreach (InventoryCell b in inventoryCells)
{
b.items.Clear();
}
OnInventoryChanged.Invoke(this, null);
}
public void RemoveItems(IEnumerable <ItemContainer> cs)
{
foreach (ItemContainer c in cs)
{
RemoveItem(c.item, c.itemCount, false);
}
OnInventoryChanged?.Invoke();
}
public void AddItem(Item item)
{
if (!Items.Contains(item))
{
Items.Add(item);
}
OnInventoryChanged?.Invoke();
}
public void InventoryChangedEvent()
{
if (OnInventoryChanged != null)
{
Debug.Log("OnInventoryChanged");
OnInventoryChanged.Invoke();
}
}
public void RemoveItem(int slotNo)
{
if (mInventory.ContainsKey(slotNo))
{
mInventory.Remove(slotNo);
OnInventoryChanged.Invoke(this, new InventoryObject(slotNo));
mSound.Play("Remove");
}
}
public void moveItemCellTo(Inventory inventoryToAddTo, Vector2 dropPoint, InventoryCell inventoryCell)
{
if (inventoryCell.items.Count > 0)
{
//Drop to ground
Game1.currentMap.entityAddQueue.Add(new Drop(inventoryCell.items.ToArray(), new RigidBody(Drop.massesOfPlayer), dropPoint));
inventoryCell.items.Clear();
OnInventoryChanged.Invoke(this, null);
}
}
public Item RemoveItem(int index)
{
Item item = _inventory[index];
_inventory[index] = null;
OnInventoryChanged?.Invoke(index);
return(item);
}
public void AddItemContainers(int quantity)
{
for (int i = 0; i < quantity; i++)
{
_itemContainers.Add(new ItemContainer(this));
}
_capacity = _itemContainers.Count;
OnInventoryChanged?.Invoke(this);
}
public void RemoveItemInstance(Item item)
{
foreach (ItemContainer itemContainer in _itemContainers)
{
if (itemContainer.HasItem(item))
{
itemContainer.RemoveItemInstance(item);
OnInventoryChanged?.Invoke(this);
}
}
}
public bool RemoveItem(Item item)
{
var removed = Items.Remove(item);
if (removed)
{
OnInventoryChanged?.Invoke();
}
return(removed);
}
public void AddItem(InventoryItemRef item, int count = 1)
{
if (items.ContainsKey(item))
{
items[item] += count;
}
else
{
items.Add(item, count);
}
OnInventoryChanged?.Invoke();
}
public void AddItem(InventoryItem item)
{
stringBuilder.Clear();
item.nameLocalized.RegisterChangeHandler(item.UpdateString);
items.Add(item);
stringBuilder.Append(youFoundString);
stringBuilder.Append(" ");
stringBuilder.Append(item.nameString);
OnInventoryChanged.Invoke(stringBuilder.ToString());
}
public void addAllItemsTo(Inventory inventoryToAddTo, Vector2 dropPoint)
{
foreach (InventoryCell b in inventoryCells)
{
if (b.items.Count > 0)
{
Game1.currentMap.entityAddQueue.Add(new Drop(b.items.ToArray(), new RigidBody(Drop.massesOfPlayer), dropPoint));
b.items.Clear();
OnInventoryChanged.Invoke(this, null);
}
}
}
public void UpdateSlot(InventoryKey key, WeaponSlot slot)
{
if (_weapons.ContainsKey(key))
{
_weapons[key] = slot;
}
else
{
_weapons.Add(key, slot);
}
OnInventoryChanged?.Invoke(key);
}
public void UpdateSlot(InventoryKey key, AggregateSlot slot)
{
if (_aggregates.ContainsKey(key))
{
_aggregates[key] = slot;
}
else
{
_aggregates.Add(key, slot);
}
OnInventoryChanged?.Invoke(key);
}
public bool AddItem(int slotNo, CollectableSO item)
{
Predicate <int> slotNoEmpty = sNo => mInventory.ContainsKey(sNo);
if (itemNotNull(item) && slotNoEmpty(slotNo))
{
mInventory.Add(slotNo, item);
OnInventoryChanged.Invoke(this, new InventoryObject(slotNo, item));
mSound.Play("Add");
return(true);
}
return(false);
}
//#################
//## INTERFACE ##
//#################
public bool AddItem(CollectableSO item)
{
int slot = FindNextOpenSlot();
if (itemNotNull(item) && slotAvailable(slot))
{
mInventory.Add(slot, item);
OnInventoryChanged.Invoke(this, new InventoryObject(slot, item));
mSound.Play("Add");
return(true);
}
return(false);
}
public int RemoveItems(Item item, int quantity = 1)
{
int removed = 0;
foreach (ItemContainer itemContainer in _itemContainers.Where(x => x.Item != null && x.Item.Equals(item)))
{
removed += itemContainer.RemoveItems(quantity).Count();
break;
}
OnInventoryChanged?.Invoke(this);
return(removed);
}
public void Awake()
{
controles = new Controles();
controles.PlayerControles.INVENTORY.performed += ctx => OpenCloseInventory();
#region Singleton Test
if (instance != null)
{
Debug.Log("Mais de um Player Inventory na Scene");
return;
}
instance = this;
#endregion
OnEquipChangedCallback += UpdateEquipment;
OnInvChangedCallback += UpdateInventory;
}
public bool RemoveItem(InventoryItemRef item, int count = 1, bool callInventoryChanged = true)
{
int itemCount;
bool result = items.TryGetValue(item, out itemCount) && itemCount >= count;
if (result)
{
itemCount -= count;
if (itemCount == 0)
{
int itemIndex = 0;
foreach (InventoryItemRef r in items.Keys)
{
if (r.Equals(item))
{
break;
}
itemIndex++;
}
if (itemIndex < selectedItemIndex)
{
selectedItemIndex--;
}
else if (selectedItemIndex == itemIndex)
{
UnequipCurrentItem();
}
//if(item == selectedItem)
//{
//}
items.Remove(item);
}
else
{
items[item] = itemCount;
}
if (callInventoryChanged)
{
OnInventoryChanged?.Invoke();
}
}
return(result);
}
public void UseItem(System.Type type)
{
foreach (InventoryItem inventoryItem in items)
{
if (inventoryItem.GetType() == type)
{
items.Remove(inventoryItem);
stringBuilder.Clear();
stringBuilder.Append(youUsedString);
stringBuilder.Append(" ");
stringBuilder.Append(inventoryItem.nameString);
OnInventoryChanged.Invoke(stringBuilder.ToString());
return;
}
}
}
//items
public void SetItem(Item item, int index)
{
if (item == null)
{
Debug.LogWarning("Setting null item!\n\n" + new NullReferenceException().StackTrace);
return;
}
if (index > _inventory.Length - 1)
{
Debug.LogWarning("Index out of range when attempting to set inventory item!" + new IndexOutOfRangeException().StackTrace);
return;
}
_inventory[index]?.OnDropped();
_inventory[index] = item;
OnInventoryChanged?.Invoke(index);
}
public bool RemoveItemContainers(int quantity)
{
if (!CanRemoveItemContainers(quantity))
{
return(false);
}
int max = _itemContainers.Count - quantity;
for (int i = _itemContainers.Count - 1; i >= max; i--)
{
_itemContainers.RemoveAt(i);
}
_capacity = _itemContainers.Count;
OnInventoryChanged?.Invoke(this);
return(true);
}
public void removeItemsFromCraft(ItemType itemCrafted)
{
for (int i = 0; i < itemCrafted.craftingRecipe.GetLength(0); i++)
{
for (int j = 0; j < itemCrafted.craftingRecipe.GetLength(1); j++)
{
if (itemCrafted.craftingRecipe[i, j, 1] != null)
{
for (int p = 0; p < (int)itemCrafted.craftingRecipe[i, j, 0]; p++)
{
if (inventoryCells[i, j].items.Count > 0)
{
inventoryCells[i, j]._items.Remove(inventoryCells[i, j]._items[0]);
}
}
}
}
}
OnInventoryChanged.Invoke(this, null);
}
public bool AddItems(List <Item> items)
{
bool canAddItems = true;
foreach (Item item in items)
{
if (GetRoomForItem(item) == 0)
{
canAddItems = false;
break;
}
}
if (canAddItems)
{
items.ForEach(x => AddItem(x));
}
OnInventoryChanged?.Invoke(this);
return(canAddItems);
}
public void AddItem(Item i)
{
switch (i.itemType)
{
case Item.ItemType.Coin:
this.Coin++;
break;
case Item.ItemType.HealthPotion:
if (Potion < MAX_POTION)
{
this.Potion++;
}
break;
default:
//Ca partira dans l'inventaire normal
break;
}
OnInventoryChanged?.Invoke(this, EventArgs.Empty);
}
