public static string GetIconForPassion(SkillRecord skill)
{
if (!Active)
{
return(null);
}
if (!UsableInterestList.Any())
{
return(null);
}
Passion passionValue = skill.passion;
Def interest;
try
{
interest = UsableInterestList[(int)passionValue];
}
catch (Exception)
{
return(string.Empty);
}
if (interest != null)
{
return(InterestIndex.TryGetValue(interest.defName, string.Empty).AltText($"{interest.LabelCap.RawText}"));
}
return(string.Empty);
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Photo,SubTitle,Title,Text")] Passion passion)
{
if (id != passion.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(passion);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!PassionExists(passion.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(passion));
}
private static Color ColorOfPriority(int prio, Passion passion)
{
if (!WidgetsWork.ColorCodedWorkPassions)
{
switch (prio)
{
case 1:
return(Color.green);
case 2:
return(new Color(1f, 0.9f, 0.6f));
case 3:
return(new Color(0.8f, 0.7f, 0.5f));
case 4:
return(new Color(0.6f, 0.6f, 0.6f));
default:
return(Color.grey);
}
}
else
{
if (passion == Passion.Minor)
{
return(new Color(1f, 1f, 0f));
}
if (passion != Passion.Major)
{
return(new Color(0.8f, 0.8f, 0.8f));
}
return(new Color(0f, 1f, 0f));
}
}
private static bool Prefix(Passion passion, ref Color __result)
{
int p = (int)passion;
InterestDef interest = InterestBase.interestList[p];
float val = interest.GetValue();
if (val < 0)
{
if (val / 75.0f < 1.0f)
{
__result = veryNegativeColor;
}
else
{
__result = negativeColor;
}
}
else if (val == 0)
{
__result = neutralColor;
}
else
{
if (val / 75.0f > 1.0f)
{
__result = veryPositiveColor;
}
else
{
__result = positiveColor;
}
}
return(false);
}
public override void TryExecute()
{
float customMultiplier = LevelPawnSettings.xpMultiplier > 0 ? LevelPawnSettings.xpMultiplier : 0.5f;
float xpWon = pawn.skills.GetSkill(skill).XpRequiredForLevelUp *customMultiplier *((float)Verse.Rand.Range(0.5f, 1.5f));
xpWon = IncidentHelper_PointsHelper.RollProportionalGamePoints(storeIncident, pointsWager, xpWon);
pawn.skills.Learn(skill, xpWon, true);
Viewer.TakeViewerCoins(pointsWager);
Viewer.CalculateNewKarma(this.storeIncident.karmaType, pointsWager);
SkillRecord record = pawn.skills.GetSkill(skill);
string increaseText = $" Level {record.levelInt}: {(int)record.xpSinceLastLevel} / {(int)record.XpRequiredForLevelUp}.";
float percent = 35;
string passionPlus = "";
Passion passion = record.passion;
if (passion == Passion.Minor)
{
percent = 100;
passionPlus = "+";
}
if (passion == Passion.Major)
{
percent = 150;
passionPlus = "++";
}
VariablesHelpers.SendPurchaseMessage($"Increasing skill {skill.LabelCap} for {pawn.LabelCap} with {pointsWager} coins wagered and ({(int)xpWon} * {percent}%){passionPlus} {(int)xpWon * (percent / 100f)} xp purchased by {Viewer.username}. {increaseText}");
string text = Helper.ReplacePlaceholder("TwitchStoriesDescription55".Translate(), colonist: pawn.Name.ToString(), skill: skill.defName, first: Math.Round(xpWon).ToString());
Current.Game.letterStack.ReceiveLetter("TwitchToolkitIncreaseSkill".Translate(), text, LetterDefOf.PositiveEvent, pawn);
}
private static void DrawWorkBoxBackground(Rect rect, Pawn p, WorkTypeDef workDef)
{
Profiler.BeginSample("AverageOfRelevantSkillsFor");
float num = p.skills.AverageOfRelevantSkillsFor(workDef);
Profiler.EndSample();
Texture2D image;
Texture2D image2;
float a;
if (num < 4f)
{
image = WidgetsWork.WorkBoxBGTex_Awful;
image2 = WidgetsWork.WorkBoxBGTex_Bad;
a = num / 4f;
}
else if (num <= 14f)
{
image = WidgetsWork.WorkBoxBGTex_Bad;
image2 = WidgetsWork.WorkBoxBGTex_Mid;
a = (num - 4f) / 10f;
}
else
{
image = WidgetsWork.WorkBoxBGTex_Mid;
image2 = WidgetsWork.WorkBoxBGTex_Excellent;
a = (num - 14f) / 6f;
}
GUI.DrawTexture(rect, image);
GUI.color = new Color(GUI.color.r, GUI.color.g, GUI.color.b, a);
GUI.DrawTexture(rect, image2);
if (workDef.relevantSkills.Any <SkillDef>() && num <= 2f && p.workSettings.WorkIsActive(workDef))
{
GUI.color = Color.white;
GUI.DrawTexture(rect.ContractedBy(-2f), WidgetsWork.WorkBoxOverlay_Warning);
}
Passion passion = p.skills.MaxPassionOfRelevantSkillsFor(workDef);
if (passion > Passion.None)
{
GUI.color = new Color(1f, 1f, 1f, 0.4f);
Rect position = rect;
position.xMin = rect.center.x;
position.yMin = rect.center.y;
if (passion == Passion.Minor)
{
GUI.DrawTexture(position, WidgetsWork.PassionWorkboxMinorIcon);
}
else if (passion == Passion.Major)
{
GUI.DrawTexture(position, WidgetsWork.PassionWorkboxMajorIcon);
}
}
GUI.color = Color.white;
}
private static void DrawWorkBoxBackground(Rect rect, Pawn p, WorkTypeDef workDef)
{
float num = p.skills.AverageOfRelevantSkillsFor(workDef);
Texture2D image;
Texture2D image2;
float a;
if (num < 4f)
{
image = WorkBoxBGTex_Awful;
image2 = WorkBoxBGTex_Bad;
a = num / 4f;
}
else if (num <= 14f)
{
image = WorkBoxBGTex_Bad;
image2 = WorkBoxBGTex_Mid;
a = (num - 4f) / 10f;
}
else
{
image = WorkBoxBGTex_Mid;
image2 = WorkBoxBGTex_Excellent;
a = (num - 14f) / 6f;
}
GUI.DrawTexture(rect, image);
GUI.color = new Color(GUI.color.r, GUI.color.g, GUI.color.b, a);
GUI.DrawTexture(rect, image2);
if (workDef.relevantSkills.Any() && num <= 2f && p.workSettings.WorkIsActive(workDef))
{
GUI.color = Color.white;
GUI.DrawTexture(rect.ContractedBy(-2f), WorkBoxOverlay_Warning);
}
Passion passion = p.skills.MaxPassionOfRelevantSkillsFor(workDef);
if ((int)passion > 0)
{
GUI.color = new Color(1f, 1f, 1f, 0.4f);
Rect position = rect;
position.xMin = rect.center.x;
position.yMin = rect.center.y;
switch (passion)
{
case Passion.Minor:
GUI.DrawTexture(position, PassionWorkboxMinorIcon);
break;
case Passion.Major:
GUI.DrawTexture(position, PassionWorkboxMajorIcon);
break;
}
}
GUI.color = Color.white;
}
public async Task <IActionResult> Create([Bind("Id,Photo,SubTitle,Title,Text")] Passion passion)
{
if (ModelState.IsValid)
{
_context.Add(passion);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(passion));
}
protected override IEnumerable <string> ApplyPartWorker(Pawn pawn, object cause)
{
SkillRecord realSkill = pawn.skills.GetSkill(skill);
Passion adjustedPassion = (Passion)MathUtility.MoveTowardsOperationClamped((byte)realSkill.passion, (byte)target, delta, operation);
yield return(MessageSkillPassionChanged.Translate(pawn.LabelShort, skill.label, adjustedPassion.ToString().ToLower(), ParseCause(cause)));
realSkill.passion = adjustedPassion;
// We're done here.
yield break;
}
/// <summary> The new passion of the skill with this mod. </summary>
public Passion GetNewPassion(Passion oldPassion)
{
if (forcedPassion != null)
{
return(forcedPassion.Value);
}
int nP = (int)oldPassion + passionOffset;
nP = Mathf.Clamp(nP, 0, 2);
return((Passion)nP);
}
public static float getCuMWorth(this Passion p)
{
switch (p)
{
case Passion.None: return(0);
case Passion.Minor: return(QOLMod.getBaseCost() * 2);
case Passion.Major: return(QOLMod.getBaseCost() * 3);
}
Log.Error("Unknown Passion type while calculation upgrade cost!");
return(0);
}
/// <summary>
/// Draws pawn Passion on the lower right side of a rect.
/// </summary>
public static void DrawPassion(Rect drawRect, Pawn worker, WorkTypeDef workDef)
{
//WidgetsWork.DrawWorkBoxBackground
Passion passion = worker.skills.MaxPassionOfRelevantSkillsFor(workDef);
if (passion > Passion.None)
{
Rect passionRect = new Rect(drawRect.xMax - PassionDrawSize - 2f, drawRect.yMax - PassionDrawSize - 2f, PassionDrawSize, PassionDrawSize);
Texture passionTex = passion == Passion.Minor ? PassionMinorIcon : PassionMajorIcon;
GUI.DrawTexture(passionRect, passionTex);
}
}
public bool hasAttributes(Passion passion)
{
bool toReturn = false;
foreach (PassionObject PO in Attributes)
{
if (PO.passion == passion)
{
toReturn = true;
}
}
return(toReturn);
}
protected virtual void DrawWorkGiverBoxFor(Rect box, Pawn pawn, WorkGiverDef workgiver, bool incapable)
{
List <SkillDef> skillsNeeded = workgiver.workType.relevantSkills;
float averageSkill = pawn.skills.AverageOfRelevantSkillsFor(workgiver.workType);
Passion passion = Passion.None;
if (skillsNeeded.Count > 0)
{
passion = pawn.skills.GetSkill(workgiver.workType.relevantSkills[0]).passion;
}
Color red = new Color(1f, 0f, 0f);
Color green = new Color(0f, 1f, 0f);
Color blue = new Color(0f, 0f, 1f);
Color black = new Color(0f, 0f, 0f);
Color passionColor;
if (passion == Passion.None)
{
passionColor = red;
}
else if (passion == Passion.Minor)
{
passionColor = blue;
}
else
{
passionColor = green;
}
GUI.color = Color.Lerp(black + (passionColor * 0.2f), passionColor, averageSkill / 20);
// draw background
//GUI.color = incapable ? new Color( 1f, .3f, .3f ) : Color.white;
DrawUtilities.DrawWorkBoxBackground(box, pawn, workgiver.workType);
GUI.color = Color.white;
// draw extras
var tracker = PriorityManager.Get[pawn];
if (tracker.TimeScheduled(workgiver))
{
DrawUtilities.DrawTimeScheduled(box);
}
// draw priorities / checks
DrawUtilities.DrawPriority(box, pawn.GetPriority(workgiver, VisibleHour), true);
}
public IActionResult Change(int PasId, Passion formPassion)
{
Passion RetrievedPassion = dbContext.Passions.FirstOrDefault(Passion => Passion.PasId == PasId);
if (ModelState.IsValid)
{
RetrievedPassion.PasName = formPassion.PasName;
RetrievedPassion.PasContent = formPassion.PasContent;
RetrievedPassion.UserId = RetrievedPassion.UserId;
RetrievedPassion.UpdatedAt = DateTime.Now;
dbContext.SaveChanges();
return(RedirectToAction("ShowPas", new { PasId = PasId }));
}
return(View("Update", RetrievedPassion));
}
private static bool Prefix(ref object __instance, ref HashSet <Pawn> ____capablePawns, ref HashSet <Pawn> ____managedPawns, ref HashSet <WorkTypeDef> ____managedWorkTypes, IEnumerable <WorkTypeDef> ____commonWorkTypes)
{
if (!____capablePawns.Any <Pawn>())
{
return(false);
}
using (IEnumerator <Pawn> enumerator = ____capablePawns.Intersect(____managedPawns).GetEnumerator())
{
while (enumerator.MoveNext())
{
Pawn pawn = enumerator.Current;
IEnumerable <WorkTypeDef> managedWorkTypes = ____managedWorkTypes;
var isBadWork = AccessTools.Method(PatchWorkManagerBase.priority, "IsBadWork");
var isPawnWorkTypeActive = AccessTools.Method(PatchWorkManagerBase.priority, "IsPawnWorkTypeActive");
var setPawnWorkTypePriority = AccessTools.Method(PatchWorkManagerBase.priority, "SetPawnWorkTypePriority");
foreach (WorkTypeDef workType in managedWorkTypes)
{
if (____commonWorkTypes.Contains(workType) || workType == WorkTypeDefOf.Doctor || workType == WorkTypeDefOf.Hunting || pawn.WorkTypeIsDisabled(workType) ||
(bool)isBadWork.Invoke(__instance, new object [] { pawn, workType }) || (bool)isPawnWorkTypeActive.Invoke(__instance, new object [] { pawn, workType }))
{
continue;
}
Passion passion = pawn.skills.MaxPassionOfRelevantSkillsFor(workType);
float val = InterestBase.interestList[(int)passion].GetValue();
if (val > 0)
{
if (val >= 100)
{
int priority = 2;
setPawnWorkTypePriority.Invoke(__instance, new object[] { pawn, workType, priority });
}
else
{
int priority = 3;
setPawnWorkTypePriority.Invoke(__instance, new object[] { pawn, workType, priority });
}
}
else if (val < -50)
{
int priority = 4;
setPawnWorkTypePriority.Invoke(__instance, new object[] { pawn, workType, priority });
}
}
}
}
return(false);
}
private static Color GetSkillPassionColor(Passion passion)
{
if (passion == Passion.None)
{
return(Theme.MainTextColor.Value);
}
if (passion == Passion.Minor)
{
return(Theme.SkillMinorPassionColor.Value);
}
if (passion == Passion.Major)
{
return(Theme.SkillMajorPassionColor.Value);
}
throw new Mod.Exception("Invalid skill passion level.");
}
public IActionResult Plan(Passion newPassion)
{
if (ModelState.IsValid)
{
Passion submittedPassion = newPassion;
if (dbContext.Passions.Any(p => p.PasName == newPassion.PasName))
{
ModelState.AddModelError("PasName", "Hobby names must be unique!");
return(View("New"));
}
newPassion.UserId = (int)UserSessionData;
dbContext.Add(newPassion);
dbContext.SaveChanges();
return(RedirectToAction("GetAll", newPassion));
}
return(View("New"));
}
public static void DrawInterest(Passion passion, Rect position)
{
Texture2D image;
if (InterestBase.interestList.GetDefaultIndex() == (int)passion)
{
image = ContentFinder <Texture2D> .Get("EdB/PrepareCarefully/NoPassion", true);
}
else
{
image = InterestBase.interestList[(int)passion].GetTexture();
}
GUI.color = Color.white;
if (image != null)
{
GUI.DrawTexture(position, image);
}
}
public Passion MaxPassionOfRelevantSkillsFor(WorkTypeDef workDef)
{
if (workDef.relevantSkills.Count == 0)
{
return(Passion.None);
}
Passion passion = Passion.None;
for (int i = 0; i < workDef.relevantSkills.Count; i++)
{
Passion passion2 = GetSkill(workDef.relevantSkills[i]).passion;
if ((int)passion2 > (int)passion)
{
passion = passion2;
}
}
return(passion);
}
private static bool Prefix(ref float __result, bool direct, Passion ___passion, SkillRecord __instance, Pawn ___pawn)
{
if (DebugSettings.fastLearning)
{
__result = 200f;
return(false);
}
float num = InterestBase.LearnRateFactor(___passion);
if (!direct)
{
num *= ___pawn.GetStatValue(StatDefOf.GlobalLearningFactor, true);
if (__instance.LearningSaturatedToday)
{
num *= 0.2f;
}
}
__result = num;
return(false);
}
private static void Postfix(ref Passion __result, WorkTypeDef workDef, Pawn_SkillTracker __instance)
{
int highestPassion = InterestBase.interestList.GetDefaultIndex();
if (workDef.relevantSkills.Count == 0)
{
__result = (Passion)highestPassion;
return;
}
for (int i = 0; i < workDef.relevantSkills.Count; i++)
{
int passion2 = (int)__instance.GetSkill(workDef.relevantSkills[i]).passion;
if (InterestBase.interestList[passion2] > InterestBase.interestList[highestPassion])
{
highestPassion = passion2;
}
}
__result = (Passion)highestPassion;
}
private void ShuffleWithInterests()
{
var iterations = 0;
int passionCount = _pawn.skills.skills.Select(s => (int)s.passion).Where(p => p < 3).Sum();
List <Passion> interests = _pawn.skills.skills.Where(s => (int)s.passion >= 3).Select(s => s.passion).ToList();
passionCount = GetPassionCount(passionCount);
if (!ShufflePassions(passionCount, ref iterations))
{
return;
}
while (interests.Any())
{
SkillRecord skill = _pawn.skills.skills.Where(s => !s.TotallyDisabled).Where(s => s.passion == Passion.None).RandomElementWithFallback();
if (skill == null)
{
iterations += 1;
continue;
}
Passion interest = interests.RandomElementWithFallback();
skill.passion = interest;
interests.Remove(interest);
iterations += 1;
if (iterations < 150)
{
continue;
}
TkUtils.Logger.Warn("Exceeded 100 iterations while shuffling interests!");
return;
}
}
private static void DrawWorkBoxBackground(Rect rect, Pawn p, WorkTypeDef workDef)
{
float num = p.skills.AverageOfRelevantSkillsFor(workDef);
Texture2D image;
Texture2D image2;
float a;
if (num <= 14f)
{
image = WidgetsWork.WorkBoxBGTex_Bad;
image2 = WidgetsWork.WorkBoxBGTex_Mid;
a = num / 14f;
}
else
{
image = WidgetsWork.WorkBoxBGTex_Mid;
image2 = WidgetsWork.WorkBoxBGTex_Excellent;
a = (num - 14f) / 6f;
}
GUI.DrawTexture(rect, image);
GUI.color = new Color(1f, 1f, 1f, a);
GUI.DrawTexture(rect, image2);
Passion passion = p.skills.MaxPassionOfRelevantSkillsFor(workDef);
if (passion > Passion.None)
{
GUI.color = new Color(1f, 1f, 1f, 0.4f);
Rect position = rect;
position.xMin = rect.center.x;
position.yMin = rect.center.y;
if (passion == Passion.Minor)
{
GUI.DrawTexture(position, WidgetsWork.PassionWorkboxMinorIcon);
}
else if (passion == Passion.Major)
{
GUI.DrawTexture(position, WidgetsWork.PassionWorkboxMajorIcon);
}
}
GUI.color = Color.white;
}
private static bool Prefix(float global_lf, Passion passion, bool learning_saturated, ref float __result)
{
bool fastLearning = DebugSettings.fastLearning;
if (fastLearning)
{
__result = 200f;
}
else
{
float num = global_lf - 1f;
InterestDef id = InterestBase.interestList[(int)passion];
float toAdd = id.learnFactor;
num += toAdd;
if (learning_saturated)
{
num *= 0.2f;
}
__result = num;
}
return(false);
}
public virtual float CommonalityFor(Pawn pawn)
{
float num = 1f;
if (pawn.skills != null && this.def.associatedSkills != null)
{
for (int i = 0; i < this.def.associatedSkills.Count; i++)
{
SkillDef skillDef = this.def.associatedSkills[i];
for (int j = 0; j < pawn.skills.skills.Count; j++)
{
SkillRecord skillRecord = pawn.skills.skills[j];
if (skillDef == skillRecord.def)
{
Passion passion = pawn.skills.skills[j].passion;
if (passion != Passion.None)
{
if (passion != Passion.Minor)
{
if (passion == Passion.Major)
{
num = Mathf.Max(num, 5f);
}
}
else
{
num = Mathf.Max(num, 2.5f);
}
}
else
{
num = Mathf.Max(num, 1f);
}
}
}
}
}
return(this.def.baseCommonality * num);
}
public Passion MaxPassionOfRelevantSkillsFor(WorkTypeDef workDef)
{
Passion result;
if (workDef.relevantSkills.Count == 0)
{
result = Passion.None;
}
else
{
Passion passion = Passion.None;
for (int i = 0; i < workDef.relevantSkills.Count; i++)
{
Passion passion2 = this.GetSkill(workDef.relevantSkills[i]).passion;
if (passion2 > passion)
{
passion = passion2;
}
}
result = passion;
}
return(result);
}
public void Learn(float xp, bool direct = false)
{
if (this.TotallyDisabled)
{
return;
}
if (xp < 0f && this.levelInt == 0)
{
return;
}
if (xp > 0f)
{
if (this.pawn.needs.joy != null)
{
float amount = 0f;
Passion passion = this.passion;
if (passion != Passion.Minor)
{
if (passion != Passion.Major)
{
if (passion == Passion.None)
{
amount = 0f * xp;
}
}
else
{
amount = 4E-05f * xp;
}
}
else
{
amount = 2E-05f * xp;
}
this.pawn.needs.joy.GainJoy(amount, JoyKindDefOf.Work);
}
xp *= this.LearnRateFactor(direct);
}
this.xpSinceLastLevel += xp;
if (!direct)
{
this.xpSinceMidnight += xp;
}
if (this.levelInt == 20 && this.xpSinceLastLevel > this.XpRequiredForLevelUp - 1f)
{
this.xpSinceLastLevel = this.XpRequiredForLevelUp - 1f;
}
while (this.xpSinceLastLevel >= this.XpRequiredForLevelUp)
{
this.xpSinceLastLevel -= this.XpRequiredForLevelUp;
this.levelInt++;
if (this.levelInt == 14)
{
if (this.passion == Passion.None)
{
TaleRecorder.RecordTale(TaleDefOf.GainedMasterSkillWithoutPassion, new object[]
{
this.pawn,
this.def
});
}
else
{
TaleRecorder.RecordTale(TaleDefOf.GainedMasterSkillWithPassion, new object[]
{
this.pawn,
this.def
});
}
}
if (this.levelInt >= 20)
{
this.levelInt = 20;
this.xpSinceLastLevel = Mathf.Clamp(this.xpSinceLastLevel, 0f, this.XpRequiredForLevelUp - 1f);
break;
}
}
while (this.xpSinceLastLevel < 0f)
{
this.levelInt--;
this.xpSinceLastLevel += this.XpRequiredForLevelUp;
if (this.levelInt <= 0)
{
this.levelInt = 0;
this.xpSinceLastLevel = 0f;
break;
}
}
}
private static string GetSkillDescription(SkillRecord sk)
{
StringBuilder stringBuilder = new StringBuilder();
if (sk.TotallyDisabled)
{
stringBuilder.Append("DisabledLower".Translate().CapitalizeFirst());
}
else
{
stringBuilder.AppendLine(string.Concat(new object[]
{
"Level".Translate(),
" ",
sk.Level,
": ",
sk.LevelDescriptor
}));
if (Current.ProgramState == ProgramState.Playing)
{
string text = (sk.Level != 20) ? "ProgressToNextLevel".Translate() : "Experience".Translate();
stringBuilder.AppendLine(string.Concat(new object[]
{
text,
": ",
sk.xpSinceLastLevel.ToString("F0"),
" / ",
sk.XpRequiredForLevelUp
}));
}
stringBuilder.Append("Passion".Translate() + ": ");
Passion passion = sk.passion;
if (passion != Passion.None)
{
if (passion != Passion.Minor)
{
if (passion == Passion.Major)
{
stringBuilder.Append("PassionMajor".Translate(new object[]
{
1.5f.ToStringPercent("F0")
}));
}
}
else
{
stringBuilder.Append("PassionMinor".Translate(new object[]
{
1f.ToStringPercent("F0")
}));
}
}
else
{
stringBuilder.Append("PassionNone".Translate(new object[]
{
0.35f.ToStringPercent("F0")
}));
}
if (sk.LearningSaturatedToday)
{
stringBuilder.AppendLine();
stringBuilder.Append("LearnedMaxToday".Translate(new object[]
{
sk.xpSinceMidnight.ToString("F0"),
4000,
0.2f.ToStringPercent("F0")
}));
}
}
stringBuilder.AppendLine();
stringBuilder.AppendLine();
stringBuilder.Append(sk.def.description);
return(stringBuilder.ToString());
}
public void UpdateSkillPassion(SkillDef skill, Passion level)
{
state.CurrentPawn.SetPassion(skill, level);
}
