Mobile Game Development: Where Level Generation Breaks
The content bottleneck manifests in the second or third week after release.
A player completes 20–40 levels in the first sessions, while a level author manually assembles 5–8 puzzles per week: the deeper the progress, the more expensive each next one is — you need to verify solvability, uniqueness of the solution, and absence of dead-end branches. The team either stops progress with artificial limits or releases levels below the quality bar.
Procedural level generation removes this limitation, but only under one condition — determinism.
The same random seed must produce an identical grid, set of elements, and solution on any device and at any point in time: otherwise leaderboards, saved playthroughs, and complaints like “mine is different from my friend’s” become an unsolvable support task.
The second weak point is puzzle difficulty balance. The generator produces formally valid levels, but the distribution of solutions spreads out: some boards are solved with one obvious move, some require brute force.
Therefore, next to the generator we put a solver that counts the number of paths, search depth, and minimum number of moves, as well as completion metrics from analytics.
The third is divergence in behavior across platforms. Different arithmetic and rounding when checking conditions produce levels that become unsolvable on some devices.
It is treated with integer logic of generation and checking each batch across the entire fleet of target configurations before publication.
Next, we break down how this is addressed in mobile game development: from generator architecture and difficulty curve to the level release pipeline and rollback of a failed batch.
Procedural Level Generation in a Game: What Changes
A level is not drawn manually but assembled by a reverse pass: the generator first builds a correct solution, then removes hints to a given density and checks the layout for solvability.
The generator seed fixes a specific level, so a defect is reproduced with a single configuration line, not “sometimes on the third screen.” The difficulty curve is set by a set of parameters — hint density, depth of logical connections, allowed number of dead ends.
Wave Function Collapse is used as one of the layout assembly modes when field variability is needed while preserving structure. The main loop remains deterministic: invariants are checked at each step, and a level is rejected before entering the build.
The effect is measured directly. One tuned parameter branch yields thousands of distinguishable levels without expanding the designer team, and a new portion for a puzzle update is assembled by running the generator, not months of manual work.
The automated test suite checks solvability, absence of false dead ends, and reachability of each branch — the class of “level is not completable” errors is closed before release.
Difficulty edits become a setting, not redrawing: we change branch parameters, run batch validation, and get a new set with preserved progression. In mobile game development, this is content without team growth — the number of levels scales, not the number of people.
Level Generation Modes and Their Limitations
Three level generation modes differ not in quality, but in who is responsible for balance — the algorithm or the designer.
Full generation gives an unlimited stream of levels from a seed, but solvability has to be proven with a separate verification algorithm, and difficulty grows statistically, not according to authorial intent.
Manual level design keeps control over pacing and player learning, but labor costs per level are high, and content runs out before interest does.
Hybrid generation removes this contradiction: the generator assembles the framework and layout, the designer defines allowed combinations, critical points, and difficulty-scaling rules.
Generator constraints are described declaratively, so they can be edited without rebuilding level logic.
| Mode | When it fits | Limitations |
|---|---|---|
| Full generation | Endless mode, daily challenges, hypothesis testing at scale | Requires separate solvability control; difficulty is distributed statistically; trivial layouts occur periodically |
| Hybrid generation | Main campaign, seasonal sets, long-term progression | Requires a template library and rule configuration; an error in the rules is replicated across the entire level stream |
| Manual level design | Tutorials, key and story levels, chapter finales | High labor costs per level; scaling is limited by people; balance edits affect each level separately |
Modes are not mutually exclusive: tutorial levels remain manual, daily challenges are fully generated, and the campaign is assembled hybridly. Switching between them does not require rewriting logic if the level description format is common.
Stages of Puzzle Development with Level Generation
We start work by formalizing the rules: which elements participate in a level, which combinations are allowed, where comfortable difficulty ends.
The level generation scheme depends on these rules — a deterministic algorithm that, based on the level number, produces the same layout for all players.
- Task and generation rules analysis: we fix the set of elements, constraints on their combinations, the rate of difficulty growth, and the required amount of content at launch.
- Designing the level generation scheme: we divide the algorithm into phases — placement, connectivity check, goal insertion — and set the seed and prohibition of dead-end starting states.
- Completability check: each generated level is run through a solver that searches for a solution within a given number of moves; layouts without a solution are discarded automatically.
- Difficulty balancing: we build a curve based on the number of moves and the number of solution variants so that growth is smooth and no wall level appears midway.
- Assembling the shell and integration with the generator: interface, progress saving, offline operation, hints based on the same solver.
- Acceptance and project handover: running automated tests on a level array, documentation on rules and algorithm, access to the build and source code.
At acceptance we show a report: how many levels were generated, what share passed the completability check, how difficulty was distributed across progression.
Project handover includes not only source code but also a description of the rules — the client’s team can add their own mechanics and change the difficulty curve without us.
Project Artifacts: Generation Rules and Documentation
The project ends not with a release in app stores, but with a set of artifacts that the client’s team works with independently afterward.
All of this is in the client’s repository from day one: source code, configurations, build scripts, and documentation — and is not uploaded at the end as a single archive.
- Level generation rules — a formal description: which parameters define the move budget, obstacle density, and difficulty curve by chapter, and which constraints guarantee solvability. Next to it is the rules configuration itself, which can be edited without changing logic.
- Balance tables — rewards, mechanic introduction rate, and difficulty are moved into data files. Editing numbers does not require rebuilding the app; the result is visible immediately in a test run.
- Automated level validation — a run of a batch of generated levels: it cuts off unsolvable and trivial ones and produces a report on difficulty distribution. Protection against the game becoming too easy after editing a coefficient.
- Builds for two platforms — release builds for both target platforms, profiles and signing keys, build scripts. Releasing a version is one command instead of a manual sequence of steps.
- Update policy — content release order: branches, pre-release checks, criteria and method for rolling back to the previous version, delivery window for seasonal level sets.
- Project documentation — architecture, progress storage scheme, instructions on “how to add a new mechanic end to end” with a breakdown using an existing one.
- Set of test scenarios — fixed generator initial values and saved progress states, on which a player complaint is reproduced in one run instead of a day of searching.
Case Study: A Puzzle on Two Platforms Without Rewriting
The puzzle was released simultaneously on two platforms: shared field and rule logic, differences only in the input and purchasing layer. Levels were still built by hand: a designer assembled the grid, ran it for solvability, and uploaded it to a common description format. A pack of 60 levels took 4-6 weeks, while strong players completed it in three evenings and left.
What was the bottleneck
Day 7 retention held around 18%, by day 30 it fell to 6% — content ran out faster than it could be made. Balance edits required rebuilding the entire pack, and some levels still came back with “no solution” complaints.
The same grid felt different on phone and tablet, and analyzing each such situation consumed team time.
What changed
Level logic was moved into the generator: it assembles grids according to a set of rules — allowed shapes, obstacle density, move limit — and checks solvability before entering the build.
There are no more uncompletable situations in release, and difficulty is set by a curve: the first levels teach the mechanic, then it grows in steps.
Metrics after
Release to Google Play and App Store became one cycle: the generator and rules are shared, only platform layers differ.
The level stream stopped being a bottleneck — the daily set is assembled for a specific player, and balance is adjusted with parameters rather than rebuilding the pack.
Day 7 retention grew from 18% to 31%, day 30 from 6% to 12%, and the share of sessions with a “stuck” complaint fell by a factor of three.
How Procedural Level Generation Differs from Manual Design
Direct answer: these are not competing approaches, but different tools for different tasks. Manual level design wins where the player learns the mechanic: first sessions, introduction of new elements, key progression milestones. Procedural generation wins where volume is needed — daily challenges, endless modes, mid-campaign.
The difference is in the cost of error. A manual level is designed for a specific difficulty curve, and the designer is responsible for every trap, but person-hours grow linearly with the number of levels.
The generator produces hundreds of configurations in minutes, but without rules it easily produces unsolvable layouts and monotonous sequences.
| Approach | Where it is stronger | Limitations |
|---|---|---|
| Manual level design | teaching mechanics, first 10–15 levels, story milestones | designer time grows linearly, expensive to scale after release |
| Procedural generation | mass levels, daily challenges, replayability | unsolvable configurations, weak difficulty curve, repetitions |
| Hybrid: manual framework + controlled randomness | seasonal content and post-launch support | requires tooling: validator, completion metrics, manual polish |
Controlled randomness is a generator constrained by rules: a fixed seed per level, a set of room templates, a limit on the number of allowed solutions, and a target difficulty corridor.
Each generated level is run through the solver: if the path is shorter or longer than specified, the layout is discarded and the seed is recalculated. Additionally, we check that starting moves do not hint at the solution and that a hint does not open a dead end.
In practice, we build a validator into such projects as part of the build — the share of discarded layouts stays within 5–10%, difficulty variance within a chapter stays within the corridor, and time to first solution for new players does not drop.
A typical setup: key levels are drawn manually, the middle and daily modes come from the generator with manual polish. Discuss the task — we will come back with an estimate of what share of levels needs a designer and for what share rules are enough.
Technical Questions on Generation and Cross-Platform
The level generator is not a black box: every draft undergoes automated solvability checking, and the difficulty curve is compared against the target profile. Below are the doubts we most often address before acceptance.
How are uncompletable levels filtered out?
The generated puzzle is solved by an automatic solver within a limited number of moves. If there is no solution or it is longer than the limit, the draft is discarded and the generator receives a new set of parameters.
Additionally, the level is run from different starting points — this filters out dead ends caused by an unsuccessful sequence of actions.
Will the levels become predictable?
Each level is built from a generation seed: one seed produces one layout. This is needed for error reproducibility and replay, but it does not play the same — the template pool and set of allowed moves change along with difficulty. We separately control that same-type solutions do not accumulate on mid-levels.
What about differences between platforms?
We build both versions from a shared codebase in Unity, but we test behavior on real devices: an emulator does not convey real gesture responsiveness. We test screen safe areas, background process pausing, and progress saving on interruption.
We check generation quality by breakdowns: the share of solvable drafts, variance in the number of moves to victory, and player exit points. Using this data, we adjust generator parameters, not individual levels.Let’s Discuss the Task: What Is Needed to Estimate Your Puzzle
For a puzzle development estimate to be based on mechanics rather than an “average market price,” an input data set is needed.
The more specific the inputs, the fewer assumptions in the calculation and the more honest the stage plan: a fixed-size field with solvability checking and an endless generator with difficulty growth are different scopes of work, even though both are called a “puzzle.”
- Level rules: field size, set of elements, win and lose conditions, move or time limit.
- Procedural generation logic: what should be random and what should be fixed; whether solvability and solution uniqueness checking is needed on every level.
- Modes and progression: endless mode, sequence of levels with increasing difficulty, daily challenges, comparison of player results.
- Platforms and target devices: where we launch first, constraints on installation package size and offline operation.
- Visual materials: mockups or reference examples, style description, animation and sound requirements.
- Project constraints: desired deadlines, who on your side makes decisions on disputed points, whether there are already existing assets or a prototype.
In response, we will send a technical specification for the game with a description of the mechanics and control points, an estimate broken down by stages — prototype, level generator, interface, build and publication — and a launch plan with open risks. Describe the task, and we will come back with an estimate and a plan.