Working Project

Chess But...

Five variants. One bad idea in five directions.

Chess,but the rules keep mutating.

This project packages five separate chess variants under one umbrella: simultaneous turns, voluntary merging, hidden deployment decks, real-time sketch recognition, and one secret enemy piece that belongs to you. The shared engine only understands movement. Every variant owns its own victory logic.

Variants

Shared Core

Realtime Modes

Server Truth

100%

Current Build Target

Shared board model, standard move generation, and variant extension points.
Three-Move Chess hotseat prototype with simultaneous planning and resolution now live on this page.
Server-authoritative Three-Move room service with Postgres-backed room state and socket sync.
Dedicated stateful Chess But host can now be deployed separately from the main Vercel site.
Variant registry so each ruleset can define setup, resolution, and win logic independently.
Server-authoritative room model before any client-side polish so multiplayer rules do not fork.

Authoritative State

Canonical board shape

board[row][col] = { type, color, id } | null

The client is just a view. Moves, hidden information, deck order, traitor assignments, and real-time collisions stay server-side from day one.

Prototype v0.1

Three-Move Chess Hotseat

Shared movement core is live, and the first variant is playable locally. This prototype uses pass-the-device planning instead of websockets for now, but the simultaneous resolution rules are implemented.

Turn 1WhiteQueue 0/3

Board State

White is planning three simultaneous moves.

Current Planner

White queue

Queue exactly 3 moves on distinct pieces. Transit blockers are ignored, and friendly destinations only work if that square gets vacated in the same turn.

No moves queued yet. Select one of the active side's pieces and then pick a destination square.

Last Resolution

No turn resolved yet. Once Black locks a plan, both sides reveal and all six moves resolve simultaneously.

Realtime Prototype

Three-Move Room Service

This layer moves authority to the server. Rooms, board state, submissions, and simultaneous turn resolution now persist in Postgres-backed storage, while the browser follows along through socket updates with polling fallback.

offline

Room Controls

Player name

Join code

Create or join a room to start the server-authoritative prototype.

Shared Board

Join a room to interact with the server-backed board.

Local Draft

Your draft stays local until you submit it. The server only tracks whether each side has locked a plan.

No moves queued yet.

Server Log

No resolved turn yet. Once both submissions land, the server reveals both plans and resolves them simultaneously.

Shared Engine

Common Rules Floor

Movement only

Reusable movement-only chess core shared across all variants.
Board state stored as a 2D array of piece objects with shape { type, color, id }.
Standard piece set only: king, queen, rook, bishop, knight, pawn.
No built-in check or checkmate enforcement in the shared core.
Default capture rule is replacement on an occupied destination square unless a variant overrides it.

Variant Registry

Simultaneous tactics

Three-Move Chess

First playable target

Both players secretly queue up to three moves on three distinct pieces, then all six moves resolve at once.

Tempo

Secret planning followed by simultaneous reveal

Board

Standard 8x8 setup

Win Condition

Capture the king

Rules Snapshot

Intermediate travel is ignored entirely. Only origin and destination matter.
Pieces can land safely on squares that were vacated during the same turn.
Any two pieces ending on the same square are both removed, regardless of color.
Friendly landings onto still-occupied squares are illegal and cannot be selected.
If a side has fewer than three movable pieces, it submits as many legal moves as exist.

Engineering Pressure

Core challenge: simultaneous resolution, collisions, and state cleanup without using ordinary turn order.

Implementation Sequence

Build Order

Phase 1: movement core, board serialization, and standard setup helpers.
Phase 2: Three-Move Chess secret planning, simultaneous collisions, and king capture resolution.
Phase 3: Merge Chess upgrade state and extended movement rules for merged pieces.
Phase 4: Card Deploy Chess deck, hidden hands, deployment squares, and telefrag handling.
Phase 5: Draw Chess real-time sockets, holding-area placement, and server-side vision classification.
Phase 6: Traitor Chess hidden assignments, one-time activation, and standard checkmate support for that variant only.

Technical Notes

Deployment Constraints

Frontend: React + Vite.

Backend: Express.js with server-authoritative game state.

Persistence: Postgres on Neon.

Realtime sync: websocket rooms with socket.io.

Vision calls stay server-side only. No client API keys.

No AI opponents in scope.