From 56168e592e616d76f8bf662e749cd1d581e0de90 Mon Sep 17 00:00:00 2001
From: Leon Friedrich <60421075+ElectroJr@users.noreply.github.com>
Date: Fri, 1 Apr 2022 15:39:26 +1300
Subject: [PATCH] Explosion refactor (#5230)

* Explosions

* fix yaml typo

and prevent silly UI inputs

* oop

* Use modified contains() checks

And remove IEnumerable

* Buff nuke, nerf meteors

* optimize the entity lookup stuff a bit

* fix tile (0,0) error

forgot to do an initial Enumerator.MoveNext(), so the first tile was always the "null" tile.

* remove celebration

* byte -> int

* remove diag edge tile dict

* fix one bug

but there is another

* fix the other bug

turns out dividing a ushort leads to rounding errors.  Why TF is the grid tile size even a ushort in the first place.

* improve edge map

* fix minor bug

If the initial-explosion tile had an airtight entity on it, the tile was processed twice.

* some reviews (transform queries, eye.mapid, and tilesizes in overlays)

* Apply suggestions from code review

Co-authored-by: metalgearsloth <31366439+metalgearsloth@users.noreply.github.com>

* is map paused

* GetAllTiles ignores space by default

* WriteLine -> WriteError

* First -> FirstOrDefault()

* default prototype const string

* entity query

* misc review changes

* grid edge max distance

* fix fire texture defn

bad use of type serializer and ioc-resolves

* Remove ExplosionLaunched

And allow nukes to throw items towards the outer part of an explosion

* no hot-reload disclaimer

* replace prototype id string with int index

* optimise damage a tiiiiny bit.

* entity queries

* comments

* misc mirror comments

* cvars

* admin logs

* move intensity-per-state to prototype

* update tile event to ECS event

* git mv

* Tweak rpg & minibomb

also fix merge bug

* you don't exist anymore go away

* Fix build

Co-authored-by: moonheart08 <moonheart08@users.noreply.github.com>
Co-authored-by: metalgearsloth <31366439+metalgearsloth@users.noreply.github.com>
---
 .../SpawnExplosion/ExplosionDebugOverlay.cs   | 193 ++++++
 .../UI/SpawnExplosion/SpawnExplosionEui.cs    |  81 +++
 .../SpawnExplosion/SpawnExplosionWindow.xaml  |  46 ++
 .../SpawnExplosionWindow.xaml.cs              | 142 ++++
 Content.Client/Entry/IgnoredComponents.cs     |   2 +-
 Content.Client/Explosion/ExplosionOverlay.cs  | 119 ++++
 .../Explosion/ExplosionOverlaySystem.cs       | 211 ++++++
 Content.Server/AME/AMENodeGroup.cs            |  11 +-
 .../Administration/AdminVerbSystem.cs         |   9 +-
 .../Commands/ExplosionCommand.cs              | 146 +++-
 .../Administration/UI/SpawnExplosionEui.cs    |  39 ++
 .../Atmos/Components/GasTankComponent.cs      |   4 +-
 .../Atmos/EntitySystems/AirtightSystem.cs     |   5 +
 .../ExplosionReactionEffect.cs                |  90 ++-
 .../Destructible/DestructibleSystem.cs        |  38 ++
 .../Thresholds/Behaviors/ExplodeBehavior.cs   |   2 +-
 .../Components/ExplosionLaunchedComponent.cs  |  43 --
 .../ExplosionResistanceComponent.cs           |  30 +
 .../Components/ExplosiveComponent.cs          |  76 ++-
 .../EntitySystems/ExplosionSystem.Airtight.cs | 181 +++++
 .../EntitySystems/ExplosionSystem.CVars.cs    |  48 ++
 .../EntitySystems/ExplosionSystem.GridMap.cs  | 386 +++++++++++
 .../ExplosionSystem.Processing.cs             | 642 ++++++++++++++++++
 .../EntitySystems/ExplosionSystem.TileFill.cs | 337 +++++++++
 .../EntitySystems/ExplosionSystem.cs          | 635 ++++++++---------
 .../Explosion/EntitySystems/GridExplosion.cs  | 304 +++++++++
 .../Explosion/EntitySystems/SpaceExplosion.cs | 160 +++++
 .../Explosion/EntitySystems/TileExplosion.cs  | 191 ++++++
 .../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                | 100 +++
 .../Damage/Components/DamageableComponent.cs  |  23 +-
 .../Damage/Systems/DamageableSystem.cs        |   4 +-
 Content.Shared/Explosion/ExplosionEvents.cs   |  85 +++
 .../Explosion/ExplosionPrototype.cs           | 104 +++
 .../Inventory/InventoryComponent.cs           |  30 +-
 .../Inventory/InventorySystem.Relay.cs        |   5 +-
 .../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         |   6 +
 .../Entities/Objects/Power/powercells.yml     |   2 +
 .../Entities/Objects/Tools/gas_tanks.yml      |   3 +
 .../Weapons/Guns/Projectiles/meteors.yml      |  10 +-
 .../Weapons/Guns/Projectiles/projectiles.yml  |  21 +-
 .../Objects/Weapons/Throwable/grenades.yml    |  25 +-
 .../Prototypes/Entities/Objects/base_item.yml |   1 -
 .../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            |  41 ++
 .../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 +
 70 files changed, 4209 insertions(+), 770 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
 delete mode 100644 Content.Server/Explosion/Components/ExplosionLaunchedComponent.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.CVars.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/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..cc00f754a6
--- /dev/null
+++ b/Content.Client/Administration/UI/SpawnExplosion/ExplosionDebugOverlay.cs
@@ -0,0 +1,193 @@
+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 ushort SpaceTileSize;
+
+    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 != args.Viewport.Eye?.Position.MapId)
+            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;
+        var xformQuery = _entityManager.GetEntityQuery<TransformComponent>();
+
+        foreach (var (gridId, tileSets) in Tiles)
+        {
+            if (!_mapManager.TryGetGrid(gridId, out var grid))
+                continue;
+
+            var gridXform = xformQuery.GetComponent(grid.GridEntityId);
+            var (_, _, matrix, invMatrix) = gridXform.GetWorldPositionRotationMatrixWithInv(xformQuery);
+            gridBounds = invMatrix.TransformBox(args.WorldBounds);
+            DrawText(handle, gridBounds, matrix, tileSets, grid.TileSize);
+        }
+
+        if (SpaceTiles == null)
+            return;
+
+        gridBounds = Matrix3.Invert(SpaceMatrix).TransformBox(args.WorldBounds);
+
+        DrawText(handle, gridBounds, SpaceMatrix, SpaceTiles, SpaceTileSize);
+    }
+
+    private void DrawText(
+        DrawingHandleScreen handle,
+        Box2 gridBounds,
+        Matrix3 transform,
+        Dictionary<int, List<Vector2i>> tileSets,
+        ushort tileSize)
+    {
+        for (var i = 1; i < Intensity.Count; i++)
+        {
+            if (!tileSets.TryGetValue(i, out var tiles))
+                continue;
+
+            foreach (var tile in tiles)
+            {
+                var centre = ((Vector2) tile + 0.5f) * tileSize;
+
+                // is the center of this tile visible to the user?
+                if (!gridBounds.Contains(centre))
+                    continue;
+
+                var worldCenter = transform.Transform(centre);
+
+                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) * tileSize);
+            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;
+        var xformQuery = _entityManager.GetEntityQuery<TransformComponent>();
+
+        foreach (var (gridId, tileSets) in Tiles)
+        {
+            if (!_mapManager.TryGetGrid(gridId, out var grid))
+                continue;
+
+            var gridXform = xformQuery.GetComponent(grid.GridEntityId);
+            var (_, _, worldMatrix, invWorldMatrix) = gridXform.GetWorldPositionRotationMatrixWithInv(xformQuery);
+            gridBounds = invWorldMatrix.TransformBox(args.WorldBounds);
+            handle.SetTransform(worldMatrix);
+            DrawTiles(handle, gridBounds, tileSets, SpaceTileSize);
+        }
+
+        if (SpaceTiles == null)
+            return;
+
+        gridBounds = Matrix3.Invert(SpaceMatrix).TransformBox(args.WorldBounds);
+        handle.SetTransform(SpaceMatrix);
+
+        DrawTiles(handle, gridBounds, SpaceTiles, SpaceTileSize);
+    }
+
+    private void DrawTiles(
+        DrawingHandleWorld handle,
+        Box2 gridBounds,
+        Dictionary<int, List<Vector2i>> tileSets,
+        ushort tileSize)
+    {
+        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)
+            {
+                var centre = ((Vector2) tile + 0.5f) * tileSize;
+
+                // is the center of this tile visible to the user?
+                if (!gridBounds.Contains(centre))
+                    continue;
+
+                var box = Box2.UnitCentered.Translated(centre);
+                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..14eeb06386
--- /dev/null
+++ b/Content.Client/Administration/UI/SpawnExplosion/SpawnExplosionEui.cs
@@ -0,0 +1,81 @@
+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 += SendClosedMessage;
+    }
+
+    public override void Opened()
+    {
+        base.Opened();
+        _window.OpenCentered();
+    }
+
+    public override void Closed()
+    {
+        base.Closed();
+        _window.OnClose -= SendClosedMessage;
+        _window.Close();
+        ClearOverlay();
+    }
+
+    public void SendClosedMessage()
+    {
+        SendMessage(new SpawnExplosionEuiMsg.Close());
+    }
+
+    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;
+        _debugOverlay.SpaceTileSize = data.Explosion.SpaceTileSize;
+    }
+}
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 fae7093a13..ce7f09805a 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",
@@ -267,7 +268,6 @@ namespace Content.Client.Entry
             "RandomSpawner",
             "SpawnAfterInteract",
             "DisassembleOnAltVerb",
-            "ExplosionLaunched",
             "BeingCloned",
             "Advertise",
             "Bible",
