shithub: puzzles

Download patch

ref: a76d269cf222ba81e717c7e9046db391f19036eb
parent: 0f77798ae24d2152c5393f01e55e0168c564ee0d
author: Simon Tatham <[email protected]>
date: Tue Nov 13 16:34:42 EST 2018 

Adopt C99 bool in the game backend API.

encode_params, validate_params and new_desc now take a bool parameter;
fetch_preset, can_format_as_text_now and timing_state all return bool;
and the data fields is_timed, wants_statusbar and can_* are all bool.
All of those were previously typed as int, but semantically boolean.

This commit changes the API declarations in puzzles.h, updates all the
games to match (including the unfinisheds), and updates the developer
docs as well.


--- a/blackbox.c
+++ b/blackbox.c
@@ -59,7 +59,7 @@
     { 10, 10, 4, 10 }
 };
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
     char str[80];
     game_params *ret;
@@ -129,7 +129,7 @@
     }
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char str[256];
 
@@ -184,7 +184,7 @@
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     if (params->w < 2 || params->h < 2)
         return "Width and height must both be at least two";
@@ -207,7 +207,7 @@
  */
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-			   char **aux, int interactive)
+			   char **aux, bool interactive)
 {
     int nballs = params->minballs, i;
     char *grid, *ret;
@@ -463,7 +463,7 @@
     return dupstr("S");
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
     return TRUE;
 }
@@ -1481,7 +1481,7 @@
     return 0;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
     return TRUE;
 }
--- a/bridges.c
+++ b/bridges.c
@@ -204,7 +204,7 @@
     }
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
     return TRUE;
 }
@@ -648,7 +648,7 @@
     return ret;
 }
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
     game_params *ret;
     char buf[80];
@@ -716,7 +716,7 @@
     }
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char buf[80];
 
@@ -795,7 +795,7 @@
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     if (params->w < 3 || params->h < 3)
         return "Width and height must be at least 3";
@@ -1820,7 +1820,7 @@
 #define ORDER(a,b) do { if (a < b) { int tmp=a; int a=b; int b=tmp; } } while(0)
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-			   char **aux, int interactive)
+			   char **aux, bool interactive)
 {
     game_state *tobuild  = NULL;
     int i, j, wh = params->w * params->h, x, y, dx, dy;
@@ -3145,7 +3145,7 @@
     return state->completed ? +1 : 0;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
     return TRUE;
 }
--- a/cube.c
+++ b/cube.c
@@ -235,7 +235,7 @@
     return ret;
 }
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
     game_params *ret = snew(game_params);
     const char *str;
@@ -304,7 +304,7 @@
     }
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char data[256];
 
@@ -534,7 +534,7 @@
     classes[thisclass]++;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     int classes[5];
     int i;
@@ -595,7 +595,7 @@
 }
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-			   char **aux, int interactive)
+			   char **aux, bool interactive)
 {
     struct grid_data data;
     int i, j, k, m, area, facesperclass;
@@ -1005,7 +1005,7 @@
     return NULL;
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
     return TRUE;
 }
@@ -1713,7 +1713,7 @@
     return state->completed ? +1 : 0;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
     return TRUE;
 }
--- a/devel.but
+++ b/devel.but
@@ -389,7 +389,7 @@
 
 \S{backend-fetch-preset} \cw{fetch_preset()}
 
-\c int (*fetch_preset)(int i, char **name, game_params **params);
+\c bool (*fetch_preset)(int i, char **name, game_params **params);
 
 This function is one of the two APIs a back end can provide to
 populate the \q{Type} menu, which provides a list of conveniently
@@ -396,16 +396,16 @@
 accessible preset parameters for most games.
 
 The function is called with \c{i} equal to the index of the preset
-required (numbering from zero). It returns \cw{FALSE} if that preset
+required (numbering from zero). It returns \cw{false} if that preset
 does not exist (if \c{i} is less than zero or greater than the
 largest preset index). Otherwise, it sets \c{*params} to point at a
 newly allocated \c{game_params} structure containing the preset
 information, sets \c{*name} to point at a newly allocated C string
 containing the preset title (to go on the \q{Type} menu), and
-returns \cw{TRUE}.
+returns \cw{true}.
 
 If the game does not wish to support any presets at all, this
-function is permitted to return \cw{FALSE} always.
+function is permitted to return \cw{false} always.
 
 If the game wants to return presets in the form of a hierarchical menu
 instead of a flat list (and, indeed, even if it doesn't), then it may
@@ -436,7 +436,7 @@
 
 \S{backend-encode-params} \cw{encode_params()}
 
-\c char *(*encode_params)(const game_params *params, int full);
+\c char *(*encode_params)(const game_params *params, bool full);
 
 The job of this function is to take a \c{game_params}, and encode it
 in a string form for use in game IDs. The return value must be a
@@ -460,10 +460,10 @@
 the value of that parameter, with a few mandatory parts at the
 beginning such as numeric width and height separated by \cq{x}.)
 
-If the \c{full} parameter is \cw{TRUE}, this function should encode
+If the \c{full} parameter is \cw{true}, this function should encode
 absolutely everything in the \c{game_params}, such that a subsequent
 call to \cw{decode_params()} (\k{backend-decode-params}) will yield
-an identical structure. If \c{full} is \cw{FALSE}, however, you
+an identical structure. If \c{full} is \cw{false}, however, you
 should leave out anything which is not necessary to describe a
 \e{specific puzzle instance}, i.e. anything which only takes effect
 when a new puzzle is \e{generated}. For example, the Solo
@@ -529,13 +529,13 @@
 
 \S{backend-can-configure} \c{can_configure}
 
-\c int can_configure;
+\c bool can_configure;
 
-This boolean data element is set to \cw{TRUE} if the back end
-supports custom parameter configuration via a dialog box. If it is
-\cw{TRUE}, then the functions \cw{configure()} and
-\cw{custom_params()} are expected to work. See \k{backend-configure}
-and \k{backend-custom-params} for more details.
+This data element is set to \cw{true} if the back end supports custom
+parameter configuration via a dialog box. If it is \cw{true}, then the
+functions \cw{configure()} and \cw{custom_params()} are expected to
+work. See \k{backend-configure} and \k{backend-custom-params} for more
+details.
 
 \S{backend-configure} \cw{configure()}
 
