Upstream Sync (#44)

# Description

This would cause so many merge conflicts if we had so many PRs open..

# TODO

- [x] Animate the spine markings with the tailwag
- [x] Use our tailwag sprites
- [x] Fix longmeme_wagging sprite
- Finally use the states of wings (in another PR)

# Media


https://github.com/Simple-Station/Parkstation-Friendly-Chainsaw/assets/77995199/91793fc9-e91a-4777-8c74-7d1b6d47f7a1

.editorconfig

@@ -338,7 +338,10 @@ dotnet_naming_symbols.type_parameters_symbols.applicable_kinds = type_parameter
 resharper_braces_for_ifelse = required_for_multiline
 resharper_keep_existing_attribute_arrangement = true
 
-[*.{csproj,xml,yml,yaml,dll.config,msbuildproj,targets}]
+[*.{csproj,xml,yml,yaml,dll.config,msbuildproj,targets,props}]
+indent_size = 2
+
+[nuget.config]
 indent_size = 2
 
 [{*.yaml,*.yml}]

.github/workflows/publish.yml

@@ -14,7 +14,7 @@ jobs:
 
     steps:
     - name: Install dependencies
-      run: sudo apt-get install -y python3-paramiko
+      run: sudo apt-get install -y python3-paramiko python3-lxml
 
     - uses: actions/[email protected]
       with:

.vscode/launch.json

@@ -13,6 +13,15 @@
             "console": "internalConsole",
             "stopAtEntry": false
         },
+        {
+            "name": "Client (Compatibility renderer)",
+            "type": "coreclr",
+            "request": "launch",
+            "program": "${workspaceFolder}/bin/Content.Client/Content.Client.dll",
+            "args": "--cvar display.compat=true",
+            "console": "internalConsole",
+            "stopAtEntry": false
+        },
         {
             "name": "Server",
             "type": "coreclr",

Content.Benchmarks/Content.Benchmarks.csproj

@@ -11,7 +11,7 @@
     <LangVersion>12</LangVersion>
   </PropertyGroup>
   <ItemGroup>
-    <PackageReference Include="BenchmarkDotNet" Version="0.13.1" />
+    <PackageReference Include="BenchmarkDotNet" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\Content.Client\Content.Client.csproj" />

Content.Benchmarks/EntityManagerGetAllComponents.cs

@@ -48,6 +48,7 @@ public void Setup()
             var componentFactory = new Mock<IComponentFactory>();
             componentFactory.Setup(p => p.GetComponent<DummyComponent>()).Returns(new DummyComponent());
             componentFactory.Setup(p => p.GetRegistration(It.IsAny<DummyComponent>())).Returns(dummyReg);
+            componentFactory.Setup(p => p.GetAllRegistrations()).Returns(new[] { dummyReg });
             componentFactory.Setup(p => p.GetAllRefTypes()).Returns(new[] { CompIdx.Index<DummyComponent>() });
 
             IoCManager.RegisterInstance<IComponentFactory>(componentFactory.Object);

Content.Benchmarks/MapLoadBenchmark.cs

@@ -46,7 +46,7 @@ public async Task Cleanup()
         PoolManager.Shutdown();
     }
 
-    public static IEnumerable<string> MapsSource { get; set; }
+    public static readonly string[] MapsSource = { "Empty", "Box", "Aspid", "Bagel", "Dev", "CentComm", "Atlas", "Core", "TestTeg", "Saltern", "Packed", "Omega", "Cluster", "Gemini", "Reach", "Origin", "Meta", "Marathon", "Europa", "MeteorArena", "Fland", "Barratry" };
 
     [ParamsSource(nameof(MapsSource))]
     public string Map;

Content.Benchmarks/Program.cs

