From 4a466f4927c7f83ca43f5f80abcea71cd3f73961 Mon Sep 17 00:00:00 2001
From: Moony <moonheart08@users.noreply.github.com>
Date: Fri, 4 Mar 2022 13:48:01 -0600
Subject: [PATCH] Explosion refactor TEST MERG (#6995)

* Explosions

* fix yaml typo

and prevent silly UI inputs

* oop

Co-authored-by: ElectroJr <leonsfriedrich@gmail.com>
---
 .../SpawnExplosion/ExplosionDebugOverlay.cs   | 185 ++++++
 .../UI/SpawnExplosion/SpawnExplosionEui.cs    |  75 +++
 .../SpawnExplosion/SpawnExplosionWindow.xaml  |  46 ++
 .../SpawnExplosionWindow.xaml.cs              | 142 +++++
 Content.Client/Entry/IgnoredComponents.cs     |   1 +
 Content.Client/Explosion/ExplosionOverlay.cs  | 120 ++++
 .../Explosion/ExplosionOverlaySystem.cs       | 190 ++++++
 Content.Server/AME/AMENodeGroup.cs            |  11 +-
 .../Administration/AdminVerbSystem.cs         |   6 +-
 .../Commands/ExplosionCommand.cs              | 142 ++++-
 .../Administration/UI/SpawnExplosionEui.cs    |  39 ++
 .../Atmos/Components/GasTankComponent.cs      |   4 +-
 .../Atmos/EntitySystems/AirtightSystem.cs     |   3 +
 .../ExplosionReactionEffect.cs                |  90 ++-
 .../Destructible/DestructibleSystem.cs        |  38 ++
 .../Thresholds/Behaviors/ExplodeBehavior.cs   |   2 +-
 .../Components/ExplosionLaunchedComponent.cs  |  42 +-
 .../ExplosionResistanceComponent.cs           |  30 +
 .../Components/ExplosiveComponent.cs          |  77 ++-
 .../EntitySystems/ExplosionSystem.Airtight.cs | 141 ++++
 .../EntitySystems/ExplosionSystem.GridMap.cs  | 438 +++++++++++++
 .../ExplosionSystem.Processing.cs             | 569 +++++++++++++++++
 .../EntitySystems/ExplosionSystem.TileFill.cs | 334 ++++++++++
 .../EntitySystems/ExplosionSystem.cs          | 600 +++++++-----------
 .../EntitySystems/ExplosionSystem.cvars.cs    |  44 ++
 .../Explosion/EntitySystems/GridExplosion.cs  | 311 +++++++++
 .../Explosion/EntitySystems/SpaceExplosion.cs | 157 +++++
 .../Explosion/EntitySystems/TileExplosion.cs  | 116 ++++
 .../Explosion/EntitySystems/TriggerSystem.cs  |  24 +-
 .../EntitySystems/NodeGroupSystem.cs          |   9 +-
 Content.Server/Nuke/NukeComponent.cs          |  51 +-
 Content.Server/Nuke/NukeSystem.cs             |  25 +-
 .../Components/RoguePointingArrowComponent.cs |   4 -
 .../EntitySystems/RoguePointingSystem.cs      |   9 +-
 Content.Server/PowerCell/PowerCellSystem.cs   |   6 +-
 .../Components/EntityStorageComponent.cs      |  20 +-
 .../Components/ServerStorageComponent.cs      |  26 +-
 Content.Shared/Acts/ActSystem.cs              |  40 +-
 .../Administration/SpawnExplosionEuiMsg.cs    |  52 ++
 Content.Shared/CCVar/CCVars.cs                |  79 +++
 .../Damage/Components/DamageableComponent.cs  |  23 +-
 Content.Shared/Explosion/ExplosionEvents.cs   |  81 +++
 .../Explosion/ExplosionPrototype.cs           |  89 +++
 Content.Shared/FixedPoint/FixedPoint2.cs      |   5 +
 .../Inventory/InventoryComponent.cs           |  30 +-
 .../Inventory/InventorySystem.Relay.cs        |   5 +-
 Resources/Audio/Effects/explosion1.ogg        | Bin 20834 -> 32032 bytes
 Resources/Audio/Effects/explosion2.ogg        | Bin 21899 -> 32735 bytes
 .../ui/admin-spawn-explosion-eui.ftl          |  16 +
 .../Entities/Clothing/Head/helmets.yml        |   2 +
 .../Entities/Clothing/OuterClothing/suits.yml |   6 +-
 .../Entities/Effects/explosion_light.yml      |   9 +
 .../Entities/Objects/Devices/nuke.yml         |   5 +
 .../Entities/Objects/Power/powercells.yml     |   2 +
 .../Entities/Objects/Tools/gas_tanks.yml      |   3 +
 .../Weapons/Guns/Projectiles/meteors.yml      |  12 +-
 .../Weapons/Guns/Projectiles/projectiles.yml  |  21 +-
 .../Objects/Weapons/Throwable/grenades.yml    |  23 +-
 .../Structures/Power/Generation/ame.yml       |   4 +
 .../Entities/Structures/Power/substation.yml  |   8 +-
 .../Storage/Closets/Lockers/lockers.yml       |   2 +
 .../Structures/Storage/Tanks/tanks.yml        |   8 +-
 .../Entities/Structures/Walls/barricades.yml  |   1 -
 .../Entities/Structures/Walls/girder.yml      |   3 -
 .../Recipes/Reactions/chemicals.yml           |  12 +-
 .../Recipes/Reactions/pyrotechnic.yml         |  10 +-
 Resources/Prototypes/explosion.yml            |  39 ++
 .../Textures/Effects/fire_greyscale.rsi/1.png | Bin 0 -> 62870 bytes
 .../Textures/Effects/fire_greyscale.rsi/2.png | Bin 0 -> 110683 bytes
 .../Textures/Effects/fire_greyscale.rsi/3.png | Bin 0 -> 18528 bytes
 .../Effects/fire_greyscale.rsi/meta.json      |   1 +
 71 files changed, 3958 insertions(+), 760 deletions(-)
 create mode 100644 Content.Client/Administration/UI/SpawnExplosion/ExplosionDebugOverlay.cs
 create mode 100644 Content.Client/Administration/UI/SpawnExplosion/SpawnExplosionEui.cs
 create mode 100644 Content.Client/Administration/UI/SpawnExplosion/SpawnExplosionWindow.xaml
 create mode 100644 Content.Client/Administration/UI/SpawnExplosion/SpawnExplosionWindow.xaml.cs
 create mode 100644 Content.Client/Explosion/ExplosionOverlay.cs
 create mode 100644 Content.Client/Explosion/ExplosionOverlaySystem.cs
 create mode 100644 Content.Server/Administration/UI/SpawnExplosionEui.cs
 create mode 100644 Content.Server/Explosion/Components/ExplosionResistanceComponent.cs
 create mode 100644 Content.Server/Explosion/EntitySystems/ExplosionSystem.Airtight.cs
 create mode 100644 Content.Server/Explosion/EntitySystems/ExplosionSystem.GridMap.cs
 create mode 100644 Content.Server/Explosion/EntitySystems/ExplosionSystem.Processing.cs
 create mode 100644 Content.Server/Explosion/EntitySystems/ExplosionSystem.TileFill.cs
 create mode 100644 Content.Server/Explosion/EntitySystems/ExplosionSystem.cvars.cs
 create mode 100644 Content.Server/Explosion/EntitySystems/GridExplosion.cs
 create mode 100644 Content.Server/Explosion/EntitySystems/SpaceExplosion.cs
 create mode 100644 Content.Server/Explosion/EntitySystems/TileExplosion.cs
 create mode 100644 Content.Shared/Administration/SpawnExplosionEuiMsg.cs
 create mode 100644 Content.Shared/Explosion/ExplosionEvents.cs
 create mode 100644 Content.Shared/Explosion/ExplosionPrototype.cs
 create mode 100644 Resources/Locale/en-US/administration/ui/admin-spawn-explosion-eui.ftl
 create mode 100644 Resources/Prototypes/Entities/Effects/explosion_light.yml
 create mode 100644 Resources/Prototypes/explosion.yml
 create mode 100644 Resources/Textures/Effects/fire_greyscale.rsi/1.png
 create mode 100644 Resources/Textures/Effects/fire_greyscale.rsi/2.png
 create mode 100644 Resources/Textures/Effects/fire_greyscale.rsi/3.png
 create mode 100644 Resources/Textures/Effects/fire_greyscale.rsi/meta.json

diff --git a/Content.Client/Administration/UI/SpawnExplosion/ExplosionDebugOverlay.cs b/Content.Client/Administration/UI/SpawnExplosion/ExplosionDebugOverlay.cs
new file mode 100644
index 0000000000..e6e18d994a
--- /dev/null
+++ b/Content.Client/Administration/UI/SpawnExplosion/ExplosionDebugOverlay.cs
@@ -0,0 +1,185 @@
+using JetBrains.Annotations;
+using Robust.Client.Graphics;
+using Robust.Client.ResourceManagement;
+using Robust.Shared.Enums;
+using Robust.Shared.Map;
+using System.Linq;
+
+namespace Content.Client.Administration.UI.SpawnExplosion;
+
+[UsedImplicitly]
+public sealed class ExplosionDebugOverlay : Overlay
+{
+    [Dependency] private readonly IEntityManager _entityManager = default!;
+    [Dependency] private readonly IEyeManager _eyeManager = default!;
+    [Dependency] private readonly IMapManager _mapManager = default!;
+
+    public Dictionary<int, List<Vector2i>>? SpaceTiles;
+    public Dictionary<GridId, Dictionary<int, List<Vector2i>>> Tiles = new();
+    public List<float> Intensity = new();
+    public float TotalIntensity;
+    public float Slope;
+
+    public override OverlaySpace Space => OverlaySpace.WorldSpace | OverlaySpace.ScreenSpace;
+
+    public Matrix3 SpaceMatrix;
+    public MapId Map;
+
+    private readonly Font _font;
+
+    public ExplosionDebugOverlay()
+    {
+        IoCManager.InjectDependencies(this);
+
+        var cache = IoCManager.Resolve<IResourceCache>();
+        _font = new VectorFont(cache.GetResource<FontResource>("/Fonts/NotoSans/NotoSans-Regular.ttf"), 8);
+    }
+
+    protected override void Draw(in OverlayDrawArgs args)
+    {
+        if (Map != _eyeManager.CurrentMap)
+            return;
+
+        if (Tiles.Count == 0 && SpaceTiles == null)
+            return;
+
+        switch (args.Space)
+        {
+            case OverlaySpace.ScreenSpace:
+                DrawScreen(args);
+                break;
+            case OverlaySpace.WorldSpace:
+                DrawWorld(args);
+                break;
+        }
+    }
+
+    private void DrawScreen(OverlayDrawArgs args)
+    {
+        var handle = args.ScreenHandle;
+        Box2 gridBounds;
+
+        foreach (var (gridId, tileSets) in Tiles)
+        {
+            if (!_mapManager.TryGetGrid(gridId, out var grid))
+                continue;
+
+            var gridXform = _entityManager.GetComponent<TransformComponent>(grid.GridEntityId);
+            gridBounds = gridXform.InvWorldMatrix.TransformBox(args.WorldBounds);
+
+            DrawText(handle, gridBounds, gridXform.WorldMatrix, tileSets);
+        }
+
+        if (SpaceTiles == null)
+            return;
+
+        gridBounds = Matrix3.Invert(SpaceMatrix).TransformBox(args.WorldBounds);
+
+        DrawText(handle, gridBounds, SpaceMatrix, SpaceTiles);
+    }
+
+    private void DrawText(
+        DrawingHandleScreen handle,
+        Box2 gridBounds,
+        Matrix3 transform,
+        Dictionary<int, List<Vector2i>> tileSets)
+    {
+        for (var i = 1; i < Intensity.Count; i++)
+        {
+            if (!tileSets.TryGetValue(i, out var tiles))
+                continue;
+
+            foreach (var tile in tiles)
+            {
+                // is the center of this tile visible to the user?
+                if (!gridBounds.Contains((Vector2) tile + 0.5f))
+                    continue;
+
+                var worldCenter = transform.Transform((Vector2) tile + 0.5f);
+
+                var screenCenter = _eyeManager.WorldToScreen(worldCenter);
+
+                if (Intensity![i] > 9)
+                    screenCenter += (-12, -8);
+                else
+                    screenCenter += (-8, -8);
+
+                handle.DrawString(_font, screenCenter, Intensity![i].ToString("F2"));
+            }
+        }
+
+        if (tileSets.ContainsKey(0))
+        {
+            var epicenter = tileSets[0].First();
+            var worldCenter = transform.Transform((Vector2) epicenter + 0.5f);
+            var screenCenter = _eyeManager.WorldToScreen(worldCenter) + (-24, -24);
+            var text = $"{Intensity![0]:F2}\nΣ={TotalIntensity:F1}\nΔ={Slope:F1}";
+            handle.DrawString(_font, screenCenter, text);
+        }
+    }
+
+    private void DrawWorld(in OverlayDrawArgs args)
+    {
+        var handle = args.WorldHandle;
+        Box2 gridBounds;
+
+        foreach (var (gridId, tileSets) in Tiles)
+        {
+            if (!_mapManager.TryGetGrid(gridId, out var grid))
+                continue;
+
+            var gridXform = _entityManager.GetComponent<TransformComponent>(grid.GridEntityId);
+            handle.SetTransform(gridXform.WorldMatrix);
+            gridBounds = gridXform.InvWorldMatrix.TransformBox(args.WorldBounds);
+
+            DrawTiles(handle, gridBounds, tileSets);
+        }
+
+        if (SpaceTiles == null)
+            return;
+
+        gridBounds = Matrix3.Invert(SpaceMatrix).TransformBox(args.WorldBounds);
+        handle.SetTransform(SpaceMatrix);
+
+        DrawTiles(handle, gridBounds, SpaceTiles);
+    }
+
+    private void DrawTiles(
+        DrawingHandleWorld handle,
+        Box2 gridBounds,
+        Dictionary<int, List<Vector2i>> tileSets)
+    {
+        for (var i = 0; i < Intensity.Count; i++)
+        {
+            var color = ColorMap(Intensity![i]);
+            var colorTransparent = color;
+            colorTransparent.A = 0.2f;
+
+
+            if (!tileSets.TryGetValue(i, out var tiles))
+                continue;
+
+            foreach (var tile in tiles)
+            {
+                // is the center of this tile visible to the user?
+                if (!gridBounds.Contains((Vector2) tile + 0.5f))
+                    continue;
+
+                var box = Box2.UnitCentered.Translated((Vector2) tile + 0.5f);
+                handle.DrawRect(box, color, false);
+                handle.DrawRect(box, colorTransparent);
+            }
+        }
+    }
+
+    private Color ColorMap(float intensity)
+    {
+        var frac = 1 - intensity / Intensity![0];
+        Color result;
+        if (frac < 0.5f)
+            result = Color.InterpolateBetween(Color.Red, Color.Orange, frac * 2);
+        else
+            result = Color.InterpolateBetween(Color.Orange, Color.Yellow, (frac - 0.5f) * 2);
+        return result;
+    }
+}
diff --git a/Content.Client/Administration/UI/SpawnExplosion/SpawnExplosionEui.cs b/Content.Client/Administration/UI/SpawnExplosion/SpawnExplosionEui.cs
new file mode 100644
index 0000000000..7bcfb3b069
--- /dev/null
+++ b/Content.Client/Administration/UI/SpawnExplosion/SpawnExplosionEui.cs
@@ -0,0 +1,75 @@
+using Content.Client.Eui;
+using Content.Shared.Administration;
+using Content.Shared.Eui;
+using JetBrains.Annotations;
+using Robust.Client.Graphics;
+using Robust.Shared.Map;
+
+namespace Content.Client.Administration.UI.SpawnExplosion;
+
+[UsedImplicitly]
+public sealed class SpawnExplosionEui : BaseEui
+{
+    [Dependency] private readonly IOverlayManager _overlayManager = default!;
+
+    private readonly SpawnExplosionWindow _window;
+    private ExplosionDebugOverlay? _debugOverlay;
+
+    public SpawnExplosionEui()
+    {
+        IoCManager.InjectDependencies(this);
+        _window = new SpawnExplosionWindow(this);
+        _window.OnClose += () => SendMessage(new SpawnExplosionEuiMsg.Close());
+    }
+
+    public override void Opened()
+    {
+        base.Opened();
+        _window.OpenCentered();
+    }
+
+    public override void Closed()
+    {
+        base.Closed();
+        _window.OnClose -= () => SendMessage(new SpawnExplosionEuiMsg.Close());
+        _window.Close();
+        ClearOverlay();
+    }
+
+    public void ClearOverlay()
+    {
+        if (_overlayManager.HasOverlay<ExplosionDebugOverlay>())
+            _overlayManager.RemoveOverlay<ExplosionDebugOverlay>();
+        _debugOverlay = null;
+    }
+
+    public void RequestPreviewData(MapCoordinates epicenter, string typeId, float totalIntensity, float intensitySlope, float maxIntensity)
+    {
+        var msg = new SpawnExplosionEuiMsg.PreviewRequest(epicenter, typeId, totalIntensity, intensitySlope, maxIntensity);
+        SendMessage(msg);
+    }
+
+    /// <summary>
+    ///     Receive explosion preview data and add a client-side explosion preview overlay
+    /// </summary>
+    /// <param name="msg"></param>
+    public override void HandleMessage(EuiMessageBase msg)
+    {
+        if (msg is not SpawnExplosionEuiMsg.PreviewData data)
+            return;
+
+        if (_debugOverlay == null)
+        {
+            _debugOverlay = new();
+            _overlayManager.AddOverlay(_debugOverlay);
+        }
+
+        _debugOverlay.Tiles = data.Explosion.Tiles;
+        _debugOverlay.SpaceTiles = data.Explosion.SpaceTiles;
+        _debugOverlay.Intensity = data.Explosion.Intensity;
+        _debugOverlay.Slope = data.Slope;
+        _debugOverlay.TotalIntensity = data.TotalIntensity;
+        _debugOverlay.Map = data.Explosion.Epicenter.MapId;
+        _debugOverlay.SpaceMatrix = data.Explosion.SpaceMatrix;
+    }
+}
diff --git a/Content.Client/Administration/UI/SpawnExplosion/SpawnExplosionWindow.xaml b/Content.Client/Administration/UI/SpawnExplosion/SpawnExplosionWindow.xaml
new file mode 100644
index 0000000000..f1dcd35cb8
--- /dev/null
+++ b/Content.Client/Administration/UI/SpawnExplosion/SpawnExplosionWindow.xaml
@@ -0,0 +1,46 @@
+<DefaultWindow
+    xmlns="https://spacestation14.io"
+    Title="{Loc 'admin-explosion-eui-title'}"
+    SetHeight="380">
+    <BoxContainer Name="MainContainer" Orientation="Vertical">
+
+        <BoxContainer Orientation="Horizontal">
+            <Label Text="{Loc 'admin-explosion-eui-label-type'}" MinSize="120 0" />
+            <OptionButton Name="ExplosionOption" MinSize="70 0" HorizontalExpand="True" />
+        </BoxContainer>
+        
+        <BoxContainer Orientation="Horizontal">
+            <Label Text="{Loc 'admin-explosion-eui-label-mapid'}" MinSize="120 0" />
+            <OptionButton Name="MapOptions" MinSize="70 0" HorizontalExpand="True" />
+        </BoxContainer>
+        <BoxContainer Orientation="Horizontal">
+            <Label Text="{Loc 'admin-explosion-eui-label-xmap'}" MinSize="120 0" />
+            <FloatSpinBox Name="MapX" MinSize="70 0" HorizontalExpand="True" />
+        </BoxContainer>
+        <BoxContainer Orientation="Horizontal">
+            <Label Text="{Loc 'admin-explosion-eui-label-ymap'}" MinSize="120 0" />
+            <FloatSpinBox Name="MapY" MinSize="70 0" HorizontalExpand="True" />
+        </BoxContainer>
+        <Button Name="Recentre" Text="{Loc 'admin-explosion-eui-label-current'}" />
+
+        <Control MinSize="0 20"/>
+
+        <CheckBox Name="Preview" Text="{Loc 'admin-explosion-eui-label-preview'}"/>
+        <BoxContainer Orientation="Horizontal">
+            <Label Text="{Loc 'admin-explosion-eui-label-total'}" MinSize="120 0"/>
+            <FloatSpinBox Name="Intensity" MinSize="130 0" HorizontalExpand="True" Value="200"/>
+        </BoxContainer>
+        <BoxContainer Orientation="Horizontal">
+            <Label Text="{Loc 'admin-explosion-eui-label-slope'}" MinSize="120 0" />
+            <FloatSpinBox Name="Slope" MinSize="130 0" HorizontalExpand="True" Value="5"/>
+        </BoxContainer>
+        <BoxContainer Orientation="Horizontal">
+            <Label Text="{Loc 'admin-explosion-eui-label-max'}" MinSize="120 0" />
+            <FloatSpinBox Name="MaxIntensity" MinSize="130 0" HorizontalExpand="True" Value="100"/>
+        </BoxContainer>
+
+        <Control MinSize="0 20"/>
+
+        <Button Name="Spawn" Text="{Loc 'admin-explosion-eui-label-spawn'}" />
+    </BoxContainer>
+</DefaultWindow>
diff --git a/Content.Client/Administration/UI/SpawnExplosion/SpawnExplosionWindow.xaml.cs b/Content.Client/Administration/UI/SpawnExplosion/SpawnExplosionWindow.xaml.cs
new file mode 100644
index 0000000000..6399c1e03c
--- /dev/null
+++ b/Content.Client/Administration/UI/SpawnExplosion/SpawnExplosionWindow.xaml.cs
@@ -0,0 +1,142 @@
+using Content.Shared.Explosion;
+using JetBrains.Annotations;
+using Robust.Client.AutoGenerated;
+using Robust.Client.Console;
+using Robust.Client.Player;
+using Robust.Client.UserInterface.CustomControls;
+using Robust.Client.UserInterface.XAML;
+using Robust.Shared.Map;
+using Robust.Shared.Prototypes;
+using static Robust.Client.UserInterface.Controls.BaseButton;
+using static Robust.Client.UserInterface.Controls.OptionButton;
+
+namespace Content.Client.Administration.UI.SpawnExplosion;
+
+[GenerateTypedNameReferences]
+[UsedImplicitly]
+public sealed partial class SpawnExplosionWindow : DefaultWindow
+{
+    [Dependency] private readonly IClientConsoleHost _conHost = default!;
+    [Dependency] private readonly IMapManager _mapManager = default!;
+    [Dependency] private readonly IPlayerManager _playerManager = default!;
+    [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
+    [Dependency] private readonly IEntityManager _entMan = default!;
+
+
+    private readonly SpawnExplosionEui _eui;
+    private List<MapId> _mapData = new();
+    private List<string> _explosionTypes = new();
+
+    /// <summary>
+    ///     Used to prevent unnecessary preview updates when setting fields (e.g., updating position)..
+    /// </summary>
+    private bool _pausePreview;
+
+    public SpawnExplosionWindow(SpawnExplosionEui eui)
+    {
+        RobustXamlLoader.Load(this);
+        IoCManager.InjectDependencies(this);
+        _eui = eui;
+
+        ExplosionOption.OnItemSelected += ExplosionSelected;
+        MapOptions.OnItemSelected += MapSelected;
+        Recentre.OnPressed += (_) => SetLocation();
+        Spawn.OnPressed += SubmitButtonOnOnPressed;
+
+        Preview.OnToggled += (_) => UpdatePreview();
+        MapX.OnValueChanged += (_) => UpdatePreview();
+        MapY.OnValueChanged += (_) => UpdatePreview();
+        Intensity.OnValueChanged += (_) => UpdatePreview();
+        Slope.OnValueChanged += (_) => UpdatePreview();
+        MaxIntensity.OnValueChanged += (_) => UpdatePreview();
+    }
+
+    private void ExplosionSelected(ItemSelectedEventArgs args)
+    {
+        ExplosionOption.SelectId(args.Id);
+        UpdatePreview();
+    }
+
+    private void MapSelected(ItemSelectedEventArgs args)
+    {
+        MapOptions.SelectId(args.Id);
+        UpdatePreview();
+    }
+
+    protected override void EnteredTree()
+    {
+        SetLocation();
+        UpdateExplosionTypeOptions();
+    }
+
+    private void UpdateExplosionTypeOptions()
+    {
+        _explosionTypes.Clear();
+        ExplosionOption.Clear();
+        foreach (var type in _prototypeManager.EnumeratePrototypes<ExplosionPrototype>())
+        {
+            _explosionTypes.Add(type.ID);
+            ExplosionOption.AddItem(type.ID);
+        }
+    }
+
+    private void UpdateMapOptions()
+    {
+        _mapData.Clear();
+        MapOptions.Clear();
+        foreach (var map in _mapManager.GetAllMapIds())
+        {
+            _mapData.Add(map);
+            MapOptions.AddItem(map.ToString());
+        }
+    }
+
+    /// <summary>
+    ///     Set the current grid & indices based on the attached entities current location.
+    /// </summary>
+    private void SetLocation()
+    {
+        UpdateMapOptions();
+
+        if (!_entMan.TryGetComponent(_playerManager.LocalPlayer?.ControlledEntity, out TransformComponent? transform))
+            return;
+
+        _pausePreview = true;
+        MapOptions.Select(_mapData.IndexOf(transform.MapID));
+        (MapX.Value, MapY.Value) = transform.MapPosition.Position;
+        _pausePreview = false;
+
+        UpdatePreview();
+    }
+
+    private void UpdatePreview()
+    {
+        if (_pausePreview)
+            return;
+
+        if (!Preview.Pressed)
+        {
+            _eui.ClearOverlay();
+            return;
+        }
+
+        MapCoordinates coords = new((MapX.Value, MapY.Value), _mapData[MapOptions.SelectedId]);
+        var explosionType = _explosionTypes[ExplosionOption.SelectedId];
+        _eui.RequestPreviewData(coords, explosionType, Intensity.Value, Slope.Value, MaxIntensity.Value);
+    }
+
+    private void SubmitButtonOnOnPressed(ButtonEventArgs args)
+    {
+        // need to make room to view the fireworks
+        Preview.Pressed = false;
+        _eui.ClearOverlay();
+
+        // for the actual explosion, we will just re-use the explosion command.
+        // so assemble command arguments:
+        var mapId = _mapData[MapOptions.SelectedId];
+        var explosionType = _explosionTypes[ExplosionOption.SelectedId];
+        var cmd = $"explosion {Intensity.Value} {Slope.Value} {MaxIntensity.Value} {MapX.Value} {MapY.Value} {mapId} {explosionType}";
+
+        _conHost.ExecuteCommand(cmd);
+    }
+}
diff --git a/Content.Client/Entry/IgnoredComponents.cs b/Content.Client/Entry/IgnoredComponents.cs
index fa31384c4a..dc6accbbab 100644
--- a/Content.Client/Entry/IgnoredComponents.cs
+++ b/Content.Client/Entry/IgnoredComponents.cs
@@ -16,6 +16,7 @@ namespace Content.Client.Entry
             "Temperature",
             "AtmosExposed",
             "Explosive",
+            "ExplosionResistance",
             "Vocal",
             "OnUseTimerTrigger",
             "WarpPoint",
diff --git a/Content.Client/Explosion/ExplosionOverlay.cs b/Content.Client/Explosion/ExplosionOverlay.cs
new file mode 100644
index 0000000000..8e71c0e5d0
--- /dev/null
+++ b/Content.Client/Explosion/ExplosionOverlay.cs
@@ -0,0 +1,120 @@
+using JetBrains.Annotations;
+using Robust.Client.Graphics;
+using Robust.Shared.Enums;
+using Robust.Shared.Map;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Random;
+
+namespace Content.Client.Explosion;
+
+[UsedImplicitly]
+public sealed class ExplosionOverlay : Overlay
+{
+    /// <summary>
+    ///     The explosion that needs to be drawn. This explosion is currently being processed by the server and
+    ///     expanding outwards.
+    /// </summary>
+    internal Explosion? ActiveExplosion;
+
+    /// <summary>
+    ///     This index specifies what parts of the currently expanding explosion should be drawn.
+    /// </summary>
+    public int Index;
+
+    /// <summary>
+    ///     These explosions have finished expanding, but we will draw for a few more frames. This is important for
+    ///     small explosions, as otherwise they disappear far too quickly.
+    /// </summary>
+    internal List<Explosion> CompletedExplosions = new ();
+
+    [Dependency] private readonly IEyeManager _eyeManager = default!;
+    [Dependency] private readonly IRobustRandom _robustRandom = default!;
+    [Dependency] private readonly IMapManager _mapManager = default!;
+
+    public override OverlaySpace Space => OverlaySpace.WorldSpaceBelowFOV;
+
+    /// <summary>
+    ///     How intense does the explosion have to be at a tile to advance to the next fire texture state?
+    /// </summary>
+    public const int IntensityPerState = 12;
+
+    private ShaderInstance _shader;
+
+    public ExplosionOverlay()
+    {
+        IoCManager.InjectDependencies(this);
+        _shader = IoCManager.Resolve<IPrototypeManager>().Index<ShaderPrototype>("unshaded").Instance();
+    }
+
+    protected override void Draw(in OverlayDrawArgs args)
+    {
+        var drawHandle = args.WorldHandle;
+        drawHandle.UseShader(_shader);
+
+        if (ActiveExplosion != null)
+        {
+            DrawExplosion(drawHandle, args.WorldBounds, ActiveExplosion, Index);
+        }
+
+        foreach (var exp in CompletedExplosions)
+        {
+            DrawExplosion(drawHandle, args.WorldBounds, exp, exp.Intensity.Count);
+        }
+
+        drawHandle.SetTransform(Matrix3.Identity);
+    }
+
+    private void DrawExplosion(DrawingHandleWorld drawHandle, Box2Rotated worldBounds, Explosion exp, int index)
+    {
+        if (exp.Map != _eyeManager.CurrentMap)
+            return;
+
+        Box2 gridBounds;
+        foreach (var (gridId, tiles) in exp.Tiles)
+        {
+            if (!_mapManager.TryGetGrid(gridId, out var grid))
+                continue;
+
+            gridBounds = grid.InvWorldMatrix.TransformBox(worldBounds);
+            drawHandle.SetTransform(grid.WorldMatrix);
+
+            DrawTiles(drawHandle, gridBounds, index, tiles, exp);
+        }
+
+        if (exp.SpaceTiles == null)
+            return;
+
+        gridBounds = Matrix3.Invert(exp.SpaceMatrix).TransformBox(worldBounds);
+        drawHandle.SetTransform(exp.SpaceMatrix);
+        
+        DrawTiles(drawHandle, gridBounds, index, exp.SpaceTiles, exp);
+    }
+
+    private void DrawTiles(
+        DrawingHandleWorld drawHandle,
+        Box2 gridBounds,
+        int index,
+        Dictionary<int, List<Vector2i>> tileSets,
+        Explosion exp)
+    {
+        for (var j = 0; j < index; j++)
+        {
+            if (!tileSets.TryGetValue(j, out var tiles))
+                continue;
+
+            var frameIndex = (int) Math.Min(exp.Intensity[j] / IntensityPerState, exp.FireFrames.Count - 1);
+            var frames = exp.FireFrames[frameIndex];
+
+            foreach (var tile in tiles)
+            {
+                Vector2 bottomLeft = (tile.X, tile.Y);
+
+                if (!gridBounds.Contains((bottomLeft + 0.5f) * 1f))
+                    continue;
+
+                var texture = _robustRandom.Pick(frames);
+                drawHandle.DrawTexture(texture, bottomLeft, exp.FireColor);
+            }
+        }
+    }
+}
diff --git a/Content.Client/Explosion/ExplosionOverlaySystem.cs b/Content.Client/Explosion/ExplosionOverlaySystem.cs
new file mode 100644
index 0000000000..486f65e28a
--- /dev/null
+++ b/Content.Client/Explosion/ExplosionOverlaySystem.cs
@@ -0,0 +1,190 @@
+using Content.Shared.Explosion;
+using Robust.Client.GameObjects;
+using Robust.Client.Graphics;
+using Robust.Client.ResourceManagement;
+using Robust.Shared.Map;
+using Robust.Shared.Prototypes;
+
+namespace Content.Client.Explosion;
+
+/// <summary>
+///     This system is responsible for showing the client-side explosion effects (light source & fire-overlay). The
+///     fire overlay code is just a bastardized version of the atmos plasma fire overlay and uses the same texture.
+/// </summary>
+public sealed class ExplosionOverlaySystem : EntitySystem
+{
+    private ExplosionOverlay _overlay = default!;
+
+    [Dependency] private readonly IPrototypeManager _protoMan = default!;
+
+
+    /// <summary>
+    ///     For how many seconds should an explosion stay on-screen once it has finished expanding?
+    /// </summary>
+    public const float ExplosionPersistence = 0.3f;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeNetworkEvent<ExplosionEvent>(OnExplosion);
+        SubscribeNetworkEvent<ExplosionOverlayUpdateEvent>(HandleExplosionUpdate);
+
+        var overlayManager = IoCManager.Resolve<IOverlayManager>();
+        _overlay = new ExplosionOverlay();
+        if (!overlayManager.HasOverlay<ExplosionOverlay>())
+            overlayManager.AddOverlay(_overlay);
+    }
+
+    public override void FrameUpdate(float frameTime)
+    {
+        base.FrameUpdate(frameTime);
+
+        // increment the lifetime of completed explosions, and remove them if they have been ons screen for more
+        // than ExplosionPersistence seconds
+        foreach (var explosion in _overlay.CompletedExplosions.ToArray())
+        {
+            explosion.Lifetime += frameTime;
+
+            if (explosion.Lifetime >= ExplosionPersistence)
+            {
+                EntityManager.QueueDeleteEntity(explosion.LightEntity);
+                _overlay.CompletedExplosions.Remove(explosion);
+            }
+        }
+    }
+
+    /// <summary>
+    ///     The server has processed some explosion. This updates the client-side overlay so that the area covered
+    ///     by the fire-visual matches up with the area that the explosion has affected.
+    /// </summary>
+    private void HandleExplosionUpdate(ExplosionOverlayUpdateEvent args)
+    {
+        if (args.ExplosionId != _overlay.ActiveExplosion?.Explosionid && !IsNewer(args.ExplosionId))
+        {
+            // out of order events. Ignore.
+            return;
+        }
+
+        _overlay.Index = args.Index;
+
+        if (_overlay.ActiveExplosion == null)
+        {
+            // no active explosion... events out of order?
+            return;
+        }
+
+        if (args.Index != int.MaxValue)
+            return;
+
+        // the explosion has finished expanding
+        _overlay.Index = 0;
+        _overlay.CompletedExplosions.Add(_overlay.ActiveExplosion);
+        _overlay.ActiveExplosion = null;
+    }
+
+    /// <summary>
+    ///     A new explosion occurred. This prepares the client-side light entity and stores the
+    ///     explosion/fire-effect overlay data.
+    /// </summary>
+    private void OnExplosion(ExplosionEvent args)
+    {
+        if (!_protoMan.TryIndex(args.TypeID, out ExplosionPrototype? type))
+            return;
+
+        // spawn in a light source at the epicenter
+        var lightEntity = Spawn("ExplosionLight", args.Epicenter);
+        var light = EnsureComp<PointLightComponent>(lightEntity);
+        light.Energy = light.Radius = args.Intensity.Count;
+        light.Color = type.LightColor;
+
+        if (_overlay.ActiveExplosion == null)
+        {
+            _overlay.ActiveExplosion = new(args, type, lightEntity);
+            return;
+        }
+
+        // we have a currently active explosion. Can happen when events are received out of order. either multiple
+        // explosions are happening in one tick, or a new explosion was received before the event telling us the old one
+        // finished got through.
+
+        if (IsNewer(args.ExplosionId))
+        {
+            // This is a newer explosion. Add the old-currently-active explosions to the completed list
+            _overlay.CompletedExplosions.Add(_overlay.ActiveExplosion);
+            _overlay.ActiveExplosion = new(args, type, lightEntity);
+        }
+        else
+        {
+            // explosions were out of order. keep the active one, and directly add the received one to the completed
+            // list.
+            _overlay.CompletedExplosions.Add(new(args, type, lightEntity));
+            return;
+        }
+    }
+
+    public bool IsNewer(byte explosionId)
+    {
+        if (_overlay.ActiveExplosion == null)
+            return true;
+
+        // byte goes up to 255, then wraps back to zero.
+        // what are the odds of more than 128 explosions happening in a tick?
+        return _overlay.ActiveExplosion.Explosionid < explosionId
+            || _overlay.ActiveExplosion.Explosionid > 192 && explosionId < 64;
+    }
+
+    public override void Shutdown()
+    {
+        base.Shutdown();
+
+        var overlayManager = IoCManager.Resolve<IOverlayManager>();
+        if (overlayManager.HasOverlay<ExplosionOverlay>())
+            overlayManager.RemoveOverlay<ExplosionOverlay>();
+    }
+}
+
+internal sealed class Explosion
+{
+    public Dictionary<int, List<Vector2i>>? SpaceTiles;
+    public Dictionary<GridId, Dictionary<int, List<Vector2i>>> Tiles;
+    public List<float> Intensity;
+    public EntityUid LightEntity;
+    public MapId Map;
+    public byte Explosionid;
+
+    public Matrix3 SpaceMatrix;
+
+    /// <summary>
+    ///     How long have we been drawing this explosion, starting from the time the explosion was fully drawn.
+    /// </summary>
+    public float Lifetime;
+
+    /// <summary>
+    ///     The textures used for the explosion fire effect. Each fire-state is associated with an explosion
+    ///     intensity range, and each stat itself has several textures.
+    /// </summary>
+    public List<Texture[]> FireFrames = new();
+
+    public Color? FireColor;
+
+    internal Explosion(ExplosionEvent args, ExplosionPrototype type, EntityUid lightEntity)
+    {
+        Map = args.Epicenter.MapId;
+        SpaceTiles = args.SpaceTiles;
+        Tiles = args.Tiles;
+        Intensity = args.Intensity;
+        SpaceMatrix = args.SpaceMatrix;
+        Explosionid = args.ExplosionId;
+        FireColor = type.FireColor;
+        LightEntity = lightEntity;
+
+        var fireRsi = IoCManager.Resolve<IResourceCache>().GetResource<RSIResource>(type.TexturePath).RSI;
+        foreach (var state in fireRsi)
+        {
+            FireFrames.Add(state.GetFrames(RSI.State.Direction.South));
+            if (FireFrames.Count == type.FireStates)
+                break;
+        }
+    }
+}
diff --git a/Content.Server/AME/AMENodeGroup.cs b/Content.Server/AME/AMENodeGroup.cs
index 8c22be06fd..c434c1eb52 100644
--- a/Content.Server/AME/AMENodeGroup.cs
+++ b/Content.Server/AME/AMENodeGroup.cs
@@ -162,22 +162,21 @@ namespace Content.Server.AME
         {
             if(_cores.Count < 1 || MasterController == null) { return; }
 
-            var intensity = 0;
+            float radius = 0;
 
             /*
              * todo: add an exact to the shielding and make this find the core closest to the controller
              * so they chain explode, after helpers have been added to make it not cancer
             */
-            var epicenter = _cores.First();
 
             foreach (AMEShieldComponent core in _cores)
             {
-                intensity += MasterController.InjectionAmount;
+                radius += MasterController.InjectionAmount;
             }
 
-            intensity = Math.Min(intensity, 8);
-
-            EntitySystem.Get<ExplosionSystem>().SpawnExplosion(epicenter.Owner, intensity / 2, intensity, intensity * 2, intensity * 3);
+            radius *= 2;
+            radius = Math.Min(radius, 8);
+            EntitySystem.Get<ExplosionSystem>().TriggerExplosive(MasterController.Owner, radius: radius, delete: false);
         }
     }
 }
