the different rule families

here is the different rule families that the rule family browser shows

-- null
the default rule family

vote
this rule family runs the vote rule and another rule at the same time
using the rule table
it calls the vote function to run the vote rule
the vote function returns 1 if 5 or more neighbors are in a odd state
otherwise it returns 0

here is a table that shows the cell's next states

cell's state	result from the vote function	table entry	cell's next state
even state	even state	even state	even state
even state	even state	odd state	odd state
even state	odd state	even state	odd state
even state	odd state	odd state	even state
odd state	even state	even state	odd state
odd state	even state	odd state	even state
odd state	odd state	even state	even state
odd state	odd state	odd state	odd state

generation_neighborhood
this rule family uses two neighborhoods
a 5x5 neighborhood and a 3x3 neighborhood
all the cells that are in the 3x3 neighborhood
are also in 5x5 neighborhood
in 3x3 neighborhood it counts the neighbors.
a neighbor's state value is how many neighbors it's counted as
you can configure how many neighbors a cell state is
counted as in the 3x3 neighborhood
by clicking on the colors in color box and going to edit->edit state.

in the 5x5 neighborhood it counts how many neighbors have a odd state
then it adds the 3x3 neighborhood sum and the 5x5 neighborhood sum togethor
and using the combined sum to lookup the cell's next state

margolus
this rule family splits the board into 2x2 blocks and the rule table into
2x2 blocks
each generation it lookups resulting 2x2 block in the rule table for each 2x2 block
and it splits the board into 2x2 blocks moved down one space and right one space

cyclic
this rule family counts the neighbors that are the cell's current state plus 1
then it lookups the cell's next state in the rule table
the cells often cycle through their states

cell_auto_1d
this rule family is 1d cellular automaton
you can change the neighborhood weights by going to edit->rule family options
you enter neighborhood weights by entering a bunch of numbers sep by commas
you can enter any number of weights in the text box the more weights you add
the bigger the size of neighborhood
if the calculate one row at a time option is on then
it will only calculate 1 row at a time
and you will see a line showing you where it will calculate the next row

margolus_ant
This rule family is like margolus2 except for following differences.
A cell state is odd if there is ant on the cell otherwise it is even.
If there is 1 or more ants in the cell's margolus 2x2 block then it looks up
entries from the odd rows of rule table otherwise it looks up from even rows.
The antcode is a code that tells the ant to turn left or right based
the sum of cells in the margolus 2x2 block.
if the sum is zero then it looks first leftmost character of the antcode
if the character is the number zero then the ant turns right
if the character is the number one then the ant turns left
if the sum is one then it looks at the second character of the antcode
if the sum is two then it looks at the third character of the antcode
if the sum is three then it looks at the fourth character of the antcode
... etc
if the sum is greater than the length of the antcode then it just warps around the antcode

To get the sum of cells for the antcode it adds the trail weights of each
of the 4 cells in the margolus 2x2 block
the trail weights are numbers separate by commas.
To get the cell's trail weight it divides the cell's state by 2 then uses it to lookup
the trail weight for that cell state if that number is greater than the number of
trail weights then it just wraps around when looking up trail weights

for example
if the cell state is 0 or 1 then it lookups the first leftmost trail weight in the string
if the cell state is 2 or 3 then it lookups the second trail weight
if the cell state is 4 or 5 then it lookups the third trail weight
if the cell state is 6 or 7 then it lookups the fourth trail weight

margolus2
in this rule family each cell looks at its 3 neighbors in the margolus 2x2 block
and gets the sum from the 3 neighbors
you can change the weight of its 3 neighbors by going to edit->rule family options
the use neighborhood weights option lets you choose if you also want to count sum of
the neighbors in the regular 3x3 or larger neighborhood

particle_streams
this is a rule by Brian Prentice where you can build logic gates
and digital circuits
it has the following states:
0 background
1 stream moving north
2 stream moving east
3 stream moving south
4 stream moving west
5 stream terminator
6 to 11 gates
the particle streams move horizontal or vertical.

diagonal_particle_streams
this is a rule by Brian Prentice where you can build logic gates
and digital circuits
it has the following states:
0 background
1 stream moving northwest
2 stream moving northeast
3 stream moving southeast
4 stream moving southwest
5 .. 6 gate posts
7 .. 22 gate selectors
the particle streams move diagonal.

Hosted by www.Geocities.ws