예제 #1
0
    public int CalculateFinalSuccessChanceOfChoiceData(StoryChoiceDataSO choice)
    {
        Debug.Log("StoryEventController.CalculateFinalSuccessChanceOfChoiceData() called, " +
                  "base success chance = " + choice.baseSuccessChance.ToString() + "%");

        // initialize return value at the choice's base success chance
        int chanceReturned = choice.baseSuccessChance;

        // dont modify base success chance if the choice is marked as being unmodifiable
        if (!choice.ignoreChanceModifiers)
        {
            foreach (SuccessChanceModifier scm in choice.successChanceModifiers)
            {
                chanceReturned += CalculateFinalValueOfSuccessChanceModifier(scm);
            }
        }

        // Prevent success chance exceding 100%
        if (chanceReturned > 100)
        {
            chanceReturned = 100;
        }
        // Prevent success chance dropping below 0%
        else if (chanceReturned < 0)
        {
            chanceReturned = 0;
        }

        Debug.Log("StoryEventController.CalculateFinalSuccessChanceOfChoiceData() final success chance calculated = " +
                  chanceReturned.ToString() + "%");

        return(chanceReturned);
    }
예제 #2
0
    public StoryChoiceButton BuildChoiceButtonFromChoiceData(StoryChoiceDataSO data)
    {
        Debug.Log("StoryEventController.BuildChoiceButtonFromChoiceData() called for choice: " + data.description);

        // Create game object, parent to the vertical fitter
        StoryChoiceButton newButton = Instantiate(choiceButtonPrefab, choiceButtonsParent.transform).GetComponent <StoryChoiceButton>();

        // Cache data
        newButton.myChoiceData = data;
        activeChoiceButtons.Add(newButton);

        // Set button main label text
        newButton.descriptionText.text = data.description;

        // set requirment text
        AutoSetChoiceButtonRequirementText(newButton, data);

        // set consequence texts
        AutoSetChoiceButtonSuccessConsequencesText(newButton, data);
        AutoSetChoiceButtonFailureConsequencesText(newButton, data);

        // calculate success chance, set related text values
        newButton.successChanceText.text = CalculateFinalSuccessChanceOfChoiceData(newButton.myChoiceData).ToString() + "%";

        // return the button just made
        return(newButton);
    }
예제 #3
0
    public void AutoSetChoiceButtonFailureConsequencesText(StoryChoiceButton button, StoryChoiceDataSO data)
    {
        Debug.Log("StoryEventController.AutoSetChoiceButtonFailureConsequencesText() called for button: '" +
                  data.description + "'");

        string consequencesString = "";

        // Disable the on failure text elements if they are not needed
        if (data.onFailureConsequences.Count == 0)
        {
            button.onFailureTextRowParent.SetActive(false);
        }
        else
        {
            foreach (ChoiceConsequence cc in data.onFailureConsequences)
            {
                // Add the choice requirement to the final string
                consequencesString += ConvertChoiceConsequenceToString(cc);

                // Seperate each requirement with a comma, if it is not the last req in list
                if (cc != data.onFailureConsequences.Last())
                {
                    consequencesString += ", ";
                }
            }
        }

        // Apply generated string to description text component
        button.failureConsequenceText.text = consequencesString;
    }
예제 #4
0
    public void AutoSetChoiceButtonRequirementText(StoryChoiceButton button, StoryChoiceDataSO data)
    {
        Debug.Log("StoryEventController.AutoSetChoiceButtonRequirementText() called for button: '" +
                  data.description + "'");

        string requirementString = "";

        // if there are no requirements in choice req list, just set text to 'None'
        if (data.choiceRequirements.Count == 0)
        {
            requirementString = "None";
        }
        else
        {
            foreach (ChoiceRequirment cr in data.choiceRequirements)
            {
                // Add the choice requirement to the final string
                requirementString += ConvertChoiceRequirementToString(cr);

                // Seperate each requirement with a comma, if it is not the last req in list
                if (cr != data.choiceRequirements.Last())
                {
                    requirementString += ", ";
                }
            }
        }

        // Apply generated string to description text component
        button.requirementsText.text = requirementString;
    }
