float barrier_probability;
};
+struct solved_game_state {
+ int width, height;
+ int refcount;
+ unsigned char *tiles;
+};
+
struct game_state {
int width, height, cx, cy, wrapping, completed, last_rotate_dir;
+ int used_solve, just_used_solve;
unsigned char *tiles;
unsigned char *barriers;
+ struct solved_game_state *solution;
};
#define OFFSET(x2,y2,x1,y1,dir,state) \
return dupstr(buf);
}
-void game_free_aux_info(game_aux_info *aux)
+static void game_free_aux_info(game_aux_info *aux)
{
assert(!"Shouldn't happen");
}
state->cy = state->height / 2;
state->wrapping = params->wrapping;
state->last_rotate_dir = 0;
- state->completed = FALSE;
+ state->completed = state->used_solve = state->just_used_solve = FALSE;
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);
}
/*
+ * 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.
+ */
+ {
+ struct solved_game_state *solution;
+
+ 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);
+
+ state->solution = solution;
+ }
+
+ /*
* Now shuffle the grid.
*/
for (y = 0; y < state->height; y++) {
ret->cy = state->cy;
ret->wrapping = state->wrapping;
ret->completed = state->completed;
+ ret->used_solve = state->used_solve;
+ ret->just_used_solve = state->just_used_solve;
ret->last_rotate_dir = state->last_rotate_dir;
ret->tiles = snewn(state->width * state->height, unsigned char);
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)
+{
+ 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.
+ */
+ *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 = TRUE;
+
+ return ret;
+}
+
static char *game_text_format(game_state *state)
{
return NULL;
if (button == MIDDLE_BUTTON) {
ret = dup_game(state);
+ ret->just_used_solve = FALSE;
tile(ret, tx, ty) ^= LOCKED;
ret->last_rotate_dir = 0;
return ret;
* turns anticlockwise; right button turns clockwise.
*/
ret = dup_game(state);
+ ret->just_used_solve = FALSE;
orig = tile(ret, tx, ty);
if (button == LEFT_BUTTON) {
tile(ret, tx, ty) = A(orig);
*/
int jx, jy;
ret = dup_game(state);
+ ret->just_used_solve = FALSE;
for (jy = 0; jy < ret->height; jy++) {
for (jx = 0; jx < ret->width; jx++) {
if (!(tile(ret, jx, jy) & LOCKED)) {
a++;
sprintf(statusbuf, "%sActive: %d/%d",
- (state->completed ? "COMPLETED! " : ""), a, n);
+ (state->used_solve ? "Auto-solved. " :
+ state->completed ? "COMPLETED! " : ""), a, n);
status_bar(fe, statusbuf);
}
int x, y, last_rotate_dir;
/*
+ * Don't animate an auto-solve move.
+ */
+ if ((dir > 0 && newstate->just_used_solve) ||
+ (dir < 0 && oldstate->just_used_solve))
+ return 0.0F;
+
+ /*
* Don't animate if last_rotate_dir is zero.
*/
last_rotate_dir = dir==-1 ? oldstate->last_rotate_dir :
* If the game has just been completed, we display a completion
* flash.
*/
- if (!oldstate->completed && newstate->completed) {
+ if (!oldstate->completed && newstate->completed &&
+ !oldstate->used_solve && !newstate->used_solve) {
int size;
size = 0;
if (size < newstate->cx+1)
new_game,
dup_game,
free_game,
+ TRUE, solve_game,
FALSE, game_text_format,
new_ui,
free_ui,