Merge branch 'space-wizards:master' into master

.github/workflows/labeler-stable.yml

@@ -0,0 +1,16 @@
+name: "Labels: Branch stable"
+
+on:
+  pull_request_target:
+    types:
+      - opened
+    branches:
+      - 'stable'
+
+jobs:
+  add_label:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions-ecosystem/action-add-labels@v1
+      with:
+        labels: "Branch: stable"

.github/workflows/labeler-staging.yml

@@ -0,0 +1,16 @@
+name: "Labels: Branch staging"
+
+on:
+  pull_request_target:
+    types:
+      - opened
+    branches:
+      - 'staging'
+
+jobs:
+  add_label:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions-ecosystem/action-add-labels@v1
+      with:
+        labels: "Branch: staging"

Content.Client/Alerts/ClientAlertsSystem.cs

@@ -2,6 +2,7 @@
 using Content.Shared.Alert;
 using JetBrains.Annotations;
 using Robust.Client.Player;
+using Robust.Shared.GameStates;
 using Robust.Shared.Player;
 using Robust.Shared.Prototypes;
 
@@ -24,8 +25,7 @@ public override void Initialize()
 
         SubscribeLocalEvent<AlertsComponent, LocalPlayerAttachedEvent>(OnPlayerAttached);
         SubscribeLocalEvent<AlertsComponent, LocalPlayerDetachedEvent>(OnPlayerDetached);
-
-        SubscribeLocalEvent<AlertsComponent, AfterAutoHandleStateEvent>(ClientAlertsHandleState);
+        SubscribeLocalEvent<AlertsComponent, ComponentHandleState>(OnHandleState);
     }
     protected override void LoadPrototypes()
     {
@@ -47,17 +47,22 @@ public IReadOnlyDictionary<AlertKey, AlertState>? ActiveAlerts
         }
     }
 
-    protected override void AfterShowAlert(Entity<AlertsComponent> alerts)
+    private void OnHandleState(Entity<AlertsComponent> alerts, ref ComponentHandleState args)
     {
+        if (args.Current is not AlertComponentState cast)
+            return;
+
+        alerts.Comp.Alerts = cast.Alerts;
+
         UpdateHud(alerts);
     }
 
-    protected override void AfterClearAlert(Entity<AlertsComponent> alerts)
+    protected override void AfterShowAlert(Entity<AlertsComponent> alerts)
     {
         UpdateHud(alerts);
     }
 
-    private void ClientAlertsHandleState(Entity<AlertsComponent> alerts, ref AfterAutoHandleStateEvent args)
+    protected override void AfterClearAlert(Entity<AlertsComponent> alerts)
     {
         UpdateHud(alerts);
     }

Content.Client/Effects/ColorFlashEffectSystem.cs

@@ -124,6 +124,10 @@ private void OnColorFlashEffect(ColorFlashEffectEvent ev)
                 continue;
             }
 
+            var targetEv = new GetFlashEffectTargetEvent(ent);
+            RaiseLocalEvent(ent, ref targetEv);
+            ent = targetEv.Target;
+
             EnsureComp<ColorFlashEffectComponent>(ent, out comp);
             comp.NetSyncEnabled = false;
             comp.Color = sprite.Color;
@@ -132,3 +136,9 @@ private void OnColorFlashEffect(ColorFlashEffectEvent ev)
         }
     }
 }
+
+/// <summary>
+/// Raised on an entity to change the target for a color flash effect.
+/// </summary>
+[ByRefEvent]
+public record struct GetFlashEffectTargetEvent(EntityUid Target);

Content.Client/Physics/Controllers/MoverController.cs

@@ -1,9 +1,12 @@
+using Content.Shared.Alert;
+using Content.Shared.CCVar;
 using Content.Shared.Movement.Components;
 using Content.Shared.Movement.Pulling.Components;
 using Content.Shared.Movement.Systems;
 using Robust.Client.GameObjects;
 using Robust.Client.Physics;
 using Robust.Client.Player;