@@ -665,7 +665,7 @@
 \S{backend-validate-params} \cw{validate_params()}
 
 \c const char *(*validate_params)(const game_params *params,
-\c                                int full);
+\c                                bool full);
 
 This function takes a \c{game_params} structure as input, and checks
 that the parameters described in it fall within sensible limits. (At
@@ -710,7 +710,7 @@
 \S{backend-new-desc} \cw{new_desc()}
 
 \c char *(*new_desc)(const game_params *params, random_state *rs,
-\c                   char **aux, int interactive);
+\c                   char **aux, bool interactive);
 
 This function is where all the really hard work gets done. This is
 the function whose job is to randomly generate a new puzzle,
@@ -1046,11 +1046,11 @@
 
 \S{backend-can-solve} \c{can_solve}
 
-\c int can_solve;
+\c bool can_solve;
 
-This boolean field is set to \cw{TRUE} if the game's \cw{solve()}
-function does something. If it's set to \cw{FALSE}, the game will
-not even offer the \q{Solve} menu option.
+This field is set to \cw{true} if the game's \cw{solve()} function
+does something. If it's set to \cw{false}, the game will not even
+offer the \q{Solve} menu option.
 
 \S{backend-solve} \cw{solve()}
 
@@ -1370,27 +1370,27 @@
 
 \S{backend-can-print} \c{can_print}
 
-\c int can_print;
+\c bool can_print;
 
-This flag is set to \cw{TRUE} if the puzzle is capable of printing
+This flag is set to \cw{true} if the puzzle is capable of printing
 itself on paper. (This makes sense for some puzzles, such as Solo,
 which can be filled in with a pencil. Other puzzles, such as
 Twiddle, inherently involve moving things around and so would not
 make sense to print.)
 
-If this flag is \cw{FALSE}, then the functions \cw{print_size()}
+If this flag is \cw{false}, then the functions \cw{print_size()}
 and \cw{print()} will never be called.
 
 \S{backend-can-print-in-colour} \c{can_print_in_colour}
 
-\c int can_print_in_colour;
+\c bool can_print_in_colour;
 
-This flag is set to \cw{TRUE} if the puzzle is capable of printing
+This flag is set to \cw{true} if the puzzle is capable of printing
 itself differently when colour is available. For example, Map can
 actually print coloured regions in different \e{colours} rather than
 resorting to cross-hatching.
 
-If the \c{can_print} flag is \cw{FALSE}, then this flag will be
+If the \c{can_print} flag is \cw{false}, then this flag will be
 ignored.
 
 \S{backend-print-size} \cw{print_size()}
@@ -1462,31 +1462,31 @@
 
 \S{backend-can-format-as-text-ever} \c{can_format_as_text_ever}
 
-\c int can_format_as_text_ever;
+\c bool can_format_as_text_ever;
 
-This boolean field is \cw{TRUE} if the game supports formatting a
+This field is \cw{true} if the game supports formatting a
 game state as ASCII text (typically ASCII art) for copying to the
-clipboard and pasting into other applications. If it is \cw{FALSE},
+clipboard and pasting into other applications. If it is \cw{false},
 front ends will not offer the \q{Copy} command at all.
 
-If this field is \cw{TRUE}, the game does not necessarily have to
+If this field is \cw{true}, the game does not necessarily have to
 support text formatting for \e{all} games: e.g. a game which can be
 played on a square grid or a triangular one might only support copy
 and paste for the former, because triangular grids in ASCII art are
 just too difficult.
 
-If this field is \cw{FALSE}, the functions
+If this field is \cw{false}, the functions
 \cw{can_format_as_text_now()} (\k{backend-can-format-as-text-now})
 and \cw{text_format()} (\k{backend-text-format}) are never called.
 
 \S{backend-can-format-as-text-now} \c{can_format_as_text_now()}
 
-\c int (*can_format_as_text_now)(const game_params *params);
+\c bool (*can_format_as_text_now)(const game_params *params);
 
-This function is passed a \c{game_params} and returns a boolean,
-which is \cw{TRUE} if the game can support ASCII text output for
-this particular game type. If it returns \cw{FALSE}, front ends will
-grey out or otherwise disable the \q{Copy} command.
+This function is passed a \c{game_params}, and returns \cw{true} if
+the game can support ASCII text output for this particular game type.
+If it returns \cw{false}, front ends will grey out or otherwise
+disable the \q{Copy} command.
 
 Games may enable and disable the copy-and-paste function for
 different game \e{parameters}, but are currently constrained to
@@ -1530,28 +1530,28 @@
 
 \S{backend-wants-statusbar} \cw{wants_statusbar}
 
-\c int wants_statusbar;
+\c bool wants_statusbar;
 
-This boolean field is set to \cw{TRUE} if the puzzle has a use for a
-textual status line (to display score, completion status, currently
-active tiles, etc).
+This field is set to \cw{true} if the puzzle has a use for a textual
+status line (to display score, completion status, currently active
+tiles, etc).
 
 \S{backend-is-timed} \c{is_timed}
 
-\c int is_timed;
+\c bool is_timed;
 
-This boolean field is \cw{TRUE} if the puzzle is time-critical. If
+This field is \cw{true} if the puzzle is time-critical. If
 so, the mid-end will maintain a game timer while the user plays.
 
-If this field is \cw{FALSE}, then \cw{timing_state()} will never be
+If this field is \cw{false}, then \cw{timing_state()} will never be
 called and need not do anything.
 
 \S{backend-timing-state} \cw{timing_state()}
 
-\c int (*timing_state)(const game_state *state, game_ui *ui);
+\c bool (*timing_state)(const game_state *state, game_ui *ui);
 
 This function is passed the current \c{game_state} and the local
-\c{game_ui}; it returns \cw{TRUE} if the game timer should currently
+\c{game_ui}; it returns \cw{true} if the game timer should currently
 be running.
 
 A typical use for the \c{game_ui} in this function is to note when
--- a/dominosa.c
+++ b/dominosa.c
@@ -130,7 +130,7 @@
     return ret;
 }
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
     game_params *ret;
     int n;
