Bug: Stalemate condition is not detected; game continues past stalemate

[Nareshkumawat-star]

Describe the bug

When stalemate is reached (no legal moves, not in check), the game does not end or declare a draw.

Steps to Reproduce

1. Engineer a stalemate position
2. Observe the game does not declare Draw

Expected Behavior

Game should stop the clock and show "Draw by Stalemate".

Files to Investigate

engine.py / main.cpp — move generation and game-over detection logic.

[coderabbitai]

Coding Plan

Summary

• root cause is check_game_status() silently returning 'ok' when engine subprocess fails
• fix by adding inline fallback stalemate detection that runs when subprocess unavailable
• add helper methods for legal move enumeration and attack detection to support fallback
• harden response parsing with try/except to catch malformed responses

Design Choices

Design Choice 1: why is stalemate consistently not detected when engine logic is correct?

Options Considered:

1. engine subprocess not starting at all (environmental/path issue)
2. check_game_status() silently returning 'ok' on failed/malformed responses
3. some edge case in move generation we missed

Chosen Option: 2

Rationale: the code explicitly returns 'ok' as fallback when engine response is None or unparseable, and theres no try/except around the split()[1] call which could raise IndexError on malformed responses

💡 User Tips

Regenerate the plan with different choices with @coderabbitai <feedback>.

Implementation Steps

Phase 1: Fix Silent Failure in Status Detection

the core issue is check_game_status() masks failures by returning 'ok'. we need to make it actually detect stalemate when subprocess fails, either by fixing the communication or adding inline fallback logic.

Task 1: Add Fallback Stalemate Detection in check_game_status()

when engine subprocess returns None or malformed response, compute stalemate detection directly in python instead of returning 'ok'. this ensures stalemate is caught even if subprocess communication breaks.

• update game/engine.py check_game_status() to implement inline fallback when _call_engine returns None or response parsing fails
• the fallback should enumerate all pieces of current_turn, check if any have legal moves (moves that dont leave king in check), and return 'stalemate' if none exist and king is not in check
• reuse existing board state from self.board and existing helper methods where available
• wrap resp.split()[1] in try/except to catch IndexError on malformed single-token responses

Task 2: Add Helper Method for Inline Legal Move Detection

create a helper that checks if current player has any legal moves without requiring subprocess call. this supports the fallback logic.

• add _has_any_legal_move() method in game/engine.py ChessGame class
• iterate all squares, for each piece of current_turn generate candidate moves
• for each candidate move, check if it leaves king in check (make move, check if king attacked, restore)
• return True on first legal move found, False if none exist
• add _is_king_in_check() helper if not already present to support this

Task 3: Add Helper for King Attack Detection

need to check if king is in check for distinguishing stalemate from checkmate in fallback path.

• add _is_square_attacked(row, col, by_color) method in game/engine.py if not already present
• check all attack vectors: knights, sliding pieces (rook/bishop/queen rays), pawns, enemy king
• this mirrors the logic in main.py is_square_attacked() but operates on self.board

🤖 Prompt for AI agents

fix the silent failure in `check_game_status()` in `game/engine.py` by adding
inline fallback stalemate detection and supporting helper methods.

