noidvan/jaipur

---
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}
}
```