@@ -177,7 +177,7 @@
         params->unique = FALSE;
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char buf[80];
     sprintf(buf, "%d", params->n);
@@ -218,7 +218,7 @@
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     if (params->n < 1)
         return "Maximum face number must be at least one";
@@ -571,7 +571,7 @@
  */
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-			   char **aux, int interactive)
+			   char **aux, bool interactive)
 {
     int n = params->n, w = n+2, h = n+1, wh = w*h;
     int *grid, *grid2, *list;
@@ -967,7 +967,7 @@
     return ret;
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
     return params->n < 1000;
 }
@@ -1672,7 +1672,7 @@
     return state->completed ? +1 : 0;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
     return TRUE;
 }
--- a/fifteen.c
+++ b/fifteen.c
@@ -60,7 +60,7 @@
     return ret;
 }
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
     if (i == 0) {
 	*params = default_params();
@@ -92,7 +92,7 @@
     }
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char data[256];
 
@@ -134,7 +134,7 @@
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     if (params->w < 2 || params->h < 2)
 	return "Width and height must both be at least two";
@@ -157,7 +157,7 @@
 }
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-			   char **aux, int interactive)
+			   char **aux, bool interactive)
 {
     int gap, n, i, x;
     int x1, x2, p1, p2, parity;
@@ -384,7 +384,7 @@
     return dupstr("S");
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
     return TRUE;
 }
@@ -1065,7 +1065,7 @@
     return state->completed ? +1 : 0;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
     return TRUE;
 }
--- a/filling.c
+++ b/filling.c
@@ -112,7 +112,7 @@
     return ret;
 }
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
     char buf[64];
 
@@ -144,7 +144,7 @@
     if (*string == 'x') ret->h = atoi(++string);
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char buf[64];
     sprintf(buf, "%dx%d", params->w, params->h);
@@ -184,7 +184,7 @@
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     if (params->w < 1) return "Width must be at least one";
     if (params->h < 1) return "Height must be at least one";
@@ -268,7 +268,7 @@
     return repr;
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
     return TRUE;
 }
@@ -1238,7 +1238,7 @@
 }
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-                           char **aux, int interactive)
+                           char **aux, bool interactive)
 {
     const int w = params->w, h = params->h, sz = w * h;
     int *board = snewn(sz, int), i, j, run;
@@ -2055,7 +2055,7 @@
     return state->completed ? +1 : 0;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
     return TRUE;
 }
--- a/flip.c
+++ b/flip.c
@@ -82,7 +82,7 @@
     {5, 5, RANDOM},
 };
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
     game_params *ret;
     char str[80];
@@ -131,7 +131,7 @@
     }
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char data[256];
 
@@ -178,7 +178,7 @@
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     if (params->w <= 0 || params->h <= 0)
         return "Width and height must both be greater than zero";
@@ -344,7 +344,7 @@
 }
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-			   char **aux, int interactive)
+			   char **aux, bool interactive)
 {
     int w = params->w, h = params->h, wh = w * h;
     int i, j;
@@ -850,7 +850,7 @@
     return ret;
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
     return TRUE;
 }
@@ -1289,7 +1289,7 @@
     return state->completed ? +1 : 0;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
     return TRUE;
 }
--- a/flood.c
+++ b/flood.c
@@ -101,7 +101,7 @@
     {{12, 12, 4, 0}, "12x12, 4 colours"},
 };
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
     game_params *ret;
 
@@ -150,7 +150,7 @@
     }
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char buf[256];
     sprintf(buf, "%dx%d", params->w, params->h);
@@ -205,7 +205,7 @@
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     if (params->w < 2 && params->h < 2)
         return "Grid must contain at least two squares";
@@ -540,7 +540,7 @@
 }
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-			   char **aux, int interactive)
+			   char **aux, bool interactive)
 {
     int w = params->w, h = params->h, wh = w*h;
     int i, moves;
@@ -729,7 +729,7 @@
     return ret;
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
     return TRUE;
 }
@@ -1310,7 +1310,7 @@
     return 0.0F;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
     return TRUE;
 }
--- a/galaxies.c
+++ b/galaxies.c
@@ -171,7 +171,7 @@
     { 15, 15, DIFF_NORMAL },
 };
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
     game_params *ret;
     char buf[80];
@@ -229,7 +229,7 @@
     }
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char str[80];
     sprintf(str, "%dx%d", params->w, params->h);
@@ -277,7 +277,7 @@
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     if (params->w < 3 || params->h < 3)
         return "Width and height must both be at least 3";
@@ -384,7 +384,7 @@
 
 #define IS_VERTICAL_EDGE(x) ((x % 2) == 0)
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
     return TRUE;
 }
@@ -1277,7 +1277,7 @@
 }
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-			   char **aux, int interactive)
+			   char **aux, bool interactive)
 {
     game_state *state = blank_game(params->w, params->h), *copy;
     char *desc;
@@ -3442,7 +3442,7 @@
     return state->completed ? +1 : 0;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
     return TRUE;
 }
--- a/guess.c
+++ b/guess.c
@@ -82,7 +82,7 @@
 };
 
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
     if (i < 0 || i >= lenof(guess_presets))
         return FALSE;
@@ -145,7 +145,7 @@
     }
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char data[256];
 
@@ -206,7 +206,7 @@
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     if (params->ncolours < 2 || params->npegs < 2)
 	return "Trivial solutions are uninteresting";
@@ -258,7 +258,7 @@
 }
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-			   char **aux, int interactive)
+			   char **aux, bool interactive)
 {
     unsigned char *bmp = snewn(params->npegs, unsigned char);
     char *ret;
@@ -365,7 +365,7 @@
     return dupstr("S");
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
     return TRUE;
 }
@@ -1455,7 +1455,7 @@
     return state->solved;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
     return TRUE;
 }
--- a/inertia.c
+++ b/inertia.c
@@ -120,7 +120,7 @@
 #endif
 };
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
     game_params p, *ret;
     char *retname;
@@ -149,7 +149,7 @@
     }
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char data[256];
 
