Formal Specification
Thai Tip-Cat — Formal Specification
Thailand · stick-team · Confidence: low
← Back to game pageImplementation Suitability
Suitability: adaptation-requiredFidelity: discretizedGap-fills: 4
# Mai Hueng — AI-optimized specification
## General idea
A traditional two-stick striking, fielding, and distance-scoring tip-cat game. A batting team launches a short wooden spindle (*Mai Luk*) from a ground trench using a long striking bat (*Mai Mae*) through four sequential batting stages of increasing technical difficulty, while the fielding team attempts to catch the projectile or throw it back to strike the trench bat. Points are scored based on the distance the spindle is driven, measured in multiples of the bat's length.
## Formal model
- **Abstraction taken:** The four physical striking techniques (Stage 1 Lever *Ngat*, Stage 2 Aerial Strike *Ti*, Stage 3 Juggle Strike *Hom*, Stage 4 Tipped Flip *Wat*) and outfield catching/throwing mechanics are modeled as stochastic outcomes parameterized by stroke difficulty and player attributes. Measured distances are converted to discrete integer points.
- **Player/agent count:** 2 teams of `K` players each (`K in [2, 6]`), designated as Batters and Fielders.
- **Turn model:** Sequential batter turns within innings; alternating team innings across 2 full innings per match.
## Formal rules
R1. Setup: The field extends from the trench origin `(0, 0)`. Fielders position themselves across outfield zones. Each team establishes a batting order of `K` players. The match lasts 2 full innings (each team bats twice).
R2. Inning Structure: The batting team sends batters sequentially to the trench. A batter attempts the four stages in order (Stage 1 -> Stage 2 -> Stage 3 -> Stage 4). An inning ends when all `K` batters on the team are declared out (*Tai*).
R3. [gap-fill] Stage Execution and Outcomes:
- **Stage 1 (Ngat - The Scoop):** The batter levers the spindle from the trench into the outfield. Distance `D ~ Uniform(10, 40)`. Fielder catch probability `P(catch) = 0.20`. If caught: batter is out. If uncaught, fielder throws spindle back at the bat resting over the trench; hit probability `P(hit_bat) = 0.30`. If hit: batter is out. Otherwise, batter advances to Stage 2 without scoring distance points.
- **Stage 2 (Ti - Toss and Strike):** The batter tosses and strikes the airborne spindle. Distance `D ~ Uniform(20, 60)`. `P(catch) = 0.25`. If caught: out. If uncaught, fielder throws back; batter can execute a defensive swing to deflect the spindle further (`P(deflect) = 0.40`, adding `+15` distance). Total distance is scored: `points += floor(D / 1.0)`.
- **Stage 3 (Hom - Juggle Strike):** The batter bounces the spindle `B` times on the bat (`B in [1, 3]`, higher `B` increases miss risk) before striking. Distance `D ~ Uniform(15, 45) * B`. If miss during juggle (`P(miss) = 0.15 * B`): out. If caught: out. Otherwise, `points += floor(D * B)`.
- **Stage 4 (Wat - Tip Flip Strike):** The batter taps the angled spindle tip to flip it airborne and strikes it mid-air. Distance `D ~ Uniform(30, 80)`. `P(whiff) = 0.30`. If whiff or caught: out. Otherwise, `points += floor(D * 2)`.
R4. [gap-fill] Batter Progression: If a batter completes Stage 4 without being put out, they loop back to Stage 1 to continue accumulating points until they are put out.
R5. [gap-fill] Inning Transition: When a batter is put out, the next batter in the batting order steps up at Stage 1. When all `K` batters are out, the batting team's half-inning concludes, and teams swap roles.
R6. [gap-fill] Match Victory: After both teams complete 2 batting innings, the team with the higher cumulative distance points wins. If tied, a sudden-death Stage 1 playoff between designated team champions decides the winner.
## Edge cases
- Tie at the end condition: Resolved via a 1-batter sudden-death Stage 1 launch contest (furthest distance wins).
- A player with no legal move: Not applicable; active batter must attempt the designated current stage stroke; fielding agents select defensive field distributions.
- Repetition / cycles: Bounded by the finite number of outs (every batter inevitably encounters an out event due to `P(out) > 0` at every stage) and the 2-inning match cap.
- Simultaneous claims on the same resource or position: When a spindle is hit into the outfield, fielding catch priority is assigned to the fielder closest to the landing coordinates.
- Player elimination mid-round; turn order repair: When a batter is put out, turn order advances deterministically to `(batter_index + 1) mod K`; when `batter_index == K - 1` and all batters are out, the half-inning closes cleanly.
- Resource exhaustion: Outfield space is unbounded; team roster size `K` and inning limits are strictly bounded.
- Termination guarantee: why the game provably ends: Because the probability of an out on any given stage is strictly positive (`P(out) >= 0.20`), the expected number of stages per batter is finite, and `K` batters across 2 innings guarantees almost-sure termination.
## State representation
- Persistent state:
- `current_inning`: integer in `[1, 2]`
- `batting_team`: `Team_A | Team_B`
- `team_scores[2]`: integer cumulative points
- `current_batter_index`: integer in `[0, K-1]`
- `active_outs`: integer in `[0, K]`
- `current_stage`: integer in `[1, 4]`
- Per-turn ephemeral state:
- `stroke_type`: current batting technique
- `sampled_trajectory`: `{ distance: float, landing_pos: (x, y), is_caught: boolean, hit_trench: boolean }`
- Observable information: Fully observable public state (scores, outs, current stage, and fielding positions are known to all agents).
## Action space
- Batter:
- `execute_ngat()`: Attempt Stage 1 lever fling.
- `execute_ti(power_level)`: Attempt Stage 2 toss and strike.
- `defend_swing()`: Defensive deflection during incoming fielder throw in Stage 2.
- `execute_hom(juggle_count)`: Attempt Stage 3 with `juggle_count in {1, 2, 3}`.
- `execute_wat(power_level)`: Attempt Stage 4 tip-flip strike.
- Fielders:
- `set_field_distribution(shallow, deep)`: Adjust outfield depth coverage to optimize catch probabilities.
## Playability notes
- Single-player-vs-AI: Natural turn-based team sports simulation; AI manages batting risk/reward decisions (e.g. number of bounces in Stage 3) and outfield positioning.
- Group games (n>4): Roster size `K` scales naturally from 2 to 6 players per team without altering the sequential inning mechanics.
- Physical-skill games: Fine kinetic timing (hitting a spinning airborne spindle) is represented via stage difficulty modifiers and miss/catch probabilities.
- What is lost in the adaptation: The auditory satisfaction of the spinning wood drone (*hueng*), the athletic sprint to catch a tumbling stick, and the post-game breath-holding running chant.
## Implementation hints
- Discrete event-driven loop matching baseball/cricket inning architectures.
- Suggested first milestone: Implement the 4-stage progression state machine for a single batter with uniform random outcomes, then expand to team rosters, innings, and fielding catch checks.
Download as JSON
Download the full game corpus entry for this game as structured JSON.
Download JSONCite this page
Thai Tip-Cat (Thailand). (n.d.). Games of Countries. https://gamesofcountries.com/games/th-thailand/mai-hueng
@misc{gamesofcountries-th-thailand-mai-hueng,
title = {Thai Tip-Cat (Thailand)},
year = {n.d.},
publisher = {Games of Countries},
url = {https://gamesofcountries.com/games/th-thailand/mai-hueng}
}