scove/BABA_YAGA
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

update

Browse Source
This commit is contained in:
scove
2026-06-02 08:27:03 +07:00
parent 7889064469
commit a48cd962e1
4232 changed files with 2 additions and 36881 deletions
Download Patch File Download Diff File Expand all files Collapse all files

115
Assets/Third Parties/Invector-3rdPersonController/ItemManager/Scripts/Examples/UseItemEventTrigger.cs Normal file
View File

@@ -0,0 +1,115 @@
using UnityEngine;
namespace Invector.vItemManager
{
[vClassHeader("Use Item Event Trigger", useHelpBox = true, helpBoxText = "This script enable ItemUsage when TriggerEnter and disable onTriggerExit", openClose = false)]
public class UseItemEventTrigger : vMonoBehaviour
{
/// <summary>
/// Item usage Event
/// </summary>
public OnUseItemEvent itemEvent;
protected vItemManager itemManager;
/// <summary>
/// Item usage Event class
/// </summary>
[System.Serializable]
public class OnUseItemEvent
{
internal vItem targetItem;
public int id;
[vHelpBox("Check this to enable the menu UI Button 'Use' on the Inventory Window")]
public bool canUseWithOpenInventory;
[vHelpBox("Override the Delay to use this Item")]
public bool overrideItemUsageDelay;
[vHideInInspector("overrideItemUsageDelay")]
public float newDeleyTime;
internal float defaultDelay;
public UnityEngine.Events.UnityEvent onUse;
/// <summary>
/// Event called when the inventory is opened or closed while in trigger
/// </summary>
/// <param name="value"></param>
public void OnOpenInventory(bool value)
{
if (canUseWithOpenInventory || !targetItem) return;
targetItem.canBeUsed = !value;
}
/// <summary>
/// Change item usage delay time, called when the Player with an Item Manager enters a trigger
/// </summary>
public void ChangeItemUsageDelay()
{
if (!overrideItemUsageDelay || targetItem == null) return;
defaultDelay = targetItem.enableDelayTime;
targetItem.enableDelayTime = newDeleyTime;
}
/// <summary>
/// Reset item usage delay time, called when the Player with an Item Manager exit a trigger
/// </summary>
public void ResetItemUsageDelay()
{
if (!overrideItemUsageDelay || targetItem == null) return;
targetItem.enableDelayTime = defaultDelay;
}
}
public virtual void OnTriggerEnter(Collider other)
{
if (other.gameObject.CompareTag("Player"))
{
itemManager = other.GetComponent<vItemManager>();
if (itemManager)
{
itemEvent.targetItem = itemManager.GetItem(itemEvent.id);
if (itemEvent.targetItem)
{
itemEvent.ChangeItemUsageDelay();
itemManager.onUseItem.AddListener(OnUseItem);
itemManager.onOpenCloseInventory.AddListener(itemEvent.OnOpenInventory);
itemEvent.targetItem.canBeUsed = true;
}
}
}
}
/// <summary>
/// Event called when the Player with Item Manager use an item while in a trigger
/// </summary>
/// <param name="item"></param>
protected virtual void OnUseItem(vItem item)
{
if (itemManager && itemEvent.id == item.id)
{
itemManager.inventory.CloseInventory();
itemManager.onUseItem.RemoveListener(OnUseItem);
itemManager.onOpenCloseInventory.RemoveListener(itemEvent.OnOpenInventory);
itemEvent.onUse.Invoke();
itemEvent.ResetItemUsageDelay();
itemEvent.targetItem = null;
}
}
public virtual void OnTriggerExit(Collider other)
{
if (other.gameObject.CompareTag("Player"))
{
if (itemManager)
{
itemManager.onUseItem.RemoveListener(OnUseItem);
itemManager.onOpenCloseInventory.RemoveListener(itemEvent.OnOpenInventory);
if (itemEvent.targetItem)
{
itemEvent.targetItem.canBeUsed = false;
itemEvent.ResetItemUsageDelay();
itemEvent.targetItem = null;
}
}
}
}
}
}