diff --git a/Content.Server/Administration/AdminVerbSystem.cs b/Content.Server/Administration/AdminVerbSystem.cs
index 4c975847ae..f388ff5e75 100644
--- a/Content.Server/Administration/AdminVerbSystem.cs
+++ b/Content.Server/Administration/AdminVerbSystem.cs
@@ -47,7 +47,7 @@ namespace Content.Server.Administration
         [Dependency] private readonly IAdminManager _adminManager = default!;
         [Dependency] private readonly IGameTiming _gameTiming = default!;
         [Dependency] private readonly EuiManager _euiManager = default!;
-        [Dependency] private readonly ExplosionSystem _explosions = default!;
+        [Dependency] private readonly ExplosionSystem _explosionSystem = default!;
         [Dependency] private readonly GhostRoleSystem _ghostRoleSystem = default!;
         [Dependency] private readonly ArtifactSystem _artifactSystem = default!;
 
@@ -155,8 +155,8 @@ namespace Content.Server.Administration
                 verb.Category = VerbCategory.Admin;
                 verb.Act = () =>
                 {
-                    var coords = Transform(args.Target).Coordinates;
-                    Timer.Spawn(_gameTiming.TickPeriod, () => _explosions.SpawnExplosion(coords, 0, 1, 2, 1), CancellationToken.None);
+                    var coords = Transform(args.Target).MapPosition;
+                    Timer.Spawn(_gameTiming.TickPeriod, () => _explosionSystem.QueueExplosion(coords, "Default", 30, 4, 8), CancellationToken.None);
                     if (TryComp(args.Target, out SharedBodyComponent? body))
                     {
                         body.Gib();
diff --git a/Content.Server/Administration/Commands/ExplosionCommand.cs b/Content.Server/Administration/Commands/ExplosionCommand.cs
index 6e94dc4030..a72c055deb 100644
--- a/Content.Server/Administration/Commands/ExplosionCommand.cs
+++ b/Content.Server/Administration/Commands/ExplosionCommand.cs
@@ -1,42 +1,134 @@
+using Content.Server.Administration.UI;
+using Content.Server.EUI;
 using Content.Server.Explosion.EntitySystems;
 using Content.Shared.Administration;
+using Content.Shared.Explosion;
 using Robust.Server.Player;
 using Robust.Shared.Console;
-using Robust.Shared.GameObjects;
-using Robust.Shared.IoC;
 using Robust.Shared.Map;
+using Robust.Shared.Prototypes;
+using System.Linq;
 
-namespace Content.Server.Administration.Commands
+namespace Content.Server.Administration.Commands;
+
+[AdminCommand(AdminFlags.Fun)]
+public sealed class OpenExplosionEui : IConsoleCommand
 {
-    [AdminCommand(AdminFlags.Fun)]
-    public sealed class ExplosionCommand : IConsoleCommand
-    {
-        public string Command => "explode";
-        public string Description => "Train go boom";
-        public string Help => "Usage: explode <x> <y> <dev> <heavy> <light> <flash>\n" +
-                              "The explosion happens on the same map as the user.";
+    public string Command => "explosionui";
+    public string Description => "Opens a window for easy access to station destruction";
+    public string Help => $"Usage: {Command}";
 
-        public void Execute(IConsoleShell shell, string argStr, string[] args)
+    public void Execute(IConsoleShell shell, string argStr, string[] args)
+    {
+        var player = shell.Player as IPlayerSession;
+        if (player == null)
         {
-            var player = shell.Player as IPlayerSession;
-            if (player?.AttachedEntity is not {Valid: true} playerEntity)
+            shell.WriteLine("This does not work from the server console.");
+            return;
+        }
+
+        var eui = IoCManager.Resolve<EuiManager>();
+        var ui = new SpawnExplosionEui();
+        eui.OpenEui(ui, player);
+    }
+}
+
+[AdminCommand(AdminFlags.Fun)] // for the admin. Not so much for anyone else.
+public sealed class ExplosionCommand : IConsoleCommand
+{
+    public string Command => "explosion";
+    public string Description => "Train go boom";
+
+    // Note that if you change the arguments, you should also update the client-side SpawnExplosionWindow, as that just
+    // uses this command.
+    public string Help => "Usage: explosion intensity [slope] [maxIntensity] [x y] [mapId] [prototypeId]";
+
+    public void Execute(IConsoleShell shell, string argStr, string[] args)
+    {
+        if (args.Length == 0 || args.Length == 4 || args.Length > 7)
+        {
+            shell.WriteLine("Wrong number of arguments.");
+            return;
+        }
+
+        if (!float.TryParse(args[0], out var intensity))
+        {
+            shell.WriteLine($"Failed to parse intensity: {args[0]}");
+            return;
+        }
+ 
+        float slope = 5;
+        if (args.Length > 1 && !float.TryParse(args[1], out slope))
+        {
+            shell.WriteLine($"Failed to parse float: {args[1]}");
+            return;
+        }
+
+        float maxIntensity = 100;
+        if (args.Length > 2 && !float.TryParse(args[2], out maxIntensity))
+        {
+            shell.WriteLine($"Failed to parse float: {args[2]}");
+            return;
+        }
+
+        float x = 0, y = 0;
+        if (args.Length > 4)
+        {
+            if (!float.TryParse(args[3], out x) ||
+                !float.TryParse(args[4], out y))
             {
-                shell.WriteLine("You must have an attached entity.");
+                shell.WriteLine($"Failed to parse coordinates: {(args[3], args[4])}");
+                return;
+            }
+        }
+
+        MapCoordinates coords;
+        if (args.Length > 5)
+        {
+            if (!int.TryParse(args[5], out var parsed))
+            {
+                shell.WriteLine($"Failed to parse map ID: {args[5]}");
+                return;
+            }
+            coords = new MapCoordinates((x, y), new(parsed));
+        }
+        else
+        {
+            // attempt to find the player's current position
+            var entMan = IoCManager.Resolve<IEntityManager>();
+            if (!entMan.TryGetComponent(shell.Player?.AttachedEntity, out TransformComponent? xform))
+            {
+                shell.WriteLine($"Failed get default coordinates/map via player's transform. Need to specify explicitly.");
                 return;
             }
 
-            var x = float.Parse(args[0]);
-            var y = float.Parse(args[1]);
+            if (args.Length > 4)
+                coords = new MapCoordinates((x, y), xform.MapID);
+            else
+                coords = xform.MapPosition;
 
-            var dev = int.Parse(args[2]);
-            var hvy = int.Parse(args[3]);
-            var lgh = int.Parse(args[4]);
-            var fla = int.Parse(args[5]);
-
-            var mapTransform = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(playerEntity).GetMapTransform();
-            var coords = new EntityCoordinates(mapTransform.Owner, x, y);
-
-            EntitySystem.Get<ExplosionSystem>().SpawnExplosion(coords, dev, hvy, lgh, fla);
         }
+
+        ExplosionPrototype? type;
+        var protoMan = IoCManager.Resolve<IPrototypeManager>();
+        if (args.Length > 6)
+        {
+            if (!protoMan.TryIndex(args[6], out type))
+            {
+                shell.WriteLine($"Unknown explosion prototype: {args[6]}");
+                return;
+            }
+        }
+        else
+        {
+            // no prototype was specified, so lets default to whichever one was defined first
+            var types = protoMan.EnumeratePrototypes<ExplosionPrototype>();
+            if (!types.Any())
+                return;
+
+            type = types.First();
+        }
+
+        EntitySystem.Get<ExplosionSystem>().QueueExplosion(coords, type.ID, intensity, slope, maxIntensity);
     }
 }
diff --git a/Content.Server/Administration/UI/SpawnExplosionEui.cs b/Content.Server/Administration/UI/SpawnExplosionEui.cs
new file mode 100644
index 0000000000..e2c1626b23
--- /dev/null
+++ b/Content.Server/Administration/UI/SpawnExplosionEui.cs
@@ -0,0 +1,39 @@
+using Content.Server.EUI;
+using Content.Server.Explosion.EntitySystems;
+using Content.Shared.Administration;
+using Content.Shared.Eui;
+using JetBrains.Annotations;
+
+namespace Content.Server.Administration.UI;
+
+/// <summary>
+///     Admin Eui for spawning and preview-ing explosions
+/// </summary>
+[UsedImplicitly]
+public sealed class SpawnExplosionEui : BaseEui
+{
+    public override void HandleMessage(EuiMessageBase msg)
+    {
+        if (msg is SpawnExplosionEuiMsg.Close)
+        {
+            Close();
+            return;
+        }
+
+        if (msg is not SpawnExplosionEuiMsg.PreviewRequest request)
+            return;
+
+        if (request.TotalIntensity <= 0 || request.IntensitySlope <= 0)
+            return;
+
+        var explosion = EntitySystem.Get<ExplosionSystem>().GenerateExplosionPreview(request);
+
+        if (explosion == null)
+        {
+            Logger.Error("Failed to generate explosion preview.");
+            return;
+        }
+
+        SendMessage(new SpawnExplosionEuiMsg.PreviewData(explosion, request.IntensitySlope, request.TotalIntensity));
+    }
+}
diff --git a/Content.Server/Atmos/Components/GasTankComponent.cs b/Content.Server/Atmos/Components/GasTankComponent.cs
index c4b042a261..1a3986bc25 100644
--- a/Content.Server/Atmos/Components/GasTankComponent.cs
+++ b/Content.Server/Atmos/Components/GasTankComponent.cs
@@ -245,14 +245,14 @@ namespace Content.Server.Atmos.Components
                 var range = (pressure - TankFragmentPressure) / TankFragmentScale;
 
                 // Let's cap the explosion, yeah?
+                // !1984
                 if (range > MaxExplosionRange)
                 {
                     range = MaxExplosionRange;
                 }
 
-                EntitySystem.Get<ExplosionSystem>().SpawnExplosion(Owner, (int) (range * 0.25f), (int) (range * 0.5f), (int) (range * 1.5f), 1);
+                EntitySystem.Get<ExplosionSystem>().TriggerExplosive(Owner, radius: range);
 
-                _entMan.QueueDeleteEntity(Owner);
                 return;
             }
 
diff --git a/Content.Server/Atmos/EntitySystems/AirtightSystem.cs b/Content.Server/Atmos/EntitySystems/AirtightSystem.cs
index db2f173bbf..89792aa5e0 100644
--- a/Content.Server/Atmos/EntitySystems/AirtightSystem.cs
+++ b/Content.Server/Atmos/EntitySystems/AirtightSystem.cs
@@ -1,4 +1,5 @@
 using Content.Server.Atmos.Components;
+using Content.Server.Explosion.EntitySystems;
 using Content.Server.Kudzu;
 using Content.Shared.Atmos;
 using JetBrains.Annotations;
@@ -14,6 +15,7 @@ namespace Content.Server.Atmos.EntitySystems
     {
         [Dependency] private readonly IMapManager _mapManager = default!;
         [Dependency] private readonly AtmosphereSystem _atmosphereSystem = default!;
+        [Dependency] private readonly ExplosionSystem _explosionSystem = default!;
 
         public override void Initialize()
         {
@@ -104,6 +106,7 @@ namespace Content.Server.Atmos.EntitySystems
             if (!gridId.IsValid())
                 return;
 
+            _explosionSystem.UpdateAirtightMap(gridId, pos);
             _atmosphereSystem.UpdateAdjacent(gridId, pos);
             _atmosphereSystem.InvalidateTile(gridId, pos);
 
diff --git a/Content.Server/Chemistry/ReactionEffects/ExplosionReactionEffect.cs b/Content.Server/Chemistry/ReactionEffects/ExplosionReactionEffect.cs
index 4416f74dfc..65cb6e542f 100644
--- a/Content.Server/Chemistry/ReactionEffects/ExplosionReactionEffect.cs
+++ b/Content.Server/Chemistry/ReactionEffects/ExplosionReactionEffect.cs
@@ -1,78 +1,68 @@
-using System;
 using System.Text.Json.Serialization;
-using Content.Server.Chemistry.Components.SolutionManager;
 using Content.Server.Explosion.EntitySystems;
-using Content.Shared.Administration.Logs;
 using Content.Shared.Chemistry.Reagent;
 using Content.Shared.Database;
-using Robust.Shared.GameObjects;
-using Robust.Shared.Serialization.Manager.Attributes;
+using Content.Shared.Explosion;
+using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom.Prototype;
 
 namespace Content.Server.Chemistry.ReactionEffects
 {
     [DataDefinition]
-    public sealed class ExplosionReactionEffect : ReagentEffect
+    public class ExplosionReactionEffect : ReagentEffect
     {
-        [DataField("devastationRange")]
+        /// <summary>
+        ///     The type of explosion. Determines damage types and tile break chance scaling.
+        /// </summary>
+        [DataField("explosionType", required: true, customTypeSerializer: typeof(PrototypeIdSerializer<ExplosionPrototype>))]
         [JsonIgnore]
-        private float _devastationRange = 1;
-
-        [DataField("heavyImpactRange")]
-        [JsonIgnore]
-        private float _heavyImpactRange = 2;
-
-        [DataField("lightImpactRange")]
-        [JsonIgnore]
-        private float _lightImpactRange = 3;
-
-        [DataField("flashRange")]
-        [JsonIgnore]
-        private float _flashRange;
+        public string ExplosionType = default!;
 
         /// <summary>
-        /// If true, then scale ranges by intensity. If not, the ranges are the same regardless of reactant amount.
+        ///     The max intensity the explosion can have at a given tile. Places an upper limit of damage and tile break
+        ///     chance.
         /// </summary>
-        [DataField("scaled")]
+        [DataField("maxIntensity")]
         [JsonIgnore]
-        private bool _scaled;
+        public float MaxIntensity = 5;
+        
+        /// <summary>
+        ///     How quickly intensity drops off as you move away from the epicenter
+        /// </summary>
+        [DataField("intensitySlope")]
+        [JsonIgnore]
+        public float IntensitySlope = 1;
 
         /// <summary>
-        /// Maximum scaling on ranges. For example, if it equals 5, then it won't scaled anywhere past
-        /// 5 times the minimum reactant amount.
+        ///     The maximum total intensity that this chemical reaction can achieve. Basically here to prevent people
+        ///     from creating a nuke by collecting enough potassium and water.
         /// </summary>
-        [DataField("maxScale")]
+        /// <remarks>
+        ///     A slope of 1 and MaxTotalIntensity of 100 corresponds to a radius of around 4.5 tiles.
+        /// </remarks>
+        [DataField("maxTotalIntensity")]
         [JsonIgnore]
-        private float _maxScale = 1;
+        public float MaxTotalIntensity = 100;
+
+        /// <summary>
+        ///     The intensity of the explosion per unit reaction.
+        /// </summary>
+        [DataField("intensityPerUnit")]
+        [JsonIgnore]
+        public float IntensityPerUnit = 1;
 
         public override bool ShouldLog => true;
         public override LogImpact LogImpact => LogImpact.High;
 
         public override void Effect(ReagentEffectArgs args)
         {
-            var floatIntensity = (float) args.Quantity;
+            var intensity = MathF.Min((float) args.Quantity * IntensityPerUnit, MaxTotalIntensity);
 
-            if (!args.EntityManager.HasComponent<SolutionContainerManagerComponent>(args.SolutionEntity))
-                return;
-
-            //Handle scaling
-            if (_scaled)
-            {
-                floatIntensity = MathF.Min(floatIntensity, _maxScale);
-            }
-            else
-            {
-                floatIntensity = 1;
-            }
-
-            //Calculate intensities
-            var finalDevastationRange = (int)MathF.Round(_devastationRange * floatIntensity);
-            var finalHeavyImpactRange = (int)MathF.Round(_heavyImpactRange * floatIntensity);
-            var finalLightImpactRange = (int)MathF.Round(_lightImpactRange * floatIntensity);
-            var finalFlashRange = (int)MathF.Round(_flashRange * floatIntensity);
-            EntitySystem.Get<ExplosionSystem>().SpawnExplosion(args.SolutionEntity, finalDevastationRange,
-                finalHeavyImpactRange, finalLightImpactRange, finalFlashRange);
+            EntitySystem.Get<ExplosionSystem>().QueueExplosion(
+                args.SolutionEntity,
+                ExplosionType,
+                intensity,
+                IntensitySlope,
+                MaxIntensity);
         }
     }
 }
-
-
diff --git a/Content.Server/Destructible/DestructibleSystem.cs b/Content.Server/Destructible/DestructibleSystem.cs
index ed4c91775f..868a5ac5f7 100644
--- a/Content.Server/Destructible/DestructibleSystem.cs
+++ b/Content.Server/Destructible/DestructibleSystem.cs
@@ -1,13 +1,17 @@
 using Content.Server.Construction;
 using Content.Server.Destructible.Thresholds;
+using Content.Server.Destructible.Thresholds.Behaviors;
+using Content.Server.Destructible.Thresholds.Triggers;
 using Content.Server.Explosion.EntitySystems;
 using Content.Server.Stack;
 using Content.Shared.Acts;
 using Content.Shared.Damage;
+using Content.Shared.FixedPoint;
 using JetBrains.Annotations;
 using Robust.Server.GameObjects;
 using Robust.Shared.Prototypes;
 using Robust.Shared.Random;
+using System;
 
 namespace Content.Server.Destructible
 {
@@ -50,6 +54,40 @@ namespace Content.Server.Destructible
                     return;
             }
         }
+
+        // FFS this shouldn't be this hard. Maybe this should just be a field of the destructible component. Its not
+        // like there is currently any entity that is NOT just destroyed upon reaching a total-damage value.
+        /// <summary>
+        ///     Figure out how much damage an entity needs to have in order to be destroyed.
+        /// </summary>
+        /// <remarks>
+        ///     This assumes that this entity has some sort of destruction or breakage behavior triggered by a
+        ///     total-damage threshold.
+        /// </remarks>
+        public FixedPoint2 DestroyedAt(EntityUid uid, DestructibleComponent? destructible = null)
+        {
+            if (!Resolve(uid, ref destructible, logMissing: false))
+                return FixedPoint2.MaxValue;
+
+            // We have nested for loops here, but the vast majority of components only have one threshold with 1-3 behaviors.
+            // Really, this should probably just be a property of the damageable component.
+            var damageNeeded = FixedPoint2.MaxValue;
+            foreach (var threshold in destructible.Thresholds)
+            {
+                if (threshold.Trigger is not DamageTrigger trigger)
+                    continue;
+
+                foreach (var behavior in threshold.Behaviors)
+                {
+                    if (behavior is DoActsBehavior actBehavior &&
+                        actBehavior.HasAct(ThresholdActs.Destruction | ThresholdActs.Breakage))
+                    {
+                        damageNeeded = Math.Min(damageNeeded.Float(), trigger.Damage);
+                    }
+                }
+            }
+            return damageNeeded;
+        }
     }
 
     // Currently only used for destructible integration tests. Unless other uses are found for this, maybe this should just be removed and the tests redone.
diff --git a/Content.Server/Destructible/Thresholds/Behaviors/ExplodeBehavior.cs b/Content.Server/Destructible/Thresholds/Behaviors/ExplodeBehavior.cs
index c850aebc7b..02d817144e 100644
--- a/Content.Server/Destructible/Thresholds/Behaviors/ExplodeBehavior.cs
+++ b/Content.Server/Destructible/Thresholds/Behaviors/ExplodeBehavior.cs
@@ -14,7 +14,7 @@ namespace Content.Server.Destructible.Thresholds.Behaviors
     {
         public void Execute(EntityUid owner, DestructibleSystem system)
         {
-            system.ExplosionSystem.SpawnExplosion(owner);
+            system.ExplosionSystem.TriggerExplosive(owner);
         }
     }
 }
diff --git a/Content.Server/Explosion/Components/ExplosionLaunchedComponent.cs b/Content.Server/Explosion/Components/ExplosionLaunchedComponent.cs
index b760ce1341..e2e204131d 100644
--- a/Content.Server/Explosion/Components/ExplosionLaunchedComponent.cs
+++ b/Content.Server/Explosion/Components/ExplosionLaunchedComponent.cs
@@ -1,40 +1,8 @@
-using Content.Server.Throwing;
-using Content.Shared.Acts;
-using Robust.Shared.GameObjects;
-using Robust.Shared.IoC;
-using Robust.Shared.Maths;
 
-namespace Content.Server.Explosion.Components
+namespace Content.Server.Explosion.Components;
+
+// TODO EXPLOSION make this a tag? or just get rid of it and launch all unanchored physics entities?
+[RegisterComponent]
+public sealed class ExplosionLaunchedComponent : Component
 {
-    [RegisterComponent]
-    public sealed class ExplosionLaunchedComponent : Component, IExAct
-    {
-        [Dependency] private readonly IEntityManager _entMan = default!;
-        void IExAct.OnExplosion(ExplosionEventArgs eventArgs)
-        {
-            if (_entMan.Deleted(Owner))
-                return;
-
-            var sourceLocation = eventArgs.Source;
-            var targetLocation = _entMan.GetComponent<TransformComponent>(eventArgs.Target).Coordinates;
-
-            if (sourceLocation.Equals(targetLocation)) return;
-
-            var offset = (targetLocation.ToMapPos(_entMan) - sourceLocation.ToMapPos(_entMan));
-
-            //Don't throw if the direction is center (0,0)
-            if (offset == Vector2.Zero) return;
-
-            var direction = offset.Normalized;
-
-            var throwForce = eventArgs.Severity switch
-            {
-                ExplosionSeverity.Heavy => 30,
-                ExplosionSeverity.Light => 20,
-                _ => 0,
-            };
-
-            Owner.TryThrow(direction, throwForce);
-        }
-    }
 }
diff --git a/Content.Server/Explosion/Components/ExplosionResistanceComponent.cs b/Content.Server/Explosion/Components/ExplosionResistanceComponent.cs
new file mode 100644
index 0000000000..1a3f700eab
--- /dev/null
+++ b/Content.Server/Explosion/Components/ExplosionResistanceComponent.cs
@@ -0,0 +1,30 @@
+using Content.Server.Explosion.EntitySystems;
+using Content.Shared.Explosion;
+using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom.Prototype.Dictionary;
+
+namespace Content.Server.Explosion.Components;
+
+/// <summary>
+///     Component that provides entities with explosion resistance.
+/// </summary>
+/// <remarks>
+///     This is desirable over just using damage modifier sets, given that equipment like bomb-suits need to
+///     significantly reduce the damage, but shouldn't be silly overpowered in regular combat.
+/// </remarks>
+[RegisterComponent]
+[Friend(typeof(ExplosionSystem))]
+public sealed class ExplosionResistanceComponent : Component
+{
+    /// <summary>
+    ///     The resistance values for this component, This fraction is added to the total resistance.
+    /// </summary>
+    [DataField("resistance")]
+    public float GlobalResistance = 0;
+
+    /// <summary>
+    ///     Like <see cref="GlobalResistance"/>, but specified specific to each explosion type for more customizability.
+    /// </summary>
+    [ViewVariables(VVAccess.ReadWrite)]
+    [DataField("resistances", customTypeSerializer: typeof(PrototypeIdDictionarySerializer<float, ExplosionPrototype>))]
+    public Dictionary<string, float> Resistances = new();
+}
diff --git a/Content.Server/Explosion/Components/ExplosiveComponent.cs b/Content.Server/Explosion/Components/ExplosiveComponent.cs
index a8f98ff685..7ca715fb86 100644
--- a/Content.Server/Explosion/Components/ExplosiveComponent.cs
+++ b/Content.Server/Explosion/Components/ExplosiveComponent.cs
@@ -1,34 +1,59 @@
-using Content.Server.Chemistry.ReactionEffects;
-using Content.Server.Destructible.Thresholds.Behaviors;
-using Robust.Shared.GameObjects;
-using Robust.Shared.Serialization.Manager.Attributes;
+using Content.Server.Explosion.EntitySystems;
+using Content.Shared.Explosion;
+using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom.Prototype;
 
-namespace Content.Server.Explosion.Components
+namespace Content.Server.Explosion.Components;
+
+/// <summary>
+///     Specifies an explosion that can be spawned by this entity. The explosion itself is spawned via <see
+///     cref="ExplosionSystem.TriggerExplosive"/>.
+/// </summary>
+/// <remarks>
+///      The total intensity may be overridden by whatever system actually calls TriggerExplosive(), but this
+///      component still determines the explosion type and other properties.
+/// </remarks>
+[RegisterComponent]
+public sealed class ExplosiveComponent : Component
 {
+    public override string Name => "Explosive";
+
     /// <summary>
-    ///     Specifies an explosion range should this entity be exploded.
+    ///     The explosion prototype. This determines the damage types, the tile-break chance, and some visual
+    ///     information (e.g., the light that the explosion gives off).
+    /// </summary>
+    [ViewVariables(VVAccess.ReadWrite)]
+    [DataField("explosionType", required: true, customTypeSerializer: typeof(PrototypeIdSerializer<ExplosionPrototype>))]
+    public string ExplosionType = default!;
+
+    /// <summary>
+    ///     The maximum intensity the explosion can have on a single time. This limits the maximum damage and tile
+    ///     break chance the explosion can achieve at any given location.
+    /// </summary>
+    [ViewVariables(VVAccess.ReadWrite)]
+    [DataField("maxIntensity")]
+    public float MaxIntensity = 4;
+
+    /// <summary>
+    ///     How quickly the intensity drops off as you move away from the epicenter.
+    /// </summary>
+    [ViewVariables(VVAccess.ReadWrite)]
+    [DataField("intensitySlope")]
+    public float IntensitySlope = 1;
+
+    /// <summary>
+    ///     The total intensity of this explosion. The radius of the explosion scales like the cube root of this
+    ///     number (see <see cref="ExplosionSystem.RadiusToIntensity"/>).
     /// </summary>
     /// <remarks>
-    ///     Explosions can be caused by:
-    ///     <list type="bullet">
-    ///         <item>Reaching a damage threshold that causes a <see cref="ExplodeBehavior"/></item>
-    ///         <item>Being triggered via the <see cref="ExplodeOnTriggerComponent"/></item>
-    ///         <item>Manually by some other system via functions in <see cref="ExplosionHelper"/> (for example, chemistry's
-    ///         <see cref="ExplosionReactionEffect"/>).</item>
-    ///     </list>
+    ///     This number can be overridden by passing optional argument to <see
+    ///     cref="ExplosionSystem.TriggerExplosive"/>.
     /// </remarks>
-    [RegisterComponent]
-    public sealed class ExplosiveComponent : Component
-    {
-        [DataField("devastationRange")]
-        public int DevastationRange;
-        [DataField("heavyImpactRange")]
-        public int HeavyImpactRange;
-        [DataField("lightImpactRange")]
-        public int LightImpactRange;
-        [DataField("flashRange")]
-        public int FlashRange;
+    [ViewVariables(VVAccess.ReadWrite)]
+    [DataField("totalIntensity")]
+    public float TotalIntensity = 10;
 
-        public bool Exploding { get; set; } = false;
-    }
+    /// <summary>
+    ///     Avoid somehow double-triggering this explosion (e.g. by damaging this entity from it's own explosion.
+    /// </summary>
+    public bool Exploded;
 }
diff --git a/Content.Server/Explosion/EntitySystems/ExplosionSystem.Airtight.cs b/Content.Server/Explosion/EntitySystems/ExplosionSystem.Airtight.cs
new file mode 100644
index 0000000000..0aae00a223
--- /dev/null
+++ b/Content.Server/Explosion/EntitySystems/ExplosionSystem.Airtight.cs
@@ -0,0 +1,141 @@
+using Content.Server.Atmos.Components;
+using Content.Server.Destructible;
+using Content.Shared.Atmos;
+using Content.Shared.Damage;
+using Content.Shared.Explosion;
+using Content.Shared.FixedPoint;
+using Robust.Shared.Map;
+
+namespace Content.Server.Explosion.EntitySystems;
+
+public sealed partial class ExplosionSystem : EntitySystem
+{
+    [Dependency] private readonly DestructibleSystem _destructibleSystem = default!;
+
+    // The explosion intensity required to break an entity depends on the explosion type. So it is stored in a
+    // Dictionary<string, float>
+    //
+    // Hence, each tile has a tuple (Dictionary<string, float>, AtmosDirection). This specifies what directions are
+    // blocked, and how intense a given explosion type needs to be in order to destroy ALL airtight entities on that
+    // tile. This is the TileData struct.
+    //
+    // We then need this data for every tile on a grid. So this mess of a variable maps the Grid ID and Vector2i grid
+    // indices to this tile-data struct.
+    private Dictionary<GridId, Dictionary<Vector2i, TileData>> _airtightMap = new();
+
+    public void UpdateAirtightMap(GridId gridId, Vector2i tile)
+    {
+        if (_mapManager.TryGetGrid(gridId, out var grid))
+            UpdateAirtightMap(grid, tile);
+    }
+
+    /// <summary>
+    ///     Update the map of explosion blockers.
+    /// </summary>
+    /// <remarks>
+    ///     Gets a list of all airtight entities on a tile. Assembles a <see cref="AtmosDirection"/> that specifies
+    ///     what directions are blocked, along with the largest explosion tolerance. Note that as we only keep track
+    ///     of the largest tolerance, this means that the explosion map will actually be inaccurate if you have
+    ///     something like a normal and a reinforced windoor on the same tile. But given that this is a pretty rare
+    ///     occurrence, I am fine with this.
+    /// </remarks>
+    public void UpdateAirtightMap(IMapGrid grid, Vector2i tile)
+    {
+        Dictionary<string, float>  tolerance = new();
+        var blockedDirections = AtmosDirection.Invalid;
+
+        if (!_airtightMap.ContainsKey(grid.Index))
+            _airtightMap[grid.Index] = new();
+
+        foreach (var uid in grid.GetAnchoredEntities(tile))
+        {
+            if (!EntityManager.TryGetComponent(uid, out AirtightComponent? airtight) || !airtight.AirBlocked)
+                continue;
+
+            blockedDirections |= airtight.AirBlockedDirection;
+            foreach (var (type, value) in GetExplosionTolerance(uid))
+            {
+                if (!tolerance.TryAdd(type, value))
+                    tolerance[type] = Math.Max(tolerance[type], value);
+            }
+        }
+
+        if (blockedDirections != AtmosDirection.Invalid)
+            _airtightMap[grid.Index][tile] = new(tolerance, blockedDirections);
+        else
+            _airtightMap[grid.Index].Remove(tile);
+    }
+
+    /// <summary>
+    ///     On receiving damage, re-evaluate how much explosion damage is needed to destroy an airtight entity.
+    /// </summary>
+    private void OnAirtightDamaged(EntityUid uid, AirtightComponent airtight, DamageChangedEvent args)
+    {
+        // do we need to update our explosion blocking map?
+        if (!airtight.AirBlocked)
+            return;
+
+        if (!EntityManager.TryGetComponent(uid, out TransformComponent transform) || !transform.Anchored)
+            return;
+
+        if (!_mapManager.TryGetGrid(transform.GridID, out var grid))
+            return;
+
+        UpdateAirtightMap(grid, grid.CoordinatesToTile(transform.Coordinates));
+    }
+
+    /// <summary>
+    ///     Return a dictionary that specifies how intense a given explosion type needs to be in order to destroy an entity.
+    /// </summary>
+    public Dictionary<string, float> GetExplosionTolerance(EntityUid uid)
+    {
+        // How much total damage is needed to destroy this entity? This also includes "break" behaviors. This ASSUMES
+        // that this will result in a non-airtight entity.Entities that ONLY break via construction graph node changes
+        // are currently effectively "invincible" as far as this is concerned. This really should be done more rigorously.
+        var totalDamageTarget = _destructibleSystem.DestroyedAt(uid);
+
+        Dictionary<string, float> explosionTolerance = new();
+
+        if (totalDamageTarget == FixedPoint2.MaxValue || !TryComp(uid, out DamageableComponent? damageable))
+            return explosionTolerance;
+
+        // What multiple of each explosion type damage set will result in the damage exceeding the required amount? This
+        // does not support entities dynamically changing explosive resistances (e.g. via clothing). But these probably
+        // shouldn't be airtight structures anyways....
+
+        foreach (var explosionType in _prototypeManager.EnumeratePrototypes<ExplosionPrototype>())
+        {
+            // evaluate the damage that this damage type would do to this entity
+            var damagePerIntensity = FixedPoint2.Zero;
+            foreach (var (type, value) in explosionType.DamagePerIntensity.DamageDict)
+            {
+                if (!damageable.Damage.DamageDict.ContainsKey(type))
+                    continue;
+
+                var ev = new GetExplosionResistanceEvent(explosionType.ID);
+                RaiseLocalEvent(uid, ev, false);
+
+                damagePerIntensity += value * Math.Clamp(0, 1 - ev.Resistance, 1);
+            }
+
+            explosionTolerance[explosionType.ID] = (float) ((totalDamageTarget - damageable.TotalDamage) / damagePerIntensity);
+        }
+
+        return explosionTolerance;
+    }
+}
+
+/// <summary>
+///     Data struct that describes the explosion-blocking airtight entities on a tile.
+/// </summary>
+internal struct TileData
+{
+    public TileData(Dictionary<string, float> explosionTolerance, AtmosDirection blockedDirections)
+    {
+        ExplosionTolerance = explosionTolerance;
+        BlockedDirections = blockedDirections;
+    }
+
+    public Dictionary<string, float> ExplosionTolerance;
+    public AtmosDirection BlockedDirections = AtmosDirection.Invalid;
+}
diff --git a/Content.Server/Explosion/EntitySystems/ExplosionSystem.GridMap.cs b/Content.Server/Explosion/EntitySystems/ExplosionSystem.GridMap.cs
new file mode 100644
index 0000000000..83f5870e8f
--- /dev/null
+++ b/Content.Server/Explosion/EntitySystems/ExplosionSystem.GridMap.cs
@@ -0,0 +1,438 @@
+using Content.Shared.Atmos;
+using Robust.Shared.Map;
+
+namespace Content.Server.Explosion.EntitySystems;
+
+// This partial part of the explosion system has all of the functions used to facilitate explosions moving across grids.
+// A good portion of it is focused around keeping track of what tile-indices on a grid correspond to tiles that border
+// space. AFAIK no other system currently needs to track these "edge-tiles". If they do, this should probably be a
+// property of the grid itself?
+public sealed partial class ExplosionSystem : EntitySystem
+{
+    /// <summary>
+    ///     Set of tiles of each grid that are directly adjacent to space, along with the directions that face space.
+    /// </summary>
+    private Dictionary<GridId, Dictionary<Vector2i, AtmosDirection>> _gridEdges = new();
+
+    /// <summary>
+    ///     Set of tiles of each grid that are diagonally adjacent to space
+    /// </summary>
+    private Dictionary<GridId, HashSet<Vector2i>> _diagGridEdges = new();
+
+    /// <summary>
+    ///     On grid startup, prepare a map of grid edges.
+    /// </summary>
+    private void OnGridStartup(GridStartupEvent ev)
+    {
+        if (!_mapManager.TryGetGrid(ev.GridId, out var grid))
+            return;
+
+        Dictionary<Vector2i, AtmosDirection> edges = new();
+        HashSet<Vector2i> diagEdges = new();
+        _gridEdges[ev.GridId] = edges;
+        _diagGridEdges[ev.GridId] = diagEdges;
+
+        foreach (var tileRef in grid.GetAllTiles())
+        {
+            if (tileRef.Tile.IsEmpty)
+                continue;
+
+            if (IsEdge(grid, tileRef.GridIndices, out var dir))
+                edges.Add(tileRef.GridIndices, dir);
+            else if (IsDiagonalEdge(grid, tileRef.GridIndices))
+                diagEdges.Add(tileRef.GridIndices);
+        }
+    }
+
+    private void OnGridRemoved(GridRemovalEvent ev)
+    {
+        _airtightMap.Remove(ev.GridId);
+        _gridEdges.Remove(ev.GridId);
+        _diagGridEdges.Remove(ev.GridId);
+    }
+
+    /// <summary>
+    ///     Take our map of grid edges, where each is defined in their own grid's reference frame, and map those
+    ///     edges all onto one grids reference frame.
+    /// </summary>
+    public (Dictionary<Vector2i, GridBlockData>, ushort) TransformGridEdges(MapId targetMap, GridId? referenceGrid, List<GridId> localGrids)
+    {
+        Dictionary<Vector2i, GridBlockData> transformedEdges = new();
+
+        var targetMatrix = Matrix3.Identity;
+        Angle targetAngle = new();
+        ushort tileSize = DefaultTileSize;
+
+        // if the explosion is centered on some grid (and not just space), get the transforms.
+        if (referenceGrid != null)
+        {
+            var targetGrid = _mapManager.GetGrid(referenceGrid.Value);
+            var xform = Transform(targetGrid.GridEntityId);
+            targetAngle = xform.WorldRotation;
+            targetMatrix = xform.InvWorldMatrix;
+            tileSize = targetGrid.TileSize;
+        }
+
+        var offsetMatrix = Matrix3.Identity;
+        offsetMatrix.R0C2 = tileSize / 2;
+        offsetMatrix.R1C2 = tileSize / 2;
+
+        // here we will get a triple nested for loop:
+        // foreach other grid
+        //   foreach edge tile in that grid
+        //     foreach tile in our grid that touches that tile (vast majority of the time: 1 tile, but could be up to 4)
+
+        HashSet<Vector2i> transformedTiles = new();
+        foreach (var gridToTransform in localGrids)
+        {
+            // we treat the target grid separately
+            if (gridToTransform == referenceGrid)
+                continue;
+
+            if (!_gridEdges.TryGetValue(gridToTransform, out var edges))
+                continue;
+
+            if (!_mapManager.TryGetGrid(gridToTransform, out var grid) ||
+                grid.ParentMapId != targetMap)
+                continue;
+
+            if (grid.TileSize != tileSize)
+            {
+                Logger.Error($"Explosions do not support grids with different grid sizes. GridIds: {gridToTransform} and {referenceGrid}");
+                continue;
+            }
+
+            var xform = EntityManager.GetComponent<TransformComponent>(grid.GridEntityId);
+            var matrix = offsetMatrix * xform.WorldMatrix * targetMatrix;
+            var angle = xform.WorldRotation - targetAngle;
+
+            var (x, y) = angle.RotateVec((tileSize / 4, tileSize / 4));
+
+            foreach (var (tile, dir) in edges)
+            {
+                var center = matrix.Transform(tile);
+
+                // this tile might touch several other tiles, or maybe just one tile. Here we use a Vector2i HashSet to
+                // remove duplicates.
+                transformedTiles.Clear();
+                transformedTiles.Add(new((int) MathF.Floor(center.X + x), (int) MathF.Floor(center.Y + y)));  // initial direction
+                transformedTiles.Add(new((int) MathF.Floor(center.X - y), (int) MathF.Floor(center.Y + x)));  // rotated 90 degrees
+                transformedTiles.Add(new((int) MathF.Floor(center.X - x), (int) MathF.Floor(center.Y - y)));  // rotated 180 degrees
+                transformedTiles.Add(new((int) MathF.Floor(center.X + y), (int) MathF.Floor(center.Y - x)));  // rotated 270 degrees
+
+                foreach (var newIndices in transformedTiles)
+                {
+                    if (!transformedEdges.TryGetValue(newIndices, out var data))
+                    {
+                        data = new();
+                        transformedEdges[newIndices] = data;
+                    }
+                    data.BlockingGridEdges.Add(new(tile, gridToTransform, center, angle, tileSize));
+                }
+            }
+        }
+
+        // Next we transform any diagonal edges.
+        Vector2i newIndex;
+        foreach (var gridToTransform in localGrids)
+        {
+            // we treat the target grid separately
+            if (gridToTransform == referenceGrid)
+                continue;
+
+            if (!_diagGridEdges.TryGetValue(gridToTransform, out var diagEdges))
+                continue;
+
+            if (!_mapManager.TryGetGrid(gridToTransform, out var grid) ||
+                grid.ParentMapId != targetMap)
+                continue;
+
+            if (grid.TileSize != tileSize)
+            {
+                Logger.Error($"Explosions do not support grids with different grid sizes. GridIds: {gridToTransform} and {referenceGrid}");
+                continue;
+            }
+
+            var xform = EntityManager.GetComponent<TransformComponent>(grid.GridEntityId);
+            var matrix = offsetMatrix * xform.WorldMatrix * targetMatrix;
+            var angle = xform.WorldRotation - targetAngle;
+
+            foreach (var tile in diagEdges)
+            {
+                var center = matrix.Transform(tile);
+                newIndex = new((int) MathF.Floor(center.X), (int) MathF.Floor(center.Y));
+                if (!transformedEdges.TryGetValue(newIndex, out var data))
+                {
+                    data = new();
+                    transformedEdges[newIndex] = data;
+                }
+
+                // explosions are not allowed to propagate diagonally ONTO grids. so we just use defaults for some fields.
+                data.BlockingGridEdges.Add(new(default, null, center, angle, tileSize));
+            }
+        }
+
+        if (referenceGrid == null)
+            return (transformedEdges, tileSize);
+
+        // finally, we also include the blocking tiles from the reference grid.
+
+        if (_gridEdges.TryGetValue(referenceGrid.Value, out var localEdges))
+        {
+            foreach (var (tile, _) in localEdges)
+            {
+                // grids cannot overlap, so tile should NEVER be an existing entry.
+                var data = new GridBlockData();
+                transformedEdges[tile] = data;
+                
+                data.UnblockedDirections = AtmosDirection.Invalid; // all directions are blocked automatically.
+                data.BlockingGridEdges.Add(new(tile, referenceGrid.Value, ((Vector2) tile + 0.5f) * tileSize, 0, tileSize));
+            }
+        }
+
+        if (_diagGridEdges.TryGetValue(referenceGrid.Value, out var localDiagEdges))
+        {
+            foreach (var tile in localDiagEdges)
+            {
+
+                // grids cannot overlap, so tile should NEVER be an existing entry.
+                var data = new GridBlockData();
+                transformedEdges[tile] = data;
+
+                data.UnblockedDirections = AtmosDirection.Invalid; // all directions are blocked automatically.
+                data.BlockingGridEdges.Add(new(default, null, ((Vector2) tile + 0.5f) * tileSize, 0, tileSize));
+            }
+        }
+
+        return (transformedEdges, tileSize);
+    }
+
+    /// <summary>
+    ///     Given an grid-edge blocking map, check if the blockers are allowed to propagate to each other through gaps in grids.
+    /// </summary>
+    /// <remarks>
+    ///     After grid edges were transformed into the reference frame of some other grid, this function figures out
+    ///     which of those edges are actually blocking explosion propagation.
+    /// </remarks>
+    public void GetUnblockedDirections(Dictionary<Vector2i, GridBlockData> transformedEdges, ushort tileSize)
+    {
+        foreach (var (tile, data) in transformedEdges)
+        {
+            if (data.UnblockedDirections == AtmosDirection.Invalid)
+                continue; // already all blocked.
+
+            var tileCenter = ((Vector2) tile + 0.5f) * tileSize;
+            foreach (var edge in data.BlockingGridEdges)
+            {
+                // if a blocking edge contains the center of the tile, block all directions
+                if (edge.Box.Contains(tileCenter))
+                {
+                    data.UnblockedDirections = AtmosDirection.Invalid;
+                    break;
+                }
+
+                // check north
+                if (edge.Box.Contains(tileCenter + (0, tileSize / 2)))
+                    data.UnblockedDirections &= ~AtmosDirection.North;
+
+                // check south
+                if (edge.Box.Contains(tileCenter + (0, -tileSize / 2)))
+                    data.UnblockedDirections &= ~AtmosDirection.South;
+
+                // check east
+                if (edge.Box.Contains(tileCenter + (tileSize / 2, 0)))
+                    data.UnblockedDirections &= ~AtmosDirection.East;
+
+                // check west
+                if (edge.Box.Contains(tileCenter + (-tileSize / 2, 0)))
+                    data.UnblockedDirections &= ~AtmosDirection.West;
+            }
+        }
+    }
+
+    /// <summary>
+    ///     When a tile is updated, we might need to update the grid edge maps.
+    /// </summary>
+    private void OnTileChanged(object? sender, TileChangedEventArgs e)
+    {
+        // only need to update the grid-edge map if the tile changed from space to not-space.
+        if (!e.NewTile.Tile.IsEmpty && !e.OldTile.IsEmpty)
+            return;
+
+        var tileRef = e.NewTile;
+
+        if (!_mapManager.TryGetGrid(tileRef.GridIndex, out var grid))
+            return;
+
+        if (!_gridEdges.TryGetValue(tileRef.GridIndex, out var edges))
+        {
+            edges = new();
+            _gridEdges[tileRef.GridIndex] = edges;
+        }
+
+        if (!_diagGridEdges.TryGetValue(tileRef.GridIndex, out var diagEdges))
+        {
+            diagEdges = new();
+            _diagGridEdges[tileRef.GridIndex] = diagEdges;
+        }
+
+        if (tileRef.Tile.IsEmpty)
+        {
+            // if the tile is empty, it cannot itself be an edge tile.
+            edges.Remove(tileRef.GridIndices);
+            diagEdges.Remove(tileRef.GridIndices);
+
+            // add any valid neighbours to the list of edge-tiles
+            for (var i = 0; i < Atmospherics.Directions; i++)
+            {
+                var direction = (AtmosDirection) (1 << i);
+
+                var neighbourIndex = tileRef.GridIndices.Offset(direction);
+
+                if (grid.TryGetTileRef(neighbourIndex, out var neighbourTile) && !neighbourTile.Tile.IsEmpty)
+                {
+                    edges[neighbourIndex] = edges.GetValueOrDefault(neighbourIndex) | direction.GetOpposite();
+                    diagEdges.Remove(neighbourIndex);
+                }
+            }
+
+            foreach (var diagNeighbourIndex in GetDiagonalNeighbors(tileRef.GridIndices))
+            {
+                if (edges.ContainsKey(diagNeighbourIndex))
+                    continue;
+
+                if (grid.TryGetTileRef(diagNeighbourIndex, out var neighbourIndex) && !neighbourIndex.Tile.IsEmpty)
+                    diagEdges.Add(diagNeighbourIndex);
+            }
+
+            return;
+        }
+
+        // the tile is not empty space, but was previously. So update directly adjacent neighbours, which may no longer
+        // be edge tiles.
+        AtmosDirection spaceDir;
+        for (var i = 0; i < Atmospherics.Directions; i++)
+        {
+            var direction = (AtmosDirection) (1 << i);
+            var neighbourIndex = tileRef.GridIndices.Offset(direction);
+
+            if (edges.TryGetValue(neighbourIndex, out spaceDir))
+            {
+                spaceDir = spaceDir & ~direction.GetOpposite();
+                if (spaceDir != AtmosDirection.Invalid)
+                    edges[neighbourIndex] = spaceDir;
+                else
+                {
+                    // no longer a direct edge ...
+                    edges.Remove(neighbourIndex);
+
+                    // ... but it could now be a diagonal edge
+                    if (IsDiagonalEdge(grid, neighbourIndex, tileRef.GridIndices))
+                        diagEdges.Add(neighbourIndex);
+                }
+            }
+        }
+
+        // and again for diagonal neighbours
+        foreach (var neighborIndex in GetDiagonalNeighbors(tileRef.GridIndices))
+        {
+            if (diagEdges.Contains(neighborIndex) && !IsDiagonalEdge(grid, neighborIndex, tileRef.GridIndices))
+                diagEdges.Remove(neighborIndex);
+        }
+
+        // finally check if the new tile is itself an edge tile
+        if (IsEdge(grid, tileRef.GridIndices, out spaceDir))
+            edges.Add(tileRef.GridIndices, spaceDir);
+        else if (IsDiagonalEdge(grid, tileRef.GridIndices))
+            diagEdges.Add(tileRef.GridIndices);
+    }
+
+    /// <summary>
+    ///     Check whether a tile is on the edge of a grid (i.e., whether it borders space).
+    /// </summary>
+    /// <remarks>
+    ///     Optionally ignore a specific Vector2i. Used by <see cref="OnTileChanged"/> when we already know that a
+    ///     given tile is not space. This avoids unnecessary TryGetTileRef calls.
+    /// </remarks>
+    private bool IsEdge(IMapGrid grid, Vector2i index, out AtmosDirection spaceDirections)
+    {
+        spaceDirections = AtmosDirection.Invalid;
+        for (var i = 0; i < Atmospherics.Directions; i++)
+        {
+            var direction = (AtmosDirection) (1 << i);
+
+            if (!grid.TryGetTileRef(index.Offset(direction), out var neighborTile) || neighborTile.Tile.IsEmpty)
+                spaceDirections |= direction;
+        }
+
+        return spaceDirections != AtmosDirection.Invalid;
+    }
+
+    private bool IsDiagonalEdge(IMapGrid grid, Vector2i index, Vector2i? ignore = null)
+    {
+        foreach (var neighbourIndex in GetDiagonalNeighbors(index))
+        {
+            if (neighbourIndex == ignore)
+                continue;
+
+            if (!grid.TryGetTileRef(neighbourIndex, out var neighborTile) || neighborTile.Tile.IsEmpty)
+                return true;
+        }
+
+        return false;
+    }
+
+    /// <summary>
+    ///     Enumerate over diagonally adjacent tiles.
+    /// </summary>
+    internal static IEnumerable<Vector2i> GetDiagonalNeighbors(Vector2i pos)
+    {
+        yield return pos + (1, 1);
+        yield return pos + (-1, -1);
+        yield return pos + (1, -1);
+        yield return pos + (-1, 1);
+    }
+}
+
+public struct GridEdgeData : IEquatable<GridEdgeData>
+{
+    public Vector2i Tile;
+    public GridId? Grid;
+    public Box2Rotated Box;
+
+    public GridEdgeData(Vector2i tile, GridId? grid, Vector2 center, Angle angle, float size)
+    {
+        Tile = tile;
+        Grid = grid;
+        Box = new(Box2.CenteredAround(center, (size, size)), angle, center);
+    }
+
+    /// <inheritdoc />
+    public bool Equals(GridEdgeData other)
+    {
+        return Tile.Equals(other.Tile) && Grid.Equals(other.Grid);
+    }
+
+    /// <inheritdoc />
+    public override int GetHashCode()
+    {
+        unchecked
+        {
+            return (Tile.GetHashCode() * 397) ^ Grid.GetHashCode();
+        }
+    }
+}
+
+public record GridBlockData
+{
+    /// <summary>
+    ///     What directions of this tile are not blocked by some other grid?
+    /// </summary>
+    public AtmosDirection UnblockedDirections = AtmosDirection.All;
+
+    /// <summary>
+    ///     Hashset contains information about the edge-tiles, which belong to some other grid(s), that are blocking
+    ///     this tile.
+    /// </summary>
+    public HashSet<GridEdgeData> BlockingGridEdges = new();
+}
diff --git a/Content.Server/Explosion/EntitySystems/ExplosionSystem.Processing.cs b/Content.Server/Explosion/EntitySystems/ExplosionSystem.Processing.cs
new file mode 100644
index 0000000000..93e3af4b73
--- /dev/null
+++ b/Content.Server/Explosion/EntitySystems/ExplosionSystem.Processing.cs
@@ -0,0 +1,569 @@
+using System.Linq;
+using Content.Server.Explosion.Components;
+using Content.Server.Throwing;
+using Content.Shared.Damage;
+using Content.Shared.Explosion;
+using Content.Shared.Maps;
+using Content.Shared.Physics;
+using Robust.Shared.Map;
+using Robust.Shared.Physics;
+using Robust.Shared.Random;
+using Robust.Shared.Timing;
+
+namespace Content.Server.Explosion.EntitySystems;
+
+public sealed partial class ExplosionSystem : EntitySystem
+{
+    /// <summary>
+    ///     Used to identify explosions when communicating with the client. Might be needed if more than one explosion is spawned in a single tick.
+    /// </summary>
+    /// <remarks>
+    ///     Overflowing back to 0 should cause no issue, as long as you don't have more than 256 explosions happening in a single tick.
+    /// </remarks>
+    private byte _explosionCounter = 0;
+    // maybe should just use a UID/explosion-entity and a state to convey information?
+    // but then need to ignore PVS? Eeehh this works well enough for now.
+
+    /// <summary>
+    ///     Arbitrary definition for when an explosion is large enough to require separating the area/tile-finding and
+    ///     the processing into separate ticks.
+    /// </summary>
+    /// <remarks>
+    ///     Only used when the explosion processing is not limited by time.
+    /// </remarks>
+    public const int NukeArea = 400;
+
+    /// <summary>
+    ///     Used to limit explosion processing time. See <see cref="MaxProcessingTime"/>.
+    /// </summary>
+    internal readonly Stopwatch Stopwatch = new();
+
+    /// <summary>
+    ///     How many tiles to explode before checking the stopwatch timer
+    /// </summary>
+    internal static int TileCheckIteration = 1;
+
+    /// <summary>
+    ///     Queue for delayed processing of explosions. If there is an explosion that covers more than <see
+    ///     cref="TilesPerTick"/> tiles, other explosions will actually be delayed slightly. Unless it's a station
+    ///     nuke, this delay should never really be noticeable.
+    /// </summary>
+    private Queue<Func<Explosion?>> _explosionQueue = new();
+
+    /// <summary>
+    ///     The explosion currently being processed.
+    /// </summary>
+    private Explosion? _activeExplosion;
+
+    /// <summary>
+    ///     While processing an explosion, the "progress" is sent to clients, so that the explosion fireball effect
+    ///     syncs up with the damage. When the tile iteration increments, an update needs to be sent to clients.
+    ///     This integer keeps track of the last value sent to clients.
+    /// </summary>
+    private int _previousTileIteration;
+
+    /// <summary>
+    ///     Process the explosion queue.
+    /// </summary>
+    public override void Update(float frameTime)
+    {
+        if (_activeExplosion == null && _explosionQueue.Count == 0)
+            // nothing to do
+            return;
+
+        Stopwatch.Restart();
+        var x = Stopwatch.Elapsed.TotalMilliseconds;
+
+        var availableTime = MaxProcessingTime;
+
+        var tilesRemaining = TilesPerTick;
+        while (tilesRemaining > 0 && MaxProcessingTime > Stopwatch.Elapsed.TotalMilliseconds)
+        {
+            // if there is no active explosion, get a new one to process
+            if (_activeExplosion == null)
+            {
+                // EXPLOSION TODO allow explosion spawning to be interrupted by time limit. In the meantime, ensure that
+                // there is at-least 1ms of time left before creating a new explosion
+                if (MathF.Max(MaxProcessingTime - 1, 0.1f)  < Stopwatch.Elapsed.TotalMilliseconds)
+                    break;
+
+                if (!_explosionQueue.TryDequeue(out var spawnNextExplosion))
+                    break;
+
+                _activeExplosion = spawnNextExplosion();
+
+                // explosion spawning can be null if something somewhere went wrong. (e.g., negative explosion
+                // intensity).
+                if (_activeExplosion == null)
+                    continue;
+
+                _explosionCounter++;
+                _previousTileIteration = 0;
+
+                // just a lil nap
+                if (SleepNodeSys)
+                {
+                    _nodeGroupSystem.Snoozing = true;
+                    // snooze grid-chunk regeneration?
+                    // snooze power network (recipients look for new suppliers as wires get destroyed).
+                }
+
+                // if this is a single-tick explosion (i.e., not severely limited by number of tiles per tick or
+                // processing time, we want to process large explosion on a tick separate from the one they were
+                // generated on.
+                if (_activeExplosion.Area > NukeArea
+                    && MaxProcessingTime >= _gameTiming.TickPeriod.TotalMilliseconds)
+                {
+                    // start processing next turn.
+                    break;
+                }
+            }
+
+            var processed = _activeExplosion.Proccess(tilesRemaining);
+            tilesRemaining -= processed;
+
+            // has the explosion finished processing?
+            if (_activeExplosion.FinishedProcessing)
+                _activeExplosion = null;
+        }
+
+        Logger.InfoS("Explosion", $"Processed {TilesPerTick - tilesRemaining} tiles in {Stopwatch.Elapsed.TotalMilliseconds}ms");
+
+        // we have finished processing our tiles. Is there still an ongoing explosion?
+        if (_activeExplosion != null)
+        {
+            // update the client explosion overlays. This ensures that the fire-effects sync up with the entities currently being damaged.
+            if (_previousTileIteration == _activeExplosion.CurrentIteration)
+                return;
+
+            _previousTileIteration = _activeExplosion.CurrentIteration;
+            RaiseNetworkEvent(new ExplosionOverlayUpdateEvent(_explosionCounter, _previousTileIteration + 1));
+            return;
+        }
+
+        if (_explosionQueue.Count > 0)
+            return;
+
+        // We have finished processing all explosions. Clear client explosion overlays
+        RaiseNetworkEvent(new ExplosionOverlayUpdateEvent(_explosionCounter, int.MaxValue));
+
+        //wakey wakey
+        _nodeGroupSystem.Snoozing = false;
+    }
+
+    /// <summary>
+    ///     Determines whether an entity is blocking a tile or not. (whether it can prevent the tile from being uprooted
+    ///     by an explosion).
+    /// </summary>
+    /// <remarks>
+    ///     Used for a variation of <see cref="TurfHelpers.IsBlockedTurf()"/> that makes use of the fact that we have
+    ///     already done an entity lookup on a tile, and don't need to do so again.
+    /// </remarks>
+    public bool IsBlockingTurf(EntityUid uid)
+    {
+        if (EntityManager.IsQueuedForDeletion(uid))
+            return false;
+
+        if (!TryComp(uid, out IPhysBody? body))
+            return false;
+
+        return body.CanCollide && body.Hard && (body.CollisionLayer & (int) CollisionGroup.Impassable) != 0;
+    }
+
+    /// <summary>
+    ///     Find entities on a grid tile using the EntityLookupComponent and apply explosion effects. 
+    /// </summary>
+    /// <returns>True if the underlying tile can be uprooted, false if the tile is blocked by a dense entity</returns>
+    internal bool ExplodeTile(EntityLookupComponent lookup,
+        IMapGrid grid,
+        Vector2i tile,
+        float intensity,
+        float throwForce,
+        DamageSpecifier damage,
+        MapCoordinates epicenter,
+        HashSet<EntityUid> processed,
+        string id)
+    {
+        var gridBox = new Box2(tile * grid.TileSize, (tile + 1) * grid.TileSize);
+
+        // get the entities on a tile. Note that we cannot process them directly, or we get
+        // enumerator-changed-while-enumerating errors.
+        List<EntityUid> list = new();
+        _entityLookup.FastEntitiesIntersecting(lookup, ref gridBox, entity => list.Add(entity));
+
+        // process those entities
+        foreach (var entity in list)
+        {
+            ProcessEntity(entity, epicenter, processed, damage, throwForce, id, false);
+        }
+
+        // process anchored entities
+        var tileBlocked = false;
+        foreach (var entity in grid.GetAnchoredEntities(tile).ToList())
+        {
+            ProcessEntity(entity, epicenter, processed, damage, throwForce, id, true);
+            tileBlocked |= IsBlockingTurf(entity);
+        }
+
+        // Next, we get the intersecting entities AGAIN, but purely for throwing. This way, glass shards spawned from
+        // windows will be flung outwards, and not stay where they spawned. This is however somewhat unnecessary, and a
+        // prime candidate for computational cost-cutting. Alternatively, it would be nice if there was just some sort
+        // of spawned-on-destruction event that could be used to automatically assemble a list of new entities that need
+        // to be thrown.
+        //
+        // All things considered, until entity spawning & destruction is sped up, this isn't all that time consuming.
+        // (unless its a REALLY big explosion)
+        if (throwForce <= 0)
+            return !tileBlocked;
+
+        list.Clear();
+        _entityLookup.FastEntitiesIntersecting(lookup, ref gridBox, entity => list.Add(entity));
+
+        foreach (var e in list)
+        {
+            // Here we only throw, no dealing damage. Containers n such might drop their entities after being destroyed, but
+            // they handle their own damage pass-through.
+            ProcessEntity(e, epicenter, processed, null, throwForce, id, false);
+        }
+
+        return !tileBlocked;
+    }
+
+    /// <summary>
+    ///     Same as <see cref="ExplodeTile"/>, but for SPAAAAAAACE.
+    /// </summary>
+    internal void ExplodeSpace(EntityLookupComponent lookup,
+        Matrix3 spaceMatrix,
+        Matrix3 invSpaceMatrix,
+        Vector2i tile,
+        float intensity,
+        float throwForce,
+        DamageSpecifier damage,
+        MapCoordinates epicenter,
+        HashSet<EntityUid> processed,
+        string id)
+    {
+        var gridBox = new Box2(tile * DefaultTileSize, (DefaultTileSize, DefaultTileSize));
+        var worldBox = spaceMatrix.TransformBox(gridBox);
+        List<EntityUid> list = new();
+
+        EntityUidQueryCallback callback = uid =>
+        {
+            if (gridBox.Contains(invSpaceMatrix.Transform(Transform(uid).WorldPosition)))
+                list.Add(uid);
+        };
+
+        _entityLookup.FastEntitiesIntersecting(lookup, ref worldBox, callback);
+
+        foreach (var entity in list)
+        {
+            ProcessEntity(entity, epicenter, processed, damage, throwForce, id, false);
+        }
+
+        if (throwForce <= 0)
+            return;
+
+        list.Clear();
+        _entityLookup.FastEntitiesIntersecting(lookup, ref worldBox, callback);
+        foreach (var entity in list)
+        {
+            ProcessEntity(entity, epicenter, processed, null, throwForce, id, false);
+        }
+    }
+
+    /// <summary>
+    ///     This function actually applies the explosion affects to an entity.
+    /// </summary>
+    private void ProcessEntity(EntityUid uid, MapCoordinates epicenter, HashSet<EntityUid> processed, DamageSpecifier? damage, float throwForce, string id, bool anchored)
+    {
+        // check whether this is a valid target, and whether we have already damaged this entity (can happen with
+        // explosion-throwing).
+        if (!anchored && _containerSystem.IsEntityInContainer(uid) || !processed.Add(uid))
+            return;
+
+        // damage
+        if (damage != null)
+        {
+            var ev = new GetExplosionResistanceEvent(id);
+            RaiseLocalEvent(uid, ev, false);
+            var coeff = Math.Clamp(0, 1 - ev.Resistance, 1);
+
+            if (!MathHelper.CloseTo(0, coeff))
+                _damageableSystem.TryChangeDamage(uid, damage * coeff, ignoreResistances: true);
+        }
+
+        // throw
+        if (!anchored
+            && throwForce > 0
+            && !EntityManager.IsQueuedForDeletion(uid)
+            && HasComp<ExplosionLaunchedComponent>(uid)
+            && TryComp(uid, out TransformComponent? transform))
+        {
+            uid.TryThrow(transform.WorldPosition - epicenter.Position, throwForce);
+        }
+
+        // TODO EXPLOSION puddle / flammable ignite?
+
+        // TODO EXPLOSION deaf/ear damage? other explosion effects?
+    }
+
+    /// <summary>
+    ///     Tries to damage floor tiles. Not to be confused with the function that damages entities intersecting the
+    ///     grid tile.
+    /// </summary>
+    public void DamageFloorTile(TileRef tileRef,
+        float intensity,
+        List<(Vector2i GridIndices, Tile Tile)> damagedTiles,
+        ExplosionPrototype type)
+    {
+        var tileDef = _tileDefinitionManager[tileRef.Tile.TypeId];
+
+        while (_robustRandom.Prob(type.TileBreakChance(intensity)))
+        {
+            intensity -= type.TileBreakRerollReduction;
+
+            if (tileDef is not ContentTileDefinition contentTileDef)
+                break;
+
+            // does this have a base-turf that we can break it down to?
+            if (contentTileDef.BaseTurfs.Count == 0)
+                break;
+
+            tileDef = _tileDefinitionManager[contentTileDef.BaseTurfs[^1]];
+        }
+
+        if (tileDef.TileId == tileRef.Tile.TypeId)
+            return;
+
+        damagedTiles.Add((tileRef.GridIndices, new Tile(tileDef.TileId)));
+    }
+}
+
+/// <summary>
+///     This is a data class that stores information about the area affected by an explosion, for processing by <see
+///     cref="ExplosionSystem"/>.
+/// </summary>
+/// <remarks>
+///     This is basically the output of <see cref="ExplosionSystem.GetExplosionTiles()"/>, but wrapped in an enumerator
+///     to iterate over the tiles, along with the ability to keep track of what entities have already been damaged by
+///     this explosion.
+/// </remarks>
+sealed class Explosion
+{
+    struct ExplosionData
+    {
+        public EntityLookupComponent Lookup;
+        public Dictionary<int, List<Vector2i>> TileLists;
+        public IMapGrid? MapGrid;
+    }
+
+    /// <summary>
+    ///     Used to avoid applying explosion effects repeatedly to the same entity. Particularly important if the
+    ///     explosion throws this entity, as then it will be moving while the explosion is happening.
+    /// </summary>
+    public readonly HashSet<EntityUid> ProcessedEntities = new();
+
+    /// <summary>
+    ///     This integer tracks how much of this explosion has been processed.
+    /// </summary>
+    public int CurrentIteration { get; private set; } = 0;
+
+    public readonly ExplosionPrototype ExplosionType;
+    public readonly MapCoordinates Epicenter;
+    private readonly Matrix3 _spaceMatrix;
+    private readonly Matrix3 _invSpaceMatrix;
+
+    private readonly List<ExplosionData> _explosionData = new();
+    private readonly List<float> _tileSetIntensity;
+
+    public bool FinishedProcessing;
+
+    // shitty enumerator implementation
+    private DamageSpecifier _currentDamage = default!;
+    private EntityLookupComponent _currentLookup = default!;
+    private IMapGrid? _currentGrid;
+    private float _currentIntensity;
+    private float _currentThrowForce;
+    private List<Vector2i>.Enumerator _currentEnumerator;
+    private int _currentDataIndex;
+    private Dictionary<IMapGrid, List<(Vector2i, Tile)>> _tileUpdateDict = new();
+
+    public int Area;
+
+    private readonly ExplosionSystem _system;
+
+    public Explosion(ExplosionSystem system,
+        ExplosionPrototype explosionType,
+        SpaceExplosion? spaceData,
+        List<GridExplosion> gridData,
+        List<float> tileSetIntensity,
+        MapCoordinates epicenter,
+        Matrix3 spaceMatrix,
+        int area)
+    {
+        _system = system;
+        ExplosionType = explosionType;
+        _tileSetIntensity = tileSetIntensity;
+        Epicenter = epicenter;
+        Area = area;
+
+        var entityMan = IoCManager.Resolve<IEntityManager>();
+        var mapMan = IoCManager.Resolve<IMapManager>();
+
+        if (spaceData != null)
+        {
+            var mapUid = mapMan.GetMapEntityId(epicenter.MapId);
+
+            _explosionData.Add(new()
+            {
+                TileLists = spaceData.TileLists,
+                Lookup = entityMan.GetComponent<EntityLookupComponent>(mapUid),
+                MapGrid = null
+            });
+
+            _spaceMatrix = spaceMatrix;
+            _invSpaceMatrix = Matrix3.Invert(spaceMatrix);
+        }
+
+        foreach (var grid in gridData)
+        {
+            _explosionData.Add(new()
+            {
+                TileLists = grid.TileLists,
+                Lookup = entityMan.GetComponent<EntityLookupComponent>(grid.Grid.GridEntityId),
+                MapGrid = grid.Grid
+            });
+        }
+
+        TryGetNextTileEnumerator();
+    }
+
+    private bool TryGetNextTileEnumerator()
+    {
+        while (CurrentIteration < _tileSetIntensity.Count)
+        {
+            _currentIntensity = _tileSetIntensity[CurrentIteration];
+            _currentDamage = ExplosionType.DamagePerIntensity * _currentIntensity;
+            _currentThrowForce = Area > _system.ThrowLimit ? 0 : 10 * MathF.Sqrt(_currentIntensity);
+
+            // for each grid/space tile set
+            while (_currentDataIndex < _explosionData.Count)
+            {
+                // try get any tile hash-set corresponding to this intensity
+                var tileSets = _explosionData[_currentDataIndex].TileLists;
+                if (!tileSets.TryGetValue(CurrentIteration, out var tileList))
+                {
+                    _currentDataIndex++;
+                    continue;
+                }
+
+                _currentEnumerator = tileList.GetEnumerator();
+                _currentLookup = _explosionData[_currentDataIndex].Lookup;
+                _currentGrid = _explosionData[_currentDataIndex].MapGrid;
+
+                _currentDataIndex++;
+                return true;
+            }
+
+            // this explosion intensity has been fully processed, move to the next one
+            CurrentIteration++;
+            _currentDataIndex = 0;
+        }
+
+        // no more explosion data to process
+        FinishedProcessing = true;
+        return false;
+    }
+
+    private bool MoveNext()
+    {
+        if (FinishedProcessing)
+            return false;
+
+        while (!FinishedProcessing)
+        {
+            if (_currentEnumerator.MoveNext())
+                return true;
+            else
+                TryGetNextTileEnumerator();
+        }
+
+        return false;
+    }
+
+    public int Proccess(int processingTarget)
+    {
+        // In case the explosion terminated early last tick due to exceeding the allocated processing time, use this
+        // time to update the tiles.
+        SetTiles();
+
+        int processed;
+        for (processed = 0; processed < processingTarget; processed++)
+        {
+            if (processed % ExplosionSystem.TileCheckIteration == 0 &&
+                _system.Stopwatch.Elapsed.TotalMilliseconds > _system.MaxProcessingTime)
+            {
+                break;
+            }
+
+            if (_currentGrid != null &&
+                _currentGrid.TryGetTileRef(_currentEnumerator.Current, out var tileRef) &&
+                !tileRef.Tile.IsEmpty)
+            {
+                if (!_tileUpdateDict.TryGetValue(_currentGrid, out var tileUpdateList))
+                {
+                    tileUpdateList = new();
+                    _tileUpdateDict[_currentGrid] = tileUpdateList;
+                }
+
+                var canDamageFloor = _system.ExplodeTile(_currentLookup,
+                    _currentGrid,
+                    _currentEnumerator.Current,
+                    _currentIntensity,
+                    _currentThrowForce,
+                    _currentDamage,
+                    Epicenter,
+                    ProcessedEntities,
+                    ExplosionType.ID);
+
+                if (canDamageFloor)
+                    _system.DamageFloorTile(tileRef, _currentIntensity, tileUpdateList, ExplosionType);
+            }
+            else
+            {
+                _system.ExplodeSpace(_currentLookup,
+                    _spaceMatrix,
+                    _invSpaceMatrix,
+                    _currentEnumerator.Current,
+                    _currentIntensity,
+                    _currentThrowForce,
+                    _currentDamage,
+                    Epicenter,
+                    ProcessedEntities,
+                    ExplosionType.ID);
+            }
+
+            if (!MoveNext())
+                break;
+        }
+
+        SetTiles();
+        return processed;
+    }
+
+    private void SetTiles()
+    {
+        if (!_system.IncrementalTileBreaking && !FinishedProcessing)
+            return;
+
+        foreach (var (grid, list) in _tileUpdateDict)
+        {
+            if (list.Count > 0)
+            {
+                grid.SetTiles(list);
+            }
+        }
+        _tileUpdateDict.Clear();
+    }
+}
+
diff --git a/Content.Server/Explosion/EntitySystems/ExplosionSystem.TileFill.cs b/Content.Server/Explosion/EntitySystems/ExplosionSystem.TileFill.cs
new file mode 100644
index 0000000000..759e63f43f
--- /dev/null
+++ b/Content.Server/Explosion/EntitySystems/ExplosionSystem.TileFill.cs
@@ -0,0 +1,334 @@
+using System.Linq;
+using Content.Shared.Administration;
+using Content.Shared.Explosion;
+using Robust.Shared.Map;
+using Robust.Shared.Timing;
+
+namespace Content.Server.Explosion.EntitySystems;
+
+// This partial part of the explosion system has all of the functions used to create the actual explosion map.
+// I.e, to get the sets of tiles & intensity values that describe an explosion.
+
+public sealed partial class ExplosionSystem : EntitySystem
+{
+    /// <summary>
+    ///     This is the main explosion generating function. 
+    /// </summary>
+    /// <param name="epicenter">The center of the explosion</param>
+    /// <param name="typeID">The explosion type. this determines the explosion damage</param>
+    /// <param name="totalIntensity">The final sum of the tile intensities. This governs the overall size of the
+    /// explosion</param>
+    /// <param name="slope">How quickly does the intensity decrease when moving away from the epicenter.</param>
+    /// <param name="maxIntensity">The maximum intensity that the explosion can have at any given tile. This
+    /// effectively caps the damage that this explosion can do.</param>
+    /// <returns>A list of tile-sets and a list of intensity values which describe the explosion.</returns>
+    private (int, List<float>, SpaceExplosion?, Dictionary<GridId, GridExplosion>, Matrix3)? GetExplosionTiles(
+        MapCoordinates epicenter,
+        string typeID,
+        float totalIntensity,
+        float slope,
+        float maxIntensity)
+    {
+        if (totalIntensity <= 0 || slope <= 0)
+            return null;
+
+        Vector2i initialTile;
+        GridId? epicentreGrid = null;
+        var (localGrids, referenceGrid) = GetLocalGrids(epicenter, totalIntensity, slope, maxIntensity);
+
+        // get the epicenter tile indices
+        if (_mapManager.TryFindGridAt(epicenter, out var candidateGrid) &&
+            candidateGrid.TryGetTileRef(candidateGrid.WorldToTile(epicenter.Position), out var tileRef) &&
+            !tileRef.Tile.IsEmpty)
+        {
+            epicentreGrid = candidateGrid.Index;
+            initialTile = tileRef.GridIndices;
+        }
+        else if (referenceGrid != null)
+        {
+            // reference grid defines coordinate system that the explosion in space will use
+            initialTile = _mapManager.GetGrid(referenceGrid.Value).WorldToTile(epicenter.Position);
+        }
+        else
+        {
+            // this is a space-based explosion that (should) not touch any grids.
+            initialTile = new Vector2i(
+                    (int) Math.Floor(epicenter.Position.X / DefaultTileSize),
+                    (int) Math.Floor(epicenter.Position.Y / DefaultTileSize));
+        }
+
+        // Main data for the exploding tiles in space and on various grids
+        Dictionary<GridId, GridExplosion> gridData = new();
+        SpaceExplosion? spaceData = null;
+
+        // The intensity slope is how much the intensity drop over a one-tile distance. The actual algorithm step-size is half of thhat.
+        var stepSize = slope / 2;
+
+        // Hashsets used for when grid-based explosion propagate into space. Basically: used to move data between
+        // `gridData` and `spaceData` in-between neighbor finding iterations.
+        HashSet<Vector2i> spaceJump = new();
+        HashSet<Vector2i> previousSpaceJump;
+
+        // As above, but for space-based explosion propagating from space onto grids.
+        HashSet<GridId> encounteredGrids = new();
+        Dictionary<GridId, HashSet<Vector2i>>? previousGridJump;
+
+        // variables for transforming between grid and space-coordiantes
+        var spaceMatrix = Matrix3.Identity;
+        var spaceAngle = Angle.Zero;
+        if (referenceGrid != null)
+        {
+            var xform = Transform(_mapManager.GetGrid(referenceGrid.Value).GridEntityId);
+            spaceMatrix = xform.WorldMatrix;
+            spaceAngle = xform.WorldRotation;
+        }
+
+        // is the explosion starting on a grid?
+        if (epicentreGrid != null)
+        {
+            // set up the initial `gridData` instance
+            encounteredGrids.Add(epicentreGrid.Value);
+
+            if (!_airtightMap.TryGetValue(epicentreGrid.Value, out var airtightMap))
+                airtightMap = new();
+
+            var initialGridData = new GridExplosion(
+                _mapManager.GetGrid(epicentreGrid.Value),
+                airtightMap,
+                maxIntensity,
+                stepSize,
+                typeID,
+                _gridEdges[epicentreGrid.Value],
+                referenceGrid,
+                spaceMatrix,
+                spaceAngle);
+
+            gridData[epicentreGrid.Value] = initialGridData;
+
+            initialGridData.InitTile(initialTile);
+        }
+        else
+        {
+            // set up the space explosion data
+            spaceData = new SpaceExplosion(this, epicenter.MapId, referenceGrid, localGrids);
+            spaceData.InitTile(initialTile);
+        }
+
+        // Is this even a multi-tile explosion?
+        if (totalIntensity < stepSize)
+            // Bit anticlimactic. All that set up for nothing....
+            return (1, new List<float> { totalIntensity }, spaceData, gridData, spaceMatrix);
+        
+        // These variables keep track of the total intensity we have distributed
+        List<int> tilesInIteration = new() { 1 };
+        List<float> iterationIntensity = new() {stepSize};
+        var totalTiles = 0;
+        var remainingIntensity = totalIntensity - stepSize;
+
+        var iteration = 1;
+        var maxIntensityIndex = 0;
+
+        // If an explosion is trapped in an indestructible room, we can end the neighbor finding steps early.
+        // These variables are used to check if we can abort early.
+        float previousIntensity;
+        var intensityUnchangedLastLoop = false;
+
+        // Main flood-fill / neighbor-finding loop
+        while (remainingIntensity > 0 && iteration <= MaxIterations && totalTiles < MaxArea)
+        {
+            previousIntensity = remainingIntensity;
+
+            // First, we increase the intensity of the tiles that were already discovered in previous iterations.
+            for (var i = maxIntensityIndex; i < iteration; i++)
+            {
+                var intensityIncrease = MathF.Min(stepSize, maxIntensity - iterationIntensity[i]);
+
+                if (tilesInIteration[i] * intensityIncrease >= remainingIntensity)
+                {
+                    // there is not enough intensity left to distribute. add a fractional amount and break.
+                    iterationIntensity[i] += (float) remainingIntensity / tilesInIteration[i];
+                    remainingIntensity = 0;
+                    break;
+                }
+
+                iterationIntensity[i] += intensityIncrease;
+                remainingIntensity -= tilesInIteration[i] * intensityIncrease;
+
+                // Has this tile-set has reached max intensity? If so, stop iterating over it in  future
+                if (intensityIncrease < stepSize)
+                    maxIntensityIndex++;
+            }
+
+            if (remainingIntensity <= 0) break;
+
+            // Next, we will add a new iteration of tiles
+
+            // In order to treat "cost" of moving off a grid on the same level as moving onto a grid, both space -> grid and grid -> space have to be delayed by one iteration.
+            previousSpaceJump = spaceJump;
+            previousGridJump = spaceData?.GridJump;
+            spaceJump = new();
+
+            var newTileCount = 0;
+
+            if (previousGridJump != null)
+                encounteredGrids.UnionWith(previousGridJump.Keys);
+
+            foreach (var grid in encounteredGrids)
+            {
+                // is this a new grid, for which we must create a new explosion data set
+                if (!gridData.TryGetValue(grid, out var data))
+                {
+                    if (!_airtightMap.TryGetValue(grid, out var airtightMap))
+                        airtightMap = new();
+
+                    data = new GridExplosion(
+                        _mapManager.GetGrid(grid),
+                        airtightMap,
+                        maxIntensity,
+                        stepSize,
+                        typeID,
+                        _gridEdges[grid],
+                        referenceGrid,
+                        spaceMatrix,
+                        spaceAngle);
+
+                    gridData[grid] = data;
+                }
+
+                // get the new neighbours, and populate gridToSpaceTiles in the process.
+                newTileCount += data.AddNewTiles(iteration, previousGridJump?.GetValueOrDefault(grid));
+                spaceJump.UnionWith(data.SpaceJump);
+            }
+
+            // if space-data is null, but some grid-based explosion reached space, we need to initialize it.
+            if (spaceData == null && previousSpaceJump.Count != 0)
+                spaceData = new SpaceExplosion(this, epicenter.MapId, referenceGrid, localGrids);
+
+            // If the explosion has reached space, do that neighbors finding step as well.
+            if (spaceData != null)
+                newTileCount += spaceData.AddNewTiles(iteration, previousSpaceJump);
+
+            // Does adding these tiles bring us above the total target intensity?
+            tilesInIteration.Add(newTileCount);
+            if (newTileCount * stepSize >= remainingIntensity)
+            {
+                iterationIntensity.Add((float) remainingIntensity / newTileCount);
+                break;
+            }
+
+            // add the new tiles and decrement available intensity
+            remainingIntensity -= newTileCount * stepSize;
+            iterationIntensity.Add(stepSize);
+            totalTiles += newTileCount;
+
+            // It is possible that the explosion has some max intensity and is stuck in a container whose walls it
+            // cannot break. if the remaining intensity remains unchanged TWO loops in a row, we know that this is the
+            // case.
+            if (intensityUnchangedLastLoop && remainingIntensity == previousIntensity)
+                break;
+
+            intensityUnchangedLastLoop = remainingIntensity == previousIntensity;
+            iteration += 1;
+        }
+
+        if (totalTiles >= MaxArea) 
+            Logger.Info("Whooooo! MAXCAP!");
+
+        // Neighbor finding is done. Perform final clean up and return.
+        foreach (var grid in gridData.Values)
+        {
+            grid.CleanUp();
+        }
+        spaceData?.CleanUp();
+
+        return (totalTiles, iterationIntensity, spaceData, gridData, spaceMatrix);
+    }
+
+    /// <summary>
+    ///     Look for grids in an area and returns them. Also selects a special grid that will be used to determine the
+    ///     orientation of an explosion in space.
+    /// </summary>
+    /// <remarks>
+    ///     Note that even though an explosion may start ON a grid, the explosion in space may still be orientated to
+    ///     match a separate grid. This is done so that if you have something like a tiny suicide-bomb shuttle exploding
+    ///     near a large station, the explosion will still orient to match the station, not the tiny shuttle.
+    /// </remarks>
+    public (List<GridId>, GridId?) GetLocalGrids(MapCoordinates epicenter, float totalIntensity, float slope, float maxIntensity)
+    {
+        // Get the explosion radius (approx radius if it were in open-space). Note that if the explosion is confined in
+        // some directions but not in others, the actual explosion may reach further than this distance from the
+        // epicenter. Conversely, it might go nowhere near as far.
+        var radius = 0.5f + IntensityToRadius(totalIntensity, slope, maxIntensity);
+
+        // to avoid a silly lookup for silly input numbers, cap the radius to half of the theoretical maximum (lookup area gets doubled later on).
+        radius = Math.Min(radius, MaxIterations / 4);
+
+        GridId? referenceGrid = null;
+        float mass = 0;
+
+        // First attempt to find a grid that is relatively close to the explosion's center. Instead of looking in a
+        // diameter x diameter sized box, use a smaller box with radius sized sides:
+        var box = Box2.CenteredAround(epicenter.Position, (radius, radius));
+
+        foreach (var grid in _mapManager.FindGridsIntersecting(epicenter.MapId, box))
+        {
+            if (TryComp(grid.GridEntityId, out PhysicsComponent? physics) && physics.Mass > mass)
+            {
+                mass = physics.Mass;
+                referenceGrid = grid.Index;
+            }
+        }
+
+        // Next, we use a much larger lookup to determine all grids relevant to the explosion. This is used to determine
+        // what grids should be includes during the grid-edge transformation steps. This means that if a grid is not in
+        // this set, the explosion can never propagate from space onto this grid.
+
+        // As mentioned before, the `diameter` is only indicative, as an explosion that is obstructed (e.g., in a
+        // tunnel) may travel further away from the epicenter. But this should be very rare for space-traversing
+        // explosions. So instead of using the largest possible distance that an explosion could theoretically travel
+        // and using that for the grid look-up, we will just arbitrarily fudge the lookup size to be twice the diameter.
+
+        box = box.Scale(4); // box with width and height of 4*radius.
+        var mapGrids = _mapManager.FindGridsIntersecting(epicenter.MapId, box).ToList();
+        var grids = mapGrids.Select(x => x.Index).ToList();
+
+        if (referenceGrid != null)
+            return (grids, referenceGrid);
+
+        // We still don't have are reference grid. So lets also look in the enlarged region
+        foreach (var grid in mapGrids)
+        {
+            if (TryComp(grid.GridEntityId, out PhysicsComponent? physics) && physics.Mass > mass)
+            {
+                mass = physics.Mass;
+                referenceGrid = grid.Index;
+            }
+        }
+
+        return (grids, referenceGrid);
+    }
+
+    public ExplosionEvent? GenerateExplosionPreview(SpawnExplosionEuiMsg.PreviewRequest request)
+    {
+        var stopwatch = new Stopwatch();
+        stopwatch.Start();
+
+        var results = GetExplosionTiles(
+            request.Epicenter,
+            request.TypeId,
+            request.TotalIntensity,
+            request.IntensitySlope,
+            request.MaxIntensity);
+
+        if (results == null)
+            return null;
+
+        var (area, iterationIntensity, spaceData, gridData, spaceMatrix) = results.Value;
+
+        Logger.Info($"Generated explosion preview with {area} tiles in {stopwatch.Elapsed.TotalMilliseconds}ms");
+
+        // the explosion event that **would** be sent to all clients, if it were a real explosion.
+        return GetExplosionEvent(request.Epicenter, request.TypeId, spaceMatrix, spaceData, gridData.Values, iterationIntensity);
+    }
+}
+
diff --git a/Content.Server/Explosion/EntitySystems/ExplosionSystem.cs b/Content.Server/Explosion/EntitySystems/ExplosionSystem.cs
index c1b14d15eb..81e99ea2a4 100644
--- a/Content.Server/Explosion/EntitySystems/ExplosionSystem.cs
+++ b/Content.Server/Explosion/EntitySystems/ExplosionSystem.cs
@@ -1,392 +1,274 @@
-using System;
-using System.Collections.Generic;
 using System.Linq;
-using Content.Server.Administration.Logs;
+using Content.Server.Atmos.Components;
 using Content.Server.Explosion.Components;
-using Content.Shared.Acts;
+using Content.Server.NodeContainer.EntitySystems;
 using Content.Shared.Camera;
-using Content.Shared.Database;
-using Content.Shared.Interaction;
-using Content.Shared.Interaction.Helpers;
-using Content.Shared.Maps;
-using Content.Shared.Physics;
-using Content.Shared.Sound;
-using Content.Shared.Tag;
-using Robust.Server.GameObjects;
+using Content.Shared.Damage;
+using Content.Shared.Explosion;
+using Robust.Server.Containers;
+using Robust.Server.Player;
 using Robust.Shared.Audio;
-using Robust.Shared.Containers;
-using Robust.Shared.GameObjects;
-using Robust.Shared.IoC;
+using Robust.Shared.Configuration;
 using Robust.Shared.Map;
-using Robust.Shared.Maths;
-using Robust.Shared.Physics;
 using Robust.Shared.Player;
+using Robust.Shared.Prototypes;
 using Robust.Shared.Random;
 using Robust.Shared.Timing;
 
-namespace Content.Server.Explosion.EntitySystems
+namespace Content.Server.Explosion.EntitySystems;
+
+public sealed partial class ExplosionSystem : EntitySystem
 {
-    public sealed class ExplosionSystem : EntitySystem
+    [Dependency] private readonly IMapManager _mapManager = default!;
+    [Dependency] private readonly IRobustRandom _robustRandom = default!;
+    [Dependency] private readonly ITileDefinitionManager _tileDefinitionManager = default!;
+    [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
+    [Dependency] private readonly IConfigurationManager _cfg = default!;
+    [Dependency] private readonly IPlayerManager _playerManager = default!;
+    [Dependency] private readonly IGameTiming _gameTiming = default!;
+
+    [Dependency] private readonly DamageableSystem _damageableSystem = default!;
+    [Dependency] private readonly ContainerSystem _containerSystem = default!;
+    [Dependency] private readonly NodeGroupSystem _nodeGroupSystem = default!;
+    [Dependency] private readonly CameraRecoilSystem _recoilSystem = default!;
+    [Dependency] private readonly EntityLookupSystem _entityLookup = default!;
+
+    /// <summary>
+    ///     "Tile-size" for space when there are no nearby grids to use as a reference.
+    /// </summary>
+    public const ushort DefaultTileSize = 1;
+
+    private AudioParams _audioParams = AudioParams.Default.WithVolume(-3f);
+
+    public override void Initialize()
     {
-        [Dependency] private readonly SharedInteractionSystem _interactionSystem = default!;
+        base.Initialize();
 
-        /// <summary>
-        /// Distance used for camera shake when distance from explosion is (0.0, 0.0).
-        /// Avoids getting NaN values down the line from doing math on (0.0, 0.0).
-        /// </summary>
-        private static readonly Vector2 EpicenterDistance = (0.1f, 0.1f);
+        // handled in ExplosionSystemGridMap.cs
+        SubscribeLocalEvent<GridRemovalEvent>(OnGridRemoved);
+        SubscribeLocalEvent<GridStartupEvent>(OnGridStartup);
+        SubscribeLocalEvent<ExplosionResistanceComponent, GetExplosionResistanceEvent>(OnGetResistance);
+        _mapManager.TileChanged += OnTileChanged;
 
-        /// <summary>
-        /// Chance of a tile breaking if the severity is Light and Heavy
-        /// </summary>
-        private const float LightBreakChance = 0.3f;
-        private const float HeavyBreakChance = 0.8f;
+        // handled in ExplosionSystemAirtight.cs
+        SubscribeLocalEvent<AirtightComponent, DamageChangedEvent>(OnAirtightDamaged);
+        SubscribeCvars();
+    }
 
-        // TODO move this to the component
-        private static readonly SoundSpecifier ExplosionSound = new SoundCollectionSpecifier("explosion");
+    public override void Shutdown()
+    {
+        base.Shutdown();
+        _mapManager.TileChanged -= OnTileChanged;
+        UnsubscribeCvars();
+    }
 
-        [Dependency] private readonly EntityLookupSystem _entityLookup = default!;
-        [Dependency] private readonly IGameTiming _timing = default!;
-        [Dependency] private readonly IMapManager _maps = default!;
-        [Dependency] private readonly IRobustRandom _random = default!;
-        [Dependency] private readonly ITileDefinitionManager _tiles = default!;
+    private void OnGetResistance(EntityUid uid, ExplosionResistanceComponent component, GetExplosionResistanceEvent args)
+    {
+        args.Resistance += component.GlobalResistance;
+        if (component.Resistances.TryGetValue(args.ExplotionPrototype, out var resistance))
+            args.Resistance += resistance;
+    }
 
-        [Dependency] private readonly ActSystem _acts = default!;
-        [Dependency] private readonly EffectSystem _effects = default!;
-        [Dependency] private readonly TriggerSystem _triggers = default!;
-        [Dependency] private readonly AdminLogSystem _logSystem = default!;
-        [Dependency] private readonly CameraRecoilSystem _cameraRecoil = default!;
-        [Dependency] private readonly TagSystem _tags = default!;
+    /// <summary>
+    ///     Given an entity with an explosive component, spawn the appropriate explosion.
+    /// </summary>
+    /// <remarks>
+    ///     Also accepts radius or intensity arguments. This is useful for explosives where the intensity is not
+    ///     specified in the yaml / by the component, but determined dynamically (e.g., by the quantity of a
+    ///     solution in a reaction).
+    /// </remarks>
+    public void TriggerExplosive(EntityUid uid, ExplosiveComponent? explosive = null, bool delete = true, float? totalIntensity = null, float? radius = null)
+    {
+        // log missing: false, because some entities (e.g. liquid tanks) attempt to trigger explosions when damaged,
+        // but may not actually be explosive.
+        if (!Resolve(uid, ref explosive, logMissing: false))
+            return;
 
-        private bool IgnoreExplosivePassable(EntityUid e)
+        // No reusable explosions here.
+        if (explosive.Exploded)
+            return;
+
+        explosive.Exploded = true;
+
+        // Override the explosion intensity if optional arguments were provided.
+        if (radius != null)
+            totalIntensity ??= RadiusToIntensity((float) radius, explosive.IntensitySlope, explosive.MaxIntensity);
+        totalIntensity ??= explosive.TotalIntensity;
+
+        QueueExplosion(uid,
+            explosive.ExplosionType,
+            (float) totalIntensity,
+            explosive.IntensitySlope,
+            explosive.MaxIntensity);
+
+        if (delete)
+            EntityManager.QueueDeleteEntity(uid);
+    }
+
+    /// <summary>
+    ///     Find the strength needed to generate an explosion of a given radius. More useful for radii larger then 4, when the explosion becomes less "blocky".
+    /// </summary>
+    /// <remarks>
+    ///     This assumes the explosion is in a vacuum / unobstructed. Given that explosions are not perfectly
+    ///     circular, here radius actually means the sqrt(Area/pi), where the area is the total number of tiles
+    ///     covered by the explosion. Until you get to radius 30+, this is functionally equivalent to the
+    ///     actual radius.
+    /// </remarks>
+    public float RadiusToIntensity(float radius, float slope, float maxIntensity = 0)
+    {
+        // If you consider the intensity at each tile in an explosion to be a height. Then a circular explosion is
+        // shaped like a cone. So total intensity is like the volume of a cone with height = slope * radius. Of
+        // course, as the explosions are not perfectly circular, this formula isn't perfect, but the formula works
+        // reasonably well.
+
+        // This should actually use the formula for the volume of a distorted octagonal frustum. But this is good
+        // enough.
+
+        var coneVolume = slope * MathF.PI / 3 * MathF.Pow(radius, 3);
+
+        if (maxIntensity <= 0 || slope * radius < maxIntensity)
+            return coneVolume;
+
+        // This explosion is limited by the maxIntensity.
+        // Instead of a cone, we have a conical frustum.
+
+        // Subtract the volume of the missing cone segment, with height:
+        var h = slope * radius - maxIntensity;
+        return coneVolume - h * MathF.PI / 3 * MathF.Pow(h / slope, 2);
+    }
+
+    /// <summary>
+    ///     Inverse formula for <see cref="RadiusToIntensity"/>
+    /// </summary>
+    public float IntensityToRadius(float totalIntensity, float slope, float maxIntensity)
+    {
+        // max radius to avoid being capped by max-intensity
+        var r0 = maxIntensity / slope;
+
+        // volume at r0
+        var v0 = RadiusToIntensity(r0, slope);
+
+        if (totalIntensity <= v0)
         {
-            return _tags.HasTag(e, "ExplosivePassable");
+            // maxIntensity is a non-issue, can use simple inverse formula
+            return MathF.Cbrt(3 * totalIntensity / (slope * MathF.PI));
         }
 
-        private ExplosionSeverity CalculateSeverity(float distance, float devastationRange, float heavyRange)
+        return r0 * (MathF.Sqrt(12 * totalIntensity/ v0 - 3) / 6 + 0.5f);
+    }
+
+    /// <summary>
+    ///     Queue an explosions, centered on some entity.
+    /// </summary>
+    public void QueueExplosion(EntityUid uid,
+        string typeId,
+        float intensity,
+        float slope,
+        float maxTileIntensity)
+    {
+        QueueExplosion(Transform(uid).MapPosition, typeId, intensity, slope, maxTileIntensity);
+    }
+
+    /// <summary>
+    ///     Queue an explosion, with a specified epicenter and set of starting tiles.
+    /// </summary>
+    public void QueueExplosion(MapCoordinates epicenter,
+        string typeId,
+        float totalIntensity,
+        float slope,
+        float maxTileIntensity)
+    {
+        if (totalIntensity <= 0 || slope <= 0)
+            return;
+
+        if (!_prototypeManager.TryIndex<ExplosionPrototype>(typeId, out var type))
         {
-            if (distance < devastationRange)
-            {
-                return ExplosionSeverity.Destruction;
-            }
-            else if (distance < heavyRange)
-            {
-                return ExplosionSeverity.Heavy;
-            }
-            else
-            {
-                return ExplosionSeverity.Light;
-            }
+            Logger.Error($"Attempted to spawn unknown explosion prototype: {type}");
+            return;
         }
 
-        private void CameraShakeInRange(EntityCoordinates epicenter, float maxRange)
+        _explosionQueue.Enqueue(() => SpawnExplosion(epicenter, type, totalIntensity,
+            slope, maxTileIntensity));
+    }
+
+    /// <summary>
+    ///     This function actually spawns the explosion. It returns an <see cref="Explosion"/> instance with
+    ///     information about the affected tiles for the explosion system to process. It will also trigger the
+    ///     camera shake and sound effect.
+    /// </summary>
+    private Explosion? SpawnExplosion(MapCoordinates epicenter,
+        ExplosionPrototype type,
+        float totalIntensity,
+        float slope,
+        float maxTileIntensity)
+    {
+        var results = GetExplosionTiles(epicenter, type.ID, totalIntensity, slope, maxTileIntensity);
+
+        if (results == null)
+            return null;
+
+        var (area, iterationIntensity, spaceData, gridData, spaceMatrix) = results.Value;
+
+        RaiseNetworkEvent(GetExplosionEvent(epicenter, type.ID, spaceMatrix, spaceData, gridData.Values, iterationIntensity));
+
+        // camera shake
+        CameraShake(iterationIntensity.Count * 2.5f, epicenter, totalIntensity);
+
+        //For whatever bloody reason, sound system requires ENTITY coordinates.
+        var mapEntityCoords = EntityCoordinates.FromMap(EntityManager, _mapManager.GetMapEntityId(epicenter.MapId), epicenter);
+
+        // play sound.
+        var audioRange = iterationIntensity.Count * 5;
+        var filter = Filter.Pvs(epicenter).AddInRange(epicenter, audioRange);
+        SoundSystem.Play(filter, type.Sound.GetSound(), mapEntityCoords, _audioParams);
+
+        return new Explosion(this,
+            type,
+            spaceData,
+            gridData.Values.ToList(),
+            iterationIntensity,
+            epicenter,
+            spaceMatrix,
+            area
+            );
+    }
+
+    /// <summary>
+    ///     Constructor for the shared <see cref="ExplosionEvent"/> using the server-exclusive explosion classes.
+    /// </summary>
+    internal ExplosionEvent GetExplosionEvent(MapCoordinates epicenter, string id, Matrix3 spaceMatrix, SpaceExplosion? spaceData, IEnumerable<GridExplosion> gridData, List<float> iterationIntensity)
+    {
+        var spaceTiles = spaceData?.TileLists;
+
+        Dictionary<GridId, Dictionary<int, List<Vector2i>>> tileLists = new();
+        foreach (var grid in gridData)
         {
-            var players = Filter.Empty()
-                .AddInRange(epicenter.ToMap(EntityManager), MathF.Ceiling(maxRange))
-                .Recipients;
-
-            foreach (var player in players)
-            {
-                if (player.AttachedEntity is not {Valid: true} playerEntity ||
-                    !EntityManager.HasComponent<CameraRecoilComponent>(playerEntity))
-                {
-                    continue;
-                }
-
-                var playerPos = EntityManager.GetComponent<TransformComponent>(playerEntity).WorldPosition;
-                var delta = epicenter.ToMapPos(EntityManager) - playerPos;
-
-                //Change if zero. Will result in a NaN later breaking camera shake if not changed
-                if (delta.EqualsApprox((0.0f, 0.0f)))
-                    delta = EpicenterDistance;
-
-                var distance = delta.LengthSquared;
-                var effect = 10 * (1 / (1 + distance));
-                if (effect > 0.01f)
-                {
-                    var kick = -delta.Normalized * effect;
-                    _cameraRecoil.KickCamera(player.AttachedEntity.Value, kick);
-                }
-            }
+            tileLists.Add(grid.Grid.Index, grid.TileLists);
         }
 
-        /// <summary>
-        /// Damage entities inside the range. The damage depends on a discrete
-        /// damage bracket [light, heavy, devastation] and the distance from the epicenter
-        /// </summary>
-        /// <returns>
-        /// A dictionary of coordinates relative to the parents of every grid of entities that survived the explosion,
-        /// have an airtight component and are currently blocking air. Like a wall.
-        /// </returns>
-        private void DamageEntitiesInRange(
-            EntityCoordinates epicenter,
-            Box2 boundingBox,
-            float devastationRange,
-            float heavyRange,
-            float maxRange,
-            MapId mapId)
+        return new ExplosionEvent(_explosionCounter, epicenter, id, iterationIntensity, spaceTiles, tileLists, spaceMatrix);
+    }
+
+    private void CameraShake(float range, MapCoordinates epicenter, float totalIntensity)
+    {
+        var players = Filter.Empty();
+        players.AddInRange(epicenter, range, _playerManager, EntityManager);
+
+        foreach (var player in players.Recipients)
         {
-            var entitiesInRange = _entityLookup.GetEntitiesInRange(mapId, boundingBox, 0).ToList();
+            if (player.AttachedEntity is not EntityUid uid)
+                continue;
 
-            var impassableEntities = new List<(EntityUid, float)>();
-            var nonImpassableEntities = new List<(EntityUid, float)>();
-            // TODO: Given this seems to rely on physics it should just query directly like everything else.
+            var playerPos = Transform(player.AttachedEntity!.Value).WorldPosition;
+            var delta = epicenter.Position - playerPos;
 
-            // The entities are paired with their distance to the epicenter
-            // and splitted into two lists based on if they are Impassable or not
-            foreach (var entity in entitiesInRange)
-            {
-                if (Deleted(entity) || entity.IsInContainer())
-                {
-                    continue;
-                }
+            if (delta.EqualsApprox(Vector2.Zero))
+                delta = new(0.01f, 0);
 
-                if (!EntityManager.GetComponent<TransformComponent>(entity).Coordinates.TryDistance(EntityManager, epicenter, out var distance) ||
-                    distance > maxRange)
-                {
-                    continue;
-                }
-
-                if (!EntityManager.TryGetComponent(entity, out FixturesComponent? fixturesComp) || fixturesComp.Fixtures.Count < 1)
-                {
-                    continue;
-                }
-
-                if (!EntityManager.TryGetComponent(entity, out PhysicsComponent? body))
-                {
-                    continue;
-                }
-
-                if ((body.CollisionLayer & (int) CollisionGroup.Impassable) != 0)
-                {
-                    impassableEntities.Add((entity, distance));
-                }
-                else
-                {
-                    nonImpassableEntities.Add((entity, distance));
-                }
-            }
-
-            // The Impassable entities are sorted in descending order
-            // Entities closer to the epicenter are first
-            impassableEntities.Sort((x, y) => x.Item2.CompareTo(y.Item2));
-
-            // Impassable entities are handled first. If they are damaged enough, they are destroyed and they may
-            // be able to spawn a new entity. I.e Wall -> Girder.
-            // Girder has a tag ExplosivePassable, and the predicate make it so the entities with this tag are ignored
-            var epicenterMapPos = epicenter.ToMap(EntityManager);
-            foreach (var (entity, distance) in impassableEntities)
-            {
-                if (!_interactionSystem.InRangeUnobstructed(epicenterMapPos, entity, maxRange, predicate: IgnoreExplosivePassable))
-                {
-                    continue;
-                }
-
-                _acts.HandleExplosion(epicenter, entity, CalculateSeverity(distance, devastationRange, heavyRange));
-            }
-
-            // Impassable entities were handled first so NonImpassable entities have a bigger chance to get hit. As now
-            // there are probably more ExplosivePassable entities around
-            foreach (var (entity, distance) in nonImpassableEntities)
-            {
-                if (!_interactionSystem.InRangeUnobstructed(epicenterMapPos, entity, maxRange, predicate: IgnoreExplosivePassable))
-                {
-                    continue;
-                }
-
-                _acts.HandleExplosion(epicenter, entity, CalculateSeverity(distance, devastationRange, heavyRange));
-            }
-        }
-
-        /// <summary>
-        /// Damage tiles inside the range. The type of tile can change depending on a discrete
-        /// damage bracket [light, heavy, devastation], the distance from the epicenter and
-        /// a probability bracket [<see cref="LightBreakChance"/>, <see cref="HeavyBreakChance"/>, 1.0].
-        /// </summary>
-        ///
-        private void DamageTilesInRange(EntityCoordinates epicenter,
-                                               GridId gridId,
-                                               Box2 boundingBox,
-                                               float devastationRange,
-                                               float heaveyRange,
-                                               float maxRange)
-        {
-            if (!_maps.TryGetGrid(gridId, out var mapGrid))
-            {
-                return;
-            }
-
-            if (!EntityManager.EntityExists(mapGrid.GridEntityId))
-            {
-                return;
-            }
-
-            var tilesInGridAndCircle = mapGrid.GetTilesIntersecting(boundingBox);
-            var epicenterMapPos = epicenter.ToMap(EntityManager);
-
-            foreach (var tile in tilesInGridAndCircle)
-            {
-                var tileLoc = mapGrid.GridTileToLocal(tile.GridIndices);
-                if (!tileLoc.TryDistance(EntityManager, epicenter, out var distance) ||
-                    distance > maxRange)
-                {
-                    continue;
-                }
-
-                if (tile.IsBlockedTurf(false))
-                {
-                    continue;
-                }
-
-                if (!_interactionSystem.InRangeUnobstructed(tileLoc.ToMap(EntityManager), epicenterMapPos, maxRange, predicate: IgnoreExplosivePassable))
-                {
-                    continue;
-                }
-
-                var tileDef = (ContentTileDefinition) _tiles[tile.Tile.TypeId];
-                var baseTurfs = tileDef.BaseTurfs;
-                if (baseTurfs.Count == 0)
-                {
-                    continue;
-                }
-
-                var zeroTile = new Tile(_tiles[baseTurfs[0]].TileId);
-                var previousTile = new Tile(_tiles[baseTurfs[^1]].TileId);
-
-                var severity = CalculateSeverity(distance, devastationRange, heaveyRange);
-
-                switch (severity)
-                {
-                    case ExplosionSeverity.Light:
-                        if (!previousTile.IsEmpty && _random.Prob(LightBreakChance))
-                        {
-                            mapGrid.SetTile(tileLoc, previousTile);
-                        }
-                        break;
-                    case ExplosionSeverity.Heavy:
-                        if (!previousTile.IsEmpty && _random.Prob(HeavyBreakChance))
-                        {
-                            mapGrid.SetTile(tileLoc, previousTile);
-                        }
-                        break;
-                    case ExplosionSeverity.Destruction:
-                        mapGrid.SetTile(tileLoc, zeroTile);
-                        break;
-                }
-            }
-        }
-
-        private void FlashInRange(EntityCoordinates epicenter, float flashRange)
-        {
-            if (flashRange > 0)
-            {
-                var time = _timing.CurTime;
-                var message = new EffectSystemMessage
-                {
-                    EffectSprite = "Effects/explosion.rsi",
-                    RsiState = "explosionfast",
-                    Born = time,
-                    DeathTime = time + TimeSpan.FromSeconds(5),
-                    Size = new Vector2(flashRange / 2, flashRange / 2),
-                    Coordinates = epicenter,
-                    Rotation = 0f,
-                    ColorDelta = new Vector4(0, 0, 0, -1500f),
-                    Color = Vector4.Multiply(new Vector4(255, 255, 255, 750), 0.5f),
-                    Shaded = false
-                };
-
-                _effects.CreateParticle(message);
-            }
-        }
-
-        public void SpawnExplosion(
-            EntityUid entity,
-            int devastationRange = 0,
-            int heavyImpactRange = 0,
-            int lightImpactRange = 0,
-            int flashRange = 0,
-            EntityUid? user = null,
-            ExplosiveComponent? explosive = null,
-            TransformComponent? transform = null)
-        {
-            if (!Resolve(entity, ref transform))
-            {
-                return;
-            }
-
-            Resolve(entity, ref explosive, false);
-
-            if (explosive is { Exploding: false })
-            {
-                _triggers.Explode(entity, explosive, user);
-            }
-            else
-            {
-                while (EntityManager.EntityExists(entity) && entity.TryGetContainer(out var container))
-                {
-                    entity = container.Owner;
-                }
-
-                if (!EntityManager.TryGetComponent(entity, out transform))
-                {
-                    return;
-                }
-
-                var epicenter = transform.Coordinates;
-
-                SpawnExplosion(epicenter, devastationRange, heavyImpactRange, lightImpactRange, flashRange, entity, user);
-            }
-        }
-
-        public void SpawnExplosion(
-            EntityCoordinates epicenter,
-            int devastationRange = 0,
-            int heavyImpactRange = 0,
-            int lightImpactRange = 0,
-            int flashRange = 0,
-            EntityUid? entity = null,
-            EntityUid? user = null)
-        {
-            var mapId = epicenter.GetMapId(EntityManager);
-            if (mapId == MapId.Nullspace)
-            {
-                return;
-            }
-
-            // logging
-            var range = $"{devastationRange}/{heavyImpactRange}/{lightImpactRange}/{flashRange}";
-            if (entity == null || !entity.Value.IsValid())
-            {
-                _logSystem.Add(LogType.Explosion, LogImpact.High, $"Explosion spawned at {epicenter:coordinates} with range {range}");
-            }
-            else if (user == null || !user.Value.IsValid())
-            {
-                _logSystem.Add(LogType.Explosion, LogImpact.High,
-                    $"{ToPrettyString(entity.Value):entity} exploded at {epicenter:coordinates} with range {range}");
-            }
-            else
-            {
-                _logSystem.Add(LogType.Explosion, LogImpact.High,
-                    $"{ToPrettyString(user.Value):user} caused {ToPrettyString(entity.Value):entity} to explode at {epicenter:coordinates} with range {range}");
-            }
-
-            var maxRange = MathHelper.Max(devastationRange, heavyImpactRange, lightImpactRange, 0);
-            var epicenterMapPos = epicenter.ToMapPos(EntityManager);
-            var boundingBox = new Box2(epicenterMapPos - new Vector2(maxRange, maxRange),
-                epicenterMapPos + new Vector2(maxRange, maxRange));
-
-            SoundSystem.Play(Filter.Broadcast(), ExplosionSound.GetSound(), epicenter);
-            DamageEntitiesInRange(epicenter, boundingBox, devastationRange, heavyImpactRange, maxRange, mapId);
-
-            var mapGridsNear = _maps.FindGridsIntersecting(mapId, boundingBox);
-
-            foreach (var gridId in mapGridsNear)
-            {
-                DamageTilesInRange(epicenter, gridId.Index, boundingBox, devastationRange, heavyImpactRange, maxRange);
-            }
-
-            CameraShakeInRange(epicenter, maxRange);
-            FlashInRange(epicenter, flashRange);
+            var distance = delta.Length;
+            var effect = 5 * MathF.Pow(totalIntensity, 0.5f) * (1 - distance / range);
+            if (effect > 0.01f)
+                _recoilSystem.KickCamera(uid, -delta.Normalized * effect);
         }
     }
 }
diff --git a/Content.Server/Explosion/EntitySystems/ExplosionSystem.cvars.cs b/Content.Server/Explosion/EntitySystems/ExplosionSystem.cvars.cs
new file mode 100644
index 0000000000..4dd2f8e477
--- /dev/null
+++ b/Content.Server/Explosion/EntitySystems/ExplosionSystem.cvars.cs
@@ -0,0 +1,44 @@
+using Content.Shared.CCVar;
+
+namespace Content.Server.Explosion.EntitySystems;
+
+public sealed partial class ExplosionSystem : EntitySystem
+{
+    public int MaxIterations { get; private set; }
+    public int MaxArea { get; private set; }
+    public float MaxProcessingTime { get; private set; }
+    public int TilesPerTick { get; private set; }
+    public int ThrowLimit { get; private set; }
+    public bool SleepNodeSys { get; private set; }
+    public bool IncrementalTileBreaking { get; private set; }
+
+    private void SubscribeCvars()
+    {
+        _cfg.OnValueChanged(CCVars.ExplosionTilesPerTick, SetTilesPerTick, true);
+        _cfg.OnValueChanged(CCVars.ExplosionThrowLimit, SetThrowLimit, true);
+        _cfg.OnValueChanged(CCVars.ExplosionSleepNodeSys, SetSleepNodeSys, true);
+        _cfg.OnValueChanged(CCVars.ExplosionMaxArea, SetMaxArea, true);
+        _cfg.OnValueChanged(CCVars.ExplosionMaxIterations, SetMaxIterations, true);
+        _cfg.OnValueChanged(CCVars.ExplosionMaxProcessingTime, SetMaxProcessingTime, true);
+        _cfg.OnValueChanged(CCVars.ExplosionIncrementalTileBreaking, SetIncrementalTileBreaking, true);
+    }
+
+    private void UnsubscribeCvars()
+    {
+        _cfg.UnsubValueChanged(CCVars.ExplosionTilesPerTick, SetTilesPerTick);
+        _cfg.UnsubValueChanged(CCVars.ExplosionThrowLimit, SetThrowLimit);
+        _cfg.UnsubValueChanged(CCVars.ExplosionSleepNodeSys, SetSleepNodeSys);
+        _cfg.UnsubValueChanged(CCVars.ExplosionMaxArea, SetMaxArea);
+        _cfg.UnsubValueChanged(CCVars.ExplosionMaxIterations, SetMaxIterations);
+        _cfg.UnsubValueChanged(CCVars.ExplosionMaxProcessingTime, SetMaxProcessingTime);
+        _cfg.UnsubValueChanged(CCVars.ExplosionIncrementalTileBreaking, SetIncrementalTileBreaking);
+    }
+
+    private void SetTilesPerTick(int value) => TilesPerTick = value;
+    private void SetThrowLimit(int value) => ThrowLimit = value;
+    private void SetSleepNodeSys(bool value) => SleepNodeSys = value;
+    private void SetMaxArea(int value) => MaxArea = value;
+    private void SetMaxIterations(int value) => MaxIterations = value;
+    private void SetMaxProcessingTime(float value) => MaxProcessingTime = value;
+    private void SetIncrementalTileBreaking(bool value) => IncrementalTileBreaking = value;
+}
diff --git a/Content.Server/Explosion/EntitySystems/GridExplosion.cs b/Content.Server/Explosion/EntitySystems/GridExplosion.cs
new file mode 100644
index 0000000000..52650c28b2
--- /dev/null
+++ b/Content.Server/Explosion/EntitySystems/GridExplosion.cs
@@ -0,0 +1,311 @@
+using Content.Shared.Atmos;
+using Robust.Shared.Map;
+
+namespace Content.Server.Explosion.EntitySystems;
+
+internal sealed class GridExplosion : TileExplosion
+{
+    public IMapGrid Grid;
+    private bool _needToTransform = false;
+
+    private Matrix3 _matrix = Matrix3.Identity;
+    private Vector2 _offset;
+
+    private HashSet<Vector2i> _processedSpaceTiles = new();
+
+    // Tiles which neighbor an exploding tile, but have not yet had the explosion spread to them due to an
+    // airtight entity on the exploding tile that prevents the explosion from spreading in that direction. These
+    // will be added as a neighbor after some delay, once the explosion on that tile is sufficiently strong to
+    // destroy the airtight entity.
+    private Dictionary<int, List<(Vector2i, AtmosDirection)>> _delayedNeighbors = new();
+
+    private Dictionary<Vector2i, TileData> _airtightMap;
+
+    private float _maxIntensity;
+    private float _intensityStepSize;
+    private string _typeID;
+
+    /// <summary>
+    ///     Tiles on this grid that are not actually on this grid.... uhh ... yeah.... look its faster than checking
+    ///     atmos directions every iteration.
+    /// </summary>
+    private HashSet<Vector2i> _spaceTiles = new();
+
+    public HashSet<Vector2i> SpaceJump = new();
+
+    private Dictionary<Vector2i, AtmosDirection> _edgeTiles;
+
+    public GridExplosion(
+        IMapGrid grid,
+        Dictionary<Vector2i, TileData> airtightMap,
+        float maxIntensity,
+        float intensityStepSize,
+        string typeID,
+        Dictionary<Vector2i, AtmosDirection> edgeTiles,
+        GridId? referenceGrid,
+        Matrix3 spaceMatrix,
+        Angle spaceAngle)
+    {
+        Grid = grid;
+        _airtightMap = airtightMap;
+        _maxIntensity = maxIntensity;
+        _intensityStepSize = intensityStepSize;
+        _typeID = typeID;
+        _edgeTiles = edgeTiles;
+
+        // initialise SpaceTiles
+        foreach (var (tile, dir) in _edgeTiles)
+        {
+            for (var i = 0; i < Atmospherics.Directions; i++)
+            {
+                var direction = (AtmosDirection) (1 << i);
+                if (dir.IsFlagSet(direction))
+                    _spaceTiles.Add(tile.Offset(direction));
+            }
+        }
+
+        // TODO EXPLOSIONS fix this shit.
+        foreach (var tile in _edgeTiles.Keys)
+        {
+            foreach (var diagTile in ExplosionSystem.GetDiagonalNeighbors(tile))
+            {
+                if (_spaceTiles.Contains(diagTile))
+                    continue;
+
+                if (!Grid.TryGetTileRef(diagTile, out var tileRef) || tileRef.Tile.IsEmpty)
+                    _spaceTiles.Add(diagTile);
+            }
+        }
+
+        if (referenceGrid == Grid.Index)
+            return;
+
+        _needToTransform = true;
+        var transform = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(Grid.GridEntityId);
+        var size = (float) Grid.TileSize;
+
+        _matrix.R0C2 = size / 2;
+        _matrix.R1C2 = size / 2;
+        _matrix *= transform.WorldMatrix * Matrix3.Invert(spaceMatrix);
+        var relativeAngle = transform.WorldRotation - spaceAngle;
+        _offset = relativeAngle.RotateVec((size / 4, size / 4));
+    }
+
+    public int AddNewTiles(int iteration, HashSet<Vector2i>? gridJump)
+    {
+        SpaceJump = new();
+        NewTiles = new();
+        NewBlockedTiles = new();
+
+        // Mark tiles as entered if any were just freed due to airtight/explosion blockers being destroyed.
+        if (FreedTileLists.TryGetValue(iteration, out var freed))
+        {
+            freed.ExceptWith(EnteredBlockedTiles);
+            EnteredBlockedTiles.UnionWith(freed);
+            NewFreedTiles = freed;
+        }
+        else
+        {
+            NewFreedTiles = new();
+            FreedTileLists[iteration] = NewFreedTiles;
+        }
+
+        // Add adjacent tiles
+        if (TileLists.TryGetValue(iteration - 2, out var adjacent))
+            AddNewAdjacentTiles(iteration, adjacent, false);
+        if (FreedTileLists.TryGetValue(iteration - 2, out var delayedAdjacent))
+            AddNewAdjacentTiles(iteration, delayedAdjacent, true);
+
+        // Add diagonal tiles
+        if (TileLists.TryGetValue(iteration - 3, out var diagonal))
+            AddNewDiagonalTiles(iteration, diagonal, false);
+        if (FreedTileLists.TryGetValue(iteration - 3, out var delayedDiagonal))
+            AddNewDiagonalTiles(iteration, delayedDiagonal, true);
+
+        // Add delayed tiles
+        AddDelayedNeighbors(iteration);
+
+        // Tiles from Spaaaace
+        if (gridJump != null)
+        {
+            foreach (var tile in gridJump)
+            {
+                ProcessNewTile(iteration, tile, AtmosDirection.Invalid);
+            }
+        }
+
+        // Store new tiles
+        if (NewTiles.Count != 0)
+            TileLists[iteration] = NewTiles;
+        if (NewBlockedTiles.Count != 0)
+            BlockedTileLists[iteration] = NewBlockedTiles;
+
+        return NewTiles.Count + NewBlockedTiles.Count;
+    }
+
+    protected override void ProcessNewTile(int iteration, Vector2i tile, AtmosDirection entryDirections)
+    {
+        // Is there an airtight blocker on this tile?
+        if (!_airtightMap.TryGetValue(tile, out var tileData))
+        {
+            // No blocker. Ezy. Though maybe this a space tile?
+
+            if (_spaceTiles.Contains(tile))
+                JumpToSpace(tile);
+            else if (ProcessedTiles.Add(tile))
+                NewTiles.Add(tile);
+
+            return;
+        }
+
+        // If the explosion is entering this new tile from an unblocked direction, we add it directly. Note that because
+        // for space -> grid jumps, we don't have a direction from which the explosion came, we will only assume it is
+        // unblocked if all space-facing directions are unblocked. Though this could eventually be done properly.
+
+        bool blocked;
+        var blockedDirections = tileData.BlockedDirections;
+        if (entryDirections == AtmosDirection.Invalid) // is coming from space?
+        {
+            var spaceDirections = _edgeTiles[tile];
+            blocked = (blockedDirections & spaceDirections) != 0; // at least one space direction is blocked.
+        }
+        else
+            blocked = (blockedDirections & entryDirections) == entryDirections;// **ALL** entry directions are blocked
+
+        if (blocked)
+        {
+            // was this tile already entered from some other direction?
+            if (EnteredBlockedTiles.Contains(tile))
+                return;
+
+            // Did the explosion already attempt to enter this tile from some other direction? 
+            if (!UnenteredBlockedTiles.Add(tile))
+                return;
+
+            NewBlockedTiles.Add(tile);
+
+            // At what explosion iteration would this blocker be destroyed?
+
+            if (!tileData.ExplosionTolerance.TryGetValue(_typeID, out var sealIntegrity))
+                sealIntegrity = float.MaxValue; // indestructible airtight entity
+
+            var clearIteration = iteration + (int) MathF.Ceiling(sealIntegrity / _intensityStepSize);
+            if (FreedTileLists.TryGetValue(clearIteration, out var list))
+                list.Add(tile);
+            else
+                FreedTileLists[clearIteration] = new() { tile };
+
+            return;
+        }
+
+        // was this tile already entered from some other direction?
+        if (!EnteredBlockedTiles.Add(tile))
+            return;
+
+        // Did the explosion already attempt to enter this tile from some other direction? 
+        if (UnenteredBlockedTiles.Contains(tile))
+        {
+            NewFreedTiles.Add(tile);
+            return;
+        }
+
+        // This is a completely new tile, and we just so happened to enter it from an unblocked direction.
+        NewTiles.Add(tile);
+    }
+
+    private void JumpToSpace(Vector2i tile)
+    {
+        // Did we already jump/process this tile?
+        if (!_processedSpaceTiles.Add(tile))
+            return;
+
+        if (!_needToTransform)
+        {
+            SpaceJump.Add(tile);
+            return;
+        }
+
+        var center = _matrix.Transform(tile);
+        SpaceJump.Add(new((int) MathF.Floor(center.X + _offset.X), (int) MathF.Floor(center.Y + _offset.Y)));
+        SpaceJump.Add(new((int) MathF.Floor(center.X - _offset.Y), (int) MathF.Floor(center.Y + _offset.X)));
+        SpaceJump.Add(new((int) MathF.Floor(center.X - _offset.X), (int) MathF.Floor(center.Y - _offset.Y)));
+        SpaceJump.Add(new((int) MathF.Floor(center.X + _offset.Y), (int) MathF.Floor(center.Y - _offset.X)));
+    }
+
+    private void AddDelayedNeighbors(int iteration)
+    {
+        if (!_delayedNeighbors.TryGetValue(iteration, out var delayed))
+            return;
+
+        foreach (var (tile, direction) in delayed)
+        {
+            ProcessNewTile(iteration, tile, direction);
+        }
+
+        _delayedNeighbors.Remove(iteration);
+    }
+
+    // Gets the tiles that are directly adjacent to other tiles. If a currently exploding tile has an airtight entity
+    // that blocks the explosion from propagating in some direction, those tiles are added to a list of delayed tiles
+    // that will be added to the explosion in some future iteration.
+    private void AddNewAdjacentTiles(int iteration, IEnumerable<Vector2i> tiles, bool ignoreTileBlockers = false)
+    {
+        foreach (var tile in tiles)
+        {
+            var blockedDirections = AtmosDirection.Invalid;
+            float sealIntegrity = 0;
+
+            // Note that if (grid, tile) is not a valid key, then airtight.BlockedDirections will default to 0 (no blocked directions)
+            if (_airtightMap.TryGetValue(tile, out var tileData))
+            {
+                blockedDirections = tileData.BlockedDirections;
+                if (!tileData.ExplosionTolerance.TryGetValue(_typeID, out sealIntegrity))
+                    sealIntegrity = float.MaxValue; // indestructible airtight entity
+            }
+
+            // First, yield any neighboring tiles that are not blocked by airtight entities on this tile
+            for (var i = 0; i < Atmospherics.Directions; i++)
+            {
+                var direction = (AtmosDirection) (1 << i);
+                if (ignoreTileBlockers || !blockedDirections.IsFlagSet(direction))
+                {
+                    ProcessNewTile(iteration, tile.Offset(direction), direction.GetOpposite());
+                }
+            }
+
+            // If there are no blocked directions, we are done with this tile.
+            if (ignoreTileBlockers || blockedDirections == AtmosDirection.Invalid)
+                continue;
+
+            // This tile has one or more airtight entities anchored to it blocking the explosion from traveling in
+            // some directions. First, check whether this blocker can even be destroyed by this explosion?
+            if (sealIntegrity > _maxIntensity || float.IsNaN(sealIntegrity))
+                continue;
+
+            // At what explosion iteration would this blocker be destroyed?
+            var clearIteration = iteration + (int) MathF.Ceiling(sealIntegrity / _intensityStepSize);
+
+            // Get the delayed neighbours list
+            if (!_delayedNeighbors.TryGetValue(clearIteration, out var list))
+            {
+                list = new();
+                _delayedNeighbors[clearIteration] = list;
+            }
+
+            // Check which directions are blocked, and add them to the list.
+            for (var i = 0; i < Atmospherics.Directions; i++)
+            {
+                var direction = (AtmosDirection) (1 << i);
+                if (blockedDirections.IsFlagSet(direction))
+                {
+                    list.Add((tile.Offset(direction), direction.GetOpposite()));
+                }
+            }
+        }
+    }
+
+    protected override AtmosDirection GetUnblockedDirectionOrAll(Vector2i tile)
+    {
+        return ~_airtightMap.GetValueOrDefault(tile).BlockedDirections;
+    }
+}
diff --git a/Content.Server/Explosion/EntitySystems/SpaceExplosion.cs b/Content.Server/Explosion/EntitySystems/SpaceExplosion.cs
new file mode 100644
index 0000000000..d6d8e5efb1
--- /dev/null
+++ b/Content.Server/Explosion/EntitySystems/SpaceExplosion.cs
@@ -0,0 +1,157 @@
+using Content.Shared.Atmos;
+using Robust.Shared.Map;
+
+namespace Content.Server.Explosion.EntitySystems;
+
+internal sealed class SpaceExplosion : TileExplosion
+{
+    /// <summary>
+    ///     The keys of this dictionary correspond to space tiles that intersect a grid. The values have information
+    ///     about what grid (which could be more than one), and in what directions the space-based explosion is allowed
+    ///     to propagate from this tile.
+    /// </summary>
+    private Dictionary<Vector2i, GridBlockData> _gridBlockMap;
+
+    /// <summary>
+    ///     After every iteration, this data set will store all the grid-tiles that were reached as a result of the
+    ///     explosion expanding in space.
+    /// </summary>
+    internal Dictionary<GridId, HashSet<Vector2i>> GridJump = new();
+
+    internal SpaceExplosion(ExplosionSystem system, MapId targetMap, GridId? referenceGrid, List<GridId> localGrids)
+    {
+        (_gridBlockMap, var tileSize) = system.TransformGridEdges(targetMap, referenceGrid, localGrids);
+        system.GetUnblockedDirections(_gridBlockMap, tileSize);
+    }
+
+    internal int AddNewTiles(int iteration, HashSet<Vector2i> inputSpaceTiles)
+    {
+        NewTiles = new();
+        NewBlockedTiles = new();
+        NewFreedTiles = new();
+        GridJump = new();
+
+        // Adjacent tiles
+        if (TileLists.TryGetValue(iteration - 2, out var adjacent))
+            AddNewAdjacentTiles(iteration, adjacent);
+        if (FreedTileLists.TryGetValue((iteration - 2) % 3, out var delayedAdjacent))
+            AddNewAdjacentTiles(iteration, delayedAdjacent);
+
+        // Diagonal tiles
+        if (TileLists.TryGetValue(iteration - 3, out var diagonal))
+            AddNewDiagonalTiles(iteration, diagonal);
+        if (FreedTileLists.TryGetValue((iteration - 3) % 3, out var delayedDiagonal))
+            AddNewDiagonalTiles(iteration, delayedDiagonal);
+
+        // Tiles entering space from some grid.
+        foreach (var tile in inputSpaceTiles)
+        {
+            ProcessNewTile(iteration, tile, AtmosDirection.All);
+        }
+
+        // Store new tiles
+        if (NewTiles.Count != 0)
+            TileLists[iteration] = NewTiles;
+        if (NewBlockedTiles.Count != 0)
+            BlockedTileLists[iteration] = NewBlockedTiles;
+        FreedTileLists[iteration % 3] = NewFreedTiles;
+
+        // return new tile count
+        return NewTiles.Count + NewBlockedTiles.Count;
+    }
+
+    private void JumpToGrid(GridBlockData blocker)
+    {
+        foreach (var edge in blocker.BlockingGridEdges)
+        {
+            if (edge.Grid == null) continue;
+
+            if (!GridJump.TryGetValue(edge.Grid.Value, out var set))
+            {
+                set = new();
+                GridJump[edge.Grid.Value] = set;
+            }
+
+            set.Add(edge.Tile);
+        }
+    }
+
+    private void AddNewAdjacentTiles(int iteration, IEnumerable<Vector2i> tiles)
+    {
+        foreach (var tile in tiles)
+        {
+            var unblockedDirections = GetUnblockedDirectionOrAll(tile);
+
+            if (unblockedDirections == AtmosDirection.Invalid)
+                continue;
+
+            for (var i = 0; i < Atmospherics.Directions; i++)
+            {
+                var direction = (AtmosDirection) (1 << i);
+
+                if (!unblockedDirections.IsFlagSet(direction))
+                    continue; // explosion cannot propagate in this direction. Ever.
+
+                ProcessNewTile(iteration, tile.Offset(direction), direction.GetOpposite());
+            }
+        }
+    }
+
+    internal override void InitTile(Vector2i initialTile)
+    {
+        base.InitTile(initialTile);
+
+        // It might be the case that the initial space-explosion tile actually overlaps on a grid. In that case we
+        // need to manually add it to the `spaceToGridTiles` dictionary. This would normally be done automatically
+        // during the neighbor finding steps.
+        if (_gridBlockMap.TryGetValue(initialTile, out var blocker))
+            JumpToGrid(blocker);
+    }
+
+    protected override void ProcessNewTile(int iteration, Vector2i tile, AtmosDirection entryDirection)
+    {
+        if (!_gridBlockMap.TryGetValue(tile, out var blocker))
+        {
+            // this tile does not intersect any grids. Add it (if its new) and continue.
+            if (ProcessedTiles.Add(tile))
+                NewTiles.Add(tile);
+            return;
+        }
+
+        // Is the entry to this tile blocked?
+        if ((blocker.UnblockedDirections & entryDirection) == 0)
+        {
+            // was this tile already entered from some other direction?
+            if (EnteredBlockedTiles.Contains(tile))
+                return;
+
+            // Did the explosion already attempt to enter this tile from some other direction? 
+            if (!UnenteredBlockedTiles.Add(tile))
+                return;
+
+            // First time the explosion is reaching this tile.
+            NewBlockedTiles.Add(tile);
+            JumpToGrid(blocker);
+        }
+
+        // Was this tile already entered?
+        if (!EnteredBlockedTiles.Add(tile))
+            return;
+
+        // Did the explosion already attempt to enter this tile from some other direction? 
+        if (UnenteredBlockedTiles.Contains(tile))
+        {
+            NewFreedTiles.Add(tile);
+            return;
+        }
+
+        // This is a completely new tile, and we just so happened to enter it from an unblocked direction.
+        NewTiles.Add(tile);
+        JumpToGrid(blocker);
+    }
+
+    protected override AtmosDirection GetUnblockedDirectionOrAll(Vector2i tile)
+    {
+        return _gridBlockMap.TryGetValue(tile, out var blocker) ? blocker.UnblockedDirections : AtmosDirection.All;
+    }
+}
diff --git a/Content.Server/Explosion/EntitySystems/TileExplosion.cs b/Content.Server/Explosion/EntitySystems/TileExplosion.cs
new file mode 100644
index 0000000000..4050434d1b
--- /dev/null
+++ b/Content.Server/Explosion/EntitySystems/TileExplosion.cs
@@ -0,0 +1,116 @@
+using Content.Shared.Atmos;
+
+namespace Content.Server.Explosion.EntitySystems;
+
+/// <summary>
+///     This is the base class for <see cref="SpaceExplosion"/> and <see cref="GridExplosion"/>. It just exists to avoid some code duplication, because those classes are generally quite distinct.
+/// </summary>
+internal abstract class TileExplosion
+{
+    // Main tile data sets, mapping iterations onto tile lists
+    internal Dictionary<int, List<Vector2i>> TileLists = new();
+    protected Dictionary<int, List<Vector2i>> BlockedTileLists = new();
+    protected Dictionary<int, HashSet<Vector2i>> FreedTileLists = new();
+
+    // The new tile lists added each iteration. I **could** just pass these along to every function, but IMO it is more
+    // readable if they are just private variables.
+    protected List<Vector2i> NewTiles = default!;
+    protected List<Vector2i> NewBlockedTiles = default!;
+    protected HashSet<Vector2i> NewFreedTiles = default!;
+
+    // HashSets used to ensure uniqueness of tiles. Prevents the explosion from looping back in on itself.
+    protected HashSet<Vector2i> ProcessedTiles = new();
+    protected HashSet<Vector2i> UnenteredBlockedTiles = new();
+    protected HashSet<Vector2i> EnteredBlockedTiles = new();
+
+    internal virtual void InitTile(Vector2i initialTile)
+    {
+        ProcessedTiles.Add(initialTile);
+        TileLists[0] = new() { initialTile };
+    }
+
+    protected abstract void ProcessNewTile(int iteration, Vector2i tile, AtmosDirection entryDirections);
+
+    protected abstract AtmosDirection GetUnblockedDirectionOrAll(Vector2i tile);
+
+    protected void AddNewDiagonalTiles(int iteration, IEnumerable<Vector2i> tiles, bool ignoreLocalBlocker = false)
+    {
+        AtmosDirection entryDirection = AtmosDirection.Invalid;
+        foreach (var tile in tiles)
+        {
+            var freeDirections = ignoreLocalBlocker ? AtmosDirection.All : GetUnblockedDirectionOrAll(tile);
+
+            // Get the free directions of the directly adjacent tiles            
+            var freeDirectionsN = GetUnblockedDirectionOrAll(tile.Offset(AtmosDirection.North));
+            var freeDirectionsE = GetUnblockedDirectionOrAll(tile.Offset(AtmosDirection.East));
+            var freeDirectionsS = GetUnblockedDirectionOrAll(tile.Offset(AtmosDirection.South));
+            var freeDirectionsW = GetUnblockedDirectionOrAll(tile.Offset(AtmosDirection.West));
+
+            // North East
+            if (freeDirections.IsFlagSet(AtmosDirection.North) && freeDirectionsN.IsFlagSet(AtmosDirection.SouthEast))
+                entryDirection |= AtmosDirection.West;
+
+            if (freeDirections.IsFlagSet(AtmosDirection.East) && freeDirectionsE.IsFlagSet(AtmosDirection.NorthWest))
+                entryDirection |= AtmosDirection.South;
+
+            if (entryDirection != AtmosDirection.Invalid)
+            {
+                ProcessNewTile(iteration, tile + (1, 1), entryDirection);
+                entryDirection = AtmosDirection.Invalid;
+            }
+
+            // North West
+            if (freeDirections.IsFlagSet(AtmosDirection.North) && freeDirectionsN.IsFlagSet(AtmosDirection.SouthWest))
+                entryDirection |= AtmosDirection.East;
+
+            if (freeDirections.IsFlagSet(AtmosDirection.West) && freeDirectionsW.IsFlagSet(AtmosDirection.NorthEast))
+                entryDirection |= AtmosDirection.West;
+
+            if (entryDirection != AtmosDirection.Invalid)
+            {
+                ProcessNewTile(iteration, tile + (-1, 1), entryDirection);
+                entryDirection = AtmosDirection.Invalid;
+            }
+
+            // South East
+            if (freeDirections.IsFlagSet(AtmosDirection.South) && freeDirectionsS.IsFlagSet(AtmosDirection.NorthEast))
+                entryDirection |= AtmosDirection.West;
+
+            if (freeDirections.IsFlagSet(AtmosDirection.East) && freeDirectionsE.IsFlagSet(AtmosDirection.SouthWest))
+                entryDirection |= AtmosDirection.North;
+
+            if (entryDirection != AtmosDirection.Invalid)
+            {
+                ProcessNewTile(iteration, tile + (1, -1), entryDirection);
+                entryDirection = AtmosDirection.Invalid;
+            }
+
+            // South West
+            if (freeDirections.IsFlagSet(AtmosDirection.South) && freeDirectionsS.IsFlagSet(AtmosDirection.NorthWest))
+                entryDirection |= AtmosDirection.West;
+
+            if (freeDirections.IsFlagSet(AtmosDirection.West) && freeDirectionsW.IsFlagSet(AtmosDirection.SouthEast))
+                entryDirection |= AtmosDirection.North;
+
+            if (entryDirection != AtmosDirection.Invalid)
+            {
+                ProcessNewTile(iteration, tile + (-1, -1), entryDirection);
+                entryDirection = AtmosDirection.Invalid;
+            }
+        }
+    }
+
+    /// <summary>
+    ///     Merge all tile lists into a single output tile list.
+    /// </summary>
+    internal void CleanUp()
+    {
+        foreach (var (iteration, blocked) in BlockedTileLists)
+        {
+            if (TileLists.TryGetValue(iteration, out var tiles))
+                tiles.AddRange(blocked);
+            else
+                TileLists[iteration] = blocked;
+        }
+    }
+}
diff --git a/Content.Server/Explosion/EntitySystems/TriggerSystem.cs b/Content.Server/Explosion/EntitySystems/TriggerSystem.cs
index b6ead70656..09fdba4329 100644
--- a/Content.Server/Explosion/EntitySystems/TriggerSystem.cs
+++ b/Content.Server/Explosion/EntitySystems/TriggerSystem.cs
@@ -65,33 +65,11 @@ namespace Content.Server.Explosion.EntitySystems
             SubscribeLocalEvent<ToggleDoorOnTriggerComponent, TriggerEvent>(HandleDoorTrigger);
         }
 
-        #region Explosions
         private void HandleExplodeTrigger(EntityUid uid, ExplodeOnTriggerComponent component, TriggerEvent args)
         {
-            if (!EntityManager.TryGetComponent(uid, out ExplosiveComponent? explosiveComponent)) return;
-
-            Explode(uid, explosiveComponent, args.User);
+            _explosions.TriggerExplosive(uid);
         }
 
-        // You really shouldn't call this directly (TODO Change that when ExplosionHelper gets changed).
-        public void Explode(EntityUid uid, ExplosiveComponent component, EntityUid? user = null)
-        {
-            if (component.Exploding)
-            {
-                return;
-            }
-
-            component.Exploding = true;
-            _explosions.SpawnExplosion(uid,
-                component.DevastationRange,
-                component.HeavyImpactRange,
-                component.LightImpactRange,
-                component.FlashRange,
-                user);
-            EntityManager.QueueDeleteEntity(uid);
-        }
-        #endregion
-
         #region Flash
         private void HandleFlashTrigger(EntityUid uid, FlashOnTriggerComponent component, TriggerEvent args)
         {
diff --git a/Content.Server/NodeContainer/EntitySystems/NodeGroupSystem.cs b/Content.Server/NodeContainer/EntitySystems/NodeGroupSystem.cs
index a620fc4e44..abf1088da0 100644
--- a/Content.Server/NodeContainer/EntitySystems/NodeGroupSystem.cs
+++ b/Content.Server/NodeContainer/EntitySystems/NodeGroupSystem.cs
@@ -50,6 +50,8 @@ namespace Content.Server.NodeContainer.EntitySystems
         private int _gen = 1;
         private int _groupNetIdCounter = 1;
 
+        public bool Snoozing = false;
+
         public override void Initialize()
         {
             base.Initialize();
@@ -138,8 +140,11 @@ namespace Content.Server.NodeContainer.EntitySystems
         {
             base.Update(frameTime);
 
-            DoGroupUpdates();
-            VisDoUpdate(frameTime);
+            if (!Snoozing)
+            {
+                DoGroupUpdates();
+                VisDoUpdate(frameTime);
+            }
         }
 
         private void DoGroupUpdates()
diff --git a/Content.Server/Nuke/NukeComponent.cs b/Content.Server/Nuke/NukeComponent.cs
index 230a86b339..aa312bec06 100644
--- a/Content.Server/Nuke/NukeComponent.cs
+++ b/Content.Server/Nuke/NukeComponent.cs
@@ -1,7 +1,9 @@
 using Content.Shared.Containers.ItemSlots;
+using Content.Shared.Explosion;
 using Content.Shared.Nuke;
 using Content.Shared.Sound;
 using Robust.Shared.Audio;
+using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom.Prototype;
 
 namespace Content.Server.Nuke
 {
@@ -36,13 +38,6 @@ namespace Content.Server.Nuke
         [DataField("diskSlot")]
         public ItemSlot DiskSlot = new();
 
-        /// <summary>
-        ///     Annihilation radius in which  all human players will be gibed
-        /// </summary>
-        [DataField("blastRadius")]
-        [ViewVariables(VVAccess.ReadWrite)]
-        public int BlastRadius = 200;
-
         /// <summary>
         ///     After this time nuke will play last alert sound
         /// </summary>
@@ -67,6 +62,48 @@ namespace Content.Server.Nuke
         [DataField("disarmSound")]
         public SoundSpecifier DisarmSound = new SoundPathSpecifier("/Audio/Misc/notice2.ogg");
 
+        // These datafields here are duplicates of those in explosive component. But I'm hesitant to use explosive
+        // component, just in case at some point, somehow, when grenade crafting added in someone manages to wire up a
+        // proximity trigger or something to the nuke and set it off prematurely. I want to make sure they MEAN to set of
+        // the nuke.
+        #region ExplosiveComponent
+        /// <summary>
+        ///     The explosion prototype. This determines the damage types, the tile-break chance, and some visual
+        ///     information (e.g., the light that the explosion gives off).
+        /// </summary>
+        [ViewVariables(VVAccess.ReadWrite)]
+        [DataField("explosionType", required: true, customTypeSerializer: typeof(PrototypeIdSerializer<ExplosionPrototype>))]
+        public string ExplosionType = default!;
+
+        /// <summary>
+        ///     The maximum intensity the explosion can have on a single time. This limits the maximum damage and tile
+        ///     break chance the explosion can achieve at any given location.
+        /// </summary>
+        [ViewVariables(VVAccess.ReadWrite)]
+        [DataField("maxIntensity")]
+        public float MaxIntensity = 100;
+
+        /// <summary>
+        ///     How quickly the intensity drops off as you move away from the epicenter.
+        /// </summary>
+        [ViewVariables(VVAccess.ReadWrite)]
+        [DataField("intensitySlope")]
+        public float IntensitySlope = 5;
+
+        /// <summary>
+        ///     The total intensity of this explosion. The radius of the explosion scales like the cube root of this
+        ///     number (see <see cref="ExplosionSystem.RadiusToIntensity"/>).
+        /// </summary>
+        [ViewVariables(VVAccess.ReadWrite)]
+        [DataField("totalIntensity")]
+        public float TotalIntensity = 100000;
+
+        /// <summary>
+        ///     Avoid somehow double-triggering this explosion.
+        /// </summary>
+        public bool Exploded;
+        #endregion
+
         /// <summary>
         ///     Time until explosion in seconds.
         /// </summary>
diff --git a/Content.Server/Nuke/NukeSystem.cs b/Content.Server/Nuke/NukeSystem.cs
index 0da655b40c..2a26ac9a77 100644
--- a/Content.Server/Nuke/NukeSystem.cs
+++ b/Content.Server/Nuke/NukeSystem.cs
@@ -1,10 +1,10 @@
 using Content.Server.Chat.Managers;
 using Content.Server.Construction.Components;
 using Content.Server.Coordinates.Helpers;
+using Content.Server.Explosion.EntitySystems;
 using Content.Server.Popups;
 using Content.Server.UserInterface;
 using Content.Shared.Audio;
-using Content.Shared.Body.Components;
 using Content.Shared.Containers.ItemSlots;
 using Content.Shared.Nuke;
 using Content.Shared.Sound;
@@ -19,7 +19,7 @@ namespace Content.Server.Nuke
         [Dependency] private readonly NukeCodeSystem _codes = default!;
         [Dependency] private readonly ItemSlotsSystem _itemSlots = default!;
         [Dependency] private readonly PopupSystem _popups = default!;
-        [Dependency] private readonly EntityLookupSystem _lookup = default!;
+        [Dependency] private readonly ExplosionSystem _explosions = default!;
         [Dependency] private readonly IChatManager _chat = default!;
 
         public override void Initialize()
@@ -397,19 +397,16 @@ namespace Content.Server.Nuke
             if (!Resolve(uid, ref component, ref transform))
                 return;
 
-            // gib anyone in a blast radius
-            // its lame, but will work for now
-            var pos = transform.Coordinates;
-            var ents = _lookup.GetEntitiesInRange(pos, component.BlastRadius);
-            foreach (var ent in ents)
-            {
-                var entUid = ent;
-                if (!EntityManager.EntityExists(entUid))
-                    continue;
+            if (component.Exploded)
+                return;
 
-                if (EntityManager.TryGetComponent(entUid, out SharedBodyComponent? body))
-                    body.Gib();
-            }
+            component.Exploded = true;
+
+            _explosions.QueueExplosion(uid,
+                component.ExplosionType,
+                component.TotalIntensity,
+                component.IntensitySlope,
+                component.MaxIntensity);
 
             EntityManager.DeleteEntity(uid);
         }
diff --git a/Content.Server/Pointing/Components/RoguePointingArrowComponent.cs b/Content.Server/Pointing/Components/RoguePointingArrowComponent.cs
index f0cda35540..d633840418 100644
--- a/Content.Server/Pointing/Components/RoguePointingArrowComponent.cs
+++ b/Content.Server/Pointing/Components/RoguePointingArrowComponent.cs
@@ -1,6 +1,5 @@
 using Content.Server.Pointing.EntitySystems;
 using Content.Shared.Pointing.Components;
-using Content.Shared.Sound;
 using Robust.Shared.Analyzers;
 using Robust.Shared.GameObjects;
 using Robust.Shared.Serialization.Manager.Attributes;
@@ -26,8 +25,5 @@ namespace Content.Server.Pointing.Components
         [ViewVariables(VVAccess.ReadWrite)]
         [DataField("chasingTime")]
         public float ChasingTime = 1;
-
-        [DataField("explosionSound")]
-        public SoundSpecifier ExplosionSound = new SoundCollectionSpecifier("explosion");
     }
 }
diff --git a/Content.Server/Pointing/EntitySystems/RoguePointingSystem.cs b/Content.Server/Pointing/EntitySystems/RoguePointingSystem.cs
index 3bfea1b949..a50422daeb 100644
--- a/Content.Server/Pointing/EntitySystems/RoguePointingSystem.cs
+++ b/Content.Server/Pointing/EntitySystems/RoguePointingSystem.cs
@@ -5,7 +5,6 @@ using Content.Shared.MobState.Components;
 using Content.Shared.Pointing.Components;
 using JetBrains.Annotations;
 using Robust.Server.GameObjects;
-using Robust.Shared.Audio;
 using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
 using Robust.Shared.Maths;
@@ -19,8 +18,7 @@ namespace Content.Server.Pointing.EntitySystems
     internal sealed class RoguePointingSystem : EntitySystem
     {
         [Dependency] private readonly IRobustRandom _random = default!;
-
-        [Dependency] private readonly ExplosionSystem _explosions = default!;
+        [Dependency] private readonly ExplosionSystem _explosion = default!;
 
         public override void Initialize()
         {
@@ -103,10 +101,7 @@ namespace Content.Server.Pointing.EntitySystems
                 {
                     return;
                 }
-
-                _explosions.SpawnExplosion(uid, 0, 2, 1, 1);
-                SoundSystem.Play(Filter.Pvs(uid, entityManager: EntityManager), component.ExplosionSound.GetSound(), uid);
-
+                _explosion.QueueExplosion(uid, "Default", 50, 3, 10);
                 EntityManager.QueueDeleteEntity(uid);
             }
         }
diff --git a/Content.Server/PowerCell/PowerCellSystem.cs b/Content.Server/PowerCell/PowerCellSystem.cs
index dacbe9be0f..b0e55f1170 100644
--- a/Content.Server/PowerCell/PowerCellSystem.cs
+++ b/Content.Server/PowerCell/PowerCellSystem.cs
@@ -88,10 +88,10 @@ public sealed class PowerCellSystem : SharedPowerCellSystem
         if (!Resolve(uid, ref battery))
             return;
 
-        var heavy = (int) Math.Ceiling(Math.Sqrt(battery.CurrentCharge) / 60);
-        var light = (int) Math.Ceiling(Math.Sqrt(battery.CurrentCharge) / 30);
+        var radius = MathF.Min(5, MathF.Ceiling(MathF.Sqrt(battery.CurrentCharge) / 30));
+        battery.CurrentCharge = 0;
 
-        _explosionSystem.SpawnExplosion(uid, 0, heavy, light, light * 2);
+        _explosionSystem.TriggerExplosive(uid, radius: radius);
         QueueDel(uid);
     }
 