diff --git a/Content.Client/Explosion/ExplosionOverlay.cs b/Content.Client/Explosion/ExplosionOverlay.cs
new file mode 100644
index 0000000000..999f2f9744
--- /dev/null
+++ b/Content.Client/Explosion/ExplosionOverlay.cs
@@ -0,0 +1,119 @@
+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 IRobustRandom _robustRandom = default!;
+    [Dependency] private readonly IMapManager _mapManager = default!;
+    [Dependency] private readonly IEntityManager _entMan = default!;
+
+    public override OverlaySpace Space => OverlaySpace.WorldSpaceBelowFOV;
+
+    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);
+
+        var xforms = _entMan.GetEntityQuery<TransformComponent>();
+
+        if (ActiveExplosion != null && ActiveExplosion.Map == args.Viewport.Eye?.Position.MapId)
+        {
+            DrawExplosion(drawHandle, args.WorldBounds, ActiveExplosion, Index, xforms);
+        }
+
+        foreach (var exp in CompletedExplosions)
+        {
+            if (exp.Map == args.Viewport.Eye?.Position.MapId)
+                DrawExplosion(drawHandle, args.WorldBounds, exp, exp.Intensity.Count, xforms);
+        }
+
+        drawHandle.SetTransform(Matrix3.Identity);
+    }
+
+    private void DrawExplosion(DrawingHandleWorld drawHandle, Box2Rotated worldBounds, Explosion exp, int index, EntityQuery<TransformComponent> xforms)
+    {
+        Box2 gridBounds;
+        foreach (var (gridId, tiles) in exp.Tiles)
+        {
+            if (!_mapManager.TryGetGrid(gridId, out var grid))
+                continue;
+
+            var xform = xforms.GetComponent(grid.GridEntityId);
+            var (_, _, worldMatrix, invWorldMatrix) = xform.GetWorldPositionRotationMatrixWithInv(xforms);
+
+            gridBounds = invWorldMatrix.TransformBox(worldBounds);
+            drawHandle.SetTransform(worldMatrix);
+
+            DrawTiles(drawHandle, gridBounds, index, tiles, exp, grid.TileSize);
+        }
+
+        if (exp.SpaceTiles == null)
+            return;
+
+        gridBounds = Matrix3.Invert(exp.SpaceMatrix).TransformBox(worldBounds);
+        drawHandle.SetTransform(exp.SpaceMatrix);
+        
+        DrawTiles(drawHandle, gridBounds, index, exp.SpaceTiles, exp, exp.SpaceTileSize);
+    }
+
+    private void DrawTiles(
+        DrawingHandleWorld drawHandle,
+        Box2 gridBounds,
+        int index,
+        Dictionary<int, List<Vector2i>> tileSets,
+        Explosion exp,
+        ushort tileSize)
+    {
+        for (var j = 0; j < index; j++)
+        {
+            if (!tileSets.TryGetValue(j, out var tiles))
+                continue;
+
+            var frameIndex = (int) Math.Min(exp.Intensity[j] / exp.IntensityPerState, exp.FireFrames.Count - 1);
+            var frames = exp.FireFrames[frameIndex];
+
+            foreach (var tile in tiles)
+            {
+                Vector2 centre = ((Vector2) tile + 0.5f) * tileSize;
+
+                if (!gridBounds.Contains(centre))
+                    continue;
+
+                var texture = _robustRandom.Pick(frames);
+                drawHandle.DrawTextureRect(texture, Box2.CenteredAround(centre, (tileSize, tileSize)), exp.FireColor);
+            }
+        }
+    }
+}
diff --git a/Content.Client/Explosion/ExplosionOverlaySystem.cs b/Content.Client/Explosion/ExplosionOverlaySystem.cs
new file mode 100644
index 0000000000..ba3ffb8bd4
--- /dev/null
+++ b/Content.Client/Explosion/ExplosionOverlaySystem.cs
@@ -0,0 +1,211 @@
+using Content.Shared.CCVar;
+using Content.Shared.Explosion;
+using Robust.Client.GameObjects;
+using Robust.Client.Graphics;
+using Robust.Client.ResourceManagement;
+using Robust.Shared.Configuration;
+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!;
+    [Dependency] private readonly IMapManager _mapMan = default!;
+    [Dependency] private readonly IResourceCache _resCache = default!;
+    [Dependency] private readonly IConfigurationManager _cfg = default!;
+
+    /// <summary>
+    ///     For how many seconds should an explosion stay on-screen once it has finished expanding?
+    /// </summary>
+    public float ExplosionPersistence = 0.3f;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeNetworkEvent<ExplosionEvent>(OnExplosion);
+        SubscribeNetworkEvent<ExplosionOverlayUpdateEvent>(HandleExplosionUpdate);
+
+        _cfg.OnValueChanged(CCVars.ExplosionPersistence, SetExplosionPersistence, true);
+
+        var overlayManager = IoCManager.Resolve<IOverlayManager>();
+        _overlay = new ExplosionOverlay();
+        if (!overlayManager.HasOverlay<ExplosionOverlay>())
+            overlayManager.AddOverlay(_overlay);
+    }
+
+    private void SetExplosionPersistence(float value) => ExplosionPersistence = value;
+
+    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
+        for (int i = _overlay.CompletedExplosions.Count - 1; i>= 0; i--) 
+        {
+            var explosion = _overlay.CompletedExplosions[i];
+
+            if (_mapMan.IsMapPaused(explosion.Map))
+                continue;
+
+            explosion.Lifetime += frameTime;
+
+            if (explosion.Lifetime >= ExplosionPersistence)
+            {
+                EntityManager.QueueDeleteEntity(explosion.LightEntity);
+
+                // Remove-swap
+                _overlay.CompletedExplosions[i] = _overlay.CompletedExplosions[^1];
+                _overlay.CompletedExplosions.RemoveAt(_overlay.CompletedExplosions.Count - 1);
+            }
+        }
+    }
+
+    /// <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, _resCache);
+            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, _resCache);
+        }
+        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, _resCache));
+            return;
+        }
+    }
+
+    public bool IsNewer(int explosionId)
+    {
+        if (_overlay.ActiveExplosion == null)
+            return true;
+
+        // If we ever get servers stable enough to live this long, the explosion Id int might overflow.
+        return _overlay.ActiveExplosion.Explosionid < explosionId
+            || _overlay.ActiveExplosion.Explosionid > int.MaxValue/2 && explosionId < int.MinValue/2;
+    }
+
+    public override void Shutdown()
+    {
+        base.Shutdown();
+
+        _cfg.UnsubValueChanged(CCVars.ExplosionPersistence, SetExplosionPersistence);
+
+        var overlayManager = IoCManager.Resolve<IOverlayManager>();
+        if (overlayManager.HasOverlay<ExplosionOverlay>())
+            overlayManager.RemoveOverlay<ExplosionOverlay>();
+    }
+}
+
+internal sealed class Explosion
+{
+    public readonly Dictionary<int, List<Vector2i>>? SpaceTiles;
+    public readonly Dictionary<GridId, Dictionary<int, List<Vector2i>>> Tiles;
+    public readonly List<float> Intensity;
+    public readonly EntityUid LightEntity;
+    public readonly MapId Map;
+    public readonly int Explosionid;
+    public readonly ushort SpaceTileSize;
+    public readonly float IntensityPerState;
+
+    public readonly 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 readonly List<Texture[]> FireFrames = new();
+
+    public readonly Color? FireColor;
+
+    internal Explosion(ExplosionEvent args, ExplosionPrototype type, EntityUid lightEntity, IResourceCache resCache)
+    {
+        Map = args.Epicenter.MapId;
+        SpaceTiles = args.SpaceTiles;
+        Tiles = args.Tiles;
+        Intensity = args.Intensity;
+        SpaceMatrix = args.SpaceMatrix;
+        Explosionid = args.ExplosionId;
+        FireColor = type.FireColor;
+        LightEntity = lightEntity;
+        SpaceTileSize = args.SpaceTileSize;
+        IntensityPerState = type.IntensityPerState;
+
+        var fireRsi = resCache.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 cf986a7491..11a58f0a56 100644
--- a/Content.Server/Administration/AdminVerbSystem.cs
+++ b/Content.Server/Administration/AdminVerbSystem.cs
@@ -42,7 +42,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!;
         [Dependency] private readonly UserInterfaceSystem _uiSystem = default!;
@@ -151,8 +151,11 @@ 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, ExplosionSystem.DefaultExplosionPrototypeId, 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..449d534efd 100644
--- a/Content.Server/Administration/Commands/ExplosionCommand.cs
+++ b/Content.Server/Administration/Commands/ExplosionCommand.cs
@@ -1,42 +1,136 @@
+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.WriteError("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.WriteError("Wrong number of arguments.");
+            return;
+        }
+
+        if (!float.TryParse(args[0], out var intensity))
+        {
+            shell.WriteError($"Failed to parse intensity: {args[0]}");
+            return;
+        }
+ 
+        float slope = 5;
+        if (args.Length > 1 && !float.TryParse(args[1], out slope))
+        {
+            shell.WriteError($"Failed to parse float: {args[1]}");
+            return;
+        }
+
+        float maxIntensity = 100;
+        if (args.Length > 2 && !float.TryParse(args[2], out maxIntensity))
+        {
+            shell.WriteError($"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.WriteError($"Failed to parse coordinates: {(args[3], args[4])}");
+                return;
+            }
+        }
+
+        MapCoordinates coords;
+        if (args.Length > 5)
+        {
+            if (!int.TryParse(args[5], out var parsed))
+            {
+                shell.WriteError($"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.WriteError($"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]);
-
-            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);
+            if (args.Length > 4)
+                coords = new MapCoordinates((x, y), xform.MapID);
+            else
+                coords = xform.MapPosition;
         }
+
+        ExplosionPrototype? type;
+        var protoMan = IoCManager.Resolve<IPrototypeManager>();
+        if (args.Length > 6)
+        {
+            if (!protoMan.TryIndex(args[6], out type))
+            {
+                shell.WriteError($"Unknown explosion prototype: {args[6]}");
+                return;
+            }
+        }
+        else
+        {
+            // no prototype was specified, so lets default to whichever one was defined first
+            type = protoMan.EnumeratePrototypes<ExplosionPrototype>().FirstOrDefault();
+
+            if (type == null)
+            {
+                shell.WriteError($"Prototype manager has no explosion prototypes?");
+                return;
+            }
+        }
+
+        var sysMan = IoCManager.Resolve<IEntitySystemManager>();
+        sysMan.GetEntitySystem<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 26543b0cac..f6182f8783 100644
--- a/Content.Server/Atmos/Components/GasTankComponent.cs
+++ b/Content.Server/Atmos/Components/GasTankComponent.cs
@@ -230,14 +230,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..75f7fff633 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,9 @@ namespace Content.Server.Atmos.EntitySystems
             if (!gridId.IsValid())
                 return;
 
+            var query = EntityManager.GetEntityQuery<AirtightComponent>();
+            _explosionSystem.UpdateAirtightMap(gridId, pos, query);
+            // TODO make atmos system use query
             _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
deleted file mode 100644
index 4d1ddc2fca..0000000000
--- a/Content.Server/Explosion/Components/ExplosionLaunchedComponent.cs
+++ /dev/null
@@ -1,43 +0,0 @@
-using Content.Server.Throwing;
-using Content.Shared.Acts;
-using Content.Shared.Throwing;
-using Robust.Shared.GameObjects;
-using Robust.Shared.IoC;
-using Robust.Shared.Maths;
-
-namespace Content.Server.Explosion.Components
-{
-    [RegisterComponent]
-    public sealed class ExplosionLaunchedComponent : Component, IExAct
-    {
-        [Dependency] private readonly IEntityManager _entMan = default!;
-        [Dependency] private readonly IEntitySystemManager _sysMan = 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,
-            };
-
-            _sysMan.GetEntitySystem<ThrowingSystem>().TryThrow(Owner, 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..c116263c8e 100644
--- a/Content.Server/Explosion/Components/ExplosiveComponent.cs
+++ b/Content.Server/Explosion/Components/ExplosiveComponent.cs
@@ -1,34 +1,58 @@
-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
 {
+
     /// <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 tile. 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 its 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..8da5486b38
--- /dev/null
+++ b/Content.Server/Explosion/EntitySystems/ExplosionSystem.Airtight.cs
@@ -0,0 +1,181 @@
+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!;
+
+    private readonly Dictionary<string, int> _explosionTypes = new();
+
+    private void InitAirtightMap()
+    {
+        // Currently explosion prototype hot-reload isn't supported, as it would involve completely re-computing the
+        // airtight map. Could be done, just not yet implemented.
+
+        // for storing airtight entity damage thresholds for all anchored airtight entities, we will use integers in
+        // place of id-strings. This initializes the string <--> id association.
+        // This allows us to replace a Dictionary<string, float> with just a float[].
+        int index = 0;
+        foreach (var prototype in _prototypeManager.EnumeratePrototypes<ExplosionPrototype>())
+        {
+            _explosionTypes.Add(prototype.ID, index);
+            index++;
+        }
+    }
+
+    // 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, EntityQuery<AirtightComponent>? query = null)
+    {
+        if (_mapManager.TryGetGrid(gridId, out var grid))
+            UpdateAirtightMap(grid, tile, query);
+    }
+
+    /// <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, EntityQuery<AirtightComponent>? query = null)
+    {
+        var tolerance = new float[_explosionTypes.Count];
+        var blockedDirections = AtmosDirection.Invalid;
+
+        if (!_airtightMap.ContainsKey(grid.Index))
+            _airtightMap[grid.Index] = new();
+
+        query ??= EntityManager.GetEntityQuery<AirtightComponent>();
+        var damageQuery = EntityManager.GetEntityQuery<DamageableComponent>();
+        var destructibleQuery = EntityManager.GetEntityQuery<DestructibleComponent>();
+
+        foreach (var uid in grid.GetAnchoredEntities(tile))
+        {
+            if (!query.Value.TryGetComponent(uid, out var airtight) || !airtight.AirBlocked)
+                continue;
+
+            blockedDirections |= airtight.AirBlockedDirection;
+            var entityTolerances = GetExplosionTolerance(uid, damageQuery, destructibleQuery);
+            for (var i = 0; i < tolerance.Length; i++)
+            {
+                tolerance[i] = Math.Max(tolerance[i], entityTolerances[i]);
+            }
+        }
+
+        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 float[] GetExplosionTolerance(
+        EntityUid uid,
+        EntityQuery<DamageableComponent> damageQuery,
+        EntityQuery<DestructibleComponent> destructibleQuery)
+    {
+        // 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 = FixedPoint2.MaxValue;
+        if (destructibleQuery.TryGetComponent(uid, out var destructible))
+        {
+            totalDamageTarget = _destructibleSystem.DestroyedAt(uid, destructible);
+        }
+
+        var explosionTolerance = new float[_explosionTypes.Count];
+        if (totalDamageTarget == FixedPoint2.MaxValue || !damageQuery.TryGetComponent(uid, out var damageable))
+        {
+            for (var i = 0; i < explosionTolerance.Length; i++)
+            {
+                explosionTolerance[i] = float.MaxValue;
+            }
+            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 (id, index) in _explosionTypes)
+        {
+            if (!_prototypeManager.TryIndex<ExplosionPrototype>(id, out var explosionType))
+                continue;
+
+            // 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))
+                {
+                    explosionTolerance[index] = float.MaxValue;
+                    continue;
+                }
+
+                var ev = new GetExplosionResistanceEvent(explosionType.ID);
+                RaiseLocalEvent(uid, ev, false);
+
+                damagePerIntensity += value * Math.Clamp(0, 1 - ev.Resistance, 1);
+            }
+
+            explosionTolerance[index] = (float) ((totalDamageTarget - damageable.TotalDamage) / damagePerIntensity);
+        }
+
+        return explosionTolerance;
+    }
+}
+
+/// <summary>
+///     Data struct that describes the explosion-blocking airtight entities on a tile.
+/// </summary>
+public struct TileData
+{
+    public TileData(float[] explosionTolerance, AtmosDirection blockedDirections)
+    {
+        ExplosionTolerance = explosionTolerance;
+        BlockedDirections = blockedDirections;
+    }
+
+    public float[] ExplosionTolerance;
+    public AtmosDirection BlockedDirections = AtmosDirection.Invalid;
+}
diff --git a/Content.Server/Explosion/EntitySystems/ExplosionSystem.CVars.cs b/Content.Server/Explosion/EntitySystems/ExplosionSystem.CVars.cs
new file mode 100644
index 0000000000..d03c64fd37
--- /dev/null
+++ b/Content.Server/Explosion/EntitySystems/ExplosionSystem.CVars.cs
@@ -0,0 +1,48 @@
+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; }
+    public int SingleTickAreaLimit {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);
+        _cfg.OnValueChanged(CCVars.ExplosionSingleTickAreaLimit, SetSingleTickAreaLimit, 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);
+        _cfg.UnsubValueChanged(CCVars.ExplosionSingleTickAreaLimit, SetSingleTickAreaLimit);
+    }
+
+    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;
+    private void SetSingleTickAreaLimit(int value) => SingleTickAreaLimit = value;
+}
diff --git a/Content.Server/Explosion/EntitySystems/ExplosionSystem.GridMap.cs b/Content.Server/Explosion/EntitySystems/ExplosionSystem.GridMap.cs
new file mode 100644
index 0000000000..bc6495f8be
--- /dev/null
+++ b/Content.Server/Explosion/EntitySystems/ExplosionSystem.GridMap.cs
@@ -0,0 +1,386 @@
+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, NeighborFlag>> _gridEdges = new();
+
+    /// <summary>
+    ///     On grid startup, prepare a map of grid edges.
+    /// </summary>
+    private void OnGridStartup(GridStartupEvent ev)
+    {
+        var grid = _mapManager.GetGrid(ev.GridId);
+
+        Dictionary<Vector2i, NeighborFlag> edges = new();
+        _gridEdges[ev.GridId] = edges;
+
+        foreach (var tileRef in grid.GetAllTiles())
+        {
+            if (IsEdge(grid, tileRef.GridIndices, out var dir))
+                edges.Add(tileRef.GridIndices, dir);
+        }
+    }
+
+    private void OnGridRemoved(GridRemovalEvent ev)
+    {
+        _airtightMap.Remove(ev.GridId);
+        _gridEdges.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, BlockedSpaceTile>, ushort) TransformGridEdges(
+        MapCoordinates epicentre,
+        GridId? referenceGrid,
+        List<GridId> localGrids,
+        float maxDistance)
+    {
+        Dictionary<Vector2i, BlockedSpaceTile> transformedEdges = new();
+
+        var targetMatrix = Matrix3.Identity;
+        Angle targetAngle = new();
+        var tileSize = DefaultTileSize;
+        var maxDistanceSq = (int) (maxDistance * maxDistance);
+
+        // 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 / 2f;
+        offsetMatrix.R1C2 = tileSize / 2f;
+
+        // Here we can end up with 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)
+
+        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))
+                continue;
+
+            if (grid.TileSize != tileSize)
+            {
+                Logger.Error($"Explosions do not support grids with different grid sizes. GridIds: {gridToTransform} and {referenceGrid}");
+                continue;
+            }
+
+            var xforms = EntityManager.GetEntityQuery<TransformComponent>();
+            var xform = xforms.GetComponent(grid.GridEntityId);
+            var  (_, gridWorldRotation, gridWorldMatrix, invGridWorldMatrid) = xform.GetWorldPositionRotationMatrixWithInv(xforms);
+
+            var localEpicentre = (Vector2i) invGridWorldMatrid.Transform(epicentre.Position);
+            var matrix = offsetMatrix * gridWorldMatrix * targetMatrix;
+            var angle = gridWorldRotation - targetAngle;
+
+            var (x, y) = angle.RotateVec((tileSize / 4f, tileSize / 4f));
+
+            foreach (var (tile, dir) in edges)
+            {
+                // if a tile is further than max distance from the epicentre, we just ignore it.
+                var delta = tile - localEpicentre;
+                if (delta.X * delta.X + delta.Y * delta.Y > maxDistanceSq) // no Vector2.Length???
+                    continue;
+
+                var center = matrix.Transform(tile);
+
+                if ((dir & NeighborFlag.Cardinal) == 0)
+                {
+                    // this is purely a diagonal edge tile
+                    var newIndex = new Vector2i((int) MathF.Floor(center.X), (int) MathF.Floor(center.Y));
+                    if (!transformedEdges.TryGetValue(newIndex, out var data))
+                    {
+                        data = new();
+                        transformedEdges[newIndex] = data;
+                    }
+
+                    data.BlockingGridEdges.Add(new(default, null, center, angle, tileSize));
+                    continue;
+                }
+
+                // Instead of just mapping the center of the tile, we map for points on that tile. This is basically a
+                // shitty approximation to doing a proper check to get all space-tiles that intersect this grid tile.
+                // Not perfect, but works well enough.
+
+                HashSet<Vector2i> transformedTiles = new()
+                {
+                    new((int) MathF.Floor(center.X + x), (int) MathF.Floor(center.Y + x)),  // center of tile, offset by (0.25, 0.25) in tile coordinates
+                    new((int) MathF.Floor(center.X - y), (int) MathF.Floor(center.Y - y)),  // center offset by (-0.25, 0.25)
+                    new((int) MathF.Floor(center.X - x), (int) MathF.Floor(center.Y + y)),  // offset by (-0.25, -0.25)
+                    new((int) MathF.Floor(center.X + y), (int) MathF.Floor(center.Y - x)),  // offset by (0.25, -0.25)
+                };
+
+                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));
+                }
+            }
+        }
+
+        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, dir) in localEdges)
+            {
+                // grids cannot overlap, so tile should never be an existing entry.
+                // if this ever changes, this needs to do a try-get.
+                var data = new BlockedSpaceTile();
+                transformedEdges[tile] = data;
+                
+                data.UnblockedDirections = AtmosDirection.Invalid; // all directions are blocked automatically.
+
+                if ((dir & NeighborFlag.Cardinal) == 0)
+                    data.BlockingGridEdges.Add(new(default, null, ((Vector2) tile + 0.5f) * tileSize, 0, tileSize));
+                else
+                    data.BlockingGridEdges.Add(new(tile, referenceGrid.Value, ((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, BlockedSpaceTile> transformedEdges, float 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 / 2f)))
+                    data.UnblockedDirections &= ~AtmosDirection.North;
+
+                // check south
+                if (edge.Box.Contains(tileCenter + (0, -tileSize / 2f)))
+                    data.UnblockedDirections &= ~AtmosDirection.South;
+
+                // check east
+                if (edge.Box.Contains(tileCenter + (tileSize / 2f, 0)))
+                    data.UnblockedDirections &= ~AtmosDirection.East;
+
+                // check west
+                if (edge.Box.Contains(tileCenter + (-tileSize / 2f, 0)))
+                    data.UnblockedDirections &= ~AtmosDirection.West;
+            }
+        }
+    }
+
+    /// <summary>
+    ///     When a tile is updated, we might need to update the grid edge maps.
+    /// </summary>
+    private void OnTileChanged(TileChangedEvent ev)
+    {
+        // only need to update the grid-edge map if a tile was added or removed from the grid.
+        if (!ev.NewTile.Tile.IsEmpty && !ev.OldTile.IsEmpty)
+            return;
+
+        var tileRef = ev.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 (tileRef.Tile.IsEmpty)
+        {
+            // if the tile is empty, it cannot itself be an edge tile.
+            edges.Remove(tileRef.GridIndices);
+
+            // add any valid neighbours to the list of edge-tiles
+            for (var i = 0; i < NeighbourVectors.Length; i++)
+            {
+                var neighbourIndex = tileRef.GridIndices + NeighbourVectors[i];
+
+                if (grid.TryGetTileRef(neighbourIndex, out var neighbourTile) && !neighbourTile.Tile.IsEmpty)
+                {
+                    var oppositeDirection = (NeighborFlag) (1 << ((i + 4) % 8));
+                    edges[neighbourIndex] = edges.GetValueOrDefault(neighbourIndex) | oppositeDirection;
+                }
+            }
+
+            return;
+        }
+
+        // the tile is not empty space, but was previously. So update directly adjacent neighbours, which may no longer
+        // be edge tiles.
+        for (var i = 0; i < NeighbourVectors.Length; i++)
+        {
+            var neighbourIndex = tileRef.GridIndices + NeighbourVectors[i];
+
+            if (edges.TryGetValue(neighbourIndex, out var neighborSpaceDir))
+            {
+                var oppositeDirection = (NeighborFlag) (1 << ((i + 4) % 8));
+                neighborSpaceDir &= ~oppositeDirection;
+                if (neighborSpaceDir == NeighborFlag.Invalid)
+                {
+                    // no longer an edge tile
+                    edges.Remove(neighbourIndex);
+                    continue;
+                }
+
+                edges[neighbourIndex] = neighborSpaceDir;
+            }
+        }
+
+        // finally check if the new tile is itself an edge tile
+        if (IsEdge(grid, tileRef.GridIndices, out var spaceDir))
+            edges.Add(tileRef.GridIndices, spaceDir);
+    }
+
+    /// <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 NeighborFlag spaceDirections)
+    {
+        spaceDirections = NeighborFlag.Invalid;
+        for (var i = 0; i < NeighbourVectors.Length; i++)
+        {
+            if (!grid.TryGetTileRef(index + NeighbourVectors[i], out var neighborTile) || neighborTile.Tile.IsEmpty)
+                spaceDirections |= (NeighborFlag) (1 << i);
+        }
+
+        return spaceDirections != NeighborFlag.Invalid;
+    }
+
+    // yeah this is now the third direction flag enum, and the 5th (afaik) direction enum overall.....
+    /// <summary>
+    ///     Directional bitflags used to denote the neighbouring tiles of some tile on a grid.. Differ from atmos and
+    ///     normal directional flags as NorthEast != North | East
+    /// </summary>
+    [Flags]
+    public enum NeighborFlag : byte
+    {
+        Invalid = 0,
+        North = 1 << 0,
+        NorthEast = 1 << 1,
+        East = 1 << 2,
+        SouthEast = 1 << 3,
+        South = 1 << 4,
+        SouthWest = 1 << 5,
+        West = 1 << 6,
+        NorthWest = 1 << 7,
+
+        Cardinal = North | East | South | West,
+        Diagonal = NorthEast | SouthEast | SouthWest | NorthWest,
+        Any = Cardinal | Diagonal
+    }
+
+    public static bool AnyNeighborBlocked(NeighborFlag neighbors, AtmosDirection blockedDirs)
+    {
+        if ((neighbors & NeighborFlag.North) == NeighborFlag.North && (blockedDirs & AtmosDirection.North) == AtmosDirection.North)
+            return true;
+
+        if ((neighbors & NeighborFlag.South) == NeighborFlag.South && (blockedDirs & AtmosDirection.South) == AtmosDirection.South)
+            return true;
+
+        if ((neighbors & NeighborFlag.East) == NeighborFlag.East && (blockedDirs & AtmosDirection.East) == AtmosDirection.East)
+            return true;
+
+        if ((neighbors & NeighborFlag.West) == NeighborFlag.West && (blockedDirs & AtmosDirection.West) == AtmosDirection.West)
+            return true;
+
+        return false;
+    }
+
+    // array indices match NeighborFlags shifts.
+    public static readonly Vector2i[] NeighbourVectors =
+        {
+            new (0, 1),
+            new (1, 1),
+            new (1, 0),
+            new (1, -1),
+            new (0, -1),
+            new (-1, -1),
+            new (-1, 0),
+            new (-1, 1)
+        };
+}
+
+/// <summary>
+///     This class has information about the space equivalent of an airtight entity blocking explosions: the edges of grids.
+/// </summary>
+public sealed class BlockedSpaceTile
+{
+    /// <summary>
+    ///     What directions of this tile are not blocked?
+    /// </summary>
+    public AtmosDirection UnblockedDirections = AtmosDirection.All;
+
+    /// <summary>
+    ///     The set of grid edge-tiles that are blocking this space tile.
+    /// </summary>
+    public List<GridEdgeData> BlockingGridEdges = new();
+
+    public sealed class 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);
+        }
+    }
+}
diff --git a/Content.Server/Explosion/EntitySystems/ExplosionSystem.Processing.cs b/Content.Server/Explosion/EntitySystems/ExplosionSystem.Processing.cs
new file mode 100644
index 0000000000..e214203363
--- /dev/null
+++ b/Content.Server/Explosion/EntitySystems/ExplosionSystem.Processing.cs
@@ -0,0 +1,642 @@
+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;
+using Robust.Shared.Utility;
+
+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 int _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>
+    ///     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 (_activeExplosion.Area > SingleTickAreaLimit)
+                    break; // start processing next turn.
+            }
+
+            // TODO EXPLOSION  check if active explosion is on a paused map. If it is... I guess support swapping out &
+            // storing the "currently active" explosion?
+
+            var processed = _activeExplosion.Process(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, EntityQuery<PhysicsComponent> physicsQuery)
+    {
+        if (EntityManager.IsQueuedForDeletion(uid))
+            return false;
+
+        if (!physicsQuery.TryGetComponent(uid, out var physics))
+            return false;
+
+        return physics.CanCollide && physics.Hard && (physics.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 throwForce,
+        DamageSpecifier damage,
+        MapCoordinates epicenter,
+        HashSet<EntityUid> processed,
+        string id,
+        EntityQuery<TransformComponent> xformQuery,
+        EntityQuery<DamageableComponent> damageQuery,
+        EntityQuery<PhysicsComponent> physicsQuery,
+        EntityQuery<MetaDataComponent> metaQuery)
+    {
+        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, TransformComponent?) > list = new();
+
+        EntityUidQueryCallback callback = uid =>
+        {
+            if (processed.Contains(uid))
+                return;
+
+            if (!xformQuery.TryGetComponent(uid, out var xform))
+                return;
+
+            if (xform.ParentUid != grid.GridEntityId)
+            {
+                if (!metaQuery.TryGetComponent(uid, out var meta))
+                    return;
+                // Not parented to grid. Likely in a container.
+                if (_containerSystem.IsEntityInContainer(uid, meta))
+                    return;
+            }
+
+            list.Add((uid, xform));
+        };
+
+        _entityLookup.FastEntitiesIntersecting(lookup, ref gridBox, callback);
+
+        // process those entities
+        foreach (var (entity, xform) in list)
+        {
+            processed.Add(entity);
+            ProcessEntity(entity, epicenter, damage, throwForce, id, damageQuery, physicsQuery, xform);
+        }
+
+        // process anchored entities
+        var tileBlocked = false;
+        foreach (var entity in grid.GetAnchoredEntities(tile).ToList())
+        {
+            processed.Add(entity);
+            ProcessEntity(entity, epicenter, damage, throwForce, id, damageQuery, physicsQuery);
+            tileBlocked |= IsBlockingTurf(entity, physicsQuery);
+        }
+
+        // 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.
+        // And throwing is disabled for nukes anyways.
+        if (throwForce <= 0)
+            return !tileBlocked;
+
+        list.Clear();
+        _entityLookup.FastEntitiesIntersecting(lookup, ref gridBox, callback);
+
+        foreach (var (entity, xform) in list)
+        {
+            // Here we only throw, no dealing damage. Containers n such might drop their entities after being destroyed, but
+            // they should handle their own damage pass-through, with their own damage reduction calculation.
+            ProcessEntity(entity, epicenter, null, throwForce, id, damageQuery, physicsQuery, xform);
+        }
+
+        return !tileBlocked;
+    }
+
+    /// <summary>
+    ///     Same as <see cref="ExplodeTile"/>, but for SPAAAAAAACE.
+    /// </summary>
+    internal void ExplodeSpace(EntityLookupComponent lookup,
+        Matrix3 spaceMatrix,
+        Matrix3 invSpaceMatrix,
+        Vector2i tile,
+        float throwForce,
+        DamageSpecifier damage,
+        MapCoordinates epicenter,
+        HashSet<EntityUid> processed,
+        string id,
+        EntityQuery<TransformComponent> xformQuery,
+        EntityQuery<DamageableComponent> damageQuery,
+        EntityQuery<PhysicsComponent> physicsQuery,
+        EntityQuery<MetaDataComponent> metaQuery)
+    {
+        var gridBox = new Box2(tile * DefaultTileSize, (DefaultTileSize, DefaultTileSize));
+        var worldBox = spaceMatrix.TransformBox(gridBox);
+        List<(EntityUid, TransformComponent)> list = new();
+
+        EntityUidQueryCallback callback = uid =>
+        {
+            if (processed.Contains(uid))
+                return;
+
+            var xform  = xformQuery.GetComponent(uid);
+
+            if (xform.ParentUid == lookup.Owner)
+            {
+                // parented directly to the map, use local position
+                if (gridBox.Contains(invSpaceMatrix.Transform(xform.LocalPosition)))
+                    list.Add((uid, xform));
+
+                return;
+            }
+
+            if (!metaQuery.TryGetComponent(uid, out var meta))
+                return;
+
+            // Not parented to map. Likely in a container.
+            if (_containerSystem.IsEntityInContainer(uid, meta))
+                return;
+
+            // finally check if it intersects our tile
+            if (gridBox.Contains(invSpaceMatrix.Transform(xform.LocalPosition)))
+                list.Add((uid, xform));
+        };
+
+        _entityLookup.FastEntitiesIntersecting(lookup, ref worldBox, callback);
+
+        foreach (var (entity, xform) in list)
+        {
+            processed.Add(entity);
+            ProcessEntity(entity, epicenter, damage, throwForce, id, damageQuery, physicsQuery, xform);
+        }
+
+        if (throwForce <= 0)
+            return;
+
+        // Also, throw any entities that were spawned as shrapnel. Compared to entity spawning & destruction, this extra
+        // lookup is relatively minor computational cost, and throwing is disabled for nukes anyways.
+        list.Clear();
+        _entityLookup.FastEntitiesIntersecting(lookup, ref worldBox, callback);
+        foreach (var (entity, xform) in list)
+        {
+            ProcessEntity(entity, epicenter, null, throwForce, id, damageQuery, physicsQuery, xform);
+        }
+    }
+
+    /// <summary>
+    ///     This function actually applies the explosion affects to an entity.
+    /// </summary>
+    private void ProcessEntity(
+        EntityUid uid,
+        MapCoordinates epicenter,
+        DamageSpecifier? damage,
+        float throwForce,
+        string id,
+        EntityQuery<DamageableComponent> damageQuery,
+        EntityQuery<PhysicsComponent> physicsQuery,
+        TransformComponent? xform = null)
+    {
+        // damage
+        if (damage != null && damageQuery.TryGetComponent(uid, out var damageable))
+        {
+            var ev = new GetExplosionResistanceEvent(id);
+            RaiseLocalEvent(uid, ev, false);
+
+            if (ev.Resistance == 0)
+            {
+                // no damage-dict multiplication required.
+                _damageableSystem.TryChangeDamage(uid, damage, ignoreResistances: true, damageable: damageable);
+            }
+            else if (ev.Resistance < 1)
+            {
+                _damageableSystem.TryChangeDamage(uid, damage * (1 - ev.Resistance), ignoreResistances: true, damageable: damageable);
+            }
+        }
+
+        // throw
+        if (xform != null
+            && !xform.Anchored
+            && throwForce > 0
+            && !EntityManager.IsQueuedForDeletion(uid)
+            && physicsQuery.TryGetComponent(uid, out var physics)
+            && physics.BodyType == BodyType.Dynamic)
+        {
+            // TODO purge throw helpers and pass in physics component
+            _throwingSystem.TryThrow(uid, xform.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();
+
+    private EntityQuery<TransformComponent> _xformQuery;
+    private EntityQuery<PhysicsComponent> _physicsQuery;
+    private EntityQuery<DamageableComponent> _damageQuery;
+    private EntityQuery<MetaDataComponent> _metaQuery;
+
+    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,
+        IEntityManager entMan,
+        IMapManager mapMan)
+    {
+        _system = system;
+        ExplosionType = explosionType;
+        _tileSetIntensity = tileSetIntensity;
+        Epicenter = epicenter;
+        Area = area;
+
+        _xformQuery = entMan.GetEntityQuery<TransformComponent>();
+        _physicsQuery = entMan.GetEntityQuery<PhysicsComponent>();
+        _damageQuery = entMan.GetEntityQuery<DamageableComponent>();
+        _metaQuery = entMan.GetEntityQuery<MetaDataComponent>();
+
+        if (spaceData != null)
+        {
+            var mapUid = mapMan.GetMapEntityId(epicenter.MapId);
+
+            _explosionData.Add(new()
+            {
+                TileLists = spaceData.TileLists,
+                Lookup = entMan.GetComponent<EntityLookupComponent>(mapUid),
+                MapGrid = null
+            });
+
+            _spaceMatrix = spaceMatrix;
+            _invSpaceMatrix = Matrix3.Invert(spaceMatrix);
+        }
+
+        foreach (var grid in gridData)
+        {
+            _explosionData.Add(new()
+            {
+                TileLists = grid.TileLists,
+                Lookup = entMan.GetComponent<EntityLookupComponent>(grid.Grid.GridEntityId),
+                MapGrid = grid.Grid
+            });
+        }
+
+        if (TryGetNextTileEnumerator())
+            MoveNext();
+    }
+
+    private bool TryGetNextTileEnumerator()
+    {
+        while (CurrentIteration < _tileSetIntensity.Count)
+        {
+            _currentIntensity = _tileSetIntensity[CurrentIteration];
+            _currentDamage = ExplosionType.DamagePerIntensity * _currentIntensity;
+
+            // only throw if either the explosion is small, or if this is the outer ring of a large explosion.
+            var doThrow = Area < _system.ThrowLimit || CurrentIteration > _tileSetIntensity.Count - 6;
+            _currentThrowForce = doThrow ? 10 * MathF.Sqrt(_currentIntensity) : 0;
+
+            // 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 Process(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,
+                    _currentThrowForce,
+                    _currentDamage,
+                    Epicenter,
+                    ProcessedEntities,
+                    ExplosionType.ID,
+                    _xformQuery,
+                    _damageQuery,
+                    _physicsQuery,
+                    _metaQuery);
+
+                // was there a blocking entity on the tile that was not destroyed by the explosion?
+                if (canDamageFloor)
+                    _system.DamageFloorTile(tileRef, _currentIntensity, tileUpdateList, ExplosionType);
+            }
+            else
+            {
+                _system.ExplodeSpace(_currentLookup,
+                    _spaceMatrix,
+                    _invSpaceMatrix,
+                    _currentEnumerator.Current,
+                    _currentThrowForce,
+                    _currentDamage,
+                    Epicenter,
+                    ProcessedEntities,
+                    ExplosionType.ID,
+                    _xformQuery,
+                    _damageQuery,
+                    _physicsQuery,
+                    _metaQuery);
+            }
+
+            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..4694fae048
--- /dev/null
+++ b/Content.Server/Explosion/EntitySystems/ExplosionSystem.TileFill.cs
@@ -0,0 +1,337 @@
+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;
+
+        if (!_explosionTypes.TryGetValue(typeID, out var typeIndex))
+        {
+            Logger.Error("Attempted to spawn explosion using a prototype that was not defined during initialization. Explosion prototype hot-reload is not currently supported.");
+            return null;
+        }
+
+        Vector2i initialTile;
+        GridId? epicentreGrid = null;
+        var (localGrids, referenceGrid, maxDistance) = 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,
+                typeIndex,
+                _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, referenceGrid, localGrids, maxDistance);
+            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 = 1;
+        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,
+                        typeIndex,
+                        _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, referenceGrid, localGrids, maxDistance);
+
+            // 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;
+        }
+
+        // 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?, float) 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 included 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.
+
+        radius *= 4;
+        box = Box2.CenteredAround(epicenter.Position, (radius, radius));
+        var mapGrids = _mapManager.FindGridsIntersecting(epicenter.MapId, box).ToList();
+        var grids = mapGrids.Select(x => x.Index).ToList();
+
+        if (referenceGrid != null)
+            return (grids, referenceGrid, radius);
+
+        // 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, radius);
+    }
+
+    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..5a6ac55990 100644
--- a/Content.Server/Explosion/EntitySystems/ExplosionSystem.cs
+++ b/Content.Server/Explosion/EntitySystems/ExplosionSystem.cs
@@ -1,392 +1,313 @@
-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.Damage;
 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.Explosion;
