| Server IP : 167.235.67.158 / Your IP : 216.73.216.95 Web Server : Apache System : Linux ubuntu-8gb-nbg1-1 6.8.0-111-generic #111-Ubuntu SMP PREEMPT_DYNAMIC Sat Apr 11 23:16:02 UTC 2026 x86_64 User : root ( 0) PHP Version : 8.3.6 Disable Function : NONE MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : OFF | Sudo : ON | Pkexec : OFF Directory : /var/www/bc.the-word.com/timer/ |
Upload File : |
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0, viewport-fit=cover">
<title>Snakes and Ladders</title>
<style>
:root {
color-scheme: dark;
--panel: rgba(17, 24, 39, 0.86);
--panel-strong: rgba(13, 18, 29, 0.94);
--panel-soft: rgba(255, 255, 255, 0.1);
--line: rgba(255, 255, 255, 0.16);
--text: #f8fafc;
--muted: #a8b3c7;
--accent: #5eead4;
--accent-strong: #14b8a6;
--danger: #fb7185;
font-family: Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
}
* {
box-sizing: border-box;
}
html,
body {
width: 100%;
height: 100%;
margin: 0;
overflow: hidden;
background: #080c13;
}
body {
color: var(--text);
user-select: none;
}
#board {
position: fixed;
inset: 0;
width: 100vw;
height: 100vh;
cursor: grab;
touch-action: none;
background: #080c13;
}
#board.is-dragging {
cursor: grabbing;
}
.leaderboard {
position: fixed;
top: 16px;
bottom: 16px;
left: 16px;
width: min(310px, calc(100vw - 32px));
display: flex;
flex-direction: column;
overflow: hidden;
border: 1px solid var(--line);
background: var(--panel);
backdrop-filter: blur(16px);
box-shadow: 0 18px 48px rgba(0, 0, 0, 0.28);
}
.leaderboard__head {
width: 100%;
display: grid;
grid-template-columns: 1fr auto;
gap: 12px;
align-items: end;
padding: 14px 14px 10px;
border: 0;
border-bottom: 1px solid var(--line);
color: var(--text);
background: var(--panel-strong);
font: inherit;
text-align: left;
cursor: pointer;
}
.leaderboard__head:hover,
.leaderboard__head:focus-visible {
background: rgba(24, 34, 52, 0.96);
outline: none;
}
.leaderboard__title {
margin: 0;
font-size: 18px;
font-weight: 800;
letter-spacing: 0;
}
.leaderboard__count {
color: var(--muted);
font-size: 12px;
font-weight: 700;
}
.leaderboard__count::after {
content: " v";
color: var(--accent);
}
.leaderboard.is-collapsed {
bottom: auto;
}
.leaderboard.is-collapsed .leaderboard__head {
border-bottom: 0;
}
.leaderboard.is-collapsed .leaderboard__count::after {
content: " >";
}
.leaderboard.is-collapsed .leaderboard__labels,
.leaderboard.is-collapsed .leaderboard__list {
display: none;
}
.leaderboard__labels {
display: grid;
grid-template-columns: 36px minmax(0, 1fr) 70px;
gap: 8px;
padding: 8px 14px;
color: var(--muted);
font-size: 11px;
font-weight: 800;
text-transform: uppercase;
}
.leaderboard__list {
overflow: auto;
padding: 0 8px 10px;
scrollbar-width: thin;
}
.contestant-row {
width: 100%;
min-height: 34px;
display: grid;
grid-template-columns: 36px minmax(0, 1fr) 70px;
gap: 8px;
align-items: center;
margin: 2px 0;
padding: 6px 6px;
border: 1px solid transparent;
border-radius: 8px;
color: inherit;
background: transparent;
font: inherit;
text-align: left;
cursor: pointer;
}
.contestant-row:hover,
.contestant-row:focus-visible {
border-color: var(--line);
background: rgba(255, 255, 255, 0.08);
outline: none;
}
.contestant-row[aria-current="true"] {
border-color: rgba(94, 234, 212, 0.58);
background: rgba(20, 184, 166, 0.2);
}
.contestant-row__rank {
color: var(--muted);
font-size: 12px;
font-weight: 800;
text-align: right;
}
.contestant-row__name {
min-width: 0;
overflow: hidden;
font-size: 13px;
font-weight: 760;
text-overflow: ellipsis;
white-space: nowrap;
}
.contestant-row__tile {
color: var(--accent);
font-size: 12px;
font-variant-numeric: tabular-nums;
font-weight: 800;
text-align: right;
}
.spectator {
position: fixed;
left: 50%;
bottom: max(16px, env(safe-area-inset-bottom));
display: grid;
grid-template-columns: 42px minmax(190px, 300px) 42px;
gap: 8px;
align-items: center;
transform: translateX(-50%);
padding: 8px;
border: 1px solid var(--line);
background: var(--panel);
backdrop-filter: blur(16px);
box-shadow: 0 18px 48px rgba(0, 0, 0, 0.28);
}
.spectator__button,
.zoom-panel__button {
width: 42px;
height: 42px;
display: grid;
place-items: center;
border: 1px solid var(--line);
border-radius: 8px;
color: var(--text);
background: rgba(255, 255, 255, 0.1);
font: inherit;
font-size: 22px;
font-weight: 900;
cursor: pointer;
}
.spectator__button:hover,
.spectator__button:focus-visible,
.zoom-panel__button:hover,
.zoom-panel__button:focus-visible {
border-color: rgba(94, 234, 212, 0.72);
background: rgba(20, 184, 166, 0.22);
outline: none;
}
.spectator__card {
min-width: 0;
text-align: center;
}
.spectator__name {
overflow: hidden;
font-size: 17px;
font-weight: 850;
text-overflow: ellipsis;
white-space: nowrap;
}
.spectator__stats {
display: flex;
justify-content: center;
gap: 12px;
margin-top: 4px;
color: var(--muted);
font-size: 12px;
font-weight: 760;
font-variant-numeric: tabular-nums;
}
.zoom-panel {
position: fixed;
top: 16px;
right: 16px;
display: grid;
grid-auto-flow: column;
gap: 8px;
padding: 8px;
border: 1px solid var(--line);
background: var(--panel);
backdrop-filter: blur(16px);
}
.zoom-panel__button {
font-size: 18px;
}
.status-pill {
position: fixed;
right: 16px;
bottom: 16px;
max-width: 250px;
padding: 8px 10px;
border: 1px solid var(--line);
background: var(--panel);
color: var(--muted);
font-size: 12px;
font-weight: 760;
backdrop-filter: blur(16px);
}
.loading-overlay {
position: fixed;
inset: 0;
z-index: 10;
display: none;
place-items: center;
padding: 24px;
background: rgba(8, 12, 19, 0.78);
backdrop-filter: blur(10px);
}
.loading-overlay.is-visible {
display: grid;
}
.loading-overlay__panel {
width: min(360px, calc(100vw - 48px));
padding: 18px;
border: 1px solid var(--line);
background: var(--panel-strong);
box-shadow: 0 18px 48px rgba(0, 0, 0, 0.36);
text-align: center;
}
.loading-overlay__title {
margin: 0 0 8px;
font-size: 18px;
font-weight: 850;
}
.loading-overlay__status {
margin: 0;
color: var(--muted);
font-size: 13px;
font-weight: 740;
font-variant-numeric: tabular-nums;
}
@media (max-width: 760px) {
.leaderboard {
top: 10px;
bottom: auto;
left: 10px;
width: min(275px, calc(100vw - 20px));
max-height: 42vh;
}
.leaderboard__head {
padding: 12px 12px 8px;
}
.leaderboard__title {
font-size: 16px;
}
.spectator {
left: 10px;
right: auto;
width: min(340px, calc(100vw - 20px));
grid-template-columns: 40px minmax(0, 1fr) 40px;
transform: none;
}
.zoom-panel {
top: auto;
right: 10px;
bottom: 82px;
grid-auto-flow: row;
}
.status-pill {
display: none;
}
}
</style>
</head>
<body>
<canvas id="board" aria-label="One million tile snakes and ladders board"></canvas>
<aside class="leaderboard" id="leaderboardPanel" aria-label="Leaderboard">
<button class="leaderboard__head" id="leaderboardToggle" type="button" aria-expanded="true" aria-controls="leaderboardList">
<h1 class="leaderboard__title">Leaderboard</h1>
<span class="leaderboard__count" id="contestantCount">100</span>
</button>
<div class="leaderboard__labels" aria-hidden="true">
<span>#</span>
<span>Name</span>
<span>Tile</span>
</div>
<div class="leaderboard__list" id="leaderboardList"></div>
</aside>
<section class="zoom-panel" aria-label="Board view controls">
<button class="zoom-panel__button" id="zoomOutButton" type="button" title="Zoom out" aria-label="Zoom out">-</button>
<button class="zoom-panel__button" id="resetViewButton" type="button" title="Reset view" aria-label="Reset view">⌂</button>
<button class="zoom-panel__button" id="zoomInButton" type="button" title="Zoom in" aria-label="Zoom in">+</button>
</section>
<section class="spectator" aria-label="Spectator controls">
<button class="spectator__button" id="previousContestant" type="button" title="Previous contestant" aria-label="Previous contestant"><</button>
<div class="spectator__card" aria-live="polite">
<div class="spectator__name" id="spectatorName"></div>
<div class="spectator__stats">
<span id="spectatorTile">Tile 0</span>
<span id="spectatorRoll">Roll -</span>
</div>
</div>
<button class="spectator__button" id="nextContestant" type="button" title="Next contestant" aria-label="Next contestant">></button>
</section>
<div class="status-pill" id="viewStatus">Zoom 100%</div>
<div class="loading-overlay" id="loadingOverlay" role="status" aria-live="polite" aria-hidden="true">
<div class="loading-overlay__panel">
<h2 class="loading-overlay__title">Catching up</h2>
<p class="loading-overlay__status" id="loadingStatus">Checking saved game...</p>
</div>
</div>
<script>
(() => {
"use strict";
const GRID_SIZE = 1000;
const TILE_COUNT = GRID_SIZE * GRID_SIZE;
const CONTESTANT_COUNT = 100;
const TILE_NUMBER_MIN_ZOOM = 28;
const STEP_DURATION_MS = 150;
const TURN_PAUSE_MS = 280;
const CONTESTANTS_STATE_VERSION = 3;
const OFFLINE_ROUND_DURATION_MS = STEP_DURATION_MS * 6 + TURN_PAUSE_MS;
const CATCH_UP_CHUNK_ROUNDS = 400;
const BOARD_KEY = "snakesBoard:v1";
const CONTESTANTS_KEY = "snakesContestants:v1";
const UI_KEY = "snakesUi:v1";
const PALETTE_VERSION = 1;
const MIN_ZOOM = 0.2;
const MAX_ZOOM = 96;
const ZOOM_STEP = 1.22;
const contestantShapes = [
"circle", "square", "diamond", "triangle", "hexagon",
"pentagon", "star", "capsule", "shield", "kite"
];
const contestantColors = [
"#ff4d6d", "#4cc9f0", "#ffd166", "#06d6a0", "#9b5de5",
"#f77f00", "#80ed99", "#4895ef", "#f72585", "#f4a261",
"#2a9d8f", "#ffca3a", "#b5179e", "#00b4d8", "#8ac926",
"#e76f51", "#7209b7", "#118ab2", "#fb7185", "#38bdf8"
];
const palette = [
"#d62828", "#f77f00", "#fcbf49", "#ffd166",
"#2a9d8f", "#00b4d8", "#0077b6", "#4361ee",
"#7209b7", "#b5179e", "#f72585", "#ef476f",
"#06d6a0", "#118ab2", "#073b4c", "#8ac926",
"#ff595e", "#ffca3a", "#1982c4", "#6a4c93",
"#4cc9f0", "#4895ef", "#3a0ca3", "#ff9f1c",
"#e76f51", "#2b9348", "#80ed99", "#9b5de5",
"#00f5d4", "#c1121f", "#669bbc", "#f4a261"
].map(hexToRgb);
const normalNames = [
"Alex", "Mia", "Sam", "Ava", "Leo", "Ivy", "Max", "Zoe", "Ben", "Nina",
"Finn", "Ruby", "Ollie", "Luna", "Noah", "Evie", "Jude", "Tess", "Eli", "Maya",
"Theo", "Sofia", "Jack", "Amira", "Oscar", "Grace", "Lucas", "Molly", "Harry", "Chloe",
"Steve", "Jeb_", "Herobrina", "Kai", "Poppy", "Arlo", "Maisie", "Riley", "Skye", "Toby"
];
const sillyPrefixes = [
"Wobble", "Noodle", "Pickle", "Biscuit", "Professor", "Captain", "Turbo", "Mega", "Tiny", "Chunky",
"Sneaky", "Zippy", "Banana", "Button", "Waffle", "Pixel", "Bouncy", "Muffin", "Squiggle", "Dizzy"
];
const sillySuffixes = [
"Pants", "Socks", "Wizard", "Sprout", "Rocket", "Beans", "Wiggle", "Cube", "Toast", "Nugget",
"Spark", "Mango", "Helmet", "Puddle", "Pebble", "Tornado", "Crumpet", "Marshmallow", "Pickaxe", "Blob"
];
const canvas = document.getElementById("board");
const ctx = canvas.getContext("2d", { alpha: false });
const leaderboardPanel = document.getElementById("leaderboardPanel");
const leaderboardToggle = document.getElementById("leaderboardToggle");
const leaderboardList = document.getElementById("leaderboardList");
const contestantCount = document.getElementById("contestantCount");
const spectatorName = document.getElementById("spectatorName");
const spectatorTile = document.getElementById("spectatorTile");
const spectatorRoll = document.getElementById("spectatorRoll");
const viewStatus = document.getElementById("viewStatus");
const loadingOverlay = document.getElementById("loadingOverlay");
const loadingStatus = document.getElementById("loadingStatus");
let boardRecord = loadBoardRecord();
let contestantsRecord = loadContestantsRecord();
let selectedContestantId = loadSelectedContestantId(contestantsRecord.contestants);
let isLeaderboardCollapsed = Boolean(loadJson(UI_KEY)?.leaderboardCollapsed);
let boardBitmap = null;
let animationFrame = 0;
let resizeObserverFrame = 0;
let turnTimer = 0;
let activeContestantIds = new Set();
let isCameraAttachedToSpectator = false;
let devicePixelRatioValue = window.devicePixelRatio || 1;
const view = {
zoom: 1,
panX: 0,
panY: 0
};
const pointerState = {
pointers: new Map(),
mode: "idle",
startX: 0,
startY: 0,
startPanX: 0,
startPanY: 0,
pinchDistance: 0,
pinchZoom: 1,
pinchCenterX: 0,
pinchCenterY: 0,
pinchWorldX: 0,
pinchWorldY: 0
};
init();
function init() {
contestantCount.textContent = String(contestantsRecord.contestants.length);
boardBitmap = buildBoardCanvas(boardRecord.seed);
resizeCanvas();
resetView();
renderLeaderboardCollapsedState();
renderLeaderboard();
renderSpectator();
bindEvents();
requestDraw();
beginReconnectCatchUp();
}
function bindEvents() {
window.addEventListener("resize", () => {
cancelAnimationFrame(resizeObserverFrame);
resizeObserverFrame = requestAnimationFrame(() => {
resizeCanvas();
requestDraw();
});
});
window.addEventListener("pagehide", markLastActivity);
document.addEventListener("visibilitychange", () => {
if (document.visibilityState === "hidden") {
markLastActivity();
}
});
canvas.addEventListener("wheel", event => {
event.preventDefault();
detachSpectatorCamera();
const rect = canvas.getBoundingClientRect();
const x = event.clientX - rect.left;
const y = event.clientY - rect.top;
const factor = event.deltaY < 0 ? ZOOM_STEP : 1 / ZOOM_STEP;
zoomAt(x, y, factor);
}, { passive: false });
canvas.addEventListener("pointerdown", event => {
detachSpectatorCamera();
canvas.setPointerCapture(event.pointerId);
pointerState.pointers.set(event.pointerId, {
x: event.clientX,
y: event.clientY
});
canvas.classList.add("is-dragging");
updatePointerMode();
});
canvas.addEventListener("pointermove", event => {
if (!pointerState.pointers.has(event.pointerId)) {
return;
}
pointerState.pointers.set(event.pointerId, {
x: event.clientX,
y: event.clientY
});
if (pointerState.mode === "pan") {
view.panX = pointerState.startPanX + event.clientX - pointerState.startX;
view.panY = pointerState.startPanY + event.clientY - pointerState.startY;
clampPan();
requestDraw();
} else if (pointerState.mode === "pinch") {
updatePinchZoom();
}
});
canvas.addEventListener("pointerup", endPointer);
canvas.addEventListener("pointercancel", endPointer);
canvas.addEventListener("lostpointercapture", event => {
pointerState.pointers.delete(event.pointerId);
updatePointerMode();
});
document.getElementById("zoomOutButton").addEventListener("click", () => {
detachSpectatorCamera();
zoomAt(canvas.clientWidth / 2, canvas.clientHeight / 2, 1 / ZOOM_STEP);
});
document.getElementById("zoomInButton").addEventListener("click", () => {
detachSpectatorCamera();
zoomAt(canvas.clientWidth / 2, canvas.clientHeight / 2, ZOOM_STEP);
});
document.getElementById("resetViewButton").addEventListener("click", () => {
detachSpectatorCamera();
resetView();
});
document.getElementById("previousContestant").addEventListener("click", () => stepSpectator(-1));
document.getElementById("nextContestant").addEventListener("click", () => stepSpectator(1));
leaderboardToggle.addEventListener("click", toggleLeaderboard);
window.addEventListener("keydown", event => {
const target = event.target;
if (target && ["INPUT", "TEXTAREA", "SELECT", "BUTTON"].includes(target.tagName)) {
return;
}
const panAmount = Math.max(28, 72 / view.zoom);
if (event.key === "+" || event.key === "=") {
event.preventDefault();
detachSpectatorCamera();
zoomAt(canvas.clientWidth / 2, canvas.clientHeight / 2, ZOOM_STEP);
} else if (event.key === "-" || event.key === "_") {
event.preventDefault();
detachSpectatorCamera();
zoomAt(canvas.clientWidth / 2, canvas.clientHeight / 2, 1 / ZOOM_STEP);
} else if (event.key === "Home") {
event.preventDefault();
detachSpectatorCamera();
resetView();
} else if (event.key === "ArrowLeft" || event.key.toLowerCase() === "a") {
event.preventDefault();
detachSpectatorCamera();
panBy(panAmount, 0);
} else if (event.key === "ArrowRight" || event.key.toLowerCase() === "d") {
event.preventDefault();
detachSpectatorCamera();
panBy(-panAmount, 0);
} else if (event.key === "ArrowUp" || event.key.toLowerCase() === "w") {
event.preventDefault();
detachSpectatorCamera();
panBy(0, panAmount);
} else if (event.key === "ArrowDown" || event.key.toLowerCase() === "s") {
event.preventDefault();
detachSpectatorCamera();
panBy(0, -panAmount);
}
});
}
function endPointer(event) {
pointerState.pointers.delete(event.pointerId);
if (pointerState.pointers.size === 0) {
canvas.classList.remove("is-dragging");
}
updatePointerMode();
}
function updatePointerMode() {
const points = Array.from(pointerState.pointers.values());
if (points.length === 0) {
pointerState.mode = "idle";
return;
}
if (points.length === 1) {
pointerState.mode = "pan";
pointerState.startX = points[0].x;
pointerState.startY = points[0].y;
pointerState.startPanX = view.panX;
pointerState.startPanY = view.panY;
return;
}
const first = points[0];
const second = points[1];
const center = getPointerCenter(first, second);
const distance = getPointerDistance(first, second);
pointerState.mode = "pinch";
pointerState.pinchDistance = distance || 1;
pointerState.pinchZoom = view.zoom;
pointerState.pinchCenterX = center.x;
pointerState.pinchCenterY = center.y;
pointerState.pinchWorldX = (center.x - view.panX) / view.zoom;
pointerState.pinchWorldY = (center.y - view.panY) / view.zoom;
}
function updatePinchZoom() {
const points = Array.from(pointerState.pointers.values());
if (points.length < 2) {
return;
}
const first = points[0];
const second = points[1];
const center = getPointerCenter(first, second);
const distance = getPointerDistance(first, second) || 1;
const nextZoom = clamp(pointerState.pinchZoom * distance / pointerState.pinchDistance, MIN_ZOOM, MAX_ZOOM);
view.zoom = nextZoom;
view.panX = center.x - pointerState.pinchWorldX * view.zoom;
view.panY = center.y - pointerState.pinchWorldY * view.zoom;
clampPan();
requestDraw();
}
function getPointerCenter(first, second) {
return {
x: (first.x + second.x) / 2,
y: (first.y + second.y) / 2
};
}
function getPointerDistance(first, second) {
return Math.hypot(first.x - second.x, first.y - second.y);
}
function resizeCanvas() {
devicePixelRatioValue = window.devicePixelRatio || 1;
const width = Math.max(1, Math.floor(window.innerWidth * devicePixelRatioValue));
const height = Math.max(1, Math.floor(window.innerHeight * devicePixelRatioValue));
canvas.width = width;
canvas.height = height;
canvas.style.width = `${window.innerWidth}px`;
canvas.style.height = `${window.innerHeight}px`;
ctx.setTransform(devicePixelRatioValue, 0, 0, devicePixelRatioValue, 0, 0);
clampPan();
}
function resetView() {
const sidePadding = window.innerWidth < 760 ? 24 : 48;
const verticalPadding = window.innerWidth < 760 ? 160 : 48;
const fitZoom = Math.min(
(canvas.clientWidth - sidePadding) / GRID_SIZE,
(canvas.clientHeight - verticalPadding) / GRID_SIZE
);
view.zoom = clamp(fitZoom, MIN_ZOOM, MAX_ZOOM);
view.panX = (canvas.clientWidth - GRID_SIZE * view.zoom) / 2;
view.panY = (canvas.clientHeight - GRID_SIZE * view.zoom) / 2;
clampPan();
requestDraw();
}
function zoomAt(screenX, screenY, factor) {
const worldX = (screenX - view.panX) / view.zoom;
const worldY = (screenY - view.panY) / view.zoom;
view.zoom = clamp(view.zoom * factor, MIN_ZOOM, MAX_ZOOM);
view.panX = screenX - worldX * view.zoom;
view.panY = screenY - worldY * view.zoom;
clampPan();
requestDraw();
}
function panBy(deltaX, deltaY) {
view.panX += deltaX;
view.panY += deltaY;
clampPan();
requestDraw();
}
function clampPan() {
const boardWidth = GRID_SIZE * view.zoom;
const boardHeight = GRID_SIZE * view.zoom;
const canvasWidth = canvas.clientWidth || window.innerWidth;
const canvasHeight = canvas.clientHeight || window.innerHeight;
const margin = Math.max(80, Math.min(canvasWidth, canvasHeight) * 0.55 + view.zoom);
if (boardWidth <= canvasWidth) {
view.panX = clamp(view.panX, -margin, canvasWidth - boardWidth + margin);
} else {
view.panX = clamp(view.panX, canvasWidth - boardWidth - margin, margin);
}
if (boardHeight <= canvasHeight) {
view.panY = clamp(view.panY, -margin, canvasHeight - boardHeight + margin);
} else {
view.panY = clamp(view.panY, canvasHeight - boardHeight - margin, margin);
}
}
function requestDraw() {
if (animationFrame) {
return;
}
animationFrame = requestAnimationFrame(draw);
}
function draw() {
animationFrame = 0;
const width = canvas.clientWidth;
const height = canvas.clientHeight;
ctx.save();
ctx.setTransform(devicePixelRatioValue, 0, 0, devicePixelRatioValue, 0, 0);
ctx.imageSmoothingEnabled = false;
ctx.fillStyle = "#080c13";
ctx.fillRect(0, 0, width, height);
ctx.drawImage(
boardBitmap,
Math.round(view.panX),
Math.round(view.panY),
Math.round(GRID_SIZE * view.zoom),
Math.round(GRID_SIZE * view.zoom)
);
drawBoardBoundary();
if (view.zoom >= 8) {
drawGridLines();
}
if (view.zoom >= TILE_NUMBER_MIN_ZOOM) {
drawTileNumbers();
}
drawContestants();
ctx.restore();
viewStatus.textContent = `Zoom ${Math.round(view.zoom * 100)}%`;
}
function drawBoardBoundary() {
ctx.strokeStyle = "rgba(255, 255, 255, 0.7)";
ctx.lineWidth = 2;
ctx.strokeRect(
Math.round(view.panX) + 0.5,
Math.round(view.panY) + 0.5,
Math.round(GRID_SIZE * view.zoom),
Math.round(GRID_SIZE * view.zoom)
);
}
function drawGridLines() {
const startCol = clamp(Math.floor((-view.panX) / view.zoom), 0, GRID_SIZE);
const endCol = clamp(Math.ceil((canvas.clientWidth - view.panX) / view.zoom), 0, GRID_SIZE);
const startRow = clamp(Math.floor((-view.panY) / view.zoom), 0, GRID_SIZE);
const endRow = clamp(Math.ceil((canvas.clientHeight - view.panY) / view.zoom), 0, GRID_SIZE);
ctx.beginPath();
ctx.strokeStyle = view.zoom >= 16 ? "rgba(0, 0, 0, 0.42)" : "rgba(0, 0, 0, 0.24)";
ctx.lineWidth = 1;
for (let col = startCol; col <= endCol; col += 1) {
const x = Math.round(view.panX + col * view.zoom) + 0.5;
ctx.moveTo(x, view.panY + startRow * view.zoom);
ctx.lineTo(x, view.panY + endRow * view.zoom);
}
for (let row = startRow; row <= endRow; row += 1) {
const y = Math.round(view.panY + row * view.zoom) + 0.5;
ctx.moveTo(view.panX + startCol * view.zoom, y);
ctx.lineTo(view.panX + endCol * view.zoom, y);
}
ctx.stroke();
}
function drawTileNumbers() {
const startCol = clamp(Math.floor((-view.panX) / view.zoom), 0, GRID_SIZE - 1);
const endCol = clamp(Math.ceil((canvas.clientWidth - view.panX) / view.zoom), 0, GRID_SIZE - 1);
const startRow = clamp(Math.floor((-view.panY) / view.zoom), 0, GRID_SIZE - 1);
const endRow = clamp(Math.ceil((canvas.clientHeight - view.panY) / view.zoom), 0, GRID_SIZE - 1);
const fontSize = clamp(Math.floor(view.zoom * 0.2), 6, 14);
const tileCenterOffset = view.zoom / 2;
ctx.save();
ctx.textAlign = "center";
ctx.textBaseline = "middle";
ctx.font = `800 ${fontSize}px Inter, ui-sans-serif, system-ui, sans-serif`;
ctx.lineWidth = Math.max(2, fontSize * 0.24);
ctx.strokeStyle = "rgba(0, 0, 0, 0.76)";
ctx.fillStyle = "rgba(255, 255, 255, 0.94)";
for (let row = startRow; row <= endRow; row += 1) {
for (let col = startCol; col <= endCol; col += 1) {
const tile = boardCoordinateToTile(col, row);
const x = view.panX + col * view.zoom + tileCenterOffset;
const y = view.panY + row * view.zoom + tileCenterOffset;
const label = String(tile);
ctx.strokeText(label, x, y);
ctx.fillText(label, x, y);
}
}
ctx.restore();
}
function drawContestants() {
const grouped = new Map();
for (const contestant of contestantsRecord.contestants) {
if (!grouped.has(contestant.tile)) {
grouped.set(contestant.tile, []);
}
grouped.get(contestant.tile).push(contestant);
}
for (const [tile, contestants] of grouped) {
const coordinate = tileToBoardCoordinate(tile);
const tileX = view.panX + coordinate.x * view.zoom;
const tileY = view.panY + coordinate.y * view.zoom;
const visibilityMargin = Math.max(32, view.zoom);
if (
tileX + view.zoom < -visibilityMargin ||
tileX > canvas.clientWidth + visibilityMargin ||
tileY + view.zoom < -visibilityMargin ||
tileY > canvas.clientHeight + visibilityMargin
) {
continue;
}
const drawOrder = [...contestants].sort((a, b) => {
const aPriority = Number(a.id === selectedContestantId) + Number(activeContestantIds.has(a.id)) * 2;
const bPriority = Number(b.id === selectedContestantId) + Number(activeContestantIds.has(b.id)) * 2;
return aPriority - bPriority;
});
drawOrder.forEach((contestant, index) => {
const slot = getContestantSlot(index, drawOrder.length);
drawContestantToken(
contestant,
tileX + slot.x,
tileY + slot.y,
slot.size,
activeContestantIds.has(contestant.id),
contestant.id === selectedContestantId
);
});
}
}
function getContestantSlot(index, count) {
if (count <= 1) {
return {
x: view.zoom / 2,
y: view.zoom / 2,
size: clamp(view.zoom * 0.74, 1.2, 28)
};
}
const columns = Math.ceil(Math.sqrt(count));
const rows = Math.ceil(count / columns);
const column = index % columns;
const row = Math.floor(index / columns);
const cellWidth = view.zoom / columns;
const cellHeight = view.zoom / rows;
return {
x: (column + 0.5) * cellWidth,
y: (row + 0.5) * cellHeight,
size: clamp(Math.min(cellWidth, cellHeight) * 0.72, 1.2, 28)
};
}
function drawContestantToken(contestant, x, y, size, isActive, isSelected) {
const shape = contestant.shape || contestantShapes[0];
const fill = contestant.color || contestantColors[0];
const radius = size / 2;
ctx.save();
ctx.translate(x, y);
ctx.beginPath();
drawShapePath(shape, radius);
ctx.fillStyle = fill;
ctx.shadowColor = "rgba(0, 0, 0, 0.5)";
ctx.shadowBlur = size < 5 ? 0 : isActive ? 9 : 4;
ctx.shadowOffsetY = size < 5 ? 0 : 2;
ctx.fill();
ctx.shadowColor = "transparent";
ctx.lineWidth = clamp(size * (isActive ? 0.16 : isSelected ? 0.13 : 0.08), 0.7, 3);
ctx.strokeStyle = isActive ? "#ffffff" : isSelected ? "#5eead4" : "rgba(255, 255, 255, 0.82)";
ctx.stroke();
if (size >= 8) {
const initial = contestant.name.trim().charAt(0).toUpperCase();
const fontSize = clamp(size * 0.54, 6, 16);
ctx.font = `900 ${fontSize}px Inter, ui-sans-serif, system-ui, sans-serif`;
ctx.textAlign = "center";
ctx.textBaseline = "middle";
ctx.lineWidth = Math.max(2, fontSize * 0.18);
ctx.strokeStyle = "rgba(0, 0, 0, 0.7)";
ctx.fillStyle = "#ffffff";
ctx.strokeText(initial, 0, 1);
ctx.fillText(initial, 0, 1);
}
ctx.restore();
}
function drawShapePath(shape, radius) {
if (shape === "circle") {
ctx.arc(0, 0, radius, 0, Math.PI * 2);
return;
}
if (shape === "square") {
ctx.rect(-radius, -radius, radius * 2, radius * 2);
return;
}
if (shape === "diamond") {
ctx.moveTo(0, -radius * 1.12);
ctx.lineTo(radius * 1.12, 0);
ctx.lineTo(0, radius * 1.12);
ctx.lineTo(-radius * 1.12, 0);
ctx.closePath();
return;
}
if (shape === "triangle") {
drawRegularPolygon(3, radius * 1.18, -Math.PI / 2);
return;
}
if (shape === "hexagon") {
drawRegularPolygon(6, radius * 1.08, Math.PI / 6);
return;
}
if (shape === "pentagon") {
drawRegularPolygon(5, radius * 1.1, -Math.PI / 2);
return;
}
if (shape === "star") {
drawStar(radius * 1.18, radius * 0.56);
return;
}
if (shape === "capsule") {
const width = radius * 2.35;
const height = radius * 1.42;
roundRectPath(-width / 2, -height / 2, width, height, height / 2);
return;
}
if (shape === "shield") {
ctx.moveTo(0, -radius * 1.16);
ctx.lineTo(radius * 0.95, -radius * 0.64);
ctx.lineTo(radius * 0.72, radius * 0.62);
ctx.lineTo(0, radius * 1.18);
ctx.lineTo(-radius * 0.72, radius * 0.62);
ctx.lineTo(-radius * 0.95, -radius * 0.64);
ctx.closePath();
return;
}
ctx.moveTo(0, -radius * 1.2);
ctx.lineTo(radius, -radius * 0.1);
ctx.lineTo(0, radius * 1.2);
ctx.lineTo(-radius, -radius * 0.1);
ctx.closePath();
}
function drawRegularPolygon(sides, radius, rotation) {
for (let i = 0; i < sides; i += 1) {
const angle = rotation + i * Math.PI * 2 / sides;
const x = Math.cos(angle) * radius;
const y = Math.sin(angle) * radius;
if (i === 0) {
ctx.moveTo(x, y);
} else {
ctx.lineTo(x, y);
}
}
ctx.closePath();
}
function drawStar(outerRadius, innerRadius) {
for (let i = 0; i < 10; i += 1) {
const radius = i % 2 === 0 ? outerRadius : innerRadius;
const angle = -Math.PI / 2 + i * Math.PI / 5;
const x = Math.cos(angle) * radius;
const y = Math.sin(angle) * radius;
if (i === 0) {
ctx.moveTo(x, y);
} else {
ctx.lineTo(x, y);
}
}
ctx.closePath();
}
function roundRectPath(x, y, width, height, radius) {
ctx.moveTo(x + radius, y);
ctx.lineTo(x + width - radius, y);
ctx.quadraticCurveTo(x + width, y, x + width, y + radius);
ctx.lineTo(x + width, y + height - radius);
ctx.quadraticCurveTo(x + width, y + height, x + width - radius, y + height);
ctx.lineTo(x + radius, y + height);
ctx.quadraticCurveTo(x, y + height, x, y + height - radius);
ctx.lineTo(x, y + radius);
ctx.quadraticCurveTo(x, y, x + radius, y);
ctx.closePath();
}
function renderLeaderboard() {
const ordered = getRankedContestants();
const previousScrollTop = leaderboardList.scrollTop;
leaderboardList.replaceChildren();
const fragment = document.createDocumentFragment();
ordered.forEach((contestant, index) => {
const row = document.createElement("button");
row.type = "button";
row.className = "contestant-row";
row.setAttribute("aria-current", contestant.id === selectedContestantId ? "true" : "false");
row.dataset.id = contestant.id;
row.title = `Spectate ${contestant.name}`;
row.innerHTML = `
<span class="contestant-row__rank">${index + 1}</span>
<span class="contestant-row__name"></span>
<span class="contestant-row__tile"></span>
`;
row.querySelector(".contestant-row__name").textContent = contestant.name;
row.querySelector(".contestant-row__tile").textContent = contestant.finishedAt
? formatDuration(contestant.finishedAt)
: String(contestant.tile);
row.addEventListener("click", () => selectContestant(contestant.id));
fragment.append(row);
});
leaderboardList.append(fragment);
leaderboardList.scrollTop = previousScrollTop;
}
function renderSpectator() {
const selected = getSelectedContestant();
spectatorName.textContent = selected.name;
spectatorTile.textContent = `Tile ${selected.tile.toLocaleString()}`;
spectatorRoll.textContent = selected.lastRoll === null ? "Roll -" : `Roll ${selected.lastRoll}`;
saveUiState();
const activeRow = leaderboardList.querySelector("[aria-current='true']");
if (activeRow) {
activeRow.setAttribute("aria-current", "false");
}
const nextRow = leaderboardList.querySelector(`[data-id="${cssEscape(selectedContestantId)}"]`);
if (nextRow) {
nextRow.setAttribute("aria-current", "true");
}
}
function selectContestant(id) {
selectedContestantId = id;
isCameraAttachedToSpectator = true;
renderSpectator();
centerViewOnContestant(getSelectedContestant(), MAX_ZOOM);
}
function detachSpectatorCamera() {
isCameraAttachedToSpectator = false;
}
function toggleLeaderboard() {
isLeaderboardCollapsed = !isLeaderboardCollapsed;
renderLeaderboardCollapsedState();
saveUiState();
}
function renderLeaderboardCollapsedState() {
leaderboardPanel.classList.toggle("is-collapsed", isLeaderboardCollapsed);
leaderboardToggle.setAttribute("aria-expanded", String(!isLeaderboardCollapsed));
leaderboardToggle.title = isLeaderboardCollapsed ? "Expand leaderboard" : "Collapse leaderboard";
}
function saveUiState() {
saveJson(UI_KEY, {
selectedContestantId,
leaderboardCollapsed: isLeaderboardCollapsed
});
}
function beginReconnectCatchUp() {
const now = Date.now();
const lastActivityAt = Number.isFinite(contestantsRecord.lastActivityAt)
? contestantsRecord.lastActivityAt
: now;
const missedRounds = Math.max(0, Math.floor((now - lastActivityAt) / OFFLINE_ROUND_DURATION_MS));
if (missedRounds === 0) {
markLastActivity();
startGameLoop();
return;
}
showLoading(`Applying ${missedRounds.toLocaleString()} missed rounds...`);
window.setTimeout(() => processCatchUpChunk({
totalRounds: missedRounds,
processedRounds: 0,
baseTime: lastActivityAt
}), 50);
}
function processCatchUpChunk(catchUp) {
const remainingRounds = catchUp.totalRounds - catchUp.processedRounds;
const roundsThisChunk = Math.min(CATCH_UP_CHUNK_ROUNDS, remainingRounds);
for (let i = 0; i < roundsThisChunk; i += 1) {
applyOfflineRound(catchUp.baseTime + (catchUp.processedRounds + 1) * OFFLINE_ROUND_DURATION_MS);
catchUp.processedRounds += 1;
}
contestantsRecord.lastActivityAt = catchUp.baseTime + catchUp.processedRounds * OFFLINE_ROUND_DURATION_MS;
saveJson(CONTESTANTS_KEY, contestantsRecord);
const progress = catchUp.totalRounds === 0
? 100
: Math.floor(catchUp.processedRounds / catchUp.totalRounds * 100);
showLoading(`Applied ${catchUp.processedRounds.toLocaleString()} of ${catchUp.totalRounds.toLocaleString()} rounds (${progress}%)`);
if (catchUp.processedRounds < catchUp.totalRounds && hasUnfinishedContestants()) {
window.setTimeout(() => processCatchUpChunk(catchUp), 0);
return;
}
activeContestantIds = new Set();
markLastActivity();
renderLeaderboard();
renderSpectator();
requestDraw();
hideLoading();
startGameLoop();
}
function applyOfflineRound(roundTimestamp) {
let rolled = false;
for (const contestant of contestantsRecord.contestants) {
if (contestant.finishedAt) {
continue;
}
rolled = true;
const roll = rollDie();
contestant.lastRoll = roll;
contestant.tile = Math.min(TILE_COUNT, contestant.tile + roll);
if (contestant.tile >= TILE_COUNT && !contestant.finishedAt) {
contestant.finishedAt = Math.max(0, roundTimestamp - contestantsRecord.startedAt);
}
}
if (rolled) {
contestantsRecord.roundNumber = (contestantsRecord.roundNumber || 0) + 1;
}
}
function hasUnfinishedContestants() {
return contestantsRecord.contestants.some(contestant => !contestant.finishedAt);
}
function showLoading(message) {
loadingStatus.textContent = message;
loadingOverlay.classList.add("is-visible");
loadingOverlay.setAttribute("aria-hidden", "false");
}
function hideLoading() {
loadingOverlay.classList.remove("is-visible");
loadingOverlay.setAttribute("aria-hidden", "true");
}
function markLastActivity() {
contestantsRecord.lastActivityAt = Date.now();
saveJson(CONTESTANTS_KEY, contestantsRecord);
}
function startGameLoop() {
clearTimeout(turnTimer);
scheduleNextRound(650);
}
function scheduleNextRound(delay) {
clearTimeout(turnTimer);
turnTimer = window.setTimeout(playNextRound, delay);
}
function playNextRound() {
const moves = contestantsRecord.contestants
.filter(contestant => !contestant.finishedAt)
.map(contestant => {
const roll = rollDie();
contestant.lastRoll = roll;
return {
contestant,
targetTile: Math.min(TILE_COUNT, contestant.tile + roll)
};
});
if (moves.length === 0) {
activeContestantIds = new Set();
requestDraw();
return;
}
activeContestantIds = new Set(moves.map(move => move.contestant.id));
contestantsRecord.roundNumber = (contestantsRecord.roundNumber || 0) + 1;
saveContestantsRecord();
renderLeaderboard();
renderSpectator();
requestDraw();
moveContestantsOneStep(moves);
}
function moveContestantsOneStep(moves) {
const anyStillMoving = moves.some(move => move.contestant.tile < move.targetTile && !move.contestant.finishedAt);
if (!anyStillMoving) {
finishActiveRound();
return;
}
turnTimer = window.setTimeout(() => {
for (const move of moves) {
const contestant = move.contestant;
if (contestant.finishedAt || contestant.tile >= move.targetTile) {
continue;
}
contestant.tile = Math.min(move.targetTile, contestant.tile + 1);
if (contestant.tile >= TILE_COUNT && !contestant.finishedAt) {
contestant.finishedAt = Date.now() - contestantsRecord.startedAt;
}
}
saveContestantsRecord();
renderLeaderboard();
renderSpectator();
const selectedMove = moves.find(move => move.contestant.id === selectedContestantId);
if (selectedMove && isCameraAttachedToSpectator) {
keepContestantInView(selectedMove.contestant);
}
requestDraw();
moveContestantsOneStep(moves);
}, STEP_DURATION_MS);
}
function finishActiveRound() {
activeContestantIds = new Set();
saveContestantsRecord();
renderLeaderboard();
renderSpectator();
requestDraw();
scheduleNextRound(TURN_PAUSE_MS);
}
function rollDie() {
return Math.floor(Math.random() * 6) + 1;
}
function centerViewOnContestant(contestant, minimumZoom) {
const coordinate = tileToBoardCoordinate(contestant.tile);
view.zoom = clamp(minimumZoom, MIN_ZOOM, MAX_ZOOM);
view.panX = canvas.clientWidth / 2 - (coordinate.x + 0.5) * view.zoom;
view.panY = canvas.clientHeight / 2 - (coordinate.y + 0.5) * view.zoom;
clampPan();
requestDraw();
}
function keepContestantInView(contestant) {
const coordinate = tileToBoardCoordinate(contestant.tile);
const screenX = view.panX + (coordinate.x + 0.5) * view.zoom;
const screenY = view.panY + (coordinate.y + 0.5) * view.zoom;
const margin = 120;
if (
screenX < margin ||
screenX > canvas.clientWidth - margin ||
screenY < margin ||
screenY > canvas.clientHeight - margin
) {
centerViewOnContestant(contestant, MAX_ZOOM);
}
}
function saveContestantsRecord() {
contestantsRecord.lastActivityAt = Date.now();
saveJson(CONTESTANTS_KEY, contestantsRecord);
}
function stepSpectator(direction) {
const contestants = contestantsRecord.contestants;
const currentIndex = contestants.findIndex(contestant => contestant.id === selectedContestantId);
const safeIndex = currentIndex === -1 ? 0 : currentIndex;
const nextIndex = (safeIndex + direction + contestants.length) % contestants.length;
selectContestant(contestants[nextIndex].id);
}
function getSelectedContestant() {
return contestantsRecord.contestants.find(contestant => contestant.id === selectedContestantId)
|| contestantsRecord.contestants[0];
}
function getRankedContestants() {
return [...contestantsRecord.contestants].sort((a, b) => {
if (a.finishedAt && b.finishedAt) {
return a.finishedAt - b.finishedAt;
}
if (a.finishedAt) {
return -1;
}
if (b.finishedAt) {
return 1;
}
if (b.tile !== a.tile) {
return b.tile - a.tile;
}
return a.name.localeCompare(b.name);
});
}
function buildBoardCanvas(seed) {
const offscreen = document.createElement("canvas");
offscreen.width = GRID_SIZE;
offscreen.height = GRID_SIZE;
const offscreenContext = offscreen.getContext("2d", { alpha: false });
const image = offscreenContext.createImageData(GRID_SIZE, GRID_SIZE);
const data = image.data;
const random = mulberry32(seed);
const previousRow = new Uint8Array(GRID_SIZE);
const currentRow = new Uint8Array(GRID_SIZE);
for (let y = 0; y < GRID_SIZE; y += 1) {
for (let x = 0; x < GRID_SIZE; x += 1) {
const left = x > 0 ? currentRow[x - 1] : 255;
const above = y > 0 ? previousRow[x] : 255;
const colorIndex = pickColorIndex(random, left, above);
currentRow[x] = colorIndex;
const offset = (y * GRID_SIZE + x) * 4;
const color = palette[colorIndex];
data[offset] = color.r;
data[offset + 1] = color.g;
data[offset + 2] = color.b;
data[offset + 3] = 255;
}
previousRow.set(currentRow);
}
offscreenContext.putImageData(image, 0, 0);
return offscreen;
}
function pickColorIndex(random, left, above) {
const blockedCount = left === above ? (left === 255 ? 0 : 1) : Number(left !== 255) + Number(above !== 255);
let pick = Math.floor(random() * (palette.length - blockedCount));
for (let index = 0; index < palette.length; index += 1) {
if (index === left || index === above) {
continue;
}
if (pick === 0) {
return index;
}
pick -= 1;
}
return 0;
}
function loadBoardRecord() {
const existing = loadJson(BOARD_KEY);
if (existing && Number.isInteger(existing.seed) && existing.paletteVersion === PALETTE_VERSION) {
return existing;
}
const record = {
seed: createSeed(),
paletteVersion: PALETTE_VERSION
};
saveJson(BOARD_KEY, record);
return record;
}
function loadContestantsRecord() {
const existing = loadJson(CONTESTANTS_KEY);
if (existing && Number.isInteger(existing.seed) && Array.isArray(existing.contestants) && existing.contestants.length === CONTESTANT_COUNT) {
const normalized = normalizeContestantsRecord(existing);
saveJson(CONTESTANTS_KEY, normalized);
return normalized;
}
const seed = createSeed();
const record = {
stateVersion: CONTESTANTS_STATE_VERSION,
seed,
startedAt: Date.now(),
lastActivityAt: Date.now(),
roundNumber: 0,
contestants: generateContestants(seed)
};
saveJson(CONTESTANTS_KEY, record);
return record;
}
function normalizeContestantsRecord(record) {
const shouldResetPositions = record.stateVersion !== CONTESTANTS_STATE_VERSION;
return {
stateVersion: CONTESTANTS_STATE_VERSION,
seed: record.seed,
startedAt: shouldResetPositions || !Number.isFinite(record.startedAt) ? Date.now() : record.startedAt,
lastActivityAt: shouldResetPositions || !Number.isFinite(record.lastActivityAt) ? Date.now() : record.lastActivityAt,
roundNumber: !shouldResetPositions && Number.isInteger(record.roundNumber)
? Math.max(0, record.roundNumber)
: 0,
contestants: record.contestants.map((contestant, index) => normalizeContestant(contestant, index, shouldResetPositions))
};
}
function normalizeContestant(contestant, index, shouldResetPosition) {
contestant = contestant || {};
const fallbackName = `Player ${index + 1}`;
const tile = !shouldResetPosition && Number.isFinite(contestant.tile) ? Math.floor(contestant.tile) : 0;
const lastRoll = !shouldResetPosition && Number.isInteger(contestant.lastRoll) && contestant.lastRoll >= 1 && contestant.lastRoll <= 6
? contestant.lastRoll
: null;
const finishedAt = !shouldResetPosition && Number.isFinite(contestant.finishedAt) ? contestant.finishedAt : null;
return {
id: contestant.id || `contestant-${String(index + 1).padStart(3, "0")}`,
name: contestant.name || fallbackName,
tile: clamp(tile, 0, TILE_COUNT),
lastRoll,
finishedAt,
shape: contestant.shape || contestantShapes[index % contestantShapes.length],
color: contestant.color || contestantColors[index % contestantColors.length]
};
}
function loadSelectedContestantId(contestants) {
const existing = loadJson(UI_KEY);
if (existing && contestants.some(contestant => contestant.id === existing.selectedContestantId)) {
return existing.selectedContestantId;
}
return getRankedContestants()[0].id;
}
function generateContestants(seed) {
const random = mulberry32(seed);
const names = [];
const normalPool = shuffle([...normalNames], random);
const prefixPool = shuffle([...sillyPrefixes], random);
const suffixPool = shuffle([...sillySuffixes], random);
for (let i = 0; i < CONTESTANT_COUNT; i += 1) {
let name;
if (i < normalPool.length && random() < 0.55) {
name = normalPool[i];
} else {
const prefix = prefixPool[i % prefixPool.length];
const suffix = suffixPool[Math.floor(i / prefixPool.length + i) % suffixPool.length];
const style = i % 5;
if (style === 0) {
name = `${prefix}${suffix}`;
} else if (style === 1) {
name = `${prefix}_${suffix}`;
} else if (style === 2) {
name = `${prefix}${Math.floor(random() * 90) + 10}`;
} else if (style === 3) {
name = `${suffix}_${Math.floor(random() * 900) + 100}`;
} else {
name = `${prefix} ${suffix}`;
}
}
names.push(name);
}
const used = new Map();
return names.map((name, index) => {
const count = used.get(name) || 0;
used.set(name, count + 1);
const uniqueName = count === 0 ? name : `${name}_${count + 1}`;
return {
id: `contestant-${String(index + 1).padStart(3, "0")}`,
name: uniqueName,
tile: 0,
lastRoll: null,
finishedAt: null,
shape: contestantShapes[index % contestantShapes.length],
color: contestantColors[index % contestantColors.length]
};
});
}
function tileToBoardCoordinate(tile) {
if (tile <= 0) {
return { x: -1, y: GRID_SIZE };
}
const index = clamp(tile - 1, 0, TILE_COUNT - 1);
const rowFromBottom = Math.floor(index / GRID_SIZE);
const colInRow = index % GRID_SIZE;
const x = rowFromBottom % 2 === 0 ? colInRow : GRID_SIZE - 1 - colInRow;
const y = GRID_SIZE - 1 - rowFromBottom;
return { x, y };
}
function boardCoordinateToTile(x, y) {
const rowFromBottom = GRID_SIZE - 1 - y;
const colInRow = rowFromBottom % 2 === 0 ? x : GRID_SIZE - 1 - x;
return rowFromBottom * GRID_SIZE + colInRow + 1;
}
function shuffle(items, random) {
for (let i = items.length - 1; i > 0; i -= 1) {
const j = Math.floor(random() * (i + 1));
[items[i], items[j]] = [items[j], items[i]];
}
return items;
}
function createSeed() {
const cryptoObject = window.crypto || window.msCrypto;
if (cryptoObject && cryptoObject.getRandomValues) {
const values = new Uint32Array(1);
cryptoObject.getRandomValues(values);
return values[0];
}
return Math.floor(Math.random() * 0xffffffff);
}
function mulberry32(seed) {
let value = seed >>> 0;
return () => {
value += 0x6D2B79F5;
let next = value;
next = Math.imul(next ^ next >>> 15, next | 1);
next ^= next + Math.imul(next ^ next >>> 7, next | 61);
return ((next ^ next >>> 14) >>> 0) / 4294967296;
};
}
function hexToRgb(hex) {
const value = Number.parseInt(hex.slice(1), 16);
return {
r: value >> 16 & 255,
g: value >> 8 & 255,
b: value & 255
};
}
function formatDuration(milliseconds) {
const totalSeconds = Math.floor(milliseconds / 1000);
const hours = Math.floor(totalSeconds / 3600);
const minutes = Math.floor(totalSeconds % 3600 / 60);
const seconds = totalSeconds % 60;
return `${String(hours).padStart(2, "0")}:${String(minutes).padStart(2, "0")}:${String(seconds).padStart(2, "0")}`;
}
function loadJson(key) {
try {
const value = localStorage.getItem(key);
return value ? JSON.parse(value) : null;
} catch (error) {
console.warn(`Unable to load ${key}`, error);
return null;
}
}
function saveJson(key, value) {
try {
localStorage.setItem(key, JSON.stringify(value));
} catch (error) {
console.warn(`Unable to save ${key}`, error);
}
}
function cssEscape(value) {
if (window.CSS && typeof window.CSS.escape === "function") {
return window.CSS.escape(value);
}
return String(value).replace(/["\\]/g, "\\$&");
}
function clamp(value, min, max) {
return Math.min(max, Math.max(min, value));
}
window.snakesDebug = Object.freeze({
tileToBoardCoordinate,
boardCoordinateToTile,
get contestants() {
return contestantsRecord.contestants;
},
get boardSeed() {
return boardRecord.seed;
}
});
})();
</script>
</body>
</html>