Merge branch 'master' into perma-knife

.github/workflows/labeler-needsreview.yml

@@ -3,14 +3,41 @@
 on:
   pull_request_target:
     types: [review_requested]
+  pull_request_review:
+    types: [submitted]
+
+permissions:
+  pull-requests: write
+  contents: write
 
 jobs:
   add_label:
     runs-on: ubuntu-latest
+    if: github.event_name == 'pull_request_target'
     steps:
     - uses: actions-ecosystem/action-add-labels@v1
       with:
         labels: "S: Needs Review"
     - uses: actions-ecosystem/action-remove-labels@v1
       with:
         labels: "S: Awaiting Changes"
+
+  handle_review:
+    runs-on: ubuntu-latest
+    if: github.event_name == 'pull_request_review'
+    steps:
+    - uses: actions-ecosystem/action-add-labels@v1
+      if: |
+        github.event.review.state == 'changes_requested' &&
+        (github.event.review.author_association == 'OWNER' ||
+         github.event.review.author_association == 'MEMBER')
+      with:
+        labels: "S: Awaiting Changes"
+
+    - uses: actions-ecosystem/action-remove-labels@v1
+      if: |
+        github.event.review.state == 'changes_requested' &&
+        (github.event.review.author_association == 'OWNER' ||
+         github.event.review.author_association == 'MEMBER')
+      with:
+        labels: "S: Needs Review"

.github/workflows/labeler-untriaged.yml

@@ -3,8 +3,6 @@
 on:
   issues:
     types: [opened]
-  pull_request_target:
-    types: [opened]
 
 jobs:
   add_label:

Content.Server/DeltaV/GameTicking/Rules/Components/DelayedRuleComponent.cs

@@ -0,0 +1,46 @@
+using Robust.Shared.Prototypes;
+using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom;
+
+namespace Content.Server.DeltaV.GameTicking.Rules.Components;
+
+/// <summary>
+/// Delays adding components to the antags of a gamerule until some time has passed.
+/// </summary>
+/// <remarks>
+/// This is used for the zombies gamemode so that new players don't hit the funny button immediately and ruin anyone else's plans.
+/// </remarks>
+[RegisterComponent, Access(typeof(DelayedRuleSystem))]
+[AutoGenerateComponentPause]
+public sealed partial class DelayedRuleComponent : Component
+{
+    /// <summary>
+    /// The players must wait this length of time before <see cref="DelayedComponents"/> gets added.
+    /// If they are somehow found out and get gibbed/cremated/etc before this delay is up they will not turn.
+    /// </summary>
+    [DataField(required: true)]
+    public TimeSpan Delay;
+
+    /// <summary>
+    /// Whether to skip the delay if there is only 1 antag selected.
+    /// </summary>
+    [DataField]
+    public bool IgnoreSolo;
+
+    /// <summary>
+    /// When the <see cref="Delay"/> will end.
+    /// </summary>
+    [DataField(customTypeSerializer: typeof(TimeOffsetSerializer)), AutoPausedField]
+    public TimeSpan DelayEnds;
+
+    /// <summary>
+    /// The components to add to each player's mob once the delay ends.
+    /// </summary>
+    [DataField(required: true)]
+    public ComponentRegistry DelayedComponents = new();
+
+    /// <summary>
+    /// Popup to show when the delay ends.
+    /// </summary>
+    [DataField(required: true)]
+    public LocId EndedPopup;
+}

Content.Server/DeltaV/GameTicking/Rules/DelayedRuleSystem.cs

@@ -0,0 +1,58 @@
+using Content.Server.Antag.Components;
+using Content.Server.GameTicking.Rules;
+using Content.Server.DeltaV.GameTicking.Rules.Components;
+using Content.Shared.GameTicking.Components;
+using Content.Shared.Mind;
+using Content.Shared.Popups;
+
+namespace Content.Server.DeltaV.GameTicking.Rules;
+
+public sealed class DelayedRuleSystem : GameRuleSystem<DelayedRuleComponent>
+{
+    [Dependency] private readonly SharedPopupSystem _popup = default!;
+
+    protected override void Started(EntityUid uid, DelayedRuleComponent component, GameRuleComponent gameRule, GameRuleStartedEvent args)
+    {
+        base.Started(uid, component, gameRule, args);
+
+        component.DelayEnds = Timing.CurTime + component.Delay;
+    }
+
+    protected override void ActiveTick(EntityUid uid, DelayedRuleComponent component, GameRuleComponent gameRule, float frameTime)
+    {
+        base.ActiveTick(uid, component, gameRule, frameTime);
+
+        CheckDelay((uid, component));
+    }
+
+    /// <summary>
+    /// Checks if the delay has ended.
+    /// </summary>
+    private void CheckDelay(Entity<DelayedRuleComponent> ent)
+    {
+        if (!TryComp<AntagSelectionComponent>(ent, out var selection))
+            return;
+
+        // skip the delay if it's just 1 player, theres no plan to ruin if you are the only one
+        var ends = ent.Comp.DelayEnds;
+        if (ent.Comp.IgnoreSolo && selection.SelectedMinds.Count < 2)
+            ends = Timing.CurTime;
+
+        if (Timing.CurTime < ends)
+            return;
+
+        var comps = ent.Comp.DelayedComponents;
+        foreach (var (mindId, _) in selection.SelectedMinds)
+        {
+            // using OriginalOwnedEntity as the player might have ghosted to try become an evil ghost antag
+            if (!TryComp<MindComponent>(mindId, out var mind) || !TryGetEntity(mind.OriginalOwnedEntity, out var mob))
+                continue;
+
+            var uid = mob.Value;
+            _popup.PopupEntity(Loc.GetString(ent.Comp.EndedPopup), uid, uid, PopupType.LargeCaution);
+            EntityManager.AddComponents(uid, comps);
+        }
+
+        RemCompDeferred<DelayedRuleComponent>(ent);
+    }
+}

