Cinka/OldThink
1
0
Fork 0
Code Issues Pull Requests Actions 3 Packages Projects Releases Wiki Activity

Dungeon generation refactor (#17121)

Browse Source
This commit is contained in:
metalgearsloth
2023-06-27 19:17:42 +10:00
committed by GitHub
parent b3d395f214
commit cca1a78384
26 changed files with 1528 additions and 496 deletions
Download Patch File Download Diff File Expand all files Collapse all files

205
Content.Server/Procedural/DungeonJob.Generator.cs
View File

@@ -20,7 +20,6 @@ public sealed partial class DungeonJob
var dungeonRotation = _dungeon.GetDungeonRotation(seed);
var dungeonTransform = Matrix3.CreateTransform(_position, dungeonRotation);
var roomPackProtos = new Dictionary<Vector2i, List<DungeonRoomPackPrototype>>();
var externalNodes = new Dictionary<DungeonRoomPackPrototype, HashSet<Vector2i>>();
var fallbackTile = new Tile(_tileDefManager[prefab.Tile].TileId);
foreach (var pack in _prototype.EnumeratePrototypes<DungeonRoomPackPrototype>())
@@ -28,21 +27,6 @@ public sealed partial class DungeonJob
var size = pack.Size;
var sizePacks = roomPackProtos.GetOrNew(size);
sizePacks.Add(pack);
// Determine external connections; these are only valid when adjacent to a room node.
// We use this later to determine which room packs connect to each other
var nodes = new HashSet<Vector2i>();
externalNodes.Add(pack, nodes);
foreach (var room in pack.Rooms)
{
var rator = new Box2iEdgeEnumerator(room, false);
while (rator.MoveNext(out var index))
{
nodes.Add(index);
}
}
}
// Need to sort to make the RNG deterministic (at least without prototype changes).
@@ -52,7 +36,7 @@ public sealed partial class DungeonJob
string.Compare(x.ID, y.ID, StringComparison.Ordinal));
}
var roomProtos = new Dictionary<Vector2i, List<DungeonRoomPrototype>>();
var roomProtos = new Dictionary<Vector2i, List<DungeonRoomPrototype>>(_prototype.Count<DungeonRoomPrototype>());
foreach (var proto in _prototype.EnumeratePrototypes<DungeonRoomPrototype>())
{
@@ -80,60 +64,13 @@ public sealed partial class DungeonJob
roomA.Sort((x, y) =>
string.Compare(x.ID, y.ID, StringComparison.Ordinal));
}
// First we gather all of the edges for each roompack in the preset
// This allows us to determine which ones should connect from being adjacent
var edges = new HashSet<Vector2i>[gen.RoomPacks.Count];
for (var i = 0; i < gen.RoomPacks.Count; i++)
{
var pack = gen.RoomPacks[i];
var nodes = new HashSet<Vector2i>(pack.Width + 2 + pack.Height);
var rator = new Box2iEdgeEnumerator(pack, false);
while (rator.MoveNext(out var index))
{
nodes.Add(index);
}
edges[i] = nodes;
}
// Build up edge groups between each pack.
var connections = new Dictionary<int, Dictionary<int, HashSet<Vector2i>>>();
for (var i = 0; i < edges.Length; i++)
{
var nodes = edges[i];
var nodeConnections = connections.GetOrNew(i);
for (var j = i + 1; j < edges.Length; j++)
{
var otherNodes = edges[j];
var intersect = new HashSet<Vector2i>(nodes);
intersect.IntersectWith(otherNodes);
if (intersect.Count == 0)
continue;
nodeConnections[j] = intersect;
var otherNodeConnections = connections.GetOrNew(j);
otherNodeConnections[i] = intersect;
}
}
var tiles = new List<(Vector2i, Tile)>();
var dungeon = new Dungeon()
{
Position = _position
};
var dungeon = new Dungeon();
var availablePacks = new List<DungeonRoomPackPrototype>();
var chosenPacks = new DungeonRoomPackPrototype?[gen.RoomPacks.Count];
var packTransforms = new Matrix3[gen.RoomPacks.Count];
var packRotations = new Angle[gen.RoomPacks.Count];
var rotatedPackNodes = new HashSet<Vector2i>[gen.RoomPacks.Count];
// Actually pick the room packs and rooms
for (var i = 0; i < gen.RoomPacks.Count; i++)
@@ -159,9 +96,6 @@ public sealed partial class DungeonJob
}
// Iterate every pack
// To be valid it needs its edge nodes to overlap with every edge group
var external = connections[i];
random.Shuffle(availablePacks);
Matrix3 packTransform = default!;
var found = false;
@@ -169,11 +103,12 @@ public sealed partial class DungeonJob
foreach (var aPack in availablePacks)
{
var aExternal = externalNodes[aPack];
var startIndex = random.Next(4);
for (var j = 0; j < 4; j++)
{
var dir = (DirectionFlag) Math.Pow(2, j);
var index = (startIndex + j) % 4;
var dir = (DirectionFlag) Math.Pow(2, index);
Vector2i aPackDimensions;
if ((dir & (DirectionFlag.East | DirectionFlag.West)) != 0x0)
@@ -190,37 +125,11 @@ public sealed partial class DungeonJob
continue;
found = true;
var rotatedNodes = new HashSet<Vector2i>(aExternal.Count);
var aRotation = dir.AsDir().ToAngle();
// Get the external nodes in terms of the dungeon layout
// (i.e. rotated if necessary + translated to the room position)
foreach (var node in aExternal)
{
// Get the node in pack terms (offset from center), then rotate it
// Afterwards we offset it by where the pack is supposed to be in world terms.
var rotated = aRotation.RotateVec((Vector2) node + grid.TileSize / 2f - aPack.Size / 2f);
rotatedNodes.Add((rotated + bounds.Center).Floored());
}
foreach (var group in external.Values)
{
if (rotatedNodes.Overlaps(group))
continue;
found = false;
break;
}
if (!found)
{
continue;
}
// Use this pack
packTransform = Matrix3.CreateTransform(bounds.Center, aRotation);
packRotations[i] = aRotation;
rotatedPackNodes[i] = rotatedNodes;
pack = aPack;
break;
}
@@ -311,6 +220,9 @@ public sealed partial class DungeonJob
var templateGrid = _entManager.GetComponent<MapGridComponent>(templateMapUid);
var roomCenter = (room.Offset + room.Size / 2f) * grid.TileSize;
var roomTiles = new HashSet<Vector2i>(room.Size.X * room.Size.Y);
var exterior = new HashSet<Vector2i>(room.Size.X * 2 + room.Size.Y * 2);
var tileOffset = -roomCenter + grid.TileSize / 2f;
Box2i? mapBounds = null;
// Load tiles
for (var x = 0; x < room.Size.X; x++)
@@ -320,23 +232,42 @@ public sealed partial class DungeonJob
var indices = new Vector2i(x + room.Offset.X, y + room.Offset.Y);
var tileRef = templateGrid.GetTileRef(indices);
var tilePos = dungeonMatty.Transform((Vector2) indices + grid.TileSize / 2f - roomCenter);
var tilePos = dungeonMatty.Transform(indices + tileOffset);
var rounded = tilePos.Floored();
tiles.Add((rounded, tileRef.Tile));
roomTiles.Add(rounded);
// If this were a Box2 we'd add tilesize although here I think that's undesirable as
// for example, a box2i of 0,0,1,1 is assumed to also include the tile at 1,1
mapBounds = mapBounds?.Union(new Box2i(rounded, rounded)) ?? new Box2i(rounded, rounded);
}
}
for (var x = -1; x <= room.Size.X; x++)
{
for (var y = -1; y <= room.Size.Y; y++)
{
if (x != -1 && y != -1 && x != room.Size.X && y != room.Size.Y)
{
continue;
}
var tilePos = dungeonMatty.Transform(new Vector2i(x + room.Offset.X, y + room.Offset.Y) + tileOffset);
exterior.Add(tilePos.Floored());
}
}
var bounds = new Box2(room.Offset, room.Offset + room.Size);
var center = Vector2.Zero;
foreach (var tile in roomTiles)
{
center += ((Vector2) tile + grid.TileSize / 2f);
center += (Vector2) tile + grid.TileSize / 2f;
}
center /= roomTiles.Count;
dungeon.Rooms.Add(new DungeonRoom(roomTiles, center));
dungeon.Rooms.Add(new DungeonRoom(roomTiles, center, mapBounds!.Value, exterior));
grid.SetTiles(tiles);
tiles.Clear();
var xformQuery = _entManager.GetEntityQuery<TransformComponent>();
@@ -344,7 +275,6 @@ public sealed partial class DungeonJob
// Load entities
// TODO: I don't think engine supports full entity copying so we do this piece of shit.
var bounds = new Box2(room.Offset, room.Offset + room.Size);
foreach (var templateEnt in _lookup.GetEntitiesIntersecting(templateMapUid, bounds, LookupFlags.Uncontained))
{
@@ -391,7 +321,7 @@ public sealed partial class DungeonJob
{
position += new Vector2(-1f / 32f, 1f / 32f);
}
else if (angle.Equals(Math.PI * 1.5))
else if (angle.Equals(-Math.PI / 2f))
{
position += new Vector2(-1f / 32f, 0f);
}
@@ -399,6 +329,17 @@ public sealed partial class DungeonJob
{
position += new Vector2(0f, 1f / 32f);
}
else if (angle.Equals(Math.PI * 1.5f))
{
// I hate this but decals are bottom-left rather than center position and doing the
// matrix ops is a PITA hence this workaround for now; I also don't want to add a stupid
// field for 1 specific op on decals
if (decal.Id != "DiagonalCheckerAOverlay" &&
decal.Id != "DiagonalCheckerBOverlay")
{
position += new Vector2(-1f / 32f, 0f);
}
}
var tilePos = position.Floored();
@@ -427,16 +368,70 @@ public sealed partial class DungeonJob
}
}
// Calculate center
// Calculate center and do entrances
var dungeonCenter = Vector2.Zero;
foreach (var room in dungeon.Rooms)
{
dungeonCenter += room.Center;
dungeon.RoomTiles.UnionWith(room.Tiles);
dungeon.RoomExteriorTiles.UnionWith(room.Exterior);
}
dungeon.Center = (Vector2i) (dungeonCenter / dungeon.Rooms.Count);
foreach (var room in dungeon.Rooms)
{
dungeonCenter += room.Center;
SetDungeonEntrance(dungeon, room, random);
}
return dungeon;
}
private void SetDungeonEntrance(Dungeon dungeon, DungeonRoom room, Random random)
{
// TODO: Move to dungeonsystem.
// TODO: Look at markers and use that.
// Pick midpoints as fallback
if (room.Entrances.Count == 0)
{
var offset = random.Next(4);
// Pick an entrance that isn't taken.
for (var i = 0; i < 4; i++)
{
var dir = (Direction) ((i + offset) * 2 % 8);
Vector2i entrancePos;
switch (dir)
{
case Direction.East:
entrancePos = new Vector2i(room.Bounds.Right + 1, room.Bounds.Bottom + room.Bounds.Height / 2);
break;
case Direction.North:
entrancePos = new Vector2i(room.Bounds.Left + room.Bounds.Width / 2, room.Bounds.Top + 1);
break;
case Direction.West:
entrancePos = new Vector2i(room.Bounds.Left - 1, room.Bounds.Bottom + room.Bounds.Height / 2);
break;
case Direction.South:
entrancePos = new Vector2i(room.Bounds.Left + room.Bounds.Width / 2, room.Bounds.Bottom - 1);
break;
default:
throw new NotImplementedException();
}
// Check if it's not blocked
var blockPos = entrancePos + dir.ToIntVec() * 2;
if (i != 3 && dungeon.RoomTiles.Contains(blockPos))
{
continue;
}
room.Entrances.Add(entrancePos);
break;
}
}
}
}

