fix(map): anchor the grid at the world's north-west corner, lattice over the whole image

The previous fix kept the partial edge cell but anchored rows at the SOUTH
edge, leaving the remainder as a squished sliver row at the top — rows sat
visibly displaced versus RustMaps and the companion app (columns were fine
because they were already west-anchored).

Rust, the app and RustMaps anchor the grid at the world's NW corner: rows
step south from the top and the partial cell sits at the south/east, bleeding
past the world edge so every visible cell looks full-size. They also draw the
grid lattice across the WHOLE map image (ocean margin included), not clipped
to the world square.

- MapRenderer.DrawGrid: lattice anchored at the NW world corner, lines
  spanning the full image in all directions; labels (A0..) only for the
  world's ceil-count cells, top-left corner placement unchanged.
- MapGrid.LabelFor: rows bin from the north edge (floor((worldSize - y) /
  CellSize)) so grid references match the visible grid; columns unchanged.
- Regression tests lock the north anchoring (1500 world: y=1360 → A0,
  y=10 → partial row A10).

Verified against RustMaps 1500/1234 (tmp/images/image.png) and the
companion-app geometry with an ocean-margin base tile.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: HandyS11

src/RustPlusBot.Abstractions/Connections/MapGrid.cs

@@ -5,9 +5,10 @@ namespace RustPlusBot.Abstractions.Connections;
 
 /// <summary>
 /// Rust map grid math shared by the map renderer and grid-reference formatting.
-/// One cell is 146.25 game units; the grid covers the whole world <em>including</em> the partial edge
-/// cell (Rust / RustMaps / companion-app behaviour). Columns are lettered west→east from A; rows are
-/// numbered north→south from 0.
+/// One cell is 146.25 game units; the grid is anchored at the world's NORTH-WEST corner
+/// (Rust / RustMaps / companion-app behaviour): columns are lettered west→east from A, rows are
+/// numbered north→south from 0, and the partial edge cell (when the world size is not a whole
+/// multiple of the cell size) sits along the south and east edges.
 /// </summary>
 public static class MapGrid
 {
@@ -16,9 +17,9 @@ public static class MapGrid
 
     /// <summary>
     /// Number of grid cells per axis, covering the whole world size — <c>ceil(worldSize / CellSize)</c>.
-    /// The final cell along each axis is a partial (narrower) edge cell whenever the world size is not a
-    /// whole multiple of <see cref="CellSize"/>; it is still a labelled cell, matching how Rust, the Rust+
-    /// companion app and RustMaps draw the grid. (A 1500 world → 11 cells: A–K, rows 0–10.)
+    /// The last cell (east-most column / south-most row) is a partial edge cell whenever the world size
+    /// is not a whole multiple of <see cref="CellSize"/>; it is still a labelled cell, matching how Rust,
+    /// the Rust+ companion app and RustMaps draw the grid. (A 1500 world → 11 cells: A–K, rows 0–10.)
     /// </summary>
     /// <param name="worldSize">The world size in game units.</param>
     /// <returns>The cell count (at least 1).</returns>
@@ -52,10 +53,11 @@ public static string ColumnLetters(int index)
     /// <returns>The grid label, rows numbered from the top; out-of-world coordinates clamp to the edge cell.</returns>
     public static string LabelFor(float x, float y, uint worldSize)
     {
+        // Rows bin from the NORTH edge (the grid anchor), not the south — with a partial edge cell the
+        // two disagree, and the north anchoring is what the in-game map, the app and RustMaps use.
         var cells = CellCount(worldSize);
         var col = Math.Clamp((int)MathF.Floor(x / CellSize), 0, cells - 1);
-        var rowFromBottom = Math.Clamp((int)MathF.Floor(y / CellSize), 0, cells - 1);
-        var row = cells - 1 - rowFromBottom;
+        var row = Math.Clamp((int)MathF.Floor((worldSize - y) / CellSize), 0, cells - 1);
         return string.Create(CultureInfo.InvariantCulture, $"{ColumnLetters(col)}{row}");
     }
 }

src/RustPlusBot.Features.Map/Rendering/MapRenderer.cs

@@ -112,38 +112,45 @@ private static void DrawGrid(Image<Rgba32> image, MapProjection projection)
 
         var lineColor = Color.FromRgba(255, 255, 255, 80);
         var labelColor = Color.FromRgba(255, 255, 255, 140);
