add ckg

plantilla base para movimiento básico

Assets/Game Kit Controller/Scripts/Crafting System/materialExtractionStationSystem.cs

@@ -0,0 +1,617 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Events;
+
+public class materialExtractionStationSystem : craftingStationSystem
+{
+	[Header ("Main Settings")]
+	[Space]
+
+	public bool stationEnabled = true;
+
+	public bool activateStationAtStart;
+
+	public float maxDetectionDistance = 10;
+
+	public Transform extractionZoneTransform;
+
+	public bool useMaxMaterialZonesToExtractAtSameTime;
+	public int maxMaterialZonesToExtractAtSameTime;
+
+	[Space]
+	[Header ("Extraction Settings")]
+	[Space]
+
+	public bool useGeneralMaterialExtractionRate;
+
+	public float generalMaterialExtractionRate;
+
+	[Space]
+
+	public bool useGeneralMaterialExtractionAmount;
+
+	public int generalMaterialExtractionAmount;
+
+	[Space]
+	[Space]
+
+	public bool stationCanOnlyExtractCustomMaterialList;
+	public List<string> customMaterialListToExtract = new List<string> ();
+
+	[Space]
+	[Header ("Custom Materials Zone To Use Settings")]
+	[Space]
+
+	public bool ignoreMaterialZonesFound;
+
+	public bool extractMaterialsEvenIfNotZoneFound;
+
+	public materialsZoneSystem customMaterialZoneSystem;
+
+	[Space]
+	[Header ("Extraction Conditions Settings")]
+	[Space]
+
+	public bool ignoreToExtractMaterialsFromIDList;
+
+	public  List<int> materialsIDListToIgnore = new List<int> ();
+
+	[Space]
+	[Header ("Spawn Extracted Objects Settings")]
+	[Space]
+
+	public bool spawnExtractedObjects;
+
+	public Transform positionToSpawnExtractedObjects;
+
+	public bool addForceToSpawnedObjects;
+
+	public ForceMode forceModeOnSpawnedObjects;
+	public float forceAmountOnSpawnedObjects;
+
+	[Space]
+
+	public bool packExtractedObjectsBeforeSpawn;
+	public int minAmountToPackToSpawn;
+
+	[Space]
+	[Header ("Energy Settings")]
+	[Space]
+
+	public bool useEnergyToExtract;
+
+	public float maxEnergyAmount;
+
+	public float currentEnergyAmount;
+
+	public float useEnergyRate;
+
+	public float energyToUseAmount;
+
+	[Space]
+
+	public bool useEnergyFromInventoryBank;
+
+	public string energyObjectName;
+
+	public bool checkEnergyObjectNameOnEnergyStation;
+
+	[Space]
+	[Header ("Debug")]
+	[Space]
+
+	public bool stationActive;
+
+	List<float> lastTimeMaterialExtractedList = new List<float> ();
+
+	public List<materialsZoneSystem> materialsZoneSystemLocatedList = new List<materialsZoneSystem> ();
+
+	public bool energySourceLocated;
+
+	public int numberOfZonesLocated;
+
+	public List<int> materialZonesSystemsIDToIgnoreList = new List<int> ();
+
+	public List<extractedMaterialInfo> extractedMaterialInfoList = new List<extractedMaterialInfo> ();
+
+	[Space]
+	[Header ("Events Settings")]
+	[Space]
+
+	public UnityEvent eventOnActivateStation;
+	public UnityEvent eventonDeactivateStation;
+
+	[Space]
+
+	public UnityEvent eventOnEnergyEmpty;
+	public UnityEvent eventOnEnergyRecharge;
+	public UnityEvent eventOnEnergyRefilled;
+
+	[Space]
+	[Header ("Components")]
+	[Space]
+
+	public inventoryBankSystem mainInventoryBankSystem;
+
+	public inventoryBankSystem inventoryBankEnergySource;
+
+
+	Coroutine updateCoroutine;
+
+	float lastTimeMaterialExtracted;
+
+	float lastTimeEnergyUsed;
+
+	materialsZoneSystem currentMaterialsZoneSystem;
+
+	inventoryListManager mainInventoryListManager;
+
+	bool mainInventoryManagerLocated;
+
+
+	void Start ()
+	{
+		if (activateStationAtStart) {
+			setExtractionActiveState (true);
+		}
+	}
+
+	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 toggleExtraction ()
+	{
+		setExtractionActiveState (!stationActive);
+	}
+
+	public void setExtractionActiveState (bool state)
+	{
+		if (!stationEnabled) {
+			return;
+		}
+
+		if (stationActive == state) {
+			return;
+		}
+
+		if (state) {
+			if (useEnergyToExtract) {
+				if (currentEnergyAmount <= 0) {
+					return;
+				}
+			}
+		}
+
+		stationActive = state;
+	
+		if (stationActive) {
+			eventOnActivateStation.Invoke ();
+
+			checkMaterialZonesAround ();
+		} else {
+			eventonDeactivateStation.Invoke ();
+
+			stopUpdateCoroutine ();
+
+			for (int i = 0; i < materialsZoneSystemLocatedList.Count; i++) {
+				materialsZoneSystemLocatedList [i].setMaterialsZoneExtractionInProcessState (false);
+			}
+		}
+	}
+
+	void checkMaterialZonesAround ()
+	{
+		materialsZoneSystemLocatedList.Clear ();
+
+		lastTimeMaterialExtractedList.Clear ();
+
+		extractedMaterialInfoList.Clear ();
+
+		if (ignoreMaterialZonesFound) {
+			if (extractMaterialsEvenIfNotZoneFound) {
+				materialsZoneSystemLocatedList.Add (customMaterialZoneSystem);
+
+				lastTimeMaterialExtractedList.Add (0);
+			}
+		} else {
+			materialsZoneSystem[] temporalMaterialsZoneSystem = FindObjectsOfType<materialsZoneSystem> ();
+
+			foreach (materialsZoneSystem currentMaterialsZoneSystem in temporalMaterialsZoneSystem) {
+				if (currentMaterialsZoneSystem.isMaterialsZoneEnabled ()) {
+					bool addZoneResult = false;
+
+					float currentDistance = GKC_Utils.distance (extractionZoneTransform.position, currentMaterialsZoneSystem.transform.position);
+
+					if (currentDistance < maxDetectionDistance) {
+						addZoneResult = true;
+					}
+
+					if (useMaxMaterialZonesToExtractAtSameTime) {
+						if (materialsZoneSystemLocatedList.Count >= maxMaterialZonesToExtractAtSameTime) {
+							addZoneResult = false;
+						}
+					}
+
+					if (addZoneResult) {
+						materialsZoneSystemLocatedList.Add (currentMaterialsZoneSystem);
+
+						lastTimeMaterialExtractedList.Add (0);
+					}
+				}
+			}
+		}
+
+		energySourceLocated = (!useEnergyFromInventoryBank || inventoryBankEnergySource != null);
+
+		lastTimeMaterialExtracted = 0;
+
+		lastTimeEnergyUsed = 0;
+
+		numberOfZonesLocated = 0;
+
+		stopUpdateCoroutine ();
+
+		if (materialsZoneSystemLocatedList.Count > 0) {
+			numberOfZonesLocated = materialsZoneSystemLocatedList.Count;
+
+			for (int i = 0; i < materialsZoneSystemLocatedList.Count; i++) {
+				materialsZoneSystemLocatedList [i].setMaterialsZoneExtractionInProcessState (true);
+			}
+
+			updateCoroutine = StartCoroutine (updateSystemCoroutine ());
+		}
+	}
+
+	public void stopUpdateCoroutine ()
+	{
+		if (updateCoroutine != null) {
+			StopCoroutine (updateCoroutine);
+		}
+	}
+
+	IEnumerator updateSystemCoroutine ()
+	{
+		var waitTime = new WaitForFixedUpdate ();
+
+		while (true) {
+			updateSystem ();
+
+			yield return waitTime;
+		}
+	}
+
+	void updateSystem ()
+	{
+		if (useGeneralMaterialExtractionRate) {
+			if (Time.time > generalMaterialExtractionRate + lastTimeMaterialExtracted) {
+				bool allMaterialZonesEmpty = true;
+
+				for (int i = 0; i < materialsZoneSystemLocatedList.Count; i++) {
+					checkMaterialZoneToExtract (i, ref allMaterialZonesEmpty);
+				}
+
+				lastTimeMaterialExtracted = Time.time;
+
+				if (allMaterialZonesEmpty) {
+					setExtractionActiveState (false);
+				}
+			}
+		} else {
+			bool allMaterialZonesEmpty = true;
+
+			for (int i = 0; i < materialsZoneSystemLocatedList.Count; i++) {
+				if (Time.time > materialsZoneSystemLocatedList [i].materialExtractionRate + lastTimeMaterialExtractedList [i]) {
+					checkMaterialZoneToExtract (i, ref allMaterialZonesEmpty);
+
+					lastTimeMaterialExtractedList [i] = Time.time;
+				}
+			}
+
+			if (allMaterialZonesEmpty) {
+				setExtractionActiveState (false);
+			}
+		}
+
+		updateEnergyUsage ();
+	}
+
+	void checkMaterialZoneToExtract (int zoneIndex, ref bool allMaterialZonesEmpty)
+	{
+		currentMaterialsZoneSystem = materialsZoneSystemLocatedList [zoneIndex];
+
+		bool checkMaterialZoneResult = true;
+
+		if (currentMaterialsZoneSystem.isMaterialsZoneEmpty ()) {
+			checkMaterialZoneResult = false;
+		}
+
+		if (checkMaterialZoneResult) {
+			if (materialZonesSystemsIDToIgnoreList.Contains (currentMaterialsZoneSystem.getMaterialZoneID ())) {
+				checkMaterialZoneResult = false;
+			}
+		}
+
+		if (checkMaterialZoneResult) {
+			allMaterialZonesEmpty = false;
+
+			bool allMaterialsOnZoneEmpty = true;
+
+			int currentExtractionAmount = 0;
+
+			for (int j = 0; j < currentMaterialsZoneSystem.materialZoneInfoList.Count; j++) {
+				materialsZoneSystem.materialZoneInfo currentMaterialZoneInfo = currentMaterialsZoneSystem.materialZoneInfoList [j];
+
+				bool canExtractMaterialResult = true;
+			
+				if (currentMaterialZoneInfo.materialAmount <= 0) {
+					canExtractMaterialResult = false;
+				}
+
+				if (canExtractMaterialResult) {
+					if (stationCanOnlyExtractCustomMaterialList && !canExtractMaterial (currentMaterialZoneInfo.materialName)) {
+						canExtractMaterialResult = false;
+					}
+				}
+
+				if (canExtractMaterialResult) {
+					if (ignoreToExtractMaterialsFromIDList && materialsIDListToIgnore.Contains (currentMaterialZoneInfo.materialID)) {
+						canExtractMaterialResult = false;
+					}
+				}
+
+				if (canExtractMaterialResult) {
+					if (useGeneralMaterialExtractionAmount) {
+						currentExtractionAmount = generalMaterialExtractionAmount;
+					} else {
+						currentExtractionAmount = currentMaterialsZoneSystem.materialExtractionAmount;
+					}
+
+					if (currentMaterialZoneInfo.useCustomMaterialExtractionAmount) {
+						currentExtractionAmount = currentMaterialZoneInfo.customMaterialExtractionAmount;
+					}
+
+					int amountToObtain = currentExtractionAmount;
+
+					currentMaterialZoneInfo.materialAmount -= amountToObtain;
+
+					if (currentMaterialZoneInfo.useInfiniteMaterialAmount) {
+						currentMaterialZoneInfo.materialAmount = 1;
+					}
+
+					if (spawnExtractedObjects) {
+						if (packExtractedObjectsBeforeSpawn) {
+							int currentIndex = extractedMaterialInfoList.FindIndex (s => s.materialName.Equals (currentMaterialZoneInfo.materialName));
+
+							if (currentIndex > -1) {
+								extractedMaterialInfoList [currentIndex].materialAmount += amountToObtain;
+							} else {
+								extractedMaterialInfo newExtractedMaterialInfo = new extractedMaterialInfo ();
+
+								newExtractedMaterialInfo.materialName = currentMaterialZoneInfo.materialName;
+								newExtractedMaterialInfo.materialAmount = amountToObtain;
+
+								extractedMaterialInfoList.Add (newExtractedMaterialInfo);
+
+								currentIndex = extractedMaterialInfoList.Count - 1;
+							}
+
+							if (extractedMaterialInfoList [currentIndex].materialAmount >= minAmountToPackToSpawn) {
+								spawnExtractedMaterial (extractedMaterialInfoList [currentIndex].materialName, minAmountToPackToSpawn);
+
+								extractedMaterialInfoList [currentIndex].materialAmount -= minAmountToPackToSpawn;
+
+								if (extractedMaterialInfoList [currentIndex].materialAmount <= 0) {
+									extractedMaterialInfoList.RemoveAt (currentIndex);
+								}
+							}
+						} else {
+							spawnExtractedMaterial (currentMaterialZoneInfo.materialName, amountToObtain);
+						}
+					} else {
+						mainInventoryBankSystem.addInventoryObjectByName (currentMaterialZoneInfo.materialName, amountToObtain);
+					}
+
+					allMaterialsOnZoneEmpty = false;
+				}
+			}
+
+			if (allMaterialsOnZoneEmpty) {
+				if (currentMaterialsZoneSystem.getRemainMaterialsAmount () > 0) {
+					materialZonesSystemsIDToIgnoreList.Add (currentMaterialsZoneSystem.getMaterialZoneID ());
+				} else {
+					currentMaterialsZoneSystem.setMaterialsZoneEmptyState (true);
+				}
+			}
+		}
+	}
+
+	void spawnExtractedMaterial (string materialName, int amountToObtain)
+	{
+		if (!mainInventoryManagerLocated) {
+			checkGetMainInventoryManager ();
+		}
+
+		if (mainInventoryManagerLocated) {
+			GameObject newMaterialObject = 
+				mainInventoryListManager.spawnInventoryObjectByName (materialName,  
+					amountToObtain, positionToSpawnExtractedObjects.position, positionToSpawnExtractedObjects.rotation); 
+
+			if (addForceToSpawnedObjects) {
+				if (newMaterialObject != null) {
+					Rigidbody objectRigidbody = newMaterialObject.GetComponent<Rigidbody> ();
+
+					if (objectRigidbody != null) {
+						objectRigidbody.AddForce (positionToSpawnExtractedObjects.forward * forceAmountOnSpawnedObjects, forceModeOnSpawnedObjects);
+					}
+				}
+			}
+		}
+	}
+
+	void updateEnergyUsage ()
+	{
+		if (useEnergyToExtract) {
+			if (Time.time > lastTimeEnergyUsed + useEnergyRate) {
+				if (useEnergyFromInventoryBank) {
+					if (energySourceLocated) {
+						currentEnergyAmount = inventoryBankEnergySource.getInventoryObjectAmountByName (energyObjectName);
+
+						if (currentEnergyAmount > 0) {
+							inventoryBankEnergySource.removeObjectAmountFromInventory (energyObjectName, (int)currentEnergyAmount);
+						}
+					} else {
+						currentEnergyAmount = 0;
+					}
+				}
+
+				if (energyStationAssigned) {
+					if (checkEnergyObjectNameOnEnergyStation) {
+						if (energyObjectName.Equals (currentEnergyStationSystem.getEnergyName ())) {
+							currentEnergyAmount = currentEnergyStationSystem.getCurrentEnergyAmount ();
+						} else {
+							currentEnergyAmount = 0;
+						}
+					} else {
+						currentEnergyAmount = currentEnergyStationSystem.getCurrentEnergyAmount ();
+					}
+				}
+
+				currentEnergyAmount -= energyToUseAmount;
+
+				if (useInfiniteEnergy) {
+					currentEnergyAmount = maxEnergyAmount;
+				}
+
+				if (currentEnergyAmount < 0) {
+					currentEnergyAmount = 0;
+				}
+
+				lastTimeEnergyUsed = Time.time;
+			}
+
+			if (currentEnergyAmount <= 0) {
+
+				setExtractionActiveState (false);
+
+				eventOnEnergyEmpty.Invoke ();
+			}
+		}
+	}
+
+	public void addEnergy (float newValue)
+	{
+		if (useEnergyToExtract) {
+			currentEnergyAmount += newValue;
+
+			if (currentEnergyAmount >= maxEnergyAmount) {
+				currentEnergyAmount = maxEnergyAmount;
+
+				eventOnEnergyRefilled.Invoke ();
+			} else {
+				eventOnEnergyRecharge.Invoke ();
+			}
+		}
+	}
+
+	public override void sendEnergyValue (float newAmount)
+	{
+		addEnergy (newAmount);
+	}
+
+	public void refullEnergy ()
+	{
+		addEnergy (maxEnergyAmount);
+	}
+
+	public void removeEnergySource ()
+	{
+		inventoryBankEnergySource = null;
+
+		energySourceLocated = false;
+
+		if (useInfiniteEnergy) {
+			currentEnergyAmount = 1;
+		} else {
+			currentEnergyAmount = 0;
+		}
+	}
+
+	public float getCurrentEnergyAmount ()
+	{
+		return currentEnergyAmount;
+	}
+
+	public float getMaxEnergyAmount ()
+	{
+		return maxEnergyAmount;
+	}
+
+	public void setEnergySource (inventoryBankSystem newBank)
+	{
+		inventoryBankEnergySource = newBank;
+
+		energySourceLocated = inventoryBankEnergySource != null;
+	}
+
+	public override void checkEnergyStationOnStateChange ()
+	{
+		if (removeRemainEnergyOnRemoveEnergyStation) {
+			if (currentEnergyStationSystem == null) {
+				currentEnergyAmount = 0;
+
+				if (stationActive) {
+					setExtractionActiveState (false);
+				}
+			}
+		}
+	}
+
+	public bool canExtractMaterial (string materialName)
+	{
+		if (stationCanOnlyExtractCustomMaterialList) {
+			if (customMaterialListToExtract.Contains (materialName)) {
+				return true;
+			}
+
+			return false;
+		} else {
+			return true;
+		}
+	}
+
+	[System.Serializable]
+	public class extractedMaterialInfo
+	{
+		[Header ("Main Settings")]
+		[Space]
+
+		public string materialName;
+
+		public int materialAmount;
+	}
+}