Ethosoft/ck3-gameplay-mouse-keyboard-dataset

👑 CRUSADER KINGS III: HUMAN GAMEPLAY MULTIMODAL TELEMETRY DATASET

🏰 The Sovereign Grand Strategy Benchmark for Vision-Language-Action (VLA) Foundation Models & Autonomous GUI Agents

💬 "Every click. Every drag. Every panicked Alt-Tab before an unexpected inheritance crisis."

---

📍 Table of Contents

• 🏰 Executive Summary & Research Vision
• 🎯 Mathematical Action Space Formalization
• 🛡️ Privacy & Capture Protocols
• 🎬 Dataset Architecture & Flow
• 📊 Schema & Data Dictionary
• 📐 Sub-Frame Temporal Synchronization Engine
• ⚖️ Synthetic vs. Real Human Gameplay Matrix
• 🚀 Multi-Framework SDK Suite (PyTorch, JAX, HuggingFace, Ray)
• 🏆 Standardized Benchmark Tasks & Split Layout
• 📈 Live Dataset Metrics
• 📜 Citation & License

---

🏰 Executive Summary & Scientific Motivation

Crusader Kings III (CK3) represents the ultimate boss level for multimodal artificial intelligence. Unlike current Web-GUI or OS-desktop benchmarks (such as WebArena, Mind2Web, OSWorld) that feature simple layout hierarchies and static HTML elements, playing Crusader Kings III demands an agent that can master:

1. Multi-Layered Tooltip Hierarchies: Cascading tooltips that require hovering over text triggers, holding lock keys, and navigating nested explanation popups.
2. Spatial-Temporal Map Navigation: Continuous 2D map panning, smooth zooming, army movement routing, and territory micro-management.
3. Complex Multi-Variable Decision Graphs: Long-horizon strategic planning, dynastic succession management, council politics, and war declaration timing under severe information density.
4. High-Frequency Motor Control: Sub-millisecond cursor trajectory dynamics, hesitation intervals, drag selection, and wheel scrolling.

This dataset provides over 610+ hours of continuous, authentic human gameplay sessions, pairing 1080p 30 FPS desktop screen captures with 60 Hz uniform temporal grids & nanosecond discrete hardware event logs.

┌─────────────────────────────────────────────────────────────────────────────────────────────┐
│                                   THE MULTIMODAL LOOP                                       │
│                                                                                             │
│   ┌───────────────────┐      Visual Observation St      ┌───────────────────────────────┐   │
│   │ 1080p Screen Video│ ───────────────────────────────►│ Multimodal VLA Policy         │   │
│   │ (30 FPS H.264)    │                                 │ (ACT, Diffusion Policy, VLM)  │   │
│   └───────────────────┘                                 └───────────────┬───────────────┘   │
│             ▲                                                           │                   │
│             │                      Action Pred at                       │                   │
│             └───────────────────────────────────────────────────────────┘                   │
│                                                                                             │
│   ┌───────────────────┐      Ground-Truth Action at     ┌───────────────────────────────┐   │
│   │ 60 Hz Telemetry   │ ───────────────────────────────►│ Trajectory Loss & Off-Policy  │   │
│   │ & Event Streams   │                                 │ Reinforcement Learning        │   │
│   └───────────────────┘                                 └───────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────────────────────────────────┘

---

🎯 Mathematical Action Space Formalization

We formulate the gameplay telemetry as a Partially Observable Markov Decision Process (POMDP) defined by the tuple $\mathcal{M} = (\mathcal{S}, \mathcal{A}, \mathcal{P}, \mathcal{R}, \gamma, \Omega, \mathcal{O})$.

1. State Observation $\mathcal{O}_t$

At discrete timestep $t$, the observation consists of a high-definition RGB screen frame:

$${\mathbf{o}}_t\in {\mathbb{R}}^{1080\times 1920\times 3},o_{t,i,j,c}\in \{0,1,\dots ,255\}\backslash mathbf\{o\}\_t\; \backslash in\; \backslash mathbb\{R\}^\{1080\; \backslash times\; 1920\; \backslash times\; 3\},\; \backslash quad\; o\_\{t,i,j,c\}\; \backslash in\; \backslash \{0,\; 1,\; \backslash dots,\; 255\backslash \}$$