diff --git a/Content.Server/Storage/Components/EntityStorageComponent.cs b/Content.Server/Storage/Components/EntityStorageComponent.cs
index bee8ec4a0e..23499a88d5 100644
--- a/Content.Server/Storage/Components/EntityStorageComponent.cs
+++ b/Content.Server/Storage/Components/EntityStorageComponent.cs
@@ -35,7 +35,7 @@ namespace Content.Server.Storage.Components
     [Virtual]
     [ComponentReference(typeof(IActivate))]
     [ComponentReference(typeof(IStorageComponent))]
-    public class EntityStorageComponent : Component, IActivate, IStorageComponent, IInteractUsing, IDestroyAct, IExAct
+    public class EntityStorageComponent : Component, IActivate, IStorageComponent, IInteractUsing, IDestroyAct
     {
         [Dependency] private readonly IEntityManager _entMan = default!;
 
@@ -478,24 +478,6 @@ namespace Content.Server.Storage.Components
             var entityLookup = EntitySystem.Get<EntityLookupSystem>();
             return entityLookup.GetEntitiesIntersecting(Owner, _enteringRange, LookupFlags.Approximate);
         }
-
-        void IExAct.OnExplosion(ExplosionEventArgs eventArgs)
-        {
-            if (eventArgs.Severity < ExplosionSeverity.Heavy)
-            {
-                return;
-            }
-
-            var containedEntities = Contents.ContainedEntities.ToList();
-            foreach (var entity in containedEntities)
-            {
-                var exActs = _entMan.GetComponents<IExAct>(entity).ToArray();
-                foreach (var exAct in exActs)
-                {
-                    exAct.OnExplosion(eventArgs);
-                }
-            }
-        }
     }
 
     public sealed class StorageOpenAttemptEvent : CancellableEntityEventArgs
