public virtual void AddIcons(DialogueOptionInitializer doi, RHSpeaker speaker, RHConversation conversation)
{
string timeStr = Time.ToString("F2") + " s";
doi.AddTextIcon(timeStr, Color.white);
for (int i = 0; i < 5; i++)
{
RHStat s = (RHStat)i;
float sum = 0;
int numListeners = 0;
foreach (RHListener l in conversation.Listeners.Keys)
{
if (l == speaker.GetComponent <RHListener>())
{
continue;
}
float f = GetPower(speaker, l, conversation, s);
sum += f;
numListeners++;
}
if (Mathf.Abs(sum) <= 1)
{
continue;
}
Color c = RHManager.ProportionToColor(GetBasePower(s), sum / numListeners);
doi.AddIcon(RHManager.GetStatIcon(s), sum.ToString("F1"), c, (sum > 0) ? Color.white : Color.red);
}
}
public virtual void OnUpdate(RHSpeaker speaker, RHListener listener, RHConversation conversation, float scaledDelta)
{
float modValue = 0;
switch (m_resourceType)
{
case RHResourceType.POSITIVE:
modValue = scaledDelta * PositiveScaleValue * Mathf.Min(3, m_Amount);
conversation.ModifyListenerPersuasion(listener, modValue);
break;
case RHResourceType.NEGATIVE:
modValue = scaledDelta * NegativeScaleValue * Mathf.Min(3, m_Amount);
conversation.ModifyListenerPersuasion(listener, modValue);
break;
case RHResourceType.QUESTION:
modValue = scaledDelta * QuestionInterestScale * Mathf.Min(3, m_Amount);
conversation.ModifyInterestTime(modValue);
break;
case RHResourceType.PERSONAL:
modValue = scaledDelta * StoryInterestScale * Mathf.Min(3, m_Amount);
conversation.ModifyInterestTime(modValue);
break;
case RHResourceType.BLUNDER:
break;
}
}
public virtual string GetHoverText(RHConversation conv)
{
string t = m_hoverText + "\n";
float value = m_basePower;
if (m_requirements.Count > 0)
{
t += "COST: ";
foreach (RHResourceType r in m_requirements.Keys)
{
int c = m_requirements[r];
t += c.ToString() + " " + r.ToString() + " ";
}
}
t += '\n';
if (displayModifierOnHover)
{
foreach (RHListener l in conv.Listeners.Keys)
{
t += l.gameObject.name;
t += " Base: " + GetPower(conv.Speakers[0], l, conv);
foreach (RHModifier m in m_modPower)
{
t += " " + m.getHoverString(value, conv, l);
value = m.ApplyModifier(value, conv, l);
}
t += "\n";
}
}
return(t);
}
public void resourceUpdate(RHConversation c, RHListener l, float conversationDelta)
{
foreach (RHResource r in m_resources)
{
r.OnUpdate(this, l, c, conversationDelta);
}
}
public void OnReceiveStatement(RHRegisteredStatement rs)
{
RHStatement statement = rs.statement;
RHSpeaker speaker = rs.speaker;
RHConversation c = rs.conversation;
GetComponent <AITaskManager>()?.triggerEvent(new AIEVStatementReceived(c, statement, speaker));
Dictionary <RHStat, float> results = new Dictionary <RHStat, float>();
for (int i = 0; i < 5; i++)
{
RHStat s = (RHStat)i;
float power = statement.GetPower(speaker, this, c, s);
float diff = applyStatementModifiers(power, rs, s);
if (diff == 0)
{
continue;
}
results[s] = diff;
ModifyStat(speaker, c, s, diff);
}
statement.OnStatementReceived(speaker, this, c, results);
RHManager.AddHistoryText(GetResponseString(statement, speaker, results));
}
public void OnRhetoricStart(RHSpeaker speaker, RHConversation conversation)
{
foreach (RHPersonalityTrait t in m_traits)
{
t.OnListenerStart(this, speaker, conversation);
}
}
public void ModifyStat(RHSpeaker s, RHConversation c, RHStat stat, float value, bool permanent = false)
{
if (stat == RHStat.CURRENT_PERSUASION_LEVEL)
{
c.ModifyListenerPersuasion(this, value);
return;
}
if (stat == RHStat.EMOTIONS)
{
m_emotionalIntensity += value;
return;
}
string label = getModifierString(s, c, permanent);
ImpressionModifier i = new ImpressionModifier(label, value);
if (!permanent)
{
if (!m_temporaryModifiers.ContainsKey(stat))
{
m_temporaryModifiers[stat] = new List <ImpressionModifier>();
}
m_temporaryModifiers[stat].Add(i);
}
GetComponent <Observer>().AddModifier(s.gameObject.name, RHStatToNoun(stat), i);
}
public virtual float GetListRankingPriority(RHSpeaker speaker, RHConversation c)
{
if (MeetsRequirements(speaker, c) == "Meets Requirements")
{
return(m_listRankingPriority - 100f);
}
return(m_listRankingPriority);
}
public virtual float GetPower(RHSpeaker speaker, RHListener listener, RHConversation c)
{
float value = m_basePower;
foreach (RHModifier m in m_modPower)
{
value = m.ApplyModifier(value, c, listener);
}
return(value);
}
public void OnRhetoricStart(List <RHStatement> availableStatements, RHConversation conversation, List <RHListener> listeners)
{
if (GetComponent <MovementBase>() != null && GetComponent <MovementBase>().IsPlayerControl)
{
//RHManager.CreateDialogueOptionList(availableStatements,this, conversation);
RHManager.SetResourceUIActive(this);
}
foreach (RHPersonalityTrait t in m_traits)
{
t.OnSpeakerStart(this, listeners, conversation);
}
}
public string getHoverString(float initialDiff, RHConversation c, RHListener l)
{
float d = getDiff(initialDiff, c, l);
string hoverStr = "";
if (d > 0)
{
hoverStr += "+";
}
else
{
hoverStr += "-";
}
hoverStr += d.ToString() + " (" + m_nameOfModifier + ")";
return(hoverStr);
}
public virtual float GetPower(RHSpeaker speaker, RHListener listener, RHConversation c, RHStat stateType = RHStat.CURRENT_PERSUASION_LEVEL)
{
float value = 0;
List <RHModifier> modList = new List <RHModifier>();
switch (stateType)
{
case RHStat.AUTHORITY:
modList = m_modAuthority;
value = m_baseAuthority;
break;
case RHStat.EMOTIONS:
modList = m_modEmotions;
value = m_baseEmotions;
break;
case RHStat.FAVOR:
modList = m_modFavor;
value = m_baseFavor;
break;
case RHStat.TRUST:
modList = m_modTrust;
value = m_baseTrust;
break;
case RHStat.CURRENT_PERSUASION_LEVEL:
modList = m_modPower;
value = m_basePower;
break;
}
foreach (RHModifier m in modList)
{
value = m.ApplyModifier(value, c, listener);
}
return(value);
}
protected virtual float calculateScaleFactor(RHScaleModifier mod, RHConversation c, RHListener l)
{
switch (mod)
{
case RHScaleModifier.FAVOR:
return(l.GetFavor(c.Speakers[0]));
case RHScaleModifier.AUTHORITY:
return(l.GetAuthority(c.Speakers[0]));
case RHScaleModifier.EMOTIONS:
return(l.GetEmotionalIntensity());
case RHScaleModifier.TRUST:
return(l.GetTrust(c.Speakers[0]));;
case RHScaleModifier.CURRENT_PERSUASION_LEVEL:
return(c.Listeners[l]);
case RHScaleModifier.INSTANCES_OF_SELF:
return(countType(statement.StatementName, c.PreviousStatements));
}
return(0f);
}
public static void CreateDialogueOptionList(List <RHStatement> statements, RHSpeaker speaker, RHConversation baseConversation, string prompt = "Select your next statement", float scroll = 0.0f)
{
DialogueSelectionInitializer dialogue = new DialogueSelectionInitializer(prompt);
List <RHStatement> sortedStatements = new List <RHStatement>();
sortedStatements = RHManager.SortedList(statements, speaker, baseConversation);
foreach (RHStatement s in sortedStatements)
{
DialogueOptionInitializer doi = convertToDialogueOption(s, statements, speaker, baseConversation);
dialogue.AddDialogueOption(doi);
}
void Close(DialogueOption selectedOption)
{
}
dialogue.AddDialogueOption("Close", Close);
GameObject go = TextboxManager.StartDialogueOptions(dialogue);
go.GetComponent <DialogueOptionBox>().SetScrollValue(scroll);
baseConversation.SetDialogueBox(go);
}
public static void StartRhetoricBattle(RHConversation conversation, List <RHSpeaker> participants, RHSpeaker startingSpeaker)
{
conversation.StartRhetoricBattle(participants, startingSpeaker);
}
public static List <RHStatement> SortedList(List <RHStatement> initialList, RHSpeaker speaker, RHConversation c)
{
initialList.Sort((p1, p2) => p1.GetListRankingPriority(speaker, c).CompareTo(p2.GetListRankingPriority(speaker, c)));
return(initialList);
}
private static DialogueOptionInitializer convertToDialogueOption(RHStatement s, List <RHStatement> allStatements, RHSpeaker speaker, RHConversation baseConversation)
{
DialogueOptionInitializer doi = new DialogueOptionInitializer();
void SelectionFunction(DialogueOption selectedOption)
{
baseConversation.QueueStatement(s, baseConversation.Speakers[0]);
RHManager.CreateDialogueOptionList(allStatements, speaker, baseConversation, "Select your next Statement", FindObjectOfType <DialogueOptionBox>().GetScrollValue());
}
string name = s.StatementName;
if (name == null || name == "")
{
name = s.gameObject.name;
}
doi.SelectionText = name;
doi.OnSelect = SelectionFunction;
doi.CloseDialogueWindow = true;
s.AddIcons(doi, speaker, baseConversation);
string missingRequirements = baseConversation.MeetsRequirements(s, speaker);
doi.Interactable = (missingRequirements == "Meets Requirements");
doi.hoverText = (doi.Interactable) ? s.GetHoverText(baseConversation) : missingRequirements;
//string timeStr = s.Time.ToString("F2") + " s";
//doi.AddTextIcon(timeStr, Color.white);
//foreach (RHListener l in baseConversation.Listeners.Keys)
//{
// if (l == speaker.GetComponent<RHListener>())
// continue;v
// float f = s.GetPower(baseConversation.Speakers[0], l, baseConversation);
// Color c = proportionToColor(s.BasePower, f);
// doi.AddTextIcon(f.ToString("F2"), c);
// doi.Interactable = s.IsEnabled(baseConversation.Speakers[0],baseConversation);
//}
return(doi);
}
public virtual float OnGetAttribute(float baseValue, RHStatement statement, RHListener l, RHSpeaker speaker, RHConversation conversation)
{
return(baseValue);
}
public virtual float OnStatementUsed(float baseValue, RHStatement statement, RHListener l, RHSpeaker speaker, RHConversation conversation, RHStat s = RHStat.CURRENT_PERSUASION_LEVEL)
{
return(baseValue);
}
public virtual float ApplyModifier(float initialDiff, RHConversation c, RHListener l)
{
float scaleFactor = calculateScaleFactor(m_scaleModifier, c, l);
return(calculateScaleValue(initialDiff, scaleFactor));
}
public virtual void OnListenerStart(RHListener l, RHSpeaker speaker, RHConversation conversation)
{
}
public virtual void OnStatementReceived(RHSpeaker speaker, RHListener listener, RHConversation c, Dictionary <RHStat, float> results)
{
//RHManager.AddHistoryText(GetResponseString(this, speaker, diff));
}
public string getModifierString(RHSpeaker s, RHConversation c, bool permanent = false)
{
return("RHConv" + s.gameObject.name + "::conv::" + c.gameObject.name + "Time:" + ScaledTime.UITimeElapsed.ToString() + "::perm::" + permanent.ToString());
}
public float getDiff(float initialDiff, RHConversation c, RHListener l)
{
return(initialDiff - ApplyModifier(initialDiff, c, l));
}
public static void CreateDialogueOptionListSortedType(List <RHStatement> statements, RHSpeaker speaker, RHConversation baseConversation, string prompt = "Select your next statement")
{
DialogueSelectionInitializer dialogue = new DialogueSelectionInitializer(prompt);
Dictionary <RHType, List <RHStatement> > sortedStatements = new Dictionary <RHType, List <RHStatement> >();
foreach (RHStatement s in statements)
{
if (!sortedStatements.ContainsKey(s.RhetoricType))
{
sortedStatements[s.RhetoricType] = new List <RHStatement>();
}
sortedStatements[s.RhetoricType].Add(s);
}
foreach (RHType t in sortedStatements.Keys)
{
void InitializeSubList(DialogueOption dop2)
{
DialogueSelectionInitializer dialogueSubList = new DialogueSelectionInitializer(prompt);
foreach (RHStatement s in sortedStatements[t])
{
DialogueOptionInitializer doi = convertToDialogueOption(s, statements, speaker, baseConversation);
dialogueSubList.AddDialogueOption(doi);
}
void ReturnToBase(DialogueOption selectedOption)
{
CreateDialogueOptionListSortedType(statements, speaker, baseConversation, prompt);
}
dialogueSubList.AddDialogueOption("Back", ReturnToBase);
GameObject go = TextboxManager.StartDialogueOptions(dialogueSubList);
baseConversation.SetDialogueBox(go);
}
dialogue.AddDialogueOption(RHTypeToString(t), InitializeSubList);
}
void Close(DialogueOption selectedOption)
{
baseConversation.CloseConversation();
}
dialogue.AddDialogueOption("Close", Close);
baseConversation.SetDialogueBox(TextboxManager.StartDialogueOptions(dialogue));
}
public virtual void OnSpeakerStart(RHSpeaker speaker, List <RHListener> listeners, RHConversation conversation)
{
}
public void StartUI(RHConversation c)
{
conversation = c;
startingTime = ScaledTime.UITimeElapsed;
}
public virtual string MeetsRequirements(RHSpeaker speaker, RHConversation c)
{
setRequirements();
return(speaker.meetsRequirements(m_requirements));
}