@@ -191,7 +191,7 @@
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     /*
      * Avoid completely degenerate cases which only have one
@@ -580,7 +580,7 @@
 }
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-			   char **aux, int interactive)
+			   char **aux, bool interactive)
 {
     return gengrid(params->w, params->h, rs);
 }
@@ -1443,7 +1443,7 @@
     return soln;
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
     return TRUE;
 }
@@ -2191,7 +2191,7 @@
     return state->gems == 0 ? +1 : 0;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
     return TRUE;
 }
--- a/keen.c
+++ b/keen.c
@@ -104,7 +104,7 @@
     {  9, DIFF_NORMAL,       FALSE },
 };
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
     game_params *ret;
     char buf[80];
@@ -161,7 +161,7 @@
     }
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char ret[80];
 
@@ -211,7 +211,7 @@
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     if (params->w < 3 || params->w > 9)
         return "Grid size must be between 3 and 9";
@@ -797,7 +797,7 @@
 }
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-			   char **aux, int interactive)
+			   char **aux, bool interactive)
 {
     int w = params->w, a = w*w;
     digit *grid, *soln;
@@ -1400,7 +1400,7 @@
     return out;
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
     return TRUE;
 }
@@ -2109,7 +2109,7 @@
     return state->completed ? +1 : 0;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
     if (state->completed)
 	return FALSE;
--- a/lightup.c
+++ b/lightup.c
@@ -204,7 +204,7 @@
     return ret;
 }
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
     game_params *ret;
     char buf[80];
@@ -274,7 +274,7 @@
     }
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char buf[80];
 
@@ -342,7 +342,7 @@
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     if (params->w < 2 || params->h < 2)
         return "Width and height must be at least 2";
@@ -1514,7 +1514,7 @@
 #define MAX_GRIDGEN_TRIES 20
 
 static char *new_game_desc(const game_params *params_in, random_state *rs,
-			   char **aux, int interactive)
+			   char **aux, bool interactive)
 {
     game_params params_copy = *params_in; /* structure copy */
     game_params *params = &params_copy;
@@ -1750,7 +1750,7 @@
     return move;
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
     return TRUE;
 }
@@ -2211,7 +2211,7 @@
     return state->completed ? +1 : 0;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
     return TRUE;
 }
--- a/loopy.c
+++ b/loopy.c
@@ -624,7 +624,7 @@
     }
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char str[80];
     sprintf(str, "%dx%dt%d", params->w, params->h, params->type);
@@ -678,7 +678,7 @@
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     if (params->type < 0 || params->type >= NUM_GRID_TYPES)
         return "Illegal grid type";
@@ -973,7 +973,7 @@
     sfree(ds);
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
     return TRUE;
 }
@@ -984,7 +984,7 @@
     return 0.0F;
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
     if (params->type != 0)
         return FALSE;
@@ -1412,7 +1412,7 @@
 
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-                           char **aux, int interactive)
+                           char **aux, bool interactive)
 {
     /* solution and description both use run-length encoding in obvious ways */
     char *retval, *game_desc, *grid_desc;
--- a/magnets.c
+++ b/magnets.c
@@ -113,7 +113,7 @@
     return ret;
 }
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
     game_params *ret;
     char buf[64];
@@ -172,7 +172,7 @@
     }
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char buf[256];
     sprintf(buf, "%dx%d", params->w, params->h);
@@ -227,7 +227,7 @@
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     if (params->w < 2) return "Width must be at least one";
     if (params->h < 2) return "Height must be at least one";
@@ -599,7 +599,7 @@
     *p_r = p;
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
     return TRUE;
 }
@@ -1684,7 +1684,7 @@
 }
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-			   char **aux_r, int interactive)
+			   char **aux_r, bool interactive)
 {
     game_state *new = new_state(params->w, params->h);
     char *desc, *aux = snewn(new->wh+1, char);
@@ -2284,7 +2284,7 @@
     return state->completed ? +1 : 0;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
     return TRUE;
 }
--- a/map.c
+++ b/map.c
@@ -131,7 +131,7 @@
 #endif
 };
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
     game_params *ret;
     char str[80];
@@ -192,7 +192,7 @@
     }
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char ret[400];
 
@@ -248,7 +248,7 @@
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     if (params->w < 2 || params->h < 2)
 	return "Width and height must be at least two";
@@ -1390,7 +1390,7 @@
  */
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-			   char **aux, int interactive)
+			   char **aux, bool interactive)
 {
     struct solver_scratch *sc = NULL;
     int *map, *graph, ngraph, *colouring, *colouring2, *regions;
@@ -2246,7 +2246,7 @@
     return dupstr(aux);
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
     return TRUE;
 }
@@ -3053,7 +3053,7 @@
     return state->completed ? +1 : 0;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
     return TRUE;
 }
--- a/mines.c
+++ b/mines.c
@@ -113,7 +113,7 @@
 #endif
 };
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
     game_params *ret;
     char str[80];
@@ -173,7 +173,7 @@
     }
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char ret[400];
     int len;
@@ -239,7 +239,7 @@
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     /*
      * Lower limit on grid size: each dimension must be at least 3.
@@ -1950,7 +1950,7 @@
 }
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-			   char **aux, int interactive)
+			   char **aux, bool interactive)
 {
     /*
      * We generate the coordinates of an initial click even if they
@@ -2308,7 +2308,7 @@
     return dupstr("S");
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
     return TRUE;
 }
@@ -3151,7 +3151,7 @@
     return state->won ? (state->used_solve ? -1 : +1) : 0;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
     if (state->dead || state->won || ui->completed || !state->layout->mines)
 	return FALSE;
--- a/net.c
+++ b/net.c
@@ -178,7 +178,7 @@
 #endif
 };
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
     game_params *ret;
     char str[80];
@@ -239,7 +239,7 @@
     }
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char ret[400];
     int len;
@@ -306,7 +306,7 @@
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     if (params->width <= 0 || params->height <= 0)
 	return "Width and height must both be greater than zero";
@@ -1130,7 +1130,7 @@
                                 const unsigned char *barriers);
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-			   char **aux, int interactive)
+			   char **aux, bool interactive)
 {
     tree234 *possibilities, *barriertree;
     int w, h, x, y, cx, cy, nbarriers;
@@ -1844,7 +1844,7 @@
     return ret;
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
     return TRUE;
 }
@@ -3089,7 +3089,7 @@
     return state->completed ? +1 : 0;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
     return TRUE;
 }
--- a/netslide.c
+++ b/netslide.c
@@ -170,7 +170,7 @@
     {5, 5, TRUE,  0, " hard"},
 };
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
     game_params *ret;
     char str[80];
@@ -232,7 +232,7 @@
     }
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char ret[400];
     int len;
@@ -302,7 +302,7 @@
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     if (params->width <= 1 || params->height <= 1)
 	return "Width and height must both be greater than one";
@@ -318,7 +318,7 @@
  */
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-			   char **aux, int interactive)
+			   char **aux, bool interactive)
 {
     tree234 *possibilities, *barriertree;
     int w, h, x, y, cx, cy, nbarriers;
@@ -889,7 +889,7 @@
     return dupstr(aux);
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
     return TRUE;
 }
