add ckg

plantilla base para movimiento básico

Assets/Game Kit Controller/Scripts/AI/Faction/factionSystem.cs

@@ -0,0 +1,583 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class factionSystem : MonoBehaviour
+{
+    public List<factionInfo> factionList = new List<factionInfo> ();
+
+    public string [] factionStringList;
+
+    public List<characterFactionManager> characterFactionManagerList = new List<characterFactionManager> ();
+
+
+    public const string mainManagerName = "Faction System";
+
+    public static string getMainManagerName ()
+    {
+        return mainManagerName;
+    }
+
+    private static factionSystem _factionSystemInstance;
+
+    public static factionSystem Instance { get { return _factionSystemInstance; } }
+
+    bool instanceInitialized;
+
+
+    public void getComponentInstance ()
+    {
+        if (instanceInitialized) {
+            return;
+        }
+
+        if (_factionSystemInstance != null && _factionSystemInstance != this) {
+            Destroy (this.gameObject);
+
+            return;
+        }
+
+        _factionSystemInstance = this;
+
+        instanceInitialized = true;
+    }
+
+    void Awake ()
+    {
+        getComponentInstance ();
+    }
+
+    public void addCharacterToList (characterFactionManager character)
+    {
+        characterFactionManagerList.Add (character);
+    }
+
+    public void removeCharacterToList (characterFactionManager character)
+    {
+        characterFactionManagerList.Remove (character);
+    }
+
+    public bool isCharacterFriendly (int ownFactionIndex, string characterToCheckFactionName)
+    {
+        factionInfo currentFactionInfo = factionList [ownFactionIndex];
+
+        if (currentFactionInfo.Name.Equals (characterToCheckFactionName)) {
+            return true;
+        }
+
+        int relationWithFactionsCount = currentFactionInfo.relationWithFactions.Count;
+
+        for (int j = 0; j < relationWithFactionsCount; j++) {
+
+            relationInfo currentRelationInfo = currentFactionInfo.relationWithFactions [j];
+
+            if (currentRelationInfo.factionName.Equals (characterToCheckFactionName)) {
+                if (currentRelationInfo.relation == relationInfo.relationType.friend) {
+                    return true;
+                } else {
+                    return false;
+                }
+            }
+        }
+
+        return false;
+    }
+
+    public bool isCharacterEnemy (int ownFactionIndex, string characterToCheckFacionName)
+    {
+        factionInfo currentFactionInfo = factionList [ownFactionIndex];
+
+        if (currentFactionInfo.Name.Equals (characterToCheckFacionName)) {
+            return false;
+        }
+
+        int relationWithFactionsCount = currentFactionInfo.relationWithFactions.Count;
+
+        for (int j = 0; j < relationWithFactionsCount; j++) {
+            relationInfo currentRelationInfo = currentFactionInfo.relationWithFactions [j];
+
+            if (currentRelationInfo.factionName.Equals (characterToCheckFacionName)) {
+                if (currentRelationInfo.relation == relationInfo.relationType.enemy) {
+
+                    //					print ("checking relation of " + currentFactionInfo + " with " + currentRelationInfo.factionName);
+
+                    return true;
+                } else {
+                    return false;
+                }
+            }
+        }
+
+        return true;
+    }
+
+    public bool isAttackerEnemy (int ownFactionIndex, string characterToCheckFacionName, bool checkForFriendlyFactionAttackers, bool changeFactionRelationWithFriendlyAttackers)
+    {
+        factionInfo currentFactionInfo = factionList [ownFactionIndex];
+
+        if (currentFactionInfo.Name.Equals (characterToCheckFacionName)) {
+            if (currentFactionInfo.friendlyFireTurnIntoEnemies) {
+                return true;
+            }
+
+            return false;
+        }
+
+        int relationWithFactionsCount = currentFactionInfo.relationWithFactions.Count;
+
+        for (int j = 0; j < relationWithFactionsCount; j++) {
+            relationInfo currentRelationInfo = currentFactionInfo.relationWithFactions [j];
+
+            if (currentRelationInfo.factionName.Equals (characterToCheckFacionName)) {
+                if (currentRelationInfo.relation == relationInfo.relationType.enemy) {
+                    return true;
+                } else {
+                    if (checkForFriendlyFactionAttackers && currentFactionInfo.turnToEnemyIfAttack) {
+                        if (changeFactionRelationWithFriendlyAttackers) {
+                            if (currentFactionInfo.turnFactionToEnemy) {
+                                changeFactionRelation (ownFactionIndex, characterToCheckFacionName, relationInfo.relationType.enemy);
+                            }
+                        }
+
+                        return true;
+                    } else {
+                        return false;
+                    }
+                }
+            }
+        }
+
+        return true;
+    }
+
+    public bool isCharacterNeutral (int ownFactionIndex, string characterToCheckFacionName)
+    {
+        factionInfo currentFactionInfo = factionList [ownFactionIndex];
+
+        if (currentFactionInfo.Name.Equals (characterToCheckFacionName)) {
+            return false;
+        }
+
+        int relationWithFactionsCount = currentFactionInfo.relationWithFactions.Count;
+
+        for (int j = 0; j < relationWithFactionsCount; j++) {
+            relationInfo currentRelationInfo = currentFactionInfo.relationWithFactions [j];
+
+            if (currentRelationInfo.factionName.Equals (characterToCheckFacionName)) {
+                if (currentRelationInfo.relation == relationInfo.relationType.neutral) {
+                    return true;
+                } else {
+                    return false;
+                }
+            }
+        }
+
+        return true;
+    }
+
+    public void changeFactionRelation (int ownFactionIndex, string otherFactionName, relationInfo.relationType relationType)
+    {
+        factionInfo currentFactionInfo = factionList [ownFactionIndex];
+
+        if (!currentFactionInfo.Name.Equals (otherFactionName)) {
+            int relationWithFactionsCount = currentFactionInfo.relationWithFactions.Count;
+
+            for (int j = 0; j < relationWithFactionsCount; j++) {
+                relationInfo currentRelationInfo = currentFactionInfo.relationWithFactions [j];
+
+                if (currentRelationInfo.factionName.Equals (otherFactionName)) {
+                    currentRelationInfo.relation = relationType;
+                }
+            }
+        }
+
+        int characterFactionManagerListCount = characterFactionManagerList.Count;
+
+        for (int i = 0; i < characterFactionManagerListCount; i++) {
+            characterFactionManager currentCharacterFactionManager = characterFactionManagerList [i];
+
+            if (currentCharacterFactionManager.factionName.Equals (currentFactionInfo.Name)) {
+                currentCharacterFactionManager.checkCharactersAround ();
+            }
+        }
+    }
+
+    public void removeEnemiesFromNewFriendFaction (int ownFactionIndex)
+    {
+        factionInfo currentFactionInfo = factionList [ownFactionIndex];
+
+        int characterFactionManagerListCount = characterFactionManagerList.Count;
+
+        for (int i = 0; i < characterFactionManagerListCount; i++) {
+            characterFactionManager currentCharacterFactionManager = characterFactionManagerList [i];
+
+            if (currentCharacterFactionManager.factionName.Equals (currentFactionInfo.Name)) {
+
+                GKC_Utils.removeEnemiesFromNewFriendFaction (currentCharacterFactionManager.characterTransform);
+            }
+        }
+    }
+
+    public void removeEnemiesFromCharacter (int ownFactionIndex, Transform characterTransform)
+    {
+        factionInfo currentFactionInfo = factionList [ownFactionIndex];
+
+        int characterFactionManagerListCount = characterFactionManagerList.Count;
+
+        for (int i = 0; i < characterFactionManagerListCount; i++) {
+            characterFactionManager currentCharacterFactionManager = characterFactionManagerList [i];
+
+            if (currentCharacterFactionManager.factionName.Equals (currentFactionInfo.Name) && characterTransform == currentCharacterFactionManager.characterTransform) {
+
+                GKC_Utils.removeEnemiesFromNewFriendFaction (currentCharacterFactionManager.characterTransform);
+
+                return;
+            }
+        }
+    }
+
+    public void removeCharacterAsTargetFromEnemies (int ownFactionIndex, GameObject characterToRemove)
+    {
+        factionInfo currentFactionInfo = factionList [ownFactionIndex];
+
+        string factionNameToCheck = currentFactionInfo.Name;
+
+        int characterFactionManagerListCount = characterFactionManagerList.Count;
+
+        for (int i = 0; i < characterFactionManagerListCount; i++) {
+            characterFactionManager currentCharacterFactionManager = characterFactionManagerList [i];
+
+            bool characterEnemyOfCharacterToRemove = isCharacterEnemy (currentCharacterFactionManager.factionIndex, factionNameToCheck);
+
+            if (characterEnemyOfCharacterToRemove) {
+
+                //print (currentCharacterFactionManager.characterTransform.gameObject.name + " is enemy of " + characterToRemove.name);
+
+                GKC_Utils.removeTargetFromAICharacter (characterToRemove, currentCharacterFactionManager.characterTransform.gameObject);
+            }
+        }
+    }
+
+    public bool checkIfCharacterBelongsToFaction (string factionName, GameObject character)
+    {
+        if (character == null) {
+            return false;
+        }
+
+        characterFactionManager characterFactionToCheck = character.GetComponent<characterFactionManager> ();
+
+        if (characterFactionToCheck != null) {
+            if (characterFactionToCheck.factionName.Equals (factionName)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    public bool isCharacterDetectedAsEnemyByOtherFaction (GameObject characterToCheck)
+    {
+        int characterFactionManagerListCount = characterFactionManagerList.Count;
+
+        for (int i = 0; i < characterFactionManagerListCount; i++) {
+            if (characterFactionManagerList [i].currentDetectedEnemyList.Contains (characterToCheck)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    public void alertFactionOnSpotted (int ownFactionIndex, float alertCloseFactionRadius, GameObject target, Vector3 alertPosition)
+    {
+        string factionNameToCheck = factionList [ownFactionIndex].Name;
+
+        //		print (factionNameToCheck);
+
+        int characterFactionManagerListCount = characterFactionManagerList.Count;
+
+        for (int i = 0; i < characterFactionManagerListCount; i++) {
+            characterFactionManager currentCharacterFactionManager = characterFactionManagerList [i];
+
+            if (currentCharacterFactionManager.factionName.Equals (factionNameToCheck)) {
+                float distance = GKC_Utils.distance (currentCharacterFactionManager.getCharacterTransform ().position, alertPosition);
+
+                //				print ("distance to target " + characterFactionManagerList [i].getCharacterTransform ().name + " " + distance);
+
+                if (distance <= alertCloseFactionRadius) {
+                    currentCharacterFactionManager.alertFaction (target);
+                }
+            }
+        }
+    }
+
+    public void removeCharacterAsTargetOnSameFaction (GameObject characterToCheck, int ownFactionIndex)
+    {
+        factionInfo currentFactionInfo = factionList [ownFactionIndex];
+
+        string factionNameToCheck = currentFactionInfo.Name;
+
+        int characterFactionManagerListCount = characterFactionManagerList.Count;
+
+        //		print ("faction to remove " + factionNameToCheck + " character to remove " + characterToCheck.name);
+
+        for (int i = 0; i < characterFactionManagerListCount; i++) {
+            characterFactionManager currentCharacterFactionManager = characterFactionManagerList [i];
+
+            bool characterEnemyOfNewFaction = isCharacterEnemy (currentCharacterFactionManager.factionIndex, factionNameToCheck);
+
+            //			print (characterEnemyOfNewFaction);
+
+            if (currentCharacterFactionManager.factionName.Equals (factionNameToCheck) || !characterEnemyOfNewFaction) {
+                currentCharacterFactionManager.sendSignalToRemoveCharacterAsTargetOnSameFaction (characterToCheck);
+
+                //				print ("remove enemy turned into friend or neutral from " + currentCharacterFactionManager.gameObject.name);
+            }
+        }
+    }
+
+
+    //EDITOR FUNCTIONS
+    public void addFaction ()
+    {
+        factionInfo newFactionInfo = new factionInfo ();
+        newFactionInfo.Name = "New Faction";
+        factionList.Add (newFactionInfo);
+
+        updateComponent ();
+    }
+
+    public void removeFaction (int factionIndexToRemove)
+    {
+        //		print ("Removing " + factionList [factionIndexToRemove].Name + " faction");
+
+        factionList.RemoveAt (factionIndexToRemove);
+
+        updateComponent ();
+    }
+
+    public void updateFactionsList ()
+    {
+        int previousFactionAmount = factionStringList.Length;
+
+        getFactionStringList ();
+
+        int newFactionAmount = factionStringList.Length;
+
+        if (previousFactionAmount > newFactionAmount) {
+            print (previousFactionAmount - newFactionAmount + " factions were removed");
+        } else if (previousFactionAmount < newFactionAmount) {
+            print (newFactionAmount - previousFactionAmount + " factions were added");
+        } else {
+            print ("No factions were added or removed");
+        }
+
+        if (factionList.Count > 1) {
+            int i = 0;
+            int j = 0;
+            int k = 0;
+
+            print ("Checking for factions removed");
+
+            for (i = 0; i < factionStringList.Length; i++) {
+                if (checkIfFactionExists (factionStringList [i])) {
+
+                } else {
+                    print ("faction " + factionStringList [i] + " was removed, removing relation with " + factionList [i].Name);
+
+                    for (j = 0; j < factionList.Count; j++) {
+                        for (k = factionList [j].relationWithFactions.Count - 1; k >= 0; k--) {
+                            if (factionList [j].relationWithFactions [k].factionName.Equals (factionStringList [i])) {
+                                factionList [j].relationWithFactions.RemoveAt (k);
+                            }
+                        }
+                    }
+                }
+            }
+
+            for (i = 0; i < factionList.Count; i++) {
+                for (j = factionList [i].relationWithFactions.Count - 1; j >= 0; j--) {
+                    if (!checkIfFactionExistsInStringList (factionList [i].relationWithFactions [j].factionName)) {
+                        print ("faction " + factionList [i].relationWithFactions [j].factionName + " was removed, removing relation with " + factionList [i].Name);
+
+                        factionList [i].relationWithFactions.RemoveAt (j);
+                    }
+                }
+            }
+
+            print ("Updating factions relations index");
+
+            for (i = 0; i < factionList.Count; i++) {
+                for (j = 0; j < factionList [i].relationWithFactions.Count; j++) {
+                    int factionIndex = getFactionIndex (factionList [i].relationWithFactions [j].factionName);
+
+                    if (factionIndex > -1) {
+                        if (factionList [i].relationWithFactions [j].factionIndex > factionIndex) {
+                            print ("Updating faction " + factionList [i].Name + " relation index on faction " +
+                            factionList [i].relationWithFactions [j].factionName + " with index " + factionIndex);
+
+                            factionList [i].relationWithFactions [j].factionIndex = factionIndex;
+                        }
+                    }
+                }
+            }
+
+            print ("Updating relations with new factions added");
+
+            for (i = 0; i < factionList.Count; i++) {
+                for (j = 0; j < factionList.Count; j++) {
+                    if (!factionList [i].Name.Equals (factionList [j].Name)) {
+
+                        bool containsRelation = factionContainsRelation (i, factionStringList [j]);
+
+                        if (!containsRelation) {
+                            print ("New relation to configure on " + factionList [i].Name + " and " + factionStringList [j] + " has been added");
+
+                            relationInfo newRelationInfo = new relationInfo ();
+                            newRelationInfo.factionName = factionStringList [j];
+                            newRelationInfo.factionIndex = j;
+                            factionList [i].relationWithFactions.Add (newRelationInfo);
+                        }
+                    }
+                }
+            }
+        }
+
+        updateComponent ();
+    }
+
+    public int getFactionIndex (string factionName)
+    {
+        int factionListCount = factionList.Count;
+
+        for (int i = 0; i < factionListCount; i++) {
+            if (factionList [i].Name.Equals (factionName)) {
+                return i;
+            }
+        }
+
+        return -1;
+    }
+
+    public bool checkIfFactionExists (string factionName)
+    {
+        int factionListCount = factionList.Count;
+
+        for (int i = 0; i < factionListCount; i++) {
+            if (factionList [i].Name.Equals (factionName)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    public bool checkIfFactionExistsInStringList (string factionName)
+    {
+        int factionStringListLength = factionStringList.Length;
+
+        for (int i = 0; i < factionStringListLength; i++) {
+            if (factionStringList [i].Equals (factionName)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    public bool factionContainsRelation (int factionIndex, string factionWithRelation)
+    {
+        factionInfo currentFactionInfo = factionList [factionIndex];
+
+        if (currentFactionInfo.Name.Equals (factionWithRelation)) {
+            return true;
+        }
+
+        int relationWithFactionsCount = currentFactionInfo.relationWithFactions.Count;
+
+        for (int j = 0; j < relationWithFactionsCount; j++) {
+            if (currentFactionInfo.relationWithFactions [j].factionName.Equals (factionWithRelation)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    public void setAllRelationsAsFriendOrEnemyOnFaction (int factionIndex, int relationTypeIndex)
+    {
+        if (factionIndex >= factionList.Count) {
+            return;
+        }
+
+        factionInfo currentFactionInfo = factionList [factionIndex];
+
+        int relationWithFactionsCount = currentFactionInfo.relationWithFactions.Count;
+
+        for (int j = 0; j < relationWithFactionsCount; j++) {
+
+            if (relationTypeIndex == 0) {
+                currentFactionInfo.relationWithFactions [j].relation = relationInfo.relationType.friend;
+            }
+
+            if (relationTypeIndex == 1) {
+                currentFactionInfo.relationWithFactions [j].relation = relationInfo.relationType.enemy;
+            }
+
+            if (relationTypeIndex == 2) {
+                currentFactionInfo.relationWithFactions [j].relation = relationInfo.relationType.neutral;
+            }
+        }
+
+        updateComponent ();
+    }
+    public void getFactionStringList ()
+    {
+        factionStringList = new string [factionList.Count];
+
+        for (int i = 0; i < factionList.Count; i++) {
+            string newFactionName = factionList [i].Name;
+
+            factionStringList [i] = newFactionName;
+        }
+    }
+
+    public void updateFactionListNames ()
+    {
+        getFactionStringList ();
+
+        updateComponent ();
+    }
+
+    public void updateComponent ()
+    {
+        GKC_Utils.updateComponent (this);
+
+        GKC_Utils.updateDirtyScene ("Update Faction System values", gameObject);
+    }
+
+    [System.Serializable]
+    public class factionInfo
+    {
+        public string Name;
+        public bool turnToEnemyIfAttack;
+        public bool turnFactionToEnemy;
+        public bool friendlyFireTurnIntoEnemies;
+        public List<relationInfo> relationWithFactions = new List<relationInfo> ();
+    }
+
+    [System.Serializable]
+    public class relationInfo
+    {
+        public string factionName;
+        public int factionIndex;
+        public relationType relation;
+
+        public enum relationType
+        {
+            friend,
+            enemy,
+            neutral
+        }
+    }
+}