This is my implementation of flowfree, a puzzle game based on forming
connections in a square grid.

Building it is relatively straightforward.  The Makefile isn't going to
work out of the box for you unless you have various other bits of my
infrastructure set up, but it _is_ a reasonable guide to, eg, what
files you will need to compile.  At this writing, there is only the one
source file, play.c, and it needs linking with -lX11 -lm, but the
Makefile is more likely to be kept updated than this README.

The source does use labeled control structure.  This means you will
need lcs-cvt or something like it (assuming you don't have LCS support
in your compiler, which is unlikely); at this writing, see
ftp.rodents-montreal.org:/mouse/local/src/lcs-cvt for that.  It also
uses nested functions, so you will most likely need gcc - I'm not aware
of any other compiler that supports nested functions, at least not for
any language that is otherwise basically C.  (In particular, clang/llvm
is under the impression they are little-used; however true that may be
in general, it is not true of my code.)  It also uses anonymous unions,
which as far as I know are a gcc feature; while they may be present in
other compilers, there are enough gccisms already that investigating
that in detail doesn't seem particularly worthwhile.

Once built, basic usage is to just run it with a puzzle specified as an
argument to -puzzle.  The syntax of the argument:

	SIZE PAIR PAIR PAIR...

SIZE is either a single number, for a square board, or two numbers
joined by an x, for a rectangular board (the first number is the X
dimension).

Each PAIR specifies one pair of endpoints you have to link to solve the
puzzle.  If the board is X by Y, and the endpoints are at (x1,y1) and
(x2,y2), then the number is x1 + (X * (y1 + (Y * (x2 + (X * y2))))).
For square grids, this can be thought of as a four-digit number in the
base which is the grid size (eg, for a 7x7 grid, base 7); for
rectangular grids, this calls for using different bases for different
digits, but with that note it's still a consistent point of view.

The file "levels" contains a number (300 at this writing) of levels.
Each line is a valid puzzle spec, ordered roughly by difficulty; a
reasonable first test after building might be

	% play -puzzle `head -1 < levels`

When making connections, you can use either click-drag-click or
push-drag-release; the game determines which you're using dynamically
based on the DragPixels, IgnoreDragTime, and MaxClickTime resource
values, the defaults for which you can find early in the code by
searching for those strings.  (The time values are in milliseconds.)
MaxClickTime is the longest time that can elapse between a press and a
release for the combination to be considered a click; if the time is
less than IgnoreDragTime, it will be considered a click anyway.  If the
time is greater than IgnoreDragTime but less than MaxClickTime, it is
considered a click if the pointer moves no more than DragPixels between
the press and the release.

To solve a level, not only does every pair of coloured endpoints have
to be connected, but also every cell of the grid must be occupied by
either endpoints or links.  At this writing, the game does not do
anything in particular when the puzzle is solved, though I hope to fix
that relatively soon.

/~\ The ASCII				  Mouse
\ / Ribbon Campaign
 X  Against HTML		mouse@rodents-montreal.org
/ \ Email!	     7D C8 61 52 5D E7 2D 39  4E F1 31 3E E8 B3 27 4B