Roguelike on Nathaniel Inman

Building a Modern Roguelike in 2026

Sun, 12 Apr 2026 00:00:00 +0000

I have a habit of writing one of these every few years. In 2017 it was a 7DRL experiment merging a roguelike with an FPS, and in 2019 it was ascii characters embedded into a 3d map. This year’s entry is different: DET-33, the bullet-hell roguelike I built in JS and Phaser over the last few months, is feature-complete and plays great. So naturally I’m rewriting it from scratch in Godot 4 and C#.

Procedural Levels with Compass

Sun, 21 Dec 2025 00:00:00 +0000

I spent a good chunk of last year writing about compass, the map-generation library with all the fluvial generators and cellular caverns. The whole time I was building it as a standalone library, the real motive was to eventually drop it into a game. This month I finally did, and DET-33 now generates every one of its floors through compass.

Pulling the library in

Wiring it up was almost anticlimactic, which is the point of having spent the time on the composition layer. DET-33 pulls compass in as a git dependency and the level code just imports the scanning digger and the template data:

Kepler452b Released

Tue, 04 Aug 2020 00:00:00 +0000

Kepler452b is available for Windows, Linux & MacOS. Enjoy a roguelike with one of 8 classes, 5 unique worlds, beautiful graphics by Oryx, music by Scott Buckley & Sergey Cheremisinov, 28 unique enemies, 101 supervisors to modify your gameplay, a story and much more! Whether you prefer to sneak around and backstab with the assassin, use a flamethrower as a pyrotechnic or grapple enemies to you and poison them, there’s bound to be a play style you will enjoy!

Kepler452b Coming 2020

Tue, 03 Dec 2019 00:00:00 +0000

August 4th, 2020 Update: v1.0.0 Release

Official release page is here.

You can submit bugs or request features here.

Downloads & Links

Windows Download

Mac Download

Linux Snapfile Download

Linux App Image Download

Screenshots

Building a Modern Roguelike in 2019

Wed, 13 Nov 2019 00:00:00 +0000

At numerous times I’ve created demos trying to figure out how to merge a traditional roguelike into a FPS without sacrificing it’s roots. Here’s an article I made in 2017. Unlike many others I don’t feel like just random maps makes a roguelike, I’ve even gone so far as saying no FPS is a roguelike. In this experiment I’ve tried to merge those ascii characters into the map itself and dropped the textures. The code can be executed and ran or viewed in its entirety on Github here.

Meander Algorithm

Tue, 04 Sep 2018 00:00:00 +0000

The meander algorithm is a combination of using mazes to allow a meandering with bresenhams line. Below you can see the actual algorithm in simplicity. Obviously you could use noise maps to created heighted terrain based on the river to make it look pretty.

Choose a starting map edge and ending map edge, acquire the terminal points based on those edges. Usually this would be a random point on those edges. Maybe you’d want to weight it so it’s predominately in the center, or you could restrict it to a certain part.
Create Bresenhams line between the terminal points. This is called the pathing vector.
Break up the pathing vector into chunks of 9x9 where the pathing vector crosses the center. There may be left-over of the pathing vector.
For each chunk, perform a recursive maze generation algorithm on the chunk. Repeat this step until there is a path from the start of the pathing vector within the chunk to the end of the pathing vector in the chunk. A* pathing algorithm can be used for the pathing.
Merely use Bresenhams line to wrap up the extraneous pathing vector not covered by chunks, alternatively break up the remaining path into the largest odd number and chunk and process it similarly to the previous part of the algorithm to make it more consistent. Left overs in this optional way would still be filled in with bresenhams line.

Recursive Maze Generation:

Generating Exhumed River Channel

Mon, 06 Aug 2018 00:00:00 +0000

I recently did some work in generating rivers in a 2d game. Revisiting this work to create an exhumed river channel, I decided it might be fun to revisit how to generate it to make the channel look more realistic. Instead of using a drunken walker, this is a more expensive but interesting map generator:

Start by generating 2d simplex noise where
less <0.6 is floor
rest is walls
Generate terminal lines at each map exit (north, south, east, west). Shuffle those lines and randomly choose a start and end location for the river based on two of those lines.

Later you can add another line with terminal point to allow a split river channel

Generating Cliffs for 2d Game

Tue, 31 Jul 2018 00:00:00 +0000

Source code available on github here.\n\nA recurring problem in 2d games is how to represent depth. In isometric games this is easily solved but in discretely top-down games it’s harder to solve. After doing a lot of research I fell onto a simple idea: do the best you can insinuating the depth and leave the rest to the imagination. Here’s the algorithm I used to create 2d top-down cliffs:

Create a small map of perlin noise and a wide map of perlin noise. Add the two together and give the large map a weight of 3 with the small a weight of 1 and render the result with different breakpoints. This is ref map A.

Less than 0.01 on A is deep water

Generating 2d Rivers

Wed, 11 Jul 2018 00:00:00 +0000

