ConwayLife.com

Code: Select all

#!/usr/bin/python
"""
This script converts hexagonal isotropic (possibly non-totalistic) CA rules[1]
into the equivalent MAP rules[2].  It runs under both Python 2 and Python 3, and
can be used either as a stand-alone script (with the rules given as command line
arguments) or run directly in Golly.  Posted[3] to github 27 Jan 2018 by vyznev[4].
Copy posted to forums (with these additional notes) 17 Mar 2018 [5].
[1]: http://www.conwaylife.com/wiki/Isotropic_non-totalistic_Life-like_cellular_automaton#Hexagonal_neighbourhood
[2]: http://golly.sourceforge.net/Help/Algorithms/QuickLife.html
[3]: http://conwaylife.com/forums/viewtopic.php?p=55715#p55715
[4]: https://gist.github.com/vyznev/0ef7eb2ac98645b284dc8e647f10d685
[5]: http://conwaylife.com/forums/viewtopic.php?f=7&t=3049&p=58058#p58058
"""

import re
from base64 import b64encode

def hex2map (rulestr, mapbits=7):
	"""
	Convert a hexagonal isotropic (possibly non-totalistic) CA rule string
	into the equivalent MAP rule.  By default, the result will be a 3+22
	character hex MAP rule string; to generate a 3+86 character rectangular
	MAP rule, use mapbits=9 instead of the default mapbits=7.
	"""

	# validate rule string format and extract the birth/survive strings
	match = re.match(
		"^\s*b((?:[0156]|[234]-?[omp]*)*)/s((?:[0156]|[234]-?[omp]*)*)h\s*$",
		rulestr.lower()
	)
	if not match:
		return None

	# initialize rule structure (list of lists of dicts)
	hexrule = [ [], [] ]
	for array in hexrule:
		for count in range(7):
			array.append({"o": 0, "m": 0, "p": 0})

	# set birth/survive bits in rule based on input string
	for oldstate in range(2):
		nhoods = match.group(oldstate + 1)
		for m in re.finditer("([0-6])(-?)([omp]*)", nhoods):
			count = int(m.group(1))
			negate = bool(m.group(2))
			letters = m.group(3)
			for letter in "omp":
				newstate = 0
				if letter in letters or not letters:
					newstate = 1
				if negate and letters:
					newstate = 1 - newstate
				hexrule[oldstate][count][letter] = newstate

	# convert hex rule to map rule
	maprule = bytearray(2**mapbits // 8)
	for mapindex in range(2**mapbits):
		bits = [ (mapindex >> i) & 1 for i in reversed(range(mapbits)) ]

		# reorder bits in clockwise order around the center cell
		if mapbits == 7:
			neighbors = [bits[i] for i in (0,1,4,6,5,2)]
			oldstate = bits[3]
		elif mapbits == 9:
			# ignore bits 2=NE and 6=SW
			neighbors = [bits[i] for i in (0,1,5,8,7,3)]
			oldstate = bits[4]
		else:
			raise NotImplementedError("only 7 and 9 bit MAPs are supported")

		count = sum(neighbors)

		# canonicalize neighbors so that the longest run of dead cells
		# comes first and the longest run of live cells comes last
		rotations = [neighbors, list(reversed(neighbors))]
		while len(rotations) < 12:
			neighbors.append(neighbors.pop(0))
			rotations += [neighbors, list(reversed(neighbors))]
		neighbors = min(rotations)

		# determine symmetry letter from longest run
		# (this always yields "o" for 0/1/5/6 neighbors)
		if count <= 3:
			maxgap = 0
			while maxgap < 6 and not neighbors[maxgap]:
				maxgap += 1
			letter = "omp"[6 - count - maxgap]
		else:
			maxrun = 0
			while maxrun < 6 and neighbors[5 - maxrun]:
				maxrun += 1
			letter = "omp"[count - maxrun]

		# set bit in map rule
		if hexrule[oldstate][count][letter]:
			maprule[mapindex // 8] |= (0x80 >> (mapindex % 8)) 

	# return base64 encoded map
	return "MAP" + b64encode(maprule).decode('ascii').strip("=")


if __name__ == '__main__':
	# looks like we're being run as a stand-alone script
	import argparse
	parser = argparse.ArgumentParser(description='Convert hex CA rule strings to MAP rules.')
	parser.add_argument('rule', nargs='+', help='input hex rule (e.g. B245/S3H or B2o/S2m34H)')
	parser.add_argument('-l', '--long-map', dest='mapbits', action='store_const', const=9, default=7,
		help='generate 3+86 character instead of 3+22 character MAP rules')
	args = parser.parse_args()
	for hexrule in args.rule:
		maprule = hex2map(hexrule, args.mapbits)
		if maprule:
			print(maprule)
		else:
			print(hexrule + " does not look like a valid hex rule. :(")
else:
	# assume we're being run as a Golly plug-in
	import golly as g
	prompt = "Enter hex rule (e.g. B245/S3H or B2o/S2m34H):"
	hexrule = "B2o/S2m34H"
	while True:
		hexrule = g.getstring(prompt, hexrule, "Set Hex Rule")
		maprule = hex2map(hexrule)
		if maprule:
			g.setrule(maprule)
			break
		else:
			prompt = "The string you entered does not appear to be a valid hex rule. Try again:"

Code: Select all

x = 270, y = 51, rule = MAPFAMgVwhXAP4AP4B+gH4A6A
17bo$17bobobo$17bo3b2o$20b2o$20bo$3bobo14b2o$3b4o13bob2o$4bo2bo12bo2bo
$5bobo15bo$5b4o$5bo2$o$obobo13bo$o3b2o12b3o$3b2o13bo2bo$3bo13b3ob2o$3b
2o15b2o$3bob2o14b2o$3bo2bo$6bo74bo$81bo$81bo2bo$81bo$82bo5$31b3o7b3o$
30b2o2bo5b3o2b2o219bo$31bo11bo222bobo$31b3o10bob2o220bo$31bobo10bo220b
2o$34bo232bobo$268b2o$268b2o$268bo5$12bo3$16b4o$15b2o$15b5o2$20bo$20bo
bo!

Code: Select all

x = 16, y = 16, rule = B3/S23
2o6bob3ob2o$3b2o3b2o2b2o$b5ob2o3bo$4b7o2b3o$bobob2ob5o2bo$o2bob2ob6obo
$o3bo3b3o4bo$o2bob3ob3obo$2o2b2o3bo4bo$6obob6o$b2o2b4o2b2o2bo$obobo2b
3obobobo$b4ob2o4b2o$bobobobob6o$ob2ob3o4bo2bo$o3bo5b2obobo!

Code: Select all

x = 31, y = 16, rule = B3/S23
obo13bo3bobobo3bobo$6bobo7bobo5bobo$2bobobobobo3bobo7bo$8bobobobobobob
o5bobobo$2bo3bo3bobo3bobobobobo5bo$o5bo3bobo3bobobobobobo3bo$o7bo7bobo
bo9bo$o5bo3bobobo3bobobo3bo$obo5bobo7bo9bo$obobobobobo3bo3bobobobobobo
$2bobo5bobobobo5bobo5bo$o3bo3bo5bobobo3bo3bo3bo$2bobobobo3bobo9bobo$2b
o3bo3bo3bo3bobobobobobo$o3bobo3bobobo9bo5bo$o7bo11bobo3bo3bo!

Code: Select all

x = 16, y = 31, rule = B3/S23
2o6bob3ob2o2$3b2o3b2o2b2o2$b5ob2o3bo2$4b7o2b3o2$bobob2ob5o2bo2$o2bob2o
b6obo2$o3bo3b3o4bo2$o2bob3ob3obo2$2o2b2o3bo4bo2$6obob6o2$b2o2b4o2b2o2b
o2$obobo2b3obobobo2$b4ob2o4b2o2$bobobobob6o2$ob2ob3o4bo2bo2$o3bo5b2obo
bo!

Code: Select all

x = 16, y = 15, rule = B2ci3ai4c8/S02ae3eijkq4iz5ar6i7e
6b2o6b2o$3b3obobobobobo$bo3bo4bo3bo$bo4b5o4bo$b2o3bo5bob2o$o2b2o2bobob
ob2o$2obobo2b2o2bo2bo$3bo2bo2bobobo$bobob3o2b2ob3o$2b2o4bo2b3obo$bo3bo
b3o2b2obo$4bobo2b2o4bo$bo3bob4o4bo$obob2o2bo$2ob2obob5o!