TangentAutomaton V.1.3

--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.3
--Notes:
--Added a friendly way to select what to do
--Cleaned up the code a bit
--Removed some debugging stuff
--To Do:
--Better pattern centering

width = 64 --Set your desired width here!
debug = false --Do you want debugging messages?

cellon="#"
celloff=" "

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={}

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] = celloff
    end
end

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 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 #rulegiven~=8 then --Rather pointless warning since an 8-bit number is ALWAYS created...
        print("You must enter an 8-bit number!")
    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.
    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]=cellon --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!")

function interface()
    print("Would you like to input a seed?(y/n)")
    input=io.read()
    if input=="y" then
        grabseed()
    else
        print("Would you like to use a randomly generated seed?(y/n)")
        input=io.read()
        if input=="y" then
            for i=1,width do
                states[i]=math.random(0,1)
            end
        else
            print("Going with standard seed...")
        end
    end

    print("Please enter the width to run for.")
    width=io.read()
    width=math.floor(width)

    print("Please enter a rule in decimal.")
    grabrule()
end

interface()

for i=1,width do
    if states[i]==1 then
        mt[1][i+1]=cellon
    else
        mt[1][i+1]=celloff
    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