X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ian/git?a=blobdiff_plain;f=midend.c;h=2f09bb528c7a9a1fb38e4262f21867b5f782326d;hb=db313b3948d27244dd7c34c2609c66d6204d8931;hp=3165df2e5d6c368d778bd0f55c8190bf6ed46686;hpb=af010d7283c4b9abbd610c93d9bc49d69e1eccfe;p=sgt-puzzles.git diff --git a/midend.c b/midend.c index 3165df2..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, **preset_encodings; - 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; @@ -94,6 +97,30 @@ 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; @@ -131,6 +158,8 @@ midend *midend_new(frontend *fe, const game *ourgame, 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; @@ -158,10 +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->preset_encodings = 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; @@ -209,31 +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->preset_encodings[i]); - } - sfree(me->presets); - sfree(me->preset_names); - sfree(me->preset_encodings); - } + midend_free_preset_menu(me, me->preset_menu); if (me->ui) me->ourgame->free_ui(me->ui); if (me->curparams) @@ -353,8 +384,27 @@ 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); @@ -454,6 +504,8 @@ 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); @@ -466,7 +518,7 @@ void midend_new_game(midend *me) int midend_can_undo(midend *me) { - return (me->statepos > 1); + return (me->statepos > 1 || me->newgame_undo_len); } int midend_can_redo(midend *me) @@ -474,8 +526,82 @@ 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, @@ -484,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; } @@ -574,6 +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->flash_pos = me->flash_time = 0.0F; midend_finish_move(me); midend_redraw(me); midend_set_timer(me); @@ -586,33 +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') { + 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') { + 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 == '\x13' && me->ourgame->can_solve) { + } 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') { + } else if (button == 'q' || button == 'Q' || button == '\x11' || + button == UI_QUIT) { ret = 0; goto done; } else @@ -924,40 +1088,177 @@ float *midend_colours(midend *me, int *ncolours) 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 *); - me->preset_encodings = sresize(me->preset_encodings, - 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); + + if (me->ourgame->validate_params(preset, TRUE)) { + /* Drop this one from the list. */ + me->ourgame->free_params(preset); + continue; + } - me->presets[me->npresets] = preset; - me->preset_names[me->npresets] = name; - me->preset_encodings[me->npresets] = - me->ourgame->encode_params(preset, TRUE);; - me->npresets++; + 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); @@ -967,57 +1268,27 @@ 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->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++; - } + e = dupstr(e); + preset_menu_add_from_user_env(me, me->preset_menu, e, TRUE); sfree(e); } } - return me->npresets; -} - -void midend_fetch_preset(midend *me, int n, - char **name, game_params **params) -{ - assert(n >= 0 && n < me->npresets); - *name = me->preset_names[n]; - *params = me->presets[n]; + /* + * 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; } int midend_which_preset(midend *me) @@ -1026,8 +1297,9 @@ int midend_which_preset(midend *me) int i, ret; ret = -1; - for (i = 0; i < me->npresets; i++) - if (!strcmp(encoding, me->preset_encodings[i])) { + for (i = 0; i < me->n_encoded_presets; i++) + if (me->encoded_presets[i] && + !strcmp(encoding, me->encoded_presets[i])) { ret = i; break; } @@ -1498,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); \ @@ -1627,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; @@ -1641,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; @@ -1731,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; @@ -1756,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 = (float)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; } } @@ -1807,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 @@ -1881,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; @@ -1930,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); @@ -1945,38 +2241,46 @@ 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