public override void ResolveRaidStrategy(IncidentParms parms, PawnGroupKindDef groupKind)
{
if (parms.raidStrategy == null)
{
Map map = (Map)parms.target;
DefDatabase <RaidStrategyDef> .AllDefs.Where(delegate(RaidStrategyDef d)
{
if (d.Worker.CanUseWith(parms, groupKind))
{
if (parms.raidArrivalMode == null)
{
if (d.arriveModes != null)
{
return(d.arriveModes.Any((PawnsArrivalModeDef x) => x.Worker.CanUseWith(parms)));
}
return(false);
}
return(true);
}
return(false);
}).TryRandomElementByWeight((RaidStrategyDef d) => d.Worker.SelectionWeight(map, parms.points), out RaidStrategyDef result);
parms.raidStrategy = result;
if (parms.raidStrategy == null)
{
Log.Error("No raid stategy found, defaulting to ImmediateAttack. Faction=" + parms.faction.def.defName + ", points=" + parms.points + ", groupKind=" + groupKind + ", parms=" + parms);
parms.raidStrategy = RaidStrategyDefOf.ImmediateAttack;
}
}
}
public static List <Pawn> GenerateRaidPawns(IncidentParms parms)
{
if (PES_Settings.DebugModeOn)
{
Log.Message("-=PS=- GenerateRaidPawns Start", false);
}
if (parms != null && parms.questTag != null) //Lt. Bob - "Temporary" bypass fix? for Quest handling
{
Log.Message("-=PS=- GenerateRaidPawns - questTag!=Null == " + parms.questTag);
}
IsIntercepting_PawnGeneration = GeneratorPatchFlag.Generate;
PawnGroupKindDef combat = PawnGroupKindDefOf.Combat;
parms.points = IncidentWorker_Raid.AdjustedRaidPoints(parms.points, parms.raidArrivalMode, parms.raidStrategy, parms.faction, combat);
PawnGroupMakerParms defaultPawnGroupMakerParms = IncidentParmsUtility.GetDefaultPawnGroupMakerParms(combat, parms, false);
List <Pawn> list = PawnGroupMakerUtility.GeneratePawns(defaultPawnGroupMakerParms, true).ToList <Pawn>();
if (list.Count == 0)
{
Log.Error("Got no pawns spawning raid from parms " + parms, false);
}
return(list);
}
public override bool CanUseWith(IncidentParms parms, PawnGroupKindDef groupKind)
{
CGO.fallingStructure = this.def.GetModExtension <FallingStructure>();
if (CGO.fallingStructure.needToHaveSettlements && !Find.World.worldObjects.Settlements.FindAll(s => s.Faction == parms.faction).Any())
{
return(false);
}
if (CGO.fallingStructure.canBeUsedBy.Contains(parms.faction.def))
{
CGO.fallingStructureChoosen = LayoutUtils.ChooseWeightedStruct(CGO.fallingStructure.WeightedStructs, parms).structureLayoutDef;
if (CGO.fallingStructureChoosen != null)
{
RectUtils.HeightWidthFromLayout(CGO.fallingStructureChoosen, out int h, out int w);
return(parms.points >= this.MinimumPoints(parms.faction, groupKind) && this.FindRect((Map)parms.target, h, w) != IntVec3.Invalid);
}
else
{
return(false);
}
}
else
{
return(false);
}
}
public override void ResolveRaidStrategy(IncidentParms parms, PawnGroupKindDef groupKind)
{
var map = (Map)parms.target;
if (map.Biome != Util_CaveBiome.CaveBiomeDef)
{
base.ResolveRaidStrategy(parms, groupKind);
return;
}
if (Rand.Bool)
{
if (Rand.Bool)
{
parms.raidStrategy = RaidStrategyDefOf.ImmediateAttack;
}
else
{
parms.raidStrategy = DefDatabase <RaidStrategyDef> .GetNamedSilentFail("ImmediateAttackSmart");
}
}
else
{
parms.raidStrategy = DefDatabase <RaidStrategyDef> .GetNamedSilentFail("StageThenAttack");
}
}
public override void ResolveRaidStrategy(IncidentParms parms, PawnGroupKindDef groupKind)
{
if (parms.raidStrategy == null)
{
Map map = (Map)parms.target;
if (!(from d in DefDatabase <RaidStrategyDef> .AllDefs
where d.Worker.CanUseWith(parms, groupKind) &&
(parms.raidArrivalMode != null ||
(d.arriveModes != null &&
d.arriveModes.Any((PawnsArrivalModeDef x) => x.Worker.CanUseWith(parms))))
select d).TryRandomElementByWeight(
(RaidStrategyDef d) => d.Worker.SelectionWeight(map, parms.points), out parms.raidStrategy))
{
Log.Error(string.Concat(new object[]
{
"No raid stategy for ",
parms.faction,
" with points ",
parms.points,
", groupKind=",
groupKind,
"\nparms=",
parms
}), false);
if (!Prefs.DevMode)
{
parms.raidStrategy = RaidStrategyDefOf.ImmediateAttack;
}
}
}
}
public override void ResolveReferences(ThingDef parentDef)
{
base.ResolveReferences(parentDef);
if (factionGroupKindDef == null)
{
factionGroupKindDef = PawnGroupKindDefOf.Combat;
}
}
public override void ResolveReferences(ThingDef parentDef)
{
base.ResolveReferences(parentDef);
if (factionGroupKindDef == null)
{
factionGroupKindDef = PawnGroupKindDefOf.Hive_OgsOld_ExtraHives;
}
}
protected override void ResolveRaidStrategy(IncidentParms parms, PawnGroupKindDef groupKind)
{
if (parms.raidStrategy != null)
{
return;
}
parms.raidStrategy = RaidStrategyDefOf.ImmediateAttack;
}
public static List <Pawn> GenerateNeutralPawns(PawnGroupKindDef pawnGroupKind, IncidentParms parms)
{
IsIntercepting_PawnGeneration = GeneratorPatchFlag.Generate;
PawnGroupMakerParms defaultPawnGroupMakerParms = IncidentParmsUtility.GetDefaultPawnGroupMakerParms(pawnGroupKind, parms, true);
List <Pawn> list = PawnGroupMakerUtility.GeneratePawns(defaultPawnGroupMakerParms, false).ToList <Pawn>();
return(list);
}
//public class PawnGroupMakerUtility
//{
public static void GeneratePawns(PawnGroupKindDef groupKind, PawnGroupMakerParms parms,
bool warnOnZeroResults, ref IEnumerable <Pawn> __result)
{
if (__result?.Count() > 0 &&
parms.faction.def.GetModExtension <FactionSettings>() is FactionSettings settings)
{
settings.entrySoundDef?.PlayOneShotOnCamera();
}
}
public override bool CanUseWith(IncidentParms parms, PawnGroupKindDef groupKind)
{
if (!base.CanUseWith(parms, groupKind))
{
return(false);
}
if (parms.faction != null)
{
return(!parms.faction.HostileTo(Faction.OfPlayer));
}
return(false);
}
public override void ResolveRaidStrategy(IncidentParms parms, PawnGroupKindDef groupKind)
{
if (IncidentDefExtension.forcedStrategy == null)
{
base.ResolveRaidStrategy(parms, groupKind);
}
else
{
parms.raidStrategy = IncidentDefExtension.forcedStrategy;
}
}
public override bool CanUseWith(IncidentParms parms, PawnGroupKindDef groupKind)
{
if (!PawnGenOptionsWithLockpickers(parms.faction, groupKind).Any())
{
return(false);
}
if (!base.CanUseWith(parms, groupKind))
{
return(false);
}
return(true);
}
public override void ResolveRaidStrategy(IncidentParms parms, PawnGroupKindDef groupKind)
{
parms.raidStrategy = VehicleRaidStrategyDefOf.ArmoredAttack;
return;
if (parms.raidStrategy != null)
{
return;
}
Map map = (Map)parms.target;
Predicate <PawnsArrivalModeDef> validator;
RaidStrategyDef raidStrategy;
DefDatabase <RaidStrategyDef> .AllDefs.Where(delegate(RaidStrategyDef d)
{
if (!d.Worker.CanUseWith(parms, groupKind))
{
return(false);
}
if (parms.raidArrivalMode != null)
{
return(true);
}
if (d.arriveModes != null)
{
List <PawnsArrivalModeDef> arriveModes = d.arriveModes;
Predicate <PawnsArrivalModeDef> validator2;
if ((validator2 = validator) == null)
{
validator2 = (validator = ((PawnsArrivalModeDef x) => x.Worker.CanUseWith(parms)));
}
return(arriveModes.Any(validator2));
}
return(false);
}).TryRandomElementByWeight((RaidStrategyDef d) => d.Worker.SelectionWeight(map, parms.points), out raidStrategy);
parms.raidStrategy = raidStrategy;
if (parms.raidStrategy == null)
{
Log.Error(string.Concat(new object[]
{
"No raid stategy found, defaulting to ImmediateAttack. Faction=",
parms.faction.def.defName,
", points=",
parms.points,
", groupKind=",
groupKind,
", parms=",
parms
}));
parms.raidStrategy = RaidStrategyDefOf.ImmediateAttack;
}
}
public static List <Pawn> GenerateBoatsForIncident(IncidentParms parms, PawnGroupKindDef group, ref List <Pawn> pawns)
{
List <Pawn> ships = new List <Pawn>();
if (group == PawnGroupKindDefOf.Trader)
{
float pointsToSpend = parms.points;
int colonistsToHouse = pawns.Count;
List <PawnKindDef> kindDefs = DefDatabase <PawnKindDef> .AllDefs.Where(x => x.race.HasComp(typeof(CompShips)) && parms.faction.def.techLevel >= x.race.GetCompProperties <CompProperties_Ships>().shipTech).ToList();
kindDefs.OrderByDescending(x => x.combatPower).ThenBy(x => x.race.GetCompProperties <CompProperties_Ships>().shipCategory);
int i = 0;
kindDefs.RemoveAll(x => x.combatPower > parms.points);
while (pointsToSpend > 0 && i < kindDefs.Count)
{
PawnKindDef t = kindDefs[i];
if (t.race.GetCompProperties <CompProperties_Ships>().shipCategory <= ShipCategory.Trader)
{
int pawnCount = 0;
int pawnCountOperate = 0;
foreach (ShipRole r in t.race.GetCompProperties <CompProperties_Ships>().roles)
{
if (r.handlingType == HandlingTypeFlags.Movement)
{
pawnCountOperate += r.slotsToOperate;
}
pawnCount += r.slots;
}
if (colonistsToHouse < pawnCountOperate)
{
i++;
continue;
}
colonistsToHouse -= pawnCount;
pointsToSpend -= t.combatPower;
Pawn p = PawnGenerator.GeneratePawn(t, parms.faction);
ships.Add(p);
if (colonistsToHouse <= 0)
{
return(ships);
}
}
else
{
i++;
}
}
}
return(ships);
}
protected override void ResolveRaidStrategy(IncidentParms parms, PawnGroupKindDef groupKind)
{
try {
base.ResolveRaidStrategy(parms, groupKind);
Pawn mole = MapComponent_Tenants.GetComponent((Map)parms.target).Moles[0];
if (mole.GetTenantComponent().HiddenFaction.def.techLevel >= TechLevel.Spacer && Rand.Value < 0.5f)
{
parms.raidArrivalMode = PawnsArrivalModeDefOf.CenterDrop;
}
}
catch (System.Exception) {
base.ResolveRaidStrategy(parms, groupKind);
}
}
private List <Pawn> SpawnRaid(IncidentParms parms, out List <TargetInfo> targetInfos)
{
PawnGroupKindDef combat = PawnGroupKindDefOf.Combat;
parms.raidStrategy.Worker.TryGenerateThreats(parms);
List <Pawn> list = parms.raidStrategy.Worker.SpawnThreats(parms);
if (list == null)
{
list = PawnGroupMakerUtility.GeneratePawns(IncidentParmsUtility.GetDefaultPawnGroupMakerParms(combat, parms)).ToList();
if (list.Count == 0)
{
Log.Error("Got no pawns spawning raid from parms " + parms);
targetInfos = null;
return(list);
}
parms.raidArrivalMode.Worker.Arrive(list, parms);
}
List <TargetInfo> list2 = new List <TargetInfo>();
if (parms.pawnGroups != null)
{
List <List <Pawn> > list3 = IncidentParmsUtility.SplitIntoGroups(list, parms.pawnGroups);
List <Pawn> list4 = list3.MaxBy((List <Pawn> x) => x.Count);
if (list4.Any())
{
list2.Add(list4[0]);
}
for (int i = 0; i < list3.Count; i++)
{
if (list3[i] != list4 && list3[i].Any())
{
list2.Add(list3[i][0]);
}
}
}
else if (list.Any())
{
foreach (Pawn item in list)
{
list2.Add(item);
}
}
parms.raidStrategy.Worker.MakeLords(parms, list);
targetInfos = list2;
return(list);
}
public static List <Pawn> GenerateRaidPawns(IncidentParms parms)
{
IsIntercepting_PawnGeneration = GeneratorPatchFlag.Generate;
PawnGroupKindDef combat = PawnGroupKindDefOf.Combat;
parms.points = IncidentWorker_Raid.AdjustedRaidPoints(parms.points, parms.raidArrivalMode, parms.raidStrategy, parms.faction, combat);
PawnGroupMakerParms defaultPawnGroupMakerParms = IncidentParmsUtility.GetDefaultPawnGroupMakerParms(combat, parms, false);
List <Pawn> list = PawnGroupMakerUtility.GeneratePawns(defaultPawnGroupMakerParms, true).ToList <Pawn>();
if (list.Count == 0)
{
Log.Error("Got no pawns spawning raid from parms " + parms, false);
}
return(list);
}
public static void Prefix(ref PawnGroupKindDef groupKind, ref IncidentParms parms)
{
if (parms.target is Map && (parms.target as Map).IsPlayerHome)
{
if (parms.faction != null && (parms.faction.def.defName.Contains("MuvLuv_BETA")))
{
if ((parms.target is Map map))
{
if (parms.raidArrivalMode.defName.Contains("TunnelIn"))
{
groupKind = OgsOld_ExtraHives.PawnGroupKindDefOf.Tunneler_OgsOld_ExtraHives;
}
}
}
}
}
public override void ResolveRaidStrategy(IncidentParms parms, PawnGroupKindDef groupKind)
{
if (parms.raidStrategy != null)
{
return;
}
Map map = (Map)parms.target;
DefDatabase <RaidStrategyDef> .AllDefs.Where((RaidStrategyDef d) => d.Worker.CanUseWith(parms, groupKind) && (parms.raidArrivalMode != null || (d.arriveModes != null && d.arriveModes.Any((PawnsArrivalModeDef x) => x.Worker.CanUseWith(parms))))).TryRandomElementByWeight((RaidStrategyDef d) => d.Worker.SelectionWeight(map, parms.points), out var result);
parms.raidStrategy = result;
if (parms.raidStrategy == null)
{
Log.Error(string.Concat("No raid stategy found, defaulting to ImmediateAttack. Faction=", parms.faction.def.defName, ", points=", parms.points, ", groupKind=", groupKind, ", parms=", parms));
parms.raidStrategy = RaidStrategyDefOf.ImmediateAttack;
}
}
public override void ResolveRaidStrategy(IncidentParms parms, PawnGroupKindDef groupKind)
{
if (parms.raidStrategy != null)
{
return;
}
var map = (Map)parms.target;
if (!(from d in DefDatabase <RaidStrategyDef> .AllDefs where d.Worker.CanUseWith(parms: parms, groupKind: groupKind) select d)
.TryRandomElementByWeight(
weightSelector: d => d.Worker.SelectionWeight(map: map, basePoints: parms.points),
result: out parms.raidStrategy
))
{
parms.raidStrategy = RaidStrategyDefOf.ImmediateAttack;
}
}
public static List <Pawn> GenerateNeutralPawns(PawnGroupKindDef pawnGroupKind, IncidentParms parms)
{
if (PES_Settings.DebugModeOn)
{
Log.Message("-=PS=- GenerateNeutralPawns Start", false);
}
if (parms != null && parms.questTag != null) //Lt. Bob - "Temporary" bypass fix? for Quest handling
{
Log.Message("-=PS=- GenerateNeutralPawns - questTag!=Null == " + parms.questTag);
}
IsIntercepting_PawnGeneration = GeneratorPatchFlag.Generate;
PawnGroupMakerParms defaultPawnGroupMakerParms = IncidentParmsUtility.GetDefaultPawnGroupMakerParms(pawnGroupKind, parms, true);
List <Pawn> list = PawnGroupMakerUtility.GeneratePawns(defaultPawnGroupMakerParms, false).ToList <Pawn>();
return(list);
}
public static void ResolveRaidStrategy(IncidentParms parms, PawnGroupKindDef groupKind)
{
if (parms.raidStrategy != null)
{
return;
}
Map map = (Map)parms.target;
if (!(from d in DefDatabase <RaidStrategyDef> .AllDefs
where d.Worker.CanUseWith(parms, groupKind) && (parms.raidArrivalMode != null || (d.arriveModes != null && d.arriveModes.Any((PawnsArrivalModeDef x) => x.Worker.CanUseWith(parms))))
select d).TryRandomElementByWeight((RaidStrategyDef d) => d.Worker.SelectionWeight(map, parms.points), out parms.raidStrategy))
{
Log.Error("No raid stategy for " + parms.faction + " with points " + parms.points + ", groupKind=" + groupKind + "\nparms=" + parms);
if (!Prefs.DevMode)
{
parms.raidStrategy = RaidStrategyDefOf.ImmediateAttack;
}
}
}
public static void Postfix(IncidentParms parms, PawnGroupKindDef groupKind)
{
Map map = (Map)parms.target;
Faction fac = parms.faction;
if (fac.def.GetModExtension <FactionDefExtension>() is FactionDefExtension ext && ext != null && ext.allowedStrategies?.Count > 0)
{
DefDatabase <RaidStrategyDef> .AllDefs.Where(d => d.Worker.CanUseWith(parms, groupKind) && ext.allowedStrategies.Contains(d) && d.arriveModes != null && d.arriveModes.Any(x => x.Worker.CanUseWith(parms)))
.TryRandomElementByWeight(d => d.Worker.SelectionWeight(map, parms.points), out RaidStrategyDef result);
parms.raidStrategy = result;
if (parms.raidStrategy != null)
{
return;
}
Log.Error("No raid stategy found, defaulting to ImmediateAttack. Faction=" + parms.faction.def.defName + ", points=" + parms.points + ", groupKind=" + groupKind + ", parms=" + parms);
parms.raidStrategy = RaidStrategyDefOf.ImmediateAttack;
}
}
public override void Resolve(ResolveParams rp)
{
Map map = BaseGen.globalSettings.map;
PawnGroupMakerParms pawnGroupMakerParms = rp.pawnGroupMakerParams;
if (pawnGroupMakerParms == null)
{
pawnGroupMakerParms = new PawnGroupMakerParms();
pawnGroupMakerParms.tile = map.Tile;
pawnGroupMakerParms.faction = Find.FactionManager.RandomEnemyFaction(false, false, true, TechLevel.Undefined);
pawnGroupMakerParms.points = 250f;
}
PawnGroupKindDef groupKind = rp.pawnGroupKindDef ?? PawnGroupKindDefOf.Normal;
foreach (Pawn current in PawnGroupMakerUtility.GeneratePawns(groupKind, pawnGroupMakerParms, true))
{
ResolveParams resolveParams = rp;
resolveParams.singlePawnToSpawn = current;
BaseGen.symbolStack.Push("pawn", resolveParams);
}
}
private float CheapestSapperCost(Faction faction, PawnGroupKindDef groupKind)
{
IEnumerable <PawnGroupMaker> enumerable = PawnGenOptionsWithLockpickers(faction, groupKind);
if (!enumerable.Any())
{
Log.Error("Tried to get MinimumPoints for " + GetType().ToString() + " for faction " + faction.ToString() + " but the faction has no groups with sappers. groupKind=" + groupKind);
return(99999f);
}
float num = 9999999f;
foreach (PawnGroupMaker item in enumerable)
{
foreach (PawnGenOption item2 in item.options.Where((PawnGenOption op) => op.kind.canBeSapper))
{
if (item2.Cost < num)
{
num = item2.Cost;
}
}
}
return(num);
}
protected override bool TryExecuteWorker(IncidentParms parms)
{
Map map = (Map)parms.target;
Cthulhu.Utility.DebugReport("Cosmic Horror Raid Report: Trying execution");
this.ResolveRaidPoints(parms);
bool result = false;
if (!this.TryResolveRaidFaction(parms))
{
Cthulhu.Utility.DebugReport("Cosmic Horror Raid Report: Failed to resolve faction");
result = false;
}
else
{
PawnGroupKindDef combat = PawnGroupKindDefOf.Combat;
this.ResolveRaidStrategy(parms, PawnGroupKindDefOf.Combat);
this.ResolveRaidArriveMode(parms);
if (!parms.raidArrivalMode.Worker.TryResolveRaidSpawnCenter(parms))
{
result = false;
}
else
{
parms.points = IncidentWorker_Raid.AdjustedRaidPoints(parms.points, parms.raidArrivalMode,
parms.raidStrategy, parms.faction, combat);
PawnGroupMakerParms defaultPawnGroupMakerParms =
IncidentParmsUtility.GetDefaultPawnGroupMakerParms(combat, parms);
List <Pawn> list = PawnGroupMakerUtility
.GeneratePawns(defaultPawnGroupMakerParms, true).ToList <Pawn>();
if (list.Count == 0)
{
Cthulhu.Utility.ErrorReport("Got no pawns spawning raid from parms " + parms);
result = false;
}
parms.raidArrivalMode.Worker.Arrive(list, parms);
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.AppendLine("Points = " + parms.points.ToString("F0"));
foreach (Pawn current2 in list)
{
string str = (current2.equipment == null || current2.equipment.Primary == null)
? "unarmed"
: current2.equipment.Primary.LabelCap;
stringBuilder.AppendLine(current2.KindLabel + " - " + str);
}
string letterLabel = this.GetLetterLabel(parms);
string letterText = this.GetLetterText(parms, list);
TaggedString letterLabelS = letterLabel;
TaggedString letterTextS = letterText;
//string lalalal = this.GetRelatedPawnsInfoLetterText(parms);
PawnRelationUtility.Notify_PawnsSeenByPlayer_Letter(list, ref letterLabelS, ref letterTextS,
this.GetRelatedPawnsInfoLetterText(parms), true, true);
List <TargetInfo> list2 = new List <TargetInfo>();
if (parms.pawnGroups != null)
{
List <List <Pawn> > list3 = IncidentParmsUtility.SplitIntoGroups(list, parms.pawnGroups);
List <Pawn> list4 = list3.MaxBy((List <Pawn> x) => x.Count);
if (list4.Any <Pawn>())
{
list2.Add(list4[0]);
}
for (int i = 0; i < list3.Count; i++)
{
if (list3[i] != list4)
{
if (list3[i].Any <Pawn>())
{
list2.Add(list3[i][0]);
}
}
}
}
else if (list.Any <Pawn>())
{
list2.Add(list[0]);
}
Find.LetterStack.ReceiveLetter(letterLabel, letterText, this.GetLetterDef(), list2, parms.faction);
if (this.GetLetterDef() == LetterDefOf.ThreatBig)
{
//TaleRecorder.RecordTale(TaleDefOf. RaidArrived, new object[0]);
}
parms.raidStrategy.Worker.MakeLords(parms, list);
LessonAutoActivator.TeachOpportunity(ConceptDefOf.EquippingWeapons, OpportunityType.Critical);
if (!PlayerKnowledgeDatabase.IsComplete(ConceptDefOf.ShieldBelts))
{
for (int j = 0; j < list.Count; j++)
{
Pawn pawn2 = list[j];
if (pawn2.apparel.WornApparel.Any((Apparel ap) => ap is ShieldBelt))
{
LessonAutoActivator.TeachOpportunity(ConceptDefOf.ShieldBelts,
OpportunityType.Critical);
break;
}
}
}
result = true;
}
}
return(result);
}
protected override bool TryExecuteWorker(IncidentParms parms)
{
ResolveRaidPoints(parms);
if (!TryResolveRaidFaction(parms))
{
return(false);
}
PawnGroupKindDef combat = PawnGroupKindDefOf.Combat;
ResolveRaidStrategy(parms, combat);
ResolveRaidArriveMode(parms);
parms.raidStrategy.Worker.TryGenerateThreats(parms);
if (!parms.raidArrivalMode.Worker.TryResolveRaidSpawnCenter(parms))
{
return(false);
}
float points = parms.points;
parms.points = AdjustedRaidPoints(parms.points, parms.raidArrivalMode, parms.raidStrategy, parms.faction, combat);
RaidPatches.includeRaidToTheList = false;
List <Pawn> list = parms.raidStrategy.Worker.SpawnThreats(parms);
if (list == null)
{
list = PawnGroupMakerUtility.GeneratePawns(IncidentParmsUtility.GetDefaultPawnGroupMakerParms(combat, parms)).ToList();
if (list.Count == 0)
{
Log.Error("Got no pawns spawning raid from parms " + parms);
return(false);
}
parms.raidArrivalMode.Worker.Arrive(list, parms);
}
RaidPatches.includeRaidToTheList = true;
GenerateRaidLoot(parms, points, list);
TaggedString letterLabel = GetLetterLabel(parms);
TaggedString letterText = GetLetterText(parms, list);
PawnRelationUtility.Notify_PawnsSeenByPlayer_Letter(list, ref letterLabel, ref letterText, GetRelatedPawnsInfoLetterText(parms), informEvenIfSeenBefore: true);
List <TargetInfo> list2 = new List <TargetInfo>();
if (parms.pawnGroups != null)
{
List <List <Pawn> > list3 = IncidentParmsUtility.SplitIntoGroups(list, parms.pawnGroups);
List <Pawn> list4 = list3.MaxBy((List <Pawn> x) => x.Count);
if (list4.Any())
{
list2.Add(list4[0]);
}
for (int i = 0; i < list3.Count; i++)
{
if (list3[i] != list4 && list3[i].Any())
{
list2.Add(list3[i][0]);
}
}
}
else if (list.Any())
{
foreach (Pawn item in list)
{
list2.Add(item);
}
}
SendStandardLetter(letterLabel, letterText, GetLetterDef(), parms, list2);
parms.raidStrategy.Worker.MakeLords(parms, list);
LessonAutoActivator.TeachOpportunity(ConceptDefOf.EquippingWeapons, OpportunityType.Critical);
if (!PlayerKnowledgeDatabase.IsComplete(ConceptDefOf.ShieldBelts))
{
for (int j = 0; j < list.Count; j++)
{
if (list[j].apparel.WornApparel.Any((Apparel ap) => ap is ShieldBelt))
{
LessonAutoActivator.TeachOpportunity(ConceptDefOf.ShieldBelts, OpportunityType.Critical);
break;
}
}
}
Find.TickManager.slower.SignalForceNormalSpeedShort();
Find.StoryWatcher.statsRecord.numRaidsEnemy++;
return(true);
}
// Token: 0x06000088 RID: 136 RVA: 0x00004224 File Offset: 0x00002424
public static void Postfix()
{
// Log.Message("GenerateImpliedDefs_PreResolve");
PawnGroupKindDef pawnGroupKindDef = new PawnGroupKindDef();
pawnGroupKindDef.defName = "Hive_OgsOld_ExtraHives";
pawnGroupKindDef.workerClass = typeof(PawnGroupKindWorker_Normal);
DefGenerator.AddImpliedDef <PawnGroupKindDef>(pawnGroupKindDef);
pawnGroupKindDef = new PawnGroupKindDef();
pawnGroupKindDef.defName = "Tunneler_OgsOld_ExtraHives";
pawnGroupKindDef.workerClass = typeof(PawnGroupKindWorker_Normal);
DefGenerator.AddImpliedDef <PawnGroupKindDef>(pawnGroupKindDef);
PawnsArrivalModeDef pawnsArrivalModeDef = new PawnsArrivalModeDef();
pawnsArrivalModeDef.defName = "EdgeTunnelIn_OgsOld_ExtraHives";
pawnsArrivalModeDef.textEnemy = "A group of {0} from {1} have tunneled in nearby.";
pawnsArrivalModeDef.textFriendly = "A group of friendly {0} from {1} have tunneled in nearby.";
pawnsArrivalModeDef.textWillArrive = "{0_pawnsPluralDef} will tunnel in.";
pawnsArrivalModeDef.workerClass = typeof(OgsOld_ExtraHives.PawnsArrivalModeWorker_EdgeTunnel);
/*
* pawnsArrivalModeDef.selectionWeightCurve = new SimpleCurve();
* pawnsArrivalModeDef.selectionWeightCurve.Add(new CurvePoint(300f,0f));
* pawnsArrivalModeDef.selectionWeightCurve.Add(new CurvePoint(700f,0.3f));
*/
DefGenerator.AddImpliedDef <PawnsArrivalModeDef>(pawnsArrivalModeDef);
pawnsArrivalModeDef = new PawnsArrivalModeDef();
pawnsArrivalModeDef.defName = "EdgeTunnelInGroups_OgsOld_ExtraHives";
pawnsArrivalModeDef.textEnemy = "Several separate groups of {0} from {1} have tunneled in nearby.";
pawnsArrivalModeDef.textFriendly = "Several separate groups of friendly {0} from {1} have tunneled in nearby.";
pawnsArrivalModeDef.textWillArrive = "Several separate groups of {0_pawnsPluralDef} will tunnel in.";
pawnsArrivalModeDef.workerClass = typeof(OgsOld_ExtraHives.PawnsArrivalModeWorker_EdgeTunnelGroups);
/*
* pawnsArrivalModeDef.selectionWeightCurve = new SimpleCurve();
* pawnsArrivalModeDef.selectionWeightCurve.Add(new CurvePoint(100f, 0f));
* pawnsArrivalModeDef.selectionWeightCurve.Add(new CurvePoint(300f, 0.2f));
* pawnsArrivalModeDef.selectionWeightCurve.Add(new CurvePoint(700f, 0.5f));
* pawnsArrivalModeDef.pointsFactorCurve = new SimpleCurve();
* pawnsArrivalModeDef.pointsFactorCurve.Add(new CurvePoint(0f, 0.9f));
*/
DefGenerator.AddImpliedDef <PawnsArrivalModeDef>(pawnsArrivalModeDef);
pawnsArrivalModeDef = new PawnsArrivalModeDef();
pawnsArrivalModeDef.defName = "CenterTunnelIn_OgsOld_ExtraHives";
pawnsArrivalModeDef.textEnemy = "A group of {0} from {1} have tunneled in right on top of you!";
pawnsArrivalModeDef.textFriendly = "A group of friendly {0} from {1} have tunneled in right on top of you!";
pawnsArrivalModeDef.textWillArrive = "{0_pawnsPluralDef} will tunnel in right on top of you.";
pawnsArrivalModeDef.workerClass = typeof(OgsOld_ExtraHives.PawnsArrivalModeWorker_CenterTunnel);
/*
* pawnsArrivalModeDef.selectionWeightCurve = new SimpleCurve();
* pawnsArrivalModeDef.selectionWeightCurve.Add(new CurvePoint(300f, 0.0f));
* pawnsArrivalModeDef.selectionWeightCurve.Add(new CurvePoint(1000f, 3.5f));
* pawnsArrivalModeDef.pointsFactorCurve = new SimpleCurve();
* pawnsArrivalModeDef.pointsFactorCurve.Add(new CurvePoint(0f, 0.75f));
* pawnsArrivalModeDef.pointsFactorCurve.Add(new CurvePoint(5000f, 0.5f));
*/
DefGenerator.AddImpliedDef <PawnsArrivalModeDef>(pawnsArrivalModeDef);
pawnsArrivalModeDef = new PawnsArrivalModeDef();
pawnsArrivalModeDef.defName = "RandomTunnelIn_OgsOld_ExtraHives";
pawnsArrivalModeDef.textEnemy = "A group of {0} from {1} have tunneled in. They are scattered all over the area!";
pawnsArrivalModeDef.textFriendly = "A group of friendly {0} from {1} have tunneled in. They are scattered all over the area!";
pawnsArrivalModeDef.textWillArrive = "{0_pawnsPluralDef} will tunnel in.";
pawnsArrivalModeDef.workerClass = typeof(OgsOld_ExtraHives.PawnsArrivalModeWorker_RandomTunnel);
/*
* pawnsArrivalModeDef.selectionWeightCurve = new SimpleCurve();
* pawnsArrivalModeDef.selectionWeightCurve.Add(new CurvePoint(300f, 0f));
* pawnsArrivalModeDef.selectionWeightCurve.Add(new CurvePoint(1000f, 1.9f));
* pawnsArrivalModeDef.pointsFactorCurve = new SimpleCurve();
* pawnsArrivalModeDef.pointsFactorCurve.Add(new CurvePoint(0f, 0.7f));
* pawnsArrivalModeDef.pointsFactorCurve.Add(new CurvePoint(5000f, 0.45f));
*/
DefGenerator.AddImpliedDef <PawnsArrivalModeDef>(pawnsArrivalModeDef);
ThingDef thingDef = new ThingDef();
thingDef.defName = "InfestedMeteoriteIncoming_OgsOld_ExtraHives";
thingDef.category = ThingCategory.Ethereal;
thingDef.thingClass = typeof(Skyfaller);
thingDef.useHitPoints = false;
thingDef.drawOffscreen = true;
thingDef.tickerType = TickerType.Normal;
thingDef.altitudeLayer = AltitudeLayer.Skyfaller;
thingDef.drawerType = DrawerType.RealtimeOnly;
thingDef.skyfaller = new SkyfallerProperties();
thingDef.label = "meteorite (incoming)";
thingDef.size = new IntVec2(3, 3);
thingDef.graphicData = new GraphicData();
thingDef.graphicData.texPath = "Things/Skyfaller/Meteorite";
thingDef.graphicData.graphicClass = typeof(Graphic_Single);
thingDef.graphicData.shaderType = ShaderTypeDefOf.Transparent;
thingDef.graphicData.drawSize = new Vector2(10, 10);
thingDef.skyfaller.shadowSize = new Vector2(3, 3);
thingDef.skyfaller.explosionRadius = 4;
thingDef.skyfaller.explosionDamage = DamageDefOf.Bomb;
thingDef.skyfaller.rotateGraphicTowardsDirection = true;
thingDef.skyfaller.speed = 1.2f;
DefGenerator.AddImpliedDef <ThingDef>(thingDef);
thingDef = new ThingDef();
thingDef.defName = "Tunneler_OgsOld_ExtraHives";
thingDef.category = ThingCategory.Ethereal;
thingDef.thingClass = typeof(OgsOld_ExtraHives.TunnelRaidSpawner);
thingDef.useHitPoints = false;
thingDef.drawOffscreen = true;
thingDef.alwaysFlee = true;
thingDef.tickerType = TickerType.Normal;
thingDef.altitudeLayer = AltitudeLayer.Skyfaller;
thingDef.drawerType = DrawerType.RealtimeOnly;
thingDef.label = "tunnel (incoming)";
thingDef.size = new IntVec2(1, 1);
DefGenerator.AddImpliedDef <ThingDef>(thingDef);
//PawnsArrivalModeDef
/*
* thingDef = new ThingDef();
* thingDef.defName = "Hive_OgsOld_ExtraHives";
* thingDef.category = ThingCategory.Ethereal;
* thingDef.thingClass = typeof(OgsOld_ExtraHives.TunnelRaidSpawner);
* thingDef.useHitPoints = false;
* thingDef.drawOffscreen = true;
* thingDef.alwaysFlee = true;
* thingDef.tickerType = TickerType.Normal;
* thingDef.altitudeLayer = AltitudeLayer.Skyfaller;
* thingDef.drawerType = DrawerType.RealtimeOnly;
* thingDef.label = "tunnel (incoming)";
* thingDef.size = new IntVec2(3,3);
* DefGenerator.AddImpliedDef<ThingDef>(thingDef);
*
*/
//RuleDef
RuleDef ruleDef;
ruleDef = new RuleDef();
ruleDef.defName = "OgsOld_ExtraHives_HiveBaseMaker";
ruleDef.symbol = "OgsOld_ExtraHives_HiveBaseMaker";
ruleDef.resolvers = new List <SymbolResolver>();
ruleDef.resolvers.Add(new OgsOld_ExtraHives.GenStuff.SymbolResolver_Hivebase());
DefGenerator.AddImpliedDef <RuleDef>(ruleDef);
ruleDef = new RuleDef();
ruleDef.defName = "OgsOld_ExtraHives_HiveMoundMaker";
ruleDef.symbol = "OgsOld_ExtraHives_HiveMoundMaker";
ruleDef.resolvers = new List <SymbolResolver>();
ruleDef.resolvers.Add(new OgsOld_ExtraHives.GenStuff.SymbolResolver_HiveBaseMoundMaker());
DefGenerator.AddImpliedDef <RuleDef>(ruleDef);
ruleDef = new RuleDef();
ruleDef.defName = "OgsOld_ExtraHives_HiveClearChamber";
ruleDef.symbol = "OgsOld_ExtraHives_HiveClearChamber";
ruleDef.resolvers = new List <SymbolResolver>();
ruleDef.resolvers.Add(new OgsOld_ExtraHives.GenStuff.SymbolResolver_ClearChamber());
DefGenerator.AddImpliedDef <RuleDef>(ruleDef);
ruleDef = new RuleDef();
ruleDef.defName = "OgsOld_ExtraHives_HiveInterals";
ruleDef.symbol = "OgsOld_ExtraHives_HiveInterals";
ruleDef.resolvers = new List <SymbolResolver>();
ruleDef.resolvers.Add(new OgsOld_ExtraHives.GenStuff.SymbolResolver_HiveInternals());
DefGenerator.AddImpliedDef <RuleDef>(ruleDef);
ruleDef = new RuleDef();
ruleDef.defName = "OgsOld_ExtraHives_HiveOutdoorLighting";
ruleDef.symbol = "OgsOld_ExtraHives_HiveOutdoorLighting";
ruleDef.resolvers = new List <SymbolResolver>();
ruleDef.resolvers.Add(new OgsOld_ExtraHives.GenStuff.SymbolResolver_OutdoorLightingHivebase());
DefGenerator.AddImpliedDef <RuleDef>(ruleDef);
ruleDef = new RuleDef();
ruleDef.defName = "OgsOld_ExtraHives_HiveRandomCorpse";
ruleDef.symbol = "OgsOld_ExtraHives_HiveRandomCorpse";
ruleDef.resolvers = new List <SymbolResolver>();
ruleDef.resolvers.Add(new OgsOld_ExtraHives.GenStuff.SymbolResolver_RandomCorpse());
DefGenerator.AddImpliedDef <RuleDef>(ruleDef);
ruleDef = new RuleDef();
ruleDef.defName = "OgsOld_ExtraHives_HiveRandomDamage";
ruleDef.symbol = "OgsOld_ExtraHives_HiveRandomDamage";
ruleDef.resolvers = new List <SymbolResolver>();
ruleDef.resolvers.Add(new OgsOld_ExtraHives.GenStuff.SymbolResolver_RandomDamage());
DefGenerator.AddImpliedDef <RuleDef>(ruleDef);
ruleDef = new RuleDef();
ruleDef.defName = "OgsOld_ExtraHives_HiveRandomHives";
ruleDef.symbol = "OgsOld_ExtraHives_HiveRandomHives";
ruleDef.resolvers = new List <SymbolResolver>();
ruleDef.resolvers.Add(new OgsOld_ExtraHives.GenStuff.SymbolResolver_RandomHives());
DefGenerator.AddImpliedDef <RuleDef>(ruleDef);
ruleDef = new RuleDef();
ruleDef.defName = "OgsOld_ExtraHives_PawnGroup";
ruleDef.symbol = "OgsOld_ExtraHives_PawnGroup";
ruleDef.resolvers = new List <SymbolResolver>();
ruleDef.resolvers.Add(new OgsOld_ExtraHives.GenStuff.SymbolResolver_PawnHiveGroup());
DefGenerator.AddImpliedDef <RuleDef>(ruleDef);
ruleDef = new RuleDef();
ruleDef.defName = "OgsOld_ExtraHives_Pawn";
ruleDef.symbol = "OgsOld_ExtraHives_Pawn";
ruleDef.resolvers = new List <SymbolResolver>();
ruleDef.resolvers.Add(new OgsOld_ExtraHives.GenStuff.SymbolResolver_SingleHivePawn());
DefGenerator.AddImpliedDef <RuleDef>(ruleDef);
}
public override void PassingParameters(ResolveParams rp)
{
string defChair = "DiningChair";
string defLamp = "Jecrell_GasLamp";
ThingDef lampDef = Cthulhu.Utility.IsIndustrialAgeLoaded() ? ThingDef.Named(defLamp) : ThingDefOf.TorchLamp;
ThingDef lampStuffDef = Cthulhu.Utility.IsIndustrialAgeLoaded() ? ThingDefOf.Steel : null;
Map map = BaseGen.globalSettings.map;
bool @bool = Rand.Bool;
bool hasLamp = false;
ThingDef thingDef = ThingDefOf.SleepingSpot;
ThingDef chairDef = ThingDef.Named(defChair);
foreach (IntVec3 current in rp.rect)
{
if (@bool)
{
if (current.x % 3 != 0 || current.z % 3 != 0)
{
continue;
}
}
else if (current.x % 3 != 0 || current.z % 3 != 0)
{
continue;
}
Rot4 rot = (!@bool) ? Rot4.South : Rot4.West;
if (!GenSpawn.WouldWipeAnythingWith(current, rot, thingDef, map, (Thing x) => x.def.category == ThingCategory.Building))
{
bool flag = false;
foreach (IntVec3 current2 in GenAdj.CellsOccupiedBy(current, rot, thingDef.Size))
{
if (BaseGenUtility.AnyDoorAdjacentCardinalTo(current2, map))
{
flag = true;
break;
}
}
if (!flag)
{
///Bed
ThingDef stuff = null;
if (thingDef.MadeFromStuff)
{
stuff = ThingDefOf.WoodLog;
}
Thing thing = ThingMaker.MakeThing(thingDef, stuff);
thing.SetFaction(rp.faction, null);
GenSpawn.Spawn(thing, current, map, rot);
if (thing != null)
{
if (thing.Spawned && thing.Position.InBounds(map))
{
CellRect thingRect = thing.OccupiedRect();
if (thingRect != null)
{
thingRect = thingRect.ExpandedBy(1);
List <IntVec3> possibleCells = new List <IntVec3>();
possibleCells.AddRange(thingRect.GetEdgeCells(Rot4.North));
possibleCells.AddRange(thingRect.GetEdgeCells(Rot4.South));
possibleCells.AddRange(thingRect.GetEdgeCells(Rot4.East));
possibleCells.AddRange(thingRect.GetEdgeCells(Rot4.West));
possibleCells.Remove(Cthulhu.Utility.GetCornerPos(thingRect, 0));
possibleCells.Remove(Cthulhu.Utility.GetCornerPos(thingRect, 1));
possibleCells.Remove(Cthulhu.Utility.GetCornerPos(thingRect, 2));
possibleCells.Remove(Cthulhu.Utility.GetCornerPos(thingRect, 3));
IntVec3 spawnPos = IntVec3.Invalid;
spawnPos = possibleCells.InRandomOrder <IntVec3>().FirstOrDefault((IntVec3 x) => x.InBounds(map) && x.Walkable(map));
if (spawnPos != null)
{
possibleCells.Remove(spawnPos);
Thing thing2 = ThingMaker.MakeThing(chairDef, ThingDefOf.WoodLog);
thing2.SetFaction(rp.faction, null);
GenSpawn.Spawn(thing2, spawnPos, map, rot.Opposite);
}
if (!hasLamp)
{
hasLamp = true;
spawnPos = possibleCells.FirstOrDefault((IntVec3 x) => x.InBounds(map) && x.Walkable(map));
if (spawnPos != null)
{
possibleCells.Remove(spawnPos);
Thing thing3 = ThingMaker.MakeThing(lampDef, lampStuffDef);
thing3.SetFaction(rp.faction, null);
GenSpawn.Spawn(thing3, spawnPos, map, rot.Opposite);
}
}
}
}
}
}
}
}
//if (!Cthulhu.Utility.IsCosmicHorrorsLoaded())
//{
PawnGroupKindDef groupKind = rp.pawnGroupKindDef ?? PawnGroupKindDefOf.Combat;
PawnGroupMakerParms pawnGroupMakerParms = new PawnGroupMakerParms()
{
faction = (from x in Find.FactionManager.AllFactions
where x.HostileTo(rp.faction) && x.def.pawnGroupMakers != null &&
x.def.pawnGroupMakers.Count > 0 &&
x.def.humanlikeFaction &&
IsCosmicHorrorFaction(x) == false &&
(x.def.pawnGroupMakers.FirstOrDefault((PawnGroupMaker y) => y.kindDef == PawnGroupKindDefOf.Combat) != null)
select x).RandomElement <Faction>(),
tile = map.Tile,
points = 5000,
generateFightersOnly = false,
};
int num = 0;
foreach (Pawn current in PawnGroupMakerUtility.GeneratePawns(pawnGroupMakerParms, true))
{
num++;
ResolveParams resolveParams = rp;
resolveParams.singlePawnToSpawn = current;
BaseGen.symbolStack.Push("pawn", resolveParams);
if (num == 3)
{
break;
}
}
//}
//else
//{
// Faction tempFaction = Find.FactionManager.AllFactions.InRandomOrder<Faction>().FirstOrDefault((Faction z) => IsCosmicHorrorFaction(z));
// PawnGroupKindDef groupKind = rp.pawnGroupKindDef ?? PawnGroupKindDefOf.Combat;
// PawnGroupMakerParms pawnGroupMakerParms = new PawnGroupMakerParms()
// {
// faction = tempFaction,
// map = map,
// points = 5000,
// generateFightersOnly = false,
// generateMeleeOnly = false
// };
// int num = 0;
// foreach (Pawn current in PawnGroupMakerUtility.GeneratePawns(groupKind, pawnGroupMakerParms, true))
// {
// num++;
// ResolveParams resolveParams = rp;
// resolveParams.singlePawnToSpawn = current;
// resolveParams.singlePawnLord = null;
// BaseGen.symbolStack.Push("pawn", resolveParams);
// if (num == 3) break;
// }
//}
//List<int> corners = new List<int>() { 0, 1, 2, 3 };
//foreach (int corner in corners.InRandomOrder<int>())
//{
// IntVec3 loc = Cthulhu.Utility.GetCornerPos(rp.rect.ContractedBy(1), corner);
// if (!GenSpawn.WouldWipeAnythingWith(loc, Rot4.South, lampDef, map, (Thing x) => x.def.category == ThingCategory.Building))
// {
// ThingDef singleThingDef3 = (Cthulhu.Utility.IsIndustrialAgeLoaded()) ? lampDef : ThingDefOf.TorchLamp;
// Thing thing3 = ThingMaker.MakeThing(singleThingDef3, ThingDefOf.Steel);
// GenSpawn.Spawn(thing3, loc, map);
// break;
// }
//}
}
