COL_HIGHLIGHT,
COL_ERROR,
COL_PENCIL,
+ COL_DIAGONAL,
NCOLOURS
};
int *pencil; /* bitmaps using bits 1<<1..1<<n */
int completed, cheated;
digit *sequence; /* sequence of group elements shown */
+
+ /*
+ * This array indicates thick lines separating rows and columns
+ * placed and unplaced manually by the user as a visual aid, e.g.
+ * to delineate a subgroup and its cosets.
+ *
+ * When a line is placed, it's deemed to be between the two
+ * particular group elements that are on either side of it at the
+ * time; dragging those two away from each other automatically
+ * gets rid of the line. Hence, for a given element i, dividers[i]
+ * is either -1 (indicating no divider to the right of i), or some
+ * other element (indicating a divider to the right of i iff that
+ * element is the one right of it). These are eagerly cleared
+ * during drags.
+ */
+ int *dividers; /* thick lines between rows/cols */
};
static game_params *default_params(void)
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);
state->pencil[i] = 0;
}
state->sequence = snewn(w, digit);
+ state->dividers = snewn(w, int);
for (i = 0; i < w; i++) {
state->sequence[i] = i;
+ state->dividers[i] = -1;
}
desc = spec_to_grid(desc, state->grid, a);
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);
ret->immutable = snewn(a, unsigned char);
ret->pencil = snewn(a, int);
ret->sequence = snewn(w, digit);
+ ret->dividers = snewn(w, int);
memcpy(ret->grid, state->grid, a*sizeof(digit));
memcpy(ret->immutable, state->immutable, a*sizeof(unsigned char));
memcpy(ret->pencil, state->pencil, a*sizeof(int));
memcpy(ret->sequence, state->sequence, w*sizeof(digit));
+ memcpy(ret->dividers, state->dividers, w*sizeof(int));
ret->completed = state->completed;
ret->cheated = state->cheated;
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 drag; /* 0=none 1=row 2=col */
int dragnum; /* element being dragged */
int dragpos; /* its current position */
+ 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
#define FLASH_TIME 0.4F
+#define DF_DIVIDER_TOP 0x1000
+#define DF_DIVIDER_BOT 0x2000
+#define DF_DIVIDER_LEFT 0x4000
+#define DF_DIVIDER_RIGHT 0x8000
#define DF_HIGHLIGHT 0x0400
#define DF_HIGHLIGHT_PENCIL 0x0200
#define DF_IMMUTABLE 0x0100
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;
if (ui->drag) {
if (IS_MOUSE_DRAG(button)) {
- int tcoord = (ui->drag == 1 ? ty : tx);
+ int tcoord = ((ui->drag &~ 4) == 1 ? ty : tx);
+ ui->drag |= 4; /* some movement has happened */
if (tcoord >= 0 && tcoord < w) {
ui->dragpos = tcoord;
return "";
}
} else if (IS_MOUSE_RELEASE(button)) {
- ui->drag = 0; /* end drag */
- if (state->sequence[ui->dragpos] == ui->dragnum)
- return ""; /* drag was a no-op overall */
- sprintf(buf, "D%d,%d", ui->dragnum, ui->dragpos);
- return dupstr(buf);
+ if (ui->drag & 4) {
+ ui->drag = 0; /* end drag */
+ if (state->sequence[ui->dragpos] == ui->dragnum)
+ return ""; /* drag was a no-op overall */
+ sprintf(buf, "D%d,%d", ui->dragnum, ui->dragpos);
+ return dupstr(buf);
+ } else {
+ ui->drag = 0; /* end 'drag' */
+ if (ui->edgepos > 0 && ui->edgepos < w) {
+ sprintf(buf, "V%d,%d",
+ state->sequence[ui->edgepos-1],
+ state->sequence[ui->edgepos]);
+ return dupstr(buf);
+ } else
+ return ""; /* no-op */
+ }
}
} 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->drag = 2;
ui->dragnum = state->sequence[tx];
ui->dragpos = tx;
+ ui->edgepos = FROMCOORD(x + TILESIZE/2);
return "";
} else if (ty >= 0 && ty < w && tx == -1) {
ui->drag = 1;
ui->dragnum = state->sequence[ty];
ui->dragpos = ty;
+ 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 (!*mp)
+ break;
- if (!ret->completed && !check_errors(ret, NULL))
- ret->completed = TRUE;
+ 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') {
/*
ret->sequence[i] = from->sequence[j++];
}
}
+ /*
+ * Eliminate any obsoleted dividers.
+ */
+ 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;
+ }
+ return ret;
+ } else if (move[0] == 'V' &&
+ sscanf(move+1, "%d,%d", &i, &j) == 2) {
+ ret = dup_game(from);
+ if (ret->dividers[i] == j)
+ ret->dividers[i] = -1;
+ else
+ ret->dividers[i] = j;
return ret;
} else
return NULL; /* couldn't parse move string */
#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_rect(dr, cx, cy, cw, 1, COL_GRID);
+ if (tile & DF_DIVIDER_BOT)
+ draw_rect(dr, cx, cy+ch-1, cw, 1, COL_GRID);
+ if (tile & DF_DIVIDER_LEFT)
+ draw_rect(dr, cx, cy, 1, ch, COL_GRID);
+ if (tile & DF_DIVIDER_RIGHT)
+ draw_rect(dr, cx+cw-1, cy, 1, ch, COL_GRID);
/* pencil-mode highlight */
if (tile & DF_HIGHLIGHT_PENCIL) {
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;
if (state->immutable[sy*w+sx])
tile |= DF_IMMUTABLE;
- if ((ui->drag == 1 && ui->dragnum == sy) ||
- (ui->drag == 2 && ui->dragnum == sx))
+ if ((ui->drag == 5 && ui->dragnum == sy) ||
+ (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 ||
flashtime >= FLASH_TIME*2/3))
tile |= DF_HIGHLIGHT; /* completion flash */
- error = ds->errtmp[y*w+x];
+ if (y <= 0 || state->dividers[ds->sequence[y-1]] == sy)
+ tile |= DF_DIVIDER_TOP;
+ if (y+1 >= w || state->dividers[sy] == ds->sequence[y+1])
+ tile |= DF_DIVIDER_BOT;
+ if (x <= 0 || state->dividers[ds->sequence[x-1]] == sx)
+ tile |= DF_DIVIDER_LEFT;
+ if (x+1 >= w || state->dividers[sx] == ds->sequence[x+1])
+ tile |= DF_DIVIDER_RIGHT;
+
+ error = ds->errtmp[sy*w+sx];
if (ds->tiles[y*w+x] != tile ||
ds->pencil[y*w+x] != pencil ||
}
}
-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_timing_state(game_state *state, game_ui *ui)
+static int game_status(const game_state *state)
+{
+ return state->completed ? +1 : 0;
+}
+
+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,
game_redraw,
game_anim_length,
game_flash_length,
+ game_status,
TRUE, FALSE, game_print_size, game_print,
FALSE, /* wants_statusbar */
FALSE, game_timing_state,