aaaa

* move mining_voucher.yml into Salvage folder

* add ShelterCapsuleComponent and system

* add shelter capsules

* add capsules to vendor and voucher

* :trollface:

* add admin logging and delete lava

* mv wire

* changes for namespace refactor

* remove dupe voucher

* add smoke when deploying

---------

Co-authored-by: deltanedas <@deltanedas:kde.org>

Content.Client/_DV/Salvage/Systems/ShelterCapsuleSystem.cs

@@ -0,0 +1,5 @@
+using Content.Shared._DV.Salvage.Systems;
+
+namespace Content.Client._DV.Salvage.Systems;
+
+public sealed class ShelterCapsuleSystem : SharedShelterCapsuleSystem;

Content.Server/DeltaV/Shuttles/Systems/DockingConsoleSystem.cs

@@ -1,11 +1,13 @@
 using Content.Server.Shuttles.Components;
 using Content.Server.Shuttles.Events;
 using Content.Server.Shuttles.Systems;
+using Content.Server.Station.Systems;
 using Content.Shared.DeltaV.Shuttles;
 using Content.Shared.DeltaV.Shuttles.Components;
 using Content.Shared.DeltaV.Shuttles.Systems;
 using Content.Shared.Shuttles.Components;
 using Content.Shared.Shuttles.Systems;
+using Content.Shared.Station.Components;
 using Content.Shared.Timing;
 using Content.Shared.Whitelist;
 using Robust.Shared.Map;
