Robotime

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.

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

$ 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 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/")

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.

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.

The grid is a 20x40 isometric grid

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.

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.

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:

• Knights, monsters, stairs & more, by artisticdude, licensed as GPLv3
• Towers of defense, by bart, public domain
• FreeCiv FT Tileset: terrain2, licensed as GPLv2
• The bonus sphere was made with inkscape with this post.