lzzrhx

C# roguelike, devlog 11: Additional map generation algorithms

2025-03-21T00:00:00+01:00

In addition to the previously implemented noise, there are several algorithms that are quite useful to have at hand when working with procedural generation. A number of these, and some sample use cases are described in the fantastic Roguelike Celebration 2020 presentation Procedural Map Generation Techniques by Herbert Wolverson. Some of these algorithms, like BSP, Perlin noise and Dijkstra maps are already implemented in the project. In this post I’ll focus on adding algorithms for Cellular automata, Diffusion-limited aggregation (DLA), Drunkard’s Walk and 2D Voronoi diagrams.

C# roguelike, devlog 10: Improved Perlin noise

2025-03-20T00:00:00+01:00

A more or less essential component needed for procedural generation is a good noise algorithm. In order to start working on terrain generation I’ll first add this to the project. I’ve opted for the Improved Perlin Noise algorithm. But another good alternative that is ready and available for C# is OpenSimplex2

C# roguelike, devlog 9: Pseudorandom number generation (LFSR)

2025-03-19T00:00:00+01:00

So far I’ve used the built-in Random class for generation of random numbers and booleans. However, at this stage in the project, before moving on to procedural landscape generation, it might be a good time to write a random number generator. This will allow for finer control of the procedural process, from start to finish, and the use of custom seeds will ensure deterministic results in the generation of terrain. Additionally the creation of a simple number generator could prove an interesting and fun excercise.

C# roguelike, devlog 8: Mesh generation and cube to sphere projection

2024-06-10T00:00:00+02:00

Moving forward I would like to try to procedurally generate planets.

I am going for the approach of generating a cube and projecting the cube as a sphere.

C# roguelike, devlog 7: Raylib and ImGui

2024-06-09T00:00:00+02:00

It’s time to bring the project into the third dimension by using the raylib library.

Raylib is written in C, but has bindings for a whole bunch of programming languages. The bindings for C# is Raylib-cs. For documentation on how to use the library we can check the C# usage examples, the Raylib Cheatsheet and the Raymath Cheatsheet.

In addition to raylib I’ll add Dear ImGui and use it first and foremost for debugging but perhaps also to build some tools later on. ImGui.NET is the C# wrapper for ImGui and to get ImGui to use raylib for rendering I’ll also add the rlImGui-cs library.

C# roguelike, devlog 6: Shadowcasting

2024-06-08T00:00:00+02:00

Next up is adding a field-of-view algorithm. Here I thought I would try to implement the Symmetric Shadowcasting algorithm by Albert Ford. He explains Symmetric Shadowcasting very well in the video presentation Vision Visualized.

Another approach to shadowcasting can be found in the blog post What the Hero Sees: Field-of-View for Roguelikes by Bob Nystrom

For further reading on field-of-view algorithms check out the post (as referenced by Albert Ford) Roguelike Vision Algorithms by Adam Milazzo.

C# roguelike, devlog 5: Dijkstra maps

2024-06-07T00:00:00+02:00

I thought I’d expand on the existing pathfinding algorithms in the PathGraph class by implementing a function that returns what Brian Walker calls a Dijkstra Map.

In the Roguebasin article The Incredible Power of Dijkstra Maps he explains a number of use cases for such a map, and example visualizations can be seen in the other article Dijkstra Maps Visualized by Derrick S Creamer.

C# roguelike, devlog 4: Corridors

2024-06-06T00:00:00+02:00

Now that some pathfinding algorithms are in place it’s time to move on to the next step, making corridors between the rooms.

C# roguelike, devlog 3: Pathfinding algorithms (Breadth-first search and A*)

2024-06-05T00:00:00+02:00

Pathfinding is a crucial component in almost any video game, and will be used in the next step of the dungeon generation to check if two given rooms are already connected when making corridors.

There are two types of pathfinding I will implement at this stage, the first one is breadth-first search (BFS), and the second is A*.

C# roguelike, devlog 2: Binary space partitioning trees

2024-06-04T00:00:00+02:00

I thought I’d start the project with creating a simple fixed size map and rendering it in the console.

The map generation technique I thought I’d try implementing involves using binary space partitioning to place rooms in a given space.

The technique is explained in the video presentation Procedural Map Generation Techniques by Herbert Wolverson. And in the roguebasin article Basic BSP Dungeon generation.

How a binary tree should function is quite well explained by Richard Fleming Jr in the videos Binary Trees and Tree Logic.

C# roguelike, devlog 1: About roguelikes

2024-06-03T00:00:00+02:00

Rogue’s storyline was very light: the point of the game was to go down all levels of a dungeon, in a world based on Dungeons & Dragons, starting from the top, killing monsters and plundering treasures, until finding the Amulet of Yendor. Then, the player had to climb every level up.

…

Contrary to many other computer RPGs of the time, all levels were randomly generated. Rogue was intended to be played on Unix terminals. Thus, the dungeon was displayed in text mode, characters and monsters being represented by letters. Actions were issued by single keystrokes. Rogue defined the very Roguelike genre. Random generation, basic plot, text (or tiled) based display still are the usual features of Roguelikes.

From the description of Rogue (1980) on roguebasin.com