public TraitData(TraitEntry entry, int status)
{
traitDef = entry.def;
degreeInt = entry.degree;
this.status = status;
trait = entry;
}
private IntInputWidget <TraitEntry> CreateTraitEntryInput(TraitEntry te)
{
var input = new IntInputWidget <TraitEntry>(te, Util.GetLabel(te.def) + " (Degree)", d => d.degree, (d, i) => d.degree = i);
StringBuilder sb = new StringBuilder(Util.GetLabel(te.def));
sb.AppendLine();
sb.AppendLine("Degrees:");
foreach (var degree in te.def.degreeDatas)
{
sb.AppendLine(degree.degree + " = " + degree.label);
}
input.ToolTip = sb.ToString();
input.IsValid = v =>
{
foreach (var degree in te.def.degreeDatas)
{
if (degree.degree == v)
{
return(true);
}
}
return(false);
};
return(input);
}
public static bool CheckTrait(ThingDef pawn, TraitEntry traitEntry)
{
if (pawn is RaceAddonThingDef thingDef)
{
if (!CheckRaceSexuality(thingDef, traitEntry.def))
{
return(false);
}
var set = thingDef.raceAddonSettings.traitSetting.traitRestriction;
if (!TraitRestrictions.Contains(traitEntry))
{
if (set.allAllow && !set.allAllow_Exceptions.Any(x => x.traitDef == traitEntry.def && x.degree == traitEntry.degree))
{
return(true);
}
if (!set.allAllow && set.allAllow_Exceptions.Any(x => x.traitDef == traitEntry.def && x.degree == traitEntry.degree))
{
return(true);
}
}
else if (set.raceSpecifics.Any(x => x.traitDef == traitEntry.def && x.degree == traitEntry.degree))
{
return(true);
}
}
else if (!TraitRestrictions.Contains(traitEntry))
{
return(true);
}
return(false);
}
public static void Setup()
{
foreach (var workTag in Enum.GetValues(typeof(WorkTags)).Cast <WorkTags>())
{
var jobList = DefDatabase <WorkTypeDef>
.AllDefs
.Where(wtd => wtd.visible &&
(wtd.workTags & workTag) != WorkTags.None &&
wtd.defName != "FinishingOff")
.ToHashSet();
workTypes.Add(workTag, jobList);
}
var hatesDumbLaborTrait = TraitDef.Named("HatesDumbLabor");
var hatesDumbLabor = new[] {
WorkTags.ManualDumb,
WorkTags.Cleaning,
WorkTags.Hauling
};
foreach (var backstory in BackstoryDatabase.allBackstories.Values)
{
TraitEntry entry = null;
foreach (var tag in hatesDumbLabor)
{
if ((tag & backstory.workDisables) == tag)
{
entry = new TraitEntry(hatesDumbLaborTrait, 0);
break;
}
}
if (entry != null)
{
if (backstory.forcedTraits.NullOrEmpty())
{
backstory.forcedTraits = new List <TraitEntry>();
}
backstory.forcedTraits.Add(entry);
}
}
if (ModsConfig.ActiveModsInLoadOrder.Any(mod => mod.Name.Contains("Force Do Job")))
{
Log.Error("MoreThanCapable :: You should remove \"Force Do Job\" from your mod list, as \"MoreThanCapable\" incorporates its functionality, and if both mods are running, you may encounter odd behavior.");
}
}
public static void postfix(ref Pawn pawn)
{
if (Amnesia.ForgetTraits)
{
pawn.story.traits.allTraits.Clear();
if (pawn.story.childhood.forcedTraits != null && !Amnesia.ForgetForcedTraits)
{
List <TraitEntry> forcedTraits = pawn.story.childhood.forcedTraits;
for (int i = 0; i < forcedTraits.Count; i++)
{
TraitEntry traitEntry = forcedTraits[i];
if (traitEntry.def == null)
{
Log.Error("Null forced trait def on " + pawn.story.childhood);
}
else if (!pawn.story.traits.HasTrait(traitEntry.def))
{
pawn.story.traits.GainTrait(new Trait(traitEntry.def, traitEntry.degree, false));
}
}
}
}
}
public BackstoryWidget(Backstory backstory, DefType type) : base(backstory, type)
{
if (backstory.skillGainsResolved == null)
{
backstory.skillGainsResolved = new Dictionary <SkillDef, int>();
}
if (backstory.forcedTraits == null)
{
backstory.forcedTraits = new List <TraitEntry>();
}
if (backstory.disallowedTraits == null)
{
backstory.disallowedTraits = new List <TraitEntry>();
}
this.Backstory = backstory;
this.type = type;
this.inputWidgets = new List <IInputWidget>()
{
new BoolInputWidget <Backstory>(this.Backstory, "Shuffleable", b => b.shuffleable, (b, v) => b.shuffleable = v),
new EnumInputWidget <Backstory, BackstorySlot>(this.Backstory, "Slot", 200, b => b.slot, (b, v) => b.slot = v),
new DefInputWidget <Backstory, BodyTypeDef>(this.Backstory, "Body Type Global", 200, b => BackstoryStats.GetBodyTypeGlobal(b), (b, v) => BackstoryStats.SetBodyTypeGlobal(b, v), true),
new DefInputWidget <Backstory, BodyTypeDef>(this.Backstory, "Body Type Male", 200, b => BackstoryStats.GetBodyTypeMale(b), (b, v) => BackstoryStats.SetBodyTypeMale(b, v), true, d => d == BodyTypeDefOf.Female),
new DefInputWidget <Backstory, BodyTypeDef>(this.Backstory, "Body Type Female", 200, b => BackstoryStats.GetBodyTypeFemale(b), (b, v) => BackstoryStats.SetBodyTypeFemale(b, v), true, d => d == BodyTypeDefOf.Male),
};
var dic = new SortedDictionary <string, WorkTags>();
foreach (var v in Enum.GetValues(typeof(WorkTags)).Cast <WorkTags>())
{
dic.Add(v.ToString(), v);
}
this.workTags = new List <WorkTags>(dic.Values);
dic.Clear();
dic = null;
this.workDisables = new PlusMinusArgs <WorkTags>()
{
allItems = this.workTags,
isBeingUsed = v => (this.Backstory.workDisables & v) == v,
onAdd = v => this.Backstory.workDisables |= v,
onRemove = v => this.Backstory.workDisables &= ~v,
getDisplayName = v => v.ToString()
};
this.requiredWorkTags = new PlusMinusArgs <WorkTags>()
{
allItems = this.workTags,
isBeingUsed = v => (this.Backstory.requiredWorkTags & v) == v,
onAdd = v => this.Backstory.requiredWorkTags |= v,
onRemove = v => this.Backstory.requiredWorkTags &= ~v,
getDisplayName = v => v.ToString()
};
this.skillGainsPlusMinus = new PlusMinusArgs <SkillDef>()
{
allItems = Util.SortedDefList <SkillDef>(),
beingUsed = () => this.Backstory.skillGainsResolved.Keys,
onAdd = v =>
{
this.Backstory.skillGainsResolved[v] = 0;
this.skillGains.Add(this.CreateSkillGainsInput(v));
},
onRemove = v =>
{
this.Backstory.skillGainsResolved.Remove(v);
for (int i = 0; i < this.skillGains.Count; ++i)
{
if (this.skillGains[i].DisplayLabel == Util.GetLabel(v))
{
this.skillGains.RemoveAt(i);
break;
}
}
},
getDisplayName = v => Util.GetLabel(v),
};
this.forcedTraitsPlusMinus = new PlusMinusArgs <TraitDef>()
{
allItems = Util.SortedDefList <TraitDef>(),
beingUsed = () => Util.ConvertItems(this.Backstory.forcedTraits, v => v.def),
onAdd = v =>
{
TraitEntry te = new TraitEntry(v, 0);
this.Backstory.forcedTraits.Add(te);
this.forcedTraits.Add(this.CreateTraitEntryInput(te));
this.RemoveDisallowedTraits(v);
},
onRemove = v =>
{
this.RemoveForcedTraits(v);
},
getDisplayName = v => Util.GetLabel(v),
};
this.disallowedTraitsPlusMinus = new PlusMinusArgs <TraitDef>()
{
allItems = Util.SortedDefList <TraitDef>(),
beingUsed = () => Util.ConvertItems(this.Backstory.disallowedTraits, v => v.def),
onAdd = v =>
{
TraitEntry te = new TraitEntry(v, 0);
this.Backstory.disallowedTraits.Add(te);
this.disallowedTraits.Add(this.CreateTraitEntryInput(te));
this.RemoveForcedTraits(v);
},
onRemove = v =>
{
this.RemoveDisallowedTraits(v);
},
getDisplayName = v => Util.GetLabel(v),
};
this.Rebuild();
}
/// <summary>
/// Remove a Component from the race's RaceComponents list.
/// </summary>
/// <param name="componentToRemove">The Component to remove.</param>
public void Remove(TraitEntry componentToRemove)
{
Remove(componentToRemove.Name);
}
public override void ResolveReferences()
{
base.ResolveReferences();
if (!this.addToDatabase)
{
return;
}
if (BackstoryDatabase.allBackstories.ContainsKey(this.UniqueSaveKey()))
{
return;
}
Backstory b = new Backstory();
if (!this.title.NullOrEmpty())
{
b.SetTitle(this.title);
}
else
{
return;
}
if (!titleShort.NullOrEmpty())
{
b.SetTitleShort(titleShort);
}
else
{
b.SetTitleShort(b.Title);
}
if (!baseDescription.NullOrEmpty())
{
b.baseDesc = baseDescription;
}
else
{
b.baseDesc = "Empty.";
}
b.bodyTypeGlobal = bodyTypeGlobal;
b.bodyTypeMale = bodyTypeMale;
b.bodyTypeFemale = bodyTypeFemale;
b.slot = slot;
b.shuffleable = shuffleable;
if (spawnCategories.NullOrEmpty())
{
return;
}
else
{
b.spawnCategories = spawnCategories;
}
if (workAllows.Count > 0)
{
foreach (WorkTags current in Enum.GetValues(typeof(WorkTags)))
{
if (!workAllows.Contains(current))
{
b.workDisables |= current;
}
}
}
else if (workDisables.Count > 0)
{
foreach (var tag in workDisables)
{
b.workDisables |= tag;
}
}
else
{
b.workDisables = WorkTags.None;
}
b.skillGains = skillGains.ToDictionary(i => i.defName, i => i.amount);
if (forcedTraits.Count > 0)
{
b.forcedTraits = new List <TraitEntry>();
foreach (var trait in forcedTraits)
{
var newTrait = new TraitEntry(trait.def, trait.degree);
b.forcedTraits.Add(newTrait);
}
}
if (disallowedTraits.Count > 0)
{
b.disallowedTraits = new List <TraitEntry>();
foreach (var trait in disallowedTraits)
{
var newTrait = new TraitEntry(trait.def, trait.degree);
b.disallowedTraits.Add(newTrait);
}
}
b.ResolveReferences();
b.PostLoad();
bool flag = false;
foreach (var s in b.ConfigErrors(false))
{
if (!flag)
{
flag = true;
}
}
if (!flag)
{
BackstoryDatabase.AddBackstory(b);
//CCL_Log.Message("Added " + this.UniqueSaveKey() + " backstory", "Backstories");
}
}
private static void GiveRandomTraits(Pawn pawn, bool allowGay)
{
if (pawn.story == null)
{
return;
}
if (pawn.story.childhood.forcedTraits != null)
{
List <TraitEntry> forcedTraits = pawn.story.childhood.forcedTraits;
for (int i = 0; i < forcedTraits.Count; i++)
{
TraitEntry traitEntry = forcedTraits[i];
if (traitEntry.def == null)
{
Log.Error("Null forced trait def on " + pawn.story.childhood);
}
else if (!pawn.story.traits.HasTrait(traitEntry.def))
{
pawn.story.traits.GainTrait(new Trait(traitEntry.def, traitEntry.degree));
}
}
}
if (pawn.story.adulthood.forcedTraits != null)
{
List <TraitEntry> forcedTraits2 = pawn.story.adulthood.forcedTraits;
for (int j = 0; j < forcedTraits2.Count; j++)
{
TraitEntry traitEntry2 = forcedTraits2[j];
if (traitEntry2.def == null)
{
Log.Error("Null forced trait def on " + pawn.story.adulthood);
}
else if (!pawn.story.traits.HasTrait(traitEntry2.def))
{
pawn.story.traits.GainTrait(new Trait(traitEntry2.def, traitEntry2.degree));
}
}
}
int num = Rand.RangeInclusive(2, 3);
if (allowGay && (LovePartnerRelationUtility.HasAnyLovePartnerOfTheSameGender(pawn) || LovePartnerRelationUtility.HasAnyExLovePartnerOfTheSameGender(pawn)))
{
Trait trait = new Trait(TraitDefOf.Gay, AlienPawnGenerator.RandomTraitDegree(TraitDefOf.Gay));
pawn.story.traits.GainTrait(trait);
}
while (pawn.story.traits.allTraits.Count < num)
{
TraitDef newTraitDef = DefDatabase <TraitDef> .AllDefsListForReading.RandomElementByWeight((TraitDef tr) => tr.GetGenderSpecificCommonality(pawn));
if (!pawn.story.traits.HasTrait(newTraitDef))
{
if (newTraitDef == TraitDefOf.Gay)
{
if (!allowGay)
{
continue;
}
if (LovePartnerRelationUtility.HasAnyLovePartnerOfTheOppositeGender(pawn) || LovePartnerRelationUtility.HasAnyExLovePartnerOfTheOppositeGender(pawn))
{
continue;
}
}
if (!pawn.story.traits.allTraits.Any((Trait tr) => newTraitDef.ConflictsWith(tr)) && (newTraitDef.conflictingTraits == null || !newTraitDef.conflictingTraits.Any((TraitDef tr) => pawn.story.traits.HasTrait(tr))))
{
if (newTraitDef.requiredWorkTypes == null || !pawn.story.OneOfWorkTypesIsDisabled(newTraitDef.requiredWorkTypes))
{
if (!pawn.story.WorkTagIsDisabled(newTraitDef.requiredWorkTags))
{
int degree = AlienPawnGenerator.RandomTraitDegree(newTraitDef);
if (!pawn.story.childhood.DisallowsTrait(newTraitDef, degree) && !pawn.story.adulthood.DisallowsTrait(newTraitDef, degree))
{
Trait trait2 = new Trait(newTraitDef, degree);
if (pawn.mindState == null || pawn.mindState.mentalBreaker == null || pawn.mindState.mentalBreaker.BreakThresholdExtreme + trait2.OffsetOfStat(StatDefOf.MentalBreakThreshold) <= 40f)
{
pawn.story.traits.GainTrait(trait2);
}
}
}
}
}
}
}
}
private static void GenerateTraits(Pawn pawn, PawnGenerationRequest request)
{
if (pawn.story == null)
{
return;
}
if (pawn.story.childhood.forcedTraits != null)
{
List <TraitEntry> forcedTraits = pawn.story.childhood.forcedTraits;
for (int i = 0; i < forcedTraits.Count; i++)
{
TraitEntry traitEntry = forcedTraits[i];
if (traitEntry.def == null)
{
Log.Error("Null forced trait def on " + pawn.story.childhood);
}
else if (!pawn.story.traits.HasTrait(traitEntry.def))
{
pawn.story.traits.GainTrait(new Trait(traitEntry.def, traitEntry.degree, false));
}
}
}
if (pawn.story.adulthood != null && pawn.story.adulthood.forcedTraits != null)
{
List <TraitEntry> forcedTraits2 = pawn.story.adulthood.forcedTraits;
for (int j = 0; j < forcedTraits2.Count; j++)
{
TraitEntry traitEntry2 = forcedTraits2[j];
if (traitEntry2.def == null)
{
Log.Error("Null forced trait def on " + pawn.story.adulthood);
}
else if (!pawn.story.traits.HasTrait(traitEntry2.def))
{
pawn.story.traits.GainTrait(new Trait(traitEntry2.def, traitEntry2.degree, false));
}
}
}
int num = Rand.RangeInclusive(2, 3);
if (request.AllowGay && (LovePartnerRelationUtility.HasAnyLovePartnerOfTheSameGender(pawn) || LovePartnerRelationUtility.HasAnyExLovePartnerOfTheSameGender(pawn)))
{
Trait trait = new Trait(TraitDefOf.Gay, PawnGenerator.RandomTraitDegree(TraitDefOf.Gay), false);
pawn.story.traits.GainTrait(trait);
}
while (pawn.story.traits.allTraits.Count < num)
{
TraitDef newTraitDef = DefDatabase <TraitDef> .AllDefsListForReading.RandomElementByWeight((TraitDef tr) => tr.GetGenderSpecificCommonality(pawn));
if (!pawn.story.traits.HasTrait(newTraitDef))
{
if (newTraitDef == TraitDefOf.Gay)
{
if (!request.AllowGay)
{
continue;
}
if (LovePartnerRelationUtility.HasAnyLovePartnerOfTheOppositeGender(pawn) || LovePartnerRelationUtility.HasAnyExLovePartnerOfTheOppositeGender(pawn))
{
continue;
}
}
if (request.Faction == null || Faction.OfPlayerSilentFail == null || !request.Faction.HostileTo(Faction.OfPlayer) || newTraitDef.allowOnHostileSpawn)
{
if (!pawn.story.traits.allTraits.Any((Trait tr) => newTraitDef.ConflictsWith(tr)) && (newTraitDef.conflictingTraits == null || !newTraitDef.conflictingTraits.Any((TraitDef tr) => pawn.story.traits.HasTrait(tr))))
{
if (newTraitDef.requiredWorkTypes == null || !pawn.story.OneOfWorkTypesIsDisabled(newTraitDef.requiredWorkTypes))
{
if (!pawn.story.WorkTagIsDisabled(newTraitDef.requiredWorkTags))
{
int degree = PawnGenerator.RandomTraitDegree(newTraitDef);
if (!pawn.story.childhood.DisallowsTrait(newTraitDef, degree) && (pawn.story.adulthood == null || !pawn.story.adulthood.DisallowsTrait(newTraitDef, degree)))
{
Trait trait2 = new Trait(newTraitDef, degree, false);
if (pawn.mindState != null && pawn.mindState.mentalBreaker != null)
{
float num2 = pawn.mindState.mentalBreaker.BreakThresholdExtreme;
num2 += trait2.OffsetOfStat(StatDefOf.MentalBreakThreshold);
num2 *= trait2.MultiplierOfStat(StatDefOf.MentalBreakThreshold);
if (num2 > 0.4f)
{
continue;
}
}
pawn.story.traits.GainTrait(trait2);
}
}
}
}
}
}
}
}
public override void ResolveReferences()
{
base.ResolveReferences();
RaceAddonTools.AllRaceAddonThingDefs.Add(this);
//==================== Rotting Corpse ====================//
if (!raceAddonSettings.deathSetting.rottingCorpse)
{
race.corpseDef.comps.RemoveAll((CompProperties x) => x is CompProperties_Rottable);
race.corpseDef.comps.RemoveAll((CompProperties x) => x is CompProperties_SpawnerFilth);
}
//==================== Work Setting ====================//
if (raceAddonSettings.workSetting.workGiverRestriction.allAllow)
{
foreach (WorkGiverDef def in raceAddonSettings.workSetting.workGiverRestriction.allAllow_Exceptions)
{
if (!DisabledWorkGivers.Contains(def))
{
DisabledWorkGivers.Add(def);
}
}
}
else
{
foreach (WorkGiverDef def in DefDatabase <WorkGiverDef> .AllDefs)
{
if (!raceAddonSettings.workSetting.workGiverRestriction.allAllow_Exceptions.Contains(def))
{
if (!DisabledWorkGivers.Contains(def))
{
DisabledWorkGivers.Add(def);
}
}
}
}
foreach (WorkGiverDef def in raceAddonSettings.workSetting.workGiverRestriction.raceSpecifics)
{
if (!RaceAddonTools.WorkGiverRestrictions.Contains(def))
{
RaceAddonTools.WorkGiverRestrictions.Add(def);
}
}
if (raceAddonSettings.workSetting.workDisables != null)
{
WorkTags workTags = WorkTags.None;
foreach (WorkTags tag in raceAddonSettings.workSetting.workDisables)
{
workTags |= tag;
}
DisabledWorkTags = workTags;
foreach (WorkTypeDef def in DefDatabase <WorkTypeDef> .AllDefsListForReading.FindAll(x => (DisabledWorkTags & x.workTags) != 0))
{
if (!DisabledWorkTypes.Contains(def))
{
DisabledWorkTypes.Add(def);
}
}
}
//==================== Trait Setting ====================//
foreach (var info in raceAddonSettings.traitSetting.traitRestriction.raceSpecifics)
{
TraitEntry traitEntry = new TraitEntry(info.traitDef, info.degree);
if (!RaceAddonTools.TraitRestrictions.Contains(traitEntry))
{
RaceAddonTools.TraitRestrictions.Add(traitEntry);
}
}
//==================== Mood Setting ====================//
List <ThoughtDef> privateMoodList = raceAddonSettings.moodSetting.moodRestriction.raceSpecifics;
foreach (ThoughtDef mood in privateMoodList)
{
if (!RaceAddonTools.MoodRestrictions.Contains(mood))
{
RaceAddonTools.MoodRestrictions.Add(mood);
}
}
//==================== Hediff Setting ====================//
List <HediffDef> privateHediffList = raceAddonSettings.hediffSetting.hediffRestriction.raceSpecifics;
foreach (HediffDef hediffDef in privateHediffList)
{
if (!RaceAddonTools.HediffRestrictions.Contains(hediffDef))
{
RaceAddonTools.HediffRestrictions.Add(hediffDef);
}
}
//==================== Restriction Setting ====================//
foreach (ThingDef def in raceAddonSettings.apparelRestrictionSetting.raceSpecifics)
{
if (!RaceAddonTools.ApparelRestrictions.Contains(def))
{
RaceAddonTools.ApparelRestrictions.Add(def);
}
}
foreach (ThingDef def in raceAddonSettings.weaponRestrictionSetting.raceSpecifics)
{
if (!RaceAddonTools.WeaponRestrictions.Contains(def))
{
RaceAddonTools.WeaponRestrictions.Add(def);
}
}
foreach (ThingDef def in raceAddonSettings.buildingRestrictionSetting.raceSpecifics)
{
if (!RaceAddonTools.BuildingRestrictions.Contains(def))
{
RaceAddonTools.BuildingRestrictions.Add(def);
}
}
foreach (ThingDef def in raceAddonSettings.foodRestrictionSetting.raceSpecifics)
{
if (!RaceAddonTools.FoodRestrictions.Contains(def))
{
RaceAddonTools.FoodRestrictions.Add(def);
}
}
foreach (ThingDef def in raceAddonSettings.plantRestrictionSetting.raceSpecifics)
{
if (!RaceAddonTools.PlantRestrictions.Contains(def))
{
RaceAddonTools.PlantRestrictions.Add(def);
}
}
foreach (ThingDef def in raceAddonSettings.animalRestrictionSetting.raceSpecifics)
{
if (!RaceAddonTools.AnimalRestrictions.Contains(def))
{
RaceAddonTools.AnimalRestrictions.Add(def);
}
}
foreach (RecipeDef def in raceAddonSettings.recipeRestrictionSetting.raceSpecifics)
{
if (!RaceAddonTools.RecipeRestrictions.Contains(def))
{
RaceAddonTools.RecipeRestrictions.Add(def);
}
}
foreach (ResearchProjectDef def in raceAddonSettings.researchRestrictionSetting.raceSpecifics)
{
if (!RaceAddonTools.ResearchRestrictions.Contains(def))
{
RaceAddonTools.ResearchRestrictions.Add(def);
}
}
if (comps.Any(x => x.compClass == typeof(RaceAddonComp)))
{
Log.Warning("====================================================================================================");
Log.Warning("[Garam, Race Addon] " + defName + " has a duplicate RaceAddonComp!");
Log.Warning("====================================================================================================");
}
else
{
comps.Add(new CompProperties(typeof(RaceAddonComp)));
}
}
private static void GenerateTraits(Pawn pawn, PawnGenerationRequest request)
{
if (pawn.story == null)
{
return;
}
if (request.ForcedTraits != null)
{
foreach (TraitDef forcedTrait in request.ForcedTraits)
{
if (forcedTrait != null)
{
pawn.story.traits.GainTrait(new Trait(forcedTrait, 0, forced: true));
}
}
}
if (pawn.story.childhood.forcedTraits != null)
{
List <TraitEntry> forcedTraits = pawn.story.childhood.forcedTraits;
for (int i = 0; i < forcedTraits.Count; i++)
{
TraitEntry traitEntry = forcedTraits[i];
if (traitEntry.def == null)
{
Log.Error("Null forced trait def on " + pawn.story.childhood);
}
else if ((request.KindDef.disallowedTraits == null || !request.KindDef.disallowedTraits.Contains(traitEntry.def)) && !pawn.story.traits.HasTrait(traitEntry.def) && (request.ProhibitedTraits == null || !request.ProhibitedTraits.Contains(traitEntry.def)))
{
pawn.story.traits.GainTrait(new Trait(traitEntry.def, traitEntry.degree));
}
}
}
if (pawn.story.adulthood != null && pawn.story.adulthood.forcedTraits != null)
{
List <TraitEntry> forcedTraits2 = pawn.story.adulthood.forcedTraits;
for (int j = 0; j < forcedTraits2.Count; j++)
{
TraitEntry traitEntry2 = forcedTraits2[j];
if (traitEntry2.def == null)
{
Log.Error("Null forced trait def on " + pawn.story.adulthood);
}
else if ((request.KindDef.disallowedTraits == null || !request.KindDef.disallowedTraits.Contains(traitEntry2.def)) && !pawn.story.traits.HasTrait(traitEntry2.def) && (request.ProhibitedTraits == null || !request.ProhibitedTraits.Contains(traitEntry2.def)))
{
pawn.story.traits.GainTrait(new Trait(traitEntry2.def, traitEntry2.degree));
}
}
}
int num = Rand.RangeInclusive(2, 3);
if (request.AllowGay && (LovePartnerRelationUtility.HasAnyLovePartnerOfTheSameGender(pawn) || LovePartnerRelationUtility.HasAnyExLovePartnerOfTheSameGender(pawn)))
{
Trait trait = new Trait(TraitDefOf.Gay, RandomTraitDegree(TraitDefOf.Gay));
pawn.story.traits.GainTrait(trait);
}
while (pawn.story.traits.allTraits.Count < num)
{
TraitDef newTraitDef = DefDatabase <TraitDef> .AllDefsListForReading.RandomElementByWeight((TraitDef tr) => tr.GetGenderSpecificCommonality(pawn.gender));
if (pawn.story.traits.HasTrait(newTraitDef) || (request.KindDef.disallowedTraits != null && request.KindDef.disallowedTraits.Contains(newTraitDef)) || (request.KindDef.requiredWorkTags != 0 && (newTraitDef.disabledWorkTags & request.KindDef.requiredWorkTags) != 0) || (newTraitDef == TraitDefOf.Gay && (!request.AllowGay || LovePartnerRelationUtility.HasAnyLovePartnerOfTheOppositeGender(pawn) || LovePartnerRelationUtility.HasAnyExLovePartnerOfTheOppositeGender(pawn))) || (request.ProhibitedTraits != null && request.ProhibitedTraits.Contains(newTraitDef)) || (request.Faction != null && Faction.OfPlayerSilentFail != null && request.Faction.HostileTo(Faction.OfPlayer) && !newTraitDef.allowOnHostileSpawn) || pawn.story.traits.allTraits.Any((Trait tr) => newTraitDef.ConflictsWith(tr)) || (newTraitDef.requiredWorkTypes != null && pawn.OneOfWorkTypesIsDisabled(newTraitDef.requiredWorkTypes)) || pawn.WorkTagIsDisabled(newTraitDef.requiredWorkTags) || (newTraitDef.forcedPassions != null && pawn.workSettings != null && newTraitDef.forcedPassions.Any((SkillDef p) => p.IsDisabled(pawn.story.DisabledWorkTagsBackstoryAndTraits, pawn.GetDisabledWorkTypes(permanentOnly: true)))))
{
continue;
}
int degree = RandomTraitDegree(newTraitDef);
if (!pawn.story.childhood.DisallowsTrait(newTraitDef, degree) && (pawn.story.adulthood == null || !pawn.story.adulthood.DisallowsTrait(newTraitDef, degree)))
{
Trait trait2 = new Trait(newTraitDef, degree);
if (pawn.mindState == null || pawn.mindState.mentalBreaker == null || !((pawn.mindState.mentalBreaker.BreakThresholdMinor + trait2.OffsetOfStat(StatDefOf.MentalBreakThreshold)) * trait2.MultiplierOfStat(StatDefOf.MentalBreakThreshold) > 0.5f))
{
pawn.story.traits.GainTrait(trait2);
}
}
}
}
public override void ResolveReferences()
{
base.ResolveReferences();
if (!this.addToDatabase)
{
return;
}
if (BackstoryDatabase.allBackstories.ContainsKey(this.UniqueSaveKey()))
{
return;
}
Backstory b = new Backstory();
if (!this.title.NullOrEmpty())
{
b.SetTitle(this.title, this.title);
}
else
{
return;
}
if (!titleShort.NullOrEmpty())
{
b.SetTitleShort(titleShort, titleShort);
}
else
{
b.SetTitleShort(b.title, b.title);
}
if (!baseDescription.NullOrEmpty())
{
b.baseDesc = baseDescription;
}
else
{
b.baseDesc = "Empty.";
}
// [B19] These are now private variables.
Traverse.Create(b).Field("bodyTypeGlobal").SetValue(bodyTypeGlobal);
Traverse.Create(b).Field("bodyTypeMale").SetValue(bodyTypeMale);
Traverse.Create(b).Field("bodyTypeFemale").SetValue(bodyTypeFemale);
b.slot = slot;
b.shuffleable = shuffleable;
if (spawnCategories.NullOrEmpty())
{
return;
}
else
{
b.spawnCategories = spawnCategories;
}
if (workAllows.Count > 0)
{
foreach (WorkTags current in Enum.GetValues(typeof(WorkTags)))
{
if (!workAllows.Contains(current))
{
b.workDisables |= current;
}
}
}
else if (workDisables.Count > 0)
{
foreach (var tag in workDisables)
{
b.workDisables |= tag;
}
}
else
{
b.workDisables = WorkTags.None;
}
Dictionary <string, int> skGains = skillGains.ToDictionary(i => i.defName, i => i.amount);
foreach (KeyValuePair <string, int> current in skGains)
{
b.skillGainsResolved.Add(DefDatabase <SkillDef> .GetNamed(current.Key, true), current.Value);
}
if (forcedTraits.Count > 0)
{
b.forcedTraits = new List <TraitEntry>();
foreach (var trait in forcedTraits)
{
var newTrait = new TraitEntry(trait.def, trait.degree);
b.forcedTraits.Add(newTrait);
}
}
if (disallowedTraits.Count > 0)
{
b.disallowedTraits = new List <TraitEntry>();
foreach (var trait in disallowedTraits)
{
var newTrait = new TraitEntry(trait.def, trait.degree);
b.disallowedTraits.Add(newTrait);
}
}
b.ResolveReferences();
b.PostLoad();
b.identifier = this.UniqueSaveKey();
bool flag = false;
foreach (var s in b.ConfigErrors(false))
{
if (!flag)
{
flag = true;
}
}
if (!flag)
{
BackstoryDatabase.AddBackstory(b);
//Log.Message("Added " + this.UniqueSaveKey() + " backstory");
//CCL_Log.Message("Added " + this.UniqueSaveKey() + " backstory", "Backstories");
}
}
public int calculateAdvantagePoints(Race race)
{
int points = 1650, hab;
int grRateFactor, facOperate, tenFacRes, operPoints, costPoints, prodPoints, tmpPoints, grRate, i, j, k;
string PRT;
/*cout << "Step 1, points = " << points << endl;*/
// BoundsCheck(race);
PRT = race.Traits.Primary.Code;
hab = habPoints(race) / 2000;
/*cout << "Step 2, hab points = " << hab << endl;*/
grRateFactor = (int)race.GrowthRate;
grRate = grRateFactor;
if (grRateFactor <= 5)
{
points += (6 - grRateFactor) * 4200;
}
else if (grRateFactor <= 13)
{
switch (grRateFactor)
{
case 6: points += 3600; break;
case 7: points += 2250; break;
case 8: points += 600; break;
case 9: points += 225; break;
}
grRateFactor = grRateFactor * 2 - 5;
}
else if (grRateFactor < 20)
{
grRateFactor = (grRateFactor - 6) * 3;
}
else
{
grRateFactor = 45;
}
points -= (hab * grRateFactor) / 24;
/*cout << "Step 3, points = " << points << endl;*/
i = 0;
for (j = 0; j < 3; j++)
{
if (race.IsImmune(j)) //if (race.centerHab(j) < 0)
{
i++;
}
else
{
points += Math.Abs(race.CenterHab(j) - 50) * 4;
}
}
if (i > 1)
{
points -= 150;
}
/*cout << "Step 4, points = " << points << endl;*/
facOperate = race.OperableFactories;
tenFacRes = race.FactoryProduction;
if (facOperate > 10 || tenFacRes > 10)
{
facOperate -= 9; if (facOperate < 1)
{
facOperate = 1;
}
tenFacRes -= 9; if (tenFacRes < 1)
{
tenFacRes = 1;
}
tenFacRes *= (2 + (PRT == PRT_HE ? 1 : 0));
/*additional penalty for two- and three-immune*/
if (i >= 2)
{
points -= ((tenFacRes * facOperate) * grRate) / 2;
}
else
{
points -= ((tenFacRes * facOperate) * grRate) / 9;
}
}
j = race.ColonistsPerResource / 100;
if (j > 25)
{
j = 25;
}
if (j <= 7)
{
points -= 2400;
}
else if (j == 8)
{
points -= 1260;
}
else if (j == 9)
{
points -= 600;
}
else if (j > 10)
{
points += (j - 10) * 120;
}
/*cout << "Step 5, points = " << points << endl;*/
if (PRT != PRT_AR)
{
/*factories*/
prodPoints = 10 - race.FactoryProduction;
costPoints = 10 - race.FactoryBuildCost;
operPoints = 10 - race.OperableFactories;
tmpPoints = 0;
if (prodPoints > 0)
{
tmpPoints = prodPoints * 100;
}
else
{
tmpPoints += prodPoints * 121;
}
if (costPoints > 0)
{
tmpPoints += costPoints * costPoints * (-60);
}
else
{
tmpPoints += costPoints * (-55);
}
if (operPoints > 0)
{
tmpPoints += operPoints * 40;
}
else
{
tmpPoints += operPoints * 35;
}
if (tmpPoints > 700)
{
tmpPoints = (tmpPoints - 700) / 3 + 700;
}
if (operPoints <= -7)
{
if (operPoints < -11)
{
if (operPoints < -14)
{
tmpPoints -= 360;
}
else
{
tmpPoints += (operPoints + 7) * 45;
}
}
else
{
tmpPoints += (operPoints + 6) * 30;
}
}
if (prodPoints <= -3)
{
tmpPoints += (prodPoints + 2) * 60;
}
points += tmpPoints;
if (race.Traits.Contains("CF"))
{
points -= 175;
}
/*mines*/
prodPoints = 10 - race.MineProductionRate;
costPoints = 3 - race.MineBuildCost;
operPoints = 10 - race.OperableMines;
tmpPoints = 0;
if (prodPoints > 0)
{
tmpPoints = prodPoints * 100;
}
else
{
tmpPoints += prodPoints * 169;
}
if (costPoints > 0)
{
tmpPoints -= 360;
}
else
{
tmpPoints += costPoints * (-65) + 80;
}
if (operPoints > 0)
{
tmpPoints += operPoints * 40;
}
else
{
tmpPoints += operPoints * 35;
}
points += tmpPoints;
}
else
{
points += 210; /* AR */
}
/*cout << "Step 6, points = " << points << endl;*/
/*LRTs*/
points -= prtCost[PRT];
i = k = 0;
foreach (DictionaryEntry de in AllTraits.Data.Secondary)
{
TraitEntry trait = de.Value as TraitEntry;
if (trait.Code == "CF" || trait.Code == "ExtraTech")
{
continue; // this is not a LRT!
}
else if (race.HasTrait(trait.Code))
{
if (lrtCost[trait.Code] >= 0)
{
i++;
}
else
{
k++;
}
points += lrtCost[trait.Code];
}
}
if ((k + i) > 4)
{
points -= (k + i) * (k + i - 4) * 10;
}
if ((i - k) > 3)
{
points -= (i - k - 3) * 60;
}
if ((k - i) > 3)
{
points -= (k - i - 3) * 40;
}
if (race.Traits.Contains("NAS")) // if (getbit(playerData->grbit, GRBIT_LRT_NAS) != 0)
{
if (PRT == PRT_PP)
{
points -= 280;
}
else if (PRT == PRT_SS)
{
points -= 200;
}
else if (PRT == PRT_JT)
{
points -= 40;
}
}
/*cout << "Step 7, points = " << points << endl;*/
/*science*/
tmpPoints = 0;
// for (j=STAT_ENERGY_COST; j<=STAT_BIO_COST; j++) tmpPoints += playerData->stats[j]-1;
int researchStat;
foreach (int tech in race.ResearchCosts)
{
if (tech == 175 || tech == 150 /*deprecated, for backward compability / old race files only*/)
{
researchStat = -1; // expensive / +75% research cost
}
else if (tech == 100)
{
researchStat = 0; // normal
}
else /*if (tech == 50)*/ researchStat {
