struct game_params {
int w, h;
+ int movetarget;
};
struct game_state {
int completed;
int just_used_solve; /* used to suppress undo animation */
int used_solve; /* used to suppress completion flash */
- int movecount;
+ int movecount, movetarget;
int last_movement_sense;
};
game_params *ret = snew(game_params);
ret->w = ret->h = 4;
+ ret->movetarget = 0;
return ret;
}
*params = ret = snew(game_params);
ret->w = w;
ret->h = h;
+ ret->movetarget = 0;
return TRUE;
}
if (*string == 'x') {
string++;
ret->h = atoi(string);
+ while (*string && isdigit((unsigned char)*string))
+ string++;
+ }
+ if (*string == 'm') {
+ string++;
+ ret->movetarget = atoi(string);
+ while (*string && isdigit((unsigned char)*string))
+ string++;
}
return ret;
config_item *ret;
char buf[80];
- ret = snewn(3, config_item);
+ ret = snewn(4, config_item);
ret[0].name = "Width";
ret[0].type = C_STRING;
ret[1].sval = dupstr(buf);
ret[1].ival = 0;
- ret[2].name = NULL;
- ret[2].type = C_END;
- ret[2].sval = NULL;
+ ret[2].name = "Number of shuffling moves";
+ ret[2].type = C_STRING;
+ sprintf(buf, "%d", params->movetarget);
+ ret[2].sval = dupstr(buf);
ret[2].ival = 0;
+ ret[3].name = NULL;
+ ret[3].type = C_END;
+ ret[3].sval = NULL;
+ ret[3].ival = 0;
+
return ret;
}
ret->w = atoi(cfg[0].sval);
ret->h = atoi(cfg[1].sval);
+ ret->movetarget = atoi(cfg[2].sval);
return ret;
}
n = params->w * params->h;
tiles = snewn(n, int);
- used = snewn(n, int);
- for (i = 0; i < n; i++) {
- tiles[i] = -1;
- used[i] = FALSE;
- }
+ if (params->movetarget) {
+ int prevstart = -1, prevoffset = -1, prevdirection = 0, nrepeats = 0;
- /*
- * If both dimensions are odd, there is a parity constraint.
- */
- if (params->w & params->h & 1)
- stop = 2;
- else
- stop = 0;
+ /*
+ * Shuffle the old-fashioned way, by making a series of
+ * single moves on the grid.
+ */
- /*
- * Place everything except (possibly) the last two tiles.
- */
- for (x = 0, i = n; i > stop; i--) {
- int k = i > 1 ? random_upto(rs, i) : 0;
- int j;
+ for (i = 0; i < n; i++)
+ tiles[i] = i;
+
+ for (i = 0; i < params->movetarget; i++) {
+ int start, offset, len, direction;
+ int j, tmp;
+
+ /*
+ * Choose a move to make. We can choose from any row
+ * or any column.
+ */
+ while (1) {
+ j = random_upto(rs, params->w + params->h);
+
+ if (j < params->w) {
+ /* Column. */
+ start = j;
+ offset = params->w;
+ len = params->h;
+ } else {
+ /* Row. */
+ start = (j - params->w) * params->w;
+ offset = 1;
+ len = params->w;
+ }
- for (j = 0; j < n; j++)
- if (!used[j] && (k-- == 0))
- break;
+ direction = -1 + 2 * random_upto(rs, 2);
- assert(j < n && !used[j]);
- used[j] = TRUE;
+ /*
+ * To at least _try_ to avoid boring cases, check that
+ * this move doesn't directly undo the previous one, or
+ * repeat it so many times as to turn it into fewer
+ * moves.
+ */
+ if (start == prevstart && offset == prevoffset) {
+ if (direction == -prevdirection)
+ continue; /* inverse of previous move */
+ else if (2 * (nrepeats+1) > len)
+ continue; /* previous move repeated too often */
+ }
- while (tiles[x] >= 0)
- x++;
- assert(x < n);
- tiles[x] = j;
- }
+ /* If we didn't `continue', we've found an OK move to make. */
+ break;
+ }
- if (stop) {
- /*
- * Find the last two locations, and the last two pieces.
- */
- while (tiles[x] >= 0)
- x++;
- assert(x < n);
- x1 = x;
- x++;
- while (tiles[x] >= 0)
- x++;
- assert(x < n);
- x2 = x;
-
- for (i = 0; i < n; i++)
- if (!used[i])
- break;
- p1 = i;
- for (i = p1+1; i < n; i++)
- if (!used[i])
- break;
- p2 = i;
+ /*
+ * Now save the move into the `prev' variables.
+ */
+ if (start == prevstart && offset == prevoffset) {
+ nrepeats++;
+ } else {
+ prevstart = start;
+ prevoffset = offset;
+ prevdirection = direction;
+ nrepeats = 1;
+ }
- /*
- * Try the last two tiles one way round. If that fails, swap
- * them.
- */
- tiles[x1] = p1;
- tiles[x2] = p2;
- if (perm_parity(tiles, n) != 0) {
- tiles[x1] = p2;
- tiles[x2] = p1;
- assert(perm_parity(tiles, n) == 0);
- }
+ /*
+ * And make it.
+ */
+ if (direction < 0) {
+ start += (len-1) * offset;
+ offset = -offset;
+ }
+ tmp = tiles[start];
+ for (j = 0; j+1 < len; j++)
+ tiles[start + j*offset] = tiles[start + (j+1)*offset];
+ tiles[start + (len-1) * offset] = tmp;
+ }
+
+ } else {
+
+ used = snewn(n, int);
+
+ for (i = 0; i < n; i++) {
+ tiles[i] = -1;
+ used[i] = FALSE;
+ }
+
+ /*
+ * If both dimensions are odd, there is a parity
+ * constraint.
+ */
+ if (params->w & params->h & 1)
+ stop = 2;
+ else
+ stop = 0;
+
+ /*
+ * Place everything except (possibly) the last two tiles.
+ */
+ for (x = 0, i = n; i > stop; i--) {
+ int k = i > 1 ? random_upto(rs, i) : 0;
+ int j;
+
+ for (j = 0; j < n; j++)
+ if (!used[j] && (k-- == 0))
+ break;
+
+ assert(j < n && !used[j]);
+ used[j] = TRUE;
+
+ while (tiles[x] >= 0)
+ x++;
+ assert(x < n);
+ tiles[x] = j;
+ }
+
+ if (stop) {
+ /*
+ * Find the last two locations, and the last two
+ * pieces.
+ */
+ while (tiles[x] >= 0)
+ x++;
+ assert(x < n);
+ x1 = x;
+ x++;
+ while (tiles[x] >= 0)
+ x++;
+ assert(x < n);
+ x2 = x;
+
+ for (i = 0; i < n; i++)
+ if (!used[i])
+ break;
+ p1 = i;
+ for (i = p1+1; i < n; i++)
+ if (!used[i])
+ break;
+ p2 = i;
+
+ /*
+ * Try the last two tiles one way round. If that fails,
+ * swap them.
+ */
+ tiles[x1] = p1;
+ tiles[x2] = p2;
+ if (perm_parity(tiles, n) != 0) {
+ tiles[x1] = p2;
+ tiles[x2] = p1;
+ assert(perm_parity(tiles, n) == 0);
+ }
+ }
+
+ sfree(used);
}
/*
ret[retlen-1] = '\0'; /* delete last comma */
sfree(tiles);
- sfree(used);
return ret;
}
assert(!*p);
state->completed = state->movecount = 0;
+ state->movetarget = params->movetarget;
state->used_solve = state->just_used_solve = FALSE;
state->last_movement_sense = 0;
memcpy(ret->tiles, state->tiles, state->w * state->h * sizeof(int));
ret->completed = state->completed;
ret->movecount = state->movecount;
+ ret->movetarget = state->movetarget;
ret->used_solve = state->used_solve;
ret->just_used_solve = state->just_used_solve;
ret->last_movement_sense = state->last_movement_sense;
if (state->used_solve)
sprintf(statusbuf, "Moves since auto-solve: %d",
state->movecount - state->completed);
- else
+ else {
sprintf(statusbuf, "%sMoves: %d",
(state->completed ? "COMPLETED! " : ""),
(state->completed ? state->completed : state->movecount));
+ if (state->movetarget)
+ sprintf(statusbuf+strlen(statusbuf), " (target %d)",
+ state->movetarget);
+ }
status_bar(fe, statusbuf);
}
~mdw / sgt / puzzles / blobdiff