2. Action Vector $\mathbf{a}_t$

The continuous-discrete hybrid action vector $\mathbf{a}_t \in \mathcal{A}$ at 60 Hz sampling rate is defined as:

$${\mathbf{a}}_t=[x_t,y_t,b_{\text{left}},b_{\text{right}},b_{\text{middle}},\mathrm{\Delta }{x}_{\text{scroll}},\mathrm{\Delta }{y}_{\text{scroll}},{\mathbf{k}}_t]\backslash mathbf\{a\}\_t\; =\; \backslash left[\; x\_t,\; y\_t,\; b\_\{\backslash text\{left\}\},\; b\_\{\backslash text\{right\}\},\; b\_\{\backslash text\{middle\}\},\; \backslash Delta\; x\_\{\backslash text\{scroll\}\},\; \backslash Delta\; y\_\{\backslash text\{scroll\}\},\; \backslash mathbf\{k\}\_t\; \backslash right]$$

Where:

• $(x_t, y_t) \in [0, 1920] \times [0, 1080] \subset \mathbb{R}^2$ represents normalized/absolute cursor coordinates.
• $b_{\text{left}}, b_{\text{right}}, b_{\text{middle}} \in {0, 1}$ represent binary mouse button states.
• $\Delta x_{\text{scroll}}, \Delta y_{\text{scroll}} \in \mathbb{Z}$ represent scroll wheel delta values.
• $\mathbf{k}_t \in {0, 1}^{K}$ represents a multi-hot binary vector over $K=104$ keyboard keys.

---

🛡️ Privacy & Capture Guarantee

Zero Background Telemetry & Strict Application Isolation All data was collected via a custom recorder (CK3 Auto Dataset Recorder). The input listener utilizes low-level OS hooks configured to log events EXCLUSIVELY while ck3.exe is the active, focused foreground window.

• A 1.0-second focus grace period ensures that any accidental window tab-outs immediately halt event capturing.
• No private DMs, personal web browsing, or background keypresses are ever recorded.

---

🎬 Dataset Architecture & Pipeline Flow

Every gameplay session is archived in a self-contained, timestamped directory: ck3_YYYYMMDD_HHMMSS/.

Ethosoft/ck3-gameplay-mouse-keyboard-dataset/
├── README.md
├── .gitattributes
├── UPLOAD_MANIFEST_CK3.txt
└── ck3_20260602_210003/
    ├── screen.mp4           # 30 FPS H.264 desktop screen capture (gdigrab)
    ├── input_events.csv     # Raw discrete event stream (move, click, scroll, key down/up)
    ├── input_samples.csv    # Uniform 60 Hz temporal grid of cursor & key states
    ├── metadata.json        # Session Rosetta Stone (sync formulas, hardware, encoder log)
    └── ffmpeg.log           # Raw FFmpeg encoder log for full reproducibility

🔄 Data Capture Sequence (Mermaid Diagram)

sequenceDiagram
    autonumber
    participant Human as 🎮 Human Player
    participant OS as 💻 OS Window Manager
    participant Listener as 🛰️ Input Event Listener
    participant FFmpeg as 🎥 FFmpeg Video Recorder
    participant Sync as ⏱️ Sub-Frame Sync Engine
    participant HF as 🤗 Hugging Face Hub

    Human->>OS: Interacts with Crusader Kings III
    OS->>Listener: Dispatches Low-Level Mouse/Keyboard Events
    alt CK3 is Active Foreground Window
        Listener->>Sync: Log Timestamped Raw Event (t_perf_ns, t_epoch_ns)
        Sync->>Sync: Resample to 60 Hz Uniform Grid
    else CK3 Lost Focus (>1.0s Grace)
        Listener->>Listener: Mute Recording (Privacy Shield)
    end
    FFmpeg->>Sync: Write 1080p 30FPS H.264 Video Stream
    Sync->>HF: Commit Aligned Directory (screen.mp4 + input_*.csv + metadata.json)

