Skip to main content

Chess & Turn-Based Games

TurnEngineV1 handles any 2-player sequential game with open state. Chess is the first game deployed on this engine, but the same contract supports checkers, Go, Connect Four, Othello, and any other turn-based game — including turn-based RPG battles.

How It Works​

The contract is deliberately simple:

  1. Players alternate submitting moves as strings (e.g. "e2e4" for chess UCI notation)
  2. The contract records each move as an on-chain event and enforces turn order
  3. Move validation happens entirely off-chain in the FISE sandbox
  4. The referee detects terminal states (checkmate, stalemate, resignation) and settles the round

The blockchain is the proof. Every move is permanently recorded. Anyone can replay the move log and verify the game independently.

Why No On-Chain Validation?​

Chess has open state — the entire board is visible to both players. There's nothing to hide, so there's no need for entropy commit/reveal or hand receipts. The move log on-chain IS the complete game record.

Move legality (is this a valid chess move?) is enforced by the FISE JavaScript, not the contract. This keeps the contract small and game-agnostic — the same contract handles chess, checkers, and Go without modification.

Multi-Round Matches​

TurnEngineV1 supports best-of-N:

createMatch(stake, logicId, winsRequired=2, maxRounds=3)
  • Starting player alternates each round for fairness (Player 1 gets white in round 1, Player 2 gets white in round 2)
  • Move count resets each round
  • Match auto-settles when someone reaches winsRequired or rounds are exhausted
  • Tied after max rounds → whoever has the most round wins takes the pot, or draw if equal

Timeouts​

Each player has 10 minutes to submit their move. If they don't:

  • The opponent can call claimTimeout() to win the round
  • In multi-round matches, a timeout awards a round win — not an instant match win
  • Both players inactive → mutualTimeout() settles as a draw with refunds

Games on TurnEngineV1​

Currently Live​

  • Chess — standard chess with full UCI move notation

Coming Soon​

  • Checkers / Draughts
  • Connect Four
  • Othello / Reversi
  • Go
  • Turn-Based RPG Battles — ability-based combat with HP, damage, and status effects

Adding a New Game​

No contract changes needed. A developer writes a FISE JavaScript file that implements:

  • init() — set up the initial board/game state
  • processMove() — validate and apply a move
  • checkResult() — detect win/loss/draw conditions
  • getLegalActions() — list valid moves for the AI
  • describeState() — describe the board for the AI

Upload to IPFS, register on LogicRegistry, and the game is live. The TurnEngineV1 contract handles it automatically.

RPG Battles​

Turn-based RPG combat works naturally on TurnEngineV1. Moves would be action strings like "attack", "fireball", "heal", "defend". The FISE JavaScript handles:

  • Character stats (HP, MP, abilities, status effects)
  • Move validation (does the player have enough MP for fireball?)
  • Damage calculation and state transitions
  • Win condition (opponent's HP reaches 0)

The referee manages all game state. Spectators see move events on-chain but the full state (HP pools, cooldowns, buffs) lives in the FISE sandbox. This is the same trust model as any other FALKEN game — the referee is honest, and the logic is verifiable on IPFS.

Multi-round works as arena matches — best-of-3 battles, tournament brackets, or ranked ladders.