@@ -23,13 +23,6 @@ public static void Main(string[] args)
 
         public static async Task MainAsync(string[] args)
         {
-            PoolManager.Startup(typeof(Program).Assembly);
-            var pair = await PoolManager.GetServerClient();
-            var gameMaps = pair.Server.ResolveDependency<IPrototypeManager>().EnumeratePrototypes<GameMapPrototype>().ToList();
-            MapLoadBenchmark.MapsSource = gameMaps.Select(x => x.ID);
-            await pair.CleanReturnAsync();
-            PoolManager.Shutdown();
-
 #if DEBUG
             Console.ForegroundColor = ConsoleColor.Red;
             Console.WriteLine("\nWARNING: YOU ARE RUNNING A DEBUG BUILD, USE A RELEASE BUILD FOR AN ACCURATE BENCHMARK");

Content.Benchmarks/PvsBenchmark.cs

@@ -0,0 +1,187 @@
+#nullable enable
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using BenchmarkDotNet.Attributes;
+using Content.IntegrationTests;
+using Content.IntegrationTests.Pair;
+using Content.Server.Warps;
+using Robust.Server.GameObjects;
+using Robust.Shared;
+using Robust.Shared.Analyzers;
+using Robust.Shared.Enums;
+using Robust.Shared.GameObjects;
+using Robust.Shared.GameStates;
+using Robust.Shared.Map;
+using Robust.Shared.Network;
+using Robust.Shared.Player;
+using Robust.Shared.Random;
+
+namespace Content.Benchmarks;
+
+// This benchmark probably benefits from some accidental cache locality. I,e. the order in which entities in a pvs
+// chunk are sent to players matches the order in which the entities were spawned.
+//
+// in a real mid-late game round, this is probably no longer the case.
+// One way to somewhat offset this is to update the NetEntity assignment to assign random (but still unique) NetEntity uids to entities.
+// This makes the benchmark run noticeably slower.
+
+[Virtual]
+public class PvsBenchmark
+{
+    public const string Map = "Maps/box.yml";
+
+    [Params(1, 8, 80)]
+    public int PlayerCount { get; set; }
+
+    private TestPair _pair = default!;
+    private IEntityManager _entMan = default!;
+    private MapId _mapId = new(10);
+    private ICommonSession[] _players = default!;
+    private EntityCoordinates[] _spawns = default!;
+    public int _cycleOffset = 0;
+    private SharedTransformSystem _sys = default!;
+    private EntityCoordinates[] _locations = default!;
+
+    [GlobalSetup]
+    public void Setup()
+    {
+#if !DEBUG
+        ProgramShared.PathOffset = "../../../../";
+#endif
+        PoolManager.Startup(null);
+
+        _pair = PoolManager.GetServerClient().GetAwaiter().GetResult();
+        _entMan = _pair.Server.ResolveDependency<IEntityManager>();
+        _pair.Server.CfgMan.SetCVar(CVars.NetPVS, true);
+        _pair.Server.CfgMan.SetCVar(CVars.ThreadParallelCount, 0);
+        _pair.Server.CfgMan.SetCVar(CVars.NetPvsAsync, false);
+        _sys = _entMan.System<SharedTransformSystem>();
+
+        // Spawn the map
+        _pair.Server.ResolveDependency<IRobustRandom>().SetSeed(42);
+        _pair.Server.WaitPost(() =>
+        {
+            var success = _entMan.System<MapLoaderSystem>().TryLoad(_mapId, Map, out _);
+            if (!success)
+                throw new Exception("Map load failed");
+            _pair.Server.MapMan.DoMapInitialize(_mapId);
+        }).Wait();
+
+        // Get list of ghost warp positions
+        _spawns = _entMan.AllComponentsList<WarpPointComponent>()
+            .OrderBy(x => x.Component.Location)
+            .Select(x => _entMan.GetComponent<TransformComponent>(x.Uid).Coordinates)
+            .ToArray();
+
+        Array.Resize(ref _players, PlayerCount);
+
+        // Spawn "Players".
+        _pair.Server.WaitPost(() =>
+        {
+            for (var i = 0; i < PlayerCount; i++)
+            {
+                var pos = _spawns[i % _spawns.Length];
+                var uid =_entMan.SpawnEntity("MobHuman", pos);
+                _pair.Server.ConsoleHost.ExecuteCommand($"setoutfit {_entMan.GetNetEntity(uid)} CaptainGear");
+                _players[i] = new DummySession{AttachedEntity = uid};
+            }
+        }).Wait();
+
+        // Repeatedly move players around so that they "explore" the map and see lots of entities.
+        // This will populate their PVS data with out-of-view entities.
+        var rng = new Random(42);
+        ShufflePlayers(rng, 100);
+
+        _pair.Server.PvsTick(_players);
+        _pair.Server.PvsTick(_players);
+
+        var ents = _players.Select(x => x.AttachedEntity!.Value).ToArray();
+        _locations = ents.Select(x => _entMan.GetComponent<TransformComponent>(x).Coordinates).ToArray();
+    }
+
+    private void ShufflePlayers(Random rng, int count)
+    {
+        while (count > 0)
+        {
+            ShufflePlayers(rng);
+            count--;
+        }
+    }
+
+    private void ShufflePlayers(Random rng)
+    {
+        _pair.Server.PvsTick(_players);
+
+        var ents = _players.Select(x => x.AttachedEntity!.Value).ToArray();
+        var locations = ents.Select(x => _entMan.GetComponent<TransformComponent>(x).Coordinates).ToArray();
+
+        // Shuffle locations
+        var n = locations.Length;
+        while (n > 1)
+        {
+            n -= 1;
+            var k = rng.Next(n + 1);
+            (locations[k], locations[n]) = (locations[n], locations[k]);
+        }
+
+        _pair.Server.WaitPost(() =>
+        {
+            for (var i = 0; i < PlayerCount; i++)
+            {
+                _sys.SetCoordinates(ents[i], locations[i]);
+            }
+        }).Wait();
+
+        _pair.Server.PvsTick(_players);
+    }
+
+    /// <summary>
+    /// Basic benchmark for PVS in a static situation where nothing moves or gets dirtied..
+    /// This effectively provides a lower bound on "real" pvs tick time, as it is missing:
+    /// - PVS chunks getting dirtied and needing to be rebuilt
+    /// - Fetching component states for dirty components
+    /// - Compressing & sending network messages
+    /// - Sending PVS leave messages
+    /// </summary>
+    [Benchmark]
+    public void StaticTick()
+    {
+        _pair.Server.PvsTick(_players);
+    }
+
+    /// <summary>
+    /// Basic benchmark for PVS in a situation where players are teleporting all over the place. This isn't very
+    /// realistic, but unlike <see cref="StaticTick"/> this will actually also measure the speed of processing dirty
+    /// chunks and sending PVS leave messages.
+    /// </summary>
+    [Benchmark]
+    public void CycleTick()
+    {
+        _cycleOffset = (_cycleOffset + 1) % _players.Length;
+        _pair.Server.WaitPost(() =>
+        {
+            for (var i = 0; i < PlayerCount; i++)
+            {
+                _sys.SetCoordinates(_players[i].AttachedEntity!.Value, _locations[(i + _cycleOffset) % _players.Length]);
+            }
+        }).Wait();
+        _pair.Server.PvsTick(_players);
+    }
+
+    private sealed class DummySession : ICommonSession
+    {
+        public SessionStatus Status => SessionStatus.InGame;
+        public EntityUid? AttachedEntity {get; set; }
+        public NetUserId UserId => default;
+        public string Name => string.Empty;
+        public short Ping => default;
+        public INetChannel Channel { get; set; } = default!;
+        public LoginType AuthType => default;
+        public HashSet<EntityUid> ViewSubscriptions { get; } = new();
+        public DateTime ConnectedTime { get; set; }
+        public SessionState State => default!;
+        public SessionData Data => default!;
+        public bool ClientSide { get; set; }
+    }
+}

Content.Client/Administration/QuickDialogSystem.cs

@@ -6,6 +6,8 @@
 
 namespace Content.Client.Administration;
 
+// mfw they ported input() from BYOND
+
 /// <summary>
 /// This handles the client portion of quick dialogs.
 /// </summary>
@@ -32,39 +34,48 @@ private void OpenDialog(QuickDialogOpenEvent ev)
 
         var promptsDict = new Dictionary<string, LineEdit>();
 
-        foreach (var entry in ev.Prompts)
+        for (var index = 0; index < ev.Prompts.Count; index++)
         {
+            var entry = ev.Prompts[index];
             var entryBox = new BoxContainer()
             {
                 Orientation = BoxContainer.LayoutOrientation.Horizontal
             };
 
             entryBox.AddChild(new Label { Text = entry.Prompt, HorizontalExpand = true, SizeFlagsStretchRatio = 0.5f });
-            var edit = new LineEdit() { HorizontalExpand = true};
+            var edit = new LineEdit() { HorizontalExpand = true };
             entryBox.AddChild(edit);
             switch (entry.Type)
             {
                 case QuickDialogEntryType.Integer:
                     edit.IsValid += VerifyInt;
-                    edit.PlaceHolder = "Integer..";
+                    edit.PlaceHolder = Loc.GetString("quick-dialog-ui-integer");
                     break;
                 case QuickDialogEntryType.Float:
                     edit.IsValid += VerifyFloat;
-                    edit.PlaceHolder = "Float..";
+                    edit.PlaceHolder = Loc.GetString("quick-dialog-ui-float");
                     break;
                 case QuickDialogEntryType.ShortText:
                     edit.IsValid += VerifyShortText;
-                    edit.PlaceHolder = "Short text..";
+                    edit.PlaceHolder = Loc.GetString("quick-dialog-ui-short-text");
                     break;
                 case QuickDialogEntryType.LongText:
                     edit.IsValid += VerifyLongText;
-                    edit.PlaceHolder = "Long text..";
+                    edit.PlaceHolder = Loc.GetString("quick-dialog-ui-long-text");
                     break;
                 default:
                     throw new ArgumentOutOfRangeException();
             }
+
             promptsDict.Add(entry.FieldId, edit);
             entryContainer.AddChild(entryBox);
+
+            if (index == ev.Prompts.Count - 1)
+            {
+                // Last text box gets enter confirmation.
+                // Only the last so you don't accidentally confirm early.
+                edit.OnTextEntered += _ => Confirm();
+            }
         }
 
         var buttonsBox = new BoxContainer()
@@ -79,17 +90,10 @@ private void OpenDialog(QuickDialogOpenEvent ev)
         {
             var okButton = new Button()
             {
-                Text = "Ok",
+                Text = Loc.GetString("quick-dialog-ui-ok"),
             };
 
-            okButton.OnPressed += _ =>
-            {
-                RaiseNetworkEvent(new QuickDialogResponseEvent(ev.DialogId,
-                    promptsDict.Select(x => (x.Key, x.Value.Text)).ToDictionary(x => x.Key, x => x.Text),
-                    QuickDialogButtonFlag.OkButton));
-                alreadyReplied = true;
-                window.Close();
-            };
+            okButton.OnPressed += _ => Confirm();
 
             buttonsBox.AddChild(okButton);
         }
@@ -98,7 +102,7 @@ private void OpenDialog(QuickDialogOpenEvent ev)
         {
             var cancelButton = new Button()
             {
-                Text = "Cancel",
+                Text = Loc.GetString("quick-dialog-ui-cancel"),
             };
 
             cancelButton.OnPressed += _ =>
@@ -130,6 +134,17 @@ private void OpenDialog(QuickDialogOpenEvent ev)
         window.MinWidth *= 2; // Just double it.
 
         window.OpenCentered();
+
+        return;
+
+        void Confirm()
+        {
+            RaiseNetworkEvent(new QuickDialogResponseEvent(ev.DialogId,
+                promptsDict.Select(x => (x.Key, x.Value.Text)).ToDictionary(x => x.Key, x => x.Text),
+                QuickDialogButtonFlag.OkButton));
+            alreadyReplied = true;
+            window.Close();
+        }
     }
 
     private bool VerifyInt(string input)

Content.Client/Administration/UI/Bwoink/BwoinkControl.xaml

@@ -14,7 +14,7 @@
                     <Button Visible="False" Name="Kick" Text="{Loc 'admin-player-actions-kick'}" StyleClasses="OpenBoth" />
                     <Button Visible="False" Name="Ban" Text="{Loc 'admin-player-actions-ban'}" StyleClasses="OpenBoth" />
                     <Button Visible="False" Name="Respawn" Text="{Loc 'admin-player-actions-respawn'}" StyleClasses="OpenBoth" />
-                    <Button Visible="False" Name="Teleport" Text="{Loc 'admin-player-actions-teleport'}" StyleClasses="OpenLeft" />
+                    <Button Visible="False" Name="Follow" Text="{Loc 'admin-player-actions-follow'}" StyleClasses="OpenLeft" />
                 </BoxContainer>
             </BoxContainer>
         </SplitContainer>