public static Character GetCharacter(string cID)
        {
            GlobalGameData gameDataRef = GameObject.Find("GameManager").GetComponent<GlobalGameData>();
            Character cData = new Character();

            cData = gameDataRef.CharacterList.Find(p => p.ID == cID);
            return cData;
        }
        public static string GenerateInitialDialogue(Character cData)
        {
            int choices = IntroGenericSentences.Count;
            int choice = 0;
            int sentenceCount = 0;
            string activeString = "";
            string completeString = "";

            // get initial sentence first
            choice = UnityEngine.Random.Range(0, IntroGreetingSentences.Count);

            activeString = IntroGreetingSentences[choice];
            activeString = ParseSentence(activeString, cData);

            completeString += activeString + " ";

            List<int> choiceList = new List<int>();
            sentenceCount = UnityEngine.Random.Range(1, sentenceMax);

            for (int x = 0; x < sentenceCount; x++)
            {
                if (choices > 0 && choiceList.Count < choices)
                {
                    chooseSentence:
                    choice = UnityEngine.Random.Range(0, choices);
                    if (choiceList.Contains(choice))
                        goto chooseSentence;
                    else
                    {
                        choiceList.Add(choice);
                        activeString = IntroGenericSentences[choice];
                        activeString = ParseSentence(activeString, cData);
                    }

                    completeString += activeString + " ";
                }
                else
                    return "No applicable string found.";
            }

            return completeString;
        }
        public static string GenerateResponse(Character cData, CharacterAction aData, float responseIndex, bool requiresDecision)
        {
            string activeString = "";
            if (requiresDecision)
            {
                if (responseIndex > 65)
                    activeString = GenerateAffirmativeResponse(cData, aData);
                else if (responseIndex > 35)
                    activeString = GenerateUndecidedResponse(cData, aData);
                else
                    activeString = GenerateDeclineResponse(cData, aData);
            }
            else
            {
                if (responseIndex > 65)
                    activeString = GeneratePositiveResponse(cData, aData); // change to positive response
                else if (responseIndex > 35)
                    activeString = GenerateNeutralResponse(cData, aData); // change to negative response
                else
                    activeString = GenerateNegativeResponse(cData, aData); // change to negative response
            }

            return activeString;
        }
        private static string ParseSentence(string activeString, Character cData)
        {
            if (activeString.Contains("[EMPEROR]"))
            {
                string newString;
                newString = activeString.Replace("[EMPEROR]", "Emperor " + HelperFunctions.DataRetrivalFunctions.GetCivLeader(cData.CivID).Name);
                activeString = newString;
            }

            if (activeString.Contains("[PLANET]"))
            {
                string newString;
                newString = activeString.Replace("[PLANET]", HelperFunctions.DataRetrivalFunctions.GetPlanet(cData.PlanetLocationID).Name);
                activeString = newString;
            }

            if (activeString.Contains("[HOUSE]"))
            {
                string newString;
                newString = activeString.Replace("[HOUSE]", cData.AssignedHouse.Name);
                activeString = newString;
            }

            if (activeString.Contains("[SPORTSTEAM]"))
            {
                string newString;
                bool positiveAdjective = false;
                newString = activeString.Replace("[SPORTSTEAM]", SportsTeamNames[UnityEngine.Random.Range(0, SportsTeamNames.Count)]);
                activeString = newString;

                if (activeString.Contains("[SPORTSRESULT"))
                {
                    string result = "";

                    int y = UnityEngine.Random.Range(0, 100);
                    if (y < 40)
                    {
                        result = "WON";
                        positiveAdjective = true;
                    }
                    else if (y < 80)
                    {
                        result = "LOST";
                        positiveAdjective = false;
                    }
                    else
                    {
                        result = "TIED";
                        positiveAdjective = false;
                    }
                    newString = activeString.Replace("[SPORTSRESULT]", result);
                    activeString = newString;
                }

                if (activeString.Contains("[ADJECTIVE]"))
                {

                    string adjective;

                    if (!positiveAdjective)
                    {
                        adjective = NegativeAdjectives[UnityEngine.Random.Range(0, NegativeAdjectives.Count)];
                    }
                    else
                    {
                        adjective = PositiveAdjectives[UnityEngine.Random.Range(0, PositiveAdjectives.Count)];
                    }

                    newString = activeString.Replace("[ADJECTIVE]", adjective);
                    activeString = newString;
                }
            }

            if (activeString.Contains("[ADJECTIVE]"))
            {
                string newString;
                int adjType = UnityEngine.Random.Range(0, 100);
                string adjective;

                if (adjType > 50)
                {
                    adjective = NegativeAdjectives[UnityEngine.Random.Range(0, NegativeAdjectives.Count)];
                }
                else
                {
                    adjective = PositiveAdjectives[UnityEngine.Random.Range(0, PositiveAdjectives.Count)];
                }

                newString = activeString.Replace("[ADJECTIVE]", adjective);
                activeString = newString;
            }

            if (activeString.Contains("[COLOR]"))
            {
                string newString;
                newString = activeString.Replace("[COLOR]", Colors[UnityEngine.Random.Range(0, Colors.Count)]);
                activeString = newString;
            }

            return activeString;
        }
        private static string GenerateUndecidedResponse(Character cData, CharacterAction aData)
        {
            string activeString = "";
            //string completeString = "";
            //int choice = 0;

            activeString = "I can't decide at this time, Your Excellence.";

            return activeString; // stub to test reader
        }
        private static string GeneratePositiveResponse(Character cData, CharacterAction aData)
        {
            string activeString = "";
            //string completeString = "";
            //int choice = 0;

            activeString = "That sounds great, Your Excellence.";

            return activeString; // stub to test reader
        }
        private static string GenerateNeutralResponse(Character cData, CharacterAction aData)
        {
            string activeString = "";
            //string completeString = "";
            //int choice = 0;

            activeString = "I guess that sounds OK, Your Excellence.";

            return activeString; // stub to test reader
        }
        private static string GenerateNegativeResponse(Character cData, CharacterAction aData)
        {
            string activeString = "";
            //string completeString = "";
            //int choice = 0;

            activeString = "That is outrageous, Your Excellence!";

            return activeString; // stub to test reader
        }
        private static string GenerateDeclineResponse(Character cData, CharacterAction aData)
        {
            string activeString = "";
            //string completeString = "";
            //int choice = 0;

            activeString = "I refuse to do that, Your Excellence.";

            return activeString; // stub to test reader
        }
