View difference between Paste ID: B95QC4NX and xnfuQsP4

 --One Dimensional Cellular Automaton
 --Adapted from "dominic"'s Lua CA written to use LOVE.
 --Original version can be found here: http://blog.signalsondisplay.com/?p=60
 --The only thing I borrowed from his version is the algorithm computer.
 -----------------------------------------------------------------------------
 --Tangent Automaton V. 1.2.2
 --Notes:
 --Added the ability to define a custom seed to start with.
 
 width = 64 --Set your desired width here!
 debug = false --Do you want debugging messages?
 random = false --Start with a randomly generated seed?
 seed = true --Start with a pre-defined seed?
 center = false --Start with one center cell?
 
 seeddata={} --Put your seed information here!
 
 height = width / 2
 
 t=true
 f=false
 
 states = {}
 rulegiven={}
 mt={}
 for i = 1, width do states[i] = 0 end
 states[width / 2] = 1
 output={}
 
 ruletable= --The rule lookup table.
 {
 	{t,t,t},
 	{t,t,f},
 	{t,f,t},
 	{t,f,f},
 	{f,t,t},
 	{f,t,f},
 	{f,f,t},
 	{f,f,f}
 }
 
 function dectobin(input)
 	conversion={1,2,4,8,16,32,64,128} --I'll make this into 2^n eventually.
 	output={0,0,0,0,0,0,0,0} --The output table, keeping it like this for now.
 	i=8 --Starting number to decrement from
 	for h=1,8 do --It's 8 bit!
 		input=input-conversion[i] --Grabs the number to convert, and subtracts it from the lookup table.
 		if debug then print(input) end
 		if input <0 then --If it's less than 0 (negative)...
 			input=input+conversion[i] --...undo that subtraction.
 		else --If it isn't less than 0 (greater than or equal to)...
 			output[h]=1 --...set the output bit high (change "h" to "i" to swap endianess).
 		end
 		i=i-1 --The simple decrementer
 	end
 end
 
 ruletable= --My second rule lookup table. I have no idea why I have two.
 {
 	{true,true,true},
 	{true,true,false},
 	{true,false,true},
 	{true,false,false},
 	{false,true,true},
 	{false,true,false},
 	{false,false,true},
 	{false,false,false}
 }
 
 rule={} --Sets up the actual table the algorithm looks at.
 
 function grabrule() --This function decodes the given rule.
 	userinput=io.read() --Gets the user's input.
 	dectobin(userinput) --Sends the input to get decoded into binary.
 	rulegiven=output --Takes that binary number and sticks it into "rulegiven".
 	if debug then print(#rulegiven) end
 	--print(string.len(userinput)) --I might re-implement this later. For now, You'll have to use the decimal system.
 	--for i=1,string.len(userinput) do
 	--	rulegiven[i]=string.sub(userinput,i,i)
 	--end
 
 	if #rulegiven~=8 then --Rather pointless warning since an 8-bit number is ALWAYS created...
 		print("You must enter an 8-bit number!")
 	end
 
 	if debug then --more debugging
 		for j=1,#rulegiven do
 			io.write(rulegiven[j].." ")
 		end
 		io.write("\n")
 	end
 
 	for k=1,#rulegiven do --This will turn the binary into bollean logic.
 		if rulegiven[k]==1 then --If the bit is 1...
 		rulegiven[k]=true --...set it to true (rather pointless, since I could combine this with the next part of the program).
 		else
 			rulegiven[k]=false --This is rather pointless, since it's set to "false" by default.
 		end
 	end
 
 	rulecounter=1 --A temporary number that helps with keeping the rule table from skipping ahead.
 
 	for i=1,#rulegiven do --For as many rules as there are given...
 		if rulegiven[i]then --...if the state of the rule is true...
 			rule[rulecounter]=ruletable[i] --...look at the lookup table, and stick that value into "rule".
 			rulecounter=rulecounter+1 --Decrements the counter for the "rule" table.
 		end
 	end
 end
 
 function grabseed() --This function asks for an input, and stores it to "state"
 	seedgiven={} --I always store "binary" data in a table.
 	print("Please enter a starting seed in binary!")
 	print("Note: This seed will be placed in the center of the algorithm.")
 	inputseed=io.read() --Asks for the seed.
 	for i=1,string.len(inputseed) do --This loop chops the user input up, and stuffs it into my table.
 		seedgiven[i]=string.sub(inputseed,i,i)
 	end
 	for i=1,#seedgiven do --Appearently, it's a string, and I need numbers.
 		if seedgiven[i]=="1" then --If the string is a "1"...
 			seedgiven[i]=1 --...make it into a number 1...
 		else
 			seedgiven[i]=0 --...else it's a 0.
 		end
 	end
 	bitshift=((width-#seedgiven)/2) --To find how much the data should be shifted, the lenght of the given seed is subtracted from the width, then divided by 2.
 	bitshift=math.floor(bitshift) --If it's an odd number, it gets rounded down.
 	j=bitshift --To keep the two numbers synced.
 	for i=1,#seedgiven do --This stores the given string into the "states" table.
 		states[j]=seedgiven[i]
 		j=j+1 --To keep j and i in sync.
 	end
 
 end
 
 
 function compute_next_gen(index) --Here's where all the computation happens.
 	--mt[1][(#states / 2)+1]="#"
 	current_gen = {} --This table stores the current information to get computed.
 	for i = 1, #states do --This just stores the data from the current bit into the p, c, and n registers.
 		p = states[i - 1] == 1
 		c = states[i] == 1
 		n = states[i + 1] == 1
 		current_gen[i] = 0 --Once that's done, it sets the gen back to 0 to do the actual computation.
 		for j = 1, #rule do --It computes for as many rules it is given.
 			if (p == rule[j][1] and c == rule[j][2] and n == rule[j][3]) then --If it complies with the rules...
 				current_gen[i] = 1 --...set the current cell to an "on" state.
 				mt[index+1][i + 1]="#" --Stores it in my matrix.
 			end
 		end
 	end
 	states = current_gen
 end
 
 print("Please take a look at the top of this script to configure it!")
 
 if seed then
 	grabseed()
 	grabrule()
 elseif center then
 	grabrule()
 elseif random then
 	grabrule()
 end
 
 
 for i=1,height+1 do --This loop sets up my matrix with a spacing character.
 	mt[i] = {}
 	for j=1,width+1 do
 		mt[i][j] = " "
 	end
 end
 
 --for i=1,width do
 --	states[i]=math.random(0,1)
 --end
 
 for i=1,width do
 	if states[i]==1 then
 		mt[1][i+1]="#"
 	else
 		mt[1][i+1]=" "
 	end
 end
 
 if debug then print("This automaton uses "..#rule.." rules.") end --Disregard this, it's for debugging.
 if debug then
 	for a=1,#rule do
 		for b=1,3 do
 			if rule[a][b] then
 				io.write("true")
 			else
 				io.write("false")
 			end
 		end
 		io.write("\n")
 	end
 end
 
 for i = 1, height do --This runs the computation function for the desired height.
 	compute_next_gen(i)
 end
 
 for a=1,height do --This loop actually prints out my matrix, displaying the pretty pattern!
 	for b=1,width do
 		io.write(mt[a][b])
 	end
 	io.write("\n")
 end