@@ -1828,7 +1828,7 @@
     return state->completed ? +1 : 0;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
     return FALSE;
 }
--- a/nullgame.c
+++ b/nullgame.c
@@ -42,7 +42,7 @@
     return ret;
 }
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
     return FALSE;
 }
@@ -63,7 +63,7 @@
 {
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     return dupstr("FIXME");
 }
@@ -78,13 +78,13 @@
     return NULL;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     return NULL;
 }
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-			   char **aux, int interactive)
+			   char **aux, bool interactive)
 {
     return dupstr("FIXME");
 }
@@ -124,7 +124,7 @@
     return NULL;
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
     return TRUE;
 }
@@ -247,7 +247,7 @@
     return 0;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
     return TRUE;
 }
--- a/palisade.c
+++ b/palisade.c
@@ -75,7 +75,7 @@
     return clone(&presets[DEFAULT_PRESET]);
 }
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
     if (i < 0 || i >= lenof(presets)) return FALSE;
 
@@ -107,7 +107,7 @@
     if (*string == 'n') params->k = atoi(++string);
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     return string(40, "%dx%dn%d", params->w, params->h, params->k);
 }
@@ -155,7 +155,7 @@
  * +---+   the dominos is horizontal or vertical.            +---+---+
  */
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     int w = params->w, h = params->h, k = params->k, wh = w * h;
 
@@ -617,7 +617,7 @@
 #define xshuffle(ptr, len, rs) shuffle((ptr), (len), sizeof (ptr)[0], (rs))
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-                           char **aux, int interactive)
+                           char **aux, bool interactive)
 {
     int w = params->w, h = params->h, wh = w*h, k = params->k;
 
@@ -819,7 +819,7 @@
     }
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
     return TRUE;
 }
@@ -1278,7 +1278,7 @@
     return state->completed ? +1 : 0;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
     assert (!"this shouldn't get called");
     return 0;                          /* placate optimiser */
--- a/pattern.c
+++ b/pattern.c
@@ -81,7 +81,7 @@
 #endif
 };
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
     game_params *ret;
     char str[80];
@@ -126,7 +126,7 @@
     }
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char ret[400];
     int len;
@@ -171,7 +171,7 @@
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     if (params->w <= 0 || params->h <= 0)
 	return "Width and height must both be greater than zero";
@@ -717,7 +717,7 @@
 #endif
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-			   char **aux, int interactive)
+			   char **aux, bool interactive)
 {
     unsigned char *grid;
     int i, j, max, rowlen, *rowdata;
@@ -1096,7 +1096,7 @@
     return ret;
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
     return TRUE;
 }
@@ -1903,7 +1903,7 @@
     return state->completed ? +1 : 0;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
     return TRUE;
 }
--- a/pearl.c
+++ b/pearl.c
@@ -155,7 +155,7 @@
     return ret;
 }
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
     game_params *ret;
     char buf[64];
@@ -213,7 +213,7 @@
     }
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char buf[256];
     sprintf(buf, "%dx%d", params->w, params->h);
@@ -268,7 +268,7 @@
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     if (params->w < 5) return "Width must be at least five";
     if (params->h < 5) return "Height must be at least five";
@@ -1351,7 +1351,7 @@
 }
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-			   char **aux, int interactive)
+			   char **aux, bool interactive)
 {
     char *grid, *clues;
     char *desc;
@@ -1765,7 +1765,7 @@
     return move;
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
     return TRUE;
 }
@@ -2544,7 +2544,7 @@
     return state->completed ? +1 : 0;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
     return TRUE;
 }
--- a/pegs.c
+++ b/pegs.c
@@ -77,7 +77,7 @@
     {9, 9, TYPE_RANDOM},
 };
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
     game_params *ret;
     char str[80];
@@ -129,7 +129,7 @@
 	    params->type = i;
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char str[80];
 
@@ -178,7 +178,7 @@
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     if (full && (params->w <= 3 || params->h <= 3))
 	return "Width and height must both be greater than three";
@@ -500,7 +500,7 @@
  */
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-			   char **aux, int interactive)
+			   char **aux, bool interactive)
 {
     int w = params->w, h = params->h;
     unsigned char *grid;
@@ -712,7 +712,7 @@
     return NULL;
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
     return TRUE;
 }
@@ -1278,7 +1278,7 @@
     return state->completed ? +1 : 0;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
     return TRUE;
 }
--- a/puzzles.h
+++ b/puzzles.h
@@ -609,28 +609,28 @@
     const char *name;
     const char *winhelp_topic, *htmlhelp_topic;
     game_params *(*default_params)(void);
-    int (*fetch_preset)(int i, char **name, game_params **params);
+    bool (*fetch_preset)(int i, char **name, game_params **params);
     struct preset_menu *(*preset_menu)(void);
     void (*decode_params)(game_params *, char const *string);
-    char *(*encode_params)(const game_params *, int full);
+    char *(*encode_params)(const game_params *, bool full);
     void (*free_params)(game_params *params);
     game_params *(*dup_params)(const game_params *params);
-    int can_configure;
+    bool can_configure;
     config_item *(*configure)(const game_params *params);
     game_params *(*custom_params)(const config_item *cfg);
