Merge remote-tracking branch 'origin/master'

Author: Marty

Content.Goobstation.Server/Devil/Condemned/CondemnedSystem.cs

@@ -7,6 +7,8 @@
 using Content.Goobstation.Shared.Devil;
 using Content.Goobstation.Shared.Devil.Condemned;
 using Content.Goobstation.Shared.Religion;
+using Content.Goobstation.Shared.HellGoose.Components;
+using Content.Goobstation.Shared.Maps;
 using Content.Server._Shitmed.StatusEffects;
 using Content.Server.IdentityManagement;
 using Content.Server.Polymorph.Systems;
@@ -16,10 +18,15 @@
 using Content.Shared.Movement.Events;
 using Content.Shared.Polymorph;
 using Content.Shared.Popups;
+using Content.Shared.Teleportation.Components;
 using Robust.Shared.Audio;
 using Robust.Shared.Audio.Systems;
 using Robust.Shared.Prototypes;
 using Robust.Shared.Spawners;
+using Robust.Shared.Map;
+using Robust.Shared.Map.Components;
+using Robust.Shared.EntitySerialization.Systems;
+using Robust.Shared.EntitySerialization;
 
 namespace Content.Goobstation.Server.Devil.Condemned;
 
@@ -29,6 +36,8 @@ public sealed partial class CondemnedSystem : EntitySystem
     [Dependency] private readonly PolymorphSystem _poly = default!;
     [Dependency] private readonly SharedPopupSystem _popup = default!;
     [Dependency] private readonly ScrambleDnaEffectSystem _scramble = default!;
