I hate dungeon crawlers but here's how I ended up making one

mel: wanna make a dungeon crawler
me: no im bad at them
mel: yeah it might be hard to make
me: nvm. we're making one

So we're making a dungeon crawler lite. You might be thinking--that's such a petty reason to make a kind of videogame you should have something better than that. And we do.

Inspiration

I don't have much to say other than... they are suitably creepy. And there's plenty of examples that feel fitting for the aesthetics of our game.

So they kind of rule in both 1. aesthetics 2. slightly unsettling horror vibe. That's exactly what we're going for.

However, they also solve a longstanding problem I've been chewing on since we started working on the game.

The map problem

I've messed around with procedural map concepts in Substance Designer. They look a bit like this:

They're fun to look at, but they've presented a bit of a gameplay problem. How do you even traverse a landscape like this? I didn't have an answer, but I thought it'd be easy enough to cheat: The map movement and encounter loops would be entirely unrelated. If anything, the map was just aesthetic and players were just progressing forward in the event loop by moving literally anywhere.

However, this started to feel like a UX problem. What if this illusion of movement didn't hold or was frustrating?

The dungeon solution

For the longest time I'd thought we couldn't move from the above maps because--they're procedural. They're based on noise created from math. The image above is a result of a graph I made that "slices" out certain gray values from this cloud noise:

When I create maps all I'm doing is processing gray values between black and white... so the type of texture plugged in at the start can greatly change the character of the map.

Here's a cell noise:

Plugged into the start of the same Substance file it looks like this:

It's very bubbly compared to the rocky texture of the cloud noise.

However, Substance does have a bitmap import...

So what if we plugged in "dungeons" combined with the type of procedural noise we like?

To test this, I had Mel create a 32x32 1bit dungeon map.

It's a bit small, so let's scale it up.

When we scale it up we also apply some linear filtering (to soften it). Now we combine it with the cloud noise which ends up with results that look most like "underwater features."

Plugged into the graph I made, we get a result like this:

Now that's traversable, if slightly hard to read. It took a few tweaks to get it so that the paths themselves felt distinct. Mel looked at it. "What if we inverted it so the black spaces were the paths?"

So I shifted around the "slices" so that they're slicing the darker parts instead:

... And we have a map. A much more legible one.

If you're not familiar with Substance Designer, it's a tool to create procedural images. One of the advantages of it is being able to adjust the random seed and get a different look instantly. Some of the transitions between dungeon rooms were a bit hard to read, so we could randomize the noise seed creating the topographic texture a few times and get something easier to read. Here's how that looks in the Substance Player:

There's some fun unpredictability in authoring procedural maps--sometimes we get some neat surprises, but all of the maps will stay within the general art direction.

So... the hard part

Luckily: It's already been done.

After fixing a bug or two this dungeon crawler framework works super well! My first step was to replace the art to look more like Salvage. (Please god click to open in a new tab because the size down absolutely destroys it)

If you've been reading closely, you might have also noticed that the minimap shown looks like the dungeon map that Mel made. (Because it is.)

The other advantage of using a bitmap is that we can read the values using PIL or Python Imaging Library. It's a standard python library for working with images. This bit might be boring if you're just here for the cool screenshots but we can read in the black and white values as 0 or 1 and make it work with the dungeon crawler framework, which uses a list of strings to represent dungeons:

When we process maps we can instantly generate both the actual dungeon map as well as write the list of strings to make it work in a json file. We can also store data such as start location and direction as well as some other stuff that we'll leave as a surprise.

And now for another Completely Useless Tool But It Saves My Sanity At Least:

Why dithering images sucked (tl;dr im lazy)

Previously to dither images, I would upload them to DitherIt then pick some random dither settings that sounded good. Sometimes I'd forget to make the image black and white, or dither it at the wrong size (which you usually have to redo since dithering is a pixel perfect operation). When you download the image from DitherIt it will automatically save to the downloads folder and rename it.

This would be easy enough if not for having to move the dithered images to the source assets directory and rename them then drag them to the game directory every single time. And just for one type of dither. If I wanted to test out other ones I'd have to repeat the upload/settings/download every single time for possibly 6 different ones.

So to get around the boredom of uploading and downloading images I just downloaded someone else's dither script then run a script to run their script then show a UI so I could pick my favorite to keep which would then get moved/renamed.

And reader you would not believe how much more fun it is to dither public domain image 34758935 of weird underwater shit.

For example:

So this is our progress so far after months! There's not a lot to show because most of the development is writing which is spoilers and I've been stuck on these silly gameplay problems for months, but it's starting to feel like a direction that is hitting the look we want.