811 lines
29 KiB
C#
811 lines
29 KiB
C#
using System;
|
|
using Invector;
|
|
using Invector.vItemManager;
|
|
using System.Collections.Generic;
|
|
using System.Text;
|
|
using UnityEngine;
|
|
using UnityEngine.Events;
|
|
using UnityEngine.UI;
|
|
using System.Linq;
|
|
|
|
namespace Beyond
|
|
{
|
|
[vClassHeader("Equip Area", openClose = false)]
|
|
public class bEquipArea : vMonoBehaviour
|
|
{
|
|
public delegate void OnPickUpItem(bEquipArea area, bItemSlot slot);
|
|
|
|
private const int powerChargesMaxValue = 100;
|
|
public OnPickUpItem onPickUpItemCallBack;
|
|
|
|
public bInventory inventory;
|
|
public bItemManager itemManager;
|
|
public bItemWindow itemPicker;
|
|
|
|
[Tooltip("Set current equiped slot when submit an slot of this area")]
|
|
public bool setEquipSlotWhenSubmit;
|
|
|
|
[Tooltip("Skip empty slots when switching between slots")]
|
|
public bool skipEmptySlots;
|
|
|
|
public List<bEquipSlot> equipSlots;
|
|
public string equipPointName;
|
|
|
|
public Text displayNameText;
|
|
public Text displayTypeText;
|
|
public Text displayAmountText;
|
|
public Text displayDescriptionText;
|
|
public Text displayAttributesText;
|
|
|
|
[vHelpBox("You can ignore display Attributes using this property")]
|
|
public List<bItemAttributes> ignoreAttributes;
|
|
|
|
public UnityEngine.Events.UnityEvent onInitPickUpItem, onFinishPickUpItem;
|
|
public InputField.OnChangeEvent onChangeName;
|
|
public InputField.OnChangeEvent onChangeType;
|
|
public InputField.OnChangeEvent onChangeAmount;
|
|
public InputField.OnChangeEvent onChangeDescription;
|
|
public InputField.OnChangeEvent onChangeAttributes;
|
|
|
|
public OnChangeEquipmentEvent onEquipItem;
|
|
public OnChangeEquipmentEvent onUnequipItem;
|
|
public OnSelectEquipArea onSelectEquipArea;
|
|
|
|
public event Action OnItemUsed;
|
|
|
|
public UnityEngine.UI.Toggle.ToggleEvent onSetLockToEquip;
|
|
|
|
[HideInInspector]
|
|
public bEquipSlot currentSelectedSlot;
|
|
|
|
public bEquipSlot lastSelectedSlot;
|
|
|
|
[HideInInspector]
|
|
public int indexOfEquippedItem;
|
|
|
|
public bItem lastEquipedItem;
|
|
|
|
protected bool _isLockedToEquip;
|
|
|
|
[vHelpBox("Select what ItemType this EquipSlot will equip", vHelpBoxAttribute.MessageType.Warning)]
|
|
public List<bItemType> itemTypes;
|
|
|
|
private List<bItem> items = new();
|
|
private List<int> usedIndexes = new();
|
|
|
|
private List<bItem> gemableWeapons = new();
|
|
private bItem selectedPowerableItem;
|
|
private int selectedGemableItemIndex;
|
|
|
|
public bool isLockedToEquip
|
|
{
|
|
get
|
|
{
|
|
return _isLockedToEquip;
|
|
}
|
|
set
|
|
{
|
|
if (_isLockedToEquip != value) onSetLockToEquip.Invoke(value);
|
|
_isLockedToEquip = value;
|
|
}
|
|
}
|
|
|
|
public bool ignoreEquipEvents;
|
|
|
|
/// <summary>
|
|
/// used to ignore <see cref="onEquipItem"/> event. if true, the inventory will just add the equipment to area but dont will send to Equip the item. you will nedd to call <see cref="EquipCurrentSlot"/> to equip the item in the area.
|
|
/// </summary>
|
|
internal bool isInit;
|
|
|
|
public void Init()
|
|
{
|
|
if (!isInit) Start();
|
|
}
|
|
|
|
private void Start()
|
|
{
|
|
if (!isInit)
|
|
{
|
|
isInit = true;
|
|
//indexOfEquipedItem = -1;
|
|
inventory = GetComponentInParent<bInventory>();
|
|
itemManager = Player.Instance.GetComponent<bItemManager>();
|
|
//itemManager.onEquipItem
|
|
if (equipSlots.Count == 0)
|
|
{
|
|
var equipSlotsArray = GetComponentsInChildren<bEquipSlot>(true);
|
|
equipSlots = equipSlotsArray.vToList();
|
|
}
|
|
foreach (bEquipSlot slot in equipSlots)
|
|
{
|
|
slot.onSubmitSlotCallBack = OnSubmitSlot;
|
|
slot.onSelectSlotCallBack = OnSelectSlot;
|
|
slot.onDeselectSlotCallBack = OnDeselect;
|
|
onSetLockToEquip.AddListener(slot.SetLockToEquip);
|
|
if (slot.displayAmountText) slot.displayAmountText.text = "";
|
|
slot.onChangeAmount.Invoke("");
|
|
}
|
|
}
|
|
if (itemPicker)
|
|
{
|
|
itemPicker.onSelectSlot.AddListener(SetPowerableWeaponImage);
|
|
}
|
|
}
|
|
|
|
public void SetEquipmentWindow()
|
|
{
|
|
itemPicker.CreateEquipmentWindow(inventory.items, itemTypes, equipSlots[0].item, OnPickItem);
|
|
}
|
|
|
|
public void SetNewItemWindow(bItemWindow newItemPicker)
|
|
{
|
|
if (itemPicker)
|
|
{
|
|
DisableItemWindow();
|
|
}
|
|
itemPicker = newItemPicker;
|
|
EnableItemWindow();
|
|
}
|
|
|
|
public void DisableItemWindow()
|
|
{
|
|
itemPicker.gameObject.SetActive(false);
|
|
}
|
|
|
|
public void EnableItemWindow()
|
|
{
|
|
itemPicker.gameObject.SetActive(true);
|
|
}
|
|
|
|
public void SetEquipmentwindowWithFilter(List<bItemType> types)
|
|
{
|
|
itemPicker.CreateEquipmentWindow(inventory.items, types, null, OnPickItem);
|
|
//itemPicker.ReloadItems();
|
|
}
|
|
|
|
public void SetEquipmentWindowsUsableWithFilter(List<bItemType> types)
|
|
{
|
|
itemPicker.CreateEquipmentWindowUsable(inventory.items, types, equipSlots[0].item, OnPickItem);
|
|
}
|
|
|
|
private void SetOccupiedIndexes()
|
|
{
|
|
for (int i = 0; i < equipSlots.Count; i++)
|
|
{
|
|
if (equipSlots[i].isOcupad())
|
|
usedIndexes.Add(i);
|
|
}
|
|
}
|
|
|
|
public bool IsAnyItemEquipped()
|
|
{
|
|
for (int i = 0; i < equipSlots.Count; i++)
|
|
{
|
|
if (equipSlots[i].isOcupad())
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Current Equipped Slot
|
|
/// </summary>
|
|
public bEquipSlot currentEquippedSlot
|
|
{
|
|
get
|
|
{
|
|
return equipSlots[indexOfEquippedItem];
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Item in Current Equipped Slot
|
|
/// </summary>
|
|
public bItem currentEquippedItem
|
|
{
|
|
get
|
|
{
|
|
var validEquipSlots = ValidSlots;
|
|
if (validEquipSlots.Count > 0 && indexOfEquippedItem >= 0 && indexOfEquippedItem < validEquipSlots.Count) return validEquipSlots[indexOfEquippedItem].item;
|
|
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// All valid slot <seealso cref="vItemSlot.isValid"/>
|
|
/// </summary>
|
|
public List<bEquipSlot> ValidSlots
|
|
{
|
|
get { return equipSlots.FindAll(slot => slot.isValid && (!skipEmptySlots || slot.item != null)); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if Item is in Area
|
|
/// </summary>
|
|
/// <param name="item">item to check</param>
|
|
/// <returns></returns>
|
|
public bool ContainsItem(vItem item)
|
|
{
|
|
return ValidSlots.Find(slot => slot.item == item) != null;
|
|
}
|
|
|
|
private void UseItemInternal(bItem item)
|
|
{
|
|
if (item.type == bItemType.Gemstones)
|
|
{
|
|
if (gemableWeapons.Count < 1 || gemableWeapons[selectedGemableItemIndex] == null)
|
|
{
|
|
if (bItemCollectionDisplay.Instance && item.type == bItemType.Gemstones && item)
|
|
{
|
|
Player.Instance.PlayFullyChargedSound();
|
|
|
|
//in menu
|
|
if (PopupMenuController.Instance != null)
|
|
{
|
|
PopupMenuController.Instance.TryToShowPopupMesssage("No proper weapons available");
|
|
} //cant use gemstone with no proper weapons available
|
|
return;
|
|
}
|
|
}
|
|
else //if (item.type == bItemType.Gemstones)
|
|
{
|
|
bItemAttribute powerAttribute = gemableWeapons[selectedGemableItemIndex].attributes.First(attribute => attribute.name == bItemAttributes.Power);
|
|
if (powerAttribute.value >= powerChargesMaxValue)
|
|
{
|
|
Player.Instance.PlayFullyChargedSound();
|
|
//Player.Instance.MeleeManager.onEquipWeapon
|
|
if (PopupMenuController.Instance != null)
|
|
{
|
|
PopupMenuController.Instance.TryToShowPopupMesssage(gemableWeapons[selectedGemableItemIndex].name + " is already fully charged");
|
|
} //cant use gemstone with no proper weapons available
|
|
return;
|
|
}
|
|
powerAttribute.value += item.GetItemAttribute(bItemAttributes.Power).value;
|
|
if (powerAttribute.value > powerChargesMaxValue)
|
|
{
|
|
powerAttribute.value = powerChargesMaxValue;
|
|
}
|
|
}
|
|
}
|
|
|
|
inventory.OnUseItem(item);
|
|
|
|
}
|
|
|
|
public void UseItem()
|
|
{
|
|
if (itemManager.UsingItem)
|
|
{
|
|
return;
|
|
}
|
|
|
|
//could move the logic to item manager
|
|
|
|
UseItemInternal(itemPicker.currentSelectedSlot.item);
|
|
/*
|
|
bItem itemBeingUsed = itemPicker.currentSelectedSlot.item;
|
|
//using here
|
|
if (itemBeingUsed.type == bItemType.Gemstones)
|
|
{
|
|
bItem item = itemBeingUsed;
|
|
|
|
if (gemableWeapons.Count < 1 || gemableWeapons[selectedGemableItemIndex] == null)
|
|
{
|
|
if (bItemCollectionDisplay.Instance && item.type == bItemType.Gemstones && item)
|
|
{
|
|
Player.Instance.PlayFullyChargedSound();
|
|
|
|
//in menu
|
|
if (PopupMenuController.Instance != null)
|
|
{
|
|
PopupMenuController.Instance.TryToShowPopupMesssage("No proper weapons available");
|
|
} //cant use gemstone with no proper weapons available
|
|
return;
|
|
}
|
|
}
|
|
else if (item.type == bItemType.Gemstones)
|
|
{
|
|
bItemAttribute powerAttribute = gemableWeapons[selectedGemableItemIndex].attributes.First(attribute => attribute.name == bItemAttributes.Power);
|
|
if (powerAttribute.value >= powerChargesMaxValue)
|
|
{
|
|
Player.Instance.PlayFullyChargedSound();
|
|
if (PopupMenuController.Instance != null)
|
|
{
|
|
PopupMenuController.Instance.TryToShowPopupMesssage(gemableWeapons[selectedGemableItemIndex].name + " is already fully charged");
|
|
} //cant use gemstone with no proper weapons available
|
|
return;
|
|
}
|
|
powerAttribute.value += item.GetItemAttribute(bItemAttributes.Power).value;
|
|
if (powerAttribute.value > powerChargesMaxValue)
|
|
{
|
|
powerAttribute.value = powerChargesMaxValue;
|
|
}
|
|
}
|
|
}
|
|
|
|
inventory.OnUseItem(itemBeingUsed);
|
|
*/
|
|
}
|
|
|
|
public void UseItem(bEquipSlot equipSlot)
|
|
{
|
|
bItem itemBeingUsed = equipSlot.item;
|
|
FindGemableWeapons();
|
|
UseItemInternal(itemBeingUsed);
|
|
//do some nice things here i think
|
|
//inventory.OnUseItem(itemBeingUsed);
|
|
}
|
|
|
|
public void UseEquippedItem()
|
|
{
|
|
inventory.OnUseItem(currentEquippedItem);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Event called from Inventory slot UI on Submit
|
|
/// </summary>
|
|
/// <param name="slot"></param>
|
|
public void OnSubmitSlot(bItemSlot slot)
|
|
{
|
|
lastSelectedSlot = currentSelectedSlot;
|
|
if (itemPicker != null)
|
|
{
|
|
currentSelectedSlot = slot as bEquipSlot;
|
|
if (setEquipSlotWhenSubmit)
|
|
{
|
|
SetEquipSlot(equipSlots.IndexOf(currentSelectedSlot));
|
|
}
|
|
itemPicker.gameObject.SetActive(true);
|
|
itemPicker.onCancelSlot.RemoveAllListeners();
|
|
itemPicker.onCancelSlot.AddListener(CancelCurrentSlot);
|
|
itemPicker.CreateEquipmentWindow(inventory.items, currentSelectedSlot.itemType, slot.item, OnPickItem);
|
|
onInitPickUpItem.Invoke();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Event called to cancel Submit action
|
|
/// </summary>
|
|
public void CancelCurrentSlot()
|
|
{
|
|
if (currentSelectedSlot == null)
|
|
currentSelectedSlot = lastSelectedSlot;
|
|
|
|
if (currentSelectedSlot != null)
|
|
currentSelectedSlot.OnCancel();
|
|
onFinishPickUpItem.Invoke();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Unequip Item of the Slot
|
|
/// </summary>
|
|
/// <param name="slot">target slot</param>
|
|
public void UnequipItem(bEquipSlot slot)
|
|
{
|
|
if (slot)
|
|
{
|
|
bItem item = slot.item;
|
|
if (ValidSlots[indexOfEquippedItem].item == item)
|
|
lastEquipedItem = item;
|
|
slot.RemoveItem();
|
|
onUnequipItem.Invoke(this, item);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Unequip Item if is present in slots
|
|
/// </summary>
|
|
/// <param name="item"></param>
|
|
public void UnequipItem(bItem item)
|
|
{
|
|
var slot = ValidSlots.Find(_slot => _slot.item == item);
|
|
if (slot)
|
|
{
|
|
if (ValidSlots[indexOfEquippedItem].item == item) lastEquipedItem = item;
|
|
slot.RemoveItem();
|
|
onUnequipItem.Invoke(this, item);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Unequip <seealso cref="currentEquippedItem"/>
|
|
/// </summary>
|
|
public void UnequipCurrentItem()
|
|
{
|
|
if (currentSelectedSlot && currentSelectedSlot.item)
|
|
{
|
|
var _item = currentSelectedSlot.item;
|
|
if (ValidSlots[indexOfEquippedItem].item == _item) lastEquipedItem = _item;
|
|
currentSelectedSlot.RemoveItem();
|
|
onUnequipItem.Invoke(this, _item);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Event called from inventory UI when select an slot
|
|
/// never fires apparently
|
|
/// </summary>
|
|
/// <param name="slot">target slot</param>
|
|
public void OnSelectSlot(bItemSlot slot)
|
|
{
|
|
if (equipSlots.Contains(slot as bEquipSlot))
|
|
currentSelectedSlot = slot as bEquipSlot;
|
|
else currentSelectedSlot = null;
|
|
|
|
onSelectEquipArea.Invoke(this);
|
|
CreateFullItemDescription(slot);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Event called from inventory UI when unselect an slot
|
|
/// </summary>
|
|
/// <param name="slot">target slot</param>
|
|
public void OnDeselect(bItemSlot slot)
|
|
{
|
|
if (equipSlots.Contains(slot as bEquipSlot))
|
|
{
|
|
currentSelectedSlot = null;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Create item description
|
|
/// </summary>
|
|
/// <param name="slot">target slot</param>
|
|
protected virtual void CreateFullItemDescription(bItemSlot slot)
|
|
{
|
|
var _name = slot.item ? slot.item.name : "";
|
|
var _type = slot.item ? slot.item.ItemTypeText() : "";
|
|
var _amount = slot.item ? slot.item.amount.ToString() : "";
|
|
var _description = slot.item ? slot.item.description : "";
|
|
var _attributes = slot.item ? slot.item.GetItemAttributesText(ignoreAttributes) : "";
|
|
|
|
if (displayNameText) displayNameText.text = _name;
|
|
onChangeName.Invoke(_name);
|
|
|
|
if (displayTypeText) displayTypeText.text = _type;
|
|
onChangeType.Invoke(_type);
|
|
|
|
if (displayAmountText) displayAmountText.text = _amount;
|
|
onChangeAmount.Invoke(_amount);
|
|
|
|
if (displayDescriptionText) displayDescriptionText.text = _description;
|
|
onChangeDescription.Invoke(_description);
|
|
|
|
if (displayAttributesText) displayAttributesText.text = _attributes;
|
|
onChangeAttributes.Invoke(_attributes);
|
|
|
|
Debug.LogError("happeingng?");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Event called from inventory UI to open <see cref="vItemWindow"/> when submit slot
|
|
/// </summary>
|
|
/// <param name="slot">target slot</param>
|
|
public void OnPickItem(bItemSlot slot)
|
|
{
|
|
/*
|
|
//for gemstones it does something different, it switches internal idnex of currently selected sword
|
|
|
|
if (slot.item.type == bItemType.Gemstones)
|
|
{
|
|
SwitchPowerableWeapon();
|
|
return;
|
|
}
|
|
*/
|
|
//1 check if any slot has this item, if it does, unequip it
|
|
//2 if not fill the first free slot
|
|
//3 if no free slots available swap with the oldest one
|
|
if (usedIndexes.Count == 0)
|
|
{
|
|
SetOccupiedIndexes();
|
|
}
|
|
//1
|
|
if (slot.isChecked)
|
|
{
|
|
bEquipSlot occupiedSlot = equipSlots.Find(eSlot => eSlot.item == slot.item);
|
|
usedIndexes.Remove(equipSlots.IndexOf(occupiedSlot));
|
|
occupiedSlot.RemoveItem();
|
|
onUnequipItem.Invoke(this, slot.item);
|
|
onFinishPickUpItem.Invoke();
|
|
return;
|
|
}
|
|
//2
|
|
bEquipSlot freeSlot = equipSlots.Find(eslot => !eslot.isOcupad() && eslot.isValid && eslot.itemType.Contains(slot.item.type));
|
|
if (freeSlot)
|
|
{
|
|
onPickUpItemCallBack?.Invoke(this, slot);
|
|
freeSlot.AddItem(slot.item);
|
|
if (!ignoreEquipEvents)
|
|
{
|
|
onEquipItem.Invoke(this, slot.item);
|
|
}
|
|
onFinishPickUpItem.Invoke();
|
|
|
|
usedIndexes.Add(equipSlots.IndexOf(freeSlot));
|
|
return;
|
|
}
|
|
//3
|
|
|
|
//get last used index that is of valid type
|
|
bEquipSlot slotToBeTaken = equipSlots[0];
|
|
|
|
for (int i = 0; i < usedIndexes.Count; i++)
|
|
{
|
|
int tempIndex = usedIndexes[i];
|
|
if (equipSlots[tempIndex].itemType.Contains(slot.item.type))
|
|
{
|
|
slotToBeTaken = equipSlots[tempIndex];
|
|
usedIndexes.RemoveAt(i);
|
|
usedIndexes.Add(tempIndex);
|
|
i = usedIndexes.Count;
|
|
}
|
|
}
|
|
// bEquipSlot slotToBeTaken = equipSlots[usedIndexes[0]];
|
|
|
|
//remove old 1st
|
|
slotToBeTaken.RemoveItem();
|
|
onUnequipItem.Invoke(this, slot.item);
|
|
onFinishPickUpItem.Invoke();
|
|
//add new
|
|
onPickUpItemCallBack?.Invoke(this, slot);
|
|
slotToBeTaken.AddItem(slot.item);
|
|
if (!ignoreEquipEvents)
|
|
{
|
|
onEquipItem.Invoke(this, slot.item);
|
|
}
|
|
onFinishPickUpItem.Invoke();
|
|
return;
|
|
|
|
if (!currentSelectedSlot)
|
|
{
|
|
currentSelectedSlot = lastSelectedSlot;
|
|
}
|
|
|
|
if (!currentSelectedSlot)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (currentSelectedSlot.item != null && slot.item != currentSelectedSlot.item)
|
|
{
|
|
currentSelectedSlot.item.isInEquipArea = false;
|
|
var item = currentSelectedSlot.item;
|
|
if (item == slot.item) lastEquipedItem = item;
|
|
currentSelectedSlot.RemoveItem();
|
|
onUnequipItem.Invoke(this, item);
|
|
}
|
|
|
|
if (slot.item != currentSelectedSlot.item)
|
|
{
|
|
if (onPickUpItemCallBack != null)
|
|
onPickUpItemCallBack(this, slot);
|
|
currentSelectedSlot.AddItem(slot.item);
|
|
if (!ignoreEquipEvents) onEquipItem.Invoke(this, currentSelectedSlot.item);
|
|
}
|
|
currentSelectedSlot.OnCancel();
|
|
currentSelectedSlot = null;
|
|
lastSelectedSlot = null;
|
|
onFinishPickUpItem.Invoke();
|
|
}
|
|
|
|
void FindGemableWeapons()
|
|
{
|
|
List<bItemType> weaponTypes = new List<bItemType>() { bItemType.Swords, bItemType.Axes };
|
|
gemableWeapons = inventory.items.FindAll(item => weaponTypes.Contains(item.type) && item.GetItemAttribute(bItemAttributes.Power) != null);
|
|
selectedGemableItemIndex = 0;
|
|
}
|
|
|
|
private void SetPowerableWeaponImage(bItemSlot itemSelected)
|
|
{
|
|
if (itemSelected.item.type == bItemType.Gemstones)
|
|
{
|
|
//for gemstones reset selection of gemable weapon, no saving per gem as of now
|
|
FindGemableWeapons();
|
|
if (gemableWeapons.Count > 0)
|
|
{
|
|
selectedPowerableItem = gemableWeapons[selectedGemableItemIndex];
|
|
itemPicker.SetPowerableSwitchSwordImage(selectedPowerableItem);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void SwitchPowerableWeapon()
|
|
{
|
|
if (gemableWeapons.Count < 1)
|
|
{
|
|
itemPicker.SetPowerableSwitchSwordImage(null);
|
|
return;
|
|
}
|
|
selectedGemableItemIndex++;
|
|
if (selectedGemableItemIndex >= gemableWeapons.Count)
|
|
{
|
|
selectedGemableItemIndex = 0;
|
|
}
|
|
selectedPowerableItem = gemableWeapons[selectedGemableItemIndex];
|
|
itemPicker.SetPowerableSwitchSwordImage(selectedPowerableItem);
|
|
//updaing ui
|
|
}
|
|
|
|
/// <summary>
|
|
/// Equip next slot <seealso cref="currentEquippedItem"/>
|
|
/// </summary>
|
|
public void NextEquipSlot()
|
|
{
|
|
if (equipSlots == null || equipSlots.Count == 0) return;
|
|
|
|
lastEquipedItem = currentEquippedItem;
|
|
var validEquipSlots = ValidSlots;
|
|
if (indexOfEquippedItem + 1 < validEquipSlots.Count)
|
|
indexOfEquippedItem++;
|
|
else
|
|
indexOfEquippedItem = 0;
|
|
|
|
if (currentEquippedItem != null && !ignoreEquipEvents)
|
|
onEquipItem.Invoke(this, currentEquippedItem);
|
|
onUnequipItem.Invoke(this, lastEquipedItem);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Equip previous slot <seealso cref="currentEquippedItem"/>
|
|
/// </summary>
|
|
public void PreviousEquipSlot()
|
|
{
|
|
if (equipSlots == null || equipSlots.Count == 0) return;
|
|
|
|
lastEquipedItem = currentEquippedItem;
|
|
var validEquipSlots = ValidSlots;
|
|
|
|
if (indexOfEquippedItem - 1 >= 0)
|
|
indexOfEquippedItem--;
|
|
else
|
|
indexOfEquippedItem = validEquipSlots.Count - 1;
|
|
|
|
if (currentEquippedItem != null && !ignoreEquipEvents)
|
|
onEquipItem.Invoke(this, currentEquippedItem);
|
|
|
|
onUnequipItem.Invoke(this, lastEquipedItem);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Equip slot <see cref="currentEquippedItem"/>
|
|
/// </summary>
|
|
/// <param name="indexOfSlot">index of target slot</param>
|
|
public void SetEquipSlot(int indexOfSlot)
|
|
{
|
|
if (equipSlots == null || equipSlots.Count == 0) return;
|
|
if (indexOfSlot < equipSlots.Count && indexOfSlot >= 0)
|
|
{
|
|
lastEquipedItem = currentEquippedItem;
|
|
indexOfEquippedItem = indexOfSlot;
|
|
if (currentEquippedItem != null && !ignoreEquipEvents)
|
|
{
|
|
onEquipItem.Invoke(this, currentEquippedItem);
|
|
}
|
|
if (currentEquippedItem != lastEquipedItem)
|
|
onUnequipItem.Invoke(this, lastEquipedItem);
|
|
}
|
|
}
|
|
|
|
public void EquipCurrentSlot()
|
|
{
|
|
if (!currentEquippedSlot || (currentEquippedSlot.item != null && currentEquippedSlot.item.isEquiped)) return;
|
|
if (currentEquippedItem) onEquipItem.Invoke(this, currentEquippedItem);
|
|
else if (lastEquipedItem) onUnequipItem.Invoke(this, lastEquipedItem);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Add an item to an slot
|
|
/// </summary>
|
|
/// <param name="slot">target Slot</param>
|
|
/// <param name="item">target Item</param>
|
|
public void AddItemToEquipSlot(bItemSlot slot, bItem item, bool autoEquip = false)
|
|
{
|
|
if (slot is bEquipSlot && equipSlots.Contains(slot as bEquipSlot))
|
|
{
|
|
AddItemToEquipSlot(equipSlots.IndexOf(slot as bEquipSlot), item, autoEquip);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Add an item to an slot
|
|
/// </summary>
|
|
/// <param name="indexOfSlot">index of target Slot</param>
|
|
/// <param name="item">target Item</param>
|
|
public void AddItemToEquipSlot(int indexOfSlot, bItem item, bool autoEquip = false)
|
|
{
|
|
if (indexOfSlot < equipSlots.Count && item != null && item.canBeUsed)
|
|
{
|
|
var slot = equipSlots[indexOfSlot];
|
|
|
|
if (slot != null && slot.isValid && slot.itemType.Contains(item.type))
|
|
{
|
|
var sameSlot = equipSlots.Find(s => s.item == item && s != slot);
|
|
|
|
if (sameSlot != null)
|
|
RemoveItemOfEquipSlot(equipSlots.IndexOf(sameSlot));
|
|
|
|
if (slot.item != null && slot.item != item)
|
|
{
|
|
if (currentEquippedItem == slot.item) lastEquipedItem = slot.item;
|
|
slot.item.isInEquipArea = false;
|
|
onUnequipItem.Invoke(this, slot.item);
|
|
}
|
|
item.checkColor = slot.checkColor;
|
|
item.isInEquipArea = true;
|
|
slot.AddItem(item);
|
|
if (autoEquip)
|
|
SetEquipSlot(indexOfSlot);
|
|
else if (!ignoreEquipEvents)
|
|
onEquipItem.Invoke(this, item);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Remove item of an slot
|
|
/// </summary>
|
|
/// <param name="slot">target Slot</param>
|
|
public void RemoveItemOfEquipSlot(bItemSlot slot)
|
|
{
|
|
if (slot is bEquipSlot && equipSlots.Contains(slot as bEquipSlot))
|
|
{
|
|
RemoveItemOfEquipSlot(equipSlots.IndexOf(slot as bEquipSlot));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Remove item of an slot
|
|
/// </summary>
|
|
/// <param name="slot">index of target Slot</param>
|
|
public void RemoveItemOfEquipSlot(int indexOfSlot)
|
|
{
|
|
if (indexOfSlot < equipSlots.Count)
|
|
{
|
|
var slot = equipSlots[indexOfSlot];
|
|
if (slot != null && slot.item != null)
|
|
{
|
|
var item = slot.item;
|
|
item.isInEquipArea = false;
|
|
if (currentEquippedItem == item) lastEquipedItem = currentEquippedItem;
|
|
slot.RemoveItem();
|
|
onUnequipItem.Invoke(this, item);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Add item to current equiped slot
|
|
/// </summary>
|
|
/// <param name="item">target item</param>
|
|
public void AddCurrentItem(bItem item)
|
|
{
|
|
if (indexOfEquippedItem < equipSlots.Count)
|
|
{
|
|
var slot = equipSlots[indexOfEquippedItem];
|
|
if (slot.item != null && item != slot.item)
|
|
{
|
|
if (currentEquippedItem == slot.item) lastEquipedItem = slot.item;
|
|
slot.item.isInEquipArea = false;
|
|
onUnequipItem.Invoke(this, currentSelectedSlot.item);
|
|
}
|
|
slot.AddItem(item);
|
|
if (!ignoreEquipEvents) onEquipItem.Invoke(this, item);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Remove current equiped Item
|
|
/// </summary>
|
|
public void RemoveCurrentItem()
|
|
{
|
|
if (!currentEquippedItem) return;
|
|
lastEquipedItem = currentEquippedItem;
|
|
ValidSlots[indexOfEquippedItem].RemoveItem();
|
|
onUnequipItem.Invoke(this, lastEquipedItem);
|
|
}
|
|
}
|
|
} |