A dev note on the bot simulators behind Arrow Sweep, Dokkaebi Tavern and Dokkaebi Night Parade: which bots we build, which numbers we read, and where a bot told us our design was wrong.
Difficulty is hard to set by feel. A level that "should be fine" turns out boring, or turns out to be a wall. And we cannot call in human testers every time we change one number.
So the JWorld team builds a bot simulator for every game before anything else. It runs the rules without a screen, so a change to a price or a multiplier shows its effect in seconds. This note explains how that works. Every figure comes from the games' READMEs, design notes and simulator scripts.
Rules and screen live apart
Simulation is possible because of one structural choice. Game rules live in a core folder that knows nothing about the screen (the DOM). The screen only draws what the rules return. Time is not read by the engine either; it is handed in as tick(state, seconds).
That means the code a human plays and the code a bot plays are the same code. A bot that simulates 90 days uses the same rules as the shipped game. Dokkaebi Night Parade goes one step further: the same bot objects drive both the simulator and a development hook in the browser, so a simulated run and a real on-screen run can be compared one by one.
Not one bot, but a ladder of bots
The key principle: a single perfect bot cannot tell you how hard a game is. A level that an optimal bot solves in a blink can still be brutal for a person. So we build bots of different skill.
Arrow Sweep has this ladder:
| Bot | What it does | What it measures |
|---|---|---|
| naive | taps the first free arrow | whether mindless tapping earns three stars |
| greedy | taps the arrow that sweeps the most | whether the obvious move is the right one |
| 2-step | looks one tap ahead | whether a slightly thoughtful player reaches par |
| human | 30% a random arrow, 70% the bigger sweep of two random arrows | a typical player's star odds |
| smart | the exact solver | par itself |
These bots also decide which boards are accepted. In the easy world a naive bot must not collect three stars. In the hard worlds even a greedy bot must miss par. Trap boards are chosen so that the most tempting tap costs exactly one extra tap.

Reading the human bot's numbers
The Arrow Sweep README lists, for every world, how the human bot does on the boards we kept. We pick boards so these land inside target bands.
| World | Human, 2+ stars | Human, 3 stars | Naive bot gets 2 stars |
|---|---|---|---|
| W1 | 0.99 | 0.55 | n/a |
| W2 | 0.80 | 0.21 | 0.09 |
| W3 | 0.78 | 0.11 | 0.18 |
| W4 | 0.81 | 0.06 | 0.04 |
| W5 | 0.80 | 0.05 | 0.04 |
The pattern is deliberate. In World 1 nearly everyone gets two stars and more than half get three. By World 5 the human bot gets three stars on roughly one board in twenty. Two-star odds stay near 0.8, so harder worlds still feel clearable. The table is checked against the design document's targets within ±0.04, and the whole pace run takes about a minute, so we can redo it every time boards are regenerated.
Idle games: simulate the visiting pattern
An idle game like Dokkaebi Tavern is not about one level. It is about days. Its bot imitates someone who drops in a few times a day:
- One long first session of 60 minutes, plus 8 minutes that evening.
- Then four visits a day, 6 to 8 minutes each.
- Time away is paid out by the real offline rules.
- One tap per second, and always the best-value purchase.
Ninety simulated days take about 40 seconds. The README's results look like this:
| Milestone | Bot result |
|---|---|
| First move to a new town | 5 minutes |
| Hanyang Market | day 10 |
| Dokkaebi Market | day 14 |
| Glutton levels 30 / 60 / 120 | days 10 / 20 / 40 |
We write the target pace first (first 30 seconds, 15 minutes, first day, weeks two and three) into the design document. When the simulator drifts away from it, we change prices or multipliers.

Where the bots caught us
A simulator earns its keep when it says the design is wrong. Three real cases:
- A runaway feedback loop. Moving town gives a reward, the reward raises income, and income raises the next reward. When Rumor was a square root of lifetime income, the bot's progress exploded. We switched to a cube root and capped how many dishes each town may sell.
- A new system pulled everything forward. The first Glutton upgrades cut the time to reach a town from 15 days to 10. We trimmed the main-game bonus to +5% per level and raised the town requirements.
- The bot was too smart. Our first-13-minutes table used a fast bot, and it disagreed with what blind playtesters did. So we added a human-like bot, PERSONA: it looks around every 12 seconds and only notices a new button after it has been on screen for 150 seconds. With it, the first move becomes available between 6:38 and 9:53 (p10 to p90) instead of being reached by only 1 run in 30.
The third case matters most. If the bot is faster than a person, the simulator says everything is fine when it is not. Making the bot slower and clumsier is part of the engineering.
Action games need a bot that stands still
In Dokkaebi Night Parade, standing still charges your ward. Its simulator therefore has bots built around that rule:
| Bot | Movement |
|---|---|
| smart | full information; dodges, collects gems, pauses when ghosts are far |
| ns | never still (the baseline for how much standing still helps) |
| as | never moves |
| random | a new random direction every 0.5 seconds |
| hb | human-like: 0.25 s late, ±15° of noise, sees only what is on screen |
Comparing the bot that stops with the one that never does shows, in numbers, whether the standing-still rule is a real advantage. Card picks are modeled too: a novice picks at random 35% of the time, a learned player 10% of the time and takes evolution partners first.
What bots cannot do
A bot cannot tell you whether a game is fun. It checks promises written in numbers: pace, star odds, survival time. That is why every game still goes through blind playtests played like a stranger would play. The bots are the filter; the final judgment comes from people-like play.
Summary
- Keep rules (
core) separate from the screen, so bots and people run the same code. - Build a ladder of bots: an exact solver for par, a human-like bot for star odds.
- For idle games, simulate "a few visits a day" and run 90 days in about 40 seconds to check milestones.
- Bots find runaway reward loops early; switching a square root to a cube root was one such fix.
- A bot faster than a human cannot be trusted, so we build deliberately slow, clumsy ones too.
- Bots are a filter. Playtests decide whether it is fun.
To feel the numbers yourself, try Arrow Sweep and Dokkaebi Night Parade, and see whether the star odds and survival times match our tables.
Written by the JWorld team from our game design documents and measured play data, with AI tools helping with the writing.