public override void PassingParameters(ResolveParams rp)
{
//string defLogo = "AgencySymbolFloorPainting";
string defTable = "TableLong";
string defChair = "DiningChair";
string defLamp = "Jecrell_GasLamp";
Map map = BaseGen.globalSettings.map;
Rot4 rot = Rot4.North;
int deskOffset = 1;
//ThingDef logoDef = ThingDef.Named(defLogo);
ThingDef thingDef = ThingDef.Named(defTable);
ThingDef chairDef = ThingDef.Named(defChair);
ThingDef lampDef = Cthulhu.Utility.IsIndustrialAgeLoaded() ? ThingDef.Named(defLamp) : ThingDefOf.TorchLamp;
ThingDef lampStuffDef = Cthulhu.Utility.IsIndustrialAgeLoaded() ? ThingDefOf.Steel : null;
IntVec3 locationCenter = rp.rect.CenterCell;
for (int i = 0; i < deskOffset; i++)
{
locationCenter -= GenAdj.AdjacentCells[rot.AsInt];
}
IntVec3 receptionCenter = rp.rect.CenterCell;
for (int i = 0; i < deskOffset; i++)
{
receptionCenter += GenAdj.AdjacentCells[rot.AsInt];
}
///Center logo
//ThingDef stuff = null;
//Thing logo = ThingMaker.MakeThing(logoDef, stuff);
//logo.SetFaction(rp.faction, null);
//GenSpawn.Spawn(logo, locationCenter, map, rot);
///Reception table
ThingDef stuff = null;
if (thingDef.MadeFromStuff)
{
stuff = ThingDefOf.WoodLog;
}
Thing thing = ThingMaker.MakeThing(thingDef, stuff);
thing.SetFaction(rp.faction, null);
GenSpawn.Spawn(thing, receptionCenter, map, rot);
///Adjacent lamps
IntVec3 loc1 = Cthulhu.Utility.GetCornerPos(thing.OccupiedRect(), 0) + GenAdj.AdjacentCells[Rot4.West.AsInt] + GenAdj.AdjacentCells[Rot4.West.AsInt];
Thing thing3 = ThingMaker.MakeThing(lampDef, lampStuffDef);
GenSpawn.Spawn(thing3, loc1, map);
IntVec3 loc2 = Cthulhu.Utility.GetCornerPos(thing.OccupiedRect(), 1) + GenAdj.AdjacentCells[Rot4.East.AsInt] + GenAdj.AdjacentCells[Rot4.East.AsInt];
Thing thing4 = ThingMaker.MakeThing(lampDef, lampStuffDef);
GenSpawn.Spawn(thing4, loc2, map);
if (thing != null)
{
if (thing.Spawned && thing.Position.InBounds(map))
{
CellRect rectToEdit = thing.OccupiedRect().ExpandedBy(1);
List <IntVec3> poss = new List <IntVec3>();
poss.AddRange(rectToEdit.GetEdgeCells(Rot4.North));
poss.AddRange(rectToEdit.GetEdgeCells(Rot4.South));
poss.AddRange(rectToEdit.GetEdgeCells(Rot4.East));
poss.AddRange(rectToEdit.GetEdgeCells(Rot4.West));
poss.Remove(Cthulhu.Utility.GetCornerPos(rectToEdit, 0));
poss.Remove(Cthulhu.Utility.GetCornerPos(rectToEdit, 1));
poss.Remove(Cthulhu.Utility.GetCornerPos(rectToEdit, 2));
poss.Remove(Cthulhu.Utility.GetCornerPos(rectToEdit, 3));
foreach (IntVec3 currentPos in poss.InRandomOrder <IntVec3>())
{
///CHAIR
float angle = (currentPos - thing.Position).ToVector3().AngleFlat();
Rot4 newRot = Pawn_RotationTracker.RotFromAngleBiased(angle).Opposite;
Thing thing2 = ThingMaker.MakeThing(chairDef, stuff);
thing2.SetFaction(rp.faction, null);
GenSpawn.Spawn(thing2, currentPos, map, newRot);
}
}
}
///Four corners, four gas lamps.
for (int i = 0; i < 1; i++)
{
Thing thing5 = ThingMaker.MakeThing(lampDef, lampStuffDef);
IntVec3 loc = Cthulhu.Utility.GetCornerPos(rp.rect.ContractedBy(1), i);
GenSpawn.Spawn(thing5, loc, map);
}
//Bring in MERF
Lord singlePawnLord = rp.singlePawnLord ?? LordMaker.MakeNewLord(rp.faction, new LordJob_DefendBase(rp.faction, rp.rect.CenterCell), map, null);
ResolveParams resolveParams = rp;
resolveParams.rect = rp.rect.ExpandedBy(1);
resolveParams.faction = rp.faction;
resolveParams.singlePawnLord = singlePawnLord;
resolveParams.pawnGroupKindDef = PawnGroupKindDefOf.Combat; //CthulhuFactionsDefOf.ROM_AgencyMERF;
float points = 10000;
resolveParams.pawnGroupMakerParams = new PawnGroupMakerParms
{
tile = map.Tile,
faction = rp.faction,
points = points
};
BaseGen.symbolStack.Push("pawnGroup", resolveParams);
}
public override void Resolve(ResolveParams rp)
{
int offsetX = 5;
Faction enemyFaction = Find.FactionManager.RandomEnemyFaction(false, false, true, TechLevel.Industrial);
rp.faction = enemyFaction ?? Faction.OfAncientsHostile;
rp.pawnGroupKindDef = PawnGroupKindDefOf.Settlement;
rp.edgeDefenseWidth = 4;
//split up the area into 4 parts with one settlement each
CellRect rectSW = new CellRect(rp.rect.minX - offsetX, rp.rect.minZ, rp.rect.Width / 2, rp.rect.Height / 2).ContractedBy(1);
CellRect rectSE = new CellRect(rp.rect.minX + rp.rect.Width / 2 + offsetX, rp.rect.minZ, rp.rect.Width / 2, rp.rect.Height / 2).ContractedBy(1);
CellRect rectNW = new CellRect(rp.rect.minX - offsetX + 3, rp.rect.minZ + rp.rect.Height / 2, rp.rect.Width / 2, rp.rect.Height / 2).ContractedBy(1);
CellRect rectNE = new CellRect(rp.rect.minX + rp.rect.Width / 2 + offsetX - 3, rp.rect.minZ + rp.rect.Height / 2, rp.rect.Width / 2, rp.rect.Height / 2).ContractedBy(1);
//change ship reactor status to powering up
ResolveParams resolveParmsReactorStatus = rp;
BaseGen.symbolStack.Push("activateShipReactorLGE", resolveParmsReactorStatus);
//Charge up batteries
ResolveParams resolveParmsBatterieCharge = rp;
//run it multiple times so they are fully charged
BaseGen.symbolStack.Push("chargeBatteries", resolveParmsBatterieCharge);
BaseGen.symbolStack.Push("chargeBatteries", resolveParmsBatterieCharge);
BaseGen.symbolStack.Push("chargeBatteries", resolveParmsBatterieCharge);
BaseGen.symbolStack.Push("chargeBatteries", resolveParmsBatterieCharge);
BaseGen.symbolStack.Push("chargeBatteries", resolveParmsBatterieCharge);
//scatter some mortar ammo
ResolveParams resolveParmsShells = rp;
resolveParmsShells.stockpileConcreteContents = IncidentUtilityLGE.GenerateShellStocks(Rand.RangeInclusive(4, 6));
BaseGen.symbolStack.Push("spawnStockpileLGE", resolveParmsShells);
//Spawn additional mortar down in the middle of the ship gap
ResolveParams resolveParmsMortar = rp;
resolveParmsMortar.rect = new CellRect(rectSW.maxX, rectSW.minZ + 3, rectSE.minX - rectSW.maxX, 5);
BaseGen.symbolStack.Push("mannedMortar", resolveParmsMortar);
BaseGen.symbolStack.Push("mannedMortar", resolveParmsMortar);
//Spawn the pregen ship in the middle
ResolveParams resolveParmsShip = rp;
BaseGen.symbolStack.Push("ship_pregen", resolveParmsShip);
//create the 4 settlements
ResolveParams resolveParmsSettlementSW = rp;
resolveParmsSettlementSW.rect = rectSW;
resolveParmsSettlementSW.edgeDefenseMortarsCount = 1;
BaseGen.symbolStack.Push("settlement", resolveParmsSettlementSW);
ResolveParams resolveParmsSettlementSE = rp;
resolveParmsSettlementSE.rect = rectSE;
resolveParmsSettlementSE.edgeDefenseMortarsCount = 1;
BaseGen.symbolStack.Push("settlement", resolveParmsSettlementSE);
ResolveParams resolveParmsSettlementNW = rp;
resolveParmsSettlementNW.rect = rectNW;
resolveParmsSettlementNW.edgeDefenseMortarsCount = Rand.RangeInclusive(1, 2);
BaseGen.symbolStack.Push("settlement", resolveParmsSettlementNW);
ResolveParams resolveParmsSettlementNE = rp;
resolveParmsSettlementNE.rect = rectNE;
resolveParmsSettlementNE.edgeDefenseMortarsCount = Rand.RangeInclusive(1, 2);
BaseGen.symbolStack.Push("settlement", resolveParmsSettlementNE);
//clear the area before spawning to get rid of roofs and mountains
ResolveParams resolveParmsClear = rp;
resolveParmsClear.clearRoof = true;
BaseGen.symbolStack.Push("clear", resolveParmsClear);
resolveParmsClear.rect = rectSE;
BaseGen.symbolStack.Push("clear", resolveParmsClear);
resolveParmsClear.rect = rectSW;
BaseGen.symbolStack.Push("clear", resolveParmsClear);
}
public override void Resolve(ResolveParams rp)
{
BaseGen.symbolStack.Push("batteryRoom", rp);
BaseGen.globalSettings.basePart_batteriesCoverage += (float)rp.rect.Area / (float)BaseGen.globalSettings.mainRect.Area;
}
public override void Generate(Map map, GenStepParams parms)
{
//skip generation due to low blueprints count
if (SnapshotStoreManager.Instance.StoredSnapshotsCount() < 10)
{
Debug.Error(Debug.Scatter, "Skipping ruins gerenation due to low blueprints count.");
return;
}
//Skip generation for starting tile if corresponding settings flag is set
if (RealRuins_ModSettings.startWithoutRuins)
{
int homes = 0;
var allMaps = Find.Maps;
for (int i = 0; i < allMaps.Count; i++)
{
Map someMap = allMaps[i];
if (someMap.IsPlayerHome)
{
homes++;
}
}
if (homes == 1 && Find.TickManager.TicksGame < 10)
{
return; //single home => we're generating that single home => that's starting map => no ruins here if this option is selected.
}
}
//Skip generation on other ruins world objects
foreach (WorldObject wo in Find.World.worldObjects.ObjectsAt(map.Tile))
{
if (wo is RealRuinsPOIWorldObject || wo is AbandonedBaseWorldObject)
{
return;
}
}
if (!map.TileInfo.WaterCovered)
{
float densityMultiplier = 1.0f;
float scaleMultiplier = 1.0f;
float distanceToSettlement = 0.0f;
float totalDensity = RealRuins_ModSettings.defaultScatterOptions.densityMultiplier;
currentOptions = RealRuins_ModSettings.defaultScatterOptions.Copy(); //store as instance variable to keep accessible on subsequent ScatterAt calls
if (RealRuins_ModSettings.defaultScatterOptions.enableProximity)
{
distanceToSettlement = CalculateDistanceToNearestSettlement(map);
if (distanceToSettlement >= 16 && Rand.Chance(0.5f))
{
totalDensity = 0;
}
if (totalDensity > 0)
{
densityMultiplier = (float)(Math.Exp(1.0 / (distanceToSettlement / 10.0 + 0.3)) - 0.7);
scaleMultiplier = (float)(Math.Exp(1 / (distanceToSettlement / 5 + 0.5)) - 0.3);
}
else
{
densityMultiplier = 0.0f;
}
currentOptions.densityMultiplier *= densityMultiplier;
currentOptions.minRadius = Math.Min(60, Math.Max(6, (int)(currentOptions.minRadius * scaleMultiplier))); //keep between 6 and 60
currentOptions.maxRadius = Math.Min(60, Math.Max(6, (int)(currentOptions.maxRadius * scaleMultiplier))); //keep between 6 and 60
currentOptions.scavengingMultiplier *= scaleMultiplier * densityMultiplier;
currentOptions.deteriorationMultiplier += Math.Min(0.2f, (1.0f / (scaleMultiplier * densityMultiplier * 3)));
if (densityMultiplier > 20.0f)
{
densityMultiplier = 20.0f;
}
while (densityMultiplier * currentOptions.maxRadius > 800)
{
densityMultiplier *= 0.9f; //WHAT? Why not 800/radius?
}
}
//number of ruins based on density settings
var num = (int)((float)map.Area / 10000.0f) * Rand.Range(1 * totalDensity, 2 * totalDensity);
Debug.Log(Debug.Scatter, "dist {0}, dens {1} (x{2}), scale x{3} ({4}-{5}), scav {6}, deter {7}", distanceToSettlement, currentOptions.densityMultiplier, densityMultiplier, scaleMultiplier, currentOptions.minRadius, currentOptions.maxRadius, currentOptions.scavengingMultiplier, currentOptions.deteriorationMultiplier);
Debug.Log(Debug.Scatter, "Spawning {0} ruin chunks", num);
BaseGen.globalSettings.map = map;
bool shouldUnpause = false;
Find.TickManager.Pause();
if (!Find.TickManager.Paused)
{
Find.TickManager.TogglePaused();
shouldUnpause = true;
}
CoverageMap coverageMap = CoverageMap.EmptyCoverageMap(map);
for (int i = 0; i < num; i++)
{
//We use copy of scatteroptions because each scatteroptions represents separate chunk with separate location, size, maps, etc.
//should use struct instead? is it compatible with IExposable?
ResolveParams rp = default(ResolveParams);
rp.SetCustom(Constants.ScatterOptions, currentOptions.Copy());
rp.SetCustom(Constants.CoverageMap, coverageMap);
if (Rand.Chance(currentOptions.hostileChance))
{
if (Rand.Chance(0.8f))
{
rp.SetCustom(Constants.ForcesGenerators, new List <AbstractDefenderForcesGenerator> {
new AnimalInhabitantsForcesGenerator()
});
}
else
{
rp.SetCustom(Constants.ForcesGenerators, new List <AbstractDefenderForcesGenerator> {
new MechanoidsForcesGenerator(0)
});
}
}
rp.faction = Find.FactionManager.OfAncientsHostile;
var center = CellFinder.RandomNotEdgeCell(10, map);
rp.rect = new CellRect(center.x, center.z, 1, 1); //after generation will be extended to a real size
BaseGen.symbolStack.Push("scatterRuins", rp);
}
BaseGen.Generate();
if (shouldUnpause)
{
//Debug.Message("Finished spawning, unpausing");
Find.TickManager.TogglePaused();
}
}
}
public override bool CanResolve(ResolveParams rp)
{
return(base.CanResolve(rp));
}
public override void PassingParameters(ResolveParams rp)
{
var map = BaseGen.globalSettings.map;
var @bool = Rand.Bool;
var defTypewriter = "Estate_TableTypewriter";
var defBench = "SimpleResearchBench";
var defChair = "DiningChair";
var defLamp = "Jecrell_GasLamp";
var wallDef = ThingDefOf.Steel;
var floorDef = TerrainDefOf.MetalTile;
var lampDef = Utility.IsIndustrialAgeLoaded() ? ThingDef.Named(defLamp) : ThingDefOf.TorchLamp;
var lampStuffDef = Utility.IsIndustrialAgeLoaded() ? ThingDefOf.Steel : null;
var thingDef = rp.singleThingDef ?? (Utility.IsIndustrialAgeLoaded()
? ThingDef.Named(defTypewriter)
: ThingDef.Named(defBench));
var chairDef = ThingDef.Named(defChair);
var rot = !@bool ? Rot4.South : Rot4.West;
var loc = rp.rect.CenterCell;
if (!GenSpawn.WouldWipeAnythingWith(loc, rot, thingDef, map, x => x.def.category == ThingCategory.Building))
{
var doorNear = false;
foreach (var current2 in GenAdj.CellsOccupiedBy(loc, rot, thingDef.Size))
{
if (!BaseGenUtility.AnyDoorAdjacentCardinalTo(current2, map))
{
continue;
}
doorNear = true;
break;
}
if (!doorNear)
{
//RESEARCH BENCH
ThingDef stuff = null;
if (thingDef.MadeFromStuff)
{
stuff = ThingDefOf.WoodLog;
}
var thing = ThingMaker.MakeThing(thingDef, stuff);
thing.SetFaction(rp.faction);
GenSpawn.Spawn(thing, loc, map, rot);
if (thing.Spawned && thing.Position != IntVec3.Invalid)
{
//CHAIR
var bld = thing as Building; //We need an interaction cell
var thing2 = ThingMaker.MakeThing(chairDef, stuff);
thing2.SetFaction(rp.faction);
if (bld != null)
{
GenSpawn.Spawn(thing2, bld.InteractionCell, map, rot.Opposite);
}
}
//Adjacent lamps
var singleThingDef3 = Utility.IsIndustrialAgeLoaded() ? lampDef : ThingDefOf.TorchLamp;
var thing3 = ThingMaker.MakeThing(singleThingDef3, lampStuffDef);
var thingLoc = Utility.GetCornerPos(thing.OccupiedRect(), 0) +
GenAdj.AdjacentCells[Rot4.West.AsInt];
GenSpawn.Spawn(thing3, thingLoc, map);
}
}
UnfogRoomCenter(rp.rect.CenterCell);
FactionUtility.RectReport(rp.rect);
}
public override void Generate(Map map, GenStepParams parms)
{
Find.TickManager.Pause();
//Debug.Message("Overridden LARGE generate");
string filename = map.Parent.GetComponent <RuinedBaseComp>()?.blueprintFileName;
Debug.Log(Debug.Scatter, "Preselected file name is {0}", filename);
currentOptions = RealRuins_ModSettings.defaultScatterOptions.Copy(); //store as instance variable to keep accessible on subsequent ScatterAt calls
currentOptions.minRadius = 200;
currentOptions.maxRadius = 200;
currentOptions.scavengingMultiplier = 0.1f;
currentOptions.deteriorationMultiplier = 0.0f;
currentOptions.hostileChance = 1.0f;
currentOptions.blueprintFileName = filename;
currentOptions.costCap = map.Parent.GetComponent <RuinedBaseComp>()?.currentCapCost ?? -1;
currentOptions.startingPartyPoints = (int)(map.Parent.GetComponent <RuinedBaseComp>()?.raidersActivity ?? -1);
currentOptions.minimumCostRequired = 100000;
currentOptions.minimumDensityRequired = 0.015f;
currentOptions.minimumAreaRequired = 6400;
currentOptions.deleteLowQuality = false; //do not delete since we have much higher requirements for base ruins
currentOptions.shouldKeepDefencesAndPower = true;
currentOptions.shouldLoadPartOnly = false;
currentOptions.shouldAddRaidTriggers = Find.Storyteller.difficulty.allowBigThreats;
currentOptions.claimableBlocks = false;
currentOptions.enableDeterioration = false;
ResolveParams resolveParams = default(ResolveParams);
BaseGen.globalSettings.map = map;
resolveParams.SetCustom(Constants.ScatterOptions, currentOptions);
resolveParams.faction = Find.FactionManager.OfAncientsHostile;
resolveParams.SetCustom(Constants.ForcesGenerators, new List <AbstractDefenderForcesGenerator> {
new BattleRoyaleForcesGenerator()
});
resolveParams.rect = new CellRect(0, 0, map.Size.x, map.Size.z);
BaseGen.symbolStack.Push("chargeBatteries", resolveParams);
BaseGen.symbolStack.Push("refuel", resolveParams);
BaseGen.symbolStack.Push("scatterRuins", resolveParams);
BaseGen.globalSettings.mainRect = resolveParams.rect;
float uncoveredCost = currentOptions.uncoveredCost;
if (uncoveredCost < 0)
{
if (Rand.Chance(0.5f))
{
uncoveredCost = -uncoveredCost; //adding really small party
}
}
BaseGen.Generate();
//adding starting party
//don't doing it via basegen because of uh oh i don't remember, something with pawn location control
List <AbstractDefenderForcesGenerator> generators = resolveParams.GetCustom <List <AbstractDefenderForcesGenerator> >(Constants.ForcesGenerators);
if (generators != null)
{
foreach (AbstractDefenderForcesGenerator generator in generators)
{
generator.GenerateStartingParty(map, resolveParams);
}
}
}
public override void Resolve(ResolveParams rp)
{
rp.floorDef = TerrainDef.Named("SterileTile");
BaseGen.symbolStack.Push("reGEncounter", rp);
REDataCache.GEncounterGenerated = true;
}
public override void Resolve(ResolveParams rp)
{
//CellRect.CellRectIterator iterator = rp.rect.ContractedBy(1).GetIterator();
//while (!iterator.Done())
foreach (var cellRect in rp.rect.ContractedBy(1))
{
if (rp.clearEdificeOnly.HasValue && rp.clearEdificeOnly.Value)
{
Building edifice = cellRect.GetEdifice(BaseGen.globalSettings.map);
if (edifice != null && edifice.def.destroyable)
{
if (edifice.def != CthulhuFactionsDefOf.ROM_TemporaryDoorMarker)
{
edifice.Destroy(DestroyMode.Vanish);
}
}
}
else
{
tmpThingsToDestroy.Clear();
tmpThingsToDestroy.AddRange(cellRect.GetThingList(BaseGen.globalSettings.map));
for (int i = 0; i < tmpThingsToDestroy.Count; i++)
{
if (tmpThingsToDestroy[i].def.destroyable)
{
if (tmpThingsToDestroy[i].def != CthulhuFactionsDefOf.ROM_TemporaryDoorMarker)
{
tmpThingsToDestroy[i].Destroy(DestroyMode.Vanish);
}
}
}
}
}
foreach (IntVec3 cell in rp.rect.Cells)
{
ResolveParams resolveParams3 = rp;
resolveParams3.rect = CellRect.SingleCell(cell);
resolveParams3.singleThingDef = CthulhuFactionsDefOf.ROM_TemporaryRegionBarrier;
BaseGen.symbolStack.Push("thing", resolveParams3);
}
PassingParameters(rp);
instanceMap = Map;
instanceFaction = rp.faction ?? Find.FactionManager.FirstFactionOfDef(FactionDef.Named("TheAgency"));
//ResolveParams resolveParams4 = rp;
//BaseGen.symbolStack.Push("clear", resolveParams4);
UnfogRoomCenter(rp.rect.CenterCell);
LongEventHandler.QueueLongEvent(delegate
{
if (instanceMap == null)
{
return;
}
foreach (IntVec3 cell in instanceMap.AllCells)
{
Thing thing = cell.GetThingList(instanceMap).Find((Thing x) => x.def == CthulhuFactionsDefOf.ROM_TemporaryDoorMarker);
if (thing == null)
{
//Log.Warning("Could not destroy temporary region barrier at " + cell + " because it's not here.");
}
else
{
if (thing.def == CthulhuFactionsDefOf.ROM_TemporaryDoorMarker)
{
newThing = null;
newThing = ThingMaker.MakeThing(ThingDefOf.Door, ThingDefOf.Steel);
newThing.SetFaction(instanceFaction, null);
//newThing.Rotation = thing.Rotation;
tempIntVec = new IntVec3(cell.x, 0, cell.z);
GenSpawn.Spawn(newThing, tempIntVec, instanceMap);
}
thing.Destroy(DestroyMode.Vanish);
}
}
foreach (Pawn pawn in instanceMap.mapPawns.AllPawnsSpawned.FindAll((Pawn x) => x != null && x.Spawned && x.RaceProps.intelligence >= Intelligence.ToolUser && !x.IsColonist && x.Faction != instanceFaction && x.guest != null && SymbolResolver_FillCells.IsCosmicHorrorFaction(x.Faction) == false))
{
pawn.guest.SetGuestStatus(instanceFaction, true);
}
foreach (Building_Bed bed in instanceMap.listerThings.AllThings.FindAll((Thing x) => x != null && x is Building_Bed && x.def == ThingDefOf.SleepingSpot && x.Faction == instanceFaction))
{
bed.ForPrisoners = true;
}
}, "doorResolver", true, null);
}
public virtual void PassingParameters(ResolveParams rp)
{
}
public override void PassingParameters(ResolveParams rp)
{
var map = BaseGen.globalSettings.map;
//Manual Override this mofo
var size = 9;
var minX = rp.rect.CenterCell.x - size;
_ = rp.rect.CenterCell.x + size;
var minZ = rp.rect.CenterCell.z - size;
_ = rp.rect.CenterCell.z + size;
var rectOverride = new CellRect(minX, minZ - (int)RectSizeValues.BASEOFFSET, size, size);
rp.rect = rectOverride;
UnfogRoomCenter(rp.rect.CenterCell);
//Bring in MERF
var singlePawnLord = rp.singlePawnLord ??
LordMaker.MakeNewLord(rp.faction,
new LordJob_DefendBase(rp.faction, rp.rect.CenterCell), map);
var resolveParams = rp;
resolveParams.rect = rp.rect.ExpandedBy(1);
resolveParams.faction = rp.faction;
resolveParams.singlePawnLord = singlePawnLord;
resolveParams.pawnGroupKindDef = PawnGroupKindDefOf.Combat; //CthulhuFactionsDefOf.ROM_AgencyMERF;
float points = 5000;
resolveParams.pawnGroupMakerParams = new PawnGroupMakerParms
{
tile = map.Tile,
faction = rp.faction,
points = points
};
BaseGen.symbolStack.Push("pawnGroup", resolveParams);
var thingDef = ThingDefOf.Steel;
var floorDef = TerrainDefOf.MetalTile;
//Faction values are read in reverse of their push.
// Programmed like: Checkpoint doors -> Lobby -> Edge Walls -> Floor -> Clear
// Read Like: Clear -> Floor -> Edge Walls -> Lobby -> Chokepoint doors
//
// Tip:
// Doors must be defined in the program first to avoid region errors.
//ROOF
if (!rp.noRoof.HasValue || !rp.noRoof.Value)
{
BaseGen.symbolStack.Push("roof", rp);
}
//DOORS
var resolveParams0 = rp;
BaseGen.symbolStack.Push("agencyDoorsNS", resolveParams0);
//LOBBY VALUES
var superParams = rp;
_ = IntVec3.Invalid;
superParams.rect = FactionUtility.AdjacentRectMaker(rp.rect, Rot4.North, out var doorLoc,
(int)RectSizeValues.LOBBY, (int)RectSizeValues.LOBBYHEIGHT);
var resolveParamsDoor = rp;
resolveParamsDoor.rect = CellRect.SingleCell(doorLoc);
resolveParamsDoor.singleThingDef = CthulhuFactionsDefOf.ROM_TemporaryDoorMarker;
BaseGen.symbolStack.Push("thing", resolveParamsDoor);
BaseGen.symbolStack.Push("agencyLobby", superParams);
//CustomBaseUtility.replaceFloor(superParams, Utility.factionFloorStuff);
//CustomBaseUtility.replaceWalls(superParams, Utility.factionWallStuff);
//CLEAR/FLOOR/WALLS
var resolveParams2 = rp;
resolveParams2.wallStuff = thingDef;
BaseGen.symbolStack.Push("edgeWalls", resolveParams2);
var resolveParams3 = rp;
resolveParams3.floorDef = floorDef;
BaseGen.symbolStack.Push("floor", resolveParams3);
BaseGen.symbolStack.Push("clear", resolveParams);
//CustomBaseUtility.replaceFloor(resolveParams3, Utility.factionFloorStuff);
//CustomBaseUtility.replaceWalls(resolveParams3, Utility.factionWallStuff);
FactionUtility.RectReport(rp.rect);
}
public override void PassingParameters(ResolveParams rp)
{
var defChair = "DiningChair";
var defLamp = "Jecrell_GasLamp";
var lampDef = Utility.IsIndustrialAgeLoaded() ? ThingDef.Named(defLamp) : ThingDefOf.TorchLamp;
var lampStuffDef = Utility.IsIndustrialAgeLoaded() ? ThingDefOf.Steel : null;
var map = BaseGen.globalSettings.map;
var @bool = Rand.Bool;
var hasLamp = false;
var thingDef = ThingDefOf.SleepingSpot;
var chairDef = ThingDef.Named(defChair);
foreach (var 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;
}
var rot = !@bool ? Rot4.South : Rot4.West;
if (GenSpawn.WouldWipeAnythingWith(current, rot, thingDef, map,
x => x.def.category == ThingCategory.Building))
{
continue;
}
{
var doorNear = false;
foreach (var current2 in GenAdj.CellsOccupiedBy(current, rot, thingDef.Size))
{
if (!BaseGenUtility.AnyDoorAdjacentCardinalTo(current2, map))
{
continue;
}
doorNear = true;
break;
}
if (doorNear)
{
continue;
}
//Bed
ThingDef stuff = null;
if (thingDef.MadeFromStuff)
{
stuff = ThingDefOf.WoodLog;
}
var thing = ThingMaker.MakeThing(thingDef, stuff);
thing.SetFaction(rp.faction);
GenSpawn.Spawn(thing, current, map, rot);
if (!thing.Spawned || !thing.Position.InBounds(map))
{
continue;
}
var thingRect = thing.OccupiedRect();
thingRect = thingRect.ExpandedBy(1);
var 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(Utility.GetCornerPos(thingRect, 0));
possibleCells.Remove(Utility.GetCornerPos(thingRect, 1));
possibleCells.Remove(Utility.GetCornerPos(thingRect, 2));
possibleCells.Remove(Utility.GetCornerPos(thingRect, 3));
var spawnPos = possibleCells.InRandomOrder()
.FirstOrDefault(x => x.InBounds(map) && x.Walkable(map));
possibleCells.Remove(spawnPos);
var thing2 = ThingMaker.MakeThing(chairDef, ThingDefOf.WoodLog);
thing2.SetFaction(rp.faction);
GenSpawn.Spawn(thing2, spawnPos, map, rot.Opposite);
if (hasLamp)
{
continue;
}
hasLamp = true;
spawnPos = possibleCells.FirstOrDefault(x =>
x.InBounds(map) && x.Walkable(map));
possibleCells.Remove(spawnPos);
var thing3 = ThingMaker.MakeThing(lampDef, lampStuffDef);
thing3.SetFaction(rp.faction);
GenSpawn.Spawn(thing3, spawnPos, map, rot.Opposite);
}
}
//if (!Cthulhu.Utility.IsCosmicHorrorsLoaded())
//{
var unused = rp.pawnGroupKindDef ?? PawnGroupKindDefOf.Combat;
var pawnGroupMakerParms = new PawnGroupMakerParms
{
faction = (from x in Find.FactionManager.AllFactions
where x.HostileTo(rp.faction) && x.def.pawnGroupMakers is { Count : > 0 } && x.def.humanlikeFaction &&