12
Assets/Third Parties/Invector-3rdPersonController/ItemManager/Scripts/Examples/UseItemEventTrigger.cs.meta Normal file
View File

@@ -0,0 +1,12 @@
fileFormatVersion: 2
guid: 648d1e19b9583464ead7d66ff716b90e
timeCreated: 1553039020
licenseType: Store
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

40
Assets/Third Parties/Invector-3rdPersonController/ItemManager/Scripts/Examples/vAddItemByID.cs Normal file
View File

@@ -0,0 +1,40 @@
using UnityEngine;
namespace Invector.vItemManager
{
[vClassHeader("Add Item By ID", "This is a simple example on how to add items using script", openClose = false)]
public class vAddItemByID : vMonoBehaviour
{
public int id, amount;
public bool addToEquipArea=true;
[vHideInInspector("addToEquipArea")]
public bool autoEquip;
public bool destroyAfter;
[vHideInInspector("addToEquipArea")]
public int indexOfEquipArea;
/// <summary>
/// Simple example on how to add one or more items into the inventory using code
/// You can also auto equip the item if it's a MeleeWeapon Type
/// </summary>
/// <param name="other"></param>
void OnTriggerEnter(Collider other)
{
if (other.gameObject.CompareTag("Player"))
{
var itemManager = other.gameObject.GetComponent<vItemManager>();
if (itemManager)
{
var reference = new ItemReference(id);
reference.amount = amount;
reference.addToEquipArea = addToEquipArea;
reference.autoEquip = autoEquip;
reference.indexArea = indexOfEquipArea;
itemManager.CollectItem(reference,textDelay:2f,ignoreItemAnimation:false);
if (destroyAfter) Destroy(gameObject);
}
}
}
}
}

12
Assets/Third Parties/Invector-3rdPersonController/ItemManager/Scripts/Examples/vAddItemByID.cs.meta Normal file
View File

@@ -0,0 +1,12 @@
fileFormatVersion: 2
guid: d9ce46fecaccad144a028174359bc8e1
timeCreated: 1497280650
licenseType: Store
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

75
Assets/Third Parties/Invector-3rdPersonController/ItemManager/Scripts/Examples/vCheckCanAddHealth.cs Normal file
View File

@@ -0,0 +1,75 @@
using System.Collections.Generic;
namespace Invector.vItemManager
{
using vCharacterController;
[vClassHeader("Check if can Add Health", "Simple Example to verify if the health item can be used based on the character's health is full or not.", openClose = false)]
public class vCheckCanAddHealth : vMonoBehaviour
{
public vItemManager itemManager;
public vThirdPersonController tpController;
public bool getInParent = true;
protected bool canUse;
protected bool firstRun;
protected virtual void Start()
{
// first we need to access our itemManager from the Controller
if (itemManager == null)
{
//check 'getInParent' if this script is attached to a children of the itemManager
if (getInParent)
itemManager = GetComponentInParent<vItemManager>();
else
itemManager = GetComponent<vItemManager>();
}
// now we access the Controller itself to know the currentHealth later
if (tpController == null)
{
if (getInParent)
tpController = GetComponentInParent<vThirdPersonController>();
else
tpController = GetComponent<vThirdPersonController>();
}
// if a itemManager is founded, we use this event to call our CanUseItem method
if (itemManager)
{
itemManager.canUseItemDelegate -= new vItemManager.CanUseItemDelegate(CanUseItem);
itemManager.canUseItemDelegate += new vItemManager.CanUseItemDelegate(CanUseItem);
}
}
protected virtual void OnDestroy()
{
var itemManager = GetComponent<vItemManager>();
if (itemManager)
// remove the event when this gameObject is destroyed
itemManager.canUseItemDelegate -= new vItemManager.CanUseItemDelegate(CanUseItem);
}
protected virtual void CanUseItem(vItem item, ref List<bool> validateResult)
{
// search for the attribute 'Health'
if (item.GetItemAttribute(vItemAttributes.Health) != null)
{
// the variable valid will identify if the currentHealth is lower than the maxHealth, allowing to use the item
var valid = tpController.currentHealth < tpController.maxHealth;
if (valid != canUse || !firstRun)
{
canUse = valid;
firstRun = true;
// trigger a custom text if there is a HUDController in the scene
vHUDController.instance.ShowText(valid ? "Increase health" : "Can't use " + item.name + " because your health is full", 4f);
}
if (!valid)
validateResult.Add(valid);
}
}
}
}

