Skip to main content
Formal Specification

Corner Puss / Catch the Corners — Formal Specification

Türkiye · chase-tag · Confidence: low

← Back to game page

Implementation 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 JSON
Cite 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}
}