dungenore wawa

Content.Server/Procedural/DungeonJob/DungeonJob.cs

@@ -213,6 +213,11 @@ public sealed partial class DungeonJob : Job<List<Dungeon>>
 
         switch (layer)
         {
+            //CP14 zone
+            case CP14OreDunGen cp14OreDunGen:
+                await PostGen(cp14OreDunGen, dungeons, reservedTiles, random);
+                break;
+            //CP14 zone end
             case AutoCablingDunGen cabling:
                 await PostGen(cabling, dungeons[^1], reservedTiles, random);
                 break;

Content.Server/_CP14/Procedural/DungeonJob/DungeonJob.CP14Ore.cs

@@ -0,0 +1,159 @@
+using System.Threading.Tasks;
+using Content.Shared.Maps;
+using Content.Shared.Procedural;
+using Content.Shared.Procedural.Components;
+using Content.Shared.Procedural.DungeonLayers;
+using Robust.Shared.Collections;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Random;
+
+namespace Content.Server.Procedural.DungeonJob;
+
+public sealed partial class DungeonJob
+{
+    /// <summary>
+    /// <see cref="OreDunGen"/>
+    /// </summary>
+    private async Task PostGen(
+        CP14OreDunGen gen,
+        List<Dungeon> dungeons,
+        HashSet<Vector2i> reservedTiles,
+        Random random)
+    {
+        // Doesn't use dungeon data because layers and we don't need top-down support at the moment.
+
+        var replaceEntities = new Dictionary<Vector2i, EntityUid>();
+        var availableTiles = new List<Vector2i>();
+        var tiles = _maps.GetAllTilesEnumerator(_gridUid, _grid);
+
+        // WARNING:
+        // This DunGen handles not only the tiles of the passed dungeon, but ALL the tiles of the current grid
+        // So don't run it anywhere
+        while (tiles.MoveNext(out var tileRef))
+        {
+            var tile = tileRef.Value.GridIndices;
+
+            //Tile mask filtering
+            if (gen.TileMask is not null)
+            {
+                if (!gen.TileMask.Contains(((ContentTileDefinition) _tileDefManager[tileRef.Value.Tile.TypeId]).ID))
+                    continue;
+            }
+
+            //Entity mask filtering
+            if (gen.EntityMask is not null)
+            {
+                var found = false;
+                var enumerator2 = _maps.GetAnchoredEntitiesEnumerator(_gridUid, _grid, tile);
+                while (enumerator2.MoveNext(out var uid))
+                {
+                    var prototype = _entManager.GetComponent<MetaDataComponent>(uid.Value).EntityPrototype;
+
+                    if (prototype?.ID is null)
+                        continue;
+
+                    if (!gen.EntityMask.Contains(prototype.ID))
+                        continue;
+
+                    replaceEntities[tile] = uid.Value;
+                    found = true;
+                }
+
+                if (!found)
+                    continue;
+            }
+            else
+            {
+                //If entity mask null - we ignore the tiles that have anything on them.
+                if (!_anchorable.TileFree(_grid, tile, DungeonSystem.CollisionLayer, DungeonSystem.CollisionMask))
+                    continue;
+            }
+
+            // Add it to valid nodes.
+            availableTiles.Add(tile);
+
+            await SuspendDungeon();
+
+            if (!ValidateResume())
+                return;
+        }
+
+        var remapping = new Dictionary<EntProtoId, EntProtoId>();
+
+        // TODO: Move this to engine
+        if (_prototype.TryIndex(gen.Entity, out var proto) &&
+            proto.Components.TryGetComponent("EntityRemap", out var comps))
+        {
+            var remappingComp = (EntityRemapComponent) comps;
+            remapping = remappingComp.Mask;
+        }
+
+        var frontier = new ValueList<Vector2i>(32);
+
+        // Iterate the group counts and pathfind out each group.
+        for (var i = 0; i < gen.Count; i++)
+        {
+            await SuspendDungeon();
+
+            if (!ValidateResume())
+                return;
+
+            var groupSize = random.Next(gen.MinGroupSize, gen.MaxGroupSize + 1);
+
+            // While we have remaining tiles keep iterating
+            while (groupSize > 0 && availableTiles.Count > 0)
+            {
+                var startNode = random.PickAndTake(availableTiles);
+                frontier.Clear();
+                frontier.Add(startNode);
+
+                // This essentially may lead to a vein being split in multiple areas but the count matters more than position.
+                while (frontier.Count > 0 && groupSize > 0)
+                {
+                    // Need to pick a random index so we don't just get straight lines of ores.
+                    var frontierIndex = random.Next(frontier.Count);
+                    var node = frontier[frontierIndex];
+                    frontier.RemoveSwap(frontierIndex);
+                    availableTiles.Remove(node);
+
+                    // Add neighbors if they're valid, worst case we add no more and pick another random seed tile.
+                    for (var x = -1; x <= 1; x++)
+                    {
+                        for (var y = -1; y <= 1; y++)
+                        {
+                            var neighbor = new Vector2i(node.X + x, node.Y + y);
+
+                            if (frontier.Contains(neighbor) || !availableTiles.Contains(neighbor))
+                                continue;
+
+                            frontier.Add(neighbor);
+                        }
+                    }
+
+                    var prototype = gen.Entity;
+
+                    if (replaceEntities.TryGetValue(node, out var existingEnt))
+                    {
+                        var existingProto = _entManager.GetComponent<MetaDataComponent>(existingEnt).EntityPrototype;
+                        _entManager.DeleteEntity(existingEnt);
+
+                        if (existingProto != null && remapping.TryGetValue(existingProto.ID, out var remapped))
+                        {
+                            prototype = remapped;
+                        }
+                    }
+
+                    // Tile valid salad so add it.
+                    _entManager.SpawnAtPosition(prototype, _maps.GridTileToLocal(_gridUid, _grid, node));
+
+                    groupSize--;
+                }
+            }
+
+            if (groupSize > 0)
+            {
+                _sawmill.Warning($"Found remaining group size for ore veins of {gen.Entity.Id ?? "null"}!");
+            }
+        }
+    }
+}