or -1 if stale. */
};
+static int check_complete(const game_state *state, int *dsf, int *colours);
+static int solver_state(game_state *state, int maxdiff);
+static int solver_obvious(game_state *state);
+static int solver_obvious_dot(game_state *state, space *dot);
+static space *space_opposite_dot(const game_state *state, const space *sp,
+ const space *dot);
+static space *tile_opposite(const game_state *state, const space *sp);
+
/* ----------------------------------------------------------
* Game parameters and presets
*/
}
}
+static void remove_assoc_with_opposite(game_state *state, space *tile) {
+ space *opposite;
+
+ if (!(tile->flags & F_TILE_ASSOC)) {
+ return;
+ }
+
+ opposite = tile_opposite(state, tile);
+ remove_assoc(state, tile);
+
+ if (opposite != NULL && opposite != tile) {
+ remove_assoc(state, opposite);
+ }
+}
+
static void add_assoc(const game_state *state, space *tile, space *dot) {
remove_assoc(state, tile);
tile->x, tile->y, dot->x, dot->y, dot->nassoc));*/
}
+static void add_assoc_with_opposite(game_state *state, space *tile, space *dot) {
+ int *colors;
+ space *opposite = space_opposite_dot(state, tile, dot);
+
+ if (opposite == NULL) {
+ return;
+ }
+ if (opposite->flags & F_DOT) {
+ return;
+ }
+
+ colors = snewn(state->w * state->h, int);
+ check_complete(state, NULL, colors);
+ if (colors[(tile->y - 1)/2 * state->w + (tile->x - 1)/2]) {
+ sfree(colors);
+ return;
+ }
+ if (colors[(opposite->y - 1)/2 * state->w + (opposite->x - 1)/2]) {
+ sfree(colors);
+ return;
+ }
+
+ sfree(colors);
+ remove_assoc_with_opposite(state, tile);
+ add_assoc(state, tile, dot);
+ remove_assoc_with_opposite(state, opposite);
+ add_assoc(state, opposite, dot);
+}
+
static space *sp2dot(const game_state *state, int x, int y)
{
space *sp = &SPACE(state, x, y);
}
#endif
-static space *space_opposite_dot(game_state *state, space *sp, space *dot)
+static space *space_opposite_dot(const game_state *state, const space *sp,
+ const space *dot)
{
int dx, dy, tx, ty;
space *sp2;
return sp2;
}
-static space *tile_opposite(game_state *state, space *sp)
+static space *tile_opposite(const game_state *state, const space *sp)
{
space *dot;
#define MAXTRIES 50
#endif
-static int solver_obvious_dot(game_state *state,space *dot);
-
#define GP_DOTS 1
static void generate_pass(game_state *state, random_state *rs, int *scratch,
dbg_state(state);
}
-static int check_complete(const game_state *state, int *dsf, int *colours);
-static int solver_state(game_state *state, int maxdiff);
-
static char *new_game_desc(const game_params *params, random_state *rs,
char **aux, int interactive)
{
game_update_dots(state);
+ if (state->ndots == 1) goto generate;
+
#ifdef DEBUGGING
{
char *tmp = encode_game(state);
return desc;
}
-static int solver_obvious(game_state *state);
-
static int dots_too_close(game_state *state)
{
/* Quick-and-dirty check, using half the solver:
return 0;
}
-static int solver_state(game_state *state, int maxdiff);
-
#define MAXRECURSE 5
static int solver_recurse(game_state *state, int maxdiff)
unsigned long *grid;
int *dx, *dy;
blitter *bl;
+ blitter *blmirror;
int dragging, dragx, dragy;
if (INUI(state, px, py)) {
sp = &SPACE(state, px, py);
- if (!(sp->flags & F_DOT) && !(sp->flags & F_TILE_ASSOC))
+ if (!(sp->flags & F_DOT))
sprintf(buf + strlen(buf), "%sA%d,%d,%d,%d",
sep, px, py, ui->dotx, ui->doty);
}
int x, y, ax, ay, n, dx, dy;
game_state *ret = dup_game(state);
space *sp, *dot;
+ int currently_solving = FALSE;
debug(("%s\n", move));
} else if (c == 'U') {
if (sp->type != s_tile || !(sp->flags & F_TILE_ASSOC))
goto badmove;
- remove_assoc(ret, sp);
+ /* The solver doesn't assume we'll mirror things */
+ if (currently_solving)
+ remove_assoc(ret, sp);
+ else
+ remove_assoc_with_opposite(ret, sp);
} else if (c == 'M') {
if (!(sp->flags & F_DOT)) goto badmove;
sp->flags ^= F_DOT_HOLD;
space *dot = &SPACE(ret, sp->dotx, sp->doty);
if (dot->flags & F_DOT_HOLD) continue;
}
- add_assoc(ret, sp, dot);
+ /* The solver doesn't assume we'll mirror things */
+ if (currently_solving)
+ add_assoc(ret, sp, dot);
+ else
+ add_assoc_with_opposite(ret, sp, dot);
}
}
move += n;
} else if (c == 'S') {
move++;
ret->used_solve = 1;
+ currently_solving = TRUE;
} else
goto badmove;
assert(!ds->bl);
ds->bl = blitter_new(dr, TILE_SIZE, TILE_SIZE);
+ assert(!ds->blmirror);
+ ds->blmirror = blitter_new(dr, TILE_SIZE, TILE_SIZE);
+
assert(!ds->cur_bl);
ds->cur_bl = blitter_new(dr, TILE_SIZE, TILE_SIZE);
}
ds->dy = snewn(ds->w*ds->h, int);
ds->bl = NULL;
+ ds->blmirror = NULL;
ds->dragging = FALSE;
ds->dragx = ds->dragy = 0;
{
if (ds->cur_bl) blitter_free(dr, ds->cur_bl);
sfree(ds->colour_scratch);
+ if (ds->blmirror) blitter_free(dr, ds->blmirror);
if (ds->bl) blitter_free(dr, ds->bl);
sfree(ds->dx);
sfree(ds->dy);
draw_update(dr, lx, ly, TILE_SIZE, TILE_SIZE);
}
+static void calculate_opposite_point(const game_ui *ui,
+ const game_drawstate *ds, const int x,
+ const int y, int *oppositex,
+ int *oppositey)
+{
+ /* oppositex - dotx = dotx - x <=> oppositex = 2 * dotx - x */
+ *oppositex = 2 * SCOORD(ui->dotx) - x;
+ *oppositey = 2 * SCOORD(ui->doty) - y;
+}
+
static void game_redraw(drawing *dr, game_drawstate *ds,
const game_state *oldstate, const game_state *state,
int dir, const game_ui *ui,
{
int w = ds->w, h = ds->h;
int x, y, flashing = FALSE;
+ int oppx, oppy;
if (flashtime > 0) {
int frame = (int)(flashtime / FLASH_TIME);
if (ds->dragging) {
assert(ds->bl);
+ assert(ds->blmirror);
+ calculate_opposite_point(ui, ds, ds->dragx + TILE_SIZE/2,
+ ds->dragy + TILE_SIZE/2, &oppx, &oppy);
+ oppx -= TILE_SIZE/2;
+ oppy -= TILE_SIZE/2;
blitter_load(dr, ds->bl, ds->dragx, ds->dragy);
draw_update(dr, ds->dragx, ds->dragy, TILE_SIZE, TILE_SIZE);
+ blitter_load(dr, ds->blmirror, oppx, oppy);
+ draw_update(dr, oppx, oppy, TILE_SIZE, TILE_SIZE);
ds->dragging = FALSE;
}
if (ds->cur_visible) {
for (x = 0; x < w; x++) {
unsigned long flags = 0;
int ddx = 0, ddy = 0;
- space *sp;
+ space *sp, *opp;
int dx, dy;
/*
* everything goes briefly back to background colour.
*/
sp = &SPACE(state, x*2+1, y*2+1);
+ if (sp->flags & F_TILE_ASSOC) {
+ opp = tile_opposite(state, sp);
+ } else {
+ opp = NULL;
+ }
if (ds->colour_scratch[y*w+x] && !flashing) {
flags |= (ds->colour_scratch[y*w+x] == 2 ?
DRAW_BLACK : DRAW_WHITE);
*/
if ((sp->flags & F_TILE_ASSOC) && !ds->colour_scratch[y*w+x]) {
if (ui->dragging && ui->srcx == x*2+1 && ui->srcy == y*2+1) {
- /* don't do it */
+ /* tile is the source, don't do it */
+ } else if (ui->dragging && opp && ui->srcx == opp->x && ui->srcy == opp->y) {
+ /* opposite tile is the source, don't do it */
} else if (sp->doty != y*2+1 || sp->dotx != x*2+1) {
flags |= DRAW_ARROW;
ddy = sp->doty - (y*2+1);
ds->dragging = TRUE;
ds->dragx = ui->dx - TILE_SIZE/2;
ds->dragy = ui->dy - TILE_SIZE/2;
+ calculate_opposite_point(ui, ds, ui->dx, ui->dy, &oppx, &oppy);
blitter_save(dr, ds->bl, ds->dragx, ds->dragy);
- draw_arrow(dr, ds, ui->dx, ui->dy,
- SCOORD(ui->dotx) - ui->dx,
+ blitter_save(dr, ds->blmirror, oppx - TILE_SIZE/2, oppy - TILE_SIZE/2);
+ draw_arrow(dr, ds, ui->dx, ui->dy, SCOORD(ui->dotx) - ui->dx,
SCOORD(ui->doty) - ui->dy, COL_ARROW);
+ draw_arrow(dr, ds, oppx, oppy, SCOORD(ui->dotx) - oppx,
+ SCOORD(ui->doty) - oppy, COL_ARROW);
}
#ifdef EDITOR
{
const struct game thegame = {
"Galaxies", "games.galaxies", "galaxies",
default_params,
- game_fetch_preset,
+ game_fetch_preset, NULL,
decode_params,
encode_params,
free_params,
~ian / sgt-puzzles.git / blobdiff