{ 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;
}
}
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
{
char str[256];
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";
*/
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;
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;
}
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;
}
}
}
-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;
}
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];
}
}
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
{
char buf[80];
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";
#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;
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;
}
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;
}
}
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
{
char data[256];
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;
}
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;
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;
}
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;
}
\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
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
\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
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
\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()}
\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
\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,
\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()}
\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()}
\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
\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
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;
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);
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";
*/
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;
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;
}
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;
}
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();
}
}
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
{
char data[256];
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";
}
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;
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;
}
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;
}
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];
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);
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";
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;
}
}
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;
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;
}
{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];
}
}
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
{
char data[256];
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";
}
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;
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;
}
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;
}
{{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;
}
}
-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);
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";
}
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;
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;
}
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;
}
{ 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];
}
}
-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);
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";
#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;
}
}
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;
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;
}
};
-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;
}
}
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
{
char data[256];
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";
}
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;
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;
}
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;
}
#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;
}
}
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
{
char data[256];
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
}
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);
}
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;
}
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;
}
{ 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];
}
}
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
{
char ret[80];
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";
}
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;
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;
}
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;
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];
}
}
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
{
char buf[80];
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";
#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 = ¶ms_copy;
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;
}
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;
}
}
}
-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);
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";
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;
}
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;
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;
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];
}
}
-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);
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";
*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;
}
}
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);
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;
}
#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];
}
}
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
{
char ret[400];
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";
*/
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;
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;
}
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;
}
#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];
}
}
-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;
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.
}
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
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;
}
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;
#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];
}
}
-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;
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";
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;
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;
}
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;
}
{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];
}
}
-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;
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";
*/
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;
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;
}
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;
}
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;
}
{
}
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
{
return dupstr("FIXME");
}
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");
}
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;
}
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;
}
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;
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);
}
* +---+ 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;
#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;
}
}
-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;
}
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 */
#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];
}
}
-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;
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";
#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;
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;
}
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;
}
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];
}
}
-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);
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";
}
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;
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;
}
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;
}
{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];
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];
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";
*/
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;
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;
}
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;
}
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);
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;
};
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;
}
}
-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);
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;
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";
* 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;
}
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 */
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;
}
}
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
{
char data[256];
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";
#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 = ¶ms_copy;
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;
}
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;
}
{ 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];
}
}
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
{
char ret[80];
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";
}
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;
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;
}
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;
}
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;
{ 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];
}
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
{
char data[256];
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";
}
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;
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;
}
{ 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];
}
}
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
{
char data[256];
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";
/* --- 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;
}
}
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);
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;
}
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;
}
}
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
{
char data[256];
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";
}
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;
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;
}
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;
}
{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];
}
}
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
{
char data[256];
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
}
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;
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;
}
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;
}
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;
}
}
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
{
char str[80];
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";
}
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;
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
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;
{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];
}
}
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
{
char buf[120];
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
}
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 = ¶ms_copy;
}
}
-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 */
}
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;
}
{ 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];
}
}
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
{
char ret[80];
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";
*/
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;
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;
}
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;
{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];
}
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
{
char buf[120];
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
}
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;
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;
}
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;
}
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;
}
}
-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,
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";
}
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;
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;
}
}
}
-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;
}
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];
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);
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";
}
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;
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;
}
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;
}
{ 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];
}
}
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
{
char ret[80];
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";
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;
}
}
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 = ¶ms_copy;
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;
}
{ 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];
}
}
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
{
char ret[80];
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";
/* ----- 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;
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;
}
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;
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;
}
}
}
-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);
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)
{
int w = params->w, h = params->h, wh = w*h, k = params->k;
unsigned char *grid;
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;
}
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;
}
{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];
}
}
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
{
char data[256];
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);
*/
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;
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;
}
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;
}
{ 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;
}
}
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
{
char data[256];
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";
}
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;
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;
}
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;
}
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];
}
}
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
{
char buf[80];
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";
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;
}
}
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;
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;
}
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;
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];
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";
}
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;
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;
}
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;
}
~ian / sgt-puzzles.git / commitdiff