Provided by: sgt-puzzles_8692-1_i386

#### NAME

```       map - map colouring game

```

#### SYNOPSIS

```       map   [--generate   n]  [--print  wxh  [--with-solutions]  [--scale  n]
[--colour]] [game-parameters|game-ID|random-seed]

map --version

```

#### DESCRIPTION

```       You are given a map consisting of a number of regions. Your task is  to
colour  each region with one of four colours, in such a way that no two
regions sharing a boundary have the same colour. You are provided  with
some  regions already coloured, sufficient to make the remainder of the
solution unique.

Only regions which  share  a  length  of  border  are  required  to  be
different  colours.  Two regions which meet at only one point (i.e. are
diagonally separated) may be the same colour.

I believe this puzzle is original; I’ve never seen an implementation of
it  anywhere else. The concept of a four-colouring puzzle was suggested
by Owen Dunn; credit must also go to Nikoli and  to  Verity  Allan  for
inspiring  the  train  of  thought  that  led  to  me  realising Owen’s
suggestion was a viable puzzle. Thanks also to Gareth Taylor  for  many
detailed suggestions.

```

#### Mapcontrols

```       To  colour  a region, click the left mouse button on an existing region
of the desired colour and drag that colour into the new region.

(The program will always ensure the starting puzzle has  at  least  one
region of each colour, so that this is always possible!)

If  you  need  to clear a region, you can drag from an empty region, or
from the puzzle boundary if there are no empty regions left.

Dragging a colour using the right mouse button will stipple the  region
in  that colour, which you can use as a note to yourself that you think
the region might be that colour.  A  region  can  contain  stipples  in
multiple  colours  at  once.  (This  is  often  useful  at  the  harder
difficulty levels.)

You can also use the cursor keys to move around the map: the colour  of
the  cursor  indicates the position of the colour you would drag (which
is not obvious if you’re on a region’s boundary, since  it  depends  on
the  direction  from  which  you approached the boundary). Pressing the
return key starts a drag of that colour, as above,  which  you  control
with  the cursor keys; pressing the return key again finishes the drag.
The space bar can be  used  similarly  to  create  a  stippled  region.
Double-pressing  the  return key (without moving the cursor) will clear
the region, as a drag from an empty region does: this  is  useful  with
the  cursor  mode  if  you  have  filled  the entire map in but need to
correct the layout.

If you press L during play, the game will toggle display of a number in
each  region  of  the  map.  This  is  useful  if you want to discuss a
having an unambiguous name for each region is much easier than trying to refer to them all by names such as âthe one down and right of the brown one on the top borderâ.
particular  puzzle  instance  with  a  friend  â.PP  (All  the  actions
described below are also available.)

```

#### Mapparameters

```       These  parameters  are  available from the â.IP "Width, Height" Size of
grid in squares.

Regions
Number of regions in the generated map.

Difficulty
In â.RS
In â.RE

```

#### Commonactions

