Skip to main content
Formal Specification

Stone Slab Pyramid Knockdown (Rrakadoçe) — Formal Specification

Albania · dexterity-throw · Confidence: low

← Back to game page

Implementation Suitability

Suitability: engine-readyFidelity: probabilistic-proxyGap-fills: 2
# Loja me rrasa — AI-optimized specification ## General idea A target-throwing and area-control contest on a 1D/2D grid. Throwing agents attempt to topple a central stone pyramid from a safe baseline. If the pyramid falls, a race unfolds where the Guard must execute discrete rebuild actions while Throwers execute sprint-recovery actions to retrieve their stones and retreat behind the baseline before the Guard completes the rebuild and initiates tags. ## Formal model - **Abstraction taken:** The 2D field is discretized into a 1D coordinate axis `x ∈ [0..L]` where `x = 0` is the Safe Baseline, `x = L/2` is the Neutral Field, and `x = L` is the Pyramid Base (`L = 20` grid cells). - **Player/agent count:** 1 Guard agent, `N` Thrower agents (default `N = 4`). - **Turn model:** Two-phase model: Sequential Throwing Phase, followed by Real-Time Ticked Movement/Rebuild Phase (or simultaneous grid tick updates). ## Formal rules R1. Setup: Pyramid at `x = L` has status `INTACT` (5 stone levels). Throwers `1..N` stand at `x = 0`, each holding 1 stone. Guard stands at `x = L`. R2. Phase 1 (Throwing): Throwers `1..N` sequentially execute `throw_at_pyramid(aim, power)`. - Hit check: Probability `P_hit = 0.40` [gap-fill: base accuracy]. - If hit: Pyramid state becomes `TOPPLED` (0/5 levels rebuilt). All thrown stones land at `x_stone_i ~ Uniform(L-4, L)`. Phase 1 ends immediately; advance to Phase 2. - If all `N` throwers miss: Pyramid remains `INTACT`. All stones land in field at `x_stone_i`. Advance to Phase 2 (Unprotected Retrieval). R3. Phase 2 (Tick Resolution): Time proceeds in discrete ticks `t = 1, 2, ...` - If `Pyramid == TOPPLED`: - Guard action per tick: `rebuild_step()`. Adds 1 level to pyramid (requires 5 total ticks to fully restore). Guard cannot tag while `levels < 5`. - Once `levels == 5`, Pyramid becomes `INTACT`; Guard may now execute `move(speed=2 cells/tick)` and `tag(target_thrower)`. - If `Pyramid == INTACT`: - Guard may immediately execute `move(speed=1.5 cells/tick)` and `tag()`. - Thrower actions per tick: `move(speed=2 cells/tick)`, `foot_dribble_stone()` (immune from tagging, speed=1 cell/tick), or `pickup_stone()` (vulnerable, speed=2 cells/tick). R4. Tag Resolution: If Guard enters same cell as a vulnerable Thrower (holding stone at `x > 0`), Thrower is `TAGGED`. - Tagged Thrower becomes the new Guard for the next round. Roles swap; round ends immediately. R5. Safe Recovery: If all `N` throwers return to `x = 0` holding their stones without being tagged, the Throwers score `+1` point; the same Guard remains on defense for round `r+1`. R6. Win condition: After `M = 10` rounds [gap-fill], the player who accumulated the fewest rounds as Guard (or highest Thrower score) wins. ## Edge cases - Tie at the end condition: Player with lowest total guard rounds wins; if tied, sudden-death 1v1 throw-off against a 3-level pyramid. - A player with no legal move: Not applicable; move/action set is non-empty on every tick. - Repetition / cycles: Bounded because tick phase forces either all throwers to reach `x = 0` or a tag within finite ticks (bounded by grid length `L`). - Simultaneous claims on the same resource or position: Resolved by explicit tick order: Thrower movement updates first, Guard movement updates second, Tag check resolves third. - Player elimination mid-round; turn order repair: A tagged thrower immediately terminates the active round and assumes the Guard role for round `r+1`. - Resource exhaustion (pieces, tokens, space, time): Stones are retrieved every round; pyramid stone count is constant (5 slabs). - Termination guarantee: why the game provably ends: Guaranteed because each round terminates within at most 50 ticks (finite arena boundaries and movement speeds), and match length is capped at `M = 10` rounds. ## State representation - Persistent state: `rounds_as_guard: array[N+1] of int`, `thrower_scores: array[N+1] of int`, `current_guard_id: int`, `round_num: int`. - Per-turn ephemeral state: `pyramid_status: {INTACT, TOPPLED}`, `rebuild_level: int (0..5)`, `positions: map[AgentID -> int]`, `stone_positions: array[N] of int`, `stone_held: array[N] of bool`. - Observable information: Fully observable by all agents. ## Action space - `throw_at_pyramid()`: Thrower action in Phase 1. - `move(direction: {-1, 0, +1})`: Spatial movement during Phase 2. - `pickup_stone()`: Grab stone from current cell. - `rebuild_step()`: Guard action to increment pyramid rebuild counter. - `tag(target_id: int)`: Guard action to tag a vulnerable thrower. ## Playability notes - Single-player-vs-AI: Natural; player controls Guard or Thrower squad against rule-based heuristic agents. - Group games (n>4): Fully supported; thrower squad can coordinate retrieval routes and decoy runs. - Physical-skill games: Stone throwing accuracy and sprinting speeds are discretized into grid coordinates and tick budgets. - What is lost in the adaptation: The physical weight and balance of stacking irregularly shaped flat river rocks under high adrenaline. ## Implementation hints Discrete 1D grid with tick-based movement. Branching factor is 3 per agent per tick (move left/stay/move right + context action). First milestone: Implement Phase 1 throwing and Phase 2 rebuild/retrieval tick simulation for 1 Guard vs. 2 Throwers.

Download as JSON

Download the full game corpus entry for this game as structured JSON.

Download JSON
Cite this page

Stone Slab Pyramid Knockdown (Rrakadoçe) (Albania). (n.d.). Games of Countries. https://gamesofcountries.com/games/al-albania/loja-me-rrasa

@misc{gamesofcountries-al-albania-loja-me-rrasa,
  title = {Stone Slab Pyramid Knockdown (Rrakadoçe) (Albania)},
  year = {n.d.},
  publisher = {Games of Countries},
  url = {https://gamesofcountries.com/games/al-albania/loja-me-rrasa}
}