+using Robust.Shared.Configuration;
 using Robust.Shared.Physics.Components;
 using Robust.Shared.Player;
 using Robust.Shared.Timing;
@@ -14,6 +17,8 @@ public sealed class MoverController : SharedMoverController
 {
     [Dependency] private readonly IGameTiming _timing = default!;
     [Dependency] private readonly IPlayerManager _playerManager = default!;
+    [Dependency] private readonly AlertsSystem _alerts = default!;
+    [Dependency] private readonly IConfigurationManager _cfg = default!;
 
     public override void Initialize()
     {
@@ -135,4 +140,15 @@ protected override bool CanSound()
     {
         return _timing is { IsFirstTimePredicted: true, InSimulation: true };
     }
+
+    public override void SetSprinting(Entity<InputMoverComponent> entity, ushort subTick, bool walking)
+    {
+        // Logger.Info($"[{_gameTiming.CurTick}/{subTick}] Sprint: {enabled}");
+        base.SetSprinting(entity, subTick, walking);
+
+        if (walking && _cfg.GetCVar(CCVars.ToggleWalk))
+            _alerts.ShowAlert(entity, WalkingAlert, showCooldown: false, autoRemove: false);
+        else
+            _alerts.ClearAlert(entity, WalkingAlert);
+    }
 }

Content.Client/Polymorph/Systems/ChameleonProjectorSystem.cs

@@ -1,7 +1,10 @@
+using Content.Client.Effects;
+using Content.Client.Smoking;
 using Content.Shared.Chemistry.Components;
 using Content.Shared.Polymorph.Components;
 using Content.Shared.Polymorph.Systems;
 using Robust.Client.GameObjects;
+using Robust.Shared.Player;
 
 namespace Content.Client.Polymorph.Systems;
 
@@ -10,24 +13,51 @@ public sealed class ChameleonProjectorSystem : SharedChameleonProjectorSystem
     [Dependency] private readonly SharedAppearanceSystem _appearance = default!;
 
     private EntityQuery<AppearanceComponent> _appearanceQuery;
+    private EntityQuery<SpriteComponent> _spriteQuery;
 
     public override void Initialize()
     {
         base.Initialize();
 
         _appearanceQuery = GetEntityQuery<AppearanceComponent>();
+        _spriteQuery = GetEntityQuery<SpriteComponent>();
 
         SubscribeLocalEvent<ChameleonDisguiseComponent, AfterAutoHandleStateEvent>(OnHandleState);
+
+        SubscribeLocalEvent<ChameleonDisguisedComponent, ComponentStartup>(OnStartup);
+        SubscribeLocalEvent<ChameleonDisguisedComponent, ComponentShutdown>(OnShutdown);
+        SubscribeLocalEvent<ChameleonDisguisedComponent, GetFlashEffectTargetEvent>(OnGetFlashEffectTargetEvent);
     }
 
     private void OnHandleState(Entity<ChameleonDisguiseComponent> ent, ref AfterAutoHandleStateEvent args)
     {
         CopyComp<SpriteComponent>(ent);
         CopyComp<GenericVisualizerComponent>(ent);
         CopyComp<SolutionContainerVisualsComponent>(ent);
+        CopyComp<BurnStateVisualsComponent>(ent);
 
         // reload appearance to hopefully prevent any invisible layers
         if (_appearanceQuery.TryComp(ent, out var appearance))
             _appearance.QueueUpdate(ent, appearance);
     }
+
+    private void OnStartup(Entity<ChameleonDisguisedComponent> ent, ref ComponentStartup args)
+    {
+        if (!_spriteQuery.TryComp(ent, out var sprite))
+            return;
+
+        ent.Comp.WasVisible = sprite.Visible;
+        sprite.Visible = false;
+    }
+
+    private void OnShutdown(Entity<ChameleonDisguisedComponent> ent, ref ComponentShutdown args)
+    {
+        if (_spriteQuery.TryComp(ent, out var sprite))
+            sprite.Visible = ent.Comp.WasVisible;
+    }
+
+    private void OnGetFlashEffectTargetEvent(Entity<ChameleonDisguisedComponent> ent, ref GetFlashEffectTargetEvent args)
+    {
+        args.Target = ent.Comp.Disguise;
+    }
 }

