Hey!

You probably skipped my first article about procedural generation, it's just an introduction, but you can read it here.

Today we're going to design a game which uses procedural generation in order to create meaningful player interaction, each article will feature a different example but I encourage you to use this resources to come up with your own implementations.

What we are going to do is design a turn-based game about hunting squirrels, but player interaction will affect the population of squirrels and how they evolve.

Now, without further delay, let's get to it!

Conway's game of life

We already talked about this algorithm on the introduction, it's quite easy to understand so it should be a good starting point for our game about hunting squirrels. As you know this "game" requires just an initial input, once we enter a grid/array(which represents a population) the algorithm "evolves" the data. To achieve that it uses four simple rules.

(these rules can be found here, or you can check out this online example)

This algorithm was conceived with cells in mind, but changing those four rules we can build a logical model for any kind of population.

The basics of our game

Let's start imagining a simple game using "Conway's game of life".

Main Loop:

Right now, we would have a game where the player has the power to shape the environment with his/her actions, let's take a look at how we can keep expanding this.

Evolution!

A cool way to add more complexity to our system would be if our squirrels were to evolve, I'm talking about natural selection. Natural selection acts when there's a quality that makes certain specimens "fitter to survive"; usually just those with that quality get to survive after a certain time.

Let's say we create a skill called "become invisible" and assign it to a few squirrels. Whenever the player tries to hunt a squirrel with the "become invisible" skill there's an additional chance it will get away. Doing so, those with the given skill are more likely to survive.

If we wanted to take this one step further, we could modify the forth step of our algorithm (the one about reproduction), adding two new "sub-rules":

We could set up a couple of skills, and try to make it look more realistic or more goofy(depending on what we're trying to achieve); just play around with the percentages and tweak them as you wish. You could even make squirrels that evolved into some kind of super-beings which fought back, there are hundreds of possibilities and it's up to you to choose which ones you want to explore.

Closing thoughts

Just with a basic implementation of this algorithm we can create a population of beings which reacts in a realistic way to player's actions, isn't that cool? And we can keep expanding this system, think about how much it can add to certain projects and how easy is to implement.

Perhaps you're making a game which can use this kind of procedural generation as its main feature, or maybe you're working on a project which could use these kind of things to add more complexity to its core (and there's a big chance you're working on something which wouldn't benefict from all this).

Keep thinking about procedural generation and how players interact with that type of content and try to come up with new implementations apart from map generation.

On the next article we won't be using "Conway's Game of Life", because we won't represent the life and death of the beings from a given population; so we'll talk about creating simple algorithms which adapt to what we want to make.

Let me know if you found this example confusing so I can try to fix that on the next article.

You can always find me on twitter or leave a comment here ^^