```       These actions are all available from the â.PP (On Mac OS X, to  conform
with  local user interface standards, these actions are situated on the
â.IP "New game (âStarts a new game, with a random initial state.

Restart game
Resets the current game to  its  initial  state.  (This  can  be
undone.)

Save   Saves the current state of your game to a file on disk.

(so you can save, reload, and still Undo and Redo things you had
done before saving).

Print  Where  supported (currently only on Windows), brings up a dialog
allowing you to print an arbitrary number  of  puzzles  randomly
generated  from the current parameters, optionally including the
current puzzle. (Only for puzzles which make sense to print,  of
course   -   it’s   hard   to  think  of  a  sensible  printable
representation of Fifteen!)

Uâ, Ctrl+âZâ, Ctrl+â_â)                                            Undo
(â.
Undoes  a  single move. (You can undo moves back to the start of
the session.)

Râ, Ctrl+âRâ)                                                      Redo
(â.
Redoes a previously undone move.

Copy   Copies  the  current state of your game to the clipboard in text
format, so that you can paste it into (say) an e-mail client  or
a  web  message board if you’re discussing the game with someone
else. (Not all games support this feature.)

Solve  Transforms the puzzle instantly into its solved state. For  some
games  (Cube) this feature is not supported at all because it is
of no particular use. For other games  (such  as  Pattern),  the
solved  state  can be used to give you information, if you can’t
see how a solution can exist at all or you want  to  know  where
you  made  a  mistake.  For still other games (such as Sixteen),
automatic solution tells you nothing about how  to  get  to  the
solution,  but it does provide a useful way to get there quickly
so  that  you  can   experiment   with   set-piece   moves   and
transformations.

Some  games  (such as Solo) are capable of solving a game ID you
have typed in from elsewhere. Other games (such  as  Rectangles)
cannot  solve  a  game  ID they didn’t invent themself, but when
they did invent the game ID  they  know  what  the  solution  is
already.  Still  other  games  (Pattern) can solve some external
game IDs, but only if they aren’t too difficult.
The â.RE

Qâ,
Ctrl+âQâ)
Quit (â.
Closes the application entirely.

```

#### SpecifyinggameswiththegameID

