Blocks_and_Walls
Posted: May 31st, 2011, 6:25 pm
Hi, well, I am new here, but, well, I created a cellular automata and sent it to Tim Hutton at rule table repository to get my cellular automata on. He said he would put it on and recommended me to add it here. So... here it is.
So, once again, hi, and tell me what you guys think.
Thanks!
Cordership
Code: Select all
n_states:21
neighborhood:Moore
symmetries:rotate4reflect
# Cells that can compute in machines
# W. Conrad Walden, 5/27/2011
# Put a cell of state one 1 your grid and put adjacent
# to it (i.e. N, S, E, W) a cell
# Of any state between 2 and 6.
# The new pair, or signal, will start to move in the direction
# Of the second cell you changed.
# Dean Hickerson's Squaredance used as template
# Only one problem as of now: a evade signal cannot run two spaces from
# a wall or block in a way other that towards that obstacle.
############################# States ##########################
# 0 is ground, nothingness
# 1, base, is the base, or sometimes tail
# 2, sensor, is a sensor, or sometimes head, that can be destroyed by walls
# or push blocks
# 3, evade, is a sensor that evades walls or blocks, and is the only one
# that can be used to make a generator
# 4, destroy, destroys walls and blocks
# 5, key, is key to gates, to make gates open or closed
# 6, build, builds blocks or strengthens blocks into walls when it is in
# front of any thing
# 7, wall, is a wall
# 8, block, is a block
# 9, lgate, is a locked gate which will not let any signals through but
# opens when a key signal is nearby
# 10, ugate, is an unlocked gate that lets all particles except key through
# and is turned into a locked gate when a key is adjacent, it
# transforms all particles running through into signals with
# sensors of 3
# 11, sensorg, is a cell sensor passing through a gate
# 12, baseg, is a cell base passing through a gate
# 13, trans, is a transformer, it changes 1 to 2, 2 to 3, 3 to 4, 4 to 5, 5 to 6,
# and 6 to 1
# 14 through 19, are transforming cells not to be made by
# the user
# 20, dynamic, is a moving dynamic block
var base = {1}
var sensor = {2}
var evade = {3}
var destroy = {4}
var key = {5}
var build = {6}
var wall = {7}
var block = {8}
var lgate = {9}
var ugate = {10}
var sensorg = {11}
var baseg = {12}
var trans = {13}
var sensort = {14}
var evadet = {15}
var destroyt = {16}
var keyt = {17}
var buildt = {18}
var baset = {19}
var dynamic = {20}
############################## Variables ###########################################
var asensor = {sensor,evade,destroy,key,build}
var tsensor = {sensort,evadet,destroyt,keyt,buildt}
var notbasea = {0,sensor,evade,destroy,key,build,wall,block,lgate,ugate,sensorg,trans,sensort,evadet,destroyt,key,buildt,dynamic}
var notbaseb = {0,sensor,evade,destroy,key,build,wall,block,lgate,ugate,sensorg,trans,sensort,evadet,destroyt,key,buildt,dynamic}
var xa = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20}
var xb = {xa}
var xc = {xa}
var xd = {xa}
var xe = {xa}
var xf = {xa}
var xg = {xa}
var xh = {xa}
var borw = {block,wall}
var solidnb = {base,sensor,evade,destroy,key,build,wall,lgate,sensorg,baseg,sensort,evadet,keyt,buildt,baset}
var notsensora = {wall,block,base,trans,ugate,lgate,0,baset}
var allsensor = {sensor,sensort,sensorg}
var allevade = {evade, evadet}
var alldestroy = {destroy,destroyt}
var allkey = {key,keyt}
var allbuild = {build,buildt}
var allbase = {base,baseg,baset}
############################### Rules ##############################################
# sensor becomes base
asensor,xa,xb,xc,xd,xe,xf,xg,xh,base
tsensor,xa,xb,xc,xd,xe,xf,xg,xh,baset
sensorg,xa,xb,xc,xd,xe,xf,xg,xh,baseg
# evade in action
0,xa,xb,borw,xc,xd,notbasea,allevade,notbaseb,base
0,xa,xb,xc,borw,xd,evade,notbasea,xe,evade
# destroy in action
borw,xa,xb,xc,xd,xe,notbasea,alldestroy,notbaseb,0
# key in action
lgate,xa,xb,xc,xd,xe,notbasea,allkey,notbaseb,ugate
ugate,xa,xb,xc,xd,xe,notbasea,allkey,notbaseb,lgate
# build in action
0,xa,xb,solidnb,xc,xd,notbasea,allbuild,notbaseb,block
block,xa,xb,xc,xd,xe,notbasea,allbuild,notbaseb,wall
# block pushed
block,xa,xb,0,xc,xd,notbasea,allsensor,notbaseb,dynamic
0,xa,xb,xc,xd,xe,notbasea,dynamic,notbaseb,block
# dynamic into base
dynamic,xa,xb,xc,xd,xe,xf,xg,xh,base
# moving signals
0,xa,xb,xc,xd,xe,notbasea,allsensor,notbaseb,sensor
0,xa,xb,xc,xd,xe,notbasea,allevade,notbaseb,evade
0,xa,xb,xc,xd,xe,notbasea,alldestroy,notbaseb,destroy
0,xa,xb,xc,xd,xe,notbasea,allkey,notbaseb,key
0,xa,xb,xc,xd,xe,notbasea,allbuild,notbaseb,build
# transforming signals
trans,xa,xb,xc,xd,xe,notbasea,allsensor,notbaseb,evadet
trans,xa,xb,xc,xd,xe,notbasea,allevade,notbaseb,destroyt
trans,xa,xb,xc,xd,xe,notbasea,alldestroy,notbaseb,keyt
trans,xa,xb,xc,xd,xe,notbasea,allkey,notbaseb,buildt
trans,xa,xb,xc,xd,xe,notbasea,allbuild,notbaseb,sensort
# gate
ugate,xa,xb,xc,xd,xe,notbasea,allsensor,notbaseb,sensorg
ugate,xa,xb,xc,xd,xe,notbasea,allevade,notbaseb,sensorg
ugate,xa,xb,xc,xd,xe,notbasea,alldestroy,notbaseb,sensorg
ugate,xa,xb,xc,xd,xe,notbasea,allkey,notbaseb,sensorg
ugate,xa,xb,xc,xd,xe,notbasea,allbuild,notbaseb,sensorg
# bases die
base,xa,xb,xc,xd,xe,xf,xg,xh,0
baset,xa,xb,xc,xd,xe,xf,xg,xh,trans
baseg,xa,xb,xc,xd,xe,xf,xg,xh,ugate
Thanks!
Cordership
