int w, h, n;
int rowsonly;
int orientable;
+ 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 lastx, lasty, lastr; /* coordinates of last rotation */
};
ret->w = ret->h = 3;
ret->n = 2;
ret->rowsonly = ret->orientable = FALSE;
+ ret->movetarget = 0;
return ret;
}
ret->w = ret->h = atoi(string);
ret->n = 2;
ret->rowsonly = ret->orientable = FALSE;
+ ret->movetarget = 0;
while (*string && isdigit(*string)) string++;
if (*string == 'x') {
string++;
ret->rowsonly = TRUE;
} else if (*string == 'o') {
ret->orientable = TRUE;
+ } else if (*string == 'm') {
+ string++;
+ ret->movetarget = atoi(string);
+ while (string[1] && isdigit(string[1])) string++;
}
string++;
}
config_item *ret;
char buf[80];
- ret = snewn(6, config_item);
+ ret = snewn(7, config_item);
ret[0].name = "Width";
ret[0].type = C_STRING;
ret[4].sval = NULL;
ret[4].ival = params->orientable;
- ret[5].name = NULL;
- ret[5].type = C_END;
- ret[5].sval = NULL;
+ ret[5].name = "Number of shuffling moves";
+ ret[5].type = C_STRING;
+ sprintf(buf, "%d", params->movetarget);
+ ret[5].sval = dupstr(buf);
ret[5].ival = 0;
+ ret[6].name = NULL;
+ ret[6].type = C_END;
+ ret[6].sval = NULL;
+ ret[6].ival = 0;
+
return ret;
}
ret->n = atoi(cfg[2].sval);
ret->rowsonly = cfg[3].ival;
ret->orientable = cfg[4].ival;
+ ret->movetarget = atoi(cfg[5].sval);
return ret;
}
* and simply shuffle the grid by making a long sequence of
* randomly chosen moves.
*/
- total_moves = w*h*n*n*2 + random_upto(rs, 1);
- for (i = 0; i < total_moves; i++) {
- int x, y;
-
- x = random_upto(rs, w - n + 1);
- y = random_upto(rs, h - n + 1);
- do_rotate(grid, w, h, n, params->orientable,
- x, y, 1 + random_upto(rs, 3));
-
- /*
- * Optionally one more move in case the entire grid has
- * happened to come out solved.
- */
- if (i == total_moves - 1 && grid_complete(grid, wh,
- params->orientable))
- i--;
- }
+ total_moves = params->movetarget;
+ if (!total_moves)
+ total_moves = w*h*n*n*2 + random_upto(rs, 2);
+
+ do {
+ int oldx = -1, oldy = -1, oldr = -1;
+
+ for (i = 0; i < total_moves; i++) {
+ int x, y, r;
+
+ do {
+ x = random_upto(rs, w - n + 1);
+ y = random_upto(rs, h - n + 1);
+ r = 1 + 2 * random_upto(rs, 2);
+ } while (x == oldx && y == oldy && (oldr == 0 || r == oldr));
+
+ do_rotate(grid, w, h, n, params->orientable,
+ x, y, r);
+
+ /*
+ * Prevent immediate reversal of a previous move, or
+ * execution of three consecutive identical moves
+ * adding up to a single inverse move. One exception is
+ * when we only _have_ one x,y setting.
+ */
+ if (w != n || h != n) {
+ if (oldx == x && oldy == y)
+ oldr = 0; /* now avoid _any_ move in this x,y */
+ else
+ oldr = -r & 3; /* only prohibit the exact inverse */
+ oldx = x;
+ oldy = y;
+ }
+ }
+ } while (grid_complete(grid, wh, params->orientable));
/*
* Now construct the game seed, by describing the grid as a
state->completed = 0;
state->used_solve = state->just_used_solve = FALSE;
state->movecount = 0;
+ state->movetarget = params->movetarget;
state->lastx = state->lasty = state->lastr = -1;
state->grid = snewn(wh, int);
ret->orientable = state->orientable;
ret->completed = state->completed;
ret->movecount = state->movecount;
+ ret->movetarget = state->movetarget;
ret->lastx = state->lastx;
ret->lasty = state->lasty;
ret->lastr = state->lastr;
for (i = 0; i < ret->w*ret->h; i++)
ret->grid[i] &= ~3;
ret->used_solve = ret->just_used_solve = TRUE;
- ret->completed = ret->movecount;
+ ret->completed = ret->movecount = 1;
return ret;
}
*/
maxlen = state->h * state->w * (col+o+1);
- ret = snewn(maxlen, char);
+ ret = snewn(maxlen+1, char);
p = ret;
for (y = 0; y < state->h; y++) {
int coords[8];
char str[40];
+ /*
+ * If we've been passed a rotation region but we're drawing a
+ * tile which is outside it, we must draw it normally. This can
+ * occur if we're cleaning up after a completion flash while a
+ * new move is also being made.
+ */
+ if (rot && (x < rot->cx || y < rot->cy ||
+ x >= rot->cx+rot->cw || y >= rot->cy+rot->ch))
+ rot = NULL;
+
if (rot)
clip(fe, rot->cx, rot->cy, rot->cw, rot->ch);
}
/*
- * Next, the colour bars for orientation.
+ * Next, the triangles for orientation.
*/
if (state->orientable) {
int xdx, xdy, ydx, ydy;
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);
}