| --- |
| license: cc-by-nc-4.0 |
| pretty_name: Jaipur - Online Card Game Replays |
| task_categories: |
| - reinforcement-learning |
| tags: |
| - board-games |
| - card-games |
| - jaipur |
| - game-ai |
| - imperfect-information |
| - two-player |
| language: |
| - en |
| size_categories: |
| - 10K<n<100K |
| configs: |
| - config_name: default |
| data_files: |
| - split: train |
| path: data/games.parquet |
| - config_name: players |
| data_files: |
| - split: train |
| path: data/players.parquet |
| dataset_info: |
| - config_name: default |
| features: |
| - name: game_id |
| dtype: string |
| - name: variant |
| dtype: string |
| - name: player_0 |
| dtype: string |
| - name: player_1 |
| dtype: string |
| - name: winner |
| dtype: int8 |
| - name: num_rounds |
| dtype: int8 |
| - name: num_turns |
| dtype: int16 |
| - name: round_scores |
| sequence: |
| sequence: int16 |
| - name: turns |
| list: |
| - name: round |
| dtype: int8 |
| - name: actor |
| dtype: int8 |
| - name: action_type |
| dtype: string |
| - name: action_goods |
| sequence: int8 |
| - name: market |
| sequence: int8 |
| - name: deck_size |
| dtype: int8 |
| - name: actor_hand |
| sequence: int8 |
| - name: opponent_hand |
| sequence: int8 |
| - name: coin_stacks |
| sequence: |
| sequence: int8 |
| - name: bonus_stacks |
| sequence: |
| sequence: int8 |
| - name: actor_coins |
| sequence: |
| sequence: int8 |
| - name: actor_bonuses |
| sequence: int8 |
| - name: actor_score |
| dtype: int16 |
| - name: opponent_score |
| dtype: int16 |
| splits: |
| - name: train |
| num_examples: 38077 |
| - config_name: players |
| features: |
| - name: player_id |
| dtype: string |
| - name: num_games |
| dtype: int32 |
| - name: num_wins |
| dtype: int32 |
| - name: win_rate |
| dtype: float32 |
| - name: num_games_as_p0 |
| dtype: int32 |
| - name: num_games_open_info |
| dtype: int32 |
| - name: num_games_original |
| dtype: int32 |
| splits: |
| - name: train |
| num_examples: 4264 |
| --- |
| |
| # Jaipur: Online Card Game Replays |
|
|
| A dataset of **38,000+ complete Jaipur card game replays** from human players on |
| [Yucata.de](https://www.yucata.de). |
|
|
| [Jaipur](https://boardgamegeek.com/boardgame/54043/jaipur) is a two-player trading card game where players compete as merchants, buying and selling goods to earn the |
| most money. It features imperfect information (hidden deck and opponent hand), delayed rewards, |
| and strategic tension between short-term gains and long-term planning. |
|
|
| ## Why This Dataset? |
|
|
| Jaipur is an excellent benchmark for game AI research: |
|
|
| - **Imperfect information**: Players cannot see the deck or (in the original variant) the |
| opponent's hand, requiring belief tracking and risk assessment |
| - **Mixed strategy space**: Actions include taking goods, selling sets, and multi-card trades |
| - **Compact but deep**: Games are short (~20-40 turns) but strategically rich |
| - **Two variants included**: Open information (both hands visible) and original rules (hidden |
| hands), enabling research on how information availability affects strategy |
|
|
| ## Dataset Structure |
|
|
| ### Games (`data/games.parquet`) |
|
|
| Each row is one complete game. The `turns` column contains the full sequence of game states |
| and actions. |
|
|
| | Column | Type | Description | |
| |--------|------|-------------| |
| | `game_id` | `string` | Unique anonymized game identifier | |
| | `variant` | `string` | `"open_info"` or `"original"` (whether hands are visible) | |
| | `player_0` | `string` | Anonymized player ID (consistent across games) | |
| | `player_1` | `string` | Anonymized player ID | |
| | `winner` | `int8` | `0` = player\_0 won, `1` = player\_1 won, `-1` = unknown | |
| | `num_rounds` | `int8` | Number of rounds played (1-3, best of 3) | |
| | `num_turns` | `int16` | Total turns across all rounds | |
| | `round_scores` | `list[list[int16]]` | Per-round scores `[[p0_r1, p1_r1], [p0_r2, p1_r2], ...]` | |
| | `turns` | `list[struct]` | Ordered list of turn records (see below) | |
|
|
| #### Turn Schema |
|
|
| Each element in the `turns` list is a struct with the state **before** the action and the |
| action taken: |
|
|
| | Field | Type | Description | |
| |-------|------|-------------| |
| | `round` | `int8` | Round index (0-based) | |
| | `actor` | `int8` | Which player acted (`0` or `1`) | |
| | `action_type` | `string` | `"take"`, `"sell"`, or `"trade"` | |
| | `action_goods` | `list[int8]` | Signed goods delta for actor: `[D, G, S, Cl, Sp, L, Ca]`. Positive = gained, negative = given away | |
| | `market` | `list[int8]` | Market goods count: `[D, G, S, Cl, Sp, L, Ca]` | |
| | `deck_size` | `int8` | Cards remaining in draw pile | |
| | `actor_hand` | `list[int8]` | Actor's hand: `[D, G, S, Cl, Sp, L, Ca]` | |
| | `opponent_hand` | `list[int8]` | Opponent's hand (always present in data, even for original variant) | |
| | `coin_stacks` | `list[list[int8]]` | Remaining coin values per good `[[D coins], [G], [S], [Cl], [Sp], [L]]`, ordered highest-first | |
| | `bonus_stacks` | `list[list[int8]]` | Remaining bonus token values `[[3-set], [4-set], [5-set]]` | |
| | `actor_coins` | `list[list[int8]]` | Coins actor has earned per good `[[D coins], ..., [L coins]]` | |
| | `actor_bonuses` | `list[int8]` | Bonus token values actor has earned | |
| | `actor_score` | `int16` | Actor's current score (goods + bonus coins) | |
| | `opponent_score` | `int16` | Opponent's current score | |
|
|
| **Goods order**: Diamond (D), Gold (G), Silver (S), Cloth (Cl), Spice (Sp), Leather (L), Camel (Ca) — 7 types. Coin stacks cover the 6 tradeable types (no camel coins). |
|
|
| ### Players (`data/players.parquet`) |
|
|
| Aggregated statistics for each unique player across all games. |
|
|
| | Column | Type | Description | |
| |--------|------|-------------| |
| | `player_id` | `string` | Anonymized player ID (matches `player_0`/`player_1` in games) | |
| | `num_games` | `int32` | Total games played | |
| | `num_wins` | `int32` | Total wins | |
| | `win_rate` | `float32` | Win rate (wins / games with known outcome) | |
| | `num_games_as_p0` | `int32` | Games played as player 0 (first mover) | |
| | `num_games_open_info` | `int32` | Games played in open info variant | |
| | `num_games_original` | `int32` | Games played in original variant | |
|
|
| ## Quick Start |
|
|
| ```python |
| from datasets import load_dataset |
| |
| # Load all games |
| ds = load_dataset("noidvan/jaipur") |
| game = ds["train"][0] |
| |
| print(f"Variant: {game['variant']}") |
| print(f"Winner: player_{game['winner']}") |
| print(f"Turns: {game['num_turns']}") |
| |
| # Iterate through turns |
| for turn in game["turns"]: |
| print(f" Round {turn['round']}, Player {turn['actor']}: {turn['action_type']}") |
| print(f" Market: {turn['market']}, Deck: {turn['deck_size']}") |
| |
| # Load player stats |
| players = load_dataset("noidvan/jaipur", "players") |
| ``` |
|
|
| ## Game Rules Summary |
|
|
| - **Setup**: 5 cards in market (3 camels + 2 goods initially), each player gets 5 cards |
| - **Turn actions**: |
| - **Take**: Pick one good from market (deck refills) or take all camels |
| - **Sell**: Sell 1+ cards of same type for coins (premium goods require selling 2+) |
| - **Trade**: Swap 2+ cards with market (can offer camels) |
| - **Coins**: Each good type has a coin stack with decreasing values (sell early = more coins) |
| - **Bonuses**: Selling 3/4/5+ cards earns a random bonus token |
| - **Round end**: 3 coin stacks empty OR deck exhausted. Most coins wins the round. |
| - **Game end**: Best of 3 rounds (first to 2 "seals") |
|
|
| ## Variants |
|
|
| | Variant | Games | Description | |
| |---------|-------|-------------| |
| | `open_info` | ~33,000 | Both players can see each other's hands | |
| | `original` | ~5,500 | Standard rules — opponent's hand is hidden | |
|
|
| The `opponent_hand` field is populated for all games regardless of variant (the server |
| records full state). The `variant` field indicates what information was available to players |
| during play, which affects their strategy. |
|
|
| ## Source & License |
|
|
| - **Source**: Game replays from [Yucata.de](https://www.yucata.de), an online board game platform |
| - **License**: [CC-BY-NC-4.0](https://creativecommons.org/licenses/by-nc/4.0/) |
| - **Privacy**: All player identities are anonymized with irreversible hashing. Original |
| usernames are not recoverable from the dataset. The player ID `"unknown"` represents |
| unknown users (~1,400 games); They are excluded from the players table. |
|
|
| ## Citation |
|
|
| ```bibtex |
| @dataset{jaipur_replays_2026, |
| title={Jaipur: Online Card Game Replays}, |
| author={Yifan Lin}, |
| year={2026}, |
| url={https://huggingface.co/datasets/noidvan/jaipur}, |
| license={CC-BY-NC-4.0} |
| } |
| ``` |
|
|