12
Assets/Third Parties/Invector-3rdPersonController/ItemManager/Scripts/Examples/vCheckCanAddHealth.cs.meta Normal file
View File

@@ -0,0 +1,12 @@
fileFormatVersion: 2
guid: aaad9c954e715fa429bfde69f0e1a9ab
timeCreated: 1553036367
licenseType: Store
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

92
Assets/Third Parties/Invector-3rdPersonController/ItemManager/Scripts/Examples/vCheckItemInInventory.cs Normal file
View File

@@ -0,0 +1,92 @@
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Events;
namespace Invector.vItemManager
{
[vClassHeader("Check Item in Inventory", openClose = false)]
public class vCheckItemInInventory : vMonoBehaviour
{
protected vItemManager itemManager;
public bool getInParent = true;
public List<CheckItemIDEvent> itemIDEvents;
void Awake()
{
if (!itemManager)
{
if (getInParent)
itemManager = GetComponentInParent<vItemManager>();
else
itemManager = GetComponent<vItemManager>();
if (itemManager)
{
itemManager.onAddItemID.AddListener(CheckItemExists);
itemManager.onRemoveItemID.AddListener(CheckItemExists);
}
}
}
public void CheckOnTrigger(Collider collider)
{
if (collider != null)
{
itemManager = collider.gameObject.GetComponent<vItemManager>();
if (itemManager)
{
for (int i = 0; i < itemIDEvents.Count; i++)
{
CheckItemIDEvent check = itemIDEvents[i];
CheckItemID(check);
}
}
}
}
private void CheckItemExists(int arg1)
{
for (int i = 0; i < itemIDEvents.Count; i++)
{
CheckItemIDEvent check = itemIDEvents[i];
CheckItemID(check);
}
}
private void CheckItemID(CheckItemIDEvent check)
{
if (check.Check(itemManager))
{
check.onContainItem.Invoke();
}
else
{
check.onNotContainItem.Invoke();
}
}
[System.Serializable]
public class CheckItemIDEvent
{
public string name;
public List<int> _itemsID;
public UnityEvent onContainItem, onNotContainItem;
public bool Check(vItemManager itemManager)
{
bool _ContainItem = true;
for (int i = 0; i < _itemsID.Count; i++)
{
if (!itemManager.ContainItem(_itemsID[i]))
{
_ContainItem = false;
break;
}
}
return _ContainItem;
}
}
}
}

12
Assets/Third Parties/Invector-3rdPersonController/ItemManager/Scripts/Examples/vCheckItemInInventory.cs.meta Normal file
View File

@@ -0,0 +1,12 @@
fileFormatVersion: 2
guid: 237576695a682fd4b8e6657977cf624c
timeCreated: 1564597325
licenseType: Store
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

88
Assets/Third Parties/Invector-3rdPersonController/ItemManager/Scripts/Examples/vCheckItemIsEquipped.cs Normal file
View File

