Fix weather draft and deploy setup

more card rule tweaks
fix draft ui
2026-04-29 12:00:56 -04:00 · 2026-04-10 16:13:45 -04:00 · 2026-04-10 16:12:41 -04:00 · 2026-04-10 13:36:43 -04:00 · 2026-04-09 17:45:09 -04:00 · 2026-04-09 17:42:19 -04:00
18 changed files with 5893 additions and 2194 deletions
--- a/index.html
+++ b/index.html
@@ -4,7 +4,7 @@
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Canopy</title>
-    <script type="module" src="/src/main.js"></script>
+    <script type="module" src="/src/main.ts"></script>
  </head>
  <body>
    <div id="app"></div>
--- a/nixpacks.toml
+++ b/nixpacks.toml
@@ -0,0 +1,11 @@
+[phases.build]
+cmds = ["npm run build"]
+
+[start]
+cmd = "serve dist -l 80 -s"
+
+[healthcheck]
+cmd = "curl -f http://localhost:80/ || exit 1"
+interval = "10s"
+timeout = "5s"
+retries = 3
--- a/package-lock.json
+++ b/package-lock.json
--- a/package.json
+++ b/package.json
@@ -6,9 +6,15 @@
  "scripts": {
    "dev": "vite",
    "build": "vite build",
-    "preview": "vite preview"
+    "preview": "vite preview",
+    "start": "serve dist -l 80 -s",
+    "typecheck": "tsc --noEmit"
  },
  "devDependencies": {
+    "typescript": "^6.0.2",
    "vite": "^5.4.19"
+  },
+  "dependencies": {
+    "serve": "^14.2.6"
  }
 }