- in `check_game_status()`, wrap `resp.split()[1]` in a try/except for
`IndexError` so malformed single-token responses fall through to fallback logic
instead of crashing or returning 'ok'
- when `_call_engine` returns `None` or response parsing fails, do not return
'ok' -- instead run inline stalemate detection using the current board state
(`self.board`)
- the fallback logic should: enumerate all pieces belonging to `current_turn`,
check if any have legal moves (moves that don't leave the king in check), and
return 'stalemate' if none exist and the king is not in check

add the following helpers to the `ChessGame` class in `game/engine.py`:
- `_has_any_legal_move()`: iterate all squares, for each piece of current_turn
generate candidate moves, for each candidate make the move, check if king is
attacked, restore the board -- return True on first legal move found, False if
none exist
- `_is_king_in_check()`: use `_is_square_attacked` to check if current player's
king is under attack
- `_is_square_attacked(row, col, by_color)`: check all attack vectors (knights,
sliding pieces via rook/bishop/queen rays, pawns, enemy king) -- mirrors the
logic in `main.py is_square_attacked()` but operates on `self.board`

Phase 2: Verify and Harden Subprocess Communication

ensure the subprocess layer is working correctly and failures are visible rather than silent.

Task 1: Add Defensive Response Parsing

harden the parsing logic in check_game_status() to handle edge cases.

• wrap response parsing in try/except for IndexError
• if resp is not None but malformed, fall through to fallback detection rather than returning 'ok'
• ensure whitespace variations in engine response dont break parsing (strip, handle multiple spaces)

Task 2: Verify Engine Subprocess Startup

confirm the engine subprocess is actually starting and the path resolution works.

• check _start_engine() in game/engine.py for correct binary/script path resolution
• verify the subprocess is actually started when ChessGame is instantiated
• if subprocess fails to start, the fallback detection from task 1.1 will handle it

🤖 Prompt for AI agents

harden the subprocess communication layer in `game/engine.py` to make failures
visible and parsing robust.

- in `check_game_status()`, wrap response parsing in try/except for `IndexError`
-- if `resp` is not None but malformed, fall through to fallback detection
rather than returning 'ok'
- strip whitespace and handle multiple spaces when parsing engine responses so
minor formatting variations don't break parsing
- review `_start_engine()` in `game/engine.py` to confirm binary/script path
resolution is correct and the subprocess is actually started on `ChessGame`
instantiation -- no logic changes needed if correct, the fallback from phase 1
covers startup failures

Research

chess engine uses a subprocess architecture - game/engine.py (django layer) talks to either a c++ binary or python fallback (game/engine/main.cpp or main.py) via stdin/stdout. both engines correctly implement stalemate detection in handleStatus/handle_status. the bug is in the communication layer: check_game_status() returns 'ok' when the engine call fails or returns malformed data, hiding actual stalemate conditions.

---

🚀 Next Steps

🤖 All AI agent prompts combined

Task: 1

fix the silent failure in `check_game_status()` in `game/engine.py` by adding
inline fallback stalemate detection and supporting helper methods.

- in `check_game_status()`, wrap `resp.split()[1]` in a try/except for
`IndexError` so malformed single-token responses fall through to fallback logic
instead of crashing or returning 'ok'
- when `_call_engine` returns `None` or response parsing fails, do not return
'ok' -- instead run inline stalemate detection using the current board state
(`self.board`)
- the fallback logic should: enumerate all pieces belonging to `current_turn`,
check if any have legal moves (moves that don't leave the king in check), and
return 'stalemate' if none exist and the king is not in check

add the following helpers to the `ChessGame` class in `game/engine.py`:
- `_has_any_legal_move()`: iterate all squares, for each piece of current_turn
generate candidate moves, for each candidate make the move, check if king is
attacked, restore the board -- return True on first legal move found, False if
none exist
- `_is_king_in_check()`: use `_is_square_attacked` to check if current player's
king is under attack
- `_is_square_attacked(row, col, by_color)`: check all attack vectors (knights,
sliding pieces via rook/bishop/queen rays, pawns, enemy king) -- mirrors the
logic in `main.py is_square_attacked()` but operates on `self.board`
===============================================================================

Task: 2

harden the subprocess communication layer in `game/engine.py` to make failures
visible and parsing robust.

- in `check_game_status()`, wrap response parsing in try/except for `IndexError`
-- if `resp` is not None but malformed, fall through to fallback detection
rather than returning 'ok'
- strip whitespace and handle multiple spaces when parsing engine responses so
minor formatting variations don't break parsing
- review `_start_engine()` in `game/engine.py` to confirm binary/script path
resolution is correct and the subprocess is actually started on `ChessGame`
instantiation -- no logic changes needed if correct, the fallback from phase 1
covers startup failures

💡 Iterate on the plan with: `@coderabbitai` <feedback>

Example Feedback
- `@coderabbitai` You can skip phase 3. Add a simple unit test case for phase 2.
- `@coderabbitai` For design choice 1 go ahead with option 3 and replan.

---

💬 Have feedback or questions? Drop into our discord!