Пример #10
0
 public static string IssuePublicReprimand(Character cData)
 {
     return null;
 }
Пример #11
0
        public static string GivePraisingSpeech(Character cData)
        {
            GlobalGameData gDataRef = GameObject.Find("GameManager").GetComponent<GlobalGameData>();
            Character eData = gDataRef.CivList[0].Leader; // you
            CharacterAction aData = gDataRef.CharacterActionList.Find(p => p.ID == "A1");
            bool speechSuccessful = false;
            float responseIndex = 0f;
            int speechEffectiveness = 0;
            string speechSuccess = ""; // debug code

            // make check based on charm + intelligence
            if (eData.Charm >= -30)
            {
                speechEffectiveness = UnityEngine.Random.Range(30, eData.Charm) + UnityEngine.Random.Range(0, eData.Intelligence);
                if (speechEffectiveness > 80)
                {
                    speechSuccessful = true;
                    speechSuccess = "successful, value of " + speechEffectiveness.ToString("N0"); // debug code
                }
                else
                {
                    speechSuccessful = false;
                    speechSuccess = "unsuccessful, value of " + speechEffectiveness.ToString("N0"); // debug code
                }
            }
            else
            {
                speechSuccessful = false;
                speechSuccess = "unsuccessful, minimum check not passed to try"; // debug code
            }

            // now determine effect of character
            responseIndex = speechEffectiveness;
            if (speechSuccessful)
            {
                if (cData.NewRelationships[eData.ID].Trust > 50)
                {
                    cData.NewRelationships[eData.ID].Trust += UnityEngine.Random.Range(0, (speechEffectiveness / 5));
                }
                else
                {
                    cData.NewRelationships[eData.ID].Trust += UnityEngine.Random.Range(0, (speechEffectiveness / 8)); // less effective when more hated
                }

                // now determine effect of characters around them, checking each character individually
                foreach (string cID in cData.NewRelationships.Keys)
                {
                    if (cData.NewRelationships.ContainsKey(cID))
                    {
                        if (cData.NewRelationships[cID].RelationshipState == Relationship.eRelationshipState.Friends || cData.NewRelationships[cID].RelationshipState == Relationship.eRelationshipState.Allies)
                        {
                            cData.NewRelationships[cID].Trust += UnityEngine.Random.Range(0, (speechEffectiveness / 8));
                            HelperFunctions.DataRetrivalFunctions.GetCharacter(cID).NewRelationships[eData.ID].Trust += UnityEngine.Random.Range(0, (speechEffectiveness / 10)); // improve trust slightly with the emperor
                        }

                        if (cData.NewRelationships[cID].RelationshipState == Relationship.eRelationshipState.Rivals || cData.NewRelationships[cID].RelationshipState == Relationship.eRelationshipState.Vendetta)
                        {
                            cData.NewRelationships[cID].Trust -= UnityEngine.Random.Range(0, (speechEffectiveness / 8));
                            HelperFunctions.DataRetrivalFunctions.GetCharacter(cID).NewRelationships[eData.ID].Trust -= UnityEngine.Random.Range(0, (speechEffectiveness / 10)); // distrusts slightly with the emperor
                        }

                        if (cData.NewRelationships[cID].RelationshipState == Relationship.eRelationshipState.Vengeance)
                        {
                            cData.NewRelationships[cID].Trust -= UnityEngine.Random.Range(0, (speechEffectiveness / 6));
                            HelperFunctions.DataRetrivalFunctions.GetCharacter(cID).NewRelationships[eData.ID].Trust -= UnityEngine.Random.Range(0, (speechEffectiveness / 6)); // distrusts a lot with the emperor
                        }
                    }
                }
            }

            // now send to speech engine to create response and return response
            UnityEngine.Debug.Log("Give Praising Speech executed. Speech was " + speechSuccess); // debug code
            string response = ConversationEngine.GenerateResponse(cData, aData, responseIndex, false);

            return response;
        }