@@ -0,0 +1,88 @@
using System.Collections.Generic;
using UnityEngine.Serialization;
namespace Invector.vItemManager
{
[vClassHeader("Check If Item Is Equipped", openClose = false)]
public class vCheckItemIsEquipped : vMonoBehaviour
{
public vItemManager itemManager;
public bool getInParent = true;
[FormerlySerializedAs("itemChecks")]
public List<CheckItemIDEvent> itemIDEvents;
public List<CheckItemTypeEvent> itemTypeEvents;
void Awake()
{
if (!itemManager)
{
if (getInParent)
itemManager = GetComponentInParent<vItemManager>();
else
itemManager = GetComponent<vItemManager>();
itemManager.onEquipItem.AddListener(CheckIsEquipped);
itemManager.onUnequipItem.AddListener(CheckIsEquipped);
}
}
private void CheckIsEquipped(vEquipArea arg0, vItem arg1)
{
for (int i = 0; i < itemIDEvents.Count; i++)
{
CheckItemIDEvent check = itemIDEvents[i];
CheckItemID(check);
}
for (int i = 0; i < itemTypeEvents.Count; i++)
{
CheckItemTypeEvent check = itemTypeEvents[i];
CheckItemType(check);
}
}
private void CheckItemID(CheckItemIDEvent check)
{
bool _isEquipped = check._itemsID.Exists(t => itemManager.ItemIsEquipped(t));
if (_isEquipped != check.isEquipped)
{
check.isEquipped = _isEquipped;
if (check.isEquipped)
check.onIsItemEquipped.Invoke();
else
check.onIsItemUnequipped.Invoke();
}
}
private void CheckItemType(CheckItemTypeEvent check)
{
bool _isEquipped = check.itemTypes.Exists(t => itemManager.ItemTypeIsEquipped(t));
if (_isEquipped != check.isEquipped)
{
check.isEquipped = _isEquipped;
if (check.isEquipped)
check.onIsItemEquipped.Invoke();
else
check.onIsItemUnequipped.Invoke();
}
}
[System.Serializable]
public class CheckItemIDEvent
{
public string name;
public List<int> _itemsID;
public UnityEngine.Events.UnityEvent onIsItemEquipped, onIsItemUnequipped;
internal bool isEquipped;
}
[System.Serializable]
public class CheckItemTypeEvent
{
public string name;
public List<vItemType> itemTypes;
public UnityEngine.Events.UnityEvent onIsItemEquipped, onIsItemUnequipped;
internal bool isEquipped;
}
}
}

12
Assets/Third Parties/Invector-3rdPersonController/ItemManager/Scripts/Examples/vCheckItemIsEquipped.cs.meta Normal file
View File

@@ -0,0 +1,12 @@
fileFormatVersion: 2
guid: 60b674fb1f2130c47938ee73697a6080
timeCreated: 1564597325
licenseType: Store
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

95
Assets/Third Parties/Invector-3rdPersonController/ItemManager/Scripts/Examples/vCheckItemsInInventory.cs Normal file
View File

@@ -0,0 +1,95 @@
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Events;
namespace Invector.vItemManager
{
[vClassHeader("Check Items in Inventory", openClose = false)]
public class vCheckItemsInInventory : vMonoBehaviour
{
public vItemManager itemManager;
public List<CheckItemIDEvent> itemIDEvents;
IEnumerator Start()
{
yield return new WaitForEndOfFrame();
if (itemManager)
{
itemManager.inventory.OnUpdateInventory += (CheckItemExists);
}
}
private void OnValidate()
{
if (!itemManager)
{
itemManager = GetComponent<vItemManager>();
if (!itemManager)
{
itemManager = GetComponentInParent<vItemManager>();
}
}
}
public void CheckItemExists()
{
for (int i = 0; i < itemIDEvents.Count; i++)
{
CheckItemIDEvent check = itemIDEvents[i];
CheckItemID(check);
}
}
private void CheckItemID(CheckItemIDEvent check)
{
if (check.Check(itemManager))
{
check.onContainItem.Invoke();
}
else
{
check.onNotContainItem.Invoke();
}
}
[System.Serializable]
public class CheckItemIDEvent
{
public string name;
public List<ItemID> itemIds;
public UnityEvent onContainItem, onNotContainItem;
public bool Check(vItemManager itemManager)
{
bool _ContainItem = true;
for (int i = 0; i < itemIds.Count; i++)
{
ItemID itemID = itemIds[i];
if (itemID.verifyAmmount && itemManager.GetAllAmount(itemID.id) < itemID.ammount)
{
_ContainItem = false;
break;
}
else if (!itemID.verifyAmmount && !itemManager.ContainItem(itemID.id))
{
_ContainItem = false;
break;
}
}
return _ContainItem;
}
}
[System.Serializable]
public class ItemID
{
public int id;
public bool verifyAmmount;
public int ammount;
}
}
}