---

📊 Data Schema & Field Specifications

📄 Click to expand metadata.json Rosetta Stone Specification

The metadata.json file serves as the single source of truth for temporal anchoring, process verification, and hardware encoder settings.

{
  "app": "CK3 Auto Dataset Recorder",
  "session_id": "20260602_210003",
  "created_utc": "2026-06-02T18:00:04.251968+00:00",
  "game_process": {
    "pid": 14492,
    "name": "ck3.exe",
    "exe": "C:\\Program Files (x86)\\Steam\\steamapps\\common\\Crusader Kings III\\binaries\\ck3.exe"
  },
  "video": {
    "path": "C:\\CK3Recorder\\datasets\\ck3_20260602_210003\\screen.mp4",
    "fps": 30,
    "ffmpeg_popen_perf_ns": 28668031260300,
    "ffmpeg_popen_sec_from_t0": 0.0237803
  },
  "input": {
    "events_csv": "C:\\CK3Recorder\\datasets\\ck3_20260602_210003\\input_events.csv",
    "samples_csv": "C:\\CK3Recorder\\datasets\\ck3_20260602_210003\\input_samples.csv",
    "sample_hz": 60,
    "contains": ["mouse_move", "mouse_click", "mouse_scroll", "key_press", "key_release"]
  },
  "privacy": {
    "record_only_when_ck3_foreground": true,
    "foreground_lost_grace_sec": 1.0
  },
  "sync": {
    "t0_perf_ns": 28668007480000,
    "t0_epoch_ns": 1780423203740019200,
    "video_time_sec_formula": "video_time_sec ~= input_t_sec - ffmpeg_popen_sec_from_t0"
  }
}

📄 Click to expand input_events.csv Discrete Event Schema

Captures raw hardware events as they occur with dual-clock nanosecond timestamps.

Column	Type	Description	Example Values
t_perf_ns	int64	High-resolution performance counter timestamp (nanoseconds).	28668020748900
t_epoch_ns	int64	UTC Epoch timestamp (nanoseconds).	1780423203753234800
t_sec	float64	Relative time in seconds since session start ($t_0$).	0.0132689
event	string	Discrete event type.	mouse_move, mouse_click, mouse_scroll, key_press, key_release
x	int32	Cursor X pixel coordinate ($0 \le x \le 1920$).	1378
y	int32	Cursor Y pixel coordinate ($0 \le y \le 1080$).	911
button	string	Mouse button indicator.	Button.left, Button.right, Button.middle
pressed	boolean	State of button or key.	True, False
dx, dy	int32	Scroll wheel movement deltas.	0, 1 or 0, -1
key	string	Pressed/released key identifier.	'Key.space', 'Key.shift', 'a'

📄 Click to expand input_samples.csv Uniform 60 Hz Resampled Schema

Resampled on a clean 60 Hz temporal grid ($\Delta t \approx 16.66$ ms). Ideal for fixed-time-step ML models without variable sample rate handling.