```       There are two ways to save a game specification out  of  a  puzzle  and
recreate  it  later, or recreate it in somebody else’s copy of the same
puzzle.
The â.PP You can enter either of these pieces of  text  back  into  the
program (via the same â.PP The difference between the two forms is that
a descriptive game ID is a literal description of the initial state  of
the game, whereas a random seed is just a piece of arbitrary text which
was provided as input to the random number generator used to create the
puzzle. This means that:

â.
Descriptive game IDs tend to be longer in many puzzles (although
some,  such  as   Cube   (cube(6)),   only   need   very   short
descriptions).  So  a random seed is often a quicker way to note
down the puzzle you’re currently  playing,  or  to  tell  it  to
somebody else so they can play the same one as you.

â.
Any  text  at  all  is  a  valid  random seed. The automatically
generated ones are fifteen-digit numbers, but anything will  do;
you  can type in your full name, or a word you just made up, and
a valid puzzle will be generated from it. This  provides  a  way
for  two or more people to race to complete the same puzzle: you
think of a random seed, then everybody types it in at  the  same
time,  and  nobody  has  an  advantage  due  to  having seen the
generated puzzle before anybody else.

â.
It is often possible to convert puzzles from other sources (such
"
as  â.IP  "âRandom  seeds are not guaranteed to produce the same
result if you use them with a different version  of  the  puzzle
program.  This  is  because  the generation algorithm might have
been improved or modified in later versions  of  the  code,  and
will  therefore  produce  a different result when given the same
sequence of random numbers. Use a descriptive  game  ID  if  you
aren’t  sure  that  it  will  be used on the same version of the
program as yours.
(Use the â.RE

A descriptive game ID starts with a piece of text which  encodes
the  parameters  of  the  current game (such as grid size). Then
there is a colon, and after  that  is  the  description  of  the
game’s initial state. A random seed starts with a similar string
of parameters, but then it contains  a  hash  sign  followed  by
arbitrary data.

If you enter a descriptive game ID, the program will not be able
to show you the random seed which generated it, since it  wasn’t
generated  from  a  random  seed.  If  you  enter a random seed,
however, the program will be able to show  you  the  descriptive
game ID derived from that random seed.

Note  that  the  game parameter strings are not always identical
between the two forms. For some games, there will  be  parameter
data  provided with the random seed which is not included in the
descriptive game ID. This is because that parameter  information
is  only  relevant  when  generating  puzzle  grids,  and is not
important when playing them. Thus, for example,  the  difficulty
level in Solo (solo(6)) is not mentioned in the descriptive game
ID.

These additional parameters are also not set permanently if  you
type  in  a  game  ID. For example, suppose you have Solo set to
â.SH "The â.PP The â.PP The â.SH "Specifying game parameters  on
the command line"

(This section does not apply to the Mac OS X version.)

The  games  in  this  collection  deliberately  do not ever save
information on to the computer they run on: they  have  no  high
score tables and no saved preferences. (This is because I expect
at least some people to play them at work, and those people will
probably appreciate leaving as little evidence as possible!)

However,  if  you  do  want to arrange for one of these games to
default to a particular set of parameters, you can specify  them
on the command line.

The  easiest way to do this is to set up the parameters you want
using the â.PP If you run the game with just that parameter text
on  the  command  line,  it  will start up with the settings you
specified.

Octahedronâ from the âTypeâ menu, and then go to the game ID selection, you will see a string of the form âo2x2#338686542711620â. Take only the part before the hash (âo2x2â), and start Cube with that text on the command line: âcube o2x2â.
For example: if you run Cube (see cube(6)), select â.PP  If  you
copy  the  entire  game ID on to the command line, the game will
start up in the  specific  game  that  was  described.  This  is
occasionally a more convenient way to start a particular game ID
than by pasting it into the game ID selection box.
(You could also retrieve the encoded game parameters  using  the
â.SH "Unix command-line options"

(This section only applies to the Unix port.)

In  addition  to  being  able  to specify game parameters on the
command line (see above), there are various other options:

--game

--load These options respectively determine whether the command-
line argument is treated as specifying game parameters or
a save file to load. Only one  should  be  specified.  If
neither  of  these  options is specified, a guess is made
based on the format of the argument.

--generate n
If this option is specified, instead of  a  puzzle  being
displayed,  a  number  of  descriptive  game  IDs will be
invented and printed on standard output. This  is  useful
for  gaining  access  to  the  game generation algorithms
without necessarily using the frontend.

If game parameters are  specified  on  the  command-line,
they  will  be used to generate the game IDs; otherwise a
default set of parameters will be used.

The most common use of this option is in conjunction with
--print,   in   which  case  its  behaviour  is  slightly
different; see below.

--print wxh
If this option is specified, instead of  a  puzzle  being
displayed,  a  printed  representation  of  one  or  more
unsolved  puzzles  is  sent  to   standard   output,   in
PostScript format.

On  each  page  of  puzzles, there will be w across and h
down. If there are more puzzles than wÃh, more  than  one
page will be printed.

If  --generate has also been specified, the invented game
IDs  will  be  used  to  generate  the  printed   output.
Otherwise,  a  list  of  game IDs is expected on standard
input (which can be  descriptive  or  random  seeds;  see
above), in the same format produced by --generate.

For example:

net --generate 12 --print 2x3 7x7w | lpr

will  generate  two pages of printed Net puzzles (each of
which will have a 7Ã7 wrapping grid), and pipe the output
to  the lpr command, which on many systems will send them
to an actual printer.

There are various other options  which  affect  printing;
see below.

--save file-prefix [ --save-suffix file-suffix ]
If  this  option  is specified, instead of a puzzle being
displayed, saved-game files  for  one  or  more  unsolved
puzzles   are  written  to  files  constructed  from  the
supplied prefix and/or suffix.

If --generate has also been specified, the invented  game
IDs   will  be  used  to  generate  the  printed  output.
Otherwise, a list of game IDs  is  expected  on  standard
input  (which  can  be  descriptive  or random seeds; see
above), in the same format produced by --generate.

For example:

net --generate 12 --save game --save-suffix .sav

will generate twelve Net saved-game files with the  names
game0.sav to game11.sav.

--version
Prints  version  information  about  the  game,  and then
quits.

The following options are only meaningful  if  --print  is  also
specified:

--with-solutions
The  set  of  pages  filled with unsolved puzzles will be
followed by the solutions to those puzzles.

--scale n
Adjusts how big  each  puzzle  is  when  printed.  Larger
numbers make puzzles bigger; the default is 1.0.

--colour
Puzzles  will  be printed in colour, rather than in black
and white (if supported by the puzzle).

```

#### SEEALSO

```       Full documentation in /usr/share/doc/sgt‐puzzles/puzzles.txt.gz.
```