Naked on Pluto wins VIDA

It’s been busy in Elastic Versailles lately, last week it was announced that Naked on Pluto won the VIDA award, and the game was selected to appear at a series of Robots and Avatars shows next year. The VIDA award concerns art and artificial life:

The projects may be based on systems which emulate, imitate or speculate on the notion of life through current research and technology. These systems may involve attributes of agency and autonomy which display specific behaviour, are dynamic, react to their surroundings and evolve, and which question the frontiers between what is alive and what is not, between synthetic and organic life.

The game attempts to minimise differences between bots and players, while the bots also form a dynamic whole, cleaning and bringing the game world back to it’s original state while players attempt to disrupt the system. The game world of Elastic Versailles is also connected with the very real world of human relationships – it’s this connection that makes otherwise very simple games engaging, and the main reason for the rise of “social games”. In our case we are attempting to use this powerful medium in order to question strong assumptions about privacy that have arisen due to the homogeneous culture these systems have sprung from.

It will be interesting to see how much this publicity will increase the player assault on Elastic Versailles – we’ve seen a rise in visitor numbers but the game is challenging and requires a lot of collaboration by players. At the time of writing, only a few brave users have broken through to the outer reaches – the final quests have yet to be beaten.

We now have the challenge of presenting Naked on Pluto at a larger scale in various exhibition settings. The spaces we will create will need to be linked with the live game world in multiple ways, we have some ideas sketched out but there is much work to be done.


manSEDANse 2011

I was honored with an invitation to present some thoughts on open source/free software at this year’s manSEDANse festival in Tampere. It was nice to talk about the connections between Germination X, Naked on Pluto and Betablocker DS with some quick live demos, and catch up on the developments of open hardware projects such as OHANDA from Tuomo Tammenpää and Cheap Fat and Open from Jacob Sikker Remin.

Visualising Elastic Versailles

Naked on Pluto is a text adventure game, it’s world is comprised of descriptions, populated by bits and pieces of text from your facebook profile while the space is largely left to your interpretation and imagination. There are some ways of visualising it though.

We have been archiving versions of the game world every hour for the last year in a git repo. In these files the only facebook profile information we have stored are names, which are considered public information in the agreement with facebook. We are interested in using this data to see how we built the game and potentially how people have been playing it (although one snapshot per hour isn’t really enough for that).

I started out experimenting with GraphViz and Gephi but I ended up switching to fluxus and adapting the exquisite code visualiser to read through thousands of dot files to make a dynamically changing graph. This animation shows the process from us building the world to the introduction of the first playtesters over the course of a few months:

Golden Medallions and in-game programming

Once the low level code for a Naked on Pluto bot is written in Scheme, it’s added by the game using secret commands which program the game inside itself, while it’s running. This means the game can be changed while people are playing it – which makes it much easier to add new things without worrying about the disruption caused by restarting the server. We can also work on the game collaboratively, at the same time this way.

(Programming a spybot with it’s behaviour)

Eventually the plan is to be able to program the bots fully within the game client – this is still a long term goal, but there are of course some fairly complex security problems with this idea.

(dressing a AudienceBot with another object)

Not all players have the ability to use these secret commands right now, in order to access them a player has to be carrying a special object (also known as a “Golden Medallion”). This allows you access to all areas of the game, including an “administration room” and various other secret powers.

Naked on Pluto goes to São Paulo

(Originally posted here)

Naked on Pluto has been selected for FILE festival São Paulo 2011 which, in addition to some funding from the Finnish Promotion Centre for Audiovisual Culture (AVEK) allows us to develop the game for an art gallery installation setting.

I’ve been reacquainting myself with bot programming, and trying some experimental and dangerous things with conversations.

As an example, here is a bot that simply repeats things it overhears – if you throw a couple of these in a room and start them going by saying something – chaos follows as they start to repeat you and then each other’s messages:

