On the downside, the role of the spirits were not clear to players at all - confusion from the quantity of messages, players constantly logging out to see what was going on from the public message timeline, and both the characters emotional state and connections between them and the permaculture plant layers were completely lost in the noise. Added to this, with the short duration of the study (1.5 hours) the pick power restriction was a massive problem, leaving players with nothing to do for long periods of time.

With more focus studies planned I've updated the game to deal with some of these issues as best I can:

Pick power is now recharged much faster. To balance this out, and add to the challenge of foraging for seeds and fruit they now regrow much slower and are harder to find in the world.

The way spirit messages are dealt with is now completely overhauled. All messages they send are viewable by all players all the time. They are displayed as speech bubbles by the spirits, making it clearer that they are responsible for them. They are now filtered out of players timeline messages to avoid problems with spamming too many messages.

There are also a bunch of updates to improve responsiveness of the world and make reactions to player's activity faster to experience. Plant no longer gain health from nearby plants which are ill, which means reactions to new plants happen faster. The season length is shorter again (10 minutes for a full year cycle). Some optimisation of the mongodb code dealing with message dispatching means I've been able to double the refresh rate of the game (number of world tiles updated per second) while also reducing overall server CPU usage.

The mongodb database the game now uses allows you to connect via a console and pull out some statistics using bits of JavaScript with a feature called mapReduce - an idea based on the lisp functions map and reduce (or fold in Scheme) and made popular by Google with it's search algorithm.

Each tile in the world contains a list of entities (each plants is an entity), so we can "map" over the tiles, creating a new list of plant counts. Then we "reduce" over the counts with another function to find the total. This approach allows the database to do the operations in parallel, and control the amount of memory required - which would be necessary if we had a fair few more players :)

db.tiles.mapReduce(
    // map fn 
    function() {
        emit("total",{count:this.entities.length});
    },
    // reduce fn
    function(key, values) {
        var result={count:0};
        values.forEach(function(v) {
            result.count+=v.count;
        });
        return result;
    },
    // tell it to spit out the result in the console
    {out: {inline:1}}
)

This more complex example tells us the distribution of players by how far they have got:

db.players.mapReduce(
    // map fn
    function() {
        if (this.layer==0) emit("ground cover",{count:1});
        if (this.layer==1) emit("shrub",{count:1});
        if (this.layer==2) emit("tree",{count:1});
        if (this.layer==3) emit("complete",{count:1});
    },
    // reduce fn
    function(key, values) {
        var result={count:0};
        values.forEach(function(v) {
            result.count+=v.count;
        });
        return result;},
    {out: {inline:1}}
)

The other big change is a new activity for when you are out of picking power which can give you more information about the other player's plants - the butterflies can be drag-dropped over plants to find out who planted them.

Having this kind of information available makes some open ended meta games possible, such as a group of players getting together to take over part of the world. The role of the spiders remains mysterious, but I'm trying to figure it out...

I've also noticed that players are not tending to send each other gifts, which is probably for many reasons - the most obvious being that they don't know it's possible. Part of a fix for this is to add some general help when players start - this seems a common practice with social games.

Firstly players now are grouped into different roles based on the permaculture layers represented in the game:

As players progress they get a chance to take on different roles as they can only pick fruit from plants from the layer they belong to. This means that even experienced players require the help of new players to provide nutrients for their plants.

Another big decision was to separate the "social elements" of the design from the things you need in order to progress through the game. Part of the idea is to remove situations like this:

I forget which game the screenshot was originally from (I think a city building facebook game), but it had absolutely no connection with the themes of the game. Relationships seem generally to be treated like resources in most of these games - the main motivation being to increase virality. I'd like to leave things a little more open to interpretation (partly so we can explore further possibilities a little more).

There are quite a few things classified as "social activity" in the game, but none of them are a direct requirement to progress, no meanings are "hardwired" with rewards or punishments - e.g. the meaning of passing different fruits to other players, or the ability to plant detrimental as well as beneficial plants. The idea is to create a situation where collaboration is important but not formulaic - the game provides a basic need for people to help each other, a couple of ways to do it and some ways for them to initially connect with each other - mainly though the plant spirits:

Players can now pass items of fruit to each other or spirits as gifts (by dragging fruit over messages and dropping them). There is some limited player development with some small surprises to prolong the gameplay a bit (spot the new plants). There is now a new mechanism to introduce players to the game and get feedback from them and also navigation to quickly locate plants - click on a message to teleport to the plant it concerns.

