extremely claude-assisted go game based on atproto! working on cleaning up and giving a more unique design, still has a bit of a slop vibe to it.
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316import type { MoveRecord } from './types';
export interface ScoreResult { black: number; white: number; winner: 'black' | 'white' | 'tie';}
export interface TerritoryMap { territory: Array<Array<'black' | 'white' | 'neutral' | null>>; blackTerritory: number; whiteTerritory: number;}
/** * Client-side scoring calculation that doesn't rely on tenuki to avoid hangs. * Replays moves to build board state, then calculates territory using flood fill. */export function calculateScore( moves: MoveRecord[], boardSize: number = 19, komi: number = 6.5, deadStones: string[] = []): ScoreResult { console.log('[client-scoring] Starting with', moves.length, 'moves, boardSize:', boardSize, 'komi:', komi, 'deadStones:', deadStones.length);
// Build board state by replaying moves with capture logic const boardState = buildBoardState(moves, boardSize);
// Count stones on the board let blackStones = 0; let whiteStones = 0;
for (let y = 0; y < boardSize; y++) { for (let x = 0; x < boardSize; x++) { if (boardState[y][x] === 'black') blackStones++; if (boardState[y][x] === 'white') whiteStones++; } }
console.log('[client-scoring] Before dead stones - Black stones:', blackStones, 'White stones:', whiteStones);
// Process dead stones - remove them from the board and count as captures for opponent let blackCaptures = 0; let whiteCaptures = 0;
if (deadStones.length > 0) { console.log('[client-scoring] Processing', deadStones.length, 'dead stones...'); for (const notation of deadStones) { // Parse notation like "bA01" or "wT19" const color = notation[0] === 'b' ? 'black' : 'white'; const col = notation.charCodeAt(1) - 65; // A=0, B=1, etc. const row = parseInt(notation.slice(2)) - 1; // 1-indexed to 0-indexed
if (row >= 0 && row < boardSize && col >= 0 && col < boardSize) { if (boardState[row][col] === color) { // Remove the stone from the board boardState[row][col] = null;
// Count as capture for opponent if (color === 'black') { blackStones--; whiteCaptures++; } else { whiteStones--; blackCaptures++; }
console.log(`[client-scoring] Removed dead ${color} stone at (${col}, ${row})`); } } } console.log('[client-scoring] After removing dead stones - Black stones:', blackStones, 'White stones:', whiteStones); console.log('[client-scoring] Captures - Black captured:', blackCaptures, 'White captured:', whiteCaptures); }
// Calculate territory using flood fill const territoryMap = calculateTerritory(boardState, boardSize);
console.log('[client-scoring] Territory calculated. Black:', territoryMap.blackTerritory, 'White:', territoryMap.whiteTerritory);
// Calculate final scores (territory + stones + captures) const blackScore = blackStones + territoryMap.blackTerritory + blackCaptures; const whiteScore = whiteStones + territoryMap.whiteTerritory + whiteCaptures + komi;
console.log('[client-scoring] Final scores. Black:', blackScore, 'White:', whiteScore);
// Determine winner let winner: 'black' | 'white' | 'tie'; if (blackScore > whiteScore) { winner = 'black'; } else if (whiteScore > blackScore) { winner = 'white'; } else { winner = 'tie'; }
console.log('[client-scoring] Winner determined:', winner);
return { black: blackScore, white: whiteScore, winner, };}
/** * Build board state by replaying moves with basic capture logic. * This is a simplified implementation that handles captures but not complex ko situations. */export function buildBoardState( moves: MoveRecord[], boardSize: number): Array<Array<'black' | 'white' | null>> { const board: Array<Array<'black' | 'white' | null>> = Array.from( { length: boardSize }, () => Array.from({ length: boardSize }, () => null) );
for (const move of moves) { const { x, y, color } = move;
if (x < 0 || x >= boardSize || y < 0 || y >= boardSize) continue; if (board[y][x] !== null) continue; // Square already occupied
// Place the stone board[y][x] = color;
// Check for captures of opponent stones const opponent = color === 'black' ? 'white' : 'black'; const neighbors = getNeighbors(x, y, boardSize);
for (const [nx, ny] of neighbors) { if (board[ny][nx] === opponent) { // Check if this opponent group has no liberties if (getLiberties(board, nx, ny, boardSize).length === 0) { // Capture the group removeGroup(board, nx, ny, boardSize); } } } }
return board;}
/** * Get neighboring coordinates */function getNeighbors(x: number, y: number, boardSize: number): Array<[number, number]> { const neighbors: Array<[number, number]> = []; if (x > 0) neighbors.push([x - 1, y]); if (x < boardSize - 1) neighbors.push([x + 1, y]); if (y > 0) neighbors.push([x, y - 1]); if (y < boardSize - 1) neighbors.push([x, y + 1]); return neighbors;}
/** * Get all liberties (empty neighbors) of a group */function getLiberties( board: Array<Array<'black' | 'white' | null>>, x: number, y: number, boardSize: number): Array<[number, number]> { const color = board[y][x]; if (color === null) return [];
const liberties = new Set<string>(); const visited = new Set<string>(); const queue: Array<[number, number]> = [[x, y]];
while (queue.length > 0) { const [cx, cy] = queue.shift()!; const key = `${cx},${cy}`;
if (visited.has(key)) continue; visited.add(key);
for (const [nx, ny] of getNeighbors(cx, cy, boardSize)) { const nkey = `${nx},${ny}`; if (board[ny][nx] === null) { liberties.add(nkey); } else if (board[ny][nx] === color && !visited.has(nkey)) { queue.push([nx, ny]); } } }
return Array.from(liberties).map(key => { const [x, y] = key.split(',').map(Number); return [x, y] as [number, number]; });}
/** * Remove a captured group from the board */function removeGroup( board: Array<Array<'black' | 'white' | null>>, x: number, y: number, boardSize: number): void { const color = board[y][x]; if (color === null) return;
const visited = new Set<string>(); const queue: Array<[number, number]> = [[x, y]];
while (queue.length > 0) { const [cx, cy] = queue.shift()!; const key = `${cx},${cy}`;
if (visited.has(key)) continue; visited.add(key);
board[cy][cx] = null;
for (const [nx, ny] of getNeighbors(cx, cy, boardSize)) { const nkey = `${nx},${ny}`; if (board[ny][nx] === color && !visited.has(nkey)) { queue.push([nx, ny]); } } }}
/** * Calculate territory for each empty intersection using flood fill. * An empty region belongs to a player if it's completely surrounded by their stones. */export function calculateTerritory( boardState: Array<Array<'black' | 'white' | null>>, boardSize: number): TerritoryMap { const territory: Array<Array<'black' | 'white' | 'neutral' | null>> = Array.from( { length: boardSize }, () => Array.from({ length: boardSize }, () => null) );
const visited: Array<Array<boolean>> = Array.from( { length: boardSize }, () => Array.from({ length: boardSize }, () => false) );
let blackTerritory = 0; let whiteTerritory = 0;
// Flood fill to find connected empty regions function floodFill(startY: number, startX: number): { points: Array<[number, number]>; owner: 'black' | 'white' | 'neutral' } { const points: Array<[number, number]> = []; const stack: Array<[number, number]> = [[startY, startX]]; let touchesBlack = false; let touchesWhite = false;
while (stack.length > 0) { const [y, x] = stack.pop()!;
if (y < 0 || y >= boardSize || x < 0 || x >= boardSize) continue; if (visited[y][x]) continue;
const cell = boardState[y][x];
if (cell === 'black') { touchesBlack = true; continue; } if (cell === 'white') { touchesWhite = true; continue; }
// Empty intersection visited[y][x] = true; points.push([y, x]);
// Add neighbors stack.push([y - 1, x], [y + 1, x], [y, x - 1], [y, x + 1]); }
let owner: 'black' | 'white' | 'neutral'; if (touchesBlack && !touchesWhite) { owner = 'black'; } else if (touchesWhite && !touchesBlack) { owner = 'white'; } else { owner = 'neutral'; }
return { points, owner }; }
// Find all empty regions for (let y = 0; y < boardSize; y++) { for (let x = 0; x < boardSize; x++) { if (!visited[y][x] && boardState[y][x] === null) { const { points, owner } = floodFill(y, x); for (const [py, px] of points) { territory[py][px] = owner; if (owner === 'black') blackTerritory++; else if (owner === 'white') whiteTerritory++; } } } }
return { territory, blackTerritory, whiteTerritory, };}