A recap of my 12 7DRLs and some tips

The 12th annual 7DRL Challenge has begun: with 240+ entries so far it shows again that roguelikes are more alive now than ever… who would have thought an exercise on development habits suggested by Jeff Lait would turn into such an important event for the genre?

There were fifteen challengers in total on 2005, the year of the first challenge, and I’ve participated on the challenge every year. Only Jeff Lait has done the same, although I participated on an additional challenge on October 2006 (his entries are much more remarkable than mine tho).

I haven’t been able to start mine for this year. As usual it comes in the busiest time of the year, but I hope to make it thru again.

Before that however, since I’m on an airport waiting for a flight and this is not my dev battlestation (and really, I don’t want to go through setting up a dev env for Android Wear for just a day of development), I thought I’d recap all of my 12 7DRLs, while at the same time giving hopefully useful tips to whoever is participating this year or in the future. Note that some of these tips may seem contradictory and conflicting: that’s completely intended.

Before the Age of 7DRL

I learned programming by developing my space shooter, Archer Fire, in QBasic. Afterwards, when I got to college I learned OO and Java, and I also found out about roguelikes. Almost immediately I wanted to create my own… thus began the Guardian Angel project.

I wanted to simulate a full fantasy world, where you could do anything from farming to dungeon hacking. I worked on it for about 2 years, and I didn’t manage to produce a working game.

First Age of 7DRL: The Java xRLs

And then came the 7DRL Challenge; we challenged each other on rec.games.roguelike.development (usenet) to create working games instead of keeping developing awesome big scale projects which never saw the light of the day.

Every year I would look forward to adapt some mechanics, a setting, or a game universe, into the roguelike format. I used Java, because that’s what I learned to program in.

Java was probably not a good choice… besides the lack of libraries for game development which forced me to do things like I/O myself using Swing and JCurses, as well as building the game engine from scratch (following wrong design patterns), there was also the issue of players being actually able to play the game. Since the Java Runtime Environment was required, and it was not completely widespread in 2005, it was not easy to obtain feedback for the games.

In this first age of 7DRL I stuck to a common evolving codebase through 8 years. It would become libjcsi (a somewhat useful library to simulate terminal I/O on Java using JCurses and Swing) and the SERF Engine (an undocumented roguelike engine with a flawed design that didn’t allow for even the simplest animations… but it worked!)

Tip: Use an existing framework for I/O, or even a game engine if you can find one which is flexible enough

1. CastlevaniaRL (2005)

cvrl

I entered the 7DRL with a lot of dreams on making something awesome. As a result I produced the first version of CastlevaniaRL which was… not that great. I was not able to work a lot on it… I managed to wrap up something playable in the end but it was neither stable, nor balanced nor fun.

The end result was what I would later call the “arena” mode, basically you had to survive wave after wave of monsters in the courtyard of Dracula’s castle, using a Vampire Killer character with a whip. There were no experience levels so you basically tried to keep your health by collecting things dropped by the enemies or the limited supply of candles. However I managed to implement my vision for the classic Castlevania powerups (dagger, axe, cross, holy water, stopwatch) which was a good advancement.

It didn’t look very nice either, as it was my first stab at trying to emulate terminal output in Java using Swing.

The end result was thus a bit “arcadeish”, since there was no character development… but it was turn based so there was a bit of tactics and strategy involved.

Tip: Simplifying things from the classic roguelike formula (Rogue, Angband, Nethack, Adom) can sometimes help you focus on a single fun feature.

2. Escape from Mt. Drash RL (2006)

drash

I initially planned to make a game about an Ant colony where you would be a soldier ant and you had to defend the ant mount from invaders; I did some research about different species of ants and how they lived. I didn’t had enough time to work on it though, and on the final day I changed everything to be themed around Ultima: Escape from Mt. Drash.

This was a much better entry than CastlevaniaRL, I reutilized its code so I had more grounds to start. The game had randomly generated cavern-like levels (because it was meant to be an ant mound first) that worked pretty well. It was a survival game where you had to find the exit to the next level, just like a classic roguelike.

For the first time I was using some kind of abstraction that allowed the game to be played on a real terminal via JCurses (and the old terminal emulation using Swing). That would later become libjcsi.

