add ckg

plantilla base para movimiento básico

Assets/Game Kit Controller/Scripts/Turn Based Combat/turnBasedCombatSystem.cs

@@ -0,0 +1,879 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Events;
+
+public class turnBasedCombatSystem : MonoBehaviour
+{
+	[Header ("Main Settings")]
+	[Space]
+
+	public bool turnBasedCombatEnabled = true;
+
+	public float minWaitTimeToActiveCombatOnSpotted = 2;
+
+	public float minExtraWaitToReactivateCombatAfterRun = 3;
+
+	public LayerMask layerToAdjustToGround = 1 << 0 | 1 << 23;
+
+	public float minDistanceToPlayerToStartCombat = 10;
+
+	[Space]
+	[Header ("Camera Settings")]
+	[Space]
+
+	public string defaultCameraStateNameOnTurnBasedCombatActive = "Default Turn Based Combat Camera";
+	public string defaultCameraStateNameOnReturnCameraToPlayer = "Return Camera To Player";
+
+	[Space]
+
+	public List<turnBasedCombatCameraInfo> turnBasedCombatCameraInfoList = new List<turnBasedCombatCameraInfo> ();
+
+	[Space]
+
+	public List<turnBasedCombatTeamPositionsInfoData> turnBasedCombatTeamPositionsInfoDataList = new List<turnBasedCombatTeamPositionsInfoData> ();
+
+	[Space]
+	[Header ("Effect Settings")]
+	[Space]
+
+	public string defaultEffectName = "Default Effect";
+
+	[Space]
+
+	public List<turnBasedCombatEffectInfo> turnBasedCombatEffectInfoList = new List<turnBasedCombatEffectInfo> ();
+
+	[Space]
+	[Header ("Respawn Position Settings")]
+	[Space]
+
+	public List<Transform> positionToRespawnList = new List<Transform> ();
+
+	[Space]
+	[Header ("Debug")]
+	[Space]
+
+	public bool turnBasedCombatActive;
+
+	public bool checkingMinWaitTimeToActiveCombatOnSpotted;
+
+	public bool freeCombatActive;
+
+	[Space]
+	[Header ("Components")]
+	[Space]
+
+	public GameObject mainPlayer;
+
+	public Camera mainCamera;
+
+	public playerCamera playerCameraManager;
+
+	public turnBasedCombatUISystem mainTurnBasedCombatUISystem;
+
+	public AIAroundManager mainAIAroundManager;
+
+	public friendListManager mainFriendListManager;
+
+	[HideInInspector] public GameObject newCharacterTeamLeader;
+
+	[HideInInspector] public string teamPositionDataName;
+	[HideInInspector] public List<GameObject> newCharacterTeamInfoList = new List<GameObject> ();
+	[HideInInspector] public bool newTeamAlwaysSelectFirst;
+	[HideInInspector] public bool useRewardSystem;
+	[HideInInspector] public objectExperienceSystem mainRewardSystem;
+
+	[HideInInspector] public bool useCustomCameraStateOnNewTeam;
+
+	[HideInInspector] public string customCameraStateOnNewTeam;
+
+	[HideInInspector] public List<turnBasedCombatTeamInfo> turnBasedCombatTeamInfoOnSceneList = new List<turnBasedCombatTeamInfo> ();
+
+
+	Transform cameraParentTransform;
+	Vector3 mainCameraTargetPosition;
+	Quaternion mainCameraTargetRotation;
+
+	Coroutine cameraState;
+
+	playerComponentsManager mainPlayerComponentsManager;
+
+	turnBasedCombatCameraInfo currentTurnBasedCombatCameraInfo;
+
+	Coroutine updateCoroutine;
+
+	float lastTimeCheckingMinWaitTimeToActiveCombatOnSpotted;
+
+	bool mainTurnBasedCombatUISystemLocated;
+
+	bool useCustomCameraState;
+
+	string customCameraState;
+
+	float lastTimeCombatRunActive = -1;
+
+	List<GameObject> currentPlayerFriendList = new List<GameObject> ();
+
+	int minTeamAmountToCheck;
+
+
+	public const string mainManagerName = "Turn Combat System";
+
+	public static string getMainManagerName ()
+	{
+		return mainManagerName;
+	}
+
+	private static turnBasedCombatSystem _turnBasedCombatSystemInstance;
+
+	public static turnBasedCombatSystem Instance { get { return _turnBasedCombatSystemInstance; } }
+
+	bool instanceInitialized;
+
+
+	public void getComponentInstance ()
+	{
+		if (instanceInitialized) {
+			return;
+		}
+
+		if (_turnBasedCombatSystemInstance != null && _turnBasedCombatSystemInstance != this) {
+			Destroy (this.gameObject);
+
+			return;
+		} 
+
+		_turnBasedCombatSystemInstance = this;
+
+		instanceInitialized = true;
+	}
+
+	void Awake ()
+	{
+		getComponentInstance ();
+	}
+
+	void Start ()
+	{
+		if (mainPlayer == null) {
+			findMainPlayer ();
+		}
+	}
+
+	void findMainPlayer ()
+	{
+		if (mainPlayer == null) {
+			mainPlayer = GKC_Utils.findMainPlayerOnScene ();
+		}
+
+		if (mainPlayer != null) {
+			setCurrentPlayer (mainPlayer);
+		}
+	}
+
+	public void adjustTurnBasedCombatPositionToPlayer ()
+	{
+		if (mainPlayer == null) {
+			findMainPlayer ();
+		}
+
+		RaycastHit hit;
+
+		Vector3 targetPosition = Vector3.zero;
+
+		for (int i = 0; i < positionToRespawnList.Count; i++) {
+			if (positionToRespawnList [i] != null) {
+				positionToRespawnList [i].SetParent (null);
+			}
+
+			targetPosition = positionToRespawnList [i].position + positionToRespawnList [i].up * 3;
+
+			if (Physics.Raycast (targetPosition, -Vector3.up, out hit, 200, layerToAdjustToGround)) {
+				targetPosition = hit.point;
+			}
+
+			positionToRespawnList [i].position = targetPosition;
+		}
+
+		targetPosition = mainPlayer.transform.position + mainPlayer.transform.up * 3;
+
+		if (Physics.Raycast (targetPosition, -Vector3.up, out hit, 200, layerToAdjustToGround)) {
+			targetPosition = hit.point;
+		}
+
+		transform.position = targetPosition;
+		transform.rotation = playerCameraManager.transform.rotation;
+	}
+
+	public void enableWaitTimeToActivateTurnBasedCombat ()
+	{
+		if (!turnBasedCombatEnabled) {
+			return;
+		}
+
+		if (freeCombatActive) {
+			return;
+		}
+
+		if (!checkingMinWaitTimeToActiveCombatOnSpotted) {
+			checkingMinWaitTimeToActiveCombatOnSpotted = true;
+
+			lastTimeCheckingMinWaitTimeToActiveCombatOnSpotted = Time.time;
+
+			if (currentPlayerFriendList != null) {
+				currentPlayerFriendList.Clear ();
+			}
+
+			currentPlayerFriendList = mainFriendListManager.getAllFriendList ();
+
+			stopUpdateCoroutine ();
+
+			updateCoroutine = StartCoroutine (updateSystemCoroutine ());
+		}
+	}
+
+	public void disableWaitTimeToActivateTurnBasedCombat ()
+	{
+		if (!turnBasedCombatEnabled) {
+			return;
+		}
+
+		if (freeCombatActive) {
+			return;
+		}
+
+		if (checkingMinWaitTimeToActiveCombatOnSpotted) {
+			checkingMinWaitTimeToActiveCombatOnSpotted = false;
+
+			stopUpdateCoroutine ();
+		}
+	}
+
+	public void stopUpdateCoroutine ()
+	{
+		if (updateCoroutine != null) {
+			StopCoroutine (updateCoroutine);
+		}
+	}
+
+	IEnumerator updateSystemCoroutine ()
+	{
+		var waitTime = new WaitForFixedUpdate ();
+
+		while (true) {
+			if (checkingMinWaitTimeToActiveCombatOnSpotted) {
+				bool checkStateResult = true;
+
+				if (lastTimeCombatRunActive != -1) {
+					if (Time.time < minExtraWaitToReactivateCombatAfterRun + lastTimeCombatRunActive) {
+						checkStateResult = false;
+					}
+				}
+
+				if (checkStateResult) {
+					if (Time.time > lastTimeCheckingMinWaitTimeToActiveCombatOnSpotted + minWaitTimeToActiveCombatOnSpotted) {
+						bool checkActivateCombatResult = false;
+
+						if (mainAIAroundManager.checkIfPlayerDetectedByAIAround (mainPlayer)) {
+
+							float distanceToPlayer = mainAIAroundManager.getMinDistanceToPlayer (mainPlayer.transform, false);
+
+							if (distanceToPlayer < minDistanceToPlayerToStartCombat) {
+								checkActivateCombatResult = true;
+							}
+						} else {
+							if (currentPlayerFriendList != null) {
+								int currentPlayerFriendListCount = currentPlayerFriendList.Count;
+
+								for (int i = 0; i < currentPlayerFriendListCount; i++) {
+									if (mainAIAroundManager.checkIfPlayerDetectedByAIAround (currentPlayerFriendList [i])) {
+
+										float distanceToPlayer = mainAIAroundManager.getMinDistanceToPlayer (mainPlayer.transform, true);
+
+										if (distanceToPlayer < minDistanceToPlayerToStartCombat) {
+											checkActivateCombatResult = true;
+										}
+									}
+								}
+							}
+						}
+
+						if (checkActivateCombatResult) {
+							checkingMinWaitTimeToActiveCombatOnSpotted = false;
+
+							stopUpdateCoroutine ();
+
+							activateTurnBasedCombat ();
+						}
+					}
+				}
+			} else {
+
+			}
+
+			yield return waitTime;
+		}
+	}
+
+	public void updateLastTimeCombatRunActive (float value)
+	{
+		lastTimeCombatRunActive = value;
+	}
+
+	public void clearCharactersAround ()
+	{
+		mainAIAroundManager.clearCharactersAround ();
+	}
+
+	public void activateTurnBasedCombat ()
+	{
+		activateOrDeactivateTurnBasedCombat (true);
+	}
+
+	public void deactivateTurnBasedCombat ()
+	{
+		activateOrDeactivateTurnBasedCombat (false);
+	}
+
+	void activateOrDeactivateTurnBasedCombat (bool state)
+	{
+		if (!mainTurnBasedCombatUISystemLocated) {
+			mainTurnBasedCombatUISystemLocated = mainTurnBasedCombatUISystem != null;
+
+			if (!mainTurnBasedCombatUISystemLocated) {
+				mainTurnBasedCombatUISystem = FindObjectOfType<turnBasedCombatUISystem> ();
+
+				mainTurnBasedCombatUISystemLocated = mainTurnBasedCombatUISystem != null;
+			}
+		}
+
+		if (mainTurnBasedCombatUISystemLocated) {
+			if (state) {
+				mainTurnBasedCombatUISystem.checkMainPlayerStateBeforeActivateCombat ();
+			}
+
+			mainTurnBasedCombatUISystem.openOrCloseMenuPanel (state);
+		}
+	}
+
+	public void setTurnBasedCombatActiveState (bool state)
+	{
+		if (turnBasedCombatEnabled) {
+			turnBasedCombatActive = state;
+
+			if (turnBasedCombatActive) {					
+				if (mainPlayer == null) {
+					findMainPlayer ();
+				}
+
+				if (mainPlayer != null) {
+					if (useCustomCameraState) {
+						setCameraState (customCameraState);
+					} else {
+						setCameraState (defaultCameraStateNameOnTurnBasedCombatActive);
+					}
+
+				} else {
+					print ("WARNING: Main Player not found on scene");
+
+					return;
+				}
+
+				if (currentPlayerFriendList != null) {
+					currentPlayerFriendList.Clear ();
+				}
+
+				currentPlayerFriendList = mainFriendListManager.getAllFriendList ();
+
+				updateCoroutine = StartCoroutine (updateSystemCoroutine ());
+			} else {
+				setCameraState (defaultCameraStateNameOnReturnCameraToPlayer);
+
+				stopUpdateCoroutine ();
+			}
+		}
+	}
+
+	public void setMinTeamAmountToCheck (int newAmount)
+	{
+		minTeamAmountToCheck = newAmount;
+	}
+
+	void setCameraState (string cameraStateName)
+	{
+		int cameraStateIndex = turnBasedCombatCameraInfoList.FindIndex (s => s.Name.Equals (cameraStateName));
+
+		if (cameraStateIndex == -1) {
+			for (int i = 0; i < turnBasedCombatCameraInfoList.Count; i++) {
+				if (cameraStateIndex == -1) {
+					if (turnBasedCombatCameraInfoList [i].minTeamAmountToCheck != 0 &&
+					    turnBasedCombatCameraInfoList [i].minTeamAmountToCheck >= minTeamAmountToCheck) {
+						cameraStateIndex = i;
+					}
+				}
+			}
+		}
+
+		if (cameraStateIndex > -1) {
+
+			currentTurnBasedCombatCameraInfo = turnBasedCombatCameraInfoList [cameraStateIndex];
+
+			mainCameraTargetRotation = Quaternion.identity;
+			mainCameraTargetPosition = Vector3.zero;
+
+			if (currentTurnBasedCombatCameraInfo.setCameraBackToPlayer) {
+				if (cameraParentTransform != null) {
+					mainCamera.transform.SetParent (cameraParentTransform);
+
+					cameraParentTransform = null;
+				}
+			} else {
+				if (cameraParentTransform == null) {
+					cameraParentTransform = mainCamera.transform.parent;
+				}
+
+				mainCamera.transform.SetParent (currentTurnBasedCombatCameraInfo.cameraPosition);
+			}
+
+			if (currentTurnBasedCombatCameraInfo.smoothCameraMovement) {
+				stopMovement ();
+
+				cameraState = StartCoroutine (adjustCamera ());
+			} else {
+				mainCamera.transform.localRotation = mainCameraTargetRotation;
+				mainCamera.transform.localPosition = mainCameraTargetPosition;
+			}
+		}
+	}
+
+	IEnumerator adjustCamera ()
+	{
+		Transform mainCameraTransform = mainCamera.transform;
+
+		if (currentTurnBasedCombatCameraInfo.useFixedLerpMovement) {
+			float i = 0;
+			//store the current rotation of the camera
+			Quaternion currentQ = mainCameraTransform.localRotation;
+			//store the current position of the camera
+			Vector3 currentPos = mainCameraTransform.localPosition;
+
+			//translate position and rotation camera
+			while (i < 1) {
+				i += Time.deltaTime * currentTurnBasedCombatCameraInfo.fixedLerpMovementSpeed;
+
+				mainCameraTransform.localRotation = Quaternion.Lerp (currentQ, mainCameraTargetRotation, i);
+				mainCameraTransform.localPosition = Vector3.Lerp (currentPos, mainCameraTargetPosition, i);
+
+				yield return null;
+			}
+
+		} else {
+
+			float dist = GKC_Utils.distance (mainCameraTransform.localPosition, mainCameraTargetPosition);
+
+			float duration = dist / currentTurnBasedCombatCameraInfo.regularMovementSpeed;
+
+			float t = 0;
+
+			float movementTimer = 0;
+
+			bool targetReached = false;
+
+			float angleDifference = 0;
+
+			float positionDifference = 0;
+
+			while (!targetReached) {
+				t += Time.deltaTime / duration; 
+
+				mainCameraTransform.localPosition = Vector3.Lerp (mainCameraTransform.localPosition, mainCameraTargetPosition, t);
+				mainCameraTransform.localRotation = Quaternion.Lerp (mainCameraTransform.localRotation, mainCameraTargetRotation, t);
+
+				angleDifference = Quaternion.Angle (mainCameraTransform.localRotation, mainCameraTargetRotation);
+
+				positionDifference = GKC_Utils.distance (mainCameraTransform.localPosition, mainCameraTargetPosition);
+
+				movementTimer += Time.deltaTime;
+
+				if ((positionDifference < 0.01f && angleDifference < 0.2f) || movementTimer > (duration + 1)) {
+					targetReached = true;
+				}
+
+				yield return null;
+			}
+		}
+	}
+
+	public void stopMovement ()
+	{
+		if (cameraState != null) {
+			StopCoroutine (cameraState);
+		}
+	}
+
+	public void setCurrentPlayer (GameObject player)
+	{
+		mainPlayer = player;
+
+		if (mainPlayer != null) {
+			mainPlayerComponentsManager = mainPlayer.GetComponent<playerComponentsManager> ();
+
+			playerCameraManager = mainPlayerComponentsManager.getPlayerCamera ();
+
+			mainCamera = playerCameraManager.getMainCamera ();
+
+			mainAIAroundManager = mainPlayerComponentsManager.getAIAroundManager ();
+
+			mainFriendListManager = mainPlayerComponentsManager.getFriendListManager ();
+		}
+	}
+
+	public turnBasedCombatTeamPositionsInfoData getTurnBasedCombatTeamPositionsInfoData (int teamSize, string teamPositionInfoName, bool isPlayerTeam)
+	{
+		int currentIndex = -1;
+
+		if (teamPositionInfoName != "") {
+			currentIndex = turnBasedCombatTeamPositionsInfoDataList.FindIndex (s => s.Name.Equals (teamPositionInfoName));
+
+			if (currentIndex > -1) {
+				bool getDataResult = true;
+
+				if (turnBasedCombatTeamPositionsInfoDataList [currentIndex].turnBasedCombatCharacterPositionsInfoList.Count < teamSize) {
+					getDataResult = false;
+				}
+
+				if (getDataResult) {
+					return turnBasedCombatTeamPositionsInfoDataList [currentIndex];
+				}
+			}
+		} 
+			
+		int turnBasedCombatTeamPositionsInfoDataListCount = turnBasedCombatTeamPositionsInfoDataList.Count;
+
+		for (int i = 0; i < turnBasedCombatTeamPositionsInfoDataListCount; i++) {
+			if (turnBasedCombatTeamPositionsInfoDataList [i].turnBasedCombatCharacterPositionsInfoList.Count == teamSize) {
+
+				if (turnBasedCombatTeamPositionsInfoDataList [i].usedForPlayerTeam == isPlayerTeam) {
+					currentIndex = i;
+				}
+			}
+		}
+
+		if (currentIndex > -1) {
+			return turnBasedCombatTeamPositionsInfoDataList [currentIndex];
+		}
+
+		return null;
+	}
+
+	public void setUseCustomCameraState (bool state, string cameraStateName)
+	{
+		useCustomCameraState = state;
+
+		customCameraState = cameraStateName;
+	}
+
+	public List<Transform> getPositionToRespawnList ()
+	{
+		return positionToRespawnList;
+	}
+
+	public Vector3 getClosestRespawnPosition (Vector3 currentPosition)
+	{
+		float minDistance = Mathf.Infinity;
+
+		int positionToRespawnListCount = positionToRespawnList.Count;
+
+		int closestPointIndex = -1;
+
+		for (int i = 0; i < positionToRespawnListCount; i++) {
+			float currentDistance = GKC_Utils.distance (positionToRespawnList [i].position, currentPosition);
+
+			if (currentDistance < minDistance) {
+				minDistance = currentDistance;
+
+				closestPointIndex = i;
+			}
+		}
+
+		if (closestPointIndex != -1) {
+			return positionToRespawnList [closestPointIndex].position;
+		}
+
+		return Vector3.zero;
+	}
+
+	public void updateAllCharacterStatsUIValue ()
+	{
+		if (turnBasedCombatActive) {
+			if (mainTurnBasedCombatUISystemLocated) {
+				mainTurnBasedCombatUISystem.updateAllCharacterStatsUIValue ();
+			}
+		}
+	}
+
+	public void setNextTurn ()
+	{
+		if (turnBasedCombatActive) {
+			if (mainTurnBasedCombatUISystemLocated) {
+				mainTurnBasedCombatUISystem.setNextTurn ();
+			}
+		}
+	}
+
+	public void setCurrentCommandNameUsed (string commandName)
+	{
+		if (turnBasedCombatActive) {
+			if (mainTurnBasedCombatUISystemLocated) {
+				mainTurnBasedCombatUISystem.setCurrentCommandNameUsed (commandName);
+			}
+		}
+	}
+
+	public void activateEffect (string effectName)
+	{
+		if (turnBasedCombatActive) {
+			if (effectName == "") {
+				effectName = defaultEffectName;
+			}
+
+			int effectIndex = turnBasedCombatEffectInfoList.FindIndex (s => s.Name.Equals (effectName));
+
+			if (effectIndex > -1) {
+				turnBasedCombatEffectInfo currentTurnBasedCombatEffectInfo = turnBasedCombatEffectInfoList [effectIndex];
+
+				if (currentTurnBasedCombatEffectInfo.effectEnabled) {
+					currentTurnBasedCombatEffectInfo.eventOnEffect.Invoke ();
+				}
+			}
+		}
+	}
+
+	public void setFreeCombatActiveState (bool state)
+	{
+		freeCombatActive = state;
+
+		if (mainTurnBasedCombatUISystemLocated) {
+			mainTurnBasedCombatUISystem.setFreeCombatActiveStateOnAllCharacters (state);
+		}
+	}
+
+	public void checkTeamsDeadStateAfterCharacterDeath (Transform characterTransform)
+	{
+		if (mainTurnBasedCombatUISystemLocated) {
+			mainTurnBasedCombatUISystem.checkTeamsDeadStateAfterCharacterDeath (characterTransform);
+		}
+	}
+
+	public void checkCharacterStateAfterResurrect (Transform characterTransform)
+	{
+		if (mainTurnBasedCombatUISystemLocated) {
+			mainTurnBasedCombatUISystem.checkCharacterStateAfterResurrect (characterTransform);
+		}
+	}
+
+	public void checkPlayerStateOnDeathDuringCombat ()
+	{
+		if (mainTurnBasedCombatUISystemLocated) {
+			mainTurnBasedCombatUISystem.checkPlayerStateOnDeathDuringCombat ();
+		}
+	}
+
+	//INPUT FUNCTIONS
+	public void inputConfirmCommand ()
+	{
+		if (turnBasedCombatActive) {
+			if (mainTurnBasedCombatUISystemLocated) {
+				mainTurnBasedCombatUISystem.inputConfirmCommand ();
+			}
+		}
+	}
+
+	public void inputCancelCommand ()
+	{
+		if (turnBasedCombatActive) {
+			if (mainTurnBasedCombatUISystemLocated) {
+				mainTurnBasedCombatUISystem.inputCancelCommand ();
+			}
+		}
+	}
+
+	public void inputSelectNextTarget ()
+	{
+		if (turnBasedCombatActive) {
+			if (mainTurnBasedCombatUISystemLocated) {
+				mainTurnBasedCombatUISystem.inputSelectNextTarget ();
+			}
+		}
+	}
+
+	public void inputSelectPreviousTarget ()
+	{
+		if (turnBasedCombatActive) {
+			if (mainTurnBasedCombatUISystemLocated) {
+				mainTurnBasedCombatUISystem.inputSelectPreviousTarget ();
+			}
+		}
+	}
+
+	public void inputToggleCombatMode ()
+	{
+		if (turnBasedCombatActive || freeCombatActive) {
+			if (mainTurnBasedCombatUISystemLocated) {
+				mainTurnBasedCombatUISystem.inputToggleCombatMode ();
+			}
+		}
+	}
+
+	public void configureNewTeamInfo ()
+	{
+		bool teamConfiguredProperly = false;
+
+		if (newCharacterTeamLeader != null && newCharacterTeamInfoList.Count > 0) {
+
+			List<GameObject> characterGameobjectTeamList = new List<GameObject> ();
+
+			int newCharacterTeamInfoListCount = newCharacterTeamInfoList.Count;
+
+			playerComponentsManager currentPlayerComponentsManager = newCharacterTeamLeader.GetComponentInChildren<playerComponentsManager> ();
+
+			if (currentPlayerComponentsManager != null) {
+				newCharacterTeamLeader = currentPlayerComponentsManager.gameObject;
+			}
+				
+			for (int i = 0; i < newCharacterTeamInfoListCount; i++) {
+				if (newCharacterTeamInfoList [i] != null) {
+					currentPlayerComponentsManager = newCharacterTeamInfoList [i].GetComponentInChildren<playerComponentsManager> ();
+
+					if (currentPlayerComponentsManager != null) {
+						characterGameobjectTeamList.Add (currentPlayerComponentsManager.gameObject);
+					}
+				}
+			}
+
+			int characterGameobjectTeamListCount = characterGameobjectTeamList.Count;
+
+			for (int i = 0; i < characterGameobjectTeamListCount; i++) {
+
+				currentPlayerComponentsManager = characterGameobjectTeamList [i].GetComponentInChildren<playerComponentsManager> ();
+
+				if (currentPlayerComponentsManager != null) {
+					GameObject currentCharacterGameObject = currentPlayerComponentsManager.gameObject;
+
+					turnBasedCombatTeamInfo	currentTurnBasedCombatTeamInfo = currentPlayerComponentsManager.getTurnBasedCombatTeamInfo ();
+
+					currentTurnBasedCombatTeamInfo.clearCharacterTeamList ();
+
+					currentTurnBasedCombatTeamInfo.setCharacterTeamList (characterGameobjectTeamList);
+
+					currentTurnBasedCombatTeamInfo.isTeamLeader = (currentCharacterGameObject == newCharacterTeamLeader);
+
+					print ("is leader " + currentTurnBasedCombatTeamInfo.isTeamLeader);
+
+					currentTurnBasedCombatTeamInfo.teamPositionDataName = teamPositionDataName;
+
+					currentTurnBasedCombatTeamInfo.thisTeamAlwaysSelectFirst = newTeamAlwaysSelectFirst;
+
+					currentTurnBasedCombatTeamInfo.useCustomCameraState = useCustomCameraStateOnNewTeam;
+
+					currentTurnBasedCombatTeamInfo.customCameraState = customCameraStateOnNewTeam;
+
+					if (useRewardSystem) {
+						currentTurnBasedCombatTeamInfo.useRewardSystem = true;
+
+						if (mainRewardSystem != null) {
+							currentTurnBasedCombatTeamInfo.mainRewardSystem = mainRewardSystem;
+						}
+					}
+
+					GKC_Utils.updateComponent (currentTurnBasedCombatTeamInfo);
+
+					GKC_Utils.updateDirtyScene ("Update Turn Based Team Combat System", currentTurnBasedCombatTeamInfo.gameObject);
+				}
+			}
+
+			teamConfiguredProperly = true;
+		}
+
+		if (teamConfiguredProperly) {
+			newCharacterTeamLeader = null;
+
+			teamPositionDataName = "";
+
+			newTeamAlwaysSelectFirst = false;
+
+			useCustomCameraStateOnNewTeam = false;
+
+			customCameraStateOnNewTeam = "";
+
+			useRewardSystem = false;
+
+			mainRewardSystem = null;
+
+			newCharacterTeamInfoList.Clear ();
+
+			print ("New Turn Based Combat Team Configured");
+
+			updateComponent ();
+		} else {
+			print ("WARNING: make sure all team info is configured properly on the inspector");
+		}
+	}
+
+	public void showAllTeamsInScene ()
+	{
+		turnBasedCombatTeamInfoOnSceneList.Clear ();
+
+		turnBasedCombatTeamInfo[] turnBasedCombatTeamInfoList = FindObjectsOfType<turnBasedCombatTeamInfo> ();
+
+		foreach (turnBasedCombatTeamInfo currentTurnBasedCombatTeamInfo in turnBasedCombatTeamInfoList) {
+			if (currentTurnBasedCombatTeamInfo.isTeamLeaderValue ()) {
+				turnBasedCombatTeamInfoOnSceneList.Add (currentTurnBasedCombatTeamInfo);
+			}
+		}
+
+		updateComponent ();
+	}
+
+	public void updateComponent ()
+	{
+		GKC_Utils.updateComponent (this);
+
+		GKC_Utils.updateDirtyScene ("Update Turn Based Combat System", gameObject);
+	}
+
+	[System.Serializable]
+	public class turnBasedCombatCameraInfo
+	{
+		public string Name;
+
+		public Transform cameraPosition;
+
+		[Space]
+
+		public int minTeamAmountToCheck;
+
+		[Space]
+
+		public bool useFixedLerpMovement = true;
+		public float fixedLerpMovementSpeed = 2;
+
+		public float regularMovementSpeed = 2;
+
+		public bool smoothCameraMovement = true;
+
+		public bool setCameraBackToPlayer;
+	}
+
+	[System.Serializable]
+	public class turnBasedCombatEffectInfo
+	{
+		public string Name;
+
+		public bool effectEnabled = true;
+
+		[Space]
+
+		public UnityEvent eventOnEffect;
+	}
+}