Content.Server/DeltaV/Silicons/Borgs/BorgSwitchableTypeSystem.Lawset.cs

@@ -0,0 +1,33 @@
+using Content.Server.Silicons.Laws;
+using Content.Shared.Emag.Components;
+using Content.Shared.Emag.Systems;
+using Content.Shared.Silicons.Laws;
+using Content.Shared.Silicons.Laws.Components;
+using Robust.Shared.Prototypes;
+
+namespace Content.Server.Silicons.Borgs;
+
+/// <summary>
+/// Handles lawset patching when switching type.
+/// If a borg is made emagged it needs its emag laws carried over.
+/// </summary>
+public sealed partial class BorgSwitchableTypeSystem
+{
+    [Dependency] private readonly SiliconLawSystem _law = default!;
+
+    private void ConfigureLawset(EntityUid uid, ProtoId<SiliconLawsetPrototype> id)
+    {
+        var laws = _law.GetLawset(id);
+        _law.SetLaws(laws.Laws, uid);
+
+        // re-add law 0 and final law based on new lawset
+        if (CompOrNull<EmagSiliconLawComponent>(uid)?.OwnerName != null)
+        {
+            // raising the event manually to bypass re-emagging checks
+            var ev = new GotEmaggedEvent(uid); // user wont be used since OwnerName isnt null, safe to pass itself
+            RaiseLocalEvent(uid, ref ev);
+        }
+
+        // ion storms don't get mirrored because thats basically impossible to track
+    }
+}

Content.Server/Objectives/Systems/KillPersonConditionSystem.cs

@@ -38,14 +38,17 @@ private void OnGetProgress(EntityUid uid, KillPersonConditionComponent comp, ref
         args.Progress = GetProgress(target.Value, comp.RequireDead);
     }
 
-    private void OnPersonAssigned(EntityUid uid, PickRandomPersonComponent comp, ref ObjectiveAssignedEvent args)
+    private void OnPersonAssigned(Entity<PickRandomPersonComponent> ent, ref ObjectiveAssignedEvent args)
     {
-        AssignRandomTarget(uid, args, _ => true);
+        AssignRandomTarget(ent, args, _ => true);
     }
 
-    private void OnHeadAssigned(EntityUid uid, PickRandomHeadComponent comp, ref ObjectiveAssignedEvent args)
+    private void OnHeadAssigned(Entity<PickRandomHeadComponent> ent, ref ObjectiveAssignedEvent args)
     {
-        AssignRandomTarget(uid, args, mind => HasComp<CommandStaffComponent>(uid));
+        AssignRandomTarget(ent, args, mindId =>
+            TryComp<MindComponent>(mindId, out var mind) &&
+            mind.OwnedEntity is { } ownedEnt &&
+            HasComp<CommandStaffComponent>(ownedEnt));
     }
 
     private void AssignRandomTarget(EntityUid uid, ObjectiveAssignedEvent args, Predicate<EntityUid> filter, bool fallbackToAny = true)

Content.Server/Procedural/DungeonJob/DungeonJob.PostGenBiome.cs

@@ -1,6 +1,5 @@
 using System.Threading.Tasks;
 using Content.Server.Parallax;
-using Content.Shared.Maps;
 using Content.Shared.Parallax.Biomes;
 using Content.Shared.Procedural;
 using Content.Shared.Procedural.PostGeneration;
