#include "puzzles.h"
#include "tree234.h"
-#define PI 3.141592653589793238462643383279502884197169399
-
#define MATMUL(xr,yr,m,x,y) do { \
float rx, ry, xx = (x), yy = (y), *mat = (m); \
rx = mat[0] * xx + mat[2] * yy; \
#define COUNT(x) ( (((x) & 0x08) >> 3) + (((x) & 0x04) >> 2) + \
(((x) & 0x02) >> 1) + ((x) & 0x01) )
-#define TILE_SIZE 48
+#define PREFERRED_TILE_SIZE 48
+#define TILE_SIZE (ds->tilesize)
#define BORDER TILE_SIZE
#define TILE_BORDER 1
#define WINDOW_OFFSET 0
int height;
int wrapping;
float barrier_probability;
-};
-
-struct solved_game_state {
- int width, height;
- int refcount;
- unsigned char *tiles;
+ int movetarget;
};
struct game_state {
int width, height, cx, cy, wrapping, completed;
- int used_solve, just_used_solve;
- int move_count;
+ int used_solve;
+ int move_count, movetarget;
/* position (row or col number, starting at 0) of last move. */
int last_move_row, last_move_col;
unsigned char *tiles;
unsigned char *barriers;
- struct solved_game_state *solution;
};
#define OFFSET(x2,y2,x1,y1,dir,state) \
if (a->direction > b->direction)
return +1;
return 0;
-};
+}
static struct xyd *new_xyd(int x, int y, int direction)
{
}
static void slide_col(game_state *state, int dir, int col);
+static void slide_col_int(int w, int h, unsigned char *tiles, int dir, int col);
static void slide_row(game_state *state, int dir, int row);
+static void slide_row_int(int w, int h, unsigned char *tiles, int dir, int row);
/* ----------------------------------------------------------------------
* Manage game parameters.
ret->height = 3;
ret->wrapping = FALSE;
ret->barrier_probability = 1.0;
+ ret->movetarget = 0;
return ret;
}
+static const struct { int x, y, wrap, bprob; const char* desc; }
+netslide_presets[] = {
+ {3, 3, FALSE, 1, " easy"},
+ {3, 3, FALSE, 0, " medium"},
+ {3, 3, TRUE, 0, " hard"},
+ {4, 4, FALSE, 1, " easy"},
+ {4, 4, FALSE, 0, " medium"},
+ {4, 4, TRUE, 0, " hard"},
+ {5, 5, FALSE, 1, " easy"},
+ {5, 5, FALSE, 0, " medium"},
+ {5, 5, TRUE, 0, " hard"},
+};
+
static int game_fetch_preset(int i, char **name, game_params **params)
{
game_params *ret;
char str[80];
- static const struct { int x, y, wrap, bprob; const char* desc; } values[] = {
- {3, 3, FALSE, 1.0, " easy"},
- {3, 3, FALSE, 0.0, " medium"},
- {3, 3, TRUE, 0.0, " hard"},
- {4, 4, FALSE, 1.0, " easy"},
- {4, 4, FALSE, 0.0, " medium"},
- {4, 4, TRUE, 0.0, " hard"},
- {5, 5, FALSE, 1.0, " easy"},
- {5, 5, FALSE, 0.0, " medium"},
- {5, 5, TRUE, 0.0, " hard"},
- };
-
- if (i < 0 || i >= lenof(values))
+
+ if (i < 0 || i >= lenof(netslide_presets))
return FALSE;
ret = snew(game_params);
- ret->width = values[i].x;
- ret->height = values[i].y;
- ret->wrapping = values[i].wrap;
- ret->barrier_probability = values[i].bprob;
+ ret->width = netslide_presets[i].x;
+ ret->height = netslide_presets[i].y;
+ ret->wrapping = netslide_presets[i].wrap;
+ ret->barrier_probability = (float)netslide_presets[i].bprob;
+ ret->movetarget = 0;
- sprintf(str, "%dx%d%s", ret->width, ret->height,
- values[i].desc);
+ sprintf(str, "%dx%d%s", ret->width, ret->height, netslide_presets[i].desc);
*name = dupstr(str);
*params = ret;
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 */
return ret;
}
-static game_params *decode_params(char const *string)
+static void decode_params(game_params *ret, char const *string)
{
- game_params *ret = default_params();
char const *p = string;
ret->wrapping = FALSE;
ret->barrier_probability = 0.0;
+ ret->movetarget = 0;
ret->width = atoi(p);
- while (*p && isdigit(*p)) p++;
+ while (*p && isdigit((unsigned char)*p)) p++;
if (*p == 'x') {
p++;
ret->height = atoi(p);
- while (*p && isdigit(*p)) p++;
+ while (*p && isdigit((unsigned char)*p)) p++;
if ( (ret->wrapping = (*p == 'w')) != 0 )
p++;
- if (*p == 'b')
- ret->barrier_probability = atof(p+1);
+ if (*p == 'b') {
+ ret->barrier_probability = (float)atof(++p);
+ while (*p && (isdigit((unsigned char)*p) || *p == '.')) p++;
+ }
+ if (*p == 'm') {
+ ret->movetarget = atoi(++p);
+ }
} else {
ret->height = ret->width;
}
-
- return ret;
}
-static char *encode_params(game_params *params)
+static char *encode_params(const game_params *params, int full)
{
char ret[400];
int len;
len = sprintf(ret, "%dx%d", params->width, params->height);
if (params->wrapping)
ret[len++] = 'w';
- if (params->barrier_probability)
+ if (full && params->barrier_probability)
len += sprintf(ret+len, "b%g", params->barrier_probability);
+ /* Shuffle limit is part of the limited parameters, because we have to
+ * provide the target move count. */
+ if (params->movetarget)
+ len += sprintf(ret+len, "m%d", params->movetarget);
assert(len < lenof(ret));
ret[len] = '\0';
return dupstr(ret);
}
-static config_item *game_configure(game_params *params)
+static config_item *game_configure(const game_params *params)
{
config_item *ret;
char buf[80];
- ret = snewn(5, config_item);
+ ret = snewn(6, config_item);
ret[0].name = "Width";
ret[0].type = C_STRING;
ret[3].sval = dupstr(buf);
ret[3].ival = 0;
- ret[4].name = NULL;
- ret[4].type = C_END;
- ret[4].sval = NULL;
+ ret[4].name = "Number of shuffling moves";
+ ret[4].type = C_STRING;
+ sprintf(buf, "%d", params->movetarget);
+ ret[4].sval = dupstr(buf);
ret[4].ival = 0;
+ ret[5].name = NULL;
+ ret[5].type = C_END;
+ ret[5].sval = NULL;
+ ret[5].ival = 0;
+
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);
ret->height = atoi(cfg[1].sval);
ret->wrapping = cfg[2].ival;
ret->barrier_probability = (float)atof(cfg[3].sval);
+ ret->movetarget = atoi(cfg[4].sval);
return ret;
}
-static char *validate_params(game_params *params)
+static char *validate_params(const game_params *params, int full)
{
- if (params->width <= 1 && params->height <= 1)
+ if (params->width <= 1 || params->height <= 1)
return "Width and height must both be greater than one";
- if (params->width <= 1)
- return "Width must be greater than one";
- if (params->height <= 1)
- return "Height must be greater than one";
if (params->barrier_probability < 0)
return "Barrier probability may not be negative";
if (params->barrier_probability > 1)
}
/* ----------------------------------------------------------------------
- * Randomly select a new game seed.
+ * Randomly select a new game description.
*/
-static char *new_game_seed(game_params *params, random_state *rs,
- game_aux_info **aux)
+static char *new_game_desc(const game_params *params, random_state *rs,
+ char **aux, int interactive)
{
- /*
- * The full description of a Net game is far too large to
- * encode directly in the seed, so by default we'll have to go
- * for the simple approach of providing a random-number seed.
- *
- * (This does not restrict me from _later on_ inventing a seed
- * string syntax which can never be generated by this code -
- * for example, strings beginning with a letter - allowing me
- * to type in a precise game, and have new_game detect it and
- * understand it and do something completely different.)
- */
- char buf[40];
- sprintf(buf, "%lu", random_bits(rs, 32));
- return dupstr(buf);
-}
+ tree234 *possibilities, *barriertree;
+ int w, h, x, y, cx, cy, nbarriers;
+ unsigned char *tiles, *barriers;
+ char *desc, *p;
-static void game_free_aux_info(game_aux_info *aux)
-{
- assert(!"Shouldn't happen");
-}
+ w = params->width;
+ h = params->height;
-static char *validate_seed(game_params *params, char *seed)
-{
- /*
- * Since any string at all will suffice to seed the RNG, there
- * is no validation required.
- */
- return NULL;
-}
+ tiles = snewn(w * h, unsigned char);
+ memset(tiles, 0, w * h);
+ barriers = snewn(w * h, unsigned char);
+ memset(barriers, 0, w * h);
-/* ----------------------------------------------------------------------
- * Construct an initial game state, given a seed and parameters.
- */
-
-static game_state *new_game(game_params *params, char *seed)
-{
- random_state *rs;
- game_state *state;
- tree234 *possibilities, *barriers;
- int w, h, x, y, nbarriers;
-
- assert(params->width > 0 && params->height > 0);
- assert(params->width > 1 || params->height > 1);
-
- /*
- * Create a blank game state.
- */
- state = snew(game_state);
- w = state->width = params->width;
- h = state->height = params->height;
- state->cx = state->width / 2;
- state->cy = state->height / 2;
- state->wrapping = params->wrapping;
- state->completed = 0;
- state->used_solve = state->just_used_solve = FALSE;
- state->move_count = 0;
- state->last_move_row = -1;
- state->last_move_col = -1;
- state->last_move_dir = 0;
- state->tiles = snewn(state->width * state->height, unsigned char);
- memset(state->tiles, 0, state->width * state->height);
- state->barriers = snewn(state->width * state->height, unsigned char);
- memset(state->barriers, 0, state->width * state->height);
-
- /*
- * Set up border barriers if this is a non-wrapping game.
- */
- if (!state->wrapping) {
- for (x = 0; x < state->width; x++) {
- barrier(state, x, 0) |= U;
- barrier(state, x, state->height-1) |= D;
- }
- for (y = 0; y < state->height; y++) {
- barrier(state, 0, y) |= L;
- barrier(state, state->width-1, y) |= R;
- }
- }
-
- /*
- * Seed the internal random number generator.
- */
- rs = random_init(seed, strlen(seed));
+ cx = w / 2;
+ cy = h / 2;
/*
* Construct the unshuffled grid.
*/
possibilities = newtree234(xyd_cmp);
- if (state->cx+1 < state->width)
- add234(possibilities, new_xyd(state->cx, state->cy, R));
- if (state->cy-1 >= 0)
- add234(possibilities, new_xyd(state->cx, state->cy, U));
- if (state->cx-1 >= 0)
- add234(possibilities, new_xyd(state->cx, state->cy, L));
- if (state->cy+1 < state->height)
- add234(possibilities, new_xyd(state->cx, state->cy, D));
+ if (cx+1 < w)
+ add234(possibilities, new_xyd(cx, cy, R));
+ if (cy-1 >= 0)
+ add234(possibilities, new_xyd(cx, cy, U));
+ if (cx-1 >= 0)
+ add234(possibilities, new_xyd(cx, cy, L));
+ if (cy+1 < h)
+ add234(possibilities, new_xyd(cx, cy, D));
while (count234(possibilities) > 0) {
int i;
d1 = xyd->direction;
sfree(xyd);
- OFFSET(x2, y2, x1, y1, d1, state);
+ OFFSET(x2, y2, x1, y1, d1, params);
d2 = F(d1);
-#ifdef DEBUG
+#ifdef GENERATION_DIAGNOSTICS
printf("picked (%d,%d,%c) <-> (%d,%d,%c)\n",
x1, y1, "0RU3L567D9abcdef"[d1], x2, y2, "0RU3L567D9abcdef"[d2]);
#endif
* Make the connection. (We should be moving to an as yet
* unused tile.)
*/
- tile(state, x1, y1) |= d1;
- assert(tile(state, x2, y2) == 0);
- tile(state, x2, y2) |= d2;
+ index(params, tiles, x1, y1) |= d1;
+ assert(index(params, tiles, x2, y2) == 0);
+ index(params, tiles, x2, y2) |= d2;
/*
* If we have created a T-piece, remove its last
* possibility.
*/
- if (COUNT(tile(state, x1, y1)) == 3) {
+ if (COUNT(index(params, tiles, x1, y1)) == 3) {
struct xyd xyd1, *xydp;
xyd1.x = x1;
xyd1.y = y1;
- xyd1.direction = 0x0F ^ tile(state, x1, y1);
+ xyd1.direction = 0x0F ^ index(params, tiles, x1, y1);
xydp = find234(possibilities, &xyd1, NULL);
if (xydp) {
-#ifdef DEBUG
+#ifdef GENERATION_DIAGNOSTICS
printf("T-piece; removing (%d,%d,%c)\n",
xydp->x, xydp->y, "0RU3L567D9abcdef"[xydp->direction]);
#endif
int x3, y3, d3;
struct xyd xyd1, *xydp;
- OFFSET(x3, y3, x2, y2, d, state);
+ OFFSET(x3, y3, x2, y2, d, params);
d3 = F(d);
xyd1.x = x3;
xydp = find234(possibilities, &xyd1, NULL);
if (xydp) {
-#ifdef DEBUG
+#ifdef GENERATION_DIAGNOSTICS
printf("Loop avoidance; removing (%d,%d,%c)\n",
xydp->x, xydp->y, "0RU3L567D9abcdef"[xydp->direction]);
#endif
if (d == d2)
continue; /* we've got this one already */
- if (!state->wrapping) {
+ if (!params->wrapping) {
if (d == U && y2 == 0)
continue;
- if (d == D && y2 == state->height-1)
+ if (d == D && y2 == h-1)
continue;
if (d == L && x2 == 0)
continue;
- if (d == R && x2 == state->width-1)
+ if (d == R && x2 == w-1)
continue;
}
- OFFSET(x3, y3, x2, y2, d, state);
+ OFFSET(x3, y3, x2, y2, d, params);
- if (tile(state, x3, y3))
+ if (index(params, tiles, x3, y3))
continue; /* this would create a loop */
-#ifdef DEBUG
+#ifdef GENERATION_DIAGNOSTICS
printf("New frontier; adding (%d,%d,%c)\n",
x2, y2, "0RU3L567D9abcdef"[d]);
#endif
/*
* Now compute a list of the possible barrier locations.
*/
- barriers = newtree234(xyd_cmp);
- for (y = 0; y < state->height; y++) {
- for (x = 0; x < state->width; x++) {
-
- if (!(tile(state, x, y) & R) &&
- (state->wrapping || x < state->width-1))
- add234(barriers, new_xyd(x, y, R));
- if (!(tile(state, x, y) & D) &&
- (state->wrapping || y < state->height-1))
- add234(barriers, new_xyd(x, y, D));
+ barriertree = newtree234(xyd_cmp);
+ for (y = 0; y < h; y++) {
+ for (x = 0; x < w; x++) {
+
+ if (!(index(params, tiles, x, y) & R) &&
+ (params->wrapping || x < w-1))
+ add234(barriertree, new_xyd(x, y, R));
+ if (!(index(params, tiles, x, y) & D) &&
+ (params->wrapping || y < h-1))
+ add234(barriertree, new_xyd(x, y, D));
}
}
/*
- * Save the unshuffled grid. We do this using a separate
- * reference-counted structure since it's a large chunk of
- * memory which we don't want to have to replicate in every
- * game state while playing.
+ * Save the unshuffled grid in aux.
*/
{
- struct solved_game_state *solution;
+ char *solution;
+ int i;
+
+ /*
+ * String format is exactly the same as a solve move, so we
+ * can just dupstr this in solve_game().
+ */
- solution = snew(struct solved_game_state);
- solution->width = state->width;
- solution->height = state->height;
- solution->refcount = 1;
- solution->tiles = snewn(state->width * state->height, unsigned char);
- memcpy(solution->tiles, state->tiles, state->width * state->height);
+ solution = snewn(w * h + 2, char);
+ solution[0] = 'S';
+ for (i = 0; i < w * h; i++)
+ solution[i+1] = "0123456789abcdef"[tiles[i] & 0xF];
+ solution[w*h+1] = '\0';
- state->solution = solution;
+ *aux = solution;
}
/*
* Now shuffle the grid.
- * FIXME - this simply does a set of random moves to shuffle the pieces.
+ * FIXME - this simply does a set of random moves to shuffle the pieces,
+ * although we make a token effort to avoid boring cases by avoiding moves
+ * that directly undo the previous one, or that repeat so often as to
+ * turn into fewer moves.
+ *
* A better way would be to number all the pieces, generate a placement
* for all the numbers as for "sixteen", observing parity constraints if
* neccessary, and then place the pieces according to their numbering.
*/
{
int i;
- int cols = state->width - 1;
- int rows = state->height - 1;
- for (i = 0; i < cols * rows * 2; i++) {
+ int cols = w - 1;
+ int rows = h - 1;
+ int moves = params->movetarget;
+ int prevdir = -1, prevrowcol = -1, nrepeats = 0;
+ if (!moves) moves = cols * rows * 2;
+ for (i = 0; i < moves; /* incremented conditionally */) {
/* Choose a direction: 0,1,2,3 = up, right, down, left. */
int dir = random_upto(rs, 4);
+ int rowcol;
if (dir % 2 == 0) {
int col = random_upto(rs, cols);
- if (col >= state->cx) col += 1;
- slide_col(state, 1 - dir, col);
+ if (col >= cx) col += 1; /* avoid centre */
+ if (col == prevrowcol) {
+ if (dir == 2-prevdir)
+ continue; /* undoes last move */
+ else if (dir == prevdir && (nrepeats+1)*2 > h)
+ continue; /* makes fewer moves */
+ }
+ slide_col_int(w, h, tiles, 1 - dir, col);
+ rowcol = col;
} else {
int row = random_upto(rs, rows);
- if (row >= state->cy) row += 1;
- slide_row(state, 2 - dir, row);
+ if (row >= cy) row += 1; /* avoid centre */
+ if (row == prevrowcol) {
+ if (dir == 4-prevdir)
+ continue; /* undoes last move */
+ else if (dir == prevdir && (nrepeats+1)*2 > w)
+ continue; /* makes fewer moves */
+ }
+ slide_row_int(w, h, tiles, 2 - dir, row);
+ rowcol = row;
}
+ if (dir == prevdir && rowcol == prevrowcol)
+ nrepeats++;
+ else
+ nrepeats = 1;
+ prevdir = dir;
+ prevrowcol = rowcol;
+ i++; /* if we got here, the move was accepted */
}
}
/*
* And now choose barrier locations. (We carefully do this
* _after_ shuffling, so that changing the barrier rate in the
- * params while keeping the game seed the same will give the
+ * params while keeping the random seed the same will give the
* same shuffled grid and _only_ change the barrier locations.
* Also the way we choose barrier locations, by repeatedly
* choosing one possibility from the list until we have enough,
* the original 10 plus 10 more, rather than getting 20 new
* ones and the chance of remembering your first 10.)
*/
- nbarriers = (int)(params->barrier_probability * count234(barriers));
- assert(nbarriers >= 0 && nbarriers <= count234(barriers));
+ nbarriers = (int)(params->barrier_probability * count234(barriertree));
+ assert(nbarriers >= 0 && nbarriers <= count234(barriertree));
while (nbarriers > 0) {
int i;
/*
* Extract a randomly chosen barrier from the list.
*/
- i = random_upto(rs, count234(barriers));
- xyd = delpos234(barriers, i);
+ i = random_upto(rs, count234(barriertree));
+ xyd = delpos234(barriertree, i);
assert(xyd != NULL);
d1 = xyd->direction;
sfree(xyd);
- OFFSET(x2, y2, x1, y1, d1, state);
+ OFFSET(x2, y2, x1, y1, d1, params);
d2 = F(d1);
- barrier(state, x1, y1) |= d1;
- barrier(state, x2, y2) |= d2;
+ index(params, barriers, x1, y1) |= d1;
+ index(params, barriers, x2, y2) |= d2;
nbarriers--;
}
{
struct xyd *xyd;
- while ( (xyd = delpos234(barriers, 0)) != NULL)
+ while ( (xyd = delpos234(barriertree, 0)) != NULL)
sfree(xyd);
- freetree234(barriers);
+ freetree234(barriertree);
+ }
+
+ /*
+ * Finally, encode the grid into a string game description.
+ *
+ * My syntax is extremely simple: each square is encoded as a
+ * hex digit in which bit 0 means a connection on the right,
+ * bit 1 means up, bit 2 left and bit 3 down. (i.e. the same
+ * encoding as used internally). Each digit is followed by
+ * optional barrier indicators: `v' means a vertical barrier to
+ * the right of it, and `h' means a horizontal barrier below
+ * it.
+ */
+ desc = snewn(w * h * 3 + 1, char);
+ p = desc;
+ for (y = 0; y < h; y++) {
+ for (x = 0; x < w; x++) {
+ *p++ = "0123456789abcdef"[index(params, tiles, x, y)];
+ if ((params->wrapping || x < w-1) &&
+ (index(params, barriers, x, y) & R))
+ *p++ = 'v';
+ if ((params->wrapping || y < h-1) &&
+ (index(params, barriers, x, y) & D))
+ *p++ = 'h';
+ }
+ }
+ assert(p - desc <= w*h*3);
+ *p = '\0';
+
+ sfree(tiles);
+ sfree(barriers);
+
+ return desc;
+}
+
+static char *validate_desc(const game_params *params, const char *desc)
+{
+ int w = params->width, h = params->height;
+ int i;
+
+ for (i = 0; i < w*h; i++) {
+ if (*desc >= '0' && *desc <= '9')
+ /* OK */;
+ else if (*desc >= 'a' && *desc <= 'f')
+ /* OK */;
+ else if (*desc >= 'A' && *desc <= 'F')
+ /* OK */;
+ else if (!*desc)
+ return "Game description shorter than expected";
+ else
+ return "Game description contained unexpected character";
+ desc++;
+ while (*desc == 'h' || *desc == 'v')
+ desc++;
+ }
+ if (*desc)
+ return "Game description longer than expected";
+
+ return NULL;
+}
+
+/* ----------------------------------------------------------------------
+ * Construct an initial game state, given a description and parameters.
+ */
+
+static game_state *new_game(midend *me, const game_params *params,
+ const char *desc)
+{
+ game_state *state;
+ int w, h, x, y;
+
+ assert(params->width > 0 && params->height > 0);
+ assert(params->width > 1 || params->height > 1);
+
+ /*
+ * Create a blank game state.
+ */
+ state = snew(game_state);
+ w = state->width = params->width;
+ h = state->height = params->height;
+ state->cx = state->width / 2;
+ state->cy = state->height / 2;
+ state->wrapping = params->wrapping;
+ state->movetarget = params->movetarget;
+ state->completed = 0;
+ state->used_solve = FALSE;
+ state->move_count = 0;
+ state->last_move_row = -1;
+ state->last_move_col = -1;
+ state->last_move_dir = 0;
+ state->tiles = snewn(state->width * state->height, unsigned char);
+ memset(state->tiles, 0, state->width * state->height);
+ state->barriers = snewn(state->width * state->height, unsigned char);
+ memset(state->barriers, 0, state->width * state->height);
+
+
+ /*
+ * Parse the game description into the grid.
+ */
+ for (y = 0; y < h; y++) {
+ for (x = 0; x < w; x++) {
+ if (*desc >= '0' && *desc <= '9')
+ tile(state, x, y) = *desc - '0';
+ else if (*desc >= 'a' && *desc <= 'f')
+ tile(state, x, y) = *desc - 'a' + 10;
+ else if (*desc >= 'A' && *desc <= 'F')
+ tile(state, x, y) = *desc - 'A' + 10;
+ if (*desc)
+ desc++;
+ while (*desc == 'h' || *desc == 'v') {
+ int x2, y2, d1, d2;
+ if (*desc == 'v')
+ d1 = R;
+ else
+ d1 = D;
+
+ OFFSET(x2, y2, x, y, d1, state);
+ d2 = F(d1);
+
+ barrier(state, x, y) |= d1;
+ barrier(state, x2, y2) |= d2;
+
+ desc++;
+ }
+ }
+ }
+
+ /*
+ * Set up border barriers if this is a non-wrapping game.
+ */
+ if (!state->wrapping) {
+ for (x = 0; x < state->width; x++) {
+ barrier(state, x, 0) |= U;
+ barrier(state, x, state->height-1) |= D;
+ }
+ for (y = 0; y < state->height; y++) {
+ barrier(state, 0, y) |= L;
+ barrier(state, state->width-1, y) |= R;
+ }
}
/*
}
}
- random_free(rs);
-
return state;
}
-static game_state *dup_game(game_state *state)
+static game_state *dup_game(const game_state *state)
{
game_state *ret;
ret->cx = state->cx;
ret->cy = state->cy;
ret->wrapping = state->wrapping;
+ ret->movetarget = state->movetarget;
ret->completed = state->completed;
ret->used_solve = state->used_solve;
- ret->just_used_solve = state->just_used_solve;
ret->move_count = state->move_count;
ret->last_move_row = state->last_move_row;
ret->last_move_col = state->last_move_col;
memcpy(ret->tiles, state->tiles, state->width * state->height);
ret->barriers = snewn(state->width * state->height, unsigned char);
memcpy(ret->barriers, state->barriers, state->width * state->height);
- ret->solution = state->solution;
- if (ret->solution)
- ret->solution->refcount++;
return ret;
}
static void free_game(game_state *state)
{
- if (state->solution && --state->solution->refcount <= 0) {
- sfree(state->solution->tiles);
- sfree(state->solution);
- }
sfree(state->tiles);
sfree(state->barriers);
sfree(state);
}
-static game_state *solve_game(game_state *state, game_aux_info *aux,
- char **error)
+static char *solve_game(const game_state *state, const game_state *currstate,
+ const char *aux, char **error)
{
- game_state *ret;
-
- if (!state->solution) {
- /*
- * 2005-05-02: This shouldn't happen, at the time of
- * writing, because Net is incapable of receiving a puzzle
- * description from outside. If in future it becomes so,
- * then we will have puzzles for which we don't know the
- * solution.
- */
+ if (!aux) {
*error = "Solution not known for this puzzle";
return NULL;
}
- assert(state->solution->width == state->width);
- assert(state->solution->height == state->height);
- ret = dup_game(state);
- memcpy(ret->tiles, state->solution->tiles, ret->width * ret->height);
- ret->used_solve = ret->just_used_solve = TRUE;
- ret->completed = ret->move_count = 1;
+ return dupstr(aux);
+}
- return ret;
+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;
}
* squares in the moving_row and moving_col are always inactive - this
* is so that "current" doesn't appear to jump across moving lines.
*/
-static unsigned char *compute_active(game_state *state,
+static unsigned char *compute_active(const game_state *state,
int moving_row, int moving_col)
{
unsigned char *active;
int 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 = state->width / 2;
- ui->cur_y = state->height / 2;
+ ui->cur_x = 0;
+ ui->cur_y = -1;
ui->cur_visible = FALSE;
return ui;
sfree(ui);
}
+static char *encode_ui(const game_ui *ui)
+{
+ return NULL;
+}
+
+static void decode_ui(game_ui *ui, const char *encoding)
+{
+}
+
/* ----------------------------------------------------------------------
* Process a move.
*/
-static void slide_row(game_state *state, int dir, int row)
+static void slide_row_int(int w, int h, unsigned char *tiles, int dir, int row)
{
- int x = dir > 0 ? -1 : state->width;
+ int x = dir > 0 ? -1 : w;
int tx = x + dir;
- int n = state->width - 1;
- unsigned char endtile = state->tiles[T(state, tx, row)];
+ int n = w - 1;
+ unsigned char endtile = tiles[row * w + tx];
do {
x = tx;
- tx = (x + dir + state->width) % state->width;
- state->tiles[T(state, x, row)] = state->tiles[T(state, tx, row)];
+ tx = (x + dir + w) % w;
+ tiles[row * w + x] = tiles[row * w + tx];
} while (--n > 0);
- state->tiles[T(state, tx, row)] = endtile;
+ tiles[row * w + tx] = endtile;
}
-static void slide_col(game_state *state, int dir, int col)
+static void slide_col_int(int w, int h, unsigned char *tiles, int dir, int col)
{
- int y = dir > 0 ? -1 : state->height;
+ int y = dir > 0 ? -1 : h;
int ty = y + dir;
- int n = state->height - 1;
- unsigned char endtile = state->tiles[T(state, col, ty)];
+ int n = h - 1;
+ unsigned char endtile = tiles[ty * w + col];
do {
y = ty;
- ty = (y + dir + state->height) % state->height;
- state->tiles[T(state, col, y)] = state->tiles[T(state, col, ty)];
+ ty = (y + dir + h) % h;
+ tiles[y * w + col] = tiles[ty * w + col];
} while (--n > 0);
- state->tiles[T(state, col, ty)] = endtile;
+ tiles[ty * w + col] = endtile;
+}
+
+static void slide_row(game_state *state, int dir, int row)
+{
+ slide_row_int(state->width, state->height, state->tiles, dir, row);
}
-static game_state *make_move(game_state *state, game_ui *ui,
- int x, int y, int button)
+static void slide_col(game_state *state, int dir, int col)
+{
+ slide_col_int(state->width, state->height, state->tiles, dir, col);
+}
+
+static void game_changed_state(game_ui *ui, const game_state *oldstate,
+ const game_state *newstate)
+{
+}
+
+struct game_drawstate {
+ int started;
+ int width, height;
+ int tilesize;
+ unsigned char *visible;
+ int cur_x, cur_y;
+};
+
+static char *interpret_move(const game_state *state, game_ui *ui,
+ const game_drawstate *ds,
+ int x, int y, int button)
{
int cx, cy;
- int n, dx, dy;
- game_state *ret;
+ int dx, dy;
+ char buf[80];
- if (button != LEFT_BUTTON && button != RIGHT_BUTTON)
- return NULL;
+ button &= ~MOD_MASK;
- cx = (x - (BORDER + WINDOW_OFFSET + TILE_BORDER) + 2*TILE_SIZE) / TILE_SIZE - 2;
- cy = (y - (BORDER + WINDOW_OFFSET + TILE_BORDER) + 2*TILE_SIZE) / TILE_SIZE - 2;
+ if (IS_CURSOR_MOVE(button)) {
+ int cpos, diff = 0;
+ cpos = c2pos(state->width, state->height, ui->cur_x, ui->cur_y);
+ diff = c2diff(state->width, state->height, ui->cur_x, ui->cur_y, button);
+
+ if (diff != 0) {
+ do { /* we might have to do this more than once to skip missing arrows */
+ cpos += diff;
+ pos2c(state->width, state->height, cpos, &ui->cur_x, &ui->cur_y);
+ } while (ui->cur_x == state->cx || ui->cur_y == state->cy);
+ }
+
+ ui->cur_visible = 1;
+ return "";
+ }
+
+ if (button == LEFT_BUTTON || button == RIGHT_BUTTON) {
+ cx = (x - (BORDER + WINDOW_OFFSET + TILE_BORDER) + 2*TILE_SIZE) / TILE_SIZE - 2;
+ cy = (y - (BORDER + WINDOW_OFFSET + TILE_BORDER) + 2*TILE_SIZE) / TILE_SIZE - 2;
+ ui->cur_visible = 0;
+ } else if (IS_CURSOR_SELECT(button)) {
+ if (ui->cur_visible) {
+ cx = ui->cur_x;
+ cy = ui->cur_y;
+ } else {
+ /* 'click' when cursor is invisible just makes cursor visible. */
+ ui->cur_visible = 1;
+ return "";
+ }
+ } else
+ return NULL;
if (cy >= 0 && cy < state->height && cy != state->cy)
{
if (cx == -1) dx = +1;
else if (cx == state->width) dx = -1;
else return NULL;
- n = state->width;
dy = 0;
}
else if (cx >= 0 && cx < state->width && cx != state->cx)
if (cy == -1) dy = +1;
else if (cy == state->height) dy = -1;
else return NULL;
- n = state->height;
dx = 0;
}
else
dy = -dy;
}
- ret = dup_game(state);
- ret->just_used_solve = FALSE;
+ if (dx == 0)
+ sprintf(buf, "C%d,%d", cx, dy);
+ else
+ sprintf(buf, "R%d,%d", cy, dx);
+ return dupstr(buf);
+}
- if (dx == 0) slide_col(ret, dy, cx);
- else slide_row(ret, dx, cy);
+static game_state *execute_move(const game_state *from, const char *move)
+{
+ game_state *ret;
+ int c, d, col;
+
+ if ((move[0] == 'C' || move[0] == 'R') &&
+ sscanf(move+1, "%d,%d", &c, &d) == 2 &&
+ c >= 0 && c < (move[0] == 'C' ? from->width : from->height)) {
+ col = (move[0] == 'C');
+ } else if (move[0] == 'S' &&
+ strlen(move) == from->width * from->height + 1) {
+ int i;
+ ret = dup_game(from);
+ ret->used_solve = TRUE;
+ ret->completed = ret->move_count = 1;
+
+ for (i = 0; i < from->width * from->height; i++) {
+ c = move[i+1];
+ if (c >= '0' && c <= '9')
+ c -= '0';
+ else if (c >= 'A' && c <= 'F')
+ c -= 'A' - 10;
+ else if (c >= 'a' && c <= 'f')
+ c -= 'a' - 10;
+ else {
+ free_game(ret);
+ return NULL;
+ }
+ ret->tiles[i] = c;
+ }
+ return ret;
+ } else
+ return NULL; /* can't parse move string */
+
+ ret = dup_game(from);
+
+ if (col)
+ slide_col(ret, d, c);
+ else
+ slide_row(ret, d, c);
ret->move_count++;
- ret->last_move_row = dx ? cy : -1;
- ret->last_move_col = dx ? -1 : cx;
- ret->last_move_dir = dx + dy;
+ ret->last_move_row = col ? -1 : c;
+ ret->last_move_col = col ? c : -1;
+ ret->last_move_dir = d;
/*
* See if the game has been completed.
* Routines for drawing the game position on the screen.
*/
-struct game_drawstate {
- int started;
- int width, height;
- unsigned char *visible;
-};
-
-static game_drawstate *game_new_drawstate(game_state *state)
+static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
{
game_drawstate *ds = snew(game_drawstate);
ds->width = state->width;
ds->height = state->height;
ds->visible = snewn(state->width * state->height, unsigned char);
+ ds->tilesize = 0; /* not decided yet */
memset(ds->visible, 0xFF, state->width * state->height);
+ ds->cur_x = ds->cur_y = -1;
return ds;
}
-static void game_free_drawstate(game_drawstate *ds)
+static void game_free_drawstate(drawing *dr, game_drawstate *ds)
{
sfree(ds->visible);
sfree(ds);
}
-static void game_size(game_params *params, 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;
+ ads.tilesize = tilesize;
+
*x = BORDER * 2 + WINDOW_OFFSET * 2 + TILE_SIZE * params->width + TILE_BORDER;
*y = BORDER * 2 + WINDOW_OFFSET * 2 + TILE_SIZE * params->height + TILE_BORDER;
}
-static float *game_colours(frontend *fe, game_state *state, int *ncolours)
+static void game_set_size(drawing *dr, game_drawstate *ds,
+ const game_params *params, int tilesize)
+{
+ ds->tilesize = tilesize;
+}
+
+static float *game_colours(frontend *fe, int *ncolours)
{
float *ret;
return ret;
}
-static void draw_thick_line(frontend *fe, int x1, int y1, int x2, int y2,
- int colour)
+static void draw_filled_line(drawing *dr, int x1, int y1, int x2, int y2,
+ int colour)
{
- draw_line(fe, x1-1, y1, x2-1, y2, COL_WIRE);
- draw_line(fe, x1+1, y1, x2+1, y2, COL_WIRE);
- draw_line(fe, x1, y1-1, x2, y2-1, COL_WIRE);
- draw_line(fe, x1, y1+1, x2, y2+1, COL_WIRE);
- draw_line(fe, x1, y1, x2, y2, colour);
+ draw_line(dr, x1-1, y1, x2-1, y2, COL_WIRE);
+ draw_line(dr, x1+1, y1, x2+1, y2, COL_WIRE);
+ draw_line(dr, x1, y1-1, x2, y2-1, COL_WIRE);
+ draw_line(dr, x1, y1+1, x2, y2+1, COL_WIRE);
+ draw_line(dr, x1, y1, x2, y2, colour);
}
-static void draw_rect_coords(frontend *fe, int x1, int y1, int x2, int y2,
+static void draw_rect_coords(drawing *dr, int x1, int y1, int x2, int y2,
int colour)
{
int mx = (x1 < x2 ? x1 : x2);
int dx = (x2 + x1 - 2*mx + 1);
int dy = (y2 + y1 - 2*my + 1);
- draw_rect(fe, mx, my, dx, dy, colour);
+ draw_rect(dr, mx, my, dx, dy, colour);
}
-static void draw_barrier_corner(frontend *fe, int x, int y, int dir, int phase)
+static void draw_barrier_corner(drawing *dr, game_drawstate *ds,
+ int x, int y, int dir, int phase)
{
int bx = BORDER + WINDOW_OFFSET + TILE_SIZE * x;
int by = BORDER + WINDOW_OFFSET + TILE_SIZE * y;
y1 = (dy > 0 ? TILE_SIZE+TILE_BORDER-1 : 0);
if (phase == 0) {
- draw_rect_coords(fe, bx+x1, by+y1,
+ draw_rect_coords(dr, bx+x1, by+y1,
bx+x1-TILE_BORDER*dx, by+y1-(TILE_BORDER-1)*dy,
COL_WIRE);
- draw_rect_coords(fe, bx+x1, by+y1,
+ draw_rect_coords(dr, bx+x1, by+y1,
bx+x1-(TILE_BORDER-1)*dx, by+y1-TILE_BORDER*dy,
COL_WIRE);
} else {
- draw_rect_coords(fe, bx+x1, by+y1,
+ draw_rect_coords(dr, bx+x1, by+y1,
bx+x1-(TILE_BORDER-1)*dx, by+y1-(TILE_BORDER-1)*dy,
COL_BARRIER);
}
}
-static void draw_barrier(frontend *fe, int x, int y, int dir, int phase)
+static void draw_barrier(drawing *dr, game_drawstate *ds,
+ int x, int y, int dir, int phase)
{
int bx = BORDER + WINDOW_OFFSET + TILE_SIZE * x;
int by = BORDER + WINDOW_OFFSET + TILE_SIZE * y;
h = (Y(dir) ? TILE_BORDER : TILE_SIZE - TILE_BORDER);
if (phase == 0) {
- draw_rect(fe, bx+x1-X(dir), by+y1-Y(dir), w, h, COL_WIRE);
+ draw_rect(dr, bx+x1-X(dir), by+y1-Y(dir), w, h, COL_WIRE);
} else {
- draw_rect(fe, bx+x1, by+y1, w, h, COL_BARRIER);
+ draw_rect(dr, bx+x1, by+y1, w, h, COL_BARRIER);
}
}
-static void draw_tile(frontend *fe, game_state *state, int x, int y, int tile,
- float xshift, float yshift)
+static void draw_tile(drawing *dr, game_drawstate *ds, const game_state *state,
+ int x, int y, int tile, float xshift, float yshift)
{
- int bx = BORDER + WINDOW_OFFSET + TILE_SIZE * x + (xshift * TILE_SIZE);
- int by = BORDER + WINDOW_OFFSET + TILE_SIZE * y + (yshift * TILE_SIZE);
+ int bx = BORDER + WINDOW_OFFSET + TILE_SIZE * x + (int)(xshift * TILE_SIZE);
+ int by = BORDER + WINDOW_OFFSET + TILE_SIZE * y + (int)(yshift * TILE_SIZE);
float cx, cy, ex, ey;
int dir, col;
* rectangle in border colour, and a smaller rectangle in
* background colour to fill it in.
*/
- draw_rect(fe, bx, by, TILE_SIZE+TILE_BORDER, TILE_SIZE+TILE_BORDER,
+ draw_rect(dr, bx, by, TILE_SIZE+TILE_BORDER, TILE_SIZE+TILE_BORDER,
COL_BORDER);
- draw_rect(fe, bx+TILE_BORDER, by+TILE_BORDER,
+ draw_rect(dr, bx+TILE_BORDER, by+TILE_BORDER,
TILE_SIZE-TILE_BORDER, TILE_SIZE-TILE_BORDER,
tile & FLASHING ? COL_FLASHING : COL_BACKGROUND);
if (tile & dir) {
ex = (TILE_SIZE - TILE_BORDER - 1.0F) / 2.0F * X(dir);
ey = (TILE_SIZE - TILE_BORDER - 1.0F) / 2.0F * Y(dir);
- draw_thick_line(fe, bx+(int)cx, by+(int)cy,
- bx+(int)(cx+ex), by+(int)(cy+ey),
- COL_WIRE);
+ draw_filled_line(dr, bx+(int)cx, by+(int)cy,
+ bx+(int)(cx+ex), by+(int)(cy+ey),
+ COL_WIRE);
}
}
for (dir = 1; dir < 0x10; dir <<= 1) {
if (tile & dir) {
ex = (TILE_SIZE - TILE_BORDER - 1.0F) / 2.0F * X(dir);
ey = (TILE_SIZE - TILE_BORDER - 1.0F) / 2.0F * Y(dir);
- draw_line(fe, bx+(int)cx, by+(int)cy,
+ draw_line(dr, bx+(int)cx, by+(int)cy,
bx+(int)(cx+ex), by+(int)(cy+ey), col);
}
}
points[i+1] = by+(int)(cy+ey);
}
- draw_polygon(fe, points, 4, TRUE, col);
- draw_polygon(fe, points, 4, FALSE, COL_WIRE);
+ draw_polygon(dr, points, 4, col, COL_WIRE);
}
/*
* in: if we are fully connected to the other tile then
* the two ACTIVE states will be the same.)
*/
- draw_rect_coords(fe, px-vx, py-vy, px+lx+vx, py+ly+vy, COL_WIRE);
- draw_rect_coords(fe, px, py, px+lx, py+ly,
+ draw_rect_coords(dr, px-vx, py-vy, px+lx+vx, py+ly+vy, COL_WIRE);
+ draw_rect_coords(dr, px, py, px+lx, py+ly,
(tile & ACTIVE) ? COL_POWERED : COL_WIRE);
} else {
/*
* actually connected to us. Just draw a single black
* dot.
*/
- draw_rect_coords(fe, px, py, px, py, COL_WIRE);
+ draw_rect_coords(dr, px, py, px, py, COL_WIRE);
}
}
- draw_update(fe, bx, by, TILE_SIZE+TILE_BORDER, TILE_SIZE+TILE_BORDER);
+ draw_update(dr, bx, by, TILE_SIZE+TILE_BORDER, TILE_SIZE+TILE_BORDER);
}
-static void draw_tile_barriers(frontend *fe, game_state *state, int x, int y)
+static void draw_tile_barriers(drawing *dr, game_drawstate *ds,
+ const game_state *state, int x, int y)
{
int phase;
int dir;
for (phase = 0; phase < 2; phase++) {
for (dir = 1; dir < 0x10; dir <<= 1)
if (barrier(state, x, y) & (dir << 4))
- draw_barrier_corner(fe, x, y, dir << 4, phase);
+ draw_barrier_corner(dr, ds, x, y, dir << 4, phase);
for (dir = 1; dir < 0x10; dir <<= 1)
if (barrier(state, x, y) & dir)
- draw_barrier(fe, x, y, dir, phase);
+ draw_barrier(dr, ds, x, y, dir, phase);
}
- draw_update(fe, bx, by, TILE_SIZE+TILE_BORDER, TILE_SIZE+TILE_BORDER);
+ draw_update(dr, bx, by, TILE_SIZE+TILE_BORDER, TILE_SIZE+TILE_BORDER);
}
-static void draw_arrow(frontend *fe, int x, int y, int xdx, int xdy)
+static void draw_arrow(drawing *dr, game_drawstate *ds,
+ int x, int y, int xdx, int xdy, int cur)
{
int coords[14];
int ydy = -xdx, ydx = xdy;
POINT(5, 3 * TILE_SIZE / 8, TILE_SIZE / 2); /* left concave */
POINT(6, TILE_SIZE / 4, TILE_SIZE / 2); /* left corner */
- draw_polygon(fe, coords, 7, TRUE, COL_LOWLIGHT);
- draw_polygon(fe, coords, 7, FALSE, COL_TEXT);
+ draw_polygon(dr, coords, 7, cur ? COL_POWERED : COL_LOWLIGHT, COL_TEXT);
}
-static void game_redraw(frontend *fe, game_drawstate *ds, game_state *oldstate,
- game_state *state, int dir, game_ui *ui, float t, float ft)
+static void draw_arrow_for_cursor(drawing *dr, game_drawstate *ds,
+ int cur_x, int cur_y, int cur)
{
- int x, y, tx, ty, frame;
+ if (cur_x == -1 && cur_y == -1)
+ return; /* 'no cursur here */
+ else if (cur_x == -1) /* LH column. */
+ draw_arrow(dr, ds, 0, cur_y+1, 0, -1, cur);
+ else if (cur_x == ds->width) /* RH column */
+ draw_arrow(dr, ds, ds->width, cur_y, 0, +1, cur);
+ else if (cur_y == -1) /* Top row */
+ draw_arrow(dr, ds, cur_x, 0, +1, 0, cur);
+ else if (cur_y == ds->height) /* Bottom row */
+ draw_arrow(dr, ds, cur_x+1, ds->height, -1, 0, cur);
+ else
+ assert(!"Invalid cursor position");
+
+ draw_update(dr,
+ cur_x * TILE_SIZE + BORDER + WINDOW_OFFSET,
+ cur_y * TILE_SIZE + BORDER + WINDOW_OFFSET,
+ TILE_SIZE, TILE_SIZE);
+}
+
+static void game_redraw(drawing *dr, game_drawstate *ds,
+ const game_state *oldstate, const game_state *state,
+ int dir, const game_ui *ui,
+ float t, float ft)
+{
+ int x, y, frame;
unsigned char *active;
float xshift = 0.0;
float yshift = 0.0;
+ int cur_x = -1, cur_y = -1;
/*
* Clear the screen and draw the exterior barrier lines if this
ds->started = TRUE;
- draw_rect(fe, 0, 0,
+ draw_rect(dr, 0, 0,
BORDER * 2 + WINDOW_OFFSET * 2 + TILE_SIZE * state->width + TILE_BORDER,
BORDER * 2 + WINDOW_OFFSET * 2 + TILE_SIZE * state->height + TILE_BORDER,
COL_BACKGROUND);
- draw_update(fe, 0, 0,
+ draw_update(dr, 0, 0,
BORDER * 2 + WINDOW_OFFSET*2 + TILE_SIZE*state->width + TILE_BORDER,
BORDER * 2 + WINDOW_OFFSET*2 + TILE_SIZE*state->height + TILE_BORDER);
for (x = 0; x < ds->width; x++) {
if (barrier(state, x, 0) & UL)
- draw_barrier_corner(fe, x, -1, LD, phase);
+ draw_barrier_corner(dr, ds, x, -1, LD, phase);
if (barrier(state, x, 0) & RU)
- draw_barrier_corner(fe, x, -1, DR, phase);
+ draw_barrier_corner(dr, ds, x, -1, DR, phase);
if (barrier(state, x, 0) & U)
- draw_barrier(fe, x, -1, D, phase);
+ draw_barrier(dr, ds, x, -1, D, phase);
if (barrier(state, x, ds->height-1) & DR)
- draw_barrier_corner(fe, x, ds->height, RU, phase);
+ draw_barrier_corner(dr, ds, x, ds->height, RU, phase);
if (barrier(state, x, ds->height-1) & LD)
- draw_barrier_corner(fe, x, ds->height, UL, phase);
+ draw_barrier_corner(dr, ds, x, ds->height, UL, phase);
if (barrier(state, x, ds->height-1) & D)
- draw_barrier(fe, x, ds->height, U, phase);
+ draw_barrier(dr, ds, x, ds->height, U, phase);
}
for (y = 0; y < ds->height; y++) {
if (barrier(state, 0, y) & UL)
- draw_barrier_corner(fe, -1, y, RU, phase);
+ draw_barrier_corner(dr, ds, -1, y, RU, phase);
if (barrier(state, 0, y) & LD)
- draw_barrier_corner(fe, -1, y, DR, phase);
+ draw_barrier_corner(dr, ds, -1, y, DR, phase);
if (barrier(state, 0, y) & L)
- draw_barrier(fe, -1, y, R, phase);
+ draw_barrier(dr, ds, -1, y, R, phase);
if (barrier(state, ds->width-1, y) & RU)
- draw_barrier_corner(fe, ds->width, y, UL, phase);
+ draw_barrier_corner(dr, ds, ds->width, y, UL, phase);
if (barrier(state, ds->width-1, y) & DR)
- draw_barrier_corner(fe, ds->width, y, LD, phase);
+ draw_barrier_corner(dr, ds, ds->width, y, LD, phase);
if (barrier(state, ds->width-1, y) & R)
- draw_barrier(fe, ds->width, y, L, phase);
+ draw_barrier(dr, ds, ds->width, y, L, phase);
}
}
*/
for (x = 0; x < ds->width; x++) {
if (x == state->cx) continue;
- draw_arrow(fe, x, 0, +1, 0);
- draw_arrow(fe, x+1, ds->height, -1, 0);
+ draw_arrow(dr, ds, x, 0, +1, 0, 0);
+ draw_arrow(dr, ds, x+1, ds->height, -1, 0, 0);
}
for (y = 0; y < ds->height; y++) {
if (y == state->cy) continue;
- draw_arrow(fe, ds->width, y, 0, +1);
- draw_arrow(fe, 0, y+1, 0, -1);
+ draw_arrow(dr, ds, ds->width, y, 0, +1, 0);
+ draw_arrow(dr, ds, 0, y+1, 0, -1, 0);
}
}
+ if (ui->cur_visible) {
+ cur_x = ui->cur_x; cur_y = ui->cur_y;
+ }
+ if (cur_x != ds->cur_x || cur_y != ds->cur_y) {
+ /* Cursor has changed; redraw two (prev and curr) arrows. */
+ assert(cur_x != state->cx && cur_y != state->cy);
+
+ draw_arrow_for_cursor(dr, ds, cur_x, cur_y, 1);
+ draw_arrow_for_cursor(dr, ds, ds->cur_x, ds->cur_y, 0);
+ ds->cur_x = cur_x; ds->cur_y = cur_y;
+ }
/* Check if this is an undo. If so, we will need to run any animation
* backwards.
*/
if (oldstate && oldstate->move_count > state->move_count) {
- game_state * tmpstate = state;
+ const game_state * tmpstate = state;
state = oldstate;
oldstate = tmpstate;
t = ANIM_TIME - t;
}
- tx = ty = -1;
if (oldstate && (t < ANIM_TIME)) {
/*
* We're animating a slide, of row/column number
* state->last_move_pos, in direction
* state->last_move_dir
*/
- xshift = state->last_move_row == -1 ? 0.0 :
+ xshift = state->last_move_row == -1 ? 0.0F :
(1 - t / ANIM_TIME) * state->last_move_dir;
- yshift = state->last_move_col == -1 ? 0.0 :
+ yshift = state->last_move_col == -1 ? 0.0F :
(1 - t / ANIM_TIME) * state->last_move_dir;
}
active = compute_active(state, -1, -1);
}
- clip(fe,
+ clip(dr,
BORDER + WINDOW_OFFSET, BORDER + WINDOW_OFFSET,
TILE_SIZE * state->width + TILE_BORDER,
TILE_SIZE * state->height + TILE_BORDER);
index(state, ds->visible, x, y) == 0xFF ||
(x == state->last_move_col || y == state->last_move_row))
{
- float xs = (y == state->last_move_row ? xshift : 0.0);
- float ys = (x == state->last_move_col ? yshift : 0.0);
+ float xs = (y == state->last_move_row ? xshift : (float)0.0);
+ float ys = (x == state->last_move_col ? yshift : (float)0.0);
- draw_tile(fe, state, x, y, c, xs, ys);
+ draw_tile(dr, ds, state, x, y, c, xs, ys);
if (xs < 0 && x == 0)
- draw_tile(fe, state, state->width, y, c, xs, ys);
+ draw_tile(dr, ds, state, state->width, y, c, xs, ys);
else if (xs > 0 && x == state->width - 1)
- draw_tile(fe, state, -1, y, c, xs, ys);
+ draw_tile(dr, ds, state, -1, y, c, xs, ys);
else if (ys < 0 && y == 0)
- draw_tile(fe, state, x, state->height, c, xs, ys);
+ draw_tile(dr, ds, state, x, state->height, c, xs, ys);
else if (ys > 0 && y == state->height - 1)
- draw_tile(fe, state, x, -1, c, xs, ys);
+ draw_tile(dr, ds, state, x, -1, c, xs, ys);
if (x == state->last_move_col || y == state->last_move_row)
index(state, ds->visible, x, y) = 0xFF;
for (x = 0; x < ds->width; x++)
for (y = 0; y < ds->height; y++)
- draw_tile_barriers(fe, state, x, y);
+ draw_tile_barriers(dr, ds, state, x, y);
- unclip(fe);
+ unclip(dr);
/*
* Update the status bar.
(state->completed ? "COMPLETED! " : ""),
(state->completed ? state->completed : state->move_count));
+ if (state->movetarget)
+ sprintf(statusbuf + strlen(statusbuf), " (target %d)",
+ state->movetarget);
+
sprintf(statusbuf + strlen(statusbuf), " Active: %d/%d", a, n);
- status_bar(fe, statusbuf);
+ status_bar(dr, statusbuf);
}
sfree(active);
}
-static float game_anim_length(game_state *oldstate,
- game_state *newstate, int dir)
+static float game_anim_length(const game_state *oldstate,
+ const game_state *newstate, int dir, game_ui *ui)
{
- /*
- * Don't animate an auto-solve move.
- */
- if ((dir > 0 && newstate->just_used_solve) ||
- (dir < 0 && oldstate->just_used_solve))
- return 0.0F;
-
return ANIM_TIME;
}
-static float game_flash_length(game_state *oldstate,
- game_state *newstate, int dir)
+static float game_flash_length(const game_state *oldstate,
+ const game_state *newstate, int dir, game_ui *ui)
{
/*
* If the game has just been completed, we display a completion
return 0.0F;
}
-static int game_wants_statusbar(void)
+static int game_status(const game_state *state)
+{
+ return state->completed ? +1 : 0;
+}
+
+static int game_timing_state(const game_state *state, game_ui *ui)
+{
+ return FALSE;
+}
+
+static void game_print_size(const game_params *params, float *x, float *y)
+{
+}
+
+static void game_print(drawing *dr, const game_state *state, int tilesize)
{
- return TRUE;
}
#ifdef COMBINED
#endif
const struct game thegame = {
- "Netslide", "games.netslide",
+ "Netslide", "games.netslide", "netslide",
default_params,
game_fetch_preset,
decode_params,
dup_params,
TRUE, game_configure, custom_params,
validate_params,
- new_game_seed,
- game_free_aux_info,
- validate_seed,
+ new_game_desc,
+ validate_desc,
new_game,
dup_game,
free_game,
TRUE, solve_game,
- FALSE, game_text_format,
+ FALSE, game_can_format_as_text_now, game_text_format,
new_ui,
free_ui,
- make_move,
- game_size,
+ encode_ui,
+ decode_ui,
+ game_changed_state,
+ interpret_move,
+ execute_move,
+ PREFERRED_TILE_SIZE, game_compute_size, game_set_size,
game_colours,
game_new_drawstate,
game_free_drawstate,
game_redraw,
game_anim_length,
game_flash_length,
- game_wants_statusbar,
+ game_status,
+ FALSE, FALSE, game_print_size, game_print,
+ TRUE, /* wants_statusbar */
+ FALSE, game_timing_state,
+ 0, /* flags */
};
+
+/* vim: set shiftwidth=4 tabstop=8: */