dave griffiths

In Germination X plants can now send messages to the players that planted them - and these are stored individually for each player as well as globally so you can see what other people are up to. Plant spirits can also send you messages when they see something happening that interests them (such as a plant of their permaculture layer getting ill).

The messages are obviously more debug text than anything helpful at the moment - but they will be expanded.

We've been talking about making a kind of transition from the players thinking of the plants as being their property to the reverse situation. Playing with these messages might give us a way to make this possible.

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:

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.

(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 (pluto-node-entity-get node (pluto-message-from msg))))) (pluto-say-to-random ; make a new message node ; to a random entity entity (string-append ; build the message (choose (list (string-append name " just said: ") (string-append "I just heard " name " saying: "))) (pluto-message-txt msg))))) ; repeat the message node (pluto-node-old-messages node)) node))

First pass at getting plant/human messaging working based on the game design I was working on earlier in the month. The borders are built from the modular decoration drawings I posted yesterday.

More sketching, this time for use in the game rather than concept design:

I'm finding Clojure has a similar feel to C++ about it - it requires a higher degree of understanding of the underlying implementation than I think is probably optimal. Partly this could be because it's a new language - but it's also what makes it interesting.

A common problem I'm having is running out of Java stack due to lazy structures - this is a problem in a game or simulation loop such as Germination X, where if the values are not used by something they are never evaluated (which saves cycles) and hang around (using up memory).

Luckily Clojure comes with (doall) which forces the evaluation of a lazy sequence - however it's not recursive and *only* works on sequences. This function is recursive, and also calls itself on all the values contained in hash-maps:

; force all sequences and maps to un-lazy (defn doall-recur [s] (cond (map? s) (reduce (fn [r i] (merge {(first i) (doall-recur (second i))} r)) {} s) (seq? s) (doall (map doall-recur s)) :else s))

Last week I attended a Clip Kino event at Alto University's Media Factory. Clip Kino is a concept to use online video as a focus for events and talks via informal screenings. The ease of access of vast amounts of online video makes this a fast way to research ideas, and doing it in small groups means that a conversational approach quickly emerges - which worked well in this event, called Clip Camp:

Clip Camp is a format that merges open sharing events, such as BarCamp, with online video culture. The event is an experiment in methodology, creating a cross between a seminar room, a short video-clip festival and an offline discussion forum about online materials.

There is a good write up of the presentations on the media factory blog.

Before I can make full use of the characters in Germination X, I need to think about the game itself, the social aspects - and how this interacts with the theme of companion planting.

This could be a very rich area to play around with, but it needs to start as simple as possible. I'm lucky in that I can make a lot of use of the research we covered as part of the Naked on Pluto project, and as ever, I have to start with plenty of drawings.

The design is focused on three main priorities:

• Getting people working together (co-operative play).
• Do this in a world organised by companion planting.
• Integrate the world with the FAtiMA AI system, and make use of the notions of social awareness encoded within it

I'm also trying one well used casual game mechanic - a time based restriction, where some "energy" or "karma" is used up by actions (planting), and then slowly recharged. This is required in order to make cooperation necessary - people will be able to request help from other players who have more energy/karma and may choose to plant beneficial companion plants near to their ill plants. This could perhaps be rewarded by being given a larger reserve of planting energy if you do this.

I'm particularly interested in the interaction of these game mechanics, and finding some sort of minimum to achieve engagement. For example I'm quite against explicitly punishing "bad behavior" (in this case planting harmful plants near other player's plants) and seeing how this might be explored by players in practice.