refactor: collision system split wit debugging

src/Apps/GameDesktop/CompositionRoots/Features/MovementFeatureCompositionRoot.cs

@@ -12,6 +12,11 @@ namespace GameDesktop.CompositionRoots.Features;
 
 internal class MovementFeatureCompositionRoot : ICompositionRoot
 {
+    private static readonly IMatcher<GameEntity>[] CollisionMatchers =
+    {
+        GameMatcher.RectangleCollision, GameMatcher.Transform
+    };
+
     private static readonly IMatcher<GameEntity>[] MovableMatchers = { GameMatcher.Transform, GameMatcher.Movable };
 
     private static readonly IMatcher<GameEntity>[] AnimatedMovableMatchers =
@@ -31,6 +36,16 @@ private static void RegisterImpl(IServiceRegistry serviceRegistry) =>
 
     private static void RegisterSystems(IServiceRegistry serviceRegistry)
     {
+        serviceRegistry.RegisterSingleton(factory =>
+        {
+            var getGroup = factory.GetInstance<Func<IMatcher<GameEntity>[], IGroup<GameEntity>>>(Matcher.AllOf);
+            IGroup<GameEntity> group = getGroup(CollisionMatchers);
+
+            var logger = factory.GetInstance<ILogger>();
+
+            return new CollisionSystem(group, logger);
+        });
+
         serviceRegistry.RegisterSingleton(factory =>
         {
             var movement = factory.GetInstance<IMovement>();

src/Libs/Features/Features.csproj

@@ -17,8 +17,4 @@
       <PackageReference Include="LightInject" Version="6.6.4" />
     </ItemGroup>
 
-    <ItemGroup>
-      <Folder Include="Debug\" />
-    </ItemGroup>
-
 </Project>

src/Libs/Features/MovementFeature.cs

@@ -4,9 +4,12 @@ namespace Features;
 
 public sealed class MovementFeature : Entitas.Extended.Feature
 {
-    public MovementFeature(MovementSystem movementSystem,
+    public MovementFeature(
+        CollisionSystem collisionSystem,
+        MovementSystem movementSystem,
         AnimatedMovementSystem animatedMovementSystem)
     {
+        Add(collisionSystem);
         Add(movementSystem);
         Add(animatedMovementSystem);
     }

src/Libs/Systems.Debugging/DrawRectangleCollisionComponentsSystem.cs

@@ -20,58 +20,31 @@ public DrawRectangleCollisionComponentsSystem(Contexts contexts, IGroup<GameEnti
     }
 
     // TODO: Move the logic in the release features
-    // TODO: Make sloped collision
+    // TODO: Pivot & anchors system
+    // TODO: Make circle colliders & relative system (sloped collision)
     public void Draw(GameTime gameTime, SpriteBatch spriteBatch)
     {
-        GameEntity[] entities = _group.GetEntities().OrderBy(x => x.transform.Position.Y).ToArray();
+        GameEntity[] entities = _group.GetEntities();
 
         spriteBatch.Begin(samplerState: SamplerState.PointClamp);
 
-        // temp start
         Color[] colors = { Color.Black, Color.White };
         int k = 0;
-        // temp end
 
-        for (int i = 0; i < entities.Length; ++i)
+        foreach (GameEntity e in entities)
         {
-            GameEntity first = entities[i];
-
-            for (int j = i + 1; j < entities.Length; ++j)
-            {
-                GameEntity second = entities[j];
-                if (AreIntersecting(first, second))
-                {
-                    first.transform.Velocity = Vector2.Zero;
-                    second.transform.Velocity = Vector2.Zero;
-                }
-            }
-
-            // temp start
             var texture = new Texture2D(spriteBatch.GraphicsDevice, 1, 1);
             texture.SetData(new[] { colors[k] });
+
             ++k;
-            if (k is 2)
+            if (k == colors.Length)
                 k = 0;
-            // temp end
 
-            spriteBatch.Draw(texture, first.transform.Position, sourceRectangle: first.rectangleCollision.Size,
+            spriteBatch.Draw(texture, e.transform.Position, sourceRectangle: e.rectangleCollision.Size,
                 Color.White);
         }
 
         spriteBatch.End();
     }
 
-    private bool AreIntersecting(GameEntity first, GameEntity second)
-    {
-        Func<GameEntity, Rectangle> buildRectangle = new(x =>
-            new((int)(x.transform.Position.X + x.transform.Velocity.X),
-                (int)(x.transform.Position.Y + x.transform.Velocity.Y),
-                x.rectangleCollision.Size.Width,
-                x.rectangleCollision.Size.Height));
-
-        Rectangle firstRectangle = buildRectangle(first);
-        Rectangle secondRectangle = buildRectangle(second);
-
-        return Rectangle.Intersect(firstRectangle, secondRectangle).IsEmpty is false;
-    }
 }

src/Libs/Systems/CollisionSystem.cs

@@ -0,0 +1,54 @@
+using Entitas;
+using Entitas.Extended;
+using Microsoft.Xna.Framework;
+using Serilog;
+
+namespace Systems;
+
+public class CollisionSystem : IFixedExecuteSystem
+{
+    private readonly IGroup<GameEntity> _group;
+    private readonly ILogger _logger;
+
+    public CollisionSystem(IGroup<GameEntity> group, ILogger logger)
+    {
+        _group = group;
+        _logger = logger;
+    }
+
+    // TODO: Optimize efficiency
+    public void FixedExecute(GameTime gameTime)
+    {
+        GameEntity[] entities = _group.GetEntities();
+
+        for (int i = 0; i < entities.Length; ++i)
+        {
+            GameEntity first = entities[i];
+
+            for (int j = i + 1; j < entities.Length; ++j)
+            {
+                GameEntity second = entities[j];
+
+                if (AreIntersecting(first, second))
+                {
+                    first.transform.Velocity = Vector2.Zero;
+                    second.transform.Velocity = Vector2.Zero;
+                }
+            }
+        }
+    }
+
+    private static bool AreIntersecting(GameEntity first, GameEntity second)
+    {
+        Rectangle firstRectangle = BuildRectangle(first);
+        Rectangle secondRectangle = BuildRectangle(second);
+
+        Rectangle intersect = Rectangle.Intersect(firstRectangle, secondRectangle);
+
+        return !intersect.IsEmpty;
+
+        Rectangle BuildRectangle(GameEntity x) => new((int)(x.transform.Position.X + x.transform.Velocity.X),
+            (int)(x.transform.Position.Y + x.transform.Velocity.Y), x.rectangleCollision.Size.Width,
+            x.rectangleCollision.Size.Height);
+    }
+}