Formal Specification
Corner Puss / Catch the Corners — Formal Specification
Türkiye · chase-tag · Confidence: low
← Back to game pageImplementation Suitability
Suitability: engine-readyFidelity: discretizedGap-fills: 2
# Köşe Kapmaca — AI-optimized specification
## General idea
A position-swapping reflex game played on a 2D discrete grid representing a square. Four agents occupy the corners of the square, and one seeker (*ebe*) occupies the center. Corner agents must coordinate simultaneous swaps while the seeker tries to intercept them or steal a vacant corner.
## Formal model
- **Abstraction taken:** The 4 corners and center are mapped to discrete coordinates on a 2D grid. [gap-fill] The physical swap is resolved as a tick-based travel path where agents are vulnerable while transit coordinates are not equal to corner markers.
- **Player/agent count:** 5 players (1 ebe `E`, and 4 corner players `P_0..P_3`).
- **Turn model:** Real-time ticked. Each tick, all agents simultaneously declare their movement or signaling action.
## Formal rules
R1. State representation:
- Four corners of a square:
- `C_0 = (-3.0, 3.0)` (Top-Left)
- `C_1 = (3.0, 3.0)` (Top-Right)
- `C_2 = (3.0, -3.0)` (Bottom-Right)
- `C_3 = (-3.0, -3.0)` (Bottom-Left)
- Center: `(0, 0)`
- `positions: Array[5] of Coordinate(x, y)` (representing `E` and `P_0..P_3`).
- `corner_occupant: Array[4] of integer` (ID of player occupying corner `0..3`, or -1 if vacant).
- `swap_state: State` (idle, signaling, swapping).
R2. Initialization:
- `positions[P_i] = C_i` for `i ∈ [0..3]`.
- `corner_occupant[i] = P_i`.
- Seeker position `positions[E] = (0, 0)`.
R3. The Signaling and Swapping Loop:
- Corner players `P_i` and `P_j` can coordinate a swap.
- Coordination steps:
- Step 1: `P_i` sends a swap request to `P_j`.
- Step 2: `P_j` accepts.
- Step 3: On the next tick, both `P_i` and `P_j` transition to `SWAPPING`.
- When transitioning to `SWAPPING`:
- `corner_occupant[i] = -1` (Corner `i` becomes vacant).
- `corner_occupant[j] = -1` (Corner `j` becomes vacant).
- Their targets are set: `target[P_i] = C_j`, `target[P_j] = C_i`.
R4. Active Movement:
- On each tick during `SWAPPING`:
- Swapping players move towards their targets: `pos = pos + unit_vector_to_target * speed(p)`.
- The Seeker `E` can move towards any coordinate: `pos_E = pos_E + unit_vector * speed(E)`.
- Safe Status: A player `P` is safe if they are inside a radius of `0.2` meters around any corner `C_k`, and `corner_occupant[k] == P` or `-1`.
R5. Seeker Interception:
- On any tick:
- **Stealing Corner:** If `E` reaches a vacant corner `C_k` (distance to `C_k <= 0.2` meters):
- `E` occupies the corner: `corner_occupant[k] = E`.
- The runner `P` whose target was `C_k` is left cornerless.
- `P` becomes the new `Ebe`, `E` joins as a corner player. Round ends.
- **Tagging Runner:** If `E` tags an active runner `P` (distance `E` to `P <= 0.3` meters while `P` is not safe):
- `P` is tagged.
- `P` becomes the new `Ebe` immediately. Round ends.
R6. Passive Play Penalty:
- [gap-fill] If no swap occurs for 20 consecutive ticks, a mandatory swap is forced: two random corner players are selected and forced to swap immediately on the next tick.
R7. End condition:
- Bounded by a fixed time limit or a set number of rounds.
R8. Win condition: The player who spent the least amount of ticks as the Seeker wins.
## Edge cases
- **Tie at the end condition:** Shared victory.
- **A player with no legal move:** Not applicable.
- **Repetition / cycles:** The forced-swap rule (R6) prevents infinite stalling.
- **Simultaneous claims on the same resource:** If the seeker `E` and runner `P` reach the corner `C_k` on the exact same tick, the runner is given priority (is safe) to prevent frustrating race conditions.
- **Player elimination mid-round:** Not applicable.
- **Resource exhaustion:** Not applicable.
- **Termination guarantee:** Guaranteed by the countdown clock and forced swap timers.
## State representation
- Persistent state:
- `positions: Array[5] of Coordinate`.
- `corner_occupant: Array[4] of integer`.
- `seeker_id: integer`.
- `scores: Array[5] of integer` (ticks spent as Ebe).
- Observable information: Public, fully observable.
## Action space
- `send_swap_request(target_id)`: send signal. Valid only for corner players.
- `accept_swap_request(sender_id)`: accept signal. Valid only for corner players.
- `move_agent(vector)`: move within speed limit. Valid for all players.
## Playability notes
- Single-player-vs-AI: Highly suitable. The player can play as a corner agent, coordinating swaps with AI corner mates and trying to trick the AI center seeker.
- Group games: Generalizes perfectly to 5 players.
- Physical-skill games: Physical running and signaling are fully abstracted into coordinate grids and state machine transitions.
- What is lost: The physical winks, body-starts, and sudden direction changes.
## Implementation hints
Low-medium complexity. Tracks 5 coordinates and 4 corner markers. Implement the signaling state transitions (R3) and the distance checks for corner occupancy (R5) first. First milestone: build the 4-corner board representation and implement the seeker corner stealing.
Download as JSON
Download the full game corpus entry for this game as structured JSON.
Download JSONCite this page
Corner Puss / Catch the Corners (Türkiye). (n.d.). Games of Countries. https://gamesofcountries.com/games/tr-turkiye/kose-kapmaca
@misc{gamesofcountries-tr-turkiye-kose-kapmaca,
title = {Corner Puss / Catch the Corners (Türkiye)},
year = {n.d.},
publisher = {Games of Countries},
url = {https://gamesofcountries.com/games/tr-turkiye/kose-kapmaca}
}