Beginning with this game I established some design guidelines, like not having experience levels (since I hate grinding for xp in games). Instead you gained skills every time you completed a level (a mechanic I reutilized in a lot of other games)

New stuff: Cavern Generation using Cellular Automata, JCurses, Powerups on level end

Tip: Have a clear goal, but also be flexible if you want to produce a complete game. Be ready to switch plans.

3. MetroidRL (2006)

metroid

This one was made for the so-called Orange October Minigun 7DRL Challenge, which ended up being one of a kind (since that, we have only made one 7DRL per year)

I again reutilized the code from DrashRL. I think this was the first 7DRL which included midi music (on its 7drl release). The random level generation was also much more complex on this one, as it was meant to be a free roaming open world similar to Metroid, so there was a base divided in 4 sectors themed with Nuclear, Biological, Chemical and Genetical weaponry. The game first generated a high level tree structure of rooms including obstacles and powerups, and then placed them so that the player was able to find the powerups required to go through the obstacles.

It also featured some kind of pseudo 3d (you could see a side view in both axis in addition to the overhead top view), where you could jump (and you actually had to jump in order to overcome obstacles).

New stuff: An higher level of procedural generation to locate artifacts and obstacles and thus make the player explore the levels back and forth. Background music, Open world, Pseudo 3d

Tip: Procedural Generation is one of the tenets of roguelikes, experiment with it to bring new stuff into the world of roguelike development.

4. ZeldaRL (2007)

zelda

The dungeon layouts were room based, similar to the Zelda 1 dungeons, incorporating a variation of the obstacle/power up algorithm from MetroidRL.

There were no skills nor experience points, you increased your max hearts (life) by completing the dungeons, and all abilities were item based.

There was also an overworld map generation which was based on cellular automata; it created different areas on the world themed for the different dungeons (forest, lake, plains, mountains, etc)

All in all, it was a pretty complete entry, although not super fun to play.

New Stuff: Overworld generation using Cellular Automata

Tip: Including elements from an already established universe will help you attract players and make it easier to hook them with already known concepts.

5. MegamanRL (2008)

megaman

This was my stab at a sidescrolling, turn based roguelike. Levels where randomly generated by defining a high level structure for the level with the room types to be placed and the connections between them, and then pasting premade segments together. I only managed to implement 3 robot masters and their stages on the 7DRL version.

There was a simple physics simulation as well as time stoping so you could for example jump and then fire an energy bullet, it would stay in the air until you did you next action or continued firing. This meant you had to plan your attacks to hit moving enemies.

I don’t remember if you got powers from the robot masters you defeated, you probably did. The end result was pretty hard to find out what was happening in the screen, with enemies and bullets around. However once

New Stuff: Sidescrolling turn based, hybrid level generation with premade templates over a generated layout.

Tip: Don’t be afraid to experiment with new stuff (both gameplay mechanics and tech), even if you fail you will probably learn a lot.

6. Expedition (2009)

expedition

This one was meant to be a mix of “The Seven Cities of Gold” and “Pirates!” in a roguelike setting; it didn’t have procedural generation but instead I managed to have a pretty high resolution map of America and the Atlantic Ocean.

Instead of a player character you assembled an expedition in Spain, made up of different kinds of units. You could fight wild savage american natives, with the units representing both your “health” (if all your units were killed you died) and your attack power (in the simulated battles, how many units died depended on the sum of the attack power of all your units).

In the 7DRL version your interaction with the wild, savage, mindless american natives was minimal, so you could only fight and fetch their gold for the crown. You could found settlements in the new world and the goal of the game, if I remember correctly, was to make 7 or so settlements to gain the rank of Viceroy of the New World.

I initially planned to use an overworld map generator for this one, but in the end never managed to do it. Still, loading the huge world map was a challenge on itself, I ended up devising a way to load 9 smaller chunks of the map at a time.

New Stuff: Player as a set of units, sailing simulation, loading huge maps into memory using chunks.

Tip: Watch out for overwhelming scope! no matter if you think you are a superb programmer, there’s a limit to what you can do in 7 days… again, be incremental!

7. Ruler (2010)

ruler

Inspired by Civilization, and in some ways continuing the design of Expedition, in RULER you also commanded group of units, but instead of them acting as an aggregation in combat, it was more similar to the battle model of Civ3, where you had a group of units led by a commander and which worked as a “stack” of units in which you fought using the topmost unit.