예제 #5
0
    public void AutoSetChoiceButtonSuccessConsequencesText(StoryChoiceButton button, StoryChoiceDataSO data)
    {
        Debug.Log("StoryEventController.AutoSetChoiceButtonSuccessConsequencesText() called for button: '" +
                  data.description + "'");

        string consequencesString = "";

        foreach (ChoiceConsequence cc in data.onSuccessConsequences)
        {
            // Add the choice requirement to the final string
            consequencesString += ConvertChoiceConsequenceToString(cc);

            // Seperate each requirement with a comma, if it is not the last req in list
            if (cc != data.onSuccessConsequences.Last())
            {
                consequencesString += ", ";
            }
        }

        // Apply generated string to description text component
        button.successConsequenceText.text = consequencesString;
    }
예제 #6
0
    public bool AreChoiceButtonRequirementsMet(StoryChoiceDataSO data)
    {
        Debug.Log("StoryEventController.AreChoiceButtonRequirementsMet() checking button: " + data.description);

        // return true;
        // TODO: uncomment in future, when we want this to work properly in the actual game

        bool        boolReturned      = true;
        List <bool> requirementChecks = new List <bool>();

        // Evaluate each requirement condition individually
        foreach (ChoiceRequirment cr in data.choiceRequirements)
        {
            // Check for none: guaranteed pass
            if (cr.requirementType == ChoiceRequirment.RequirementType.None)
            {
                Debug.Log("Choice Requirement Met: Choice Button does not have any requirements");
                requirementChecks.Add(true);
            }

            // Check Gold
            else if (cr.requirementType == ChoiceRequirment.RequirementType.HasEnoughGold)
            {
                if (PlayerDataManager.Instance.currentGold >= cr.goldAmountRequired)
                {
                    Debug.Log("Choice Requirement Met: Choice Button has a gold requirement of " + cr.goldAmountRequired +
                              ", player currently has " + PlayerDataManager.Instance.currentGold);
                    requirementChecks.Add(true);
                }
                else
                {
                    Debug.Log("Choice Requirement NOT Met: Choice Button has a gold requirement of " + cr.goldAmountRequired +
                              ", player currently has " + PlayerDataManager.Instance.currentGold);
                    requirementChecks.Add(false);
                }
            }

            // Check backgrounds
            else if (cr.requirementType == ChoiceRequirment.RequirementType.HasBackground)
            {
                bool passedBgCheck = false;

                if (CharacterRoster.Instance)
                {
                    foreach (CharacterData cd in CharacterRoster.Instance.allCharacterDataObjects)
                    {
                        if (cd.backgrounds.Contains(cr.backgroundRequirement))
                        {
                            passedBgCheck = true;
                        }
                    }
                }

                if (passedBgCheck)
                {
                    Debug.Log("Choice Requirement Met: Player has a character in party with the required background of "
                              + cr.backgroundRequirement);

                    requirementChecks.Add(true);
                }
                else
                {
                    Debug.Log("Choice Requirement NOT Met: Player does not have a character in party with the required background of "
                              + cr.backgroundRequirement);
                    requirementChecks.Add(false);
                }
            }

            // Check racials
            else if (cr.requirementType == ChoiceRequirment.RequirementType.HasRace)
            {
                bool passedRacialCheck = false;

                foreach (CharacterData cd in CharacterRoster.Instance.allCharacterDataObjects)
                {
                    if (cd.myRace == cr.raceRequirement)
                    {
                        passedRacialCheck = true;
                    }
                }

                if (passedRacialCheck)
                {
                    Debug.Log("Choice Requirement Met: Player has a character in party with the required race of "
                              + cr.raceRequirement);
                    requirementChecks.Add(true);
                }
                else
                {
                    Debug.Log("Choice Requirement NOT Met: Player does not have a character in party with the required race of "
                              + cr.raceRequirement);
                    requirementChecks.Add(false);
                }
            }

            // Check talents
            else if (cr.requirementType == ChoiceRequirment.RequirementType.HasTalent)
            {
                bool passTalentCheck = false;

                // check the talent type + tier requirement value against each character in player's party
                foreach (CharacterData cd in CharacterRoster.Instance.allCharacterDataObjects)
                {
                    if (cr.talentTypeRequirement == AbilityDataSO.AbilitySchool.Assassination &&
                        cd.assassinationPoints >= cr.talentTierRequirement)
                    {
                        passTalentCheck = true;
                    }
                    else if (cr.talentTypeRequirement == AbilityDataSO.AbilitySchool.Brawler &&
                             cd.brawlerPoints >= cr.talentTierRequirement)
                    {
                        passTalentCheck = true;
                    }
                    else if (cr.talentTypeRequirement == AbilityDataSO.AbilitySchool.Corruption &&
                             cd.corruptionPoints >= cr.talentTierRequirement)
                    {
                        passTalentCheck = true;
                    }
                    else if (cr.talentTypeRequirement == AbilityDataSO.AbilitySchool.Cyromancy &&
                             cd.cyromancyPoints >= cr.talentTierRequirement)
                    {
                        passTalentCheck = true;
                    }
                    else if (cr.talentTypeRequirement == AbilityDataSO.AbilitySchool.Divinity &&
                             cd.divinityPoints >= cr.talentTierRequirement)
                    {
                        passTalentCheck = true;
                    }
                    else if (cr.talentTypeRequirement == AbilityDataSO.AbilitySchool.Duelist &&
                             cd.duelistPoints >= cr.talentTierRequirement)
                    {
                        passTalentCheck = true;
                    }
                    else if (cr.talentTypeRequirement == AbilityDataSO.AbilitySchool.Guardian &&
                             cd.guardianPoints >= cr.talentTierRequirement)
                    {
                        passTalentCheck = true;
                    }
                    else if (cr.talentTypeRequirement == AbilityDataSO.AbilitySchool.Manipulation &&
                             cd.manipulationPoints >= cr.talentTierRequirement)
                    {
                        passTalentCheck = true;
                    }
                    else if (cr.talentTypeRequirement == AbilityDataSO.AbilitySchool.Naturalism &&
                             cd.naturalismPoints >= cr.talentTierRequirement)
                    {
                        passTalentCheck = true;
                    }
                    else if (cr.talentTypeRequirement == AbilityDataSO.AbilitySchool.Pyromania &&
                             cd.pyromaniaPoints >= cr.talentTierRequirement)
                    {
                        passTalentCheck = true;
                    }
                    else if (cr.talentTypeRequirement == AbilityDataSO.AbilitySchool.Ranger &&
                             cd.rangerPoints >= cr.talentTierRequirement)
                    {
                        passTalentCheck = true;
                    }
                    else if (cr.talentTypeRequirement == AbilityDataSO.AbilitySchool.Shadowcraft &&
                             cd.shadowcraftPoints >= cr.talentTierRequirement)
                    {
                        passTalentCheck = true;
                    }
                }

                if (passTalentCheck)
                {
                    Debug.Log("Choice Requirement Met: Player has a character in party with the required talent of "
                              + cr.talentTypeRequirement.ToString() + "(" + cr.talentTierRequirement.ToString() + ")");
                    requirementChecks.Add(true);
                }
                else
                {
                    Debug.Log("Choice Requirement NOT Met: Player does not have a character in party with the required talent of "
                              + cr.talentTypeRequirement.ToString() + "(" + cr.talentTierRequirement.ToString() + ")");
                    requirementChecks.Add(false);
                }
            }

            // if we get here, it means the code to check the enum related to
            // the requirement has not been written...
            else
            {
                Debug.Log("StoryEventController.AreChoiceButtonRequirementsMet() detected that the requirement type enum value '" + cr.requirementType.ToString() +
                          "' is not recognized and cannot be evaluated, returning false by default...");
                requirementChecks.Add(false);
            }
        }

        // did we fail any of the requirment checks?
        if (requirementChecks.Contains(false))
        {
            // we did, return false
            boolReturned = false;
        }

        return(boolReturned);
    }