TAKEZO — Gameplay Specification

Tactical Analysis & Strategic Mastery

Version 1.0 | April 2026 | Status: Definitive (Launch Title)

CIPHER-LINE revision note (2026-04-24): Takezo’s Cipher voice — move commentary, pattern-recognition hints, deliberative pauses — renders on the CIPHER-LINE OLED, not the main 80×25 grid. The module’s contemplative pace means silence dominates; Cipher drifts about old boards while the operator thinks. See the CIPHER-LINE Contributions section at the end. Canonical engine spec: docs/software/runtime/cipher-voice.md.

Mission Contributions

Mission Composition Grammar declaration — verb vocabulary, affinity tag set, and mission-contributions schema are defined in docs/plans/post-v0.1/2026-04-25-mission-composition-grammar.md §1–§3.

(mission-contributions
  :verbs (DECIDE OBSERVE ANALYZE)
  :affinities (NETWORK PHYSICAL))

Takezo is the launch library’s contemplative tactical-strategy cart. Irrevocable multi-turn commits satisfy DECIDE (addendum §1 explicitly cites Takezo as the canonical DECIDE example); INFO-cycled threat heatmaps and influence views satisfy OBSERVE; pattern recognition over board states satisfies ANALYZE. Affinities are NETWORK (the board is a graph of contested positions and influence relationships) and PHYSICAL (territory has spatial extent). Default biases.

Design Philosophy

TAKEZO is the anti-tempo cartridge. Where ICE BREAKER demands split-second decision-making under time pressure, TAKEZO rewards patience, long-term thinking, and pattern mastery. The operator who can see five moves ahead wins. Speed is irrelevant. The operator has unlimited time per turn. The cartridge is named for Miyamoto Musashi, the legendary swordmaster who defeated his opponents through contemplation, not haste. TAKEZO embodies that philosophy.

The core mechanic is turn-based pattern analysis on abstract territory networks. The operator studies a board state (5×5 up to 11×11 grid), identifies winning patterns or defensive structures, and commits moves strategically. An AI opponent (ranging from novice to master-level) responds. The operator’s skill is measured by:

Tempo of thought — Can they see the board’s deep structure quickly?
Pattern recognition — Do they spot the winning configuration before the opponent does?
Tactical discipline — Can they execute a multi-turn plan without deviation?
Risk assessment — Do they understand the cost of every move?

TAKEZO is philosophy made playable. It is the game for operators who think. There is no timer. No pressure. No panic. Only the board and the mind.

1. THE ANALYSIS LOOP: ATOMIC UNIT OF PLAY

The TAKEZO gameplay cycle is fundamentally different from ICE BREAKER’s OODA loop. It is not fast. It is deliberate.

The Cycle: OBSERVE → ANALYZE → COMMIT → REFLECT

OBSERVE (unlimited time): The operator studies the board state. They press INFO (double-tap to cycle views) to see different analytical lenses: the raw grid, a threat heatmap, a unit strength visualization, or a multi-move lookahead prediction. Each view reveals different information. The operator is gathering intelligence. There is no time pressure. They can study for 30 seconds or 30 minutes.

ANALYZE (unlimited time): The operator thinks. The Cipher voice is present but subtle. It may offer hints: “Three of your units form a defensive triangle. That position holds against 78% of predicted attack patterns.” The operator uses these hints to validate or correct their thinking. They can press QUOTE to bookmark a board position for later reference. They can press EQ to compare two board states (before and after a hypothetical move).

COMMIT (immediate): The operator makes a decision. They press CAR/CDR to select a unit or position, then press EVAL to execute the move. This action is irreversible. The board advances. The opponent responds.

REFLECT (feedback): The board updates. The AI opponent makes their move. The operator observes the new board state and learns: “That unit I reinforced at C4 just blocked the opponent’s acquisition route. That was correct.” Or: “That unit I moved to D5 is now isolated. The opponent will encircle it next turn. I made an error.” Reflection is how learning compounds.

Why Unlimited Time Matters

Unlimited time transforms strategy from reactive to proactive. An operator with 60 seconds per turn plays differently than an operator with 60 seconds per entire game.

Reactive operator (tempo-limited): Move quickly. Anticipate 2-3 moves ahead. Hope the plan works.
Proactive operator (unlimited time): Think deeply. Anticipate 5-7 moves ahead. Understand the opponent’s entire strategy. Execute a flawless plan.

The proactive operator becomes the master. The reactive operator becomes the novice. TAKEZO rewards the proactive player.

2. SYSTEM ONE: THE BOARD

The board is a tactical grid representing territory, assets, and influence. It is inspired by abstract strategy games (Go, Chess) but simplified for the KN-86’s display constraints.

Board Topology

The board is a square grid: 5×5 (novice), 7×7 (apprentice), 9×9 (specialist), or 11×11 (master).

Each cell on the board contains one of:

Empty space (‧) — neutral territory
Friendly unit (●) — operator’s asset (finance, IP, comms, executive team, etc.)
Enemy unit (○) — opponent’s acquisition or attack unit
Objective/control point (◆) — strategic location both players contest
Fortified position (■) — territory the operator controls (high defensive value)

Unit Properties

Each unit (friendly or enemy) has:

Position (x, y on grid)
Type (Finance, IP, Comms, Executive, Military, Acquisition)
Health (0-100; unit removed if health=0)
Threat Level (how much under attack)
Strategic Value (how important to win condition)
Mobility (can move 0-3 spaces per turn)

Territory and Influence

TAKEZO introduces influence maps. Each unit projects influence over adjacent cells. Friendly units create defensive influence (they protect nearby assets). Enemy units create offensive influence (they threaten to capture nearby assets).

The board UI shows:

Grid view (raw piece positions)
Threat heatmap (red = high danger, blue = safe)
Influence view (radiating circles showing unit reach)
Lookahead preview (showing predicted unit movements if opponent responds optimally)

Fog of War and Perfect Information

Unlike chess (perfect information) or Go (perfect information), TAKEZO sometimes uses limited information scenarios. The operator cannot see the opponent’s future moves. They see:

Current board state (perfect)
Opponent’s unit capabilities (perfect)
Likely opponent responses (probabilistic — “This opponent will attack Finance in 60% of scenarios”)
Hidden variables (opponent AI level, opponent’s “personality” — aggressive vs. cautious)

Expert operators learn to read opponent patterns and predict responses accurately. Novice operators struggle.

3. SYSTEM TWO: THE TOOLKIT — TACTICAL ANALYSIS UTILITIES

The operator doesn’t deploy weapons. They deploy thinking tools. These are gameplay affordances that help the operator analyze the board.

Analysis Tools (Unlocked by Reputation)

THREAT ASSESSMENT (Always available)

Press INFO to see which friendly units are under threat
Color coding: Green = safe, Yellow = threatened, Red = critical
Numerical value: “Unit at C3 is threatened by 2 enemy units within 2 moves”

MULTI-TURN LOOKAHEAD (Apprentice, Rep 5+)

Press INFO multiple times to cycle to lookahead view
Shows 2-3 hypothetical opponent moves
Displays “If opponent attacks Finance, your IP will be undefended” (yellow warning)
Helps operator think ahead

PATTERN RECOGNITION HINTS (Specialist, Rep 15+)

Cipher voice proactively suggests winning patterns
Example: “Three units in a line are unbreakable. You have two units aligned; place one more at E5 to complete the pattern.”
Operator doesn’t have to follow hints, but they are valuable teaching tools

RISK QUANTIFICATION (Master, Rep 25+)

Press APPLY → INFO to see move outcome probabilities
Example: “If you move to D4, opponent has 65% chance of attacking Finance. If you stay at C4, opponent has 40% chance.”
Enables precise risk/reward calculation

COUNTER-STRATEGY ANALYSIS (Legend, Rep 35+)

Cipher shows the opponent’s predicted 3-move plan
Operator can then position units to counter that plan
Highest-level strategic play: predict the opponent and prepare the counter before the threat emerges

CONS for Strategic Combinations

Unlike ICE BREAKER’s tool combinations, TAKEZO’s CONS operation is about unit synergies. Press CONS to select two friendly units. If they are adjacent or overlapping in influence, they may form a synergistic pair:

Finance + Legal = Protected Assets (legal team shields finance from acquisition)
Executive + Comms = Command & Control (executive can coordinate faster with comms)
IP + Engineering = Fast Iteration (IP assets develop faster when paired with engineers)

Synergistic pairs unlock move options — units can act together on the same turn, combining their effects. This adds depth to planning.

4. SYSTEM THREE: THE OPPONENT — AI PERSONALITIES

The AI opponent is not a random threat. It is a persona with a strategy.

AI Levels (Threat 1-5)

NOVICE (Threat 1, Rep 0+)

Makes random moves
No lookahead; reacts to immediate threats only
Easily defeated by any reasonable strategy
Strategy: No strategy; just moves units

APPRENTICE (Threat 2, Rep 5+)

Looks ahead 1-2 moves
Defends assets directly under threat
Doesn’t anticipate 3+ move combinations
Strategy: Defensive; protects what’s valuable

SPECIALIST (Threat 3, Rep 15+)

Looks ahead 3 moves minimum
Identifies operator’s weak points 2 moves away
Executes coordinated multi-unit attacks
Strategy: Aggressive but predictable; always attacks weakness

MASTER (Threat 4, Rep 25+)

