Robotime

Robotime is a robots-like game made with Common Lisp It is made for the 2010 International Lisp Games Expo and for the Novendiales(fr) (the theme was "time control"). A screenshot is available here.

Table of Contents

1 Install and play

1.1 Dependencies

You need a correct Common Lisp implementation (look at SBCL for Unix-based systems and Clozure CL for Windows or OS X). Also, be sure to have ASDF installed (provided with SBCL, don't know for Clozure CL). There are only two libraries needed for robotime: Alexandria and Until It Dies.

1.1.1 Alexandria

You can easily install Alexandria with ASDF-Install:

(require :asdf)
(require :asdf-install)
(asdf-install:install 'alexandria)

1.1.2 Until It Dies

Since Until It Dies is a fairly new library, it's only available through the git repo at github, and robotime needs it's devel branch. Basically, here are the steps to install it (on an Unix-based system):

$ cd ~/.sbcl/site/
$ git clone -b devel http://github.com/sykopomp/until-it-dies.git
$ ln -s `pwd`/until-it-dies/*.asd ~/.sbcl/systems/

You'll also need to install UID's dependencies:

Of course you'll need to install devil, openal, the opengl libs, and ftgl.

If you encounter any problem with UID, you might try to use the commit 18c4895bc2bc0512a4425ab2ef23550b186ac175 (with git checkout).

1.2 Robotime

You can now install robotime:

$ hg clone http://hg.awesom.eu/robotime/
$ ln -s `pwd`/robotime/robotime.asd ~/.sbcl/systems/

And to launch it:

$ cd robotime
$ ./robotime.sh

If you get a CL-DEVIL:COULD-NOT-OPEN-FILE condition, you can adapt the variable *resources-dir* in graphic.lisp, eg. :

(defparameter *resources-dir* #p"/home/user/robotime/resources/")

1.2.1 Keybindings

ActionKey
Move northr
Move southv
Move westd
Move eastg
Move north-weste
Move north-eastt
Move south-westc
Move south-eastb
Forward the timef
Backward the timey
Use a blastspace
Quitescape

2 Gameplay

Robotime is a robots-like game. Robots is an old turn-based game (you can test the original one by installing bsdgames if you're under Linux) with a very simple principle:

Robots is played on a two-dimensional rectangular grid. The objective of the game is to escape from a number of robots, which have been programmed with only a single objective: to kill the player. – Wikipedia

Robotime has some differences with the original robots games:

2.1 Time control

You can control the time in both directions (forward and backward). If you go back in the time, robots will backtrack and you'll lose some power. If you advance the time, robots will move in your direction and you'll gain power. You can also gain power with some bonus. When you control the time you can't move, so be carefull not to be caught by robots. If you die, you'll simply be teleported somewhere else on the grid.

2.2 Bonus

There are two kinds of bonus in the game, which appears and disappears randomly if the player don't take them:

  • A power bonus which increase your power
  • A blast bonus which gives you one more blast. You can use a blast by pressing space, it'll blow some robots that are near you.

When you go back in the time, bonus may reappear if you didn't take them.

2.3 The grid

The grid is a 20x40 isometric grid

3 Conclusion

3.1 Lisp

Lisp is very usefull for rapid game prototyping. The game had to be done in nine days, but after 2 days it was already playable (with awful graphics). CLOS is very nice to use and provides usefull things (around methods etc.). Also, macros allows you to save a lot of lines of code. By example, here's how the power bonus is defined:

(new-bonus power "bonus.png"
  (add-power player 10))

And here's how it would be defined without the new-bonus macro:

(defvar *power-bonus-tile* (load-image "bonus.png"))
(defclass power-bonus (bonus) 
  ())
(defmethod draw ((bonus power-bonus))
  (when (alivep bonus)
    (draw-at (x bonus) (y bonus) *power-bonus-tile*)))
(defmethod collision ((player player) (bonus power-bonus))
  (when (alivep bonus)
    (add-power player 10)))
(push 'bonus *bonus*)
(incf *n-bonus*)

It might be ok for one or two bonus only, but with the new-bonus macro we can define easily a lot of new bonus, without repeating everytime the same code.

3.2 Libraries

Common Lisp has a lot of libraries, but when it comes to games related libraries, there are only two or three libraries. Or rather, there were two or three libraries, because those dto's ILGE has motived some people to work on games and games related libraries, and now there are much more good games libs and bindings (see here). Even if most of them are not officially released and still in developpement, they're quite usable, and if you encounter some bugs you can still contact the authors on #lisp or #lispgames.

3.3 Graphic Stuff

3b's entry made me discover OpenGameArt.org. Those kinds of site are usefull, but really lack of content. I know a bit of gimp, inkscape and blender, but I don't have the knowledge to create my own graphic stuff. I think graphics are what free games miss the most, and sites like OpenGameArt might help with that, but apparently they're not enough known from graphists.

The graphics I used are:

4 Contact

Any feedback, suggestions, bug reports, etc. is welcome at #lispgames (irc.freenode.org) or in french at #GCN (irc.langochat.org).

Author: Quentin Stievenart <acieroid@awesom.eu>

Date: 2010-07-21 14:16:48 CEST

HTML generated by org-mode 6.33x in emacs 23