/// <summary>
/// Функция для добавления предмета в инвентарь.
/// </summary>
/// <param name="item"> Предмет, который мы хотим добавить. </param>
/// <returns> Возвращает true, если добавить предмет получилось, иначе возвращает false</returns>
/// <remarks> Ищет либо ячейку с таким же предметом, либо пустую ячейку</remarks>
public bool AttemptAdd(ItemData item)
{
// Индекс первой пустой ячейки в инвентаре
// -1 сигнализирует о том, что пустых ячеек нет
int firstEmptyCellIndex = -1;
for (int i = 0; i < cellNumber; i++)
{
// Если ячейка не пустая
if (!cells[i].IsEmpty())
{
// Если название предмета в текущей ячейке совпадает с названием добавляемого предмета
// И
// Если количество предметов в текущей ячейке меньше максимального, т.е. есть место на ещё 1 такой же предмет
if (cells[i].itemData.name == item.name &&
cells[i].number < cells[i].itemData.maxInInventoryCell)
{
// Добавляем предмет, увеличивая количество предметов
cells[i].number++;
if (onInventoryChangedCallBack != null)
{
onInventoryChangedCallBack.Invoke();
}
// Выходим из функции
return(true);
}
}
// Иначе, получается, что ячейка пустая, и, если мы ни разу не находили пустую ячеку, записываем индекс текущей
else if (firstEmptyCellIndex == -1)
{
firstEmptyCellIndex = i;
}
}
// Дальнейший код выполняется, если не нашли незаполненную ячейку с таким же именем
// Если находили пустую ячейку
if (firstEmptyCellIndex != -1)
{
// Добавляем предмет в неё
cells[firstEmptyCellIndex].itemData = item;
cells[firstEmptyCellIndex].number = 1;
if (onInventoryChangedCallBack != null)
{
onInventoryChangedCallBack.Invoke();
}
return(true);
}
else
{
return(false);
}
}
private void CallbackOLD()
{
if (onInventoryChanged != null)
{
onInventoryChanged.Invoke(); //callback
}
else
{
Debug.LogError("NULL");
}
}
private void Callback()
{
if (onInventoryChanged != null)
{
onInventoryChanged.Invoke(); //callback
}
}
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, 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 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 void AddItem(Item item)
{
if (!Items.Contains(item))
{
Items.Add(item);
}
OnInventoryChanged?.Invoke();
}
public void RemoveItems(IEnumerable <ItemContainer> cs)
{
foreach (ItemContainer c in cs)
{
RemoveItem(c.item, c.itemCount, false);
}
OnInventoryChanged?.Invoke();
}
public void InventoryChangedEvent()
{
if (OnInventoryChanged != null)
{
Debug.Log("OnInventoryChanged");
OnInventoryChanged.Invoke();
}
}
public void clearAll()
{
foreach (InventoryCell b in inventoryCells)
{
b.items.Clear();
}
OnInventoryChanged.Invoke(this, null);
}
public void RemoveItem(int slotNo)
{
if (mInventory.ContainsKey(slotNo))
{
mInventory.Remove(slotNo);
OnInventoryChanged.Invoke(this, new InventoryObject(slotNo));
mSound.Play("Remove");
}
}
public void AddItemContainers(int quantity)
{
for (int i = 0; i < quantity; i++)
{
_itemContainers.Add(new ItemContainer(this));
}
_capacity = _itemContainers.Count;
OnInventoryChanged?.Invoke(this);
}
public Item RemoveItem(int index)
{
Item item = _inventory[index];
_inventory[index] = null;
OnInventoryChanged?.Invoke(index);
return(item);
}
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 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(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 AddItem(InventoryItemRef item, int count = 1)
{
if (items.ContainsKey(item))
{
items[item] += count;
}
else
{
items.Add(item, count);
}
OnInventoryChanged?.Invoke();
}
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 uint Add(string name, uint count)
{
uint had = Count(name);
if (IsFull)
{
return(had);
}
count = (uint)Mathf.Min((int)(maxItemCount - ItemCount), (int)count);
uint have = had + count;
ItemCount += count;
Items[name] = have;
onItemChanged?.Invoke(name, had, have);
onInventoryChanged?.Invoke();
return(have);
}
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 void AddItem(Item item, int amount)
{
if (IsInventoryFull() && !item.stackable)
{
Debug.Log("Inventory is full");
return;
}
if (item.stackable && items.Contains(item))
{
//Add more amount on top of the existing item.
items.Find(i => i == item).amount += amount;
}
else
{
item.amount = amount;
items.Add(item);
}
if (onInventoryChangedCallBack != null)
{
onInventoryChangedCallBack.Invoke();
}
}
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 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);
}
public static void Add(Item item, float stack)
{
ItemStack tempItem = items.Find(x => x.item == item);
if (tempItem != null)
{
for (int i = 0; i < items.Count; i++)
{
if (items[i].item == item)
{
items[i].stacks += stack;
}
}
}
else
{
items.Add(new ItemStack(item, stack));
}
if (OnInventoryChangedCallback != null)
{
OnInventoryChangedCallback.Invoke();
}
}
//#################
//## 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 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;
}
}
}