
How to Make a Tycoon Game: Economy, Balance and Tests
A tycoon is an economy, time and player decisions. If you're figuring out how to make a tycoon game whose balance a small team can actually hold together, you need three things. The game logic must live in separate code with no UI. The randomness in it must be reproducible. And the balance must be guarded by automated tests that run through decades of play in seconds. This guide has six steps. They're how we built our management sim AI Inc: Tycoon.
In short:
- The game core is a separate module with zero UI imports.
- The logic has no unseeded
Random()and no "current time". - Time runs on its own but never makes the player wait.
- The balance is described by tests. If a test fails, the balance broke — the test didn't go stale.
Step 1. Keep the core separate from the UI
The whole game is a module in a plain language with no engine: in a Flutter project, that's Dart without package:flutter and dart:ui. Add a test that fails the moment a UI import sneaks into the core. Then a run from the first year of the game to the last takes seconds instead of hours of manual play.
The second rule: the UI owns nothing. A screen doesn't calculate money by itself; it asks the core. Otherwise, sooner or later, the same number will show up differently on two screens.
Step 2. Make randomness reproducible
Route all randomness through one generator whose state is stored in the save. The simplest option is xorshift32, where the entire state is a single number:
class Rng {
static const int _m32 = 0xFFFFFFFF;
int _x; // the whole generator is one number, and that's what goes into the save
int next() {
var x = _x;
x ^= (x << 13) & _m32;
x ^= x >>> 17;
x ^= (x << 5) & _m32;
return _x = x;
}
}
There's deliberately no multiplication here, only shifts and XOR, so the result is identical on every platform. What this gives you:
- the same save and the same decisions always produce the same result;
- a player's bug can be reproduced step by step from their save;
- leaderboard results can be verified by replaying the run.
Step 3. Let time run, but never make players wait
Let the game clock run on its own while the game is open: pause, 1×, 2×, 3×. But skip "come back in 4 hours" timers entirely. Three more rules keep the game fair:
- time stops while an unresolved letter or an open window is waiting for the player, so decisions never scroll past without them;
- when the app is closed, the game doesn't simulate: players aren't punished for leaving, and they aren't "rewarded" for not playing;
- events don't fire on their own; they join a short queue, and the player always makes the choice.
Step 4. Turn tycoon game balance into tests
Balance isn't a feeling; it's a few measurable rules. We have four, and each one has already caught a real defect:
- Diagonal dominance. The best strategy for each model class wins in its own class.
- No universal build. A class's own optimum clearly beats the "best on average".
- Choices matter. The optimum clearly beats an even split.
- No economically dominant class. The income spread between classes stays under a set threshold.
An example of what these tests catch. One research direction yielded 2.6 points per unit invested, another 0.5. A 5.2× spread isn't a trade-off; it's an obvious best strategy. The fix is an invariant: every row of the contribution matrix has the same sum. Directions differ in where they give points, not how many. The second rule: every discipline has exactly one leader.
Step 5. Measure along the timeline
Calibrating in a single year can't see what breaks over time: salaries, hardware prices, market expectations. Normalize era multipliers to the founding year so they equal exactly 1.0 in year one, and guard that with a test. Measure every year-dependent value along the whole timeline, not at a single point.
One more rule: run every new reward at the game's worst pace. A gift that looks minor can, on a weak start, unlock a strategy that breaks the whole early market.
Step 6. Cover everything else
Beyond balance, tests should guard saves (a checksum and several backups), texts in every language, how screens look and the real-time pacing of events. The rule is simple: if a balance test fails after you change a constant, the test isn't outdated — the change broke the game.
Checklist
- ✓ The core doesn't import the UI, and a test guards that.
- ✓ All randomness goes through a generator whose state lives in the save.
- ✓ No wait timers, and a closed game doesn't simulate.
- ✓ Balance rules are written as tests.
- ✓ Year-dependent values are measured across the whole timeline.
- ✓ Every reward has been tested at the worst pace.
FAQ
What should you use to make a tycoon game?
A tycoon is mostly interface, so we build ours with Flutter. For a comparison with Unity, see our guide Flutter vs Unity for mobile games.
How do you test balance without thousands of players?
By running the core without a UI: dozens of strategies, hundreds of seeds, every year of the game. Live testers are for feel, not for arithmetic. How to find them for Google Play is in our guide Google Play closed testing.
How do you check hundreds of events?
With a validator that runs in the tests: a unique ID, a year within its era, a known trigger and 2–3 choices in every event.
Can a tycoon work offline?
Yes, if the simulation core runs on the phone. Then you don't need a server at all.
Building your own tycoon or management sim? We design economies, progression and balance tests for other people's games the same way we do for our own. More on our services page, and for publishers and studios, see partnerships with companies.