You could also create settlements, link them together with roads and trade goods between them, as well as influence them to research a given technology and raise new different kind of units.

The game was a bit unbalanced since you could very quickly get into the modern age with super powerful units, and enemy AI was pretty poor.

New stuff: Trading simulation, tech trees.

Tip: Devote enough time to playtest your game and make it a bit less unbalanced, try to have some friends or enemies help you with this task.

8. Elite International Detective (2011)

elite

Inspired by the classic game “Where in the World is Carmen Sandiego”,  you are a detective who has to fly around the world tracking down criminals. Basically you get a mission with a limited time to fulfill, you fly from the headquarters in Medellin, Colombia, to the place where the crime took place and then walk around the city looking for clues.

While roaming the city you may meet with bad, evil agents who will try to gun you down. (I tried to theme it around 1930-1940’s detectives). Instead of hit points you had “Luck”, which represented how likely you were to be missed by the enemy bullets (you could only take 2 or 3 bullet hits). There was also “running”, which spent your stamina.

The random generator created a simple city layout with buildings and roads, using simple rectangular recursive space subdivision. It then placed clues in a building far from the player’s starting location. Once you found a clue you’d get back to the airport where you have to pick a location to travel to. Picking the wrong one would make you spend valuable time, and the game gives you a bit of information of the place you are traveling to (educational, yay!). In the end you’d have to confront the criminal (and kill him, most of the times).

In the end I managed to implement the full gameplay cycle, however I failed being able to add more content (although I got help from a friend, time was just not enough). Also, the SERF engine was unable to handle even the simplest of animations, so for example machine gun fire looked pretty crappy.

New stuff: Educational content, subdivision city layout generator

Tip: Plan enough time to add quality content to your game, else all your hard work on the engine won’t be reflected on a good user experience.

9. Hope (2012)

hope

Themed in a post apocalyptic world, you are a bike riding guy who woke up and doesn’t remember the password to get back into the safety of an underground shelter.

You have to survive the deserted wasteland fighting punks and mutants, while finding food, water, fuel for your bike and ammo for your guns… but then the interesting part comes: You must look for the password inside your dreams…

So, when night comes or you are too tired, you’ll fall asleep (hopefully in a safe place) and then land into several different kind of videogame themed dreams, you have to get from one dream into another and if you survive (and are not awaken by a real-life enemy) you’ll find part of the password. There are several videogame dreams you could land into, including Pokemon, Contra, Megaman, Super Mario, Final Fight, even Aquaria, all of them incorporating a simple set of roguelike rules.

The concept I think was pretty good, and there was a working gameplay cycle, but the execution failed because of several factors: for the first time I tried to release a graphics version of a 7DRL, and since I’m not an artist I got help from some guys who worked in the company I had recently incorporated. The title screen was pretty nice, but they were not skilled on pixel art so the in-game graphics didn’t end up so well (I shouldn’t have tried to do pixel art.)

Also, the SERF engine which had advanced quite a lot since I invested a lot of development efforts on the post-7DRL version of Expedition, still didn’t allow for animations and the presentation I went for used non-square rectangular tiles which I thought was good because it allowed to use all of the screen space while still providing the same number of tiles horizontally and vertically, but in practical usage was a bit confusing.

And then, of course, the “dream” worlds… it was hard enough to get an xRL done right, but then I tried to do a lot of them at the time… implementing unique mechanics for each one and making them fun was far beyond the 7DRL timeframe.

In the end, I think it was a good idea, poorly executed.

New stuff: “Narrow” level generation to simulate semi top down (similar to beat’em ups like Final Fight and Double Dragon). Survival mechanics

Tip: Do one thing well, build incrementally.

Tip: If you are going for graphics, pick an art style matching your team skills.

Second Age of 7DRL: The accessible games

Then I decided I didn’t really want to continue down the same path… I wanted to learn something new, and make games which were more accessible to people and actually fun to play.

In this second age, I am no longer going for exotic themes or adaptations, or half-baked novel gameplay mechanics which are not fun in the long term. Instead, I’d take the basic roguelike formula, and try to make games which were easy to play and enjoyable.

10. Rodney (2013)

rodney

