X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ian/git?a=blobdiff_plain;f=midend.c;h=2f09bb528c7a9a1fb38e4262f21867b5f782326d;hb=db313b3948d27244dd7c34c2609c66d6204d8931;hp=1be8ca93c40a4578e8cf8709cda98474d3e878d4;hpb=3bfb9b108ea7276c5f0986aa82787cd8f098d6eb;p=sgt-puzzles.git diff --git a/midend.c b/midend.c index 1be8ca9..2f09bb5 100644 --- a/midend.c +++ b/midend.c @@ -30,9 +30,9 @@ struct midend { random_state *random; const game *ourgame; - game_params **presets; - char **preset_names; - int npresets, presetsize; + struct preset_menu *preset_menu; + char **encoded_presets; /* for midend_which_preset to check against */ + int n_encoded_presets; /* * `desc' and `privdesc' deserve a comment. @@ -63,6 +63,9 @@ struct midend { int nstates, statesize, statepos; struct midend_state_entry *states; + void *newgame_undo_buf; + int newgame_undo_len, newgame_undo_size; + game_params *params, *curparams; game_drawstate *drawstate; game_ui *ui; @@ -80,7 +83,10 @@ struct midend { int pressed_mouse_button; - int tilesize, winwidth, winheight; + int preferred_tilesize, tilesize, winwidth, winheight; + + void (*game_id_change_notify_function)(void *); + void *game_id_change_notify_ctx; }; #define ensure(me) do { \ @@ -91,6 +97,53 @@ struct midend { } \ } while (0) +/* + * Structure storing all the decoded data from reading a serialised + * game. We keep it in one of these while we check its sanity, and + * only once we're completely satisfied do we install it all in the + * midend structure proper. + */ +struct deserialise_data { + char *seed, *parstr, *desc, *privdesc; + char *auxinfo, *uistr, *cparstr; + float elapsed; + game_params *params, *cparams; + game_ui *ui; + struct midend_state_entry *states; + int nstates, statepos; +}; + +/* + * Forward reference. + */ +static char *midend_deserialise_internal( + midend *me, int (*read)(void *ctx, void *buf, int len), void *rctx, + char *(*check)(void *ctx, midend *, const struct deserialise_data *), + void *cctx); + +void midend_reset_tilesize(midend *me) +{ + me->preferred_tilesize = me->ourgame->preferred_tilesize; + { + /* + * Allow an environment-based override for the default tile + * size by defining a variable along the lines of + * `NET_TILESIZE=15'. + */ + + char buf[80], *e; + int j, k, ts; + + sprintf(buf, "%s_TILESIZE", 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 && sscanf(e, "%d", &ts) == 1 && ts > 0) + me->preferred_tilesize = ts; + } +} + midend *midend_new(frontend *fe, const game *ourgame, const drawing_api *drapi, void *drhandle) { @@ -102,10 +155,31 @@ 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->newgame_undo_buf = NULL; + me->newgame_undo_size = me->newgame_undo_len = 0; me->params = ourgame->default_params(); + me->game_id_change_notify_function = NULL; + me->game_id_change_notify_ctx = NULL; + + /* + * 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; @@ -113,9 +187,7 @@ midend *midend_new(frontend *fe, const game *ourgame, me->genmode = GOT_NOTHING; me->drawstate = NULL; me->oldstate = NULL; - me->presets = NULL; - me->preset_names = NULL; - me->npresets = me->presetsize = 0; + me->preset_menu = NULL; me->anim_time = me->anim_pos = 0.0F; me->flash_time = me->flash_pos = 0.0F; me->dir = 0; @@ -126,15 +198,31 @@ 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; + midend_reset_tilesize(me); + sfree(randseed); 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) { @@ -147,29 +235,36 @@ static void midend_free_game(midend *me) me->ourgame->free_drawstate(me->drawing, me->drawstate); } -void midend_free(midend *me) +static void midend_free_preset_menu(midend *me, struct preset_menu *menu) { - int i; + if (menu) { + int i; + for (i = 0; i < menu->n_entries; i++) { + sfree(menu->entries[i].title); + if (menu->entries[i].params) + me->ourgame->free_params(menu->entries[i].params); + midend_free_preset_menu(me, menu->entries[i].submenu); + } + sfree(menu->entries); + sfree(menu); + } +} +void midend_free(midend *me) +{ midend_free_game(me); if (me->drawing) drawing_free(me->drawing); random_free(me->random); + sfree(me->newgame_undo_buf); sfree(me->states); sfree(me->desc); sfree(me->privdesc); sfree(me->seedstr); sfree(me->aux_info); me->ourgame->free_params(me->params); - if (me->npresets) { - for (i = 0; i < me->npresets; i++) { - sfree(me->presets[i]); - sfree(me->preset_names[i]); - } - sfree(me->presets); - sfree(me->preset_names); - } + midend_free_preset_menu(me, me->preset_menu); if (me->ui) me->ourgame->free_ui(me->ui); if (me->curparams) @@ -192,25 +287,39 @@ 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; + /* + * We can't set the size on the same drawstate twice. So if + * we've already sized one drawstate, we must throw it away and + * create a new one. + */ + if (me->drawstate && me->tilesize > 0) { + me->ourgame->free_drawstate(me->drawing, me->drawstate); + me->drawstate = me->ourgame->new_drawstate(me->drawing, + me->states[0].state); + } + /* * 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; me->ourgame->compute_size(me->params, max, &rx, &ry); } while (rx <= *x && ry <= *y); } else - max = me->ourgame->preferred_tilesize + 1; + max = me->preferred_tilesize + 1; min = 1; /* @@ -233,11 +342,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); @@ -270,8 +384,28 @@ void midend_force_redraw(midend *me) midend_redraw(me); } +static void newgame_serialise_write(void *ctx, void *buf, int len) +{ + midend *const me = ctx; + int new_len; + + assert(len < INT_MAX - me->newgame_undo_len); + new_len = me->newgame_undo_len + len; + if (new_len > me->newgame_undo_size) { + me->newgame_undo_size = new_len + new_len / 4 + 1024; + me->newgame_undo_buf = sresize(me->newgame_undo_buf, + me->newgame_undo_size, char); + } + memcpy(me->newgame_undo_buf + me->newgame_undo_len, buf, len); + me->newgame_undo_len = new_len; +} + void midend_new_game(midend *me) { + me->newgame_undo_len = 0; + midend_serialise(me, newgame_serialise_write, me); + + midend_stop_anim(me); midend_free_game(me); assert(me->nstates == 0); @@ -295,9 +429,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); @@ -311,7 +445,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 @@ -325,8 +459,43 @@ 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); + } + me->states[me->nstates].movestr = NULL; me->states[me->nstates].movetype = NEWGAME; me->nstates++; @@ -335,15 +504,104 @@ void midend_new_game(midend *me) me->states[0].state); midend_size_new_drawstate(me); me->elapsed = 0.0F; + me->flash_pos = me->flash_time = 0.0F; + me->anim_pos = me->anim_time = 0.0F; if (me->ui) me->ourgame->free_ui(me->ui); me->ui = me->ourgame->new_ui(me->states[0].state); midend_set_timer(me); me->pressed_mouse_button = 0; + + if (me->game_id_change_notify_function) + me->game_id_change_notify_function(me->game_id_change_notify_ctx); +} + +int midend_can_undo(midend *me) +{ + return (me->statepos > 1 || me->newgame_undo_len); +} + +int midend_can_redo(midend *me) +{ + return (me->statepos < me->nstates); +} + +struct newgame_undo_deserialise_read_ctx { + midend *me; + int len, pos; +}; + +static int newgame_undo_deserialise_read(void *ctx, void *buf, int len) +{ + struct newgame_undo_deserialise_read_ctx *const rctx = ctx; + midend *const me = rctx->me; + + int use = min(len, rctx->len - rctx->pos); + memcpy(buf, me->newgame_undo_buf + rctx->pos, use); + rctx->pos += use; + return use; +} + +struct newgame_undo_deserialise_check_ctx { + int refused; +}; + +static char *newgame_undo_deserialise_check( + void *vctx, midend *me, const struct deserialise_data *data) +{ + struct newgame_undo_deserialise_check_ctx *ctx = + (struct newgame_undo_deserialise_check_ctx *)vctx; + char *old, *new; + + /* + * Undoing a New Game operation is only permitted if it doesn't + * change the game parameters. The point of having the ability at + * all is to recover from the momentary finger error of having hit + * the 'n' key (perhaps in place of some other nearby key), or hit + * the New Game menu item by mistake when aiming for the adjacent + * Restart; in both those situations, the game params are the same + * before and after the new-game operation. + * + * In principle, we could generalise this so that _any_ call to + * midend_new_game could be undone, but that would need all front + * ends to be alert to the possibility that any keystroke passed + * to midend_process_key might (if it turns out to have been one + * of the synonyms for undo, which the frontend doesn't + * necessarily check for) have various knock-on effects like + * needing to select a different preset in the game type menu, or + * even resizing the window. At least for the moment, it's easier + * not to do that, and to simply disallow any newgame-undo that is + * disruptive in either of those ways. + * + * We check both params and cparams, to be as safe as possible. + */ + + old = me->ourgame->encode_params(me->params, TRUE); + new = me->ourgame->encode_params(data->params, TRUE); + if (strcmp(old, new)) { + /* Set a flag to distinguish this deserialise failure + * from one due to faulty decoding */ + ctx->refused = TRUE; + return "Undoing this new-game operation would change params"; + } + + old = me->ourgame->encode_params(me->curparams, TRUE); + new = me->ourgame->encode_params(data->cparams, TRUE); + if (strcmp(old, new)) { + ctx->refused = TRUE; + return "Undoing this new-game operation would change params"; + } + + /* + * Otherwise, fine, go ahead. + */ + return NULL; } static int midend_undo(midend *me) { + char *deserialise_error; + if (me->statepos > 1) { if (me->ui) me->ourgame->changed_state(me->ui, @@ -352,6 +610,36 @@ static int midend_undo(midend *me) me->statepos--; me->dir = -1; return 1; + } else if (me->newgame_undo_len) { + /* This undo cannot be undone with redo */ + struct newgame_undo_deserialise_read_ctx rctx; + struct newgame_undo_deserialise_check_ctx cctx; + rctx.me = me; + rctx.len = me->newgame_undo_len; /* copy for reentrancy safety */ + rctx.pos = 0; + cctx.refused = FALSE; + deserialise_error = midend_deserialise_internal( + me, newgame_undo_deserialise_read, &rctx, + newgame_undo_deserialise_check, &cctx); + if (cctx.refused) { + /* + * Our post-deserialisation check shows that we can't use + * this saved game after all. (deserialise_error will + * contain the dummy error message generated by our check + * function, which we ignore.) + */ + return 0; + } else { + /* + * There should never be any _other_ deserialisation + * error, because this serialised data has been held in + * our memory since it was created, and hasn't had any + * opportunity to be corrupted on disk, accidentally + * replaced by the wrong file, etc., by user error. + */ + assert(!deserialise_error); + return 1; + } } else return 0; } @@ -415,8 +703,6 @@ void midend_restart_game(midend *me) { game_state *s; - midend_stop_anim(me); - assert(me->statepos >= 1); if (me->statepos == 1) return; /* no point doing anything at all! */ @@ -434,8 +720,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); @@ -445,7 +730,7 @@ void midend_restart_game(midend *me) me->ourgame->changed_state(me->ui, me->states[me->statepos-2].state, me->states[me->statepos-1].state); - me->anim_time = 0.0; + me->flash_pos = me->flash_time = 0.0F; midend_finish_move(me); midend_redraw(me); midend_set_timer(me); @@ -458,31 +743,40 @@ static int midend_really_process_key(midend *me, int x, int y, int button) int type = MOVE, gottype = FALSE, ret = 1; float anim_time; game_state *s; - char *movestr; - - movestr = - me->ourgame->interpret_move(me->states[me->statepos-1].state, - me->ui, me->drawstate, x, y, button); + char *movestr = NULL; + + if (!IS_UI_FAKE_KEY(button)) { + movestr = me->ourgame->interpret_move( + me->states[me->statepos-1].state, + me->ui, me->drawstate, x, y, button); + } if (!movestr) { - if (button == 'n' || button == 'N' || button == '\x0E') { - midend_stop_anim(me); + if (button == 'n' || button == 'N' || button == '\x0E' || + button == UI_NEWGAME) { midend_new_game(me); midend_redraw(me); goto done; /* never animate */ - } else if (button == 'u' || button == 'u' || - button == '\x1A' || button == '\x1F') { + } else if (button == 'u' || button == 'U' || + button == '\x1A' || button == '\x1F' || + button == UI_UNDO) { midend_stop_anim(me); type = me->states[me->statepos-1].movetype; gottype = TRUE; if (!midend_undo(me)) goto done; } else if (button == 'r' || button == 'R' || - button == '\x12' || button == '\x19') { + button == '\x12' || button == '\x19' || + button == UI_REDO) { midend_stop_anim(me); if (!midend_redo(me)) goto done; - } else if (button == 'q' || button == 'Q' || button == '\x11') { + } else if ((button == '\x13' || button == UI_SOLVE) && + me->ourgame->can_solve) { + if (midend_solve(me)) + goto done; + } else if (button == 'q' || button == 'Q' || button == '\x11' || + button == UI_QUIT) { ret = 0; goto done; } else @@ -503,11 +797,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; @@ -531,7 +825,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, @@ -626,6 +920,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) { @@ -643,7 +945,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 */ @@ -655,6 +957,23 @@ int midend_process_key(midend *me, int x, int y, int button) (LEFT_RELEASE - LEFT_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. */ @@ -692,8 +1011,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) { @@ -706,7 +1038,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; @@ -720,20 +1053,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; @@ -756,49 +1078,187 @@ 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; } -int midend_num_presets(midend *me) +struct preset_menu *preset_menu_new(void) { - if (!me->npresets) { - char *name; + struct preset_menu *menu = snew(struct preset_menu); + menu->n_entries = 0; + menu->entries_size = 0; + menu->entries = NULL; + return menu; +} + +static struct preset_menu_entry *preset_menu_add(struct preset_menu *menu, + char *title) +{ + struct preset_menu_entry *toret; + if (menu->n_entries >= menu->entries_size) { + menu->entries_size = menu->n_entries * 5 / 4 + 10; + menu->entries = sresize(menu->entries, menu->entries_size, + struct preset_menu_entry); + } + toret = &menu->entries[menu->n_entries++]; + toret->title = title; + toret->params = NULL; + toret->submenu = NULL; + return toret; +} + +struct preset_menu *preset_menu_add_submenu(struct preset_menu *parent, + char *title) +{ + struct preset_menu_entry *entry = preset_menu_add(parent, title); + entry->submenu = preset_menu_new(); + return entry->submenu; +} + +void preset_menu_add_preset(struct preset_menu *parent, + char *title, game_params *params) +{ + struct preset_menu_entry *entry = preset_menu_add(parent, title); + entry->params = params; +} + +game_params *preset_menu_lookup_by_id(struct preset_menu *menu, int id) +{ + int i; + game_params *retd; + + for (i = 0; i < menu->n_entries; i++) { + if (id == menu->entries[i].id) + return menu->entries[i].params; + if (menu->entries[i].submenu && + (retd = preset_menu_lookup_by_id( + menu->entries[i].submenu, id)) != NULL) + return retd; + } + + return NULL; +} + +static char *preset_menu_add_from_user_env( + midend *me, struct preset_menu *menu, char *p, int top_level) +{ + while (*p) { + char *name, *val; game_params *preset; - while (me->ourgame->fetch_preset(me->npresets, &name, &preset)) { - if (me->presetsize <= me->npresets) { - me->presetsize = me->npresets + 10; - me->presets = sresize(me->presets, me->presetsize, - game_params *); - me->preset_names = sresize(me->preset_names, me->presetsize, - char *); + name = p; + while (*p && *p != ':') p++; + if (*p) *p++ = '\0'; + val = p; + while (*p && *p != ':') p++; + if (*p) *p++ = '\0'; + + if (!strcmp(val, "#")) { + /* + * Special case: either open a new submenu with the given + * title, or terminate the current submenu. + */ + if (*name) { + struct preset_menu *submenu = + preset_menu_add_submenu(menu, dupstr(name)); + p = preset_menu_add_from_user_env(me, submenu, p, FALSE); + } else { + /* + * If we get a 'close submenu' indication at the top + * level, there's not much we can do but quietly + * ignore it. + */ + if (!top_level) + return p; } + continue; + } + + preset = me->ourgame->default_params(); + me->ourgame->decode_params(preset, val); - me->presets[me->npresets] = preset; - me->preset_names[me->npresets] = name; - me->npresets++; + if (me->ourgame->validate_params(preset, TRUE)) { + /* Drop this one from the list. */ + me->ourgame->free_params(preset); + continue; } + + preset_menu_add_preset(menu, dupstr(name), preset); + } + + return p; +} + +static void preset_menu_alloc_ids(midend *me, struct preset_menu *menu) +{ + int i; + + for (i = 0; i < menu->n_entries; i++) + menu->entries[i].id = me->n_encoded_presets++; + + for (i = 0; i < menu->n_entries; i++) + if (menu->entries[i].submenu) + preset_menu_alloc_ids(me, menu->entries[i].submenu); +} + +static void preset_menu_encode_params(midend *me, struct preset_menu *menu) +{ + int i; + + for (i = 0; i < menu->n_entries; i++) { + if (menu->entries[i].params) { + me->encoded_presets[menu->entries[i].id] = + me->ourgame->encode_params(menu->entries[i].params, TRUE); + } else { + preset_menu_encode_params(me, menu->entries[i].submenu); + } + } +} + +struct preset_menu *midend_get_presets(midend *me, int *id_limit) +{ + int i; + + if (me->preset_menu) + return me->preset_menu; + +#if 0 + /* Expect the game to implement exactly one of the two preset APIs */ + assert(me->ourgame->fetch_preset || me->ourgame->preset_menu); + assert(!(me->ourgame->fetch_preset && me->ourgame->preset_menu)); +#endif + + if (me->ourgame->fetch_preset) { + char *name; + game_params *preset; + + /* Simple one-level menu */ + assert(!me->ourgame->preset_menu); + me->preset_menu = preset_menu_new(); + for (i = 0; me->ourgame->fetch_preset(i, &name, &preset); i++) + preset_menu_add_preset(me->preset_menu, name, preset); + + } else { + /* Hierarchical menu provided by the game backend */ + me->preset_menu = me->ourgame->preset_menu(); } { /* - * Allow environment-based extensions to the preset list by - * defining a variable along the lines of `SOLO_PRESETS=2x3 - * Advanced:2x3da'. Colon-separated list of items, - * alternating between textual titles in the menu and - * encoded parameter strings. + * Allow user extensions to the preset list by defining an + * environment variable _PRESETS whose value is a + * colon-separated list of items, alternating between textual + * titles in the menu and encoded parameter strings. For + * example, "SOLO_PRESETS=2x3 Advanced:2x3da" would define + * just one additional preset for Solo. */ - char buf[80], *e, *p; + char buf[80], *e; int j, k; sprintf(buf, "%s_PRESETS", me->ourgame->name); @@ -808,57 +1268,55 @@ int midend_num_presets(midend *me) buf[k] = '\0'; if ((e = getenv(buf)) != NULL) { - p = e = dupstr(e); - - while (*p) { - char *name, *val; - game_params *preset; - - name = p; - while (*p && *p != ':') p++; - if (*p) *p++ = '\0'; - val = p; - while (*p && *p != ':') p++; - if (*p) *p++ = '\0'; - - preset = me->ourgame->default_params(); - me->ourgame->decode_params(preset, val); - - if (me->ourgame->validate_params(preset, TRUE)) { - /* Drop this one from the list. */ - me->ourgame->free_params(preset); - continue; - } - - if (me->presetsize <= me->npresets) { - me->presetsize = me->npresets + 10; - me->presets = sresize(me->presets, me->presetsize, - game_params *); - me->preset_names = sresize(me->preset_names, - me->presetsize, char *); - } - - me->presets[me->npresets] = preset; - me->preset_names[me->npresets] = dupstr(name); - me->npresets++; - } + e = dupstr(e); + preset_menu_add_from_user_env(me, me->preset_menu, e, TRUE); + sfree(e); } } - return me->npresets; + /* + * Finalise the menu: allocate an integer id to each entry, and + * store string encodings of the presets' parameters in + * me->encoded_presets. + */ + me->n_encoded_presets = 0; + preset_menu_alloc_ids(me, me->preset_menu); + me->encoded_presets = snewn(me->n_encoded_presets, char *); + for (i = 0; i < me->n_encoded_presets; i++) + me->encoded_presets[i] = NULL; + preset_menu_encode_params(me, me->preset_menu); + + if (id_limit) + *id_limit = me->n_encoded_presets; + return me->preset_menu; } -void midend_fetch_preset(midend *me, int n, - char **name, game_params **params) +int midend_which_preset(midend *me) { - assert(n >= 0 && n < me->npresets); - *name = me->preset_names[n]; - *params = me->presets[n]; + char *encoding = me->ourgame->encode_params(me->params, TRUE); + int i, ret; + + ret = -1; + for (i = 0; i < me->n_encoded_presets; i++) + if (me->encoded_presets[i] && + !strcmp(encoding, me->encoded_presets[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_request_id_changes(midend *me, void (*notify)(void *), void *ctx) +{ + me->game_id_change_notify_function = notify; + me->game_id_change_notify_ctx = ctx; } void midend_supersede_game_desc(midend *me, char *desc, char *privdesc) @@ -867,6 +1325,8 @@ void midend_supersede_game_desc(midend *me, char *desc, char *privdesc) sfree(me->privdesc); me->desc = dupstr(desc); me->privdesc = privdesc ? dupstr(privdesc) : NULL; + if (me->game_id_change_notify_function) + me->game_id_change_notify_function(me->game_id_change_notify_ctx); } config_item *midend_get_config(midend *me, int which, char **wintitle) @@ -988,7 +1448,45 @@ static char *midend_game_id_int(midend *me, char *id, int defmode) newcurparams = newparams = oldparams1 = oldparams2 = NULL; if (par) { - newcurparams = me->ourgame->dup_params(me->params); + /* + * The params string may underspecify the game parameters, so + * we must first initialise newcurparams with a full set of + * params from somewhere else before we decode_params the + * input string over the top. + * + * But which set? It depends on what other data we have. + * + * If we've been given a _descriptive_ game id, then that may + * well underspecify by design, e.g. Solo game descriptions + * often start just '3x3:' without specifying one of Solo's + * difficulty settings, because it isn't necessary once a game + * has been generated (and you might not even know it, if + * you're manually transcribing a game description). In that + * situation, I've always felt that the best thing to set the + * difficulty to (for use if the user hits 'New Game' after + * pasting in that game id) is whatever it was previously set + * to. That is, we use whatever is already in me->params as + * the basis for our decoding of this input string. + * + * A random-seed based game id, however, should use the real, + * built-in default params, and not even check the + * _DEFAULT environment setting, because when people + * paste each other random seeds - whether it's two users + * arranging to generate the same game at the same time to + * race solving them, or a user sending a bug report upstream + * - the whole point is for the random game id to always be + * interpreted the same way, even if it does underspecify. + * + * A parameter string typed in on its own, with no seed _or_ + * description, gets treated the same way as a random seed, + * because again I think the most likely reason for doing that + * is to have a portable representation of a set of params. + */ + if (desc) { + newcurparams = me->ourgame->dup_params(me->params); + } else { + newcurparams = me->ourgame->default_params(); + } me->ourgame->decode_params(newcurparams, par); error = me->ourgame->validate_params(newcurparams, desc == NULL); if (error) { @@ -1086,6 +1584,21 @@ char *midend_get_game_id(midend *me) return ret; } +char *midend_get_random_seed(midend *me) +{ + char *parstr, *ret; + + if (!me->seedstr) + return NULL; + + parstr = me->ourgame->encode_params(me->curparams, TRUE); + assert(parstr); + ret = snewn(strlen(parstr) + strlen(me->seedstr) + 2, char); + sprintf(ret, "%s#%s", parstr, me->seedstr); + sfree(parstr); + return ret; +} + char *midend_set_config(midend *me, int which, config_item *cfg) { char *error; @@ -1117,9 +1630,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; @@ -1136,12 +1658,15 @@ char *midend_solve(midend *me) if (me->statepos < 1) return "No game set up to solve"; /* _shouldn't_ happen! */ - msg = "Solve operation failed"; /* game _should_ overwrite on error */ + msg = NULL; movestr = me->ourgame->solve(me->states[0].state, me->states[me->statepos-1].state, me->aux_info, &msg); - if (!movestr) + if (!movestr) { + if (!msg) + msg = "Solve operation failed"; /* _shouldn't_ happen, but can */ return msg; + } s = me->ourgame->execute_move(me->states[me->statepos-1].state, movestr); assert(s); @@ -1149,8 +1674,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); + midend_purge_states(me); ensure(me); me->states[me->nstates].state = s; me->states[me->nstates].movestr = movestr; @@ -1161,7 +1685,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, @@ -1172,11 +1696,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) { /* @@ -1192,7 +1734,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); @@ -1228,7 +1770,9 @@ void midend_serialise(midend *me, #define wr(h,s) do { \ char hbuf[80]; \ char *str = (s); \ - sprintf(hbuf, "%-8.8s:%d:", (h), (int)strlen(str)); \ + char lbuf[9]; \ + copy_left_justified(lbuf, sizeof(lbuf), h); \ + sprintf(hbuf, "%s:%d:", lbuf, (int)strlen(str)); \ write(wctx, hbuf, strlen(hbuf)); \ write(wctx, str, strlen(str)); \ write(wctx, "\n", 1); \ @@ -1357,13 +1901,20 @@ void midend_serialise(midend *me, } /* - * This function returns NULL on success, or an error message. + * Internal version of midend_deserialise, taking an extra check + * function to be called just before beginning to install things in + * the midend. + * + * Like midend_deserialise proper, this function returns NULL on + * success, or an error message. */ -char *midend_deserialise(midend *me, - int (*read)(void *ctx, void *buf, int len), - void *rctx) +static char *midend_deserialise_internal( + midend *me, int (*read)(void *ctx, void *buf, int len), void *rctx, + char *(*check)(void *ctx, midend *, const struct deserialise_data *data), + void *cctx) { - int nstates = 0, statepos = -1, gotstates = 0; + struct deserialise_data data; + int gotstates = 0; int started = FALSE; int i; @@ -1371,25 +1922,22 @@ char *midend_deserialise(midend *me, /* Initially all errors give the same report */ char *ret = "Data does not appear to be a saved game file"; - /* - * We construct all the new state in local variables while we - * check its sanity. Only once we have finished reading the - * serialised data and detected no errors at all do we start - * modifying stuff in the midend passed in. - */ - char *seed = NULL, *parstr = NULL, *desc = NULL, *privdesc = NULL; - char *auxinfo = NULL, *uistr = NULL, *cparstr = NULL; - float elapsed = 0.0F; - game_params *params = NULL, *cparams = NULL; - game_ui *ui = NULL; - struct midend_state_entry *states = NULL; + data.seed = data.parstr = data.desc = data.privdesc = NULL; + data.auxinfo = data.uistr = data.cparstr = NULL; + data.elapsed = 0.0F; + data.params = data.cparams = NULL; + data.ui = NULL; + data.states = NULL; + data.nstates = 0; + data.statepos = -1; /* * Loop round and round reading one key/value pair at a time * from the serialised stream, until we have enough game states * to finish. */ - while (nstates <= 0 || statepos < 0 || gotstates < nstates-1) { + while (data.nstates <= 0 || data.statepos < 0 || + gotstates < data.nstates-1) { char key[9], c; int len; @@ -1461,24 +2009,24 @@ char *midend_deserialise(midend *me, goto cleanup; } } else if (!strcmp(key, "PARAMS")) { - sfree(parstr); - parstr = val; + sfree(data.parstr); + data.parstr = val; val = NULL; } else if (!strcmp(key, "CPARAMS")) { - sfree(cparstr); - cparstr = val; + sfree(data.cparstr); + data.cparstr = val; val = NULL; } else if (!strcmp(key, "SEED")) { - sfree(seed); - seed = val; + sfree(data.seed); + data.seed = val; val = NULL; } else if (!strcmp(key, "DESC")) { - sfree(desc); - desc = val; + sfree(data.desc); + data.desc = val; val = NULL; } else if (!strcmp(key, "PRIVDESC")) { - sfree(privdesc); - privdesc = val; + sfree(data.privdesc); + data.privdesc = val; val = NULL; } else if (!strcmp(key, "AUXINFO")) { unsigned char *tmp; @@ -1486,49 +2034,49 @@ char *midend_deserialise(midend *me, tmp = hex2bin(val, len); obfuscate_bitmap(tmp, len*8, TRUE); - sfree(auxinfo); - auxinfo = snewn(len + 1, char); - memcpy(auxinfo, tmp, len); - auxinfo[len] = '\0'; + sfree(data.auxinfo); + data.auxinfo = snewn(len + 1, char); + memcpy(data.auxinfo, tmp, len); + data.auxinfo[len] = '\0'; sfree(tmp); } else if (!strcmp(key, "UI")) { - sfree(uistr); - uistr = val; + sfree(data.uistr); + data.uistr = val; val = NULL; } else if (!strcmp(key, "TIME")) { - elapsed = atof(val); + data.elapsed = (float)atof(val); } else if (!strcmp(key, "NSTATES")) { - nstates = atoi(val); - if (nstates <= 0) { + data.nstates = atoi(val); + if (data.nstates <= 0) { ret = "Number of states in save file was negative"; goto cleanup; } - if (states) { + if (data.states) { ret = "Two state counts provided in save file"; goto cleanup; } - states = snewn(nstates, struct midend_state_entry); - for (i = 0; i < nstates; i++) { - states[i].state = NULL; - states[i].movestr = NULL; - states[i].movetype = NEWGAME; + data.states = snewn(data.nstates, struct midend_state_entry); + for (i = 0; i < data.nstates; i++) { + data.states[i].state = NULL; + data.states[i].movestr = NULL; + data.states[i].movetype = NEWGAME; } } else if (!strcmp(key, "STATEPOS")) { - statepos = atoi(val); + data.statepos = atoi(val); } else if (!strcmp(key, "MOVE")) { gotstates++; - states[gotstates].movetype = MOVE; - states[gotstates].movestr = val; + data.states[gotstates].movetype = MOVE; + data.states[gotstates].movestr = val; val = NULL; } else if (!strcmp(key, "SOLVE")) { gotstates++; - states[gotstates].movetype = SOLVE; - states[gotstates].movestr = val; + data.states[gotstates].movetype = SOLVE; + data.states[gotstates].movestr = val; val = NULL; } else if (!strcmp(key, "RESTART")) { gotstates++; - states[gotstates].movetype = RESTART; - states[gotstates].movestr = val; + data.states[gotstates].movetype = RESTART; + data.states[gotstates].movestr = val; val = NULL; } } @@ -1537,68 +2085,77 @@ char *midend_deserialise(midend *me, val = NULL; } - params = me->ourgame->default_params(); - me->ourgame->decode_params(params, parstr); - if (me->ourgame->validate_params(params, TRUE)) { + data.params = me->ourgame->default_params(); + me->ourgame->decode_params(data.params, data.parstr); + if (me->ourgame->validate_params(data.params, TRUE)) { ret = "Long-term parameters in save file are invalid"; goto cleanup; } - cparams = me->ourgame->default_params(); - me->ourgame->decode_params(cparams, cparstr); - if (me->ourgame->validate_params(cparams, FALSE)) { + data.cparams = me->ourgame->default_params(); + me->ourgame->decode_params(data.cparams, data.cparstr); + if (me->ourgame->validate_params(data.cparams, FALSE)) { ret = "Short-term parameters in save file are invalid"; goto cleanup; } - if (seed && me->ourgame->validate_params(cparams, TRUE)) { + if (data.seed && me->ourgame->validate_params(data.cparams, TRUE)) { /* * The seed's no use with this version, but we can perfectly * well use the rest of the data. */ - sfree(seed); - seed = NULL; + sfree(data.seed); + data.seed = NULL; } - if (!desc) { + if (!data.desc) { ret = "Game description in save file is missing"; goto cleanup; - } else if (me->ourgame->validate_desc(params, desc)) { + } else if (me->ourgame->validate_desc(data.cparams, data.desc)) { ret = "Game description in save file is invalid"; goto cleanup; } - if (privdesc && me->ourgame->validate_desc(params, privdesc)) { + if (data.privdesc && + me->ourgame->validate_desc(data.cparams, data.privdesc)) { ret = "Game private description in save file is invalid"; goto cleanup; } - if (statepos < 0 || statepos >= nstates) { + if (data.statepos < 0 || data.statepos >= data.nstates) { ret = "Game position in save file is out of range"; } - states[0].state = me->ourgame->new_game(me, params, - privdesc ? privdesc : desc); - for (i = 1; i < nstates; i++) { - assert(states[i].movetype != NEWGAME); - switch (states[i].movetype) { + data.states[0].state = me->ourgame->new_game( + me, data.cparams, data.privdesc ? data.privdesc : data.desc); + for (i = 1; i < data.nstates; i++) { + assert(data.states[i].movetype != NEWGAME); + switch (data.states[i].movetype) { case MOVE: case SOLVE: - states[i].state = me->ourgame->execute_move(states[i-1].state, - states[i].movestr); - if (states[i].state == NULL) { + data.states[i].state = me->ourgame->execute_move( + data.states[i-1].state, data.states[i].movestr); + if (data.states[i].state == NULL) { ret = "Save file contained an invalid move"; goto cleanup; } break; case RESTART: - if (me->ourgame->validate_desc(params, states[i].movestr)) { + if (me->ourgame->validate_desc( + data.cparams, data.states[i].movestr)) { ret = "Save file contained an invalid restart move"; goto cleanup; } - states[i].state = me->ourgame->new_game(me, params, - states[i].movestr); + data.states[i].state = me->ourgame->new_game( + me, data.cparams, data.states[i].movestr); break; } } - ui = me->ourgame->new_ui(states[0].state); - me->ourgame->decode_ui(ui, uistr); + data.ui = me->ourgame->new_ui(data.states[0].state); + me->ourgame->decode_ui(data.ui, data.uistr); + + /* + * Run the externally provided check function, and abort if it + * returns an error message. + */ + if (check && (ret = check(cctx, me, &data)) != NULL) + goto cleanup; /* error message is already in ret */ /* * Now we've run out of possible error conditions, so we're @@ -1611,45 +2168,54 @@ char *midend_deserialise(midend *me, char *tmp; tmp = me->desc; - me->desc = desc; - desc = tmp; + me->desc = data.desc; + data.desc = tmp; tmp = me->privdesc; - me->privdesc = privdesc; - privdesc = tmp; + me->privdesc = data.privdesc; + data.privdesc = tmp; tmp = me->seedstr; - me->seedstr = seed; - seed = tmp; + me->seedstr = data.seed; + data.seed = tmp; tmp = me->aux_info; - me->aux_info = auxinfo; - auxinfo = tmp; + me->aux_info = data.auxinfo; + data.auxinfo = tmp; } me->genmode = GOT_NOTHING; - me->statesize = nstates; - nstates = me->nstates; + me->statesize = data.nstates; + data.nstates = me->nstates; me->nstates = me->statesize; { struct midend_state_entry *tmp; tmp = me->states; - me->states = states; - states = tmp; + me->states = data.states; + data.states = tmp; } - me->statepos = statepos; + me->statepos = data.statepos; + + /* + * Don't save the "new game undo" state. So "new game" twice or + * (in some environments) switching away and back, will make a + * "new game" irreversible. Maybe in the future we will have a + * more sophisticated way to decide when to discard the previous + * game state. + */ + me->newgame_undo_len = 0; { game_params *tmp; tmp = me->params; - me->params = params; - params = tmp; + me->params = data.params; + data.params = tmp; tmp = me->curparams; - me->curparams = cparams; - cparams = tmp; + me->curparams = data.cparams; + data.cparams = tmp; } me->oldstate = NULL; @@ -1660,11 +2226,11 @@ char *midend_deserialise(midend *me, game_ui *tmp; tmp = me->ui; - me->ui = ui; - ui = tmp; + me->ui = data.ui; + data.ui = tmp; } - me->elapsed = elapsed; + me->elapsed = data.elapsed; me->pressed_mouse_button = 0; midend_set_timer(me); @@ -1675,38 +2241,151 @@ char *midend_deserialise(midend *me, me->ourgame->new_drawstate(me->drawing, me->states[me->statepos-1].state); midend_size_new_drawstate(me); + if (me->game_id_change_notify_function) + me->game_id_change_notify_function(me->game_id_change_notify_ctx); ret = NULL; /* success! */ cleanup: sfree(val); - sfree(seed); - sfree(parstr); - sfree(cparstr); - sfree(desc); - sfree(privdesc); - sfree(auxinfo); - sfree(uistr); - if (params) - me->ourgame->free_params(params); - if (cparams) - me->ourgame->free_params(cparams); - if (ui) - me->ourgame->free_ui(ui); - if (states) { + sfree(data.seed); + sfree(data.parstr); + sfree(data.cparstr); + sfree(data.desc); + sfree(data.privdesc); + sfree(data.auxinfo); + sfree(data.uistr); + if (data.params) + me->ourgame->free_params(data.params); + if (data.cparams) + me->ourgame->free_params(data.cparams); + if (data.ui) + me->ourgame->free_ui(data.ui); + if (data.states) { int i; - for (i = 0; i < nstates; i++) { - if (states[i].state) - me->ourgame->free_game(states[i].state); - sfree(states[i].movestr); + for (i = 0; i < data.nstates; i++) { + if (data.states[i].state) + me->ourgame->free_game(data.states[i].state); + sfree(data.states[i].movestr); } - sfree(states); + sfree(data.states); } return ret; } +char *midend_deserialise( + midend *me, int (*read)(void *ctx, void *buf, int len), void *rctx) +{ + return midend_deserialise_internal(me, read, rctx, NULL, NULL); +} + +/* + * 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;