plantilla base para movimiento básico
This commit is contained in:
Robii Aragon
2026-02-05 05:07:55 -08:00
parent ed7b223c04
commit fd87a6ffd5
14441 changed files with 13711084 additions and 20 deletions

View File

@@ -0,0 +1,619 @@
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;
}
}