Looks ahead 5 moves
Adapts to operator’s pattern (learns operator tendencies)
Executes deceptive strategies (sacrifices unit to gain tempo)
Strategy: Flexible; adapts to opponent’s playstyle

LEGEND (Threat 5, Rep 35+)

Looks ahead 7+ moves (near-optimal play)
Plays perfectly against known strategies
Exploits subtle positional advantages
Strategy: Optimal; near-flawless execution

Opponent Personalities (Cross-cut with Threat)

Beyond threat level, opponents have personality traits that affect their play:

AGGRESSIVE: Always attacks, even at cost. Generates threats. Operator must defend constantly.
CAUTIOUS: Rarely commits; waits for advantage. Operator must force commitment.
ADAPTIVE: Watches operator’s patterns and copies them. Operator must vary playstyle.
POSITIONAL: Cares about long-term territory control, not immediate wins. Operator must think long-term.

Threat Level × Personality creates 20 distinct matchups. A Specialist-level Positional opponent is very different from a Specialist-level Aggressive opponent.

How the Opponent “Thinks”

The opponent runs a simplified OODA loop:

OBSERVE: Analyze board. Identify operator’s weak points. Assess own unit health.
ORIENT: Classify operator as aggressive/defensive/cautious. Choose strategy (attack/defend/consolidate).
DECIDE: Select target unit to attack or defend.
ACT: Move opponent’s units. Advance turn.

The operator can learn this loop and predict it. A Master-level operator can say: “This opponent always attacks Finance when threatened elsewhere. I’ll leave Finance defended with exactly 2 units and move my 3rd unit to attack IP. The opponent will take the bait and commit to Finance, leaving IP undefended.”

This is high-level play. This is mastery.

AI Opponent Decision Algorithm (Pseudocode)

Each opponent personality executes a distinct decision-making algorithm every turn. The evaluation function scores each possible move, and the AI selects the highest-scoring move (or lowest, if personality=DEFENSIVE).

Threat Level Adjustment: Base lookahead depth scales with threat level:

Threat 1-2: lookahead 1-2 moves
Threat 3: lookahead 3 moves (default)
Threat 4: lookahead 5 moves
Threat 5: lookahead 7+ moves (near-optimal play)

AGGRESSIVE Personality (Threat 1-2)

function opponent_turn_aggressive():
  vulnerable_units = find_undefended_units(board)
  if vulnerable_units.count > 0:
    // Attack exposed units
    for unit in vulnerable_units:
      threat_level = threat_heatmap[unit.position]
      if threat_level > 50:  // This unit is exposed
        move_option = create_attack_move(unit, nearest_weak_enemy)
        score = evaluate_move(move_option, lookahead=1)
        if score > best_score:
          best_move = move_option
          best_score = score
  else:
    // No vulnerable units; reinforce own position
    weak_units = find_units_below_health_threshold(own_units, 60)
    if weak_units.count > 0:
      for unit in weak_units:
        move_option = create_reinforcement_move(unit)
        score = evaluate_move(move_option, lookahead=1)
        if score > best_score:
          best_move = move_option
          best_score = score

  if best_move == null:
    best_move = create_random_adjacent_move()

  execute_move(best_move)

function evaluate_move(move, lookahead):
  // Evaluation: maximize own units alive - opponent units alive
  simulated_board = simulate_move(board, move)
  score = (own_unit_count(simulated_board) - opponent_unit_count(simulated_board)) * 100
  if lookahead > 1:
    opponent_response = opponent_minimax_one_level(simulated_board, lookahead-1)
    score -= opponent_response.score  // Penalty if opponent counters well
  return score

DEFENSIVE Personality (Threat 2-3)

function opponent_turn_defensive():
  threatened_units = find_threatened_units(board, threat_threshold=40)
  if threatened_units.count > 0:
    // Defend threatened units
    for unit in threatened_units:
      move_option = create_defensive_move(unit)
      score = evaluate_defensive_move(move_option, lookahead=2)
      if score > best_score:
        best_move = move_option
        best_score = score
  else:
    // No threats; cautiously expand or consolidate
    neutral_adjacent = find_neutral_adjacent_nodes(own_units)
    if neutral_adjacent.count > 0 and random() < 0.5:
      nearest_neutral = closest_neutral_to_core(neutral_adjacent)
      best_move = create_move_to_neutral(nearest_neutral)
    else:
      // Fortify core territory
      core_units = find_units_near_starting_position()
      best_unit = weakest_by_defensive_value(core_units)
      best_move = create_fortification_move(best_unit)

  execute_move(best_move)

function evaluate_defensive_move(move, lookahead):
  // Defensive: maximize security of threatened unit
  simulated_board = simulate_move(board, move)
  unit = move.target_unit
  new_threat_level = calculate_threat_level(unit, simulated_board)
  score = (100 - new_threat_level) * 50  // Lower threat = higher score
  if lookahead > 1:
    future_board = simulate_operator_best_response(simulated_board, lookahead-1)
    future_threat = calculate_threat_level(unit, future_board)
    score -= (future_threat * 0.5)  // Penalty if threat resurges
  return score

ADAPTIVE Personality (Threat 3-4)

function opponent_turn_adaptive():
  // Learn from operator's move history
  recent_moves = operator_move_history[last_5_turns]

  operator_pattern = classify_operator_pattern(recent_moves)
  // Returns: AGGRESSIVE, DEFENSIVE, ENCIRCLING, TEMPO_SHIFT, SACRIFICIAL

  if operator_pattern == AGGRESSIVE:
    // Operator attacking; match aggression with extra defense
    defensive_weight = 1.5
    aggressive_weight = 0.8
  elif operator_pattern == ENCIRCLING:
    // Operator trying to cut supply lines
    defensive_weight = 2.0
    aggressive_weight = 0.3
  elif operator_pattern == SACRIFICIAL:
    // Operator sacrificing units for tempo
    defensive_weight = 0.5
    aggressive_weight = 1.8
  else:
    // Default balanced
    defensive_weight = 1.0
    aggressive_weight = 1.0

  candidate_moves = generate_all_legal_moves(board)
  best_move = null
  best_score = -∞

  for move in candidate_moves:
    simulated_board = simulate_move(board, move)

    // Evaluate defensively
    if is_defensive_move(move):
      defensive_score = evaluate_defensive_position(move, simulated_board) * defensive_weight
    else:
      defensive_score = 0

    // Evaluate aggressively
    if is_aggressive_move(move):
      aggressive_score = evaluate_threat_increase(move, simulated_board) * aggressive_weight
    else:
      aggressive_score = 0

    // Lookahead 3 moves
    lookahead_score = 0
    if has_future_advantage(move, simulated_board, depth=3):
      lookahead_score = 50

    score = defensive_score + aggressive_score + lookahead_score
    if score > best_score:
      best_move = move
      best_score = score

  execute_move(best_move)

ASYMMETRIC Personality (Threat 4-5)

function opponent_turn_asymmetric():
  current_phase = determine_phase_by_turn_count(turn_number)

  if current_phase == PHASE_CONSOLIDATION:  // Turns 1-10
    // Defend core territory; minimal aggression
    vulnerable_own_units = find_units_below_health_80(board)
    best_move = create_defensive_move(vulnerable_own_units[0])

  elif current_phase == PHASE_EXPANSION:  // Turns 11-25
    // Aggressive claiming; multi-unit coordinated attacks
    undefended_operator_clusters = identify_disconnected_clusters(operator_units)
    target_cluster = weakest_cluster(undefended_operator_clusters)
    best_move = create_attack_move_against_cluster(target_cluster)

  elif current_phase == PHASE_SEVERANCE:  // Turns 26+
    // Cut supply lines; sacrifice weak units to isolate operator
    supply_nodes = find_nodes_connecting_operator_clusters()
    for node in supply_nodes:
      if can_contest_node(node):
        move_option = create_contest_move(node)
        // Evaluate: value = importance_to_cutting_supply * 100
        //          - defense_cost * 50
        if value > best_value:
          best_move = move_option
          best_value = value

  // ASYMMETRIC does not adapt to operator moves
  // Behavior is purely phase-driven
  execute_move(best_move)

function determine_phase_by_turn_count(turn):
  if turn <= 10:
    return PHASE_CONSOLIDATION
  elif turn <= 25:
    return PHASE_EXPANSION
  else:
    return PHASE_SEVERANCE

Evaluation Function (Universal)

function evaluate_move(move, board_state):
  // Core metric: material advantage (unit health differential)
  own_unit_sum = sum(unit.health for unit in own_units)
  opponent_unit_sum = sum(unit.health for unit in opponent_units)
  material_score = (own_unit_sum - opponent_unit_sum) / 100

  // Positional bonus: control of strategic positions
  strategic_value = 0
  for unit in own_units:
    if unit.strategic_value > 5:  // Important unit
      distance_to_opponent = min_distance_to_opponent_units(unit)
      if distance_to_opponent < 3:
        strategic_value += unit.strategic_value * 10

  // Threat reduction: moving units out of danger
  threat_reduction = 0
  for unit in own_units:
    old_threat = unit.threat_level
    new_threat = recalculate_threat(unit, board_state)
    threat_reduction += (old_threat - new_threat) * 5

  // Future advantage: lookahead bonus
  future_bonus = 0
  if lookahead_depth > 1:
    future_board = simulate_several_moves_ahead(board_state, lookahead_depth)
    if operator_winning_position(board_state) and !operator_winning_position(future_board):
      future_bonus = 50  // We improved our position

  total_score = material_score + strategic_value + threat_reduction + future_bonus
  return total_score