-        var worldSize = projection.WorldSize;
-        var cells = MapGrid.CellCount(worldSize);
-        var (left, top) = projection.ToPixel(0f, worldSize);
-        var (right, bottom) = projection.ToPixel(worldSize, 0f);
+        var cells = MapGrid.CellCount(projection.WorldSize);
+
+        // The lattice is anchored at the world's NORTH-WEST corner and spans the whole image, ocean
+        // margin included — exactly how the in-game map, the companion app and RustMaps draw it. The
+        // partial edge cell (world size not a whole multiple of the cell size) sits at the south/east
+        // and simply bleeds past the world edge, so every rendered cell looks full-size.
+        var (anchorX, anchorY) = projection.ToPixel(0f, projection.WorldSize);
+        var (cellEndX, cellEndY) = projection.ToPixel(MapGrid.CellSize, projection.WorldSize - MapGrid.CellSize);
+        var stepX = cellEndX - anchorX;
+        var stepY = cellEndY - anchorY;
+        if (stepX <= 0f || stepY <= 0f)
+        {
+            return; // Degenerate projection (no drawable world area).
+        }
 
         image.Mutate(ctx =>
         {
-            for (var i = 0; i <= cells; i++)
+            for (var k = (int)MathF.Ceiling(-anchorX / stepX); anchorX + (k * stepX) <= image.Width; k++)
+            {
+                var x = anchorX + (k * stepX);
+                ctx.DrawLine(lineColor, OutlinePenWidth, new PointF(x, 0f), new PointF(x, image.Height));
+            }
+
+            for (var k = (int)MathF.Ceiling(-anchorY / stepY); anchorY + (k * stepY) <= image.Height; k++)
             {
-                // Cover the whole world including the partial edge cell: the final boundary is clamped to
-                // worldSize (Rust / RustMaps behaviour), so the last cell is narrower when the world size
-                // is not a whole multiple of MapGrid.CellSize.
-                var boundary = MathF.Min(i * MapGrid.CellSize, worldSize);
-                var (vx, _) = projection.ToPixel(boundary, 0f);
-                ctx.DrawLine(lineColor, OutlinePenWidth, new PointF(vx, top), new PointF(vx, bottom));
-                var (_, hy) = projection.ToPixel(0f, boundary);
-                ctx.DrawLine(lineColor, OutlinePenWidth, new PointF(left, hy), new PointF(right, hy));
+                var y = anchorY + (k * stepY);
+                ctx.DrawLine(lineColor, OutlinePenWidth, new PointF(0f, y), new PointF(image.Width, y));
             }
 
+            // Only the world's cells carry labels (A0 in the north-west corner), each just inside its
+            // cell's top-left corner (companion-app placement).
             for (var col = 0; col < cells; col++)
             {
                 for (var row = 0; row < cells; row++)
                 {
-                    // Label sits just inside each cell's top-left corner (companion-app placement). Row 0 is
-                    // the northernmost cell, so its top edge is the world's north edge (worldSize).
-                    var worldX = col * MapGrid.CellSize;
-                    var worldY = MathF.Min((cells - row) * MapGrid.CellSize, worldSize);
-                    var (lx, ly) = projection.ToPixel(worldX, worldY);
                     var label = MapGrid.ColumnLetters(col) + row.ToString(CultureInfo.InvariantCulture);
                     ctx.DrawText(new RichTextOptions(GridLabelFont)
                         {
-                            Origin = new PointF(lx + 2f, ly + 2f)
+                            Origin = new PointF(anchorX + (col * stepX) + 2f, anchorY + (row * stepY) + 2f)
                         },
                         label, labelColor);
                 }

tests/RustPlusBot.Abstractions.Tests/Connections/MapGridTests.cs

@@ -35,6 +35,22 @@ public void LabelFor_north_west_corner_is_A0()
         Assert.Equal("A0", MapGrid.LabelFor(0f, 3999f, 4000u));
     }
 
+    [Fact]
+    public void LabelFor_rows_bin_from_the_north_edge()
+    {
+        // 1500 world -> 11 cells with a 37.5-unit partial edge cell. y = 1360 is 140 units below the
+        // north edge: row 0 with north-anchored rows (in-game / app / RustMaps behaviour); binning from
+        // the south would put it in row 1. Locks in the anchoring.
+        Assert.Equal("A0", MapGrid.LabelFor(0f, 1360f, 1500u));
+    }
+
+    [Fact]
+    public void LabelFor_south_edge_falls_in_the_partial_row()
+    {
+        // 1500 world: the southernmost 37.5 units are the partial row 10.
+        Assert.Equal("A10", MapGrid.LabelFor(0f, 10f, 1500u));
+    }
+
     [Fact]
     public void LabelFor_beyond_world_size_clamps_to_last_cell()
     {