diff --git a/Content.Server/Storage/Components/ServerStorageComponent.cs b/Content.Server/Storage/Components/ServerStorageComponent.cs
index 9d22e21338..a7f79a3477 100644
--- a/Content.Server/Storage/Components/ServerStorageComponent.cs
+++ b/Content.Server/Storage/Components/ServerStorageComponent.cs
@@ -43,7 +43,7 @@ namespace Content.Server.Storage.Components
     [ComponentReference(typeof(IActivate))]
     [ComponentReference(typeof(IStorageComponent))]
     [ComponentReference(typeof(SharedStorageComponent))]
-    public sealed class ServerStorageComponent : SharedStorageComponent, IInteractUsing, IActivate, IStorageComponent, IDestroyAct, IExAct, IAfterInteract
+    public sealed class ServerStorageComponent : SharedStorageComponent, IInteractUsing, IActivate, IStorageComponent, IDestroyAct, IAfterInteract
     {
         [Dependency] private readonly IEntityManager _entityManager = default!;
 
@@ -667,30 +667,6 @@ namespace Content.Server.Storage.Components
             }
         }
 
-        void IExAct.OnExplosion(ExplosionEventArgs eventArgs)
-        {
-            if (eventArgs.Severity < ExplosionSeverity.Heavy)
-            {
-                return;
-            }
-
-            var storedEntities = StoredEntities?.ToList();
-
-            if (storedEntities == null)
-            {
-                return;
-            }
-
-            foreach (var entity in storedEntities)
-            {
-                var exActs = _entityManager.GetComponents<IExAct>(entity).ToArray();
-                foreach (var exAct in exActs)
-                {
-                    exAct.OnExplosion(eventArgs);
-                }
-            }
-        }
-
         private void PlaySoundCollection()
         {
             SoundSystem.Play(Filter.Pvs(Owner), StorageSoundCollection.GetSound(), Owner, AudioParams.Default);
diff --git a/Content.Shared/Acts/ActSystem.cs b/Content.Shared/Acts/ActSystem.cs
index 03add7917d..7527db0678 100644
--- a/Content.Shared/Acts/ActSystem.cs
+++ b/Content.Shared/Acts/ActSystem.cs
@@ -29,21 +29,6 @@ namespace Content.Shared.Acts
         void OnBreak(BreakageEventArgs eventArgs);
     }
 
