# Langton's Ant

Another example of cellular automata that I've only just discovered is Langton's Ant.

It's a tiny program that obeys a couple of simple rules and draws some really very interesting patterns that look for all the world like there is an intelligence behind the process, guiding it.

``````
from microbit import *
import random

def create_new_ant():
return [random.randint(0, 4), random.randint(0, 4)] # start at a random place on the board

def pick_direction(compass_points):
return random.choice(compass_points)

# lit pixel -> dark, dark pixel -> lit
def flip_pixel(pixel):
intensity = display.get_pixel(pixel[0], pixel[1])

if intensity == 0: intensity = 9
else: intensity = 0

display.set_pixel(pixel[0], pixel[1], intensity)

def turn_left(direction, compass_points):
index = compass_points.index(direction)
if index == 0:
index = len(compass_points) - 1
else:
index -= 1
return compass_points[index]

def turn_right(direction, compass_points):
index = compass_points.index(direction)
if index == (len(compass_points) -1):
index = 0
else:
index += 1
return compass_points[index]

return new_ant

def wrap_value_if_required(value):
if value > 4:
value = 0
elif value < 0:
value = 4
return value

# Keep the ant on the board. If we go too far one direction,
# wrap the board around and start again on the opposite edge
def wrap_world_edges(ant):
return [wrap_value_if_required(ant[0]), wrap_value_if_required(ant[1])]

ant = create_new_ant()

north = [1, 0]
east = [0, 1]
south = [-1, 0]
west = [0, -1]

compass_points = [ north, east, south, west ]
direction = pick_direction(compass_points) # start off pointing in a random direction

while True:
square = display.get_pixel(ant[0], ant[1])

if square == 0:
direction = turn_left(direction, compass_points)
else:
direction = turn_right(direction, compass_points)

flip_pixel(ant)
ant = move_forward(ant, direction)
ant = wrap_world_edges(ant)
sleep(500)
``````

The effect is somewhat reduced on the microbit's 5x5 screen but it's still a nice illustration of complexity coming from simple rules.