[Funky port] Salvage ruins

Content.Client/Salvage/UI/SalvageMagnetBoundUserInterface.cs

@@ -128,6 +128,11 @@ protected override void UpdateState(BoundUserInterfaceState state)
 
                     option.AddContent(salvContainer);
                     break;
+                // Macro start - Adding RuinOffering to the salvage system
+                case RuinOffering ruin:
+                    option.Title = Loc.GetString("salvage-magnet-ruin");
+                    break;
+                // Macro end
                 default:
                     throw new ArgumentOutOfRangeException();
             }

Content.Server/Procedural/DungeonJob/DungeonJob.Biome.cs

@@ -1,10 +1,12 @@
+using System.Collections.Generic;
 using System.Threading.Tasks;
 using Content.Server.Parallax;
 using Content.Shared.Maps;
 using Content.Shared.Parallax.Biomes;
 using Content.Shared.Procedural;
 using Content.Shared.Procedural.PostGeneration;
 using Robust.Shared.Map;
+using Robust.Shared.Noise;
 using Robust.Shared.Utility;
 
 namespace Content.Server.Procedural.DungeonJob;
@@ -23,6 +25,7 @@ private async Task PostGen(BiomeDunGen dunGen, Dungeon dungeon, HashSet<Vector2i
 
         var seed = random.Next();
         var xformQuery = _entManager.GetEntityQuery<TransformComponent>();
+        var noiseCache = new Dictionary<int, FastNoiseLite>();
 
         var tiles = _maps.GetAllTilesEnumerator(_gridUid, _grid);
         while (tiles.MoveNext(out var tileRef))
@@ -44,15 +47,15 @@ private async Task PostGen(BiomeDunGen dunGen, Dungeon dungeon, HashSet<Vector2i
                 _maps.SetTile(_gridUid, _grid, node, tile.Value);
             }
 
-            if (biomeSystem.TryGetDecals(node, indexedBiome.Layers, seed, (_gridUid, _grid), out var decals))
+            if (biomeSystem.TryGetDecals(node, indexedBiome.Layers, seed, (_gridUid, _grid), out var decals, noiseCache))
             {
                 foreach (var decal in decals)
                 {
                     _decals.TryAddDecal(decal.ID, new EntityCoordinates(_gridUid, decal.Position), out _);
                 }
             }
 
-            if (biomeSystem.TryGetEntity(node, indexedBiome.Layers, tile ?? tileRef.Value.Tile, seed, (_gridUid, _grid), out var entityProto))
+            if (biomeSystem.TryGetEntity(node, indexedBiome.Layers, tile ?? tileRef.Value.Tile, seed, (_gridUid, _grid), out var entityProto, noiseCache))
             {
                 var ent = _entManager.SpawnEntity(entityProto, new EntityCoordinates(_gridUid, node + _grid.TileSizeHalfVector));
                 var xform = xformQuery.Get(ent);

Content.Server/Salvage/SalvageSystem.Magnet.cs

@@ -1,22 +1,40 @@
+using System.Collections.Generic; // Macro
 using System.Linq;
 using System.Numerics;
 using System.Threading.Tasks;
+using Content.Server.Decals; // Macro
 using Content.Server.Salvage.Magnet;
+using Content.Shared.Damage; // Macro
+using Content.Shared.Damage.Components; // Macro
+using Content.Shared.Damage.Prototypes; // Macro
+using Content.Shared.Damage.Systems; // Macro
+using Content.Shared.FixedPoint; // Macro
+using Content.Shared.Maps; // Macro
 using Content.Shared.Mobs.Components;
+using Content.Shared.Parallax.Biomes; // Macro
+using Content.Shared.Physics; // Macro
 using Content.Shared.Procedural;
 using Content.Shared.Radio;
+using Content.Shared.Salvage; // Macro
 using Content.Shared.Salvage.Magnet;
 using Robust.Shared.Exceptions;
 using Robust.Shared.Map;
+using Robust.Shared.Map.Components; //Macro
+using Robust.Shared.Noise; // Macro
 using Robust.Shared.Prototypes;
 
 namespace Content.Server.Salvage;
 
 public sealed partial class SalvageSystem
 {
+    [Dependency] private readonly DecalSystem _decals = default!;
     [Dependency] private readonly IRuntimeLog _runtimeLog = default!;
+    [Dependency] private readonly DamageableSystem _damageable = default!; // Macro
+    [Dependency] private readonly SalvageRuinGeneratorSystem _ruinGenerator = default!; // Macro
 
     private static readonly ProtoId<RadioChannelPrototype> MagnetChannel = "Supply";
+    private static readonly ProtoId<DamageTypePrototype> StructuralDamageType = "Structural"; // Macro
+    private static readonly ProtoId<BiomeTemplatePrototype> SpaceRuinBiome = "SpaceRuin"; // Macro
 
     private EntityQuery<SalvageMobRestrictionsComponent> _salvMobQuery;
     private EntityQuery<MobStateComponent> _mobStateQuery;
@@ -305,14 +323,63 @@ private async Task TakeMagnetOffer(Entity<SalvageMagnetDataComponent> data, int
                 break;
             case SalvageOffering wreck:
                 var salvageProto = wreck.SalvageMap;
-
+// Macro Start - Adding RuinOffering to the salvage system  
                 if (!_loader.TryLoadGrid(salvMapXform.MapID, salvageProto.MapPath, out _))
                 {
-                    Report(magnet, MagnetChannel, "salvage-system-announcement-spawn-debris-disintegrated");
+                    Report(magnet.Owner, MagnetChannel, "salvage-system-announcement-spawn-debris-disintegrated");
                     _mapSystem.DeleteMap(salvMapXform.MapID);
                     return;
                 }
 
+                break;
+            case RuinOffering ruin:
+                var ruinConfigId = new ProtoId<SalvageMagnetRuinConfigPrototype>("Default");
+                _prototypeManager.TryIndex<Content.Shared.Salvage.SalvageMagnetRuinConfigPrototype>(ruinConfigId, out var ruinConfig);
+
+                var ruinResult = _ruinGenerator.GenerateRuin(ruin.RuinMap.MapPath, seed, ruinConfig);
+                if (ruinResult == null)
+                {
+                    Report(magnet.Owner, MagnetChannel, "salvage-system-announcement-spawn-no-debris-available");
+                    _mapSystem.DeleteMap(salvMapXform.MapID);
+                    return;
+                }
+
+                var ruinGrid = _mapManager.CreateGridEntity(salvMap);
+                _mapSystem.SetTiles(ruinGrid.Owner, ruinGrid.Comp, ruinResult.FloorTiles);
+
+                foreach (var (wallPos, wallProto) in ruinResult.WallEntities)
+                {
+                    var wallEntity = SpawnAtPosition(wallProto, new EntityCoordinates(ruinGrid.Owner, wallPos));
+                    var wallXform = Transform(wallEntity);
+                    if (!wallXform.Anchored)
+                        _transform.AnchorEntity((wallEntity, wallXform), (ruinGrid.Owner, ruinGrid.Comp), wallPos);
+                }
+
+                var windowDamageChance = ruinResult.Config?.WindowDamageChance ?? 0.0f;
+                var windowRand = new System.Random(seed);
+                foreach (var (windowPos, windowProto, windowRotation) in ruinResult.WindowEntities)
+                {
+                    var tileRef = _mapSystem.GetTileRef(ruinGrid.Owner, ruinGrid.Comp, windowPos);
+                    if (tileRef.Tile.IsEmpty)
+                        continue;
+
+                    var windowEntity = SpawnAttachedTo(windowProto, new EntityCoordinates(ruinGrid.Owner, windowPos), rotation: windowRotation);
+                    var windowXform = Transform(windowEntity);
+                    if (!windowXform.Anchored)
+                        _transform.AnchorEntity((windowEntity, windowXform), (ruinGrid.Owner, ruinGrid.Comp), windowPos);
+
+                    if (windowDamageChance > 0.0f && windowRand.NextSingle() < windowDamageChance &&
+                        TryComp<DamageableComponent>(windowEntity, out _))
+                    {
+                        var damage = new DamageSpecifier(
+                            _prototypeManager.Index(StructuralDamageType),
+                            FixedPoint2.New(25));
+                        _damageable.TryChangeDamage(windowEntity, damage);
+                    }
+                }
+
+                SpawnRuinBiomeEntities(ruinGrid.Owner, ruinGrid.Comp, ruinResult, seed);
+
                 break;
             default:
                 throw new ArgumentOutOfRangeException();
@@ -338,13 +405,13 @@ private async Task TakeMagnetOffer(Entity<SalvageMagnetDataComponent> data, int
             bounds = bounds?.Union(childAABB) ?? childAABB;
 
             // Update mass scanner names as relevant.
-            if (offering is AsteroidOffering or DebrisOffering)
+            if (offering is AsteroidOffering or DebrisOffering or RuinOffering)
             {
                 _metaData.SetEntityName(mapChild, Loc.GetString("salvage-asteroid-name"));
                 _gravity.EnableGravity(mapChild);
             }
         }
-
+// Macro end
         var magnetXform = _xformQuery.GetComponent(magnet.Owner);
         var magnetGridUid = magnetXform.GridUid;
         var attachedBounds = new Box2Rotated();
@@ -418,7 +485,49 @@ private async Task TakeMagnetOffer(Entity<SalvageMagnetDataComponent> data, int
 
         RaiseLocalEvent(ref active);
     }
+// Macro start - Adding mobs and loot to the salvage system via SpaceRuin biome template
+    private void SpawnRuinBiomeEntities(EntityUid gridUid, MapGridComponent grid, SalvageRuinGeneratorSystem.RuinResult ruinResult, int seed)
+    {
+        var blockedPositions = new HashSet<Vector2i>(
+            ruinResult.WallEntities.Select(w => w.Position)
+                .Concat(ruinResult.WindowEntities.Select(w => w.Position)));
+
+        if (!_prototypeManager.TryIndex(SpaceRuinBiome, out var ruinTemplate))
+            return;
+
+        var layers = ruinTemplate.Layers;
+        var noiseCache = new Dictionary<int, FastNoiseLite>();
+
+        foreach (var (pos, tile) in ruinResult.FloorTiles)
+        {
+            if (blockedPositions.Contains(pos))
+                continue;
+
+            var tileRef = _mapSystem.GetTileRef(gridUid, grid, pos);
+            if (tileRef.Tile.IsEmpty)
+                continue;
+
+            if (_biome.TryGetDecals(pos, layers, seed, (gridUid, grid), out var decals, noiseCache))
+            {
+                foreach (var decal in decals)
+                {
+                    _decals.TryAddDecal(decal.ID, new EntityCoordinates(gridUid, decal.Position), out _);
+                }
+            }
+
+            if (_biome.TryGetEntity(pos, layers, tileRef.Tile, seed, (gridUid, grid), out var entityProto, noiseCache))
+            {
+                if (!_anchorable.TileFree((gridUid, grid), pos, (int)CollisionGroup.MachineLayer, (int)CollisionGroup.MachineLayer))
+                    continue;
 
+                var entity = SpawnAtPosition(entityProto, new EntityCoordinates(gridUid, pos + grid.TileSizeHalfVector));
+                var xform = Transform(entity);
+                if (!xform.Anchored)
+                    _transform.AnchorEntity((entity, xform), (gridUid, grid), pos);
+            }
+        }
+    }
+// Macro end
     private bool TryGetSalvagePlacementLocation(Entity<SalvageMagnetComponent> magnet, MapId mapId, Box2Rotated attachedBounds, Box2 bounds, Angle worldAngle, out MapCoordinates coords, out Angle angle)
     {
         var attachedAABB = attachedBounds.CalcBoundingBox();