X-Git-Url: https://git.distorted.org.uk/~mdw/sgt/puzzles/blobdiff_plain/ab3a1e43565de2cb5d3404ee326c0f7f8ed11610..HEAD:/galaxies.c diff --git a/galaxies.c b/galaxies.c index 3fe33dc..db89700 100644 --- a/galaxies.c +++ b/galaxies.c @@ -53,6 +53,25 @@ int solver_show_working; #define solvep(x) do { if (solver_show_working) { printf x; } } while(0) #endif +#ifdef STANDALONE_PICTURE_GENERATOR +/* + * Dirty hack to enable the generator to construct a game ID which + * solves to a specified black-and-white bitmap. We define a global + * variable here which gives the desired colour of each square, and + * we arrange that the grid generator never merges squares of + * different colours. + * + * The bitmap as stored here is a simple int array (at these sizes + * it isn't worth doing fiddly bit-packing). picture[y*w+x] is 1 + * iff the pixel at (x,y) is intended to be black. + * + * (It might be nice to be able to specify some pixels as + * don't-care, to give the generator more leeway. But that might be + * fiddly.) + */ +static int *picture; +#endif + enum { COL_BACKGROUND, COL_WHITEBG, @@ -62,13 +81,13 @@ enum { COL_GRID, COL_EDGE, COL_ARROW, + COL_CURSOR, NCOLOURS }; #define DIFFLIST(A) \ - A(EASY,Easy,e) \ - A(HARD,Hard,h) \ - A(RECURSIVE,Recursive,r) + A(NORMAL,Normal,n) \ + A(UNREASONABLE,Unreasonable,u) #define ENUM(upper,title,lower) DIFF_ ## upper, #define TITLE(upper,title,lower) #title, @@ -135,16 +154,13 @@ struct game_state { /* make up some sensible default sizes */ -#define DEFAULT_PRESET 1 +#define DEFAULT_PRESET 0 static const game_params galaxies_presets[] = { - { 7, 7, DIFF_EASY }, - { 7, 7, DIFF_HARD }, - { 7, 7, DIFF_RECURSIVE }, - { 10, 10, DIFF_EASY }, - { 10, 10, DIFF_HARD }, - { 15, 15, DIFF_EASY }, - { 15, 15, DIFF_HARD }, + { 7, 7, DIFF_NORMAL }, + { 7, 7, DIFF_UNREASONABLE }, + { 10, 10, DIFF_NORMAL }, + { 15, 15, DIFF_NORMAL }, }; static int game_fetch_preset(int i, char **name, game_params **params) @@ -188,7 +204,7 @@ static game_params *dup_params(game_params *params) static void decode_params(game_params *params, char const *string) { params->h = params->w = atoi(string); - params->diff = DIFF_EASY; + params->diff = DIFF_NORMAL; while (*string && isdigit((unsigned char)*string)) string++; if (*string == 'x') { string++; @@ -198,7 +214,7 @@ static void decode_params(game_params *params, char const *string) if (*string == 'd') { int i; string++; - for (i = 0; i <= DIFF_RECURSIVE; i++) + for (i = 0; i <= DIFF_UNREASONABLE; i++) if (*string == galaxies_diffchars[i]) params->diff = i; if (*string) string++; @@ -266,7 +282,7 @@ static char *validate_params(game_params *params, int full) * and custom_params will never generate anything that isn't * within range. */ - assert(params->diff <= DIFF_RECURSIVE); + assert(params->diff <= DIFF_UNREASONABLE); return NULL; } @@ -298,12 +314,17 @@ static void remove_assoc(game_state *state, space *tile) { static void add_assoc(game_state *state, space *tile, space *dot) { remove_assoc(state, tile); +#ifdef STANDALONE_PICTURE_GENERATOR + if (picture) + assert(!picture[(tile->y/2) * state->w + (tile->x/2)] == + !(dot->flags & F_DOT_BLACK)); +#endif tile->flags |= F_TILE_ASSOC; tile->dotx = dot->x; tile->doty = dot->y; dot->nassoc++; - debug(("add_assoc sp %d %d --> dot %d,%d, new nassoc %d.\n", - tile->x, tile->y, dot->x, dot->y, dot->nassoc)); + /*debug(("add_assoc sp %d %d --> dot %d,%d, new nassoc %d.\n", + tile->x, tile->y, dot->x, dot->y, dot->nassoc));*/ } static struct space *sp2dot(game_state *state, int x, int y) @@ -315,6 +336,11 @@ static struct space *sp2dot(game_state *state, int x, int y) #define IS_VERTICAL_EDGE(x) ((x % 2) == 0) +static int game_can_format_as_text_now(game_params *params) +{ + return TRUE; +} + static char *game_text_format(game_state *state) { int maxlen = (state->sx+1)*state->sy, x, y; @@ -329,15 +355,17 @@ static char *game_text_format(game_state *state) sp = &SPACE(state, x, y); if (sp->flags & F_DOT) *p++ = 'o'; +#if 0 else if (sp->flags & (F_REACHABLE|F_MULTIPLE|F_MARK)) *p++ = (sp->flags & F_MULTIPLE) ? 'M' : (sp->flags & F_REACHABLE) ? 'R' : 'X'; +#endif else { switch (sp->type) { case s_tile: if (sp->flags & F_TILE_ASSOC) { space *dot = sp2dot(state, sp->x, sp->y); - if (dot->flags & F_DOT) + if (dot && dot->flags & F_DOT) *p++ = (dot->flags & F_DOT_BLACK) ? 'B' : 'W'; else *p++ = '?'; /* association with not-a-dot. */ @@ -587,85 +615,8 @@ static void tiles_from_edge(struct game_state *state, ts[1] = INGRID(state, xs[1], ys[1]) ? &SPACE(state, xs[1], ys[1]) : NULL; } - /* Check all tiles are associated with something, and all shapes - * are the correct symmetry (i.e. all tiles have a matching tile - * the opposite direction from the dot) */ -static int cccb_assoc(game_state *state, space *tile, void *unused) -{ - assert(tile->type == s_tile); - - if (!(tile->flags & F_TILE_ASSOC)) return -1; - return 0; -} - -struct dgs_ctx { - space *dot; - int ndots; -}; - -static int dgs_cb_check(game_state *state, space *tile, void *vctx) -{ - struct dgs_ctx *ctx = (struct dgs_ctx *)vctx; - space *opp; - - if (!(tile->flags & F_TILE_ASSOC)) return 0; - if (tile->dotx != ctx->dot->x || - tile->doty != ctx->dot->y) return 0; - - ctx->ndots += 1; - - /* Check this tile has an opposite associated with same dot. */ - opp = tile_opposite(state, tile); - if (!opp || !(opp->flags & F_TILE_ASSOC)) return -1; - if (opp->dotx != tile->dotx || opp->doty != tile->doty) return -1; - - /* Check its edges are correct */ - if (outline_tile_fordot(state, tile, 0) == 1) - return -1; /* there was some fixing required, we're wrong. */ - - return 0; -} - -static int dot_good_shape(game_state *state, space *dot, int mark) -{ - struct dgs_ctx ctx; - - ctx.dot = dot; - ctx.ndots = 0; - - if (mark) dot->flags &= ~F_GOOD; - - if (foreach_tile(state, dgs_cb_check, 0, &ctx) == -1) - return 0; - if (ctx.ndots == 0) return 0; /* no dots assoc. with tile. */ - - if (mark) { - debug(("marking dot %d,%d good tile.\n", dot->x, dot->y)); - dot->flags |= F_GOOD; - } - return 1; -} - -static int check_complete(game_state *state, int mark_errors) -{ - int i, complete = 1; - - /* Are all tiles associated? */ - if (foreach_tile(state, cccb_assoc, 0, NULL) == -1) - complete = 0; - - /* Check all dots are associated, and their tiles are well-formed. */ - for (i = 0; i < state->ndots; i++) { - if (!dot_good_shape(state, state->dots[i], mark_errors)) - complete = 0; - } - - /*if (complete == 1) printf("Complete!\n");*/ - return complete; -} - -/* Returns a move string for use by 'solve'; if you don't want the - * initial 'S;' use ret[2]. */ +/* Returns a move string for use by 'solve', including the initial + * 'S' if issolve is true. */ static char *diff_game(game_state *src, game_state *dest, int issolve) { int movelen = 0, movesize = 256, x, y, len; @@ -732,6 +683,9 @@ static int dot_is_possible(game_state *state, space *sp, int allow_assoc) { int bx = 0, by = 0, dx, dy; space *adj; +#ifdef STANDALONE_PICTURE_GENERATOR + int col = -1; +#endif switch (sp->type) { case s_tile: @@ -753,8 +707,24 @@ static int dot_is_possible(game_state *state, space *sp, int allow_assoc) adj = &SPACE(state, sp->x+dx, sp->y+dy); - if (!allow_assoc && (adj->flags & F_TILE_ASSOC)) - return 0; +#ifdef STANDALONE_PICTURE_GENERATOR + /* + * Check that all the squares we're looking at have the + * same colour. + */ + if (picture) { + if (adj->type == s_tile) { + int c = picture[(adj->y / 2) * state->w + (adj->x / 2)]; + if (col < 0) + col = c; + if (c != col) + return 0; /* colour mismatch */ + } + } +#endif + + if (!allow_assoc && (adj->flags & F_TILE_ASSOC)) + return 0; if (dx != 0 || dy != 0) { /* Other than our own square, no dots nearby. */ @@ -952,6 +922,19 @@ static int movedot_cb(game_state *state, space *tile, void *vctx) newopp->doty != md->olddot->y) return -1; /* associated, but wrong dot. */ } +#ifdef STANDALONE_PICTURE_GENERATOR + if (picture) { + /* + * Reject if either tile and the dot don't match in colour. + */ + if (!(picture[(tile->y/2) * state->w + (tile->x/2)]) ^ + !(md->newdot->flags & F_DOT_BLACK)) + return -1; + if (!(picture[(newopp->y/2) * state->w + (newopp->x/2)]) ^ + !(md->newdot->flags & F_DOT_BLACK)) + return -1; + } +#endif break; case MD_MOVE: @@ -987,12 +970,36 @@ static int dot_expand_or_move(game_state *state, space *dot, toadd[i]->x, toadd[i]->y)); assert(dot->flags & F_DOT); +#ifdef STANDALONE_PICTURE_GENERATOR + if (picture) { + /* + * Reject the expansion totally if any of the new tiles are + * the wrong colour. + */ + for (i = 0; i < nadd; i++) { + if (!(picture[(toadd[i]->y/2) * state->w + (toadd[i]->x/2)]) ^ + !(dot->flags & F_DOT_BLACK)) + return 0; + } + } +#endif + /* First off, could we just expand the current dot's tile to cover * the space(s) passed in and their opposites? */ for (i = 0; i < nadd; i++) { tileopp = space_opposite_dot(state, toadd[i], dot); if (!tileopp) goto noexpand; if (tileopp->flags & F_TILE_ASSOC) goto noexpand; +#ifdef STANDALONE_PICTURE_GENERATOR + if (picture) { + /* + * The opposite tiles have to be the right colour as well. + */ + if (!(picture[(tileopp->y/2) * state->w + (tileopp->x/2)]) ^ + !(dot->flags & F_DOT_BLACK)) + goto noexpand; + } +#endif } /* OK, all spaces have valid empty opposites: associate spaces and * opposites with our dot. */ @@ -1010,7 +1017,7 @@ static int dot_expand_or_move(game_state *state, space *dot, noexpand: /* Otherwise, try to move dot so as to encompass given spaces: */ - /* first, alculate the 'centre of gravity' of the new dot. */ + /* first, calculate the 'centre of gravity' of the new dot. */ nnew = dot->nassoc + nadd; /* number of tiles assoc. with new dot. */ cx = dot->x * dot->nassoc; cy = dot->y * dot->nassoc; @@ -1050,6 +1057,13 @@ noexpand: dot->x, dot->y)); return 0; } +#ifdef STANDALONE_PICTURE_GENERATOR + if (picture) { + if (!(picture[(tileopp->y/2) * state->w + (tileopp->x/2)]) ^ + !(dot->flags & F_DOT_BLACK)) + return 0; + } +#endif } /* If we've got here, we're ok. First, associate all of 'toadd' @@ -1064,8 +1078,16 @@ noexpand: /* Finally, move the dot and fix up all the old associations. */ debug(("Moving dot at %d,%d to %d,%d\n", dot->x, dot->y, md.newdot->x, md.newdot->y)); - remove_dot(dot); - add_dot(md.newdot); + { +#ifdef STANDALONE_PICTURE_GENERATOR + int f = dot->flags & F_DOT_BLACK; +#endif + remove_dot(dot); + add_dot(md.newdot); +#ifdef STANDALONE_PICTURE_GENERATOR + md.newdot->flags |= f; +#endif + } md.op = MD_MOVE; ret = foreach_tile(state, movedot_cb, 0, &md); @@ -1192,6 +1214,12 @@ static void generate_pass(game_state *state, random_state *rs, int *scratch, * if we can, and add one if so. */ if (dot_is_possible(state, sp, 0)) { add_dot(sp); +#ifdef STANDALONE_PICTURE_GENERATOR + if (picture) { + if (picture[(sp->y/2) * state->w + (sp->x/2)]) + sp->flags |= F_DOT_BLACK; + } +#endif ret = solver_obvious_dot(state, sp); assert(ret != -1); debug(("Added dot (and obvious associations) at %d,%d\n", @@ -1202,6 +1230,7 @@ static void generate_pass(game_state *state, random_state *rs, int *scratch, dbg_state(state); } +static int check_complete(game_state *state, int *dsf, int *colours); static int solver_state(game_state *state, int maxdiff); static char *new_game_desc(game_params *params, random_state *rs, @@ -1210,7 +1239,7 @@ static char *new_game_desc(game_params *params, random_state *rs, game_state *state = blank_game(params->w, params->h), *copy; char *desc; int *scratch, sz = state->sx*state->sy, i; - int diff, ntries = 0; + int diff, ntries = 0, cc; /* Random list of squares to try and process, one-by-one. */ scratch = snewn(sz, int); @@ -1220,8 +1249,8 @@ generate: clear_game(state, 1); ntries++; - //generate_pass(state, rs, scratch, 10, GP_DOTS); - //generate_pass(state, rs, scratch, 100, 0); + /* generate_pass(state, rs, scratch, 10, GP_DOTS); */ + /* generate_pass(state, rs, scratch, 100, 0); */ generate_pass(state, rs, scratch, 100, GP_DOTS); game_update_dots(state); @@ -1234,6 +1263,12 @@ generate: } #endif + for (i = 0; i < state->sx*state->sy; i++) + if (state->grid[i].type == s_tile) + outline_tile_fordot(state, &state->grid[i], TRUE); + cc = check_complete(state, NULL, NULL); + assert(cc); + copy = dup_game(state); clear_game(copy, 0); dbg_state(copy); @@ -1242,8 +1277,182 @@ generate: assert(diff != DIFF_IMPOSSIBLE); if (diff != params->diff) { - if (ntries < MAXTRIES) goto generate; + /* + * We'll grudgingly accept a too-easy puzzle, but we must + * _not_ permit a too-hard one (one which the solver + * couldn't handle at all). + */ + if (diff > params->diff || + ntries < MAXTRIES) goto generate; + } + +#ifdef STANDALONE_PICTURE_GENERATOR + /* + * Postprocessing pass to prevent excessive numbers of adjacent + * singletons. Iterate over all edges in random shuffled order; + * for each edge that separates two regions, investigate + * whether removing that edge and merging the regions would + * still yield a valid and soluble puzzle. (The two regions + * must also be the same colour, of course.) If so, do it. + * + * This postprocessing pass is slow (due to repeated solver + * invocations), and seems to be unnecessary during normal + * unconstrained game generation. However, when generating a + * game under colour constraints, excessive singletons seem to + * turn up more often, so it's worth doing this. + */ + { + int *posns, nposns; + int i, j, newdiff; + game_state *copy2; + + nposns = params->w * (params->h+1) + params->h * (params->w+1); + posns = snewn(nposns, int); + for (i = j = 0; i < state->sx*state->sy; i++) + if (state->grid[i].type == s_edge) + posns[j++] = i; + assert(j == nposns); + + shuffle(posns, nposns, sizeof(*posns), rs); + + for (i = 0; i < nposns; i++) { + int x, y, x0, y0, x1, y1, cx, cy, cn, cx0, cy0, cx1, cy1, tx, ty; + space *s0, *s1, *ts, *d0, *d1, *dn; + int ok; + + /* Coordinates of edge space */ + x = posns[i] % state->sx; + y = posns[i] / state->sx; + + /* Coordinates of square spaces on either side of edge */ + x0 = ((x+1) & ~1) - 1; /* round down to next odd number */ + y0 = ((y+1) & ~1) - 1; + x1 = 2*x-x0; /* and reflect about x to get x1 */ + y1 = 2*y-y0; + + if (!INGRID(state, x0, y0) || !INGRID(state, x1, y1)) + continue; /* outermost edge of grid */ + s0 = &SPACE(state, x0, y0); + s1 = &SPACE(state, x1, y1); + assert(s0->type == s_tile && s1->type == s_tile); + + if (s0->dotx == s1->dotx && s0->doty == s1->doty) + continue; /* tiles _already_ owned by same dot */ + + d0 = &SPACE(state, s0->dotx, s0->doty); + d1 = &SPACE(state, s1->dotx, s1->doty); + + if ((d0->flags ^ d1->flags) & F_DOT_BLACK) + continue; /* different colours: cannot merge */ + + /* + * Work out where the centre of gravity of the new + * region would be. + */ + cx = d0->nassoc * d0->x + d1->nassoc * d1->x; + cy = d0->nassoc * d0->y + d1->nassoc * d1->y; + cn = d0->nassoc + d1->nassoc; + if (cx % cn || cy % cn) + continue; /* CoG not at integer coordinates */ + cx /= cn; + cy /= cn; + assert(INUI(state, cx, cy)); + + /* + * Ensure that the CoG would actually be _in_ the new + * region, by verifying that all its surrounding tiles + * belong to one or other of our two dots. + */ + cx0 = ((cx+1) & ~1) - 1; /* round down to next odd number */ + cy0 = ((cy+1) & ~1) - 1; + cx1 = 2*cx-cx0; /* and reflect about cx to get cx1 */ + cy1 = 2*cy-cy0; + ok = TRUE; + for (ty = cy0; ty <= cy1; ty += 2) + for (tx = cx0; tx <= cx1; tx += 2) { + ts = &SPACE(state, tx, ty); + assert(ts->type == s_tile); + if ((ts->dotx != d0->x || ts->doty != d0->y) && + (ts->dotx != d1->x || ts->doty != d1->y)) + ok = FALSE; + } + if (!ok) + continue; + + /* + * Verify that for every tile in either source region, + * that tile's image in the new CoG is also in one of + * the two source regions. + */ + for (ty = 1; ty < state->sy; ty += 2) { + for (tx = 1; tx < state->sx; tx += 2) { + int tx1, ty1; + + ts = &SPACE(state, tx, ty); + assert(ts->type == s_tile); + if ((ts->dotx != d0->x || ts->doty != d0->y) && + (ts->dotx != d1->x || ts->doty != d1->y)) + continue; /* not part of these tiles anyway */ + tx1 = 2*cx-tx; + ty1 = 2*cy-ty; + if (!INGRID(state, tx1, ty1)) { + ok = FALSE; + break; + } + ts = &SPACE(state, cx+cx-tx, cy+cy-ty); + if ((ts->dotx != d0->x || ts->doty != d0->y) && + (ts->dotx != d1->x || ts->doty != d1->y)) { + ok = FALSE; + break; + } + } + if (!ok) + break; + } + if (!ok) + continue; + + /* + * Now we're clear to attempt the merge. We take a copy + * of the game state first, so we can revert it easily + * if the resulting puzzle turns out to have become + * insoluble. + */ + copy2 = dup_game(state); + + remove_dot(d0); + remove_dot(d1); + dn = &SPACE(state, cx, cy); + add_dot(dn); + dn->flags |= (d0->flags & F_DOT_BLACK); + for (ty = 1; ty < state->sy; ty += 2) { + for (tx = 1; tx < state->sx; tx += 2) { + ts = &SPACE(state, tx, ty); + assert(ts->type == s_tile); + if ((ts->dotx != d0->x || ts->doty != d0->y) && + (ts->dotx != d1->x || ts->doty != d1->y)) + continue; /* not part of these tiles anyway */ + add_assoc(state, ts, dn); + } + } + + copy = dup_game(state); + clear_game(copy, 0); + dbg_state(copy); + newdiff = solver_state(copy, params->diff); + free_game(copy); + if (diff == newdiff) { + /* Still just as soluble. Let the merge stand. */ + free_game(copy2); + } else { + /* Became insoluble. Revert. */ + free_game(state); + state = copy2; + } + } + sfree(posns); } +#endif desc = encode_game(state); #ifndef STANDALONE_SOLVER @@ -1915,7 +2124,7 @@ static int solver_recurse(game_state *state, int maxdiff) else { /* precisely one solution */ if (diff == DIFF_IMPOSSIBLE) - diff = DIFF_RECURSIVE; + diff = DIFF_UNREASONABLE; else diff = DIFF_AMBIGUOUS; } @@ -1941,7 +2150,14 @@ static int solver_recurse(game_state *state, int maxdiff) static int solver_state(game_state *state, int maxdiff) { solver_ctx *sctx = new_solver(state); - int ret, diff = DIFF_EASY; + int ret, diff = DIFF_NORMAL; + +#ifdef STANDALONE_PICTURE_GENERATOR + /* hack, hack: set picture to NULL during solving so that add_assoc + * won't complain when we attempt recursive guessing and guess wrong */ + int *savepic = picture; + picture = NULL; +#endif ret = solver_obvious(state); if (ret < 0) { @@ -1958,21 +2174,16 @@ static int solver_state(game_state *state, int maxdiff) cont: ret = foreach_edge(state, solver_lines_opposite_cb, IMPOSSIBLE_QUITS, sctx); - CHECKRET(DIFF_EASY); + CHECKRET(DIFF_NORMAL); ret = foreach_tile(state, solver_spaces_oneposs_cb, IMPOSSIBLE_QUITS, sctx); - CHECKRET(DIFF_EASY); - - /* more easy stuff? */ - - if (maxdiff <= DIFF_EASY) - break; + CHECKRET(DIFF_NORMAL); ret = solver_expand_dots(state, sctx); - CHECKRET(DIFF_HARD); + CHECKRET(DIFF_NORMAL); - if (maxdiff <= DIFF_HARD) + if (maxdiff <= DIFF_NORMAL) break; /* harder still? */ @@ -1981,18 +2192,22 @@ cont: break; } - if (check_complete(state, 0)) goto got_result; + if (check_complete(state, NULL, NULL)) goto got_result; - diff = (maxdiff >= DIFF_RECURSIVE) ? + diff = (maxdiff >= DIFF_UNREASONABLE) ? solver_recurse(state, maxdiff) : DIFF_UNFINISHED; got_result: free_solver(sctx); #ifndef STANDALONE_SOLVER - debug(("solver_state ends:\n")); + debug(("solver_state ends, diff %s:\n", galaxies_diffnames[diff])); dbg_state(state); #endif +#ifdef STANDALONE_PICTURE_GENERATOR + picture = savepic; +#endif + return diff; } @@ -2006,7 +2221,7 @@ static char *solve_game(game_state *state, game_state *currstate, int diff; tosolve = dup_game(currstate); - diff = solver_state(tosolve, DIFF_RECURSIVE); + diff = solver_state(tosolve, DIFF_UNREASONABLE); if (diff != DIFF_UNFINISHED && diff != DIFF_IMPOSSIBLE) { debug(("solve_game solved with current state.\n")); goto solved; @@ -2014,7 +2229,7 @@ static char *solve_game(game_state *state, game_state *currstate, free_game(tosolve); tosolve = dup_game(state); - diff = solver_state(tosolve, DIFF_RECURSIVE); + diff = solver_state(tosolve, DIFF_UNREASONABLE); if (diff != DIFF_UNFINISHED && diff != DIFF_IMPOSSIBLE) { debug(("solve_game solved with original state.\n")); goto solved; @@ -2045,12 +2260,15 @@ struct game_ui { int dx, dy; /* pixel coords of drag pos. */ int dotx, doty; /* grid coords of dot we're dragging from. */ int srcx, srcy; /* grid coords of drag start */ + int cur_x, cur_y, cur_visible; }; static game_ui *new_ui(game_state *state) { game_ui *ui = snew(game_ui); ui->dragging = FALSE; + ui->cur_x = ui->cur_y = 1; + ui->cur_visible = 0; return ui; } @@ -2078,7 +2296,7 @@ static void game_changed_state(game_ui *ui, game_state *oldstate, #define PREFERRED_TILE_SIZE 32 #define TILE_SIZE (ds->tilesize) #define DOT_SIZE (TILE_SIZE / 4) -#define EDGE_THICKNESS (TILE_SIZE / 16) +#define EDGE_THICKNESS (max(TILE_SIZE / 16, 2)) #define BORDER TILE_SIZE #define COORD(x) ( (x) * TILE_SIZE + BORDER ) @@ -2088,6 +2306,8 @@ static void game_changed_state(game_ui *ui, game_state *oldstate, #define DRAW_WIDTH (BORDER * 2 + ds->w * TILE_SIZE) #define DRAW_HEIGHT (BORDER * 2 + ds->h * TILE_SIZE) +#define CURSOR_SIZE DOT_SIZE + struct game_drawstate { int started; int w, h; @@ -2099,6 +2319,9 @@ struct game_drawstate { int dragging, dragx, dragy; int *colour_scratch; + + int cx, cy, cur_visible; + blitter *cur_bl; }; #define CORNER_TOLERANCE 0.15F @@ -2146,7 +2369,7 @@ static void coord_round_to_edge(float x, float y, int *xr, int *yr) #endif #ifdef EDITOR -static char *interpret_move(game_state *state, game_ui *ui, game_drawstate *ds, +static char *interpret_move(game_state *state, game_ui *ui, const game_drawstate *ds, int x, int y, int button) { char buf[80]; @@ -2163,7 +2386,7 @@ static char *interpret_move(game_state *state, game_ui *ui, game_drawstate *ds, if (button == 'S' || button == 's') { char *ret; game_state *tmp = dup_game(state); - state->cdiff = solver_state(tmp, DIFF_RECURSIVE-1); + state->cdiff = solver_state(tmp, DIFF_UNREASONABLE-1); ret = diff_game(state, tmp, 0); free_game(tmp); return ret; @@ -2181,7 +2404,7 @@ static char *interpret_move(game_state *state, game_ui *ui, game_drawstate *ds, return NULL; } #else -static char *interpret_move(game_state *state, game_ui *ui, game_drawstate *ds, +static char *interpret_move(game_state *state, game_ui *ui, const game_drawstate *ds, int x, int y, int button) { /* UI operations (play mode): @@ -2196,24 +2419,23 @@ static char *interpret_move(game_state *state, game_ui *ui, game_drawstate *ds, * Add or remove dot (left-click) */ char buf[80]; - const char *sep; + const char *sep = ""; int px, py; struct space *sp, *dot; - if (button == 'H' || button == 'h' || - button == 'S' || button == 's') { + buf[0] = '\0'; + + if (button == 'H' || button == 'h') { char *ret; game_state *tmp = dup_game(state); - if (button == 'H' || button == 'h') - solver_obvious(tmp); - else - solver_state(tmp, DIFF_RECURSIVE-1); + solver_obvious(tmp); ret = diff_game(state, tmp, 0); free_game(tmp); return ret; } if (button == LEFT_BUTTON) { + ui->cur_visible = 0; coord_round_to_edge(FROMCOORD((float)x), FROMCOORD((float)y), &px, &py); @@ -2228,8 +2450,10 @@ static char *interpret_move(game_state *state, game_ui *ui, game_drawstate *ds, } else if (button == RIGHT_BUTTON) { int px1, py1; - px = 2*FROMCOORD((float)x) + 0.5; - py = 2*FROMCOORD((float)y) + 0.5; + ui->cur_visible = 0; + + px = (int)(2*FROMCOORD((float)x) + 0.5); + py = (int)(2*FROMCOORD((float)y) + 0.5); dot = NULL; @@ -2240,7 +2464,7 @@ static char *interpret_move(game_state *state, game_ui *ui, game_drawstate *ds, for (py1 = py-1; py1 <= py+1; py1++) for (px1 = px-1; px1 <= px+1; px1++) { if (px1 >= 0 && px1 < state->sx && - py1 >= 0 && py1 < state->sx && + py1 >= 0 && py1 < state->sy && x >= SCOORD(px1-1) && x < SCOORD(px1+1) && y >= SCOORD(py1-1) && y < SCOORD(py1+1) && SPACE(state, px1, py1).flags & F_DOT) { @@ -2248,8 +2472,8 @@ static char *interpret_move(game_state *state, game_ui *ui, game_drawstate *ds, * Found a dot. Begin a drag from it. */ dot = &SPACE(state, px1, py1); - ui->srcx = px; - ui->srcy = py; + ui->srcx = px1; + ui->srcy = py1; goto done; /* multi-level break */ } } @@ -2261,7 +2485,7 @@ static char *interpret_move(game_state *state, game_ui *ui, game_drawstate *ds, if (!dot) { px = 2*FROMCOORD(x+TILE_SIZE) - 1; py = 2*FROMCOORD(y+TILE_SIZE) - 1; - if (px >= 0 && px < state->sx && py >= 0 && py < state->sx) { + if (px >= 0 && px < state->sx && py >= 0 && py < state->sy) { sp = &SPACE(state, px, py); if (sp->flags & F_TILE_ASSOC) { dot = &SPACE(state, sp->dotx, sp->doty); @@ -2304,9 +2528,6 @@ static char *interpret_move(game_state *state, game_ui *ui, game_drawstate *ds, if (px == ui->srcx && py == ui->srcy) return ""; - sep = ""; - buf[0] = '\0'; - /* * Otherwise, we remove the arrow from its starting * square if we didn't start from a dot... @@ -2333,13 +2554,63 @@ static char *interpret_move(game_state *state, game_ui *ui, game_drawstate *ds, return dupstr(buf); else return ""; + } 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; + if (ui->cur_y < 1) ui->cur_y = 1; + ui->cur_visible = 1; + if (ui->dragging) { + ui->dx = SCOORD(ui->cur_x); + ui->dy = SCOORD(ui->cur_y); + } + return ""; + } else if (IS_CURSOR_SELECT(button)) { + if (!ui->cur_visible) { + ui->cur_visible = 1; + return ""; + } + sp = &SPACE(state, ui->cur_x, ui->cur_y); + if (ui->dragging) { + ui->dragging = FALSE; + + if ((ui->srcx != ui->dotx || ui->srcy != ui->doty) && + SPACE(state, ui->srcx, ui->srcy).flags & F_TILE_ASSOC) { + sprintf(buf, "%sU%d,%d", sep, ui->srcx, ui->srcy); + sep = ";"; + } + if (sp->type == s_tile && !(sp->flags & F_DOT) && !(sp->flags & F_TILE_ASSOC)) { + sprintf(buf + strlen(buf), "%sA%d,%d,%d,%d", + sep, ui->cur_x, ui->cur_y, ui->dotx, ui->doty); + } + return dupstr(buf); + } else if (sp->flags & F_DOT) { + ui->dragging = TRUE; + ui->dx = SCOORD(ui->cur_x); + ui->dy = SCOORD(ui->cur_y); + ui->dotx = ui->srcx = ui->cur_x; + ui->doty = ui->srcy = ui->cur_y; + return ""; + } else if (sp->flags & F_TILE_ASSOC) { + assert(sp->type == s_tile); + ui->dragging = TRUE; + ui->dx = SCOORD(ui->cur_x); + ui->dy = SCOORD(ui->cur_y); + ui->dotx = sp->dotx; + ui->doty = sp->doty; + ui->srcx = ui->cur_x; + ui->srcy = ui->cur_y; + return ""; + } else if (sp->type == s_edge) { + sprintf(buf, "E%d,%d", ui->cur_x, ui->cur_y); + return dupstr(buf); + } } return NULL; } #endif -static int check_complete_in_play(game_state *state, int *dsf, int *colours) +static int check_complete(game_state *state, int *dsf, int *colours) { int w = state->w, h = state->h; int x, y, i, ret; @@ -2418,10 +2689,16 @@ static int check_complete_in_play(game_state *state, int *dsf, int *colours) */ for (i = 0; i < w*h; i++) if (sqdata[i].valid) { - sqdata[i].cx = sqdata[i].minx + sqdata[i].maxx + 1; - sqdata[i].cy = sqdata[i].miny + sqdata[i].maxy + 1; + int cx, cy; + cx = sqdata[i].cx = sqdata[i].minx + sqdata[i].maxx + 1; + cy = sqdata[i].cy = sqdata[i].miny + sqdata[i].maxy + 1; if (!(SPACE(state, sqdata[i].cx, sqdata[i].cy).flags & F_DOT)) sqdata[i].valid = FALSE; /* no dot at centre of symmetry */ + if (dsf_canonify(dsf, (cy-1)/2*w+(cx-1)/2) != i || + dsf_canonify(dsf, (cy)/2*w+(cx-1)/2) != i || + dsf_canonify(dsf, (cy-1)/2*w+(cx)/2) != i || + dsf_canonify(dsf, (cy)/2*w+(cx)/2) != i) + sqdata[i].valid = FALSE; /* dot at cx,cy isn't ours */ if (SPACE(state, sqdata[i].cx, sqdata[i].cy).flags & F_DOT_BLACK) sqdata[i].colour = 2; else @@ -2597,6 +2874,7 @@ static game_state *execute_move(game_state *state, char *move) #endif } else if (c == 'S') { move++; + ret->used_solve = 1; } else goto badmove; @@ -2605,7 +2883,7 @@ static game_state *execute_move(game_state *state, char *move) else if (*move) goto badmove; } - if (check_complete_in_play(ret, NULL, NULL)) + if (check_complete(ret, NULL, NULL)) ret->completed = 1; return ret; @@ -2651,6 +2929,9 @@ static void game_set_size(drawing *dr, game_drawstate *ds, assert(!ds->bl); ds->bl = blitter_new(dr, TILE_SIZE, TILE_SIZE); + + assert(!ds->cur_bl); + ds->cur_bl = blitter_new(dr, TILE_SIZE, TILE_SIZE); } static float *game_colours(frontend *fe, int *ncolours) @@ -2696,10 +2977,13 @@ static float *game_colours(frontend *fe, int *ncolours) /* tinge the edit background to bluey */ ret[COL_BACKGROUND * 3 + 0] = ret[COL_BACKGROUND * 3 + 0] * 0.8F; ret[COL_BACKGROUND * 3 + 1] = ret[COL_BACKGROUND * 3 + 0] * 0.8F; - ret[COL_BACKGROUND * 3 + 2] = ret[COL_BACKGROUND * 3 + 0] * 1.4F; - if (ret[COL_BACKGROUND * 3 + 2] > 1.0F) ret[COL_BACKGROUND * 3 + 2] = 1.0F; + ret[COL_BACKGROUND * 3 + 2] = min(ret[COL_BACKGROUND * 3 + 0] * 1.4F, 1.0F); #endif + ret[COL_CURSOR * 3 + 0] = min(ret[COL_BACKGROUND * 3 + 0] * 1.4F, 1.0F); + ret[COL_CURSOR * 3 + 1] = ret[COL_BACKGROUND * 3 + 0] * 0.8F; + ret[COL_CURSOR * 3 + 2] = ret[COL_BACKGROUND * 3 + 0] * 0.8F; + *ncolours = NCOLOURS; return ret; } @@ -2725,11 +3009,16 @@ static game_drawstate *game_new_drawstate(drawing *dr, game_state *state) ds->colour_scratch = snewn(ds->w * ds->h, int); + ds->cur_bl = NULL; + ds->cx = ds->cy = 0; + ds->cur_visible = 0; + return ds; } static void game_free_drawstate(drawing *dr, game_drawstate *ds) { + if (ds->cur_bl) blitter_free(dr, ds->cur_bl); sfree(ds->colour_scratch); if (ds->bl) blitter_free(dr, ds->bl); sfree(ds->dx); @@ -2749,7 +3038,8 @@ static void game_free_drawstate(drawing *dr, game_drawstate *ds) #define DRAW_WHITE 0x0100 #define DRAW_BLACK 0x0200 #define DRAW_ARROW 0x0400 -#define DOT_SHIFT_C 11 +#define DRAW_CURSOR 0x0800 +#define DOT_SHIFT_C 12 #define DOT_SHIFT_M 2 #define DOT_WHITE 1UL #define DOT_BLACK 2UL @@ -2759,19 +3049,19 @@ static void game_free_drawstate(drawing *dr, game_drawstate *ds) * (ddx,ddy). (I.e. pointing at the point (cx+ddx, cy+ddy). */ static void draw_arrow(drawing *dr, game_drawstate *ds, - int cx, int cy, int ddx, int ddy) + int cx, int cy, int ddx, int ddy, int col) { - float vlen = sqrt(ddx*ddx+ddy*ddy); + float vlen = (float)sqrt(ddx*ddx+ddy*ddy); float xdx = ddx/vlen, xdy = ddy/vlen; float ydx = -xdy, ydy = xdx; - int e1x = cx + xdx*TILE_SIZE/3, e1y = cy + xdy*TILE_SIZE/3; - int e2x = cx - xdx*TILE_SIZE/3, e2y = cy - xdy*TILE_SIZE/3; - int adx = (ydx-xdx)*TILE_SIZE/8, ady = (ydy-xdy)*TILE_SIZE/8; - int adx2 = (-ydx-xdx)*TILE_SIZE/8, ady2 = (-ydy-xdy)*TILE_SIZE/8; + int e1x = cx + (int)(xdx*TILE_SIZE/3), e1y = cy + (int)(xdy*TILE_SIZE/3); + int e2x = cx - (int)(xdx*TILE_SIZE/3), e2y = cy - (int)(xdy*TILE_SIZE/3); + int adx = (int)((ydx-xdx)*TILE_SIZE/8), ady = (int)((ydy-xdy)*TILE_SIZE/8); + int adx2 = (int)((-ydx-xdx)*TILE_SIZE/8), ady2 = (int)((-ydy-xdy)*TILE_SIZE/8); - draw_line(dr, e1x, e1y, e2x, e2y, COL_ARROW); - draw_line(dr, e1x, e1y, e1x+adx, e1y+ady, COL_ARROW); - draw_line(dr, e1x, e1y, e1x+adx2, e1y+ady2, COL_ARROW); + draw_line(dr, e1x, e1y, e2x, e2y, col); + draw_line(dr, e1x, e1y, e1x+adx, e1y+ady, col); + draw_line(dr, e1x, e1y, e1x+adx2, e1y+ady2, col); } static void draw_square(drawing *dr, game_drawstate *ds, int x, int y, @@ -2798,10 +3088,17 @@ static void draw_square(drawing *dr, game_drawstate *ds, int x, int y, draw_rect(dr, lx, ly, TILE_SIZE, 1, gridcol); /* - * Draw the arrow. + * Draw the arrow, if present, or the cursor, if here. */ if (flags & DRAW_ARROW) - draw_arrow(dr, ds, lx + TILE_SIZE/2, ly + TILE_SIZE/2, ddx, ddy); + draw_arrow(dr, ds, lx + TILE_SIZE/2, ly + TILE_SIZE/2, ddx, ddy, + (flags & DRAW_CURSOR) ? COL_CURSOR : COL_ARROW); + else if (flags & DRAW_CURSOR) + draw_rect_outline(dr, + lx + TILE_SIZE/2 - CURSOR_SIZE, + ly + TILE_SIZE/2 - CURSOR_SIZE, + 2*CURSOR_SIZE+1, 2*CURSOR_SIZE+1, + COL_CURSOR); /* * Draw the edges. @@ -2866,6 +3163,12 @@ static void game_redraw(drawing *dr, game_drawstate *ds, game_state *oldstate, draw_update(dr, ds->dragx, ds->dragy, TILE_SIZE, TILE_SIZE); ds->dragging = FALSE; } + if (ds->cur_visible) { + assert(ds->cur_bl); + blitter_load(dr, ds->cur_bl, ds->cx, ds->cy); + draw_update(dr, ds->cx, ds->cy, CURSOR_SIZE*2+1, CURSOR_SIZE*2+1); + ds->cur_visible = FALSE; + } if (!ds->started) { draw_rect(dr, 0, 0, DRAW_WIDTH, DRAW_HEIGHT, COL_BACKGROUND); @@ -2876,7 +3179,7 @@ static void game_redraw(drawing *dr, game_drawstate *ds, game_state *oldstate, ds->started = TRUE; } - check_complete_in_play(state, NULL, ds->colour_scratch); + check_complete(state, NULL, ds->colour_scratch); for (y = 0; y < h; y++) for (x = 0; x < w; x++) { @@ -2959,6 +3262,15 @@ static void game_redraw(drawing *dr, game_drawstate *ds, game_state *oldstate, } /* + * Now work out if we have to draw a cursor for this square; + * cursors-on-lines are taken care of below. + */ + if (ui->cur_visible && + ui->cur_x == x*2+1 && ui->cur_y == y*2+1 && + !(SPACE(state, x*2+1, y*2+1).flags & F_DOT)) + flags |= DRAW_CURSOR; + + /* * Now we have everything we're going to need. Draw the * square. */ @@ -2972,6 +3284,33 @@ static void game_redraw(drawing *dr, game_drawstate *ds, game_state *oldstate, } } + /* + * Draw a cursor. This secondary blitter is much less invasive than trying + * to fix up all of the rest of the code with sufficient flags to be able to + * display this sensibly. + */ + if (ui->cur_visible) { + space *sp = &SPACE(state, ui->cur_x, ui->cur_y); + ds->cur_visible = TRUE; + ds->cx = SCOORD(ui->cur_x) - CURSOR_SIZE; + ds->cy = SCOORD(ui->cur_y) - CURSOR_SIZE; + blitter_save(dr, ds->cur_bl, ds->cx, ds->cy); + if (sp->flags & F_DOT) { + /* draw a red dot (over the top of whatever would be there already) */ + draw_circle(dr, SCOORD(ui->cur_x), SCOORD(ui->cur_y), DOT_SIZE, + COL_CURSOR, COL_BLACKDOT); + } else if (sp->type != s_tile) { + /* draw an edge/vertex square; tile cursors are dealt with above. */ + int dx = (ui->cur_x % 2) ? CURSOR_SIZE : CURSOR_SIZE/3; + int dy = (ui->cur_y % 2) ? CURSOR_SIZE : CURSOR_SIZE/3; + int x1 = SCOORD(ui->cur_x)-dx, y1 = SCOORD(ui->cur_y)-dy; + int xs = dx*2+1, ys = dy*2+1; + + draw_rect(dr, x1, y1, xs, ys, COL_CURSOR); + } + draw_update(dr, ds->cx, ds->cy, CURSOR_SIZE*2+1, CURSOR_SIZE*2+1); + } + if (ui->dragging) { ds->dragging = TRUE; ds->dragx = ui->dx - TILE_SIZE/2; @@ -2979,7 +3318,7 @@ static void game_redraw(drawing *dr, game_drawstate *ds, game_state *oldstate, blitter_save(dr, ds->bl, ds->dragx, ds->dragy); draw_arrow(dr, ds, ui->dx, ui->dy, SCOORD(ui->dotx) - ui->dx, - SCOORD(ui->doty) - ui->dy); + SCOORD(ui->doty) - ui->dy, COL_ARROW); } #ifdef EDITOR { @@ -3009,6 +3348,11 @@ static float game_flash_length(game_state *oldstate, game_state *newstate, return 0.0F; } +static int game_status(game_state *state) +{ + return state->completed ? +1 : 0; +} + static int game_timing_state(game_state *state, game_ui *ui) { return TRUE; @@ -3041,16 +3385,16 @@ static void game_print(drawing *dr, game_state *state, int sz) game_drawstate ads, *ds = &ads; ds->tilesize = sz; - white = print_grey_colour(dr, HATCH_CLEAR, 1.0F); - black = print_grey_colour(dr, HATCH_SOLID, 0.0F); - blackish = print_grey_colour(dr, HATCH_X, 0.5F); + white = print_mono_colour(dr, 1); + black = print_mono_colour(dr, 0); + blackish = print_hatched_colour(dr, HATCH_X); /* * Get the completion information. */ dsf = snewn(w * h, int); colours = snewn(w * h, int); - check_complete_in_play(state, dsf, colours); + check_complete(state, dsf, colours); /* * Draw the grid. @@ -3179,7 +3523,7 @@ static void game_print(drawing *dr, game_state *state, int sz) for (y = 0; y <= 2*h; y++) for (x = 0; x <= 2*w; x++) if (SPACE(state, x, y).flags & F_DOT) { - draw_circle(dr, COORD(x/2.0), COORD(y/2.0), DOT_SIZE, + draw_circle(dr, (int)COORD(x/2.0), (int)COORD(y/2.0), DOT_SIZE, (SPACE(state, x, y).flags & F_DOT_BLACK ? black : white), black); } @@ -3214,7 +3558,7 @@ const struct game thegame = { #else TRUE, solve_game, #endif - TRUE, game_text_format, + TRUE, game_can_format_as_text_now, game_text_format, new_ui, free_ui, encode_ui, @@ -3229,15 +3573,16 @@ const struct game thegame = { game_redraw, game_anim_length, game_flash_length, + game_status, #ifdef EDITOR FALSE, FALSE, NULL, NULL, TRUE, /* wants_statusbar */ #else - TRUE, TRUE, game_print_size, game_print, + TRUE, FALSE, game_print_size, game_print, FALSE, /* wants_statusbar */ #endif FALSE, game_timing_state, - 0, /* flags */ + REQUIRE_RBUTTON, /* flags */ }; #ifdef STANDALONE_SOLVER @@ -3277,7 +3622,7 @@ static int gen(game_params *p, random_state *rs, int debug) state = new_game(NULL, p, desc); dump_state(state); - diff = solver_state(state, DIFF_RECURSIVE); + diff = solver_state(state, DIFF_UNREASONABLE); printf("Generated %s game %dx%d:%s\n", galaxies_diffnames[diff], p->w, p->h, desc); dump_state(state); @@ -3378,7 +3723,7 @@ int main(int argc, char **argv) while (1) { p->w = random_upto(rs, 15) + 3; p->h = random_upto(rs, 15) + 3; - p->diff = random_upto(rs, DIFF_RECURSIVE); + p->diff = random_upto(rs, DIFF_UNREASONABLE); diff = gen(p, rs, 0); } return 0; @@ -3400,7 +3745,7 @@ int main(int argc, char **argv) exit(1); } s = new_game(NULL, p, desc); - diff = solver_state(s, DIFF_RECURSIVE); + diff = solver_state(s, DIFF_UNREASONABLE); dump_state(s); printf("Puzzle is %s.\n", galaxies_diffnames[diff]); free_game(s); @@ -3413,4 +3758,146 @@ int main(int argc, char **argv) #endif +#ifdef STANDALONE_PICTURE_GENERATOR + +/* + * Main program for the standalone picture generator. To use it, + * simply provide it with an XBM-format bitmap file (note XBM, not + * XPM) on standard input, and it will output a game ID in return. + * For example: + * + * $ ./galaxiespicture < badly-drawn-cat.xbm + * 11x11:eloMBLzFeEzLNMWifhaWYdDbixCymBbBMLoDdewGg + * + * If you want a puzzle with a non-standard difficulty level, pass + * a partial parameters string as a command-line argument (e.g. + * `./galaxiespicture du < foo.xbm', where `du' is the same suffix + * which if it appeared in a random-seed game ID would set the + * difficulty level to Unreasonable). However, be aware that if the + * generator fails to produce an adequately difficult puzzle too + * many times then it will give up and return an easier one (just + * as it does during normal GUI play). To be sure you really have + * the difficulty you asked for, use galaxiessolver to + * double-check. + * + * (Perhaps I ought to include an option to make this standalone + * generator carry on looping until it really does get the right + * difficulty. Hmmm.) + */ + +#include + +int main(int argc, char **argv) +{ + game_params *par; + char *params, *desc; + random_state *rs; + time_t seed = time(NULL); + char buf[4096]; + int i; + int x, y; + + par = default_params(); + if (argc > 1) + decode_params(par, argv[1]); /* get difficulty */ + par->w = par->h = -1; + + /* + * Now read an XBM file from standard input. This is simple and + * hacky and will do very little error detection, so don't feed + * it bogus data. + */ + picture = NULL; + x = y = 0; + while (fgets(buf, sizeof(buf), stdin)) { + buf[strcspn(buf, "\r\n")] = '\0'; + if (!strncmp(buf, "#define", 7)) { + /* + * Lines starting `#define' give the width and height. + */ + char *num = buf + strlen(buf); + char *symend; + + while (num > buf && isdigit((unsigned char)num[-1])) + num--; + symend = num; + while (symend > buf && isspace((unsigned char)symend[-1])) + symend--; + + if (symend-5 >= buf && !strncmp(symend-5, "width", 5)) + par->w = atoi(num); + else if (symend-6 >= buf && !strncmp(symend-6, "height", 6)) + par->h = atoi(num); + } else { + /* + * Otherwise, break the string up into words and take + * any word of the form `0x' plus hex digits to be a + * byte. + */ + char *p, *wordstart; + + if (!picture) { + if (par->w < 0 || par->h < 0) { + printf("failed to read width and height\n"); + return 1; + } + picture = snewn(par->w * par->h, int); + for (i = 0; i < par->w * par->h; i++) + picture[i] = -1; + } + + p = buf; + while (*p) { + while (*p && (*p == ',' || isspace((unsigned char)*p))) + p++; + wordstart = p; + while (*p && !(*p == ',' || *p == '}' || + isspace((unsigned char)*p))) + p++; + if (*p) + *p++ = '\0'; + + if (wordstart[0] == '0' && + (wordstart[1] == 'x' || wordstart[1] == 'X') && + !wordstart[2 + strspn(wordstart+2, + "0123456789abcdefABCDEF")]) { + unsigned long byte = strtoul(wordstart+2, NULL, 16); + for (i = 0; i < 8; i++) { + int bit = (byte >> i) & 1; + if (y < par->h && x < par->w) + picture[y * par->w + x] = bit; + x++; + } + + if (x >= par->w) { + x = 0; + y++; + } + } + } + } + } + + for (i = 0; i < par->w * par->h; i++) + if (picture[i] < 0) { + fprintf(stderr, "failed to read enough bitmap data\n"); + return 1; + } + + rs = random_new((void*)&seed, sizeof(time_t)); + + desc = new_game_desc(par, rs, NULL, FALSE); + params = encode_params(par, FALSE); + printf("%s:%s\n", params, desc); + + sfree(desc); + sfree(params); + free_params(par); + random_free(rs); + + return 0; +} + +#endif + /* vim: set shiftwidth=4 tabstop=8: */