@@ -16,8 +18,10 @@ namespace Content.Server.DeltaV.Shuttles.Systems;
 public sealed class DockingConsoleSystem : SharedDockingConsoleSystem
 {
     [Dependency] private readonly EntityWhitelistSystem _whitelist = default!;
+    [Dependency] private readonly SharedMapSystem _map = default!;
     [Dependency] private readonly SharedUserInterfaceSystem _ui = default!;
     [Dependency] private readonly ShuttleSystem _shuttle = default!;
+    [Dependency] private readonly StationSystem _station = default!;
 
     public override void Initialize()
     {
@@ -114,7 +118,10 @@ public sealed class DockingConsoleSystem : SharedDockingConsoleSystem
         if (FindLargestGrid(map) is not {} grid)
             return;
 
+        Log.Debug($"{ToPrettyString(args.Actor):user} is FTL-docking {ToPrettyString(shuttle):shuttle} to {ToPrettyString(grid):grid}");
+
         _shuttle.FTLToDock(shuttle, Comp<ShuttleComponent>(shuttle), grid, priorityTag: ent.Comp.DockTag);
+        UpdateUI(ent);
     }
 
     private EntityUid? FindLargestGrid(MapId map)
@@ -122,6 +129,12 @@ public sealed class DockingConsoleSystem : SharedDockingConsoleSystem
         EntityUid? largestGrid = null;
         var largestSize = 0f;
 
+        if (_station.GetStationInMap(map) is {} station)
+        {
+            // prevent picking vgroid and stuff
+            return _station.GetLargestGrid(station); // May need to get the StationDataComponent if this doesn't work
+        }
+
         var query = EntityQueryEnumerator<MapGridComponent, TransformComponent>();
         while (query.MoveNext(out var gridUid, out var grid, out var xform))
         {

Content.Server/DeltaV/Weather/WeatherEffectsSystem.cs

@@ -0,0 +1,83 @@
+using Content.Shared.Damage;
+using Content.Shared.Damage.Systems;
+using Content.Shared.Mobs;
+using Content.Shared.Mobs.Components;
+using Content.Shared.Weather;
+using Content.Shared.Whitelist;
+using Robust.Shared.Map.Components;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Timing;
+
+namespace Content.Shared.DeltaV.Weather;
+
+/// <summary>
+/// Handles weather damage for exposed entities.
+/// </summary>
+public sealed partial class WeatherEffectsSystem : EntitySystem
+{
+    [Dependency] private readonly DamageableSystem _damageable = default!;
+    [Dependency] private readonly EntityWhitelistSystem _whitelist = default!;
+    [Dependency] private readonly IGameTiming _timing = default!;
+    [Dependency] private readonly IPrototypeManager _proto = default!;
+    [Dependency] private readonly SharedMapSystem _map = default!;
+    [Dependency] private readonly SharedWeatherSystem _weather = default!;
+
+    private EntityQuery<MapGridComponent> _gridQuery;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        _gridQuery = GetEntityQuery<MapGridComponent>();
+    }
+
+    public override void Update(float frameTime)
+    {
+        base.Update(frameTime);
+
+        var now = _timing.CurTime;
+        var query = EntityQueryEnumerator<WeatherComponent>();
+        while (query.MoveNext(out var map, out var weather))
+        {
+            if (now < weather.NextUpdate)
+                continue;
+
+            weather.NextUpdate = now + weather.UpdateDelay;
+
+            foreach (var (id, data) in weather.Weather)
+            {
+                // start and end do no damage
+                if (data.State != WeatherState.Running)
+                    continue;
+
+                UpdateDamage(map, id);
+            }
+        }
+    }
+
+    private void UpdateDamage(EntityUid map, ProtoId<WeatherPrototype> id)
+    {
+        var weather = _proto.Index(id);
+        if (weather.Damage is not {} damage)
+            return;
+
+        var query = EntityQueryEnumerator<MobStateComponent, TransformComponent>();
+        while (query.MoveNext(out var uid, out var mob, out var xform))
+        {
+            // Dead bodies aren't revivable anyways!
+            if (xform.MapUid != map)
+                continue;
+
+            // if not in space, check for being indoors
+            if (xform.GridUid is {} gridUid && _gridQuery.TryComp(gridUid, out var grid))
+            {
+                var tile = _map.GetTileRef((gridUid, grid), xform.Coordinates);
+                if (!_weather.CanWeatherAffect(gridUid, grid, tile))
+                    continue;
+            }
+
+            if (_whitelist.IsBlacklistFailOrNull(weather.DamageBlacklist, uid))
+                _damageable.TryChangeDamage(uid, damage, interruptsDoAfters: false);
+        }
+    }
+}

Content.Server/DeltaV/Weather/WeatherSchedulerComponent.cs

@@ -0,0 +1,58 @@
+using Content.Shared.Destructible.Thresholds;
+using Content.Shared.Weather;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Serialization;
+using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom;
+
+namespace Content.Server.DeltaV.Weather;
+
+/// <summary>
+/// Makes weather randomly happen every so often.
+/// </summary>
+[RegisterComponent, Access(typeof(WeatherSchedulerSystem))]
+[AutoGenerateComponentPause]
+public sealed partial class WeatherSchedulerComponent : Component
+{
+    /// <summary>
+    /// Weather stages to schedule.
+    /// </summary>
+    [DataField(required: true)]
+    public List<WeatherStage> Stages = new();
+
+    /// <summary>
+    /// The index of <see cref="Stages"/> to use next, wraps back to the start.
+    /// </summary>
+    [DataField]
+    public int Stage;
+
+    /// <summary>
+    /// When to go to the next step of the schedule.
+    /// </summary>
+    [DataField(customTypeSerializer: typeof(TimeOffsetSerializer)), AutoPausedField]
+    public TimeSpan NextUpdate;
+}
+
+/// <summary>
+/// A stage in a weather schedule.
+/// </summary>
+[Serializable, DataDefinition]
+public partial struct WeatherStage
+{
+    /// <summary>
+    /// A range of how long the stage can last for, in seconds.
+    /// </summary>
+    [DataField(required: true)]
+    public MinMax Duration = new(0, 0);
+
+    /// <summary>
+    /// The weather prototype to add, or null for clear weather.
+    /// </summary>
+    [DataField]
+    public ProtoId<WeatherPrototype>? Weather;
+
+    /// <summary>
+    /// Alert message to send in chat for players on the map when it starts.
+    /// </summary>
+    [DataField]
+    public LocId? Message;
+}

Content.Server/DeltaV/Weather/WeatherSchedulerSystem.cs

@@ -0,0 +1,75 @@
+using Content.Server.Chat.Managers;
+using Content.Shared.Chat;
+using Content.Shared.Weather;
+using Robust.Shared.Map.Components;
+using Robust.Shared.Player;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Random;
+using Robust.Shared.Timing;
+
+namespace Content.Server.DeltaV.Weather;
+
+public sealed class WeatherSchedulerSystem : EntitySystem
+{
+    [Dependency] private readonly IChatManager _chat = default!;
+    [Dependency] private readonly IGameTiming _timing = default!;
+    [Dependency] private readonly IPrototypeManager _proto = default!;
+    [Dependency] private readonly IRobustRandom _random = default!;
+    [Dependency] private readonly SharedWeatherSystem _weather = default!;
+
+    public override void Update(float frameTime)
+    {
+        base.Update(frameTime);
+
+        var now = _timing.CurTime;
+        var query = EntityQueryEnumerator<WeatherSchedulerComponent>();
+        while (query.MoveNext(out var map, out var comp))
+        {
+            if (now < comp.NextUpdate)
+                continue;
+
+            if (comp.Stage >= comp.Stages.Count)
+                comp.Stage = 0;
+
+            var stage = comp.Stages[comp.Stage++];
+            var duration = stage.Duration.Next(_random);
+            comp.NextUpdate = now + TimeSpan.FromSeconds(duration);
+
+            var mapId = Comp<MapComponent>(map).MapId;
+            if (stage.Weather is {} weather)
+            {
+                var ending = comp.NextUpdate;
+                // crossfade weather so as one ends the next starts
+                if (HasWeather(comp, comp.Stage - 1))
+                    ending += WeatherComponent.ShutdownTime;
+                if (HasWeather(comp, comp.Stage + 1))
+                    ending += WeatherComponent.StartupTime;
+                _weather.SetWeather(mapId, _proto.Index(weather), ending);
+            }
+
+            if (stage.Message is {} message)
+            {
+                var msg = Loc.GetString(message);
+                _chat.ChatMessageToManyFiltered(
+                    Filter.BroadcastMap(mapId),
+                    ChatChannel.Radio,
+                    msg,
+                    msg,
+                    map,
+                    false,
+                    true,
+                    null);
+            }
+        }
+    }
+
+    private bool HasWeather(WeatherSchedulerComponent comp, int stage)
+    {
+        if (stage < 0)
+            stage = comp.Stages.Count + stage;
+        else if (stage >= comp.Stages.Count)
+            stage %= comp.Stages.Count;
+
+        return comp.Stages[stage].Weather != null;
+    }
+}

Content.Server/_DV/Salvage/Systems/ShelterCapsuleSystem.cs

@@ -0,0 +1,109 @@
+using Content.Server.Fluids.EntitySystems;
+using Content.Server.Procedural;
+using Content.Shared.Administration.Logs;
+using Content.Shared.Chemistry.Components;
+using Content.Shared.Database;
+using Content.Shared._DV.Salvage.Components;
+using Content.Shared._DV.Salvage.Systems;
+using Content.Shared.Maps;
+using Content.Shared.Physics;
+using Robust.Shared.Map.Components;
+using Robust.Shared.Maths;
+using Robust.Shared.Physics;
+using Robust.Shared.Prototypes;
+using System.Numerics;
+
+namespace Content.Server._DV.Salvage.Systems;
+
+public sealed class ShelterCapsuleSystem : SharedShelterCapsuleSystem
+{
+    [Dependency] private readonly DungeonSystem _dungeon = default!;
+    [Dependency] private readonly EntityLookupSystem _lookup = default!;
+    [Dependency] private readonly IPrototypeManager _proto = default!;
+    [Dependency] private readonly ISharedAdminLogManager _adminLogger = default!;
+    [Dependency] private readonly SharedMapSystem _map = default!;
+    [Dependency] private readonly SmokeSystem _smoke = default!;
+
+    public static readonly EntProtoId SmokePrototype = "Smoke";
+
+    private EntityQuery<FixturesComponent> _fixturesQuery;
+    private HashSet<EntityUid> _entities = new();
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        _fixturesQuery = GetEntityQuery<FixturesComponent>();
+    }
+
+    protected override LocId? TrySpawnRoom(Entity<ShelterCapsuleComponent> ent)
+    {
+        var xform = Transform(ent);
+        if (xform.GridUid is not {} gridUid || !TryComp<MapGridComponent>(gridUid, out var grid))
+            return "shelter-capsule-error-space";
+
+        var center = _map.LocalToTile(gridUid, grid, xform.Coordinates);
+        var room = _proto.Index(ent.Comp.Room);
+        var origin = center - room.Size / 2;
+
+        // check that every tile it needs isn't blocked
+        var mask = (int) CollisionGroup.MobMask;
+        if (IsAreaBlocked(gridUid, center, room.Size, mask))
+            return "shelter-capsule-error-obstructed";
+
+        // check that it isn't on space or SpawnRoom will crash
+        for (int y = 0; y < room.Size.Y; y++)
+        {
+            for (int x = 0; x < room.Size.X; x++)
+            {
+                var pos = origin + new Vector2i(x, y);
+                var tile = _map.GetTileRef((gridUid, grid), pos);
+                if (tile.Tile.IsEmpty)
+                    return "shelter-capsule-error-space";
+            }
+        }
+
+        var user = ent.Comp.User;
+        _adminLogger.Add(LogType.Action, LogImpact.High, $"{ToPrettyString(user):user} expanded {ToPrettyString(ent):capsule} at {center} on {ToPrettyString(gridUid):grid}");
+
+        _dungeon.SpawnRoom(gridUid,
+            grid,
+            origin,
+            room,
+            new Random(),
+            null,
+            clearExisting: true); // already checked for mobs and structures here
+
+        var smoke = Spawn(SmokePrototype, xform.Coordinates);
+        var spreadAmount = (int) room.Size.Length * 2;
+        _smoke.StartSmoke(smoke, new Solution(), 3f, spreadAmount);
+
+        QueueDel(ent);
+        return null;
+    }
+
+    private bool IsAreaBlocked(EntityUid grid, Vector2i center, Vector2i size, int mask)
+    {
+        // This is scaled to 95 % so it doesn't encompass walls on other tiles.
+        var aabb = Box2.CenteredAround(center, size * 0.95f);
+        _entities.Clear();
+        _lookup.GetLocalEntitiesIntersecting(grid, aabb, _entities, LookupFlags.Dynamic | LookupFlags.Static);
+        foreach (var uid in _entities)
+        {
+            // don't care about non-physical entities
+            if (!_fixturesQuery.TryComp(uid, out var fixtures))
+                continue;
+
+            foreach (var fixture in fixtures.Fixtures.Values)
+            {
+                if (!fixture.Hard)
+                    continue;
+
+                if ((fixture.CollisionLayer & mask) != 0)
+                    return true;
+            }
+        }
+
+        return false; // no entities colliding with the mask found
+    }
+}