+using Content.Shared.Throwing;
+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;
+using Robust.Shared.Utility;
 
-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!;
+    [Dependency] private readonly AdminLogSystem _logsSystem = default!;
+    [Dependency] private readonly ThrowingSystem _throwingSystem = 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);
+
+    /// <summary>
+    ///     The "default" explosion prototype.
+    /// </summary>
+    /// <remarks>
+    ///     Generally components should specify an explosion prototype via a yaml datafield, so that the yaml-linter can
+    ///     find errors. However some components, like rogue arrows, or some commands like the admin-smite need to have
+    ///     a "default" option specified outside of yaml data-fields. Hence this const string.
+    /// </remarks>
+    public const string DefaultExplosionPrototypeId = "Default";
+
+    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);
+        DebugTools.Assert(_prototypeManager.HasIndex<ExplosionPrototype>(DefaultExplosionPrototypeId));
 
-        /// <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 ExplosionSystemGridMap.cs
+        SubscribeLocalEvent<GridRemovalEvent>(OnGridRemoved);
+        SubscribeLocalEvent<GridStartupEvent>(OnGridStartup);
+        SubscribeLocalEvent<ExplosionResistanceComponent, GetExplosionResistanceEvent>(OnGetResistance);
+        SubscribeLocalEvent<TileChangedEvent>(OnTileChanged);
 
