X-Git-Url: https://git.distorted.org.uk/~mdw/sgt/puzzles/blobdiff_plain/821f9f32f616cda1802563fb9be2f44ba161dff2..HEAD:/midend.c diff --git a/midend.c b/midend.c index cc360b5..53dca21 100644 --- a/midend.c +++ b/midend.c @@ -31,7 +31,7 @@ struct midend { const game *ourgame; game_params **presets; - char **preset_names; + char **preset_names, **preset_encodings; int npresets, presetsize; /* @@ -102,10 +102,26 @@ midend *midend_new(frontend *fe, const game *ourgame, me->frontend = fe; me->ourgame = ourgame; - me->random = random_init(randseed, randseedsize); + me->random = random_new(randseed, randseedsize); me->nstates = me->statesize = me->statepos = 0; me->states = NULL; me->params = ourgame->default_params(); + /* + * Allow environment-based changing of the default settings by + * defining a variable along the lines of `NET_DEFAULT=25x25w' + * in which the value is an encoded parameter string. + */ + { + char buf[80], *e; + int j, k; + sprintf(buf, "%s_DEFAULT", me->ourgame->name); + for (j = k = 0; buf[j]; j++) + if (!isspace((unsigned char)buf[j])) + buf[k++] = toupper((unsigned char)buf[j]); + buf[k] = '\0'; + if ((e = getenv(buf)) != NULL) + me->ourgame->decode_params(me->params, e); + } me->curparams = NULL; me->desc = me->privdesc = NULL; me->seedstr = NULL; @@ -115,6 +131,7 @@ midend *midend_new(frontend *fe, const game *ourgame, me->oldstate = NULL; me->presets = NULL; me->preset_names = NULL; + me->preset_encodings = NULL; me->npresets = me->presetsize = 0; me->anim_time = me->anim_pos = 0.0F; me->flash_time = me->flash_pos = 0.0F; @@ -126,7 +143,7 @@ midend *midend_new(frontend *fe, const game *ourgame, me->elapsed = 0.0F; me->tilesize = me->winwidth = me->winheight = 0; if (drapi) - me->drawing = drawing_init(drapi, drhandle); + me->drawing = drawing_new(drapi, me, drhandle); else me->drawing = NULL; @@ -155,6 +172,20 @@ midend *midend_new(frontend *fe, const game *ourgame, return me; } +const game *midend_which_game(midend *me) +{ + return me->ourgame; +} + +static void midend_purge_states(midend *me) +{ + while (me->nstates > me->statepos) { + me->ourgame->free_game(me->states[--me->nstates].state); + if (me->states[me->nstates].movestr) + sfree(me->states[me->nstates].movestr); + } +} + static void midend_free_game(midend *me) { while (me->nstates > 0) { @@ -186,9 +217,11 @@ void midend_free(midend *me) for (i = 0; i < me->npresets; i++) { sfree(me->presets[i]); sfree(me->preset_names[i]); + sfree(me->preset_encodings[i]); } sfree(me->presets); sfree(me->preset_names); + sfree(me->preset_encodings); } if (me->ui) me->ourgame->free_ui(me->ui); @@ -212,7 +245,7 @@ static void midend_size_new_drawstate(midend *me) } } -void midend_size(midend *me, int *x, int *y, int expand) +void midend_size(midend *me, int *x, int *y, int user_size) { int min, max; int rx, ry; @@ -230,11 +263,14 @@ void midend_size(midend *me, int *x, int *y, int expand) /* * Find the tile size that best fits within the given space. If - * `expand' is TRUE, we must actually find the _largest_ such - * tile size; otherwise, we bound above at the game's preferred - * tile size. + * `user_size' is TRUE, we must actually find the _largest_ such + * tile size, in order to get as close to the user's explicit + * request as possible; otherwise, we bound above at the game's + * preferred tile size, so that the game gets what it wants + * provided that this doesn't break the constraint from the + * front-end (which is likely to be a screen size or similar). */ - if (expand) { + if (user_size) { max = 1; do { max *= 2; @@ -264,11 +300,16 @@ void midend_size(midend *me, int *x, int *y, int expand) */ me->tilesize = min; + if (user_size) + /* If the user requested a change in size, make it permanent. */ + me->preferred_tilesize = me->tilesize; midend_size_new_drawstate(me); *x = me->winwidth; *y = me->winheight; } +int midend_tilesize(midend *me) { return me->tilesize; } + void midend_set_params(midend *me, game_params *params) { me->ourgame->free_params(me->params); @@ -326,9 +367,9 @@ void midend_new_game(midend *me) char newseed[16]; int i; newseed[15] = '\0'; - newseed[0] = '1' + random_upto(me->random, 9); + newseed[0] = '1' + (char)random_upto(me->random, 9); for (i = 1; i < 15; i++) - newseed[i] = '0' + random_upto(me->random, 10); + newseed[i] = '0' + (char)random_upto(me->random, 10); sfree(me->seedstr); me->seedstr = dupstr(newseed); @@ -342,7 +383,7 @@ void midend_new_game(midend *me) sfree(me->aux_info); me->aux_info = NULL; - rs = random_init(me->seedstr, strlen(me->seedstr)); + rs = random_new(me->seedstr, strlen(me->seedstr)); /* * If this midend has been instantiated without providing a * drawing API, it is non-interactive. This means that it's @@ -356,8 +397,92 @@ void midend_new_game(midend *me) } ensure(me); + + /* + * It might seem a bit odd that we're using me->params to + * create the initial game state, rather than me->curparams + * which is better tailored to this specific game and which we + * always know. + * + * It's supposed to be an invariant in the midend that + * me->params and me->curparams differ in no aspect that is + * important after generation (i.e. after new_desc()). By + * deliberately passing the _less_ specific of these two + * parameter sets, we provoke play-time misbehaviour in the + * case where a game has failed to encode a play-time parameter + * in the non-full version of encode_params(). + */ me->states[me->nstates].state = me->ourgame->new_game(me, me->params, me->desc); + + /* + * As part of our commitment to self-testing, test the aux + * string to make sure nothing ghastly went wrong. + */ + if (me->ourgame->can_solve && me->aux_info) { + game_state *s; + char *msg, *movestr; + + msg = NULL; + movestr = me->ourgame->solve(me->states[0].state, + me->states[0].state, + me->aux_info, &msg); + assert(movestr && !msg); + s = me->ourgame->execute_move(me->states[0].state, movestr); + assert(s); + me->ourgame->free_game(s); + sfree(movestr); + } + + /* + * Soak test, enabled by setting _TESTSOLVE in the + * environment. This causes an immediate attempt to re-solve the + * game without benefit of aux_info. The effect is that (at least + * on Unix) you can run 'FOO_TESTSOLVE=1 foo --generate 10000 + * #12345' and it will generate a lot of game ids and + * instantly pass each one back to the solver. + * + * (It's worth putting in an explicit seed in any such test, so + * you can repeat it to diagnose a problem if one comes up!) + */ + { + char buf[80]; + int j, k; + static int doing_test_solve = -1; + if (doing_test_solve < 0) { + sprintf(buf, "%s_TESTSOLVE", me->ourgame->name); + for (j = k = 0; buf[j]; j++) + if (!isspace((unsigned char)buf[j])) + buf[k++] = toupper((unsigned char)buf[j]); + buf[k] = '\0'; + if (getenv(buf)) { + /* + * Since this is used for correctness testing, it's + * helpful to have a visual acknowledgment that the + * user hasn't mistyped the environment variable name. + */ + fprintf(stderr, "Running solver soak tests\n"); + doing_test_solve = TRUE; + } else { + doing_test_solve = FALSE; + } + } + if (doing_test_solve) { + game_state *s; + char *msg, *movestr; + + msg = NULL; + movestr = me->ourgame->solve(me->states[0].state, + me->states[0].state, + NULL, &msg); + assert(movestr && !msg); + s = me->ourgame->execute_move(me->states[0].state, movestr); + assert(s); + me->ourgame->free_game(s); + sfree(movestr); + } + } + me->states[me->nstates].movestr = NULL; me->states[me->nstates].movetype = NEWGAME; me->nstates++; @@ -373,6 +498,16 @@ void midend_new_game(midend *me) me->pressed_mouse_button = 0; } +int midend_can_undo(midend *me) +{ + return (me->statepos > 1); +} + +int midend_can_redo(midend *me) +{ + return (me->statepos < me->nstates); +} + static int midend_undo(midend *me) { if (me->statepos > 1) { @@ -465,8 +600,7 @@ void midend_restart_game(midend *me) * Now enter the restarted state as the next move. */ midend_stop_anim(me); - while (me->nstates > me->statepos) - me->ourgame->free_game(me->states[--me->nstates].state); + midend_purge_states(me); ensure(me); me->states[me->nstates].state = s; me->states[me->nstates].movestr = dupstr(me->desc); @@ -513,6 +647,9 @@ static int midend_really_process_key(midend *me, int x, int y, int button) midend_stop_anim(me); if (!midend_redo(me)) goto done; + } else if (button == '\x13' && me->ourgame->can_solve) { + if (midend_solve(me)) + goto done; } else if (button == 'q' || button == 'Q' || button == '\x11') { ret = 0; goto done; @@ -534,11 +671,11 @@ static int midend_really_process_key(midend *me, int x, int y, int button) * state has been updated and a redraw is called for. */ midend_redraw(me); + midend_set_timer(me); goto done; } else if (s) { midend_stop_anim(me); - while (me->nstates > me->statepos) - me->ourgame->free_game(me->states[--me->nstates].state); + midend_purge_states(me); ensure(me); assert(movestr != NULL); me->states[me->nstates].state = s; @@ -562,7 +699,7 @@ static int midend_really_process_key(midend *me, int x, int y, int button) * See if this move requires an animation. */ if (special(type) && !(type == SOLVE && - (me->ourgame->mouse_priorities & SOLVE_ANIMATES))) { + (me->ourgame->flags & SOLVE_ANIMATES))) { anim_time = 0; } else { anim_time = me->ourgame->anim_length(oldstate, @@ -657,6 +794,14 @@ int midend_process_key(midend *me, int x, int y, int button) * like a left click for the benefit of users of other * implementations. So the last of the above points is modified * in the presence of an (optional) button priority order. + * + * A further addition: we translate certain keyboard presses to + * cursor key 'select' buttons, so that a) frontends don't have + * to translate these themselves (like they do for CURSOR_UP etc), + * and b) individual games don't have to hard-code button presses + * of '\n' etc for keyboard-based cursors. The choice of buttons + * here could eventually be controlled by a runtime configuration + * option. */ if (IS_MOUSE_DRAG(button) || IS_MOUSE_RELEASE(button)) { if (me->pressed_mouse_button) { @@ -674,7 +819,7 @@ int midend_process_key(midend *me, int x, int y, int button) * If the new button has lower priority than the old one, * don't bother doing this. */ - if (me->ourgame->mouse_priorities & + if (me->ourgame->flags & BUTTON_BEATS(me->pressed_mouse_button, button)) return ret; /* just ignore it */ @@ -687,6 +832,23 @@ int midend_process_key(midend *me, int x, int y, int button) } /* + * Translate keyboard presses to cursor selection. + */ + if (button == '\n' || button == '\r') + button = CURSOR_SELECT; + if (button == ' ') + button = CURSOR_SELECT2; + + /* + * Normalise both backspace characters (8 and 127) to \b. Easier + * to do this once, here, than to require all front ends to + * carefully generate the same one - now each front end can + * generate whichever is easiest. + */ + if (button == '\177') + button = '\b'; + + /* * Now send on the event we originally received. */ ret = ret && midend_really_process_key(me, x, y, button); @@ -723,8 +885,21 @@ void midend_redraw(midend *me) } } +/* + * Nasty hacky function used to implement the --redo option in + * gtk.c. Only used for generating the puzzles' icons. + */ +void midend_freeze_timer(midend *me, float tprop) +{ + me->anim_pos = me->anim_time * tprop; + midend_redraw(me); + deactivate_timer(me->frontend); +} + void midend_timer(midend *me, float tplus) { + int need_redraw = (me->anim_time > 0 || me->flash_time > 0); + me->anim_pos += tplus; if (me->anim_pos >= me->anim_time || me->anim_time == 0 || !me->oldstate) { @@ -737,7 +912,8 @@ void midend_timer(midend *me, float tplus) me->flash_pos = me->flash_time = 0; } - midend_redraw(me); + if (need_redraw) + midend_redraw(me); if (me->timing) { float oldelapsed = me->elapsed; @@ -751,20 +927,9 @@ void midend_timer(midend *me, float tplus) float *midend_colours(midend *me, int *ncolours) { - game_state *state = NULL; float *ret; - if (me->nstates == 0) { - char *aux = NULL; - char *desc = me->ourgame->new_desc(me->params, me->random, - &aux, TRUE); - state = me->ourgame->new_game(me, me->params, desc); - sfree(desc); - sfree(aux); - } else - state = me->states[0].state; - - ret = me->ourgame->colours(me->frontend, state, ncolours); + ret = me->ourgame->colours(me->frontend, ncolours); { int i; @@ -787,16 +952,13 @@ float *midend_colours(midend *me, int *ncolours) buf[k] = '\0'; if ((e = getenv(buf)) != NULL && sscanf(e, "%2x%2x%2x", &r, &g, &b) == 3) { - ret[i*3 + 0] = r / 255.0; - ret[i*3 + 1] = g / 255.0; - ret[i*3 + 2] = b / 255.0; + ret[i*3 + 0] = r / 255.0F; + ret[i*3 + 1] = g / 255.0F; + ret[i*3 + 2] = b / 255.0F; } } } - if (me->nstates == 0) - me->ourgame->free_game(state); - return ret; } @@ -813,10 +975,14 @@ int midend_num_presets(midend *me) game_params *); me->preset_names = sresize(me->preset_names, me->presetsize, char *); + me->preset_encodings = sresize(me->preset_encodings, + me->presetsize, char *); } me->presets[me->npresets] = preset; me->preset_names[me->npresets] = name; + me->preset_encodings[me->npresets] = + me->ourgame->encode_params(preset, TRUE);; me->npresets++; } } @@ -867,12 +1033,17 @@ int midend_num_presets(midend *me) game_params *); me->preset_names = sresize(me->preset_names, me->presetsize, char *); + me->preset_encodings = sresize(me->preset_encodings, + me->presetsize, char *); } me->presets[me->npresets] = preset; me->preset_names[me->npresets] = dupstr(name); + me->preset_encodings[me->npresets] = + me->ourgame->encode_params(preset, TRUE); me->npresets++; } + sfree(e); } } @@ -887,9 +1058,25 @@ void midend_fetch_preset(midend *me, int n, *params = me->presets[n]; } +int midend_which_preset(midend *me) +{ + char *encoding = me->ourgame->encode_params(me->params, TRUE); + int i, ret; + + ret = -1; + for (i = 0; i < me->npresets; i++) + if (!strcmp(encoding, me->preset_encodings[i])) { + ret = i; + break; + } + + sfree(encoding); + return ret; +} + int midend_wants_statusbar(midend *me) { - return me->ourgame->wants_statusbar(); + return me->ourgame->wants_statusbar; } void midend_supersede_game_desc(midend *me, char *desc, char *privdesc) @@ -1148,9 +1335,18 @@ char *midend_set_config(midend *me, int which, config_item *cfg) return NULL; } +int midend_can_format_as_text_now(midend *me) +{ + if (me->ourgame->can_format_as_text_ever) + return me->ourgame->can_format_as_text_now(me->params); + else + return FALSE; +} + char *midend_text_format(midend *me) { - if (me->ourgame->can_format_as_text && me->statepos > 0) + if (me->ourgame->can_format_as_text_ever && me->statepos > 0 && + me->ourgame->can_format_as_text_now(me->params)) return me->ourgame->text_format(me->states[me->statepos-1].state); else return NULL; @@ -1183,11 +1379,7 @@ char *midend_solve(midend *me) * Now enter the solved state as the next move. */ midend_stop_anim(me); - while (me->nstates > me->statepos) { - me->ourgame->free_game(me->states[--me->nstates].state); - if (me->states[me->nstates].movestr) - sfree(me->states[me->nstates].movestr); - } + midend_purge_states(me); ensure(me); me->states[me->nstates].state = s; me->states[me->nstates].movestr = movestr; @@ -1198,7 +1390,7 @@ char *midend_solve(midend *me) me->states[me->statepos-2].state, me->states[me->statepos-1].state); me->dir = +1; - if (me->ourgame->mouse_priorities & SOLVE_ANIMATES) { + if (me->ourgame->flags & SOLVE_ANIMATES) { me->oldstate = me->ourgame->dup_game(me->states[me->statepos-2].state); me->anim_time = me->ourgame->anim_length(me->states[me->statepos-2].state, @@ -1209,11 +1401,29 @@ char *midend_solve(midend *me) me->anim_time = 0.0; midend_finish_move(me); } - midend_redraw(me); + if (me->drawing) + midend_redraw(me); midend_set_timer(me); return NULL; } +int midend_status(midend *me) +{ + /* + * We should probably never be called when the state stack has no + * states on it at all - ideally, midends should never be left in + * that state for long enough to get put down and forgotten about. + * But if we are, I think we return _true_ - pedantically speaking + * a midend in that state is 'vacuously solved', and more + * practically, a user whose midend has been left in that state + * probably _does_ want the 'new game' option to be prominent. + */ + if (me->statepos == 0) + return +1; + + return me->ourgame->status(me->states[me->statepos-1].state); +} + char *midend_rewrite_statusbar(midend *me, char *text) { /* @@ -1229,7 +1439,7 @@ char *midend_rewrite_statusbar(midend *me, char *text) char timebuf[100], *ret; int min, sec; - sec = me->elapsed; + sec = (int)me->elapsed; min = sec / 60; sec %= 60; sprintf(timebuf, "[%d:%02d] ", min, sec); @@ -1533,7 +1743,7 @@ char *midend_deserialise(midend *me, uistr = val; val = NULL; } else if (!strcmp(key, "TIME")) { - elapsed = atof(val); + elapsed = (float)atof(val); } else if (!strcmp(key, "NSTATES")) { nstates = atoi(val); if (nstates <= 0) { @@ -1744,6 +1954,111 @@ char *midend_deserialise(midend *me, return ret; } +/* + * This function examines a saved game file just far enough to + * determine which game type it contains. It returns NULL on success + * and the game name string in 'name' (which will be dynamically + * allocated and should be caller-freed), or an error message on + * failure. + */ +char *identify_game(char **name, int (*read)(void *ctx, void *buf, int len), + void *rctx) +{ + int nstates = 0, statepos = -1, gotstates = 0; + int started = FALSE; + + char *val = NULL; + /* Initially all errors give the same report */ + char *ret = "Data does not appear to be a saved game file"; + + *name = NULL; + + /* + * Loop round and round reading one key/value pair at a time from + * the serialised stream, until we've found the game name. + */ + while (nstates <= 0 || statepos < 0 || gotstates < nstates-1) { + char key[9], c; + int len; + + do { + if (!read(rctx, key, 1)) { + /* unexpected EOF */ + goto cleanup; + } + } while (key[0] == '\r' || key[0] == '\n'); + + if (!read(rctx, key+1, 8)) { + /* unexpected EOF */ + goto cleanup; + } + + if (key[8] != ':') { + if (started) + ret = "Data was incorrectly formatted for a saved game file"; + goto cleanup; + } + len = strcspn(key, ": "); + assert(len <= 8); + key[len] = '\0'; + + len = 0; + while (1) { + if (!read(rctx, &c, 1)) { + /* unexpected EOF */ + goto cleanup; + } + + if (c == ':') { + break; + } else if (c >= '0' && c <= '9') { + len = (len * 10) + (c - '0'); + } else { + if (started) + ret = "Data was incorrectly formatted for a" + " saved game file"; + goto cleanup; + } + } + + val = snewn(len+1, char); + if (!read(rctx, val, len)) { + if (started) + goto cleanup; + } + val[len] = '\0'; + + if (!started) { + if (strcmp(key, "SAVEFILE") || strcmp(val, SERIALISE_MAGIC)) { + /* ret already has the right message in it */ + goto cleanup; + } + /* Now most errors are this one, unless otherwise specified */ + ret = "Saved data ended unexpectedly"; + started = TRUE; + } else { + if (!strcmp(key, "VERSION")) { + if (strcmp(val, SERIALISE_VERSION)) { + ret = "Cannot handle this version of the saved game" + " file format"; + goto cleanup; + } + } else if (!strcmp(key, "GAME")) { + *name = dupstr(val); + ret = NULL; + goto cleanup; + } + } + + sfree(val); + val = NULL; + } + + cleanup: + sfree(val); + return ret; +} + char *midend_print_puzzle(midend *me, document *doc, int with_soln) { game_state *soln = NULL;