Procedural Levels for Roguelikes

Design the Level Generation Pipeline for Permadeath Play

Permadeath changes the design requirements for procedural generation fundamentally. In a game where the player can reload a save and try again, an unfair level is an inconvenience. In a roguelike, an unfair level ends a run that might have lasted an hour. This means the generator must be more careful about fairness than generators for non-permadeath games.

Fairness in a roguelike means the player should always have the tools and information needed to survive, if they play well enough. The generator must never create situations where death is unavoidable regardless of player skill. This requires guarantees like: the player can always reach the exit, every locked door has an accessible key, no enemy is placed where the player must fight it without adequate preparation, and essential resources (health, ammunition, escape options) appear at regular intervals along the critical path.

Variety is equally important. A roguelike player who has completed 200 runs will notice repeated patterns very quickly. The generator must produce enough visual and structural variation that even experienced players encounter surprising layouts. This means using randomization at multiple scales: the overall floor shape, room sizes and positions, corridor routing, decoration themes, enemy group compositions, and item locations should all vary independently.

Learnability distinguishes great roguelike generators from merely adequate ones. While the specific layout changes every run, the rules governing generation should be consistent. Players should be able to learn patterns like "shops always appear on floors 3, 6, and 9" or "treasure rooms have exactly two entrances" or "the boss floor always has a preparation room before the boss arena." These consistent rules give players knowledge that accumulates across runs, creating a sense of mastery even as the specific challenges change.

Build the Spatial Layout with Roguelike-Appropriate Algorithms

Traditional roguelikes use grid-based maps where each cell is a wall, floor, door, or special tile. The grid resolution determines the level of spatial detail, with common sizes ranging from 40x25 for compact levels to 120x80 for sprawling dungeons.

BSP tree generation remains the most popular algorithm for traditional roguelikes because it produces clean room-and-corridor layouts that work well with turn-based, grid-based movement. The rectangular rooms give clear sightlines for tactical positioning, and the corridor connections create chokepoints that reward careful play. The original Rogue used a simplified version of this approach, and modern roguelikes like Dungeon Crawl Stone Soup use sophisticated variants with variable room shapes and multi-connection corridors.

Cellular automata caves work well for organic-themed roguelike levels: natural caverns, underground forests, or alien hives. The organic shapes break up the rectangular monotony of BSP dungeons and create more complex tactical situations with irregular cover, narrow passages, and open chambers. Many roguelikes alternate between BSP and cellular automata levels to provide visual and tactical variety across different dungeon zones.

Hybrid approaches combine multiple algorithms within a single level. A BSP-generated castle section might connect to a cellular automata cave through a transition corridor. A central hub room might connect to procedurally placed satellite rooms via random walk tunnels. These hybrids produce the most interesting levels because the contrast between different generation styles creates variety within a single floor.

Action roguelikes (sometimes called roguelites) like Dead Cells and Hades use hand-crafted room templates that are assembled procedurally. The generator selects rooms from a pool, connects them into a graph, and randomizes enemy and item placement within each room. This hybrid approach combines the quality of hand-designed spaces with the variety of procedural sequencing.

Implement Floor-Based Difficulty Progression

Most roguelikes organize their dungeons into floors (or depths), with difficulty increasing as the player descends. The generator must produce floors that match the expected player power level for that depth, creating a smooth difficulty curve from the entrance to the final challenge.

Enemy scaling across floors follows a defined difficulty table. Floor 1 might draw from a pool of basic enemies (rats, goblins, slimes) with low health and simple attack patterns. Floor 5 might introduce ranged enemies and enemies with special abilities. Floor 10 might add enemies that inflict status effects or summon reinforcements. Each floor's enemy pool is a subset of the total bestiary, tuned to match the player's expected capabilities at that depth.

Item generation follows a parallel curve. Early floors provide basic equipment and consumables that teach the player game mechanics. Mid-game floors introduce powerful items that enable build specialization and strategic diversity. Late-game floors offer rare items with unique effects that can transform a run. The generator controls this progression through rarity tables that shift as depth increases, making powerful items more common on deeper floors.

