public override void GenerateRect(Stencil s)
{
if (!Config_Cities.Instance.enableTurrets)
{
return;
}
var stuff = GenCity.RandomStuff(ThingDefOf.Sandbags, s.map);
for (var dir = 0; dir < 4; dir++)
{
var sDir = s.Rotate(dir);
for (var x = sDir.MinX; x <= sDir.MaxX; x++)
{
if (x <= sDir.MinX / 2 || x >= sDir.MaxX / 2)
{
sDir.Spawn(x, sDir.MaxZ, ThingDefOf.Sandbags, stuff);
}
}
}
var emplacementOption = options
.Where(opt => {
if (opt.selfDestructive)
{
return(Config_Cities.Instance.enableMortars && (s.map.ParentFaction.def.permanentEnemy || s.map.Parent is Citadel));
}
return(Config_Cities.Instance.enableTurrets);
})
.RandomElementByWeight(opt => opt.weight);
emplacementOption?.Generate(s);
}
public override void Decorate(Stencil s)
{
var floorStuff = GenCity.RandomFloor(s.map);
var columnStuff = GenCity.RandomStuff(ThingDefOf.Column, s.map);
var distance = distanceRange.RandomInRange;
for (var dir = 0; dir < 4; dir++)
{
var sDir = s.Rotate(dir);
sDir = sDir.Bound(sDir.MinX, sDir.MaxZ + 1, sDir.MaxX, sDir.MaxZ + distance);
if (dir % 2 == 0)
{
sDir = sDir.Expand(distance, 0, distance, 0);
}
var spacing = columnSpacingRange.RandomInRange;
for (var x = sDir.MinX + Rand.Range(0, spacing); x <= sDir.MaxX; x += spacing)
{
var sCol = sDir.Move(x, sDir.MaxZ);
if (sCol.IsInMap() && IsValidTile(s.map, sCol.pos))
{
sCol.Spawn(ThingDefOf.Column, columnStuff);
}
}
sDir.FillRoof(RoofDefOf.RoofConstructed)
.FillTerrain(floorStuff, IsValidTile);
}
}
protected override void ScatterAt(IntVec3 pos, Map map, GenStepParams parms, int count)
{
var s = new Stencil(map);
s = s.BoundTo(CellRect.FromLimits(pos, s.bounds.RandomCell));
var stuff = GenCity.RandomWallStuff(map);
for (var dir = 0; dir < 4; dir++)
{
var sDir = s.Rotate(dir);
sDir.Fill(sDir.MinX, sDir.MaxZ, sDir.MaxX, sDir.MaxZ, ThingDefOf.Wall, stuff, IsValidTile);
}
}
public override void Decorate(Stencil s)
{
Stencil.Mask mask = p => TerrainUtility.IsNatural(p.GetTerrain(s.map));
for (var dir = 0; dir < 4; dir++)
{
var sDir = s.Rotate(dir);
sDir.Bound(sDir.MinX - distance, sDir.MaxZ + distance, sDir.MinX / 2, sDir.MaxZ + distance)
.Fill(ThingDefOf.Sandbags, mask: mask);
sDir.Bound(sDir.MaxX / 2, sDir.MaxZ + distance, sDir.MaxX + distance, sDir.MaxZ + distance)
.Fill(ThingDefOf.Sandbags, mask: mask);
}
}
public override void GenerateRect(Stencil s)
{
s.FillTerrain(GenCity.RandomFloor(s.map));
var pawn = (Pawn)null;
if (!s.map.ParentFaction.HostileTo(Faction.OfPlayer))
{
pawn = GenCity.SpawnInhabitant(s.Coords(s.RandX / 2, s.RandZ / 2), s.map);
var traderKind = DefDatabase <TraderKindDef> .AllDefs.RandomElement();
pawn.mindState.wantsToTradeWithColony = true;
PawnComponentsUtility.AddAndRemoveDynamicComponents(pawn, true);
pawn.trader.traderKind = traderKind;
pawn.inventory.DestroyAll();
var parms = new ThingSetMakerParams {
traderDef = traderKind,
tile = s.map.Tile,
makingFaction = s.map.ParentFaction,
};
foreach (var item in ThingSetMakerDefOf.TraderStock.root.Generate(parms))
{
if (!(item is Pawn) && !pawn.inventory.innerContainer.TryAdd(item))
{
item.Destroy();
}
}
PawnInventoryGenerator.GiveRandomFood(pawn);
}
for (var dir = 0; dir < 4; dir++)
{
if (s.Chance(standChance))
{
var sStand = s.Rotate(dir).Move(Mathf.RoundToInt(s.RandX / 2F), s.MaxZ - s.RandInclusive(0, 2)).Bound(-1, 0, 1, 0);
sStand.FillTerrain(GenCity.RandomFloor(s.map, true));
var wallStuff = GenCity.RandomWallStuff(s.map);
sStand.Spawn(sStand.MinX - 1, 0, ThingDefOf.Wall, wallStuff);
sStand.Spawn(sStand.MaxX + 1, 0, ThingDefOf.Wall, wallStuff);
sStand.Expand(1).FillRoof(RoofDefOf.RoofConstructed);
// if (pawn != null) {
// var itemPos = sStand.Coords(sStand.RandX, sStand.RandZ);
// var item = pawn.inventory.innerContainer.FirstOrDefault();
// if (item != null) {
// pawn.inventory.innerContainer.TryDrop(item, itemPos, s.map, ThingPlaceMode.Direct, out var result);
// item.SetOwnedByCity(true, s.map);
// }
// }
}
}
}
public override void Decorate(Stencil s)
{
var thing = Rand.Chance(barricadeChance) ? ThingDefOf.Barricade : ThingDefOf.Sandbags;
var stuff = GenCity.RandomStuff(thing, s.map);
for (var dir = 0; dir < 4; dir++)
{
var sDir = s.Rotate(dir);
sDir.Bound(sDir.MinX - distance, sDir.MaxZ + distance, sDir.MinX / 2, sDir.MaxZ + distance)
.Fill(thing, stuff, mask: IsValidTile);
sDir.Bound(sDir.MaxX / 2, sDir.MaxZ + distance, sDir.MaxX + distance, sDir.MaxZ + distance)
.Fill(thing, stuff, mask: IsValidTile);
}
}
public override void Decorate(Stencil s)
{
var stuff = GenCity.RandomStuff(ThingDefOf.Bed, s.map);
var sDresser = s.Rotate(s.RandInclusive(0, 1) * 2);
sDresser.Spawn(s.RandInclusive(sDresser.MinX + 1, sDresser.MaxX - 1), sDresser.MinZ + 1, DefDatabase <ThingDef> .GetNamed("Dresser"), stuff);
var bedX = s.RandX;
s.Spawn(bedX, s.MinZ, DefDatabase <ThingDef> .GetNamed("EndTable"), stuff);
var bed = (Building_Bed)s.Spawn(bedX, s.MinZ + 1, ThingDefOf.Bed, stuff);
bed.SetFactionDirect(s.map.ParentFaction);
var pawn = GenCity.SpawnInhabitant(s.Chance(pawnInBedroomChance) ? s.pos : s.MapBounds.RandomCell, s.map, null, randomWorkSpot: true);
bed.CompAssignableToPawn.TryAssignPawn(pawn);
}
public override void GenerateRect(Stencil s)
{
GenRooms(s, true);
var wallStuff = RandomWallStuff(s.map);
var doorStuff = RandomWallStuff(s.map);
var hasDoor = false;
for (var dir = 0; dir < 4; dir++)
{
var sDir = s.Rotate(dir);
var doorHere = !hasDoor || s.Chance(doorChance);
if (doorHere)
{
hasDoor = true;
var offset = sDir.RandInclusive(0, 2) + 2;
var doorZ = sDir.Chance(.5F) ? sDir.MinZ + offset : sDir.MaxZ - offset;
for (var z = sDir.MinZ; z < sDir.MaxZ; z++)
{
if (z != doorZ)
{
sDir.Spawn(sDir.MaxX, z, ThingDefOf.Wall, doorStuff);
}
else
{
sDir.Move(sDir.MaxX + 1, z).ClearBuildingsAtPos();
sDir.Spawn(sDir.MaxX, z, ThingDefOf.Door, wallStuff);
}
}
}
else
{
sDir.Fill(sDir.MaxX, sDir.MinZ, sDir.MaxX, sDir.MaxZ - 1, ThingDefOf.Wall, wallStuff);
}
}
if (buildingDecorators.Count > 0)
{
buildingDecorators.RandomElement().Decorate(s);
}
// s.FillFog();
s.Expand(1).BorderTerrain(GenCity.RandomFloor(s.map), IsValidTile);
}
public override void GenerateRect(Stencil s)
{
var stuff = GenCity.RandomStuff(ThingDefOf.Sandbags, s.map);
for (var dir = 0; dir < 4; dir++)
{
var sDir = s.Rotate(dir);
for (var x = sDir.MinX; x <= sDir.MaxX; x++)
{
if (x <= sDir.MinX / 2 || x >= sDir.MaxX / 2)
{
sDir.Spawn(x, sDir.MaxZ, ThingDefOf.Sandbags, stuff);
}
}
}
options.Where(opt => !opt.selfDestructive || s.map.ParentFaction.def.permanentEnemy || s.map.Parent is Citadel)
.RandomElementByWeight(opt => opt.weight).Generate(s);
}
public override void Generate(Map map, GenStepParams parms)
{
var roadTerrain = roadTerrains.RandomElement();
var divTerrain = divTerrains.RandomElement();
var sidewalkTerrain = sidewalkTerrains.RandomElement();
var radius = centerRadius.RandomInRange;
var s = new Stencil(map);
s = s.MoveTo(s.Expand(-radius - 2).bounds.RandomCell);
s.Bound(-radius, -radius, radius, radius)
.ClearThingsInBounds()
.FillTerrain(sidewalkTerrains.RandomElement());
s.FillTerrain(-2, -2, 2, 2, roadTerrain);
for (var dir = 0; dir < 4; dir++)
{
GenMainRoad(s.Rotate(dir).Move(0, 3), roadTerrain, divTerrain, sidewalkTerrain);
}
}
void GenRooms(Stencil s, bool parentWall)
{
s = s.Center();
var room = roomDecorators.RandomElementByWeight(r => r.weight / r.maxArea);
if (s.Area > room.maxArea)
{
if (s.Width < s.Height)
{
s = s.Rotate(1 + s.RandInclusive(0, 1) * 2);
}
var wallX = Mathf.RoundToInt(s.RandX * .3F);
var hasWall = s.Chance(wallChance);
var doorZ = 0; // default unused
if (hasWall)
{
var wallStuff = RandomWallStuff(s.map);
if (parentWall)
{
var offset = s.RandInclusive(0, 2) + 1;
doorZ = s.Chance(.5F) ? s.MinZ + offset : s.MaxZ - offset;
var minZ = s.MinZ + 1;
var maxZ = s.MaxZ - 1;
for (var z = minZ; z <= maxZ; z++)
{
if (z != doorZ)
{
s.Spawn(wallX, z, ThingDefOf.Wall, wallStuff);
}
}
// TODO dry
}
else
{
s.Fill(wallX, s.MinZ + 1, wallX, s.MaxZ - 1, ThingDefOf.Wall, RandomWallStuff(s.map));
}
}
var left = s.Bound(s.MinX, s.MinZ, wallX, s.MaxZ);
var right = s.Bound(wallX, s.MinZ, s.MaxX, s.MaxZ);
GenRooms(left, hasWall);
GenRooms(right, hasWall);
if (hasWall && parentWall)
{
s.Spawn(wallX, doorZ, ThingDefOf.Door, RandomWallStuff(s.map));
}
}
else
{
var sInterior = s.Expand(-1);
sInterior.ClearThingsInBounds();
s.FillTerrain(RandomFloor(s.map));
if (room.roofed)
{
s.FillRoof(RoofDefOf.RoofConstructed);
}
if (s.Chance(room.lightChance))
{
var sLamp = s.Expand(-1).MoveRand();
sLamp.Spawn(ThingDefOf.StandingLamp);
}
try {
room.Decorate(sInterior);
}
catch {
Log.Error("Error occurred in room decorator type: " + room.GetType().Name);
throw;
}
}
}