12
Assets/Third Parties/Invector-3rdPersonController/ItemManager/Scripts/Examples/vCheckItemsInInventory.cs.meta Normal file
View File

@@ -0,0 +1,12 @@
fileFormatVersion: 2
guid: bc636d7cf1ef747dfa13814fdda2c7d9
timeCreated: 1564597325
licenseType: Store
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

106
Assets/Third Parties/Invector-3rdPersonController/ItemManager/Scripts/Examples/vContainsItemTrigger.cs Normal file
View File

@@ -0,0 +1,106 @@
using UnityEngine;
namespace Invector.vItemManager
{
[vClassHeader("Contains Item Trigger", "Simple trigger to check if the Player has a specific Item, you can also use Events to trigger something if you have the item.", openClose = false)]
public class vContainsItemTrigger : vMonoBehaviour
{
public bool getItemByName;
[vHideInInspector("getItemByName")]
public string itemName;
[vHideInInspector("getItemByName", true)]
public int itemID;
public bool useTriggerStay;
public int desiredAmount = 1;
[Header("OnTriggerEnter/Stay")]
public UnityEngine.Events.UnityEvent onContains;
public UnityEngine.Events.UnityEvent onNotContains;
[Header("OnTriggerExit")]
public UnityEngine.Events.UnityEvent onExit;
public vItemManager itemManager;
public void OnTriggerEnter(Collider other)
{
if (other.gameObject.CompareTag("Player"))
{
var itemManager = other.GetComponent<vItemManager>();
if (itemManager)
{
CheckItem(itemManager);
}
}
}
public void OnTriggerStay(Collider other)
{
if (!useTriggerStay) return;
if (other.gameObject.CompareTag("Player"))
{
itemManager = other.GetComponent<vItemManager>();
if (itemManager)
{
CheckItem(itemManager);
}
}
}
public void OnTriggerExit(Collider other)
{
if (other.gameObject.CompareTag("Player"))
{
onExit.Invoke();
}
}
/// <summary>
/// Remove desired item of the target <seealso cref="vItemManager"/>
/// </summary>
public void RemoveDesiredItem()
{
if (itemManager)
{
if (getItemByName)
{
if (ContainsItem(itemManager))
{
itemManager.DestroyItem(itemManager.GetItem(itemName), desiredAmount > 1 ? desiredAmount : 1);
}
}
else
{
if (ContainsItem(itemManager))
{
itemManager.DestroyItem(itemManager.GetItem(itemID), desiredAmount > 1 ? desiredAmount : 1);
}
}
}
}
/// <summary>
/// Check if the <seealso cref="vItemManager"/> has the target item and call events <seealso cref="onContains"/> or <seealso cref="onNotContains"/>
/// </summary>
/// <param name="itemManager"></param>
protected virtual void CheckItem(vItemManager itemManager)
{
if (itemManager == null) return;
if (ContainsItem(itemManager))
{
onContains.Invoke();
}
else
onNotContains.Invoke();
}
/// <summary>
/// Check if a item exists in the <seealso cref="itemManager"/>
/// </summary>
/// <param name="itemManager"></param>
/// <returns>Contains or not</returns>
protected bool ContainsItem(vItemManager itemManager)
{
return desiredAmount > 1 ? (getItemByName ? itemManager.ContainItem(itemName, desiredAmount) : itemManager.ContainItem(itemID, desiredAmount)) :
(getItemByName ? itemManager.ContainItem(itemName) : itemManager.ContainItem(itemID));
}
}
}

12
Assets/Third Parties/Invector-3rdPersonController/ItemManager/Scripts/Examples/vContainsItemTrigger.cs.meta Normal file
View File

@@ -0,0 +1,12 @@
fileFormatVersion: 2
guid: 20cb3ab7fd92ec2499f6e983a8f174d5
timeCreated: 1498014940
licenseType: Store
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

41
Assets/Third Parties/Invector-3rdPersonController/ItemManager/Scripts/Examples/vEquipItemTrigger.cs Normal file
View File