Content.Shared/DeltaV/Salvage/Components/ShelterCapsuleComponent.cs

@@ -0,0 +1,39 @@
+using Content.Shared._DV.Salvage.Systems;
+using Content.Shared.Procedural;
+using Robust.Shared.GameStates;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom;
+
+namespace Content.Shared._DV.Salvage.Components;
+
+/// <summary>
+/// Spawns a dungeon room after a delay when used and deletes itself.
+/// </summary>
+[RegisterComponent, NetworkedComponent, Access(typeof(SharedShelterCapsuleSystem))]
+[AutoGenerateComponentPause]
+public sealed partial class ShelterCapsuleComponent : Component
+{
+    /// <summary>
+    /// The room to spawn.
+    /// </summary>
+    [DataField(required: true)]
+    public ProtoId<DungeonRoomPrototype> Room;
+
+    /// <summary>
+    /// How long to wait between using and spawning the room.
+    /// </summary>
+    [DataField]
+    public TimeSpan Delay = TimeSpan.FromSeconds(5);
+
+    /// <summary>
+    /// When to next spawn the room, also used to ignore activating multiple times.
+    /// </summary>
+    [DataField(customTypeSerializer: typeof(TimeOffsetSerializer)), AutoPausedField]
+    public TimeSpan? NextSpawn;
+
+    /// <summary>
+    /// The user of the capsule, used for logging.
+    /// </summary>
+    [DataField]
+    public EntityUid? User;
+}