997
Content.Server/Procedural/DungeonJob.PostGen.cs
View File

File diff suppressed because it is too large Load Diff

41
Content.Server/Procedural/DungeonJob.cs
View File

@@ -6,10 +6,12 @@ using Content.Server.Decals;
using Content.Shared.Procedural;
using Content.Shared.Procedural.DungeonGenerators;
using Content.Shared.Procedural.PostGeneration;
using Content.Shared.Tag;
using Robust.Server.Physics;
using Robust.Shared.Map;
using Robust.Shared.Map.Components;
using Robust.Shared.Prototypes;
using Robust.Shared.Utility;
namespace Content.Server.Procedural;
@@ -25,6 +27,7 @@ public sealed partial class DungeonJob : Job<Dungeon>
private readonly DungeonSystem _dungeon;
private readonly EntityLookupSystem _lookup;
private readonly SharedTransformSystem _transform;
private EntityQuery<TagComponent> _tagQuery;
private readonly DungeonConfigPrototype _gen;
private readonly int _seed;
@@ -65,6 +68,7 @@ public sealed partial class DungeonJob : Job<Dungeon>
_dungeon = dungeon;
_lookup = lookup;
_transform = transform;
_tagQuery = _entManager.GetEntityQuery<TagComponent>();
_gen = gen;
_grid = grid;
@@ -88,10 +92,8 @@ public sealed partial class DungeonJob : Job<Dungeon>
throw new NotImplementedException();
}
foreach (var room in dungeon.Rooms)
{
dungeon.RoomTiles.UnionWith(room.Tiles);
}
DebugTools.Assert(dungeon.RoomTiles.Count > 0);
DebugTools.Assert(dungeon.RoomExteriorTiles.Count > 0);
// To make it slightly more deterministic treat this RNG as separate ig.
var random = new Random(_seed);
@@ -102,10 +104,31 @@ public sealed partial class DungeonJob : Job<Dungeon>
switch (post)
{
case AutoCablingPostGen cabling:
await PostGen(cabling, dungeon, _gridUid, _grid, random);
break;
case BoundaryWallPostGen boundary:
await PostGen(boundary, dungeon, _gridUid, _grid, random);
break;
case CornerClutterPostGen clutter:
await PostGen(clutter, dungeon, _gridUid, _grid, random);
break;
case CorridorPostGen cordor:
await PostGen(cordor, dungeon, _gridUid, _grid, random);
break;
case CorridorDecalSkirtingPostGen decks:
await PostGen(decks, dungeon, _gridUid, _grid, random);
break;
case EntranceFlankPostGen flank:
await PostGen(flank, dungeon, _gridUid, _grid, random);
break;
case JunctionPostGen junc:
await PostGen(junc, dungeon, _gridUid, _grid, random);
break;
case MiddleConnectionPostGen dordor:
await PostGen(dordor, dungeon, _gridUid, _grid, random);
break;
case EntrancePostGen entrance:
case DungeonEntrancePostGen entrance:
await PostGen(entrance, dungeon, _gridUid, _grid, random);
break;
case ExternalWindowPostGen externalWindow:
@@ -114,8 +137,8 @@ public sealed partial class DungeonJob : Job<Dungeon>
case InternalWindowPostGen internalWindow:
await PostGen(internalWindow, dungeon, _gridUid, _grid, random);
break;
case BoundaryWallPostGen boundary:
await PostGen(boundary, dungeon, _gridUid, _grid, random);
case RoomEntrancePostGen rEntrance:
await PostGen(rEntrance, dungeon, _gridUid, _grid, random);
break;
case WallMountPostGen wall:
await PostGen(wall, dungeon, _gridUid, _grid, random);
@@ -125,7 +148,9 @@ public sealed partial class DungeonJob : Job<Dungeon>
}
await SuspendIfOutOfTime();
ValidateResume();
if (!ValidateResume())
break;
}
_grid.CanSplit = true;