Column	Type	Description	Example Values
t_perf_ns	int64	Performance counter timestamp for the 60 Hz frame.	28668019447900
t_epoch_ns	int64	UTC Epoch timestamp for the 60 Hz frame.	1780423203752236000
t_sec	float64	Elapsed time in seconds.	0.0119679
x	int32	Instantaneous cursor X coordinate.	1379
y	int32	Instantaneous cursor Y coordinate.	928
left	boolean	State of Left Mouse Button.	True / False
right	boolean	State of Right Mouse Button.	True / False
middle	boolean	State of Middle Mouse Button.	True / False
pressed_keys	string	Delimited string of currently held keys.	`'Key.shift

---

📐 Sub-Frame Temporal Synchronization Mechanics

To achieve exact alignment between screen pixels in screen.mp4 and user inputs in input_samples.csv or input_events.csv, use the sub-frame sync equation:

$$t_{\text{video\_sec}}\approx t_{\text{input\_sec}}-\text{ffmpeg\_popen\_sec\_from\_t0}t\_\{\backslash text\{video\backslash \_sec\}\}\; \backslash approx\; t\_\{\backslash text\{input\backslash \_sec\}\}\; -\; \backslash text\{ffmpeg\backslash \_popen\backslash \_sec\backslash \_from\backslash \_t0\}$$

Where:

• $t_{\text{input_sec}}$ is the t_sec column in the CSV files.
• $\text{ffmpeg_popen_sec_from_t0}$ is extracted from metadata.json["video"]["ffmpeg_popen_sec_from_t0"].
• Frame index $N$ in screen.mp4 corresponds to:

$$\text{Frame Index }N=\max (0,\lfloor t_{\text{video\_sec}}\times \text{FPS}\rfloor )\backslash text\{Frame\; Index\; \}\; N\; =\; \backslash max\backslash left(0,\; \backslash left\backslash lfloor\; t\_\{\backslash text\{video\backslash \_sec\}\}\; \backslash times\; \backslash text\{FPS\}\; \backslash right\backslash rfloor\backslash right)$$

  Input Event Timestamp (t_sec = 1.054s)
  ───────────────────────────────────────►
                                         │  Offset Correction (-0.023s)
                                         ▼
  Video Relative Time  (t_video = 1.031s)
  ───────────────────────────────────────►
                                         │  FPS Multiply (30 FPS)
                                         ▼
  Target Frame Index   (Frame N = 30)   ──► [ Extract Frame from screen.mp4 ]

---

⚖️ Synthetic LLM Clickers vs. Authentic Human Gameplay

Dimension	Synthetic LLM / Rule-Based Clickers	CK3 Human Gameplay Dataset (This Work)
Cursor Pathing	Teleportation / Rigid Linear Vectors	Natural Fitts' Law Curvature, Acceleration & Micro-Tremors
Decision Speed	Fixed Artificial Delay	Dynamic Human Hesitation (10ms reaction to 5s strategic pauses)
Error & Correction	Perfect execution or total failure	Realistic Human Misclicks, Menu Dragging & Self-Correction
UI Traversal	Direct coordinate hits	Exploratory Hovering & Tooltip Hierarchy Traversal
Dataset Scale	Small / Synthetic (~10-50 trajectories)	617 Sessions (~610+ hours, ~200+ GB)

---

🚀 Multi-Framework SDK Suite

1. PyTorch & PyTorch Lightning DataModule

import os
import json
import cv2
import pandas as pd
import torch
from torch.utils.data import Dataset, DataLoader

class CK3MultimodalDataset(Dataset):
    """
    PyTorch Dataset loader for CK3 Gameplay Video + 60Hz Action Alignment.
    """
    def __init__(self, session_dir, transform=None):
        self.session_dir = session_dir
        self.transform = transform
        
        with open(os.path.join(session_dir, "metadata.json"), "r") as f:
            self.meta = json.load(f)
            
        self.offset = self.meta["video"]["ffmpeg_popen_sec_from_t0"]
        self.samples = pd.read_csv(os.path.join(session_dir, "input_samples.csv"))
        self.cap = cv2.VideoCapture(os.path.join(session_dir, "screen.mp4"))
        self.fps = self.meta["video"]["fps"]

    def __len__(self):
        return len(self.samples)

    def __getitem__(self, idx):
        row = self.samples.iloc[idx]
        t_video = row["t_sec"] - self.offset
        frame_idx = max(0, int(t_video * self.fps))
        
        self.cap.set(cv2.CAP_PROP_POS_FRAMES, frame_idx)
        ret, frame = self.cap.read()
        
        if not ret:
            frame = torch.zeros((3, 1080, 1920), dtype=torch.uint8)
        else:
            frame = torch.from_numpy(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)).permute(2, 0, 1)
            
        action = {
            "cursor": torch.tensor([row["x"] / 1920.0, row["y"] / 1080.0], dtype=torch.float32),
            "buttons": torch.tensor([row["left"], row["right"], row["middle"]], dtype=torch.float32)
        }
        
        return frame, action

---

2. JAX / Flax Data Loading Pipeline

import jax
import jax.numpy as jnp
import numpy as np

def jax_collate_fn(batch):
    frames, actions = zip(*batch)
    frames_np = np.stack([f.numpy() for f in frames])
    cursors_np = np.stack([a["cursor"].numpy() for a in actions])
    
    return {
        "image": jnp.array(frames_np),
        "cursor_target": jnp.array(cursors_np)
    }

---

3. Spatial Cursor Heatmap EDA Script (Matplotlib / Seaborn)

import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

def generate_cursor_heatmap(csv_path, output_png="heatmap.png"):
    df = pd.read_csv(csv_path)
    
    plt.figure(figsize=(16, 9), dpi=100)
    sns.kdeplot(
        x=df['x'], y=df['y'], 
        cmap="rocket", fill=True, thresh=0, levels=100
    )
    plt.xlim(0, 1920)
    plt.ylim(1080, 0) # Invert Y for screen coordinates
    plt.title("Crusader Kings III - Spatial Cursor Density Heatmap")
    plt.axis("off")
    plt.tight_layout()
    plt.savefig(output_png)
    print(f"🔥 Heatmap saved to {output_png}")

# generate_cursor_heatmap("input_samples.csv")

---

🏆 Standardized Benchmark Tasks & Split Layout

We define four standardized benchmark tasks for evaluating vision-language-action agents on CK3:

1. Task A: Next-Frame Cursor Trajectory Prediction ($L_2$ Pixel Error):
   • Predict $(x_{t+1}, y_{t+1})$ given image frame $O_t$ and historical context.
2. Task B: Mouse Button Click Classification (F1-Score):
   • Predict whether left, right, or middle mouse button will be triggered.
3. Task C: Keyboard Shortcut Intent Recognition:
   • Predict spacebar pause/unpause or map mode hotkey activations.
4. Task D: Action Chunking Horizon Prediction (ACT / Diffusion):
   • Predict a sequence of $K=16$ future actions $\mathbf{a}_{t:t+K}$ simultaneously.

📌 Recommended Session Split Layout

• Training Set: 500 Sessions (ck3_20260602_* to ck3_20260720_*)
• Validation Set: 50 Sessions (ck3_20260721_* to ck3_20260727_*)
• Test Benchmark Set: 67 Sessions (ck3_20260728_* to ck3_20260802_*)

---

📈 Live Dataset Metrics

Current Dataset Phase 1 Progress:
[██████████████████████████████████████████████████] 100% (617 / 617 Initial Target Sessions)

Metric	Specification Details
Total Recorded Sessions	617 Sessions
Total Repository Files	3,088 Files
Recording Period	June 2, 2026 – August 2, 2026
Video Format	1080p @ 30 FPS (H.264, gdigrab, CRF 20)
Input Sampling	60 Hz Uniform Grid + Microsecond Raw Events
Captured Action Dimensions	Cursor Coordinates $(x,y)$, Mouse Buttons, Wheel Deltas, Keyboard State
Total Storage Footprint	~200+ GB Video + 12+ GB CSV Telemetry
Dataset License	Creative Commons Attribution 4.0 International (CC BY 4.0)

---

📜 Citation & Attribution

If you utilize this dataset in your research, benchmarks, or AI projects, please cite it using the following BibTeX format:

@dataset{ck3_gameplay_mouse_keyboard_2026,
  title        = {CK3 Gameplay Mouse & Keyboard Telemetry Dataset},
  author       = {Yağız Ekrem Dalar},
  year         = {2026},
  publisher    = {Hugging Face},
  month        = {August},
  doi          = {10.57967/hf/9535},
  url          = {https://huggingface.co/datasets/Ethosoft/ck3-gameplay-mouse-keyboard-dataset},
  note         = {Multimodal 1080p video and 60 Hz input telemetry dataset for Crusader Kings III}
}

---

👑 Designed & Maintained by Yağız Ekrem Dalar (Ethosoft)

May your dynasty flourish, your cursor trajectories remain smooth, and your model loss converge!