Content.Shared/DeltaV/Salvage/Systems/SharedShelterCapsuleSystem.cs

@@ -0,0 +1,66 @@
+using Content.Shared._DV.Salvage.Components;
+using Content.Shared.Interaction.Events;
+using Content.Shared.Popups;
+using Robust.Shared.Timing;
+
+namespace Content.Shared._DV.Salvage.Systems;
+
+/// <summary>
+/// Handles interaction for shelter capsules.
+/// Room spawning is done serverside.
+/// </summary>
+public abstract class SharedShelterCapsuleSystem : EntitySystem
+{
+    [Dependency] private readonly IGameTiming _timing = default!;
+    [Dependency] private readonly SharedPopupSystem _popup = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<ShelterCapsuleComponent, UseInHandEvent>(OnUse);
+    }
+
+    public override void Update(float frameTime)
+    {
+        base.Update(frameTime);
+
+        var now = _timing.CurTime;
+        var query = EntityQueryEnumerator<ShelterCapsuleComponent>();
+        while (query.MoveNext(out var uid, out var comp))
+        {
+            if (comp.NextSpawn is not {} nextSpawn || now < nextSpawn)
+                continue;
+
+            comp.User = null;
+            comp.NextSpawn = null;
+            if (TrySpawnRoom((uid, comp)) is {} id)
+            {
+                var msg = Loc.GetString(id, ("capsule", uid));
+                _popup.PopupEntity(msg, uid, PopupType.LargeCaution);
+            }
+        }
+    }
+
+    /// <summary>
+    /// Spawn the room, returning a locale string for an error. It gets "capsule" passed.
+    /// </summary>
+    protected virtual LocId? TrySpawnRoom(Entity<ShelterCapsuleComponent> ent)
+    {
+        return null;
+    }
+
+    private void OnUse(Entity<ShelterCapsuleComponent> ent, ref UseInHandEvent args)
+    {
+        if (args.Handled || ent.Comp.NextSpawn != null)
+            return;
+
+        args.Handled = true;
+
+        var msg = Loc.GetString("shelter-capsule-warning", ("capsule", ent));
+        _popup.PopupPredicted(msg, ent, args.User, PopupType.LargeCaution);
+
+        ent.Comp.User = args.User;
+        ent.Comp.NextSpawn = _timing.CurTime + ent.Comp.Delay;
+    }
+}

Content.Shared/DeltaV/Shuttles/DockingConsoleUI.cs