-    public interface IExAct
-    {
-        /// <summary>
-        /// Called when explosion reaches the entity
-        /// </summary>
-        void OnExplosion(ExplosionEventArgs eventArgs);
-    }
-
-    public sealed class ExplosionEventArgs : EventArgs
-    {
-        public EntityCoordinates Source { get; set; }
-        public EntityUid Target { get; set; }
-        public ExplosionSeverity Severity { get; set; }
-    }
-
     [UsedImplicitly]
     public sealed class ActSystem : EntitySystem
     {
@@ -59,23 +44,7 @@ namespace Content.Shared.Acts
                 destroyAct.OnDestroy(eventArgs);
             }
 
-            EntityManager.QueueDeleteEntity(owner);
-        }
-
-        public void HandleExplosion(EntityCoordinates source, EntityUid target, ExplosionSeverity severity)
-        {
-            var eventArgs = new ExplosionEventArgs
-            {
-                Source = source,
-                Target = target,
-                Severity = severity
-            };
-            var exActs = EntityManager.GetComponents<IExAct>(target).ToList();
-
-            foreach (var exAct in exActs)
-            {
-                exAct.OnExplosion(eventArgs);
-            }
+            QueueDel(owner);
         }
 
         public void HandleBreakage(EntityUid owner)
@@ -89,11 +58,4 @@ namespace Content.Shared.Acts
             }
         }
     }
