Papers, notebooks, and the data bundles that make them reproducible. Most of this work comes out of programmatic game leagues, which are useful testbeds because every game is re-simulated bit-exact from its replay, so the ground truth is complete in a way real-world data rarely is. The methods travel.
A multi-configuration study of genetic-algorithm tuning for a scripted CogsGuard policy, covering roughly 60,000 candidate configurations across seven GA runs and six parameter schemas. It reports reliable fitness gains in five of seven runs and shows how team share and teammate strength shape per-cog reward. A set of case studies pulls out the interpretable strategies the GA converged on.
A calibrated system-dynamics model of the Cogs vs. Clips environment that predicts match reward from team composition and two tunable policy parameters. Its four coupled subsystems (resource economy, territory, agent loss, and scheduled adversary events) are fit against roughly 13,000 match outcomes. Aligner cycle time emerges as the dominant lever, and scout-inclusive teams carry a consistent reward penalty of about 1.3 units.
A plain-Python reimplementation of the paper’s AnyLogic model using NumPy and matplotlib. It contains the full simulator in a single function, every calibrated parameter from the paper’s table, reproductions of the match-trajectory and sensitivity figures, and a sandbox for swapping in new compositions and parameter sweeps.
A walkthrough of the modeling-and-simulation methodology, with the league’s bots as the worked examples: each policy’s movement and kill behavior is learned from replays as an input-driven hidden-state model, validated against held-out data, then dropped into a calibrated simulator to compare how well each impostor converts its kill opportunities. The notebook renders every bot’s behavioral fingerprint card, the finishing and conversion analyses, and a live playground that runs the simulator from the bundled models. Paired with the dependency bundle below, it runs end to end in Colab or locally.
Everything the notebook needs to run: the fitted movement and kill models for every policy, the Skeld map, pre-rendered fingerprint cards, and the precomputed simulation sweeps and bootstrap confidence intervals. Unpack alongside the notebook to render every card and chart and run the live simulation playground without a GPU or the raw replay corpus. In Colab, the notebook’s first cell downloads and unpacks this automatically.
A render notebook that turns re-simulated tournament replays into per-pixel heatmaps over the Skeld map: where players and impostors travel, where crew are isolated and vulnerable, where kills land, and where bodies go unreported. Each game is re-simulated tick-by-tick from its replay, then accumulated into per-pixel grids and composited over a desaturated floorplan. Paired with the dependency bundle below, it runs end to end and reproduces every overlay.
The pre-mined data the notebook renders: six per-pixel grids (occupancy, impostor position, vulnerability, kill events, and body dwell) aggregated over 1,610 re-simulated tournament games, plus the Skeld map base and palette. Unpack alongside the notebook to render every overlay without re-mining the replay corpus.
Across 995 games, which lever decides the result? Two things make that hard to answer honestly. 64% of wins are wipes, so any whole-game statistic mostly restates the outcome, and a strong policy wins while also doing more of everything. The design here handles both: every metric is measured in the first 25 seconds of play, so the measurement precedes the result, and teams are compared only against the same matchup, which the complete round-robin of 11 policies over all 55 pairs makes possible. Early damage and net kills turn out to be the only levers that move the outcome. Heart activity sits at exactly zero until the game is already decided, and three behavioural numbers from the opening predict the winner more accurately than knowing which two policies are on the field. Every section ends in a chart, and the whole notebook runs in a few seconds on a free Colab instance.
Coworld CTF is a capture-the-flag league played by programs on a single symmetric arena, which makes every question about it a question about place. This notebook first builds the board’s own geometry from the simulator’s collision mask alone, covering what can see each patch of ground and what can shoot it, then asks 995 league games whether they agree. Mostly they disagree. The most exposed ground on the map is your own endzone and almost nobody dies there, a bullet crossed every standable cell at least once in the corpus, and the property that predicts dying turns out to be how many cells were actually looking at you rather than how many could see you. Six scenarios, each ending in a verdict and a prompt you can hand to a coding agent. The first cell installs the analysis wheel and the second downloads the baked data from this site, so it runs end to end in Colab with no game engine and no replay corpus.
The baked tables the two notebooks read, plus the library that reads them. The geography bundle holds per-cell grids over all 995 games and the full per-tick frames for a 60-game stratified sample, about 20 MB. The victory bundle holds the per-team, per-window feature tables, about 1 MB. The ctf_analysis wheel carries the loaders, the arena model, the map layers and a numpy statistics kernel that needs no scipy. Each notebook pulls what it needs in its first two cells, so these links are here for anyone who wants the data on its own. A .replay file holds only inputs and a per-tick hash, so all of this exists only after the engine re-simulates each game bit-exact on the build that recorded it.
Two paired notebooks for CrewRift, a social-deduction league in the Among Us genre where every player is a program on one fixed map, Croatoan. Let’s Play CrewRift is a hands-on tour that builds a role-aware starter policy from zero: a crew brain that navigates to task stations and votes to dodge the abstain penalty, and an imposter brain that hunts an isolated crewmate, kills in range, vents away, and reports bodies. It then validates the policy with an offline fuzz harness and shows how to submit it to the league. Let’s Analyze CrewRift is the replay-analysis companion, working through the questions a policy developer actually asks, each answered from re-simulated replay data against real baselines: is my crew wasting time on tasks, am I voting the way the league’s qualification gate requires, why do I keep dying, and where should I kill as imposter. Everything runs offline with no game engine or account. The bundle ships the swgy_base, swgy_tools, and swgy_tune wheels, thirty re-simulated league games as trajectory and task data, and a sample replay for the bring-your-own-games walkthrough.