#include "puzzles.h"
const char *const game_name = "Sixteen";
+const int game_can_configure = TRUE;
#define TILE_SIZE 48
#define BORDER TILE_SIZE /* big border to fill with arrows */
#define COORD(x) ( (x) * TILE_SIZE + BORDER )
#define FROMCOORD(x) ( ((x) - BORDER + 2*TILE_SIZE) / TILE_SIZE - 2 )
-#define ANIM_TIME 0.1F
-#define FLASH_FRAME 0.1F
+#define ANIM_TIME 0.13F
+#define FLASH_FRAME 0.13F
#define X(state, i) ( (i) % (state)->w )
#define Y(state, i) ( (i) / (state)->w )
int w, h, n;
int *tiles;
int completed;
+ int movecount;
+ int last_movement_sense;
};
game_params *default_params(void)
return ret;
}
+config_item *game_configure(game_params *params)
+{
+ config_item *ret;
+ char buf[80];
+
+ ret = snewn(3, config_item);
+
+ ret[0].name = "Width";
+ ret[0].type = C_STRING;
+ sprintf(buf, "%d", params->w);
+ ret[0].sval = dupstr(buf);
+ ret[0].ival = 0;
+
+ ret[1].name = "Height";
+ ret[1].type = C_STRING;
+ sprintf(buf, "%d", params->h);
+ ret[1].sval = dupstr(buf);
+ ret[1].ival = 0;
+
+ ret[2].name = NULL;
+ ret[2].type = C_END;
+ ret[2].sval = NULL;
+ ret[2].ival = 0;
+
+ return ret;
+}
+
+game_params *custom_params(config_item *cfg)
+{
+ game_params *ret = snew(game_params);
+
+ ret->w = atoi(cfg[0].sval);
+ ret->h = atoi(cfg[1].sval);
+
+ return ret;
+}
+
+char *validate_params(game_params *params)
+{
+ if (params->w < 2 && params->h < 2)
+ return "Width and height must both be at least two";
+
+ return NULL;
+}
+
int perm_parity(int *perm, int n)
{
int i, j, ret;
return ret;
}
-char *new_game_seed(game_params *params)
+char *new_game_seed(game_params *params, random_state *rs)
{
int stop, n, i, x;
int x1, x2, p1, p2;
* Place everything except (possibly) the last two tiles.
*/
for (x = 0, i = n; i > stop; i--) {
- int k = i > 1 ? rand_upto(i) : 0;
+ int k = i > 1 ? random_upto(rs, i) : 0;
int j;
for (j = 0; j < n; j++)
return ret;
}
+
+char *validate_seed(game_params *params, char *seed)
+{
+ char *p, *err;
+ int i, area;
+ int *used;
+
+ area = params->w * params->h;
+ p = seed;
+ err = NULL;
+
+ used = snewn(area, int);
+ for (i = 0; i < area; i++)
+ used[i] = FALSE;
+
+ for (i = 0; i < area; i++) {
+ char *q = p;
+ int n;
+
+ if (*p < '0' || *p > '9') {
+ err = "Not enough numbers in string";
+ goto leave;
+ }
+ while (*p >= '0' && *p <= '9')
+ p++;
+ if (i < area-1 && *p != ',') {
+ err = "Expected comma after number";
+ goto leave;
+ }
+ else if (i == area-1 && *p) {
+ err = "Excess junk at end of string";
+ goto leave;
+ }
+ n = atoi(q);
+ if (n < 1 || n > area) {
+ err = "Number out of range";
+ goto leave;
+ }
+ if (used[n-1]) {
+ err = "Number used twice";
+ goto leave;
+ }
+ used[n-1] = TRUE;
+
+ if (*p) p++; /* eat comma */
+ }
+
+ leave:
+ sfree(used);
+ return err;
+}
+
game_state *new_game(game_params *params, char *seed)
{
game_state *state = snew(game_state);
}
assert(!*p);
- state->completed = FALSE;
+ state->completed = state->movecount = 0;
+ state->last_movement_sense = 0;
return state;
}
ret->tiles = snewn(state->w * state->h, int);
memcpy(ret->tiles, state->tiles, state->w * state->h * sizeof(int));
ret->completed = state->completed;
+ ret->movecount = state->movecount;
+ ret->last_movement_sense = state->last_movement_sense;
return ret;
}
ret->tiles[C(ret, cx, cy)] = from->tiles[C(from, tx, ty)];
} while (--n > 0);
+ ret->movecount++;
+
+ ret->last_movement_sense = -(dx+dy);
+
/*
* See if the game has been completed.
*/
if (!ret->completed) {
- ret->completed = TRUE;
+ ret->completed = ret->movecount;
for (n = 0; n < ret->n; n++)
if (ret->tiles[n] != n+1)
ret->completed = FALSE;
void game_redraw(frontend *fe, game_drawstate *ds, game_state *oldstate,
game_state *state, float animtime, float flashtime)
{
- int i, pass, bgcolour;
+ int i, bgcolour;
if (flashtime > 0) {
int frame = (int)(flashtime / FLASH_FRAME);
}
/*
- * Now draw each tile. We do this in two passes to make
- * animation easy.
+ * Now draw each tile.
*/
clip(fe, COORD(0), COORD(0), TILE_SIZE*state->w, TILE_SIZE*state->h);
- for (pass = 0; pass < 2; pass++) {
- for (i = 0; i < state->n; i++) {
- int t, t0;
- /*
- * Figure out what should be displayed at this
- * location. It's either a simple tile, or it's a
- * transition between two tiles (in which case we say
- * -1 because it must always be drawn).
- */
-
- if (oldstate && oldstate->tiles[i] != state->tiles[i])
- t = -1;
- else
- t = state->tiles[i];
-
- t0 = t;
-
- if (ds->bgcolour != bgcolour || /* always redraw when flashing */
- ds->tiles[i] != t || ds->tiles[i] == -1 || t == -1) {
- int x, y, x2, y2;
-
- /*
- * Figure out what to _actually_ draw, and where to
- * draw it.
- */
- if (t == -1) {
- int x0, y0, x1, y1, dx, dy;
- int j;
-
- /*
- * On the first pass, just blank the tile.
- */
- if (pass == 0) {
- x = COORD(X(state, i));
- y = COORD(Y(state, i));
- x2 = y2 = -1;
- t = 0;
- } else {
- float c;
-
- t = state->tiles[i];
-
- /*
- * FIXME: must be prepared to draw a double
- * tile in some situations.
- */
-
- /*
- * Find the coordinates of this tile in the old and
- * new states.
- */
- x1 = COORD(X(state, i));
- y1 = COORD(Y(state, i));
- for (j = 0; j < oldstate->n; j++)
- if (oldstate->tiles[j] == state->tiles[i])
- break;
- assert(j < oldstate->n);
- x0 = COORD(X(state, j));
- y0 = COORD(Y(state, j));
-
- dx = (x1 - x0);
- if (abs(dx) > TILE_SIZE) {
- dx = (dx < 0 ? dx + TILE_SIZE * state->w :
- dx - TILE_SIZE * state->w);
- assert(abs(dx) == TILE_SIZE);
- }
- dy = (y1 - y0);
- if (abs(dy) > TILE_SIZE) {
- dy = (dy < 0 ? dy + TILE_SIZE * state->h :
- dy - TILE_SIZE * state->h);
- assert(abs(dy) == TILE_SIZE);
- }
-
- c = (animtime / ANIM_TIME);
- if (c < 0.0F) c = 0.0F;
- if (c > 1.0F) c = 1.0F;
-
- x = x0 + (int)(c * dx);
- y = y0 + (int)(c * dy);
- x2 = x1 - dx + (int)(c * dx);
- y2 = y1 - dy + (int)(c * dy);
- }
-
- } else {
- if (pass == 0)
- continue;
- x = COORD(X(state, i));
- y = COORD(Y(state, i));
- x2 = y2 = -1;
- }
-
- draw_tile(fe, state, x, y, t, bgcolour);
- if (x2 != -1 || y2 != -1)
- draw_tile(fe, state, x2, y2, t, bgcolour);
- }
- ds->tiles[i] = t0;
- }
+ for (i = 0; i < state->n; i++) {
+ int t, t0;
+ /*
+ * Figure out what should be displayed at this
+ * location. It's either a simple tile, or it's a
+ * transition between two tiles (in which case we say
+ * -1 because it must always be drawn).
+ */
+
+ if (oldstate && oldstate->tiles[i] != state->tiles[i])
+ t = -1;
+ else
+ t = state->tiles[i];
+
+ t0 = t;
+
+ if (ds->bgcolour != bgcolour || /* always redraw when flashing */
+ ds->tiles[i] != t || ds->tiles[i] == -1 || t == -1) {
+ int x, y, x2, y2;
+
+ /*
+ * Figure out what to _actually_ draw, and where to
+ * draw it.
+ */
+ if (t == -1) {
+ int x0, y0, x1, y1, dx, dy;
+ int j;
+ float c;
+ int sense;
+
+ if (oldstate && state->movecount < oldstate->movecount)
+ sense = -oldstate->last_movement_sense;
+ else
+ sense = state->last_movement_sense;
+
+ t = state->tiles[i];
+
+ /*
+ * FIXME: must be prepared to draw a double
+ * tile in some situations.
+ */
+
+ /*
+ * Find the coordinates of this tile in the old and
+ * new states.
+ */
+ x1 = COORD(X(state, i));
+ y1 = COORD(Y(state, i));
+ for (j = 0; j < oldstate->n; j++)
+ if (oldstate->tiles[j] == state->tiles[i])
+ break;
+ assert(j < oldstate->n);
+ x0 = COORD(X(state, j));
+ y0 = COORD(Y(state, j));
+
+ dx = (x1 - x0);
+ if (dx != 0 &&
+ dx != TILE_SIZE * sense) {
+ dx = (dx < 0 ? dx + TILE_SIZE * state->w :
+ dx - TILE_SIZE * state->w);
+ assert(abs(dx) == TILE_SIZE);
+ }
+ dy = (y1 - y0);
+ if (dy != 0 &&
+ dy != TILE_SIZE * sense) {
+ dy = (dy < 0 ? dy + TILE_SIZE * state->h :
+ dy - TILE_SIZE * state->h);
+ assert(abs(dy) == TILE_SIZE);
+ }
+
+ c = (animtime / ANIM_TIME);
+ if (c < 0.0F) c = 0.0F;
+ if (c > 1.0F) c = 1.0F;
+
+ x = x0 + (int)(c * dx);
+ y = y0 + (int)(c * dy);
+ x2 = x1 - dx + (int)(c * dx);
+ y2 = y1 - dy + (int)(c * dy);
+ } else {
+ x = COORD(X(state, i));
+ y = COORD(Y(state, i));
+ x2 = y2 = -1;
+ }
+
+ draw_tile(fe, state, x, y, t, bgcolour);
+ if (x2 != -1 || y2 != -1)
+ draw_tile(fe, state, x2, y2, t, bgcolour);
+ }
+ ds->tiles[i] = t0;
}
unclip(fe);
ds->bgcolour = bgcolour;
+
+ /*
+ * Update the status bar.
+ */
+ {
+ char statusbuf[256];
+
+ /*
+ * Don't show the new status until we're also showing the
+ * new _state_ - after the game animation is complete.
+ */
+ if (oldstate)
+ state = oldstate;
+
+ sprintf(statusbuf, "%sMoves: %d",
+ (state->completed ? "COMPLETED! " : ""),
+ (state->completed ? state->completed : state->movecount));
+
+ status_bar(fe, statusbuf);
+ }
}
float game_anim_length(game_state *oldstate, game_state *newstate)
else
return 0.0F;
}
+
+int game_wants_statusbar(void)
+{
+ return TRUE;
+}
~mdw / sgt / puzzles / blobdiff