Merge remote-tracking branch 'upstream/master'

.editorconfig

@@ -9,7 +9,7 @@ indent_style = space
 tab_width = 4
 
 # New line preferences
-#end_of_line = crlf
+end_of_line = crlf:suggestion
 insert_final_newline = true
 trim_trailing_whitespace = true
 
@@ -104,6 +104,7 @@ csharp_preferred_modifier_order = public, private, protected, internal, new, abs
 
 # 'using' directive preferences
 csharp_using_directive_placement = outside_namespace:silent
+csharp_style_namespace_declarations = file_scoped:suggestion
 
 #### C# Formatting Rules ####
 
@@ -338,7 +339,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}]

.envrc

@@ -1,4 +1,4 @@
-if ! has nix_direnv_version || ! nix_direnv_version 2.3.0; then
-    source_url "https://raw.githubusercontent.com/nix-community/nix-direnv/2.3.0/direnvrc" "sha256-Dmd+j63L84wuzgyjITIfSxSD57Tx7v51DMxVZOsiUD8="
+if ! has nix_direnv_version || ! nix_direnv_version 3.0.4; then
+    source_url "https://raw.githubusercontent.com/nix-community/nix-direnv/3.0.4/direnvrc" "sha256-DzlYZ33mWF/Gs8DDeyjr8mnVmQGx7ASYqA5WlxwvBG4="
 fi
 use flake

.github/workflows/check-crlf.yml

@@ -0,0 +1,15 @@
+name: CRLF Check
+
+on:
+  pull_request:
+    types: [ opened, reopened, synchronize, ready_for_review ]
+
+jobs:
+  build:
+    name: CRLF Check
+    if: github.event.pull_request.draft == false
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/[email protected]
+    - name: Check for CRLF
+      run: Tools/check_crlf.py

.github/workflows/close-master-pr.yml

@@ -0,0 +1,27 @@
+name: Close PRs on master
+
+on:
+  pull_request_target:
+    types: [ opened, ready_for_review ]
+
+jobs:
+  run:
+    runs-on: ubuntu-latest
+    if: ${{github.head_ref == 'master' || github.head_ref == 'main' || github.head_ref == 'develop'}}
+
+    steps:    
+    - uses: superbrothers/close-pull-request@v3
+      with:
+        comment: "Thank you for contributing to the Space Station 14 repository. Unfortunately, it looks like you submitted your pull request from the master branch. We suggest you follow [our git usage documentation](https://docs.spacestation14.com/en/general-development/setup/git-for-the-ss14-developer.html) \n\n You can move your current work from the master branch to another branch by doing `git branch <branch_name` and resetting the master branch."
+
+    # If you prefer to just comment on the pr and not close it, uncomment the bellow and comment the above
+
+    # - uses: actions/github-script@v7
+    #   with:
+    #     script: |
+    #       github.rest.issues.createComment({
+    #         issue_number: ${{ github.event.number }},
+    #         owner: context.repo.owner,
+    #         repo: context.repo.repo,
+    #         body: "Thank you for contributing to the Space Station 14 repository. Unfortunately, it looks like you submitted your pull request from the master branch. We suggest you follow [our git usage documentation](https://docs.spacestation14.com/en/general-development/setup/git-for-the-ss14-developer.html) \n\n You can move your current work from the master branch to another branch by doing `git branch <branch_name` and resetting the master branch. \n\n This pr won't be automatically closed. However, a maintainer may close it for this reason."
+    #       })

.github/workflows/labeler-untriaged.yml

@@ -0,0 +1,13 @@
+name: "Labels: Untriaged"
+
+on:
+  issues:
+    types: [opened]
+
+jobs:
+  add_label:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions-ecosystem/action-add-labels@v1
+      with:
+        labels: "Status: Untriaged"

.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:

.run/Content Server+Client.run.xml

@@ -1,4 +1,4 @@
-<component name="ProjectRunConfigurationManager">
+<component name="ProjectRunConfigurationManager">
   <configuration default="false" name="Content Server+Client" type="CompoundRunConfigurationType">
     <toRun name="Content.Client" type="DotNetProject" />
     <toRun name="Content.Server" type="DotNetProject" />

.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/ColorInterpolateBenchmark.cs

@@ -131,8 +131,8 @@ public static Color InterpolateSysVector4(Color a, Color b,
         public static Color InterpolateSysVector4In(in Color endPoint1, in Color endPoint2,
             float lambda)
         {
-            ref var sva = ref Unsafe.As<Color, SysVector4>(ref Unsafe.AsRef(endPoint1));
-            ref var svb = ref Unsafe.As<Color, SysVector4>(ref Unsafe.AsRef(endPoint2));
+            ref var sva = ref Unsafe.As<Color, SysVector4>(ref Unsafe.AsRef(in endPoint1));
+            ref var svb = ref Unsafe.As<Color, SysVector4>(ref Unsafe.AsRef(in endPoint2));
 
             var res = SysVector4.Lerp(svb, sva, lambda);
 
@@ -156,8 +156,8 @@ public static Color InterpolateSimd(Color a, Color b,
         public static Color InterpolateSimdIn(in Color a, in Color b,
             float lambda)
         {
-            var vecA = Unsafe.As<Color, Vector128<float>>(ref Unsafe.AsRef(a));
-            var vecB = Unsafe.As<Color, Vector128<float>>(ref Unsafe.AsRef(b));
+            var vecA = Unsafe.As<Color, Vector128<float>>(ref Unsafe.AsRef(in a));
+            var vecB = Unsafe.As<Color, Vector128<float>>(ref Unsafe.AsRef(in b));
 
             vecB = Fma.MultiplyAdd(Sse.Subtract(vecB, vecA), Vector128.Create(lambda), vecA);
 

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/DeviceNetworkingBenchmark.cs

@@ -4,8 +4,8 @@
 using Content.IntegrationTests;
 using Content.IntegrationTests.Pair;
 using Content.IntegrationTests.Tests.DeviceNetwork;
-using Content.Server.DeviceNetwork;
 using Content.Server.DeviceNetwork.Systems;
+using Content.Shared.DeviceNetwork;
 using Robust.Shared;
 using Robust.Shared.Analyzers;
 using Robust.Shared.GameObjects;

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", "Bagel", "Dev", "CentComm", "Atlas", "Core", "TestTeg", "Saltern", "Packed", "Omega", "Cluster", "Reach", "Origin", "Meta", "Marathon", "Europa", "MeteorArena", "Fland", "Barratry" };
 
     [ParamsSource(nameof(MapsSource))]
     public string Map;

Content.Benchmarks/Program.cs

@@ -18,18 +18,6 @@ internal static class Program
 
         public static void Main(string[] args)
         {
-            MainAsync(args).GetAwaiter().GetResult();
-        }
-
-        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.Benchmarks/SpawnEquipDeleteBenchmark.cs

@@ -58,7 +58,7 @@ await _pair.Server.WaitPost(() =>
             for (var i = 0; i < N; i++)
             {
                 _entity = server.EntMan.SpawnAttachedTo(Mob, _coords);
-                _spawnSys.EquipStartingGear(_entity, _gear, null);
+                _spawnSys.EquipStartingGear(_entity, _gear);
                 server.EntMan.DeleteEntity(_entity);
             }
         });