e

--[[
Program created by Frekvens1, modified by ChatGPT

1. Any live cell with two or three neighbors survives.
2. Any dead cell with three live neighbors becomes a live cell.
3. All other live cells die in the next generation. Similarly, all other dead cells stay dead.

https://en.wikipedia.org/wiki/Conway%27s_Game_of_Life

Original: pastebin get si4sDXrY GameOfLife.lua
--]]

local mon = peripheral.find("monitor")
mon.setTextScale(0.5)

-- Define initial example grids
local grid1 = {
	-- Medium exploder (Variant)
	[10] = {[10] = true,[11] = true},[11] = {[10] = true,[11] = true},[13] = {[10] = true,[11] = true,[12] = true},
	-- Small exploder (Variant)
	[50] = {[10] = true,[11] = true},[51] = {[10] = true,[11] = true},[53] = {[11] = true},[54] = {[11] = true},[55] = {[11] = true}
}

local grid2 = {
	-- Gosper Glider Gun
	[10] = { [10] = true, [11] = true },[11] = { [10] = true, [11] = true },
	[18] = { [11] = true, [12] = true },[19] = { [10] = true, [12] = true },[20] = { [10] = true, [11] = true },
	[26] = { [12] = true, [13] = true, [14] = true },[27] = { [12] = true },[28] = { [13] = true },
	[32] = { [10] = true, [9] = true },[33] = { [10] = true, [8] = true },[34] = { [8] = true, [9] = true, [20] = true, [21] = true },
	[35] = { [20] = true, [22] = true },[36] = { [20] = true },[44] = { [8] = true, [9] = true },
	[45] = { [8] = true, [9] = true, [15] = true, [16] = true, [17] = true },[46] = { [15] = true},[47] = { [16] = true},
}

-- Merge two grids into one
local function mergeGrids(a, b)
	local result = {}
	for x, col in pairs(a) do
		result[x] = result[x] or {}
		for y in pairs(col) do
			result[x][y] = true
		end
	end
	for x, col in pairs(b) do
		result[x] = result[x] or {}
		for y in pairs(col) do
			result[x][y] = true
		end
	end
	return result
end

-- Initial grid is the combination of both examples
local grid = mergeGrids(grid1, grid2)
local dead_cells = {}
local new_cells = {}

function draw(redraw)
	if redraw then
		mon.setBackgroundColor(colors.black)
		mon.clear()

		mon.setBackgroundColor(colors.white)
		for x in pairs(grid) do
			for y in pairs(grid[x]) do
				mon.setCursorPos(x*2, y)
				mon.write("  ") -- Draws all cells from scratch
			end
		end
	else -- Fast render
		mon.setBackgroundColor(colors.black)
		for x in pairs(dead_cells) do
			for y in pairs(dead_cells[x]) do
				mon.setCursorPos(x*2, y)
				mon.write("  ") -- Erase dead cells
			end
		end

		mon.setBackgroundColor(colors.white)
		for x in pairs(new_cells) do
			for y in pairs(new_cells[x]) do
				mon.setCursorPos(x*2, y)
				mon.write("  ") -- Draw new cells
			end
		end
	end

	mon.setBackgroundColor(colors.black)
end

function nextGeneration()
	dead_cells = {}
	new_cells = {}
	local x_axis_pending_delete = {}

	for x in pairs(grid) do
		local y_elements = 0
		for y in pairs(grid[x]) do
			y_elements = y_elements + 1

			-- Check if cell should die
			local alive_neighbors = calculateCell(x, y)
			if not (alive_neighbors == 2 or alive_neighbors == 3) then
				dead_cells[x] = dead_cells[x] or {}
				dead_cells[x][y] = true
			end

			-- Check dead neighbors for birth
			local cells = {
				{ x+1, y }, { x-1, y }, { x, y+1 }, { x, y-1 },
				{ x+1, y+1 }, { x+1, y-1 }, { x-1, y+1 }, { x-1, y-1 }
			}
			for _, cell in ipairs(cells) do
				local cx, cy = cell[1], cell[2]
				if not cellAlive(cx, cy) and calculateCell(cx, cy) == 3 then
					new_cells[cx] = new_cells[cx] or {}
					new_cells[cx][cy] = true
				end
			end
		end

		if y_elements == 0 then
			table.insert(x_axis_pending_delete, x)
		end
	end

	for x in pairs(dead_cells) do
		for y in pairs(dead_cells[x]) do
			grid[x][y] = nil
		end
	end

	for _, x in ipairs(x_axis_pending_delete) do
		grid[x] = nil
	end

	for x in pairs(new_cells) do
		for y in pairs(new_cells[x]) do
			grid[x] = grid[x] or {}
			grid[x][y] = true
		end
	end
end

function calculateCell(x, y)
	local count = 0
	local neighbors = {
		{ x+1, y }, { x-1, y }, { x, y+1 }, { x, y-1 },
		{ x+1, y+1 }, { x+1, y-1 }, { x-1, y+1 }, { x-1, y-1 }
	}
	for _, cell in ipairs(neighbors) do
		if cellAlive(cell[1], cell[2]) then
			count = count + 1
		end
	end
	return count
end

function cellAlive(x, y)
	return grid[x] and grid[x][y]
end

function isGridEmpty()
	for x in pairs(grid) do
		for _ in pairs(grid[x]) do
			return false
		end
	end
	return true
end

function resetGrid()
	grid = mergeGrids(grid1, grid2)
	draw(true)
end

draw(true)
while true do
	os.sleep(0)
	nextGeneration()
	draw(false)

	if isGridEmpty() then
		os.sleep(1)
		resetGrid()
	end
end