CommandBuffers

RELEASE-NOTES.md

@@ -35,23 +35,57 @@ END TEMPLATE-->
 
 ### Breaking changes
 
-*None yet*
+- Engine has a new `ComponentFilter` type, which name conflicts with the one currently in content.
+  Content maintainers should apply [this patch](https://github.com/space-wizards/space-station-14/pull/43168).
+- `ComponentRegistry` no longer inherits directly from Dictionary, and only provides a subset of the dictionary API
+  that was necessary to get the Space Station 14 Wizard's Den content package compiling. All Dictionary methods are
+  additionally obsolete, and you should consult `ComponentRegistry`'s documentation and method list for replacements.
+- `IEntityLoadContext` has new required methods that take an `IComponentFactory`.
 
 ### New features
 
-*None yet*
+- Introduces `ComponentFilter`, a set of components that can be used with various filter methods on `IEntityManager`.
+  Please consult the documentation for the type, alongside `IEntityManager.Filters.cs`, for the full set of new features.
+- `ComponentRegistry` now provides an improved API that does not require users manually insert components into the
+  dictionary. Consult the documentation for the type for the full feature list.
+- `EntityQuery<TComp1>` now implements `IEnumerable<Entity<TComp1>>` and can be used with `foreach` performantly.
+- `EntityQuery<TComp1, TComp2>`, `EntityQuery<TComp1, TComp2, TComp3>`, and `EntityQuery<TComp1, TComp2, TComp3, TComp4>`
+  have been added and implement `IEnumerable`.
+  <br/><br/>
+  They're direct counterparts to `EntityQuery<TComp1>` with similar methods and constructors.
+  Additionally, like `EntityQuery<TComp1>`, all of these types can be resolved with a `[Dependency]` in systems.
+- `DynamicEntityQuery` has been added. It implements component queries for an unbounded set of components, with the
+  ability to mark the presence of specific components as optional (may be null) or excluded (query doesn't match
+  entities with that component).
+  <br/><br/>
+  It is currently primarily an implementation detail of `EntityQuery<>` but can be used directly and will lead to
+  expanded functionality in the future.
 
 ### Bugfixes
 
 *None yet*
 
 ### Other
 
-*None yet*
+- `void AddComponents(EntityUid target, EntityPrototype prototype, bool removeExisting = true)` and
+  `void RemoveComponents(EntityUid target, EntityPrototype prototype)` were marked obsolete and will be removed without
+  replacement. Using EntityPrototype as a filter and registry is not supported. Additionally,
+  the former API has never functioned correctly with `removeExisting: true` and that functionality is not supported.
+- `void RemoveComponents(EntityUid target, ComponentRegistry registry)` is now obsolete and a ComponentFilter solution
+  should be used instead.
+- `CompRegistryEntityEnumerator` is now obsolete in favor of `ComponentFilterQuery`.
+- `EntityQueryEnumerator<TComp1>`, `EntityQueryEnumerator<TComp1, TComp2>`, `EntityQueryEnumerator<TComp1, TComp2, TComp3>`,
+  `EntityQueryEnumerator<TComp1, TComp2, TComp3, TComp4>`, `AllEntityQueryEnumerator<TComp1>`, `AllEntityQueryEnumerator<TComp1, TComp2>`,
+  `AllEntityQueryEnumerator<TComp1, TComp2, TComp3>`, `AllEntityQueryEnumerator<TComp1, TComp2, TComp3, TComp4>`,
+  and `ComponentQueryEnumerator` are now obsolete.
+- The EntityManager methods `EntityQuery<TComp1>`, `EntityQuery<TComp1, TComp2>`, `EntityQuery<TComp1, TComp2, TComp3>`,
+  and `EntityQuery<TComp1, TComp2, TComp3, TComp4>`, `EntityQueryEnumerator`, `AllEntityQueryEnumerator`,
+  `ComponentQueryEnumerator`, `AllComponentsList`, `AllEntityUids`, `AllEntityUids`, `AllEntities`, and `AllComponents`
+  are now obsolete.
 
 ### Internal
 
-*None yet*
+- `ComponentRegistry`-dependant surfaces in the engine have been rewritten to use the new methods wherever possible.
 
 
 ## 274.0.1

Robust.Client/ClientIoC.cs

@@ -70,6 +70,7 @@ public static void RegisterIoC(GameController.DisplayMode mode, IDependencyColle
             deps.Register<IMapManagerInternal, NetworkedMapManager>();
             deps.Register<INetworkedMapManager, NetworkedMapManager>();
             deps.Register<IEntityManager, ClientEntityManager>();
+            deps.Register<IRemoteEntityManager, ClientEntityManager>();
             deps.Register<FontTagHijackHolder>();
             deps.Register<IReflectionManager, ClientReflectionManager>();
             deps.Register<IConsoleHost, ClientConsoleHost>();

Robust.Client/GameObjects/ClientEntityManager.Network.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Threading;
 using Robust.Shared.GameObjects;
 using Robust.Shared.Map;
 using Robust.Shared.Utility;
@@ -8,7 +9,7 @@ namespace Robust.Client.GameObjects;
 
 public sealed partial class ClientEntityManager
 {
-    protected override NetEntity GenerateNetEntity() => new(NextNetworkId++ | NetEntity.ClientEntity);
+    protected override NetEntity GenerateNetEntity() => new(Interlocked.Increment(ref NextNetworkId) | NetEntity.ClientEntity);
 
     /// <summary>
     /// If the client fails to resolve a NetEntity then during component state handling or the likes we

Robust.Client/GameObjects/Components/Renderable/SpriteComponent.cs

@@ -243,12 +243,13 @@ public ShaderInstance? PostShader
         public ISpriteLayer this[object layerKey] => this[LayerMap[layerKey]];
         public IEnumerable<ISpriteLayer> AllLayers => Layers;
 
-        void ISerializationHooks.AfterDeserialization()
+        void ISerializationHooks.AfterDeserialization(IDependencyCollection collection)
         {
             // Please somebody burn this to the ground. There is so much spaghetti.
             // Why has no one answered my prayers.
+            // Workin' on it --kaylie.
 
-            IoCManager.InjectDependencies(this);
+            collection.InjectDependencies(this);
             if (!string.IsNullOrWhiteSpace(rsi))
             {
                 var rsiPath = TextureRoot / rsi;

Robust.Client/GameObjects/EntitySystems/SpriteSystem.Component.cs

@@ -1,13 +1,17 @@
 using System;
 using System.Collections.Generic;
 using Robust.Shared.GameObjects;
+using Robust.Shared.IoC;
 using Robust.Shared.Maths;
+using Robust.Shared.Serialization.Manager;
 using Robust.Shared.Utility;
 
 namespace Robust.Client.GameObjects;
 
 public sealed partial class SpriteSystem
 {
+    [Dependency] private readonly ISerializationManager _serMan = default!;
+
     /// <summary>
     /// Resets the sprite's animated layers to align with a given time (in seconds).
     /// </summary>
@@ -54,6 +58,15 @@ public void CopySprite(Entity<SpriteComponent?> source, Entity<SpriteComponent?>
         if (!Resolve(target.Owner, ref target.Comp))
             return;
 
+        // Some code in content decided it'd be cool to copy from uninitialized SpriteComponents.
+        // Because this no longer works, we copy some extra data to ensure it does anyway.
+        if (source.Comp.LifeStage == ComponentLifeStage.PreAdd)
+        {
+            Log.Info($"Hit a bodge case in CopySprite, please change your usage to use ISerializationManager.CopyTo instead: {Environment.StackTrace}");
+            _serMan.CopyTo<SpriteComponent>(source.Comp, ref target.Comp, notNullableOverride: true);
+            return;
+        }
+
         target.Comp._baseRsi = source.Comp._baseRsi;
         target.Comp._bounds = source.Comp._bounds;
         target.Comp._visible = source.Comp._visible;

Robust.Client/Graphics/Shaders/ShaderPrototype.cs

@@ -107,8 +107,9 @@ public ShaderInstance InstanceUnique()
         [DataField("blend_mode")]
         private string? _rawBlendMode;
 
-        void ISerializationHooks.AfterDeserialization()
+        void ISerializationHooks.AfterDeserialization(IDependencyCollection collection)
         {
+            // TODO: This isn't threadsafe and can't be! WGPU when.
             switch (_rawKind)
             {
                 case "source":
@@ -118,7 +119,7 @@ void ISerializationHooks.AfterDeserialization()
                     if (_path == null)
                         throw new InvalidOperationException("Source shaders must specify a source file.");
 
-                    _source = IoCManager.Resolve<IResourceCache>().GetResource<ShaderSourceResource>(_path.Value);
+                    _source = collection.Resolve<IResourceCache>().GetResource<ShaderSourceResource>(_path.Value);
 
                     if (_paramMapping != null)
                     {
@@ -140,7 +141,7 @@ void ISerializationHooks.AfterDeserialization()
 
                 case "canvas":
                     Kind = ShaderKind.Canvas;
-                    _source = IoCManager.Resolve<IResourceCache>().GetResource<ShaderSourceResource>("/Shaders/Internal/default-sprite.swsl");
+                    _source = collection.Resolve<IResourceCache>().GetResource<ShaderSourceResource>("/Shaders/Internal/default-sprite.swsl");
                     break;
 
                 default:

Robust.Server.IntegrationTests/GameObjects/ThrowingEntityDeletion_Test.cs

@@ -48,7 +48,10 @@ public void Test(string prototypeName)
             _sim.Resolve<IEntityManager>().System<SharedMapSystem>().CreateMap(out var map);
 
             Assert.That(() => entMan.SpawnEntity(prototypeName, new MapCoordinates(0, 0, map)),
-                Throws.TypeOf<EntityCreationException>());
+                // Throws an aggregate containing only creation exceptions.
+                Throws.TypeOf<AggregateException>()
+                    .And.Property("InnerExceptions")
+                    .All.TypeOf<EntityCreationException2>());
 
             Assert.That(entMan.GetEntities().Where(p => entMan.GetComponent<MetaDataComponent>(p).EntityPrototype?.ID == prototypeName), Is.Empty);
         }

Robust.Server.Testing/RobustServerSimulation.cs

@@ -246,6 +246,7 @@ public ISimulation InitializeInstance()
             //Tier 2: Simulation
             container.RegisterInstance<IConsoleHost>(new Mock<IConsoleHost>().Object); //Console is technically a frontend, we want to run headless
             container.Register<IEntityManager, ServerEntityManager>();
+            container.Register<IRemoteEntityManager, ServerEntityManager>();
             container.Register<IServerEntityNetworkManager, ServerEntityManager>();
             container.Register<EntityManager, ServerEntityManager>();
             container.Register<IMapManager, NetworkedMapManager>();

Robust.Server/GameObjects/ServerEntityManager.cs

@@ -13,6 +13,8 @@
 using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
 using Robust.Shared.Log;
+using Robust.Shared.Map;
+using Robust.Shared.Maths;
 using Robust.Shared.Network;
 using Robust.Shared.Network.Messages;
 using Robust.Shared.Player;
@@ -136,6 +138,58 @@ internal override void SetLifeStage(MetaDataComponent meta, EntityLifeStage stag
 
         public override IEntityNetworkManager EntityNetManager => this;
 
+        public override EntityUid Spawn(
+            string? protoName,
+            MapCoordinates coordinates,
+            ComponentRegistry? overrides = null,
+            Angle rotation = default)
+        {
+            // Start building the entity as described...
+            var builder = EntityBuilder(protoName)
+                .LocatedAt(coordinates, rotation);
+
+            // If we got overrides, apply them here.
+            if (overrides is not null)
+                builder.ApplyRegistry(overrides);
+
+            // Spawn it into the simulation and return the id.
+            return Spawn(builder);
+        }
+
+        public override EntityUid SpawnAttachedTo(
+            string? protoName,
+            EntityCoordinates coordinates,
+            ComponentRegistry? overrides = null,
+            Angle rotation = default)
+        {
+            if (!coordinates.IsValid(this))
+                throw new InvalidOperationException($"Tried to spawn entity {protoName} on invalid coordinates {coordinates}.");
+
+            // Start building the entity as described...
+            var builder = EntityBuilder(protoName)
+                .ChildOf(coordinates, rotation);
+
+            // If we got overrides, apply them here.
+            if (overrides is not null)
+                builder.ApplyRegistry(overrides);
+
+            // Spawn it into the simulation and return the id.
+            return Spawn(builder);
+        }
+
+        public override EntityUid Spawn(string? protoName = null, ComponentRegistry? overrides = null, bool doMapInit = true)
+        {
+            // Start building the entity as described...
+            var builder = EntityBuilder(protoName);
+
+            // If we got overrides, apply them here.
+            if (overrides is not null)
+                builder.ApplyRegistry(overrides);
+
+            // Spawn it into the simulation and return the id.
+            return Spawn(builder, doMapInit);
+        }
+
         /// <inheritdoc />
         public event EventHandler<object>? ReceivedSystemMessage;
 

Robust.Server/ServerIoC.cs

@@ -60,6 +60,7 @@ internal static void RegisterIoC(IDependencyCollection deps)
             deps.Register<IMapManagerInternal, NetworkedMapManager>();
             deps.Register<INetworkedMapManager, NetworkedMapManager>();
             deps.Register<IEntityManager, ServerEntityManager>();
+            deps.Register<IRemoteEntityManager, ServerEntityManager>();
             deps.Register<IEntityNetworkManager, ServerEntityManager>();
             deps.Register<IServerEntityNetworkManager, ServerEntityManager>();
             deps.Register<IPlacementManager, PlacementManager>();

Robust.Shared.IntegrationTests/EntitySerialization/LifestageSerializationTest.cs

@@ -57,7 +57,7 @@ void AssertPaused(bool expected, params EntityUid[] uids)
         {
             foreach (var uid in uids)
             {
-                Assert.That(entMan.GetComponent<MetaDataComponent>(uid).EntityPaused, Is.EqualTo(expected));
+                Assert.That(entMan.GetComponent<MetaDataComponent>(uid).EntityPaused, Is.EqualTo(expected), $"Entity {entMan.ToPrettyString(uid)} was not paused.");
             }
         }
 

Robust.Shared.IntegrationTests/GameObjects/CommandBuffers/CommandConstructionTests.cs

@@ -0,0 +1,42 @@
+using NUnit.Framework;
+using Robust.Shared.GameObjects;
+using Robust.Shared.GameObjects.CommandBuffers;
+
+namespace Robust.UnitTesting.Shared.GameObjects.CommandBuffers;
+
+public sealed class CommandConstructionTests
+{
+    [Test]
+    public void ConstructQueuedActionT()
+    {
+        CommandBufferEntry.QueuedActionT(ctx =>
+            {
+                Assert.That(ctx, NUnit.Framework.Is.Not.Null);
+                Assert.Pass();
+            },
+            this,
+            out var entry);
+
+        entry.InvokeQueuedActionT();
+
+        Assert.Fail("Invocation did nothing?");
+    }
+
+    [Test]
+    public void ConstructQueuedActionTEnt()
+    {
+        CommandBufferEntry.QueuedActionTEnt(static (ctx, ent) =>
+            {
+                Assert.That(ctx, NUnit.Framework.Is.Not.Null);
+                Assert.That(ent, NUnit.Framework.Is.EqualTo(EntityUid.FirstUid));
+                Assert.Pass();
+            },
+            this,
+            EntityUid.FirstUid,
+            out var entry);
+
+        entry.InvokeQueuedActionTEnt();
+
+        Assert.Fail("Invocation did nothing?");
+    }
+}

Robust.Shared.IntegrationTests/GameObjects/EntityBuilder/ClientEntityBuilderTests.cs

@@ -0,0 +1,41 @@
+using NUnit.Framework;
+using Robust.Client.GameObjects;
+using Robust.Shared.GameObjects;
+using Robust.Shared.IoC;
+using Robust.Shared.Serialization.Manager;
+
+namespace Robust.UnitTesting.Shared.GameObjects.EntityBuilder;
+
+internal sealed class ClientEntityBuilderTests : OurRobustUnitTest
+{
+    private IEntityManager _entMan = default!;
+
+    public override UnitTestProject Project => UnitTestProject.Client;
+
+    [OneTimeSetUp]
+    public void Setup()
+    {
+        IoCManager.Resolve<ISerializationManager>().Initialize();
+
+        _entMan = IoCManager.Resolve<IEntityManager>();
+    }
+
+    [Test]
+    [Description("Ensure that adding SpriteComponent to a builder doesn't immediately explode.")]
+    public void CreateWithSprite()
+    {
+        Robust.Shared.GameObjects.EntityBuilders.EntityBuilder b = null!;
+        // NUnit [RequiresThread] is old and crusty and doesn't work for us.
+        // So we need to isolate IoC this way instead.
+        var t = new Thread(() =>
+        {
+            b = _entMan.EntityBuilder()
+                .AddComp<SpriteComponent>();
+        });
+
+        t.Start();
+        t.Join();
+
+        _entMan.Spawn(b);
+    }
+}