@@ -1,3 +1,4 @@
+
 using Content.Shared.DeltaV.Shuttles.Components;
 using Content.Shared.Shuttles.Systems;
 using Content.Shared.Timing;
@@ -24,3 +25,6 @@ public sealed class DockingConsoleFTLMessage(int index) : BoundUserInterfaceMess
 {
     public int Index = index;
 }
+
+[Serializable, NetSerializable]
+public sealed class DockingConsoleShuttleCheckMessage : BoundUserInterfaceMessage;

Content.Shared/DeltaV/Weather/Components/AshStormImmuneComponent.cs

@@ -0,0 +1,9 @@
+using Robust.Shared.GameStates;
+
+namespace Content.Shared.DeltaV.Weather.Components;
+
+/// <summary>
+/// Makes an entity not take damage from ash storms.
+/// </summary>
+[RegisterComponent, NetworkedComponent]
+public sealed partial class AshStormImmuneComponent : Component;

Content.Shared/Weather/SharedWeatherSystem.cs

@@ -38,6 +38,7 @@ public abstract class SharedWeatherSystem : EntitySystem
             if (weather.EndTime != null)
                 weather.EndTime = weather.EndTime.Value + args.PausedTime;
         }
+        component.NextUpdate += args.PausedTime; // DeltaV
     }
 
     public bool CanWeatherAffect(EntityUid uid, MapGridComponent grid, TileRef tileRef, RoofComponent? roofComp = null)

Content.Shared/Weather/WeatherComponent.cs

@@ -14,6 +14,18 @@ public sealed partial class WeatherComponent : Component
     [DataField]
     public Dictionary<ProtoId<WeatherPrototype>, WeatherData> Weather = new();
 
+    /// <summary>
+    /// DeltaV: How long to wait between updating weather effects.
+    /// </summary>
+    [DataField]
+    public TimeSpan UpdateDelay = TimeSpan.FromSeconds(1);
+
+    /// <summary>
+    /// DeltaV: When to next update weather effects (damage).
+    /// </summary>
+    [DataField(customTypeSerializer: typeof(TimeOffsetSerializer))]
+    public TimeSpan NextUpdate = TimeSpan.Zero;
+
     public static readonly TimeSpan StartupTime = TimeSpan.FromSeconds(15);
     public static readonly TimeSpan ShutdownTime = TimeSpan.FromSeconds(15);
 }

Content.Shared/Weather/WeatherPrototype.cs

@@ -1,3 +1,5 @@
+using Content.Shared.Damage;
+using Content.Shared.Whitelist;
 using Robust.Shared.Audio;
 using Robust.Shared.Prototypes;
 using Robust.Shared.Utility;
@@ -20,4 +22,17 @@ public sealed partial class WeatherPrototype : IPrototype
     /// </summary>
     [ViewVariables(VVAccess.ReadWrite), DataField("sound")]
     public SoundSpecifier? Sound;
+
+    /// <summary>
+    /// DeltaV: Damage you can take from being in this weather.
+    /// Only applies when weather has fully set in.
+    /// </summary>
+    [DataField]
+    public DamageSpecifier? Damage;
+
+    /// <summary>
+    /// DeltaV: Don't damage entities that match this blacklist.
+    /// </summary>
+    [DataField]
+    public EntityWhitelist? DamageBlacklist;
 }

Resources/Locale/en-US/_DV/salvage/shelter-capsule.ftl

@@ -0,0 +1,3 @@
+shelter-capsule-warning = {THE($capsule)} begins to shake. Stand back!
+shelter-capsule-error-space = {THE($capsule)} needs ground to deploy on!
+shelter-capsule-error-obstructed = {THE($capsule)} is obstructed, clear the area first!

Resources/Locale/en-US/deltav/weather/ashstorm.ftl

@@ -0,0 +1,3 @@
+ash-storm-telegraph = [color=red][bold]An eerie moan rises on the wind. Sheets of burning ash blacken the horizon. Seek shelter.[/bold][/color]
+ash-storm-alert = [color=red][bolditalic]Smoldering clouds of scorching ash billow down around you! Get inside![/bolditalic][/color]
+ash-storm-clearing = [color=red]The shrieking wind whips away the last of the ash and falls to its usual murmur. It should be safe to go outside now.[/color]

Resources/Maps/reach.yml

@@ -4,8 +4,8 @@ meta:
   engineVersion: 268.0.0
   forkId: ""
   forkVersion: ""
-  time: 11/24/2025 21:47:10
+  time: 11/27/2025 18:20:30
-  entityCount: 2899
+  entityCount: 2900
 maps:
 - 1
 grids:
@@ -107,7 +107,7 @@ entities:
           version: 7
         -1,1:
           ind: -1,1