Пример #12
0
        public bool IsActionValid(Character cData, Civilization civ)
        {
            if (AllValid)
            {
                return true;
            }

            if (cData.Role == Character.eRole.Emperor && !EmperorAction) // if not an Emperor character action, kick
                return false;

            if (cData.Role == Character.eRole.Viceroy && !ViceroyValid)
            {
                return false;
            }

            if (cData.Role == Character.eRole.SystemGovernor && !SysGovValid)
            {
                return false;
            }

            if (cData.Role == Character.eRole.ProvinceGovernor && !ProvGovValid)
            {
                return false;
            }

            if (cData.Role == Character.eRole.DomesticPrime && !PrimeValid)
            {
                return false;
            }

            if (cData.Role == Character.eRole.Inquisitor && !InquisitorValid)
            {
                return false;
            }

            if (EmperorNearValid)
            {
                if (civ.Leader != null)
                {
                    if (cData.PlanetLocationID != civ.Leader.PlanetLocationID)
                    {
                        return false;
                    }

                }
                else
                {
                    return false; // no leader, so false anyway
                }
            }
            return true; // passed all tests so it's true
        }
 public void InitializeTooltipData(Character characterData, float offset)
 {
     cData = characterData;
     offsetAmount = offset;
 }
 public static string ConvertRoleEnum(Character.eRole role)
 {
     switch (role)
     {
         case Character.eRole.DomesticPrime:
             return "Domestic Prime";
         case Character.eRole.ProvinceGovernor:
             return "Provincial Governor";
         case Character.eRole.SystemGovernor:
             return "System Governor";
         case Character.eRole.FinancePrime:
             return "Financial Prime";
         case Character.eRole.Viceroy:
             return "Planetary Viceroy";
         default:
             return "Unknown Role";
     }
 }
        public static string GetPrime(Character.eRole charRole)
        {
            GlobalGameData gameDataRef = GameObject.Find("GameManager").GetComponent<GlobalGameData>();

            foreach (Character charData in gameDataRef.CharacterList)
            {
                if (charData.Role == charRole)
                {
                    return charData.ID;
                }
            }

            return "none";
        }