print.py

   1 #!/usr/bin/env python
   2
   3 # This program accepts a series of newline-separated game IDs on
   4 # stdin and formats them into PostScript to be printed out. You
   5 # specify using command-line options which game the IDs are for,
   6 # and how many you want per page.
   7
   8 # Supported games are those which are sensibly solvable using
   9 # pencil and paper: Rectangles, Pattern and Solo.
  10
  11 # Command-line syntax is
  12 #
  13 #     print.py <game-name> <format>
  14 #
  15 # <game-name> is one of `rect', `rectangles', `pattern', `solo'.
  16 # <format> is two numbers separated by an x: `2x3', for example,
  17 # means two columns by three rows.
  18 #
  19 # The program will then read game IDs from stdin until it sees EOF,
  20 # and generate as many PostScript pages on stdout as it needs.
  21 #
  22 # The resulting PostScript will automatically adapt itself to the
  23 # size of the clip rectangle, so that the puzzles are sensibly
  24 # distributed across whatever paper size you decide to use.
  25
  26 import sys
  27 import string
  28 import re
  29
  30 class Holder:
  31     pass
  32
  33 def psvprint(h, a):
  34     for i in xrange(len(a)):
  35         h.s = h.s + str(a[i])
  36         if i < len(a)-1:
  37             h.s = h.s + " "
  38         else:
  39             h.s = h.s + "\n"
  40
  41 def psprint(h, *a):
  42     psvprint(h, a)
  43
  44 def rect_format(s):
  45     # Parse the game ID.
  46     ret = Holder()
  47     ret.s = ""
  48     params, seed = string.split(s, ":")
  49     w, h = map(string.atoi, string.split(params, "x"))
  50     grid = []
  51     while len(seed) > 0:
  52         if seed[0] in '_'+string.lowercase:
  53             if seed[0] in string.lowercase:
  54                 grid.extend([-1] * (ord(seed[0]) - ord('a') + 1))
  55             seed = seed[1:]
  56         elif seed[0] in string.digits:
  57             ns = ""
  58             while len(seed) > 0 and seed[0] in string.digits:
  59                 ns = ns + seed[0]
  60                 seed = seed[1:]
  61             grid.append(string.atoi(ns))
  62     assert w * h == len(grid)
  63     # I'm going to arbitrarily choose to use 7pt text for the
  64     # numbers, and a 14pt grid pitch.
  65     textht = 7
  66     gridpitch = 14
  67     # Set up coordinate system.
  68     pw = gridpitch * w
  69     ph = gridpitch * h
  70     ret.coords = (pw/2, pw/2, ph/2, ph/2)
  71     psprint(ret, "%g %g translate" % (-ret.coords[0], -ret.coords[2]))
  72     # Draw the internal grid lines, _very_ thin (the player will
  73     # need to draw over them visibly).
  74     psprint(ret, "newpath 0.01 setlinewidth")
  75     for x in xrange(1,w):
  76         psprint(ret, "%g 0 moveto 0 %g rlineto" % (x * gridpitch, h * gridpitch))
  77     for y in xrange(1,h):
  78         psprint(ret, "0 %g moveto %g 0 rlineto" % (y * gridpitch, w * gridpitch))
  79     psprint(ret, "stroke")
  80     # Draw round the grid exterior, much thicker.
  81     psprint(ret, "newpath 1.5 setlinewidth")
  82     psprint(ret, "0 0 moveto 0 %g rlineto %g 0 rlineto 0 %g rlineto" % \
  83     (h * gridpitch, w * gridpitch, -h * gridpitch))
  84     psprint(ret, "closepath stroke")
  85     # And draw the numbers.
  86     psprint(ret, "/Helvetica findfont %g scalefont setfont" % textht)
  87     for y in xrange(h):
  88         for x in xrange(w):
  89             n = grid[y*w+x]
  90             if n > 0:
  91                 psprint(ret, "%g %g (%d) ctshow" % \
  92                 ((x+0.5)*gridpitch, (h-y-0.5)*gridpitch, n))
  93     return ret.coords, ret.s
  94
  95 def pattern_format(s):
  96     ret = Holder()
  97     ret.s = ""
  98     # Parse the game ID.
  99     params, seed = string.split(s, ":")
 100     w, h = map(string.atoi, string.split(params, "x"))
 101     rowdata = map(lambda s: string.split(s, "."), string.split(seed, "/"))
 102     assert len(rowdata) == w+h
 103     # I'm going to arbitrarily choose to use 7pt text for the
 104     # numbers, and a 14pt grid pitch.
 105     textht = 7
 106     gridpitch = 14
 107     gutter = 8 # between the numbers and the grid
 108     # Find the maximum number of numbers in each dimension, to
 109     # determine the border size required.
 110     xborder = reduce(max, map(len, rowdata[w:]))
 111     yborder = reduce(max, map(len, rowdata[:w]))
 112     # Set up coordinate system. I'm going to put the origin at the
 113     # _top left_ of the grid, so that both sets of numbers get
 114     # drawn the same way.
 115     pw = (w + xborder) * gridpitch + gutter
 116     ph = (h + yborder) * gridpitch + gutter
 117     ret.coords = (xborder * gridpitch + gutter, w * gridpitch, \
 118     yborder * gridpitch + gutter, h * gridpitch)
 119     # Draw the internal grid lines. Every fifth one is thicker, as
 120     # a visual aid.
 121     psprint(ret, "newpath 0.1 setlinewidth")
 122     for x in xrange(1,w):
 123         if x % 5 != 0:
 124             psprint(ret, "%g 0 moveto 0 %g rlineto" % (x * gridpitch, -h * gridpitch))
 125     for y in xrange(1,h):
 126         if y % 5 != 0:
 127             psprint(ret, "0 %g moveto %g 0 rlineto" % (-y * gridpitch, w * gridpitch))
 128     psprint(ret, "stroke")
 129     psprint(ret, "newpath 0.75 setlinewidth")
 130     for x in xrange(5,w,5):
 131         psprint(ret, "%g 0 moveto 0 %g rlineto" % (x * gridpitch, -h * gridpitch))
 132     for y in xrange(5,h,5):
 133         psprint(ret, "0 %g moveto %g 0 rlineto" % (-y * gridpitch, w * gridpitch))
 134     psprint(ret, "stroke")
 135     # Draw round the grid exterior.
 136     psprint(ret, "newpath 1.5 setlinewidth")
 137     psprint(ret, "0 0 moveto 0 %g rlineto %g 0 rlineto 0 %g rlineto" % \
 138     (-h * gridpitch, w * gridpitch, h * gridpitch))
 139     psprint(ret, "closepath stroke")
 140     # And draw the numbers.
 141     psprint(ret, "/Helvetica findfont %g scalefont setfont" % textht)
 142     for i in range(w+h):
 143         ns = rowdata[i]
 144         if i < w:
 145             xo = (i + 0.5) * gridpitch
 146             yo = (gutter + 0.5 * gridpitch)
 147         else:
 148             xo = -(gutter + 0.5 * gridpitch)
 149             yo = ((i-w) + 0.5) * -gridpitch
 150         for j in range(len(ns)-1, -1, -1):
 151             psprint(ret, "%g %g (%s) ctshow" % (xo, yo, ns[j]))
 152             if i < w:
 153                 yo = yo + gridpitch
 154             else:
 155                 xo = xo - gridpitch
 156     return ret.coords, ret.s
 157
 158 def solo_format(s):
 159     ret = Holder()
 160     ret.s = ""
 161     # Parse the game ID.
 162     params, seed = string.split(s, ":")
 163     c, r = map(string.atoi, string.split(params, "x"))
 164     cr = c*r
 165     grid = []
 166     while len(seed) > 0:
 167         if seed[0] in '_'+string.lowercase:
 168             if seed[0] in string.lowercase:
 169                 grid.extend([-1] * (ord(seed[0]) - ord('a') + 1))
 170             seed = seed[1:]
 171         elif seed[0] in string.digits:
 172             ns = ""
 173             while len(seed) > 0 and seed[0] in string.digits:
 174                 ns = ns + seed[0]
 175                 seed = seed[1:]
 176             grid.append(string.atoi(ns))
 177     assert cr * cr == len(grid)
 178     # I'm going to arbitrarily choose to use 9pt text for the
 179     # numbers, and a 16pt grid pitch.
 180     textht = 9
 181     gridpitch = 16
 182     # Set up coordinate system.
 183     pw = ph = gridpitch * cr
 184     ret.coords = (pw/2, pw/2, ph/2, ph/2)
 185     psprint(ret, "%g %g translate" % (-ret.coords[0], -ret.coords[2]))
 186     # Draw the thin internal grid lines.
 187     psprint(ret, "newpath 0.1 setlinewidth")
 188     for x in xrange(1,cr):
 189         if x % r != 0:
 190             psprint(ret, "%g 0 moveto 0 %g rlineto" % (x * gridpitch, cr * gridpitch))
 191     for y in xrange(1,cr):
 192         if y % c != 0:
 193             psprint(ret, "0 %g moveto %g 0 rlineto" % (y * gridpitch, cr * gridpitch))
 194     psprint(ret, "stroke")
 195     # Draw the thicker internal grid lines.
 196     psprint(ret, "newpath 1 setlinewidth")
 197     for x in xrange(r,cr,r):
 198         psprint(ret, "%g 0 moveto 0 %g rlineto" % (x * gridpitch, cr * gridpitch))
 199     for y in xrange(c,cr,c):
 200         psprint(ret, "0 %g moveto %g 0 rlineto" % (y * gridpitch, cr * gridpitch))
 201     psprint(ret, "stroke")
 202     # Draw round the grid exterior, thicker still.
 203     psprint(ret, "newpath 1.5 setlinewidth")
 204     psprint(ret, "0 0 moveto 0 %g rlineto %g 0 rlineto 0 %g rlineto" % \
 205     (cr * gridpitch, cr * gridpitch, -cr * gridpitch))
 206     psprint(ret, "closepath stroke")
 207     # And draw the numbers.
 208     psprint(ret, "/Helvetica findfont %g scalefont setfont" % textht)
 209     for y in xrange(cr):
 210         for x in xrange(cr):
 211             n = grid[y*cr+x]
 212             if n > 0:
 213                 if n > 9:
 214                     s = chr(ord('a') + n - 10)
 215                 else:
 216                     s = chr(ord('0') + n)
 217                 psprint(ret, "%g %g (%s) ctshow" % \
 218                 ((x+0.5)*gridpitch, (cr-y-0.5)*gridpitch, s))
 219     return ret.coords, ret.s
 220
 221 formatters = {
 222 "rect": rect_format,
 223 "rectangles": rect_format,
 224 "pattern": pattern_format,
 225 "solo": solo_format
 226 }
 227
 228 if len(sys.argv) < 3:
 229     sys.stderr.write("print.py: expected two arguments (game and format)\n")
 230     sys.exit(1)
 231
 232 formatter = formatters.get(sys.argv[1], None)
 233 if formatter == None:
 234     sys.stderr.write("print.py: unrecognised game name `%s'\n" % sys.argv[1])
 235     sys.exit(1)
 236
 237 try:
 238     format = map(string.atoi, string.split(sys.argv[2], "x"))
 239 except ValueError, e:
 240     format = []
 241 if len(format) != 2:
 242     sys.stderr.write("print.py: expected format such as `2x3' as second" \
 243     + " argument\n")
 244     sys.exit(1)
 245
 246 xx, yy = format
 247 ppp = xx * yy # puzzles per page
 248
 249 ids = []
 250 while 1:
 251     s = sys.stdin.readline()
 252     if s == "": break
 253     if s[-1:] == "\n": s = s[:-1]
 254     ids.append(s)
 255
 256 pages = int((len(ids) + ppp - 1) / ppp)
 257
 258 # Output initial DSC stuff.
 259 print "%!PS-Adobe-3.0"
 260 print "%%Creator: print.py from Simon Tatham's Puzzle Collection"
 261 print "%%DocumentData: Clean7Bit"
 262 print "%%LanguageLevel: 1"
 263 print "%%Pages:", pages
 264 print "%%DocumentNeededResources:"
 265 print "%%+ font Helvetica"
 266 print "%%DocumentSuppliedResources: procset Puzzles 0 0"
 267 print "%%EndComments"
 268 print "%%BeginProlog"
 269 print "%%BeginResource: procset Puzzles 0 0"
 270 print "/ctshow {"
 271 print "  3 1 roll"
 272 print "  newpath 0 0 moveto (X) true charpath flattenpath pathbbox"
 273 print "  3 -1 roll add 2 div 3 1 roll pop pop sub moveto"
 274 print "  dup stringwidth pop 0.5 mul neg 0 rmoveto show"
 275 print "} bind def"
 276 print "%%EndResource"
 277 print "%%EndProlog"
 278 print "%%BeginSetup"
 279 print "%%IncludeResource: font Helvetica"
 280 print "%%EndSetup"
 281
 282 # Now do each page.
 283 puzzle_index = 0;
 284
 285 for i in xrange(1, pages+1):
 286     print "%%Page:", i, i
 287     print "save"
 288
 289     # Do the drawing for each puzzle, giving a set of PS fragments
 290     # and bounding boxes.
 291     fragments = [['' for i in xrange(xx)] for i in xrange(yy)]
 292     lrbound = [(0,0) for i in xrange(xx)]
 293     tbbound = [(0,0) for i in xrange(yy)]
 294
 295     for y in xrange(yy):
 296         for x in xrange(xx):
 297             if puzzle_index >= len(ids):
 298                 break
 299             coords, frag = formatter(ids[puzzle_index])
 300             fragments[y][x] = frag
 301             lb, rb = lrbound[x]
 302             lrbound[x] = (max(lb, coords[0]), max(rb, coords[1]))
 303             tb, bb = tbbound[y]
 304             tbbound[y] = (max(tb, coords[2]), max(bb, coords[3]))
 305             puzzle_index = puzzle_index + 1
 306
 307     # Now we know the sizes of everything, do the drawing in such a
 308     # way that we provide equal gutter space at the page edges and
 309     # between puzzle rows/columns.
 310     for y in xrange(yy):
 311         for x in xrange(xx):
 312             if len(fragments[y][x]) > 0:
 313                 print "gsave"
 314                 print "clippath flattenpath pathbbox pop pop translate"
 315                 print "clippath flattenpath pathbbox 4 2 roll pop pop"
 316                 # Compute the total height of all puzzles, which
 317                 # we'll use it to work out the amount of gutter
 318                 # space below this puzzle.
 319                 htotal = reduce(lambda a,b:a+b, map(lambda (a,b):a+b, tbbound), 0)
 320                 # Now compute the total height of all puzzles
 321                 # _below_ this one, plus the height-below-origin of
 322                 # this one.
 323                 hbelow = reduce(lambda a,b:a+b, map(lambda (a,b):a+b, tbbound[y+1:]), 0)
 324                 hbelow = hbelow + tbbound[y][1]
 325                 print "%g sub %d mul %d div %g add exch" % (htotal, yy-y, yy+1, hbelow)
 326                 # Now do all the same computations for width,
 327                 # except we need the total width of everything
 328                 # _before_ this one since the coordinates work the
 329                 # other way round.
 330                 wtotal = reduce(lambda a,b:a+b, map(lambda (a,b):a+b, lrbound), 0)
 331                 # Now compute the total height of all puzzles
 332                 # _below_ this one, plus the height-below-origin of
 333                 # this one.
 334                 wleft = reduce(lambda a,b:a+b, map(lambda (a,b):a+b, lrbound[:x]), 0)
 335                 wleft = wleft + lrbound[x][0]
 336                 print "%g sub %d mul %d div %g add exch" % (wtotal, x+1, xx+1, wleft)
 337                 print "translate"
 338                 sys.stdout.write(fragments[y][x])
 339                 print "grestore"
 340
 341     print "restore showpage"
 342
 343 print "%%EOF"