-          tiles: AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB+AAAAAAAAfQAAAAAAAH0AAAAAAAB9AAAAAAAAbQAAAAAAAH4AAAAAAAB+AAAAAAAAfgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAfgAAAAAAAH4AAAAAAABtAAAAAAAAfgAAAAAAAG0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==
+          tiles: AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB+AAAAAAAAfQAAAAAAAH0AAAAAAAB9AAAAAAAAbQAAAAAAAH4AAAAAAAB+AAAAAAAAbQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAfgAAAAAAAH4AAAAAAABtAAAAAAAAfgAAAAAAAG0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==
           version: 7
         -1,-2:
           ind: -1,-2
@@ -1069,7 +1069,7 @@ entities:
           -2,4:
             0: 14
           -1,4:
-            1: 175
+            1: 47
           0,-5:
             1: 24576
             0: 3584
@@ -1582,14 +1582,8 @@ entities:
       rot: 1.5707963267948966 rad
       pos: 13.5,13.5
       parent: 2
-- proto: AirlockExternalGlassShuttleLocked
+- proto: AirlockExternalGlassShuttleMining
   entities:
-  - uid: 44
-    components:
-    - type: Transform
-      rot: 3.141592653589793 rad
-      pos: -0.5,17.5
-      parent: 2
   - uid: 45
     components:
     - type: Transform
@@ -1977,12 +1971,6 @@ entities:
       rot: 3.141592653589793 rad
       pos: -2.5,17.5
       parent: 2
-  - uid: 100
-    components:
-    - type: Transform
-      rot: 3.141592653589793 rad
-      pos: -0.5,17.5
-      parent: 2
   - uid: 101
     components:
     - type: Transform
@@ -4402,6 +4390,11 @@ entities:
     - type: Transform
       pos: -4.5,-14.5
       parent: 2
+  - uid: 2900
+    components:
+    - type: Transform
+      pos: -5.5,10.5
+      parent: 2
 - proto: CableHV
   entities:
   - uid: 571
@@ -6857,11 +6850,6 @@ entities:
     - type: Transform
       pos: -0.5,15.5
       parent: 2
-  - uid: 1053
-    components:
-    - type: Transform
-      pos: -0.5,16.5
-      parent: 2
   - uid: 1054
     components:
     - type: Transform
@@ -7790,6 +7778,13 @@ entities:
     - type: Transform
       pos: 2.5,13.5
       parent: 2
+- proto: ComputerShuttleMining
+  entities:
+  - uid: 1053
+    components:
+    - type: Transform
+      pos: -0.5,16.5
+      parent: 2
 - proto: ComputerSurveillanceCameraMonitor
   entities:
   - uid: 1200
@@ -12183,6 +12178,11 @@ entities:
       radius: 175.75
 - proto: Grille
   entities:
+  - uid: 44
+    components:
+    - type: Transform
+      pos: -0.5,17.5
+      parent: 2
   - uid: 1812
     components:
     - type: Transform
@@ -14758,6 +14758,11 @@ entities:
       parent: 2
 - proto: ShuttleWindow
   entities:
+  - uid: 100
+    components:
+    - type: Transform
+      pos: -0.5,17.5
+      parent: 2
   - uid: 2183
     components:
     - type: Transform

Resources/Prototypes/Body/Prototypes/ashwalker.yml

@@ -0,0 +1,50 @@
+# TODO: will need updating with shitmed
+- type: body
+  name: ashwalker
+  id: AshWalker
+  root: torso
+  slots:
+    head:
+      part: HeadReptilian
+      connections:
+      - torso
+      organs:
+        brain: OrganHumanBrain
+        eyes: OrganHumanEyes
+    torso:
+      part: TorsoReptilian
+      organs:
+        heart: OrganAnimalHeart
+        lungs: OrganAshWalkerLungs
+        stomach: OrganReptilianStomach
+        liver: OrganAnimalLiver
+        kidneys: OrganHumanKidneys
+      connections:
+      - right arm
+      - left arm
+      - right leg
+      - left leg
+    right arm:
+      part: RightArmReptilian
+      connections:
+      - right hand
+    left arm:
+      part: LeftArmReptilian
+      connections:
+      - left hand
+    right hand:
+      part: RightHandReptilian
+    left hand:
+      part: LeftHandReptilian
+    right leg:
+      part: RightLegReptilian
+      connections:
+      - right foot
+    left leg:
+      part: LeftLegReptilian
+      connections:
+      - left foot
+    right foot:
+      part: RightFootReptilian
+    left foot:
+      part: LeftFootReptilian

Resources/Prototypes/Catalog/Fills/Lockers/cargo.yml

@@ -11,6 +11,7 @@
   id: LockerFillSalvageSpecialist
   table: !type:AllSelector
     children:
+    - id: OreBag
     - id: Pickaxe
     - id: WeaponProtoKineticAccelerator
     - id: FlashlightSeclite