-    const char *(*validate_params)(const game_params *params, int full);
+    const char *(*validate_params)(const game_params *params, bool full);
     char *(*new_desc)(const game_params *params, random_state *rs,
-		      char **aux, int interactive);
+		      char **aux, bool interactive);
     const char *(*validate_desc)(const game_params *params, const char *desc);
     game_state *(*new_game)(midend *me, const game_params *params,
                             const char *desc);
     game_state *(*dup_game)(const game_state *state);
     void (*free_game)(game_state *state);
-    int can_solve;
+    bool can_solve;
     char *(*solve)(const game_state *orig, const game_state *curr,
                    const char *aux, const char **error);
-    int can_format_as_text_ever;
-    int (*can_format_as_text_now)(const game_params *params);
+    bool can_format_as_text_ever;
+    bool (*can_format_as_text_now)(const game_params *params);
     char *(*text_format)(const game_state *state);
     game_ui *(*new_ui)(const game_state *state);
     void (*free_ui)(game_ui *ui);
@@ -658,12 +658,12 @@
     float (*flash_length)(const game_state *oldstate,
                           const game_state *newstate, int dir, game_ui *ui);
     int (*status)(const game_state *state);
-    int can_print, can_print_in_colour;
+    bool can_print, can_print_in_colour;
     void (*print_size)(const game_params *params, float *x, float *y);
     void (*print)(drawing *dr, const game_state *state, int tilesize);
-    int wants_statusbar;
-    int is_timed;
-    int (*timing_state)(const game_state *state, game_ui *ui);
+    bool wants_statusbar;
+    bool is_timed;
+    bool (*timing_state)(const game_state *state, game_ui *ui);
     int flags;
 };
 
--- a/range.c
+++ b/range.c
@@ -123,7 +123,7 @@
     return ret;
 }
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
     game_params *ret;
 
@@ -155,7 +155,7 @@
     }
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char str[80];
     sprintf(str, "%dx%d", params->w, params->h);
@@ -687,7 +687,7 @@
 static char *newdesc_encode_game_description(int n, puzzle_size *grid);
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-                           char **aux, int interactive)
+                           char **aux, bool interactive)
 {
     int const w = params->w, h = params->h, n = w * h;
 
@@ -907,7 +907,7 @@
     return k;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     int const w = params->w, h = params->h;
     if (w < 1) return "Error: width is less than 1";
@@ -1149,7 +1149,7 @@
  * User interface: ascii
  */
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
     return TRUE;
 }
@@ -1745,7 +1745,7 @@
     draw_update(draw, x, y, ts + 1, ts + 1);
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
     puts("warning: game_timing_state was called (this shouldn't happen)");
     return FALSE; /* the (non-existing) timer should not be running */
--- a/rect.c
+++ b/rect.c
@@ -95,7 +95,7 @@
     return ret;
 }
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
     game_params *ret;
     int w, h;
@@ -157,7 +157,7 @@
     }
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char data[256];
 
@@ -214,7 +214,7 @@
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     if (params->w <= 0 || params->h <= 0)
 	return "Width and height must both be greater than zero";
@@ -1141,7 +1141,7 @@
 #endif
 
 static char *new_game_desc(const game_params *params_in, random_state *rs,
-			   char **aux, int interactive)
+			   char **aux, bool interactive)
 {
     game_params params_copy = *params_in; /* structure copy */
     game_params *params = &params_copy;
@@ -2042,7 +2042,7 @@
     return ret;
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
     return TRUE;
 }
@@ -2879,7 +2879,7 @@
     return state->completed ? +1 : 0;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
     return TRUE;
 }
--- a/samegame.c
+++ b/samegame.c
@@ -158,7 +158,7 @@
     { 20, 15, 4, 2, TRUE }
 };
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
     game_params *ret;
     char str[80];
@@ -221,7 +221,7 @@
     }
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char ret[80];
 
@@ -281,7 +281,7 @@
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     if (params->w < 1 || params->h < 1)
 	return "Width and height must both be positive";
@@ -912,7 +912,7 @@
 }
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-			   char **aux, int interactive)
+			   char **aux, bool interactive)
 {
     char *ret;
     int n, i, retlen, *tiles;
@@ -1017,7 +1017,7 @@
     return NULL;
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
     return TRUE;
 }
@@ -1618,7 +1618,7 @@
     return state->complete ? +1 : 0;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
     return TRUE;
 }
--- a/signpost.c
+++ b/signpost.c
@@ -197,7 +197,7 @@
     state->prev[to] = from;
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
     if (params->w * params->h >= 100) return 0;
     return 1;
@@ -316,7 +316,7 @@
   { 7, 7, 1 }
 };
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
     game_params *ret;
     char buf[80];
@@ -364,7 +364,7 @@
 
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char data[256];
 
@@ -415,7 +415,7 @@
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     if (params->w < 1) return "Width must be at least one";
     if (params->h < 1) return "Height must be at least one";
@@ -795,7 +795,7 @@
 }
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-			   char **aux, int interactive)
+			   char **aux, bool interactive)
 {
     game_state *state = blank_game(params->w, params->h);
     char *ret;
@@ -2175,7 +2175,7 @@
     return state->completed ? +1 : 0;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
     return TRUE;
 }
--- a/singles.c
+++ b/singles.c
@@ -147,7 +147,7 @@
   { 12, 12, DIFF_TRICKY }
 };
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
     game_params *ret;
     char buf[80];
@@ -200,7 +200,7 @@
     }
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char data[256];
 
@@ -251,7 +251,7 @@
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     if (params->w < 2 || params->h < 2)
 	return "Width and neight must be at least two";
@@ -374,7 +374,7 @@
 
 /* --- Useful game functions (completion, etc.) --- */
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
     return TRUE;
 }
@@ -1299,7 +1299,7 @@
 }
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-			   char **aux, int interactive)
+			   char **aux, bool interactive)
 {
     game_state *state = blank_game(params->w, params->h);
     game_state *tosolve = blank_game(params->w, params->h);
@@ -1752,7 +1752,7 @@
     return state->completed ? +1 : 0;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
     return TRUE;
 }
--- a/sixteen.c
+++ b/sixteen.c
@@ -62,7 +62,7 @@
     return ret;
 }
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
     game_params *ret;
     int w, h;
