Blocks_and_Walls

For discussion of other cellular automata.
Post Reply
User avatar
cordership
Posts: 8
Joined: May 31st, 2011, 6:14 pm

Blocks_and_Walls

Post by cordership » 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.

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 
So, once again, hi, and tell me what you guys think.


Thanks!
Cordership
Dreaming of being a Gemini knightship. Ahhhh........

ebcube
Posts: 124
Joined: February 27th, 2010, 2:11 pm

Re: Blocks_and_Walls

Post by ebcube » May 31st, 2011, 10:06 pm

I like it! Maybe it's a little too complex, but it's a great job! The "quirks" on the behavior of the evade signal actually allow for some interesting mechanics.

Rudimentary "head detector" (to be improved!)

Code: Select all

x = 13, y = 45, rule = blocks_and_walls
.I.G$2.3G2.I$.G6.G$MG2.G3.I$3.G3.J$2.3G3.I$.G7.G$MG2.G4.I$3.G4.J$2.3G
4.I$.G8.G$MG2.G5.I$3.G5.J$2.3G5.I$.G9.G$MG2.G6.I$3.G6.J$2.3G6.I$.G10.
G$MG2.G7.I$3.G7.J$2.3G$.G$.G4$D$A3$E$A3$F$A3$B$A3$C$A!
EDIT: As part of the improvement process, I created a generic detector. It creates a sensor signal with the same direction as the original signal, which can be of any type. The detector returns both the original signal and the sensor signal.

Code: Select all

x = 12, y = 38, rule = blocks_and_walls
2.2G$.G.2G$.G7.G$MG2.G5.G$3.G7.G$2.2G4.J.G$.G.2G4.G$.G7.G$MG2.G5.G$3.
G7.G$2.2G4.J.G$.G.2G4.G$.G7.G$MG2.G5.G$3.G7.G$2.2G4.J.G$.G.2G4.G$.G7.
G$MG2.G5.G$3.G7.G$2.2G4.J.G$.G.2G4.G$.G7.G$MG2.G5.G$3.G7.G$2.2G4.J.G$
.G.2G4.G$.G$.G4$F$A3$D$A!
I've just realized that this works as a "evade blocker": it turns every signal into a sensor signal, except if it is an evade signal; if it is an evade signal, it is destroyed.

Code: Select all

x = 4, y = 14, rule = blocks_and_walls
A$B3$A$C4$.G$2.G$3.G$J.G$.G!
Can you provide a .colors or .icons file for your table? Thanks!

Edit 2: Explicit proof of omniperiodicity (oscillators + guns) for every period p > 3.

Code: Select all

x = 17, y = 59, rule = blocks_and_walls
5.H$5H.H$7.H$3H.CGA.H$.H.2AG2C.H$H4.G4.H$.H.2CG2A.H$2.H.AGC.H$3.H3.H$
4.H.H$5.H2$6.H$5.H.H$5H.C.H$5.AC2.H$3H2.3G2.H$.H3.3G2A.H$H.3C3G3C.H$.
H.2A3G3.H$2.H2.3G2.H$3.H2.CA.H$4.H.C.H$5.H.H$6.H2$7.H$6.H.H$5.H3.H$5H
5.H$4.AC3.2AH$3H.A5HC.H$.H3.5H3.H$H4.5H4.H$.H3.5H3.H$2.H.C5HA.H$3.H2A
3.CAH$4.H5.H$5.H3.H$6.H.H$7.H2$8.H$7.H.H$6.H3.H$5.H5.H$5H5.2AH$3.CAC
4.AC.H$3H.A7H2.H$.H3.7H3.H$H4.7H4.H$.H3.7H3.H$2.H2.7HA.H$3.H.CA4.CAH$
4.H2A5.H$5.H5.H$6.H3.H$7.H.H$8.H!
How to create a oscillator/gun of period p > 3:

1. Draw a 45º-tilted square of side p + 3 with walls or blocks.
2. Inside the 45º-tilted square, draw a rectangle of size 5 by [(p - 3) + 1].
3. On one of the sides of the rectangle, draw a evade signal.
4. Advance p generations, copy the current state of the evade signal(s) and paste it over the initial state. Repeat this three times.
5. If you want it to be a gun, add the "shooting channel".

Of course, this is the general, "proof-like" method. It is not the most optimal way to create a gun, but it always works.

User avatar
Tim Hutton
Posts: 64
Joined: May 20th, 2010, 7:30 am
Contact:

Re: Blocks_and_Walls

Post by Tim Hutton » June 1st, 2011, 5:16 am

Attached is a zip file containing Conrad's rule table together with the icons and an example pattern.

Let me know when you consider it finished, Conrad, and I'll add it to the RTR.
Attachments
BlocksAndWalls_ConradWalden.zip
(5.5 KiB) Downloaded 170 times

User avatar
ssaamm
Posts: 125
Joined: June 4th, 2010, 9:43 pm

Re: Blocks_and_Walls

Post by ssaamm » June 1st, 2011, 5:22 pm

Now, I'm no professional, but I have an improvement to the icon file to suggest:
Blocks_and_Walls.zip
(984 Bytes) Downloaded 176 times
Earlier version:
Blocks_and_Walls icons.zip
(7.98 KiB) Downloaded 172 times
How's this?

User avatar
cordership
Posts: 8
Joined: May 31st, 2011, 6:14 pm

Re: Blocks_and_Walls

Post by cordership » June 1st, 2011, 9:18 pm

Omg you guys are AMAZING!!!! I love it all. The icons file a love, so thanks ssaamm!! :D
Dreaming of being a Gemini knightship. Ahhhh........

User avatar
cordership
Posts: 8
Joined: May 31st, 2011, 6:14 pm

Re: Blocks_and_Walls

Post by cordership » July 30th, 2011, 4:04 pm

Featured!!! I feel great!!
Last edited by cordership on May 27th, 2012, 12:51 pm, edited 1 time in total.
Dreaming of being a Gemini knightship. Ahhhh........

edwardfanboy
Posts: 80
Joined: September 16th, 2011, 10:29 pm

Re: Blocks_and_Walls

Post by edwardfanboy » December 10th, 2011, 4:57 am

Made this p4 gun of Evade signals.

Code: Select all

x = 5, y = 7, rule = blocks_and_walls
2.G.G$.2G.G$.G2CG$.G.AG$G3.G$G3.G$.3G!

User avatar
Hektor
Posts: 89
Joined: November 3rd, 2011, 2:37 pm

Re: Blocks_and_Walls

Post by Hektor » February 18th, 2012, 1:26 pm

A loop that increases the number of evade signals emitted. In the end the signal became continuous.

Code: Select all

x = 50, y = 33, rule = Blocks_And_Walls
13.G.G2.G$13.G.2G.G$13.G.G.2G$13.G.G2.G4$2G37.2G$G39.G7$32.2G$8.G22.
2G7.G$7.G.G10.G10.G2.2G3.2G$G32.2G$2G7.10G.G10.G2.2G$9.10G12.2G$9.10G
13.2G$9.10GA$9.10GC$9.10G20.3G.G.G.3G$9.10G20.G.G.G.G2.G$9.10G20.G.G.
G.G2.G$9.10G20.3G.3G2.G$9.10G$7.G.10G$6.G$7.G10.G.G$19.G!

edwardfanboy
Posts: 80
Joined: September 16th, 2011, 10:29 pm

Re: Blocks_and_Walls

Post by edwardfanboy » February 18th, 2012, 11:07 pm

A 3-signal "flotilla" gun

Code: Select all

x = 22, y = 16, rule = Blocks_And_Walls
2.4G.3G$.G4.G3.G2$6.G$5.A.A$5.C.C2$.G$G$.2G$G11.J6.AB$G.2G5.2G$G11.J
7.AB$G$G11.J6.AB$.G.2G3.2G!


Post Reply