(define (talkative-action entity graph node)
  (if (and
       (< (random 5) 3) ; do this 3 out of 5 times
       (< (length (pluto-node-old-messages node)) 10)) ; safety valve
      (foldl                ; loop over all the messages
       (lambda (msg node)
         ; get the name of the sender
         (let ((name (entity-name 
                       node (pluto-message-from msg)))))
           (pluto-say-to-random ; make a new message 
            node                ; to a random entity
            (string-append ; build the message
               (string-append name " just said: ")
               (string-append "I just heard " name " saying: ")))
             (pluto-message-txt msg))))) ; repeat the message
       (pluto-node-old-messages node))

Reading/writing clojure

Revisiting my clojure frustrations, I was having problems getting things saved out to be recreated properly when loaded back in. This is something you take for granted perhaps, as a scheme programmer – but by restricting the set of containers I use, I’ve managed to get the right behavior from clojure.

user=> (def a (hash-map :number 43 :list () :string "hello"))
user=> (spit "test.txt" a)
user=> (slurp "test.txt")
"{:string \"hello\", :list (), :number 43}"
user=> (read-string (slurp "test.txt"))
{:string "hello", :list (), :number 43}
user=> (:number (read-string (slurp "test.txt")))

As originally suggested by Sam – if I save a hash-map, I get one back when I parse the text – same for lists or normal data. This isn’t the case for struct-maps or records which I tried before. I can also do versioning with hash-maps, where one of the fields is the version number, and structures can change without breaking file compatibility. When you load an old version, you can automatically detect this and convert it on the fly by adding default values for new data, or removing old stuff.

This is essential for production work, especially with an online game – as you need to keep file formats and data structures flexible while doing the upgrades in an quick automated way to match the code which is running.

Here is a section of the Naked on Pluto code (in scheme, but the process will be similar in clojure for Germination X) it gives you an idea of the kind of changes we made throughout the development process:

(let* ((f (open-input-file filename))
         (l (read f)) ; read the file
         (v (car l)) ; first item is the version
         (g (cadr l))) ; second item is the graph
    ; the version allows us to preprocess the graph to fix
    ; things which have changed. do this here.
    (let ((g (if (< v 1) (add-vocab-to-nodes g) g)))
      (let ((g (if (< v 2) (add-message-types g) g)))
        (let ((g (if (< v 3) (add-bot-timers g) g)))
          (let ((g (if (< v 4) (add-old-messages-to-nodes g) g)))
            (let ((g (if (< v 5) (remove-dir-from-edges g) g)))
              (let ((g (if (< v 6) (add-hatface g) g)))
                (let ((g (if (< v 7) (add-votes g) g)))
                    ; g is now up to date, whatever the version was we loaded

Naked on Pluto vs Mozilla

We had some trouble following a submission of Naked on Pluto to the Mozilla Game On competition. Aymeric describes the full story here, and it looks like a case of satire mistaken as the real thing, but it’s just a shame that we needed to go public with a blog post before we received any replies from Mozilla to our numerous emails.


I also wanted to write something about FaceBook as so far we have had zero problems with them over Naked on Pluto, a FaceBook game designed to confront the concept of online social networks.

This could be for two reasons, firstly FaceBook could be a place that welcomes strange and awkward software art and games even if they are a bit critical and have an odd sense of humour (although evidently they can’t be as confrontational as the web2.0 suicide machine).

The other, much more likely possibility is that with the sheer number of applications and games they haven’t even noticed we exist – which in itself makes the space, if not free, slightly “loose”.

Germination X – the next steps

Lina and I have begun work on the next iteration of Germination X which will be more playable than the demos we’ve been working on up till now. We are developing the look and building some of the underlying technology we need for the Pixelache event in March, lots more of this to come, but I’ve begun using the Lirec wiki to start to organise and document things.

The first part I’m looking at is getting characters drawn on paper into a multiplayer game instantly using various computer vision algorithms. This will be used in of one of our workshops at Pixelache, but we also want to prototype characters quickly and easily ourselves. Something which was lacking with the first groworld games, and I tried to address during Naked on Pluto was the effectiveness of making games shapeable by everyone involved in a project. Programming time and effort spent on this kind of accessibility seems to buy you a lot more time throughout a project even if it’s not actually seen or used by players in the end.