/* ScummVM - Graphic Adventure Engine * * ScummVM is the legal property of its developers, whose names * are too numerous to list here. Please refer to the COPYRIGHT * file distributed with this source distribution. * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * as published by the Free Software Foundation; either version 2 * of the License, or (at your option) any later version. * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. * * $URL$ * $Id$ * */ /* Savegame handling for EngineState structs. Makes heavy use of cfsml magic. */ /* DON'T EDIT savegame.cpp ! Only modify savegame.cfsml, if something needs ** to be changed. Refer to freesci/docs/misc/cfsml.spec if you don't understand ** savegame.cfsml. If this doesn't solve your problem, contact the maintainer. */ #include // FIXME: For struct tm #include "common/stream.h" #include "common/system.h" #include "sci/sci_memory.h" #include "sci/gfx/operations.h" #include "sci/gfx/menubar.h" #include "sci/gfx/gfx_state_internal.h" // required for gfxw_port_t, gfxw_container_t #include "sci/sfx/core.h" #include "sci/sfx/iterator.h" #include "sci/engine/state.h" #include "sci/engine/intmap.h" #ifdef _WIN32 #pragma warning( disable : 4101 ) #endif namespace Sci { #define HUNK_TYPE_GFX_SNAPSHOT_STRING "g\n" /* Missing: ** - SFXdriver ** - File input/output state (this is likely not to happen) */ const unsigned int PRINTFBUFLEN = 128; int WSprintf(Common::WriteStream* str, const char *format, ...) { va_list args; char buf[PRINTFBUFLEN]; // default buffer to prevent new in common case char* writebuf = buf; unsigned int s = PRINTFBUFLEN; unsigned int outsize; while (true) { va_start(args, format); outsize = vsnprintf(writebuf, s, format, args); va_end(args); if (outsize == s) { if (s > 16384) { // there are limits... delete[] writebuf; warning("Saving failed: line much too long"); return 0; } s *= 2; if (writebuf != buf) delete[] writebuf; writebuf = new char[s]; } else { break; } } uint32 ret = str->write(writebuf, outsize); if (writebuf != buf) delete[] writebuf; return ret; } int SRSgetc(Common::SeekableReadStream* str) { char c = str->readSByte(); if (str->err() || str->eos()) return EOF; return c; } char* SRSgets(char* s, int size, Common::SeekableReadStream* str) { return str->readLine_NEW(s, size); } static EngineState *_global_save_state; // Needed for some graphical stuff. #define FILE_VERSION _global_save_state->savegame_version void write_reg_t(Common::WriteStream *fh, reg_t const *foo) { WSprintf(fh, PREG, PRINT_REG(*foo)); } int read_reg_t(Common::SeekableReadStream *fh, reg_t *foo, const char *lastval, int *line, int *hiteof) { unsigned int segment, offset; if (sscanf(lastval, PREG, &segment, &offset) < 2) { sciprintf("Error parsing reg_t on line %d\n", *line); return 1; } *foo = make_reg(segment, offset); return 0; } void write_sci_version(Common::WriteStream *fh, sci_version_t const *foo) { WSprintf(fh, "%d.%03d.%03d", SCI_VERSION_MAJOR(*foo), SCI_VERSION_MINOR(*foo), SCI_VERSION_PATCHLEVEL(*foo)); } int read_sci_version(Common::SeekableReadStream *fh, sci_version_t *foo, const char *lastval, int *line, int *hiteof) { return version_parse(lastval, foo); } void write_PTN(Common::WriteStream *fh, parse_tree_node_t const *foo) { if (foo->type == PARSE_TREE_NODE_LEAF) WSprintf(fh, "L%d", foo->content.value); else WSprintf(fh, "B(%d,%d)", foo->content.branches[0], foo->content.branches[1]); } int read_PTN(Common::SeekableReadStream *fh, parse_tree_node_t *foo, const char *lastval, int *line, int *hiteof) { if (lastval[0] == 'L') { const char *c = lastval + 1; char *strend; while (*c && isspace(*c)) ++c; if (!*c) return 1; foo->content.value = strtol(c, &strend, 0); return (strend == c); // Error if nothing could be read return 0; } else if (lastval[0] == 'B') { const char *c = lastval + 1; char *strend; while (*c && isspace(*c)) ++c; if (*c++ != '(') return 1; while (*c && isspace(*c)) ++c; foo->content.branches[0] = strtol(c, &strend, 0); if (strend == c) return 1; c = strend; while (*c && isspace(*c)) ++c; if (*c++ != ',') return 1; while (*c && isspace(*c)) ++c; foo->content.branches[1] = strtol(c, &strend, 0); if (strend == c) return 1; c = strend; while (*c && isspace(*c)) ++c; if (*c++ != ')') return 1; return 0; } else return 1; // failure to parse anything } void write_CommonString(Common::WriteStream *fh, Common::String const *string); int read_CommonString(Common::SeekableReadStream *fh, Common::String *string, const char *lastval, int *line, int *hiteof); void write_menubar_tp(Common::WriteStream *fh, const menubar_t * const *foo); int read_menubar_tp(Common::SeekableReadStream *fh, menubar_t **foo, const char *lastval, int *line, int *hiteof); void write_MemObjPtr(Common::WriteStream *fh, const MemObject * const *foo); int read_MemObjPtr(Common::SeekableReadStream *fh, MemObject **foo, const char *lastval, int *line, int *hiteof); void write_songlib_t(Common::WriteStream *fh, songlib_t const *foo); int read_songlib_t(Common::SeekableReadStream *fh, songlib_t *foo, const char *lastval, int *line, int *hiteof); int read_song_tp(Common::SeekableReadStream *fh, song_t **foo, const char *lastval, int *line, int *hiteof); void write_IntMapperPtr(Common::WriteStream *fh, const IntMapper * const *foo); int read_IntMapperPtr(Common::SeekableReadStream *fh, IntMapper **foo, const char *lastval, int *line, int *hiteof); void write_IntMapperNodePtr(Common::WriteStream *fh, const IntMapper::Node * const *foo); int read_IntMapperNodePtr(Common::SeekableReadStream *fh, IntMapper::Node **foo, const char *lastval, int *line, int *hiteof); void write_SegManagerPtr(Common::WriteStream *fh, const SegManager * const *foo); int read_SegManagerPtr(Common::SeekableReadStream *fh, SegManager **foo, const char *lastval, int *line, int *hiteof); typedef MemObject *mem_obj_ptr; // Unused types /* TYPE long "long" LIKE int; TYPE int16 "int16" LIKE int; RECORD synonym_t "synonym_t" { int replaceant; int replacement; } */ %CFSML TYPE bool "bool" LIKE int; TYPE byte "byte" LIKE int; TYPE Common::String ""Common::String" USING write_CommonString read_CommonString; TYPE SegmentId "SegmentId" LIKE int; TYPE sci_version_t "sci_version_t" USING write_sci_version read_sci_version; TYPE menubar_tp "menubar_t *" USING write_menubar_tp read_menubar_tp; TYPE MemObject "MemObject" USING write_MemObject read_MemObject; TYPE mem_obj_ptr "MemObject *" USING write_MemObjPtr read_MemObjPtr; TYPE reg_t "reg_t" USING write_reg_t read_reg_t; TYPE size_t "size_t" LIKE int; TYPE IntMapperPtr "IntMapper *" USING write_IntMapperPtr read_IntMapperPtr; TYPE IntMapperNodePtr "IntMapper::Node *" USING write_IntMapperNodePtr read_IntMapperNodePtr; TYPE songlib_t "songlib_t" USING write_songlib_t read_songlib_t; TYPE song_tp "song_t *" USING write_song_tp read_song_tp; TYPE SongIterator "SongIterator" USING write_song_iterator_t read_song_iterator_t; TYPE song_handle_t "song_handle_t" LIKE int; TYPE SegManagerPtr "SegManager *" USING write_SegManagerPtr read_SegManagerPtr; RECORD song_t "song_t" { song_handle_t handle; int resource_num; int priority; int status; int restore_behavior; int restore_time; int loops; int hold; } RECORD IntMapper "IntMapper" { int base_value; IntMapperNodePtr nodes[STATIC DCS_INT_HASH_MAX]; } RECORD menu_item_t "menu_item_t" { int type; string keytext; int keytext_size; int flags; byte said[STATIC MENU_SAID_SPEC_SIZE]; reg_t said_pos; string text; reg_t text_pos; int modifiers; int key; int enabled; int tag; } RECORD menu_t "menu_t" { string title; int title_width; int width; menu_item_t items[DYNAMIC items_nr]; } RECORD menubar_t "menubar_t" { menu_t menus[DYNAMIC menus_nr]; } RECORD SegManager "SegManager" { IntMapperPtr id_seg_map; mem_obj_ptr heap[DYNAMIC heap_size]; int heap_size; int reserved_id; int exports_wide; int gc_mark_bits; size_t mem_allocated; SegmentId Clones_seg_id; SegmentId Lists_seg_id; SegmentId Nodes_seg_id; } RECORD Class "Class" { int script; reg_t reg; } RECORD sfx_state_t "sfx_state_t" { songlib_t songlib; } RECORD SavegameMetadata "SavegameMetadata" { Common::String savegame_name; int savegame_version; Common::String game_version; sci_version_t version; int savegame_date; int savegame_time; } RECORD EngineState "EngineState" { int savegame_version; string game_version; sci_version_t version; menubar_tp menubar; int status_bar_foreground; int status_bar_background; SegManagerPtr seg_manager; int classtable_size; Class classtable[DYNAMIC classtable_size]; sfx_state_t sound; } RECORD LocalVariables "LocalVariables" { int script_id; int nr; reg_t locals[DYNAMIC nr]; } RECORD Object "Object" { int flags; reg_t pos; int variables_nr; int variable_names_nr; int methods_nr; reg_t variables[DYNAMIC variables_nr]; } RECORD Clone "Clone" { int flags; reg_t pos; int variables_nr; int variable_names_nr; int methods_nr; reg_t variables[DYNAMIC variables_nr]; } RECORD List "List" { reg_t first; reg_t last; } RECORD Node "Node" { reg_t pred; reg_t succ; reg_t key; reg_t value; } RECORD CloneEntry "CloneEntry" { int next_free; Clone entry; } RECORD CloneTable "CloneTable" { int entries_nr; int first_free; int entries_used; int max_entry; CloneEntry table[DYNAMIC entries_nr]; } RECORD ListEntry "ListEntry" { int next_free; List entry; } RECORD ListTable "ListTable" { int entries_nr; int first_free; int entries_used; int max_entry; ListEntry table[DYNAMIC entries_nr]; } RECORD NodeEntry "NodeEntry" { int next_free; Node entry; } RECORD NodeTable "NodeTable" { int entries_nr; int first_free; int entries_used; int max_entry; NodeEntry table[DYNAMIC entries_nr]; } RECORD Script "Script" { int nr; size_t buf_size; size_t script_size; size_t heap_size; IntMapperPtr obj_indices; int exports_nr; int synonyms_nr; int lockers; int objects_allocated; int objects_nr; Object objects[DYNAMIC objects_allocated]; int locals_offset; int locals_segment; int marked_as_deleted; } RECORD SystemString "SystemString" { string name; int max_size; string value; } RECORD SystemStrings "SystemStrings" { SystemString strings[STATIC SYS_STRINGS_MAX]; } RECORD DynMem "DynMem" { int size; string description; byte buf[DYNAMIC size]; } %END CFSML void write_songlib_t(Common::WriteStream *fh, songlib_t const *songlib) { song_t *seeker = *(songlib->lib); int songcount = song_lib_count(*songlib); WSprintf(fh, "{\n"); WSprintf(fh, "songcount = %d\n", songcount); WSprintf(fh, "list = \n"); WSprintf(fh, "[\n"); while (seeker) { seeker->restore_time = seeker->it->getTimepos(); %CFSMLWRITE song_t seeker INTO fh; seeker = seeker->next; } WSprintf(fh, "]\n"); WSprintf(fh, "}\n"); } int read_songlib_t(Common::SeekableReadStream *fh, songlib_t *songlib, const char *lastval, int *line, int *hiteof) { int songcount; int i; song_t *newsong; if (strcmp(lastval, "{")) { _cfsml_error("Opening brackets expected at line %d\n", *line); return CFSML_FAILURE; } // FIXME: error checking Common::String l = fh->readLine(); sscanf(l.c_str(), "songcount = %d", &songcount); l = fh->readLine(); // "list = " l = fh->readLine(); // "[" *line += 4; song_lib_init(songlib); for (i = 0; i < songcount; i++) { %CFSMLREAD song_tp &newsong FROM fh ERRVAR *hiteof FIRSTTOKEN lastval LINECOUNTER *line; song_lib_add(*songlib, newsong); } l = fh->readLine(); // "]" l = fh->readLine(); // "}" *line += 2; return 0; } void write_song_tp(Common::WriteStream *fh, const song_t * const *foo) { %CFSMLWRITE song_t *foo INTO fh; } SongIterator *build_iterator(EngineState *s, int song_nr, int type, songit_id_t id); int read_song_tp(Common::SeekableReadStream *fh, song_t **foo, const char *lastval, int *line, int *hiteof) { char *token; int assignment; *foo = (song_t*) malloc(sizeof(song_t)); token = _cfsml_get_identifier(fh, line, hiteof, &assignment); %CFSMLREAD song_t (*foo) FROM fh ERRVAR *hiteof FIRSTTOKEN token LINECOUNTER *line; (*foo)->_delay = 0; (*foo)->it = NULL; (*foo)->next_playing = (*foo)->next_stopping = (*foo)->next = NULL; return 0; } void write_IntMapperPtr(Common::WriteStream *fh, const IntMapper * const *foo) { %CFSMLWRITE IntMapper *foo INTO fh; } int read_IntMapperPtr(Common::SeekableReadStream *fh, IntMapper **foo, const char *lastval, int *line, int *hiteof) { *foo = new IntMapper(); %CFSMLREAD IntMapper (*foo) FROM fh ERRVAR *hiteof FIRSTTOKEN lastval LINECOUNTER *line; (*foo)->holes = NULL; return 0; } void write_IntMapperNodePtr(Common::WriteStream *fh, const IntMapper::Node * const *foo) { if (!(*foo)) { WSprintf(fh, "\\null"); } else { WSprintf(fh,"[\n%d=>%d\n", (*foo)->key, (*foo)->idx); if ((*foo)->next) { %CFSMLWRITE IntMapperNodePtr &((*foo)->next) INTO fh; } else WSprintf(fh, "L"); WSprintf(fh, "]"); } } int read_IntMapperNodePtr(Common::SeekableReadStream *fh, IntMapper::Node **foo, const char *lastval, int *line, int *hiteof) { static char buffer[80]; if (lastval[0] == '\\') { *foo = NULL; // No hash map node } else { *foo = (IntMapper::Node*)malloc(sizeof(IntMapper::Node)); if (lastval[0] != '[') { sciprintf("Expected opening bracket in hash_map_node_t on line %d\n", *line); return 1; } do { (*line)++; SRSgets(buffer, 80, fh); if (buffer[0] == 'L') { (*foo)->next = NULL; buffer[0] = buffer[1]; } // HACK: deliberately no else clause here if (buffer[0] == ']') { break; } else if (buffer[0] == '[') { if (read_IntMapperNodePtr(fh, &((*foo)->next), buffer, line, hiteof)) return 1; } else if (sscanf(buffer, "%d=>%d", &((*foo)->key), &((*foo)->idx))<2) { sciprintf("Error parsing hash_map_node_t on line %d\n", *line); return 1; } } while (1); } return 0; } void write_menubar_tp(Common::WriteStream *fh, const menubar_t * const *foo) { if (*foo) { %CFSMLWRITE menubar_t (*foo) INTO fh; } else { // Nothing to write WSprintf(fh, "\\null\\"); } } int read_menubar_tp(Common::SeekableReadStream *fh, menubar_t **foo, const char *lastval, int *line, int *hiteof) { if (lastval[0] == '\\') { *foo = NULL; // No menu bar } else { *foo = (menubar_t *) sci_malloc(sizeof(menubar_t)); %CFSMLREAD menubar_t (*foo) FROM fh ERRVAR *hiteof FIRSTTOKEN lastval LINECOUNTER *line; } return *hiteof; } static struct { int type; const char *name; } mem_obj_string_names[] = { {MEM_OBJ_INVALID, "INVALID"}, {MEM_OBJ_SCRIPT, "SCRIPT"}, {MEM_OBJ_CLONES, "CLONES"}, {MEM_OBJ_LOCALS, "LOCALS"}, {MEM_OBJ_STACK, "STACK"}, {MEM_OBJ_SYS_STRINGS,"SYS_STRINGS"}, {MEM_OBJ_LISTS,"LISTS"}, {MEM_OBJ_NODES,"NODES"}, {MEM_OBJ_HUNK,"HUNK"}, {MEM_OBJ_DYNMEM,"DYNMEM"}, {MEM_OBJ_STRING_FRAG,"STRING_FRAGS"}, }; int mem_obj_string_to_enum(const char *str) { int i; for (i = 0; i <= MEM_OBJ_MAX; i++) { if (!scumm_stricmp(mem_obj_string_names[i].name, str)) return i; } return -1; } void write_MemObject(Common::WriteStream *fh, MemObject const *foo) { WSprintf(fh, "%s\n", mem_obj_string_names[foo->type].name); %CFSMLWRITE int &foo->segmgr_id INTO fh; switch (foo->type) { case MEM_OBJ_SCRIPT: %CFSMLWRITE Script &foo->data.script INTO fh; break; case MEM_OBJ_CLONES: %CFSMLWRITE CloneTable &foo->data.clones INTO fh; break; case MEM_OBJ_LOCALS: %CFSMLWRITE LocalVariables &foo->data.locals INTO fh; break; case MEM_OBJ_SYS_STRINGS: %CFSMLWRITE SystemStrings &foo->data.sys_strings INTO fh; break; case MEM_OBJ_STACK: %CFSMLWRITE int &foo->data.stack.nr INTO fh; break; case MEM_OBJ_HUNK: break; case MEM_OBJ_STRING_FRAG: break; case MEM_OBJ_LISTS: %CFSMLWRITE ListTable &foo->data.lists INTO fh; break; case MEM_OBJ_NODES: %CFSMLWRITE NodeTable &foo->data.nodes INTO fh; break; case MEM_OBJ_DYNMEM: %CFSMLWRITE DynMem &foo->data.dynmem INTO fh; break; default: break; } } int read_MemObject(Common::SeekableReadStream *fh, MemObject *foo, const char *lastval, int *line, int *hiteof) { foo->type = (memObjType)mem_obj_string_to_enum(lastval); if (foo->type < 0) { sciprintf("Unknown MemObject type %s on line %d\n", lastval, *line); return 1; } %CFSMLREAD int &foo->segmgr_id FROM fh ERRVAR *hiteof LINECOUNTER *line; switch (foo->type) { case MEM_OBJ_SCRIPT: %CFSMLREAD Script &foo->data.script FROM fh ERRVAR *hiteof LINECOUNTER *line; break; case MEM_OBJ_CLONES: %CFSMLREAD CloneTable &foo->data.clones FROM fh ERRVAR *hiteof LINECOUNTER *line; break; case MEM_OBJ_LOCALS: %CFSMLREAD LocalVariables &foo->data.locals FROM fh ERRVAR *hiteof LINECOUNTER *line; break; case MEM_OBJ_SYS_STRINGS: %CFSMLREAD SystemStrings &foo->data.sys_strings FROM fh ERRVAR *hiteof LINECOUNTER *line; break; case MEM_OBJ_LISTS: %CFSMLREAD ListTable &foo->data.lists FROM fh ERRVAR *hiteof LINECOUNTER *line; break; case MEM_OBJ_NODES: %CFSMLREAD NodeTable &foo->data.nodes FROM fh ERRVAR *hiteof LINECOUNTER *line; break; case MEM_OBJ_STACK: %CFSMLREAD int &foo->data.stack.nr FROM fh ERRVAR *hiteof LINECOUNTER *line; foo->data.stack.entries = (reg_t *)sci_calloc(foo->data.stack.nr, sizeof(reg_t)); break; case MEM_OBJ_HUNK: init_Hunk_table(&foo->data.hunks); break; case MEM_OBJ_STRING_FRAG: break; case MEM_OBJ_DYNMEM: %CFSMLREAD DynMem &foo->data.dynmem FROM fh ERRVAR *hiteof LINECOUNTER *line; break; default: break; } return *hiteof; } void write_MemObjPtr(Common::WriteStream *fh, const MemObject * const *foo) { if (*foo) { %CFSMLWRITE MemObject (*foo) INTO fh; } else { // Nothing to write WSprintf(fh, "\\null\\"); } } int read_MemObjPtr(Common::SeekableReadStream *fh, MemObject **foo, const char *lastval, int *line, int *hiteof) { if (lastval[0] == '\\') { *foo = NULL; // No menu bar } else { *foo = (MemObject *)sci_malloc(sizeof(MemObject)); %CFSMLREAD MemObject (*foo) FROM fh ERRVAR *hiteof FIRSTTOKEN lastval LINECOUNTER *line; return *hiteof; } return 0; } void write_CommonString(Common::WriteStream *fh, Common::String const *string) { const char *t = string->c_str(); %CFSMLWRITE string (&t) INTO fh; } int read_CommonString(Common::SeekableReadStream *fh, Common::String *string, const char *lastval, int *line, int *hiteof) { char *t; // Do an atomic read to prevent t from being freed if we hit an eof later %CFSMLREAD-ATOMIC string (&t) FROM fh ERRVAR *hiteof FIRSTTOKEN lastval LINECOUNTER *line; if (*hiteof) return *hiteof; *string = t; free(t); return 0; } void write_SegManagerPtr(Common::WriteStream *fh, const SegManager * const *foo) { %CFSMLWRITE bool &((*foo)->isSci1_1) INTO fh; %CFSMLWRITE SegManager *foo INTO fh; } int read_SegManagerPtr(Common::SeekableReadStream *fh, SegManager **foo, const char *lastval, int *line, int *hiteof) { char *token; int assignment; bool sci11; %CFSMLREAD bool (&sci11) FROM fh ERRVAR *hiteof FIRSTTOKEN lastval LINECOUNTER *line; *foo = new SegManager(sci11); token = _cfsml_get_identifier(fh, line, hiteof, &assignment); %CFSMLREAD SegManager (*foo) FROM fh ERRVAR *hiteof FIRSTTOKEN token LINECOUNTER *line; return 0; } // This function is called to undo some strange stuff done in preparation // to writing a gamestate to disk void _gamestate_unfrob(EngineState *s) { } int gamestate_save(EngineState *s, Common::WriteStream *fh, const char* savename) { tm curTime; g_system->getTimeAndDate(curTime); SavegameMetadata meta; meta.savegame_version = FREESCI_CURRENT_SAVEGAME_VERSION; meta.savegame_name = savename; meta.version = s->version; meta.game_version = s->game_version; meta.savegame_date = ((curTime.tm_mday & 0xFF) << 24) | (((curTime.tm_mon + 1) & 0xFF) << 16) | ((curTime.tm_year + 1900) & 0xFFFF); meta.savegame_time = ((curTime.tm_hour & 0xFF) << 16) | (((curTime.tm_min) & 0xFF) << 8) | ((curTime.tm_sec) & 0xFF); _global_save_state = s; s->savegame_version = FREESCI_CURRENT_SAVEGAME_VERSION; s->dyn_views_list_serial = (s->dyn_views)? s->dyn_views->serial : -2; s->drop_views_list_serial = (s->drop_views)? s->drop_views->serial : -2; s->port_serial = (s->port)? s->port->serial : -2; if (s->execution_stack_base) { sciprintf("Cannot save from below kernel function\n"); return 1; } /* if (s->sound_server) { if ((s->sound_server->save)(s, dirname)) { sciprintf("Saving failed for the sound subsystem\n"); chdir(".."); return 1; } } */ // Calculate the time spent with this game s->game_time = (g_system->getMillis() - s->game_start_time) / 1000; %CFSMLWRITE SavegameMetadata (&meta) INTO fh; %CFSMLWRITE EngineState s INTO fh; _gamestate_unfrob(s); return 0; } static SegmentId find_unique_seg_by_type(SegManager *self, int type) { int i; for (i = 0; i < self->heap_size; i++) if (self->heap[i] && self->heap[i]->type == type) return i; return -1; } static byte *find_unique_script_block(EngineState *s, byte *buf, int type) { int magic_pos_adder = s->version >= SCI_VERSION_FTU_NEW_SCRIPT_HEADER ? 0 : 2; buf += magic_pos_adder; do { int seeker_type = READ_LE_UINT16(buf); int seeker_size; if (seeker_type == 0) break; if (seeker_type == type) return buf; seeker_size = READ_LE_UINT16(buf + 2); buf += seeker_size; } while(1); return NULL; } static void reconstruct_stack(EngineState *retval) { SegmentId stack_seg = find_unique_seg_by_type(retval->seg_manager, MEM_OBJ_STACK); dstack_t *stack = &(retval->seg_manager->heap[stack_seg]->data.stack); retval->stack_segment = stack_seg; retval->stack_base = stack->entries; retval->stack_top = retval->stack_base + VM_STACK_SIZE; } static int clone_entry_used(CloneTable *table, int n) { int backup; int seeker = table->first_free; CloneEntry *entries = table->table; if (seeker == HEAPENTRY_INVALID) return 1; do { if (seeker == n) return 0; backup = seeker; seeker = entries[seeker].next_free; } while (entries[backup].next_free != HEAPENTRY_INVALID); return 1; } static void load_script(EngineState *s, SegmentId seg) { Resource *script, *heap = NULL; Script *scr = &(s->seg_manager->heap[seg]->data.script); scr->buf = (byte *)malloc(scr->buf_size); script = s->resmgr->findResource(kResourceTypeScript, scr->nr, 0); if (s->version >= SCI_VERSION(1,001,000)) heap = s->resmgr->findResource(kResourceTypeHeap, scr->nr, 0); switch (s->seg_manager->isSci1_1) { case 0 : s->seg_manager->mcpyInOut(0, script->data, script->size, seg, SEG_ID); break; case 1 : s->seg_manager->mcpyInOut(0, script->data, script->size, seg, SEG_ID); s->seg_manager->mcpyInOut(scr->script_size, heap->data, heap->size, seg, SEG_ID); break; } } static void reconstruct_scripts(EngineState *s, SegManager *self) { int i; MemObject *mobj; for (i = 0; i < self->heap_size; i++) { if (self->heap[i]) { mobj = self->heap[i]; switch (mobj->type) { case MEM_OBJ_SCRIPT: { int j; Script *scr = &mobj->data.script; load_script(s, i); scr->locals_block = scr->locals_segment == 0 ? NULL : &s->seg_manager->heap[scr->locals_segment]->data.locals; scr->export_table = (uint16 *) find_unique_script_block(s, scr->buf, sci_obj_exports); scr->synonyms = find_unique_script_block(s, scr->buf, sci_obj_synonyms); scr->code = NULL; scr->code_blocks_nr = 0; scr->code_blocks_allocated = 0; if (!self->isSci1_1) scr->export_table += 3; for (j = 0; j < scr->objects_nr; j++) { byte *data = scr->buf + scr->objects[j].pos.offset; scr->objects[j].base = scr->buf; scr->objects[j].base_obj = data; } break; } default: break; } } } for (i = 0; i < self->heap_size; i++) { if (self->heap[i]) { mobj = self->heap[i]; switch (mobj->type) { case MEM_OBJ_SCRIPT: { int j; Script *scr = &mobj->data.script; for (j = 0; j < scr->objects_nr; j++) { byte *data = scr->buf + scr->objects[j].pos.offset; if (self->isSci1_1) { uint16 *funct_area = (uint16 *) (scr->buf + READ_LE_UINT16( data + 6 )); uint16 *prop_area = (uint16 *) (scr->buf + READ_LE_UINT16( data + 4 )); scr->objects[j].base_method = funct_area; scr->objects[j].base_vars = prop_area; } else { int funct_area = READ_LE_UINT16( data + SCRIPT_FUNCTAREAPTR_OFFSET ); Object *base_obj; base_obj = obj_get(s, scr->objects[j].variables[SCRIPT_SPECIES_SELECTOR]); if (!base_obj) { sciprintf("Object without a base class: Script %d, index %d (reg address "PREG"\n", scr->nr, j, PRINT_REG(scr->objects[j].variables[SCRIPT_SPECIES_SELECTOR])); continue; } scr->objects[j].variable_names_nr = base_obj->variables_nr; scr->objects[j].base_obj = base_obj->base_obj; scr->objects[j].base_method = (uint16 *) (data + funct_area); scr->objects[j].base_vars = (uint16 *) (data + scr->objects[j].variable_names_nr * 2 + SCRIPT_SELECTOR_OFFSET); } } break; } default: break; } } } } void reconstruct_clones(EngineState *s, SegManager *self) { int i; MemObject *mobj; for (i = 0; i < self->heap_size; i++) { if (self->heap[i]) { mobj = self->heap[i]; switch (mobj->type) { case MEM_OBJ_CLONES: { int j; CloneEntry *seeker = mobj->data.clones.table; sciprintf("Free list: "); for (j = mobj->data.clones.first_free; j != HEAPENTRY_INVALID; j = mobj->data.clones.table[j].next_free) { sciprintf("%d ", j); } sciprintf("\n"); sciprintf("Entries w/zero vars: "); for (j = 0; j < mobj->data.clones.max_entry; j++) { if (mobj->data.clones.table[j].entry.variables == NULL) sciprintf("%d ", j); } sciprintf("\n"); for (j = 0; j < mobj->data.clones.max_entry; j++) { Object *base_obj; if (!clone_entry_used(&mobj->data.clones, j)) { seeker++; continue; } base_obj = obj_get(s, seeker->entry.variables[SCRIPT_SPECIES_SELECTOR]); if (!base_obj) { sciprintf("Clone entry without a base class: %d\n", j); seeker->entry.base = seeker->entry.base_obj = NULL; seeker->entry.base_vars = seeker->entry.base_method = NULL; continue; } seeker->entry.base = base_obj->base; seeker->entry.base_obj = base_obj->base_obj; seeker->entry.base_vars = base_obj->base_vars; seeker->entry.base_method = base_obj->base_method; seeker++; } break; } default: break; } } } } int _reset_graphics_input(EngineState *s); static void reconstruct_sounds(EngineState *s) { song_t *seeker; int it_type = s->resmgr->_sciVersion >= SCI_VERSION_01 ? SCI_SONG_ITERATOR_TYPE_SCI1 : SCI_SONG_ITERATOR_TYPE_SCI0; if (s->sound.songlib.lib) seeker = *(s->sound.songlib.lib); else { song_lib_init(&s->sound.songlib); seeker = NULL; } while (seeker) { SongIterator *base, *ff; int oldstatus; SongIteratorMessage msg; base = ff = build_iterator(s, seeker->resource_num, it_type, seeker->handle); if (seeker->restore_behavior == RESTORE_BEHAVIOR_CONTINUE) ff = new_fast_forward_iterator(base, seeker->restore_time); ff->init(); msg = SongIteratorMessage(seeker->handle, SIMSG_SET_LOOPS(seeker->loops)); songit_handle_message(&ff, msg); msg = SongIteratorMessage(seeker->handle, SIMSG_SET_HOLD(seeker->hold)); songit_handle_message(&ff, msg); oldstatus = seeker->status; seeker->status = SOUND_STATUS_STOPPED; seeker->it = ff; sfx_song_set_status(&s->sound, seeker->handle, oldstatus); seeker = seeker->next; } } void internal_stringfrag_strncpy(EngineState *s, reg_t *dest, reg_t *src, int len); EngineState *gamestate_restore(EngineState *s, Common::SeekableReadStream *fh) { int read_eof = 0; EngineState *retval; songlib_t temp; /* if (s->sound_server) { if ((s->sound_server->restore)(s, dirname)) { sciprintf("Restoring failed for the sound subsystem\n"); return NULL; } } */ retval = new EngineState(); retval->savegame_version = -1; _global_save_state = retval; retval->gfx_state = s->gfx_state; SavegameMetadata meta; %CFSMLREAD-ATOMIC SavegameMetadata (&meta) FROM fh ERRVAR read_eof; if (read_eof) return false; if ((meta.savegame_version < FREESCI_MINIMUM_SAVEGAME_VERSION) || (meta.savegame_version > FREESCI_CURRENT_SAVEGAME_VERSION)) { if (meta.savegame_version < FREESCI_MINIMUM_SAVEGAME_VERSION) sciprintf("Old savegame version detected- can't load\n"); else sciprintf("Savegame version is %d- maximum supported is %0d\n", meta.savegame_version, FREESCI_CURRENT_SAVEGAME_VERSION); return NULL; } // Backwards compatibility settings retval->dyn_views = NULL; retval->drop_views = NULL; retval->port = NULL; retval->save_dir_copy_buf = NULL; retval->sound_mute = s->sound_mute; retval->sound_volume = s->sound_volume; %CFSMLREAD-ATOMIC EngineState retval FROM fh ERRVAR read_eof; sfx_exit(&s->sound); _gamestate_unfrob(retval); // Set exec stack base to zero retval->execution_stack_base = 0; retval->execution_stack_pos = 0; // Now copy all current state information // Graphics and input state: retval->animation_delay = s->animation_delay; retval->animation_granularity = s->animation_granularity; retval->gfx_state = s->gfx_state; retval->resmgr = s->resmgr; temp = retval->sound.songlib; sfx_init(&retval->sound, retval->resmgr, s->sfx_init_flags); retval->sfx_init_flags = s->sfx_init_flags; song_lib_free(retval->sound.songlib); retval->sound.songlib = temp; _reset_graphics_input(retval); reconstruct_stack(retval); reconstruct_scripts(retval, retval->seg_manager); reconstruct_clones(retval, retval->seg_manager); retval->game_obj = s->game_obj; retval->script_000 = &retval->seg_manager->heap[script_get_segment(s, 0, SCRIPT_GET_DONT_LOAD)]->data.script; retval->gc_countdown = GC_INTERVAL - 1; retval->save_dir_copy = make_reg(s->sys_strings_segment, SYS_STRING_SAVEDIR); retval->save_dir_edit_offset = 0; retval->sys_strings_segment = find_unique_seg_by_type(retval->seg_manager, MEM_OBJ_SYS_STRINGS); retval->sys_strings = &(((MemObject *)(GET_SEGMENT(*retval->seg_manager, retval->sys_strings_segment, MEM_OBJ_SYS_STRINGS)))->data.sys_strings); // Restore system strings SystemString *str; // First, pad memory for (int i = 0; i < SYS_STRINGS_MAX; i++) { str = &retval->sys_strings->strings[i]; char *data = (char *) str->value; if (data) { str->value = (reg_t *)sci_malloc(str->max_size + 1); strcpy((char *)str->value, data); free(data); } } str = &retval->sys_strings->strings[SYS_STRING_SAVEDIR]; internal_stringfrag_strncpy(s, str->value, s->sys_strings->strings[SYS_STRING_SAVEDIR].value, str->max_size); str->value[str->max_size].segment = s->string_frag_segment; // Make sure to terminate str->value[str->max_size].offset &= 0xff00; // Make sure to terminate // Time state: retval->last_wait_time = g_system->getMillis(); retval->game_start_time = g_system->getMillis() - retval->game_time * 1000; // static parser information: retval->parser_rules = s->parser_rules; retval->parser_words_nr = s->parser_words_nr; retval->parser_words = s->parser_words; retval->_parserSuffixes = s->_parserSuffixes; retval->parser_branches_nr = s->parser_branches_nr; retval->parser_branches = s->parser_branches; // static VM/Kernel information: retval->_selectorNames = s->_selectorNames; retval->kernel_names_nr = s->kernel_names_nr; retval->kernel_names = s->kernel_names; retval->kfunct_table = s->kfunct_table; retval->kfunct_nr = s->kfunct_nr; retval->opcodes = s->opcodes; memcpy(&(retval->selector_map), &(s->selector_map), sizeof(selector_map_t)); retval->max_version = retval->version; retval->min_version = retval->version; retval->parser_base = make_reg(s->sys_strings_segment, SYS_STRING_PARSER_BASE); // Copy breakpoint information from current game instance retval->have_bp = s->have_bp; retval->bp_list = s->bp_list; retval->debug_mode = s->debug_mode; retval->kernel_opt_flags = 0; retval->have_mouse_flag = 1; retval->successor = NULL; retval->pic_priority_table = (int*)gfxop_get_pic_metainfo(retval->gfx_state); retval->game_name = sci_strdup(obj_get_name(retval, retval->game_obj)); retval->sound.it = NULL; retval->sound.flags = s->sound.flags; retval->sound.song = NULL; retval->sound.suspended = s->sound.suspended; retval->sound.debug = s->sound.debug; reconstruct_sounds(retval); return retval; } bool get_savegame_metadata(Common::SeekableReadStream* stream, SavegameMetadata* meta) { int read_eof = 0; %CFSMLREAD-ATOMIC SavegameMetadata meta FROM stream ERRVAR read_eof; if (read_eof) return false; if ((meta->savegame_version < FREESCI_MINIMUM_SAVEGAME_VERSION) || (meta->savegame_version > FREESCI_CURRENT_SAVEGAME_VERSION)) { if (meta->savegame_version < FREESCI_MINIMUM_SAVEGAME_VERSION) sciprintf("Old savegame version detected- can't load\n"); else sciprintf("Savegame version is %d- maximum supported is %0d\n", meta->savegame_version, FREESCI_CURRENT_SAVEGAME_VERSION); return false; } return true; } } // End of namespace Sci