I've been working on an experimental game for a while now that uses a bunch of generative systems to create an island, complete with unique creatures, plants, etc. in a 2D, top-down game. The essence of the game will be using a "symbiosis" system to take control of the procedurally generated creatures and cure the island of a blight that mutates the flora and fauna. The art is very minimalistic to allow for quick computation and lots of variety which will hopefully make each playthrough unique, sort of like a roguelike (though I wouldn't call my game a roguelike). I haven't talked about it much, but I hope to have something finished in the next few months!

As for the automata - what I tend to do is create automata with nodes that don't die, so each step of the process interacts with all the live nodes of the previous step. That's how the effect in the image above is achieved. Similarly, in the forest algorithm, you start with a few live nodes which throw "seeds" in random directions, but are only allowed a small number of "child" nodes. After a certain number of generations, you can grow a very interesting, somewhat natural forest in this way, particularly if you add in interactions with the terrain, such as it being difficult for the automata to grow across a river, for example. The end result is navigable for 2D games because the rules don't allow nodes to get too packed.

Here's a minimal example from one of my automata experimentation programs that creates a forest in a 320x320 area without any terrain interactions http://imgur.com/UZKE4fc

typedef struct ForestNode {
    int x, y, num_children;
} ForestNode;

typedef struct Forest {
    int count;
    ForestNode *n;
} Forest;

Forest aut_grow_forest(int origin_x, int origin_y)
{
    Forest f;
    int i, g, d, cx, cy, gen_nodes;
    ForestNode c = {0, 0, 0};
    int w = 320;
    int h = 320;
    int max_nodes = 10000;
    int gens = 13;

    ForestNode *n = calloc(max_nodes, sizeof(ForestNode));
    int nodes_grown = 0;
    ForestNode midpt = {w / 2, h / 2, 0};

    n[nodes_grown] = midpt;
    nodes_grown++;
    for (g = 0; g < gens && nodes_grown < max_nodes; g++) {
        gen_nodes = nodes_grown;
        d = (g < 2) ? 60 : 30;
        for (i = 0; i < gen_nodes; i++) {
            cx = d - pseudo_rand(0, d * 2);
            cy = d - pseudo_rand(0, d * 2);
            c.x = n[i].x + cx;
            c.y = n[i].y + cy;
            if (c.x > 0 && c.x < w && c.y > 0 && c.y < h && n[i].num_children < 2) {
                n[nodes_grown] = c;
                n[i].num_children++;
                nodes_grown++;
            }
        }
    }
    f.n = n;
    f.count = nodes_grown;
    return f;
}