protected override bool TryExecuteWorker(IncidentParms parms)
{
Map map = Find.AnyPlayerHomeMap;
if (!TileFinder.TryFindPassableTileWithTraversalDistance(map.Tile, 5, 7, out int newTile))
{
return(false);
}
SkillDef compSkill = DefDatabase <SkillDef> .GetRandom();
int level = Rand.Range(8, 20);
WorldObject_Competitions place = (WorldObject_Competitions)WorldObjectMaker.MakeWorldObject(WorldObjectsDefOfLocal.CompetitionsPlace);
place.Tile = newTile;
place.SetFaction(Faction.OfPlayer);
place.CompetitionSkill = compSkill;
place.CompetitionSkillLevelRequired = level;
place.RewardCount = level * 140;
place.TicksToEnd = 5 * 60000;
Find.WorldObjects.Add(place);
string label = def.label;
string description = string.Format(def.letterText, compSkill.LabelCap, place.RewardCount, level);
Find.LetterStack.ReceiveLetter(label, description, def.letterDef, new LookTargets(place));
var dialog = QuestsManager.Communications.MakeDialogFromIncident(def, new List <CommOption>
{
new CommOption_CompetitionsPaid()
{
WorldObject_Competitions = place
}
});
dialog.Description = description;
QuestsManager.Communications.AddCommunication(dialog);
place.Dialog = dialog;
return(true);
}
public override bool PreReceived(EmailMessage message, EmailBox box)
{
base.PreReceived(message, box);
var settlementBase = RandomNearbyTradeableSettlement(Find.AnyPlayerHomeMap.Tile, message.Faction);
if (settlementBase != null)
{
WeatherDef weather = DefDatabase <WeatherDef> .GetRandom();
message.Message = string.Format(message.Message, box.Owner.Name, settlementBase.Name, weather.LabelCap.ToLower());
return(true);
}
else
{
return(false);
}
}
public override void MapComponentTick()
{
if ((Find.TickManager.TicksGame + map.Parent.ID) % EventTimeCycle == 0)
{
if (!Config_Cities.Instance.enableEvents)
{
return;
}
if (map.Parent is City city)
{
if (!city.Abandoned)
{
if (city.Faction.HostileTo(Faction.OfPlayer))
{
var storyComp = Find.Storyteller.storytellerComps
.First(x => x is StorytellerComp_OnOffCycle || x is StorytellerComp_RandomMain);
var parms = storyComp.GenerateParms(IncidentCategoryDefOf.ThreatBig, map);
parms.faction = city.Faction;
parms.raidStrategy = RaidStrategyDefOf.ImmediateAttack;
parms.raidArrivalMode = DefDatabase <PawnsArrivalModeDef> .GetRandom();
parms.raidArrivalModeForQuickMilitaryAid = true;
parms.points += city.RaidPointIncrease;
IncidentDefOf.RaidEnemy.Worker.TryExecute(parms);
}
foreach (var pawn in map.mapPawns.SpawnedPawnsInFaction(map.ParentFaction))
{
if (!pawn.inventory.innerContainer.Any(thing => pawn.WillEat(thing)))
{
for (var i = 0; i < 2; i++)
{
var meal = ThingMaker.MakeThing(ThingDefOf.MealSurvivalPack);
pawn.inventory.innerContainer.TryAdd(meal);
}
}
}
}
}
}
}
public static Pawn PawnGenerateRandom()
{
Faction faction;
/* к сожалению бессмысленно, т.к. в FactionGenerator.NewGeneratedFaction используется Find.World
* if (Find.World == null || Find.World.factionManager == null)
* {
* var facDef = DefDatabase<FactionDef>.GetNamed("PlayerColony");
* faction = FactionGenerator.NewGeneratedFaction(facDef);
* }
* else
*/
faction = Faction.OfPlayer;
PawnKindDef random = DefDatabase <PawnKindDef> .GetRandom();
//Faction faction = Faction.OfPlayer;//FactionUtility.DefaultFactionFrom(FactionDef.Named("PlayerColony")); // FactionUtility.DefaultFactionFrom(random.defaultFactionType);
Pawn pawn = PawnGenerator.GeneratePawn(random, faction);
return(pawn);
}
public override void CompTick()
{
if (!active)
{
return;
}
if (ShouldRemoveWorldObjectNow)
{
var threatparms = Find.Storyteller.storytellerComps.First(x => x is StorytellerComp_OnOffCycle || x is StorytellerComp_RandomMain).GenerateParms(IncidentCategoryDefOf.ThreatBig, Find.AnyPlayerHomeMap);
threatparms.faction = parent.Faction;
threatparms.raidStrategy = DefDatabase <RaidStrategyDef> .GetRandom();
threatparms.raidArrivalMode = DefDatabase <PawnsArrivalModeDef> .AllDefs.First(def => def.defName.Contains("EdgeDropGroups"));
threatparms.points = Mathf.Clamp(StorytellerUtility.DefaultThreatPointsNow(Find.AnyPlayerHomeMap) * 4, 300, 15000);
threatparms.raidNeverFleeIndividual = true;
IncidentDefOf.RaidEnemy.Worker.TryExecute(threatparms);
active = false;
Find.WorldObjects.Remove(parent);
}
}
public override void MapComponentTick()
{
if ((Find.TickManager.TicksGame + map.Parent.ID) % EventTimeCycle == 0)
{
if (!LoadedModManager.GetMod <Mod_Cities>().GetSettings <ModSettings_Cities>().enableEvents)
{
return;
}
if (map.Parent is City city && !city.Abandoned)
{
if (city.Faction.HostileTo(Faction.OfPlayer))
{
var storyComp = Find.Storyteller.storytellerComps.First(x => x is StorytellerComp_OnOffCycle || x is StorytellerComp_RandomMain);
var parms = storyComp.GenerateParms(IncidentCategoryDefOf.ThreatBig, map);
parms.faction = city.Faction;
parms.raidStrategy = RaidStrategyDefOf.ImmediateAttack;
parms.raidArrivalMode = DefDatabase <PawnsArrivalModeDef> .GetRandom();
parms.raidArrivalModeForQuickMilitaryAid = true;
parms.points += RaidPointIncrease;
IncidentDefOf.RaidEnemy.Worker.TryExecute(parms);
}
else
{
var pos = QuestUtility.FindDropSpot(map);
var things = new List <Thing>();
var foodCount = (int)(map.mapPawns.SpawnedPawnsInFaction(map.ParentFaction).Count *EventTimeCycle / 60000F * DailyFoodGivenPerPerson);
for (var i = 0; i < foodCount; i++)
{
var thing = ThingMaker.MakeThing(ThingDefOf.MealSurvivalPack);
map.GetComponent <MapComponent_City>().cityOwnedThings.Add(thing);
things.Add(thing);
}
DropPodUtility.DropThingsNear(pos, map, things, canRoofPunch: false);
}
}
}
}
public static void SetPawnTraits(Pawn pawn, int num)
{
pawn.story.traits.allTraits.Clear();
while (pawn.story.traits.allTraits.Count < num)
{
TraitDef newTraitDef = DefDatabase <TraitDef> .GetRandom();
if (!pawn.story.traits.HasTrait(newTraitDef))
{
if (newTraitDef.conflictingTraits == null || !Contains(pawn, newTraitDef.conflictingTraits))
{
Trait trait = new Trait(newTraitDef);
trait.degree = PawnGenerator.RandomTraitDegree(trait.def);
if (pawn.mindState.breaker.HardBreakThreshold + trait.OffsetOfStat(StatDefOf.MentalBreakThreshold) <= 40f)
{
pawn.story.traits.GainTrait(trait);
}
}
}
}
}
public void PlaySong()
{
currentState = true;
if (JukeBoxCore.orignalSongList.Count <= 0)
{
JukeBoxCore.orignalSongList.AddRange(DefDatabase <SongDef> .AllDefs);
}
if (JukeBoxCore.customSongList.Count <= 0)
{
JukeBoxCore.Scanning();
if (JukeBoxCore.customSongList.Count <= 0)
{
Log.Error("Songs Folder is Empty");
return;
}
}
DefDatabase <SongDef> .Clear();
DefDatabase <SongDef> .Add(JukeBoxCore.customSongList);
Find.MusicManagerPlay.ForceStartSong(DefDatabase <SongDef> .GetRandom(), false);
}
private SongDef ChooseNextSong()
{
this.songWasForced = false;
SongDef result;
if (this.forcedNextSong != null)
{
SongDef songDef = this.forcedNextSong;
this.forcedNextSong = null;
this.songWasForced = true;
result = songDef;
}
else
{
IEnumerable <SongDef> source = from song in DefDatabase <SongDef> .AllDefs
where this.AppropriateNow(song)
select song;
while (this.recentSongs.Count > 7)
{
this.recentSongs.Dequeue();
}
while (!source.Any <SongDef>() && this.recentSongs.Count > 0)
{
this.recentSongs.Dequeue();
}
if (!source.Any <SongDef>())
{
Log.Error("Could not get any appropriate song. Getting random and logging song selection data.", false);
this.SongSelectionData();
result = DefDatabase <SongDef> .GetRandom();
}
else
{
result = source.RandomElementByWeight((SongDef s) => s.commonality);
}
}
return(result);
}
public static Faction NewGeneratedFaction()
{
return(FactionGenerator.NewGeneratedFaction(DefDatabase <FactionDef> .GetRandom()));
}
private void CreateNew()
{
if (featureName == null)
{
Messages.Message($"Enter correct feature name", MessageTypeDefOf.NeutralEvent, false);
return;
}
if (maxLength <= 0)
{
Messages.Message($"Enter correct size", MessageTypeDefOf.NeutralEvent, false);
return;
}
if (edit)
{
editFeature.name = featureName;
editFeature.drawAngle = rotate;
editFeature.maxDrawSizeInTiles = maxLength;
Find.WorldFeatures.textsCreated = false;
Find.WorldFeatures.UpdateFeatures();
Messages.Message($"Success", MessageTypeDefOf.NeutralEvent, false);
return;
}
int tile = Find.WorldSelector.selectedTile;
if (tile < 0)
{
Messages.Message($"Select tile", MessageTypeDefOf.NeutralEvent, false);
return;
}
List <int> members = new List <int>();
members.Add(tile);
WorldFeature worldFeature = new WorldFeature
{
uniqueID = Find.UniqueIDsManager.GetNextWorldFeatureID(),
def = DefDatabase <FeatureDef> .GetRandom(),
name = featureName
};
WorldGrid worldGrid = Find.WorldGrid;
for (int i = 0; i < members.Count; i++)
{
worldGrid[members[i]].feature = worldFeature;
}
worldFeature.drawCenter = worldGrid.GetTileCenter(tile);
worldFeature.maxDrawSizeInTiles = maxLength;
worldFeature.drawAngle = rotate;
Find.WorldFeatures.features.Add(worldFeature);
Find.WorldFeatures.textsCreated = false;
Find.WorldFeatures.UpdateFeatures();
Messages.Message($"Feature created", MessageTypeDefOf.NeutralEvent, false);
}
//Patch for Caravan/Worldmap death
//TBF
//Patch death messages
//TBF
//Change Appearance, Traits and memories of pawns
static void Regenerate(Pawn __instance)
{
// Health State Changes ----------------------------------------------------------------------------------------------------------
//Resurrect the __instance
ResurrectionUtility.Resurrect(__instance);
//Remove all bad hediffs
foreach (Hediff h in __instance.health.hediffSet.GetHediffs <Hediff>())
{
if (h.def.isBad)
{
__instance.health.RemoveHediff(h);
}
}
//Add resurrection sickness
__instance.health.AddHediff(HediffDef.Named("ResurrectionSickness"));
//Remove current RegenHediff and add the next
BodyPartRecord heart = __instance.health.hediffSet.GetNotMissingParts().First(bpr => bpr.def == BodyPartDefOf.Heart);
HediffDef Regen1Def = HediffDef.Named("Regeneration01");
HediffDef Regen2Def = HediffDef.Named("Regeneration02");
HediffDef Regen3Def = HediffDef.Named("Regeneration03");
HediffDef Regen4Def = HediffDef.Named("Regeneration04");
HediffDef Regen5Def = HediffDef.Named("Regeneration05");
HediffDef Regen6Def = HediffDef.Named("Regeneration06");
HediffDef Regen7Def = HediffDef.Named("Regeneration07");
HediffDef Regen8Def = HediffDef.Named("Regeneration08");
HediffDef Regen9Def = HediffDef.Named("Regeneration09");
HediffDef Regen10Def = HediffDef.Named("Regeneration10");
HediffDef Regen11Def = HediffDef.Named("Regeneration11");
HediffDef Regen12Def = HediffDef.Named("Regeneration12");
HediffDef Regen13Def = HediffDef.Named("Regeneration13");
if (__instance.health.hediffSet.HasHediff(Regen1Def))
{
__instance.health.RemoveHediff(__instance.health.hediffSet.GetFirstHediffOfDef(Regen1Def)); __instance.health.AddHediff(Regen2Def, heart);
}
else if (__instance.health.hediffSet.HasHediff(Regen2Def))
{
__instance.health.RemoveHediff(__instance.health.hediffSet.GetFirstHediffOfDef(Regen2Def)); __instance.health.AddHediff(Regen3Def, heart);
}
else if (__instance.health.hediffSet.HasHediff(Regen3Def))
{
__instance.health.RemoveHediff(__instance.health.hediffSet.GetFirstHediffOfDef(Regen3Def)); __instance.health.AddHediff(Regen4Def, heart);
}
else if (__instance.health.hediffSet.HasHediff(Regen4Def))
{
__instance.health.RemoveHediff(__instance.health.hediffSet.GetFirstHediffOfDef(Regen4Def)); __instance.health.AddHediff(Regen5Def, heart);
}
else if (__instance.health.hediffSet.HasHediff(Regen5Def))
{
__instance.health.RemoveHediff(__instance.health.hediffSet.GetFirstHediffOfDef(Regen5Def)); __instance.health.AddHediff(Regen6Def, heart);
}
else if (__instance.health.hediffSet.HasHediff(Regen6Def))
{
__instance.health.RemoveHediff(__instance.health.hediffSet.GetFirstHediffOfDef(Regen6Def)); __instance.health.AddHediff(Regen7Def, heart);
}
else if (__instance.health.hediffSet.HasHediff(Regen7Def))
{
__instance.health.RemoveHediff(__instance.health.hediffSet.GetFirstHediffOfDef(Regen7Def)); __instance.health.AddHediff(Regen8Def, heart);
}
else if (__instance.health.hediffSet.HasHediff(Regen8Def))
{
__instance.health.RemoveHediff(__instance.health.hediffSet.GetFirstHediffOfDef(Regen8Def)); __instance.health.AddHediff(Regen9Def, heart);
}
else if (__instance.health.hediffSet.HasHediff(Regen9Def))
{
__instance.health.RemoveHediff(__instance.health.hediffSet.GetFirstHediffOfDef(Regen9Def)); __instance.health.AddHediff(Regen10Def, heart);
}
else if (__instance.health.hediffSet.HasHediff(Regen10Def))
{
__instance.health.RemoveHediff(__instance.health.hediffSet.GetFirstHediffOfDef(Regen10Def)); __instance.health.AddHediff(Regen11Def, heart);
}
else if (__instance.health.hediffSet.HasHediff(Regen11Def))
{
__instance.health.RemoveHediff(__instance.health.hediffSet.GetFirstHediffOfDef(Regen11Def)); __instance.health.AddHediff(Regen12Def, heart);
}
else if (__instance.health.hediffSet.HasHediff(Regen12Def))
{
__instance.health.RemoveHediff(__instance.health.hediffSet.GetFirstHediffOfDef(Regen12Def)); __instance.health.AddHediff(Regen13Def, heart);
}
// Visual Changes ----------------------------------------------------------------------------------------------------------
//Gender
__instance.gender = GenderSwap(__instance.gender);
//Skintone
__instance.story.melanin = 0.01f * Rand.Range(10, 200);
//Head
var graphicPath = GraphicDatabaseHeadRecords.GetHeadRandom(__instance.gender, __instance.story.SkinColor, __instance.story.crownType).GraphicPath;
Traverse.Create(__instance.story).Field("headGraphicPath").SetValue(graphicPath);
//Hair
__instance.story.hairDef = PawnHairChooser.RandomHairDefFor(__instance, FactionDefOf.PlayerColony);
__instance.story.hairColor = HairColor();
//Body
__instance.story.bodyType = BodySwap(__instance.gender);
//Redraw the __instance to trigger the above affects
__instance.Drawer.renderer.graphics.nakedGraphic = null;
// Bio Changes ----------------------------------------------------------------------------------------------------------
//randomise traits
__instance.story.traits.allTraits.Clear();
int i = 0;
int rInt = Rand.RangeInclusive(1, 3);
while (i < rInt)
{
TraitDef random = DefDatabase <TraitDef> .GetRandom();
Trait trait = new Trait(random, PawnGenerator.RandomTraitDegree(random), false);
__instance.story.traits.GainTrait(trait);
Trait trait2 = new Trait(random, PawnGenerator.RandomTraitDegree(random), false);
__instance.story.traits.GainTrait(trait2);
i++;
}
//Add Memory
__instance.needs.mood.thoughts.memories.TryGainMemory(RegenerationThoughtDefs.RecentlyRegenerated, null);
//Add debuff thought to all related colonists
foreach (Pawn p in __instance.relations.RelatedPawns)
{
//Log.Warning("related to: " + p.Name);
try
{
if (!p.health.Dead)
{
p.needs.mood.thoughts.memories.TryGainMemory(RegenerationThoughtDefs.KnownColonistRegeneratedSocial, __instance);
p.needs.mood.thoughts.memories.TryGainMemory(RegenerationThoughtDefs.KnownColonistRegenerated);
}
}
catch
{
Log.Warning("Couldn't add social debuff to " + p.Name);
}
}
// Visual effects -------------------------------------------------------------------------------------------------------
//Glow effect (ugly approach, look at cleaning this up)
MoteMaker.ThrowAirPuffUp(__instance.DrawPos, __instance.Map);
MoteMaker.ThrowFireGlow(__instance.Position, __instance.Map, 3f);
MoteMaker.ThrowFireGlow(__instance.Position, __instance.Map, 3f);
MoteMaker.ThrowFireGlow(__instance.Position, __instance.Map, 3f);
MoteMaker.ThrowFireGlow(__instance.Position, __instance.Map, 3f);
MoteMaker.ThrowFireGlow(__instance.Position, __instance.Map, 3f);
}
// Token: 0x06002944 RID: 10564 RVA: 0x00139525 File Offset: 0x00137925
public override void Initialize(CompProperties props)
{
base.Initialize(props);
this.skill = DefDatabase <SkillDef> .GetRandom();
}
public static bool HealthTick(Pawn_HealthTracker __instance)
{
if (__instance.Dead)
{
return(false);
}
for (int index = __instance.hediffSet.hediffs.Count - 1; index >= 0; --index)
{
Hediff hediff = __instance.hediffSet.hediffs[index];
try
{
hediff.Tick();
hediff.PostTick();
}
catch (Exception ex1)
{
Log.Error("Exception ticking hediff " + hediff.ToStringSafe <Hediff>() + " for pawn " + __instance.pawn.ToStringSafe <Pawn>() + ". Removing hediff... Exception: " + (object)ex1);
try
{
__instance.RemoveHediff(hediff);
}
catch (Exception ex2)
{
Log.Error("Error while removing hediff: " + (object)ex2);
}
}
if (__instance.Dead)
{
return(false);
}
}
bool flag1 = false;
lock (__instance.hediffSet) //added
{
List <Hediff> newHediffs = new List <Hediff>(__instance.hediffSet.hediffs); //added
for (int index = newHediffs.Count - 1; index >= 0; --index) //changed
{
Hediff hediff = newHediffs[index];
if (hediff.ShouldRemove)
{
newHediffs.RemoveAt(index); //changed
__instance.hediffSet.hediffs = newHediffs; //added
hediff.PostRemoved();
flag1 = true;
}
}
}
if (flag1)
{
__instance.Notify_HediffChanged((Hediff)null);
}
if (__instance.Dead)
{
return(false);
}
__instance.immunity.ImmunityHandlerTick();
if (__instance.pawn.RaceProps.IsFlesh && __instance.pawn.IsHashIntervalTick(600) && (__instance.pawn.needs.food == null || !__instance.pawn.needs.food.Starving))
{
bool flag2 = false;
if (__instance.hediffSet.HasNaturallyHealingInjury())
{
float num = 8f;
if (__instance.pawn.GetPosture() != PawnPosture.Standing)
{
num += 4f;
Building_Bed buildingBed = __instance.pawn.CurrentBed();
if (buildingBed != null)
{
num += buildingBed.def.building.bed_healPerDay;
}
}
foreach (Hediff hediff in __instance.hediffSet.hediffs)
{
HediffStage curStage = hediff.CurStage;
if (curStage != null && (double)curStage.naturalHealingFactor != -1.0)
{
num *= curStage.naturalHealingFactor;
}
}
__instance.hediffSet.GetHediffs <Hediff_Injury>().Where <Hediff_Injury>((Func <Hediff_Injury, bool>)(x => x.CanHealNaturally())).RandomElement <Hediff_Injury>().Heal((float)((double)num * (double)__instance.pawn.HealthScale * 0.00999999977648258) * __instance.pawn.GetStatValue(StatDefOf.InjuryHealingFactor));
flag2 = true;
}
if (__instance.hediffSet.HasTendedAndHealingInjury() && (__instance.pawn.needs.food == null || !__instance.pawn.needs.food.Starving))
{
Hediff_Injury hd = __instance.hediffSet.GetHediffs <Hediff_Injury>().Where <Hediff_Injury>((Func <Hediff_Injury, bool>)(x => x.CanHealFromTending())).RandomElement <Hediff_Injury>();
hd.Heal((float)(8.0 * (double)GenMath.LerpDouble(0.0f, 1f, 0.5f, 1.5f, Mathf.Clamp01(hd.TryGetComp <HediffComp_TendDuration>().tendQuality)) * (double)__instance.pawn.HealthScale * 0.00999999977648258) * __instance.pawn.GetStatValue(StatDefOf.InjuryHealingFactor));
flag2 = true;
}
if (flag2 && !__instance.HasHediffsNeedingTendByPlayer() && (!HealthAIUtility.ShouldSeekMedicalRest(__instance.pawn) && !__instance.hediffSet.HasTendedAndHealingInjury()) && PawnUtility.ShouldSendNotificationAbout(__instance.pawn))
{
Messages.Message((string)"MessageFullyHealed".Translate((NamedArgument)__instance.pawn.LabelCap, (NamedArgument)(Thing)__instance.pawn), (LookTargets)(Thing)__instance.pawn, MessageTypeDefOf.PositiveEvent);
}
}
if (__instance.pawn.RaceProps.IsFlesh && (double)__instance.hediffSet.BleedRateTotal >= 0.100000001490116)
{
float num = __instance.hediffSet.BleedRateTotal * __instance.pawn.BodySize;
if ((double)Rand.Value < (__instance.pawn.GetPosture() != PawnPosture.Standing ? (double)(num * 0.0004f) : (double)(num * 0.004f)))
{
__instance.DropBloodFilth();
}
}
if (!__instance.pawn.IsHashIntervalTick(60))
{
return(false);
}
List <HediffGiverSetDef> hediffGiverSets = __instance.pawn.RaceProps.hediffGiverSets;
if (hediffGiverSets != null)
{
for (int index1 = 0; index1 < hediffGiverSets.Count; ++index1)
{
List <HediffGiver> hediffGivers = hediffGiverSets[index1].hediffGivers;
for (int index2 = 0; index2 < hediffGivers.Count; ++index2)
{
hediffGivers[index2].OnIntervalPassed(__instance.pawn, (Hediff)null);
if (__instance.pawn.Dead)
{
return(false);
}
}
}
}
if (__instance.pawn.story == null)
{
return(false);
}
List <Trait> allTraits = __instance.pawn.story.traits.allTraits;
for (int index = 0; index < allTraits.Count; ++index)
{
TraitDegreeData currentData = allTraits[index].CurrentData;
if ((double)currentData.randomDiseaseMtbDays > 0.0 && Rand.MTBEventOccurs(currentData.randomDiseaseMtbDays, 60000f, 60f))
{
BiomeDef biome = __instance.pawn.Tile == -1 ? DefDatabase <BiomeDef> .GetRandom() : Find.WorldGrid[__instance.pawn.Tile].biome;
IncidentDef incidentDef = DefDatabase <IncidentDef> .AllDefs.Where <IncidentDef>((Func <IncidentDef, bool>)(d => d.category == IncidentCategoryDefOf.DiseaseHuman)).RandomElementByWeightWithFallback <IncidentDef>((Func <IncidentDef, float>)(d => biome.CommonalityOfDisease(d)));
if (incidentDef != null)
{
string blockedInfo;
List <Pawn> pawns = ((IncidentWorker_Disease)incidentDef.Worker).ApplyToPawns(Gen.YieldSingle <Pawn>(__instance.pawn), out blockedInfo);
if (PawnUtility.ShouldSendNotificationAbout(__instance.pawn))
{
if (pawns.Contains(__instance.pawn))
{
Find.LetterStack.ReceiveLetter("LetterLabelTraitDisease".Translate((NamedArgument)incidentDef.diseaseIncident.label), "LetterTraitDisease".Translate((NamedArgument)__instance.pawn.LabelCap, (NamedArgument)incidentDef.diseaseIncident.label, __instance.pawn.Named("PAWN")).AdjustedFor(__instance.pawn), LetterDefOf.NegativeEvent, (LookTargets)(Thing)__instance.pawn);
}
else if (!blockedInfo.NullOrEmpty())
{
Messages.Message(blockedInfo, (LookTargets)(Thing)__instance.pawn, MessageTypeDefOf.NeutralEvent);
}
}
}
}
}
return(false);
}
// Token: 0x0600000D RID: 13 RVA: 0x00002BAC File Offset: 0x00000DAC
private void TrySetCellAs(IntVec3 c, ThingDef thingDef, Rot4 thingRot, Map map, ThingDef stuffDef = null,
TerrainDef terrainDef = null, PawnKindDef pawnKindDef = null, ThingDef itemDef = null,
MapGeneratorBlueprintDef blueprint = null)
{
if (!c.InBounds(map))
{
Log.Warning("GenStep_CreateBlueprint: Invalid Target-Cell: cell is null or out of bounds.");
}
else
{
var thingList = c.GetThingList(map);
foreach (var thing in thingList)
{
if (!thing.def.destroyable)
{
return;
}
}
if (terrainDef != null)
{
map.terrainGrid.SetTerrain(c, terrainDef);
}
else
{
if (thingDef != null && stuffDef != null)
{
map.terrainGrid.SetTerrain(c, CorrespondingTileDef(stuffDef));
}
}
if (thingDef != null)
{
var stuff = stuffDef;
if (!thingDef.MadeFromStuff)
{
stuff = null;
}
var thing = ThingMaker.MakeThing(thingDef, stuff);
if (thingRot == Rot4.Invalid)
{
GenSpawn.Spawn(thing, c, map);
}
else
{
GenSpawn.Spawn(thing, c, map, thingRot);
}
}
if (blueprint == null)
{
return;
}
if (itemDef != null && blueprint.itemSpawnChance / 100f > Rand.Value)
{
var isApparel = itemDef.IsApparel;
ThingDef thingDef2;
if (isApparel)
{
var num = 0;
for (;;)
{
thingDef2 = DefDatabase <ThingDef> .GetRandom();
if (thingDef2.IsStuff &&
thingDef2.stuffCategories.Contains(StuffCategoryDefOf.Fabric))
{
break;
}
num++;
if (num > 100)
{
goto Block_17;
}
}
goto IL_18F;
Block_17:
thingDef2 = DefDatabase <ThingDef> .GetNamedSilentFail("Synthread");
IL_18F :;
}
else
{
var source = new List <string>
{
"Steel",
"Steel",
"Steel",
"Steel",
"Steel",
"Plasteel"
};
thingDef2 = DefDatabase <ThingDef> .GetNamedSilentFail(source.RandomElement());
}
if (!itemDef.MadeFromStuff)
{
thingDef2 = null;
}
var thing2 = TryGetTreasure(itemDef, thingDef2);
thing2 = GenSpawn.Spawn(thing2, c, map);
if (thing2.TryGetComp <CompForbiddable>() != null)
{
thing2.SetForbidden(true);
}
if (thing2 is Hive hive)
{
hive.CompDormant.WakeUp();
}
}
if (pawnKindDef == null || !(blueprint.pawnSpawnChance / 100f > Rand.Value))
{
return;
}
if (faction == null)
{
faction = Find.FactionManager.FirstFactionOfDef(blueprint.factionDef);
}
if (faction == null)
{
switch (blueprint.factionSelection)
{
case FactionSelection.none:
{
faction = Find.FactionManager.AllFactions.RandomElementByWeight(fac =>
fac.def.settlementGenerationWeight);
if (faction == null)
{
faction = Faction.OfMechanoids;
}
break;
}
case FactionSelection.hostile:
{
faction = (from fac in Find.FactionManager.AllFactions
where fac.HostileTo(Faction.OfPlayer)
select fac).RandomElementByWeight(fac =>
101f - fac.def.settlementGenerationWeight);
if (faction == null)
{
faction = Faction.OfMechanoids;
}
break;
}
case FactionSelection.friendly:
{
faction = (from fac in Find.FactionManager.AllFactions
where !fac.HostileTo(Faction.OfPlayer) && fac.PlayerGoodwill > 0f &&
fac != Faction.OfPlayer
select fac).RandomElementByWeight(fac =>
101f - fac.def.settlementGenerationWeight);
if (faction == null)
{
faction = Find.FactionManager.AllFactions.RandomElementByWeight(fac =>
fac.def.settlementGenerationWeight);
}
break;
}
}
}
var pawn = PawnGenerator.GeneratePawn(pawnKindDef, faction);
pawn.mindState.Active = false;
pawn = GenSpawn.Spawn(pawn, c, map) as Pawn;
if (pawn == null)
{
return;
}
if (allSpawnedPawns == null)
{
allSpawnedPawns = new List <Pawn>();
}
allSpawnedPawns.Add(pawn);
}
}
public static void Post_GeneratePawn_Yautja(PawnGenerationRequest request, ref Pawn __result)
{
if (__result.kindDef.race == YautjaDefOf.RRY_Alien_Yautja)
{
Comp_Yautja _Yautja = __result.TryGetComp <Comp_Yautja>();
if (_Yautja != null)
{
Backstory pawnStoryC = __result.story.childhood;
Backstory pawnStoryA = __result.story.adulthood != null ? __result.story.adulthood : null;
AlienRace.BackstoryDef bsDefUnblooded = DefDatabase <AlienRace.BackstoryDef> .GetNamed("RRY_Yautja_YoungBlood");
AlienRace.BackstoryDef bsDefBlooded = DefDatabase <AlienRace.BackstoryDef> .GetNamed("RRY_Yautja_Blooded");
AlienRace.BackstoryDef bsDefBadbloodA = DefDatabase <AlienRace.BackstoryDef> .GetNamed("RRY_Yautja_BadBloodA");
AlienRace.BackstoryDef bsDefBadblooBd = DefDatabase <AlienRace.BackstoryDef> .GetNamed("RRY_Yautja_BadBloodB");
HediffDef unbloodedDef = YautjaDefOf.RRY_Hediff_Unblooded;
HediffDef unmarkedDef = YautjaDefOf.RRY_Hediff_BloodedUM;
HediffDef markedDef = YautjaDefOf.RRY_Hediff_BloodedM;
bool hasunblooded = __result.health.hediffSet.HasHediff(unbloodedDef);
bool hasbloodedUM = __result.health.hediffSet.HasHediff(unmarkedDef);
bool hasbloodedM = __result.health.hediffSet.hediffs.Any <Hediff>(x => x.def.defName.StartsWith(markedDef.defName));
if (!hasunblooded && !hasbloodedUM && !hasbloodedM)
{
HediffDef hediffDef;
if (pawnStoryA != null)
{
if (pawnStoryA != bsDefUnblooded.backstory)
{
hediffDef = _Yautja.Props.bloodedDefs.RandomElement();
}
else
{
hediffDef = unbloodedDef;
}
}
else
{
hediffDef = unbloodedDef;
}
__result.health.AddHediff(hediffDef);
}
else
{
Log.Message(string.Format("new pawn has hasunblooded:{0}, hasbloodedUM:{1}, hasbloodedM:{2}", hasunblooded, hasbloodedUM, hasbloodedM));
}
}
}
else if (request.Faction == Find.FactionManager.FirstFactionOfDef(XenomorphDefOf.RRY_Xenomorph))
{
Log.Message(string.Format("Xenomorph spawning"));
}
else if (__result.kindDef.race != YautjaDefOf.RRY_Alien_Yautja && __result.RaceProps.Humanlike && (__result.story.hairDef == YautjaDefOf.RRY_Yaujta_Dreds || __result.story.hairDef == YautjaDefOf.RRY_Yaujta_Ponytail || __result.story.hairDef == YautjaDefOf.RRY_Yaujta_Bald))
{
Log.Message(string.Format("Non Yautja with Yautja Hair"));
__result.story.hairDef = DefDatabase <HairDef> .GetRandom();
}
}
