Formal Specification
Malaysian Traditional Hopscotch — Formal Specification
Malaysia · dexterity-small · Confidence: low
← Back to game pageImplementation Suitability
Suitability: engine-readyFidelity: probabilistic-proxyGap-fills: 2
# Teng-Teng / Ketinting — AI-optimized specification
## General idea
A turn-based sequential jumping and territory-claiming game on a 9-cell topological graph. Agents execute a progression of marker throws and single-legged traversal paths, eventually conducting stochastic blind throws to claim exclusive cells as resting houses that permanently restrict opponent movement paths.
## Formal model
- **Abstraction taken:** The 2D hopscotch grid is represented as a directed graph of 9 numbered cells. Marker throws and single-legged hops are modeled as discrete state transitions with Gaussian throw dispersion and balance failure probabilities.
- **Player/agent count:** agents (), taking sequential turns.
- **Turn model:** Sequential individual turns.
## Formal rules
R1. Graph topology: .
- Cells 1, 2, 3, 6, 9 are single-hop cells (1 foot).
- Cells (4, 5) and (7, 8) are paired wing cells (simultaneous 2-foot landing).
- Adjacency defines the forward traversal path and reverse return.
R2. State tracking:
- Per-cell ownership: `owner[9]`, initialized to .
- Per-agent state: `current_target_box[N]` , `house_count[N]` , `completed_circuit_flag[N]` (boolean).
R3. Phase 1 — Marker Throw: Active agent aims marker at target cell .
- Landing coordinate is sampled from .
- If marker touches boundary or lands in wrong cell, throw faults; turn ends.
R4. Phase 2 — Traversal: If throw succeeds, agent hops the graph from cell 1 to 9 and back:
- Must skip cell completely (no landing in the cell containing the marker).
- In an unclaimed single cell: Land on 1 foot (Success probability ).
- In paired cells: Land with both feet spread.
- In own house (`owner == i`): May rest on both feet (100% success).
- In opponent's house (`owner == j \neq i`): Strictly forbidden to enter; must leap completely over the cell. If two adjacent cells are owned by opponents creating an impossible gap ( cells), the agent cannot jump and faults.
- On return leg: Agent retrieves marker from cell while balancing on adjacent cell, hops over , and exits.
- If all hops succeed: .
R5. Phase 3 — Claiming a House (*Rumah*): When , the agent executes a blind over-the-shoulder throw:
- Throw target is sampled over the entire board from a broad dispersion distribution.
- If marker lands inside an unclaimed cell (`owner[m] == UNCLAIMED`), set `owner[m] = i` and increment `house_count[i]`.
- Reset `current_target_box[i] \leftarrow 1` to start a new cycle.
R6. [gap-fill] Turn penalty: On any fault, the turn ends immediately without state advance; the next player in round-robin order acts.
R7. [gap-fill] Win condition: The game terminates when all 9 cells are claimed as houses (or when only 1 non-eliminated player remains capable of traversing the board). The agent owning the most houses wins.
## Edge cases
- Tie at the end condition: If two agents own equal numbers of houses at board saturation, the agent who claimed their first house earlier in the game wins.
- A player with no legal move: If opponent houses create an unbridgeable obstacle preventing forward traversal, the blocked agent is eliminated from further turns.
- Repetition / cycles: Bounded by the finite pool of 9 claimable cells.
- Simultaneous claims on the same resource: Turns are strictly sequential; a cell claimed by one agent is permanently locked.
- Player elimination mid-round: Blocked or fully faulted players are skipped in rotation.
- Resource exhaustion: Exactly 9 discrete cells on the grid.
- Termination guarantee: Each successfully claimed house monotonically reduces available territory until all 9 are occupied.
## State representation
- Persistent state: `owner[9]` (values in ), `target_box[N]`, `houses[N]`, `active_agent_id`.
- Observable information: Perfectly observable to all agents.
## Action space
- `throw_marker(target_cell_id)`.
- `hop_step(landing_cell_ids)`.
- `blind_house_throw()`.
## Playability notes
- Single-player-vs-AI: Engine-ready; easily simulated with Monte Carlo search or heuristic graph traversal.
- Group games (n>4): Standard round-robin multi-agent play.
- Physical-skill games: Real-world physical jumping stamina and single-leg balancing are parameterized via balance probabilities and jump span limits.
- What is lost: The exact micro-biomechanics of bending down to pick up a stone on one trembling leg is mapped to an execution probability.
## Implementation hints
Represent the 9-cell board as an array of ownership flags and an adjacency list. Implement graph leap validation (checking whether a jump over enemy houses exceeds max hop distance of 1 cell).
Download as JSON
Download the full game corpus entry for this game as structured JSON.
Download JSONCite this page
Malaysian Traditional Hopscotch (Malaysia). (n.d.). Games of Countries. https://gamesofcountries.com/games/my-malaysia/teng-teng
@misc{gamesofcountries-my-malaysia-teng-teng,
title = {Malaysian Traditional Hopscotch (Malaysia)},
year = {n.d.},
publisher = {Games of Countries},
url = {https://gamesofcountries.com/games/my-malaysia/teng-teng}
}