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
*/
ret[0].name = "Width";
ret[0].type = C_STRING;
sprintf(buf, "%d", params->w);
- ret[0].sval = dupstr(buf);
- ret[0].ival = 0;
+ ret[0].u.string.sval = dupstr(buf);
ret[1].name = "Height";
ret[1].type = C_STRING;
sprintf(buf, "%d", params->h);
- ret[1].sval = dupstr(buf);
- ret[1].ival = 0;
+ ret[1].u.string.sval = dupstr(buf);
ret[2].name = "Difficulty";
ret[2].type = C_CHOICES;
- ret[2].sval = DIFFCONFIG;
- ret[2].ival = params->diff;
+ ret[2].u.choices.choicenames = DIFFCONFIG;
+ ret[2].u.choices.selected = params->diff;
ret[3].name = NULL;
ret[3].type = C_END;
- ret[3].sval = NULL;
- ret[3].ival = 0;
return ret;
}
{
game_params *ret = snew(game_params);
- ret->w = atoi(cfg[0].sval);
- ret->h = atoi(cfg[1].sval);
- ret->diff = cfg[2].ival;
+ ret->w = atoi(cfg[0].u.string.sval);
+ ret->h = atoi(cfg[1].u.string.sval);
+ ret->diff = cfg[2].u.choices.selected;
return ret;
}
-static char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, int full)
{
if (params->w < 3 || params->h < 3)
return "Width and height must both be at least 3";
}
}
+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 struct space *sp2dot(const game_state *state, int x, int y)
+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)
{
- struct space *sp = &SPACE(state, x, y);
+ space *sp = &SPACE(state, x, y);
if (!(sp->flags & F_TILE_ASSOC)) return NULL;
return &SPACE(state, sp->dotx, sp->doty);
}
static int is_same_assoc(game_state *state,
int x1, int y1, int x2, int y2)
{
- struct space *s1, *s2;
+ space *s1, *s2;
if (!INGRID(state, x1, y1) || !INGRID(state, x2, y2))
return 0;
}
#endif
-static struct space *space_opposite_dot(struct game_state *state,
- struct space *sp, struct 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 struct space *tile_opposite(struct game_state *state, struct space *sp)
+static space *tile_opposite(const game_state *state, const space *sp)
{
- struct space *dot;
+ space *dot;
assert(sp->flags & F_TILE_ASSOC);
dot = &SPACE(state, sp->dotx, sp->doty);
return 1;
}
-static void adjacencies(struct game_state *state, struct space *sp,
- struct space **a1s, struct space **a2s)
+static void adjacencies(game_state *state, space *sp, space **a1s, space **a2s)
{
int dxs[4] = {-1, 1, 0, 0}, dys[4] = {0, 0, -1, 1};
int n, x, y;
static int outline_tile_fordot(game_state *state, space *tile, int mark)
{
- struct space *tadj[4], *eadj[4];
+ space *tadj[4], *eadj[4];
int i, didsth = 0, edge, same;
assert(tile->type == s_tile);
return didsth;
}
-static void tiles_from_edge(struct game_state *state,
- struct space *sp, struct space **ts)
+static void tiles_from_edge(game_state *state, space *sp, space **ts)
{
int xs[2], ys[2];
int issolve)
{
int movelen = 0, movesize = 256, x, y, len;
- char *move = snewn(movesize, char), buf[80], *sep = "";
+ char *move = snewn(movesize, char), buf[80];
+ const char *sep = "";
char achar = issolve ? 'a' : 'A';
space *sps, *spd;
state->sx = (w*2)+1;
state->sy = (h*2)+1;
- state->grid = snewn(state->sx * state->sy, struct space);
+ state->grid = snewn(state->sx * state->sy, space);
state->completed = state->used_solve = 0;
for (x = 0; x < state->sx; x++) {
for (y = 0; y < state->sy; y++) {
- struct space *sp = &SPACE(state, x, y);
- memset(sp, 0, sizeof(struct space));
+ space *sp = &SPACE(state, x, y);
+ memset(sp, 0, sizeof(space));
sp->x = x;
sp->y = y;
if ((x % 2) == 0 && (y % 2) == 0)
ret->used_solve = state->used_solve;
memcpy(ret->grid, state->grid,
- ret->sx*ret->sy*sizeof(struct space));
+ ret->sx*ret->sy*sizeof(space));
game_update_dots(ret);
#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:
}
static game_state *load_game(const game_params *params, const char *desc,
- char **why_r)
+ const char **why_r)
{
game_state *state = blank_game(params->w, params->h);
- char *why = NULL;
+ const char *why = NULL;
int i, x, y, n;
unsigned int df;
return NULL;
}
-static char *validate_desc(const game_params *params, const char *desc)
+static const char *validate_desc(const game_params *params, const char *desc)
{
- char *why = NULL;
+ const char *why = NULL;
game_state *dummy = load_game(params, desc, &why);
if (dummy) {
free_game(dummy);
static int solver_spaces_oneposs_cb(game_state *state, space *tile, void *ctx)
{
int n, eset, ret;
- struct space *edgeadj[4], *tileadj[4];
+ space *edgeadj[4], *tileadj[4];
int dotx, doty;
assert(tile->type == s_tile);
return 0;
}
-static int solver_state(game_state *state, int maxdiff);
-
#define MAXRECURSE 5
static int solver_recurse(game_state *state, int maxdiff)
solver_recurse_depth++;
#endif
- ingrid = snewn(gsz, struct space);
- memcpy(ingrid, state->grid, gsz * sizeof(struct space));
+ ingrid = snewn(gsz, space);
+ memcpy(ingrid, state->grid, gsz * sizeof(space));
for (n = 0; n < state->ndots; n++) {
- memcpy(state->grid, ingrid, gsz * sizeof(struct space));
+ memcpy(state->grid, ingrid, gsz * sizeof(space));
if (!dotfortile(state, rctx.best, state->dots[n])) continue;
if (diff == DIFF_IMPOSSIBLE && ret != DIFF_IMPOSSIBLE) {
/* we found our first solved grid; copy it away. */
assert(!outgrid);
- outgrid = snewn(gsz, struct space);
- memcpy(outgrid, state->grid, gsz * sizeof(struct space));
+ outgrid = snewn(gsz, space);
+ memcpy(outgrid, state->grid, gsz * sizeof(space));
}
/* reset cell back to unassociated. */
bestopp = tile_opposite(state, rctx.best);
if (outgrid) {
/* we found (at least one) soln; copy it back to state */
- memcpy(state->grid, outgrid, gsz * sizeof(struct space));
+ memcpy(state->grid, outgrid, gsz * sizeof(space));
sfree(outgrid);
}
sfree(ingrid);
#ifndef EDITOR
static char *solve_game(const game_state *state, const game_state *currstate,
- const char *aux, char **error)
+ const char *aux, const char **error)
{
game_state *tosolve;
char *ret;
unsigned long *grid;
int *dx, *dy;
blitter *bl;
+ blitter *blmirror;
int dragging, dragx, dragy;
{
char buf[80];
int px, py;
- struct space *sp;
+ space *sp;
px = 2*FROMCOORD((float)x) + 0.5;
py = 2*FROMCOORD((float)y) + 0.5;
char buf[80];
const char *sep = "";
int px, py;
- struct space *sp, *dot;
+ space *sp, *dot;
buf[0] = '\0';
ui->dy = y;
ui->dotx = dot->x;
ui->doty = dot->y;
- return "";
+ return UI_UPDATE;
}
} else if (button == RIGHT_DRAG && ui->dragging) {
/* just move the drag coords. */
ui->dx = x;
ui->dy = y;
- return "";
+ return UI_UPDATE;
} else if (button == RIGHT_RELEASE && ui->dragging) {
ui->dragging = FALSE;
* is a null move; just update the ui and finish.
*/
if (px == ui->srcx && py == ui->srcy)
- return "";
+ return UI_UPDATE;
/*
* Otherwise, we remove the arrow from its starting
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);
}
if (buf[0])
return dupstr(buf);
else
- return "";
+ return UI_UPDATE;
} else if (IS_CURSOR_MOVE(button)) {
move_cursor(button, &ui->cur_x, &ui->cur_y, state->sx-1, state->sy-1, 0);
if (ui->cur_x < 1) ui->cur_x = 1;
ui->dx = SCOORD(ui->cur_x);
ui->dy = SCOORD(ui->cur_y);
}
- return "";
+ return UI_UPDATE;
} else if (IS_CURSOR_SELECT(button)) {
if (!ui->cur_visible) {
ui->cur_visible = 1;
- return "";
+ return UI_UPDATE;
}
sp = &SPACE(state, ui->cur_x, ui->cur_y);
if (ui->dragging) {
ui->dy = SCOORD(ui->cur_y);
ui->dotx = ui->srcx = ui->cur_x;
ui->doty = ui->srcy = ui->cur_y;
- return "";
+ return UI_UPDATE;
} else if (sp->flags & F_TILE_ASSOC) {
assert(sp->type == s_tile);
ui->dragging = TRUE;
ui->doty = sp->doty;
ui->srcx = ui->cur_x;
ui->srcy = ui->cur_y;
- return "";
+ return UI_UPDATE;
} else if (sp->type == s_edge) {
sprintf(buf, "E%d,%d", ui->cur_x, ui->cur_y);
return dupstr(buf);
{
int x, y, ax, ay, n, dx, dy;
game_state *ret = dup_game(state);
- struct space *sp, *dot;
+ 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,
int main(int argc, char **argv)
{
game_params *p;
- char *id = NULL, *desc, *err;
+ char *id = NULL, *desc;
+ const char *err;
game_state *s;
int diff, do_soak = 0, verbose = 0;
random_state *rs;
~ian / sgt-puzzles.git / blobdiff