Here is the script:

Code: Select all

`-- For 3D.lua (make sure to copy this line)`

-- This script will use 3D.lua to display the evolution of a

-- two-dimensional rule in a bounded grid, using Y as the time

-- dimension.

-- It will generate up to 99 steps of any size in any two-state rule,

-- and any kind of bounded grid with dimensions <= 100. (The size

-- limitations are due to the maximum grid size of 3D.lua.)

-- How to use:

-- 1. In Golly's normal interface, create a pattern using a 2-state

-- rule, in a bounded grid with any dimensions <= 100.

-- 2. Start 3D.lua, and run this script through it.

-- 3. Enter the number of steps to run.

-- By SuperSupermario24, 2018-08-18

---------------------------------------------------------------------

local g = golly()

local gp = require "gplus"

-- function that displays an error message and aborts

-- (can't use g.exit() with a string argument because that bugs 3D.lua)

local function raiseError(message)

g.warn(message)

g.exit()

end

---------------------------------------------------------------------

-- preliminary error-checking

if g.numstates() > 2 then

raiseError("2D rule simulated cannot have more than 2 states.")

elseif g.getwidth() == 0 or g.getheight() == 0 then

raiseError("2D universe must be bounded.")

elseif g.getwidth() > 100 or g.getheight() > 100 then

raiseError("2D universe cannot have a dimension that is greater than 100.")

end

---------------------------------------------------------------------

-- clear 3D grid

NewPattern()

-- get number of steps and step size

local genstring = g.getstring("Enter steps and optional step size (separated by a space):", "99 1", "Enter generations:")

local numgens, step = gp.split(genstring, " ")

-- convert to numbers

numgens = tonumber(numgens)

-- set default step size to 1 if not entered

if step == nil then

step = 1

else

step = tonumber(step)

end

-- check if valid generation and step count

if numgens < 0 then

g.warn("Cannot run fewer than 0 generations. Running 0 generations instead...")

numgens = 0

elseif numgens > 99 then -- 99 is max because gen 0 is included

g.warn("Cannot run more than 99 steps. Running 99 steps instead...")

numgens = 99

end

---------------------------------------------------------------------

-- set grid size to highest out of universe width, height, and number of gens displayed

local gridsize = math.max(g.getwidth(), g.getheight(), numgens + 1)

SetGridSize(gridsize)

---------------------------------------------------------------------

-- set initial current plane to lowest available y value

local currenty = math.ceil(-gridsize / 2)

for i = 1, numgens + 1 do

if not g.empty() then

-- get all the cells in the current universe

local array2d = g.getcells(g.getrect())

-- create 3D cell array out of 2D cell array, using 0 as Y coordinate of all of them

local array3d = {}

for i = 1, #array2d / 2 do

table.insert(array3d, {array2d[2*i - 1], 0, array2d[2*i]})

end

-- put the cells in current plane

PutCells(array3d, 0, currenty, 0)

-- if not finished, update the pattern and move current plane up

if i ~= numgens + 1 then

g.run(step)

currenty = currenty + 1

end

end

end

---------------------------------------------------------------------

-- set current mode to hand cursor (otherwise it will be set to draw)

MoveMode()

The script uses Golly's regular 2D universe in order to generate each step behind the scenes. As such, you don't need to fiddle with the 3D editing interface to enter a pattern to simulate; just enter a pattern using the regular Golly interface, and then open 3D.lua and run this script through it.

It will run any pattern for up to 99 steps (due to the max grid size in 3D.lua being 100, and the fact that it will include generation 0), of any step size. It supports any two-state rule, in any bounded grid where the X and Y dimensions are both 100 or less. The type of bounded grid doesn't matter either; go nuts with your tori and Klein bottles and whatnot if you so desire.

Here are a few example pictures:

Let me know what you guys think, or if there are any problems with the script.

UPDATE 1: I've added the ability to enter a custom step size, so that multiple generations may be run per step. This effectively means that the maximum generation count is now theoretically unbounded, although obviously not all of them will be displayed.