One of the features that makes certain roguelikes feel alive is the presence of structured dungeon encounters rather than purely random rooms. These special constructions are often called machines.
Machines are small procedural structures that combine terrain, items, monsters, and traps into meaningful scenarios. Instead of simply scattering content randomly, the game creates coherent situations that challenge the player in interesting ways.
Games like Brogue are well known for using machine generation to produce memorable dungeon moments.
A machine is essentially a procedural mini-event embedded inside the dungeon.
Unlike simple room decoration, machines follow a specific template that defines how several elements interact.
For example, a machine might include:
Together, these elements form a small gameplay puzzle.
Machines make the dungeon feel designed, even though everything is still generated procedurally.
Without machines, dungeon generation can feel repetitive. Random placement alone often produces rooms that lack purpose.
Machines solve this problem by introducing structured encounters.
They create situations such as:
Because each machine combines multiple systems, the player must think tactically about how to approach the encounter.
Each machine type is defined by a template describing what should appear and how it should be arranged.
A template might specify:
For example, a simplified template could describe a treasure vault:
Room center:
treasure chest
Entrance:
locked door
Guard:
strong monster nearbyThe exact layout may vary, but the general structure remains recognizable.
When generating a dungeon level, the game evaluates which machines are allowed to appear.
Typical conditions include:
If conditions are satisfied, the generator attempts to place the machine inside the level.
Placement may involve:
Because these steps modify the map, the generator must ensure the machine fits naturally into the dungeon.
Machines should feel like part of the dungeon rather than artificial structures.
To achieve this, the generator respects several constraints:
This ensures that the dungeon remains playable while still containing interesting encounters.
The real strength of machines comes from how they interact with other game systems.
For example:
Because roguelikes rely heavily on emergent mechanics, machines often produce unexpected situations.
The player might turn a dangerous machine encounter into an advantage by using clever tactics.
In the Swift reimplementation, machines are implemented as structured data rather than scattered procedural logic.
Each machine template describes:
Conceptually, a machine definition might look like this:
struct MachineTemplate {
var terrain: TileType
var features: [DungeonFeature]
var monsters: [CreatureType]
var items: [ItemType]
}This approach allows the generation system to treat machines as modular building blocks.
Machines also evolve as the player descends deeper into the dungeon.
Later levels may include:
By tying machine selection to dungeon depth, the generator ensures that encounters remain appropriate to the player’s progression.
One challenge with machine systems is preventing them from becoming predictable.
To maintain variety, the generator introduces several random elements:
This ensures that even familiar machines can produce different scenarios each time they appear.
The machine generation system was reimplemented entirely during the engine rebuild.
Instead of relying on tightly coupled procedural code, the Swift implementation treats machines as data-driven structures.
This makes the system:
New machine types can be added simply by defining new templates rather than modifying the core generator.
Machine generation is one of the systems that gives roguelikes their memorable moments. By combining terrain, monsters, and items into structured encounters, the dungeon becomes more than just a collection of random rooms.
Each machine introduces a small story: a guarded vault, a trap-filled chamber, or a monster-infested nest.
Rebuilding this system in Swift ensures that the new engine can generate these dynamic encounters while maintaining a clean and flexible architecture.