@@ -16,43 +15,35 @@ public sealed partial class DungeonJob
     /// </summary>
     private async Task PostGen(BiomeDunGen dunGen, DungeonData data, Dungeon dungeon, HashSet<Vector2i> reservedTiles, Random random)
     {
-        if (!_prototype.TryIndex(dunGen.BiomeTemplate, out var indexedBiome))
+        if (_entManager.TryGetComponent(_gridUid, out BiomeComponent? biomeComp))
             return;
 
+        biomeComp = _entManager.AddComponent<BiomeComponent>(_gridUid);
         var biomeSystem = _entManager.System<BiomeSystem>();
-
+        biomeSystem.SetTemplate(_gridUid, biomeComp, _prototype.Index(dunGen.BiomeTemplate));
         var seed = random.Next();
         var xformQuery = _entManager.GetEntityQuery<TransformComponent>();
 
-        var tiles = _maps.GetAllTilesEnumerator(_gridUid, _grid);
-        while (tiles.MoveNext(out var tileRef))
+        foreach (var node in dungeon.RoomTiles)
         {
-            var node = tileRef.Value.GridIndices;
-
             if (reservedTiles.Contains(node))
                 continue;
-
-            if (dunGen.TileMask is not null)
-            {
-                if (!dunGen.TileMask.Contains(((ContentTileDefinition) _tileDefManager[tileRef.Value.Tile.TypeId]).ID))
-                    continue;
-            }
 
             // Need to set per-tile to override data.
-            if (biomeSystem.TryGetTile(node, indexedBiome.Layers, seed, _grid, out var tile))
+            if (biomeSystem.TryGetTile(node, biomeComp.Layers, seed, _grid, out var tile))
             {
                 _maps.SetTile(_gridUid, _grid, node, tile.Value);
             }
 
-            if (biomeSystem.TryGetDecals(node, indexedBiome.Layers, seed, _grid, out var decals))
+            if (biomeSystem.TryGetDecals(node, biomeComp.Layers, seed, _grid, out var decals))
             {
                 foreach (var decal in decals)
                 {
                     _decals.TryAddDecal(decal.ID, new EntityCoordinates(_gridUid, decal.Position), out _);
                 }
             }
 
-            if (tile is not null && biomeSystem.TryGetEntity(node, indexedBiome.Layers, tile.Value, seed, _grid, out var entityProto))
+            if (biomeSystem.TryGetEntity(node, biomeComp, _grid, out var entityProto))
             {
                 var ent = _entManager.SpawnEntity(entityProto, new EntityCoordinates(_gridUid, node + _grid.TileSizeHalfVector));
                 var xform = xformQuery.Get(ent);
@@ -70,5 +61,7 @@ private async Task PostGen(BiomeDunGen dunGen, DungeonData data, Dungeon dungeon
             if (!ValidateResume())
                 return;
         }
+
+        biomeComp.Enabled = false;
     }
 }

Content.Server/Silicons/Borgs/BorgSwitchableTypeSystem.cs

@@ -11,7 +11,7 @@ namespace Content.Server.Silicons.Borgs;
 /// <summary>
 /// Server-side logic for borg type switching. Handles more heavyweight and server-specific switching logic.
 /// </summary>
-public sealed class BorgSwitchableTypeSystem : SharedBorgSwitchableTypeSystem
+public sealed partial class BorgSwitchableTypeSystem : SharedBorgSwitchableTypeSystem // DeltaV: Made partial
 {
     [Dependency] private readonly BorgSystem _borgSystem = default!;
     [Dependency] private readonly ServerInventorySystem _inventorySystem = default!;
@@ -59,6 +59,11 @@ protected override void SelectBorgModule(Entity<BorgSwitchableTypeComponent> ent
             }
         }
 
+        // Begin DeltaV Code: Custom lawset patching
+        if (prototype.Lawset is {} lawset)
+            ConfigureLawset(ent, lawset);
+        // End DeltaV Code
+
         // Configure special components
         if (Prototypes.TryIndex(ent.Comp.SelectedBorgType, out var previousPrototype))
         {

Content.Server/Silicons/Laws/SiliconLawSystem.cs

@@ -131,9 +131,10 @@ private void OnEmagLawsAdded(EntityUid uid, SiliconLawProviderComponent componen
             component.Lawset = GetLawset(component.Laws);
 
         // Add the first emag law before the others
+        var name = CompOrNull<EmagSiliconLawComponent>(uid)?.OwnerName ?? Name(args.UserUid); // DeltaV: Reuse emagger name if possible
         component.Lawset?.Laws.Insert(0, new SiliconLaw
         {
-            LawString = Loc.GetString("law-emag-custom", ("name", Name(args.UserUid)), ("title", Loc.GetString(component.Lawset.ObeysTo))),
+            LawString = Loc.GetString("law-emag-custom", ("name", name), ("title", Loc.GetString(component.Lawset.ObeysTo))), // DeltaV: pass name from variable
             Order = 0
         });
 

Content.Server/_CD/Engraving/EngraveableComponent.cs

@@ -0,0 +1,32 @@
+namespace Content.Server._CD.Engraving;
+
+/// <summary>
+///     Allows an items' description to be modified with an engraving
+/// </summary>
+[RegisterComponent, Access(typeof(EngraveableSystem))]
+public sealed partial class EngraveableComponent : Component
+{
+    /// <summary>
+    ///     Message given to user to notify them a message was sent
+    /// </summary>
+    [DataField]
+    public string EngravedMessage = string.Empty;
+
+    /// <summary>
+    ///     The inspect text to use when there is no engraving
+    /// </summary>
+    [DataField]
+    public LocId NoEngravingText = "engraving-dogtags-no-message";
+
+    /// <summary>
+    ///     The message to use when successfully engraving the item
+    /// </summary>
+    [DataField]
+    public LocId EngraveSuccessMessage = "engraving-dogtags-succeed";
+
+    /// <summary>
+    ///     The inspect text to use when there is an engraving. The message will be shown seperately afterwards.
+    /// </summary>
+    [DataField]
+    public LocId HasEngravingText = "engraving-dogtags-has-message";
+}