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 data[256];
return dupstr(data);
}
-static config_item *game_configure(game_params *params)
+static config_item *game_configure(const game_params *params)
{
config_item *ret;
char buf[80];
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)
{
/*
* Avoid completely degenerate cases which only have one
return grid;
}
-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, int interactive)
{
return gengrid(params->w, params->h, rs);
}
-static char *validate_desc(game_params *params, char *desc)
+static char *validate_desc(const game_params *params, const char *desc)
{
int w = params->w, h = params->h, wh = w*h;
int starts = 0, gems = 0, i;
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)
{
int w = params->w, h = params->h, wh = w*h;
int i;
return state;
}
-static game_state *dup_game(game_state *state)
+static game_state *dup_game(const game_state *state)
{
int w = state->p.w, h = state->p.h, wh = w*h;
game_state *ret = snew(game_state);
return 0;
}
-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)
{
- int w = state->p.w, h = state->p.h, wh = w*h;
+ int w = currstate->p.w, h = currstate->p.h, wh = w*h;
int *nodes, *nodeindex, *edges, *backedges, *edgei, *backedgei, *circuit;
int nedges;
int *dist, *dist2, *list;
return soln;
}
-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)
{
- return NULL;
+ int w = state->p.w, h = state->p.h, r, c;
+ int cw = 4, ch = 2, gw = cw*w + 2, gh = ch * h + 1, len = gw * gh;
+ char *board = snewn(len + 1, char);
+
+ sprintf(board, "%*s+\n", len - 2, "");
+
+ for (r = 0; r < h; ++r) {
+ for (c = 0; c < w; ++c) {
+ int cell = r*ch*gw + cw*c, center = cell + gw*ch/2 + cw/2;
+ int i = r*w + c;
+ switch (state->grid[i]) {
+ case BLANK: break;
+ case GEM: board[center] = 'o'; break;
+ case MINE: board[center] = 'M'; break;
+ case STOP: board[center-1] = '('; board[center+1] = ')'; break;
+ case WALL: memset(board + center - 1, 'X', 3);
+ }
+
+ if (r == state->py && c == state->px) {
+ if (!state->dead) board[center] = '@';
+ else memcpy(board + center - 1, ":-(", 3);
+ }
+ board[cell] = '+';
+ memset(board + cell + 1, '-', cw - 1);
+ for (i = 1; i < ch; ++i) board[cell + i*gw] = '|';
+ }
+ for (c = 0; c < ch; ++c) {
+ board[(r*ch+c)*gw + gw - 2] = "|+"[!c];
+ board[(r*ch+c)*gw + gw - 1] = '\n';
+ }
+ }
+ memset(board + len - gw, '-', gw - 2);
+ for (c = 0; c < w; ++c) board[len - gw + cw*c] = '+';
+
+ return board;
}
struct game_ui {
int just_died;
};
-static game_ui *new_ui(game_state *state)
+static game_ui *new_ui(const game_state *state)
{
game_ui *ui = snew(game_ui);
ui->anim_length = 0.0F;
sfree(ui);
}
-static char *encode_ui(game_ui *ui)
+static char *encode_ui(const game_ui *ui)
{
char buf[80];
/*
return dupstr(buf);
}
-static void decode_ui(game_ui *ui, char *encoding)
+static void decode_ui(game_ui *ui, const char *encoding)
{
int p = 0;
sscanf(encoding, "D%d%n", &ui->deaths, &p);
}
-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)
{
/*
* Increment the deaths counter. We only do this if
#define COORD(x) ( (x) * TILESIZE + BORDER )
#define FROMCOORD(x) ( ((x) - BORDER + TILESIZE) / TILESIZE - 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 w = state->p.w, h = state->p.h /*, wh = w*h */;
int dir;
return dupstr(buf);
}
-static game_state *execute_move(game_state *state, char *move)
+static void install_new_solution(game_state *ret, const char *move)
+{
+ int i;
+ soln *sol;
+ assert (*move == 'S');
+ ++move;
+
+ sol = snew(soln);
+ sol->len = strlen(move);
+ sol->list = snewn(sol->len, unsigned char);
+ for (i = 0; i < sol->len; ++i) sol->list[i] = move[i] - '0';
+
+ if (ret->soln && --ret->soln->refcount == 0) {
+ sfree(ret->soln->list);
+ sfree(ret->soln);
+ }
+
+ ret->soln = sol;
+ sol->refcount = 1;
+
+ ret->cheated = TRUE;
+ ret->solnpos = 0;
+}
+
+static void discard_solution(game_state *ret)
+{
+ --ret->soln->refcount;
+ assert(ret->soln->refcount > 0); /* ret has a soln-pointing dup */
+ ret->soln = NULL;
+ ret->solnpos = 0;
+}
+
+static game_state *execute_move(const game_state *state, const char *move)
{
int w = state->p.w, h = state->p.h /*, wh = w*h */;
int dir;
game_state *ret;
if (*move == 'S') {
- int len, i;
- soln *sol;
-
/*
* This is a solve move, so we don't actually _change_ the
* grid but merely set up a stored solution path.
*/
- move++;
- len = strlen(move);
- sol = snew(soln);
- sol->len = len;
- sol->list = snewn(len, unsigned char);
- for (i = 0; i < len; i++)
- sol->list[i] = move[i] - '0';
ret = dup_game(state);
- ret->cheated = TRUE;
- if (ret->soln && --ret->soln->refcount == 0) {
- sfree(ret->soln->list);
- sfree(ret->soln);
- }
- ret->soln = sol;
- ret->solnpos = 0;
- sol->refcount = 1;
+ install_new_solution(ret, move);
return ret;
}
}
if (ret->soln) {
- /*
- * If this move is the correct next one in the stored
- * solution path, advance solnpos.
- */
- if (ret->soln->list[ret->solnpos] == dir &&
- ret->solnpos+1 < ret->soln->len) {
- ret->solnpos++;
+ if (ret->dead || ret->gems == 0)
+ discard_solution(ret);
+ else if (ret->soln->list[ret->solnpos] == dir) {
+ ++ret->solnpos;
+ assert(ret->solnpos < ret->soln->len); /* or gems == 0 */
+ assert(!ret->dead); /* or not a solution */
} else {
- /*
- * Otherwise, the user has strayed from the path, so
- * the path is no longer valid.
- */
- ret->soln->refcount--;
- assert(ret->soln->refcount > 0);/* `state' at least still exists */
- ret->soln = NULL;
- ret->solnpos = 0;
+ char *error = NULL, *soln = solve_game(NULL, ret, NULL, &error);
+ if (!error) {
+ install_new_solution(ret, soln);
+ sfree(soln);
+ } else discard_solution(ret);
}
}
* 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)
{
int w = state->p.w, h = state->p.h, wh = w*h;
struct game_drawstate *ds = snew(struct game_drawstate);
#define BASE_ANIM_LENGTH 0.1F
#define FLASH_LENGTH 0.3F
-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 w = state->p.w, h = state->p.h /*, wh = w*h */;
int x, y;
ds->player_bg_saved = TRUE;
}
-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)
{
int dist;
if (dir > 0)
return ui->anim_length;
}
-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->dead && newstate->dead) {
ui->flashtype = FLASH_DEAD;
return 0.0F;
}
-static int game_status(game_state *state)
+static int game_status(const game_state *state)
{
/*
* We never report the game as lost, on the grounds that if the
return state->gems == 0 ? +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)
{
}
-static void game_print(drawing *dr, game_state *state, int tilesize)
+static void game_print(drawing *dr, const game_state *state, int tilesize)
{
}
dup_game,
free_game,
TRUE, solve_game,
- FALSE, game_can_format_as_text_now, game_text_format,
+ TRUE, game_can_format_as_text_now, game_text_format,
new_ui,
free_ui,
encode_ui,
~ian / sgt-puzzles.git / blobdiff