Hotfix 22.01.2026

Content.Server/Backmen/NPC/HTN/LaydownPrecondition.cs

@@ -0,0 +1,31 @@
+using Content.Server.NPC;
+using Content.Server.NPC.HTN.Preconditions;
+using Content.Shared.Standing;
+
+namespace Content.Server.Backmen.NPC.HTN;
+
+/// <summary>
+/// Checks if the owner is laydown or not
+/// </summary>
+public sealed partial class LaydownPrecondition : HTNPrecondition
+{
+    private StandingStateSystem _stand = default!;
+
+    [ViewVariables(VVAccess.ReadWrite)]
+    [DataField("isDown")]
+    public bool IsDown = true;
+
+    public override void Initialize(IEntitySystemManager sysManager)
+    {
+        base.Initialize(sysManager);
+        _stand = sysManager.GetEntitySystem<StandingStateSystem>();
+    }
+
+    public override bool IsMet(NPCBlackboard blackboard)
+    {
+        var owner = blackboard.GetValue<EntityUid>(NPCBlackboard.Owner);
+
+        return IsDown && _stand.IsDown(owner) ||
+               !IsDown && !_stand.IsDown(owner);
+    }
+}

Content.Server/Backmen/NPC/HTN/PrimitiveTasks/Operators/Combat/StandOperator.cs

@@ -0,0 +1,32 @@
+using Content.Server.NPC;
+using Content.Server.NPC.HTN;
+using Content.Server.NPC.HTN.PrimitiveTasks;
+using Content.Shared.Standing;
+
+namespace Content.Server.Backmen.NPC.HTN.PrimitiveTasks.Operators.Combat;
+
+public sealed partial class StandOperator : HTNOperator
+{
+    private StandingStateSystem _stand = default!;
+
+    [DataField("shutdownState")]
+    public HTNPlanState ShutdownState { get; private set; } = HTNPlanState.TaskFinished;
+
+    public override void Startup(NPCBlackboard blackboard)
+    {
+        base.Startup(blackboard);
+        var owner = blackboard.GetValue<EntityUid>(NPCBlackboard.Owner);
+        _stand.Stand(owner);
+    }
+
+    public override void Initialize(IEntitySystemManager sysManager)
+    {
+        base.Initialize(sysManager);
+        _stand = sysManager.GetEntitySystem<StandingStateSystem>();
+    }
+
+    public override HTNOperatorStatus Update(NPCBlackboard blackboard, float frameTime)
+    {
+        return HTNOperatorStatus.Finished;
+    }
+}

Content.Server/Backmen/Shipwrecked/NPCZombieSystem.cs

@@ -4,7 +4,10 @@
 using Content.Server.Humanoid.Systems;
 using Content.Server.RandomMetadata;
 using Content.Server.Zombies;
+using Content.Shared.Backmen.Language.Components;
+using Content.Shared.Backmen.Surgery.Consciousness.Components;
 using Content.Shared.Damage;
+using Content.Shared.Standing;
 using Content.Shared.Trigger;
 using Content.Shared.Weapons.Melee;
 using Content.Shared.Zombies;
@@ -22,6 +25,7 @@ public sealed class NpcZombieMakeEvent : EntityEventArgs
 public sealed class NPCZombieSystem : EntitySystem
 {
     [Dependency] private readonly ZombieSystem _zombieSystem = default!;
+    [Dependency] private readonly StandingStateSystem _stateSystem = default!;
 
     public override void Initialize()
     {
@@ -38,9 +42,12 @@ private void OnZombifyEntity(NpcZombieMakeEvent ev)
         if (TerminatingOrDeleted(ev.Target))
             return;
 
+        _stateSystem.Stand(ev.Target);
         _zombieSystem.ZombifyEntity(ev.Target);
+        EnsureComp<UniversalLanguageSpeakerComponent>(ev.Target);
         RemComp<GhostTakeoverAvailableComponent>(ev.Target);
         RemComp<GhostRoleComponent>(ev.Target);
+        RemComp<ConsciousnessComponent>(ev.Target);
 
         var z = EnsureComp<ZombieComponent>(ev.Target);
         z.BaseZombieInfectionChance = 0.0001f;
@@ -110,7 +117,7 @@ private void OnSpawnZombifiedStartup(EntityUid uid, ZombifiedOnSpawnComponent co
         });
     }
 
