public void DoNeoCough()
{
lastCoughSeverity = parent.Severity;
lastCoughStage = parent.CurStageIndex;
lastCoughTick = parent.ageTicks; // Find.TickManager.TicksGame; // parent.ageTicks; //
nextCoughTick = lastCoughTick + Rand.RangeInclusiveSeeded(3000, 24000, AvPConstants.AvPSeed);
float chance = ((0.25f + lastCoughSeverity)) + (((timesCoughedBlood * 2) + timesCoughed) / 10);
if (Rand.ChanceSeeded(chance, AvPConstants.AvPSeed))
{
if (this.parent.pawn.Faction == Faction.OfPlayer)
{
string text = TranslatorFormattedStringExtensions.Translate("Xeno_Neospores_Cough", base.parent.pawn.LabelShortCap, Coughlist[Rand.RangeInclusiveSeeded(timesCoughed, Coughlist.Count, AvPConstants.AvPSeed)]);
// Log.Message(text);
MoteMaker.ThrowText(base.parent.pawn.Position.ToVector3(), base.parent.pawn.Map, text, 3f);
}
if (Rand.ChanceSeeded(chance, AvPConstants.AvPSeed))
{
if (this.parent.pawn.Faction == Faction.OfPlayer)
{
string text = TranslatorFormattedStringExtensions.Translate("Xeno_Neospores_Cough_Blood");
// Log.Message(text);
MoteMaker.ThrowText(base.parent.pawn.Position.ToVector3(), base.parent.pawn.Map, text, 3f);
}
parent.pawn.health.DropBloodFilth();
timesCoughedBlood++;
}
else
{
timesCoughed++;
}
}
}
public static bool ShouldTrashBuilding(Pawn pawn, Building b, bool attackAllInert = false)
{
if (!b.def.useHitPoints)
{
return(false);
}
if (b.def.building.isInert && !attackAllInert)
{
goto IL_0042;
}
if (b.def.building.isTrap)
{
goto IL_0042;
}
goto IL_007f;
IL_0042:
int num = GenLocalDate.HourOfDay(pawn) / 3;
int specialSeed = b.GetHashCode() * 612361 ^ pawn.GetHashCode() * 391 ^ num * 734273247;
if (!Rand.ChanceSeeded(0.008f, specialSeed))
{
return(false);
}
goto IL_007f;
IL_007f:
if (b.def.building.isTrap && ((Building_Trap)b).Armed)
{
return(false);
}
if (TrashUtility.CanTrash(pawn, b) && pawn.HostileTo(b))
{
return(true);
}
return(false);
}
public static bool ShouldTrashBuilding(Pawn pawn, Building b, bool attackAllInert = false)
{
if (!b.def.useHitPoints)
{
return(false);
}
if (pawn.mindState.spawnedByInfestationThingComp && b.GetComp <CompCreatesInfestations>() != null)
{
return(false);
}
if (((b.def.building.isInert || b.def.IsFrame) && !attackAllInert) || b.def.building.isTrap)
{
int num = GenLocalDate.HourOfDay(pawn) / 3;
int specialSeed = (b.GetHashCode() * 612361) ^ (pawn.GetHashCode() * 391) ^ (num * 73427324);
if (!Rand.ChanceSeeded(0.008f, specialSeed))
{
return(false);
}
}
if (b.def.building.isTrap)
{
return(false);
}
if (!CanTrash(pawn, b) || !pawn.HostileTo(b))
{
return(false);
}
return(true);
}
public static bool ShouldTrashBuilding(Pawn pawn, Building b, bool attackAllInert = false)
{
bool result;
if (!b.def.useHitPoints)
{
result = false;
}
else if (pawn.mindState.spawnedByInfestationThingComp && b.GetComp <CompCreatesInfestations>() != null)
{
result = false;
}
else
{
if ((b.def.building.isInert && !attackAllInert) || b.def.building.isTrap)
{
int num = GenLocalDate.HourOfDay(pawn) / 3;
int specialSeed = b.GetHashCode() * 612361 ^ pawn.GetHashCode() * 391 ^ num * 73427324;
if (!Rand.ChanceSeeded(0.008f, specialSeed))
{
return(false);
}
}
result = ((!b.def.building.isTrap || !((Building_Trap)b).Armed) && TrashUtility.CanTrash(pawn, b) && pawn.HostileTo(b));
}
return(result);
}
// Token: 0x06002676 RID: 9846 RVA: 0x0012417C File Offset: 0x0012257C
public override void Tick()
{
base.Tick();
if (base.Spawned)
{
this.FilterOutUnspawnedPawns();
if (!this.active && !base.Position.Fogged(base.Map))
{
this.Activate();
}
if (this.active && Find.TickManager.TicksGame >= this.nextPawnSpawnTick)
{
if (this.SpawnedPawnsPoints < MaxSpawnedPawnsPoints)
{
bool flag = this.TrySpawnPawn(out Pawn pawn);
if (flag && pawn.caller != null)
{
pawn.caller.DoCall();
}
}
this.CalculateNextPawnSpawnTick();
}
if (this.Map.skyManager.CurSkyGlow < 0.5f && this.active)
{
if (this.innerContainer != null)
{
if (this.innerContainer.Count > 0)
{
this.innerContainer.TryDropAll(this.Position, this.Map, ThingPlaceMode.Near, null, null);
}
}
}
if (this.innerContainer != null && hiveMaintainer != null)
{
if (this.innerContainer.Count > 0 && hiveMaintainer.CurStage == MaintainableStage.NeedsMaintenance)
{
Thing thing = this.innerContainer.RandomElement();
this.innerContainer.TryDrop(thing, ThingPlaceMode.Near, out thing);
}
}
if (this.innerContainer != null && Find.TickManager.TicksGame % 10000 == 0)
{
Thing thing = GenClosest.ClosestThingReachable(this.Position, this.Map, ThingRequest.ForGroup(ThingRequestGroup.Pawn), Verse.AI.PathEndMode.ClosestTouch, TraverseParms.For(TraverseMode.ByPawn, Danger.Deadly), 30f, (x => x.isPotentialHost()));
if (this.innerContainer.Count > 0 && !thing.DestroyedOrNull())
{
Pawn p = (Pawn)thing;
for (int i = 0; i < this.innerContainer.Count; i++)
{
Thing thing2 = this.innerContainer[i];
float chance = p.RaceProps.baseBodySize * p.ageTracker.CurLifeStage.bodySizeFactor / XenomorphUtil.DistanceBetween(this.Position, p.Position) * this.innerContainer.Count;
if (Rand.ChanceSeeded(chance, AvPConstants.AvPSeed))
{
this.innerContainer.TryDrop(thing2, ThingPlaceMode.Near, out thing2);
}
}
}
}
}
}
private static bool CanUsePair(ThingStuffPair pair, Pawn pawn, float moneyLeft, bool allowHeadgear, int fixedSeed)
{
bool result;
if (pair.Price > moneyLeft)
{
result = false;
}
else if (!allowHeadgear && PawnApparelGenerator.IsHeadgear(pair.thing))
{
result = false;
}
else if (pair.stuff != null && pawn.Faction != null && !pawn.Faction.def.CanUseStuffForApparel(pair.stuff))
{
result = false;
}
else if (PawnApparelGenerator.workingSet.PairOverlapsAnything(pair))
{
result = false;
}
else
{
if (!pawn.kindDef.apparelTags.NullOrEmpty <string>())
{
bool flag = false;
for (int i = 0; i < pawn.kindDef.apparelTags.Count; i++)
{
for (int j = 0; j < pair.thing.apparel.tags.Count; j++)
{
if (pawn.kindDef.apparelTags[i] == pair.thing.apparel.tags[j])
{
flag = true;
break;
}
}
if (flag)
{
break;
}
}
if (!flag)
{
return(false);
}
}
if (pair.thing.generateAllowChance < 1f)
{
if (!Rand.ChanceSeeded(pair.thing.generateAllowChance, fixedSeed ^ (int)pair.thing.shortHash ^ 64128343))
{
return(false);
}
}
result = true;
}
return(result);
}
private static bool CanUsePair(ThingStuffPair pair, Pawn pawn, float moneyLeft, bool allowHeadgear, int fixedSeed)
{
if (pair.Price > moneyLeft)
{
return(false);
}
if (!allowHeadgear && IsHeadgear(pair.thing))
{
return(false);
}
if (!pair.thing.apparel.CorrectGenderForWearing(pawn.gender))
{
return(false);
}
if (!pawn.kindDef.apparelTags.NullOrEmpty())
{
bool flag = false;
for (int i = 0; i < pawn.kindDef.apparelTags.Count; i++)
{
for (int j = 0; j < pair.thing.apparel.tags.Count; j++)
{
if (pawn.kindDef.apparelTags[i] == pair.thing.apparel.tags[j])
{
flag = true;
break;
}
}
if (flag)
{
break;
}
}
if (!flag)
{
return(false);
}
}
if (!pawn.kindDef.apparelDisallowTags.NullOrEmpty())
{
for (int k = 0; k < pawn.kindDef.apparelDisallowTags.Count; k++)
{
if (pair.thing.apparel.tags.Contains(pawn.kindDef.apparelDisallowTags[k]))
{
return(false);
}
}
}
if (pair.thing.generateAllowChance < 1f && !Rand.ChanceSeeded(pair.thing.generateAllowChance, fixedSeed ^ pair.thing.shortHash ^ 0x3D28557))
{
return(false);
}
return(true);
}
// Token: 0x0600000A RID: 10 RVA: 0x000022B0 File Offset: 0x000004B0
public static void PawnWeaponGenerator_TryGenerateWeaponFor_PostFix(Pawn pawn)
{
HugsLib.Settings.SettingHandle <int> chance = Traverse.Create(typeof(DualWield.Base)).Field("NPCDualWieldChance").GetValue <HugsLib.Settings.SettingHandle <int> >();
bool alwaysDW = (pawn.kindDef.weaponTags != null && pawn.kindDef.weaponTags.Contains("AlwaysDualWield"));
Rand.PushState();
bool flag = !pawn.RaceProps.Humanlike && pawn.RaceProps.ToolUser && pawn.RaceProps.FleshType != FleshTypeDefOf.Mechanoid && pawn.equipment != null && (Rand.Chance((float)chance / 100f) || alwaysDW);
Rand.PopState();
if (flag)
{
float randomInRange = pawn.kindDef.weaponMoney.RandomInRange;
List <ThingStuffPair> allWeaponPairs = Traverse.Create(typeof(PawnWeaponGenerator)).Field("allWeaponPairs").GetValue <List <ThingStuffPair> >();
List <ThingStuffPair> workingWeapons = Traverse.Create(typeof(PawnWeaponGenerator)).Field("workingWeapons").GetValue <List <ThingStuffPair> >();
if (pawn.equipment != null && pawn.equipment.Primary != null && pawn.equipment.Primary.def.IsTwoHand())
{
return;
}
if (pawn.equipment == null || pawn.equipment.Primary == null)
{
return;
}
for (int i = 0; i < allWeaponPairs.Count; i++)
{
ThingStuffPair w = allWeaponPairs[i];
if (w.Price <= randomInRange)
{
if (pawn.kindDef.weaponTags == null || pawn.kindDef.weaponTags.Any((string tag) => w.thing.weaponTags.Contains(tag)))
{
Rand.PushState();
if (w.thing.generateAllowChance >= 1f || Rand.ChanceSeeded(w.thing.generateAllowChance, pawn.thingIDNumber ^ (int)w.thing.shortHash ^ 28554824))
{
workingWeapons.Add(w);
}
Rand.PopState();
}
}
}
if (workingWeapons.Count == 0)
{
return;
}
IEnumerable <ThingStuffPair> matchingWeapons = workingWeapons.Where((ThingStuffPair tsp) =>
tsp.thing.CanBeOffHand() &&
!tsp.thing.IsTwoHand());
if (matchingWeapons != null && matchingWeapons.TryRandomElementByWeight((ThingStuffPair w) => w.Commonality * w.Price, out ThingStuffPair thingStuffPair))
{
ThingWithComps thingWithComps = (ThingWithComps)ThingMaker.MakeThing(thingStuffPair.thing, thingStuffPair.stuff);
PawnGenerator.PostProcessGeneratedGear(thingWithComps, pawn);
AddOffHandEquipment(pawn.equipment, thingWithComps);
}
}
}
public static void TryGenerateWeaponFor(Pawn pawn)
{
PawnWeaponGenerator.workingWeapons.Clear();
if (pawn.kindDef.weaponTags == null || pawn.kindDef.weaponTags.Count == 0)
{
return;
}
if (!pawn.RaceProps.ToolUser)
{
return;
}
if (!pawn.health.capacities.CapableOf(PawnCapacityDefOf.Manipulation))
{
return;
}
if (pawn.story != null && pawn.story.WorkTagIsDisabled(WorkTags.Violent))
{
return;
}
float randomInRange = pawn.kindDef.weaponMoney.RandomInRange;
for (int i = 0; i < PawnWeaponGenerator.allWeaponPairs.Count; i++)
{
ThingStuffPair w = PawnWeaponGenerator.allWeaponPairs[i];
if (w.Price <= randomInRange)
{
if (pawn.kindDef.weaponTags == null || pawn.kindDef.weaponTags.Any((string tag) => w.thing.weaponTags.Contains(tag)))
{
if (w.thing.generateAllowChance >= 1f || Rand.ChanceSeeded(w.thing.generateAllowChance, pawn.thingIDNumber ^ (int)w.thing.shortHash ^ 28554824))
{
PawnWeaponGenerator.workingWeapons.Add(w);
}
}
}
}
if (PawnWeaponGenerator.workingWeapons.Count == 0)
{
return;
}
pawn.equipment.DestroyAllEquipment(DestroyMode.Vanish);
ThingStuffPair thingStuffPair;
if (PawnWeaponGenerator.workingWeapons.TryRandomElementByWeight((ThingStuffPair w) => w.Commonality * w.Price, out thingStuffPair))
{
ThingWithComps thingWithComps = (ThingWithComps)ThingMaker.MakeThing(thingStuffPair.thing, thingStuffPair.stuff);
PawnGenerator.PostProcessGeneratedGear(thingWithComps, pawn);
pawn.equipment.AddEquipment(thingWithComps);
}
PawnWeaponGenerator.workingWeapons.Clear();
}
private void TryGenerateWeaponWithAmmoFor(Pawn pawn, CompInventory inventory, SidearmOption option)
{
if (option.weaponTags.NullOrEmpty() || !Rand.Chance(option.generateChance))
{
return;
}
// Generate weapon - mostly based on PawnWeaponGenerator.TryGenerateWeaponFor()
// START 1:1 COPY
float randomInRange = pawn.kindDef.weaponMoney.RandomInRange;
for (int i = 0; i < allWeaponPairs.Count; i++)
{
ThingStuffPair w = allWeaponPairs[i];
if (w.Price <= randomInRange)
{
if (option.weaponTags == null || option.weaponTags.Any((string tag) => w.thing.weaponTags.Contains(tag)))
{
if (w.thing.generateAllowChance >= 1f || Rand.ChanceSeeded(w.thing.generateAllowChance, pawn.thingIDNumber ^ (int)w.thing.shortHash ^ 28554824))
{
workingWeapons.Add(w);
}
}
}
}
if (workingWeapons.Count == 0)
{
return;
}
// END 1:1 COPY
// pawn.equipment.DestroyAllEquipment(DestroyMode.Vanish); --removed compared to sourcecode
// Some 1:1 COPY below
ThingStuffPair thingStuffPair;
if (workingWeapons.TryRandomElementByWeight((ThingStuffPair w) => w.Commonality * w.Price, out thingStuffPair))
{
// Create the actual weapon and put it into inventory
ThingWithComps thingWithComps = (ThingWithComps)ThingMaker.MakeThing(thingStuffPair.thing, thingStuffPair.stuff);
LoadWeaponWithRandAmmo(thingWithComps); //Custom
int count; //Custom
if (inventory.CanFitInInventory(thingWithComps, out count)) //Custom
{
PawnGenerator.PostProcessGeneratedGear(thingWithComps, pawn);
if (inventory.container.TryAdd(thingWithComps)) //Custom
{
TryGenerateAmmoFor(thingWithComps, inventory, Mathf.RoundToInt(option.magazineCount.RandomInRange)); //Custom
}
}
}
workingWeapons.Clear();
}
protected override ThoughtState CurrentSocialStateInternal(Pawn p, Pawn other)
{
if (!other.RaceProps.Humanlike)
{
return(false);
}
if (!RelationsUtility.PawnsKnowEachOther(p, other))
{
return(false);
}
if (IsRoyalty(p, other) && Rand.ChanceSeeded(0.1f, p.thingIDNumber))
{
return(true);
}
return(false);
}
public static bool PreExecute(ref IncidentParms parms)
{
if (parms.target is Map && (parms.target as Map).IsPlayerHome)
{
if (parms.faction != null && (parms.faction.def == XenomorphDefOf.RRY_Xenomorph))
{
if ((parms.target is Map map))
{
parms.generateFightersOnly = true;
int @int = Rand.Int;
bool extTunnels = !map.GetComponent <MapComponent_HiveGrid>().HiveChildlist.NullOrEmpty();
if (Rand.ChanceSeeded(0.05f, AvPConstants.AvPSeed))
{
parms.forced = true;
parms.points = Mathf.Max(parms.points * new FloatRange(1f, 1.6f).RandomInRange, parms.faction.def.MinPointsToGeneratePawnGroup(PawnGroupKindDefOf.Combat));
}
if ((parms.target as Map).skyManager.CurSkyGlow <= 0.5f)
{
parms.points *= 2;
parms.raidArrivalMode = YautjaDefOf.EdgeWalkInGroups;
if (Rand.ChanceSeeded(0.05f, AvPConstants.AvPSeed))
{
parms.forced = true;
parms.points = Mathf.Max(parms.points * new FloatRange(1f, 1.6f).RandomInRange, parms.faction.def.MinPointsToGeneratePawnGroup(PawnGroupKindDefOf.Combat));
}
}
if (extTunnels && Rand.ChanceSeeded(0.10f + (map.GetComponent <MapComponent_HiveGrid>().HiveChildlist.Count / 100f), AvPConstants.AvPSeed))
{
parms.raidStrategy = RaidStrategyDefOf.ImmediateAttack;
parms.raidArrivalMode = XenomorphDefOf.RRY_RandomEnterFromTunnel;
}
else
{
if (parms.raidStrategy != XenomorphDefOf.RRY_PowerCut)
{
parms.raidStrategy = RaidStrategyDefOf.ImmediateAttack;
}
if (parms.raidArrivalMode != XenomorphDefOf.RRY_RandomEnterFromTunnel && parms.raidArrivalMode != XenomorphDefOf.RRY_DropThroughRoofNearPower)
{
parms.raidArrivalMode = PawnsArrivalModeDefOf.EdgeWalkIn;
}
}
}
}
}
return(true);
}
// RimWorld.TrashUtility
public static bool ShouldTrashBuilding(Pawn pawn, Building b)
{
if (!b.def.useHitPoints)
{
return(false);
}
if (b.def.building.isInert || b.def.building.isTrap)
{
int num = GenLocalDate.HourOfDay(pawn) / 3;
int specialSeed = b.GetHashCode() * 612361 ^ pawn.GetHashCode() * 391 ^ num * 734273247;
if (!Rand.ChanceSeeded(0.008f, specialSeed))
{
return(false);
}
}
return((!b.def.building.isTrap || !((Building_Trap)b).Armed) && CanTrash(pawn, b) && pawn.HostileTo(b));
}
// RimWorld.TrashUtility
public static bool ShouldTrashBuilding(Pawn pawn, Building b)
{
if (!b.def.useHitPoints)
{
return(false);
}
if (b.def.building.isInert || b.def.building.isTrap)
{
var num = GenLocalDate.HourOfDay(pawn) / 3;
var specialSeed = (b.GetHashCode() * 612361) ^ (pawn.GetHashCode() * 391) ^ (num * 734273247);
if (!Rand.ChanceSeeded(0.008f, specialSeed))
{
return(false);
}
}
return(!b.def.building.isTrap && pawn.HostileTo(b));
}
static void Postfix(Pawn pawn)
{
if (pawn.RaceProps.Humanlike && Rand.Chance(((float)Base.NPCDualWieldChance) / 100f))
{
float randomInRange = pawn.kindDef.weaponMoney.RandomInRange;
List <ThingStuffPair> allWeaponPairs = Traverse.Create(typeof(PawnWeaponGenerator)).Field("allWeaponPairs").GetValue <List <ThingStuffPair> >();
List <ThingStuffPair> workingWeapons = Traverse.Create(typeof(PawnWeaponGenerator)).Field("workingWeapons").GetValue <List <ThingStuffPair> >();
if (pawn.equipment != null && pawn.equipment.Primary != null && pawn.equipment.Primary.def.IsTwoHand())
{
return;
}
if (pawn.equipment == null || pawn.equipment.Primary == null)
{
return;
}
for (int i = 0; i < allWeaponPairs.Count; i++)
{
ThingStuffPair w = allWeaponPairs[i];
if (w.Price <= randomInRange)
{
if (pawn.kindDef.weaponTags == null || pawn.kindDef.weaponTags.Any((string tag) => w.thing.weaponTags.Contains(tag)))
{
if (w.thing.generateAllowChance >= 1f || Rand.ChanceSeeded(w.thing.generateAllowChance, pawn.thingIDNumber ^ (int)w.thing.shortHash ^ 28554824))
{
workingWeapons.Add(w);
}
}
}
}
if (workingWeapons.Count == 0)
{
return;
}
ThingStuffPair thingStuffPair;
IEnumerable <ThingStuffPair> matchingWeapons = workingWeapons.Where((ThingStuffPair tsp) =>
tsp.thing.CanBeOffHand() &&
!tsp.thing.IsTwoHand());
if (matchingWeapons != null && matchingWeapons.TryRandomElementByWeight((ThingStuffPair w) => w.Commonality * w.Price, out thingStuffPair))
{
ThingWithComps thingWithComps = (ThingWithComps)ThingMaker.MakeThing(thingStuffPair.thing, thingStuffPair.stuff);
PawnGenerator.PostProcessGeneratedGear(thingWithComps, pawn);
pawn.equipment.AddOffHandEquipment(thingWithComps);
}
}
}
public static void doClot(Pawn pawn, BodyPartRecord part = null)
{
var i = 5;
foreach (var hediff in pawn.health.hediffSet.hediffs.Where(x => x.Bleeding).OrderByDescending(x => x.BleedRate))
{
if (Rand.ChanceSeeded(0.25f, AvPConstants.AvPSeed))
{
hediff.Tended(Math.Min(Rand.Value + Rand.Value + Rand.Value, 1f));
}
i--;
if (i <= 0)
{
return;
}
}
}
private static void Postfix(Pawn __instance, Map map, bool respawningAfterLoad)
{
if (!respawningAfterLoad)
{
var pawnAge = __instance.ageTracker.AgeChronologicalYearsFloat;
foreach (var relPawn in __instance.relations.PotentiallyRelatedPawns)
{
var relPawnAge = relPawn.ageTracker.AgeChronologicalYearsFloat;
if (__instance.relations.OpinionOf(relPawn) >= 30 && relPawn.relations.OpinionOf(__instance) >= 30 && new FloatRange(-5f, 5f).Includes(pawnAge - relPawnAge))
{
if (Rand.ChanceSeeded(0.1f, __instance.thingIDNumber))
{
TaleRecorder.RecordTale(VSIE_DefOf.VSIE_HasBeenMyFriendSinceChildhood, __instance, relPawn);
TaleRecorder.RecordTale(VSIE_DefOf.VSIE_HasBeenMyFriendSinceChildhood, relPawn, __instance);
}
}
}
}
}
public bool HasCaves(int tile)
{
Tile tile2 = grid[tile];
float chance;
if ((int)tile2.hilliness >= 4)
{
chance = 0.5f;
}
else
{
if ((int)tile2.hilliness < 3)
{
return(false);
}
chance = 0.25f;
}
return(Rand.ChanceSeeded(chance, Gen.HashCombineInt(Find.World.info.Seed, tile)));
}
public bool HasCaves(int tile)
{
Tile tile2 = this.grid[tile];
float chance;
if (tile2.hilliness >= Hilliness.Mountainous)
{
chance = 0.5f;
}
else
{
if (tile2.hilliness < Hilliness.LargeHills)
{
return(false);
}
chance = 0.25f;
}
return(Rand.ChanceSeeded(chance, Gen.HashCombineInt(Find.World.info.Seed, tile)));
}
public bool HasCaves(int tile)
{
Tile tile2 = this.grid[tile];
float chance;
if ((int)tile2.hilliness >= 4)
{
chance = 0.5f;
goto IL_003d;
}
if ((int)tile2.hilliness >= 3)
{
chance = 0.25f;
goto IL_003d;
}
return(false);
IL_003d:
return(Rand.ChanceSeeded(chance, Gen.HashCombineInt(Find.World.info.Seed, tile)));
}
public static Thing FungusHarvest(ThingDef harvested, ThingDef stuff, Pawn pawn, Plant plant)
{
ThingDef harvestedThingDef = harvested;
OrkoidFungus fungus = plant as OrkoidFungus;
if (fungus != null && (pawn != null && pawn.isOrkoid()))
{
// Log.Message(pawn.Name+" 'ez arvestin " + plant.LabelCap + " boss");
Rand.PushState(plant.thingIDNumber);
if (FungalMeds != null && Rand.ChanceSeeded(0.01f, plant.thingIDNumber))
{
harvestedThingDef = FungalMeds;
// Log.Message("we'ez found some meds boss!");
}
Rand.PopState();
}
return(ThingMaker.MakeThing(harvestedThingDef));
}
public override bool ShowInCompactView()
{
if (!this.deflected)
{
if (this.recipientPawn != null)
{
return(true);
}
if (this.originalTargetThing != null && this.originalTargetThing == this.recipientThing)
{
return(true);
}
}
int num = 1;
if (this.weaponDef != null && !this.weaponDef.Verbs.NullOrEmpty <VerbProperties>())
{
num = this.weaponDef.Verbs[0].burstShotCount;
}
return(Rand.ChanceSeeded(BattleLogEntry_WeaponOverheated.DisplayChanceOnMiss / (float)num, this.logID));
}
private static string DestroyOldOutpostAndCreateNewAtSpot(Settlement someRandomPreferablyNearbySettlement)
{
if (Rand.ChanceSeeded(chance: 0.5f, specialSeed: someRandomPreferablyNearbySettlement.ID))
{
Settlement factionBase = (Settlement)WorldObjectMaker.MakeWorldObject(def: WorldObjectDefOf.Settlement);
factionBase.SetFaction(newFaction: someRandomPreferablyNearbySettlement.Faction.EnemyInFactionWar());
factionBase.Tile = someRandomPreferablyNearbySettlement.Tile;
factionBase.Name = SettlementNameGenerator.GenerateSettlementName(factionBase: factionBase);
Find.WorldObjects.Remove(o: someRandomPreferablyNearbySettlement);
Find.WorldObjects.Add(o: factionBase);
return("MFI_FactionWarBaseTakenOver".Translate(someRandomPreferablyNearbySettlement.Faction, someRandomPreferablyNearbySettlement.Faction.EnemyInFactionWar()));
}
DestroyedSettlement destroyedSettlement = (DestroyedSettlement)WorldObjectMaker.MakeWorldObject(def: WorldObjectDefOf.DestroyedSettlement);
destroyedSettlement.Tile = someRandomPreferablyNearbySettlement.Tile;
Faction loserFaction = someRandomPreferablyNearbySettlement.Faction;
Find.WorldObjects.Add(o: destroyedSettlement);
Find.WorldObjects.Remove(o: someRandomPreferablyNearbySettlement);
return("MFI_FactionWarBaseDestroyed".Translate(loserFaction, loserFaction.EnemyInFactionWar()));
}
public static void Postfix(IncidentWorker_RaidEnemy __instance, ref IncidentParms parms, bool __result)
{
if (__result)
{
if (parms.faction.def == XenomorphDefOf.RRY_Xenomorph && parms.raidStrategy != XenomorphDefOf.RRY_PowerCut)
{
Map map = (Map)parms.target;
if (map.listerBuildings.allBuildingsColonist.Any(x => x.TryGetComp <CompPowerPlant>() != null))
{
Rand.PushState();
int @int = Rand.Int;
bool chance = Rand.ChanceSeeded(0.1f, @int);
Rand.PopState();
if (AvP_IncidentWorker_RaidEnemy_TryExecute_PowerCut_Patch.TryFindSpawnSpot(map, out IntVec3 intVec) && chance)
{
IncidentParms raidParms = StorytellerUtility.DefaultParmsNow(IncidentCategoryDefOf.ThreatBig, map);
raidParms.forced = true;
raidParms.faction = parms.faction;
raidParms.raidStrategy = XenomorphDefOf.RRY_PowerCut;
raidParms.raidArrivalMode = XenomorphDefOf.RRY_DropThroughRoofNearPower;
raidParms.spawnCenter = intVec;
raidParms.generateFightersOnly = true;
Rand.PushState();
raidParms.points = Mathf.Max((raidParms.points / 5) * AvP_IncidentWorker_RaidEnemy_TryExecute_PowerCut_Patch.RaidPointsFactorRange.RandomInRange, 500f);
Rand.PopState();
raidParms.pawnGroupMakerSeed = new int?(@int);
PawnGroupMakerParms defaultPawnGroupMakerParms = IncidentParmsUtility.GetDefaultPawnGroupMakerParms(PawnGroupKindDefOf.Combat, raidParms, true);
defaultPawnGroupMakerParms.points = IncidentWorker_Raid.AdjustedRaidPoints(defaultPawnGroupMakerParms.points, XenomorphDefOf.RRY_DropThroughRoofNearPower, XenomorphDefOf.RRY_PowerCut, defaultPawnGroupMakerParms.faction, PawnGroupKindDefOf.Combat);
IEnumerable <PawnKindDef> pawnKinds = PawnGroupMakerUtility.GeneratePawnKindsExample(defaultPawnGroupMakerParms);
QueuedIncident qi = new QueuedIncident(new FiringIncident(XenomorphDefOf.RRY_PowerCut_Xenomorph, null, raidParms), Find.TickManager.TicksGame + AvP_IncidentWorker_RaidEnemy_TryExecute_PowerCut_Patch.RaidDelay.RandomInRange, 0);
Find.Storyteller.incidentQueue.Add(qi);
}
}
}
}
}
// Token: 0x06000D17 RID: 3351 RVA: 0x00061114 File Offset: 0x0005F514
protected override bool TryExecuteWorker(IncidentParms parms)
{
Faction zFaction = Faction.OfInsects;
foreach (Faction faction in Find.FactionManager.AllFactionsListForReading)
{
if (faction.def.defName == "Zombie")
{
zFaction = faction;
}
}
ResolveRaidPoints(parms);
Map map = (Map)parms.target;
PawnKindDef pawnKindDef;
if (!TryFindAnimalKind(parms.points, map.Tile, out pawnKindDef))
{
return(false);
}
IntVec3 intVec;
if (!RCellFinder.TryFindRandomPawnEntryCell(out intVec, map, CellFinder.EdgeRoadChance_Animal))
{
return(false);
}
//List<Pawn> list = ManhunterPackIncidentUtility.GenerateAnimals(pawnKindDef, map.Tile, parms.points);
Rot4 rot = Rot4.FromAngleFlat((map.Center - intVec).AngleFlat);
Pawn reference = null;
int num = (int)(parms.points / 100f);
if (num < 2)
{
num = 2;
}
for (int i = 0; i < num; i++)
{
TryFindAnimalKind(parms.points, map.Tile, out pawnKindDef);
if (pawnKindDef.RaceProps.baseBodySize > 4f && Rand.ChanceSeeded(0.5f, Find.TickManager.TicksAbs + i))
{
TryFindAnimalKind(parms.points, map.Tile, out pawnKindDef);
}
Pawn pawn = PawnGenerator.GeneratePawn(pawnKindDef, zFaction);
IntVec3 loc = CellFinder.RandomClosewalkCellNear(intVec, map, 10, null);
pawn.apparel.DestroyAll();
//pawn.SetFactionDirect(zFaction);
Pawn_Zombiefied zomb = (Pawn_Zombiefied)GenSpawn.Spawn(pawn, loc, map, rot, WipeMode.Vanish, false);
if (zomb != null)
{
zomb.FixZombie();
}
reference = pawn;
}
if (ZombiefiedMod.zombieRaidNotifications)
{
Find.LetterStack.ReceiveLetter("Zombies", "Some zombies walked into your territory. You might want to deal with them before they deal with you."
, LetterDefOf.NeutralEvent, reference, null);
Find.TickManager.slower.SignalForceNormalSpeedShort();
}
LessonAutoActivator.TeachOpportunity(ConceptDefOf.ForbiddingDoors, OpportunityType.Critical);
LessonAutoActivator.TeachOpportunity(ConceptDefOf.AllowedAreas, OpportunityType.Important);
return(true);
}
// Token: 0x06000E1C RID: 3612 RVA: 0x00069B78 File Offset: 0x00067F78
protected override bool TryExecuteWorker(IncidentParms parms)
{
/*
* GameConditionManager gameConditionManager = parms.target.GameConditionManager;
* int duration = Mathf.RoundToInt(this.def.durationDays.RandomInRange * 60000f);
* GameCondition cond = GameConditionMaker.MakeCondition(this.def.gameCondition, duration, 0);
* gameConditionManager.RegisterCondition(cond);
*/
Map map = (Map)parms.target;
IntVec3 spawnSpot;
if (!this.TryFindSpawnSpot(map, out spawnSpot))
{
return(false);
}
Faction faction = Find.FactionManager.FirstFactionOfDef(XenomorphDefOf.RRY_Xenomorph);
if (faction == null)
{
return(false);
}
int @int = Rand.Int;
IncidentParms raidParms = StorytellerUtility.DefaultParmsNow(IncidentCategoryDefOf.ThreatBig, map);
raidParms.forced = true;
raidParms.faction = faction;
raidParms.raidStrategy = RaidStrategyDefOf.ImmediateAttack;
raidParms.raidArrivalMode = PawnsArrivalModeDefOf.EdgeWalkIn;
raidParms.spawnCenter = spawnSpot;
raidParms.generateFightersOnly = true;
raidParms.points = Mathf.Max(raidParms.points * IncidentWorker_PowerCutV2.RaidPointsFactorRange.RandomInRange, faction.def.MinPointsToGeneratePawnGroup(PawnGroupKindDefOf.Combat));
raidParms.pawnGroupMakerSeed = new int?(@int);
PawnGroupMakerParms defaultPawnGroupMakerParms = IncidentParmsUtility.GetDefaultPawnGroupMakerParms(PawnGroupKindDefOf.Combat, raidParms, false);
defaultPawnGroupMakerParms.points = IncidentWorker_Raid.AdjustedRaidPoints(defaultPawnGroupMakerParms.points, raidParms.raidArrivalMode, raidParms.raidStrategy, defaultPawnGroupMakerParms.faction, PawnGroupKindDefOf.Combat);
IEnumerable <PawnKindDef> pawnKinds = PawnGroupMakerUtility.GeneratePawnKindsExample(defaultPawnGroupMakerParms);
base.SendStandardLetter();
QueuedIncident qi = new QueuedIncident(new FiringIncident(IncidentDefOf.RaidEnemy, null, raidParms), 0, 0);
Find.Storyteller.incidentQueue.Add(qi);
@int = Rand.Int;
if (!this.TryFindSpawnSpot(map, out spawnSpot))
{
return(false);
}
raidParms = StorytellerUtility.DefaultParmsNow(IncidentCategoryDefOf.ThreatBig, map);
raidParms.forced = true;
raidParms.faction = faction;
raidParms.raidStrategy = RaidStrategyDefOf.ImmediateAttack;
raidParms.raidArrivalMode = PawnsArrivalModeDefOf.EdgeWalkIn;
raidParms.spawnCenter = spawnSpot;
raidParms.generateFightersOnly = true;
raidParms.points = Mathf.Max(raidParms.points * IncidentWorker_PowerCutV2.RaidPointsFactorRange.RandomInRange, faction.def.MinPointsToGeneratePawnGroup(PawnGroupKindDefOf.Combat));
raidParms.pawnGroupMakerSeed = new int?(@int);
defaultPawnGroupMakerParms = IncidentParmsUtility.GetDefaultPawnGroupMakerParms(PawnGroupKindDefOf.Combat, raidParms, false);
defaultPawnGroupMakerParms.points = IncidentWorker_Raid.AdjustedRaidPoints(defaultPawnGroupMakerParms.points, raidParms.raidArrivalMode, raidParms.raidStrategy, defaultPawnGroupMakerParms.faction, PawnGroupKindDefOf.Combat);
pawnKinds = PawnGroupMakerUtility.GeneratePawnKindsExample(defaultPawnGroupMakerParms);
base.SendStandardLetter();
/*
* qi = new QueuedIncident(new FiringIncident(IncidentDefOf.RaidEnemy, null, raidParms), Find.TickManager.TicksGame + IncidentWorker_PowerCutV2.RaidDelay.RandomInRange, 0);
* Find.Storyteller.incidentQueue.Add(qi);
*/
List <Building> list = map.listerBuildings.allBuildingsColonist.FindAll(x => x.TryGetComp <CompPowerPlant>() != null);
float chance = 1f;
foreach (var item in list.OrderBy(x => x.TryGetComp <CompPowerPlant>().EnergyOutputPerTick))
{
CompPowerPlant powerPlant = item.TryGetComp <CompPowerPlant>();
if (powerPlant != null)
{
CompBreakdownable breakdownable = item.TryGetComp <CompBreakdownable>();
if (Rand.ChanceSeeded(chance, AvPConstants.AvPSeed))
{
if (breakdownable != null)
{
breakdownable.DoBreakdown();
chance -= 0.00001f * powerPlant.PowerOutput;
}
else
{
}
chance -= 0.05f;
}
}
}
/*
* DiaNode diaNode = new DiaNode(text);
* DiaOption diaOption = new DiaOption("RefugeeChasedInitial_Accept".Translate());
* diaOption.action = delegate ()
* {
* QueuedIncident qi = new QueuedIncident(new FiringIncident(IncidentDefOf.RaidEnemy, null, raidParms), Find.TickManager.TicksGame + IncidentWorker_PowerCut.RaidDelay.RandomInRange, 0);
* Find.Storyteller.incidentQueue.Add(qi);
* };
* diaOption.resolveTree = true;
* diaNode.options.Add(diaOption);
* string text2 = "RefugeeChasedRejected".Translate(refugee.LabelShort, refugee);
* DiaNode diaNode2 = new DiaNode(text2);
* DiaOption diaOption2 = new DiaOption("OK".Translate());
* diaOption2.resolveTree = true;
* diaNode2.options.Add(diaOption2);
* DiaOption diaOption3 = new DiaOption("RefugeeChasedInitial_Reject".Translate());
* diaOption3.action = delegate ()
* {
* Find.WorldPawns.PassToWorld(refugee, PawnDiscardDecideMode.Decide);
* };
* diaOption3.link = diaNode2;
* diaNode.options.Add(diaOption3);
* string title = "RefugeeChasedTitle".Translate(map.Parent.Label);
* Find.WindowStack.Add(new Dialog_NodeTreeWithFactionInfo(diaNode, faction, true, true, title));
* Find.Archive.Add(new ArchivedDialog(diaNode.text, title, faction));
*/
return(true);
}
public static void TryGenerateWeaponFor(Pawn pawn)
{
workingWeapons.Clear();
if (pawn.kindDef.weaponTags != null && pawn.kindDef.weaponTags.Count != 0 && pawn.RaceProps.ToolUser && pawn.health.capacities.CapableOf(PawnCapacityDefOf.Manipulation) && (pawn.story == null || !pawn.story.WorkTagIsDisabled(WorkTags.Violent)))
{
float randomInRange = pawn.kindDef.weaponMoney.RandomInRange;
for (int i = 0; i < allWeaponPairs.Count; i++)
{
ThingStuffPair w2 = allWeaponPairs[i];
if (!(w2.Price > randomInRange) && (pawn.kindDef.weaponTags == null || pawn.kindDef.weaponTags.Any((string tag) => w2.thing.weaponTags.Contains(tag))) && (!(w2.thing.generateAllowChance < 1f) || Rand.ChanceSeeded(w2.thing.generateAllowChance, pawn.thingIDNumber ^ w2.thing.shortHash ^ 0x1B3B648)))
{
workingWeapons.Add(w2);
}
}
if (workingWeapons.Count != 0)
{
pawn.equipment.DestroyAllEquipment();
if (workingWeapons.TryRandomElementByWeight((ThingStuffPair w) => w.Commonality * w.Price, out ThingStuffPair result))
{
ThingWithComps thingWithComps = (ThingWithComps)ThingMaker.MakeThing(result.thing, result.stuff);
PawnGenerator.PostProcessGeneratedGear(thingWithComps, pawn);
pawn.equipment.AddEquipment(thingWithComps);
}
workingWeapons.Clear();
}
}
}
// Token: 0x060029C1 RID: 10689 RVA: 0x0013C434 File Offset: 0x0013A834
private void TryExpandHive()
{
if (this.snowNoise == null)
{
this.snowNoise = new Perlin(5.074999999701976776, 2.0, 0.5, 5, Rand.Range(0, 651431), QualityMode.Medium); //new Perlin(0.054999999701976776, 2.0, 0.5, 5, Rand.Range(0, 651431), QualityMode.Medium);
}
if (this.hiveRadius < 8f)
{
this.hiveRadius += 1.3f;
}
else if (this.hiveRadius < 17f)
{
this.hiveRadius += 0.7f;
}
else if (this.hiveRadius < 30f)
{
this.hiveRadius += 0.4f;
}
else
{
this.hiveRadius += 0.1f;
}
this.hiveRadius = this.maxRadius; // Mathf.Min(this.hiveRadius, this.maxRadius);
CellRect occupiedRect = this.parent.OccupiedRect();
CompHiveCreep.reachableCells.Clear();
// Log.Message(string.Format("1"));
this.parent.Map.floodFiller.FloodFill(this.parent.Position, (IntVec3 x) => (float)x.DistanceToSquared(this.parent.Position) <= this.hiveRadius * this.hiveRadius && (occupiedRect.Contains(x) || !x.Filled(this.parent.Map) && x.InBounds(this.parent.Map) && x.Roofed(this.parent.Map)), delegate(IntVec3 x)
{
CompHiveCreep.reachableCells.Add(x);
}, int.MaxValue, false, null);
// Log.Message(string.Format("2")); errors here V
int num = GenRadial.NumCellsInRadius(this.hiveRadius);
// Log.Message(string.Format("3")); errors here ^
for (int i = 0; i < num; i++)
{
// Log.Message(string.Format("3 {0} a", i), true);
if ((this.parent.Position + GenRadial.RadialPattern[i]).InBounds(this.parent.Map))
{
IntVec3 intVec = this.parent.Position + GenRadial.RadialPattern[i];
if (intVec.InBounds(this.parent.Map))
{
// if (i % 50 == 0) Log.Message(string.Format("3 {0} b", i), true);
if (CompHiveCreep.reachableCells.Contains(intVec))
{
List <Thing> list = intVec.GetThingList(parent.Map);
if (!list.NullOrEmpty())
{
if (list.Any(x => x.def.IsFilth))
{
foreach (var item in list.FindAll(x => x.def.IsFilth))
{
if (Rand.ChanceSeeded(0.25f, AvPConstants.AvPSeed))
{
item.Destroy();
}
}
}
}
// Log.Message(string.Format("3 {0} c", i));
float num2 = 1f;
num2 += 1f;
num2 *= 0.5f;
if (num2 < 0.1f)
{
num2 = 0.1f;
}
if (this.parent.Map.GetComponent <MapComponent_HiveGrid>().GetDepth(intVec) <= num2)
{
// Log.Message(string.Format("3 {0} d", i));
float lengthHorizontal = (intVec - this.parent.Position).LengthHorizontal;
float num3 = 1f - lengthHorizontal / this.hiveRadius;
this.parent.Map.GetComponent <MapComponent_HiveGrid>().AddDepth(intVec, num3 * this.Props.addAmount * num2);
// Log.Message(string.Format("3 {0} e", i));
}
}
}
}
}
}
public static void TryGenerateShieldFor(Pawn pawn)
{
workingShields.Clear();
var kindDefExtension = PawnKindDefExtension.Get(pawn.kindDef);
// No shieldTags
if (kindDefExtension.shieldTags.NullOrEmpty())
{
return;
}
// Not a tool user
if (!pawn.RaceProps.ToolUser)
{
return;
}
// Primary unusable with shields
if (pawn.equipment.Primary is ThingWithComps primary && !primary.def.UsableWithShields())
{
return;
}
// Has multiple weapons
if (pawn.equipment.AllEquipmentListForReading.Count(t => t.def.equipmentType == EquipmentType.Primary) > 1)
{
return;
}
// Not enough manipulation
if (!pawn.health.capacities.CapableOf(PawnCapacityDefOf.Manipulation) || !pawn.CanUseShields())
{
return;
}
// Pacifist
if (pawn.story != null && pawn.WorkTagIsDisabled(WorkTags.Violent))
{
return;
}
float randomInRange = kindDefExtension.shieldMoney.RandomInRange;
for (int i = 0; i < allShieldPairs.Count; i++)
{
ThingStuffPair w = allShieldPairs[i];
if (w.Price <= randomInRange)
{
var shieldProps = w.thing.GetCompProperties <CompProperties_Shield>();
if (kindDefExtension.shieldTags == null || kindDefExtension.shieldTags.Any((string tag) => shieldProps.shieldTags.Contains(tag)))
{
if (w.thing.generateAllowChance >= 1f || Rand.ChanceSeeded(w.thing.generateAllowChance, pawn.thingIDNumber ^ (int)w.thing.shortHash ^ 28554824))
{
workingShields.Add(w);
}
}
}
}
if (workingShields.Count == 0)
{
return;
}
//pawn.equipment.DestroyAllEquipment(DestroyMode.Vanish);
ThingStuffPair thingStuffPair;
if (workingShields.TryRandomElementByWeight((ThingStuffPair w) => w.Commonality * w.Price, out thingStuffPair))
{
var shield = (Apparel)ThingMaker.MakeThing(thingStuffPair.thing, thingStuffPair.stuff);
PawnGenerator.PostProcessGeneratedGear(shield, pawn);
// Colour the shield
if (pawn.Faction != null)
{
var thingDefExtension = ThingDefExtension.Get(thingStuffPair.thing);
if (!thingDefExtension.useFactionColourForPawnKinds.NullOrEmpty() && thingDefExtension.useFactionColourForPawnKinds.Contains(pawn.kindDef))
{
shield.SetColor(pawn.Faction.Color);
}
}
pawn.AddShield(shield);
}
workingShields.Clear();
}
public static void TryGenerateWeaponFor(Pawn pawn, PawnGenerationRequest request)
{
workingWeapons.Clear();
if (pawn.kindDef.weaponTags == null || pawn.kindDef.weaponTags.Count == 0 || !pawn.RaceProps.ToolUser || !pawn.health.capacities.CapableOf(PawnCapacityDefOf.Manipulation) || pawn.WorkTagIsDisabled(WorkTags.Violent))
{
return;
}
float randomInRange = pawn.kindDef.weaponMoney.RandomInRange;
for (int i = 0; i < allWeaponPairs.Count; i++)
{
ThingStuffPair w2 = allWeaponPairs[i];
if (!(w2.Price > randomInRange) && (pawn.kindDef.weaponTags == null || pawn.kindDef.weaponTags.Any((string tag) => w2.thing.weaponTags.Contains(tag))) && (!(w2.thing.generateAllowChance < 1f) || Rand.ChanceSeeded(w2.thing.generateAllowChance, pawn.thingIDNumber ^ w2.thing.shortHash ^ 0x1B3B648)))
{
workingWeapons.Add(w2);
}
}
if (workingWeapons.Count == 0)
{
return;
}
pawn.equipment.DestroyAllEquipment();
if (workingWeapons.TryRandomElementByWeight((ThingStuffPair w) => w.Commonality * w.Price, out var result))
{
ThingWithComps thingWithComps = (ThingWithComps)ThingMaker.MakeThing(result.thing, result.stuff);
PawnGenerator.PostProcessGeneratedGear(thingWithComps, pawn);
float num = ((request.BiocodeWeaponChance > 0f) ? request.BiocodeWeaponChance : pawn.kindDef.biocodeWeaponChance);
if (Rand.Value < num)
{
thingWithComps.TryGetComp <CompBiocodableWeapon>()?.CodeFor(pawn);
}
pawn.equipment.AddEquipment(thingWithComps);
}
workingWeapons.Clear();
}
