Formal Specification
Beto / Portuguese Street Bat and Ball — Formal Specification
Portugal · stick-team · Confidence: low
← Back to game pageImplementation Suitability
Suitability: engine-readyFidelity: discretizedGap-fills: 4
# Jogo do Beto — AI-optimized specification
## General idea
A four-agent, two-team turn-based bat-and-wicket game. One team bowls to topple the wicket while the other defends, hits the ball into the field, and decides how many crossing runs to attempt between bases before fielders can retrieve the ball and break a wicket.
## Formal model
- **Abstraction taken:** The 14m field is discretized into 2 base positions and 3 outfield zones (Left, Center, Right) with associated fielding recovery times.
- **Player/agent count:** 4 agents (Team A: Batters A1, A2; Team B: Fielders B1, B2).
- **Turn model:** Round-based sequential phases: Pitch -> Batting Contact Check -> Fielding Recovery vs Running Decision.
## Formal rules
R1. Setup: Base 1 at `y = 0`, Base 2 at `y = 14`. Target score `S_win = 24` points. Initial roles: Team A = Batting, Team B = Fielding.
R2. Pitch Phase: Fielder B1 pitches to Batter A1 at Base 1. Pitch accuracy: `P(target_hit) = 0.60` [gap-fill].
R3. Batting Decision: Batter A1 chooses swing type `S in {defend_bunt, normal_drive, power_loft}`.
- If `defend_bunt`: Hit probability = 0.95, ball stays shallow (recovery time = 1 turn), catch probability = 0.05.
- If `normal_drive`: Hit probability = 0.75, ball travels to mid-court (recovery time = 2 turns), catch probability = 0.15.
- If `power_loft`: Hit probability = 0.50, ball travels deep (recovery time = 3 turns), catch probability = 0.30 [gap-fill].
R4. Resolution of Pitch & Bat:
- If miss and pitch hit target: Wicket toppled. Immediate dismissal: Team roles swap; 0 runs scored.
- If hit and caught on fly: Immediate dismissal: Team roles swap; 0 runs scored.
- If hit and uncaught: Ball is in play with `RecoveryTime = T_rec`.
R5. Running Phase: Batters A1 and A2 simultaneously choose how many runs `R in {0, 1, 2, 3}` to attempt.
- Time required to complete `R` runs is `T_run = R` turns [gap-fill].
- If `T_run <= T_rec`: All `R` runs succeed. Team A scores `R` points.
- If `T_run > T_rec`: Run out occurs. Batters score `max(0, T_rec)` points, but the running batter is dismissed (Team roles swap).
R6. Role Swap: Upon any dismissal (topple, catch, or run-out), the Fielding Team becomes the Batting Team and vice versa.
R7. Win condition: The first team to accumulate `>= 24` points wins the match.
## Edge cases
- Tie at the end condition: If both teams reach `>= 24` with equal points after equal batting half-innings, extra half-innings are played until one team leads at the end of a full round.
- A player with no legal move: Not applicable; choosing pitch/swing/run actions is always valid.
- Repetition / cycles: Bounded by maximum total innings capped at 30 [gap-fill].
- Simultaneous claims on the same resource or position: Batters commit running decisions simultaneously; the lowest chosen run count between the two partners dictates the safe run limit.
- Player elimination mid-round: If a player disconnects, their teammate executes both batting/fielding roles.
- Resource exhaustion (pieces, tokens, space, time): Finite inning cap ensures finite game trees.
- Termination guarantee: Monotonically increasing score during batting turns ensures eventual reach of 24 points.
## State representation
- Persistent state: `scores: [int, int]`, `batting_team: int (0 or 1)`, `inning: int`, `wickets_down: int`.
- Per-round ephemeral state: `pitch_accuracy: bool`, `bat_outcome: Enum (miss, hit, caught)`, `recovery_time: int`, `runs_attempted: int`.
- Minimal observable information: Fully observable public state.
## Action space
- Pitcher: `pitch(velocity: Enum)`: where `velocity in {fast, curve, steady}`.
- Batter: `bat(swing: Enum)`: where `swing in {defend_bunt, normal_drive, power_loft}`.
- Runner: `run(runs: int)`: where `runs in {0, 1, 2, 3}`.
## Playability notes
- Single-player-vs-AI: 2-agent reduction available (1 Batter controlling both runners vs 1 Fielder controlling both pitchers).
- Group games (n>4): Native 4-agent design (2v2) models authentic street communication and running risk calculation.
- Physical-skill games: Physical batting/running abstracted into discrete risk-reward decisions (bunt vs loft; run 1 vs push for 2).
- What is lost in the adaptation: The physical scramble of diving bats and throwing balls under pressure.
## Implementation hints
Discrete state machine with 3 sequential decision phases per delivery. Suggested milestone 1: Implement single delivery resolution (Pitch -> Swing -> Run Evaluation) and verify role swap mechanics.
Download as JSON
Download the full game corpus entry for this game as structured JSON.
Download JSONCite this page
Beto / Portuguese Street Bat and Ball (Portugal). (n.d.). Games of Countries. https://gamesofcountries.com/games/pt-portugal/jogo-do-beto
@misc{gamesofcountries-pt-portugal-jogo-do-beto,
title = {Beto / Portuguese Street Bat and Ball (Portugal)},
year = {n.d.},
publisher = {Games of Countries},
url = {https://gamesofcountries.com/games/pt-portugal/jogo-do-beto}
}