I improved the script and here it is!

`# Solid.py`

# Makes soups and runs oscar until a ship is found

# Seemingly stupid but actually very useful and fast

# Mainly used for searching "Solid" ships in LTL since soups of the right size

# produce only 1 object and separation is not needed so oscar can be run.

# Best fit for solid LTL rules that have lower period oscs that stabilize quicker but can also be used for larger ranges.

# Beeps when a ship is found.

# By Saka with oscar.py code from Andrew Trevorrow.

import golly as g

if len(g.getselrect()) == 0:

g.exit("No selection!")

else:

selection = g.getselrect()

g.new("Solid")

g.select(selection)

g.fitsel()

result = "Soup"

#maxGen = int(g.getstring("Maximum gens (To avoid expanding soups)")) # Maximum gens and population to avoid expanding soups

maxPop = (selection[2]*selection[3])*10 #This is much, much better

n = -1

while result != "S": #Old and not used anymore but whatever.

#g.setgen('0')

n += 1

if n % 100==0:

g.show(str(n)+" soups searched")

g.update()

g.reset()

g.randfill(50)

# The entire code of oscar.py :)

# Oscar is an OSCillation AnalyzeR for use with Golly.

# Author: Andrew Trevorrow (andrew@trevorrow.com), March 2006.

from glife import rect, pattern

from time import time

# --------------------------------------------------------------------

# initialize lists

hashlist = [] # for pattern hash values

genlist = [] # corresponding generation counts

poplist = [] # corresponding population counts

boxlist = [] # corresponding bounding boxes

# --------------------------------------------------------------------

def show_spaceship_speed(period, deltax, deltay):

# we found a moving oscillator

if (deltax == deltay) or (deltax == 0) or (deltay == 0):

speed = ""

if (deltax == 0) or (deltay == 0):

# orthogonal spaceship

if (deltax > 1) or (deltay > 1):

speed += str(deltax + deltay)

else:

# diagonal spaceship (deltax == deltay)

if deltax > 1:

speed += str(deltax)

if period == 1:

g.show("S")

g.exit("Found ship with speed " + speed + "c"+" after "+str(n)+" soups.")

else:

g.show("S")

g.exit("Found ship with speed " + speed + "c/" +str(period)+" after "+str(n)+" soups.")

else:

# deltax != deltay and both > 0

speed = str(deltay) + "," + str(deltax)

if period == 1:

g.show("S")

g.exit("Found knightship with speed " + speed + "c"+" after "+str(n)+" soups.")

else:

g.show("S")

g.exit("Found knightship with speed " + speed + "c/" + str(period)+" after "+str(n)+" soups.")

# --------------------------------------------------------------------

def oscillating():

# return True if the pattern is empty, stable or oscillating

# first get current pattern's bounding box

prect = g.getrect()

pbox = rect(prect)

if pbox.empty:

#g.show("The pattern is empty.")

return True

# get current pattern and create hash of "normalized" version -- ie. shift

# its top left corner to 0,0 -- so we can detect spaceships and knightships

h = g.hash(prect)

# check if outer-totalistic rule has B0 but not S8

rule = g.getrule().split(":")[0]

hasB0notS8 = rule.startswith("B0") and (rule.find("/") > 1) and not rule.endswith("8")

# determine where to insert h into hashlist

pos = 0

listlen = len(hashlist)

while pos < listlen:

if h > hashlist[pos]:

pos += 1

elif h < hashlist[pos]:

# shorten lists and append info below

del hashlist[pos : listlen]

del genlist[pos : listlen]

del poplist[pos : listlen]

del boxlist[pos : listlen]

break

else:

# h == hashlist[pos] so pattern is probably oscillating, but just in

# case this is a hash collision we also compare pop count and box size

if (int(g.getpop()) == poplist[pos]) and \

(pbox.wd == boxlist[pos].wd) and \

(pbox.ht == boxlist[pos].ht):

period = int(g.getgen()) - genlist[pos]

if hasB0notS8 and (period % 2 > 0) and (pbox == boxlist[pos]):

# ignore this hash value because B0-and-not-S8 rules are

# emulated by using different rules for odd and even gens,

# so it's possible to have identical patterns at gen G and

# gen G+p if p is odd

return False

if pbox == boxlist[pos]:

# pattern hasn't moved

if period == 1:

pass

#g.show("SL")

else:

pass

#g.show("OSC")

else:

deltax = abs(boxlist[pos].x - pbox.x)

deltay = abs(boxlist[pos].y - pbox.y)

show_spaceship_speed(period, deltax, deltay)

return True

else:

# look at next matching hash value or insert if no more

pos += 1

# store hash/gen/pop/box info at same position in various lists

hashlist.insert(pos, h)

genlist.insert(pos, int(g.getgen()))

poplist.insert(pos, int(g.getpop()))

boxlist.insert(pos, pbox)

return False

# --------------------------------------------------------------------

def fit_if_not_visible():

# fit pattern in viewport if not empty and not completely visible

r = rect(g.getrect())

if (not r.empty) and (not r.visible()): g.fit()

# --------------------------------------------------------------------

#g.show("Checking for oscillation... (hit escape to abort)")

oldsecs = time()

while not oscillating():

g.run(1)

newsecs = time()

#if newsecs - oldsecs >= 1.0: # show pattern every second

#oldsecs = newsecs

#fit_if_not_visible()

#g.update()

if int(g.getpop()) > maxPop: #If not: Use int(g.getgen()) > maxGen

break

Mostly just oscar.py

It has found quite a few ships, not released yet, still in my "Solid" folder.

How to use:

1. Use slowshipconvert.py in the top post (

here) to convert to the desired range.

2. (Optional) Tweak the limits a bit, +-5 or something.

3. Select an area to search. Make sure that a 50% fill of the area produces only 1 "donut" when you fill it or else oscar will get stuck if it finds a osc+ship or ship+ship. Expanding soups will be skipped using a "smart maxPop" I made.

4. Still selecting the area, run solid.py

5. Wait until a ship is found (It will beep because it uses g.exit)

TODO:

-Display approximate soups/sec

-After a set amount of failed soups, adjust the rule and start over

EDIT:

VERY FAST c/10o with a very thin core found with the script

`x = 28, y = 28, rule = R10,C0,M1,S154..256,B133..269,NM`

12b3o$11b6o$10bob3o$11b5o$11b6o$10b7o$9b9o$9b10o$8b12o$7b14o$5b18o2bo$

bo2b8o3b10obo$11o5b11o$11o6b11o$10o7b11o$11o6b11o$12o4b9obo$bo2b9ob9o$

6b16o$8b12o$9b10o$9b9o$10b8o$11b6o$11b5o$11b5o$11b6o$12b4o!

Turns out the original slow ship rule has a 2c/542o!

`x = 24, y = 25, rule = R10,C0,M1,S154..262,B133..265,NM`

10b6o$11b7o$6bo2b10o$5bob12o$4bob14o$3b18o$2b18o$b10o3b7o$9o6b7o$8o8b

6obo$7o10b7o$7o10b7o$7o10b7o$7o10b7o$ob6o9b7o$2b6o8b8o$3b6o6b9o$3b8o2b

10o$4b18o$3b16obo$4b14obo$5b11o2bo$6b9o$7b5o3bo$9b4o!