Procedural Generation is Not So Easy Part 791

I really like procedurally generating levels. As a programmer, if I can design a level by hand once, I’d much rather just take those rules that I used to design the level, put them in a program, and then I can generate a bunch of levels automatically!

Of course it isn’t so easy. Putting all my design rules into code turns out to be a lot of work! Here’s an example.

Part of making dungeon levels, particularly at high levels, involves adding secret doors. In this case, sometimes I will add a secret door hiding an exit from a level. Like this:

Secret door on the level exit

But wait, if you walk down the stairs to this level, you will immediately be faced with a blank wall! In fact, I’m not even sure that the party placement logic will properly handle placing the player characters in this situation; some might end up on one side of the wall, and others on the other side!

The fix is “easy”, of course; don’t create a secret door at the level exit. But just a reminder that the rules to create a dungeon are not as simple as you might imagine. Here’s the fixed version:

Level exit with no secret door

ACotGK Character Creation Video

Here is a video demonstrating character creation in ACotGK. The player starts up the game, and goes through the dialogs, choosing gender, race, class, etc. You may find it mildly interesting; I should have more interesting videos to follow.

From my perspective, this was an exercise in getting video capture, editing, and upload working. Many follies ensued, but I managed to get it all working. Hopefully I can do it faster next time.

The Accursed Crown of the Giant King is an old school role-playing game, single player, party based. It will be released in 2020 for Windows, Mac, and iOS. ACotGK is by Merry Prankster Games, and you can get more information at https://prankster.com/acotgk.

GitHub

Something like 10 years ago, when I started seriously working on the SENG code that is behind my Merry Prankster RPG games (still going!), I needed a source control system for the code. At the time, Subversion ( https://subversion.apache.org/ ) was the safe, standard open-source SCS. However, I wanted to try out the new distributed source control that was just coming into fashion. At the time, Git ( https://git-scm.com/ ) was the leading SCS, mainly because it was used for the Linux kernel, but Mercurial ( https://www.mercurial-scm.org/ ) was also popular, and reputed to have better Windows support, so I went with that.

For the past 10 years, I’ve been using SCS as a single-user, but with multiple instances, for example one on Windows for building Windows apps, and another on Mac for building iOS and MacOS apps. The benefits of SCS are source code history (which I can’t live without anymore), and easy sharing of code between those multiple instances. For backing up source code, I just zip up the whole source tree once a week and put it somewhere safe.

Recently, since cloud hosting of source code has become inexpensive (free) and reliable, I’ve wanted to move over to that. When I started looking into that, I realized that Mercurial has sunk to a very low percentage of the open-source SCS market, and Git has basically triumphed. So, I made the call to move over to Git, with GitHub ( https://github.com/ ).

I’ve just made the transition. I’m using GitHub Desktop as a UI, and haven’t had to go to the command line at all to use Git yet. Honestly, I am not really used to that yet, but I’m not going to use the command line (and create extra stuff to learn) for no good reason. Otherwise, I’m very happy with things thus far, and appreciate that I now have a cloud backup automatically for my source code. I do miss Mercurial a little bit, just from a nostalgia/plucky-underdog point of view.