Remove obsolete project files for MrGameEng.AI, MrGameEng.Assets, MrGameEng.Atlases, and MrGameEng.Collisions modules. Introduce new AssetManager and related classes for asset loading and management, including support for texture atlases and mod definitions. Enhance mod loading capabilities with DefDatabase and LanguageManager for JSON-based definitions and localization. Implement a shelf packing algorithm for efficient texture atlas creation.

2026-06-12 07:47:04 +03:00
parent 1f87fb0b74
commit c30e2ce764
70 changed files with 0 additions and 233 deletions
@@ -0,0 +1,101 @@
+using Microsoft.Xna.Framework;
+using Xunit;
+
+namespace MrGameEng.Pathfinding.Tests;
+
+public class FlowFieldTests
+{
+    [Fact]
+    public void Build_DistancesGrowFromGoal_DirectionsDescend()
+    {
+        var grid = new TestGrid(".....", ".###.", ".....");
+        var builder = new FlowFieldBuilder(grid);
+        var field = new FlowField();
+
+        builder.Build([new Point(0, 0)], field);
+
+        Assert.Equal(0f, field.DistanceAt(0, 0));
+        Assert.True(field.DistanceAt(4, 2) > field.DistanceAt(1, 0));
+
+        // Из любой достижимой не-целевой клетки направление ведёт к клетке с меньшей дистанцией.
+        for (var y = 0; y < grid.Height; y++)
+        {
+            for (var x = 0; x < grid.Width; x++)
+            {
+                if (
+                    !grid.IsPassable(x, y)
+                    || !field.IsReachable(x, y)
+                    || field.DistanceAt(x, y) == 0f
+                )
+                {
+                    continue;
+                }
+
+                var direction = field.DirectionAt(x, y);
+                Assert.NotEqual(Vector2.Zero, direction);
+                var nx = x + Math.Sign(MathF.Round(direction.X * 10f));
+                var ny = y + Math.Sign(MathF.Round(direction.Y * 10f));
+                Assert.True(
+                    field.DistanceAt(nx, ny) < field.DistanceAt(x, y),
+                    $"direction at ({x},{y}) does not descend"
+                );
+            }
+        }
+    }
+
+    [Fact]
+    public void Build_UnreachablePocket_IsFlagged()
+    {
+        var grid = new TestGrid("..#..", "..#..", "..#..");
+        var builder = new FlowFieldBuilder(grid);
+        var field = new FlowField();
+
+        builder.Build([new Point(0, 1)], field);
+
+        Assert.False(field.IsReachable(4, 1));
+        Assert.Equal(Vector2.Zero, field.DirectionAt(4, 1));
+        Assert.True(field.IsReachable(1, 2));
+    }
+
+    [Fact]
+    public void Build_MultipleGoals_EachCellFlowsToNearest()
+    {
+        var grid = new TestGrid("..........");
+        var builder = new FlowFieldBuilder(grid);
+        var field = new FlowField();
+
+        builder.Build([new Point(0, 0), new Point(9, 0)], field);
+
+        Assert.True(field.DirectionAt(2, 0).X < 0f); // ближе к левой цели
+        Assert.True(field.DirectionAt(7, 0).X > 0f); // ближе к правой
+        Assert.Equal(0f, field.DistanceAt(9, 0));
+    }
+
+    [Fact]
+    public void Build_Rebuild_OverwritesPreviousField()
+    {
+        var grid = new TestGrid(".....");
+        var builder = new FlowFieldBuilder(grid);
+        var field = new FlowField();
+
+        builder.Build([new Point(0, 0)], field);
+        Assert.True(field.DirectionAt(4, 0).X < 0f);
+
+        builder.Build([new Point(4, 0)], field);
+        Assert.True(field.DirectionAt(0, 0).X > 0f);
+        Assert.Equal(0f, field.DistanceAt(4, 0));
+    }
+
+    [Fact]
+    public void Build_NoValidGoals_EverythingUnreachable()
+    {
+        var grid = new TestGrid(".#.");
+        var builder = new FlowFieldBuilder(grid);
+        var field = new FlowField();
+
+        builder.Build([new Point(1, 0)], field); // цель — стена
+
+        Assert.False(field.IsReachable(0, 0));
+        Assert.False(field.IsReachable(2, 0));
+    }
+}
@@ -0,0 +1,183 @@
+using Microsoft.Xna.Framework;
+using Xunit;
+
+namespace MrGameEng.Pathfinding.Tests;
+
+public class GridPathfinderTests
+{
+    private static List<Point> Path(
+        IPathGrid grid,
+        Point start,
+        Point goal,
+        PathAlgorithm algorithm = PathAlgorithm.AStar,
+        GridConnectivity connectivity = GridConnectivity.Eight
+    )
+    {
+        var pathfinder = new GridPathfinder(grid, connectivity);
+        var path = new List<Point>();
+        Assert.True(pathfinder.FindPath(start, goal, path, algorithm));
+        return path;
+    }
+
+    private static void AssertValidPath(IPathGrid grid, List<Point> path, Point start, Point goal)
+    {
+        Assert.Equal(start, path[0]);
+        Assert.Equal(goal, path[^1]);
+        for (var i = 0; i < path.Count; i++)
+        {
+            Assert.True(grid.IsPassable(path[i].X, path[i].Y), $"impassable cell {path[i]}");
+            if (i > 0)
+            {
+                var dx = Math.Abs(path[i].X - path[i - 1].X);
+                var dy = Math.Abs(path[i].Y - path[i - 1].Y);
+                Assert.True(
+                    dx <= 1 && dy <= 1 && dx + dy > 0,
+                    $"non-adjacent step {path[i - 1]} -> {path[i]}"
+                );
+            }
+        }
+    }
+
+    [Theory]
+    [InlineData(PathAlgorithm.AStar)]
+    [InlineData(PathAlgorithm.Dijkstra)]
+    [InlineData(PathAlgorithm.BreadthFirst)]
+    public void FindPath_OpenField_StraightLine(PathAlgorithm algorithm)
+    {
+        var grid = new TestGrid(".....", ".....", ".....");
+
+        var path = Path(grid, new Point(0, 1), new Point(4, 1), algorithm);
+
+        AssertValidPath(grid, path, new Point(0, 1), new Point(4, 1));
+        Assert.Equal(5, path.Count); // прямая, без лишних шагов
+    }
+
+    [Theory]
+    [InlineData(PathAlgorithm.AStar)]
+    [InlineData(PathAlgorithm.Dijkstra)]
+    [InlineData(PathAlgorithm.BreadthFirst)]
+    public void FindPath_WallsForceDetour(PathAlgorithm algorithm)
+    {
+        var grid = new TestGrid(".....", "####.", ".....");
+
+        var path = Path(grid, new Point(0, 0), new Point(0, 2), algorithm);
+
+        AssertValidPath(grid, path, new Point(0, 0), new Point(0, 2));
+        Assert.Contains(new Point(4, 1), path); // единственный проход
+    }
+
+    [Fact]
+    public void FindPath_NoRoute_ReturnsFalse()
+    {
+        var grid = new TestGrid(".#.", ".#.", ".#.");
+        var pathfinder = new GridPathfinder(grid);
+        var path = new List<Point>();
+
+        Assert.False(pathfinder.FindPath(new Point(0, 0), new Point(2, 0), path));
+        Assert.Empty(path);
+    }
+
+    [Fact]
+    public void FindPath_StartEqualsGoal_SinglePoint()
+    {
+        var grid = new TestGrid("...");
+
+        var path = Path(grid, new Point(1, 0), new Point(1, 0));
+
+        Assert.Equal([new Point(1, 0)], path);
+    }
+
+    [Fact]
+    public void FindPath_DiagonalNeverCutsCorners()
+    {
+        var grid = new TestGrid(".#", "#.");
+        var pathfinder = new GridPathfinder(grid, GridConnectivity.Eight);
+        var path = new List<Point>();
+
+        // Диагональ (0,0)->(1,1) зажата стенами — пути нет.
+        Assert.False(pathfinder.FindPath(new Point(0, 0), new Point(1, 1), path));
+    }
+
+    [Fact]
+    public void FindPath_FourConnectivity_NoDiagonalSteps()
+    {
+        var grid = new TestGrid("...", "...", "...");
+
+        var path = Path(
+            grid,
+            new Point(0, 0),
+            new Point(2, 2),
+            connectivity: GridConnectivity.Four
+        );
+
+        Assert.Equal(5, path.Count); // манхэттен: 4 шага
+        for (var i = 1; i < path.Count; i++)
+        {
+            var dx = Math.Abs(path[i].X - path[i - 1].X);
+            var dy = Math.Abs(path[i].Y - path[i - 1].Y);
+            Assert.Equal(1, dx + dy);
+        }
+    }
+
+    [Theory]
+    [InlineData(PathAlgorithm.AStar)]
+    [InlineData(PathAlgorithm.Dijkstra)]
+    public void FindPath_CostAware_AvoidsExpensiveTerrain(PathAlgorithm algorithm)
+    {
+        // Прямой путь через болото (цена 9) дороже обхода по краю.
+        var grid = new TestGrid(".....", ".999.", ".....");
+
+        var path = Path(grid, new Point(0, 1), new Point(4, 1), algorithm);
+
+        Assert.DoesNotContain(path, p => grid.Cost(p.X, p.Y) > 1f);
+    }
+
+    [Fact]
+    public void FindPath_BreadthFirst_IgnoresCosts()
+    {
+        var grid = new TestGrid(".....", ".999.", ".....");
+
+        var path = Path(grid, new Point(0, 1), new Point(4, 1), PathAlgorithm.BreadthFirst);
+
+        Assert.Equal(5, path.Count); // идёт напрямик через дорогие клетки
+    }
+
+    [Fact]
+    public void FindPath_ReusedInstance_GivesCleanResults()
+    {
+        var grid = new TestGrid(".....", ".###.", ".....");
+        var pathfinder = new GridPathfinder(grid);
+        var path = new List<Point>();
+
+        Assert.True(pathfinder.FindPath(new Point(0, 0), new Point(4, 2), path));
+        var first = path.ToArray();
+        Assert.True(pathfinder.FindPath(new Point(0, 0), new Point(4, 2), path));
+
+        Assert.Equal(first, path); // generation-сброс не оставляет мусора между запросами
+    }
+
+    [Fact]
+    public void FindPath_AStarMatchesDijkstraCost()
+    {
+        var grid = new TestGrid("..3..", ".#3#.", "..3..", ".###.", ".....");
+        var start = new Point(0, 0);
+        var goal = new Point(4, 4);
+
+        var aStar = Path(grid, start, goal, PathAlgorithm.AStar);
+        var dijkstra = Path(grid, start, goal, PathAlgorithm.Dijkstra);
+
+        Assert.Equal(PathCost(grid, dijkstra), PathCost(grid, aStar), 3);
+    }
+
+    private static float PathCost(IPathGrid grid, List<Point> path)
+    {
+        var total = 0f;
+        for (var i = 1; i < path.Count; i++)
+        {
+            var diagonal = path[i].X != path[i - 1].X && path[i].Y != path[i - 1].Y;
+            total += (diagonal ? 1.4142135f : 1f) * grid.Cost(path[i].X, path[i].Y);
+        }
+
+        return total;
+    }
+}
@@ -0,0 +1,46 @@
+using Microsoft.Xna.Framework;
+using Xunit;
+
+namespace MrGameEng.Pathfinding.Tests;
+
+/// <summary>
+/// Размеры грида фиксируются в конструкторе; «уехавший» грид должен давать
+/// громкую ошибку, а не молчаливое чтение мимо границ.
+/// </summary>
+public class GridResizeTests
+{
+    private sealed class ResizableGrid : IPathGrid
+    {
+        public int Width { get; set; } = 4;
+
+        public int Height { get; set; } = 4;
+
+        public bool IsPassable(int x, int y) => true;
+
+        public float Cost(int x, int y) => 1f;
+    }
+
+    [Fact]
+    public void FindPath_AfterGridResize_Throws()
+    {
+        var grid = new ResizableGrid();
+        var pathfinder = new GridPathfinder(grid);
+        grid.Width = 8;
+
+        Assert.Throws<InvalidOperationException>(() =>
+            pathfinder.FindPath(new Point(0, 0), new Point(1, 1), [])
+        );
+    }
+
+    [Fact]
+    public void FlowFieldBuild_AfterGridResize_Throws()
+    {
+        var grid = new ResizableGrid();
+        var builder = new FlowFieldBuilder(grid);
+        grid.Height = 8;
+
+        Assert.Throws<InvalidOperationException>(() =>
+            builder.Build([new Point(0, 0)], new FlowField())
+        );
+    }
+}
@@ -0,0 +1,23 @@
+using MrGameEng.Pathfinding;
+
+namespace MrGameEng.Pathfinding.Tests;
+
+/// <summary>Грид из строк: '#' — стена, '.' — клетка с ценой 1, '2'..'9' — клетка с этой ценой.</summary>
+public sealed class TestGrid : IPathGrid
+{
+    private readonly string[] _rows;
+
+    public TestGrid(params string[] rows) => _rows = rows;
+
+    public int Width => _rows[0].Length;
+
+    public int Height => _rows.Length;
+
+    public bool IsPassable(int x, int y) => _rows[y][x] != '#';
+
+    public float Cost(int x, int y)
+    {
+        var cell = _rows[y][x];
+        return cell is >= '2' and <= '9' ? cell - '0' : 1f;
+    }
+}