My most recent game obsession is this enjoyable small-print game called Waters of Nereus. I won’t go into details about the game, but I enjoyed it enough to write my first game review. The thing I’ve most enjoyed about the game is that it’s tapped my creativity in two ways such that I’ve spent maybe sixty hours on two expansion projects.
Before going any further, note that this work is all based on other people’s hard copyrighted work. I have no problem scanning and reusing their images for personal use, and I’m happy to show you photos and rough screenshots, but I have no plans to make these cards generally available. (The expansion rules, not reusing copyrighted artwork, will be, and already is, available.)
Expansion 1
The first, and far simpler expansion, merely provides extra cards for indicating spots on a 5×5 grid. The game itself comes with six cards, each with a different pattern in each of the 25 cells, which is either on, or off. It doesn’t seem particularly advantageous to have more cards with more patterns, but whatever, I want it.
Look at the cards below. The four on the left are my prototypes, and the one on the right is an original. So, either my printer or scanner is losing color. That one doesn’t really bother me.
The patterns from the top two cards come from the original set, the bottom two are new ones I laid out. These four are part of a set of 24.)
I did all of this work in Gimp. As I said, the top two cards are in the original set. If you look at them, between the two of them all 25 water squares are filled. So within Gimp, I put those two images on two layers, and cut holes out of the top one where the lower icons are, and presto! I had a single image with all 25 spots filled.
And I can do the same thing with the negative spaces. Between the two cards, I can also compose a single image that was all background.
From there it was a matter of cutting out the patterns, 24 times. Or, not. Turns out Gimp has scripting! With Python! So, that was another four hours, just learning the ins and outs of the Gimp scripting API. The Python code is at the bottom of this post, because I am a huge nerd.
It wasn’t always easy. Sometimes I forgot to include the base image.
But persistence paid off and soon I had 24 computer-generated images
If you go back and look at the photo of the printed cards, you might get an idea how tricky the actual printing process can be. Those white borders on the edges. The wrinkling paper. The corners. Did you notice the corners? The original card has rounded corners. Scanning those images, I had to draw a reasonable looking corner to continue the image. I’m no professional, but I just wanted something … decent. So, that was another hour.
Even though I’ll probably get my hands on a corner cutter, it’s good to feel good about one’s effort.
Expansion 2
The second expansion I wanted was a decent solo automaton. Inspired by the automata for Scythe and Patchwork, I came up with a mechanism for defining actions through a deck of cards. I’ve never done anything like that before, and it took well over 20 hours of thinking, sketching, writing and play testing. I’ve still only play tested 3 times over those 20 hours of thinking and writing.
These card above were my original testing cards. They represent a set of rules that I abandoned part-way through for something I like much more. Rather than draw new cards every times the rules changed, I used the numbers in the bottom-right corner to look up actions in the rules document. It still needs more play testing, but rather than complete it, my mind wandered toward card design. I sketched ideas until finally setting on something like what you see on the right, below.
Rather than draw icons for everything, I scanned the game board, shown below. Almost every icon you see can be traced to that board.
And after hours, and hours, and hours of printing, testing, sizing, and learning features of Gimp I never knew existed, (Alpha To Selection is why you see the border around the 2 and 3, below,) I present my first four (not embarrassing) prototypes.
The post-artwork layout is done in Google Slides, which provide far more features than I expected. Still, Inkscape or Illustrator may not be far from my future.
The Card Backs
Like everything else, I scanned a card back to make my own backs. A reference card is on the left, my Automaton cards are in the middle, and extra pattern cards on the right.
More Sizing
Go back and look at the card backs on the right. They, like the pattern cards up at the top, have some extra white border. And that’s because I was relying too much on perfectly-sized artwork. (I also hadn’t yet filled in the corners, like you can see in the Automaton cards.)
To accommodate this, I added .03″ on all for edges. And that meant having to fill it in. Which I did.
Look at the two cards, above. The one on top is the original, with a rounded corner, and the one on the bottom is a printout with the expanded geography, which you can see along the bottom and sides. I even extended the chain links. And like before, those will probably disappear when I cut them, and nobody will ever notice, but, I’ll notice.
Finally
What a long slog. It’s not even done! I’ve still got plenty of construction ahead of me, and then I need to get down to decent printing and cutting. I’m relying on this great video web series called Dining Table Print & Play, and specifically this time, How to Make Playing Cards. I’ve purchased sticker sheets and a corner cutter, and have carefully laid out a template complete with cutting guides and folding guides. Looking at the image below, I already see a problem with the layout that’ll cost me at least an hour to fix.
Python!
from itertools import izip
xts = [128, 391, 645, 926, 1200]
xbs = [332, 591, 854, 1126, 1390]
yts = [155, 500, 825, 1196, 1549]
ybs = [384, 730, 1105, 1430, 1789]
def sel(img, x, y, mode = 2):
xc = xts[x-1]
yc = yts[y-1]
w = xbs[x-1] - xc
h = ybs[y-1] - yc
pdb.gimp_image_select_rectangle(img, mode, xc, yc, w, h)
def go(idx, l):
if len(gimp.image_list()) > 1:
raise "oof"
filename = "/tmp/images/img_%d.png" % idx
img = gimp.image_list()[0]
#
layer = pdb.gimp_image_get_layer_by_name(img, 'template')
copy = layer.copy()
img.add_layer(copy, 0)
img.active_layer = copy
#
drw = pdb.gimp_image_active_drawable(img)
it = iter(l)
pdb.gimp_selection_none(img)
for entry in izip(it, it):
sel(img, entry[0], entry[1], 0)
pdb.gimp_edit_cut(drw)
pdb.gimp_selection_clear(img)
#
new_image = pdb.gimp_image_duplicate(img)
layer = pdb.gimp_image_merge_visible_layers(new_image, CLIP_TO_IMAGE)
pdb.gimp_file_save(new_image, layer, filename, filename)
pdb.gimp_image_delete(new_image)
#
pdb.gimp_image_remove_layer(img,copy)
def parse(s, invert = None):
r = []
for c in s:
a = ord(c) - 97
row = (a / 5) + 1
col = (a % 5) + 1
if invert:
r.append(col)
r.append(row)
if not invert:
r.append(col)
return r
cards=[]
cards.append(parse("abdefjmptuvxy"))
cards.append(parse("bdfgijmpqstvx"))
cards.append(parse("bdgiklmnoqsvx"))
cards.append(parse("bdgiklmnoqsvx", True))
cards.append(parse("cfgijmpqstw"))
cards.append(parse("cfgijmpqstw", True))
cards.append(parse("cfghijmpqrstw"))
cards.append(parse("cfghijmpqrstw", True))
cards.append(parse("bcdgikmoqsvwx"))
cards.append(parse("bcdgikmoqsvwx", True))
cards.append(parse("aefgijmpqstuy"))
cards.append(parse("aefgijmpqstuy", True))
cards.append(parse("aegiklmnoqsuy"))
cards.append(parse("aegiklmnoqsuy", True))
cards.append(parse("aceghikmoqrsuwy"))
cards.append(parse("aceghikmoqrsuwy", True))
cards.append(parse("abdefgjpstuvxy"))
cards.append(parse("abdefijpqtuvxy"))
cards.append(parse("abcdeklmnouvwxy"))
cards.append(parse("cghiklnoqrsw"))
cards.append(parse("acefhjkmoprtuwy"))
cards.append(parse("bcdfjkmoptvwx"))
cards.append(parse("acegikmoqsuwy"))
cards.append(parse("bdfhjlnprtvx"))
for x in range(len(cards)):
go(x, cards[x])
Blatherberg 