619 lines
17 KiB
C#
619 lines
17 KiB
C#
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using UnityEngine;
|
|
using UnityEngine.UI;
|
|
|
|
using System.IO;
|
|
using System;
|
|
using GameKitController.Audio;
|
|
using UnityEngine.Events;
|
|
using UnityEngine.EventSystems;
|
|
|
|
public class inventoryBankSystem : MonoBehaviour
|
|
{
|
|
public bool usingInventoryBank;
|
|
|
|
public float openBankDelay;
|
|
|
|
public string animationName;
|
|
public AudioClip openSound;
|
|
public AudioElement openAudioElement;
|
|
public AudioClip closeSound;
|
|
public AudioElement closeAudioElement;
|
|
|
|
public List<inventoryListElement> inventoryListManagerList = new List<inventoryListElement> ();
|
|
public List<inventoryInfo> bankInventoryList = new List<inventoryInfo> ();
|
|
|
|
public string[] inventoryManagerListString;
|
|
public List<inventoryManagerStringInfo> inventoryManagerStringInfoList = new List<inventoryManagerStringInfo> ();
|
|
|
|
public bool useInventoryFromThisBank;
|
|
|
|
public bool useAsVendorSystem;
|
|
|
|
public bool useGeneralBuyPriceMultiplier;
|
|
public float generalBuyPriceMultiplayerPercentage;
|
|
|
|
public bool useGeneralSellPriceMultiplier;
|
|
public float generalSellPriceMultiplayerPercentage;
|
|
|
|
public bool infiniteVendorAmountAvailable;
|
|
|
|
public bool attachToTransformActive;
|
|
public Transform transformToAttach;
|
|
public Vector3 localOffset;
|
|
|
|
public Transform positionToSpawnObjects;
|
|
|
|
public bool useEventOnInventoryEmpty;
|
|
public UnityEvent eventOnInventoryEmpty;
|
|
public bool repeatEventOnInventoryEmpty;
|
|
bool eventOnInventoryEmptyActivated;
|
|
|
|
public Animation mainAnimation;
|
|
public AudioSource mainAudioSource;
|
|
|
|
public inventoryListManager mainInventoryListManager;
|
|
|
|
public inventoryBankManager mainInventoryBankManager;
|
|
|
|
public spawnObject mainSpawnObject;
|
|
|
|
public bool useMaxInventoryBankSlotsAmount;
|
|
public int maxInventoryBankSlotsAmount;
|
|
|
|
public playerController playerControllerManager;
|
|
|
|
public string mainInventoryManagerName = "Main Inventory Manager";
|
|
|
|
bool mainInventoryManagerLocated;
|
|
|
|
GameObject currentPlayer;
|
|
|
|
inventoryManager currentPlayerInventoryManager;
|
|
|
|
vendorUISystem currentPlayerVendorUISystem;
|
|
|
|
Coroutine openCoroutine;
|
|
bool firstAnimationPlay = true;
|
|
|
|
usingDevicesSystem usingDevicesManager;
|
|
|
|
playerComponentsManager mainPlayerComponentsManager;
|
|
|
|
private void InitializeAudioElements ()
|
|
{
|
|
if (mainAudioSource == null) {
|
|
mainAudioSource = GetComponent<AudioSource> ();
|
|
}
|
|
|
|
if (mainAudioSource != null) {
|
|
openAudioElement.audioSource = mainAudioSource;
|
|
closeAudioElement.audioSource = mainAudioSource;
|
|
}
|
|
|
|
if (openSound != null) {
|
|
openAudioElement.clip = openSound;
|
|
}
|
|
|
|
if (closeSound != null) {
|
|
closeAudioElement.clip = closeSound;
|
|
}
|
|
}
|
|
|
|
void Start ()
|
|
{
|
|
if (mainAnimation == null) {
|
|
mainAnimation = GetComponent<Animation> ();
|
|
}
|
|
|
|
InitializeAudioElements ();
|
|
|
|
checkGetMainInventoryManager ();
|
|
|
|
setInventoryFromInventoryListManager ();
|
|
|
|
if (attachToTransformActive && transformToAttach != null) {
|
|
transform.SetParent (transformToAttach);
|
|
transform.localPosition = Vector3.zero + localOffset;
|
|
}
|
|
}
|
|
|
|
public void spawnRandomObjectFromInventoryBank ()
|
|
{
|
|
if (mainSpawnObject != null) {
|
|
GameObject randomInventoryObject = null;
|
|
|
|
if (useInventoryFromThisBank) {
|
|
int bankInventoryListCount = bankInventoryList.Count;
|
|
|
|
if (bankInventoryListCount > 0) {
|
|
int randomIndex = UnityEngine.Random.Range (0, bankInventoryListCount);
|
|
|
|
inventoryInfo currentInventoryInfo = bankInventoryList [randomIndex];
|
|
|
|
randomInventoryObject = currentInventoryInfo.inventoryObjectPrefab;
|
|
|
|
removeObjectAmountFromInventory (currentInventoryInfo.Name, 1);
|
|
}
|
|
} else {
|
|
checkGetMainInventoryBankManager ();
|
|
|
|
if (mainInventoryBankManager != null) {
|
|
List<inventoryInfo> temporalBankInventoryList = mainInventoryBankManager.getBankInventoryList ();
|
|
|
|
int bankInventoryListCount = temporalBankInventoryList.Count;
|
|
|
|
if (bankInventoryListCount > 0) {
|
|
int randomIndex = UnityEngine.Random.Range (0, bankInventoryListCount);
|
|
|
|
inventoryInfo currentInventoryInfo = temporalBankInventoryList [randomIndex];
|
|
|
|
randomInventoryObject = currentInventoryInfo.inventoryObjectPrefab;
|
|
|
|
removeObjectAmountFromInventory (currentInventoryInfo.Name, 1);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (randomInventoryObject != null) {
|
|
mainSpawnObject.createObject (randomInventoryObject);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void setUsingInventoryBankState (bool state)
|
|
{
|
|
usingInventoryBank = state;
|
|
|
|
if (!usingInventoryBank) {
|
|
checkEventOnInventoryEmpty ();
|
|
}
|
|
}
|
|
|
|
public void activateInventoryBank ()
|
|
{
|
|
if (openCoroutine != null) {
|
|
StopCoroutine (openCoroutine);
|
|
}
|
|
|
|
openCoroutine = StartCoroutine (openOrCloseInventoryBank ());
|
|
}
|
|
|
|
IEnumerator openOrCloseInventoryBank ()
|
|
{
|
|
usingInventoryBank = !usingInventoryBank;
|
|
|
|
playAnimation (usingInventoryBank);
|
|
|
|
playSound (usingInventoryBank);
|
|
|
|
playerControllerManager.setUsingDeviceState (usingInventoryBank);
|
|
|
|
if (usingInventoryBank) {
|
|
yield return new WaitForSeconds (openBankDelay);
|
|
}
|
|
|
|
if (useAsVendorSystem) {
|
|
bool cancelOpenVendorMenu = false;
|
|
|
|
if (usingInventoryBank) {
|
|
currentPlayerInventoryManager.setCurrentVendorObject (gameObject);
|
|
|
|
currentPlayerInventoryManager.setCurrentVendorSystem (gameObject);
|
|
|
|
if (usingDevicesManager != null) {
|
|
if (!usingDevicesManager.existInDeviceList (gameObject)) {
|
|
activateInventoryBank ();
|
|
cancelOpenVendorMenu = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!cancelOpenVendorMenu) {
|
|
currentPlayerVendorUISystem.openOrCloseVendorMenu (usingInventoryBank);
|
|
}
|
|
} else {
|
|
bool cancelOpenInventoryBank = false;
|
|
|
|
if (usingInventoryBank) {
|
|
currentPlayerInventoryManager.setCurrentInventoryBankObject (gameObject);
|
|
|
|
currentPlayerInventoryManager.setCurrentInventoryBankSystem (gameObject);
|
|
|
|
if (usingDevicesManager != null) {
|
|
if (!usingDevicesManager.existInDeviceList (gameObject)) {
|
|
activateInventoryBank ();
|
|
cancelOpenInventoryBank = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!cancelOpenInventoryBank) {
|
|
currentPlayerInventoryManager.openOrCloseInventoryBankMenu (usingInventoryBank);
|
|
}
|
|
}
|
|
|
|
if (!usingInventoryBank) {
|
|
checkEventOnInventoryEmpty ();
|
|
}
|
|
}
|
|
|
|
public void checkEventOnInventoryEmpty ()
|
|
{
|
|
if (useEventOnInventoryEmpty) {
|
|
if (!eventOnInventoryEmptyActivated || repeatEventOnInventoryEmpty) {
|
|
if (bankInventoryList.Count == 0) {
|
|
eventOnInventoryEmpty.Invoke ();
|
|
|
|
eventOnInventoryEmptyActivated = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void playAnimation (bool playForward)
|
|
{
|
|
if (mainAnimation != null) {
|
|
if (playForward) {
|
|
if (!mainAnimation.IsPlaying (animationName)) {
|
|
mainAnimation [animationName].normalizedTime = 0;
|
|
}
|
|
|
|
mainAnimation [animationName].speed = 1;
|
|
} else {
|
|
if (!mainAnimation.IsPlaying (animationName)) {
|
|
mainAnimation [animationName].normalizedTime = 1;
|
|
}
|
|
|
|
mainAnimation [animationName].speed = -1;
|
|
}
|
|
|
|
if (firstAnimationPlay) {
|
|
mainAnimation.Play (animationName);
|
|
firstAnimationPlay = false;
|
|
} else {
|
|
mainAnimation.CrossFade (animationName);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void playSound (bool state)
|
|
{
|
|
if (mainAudioSource != null) {
|
|
GKC_Utils.checkAudioSourcePitch (mainAudioSource);
|
|
}
|
|
|
|
if (state) {
|
|
AudioPlayer.PlayOneShot (openAudioElement, gameObject);
|
|
} else {
|
|
AudioPlayer.PlayOneShot (closeAudioElement, gameObject);
|
|
}
|
|
}
|
|
|
|
public void setCurrentPlayer (GameObject player)
|
|
{
|
|
currentPlayer = player;
|
|
|
|
if (currentPlayer != null) {
|
|
|
|
mainPlayerComponentsManager = currentPlayer.GetComponent<playerComponentsManager> ();
|
|
|
|
currentPlayerInventoryManager = mainPlayerComponentsManager.getInventoryManager ();
|
|
|
|
playerControllerManager = mainPlayerComponentsManager.getPlayerController ();
|
|
|
|
usingDevicesManager = mainPlayerComponentsManager.getUsingDevicesSystem ();
|
|
|
|
currentPlayerVendorUISystem = mainPlayerComponentsManager.getVendorUISystem ();
|
|
}
|
|
}
|
|
|
|
public void setInventoryFromInventoryListManager ()
|
|
{
|
|
if (mainInventoryListManager == null) {
|
|
return;
|
|
}
|
|
|
|
int inventoryListManagerListCount = inventoryListManagerList.Count;
|
|
|
|
List<inventoryCategoryInfo> inventoryCategoryInfoList = mainInventoryListManager.inventoryCategoryInfoList;
|
|
|
|
int inventoryCategoryInfoListCount = inventoryCategoryInfoList.Count;
|
|
|
|
for (int i = 0; i < inventoryListManagerListCount; i++) {
|
|
|
|
inventoryListElement currentElement = inventoryListManagerList [i];
|
|
|
|
if (currentElement.addObjectToList) {
|
|
|
|
bool inventoryInfoLocated = false;
|
|
|
|
if (inventoryCategoryInfoListCount > currentElement.categoryIndex) {
|
|
|
|
inventoryCategoryInfo currentCategoryInfo = inventoryCategoryInfoList [currentElement.categoryIndex];
|
|
|
|
if (currentCategoryInfo.inventoryList.Count > currentElement.elementIndex) {
|
|
|
|
inventoryInfo currentInventoryInfo = currentCategoryInfo.inventoryList [currentElement.elementIndex];
|
|
|
|
if (currentInventoryInfo != null) {
|
|
inventoryInfo newInventoryInfo = new inventoryInfo (currentInventoryInfo);
|
|
newInventoryInfo.Name = currentInventoryInfo.Name;
|
|
newInventoryInfo.amount = currentElement.amount;
|
|
|
|
if (useAsVendorSystem) {
|
|
float buyPrice = currentElement.vendorPrice;
|
|
|
|
if (useGeneralBuyPriceMultiplier) {
|
|
buyPrice = currentInventoryInfo.vendorPrice * generalBuyPriceMultiplayerPercentage;
|
|
}
|
|
newInventoryInfo.vendorPrice = buyPrice;
|
|
|
|
float sellPrice = currentElement.sellPrice;
|
|
|
|
if (useGeneralBuyPriceMultiplier) {
|
|
sellPrice = currentInventoryInfo.sellPrice * generalSellPriceMultiplayerPercentage;
|
|
}
|
|
newInventoryInfo.sellPrice = sellPrice;
|
|
|
|
newInventoryInfo.infiniteVendorAmountAvailable = infiniteVendorAmountAvailable || currentElement.infiniteAmount;
|
|
|
|
if (currentElement.useMinLevelToBuy) {
|
|
newInventoryInfo.useMinLevelToBuy = true;
|
|
newInventoryInfo.minLevelToBuy = currentElement.minLevelToBuy;
|
|
}
|
|
|
|
newInventoryInfo.spawnObject = currentElement.spawnObject;
|
|
}
|
|
|
|
bankInventoryList.Add (newInventoryInfo);
|
|
}
|
|
|
|
inventoryInfoLocated = true;
|
|
}
|
|
}
|
|
|
|
if (!inventoryInfoLocated) {
|
|
print ("WARNING: The inventory bank system configured on the object " + gameObject.name + " hasn't the proper inventory objects to pick by the player properly configured. " +
|
|
"Make sure the inventory list on this component has the correct fields ");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void checkGetMainInventoryManager ()
|
|
{
|
|
if (!mainInventoryManagerLocated) {
|
|
mainInventoryManagerLocated = mainInventoryListManager != null;
|
|
|
|
if (!mainInventoryManagerLocated) {
|
|
mainInventoryListManager = inventoryListManager.Instance;
|
|
|
|
mainInventoryManagerLocated = mainInventoryListManager != null;
|
|
}
|
|
|
|
if (!mainInventoryManagerLocated) {
|
|
GKC_Utils.instantiateMainManagerOnSceneWithTypeOnApplicationPlaying (inventoryListManager.getMainManagerName (), typeof(inventoryListManager), true);
|
|
|
|
mainInventoryListManager = inventoryListManager.Instance;
|
|
|
|
mainInventoryManagerLocated = (mainInventoryListManager != null);
|
|
}
|
|
|
|
if (!mainInventoryManagerLocated) {
|
|
mainInventoryListManager = FindObjectOfType<inventoryListManager> ();
|
|
|
|
mainInventoryManagerLocated = mainInventoryListManager != null;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void getInventoryListManagerList ()
|
|
{
|
|
checkGetMainInventoryManager ();
|
|
|
|
if (mainInventoryListManager != null) {
|
|
inventoryManagerListString = new string[mainInventoryListManager.inventoryCategoryInfoList.Count];
|
|
|
|
for (int i = 0; i < inventoryManagerListString.Length; i++) {
|
|
inventoryManagerListString [i] = mainInventoryListManager.inventoryCategoryInfoList [i].Name;
|
|
}
|
|
|
|
inventoryManagerStringInfoList.Clear ();
|
|
|
|
for (int i = 0; i < mainInventoryListManager.inventoryCategoryInfoList.Count; i++) {
|
|
|
|
inventoryManagerStringInfo newInventoryManagerStringInfoo = new inventoryManagerStringInfo ();
|
|
newInventoryManagerStringInfoo.Name = mainInventoryListManager.inventoryCategoryInfoList [i].Name;
|
|
|
|
newInventoryManagerStringInfoo.inventoryManagerListString = new string[mainInventoryListManager.inventoryCategoryInfoList [i].inventoryList.Count];
|
|
|
|
for (int j = 0; j < mainInventoryListManager.inventoryCategoryInfoList [i].inventoryList.Count; j++) {
|
|
string newName = mainInventoryListManager.inventoryCategoryInfoList [i].inventoryList [j].Name;
|
|
newInventoryManagerStringInfoo.inventoryManagerListString [j] = newName;
|
|
}
|
|
|
|
inventoryManagerStringInfoList.Add (newInventoryManagerStringInfoo);
|
|
}
|
|
|
|
updateComponent ();
|
|
}
|
|
}
|
|
|
|
public void setInventoryObjectListNames ()
|
|
{
|
|
for (int i = 0; i < inventoryListManagerList.Count; i++) {
|
|
inventoryListManagerList [i].Name = inventoryListManagerList [i].inventoryObjectName;
|
|
}
|
|
|
|
updateComponent ();
|
|
}
|
|
|
|
public void addNewInventoryObjectToInventoryListManagerList ()
|
|
{
|
|
inventoryListElement newInventoryListElement = new inventoryListElement ();
|
|
|
|
newInventoryListElement.Name = "New Object";
|
|
|
|
inventoryListManagerList.Add (newInventoryListElement);
|
|
|
|
updateComponent ();
|
|
}
|
|
|
|
public Transform getPositionToSpawnObjects ()
|
|
{
|
|
return positionToSpawnObjects;
|
|
}
|
|
|
|
public List<inventoryInfo> getBankInventoryList ()
|
|
{
|
|
return bankInventoryList;
|
|
}
|
|
|
|
public List<inventoryInfo> getBankInventoryListFromFullBank ()
|
|
{
|
|
if (useInventoryFromThisBank) {
|
|
return bankInventoryList;
|
|
} else {
|
|
checkGetMainInventoryBankManager ();
|
|
|
|
if (mainInventoryBankManager != null) {
|
|
return mainInventoryBankManager.getBankInventoryList ();
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public void addInventoryObjectByName (string objectName, int amountToAdd)
|
|
{
|
|
if (useInventoryFromThisBank) {
|
|
int inventoryListCount = bankInventoryList.Count;
|
|
|
|
for (int i = 0; i < inventoryListCount; i++) {
|
|
inventoryInfo currentInventoryInfo = bankInventoryList [i];
|
|
|
|
if (currentInventoryInfo.Name.Equals (objectName)) {
|
|
|
|
currentInventoryInfo.amount += amountToAdd;
|
|
|
|
return;
|
|
}
|
|
}
|
|
|
|
inventoryInfo inventoryInfoToCheck = mainInventoryListManager.getInventoryInfoFromName (objectName);
|
|
|
|
if (inventoryInfoToCheck != null) {
|
|
inventoryInfo newObjectToAdd = new inventoryInfo (inventoryInfoToCheck);
|
|
newObjectToAdd.amount = amountToAdd;
|
|
|
|
bankInventoryList.Add (newObjectToAdd);
|
|
}
|
|
} else {
|
|
checkGetMainInventoryBankManager ();
|
|
|
|
if (mainInventoryBankManager != null) {
|
|
mainInventoryBankManager.addInventoryObjectByName (objectName, amountToAdd);
|
|
} else {
|
|
print ("WARNING: No Inventory Bank Manager found in the scene, make sure to add the Main Inventory Manager prefab to the scene");
|
|
}
|
|
}
|
|
}
|
|
|
|
public int getInventoryObjectAmountByName (string inventoryObjectName)
|
|
{
|
|
int totalAmount = 0;
|
|
|
|
if (useInventoryFromThisBank) {
|
|
int inventoryListCount = bankInventoryList.Count;
|
|
|
|
for (int i = 0; i < inventoryListCount; i++) {
|
|
inventoryInfo currentInventoryInfo = bankInventoryList [i];
|
|
|
|
if (currentInventoryInfo.Name.Equals (inventoryObjectName)) {
|
|
totalAmount += currentInventoryInfo.amount;
|
|
}
|
|
}
|
|
|
|
if (totalAmount > 0) {
|
|
return totalAmount;
|
|
}
|
|
} else {
|
|
checkGetMainInventoryBankManager ();
|
|
|
|
if (mainInventoryBankManager != null) {
|
|
return mainInventoryBankManager.getInventoryObjectAmountByName (inventoryObjectName);
|
|
}
|
|
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
public void removeObjectAmountFromInventory (string objectName, int amountToRemove)
|
|
{
|
|
if (useInventoryFromThisBank) {
|
|
int inventoryListCount = bankInventoryList.Count;
|
|
|
|
for (int i = 0; i < inventoryListCount; i++) {
|
|
if (bankInventoryList [i].Name.Equals (objectName)) {
|
|
bankInventoryList [i].amount -= amountToRemove;
|
|
|
|
if (bankInventoryList [i].amount <= 0) {
|
|
bankInventoryList.RemoveAt (i);
|
|
}
|
|
|
|
return;
|
|
}
|
|
}
|
|
} else {
|
|
checkGetMainInventoryBankManager ();
|
|
|
|
if (mainInventoryBankManager != null) {
|
|
mainInventoryBankManager.removeObjectAmountFromInventory (objectName, amountToRemove);
|
|
}
|
|
}
|
|
}
|
|
|
|
void checkGetMainInventoryBankManager ()
|
|
{
|
|
if (mainInventoryBankManager == null) {
|
|
mainInventoryListManager = inventoryListManager.Instance;
|
|
|
|
bool mainInventoryManagerLocated = mainInventoryListManager != null;
|
|
|
|
if (!mainInventoryManagerLocated) {
|
|
GKC_Utils.instantiateMainManagerOnSceneWithTypeOnApplicationPlaying (inventoryListManager.getMainManagerName (), typeof(inventoryListManager), true);
|
|
|
|
mainInventoryListManager = inventoryListManager.Instance;
|
|
|
|
mainInventoryManagerLocated = (mainInventoryListManager != null);
|
|
}
|
|
|
|
if (!mainInventoryManagerLocated) {
|
|
mainInventoryListManager = FindObjectOfType<inventoryListManager> ();
|
|
|
|
mainInventoryManagerLocated = mainInventoryListManager != null;
|
|
}
|
|
|
|
if (mainInventoryManagerLocated) {
|
|
mainInventoryBankManager = mainInventoryListManager.getMainInventoryBankManager ();
|
|
}
|
|
}
|
|
}
|
|
|
|
public void updateComponent ()
|
|
{
|
|
GKC_Utils.updateComponent (this);
|
|
|
|
GKC_Utils.updateDirtyScene ("Update Inventory Bank Info", gameObject);
|
|
}
|
|
|
|
[System.Serializable]
|
|
public class inventoryManagerStringInfo
|
|
{
|
|
public string Name;
|
|
public string[] inventoryManagerListString;
|
|
}
|
|
} |