This is a framework for running cellular automata built in python.
A Cellular Automata is a (typically infinite) grid of cells. Each cell has a state from a set of possible states. Once initialized, the cellular automata iterates, with the next state of each cell at each iteration being determined by a set of rules, typically based on the current state of the cell and the cells around it.
This should work with any simple (two dimensional, values of 1 or 0) cellular automata. The script allows you to pass an outside function in to the cellular automata to be used when iterating. This is useful for creating/testing many different cellular automata. The function need only accept x and y coordinates, as well as the current cellular automata object, and return the next state for that cell.
The following files are included:
- cellular_automata_framework.py - This is the cellular automata class. Create a new cellular automata by creating a new instance of this class. Call the iterate function to iterate it.
- cellularAutomata_Functions.py - This is a collection of rule set functions that I created, as well as the most famous rule set, Conway's Game of Life.
- cellularAutomata_Driver.py - This is a script I created for running and testing different cellular automata. In the script are functions for creating initial boars for the automata, saving the board to a text file, saving the board and related information to a JSON file, displaying the board, and taking a screenshot of the display.
CellularAutomata_driver.py utilizes my noise_squirrel5 package which can be found here: https://github.com/FiniteUI/Squirrel-Noise-5
I initially was playing around with them as a way to procedurally generate terrain for video games, and tested out over 200 functions. Most of the functions I tested were created randomly with by looking at different possibilites for a few different parameters. It is very difficult to tell how the automata will actually act from the ruleset, so I followed the mindset of creating a ton of them without much thought and seeing how they played out. Below are some of the more interesting results. The functions for these are the titles displayed at the top of the grid, and can be found in the cellularAutomata_functions.py script:
This function generates a maze like structure:
These functions generate splotchy, discrete masses. These could be useful for terrain generation for forests, rocks, hills, water, etc.:
These functions generates paths:
These functions generate large blocky areas:
These functions generate competing sections of vertical and horizontal lines:
These functions generate piles of "snakes":
This function generates some discrete areas with a distinct pattern:
These functions devolve into small cycling blocks:
And here's a few more slightly less interesting ones for good measure:
Apart from these, many of them end up in uninteresting cycles or blank voids of black or white. However, while some of them don't produce interesting end points, many of them actually display interesting movement patters that the screenshots/endpoints don't reflect. Also, I am using a 100 by 100 grid, running them for 100 iterations, and giving completely randomized input. It is very possible that changes in grid size could produce different results. It's also possible that different types of input (different densities, patterns, etc) could produce different results. Lastly, while some of them terminate in empty grids or simple cycles, they may show interesting patters earlier in their iterations. Ones that do not terminate but don't show interesting results, may show better results if ran for more iterations.
I will be working on more in the future, utilizing new parameters and different combinations of existing parameters.