= 0 && $col < $cols && $row >= 0 && $row < $rows; } public static function neighbors(int $q, int $r): array { $out = []; foreach (self::DIRS as [$dq, $dr]) { $out[] = [$q + $dq, $r + $dr]; } return $out; } public static function neighbor(int $q, int $r, int $dir): array { $d = self::DIRS[($dir % 6 + 6) % 6]; return [$q + $d[0], $r + $d[1]]; } public static function distance(int $q1, int $r1, int $q2, int $r2): int { return intdiv(abs($q1 - $q2) + abs($q1 + $r1 - $q2 - $r2) + abs($r1 - $r2), 2); } public static function cubeRound(float $x, float $z, float $y): array { $rx = (int)round($x); $rz = (int)round($z); $ry = (int)round($y); $dx = abs($rx - $x); $dz = abs($rz - $z); $dy = abs($ry - $y); if ($dx > $dz && $dx > $dy) { $rx = -$rz - $ry; } elseif ($dz > $dy) { $rz = -$rx - $ry; } return [$rx, $rz]; } /** Inclusive hex line from A to B. */ public static function line(int $q1, int $r1, int $q2, int $r2): array { $n = self::distance($q1, $r1, $q2, $r2); if ($n === 0) { return [[$q1, $r1]]; } $out = []; $y1 = -$q1 - $r1; $y2 = -$q2 - $r2; for ($i = 0; $i <= $n; $i++) { $t = $i / $n; $out[] = self::cubeRound( $q1 + ($q2 - $q1) * $t, $r1 + ($r2 - $r1) * $t, $y1 + ($y2 - $y1) * $t ); } return $out; } /** Hexes from origin stepping in a facing, excluding origin. */ public static function ray(int $q, int $r, int $dir, int $length): array { $out = []; for ($i = 0; $i < $length; $i++) { [$q, $r] = self::neighbor($q, $r, $dir); $out[] = [$q, $r]; } return $out; } /** * LoS is blocked by walls on intermediate hexes. Endpoints may be occupied. * @param array $walls */ public static function los(int $q1, int $r1, int $q2, int $r2, array $walls): bool { $line = self::line($q1, $r1, $q2, $r2); $last = count($line) - 1; for ($i = 1; $i < $last; $i++) { if (isset($walls[self::key($line[$i][0], $line[$i][1])])) { return false; } } return true; } public static function pixel(int $q, int $r): array { return [sqrt(3) * ($q + $r / 2), 1.5 * $r]; } public static function facingAngle(int $dir): float { $d = self::DIRS[($dir % 6 + 6) % 6]; [$x, $y] = self::pixel($d[0], $d[1]); return atan2($y, $x); } public static function bearing(int $q1, int $r1, int $q2, int $r2): float { [$x1, $y1] = self::pixel($q1, $r1); [$x2, $y2] = self::pixel($q2, $r2); return atan2($y2 - $y1, $x2 - $x1); } public static function angleDiff(float $a, float $b): float { $d = fmod($a - $b + M_PI, 2 * M_PI); if ($d < 0) { $d += 2 * M_PI; } return $d - M_PI; } public static function inCone(int $uq, int $ur, int $facing, int $tq, int $tr, float $halfDeg): bool { if ($uq === $tq && $ur === $tr) { return false; } return abs(self::angleDiff(self::bearing($uq, $ur, $tq, $tr), self::facingAngle($facing))) <= deg2rad($halfDeg) + 1e-9; } public static function dirToward(int $q1, int $r1, int $q2, int $r2): int { $best = 0; $bestAbs = INF; $bearing = self::bearing($q1, $r1, $q2, $r2); for ($d = 0; $d < 6; $d++) { $abs = abs(self::angleDiff($bearing, self::facingAngle($d))); if ($abs < $bestAbs) { $bestAbs = $abs; $best = $d; } } return $best; } public static function onFacingLine(int $q, int $r, int $facing, int $tq, int $tr, int $length): bool { foreach (self::ray($q, $r, $facing, $length) as [$qq, $rr]) { if ($qq === $tq && $rr === $tr) { return true; } } return false; } /** * A* path across walkable hexes. Returns inclusive hex list or null. * @param array $walkable */ public static function path(int $q1, int $r1, int $q2, int $r2, array $walkable): ?array { $start = self::key($q1, $r1); $goal = self::key($q2, $r2); if (!isset($walkable[$start]) || !isset($walkable[$goal])) { return null; } if ($start === $goal) { return [[$q1, $r1]]; } $open = [$start => 0]; $came = []; $g = [$start => 0]; while ($open) { $current = array_key_first($open); $best = $open[$current]; foreach ($open as $k => $f) { if ($f < $best) { $current = $k; $best = $f; } } unset($open[$current]); if ($current === $goal) { $path = []; while ($current !== $start) { $path[] = self::parse($current); $current = $came[$current]; } $path[] = [$q1, $r1]; return array_reverse($path); } [$cq, $cr] = self::parse($current); foreach (self::neighbors($cq, $cr) as [$nq, $nr]) { $nk = self::key($nq, $nr); if (!isset($walkable[$nk])) { continue; } $tg = $g[$current] + 1; if (!isset($g[$nk]) || $tg < $g[$nk]) { $came[$nk] = $current; $g[$nk] = $tg; $open[$nk] = $tg + self::distance($nq, $nr, $q2, $r2); } } } return null; } /** * @return array */ public static function allHexes(int $cols, int $rows): array { $out = []; for ($row = 0; $row < $rows; $row++) { for ($col = 0; $col < $cols; $col++) { [$q, $r] = self::axial($col, $row); $out[self::key($q, $r)] = true; } } return $out; } } /** Deterministic 32-bit RNG used by wall generation and combat. */ final class SynhexRng { private int $state; public function __construct(int $seed) { $this->state = $seed | 1; } public function next(): int { $x = $this->state; $x = ($x ^ ($x << 13)) & 0x7fffffff; $x = ($x ^ ($x >> 17)) & 0x7fffffff; $x = ($x ^ ($x << 5)) & 0x7fffffff; return $this->state = $x; } public function below(int $n): int { return $n <= 0 ? 0 : $this->next() % $n; } public function chance(int $percent): bool { if ($percent <= 0) { return false; } if ($percent >= 100) { return true; } return $this->below(100) < $percent; } public function unit(): float { return $this->next() / 0x7fffffff; } }