-
-    public enum ExplosionSeverity
-    {
-        Light,
-        Heavy,
-        Destruction,
-    }
 }
diff --git a/Content.Shared/Administration/SpawnExplosionEuiMsg.cs b/Content.Shared/Administration/SpawnExplosionEuiMsg.cs
new file mode 100644
index 0000000000..f9011bda30
--- /dev/null
+++ b/Content.Shared/Administration/SpawnExplosionEuiMsg.cs
@@ -0,0 +1,52 @@
+using Content.Shared.Eui;
+using Robust.Shared.Serialization;
+using Robust.Shared.Map;
+using Content.Shared.Explosion;
+
+namespace Content.Shared.Administration;
+
+public static class SpawnExplosionEuiMsg
+{
+    [Serializable, NetSerializable]
+    public sealed class Close : EuiMessageBase { }
+
+    /// <summary>
+    ///     This message is sent to the server to request explosion preview data.
+    /// </summary>
+    [Serializable, NetSerializable]
+    public sealed class PreviewRequest : EuiMessageBase
+    {
+        public readonly MapCoordinates Epicenter;
+        public readonly string TypeId;
+        public readonly float TotalIntensity;
+        public readonly float IntensitySlope;
+        public readonly float MaxIntensity;
+
+        public PreviewRequest(MapCoordinates epicenter, string typeId, float totalIntensity, float intensitySlope, float maxIntensity)
+        {
+            Epicenter = epicenter;
+            TypeId = typeId;
+            TotalIntensity = totalIntensity;
+            IntensitySlope = intensitySlope;
+            MaxIntensity = maxIntensity;
+        }
+    }
+
+    /// <summary>
+    ///     This message is used to send explosion-preview data to the client.
+    /// </summary>
+    [Serializable, NetSerializable]
+    public sealed class PreviewData : EuiMessageBase
+    {
+        public readonly float Slope;
+        public readonly float TotalIntensity;
+        public readonly ExplosionEvent Explosion;
+
+        public PreviewData(ExplosionEvent explosion, float slope, float totalIntensity)
+        {
+            Slope = slope;
+            TotalIntensity = totalIntensity;
+            Explosion = explosion;
+        }
+    }
+}
diff --git a/Content.Shared/CCVar/CCVars.cs b/Content.Shared/CCVar/CCVars.cs
index 5e0e20d96a..202f7413a2 100644
--- a/Content.Shared/CCVar/CCVars.cs
+++ b/Content.Shared/CCVar/CCVars.cs
@@ -348,6 +348,85 @@ namespace Content.Shared.CCVar
         public static readonly CVarDef<bool> AdminAnnounceLogout =
             CVarDef.Create("admin.announce_logout", true, CVar.SERVERONLY);
 