-    private readonly EntProtoId ZombieSurpriseDetector = "ZombieSurpriseDetector";
+    private static readonly EntProtoId ZombieSurpriseDetector = "ZombieSurpriseDetector";
     private void OnZombieSurpriseInit(EntityUid uid, ZombieSurpriseComponent component, MapInitEvent args)
     {
         if (TerminatingOrDeleted(uid))

Content.Server/Backmen/Vampiric/BloodSuckerSystem.cs

@@ -73,7 +73,6 @@ public sealed class BloodSuckerSystem : SharedBloodSuckerSystem
     [Dependency] private readonly MindSystem _mindSystem = default!;
     [Dependency] private readonly BkmVampireLevelingSystem _leveling = default!;
     [Dependency] private readonly DamageableSystem _damageableSystem = default!;
-    [Dependency] private readonly NPCRetaliationSystem _retaliationSystem = default!;
     [Dependency] private readonly SharedCuffableSystem _cuffableSystem = default!;
     [Dependency] private readonly NpcFactionSystem _npcFaction = default!;
     [Dependency] private readonly IGameTiming _timing = default!;

Content.Server/Weapons/DamageMarkerSystem.cs

@@ -15,7 +15,6 @@ public sealed class DamageMarkerSystem : SharedDamageMarkerSystem
     // Lavaland Change Start
     [Dependency] private readonly PressureEfficiencyChangeSystem _pressure = default!;
     [Dependency] private readonly BackStabSystem _backstab = default!;
-    [Dependency] private readonly SharedStunSystem _stun = default!;
     [Dependency] private readonly DamageableSystem _damageable = default!;
     public override void Initialize()
     {
@@ -39,13 +38,17 @@ private void OnApplyMarkerBonus(EntityUid uid, DamageMarkerComponent component,
 
             if (boost.BackstabBoost != null
                 && _backstab.TryBackstab(uid, args.User, Angle.FromDegrees(45d), playSound: false))
+            {
                 _damageable.TryChangeDamage((uid,damageable),
-                (boost.BackstabBoost + boost.Boost) * pressureMultiplier,
-                origin: args.User);
+                    (boost.BackstabBoost + boost.Boost) * pressureMultiplier,
+                    origin: args.User);
+            }
             else
+            {
                 _damageable.TryChangeDamage((uid,damageable),
-                boost.Boost * pressureMultiplier,
-                origin: args.User);
+                    boost.Boost * pressureMultiplier,
+                    origin: args.User);
+            }
         }
     }
     // Lavaland Change End

Content.Server/Zombies/ZombieSystem.Transform.cs

@@ -18,6 +18,7 @@
 using Content.Shared.Backmen.Surgery.Pain;
 using Content.Shared.Backmen.Surgery.Pain.Systems;
 using Content.Shared.Body.Components;
+using Content.Shared.Body.Systems;
 using Content.Shared.CombatMode;
 using Content.Shared.CombatMode.Pacification;
 using Content.Shared.Hands.Components;
@@ -73,6 +74,7 @@ public sealed partial class ZombieSystem
     [Dependency] private readonly NPCSystem _npc = default!;
     [Dependency] private readonly TagSystem _tag = default!;
     [Dependency] private readonly ISharedPlayerManager _player = default!;
+    [Dependency] private readonly SharedBodySystem _bodySystem = default!; // backmen
 
     private static readonly ProtoId<TagPrototype> InvalidForGlobalSpawnSpellTag = "InvalidForGlobalSpawnSpell";
     private static readonly ProtoId<TagPrototype> CannotSuicideTag = "CannotSuicide";
