mirror of
https://gitgud.io/lutepickle/rjw_menstruation.git
synced 2024-08-14 22:46:52 +00:00
755 lines
30 KiB
C#
755 lines
30 KiB
C#
using RimWorld;
|
|
using rjw;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using UnityEngine;
|
|
using Verse;
|
|
|
|
namespace RJW_Menstruation
|
|
{
|
|
public class Hediff_MultiplePregnancy : Hediff_BasePregnancy
|
|
{
|
|
public override void DiscoverPregnancy()
|
|
{
|
|
PregnancyThought();
|
|
base.DiscoverPregnancy();
|
|
}
|
|
|
|
protected void PregnancyThought()
|
|
{
|
|
if (!is_discovered && xxx.is_human(pawn))
|
|
{
|
|
if (!pawn.Has(Quirk.Breeder) && pawn.relations?.DirectRelations?.Find(x => x.def.Equals(PawnRelationDefOf.Spouse) || x.def.Equals(PawnRelationDefOf.Fiance)) == null)
|
|
{
|
|
if (pawn.Has(Quirk.ImpregnationFetish) || pawn.relations?.DirectRelations?.Find(x => x.def.Equals(PawnRelationDefOf.Lover)) != null)
|
|
{
|
|
pawn.needs.mood.thoughts.memories.TryGainMemory(VariousDefOf.UnwantedPregnancyMild);
|
|
}
|
|
else
|
|
{
|
|
pawn.needs.mood.thoughts.memories.TryGainMemory(VariousDefOf.UnwantedPregnancy);
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
public override void GiveBirth()
|
|
{
|
|
|
|
if (babies.NullOrEmpty())
|
|
{
|
|
ModLog.Warning(" no babies (debug?) " + this.GetType().Name);
|
|
if (father == null)
|
|
{
|
|
father = Trytogetfather(ref pawn);
|
|
}
|
|
Initialize(pawn, father);
|
|
}
|
|
|
|
List<Pawn> siblings = new List<Pawn>();
|
|
foreach (Pawn baby in babies)
|
|
{
|
|
if (xxx.is_animal(baby))
|
|
{
|
|
BestialBirth(baby, siblings);
|
|
}
|
|
else
|
|
{
|
|
HumanlikeBirth(baby, siblings);
|
|
}
|
|
|
|
baby.ageTracker.AgeChronologicalTicks = 0;
|
|
}
|
|
|
|
pawn.health.RemoveHediff(this);
|
|
}
|
|
|
|
public string GetBabyInfo()
|
|
{
|
|
string res = "";
|
|
if (!babies.NullOrEmpty())
|
|
{
|
|
var babiesdistinct = babies.Distinct(new RaceComparer());
|
|
int iteration = 0;
|
|
foreach (Pawn baby in babiesdistinct)
|
|
{
|
|
int num = babies.Where(x => x.def.Equals(baby.def)).Count();
|
|
if (iteration > 0) res += ", ";
|
|
res += num + " " + baby.def.label;
|
|
iteration++;
|
|
}
|
|
res += " " + Translations.Dialog_WombInfo02;
|
|
return res;
|
|
}
|
|
return "Null";
|
|
}
|
|
|
|
public string GetFatherInfo()
|
|
{
|
|
if (babies.NullOrEmpty())
|
|
return "Null";
|
|
|
|
string res = Translations.Dialog_WombInfo03 + ": ";
|
|
|
|
if (!is_parent_known && Configurations.InfoDetail != Configurations.DetailLevel.All)
|
|
return res + Translations.Dialog_FatherUnknown;
|
|
|
|
var babiesdistinct = babies.Distinct(new FatherComparer(pawn));
|
|
int iteration = 0;
|
|
foreach (Pawn baby in babiesdistinct)
|
|
{
|
|
if (iteration > 0) res += ", ";
|
|
res += Utility.GetFather(baby, pawn)?.LabelShort ?? Translations.Dialog_FatherUnknown;
|
|
iteration++;
|
|
}
|
|
return res;
|
|
}
|
|
|
|
private void HumanlikeBirth(Pawn baby, List<Pawn> siblings)
|
|
{
|
|
Pawn mother = pawn; Pawn father = Utility.GetFather(baby, pawn);
|
|
//backup melanin, LastName for when baby reset by other mod on spawn/backstorychange
|
|
//var skin_whiteness = baby.story.melanin;
|
|
//var last_name = baby.story.birthLastName;
|
|
|
|
PawnUtility.TrySpawnHatchedOrBornPawn(baby, mother);
|
|
|
|
var sex_need = mother.needs?.TryGetNeed<Need_Sex>();
|
|
if (mother.Faction != null && !(mother.Faction?.IsPlayer ?? false) && sex_need != null)
|
|
{
|
|
sex_need.CurLevel = 1.0f;
|
|
}
|
|
if (mother.Faction != null)
|
|
{
|
|
if (mother.Faction != baby.Faction)
|
|
baby.SetFaction(mother.Faction);
|
|
}
|
|
if (mother.IsSlaveOfColony)
|
|
{
|
|
if (mother.SlaveFaction != null)
|
|
baby.SetFaction(mother.SlaveFaction);
|
|
else if (mother.HomeFaction != null)
|
|
baby.SetFaction(mother.HomeFaction);
|
|
else if (mother.Faction != null)
|
|
baby.SetFaction(mother.Faction);
|
|
else
|
|
baby.SetFaction(Faction.OfPlayer);
|
|
baby.guest.SetGuestStatus(Faction.OfPlayer, GuestStatus.Slave);
|
|
}
|
|
else if (mother.IsPrisonerOfColony)
|
|
{
|
|
if (mother.HomeFaction != null)
|
|
baby.SetFaction(mother.HomeFaction);
|
|
baby.guest.SetGuestStatus(Faction.OfPlayer, GuestStatus.Prisoner);
|
|
}
|
|
|
|
foreach (Pawn sibling in siblings)
|
|
{
|
|
baby.relations.AddDirectRelation(PawnRelationDefOf.Sibling, sibling);
|
|
}
|
|
siblings.Add(baby);
|
|
|
|
PostBirth(mother, father, baby);
|
|
}
|
|
|
|
|
|
private void BestialBirth(Pawn baby, List<Pawn> siblings)
|
|
{
|
|
Pawn mother = pawn; Pawn father = Utility.GetFather(baby, pawn);
|
|
//backup melanin, LastName for when baby reset by other mod on spawn/backstorychange
|
|
//var skin_whiteness = baby.story.melanin;
|
|
//var last_name = baby.story.birthLastName;
|
|
|
|
PawnUtility.TrySpawnHatchedOrBornPawn(baby, mother);
|
|
|
|
Need_Sex sex_need = mother.needs?.TryGetNeed<Need_Sex>();
|
|
if (mother.Faction != null && !(mother.Faction?.IsPlayer ?? false) && sex_need != null)
|
|
{
|
|
sex_need.CurLevel = 1.0f;
|
|
}
|
|
if (mother.Faction != null)
|
|
{
|
|
if (mother.Faction != baby.Faction)
|
|
baby.SetFaction(mother.Faction);
|
|
}
|
|
|
|
if (!RJWSettings.Disable_bestiality_pregnancy_relations)
|
|
{
|
|
foreach (Pawn sibling in siblings)
|
|
{
|
|
baby.relations.AddDirectRelation(PawnRelationDefOf.Sibling, sibling);
|
|
}
|
|
siblings.Add(baby);
|
|
}
|
|
Train(baby, mother);
|
|
|
|
PostBirth(mother, father, baby);
|
|
|
|
//restore melanin, LastName for when baby reset by other mod on spawn/backstorychange
|
|
//baby.story.melanin = skin_whiteness;
|
|
//baby.story.birthLastName = last_name;
|
|
}
|
|
|
|
// From RJW's trait code
|
|
protected List<Trait> GetInheritableTraits(Pawn mother, Pawn father)
|
|
{
|
|
List<Trait> traitpool = new List<Trait>();
|
|
List<Trait> momtraits = new List<Trait>();
|
|
List<Trait> poptraits = new List<Trait>();
|
|
List<Trait> traits_to_inherit = new List<Trait>();
|
|
System.Random rd = new System.Random();
|
|
float max_num_momtraits_inherited = RJWPregnancySettings.max_num_momtraits_inherited;
|
|
float max_num_poptraits_inherited = RJWPregnancySettings.max_num_poptraits_inherited;
|
|
float max_num_traits_inherited = max_num_momtraits_inherited + max_num_poptraits_inherited;
|
|
int i = 1;
|
|
int j = 1;
|
|
if (xxx.has_traits(mother) && mother.RaceProps.Humanlike)
|
|
{
|
|
foreach (Trait momtrait in mother.story.traits.allTraits)
|
|
{
|
|
if (!non_genetic_traits.Contains(momtrait.def.defName) && !momtrait.ScenForced)
|
|
momtraits.Add(momtrait);
|
|
}
|
|
}
|
|
if (father != null && xxx.has_traits(father) && father.RaceProps.Humanlike)
|
|
{
|
|
foreach (Trait poptrait in father.story.traits.allTraits)
|
|
{
|
|
if (!non_genetic_traits.Contains(poptrait.def.defName) && !poptrait.ScenForced)
|
|
poptraits.Add(poptrait);
|
|
}
|
|
}
|
|
int rand_trait_index;
|
|
if (!momtraits.NullOrEmpty())
|
|
{
|
|
i = 1;
|
|
while (momtraits.Count > 0 && i <= max_num_momtraits_inherited)
|
|
{
|
|
rand_trait_index = rd.Next(0, momtraits.Count);
|
|
traits_to_inherit.Add(momtraits[rand_trait_index]);
|
|
momtraits.RemoveAt(rand_trait_index);
|
|
}
|
|
}
|
|
if (!poptraits.NullOrEmpty())
|
|
{
|
|
j = 1;
|
|
while (poptraits.Count > 0 && j <= max_num_poptraits_inherited)
|
|
{
|
|
rand_trait_index = rd.Next(0, poptraits.Count);
|
|
traits_to_inherit.Add(poptraits[rand_trait_index]);
|
|
poptraits.RemoveAt(rand_trait_index);
|
|
}
|
|
}
|
|
|
|
if (poptraits.NullOrEmpty() || momtraits.NullOrEmpty())
|
|
{
|
|
foreach (Trait traits in traits_to_inherit)
|
|
{
|
|
traitpool.Add(traits);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (traits_to_inherit.Count() != max_num_traits_inherited)
|
|
{
|
|
if (momtraits.Count != 0 && i != max_num_momtraits_inherited)
|
|
{
|
|
while (poptraits != null && momtraits.Count() > 0 && i <= max_num_momtraits_inherited)
|
|
{
|
|
rand_trait_index = rd.Next(0, momtraits.Count);
|
|
if (!traits_to_inherit.Contains(momtraits[rand_trait_index]))
|
|
{
|
|
traits_to_inherit.Add(momtraits[rand_trait_index]);
|
|
}
|
|
momtraits.RemoveAt(rand_trait_index);
|
|
}
|
|
}
|
|
if (poptraits != null && poptraits.Count != 0 && j != max_num_poptraits_inherited)
|
|
{
|
|
while (poptraits.Count > 0 && i < max_num_poptraits_inherited)
|
|
{
|
|
rand_trait_index = rd.Next(0, poptraits.Count);
|
|
if (!traits_to_inherit.Contains(poptraits[rand_trait_index]))
|
|
{
|
|
traits_to_inherit.Add(poptraits[rand_trait_index]);
|
|
}
|
|
poptraits.RemoveAt(rand_trait_index);
|
|
}
|
|
}
|
|
}
|
|
foreach (Trait traits in traits_to_inherit)
|
|
{
|
|
traitpool.Add(traits);
|
|
}
|
|
}
|
|
return traitpool;
|
|
}
|
|
|
|
protected override void GenerateBabies()
|
|
{
|
|
AddNewBaby(pawn, father);
|
|
}
|
|
|
|
|
|
|
|
protected void Train(Pawn baby, Pawn mother)
|
|
{
|
|
if (!xxx.is_human(baby) && baby.Faction == Faction.OfPlayer)
|
|
{
|
|
if (xxx.is_human(mother) && baby.Faction == Faction.OfPlayer && baby.training.CanAssignToTrain(TrainableDefOf.Obedience, out _).Accepted)
|
|
{
|
|
baby.training.Train(TrainableDefOf.Obedience, mother);
|
|
}
|
|
if (xxx.is_human(mother) && baby.Faction == Faction.OfPlayer && baby.training.CanAssignToTrain(TrainableDefOf.Tameness, out _).Accepted)
|
|
{
|
|
baby.training.Train(TrainableDefOf.Tameness, mother);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
public bool AddNewBaby(Pawn mother, Pawn father)
|
|
{
|
|
float melanin;
|
|
string lastname;
|
|
if (xxx.is_human(mother))
|
|
{
|
|
if (xxx.is_human(father))
|
|
{
|
|
melanin = ChildRelationUtility.GetRandomChildSkinColor(father.story?.melanin ?? 0f, mother.story?.melanin ?? 0f);
|
|
//melanin = (mother.story?.melanin ?? 0f + father.story?.melanin ?? 0f) / 2;
|
|
}
|
|
else
|
|
{
|
|
melanin = mother.story?.melanin ?? 0f;
|
|
}
|
|
lastname = NameTriple.FromString(mother.Name.ToStringFull).Last;
|
|
}
|
|
else if (xxx.is_human(father))
|
|
{
|
|
melanin = father.story?.melanin ?? 0f;
|
|
lastname = NameTriple.FromString(father.Name.ToStringFull).Last;
|
|
}
|
|
else
|
|
{
|
|
melanin = Rand.Range(0, 1.0f);
|
|
lastname = "";
|
|
}
|
|
|
|
PawnGenerationRequest request = new PawnGenerationRequest(
|
|
newborn: true,
|
|
allowDowned: true,
|
|
faction: mother.Faction,
|
|
canGeneratePawnRelations: false,
|
|
forceGenerateNewPawn: true,
|
|
colonistRelationChanceFactor: 0,
|
|
allowFood: false,
|
|
allowAddictions: false,
|
|
relationWithExtraPawnChanceFactor: 0,
|
|
fixedMelanin: melanin,
|
|
fixedLastName: lastname,
|
|
kind: BabyPawnKindDecider(mother, father),
|
|
//fixedIdeo: mother.Ideo,
|
|
//forbidAnyTitle: true,
|
|
forceNoBackstory:true
|
|
);
|
|
|
|
int division = 1;
|
|
HairDef firsthair = null;
|
|
Color firsthaircolor = Color.white;
|
|
BodyTypeDef firstbody = null;
|
|
CrownType firstcrown = CrownType.Undefined;
|
|
string firstheadpath = null;
|
|
string firstHARcrown = null;
|
|
int traitSeed = Rand.Int;
|
|
List <Trait> parentTraits = GetInheritableTraits(mother, father);
|
|
while (Rand.Chance(Configurations.EnzygoticTwinsChance) && division < Configurations.MaxEnzygoticTwins) division++;
|
|
for (int i = 0; i < division; i++)
|
|
{
|
|
Pawn baby = GenerateBaby(request, mother, father, parentTraits, traitSeed);
|
|
if (division > 1)
|
|
{
|
|
if (i == 0 && baby.story != null)
|
|
{
|
|
firsthair = baby.story.hairDef;
|
|
firsthaircolor = baby.story.hairColor;
|
|
request.FixedGender = baby.gender;
|
|
firstbody = baby.story.bodyType;
|
|
firstcrown = baby.story.crownType;
|
|
firstheadpath = (string)baby.story.GetMemberValue("headGraphicPath");
|
|
if (firstheadpath == null)
|
|
{
|
|
Graphic_Multi head = GraphicDatabaseHeadRecords.GetHeadRandom(baby.gender, baby.story.SkinColor, baby.story.crownType, true);
|
|
if (head != null) baby.story.SetMemberValue("headGraphicPath", head.GraphicPath);
|
|
firstheadpath = (string)baby.story.GetMemberValue("headGraphicPath");
|
|
}
|
|
if (Configurations.HARActivated && baby.IsHAR())
|
|
{
|
|
firstHARcrown = baby.GetHARCrown();
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
if (baby.story != null)
|
|
{
|
|
baby.story.hairDef = firsthair;
|
|
baby.story.hairColor = firsthaircolor;
|
|
baby.story.bodyType = firstbody;
|
|
baby.story.crownType = firstcrown;
|
|
baby.story.SetMemberValue("headGraphicPath", firstheadpath);
|
|
|
|
if (Configurations.HARActivated && baby.IsHAR())
|
|
{
|
|
baby.SetHARCrown(firstHARcrown);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (baby != null) babies.Add(baby);
|
|
}
|
|
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
public Pawn GenerateBaby(PawnGenerationRequest request, Pawn mother, Pawn father, List<Trait> parentTraits, int traitSeed)
|
|
{
|
|
Pawn baby = PawnGenerator.GeneratePawn(request);
|
|
if (baby != null)
|
|
{
|
|
if (xxx.is_human(baby))
|
|
{
|
|
baby.SetMother(mother);
|
|
if (mother != father)
|
|
{
|
|
if (father.gender != Gender.Female) baby.SetFather(father);
|
|
else
|
|
{
|
|
baby.relations.AddDirectRelation(PawnRelationDefOf.Parent, father);
|
|
}
|
|
}
|
|
|
|
// Ensure the same inherited traits are chosen each run
|
|
// Has to happen right here so GeneratePawn up there still gets unique results
|
|
Rand.PushState(traitSeed); // With a seed just to make sure that fraternal twins *don't* get trait-duped
|
|
UpdateTraits(baby, parentTraits);
|
|
Rand.PopState();
|
|
}
|
|
else if (baby.relations != null && !RJWSettings.Disable_bestiality_pregnancy_relations)
|
|
{
|
|
baby.relations.AddDirectRelation(VariousDefOf.Relation_birthgiver, mother);
|
|
mother.relations.AddDirectRelation(VariousDefOf.Relation_spawn, baby);
|
|
if (mother != father)
|
|
{
|
|
baby.relations.AddDirectRelation(VariousDefOf.Relation_birthgiver, father);
|
|
father.relations.AddDirectRelation(VariousDefOf.Relation_spawn, baby);
|
|
}
|
|
}
|
|
}
|
|
else Log.Error("Baby not generated. Request: " + request.ToString());
|
|
return baby;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Decide pawnkind from mother and father <para/>
|
|
/// Come from RJW
|
|
/// </summary>
|
|
/// <param name="mother"></param>
|
|
/// <param name="father"></param>
|
|
/// <returns></returns>
|
|
public PawnKindDef BabyPawnKindDecider(Pawn mother, Pawn father)
|
|
{
|
|
PawnKindDef spawn_kind_def = mother.kindDef;
|
|
|
|
int flag = 0;
|
|
if (xxx.is_human(mother)) flag += 2;
|
|
if (xxx.is_human(father)) flag += 1;
|
|
//Mother - Father = Flag
|
|
//Human - Human = 3
|
|
//Human - Animal = 2
|
|
//Animal - Human = 1
|
|
//Animal - Animal = 0
|
|
|
|
switch (flag)
|
|
{
|
|
case 3:
|
|
if (!Rand.Chance(RJWPregnancySettings.humanlike_DNA_from_mother)) spawn_kind_def = father.kindDef;
|
|
break;
|
|
case 2:
|
|
if (RJWPregnancySettings.bestiality_DNA_inheritance == 0f) spawn_kind_def = father.kindDef;
|
|
else if (!Rand.Chance(RJWPregnancySettings.bestial_DNA_from_mother)) spawn_kind_def = father.kindDef;
|
|
break;
|
|
case 1:
|
|
if (RJWPregnancySettings.bestiality_DNA_inheritance == 1f) spawn_kind_def = father.kindDef;
|
|
else if (!Rand.Chance(RJWPregnancySettings.bestial_DNA_from_mother)) spawn_kind_def = father.kindDef;
|
|
break;
|
|
case 0:
|
|
if (!Rand.Chance(RJWPregnancySettings.bestial_DNA_from_mother)) spawn_kind_def = father.kindDef;
|
|
break;
|
|
}
|
|
|
|
bool IsAndroidmother = AndroidsCompatibility.IsAndroid(mother);
|
|
bool IsAndroidfather = AndroidsCompatibility.IsAndroid(father);
|
|
if (IsAndroidmother && !IsAndroidfather)
|
|
{
|
|
spawn_kind_def = father.kindDef;
|
|
}
|
|
else if (!IsAndroidmother && IsAndroidfather)
|
|
{
|
|
spawn_kind_def = mother.kindDef;
|
|
}
|
|
|
|
string MotherRaceName = "";
|
|
string FatherRaceName = "";
|
|
MotherRaceName = mother.kindDef?.race?.defName;
|
|
PawnKindDef non_hybrid_kind_def = spawn_kind_def;
|
|
if (father != null)
|
|
FatherRaceName = father.kindDef?.race?.defName;
|
|
|
|
|
|
if (FatherRaceName != "" && Configurations.UseHybridExtention)
|
|
{
|
|
spawn_kind_def = GetHybrid(father, mother);
|
|
//Log.Message("pawnkind: " + spawn_kind_def?.defName);
|
|
}
|
|
|
|
if (MotherRaceName != FatherRaceName && FatherRaceName != "")
|
|
{
|
|
if (!Configurations.UseHybridExtention || spawn_kind_def == null)
|
|
{
|
|
spawn_kind_def = non_hybrid_kind_def;
|
|
var groups = DefDatabase<RaceGroupDef>.AllDefs.Where(x => !(x.hybridRaceParents.NullOrEmpty() || x.hybridChildKindDef.NullOrEmpty()));
|
|
|
|
|
|
//ModLog.Message(" found custom RaceGroupDefs " + groups.Count());
|
|
foreach (var t in groups)
|
|
{
|
|
if ((t.hybridRaceParents.Contains(MotherRaceName) && t.hybridRaceParents.Contains(FatherRaceName))
|
|
|| (t.hybridRaceParents.Contains("Any") && (t.hybridRaceParents.Contains(MotherRaceName) || t.hybridRaceParents.Contains(FatherRaceName))))
|
|
{
|
|
//ModLog.Message(" has hybridRaceParents");
|
|
if (t.hybridChildKindDef.Contains("MotherKindDef"))
|
|
spawn_kind_def = mother.kindDef;
|
|
else if (t.hybridChildKindDef.Contains("FatherKindDef") && father != null)
|
|
spawn_kind_def = father.kindDef;
|
|
else
|
|
{
|
|
//ModLog.Message(" trying hybridChildKindDef " + t.defName);
|
|
var child_kind_def_list = new List<PawnKindDef>();
|
|
child_kind_def_list.AddRange(DefDatabase<PawnKindDef>.AllDefs.Where(x => t.hybridChildKindDef.Contains(x.defName)));
|
|
|
|
//ModLog.Message(" found custom hybridChildKindDefs " + t.hybridChildKindDef.Count);
|
|
if (!child_kind_def_list.NullOrEmpty())
|
|
spawn_kind_def = child_kind_def_list.RandomElement();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
else if (!Configurations.UseHybridExtention || spawn_kind_def == null)
|
|
{
|
|
spawn_kind_def = mother.RaceProps?.AnyPawnKind ?? mother.kindDef;
|
|
}
|
|
|
|
if (spawn_kind_def.defName.Contains("Nymph"))
|
|
{
|
|
//child is nymph, try to find other PawnKindDef
|
|
var spawn_kind_def_list = new List<PawnKindDef>();
|
|
spawn_kind_def_list.AddRange(DefDatabase<PawnKindDef>.AllDefs.Where(x => x.race == spawn_kind_def.race && !x.defName.Contains("Nymph")));
|
|
//no other PawnKindDef found try mother
|
|
if (spawn_kind_def_list.NullOrEmpty())
|
|
spawn_kind_def_list.AddRange(DefDatabase<PawnKindDef>.AllDefs.Where(x => x.race == mother.kindDef.race && !x.defName.Contains("Nymph")));
|
|
//no other PawnKindDef found try father
|
|
if (spawn_kind_def_list.NullOrEmpty() && father != null)
|
|
spawn_kind_def_list.AddRange(DefDatabase<PawnKindDef>.AllDefs.Where(x => x.race == father.kindDef.race && !x.defName.Contains("Nymph")));
|
|
//no other PawnKindDef found fallback to generic colonist
|
|
if (spawn_kind_def_list.NullOrEmpty())
|
|
spawn_kind_def = PawnKindDefOf.Colonist;
|
|
|
|
if (!spawn_kind_def_list.NullOrEmpty()) spawn_kind_def = spawn_kind_def_list.RandomElement();
|
|
}
|
|
|
|
|
|
|
|
|
|
return spawn_kind_def;
|
|
|
|
}
|
|
|
|
public PawnKindDef GetHybrid(Pawn first, Pawn second)
|
|
{
|
|
PawnKindDef res = null;
|
|
Pawn opposite = second;
|
|
HybridInformations info = null;
|
|
|
|
|
|
if (!Configurations.HybridOverride.NullOrEmpty())
|
|
{
|
|
info = Configurations.HybridOverride.FirstOrDefault(x => x.DefName == first.def?.defName && (x.hybridExtension?.Exists(y => y.DefName == second.def?.defName) ?? false));
|
|
if (info == null)
|
|
{
|
|
info = Configurations.HybridOverride.FirstOrDefault(x => x.DefName == second.def?.defName && (x.hybridExtension?.Exists(y => y.DefName == first.def?.defName) ?? false));
|
|
opposite = first;
|
|
}
|
|
}
|
|
|
|
if (info != null)
|
|
{
|
|
res = info.GetHybridWith(opposite.def.defName) ?? null;
|
|
}
|
|
if (res != null) return res;
|
|
|
|
|
|
PawnDNAModExtension dna;
|
|
dna = first.def.GetModExtension<PawnDNAModExtension>();
|
|
if (dna != null)
|
|
{
|
|
res = dna.GetHybridWith(second.def.defName) ?? null;
|
|
}
|
|
else
|
|
{
|
|
dna = second.def.GetModExtension<PawnDNAModExtension>();
|
|
if (dna != null)
|
|
{
|
|
res = dna.GetHybridWith(first.def.defName) ?? null;
|
|
}
|
|
}
|
|
return res;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Copy from RJW
|
|
/// </summary>
|
|
/// <param name="pawn"></param>
|
|
/// <param name="parentTraits"></param>
|
|
///
|
|
public void UpdateTraits(Pawn pawn, List<Trait> parentTraits)
|
|
{
|
|
if (pawn?.story?.traits == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
int traitLimit = pawn.story.traits.allTraits.Count;
|
|
|
|
//Personal pool
|
|
List<Trait> personalTraitPool = new List<Trait>(pawn.story.traits.allTraits);
|
|
//Parents
|
|
List<Trait> parentTraitPool = new List<Trait>(parentTraits);
|
|
parentTraitPool.RemoveAll(x => x.ScenForced);
|
|
int numberInherited;
|
|
if (parentTraitPool != null)
|
|
numberInherited = System.Math.Min(parentTraitPool.Count(), Rand.RangeInclusive(0,2)); // Not 3; give a better chance for a natural trait to appear
|
|
else
|
|
numberInherited = 0;
|
|
|
|
//Game suggested traits.
|
|
var forcedTraits = personalTraitPool
|
|
.Where(x => x.ScenForced)
|
|
.Distinct(new TraitComparer(ignoreDegree: true)); // result can be a mess, because game allows this mess to be created in scenario editor
|
|
|
|
List<Trait> selectedTraits = new List<Trait>();
|
|
var comparer = new TraitComparer(); // trait comparision implementation, because without game compares traits *by reference*, makeing them all unique.
|
|
selectedTraits.AddRange(forcedTraits); // enforcing scenario forced traits
|
|
for (int i = 0; i < numberInherited; i++) // add parent traits first
|
|
{
|
|
int index = Rand.Range(0, parentTraitPool.Count);
|
|
Trait trait = parentTraitPool[index];
|
|
parentTraitPool.RemoveAt(index);
|
|
if (!selectedTraits.Any(x => comparer.Equals(x, trait) ||
|
|
x.def.ConflictsWith(trait)))
|
|
selectedTraits.Add(new Trait(trait.def, trait.Degree, false));
|
|
}
|
|
|
|
while (selectedTraits.Count < traitLimit && personalTraitPool.Count > 0)
|
|
{
|
|
int index = Rand.Range(0, personalTraitPool.Count); // getting trait and removing from the pull
|
|
var trait = personalTraitPool[index];
|
|
personalTraitPool.RemoveAt(index);
|
|
|
|
if (!selectedTraits.Any(x => comparer.Equals(x, trait) || // skipping traits conflicting with already added
|
|
x.def.ConflictsWith(trait)))
|
|
selectedTraits.Add(new Trait(trait.def, trait.Degree, false));
|
|
|
|
}
|
|
|
|
pawn.story.traits.allTraits = selectedTraits;
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Copy from RJW
|
|
/// </summary>
|
|
public class TraitComparer : IEqualityComparer<Trait>
|
|
{
|
|
readonly bool ignoreForced;
|
|
readonly bool ignoreDegree;
|
|
|
|
public TraitComparer(bool ignoreDegree = false, bool ignoreForced = true)
|
|
{
|
|
this.ignoreDegree = ignoreDegree;
|
|
this.ignoreForced = ignoreForced;
|
|
}
|
|
|
|
public bool Equals(Trait x, Trait y)
|
|
{
|
|
return
|
|
x.def == y.def &&
|
|
(ignoreDegree || (x.Degree == y.Degree)) &&
|
|
(ignoreForced || (x.ScenForced == y.ScenForced));
|
|
}
|
|
|
|
public int GetHashCode(Trait obj)
|
|
{
|
|
return
|
|
(obj.def.GetHashCode() << 5) +
|
|
(ignoreDegree ? 0 : obj.Degree) +
|
|
((ignoreForced || obj.ScenForced) ? 0 : 0x10);
|
|
}
|
|
}
|
|
|
|
public class RaceComparer : IEqualityComparer<Pawn>
|
|
{
|
|
public bool Equals(Pawn x, Pawn y)
|
|
{
|
|
return x.def.Equals(y.def);
|
|
}
|
|
|
|
public int GetHashCode(Pawn obj)
|
|
{
|
|
return obj.def.GetHashCode();
|
|
}
|
|
}
|
|
|
|
public class FatherComparer : IEqualityComparer<Pawn>
|
|
{
|
|
readonly Pawn mother;
|
|
|
|
public FatherComparer(Pawn mother)
|
|
{
|
|
this.mother = mother;
|
|
}
|
|
|
|
public bool Equals(Pawn x, Pawn y)
|
|
{
|
|
if (Utility.GetFather(x, mother) == null && Utility.GetFather(y, mother) == null) return true;
|
|
return Utility.GetFather(x, mother)?.Label.Equals(Utility.GetFather(y, mother)?.Label) ?? false;
|
|
}
|
|
|
|
public int GetHashCode(Pawn obj)
|
|
{
|
|
return obj.def.GetHashCode();
|
|
}
|
|
}
|
|
|
|
}
|