Resources/Prototypes/DeltaV/Body/Organs/ashwalker.yml

@@ -0,0 +1,9 @@
+- type: entity
+  parent: OrganAnimalLungs
+  id: OrganAshWalkerLungs
+  name: ashwalker lungs
+  description: These lungs are adapted from isolation in lavaland, capable of withstanding the low oxygen content and ash storms.
+  components:
+  - type: Lung
+    saturationLoss: 0.5
+  # TODO SHITMED: add AshStormImmune when transplanted

Resources/Prototypes/DeltaV/Catalog/VendingMachines/Inventories/salvage_points.yml

@@ -18,7 +18,8 @@
   # TODO: stabilizing serum for 400
   - id: FultonBeacon
     cost: 400
-  # TODO: bluespace shelter capsule for 400
+  - id: ShelterCapsule
+    cost: 400
   - id: ClothingEyesGlassesGarMeson
     cost: 500
   - id: ClothingBeltSalvageWebbing
@@ -47,7 +48,9 @@
   # TODO: jump boots for 2500
   - id: ClothingOuterHardsuitSalvage
     cost: 3000
-  # TODO: luxury shelter capsule for 3k
+  - id: ShelterCapsuleLuxury
-  # TODO: luxury elite bar capsule for 10k
+    cost: 3000
+  - id: ShelterCapsuleBar
+    cost: 10000
   # TODO: pka mods
   # TODO: mining drone stuff

Resources/Prototypes/DeltaV/Entities/Mobs/Species/ashwalker.yml

@@ -0,0 +1,11 @@
+- type: entity
+  save: false
+  parent: MobReptilian
+  id: MobAshWalker
+  name: Urist McAsh
+  suffix: ""
+  components:
+  - type: Body
+    prototype: AshWalker
+  - type: AshStormImmune
+  # TODO: shitmed stuff so you can steal ashwalker lungs

Resources/Prototypes/DeltaV/Entities/Stations/base.yml

@@ -4,4 +4,4 @@
   components:
   - type: StationPlanetSpawner
     planet: Lavaland
-    gridPath: /Maps/Nonstations/DeltaV/lavaland_mining_base.yml
+    gridPath: /Maps/Nonstations/_TBD/lavaland_base.yml

Resources/Prototypes/DeltaV/planets.yml

@@ -0,0 +1,75 @@
+- type: planet
+  id: Lavaland
+  biome: Lava
+  mapName: shuttle-destination-lavaland
+  mapLight: "#A34931"
+  addedComponents:
+  - type: FTLDestination
+    whitelist:
+      components:
+      - MiningShuttle
+  - type: WeatherScheduler # Regular ash storms
+    stages:
+    - duration: # 5-10 minutes of calm
+        min: 300
+        max: 600
+    - weather: AshfallLight # ash starts to fall, 30 second warning
+      message: ash-storm-telegraph
+      duration:
+        min: 30
+        max: 30
+    - weather: Ashfall # 1-2 minutes of damaging storm
+      message: ash-storm-alert
+      duration:
+        min: 60
+        max: 120
+    - weather: AshfallLight # ash clears away for 30 seconds
+      message: ash-storm-clearing
+      duration:
+        min: 30
+        max: 30
+  atmosphere:
+    volume: 2500
+    temperature: 353.15 # 80C
+    moles: # 120kPa, 14% O2 (unbreathable)
+    - 14.38346
+    - 88.35554
+  biomeMarkerLayers:
+  - OreIron
+  - OreQuartz
+  - OreCoal
+  - OreGold
+  - OreSilver
+  - OrePlasmaLow
+  - OreUranium
+  - OreDiamondLow
+  - OreArtifactFragment
+  - WatchersLavaland
+  - GoliathsLavaland
+
+- type: planet
+  id: GlacierSurface
+  biome: Snow
+  mapName: shuttle-destination-glacier-surface
+  mapLight: "#2B3153"
+  addedComponents:
+  - type: FTLDestination
+    whitelist:
+      components:
+      - MiningShuttle
+  atmosphere:
+    volume: 2500
+    temperature: 180 # -93, extreme cold
+    moles: # 119kPa, 21% O2
+    - 42
+    - 158
+  biomeMarkerLayers:
+  - OreIron
+  - OreQuartz
+  - OreCoal
+  - OreGold
+  - OreSilver
+  - OrePlasma
+  - OreUraniumLow
+  - OreDiamond
+  - OreArtifactFragment

Resources/Prototypes/Entities/Stations/base.yml

@@ -53,6 +53,14 @@
       path: /Maps/Shuttles/cargo.yml
     - type: GridSpawn
       groups:
