public List <Reaction> Evaluate(CharacterTraits traits, Memory memory, PerceivedEvent perceivedEvent)
{
return(new List <Reaction>
{
new Reaction
{
Tone = Tone.Sarcastic,
Target = perceivedEvent.Source,
Intent = Intent.Neutral,
ActionType = ActionType.Verbal,
InitialEvent = perceivedEvent,
EventType = EventType.Interaction,
ReactionScore = 0,
EventName = "Yeah",
Message = "Yeah...",
AssociatedKarma = 0,
IntervalToNextReaction = 1
},
new Reaction
{
Tone = Tone.Sarcastic,
Target = perceivedEvent.Source,
Intent = Intent.Neutral,
ActionType = ActionType.Verbal,
InitialEvent = perceivedEvent,
EventType = EventType.Interaction,
ReactionScore = 0,
EventName = "YouKnowMe",
Message = "It's like you've known me all my life.",
AssociatedKarma = 0
}
});
}
/// <summary>
/// Initializes all qualities with a random value, to be adjusted later
/// </summary>
/// <param name="traits">character traits</param>
private static void RandomlyInitializeAllQualities(CharacterTraits traits)
{
traits.Acuity = RandomValueGenerator.GenerateMidRangeAttributeValue();
traits.Adaptiveness = RandomValueGenerator.GenerateMidRangeAttributeValue();
traits.Ambition = RandomValueGenerator.GenerateMidRangeAttributeValue();
traits.Assertiveness = RandomValueGenerator.GenerateMidRangeAttributeValue();
traits.Awareness = RandomValueGenerator.GenerateMidRangeAttributeValue();
traits.Changing = RandomValueGenerator.GenerateMidRangeAttributeValue();
traits.Charisma = RandomValueGenerator.GenerateMidRangeAttributeValue();
traits.Charitable = RandomValueGenerator.GenerateMidRangeAttributeValue();
traits.Compassion = RandomValueGenerator.GenerateMidRangeAttributeValue();
traits.Confidence = RandomValueGenerator.GenerateMidRangeAttributeValue();
traits.Conscience = RandomValueGenerator.GenerateMidRangeAttributeValue();
traits.CriticalSense = RandomValueGenerator.GenerateMidRangeAttributeValue();
traits.Determination = RandomValueGenerator.GenerateMidRangeAttributeValue();
traits.Energetic = RandomValueGenerator.GenerateMidRangeAttributeValue();
traits.Expressiveness = RandomValueGenerator.GenerateMidRangeAttributeValue();
traits.Gregariousness = RandomValueGenerator.GenerateMidRangeAttributeValue();
traits.Imagination = RandomValueGenerator.GenerateMidRangeAttributeValue();
traits.Introspection = RandomValueGenerator.GenerateMidRangeAttributeValue();
traits.Inventiveness = RandomValueGenerator.GenerateMidRangeAttributeValue();
traits.Memory = RandomValueGenerator.GenerateMidRangeAttributeValue();
traits.Modesty = RandomValueGenerator.GenerateMidRangeAttributeValue();
traits.Quietude = RandomValueGenerator.GenerateMidRangeAttributeValue();
traits.Outlook = RandomValueGenerator.GenerateMidRangeAttributeValue();
traits.SelfEsteem = RandomValueGenerator.GenerateMidRangeAttributeValue();
traits.Selflessness = RandomValueGenerator.GenerateMidRangeAttributeValue();
traits.Sociability = RandomValueGenerator.GenerateMidRangeAttributeValue();
traits.Tolerance = RandomValueGenerator.GenerateMidRangeAttributeValue();
traits.Tact = RandomValueGenerator.GenerateMidRangeAttributeValue();
traits.Willpower = RandomValueGenerator.GenerateMidRangeAttributeValue();
}
/// <summary>
/// Evaluates all rules and applies them
/// </summary>
/// <param name="traits">character traits</param>
public void EvaluateAndApplyAllRules(CharacterTraits traits)
{
var rules = GetAllEmotionalTraitRules();
foreach (var rule in rules)
{
var quality = traits.GetType().GetProperty(rule.Quality);
var emotion = traits.LongTermEmotions.GetType().GetProperty(rule.Emotion);
if (quality == null || emotion == null)
{
continue;
}
int randomValue = RandomValueGenerator.GeneratePercentileIntegerValue();
int qualityValue = (int)quality.GetValue(traits);
int currentEmotionValue = (int)emotion.GetValue(traits.LongTermEmotions);
if (rule.IsComparedBelowQualityValue && qualityValue > randomValue ||
(!rule.IsComparedBelowQualityValue && qualityValue < randomValue))
{
//If conditions are met, emotion is modified, but by at most 3.
emotion.SetValue(traits.LongTermEmotions, currentEmotionValue + RandomValueGenerator.GenerateIntWithMaxValue(3));
}
}
}
public List <Reaction> Evaluate(CharacterTraits traits, Memory memory, PerceivedEvent perceivedEvent)
{
return(new List <Reaction>
{
new Reaction
{
Tone = Tone.Casual,
Target = perceivedEvent.Source,
Intent = Intent.Neutral,
ActionType = ActionType.Verbal,
InitialEvent = perceivedEvent,
EventType = EventType.Interaction,
ReactionScore = 0,
EventName = "ImGood",
Message = "I'm good", //TODO: Randomize
Source = perceivedEvent.Target,
IntervalToNextReaction = 1
},
new Reaction
{
Tone = Tone.Casual,
Target = perceivedEvent.Source,
Intent = Intent.Neutral,
ActionType = ActionType.Verbal,
InitialEvent = perceivedEvent,
EventType = EventType.Interaction,
ReactionScore = 0,
EventName = "AndYou",
Message = "And you?", //TODO: Randomize
Source = perceivedEvent.Target
}
});
}
/// <summary>
/// Evaluates rule that can work one way
/// </summary>
/// <param name="traits">character traits to modify</param>
/// <param name="rule">rules to evaluate</param>
private static void EvaluateSimpleRule(CharacterTraits traits, QualityTraitRule rule)
{
var leadingProperty = traits.GetType().GetProperty(rule.LeadingQuality);
var attachedProperty = traits.GetType().GetProperty(rule.AttachedQuality);
if (leadingProperty == null || attachedProperty == null)
{
return;
}
int leadingValue;
int attachedValue;
if (ValuesAreWithinRange(traits, rule, leadingProperty, attachedProperty, out leadingValue, out attachedValue))
{
return;
}
if (leadingValue > attachedValue)
{
//We won't raise if it's a weakness
if (!traits.WeakPoints.Contains(rule.AttachedQuality))
{
attachedProperty.SetValue(traits, leadingValue - rule.RangeLimit + 1);
}
}
else
{
//We won't lower it if it's a strong point
if (!traits.StrongPoints.Contains(rule.AttachedQuality))
{
attachedProperty.SetValue(traits, leadingValue + rule.RangeLimit - 1);
}
}
}
public List <Reaction> Evaluate(CharacterTraits traits, Memory memory, PerceivedEvent perceivedEvent)
{
return(new List <Reaction>
{
new Reaction
{
Tone = Tone.Enthusiastic,
Target = perceivedEvent.Source,
Intent = Intent.Friendly,
ActionType = ActionType.Verbal,
InitialEvent = perceivedEvent,
EventType = EventType.Interaction,
ReactionScore = 0,
EventName = "FriendlyImGood",
Message = "I'm doing well", //TODO: Randomize
Source = perceivedEvent.Target,
IntervalToNextReaction = 1
},
new Reaction
{
Tone = Tone.Enthusiastic,
Target = perceivedEvent.Source,
Intent = Intent.Friendly,
ActionType = ActionType.Verbal,
InitialEvent = perceivedEvent,
EventType = EventType.Interaction,
ReactionScore = 0,
EventName = "WhatAboutYou",
Message = "And you?", //TODO: Randomize
Source = perceivedEvent.Target
}
});
}
public void EvaluateAndApplyAllRules_RandomlyGeneratedCharacter_ValuesNormalizedAfterCall()
{
//Arrange
QualityRuleEvaluator evaluator = new QualityRuleEvaluator();
CharacterTraits traits = new CharacterTraits("Lara Croft", Sex.Female)
{
Adaptiveness = 90,
Changing = 45,
Inventiveness = 20,
Imagination = 66,
WeakPoints = new List <string> {
"Inventiveness"
},
StrongPoints = new List <string> {
"Adaptiveness"
}
};
var currentQualityValues = traits.GetPersonalQualitiesValues();
//Act
evaluator.EvaluateAndApplyAllRules(traits);
var newValues = traits.GetPersonalQualitiesValues();
int differenceCount = currentQualityValues.Count(qualityValue => qualityValue.Value != newValues[qualityValue.Key]);
//Assert
Assert.IsTrue(differenceCount > 0);
}
public List <Reaction> Evaluate(CharacterTraits traits, Memory memory, PerceivedEvent perceivedEvent)
{
return(new List <Reaction>
{
new Reaction
{
Tone = Tone.Annoyed,
Target = perceivedEvent.Source,
Intent = Intent.Hostile,
ActionType = ActionType.NonVerbal,
InitialEvent = perceivedEvent,
EventType = EventType.Interaction,
ReactionScore = 0,
EventName = "Pause",
Message = $"{memory.Me.Name} pauses.",
AssociatedKarma = 0,
IntervalToNextReaction = 5
},
new Reaction
{
Tone = Tone.Annoyed,
Target = perceivedEvent.Source,
Intent = Intent.Hostile,
ActionType = ActionType.Verbal,
InitialEvent = perceivedEvent,
EventType = EventType.Interaction,
ReactionScore = 0,
EventName = "WhoAreYou",
Message = "And who are you?",
AssociatedKarma = -1
}
});
}
/// <summary>
/// Main method - template for the FileController evaluation
/// </summary>
/// <param name="traits">Character Traits</param>
/// <param name="memory">Character's Memory and knowledge</param>
/// <param name="perceivedEvent">Event to evaluate</param>
/// <returns>Character's reaction</returns>
public List <Reaction> Evaluate(CharacterTraits traits, Memory.Memory memory, PerceivedEvent perceivedEvent)
{
List <Reaction> reactions;
if (EvaluateNode(perceivedEvent, memory, traits))
{
if (RightNode == null)
{
throw new NullNodeException($"Right node for node {this} is missing.");
}
reactions = RightNode.Evaluate(traits, memory, perceivedEvent);
if (RightNode.GetNodeType() == "Node")
{
DataToMemorize.AddRange(((AbstractDecisionNode)RightNode).DataToMemorize);
}
}
else
{
if (LeftNode == null)
{
throw new NullNodeException($"Left node for node {this} is missing.");
}
reactions = LeftNode.Evaluate(traits, memory, perceivedEvent);
if (LeftNode.GetNodeType() == "Node")
{
DataToMemorize.AddRange(((AbstractDecisionNode)LeftNode).DataToMemorize);
}
}
return(reactions);
}
/// <summary>
///
/// </summary>
/// <param name="traits"></param>
/// <param name="rule"></param>
/// <param name="leadingProperty"></param>
/// <param name="attachedProperty"></param>
/// <param name="leadingValue"></param>
/// <param name="attachedValue"></param>
/// <returns></returns>
private static bool ValuesAreWithinRange(CharacterTraits traits, QualityTraitRule rule, PropertyInfo leadingProperty,
PropertyInfo attachedProperty, out int leadingValue, out int attachedValue)
{
leadingValue = (int)leadingProperty.GetValue(traits);
attachedValue = (int)attachedProperty.GetValue(traits);
return(Math.Abs(leadingValue - attachedValue) <= rule.RangeLimit);
}
public void SetQualityAttributeByIndex_IndexOfCriticalSense_CriticalSenseSetTo87()
{
//Arrange
CharacterTraits traits = new CharacterTraits("Deadpool", Sex.Male, Orientation.Undefined, Gender.Genderfluid);
//Act
traits.SetQualityAttributeByIndex(11, 87);
//Assert
Assert.AreEqual(87, traits.CriticalSense);
}
public void Initialize_NewCharacterTraits_ValuesInitializedAndAdjusted()
{
CharacterTraits traits = new CharacterTraits("Ronald McDonald", Sex.Male, Orientation.Straight, Gender.Male);
new RandomInitializationMethod().Initialize(ref traits, new QualityRuleEvaluator(), new EmotionRuleEvaluator());
Assert.IsFalse(traits.GetPersonalQualitiesValues().Any(x => x.Value == 0));
Assert.IsTrue(traits.PersonalValues.Count == 3);
Assert.IsFalse(traits.GetEmotionalStateValues().Any(x => x.Value > 12));
}
public void GetPersonalQualitiesValues_NormalCharacterCreation_29QualitiesExpected()
{
//Arrange
CharacterTraits traits = new CharacterTraits("Fred Flintstone", Sex.Male);
//Act
var list = traits.GetPersonalQualitiesValues();
//Assert
Assert.AreEqual(list.Count, CharacterTraits.GetPersonalQualitiesCount());
}
///<inheritdoc/>
protected override void AdjustQualitiesAccordingToArchetype(CharacterTraits traits)
{
//Strong points
traits.Modesty = RandomValueGenerator.GenerateStrongAttributeValue();
traits.Tolerance = RandomValueGenerator.GenerateStrongAttributeValue();
traits.Changing = RandomValueGenerator.GenerateStrongAttributeValue();
//Weak points
traits.Compassion = RandomValueGenerator.GenerateWeakAttributeValue();
traits.Conscience = RandomValueGenerator.GenerateWeakAttributeValue();
}
///<inheritdoc/>
protected override void AdjustQualitiesAccordingToArchetype(CharacterTraits traits)
{
//Strong points
traits.Acuity = RandomValueGenerator.GenerateStrongAttributeValue();
traits.Expressiveness = RandomValueGenerator.GenerateStrongAttributeValue();
traits.Inventiveness = RandomValueGenerator.GenerateStrongAttributeValue();
//Weak points
traits.Conscience = RandomValueGenerator.GenerateWeakAttributeValue();
traits.Selflessness = RandomValueGenerator.GenerateWeakAttributeValue();
}
///<inheritdoc/>
protected override void AdjustQualitiesAccordingToArchetype(CharacterTraits traits)
{
//Strong points
traits.Ambition = RandomValueGenerator.GenerateStrongAttributeValue();
traits.Imagination = RandomValueGenerator.GenerateStrongAttributeValue();
traits.Adaptiveness = RandomValueGenerator.GenerateStrongAttributeValue();
//Weak points
traits.Tolerance = RandomValueGenerator.GenerateWeakAttributeValue();
traits.Introspection = RandomValueGenerator.GenerateWeakAttributeValue();
}
///<inheritdoc/>
protected override void AdjustQualitiesAccordingToArchetype(CharacterTraits traits)
{
//Strong points
traits.Charisma = RandomValueGenerator.GenerateStrongAttributeValue();
traits.Expressiveness = RandomValueGenerator.GenerateStrongAttributeValue();
traits.Sociability = RandomValueGenerator.GenerateStrongAttributeValue();
//Weak points
traits.Ambition = RandomValueGenerator.GenerateWeakAttributeValue();
traits.Willpower = RandomValueGenerator.GenerateWeakAttributeValue();
}
///<inheritdoc/>
protected override void AdjustQualitiesAccordingToArchetype(CharacterTraits traits)
{
//Strong points
traits.Assertiveness = RandomValueGenerator.GenerateStrongAttributeValue();
traits.Determination = RandomValueGenerator.GenerateStrongAttributeValue();
traits.Expressiveness = RandomValueGenerator.GenerateStrongAttributeValue();
//Weak points
traits.Inventiveness = RandomValueGenerator.GenerateWeakAttributeValue();
traits.Imagination = RandomValueGenerator.GenerateWeakAttributeValue();
}
///<inheritdoc/>
protected override void AdjustQualitiesAccordingToArchetype(CharacterTraits traits)
{
//Strong points
traits.CriticalSense = RandomValueGenerator.GenerateStrongAttributeValue();
traits.Compassion = RandomValueGenerator.GenerateStrongAttributeValue();
traits.Determination = RandomValueGenerator.GenerateStrongAttributeValue();
//Weak points
traits.Outlook = RandomValueGenerator.GenerateWeakAttributeValue();
traits.Gregariousness = RandomValueGenerator.GenerateWeakAttributeValue();
}
///<inheritdoc/>
protected override void AdjustQualitiesAccordingToArchetype(CharacterTraits traits)
{
//Strong points
traits.Determination = RandomValueGenerator.GenerateStrongAttributeValue();
traits.Tolerance = RandomValueGenerator.GenerateStrongAttributeValue();
traits.Willpower = RandomValueGenerator.GenerateStrongAttributeValue();
//Weak points
traits.Changing = RandomValueGenerator.GenerateWeakAttributeValue();
traits.Imagination = RandomValueGenerator.GenerateWeakAttributeValue();
}
///<inheritdoc/>
protected override void AdjustQualitiesAccordingToArchetype(CharacterTraits traits)
{
//Strong points
traits.Awareness = RandomValueGenerator.GenerateStrongAttributeValue();
traits.CriticalSense = RandomValueGenerator.GenerateStrongAttributeValue();
traits.Memory = RandomValueGenerator.GenerateStrongAttributeValue();
//Weak points
traits.Outlook = RandomValueGenerator.GenerateWeakAttributeValue();
traits.Imagination = RandomValueGenerator.GenerateWeakAttributeValue();
}
///<inheritdoc/>
protected override void AdjustQualitiesAccordingToArchetype(CharacterTraits traits)
{
//Strong points
traits.Compassion = RandomValueGenerator.GenerateStrongAttributeValue();
traits.Selflessness = RandomValueGenerator.GenerateStrongAttributeValue();
traits.Tolerance = RandomValueGenerator.GenerateStrongAttributeValue();
//Weak points
traits.Introspection = RandomValueGenerator.GenerateWeakAttributeValue();
traits.SelfEsteem = RandomValueGenerator.GenerateWeakAttributeValue();
AddRandomWeakPoint(traits);
}
public BaseCharacterTraits(CharacterTraits traits)
{
if (traits == null)
{
return;
}
Calculating = traits.Calculating;
Generosity = traits.Generosity;
Honor = traits.Honor;
Mercy = traits.Mercy;
Valor = traits.Valor;
}
/// <summary>
/// Evaluates rule that can work both ways
/// </summary>
/// <param name="traits">character traits to modify</param>
/// <param name="rule">rules to evaluate</param>
private void EvaluateBidirectionalRule(CharacterTraits traits, QualityTraitRule rule)
{
var leadingProperty = traits.GetType().GetProperty(rule.LeadingQuality);
var attachedProperty = traits.GetType().GetProperty(rule.AttachedQuality);
if (leadingProperty == null || attachedProperty == null)
{
return;
}
int leadingValue;
int attachedValue;
if (ValuesAreWithinRange(traits, rule, leadingProperty, attachedProperty, out leadingValue, out attachedValue))
{
return;
}
if (leadingValue > attachedValue)
{
//If the attached is a weak point AND the leading is a NOT a strong point,
//then we just lower the leading property. Otherwise we raise the attached quality.
if (traits.WeakPoints.Contains(rule.AttachedQuality))
{
if (!traits.StrongPoints.Contains(rule.LeadingQuality))
{
leadingProperty.SetValue(traits, attachedValue + rule.RangeLimit + 1);
}
}
else
{
attachedProperty.SetValue(traits, leadingValue - rule.RangeLimit + 1);
}
}
else
{
//If the leading value is a weakness AND the attached is not a strong point,
//we lower the attached property. Otherwise we raise the leading quality
if (traits.WeakPoints.Contains(rule.LeadingQuality))
{
if (!traits.StrongPoints.Contains(rule.AttachedQuality))
{
attachedProperty.SetValue(traits, leadingValue + rule.RangeLimit - 1);
}
}
else
{
leadingProperty.SetValue(traits, attachedValue - rule.RangeLimit + 1);
}
}
}
/// <summary>
/// Evaluate and applies all rules, no exception
/// </summary>
/// <param name="traits">character traits</param>
public void EvaluateAndApplyAllRules(CharacterTraits traits)
{
var rules = GetAllPersonalQualitiesRules();
foreach (var rule in rules)
{
if (rule.IsBidirectional)
{
EvaluateBidirectionalRule(traits, rule);
}
else
{
EvaluateSimpleRule(traits, rule);
}
}
}
///<inheritdoc/>
protected override void SetPersonalValuesAccordingToArchetype(CharacterTraits traits)
{
int numberOfValues = Enum.GetValues(typeof(PersonalValues)).Length;
while (traits.PersonalValues.Count < 3)
{
int valueIndex = RandomValueGenerator.GenerateIntWithMaxValue(numberOfValues);
var personalValue = (PersonalValues)valueIndex;
if (!traits.PersonalValues.Contains(personalValue))
{
traits.PersonalValues.Add(personalValue);
}
}
}
public static bool Prefix(int sacrificedMenCount)
{
bool flag = sacrificedMenCount >= 1;
if (flag)
{
Support.LogMessage("The troops left behind march bravely to their fates.");
bool player_trait_skill_gain_enabled = Support.settings.player_trait_skill_gain_enabled;
if (player_trait_skill_gain_enabled)
{
Campaign.Current.PlayerTraitDeveloper.AddTraitXp(DefaultTraits.Mercy, -(3 * sacrificedMenCount));
Campaign.Current.PlayerTraitDeveloper.AddTraitXp(DefaultTraits.Honor, -sacrificedMenCount);
}
List <Hero> heroesInMainParty = Support.GetHeroesInMainParty();
int num = sacrificedMenCount / 5;
bool flag2 = num < 2;
if (flag2)
{
num = 2;
}
int num2 = num / 2;
for (int i = 0; i < heroesInMainParty.Count; i++)
{
bool flag3 = (Support.settings.battle_companions_bad_reputation_enabled && heroesInMainParty[i].IsPlayerCompanion) || (Support.settings.battle_family_bad_reputation_enabled && !heroesInMainParty[i].IsPlayerCompanion);
if (flag3)
{
CharacterTraits heroTraits = heroesInMainParty[i].GetHeroTraits();
int num3 = Support.EvaluatePersonality(heroTraits);
int num4 = num3;
if (num4 != 1)
{
if (num4 == 4)
{
Support.ChangeRelation(Hero.MainHero, heroesInMainParty[i], Support.Random(-num2, 0));
}
}
else
{
Support.ChangeRelation(Hero.MainHero, heroesInMainParty[i], Support.Random(-num, 0));
}
}
}
}
return(false);
}
public List <Reaction> Evaluate(CharacterTraits traits, Memory memory, PerceivedEvent perceivedEvent)
{
return(new List <Reaction>
{
new Reaction
{
Target = perceivedEvent.Source,
Intent = Intent.Friendly,
ActionType = ActionType.NonVerbal,
InitialEvent = perceivedEvent,
EventType = EventType.Interaction,
ReactionScore = 0,
EventName = "Laugh",
Message = $"{perceivedEvent.Target} laughs.", //TODO: Randomize
Source = perceivedEvent.Target
}
});
}
public List <Reaction> Evaluate(CharacterTraits traits, Memory memory, PerceivedEvent perceivedEvent)
{
return(new List <Reaction>
{
new Reaction
{
Tone = Tone.Curious,
Target = perceivedEvent.Source,
Intent = Intent.Neutral,
ActionType = ActionType.Verbal,
InitialEvent = perceivedEvent,
EventType = EventType.Interaction,
ReactionScore = 0,
EventName = "AskWhy",
Message = "Why?"
}
});
}
public List <Reaction> Evaluate(CharacterTraits traits, Memory memory, PerceivedEvent perceivedEvent)
{
return(new List <Reaction>
{
new Reaction
{
Tone = Tone.Disappointed,
Target = perceivedEvent.Source,
Intent = Intent.Hostile,
ActionType = ActionType.Verbal,
InitialEvent = perceivedEvent,
EventType = EventType.Interaction,
ReactionScore = 0,
EventName = "AskWhy",
Message = "Why are you acting like this?"
}
});
}