@@ -0,0 +1,41 @@
using System;
using System.Collections;
using System.Collections.Generic;
using Invector.vItemManager;
using UnityEngine;
using UnityEngine.Events;
public class vEquipItemTrigger : MonoBehaviour
{
public int itemID;
public UnityEvent OnEquipSuccess, OnEquipFail;
public vItemManager itemManager;
public void OnTriggerEnter(Collider other)
{
if (other.gameObject.CompareTag("Player"))
{
var itemManager = other.GetComponent<vItemManager>();
if (itemManager)
{
EquipItemIfExist(itemManager);
}
}
}
private void EquipItemIfExist(vItemManager itemManager)
{
if (itemManager.items.Exists(i => i.id == itemID))
{
var item = itemManager.items.Find(i => i.id == itemID);
var indexOfArea = System.Array.FindIndex(itemManager.inventory.equipAreas, area => area.equipSlots.Exists(slot => slot.itemType.Contains(item.type)));
itemManager.EquipItemToCurrentEquipSlot(item, indexOfArea);
OnEquipSuccess.Invoke();
}
else
{
OnEquipFail.Invoke();
}
}
}

11
Assets/Third Parties/Invector-3rdPersonController/ItemManager/Scripts/Examples/vEquipItemTrigger.cs.meta Normal file
View File

@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 349a324997e0b4a138d8710cfdbdc552
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

27
Assets/Third Parties/Invector-3rdPersonController/ItemManager/Scripts/Examples/vLoadInventoryItemsExample.cs Normal file
View File

@@ -0,0 +1,27 @@
using Invector;
using Invector.vItemManager;
using System.Collections;
using UnityEngine;
public class vLoadInventoryItemsExample : MonoBehaviour
{
vGameController gm;
void Start()
{
gm = GetComponent<vGameController>();
}
public void LoadItemsToInventory()
{
if (!gm) return;
StartCoroutine(LoadItems());
}
IEnumerator LoadItems()
{
yield return new WaitForSeconds(.1f);
var loadItems = gm.currentPlayer.GetComponent<vItemManager>();
loadItems.LoadItemsExample();
}
}

11
Assets/Third Parties/Invector-3rdPersonController/ItemManager/Scripts/Examples/vLoadInventoryItemsExample.cs.meta Normal file
View File

@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 5b75f9b988aae6044a4eae440fecc771
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

40
Assets/Third Parties/Invector-3rdPersonController/ItemManager/Scripts/Examples/vRemoveCurrentItem.cs Normal file
View File

@@ -0,0 +1,40 @@
using UnityEngine;
using UnityEngine.Events;
namespace Invector.vItemManager
{
[vClassHeader("Remove Current Item", false)]
public class vRemoveCurrentItem : vMonoBehaviour
{
public enum Type
{
UnequipItem,
DestroyItem,
DropItem
}
public Type type = Type.UnequipItem;
[Tooltip("Immediately equip the item ignoring the Equip animation")]
public bool immediate = true;
[Tooltip("Equip Area of your Inventory Prefab")]
public int equipArea;
public UnityEvent OnTriggerEnterEvent;
void OnTriggerEnter(Collider other)
{
if (other.gameObject.CompareTag("Player"))
{
var itemManager = other.gameObject.GetComponent<vItemManager>();
if (itemManager)
{
if (type == Type.UnequipItem)
itemManager.UnequipCurrentEquipedItem(equipArea, immediate);
else if (type == Type.DestroyItem)
itemManager.DestroyCurrentEquipedItem(equipArea, immediate);
else
itemManager.DropCurrentEquippedItem(equipArea, immediate);
}
OnTriggerEnterEvent.Invoke();
}
}
}
}

12
Assets/Third Parties/Invector-3rdPersonController/ItemManager/Scripts/Examples/vRemoveCurrentItem.cs.meta Normal file
View File

@@ -0,0 +1,12 @@
fileFormatVersion: 2
guid: 4899667cf5f3ac6469b6f474a93936cf
timeCreated: 1495915888
licenseType: Store
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

86
Assets/Third Parties/Invector-3rdPersonController/ItemManager/Scripts/Examples/vRemoveItem.cs Normal file
View File