Learning (ADAPTIVE Only)

function update_operator_pattern_history():
  // Track operator's decisions over last 5 turns
  for turn in [current_turn - 5 ... current_turn]:
    move = operator_moves[turn]
    pattern = classify_move(move)
    // Patterns: DEFENSIVE (move reinforces unit), AGGRESSIVE (attacks),
    //           ENCIRCLING (controls supply nodes), SACRIFICIAL (loses unit intentionally)
    pattern_history.append(pattern)

  // Compute moving average
  recent_pattern = most_common(pattern_history)
  adaptive_opponent.learns(recent_pattern)

The operator’s task is to recognize which algorithm the opponent is running and exploit its assumptions. An AGGRESSIVE opponent leaves its core undefended. A DEFENSIVE opponent is slow to respond to rapid pivots. An ADAPTIVE opponent can be tricked by false patterns. An ASYMMETRIC opponent reveals its agenda through phase transitions — a skilled operator spots the phase shift by turn 8-10 and positions to counter it.

5. SYSTEM FOUR: SOUND DESIGN — THE CONTEMPLATIVE SOUNDSCAPE

The YM2149 PSG in TAKEZO produces a completely different audio environment than ICE BREAKER. There is no alarm. No urgency. Only contemplation.

Three Voices as Meditation

Voice 1: Strategic Depth

A sustained koto note (Japanese plucked string instrument) at base frequency C3 (131 Hz). The note is clean, pure, meditative. As the operator thinks deeper (more moves planned ahead), the harmonic content increases. The note grows richer.

0-2 moves planned: Single C3 note (sparse)
3-5 moves planned: C3 with overtone E4 (harmony)
6+ moves planned: Full chord (C3-E4-G4, C major triad; rich complexity)

The operator is literally hearing their own depth of thought. A player who thinks 7 moves ahead hears a rich chord. A player who thinks 2 moves ahead hears a simple note. The audio is a mirror.

Voice 2: Tactical Commitment

Sparse koto plucks. Each time the operator presses EVAL to commit a move, a koto note plays. The pitch varies based on the move’s risk:

Low risk move (well-defended position): Low koto note (reassuring)
Medium risk move (moderately threatened): Medium koto note (neutral)
High risk move (exposed or aggressive): High koto note (tense)

Over a full game, the operator’s move sequence creates a melody. A defensive player’s melody is conservative, staying in the low register. An aggressive player’s melody is bold, with high notes. This is the signature of their strategy. Experienced players learn to recognize opponent playstyles by listening to their move melodies.

Voice 3: Opponent Presence

Shamisen (Japanese 2-string lute, used in traditional music for dramatic moments). Quiet at the start. As the opponent makes moves and the game heats up, Voice 3 grows louder.

Opening phase (first 5 turns): Shamisen barely audible (opponent not yet committed)
Middlegame (turns 6-15): Shamisen prominent (opponent pressing advantage)
Endgame (turns 16+): Shamisen loud (opponent making final critical moves)

The operator hears the opponent’s presence growing. This is pressure, but patient pressure. Not the frantic alarm of ICE BREAKER, but the mounting tension of a game coming to a climax.

YM2149 Register Specification

The TAKEZO audio engine uses the YM2149 PSG’s three tone channels as follows:

Channel A (Voice 1: Strategic Depth)

Tone A Period (R0-R1): Base frequency C3 = period 0x0C50 (50 Hz pitch register; 131 Hz audio frequency)
Baseline Envelope: Sawtooth up (Envelope shape 8, fastest attack 0x0F release). Sustains at full amplitude.
Dynamic Modulation (planning phase):
- 0-2 moves ahead: single tone, amplitude = 31 (max)
- 3-5 moves ahead: amplitude = 28, secondary harmonic (E4 = period 0x0600) fades in at 15 amplitude
- 6+ moves ahead: amplitude = 25, full triad (E4 + G4 = period 0x050A) blends at 12 amplitude each
Registers Used: R0 (Period Low), R1 (Period High), R8 (Amplitude A), R13 (Envelope Shape)

Channel B (Voice 2: Tactical Commitment)

Tone B Period (R2-R3): Pluck frequency varies by risk assessment
- Low risk: G2 = period 0x18A4 (98 Hz)
- Medium risk: C3 = period 0x0C50 (131 Hz)
- High risk: E3 = period 0x0904 (165 Hz)
Envelope: Percussive attack (Envelope shape 10, decay 0x08). Single pluck per move commitment.
Duration: 0.4 seconds per move event
Amplitude: 31 (max) on attack, decays to 0 over 0.4s
Registers Used: R2 (Period Low), R3 (Period High), R9 (Amplitude B), R13 (Envelope Shape)

Channel C (Voice 3: Opponent Presence)

Tone C Period (R4-R5): Shamisen base frequency D3 = period 0x0A20 (147 Hz)
Envelope: Sustained with slow fade (Envelope shape 9, attack 0x04, decay 0x06)
Volume Progression by Game Phase:
- Turns 0-5: amplitude = 2 (barely audible)
- Turns 6-15: amplitude = 12 (prominent)
- Turns 16+: amplitude = 20 (loud, mounting tension)
- Victory/defeat: amplitude = 0 (fade out)
Registers Used: R4 (Period Low), R5 (Period High), R10 (Amplitude C), R13 (Envelope Shape)

Noise Channel (Optional Accent):

Noise Register (R6): Disable noise (bit 5-6 of R7 = enable tone only, disable noise)
Exception: At board state transitions (opponent moves committed), brief noise burst (R6 = 0x1F, 40ms) provides tactile feedback

Master Mixer Register (R7):

Bit 7: I/O B direction (unused)
Bit 6: I/O A direction (unused)
Bit 5: Noise enable C (0 = enable, for accent bursts only)
Bit 4: Noise enable B (1 = disable)
Bit 3: Noise enable A (1 = disable)
Bit 2: Tone enable C (0 = enable)
Bit 1: Tone enable B (0 = enable)
Bit 0: Tone enable A (0 = enable)
Standard config: R7 = 0x24 (tone A, B, C enabled; noise disabled)

Envelope Generator Timing (R11-R12):

Fine Tuning (R11): 0x06 (6 × 256 clock ticks = ~1.5ms per envelope step at 1MHz CPU)
Coarse Tuning (R12): 0x04 (4 = decay speed moderate, ~6ms per step)
Envelope Shapes Used:
- 8 (sawtooth up, single attack): Voice 1 base, sustained
- 9 (sawtooth up, looped): Voice 3 gradual fade
- 10 (sawtooth down, single attack): Voice 2 percussive pluck

Audio State Machine (8 Named States):

STATE 0: SILENCE
  All channels amplitude = 0. Network waiting for operator input.
  Transition: → STATE 1 on game start

STATE 1: PLANNING_SPARSE (0-2 moves planned)
  Voice 1: C3 (period 0x0C50), amplitude 31, envelope 8
  Voice 2: silent (amplitude 0)
  Voice 3: silent (amplitude 0)
  Transition: → STATE 2 (if operator deep-thinks 3+ moves) or STATE 5 (if move committed)

STATE 2: PLANNING_RICH (3-5 moves planned)
  Voice 1: C3 + E4 harmony (dual-period blend), amplitude 28+15
  Voice 2: silent
  Voice 3: silent
  Transition: → STATE 3 (if 6+ moves planned) or STATE 5 (if move committed)

STATE 3: PLANNING_TRIAD (6+ moves planned)
  Voice 1: C3 + E4 + G4 full chord (tri-period blend), amplitude 25+12+12
  Voice 2: silent
  Voice 3: silent
  Transition: → STATE 5 (if move committed) or loop (continue planning)