@@ -117,7 +117,7 @@
     }
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char data[256];
 
@@ -169,7 +169,7 @@
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     if (params->w < 2 || params->h < 2)
 	return "Width and height must both be at least two";
@@ -192,7 +192,7 @@
 }
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-			   char **aux, int interactive)
+			   char **aux, bool interactive)
 {
     int stop, n, i, x;
     int x1, x2, p1, p2;
@@ -508,7 +508,7 @@
     return dupstr("S");
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
     return TRUE;
 }
@@ -1150,7 +1150,7 @@
     return state->completed ? +1 : 0;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
     return TRUE;
 }
--- a/slant.c
+++ b/slant.c
@@ -114,7 +114,7 @@
     {12, 10, DIFF_HARD},
 };
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
     game_params *ret;
     char str[80];
@@ -163,7 +163,7 @@
     }
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char data[256];
 
@@ -213,7 +213,7 @@
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     /*
      * (At least at the time of writing this comment) The grid
@@ -1060,7 +1060,7 @@
 }
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-			   char **aux, int interactive)
+			   char **aux, bool interactive)
 {
     int w = params->w, h = params->h, W = w+1, H = h+1;
     signed char *soln, *tmpsoln, *clues;
@@ -1520,7 +1520,7 @@
     return move;
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
     return TRUE;
 }
@@ -2063,7 +2063,7 @@
     return state->completed ? +1 : 0;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
     return TRUE;
 }
--- a/solo.c
+++ b/solo.c
@@ -296,7 +296,7 @@
     return ret;
 }
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
     static struct {
         const char *title;
@@ -399,7 +399,7 @@
     }
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char str[80];
 
@@ -501,7 +501,7 @@
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     if (params->c < 2)
 	return "Both dimensions must be at least 2";
@@ -3629,7 +3629,7 @@
 }
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-			   char **aux, int interactive)
+			   char **aux, bool interactive)
 {
     int c = params->c, r = params->r, cr = c*r;
     int area = cr*cr;
@@ -4499,7 +4499,7 @@
     return ret;
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
     /*
      * Formatting Killer puzzles as text is currently unsupported. I
@@ -5290,7 +5290,7 @@
     return state->completed ? +1 : 0;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
     if (state->completed)
 	return FALSE;
--- a/tents.c
+++ b/tents.c
@@ -301,7 +301,7 @@
     {15, 15, DIFF_TRICKY},
 };
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
     game_params *ret;
     char str[80];
@@ -350,7 +350,7 @@
     }
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char buf[120];
 
@@ -400,7 +400,7 @@
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     /*
      * Generating anything under 4x4 runs into trouble of one kind
@@ -897,7 +897,7 @@
 }
 
 static char *new_game_desc(const game_params *params_in, random_state *rs,
-			   char **aux, int interactive)
+			   char **aux, bool interactive)
 {
     game_params params_copy = *params_in; /* structure copy */
     game_params *params = &params_copy;
@@ -1360,7 +1360,7 @@
     }
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
     return params->w <= 1998 && params->h <= 1998; /* 999 tents */
 }
@@ -2553,7 +2553,7 @@
     return state->completed ? +1 : 0;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
     return TRUE;
 }
--- a/towers.c
+++ b/towers.c
@@ -140,7 +140,7 @@
     {  6, DIFF_UNREASONABLE },
 };
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
     game_params *ret;
     char buf[80];
@@ -191,7 +191,7 @@
     }
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char ret[80];
 
@@ -235,7 +235,7 @@
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     if (params->w < 3 || params->w > 9)
         return "Grid size must be between 3 and 9";
@@ -602,7 +602,7 @@
  */
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-			   char **aux, int interactive)
+			   char **aux, bool interactive)
 {
     int w = params->w, a = w*w;
     digit *grid, *soln, *soln2;
@@ -1019,7 +1019,7 @@
     return out;
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
     return TRUE;
 }
@@ -1903,7 +1903,7 @@
     return state->completed ? +1 : 0;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
     if (state->completed)
 	return FALSE;
--- a/tracks.c
+++ b/tracks.c
@@ -70,7 +70,7 @@
     {15, 15, DIFF_TRICKY, 1},
 };
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
     game_params *ret;
     char str[80];
@@ -126,7 +126,7 @@
 
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char buf[120];
 
@@ -182,7 +182,7 @@
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     /*
      * Generating anything under 4x4 runs into trouble of one kind
@@ -685,7 +685,7 @@
 }
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-                           char **aux, int interactive)
+                           char **aux, bool interactive)
 {
     int i, j, w = params->w, h = params->h, x, y, ret;
     game_state *state;
@@ -1389,7 +1389,7 @@
     return move;
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
     return TRUE;
 }
@@ -2567,7 +2567,7 @@
     return state->completed ? +1 : 0;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
     return TRUE;
 }
--- a/twiddle.c
+++ b/twiddle.c
@@ -77,7 +77,7 @@
     return ret;
 }
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
     static struct {
         const char *title;
@@ -133,7 +133,7 @@
     }
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char buf[256];
     sprintf(buf, "%dx%dn%d%s%s", params->w, params->h, params->n,
@@ -201,7 +201,7 @@
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     if (params->n < 2)
 	return "Rotating block size must be at least two";
@@ -299,7 +299,7 @@
 }
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-			   char **aux, int interactive)
+			   char **aux, bool interactive)
 {
     int *grid;
     int w = params->w, h = params->h, n = params->n, wh = w*h;
@@ -538,7 +538,7 @@
     return dupstr("S");
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
     return TRUE;
 }
@@ -1253,7 +1253,7 @@
     }
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
     return TRUE;
 }
--- a/undead.c
+++ b/undead.c
@@ -92,7 +92,7 @@
     return ret;
 }
 
-static int game_fetch_preset(int i, char **name, game_params **params) {
+static bool game_fetch_preset(int i, char **name, game_params **params) {
     game_params *ret;
     char buf[64];
 
@@ -144,7 +144,7 @@
     return;
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char buf[256];
     sprintf(buf, "%dx%d", params->w, params->h);
@@ -191,7 +191,7 @@
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     if ((params->w * params->h ) > 54)  return "Grid is too big";
     if (params->w < 3)                  return "Width must be at least 3";
@@ -970,7 +970,7 @@
 }
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-                           char **aux, int interactive) {
+                           char **aux, bool interactive) {
     int i,count,c,w,h,r,p,g;
     game_state *new;
 
@@ -1591,7 +1591,7 @@
     return move;
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
     return TRUE;
 }
@@ -2696,7 +2696,7 @@
     return state->solved;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
     return TRUE;
 }
--- a/unequal.c
+++ b/unequal.c
@@ -126,7 +126,7 @@
     {  7, DIFF_EXTREME, 0 }
 };
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
     game_params *ret;
     char buf[80];
@@ -196,7 +196,7 @@
     }
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char ret[80];
 
@@ -248,7 +248,7 @@
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     if (params->order < 3 || params->order > 32)
         return "Order must be between 3 and 32";
@@ -449,7 +449,7 @@
     return -1;
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
     return TRUE;
 }
@@ -1099,7 +1099,7 @@
 }
 
 static char *new_game_desc(const game_params *params_in, random_state *rs,
-			   char **aux, int interactive)
+			   char **aux, bool interactive)
 {
     game_params params_copy = *params_in; /* structure copy */
     game_params *params = &params_copy;