@@ -0,0 +1,86 @@
using UnityEngine;
namespace Invector.vItemManager
{
[vClassHeader("Remove Item", openClose = false)]
public class vRemoveItem : vMonoBehaviour
{
public vRemoveCurrentItem.Type type = vRemoveCurrentItem.Type.DestroyItem;
public bool getItemByName;
[vHideInInspector("getItemByName")]
public string itemName;
[vHideInInspector("getItemByName", true)]
public int itemID;
/// <summary>
/// Remove item of the target collider
/// </summary>
/// <param name="target">target </param>
public void RemoveItem(Collider target)
{
var itemManager = target.GetComponent<vItemManager>();
RemoveItem(itemManager);
}
/// <summary>
/// Remove item of the target gameObject
/// </summary>
/// <param name="target">target </param>
public void RemoveItem(GameObject target)
{
var itemManager = target.GetComponent<vItemManager>();
RemoveItem(itemManager);
}
/// <summary>
/// Remove item of the target <seealso cref="vItemManager"/>
/// </summary>
/// <param name="target">target</param>
public void RemoveItem(vItemManager itemManager)
{
if (itemManager)
{
var item = GetItem(itemManager);
if (item != null)
{
if (type == vRemoveCurrentItem.Type.UnequipItem)
{
itemManager.UnequipItem(item);
}
else if (type == vRemoveCurrentItem.Type.DestroyItem)
{
itemManager.DestroyItem(item, 1);
}
else
{
itemManager.DropItem(item, 1);
}
}
}
}
vItem GetItem(vItemManager itemManager)
{
if (getItemByName)
{
// Check if you have an item via name (string) in your Inventory
if (itemManager.ContainItem(itemName))
{
return itemManager.GetItem(itemName);
}
}
else
{
// Check if you have an item via ID (integer) in your Inventory
if (itemManager.ContainItem(itemID))
{
return itemManager.GetItem(itemID);
}
}
return null;
}
}
}

12
Assets/Third Parties/Invector-3rdPersonController/ItemManager/Scripts/Examples/vRemoveItem.cs.meta Normal file
View File

@@ -0,0 +1,12 @@
fileFormatVersion: 2
guid: 2f27c95ff3823f94ca341218013b9237
timeCreated: 1528330039
licenseType: Store
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

185
Assets/Third Parties/Invector-3rdPersonController/ItemManager/Scripts/Examples/vSaveLoadInventory.cs Normal file
View File