My first JavaScript game, Rodney could be played completely on a browser, you didn’t need to download anything (explicitly)!

For the 7DRL version I got back to terminal display after the graphics failure with Hope. I used a pretty cool JavaScript library which allowed cool things like color animations simulating torches, while still on terminal mode. It also included FOV algorithms.

Rodney was a basic dungeon crawler with a rooms + corridors generator, with no experience points (I hate xp grinding), instead every time you got to a new level you could pick a new skill or upgrade your stats. All of the skills where active and implicit, which means you could execute them just by moving around (there was no actions or spells menu). For example you could use the Corner skill by attacking an enemy who was standing next to a wall. Most of the skills were derived from DrashRL.

Also, Rodney used the directional keys plus a single action button for all the interactions of the player with the dungeon. This was a basic design criteria I had from the start

I also implemented a simple online feature which allowed players to chat with each other, and bump with others in an overworld level. It had some rough edges but worked overall.

I think Rodney was probably my first real success in the challenge. I managed to create a fully working game which was enjoyable and people keep playing nowadays.

Tip: A simple command set reduces the entry barrier for your potential players

11. Ananias (2014)

ananias

Another classic dungeon crawler, but instead of aiming for a single action button game I went for a game that could be played comfortably on smartphones and tablets.

At first, I planned it to be based around cooldown times – so you would explore the dungeon in semi real time. Moving from one room to another would take something like 3 minutes of real life time, so you would wait and then play again once the time had elapsed (I’ve been tinkering around with similar mechanics since 2008 with Pixal).

Then I found out it would be too tedious to play that way, but that initial design idea left something more useful… the rooms! I eliminated the corridors as gameplay spaces, and this allowed things like being able to move quickly between the rooms just by tapping on the doors. Fine grid movement was only needed while on combat. It may seem like a small thing, but I think it made dungeon exploration much more comfortable on touch devices!

Another breaking event for Ananias was that for the first time I was building over a framework instead of doing things from scratch. I learned about phaser.io and began experimenting with it (I created a flappy bird clone). What this meant was something that had eluded me for years: animations (both sprite based and tweens). I had been developing games for years, but I had never done even simple 2d graphic effects. (In fact, trying to add them to the post-7DRL Expedition was one of the reasons of it’s (temporary?) failure).

The results were pretty good! although somewhat buggy, the game was playable and provided at least something novel to the genre (I think).

Tip: Create an user experience taking the most advantage of your target platform

12. Stygian Abyss (2015)

stygian

I teamed up with Jucarave for this one… he did most of the actual gameplay work, since I focused on the map generation. It was the first real time “roguelike” I worked on, so it’s a bit less of roguelike, more of Dungeon Crawler. It was themed around the ancient dungeon from the Ultima series, and included content based on it such as weapons, monsters and spells.

We failed to get an artist on board, so we struggled a lot to use the graphics from the original series (which of course were not intended for first person view….).

The dungeon generator I made worked on three different levels, first defining what features the level should have based on a 1 to 8 depth (using the levels from Ultima IV as reference), then splitting the square levels into different connected sections and then rendering each section and blending them together. I think it came along pretty nice, except the levels ended up being super huge for a roguelike (they may have been ok for a more classic cRPG, since they were sized taking Ultima Underworld as a reference).

The game itself was pretty straightforward, you had to time your attacks and dodge the enemy projectiles, while trying not to get lost and finding the ladders to the next level on the huge maps. You could walk around, swim, use ranged attack and we even managed to implement some spells.

I think this entry was a mixed success. It was complete and fairly stable (as long as you used the correct browser), but getting through the level was a great exercise on patience. So far I don’t know if anyone has been able to go thru all 8 levels!

Tip: Team up with another developer, set up the project so that you can work in separate modules without bumping on each other.

Tip: It may sound obvious but if you are going for graphics and you can get an artist that will help a lot! You may think there are a lot of freely available graphics online, but

13. Legend of Relojiah (?) (2016)

And now, I’m planning to make a simple and fun roguelike for Android Wear smartwatches… I hope to also make it available for Android phones since these devices are not very widespread yet.

Tip: Try to use a new technology in your project

That’s the story so far, I hope you enjoyed it and found it useful!

3 thoughts on “A recap of my 12 7DRLs and some tips

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s