+        mining: !type:GridSpawnGroup
+          addComponents:
+            - type: ProtectedGrid
+          paths:
+          - /Maps/Shuttles/DeltaV/mining.yml
+        reclaimer: !type:GridSpawnGroup
+          paths:
+          - /Maps/Shuttles/mining.yml
         trade: !type:GridSpawnGroup
           addComponents:
             - type: ProtectedGrid

Resources/Prototypes/Procedural/biome_markers.yml

@@ -7,8 +7,14 @@
 - type: biomeMarkerLayer
   id: WatchersLavaland
   prototype: MobWatcherLavaland
-  minGroupSize: 3
+  minGroupSize: 2
   maxGroupSize: 3
+  
+- type: biomeMarkerLayer
+  id: GoliathsLavaland
+  prototype: MobGoliath
+  minGroupSize: 1
+  maxGroupSize: 2
 
 - type: biomeMarkerLayer
   id: WatchersIcewing

Resources/Prototypes/_DV/Catalog/Fills/Crates/salvage.yml

@@ -0,0 +1,23 @@
+# This is meant to be a smart fridge, but thats useless so
+- type: entity
+  parent: CratePlastic
+  id: CrateSurvivalPodStorage
+  name: survival pod storage
+  suffix: Filled
+  components:
+  - type: EntityTableContainerFill
+    containers:
+      entity_storage: !type:NestedSelector
+        tableId: SurvivalPod
+
+- type: entityTable
+  id: SurvivalPod
+  table: !type:AllSelector
+    children:
+    - id: FoodDonkpocketWarm
+      amount: !type:ConstantNumberSelector
+        value: 5
+    - !type:GroupSelector
+      children:
+      - id: d6Dice
+      - id: AcousticGuitarInstrument

Resources/Prototypes/_DV/Entities/Objects/Specific/Salvage/shelter_capsules.yml

@@ -0,0 +1,63 @@
+- type: entity
+  abstract: true
+  parent: BaseItem
+  id: BaseShelterCapsule
+  components:
+  - type: Sprite
+    sprite: _DV/Objects/Specific/Salvage/shelter_capsule.rsi
+    state: capsule
+  - type: Item
+    size: Tiny
+  - type: UseDelay
+    delay: 15 # avoid spamming popups when you know it will fail to spawn a room
+  - type: ShelterCapsule
+
+- type: entity
+  parent: BaseShelterCapsule
+  id: ShelterCapsule
+  name: bluespace shelter capsule
+  description: An emergency shelter stored within a pocket of bluespace.
+  components:
+  - type: ShelterCapsule
+    room: EmergencyShelter
+
+- type: entity
+  parent: BaseShelterCapsule
+  id: ShelterCapsuleLuxury
+  name: luxury bluespace shelter capsule
+  description: An exorbitantly expensive luxury suite stored within a pocket of bluespace.
+  components:
+  - type: ShelterCapsule
+    room: LuxuryShelter
+
+- type: entity
+  parent: BaseShelterCapsule
+  id: ShelterCapsuleBar
+  name: luxury elite bar capsule
+  description: A luxury bar in a capsule. Bartender required and not included.
+  components:
+  - type: ShelterCapsule
+    room: EliteBarShelter
+
+# Dungeon room prototypes
+
+- type: dungeonRoom
+  id: EmergencyShelter
+  size: 5,5
+  atlas: /Maps/_DV/Nonstations/shelters.yml
+  offset: -2,-2 # grid is offset badly cba to fix it
+  ignoreTile: FloorShuttleOrange
+
+- type: dungeonRoom
+  id: LuxuryShelter
+  size: 7,7
+  atlas: /Maps/_DV/Nonstations/shelters.yml
+  offset: 4,-2
+  ignoreTile: FloorShuttleOrange
+
+- type: dungeonRoom
+  id: EliteBarShelter
+  size: 11,11
+  atlas: /Maps/_DV/Nonstations/shelters.yml
+  offset: 12,-2
+  ignoreTile: FloorShuttleOrange

Resources/Prototypes/weather.yml

@@ -8,6 +8,12 @@
     params:
       loop: true
       volume: -6
+  damage: # DeltaV
+    types:
+      Heat: 4
+  damageBlacklist: # DeltaV
+    components:
+    - AshStormImmune
 
 - type: weather
   id: AshfallLight

Resources/Textures/_DV/Objects/Specific/Salvage/shelter_capsule.rsi/meta.json

@@ -0,0 +1,14 @@
+{
+    "version": 1,
+    "license": "CC-BY-SA-3.0",
+    "copyright": "Taken from tgstation at https://github.com/tgstation/tgstation/blob/8d20615ba100e7744792b42b6a6c7f4ea6314b3f/icons/obj/mining.dmi",
+    "size": {
+        "x": 32,
+        "y": 32
+    },
+    "states": [
+        {
+            "name": "capsule"
+        }
+    ]
+}