- New HexGrid.cs: axial coord helpers, BFS neighbors, cube-lerp LOS, jump-range - Board: HexSides property, GetNeighbors() dispatches hex/square, IsInBounds() hex-aware - BoardShapeGenerator: MakeHexagon() with edge-based starting zones (2–6 players); FromTemplate() now carries HexSides through to the Board - Pathfinding: Walk/Flight BFS uses board.GetNeighbors() (hex+square unified) - LineOfSight: delegates to HexGrid.HasLos when hexSides > 0 - GameRules/GameRuleSet/BoardTemplate/BoardTemplateSnapshot: GridType + HexSides fields - GameMessages BoardDto: GridType + HexSides sent to client - GameEngine: PlaceArchSpirit range uses HexGrid.Distance on hex boards; Teleport LOS passes board.HexSides; ToBoardDto emits GridType/HexSides - EF migration 20260401000000_AddHexGridSupport: grid_type + hex_sides columns on game_rule_sets and board_templates; applied to pg-forge-01 - Client game_screen.gd: hex coord→world (pointy-top flat layout), CylinderMesh tiles (radial_segments=6), _board_distance cube metric, _bfs_reachable 6-dir, _client_has_los cube-lerp, highlight mesh for hex tiles; reads gridType/hexSides from BoardDto Generated with [Claude Code](https://claude.ai/code) via [Happy](https://happy.engineering) Co-Authored-By: Claude <noreply@anthropic.com> Co-Authored-By: Happy <yesreply@happy.engineering>
614 lines
24 KiB
C#
614 lines
24 KiB
C#
namespace SOR.Game.Grid;
|
||
|
||
using System.Text.Json;
|
||
using SOR.Database.Enums;
|
||
|
||
/// <summary>
|
||
/// Generates <see cref="Board"/> instances for different board shapes, populating
|
||
/// <see cref="Board.StartingZones"/> for each player seat.
|
||
/// </summary>
|
||
public static class BoardShapeGenerator
|
||
{
|
||
/// <summary>
|
||
/// Returns the recommended board shape for a given player count when none is explicitly specified.
|
||
/// </summary>
|
||
public static string AutoShape(int playerCount) => playerCount switch
|
||
{
|
||
3 => "Triangular",
|
||
4 => "Cross",
|
||
5 => "RadialStar",
|
||
6 => "HexRing",
|
||
7 => "Decagonal",
|
||
8 => "Decagonal",
|
||
9 => "Decagonal",
|
||
10 => "Decagonal",
|
||
_ => "Rectangle", // 2
|
||
};
|
||
|
||
/// <summary>
|
||
/// Normalize inbound shape labels to canonical values.
|
||
/// Null/empty/"Default" auto-selects by player count.
|
||
/// </summary>
|
||
public static string NormalizeShape(string? shape, int playerCount)
|
||
{
|
||
if (string.IsNullOrWhiteSpace(shape) || shape.Equals("Default", StringComparison.OrdinalIgnoreCase))
|
||
return AutoShape(playerCount);
|
||
|
||
return shape.Trim().ToLowerInvariant() switch
|
||
{
|
||
"rectangle" => "Rectangle",
|
||
"cross" => "Cross",
|
||
"triangular" => "Triangular",
|
||
"triangle" => "Triangular", // alias accepted from older/alternate clients
|
||
"radialstar" => "RadialStar",
|
||
"hexring" => "HexRing",
|
||
"decagonal" => "Decagonal",
|
||
"hexagon" => "Hexagon",
|
||
_ => "Rectangle",
|
||
};
|
||
}
|
||
|
||
/// <summary>Generate a board appropriate for the given shape, rules, and player count.</summary>
|
||
public static Board Generate(string? shape, GameRules rules, int playerCount)
|
||
{
|
||
var normalized = NormalizeShape(shape, playerCount);
|
||
return normalized switch
|
||
{
|
||
"Cross" => MakeCross(rules),
|
||
"Triangular" => MakeTriangular(rules),
|
||
"RadialStar" => MakeRadialStar(rules),
|
||
"HexRing" => MakeHexRing(rules),
|
||
"Decagonal" => MakeDecagonal(rules, playerCount),
|
||
"Hexagon" => MakeHexagon(rules, playerCount),
|
||
_ => MakeRectangle(rules, playerCount),
|
||
};
|
||
}
|
||
|
||
/// <summary>
|
||
/// Rectangle board. Starting zones per seat:
|
||
/// Seat 0 = rows 0–1 (bottom edge)
|
||
/// Seat 1 = rows Height-2 .. Height-1 (top edge)
|
||
/// Seat 2 = cols 0–1 (left edge)
|
||
/// Seat 3 = cols Width-2 .. Width-1 (right edge)
|
||
/// </summary>
|
||
private static Board MakeRectangle(GameRules rules, int playerCount)
|
||
{
|
||
var board = Board.Create(rules.BoardWidth, rules.BoardHeight, rules.StartingRandomTilePct);
|
||
int w = rules.BoardWidth, h = rules.BoardHeight;
|
||
|
||
var zones = new Dictionary<int, HashSet<Coord>>();
|
||
|
||
// 2-player: one placement row each (preserves original 1v1 behavior).
|
||
// 3-4 player: two rows/cols per seat to give more placement room.
|
||
if (playerCount <= 2)
|
||
{
|
||
zones[0] = CoordsInRows(0, 0, w);
|
||
if (playerCount >= 2)
|
||
zones[1] = CoordsInRows(h - 1, h - 1, w);
|
||
}
|
||
else
|
||
{
|
||
zones[0] = CoordsInRows(0, 1, w);
|
||
if (playerCount >= 2)
|
||
zones[1] = CoordsInRows(h - 2, h - 1, w);
|
||
if (playerCount >= 3)
|
||
zones[2] = CoordsInCols(0, 1, h);
|
||
if (playerCount >= 4)
|
||
zones[3] = CoordsInCols(w - 2, w - 1, h);
|
||
}
|
||
|
||
// Return a new Board with the zones attached (Board is a reference type with mutable Tiles
|
||
// so we create a wrapper that shares the same Tiles dictionary).
|
||
return new Board { Width = board.Width, Height = board.Height, Tiles = board.Tiles, StartingZones = zones };
|
||
}
|
||
|
||
/// <summary>
|
||
/// Cross (plus-sign) board for 4 players.
|
||
/// A square center arena with 4 arms; the tip of each arm is one player's starting zone.
|
||
/// </summary>
|
||
private static Board MakeCross(GameRules rules)
|
||
{
|
||
const int arm = 4;
|
||
const int center = 5;
|
||
int total = center + arm * 2; // 13 in each dimension
|
||
|
||
var tiles = new Dictionary<string, Tile>();
|
||
|
||
// Center square
|
||
for (int x = arm; x < arm + center; x++)
|
||
for (int y = arm; y < arm + center; y++)
|
||
AddTile(tiles, x, y);
|
||
|
||
int mid = arm + center / 2; // midpoint column/row of the center section
|
||
|
||
// Bottom arm
|
||
for (int i = 0; i < arm; i++) AddTile(tiles, mid, i);
|
||
// Top arm
|
||
for (int i = 0; i < arm; i++) AddTile(tiles, mid, arm + center + i);
|
||
// Left arm
|
||
for (int i = 0; i < arm; i++) AddTile(tiles, i, mid);
|
||
// Right arm
|
||
for (int i = 0; i < arm; i++) AddTile(tiles, arm + center + i, mid);
|
||
|
||
var zones = new Dictionary<int, HashSet<Coord>>
|
||
{
|
||
[0] = new() { new Coord(mid, 0) }, // bottom tip
|
||
[1] = new() { new Coord(mid, arm + center - 1 + arm) }, // top tip
|
||
[2] = new() { new Coord(0, mid) }, // left tip
|
||
[3] = new() { new Coord(arm + center - 1 + arm, mid) }, // right tip
|
||
};
|
||
|
||
return new Board { Width = total, Height = total, Tiles = tiles, StartingZones = zones };
|
||
}
|
||
|
||
/// <summary>
|
||
/// Triangular board for 3 players.
|
||
/// Uses a symmetric sparse footprint with equal corner-to-corner path lengths:
|
||
/// Seat 0 = bottom-left corner, Seat 1 = bottom-right corner, Seat 2 = top apex.
|
||
///
|
||
/// Geometry is chosen so:
|
||
/// base distance (corner↔corner) == side distance (corner↔apex)
|
||
/// under orthogonal movement.
|
||
/// </summary>
|
||
private static Board MakeTriangular(GameRules rules)
|
||
{
|
||
// Let "side" be the desired equal travel distance between any two starting corners.
|
||
// For an isosceles triangle on an orthogonal grid:
|
||
// base = w - 1
|
||
// side = (w - 1)/2 + (h - 1)
|
||
// Enforce equality by picking h = (w + 1)/2, i.e. side = base.
|
||
int side = Math.Max(12, Math.Max(rules.BoardWidth - 1, 2 * (rules.BoardHeight - 1)));
|
||
if (side % 2 != 0) side++; // keep width odd so apex is centered exactly
|
||
|
||
int w = side + 1; // odd
|
||
int h = side / 2 + 1; // ensures equidistant corners
|
||
int cx = w / 2;
|
||
|
||
var tiles = new Dictionary<string, Tile>();
|
||
|
||
for (int y = 0; y < h; y++)
|
||
{
|
||
// Shrink by 1 tile per side each row moving upward.
|
||
int halfSpan = (h - 1) - y;
|
||
int x0 = cx - halfSpan;
|
||
int x1 = cx + halfSpan;
|
||
for (int x = x0; x <= x1; x++)
|
||
AddTile(tiles, x, y, rules.StartingRandomTilePct);
|
||
}
|
||
|
||
var seat0 = new Coord(0, 0);
|
||
var seat1 = new Coord(w - 1, 0);
|
||
var seat2 = new Coord(cx, h - 1);
|
||
|
||
var zones = new Dictionary<int, HashSet<Coord>>
|
||
{
|
||
[0] = new() { seat0 },
|
||
[1] = new() { seat1 },
|
||
[2] = new() { seat2 },
|
||
};
|
||
|
||
return new Board { Width = w, Height = h, Tiles = tiles, StartingZones = zones };
|
||
}
|
||
|
||
/// <summary>
|
||
/// Radial star board for 5 players.
|
||
/// Five arms radiating from a central arena; one starting-zone tile at each arm tip.
|
||
/// Arms point: bottom, lower-right, upper-right, upper-left, lower-left (pentagon arrangement).
|
||
/// </summary>
|
||
private static Board MakeRadialStar(GameRules rules)
|
||
{
|
||
const int armLen = 5; // tiles per arm (not counting center)
|
||
const int arenaR = 4; // radius of central filled square (half-width)
|
||
int center = arenaR * 2 + 1; // 9
|
||
int total = center + armLen * 2; // 19 in each dimension (plenty of room)
|
||
|
||
var tiles = new Dictionary<string, Tile>();
|
||
|
||
// Central arena
|
||
int c = total / 2;
|
||
for (int x = c - arenaR; x <= c + arenaR; x++)
|
||
for (int y = c - arenaR; y <= c + arenaR; y++)
|
||
AddTile(tiles, x, y);
|
||
|
||
// 5 arms at angles 270°, 342°, 54°, 126°, 198° (bottom-first, counter-clockwise)
|
||
// Approximated on a square grid as (dx, dy) unit directions scaled to armLen steps.
|
||
// Pentagon vertices (unit circle, starting at bottom):
|
||
// 270° → (0, -1) lower center
|
||
// 342° → (0.95, -0.31) → approx (1, 0) then (1,-1) staircase
|
||
// 54° → (0.59, 0.81) → approx (1, 1) staircase
|
||
// 126° → (-0.59, 0.81) → approx (-1, 1)
|
||
// 198° → (-0.95, -0.31) → approx (-1, 0) then (-1,-1)
|
||
// Grid-friendly arm directions for the 5 seats:
|
||
(int dx, int dy)[] dirs =
|
||
[
|
||
( 0, -1), // Seat 0: bottom
|
||
( 1, -1), // Seat 1: lower-right (diagonal)
|
||
( 1, 1), // Seat 2: upper-right (diagonal)
|
||
(-1, 1), // Seat 3: upper-left (diagonal)
|
||
(-1, -1), // Seat 4: lower-left (diagonal)
|
||
];
|
||
|
||
var zones = new Dictionary<int, HashSet<Coord>>();
|
||
|
||
for (int seat = 0; seat < dirs.Length; seat++)
|
||
{
|
||
var (dx, dy) = dirs[seat];
|
||
int tipX = c, tipY = c;
|
||
for (int step = 1; step <= armLen; step++)
|
||
{
|
||
int ax = c + dx * step;
|
||
int ay = c + dy * step;
|
||
AddTile(tiles, ax, ay);
|
||
tipX = ax; tipY = ay;
|
||
}
|
||
zones[seat] = new HashSet<Coord> { new Coord(tipX, tipY) };
|
||
}
|
||
|
||
return new Board { Width = total, Height = total, Tiles = tiles, StartingZones = zones };
|
||
}
|
||
|
||
/// <summary>
|
||
/// Hexagonal ring board for 6 players.
|
||
/// A filled hexagon (approximated on a square grid) with 6 starting zones at the
|
||
/// flat-top hex vertices: bottom-left, bottom, bottom-right, top-right, top, top-left.
|
||
/// </summary>
|
||
private static Board MakeHexRing(GameRules rules)
|
||
{
|
||
// Use a rectangle large enough to contain the hex, with random tiles.
|
||
int w = Math.Max(rules.BoardWidth, 14);
|
||
int h = Math.Max(rules.BoardHeight, 12);
|
||
var board = Board.Create(w, h, rules.StartingRandomTilePct);
|
||
|
||
// Starting zones at 6 evenly-spaced perimeter positions.
|
||
// Place them like a hex: 2 on bottom row, 2 on top row, 1 left-mid, 1 right-mid.
|
||
int zW = Math.Max(2, w / 6);
|
||
int mY = h / 2; // mid row for left/right zones
|
||
|
||
var zones = new Dictionary<int, HashSet<Coord>>
|
||
{
|
||
[0] = CoordsInRect(0, 0, zW - 1, 1, w, h), // bottom-left
|
||
[1] = CoordsInRect(w / 2 - zW / 2, 0, w / 2 + zW / 2 - 1, 1, w, h), // bottom-center
|
||
[2] = CoordsInRect(w - zW, 0, w - 1, 1, w, h), // bottom-right
|
||
[3] = CoordsInRect(w - zW, h - 2, w - 1, h - 1, w, h), // top-right
|
||
[4] = CoordsInRect(w / 2 - zW / 2, h - 2, w / 2 + zW / 2 - 1, h - 1, w, h), // top-center
|
||
[5] = CoordsInRect(0, h - 2, zW - 1, h - 1, w, h), // top-left
|
||
};
|
||
|
||
return new Board { Width = board.Width, Height = board.Height, Tiles = board.Tiles, StartingZones = zones };
|
||
}
|
||
|
||
/// <summary>
|
||
/// Decagonal radial board for 7–10 players.
|
||
/// A filled square central arena with up to 10 arms evenly spaced around it.
|
||
/// Only the first <paramref name="playerCount"/> arms are activated; the rest are omitted.
|
||
/// Arm tips in clockwise order starting at the bottom: 270°, 306°, 342°, 18°, 54°, 90°,
|
||
/// 126°, 162°, 198°, 234°.
|
||
/// </summary>
|
||
private static Board MakeDecagonal(GameRules rules, int playerCount)
|
||
{
|
||
const int armLen = 5;
|
||
const int arenaR = 5; // half-width of central square (11×11)
|
||
int center = arenaR * 2 + 1; // 11
|
||
int total = center + armLen * 2; // 21
|
||
|
||
var tiles = new Dictionary<string, Tile>();
|
||
|
||
int c = total / 2;
|
||
// Central arena
|
||
for (int x = c - arenaR; x <= c + arenaR; x++)
|
||
for (int y = c - arenaR; y <= c + arenaR; y++)
|
||
AddTile(tiles, x, y, rules.StartingRandomTilePct);
|
||
|
||
// 10 arm directions evenly spaced at 36° each.
|
||
// Grid-approximated unit directions (dx, dy) — chosen so each arm has
|
||
// a non-degenerate path from the arena edge to its tip.
|
||
// Angles: 270°, 306°, 342°, 18°, 54°, 90°, 126°, 162°, 198°, 234°
|
||
(int dx, int dy)[] allDirs =
|
||
[
|
||
( 0, -1), // 0: 270° bottom
|
||
( 1, -1), // 1: 306° lower-right diagonal
|
||
( 1, 0), // 2: 342°/0° right
|
||
( 1, 1), // 3: 54° upper-right diagonal
|
||
( 0, 1), // 4: 90° top
|
||
(-1, 1), // 5: 126° upper-left diagonal
|
||
(-1, 0), // 6: 162°/180° left
|
||
(-1, -1), // 7: 198°/216° lower-left diagonal
|
||
// Two extra arms split the diagonal sectors for 9/10 players.
|
||
// These reuse adjacent diagonals with a slight offset (arm root shifted).
|
||
( 1, -1), // 8: duplicate lower-right — arm rooted 2 cols right of center
|
||
(-1, 1), // 9: duplicate upper-left — arm rooted 2 cols left of center
|
||
];
|
||
|
||
// Root offsets for arms 8 and 9 to avoid overlap with arms 1/5.
|
||
int[] rootOffsetX = [0, 0, 0, 0, 0, 0, 0, 0, 2, -2];
|
||
int[] rootOffsetY = [0, 0, 0, 0, 0, 0, 0, 0, -2, 2];
|
||
|
||
int seats = Math.Clamp(playerCount, 7, 10);
|
||
var zones = new Dictionary<int, HashSet<Coord>>();
|
||
|
||
for (int seat = 0; seat < seats; seat++)
|
||
{
|
||
var (dx, dy) = allDirs[seat];
|
||
int rx = c + rootOffsetX[seat];
|
||
int ry = c + rootOffsetY[seat];
|
||
int tipX = rx, tipY = ry;
|
||
for (int step = 1; step <= armLen; step++)
|
||
{
|
||
int ax = rx + dx * step;
|
||
int ay = ry + dy * step;
|
||
// Clamp to grid bounds.
|
||
if (ax < 0 || ax >= total || ay < 0 || ay >= total) break;
|
||
AddTile(tiles, ax, ay, rules.StartingRandomTilePct);
|
||
tipX = ax; tipY = ay;
|
||
}
|
||
zones[seat] = new HashSet<Coord> { new Coord(tipX, tipY) };
|
||
}
|
||
|
||
return new Board { Width = total, Height = total, Tiles = tiles, StartingZones = zones };
|
||
}
|
||
|
||
/// <summary>
|
||
/// Regular hexagonal board. <see cref="GameRules.HexSides"/> N controls size (3–10).
|
||
/// Diameter = 2N−1. Up to 6 starting zones, one per flat-top edge, assigned in order
|
||
/// bottom → lower-right → upper-right → top → upper-left → lower-left.
|
||
/// </summary>
|
||
private static Board MakeHexagon(GameRules rules, int playerCount)
|
||
{
|
||
int N = Math.Clamp(rules.HexSides > 0 ? rules.HexSides : 5, 3, 10);
|
||
int diameter = 2 * N - 1;
|
||
|
||
var tiles = new Dictionary<string, Tile>();
|
||
|
||
for (int x = 0; x < diameter; x++)
|
||
for (int y = 0; y < diameter; y++)
|
||
{
|
||
var c = new Coord(x, y);
|
||
if (HexGrid.IsInBounds(c, N))
|
||
AddTile(tiles, x, y, rules.StartingRandomTilePct);
|
||
}
|
||
|
||
// Six edge directions in axial (dq, dr) — each edge spans N tiles.
|
||
// Axial corners (q,r): (N-1, -(N-1)), (N-1, 0), (0, N-1),
|
||
// (-(N-1), N-1), (-(N-1), 0), (0, -(N-1))
|
||
(int q, int r)[] corners =
|
||
[
|
||
( N-1, -(N-1)), // edge 0 start (bottom-right corner)
|
||
( N-1, 0), // edge 1 start (right corner)
|
||
( 0, N-1), // edge 2 start (upper-right corner)
|
||
(-(N-1), N-1), // edge 3 start (upper-left corner) — top edge start
|
||
(-(N-1), 0), // edge 4 start (left corner)
|
||
( 0, -(N-1)), // edge 5 start (lower-left corner)
|
||
];
|
||
(int dq, int dr)[] edgeDirs =
|
||
[
|
||
(-1, +1), // edge 0: bottom
|
||
(-1, 0), // edge 1: lower-right
|
||
( 0, -1), // edge 2: upper-right
|
||
(+1, -1), // edge 3: top
|
||
(+1, 0), // edge 4: upper-left
|
||
( 0, +1), // edge 5: lower-left
|
||
];
|
||
|
||
int seats = Math.Clamp(playerCount, 2, 6);
|
||
int[] edgeAssign = seats switch
|
||
{
|
||
2 => [0, 3],
|
||
3 => [0, 2, 4],
|
||
4 => [0, 1, 3, 4],
|
||
5 => [0, 1, 2, 3, 4],
|
||
_ => [0, 1, 2, 3, 4, 5],
|
||
};
|
||
|
||
var zones = new Dictionary<int, HashSet<Coord>>();
|
||
for (int seat = 0; seat < seats; seat++)
|
||
{
|
||
int ei = edgeAssign[seat];
|
||
var (sq, sr) = corners[ei];
|
||
var (dq, dr) = edgeDirs[ei];
|
||
var edge = new HashSet<Coord>(N);
|
||
for (int step = 0; step < N; step++)
|
||
{
|
||
var c = HexGrid.FromAxial(sq + dq * step, sr + dr * step, N);
|
||
if (HexGrid.IsInBounds(c, N))
|
||
edge.Add(c);
|
||
}
|
||
zones[seat] = edge;
|
||
}
|
||
|
||
return new Board
|
||
{
|
||
Width = diameter,
|
||
Height = diameter,
|
||
HexSides = N,
|
||
Tiles = tiles,
|
||
StartingZones = zones,
|
||
};
|
||
}
|
||
|
||
// ── Template-based board ──────────────────────────────────────────────────
|
||
|
||
/// <summary>
|
||
/// Separate options for template deserialisation: no JsonStringEnumConverter —
|
||
/// the admin builder serialises affinities as integers.
|
||
/// </summary>
|
||
private static readonly JsonSerializerOptions _templateJson =
|
||
new(JsonSerializerDefaults.Web);
|
||
|
||
/// <summary>
|
||
/// Build a <see cref="Board"/> from a <see cref="BoardTemplateSnapshot"/>.
|
||
///
|
||
/// All Width × Height cells are present in the result; tiles absent from
|
||
/// <paramref name="snapshot"/>.<see cref="BoardTemplateSnapshot.Tiles"/> default to Void+Void.
|
||
///
|
||
/// When <paramref name="startingRandomTilePct"/> is > 0, tiles whose
|
||
/// <see cref="SnapshotTile.AffinityOverrideable"/> flag is set are independently
|
||
/// randomised with that probability (matching the normal <see cref="Board.Create"/> logic).
|
||
/// Locked tiles (<c>AffinityOverrideable = false</c>) always keep their designed affinity.
|
||
/// </summary>
|
||
public static Board FromTemplate(
|
||
BoardTemplateSnapshot snapshot,
|
||
int playerCount,
|
||
int startingRandomTilePct = 0)
|
||
{
|
||
var pct = Math.Clamp(startingRandomTilePct, 0, 100);
|
||
var tiles = new Dictionary<string, Tile>(snapshot.Width * snapshot.Height);
|
||
|
||
// Populate all cells with default Void+Void.
|
||
for (int y = 0; y < snapshot.Height; y++)
|
||
for (int x = 0; x < snapshot.Width; x++)
|
||
{
|
||
var c = new Coord(x, y);
|
||
tiles[c.ToKey()] = new Tile { Coord = c };
|
||
}
|
||
|
||
// Apply designed affinities, respecting the overrideable flag.
|
||
foreach (var td in snapshot.Tiles)
|
||
{
|
||
if (td.X < 0 || td.X >= snapshot.Width || td.Y < 0 || td.Y >= snapshot.Height)
|
||
continue;
|
||
|
||
var c = new Coord(td.X, td.Y);
|
||
|
||
// Absent tiles are completely removed from the board (sparse layout).
|
||
if (td.IsAbsent)
|
||
{
|
||
tiles.Remove(c.ToKey());
|
||
continue;
|
||
}
|
||
var tile = new Tile { Coord = c };
|
||
|
||
if (td.AffinityOverrideable && pct > 0 && Random.Shared.Next(100) < pct)
|
||
{
|
||
// Randomise Base1/Base2 identically to Board.Create.
|
||
var b1 = _base1Pool[Random.Shared.Next(_base1Pool.Length)];
|
||
var b2 = Random.Shared.Next(100) < pct
|
||
? _base2Pool[Random.Shared.Next(_base2Pool.Length)]
|
||
: Affinity.Void;
|
||
if (b2 != Affinity.Void)
|
||
{
|
||
tile.Base1 = b1;
|
||
tile.Base2 = b2;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
tile.Base1 = td.Base1;
|
||
tile.Base2 = td.Base2;
|
||
}
|
||
|
||
tiles[c.ToKey()] = tile;
|
||
}
|
||
|
||
// Resolve starting zones for the given player count.
|
||
var zones = new Dictionary<int, HashSet<Coord>>();
|
||
if (snapshot.StartingZones.TryGetValue(playerCount, out var seatMap))
|
||
{
|
||
foreach (var (seat, coords) in seatMap)
|
||
{
|
||
var set = new HashSet<Coord>(coords.Count);
|
||
foreach (var xy in coords)
|
||
{
|
||
var sep = xy.IndexOf(',');
|
||
if (sep > 0
|
||
&& int.TryParse(xy[..sep], out int cx)
|
||
&& int.TryParse(xy[(sep + 1)..], out int cy))
|
||
set.Add(new Coord(cx, cy));
|
||
}
|
||
zones[seat] = set;
|
||
}
|
||
}
|
||
|
||
return new Board
|
||
{
|
||
Width = snapshot.Width,
|
||
Height = snapshot.Height,
|
||
HexSides = snapshot.HexSides,
|
||
Tiles = tiles,
|
||
StartingZones = zones,
|
||
};
|
||
}
|
||
|
||
/// <summary>
|
||
/// Deserialise a JSON snapshot string and delegate to
|
||
/// <see cref="FromTemplate(BoardTemplateSnapshot, int, int)"/>.
|
||
/// </summary>
|
||
public static Board FromTemplateJson(string json, int playerCount, int startingRandomTilePct = 0)
|
||
{
|
||
var snapshot = JsonSerializer.Deserialize<BoardTemplateSnapshot>(json, _templateJson)
|
||
?? throw new InvalidOperationException("Failed to deserialise BoardTemplateSnapshot.");
|
||
return FromTemplate(snapshot, playerCount, startingRandomTilePct);
|
||
}
|
||
|
||
// ── Helpers ───────────────────────────────────────────────────────────────
|
||
|
||
private static HashSet<Coord> CoordsInRect(int x0, int y0, int x1, int y1, int w, int h)
|
||
{
|
||
var s = new HashSet<Coord>();
|
||
for (int x = Math.Max(0, x0); x <= Math.Min(w - 1, x1); x++)
|
||
for (int y = Math.Max(0, y0); y <= Math.Min(h - 1, y1); y++)
|
||
s.Add(new Coord(x, y));
|
||
return s;
|
||
}
|
||
|
||
private static HashSet<Coord> CoordsInRows(int r0, int r1, int width)
|
||
{
|
||
var s = new HashSet<Coord>();
|
||
for (int x = 0; x < width; x++)
|
||
for (int y = r0; y <= r1; y++)
|
||
s.Add(new Coord(x, y));
|
||
return s;
|
||
}
|
||
|
||
private static HashSet<Coord> CoordsInCols(int c0, int c1, int height)
|
||
{
|
||
var s = new HashSet<Coord>();
|
||
for (int x = c0; x <= c1; x++)
|
||
for (int y = 0; y < height; y++)
|
||
s.Add(new Coord(x, y));
|
||
return s;
|
||
}
|
||
|
||
private static HashSet<Coord> CollectExistingRect(
|
||
Dictionary<string, Tile> tiles, int x0, int y0, int x1, int y1)
|
||
{
|
||
var s = new HashSet<Coord>();
|
||
for (int x = Math.Min(x0, x1); x <= Math.Max(x0, x1); x++)
|
||
for (int y = Math.Min(y0, y1); y <= Math.Max(y0, y1); y++)
|
||
{
|
||
var c = new Coord(x, y);
|
||
if (tiles.ContainsKey(c.ToKey()))
|
||
s.Add(c);
|
||
}
|
||
return s;
|
||
}
|
||
|
||
private static readonly Affinity[] _base1Pool =
|
||
[Affinity.Lake, Affinity.Hill, Affinity.Forest, Affinity.Field, Affinity.Aether];
|
||
|
||
private static readonly Affinity[] _base2Pool =
|
||
[Affinity.Lake, Affinity.Hill, Affinity.Forest, Affinity.Field, Affinity.Aether, Affinity.Void];
|
||
|
||
private static void AddTile(Dictionary<string, Tile> tiles, int x, int y, int startingRandomTilePct = 0)
|
||
{
|
||
var c = new Coord(x, y);
|
||
var tile = new Tile { Coord = c };
|
||
|
||
var pct = Math.Clamp(startingRandomTilePct, 0, 100);
|
||
if (pct > 0 && Random.Shared.Next(100) < pct)
|
||
{
|
||
var b1 = _base1Pool[Random.Shared.Next(_base1Pool.Length)];
|
||
var b2 = Random.Shared.Next(100) < pct
|
||
? _base2Pool[Random.Shared.Next(_base2Pool.Length)]
|
||
: Affinity.Void;
|
||
|
||
if (b2 != Affinity.Void)
|
||
{
|
||
tile.Base1 = b1;
|
||
tile.Base2 = b2;
|
||
}
|
||
}
|
||
|
||
tiles[c.ToKey()] = tile;
|
||
}
|
||
}
|