Postmortem for Legend of the Rune Lords

Note: This a re-post from my old blog, originally posted June 2010
On June 11, 2010, I released my first indie game, Legend of the Rune Lords, on Xbox Live Indie Games. LotRL is a short role-playing game featuring many of the trappings of full RPGs: stat-driven combat, leveling, multiple characters, and a cutscene-driven story. While hardly a great game, I think that it stands as a good example of what a determined (or at least stubborn) individual can accomplish in their spare time even while crunching at their day job.
Continue reading

Virtual Spelunking: Decorating the Floor

With the basic shape generated and tile rendering logic in place, my procedurally-generated cave is ready to be navigated. Unfortunately, it’s still a little bland since all the wall and floor tiles look the same. Worse still, this means that the player would likely have trouble distinguishing between different areas of the map. What we need is a little bit of visual variety to help give each area of the cave a unique visual signature.

To accomplish this, I decided to start by adding more visual detail to the floor. Of course, I could just randomly pepper the ground with detail tiles, but this would a) look random and b) do nothing to help the player distinguish different areas of the floor from each other. So, I needed a way to create distinct regions of like details on my map. I found a method to do this in a rather sentimentally-named cellular automaton called “Togetherness”.
Continue reading

Virtual Spelunking: Tiles and Shadows

Last week, I used a combination of algorithms to procedurally generate caves and render them on screen as arrays of ‘#’s and ‘.’s. While text-based rendering is great for debugging and Rogue-likes, sometimes you need something a little more graphical. Rendering the floor and wall spaces created by the random map generator as tile sprites should do just the trick.

For my cave tile rendering implementation, I decided to use some of the best, free graphic resources available on the web: Danc’s Miraculously Flexible Game Prototyping Tiles. In addition to being attractive, this tileset is also very easy to use because each tile is a self-contained piece. With the exception of shadows (which I will cover later), tiles don’t affect each other visually so you don’t need to change which tile you draw based on its neighbors. Because you can treat each tile as a self-contained piece it’s very easy to map a tile to the floor and wall spaces created by the procedural cave generator and end up with something like this:
Continue reading

Virtual Spelunking: Procedural Cave Generation

It’s easy to understand the lure of algorithmically generating game maps, especially for a programmer. A game using this technique can generate a near-infinite set of unique maps allowing it to be played over-and-over again. Generating random maps is the bread-and-butter of certain game genres, Rogue-likes for example, that thrive on such variety and replay.

There is a wealth of information on the subject of procedurally generated maps on the web. Particularly on sites devoted to the aforementioned Rogue-like genre of game. By using techniques documented on one such site and mixing in some well-known algorithms, I managed to implement a random cave generator that I think I’ll be able to use in a game or two in the future. Continue reading

Creating a Simple In-Game Editor in UDK

Any video game has a number variables that can be tweaked to affect the game experience. Often, adjusting these values is a trial-and-error process of iterating until the game just feels right. It’s common practice to implement a way of doing such tweaking without having to restart the game to see changes take place: an in-game editor.

The UDK provides several utilities for editing objects and actors on-the-fly. You can use these utilities to quickly implement a tweaking interface to allow game designers on your team to easily adjust game parameters in realtime. Continue reading