Fighting the urge to use fantasy tropes

I have been working on an update of my 7DRL from earlier this year, Dungeon Dual. Since it is a web game, I can tell it was decently popular — certainly by my (very low) bar it is the most popular 7DRL I have put out there.

As a 7DRL it had some rough edges. But the core mechanic of the “asynchronous co-op” was there. Since then I have been polishing up the actual gameplay, UI, fixing bugs, making cooler animations, refactoring messy code, and all of that fun stuff.

The problem is in the back of my head I am also designing another game. My 7DRL from a few years ago, RoboCaptain, was also decently popular, and I have had various versions “in development” since then.

So, my plan was “hey I will just freshen up Dungeon Dual, and then put it out there” then take whatever improvements I had made to my CoffeeScript/rot.js engine and apply them to RoboCaptain.

The problem I am encountering is that designing a “classic” dungeon-diver is so addicting. The more I work on it, the less I am fixing bugs and the more I am adding entirely new mechanics to the game. Why? I think it is because fantasy tropes give us (as designers) so much to fall back on. There is so much “lore” built into all of our heads that is easy to leverage. Even something so simple as “would you like this dagger or this axe” is actually leveraging a collective intelligence/memory/lore that exists within your players.

This sort of lore is also influenced by the fact that so many great roguelikes are in fact classic “dungeons & monsters” sorts of games. You go too far down the path and you find yourself developing brogue, or ToME, or DCSS, or <pick your favorite game>.

I feel comfortable saying that a dungeon game would probably be more popular than an “indeterminate future” game with “robots and stuff”. At least initially. People on r/roguelikes will say that a great roguelike will win out, regardless. But I’m not so sure. I know my own experiences… not having a common “future robots & stuff” lore to leverage always makes me skeptical to start out with. The first time I have to choose between “laser pistol” and “plasma pistol” my brain starts to melt down.

The few existing great non-fantasy roguelikes such as DoomRL get around this problem by using existing canons. Everyone knows that Imps throw fireballs and that Cacodemons are very tough for early-game players.

So my question is: do other developers feel similarly? Is designing a fantasy dungeon simply “too fun”? How do you get players to get over the initial lack of “lore” and stick it out through the first couple ten-or-twenty plays of your game? Are there other future/sci-fi games that do this well?

Here’s some more images for the curious. Cheers!

Roguelike Animations using Javascript and ROT.js

I am using javascript (CoffeeScript, actually) and the excellent ROT.js library to build the next version of RoboCaptain. ROT.js is great; it makes easy stuff really easy and hard stuff much more straightforward. It allows you to break away from messing around finely tuning your Field Of View algorithm or your AStar pathfinding routines and spend time building actual game content.

I am something of a roguelike traditionalist (you can find me calling out non-roguelikes in a hopefully non-obnoxious manner on reddit) but while I do love my ASCII, I also think looking nice is important. Once I started building ranged weapons into my game I realized: I need animation.

In most programming languages, animation is straightforward. Start an animation, wait, continue where you left off. In javascript, this is less straight forward, because javascript is a single-threaded non-blocking language. The appropriate way to do delays in javascript is to use setTimeout. However, if your code looks like this:

player.shoot(monster, weapon)
game.drawAnimation(player, weapon)
if monster.is_dead() then

Then your game will not work like you think it will. As your drawAnimation function starts firing off setTimeout events and drawing (for example) the path of the shot across the screen with 20ms delays, the javascript machine continues chugging along. This means while your player is watching their bullets fly across the screen, javascript has already moved on and is now calling your damage() and potentially kill() functions. Even worse, depending on how you write your code, it will keep going and eventually start moving other monsters, potentially even the one that just got shot.

Despite the cries of anguish from javascript purists, my first idea was to implement a delay() function, forcing javascript to wait until my animation drawing was done before continuing. Javascript purists hate this because you will be blocking the entire browser (or tab?) while this is happening. I figured when programming a game, this was OK, because it’s not like anything else is happening on the page other than the game.

Unfortunately if you use this method ROT.js will not ever get a chance to run it’s display handling code, and your canvas will not update until after your terrible delays are over.

Using setTimeout is a pain in the ass. It makes coding very messy because you have to use callbacks, something like this:

