Formal Specification
Turkish Peg-Stick Game (Met / Sülü) — Formal Specification
Türkiye · stick-team · Confidence: low
← Back to game pageImplementation Suitability
Suitability: adaptation-requiredFidelity: discretizedGap-fills: 3
# Çelik Çomak — AI-optimized specification
## General idea
A physical team game where a batting agent strikes a short peg (*çelik*) into a 2D field, and a fielding team attempts to catch it or throw it back to hit the home base. The physical batting distance, catching chance, and throw-back accuracy are modeled stochastically, focusing agent strategy on hit angle/force selection and fielder positioning.
## Formal model
- **Abstraction taken:** The 2D field, stick launching, and manual distance measurement are represented on a 2D coordinate plane centered at the *ocak* (0,0). [gap-fill] The physical swing and ball flight are abstracted into a random landing coordinate vector.
- **Player/agent count:** 2 teams of equal size `K` (where `K ∈ [2..6]`).
- **Turn model:** Sequential batting within an inning. Once all batting team members are out, roles swap.
## Formal rules
R1. State representation:
- `batting_team: integer` (0 or 1).
- `batting_order: List of integer` (active batters).
- `active_batter_index: integer`.
- `scores: Array[2] of integer` (team scores).
- `celik_position: Coordinate(x, y)` (starts at (0,0)).
- `fielder_positions: Array[K] of Coordinate(x, y)` (distributed on y > 0).
R2. On a batting turn, the active batter `b` selects a hit force `F ∈ [1..10]` and target angle `θ ∈ [0..180]` degrees.
R3. Hit resolution:
- The peg's landing position `L = (x_l, y_l)` is sampled:
- `Distance D = F * 10.0 * random(0.8, 1.2) * skill(b)`.
- `x_l = D * cos(θ) + noise_x`.
- `y_l = D * sin(θ) + noise_y`.
R4. Catch phase:
- [gap-fill] For each fielder `f`, the probability of catching the peg in mid-air is:
`P(Catch_f) = skill(f) * max(0.0, 1.0 - distance(fielder_f, L) / 5.0)`
(only fielders within 5.0 meters can catch).
- If any fielder catches:
- Batter `b` is OUT. `celik_position` resets to (0,0). Turn passes to the next batter.
- If uncaught, the closest fielder `f_close` moves to `L` to retrieve the peg.
R5. Throw Back phase:
- The retrieving fielder `f_close` throws the peg back toward (0,0).
- `P(Hit_Ocak) = skill(f_close) * (1.0 - distance(L, (0,0)) / 100.0)`.
- If `Hit_Ocak` is successful:
- Batter `b` is OUT. `celik_position` resets to (0,0). Turn passes to next batter.
- If `Hit_Ocak` fails:
- The peg lands at a random distance `D_rest` from (0,0) near `L`.
- The batting team scores points equal to `floor(D_rest / length_comak)` where `length_comak = 0.75` meters.
- `scores[batting_team] += points`.
- Batter `b` remains active for another hit, or turn passes [gap-fill: standard local custom permits 3 hits per batter maximum before rotating, which we enforce as a limit].
R6. Swapping: When all batters of a team are OUT, the teams swap roles.
R7. End condition: Game terminates after a fixed number of complete innings (e.g., 3 innings).
R8. Win condition: The team with the highest score wins.
## Edge cases
- **Tie at the end condition:** Handled by sudden-death extra inning or declared a tie.
- **A player with no legal move:** Not applicable; players can always select force and angle.
- **Repetition / cycles:** Bounded by the 3-hit-per-batter limit and the finite innings limit (R7).
- **Simultaneous claims on the same resource:** Not applicable; turns are sequential.
- **Player elimination mid-round:** Out batters are removed from the active batting list for that half-inning, turn order repairs sequentially.
- **Resource exhaustion:** Not applicable.
- **Termination guarantee:** Guaranteed by R5's hit limit, R6's OUT rotation, and R7's inning cap.
## State representation
- Persistent state:
- `scores: Array[2] of integer`.
- `inning: integer`.
- `batting_team: integer`.
- `active_batter: integer`.
- `outs_count: integer`.
- Ephemeral state:
- `celik_position: Coordinate(x, y)`.
- `fielder_positions: List of Coordinate(x, y)`.
- Information set: Public, fully observable.
## Action space
- `strike_peg(force, angle)`: where `force ∈ [1..10]` and `angle ∈ [0..180]`. Only valid for the active batter.
## Playability notes
- Single-player-vs-AI: Highly suitable. The player can play as the batter against a team of AI fielders who position themselves dynamically based on the batter's past hit statistics.
- Group games: Generalizes to any even team size.
- Physical-skill games: Physical batting and throwing are fully abstracted via coordinate sampling and distance-based probability.
- What is lost: The raw athletic joy of swinging a real wooden stick and chasing a flying peg in the wind.
## Implementation hints
Medium complexity. Requires basic 2D geometry (distances, vectors, angles). Implement the hit landing coordinate generator (R3) and the catching proximity checks (R4) first. First milestone: build the turn-taking loop and score accumulator with static fielders.
Download as JSON
Download the full game corpus entry for this game as structured JSON.
Download JSONCite this page
Turkish Peg-Stick Game (Met / Sülü) (Türkiye). (n.d.). Games of Countries. https://gamesofcountries.com/games/tr-turkiye/celik-comak
@misc{gamesofcountries-tr-turkiye-celik-comak,
title = {Turkish Peg-Stick Game (Met / Sülü) (Türkiye)},
year = {n.d.},
publisher = {Games of Countries},
url = {https://gamesofcountries.com/games/tr-turkiye/celik-comak}
}