Rivers are really hard to generate for 2d top-down games for multiple reasons:

Rivers primarily form based on heightmaps which are hard to display in top-down
Displaying fluidity when working with sectors or grid-based rendering can be complicated, bresenham’s line algorithm only goes so far to make things look smooth
naturally occurring mechanisms of nature have numerous factors in play that caused them to exist. Simulating all of these factors isn’t reasonable.

I was able to make relatively decent 2d rivers using a few techniques.

Balancing Game Mechanics

Wed, 06 Jun 2018 00:00:00 +0000

Two of the most influential components to decreasing LOE in balancing game mechanics is automating the most essential parts of testing those mechanics, and providing meaningful and easy to understand graphs. Some meaningful questions to better lay the foundation of balancing and creating these components:

What are the actual ‘core stat(s)’ that identify survival? (Usually health)
What are the ‘ancillary stat(s)’ that help facilitate the increase or decrease that core? (damage, strength, dexterity, etc.) I’m assuming all actors here are equal and we aren’t comparing apples and oranges.
What are the ‘supplemental stat(s)’ that may contribute to the increase or decrease of the ancillary stats? (class, rank, level)
What are the ’extraneous stat(s)’ that don’t affect the other stats already identified.

I found that creating a tree by drawing lines connecting these identified stats provided incredible insight and direction.

Pigeon Hole Stepping v2

Tue, 08 May 2018 00:00:00 +0000

I had originally written an article on how to implement PHS. Having found the maps generated slightly redundant I decided to take another look. Here are the steps taken to successfully generate a more realistic town. It’s essentially a drunken walker like Diffusion Limited Aggregation mixed with a hallway constraint that mimics the large part of PHS.

Start somewhere in the middle, add this and all possible directions up to a certain dynamic length (I used a standard deviation of 1.4 with a mean of 5, ) as nodes: [{x,y,direction},...].
We will be looping until all nodes and edges (we’ll describe that shortly,) are gone.
When we have node then check to see if the path between it’s ‘x,y’ and ‘x2,y2’ (given the length and direction) is clear. If it is, then add the entire path minus the start and end as edges, and add the end as a new node. Shuffle nodes after adding a new one. After building the path run through the path array randomly attempting to build a room in all directions. (this won’t be entirely possible and will leave negative space to fill with edges.)
If there are no nodes, repeat step 3 except with edges (this helps fill the map negative space.)
After all nodes and edges are gone then cover all cells adjacent to floors with walls if it’s empty.

I found it helpful to use this simple formula to generate hallway lengths with a mean and standard deviation constraint. Both the x and y would work fine, here we’re using the y only.

Textures make a difference

Wed, 22 Mar 2017 00:00:00 +0000

I’ve been playing around with textures in exploring the bleak to see how much of a difference it would make. Essentially I’m torn between two ideas:

Make the floors all a plain color and glow them based on the environment color so as not to be too realistic and keep a more roguelike feel.
Struggle with having textures that blend together between sectors so it has a more natural feel albeit simple in perspective to traditional 3d games.

At the moment I’m leaning towards number two, but I haven’t been able to reproduce a reliable glow postprocessing effect that I actually like and that feels natural. I’ll follow down both roads further before making a discrete decision.

No FPS is a Roguelike

Fri, 10 Mar 2017 00:00:00 +0000

I’ve struggled with the concept of merging the roguelike turn-based system with a FPS. Having a turn based on when you fully leave a cell makes the monsters seem jumpy which doesn’t make for very nice gameplay. Because I believe turn-based systems are core to roguelikes and first person shooters can’t be turned based in a cohesive way, I’ve dropped the FPS perspective altogether and pulled the camera above the player.

Building A Modern Roguelike in 2017

Wed, 08 Mar 2017 00:00:00 +0000

Building games has become easier to do with the increase in quality of tooling and specialization software. The unfortunate side effect is the developer has to become more trained and specialized in a variety of facets in order to maintain competency in the field. Ergo building games is also harder.

This year for the 7DRL competition I’ve been pretty lazy, which doesn’t help much to making deadlines. Setting aside playing games for making games I decided to finally venture into the competition whole heartedly.

Pigeon Hole Stepping

Tue, 08 Mar 2016 00:00:00 +0000

For 7DRL this year I developed a new map generation algorithm called Pigeon Hole Stepping.

Fill the map with walls

This map generation algorithm relies on negative building techniques. This concept will make more sense as the later steps are explained.

Dig Hallways

Essentially, we can assume that hallways that are parallel to each other are at least the length of a single room and up to two rooms apart in distance. Because of this assumption, we can make a random walker that will move around with this restriction in mind until map is filled completely.

Automata Generated Caverns

Fri, 13 Nov 2015 00:00:00 +0000

Randomly generated dungeons are a lot of fun to program, but sometimes they can be pretty difficult to originally wrap your head around. For this years 7DRL I added Automata Generated Caverns as one of the algorithms I wanted to figure out completely. You can read more specifically on the theory here.