COL_HIGHLIGHT,
COL_ERROR,
COL_PENCIL,
+ COL_DIAGONAL,
NCOLOURS
};
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 */
}
}
-static char *encode_params(game_params *params, int full)
+static char *encode_params(const game_params *params, int full)
{
char ret[80];
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];
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);
return ret;
}
-static char *validate_params(game_params *params, int full)
+static char *validate_params(const game_params *params, int full)
{
if (params->w < 3 || params->w > 26)
return "Grid size must be between 3 and 26";
#define SOLVER(upper,title,func,lower) func,
static usersolver_t const group_solvers[] = { DIFFLIST(SOLVER) };
-static int solver(game_params *params, digit *grid, int maxdiff)
+static int solver(const game_params *params, digit *grid, int maxdiff)
{
int w = params->w;
int ret;
/* ----- data generated by group.gap ends ----- */
-static char *new_game_desc(game_params *params, random_state *rs,
+static char *new_game_desc(const game_params *params, random_state *rs,
char **aux, int interactive)
{
int w = params->w, a = w*w;
return NULL;
}
-static char *validate_desc(game_params *params, char *desc)
+static char *validate_desc(const game_params *params, const char *desc)
{
int w = params->w, a = w*w;
const char *p = desc;
return validate_grid_desc(&p, w, a);
}
-static char *spec_to_grid(char *desc, digit *grid, int area)
+static const char *spec_to_grid(const char *desc, digit *grid, int area)
{
int i = 0;
while (*desc && *desc != ',') {
return desc;
}
-static game_state *new_game(midend *me, game_params *params, char *desc)
+static game_state *new_game(midend *me, const game_params *params,
+ const char *desc)
{
int w = params->w, a = w*w;
game_state *state = snew(game_state);
return state;
}
-static game_state *dup_game(game_state *state)
+static game_state *dup_game(const game_state *state)
{
int w = state->par.w, a = w*w;
game_state *ret = snew(game_state);
sfree(state);
}
-static char *solve_game(game_state *state, game_state *currstate,
- char *aux, char **error)
+static char *solve_game(const game_state *state, const game_state *currstate,
+ const char *aux, char **error)
{
int w = state->par.w, a = w*w;
int i, ret;
return out;
}
-static int game_can_format_as_text_now(game_params *params)
+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)
{
int w = state->par.w;
int x, y;
struct game_ui {
/*
- * These are the coordinates of the currently highlighted
- * square on the grid, if hshow = 1.
+ * These are the coordinates of the primary highlighted square on
+ * the grid, if hshow = 1.
*/
int hx, hy;
+ /*
+ * These are the coordinates hx,hy _before_ they go through
+ * state->sequence.
+ */
+ int ohx, ohy;
+ /*
+ * These variables give the length and displacement of a diagonal
+ * sequence of highlighted squares starting at ohx,ohy (still if
+ * hshow = 1). To find the squares' real coordinates, for 0<=i<dn,
+ * compute ohx+i*odx and ohy+i*ody and then map through
+ * state->sequence.
+ */
+ int odx, ody, odn;
/*
* This indicates whether the current highlight is a
* pencil-mark one or a real one.
int edgepos;
};
-static game_ui *new_ui(game_state *state)
+static game_ui *new_ui(const game_state *state)
{
game_ui *ui = snew(game_ui);
sfree(ui);
}
-static char *encode_ui(game_ui *ui)
+static char *encode_ui(const game_ui *ui)
{
return NULL;
}
-static void decode_ui(game_ui *ui, char *encoding)
+static void decode_ui(game_ui *ui, const char *encoding)
{
}
-static void game_changed_state(game_ui *ui, game_state *oldstate,
- game_state *newstate)
+static void game_changed_state(game_ui *ui, const game_state *oldstate,
+ const game_state *newstate)
{
int w = newstate->par.w;
/*
newstate->grid[ui->hy * w + ui->hx] != 0) {
ui->hshow = 0;
}
+ if (ui->hshow && ui->odn > 1) {
+ /*
+ * Reordering of rows or columns within the range of a
+ * multifill selection cancels the multifill and deselects
+ * everything.
+ */
+ int i;
+ for (i = 0; i < ui->odn; i++) {
+ if (oldstate->sequence[ui->ohx + i*ui->odx] !=
+ newstate->sequence[ui->ohx + i*ui->odx]) {
+ ui->hshow = 0;
+ break;
+ }
+ if (oldstate->sequence[ui->ohy + i*ui->ody] !=
+ newstate->sequence[ui->ohy + i*ui->ody]) {
+ ui->hshow = 0;
+ break;
+ }
+ }
+ } else if (ui->hshow &&
+ (newstate->sequence[ui->ohx] != ui->hx ||
+ newstate->sequence[ui->ohy] != ui->hy)) {
+ /*
+ * Otherwise, reordering of the row or column containing the
+ * selection causes the selection to move with it.
+ */
+ int i;
+ for (i = 0; i < w; i++) {
+ if (newstate->sequence[i] == ui->hx)
+ ui->ohx = i;
+ if (newstate->sequence[i] == ui->hy)
+ ui->ohy = i;
+ }
+ }
}
#define PREFERRED_TILESIZE 48
digit *sequence;
};
-static int check_errors(game_state *state, long *errors)
+static int check_errors(const game_state *state, long *errors)
{
int w = state->par.w, a = w*w;
digit *grid = state->grid;
return errs;
}
-static char *interpret_move(game_state *state, game_ui *ui, game_drawstate *ds,
- int x, int y, int button)
+static int find_in_sequence(digit *seq, int len, digit n)
+{
+ int i;
+
+ for (i = 0; i < len; i++)
+ if (seq[i] == n)
+ return i;
+
+ assert(!"Should never get here");
+ return -1;
+}
+
+static char *interpret_move(const game_state *state, game_ui *ui,
+ const game_drawstate *ds,
+ int x, int y, int button)
{
int w = state->par.w;
int tx, ty;
}
} else if (IS_MOUSE_DOWN(button)) {
if (tx >= 0 && tx < w && ty >= 0 && ty < w) {
+ int otx = tx, oty = ty;
tx = state->sequence[tx];
ty = state->sequence[ty];
if (button == LEFT_BUTTON) {
} else {
ui->hx = tx;
ui->hy = ty;
+ ui->ohx = otx;
+ ui->ohy = oty;
+ ui->odx = ui->ody = 0;
+ ui->odn = 1;
ui->hshow = !state->immutable[ty*w+tx];
ui->hpencil = 0;
}
ui->hpencil = 1;
ui->hx = tx;
ui->hy = ty;
+ ui->ohx = otx;
+ ui->ohy = oty;
+ ui->odx = ui->ody = 0;
+ ui->odn = 1;
ui->hshow = 1;
}
} else {
ui->edgepos = FROMCOORD(y + TILESIZE/2);
return "";
}
+ } else if (IS_MOUSE_DRAG(button)) {
+ if (!ui->hpencil &&
+ tx >= 0 && tx < w && ty >= 0 && ty < w &&
+ abs(tx - ui->ohx) == abs(ty - ui->ohy)) {
+ ui->odn = abs(tx - ui->ohx) + 1;
+ ui->odx = (tx < ui->ohx ? -1 : +1);
+ ui->ody = (ty < ui->ohy ? -1 : +1);
+ } else {
+ ui->odx = ui->ody = 0;
+ ui->odn = 1;
+ }
+ return "";
}
if (IS_CURSOR_MOVE(button)) {
- move_cursor(button, &ui->hx, &ui->hy, w, w, 0);
+ int cx = find_in_sequence(state->sequence, w, ui->hx);
+ int cy = find_in_sequence(state->sequence, w, ui->hy);
+ move_cursor(button, &cx, &cy, w, w, 0);
+ ui->hx = state->sequence[cx];
+ ui->hy = state->sequence[cy];
ui->hshow = ui->hcursor = 1;
return "";
}
((ISCHAR(button) && FROMCHAR(button, state->par.id) <= w) ||
button == CURSOR_SELECT2 || button == '\b')) {
int n = FROMCHAR(button, state->par.id);
+ int i, buflen;
+ char *movebuf;
+
if (button == CURSOR_SELECT2 || button == '\b')
n = 0;
- /*
- * Can't make pencil marks in a filled square. This can only
- * become highlighted if we're using cursor keys.
- */
- if (ui->hpencil && state->grid[ui->hy*w+ui->hx])
- return NULL;
-
- /*
- * Can't do anything to an immutable square.
- */
- if (state->immutable[ui->hy*w+ui->hx])
- return NULL;
+ for (i = 0; i < ui->odn; i++) {
+ int x = state->sequence[ui->ohx + i*ui->odx];
+ int y = state->sequence[ui->ohy + i*ui->ody];
+ int index = y*w+x;
+
+ /*
+ * Can't make pencil marks in a filled square. This can only
+ * become highlighted if we're using cursor keys.
+ */
+ if (ui->hpencil && state->grid[index])
+ return NULL;
+
+ /*
+ * Can't do anything to an immutable square. Exception:
+ * trying to set it to what it already was is OK (so that
+ * multifilling can set a whole diagonal to a without
+ * having to detour round the one immutable square in the
+ * middle that already said a).
+ */
+ if (!ui->hpencil && state->grid[index] == n)
+ /* OK even if it is immutable */;
+ else if (state->immutable[index])
+ return NULL;
+ }
- sprintf(buf, "%c%d,%d,%d",
- (char)(ui->hpencil && n > 0 ? 'P' : 'R'), ui->hx, ui->hy, n);
+ movebuf = snewn(80 * ui->odn, char);
+ buflen = sprintf(movebuf, "%c%d,%d,%d",
+ (char)(ui->hpencil && n > 0 ? 'P' : 'R'),
+ ui->hx, ui->hy, n);
+ for (i = 1; i < ui->odn; i++) {
+ assert(buflen < i*80);
+ buflen += sprintf(movebuf + buflen, "+%d,%d",
+ state->sequence[ui->ohx + i*ui->odx],
+ state->sequence[ui->ohy + i*ui->ody]);
+ }
+ movebuf = sresize(movebuf, buflen+1, char);
if (!ui->hcursor) ui->hshow = 0;
- return dupstr(buf);
+ return movebuf;
}
if (button == 'M' || button == 'm')
return NULL;
}
-static game_state *execute_move(game_state *from, char *move)
+static game_state *execute_move(const game_state *from, const char *move)
{
int w = from->par.w, a = w*w;
game_state *ret;
- int x, y, i, j, n;
+ int x, y, i, j, n, pos;
if (move[0] == 'S') {
ret = dup_game(from);
return ret;
} else if ((move[0] == 'P' || move[0] == 'R') &&
- sscanf(move+1, "%d,%d,%d", &x, &y, &n) == 3 &&
- x >= 0 && x < w && y >= 0 && y < w && n >= 0 && n <= w) {
- if (from->immutable[y*w+x])
- return NULL;
+ sscanf(move+1, "%d,%d,%d%n", &x, &y, &n, &pos) == 3 &&
+ n >= 0 && n <= w) {
+ const char *mp = move + 1 + pos;
+ int pencil = (move[0] == 'P');
+ ret = dup_game(from);
+
+ while (1) {
+ if (x < 0 || x >= w || y < 0 || y >= w) {
+ free_game(ret);
+ return NULL;
+ }
+ if (from->immutable[y*w+x] && !(!pencil && from->grid[y*w+x] == n))
+ return NULL;
- ret = dup_game(from);
- if (move[0] == 'P' && n > 0) {
- ret->pencil[y*w+x] ^= 1 << n;
- } else {
- ret->grid[y*w+x] = n;
- ret->pencil[y*w+x] = 0;
+ if (move[0] == 'P' && n > 0) {
+ ret->pencil[y*w+x] ^= 1 << n;
+ } else {
+ ret->grid[y*w+x] = n;
+ ret->pencil[y*w+x] = 0;
+ }
- if (!ret->completed && !check_errors(ret, NULL))
- ret->completed = TRUE;
+ if (!*mp)
+ break;
+
+ if (*mp != '+')
+ return NULL;
+ if (sscanf(mp, "+%d,%d%n", &x, &y, &pos) < 2)
+ return NULL;
+ mp += pos;
}
+
+ if (!ret->completed && !check_errors(ret, NULL))
+ ret->completed = TRUE;
+
return ret;
} else if (move[0] == 'M') {
/*
/*
* Eliminate any obsoleted dividers.
*/
- for (x = 0; x+1 < w; x++) {
- int i = ret->sequence[x], j = ret->sequence[x+1];
+ for (x = 0; x < w; x++) {
+ int i = ret->sequence[x];
+ int j = (x+1 < w ? ret->sequence[x+1] : -1);
if (ret->dividers[i] != j)
ret->dividers[i] = -1;
}
#define SIZE(w) ((w) * TILESIZE + 2*BORDER + LEGEND)
-static void game_compute_size(game_params *params, int tilesize,
- 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;
}
static void game_set_size(drawing *dr, game_drawstate *ds,
- game_params *params, int tilesize)
+ const game_params *params, int tilesize)
{
ds->tilesize = tilesize;
}
ret[COL_PENCIL * 3 + 1] = 0.5F * ret[COL_BACKGROUND * 3 + 1];
ret[COL_PENCIL * 3 + 2] = ret[COL_BACKGROUND * 3 + 2];
+ ret[COL_DIAGONAL * 3 + 0] = 0.95F * ret[COL_BACKGROUND * 3 + 0];
+ ret[COL_DIAGONAL * 3 + 1] = 0.95F * ret[COL_BACKGROUND * 3 + 1];
+ ret[COL_DIAGONAL * 3 + 2] = 0.95F * ret[COL_BACKGROUND * 3 + 2];
+
*ncolours = NCOLOURS;
return ret;
}
-static game_drawstate *game_new_drawstate(drawing *dr, game_state *state)
+static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
{
int w = state->par.w, a = w*w;
struct game_drawstate *ds = snew(struct game_drawstate);
/* background needs erasing */
draw_rect(dr, cx, cy, cw, ch,
- (tile & DF_HIGHLIGHT) ? COL_HIGHLIGHT : COL_BACKGROUND);
+ (tile & DF_HIGHLIGHT) ? COL_HIGHLIGHT :
+ (x == y) ? COL_DIAGONAL : COL_BACKGROUND);
/* dividers */
if (tile & DF_DIVIDER_TOP)
draw_update(dr, cx, cy, cw, ch);
}
-static void game_redraw(drawing *dr, game_drawstate *ds, game_state *oldstate,
- game_state *state, int dir, game_ui *ui,
- float animtime, float flashtime)
+static void game_redraw(drawing *dr, game_drawstate *ds,
+ const game_state *oldstate, const game_state *state,
+ int dir, const game_ui *ui,
+ float animtime, float flashtime)
{
int w = state->par.w /*, a = w*w */;
int x, y, i, j;
tile |= DF_IMMUTABLE;
if ((ui->drag == 5 && ui->dragnum == sy) ||
- (ui->drag == 6 && ui->dragnum == sx))
+ (ui->drag == 6 && ui->dragnum == sx)) {
tile |= DF_HIGHLIGHT;
- else if (ui->hshow && ui->hx == sx && ui->hy == sy)
- tile |= (ui->hpencil ? DF_HIGHLIGHT_PENCIL : DF_HIGHLIGHT);
+ } else if (ui->hshow) {
+ int i = abs(x - ui->ohx);
+ int highlight = 0;
+ if (ui->odn > 1) {
+ /*
+ * When a diagonal multifill selection is shown,
+ * we show it in its original grid position
+ * regardless of in-progress row/col drags. Moving
+ * every square about would be horrible.
+ */
+ if (i >= 0 && i < ui->odn &&
+ x == ui->ohx + i*ui->odx &&
+ y == ui->ohy + i*ui->ody)
+ highlight = 1;
+ } else {
+ /*
+ * For a single square, we move its highlight
+ * around with the drag.
+ */
+ highlight = (ui->hx == sx && ui->hy == sy);
+ }
+ if (highlight)
+ tile |= (ui->hpencil ? DF_HIGHLIGHT_PENCIL : DF_HIGHLIGHT);
+ }
if (flashtime > 0 &&
(flashtime <= FLASH_TIME/3 ||
}
}
-static float game_anim_length(game_state *oldstate, game_state *newstate,
- int dir, game_ui *ui)
+static float game_anim_length(const game_state *oldstate,
+ const game_state *newstate, int dir, game_ui *ui)
{
return 0.0F;
}
-static float game_flash_length(game_state *oldstate, game_state *newstate,
- int dir, game_ui *ui)
+static float game_flash_length(const game_state *oldstate,
+ const game_state *newstate, int dir, game_ui *ui)
{
if (!oldstate->completed && newstate->completed &&
!oldstate->cheated && !newstate->cheated)
return 0.0F;
}
-static int game_status(game_state *state)
+static int game_status(const game_state *state)
{
return state->completed ? +1 : 0;
}
-static int game_timing_state(game_state *state, game_ui *ui)
+static int game_timing_state(const game_state *state, game_ui *ui)
{
if (state->completed)
return FALSE;
return TRUE;
}
-static void game_print_size(game_params *params, float *x, float *y)
+static void game_print_size(const game_params *params, float *x, float *y)
{
int pw, ph;
*y = ph / 100.0F;
}
-static void game_print(drawing *dr, game_state *state, int tilesize)
+static void game_print(drawing *dr, const game_state *state, int tilesize)
{
int w = state->par.w;
int ink = print_mono_colour(dr, 0);
const struct game thegame = {
"Group", NULL, NULL,
default_params,
- game_fetch_preset,
+ game_fetch_preset, NULL,
decode_params,
encode_params,
free_params,
~ian / sgt-puzzles.git / blobdiff