On this page
  1. A template is a tagged piece
  2. Weighted selection
  3. The guaranteed route
  4. Noise instead of templates
  5. Determinism where it helps
  6. Testing a generator
  7. Templates, not noise
  8. Joining chunks without seams

A template is a tagged piece

Monster Tower builds each floor from a library of templates, and each template carries two pieces of metadata: what it requires, and the earliest floor it may appear on.

TemplateRequiresFirst allowed floor
PlainNothing1
GapA jump2
StepsHeight judgement3
MovingTiming a board5
ThinKnowing you can drop through6
SpikesA precise landing8
CrumbleNot stopping11
NarrowGap and precision together14
GauntletMoving and crumbling together20

The floor number is the teaching mechanism. A mechanic cannot appear before the player has had a chance to meet its components, which reproduces the introduce-then-combine curve of a hand-built level set without a designer placing anything.

Weighted selection

Once a template becomes legal it is not immediately common. Each eligible template is weighted by how far past its minimum floor you are, capped at a small maximum.

The effect is that a mechanic is rare when it first becomes possible and normal later. That matters because a player meeting a new template for the first time on floor five and then not seeing it again for twenty floors learns nothing; meeting it occasionally, then regularly, builds a vocabulary.

It also means the difficulty of a generated run is smooth in aggregate even though any individual floor is a draw.

The guaranteed route

The single most important constraint: every generated floor includes at least one plain landing platform, and there is always a route through that does not require frame-perfect timing.

That is what separates a generator with rules from a random number generator with extra steps. A generator allowed to be genuinely unfair produces content that is technically infinite and emotionally meaningless, because a player cannot tell whether failure was their fault.

The same principle appears elsewhere. In Lava Beast, each generated ledge is placed within jump reach of the one below it. In Monster Escape, extra walls are knocked through the carved maze so no wrong turn is a full retrace.

Noise instead of templates

Two games generate continuous geometry rather than discrete pieces.

Rolling Beast builds terrain from layered value noise — three octaves at different frequencies, summed. Amplitude grows with distance travelled, so the hills genuinely get bigger rather than only arriving faster.

Monster Tunnel uses the same approach for its walls. The tunnel's centre line is a noise function of distance; the gap narrows toward a floor and stops. All late difficulty comes from the noise being sampled faster — the walls undulate more, the gap does not shrink further.

Noise suits continuous surfaces for the same reason templates suit discrete obstacles: it produces variation without discontinuity, and a sudden discontinuity in a surface you are tracking reads as a bug.

Determinism where it helps

The generators are not seeded per run — there is no leaderboard to share a seed with, and determinism would cost the main benefit of generation.

Determinism is used internally, though. Background detail in several scenes is derived from a hash of its position rather than stored, which means a distant spire stays in the same place between frames without costing any memory. The terrain noise is seeded per run so a hill you are approaching does not move while you approach it.

The rule of thumb: determinism for anything the player will see twice in one run, randomness for anything they will see once.

Testing a generator

You cannot playtest a generator by playing it, because you will only ever see a few hundred of its outputs.

What works instead is generating thousands of outputs offline and checking the constraints held on every one: minimum gaps respected, at least one safe route per floor, no ledge beyond jump reach, no two-lane block repeated. A constraint that holds in practice but is not enforced in code will eventually fail in front of a player.

The second technique is deliberately generating at extreme difficulty values — the conditions a player reaches after ten minutes — rather than always testing from second zero. Most generator bugs live in the tail, which is exactly where nobody looks.

Templates, not noise

Generation here does not place objects at random positions. It assembles hand-authored chunks, which is why generated content still looks designed.

Each template is a small arrangement that a person built and verified — a three-gap sequence, a floor layout, a two-lane obstacle pair. The generator's job is choosing which template comes next and how to join it to the previous one, not inventing the content.

The advantages are substantial. Every template is known to be fair, because someone played it. Variety comes from combination rather than from randomness, which produces arrangements that surprise without producing arrangements that are broken. And when something plays badly, the fix is a template rather than a probability distribution.

The risk is repetition, which is handled by forbidding the same template within a window and by varying how templates are joined. A player should recognise the vocabulary without recognising the sentence.

Joining chunks without seams

Assembling hand-authored pieces solves fairness and creates a new problem: the joins.

Two individually reasonable templates placed back to back can produce something neither designer intended — a landing immediately followed by a required jump, or a dense section arriving directly after another.

So the generator does not simply concatenate. Each template declares what state it leaves the player in — on the ground, airborne, at speed — and what state it requires to begin. A join is only legal when those match, and a short connector is inserted when they do not.

That connector is why generated content has breathing room at all. Without it, a run would be a sequence of demands with nothing between them, which is the single most common failing in procedurally generated action games.

Key takeaways

  • Templates carry a requirement tag and a minimum floor, which reproduces introduce-then-combine teaching automatically.
  • Weighted selection makes a new mechanic rare at first and normal later, building vocabulary.
  • Every generated floor guarantees a route that needs no frame-perfect timing.
  • Continuous surfaces use layered noise rather than templates, because discontinuity reads as a bug.

Frequently asked questions

Can a generated floor be impossible?

No. Every floor includes at least one plain landing platform and a route that needs no frame-perfect timing.

Why does terrain use noise instead of pieces?

Because a continuous surface needs variation without discontinuity. A sudden join in terrain you are rolling over reads as a bug rather than as difficulty.

Do you use random seeds?

Not per run. Determinism is used internally for anything the player sees twice in a run, like background detail and terrain, so it stays put between frames.

Is the content actually random?
Not in the way people usually mean. The generator assembles hand-authored chunks that a person built and verified — it chooses which comes next and how to join them, rather than inventing the content.
Can it generate something impossible?
Not within its constraints: reachability, commit spacing, a guaranteed safe route, no short-range repetition, and recovery space after dense sections. If a section felt impossible rather than hard, it is worth reporting.
Illustrated portrait used for the Monster Arcade editorial byline

Alex Morgan

Browser Games Editor & Interactive Gaming Content Specialist

Alex Morgan is the editorial byline for everything published on Monster Arcade — the design notes behind all 30 original games, the strategy guides, and the tuning decisions that set every difficulty curve on the site. More about our editorial byline.

Published · Last updated