Environmental hazards escalate alongside enemies and items. Early floors might have simple spike traps visible on the ground. Later floors introduce hidden traps, moving hazards, environmental damage zones, and timed mechanisms. The generator places hazards using the same distance-from-entrance heuristic used for enemy scaling, ensuring the player encounters hazards appropriate to their experience level.

Floor size and complexity also scale with depth. Early floors are typically smaller and simpler, letting new players learn movement and combat mechanics without being overwhelmed by navigation. Later floors grow larger and more complex, with branching paths, secret areas, and optional challenge rooms. This spatial scaling creates a natural pacing curve where the player spends more time on each successive floor, building tension toward the final confrontation.

Place Items, Enemies, and Interactive Elements

The spatial layout is the skeleton, but gameplay element placement creates the actual play experience. Each element, whether it is an enemy, an item, a trap, or an interactive object, must be placed with intention relative to the dungeon's structure.

Enemy placement uses room size and position to create varied encounter types. Large rooms host group encounters where the player must manage multiple threats simultaneously. Small rooms create tense one-on-one fights in cramped quarters. Corridor intersections become ambush points where enemies can approach from multiple directions. Dead-end rooms place the player at a tactical disadvantage, making the reward for exploring them proportionally greater.

Item shops, rest points, and safe rooms should appear at predictable intervals to create a reliable rhythm. Players learn to expect a shop every three floors, a healing fountain before each boss, and an equipment upgrade opportunity at the midpoint of each zone. These anchor points give the player a sense of progress and create natural decision points (spend resources now or save them for later?).

Secret rooms reward exploration and observation. A wall segment that looks slightly different, a floor tile with a subtle pattern, or a dead end that is suspiciously close to an adjacent room all hint at hidden areas. The generator places secrets based on the dungeon graph, targeting locations where two rooms are separated by a single wall segment. The secret passage connects them, creating a shortcut or revealing a hidden reward.

Interactive elements like levers, pressure plates, teleporters, and conveyor belts add mechanical variety to the dungeon. The generator places these elements in configurations that create small puzzles: a lever that opens a gate across the room, a pressure plate that disables a trap in the adjacent corridor, a teleporter that provides a shortcut past a dangerous area. These interactions break up the combat-exploration loop and give the player additional tools for navigating the dungeon.

Test and Tune with Automated Playtesting

Roguelike generators require extensive testing because every possible seed must produce a playable level. Manual testing cannot cover the enormous output space, so automated testing is essential.

Structural validation runs first. Every generated level is checked for connectivity (all reachable areas are connected to the exit), solvability (any required keys or switches are accessible before their corresponding locks), and bounds compliance (the level fits within the expected dimensions and does not violate spatial constraints). Structural validation catches catastrophic generation failures that would brick a run.

Automated play simulations test gameplay quality. A simple AI player navigates the generated level, fighting enemies and collecting items while following basic strategies (seek the exit, fight enemies that block the path, pick up nearby items). By running thousands of these simulations, you can measure statistics like average completion time, percentage of runs that reach the exit, average health remaining at the exit, and percentage of items collected. These metrics reveal systematic issues like floors that are consistently too hard, areas that are never visited, or resources that are too scarce.

Difficulty distribution analysis checks that the generator produces a consistent difficulty curve across its output range. A histogram of "average player health at each floor depth across 10,000 runs" should show a smooth decline, not erratic spikes. If certain floor depths consistently produce spikes in difficulty, the generator's parameters for those depths need adjustment.

Seed-specific regression testing saves seeds that produce known-good or known-problematic levels and re-runs them after generator changes. This ensures that bug fixes and improvements do not accidentally make previously good levels worse. A library of reference seeds, categorized by interesting properties (unusually hard, unusually easy, edge cases), provides a fast regression suite for validating generator changes.