player.shoot(monster, weapon)
game.drawAnimation(player, weapon, function () {
    if monster.is_dead() then


Using this method I was still running into asynchronous event issues, and gods help you if you want to nest your animations (like a shooting rocket causing an explosion).

After a lot of messing about, I came up with a relatively elegant solution. It might be obvious to some, but no amount of googling on my part led me to anything similar.

You have to treat your animations as game actors. They need to have turns just like the player and monsters. They use the same drawing routines, screen updating routines, etc.

Now my game loop looks something like this (in CoffeeScript, but you should get the idea):

endPlayerTurn: () ->

nextTurn: () ->
    if @hasAnimations()
        first_animation = @animations[0]

    next_actor =

    if == “player”

    if next_actor.objtype == “monster”
        monster = next_actor

animationTurn: (animation) ->
    animation.runTurn(@, @ui, @my_level)
    if not


So, now my code is much more readable. Players and monsters take turns as per usual, using the ROT.js scheduler. Animations are independent actors that always take their turns first, if any are still alive. Within each animation there is a runTurn() method that calls the relevant game code: draw a rocket, draw a flash of light, move an expanding circle outwards, etc. The setTimeout is there but feels much less intrusive to me this way. 
The code exits out to the main ROT.js loop elegantly, and does not hold up any operation or freeze the browser. The last step is to just make sure the player can’t move or start a new turn until the animation is over (this last part is somewhat optional, in my experience roguelikes are not that fast-paced anyways).
The tricky thing is thinking of animations as game actors. The player may launch a rocket or a laser, but it will be the actual laser actor that calls the attack() or damage() functions. It is a little tricky to get used to, but I find it much more simple and easy to code than worrying about callbacks.
Your mileage may vary, but I wanted to put this out there so the next developer trying to solve this problem can save a few days of refactoring hell

RoboCaptain: That's levitation, Holmes

Jetpacks! Chasms to fly over! Also melee weapons with special attack patterns! Also flying enemies! Also ammo-based guns!

Melee weapons are a bit different from systems. They take up a coveted slot, but you can carry them around when they aren’t in use. When activated, the current weapons all have special attack patterns (ala brogue). The blade will pierce multiple enemies, the flail will damage all surrounding enemies, and the hammer will temporarily stun your target.

Coming soon: radiation, fire, exploding barrels, and upgrades. And recharging. And rockets. And…

PS – I will need beta (alpha?) testers at some point this month. Shoot me a comment or e-mail (twpage AT gmail) if you are curious and want to help.

RoboCaptain 2.0

Just wondering if anyone still actually has this blog in a dusty corner of their RSS reader?

I dusted off my old 2011 7DRL RoboCaptain a few months ago and have made steady progress. The new engine utilizes the wonderful rot.js and is fully re-coded in CoffeeScript.

It looks kind of like this:

For the first time today I actually spent time “playing” the game for more than testing purposes. There are already some interesting tactics arising from having to utilize different systems. There is a lot of work to be done on balancing this mechanic. I think the original 7DRL struck a chord with lots of people, but having to constantly switch between systems in order to recharge them seemed very fiddly to me by the end.

The current mechanic modifies the original one. You don’t have to worry (as much) about recharging your systems, but instead you need to pick which one is currently ACTIVE. 

Some systems function whether or not they are active, but being activated makes them better. Active lasers will have 2x change of critical hits. Active shields will recharge over time. Active melee weapons will perform special attacks like shoving enemies back or piercing through multiple enemies (thanks Brogue).

Other systems only function while active. The cloak is an obvious one. The promised jetpack also makes an appearance (jet-punch is a must-have feature). When activated, the Armor system makes your melee attacks do double damage and allows you to smash through walls — very satisfying.

I’m still working out how to balance the two different kinds of systems with things like melee weapons, limited ammunition weapons, and rockets. I think melee weapons will become systems. Since you are limited to 5 or 6 systems, this will become a strategic choice. I may also add ammo-based weapons that are designed to be disposable, but have special features when compared to the default laser. In theory you could even drop your lasers and do (for example) a melee/cloak-only build. Or even leave your shields behind and stack your robo-suit with 4 weapons systems.

Currently I decided that you can’t “carry” systems around to install later, so the strategic choices around which 5 (or 6) to keep installed is an important one.

Anyways, if you are still listening, drop me a line. I will need beta testers soon enough.



Adventures in UI Design

Traditional roguelike games are restricted in what they can display graphically. Restrictions are part of what make roguelikes great (this is definitely true for the original rogue), but graphics no longer have to be one of them. While troubleshooting the firing logic for robocaptain I found myself stuck in a “traditional” mode of thinking.

In the original 7DRL version of the game, firing took two steps: ‘f’ to confirm target, and ‘f’ again to fire. Alternatively, once ‘f’ was pressed the first time, the player could hit ‘g’ to cycle between targets. This is mostly fine, but can be improved. While I mostly play with the mouse, I want the keyboard controls to be just as good.

The thing that ‘unstuck’ me was realizing I wasn’t limited to conventional roguelike graphical restrictions. The restriction being ‘1 tile, 1 character’. Why not just add another indicator over top of the existing character?

I came up with a simple ‘targeting’ overlay that constantly tracks the closest (or last hit) enemy. This targeting overlay can be cycled at any time by hitting ‘g’. Hitting ‘f’ will automatically shoot at the currently targeted enemy.

This kind of ‘passive tracking’ saves the player an extra keystroke, since most of the time you are shooting the only/closest enemy. The rest of the time you can use ‘g’ to cycle between targets just as before. The game will remember the last enemy you shot at and always keep them as the default target.