Content.Server/Alert/ServerAlertsSystem.cs

@@ -1,7 +1,19 @@
 using Content.Shared.Alert;
+using Robust.Shared.GameStates;
 
 namespace Content.Server.Alert;
 
 internal sealed class ServerAlertsSystem : AlertsSystem
 {
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<AlertsComponent, ComponentGetState>(OnGetState);
+    }
+
+    private void OnGetState(Entity<AlertsComponent> alerts, ref ComponentGetState args)
+    {
+        args.State = new AlertComponentState(alerts.Comp.Alerts);
+    }
 }

Content.Server/Antag/AntagSelectionSystem.cs

@@ -55,6 +55,8 @@ public override void Initialize()
     {
         base.Initialize();
 
+        Log.Level = LogLevel.Debug;
+
         SubscribeLocalEvent<GhostRoleAntagSpawnerComponent, TakeGhostRoleEvent>(OnTakeGhostRole);
 
         SubscribeLocalEvent<AntagSelectionComponent, ObjectivesTextGetInfoEvent>(OnObjectivesTextGetInfo);
@@ -360,6 +362,8 @@ public void MakeAntag(Entity<AntagSelectionComponent> ent, ICommonSession? sessi
             _role.MindAddRoles(curMind.Value, def.MindRoles, null, true);
             ent.Comp.SelectedMinds.Add((curMind.Value, Name(player)));
             SendBriefing(session, def.Briefing);
+
+            Log.Debug($"Selected {ToPrettyString(curMind)} as antagonist: {ToPrettyString(ent)}");
         }
 
         var afterEv = new AfterAntagEntitySelectedEvent(session, player, ent, def);

Content.Server/GameTicking/Rules/TraitorRuleSystem.cs

@@ -41,6 +41,8 @@ public override void Initialize()
     {
         base.Initialize();
 
+        Log.Level = LogLevel.Debug;
+
         SubscribeLocalEvent<TraitorRuleComponent, AfterAntagEntitySelectedEvent>(AfterEntitySelected);
         SubscribeLocalEvent<TraitorRuleComponent, ObjectivesTextPrependEvent>(OnObjectivesTextPrepend);
     }
@@ -53,6 +55,7 @@ protected override void Added(EntityUid uid, TraitorRuleComponent component, Gam
 
     private void AfterEntitySelected(Entity<TraitorRuleComponent> ent, ref AfterAntagEntitySelectedEvent args)
     {
+        Log.Debug($"AfterAntagEntitySelected {ToPrettyString(ent)}");
         MakeTraitor(args.EntityUid, ent);
     }
 
@@ -78,14 +81,22 @@ public string[] GenerateTraitorCodewords(TraitorRuleComponent component)
 
     public bool MakeTraitor(EntityUid traitor, TraitorRuleComponent component)
     {
+        Log.Debug($"MakeTraitor {ToPrettyString(traitor)} - start");
+
         //Grab the mind if it wasn't provided
         if (!_mindSystem.TryGetMind(traitor, out var mindId, out var mind))
+        {
+            Log.Debug($"MakeTraitor {ToPrettyString(traitor)}  - failed, no Mind found");
             return false;
+        }
 
         var briefing = "";
 
         if (component.GiveCodewords)
+        {
+            Log.Debug($"MakeTraitor {ToPrettyString(traitor)} - added codewords flufftext to briefing");
             briefing = Loc.GetString("traitor-role-codewords-short", ("codewords", string.Join(", ", component.Codewords)));
+        }
 
         var issuer = _random.Pick(_prototypeManager.Index(component.ObjectiveIssuers).Values);
 
@@ -94,6 +105,7 @@ public bool MakeTraitor(EntityUid traitor, TraitorRuleComponent component)
 
         if (component.GiveUplink)
         {
+            Log.Debug($"MakeTraitor {ToPrettyString(traitor)} - Uplink start");
             // Calculate the amount of currency on the uplink.
             var startingBalance = component.StartingBalance;
             if (_jobs.MindTryGetJob(mindId, out var prototype))
@@ -105,18 +117,27 @@ public bool MakeTraitor(EntityUid traitor, TraitorRuleComponent component)
             }
 
             // Choose and generate an Uplink, and return the uplink code if applicable
+            Log.Debug($"MakeTraitor {ToPrettyString(traitor)} - Uplink request start");
             var uplinkParams = RequestUplink(traitor, startingBalance, briefing);
             code = uplinkParams.Item1;
             briefing = uplinkParams.Item2;
+            Log.Debug($"MakeTraitor {ToPrettyString(traitor)} - Uplink request completed");
         }
 
         string[]? codewords = null;
         if (component.GiveCodewords)
+        {
+            Log.Debug($"MakeTraitor {ToPrettyString(traitor)} - set codewords from component");
             codewords = component.Codewords;
+        }
 
         if (component.GiveBriefing)
+        {
             _antag.SendBriefing(traitor, GenerateBriefing(codewords, code, issuer), null, component.GreetSoundNotification);
+            Log.Debug($"MakeTraitor {ToPrettyString(traitor)} - Sent the Briefing");
+        }
 
+        Log.Debug($"MakeTraitor {ToPrettyString(traitor)} - Adding TraitorMind");
         component.TraitorMinds.Add(mindId);
 
         // Assign briefing
@@ -126,9 +147,14 @@ public bool MakeTraitor(EntityUid traitor, TraitorRuleComponent component)
         _roleSystem.MindHasRole<TraitorRoleComponent>(mindId, out var traitorRole);
         if (traitorRole is not null)
         {
+            Log.Debug($"MakeTraitor {ToPrettyString(traitor)} - Add traitor briefing components");
             AddComp<RoleBriefingComponent>(traitorRole.Value.Owner);
             Comp<RoleBriefingComponent>(traitorRole.Value.Owner).Briefing = briefing;
         }
+        else
+        {
+            Log.Debug($"MakeTraitor {ToPrettyString(traitor)} - did not get traitor briefing");
+        }
 
         // Send codewords to only the traitor client
         var color = TraitorCodewordColor; // Fall back to a dark red Syndicate color if a prototype is not found
@@ -137,9 +163,11 @@ public bool MakeTraitor(EntityUid traitor, TraitorRuleComponent component)
         _roleCodewordSystem.SetRoleCodewords(codewordComp, "traitor", component.Codewords.ToList(), color);
 
         // Change the faction
+        Log.Debug($"MakeTraitor {ToPrettyString(traitor)} - Change faction");
         _npcFaction.RemoveFaction(traitor, component.NanoTrasenFaction, false);
         _npcFaction.AddFaction(traitor, component.SyndicateFaction);
 
+        Log.Debug($"MakeTraitor {ToPrettyString(traitor)} - Finished");
         return true;
     }
 
@@ -148,10 +176,12 @@ public bool MakeTraitor(EntityUid traitor, TraitorRuleComponent component)
         var pda = _uplink.FindUplinkTarget(traitor);
         Note[]? code = null;
 
+        Log.Debug($"MakeTraitor {ToPrettyString(traitor)} - Uplink add");
         var uplinked = _uplink.AddUplink(traitor, startingBalance, pda, true);
 
         if (pda is not null && uplinked)
         {
+            Log.Debug($"MakeTraitor {ToPrettyString(traitor)} - Uplink is PDA");
             // Codes are only generated if the uplink is a PDA
             code = EnsureComp<RingerUplinkComponent>(pda.Value).Code;
 
@@ -163,6 +193,7 @@ public bool MakeTraitor(EntityUid traitor, TraitorRuleComponent component)
         }
         else if (pda is null && uplinked)
         {
+            Log.Debug($"MakeTraitor {ToPrettyString(traitor)} - Uplink is implant");
             briefing += "\n" + Loc.GetString("traitor-role-uplink-implant-short");
         }