+    [Dependency] private readonly SharedTransformSystem _sharedTransformSystem = default!;
+    [Dependency] private readonly MapLoaderSystem _mapLoader = default!;
     public override void Initialize()
     {
         base.Initialize();
@@ -147,15 +156,63 @@ private void UpdateHandPhase(EntityUid uid, float frameTime, CondemnedComponent?
         comp.CurrentPhase = CondemnedPhase.Complete;
     }
 
-    private void DoCondemnedBehavior(EntityUid uid, bool scramble = true, CondemnedComponent? comp = null)
+    private void DoCondemnedBehavior(EntityUid uid, bool scramble = true, CondemnedComponent? comp = null, bool retry = false)
     {
+        TransformComponent? portalXform = null;
+        HellPortalExitComponent? targetportal = null;
         if (!Resolve(uid, ref comp))
             return;
 
         switch (comp)
         {
             case { CondemnedBehavior: CondemnedBehavior.Delete }:
-                QueueDel(uid);
+                var query = EntityQueryEnumerator<HellPortalExitComponent, TransformComponent>();
+                while (query.MoveNext(out var hellexitportalcomp, out var xform))
+                {
+                    targetportal = hellexitportalcomp;
+                    portalXform = xform;
+                    break;
+                }
+
+                if (targetportal == null || portalXform == null)
+                {
+                    if (!_mapLoader.TryLoadMap(comp.HellMapPath,
+                        out var map, out var roots,
+                        options: new DeserializationOptions { InitializeMaps = true }))
+                    {
+                        Log.Error($"Failed to load hell map at {comp.HellMapPath}");
+                        QueueDel(map);
+                        return;
+                    }
+
+                    foreach (var root in roots)
+                    {
+                        if (!HasComp<HellMapComponent>(root))
+                            continue;
+
+                        var pos = new EntityCoordinates(root, 0, 0);
+
+                        var exitPortal = Spawn(comp.ExitPortalPrototype, pos);
+
+                        EnsureComp<PortalComponent>(exitPortal, out var hellPortalComp);
+
+                        var newHellMapComp = EnsureComp<HellMapComponent>(root);
+                        newHellMapComp.ExitPortal = exitPortal;
+
+                        break;
+                    }
+                    if (!retry)
+                    {
+                        DoCondemnedBehavior(uid, scramble, comp, true);
+                        return;
+                    }
+                }
+                if (portalXform == null)
+                {
+                    return;
+                }
+                // Teleport
+                _sharedTransformSystem.SetCoordinates(uid, portalXform.Coordinates);
                 break;
             case { CondemnedBehavior: CondemnedBehavior.Banish }:
                 if (scramble)

Content.Goobstation.Server/StationEvents/SecretPlus/SecretPlusSystem.cs

@@ -239,7 +239,7 @@ private void TrySpawnRoundstartAntags(Entity<SecretPlusComponent> scheduler)
         var primaryWeightList = _prototypeManager.Index(scheduler.Comp.PrimaryAntagsWeightTable);
         var weightList = _prototypeManager.Index(scheduler.Comp.RoundStartAntagsWeightTable);
 
-        var count = GetTotalPlayerCount(_playerManager.Sessions);
+        var count = GameTicker.ReadyPlayerCount(); //GetTotalPlayerCount(_playerManager.Sessions); // Omu, this should only check for players that are ready.
 
         LogMessage($"Trying to run roundstart rules, total player count: {count}", false);
 

Content.Goobstation.Shared/Devil/Condemned/CondemnedComponent.cs

@@ -7,6 +7,7 @@
 using Content.Shared.Polymorph;
 using Robust.Shared.Audio;
 using Robust.Shared.Prototypes;
+using Robust.Shared.Utility;
 
 namespace Content.Goobstation.Shared.Devil.Condemned;
 
@@ -97,6 +98,16 @@ public sealed partial class CondemnedComponent : Component
 
     [DataField]
     public ProtoId<PolymorphPrototype> BanishProto = "ShadowJaunt180";
+    /// <summary>
+    /// The map file location of the hell map used after banishment
+    /// </summary>
+    [DataField]
+    public ResPath HellMapPath = new ResPath("/Maps/_Goobstation/Nonstations/Hell.yml");
+    /// <summary>
+    /// The Prototype of the exit portal spawned in hell
+    /// </summary>
+    [DataField]
+    public EntProtoId ExitPortalPrototype = "PortalHellExit";
 }
 
 public enum CondemnedPhase : byte

Content.Goobstation.Shared/FloorGoblin/SharedCrawlUnderFloorSystem.cs

@@ -1,10 +1,9 @@
 // SPDX-FileCopyrightText: 2025 Evaisa <mail@evaisa.dev>
-//
+// SPDX-FileCopyrightText: 2025 RichardBlonski <48651647+RichardBlonski@users.noreply.github.com>
 // SPDX-License-Identifier: AGPL-3.0-or-later
 
 using Content.Shared._DV.Abilities;
 using Content.Shared._Starlight.VentCrawling;
-using Content.Shared.Actions;
 using Content.Shared.Climbing.Components;
 using Content.Shared.Climbing.Events;
 using Content.Shared.Interaction.Events;
@@ -22,6 +21,14 @@
 using Robust.Shared.Physics.Systems;
 using Robust.Shared.Player;
 using Robust.Shared.Random;
+using Content.Shared.Actions;
+using Content.Shared.Mobs.Components;
+using Content.Shared.Doors.Components;
+using Content.Shared.Conveyor;
+using Robust.Shared.Physics.Events;
+using Robust.Shared.Physics;
+using Robust.Shared.Physics.Components;
+using Robust.Shared.Physics.Systems;
 
 namespace Content.Goobstation.Shared.FloorGoblin;
 
@@ -40,9 +47,6 @@ public abstract class SharedCrawlUnderFloorSystem : EntitySystem
     [Dependency] private readonly TileSystem _tile = default!;
     [Dependency] private readonly SharedStealthSystem _stealth = default!;
 
-    private const int HiddenMask = (int) (CollisionGroup.HighImpassable | CollisionGroup.MidImpassable | CollisionGroup.LowImpassable | CollisionGroup.InteractImpassable);
-    private const int HiddenLayer = (int) (CollisionGroup.HighImpassable | CollisionGroup.MidImpassable | CollisionGroup.LowImpassable | CollisionGroup.MobLayer);
-
     public override void Initialize()
     {
         base.Initialize();
@@ -51,6 +55,7 @@ public override void Initialize()
         SubscribeLocalEvent<CrawlUnderFloorComponent, AttemptClimbEvent>(OnAttemptClimb);
         SubscribeLocalEvent<MapGridComponent, TileChangedEvent>(OnTileChanged);
         SubscribeLocalEvent<CrawlUnderFloorComponent, MoveEvent>(OnMove);
+        SubscribeLocalEvent<CrawlUnderFloorComponent, PreventCollideEvent>(OnPreventCollision);
         SubscribeLocalEvent<CrawlUnderFloorComponent, AttackAttemptEvent>(OnAttemptAttack);
         SubscribeLocalEvent<AttackAttemptEvent>(OnAnyAttackAttempt);
     }
@@ -130,21 +135,47 @@ private void OnTileChanged(EntityUid gridUid, MapGridComponent grid, ref TileCha
 
     private void OnMove(EntityUid uid, CrawlUnderFloorComponent comp, ref MoveEvent args)
     {
-        ProcessCrawlStateChange(uid, comp, false);
+        // Just update the crawl state based on whether we're enabled
+        ProcessCrawlStateChange(uid, comp, comp.Enabled);
     }
 
+
     private void OnAttemptAttack(EntityUid uid, CrawlUnderFloorComponent comp, AttackAttemptEvent args)
     {
         if (IsHidden(uid, comp))
             args.Cancel();
     }
 
-    private void OnAnyAttackAttempt(AttackAttemptEvent args)
+    private void OnAnyAttackAttempt(AttackAttemptEvent ev)
     {
-        if (args.Target is not { } target)
+        if (HasComp<CrawlUnderFloorComponent>(ev.Target))
+            ev.Cancel();
+    }
+
+    private void OnPreventCollision(EntityUid uid, CrawlUnderFloorComponent component, ref PreventCollideEvent args)
+    {
+        var otherUid = args.OtherEntity;
+
+        // Always prevent collision with mobs
+        if (HasComp<MobStateComponent>(otherUid))
+        {
+            args.Cancelled = true;
             return;
-        if (TryComp(target, out CrawlUnderFloorComponent? goblinComp) && IsHidden(target, goblinComp))
-            args.Cancel();
+        }
+
+        // Handle airlocks - allow phasing in stealth mode
+        if (HasComp<AirlockComponent>(otherUid) && component.Enabled)
+        {
+            args.Cancelled = true;
+            return;
+        }
+
+        // Handle conveyor belts - allow phasing in stealth mode
+        if (HasComp<ConveyorComponent>(otherUid) && component.Enabled)
+        {
+            args.Cancelled = true;
+            return;
+        }
     }
 
     protected void PlayDuendeSound(EntityUid uid, float probability = 0.3f)
@@ -163,7 +194,6 @@ protected bool EnableSneakMode(EntityUid uid, CrawlUnderFloorComponent component
             return false;
         component.Enabled = true;
         Dirty(uid, component);
-        UpdateSneakCollision(uid, component);
         return true;
     }
 
@@ -189,33 +219,21 @@ protected bool DisableSneakMode(EntityUid uid, CrawlUnderFloorComponent componen
         return true;
     }
 
-    protected void UpdateSneakCollision(EntityUid uid, CrawlUnderFloorComponent comp)
-    {
-        if (!TryComp(uid, out FixturesComponent? fixtures))
-            return;
-
-        var hidden = IsHidden(uid, comp);
-
-        foreach (var (key, fixture) in fixtures.Fixtures)
-        {
-            var baseMask = GetOrCacheBase(comp.ChangedFixtures, key, fixture.CollisionMask);
-            var desiredMask = hidden ? GetHiddenMask(baseMask) : baseMask;
-            if (fixture.CollisionMask != desiredMask)
-                _physics.SetCollisionMask(uid, key, fixture, desiredMask, manager: fixtures);
-
-            var baseLayer = GetOrCacheBase(comp.ChangedFixtureLayers, key, fixture.CollisionLayer);
-            var desiredLayer = hidden ? GetHiddenLayer(baseLayer) : baseLayer;
-            if (fixture.CollisionLayer != desiredLayer)
-                _physics.SetCollisionLayer(uid, key, fixture, desiredLayer, manager: fixtures);
-        }
-    }
 
     public bool IsOnCollidingTile(EntityUid uid)
     {
-        if (!TryGetCurrentTile(uid, out var tileRef, out _))
+        // If we're under the floor, don't consider any tiles as colliding
+        if (TryComp<CrawlUnderFloorComponent>(uid, out var crawlComp) &&
+            crawlComp.Enabled &&
+            !IsOnSubfloor(uid))
+        {
             return false;
-        if (tileRef.Tile.IsEmpty)
+        }
+
+        // Standard collision check for tiles
+        if (!TryGetCurrentTile(uid, out var tileRef, out _) || tileRef.Tile.IsEmpty)
             return false;
+
         return _turf.IsTileBlocked(tileRef, CollisionGroup.MobMask);
     }
 
@@ -237,7 +255,7 @@ private bool IsInSpace(EntityUid uid)
     }
 
     public bool IsHidden(EntityUid uid, CrawlUnderFloorComponent comp)
-        => comp.Enabled && !IsOnSubfloor(uid);
+        => comp.Enabled; // No longer check for subfloor, just check if crawling is enabled
 
     private void HandleCrawlTransition(EntityUid uid, bool wasOnSubfloor, bool isOnSubfloor, CrawlUnderFloorComponent comp, bool causedByTileChange)
     {
@@ -260,15 +278,6 @@ private void HandleCrawlTransition(EntityUid uid, bool wasOnSubfloor, bool isOnS
             PlayDuendeSound(uid, causedByTileChange ? 1f : 0.3f);
     }
 
-
-    private static int GetHiddenMask(int baseMask)
-        => baseMask
-           & ~HiddenMask;
-
-    private static int GetHiddenLayer(int baseLayer)
-        => baseLayer
-           & ~HiddenLayer;
-
     private static int GetOrCacheBase<TKey>(List<(TKey, int)> list, TKey key, int current)
     {
         var idx = list.FindIndex(t => EqualityComparer<TKey>.Default.Equals(t.Item1, key));
@@ -294,8 +303,39 @@ private void PryTileIfUnder(EntityUid uid, CrawlUnderFloorComponent comp)
         _tile.PryTile(snapPos, gridUid);
     }
 
+    private void UpdateCollisionMask(EntityUid uid, bool stealthMode)
+    {
+        if (!TryComp<FixturesComponent>(uid, out var fixtures))
+            return;
+
+        if (stealthMode)
+        {
+            // In stealth mode, set to SmallMob collision to maintain some physics
+            // while still allowing phasing through most objects
+            foreach (var (id, fixture) in fixtures.Fixtures)
+            {
+                _physics.SetCollisionMask(uid, id, fixture, (int)CollisionGroup.SmallMobMask, fixtures);
+                _physics.SetCollisionLayer(uid, id, fixture, (int)CollisionGroup.SmallMobLayer, fixtures);
+            }
+        }
+        else
+        {
+            // In normal mode, use standard mob collision
+            foreach (var (id, fixture) in fixtures.Fixtures)
+            {
+                _physics.SetCollisionMask(uid, id, fixture, (int)CollisionGroup.MobMask, fixtures);
+                _physics.SetCollisionLayer(uid, id, fixture, (int)CollisionGroup.MobLayer, fixtures);
+            }
+        }
+
+        Dirty(uid, fixtures);
+    }
+
     private void SetStealth(EntityUid uid, bool enabled)
     {
+        // Update collision mask based on stealth state
+        UpdateCollisionMask(uid, enabled);
+
         // Evil hud overlay hiding shitcode that hijacks StealthComponent
         if (enabled)
         {
@@ -324,9 +364,6 @@ private void RefreshCrawlSubfloorState(EntityUid uid, CrawlUnderFloorComponent c
         var old = comp.WasOnSubfloor;
         comp.WasOnSubfloor = now;
 
-        if (comp.Enabled && now != old)
-            UpdateSneakCollision(uid, comp);
-
         HandleCrawlTransition(uid, old, now, comp, causedByTileChange);
     }