Still lots of rough edges, hopefully I will be able to smooth some of them out next week at the Mobile Life Centre in Stockholm. We have also now moved the game to it's own dedicated server, and completed the transition to mongodb.

The focus is adding a kind of "levelup" system for players to progress through the game in a longer term way than currently, along with some surprises. Also adding a way for players to send fruit they pick to other players as gifts, or to the plant spirits as a kind of "offering".

The other major change is updating the game to use MongoDB to store all it's data. I'm using congomongo as the Clojure wrapper, and it's been fairly simple to integrate with the existing game code as I can replace normal Clojure functions like reduce with versions that iterate over records in the database. These can also be written to load data and work on it in chunks, to keep the memory overhead fixed:

(defn db-reduce
  "run f on each item in the collection, return the result"
  [f ret coll]
  (loop [skip 0 ret ret]
    (let [limit 200 ; limit to loading 200 records at a time
          items (fetch coll :limit limit :skip skip)] ; do the fetch
      (if (not (empty? items)) ; are there any items?
        (recur (+ skip limit) ; do the next chunk
               (reduce f ret items)) ; reduce f over the items
        ret))))

The game's main mechanics are as follows:

Germination X is similar to other farming games except for the third factor - that plants may get ill if their ecosystem cannot provide them with what they need. The other thing that makes Germination X unique in the socal games space is of course the addition of the plant spirits.

Each spirit represents a group of plants - the more specific permaculture term is a "layer", as the groups represent the layers of a forest, from the root level (called rhizosphere) all the way up to the canopy trees.

Note: dandelions are more correctly part of the herbaceous layer, but we are taking artistic licence here, and lending it to the ground cover spirit for the moment.

In the FAtiMA rules for the game, the spirits have relationships defined for each of the plants in their group, and relationships defined between themselves. This allows us to use the way FAtiMA models emotions to get some nice results, for example if a player plants an apple tree the Tree Spirit may experience "Joy". However, the Ground Cover Spirit doesn't like the Tree Spirit as it's plants shade it's clover and dandelions too much - this action will cause it to express "Resentment". Such processes, so the theory goes, create more understandable and believable characters.

The main new stuff includes:

The process of moving around the world is now more continuous, as the land is split into sub-tiles that are loaded 9 at a time. When you move out of the central tile the 3 at the back are discarded while the 3 at the front are loading. Spirits can also "see" into the tiles surrounding their current one, and so can navigate the entire world slowly, but independently.

Spirit emotional colours - both in their character design and in their messages. I'll post more fully about this later.

The messaging system has been rewritten and now forms the major information source from the spirits. It's probably a little too much right now, and some thought is needed on effective ways to communicate some of these things. All the spirit's messages are triggered by actions driven by the FAtiMA agent. Here is an example of what happens when a "praise" action is received for an object:

(defn spirit-praise [spirit plant]
  (modify :log
          (fn [log]
            (log-add-msg
             log
             ; we can't exactly be sure why the fatima agent
             ; has triggered the praise action, but we can make
             ; an educated guess by looking at the plant

             ; if it's not the same type as the spirit
             (if (not (= (:name spirit)
                         (layer->spirit-name (:layer plant))))
               ; we're happy as it's providing a benefit to our plant
               (make-praise-msg 'spirit_helper_praise spirit plant)
               ; it's the same type
               (cond
                (= (:state plant) 'grow-a)
                ; we're happy because a new plant is growing
                (make-praise-msg 'spirit_growing_praise spirit plant)

                (= (:state plant) 'fruit-a)
                ; our plant is flowering (first phase of fruiting)
                (make-praise-msg 'spirit_flowering_praise spirit plant)

                (= (:state plant) 'fruit-c)
                ; our plant is fruiting (last phase)
                (make-praise-msg 'spirit_fruiting_praise spirit plant)

                ; i give up!
                :else (make-praise-msg 'spirit_general_praise spirit plant)))))
          spirit))

The Haxe client then reads the messages which consist of these codes and a host of other information (eg. the spirit's current emotional state and the players involved) and builds the text for display.

After a few iterations we have some ready to use in the game, the colours will be driven by their emotions (more on that later on). These are the ground cover (mulching), tree and shrub layer spirits:

Along with this, all the artwork in the game has been updated, taking Lina's latest versions and also increasing the resolution. I also had a chance to work on a new dandelion from Lina's uncoloured version, here are all of the different variations, with growth, autumn and illness stages.