Formal Specification
Slipper Castle Knockdown & Tag — Formal Specification
Malaysia · dexterity-throw · Confidence: low
← Back to game pageImplementation Suitability
Suitability: engine-readyFidelity: probabilistic-proxyGap-fills: 4
# Baling Selipar — AI-optimized specification
## General idea
A multi-agent asymmetric spatial combat and structure-reconstruction game played on a discretized 2D grid court. One team (Attackers) must coordinate to knock down a central target tripod, scatter, and sequentially rebuild the structure piece by piece, while the defending team retrieves the projectile, passes between teammates with a stationary-throw constraint, and tags out all active attackers before reconstruction completes.
## Formal model
- **Abstraction taken:** Continuous player running and slipper throwing are mapped onto a discretized 2D grid graph ( cells). Slipper projectile trajectories are simulated as discrete ballistic lines with hit probabilities determined by target agent evasion status and line-of-sight distance.
- **Player/agent count:** 2 teams of 4 agents each (Team A: Attackers, Team B: Defenders).
- **Turn model:** Simultaneous discrete-time simulation ticks (). During each tick, all 8 agents choose movement or interaction actions simultaneously, followed by physics resolution (projectile flight, tags, and structure assembly).
## Formal rules
R1. Arena & coordinate system: A grid with center origin at .
- Slipper pyramid location: Cell .
- Attacker base line: .
- Structure state: , where denotes the number of standing slippers reconstructed.
R2. Phase 1 — Knockdown throw:
- Attackers sequentially take throwing actions from the base line targeting cell .
- Knockdown success probability per throw:
where is distance to origin.
- If all 4 attackers miss their assigned attempts (maximum 2 throws each), Phase 1 fails; teams immediately swap roles ( [gap-fill]).
- Upon a successful hit, , the 3 target slippers scatter to adjacent coordinates , the projectile lands at coordinate , and Phase 2 begins immediately.
R3. Phase 2 — Reconstruction & tag combat:
- Attacker movement & reconstruction:
- Attackers move up to 1 cell orthogonally/diagonally per tick ().
- When an active attacker occupies a cell with an uncollected scattered slipper, they may execute `collect_piece`.
- When an active attacker possessing a slipper occupies , they may execute `place_piece`, incrementing .
- Defender movement & passing:
- Defenders move up to 1 cell per tick.
- A defender occupying the projectile cell may execute `pickup_projectile`.
- **Stationary rule:** The defender holding the projectile cannot move (); they may only execute `pass(target_defender_id)` or `throw_tag(target_cell)`.
R4. Tag & elimination resolution:
- A `throw_tag` action traces a line trajectory to `target_cell`.
- If an active attacker is in the target cell, tag hit probability is:
- If hit, the attacker transitions to `ELIMINATED` and is removed from play.
- If an attacker possesses high agility and declares `catch_attempt`, they may intercept the projectile with probability ; if caught, the projectile is deflected away in a random direction.
R5. Defender exclusion zone: Defenders may not enter the zone centered at unless pursuing a live rolling projectile that landed inside it ( [gap-fill]).
R6. Victory condition:
- Attacker victory: When (all 3 pieces successfully rebuilt at origin), the attacking team scores +1 point and wins the round.
- Defender victory: If all 4 attackers transition to `ELIMINATED` before , the round ends with 0 points scored for attackers.
R7. [gap-fill] Round turnover: Teams alternate attacking and defending roles for 4 total rounds. Team with the highest cumulative points wins the match.
R8. [gap-fill] Hard round time ceiling: A round terminates automatically after (60 seconds). If time expires before reconstruction or elimination, the defending team is awarded the round win.
## Edge cases
- Tie at the end condition: If match score is tied after 4 rounds, sudden-death single-round playoff where the team achieving the fastest reconstruction time wins.
- A player with no legal move: In place wait (`WAIT`) is always a valid legal action for all agents.
- Repetition / cycles: Bounded strictly by the 120-tick round timer.
- Simultaneous claims on the same resource or position: If two attackers attempt to pick up the same slipper piece on the exact same tick, awarded to the agent with higher initiative index.
- Player elimination mid-round; turn order repair: Eliminated attackers drop any carried slipper at their current cell and exit the board; the remaining attackers continue play without turn-order disruption.
- Resource exhaustion (pieces, tokens, space, time): There are exactly 3 slipper pieces and 1 projectile; maximum round duration is 120 ticks.
- Termination guarantee: The round must terminate within 120 ticks due to hard timeout , piece reconstruction (), or complete attacker elimination.
## State representation
- Persistent state: `match_scores[2]`, `round_number` (), `attacking_team_id`.
- Grid state: occupancy grid, `pyramid_status`, `reconstructed_count` , `scatter_positions[3]`, `projectile_position`, `projectile_carrier_id` (or `None`).
- Agent state: For each agent : `(x, y, team, status, carrying_piece)`.
- Observable information: Fully observable by all agents (all positions, slipper locations, and projectile possession are public).
## Action space
- Attacker actions: `move(dx, dy)`, `collect_piece()`, `place_piece()`, `catch_attempt()`, `wait()`.
- Defender actions: `move(dx, dy)`, `pickup_projectile()`, `pass(teammate_id)`, `throw_tag(target_cell)`, `wait()`.
## Playability notes
- Single-player-vs-AI: Highly engaging; single human player controls the primary rebuilding attacker while AI teammates draw defender fire and AI defenders coordinate zone passing.
- Group games (n>4): Native 4v4 multi-agent adversarial environment.
- Physical-skill games: Real-time ballistics and dodging are abstracted into range-dependent probabilities and line-of-sight cell tracing.
- What is lost in the adaptation: The tactile physics of balancing rubber slippers against one another in wind/rough terrain is simplified to a 3-step placement counter.
## Implementation hints
Treat as a grid-world multi-agent pursuit-evasion game with a cooperative sub-goal. First milestone: implement defender passing relay and stationary-throw logic on a grid before enabling attacker reconstruction logic.
Download as JSON
Download the full game corpus entry for this game as structured JSON.
Download JSONCite this page
Slipper Castle Knockdown & Tag (Malaysia). (n.d.). Games of Countries. https://gamesofcountries.com/games/my-malaysia/baling-selipar
@misc{gamesofcountries-my-malaysia-baling-selipar,
title = {Slipper Castle Knockdown & Tag (Malaysia)},
year = {n.d.},
publisher = {Games of Countries},
url = {https://gamesofcountries.com/games/my-malaysia/baling-selipar}
}