@@ -271,6 +273,7 @@ public void ZombifyEntity(EntityUid target, MobStateComponent? mobState = null)
                 PainType.TraumaticPain,
                 nerveSys.Value);
         }
+        _bodySystem.ForceRestoreBody(target, true);
         // Backmen Edit end
 
         _faction.ClearFactions(target, dirty: false);

Content.Server/_Lavaland/Procedural/Systems/LavalandPlanetSystem.Grid.cs

@@ -0,0 +1,167 @@
+using System;
+using System.Linq;
+using System.Numerics;
+using Content.Server._Lavaland.Procedural.Components;
+using Content.Shared._Lavaland.Procedural.Components;
+using Content.Shared._Lavaland.Procedural.Prototypes;
+using Content.Shared.Maps;
+using Robust.Server.Physics;
+using Robust.Shared.Map;
+using Robust.Shared.Map.Components;
+using Robust.Shared.Random;
+
+namespace Content.Server._Lavaland.Procedural.Systems;
+
+public sealed partial class LavalandPlanetSystem
+{
+        [Dependency] private readonly GridFixtureSystem _gridFixture = default!;
+        [Dependency] private readonly ITileDefinitionManager _tileDef = default!;
+
+    private bool LoadGridRuin(
+        LavalandGridRuinPrototype ruin,
+        Entity<LavalandMapComponent> lavaland,
+        Entity<LavalandPreloaderComponent> preloader,
+        Random random,
+        ref Dictionary<string, Box2> ruinsBoundsDict,
+        ref List<Box2> usedSpace,
+        ref List<Vector2> coords)
+    {
+        EntityUid? spawned = null;
+        if (coords.Count == 0)
+            return false;
+
+        var coord = random.Pick(coords);
+        var mapXform = Transform(preloader);
+        Box2 ruinBox; // This is ruin box, but moved to it's correct coords on the map
+
+        // Check if we already calculated that boundary before, and if we didn't then calculate it now
+        if (!ruinsBoundsDict.TryGetValue(ruin.ID, out var box))
+        {
+            if (!_mapLoader.TryLoadGrid(mapXform.MapID, ruin.Path, out var spawnedBoundedGrid))
+            {
+                Log.Error($"Failed to load ruin {ruin.ID} onto dummy map, on stage of loading! AAAAA!!");
+                return false;
+            }
+
+            // It's not useless!
+            spawned = spawnedBoundedGrid.Value.Owner;
+
+            if (!_fixtureQuery.TryGetComponent(spawned, out var manager))
+            {
+                Log.Error($"Failed to load ruin {ruin.ID} onto dummy map, it doesn't have fixture component! AAAAA!!");
+                Del(spawned);
+                return false;
+            }
+
+            // Actually calculate ruin bound
+            var transform = _physics.GetRelativePhysicsTransform(spawned.Value, preloader.Owner);
+            // holy shit
+            var bounds = (from fixture in manager.Fixtures.Values where fixture.Hard select fixture.Shape.ComputeAABB(transform, 0).Rounded(0)).ToList();
+            // Round this list of boxes up to
+            var calculatedBox = _random.Pick(bounds);
+            foreach (var bound in bounds)
+            {
+                calculatedBox = calculatedBox.Union(bound);
+            }
+
+            // Safety measure
+            calculatedBox = calculatedBox.Enlarged(8f);
+
+            // Add calculated box to dictionary
+            ruinsBoundsDict.Add(ruin.ID, calculatedBox);
+
+            // Move our calculated box to correct position
+            var v1 = calculatedBox.BottomLeft + coord;
+            var v2 = calculatedBox.TopRight + coord;
+            ruinBox = new Box2(v1, v2);
+
+            // Teleport it into place on preloader map
+            _transform.SetCoordinates(spawned.Value, new EntityCoordinates(preloader, coord));
+        }
+        else
+        {
+            // Why there's no method to move the Box2 around???
+            var v1 = box.BottomLeft + coord;
+            var v2 = box.TopRight + coord;
+            ruinBox = new Box2(v1, v2);
+        }
+
+        // If any used boundary intersects with current boundary, return
+        if (usedSpace.Any(used => used.Intersects(ruinBox)))
+        {
+            Log.Debug("Ruin can't be placed on it's coordinates, skipping spawn");
+            return false;
+        }
+
+        // Try to load it on a dummy map if it wasn't already
+        if (spawned == null)
+        {
+            if (!_mapLoader.TryLoadGrid(mapXform.MapID, ruin.Path, out var spawnedGrid, offset: coord))
+            {
+                Log.Error($"Failed to load ruin {ruin.ID} onto dummy map, on stage of reparenting it to Lavaland! (this is really bad)");
+                return false;
+            }
+
+            spawned = spawnedGrid.Value.Owner;
+        }
+
+        // Set its position to Lavaland
+        var spawnedXForm = _xformQuery.GetComponent(spawned.Value);
+        _metaData.SetEntityName(spawned.Value, Loc.GetString(ruin.Name));
+        _transform.SetParent(spawned.Value, spawnedXForm, lavaland);
+        _transform.SetCoordinates(spawned.Value, new EntityCoordinates(lavaland, spawnedXForm.Coordinates.Position.Rounded()));
+
+        // Merge fixtures from lavaland grid to spawned ruin grid
+        if (HasComp<MapGridComponent>(lavaland.Owner))
+        {
+            var sourceGridUid = lavaland.Owner;
+
+            if (TryComp<MapGridComponent>(spawned.Value, out var spawnedGrid) &&
+                TryComp<MapGridComponent>(sourceGridUid, out var sourceGrid) &&
+                sourceGridUid != spawned.Value)
+            {
+                try
+                {
+                    // Get the position of source grid (lavaland) in local coordinates of target grid (spawned)
+                    var sourceWorldPos = _transform.GetWorldPosition(sourceGridUid);
+                    var localPos = _map.WorldToLocal(spawned.Value, spawnedGrid, sourceWorldPos);
+                    var offset = (Vector2i)localPos;
+
+                    // Get the rotation of the target grid
+                    var rotation = Transform(spawned.Value).LocalRotation;
+
+                    // Replace empty tiles in spawned grid with tiles from the same position in lavaland grid
+                    foreach (var tile in _map.GetAllTiles(spawned.Value, spawnedGrid, false))
+                    {
+                        if (tile.Tile == Tile.Empty)
+                        {
+                            // Get world position of this tile
+                            var tileWorldPos = _map.GridTileToWorldPos(spawned.Value, spawnedGrid, tile.GridIndices);
+
+                            // Convert to local coordinates in lavaland grid
+                            var lavalandTileIndices = _map.WorldToTile(sourceGridUid, sourceGrid, tileWorldPos);
+
+                            // Get tile from lavaland grid at this position
+                            if (_map.TryGetTileRef(sourceGridUid, sourceGrid, lavalandTileIndices, out var lavalandTile) &&
+                                !lavalandTile.Tile.IsEmpty)
+                            {
+                                _map.SetTile(spawned.Value, spawnedGrid, tile.GridIndices, lavalandTile.Tile);
+                            }
+                        }
+                    }
+
+                    _gridFixture.Merge(sourceGridUid, spawned.Value, offset, rotation);
+                }
+                catch (Exception ex)
+                {
+                    Log.Error($"Failed to merge fixtures for ruin {ruin.ID}: {ex}");
+                }
+            }
+        }
+
+        // yaaaaaaaaaaaaaaaay
+        usedSpace.Add(ruinBox);
+        coords.Remove(coord);
+        return true;
+    }
+}