+        /*
+         * Explosions
+         */
+
+        /// <summary>
+        ///     How many tiles the explosion system will process per tick
+        /// </summary>
+        /// <remarks>
+        ///     Setting this too high will put a large load on a single tick. Setting this  too low will lead to
+        ///     unnaturally "slow" explosions.
+        /// </remarks>
+        public static readonly CVarDef<int> ExplosionTilesPerTick =
+            CVarDef.Create("explosion.tilespertick", 100, CVar.SERVERONLY);
+
+        /// <summary>
+        ///     Upper limit on the size of an explosion before physics-throwing is disabled.
+        /// </summary>
+        /// <remarks>
+        ///     Large nukes tend to generate a lot of shrapnel that flies through space. This can functionally cripple
+        ///     the server TPS for a while after an explosion (or even during, if the explosion is processed
+        ///     incrementally. 
+        /// </remarks>
+        public static readonly CVarDef<int> ExplosionThrowLimit =
+            CVarDef.Create("explosion.throwlimit", 400, CVar.SERVERONLY);
+
+        /// <summary>
+        ///     If this is true, explosion processing will pause the NodeGroupSystem to pause updating.
+        /// </summary>
+        /// <remarks>
+        ///     This only takes effect if an explosion needs more than one tick to process (i.e., covers more than <see
+        ///     cref="ExplosionTilesPerTick"/> tiles). If this is not enabled, the node-system will rebuild its graph
+        ///     every tick as the explosion shreds the station, causing significant slowdown.
+        /// </remarks>
+        public static readonly CVarDef<bool> ExplosionSleepNodeSys =
+            CVarDef.Create("explosion.nodesleep", true, CVar.SERVERONLY);
+
+        /// <summary>
+        ///     Upper limit on the total area that an explosion can affect before the neighbor-finding algorithm just
+        ///     stops. Defaults to a 60-rile radius explosion.
+        /// </summary>
+        /// <remarks>
+        ///     Actual area may be larger, as it currently doesn't terminate mid neighbor finding. I.e., area may be that of a ~51 tile radius circle instead.
+        /// </remarks>
+        public static readonly CVarDef<int> ExplosionMaxArea =
+            CVarDef.Create("explosion.maxarea", (int) 3.14f * 50 * 50, CVar.SERVERONLY);
+
+        /// <summary>
+        ///     Upper limit on the number of neighbor finding steps for the explosion system neighbor-finding algorithm.
+        /// </summary>
+        /// <remarks>
+        ///     Effectively places an upper limit on the range that any explosion can have. In the vast majority of
+        ///     instances, <see cref="ExplosionMaxArea"/> will likely be hit before this becomes a limiting factor.
+        /// </remarks>
+        public static readonly CVarDef<int> ExplosionMaxIterations =
+            CVarDef.Create("explosion.maxiterations", 150, CVar.SERVERONLY);
+
+        /// <summary>
+        ///     Max Time in milliseconds to spend processing explosions every tick.
+        /// </summary>
+        /// <remarks>
+        ///     This time limiting is not perfectly implemented. Firstly, a significant chunk of processing time happens
+        ///     due to queued entity deletions, which happen outside of the system update code. Secondly, explosion
+        ///     spawning cannot currently be interrupted & resumed, and may lead to exceeding this time limit.
+        /// </remarks>
+        public static readonly CVarDef<float> ExplosionMaxProcessingTime =
+            CVarDef.Create("explosion.maxtime", 7f, CVar.SERVERONLY);
+
+        /// <summary>
+        ///     If the explosion is being processed incrementally over several ticks, this variable determines whether
+        ///     updating the grid tiles should be done incrementally at the end of every tick, or only once the explosion has finished processing.
+        /// </summary>
+        /// <remarks>
+        ///     The most notable consequence of this change is that explosions will only punch a hole in the station &
+        ///     create a vacumm once they have finished exploding. So airlocks will no longer slam shut as the explosion
+        ///     expands, just suddenly at the end.
+        /// </remarks>
+        public static readonly CVarDef<bool> ExplosionIncrementalTileBreaking =
+            CVarDef.Create("explosion.incrementaltile", false, CVar.SERVERONLY);
+
         /*
          * Admin logs
          */
diff --git a/Content.Shared/Damage/Components/DamageableComponent.cs b/Content.Shared/Damage/Components/DamageableComponent.cs
index 01ef07abdc..e130c9889f 100644
--- a/Content.Shared/Damage/Components/DamageableComponent.cs
+++ b/Content.Shared/Damage/Components/DamageableComponent.cs
@@ -25,7 +25,7 @@ namespace Content.Shared.Damage
     [RegisterComponent]
     [NetworkedComponent()]
     [Friend(typeof(DamageableSystem))]
-    public sealed class DamageableComponent : Component, IRadiationAct, IExAct
+    public sealed class DamageableComponent : Component, IRadiationAct
     {
         /// <summary>
         ///     This <see cref="DamageContainerPrototype"/> specifies what damage types are supported by this component.
@@ -92,27 +92,6 @@ namespace Content.Shared.Damage
 
             EntitySystem.Get<DamageableSystem>().TryChangeDamage(Owner, damage);
         }
-
-        // TODO EXPLOSION Remove this.
-        void IExAct.OnExplosion(ExplosionEventArgs eventArgs)
-        {
-            var damageValue = eventArgs.Severity switch
-            {
-                ExplosionSeverity.Light => FixedPoint2.New(20),
-                ExplosionSeverity.Heavy => FixedPoint2.New(60),
-                ExplosionSeverity.Destruction => FixedPoint2.New(250),
-                _ => throw new ArgumentOutOfRangeException()
-            };
-
-            // Explosion should really just be a damage group instead of a list of types.
-            DamageSpecifier damage = new();
-            foreach (var typeID in ExplosionDamageTypeIDs)
-            {
-                damage.DamageDict.Add(typeID, damageValue);
-            }
-
-            EntitySystem.Get<DamageableSystem>().TryChangeDamage(Owner, damage);
-        }
     }
 
     [Serializable, NetSerializable]
