Script request thread

[yaochen2]

A program for searching for ancestors of a certain pattern that fit within a certain bounding box or have fewer than a certain amount of cells.

[dvgrn]

A program for searching for ancestors of a certain pattern that fit within a certain bounding box or have fewer than a certain amount of cells.

Have you tried JavaLifeSearch, or the older Windows version WLS? They can perform those tasks fairly well, depending on exactly what you want.

[creeperman7002]

Can rlifesrc have a feature that skips solutions containing non-interacting objects?

[Entity Valkyrie 2]

Is there a script that can turn a pattern into a static png?

[rowett]

Is there a script that can turn a pattern into a static png?

This Lua script will save the current pattern into Golly's temp folder as "pattern.png". Maximum pattern size is 4096 x 4096.

Code: Select all

-- Save current pattern as a PNG
--
-- Author:
--   Chris Rowett (crowett@gmail.com)

local g = golly()
local gp = require "gplus"
require "gplus.strict"

-- overlay
local ov = g.overlay
local overlaycreated = false

-- temporary file path
local temppath = g.getdir("temp")

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

local function savepng()
    -- get the bounding box of the pattern
    local box = g.getrect()
    if #box == 0 then
        g.note("There is no pattern.")
    else
        -- get the size of the pattern
        local x, y, wd, ht = table.unpack(box)
        local cwd = wd
        local cht = ht

        -- cellview width and height must be multiples of 16
        if cwd & 15 ~= 0 then
            cwd = ((cwd // 16) + 1) * 16
        end
        if cht & 15 ~= 0 then
            cht = ((cht // 16) + 1) * 16
        end

        -- check the width or height are not bigger than the cellview maximum
        if wd > 4096 or ht > 4096 then
            g.note("Pattern too big! Maximum is 4096x4096.")
        else
            -- create the overlay
            ov("create "..cwd.. " "..cht)
            overlaycreated = true
    
            -- draw the pattern onto the overlay
            ov("cellview "..x.." "..y.." "..cwd.." "..cht)
            ov("drawcells")
            ov("update")
    
            -- save the overlay as a PNG
            local savefile = temppath.."pattern.png"
            ov("save 0 0 "..wd.." "..ht.." "..savefile)
    
            -- delete overlay
            ov("delete")
            g.update()
            overlaycreated = false
    
            g.note("Saved pattern of size "..wd.."x"..ht.." to "..savefile)
        end
    end
end

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

local status, err = xpcall(savepng, gp.trace)
if err then g.continue(err) end

-- this code is always executed, even after escape/error;
-- clear message line in case there was no escape/error
g.check(false)
if overlaycreated then ov("delete") end

[GUYTU6J]

Is there a script that can turn a pattern into a static png?

LifeWiki Help:Images says that you can just use the standard giffer.py with Number of generations = 1, then open the resulting .gif in any image-editing program and save as .png.
BTW in Special:UnusedFiles you can see lots of blur gray-background images (both static and animated) by exactly you. Would you mind deleting them so as to save storage space?

[Cyclotrons]

Would anyone mind writing a script that enumerates every collision of 2 of a given ship?

[yujh]

Would anyone mind writing a script that enumerates every collision of 2 of a given ship?

I think there was one; but I can’t remember what it is.

[goldenratio]

Would anyone mind writing a script that enumerates every collision of 2 of a given ship?

Here you go! Note that this only works on diagonal ships. (I'm making one for orthogonal ships.) Before using, make a layer with the ship you want to collide traveling southwest.

Code: Select all

import golly as g

shippattern = g.getcells(g.getrect())
layerindex = g.getlayer()
collideship = []
popseq1 = []
popseq2 = []
g.addlayer()
g.setname("Ship collider space")
g.putcells(shippattern)
box = g.getrect()
g.select(g.getrect())
g.flip(1)
# For perpendicular collisions
flipship = g.getcells(g.getrect())
g.addlayer()
g.setname("Ship evolving space")
g.putcells(flipship)
g.addlayer()
g.setname("Collisions")
g.setlayer(layerindex + 2)

# Find the spaceship period
shiphash = g.hash(g.getrect())
period = 0
while True:
    g.run(1)
    period += 1
    if g.hash(g.getrect()) == shiphash:
        break
    if period > 500:
        g.exit("Period is too large! Are you sure the pattern is a spaceship?")
        
g.reset()
shipseq = [0] * period
def clear_layer():
    r = g.getrect()
    if r:
        g.select(r)
        g.clear(0)
    return

# Checks if two spaceships interact.
def interact():
    popseq = [[0] * 10] * period
    for j in range(10):
        for i in range(period):
            g.run(1)
            popseq[i][j] = int(g.getpop())
    notequal = False
    for j in range(10):
        for i in range(period):
            if popseq[i][j] != shipseq[i]:
                notequal = True
    if notequal == False:
        return False
    else:
        return True
    g.reset()
    
# Enumerating collisions
def putcollision(orientation, i, j):
    if interact() == True:
        g.reset()
        collision = g.getcells(g.getrect())
        g.setlayer(layerindex + 3)
        if orientation == 0:
            g.putcells(collision, 100 * j, - 100 * i)
        else:
            g.putcells(collision, 100 * j, 100 * i + 100)
        g.setlayer(layerindex + 1)
    g.reset()
    
def makecollision():
    g.setlayer(layerindex + 1)
    for i in range(period):
        g.setlayer(layerindex + 2)
        g.run(1)
        collideship = g.getcells(g.getrect())
        g.setlayer(layerindex + 1)
        clear_layer()
        g.putcells(shippattern)
        g.putcells(collideship, 500, 500)
        for k in range(period):
            shipseq[k] = int(g.getpop())
        for j in range(box[2] * 8):
            g.reset()
            clear_layer()
            # Perpendicular collisions
            g.putcells(shippattern, 0, 0)
            g.putcells(collideship, j - 3 * box[2], box[3] + 3)
            putcollision(0, i, j)
            # Head-on collisions
            g.select(box)
            g.flip(0)
            putcollision(1, i, j)
            
def deletelayers():
    g.setlayer(layerindex + 1)
    g.dellayer()
    g.setlayer(layerindex + 1)
    g.dellayer()
    
makecollision()
deletelayers()

Note that this makes a lot of layers, so hopefully you don't have too many open before running the script.

For larger ships, lines 45, 46, and 51 might need to be modified to allow later interactions.

[PC101]

Can someone make a script that generates collisions between a NW travelling glider and 2 upward travelling LWSSs? And before it generates those collisions it

Can someone make a script that does this?
Step 1: Generate all combinations of 2 upward LWSSs at a certain distance from each other (they can also be different phases from each other).
Step 2: Generate all combinations of a NW travelling glider colliding with all the combinations of the upward LWSS generated from the previous step.
Step 3: Filter the output of step 2 so the only combinations left from step 2are ones where a NW glider collides with an LWSS pair, then gets reflected into a NE travelling glider without any leftover ash.

Example of a combination of 2 Upward LWSSs + NW glider = NE glider:

Code: Select all

x = 9, y = 17, rule = B3/S23
7b2o$6b2o$8bo$bo$3o$ob2o$b3o$b2o5$3bo$2b3o$2bob2o$3b3o$3b2o!

EDIT March 12: I was finally able to get gencols working so I will use gencols for each step.

[LaundryPizza03]

A script to convert EnumPattEvo output to an sss file. Attached is a partial sample run which found 373 ships in a B2a rulespace.

Output - EnumPattEvo.txt

(32.02 KiB) Downloaded 3 times