protected override void ResolveInt(ResolveParams parms) { CellRect outerRect = parms.rect ?? parms.sketch.OccupiedRect; bool allowWood = parms.allowWood ?? true; ThingDef stuff = GenStuff.RandomStuffInexpensiveFor(parms.wallEdgeThing, null, (ThingDef x) => SketchGenUtility.IsStuffAllowed(x, allowWood, parms.useOnlyStonesAvailableOnMap, allowFlammableWalls: true, parms.wallEdgeThing)); Rot4 rot = ((parms.wallEdgeThing.size.z > parms.wallEdgeThing.size.x) ? Rot4.North : Rot4.East); Rot4 rot2 = ((parms.wallEdgeThing.size.z > parms.wallEdgeThing.size.x) ? Rot4.East : Rot4.North); CellRect cellRect = GenAdj.OccupiedRect(default(IntVec3), rot, parms.wallEdgeThing.size); CellRect cellRect2 = GenAdj.OccupiedRect(default(IntVec3), rot2, parms.wallEdgeThing.size); bool requireFloor = parms.requireFloor ?? false; processed.Clear(); try { foreach (IntVec3 item in outerRect.Cells.InRandomOrder()) { CellRect cellRect3 = SketchGenUtility.FindBiggestRectAt(item, outerRect, parms.sketch, processed, (IntVec3 x) => !parms.sketch.ThingsAt(x).Any() && (!requireFloor || (parms.sketch.TerrainAt(x) != null && parms.sketch.TerrainAt(x).layerable))); if (cellRect3.Width < cellRect.Width || cellRect3.Height < cellRect.Height || cellRect3.Width < cellRect2.Width || cellRect3.Height < cellRect2.Height || !Rand.Chance(0.2f)) { continue; } CellRect rect = new CellRect(cellRect3.minX, cellRect3.CenterCell.z - cellRect.Height / 2, cellRect.Width, cellRect.Height); CellRect rect2 = new CellRect(cellRect3.maxX - (cellRect.Width - 1), cellRect3.CenterCell.z - cellRect.Height / 2, cellRect.Width, cellRect.Height); CellRect rect3 = new CellRect(cellRect3.CenterCell.x - cellRect2.Width / 2, cellRect3.maxZ - (cellRect2.Height - 1), cellRect2.Width, cellRect2.Height); CellRect rect4 = new CellRect(cellRect3.CenterCell.x - cellRect2.Width / 2, cellRect3.minZ, cellRect2.Width, cellRect2.Height); if ((Rand.Bool && CanPlaceAt(rect, Rot4.West, parms.sketch)) || CanPlaceAt(rect2, Rot4.East, parms.sketch)) { if (Rand.Bool && CanPlaceAt(rect, Rot4.West, parms.sketch)) { parms.sketch.AddThing(parms.wallEdgeThing, new IntVec3(rect.minX - cellRect.minX, 0, rect.minZ - cellRect.minZ), rot, stuff, 1, null, null, wipeIfCollides: false); } else if (CanPlaceAt(rect2, Rot4.East, parms.sketch)) { parms.sketch.AddThing(parms.wallEdgeThing, new IntVec3(rect2.minX - cellRect.minX, 0, rect2.minZ - cellRect.minZ), rot, stuff, 1, null, null, wipeIfCollides: false); } } else if (Rand.Bool && CanPlaceAt(rect3, Rot4.North, parms.sketch)) { parms.sketch.AddThing(parms.wallEdgeThing, new IntVec3(rect3.minX - cellRect2.minX, 0, rect3.minZ - cellRect2.minZ), rot2, stuff, 1, null, null, wipeIfCollides: false); } else if (CanPlaceAt(rect4, Rot4.South, parms.sketch)) { parms.sketch.AddThing(parms.wallEdgeThing, new IntVec3(rect4.minX - cellRect2.minX, 0, rect4.minZ - cellRect2.minZ), rot2, stuff, 1, null, null, wipeIfCollides: false); } } } finally { processed.Clear(); } }
private static bool TryFindFloors(out TerrainDef floor1, out TerrainDef floor2, ResolveParams parms) { Predicate <TerrainDef> validator = (TerrainDef x) => SketchGenUtility.IsFloorAllowed_NewTmp(x, parms.allowWood ?? true, parms.allowConcrete ?? true, parms.useOnlyStonesAvailableOnMap, parms.onlyBuildableByPlayer ?? false, parms.onlyStoneFloors ?? true); if (!BaseGenUtility.TryRandomInexpensiveFloor(out floor1, validator)) { floor2 = null; return(false); } if (parms.singleFloorType ?? false) { floor2 = null; return(true); } TerrainDef floor1Local = floor1; return(BaseGenUtility.TryRandomInexpensiveFloor(out floor2, (TerrainDef x) => x != floor1Local && (validator == null || validator(x)))); }
protected override void ResolveInt(ResolveParams parms) { CellRect outerRect = parms.rect ?? parms.sketch.OccupiedRect; HashSet <IntVec3> processed = new HashSet <IntVec3>(); foreach (IntVec3 c in outerRect.Cells.InRandomOrder()) { CellRect cellRect = SketchGenUtility.FindBiggestRectAt(c, outerRect, parms.sketch, processed, (IntVec3 x) => !parms.sketch.ThingsAt(x).Any() && parms.sketch.AnyTerrainAt(c)); if (cellRect.Width >= 7 && cellRect.Height >= 7) { int newX = Rand.RangeInclusive(5, cellRect.Width - 2); int newZ = Rand.RangeInclusive(5, cellRect.Height - 2); Sketch sketch = new Sketch(); ResolveParams parms2 = parms; parms2.sketch = sketch; parms2.monumentSize = new IntVec2(newX, newZ); parms2.rect = null; SketchResolverDefOf.Monument.Resolve(parms2); parms.sketch.MergeAt(sketch, cellRect.CenterCell, Sketch.SpawnPosType.OccupiedCenter, wipeIfCollides: false); } } }
protected override void ResolveInt(ResolveParams parms) { CellRect outerRect = parms.rect ?? parms.sketch.OccupiedRect; bool allowWood = parms.allowWood ?? true; ThingDef stuff = GenStuff.RandomStuffInexpensiveFor(parms.thingCentral, null, (ThingDef x) => SketchGenUtility.IsStuffAllowed(x, allowWood, parms.useOnlyStonesAvailableOnMap, allowFlammableWalls: true, parms.thingCentral)); bool requireFloor = parms.requireFloor ?? false; processed.Clear(); try { foreach (IntVec3 item in outerRect.Cells.InRandomOrder()) { CellRect cellRect = SketchGenUtility.FindBiggestRectAt(item, outerRect, parms.sketch, processed, (IntVec3 x) => !parms.sketch.ThingsAt(x).Any() && (!requireFloor || (parms.sketch.TerrainAt(x) != null && parms.sketch.TerrainAt(x).layerable))); if (cellRect.Width >= parms.thingCentral.size.x + 2 && cellRect.Height >= parms.thingCentral.size.z + 2 && Rand.Chance(0.4f)) { parms.sketch.AddThing(parms.thingCentral, new IntVec3(cellRect.CenterCell.x - parms.thingCentral.size.x / 2, 0, cellRect.CenterCell.z - parms.thingCentral.size.z / 2), Rot4.North, stuff, 1, null, null, wipeIfCollides: false); } } } finally { processed.Clear(); } }
protected override void ResolveInt(ResolveParams parms) { IntVec2 intVec; if (parms.monumentSize.HasValue) { intVec = parms.monumentSize.Value; } else { int num = Rand.Range(10, 50); intVec = new IntVec2(num, num); } int width = intVec.x; int height = intVec.z; bool flag = ((!parms.monumentOpen.HasValue) ? Rand.Chance(OpenChancePerSizeCurve.Evaluate(Mathf.Max(width, height))) : parms.monumentOpen.Value); Sketch monument = new Sketch(); bool onlyBuildableByPlayer = parms.onlyBuildableByPlayer ?? false; bool filterAllowsAll = parms.allowedMonumentThings == null; List <IntVec3> list = new List <IntVec3>(); bool horizontalSymmetry; bool verticalSymmetry; if (flag) { horizontalSymmetry = true; verticalSymmetry = true; bool[,] array = AbstractShapeGenerator.Generate(width, height, horizontalSymmetry, verticalSymmetry, allTruesMustBeConnected: false, allowEnclosedFalses: false, preferOutlines: true); for (int i = 0; i < array.GetLength(0); i++) { for (int j = 0; j < array.GetLength(1); j++) { if (array[i, j]) { monument.AddThing(ThingDefOf.Wall, new IntVec3(i, 0, j), Rot4.North, ThingDefOf.WoodLog); } } } } else { horizontalSymmetry = Rand.Bool; verticalSymmetry = !horizontalSymmetry || Rand.Bool; bool[,] shape = AbstractShapeGenerator.Generate(width - 2, height - 2, horizontalSymmetry, verticalSymmetry, allTruesMustBeConnected: true); Func <int, int, bool> func = (int x, int z) => x >= 0 && z >= 0 && x < shape.GetLength(0) && z < shape.GetLength(1) && shape[x, z]; for (int k = -1; k < shape.GetLength(0) + 1; k++) { for (int l = -1; l < shape.GetLength(1) + 1; l++) { if (!func(k, l) && (func(k - 1, l) || func(k, l - 1) || func(k, l + 1) || func(k + 1, l) || func(k - 1, l - 1) || func(k - 1, l + 1) || func(k + 1, l - 1) || func(k + 1, l + 1))) { int newX = k + 1; int newZ = l + 1; monument.AddThing(ThingDefOf.Wall, new IntVec3(newX, 0, newZ), Rot4.North, ThingDefOf.WoodLog); } } } for (int m = -1; m < shape.GetLength(0) + 1; m++) { for (int n = -1; n < shape.GetLength(1) + 1; n++) { if (!func(m, n) && (func(m - 1, n) || func(m, n - 1) || func(m, n + 1) || func(m + 1, n))) { int num2 = m + 1; int num3 = n + 1; if ((!func(m - 1, n) && monument.Passable(new IntVec3(num2 - 1, 0, num3))) || (!func(m, n - 1) && monument.Passable(new IntVec3(num2, 0, num3 - 1))) || (!func(m, n + 1) && monument.Passable(new IntVec3(num2, 0, num3 + 1))) || (!func(m + 1, n) && monument.Passable(new IntVec3(num2 + 1, 0, num3)))) { list.Add(new IntVec3(num2, 0, num3)); } } } } } ResolveParams parms2 = parms; parms2.sketch = monument; parms2.connectedGroupsSameStuff = true; parms2.assignRandomStuffTo = ThingDefOf.Wall; SketchResolverDefOf.AssignRandomStuff.Resolve(parms2); if (parms.addFloors ?? true) { ResolveParams parms3 = parms; parms3.singleFloorType = true; parms3.sketch = monument; parms3.floorFillRoomsOnly = !flag; parms3.onlyStoneFloors = parms.onlyStoneFloors ?? true; parms3.allowConcrete = parms.allowConcrete ?? false; parms3.rect = new CellRect(0, 0, width, height); SketchResolverDefOf.FloorFill.Resolve(parms3); } if (CanUse(ThingDefOf.Column)) { ResolveParams parms4 = parms; parms4.rect = new CellRect(0, 0, width, height); parms4.sketch = monument; parms4.requireFloor = true; SketchResolverDefOf.AddColumns.Resolve(parms4); } TryPlaceFurniture(parms, monument, CanUse); for (int num4 = 0; num4 < 2; num4++) { ResolveParams parms5 = parms; parms5.addFloors = false; parms5.sketch = monument; parms5.rect = new CellRect(0, 0, width, height); SketchResolverDefOf.AddInnerMonuments.Resolve(parms5); } bool num5 = parms.allowMonumentDoors ?? (filterAllowsAll || parms.allowedMonumentThings.Allows(ThingDefOf.Door)); if (num5 && list.Where((IntVec3 x) => (!horizontalSymmetry || x.x < width / 2) && (!verticalSymmetry || x.z < height / 2) && monument.ThingsAt(x).Any((SketchThing y) => y.def == ThingDefOf.Wall) && ((!monument.ThingsAt(new IntVec3(x.x - 1, x.y, x.z)).Any() && !monument.ThingsAt(new IntVec3(x.x + 1, x.y, x.z)).Any()) || (!monument.ThingsAt(new IntVec3(x.x, x.y, x.z - 1)).Any() && !monument.ThingsAt(new IntVec3(x.x, x.y, x.z + 1)).Any()))).TryRandomElement(out var result)) { SketchThing sketchThing = monument.ThingsAt(result).FirstOrDefault((SketchThing x) => x.def == ThingDefOf.Wall); if (sketchThing != null) { monument.Remove(sketchThing); monument.AddThing(ThingDefOf.Door, result, Rot4.North, sketchThing.Stuff); } } TryPlaceFurniture(parms, monument, CanUse); ApplySymmetry(parms, horizontalSymmetry, verticalSymmetry, monument, width, height); if (num5 && !flag && !monument.Things.Any((SketchThing x) => x.def == ThingDefOf.Door) && monument.Things.Where((SketchThing x) => x.def == ThingDefOf.Wall && ((monument.Passable(x.pos.x - 1, x.pos.z) && monument.Passable(x.pos.x + 1, x.pos.z) && monument.AnyTerrainAt(x.pos.x - 1, x.pos.z) != monument.AnyTerrainAt(x.pos.x + 1, x.pos.z)) || (monument.Passable(x.pos.x, x.pos.z - 1) && monument.Passable(x.pos.x, x.pos.z + 1) && monument.AnyTerrainAt(x.pos.x, x.pos.z - 1) != monument.AnyTerrainAt(x.pos.x, x.pos.z + 1)))).TryRandomElement(out var result2)) { SketchThing sketchThing2 = monument.ThingsAt(result2.pos).FirstOrDefault((SketchThing x) => x.def == ThingDefOf.Wall); if (sketchThing2 != null) { monument.Remove(sketchThing2); } monument.AddThing(ThingDefOf.Door, result2.pos, Rot4.North, result2.Stuff); } List <SketchThing> things = monument.Things; for (int num6 = 0; num6 < things.Count; num6++) { if (things[num6].def == ThingDefOf.Wall) { monument.RemoveTerrain(things[num6].pos); } } parms.sketch.MergeAt(monument, default(IntVec3), Sketch.SpawnPosType.OccupiedCenter); bool CanUse(ThingDef def) { if (onlyBuildableByPlayer && !SketchGenUtility.PlayerCanBuildNow(def)) { return(false); } if (!filterAllowsAll && !parms.allowedMonumentThings.Allows(def)) { return(false); } return(true); } }
protected override void ResolveInt(ResolveParams parms) { CellRect outerRect = parms.rect ?? parms.sketch.OccupiedRect; bool allowWood = parms.allowWood ?? true; bool flag = parms.requireFloor ?? false; rects.Clear(); processed.Clear(); foreach (IntVec3 item2 in outerRect.Cells.InRandomOrder()) { CellRect item = SketchGenUtility.FindBiggestRectAt(item2, outerRect, parms.sketch, processed, (IntVec3 x) => !AnyColumnBlockerAt(x, parms.sketch)); if (!item.IsEmpty) { rects.Add(item); } } ThingDef stuff = GenStuff.RandomStuffInexpensiveFor(ThingDefOf.Column, null, (ThingDef x) => SketchGenUtility.IsStuffAllowed(x, allowWood, parms.useOnlyStonesAvailableOnMap, allowFlammableWalls: true, ThingDefOf.Column)); for (int i = 0; i < rects.Count; i++) { if (rects[i].Width < 3 || rects[i].Height < 3 || !Rand.Chance(0.8f)) { continue; } CellRect cellRect = rects[i].ContractedBy(1); Sketch sketch = new Sketch(); if (Rand.Bool) { int newZ = Rand.RangeInclusive(cellRect.minZ, cellRect.CenterCell.z); int num = ((cellRect.Width >= 4) ? Rand.Element(2, 3) : 2); for (int j = cellRect.minX; j <= cellRect.maxX; j += num) { if (!flag || parms.sketch.AnyTerrainAt(new IntVec3(j, 0, newZ))) { sketch.AddThing(ThingDefOf.Column, new IntVec3(j, 0, newZ), Rot4.North, stuff); } } ResolveParams parms2 = parms; parms2.sketch = sketch; parms2.symmetryOrigin = rects[i].minZ + rects[i].Height / 2; parms2.symmetryOriginIncluded = rects[i].Height % 2 == 1; SketchResolverDefOf.Symmetry.Resolve(parms2); } else { int newX = Rand.RangeInclusive(cellRect.minX, cellRect.CenterCell.x); int num2 = ((cellRect.Height >= 4) ? Rand.Element(2, 3) : 2); for (int k = cellRect.minZ; k <= cellRect.maxZ; k += num2) { if (!flag || parms.sketch.AnyTerrainAt(new IntVec3(newX, 0, k))) { sketch.AddThing(ThingDefOf.Column, new IntVec3(newX, 0, k), Rot4.North, stuff); } } ResolveParams parms3 = parms; parms3.sketch = sketch; parms3.symmetryOrigin = rects[i].minX + rects[i].Width / 2; parms3.symmetryOriginIncluded = rects[i].Width % 2 == 1; SketchResolverDefOf.Symmetry.Resolve(parms3); } parms.sketch.Merge(sketch, wipeIfCollides: false); } rects.Clear(); processed.Clear(); }
protected override void ResolveInt(ResolveParams parms) { ThingDef assignRandomStuffTo = parms.assignRandomStuffTo; bool flag = parms.connectedGroupsSameStuff ?? false; bool allowWood = parms.allowWood ?? true; bool allowFlammableWalls = parms.allowFlammableWalls ?? true; thingsAt.Clear(); foreach (SketchThing thing2 in parms.sketch.Things) { if (assignRandomStuffTo != null && thing2.def != assignRandomStuffTo) { continue; } foreach (IntVec3 item in thing2.OccupiedRect) { if (!thingsAt.TryGetValue(item, out var value)) { value = new List <SketchThing>(); thingsAt.Add(item, value); } value.Add(thing2); } } visited.Clear(); foreach (SketchThing thing in parms.sketch.Things) { if ((assignRandomStuffTo != null && thing.def != assignRandomStuffTo) || visited.Contains(thing)) { continue; } ThingDef stuff = GenStuff.RandomStuffInexpensiveFor(thing.def, null, (ThingDef x) => SketchGenUtility.IsStuffAllowed(x, allowWood, parms.useOnlyStonesAvailableOnMap, allowFlammableWalls, thing.def)); thing.stuff = stuff; visited.Add(thing); if (!flag) { continue; } stack.Clear(); stack.Push(thing); while (stack.Count != 0) { SketchThing sketchThing = stack.Pop(); sketchThing.stuff = stuff; foreach (IntVec3 item2 in sketchThing.OccupiedRect.ExpandedBy(1)) { if (!thingsAt.TryGetValue(item2, out var value2)) { continue; } for (int i = 0; i < value2.Count; i++) { if (value2[i].def == thing.def && !visited.Contains(value2[i])) { visited.Add(value2[i]); stack.Push(value2[i]); } } } } } }
protected override void ResolveInt(ResolveParams parms) { wallPositions.Clear(); for (int i = 0; i < parms.sketch.Things.Count; i++) { if (parms.sketch.Things[i].def == ThingDefOf.Wall) { wallPositions.Add(parms.sketch.Things[i].pos); } } bool allowWood = parms.allowWood ?? true; ThingDef stuff = GenStuff.RandomStuffInexpensiveFor(parms.cornerThing, null, (ThingDef x) => SketchGenUtility.IsStuffAllowed(x, allowWood, parms.useOnlyStonesAvailableOnMap, allowFlammableWalls: true, parms.cornerThing)); bool flag = parms.requireFloor ?? false; try { foreach (IntVec3 wallPosition in wallPositions) { if (Rand.Chance(0.09f)) { if (wallPositions.Contains(new IntVec3(wallPosition.x + 1, 0, wallPosition.z - 1)) && !wallPositions.Contains(new IntVec3(wallPosition.x + 1, 0, wallPosition.z)) && (!flag || (parms.sketch.TerrainAt(new IntVec3(wallPosition.x + 1, 0, wallPosition.z)) != null && parms.sketch.TerrainAt(new IntVec3(wallPosition.x + 1, 0, wallPosition.z)).layerable))) { parms.sketch.AddThing(parms.cornerThing, new IntVec3(wallPosition.x + 1, 0, wallPosition.z), Rot4.North, stuff, 1, null, null, wipeIfCollides: false); } if (wallPositions.Contains(new IntVec3(wallPosition.x + 1, 0, wallPosition.z - 1)) && !wallPositions.Contains(new IntVec3(wallPosition.x, 0, wallPosition.z - 1)) && (!flag || (parms.sketch.TerrainAt(new IntVec3(wallPosition.x, 0, wallPosition.z - 1)) != null && parms.sketch.TerrainAt(new IntVec3(wallPosition.x, 0, wallPosition.z - 1)).layerable))) { parms.sketch.AddThing(parms.cornerThing, new IntVec3(wallPosition.x, 0, wallPosition.z - 1), Rot4.North, stuff, 1, null, null, wipeIfCollides: false); } if (wallPositions.Contains(new IntVec3(wallPosition.x + 1, 0, wallPosition.z + 1)) && !wallPositions.Contains(new IntVec3(wallPosition.x, 0, wallPosition.z + 1)) && (!flag || (parms.sketch.TerrainAt(new IntVec3(wallPosition.x, 0, wallPosition.z + 1)) != null && parms.sketch.TerrainAt(new IntVec3(wallPosition.x, 0, wallPosition.z + 1)).layerable))) { parms.sketch.AddThing(parms.cornerThing, new IntVec3(wallPosition.x, 0, wallPosition.z + 1), Rot4.North, stuff, 1, null, null, wipeIfCollides: false); } if (wallPositions.Contains(new IntVec3(wallPosition.x + 1, 0, wallPosition.z + 1)) && !wallPositions.Contains(new IntVec3(wallPosition.x + 1, 0, wallPosition.z)) && (!flag || (parms.sketch.TerrainAt(new IntVec3(wallPosition.x + 1, 0, wallPosition.z)) != null && parms.sketch.TerrainAt(new IntVec3(wallPosition.x + 1, 0, wallPosition.z)).layerable))) { parms.sketch.AddThing(parms.cornerThing, new IntVec3(wallPosition.x + 1, 0, wallPosition.z), Rot4.North, stuff, 1, null, null, wipeIfCollides: false); } } } } finally { wallPositions.Clear(); } }