Formal Specification
Stone Slab Pyramid Knockdown (Rrakadoçe) — Formal Specification
Albania · dexterity-throw · Confidence: low
← Back to game pageImplementation 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 JSONCite 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}
}