December 30, 2004

The Ramble Chronicles: Background

As I indicated yesterday, I've been working on a simple computer game for my son David. As I progress, two things happen: the game gets more interesting, and the infrastructure I'm using to produce it gets cleaner and more powerful. I thought it might be interesting to some if I were to talk about the design of the game and also of the underlying software. Consequently, I'll be making a series of posts over the next few days, weeks, and months about the issues involved.

Ramble is what's called a tile-based game: the game world is made up of a rectangular grid of square tiles, each of which represents a bit of terrain, or whatever is sitting on top of it. As the player, you have a top down view on this tiled world.

In the earliest games of this type, the so-called Rogue-like games, the tiles were simply ASCII characters: "#" might be a wall, "." for a floor, and so on. Descendants of Rogue are still being played and developed; my favorite is called Angband, which has many variants. Here's a reasonably representative screen shot from a variant called Zangband:

The "@" represents the player. The apostrophes are open doors, the "+" characters are closed doors. The player's stats are displayed on the right. The brown "}" near the "@" represents some kind of missile weapon (a sling, in this case). If there were any monsters in sight, they'd be represented as colored letters. A "k" is a kobold of some kind, an "o" is an orc of some kind, a "d" is a dragon, and a "D" is an ancient dragon (better run...).

The Rogue-like games have a number of things in common:

The interface may be simple and character-based, but the underlying game model is anything but. Angband has hundreds if not thousands of distinct types of monster, each with its own specific behavior. Angband's combat system has been continuously refined, elaborated, redefined, tweaked, prodded, and complexified by generations of computer geeks since the early 1980's (though it was called "Moria" back then). There are generally many kinds of things to interact with, and many ways to interact with them.

The game world is randomly generated. Most computer role-playing games (RPGs) these days features complex hand-designed worlds. This makes them cool to play--once or twice. After that, you pretty much know what to expect. For computer game companies, that's not a problem; they'd just as soon you bought the next game anyway. But where computer game companies write games so other people can play them, computer geeks write games so they themselves can play them. And that's a lot more fun if the game world is different every time.

Combat takes place "in the world". The monsters walk around the same map you do. If you run away, they can follow. If you frighten them, they can run away. If they are asleep, you might be able to sneak past them.
By contrast, many other tile-based RPGs take you to a special combat screen when you encounter a monster or monsters (Nintendo's Pokemon series, for example). You don't see the monsters coming; instead, you're walking along, minding your own business, when *bam* you're in combat.

Gameplay is turn-based, rather than real-time.
Generally speaking, you move, then the monsters move, and so on. You can take as long between moves as you like, secure that the monsters aren't sneaking up on as you stand there.

You only know what you've seen. You can generally see the whole world (or, at least, the current level) all at once--but only those parts you've explored--and line of sight is very important. In many other games you can see everything that's within a certain distance, even if your character's view is blocked by a wall, but you can't look at things that are far away even if you've been there before.

I like the Rogue-like games; Angband and its variants are clearly the most important influence on Ramble.

There's another strain of tile-based game that I think of as the Ultima family. Ultima was one of the first graphical RPGs; it goes back to the Apple II days, though it also ran on the IBM PC. Ultima had a simpler game model, but it used iconic bitmaps as tiles instead of characters, and the world was carefully designed by hand.

There are things about the Ultima philosophy that I like. It's prettier than Angband and friends, and it's more than just a dungeon crawl--there are non-player characters to interact with, and quests to go on, and puzzles to solve. I'd like to use some of these ideas in Ramble as well.

Here's a list of my game design goals for Ramble:

  • Graphical tiles
  • Turn-based
  • Combat takes place "in the world", not on a combat screen.
  • A mixture of hand-designed and randomly-generated levels.
  • Hand-designed quests and non-player characters.
  • You'll note that this doesn't address all of the issues

You'll note that this doesn't address all of the issues listed above (e.g., visibility); that's because I haven't made my mind up yet.

I also have some personal goals:

  • Use Tcl/Tk as the development language (because it's convenient and easy).
  • Develop an infrastructure library general enough for use in a variety of tile-based games.
  • Write a game I'd like to play myself.
  • Have lots of fun.
  • Impress and entertain my kids.

More later.

Posted by Will Duquette at December 30, 2004 02:10 PM