sfree(params);
}
-static game_params *dup_params(game_params *params)
+static game_params *dup_params(const game_params *params)
{
game_params *ret = snew(game_params);
*ret = *params; /* structure copy */
}
}
-static char *encode_params(game_params *params, int full)
+static char *encode_params(const game_params *params, int full)
{
char buf[256];
sprintf(buf, "%dx%d", params->w, params->h);
return dupstr(buf);
}
-static config_item *game_configure(game_params *params)
+static config_item *game_configure(const game_params *params)
{
config_item *ret;
char buf[64];
return ret;
}
-static game_params *custom_params(config_item *cfg)
+static game_params *custom_params(const config_item *cfg)
{
game_params *ret = snew(game_params);
return ret;
}
-static char *validate_params(game_params *params, int full)
+static char *validate_params(const game_params *params, int full)
{
if (params->w < 2) return "Width must be at least one";
if (params->h < 2) return "Height must be at least one";
return ret;
}
-static game_state *dup_game(game_state *src)
+static game_state *dup_game(const game_state *src)
{
game_state *dest = snew(game_state);
return -1;
}
-static char *readrow(char *desc, int n, int *array, int off, const char **prob)
+static const char *readrow(const char *desc, int n, int *array, int off,
+ const char **prob)
{
int i, num;
char c;
return NULL;
}
-static game_state *new_game_int(game_params *params, char *desc, const char **prob)
+static game_state *new_game_int(const game_params *params, const char *desc,
+ const char **prob)
{
game_state *state = new_state(params->w, params->h);
int x, y, idx, *count;
return state;
}
-static char *validate_desc(game_params *params, char *desc)
+static char *validate_desc(const game_params *params, const char *desc)
{
const char *prob;
game_state *st = new_game_int(params, desc, &prob);
return NULL;
}
-static game_state *new_game(midend *me, game_params *params, char *desc)
+static game_state *new_game(midend *me, const game_params *params,
+ const char *desc)
{
const char *prob;
game_state *st = new_game_int(params, desc, &prob);
return desc;
}
-static void game_text_hborder(game_state *state, char **p_r)
+static void game_text_hborder(const game_state *state, char **p_r)
{
char *p = *p_r;
int x;
*p_r = p;
}
-static int game_can_format_as_text_now(game_params *params)
+static int game_can_format_as_text_now(const game_params *params)
{
return TRUE;
}
-static char *game_text_format(game_state *state)
+static char *game_text_format(const game_state *state)
{
int len, x, y, i;
char *ret, *p;
const char *name;
} rowcol;
-static rowcol mkrowcol(game_state *state, int num, int roworcol)
+static rowcol mkrowcol(const game_state *state, int num, int roworcol)
{
rowcol rc;
return rc;
}
-static int count_rowcol(game_state *state, int num, int roworcol, int which)
+static int count_rowcol(const game_state *state, int num, int roworcol,
+ int which)
{
int i, count = 0;
rowcol rc = mkrowcol(state, num, roworcol);
static int solve_force(game_state *state)
{
- int x, y, i, which, didsth = 0;
+ int i, which, didsth = 0;
unsigned long f;
for (i = 0; i < state->wh; i++) {
if (f == (GS_NOTNEGATIVE|GS_NOTNEUTRAL))
which = POSITIVE;
if (which != -1) {
- x = i%state->w; y = i/state->w;
if (solve_set(state, i, which, "forced by flags", NULL) < 0)
return -1;
didsth = 1;
static int solve_neither(game_state *state)
{
- int x, y, i, j, didsth = 0;
+ int i, j, didsth = 0;
for (i = 0; i < state->wh; i++) {
if (state->flags[i] & GS_SET) continue;
(state->flags[j] & GS_NOTPOSITIVE)) ||
((state->flags[i] & GS_NOTNEGATIVE) &&
(state->flags[j] & GS_NOTNEGATIVE))) {
- x = i%state->w; y = i/state->w;
if (solve_set(state, i, NEUTRAL, "neither tile magnet", NULL) < 0)
return -1;
didsth = 1;
}
-static char *game_state_diff(game_state *src, game_state *dst, int issolve)
+static char *game_state_diff(const game_state *src, const game_state *dst,
+ int issolve)
{
char *ret = NULL, buf[80], c;
int retlen = 0, x, y, i, k;
return ret;
}
-static void solve_from_aux(game_state *state, char *aux)
+static void solve_from_aux(const game_state *state, const char *aux)
{
int i;
assert(strlen(aux) == state->wh);
}
}
-static char *solve_game(game_state *state, game_state *currstate,
- char *aux, char **error)
+static char *solve_game(const game_state *state, const game_state *currstate,
+ const char *aux, char **error)
{
game_state *solved = dup_game(currstate);
char *move = NULL;
static int lay_dominoes(game_state *state, random_state *rs, int *scratch)
{
- int n, i, ret = 0, x, y, nlaid = 0, n_initial_neutral;
+ int n, i, ret = 0, nlaid = 0, n_initial_neutral;
for (i = 0; i < state->wh; i++) {
scratch[i] = i;
/* ...and lay a domino if we can. */
- x = i%state->w; y = i/state->w;
- debug(("Laying domino at i:%d, (%d,%d)\n", i, x, y));
+ debug(("Laying domino at i:%d, (%d,%d)\n", i, i%state->w, i/state->w));
/* The choice of which type of domino to lay here leads to subtle differences
* in the sorts of boards that get produced. Too much bias towards magnets
ret = solve_set(state, i, NEUTRAL, "layout", NULL);
}
if (!ret) {
- debug(("Unable to lay anything at (%d,%d), giving up.", x, y));
+ debug(("Unable to lay anything at (%d,%d), giving up.",
+ i%state->w, i/state->w));
ret = -1;
break;
}
aux[new->wh] = '\0';
}
-static int check_difficulty(game_params *params, game_state *new,
+static int check_difficulty(const game_params *params, game_state *new,
random_state *rs)
{
int *scratch, *grid_correct, slen, i;
return 0;
}
-static char *new_game_desc(game_params *params, random_state *rs,
+static char *new_game_desc(const game_params *params, random_state *rs,
char **aux_r, int interactive)
{
game_state *new = new_state(params->w, params->h);
int cur_x, cur_y, cur_visible;
};
-static game_ui *new_ui(game_state *state)
+static game_ui *new_ui(const game_state *state)
{
game_ui *ui = snew(game_ui);
ui->cur_x = ui->cur_y = 0;
sfree(ui);
}
-static char *encode_ui(game_ui *ui)
+static char *encode_ui(const game_ui *ui)
{
return NULL;
}
-static void decode_ui(game_ui *ui, char *encoding)
+static void decode_ui(game_ui *ui, const char *encoding)
{
}
-static void game_changed_state(game_ui *ui, game_state *oldstate,
- game_state *newstate)
+static void game_changed_state(game_ui *ui, const game_state *oldstate,
+ const game_state *newstate)
{
if (!oldstate->completed && newstate->completed)
ui->cur_visible = 0;
#define COORD(x) ( (x+1) * TILE_SIZE + BORDER )
#define FROMCOORD(x) ( (x - BORDER) / TILE_SIZE - 1 )
-static char *interpret_move(game_state *state, game_ui *ui, game_drawstate *ds,
- int x, int y, int button)
+static char *interpret_move(const game_state *state, game_ui *ui,
+ const game_drawstate *ds,
+ int x, int y, int button)
{
int gx = FROMCOORD(x), gy = FROMCOORD(y), idx, curr;
char *nullret = NULL, buf[80], movech;
return dupstr(buf);
}
-static game_state *execute_move(game_state *state, char *move)
+static game_state *execute_move(const game_state *state, const char *move)
{
game_state *ret = dup_game(state);
int x, y, n, idx, idx2;
* Drawing routines.
*/
-static void game_compute_size(game_params *params, int tilesize,
- int *x, int *y)
+static void game_compute_size(const game_params *params, int tilesize,
+ int *x, int *y)
{
/* Ick: fake up `ds->tilesize' for macro expansion purposes */
struct { int tilesize; } ads, *ds = &ads;
}
static void game_set_size(drawing *dr, game_drawstate *ds,
- game_params *params, int tilesize)
+ const game_params *params, int tilesize)
{
ds->tilesize = tilesize;
}
return ret;
}
-static game_drawstate *game_new_drawstate(drawing *dr, game_state *state)
+static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
{
struct game_drawstate *ds = snew(struct game_drawstate);
}
-static void game_redraw(drawing *dr, game_drawstate *ds, game_state *oldstate,
- game_state *state, int dir, game_ui *ui,
- float animtime, float flashtime)
+static void game_redraw(drawing *dr, game_drawstate *ds,
+ const game_state *oldstate, const game_state *state,
+ int dir, const game_ui *ui,
+ float animtime, float flashtime)
{
int x, y, w = state->w, h = state->h, which, i, j, flash;
unsigned long c = 0;
ds->started = 1;
}
-static float game_anim_length(game_state *oldstate, game_state *newstate,
- int dir, game_ui *ui)
+static float game_anim_length(const game_state *oldstate,
+ const game_state *newstate, int dir, game_ui *ui)
{
return 0.0F;
}
-static float game_flash_length(game_state *oldstate, game_state *newstate,
- int dir, game_ui *ui)
+static float game_flash_length(const game_state *oldstate,
+ const game_state *newstate, int dir, game_ui *ui)
{
if (!oldstate->completed && newstate->completed &&
!oldstate->solved && !newstate->solved)
return 0.0F;
}
-static int game_is_solved(game_state *state)
+static int game_status(const game_state *state)
{
- return state->completed;
+ return state->completed ? +1 : 0;
}
-static int game_timing_state(game_state *state, game_ui *ui)
+static int game_timing_state(const game_state *state, game_ui *ui)
{
return TRUE;
}
-static void game_print_size(game_params *params, float *x, float *y)
+static void game_print_size(const game_params *params, float *x, float *y)
{
int pw, ph;
*y = ph / 100.0F;
}
-static void game_print(drawing *dr, game_state *state, int tilesize)
+static void game_print(drawing *dr, const game_state *state, int tilesize)
{
int w = state->w, h = state->h;
int ink = print_mono_colour(dr, 0);
int paper = print_mono_colour(dr, 1);
- int x, y, target, count, which, i, j;
+ int x, y, which, i, j;
/* Ick: fake up `ds->tilesize' for macro expansion purposes */
game_drawstate ads, *ds = &ads;
draw_sym(dr, ds, state->w, state->h, NEGATIVE, ink);
for (which = POSITIVE, j = 0; j < 2; which = OPPOSITE(which), j++) {
for (i = 0; i < w; i++) {
- target = state->common->colcount[i*3+which];
- count = count_rowcol(state, i, COLUMN, which);
draw_num_col(dr, ds, COLUMN, which, i, paper, ink,
- state->common->colcount[i*3+which]);
+ state->common->colcount[i*3+which]);
}
for (i = 0; i < h; i++) {
- target = state->common->rowcount[i*3+which];
- count = count_rowcol(state, i, ROW, which);
draw_num_col(dr, ds, ROW, which, i, paper, ink,
- state->common->rowcount[i*3+which]);
+ state->common->rowcount[i*3+which]);
}
}
game_redraw,
game_anim_length,
game_flash_length,
- game_is_solved,
+ game_status,
TRUE, FALSE, game_print_size, game_print,
FALSE, /* wants_statusbar */
FALSE, game_timing_state,