196
Content.Server/Procedural/DungeonSystem.Helpers.cs Normal file
View File

@@ -0,0 +1,196 @@
using Content.Shared.NPC;
using Robust.Shared.Collections;
using Robust.Shared.Utility;
namespace Content.Server.Procedural;
public sealed partial class DungeonSystem
{
public List<(Vector2i Start, Vector2i End)> MinimumSpanningTree(List<Vector2i> tiles, System.Random random)
{
// Generate connections between all rooms.
var connections = new Dictionary<Vector2i, List<(Vector2i Tile, float Distance)>>(tiles.Count);
foreach (var entrance in tiles)
{
var edgeConns = new List<(Vector2i Tile, float Distance)>(tiles.Count - 1);
foreach (var other in tiles)
{
if (entrance == other)
continue;
edgeConns.Add((other, (other - entrance).Length));
}
// Sort these as they will be iterated many times.
edgeConns.Sort((x, y) => x.Distance.CompareTo(y.Distance));
connections.Add(entrance, edgeConns);
}
var seedIndex = random.Next(tiles.Count);
var remaining = new ValueList<Vector2i>(tiles);
remaining.RemoveAt(seedIndex);
var edges = new List<(Vector2i Start, Vector2i End)>();
var seedEntrance = tiles[seedIndex];
var forest = new ValueList<Vector2i>(tiles.Count) { seedEntrance };
while (remaining.Count > 0)
{
// Get cheapest edge
var cheapestDistance = float.MaxValue;
var cheapest = (Vector2i.Zero, Vector2i.Zero);
foreach (var node in forest)
{
foreach (var conn in connections[node])
{
// Existing tile, skip
if (forest.Contains(conn.Tile))
continue;
// Not the cheapest
if (cheapestDistance < conn.Distance)
continue;
cheapestDistance = conn.Distance;
cheapest = (node, conn.Tile);
// List is pre-sorted so we can just breakout easily.
break;
}
}
DebugTools.Assert(cheapestDistance < float.MaxValue);
// Add to tree
edges.Add(cheapest);
forest.Add(cheapest.Item2);
remaining.Remove(cheapest.Item2);
}
return edges;
}
/// <summary>
/// Primarily for dungeon usage.
/// </summary>
public void GetCorridorNodes(HashSet<Vector2i> corridorTiles,
List<(Vector2i Start, Vector2i End)> edges,
int pathLimit,
HashSet<Vector2i>? forbiddenTiles = null,
Func<Vector2i, float>? tileCallback = null)
{
// Pathfind each entrance
var frontier = new PriorityQueue<Vector2i, float>();
var cameFrom = new Dictionary<Vector2i, Vector2i>();
var directions = new Dictionary<Vector2i, Direction>();
var costSoFar = new Dictionary<Vector2i, float>();
forbiddenTiles ??= new HashSet<Vector2i>();
foreach (var (start, end) in edges)
{
frontier.Clear();
cameFrom.Clear();
costSoFar.Clear();
directions.Clear();
directions[start] = Direction.Invalid;
frontier.Enqueue(start, 0f);
costSoFar[start] = 0f;
var found = false;
var count = 0;
while (frontier.Count > 0 && count < pathLimit)
{
count++;
var node = frontier.Dequeue();
if (node == end)
{
found = true;
break;
}
var lastDirection = directions[node];
// Foreach neighbor etc etc
for (var x = -1; x <= 1; x++)
{
for (var y = -1; y <= 1; y++)
{
// Cardinals only.
if (x != 0 && y != 0)
continue;
var neighbor = new Vector2i(node.X + x, node.Y + y);
// FORBIDDEN
if (neighbor != end &&
forbiddenTiles.Contains(neighbor))
{
continue;
}
var tileCost = SharedPathfindingSystem.ManhattanDistance(node, neighbor);
// Weight towards existing corridors ig
if (corridorTiles.Contains(neighbor))
{
tileCost *= 0.10f;
}
var costMod = tileCallback?.Invoke(neighbor);
costMod ??= 1f;
tileCost *= costMod.Value;
var direction = (neighbor - node).GetCardinalDir();
directions[neighbor] = direction;
// If direction is different then penalise it.
if (direction != lastDirection)
{
tileCost *= 3f;
}
// f = g + h
// gScore is distance to the start node
// hScore is distance to the end node
var gScore = costSoFar[node] + tileCost;
if (costSoFar.TryGetValue(neighbor, out var nextValue) && gScore >= nextValue)
{
continue;
}
cameFrom[neighbor] = node;
costSoFar[neighbor] = gScore;
// Make it greedy so multiply h-score to punish further nodes.
// This is necessary as we might have the deterredTiles multiplying towards the end
// so just finish it.
var hScore = SharedPathfindingSystem.ManhattanDistance(end, neighbor) * (1.0f - 1.0f / 1000.0f);
var fScore = gScore + hScore;
frontier.Enqueue(neighbor, fScore);
}
}
}
// Rebuild path if it's valid.
if (found)
{
var node = end;
while (true)
{
node = cameFrom[node];
// Don't want start or end nodes included.
if (node == start)
break;
corridorTiles.Add(node);
}
}
}
}
}

2
Content.Server/Procedural/DungeonSystem.cs
View File

@@ -15,7 +15,7 @@ using Robust.Shared.Prototypes;
namespace Content.Server.Procedural;
public sealed partial class DungeonSystem : EntitySystem
public sealed partial class DungeonSystem : SharedDungeonSystem
{
[Dependency] private readonly IConfigurationManager _configManager = default!;
[Dependency] private readonly IConsoleHost _console = default!;