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; } }