@@ -1952,7 +1952,7 @@
     return state->completed ? +1 : 0;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
     return TRUE;
 }
--- a/unfinished/group.c
+++ b/unfinished/group.c
@@ -127,7 +127,7 @@
     { 12, DIFF_NORMAL, TRUE },
 };
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
     game_params *ret;
     char buf[80];
@@ -189,7 +189,7 @@
     }
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char ret[80];
 
@@ -240,7 +240,7 @@
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     if (params->w < 3 || params->w > 26)
         return "Grid size must be between 3 and 26";
@@ -593,7 +593,7 @@
 /* ----- data generated by group.gap ends ----- */
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-			   char **aux, int interactive)
+			   char **aux, bool interactive)
 {
     int w = params->w, a = w*w;
     digit *grid, *soln, *soln2;
@@ -940,7 +940,7 @@
     return out;
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
     return TRUE;
 }
@@ -1973,7 +1973,7 @@
     return state->completed ? +1 : 0;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
     if (state->completed)
 	return FALSE;
--- a/unfinished/separate.c
+++ b/unfinished/separate.c
@@ -120,7 +120,7 @@
     return ret;
 }
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
     return FALSE;
 }
@@ -153,7 +153,7 @@
     }
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char buf[256];
     sprintf(buf, "%dx%dn%d", params->w, params->h, params->k);
@@ -170,7 +170,7 @@
     return NULL;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     return NULL;
 }
@@ -627,7 +627,7 @@
  */
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-			   char **aux, int interactive)
+			   char **aux, bool interactive)
 {
     int w = params->w, h = params->h, wh = w*h, k = params->k;
     unsigned char *grid;
@@ -681,7 +681,7 @@
     return NULL;
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
     return TRUE;
 }
@@ -803,7 +803,7 @@
     return 0;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
     return TRUE;
 }
--- a/unfinished/slide.c
+++ b/unfinished/slide.c
@@ -168,7 +168,7 @@
     {8, 6, -1},
 };
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
     game_params *ret;
     char str[80];
@@ -221,7 +221,7 @@
     }
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char data[256];
 
@@ -273,7 +273,7 @@
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     if (params->w > MAXWID)
 	return "Width must be at most " STR(MAXWID);
@@ -833,7 +833,7 @@
  */
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-			   char **aux, int interactive)
+			   char **aux, bool interactive)
 {
     int w = params->w, h = params->h, wh = w*h;
     int tx, ty, minmoves;
@@ -1164,7 +1164,7 @@
     return ret;
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
     return TRUE;
 }
@@ -2295,7 +2295,7 @@
     return state->completed ? +1 : 0;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
     return TRUE;
 }
--- a/unfinished/sokoban.c
+++ b/unfinished/sokoban.c
@@ -162,7 +162,7 @@
     { 20, 16 },
 };
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
     game_params p, *ret;
     char *retname;
@@ -191,7 +191,7 @@
     }
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char data[256];
 
@@ -233,7 +233,7 @@
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     if (params->w < 4 || params->h < 4)
 	return "Width and height must both be at least 4";
@@ -728,7 +728,7 @@
 }
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-			   char **aux, int interactive)
+			   char **aux, bool interactive)
 {
     int w = params->w, h = params->h;
     char *desc;
@@ -904,7 +904,7 @@
     return NULL;
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
     return TRUE;
 }
@@ -1419,7 +1419,7 @@
     return state->completed ? +1 : 0;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
     return TRUE;
 }
--- a/unruly.c
+++ b/unruly.c
@@ -151,7 +151,7 @@
     return ret;
 }
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
     game_params *ret;
     char buf[80];
@@ -216,7 +216,7 @@
     }
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char buf[80];
 
@@ -273,7 +273,7 @@
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     if ((params->w2 & 1) || (params->h2 & 1))
         return "Width and height must both be even";
@@ -425,7 +425,7 @@
     sfree(state);
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
     return TRUE;
 }
@@ -1269,7 +1269,7 @@
 }
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-                           char **aux, int interactive)
+                           char **aux, bool interactive)
 {
 #ifdef STANDALONE_SOLVER
     char *debug;
@@ -1854,7 +1854,7 @@
     return state->completed ? +1 : 0;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
     return TRUE;
 }
--- a/untangle.c
+++ b/untangle.c
@@ -125,7 +125,7 @@
     return ret;
 }
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
     game_params *ret;
     int n;
@@ -166,7 +166,7 @@
     params->n = atoi(string);
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char buf[80];
 
@@ -202,7 +202,7 @@
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     if (params->n < 4)
         return "Number of points must be at least four";
@@ -489,7 +489,7 @@
 }
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-			   char **aux, int interactive)
+			   char **aux, bool interactive)
 {
     int n = params->n, i;
     long w, h, j, k, m;
@@ -1023,7 +1023,7 @@
     return ret;
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
     return TRUE;
 }
@@ -1432,7 +1432,7 @@
     return state->completed ? +1 : 0;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
     return TRUE;
 }