-        // TODO move this to the component
-        private static readonly SoundSpecifier ExplosionSound = new SoundCollectionSpecifier("explosion");
+        // handled in ExplosionSystemAirtight.cs
+        SubscribeLocalEvent<AirtightComponent, DamageChangedEvent>(OnAirtightDamaged);
+        SubscribeCvars();
+        InitAirtightMap();
+    }
 
-        [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!;
+    public override void Shutdown()
+    {
+        base.Shutdown();
+        UnsubscribeCvars();
+    }
 
-        [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!;
+    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;
+    }
 
-        private bool IgnoreExplosivePassable(EntityUid e)
+    /// <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, EntityUid? user = 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;
+
+        // 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,
+            user);
+
+        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 totalIntensity,
+        float slope,
+        float maxTileIntensity,
+        EntityUid? user = null,
+        bool addLog = false)
+    {
+        var pos = Transform(uid).MapPosition;
+
+
+        QueueExplosion(pos, typeId, totalIntensity, slope, maxTileIntensity, addLog: false);
+
+        if (!addLog)
+            return;
+
+        if (user == null)
+            _logsSystem.Add(LogType.Explosion, LogImpact.High,
+                $"{ToPrettyString(uid):entity} exploded at {pos:coordinates} with intensity {totalIntensity} slope {slope}");
+        else
+            _logsSystem.Add(LogType.Explosion, LogImpact.High,
+                $"{ToPrettyString(user.Value):user} caused {ToPrettyString(uid):entity} to explode at {pos:coordinates} with intensity {totalIntensity} slope {slope}");
+    }
+
+    /// <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,
+        bool addLog = false)
+    {
+        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)
+        if (addLog) // dont log if already created a separate, more detailed, log.
+            _logsSystem.Add(LogType.Explosion, LogImpact.High, $"Explosion spawned at {epicenter:coordinates} with intensity {totalIntensity} slope {slope}");
+        
+        _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,
+            EntityManager,
+            _mapManager);
+    }
+
+    /// <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, spaceData?.TileSize ?? DefaultTileSize);
+    }
+
+    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/GridExplosion.cs b/Content.Server/Explosion/EntitySystems/GridExplosion.cs
new file mode 100644
index 0000000000..e1632d0c70
--- /dev/null
+++ b/Content.Server/Explosion/EntitySystems/GridExplosion.cs
@@ -0,0 +1,304 @@
+using Content.Shared.Atmos;
+using Robust.Shared.Map;
+using static Content.Server.Explosion.EntitySystems.ExplosionSystem;
+
+namespace Content.Server.Explosion.EntitySystems;
+
+public sealed class GridExplosion : TileExplosion
+{
+    public IMapGrid Grid;
+    private bool _needToTransform = false;
+
+    private Matrix3 _matrix = Matrix3.Identity;
+    private Vector2 _offset;
+
+    // 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 int _typeIndex;
+
+    private UniqueVector2iSet _spaceTiles = new();
+    private UniqueVector2iSet _processedSpaceTiles = new();
+
+    public HashSet<Vector2i> SpaceJump = new();
+
+    private Dictionary<Vector2i, NeighborFlag> _edgeTiles;
+
+    public GridExplosion(
+        IMapGrid grid,
+        Dictionary<Vector2i, TileData> airtightMap,
+        float maxIntensity,
+        float intensityStepSize,
+        int typeIndex,
+        Dictionary<Vector2i, NeighborFlag> edgeTiles,
+        GridId? referenceGrid,
+        Matrix3 spaceMatrix,
+        Angle spaceAngle)
+    {
+        Grid = grid;
+        _airtightMap = airtightMap;
+        _maxIntensity = maxIntensity;
+        _intensityStepSize = intensityStepSize;
+        _typeIndex = typeIndex;
+        _edgeTiles = edgeTiles;
+
+        // initialise SpaceTiles
+        foreach (var (tile, spaceNeighbors) in _edgeTiles)
+        {
+            for (var i = 0; i < NeighbourVectors.Length; i++)
+            {
+                var dir = (NeighborFlag) (1 << i);
+                if ((spaceNeighbors & dir) != NeighborFlag.Invalid)
+                    _spaceTiles.Add(tile + NeighbourVectors[i]);
+            }
+        }
+
+        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 override void InitTile(Vector2i initialTile)
+    {
+        TileLists[0] = new() { initialTile };
+
+        if (_airtightMap.ContainsKey(initialTile))
+            EnteredBlockedTiles.Add(initialTile);
+        else
+            ProcessedTiles.Add(initialTile);
+    }
+
+    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))
+        {
+            HashSet<Vector2i> toRemove = new();
+            foreach (var tile in freed)
+            {
+                if (!EnteredBlockedTiles.Add(tile))
+                    toRemove.Add(tile);
+            }
+
+            freed.ExceptWith(toRemove);
+            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?
+        {
+            blocked = AnyNeighborBlocked(_edgeTiles[tile], blockedDirections); // 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?
+            var clearIteration = iteration + (int) MathF.Ceiling(tileData.ExplosionTolerance[_typeIndex] / _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;
+                sealIntegrity = tileData.ExplosionTolerance[_typeIndex];
+            }
+
+            // 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..e00653ed88
--- /dev/null
+++ b/Content.Server/Explosion/EntitySystems/SpaceExplosion.cs
@@ -0,0 +1,160 @@
+using Content.Shared.Atmos;
+using Robust.Shared.Map;
+
+namespace Content.Server.Explosion.EntitySystems;
+
+public 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, BlockedSpaceTile> _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>
+    public Dictionary<GridId, HashSet<Vector2i>> GridJump = new();
+
+    public ushort TileSize = ExplosionSystem.DefaultTileSize;
+
+    public SpaceExplosion(ExplosionSystem system, MapCoordinates epicentre, GridId? referenceGrid, List<GridId> localGrids, float maxDistance)
+    {
+        (_gridBlockMap, TileSize) = system.TransformGridEdges(epicentre, referenceGrid, localGrids, maxDistance);
+        system.GetUnblockedDirections(_gridBlockMap, TileSize);
+    }
+
+    public 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(BlockedSpaceTile 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());
+            }
+        }
+    }
+
+    public override void InitTile(Vector2i initialTile)
+    {
+        ProcessedTiles.Add(initialTile);
+        TileLists[0] = new() { 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..c09c9255d4
--- /dev/null
+++ b/Content.Server/Explosion/EntitySystems/TileExplosion.cs
@@ -0,0 +1,191 @@
+using Content.Shared.Atmos;
+using System.Runtime.CompilerServices;
+
+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>
+public abstract class TileExplosion
+{
+    // Main tile data sets, mapping iterations onto tile lists
+    public 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 UniqueVector2iSet ProcessedTiles = new();
+    protected UniqueVector2iSet UnenteredBlockedTiles = new();
+    protected UniqueVector2iSet EnteredBlockedTiles = new();
+
+    public abstract void InitTile(Vector2i 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>
+    public void CleanUp()
+    {
+        foreach (var (iteration, blocked) in BlockedTileLists)
+        {
+            if (TileLists.TryGetValue(iteration, out var tiles))
+                tiles.AddRange(blocked);
+            else
+                TileLists[iteration] = blocked;
+        }
+    }
+}
+
+/// <summary>
+///     This is a data structure can be used to ensure the uniqueness of Vector2i indices.
+/// </summary>
+/// <remarks>
+///     This basically exists to replace the use of HashSet<Vector2i> if all you need is the the functions Contains()
+///     and Add(). This is both faster and apparently allocates less. Does not support iterating over contents
+/// </remarks>
+public sealed class UniqueVector2iSet
+{
+    private const int ChunkSize = 32; // # of bits in an integer.
+
+    private Dictionary<Vector2i, VectorChunk> _chunks = new();
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public Vector2i ToChunkIndices(Vector2i indices)
+    {
+        var x = (int) Math.Floor(indices.X / (float) ChunkSize);
+        var y = (int) Math.Floor(indices.Y / (float) ChunkSize);
+        return new Vector2i(x, y);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public bool Add(Vector2i index)
+    {
+        var chunkIndex = ToChunkIndices(index);
+        if (_chunks.TryGetValue(chunkIndex, out var chunk))
+        {
+            return chunk.Add(index);
+        }
+
+        chunk = new();
+        chunk.Add(index);
+        _chunks[chunkIndex] = chunk;
+
+        return true;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public bool Contains(Vector2i index)
+    {
+        if (!_chunks.TryGetValue(ToChunkIndices(index), out var chunk))
+            return false;
+
+        return chunk.Contains(index);
+    }
+
+    private sealed class VectorChunk
+    {
+        // 32*32 chunk represented via 32 ints with 32 bits each. Basic testing showed that this was faster than using
+        // 16-sized chunks with ushorts, a bool[,], or just having each chunk be a HashSet.
+        private readonly int[] _tiles = new int[ChunkSize];
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool Add(Vector2i index)
+        {
+            var x = MathHelper.Mod(index.X, ChunkSize);
+            var y = MathHelper.Mod(index.Y, ChunkSize);
+
+            var oldFlags = _tiles[x];
+            var newFlags = oldFlags | (1 << y);
+
+            if (newFlags == oldFlags)
+                return false;
+
+            _tiles[x] = newFlags;
+            return true;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool Contains(Vector2i index)
+        {
+            var x = MathHelper.Mod(index.X, ChunkSize);
+            var y = MathHelper.Mod(index.Y, ChunkSize);
+            return (_tiles[x] & (1 << y)) != 0;
+        }
+    }
+}
diff --git a/Content.Server/Explosion/EntitySystems/TriggerSystem.cs b/Content.Server/Explosion/EntitySystems/TriggerSystem.cs
index ffa72a0039..6515f9c4c2 100644
--- a/Content.Server/Explosion/EntitySystems/TriggerSystem.cs
+++ b/Content.Server/Explosion/EntitySystems/TriggerSystem.cs
@@ -55,33 +55,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, user: args.User);
         }
 
-        // 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 ecd3b8bc72..11dcbdaf88 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 4374099eb7..94a7201a2d 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()
@@ -388,19 +388,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..02b486bcc9 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, ExplosionSystem.DefaultExplosionPrototypeId, 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 b67e1dddba..2019803ef1 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 971f9b11af..c715e85876 100644
--- a/Content.Server/Storage/Components/ServerStorageComponent.cs
+++ b/Content.Server/Storage/Components/ServerStorageComponent.cs
@@ -44,7 +44,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!;
         [Dependency] private readonly IEntitySystemManager _sysMan = default!;
@@ -630,30 +630,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 a50895f2bd..ed6abb8828 100644
--- a/Content.Shared/CCVar/CCVars.cs
+++ b/Content.Shared/CCVar/CCVars.cs
@@ -408,6 +408,106 @@ 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.tiles_per_tick", 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.throw_limit", 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.node_sleep", 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.max_area", (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.max_iterations", 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.max_tick_time", 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.incremental_tile", false, CVar.SERVERONLY);
+
+        /// <summary>
+        ///     Client-side explosion visuals: for how many seconds should an explosion stay on-screen once it has
+        ///     finished expanding?
+        /// </summary>
+        public static readonly CVarDef<float> ExplosionPersistence =
+            CVarDef.Create("explosion.persistence", 0.3f, CVar.REPLICATED);
+
+        /// <summary>
+        ///     If an explosion covers a larger area than this number, the damaging/processing will always start during
+        ///     the next tick, instead of during the same tick that the explosion was generated in.
+        /// </summary>
+        /// <remarks>
+        ///     This value can be used to ensure that for large explosions the area/tile calculation and the explosion
+        ///     processing/damaging occurs in separate ticks. This helps reduce the single-tick lag if both <see
+        ///     cref="ExplosionMaxProcessingTime"/> and <see cref="ExplosionTilesPerTick"/> are large. I.e., instead of
+        ///     a single tick explosion, this cvar allows for a configuration that results in a two-tick explosion,
+        ///     though most of the computational cost is still in the second tick.
+        /// </remarks>
+        public static readonly CVarDef<int> ExplosionSingleTickAreaLimit =
+            CVarDef.Create("explosion.single_tick_area_limit", 400, 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/Damage/Systems/DamageableSystem.cs b/Content.Shared/Damage/Systems/DamageableSystem.cs
index 6902a3e943..d2a198c329 100644
--- a/Content.Shared/Damage/Systems/DamageableSystem.cs
+++ b/Content.Shared/Damage/Systems/DamageableSystem.cs
@@ -107,9 +107,9 @@ namespace Content.Shared.Damage
         ///     null if the user had no applicable components that can take damage.
         /// </returns>
         public DamageSpecifier? TryChangeDamage(EntityUid? uid, DamageSpecifier damage, bool ignoreResistances = false,
-            bool interruptsDoAfters = true)
+            bool interruptsDoAfters = true, DamageableComponent? damageable = null)
         {
-            if (!EntityManager.TryGetComponent<DamageableComponent>(uid, out var damageable))
+            if (!uid.HasValue || !Resolve(uid.Value, ref damageable, false))
             {
                 // TODO BODY SYSTEM pass damage onto body system
                 return null;
diff --git a/Content.Shared/Explosion/ExplosionEvents.cs b/Content.Shared/Explosion/ExplosionEvents.cs
new file mode 100644
index 0000000000..aef746d391
--- /dev/null
+++ b/Content.Shared/Explosion/ExplosionEvents.cs
@@ -0,0 +1,85 @@
+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 sealed 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 sealed 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 int ExplosionId;
+
+    public ushort SpaceTileSize;
+
+    public ExplosionEvent(
+        int explosionId,
+        MapCoordinates epicenter,
+        string typeID,
+        List<float> intensity,
+        Dictionary<int, List<Vector2i>>? spaceTiles,
+        Dictionary<GridId, Dictionary<int, List<Vector2i>>> tiles,
+        Matrix3 spaceMatrix,
+        ushort spaceTileSize)
+    {
+        Epicenter = epicenter;
+        SpaceTiles = spaceTiles;
+        Tiles = tiles;
+        Intensity = intensity;
+        TypeID = typeID;
+        SpaceMatrix = spaceMatrix;
+        ExplosionId = explosionId;
+        SpaceTileSize = spaceTileSize;
+    }
+}
+
+/// <summary>
+///     Update visual rendering of the explosion to correspond to the servers processing of it.
+/// </summary>
+[Serializable, NetSerializable]
+public sealed class ExplosionOverlayUpdateEvent : EntityEventArgs
+{
+    public int Index;
+    public int ExplosionId;
+
+    public ExplosionOverlayUpdateEvent(int 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..3d5e03952b
--- /dev/null
+++ b/Content.Shared/Explosion/ExplosionPrototype.cs
@@ -0,0 +1,104 @@
+using Content.Shared.Damage;
+using Content.Shared.Sound;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Utility;
+
+namespace Content.Shared.Explosion;
+
+/// <summary>
+///     Explosion Prototype. Determines damage, tile break probabilities, and visuals.
+/// </summary>
+/// <remarks>
+///     Does not currently support prototype hot-reloading. The explosion-intensity required to destroy airtight
+///     entities is evaluated and stored by the explosion system. Adding or removing a prototype would require updating
+///     that map of airtight entities. This could be done, but is just not yet implemented.
+/// </remarks>
+[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 ResourcePath TexturePath = new("/Textures/Effects/fire.rsi");
+
+    /// <summary>
+    ///     How intense does the explosion have to be at a tile to advance to the next fire texture state?
+    /// </summary>
+    [DataField("intensityPerState")]
+    public float IntensityPerState = 12;
+
+    // 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 the _tileBreakChance and _tileBreakIntensity arrays
+    /// </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/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/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 b78a8356f8..41726c91b5 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 48a46bc9c9..47da2c0860 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 fd06120419..b6cde8a3a7 100644
--- a/Resources/Prototypes/Entities/Objects/Devices/nuke.yml
+++ b/Resources/Prototypes/Entities/Objects/Devices/nuke.yml
@@ -21,6 +21,12 @@
         layer:
         - SmallImpassable
     - type: Nuke
+      # ~50 tile radius in open space
+      # close to defaulkt max cap.
+      explosionType: Default
+      maxIntensity: 100
+      intensitySlope: 5
+      totalIntensity: 500000
       diskSlot:
         name: Disk
         insertSound:
diff --git a/Resources/Prototypes/Entities/Objects/Power/powercells.yml b/Resources/Prototypes/Entities/Objects/Power/powercells.yml
index 91d8b07258..1095d09da2 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 d0a8474342..b7ade5dabe 100644
--- a/Resources/Prototypes/Entities/Objects/Tools/gas_tanks.yml
+++ b/Resources/Prototypes/Entities/Objects/Tools/gas_tanks.yml
@@ -23,6 +23,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..02c3acf4f1 100644
--- a/Resources/Prototypes/Entities/Objects/Weapons/Guns/Projectiles/meteors.yml
+++ b/Resources/Prototypes/Entities/Objects/Weapons/Guns/Projectiles/meteors.yml
@@ -18,10 +18,10 @@
     damage: {}
     deleteOnCollide: false
   - type: Explosive
-    devastationRange: 3
-    heavyImpactRange: 5
-    lightImpactRange: 7
-    flashRange: 10
+    explosionType: Default
+    totalIntensity: 600.0
+    intensitySlope: 30
+    maxIntensity: 45
   - type: Physics
     bodyType: Dynamic
     fixedRotation: false
@@ -29,7 +29,7 @@
     fixtures:
     - shape:
         !type:PhysShapeCircle
-          radius: 0.5
+          radius: 0.8
       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 23a624c138..4c51c726f7 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: 40
+    intensitySlope: 6
+    totalIntensity: 200
   - type: PointLight
     radius: 3.5
     color: orange
@@ -251,10 +251,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
@@ -282,10 +281,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 e51ace2f79..2a328771ca 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,12 @@
   - type: OnUseTimerTrigger
     delay: 5
   - type: Explosive
-    devastationRange: 1
-    heavyImpactRange: 3
-    lightImpactRange: 5
-    flashRange: 10
+    explosionType: Default
+    # About a 3-3.5 tile radius, strong enough to break reinforced walls near centre.
+    # Currently a big spacing hazzard.
+    totalIntensity: 800
+    intensitySlope: 15
+    maxIntensity: 45
   - type: ExplodeOnTrigger
   - type: Damageable
     damageContainer: Inorganic
@@ -129,9 +131,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/Objects/base_item.yml b/Resources/Prototypes/Entities/Objects/base_item.yml
index a55b296db9..5141e9c5bd 100644
--- a/Resources/Prototypes/Entities/Objects/base_item.yml
+++ b/Resources/Prototypes/Entities/Objects/base_item.yml
@@ -35,4 +35,3 @@
     drawdepth: Items
     noRot: false
   - type: Pullable
-  - type: ExplosionLaunched
diff --git a/Resources/Prototypes/Entities/Structures/Power/Generation/ame.yml b/Resources/Prototypes/Entities/Structures/Power/Generation/ame.yml
index 5d030735f3..2ed868b2cd 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: ActivatableUI
     key: enum.AMEControllerUiKey.Key
   - type: UserInterface
diff --git a/Resources/Prototypes/Entities/Structures/Power/substation.yml b/Resources/Prototypes/Entities/Structures/Power/substation.yml
index 6158fa8404..fed74d69eb 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 694f0c90e3..4d7bd5c150 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 a871719d15..c82d956be9 100644
--- a/Resources/Prototypes/Recipes/Reactions/chemicals.yml
+++ b/Resources/Prototypes/Recipes/Reactions/chemicals.yml
@@ -89,13 +89,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 22affe6422..4112b9994c 100644
--- a/Resources/Prototypes/Recipes/Reactions/pyrotechnic.yml
+++ b/Resources/Prototypes/Recipes/Reactions/pyrotechnic.yml
@@ -37,13 +37,13 @@
     Fluorine:
       amount: 3
   effects:
-  # TODO electro's pretty explosions PR make this big and firey!!
   # TODO solution temperature!!
   - !type:ExplosionReactionEffect
-    devastationRange: 0
-    heavyImpactRange: 0
-    lightImpactRange: 2
-    scaled: false
+    explosionType: Default # 15 damage per intensity.
+    maxIntensity: 1 # at most 15 damage per tile.
+    intensityPerUnit: 3 # 12 total input reagent units reach max total intensity
+    intensitySlope: 0.5
+    maxTotalIntensity: 9
   - !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..a6206d5f79
--- /dev/null
+++ b/Resources/Prototypes/explosion.yml
@@ -0,0 +1,41 @@
+#  Does not currently support prototype hot-reloading. See comments in c# file.
+
+- 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
zcmdSBWmp?u+x8m>?(R@Xf)*(hcMI+=rKPw#w1rZvP$Wo#w73+v;##aYEv_Y4ffC%M
zXm|e4z2AMj$NSuSAJ2aG^JP!wOJ*`_CbL#%UDtX3uKZp2y9OZBP*GO_U|;|M80Z(^
zFA|^x0AgbPv!WL)^oos#jg5tcO@NDwgGWR_L_|nHNJvaVK}JkMPC`gXMngtUNkvUf
zO+-pdM?*zNK}AjVPa_yW^f6f2_}JL^RK$eDRR6D+zuf?GJir<T0EhtsV3K11$ua)+
z0T=-2_vi)ie=V3mEDUS_4tk$382}RlebJcMKp^&id<Fx(lbj7eAxNp94|<7B<sAkG
z3*}G#I#%?p?Kv@c>VrOt>VIzRU#<SLmHdA?#s9f=5kLgQKwk=w93Tg{Ic?-qtd<Np
z7~BCQy1jUIvlu$FTL9F<%G5&e|7!6~Y@vBHZ*)PCAVLn2n)#xW<u2fA)<pb=lXG|=
zTUyBUtxRzS$5O1u=NDdUt4;%ZC-GRnjcsEf2!{7wl5n+dusbK~D^}#mLGje2f-z>B
z;rXW0^kV_H#ZAUl7-eZeNld|B#H_sn+0JS4+9r#e?;W#2N-E)FJ>j~qYV-#LZp2=}
zVw}yP!dOPysu1hPbMUYG)<5ZxK}fk5osBLID>htvQV5D$;}DcaHd_KK2-%wP!=|_F
zQPbtg_4LkqMcHTd!e}J}1$KsmxW&1<ZMH7~uQPH$4i!Q_H<Bo@7rTRT-*r24>+dnz
z@^C+zIC-KM^=%hpz|Gq&$oU&sMssYmu3*7xU{}B<0M&o|)c3P<Mvb&>;Woh3?3wi{
zU5&@v>j}#fT6~VFb#p2%9#Tl|5?~C#ac67zSlygh0&16L6VP~=M|di_X8lg3+9V<E
zwWBL<A`5*c_Ba@c`{*yg!nRF+!Y{(Yz<41}Q0MB3X2Q4l&xfIQ8jNrXK8D6mW|^d0
zi`&yiP<@tJ{`UUKPb_$?066k5KxBjrC;hkJxvBlw+*h}z4X0Y%g9=$jy_&E3MGI<$
z5{qt(0E~C59ycVx%4!X33ey3Jlg?r7Eb85@&CN5rQC!1JiDdC?Flj{63zvl@qNUt%
z$;F0%%9x6ub}@EN_vpLB=*(E3g9p~CDvC`@%O|%`e{@0j{p}UxMgJFfKnDA+yhG~P
ztaW>Qc-qm{2A$+gl)60mB3YAE6M5X$mGsrr0~_%Xllx5i#}E@?PTu)0aoWzZSI#%^
z!6#Bi1Nuj|RW>>vsv(`BC~A(x*F0md^>_s~<KlMJU9)X)AiO=_gg;y+ujWY5b=~jD
zvY+4-6b6Qt2D(+UDgw!H#mDJ}<TPF0f4R=!{8V?rh8=#`&hP8h(s3w<l9v-tImd?-
zJsMeiEOOvkJ74<DSeZsy!Gt)rW_@{I#l3y;CdMVLurvW$o+j<4-vW%t?NptJ_mfQB
zs_AKzWY-?yW_;eA`KJHj1`jItJx{}?F2cbypdE+rR)IA~0X3GZ#;!T0PTquNFTcp|
zZQa~ed+0BM4eHnB<?h4_WBdHrL2MHtaboSa&1Gl9U@En)_glTiFl%A!&x0RciE&AW
zT1r${(opSCAE57;pKthP)i~C+rJuQ&?dmfoj)(7GK=4^!3g0t$ZRfWF`Th0pnJaTB
zIheCH%TIb1d<G#PkUBj+j2_v|n$z3lM+wzojSb}Hc|R?&%rMdvH~lsu%Mm?7d?Toc
zPL*a-!34iBXvJB9p6?`Xoj{-8l)sPR=>wC94dErrVzg}By3D@HdHo$1pM{|9*=mkw
z!rS{V*;pt0l`-o)RyQUY{GX6txmXZx5@KDo(+ksl{_v2=+A|*o)Jbq)frjS?ZOCNO
z51lRDhfKEUn$Eo!45;b3Zx!P9sqZ0eG_<ZHzISHm?*l9;HT(J5ptORyS)hD5vUBrt
zE`qJJZ0UeOz1i)fsACscyaw2$J}1IRm)fK`%^DdN;DNO9O@<LUnhX2|6iH4Fq%13R
z*pbt0I&{Nwck*1DtHrbNeDc%1=Eg|8BQEB8Eg^Nf6Kq?}dC#mOqtBPjLP;-Y!prii
zQtdvR&y&b=tY4j+Z>(nRZWsO(l1vYv-i6Y$M$zo+V)<tJ=E2uAK88UA(``UdwM>~X
zRAcSM-40?>Epr1=Y(BYV5cy)JFyLTq14eSEq|2kzs6Q!hlfeo$e=&a(Jls7X_kFib
z!ZFJHxgrMzAOXuV*e;YbA~b|{LY9_Xdj|J)3g2NLiCW{=%W-&dn;(NSIR5#{d$Sap
z&9$&0+_7ZkM|L&ovz526-tVO0++B+eO5(kH<UXZB&Y}H<<9=v?GjnTTMQR&&{Sk@N
z-lpJ1RsCzhP&1j6h@r-MPX?{W!b!sU&n4z3s8SsP<mbShBBQ%m8Q(#wbvon2FkAK^
z3AbZ@&$VE`LG!!{{vWfLPR$SHH}bf^T@TWD%nI<6d4ja$3a|WOS2eu9fZZiWD?#Nt
zW8qXO7TcR3)5&lQ$P1+N-L8!ZPwAW*wN`mw^s+k}I5{W)XVuDt!y?wqrWht>M5<h=
zGx;_P7148aJ;9edmsCe~xwIG6<mC%{RNchzlO6Fcj8vopbA6vzwRpV`5YkkTQ1SVN
zVFw|{#*A$7(OX;QDo>Q;w)|z1Mz$>(#zuUlk}VBqxWs4!<+xsLy-Jb3iIm3+<95Q}
z;e$$t%&ija4DsK{CfBu&YZM)egydkc40~|hd8M&6<11t)Q<g34a_UEiYP@qERsPuT
z<N`IZzkp2^-SY`UmXV<xP|<3UbHPr0`?s(ij^5;;TV|Pfp?P!Kd&Wm%5S9?yIc*s}
zqPkH+-uSk|(9?Ogs+YlYog&yWZano-=4OhT`7Z-%P;&i=R}&x}Z!E(}bt8`SvF$nI
zhUb}^OdE37<s|{dFtua)-*{lV822p3X9*HL<0n<I@mu8-kP0%G_$n(%>krOG;=$*t
zk8fwD)GqMgYI!PUE%iYUzWd@`tkG*!jTDM*FL~_DHf?CVr7@vZzSpw?itD0gs?RDs
z6=CI`zNp*n@>HH;*r83+YHOA`_EC@}r(C?o-t@=fnbWUs7+*zgLsbHfiN`UoS%e8=
zqYbKd_75+ue{3f8S2a+cgJu0+^sK@0a$NI1;z$9gmezYz&kEm4Mni-YShhi}#Eit1
zp2HB|_4(-?E_NX(?-=@?5!ALNc#e67<p$&2^?CO&{^-7OGs7k@Ypn7;@*MDMlZQl&
zH%UeYrGmSHmK^!UMB)VWC(YYVd6xC~2B7`pt+cqEDivjK4kxtQS$SSbKI2~(2e#Bo
zoaNC{Q%<HERis%JL1&)%`nNo^DW@isKIi%_dmN>xGwtE^8Wn~f+ED8fM6rm9pyWYh
zFt5qdYVuXrw29$7!w{_55X5F(`BRh8ju4<do)`>Z_)pW6u(~6L!9=;)5*uBo2R^DR
zn{%CP<z!%4J^j^%t)kCp&{<f}?&rrER-jK5q4}z~R~Y}ArXq4pscZn;H*Uk*$S1DJ
z!_v=?$X&m!e>aaxj*c7Bj=z6BXUM#f?5rmbepMkh1V%zFHL3ad6hRFLxn04u>qE7!
zxaW&l#-<GRaJr;&HD<DJf24!X+?>Cg3~MvLuMa0Kp*5i$YH9Kf55Zi_l4o#C8Jx8G
zC}nX{hm0@id(@Q9*n7H815J}4J0dCZxU=ZHY}q8aA+XCD$u#cE#Qb1+#euBNGRv(U
zC=pV(#C`(hIThS#8EPCqWc0wnl~pN=iNsHUDy!Oogbu>zx*>$HM<{KG{v_23)(6)b
zOEIm@<acX{lK5=iRLk<OViZ^Q<u~Ij$K9?OTuT&+5#qB4+t3&V4;?(F(6>9n3YVJr
z*%sr?uXWO`J;#&Z`sRK3b^A(_&L~~<Yvy59xaXLg`$lJ&C#KO?d^Xs3ata>hpZlaT
zRf%6vT4}M$t4ygvV~Ij3JP$?SW=~uu>sRYsTaoLf7Q$rT8P5Ca0xPpnLxU&fPQ@AA
z><AS~d@8VeocmG|#<3Ua`VD}pO2(}UvReGp3!jFzIk$x6&e0Ugat)`_tP#-R#shFQ
zTfgCit;X}s&ofnTw&+zZSfYU9!#A!k3lQ9#+kj-t2{-<Nz8eoW4B+iH)hrBTyegoD
zY2yF0-935?N9bw1UDrd(fhx%8e4rnuVH%c6;T2Nd6zC7nfD-IZuDaZKE?FLu20Kv@
z#AXjoL4pDXZS8}O1vA5?*5a{6$fw_`IJ3d9tpn=+0#1MOV#i-uT+hqq#L}357cS>u
zCljnUJ4@U`-MW0b)bBe@<GO!5Dxl}SV)RH&j494?X=k51qiuV2d*x3p!1uZ-T)cvX
zA)i6HE(Vy5ps*VZcN2eDY}8-NdD1_kju^WX+lX^ad=#|t>~%TTiLNC(SCpNUt+T~R
z;FnNASjb_uk9`<Iz0K$A%dC8kK>(S+!ML0|ZqZ|Ph>K?p7Yxi=?=aVKJ-8uhsNSaX
zDhCP!<U#FUdg%n50&rUo;<2Upl&3WEcnP9J5KssWF5K5cb?&CpD0{%{0AHY%3gGLT
zcyo}A)j;jaCtc5Ry$(rBYFw~PlHVBZp3bX=tC{N^r7F^ZdJ?>SGf{u0`c;3h23pr*
z*c<uR(-7Z=LRi#M1G#GULEQ?1)yk1!OX$FEzN__6n39iYnp$w6p>8;PHz3^W=~eel
za`gwDuO{?YoXXrSDxAIxKu@}^RfSV$eR=o@xpWgj#q+D%?7&EDUWGzG5xb>&7SF}a
z_1oZsJl(!dmf40x9eP~-ROM|9YrGBm4GHj`yI#s8KIP-o=Y`#+?oAG39;UP%<99pB
z8F1AaY*VHuVzkHF@r{rM{z(kVRGVLmPj3~D#-)jn59eh6H&K|;;ml+V3s5>A%MH#~
zAK?lg6qk4qsn!2FtEil6L;itr6H7f8u;hK;;9qx?k)h6#Pr*%vH!DWt88R09fp(KX
zCKWCX)$G!khE6lSiUdw+f8e;flni39udWlg5ta2&lYS7W%m}ogx6hz4XY^mj_+71J
z@$I(itqVcmg0Uk}UCsNCir)@ij)lZMI?7WvTE{CXK$L1f&7Q2RaOw~nk{Ad%GuAoK
zrh~6N9U)U0ra+2|wleuf<Zf6}GmaWT)J@pvygTKU(~pS<A0bsO`LD|g;k)D@xO}{!
zx5L#PYQg)R{O6zMlzm3+=T*X1g3Yh>WFQMZo*}j+wZ#^Dpud36wp*JK<LfuWB}MsZ
z=K1#UW~&Jni%pSAfwuX9yppO&6R+=&@zniz`RABWe`+6Yu<k~Up>N66PKAY{4C!bv
zjuQ2TT3GK%n=1Y!_VE;Ye1h}M3Wm|Kf5-4m;2YnFXUi!FjO2P*LROo6K5T8eWHSgn
zsB*GND0;8m_R88!W`TzA{E#H<NK##UiVa>hy`-`}-hX*@bTv&k{jE?P6g#WetPs#m
z)A6V0(LjPlV4!ETCWMQoSU<qp<B4z3wsUHy{g1*y3D@)CeWQ1BO=0%`KF>9r=rz^)
z!o(~=w*QzzYH{<`2JWhUzb++o9=CiXoNfBIcF&OX0_u<Cm*2$}i3n2e1a@954QjI_
zZ=aA*VZ!S-7CH3tv?I|U0Z+~j+<EGZuKjUnvT%_d^Il6b?LOF136jOJe4C(DYXedJ
zR{0(=rnRhGX_puq5hEP+&(@c`@XWORz5}}DcQOscF;MRW5x-YP98dN_=XzKfvq(3z
zSxxk57l<NU1T6*hHpxA@NhP(C=#qW%5?>n}c&x2@Jk5k(Nz80XaOD+q_2-Dn2-DHD
z-Vgc@4WYUxxO8Y7qlf3L(xgl#%aPgNHgh}E8I(@f9sFa(Cyw|B(Nj?OW$PNtB11W)
zL7fz)aSXV?42hfg&OKYgnSSSUZ5jZh0ds#~fmUq5M|BOUkeZ1o7Rcp-Hxz5CvaELl
zaE^5N5W1bQP31i079UicHg%_8@|`S%g@`p?us^H)gi*3nA@{|vznT=w*E_^BfBF-s
z(EDqFa>f&cvby$nTOUEM5GE&?6a1<-;OAK*?UMSf^d^lhLme0TF$Mf5iWpwc+LLdi
zTXAWD%}6zoikVPt%J`A~SA<cIk)vZmeom*|K=xwOni?PPw@dJGPf5JpcTDxu!`h6X
zbgO_LoyCM6d_%X$y$bGaZ6=k+T=0ofhi4t5r_dhI;CScPtpb9l6p@M*Ej8_gIUaLz
z^J<9rp9D}g(-o!xg++leU1=X-%v!%?`j7cwzSLebYqMuTl-5#qyKN~s2hyXRfD#|}
zkwaio5Fs#8Quq5HguHMBxA?b$L4L&ZOWDgilx87F+~d}+)Unnk=&EB(=&PfA*9Vgi
zQR*AZ(x&W%wylw^SR~Rbi^1$~3)BkI886)F9cT<kuSZV>56VDQ)S50q;G&erY*;m}
zhk$$a@p#kYH=91J8Hb=@#9EY?M2qd+Hc1&G&1qnc&^^-}JL~ye$FcXHnd)Wrz<7Ng
zl{`WvdkHL*C#%`9XBf(yX}!EaJ^nqLmMbJy;}ACqzp+|QvS=@BU=)9w#yy(cIR5bM
zUw}K#f1gwkk*!a`Cr;+K{Q2C%+G7ym#qWM_A(<a5qzdi>tJ#u53TYRc#DHR)XJbuO
z%oQM)OLLGpgPd|$K-8kjJ}Mk<`mwW3QBkR~2}1Q=MQBxKnD)dKDbEoTm_%RX+i1qW
zVO`XI-7-MZ$cE6v3V6?#aPZ#dx?^1CyenEMXpqsL!+v!(9{;<@(HQnoxz*ykLhm0W
zvw|r>4|`_Gnef%4Jd}}goDLSVnA1JYC&t>%EW*s7V4YGM7<}jiZ;GyWm>c`DD!zMk
z`0lK#Le*s`qa#f%O(k)X)hfRU-Y&5gE<CbmR_5$NPF)E93($u(kNZIHEG{Rsh)xSn
zg`M&3jd+>3VeTD+9vdu+X&NKxFn2BLzyOfqM-CmaH{%!cCgj-CK8BijADqnT%nsaE
zaT9!k{sI^nCZ(Ov1e<=sMQhW#1M98jYfv>4P_7Idld!=bBF)@5KRkD9WxHYCS$o6J
zqrdS)eKH=<{QALXWw1p$@g3gH_Ak%mAhopumD&av@fh)FtL*2H&f*f4duT&yH=JQG
zt_8FySlfhgbAL`;lu&MSbjDY!!``|-NO#s>g+6~ReTTac|7oyJUgiQYY<TdFS&-Ft
zJDNML>{Sea5n7Gip0&#2N2T}GAX;+mN8WR3Kylx}F|_MQL8G!!?=YNhJ!zrzSND}T
z{YgBxEa<S*(sh`wo+46hU-9hipH2}C89qA=_Lh_lKj+&a=618!SMwqUk`h0$B}!61
zxoa+wi9I{(8BACtu+Gpp`cU~~1PPaSv^->r^AKNt=UaF_l^`ngRcfZ$An!oH^%+0(
z4;VN!R$Nd*tn<TB1fbrc%ILxPf&Mnx_g-Xz*kFeDL&?KtP7>Z#|2bucmEuU_9@Q5L
zY|S6Hz-Oe!p$D7U+I-5|wDJiRJoLJTsbXL(U)#h@m&Ni0o;<t2gskYmu!4ik1@fSi
zB;mY~+L4n%VnuNo30pn#CU|&IlINex3BmHhqIh?P18noaSM_m>i_6!SGs%M@dS9nN
z-vIDA4xU>NHQWf-;FBuHH?l7a>jvulB10vB?$_O$!D@pH1+5b!FCAVz`HAJ7{I=?D
z<JJlH*Ixidc;hF-_V0FtPn5BhEIp)reRFY}DxVt0PEe9y5J@d8q7H)j!???0KbaY+
zH+T>X{8(+sycFfk6`SI+k1u>3npBthS&d&FmD~Rp(3|(nWirwM`Ucebn}%*QK1y}M
z+bvr(xA?enm?4vhg6@eyGi_(c_p50{;oY>h6l+)q&pbw@j>5sqgsT~J`Y``yWtOBc
zjb3K-C?b*N2HSW7%Hx({V3RtopWgH{0RtBah$tu})Wd!npHFSB55(b11KjstGwq~K
zP^Yu&CCeNRh}2s1YS(#qeiqI|;Q;G|)cwWkpFM$~GBa~-Ff!L^kW7&jc1!U6rTB31
zCO3CfXF@~gP%+tK^D8%jX<p)%Q_mdXKQS@CVwUY#J#E35OR(@afIm~qSd{xOXUvs|
zxSP}<tK-wH6WZof$KNSbu)fJ#;eYh3M5rBm;jS+t3Lx3ec2!yZ!tz6toL|mwG2pO}
zkMl2S%pknr-TVLtPLB1tje|cjLo-F|sl{*xZg$PG0D4-E?ohejgS=<!Pzt(i%;A^b
z?iF;sFIF}m{ES2tiz1{WQ<AA;=-Rz68cz-m3e?uG9i88Mt1^5PXrFJo!kp{q@?x+D
zeLGau!k|if|H6HkW2-kafOE-9n4r>*<kna@SW^q8vW&#>@)5jqojGfWrcsHRjf}iq
zT&TUhn)7Fw(r*<1P+3i`htUIxyQZDQ;7VuQQs&xp(@Ce`YU$qh5I7Xb%PD|Zc(LxZ
zt8O=RFDF9Q{z-TJm8k3zRHIdr23XY91RC8ua6EKT+044e<w+*{8G>xE_tpgA7_{TH
zxRzGB#O%T+1^?u_Pt|=d&_SSPSYEGkhZ@mT>tZFXca6dF-I6V?Mba=Arj#PhV8A!Q
zw=1Zen-_g-OGMsc1`bxsW)r#kVjV~5bo^sLZW)s=uu;pN<u9OZ4zjiR>ULX3I*!}l
zQuQly9Tx9fho!);aHPc~12q&O><HzxF%TmURb#Tw4c2B$XtGz(nwHFz4vMeZsrT&`
z6CJDO$cTUOa+$T;F=0Ro7Op-djYKLiN?EaR&9umVw1!sW4{h2$s1%h`Kam#VZMW^_
z=f`Med6(9FG3#IRweFMTnpXFsG}%D+!7+B%o+`wEm1i54t!Nvi$J-qT-&d75$xADm
z_I1+(?OGW7#v@g<Tj?HzjsBOen6lxc&q@C*7}J+Y?rlvxa<6*7Q$Bq+k}Rhv_HycZ
z`YuL-lmlv25+h5kK#4NXoR^=k(U#8jb}4r({rEbgC5>nb8ygQ|u5w7+`Dd2uFM!xN
z*$&Pt|9s5i2lU95d_XteP**GE7~55~wYn4!h>(Z)J`m&b*Kz+!gTV0Lhqh7jubM;P
zYip$ajqJ+ml2gN$60uHU@B-ZzJC{H(-Cuw}ML`u@RGnG4{_~HXUd}SLBV_kDoy;E#
zom2s-0kBY?mfLA{5PZ<paqrKBkY}`|n-7(GvX5%Lk0{>y&)Vjk8_B6#&?osS$K{$X
zts2pd;m+67@Ec+xAGI%@mJOAJK0^4LzzvObEJMGc6?S4*ZeWsUh|J06Hha|{KaUQH
zO&M;pj}GoloPdafxQK(IxxPlt(~a|G#Z){xL9rI%kbH@=^1U4<on$EO3o%=Y%`eic
z9Df1YfguqeGphh(IGk@-53Q9jb%KvVLfo;=%blmhM=tEc)U211q}E>SOFNoO-c>0p
znoaYxx*ZyWJ5ED-KPPVC_9Lr}lxj*Lp$ESG-A%I16YNBO<)=?LDvQ?##Wpj&LvA|5
z<vtkoOA7l<sSDyen_4f@t%Zom*;Wuv_n6RtO7+arzMH{YRu6IKpXZloh%$qj5P-t>
zHm`E<$8iS7ef(l2sEZH~Ay1r>hPWWYB^1+I$OnaD(?ZQk7s@FkWztf!mARukmw*yP
zzT$Tf1c1+MW5X1eY}>PO6wCzM=X_;P{$b~*yeO-Crw*<hyqrhLV`s#UgB7#TZWY`V
zeCx<S`gU_@tE=d#N_n(oC7Fa&unCan)L*#K`;+XmgwH(mmSsay(LGEH8^<aY<yGP3
zII5*PLmx^R_<weU(RR@THHa#hzA$;sfFq{UL@*eg={Q?){sI!+u?1(;PZ-#kgvdr@
zbRuTH#^Io6QRsO>hW@~S>4(6yT_fhA1J}r*E-dRe^fNO?zsi2Xw({`B@HX6gy*A{0
zJVJ`wFv=|=lg|GFmXfD1SpIZIn1G*E*AB!U=D*icSrftl!{7&%;n3)U#=-@h9Rg}u
z!FR#W@sCP?+Gb^650cjERDIc_0IX{y?nkAzf|FW9&Kb0}c8T7N9i|?yIR+LcbTxP!
z-xNB(QcYr73bT0|?C!Z!p1OE=I*>nnAsOyzO@hn$=-6*)9o}uEY_to62x8a+o{{>z
z8O+9}5}+y|X?e;;n+V{pm3m9=c{>406HXo09y8aJ#PD}$jEos<8PBFxRd>OQWkR}z
z#V_3cX{;*I<m2N;I1TY@uZVbFJRh~ezOwkUVE{F!)v+;A1hIegYB%$}ULTZ?wpA_;
z6fHHkPx1#-Bu<NVdcP$+DR=yLYVj8(<<pr;_()B3MEoIM(u-~}rVw|bCaW_;b?^)b
z3JPN=ULQTW9<N!y3!OJ6aNtEy>nWRHIgAd@%?);SMqz;QepE-=wzM|Q!G5_PdC4&p
zRJ~LM7UQL9Y6-OUk=xq#-@^CBB`pVOzk?OQX%bZ8!7Cljtu&1Xw+a*X$_EV8@dZ$Q
zTaWopUfJb~T~WoIR-?h02ChQ)<r)+xP;RUtMr&+Uh(nn(&~F$XIY#>OrKhhusr~^o
z!*om=PuOg?bdr2mvODH_1x(>|&F^QDMu)8W5{~*h>Jh?UcTDT>@r@y`TlI&+o^Rys
zvo=pd!1Cr6;yG%+N|b?Rys-rQ>t3Wb+Fi0Y?tE@kH9YL92C6cOQ&*$=>W!`4l7O8e
zI~SYRuWFxX%P+FbwLT*}CLxW;meq)nWmdM$P&EHgv=o>bX4A{~rMvU1MUj&+uI~NN
zy?pXfrfaUH4o$Y1j&o14cY?~I7>n;E&c@9)AE~a4xw%HGx3wv;wa#=%?ISDI6NXQD
z(1c=jHg-OWeMU{9M_Yr3!i&Sy_6eLqo*bvbuC8%Qj?#7^5xUhS8Ur$hOg?0NxHh6J
z7=s+W<JNv;RnjTDCfwv}tV3~+Db}7blIT7P+6{X=TeK*`z01pvJH^WvboC(Y*VF8`
zE(GLaLnwNNt;#N+W$Q9ZMl;iE+1~_MV-GWWM!*NxwyB{MQ(wO4&IAydiQ9CqZ1Q#H
zZ49JCkGCfSz0?BrpKy&Jt5xthS4DxVx)E!?Iren0eyJ_UOQitv$a7s+k*m-13Vo$U
zd98?+wJMUnp1ozf_am;nws@UkPRZNic4!Z5tdr|4El-(&z$14wB}4Py0Ir6*7On@X
z0_k>BA$m|V?Vc#U9@?$dD|e>cC-3+>FpHVP)UjwSS@@y#7oFkGoow#4L;4)r!z`mi
z3*b11ft8@`J<a{tmza&Y0pIS0x{-+-*Bd&j+romwppFiYsT#haA<iVycpf`)?P>7q
z6p_k85`~VttHI<vsGVUiuR0wiK87EMRcD<#xTpJ3oQp;@!oLX7<V!UP1S{usP4DBV
z2tK?pg<68#5R%T0s_79?x(4vo=CGV6LB|c*JkMXjRP3Wa{rvsx3Y;)EK98QBb0A?Z
zg#}sPh4a*E<vyR^MkK@j0@7yvymf`^3PTma7)vp)0(-DXfmjdjm2alf*WO^+n5)G<
zXCJqDbKrI#!eG}}CwmPkPQy}9VKurCl)1f@*Z_C2`av%>1;b2^+O6N^>j{iUygkYL
zuui+oWY6Nbi11uGK)mU66F@bk6W}}Sgw-h1Tp6fBRvv;--P2Y#2g2S%Wg!;AT0kEk
zwKYnV!f@Gjc`ORSg*8$ClVC_G^vS~7!s^hCbHcQ)iGFHXpP<{l$$63v>5LgELr9-2
zXv%a5yl3gq4Q3S#+TaXxwRsT!WZ|^t6d|45Tq#IUtpMI7otOVcV^O-OJ`2<6{xs=M
z4~z)9<XF`<VY3J{voB5(P$PX-uJY?G3>7wf^k<%@PD#Y8*y+ZE;2HJT_qh*MWB$|B
z70iaJhP51z%36b812D1gn-a&u>2?BVFQk^rJ!BMipI;96F3vqXt$vUH21|X8oQy((
zp_^auKO}ffyNkjfn;lK<FFmt}HaK^xqGHtwbMr8@Jr!!&;wX1oYp_U<@|0$B5XC!z
zCcO3W?Fap1I8Vo<oE`Wx2WF;Y^FFu?&ao1Poa*A<>`YHr!lt-PO%iTRr{ArwdIjy#
zJ6x9yn;^uS4x$!F--(Zr=BS`e;G*g@vzNy4&E`ua44aLWo^A7Ec_jsrX+EPoF)_+S
zZgbKb*R2nW#WE@0(nYay8fTg_jIUC0r-%nZb61i<1P;}0VmD%)yz)#B?s*A3gHfd_
zaNYuWl->Ju!L>{hxu%3BzGOqRJs_zGf`dAzs*e7Q*KXY@QOoCW@7WcR{rKSK{`k3o
z@iC5I;{B}QXQKh|n;#S@6i@r+$FTQxnKn^>CS;>KhaH~qEMK{i&hTJgAET2KvOC4w
z&#=!wZVj|=v+H!lMkDVor{P#<`})&n;jpqMeAd<R`Ic#R4$};XKMdZX<@P^D&R|Il
zt3?@CiO?t)1+VV*z3kfNhTQK)D<;EH-ZECQ=<Zh_tCboBV0VvPrc-Y}r4qP7f8<hc
zSI7<8jTQ0%X)O6&It&&JA*n31URt@k{|f-ONaF8GIumN0l(r0G#8DIax;ox<x$_u1
z1BD6-5lELzCY!B6&h0myBn<|tpd-e)d@8a*+}e&)-wmX(jQVv^296Tujd?Yp8573h
zpv+NTY!;um@Q@g;iGwPUnJ8V@mDuJ<eqmlL<R?)flrkanu}3=*g>I)j&?r_rIay+r
zj<q1}ryCXK)6xFHU~D4n;x}dxfuJ(DhY=(EZ5-n^C6=#2TrWr%LQigQGv2h8Bq7?o
zDp}=HSRVg{;eb88?PDDw;q!ZRdOgvGugo(R<(i+M=o#6Sh2|4<s!#6PRUP6BcNjy3
zRFG%z?wg1NKV~)&i7K|!O~B`l$o+ShGa+PuQmC{F@>d?`n<?cHSRj4TKJy#q#>T0E
zI*76wef;ug8i?=s*6Oe6y{U}C+Vn{2Or41zZdJDmUB1@hC&8F3)%o@o7qO->m_=K`
zVb!?h-2taM#c2f`ae1o7sYE4ZBbo4UiQ2(a5qD!ZYCRztRUKs+`N@FMeY}o8LkxQM
zX1`x=MCCKFWYw19A=P?hhQ#iIoVdcBA9u3U^gi~0Vq|-^`0%xC_+O7DPiu%Tj2s^s
zENetGbX0k@(yqZs!IBxVSt3$`Su+?MznI)xJeV90wa3rr<wZ30>R57b5rOjHRoV$~
zaVoql=GRJppg+(l$l|w`K)1LoiQmo^;=`{4qNyg70rlc-A|^6Q>;-I3)2NCdZ|5(d
z^-(EB@R_^sp7Xcq3j9%VArHYJq{_zFyY8hBD;%gkMgIh_@JG1*^zZm?w1K*DEm_2~
z%V6@wsYoqL=sE2QP4`WuY6$Bd;bT?GVJ6}2P=9u~0(40SV_&@)wW?iI6`qEzT)L}<
zDz$ii-4P?&ERHLmzCsVe;cHK={>Ix*dF$yZmo1xP(dHr?rLH{7N@i8v(s2|r7FrXP
zppIcw1$?=X@8jDx*Cd<k?lP_Yb;N4X4^nhl_ZKh_F325Tv}V7m?<P7OK-<b#yR{%*
zJK4ae!lE#x%=)x}OUM(p)GYhf>G33jqcob%rLXx71OjwukyBc&WzaCZ8Td&^(0mTj
zpp&R+$MlZNT9v&aS*-Lo>;;+^svTFhkVwe>L1$Fg)65ig5#=<e;icW?nwQNrO~rp=
zag)6js9;oSz;Mz7EJs$j$J4S@yU$Ts;HTg5rA+1wh_9vUgyewom|peLDmr!hwTn&h
zCQFC3koybAUgtT-Smn0pnU9R|an|7i$RniT=<#1bP5_bO2gr)3D_1S;qtV96;*!`L
znGxnDLQt(VhK)RD*MpP9g~y&b#eDf7rP@>=n7D<1Ld=#4p_6WDOl{1k^jX-4bEhWl
z&%S(D=Hg9kfsu=s_0DJYy{~=Cx>(jrFOb{*N?1k-Vkv6LDimrl+^udND*U7y@wlCA
zB3~e`)9I#;8e(9cxn_Da_~qv$iBQF3Oc}C5gI_)*{J5S?2v^fGKn5pcYV08`k!f>g
zmffC#GYBx~9AW0Zq9c&G<cn0;E!Hsq%xK2f<Zegf9b|FUGq_>U?$5p}qFlxh%14~C
zNtyjM%(kZ!H`~rPwmgPIlq^!P62bkrg+-oYuH|m`W3?}%FlU~56D!n2to7`^f$~nW
zL0U+cWoNyW56t|7Z-~`<>vDSM@ox$!)zE5%)AuKJIcT^6p6ISl?Nn}Q_>-A8-yDxU
z;)NIPuFhMRu846k9Bba2M(ZP%VC!h_Bb0n&T=Djg4t#pIYKC6SZyO7l7)VaznZhgQ
zE%#$=DLB8W7gNN78Pl7och4nQ<2m$X#CQl&i5RYGubNSkR&3<GuaN9YGI5lv9f#hj
z8<N;FcM^^zhzwDvP}@OzuolgdCH$&+-o$VsLmXzJ56;*7(HfMw85a&s%ng1ss!Zj;
zP7rD8{W5@7dbu*B8qUsGM-{91<*NiNqTxkW&g)Glv2{v|Q<V;h)BwNFK0;Nl-f%SF
zK&foC{vLC!^%dt8`M<g&=|6SH_T=wS98Ik+FReG%uUo-6D}ET}tvoi@r!kBgb`9Q#
zya0g5`T9@D?RJGrL3vTBpF@K3y(q;hb2RN)&<g|O@ARPz?=tFduCy%Hj#b5IFK?J7
z!g*8~M<D8-@gd47OHE>6THKR?Fq{80tj~w09(|;ITB$$q;Z1<ltMxhD#&N*q#H?OM
zDtv*WQk|J%VBsHFV&}WsxHdDa20)xg>mb_Q+W8bAhqH*QT+lMe&?Z$*N$20~YMn$p
zhI>++^q4DdA4j2)uIgi{4_>o1ZZ?M+k$S71>R0Z7W-rfX`q81=tX*HG6g@*Kn{h^#
z3?jm34;yWpcD`#)9I*xLae27v=~$mjzB7g)UbhaO`oH+`WA>3Gg+5cc5#1-DGQd_}
z2<!I0e{^Y;R7WAw4J2+55-S#3R~<12W4KLW<Wmi`ZtQgR0K`+`A0%ou8-TSxC?ieo
zqCCM-Fm0_-(vp}x*bB|o9u(g7Rp=7Q$Nhd^kz{s#*_3Kd@wP4bsXXD~!a;+F>^&MI
zQh1x3Zs^jIY^}HVZW9^sG>-C8d}d4iv2`(C(Q_3UF?zI-*X!QhjT)L2e3CCXR2sei
zUd5`$VgW16JK}DqFjf+j*`0I{K<KcOg^p9nQ3_+_)xzIFf^0@fl5CO3udlWirqikr
z8B+L;Sd2RSl>%^YHx$+bcB6Qx@Hls3K|6my<A!}RBQ#phT}bT1?>^o*ULUp<W}W3f
zjWGw_L(J#+6|sT<s(VqpbN5do!<#w(;okWETS?IYRThW(Chf|da5CIb%8E`6GdIZ(
z3jT{I>i;g|6XwCg`B|vUl($_YuC!%q&->ml<}tJ0SN*i$UqtV-i<j0;#(^4Te`0%d
z*|l6?HvUM08?&m`F3zKn;>wb05jed^v9e;1d0m?55Dg$R7p-dlHxp91>n})M7FA1#
zB1%UJ`~Wpr-msG__(fBx25DNsYmF}k)<&Ypr;cKe<5o})e#4_`pBFGI66hG?{%{N|
zA}nZ~LSsg1y$<N_^R7@iIPQM|f%tQ&&at01EX?i3E~FI1>2KG9)#sH;o<AnKO)j8X
z0#ml`V>H8F9OYdLm*%Pc#>=t9HvSTHKh~ibp2j*Q$x!EEo+x(U;~m_2IRRBLshj>T
z<e39fcP6y@4>xj&Sdw6eDl(Pi+KA1DmkvcM(HRoYYxMRTZZVp>H&(S2v|eq&RM^aU
z>wF$%`W1_kVN=bF`5Q`%IOsNKLtZGg5FsMAK&3*SWM1$3{BGkUo4arsEHw@q0O*10
zYFap@-T;70mjmJ1X$8*gdNkNd48tG<A#kX*8N3&4!lSdn8}R<)LM%X{b?`o5EKJZu
zT0~Je#-0LK3IZ8U#9HvaZ*=+GBmFWiC7C^Y-*b>=oJIC(pyk8}e?6y3L!W3UU|_0o
z{o)0{7Cm_{Kim8cge3d@e%&jfsGR^{eSyq*w@BauF8%|XQlca1K0t%Fzw68h84nxJ
zs)J>yc<a-gjkGjaZ5?V+k4DEYX9f2^$Nc8izcI~to`?KeDx2gXLDSqiy<jNfKiM_e
zabg2Now;LGnSEooIz8`ZceKiET7a$Dg2m@F{{nV&W_;LnwcO15ieA&#a^l|XIhL5y
z7wT14F<*WuzVGi`yP6AQMN_r$Ak}8K08!H}AbktC6K{gmpy8sfA^BaVeK*AH`O3Sj
zpp$GXs-P`peg5ta@j_NW!E)GU&eM0o%`cw$v?G2g*8e|dXCt6n_D|gvua;}%^h#+_
zJ)N&7lun3|1+a>LGL<WbVKI~_?HN)l606>?djUikR0c+%Ro$~S=j!`_4Dn5)t||r&
zj8+MV7yen^<{%L_wUT~IhB<91D0$j%Ll!3_+Ym}LHO%Y7^<E_(>DFGk7LFSh9wIuQ
z<5&EeMS(8O0BjoLyO0xPDfeO^ozE??Q=PjgjKUs|T1HFv-Gk2Sp`#(j|6V>gConQT
zLxd-`7U^?SwP1Ou>+U4P5Su+VS(q6x?CTJ8`ZNw8WtVNMUmIg-*CB*wM(c3U#3>=(
zJ>ZY{3%D_?Vsh4=VVqMS_fT=e8-B>ZQLU@vj4pe%W8u_h>v5bHs9v+V@-V1ttJOFM
z{R>bT9395Z?Z4QK;qGJ>PF7J8luDPoaf<@|1NOM)>RJ+1{z@|;Lu{K_RZ5JX*xsMx
z#bzl`of{bA7yGt}q`K1<U!x)U2Nx6$7yagkG9DG`Z<zdE@;EDZzUben%9$}fg>keB
zlV=h+$6KKH;N@)jk@QI#357JZUu&22D%17t3rP}p$tvk7<w9YiC}@HTD-LIvw}&p8
z^fF`~;5rZ_?Vuxj>YICel#P||vKb$LNlk(4Nb_vvvRUHJR>SFXXy{mNGKr3^@`oGV
z*a`;LC3Ah=amlqGzLtre+sNU(b$^!=gmOq4U8#Xp_GTC)+6^mZgpTpjTwThH73US2
zmHmzs>mh>(+q(_iAyj2~NwTqtU`iUOw;D`kVg$aKOskK^!ktPZc~)}9jvR=_)QK#R
z3UZ21QO0*H_+&9#ZTMccH5l4syi_5Qs=cM*N)YnH@W)A$HH-hz9$&C5BHR#S@Z;dd
zB&mY2bn9;G5B=4IE)!;2ftogqT`P_Wrg+F1s@7N?B3ZQkOyxV?UaI@Heya9ASVJ(i
zL6Om9_74-})zdiEjw4q))Jd6DpwIbYj%j?TSkw=%f4+3<+6(YN*eY4ZJVIpWM@4-R
zBRtjB5*D{=)F#ZV4t`HOV#j}VKld*pMg2b!DgI@`aDZ(?Po?M)C++B=#6ccGvwvlb
z>#S`|p|cEm)Do=|V{L*ur&d*YY<XJ#WQGLg`GV%#0M-|y2f<K%9ue^;ev^e4D>fb_
z;ZHmS4$dX>|84x$V61O2HQipX4t~gp{*u$p_`2~+(Uer9U4?uFL=!Z;2jibWh9P0c
zc#{2i!w_dKbm2&$HzvAp#4PI>x^N^X$H>CR5$zT3eT6J10_>KMtJ}iNR4Tb8kfex4
z<*+HVYc~(D*$lYd_53gzqz<~^u>Uy)AO0><HGq9kEIp-xkC=#TL4Jk3ps7JM)tG!S
z@Fvm;C{J7DrE2yRqaT{^Eobi1{=)7B8Je;=#H-=qcMp~A3N{qF%Ulu0rVxeO8hCi|
z3JhN`2A`A4M-N!|qX7m*h%FjmsAWp@z`NO-q|b9OpLpB*!WGkP;2|??A7h+uAbb%l
z?R+}L{}V38726$H>w{l|YMs=wE=iF5R7`e2%#fK~m1*Zah8u!<R=U0GAjGF`yt72t
zyOb`0M9EDXlS`Ljxq=kU&A+7(*fP4?B3s9sA}aI^QjTdXRa+~^<bg@}fU^f?ZT%CD
zbg@C6KJ4l+x4!4|Ez)+cXZ`}nA}i29Hme>J8Fq@t=8J=Dejq5iuQbfAwYF&%X77IF
zBPWSzpSxv-CrRGUQsGakM|6f1W4WFxBBl>7vP1iZLCdw)#1X-0-*A>pINCx4ZS#({
zFJ8CY224zYJgoMytTg+E1lygvyTFeI!j4;FJ@Tab@;w7seV|pSrnm7T(|ObCOfHw_
zpuW6jPAn36S-%X{TlV*3RgTE7oLV(vsNqhD38mv(55$ugA@?_8hbleNtD>SOtMbiZ
zJkPO`2JE9_s6lR*xH)r!^Jm4HP>^SWMmk!6)u0YBfFqkD5}rt%5KEUy&Z<H&Vx2<c
z?L%JdTyX;bu@=j>f9KHKzrp*YhAB?&et`hUl3?7uP|%!L)hJ^?xQw_HJbee~qWue~
z*xtMjJMrJfCfg^H2S`0TvvE%>I;YNktWOCA|28Ge9w`iH()}YsZOGt<kY6^p)-(D7
zA^9nGn@cyLk2^p(I++y>B(K4I^@L3g$a2}-)zqP2vi>T{Jn*_M#*+Q@`cJVN7Y%Nc
zvUk=GnWfhK-*GrD+1<~9EPf*b(F1!k;ZLVhL!rh<8y^LhpS3JE1kQ0DyUGv_R!!;9
zRdA=wEs7yWB!CRW6Wx2k-^WNMW(fo)4o~nYrxI9jO|k+8;(3xbpAjaI{v-QSPO)b|
z@pp;rIcNSQ`_r2<G}Ml)Yp*Rr<G;KNBC^fOJ$AmB#a9_D2P5R^Fn4v%hUnH7{v6_b
zrN|+un~GEnU*osv%Pv^;dDoV>E<C9d$FAk0rTCm<MKnr6ZuG-~6Yq6jNuD}8*MljB
z`4`vVgbu~^a@IN!L5-X72bv?Br|v8BGnz(d%h!j`sCL69zMF~Z{#5q8YyQj^ktpJ_
zNgfY<wZ%&;<e0$K1k-xq<Po;{I01I#9o#!uozJ&YzAy5VxJuH)RM6QV7~MY|j(wf1
zGe(Je)TG*}@A2f(F%10%J?@UXUg}@KQ{^+7=Y^~_R`d2_9<;O_gLm7I*xFy^<b|4C
zNfJNVIJ91K^!`%=5ob3uIh0C*7%Eiz(ohlf@O1x87g@g^XKdh4Zsn(JNJfqMxY@TD
zFx$TXf1~YL!RQrVtRgJfi3l3lryP`!co3%1#^&>@>m{gkZyQ_lnrE-FMOSS2WB>0)
zVYspdvD9V+4V7$cOx*2e-icf2TB$$QXoQu^!5H3b&Xi!WR(0svHaFG?6`Hp~-ZM_q
zLRjQzryxJgDKzNX&%Y2AD>T102$nbVarb<g$H3J*YRKfQ7efWpg5Ac6HKSO1Gfyez
zq-RycVr<CYOMxNkxsYex_ZLZELls-~AE)ny9*@k8LH9|S>>RIW>Spjj;Z2hI!eaqL
zlOhG@NGwPCzkpF(jiSsgJ!K-_v}Qe$eqA){Q&3t`{O7&?k6$kKG{&F}T$-jZs5B3e
zcWIR|pQD%?Fvt={dAH+?sjfYX4X>J6Bv~IHZGLrdHNoZ(E14=(y|Wx`@X^{#V7^7N
zUn6FhPCP10@tfQXcGwHsIHpHUxyMHzX4RIJ7%a;n9EzH0n7z`LiGz~Kzst)Xqtb-o
z`6-X_@oPxm-snJkz}vwMG*1UrC0k2{PwSb-UBhvZB;pb$t5%#E7DJ!<y}8GJKDtVh
zx~w@nD$D&fw)-pKD?F~0#3*5{S!_IWL)#&(oVk9K$$&9RTAZa9DC?b<(c~CwC?`*!
z!l)ifwLrXr*L?4^@=CT<<5OFj`m?YGi@w#?(R!4ozo+82y|1|%f*hAvcBkHd0YLp(
zbz?#0YlnprL9@%3S=U=ve*y8>?EfC+{r_09N=04fLhU{M7vLeMh81LUgPNPcDKREv
z2!$-#!Cw*gW(9ZGJhYXRrg)deu&opY`fWG|S@hR<_DIO;2=DwtwEsE~o)q0QFlM;@
zfOD&YR#~0Mt*G2V8d{MlKj)tM;4-~)e;}6a*eQ#{PeIdK2fW2UR$B-IM8S!o(^$gm
z4Ig_$334vQYHnZX-zoj7F{#UV|HdscpMR~?)nnYlO>iw>f|`IWMXUVqWqUdV=i2i1
z;N{G2BIozY0JAxrvQ}JHk7hciM`aQybF5@zLL~-XR=UX|gD*{M6yj)EouSIvt|<Ns
z=m0yl?PGo1zhrg1id6~9csK&{Nk_&nH6YW{!mA0rF%!p_SgotN7>54P7TTWH&W}1K
zc?>C1ijN;lr4d;YsNKeSNlZ+c_Vai~foxI-wT%OQCa8gt5b`{yiUg4bu|}m*3?1E<
zuGSmlo#lbHXPQI=;W!sU3plmn;Krz+7wV-uU-<}!ihEgUh^VUKt8!15&&$j|6P53t
zLftFf1mohe63f;X7zhbw8VOp^GIjH#LQI+3VBb9#pkaA5u{?#lkXn1xuQAy*vk)u8
z84d9n<)kBn4oPpcXl}D0hDNM88Q!LxzEz1H7Pb>g)R4Fk!1;~tk_dOK{{Q;mDFYS4
zdd>hB^m@u2vI<Ki3R{D6N&dRSKN7ek>xEsaQHA-y<o0PFZ%?2?W4*LN`VHVm-l7(u
zxZ49wLZTs~I&t2^*la~`h5>ILA?2Yi{aI0+$Rr4^l)R$?S?Px5=*X?PSbR2=>SgF}
zlcosYBqT@eq3KU;Yzn;XVpD29!rJ!XhQ*ak0VYcCw=V1471Wo+bxe_O`0Z+jSz#Fc
z_vh&wW^r|k+Mx$92}6`9YIc)laV}+^M;HNWFEiu`Yayb**nk8%u@}U>ofRBNMHj5~
z4UMA<*4}yVOLRTXX#8E~v>Ee~97~D}&f10G7k{`p$D5h_H03LuPZWFFSPu^Z4${*<
z_zO>g4B2g_E9-_NedrQ*GA-#lv9Bj&EyUZrLZ`^d36R>0y@}&u4Aop^&RSkW7(Q+Y
zp}&CgE6Z^7<93`uTTa~tBh3xzXAfPtMaQc7<#2YdN4{x#rJKv<RlZ(=``#N09byfs
z@p>HF6)ASCr)nH4+70p}4$$kDLTrqWO0{78LQ;f;x0$YwsR=vh3?CVsNntbx^uUOS
z{sJT~q=^}D;5JZw?|1V}9`EiO7!c6Yv3k1S2~aLW&oA!##79Bz)`dq@BAIgXK;{DY
zO?zb8{e!goq^)baZ+^fa<RI#Vfp18Qr)gasJ$Fu}&d{gWuSZHbER&u(p!Qr*tE&n&
z!u3N&>QnOjl_bQYRfEXWps+FxD5W+7ul~rD4a~<)JBIZy-~&>@ocBzVazGjML?0vW
zRV4-f@e|dp8$^Lon6qtFDB8Xrm?}Zr*W?lZ*w+&QARN;uQz#5x`#u)v^8{m!azpbK
z<#<P;whfWjzyd3|r<~4)dgiYyBqWT*ap`0qZAhchNP&%}ga+B6e9H3W%Oh^I``B{q
znczoQoz*Z*krH|2K;AeKVeKAf8%$sEQ=E+WBwVSsBdsR}muboDYG&5|L^*RSI=aAj
z#>8s=WfI`32eMsGFdb%q^71z}RqT(jSCI4dAY~vl_;fd|B$*!;tkHyBNuqvWn=n69
zTrENSa-|WkkeW`WzbZLbc5&!uAwlIXLNoXWuXiRPEVp#)n!#O8o6XDsN=t`TYm@IL
zfKI^D4)Xkg(?+Rer6tKuOUBx%UEVZ@Zltn&g?jxAL#Gj}4x-Sc1^D2jxW9l1bF?24
z)ua5wd2+oC=hNrVqN;Z0)|T;PqzRq#s1x@`)-;)YKJTlhh>W3=yKlp28*n#{Oh{$V
z8$Ns!mLmf7VNLllvh7eG1IGDd`Fi|nQiL~EzpBuxu>6b8rGjmcWtZ$C;tfX;O@^?O
z8hN{NQLg(C)~UN^ryn!s|4;s7fsTUPf^OLcVN{Q02>0Pv;JlMvEL${#5ZLYJ`x^t%
z)zhe>Kg`4PEICHmE}siR(a@_(T^Aa9O%6jtud{wW<3x2|-)liInDClzh5?Uo0S^Ls
zMNA5^7c$Tk?(d9tN!VZSgR+J6Y~B<po8vK3sr-+OBlf?RaVV_YQ%c^|L^5R`q0uK=
z37Po*j{b8Qu?GJ*J+?g_T1VD@<PGRW<NuNg&6mysi?{S2863BTH3#&<V6YGdoY@Bc
zwF>~b`kVNsB?K@3n`SSWM4;vy(6ybJ78<pEkKa7sbjfkm(d8`3u&Zy-Zy+?HmbOM@
z)q1n|^YU_{+fJV@m5leJsOVxXtg7Qs6{X+;)}2PEDJ&Mq?}RM7h6?&f1z(8uZY^OU
zzMx^&4sNDgebL6Mups9|VMMrH1Dl8F5tz2WQsSVJx?(0vi88yqs3{Jc4>>yEBh09z
zkEUlSq=XT2JLQAE=QyjHl$FK1jfNR~$tn;E%v}sU1)POTEGH^31YTGm93=$r!w;@_
zX@f2!lHLt`qwhSNTYT`S`Zzg28Y9`)GbC@~1yda>Q35Pm9+Ck<GpfLSRl1YBg7n`h
zx)YcVn5WiJqTpAdd}uuwk@A1+%7M>r7jyen6nC&a`SC06Kg0D<Ez`TI6TO>XxvE4x
z;E{8)fAT_yX;yD=#a)GyA(MbBXayKf*u>usIHtUI=A0{A&MkYXb~(Fh-JSy8*3YZL
zf}Pe~Jkj%Fq01V!M@A0nJ;LwTG?`9WY`XX!+l$lF><a5_;~0QDCoYDtE>AU(DoDAd
z(p%Phyr;Hf<G)!iSXV}g6@!{l{sAh#({6n!`2^gZ?8%d|nLkMJtGU`kKlAv>xymc1
zPTVk6@!rv0Q=S7Ss}F9<KOiZ`X2Kro%BsWj-v7$P^FBJUpR*fu^NQT2h(=ikSt>4f
zVP7ti16*Ea<eudFpTX{z{p6W<E|jK4+zdP(>fEB7zwE)Ye|*cPO)_LZBYZi{S-8|v
zz0iWWd(J<G3prh{)ZIf3r@xBz5Le0D=H_nSxJt`A@0FJdTL9Odg!|0fY<H(yF$-T^
zI?Yw{C0COAC7t~2@_(k*A)bB<m-fmrvE*IU)MGud^U25W`<h-!wX8|JBzRnri_=v(
z@k!689Gfy_kHx)Vk*bbrpK_&6T-&j?&-fVskCOH6!LCduQ!bw5)U1rIxD}C7Z!TZF
znk)Exn3Tf0n3%T15rR9S-vAf*6#hB*V|VGH8D(M&4Y4_u8_dpM`o*%YZ)KdBN@&Zi
zkVki#^MFJDWmiJhWC>Yvmn@y@nRKV2I^q61o9Cd_ur^K__jPv00GER8{bYY|L1=CC
z%u5nWU!<K;%4vPvopAs4djF42lS>km3YNTQnR|*M$?^EswQt`q3H#$_61U{zyeU4;
utMy(_1Xct`Pky`fIyEZvXXCHFgHBU)BBXDK?Z49V<AUW-IBvoI|4jgnw;o#n

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]]}]}