Tutorial
Build Golf
Recreate the complete playable Golf card game using normal Handlimit authoring tools.
This tutorial checks the current game as you work. Build every item through normal Handlimit authoring; common-piece tools only automate repetitive setup.
0/9
steps complete
0%
Common Pieces
Standard 52-card deck
Creates the Playing Card type and all 52 normal cards with suit, face-value, rank-value, and score-value attributes. Running it again updates those cards instead of creating duplicates; unrelated pieces are left alone.
Walkthrough
Build it in order
○ 1. Game basics Set Golf up as a 2–6 player game. The Rules section will define the nine-round structure. 0/3 ⌄
What to create
- ›Players: 2–6
- ›Description: Nine-round card game where players minimize the score of a 3×2 tableau.
Current game
○
2-player minimum
○
6-player maximum
○
Game description
Exact settings
Minimum players: 2
Maximum players: 6
Description: Nine-round card game where players minimize the score of a 3×2 tableau.
Ruleset rounds: 9
Turn order: Clockwise
○ 2. Scoring stats Create the three player stats used to track round reveals and Golf scoring. 0/3 ⌄
What to create
- ›Total Score → total_score — All Players — default 0
- ›Round Score → round_score — All Players — default 0
- ›Round Reveals → round_reveals — All Players — default 0
Current game
○
total_score
○
round_score
○
round_reveals
| Name | Auto Key | Scope | Default |
|---|---|---|---|
| Total Score | total_score | All Players | 0 |
| Round Score | round_score | All Players | 0 |
| Round Reveals | round_reveals | All Players | 0 |
○ 3. Standard playing-card deck Golf uses a normal 52-card deck. You can create it manually, or use the Common Pieces tool below to generate the Piece Type and all 52 cards at once. 0/4 ⌄
What to create
- ›Playing Card → playing_card
- ›Suits: spades, hearts, diamonds, clubs
- ›Ranks: A, 2–10, J, Q, K
- ›Golf scoring: A=1, 2=-2, J/Q=10, K=0; number cards use face value.
- ›Matching vertical ranks score zero during round scoring.
Current game
○
Playing Card piece type
○
52 standard playing cards
○
Suit, face value and score attributes
○
Golf score values
Playing Card type
Name: Playing Card
Auto Key: playing_card
Base type: Card
Playtest renderer: Playing Card
Back label: GOLF
Attributes: suit, face_value, rank_value, score_value.
Golf values: A=1, 2=-2, 3–10=face value, J=10, Q=10, K=0.
Open Standard playing-card deck
Or use the Standard Deck tool above for the repetitive card setup.
○ 4. Effects Effects are the reusable operations that build the deck, move cards, reveal cards, score a tableau, and determine the winner. 0/16 ⌄
What to create
- ›Each Effect name naturally generates the key shown in the reference table.
- ›Round setup: build deck, shuffle, reset counters, deal six, start discard, choose first player.
- ›Player play: reveal, draw, take discard, replace, discard.
- ›Scoring: reveal all, score 3 columns, rank the lowest total score.
Current game
○
build_standard_deck
○
shuffle_deck
○
reset_initial_reveals
○
reset_round_score
○
deal_six_cards
○
start_discard_pile
○
choose_first_player
○
reveal_tableau_card
○
count_initial_reveal
○
draw_top_deck_card
○
take_top_discard
○
discard_drawn_card
○
replace_tableau_card
○
reveal_all_tableaus
○
score_tableau_columns
○
rank_lowest_score
| Name | Auto Key | Operation | Runtime settings |
|---|---|---|---|
| Build Standard Deck | build_standard_deck | Seed Piece Type | playing_card → deck; clear existing; face down |
| Shuffle Deck | shuffle_deck | Shuffle Zone | deck; Global |
| Reset Initial Reveals | reset_initial_reveals | Set Stat | round_reveals = 0; All Players |
| Reset Round Score | reset_round_score | Set Stat | round_score = 0; All Players |
| Deal Six Cards | deal_six_cards | Deal Pieces | deck → tableau; 6 per player; 3 columns; face down |
| Start Discard Pile | start_discard_pile | Move Top Piece | deck → discard; Global → Global; face up |
| Choose First Player | choose_first_player | Choose Random Active Player | No additional fields |
| Reveal Tableau Card | reveal_tableau_card | Reveal Piece | input piece_id; tableau; owner Actor |
| Count Initial Reveal | count_initial_reveal | Add Stat | round_reveals + 1; Actor |
| Draw Top Deck Card | draw_top_deck_card | Move Top Piece | deck → drawn; Global → Actor; face up |
| Take Top Discard | take_top_discard | Move Top Piece | discard → drawn; Global → Actor; face up |
| Discard Drawn Card | discard_drawn_card | Move Piece From Zone | drawn → discard; Actor → Global; face up |
| Replace Tableau Card | replace_tableau_card | Replace Piece | input piece_id; drawn replaces tableau target; replaced card → discard |
| Reveal All Tableaus | reveal_all_tableaus | Reveal All | tableau; All Players |
| Score Tableau Columns | score_tableau_columns | Score Grid | tableau; 3 columns; value=score_value; match=face_value; matching score=0; round_score + total_score |
| Rank Lowest Score | rank_lowest_score | Rank Players | total_score; Lowest wins |
○ 5. Actions Combine Effects into the player and system actions that are legal during each Window. 0/8 ⌄
What to create
- ›System: Prepare Round, Score Round, Determine Winner.
- ›Player: Reveal Card, Draw From Deck, Draw From Discard, Replace Tableau Card, Discard Drawn Card.
- ›Leave generated keys alone; they should match the snake_case values in the reference table.
Current game
○
prepare_round
○
reveal_card
○
draw_from_deck
○
draw_from_discard
○
replace_tableau_card
○
discard_drawn_card
○
score_round
○
determine_winner
| Name | Auto Key | Playtest UI | Effects in order | Requirements |
|---|---|---|---|---|
| Prepare Round | prepare_round | System | build_standard_deck → shuffle_deck → reset_initial_reveals → reset_round_score → deal_six_cards → start_discard_pile → choose_first_player | None |
| Reveal Card | reveal_card | Piece: tableau | reveal_tableau_card → count_initial_reveal | Actor round_reveals < 2; selected tableau card belongs to Actor and is face down |
| Draw From Deck | draw_from_deck | Zone: deck | draw_top_deck_card | Global deck count > 0 |
| Draw From Discard | draw_from_discard | Zone: discard | take_top_discard | Global discard count > 0 |
| Replace Tableau Card | replace_tableau_card | Piece: tableau | replace_tableau_card | Actor drawn count > 0; selected tableau card belongs to Actor |
| Discard Drawn Card | discard_drawn_card | Button | discard_drawn_card | Actor drawn count > 0 |
| Score Round | score_round | System | reveal_all_tableaus → score_tableau_columns | None |
| Determine Winner | determine_winner | System | rank_lowest_score | None |
○ 6. Phases and Windows Build the game hierarchy in Rules: Phases define the major game flow, and each Phase owns a sequential Window chain. 0/13 ⌄
What to create
- ›Setup: Prepare Round → Reveal Two Cards
- ›Player Turn: Draw a Card → Keep or Discard
- ›Scoring: Score Round → Round Complete
- ›Game End: Game Complete
- ›Use the automatically generated Window keys from those names.
Current game
○
9 rounds
○
Clockwise turns
○
Window: prepare_round
○
Window: reveal_two_cards
○
Window: draw_a_card
○
Window: keep_or_discard
○
Window: score_round
○
Window: round_complete
○
Window: game_complete
○
Phase: setup
○
Phase: player_turn
○
Phase: scoring
○
Phase: game_end
| Name | Auto Key | Target | Capability | Allowed Actions |
|---|---|---|---|---|
| Prepare Round | prepare_round | Game | Automatic | — |
| Reveal Two Cards | reveal_two_cards | All Players | Take Action | reveal_card |
| Draw a Card | draw_a_card | Active Player | Take Action | draw_from_deck, draw_from_discard |
| Keep or Discard | keep_or_discard | Active Player | Take Action | replace_tableau_card, discard_drawn_card |
| Score Round | score_round | Game | Automatic | — |
| Round Complete | round_complete | Game | Confirmation | — |
| Game Complete | game_complete | Game | Automatic | — |
Setup setup
prepare_round → reveal_two_cards
Player Turn player_turn
draw_a_card → keep_or_discard
Scoring scoring
score_round → round_complete
Game End game_end
game_complete
○ 7. Playable zones Define where runtime card instances live. These zones are what the tabletop renderer displays and what Effects move cards between. 0/4 ⌄
What to create
- ›Deck → deck — Global Stack — Hidden
- ›Discard → discard — Global Stack — Public
- ›Tableau → tableau — Per Player Grid — Mixed — 2 rows × 3 columns
- ›Drawn → drawn — Per Player Slot — Owner
Current game
○
deck
○
discard
○
tableau
○
drawn
| Name | Auto Key | Scope | Kind | Visibility | Layout |
|---|---|---|---|---|---|
| Deck | deck | Global | Stack | Hidden | — |
| Discard | discard | Global | Stack | Public | — |
| Tableau | tableau | Per Player | Grid | Mixed | 2 × 3 |
| Drawn | drawn | Per Player | Slot | Owner | — |
○ 8. Game progression Connect the Phase and Window routes so the node graph explains the whole game just by following its arrows. 0/8 ⌄
What to create
- ›Start → Setup → Player Turn.
- ›Player Turn → Scoring when the deck is empty or a tableau is fully revealed.
- ›Otherwise Player Turn loops to itself and rotates the active player.
- ›Scoring → Game End when Round ≥ 9; otherwise → Setup and increment the round.
- ›Game End → End.
Current game
○
Game starts in Setup
○
Setup first Window is prepare_round
○
Player Turn first Window is draw_a_card
○
Scoring first Window is score_round
○
Game End first Window is game_complete
○
Player Turn has a route to Scoring
○
Scoring has a route to Game End
○
Scoring has a next-round route to Setup
START → Setup → Player Turn → Scoring → Game End → END
Setup: first Window prepare_round. Prepare Round runs automatically, then Reveal Two Cards completes when all players have round_reveals ≥ 2.
Player Turn: draw_a_card → keep_or_discard. Phase route to Scoring when deck count ≤ 0. Add another route to Scoring when any player's entire tableau.face_up = true. Otherwise loop Player Turn to itself with Next player.
Scoring: score_round → round_complete. When Round ≥ 9, route to Game End. Otherwise route to Setup with Next round.
Game End: first Window game_complete; entry action determine_winner; finish the game.
○ 9. Playtest the finished game Run through all nine rounds and verify that the authored definition behaves like Golf from setup through winner selection. 0/1 ⌄
What to create
- ›Each player receives six face-down cards in a 3×2 tableau.
- ›Each player reveals exactly two starting cards.
- ›Players draw from deck/discard, then replace a tableau card or discard the drawn card.
- ›Rounds score automatically when the deck empties or a tableau is fully revealed.
- ›After round 9, the lowest total score wins; ties are supported.
Current game
○
Playable definition has cards, rules and a start Phase
Expected loop: fresh deck → deal six → reveal two each → draw from deck/discard → replace/discard → next player → score when a tableau is open or deck is empty → confirm score → next round → lowest total wins after round 9.
How the finished game should read
START → Setup → Player Turn → Scoring → Game End → END
↖ otherwise + next player ↙
Scoring → Game End when Round ≥ 9
Scoring → Setup otherwise + next round
↖ otherwise + next player ↙
Scoring → Game End when Round ≥ 9
Scoring → Setup otherwise + next round
Inside each Phase, follow the Window chain from its blue Window connector. Select a Window to define when it completes; select a When… route to define why the game takes that branch.