STATE 4: MOVE_COMMITMENT (low/med/high risk)
  Voice 1: sustain from previous planning state
  Voice 2: G2/C3/E3 pluck (0.4s percussive decay), amplitude 31→0
  Voice 3: shamisen present if game is past turn 5, amplitude ≥ 2
  Transition: → STATE 5 or STATE 6 (if opponent's turn)

STATE 5: OPPONENT_TURN_EARLY (turns 0-5)
  Voice 1: C3 sparse (amplitude 31, sustain)
  Voice 2: silent
  Voice 3: shamisen barely audible (amplitude 2), period 0x0A20
  Transition: → STATE 6 (opponent committing move)

STATE 6: OPPONENT_TURN_MID (turns 6-15)
  Voice 1: C3 sparse (ambient)
  Voice 2: silent
  Voice 3: shamisen prominent (amplitude 12), period 0x0A20
  Transition: → STATE 7 (if turns ≥ 16) or back to planning (next operator turn)

STATE 7: OPPONENT_TURN_ENDGAME (turns 16+)
  Voice 1: C3 sparse
  Voice 2: silent
  Voice 3: shamisen loud (amplitude 20), period 0x0A20, accelerating envelope
  Transition: → STATE 8 (game end) or back to planning (next operator turn)

STATE 8: GAME_END (victory/defeat)
  Voice 1: C3 → C4 glissando (0.8s) if victory, or C3 → G2 glissando if defeat
  Voice 2: single resolving note (C3, amplitude 20, 1.2s decay)
  Voice 3: shamisen resolves to silence
  Transition: → STATE 0 (game over, return to menu)

Example Transition (30-turn game):

Turn 0-5: operator in STATE 1 or 2, voices cycle based on planning depth. Voice 3 barely audible.
Turn 6-15: opponent enters STATE 6, Voice 3 amplitude rises to 12.
Turn 16-30: opponent enters STATE 7, Voice 3 amplitude = 20, tension mounts.
Turn 35+: game concludes, Voice 1 performs glissando (STATE 8), all voices resolve.

Key Audio Events

Event	Voice	Tone	Duration	Meaning
Move Committed	2	Koto pluck (pitch = risk)	0.4s	Decision made
Opponent Moves	3	Shamisen pluck	0.5s	Opponent acts
Planning Phase Complete	1	Harmonic resolution	1.2s	Planning done
Threat Identified	1	Harmonic shift (dissonance)	0.8s	Warning
Strategic Victory	1+2+3	Full composition (koto + shamisen + harmony)	2.0s	Game won
Defeat	1+2+3	Descending resolution (minor key)	2.0s	Game lost
Silence (Deep Thought)	Mute	N/A	N/A	Player in contemplative mode

The silence is never punished. A player can sit for 10 minutes staring at the board, and the YM2149 waits. This is by design. Contemplation is the highest mode of play.

6. THE GAME PHASES: PLANNING → EXECUTION → REFLECTION

TAKEZO games follow a strict 3-phase structure.

PHASE 1: PLANNING (Unlimited time)

The operator is given a board state and the question: “What is your strategy?”

The operator can:

Press INFO (multiple times) to cycle through analytical views
Press CAR/CDR to examine units and their properties
Press QUOTE to bookmark board positions
Press EQ to compare positions
Press APPLY to preview a hypothetical move (doesn’t commit it)
Take as much time as they need

There is no timer. No pressure. An operator can study a board for an hour if they want. The Cipher voice occasionally offers hints but never rushes.

The planning phase ends when the operator presses EVAL. This commits the first move and transitions to Execution.

PHASE 2: EXECUTION (Tactical combat, real-time with opponent)

The board becomes live. Units move. The opponent responds. The operator and opponent alternate turns.

Operator’s turn: Select a unit (CAR/CDR), choose a move or action (APPLY or CONS), commit (EVAL). Takes 5-30 seconds.
Opponent’s turn: AI opponent calculates and executes move. Takes 2-5 seconds.

The pace is steady, not frantic. If the operator needs to think mid-execution, they can press INFO to pause and analyze. The pause is free; no time penalty.

The execution phase ends when:

Operator’s objective is achieved (opponent defeated, territory secured, control points captured)
Opponent’s objective is achieved (operator’s assets lost, takeover completed)
Maximum turn count is reached (game is draw or partial victory)

PHASE 3: REFLECTION (Debrief)

The game ends. The Cipher voice provides commentary:

Victory: “Perfect execution. Your strategy was sound and your adaptation flawless.”
Defeat: “Your plan was defeated. Study this board. The opponent found a weakness you missed. Next time, you’ll see it sooner.”
Draw: “Respect between equals. You planned well; the opponent executed better. Or vice versa.”

Payout is calculated. Reputation is awarded. The operator reflects on what they learned.

7. CELL ARCHITECTURE AND KEY MAPPING

Core Cell Types (CELL_DEFINE)

BOARD_CELL — Master game state container

CELL_DEFINE(BOARD_CELL) {
  // Board topology
  FIELD(uint8_t, board_size, "Board dimensions: 5, 7, 9, or 11");
  FIELD(uint8_t[121], board_state, "Flattened grid (max 11×11 = 121 cells); contents: EMPTY, UNIT_FRIENDLY, UNIT_OPPONENT, CONTROL_POINT, FORTIFIED");

  // Unit populations
  FIELD(CellList*, units_player, "Linked list of UNIT_CELL nodes; operator's units");
  FIELD(CellList*, units_opponent, "Linked list of UNIT_CELL nodes; opponent's units");
  FIELD(uint8_t, unit_count_player, "Count of operator units (0-11 max)");
  FIELD(uint8_t, unit_count_opponent, "Count of opponent units (0-11 max)");

  // Game phase tracking
  FIELD(uint8_t, phase, "PHASE_PLANNING (0), PHASE_EXECUTION (1), PHASE_REFLECTION (2)");
  FIELD(uint16_t, turn_number, "Current turn (0-indexed, max 99)");
  FIELD(uint16_t, max_turns, "Game length limit (varies by threat level)");

  // Threat assessment
  FIELD(uint16_t[121], threat_heatmap, "Precomputed threat levels per cell (0-65535); updated each turn");

  // AI personality and state
  FIELD(uint8_t, opponent_personality, "AGGRESSIVE (0), DEFENSIVE (1), ADAPTIVE (2), ASYMMETRIC (3)");
  FIELD(uint8_t, opponent_threat_level, "Threat 1-5; determines lookahead depth");
  FIELD(uint8_t*, opponent_move_history, "Last 5 operator moves; used by ADAPTIVE personality");

  // Synergy tracking
  FIELD(uint8_t[11], unit_synergies_active, "Bitmask of active unit pair synergies; bit N = synergy between units N and (N+1)");

  // Audio state
  FIELD(uint8_t, psg_audio_state, "Current YM2149 state (0-8): SILENCE, PLANNING_SPARSE, PLANNING_RICH, PLANNING_TRIAD, MOVE_COMMITMENT, OPP_EARLY, OPP_MID, OPP_ENDGAME, GAME_END");

  SLOT(on_unit_selected, BOARD_CELL *board, UNIT_CELL *unit, void);
  SLOT(on_move_committed, BOARD_CELL *board, UNIT_CELL *unit, uint16_t target_pos, void);
  SLOT(on_opponent_moved, BOARD_CELL *board, UNIT_CELL *opp_unit, void);
  SLOT(on_phase_transition, BOARD_CELL *board, uint8_t old_phase, uint8_t new_phase, void);
};

UNIT_CELL — Individual game unit

CELL_DEFINE(UNIT_CELL) {
  // Unit identity
  FIELD(uint8_t, unit_type, "FINANCE (0), IP (1), COMMS (2), EXECUTIVE (3), MILITARY (4), ACQUISITION (5)");
  FIELD(uint8_t, owner, "OWNER_PLAYER (0) or OWNER_OPPONENT (1)");

  // Position and movement
  FIELD(uint16_t, position, "Flattened grid index (0-120 max for 11×11 board)");
  FIELD(uint8_t, x, "Grid column (0-10)");
  FIELD(uint8_t, y, "Grid row (0-10)");
  FIELD(uint8_t, mobility, "Spaces per turn (0-3)");
  FIELD(uint8_t[3], legal_moves, "Precomputed valid target positions; count in legal_moves_count");
  FIELD(uint8_t, legal_moves_count, "Number of legal moves available (0-8)");

  // Combat state
  FIELD(uint8_t, health, "Current health (0-100); unit removed if health = 0");
  FIELD(uint8_t, health_max, "Max health (typically 80-100)");
  FIELD(uint8_t, threat_level, "How under attack (0-255); higher = more threatened");
  FIELD(uint8_t, defense_bonus, "Bonus defense if unit forms synergy (+0 to +10)");

  // Valuation
  FIELD(uint8_t, strategic_value, "Importance to win condition (1-100); Finance = 90, IP = 80, etc.");
  FIELD(uint8_t, capture_cost, "How many opponent actions to capture this unit (1-5)");

  // Synergy tracking
  FIELD(UNIT_CELL*, synergy_partner, "If unit is in active synergy, pointer to partner unit; else NULL");
  FIELD(uint8_t, synergy_type, "Synergy class: PROTECTED_ASSETS (0), COMMAND_CONTROL (1), FAST_ITERATION (2), etc.");

  // Parent reference
  FIELD(CellBase*, parent_board, "Pointer to parent BOARD_CELL");

  SLOT(on_unit_moved, UNIT_CELL *unit, uint16_t old_pos, uint16_t new_pos, void);
  SLOT(on_health_changed, UNIT_CELL *unit, uint8_t old_health, uint8_t new_health, void);
  SLOT(on_synergy_formed, UNIT_CELL *unit, UNIT_CELL *partner, void);
};

MOVE_ANALYSIS_CELL — Move preview and decision support

CELL_DEFINE(MOVE_ANALYSIS_CELL) {
  // Move coordinates
  FIELD(uint16_t, source_position, "Starting position (flattened grid index)");
  FIELD(uint16_t, target_position, "Destination (flattened grid index)");
  FIELD(uint8_t, source_x, "Starting x coordinate");
  FIELD(uint8_t, source_y, "Starting y coordinate");
  FIELD(uint8_t, target_x, "Target x coordinate");
  FIELD(uint8_t, target_y, "Target y coordinate");

  // Risk assessment
  FIELD(uint8_t, expected_risk, "0-100 likelihood opponent counters this move");
  FIELD(uint8_t, exposure_rating, "0-100 how exposed unit becomes after move (100 = very exposed)");
  FIELD(uint8_t, tactical_value, "0-100 strategic benefit of move (100 = excellent move)");

  // Tactical reasoning
  FIELD(char[64], tactical_reason, "Human-readable reason from Cipher (e.g., 'Defend Finance from flanking attack')");
  FIELD(uint16_t, outcome_probability, "0-10000 (centipercent); chance move leads to advantage; 5000 = 50%");

  // Lookahead preview
  FIELD(uint8_t, lookahead_depth, "How many moves ahead analyzed (1-3)");
  FIELD(uint8_t[3], lookahead_opponent_responses, "Predicted opponent move types (ATTACK, DEFEND, FORTIFY)");

  // Move type classification
  FIELD(uint8_t, move_class, "DEFENSIVE (0), OFFENSIVE (1), POSITIONAL (2), SACRIFICIAL (3)");

  SLOT(on_move_previewed, MOVE_ANALYSIS_CELL *analysis, void);
  SLOT(on_move_committed_from_preview, MOVE_ANALYSIS_CELL *analysis, void);
};

SYNERGY_PAIR_CELL — Unit pair synergy definition

CELL_DEFINE(SYNERGY_PAIR_CELL) {
  FIELD(uint8_t, unit_type_a, "First unit type (FINANCE, IP, COMMS, etc.)");
  FIELD(uint8_t, unit_type_b, "Second unit type");
  FIELD(uint8_t, synergy_type, "PROTECTED_ASSETS, COMMAND_CONTROL, FAST_ITERATION, etc.");
  FIELD(uint8_t, adjacency_required, "Boolean: must units be adjacent? (1 = yes, 0 = no)");
  FIELD(uint8_t, defense_bonus, "Defense bonus granted (+1 to +10)");
  FIELD(uint8_t, mobility_bonus, "Mobility bonus granted (+0 to +2)");
  FIELD(char[48], synergy_description, "Human-readable name (e.g., 'Protected Assets')");
};

Key Mapping by Cell Type

BOARD_CELL (Planning and Execution phases)

Key	Action
CAR	Select first friendly unit on board; drill into unit details
CDR	Select next friendly unit; cycle through units
CONS	Open unit synergy selector; combine two units
NIL	Deselect current unit; clear pending move
EVAL	Commit selected move; advance turn (planning phase) / execute move (execution phase)
INFO	Cycle analytical views: grid → threat heatmap → influence → lookahead
QUOTE	Bookmark current board state for later reference
EQ	Compare two bookmarked board states; show differences
APPLY	Preview move outcome without committing
BACK	Return to previous menu (navigation stack)
Numpad 1-9	Select board position (grid coordinates)

UNIT_CELL (Unit detail screen)

Key	Action
INFO	Show unit stats: health, threat level, strategic value, mobility
CAR	Examine unit’s position on board; zoom to location
CDR	Move to next nearby unit
EVAL	Accept this unit for movement; proceed to move selection
BACK	Return to board view

MOVE_ANALYSIS_CELL (Move preview screen)

Key	Action
INFO	Show detailed move analysis: risk, outcome probability, tactical reasoning
CAR	View alternative moves for selected unit
CDR	View next alternative move
EVAL	Commit this move
BACK	Cancel; return to unit selection

8. PHASE CHAIN SERIALIZATION (HOT SWAP)

TAKEZO integrates with multi-phase campaigns via the capability model. When a Hot Swap occurs, the nOSh runtime preserves TAKEZO’s game state to the 256-byte phase chain in SRAM. The struct below defines byte-level serialization.

Phase Chain Struct

/* TAKEZO Phase Chain State — 256 bytes max, aligned to 8-byte boundary */
typedef struct {
  // Header (8 bytes)
  uint8_t  magic;                    /* 0x54 = 'T' (TAKEZO identifier) */
  uint8_t  version;                  /* 0x01 (serialization format version) */
  uint8_t  phase;                    /* 0x00=PLANNING, 0x01=EXECUTION, 0x02=REFLECTION */
  uint8_t  board_size;               /* 5, 7, 9, or 11 */
  uint16_t turn_number;              /* Current turn (0-99) */
  uint16_t max_turns;                /* Game length (20-100) */

  // Board state (121 bytes for max 11×11 grid)
  uint8_t  board_state[121];         /* Flattened grid: EMPTY=0, FRIENDLY=1, OPPONENT=2, CONTROL=3, FORTIFIED=4 */

  // Unit population (44 bytes max: 11 units × 4 bytes each)
  uint8_t  unit_count_player;        /* 0-11 */
  uint8_t  unit_count_opponent;      /* 0-11 */
  struct {
    uint16_t position;               /* Flattened grid index */
    uint8_t  health;                 /* 0-100 */
    uint8_t  unit_type;              /* FINANCE, IP, COMMS, EXECUTIVE, MILITARY, ACQUISITION */
  } units_player[11];                /* 44 bytes */

  struct {
    uint16_t position;
    uint8_t  health;
    uint8_t  unit_type;
  } units_opponent[11];              /* 44 bytes */

  // AI state (4 bytes)
  uint8_t  opponent_personality;     /* 0=AGGRESSIVE, 1=DEFENSIVE, 2=ADAPTIVE, 3=ASYMMETRIC */
  uint8_t  opponent_threat_level;    /* 1-5 */
  uint8_t  opponent_phase;           /* For ASYMMETRIC: 0=CONSOLIDATION, 1=EXPANSION, 2=SEVERANCE */
  uint8_t  padding_ai;               /* Reserved for future AI state */

  // Payout tracking (4 bytes)
  uint16_t payout_base;              /* Base contract payout (500-8000) */
  uint16_t payout_bonuses;           /* Accumulated planning/execution bonuses */

  // Audio state (1 byte)
  uint8_t  psg_audio_state;          /* 0-8: current audio state machine state */

  // Padding and checksum (3 bytes)
  uint8_t  reserved[3];              /* Padding to align to 8-byte boundary */

  /* Total: 8 + 121 + 88 + 4 + 4 + 1 + 3 = 229 bytes (fits in 256-byte phase chain) */
} TakezoPhaseState;

/* Alternative compact layout (if 229 bytes is insufficient):
   Compress board_state[121] into 61 bytes (2 cells per byte using nibbles for 16 state values)
   Reduces struct to ~168 bytes, allowing 88 bytes for future expansion.
*/

Serialization Protocol

On Hot Swap OUT (Operator swaps away from TAKEZO):

Firmware calls takezo_serialize(&game_state, &phase_chain_buffer)
Magic number (0x54) + version written
Board state, unit positions, health values flattened
Opponent AI state (personality, threat level, phase) stored
Current payout totals stored
Audio state machine state (0-8) stored for seamless audio resumption
Checksum computed (CRC-8 of all 228 data bytes, stored in reserved[0])
Buffer written to SRAM at firmware-designated phase chain address

On Hot Swap IN (Operator swaps back to TAKEZO):

Firmware calls takezo_deserialize(&phase_chain_buffer, &game_state)
Magic number verified (0x54); if not, return error (corrupted state)
Version checked; if mismatch, reject state and restart fresh game
Board size, turn count, phase extracted
Board grid reconstructed from flattened array
Unit lists rebuilt from serialized unit structs
Opponent AI personality and state restored
Audio state machine restored (Cipher voice resumes mid-narration if needed)
Game loop resumed at exact board state where operator left

Hot Swap Scenarios

“Plan & Execute” (TAKEZO Phase 1 + ICE BREAKER Phase 2)

The operator plans a network intrusion strategy in TAKEZO (abstract board representing network topology). Then, the operator swaps to ICE BREAKER and executes the plan in real-time (actual network penetration).

TAKEZO payout: Base 500-2000¤ for planning phase (turn 1 only)
ICE BREAKER payout: Base 800-3500¤ for execution phase
Bonus: +300¤ if execution matches plan perfectly (operator follows their own strategy)
Phase Chain: TAKEZO state (PHASE_PLANNING, turn 1) serialized; ICE BREAKER loads and performs phase 2. On swap back, TAKEZO state preserved; game transitions to PHASE_EXECUTION with opponent responding.

“Strategic Analysis + Black Ledger Audit” (TAKEZO Phase 1 + BLACK LEDGER Phase 2)

The operator analyzes a hostile takeover scenario in TAKEZO. Then, they swap to BLACK LEDGER to audit the financial records and find evidence of the takeover plot.

TAKEZO payout: Strategic victory bonus (turn 1-15 analysis, then swap)
BLACK LEDGER payout: Forensic auditing bonus
Bonus: +200¤ if financial evidence matches TAKEZO scenario predictions
Phase Chain: TAKEZO state (board setup, unit positions) serialized; BLACK LEDGER performs audit with board context (e.g., Finance unit position maps to account server location in ledger). On swap back, TAKEZO resumes PHASE_EXECUTION with updated threat intelligence from BLACK LEDGER.

Memory Budget

Component	Bytes	Notes
Header	8	Magic, version, phase, board_size, turn_number, max_turns
Board state	121	Flattened 11×11 grid
Unit populations	88	22 units × 4 bytes (22 total across both sides)
AI state	4	Personality, threat level, phase, padding
Payout	4	Base + bonuses (16-bit each)
Audio	1	PSG state machine state (0-8)
Padding/Checksum	3	CRC-8 + reserved
Total	229 bytes	Fits within 256-byte limit with 27 bytes spare

The 27-byte spare can be used for:

Operator move history (5 bytes)
Synergy pair state (3 bytes)
Threat heatmap cache (16 bytes; optional, can be recomputed)
Future AI learning state (adaptive opponent pattern tracking)

9. MISSION TEMPLATES AND SCENARIO TYPES

Contract Classes

PATTERN RECOGNITION (Threat 1-2, Rep 0+)

Small boards (5×5)
Simple patterns (three units form a line, triangle, or square)
Operator has 8-15 turns to identify and execute winning pattern
No opponent; task is pure pattern recognition
Payout: 150-400¤

TACTICAL ANALYSIS (Threat 2-3, Rep 5+)

Medium boards (7×7)
Operator vs. Apprentice-level AI
15-25 turns; operator must defend assets and identify opponent weakness
Payout: 300-900¤

STRATEGIC PLANNING (Threat 3-4, Rep 15+)

Large boards (9×9)
Operator vs. Specialist-level AI
25-40 turns; multi-phase strategy required
Operator must plan 5+ moves ahead to win
Payout: 600-1800¤

ADVERSARIAL WARGAME (Threat 4-5, Rep 25+)

Very large boards (11×11)
Operator vs. Master-level AI
40-60 turns; maximum strategic depth
Operator must adapt plan as game progresses
Payout: 1500-4000¤

MASTERY CHALLENGE (Threat 5, Rep 35+)

Historical military or corporate scenarios
Operator must replicate historical victory (or prevent historical defeat)
Zero-error requirement (one strategic mistake = failure)
60+ turns; extreme complexity
Payout: 3000-8000¤ (if successful)

10. SESSION WALKTHROUGH: “THE STUDY”

60-Minute Threat 4 Adversarial Wargame

MINUTE 0:00 — Boot and Scenario Selection

The operator boots TAKEZO. Kōji Interactive loading screen (3.5 seconds). The cartridge initializes. The mission board shows 3-4 wargame scenarios (Threat 3-4). The operator selects “Corporate Takeover Defense” (estimated 50 turns, 3000¤).

Cipher voice: “Hostile acquisition in motion. Nine corporate moves until they control majority shares. You have eight defensive units. Deploy strategically. Think deep.”

MINUTE 1:00 — Planning Phase Setup

The board is displayed: 9×9 grid. Seven friendly units (representing Finance, IP, Comms, Executive, Legal, Engineering, Security). Ten enemy units (acquisition teams converging on the board). Two control points in the center (strategic assets that determine victory).

The operator’s task: Position units defensively such that the opponent cannot acquire majority control. The opponent is Specialist-level, moderately intelligent.

MINUTE 1:00 — Study Phase (10 minutes)

The operator presses INFO repeatedly, cycling through views:

Grid view: Raw positions of all units
Threat heatmap: Red zones = high danger, blue zones = safe
Influence map: Radiating circles showing how far each unit can defend
Lookahead preview: “If opponent attacks Finance on turn 1, your IP is undefended on turn 2”

The operator bookmarks key positions using QUOTE. They compare two defensive layouts using EQ. They preview hypothetical moves using APPLY (no commitment).

The Cipher voice offers hints: “Your Finance unit is exposed on three sides. Legal team can protect it, but then Comms is undefended. Choose your priority.”

MINUTE 11:00 — Insight Moment

The operator recognizes a pattern: Three units arranged in a triangle can defend all three sides. They position Finance-Legal-Comms in a defensive triangle at the board center. The Cipher voice confirms: “That formation holds against 85% of predicted attack patterns.”

The operator commits. EVAL pressed. Koto note plays (medium register = medium-risk strategy). The execution phase begins.

MINUTE 12:00 — Execution Phase (30 minutes)

The opponent reveals their strategy. They begin attacking with their acquisition teams.

Turns 1-5: Opponent probes operator’s defenses. Makes test moves. The operator’s triangle holds.

Turns 6-10: Opponent launches major assault on Finance (the financial flank). The operator’s defensive triangle absorbs the attack. Finance-Legal-Comms remain intact.

Turns 11-15: Opponent pivots. They attack IP sector (which operator defended lightly). The operator must decide: reinforce IP, or accept loss?

The operator makes a bold move: instead of reinforcing, they counter-attack opponent’s rear guard. A risky play. A high koto note sounds (high-risk move). The Cipher voice: “Bold. The opponent doesn’t expect counter-attack. But your rear is now exposed.”

The operator is betting on tempo advantage. A specialist player reading five moves ahead.

Turns 16-25: The counter-attack works. Opponent’s rear guard is overwhelmed. The opponent must retreat, protecting their rear units.

Turns 26-30: Final phase. Control of the board shifts. The operator’s strategic insight (the defensive triangle) held long enough for the counter-attack to work. The opponent is now on defense.

Turn 35: Victory. Opponent’s acquisition is blocked. Operator has maintained control of three critical assets. Mission complete.

MINUTE 42:00 — Reflection and Debrief

Cipher voice: “Masterful. You saw five moves ahead and prepared your counter. Most operators react. You anticipated. That is the difference between specialist and master.”

Payout calculation:

Base: 4 × 350 + 81 × 20 = 2,780¤
Planning bonus: Completed plan efficiently = +100¤
Execution bonus: Better than AI expected (70% AI confidence, 95% operator success) = +800¤
Mastery bonus: Large board (9×9 = 81 cells) × 1.3 difficulty = +105¤
Total: 3,785¤

Reputation: +7 (Threat 4)

The operator is now Rep 28. They are approaching Master tier (Rep 25+). They have proven they can think deeply and execute strategically.

11. DESIGN NOTES

Why No Time Pressure Matters

The fundamental design principle: Patience is the highest virtue. In a world of action games demanding split-second reflexes, TAKEZO says: “Slow down. Think. Mastery requires stillness.”

This serves multiple audiences:

Disabled and elderly players: Strategy games don’t require reflexes. They require only a sharp mind.
Deep thinkers: Players who love chess, Go, or tactical wargaming can play TAKEZO for 100+ hours without exhaustion.
Contemplative players: Players who find tempo-based games stressful find TAKEZO meditative and therapeutic.

The Musashi Philosophy

Takezo (Musashi’s birth name) mastered combat not through faster sword work, but through deeper understanding of his opponent’s mind. He would study an opponent’s patterns and exploit them.

TAKEZO the cartridge embodies this:

Study phase: The operator contemplates the board (like Musashi meditating before a duel)
Execution phase: The operator and opponent duel (like Musashi’s actual combat)
Reflection: The operator learns (like Musashi’s recorded meditations on combat)

The loop repeats. With each session, the operator becomes more like Musashi: deeper in understanding, wiser in judgment, more efficient in execution.

Cross-Module Depth

TAKEZO’s strategic depth is enhanced when combined with other cartridges:

With ICE BREAKER: Strategic planning translates to network intrusion planning. The operator’s board-level thinking scales to network-level intrusion.
With BLACK LEDGER: Takeover scenarios become forensic auditing scenarios. Strategic thinking about corporate control translates to financial auditing.
With DEPTHCHARGE: Submarine warfare tactics (depth positioning, evasion) become strategic board scenarios.

The operator who masters TAKEZO learns a universal strategic language. That language applies across all modules. This is the power of pattern mastery.

12. SCREEN WIREFRAMES

All screens fit the 80×25 character grid. Tactical board states are rendered as ASCII grids (9×9 max). Status bar (row 0) and action bar (row 24) are nOSh-runtime-owned. Content occupies rows 1-23.

Screen 1: Mission Board (Contract Selection)

ROW 0: TAKEZO > MISSION BOARD [REP: 28] [CREDITS: 4200] [MASTERY: 5/8] [CONTRACTS: 8]
ROW 1:
ROW 2: AVAILABLE CONTRACTS:
ROW 3:
ROW 4: ▸ PATTERN RECOGNITION        Threat 1  | Rep 0+  | Payout: 300 ¤
ROW 5:    Small 5×5 board. Identify winning pattern in 8 turns.
ROW 6:    Time estimate: 10 minutes
ROW 7:
ROW 8:   TACTICAL ANALYSIS          Threat 2  | Rep 5+  | Payout: 600 ¤
ROW 9:    Medium 7×7 board. Opponent: Apprentice AI. 20 turns. Pure tactics.
ROW 10:   Time estimate: 25 minutes
ROW 11:
ROW 12:  STRATEGIC PLANNING         Threat 3  | Rep 15+ | Payout: 1200 ¤
ROW 13:   Large 9×9 board. Opponent: Specialist AI. 30+ turns. Deep strategy.
ROW 14:   Time estimate: 50 minutes
ROW 15:
ROW 16:  ADVERSARIAL WARGAME        Threat 4  | Rep 25+ | Payout: 3000 ¤
ROW 17:   Master-level AI. 11×11 board. Strategic mastery required.
ROW 18:   Time estimate: 90+ minutes
ROW 19:
ROW 20: (Press CAR to inspect, CDR to scroll, EVAL to accept contract.)
ROW 21:
ROW 22:  [CAR=details] [CDR=next] [EVAL=accept] [INFO=analyze] [SYS=menu]
ROW 23: MISSION BOARD | 8 CONTRACTS | REP: 28 | MASTERY: 5/8 | SELECTED: PATTERN

Screen 2: Planning Phase — Threat Heatmap View

ROW 0: TAKEZO > THREAT HEATMAP [PHASE: PLANNING] [TURN: 0/40] [UNITS: 7 YOUR / 7 OPP]
ROW 1:
ROW 2: BOARD STATE (9×9 hexagonal grid equivalent):
ROW 3:
ROW 4:   1 2 3 4 5 6 7 8 9
ROW 5: A . . . . . . . . .
ROW 6: B . . . . . . . . .
ROW 7: C . . █ . . . . . .   THREAT LEVEL HEATMAP
ROW 8: D . . . ● . . . . .   ──────────────────────
ROW 9: E . . . . . . . . .   █ = CRITICAL (opponent attacks here next)
ROW 10: F . ● . . . . . . .   ▓ = HIGH (threatened in 2-3 moves)
ROW 11: G . . . . . . . . .   ▒ = MEDIUM (threatened in 4+ moves)
ROW 12: H . . . . . . . . .   ░ = LOW (relatively safe)
ROW 13: I . . . . . . . . .   . = SAFE (no current threat)
ROW 14:
ROW 15: UNIT LEGEND: ● = Your Units (AMBER) | ○ = Opponent (RED) | ◆ = Control Pts
ROW 16:
ROW 17: THREAT ASSESSMENT:
ROW 18:  Finance Unit (C3) ... HIGH (flanked by 2 opponent units, vulnerable position)
ROW 19:  IP Unit (D4) ....... MEDIUM (1 opponent unit adjacent, but defensible)
ROW 20:  Comms Unit (F6) .... LOW (4 spaces from nearest opponent, safe)
ROW 21:
ROW 22:  [CAR=select unit] [CDR=next view] [INFO=details] [APPLY=preview] [EVAL=plan]
ROW 23: THREAT HEATMAP | PLANNING PHASE | YOUR THREAT: HIGH | OPP THREAT: MODERATE

Screen 3: Execution Phase — Move Commitment

ROW 0: TAKEZO > EXECUTION [SELECTED: FINANCE] [TURN: 3/40] [OPPONENT: SPECIALIST AI]
ROW 1:
ROW 2: BOARD STATE:
ROW 3:
ROW 4:   1 2 3 4 5 6 7 8 9
ROW 5: A . . . . . . . . .
ROW 6: B . . . . . . . . .
ROW 7: C . . █ . . . . . .
ROW 8: D . . . ● . . . . .
ROW 9: E . . . . . . . . .
ROW 10: F . ● . . . . . . .
ROW 11: G . . . . . . . . .
ROW 12: H . . . . . . . . .
ROW 13: I . . . . . . . . .
ROW 14:
ROW 15: SELECTED UNIT: Finance (Corporate Assets) at C3
ROW 16:  Health: 80/100 | Threat Level: HIGH | Strategic Value: 9/10
ROW 17:  Mobility: 2 spaces/turn | Possible destinations: A3, B3, C1, C2, D3, E3
ROW 18:
ROW 19: MOVE OPTIONS:
ROW 20:  ▸ Move to C4 (defend center, block opponent advance toward core)
ROW 21:   Move to C5 (aggressive, threaten opponent unit at CRITICAL distance)
ROW 22:   Move to D3 (withdraw, reduce exposure to flanking attack)
ROW 23: EXECUTION PHASE | UNIT: FINANCE | MOBILITY: 2 | PRIORITY: DEFEND CENTER

Screen 4: Unit Detail & Synergy View

ROW 0: TAKEZO > UNIT DETAIL [UNIT: FINANCE] [POSITION: C3] [TURN: 15/40]
ROW 1:
ROW 2: UNIT: Finance (Corporate Assets)
ROW 3:  Owner: You (AMBER) | Position: C3 (3 spaces from board center)
ROW 4:
ROW 5: COMBAT STATE:
ROW 6:  Health: 80/100 [████████░░]
ROW 7:  Threat Level: 65/100 (HIGH — flanked by 2 opponent units)
ROW 8:  Defense Bonus: +0 (unpaired; +5 if paired with Legal unit)
ROW 9:
ROW 10: CHARACTERISTICS:
ROW 11:  Strategic Value: 90/100 (critical asset for payout)
ROW 12:  Mobility: 2 spaces/turn
ROW 13:  Capture Cost (to opponent): 3 actions (base 2 + threat penalty +1)
ROW 14:
ROW 15: POSSIBLE SYNERGIES:
ROW 16:  ▸ Finance + Legal = PROTECTED_ASSETS (+5 defense, +1 mobility)
ROW 17:    Legal unit is 1 space east at D3 (ADJACENT — ready to activate!)
ROW 18:
ROW 19:   Finance + Comms = CAPITAL_FLOW (improves payout extraction)
ROW 20:    Comms unit is 5 spaces away (out of synergy range)
ROW 21:
ROW 22:  [CAR=adjacent unit] [CDR=next unit] [INFO=threat] [EVAL=accept]
ROW 23: UNIT DETAIL | FINANCE | HEALTH: 80% | THREAT: HIGH | SYNERGIES: 1 READY

Screen 5: Move History & Replay View

ROW 0: TAKEZO > MOVE HISTORY [GAME: CORPORATE TAKEOVER] [SHOWING: TURNS 8-15]
ROW 1:
ROW 2: MOVE SEQUENCE (Operator=AMBER, Opponent=RED):
ROW 3:
ROW 4: ▸ Turn 8: Finance moves B3 → C3 (DEFENSIVE reposition)
ROW 5:   Risk: 35% | Opponent countered with Attack on IP (unsuccessful)
ROW 6:
ROW 7: ▸ Turn 9: IP moves D4 → D5 (dodge opponent attack)
ROW 8:   Risk: 28% | Tactical value: HIGH (escaped encirclement)
ROW 9:
ROW 10: ▸ Turn 10: Legal reinforces C3-Finance (PROTECTIVE pair)
ROW 11:  Risk: 15% | Synergy formed: PROTECTED_ASSETS active (+5 def, +1 mobility)
ROW 12:
ROW 13: ▸ Turn 12: Comms moves F6 → E5 (aggressive advance toward opponent core)
ROW 14:  Risk: 62% (AGGRESSIVE) | Tactical value: 85% (cutting supply lines)
ROW 15:
ROW 16: ▸ Turn 14: Executive moves E3 → E4 (reposition for counter-attack)
ROW 17:  Risk: 45% | Tactical value: 70% (threaten opponent Finance equivalent)
ROW 18:
ROW 19: ANALYSIS: Turn 12 (Comms advance) was the turning point. You are now ahead by
ROW 20: 3 board positions and controlling opponent's supply lines. Strong strategic play.
ROW 21:
ROW 22:  [CAR=rewind 1] [CDR=advance 1] [EVAL=jump to turn] [BACK=exit replay]
ROW 23: MOVE HISTORY | TURN: 15/40 | YOUR ADVANTAGE: MODERATE | STATUS: WINNING

Screen 6: AI Analysis View (Rep 15+ only)

ROW 0: TAKEZO > OPPONENT ANALYSIS [OPPONENT: SPECIALIST AI] [REP: 15+] [UNLOCKED]
ROW 1:
ROW 2: OPPONENT PROFILE:
ROW 3:  Type: ADAPTIVE (learns from your patterns across games)
ROW 4:  Recent Behavior: DEFENSIVE (last 5 moves all defensive)
ROW 5:  Predicted Phase: AGGRESSIVE (when strategic opportunity appears)
ROW 6:
ROW 7: OPPONENT HEATMAP (Predicted attack targets, next 3 turns):
ROW 8:
ROW 9:   1 2 3 4 5 6 7 8 9
ROW 10: A . . . . . . . . .
ROW 11: B . . . . . . . . .
ROW 12: C . . ⭐ . . ⭐ . . .   ⭐ = 85% likely opponent attacks here
ROW 13: D . . . ⭐ ⭐ ⭐ . . .   ◆ = 45% likely opponent defends
ROW 14: E . . . ◆ . . . . .
ROW 15: F . . . . . . . . .
ROW 16:
ROW 17: THREAT ASSESSMENT:
ROW 18:  Opponent Strongest Unit: Finance equivalent at C1 (90 health)
ROW 19:  Opponent Weakest Position: IP equivalent at G3 (isolated, low defense)
ROW 20:  Opponent Supply Lines: STABLE (well-connected 5-node core)
ROW 21:
ROW 22:  [INFO=learning patterns] [CAR=unit stats] [CONS=counters] [BACK=return board]
ROW 23: AI ANALYSIS | SPECIALIST AI | ADAPTIVE | GAMES SEEN: 4 | LEARNING: ENABLED

Screen 7: Territory Control & Influence Map

ROW 0: TAKEZO > TERRITORY CONTROL [TURN: 15/40] [YOUR: 37% / OPP: 33% / NEUTRAL: 30%]
ROW 1:
ROW 2: BOARD STATE (Territory ownership):
ROW 3:
ROW 4:   1 2 3 4 5 6 7 8 9
ROW 5: A . . . . . . . . .
ROW 6: B . . . . . . . . .
ROW 7: C . . ● ◆ . . . . .   ● = Your unit (AMBER)
ROW 8: D . . . ● . . . ○ .   ○ = Opponent unit (RED)
ROW 9: E . . . . . . . . .   ◆ = Contested control point
ROW 10: F . . ● . . . . . .   ⌛ = Fortified position (high defense)
ROW 11: G . . . . . . . . .
ROW 12: H . . . . . . . . .
ROW 13: I . . . . . . . . .
ROW 14:
ROW 15: TERRITORY OWNERSHIP:
ROW 16:  Your Territory: 30 cells (37%) | Opponent: 27 cells (33%) | Neutral: 24 (30%)
ROW 17:  Your Influence (soft blue halos): covers 28 cells (1-2 moves away)
ROW 18:  Opponent Influence (soft red halos): covers 25 cells (1-2 moves away)
ROW 19:
ROW 20: CRITICAL NODES: Node B1 (bridge) is CONTESTED (2v1 ratio, you hold advantage)
ROW 21: Node E4 (supply hub) is OPPONENT-CONTROLLED (avoid extending east now)
ROW 22:
ROW 23: TERRITORY VIEW | YOU: 37% | OPP: 33% | ADVANTAGE: SLIGHT | SUPPLY: SECURE

Screen 8: Game Completion & Mastery Report

ROW 0: TAKEZO > CONTRACT COMPLETE [GAME: PATTERN RECOGNITION] [STATUS: VICTORY] [FINAL]
ROW 1:
ROW 2: GAME SUMMARY:
ROW 3:  Contract: Pattern Recognition (Threat 1)
ROW 4:  Board Size: 5×5 | Opponent: Tutorial AI | Duration: 8 turns / 8 turn limit
ROW 5:  Final Outcome: VICTORY (all opponent units captured, control 100% board)
ROW 6:
ROW 7: PERFORMANCE METRICS:
ROW 8:  Territory Won: 25/25 cells (100%)
ROW 9:  Units Remaining: 5/5 (no losses, perfect preservation)
ROW 10: Efficiency Rating: 95/100 (minimal wasted moves)
ROW 11: Strategic Depth: 7/10 (pattern mastery, limited by small board)
ROW 12:
ROW 13: PAYOUT BREAKDOWN:
ROW 14:  Base Payout: 300 ¤ (contract base reward)
ROW 15:  Victory Bonus: +100 ¤ (clean win, no unit losses)
ROW 16:  Speed Bonus: +25 ¤ (completed in 8/8 turns, perfect efficiency)
ROW 17:  Mastery Bonus: +50 ¤ (flawless pattern recognition)
ROW 18:  TOTAL PAYOUT: 475 ¤
ROW 19:  REPUTATION GAIN: +6 (pattern mastery +4, perfect execution +2)
ROW 20:
ROW 21: NEXT CHALLENGE UNLOCKED: Tactical Analysis (7×7 board, Rep 5+ required)
ROW 22:
ROW 23: CONTRACT COMPLETE | VICTORY | PAYOUT: 475 ¤ | REP: +6 | NEXT: TACTICAL

SUMMARY

TAKEZO is the cartridge for the operator who wants to think deeply. It is turn-based, unlimited-time, and meditative. The core loop is study → plan → execute → reflect. The YM2149 produces a contemplative soundscape of koto and shamisen. The opponent is an AI personality that learns and adapts. The operator’s skill is measured by their ability to see 5-7 moves ahead and execute a coherent multi-turn strategy.

TAKEZO is inspired by Miyamoto Musashi’s philosophy: mastery through contemplation, not haste. It is a game for the patient, the thoughtful, and the strategic. It is the counterweight to ICE BREAKER’s tempo-driven intensity.

For operators who play TAKEZO, the cartridge becomes a teacher. Each game teaches pattern recognition. Each loss teaches humility. Each victory teaches mastery. After 100 hours of play, the operator doesn’t just have a high reputation. They have become a strategic thinker. That skill transfers to every other module. That is the depth of TAKEZO.

CIPHER-LINE Contributions

Takezo’s voice: Go commentator turned monk. Clipped observations on the board. Silence is contemplation. Fragments reference Musashi-era austere images.

Vocabulary Pools

(:subject       "stone" "shape" "wall" "group" "ko"
                "pattern" "shape" "eye" "territory" "sente")
(:object        "corner" "edge" "center" "liberty" "atari")
(:location      "board" "corner" "side" "center" "ring")
(:verb-present  "holds" "threatens" "dies" "lives" "connects"
                "cuts" "watches")
(:verb-past-participle "taken" "sealed" "lost" "mirrored"
                       "connected" "cut")
(:memory-keyword "shape" "ko" "wall" "sente" "territory")
(:affect-word   "thin" "heavy" "clean" "dead" "alive")

Production Fragments

(:mode-observe
  (3 (:subject) ". " (:affect-word) ".")
  (2 (:location) ". " (:verb-present) ".")
  (1 "sente."))

(:mode-annotate
  (3 "that shape. " (:affect-word) ".")
  (1 "two eyes.")
  (1 "dead."))

(:mode-reflect
  (3 "same ko. " (:memory-fragment))
  (2 "this shape. " (:memory-fragment)))

(:mode-drift
  (2 "the corner from the tournament.")
  (1 "one eye. never enough.")
  (1 "musashi's rain."))

:event-types
  ((:type :move-committed   :affect (:routine))
   (:type :shape-completed  :affect (:significant))
   (:type :group-died       :affect (:significant :anomalous))
   (:type :pattern-recognized :affect (:significant)))

Mode-Weight Biases

Beat	`observe`	`annotate`	`reflect`	`drift`	`silent`
`:active-hack`	−0.10	—	+0.05	+0.10	+0.15
`:idle` (player thinking)	—	—	+0.10	+0.15	+0.10
`:debrief`	—	+0.10	+0.15	—	—

Rationale. Takezo is slow. Voice defers to silence, then drifts across old boards during thinking time. Debrief is reflective — “same shape as the tournament.”

Style Deltas

((:active-hack (:terseness +56 :certainty +32 :temporal-blur +24))
 (:idle        (:temporal-blur +64))
 (:debrief     (:terseness +16 :certainty +40)))

Takezo’s voice is unusually certain (the board is knowable) and unusually blurred temporally (every board recalls every prior board).

Structurally Important Moments Preserved on CIPHER-LINE

Beat	Intent	CIPHER-LINE fragment(s)
Move committed	(no narration needed)	`(silent)`
Winning shape recognized	”Pattern identified. Double threat.”	`shape.` then `double.` (reflect)
Group died	”Group lost. Fifteen points.”	`dead.` (one fragment; let it hit)
Master victory	”Master-level match won. Exceptional.”	`master. beaten.` (debrief)

nEmacs Contributions

Per ADR-0016 (nEmacs + REPL + Input Model), each cart declares what its scripted-mission surface looks like — grammar fragments contributed to the predictive palette, domain vocabulary that earns the +5 ranking boost (ADR-0016 §7), whether it uses prompt-text for raw text entry (§8), and whether any of its keys bind :double-tap or :long-press events (§9). Takezo is the anti-tempo cart — contemplative, pattern-driven, played entirely through observation and move commitment. Its scripting surface is intentionally absent.

Scripted Missions?

No. Takezo is pure primitive-and-numpad — observe the board, commit the move, cycle. Scripting a Go-like game undercuts the entire point: pattern mastery is embodied, not compositional. The cart has no scripted-mission contracts, and the Takezo Institute publisher aesthetic explicitly rejects automation (“the move you do not make is as important as the one you do”). Takezo ships without scripted-mission support on the critical path and does not unlock one at high reputation. This places Takezo firmly in the “primitive-orchestration only” subset of 14 launch carts (ADR-0002 explicitly allows this).

Cart Grammar Fragments

Minimal read-only introspection for REPL inspection (an advanced operator may want to query the cart’s internal state for study purposes), but no action primitives and no scripted-mission forms:

(emacs-extend-grammar
  (board)                                       ; current board state
  (board-size)
  (stone              (coord))                  ; :self :adversary nil
  (group-of           (coord))
  (liberties-of       (group))
  (move-history)                                ; read-only replay
  (last-move)
  (adversary-level)
  (campaign-phase))

No action primitives. No event binders. Moves commit via numpad + EVAL, not Lisp.

Vocabulary Contribution

Via (emacs-extend-vocabulary ...). Go-player / pattern terms. Takezo’s vocabulary is deliberately poetic — these are terms the Institute’s supplementary texts use, reinforcing the cart’s pedagogical tone:

(emacs-extend-vocabulary
  "stone" "board" "group" "chain" "liberty"
  "eye" "shape" "wall" "ladder" "net"
  "atari" "seki" "ko" "snapback" "throw-in"
  "fuseki" "joseki" "tesuji" "yose"
  "opening" "midgame" "endgame"
  "sente" "gote" "kikashi"
  "invasion" "reduction" "framework" "moyo"
  "territory" "influence" "thickness"
  "pattern" "shape" "threat" "double"
  "master" "student" "balance" "restraint")

`prompt-text` FFI Usage

No. Move entry is numpad (coordinate pair). Adversary level is menu. Takezo declares nothing via prompt-text.

Double-Tap and Long-Press Bindings

Takezo opts into ADR-0016 §9 on INFO for board-analysis drill-down that serves the contemplative loop:

Key	`:tap`	`:double-tap`	`:long-press`
`INFO`	`inspect-stone`	`inspect-group` — whole connected group + liberties	`show-local-shape-library` — compare current cell to named shapes from the Institute’s pattern corpus

All other Takezo keys bind :tap only — the cart honors single-press intentionality. Row 24 renders: INFO:STONE INFO²:GROUP INFO…:LIB EVAL:COMMIT BACK:UNDO.

Context-Polymorphic Key Semantics (Cart Gameplay)

Takezo has one primary cursor context — board view — plus a study view for post-game review:

Key	Board view	Study view
`INFO`	inspect-stone	show-move-commentary
`CAR`	descend-into-group	enter-variation
`CDR`	cycle-group	next-move
`EVAL`	commit-move	re-play-from-here
`QUOTE`	flag-move (self-marker for reflection)	bookmark
`BACK`	undo-selection-pointer	exit-study
Numpad	coordinate entry	move-number select

When the operator opens nEmacs — to probe board state from the REPL, nothing more — dispatch yields to :nemacs-nav per ADR-0016 §3. Takezo freezes the match timer; the Institute’s fiction is that study is never wasted.