### Procedural content generation: L-Systems

After watching this fantastic interview with Sean Murray about No Man’s Sky I’ve been inspired to write a bit about procedural content generation. I’ve been tinkering with procedural content generation for years, using it for everything from creating games levels to generating sample data for testing and it is a fascinating subject.

So what is procedural content generation?

Wikipedia says “*procedural generation is generating content algorithmically rather than manually… The term procedural refers to the process that computes a particular function*”. The Procedural Content Generation Wiki suggests it “*is the programmatic generation of game content using a random or pseudo-random process that results in an unpredictable range of possible game play spaces… procedural content generation should ensure that from a few parameters, a large number of possible types of content can be generated*”.

That’s quite a mouthful! Basically the idea is to get the computer to generate content so you don’t have to :)

## Lindenmayer systems

To get the ball rolling I’m going to start with Lindenmayer systems or L-systems. Developed by Hungarian biologist Aristid Lindenmayer in 1968 to describe and model the growth of plants, L-systems can be used to generate amazingly complex structures from a set of very simple rules.

An L-system is represented by a simple string of characters (much like a DNA string) for example “FG+G-F. A very simple system would consist of just a single letter, for example “F”.

It also has bunch of rules. These are simple substitutions that define how each letter in the system should be replaced or expanded.

For example we might have two rules that say “F=G-F-G” and “G=F+G+F”, which basically says replace all F’s with “G-F-G” and replace all G’s with “F+G+F”.

To generate our output we simply iterate a number of times, applying the rules to the result of the previous iteration.

For example if we start with:

- Start: F
- Rules:
- F=G-F-G
- G=F+G+F

And we iterate once, we get:

G-F-G

If we iterate again (applying the rules again), we get:

F+G+F-G-F-G-F+G+F

And after you iterate 5 times you land up with this enormous string:

G-F-G+F+G+F+G-F-G-F+G+F-G-F-G-F+G+F-G-F-G+F+G+F+G-F-G+F+G+F-G-F-G-F+G+F+G-F-G+F+G+F+G-F-G+F+G+F-G-F-G-F+G+F+G-F-G+F+G+F+G-F-G-F+G+F-G-F-G-F+G+F-G-F-G+F+G+F+G-F-G-F+G+F-G-F-G-F+G+F+G-F-G+F+G+F+G-F-G+F+G+F-G-F-G-F+G+F-G-F-G+F+G+F+G-F-G-F+G+F-G-F-G-F+G+F-G-F-G+F+G+F+G-F-G-F+G+F-G-F-G-F+G+F+G-F-G+F+G+F+G-F-G+F+G+F-G-F-G-F+G+F-G-F-G+F+G+F+G-F-G-F+G+F-G-F-G-F+G+F-G-F-G+F+G+F+G-F-G+F+G+F-G-F-G-F+G+F+G-F-G+F+G+F+G-F-G+F+G+F-G-F-G-F+G+F+G-F-G+F+G+F+G-F-G-F+G+F-G-F-G-F+G+F-G-F-G+F+G+F+G-F-G

## Enter the turtle

So great, you now have a very long line of text but it doesn’t seem very useful…

Well imagine a tiny little turtle, this turtle is dragging a pen behind himself and everywhere he walks he leaves a line. He is also a very well trained little turtle and he can follow commands to walk forward or turn left or turn right.

So looking at our string again let’s define that *F* and *G* means “go forward 80 steps” and *-* means “turn left 60 degrees” and *+* means “turn right 60 degrees”. Then lets turn our generated strings into a list of commands for our wee friend, the turtle.

With 2 iterations (and a result of F+G+F-G-F-G-F+G+F) our turtle will draw the following:

If we keep incrementing our iterations, our turtle will draw:

With 8 iterations we end up with quite a cool pattern (known as a Sierpinski Triangle). It could be used as a nice (but predictable) maze for a game or perhaps an interesting texture.

## Teleporting Turtle

Let’s teach our turtle some new tricks. Firstly we will teach him to remember his current location and which direction he facing. Next we will teach him to teleport from his current position back to a previous one that he has remembered. We’ll tie these to the *[* and *]* characters in our L-system strings.

These new commands let us create branching structures, perfect for generating organic things like plants.

For example with a very simple L-system like this:

- Start: F
- Rules:
- F[+F]F[-F][F]

- Iterations: 5
- Angle: 20

We get this neat plant:

With these very simple types of rules we can generate a swag of different plants:

## Small changes, big impact

One of the nice things about procedural content generation is that a small tweak to the input parameters can result in big changes in the output. The following animation shows the same L-system but with varying iterations, angles and step lengths.

## A new dimension

Lastly, our turtle doesn’t necessarily need to only draw only lines or operate in 2 dimensions. Laurens Lapre created a great tool in the early 90’s called LPARSER which generated 3D models using L-systems. Below are a couple of these models rendered in Blender. As you can see in the “spider” and “air horse” examples, organic creatures can also be generated using L-systems. Laurens’ tool also has a mutate function that mutates the generated system to great effect.

## Wrapping up

Phewww, well that was longer then I expected! If you’d like to find out more about L-systems then check out The Algorithmic Beauty of Plants by P. Prusinkiewicz and A. Lindenmayer. Also all the code (mostly Processing) used to generate the images above can be found here.

If you enjoyed this post then check out my other posts on procedural content generation.

### B is for Blender

I have tinkered with 3D graphics for years, using POV-Ray in the mid nineties and later Hash Animation:Master. However these tools were pretty limited or not widely supported and commercial tools costed (and still do) a small fortune which put them out of reach of hobbyists.

So I was very excited when Blender was released in 2002 . With its commercial features and it being free (open source) the scene was set for great things to happen.

Unfortunately Blender’s origin as an in-house product for a visual FX studio meant that it was hard to use, with a confusing user interface and buggy features.

However Blender is a show case of how open source software works. A community quickly formed, new features were rapidly added and a new improved (and consistent) user interface was developed.

Today Blender is an easy to use, powerful application. In fact it has several releases a year, outdoing most commercial applications in the speed at which it evolves and improves.

So what can Blender do? Well pretty much anything you need to produce 3D animation and special effects. It supports 3D modelling, animation, physics, rendering, video editing and compositing. It even has a game engine and is widely used by hobbyist and indie developers to create assets for their games.

One interesting aspect of Blender are the blender movie projects. Every couple of years the Blender Foundation raises funds and tackles the production of a movie. As they do this, they fine tune and enhance the product based on real world experience. All the assets of the movies are also released to community. There have been 4 movies to date and the 5th one is in the works.

There are also a number of other “open” movie projects. For instance Caminandes:

If you want to give Blender a go I ‘d suggest you start with the very well paced tutorials by BornCG, for inspiration you cannot go wrong with the excellent tutorials of Andrew Price over at Blender Guru and finally, here is a tutorial on creating some cute Minions:

Happy Blending!