--- a/src/engine/constants.ts
+++ b/src/engine/constants.ts
@@ -0,0 +1,16 @@
+import type { PlayerPalette } from "./types";
+
+export const STARTING_POINTS = 3;
+export const ROOT_SHIFT_COST = 1;
+export const ROUND_ANIMATION_SUN_MS = 900;
+export const ROUND_ANIMATION_BRANCH_MS = 1200;
+export const ROUND_ANIMATION_BONUS_MS = 900;
+
+export const PLAYER_PALETTE: PlayerPalette[] = [
+  { name: "Coral", primary: "#ff6b8a", glow: "rgba(255, 107, 138, 0.35)" },
+  { name: "Aqua", primary: "#4de0ff", glow: "rgba(77, 224, 255, 0.35)" },
+  { name: "Amber", primary: "#ffbf47", glow: "rgba(255, 191, 71, 0.35)" },
+  { name: "Mint", primary: "#6fffb0", glow: "rgba(111, 255, 176, 0.35)" },
+  { name: "Violet", primary: "#b28dff", glow: "rgba(178, 141, 255, 0.35)" },
+  { name: "Rose", primary: "#ff8dbf", glow: "rgba(255, 141, 191, 0.35)" },
+];
--- a/src/engine/rules-board.ts
+++ b/src/engine/rules-board.ts
@@ -0,0 +1,173 @@
+import { ROOT_SHIFT_COST } from "./constants";
+import type { ColumnLeader, GameState, GrowTarget, NodeKey, Player, PlayerId, ShiftMove } from "./types";
+import { keyFor, parseKey } from "./utils";
+
+export function getNodeOwner(state: GameState, row: number, column: number): PlayerId | null {
+  return state.nodes.get(keyFor(row, column))?.ownerId ?? null;
+}
+
+export function buildParentMap(state: GameState) {
+  return new Map(state.edges.map((edge) => [keyFor(edge.to.row, edge.to.column), keyFor(edge.from.row, edge.from.column)]));
+}
+
+export function buildChildrenMap(state: GameState, ownerId: PlayerId | null = null) {
+  const childrenMap = new Map<NodeKey, NodeKey[]>();
+
+  state.edges.forEach((edge) => {
+    if (ownerId !== null && edge.ownerId !== ownerId) {
+      return;
+    }
+
+    const fromKey = keyFor(edge.from.row, edge.from.column);
+    const target = keyFor(edge.to.row, edge.to.column);
+    const entry = childrenMap.get(fromKey) ?? [];
+    entry.push(target);
+    childrenMap.set(fromKey, entry);
+  });
+
+  return childrenMap;
+}
+
+export function collectSubtreeKeys(state: GameState, rootKey: NodeKey, player: Player) {
+  const childrenMap = buildChildrenMap(state, player.id);
+  const subtree = new Set<NodeKey>([rootKey]);
+  const queue: NodeKey[] = [rootKey];
+
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (!current) {
+      continue;
+    }
+
+    (childrenMap.get(current) ?? []).forEach((childKey) => {
+      if (!subtree.has(childKey)) {
+        subtree.add(childKey);
+        queue.push(childKey);
+      }
+    });
+  }
+
+  return subtree;
+}
+
+export function getRootShiftMove(state: GameState, sourceKey: NodeKey, delta: number, player: Player): ShiftMove | null {
+  if (state.round !== 1 || player.growthPoints < ROOT_SHIFT_COST) {
+    return null;
+  }
+
+  const parentMap = buildParentMap(state);
+  const source = parseKey(sourceKey);
+  if (source.row !== state.config.rows - 1 || state.nodes.get(sourceKey)?.ownerId !== player.id || parentMap.has(sourceKey)) {
+    return null;
+  }
+
+  const subtree = collectSubtreeKeys(state, sourceKey, player);
+  const movedNodes: ShiftMove["movedNodes"] = [];
+
+  for (const nodeKey of subtree) {
+    const node = parseKey(nodeKey);
+    const targetColumn = node.column + delta;
+    if (targetColumn < 0 || targetColumn >= state.config.columns) {
+      return null;
+    }
+
+    const targetKey = keyFor(node.row, targetColumn);
+    if (!subtree.has(targetKey) && state.nodes.has(targetKey)) {
+      return null;
+    }
+
+    movedNodes.push({ fromKey: nodeKey, toKey: targetKey, row: node.row, fromColumn: node.column, toColumn: targetColumn });
+  }
+
+  const movedEdges = state.edges
+    .filter((edge) => subtree.has(keyFor(edge.from.row, edge.from.column)) && subtree.has(keyFor(edge.to.row, edge.to.column)))
+    .map((edge) => ({
+      before: {
+        from: { ...edge.from },
+        to: { ...edge.to },
+        ownerId: edge.ownerId,
+      },
+      after: {
+        from: { row: edge.from.row, column: edge.from.column + delta },
+        to: { row: edge.to.row, column: edge.to.column + delta },
+        ownerId: edge.ownerId,
+      },
+    }));
+
+  return {
+    type: "shift",
+    cost: ROOT_SHIFT_COST,
+    direction: delta < 0 ? "left" : "right",
+    movedNodes,
+    movedEdges,
+    undoKeys: movedNodes.map((node) => node.toKey),
+    selectKey: keyFor(source.row, source.column + delta),
+  };
+}
+
+export function playerHasRootShiftMove(state: GameState, player: Player) {
+  if (state.round !== 1 || player.growthPoints < ROOT_SHIFT_COST) {
+    return false;
+  }
+
+  return Array.from(state.nodes.entries()).some(([nodeKey, node]) => {
+    if (node.ownerId !== player.id) {
+      return false;
+    }
+
+    return Boolean(getRootShiftMove(state, nodeKey, -1, player) || getRootShiftMove(state, nodeKey, 1, player));
+  });
+}
+
+export function getLegalMovesForSource(state: GameState, sourceKey: NodeKey, player: Player): GrowTarget[] {
+  const columns = state.config.columns;
+  const { row, column } = parseKey(sourceKey);
+  if (player.id !== getNodeOwner(state, row, column) || row === 0) {
+    return [];
+  }
+
+  const moves: GrowTarget[] = [
+    { row: row - 1, column, cost: 1, direction: "vertical" },
+    { row: row - 1, column: column - 1, cost: 2, direction: "left" },
+    { row: row - 1, column: column + 1, cost: 2, direction: "right" },
+  ];
+
+  return moves.filter((move) => {
+    if (move.column < 0 || move.column >= columns) {
+      return false;
+    }
+
+    if (state.nodes.has(keyFor(move.row, move.column))) {
+      return false;
+    }
+
+    return move.cost <= player.growthPoints;
+  });
+}
+
+export function playerHasLegalMove(state: GameState, player: Player) {
+  if (player.growthPoints <= 0) {
+    return false;
+  }
+
+  return Array.from(state.nodes.entries()).some(([nodeKey, node]) => {
+    if (node.ownerId !== player.id) {
+      return false;
+    }
+
+    return getLegalMovesForSource(state, nodeKey, player).length > 0;
+  }) || playerHasRootShiftMove(state, player);
+}
+
+export function getColumnLeaders(state: GameState): ColumnLeader[] {
+  return Array.from({ length: state.config.columns }, (_, column) => {
+    for (let row = 0; row < state.config.rows; row += 1) {
+      const owner = getNodeOwner(state, row, column);
+      if (owner !== null) {
+        return { ownerId: owner, row, tied: false };
+      }
+    }
+
+    return { ownerId: null, row: null, tied: false };
+  });
+}
--- a/src/engine/rules-initiative.ts
+++ b/src/engine/rules-initiative.ts
@@ -0,0 +1,55 @@
+import type { GameState, InitiativeDraftState, PlayerId } from "./types";
+
+export function getInitiativeGraceRounds(state: GameState) {
+  return Math.max(0, (state.config.columns / state.players.length) - state.players.length);
+}
+
+export function getSeatBonuses(state: GameState) {
+  const graceRounds = getInitiativeGraceRounds(state);
+  const firstSeatBonus = state.round - 1 < graceRounds ? 0 : 1;
+
+  return Array.from({ length: state.players.length }, (_, index) => (index === 0 ? firstSeatBonus : 0));
+}
+
+export function getRotatingBiddingOrder(state: GameState) {
+  const start = (state.initiativeAnchorPlayerId + state.round - 1) % state.players.length;
+  return Array.from({ length: state.players.length }, (_, index) => (start + index) % state.players.length);
+}
+
+export function getLowestGrowthBiddingOrder(state: GameState) {
+  const orderRank = new Map<PlayerId, number>(state.turnOrder.map((playerId, index) => [playerId, index]));
+
+  return [...state.players]
+    .sort((left, right) => {
+      if (left.lifetimeGrowthIncome !== right.lifetimeGrowthIncome) {
+        return left.lifetimeGrowthIncome - right.lifetimeGrowthIncome;
+      }
+
+      const leftRank = orderRank.get(left.id) ?? left.id;
+      const rightRank = orderRank.get(right.id) ?? right.id;
+      if (leftRank !== rightRank) {
+        return leftRank - rightRank;
+      }
+
+      return left.id - right.id;
+    })
+    .map((player) => player.id);
+}
+
+export function createInitiativeDraft(state: GameState): InitiativeDraftState {
+  const biddingOrder = state.config.biddingOrderRule === "lowest_growth_income"
+    ? getLowestGrowthBiddingOrder(state)
+    : getRotatingBiddingOrder(state);
+
+  return {
+    biddingOrder,
+    biddingIndex: 0,
+    seatAssignments: Array.from({ length: state.players.length }, () => null),
+    seatBonuses: getSeatBonuses(state),
+  };
+}
+
+export function getSeatNumberForPlayer(draft: InitiativeDraftState, playerId: PlayerId) {
+  const seatIndex = draft.seatAssignments.findIndex((assignedPlayerId) => assignedPlayerId === playerId);
+  return seatIndex === -1 ? null : seatIndex + 1;
+}
--- a/src/engine/rules-scoring.ts
+++ b/src/engine/rules-scoring.ts
@@ -0,0 +1,453 @@
+import type {
+	EnergySimulation,
+	GameState,
+	NodeKey,
+	PlayerId,
+	RootBurst,
+	RoundAnimation,
+} from "./types";
+import { keyFor, parseKey, shuffleArray } from "./utils";
+import { buildChildrenMap, buildParentMap } from "./rules-board";
+
+function getColumnRegion(state: GameState, column: number) {
+	const third = state.config.columns / 3;
+	if (column < third) {
+		return "left";
+	}
+
+	if (column >= state.config.columns - third) {
+		return "right";
+	}
+
+	return "center";
+}
+
+function getLeafCounts(state: GameState) {
+	const childrenMap = buildChildrenMap(state);
+	const counts = state.players.map(() => 0);
+
+	Array.from(state.nodes.entries()).forEach(([nodeKey, node]) => {
+		if (!childrenMap.get(nodeKey)?.length) {
+			counts[node.ownerId] += 1;
+		}
+	});
+
+	return counts;
+}
+
+function getColumnPresence(state: GameState, column: number) {
+	const owners = new Set<PlayerId>();
+
+	for (let row = 0; row < state.config.rows; row += 1) {
+		const ownerId = state.nodes.get(keyFor(row, column))?.ownerId;
+		if (ownerId !== undefined) {
+			owners.add(ownerId);
+		}
+	}
+
+	return [...owners];
+}
+
+function addRoundedHalfBonus(scores: number[], counts: number[]) {
+	counts.forEach((count, playerId) => {
+		if (count > 0) {
+			scores[playerId] += Math.ceil(count * 0.5);
+		}
+	});
+}
+
+function applyColumnBaseEnergy(
+	state: GameState,
+	scores: number[],
+	ownerId: PlayerId,
+	playersPresent: PlayerId[],
+) {
+	const contested = playersPresent.length > 1;
+
+	if (!contested) {
+		scores[ownerId] += 1;
+		return;
+	}
+
+	if (state.activeRoundEffects.includes("stalemate")) {
+		return;
+	}
+
+	if (state.activeRoundEffects.includes("split_light")) {
+		playersPresent.forEach((playerId) => {
+			scores[playerId] += 1;
+		});
+		return;
+	}
+
+	scores[ownerId] += 1;
+}
+
+function applyWeatherEffects(
+	state: GameState,
+	scores: number[],
+	energySimulation: EnergySimulation,
+) {
+	if (state.activeRoundEffects.length === 0) {
+		return;
+	}
+
+	const leafCounts = getLeafCounts(state);
+	const childrenMap = buildChildrenMap(state);
+	const tallestLeaves = state.players.map(() => null as number | null);
+
+	Array.from(state.nodes.entries()).forEach(([nodeKey, node]) => {
+		const leafCount = leafCounts[node.ownerId];
+		if (leafCount <= 0) {
+			return;
+		}
+
+		if (childrenMap.get(nodeKey)?.length) {
+			return;
+		}
+
+		const { row } = parseKey(nodeKey);
+		const currentTallest = tallestLeaves[node.ownerId];
+		if (currentTallest === null || row < currentTallest) {
+			tallestLeaves[node.ownerId] = row;
+		}
+	});
+
+	state.activeRoundEffects.forEach((effectId) => {
+		if (effectId === "leaf_surge") {
+			leafCounts.forEach((count, playerId) => {
+				scores[playerId] += count;
+			});
+			return;
+		}
+
+		if (effectId === "branching_season") {
+			// Find the player with the most leaves
+			let maxLeaves = 0;
+			let playerWithMostLeaves = -1;
+
+			leafCounts.forEach((count, playerId) => {
+				scores[playerId] += Math.max(0, count - 1);
+				if (count > maxLeaves) {
+					maxLeaves = count;
+					playerWithMostLeaves = playerId;
+				}
+			});
+
+			// Give the player with most leaves 50% more energy (rounded down)
+			if (playerWithMostLeaves !== -1 && maxLeaves > 1) {
+				const bonus = Math.floor((maxLeaves - 1) * 0.5);
+				scores[playerWithMostLeaves] += bonus;
+			}
+			return;
+		}
+
+		if (effectId === "tall_reward" || effectId === "deep_roots") {
+			const bestRow = tallestLeaves.reduce<number | null>(
+				(currentBest, row) => {
+					if (row === null) {
+						return currentBest;
+					}
+
+					if (
+						(effectId === "deep_roots" &&
+							(currentBest === null || row > currentBest)) ||
+						(effectId === "tall_reward" &&
+							(currentBest === null || row < currentBest))
+					) {
+						return row;
+					}
+
+					return currentBest;
+				},
+				null,
+			);
+
+			if (bestRow !== null) {
+				tallestLeaves.forEach((row, playerId) => {
+					if (row === bestRow) {
+						scores[playerId] += effectId === "deep_roots" ? 4 : 2;
+					}
+				});
+			}
+			return;
+		}
+
+		if (effectId === "wide_reach") {
+			const maxScore = Math.max(...energySimulation.scores);
+			energySimulation.scores.forEach((score, playerId) => {
+				if (score === maxScore && maxScore > 0) {
+					scores[playerId] += 2;
+				}
+			});
+			return;
+		}
+
+		const westLightCounts = state.players.map(() => 0);
+		const eastLightCounts = state.players.map(() => 0);
+		const highNoonCounts = state.players.map(() => 0);
+
+		energySimulation.columns.forEach((column) => {
+			if (!column.intercepted || column.ownerId === null) {
+				return;
+			}
+
+			const region = getColumnRegion(state, column.column);
+			if (region === "left") {
+				westLightCounts[column.ownerId] += 1;
+			}
+			if (region === "right") {
+				eastLightCounts[column.ownerId] += 1;
+			}
+			if (region === "center") {
+				highNoonCounts[column.ownerId] += 1;
+			}
+			if (
+				effectId === "edge_bloom" &&
+				(column.column === 0 || column.column === state.config.columns - 1)
+			) {
+				scores[column.ownerId] += 1;
+			}
+		});
+
+		if (effectId === "west_light") {
+			addRoundedHalfBonus(scores, westLightCounts);
+		}
+		if (effectId === "east_light") {
+			addRoundedHalfBonus(scores, eastLightCounts);
+		}
+		if (effectId === "high_noon") {
+			addRoundedHalfBonus(scores, highNoonCounts);
+		}
+	});
+}
+
+export function buildEnergySimulation(state: GameState): EnergySimulation {
+	const parentMap = buildParentMap(state);
+	const columns = [];
+	const scores = state.players.map(() => 0);
+
+	for (let column = 0; column < state.config.columns; column += 1) {
+		let hitNodeKey: NodeKey | null = null;
+
+		for (let row = 0; row < state.config.rows; row += 1) {
+			const nodeKey = keyFor(row, column);
+			if (state.nodes.has(nodeKey)) {
+				hitNodeKey = nodeKey;
+				break;
+			}
+		}
+
+		if (!hitNodeKey) {
+			columns.push({
+				column,
+				terminalRow: state.config.rows - 1,
+				intercepted: false,
+				ownerId: null,
+				playersPresent: [],
+				hitNode: null,
+				rootKey: null,
+				branchNodes: [],
+				branchEdges: [],
+			});
+			continue;
+		}
+
+		const hitNode = parseKey(hitNodeKey);
+		const ownerId = state.nodes.get(hitNodeKey)?.ownerId as PlayerId;
+		const playersPresent = getColumnPresence(state, column);
+		const branchNodes = [hitNode];
+		const branchEdges = [];
+		let cursor = hitNodeKey;
+
+		while (parentMap.has(cursor)) {
+			const parentKey = parentMap.get(cursor) as NodeKey;
+			branchEdges.push({ from: parseKey(cursor), to: parseKey(parentKey) });
+			branchNodes.push(parseKey(parentKey));
+			cursor = parentKey;
+		}
+
+		applyColumnBaseEnergy(state, scores, ownerId, playersPresent);
+		columns.push({
+			column,
+			terminalRow: hitNode.row,
+			intercepted: true,
+			ownerId,
+			playersPresent,
+			hitNode,
+			rootKey: cursor,
+			branchNodes,
+			branchEdges,
+		});
+	}
+
+	const rootBurstMap = columns.reduce((map, column) => {
+		if (!column.intercepted || !column.rootKey) {
+			return map;
+		}
+
+		const entry = map.get(column.rootKey) ?? {
+			key: column.rootKey,
+			playerId: column.ownerId as PlayerId,
+			count: 0,
+			displayCount: 0,
+		};
+		entry.count += 1;
+		map.set(column.rootKey, entry);
+		return map;
+	}, new Map<NodeKey, RootBurst>());
+	const rootBursts: RootBurst[] = [...rootBurstMap.values()];
+
+	applyWeatherEffects(state, scores, { scores, columns, rootBursts });
+
+	const playerRootTotals = state.players.map(() => 0);
+	rootBursts.forEach((burst) => {
+		playerRootTotals[burst.playerId] += burst.count;
+	});
+
+	const playerLargestBurst = new Map<PlayerId, RootBurst>();
+	rootBursts.forEach((burst) => {
+		const current = playerLargestBurst.get(burst.playerId);
+		if (!current || burst.count > current.count) {
+			playerLargestBurst.set(burst.playerId, burst);
+		}
+	});
+
+	rootBursts.forEach((burst) => {
+		burst.displayCount = burst.count;
+	});
+
+	state.players.forEach((player) => {
+		const largestBurst = playerLargestBurst.get(player.id);
+		if (!largestBurst) {
+			return;
+		}
+
+		const extraEarned = scores[player.id] - playerRootTotals[player.id] + 1;
+		largestBurst.displayCount += extraEarned;
+	});
+
+	return {
+		scores,
+		columns,
+		rootBursts,
+	};
+}
+
+export function buildRoundAnimation(
+	state: GameState,
+	energySimulation: EnergySimulation,
+	sunbeamPlayerId: PlayerId | null,
+	diseaseKeys: NodeKey[],
+): RoundAnimation {
+	const traces = energySimulation.columns
+		.filter((column) => column.intercepted)
+		.map((column) => ({
+			playerId: column.ownerId as PlayerId,
+			verticalCells: Array.from(
+				{ length: column.terminalRow + 1 },
+				(_, row) => ({ row, column: column.column }),
+			),
+			ray: {
+				x: ((column.column + 0.5) / state.config.columns) * 100,
+				y: ((column.terminalRow + 0.5) / state.config.rows) * 100,
+			},
+			rootKey: column.rootKey,
+			branchNodes: column.branchNodes,
+		}));
+
+	const bonusTrace =
+		sunbeamPlayerId === null
+			? null
+			: (traces.find((trace) => trace.playerId === sunbeamPlayerId) ?? null);
+	const bonusBurst = bonusTrace
+		? (energySimulation.rootBursts.find(
+				(burst) => burst.key === bonusTrace.rootKey,
+			) ?? null)
+		: null;
+
+	return {
+		phase: "sunlight",
+		columns: energySimulation.columns,
+		traces,
+		rootBursts: energySimulation.rootBursts,
+		sunbeamPlayerId,
+		bonusTrace,
+		bonusBurst,
+		diseaseKeys,
+	};
+}
+
+export function scoreColumns(state: GameState) {
+	const energySimulation = buildEnergySimulation(state);
+	const columnResults = energySimulation.columns.map((column) => ({
+		column: column.column,
+		ownerId: column.ownerId,
+		topRow: column.intercepted ? column.terminalRow : null,
+		tied: false,
+	}));
+
+	return { scores: energySimulation.scores, columnResults, energySimulation };
+}
+
+export function maybeRollSunbeam(state: GameState, scores: number[]) {
+	const nextGrowth = scores.map((score) => score + 1);
+	const { sunbeamChance } = state.randomEffects;
+
+	if (sunbeamChance <= 0 || Math.random() * 100 >= sunbeamChance) {
+		return {
+			nextGrowth,
+			event: null,
+			awardedPlayer: null,
+		};
+	}
+
+	const awardedPlayer = Math.floor(Math.random() * state.players.length);
+	nextGrowth[awardedPlayer] += 1;
+
+	return {
+		nextGrowth,
+		awardedPlayer,
+		event: `${state.players[awardedPlayer].name} caught a stray sunbeam and gains +1 growth next round.`,
+	};
+}
+
+export function maybeRollDisease(state: GameState) {
+	const { diseaseChance } = state.randomEffects;
+	if (diseaseChance <= 0 || Math.random() * 100 >= diseaseChance) {
+		return {
+			killedKeys: [],
+			event: null,
+		};
+	}
+
+	const childrenMap = buildChildrenMap(state);
+	const parentMap = buildParentMap(state);
+	const twigKeys = Array.from(state.nodes.keys()).filter((nodeKey) => {
+		const { row } = parseKey(nodeKey);
+		return (
+			row !== state.config.rows - 1 &&
+			!childrenMap.has(nodeKey) &&
+			parentMap.has(nodeKey)
+		);
+	});
+
+	if (twigKeys.length === 0) {
+		return {
+			killedKeys: [],
+			event: null,
+		};
+	}
+
+	const shuffled = shuffleArray(twigKeys);
+	const killCount = Math.min(
+		shuffled.length,
+		1 + Math.floor(Math.random() * Math.min(3, shuffled.length)),
+	);
+	const killedKeys = shuffled.slice(0, killCount);
+
+	return {
+		killedKeys,
+		event: `Disease spread through ${killCount} twig node${killCount === 1 ? "" : "s"} before the next round.`,
+	};
+}
--- a/src/engine/rules-weather.ts
+++ b/src/engine/rules-weather.ts
@@ -0,0 +1,83 @@
+import type { GameState, PlayerId, WeatherCardDefinition, WeatherCardId, WeatherDraftState, WeatherOfferPair } from "./types";
+import { shuffleArray } from "./utils";
+
+export const WEATHER_CARDS: WeatherCardDefinition[] = [
+  { id: "leaf_surge", title: "Leaf Surge", description: "Each leaf gives +1." },
+  { id: "branching_season", title: "Branching Season", description: "Each leaf after your first gives +1. Player with most branches gets 50% more energy (rounded down)." },
+  { id: "storehouse", title: "Storehouse", description: "Banked energy is safe but earns no interest. Lose 1 banked energy (min 0)." },
+  { id: "compound_interest", title: "Compound Interest", description: "Gain 20% interest on all banked energy (rounded down)." },
+  { id: "sun_ladder", title: "Sun Ladder", description: "Your first 3 vertical growths cost 0." },
+  { id: "west_light", title: "West Light", description: "Left third energy gets +50%, rounded up." },
+  { id: "east_light", title: "East Light", description: "Right third energy gets +50%, rounded up." },
+  { id: "high_noon", title: "High Noon", description: "Center third energy gets +50%, rounded up." },
+  { id: "edge_bloom", title: "Edge Bloom", description: "Edge columns give +1." },
+  { id: "wide_reach", title: "Wide Reach", description: "Most columns gets +2." },
+  { id: "tall_reward", title: "Tall Reward", description: "Tallest leaf on the board gives +2." },
+  { id: "deep_roots", title: "Deep Roots", description: "Shortest plant receives +4 energy." },
+  { id: "stalemate", title: "Stalemate", description: "Contested columns give no energy." },
+  { id: "split_light", title: "Split Light", description: "Contested columns give 1 energy to each player there." },
+];
+
+export const WEATHER_CARD_LOOKUP = new Map<WeatherCardId, WeatherCardDefinition>(
+  WEATHER_CARDS.map((card) => [card.id, card]),
+);
+
+export const WEATHER_OFFER_PAIRS: WeatherOfferPair[] = [
+  { id: "growth_mix", options: ["leaf_surge", "branching_season"] },
+  { id: "banking_mix", options: ["storehouse", "compound_interest"] },
+  { id: "tempo", options: ["sun_ladder", "edge_bloom"] },
+  { id: "side_bias", options: ["west_light", "east_light"] },
+  { id: "shape", options: ["high_noon", "wide_reach"] },
+  { id: "height", options: ["tall_reward", "deep_roots"] },
+  { id: "contest_soft", options: ["stalemate", "split_light"] },
+];
+
+export function createWeatherDraft(state: GameState): WeatherDraftState {
+  const rowSize = Math.min(WEATHER_OFFER_PAIRS.length, state.config.weatherDraftCount);
+  
+  // Rotate draft order based on round number to ensure fairness
+  const rotatedOrder = [...state.turnOrder];
+  const rotation = (state.round - 1) % state.turnOrder.length;
+  if (rotation > 0) {
+    const start = rotatedOrder.splice(0, rotation);
+    rotatedOrder.push(...start);
+  }
+
+  return {
+    playerOrder: rotatedOrder,
+    draftIndex: 0,
+    offers: shuffleArray(WEATHER_OFFER_PAIRS).slice(0, rowSize),
+    drafted: [],
+    banned: [],
+    locked: [],
+  };
+}
+
+export function getCurrentWeatherPlayerId(draft: WeatherDraftState) {
+  return draft.playerOrder[draft.draftIndex] as PlayerId;
+}
+
+export function isWeatherCardAvailable(draft: WeatherDraftState, offerId: string, cardId: WeatherCardId) {
+  const offer = draft.offers.find((entry) => entry.id === offerId);
+  if (!offer) {
+    return false;
+  }
+
+  return offer.options.includes(cardId)
+    && !draft.banned.includes(cardId)
+    && !draft.drafted.includes(cardId)
+    && !draft.locked.includes(cardId);
+}
+
+export function isWeatherOfferResolved(draft: WeatherDraftState, offerId: string) {
+  const offer = draft.offers.find((entry) => entry.id === offerId);
+  if (!offer) {
+    return true;
+  }
+
+  return offer.options.some((cardId) => draft.banned.includes(cardId) || draft.drafted.includes(cardId));
+}
+
+export function getWeatherCard(cardId: WeatherCardId) {
+  return WEATHER_CARD_LOOKUP.get(cardId) ?? null;
+}
--- a/src/engine/state.ts
+++ b/src/engine/state.ts
@@ -0,0 +1,263 @@
+import { PLAYER_PALETTE, STARTING_POINTS } from "./constants";
+import type { GameState, Player, SetupState } from "./types";
+import { keyFor } from "./utils";
+
+export function createDefaultPaletteOrder(playerCount: number) {
+  return Array.from({ length: playerCount }, (_, index) => index % PLAYER_PALETTE.length);
+}
+
+function getMinimumColumnsForEvenSpacing(playerCount: number, minColumns: number): number {
+  // We need columns to be divisible by (playerCount + 1) for even spacing
+  // Each player needs at least 1 column, so minimum is playerCount
+  // But for even spacing from edges, we need: columns % (playerCount + 1) === 0
+  const spacingDivisor = playerCount + 1;
+
+  // Start from at least minColumns or playerCount (whichever is larger)
+  let columns = Math.max(minColumns, playerCount);
+
+  // Increase columns until it's divisible by (playerCount + 1)
+  while (columns % spacingDivisor !== 0) {
+    columns += 1;
+  }
+
+  return columns;
+}
+
+export function createDefaultSeedInputs(playerCount: number, columns: number, startingNodesPerPlayer: number) {
+  // Calculate spacing to place players equidistant from each other and edges
+  // Formula: space = columns / (playerCount + 1)
+  // This ensures equal spacing between players and from edges
+  const spacing = columns / (playerCount + 1);
+
+  return Array.from({ length: playerCount }, (_, playerId) => {
+    const playerCenter = Math.round((playerId + 1) * spacing);
+
+    // For multiple seeds per player, spread them around the center
+    if (startingNodesPerPlayer === 1) {
+      return String(playerCenter + 1);
+    }
+
+    // For multiple seeds, alternate left and right from center
+    const positions = [];
+    for (let i = 0; i < startingNodesPerPlayer; i++) {
+      // Alternate: 0, +1, -1, +2, -2, etc.
+      const offset = i === 0 ? 0 : (i % 2 === 1 ? Math.ceil(i / 2) : -Math.ceil(i / 2));
+      const pos = Math.max(1, Math.min(columns, playerCenter + offset + 1));
+      positions.push(pos);
+    }
+
+    return positions.join(", ");
+  });
+}
+
+function pickNearestOpenColumn(preferredColumn: number, columns: number, usedColumns: Set<number>) {
+  if (!usedColumns.has(preferredColumn)) {
+    return preferredColumn;
+  }
+
+  for (let distance = 1; distance < columns; distance += 1) {
+    const left = preferredColumn - distance;
+    if (left >= 0 && !usedColumns.has(left)) {
+      return left;
+    }
+
+    const right = preferredColumn + distance;
+    if (right < columns && !usedColumns.has(right)) {
+      return right;
+    }
+  }
+
+  return preferredColumn;
+}
+
+export function createRandomizedSeedInputs(playerCount: number, columns: number, startingNodesPerPlayer: number) {
+  const zoneWidth = columns / playerCount;
+  const usedColumns = new Set<number>();
+
+  return Array.from({ length: playerCount }, (_, playerId) => {
+    const picks: number[] = [];
+
+    for (let seedIndex = 0; seedIndex < startingNodesPerPlayer; seedIndex += 1) {
+      const localRatio = (seedIndex + 1) / (startingNodesPerPlayer + 1);
+      const center = (playerId + localRatio) * zoneWidth;
+      const subZoneWidth = zoneWidth / (startingNodesPerPlayer + 1);
+      const maxJitter = Math.max(0.35, Math.min(zoneWidth * 0.22, subZoneWidth * 0.42));
+      const jitter = (Math.random() * 2 - 1) * maxJitter;
+      const preferredColumn = Math.max(0, Math.min(columns - 1, Math.round(center + jitter - 0.5)));
+      const chosenColumn = pickNearestOpenColumn(preferredColumn, columns, usedColumns);
+
+      usedColumns.add(chosenColumn);
+      picks.push(chosenColumn + 1);
+    }
+
+    return picks.sort((left, right) => left - right).join(", ");
+  });
+}
+
+export function getMaxStartingNodesPerPlayer(playerCount: number, columns: number) {
+  return Math.max(1, Math.floor(columns / playerCount));
+}
+
+export function createSetupState(
+  playerCount = 2,
+  playerNames: string[] | null = null,
+  columns = 18,
+  rows = 16,
+  startingNodesPerPlayer = 1,
+  sunbeamChance = 0,
+  diseaseChance = 0,
+  seedInputs: string[] | null = null,
+  paletteOrder: number[] | null = null,
+  initiativeMode: SetupState["initiativeMode"] = "fixed",
+  biddingOrderRule: SetupState["biddingOrderRule"] = "rotating",
+  weatherDraftEnabled = true,
+  weatherDraftCount = playerCount,
+  bankingEnabled = true,
+  winCondition: SetupState["winCondition"] = "rounds",
+  maxRounds = 12,
+  topLeafTarget = 4,
+): SetupState {
+  // Adjust columns to ensure even spacing between players and edges
+  const adjustedColumns = getMinimumColumnsForEvenSpacing(playerCount, columns);
+
+  const clampedSeeds = Math.min(startingNodesPerPlayer, getMaxStartingNodesPerPlayer(playerCount, adjustedColumns));
+  const defaults = createDefaultSeedInputs(playerCount, adjustedColumns, clampedSeeds);
+  const paletteDefaults = createDefaultPaletteOrder(playerCount);
+
+  return {
+    playerCount,
+    playerNames: Array.from({ length: playerCount }, (_, index) => playerNames?.[index] ?? `Player ${index + 1}`),
+    columns: adjustedColumns,
+    rows,
+    startingNodesPerPlayer: clampedSeeds,
+    sunbeamChance,
+    diseaseChance,
+    seedInputs: Array.from({ length: playerCount }, (_, index) => seedInputs?.[index] ?? defaults[index]),
+    paletteOrder: Array.from({ length: playerCount }, (_, index) => paletteOrder?.[index] ?? paletteDefaults[index]),
+    initiativeMode,
+    biddingOrderRule,
+    weatherDraftEnabled,
+    weatherDraftCount: Math.max(1, weatherDraftCount),
+    bankingEnabled,
+    winCondition,
+    maxRounds,
+    topLeafTarget: Math.max(1, Math.min(adjustedColumns, topLeafTarget)),
+  };
+}
+
+export function createPlayers(
+  playerCount: number,
+  paletteOrder = createDefaultPaletteOrder(playerCount),
+  playerNames: string[] = Array.from({ length: playerCount }, (_, index) => `Player ${index + 1}`),
+): Player[] {
+  return Array.from({ length: playerCount }, (_, index) => {
+    const palette = PLAYER_PALETTE[paletteOrder[index] % PLAYER_PALETTE.length];
+    return {
+      id: index,
+      name: playerNames[index] ?? `Player ${index + 1}`,
+      color: palette.primary,
+      glow: palette.glow,
+      totalScore: 0,
+      roundScore: 0,
+      growthPoints: STARTING_POINTS,
+      bankedPoints: 0,
+      bonusPoints: 0,
+      lifetimeGrowthIncome: STARTING_POINTS,
+      passed: false,
+    };
+  });
+}
+
+export function normalizeSeedInputs(setup: SetupState) {
+  const assigned = new Set<number>();
+  const fallback = createDefaultSeedInputs(setup.playerCount, setup.columns, setup.startingNodesPerPlayer)
+    .map((input) => input.split(",").map((part) => Number(part.trim()) - 1));
+
+  return Array.from({ length: setup.playerCount }, (_, playerId) => {
+    const requested = (setup.seedInputs[playerId] ?? "")
+      .split(",")
+      .map((part) => Number.parseInt(part.trim(), 10) - 1)
+      .filter((column) => Number.isInteger(column) && column >= 0 && column < setup.columns);
+
+    const uniqueColumns: number[] = [];
+    requested.forEach((column) => {
+      if (!assigned.has(column) && uniqueColumns.length < setup.startingNodesPerPlayer) {
+        assigned.add(column);
+        uniqueColumns.push(column);
+      }
+    });
+
+    fallback[playerId].forEach((column) => {
+      if (!assigned.has(column) && uniqueColumns.length < setup.startingNodesPerPlayer) {
+        assigned.add(column);
+        uniqueColumns.push(column);
+      }
+    });
+
+    for (let column = 0; column < setup.columns && uniqueColumns.length < setup.startingNodesPerPlayer; column += 1) {
+      if (!assigned.has(column)) {
+        assigned.add(column);
+        uniqueColumns.push(column);
+      }
+    }
+
+    return uniqueColumns;
+  });
+}
+
+export function createInitialState(setup: SetupState): GameState {
+  const playerPaletteOrder = [...setup.paletteOrder];
+  const players = createPlayers(setup.playerCount, playerPaletteOrder, setup.playerNames);
+  const turnOrder = players.map((player) => player.id);
+  const nodes = new Map();
+  const edges = [];
+  const seedColumnsByPlayer = normalizeSeedInputs(setup);
+
+  seedColumnsByPlayer.forEach((seedColumns, index) => {
+    seedColumns.forEach((column) => {
+      nodes.set(keyFor(setup.rows - 1, column), { ownerId: index });
+    });
+  });
+  return {
+    config: {
+      columns: setup.columns,
+      rows: setup.rows,
+      playerCount: setup.playerCount,
+      startingNodesPerPlayer: setup.startingNodesPerPlayer,
+      playerPaletteOrder,
+      initiativeMode: setup.initiativeMode,
+      biddingOrderRule: setup.biddingOrderRule,
+      weatherDraftEnabled: setup.weatherDraftEnabled,
+      weatherDraftCount: setup.weatherDraftCount,
+      bankingEnabled: setup.bankingEnabled,
+      winCondition: setup.winCondition,
+      maxRounds: setup.maxRounds,
+      topLeafTarget: setup.topLeafTarget,
+    },
+    players,
+    nodes,
+    edges,
+    round: 1,
+    activePlayerId: turnOrder[0],
+    turnOrder,
+    phase: setup.initiativeMode === "bid" ? "initiative" : "turn",
+    turnMoves: [],
+    selectedSource: null,
+    availableTargets: [],
+    animation: null,
+    initiativeAnchorPlayerId: Math.floor(Math.random() * players.length),
+    initiativeDraft: null,
+    weatherDraft: null,
+    activeRoundEffects: [],
+    randomEffects: {
+      sunbeamChance: setup.sunbeamChance,
+      diseaseChance: setup.diseaseChance,
+    },
+    gameOver: false,
+    history: [
+      `Round 1 begins on a ${setup.columns}x${setup.rows} board with ${setup.startingNodesPerPlayer} starting node${setup.startingNodesPerPlayer === 1 ? "" : "s"} each.`,
+      "Turn order uses the setup order unless changed by initiative drafting.",
+    ],
+    roundSummary: null,
+  };
+}
--- a/src/engine/types.ts
+++ b/src/engine/types.ts
@@ -0,0 +1,254 @@
+export type PlayerId = number;
+export type NodeKey = `${number}:${number}`;
+
+export type PlayerPalette = {
+  name: string;
+  primary: string;
+  glow: string;
+};
+
+export type Position = {
+  row: number;
+  column: number;
+};
+
+export type SetupState = {
+  playerCount: number;
+  playerNames: string[];
+  columns: number;
+  rows: number;
+  startingNodesPerPlayer: number;
+  sunbeamChance: number;
+  diseaseChance: number;
+  seedInputs: string[];
+  paletteOrder: number[];
+  initiativeMode: "fixed" | "bid";
+  biddingOrderRule: "rotating" | "lowest_growth_income";
+  weatherDraftEnabled: boolean;
+  weatherDraftCount: number;
+  bankingEnabled: boolean;
+  winCondition: "rounds" | "top_leaves";
+  maxRounds: number;
+  topLeafTarget: number;
+};
+
+export type Player = {
+  id: PlayerId;
+  name: string;
+  color: string;
+  glow: string;
+  totalScore: number;
+  roundScore: number;
+  growthPoints: number;
+  bankedPoints: number;
+  bonusPoints: number;
+  lifetimeGrowthIncome: number;
+  passed: boolean;
+};
+
+export type GameConfig = {
+  columns: number;
+  rows: number;
+  playerCount: number;
+  startingNodesPerPlayer: number;
+  playerPaletteOrder: number[];
+  initiativeMode: SetupState["initiativeMode"];
+  biddingOrderRule: SetupState["biddingOrderRule"];
+  weatherDraftEnabled: boolean;
+  weatherDraftCount: number;
+  bankingEnabled: boolean;
+  winCondition: SetupState["winCondition"];
+  maxRounds: number;
+  topLeafTarget: number;
+};
+
+export type NodeState = {
+  ownerId: PlayerId;
+};
+
+export type Edge = {
+  from: Position;
+  to: Position;
+  ownerId: PlayerId;
+};
+
+export type GrowDirection = "vertical" | "left" | "right";
+
+export type GrowTarget = Position & {
+  cost: number;
+  direction: GrowDirection;
+};
+
+export type ShiftMove = {
+  type: "shift";
+  cost: number;
+  direction: "left" | "right";
+  movedNodes: Array<{
+    fromKey: NodeKey;
+    toKey: NodeKey;
+    row: number;
+    fromColumn: number;
+    toColumn: number;
+  }>;
+  movedEdges: Array<{
+    before: Edge;
+    after: Edge;
+  }>;
+  undoKeys: NodeKey[];
+  selectKey: NodeKey;
+};
+
+export type GrowMove = {
+  type: "grow";
+  from: Position;
+  to: Position;
+  cost: number;
+  targetKey: NodeKey;
+  undoKeys: NodeKey[];
+  selectKey: NodeKey;
+};
+
+export type TurnMove = GrowMove | ShiftMove;
+
+export type ColumnEnergy = {
+  column: number;
+  terminalRow: number;
+  intercepted: boolean;
+  ownerId: PlayerId | null;
+  playersPresent: PlayerId[];
+  hitNode: Position | null;
+  rootKey: NodeKey | null;
+  branchNodes: Position[];
+  branchEdges: Array<{ from: Position; to: Position }>;
+};
+
+export type RootBurst = {
+  key: NodeKey;
+  playerId: PlayerId;
+  count: number;
+  displayCount: number;
+};
+
+export type EnergySimulation = {
+  scores: number[];
+  columns: ColumnEnergy[];
+  rootBursts: RootBurst[];
+};
+
+export type RoundAnimationTrace = {
+  playerId: PlayerId;
+  verticalCells: Position[];
+  ray: { x: number; y: number };
+  rootKey: NodeKey | null;
+  branchNodes: Position[];
+};
+
+export type RoundAnimation = {
+  phase: "sunlight" | "branches" | "bonus" | "events";
+  columns: ColumnEnergy[];
+  traces: RoundAnimationTrace[];
+  rootBursts: RootBurst[];
+  sunbeamPlayerId: PlayerId | null;
+  bonusTrace: RoundAnimationTrace | null;
+  bonusBurst: RootBurst | null;
+  diseaseKeys: NodeKey[];
+};
+
+export type ColumnResult = {
+  column: number;
+  ownerId: PlayerId | null;
+  topRow: number | null;
+  tied: boolean;
+};
+
+export type RoundSummary = {
+  scores: number[];
+  columnResults: ColumnResult[];
+  event: string | null;
+};
+
+export type ScoreSnapshot = {
+  projectedIncome: number;
+  growthPoints: number;
+  bankedPoints: number;
+  lifetimeGrowthIncome: number;
+};
+
+export type ColumnLeader = {
+  ownerId: PlayerId | null;
+  row: number | null;
+  tied: boolean;
+};
+
+export type RandomEffects = {
+  sunbeamChance: number;
+  diseaseChance: number;
+};
+
+export type GamePhase = "initiative" | "turn" | "round_end" | "game_over";
+
+export type WeatherCardId =
+  | "leaf_surge"
+  | "branching_season"
+  | "storehouse"
+  | "compound_interest"
+  | "sun_ladder"
+  | "west_light"
+  | "east_light"
+  | "high_noon"
+  | "edge_bloom"
+  | "wide_reach"
+  | "tall_reward"
+  | "deep_roots"
+  | "stalemate"
+  | "split_light";
+
+export type WeatherCardDefinition = {
+  id: WeatherCardId;
+  title: string;
+  description: string;
+};
+
+export type WeatherOfferPair = {
+  id: string;
+  options: [WeatherCardId, WeatherCardId];
+};
+
+export type InitiativeDraftState = {
+  biddingOrder: PlayerId[];
+  biddingIndex: number;
+  seatAssignments: Array<PlayerId | null>;
+  seatBonuses: number[];
+};
+
+export type WeatherDraftState = {
+  playerOrder: PlayerId[];
+  draftIndex: number;
+  offers: WeatherOfferPair[];
+  drafted: WeatherCardId[];
+  banned: WeatherCardId[];
+  locked: WeatherCardId[];
+};
+
+export type GameState = {
+  config: GameConfig;
+  players: Player[];
+  nodes: Map<NodeKey, NodeState>;
+  edges: Edge[];
+  round: number;
+  activePlayerId: PlayerId;
+  turnOrder: PlayerId[];
+  phase: GamePhase | "weather";
+  turnMoves: TurnMove[];
+  selectedSource: NodeKey | null;
+  availableTargets: GrowTarget[];
+  animation: RoundAnimation | null;
+  initiativeAnchorPlayerId: PlayerId;
+  initiativeDraft: InitiativeDraftState | null;
+  weatherDraft: WeatherDraftState | null;
+  activeRoundEffects: WeatherCardId[];
+  randomEffects: RandomEffects;
+  gameOver: boolean;
+  history: string[];
+  roundSummary: RoundSummary | null;
+};
--- a/src/engine/utils.ts
+++ b/src/engine/utils.ts
@@ -0,0 +1,41 @@
+import type { NodeKey, Position } from "./types";
+
+export function keyFor(row: number, column: number): NodeKey {
+  return `${row}:${column}`;
+}
+
+export function parseKey(key: string): Position {
+  const [row, column] = key.split(":").map(Number);
+  return { row, column };
+}
+
+export function hexToRgb(hex: string) {
+  const value = hex.replace("#", "");
+  const normalized = value.length === 3 ? value.split("").map((part) => part + part).join("") : value;
+  const int = Number.parseInt(normalized, 16);
+  return {
+    r: (int >> 16) & 255,
+    g: (int >> 8) & 255,
+    b: int & 255,
+  };
+}
+
+export function tint(hex: string, alpha = 0.16) {
+  const { r, g, b } = hexToRgb(hex);
+  return `rgba(${r}, ${g}, ${b}, ${alpha})`;
+}
+
+export function wait(milliseconds: number) {
+  return new Promise<void>((resolve) => window.setTimeout(resolve, milliseconds));
+}
+
+export function shuffleArray<T>(items: T[]) {
+  const next = [...items];
+
+  for (let index = next.length - 1; index > 0; index -= 1) {
+    const swapIndex = Math.floor(Math.random() * (index + 1));
+    [next[index], next[swapIndex]] = [next[swapIndex], next[index]];
+  }
+
+  return next;
+}
--- a/src/main.js
+++ b/src/main.js
--- a/src/main.ts
+++ b/src/main.ts
--- a/src/styles.css
+++ b/src/styles.css
@@ -1,684 +0,0 @@
-:root {
-  color-scheme: dark;
-  font-family: Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
-  background:
-    radial-gradient(circle at top, rgba(48, 72, 104, 0.35), transparent 42%),
-    linear-gradient(180deg, #0b1220 0%, #070b13 100%);
-  color: #f4f7fb;
-}
-
-* {
-  box-sizing: border-box;
-}
-
-body {
-  margin: 0;
-  min-height: 100vh;
-  background: transparent;
-}
-
-button,
-input {
-  font: inherit;
-}
-
-input[type="number"],
-input[type="text"] {
-  width: 100%;
-  min-height: 2.8rem;
-  padding: 0.7rem 0.85rem;
-  border-radius: 0.9rem;
-  border: 1px solid rgba(255, 255, 255, 0.12);
-  background: rgba(255, 255, 255, 0.05);
-  color: #f4f7fb;
-}
-
-button {
-  border: 0;
-  cursor: pointer;
-}
-
-#app {
-  min-height: 100vh;
-}
-
-.layout {
-  min-height: 100vh;
-  padding: 1rem;
-  display: flex;
-  flex-direction: column;
-  gap: 0.85rem;
-}
-
-.scoreboard {
-  display: grid;
-  grid-template-columns: repeat(auto-fit, minmax(220px, 1fr));
-  gap: 0.75rem;
-}
-
-.scoreboard--bottom {
-  align-items: end;
-}
-
-.score-card {
-  border: 1px solid rgba(255, 255, 255, 0.1);
-  border-radius: 1.25rem;
-  padding: 0.8rem 1rem;
-  background: linear-gradient(180deg, rgba(255, 255, 255, 0.08), rgba(255, 255, 255, 0.02));
-  box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.06);
-}
-
-.score-card.active {
-  border-color: color-mix(in srgb, var(--player-color) 55%, white);
-  box-shadow: 0 0 0 1px rgba(255, 255, 255, 0.08), 0 0 24px var(--player-glow);
-}
-
-.score-card__head,
-.score-card__numbers,
-.panel__title-row,
-.button-row,
-.setup-grid,
-.toggle-row,
-.active-turn {
-  display: flex;
-  align-items: center;
-}
-
-.score-card__head,
-.panel__title-row,
-.button-row,
-.toggle-row {
-  justify-content: space-between;
-}
-
-.score-card__head h2,
-.panel h1,
-.panel h2,
-.active-turn h2 {
-  margin: 0;
-}
-
-.score-card__numbers {
-  margin-top: 0.65rem;
-  gap: 1rem;
-}
-
-.score-card__numbers div {
-  display: grid;
-  gap: 0.15rem;
-}
-
-.score-card__numbers span,
-.eyebrow,
-label span,
-.log-list p,
-.status-panel p,
-.active-turn p {
-  color: rgba(231, 238, 247, 0.72);
-}
-
-.score-card__numbers strong {
-  font-size: 1.35rem;
-}
-
-.score-value {
-  display: inline-block;
-}
-
-.score-value.changed {
-  animation: score-pop 0.7s ease;
-}
-
-.player-dot {
-  width: 0.95rem;
-  height: 0.95rem;
-  border-radius: 999px;
-  background: var(--player-color);
-  box-shadow: 0 0 18px var(--player-glow);
-}
-
-.game-area {
-  flex: 1;
-  display: grid;
-  grid-template-columns: minmax(0, 1.9fr) minmax(320px, 0.85fr);
-  gap: 0.85rem;
-  min-height: 0;
-  align-items: start;
-}
-
-.board-shell,
-.panel {
-  border-radius: 1.5rem;
-  border: 1px solid rgba(255, 255, 255, 0.08);
-  background: rgba(9, 16, 29, 0.72);
-  backdrop-filter: blur(20px);
-}
-
-.board-shell {
-  min-height: 0;
-  padding: 0.8rem;
-}
-
-.board {
-  position: relative;
-  width: 100%;
-  height: auto;
-  max-height: calc(100vh - 10.5rem);
-  aspect-ratio: var(--board-columns) / var(--board-rows);
-  display: grid;
-  gap: 0.32rem;
-  margin: 0 auto;
-}
-
-.board__lines {
-  position: absolute;
-  inset: 0;
-  width: 100%;
-  height: 100%;
-  pointer-events: none;
-  filter: drop-shadow(0 0 8px rgba(255, 255, 255, 0.18));
-  z-index: 1;
-}
-
-.board__fx {
-  position: absolute;
-  inset: 0;
-  width: 100%;
-  height: 100%;
-  pointer-events: none;
-  z-index: 4;
-}
-
-.cell {
-  position: relative;
-  background: rgba(255, 255, 255, 0.03);
-  border-radius: 0.8rem;
-  border: 1px solid rgba(255, 255, 255, 0.05);
-  overflow: hidden;
-  z-index: 2;
-}
-
-.cell__shade {
-  position: absolute;
-  inset: 0;
-  background: linear-gradient(180deg, rgba(255, 255, 255, 0.03), var(--column-tint));
-}
-
-.cell__root-ring {
-  position: absolute;
-  inset: 18% 18%;
-  border: 1px dashed rgba(255, 255, 255, 0.28);
-  border-radius: 999px;
-}
-
-.cell__node,
-.cell__target-label {
-  position: absolute;
-  inset: 50% auto auto 50%;
-  transform: translate(-50%, -50%);
-}
-
-.cell__node {
-  width: min(2.5vw, 1.6rem);
-  height: min(2.5vw, 1.6rem);
-  min-width: 1rem;
-  min-height: 1rem;
-  border-radius: 50%;
-  background: var(--node-color);
-  box-shadow: 0 0 0 0.2rem rgba(255, 255, 255, 0.06), 0 0 1.2rem var(--node-glow);
-}
-
-.cell.selected {
-  border-color: rgba(255, 255, 255, 0.55);
-  box-shadow: inset 0 0 0 1px rgba(255, 255, 255, 0.22);
-}
-
-.cell.pending {
-  border-color: rgba(255, 255, 255, 0.28);
-  box-shadow: inset 0 0 0 1px rgba(255, 255, 255, 0.12), 0 0 18px rgba(255, 255, 255, 0.08);
-}
-
-.cell.pending .cell__node {
-  box-shadow: 0 0 0 0.22rem rgba(255, 255, 255, 0.08), 0 0 1.4rem var(--node-glow), 0 0 2rem rgba(255, 255, 255, 0.08);
-}
-
-.board__drop-layer {
-  position: absolute;
-  inset: 0;
-  pointer-events: none;
-  overflow: hidden;
-  z-index: 5;
-}
-
-.board__energy-layer {
-  position: absolute;
-  inset: 0;
-  pointer-events: none;
-  z-index: 4;
-}
-
-.board__energy-cell {
-  position: absolute;
-  border-radius: 0.8rem;
-  background:
-    radial-gradient(circle at 50% 50%, rgba(255, 255, 255, 0.95), color-mix(in srgb, var(--flash-color) 70%, #ffe08a) 34%, rgba(255, 224, 138, 0.18) 72%, transparent 100%),
-    linear-gradient(180deg, rgba(255, 255, 255, 0.18), transparent);
-  box-shadow: inset 0 0 0 1px rgba(255, 255, 255, 0.12), 0 0 18px color-mix(in srgb, var(--flash-color) 55%, #ffe08a);
-  opacity: 0;
-}
-
-.board__energy-cell--sunlight {
-  inset: 12%;
-  background:
-    linear-gradient(180deg, rgba(255, 244, 214, 0.05), rgba(255, 244, 214, 0.008)),
-    radial-gradient(circle at 50% 50%, rgba(255, 242, 196, 0.11), color-mix(in srgb, var(--flash-color) 10%, #ffe3a3) 42%, rgba(255, 221, 128, 0.03) 72%, transparent 100%);
-  box-shadow: inset 0 0 0 1px rgba(255, 245, 224, 0.02), 0 0 6px color-mix(in srgb, var(--flash-color) 8%, #ffe3a3);
-}
-
-.board--sunlight .board__energy-cell--sunlight,
-.board--branches .board__energy-cell,
-.board--bonus .board__energy-cell--bonus {
-  animation: energy-cell-flash 0.48s ease forwards;
-  animation-delay: var(--flash-delay, 0ms);
-}
-
-.board__energy-cell--bonus {
-  box-shadow: inset 0 0 0 1px rgba(255, 255, 255, 0.18), 0 0 22px rgba(255, 216, 94, 0.9);
-}
-
-.board--bonus .board__drop--bonus {
-  animation: sunlight-drop 0.85s cubic-bezier(0.2, 0.7, 0.2, 1) forwards;
-}
-
-.board__drop-core,
-.board__drop-spark {
-  position: absolute;
-  inset: 0;
-  border-radius: 999px;
-}
-
-.board__drop-core {
-  background: radial-gradient(circle at 35% 30%, rgba(255, 255, 255, 0.98), color-mix(in srgb, var(--drop-color) 72%, #ffe38a) 45%, rgba(255, 227, 138, 0.18) 100%);
-  box-shadow: 0 0 18px color-mix(in srgb, var(--drop-color) 40%, #ffe38a), 0 0 32px rgba(255, 236, 174, 0.65);
-}
-
-.board__drop-spark {
-  inset: 35%;
-  border: 1px solid rgba(255, 248, 220, 0.95);
-  opacity: 0.9;
-}
-
-.board__drop-spark--a { transform: translate(-0.8rem, -0.15rem) scale(0.55); }
-.board__drop-spark--b { transform: translate(0.75rem, -0.1rem) scale(0.45); }
-.board__drop-spark--c { transform: translate(0.1rem, -0.75rem) scale(0.35); }
-
-.board__root-burst,
-.board__disease-mark,
-.board__sunbeam-burst {
-  opacity: 0;
-}
-
-.board__root-burst circle,
-.board__sunbeam-burst {
-  fill: color-mix(in srgb, var(--burst-color, #ffd85e) 70%, white);
-  stroke: rgba(255, 255, 255, 0.65);
-  stroke-width: 0.35;
-}
-
-.board__root-burst text {
-  fill: #08111c;
-  font-size: 2.1px;
-  font-weight: 800;
-}
-
-.board__disease-mark circle {
-  fill: rgba(162, 255, 142, 0.2);
-  stroke: rgba(162, 255, 142, 0.9);
-  stroke-width: 0.35;
-}
-
-.board__disease-mark path {
-  stroke: rgba(162, 255, 142, 1);
-  stroke-width: 0.5;
-  stroke-linecap: round;
-}
-
-.board--branches .board__root-burst,
-.board--events .board__root-burst,
-.board--events .board__disease-mark,
-.board--bonus .board__sunbeam-burst,
-.board--events .board__sunbeam-burst {
-  animation: pop-fade 0.8s ease forwards;
-  animation-delay: var(--trace-delay, 0ms);
-}
-
-.board__sunbeam-burst text {
-  fill: #08111c;
-  font-size: 2.1px;
-  font-weight: 800;
-}
-
-.cell.target {
-  border-color: rgba(255, 255, 255, 0.22);
-  background: rgba(255, 255, 255, 0.05);
-}
-
-.cell.target:hover {
-  transform: translateY(-1px);
-}
-
-.cell__target-label {
-  width: 2rem;
-  height: 2rem;
-  display: grid;
-  place-items: center;
-  border-radius: 999px;
-  background: rgba(255, 255, 255, 0.09);
-  border: 1px solid rgba(255, 255, 255, 0.18);
-  font-weight: 700;
-}
-
-.sidebar {
-  display: flex;
-  flex-direction: column;
-  gap: 1rem;
-}
-
-.panel {
-  padding: 1rem;
-}
-
-.controls-panel {
-  display: grid;
-  gap: 0.8rem;
-}
-
-.panel__actions {
-  display: flex;
-  gap: 0.55rem;
-}
-
-.modal-backdrop {
-  position: fixed;
-  inset: 0;
-  display: grid;
-  place-items: center;
-  padding: 1.25rem;
-  background: rgba(3, 8, 16, 0.72);
-  backdrop-filter: blur(14px);
-  z-index: 20;
-}
-
-.modal {
-  width: min(1180px, 100%);
-  max-height: min(92vh, 980px);
-  overflow: auto;
-}
-
-.modal-setup-grid,
-.modal-grid {
-  display: grid;
-  gap: 0.9rem;
-}
-
-.modal-setup-grid {
-  grid-template-columns: repeat(auto-fit, minmax(180px, 1fr));
-}
-
-.modal-grid {
-  margin-top: 0.9rem;
-  grid-template-columns: repeat(2, minmax(0, 1fr));
-}
-
-.modal-actions {
-  margin-top: 0.9rem;
-  justify-content: flex-end;
-}
-
-.eyebrow {
-  margin: 0 0 0.3rem;
-  font-size: 0.82rem;
-  letter-spacing: 0.12em;
-  text-transform: uppercase;
-}
-
-.setup-grid {
-  gap: 1rem;
-  align-items: end;
-}
-
-.setup-grid label {
-  flex: 1;
-  display: grid;
-  gap: 0.35rem;
-}
-
-.seed-editor {
-  display: grid;
-  gap: 0.65rem;
-  padding: 0.8rem;
-  border-radius: 1rem;
-  background: rgba(255, 255, 255, 0.03);
-  border: 1px solid rgba(255, 255, 255, 0.06);
-}
-
-.seed-row {
-  display: grid;
-  gap: 0.35rem;
-}
-
-.order-row,
-.order-row__label,
-.order-row__actions {
-  display: flex;
-  align-items: center;
-}
-
-.order-row {
-  justify-content: space-between;
-  gap: 0.75rem;
-}
-
-.order-row__label {
-  gap: 0.6rem;
-  font-weight: 600;
-}
-
-.order-row__actions {
-  gap: 0.4rem;
-}
-
-.mini-button {
-  min-height: 2rem;
-  padding: 0.35rem 0.65rem;
-  border-radius: 0.7rem;
-  background: rgba(255, 255, 255, 0.08);
-  color: #f4f7fb;
-  border: 1px solid rgba(255, 255, 255, 0.1);
-  font-weight: 600;
-}
-
-.seed-help {
-  margin: 0;
-  color: rgba(231, 238, 247, 0.72);
-}
-
-.randomize-button {
-  width: 100%;
-}
-
-input[type="range"] {
-  width: 100%;
-}
-
-.active-turn {
-  flex-direction: column;
-  align-items: flex-start;
-  gap: 0.35rem;
-  padding: 0.8rem;
-  border-radius: 1rem;
-  background: linear-gradient(135deg, color-mix(in srgb, var(--player-color) 22%, rgba(255, 255, 255, 0.04)), rgba(255, 255, 255, 0.04));
-  border: 1px solid color-mix(in srgb, var(--player-color) 35%, rgba(255, 255, 255, 0.08));
-}
-
-.root-shift-row {
-  display: flex;
-  gap: 0.55rem;
-  flex-wrap: wrap;
-}
-
-.root-shift-button {
-  min-height: 2.2rem;
-}
-
-.button-row {
-  gap: 0.75rem;
-}
-
-.button-row button,
-.ghost-button {
-  min-height: 2.7rem;
-  padding: 0.65rem 0.9rem;
-  border-radius: 0.95rem;
-  background: #f4f7fb;
-  color: #0a1020;
-  font-weight: 700;
-}
-
-.ghost-button,
-#finish-game {
-  background: rgba(255, 255, 255, 0.08);
-  color: #f4f7fb;
-  border: 1px solid rgba(255, 255, 255, 0.1);
-}
-
-button:disabled {
-  opacity: 0.45;
-  cursor: not-allowed;
-}
-
-.log-list {
-  display: grid;
-  gap: 0.55rem;
-  max-height: 18vh;
-  overflow: auto;
-}
-
-.log-list p,
-.status-panel p,
-.active-turn p {
-  margin: 0;
-}
-
-.event-note {
-  color: #ffd577;
-}
-
-@keyframes sunlight-drop {
-  0% {
-    opacity: 0;
-    top: -0.9rem;
-    transform: scale(0.65);
-  }
-
-  12% {
-    opacity: 1;
-  }
-
-  85% {
-    opacity: 1;
-    top: calc(var(--drop-end) - 0.55rem);
-    transform: scale(1);
-  }
-
-  100% {
-    opacity: 0;
-    top: calc(var(--drop-end) - 0.55rem);
-    transform: scale(1.25);
-  }
-}
-
-@keyframes pop-fade {
-  0% {
-    opacity: 0;
-    transform: scale(0.65);
-  }
-
-  25% {
-    opacity: 1;
-    transform: scale(1);
-  }
-
-  100% {
-    opacity: 1;
-    transform: scale(1);
-  }
-}
-
-@keyframes energy-cell-flash {
-  0% {
-    opacity: 0;
-  }
-
-  20% {
-    opacity: 0.98;
-  }
-
-  100% {
-    opacity: 0;
-  }
-}
-
-@keyframes score-pop {
-  0% {
-    transform: scale(0.88);
-    color: #fff7d6;
-    text-shadow: 0 0 0 rgba(255, 235, 153, 0);
-  }
-
-  35% {
-    transform: scale(1.18);
-    color: #ffe480;
-    text-shadow: 0 0 16px rgba(255, 228, 128, 0.9);
-  }
-
-  100% {
-    transform: scale(1);
-    color: inherit;
-    text-shadow: 0 0 0 rgba(255, 235, 153, 0);
-  }
-}
-
-@media (max-width: 1100px) {
-  .game-area {
-    grid-template-columns: 1fr;
-  }
-
-  .modal-grid {
-    grid-template-columns: 1fr;
-  }
-
-  .board {
-    max-height: none;
-    width: 100%;
-  }
-}
-
-@media (max-width: 720px) {
-  .layout {
-    padding: 1rem;
-  }
-
-  .scoreboard {
-    grid-template-columns: repeat(2, minmax(0, 1fr));
-  }
-
-  .score-card__numbers {
-    gap: 1rem;
-  }
-
-  .cell__node {
-    width: 1rem;
-    height: 1rem;
-  }
-}
--- a/src/styles/globals.css
+++ b/src/styles/globals.css
--- a/src/vite-env.d.ts
+++ b/src/vite-env.d.ts
@@ -0,0 +1 @@
+declare module "*.css";
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "useDefineForClassFields": true,
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "allowJs": false,
+    "skipLibCheck": true,
+    "strict": false,
+    "noEmit": true,
+    "isolatedModules": true,
+    "esModuleInterop": true
+  },
+  "include": ["src"]
+}
Author	SHA1	Message	Date
Tim Bendt	c4da8c942e	Fix weather draft and deploy setup	2026-04-29 12:00:56 -04:00
Tim Bendt	f071837ed6	more card rule tweaks	2026-04-10 16:13:45 -04:00
Tim Bendt	856f0049b7	fix draft ui	2026-04-10 16:12:41 -04:00
Tim Bendt	30e3f88b21	Refine setup and draft interactions	2026-04-10 13:36:43 -04:00
Tim Bendt	e11264168c	Fix: ensure board cells stay square so circles don't become ovals	2026-04-09 17:45:09 -04:00
Tim Bendt	1cc85397bd	Add weather rules and streamline setup	2026-04-09 17:42:19 -04:00
Tim Bendt	8b50482621	Fix score-card padding in responsive media query	2026-04-09 17:42:14 -04:00
Tim Bendt	f866ce02cb	Fix: increase player card padding and ensure cell nodes stay circular	2026-04-09 14:56:18 -04:00
Tim Bendt	ad055d3ae4	Restore missing layout CSS that was accidentally deleted	2026-04-09 14:23:09 -04:00
Tim Bendt	f5ffb211cf	Add debug console logs to find startup issues	2026-04-09 14:07:34 -04:00
Tim Bendt	6c47b3e288	Redesign setup modal with organized sections and improved layout	2026-04-09 13:33:57 -04:00
Tim Bendt	b4de9d112b	Remove 16:9 aspect ratio constraint - fill available viewport space instead	2026-04-09 13:24:43 -04:00
Tim Bendt	94c619ce7c	Rewrite layout with CSS Grid framework - predictable areas for gameboard, sidebar, and bottom bar	2026-04-09 13:20:20 -04:00
Tim Bendt	977481936c	Fix board sizing to fill available width instead of being height-constrained	2026-04-09 13:11:34 -04:00
Tim Bendt	c85d7a8fc1	Optimize board sizing for constrained 16:9 container - reduce gaps and padding	2026-04-09 13:01:45 -04:00
Tim Bendt	170db88c5b	Fix CSS to work within 16:9 constrained container - replace viewport units with relative units	2026-04-09 12:03:45 -04:00
Tim Bendt	2e08b6e66a	Add health check to ensure Docker Swarm stops old containers after new one is healthy	2026-04-09 09:44:56 -04:00
Tim Bendt	8c302ed55a	Add 16:9 aspect ratio container optimized for TV fullscreen with browser chrome compensation	2026-04-09 09:31:42 -04:00
Tim Bendt	98c19ca262	Add explicit start command to nixpacks.toml to override nginx default	2026-04-09 09:19:04 -04:00
Tim Bendt	7ef736be64	Fix: use port 80 instead of 3000 for dokploy static site	2026-04-09 09:06:55 -04:00
Tim Bendt	d61b8de6b7	refactor	2026-04-09 09:00:25 -04:00
Tim Bendt	5b44762fbb	Fix nixpacks build: add start script and configure build phase	2026-04-09 08:50:24 -04:00
Tim Bendt	a99a1f32e3	big version with draft order and weather cards	2026-04-08 17:46:42 -04:00
Tim Bendt	4034ca55cf	ts refactor	2026-04-08 16:44:16 -04:00