/// <summary>
/// Catches MMInventoryEvents and displays details if needed
/// </summary>
/// <param name="inventoryEvent">Inventory event.</param>
public override void OnMMEvent(MMInventoryEvent inventoryEvent)
{
if (multiInventory == false)
{
// if this event doesn't concern our inventory display, we do nothing and exit
if (inventoryEvent.TargetInventoryName != this.TargetInventoryName)
{
return;
}
}
else
{
foreach (string disabledInv in disabledInventories)
{
if (inventoryEvent.TargetInventoryName == disabledInv)
{
return;
}
}
}
switch (inventoryEvent.InventoryEventType)
{
case MMInventoryEventType.Select:
DisplayDetails(inventoryEvent.EventItem);
break;
case MMInventoryEventType.InventoryOpens:
DisplayDetails(inventoryEvent.EventItem);
break;
}
}
/// <summary>
/// Picks this item and adds it to the target inventory specified as a parameter
/// </summary>
/// <param name="targetInventoryName">Target inventory name.</param>
public virtual void Pick(string targetInventoryName)
{
FindTargetInventory(targetInventoryName);
if (_targetInventory == null)
{
return;
}
if (!Pickable())
{
PickFail();
return;
}
DetermineMaxQuantity();
if (!Application.isPlaying)
{
_targetInventory.AddItem(Item, 1);
}
else
{
MMInventoryEvent.Trigger(MMInventoryEventType.Pick, null, Item.TargetInventoryName, Item, _pickedQuantity, 0);
}
if (Item.Pick())
{
Quantity = Quantity - _pickedQuantity;
PickSuccess();
DisableObjectIfNeeded();
}
}
/// <summary>
/// Remove amount of currency item form main inventory even if items are in few places in inventory
/// </summary>
/// <param name="amount"></param>
public virtual void PayForItem(int amount)
{
Dictionary <int, int> currencyItems = GetAllCurrencyItems();
int restToPay = amount;
for (int i = 0; i < currencyItems.Count; i++)
{
int index = currencyItems.ElementAt(i).Key;
int quantity = currencyItems.ElementAt(i).Value;
//we don't have enaugh money using i index item
if ((restToPay - quantity) == 0)
{
mainInventory.Content[index] = null;
MMInventoryEvent.Trigger(MMInventoryEventType.ContentChanged, null, mainInventory.name, null, 0, 0);
return;
}
//we can pay with
else if ((restToPay - quantity) > 0)
{
restToPay -= quantity;
mainInventory.Content[index] = null;
MMInventoryEvent.Trigger(MMInventoryEventType.ContentChanged, null, mainInventory.name, null, 0, 0);
}
else if ((restToPay - quantity) < 0)
{
int newQuantity = quantity - restToPay;
mainInventory.Content[index].Quantity = newQuantity;
MMInventoryEvent.Trigger(MMInventoryEventType.ContentChanged, null, mainInventory.name, null, 0, 0);
return;
}
}
}
/// <summary>
/// Unequip this item if possible.
/// </summary>
public virtual void UnEquip()
{
if (!SlotEnabled)
{
return;
}
MMInventoryEvent.Trigger(MMInventoryEventType.UnEquipRequest, this, ParentInventoryDisplay.TargetInventoryName, ParentInventoryDisplay.TargetInventory.Content[Index], 0, Index);
}
/// <summary>
/// When that slot gets selected (via a mouse over or a touch), triggers an event for other classes to act on
/// </summary>
/// <param name="eventData">Event data.</param>
public override void OnSelect(BaseEventData eventData)
{
base.OnSelect(eventData);
if (ParentInventoryDisplay != null)
{
InventoryItem item = ParentInventoryDisplay.TargetInventory.Content[Index];
MMInventoryEvent.Trigger(MMInventoryEventType.Select, this, ParentInventoryDisplay.TargetInventoryName, item, 0, Index);
}
}
/// <summary>
/// When that slot gets clicked, triggers an event for other classes to act on
/// </summary>
public virtual void SlotClicked()
{
if (ParentInventoryDisplay != null)
{
InventoryItem item = ParentInventoryDisplay.TargetInventory.Content[Index];
MMInventoryEvent.Trigger(MMInventoryEventType.Click, this, ParentInventoryDisplay.TargetInventoryName, item, 0, Index);
// if we're currently moving an object
if (ParentInventoryDisplay.CurrentlyBeingMovedItemIndex != -1)
{
Move();
}
}
}
/// <summary>
/// Populate vendor main inventory based on bool limitedStock. Vendor stock could be unlimited or limited to given quantity
/// </summary>
protected virtual void PopulateVendorInventory()
{
//vendor has limited stock
if (limitedStock)
{
int inventorySize = vendorInventory.Content.Length - 1;
int i = 0;
foreach (VendorContent element in vendorContent)
{
if (i < inventorySize)
{
if (element.Quantity > element.Item.MaximumStack)
{
vendorInventory.Content[i] = element.Item;
vendorInventory.Content[i].Quantity = element.Item.MaximumStack;
}
else
{
vendorInventory.Content[i] = element.Item;
vendorInventory.Content[i].Quantity = element.Quantity;
}
}
else
{
return;
}
i++;
}
}
//vendor has unlimited stock
else
{
int inventorySize = vendorInventory.Content.Length - 1;
int i = 0;
foreach (VendorContent element in vendorContent)
{
if (i < inventorySize)
{
vendorInventory.Content[i] = element.Item;
vendorInventory.Content[i].Quantity = 1;
}
else
{
return;
}
i++;
}
}
MMInventoryEvent.Trigger(MMInventoryEventType.ContentChanged, null, vendorInventory.name, null, 0, 0);
}
/// <summary>
/// Drops this item.
/// </summary>
public virtual void Drop()
{
if (!SlotEnabled)
{
return;
}
if (InventoryItem.IsNull(ParentInventoryDisplay.TargetInventory.Content[Index]))
{
MMInventoryEvent.Trigger(MMInventoryEventType.Error, this, ParentInventoryDisplay.TargetInventoryName, null, 0, Index);
return;
}
if (ParentInventoryDisplay.TargetInventory.Content[Index].Drop())
{
ParentInventoryDisplay.CurrentlyBeingMovedItemIndex = -1;
MMInventoryEvent.Trigger(MMInventoryEventType.Drop, this, ParentInventoryDisplay.TargetInventoryName, ParentInventoryDisplay.TargetInventory.Content[Index], 0, Index);
}
}
/// <summary>
/// Opens storage inventory and display
/// </summary>
public virtual void OpenStorage()
{
InitializeStorageData();
isOpen = true;
if (!File.Exists(_saveFolderName + _saveFileExtension))
{
PopulateStorageInventory();
}
_storageInventory.LoadSavedInventory();
storageInventoryDisplay.gameObject.SetActive(true);
AddStorageDisplayToMainDisplay();
SetupStorageDispaly();
PlayOpenAnimation();
storageInventoryDisplay.SetTargetInventory(_storageInventory);
MMInventoryEvent.Trigger(MMInventoryEventType.Redraw, null, _storageInventory.name, null, 0, 0);
_inputManager.ToggleInventory();
}
/// <summary>
/// Selects the item in this slot for a movement, or moves the currently selected one to that slot
/// This will also swap both objects if possible
/// </summary>
public virtual void Move()
{
if (!SlotEnabled)
{
return;
}
// if we're not already moving an object
if (ParentInventoryDisplay.CurrentlyBeingMovedItemIndex == -1)
{
// if the slot we're on is empty, we do nothing
if (InventoryItem.IsNull(ParentInventoryDisplay.TargetInventory.Content[Index]))
{
MMInventoryEvent.Trigger(MMInventoryEventType.Error, this, ParentInventoryDisplay.TargetInventoryName, null, 0, Index);
return;
}
if (ParentInventoryDisplay.TargetInventory.Content[Index].CanMoveObject)
{
// we change the background image
GetComponent <Image>().sprite = ParentInventoryDisplay.MovedSlotImage;
ParentInventoryDisplay.CurrentlyBeingMovedItemIndex = Index;
}
}
// if we ARE moving an object
else
{
// we move the object to a new slot.
if (!ParentInventoryDisplay.TargetInventory.MoveItem(ParentInventoryDisplay.CurrentlyBeingMovedItemIndex, Index))
{
// if the move couldn't be made (non empty destination slot for example), we play a sound
MMInventoryEvent.Trigger(MMInventoryEventType.Error, this, ParentInventoryDisplay.TargetInventoryName, null, 0, Index);
}
else
{
// if the move could be made, we reset our currentlyBeingMoved pointer
ParentInventoryDisplay.CurrentlyBeingMovedItemIndex = -1;
MMInventoryEvent.Trigger(MMInventoryEventType.Move, this, ParentInventoryDisplay.TargetInventoryName, ParentInventoryDisplay.TargetInventory.Content[Index], 0, Index);
}
}
}
/// <summary>
/// Opens vendor inventory and display
/// </summary>
public virtual void OpenVendor()
{
InitializeVendor();
_inputManager._inVendor = true;
inventoryButtons.SetActive(false);
isOpen = true;
if (_itemDetails != null)
{
_itemDetails.vendorUI.SetActive(true);
}
UpdateVendorItemDisplay();
if (!File.Exists(_saveFolderName + _saveFileExtension))
{
PopulateVendorInventory();
}
vendorInventory.LoadSavedInventory();
vendorInventoryDisplay.gameObject.SetActive(true);
SetupVendorDispaly();
vendorInventoryDisplay.SetTargetInventory(vendorInventory);
MMInventoryEvent.Trigger(MMInventoryEventType.Redraw, null, vendorInventory.name, null, 0, 0);
AddVendorDisplayToMainDisplay();
_inputManager.ToggleInventory();
}
/// <summary>
/// Split item stack in half
/// </summary>
public virtual void SplitItemStack()
{
if (!_inVendor && !_isMoving)
{
Inventory _inventory = CurrentlySelectedInventorySlot.ParentInventoryDisplay.TargetInventory;
int _freeSlots = _inventory.NumberOfFreeSlots;
if (_freeSlots < 1)
{
return;
}
else
{
_slotFrom = CurrentlySelectedInventorySlot;
_indexFrom = _slotFrom.Index;
_inventoryItemFrom = _inventory.Content[_indexFrom];
if (_inventoryItemFrom != null)
{
_quantityFrom = _inventoryItemFrom.Quantity;
if (_quantityFrom > 1)
{
int low = (int)Mathf.Floor(_quantityFrom / 2.0f);
int high = (int)Mathf.Ceil(_quantityFrom / 2.0f);
InventoryItem tmpItemLow = _inventoryItemFrom.Copy();
tmpItemLow.Quantity = low;
InventoryItem tmpItemHigh = _inventoryItemFrom.Copy();
tmpItemHigh.Quantity = high;
int freeSlot = FindFirstFreeSlot(_inventory);
_inventory.Content[_indexFrom] = tmpItemHigh;
_inventory.Content[freeSlot] = tmpItemLow;
MMInventoryEvent.Trigger(MMInventoryEventType.ContentChanged, null, _inventory.name, null, 0, 0);
MMInventoryEvent.Trigger(MMInventoryEventType.ContentChanged, null, _inventory.name, null, 0, 0);
}
}
}
}
}
/// <summary>
/// Fill storage with items based on given config
/// </summary>
protected virtual void PopulateStorageInventory()
{
//we check if we want to use loot
if (useLoot)
{
//we check if loot must be generated randomly
if (randomLoot)
{
int slot = 0;
int lootItems = Random.Range(min: 1, max: randomLootMaxItems);
for (int i = 0; i <= lootItems; i++)
{
// Select a random item from the table
int randomItem = Random.Range(0, lootbox.Count - 1);
// dice a chance from 0 to 100
int randomChance = Random.Range(0, 100);
if (randomChance <= lootbox[randomItem].dropChance)
{
_storageInventory.Content[slot] = lootbox[i].item;
if (lootbox[i].quantity > 1)
{
int rolledQuantity = Random.Range(1, lootbox[i].maxQuantity);
if (rolledQuantity > lootbox[i].item.MaximumStack)
{
rolledQuantity = lootbox[i].item.MaximumStack;
_storageInventory.Content[slot].Quantity = lootbox[i].quantity;
}
}
slot++;
}
}
}
else
{
int inventorySize = _storageInventory.Content.Length - 1;
int i = 0;
foreach (Loot element in lootbox)
{
if (i < inventorySize)
{
if (element.quantity > element.item.MaximumStack)
{
_storageInventory.Content[i] = element.item;
_storageInventory.Content[i].Quantity = element.item.MaximumStack;
}
else
{
_storageInventory.Content[i] = element.item;
_storageInventory.Content[i].Quantity = element.quantity;
}
}
else
{
return;
}
i++;
}
}
MMInventoryEvent.Trigger(MMInventoryEventType.ContentChanged, null, _storageInventory.name, null, 0, 0);
}
}
/// <summary>
/// Buy item or items from vendor
/// </summary>
public virtual void BuyItem()
{
Vendor openedVendor = null;
Vendor[] vendors = FindObjectsOfType <Vendor>();
foreach (Vendor vendor in vendors)
{
if (vendor.enabled && vendor.isOpen)
{
openedVendor = vendor;
}
}
if (openedVendor != null)
{
InventorySlot slot = CurrentlySelectedInventorySlot;
Inventory inventory = slot.ParentInventoryDisplay.TargetInventory;
int index = slot.Index;
InventoryItem item = inventory.Content[index];
InventoryDetailsExtended ide = FindObjectOfType <InventoryDetailsExtended>();
if (ide != null && item != null && ide.disabledItems.Contains(item) == false && (inventory.name == openedVendor.vendorInventory.name || inventory.name == openedVendor.vendorRollBackInventory.name))
{
int quantity = Int32.Parse(ide.vendorQuantity.text);
int price = Int32.Parse(ide.vendorPrice.text);
int cash = openedVendor.GetPlayerCash();
if (cash >= price)
{
int freeSlot = FindFirstFreeSlot(openedVendor.mainInventory);
if (freeSlot != -1)
{
openedVendor.PayForItem(price);
openedVendor.mainInventory.Content[freeSlot] = item.Copy();
openedVendor.mainInventory.Content[freeSlot].Quantity = quantity;
MMInventoryEvent.Trigger(MMInventoryEventType.ContentChanged, null, openedVendor.mainInventory.name, null, 0, 0);
}
if (inventory.name == openedVendor.vendorInventory.name)
{
//vendor has limited stock
if (openedVendor.limitedStock)
{
if (quantity < item.Quantity)
{
item.Quantity -= quantity;
}
else
{
openedVendor.vendorInventory.DestroyItem(index);
}
MMInventoryEvent.Trigger(MMInventoryEventType.ContentChanged, null, openedVendor.vendorInventory.name, null, 0, 0);
}
}
else if (inventory.name == openedVendor.vendorRollBackInventory.name)
{
if (quantity < item.Quantity)
{
item.Quantity -= quantity;
}
else
{
openedVendor.vendorRollBackInventory.DestroyItem(index);
}
MMInventoryEvent.Trigger(MMInventoryEventType.ContentChanged, null, openedVendor.vendorRollBackInventory.name, null, 0, 0);
}
}
}
}
}
/// <summary>
/// Sell item or items to vendor
/// </summary>
public virtual void SellItem()
{
Vendor openedVendor = null;
Vendor[] vendors = FindObjectsOfType <Vendor>();
foreach (Vendor vendor in vendors)
{
if (vendor.enabled && vendor.isOpen)
{
openedVendor = vendor;
}
}
if (openedVendor != null)
{
InventorySlot slot = CurrentlySelectedInventorySlot;
Inventory inventory = slot.ParentInventoryDisplay.TargetInventory;
int index = slot.Index;
InventoryItem item = inventory.Content[index];
InventoryDetailsExtended ide = FindObjectOfType <InventoryDetailsExtended>();
if (ide != null && item != null && inventory.name == openedVendor.mainInventory.name)
{
foreach (InventoryItem disabled in ide.disabledItems)
{
if (item.name == disabled.name)
{
return;
}
}
int quantity = Int32.Parse(ide.vendorQuantity.text);
int price = Int32.Parse(ide.vendorPrice.text);
//we can buy back items from vendor
if (openedVendor.canRollBackItems)
{
if (openedVendor.vendorRollBackInventory.AddItem(item, quantity))
{
if (openedVendor.mainInventory.AddItem(openedVendor.currencyItem, price))
{
//openedVendor.vendorRollBackInventory.AddItem(item, quantity);
MMInventoryEvent.Trigger(MMInventoryEventType.ContentChanged, null, openedVendor.vendorRollBackInventory.name, null, 0, 0);
if (quantity < item.Quantity)
{
item.Quantity -= quantity;
}
else
{
openedVendor.mainInventory.DestroyItem(index);
}
//openedVendor.GetCashForItem(price);
MMInventoryEvent.Trigger(MMInventoryEventType.ContentChanged, null, openedVendor.mainInventory.name, null, 0, 0);
}
}
}
//we can't buy back items from vendor
else
{
if (openedVendor.mainInventory.AddItem(openedVendor.currencyItem, price))
{
if (quantity < item.Quantity)
{
item.Quantity -= quantity;
}
else
{
openedVendor.mainInventory.DestroyItem(index);
}
//openedVendor.GetCashForItem(price);
MMInventoryEvent.Trigger(MMInventoryEventType.ContentChanged, null, openedVendor.mainInventory.name, null, 0, 0);
}
}
}
}
}
/// <summary>
/// Move method supporting move between inventories
/// </summary>
protected virtual void MultiInventoryMove(bool keyboard)
{
//We have selected first slot and hit Move button
if (_isMoving == false)
{
_slotFrom = CurrentlySelectedInventorySlot;
_inventoryFrom = _slotFrom.ParentInventoryDisplay.TargetInventory;
_indexFrom = _slotFrom.Index;
_inventoryItemFrom = _inventoryFrom.Content[_indexFrom];
//selected slot has an item in it so we gather rest of item data like item quantity and change sprite to Moved so we can see what happened
if (_inventoryItemFrom != null)
{
_quantityFrom = _inventoryItemFrom.Quantity;
//now we store none selected slot sprite to change it after moving
_oldSprite = CurrentlySelectedInventorySlot.GetComponent <Image>().sprite;
//now we change the slot sprite to Moved
_slotFrom.GetComponent <Image>().sprite = _slotFrom.MovedSprite;
//and by setting _isMoving to "true" we can wait for next click on slot
_isMoving = true;
if (keyboard)
{
_useKeyboardJoypad = true;
}
}
}
//We have selected second slot
else
{
_slotTo = CurrentlySelectedInventorySlot;
_inventoryTo = _slotTo.ParentInventoryDisplay.TargetInventory;
_indexTo = _slotTo.Index;
_inventoryItemTo = _inventoryTo.Content[_indexTo];
if (_inventoryTo.name == _inventoryFrom.name)
{
if (_indexTo == _indexFrom)
{
return;
}
}
//second clicked slot is empty so we add item to this inventory, move to desired slot and remove it from first one
if (_inventoryItemTo == null)
{
//we change first selected slot sprite back to old sprite
_slotFrom.GetComponent <Image>().sprite = _oldSprite;
//we add item to selected inventory
_inventoryTo.Content[_indexTo] = _inventoryItemFrom.Copy();
//we remove item from first inventory
_inventoryFrom.DestroyItem(_indexFrom);
_inventoryFrom.Content[_indexFrom] = null;
}
else
{
_quantityTo = _inventoryItemTo.Quantity;
//we check if item is the same as we try to move
if (_inventoryItemFrom.ItemName == _inventoryItemTo.ItemName)
{
//we check what is the rest free quantity to close the full sack
int _restStack = _inventoryItemTo.MaximumStack - _quantityTo;
//if quantity of our item we try to move in less or equal than free quantity
if (_quantityFrom <= _restStack)
{
//we update quantity of our item
_inventoryItemTo.Quantity = _inventoryItemTo.Quantity + _quantityFrom;
//we remove item from first inventory
_inventoryFrom.DestroyItem(_indexFrom);
}
//if quantity of our item we try to move is higher than free quantity
else if (_quantityFrom > _restStack)
{
//we update quantity of our item to full stack
_inventoryItemTo.Quantity = _inventoryItemTo.MaximumStack;
//we check what's left after moving some items
int _restToAddQuantity = _quantityFrom - _restStack;
//if there is free slot in second inventory
if (_inventoryTo.NumberOfFreeSlots >= 1)
{
//we need to find first free slot
int _fistFreeSlot = FindFirstFreeSlot(_inventoryTo);
//we add rest of item quantity to inventory as new item
_inventoryTo.Content[_fistFreeSlot] = _inventoryItemFrom;
_inventoryTo.Content[_fistFreeSlot].Quantity = _restToAddQuantity;
//we remove item from first inventory
_inventoryFrom.DestroyItem(_indexFrom);
}
//there is no free slots in second inventory
else
{
//we reduce item quantity in first inventory
_inventoryFrom.Content[_indexFrom].Quantity = _inventoryFrom.Content[_indexFrom].Quantity - _restStack;
}
}
}
else
{
//we need to create copy of item from first inventory
InventoryItem _tempItemFrom = _inventoryItemFrom.Copy();
//we need to create copy of item from second inventory
InventoryItem _tempItemTo = _inventoryItemTo.Copy();
//we remove item from first inventory
_inventoryFrom.DestroyItem(_indexFrom);
//we remove item from second inventory
_inventoryTo.DestroyItem(_indexTo);
//we add item from first inventory to second inventory
_inventoryTo.Content[_indexTo] = _tempItemFrom.Copy();
//we add item from second inventory to first inventory
_inventoryFrom.Content[_indexFrom] = _tempItemTo.Copy();
}
}
_isMoving = false;
if (keyboard)
{
_useKeyboardJoypad = false;
}
MMInventoryEvent.Trigger(MMInventoryEventType.ContentChanged, null, _inventoryFrom.name, null, 0, 0);
MMInventoryEvent.Trigger(MMInventoryEventType.ContentChanged, null, _inventoryTo.name, null, 0, 0);
}
}