@@ -0,0 +1,185 @@
using System.Collections.Generic;
using System.IO;
using UnityEngine;
namespace Invector.vItemManager
{
public static class vSaveLoadInventory
{
public static string InventoryDataFile = Application.dataPath + Path.DirectorySeparatorChar + "InventoryData.json";
/// <summary>
/// Create a Json text from Inventory EquipAreas and ItemManager Items
/// </summary>
/// <param name="itemManager">Target ItemManaget</param>
/// <returns>Json file text</returns>
public static string InventoryToJsonText(vItemManager itemManager)
{
if (!itemManager.inventory) return string.Empty;
InventoryData data = new InventoryData();
vEquipArea[] equipAreas = itemManager.inventory.equipAreas;
for (int i = 0; i < equipAreas.Length; i++)
{
EquipAreaData equipAreaData = new EquipAreaData();
equipAreaData.indexOfSelectedSlot = equipAreas[i].indexOfEquippedItem;
for (int e = 0; e < equipAreas[i].equipSlots.Count; e++)
{
SlotData equipAreaSlotData = new SlotData();
equipAreaSlotData.hasItem = equipAreas[i].equipSlots[e].item != null;
if (equipAreaSlotData.hasItem)
{
equipAreaSlotData.indexOfItem = itemManager.items.IndexOf(equipAreas[i].equipSlots[e].item);
}
equipAreaData.slotsData.Add(equipAreaSlotData);
}
data.equipAreas.Add(equipAreaData);
}
for (int i = 0; i < itemManager.items.Count; i++)
{
data.itemReferences.Add(new ItemReference(itemManager.items[i]));
}
return JsonUtility.ToJson(data, true);
}
/// <summary>
/// Load json file from <seealso cref="InventoryDataFile"/>
/// </summary>
/// <returns>Json file text</returns>
public static string LoadInventoryJasonText()
{
if (File.Exists(InventoryDataFile)) return File.ReadAllText(InventoryDataFile);
return string.Empty;
}
/// <summary>
/// Save inventory items and occupied equipSlots
/// </summary>
/// <param name="itemManager"></param>
public static void SaveInventory(this vItemManager itemManager)
{
string json = InventoryToJsonText(itemManager);
if (!string.IsNullOrEmpty(json))
{
File.WriteAllText(InventoryDataFile, json);
itemManager.onSaveItems.Invoke();
}
}
/// <summary>
/// Load inventory items and occupied equipSlots
/// </summary>
/// <param name="itemManager"></param>
public static void LoadInventory(this vItemManager itemManager)
{
string json = LoadInventoryJasonText();
if (!string.IsNullOrEmpty(json))
{
InventoryData data = new InventoryData();
JsonUtility.FromJsonOverwrite(json, data);
itemManager.items = data.GetItems(itemManager.itemListData);
vEquipArea[] equipAreas = itemManager.inventory.equipAreas;
for (int i = 0; i < equipAreas.Length; i++)
{
if (i < data.equipAreas.Count)
{
vEquipArea area = equipAreas[i];
EquipAreaData areaData = data.equipAreas[i];
area.indexOfEquippedItem = areaData.indexOfSelectedSlot;
for (int e = 0; e < equipAreas[i].equipSlots.Count; e++)
{
if (e < areaData.slotsData.Count)
{
SlotData slotData = areaData.slotsData[e];
vEquipSlot slot = equipAreas[i].equipSlots[e];
itemManager.temporarilyIgnoreItemAnimation = true;
if (slotData.hasItem)
{
area.AddItemToEquipSlot(e, itemManager.items[slotData.indexOfItem]);
}
else area.RemoveItemOfEquipSlot(e);
}
}
}
}
}
itemManager.inventory.UpdateInventory();
itemManager.temporarilyIgnoreItemAnimation = false;
itemManager.onLoadItems.Invoke();
}
[System.Serializable]
class InventoryData
{
/// <summary>
/// List of <see cref="ItemReference"/>
/// </summary>
public List<ItemReference> itemReferences = new List<ItemReference>();
/// <summary>
/// List of <seealso cref="EquipAreaData"/>
/// </summary>
public List<EquipAreaData> equipAreas = new List<EquipAreaData>();
/// <summary>
/// Get <seealso cref="vItem"/> from <seealso cref="ItemReference"/>
/// </summary>
/// <param name="itemListData"></param>
/// <returns></returns>
public List<vItem> GetItems(vItemListData itemListData)
{
List<vItem> items = new List<vItem>();
for (int i = 0; i < itemReferences.Count; i++)
{
vItem item = itemListData.items.Find(a => a.id.Equals(itemReferences[i].id));
item = GameObject.Instantiate(item);
item.amount = itemReferences[i].amount;
item.attributes = itemReferences[i].attributes;
item.name = item.name.Replace("(Clone)", string.Empty);
items.Add(item);
}
return items;
}
}
[System.Serializable]
class EquipAreaData
{
/// <summary>
/// List of <seealso cref="SlotData"/>
/// </summary>
public List<SlotData> slotsData = new List<SlotData>();
public int indexOfSelectedSlot;
}
[System.Serializable]
class SlotData
{
public bool hasItem;
public int indexOfItem;
}
[System.Serializable]
class ItemReference
{
[SerializeField] public int amount;
[SerializeField] public int id;
[SerializeField] public List<vItemAttribute> attributes;
public ItemReference(vItem item)
{
amount = item.amount;
id = item.id;
attributes = item.attributes;
}
}
}
}

11
Assets/Third Parties/Invector-3rdPersonController/ItemManager/Scripts/Examples/vSaveLoadInventory.cs.meta Normal file
View File

@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: b6d5d018e98c7b04687fd28bc2dc49ae
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant: