Merge branch 'master' into outercommand-drip

Author: Androidonator

Content.Goobstation.Client/Tools/WeldingSparksAnimationSystem.cs

@@ -0,0 +1,99 @@
+using Content.Goobstation.Shared.Tools;
+using Content.Shared.Tools.Components;
+using Robust.Client.Animations;
+using Robust.Client.GameObjects;
+using Robust.Client.Graphics;
+using Robust.Shared.Animations;
+using System.Numerics;
+
+namespace Content.Goobstation.Client.Tools;
+
+public sealed class WeldingSparksAnimationSystem : EntitySystem
+{
+    [Dependency] private readonly AnimationPlayerSystem _animation = default!;
+    [Dependency] private readonly IEyeManager _eyeManager = default!;
+    [Dependency] private readonly TransformSystem _transformSystem = default!;
+
+    private const string ANIM_KEY = "WeldAnim";
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeNetworkEvent<SpawnedWeldingSparksEvent>(OnSpawnedWeldingSparks);
+    }
+
+    private void OnSpawnedWeldingSparks(SpawnedWeldingSparksEvent ev)
+    {
+        var targetEnt = GetEntity(ev.TargetEnt);
+        if (!TryComp<WeldableComponent>(targetEnt, out var weldableComp) || !TryComp<WeldingSparksAnimationComponent>(targetEnt, out var sparksAnim))
+            return;
+
+        if (!TryGetEntity(ev.SparksEnt, out var sparksEnt))
+            // `targetEnt` is validated with the `TryComp()` calls, so that can just use `GetEntity()`.
+            return;
+
+        var animationPlayer = EnsureComp<AnimationPlayerComponent>(targetEnt);
+        if (_animation.HasRunningAnimation(targetEnt, animationPlayer, ANIM_KEY))
+            return;
+
+        var (startOffset, endOffset) = GetOffsets((targetEnt, sparksAnim), weldableComp.IsWelded);
+
+        var animation = new Animation()
+        {
+            Length = ev.Duration,
+            AnimationTracks =
+            {
+                new AnimationTrackComponentProperty()
+                {
+                    ComponentType = typeof(SpriteComponent),
+                    Property = nameof(SpriteComponent.Offset),
+                    InterpolationMode = AnimationInterpolationMode.Linear,
+                    KeyFrames =
+                    {
+                        new AnimationTrackProperty.KeyFrame(startOffset, 0f),
+                        new AnimationTrackProperty.KeyFrame(endOffset, (float) ev.Duration.TotalSeconds),
+                    }
+                }
+            }
+        };
+
+        _animation.Play(sparksEnt.Value, animation, ANIM_KEY);
+    }
+
+    private (Vector2, Vector2) GetOffsets(Entity<WeldingSparksAnimationComponent> ent, bool isWelded)
+    {
+        var start = ent.Comp.StartingOffset;
+        // If there's no manual `EndingOffset`, just go to the opposite of `StartingOffset`.
+        var end = ent.Comp.EndingOffset ?? -ent.Comp.StartingOffset;
+
+        // Rotation
+        // Honestly I don't understand all of RT's sprite/eye/world/cardinal rotation stuff. I just trial-and-error'd this into working.
+        // (why isn't there a helper function for this) :(
+        if (TryComp<SpriteComponent>(ent, out var sprite))
+        {
+            var worldRotation = _transformSystem.GetWorldRotation(ent);
+            var eyeRotation = _eyeManager.CurrentEye.Rotation;
+
+            var relativeRotation = (worldRotation + eyeRotation).Reduced().FlipPositive();
+
+            var cardinalSnapping = sprite.SnapCardinals ? relativeRotation.GetCardinalDir().ToAngle() : Angle.Zero;
+
+            var finalAngle = sprite.NoRotation ? relativeRotation : relativeRotation - cardinalSnapping;
+
+            start = finalAngle.RotateVec(start); // `RotateVec()` contains a `Theta == 0` check, so no need to check for it in here.
+            end = finalAngle.RotateVec(end);
+        }
+
+        // Welding.
+        if (!isWelded)
+        {
+            return (start, end);
+        }
+        // Unwelding. (go backwards)
+        else
+        {
+            return (end, start);
+        }
+    }
+}

Content.Goobstation.Common/Silicons/Components/ExperimentalLawProviderComponent.cs

@@ -14,8 +14,8 @@ public sealed partial class ExperimentalLawProviderComponent : Component
 {
     [DataField] public string RandomLawsets = "IonStormLawsets";
 
-    // Numbers are equivalent to 83 points per second, so it's like running a dangerous anomaly for 2 minutes.
+    // buffed point amounts 3x so people will actually use this; 30k in two minutes seems ok to me (triples points per second from ~80 to ~240)- strong but takes a lot of setup by RD (and stealing the AI upload console)
     [DataField] public float RewardTime = 120.0f;
 
-    [DataField] public int RewardPoints = 10000;
+    [DataField] public int RewardPoints = 30000;
 }

Content.Goobstation.Common/Tools/UseToolEvent.cs

@@ -0,0 +1,38 @@
+namespace Content.Goobstation.Common.Tools;
+
+/// <summary>
+/// Event raised on a tool in `SharedToolSystem.UseTool()` if its DoAfter timer successfully started.
+/// </summary>
+public readonly record struct UseToolEvent
+{
+    /// <summary>
+    /// The entity using the tool.
+    /// </summary>
+    public readonly EntityUid User;
+
+    /// <summary>
+    /// The entity that the tool is being used on. (May be null)
+    /// </summary>
+    public readonly EntityUid? Target;
+
+    /// <summary>
+    /// The ID index of the DoAfter.
+    /// </summary>
+    /// <remarks>
+    /// Ideally this would just be a <c>DoAfterIdx</c> instance and wouldn't need converting back, but this is in '.Common' so oh well.
+    /// </remarks>
+    public readonly ushort DoAfterIdx;
+
+    /// <summary>
+    /// Duration of the DoAfter timer.
+    /// </summary>
+    public readonly TimeSpan DoAfterLength;
+
+    public UseToolEvent(EntityUid user, EntityUid? target, ushort doAfterIdx, TimeSpan doAfterLength)
+    {
+        User = user;
+        Target = target;
+        DoAfterIdx = doAfterIdx;
+        DoAfterLength = doAfterLength;
+    }
+}

Content.Goobstation.Server/Actions/ActionsProviderComponent.cs

@@ -24,6 +24,7 @@
 using Content.Server.Nuke;
 using Content.Server.Objectives;
 using Content.Server.RoundEnd;
+using Content.Server.Shuttles.Systems;
 using Content.Server.Station.Components;
 using Content.Server.Station.Systems;
 using Content.Shared.GameTicking.Components;
@@ -44,6 +45,7 @@ public sealed class BlobRuleSystem : GameRuleSystem<BlobRuleComponent>
     [Dependency] private readonly AlertLevelSystem _alertLevelSystem = default!;
     [Dependency] private readonly IChatManager _chatManager = default!;
     [Dependency] private readonly IPlayerManager _player = default!;
+    [Dependency] private readonly EmergencyShuttleSystem _emergency = default!;
 
     public override void Initialize()
     {
@@ -124,7 +126,8 @@ private void CheckChangeStage(
         var stationName = Name(stationUid);
 
         if (blobTilesCount >= (stationUid.Comp?.StageBegin ?? StationBlobConfigComponent.DefaultStageBegin)
-            && _roundEndSystem.ExpectedCountdownEnd != null)
+            && _roundEndSystem.ExpectedCountdownEnd != null
+            && !_emergency.EmergencyShuttleArrived)
         {
             _roundEndSystem.CancelRoundEndCountdown(checkCooldown: false);
             _chatSystem.DispatchStationAnnouncement(stationUid,
@@ -134,7 +137,17 @@ private void CheckChangeStage(
                 null,
                 Color.Red);
         }
-
+        else if (blobTilesCount >= (stationUid.Comp?.StageBegin ?? StationBlobConfigComponent.DefaultStageBegin)
+                 && _roundEndSystem.ExpectedCountdownEnd != null && _emergency.EmergencyShuttleArrived) 
+        {
+            _chatSystem.DispatchStationAnnouncement(stationUid,
+                Loc.GetString("blob-alert-shuttle-arrived"),
+                Loc.GetString("Station"),
+                false,
+                null,
+                Color.OrangeRed);
+        }
+        
         switch (blobRuleComp.Stage)
         {
             case BlobStage.Default when blobTilesCount >= (stationUid.Comp?.StageBegin ?? StationBlobConfigComponent.DefaultStageBegin):

Content.Goobstation.Server/Actions/ActionsProviderSystem.cs

@@ -5,6 +5,7 @@
 // SPDX-License-Identifier: AGPL-3.0-or-later
 
 using Content.Goobstation.Common.Standing;
+using Content.Goobstation.Server.Sandevistan;
 using Content.Goobstation.Shared.Sprinting;
 using Content.Server.Stunnable;
 using Content.Shared.CombatMode;
@@ -35,7 +36,9 @@ private void OnCollide(EntityUid uid, SprinterComponent sprinter, ref StartColli
             return;
         }
 
-        if (!TryComp(otherUid, out SprinterComponent? otherSprinter) || !otherSprinter.IsSprinting)
+        if (!TryComp(otherUid, out SprinterComponent? otherSprinter)
+            || !otherSprinter.IsSprinting
+            || !HasComp<ActiveSandevistanUserComponent>(otherUid))
         {
             return;
         }

Content.Goobstation.Server/Blob/GameTicking/BlobRuleSystem.cs

@@ -12,7 +12,7 @@
 
 namespace Content.Goobstation.Server.StationEvents.Components;
 
-[RegisterComponent, Access(typeof(GameDirectorSystem))]
+[RegisterComponent, Access(typeof(GameDirector.GameDirectorSystem))]
 public sealed partial class GameDirectorComponent : Component
 {
 

Content.Goobstation.Server/Sprinting/SprintingSystem.cs

@@ -0,0 +1,33 @@
+using Content.Goobstation.Server.StationEvents.Components;
+using Content.Goobstation.Server.StationEvents.Metric;
+
+namespace Content.Goobstation.Server.StationEvents.GameDirector;
+
+/// <summary>
+///   Pairs a PossibleEvent with the resultant chaos and a "score" for sorting by the GameDirector
+///   Temporary class used in processing and ranking the list of events.
+/// </summary>
+public sealed class RankedEvent(PossibleEvent possibleEvent, ChaosMetrics result, float score)
+{
+    /// <summary>
+    ///   Contains the StationEvent and expected chaos delta
+    /// </summary>
+    public readonly PossibleEvent PossibleEvent = possibleEvent;
+
+    /// <summary>
+    ///   Current chaos + PossibleEvent.Chaos at time of creation
+    /// </summary>
+    public readonly ChaosMetrics Result = result;
+
+    /// <summary>
+    ///   Preference for this RankedEvent, lower is better.
+    ///   Essentially the "pain" of how far Result is from the StoryBeat.Goal
+    /// </summary>
+    public readonly float Score = score;
+}
+
+public sealed class PlayerCount
+{
+    public int Players;
+    public int Ghosts;
+}

Content.Goobstation.Server/StationEvents/Components/GameDirectorComponent.cs

@@ -0,0 +1,65 @@
+using System.Linq;
+using Content.Shared.Mind;
+using Robust.Shared.Enums;
+using Robust.Shared.Player;
+
+namespace Content.Goobstation.Server.StationEvents.GameDirector;
+
+public sealed partial class GameDirectorSystem
+{
+
+    /// <summary>
+    ///   Count the active players and ghosts on the server.
+    ///   Players gates which stories and events are available
+    ///   Ghosts can be used to gate certain events (which require ghosts to occur)
+    /// </summary>
+    private PlayerCount CountActivePlayers()
+    {
+        var allPlayers = Enumerable.ToList<ICommonSession>(_playerManager.Sessions);
+        var count = new PlayerCount();
+        foreach (var player in allPlayers)
+        {
+            if (player.AttachedEntity == null)
+                continue;
+            var ev = new GetCharactedDeadIcEvent();
+            RaiseLocalEvent(player.AttachedEntity.Value, ref ev);
+            if (ev.Dead is not true)
+                count.Players++;
+            else
+                count.Ghosts++;
+        }
+
+        count.Players += _event.PlayerCountBias;
+
+        return count;
+    }
+
+    /// <summary>
+    /// Gets the player count for antag selection (debug or actual)
+    /// </summary>
+    private int GetPlayerCount()
+    {
+#if DEBUG
+        return _gameDirectorDebugPlayerCount;
+#else
+        return GetTotalPlayerCount(_playerManager.Sessions);
+#endif
+    }
+
+    /// <summary>
+    ///   Count all the players on the server.
+    /// </summary>
+    private int GetTotalPlayerCount(IList<ICommonSession> pool)
+    {
+        var count = 0;
+        foreach (var session in pool)
+        {
+            if (session.Status is SessionStatus.Disconnected or SessionStatus.Zombie)
+                continue;
+
+            count++;
+        }
+
+        return count + _event.PlayerCountBias;
+    }
+}