diff --git a/Content.Shared/Explosion/ExplosionEvents.cs b/Content.Shared/Explosion/ExplosionEvents.cs
new file mode 100644
index 0000000000..876beff3ed
--- /dev/null
+++ b/Content.Shared/Explosion/ExplosionEvents.cs
@@ -0,0 +1,81 @@
+using Content.Shared.Inventory;
+using Robust.Shared.Map;
+using Robust.Shared.Serialization;
+
+namespace Content.Shared.Explosion;
+
+/// <summary>
+///     Raised directed at an entity to determine its explosion resistance, probably right before it is about to be
+///     damaged by one.
+/// </summary>
+public class GetExplosionResistanceEvent : EntityEventArgs, IInventoryRelayEvent
+{
+    /// <summary>
+    ///     Can be set to whatever, but currently is being additively increased by components & clothing. So think twice
+    ///     before multiplying or directly setting this.
+    /// </summary>
+    public float Resistance = 0;
+
+    public readonly string ExplotionPrototype;
+
+    SlotFlags IInventoryRelayEvent.TargetSlots =>  ~SlotFlags.POCKET;
+
+    public GetExplosionResistanceEvent(string id)
+    {
+        ExplotionPrototype = id;
+    }
+}
+
+/// <summary>
+///     An explosion event. Used for client side rendering.
+/// </summary>
+[Serializable, NetSerializable]
+public class ExplosionEvent : EntityEventArgs
+{
+    public MapCoordinates Epicenter;
+
+    public Dictionary<int, List<Vector2i>>? SpaceTiles;
+    public Dictionary<GridId, Dictionary<int, List<Vector2i>>> Tiles;
+
+    public List<float> Intensity;
+
+    public string TypeID;
+
+    public Matrix3 SpaceMatrix;
+
+    public byte ExplosionId;
+
+    public ExplosionEvent(
+        byte explosionId,
+        MapCoordinates epicenter,
+        string typeID,
+        List<float> intensity,
+        Dictionary<int, List<Vector2i>>? spaceTiles,
+        Dictionary<GridId, Dictionary<int, List<Vector2i>>> tiles,
+        Matrix3 spaceMatrix)
+    {
+        Epicenter = epicenter;
+        SpaceTiles = spaceTiles;
+        Tiles = tiles;
+        Intensity = intensity;
+        TypeID = typeID;
+        SpaceMatrix = spaceMatrix;
+        ExplosionId = explosionId;
+    }
+}
+
+/// <summary>
+///     Update visual rendering of the explosion to correspond to the servers processing of it.
+/// </summary>
+[Serializable, NetSerializable]
+public class ExplosionOverlayUpdateEvent : EntityEventArgs
+{
+    public int Index;
+    public byte ExplosionId;
+
+    public ExplosionOverlayUpdateEvent(byte explosionId, int index)
+    {
+        Index = index;
+        ExplosionId = explosionId;
+    }
+}
diff --git a/Content.Shared/Explosion/ExplosionPrototype.cs b/Content.Shared/Explosion/ExplosionPrototype.cs
new file mode 100644
index 0000000000..f846a185ec
--- /dev/null
+++ b/Content.Shared/Explosion/ExplosionPrototype.cs
@@ -0,0 +1,89 @@
+using Content.Shared.Damage;
+using Content.Shared.Sound;
+using Robust.Shared.Prototypes;
+
+namespace Content.Shared.Explosion;
+
+[Prototype("explosion")]
+public sealed class ExplosionPrototype : IPrototype
+{
+    [DataField("id", required: true)]
+    public string ID { get; } = default!;
+
+    /// <summary>
+    ///     Damage to deal to entities. This is scaled by the explosion intensity.
+    /// </summary>
+    [DataField("damagePerIntensity", required: true)]
+    public readonly DamageSpecifier DamagePerIntensity = default!;
+
+    /// <summary>
+    ///     This set of points, together with <see cref="_tileBreakIntensity"/> define a function that maps the
+    ///     explosion intensity to a tile break chance via linear interpolation. 
+    /// </summary>
+    [DataField("tileBreakChance")]
+    private readonly float[] _tileBreakChance = { 0f, 1f };
+
+    /// <summary>
+    ///     This set of points, together with <see cref="_tileBreakChance"/> define a function that maps the
+    ///     explosion intensity to a tile break chance via linear interpolation. 
+    /// </summary>
+    [DataField("tileBreakIntensity")]
+    private readonly float[] _tileBreakIntensity = {0f, 15f };
+
+    /// <summary>
+    ///     When a tile is broken by an explosion, the intensity is reduced by this amount and is used to try and
+    ///     break the tile a second time. This is repeated until a roll fails or the tile has become space.
+    /// </summary>
+    /// <remarks>
+    ///     If this number is too small, even relatively weak explosions can have a non-zero
+    ///     chance to create a space tile.
+    /// </remarks>
+    [DataField("tileBreakRerollReduction")]
+    public readonly float TileBreakRerollReduction = 10f;
+
+    /// <summary>
+    ///     Color emitted by a point light at the center of the explosion.
+    /// </summary>
+    [DataField("lightColor")]
+    public readonly Color LightColor = Color.Orange;
+
+    /// <summary>
+    ///     Color used to modulate the fire texture.
+    /// </summary>
+    [DataField("fireColor")]
+    public readonly Color? FireColor;
+
+    [DataField("Sound")]
+    public readonly SoundSpecifier Sound = new SoundCollectionSpecifier("explosion");
+
+    [DataField("texturePath")]
+    public readonly string TexturePath = "/Textures/Effects/fire.rsi";
+
+    // Theres probably a better way to do this. Currently Atmos just hard codes a constant int, so I have no one to
+    // steal code from.
+    [DataField("fireStates")]
+    public readonly int FireStates = 3;
+
+    /// <summary>
+    ///     Basic function for linear interpolation of _tileBreakChance and _tileBreakIntensity
+    /// </summary>
+    public float TileBreakChance(float intensity)
+    {
+        if (_tileBreakChance.Length == 0 || _tileBreakChance.Length != _tileBreakIntensity.Length)
+        {
+            Logger.Error($"Malformed tile break chance definitions for explosion prototype: {ID}");
+            return 0;
+        }
+
+        if (intensity >= _tileBreakIntensity[^1] || _tileBreakIntensity.Length == 1)
+            return _tileBreakChance[^1];
+
+        if (intensity <= _tileBreakIntensity[0])
+            return _tileBreakChance[0];
+
+        int i = Array.FindIndex(_tileBreakIntensity, k => k >= intensity);
+
+        var slope = (_tileBreakChance[i] - _tileBreakChance[i - 1]) / (_tileBreakIntensity[i] - _tileBreakIntensity[i - 1]);
+        return _tileBreakChance[i - 1] + slope * (intensity - _tileBreakIntensity[i - 1]);
+    }
+}
diff --git a/Content.Shared/FixedPoint/FixedPoint2.cs b/Content.Shared/FixedPoint/FixedPoint2.cs
index e6a3dcdb53..180bbf9893 100644
--- a/Content.Shared/FixedPoint/FixedPoint2.cs
+++ b/Content.Shared/FixedPoint/FixedPoint2.cs
@@ -234,6 +234,11 @@ namespace Content.Shared.FixedPoint
                    _value == unit._value;
         }
 
+        public bool EqualsApprox(FixedPoint2 other, FixedPoint2 tolerance)
+        {
+            return Math.Abs(_value - other._value) < tolerance._value;
+        }
+
         public override readonly int GetHashCode()
         {
             // ReSharper disable once NonReadonlyMemberInGetHashCode
diff --git a/Content.Shared/Inventory/InventoryComponent.cs b/Content.Shared/Inventory/InventoryComponent.cs
index fd1959e62c..79bead9873 100644
--- a/Content.Shared/Inventory/InventoryComponent.cs
+++ b/Content.Shared/Inventory/InventoryComponent.cs
@@ -1,38 +1,10 @@
-using System.Linq;
-using Content.Shared.Acts;
-using Robust.Shared.GameObjects;
-using Robust.Shared.IoC;
-using Robust.Shared.Serialization.Manager.Attributes;
 using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom.Prototype;
 
 namespace Content.Shared.Inventory;
 
-public abstract class InventoryComponent : Component, IExAct
+public abstract class InventoryComponent : Component
 {
-    [Dependency] private readonly IEntityManager _entityManager = default!;
-
     [DataField("templateId", required: true,
         customTypeSerializer: typeof(PrototypeIdSerializer<InventoryTemplatePrototype>))]
     public string TemplateId { get; } = "human";
-
-    void IExAct.OnExplosion(ExplosionEventArgs eventArgs)
-    {
-        if (eventArgs.Severity < ExplosionSeverity.Heavy)
-        {
-            return;
-        }
-
-        if (EntitySystem.Get<InventorySystem>()
-            .TryGetContainerSlotEnumerator(Owner, out var enumerator, this))
-        {
-            while (enumerator.MoveNext(out var container))
-            {
-                if (!container.ContainedEntity.HasValue) continue;
-                foreach (var exAct in _entityManager.GetComponents<IExAct>(container.ContainedEntity.Value).ToArray())
-                {
-                    exAct.OnExplosion(eventArgs);
-                }
-            }
-        }
-    }
 }
diff --git a/Content.Shared/Inventory/InventorySystem.Relay.cs b/Content.Shared/Inventory/InventorySystem.Relay.cs
index 7b473f3b07..6cbe1a7e6f 100644
--- a/Content.Shared/Inventory/InventorySystem.Relay.cs
+++ b/Content.Shared/Inventory/InventorySystem.Relay.cs
@@ -1,8 +1,8 @@
-using Content.Shared.Damage;
+using Content.Shared.Damage;
 using Content.Shared.Electrocution;
+using Content.Shared.Explosion;
 using Content.Shared.Movement.EntitySystems;
 using Content.Shared.Slippery;
-using Robust.Shared.GameObjects;
 
 namespace Content.Shared.Inventory;
 
@@ -14,6 +14,7 @@ public partial class InventorySystem
         SubscribeLocalEvent<InventoryComponent, ElectrocutionAttemptEvent>(RelayInventoryEvent);
         SubscribeLocalEvent<InventoryComponent, SlipAttemptEvent>(RelayInventoryEvent);
         SubscribeLocalEvent<InventoryComponent, RefreshMovementSpeedModifiersEvent>(RelayInventoryEvent);
+        SubscribeLocalEvent<InventoryComponent, GetExplosionResistanceEvent>(RelayInventoryEvent);
     }
 
     protected void RelayInventoryEvent<T>(EntityUid uid, InventoryComponent component, T args) where T : EntityEventArgs, IInventoryRelayEvent
diff --git a/Resources/Audio/Effects/explosion1.ogg b/Resources/Audio/Effects/explosion1.ogg
index 14df2c88ccb2f976c636282f9fc7c0c67a1c039d..622702912ca0daa1391c1e53acdd17663c6bdf84 100644
GIT binary patch
literal 32032
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

literal 20834
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

diff --git a/Resources/Audio/Effects/explosion2.ogg b/Resources/Audio/Effects/explosion2.ogg
index 4c742337202250cce35c4d184ab794fef0f3e34b..147049c6fd44e3686e1ae65a3e69c3bd978ed62a 100644
GIT binary patch
literal 32735
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

literal 21899
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

diff --git a/Resources/Locale/en-US/administration/ui/admin-spawn-explosion-eui.ftl b/Resources/Locale/en-US/administration/ui/admin-spawn-explosion-eui.ftl
new file mode 100644
index 0000000000..85f4a065f4
--- /dev/null
+++ b/Resources/Locale/en-US/administration/ui/admin-spawn-explosion-eui.ftl
@@ -0,0 +1,16 @@
+admin-explosion-eui-title = Spawn Explosions
+
+admin-explosion-eui-label-type = Explosion Type
+admin-explosion-eui-label-mapid = Map ID
+admin-explosion-eui-label-xmap = X (Map)
+admin-explosion-eui-label-ymap = Y (Map)
+admin-explosion-eui-label-current = Current Position
+admin-explosion-eui-label-preview = Preview
+admin-explosion-eui-label-total = Total Intensity
+admin-explosion-eui-label-slope = Intensity Slope
+admin-explosion-eui-label-max = Max Intensity
+admin-explosion-eui-label-directional = Directional
+admin-explosion-eui-label-angle = Angle
+admin-explosion-eui-label-spread = Spread
+admin-explosion-eui-label-distance = Distance
+admin-explosion-eui-label-spawn = Kabloom!
\ No newline at end of file
diff --git a/Resources/Prototypes/Entities/Clothing/Head/helmets.yml b/Resources/Prototypes/Entities/Clothing/Head/helmets.yml
index bd6b2be6d5..728d38ee90 100644
--- a/Resources/Prototypes/Entities/Clothing/Head/helmets.yml
+++ b/Resources/Prototypes/Entities/Clothing/Head/helmets.yml
@@ -9,6 +9,8 @@
   - type: Clothing
     sprite: Clothing/Head/Helmets/bombsuit.rsi
   - type: IngestionBlocker
+  - type: ExplosionResistance
+    resistance: 0.25 # +0.65 from body -> 90%
 
 - type: entity
   parent: ClothingHeadBase
diff --git a/Resources/Prototypes/Entities/Clothing/OuterClothing/suits.yml b/Resources/Prototypes/Entities/Clothing/OuterClothing/suits.yml
index 61bec73c34..2881b2555b 100644
--- a/Resources/Prototypes/Entities/Clothing/OuterClothing/suits.yml
+++ b/Resources/Prototypes/Entities/Clothing/OuterClothing/suits.yml
@@ -8,13 +8,15 @@
     sprite: Clothing/OuterClothing/Suits/bombsuit.rsi
   - type: Clothing
     sprite: Clothing/OuterClothing/Suits/bombsuit.rsi
-  - type: Armor
+  - type: Armor #explosion damage ignores "normal" armor, see ExplosionResistance.
     modifiers:
       coefficients:
-        Blunt: 0.2 #big blast protection, a little protection from heat, negligable cushioning from other damage cos its thick
+        Blunt: 0.5
         Slash: 0.9
         Piercing: 0.9
         Heat: 0.75
+  - type: ExplosionResistance
+    resistance: 0.65 # +0.25 from helmet -> 90%
 
 - type: entity
   parent: ClothingOuterBase
diff --git a/Resources/Prototypes/Entities/Effects/explosion_light.yml b/Resources/Prototypes/Entities/Effects/explosion_light.yml
new file mode 100644
index 0000000000..378e65ffcc
--- /dev/null
+++ b/Resources/Prototypes/Entities/Effects/explosion_light.yml
@@ -0,0 +1,9 @@
+- type: entity
+  abstract: true
+  id: ExplosionLight
+  name: explosion light
+  components:
+  - type: PointLight
+  - type: Tag
+    tags:
+    - HideContextMenu
\ No newline at end of file
diff --git a/Resources/Prototypes/Entities/Objects/Devices/nuke.yml b/Resources/Prototypes/Entities/Objects/Devices/nuke.yml
index c8d9e04311..9b1cb01359 100644
--- a/Resources/Prototypes/Entities/Objects/Devices/nuke.yml
+++ b/Resources/Prototypes/Entities/Objects/Devices/nuke.yml
@@ -21,6 +21,11 @@
         layer:
         - SmallImpassable
     - type: Nuke
+      # ~35 tile radius in open space
+      explosionType: Default
+      maxIntensity: 100
+      intensitySlope: 5
+      totalIntensity: 200000
       diskSlot:
         name: Disk
         insertSound:
diff --git a/Resources/Prototypes/Entities/Objects/Power/powercells.yml b/Resources/Prototypes/Entities/Objects/Power/powercells.yml
index 1f24bed06b..4b003edaf3 100644
--- a/Resources/Prototypes/Entities/Objects/Power/powercells.yml
+++ b/Resources/Prototypes/Entities/Objects/Power/powercells.yml
@@ -8,6 +8,8 @@
   components:
   - type: Battery
   - type: PowerCell
+  - type: Explosive
+    explosionType: Default
   - type: Sprite
     netsync: false
   - type: SolutionContainerManager
diff --git a/Resources/Prototypes/Entities/Objects/Tools/gas_tanks.yml b/Resources/Prototypes/Entities/Objects/Tools/gas_tanks.yml
index 994624e7b3..626ba8efcc 100644
--- a/Resources/Prototypes/Entities/Objects/Tools/gas_tanks.yml
+++ b/Resources/Prototypes/Entities/Objects/Tools/gas_tanks.yml
@@ -21,6 +21,9 @@
       icon: Interface/Actions/internal0.png
       iconOn: Interface/Actions/internal1.png
       event: !type:ToggleActionEvent
+  - type: Explosive
+    explosionType: Default
+    maxIntensity: 20
 
 - type: entity
   parent: GasTankBase
diff --git a/Resources/Prototypes/Entities/Objects/Weapons/Guns/Projectiles/meteors.yml b/Resources/Prototypes/Entities/Objects/Weapons/Guns/Projectiles/meteors.yml
index 1e2dff0db4..31f7405f08 100644
--- a/Resources/Prototypes/Entities/Objects/Weapons/Guns/Projectiles/meteors.yml
+++ b/Resources/Prototypes/Entities/Objects/Weapons/Guns/Projectiles/meteors.yml
@@ -18,10 +18,12 @@
     damage: {}
     deleteOnCollide: false
   - type: Explosive
-    devastationRange: 3
-    heavyImpactRange: 5
-    lightImpactRange: 7
-    flashRange: 10
+    explosionType: Default
+    totalIntensity: 2000.0
+    intensitySlope: 20
+    maxIntensity: 60 
+    # should be enough to kill reinforced walls, so meteors are actually a problem for the station.
+    # though maybe reinforced walls should just be nerfed?
   - type: Physics
     bodyType: Dynamic
     fixedRotation: false
@@ -29,7 +31,7 @@
     fixtures:
     - shape:
         !type:PhysShapeCircle
-          radius: 0.5
+          radius: 1.0
       mass: 200
       hard: true
       # Didn't use MapGrid for now as the bounds are stuffed.
diff --git a/Resources/Prototypes/Entities/Objects/Weapons/Guns/Projectiles/projectiles.yml b/Resources/Prototypes/Entities/Objects/Weapons/Guns/Projectiles/projectiles.yml
index 04bc34c0a2..1ccc31f5b6 100644
--- a/Resources/Prototypes/Entities/Objects/Weapons/Guns/Projectiles/projectiles.yml
+++ b/Resources/Prototypes/Entities/Objects/Weapons/Guns/Projectiles/projectiles.yml
@@ -187,10 +187,10 @@
     state: frag
   - type: ExplodeOnTrigger
   - type: Explosive
-    devastationRange: 1
-    heavyImpactRange: 2
-    lightImpactRange: 4
-    flashRange: 10
+    explosionType: Default
+    maxIntensity: 50
+    intensitySlope: 7.5
+    totalIntensity: 300
   - type: PointLight
     radius: 3.5
     color: orange
@@ -229,10 +229,9 @@
     state: grenade
   - type: ExplodeOnTrigger
   - type: Explosive
-    devastationRange: 1
-    heavyImpactRange: 2
-    lightImpactRange: 7
-    flashRange: 10
+    explosionType: Default
+    totalIntensity: 500 # a ~7 tile radius. This is pretty big.
+    maxIntensity: 10 # caps at 150 damage
 
 - type: entity
   id: BulletGrenadeFlash
@@ -260,10 +259,8 @@
     state: grenade
   - type: ExplodeOnTrigger
   - type: Explosive
-    devastationRange: 0
-    heavyImpactRange: 1
-    lightImpactRange: 4
-    flashRange: 10
+    explosionType: Default
+    totalIntensity: 64 # about a ~4 tile radius
 
 - type: entity
   id: BulletFoam
diff --git a/Resources/Prototypes/Entities/Objects/Weapons/Throwable/grenades.yml b/Resources/Prototypes/Entities/Objects/Weapons/Throwable/grenades.yml
index eaf25ef0d3..60b5d2dce6 100644
--- a/Resources/Prototypes/Entities/Objects/Weapons/Throwable/grenades.yml
+++ b/Resources/Prototypes/Entities/Objects/Weapons/Throwable/grenades.yml
@@ -18,10 +18,10 @@
   - type: OnUseTimerTrigger
     delay: 3.5
   - type: Explosive
-    devastationRange: 0
-    heavyImpactRange: 2
-    lightImpactRange: 4
-    flashRange: 7
+    explosionType: Default
+    maxIntensity: 10
+    intensitySlope: 3
+    totalIntensity: 120 # about a ~4 tile radius
   - type: ExplodeOnTrigger
   - type: Damageable
     damageContainer: Inorganic
@@ -94,10 +94,10 @@
   - type: OnUseTimerTrigger
     delay: 5
   - type: Explosive
-    devastationRange: 1
-    heavyImpactRange: 3
-    lightImpactRange: 5
-    flashRange: 10
+    explosionType: Default
+    totalIntensity: 400
+    intensitySlope: 3
+    maxIntensity: 20
   - type: ExplodeOnTrigger
   - type: Damageable
     damageContainer: Inorganic
@@ -129,9 +129,10 @@
   - type: OnUseTimerTrigger
     delay: 5
   - type: Explosive
-    devastationRange: 25
-    heavyImpactRange: 25
-    flashRange: 50
+    explosionType: Default
+    totalIntensity: 20000 # ~15 tile radius.
+    intensitySlope: 5
+    maxIntensity: 50
   - type: ExplodeOnTrigger
   - type: Damageable
     damageContainer: Inorganic
diff --git a/Resources/Prototypes/Entities/Structures/Power/Generation/ame.yml b/Resources/Prototypes/Entities/Structures/Power/Generation/ame.yml
index 541ffb4f8f..c42a620496 100644
--- a/Resources/Prototypes/Entities/Structures/Power/Generation/ame.yml
+++ b/Resources/Prototypes/Entities/Structures/Power/Generation/ame.yml
@@ -46,6 +46,10 @@
   - type: Anchorable
   - type: Pullable
   - type: AMEController
+  - type: Explosive
+    explosionType: Default
+    intensitySlope: 5
+    maxIntensity: 60
   - type: UserInterface
     interfaces:
     - key: enum.AMEControllerUiKey.Key
diff --git a/Resources/Prototypes/Entities/Structures/Power/substation.yml b/Resources/Prototypes/Entities/Structures/Power/substation.yml
index 970aa1be1f..57d68ccbc9 100644
--- a/Resources/Prototypes/Entities/Structures/Power/substation.yml
+++ b/Resources/Prototypes/Entities/Structures/Power/substation.yml
@@ -64,10 +64,10 @@
             min: 1
             max: 1
   - type: Explosive
-    devastationRange: 1
-    heavyImpactRange: 3
-    lightImpactRange: 5
-    flashRange: 6
+    explosionType: Default
+    maxIntensity: 100
+    intensitySlope: 2
+    totalIntensity: 200
   - type: Wires
     BoardName: "Substation"
     LayoutId: Substation
diff --git a/Resources/Prototypes/Entities/Structures/Storage/Closets/Lockers/lockers.yml b/Resources/Prototypes/Entities/Structures/Storage/Closets/Lockers/lockers.yml
index 1537a5bc08..21fc05f9ee 100644
--- a/Resources/Prototypes/Entities/Structures/Storage/Closets/Lockers/lockers.yml
+++ b/Resources/Prototypes/Entities/Structures/Storage/Closets/Lockers/lockers.yml
@@ -167,6 +167,8 @@
       state_closed: freezer_door
   - type: AccessReader
     access: [ [ "Kitchen" ] ]
+  - type: ExplosionResistance
+    resistance: 0.90
 
 # Botanist
 - type: entity
diff --git a/Resources/Prototypes/Entities/Structures/Storage/Tanks/tanks.yml b/Resources/Prototypes/Entities/Structures/Storage/Tanks/tanks.yml
index c3eceef59b..ef8e2f5bfe 100644
--- a/Resources/Prototypes/Entities/Structures/Storage/Tanks/tanks.yml
+++ b/Resources/Prototypes/Entities/Structures/Storage/Tanks/tanks.yml
@@ -19,12 +19,8 @@
       types:
         Heat: 10
   - type: Explosive
-    # The explosive component is independent of the stored liquid :/
-    # I dream of a day where all grenades/explosives will be reagent dependent.
-    devastationRange: 0
-    heavyImpactRange: 2
-    lightImpactRange: 6
-    flashRange: 5
+    explosionType: Default
+    totalIntensity: 120 # ~ 5 tile radius
 
 - type: entity
   id: WeldingFuelTankFull
diff --git a/Resources/Prototypes/Entities/Structures/Walls/barricades.yml b/Resources/Prototypes/Entities/Structures/Walls/barricades.yml
index 5c1ab1a037..6028351e04 100644
--- a/Resources/Prototypes/Entities/Structures/Walls/barricades.yml
+++ b/Resources/Prototypes/Entities/Structures/Walls/barricades.yml
@@ -23,7 +23,6 @@
       - SmallImpassable
   - type: Tag
     tags:
-    - ExplosivePassable
     - Wooden
   - type: Damageable
     damageModifierSet: Wood
diff --git a/Resources/Prototypes/Entities/Structures/Walls/girder.yml b/Resources/Prototypes/Entities/Structures/Walls/girder.yml
index d4433cc925..8c4724ae25 100644
--- a/Resources/Prototypes/Entities/Structures/Walls/girder.yml
+++ b/Resources/Prototypes/Entities/Structures/Walls/girder.yml
@@ -25,9 +25,6 @@
   - type: Sprite
     sprite: Structures/Walls/solid.rsi
     state: wall_girder
-  - type: Tag
-    tags:
-    - ExplosivePassable
   - type: Damageable
     damageContainer: Inorganic
     damageModifierSet: Metallic
diff --git a/Resources/Prototypes/Recipes/Reactions/chemicals.yml b/Resources/Prototypes/Recipes/Reactions/chemicals.yml
index 0a0c663e71..92f882f8df 100644
--- a/Resources/Prototypes/Recipes/Reactions/chemicals.yml
+++ b/Resources/Prototypes/Recipes/Reactions/chemicals.yml
@@ -88,13 +88,11 @@
       amount: 1
   effects:
     - !type:ExplosionReactionEffect
-      #Ranges used when 1 potassium + 1 water react (A unit reaction)
-      devastationRange: 0.025
-      heavyImpactRange: 0.05
-      lightImpactRange: 0.075
-      flashRange: 0.1
-      scaled: true #Scaled proportionally to amount of potassium and water
-      maxScale: 20 #Explosion strength stops scaling at 20 potassium + 20 water
+      explosionType: Default
+      maxIntensity: 1 # at most 15 damage per tile
+      intensityPerUnit: 0.5 # 50+50 reagent for maximum explosion 
+      intensitySlope: 2
+      maxTotalIntensity: 25
 
 - type: reaction
   id: Smoke
diff --git a/Resources/Prototypes/Recipes/Reactions/pyrotechnic.yml b/Resources/Prototypes/Recipes/Reactions/pyrotechnic.yml
index 62731c9062..66a0cd9d4d 100644
--- a/Resources/Prototypes/Recipes/Reactions/pyrotechnic.yml
+++ b/Resources/Prototypes/Recipes/Reactions/pyrotechnic.yml
@@ -37,12 +37,14 @@
       amount: 3
   effects:
   # TODO electro's pretty explosions PR make this big and firey!!
+  # Welp its fiery now (low damage). Someone else needs to come in and define how big it should get & how it compares to potassium
   # TODO solution temperature!!
   - !type:ExplosionReactionEffect
-    devastationRange: 0
-    heavyImpactRange: 0
-    lightImpactRange: 2
-    scaled: false
+    explosionType: Default # 15 damage per intensity
+    maxIntensity: 2 # at most 30 damage per tile.
+    intensityPerUnit: 2 # 80 total input reagent units for max size
+    intensitySlope: 1
+    maxTotalIntensity: 40
   - !type:PopupMessage
     messages: [ "clf3-explosion" ]
     type: Pvs
diff --git a/Resources/Prototypes/explosion.yml b/Resources/Prototypes/explosion.yml
new file mode 100644
index 0000000000..9de6203fe2
--- /dev/null
+++ b/Resources/Prototypes/explosion.yml
@@ -0,0 +1,39 @@
+- type: explosion
+  id: Default
+  damagePerIntensity:
+    types:
+      Heat: 5
+      Blunt: 5
+      Piercing: 5
+  tileBreakChance: [0, 0.5, 1]
+  tileBreakIntensity: [0, 10, 30]
+  tileBreakRerollReduction: 20
+  lightColor: Orange
+  texturePath: /Textures/Effects/fire.rsi 
+  fireStates: 3
+
+- type: explosion
+  id: Radioactive
+  damagePerIntensity:
+    types:
+      Radiation: 5
+      Heat: 4
+      Blunt: 3
+      Piercing: 3
+  lightColor: Green
+  fireColor: Green
+  texturePath: /Textures/Effects/fire_greyscale.rsi 
+  fireStates: 3
+
+- type: explosion
+  id: Cryo
+  damagePerIntensity:
+    types:
+      Cold: 5
+      Blunt: 2  
+  tileBreakChance: [0]
+  tileBreakIntensity: [0]
+  lightColor: Blue
+  fireColor: Blue
+  texturePath: /Textures/Effects/fire_greyscale.rsi 
+  fireStates: 3
diff --git a/Resources/Textures/Effects/fire_greyscale.rsi/1.png b/Resources/Textures/Effects/fire_greyscale.rsi/1.png
new file mode 100644
index 0000000000000000000000000000000000000000..b3ceb657dee9e8ee55f5828607a2bf25eb190fa7
GIT binary patch
literal 62870
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
JsFpJe`43J3+$8`2

literal 0
HcmV?d00001

diff --git a/Resources/Textures/Effects/fire_greyscale.rsi/2.png b/Resources/Textures/Effects/fire_greyscale.rsi/2.png
new file mode 100644
index 0000000000000000000000000000000000000000..1f03469c04d3024d4a69f9da6ea4a4aa90a51b9e
GIT binary patch
literal 110683
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

literal 0
HcmV?d00001

diff --git a/Resources/Textures/Effects/fire_greyscale.rsi/3.png b/Resources/Textures/Effects/fire_greyscale.rsi/3.png
new file mode 100644
index 0000000000000000000000000000000000000000..949505eef62978bcb6aefc5c7f7ed3ab604f3d9e
GIT binary patch
literal 18528
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

literal 0
HcmV?d00001

diff --git a/Resources/Textures/Effects/fire_greyscale.rsi/meta.json b/Resources/Textures/Effects/fire_greyscale.rsi/meta.json
new file mode 100644
index 0000000000..d1b76a068b
--- /dev/null
+++ b/Resources/Textures/Effects/fire_greyscale.rsi/meta.json
@@ -0,0 +1 @@
+{"version": 1, "size": {"x": 32, "y": 32}, "license": "CC-BY-SA-3.0", "copyright": "Taken from https://github.com/tgstation/tgstation at 04e43d8c1d5097fdb697addd4395fb849dd341bd", "states": [{"name": "1", "directions": 4, "delays": [[0.1, 0.2, 0.1, 0.1, 0.1, 0.1], [0.1, 0.2, 0.1, 0.1, 0.1, 0.1], [0.1, 0.2, 0.1, 0.1, 0.1, 0.1], [0.1, 0.2, 0.1, 0.1, 0.1, 0.1]]}, {"name": "2", "directions": 4, "delays": [[0.1, 0.2, 0.1, 0.2, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1], [0.1, 0.2, 0.1, 0.2, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1], [0.1, 0.2, 0.1, 0.2, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1], [0.1, 0.2, 0.1, 0.2, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1]]}, {"name": "3", "directions": 4, "delays": [[0.1, 0.2, 0.1, 0.2, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1], [0.1, 0.2, 0.1, 0.2, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1], [0.1, 0.2, 0.1, 0.2, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1], [0.1, 0.2, 0.1, 0.2, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1]]}]}