public Inventory(int slotCount)
{
Slots = slotCount;
InitializeSlots();
ItemPickup += (item) => InventoryChanged?.Invoke();
}
public bool Remove(Item item)
{
bool result = _items.Remove(item);
InventoryChanged?.Invoke();
return(result);
}
public void RemoveItem(Item item)
{
Items.Remove(item);
FilledSlots -= item.Template.AmountOfSlotsOccuoied;
InventoryChanged?.Invoke();
Debug.Log("Убрал предмет из инвентаря " + item.Template.ItemName);
}
public InventoryObserver()
{
// ReSharper disable HeapView.ClosureAllocation HeapView.DelegateAllocation
// ReSharper disable once ConvertToLocalFunction
Action <MyInventoryBase> invChanged = inv => InventoryChanged?.Invoke();
_unregisterComponent = x =>
{
var inv = x as MyInventoryBase;
if (inv == null)
{
return;
}
_inventories.Remove(inv.SubtypeId);
inv.ContentsChanged -= invChanged;
InventoryChanged?.Invoke();
};
_registerComponent = x =>
{
var inv = x as MyInventoryBase;
if (inv == null)
{
return;
}
if (_inventories.TryGetValue(inv.InventoryId, out var curr))
{
_unregisterComponent(curr);
}
_inventories[inv.InventoryId] = inv;
inv.ContentsChanged += invChanged;
InventoryChanged?.Invoke();
};
// ReSharper restore HeapView.ClosureAllocation HeapView.DelegateAllocation
}
private void Object_CollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
{
if (InventoryChanged != null)
{
InventoryChangedEventArgs eventArgs = new InventoryChangedEventArgs(this);
InventoryChanged.Invoke(this, eventArgs);
}
}
public void SetItems(IEnumerable <ushort> items)
{
using (TimedLock.Lock(_invLock))
{
var oItems = _items.GetItems();
_items.SetItems(ConvertObjectType2ItemArray(items));
InventoryChanged?.Invoke(this, new InventoryChangedEventArgs(oItems, _items.GetItems()));
}
}
public void SetItems(Item[] items)
{
using (TimedLock.Lock(_invLock))
{
var oItems = _items.GetItems();
_items.SetItems(items);
InventoryChanged?.Invoke(this, new InventoryChangedEventArgs(oItems, _items.GetItems()));
}
}
public void Add(Item item)
{
if (Full)
{
throw new Exception($"Tried to add {item.Name} to the inventory of {gameObject.name}, while it's full");
}
_items.Add(item);
InventoryChanged?.Invoke();
}
public bool Use(ItemType type)
{
if (Items[type] <= 0)
{
return(false); // Inventory does not contain this item
}
Items[type] = Items[type] - 1;
InventoryChanged?.Invoke(InventoryEvents.InventoryChangedEventType.ItemUsed, type);
return(true);
}
public IItem TryPopItem(int index)
{
if (index < 0 || index >= _capacity)
{
return(null);
}
var result = Items[index];
Items[index] = null;
InventoryChanged?.Invoke();
return(result);
}
// Start is called before the first frame update
void Start()
{
SceneLoader.LoadGameUIAsync();
Collectable.ItemCollected += OnCollectiblePickedUp;
Door.Opened += OnDoorOpen;
PlayerController.PlayerDied += OnPlayerDeath;
SceneLoader.sceneFinishedLoading += EndSceneTransition;
SceneManager.activeSceneChanged += OnSceneChanged;
InventoryUpdateType[] t = { InventoryUpdateType.ALL };
InventoryChanged?.Invoke(_playerInventory);
}
private void OnPlayerDeath(Vector2 position)
{
if (_playerInventory.lives > 1)
{
_playerInventory.lives--;
InventoryChanged?.Invoke(_playerInventory);
StartCoroutine(Co_ResetScene());
}
else
{
StartCoroutine(Co_ProcessGameOver());
}
}
public void RemoveItem(IItem selectedItem)
{
foreach (var slot in ItemStacks)
{
if (slot.Item != selectedItem)
{
continue;
}
slot.Count--;
InventoryChanged?.Invoke();
break;
}
}
public Item this[int index]
{
get { return(items[index]); }
set
{
if (items[index] != value)
{
var e = new InventoryChangedEventArgs(index, items[index], value);
items[index] = value;
InventoryChanged?.Invoke(this, e);
}
}
}
public bool AddItem(Item item)
{
bool result = false;
if (FilledSlots + item.Template.AmountOfSlotsOccuoied < Size)
{
FilledSlots += item.Template.AmountOfSlotsOccuoied;
Items.Add(item);
result = true;
InventoryChanged?.Invoke();
Debug.Log("Добавил предмет в инвентарь " + item.Template.ItemName);
}
return(result);
}
public bool TryPutItem(IItem item)
{
if (_capacity == Count)
{
return(false);
}
for (var i = 0; i < _capacity; i++)
{
if (Items[i] == null)
{
Items[i] = item;
break;
}
}
InventoryChanged?.Invoke();
return(true);
}
public void AddItem(ushort blockId, int amount)
{
int remainingAmount = amount;
while ((_InternalHotbar.Count
<= HotbarController.MAXIMUM_HOTBAR_STACKS) && /* todo remove this, make it more... dynamic */
(remainingAmount > 0))
{
ItemStack itemStack = GetFirstNonFullItemStackWithId(blockId);
if (itemStack == default)
{
itemStack = new ItemStack(0, blockId);
if (_InternalHotbar.Count <= HotbarController.MAXIMUM_HOTBAR_STACKS)
{
itemStack.InventoryIndex = _InternalHotbar.Count;
_InternalHotbar.Add(itemStack);
HotbarChanged?.Invoke(this,
new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, itemStack,
_InternalHotbar.Count));
}
else
{
_InternalInventory.Add(itemStack);
InventoryChanged?.Invoke(this,
new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, itemStack,
HotbarController.MAXIMUM_HOTBAR_STACKS + _InternalInventory.Count));
}
}
if (HotbarContainsNonMaxStackOf(blockId))
{
int consumedAmount = itemStack.AllocateAmount(remainingAmount);
remainingAmount -= consumedAmount;
HotbarChanged?.Invoke(this,
new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Move, itemStack,
itemStack.InventoryIndex, itemStack.InventoryIndex));
}
}
}
public Item this[int index]
{
get
{
using (TimedLock.Lock(_invLock))
{
return(_items[index]);
}
}
set
{
using (TimedLock.Lock(_invLock))
{
if (_items[index] != value)
{
var oItems = _items.GetItems();
_items[index] = value;
InventoryChanged?.Invoke(this, new InventoryChangedEventArgs(oItems, _items.GetItems()));
}
}
}
}
private void OnCollectiblePickedUp(Collectable item)
{
item.UpdateInventory(_playerInventory);
InventoryChanged?.Invoke(_playerInventory);
}
private void OnInventoryChanged()
{
InventoryChanged?.Invoke(this.unit);
}
public void SetItems(Item[] items)
{
this.items = items;
InventoryChanged?.Invoke(this, new InventoryChangedEventArgs(-1, null, null));
}
public bool Pickup(ItemType type)
{
Items[type] = Items[type] + 1;
InventoryChanged?.Invoke(InventoryEvents.InventoryChangedEventType.ItemPickedUp, type);
return(true);
}
public static void OnInventoryChanged(InventoryItemType type, string id, int count)
{
InventoryChanged?.Invoke(type, id, count);
}
internal static void InvokeInventoryChanged(List <Item> inventory, List <ItemStackChange> changedItems)
{
InventoryChanged.Invoke(null, new EventArgsInventoryChanged(inventory, changedItems));
}
internal void AddItem(ItemData item)
{
print("Adding Inventory Item: " + item.name);
_inventory.Add(item);
InventoryChanged?.Invoke(this, new InventoryChangeEventArgs(CollectionChangeAction.Add, item));
}
internal void RemoveItem(ItemData item)
{
print("Removing Inventory Item: " + item.name);
_inventory.Remove(item);
InventoryChanged?.Invoke(this, new InventoryChangeEventArgs(CollectionChangeAction.Remove, item));
}
private void OnTryPickUp(ItemInteraction item)
{
collectedItems.Add(item.GetItemType());
InventoryChanged?.Invoke();
}
public void OnInventoryChanged()
{
InventoryChanged?.Invoke(this, EventArgs.Empty);
}
private void OnInventoryChanged(InventoryChangeArgs e) => InventoryChanged?.Invoke(this, e);
