public bool IsDisabled(WorkTags combinedDisabledWorkTags, IEnumerable <WorkTypeDef> disabledWorkTypes)
{
if ((combinedDisabledWorkTags & disablingWorkTags) != 0)
{
return(true);
}
if (neverDisabledBasedOnWorkTypes)
{
return(false);
}
List <WorkTypeDef> allDefsListForReading = DefDatabase <WorkTypeDef> .AllDefsListForReading;
bool flag = false;
for (int i = 0; i < allDefsListForReading.Count; i++)
{
WorkTypeDef workTypeDef = allDefsListForReading[i];
for (int j = 0; j < workTypeDef.relevantSkills.Count; j++)
{
if (workTypeDef.relevantSkills[j] == this)
{
if (!disabledWorkTypes.Contains(workTypeDef))
{
return(false);
}
flag = true;
}
}
}
if (!flag)
{
return(false);
}
return(true);
}
public bool IsDisabled(WorkTags combinedDisabledWorkTags, IEnumerable <WorkTypeDef> disabledWorkTypes)
{
bool result;
if ((combinedDisabledWorkTags & this.disablingWorkTags) != WorkTags.None)
{
result = true;
}
else
{
List <WorkTypeDef> allDefsListForReading = DefDatabase <WorkTypeDef> .AllDefsListForReading;
bool flag = false;
for (int i = 0; i < allDefsListForReading.Count; i++)
{
WorkTypeDef workTypeDef = allDefsListForReading[i];
for (int j = 0; j < workTypeDef.relevantSkills.Count; j++)
{
if (workTypeDef.relevantSkills[j] == this)
{
if (!disabledWorkTypes.Contains(workTypeDef))
{
return(false);
}
flag = true;
}
}
}
result = flag;
}
return(result);
}
static void FixCombinedDisabledWorkTags(ref WorkTags __result, [NotNull] Pawn __instance)
{
var hediffs = __instance.health?.hediffSet?.hediffs;
if (hediffs == null)
{
return;
}
foreach (Hediff hediff in hediffs)
{
if (hediff is IWorkModifier wM)
{
__result |= ~wM.AllowedWorkTags;
}
else
{
foreach (HediffStage hediffStage in hediff.def.stages.MakeSafe())
{
if (hediffStage is IWorkModifier sWM)
{
__result |= ~sWM.AllowedWorkTags;
}
}
}
}
}
public static float getCuMWorth(this Backstory bs, bool includeSkillGainWorth = true)
{
if (bs == null)
{
return(0);
}
float total = 0, BC = QOLMod.getBaseCost();
if (includeSkillGainWorth)
{
foreach (KeyValuePair <SkillDef, int> p in bs.skillGainsResolved)
{
total += BC * (float)p.Value;
}
}
WorkTags disabledWorkTags = bs.workDisables;
List <WorkTypeDef> allDefsListForReading = DefDatabase <WorkTypeDef> .AllDefsListForReading;
foreach (WorkTypeDef wtd in allDefsListForReading)
{
if ((wtd.workTags & disabledWorkTags) != WorkTags.None)
{
total += -2 * BC;
}
}
return(total);
}
public override void ResolveReferences()
{
base.ResolveReferences();
if (!this.addToDatabase || BackstoryDatabase.allBackstories.ContainsKey(key: this.defName) || this.title.NullOrEmpty() || this.spawnCategories.NullOrEmpty())
{
return;
}
this.backstory = new Backstory
{
slot = this.slot,
shuffleable = this.shuffleable,
spawnCategories = this.spawnCategories,
forcedTraits = this.forcedTraits.NullOrEmpty() ? null : this.forcedTraits.Where(predicate: trait => Rand.Range(min: 0, max: 100) < trait.chance).ToList().ConvertAll(converter: trait => new TraitEntry(def: TraitDef.Named(defName: trait.defName), degree: trait.degree)),
disallowedTraits = this.disallowedTraits.NullOrEmpty() ? null : this.disallowedTraits.Where(predicate: trait => Rand.Range(min: 0, max: 100) < trait.chance).ToList().ConvertAll(converter: trait => new TraitEntry(def: TraitDef.Named(defName: trait.defName), degree: trait.degree)),
workDisables = this.workAllows.NullOrEmpty() ? this.workDisables.NullOrEmpty() ? WorkTags.None : ((Func <WorkTags>) delegate
{
WorkTags wt = WorkTags.None;
this.workDisables.ForEach(action: tag => wt |= tag);
return(wt);
})() : ((Func <WorkTags>) delegate
{
WorkTags wt = WorkTags.None;
Enum.GetValues(enumType: typeof(WorkTags)).Cast <WorkTags>().Where(predicate: tag => !this.workAllows.Contains(item: tag)).ToList().ForEach(action: tag => wt |= tag);
return(wt);
})(),
identifier = this.defName,
requiredWorkTags = ((Func <WorkTags>) delegate
{
WorkTags wt = WorkTags.None;
this.requiredWorkTags.ForEach(action: tag => wt |= tag);
return(wt);
})()
};
Traverse.Create(root: this.backstory).Field(name: "bodyTypeGlobalResolved").SetValue(value: this.bodyTypeGlobal);
Traverse.Create(root: this.backstory).Field(name: "bodyTypeFemaleResolved").SetValue(value: this.bodyTypeFemale);
Traverse.Create(root: this.backstory).Field(name: "bodyTypeMaleResolved").SetValue(value: this.bodyTypeMale);
Traverse.Create(root: this.backstory).Field(name: nameof(this.skillGains)).SetValue(value: this.skillGains.ToDictionary(keySelector: i => i.defName, elementSelector: i => i.amount));
UpdateTranslateableFields(bs: this);
this.backstory.ResolveReferences();
this.backstory.PostLoad();
this.backstory.identifier = this.defName;
IEnumerable <string> errors;
if (!(errors = this.backstory.ConfigErrors(ignoreNoSpawnCategories: false)).Any())
{
BackstoryDatabase.AddBackstory(bs: this.backstory);
}
else
{
Log.Error(text: this.defName + " has errors:\n" + string.Join(separator: "\n", value: errors.ToArray()));
}
}
private static float SelectionWeightFactorFromWorkTagsDisabled(WorkTags wt)
{
float num = 1f;
if ((wt & WorkTags.ManualDumb) != 0)
{
num *= 0.4f;
}
if ((wt & WorkTags.ManualSkilled) != 0)
{
num *= 1f;
}
if ((wt & WorkTags.Violent) != 0)
{
num *= 0.5f;
}
if ((wt & WorkTags.Caring) != 0)
{
num *= 0.9f;
}
if ((wt & WorkTags.Social) != 0)
{
num *= 0.5f;
}
if ((wt & WorkTags.Intellectual) != 0)
{
num *= 0.35f;
}
if ((wt & WorkTags.Firefighting) != 0)
{
num *= 0.7f;
}
return(num);
}
private static void Postfix(Pawn ___pawn, ref WorkTags __result)
{
if (___pawn.def is RaceAddonThingDef thingDef)
{
__result |= thingDef.DisabledWorkTags;
}
}
private static string GetWorkTypeDisabledCausedBy(Pawn pawn, WorkTags workTag)
{
List <object> workTypeDisableCauses = GetWorkTypeDisableCauses(pawn, workTag);
StringBuilder stringBuilder = new StringBuilder();
foreach (object item in workTypeDisableCauses)
{
if (item is Backstory)
{
stringBuilder.AppendLine("IncapableOfTooltipBackstory".Translate((item as Backstory).TitleFor(pawn.gender)));
}
else if (item is Trait)
{
stringBuilder.AppendLine("IncapableOfTooltipTrait".Translate((item as Trait).LabelCap));
}
else if (item is Hediff)
{
stringBuilder.AppendLine("IncapableOfTooltipHediff".Translate((item as Hediff).LabelCap));
}
else if (item is RoyalTitle)
{
stringBuilder.AppendLine("IncapableOfTooltipTitle".Translate((item as RoyalTitle).def.GetLabelFor(pawn)));
}
else if (item is Quest)
{
stringBuilder.AppendLine("IncapableOfTooltipQuest".Translate((item as Quest).name));
}
}
return(stringBuilder.ToString());
}
private static void AppendDisabledWorkTags(StringBuilder sb, WorkTags disabledWorkTags)
{
sb.Append(CreateTitle("IncapableOf".Translate()));
sb.AppendLine();
if (disabledWorkTags == 0)
{
sb.Append("(" + "NoneLower".Translate() + ")");
}
else
{
int count = 0;
bool capitalize = true;
foreach (WorkTags workTag in Enum.GetValues(typeof(WorkTags)))
{
if (workTag != 0 && (disabledWorkTags & workTag) == workTag)
{
if (count > 0)
{
sb.Append(", ");
}
if (!capitalize)
{
sb.Append(workTag.LabelTranslated().ToLower());
}
else
{
sb.Append(workTag.LabelTranslated());
}
++count;
capitalize = false;
}
}
}
}
public SkillDefStats(SkillDef def) : base(def)
{
this.skillLabel = def.skillLabel;
this.usuallyDefinedInBackstories = def.usuallyDefinedInBackstories;
this.pawnCreatorSummaryVisible = def.pawnCreatorSummaryVisible;
this.disablingWorkTags = def.disablingWorkTags;
this.listOrder = def.listOrder;
}
public bool WorkTagIsDisabled(WorkTags w)
{
if (w == WorkTags.Firefighting)
{
w = w | WorkTags.Scary;
}
return((CombinedDisabledWorkTags & w) != WorkTags.None);
}
public static string LabelTranslated(this WorkTags tags)
{
switch (tags)
{
case WorkTags.None:
return("WorkTagNone".Translate());
case WorkTags.Intellectual:
return("WorkTagIntellectual".Translate());
case WorkTags.ManualDumb:
return("WorkTagManualDumb".Translate());
case WorkTags.ManualSkilled:
return("WorkTagManualSkilled".Translate());
case WorkTags.Violent:
return("WorkTagViolent".Translate());
case WorkTags.Caring:
return("WorkTagCaring".Translate());
case WorkTags.Social:
return("WorkTagSocial".Translate());
case WorkTags.Animals:
return("WorkTagAnimals".Translate());
case WorkTags.Artistic:
return("WorkTagArtistic".Translate());
case WorkTags.Crafting:
return("WorkTagCrafting".Translate());
case WorkTags.Cooking:
return("WorkTagCooking".Translate());
case WorkTags.Firefighting:
return("WorkTagFirefighting".Translate());
case WorkTags.Cleaning:
return("WorkTagCleaning".Translate());
case WorkTags.Hauling:
return("WorkTagHauling".Translate());
case WorkTags.PlantWork:
return("WorkTagPlantWork".Translate());
case WorkTags.Mining:
return("WorkTagMining".Translate());
default:
Log.Error("Unknown or mixed worktags for naming: " + (int)tags);
return("Worktag");
}
}
private static IEnumerable <WorkTags> WorkTagsFrom(WorkTags tags)
{
foreach (WorkTags allSelectedItem in tags.GetAllSelectedItems <WorkTags>())
{
if (allSelectedItem != 0)
{
yield return(allSelectedItem);
}
}
}
//
// Methods
//
private WorkTags InitWorkTagsFromWorkTypes()
{
WorkTags workTags = 0;
foreach (ThingDef_BaseRobot.RobotWorkTypes current in this.robotWorkTypes)
{
workTags |= current.workTypeDef.workTags;
}
return(workTags);
}
private static IEnumerable <WorkTags> WorkTagsFrom(WorkTags tags)
{
foreach (WorkTags workTag in tags.GetAllSelectedItems <WorkTags>())
{
if (workTag != WorkTags.None)
{
yield return(workTag);
}
}
}
private WorkTags InitWorkTagsFromWorkTypes()
{
WorkTags workTags = WorkTags.None;
foreach (RobotWorkTypes workTypes in this.robotWorkTypes)
{
workTags = workTags | workTypes.workTypeDef.workTags;
}
return(workTags);
}
private static Color GetDisabledWorkTagLabelColor(Pawn pawn, WorkTags workTag)
{
foreach (object workTypeDisableCause in GetWorkTypeDisableCauses(pawn, workTag))
{
if (workTypeDisableCause is RoyalTitleDef)
{
return(TitleCausedWorkTagDisableColor);
}
}
return(Color.white);
}
public static string GetBackstoryUniqueKey(WorkTags workDisables)
{
//string log = "UNIQUE KEY";
string baseBackstoryDefName = BackstoryDefNameIdentifier + BackstoryDefNameIdentifierDisabled;
string ukey = baseBackstoryDefName + workDisables.ToString().Replace(", ", "_");
//log = log + Environment.NewLine + ukey;
//Log.Error(log);
return(ukey);
}
private static List <object> GetWorkTypeDisableCauses(Pawn pawn, WorkTags workTag)
{
List <object> list = new List <object>();
if (pawn.story != null && pawn.story.childhood != null && (pawn.story.childhood.workDisables & workTag) != 0)
{
list.Add(pawn.story.childhood);
}
if (pawn.story != null && pawn.story.adulthood != null && (pawn.story.adulthood.workDisables & workTag) != 0)
{
list.Add(pawn.story.adulthood);
}
if (pawn.health != null && pawn.health.hediffSet != null)
{
foreach (Hediff hediff in pawn.health.hediffSet.hediffs)
{
HediffStage curStage = hediff.CurStage;
if (curStage != null && (curStage.disabledWorkTags & workTag) != 0)
{
list.Add(hediff);
}
}
}
if (pawn.story.traits != null)
{
for (int i = 0; i < pawn.story.traits.allTraits.Count; i++)
{
Trait trait = pawn.story.traits.allTraits[i];
if ((trait.def.disabledWorkTags & workTag) != 0)
{
list.Add(trait);
}
}
}
if (pawn.royalty != null)
{
foreach (RoyalTitle item in pawn.royalty.AllTitlesForReading)
{
if (item.conceited && (item.def.disabledWorkTags & workTag) != 0)
{
list.Add(item);
}
}
}
foreach (QuestPart_WorkDisabled item2 in QuestUtility.GetWorkDisabledQuestPart(pawn))
{
if ((item2.disabledWorkTags & workTag) != 0 && !list.Contains(item2.quest))
{
list.Add(item2.quest);
}
}
return(list);
}
private static bool IsArtOrCraft(WorkTags workTags)
{
var tags = workTags.GetAllSelectedItems <WorkTags>();
foreach (var tag in tags)
{
if (tag == WorkTags.Crafting || tag == WorkTags.Artistic)
{
return(true);
}
}
return(false);
}
public static bool OverlapsWithOnAnyWorkType(this WorkTags a, WorkTags b)
{
List <WorkTypeDef> allDefsListForReading = DefDatabase <WorkTypeDef> .AllDefsListForReading;
for (int i = 0; i < allDefsListForReading.Count; i++)
{
WorkTypeDef workTypeDef = allDefsListForReading[i];
if ((workTypeDef.workTags & a) != 0 && (workTypeDef.workTags & b) != 0)
{
return(true);
}
}
return(false);
}
public TraitDefStat(TraitDef d) : base(d)
{
this.commonality = GetCommonality(d);
this.commonalityFemale = GetCommonalityFemale(d);
this.allowOnHostileSpawn = d.allowOnHostileSpawn;
this.requiredWorkTags = d.requiredWorkTags;
this.disabledWorkTags = d.disabledWorkTags;
this.disabledWorkTypes = Util.CreateDefStatList(d.disabledWorkTypes);
this.conflictingTraits = Util.CreateDefStatList(d.conflictingTraits);
this.requiredWorkTypes = Util.CreateDefStatList(d.requiredWorkTypes);
Util.Populate(out this.degreeDatas, d.degreeDatas, (v) => new TraitDegreeDataStats(v));
}
static bool Prefix(Pawn __instance, ref WorkTags __result)
{
if (LoadedModManager.GetMod <RoyaltyTweaksMod>().GetSettings <RoyaltyTweaksSettings>().willWorkPassionSkills &&
__instance.royalty != null &&
__instance.royalty.MostSeniorTitle != null &&
__instance.royalty.MostSeniorTitle.def != null &&
__instance.royalty.MostSeniorTitle.def.seniority > 100)
{
var list = DefDatabase <WorkTypeDef> .AllDefsListForReading;
var namelist = new List <string>();
if (LoadedModManager.GetMod <RoyaltyTweaksMod>().GetSettings <RoyaltyTweaksSettings>().willWorkOnlyMajorPassionSkills)
{
namelist = __instance.skills.skills.Where(a => a.passion == Passion.Major).Select(b => b.def.defName).ToList();
}
else
{
namelist = __instance.skills.skills.Where(a => a.passion != Passion.None).Select(b => b.def.defName).ToList();
}
if (namelist != null && namelist.Any())
{
var worklist = list.Where(a => a.relevantSkills != null && a.relevantSkills.Any() && namelist.Contains(a.relevantSkills.First().defName)).Select(b => b.workTags);
if (worklist != null && worklist.Any())
{
foreach (var worklistItem in worklist)
{
__result &= ~worklistItem;
}
// Might need to do this some day
//if (__instance.health != null && __instance.health.hediffSet != null)
//{
// foreach (Hediff hediff in __instance.health.hediffSet.hediffs)
// {
// HediffStage curStage = hediff.CurStage;
// if (curStage != null)
// {
// __result |= curStage.disabledWorkTags;
// }
// }
//}
}
}
return(false);
}
return(true);
}
private static IEnumerable <WorkTags> WorkTagsFrom(WorkTags tags)
{
foreach (WorkTags allSelectedItem in ((Enum)(object)tags).GetAllSelectedItems <WorkTags>())
{
if (allSelectedItem != 0)
{
yield return(allSelectedItem);
/*Error: Unable to find new state assignment for yield return*/;
}
}
yield break;
IL_00ce:
/*Error near IL_00cf: Unexpected return in MoveNext()*/;
}
private static string GetWorkTypesDisabledByWorkTag(WorkTags workTag)
{
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.AppendLine("IncapableOfTooltipWorkTypes".Translate());
foreach (WorkTypeDef allDef in DefDatabase <WorkTypeDef> .AllDefs)
{
if ((allDef.workTags & workTag) > WorkTags.None)
{
stringBuilder.Append("- ");
stringBuilder.AppendLine(allDef.pawnLabel);
}
}
return(stringBuilder.ToString());
}
public BackstoryStats(Backstory b)
{
this.backstory = b;
this.identifier = b.identifier;
this.shuffleable = b.shuffleable;
this.slot = b.slot;
this.workDisables = b.workDisables;
this.requiredWorkTags = b.requiredWorkTags;
Util.AssignDefStat(GetBodyTypeGlobal(b), out this.bodyTypeGlobal);
Util.AssignDefStat(GetBodyTypeMale(b), out this.bodyTypeMale);
Util.AssignDefStat(GetBodyTypeFemale(b), out this.bodyTypeFemale);
Util.Populate(out this.skillGains, b.skillGainsResolved, v => new IntValueDefStat <SkillDef>(v.Key, v.Value));
Util.Populate(out this.forcedTraits, b.forcedTraits, v => new IntValueDefStat <TraitDef>(v.def, v.degree));
Util.Populate(out this.disallowedTraits, b.disallowedTraits, v => new IntValueDefStat <TraitDef>(v.def, v.degree));
Util.Populate(out this.spawnCategories, b.spawnCategories);
}
public static bool Prefix(X2_ThingDef_AIRobot __instance, ref WorkTags ___robotWorkTagsInt, ref WorkTags __result)
{
if (___robotWorkTagsInt == WorkTags.None && __instance.robotWorkTypes.Count > 0)
{
foreach (X2_ThingDef_AIRobot.RobotWorkTypes robotWorkType in __instance.robotWorkTypes)
{
___robotWorkTagsInt |= robotWorkType.workTypeDef.workTags;
}
___robotWorkTagsInt &= ~(WorkTags.AllWork | WorkTags.Commoner | WorkTags.ManualDumb | WorkTags.ManualSkilled);
// Log.Message($"{__instance.defName} result {___robotWorkTagsInt}");
}
__result = ___robotWorkTagsInt;
return(false);
}
public static void PawnWorkDisablesSampled()
{
IOrderedEnumerable <PawnKindDef> orderedEnumerable = from k in DefDatabase <PawnKindDef> .AllDefs
where k.RaceProps.Humanlike
orderby k.combatPower
select k;
List <FloatMenuOption> list = new List <FloatMenuOption>();
foreach (PawnKindDef item2 in orderedEnumerable)
{
PawnKindDef kind = item2;
Faction fac = FactionUtility.DefaultFactionFrom(kind.defaultFactionType);
FloatMenuOption item = new FloatMenuOption(kind.defName + " (" + kind.combatPower + ")", delegate
{
Dictionary <WorkTags, int> dictionary = new Dictionary <WorkTags, int>();
for (int i = 0; i < 1000; i++)
{
Pawn pawn = PawnGenerator.GeneratePawn(kind, fac);
WorkTags combinedDisabledWorkTags = pawn.CombinedDisabledWorkTags;
foreach (WorkTags value in Enum.GetValues(typeof(WorkTags)))
{
if (!dictionary.ContainsKey(value))
{
dictionary.Add(value, 0);
}
if ((combinedDisabledWorkTags & value) != 0)
{
dictionary[value]++;
}
}
pawn.Destroy();
}
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.AppendLine("Sampled " + 1000 + "x " + kind.defName + ":");
stringBuilder.AppendLine("Worktags disabled");
foreach (WorkTags value2 in Enum.GetValues(typeof(WorkTags)))
{
int num = dictionary[value2];
stringBuilder.AppendLine(" " + value2.ToString() + " " + num + " (" + ((float)num / 1000f).ToStringPercent() + ")");
}
Log.Message(stringBuilder.ToString().TrimEndNewlines());
});
list.Add(item);
}
Find.WindowStack.Add(new FloatMenu(list));
}
public override void ResolveReferences()
{
Dictionary <SkillDef, int> skills = new Dictionary <SkillDef, int>();
base.ResolveReferences();
foreach (skillGains skillGains in this.skillGains)
{
if (!skills.ContainsKey(skillGains.skill))
{
skills.Add(skillGains.skill, skillGains.amount);
}
}
foreach (traitList traitItem in forcedTraits)
{
traitsToForce.Add(new TraitEntry(traitItem.def, traitItem.degree));
}
this.story = new Backstory
{
slot = this.backstorySlot,
title = this.title,
titleFemale = this.femaleTitle,
titleShort = this.shortTitle,
titleShortFemale = this.shortFemaleTitle,
identifier = this.defName,
baseDesc = this.storyDesc,
spawnCategories = this.spawnInCategories,
skillGainsResolved = skills,
forcedTraits = this.traitsToForce,
disallowedTraits = this.traitsToDisable,
workDisables = ((Func <WorkTags>) delegate {
WorkTags work = WorkTags.None;
Enum.GetValues(typeof(WorkTags)).Cast <WorkTags>().Where(tag =>
((!enabledWorkTypes.NullOrEmpty() && !enabledWorkTypes.Contains(tag)) ||
disabledWorkTypes.Contains(tag)) &&
(!(disabledWorkTypes.Contains(WorkTags.AllWork)) && !(tag == WorkTags.AllWork))
).ToList().ForEach(tag => work |= tag);
return(work);
})(),
shuffleable = this.shuffable
};
BackstoryDatabase.AddBackstory(story);
//Log.Message("created story: " + this.defName);
}
public static void WorkTagIsDisabledPostfix(WorkTags w, ref Pawn __instance, ref bool __result)
{
if (w != WorkTags.Violent)
{
return;
}
if (__result == false)
{
return;
}
if (Controller.LastWeaponCheckType == FireExtDefOf.Gun_Fire_Ext &&
__instance.equipment?.PrimaryEq?.parent?.def == FireExtDefOf.Gun_Fire_Ext)
{
__result = false;
}
}
