/* ScummVM - Scumm Interpreter * Copyright (C) 2001/2002 The ScummVM project * * 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * * $Header$ * */ #include "stdafx.h" #include "simon/simon.h" #include "simon/intern.h" #include "sound/mididrv.h" #include "common/gameDetector.h" #include #include #ifdef _WIN32_WCE extern bool toolbar_drawn; extern bool draw_keyboard; #endif static const GameSpecificSettings simon1_settings = { 1, /* VGA_DELAY_BASE */ 1576 / 4, /* TABLE_INDEX_BASE */ 1460 / 4, /* TEXT_INDEX_BASE */ 1700 / 4, /* NUM_GAME_OFFSETS */ 64, /* NUM_VIDEO_OP_CODES */ 1000000, /* VGA_MEM_SIZE */ 50000, /* TABLES_MEM_SIZE */ 3624, /* NUM_VOICE_RESOURCES */ 141, /* NUM_EFFECT_RESOURCES */ 1316 / 4, /* MUSIC_INDEX_BASE */ 0, /* SOUND_INDEX_BASE */ "SIMON.GME", /* gme_filename */ "SIMON.WAV", /* wav_filename */ "SIMON.VOC", /* wav_filename2 */ "EFFECTS.VOC", /* effects_filename */ "GAMEPC", /* gamepc_filename */ }; static const GameSpecificSettings simon2win_settings = { 5, /* VGA_DELAY_BASE */ 1580 / 4, /* TABLE_INDEX_BASE */ 1500 / 4, /* TEXT_INDEX_BASE */ 2116 / 4, /* NUM_GAME_OFFSETS */ 75, /* NUM_VIDEO_OP_CODES */ 2000000, /* VGA_MEM_SIZE */ 100000, /* TABLES_MEM_SIZE */ 12256, /* NUM_VOICE_RESOURCES */ 0, 1128 / 4, /* MUSIC_INDEX_BASE */ 1660 / 4, /* SOUND_INDEX_BASE */ "SIMON2.GME", /* gme_filename */ "SIMON2.WAV", /* wav_filename */ NULL, "", "GSPTR30", /* gamepc_filename */ }; static const GameSpecificSettings simon2dos_settings = { 5, /* VGA_DELAY_BASE */ 1580 / 4, /* TABLE_INDEX_BASE */ 1500 / 4, /* TEXT_INDEX_BASE */ 2116 / 4, /* NUM_GAME_OFFSETS */ 75, /* NUM_VIDEO_OP_CODES */ 2000000, /* VGA_MEM_SIZE */ 100000, /* TABLES_MEM_SIZE */ 12256, /* NUM_VOICE_RESOURCES */ 0, 1128 / 4, /* MUSIC_INDEX_BASE */ 1660 / 4, /* SOUND_INDEX_BASE */ "SIMON2.GME", /* gme_filename */ "SIMON2.WAV", /* wav_filename */ NULL, "", "GAME32", /* gamepc_filename */ }; SimonState::SimonState(GameDetector *detector, OSystem *syst) : Engine(detector, syst) { MidiDriver *driver = detector->createMidi(); _dummy_item_1 = new Item(); _dummy_item_2 = new Item(); _dummy_item_3 = new Item(); _fcs_list = new FillOrCopyStruct[16]; /* Setup midi driver */ if (!driver) driver = MidiDriver_NULL_create(); midi.set_driver(driver); _game = detector->_gameId; /* Setup mixer */ if (!_mixer->bindToSystem(syst)) warning("Sound initialization failed. " "Features of the game that depend on sound synchronization will most likely break"); set_volume(detector->_sfx_volume); } SimonState::~SimonState() { delete _dummy_item_1; delete _dummy_item_2; delete _dummy_item_3; delete [] _fcs_list; } void palette_fadeout(uint32 *pal_values, uint num) { byte *p = (byte *)pal_values; do { if (p[0] >= 8) p[0] -= 8; else p[0] = 0; if (p[1] >= 8) p[1] -= 8; else p[1] = 0; if (p[2] >= 8) p[2] -= 8; else p[2] = 0; p += sizeof(uint32); } while (--num); } byte *SimonState::allocateItem(uint size) { byte *org = _itemheap_ptr; size = (size + 3) & ~3; _itemheap_ptr += size; _itemheap_curpos += size; if (_itemheap_curpos > _itemheap_size) error("Itemheap overflow"); return org; } void SimonState::alignTableMem() { if ((uint32)_tablesheap_ptr & 3) { _tablesheap_ptr += 2; _tablesheap_curpos += 2; } } byte *SimonState::allocateTable(uint size) { byte *org = _tablesheap_ptr; size = (size + 1) & ~1; _tablesheap_ptr += size; _tablesheap_curpos += size; if (_tablesheap_curpos > _tablesheap_size) error("Tablesheap overflow"); return org; } int SimonState::allocGamePcVars(File *in) { uint item_array_size, item_array_inited, stringtable_num; uint32 version; uint i; item_array_size = in->readDwordBE(); version = in->readDwordBE(); item_array_inited = in->readDwordBE(); stringtable_num = in->readDwordBE(); item_array_inited += 2; /* first two items are predefined */ item_array_size += 2; if (version != 0x80) error("Not a runtime database"); _itemarray_ptr = (Item **)calloc(item_array_size, sizeof(Item *)); if (_itemarray_ptr == NULL) error("Out of memory for Item array"); _itemarray_size = item_array_size; _itemarray_inited = item_array_inited; for (i = 2; i != item_array_inited; i++) { _itemarray_ptr[i] = (Item *)allocateItem(sizeof(Item)); } /* The rest is cleared automatically by calloc */ allocateStringTable(stringtable_num + 10); _stringtab_num = stringtable_num; return item_array_inited; } Item *SimonState::allocItem1() { Item *item = (Item *)allocateItem(sizeof(Item)); _itemarray_ptr[1] = item; return item; } void SimonState::loginPlayerHelper(Item *item, int a, int b) { Child9 *child; child = (Child9 *) findChildOfType(item, 9); if (child == NULL) { child = (Child9 *) allocateChildBlock(item, 9, sizeof(Child9)); } if (a >= 0 && a <= 3) child->array[a] = b; } void SimonState::loginPlayer() { Item *item; Child *child; item = _itemarray_ptr[1]; item->unk2 = -1; item->unk1 = 10000; _item_1 = item; child = (Child *)allocateChildBlock(item, 3, sizeof(Child)); if (child == NULL) error("player create failure"); loginPlayerHelper(item, 0, 0); } void SimonState::allocateStringTable(int num) { _stringtab_ptr = (byte **)calloc(num, sizeof(byte *)); _stringtab_pos = 0; _stringtab_numalloc = num; } void SimonState::setupStringTable(byte *mem, int num) { int i = 0; for (;;) { _stringtab_ptr[i++] = mem; if (--num == 0) break; for (; *mem; mem++); mem++; } _stringtab_pos = i; } void SimonState::setupLocalStringTable(byte *mem, int num) { int i = 0; for (;;) { _local_stringtable[i++] = mem; if (--num == 0) break; for (; *mem; mem++); mem++; } } void SimonState::readSubroutineLine(File *in, SubroutineLine *sl, Subroutine *sub) { byte line_buffer[1024], *q = line_buffer; int size; if (sub->id == 0) { sl->cond_a = in->readWordBE(); sl->cond_b = in->readWordBE(); sl->cond_c = in->readWordBE(); } while ((*q = in->readByte()) != 0xFF) { if (*q == 87) { in->readWordBE(); } else { q = readSingleOpcode(in, q); } } size = q - line_buffer + 1; memcpy(allocateTable(size), line_buffer, size); } SubroutineLine *SimonState::createSubroutineLine(Subroutine *sub, int where) { SubroutineLine *sl, *cur_sl = NULL, *last_sl = NULL; if (sub->id == 0) sl = (SubroutineLine *)allocateTable(SUBROUTINE_LINE_BIG_SIZE); else sl = (SubroutineLine *)allocateTable(SUBROUTINE_LINE_SMALL_SIZE); /* where is what offset to insert the line at, locate the proper beginning line */ if (sub->first != 0) { cur_sl = (SubroutineLine *)((byte *)sub + sub->first); while (where) { last_sl = cur_sl; cur_sl = (SubroutineLine *)((byte *)sub + cur_sl->next); if ((byte *)cur_sl == (byte *)sub) break; where--; } } if (last_sl != NULL) { /* Insert the subroutine line in the middle of the link */ last_sl->next = (byte *)sl - (byte *)sub; sl->next = (byte *)cur_sl - (byte *)sub; } else { /* Insert the subroutine line at the head of the link */ sl->next = sub->first; sub->first = (byte *)sl - (byte *)sub; } return sl; } void SimonState::readSubroutine(File *in, Subroutine *sub) { while (in->readWordBE() == 0) { readSubroutineLine(in, createSubroutineLine(sub, 0xFFFF), sub); } } Subroutine *SimonState::createSubroutine(uint id) { Subroutine *sub; alignTableMem(); sub = (Subroutine *)allocateTable(sizeof(Subroutine)); sub->id = id; sub->first = 0; sub->next = _subroutine_list; _subroutine_list = sub; return sub; } void SimonState::readSubroutineBlock(File *in) { while (in->readWordBE() == 0) { readSubroutine(in, createSubroutine(in->readWordBE())); } } Child *SimonState::findChildOfType(Item *i, uint type) { Child *child = i->children; for (; child; child = child->next) if (child->type == type) return child; return NULL; } bool SimonState::hasChildOfType1(Item *item) { return findChildOfType1(item) != NULL; } bool SimonState::hasChildOfType2(Item *item) { return findChildOfType2(item) != NULL; } Child1 *SimonState::findChildOfType1(Item *item) { return (Child1 *)findChildOfType(item, 1); } Child2 *SimonState::findChildOfType2(Item *item) { return (Child2 *)findChildOfType(item, 2); } Child3 *SimonState::findChildOfType3(Item *item) { return (Child3 *) findChildOfType(item, 3); } uint SimonState::getOffsetOfChild2Param(Child2 *child, uint prop) { uint m = 1; uint offset = 0; while (m != prop) { if (child->avail_props & m) offset++; m <<= 1; } return offset; } Child *SimonState::allocateChildBlock(Item *i, uint type, uint size) { Child *child = (Child *)allocateItem(size); child->next = i->children; i->children = child; child->type = type; return child; } void SimonState::allocItemHeap() { _itemheap_size = 10000; _itemheap_curpos = 0; _itemheap_ptr = (byte *)calloc(10000, 1); } void SimonState::allocTablesHeap() { _tablesheap_size = gss->TABLES_MEM_SIZE; _tablesheap_curpos = 0; _tablesheap_ptr = (byte *)calloc(gss->TABLES_MEM_SIZE, 1); } void SimonState::setItemUnk3(Item *item, int value) { item->unk3 = value; } int SimonState::getNextWord() { _code_ptr += 2; return (int16)((_code_ptr[-2] << 8) | _code_ptr[-1]); } uint SimonState::getNextStringID() { return (uint16)getNextWord(); } uint SimonState::getVarOrByte() { uint a = *_code_ptr++; if (a != 255) return a; return readVariable(*_code_ptr++); } uint SimonState::getVarOrWord() { uint a = (_code_ptr[0] << 8) | _code_ptr[1]; _code_ptr += 2; if (a >= 30000 && a < 30512) return readVariable(a - 30000); return a; } Item *SimonState::getNextItemPtr() { int a = getNextWord(); switch (a) { case -1: return _subject_item; case -3: return _object_item; case -5: return getItem1Ptr(); case -7: return getItemPtrB(); case -9: return derefItem(getItem1Ptr()->parent); default: return derefItem(a); } } Item *SimonState::getNextItemPtrStrange() { int a = getNextWord(); switch (a) { case -1: return _subject_item; case -3: return _object_item; case -5: return _dummy_item_2; case -7: return NULL; case -9: return _dummy_item_3; default: return derefItem(a); } } uint SimonState::getNextItemID() { int a = getNextWord(); switch (a) { case -1: return itemPtrToID(_subject_item); case -3: return itemPtrToID(_object_item); case -5: return getItem1ID(); case -7: return 0; case -9: return getItem1Ptr()->parent; default: return a; } } Item *SimonState::getItem1Ptr() { if (_item_1_ptr) return _item_1_ptr; return _dummy_item_1; } Item *SimonState::getItemPtrB() { error("getItemPtrB: is this code ever used?"); if (_item_ptr_B) return _item_ptr_B; return _dummy_item_1; } uint SimonState::getNextVarContents() { return (uint16)readVariable(getVarOrByte()); } uint SimonState::readVariable(uint variable) { if (variable >= 255) error("Variable %d out of range in read", variable); return _variableArray[variable]; } void SimonState::writeNextVarContents(uint16 contents) { writeVariable(getVarOrByte(), contents); } void SimonState::writeVariable(uint variable, uint16 contents) { if (variable >= 256) error("Variable %d out of range in write", variable); _variableArray[variable] = contents; } void SimonState::setItemParent(Item *item, Item *parent) { Item *old_parent = derefItem(item->parent); if (item == parent) error("Trying to set item as its own parent"); /* unlink it if it has a parent */ if (old_parent) unlinkItem(item); itemChildrenChanged(old_parent); linkItem(item, parent); itemChildrenChanged(parent); } void SimonState::itemChildrenChanged(Item *item) { int i; FillOrCopyStruct *fcs; if (_no_parent_notify) return; lock(); for (i = 0; i != 8; i++) { fcs = _fcs_ptr_array_3[i]; if (fcs && fcs->fcs_data && fcs->fcs_data->item_ptr == item) { if (_fcs_data_1[i]) { _fcs_data_2[i] = true; } else { _fcs_data_2[i] = false; fcs_unk_proc_1(i, item, fcs->fcs_data->unk1, fcs->fcs_data->unk2); } } } unlock(); } void SimonState::unlinkItem(Item *item) { Item *first, *parent, *next; /* cannot unlink item without parent */ if (item->parent == 0) return; /* get parent and first child of parent */ parent = derefItem(item->parent); first = derefItem(parent->child); /* the node to remove is first in the parent's children? */ if (first == item) { parent->child = item->sibling; item->parent = 0; item->sibling = 0; return; } for (;;) { if (!first) error("unlinkItem: parent empty"); if (first->sibling == 0) error("unlinkItem: parent does not contain child"); next = derefItem(first->sibling); if (next == item) { first->sibling = next->sibling; item->parent = 0; item->sibling = 0; return; } first = next; } } void SimonState::linkItem(Item *item, Item *parent) { uint id; /* Don't allow that an item that is already linked is relinked */ if (item->parent) return; id = itemPtrToID(parent); item->parent = id; if (parent != 0) { item->sibling = parent->child; parent->child = itemPtrToID(item); } else { item->sibling = 0; } } const byte *SimonState::getStringPtrByID(uint string_id) { const byte *string_ptr; byte *dst; _free_string_slot ^= 1; if (string_id < 0x8000) { string_ptr = _stringtab_ptr[string_id]; } else { string_ptr = getLocalStringByID(string_id); } dst = &_stringReturnBuffer[_free_string_slot][0]; strcpy((char *)dst, (const char *)string_ptr); return dst; } const byte *SimonState::getLocalStringByID(uint string_id) { if (string_id < _string_id_local_min || string_id >= _string_id_local_max) { loadTextIntoMem(string_id); } return _local_stringtable[string_id - _string_id_local_min]; } void SimonState::loadTextIntoMem(uint string_id) { byte *p; char filename[30]; int i; uint base_min = 0x8000, base_max, size; _tablesheap_ptr = _tablesheap_ptr_new; _tablesheap_curpos = _tablesheap_curpos_new; p = _stripped_txt_mem; /* get filename */ while (*p) { for (i = 0; *p; p++, i++) filename[i] = *p; filename[i] = 0; p++; base_max = (p[0] << 8) | p[1]; p += 2; if (string_id < base_max) { _string_id_local_min = base_min; _string_id_local_max = base_max; _local_stringtable = (byte **)_tablesheap_ptr; size = (base_max - base_min + 1) * sizeof(byte *); _tablesheap_ptr += size; _tablesheap_curpos += size; size = loadTextFile(filename, _tablesheap_ptr); setupLocalStringTable(_tablesheap_ptr, base_max - base_min + 1); _tablesheap_ptr += size; _tablesheap_curpos += size; if (_tablesheap_curpos > _tablesheap_size) { error("loadTextIntoMem: Out of table memory"); } return; } base_min = base_max; } error("loadTextIntoMem: didn't find %d", string_id); } void SimonState::loadTablesIntoMem(uint subr_id) { byte *p; int i; uint min_num, max_num; char filename[30]; File *in; p = _tbl_list; if (p == NULL) return; while (*p) { for (i = 0; *p; p++, i++) filename[i] = *p; filename[i] = 0; p++; for (;;) { min_num = (p[0] << 8) | p[1]; p += 2; if (min_num == 0) break; max_num = (p[0] << 8) | p[1]; p += 2; if (subr_id >= min_num && subr_id <= max_num) { _subroutine_list = _subroutine_list_org; _tablesheap_ptr = _tablesheap_ptr_org; _tablesheap_curpos = _tablesheap_curpos_org; _string_id_local_min = 1; _string_id_local_max = 0; in = openTablesFile(filename); readSubroutineBlock(in); closeTablesFile(in); memcpy(filename, "SFXXXX", 6); readSfxFile(filename); alignTableMem(); _tablesheap_ptr_new = _tablesheap_ptr; _tablesheap_curpos_new = _tablesheap_curpos; if (_tablesheap_curpos > _tablesheap_size) error("loadTablesIntoMem: Out of table memory"); return; } } } warning("loadTablesIntoMem: didn't find %d", subr_id); } Subroutine *SimonState::getSubroutineByID(uint subroutine_id) { Subroutine *cur; for (cur = _subroutine_list; cur; cur = cur->next) { if (cur->id == subroutine_id) return cur; } loadTablesIntoMem(subroutine_id); for (cur = _subroutine_list; cur; cur = cur->next) { if (cur->id == subroutine_id) return cur; } warning("getSubroutineByID: subroutine %d not found", subroutine_id); return NULL; } uint SimonState::loadTextFile_gme(const char *filename, byte *dst) { uint res; uint32 offs; uint32 size; res = atoi(filename + 4) + gss->TEXT_INDEX_BASE - 1; offs = _game_offsets_ptr[res]; size = _game_offsets_ptr[res + 1] - offs; resfile_read(dst, offs, size); return size; } File *SimonState::openTablesFile_gme(const char *filename) { uint res; uint32 offs; res = atoi(filename + 6) + gss->TABLE_INDEX_BASE - 1; offs = _game_offsets_ptr[res]; _game_file->seek(offs, SEEK_SET); return _game_file; } void SimonState::closeTablesFile_gme(File *in) { /* not needed */ } /* Simon1DOS load tables file */ uint SimonState::loadTextFile_simon1(const char *filename, byte *dst) { File fo; fo.open(filename, _gameDataPath); uint32 size; if (fo.isOpen() == false) error("loadTextFile: Cannot open '%s'", filename); fo.seek(0, SEEK_END); size = fo.pos(); fo.seek(0, SEEK_SET); if (fo.read(dst, size) != size) error("loadTextFile: fread failed"); fo.close(); return size; } File *SimonState::openTablesFile_simon1(const char *filename) { File *fo = new File(); fo->open(filename, _gameDataPath); if (fo->isOpen() == false) error("openTablesFile: Cannot open '%s'", filename); return fo; } void SimonState::closeTablesFile_simon1(File *in) { in->close(); } uint SimonState::loadTextFile(const char *filename, byte *dst) { if (_game == GAME_SIMON1DOS) return loadTextFile_simon1(filename, dst); else return loadTextFile_gme(filename, dst); } File *SimonState::openTablesFile(const char *filename) { if (_game == GAME_SIMON1DOS) return openTablesFile_simon1(filename); else return openTablesFile_gme(filename); } void SimonState::closeTablesFile(File *in) { if (_game == GAME_SIMON1DOS) closeTablesFile_simon1(in); else closeTablesFile_gme(in); } void SimonState::addTimeEvent(uint timeout, uint subroutine_id) { TimeEvent *te = (TimeEvent *)malloc(sizeof(TimeEvent)), *first, *last = NULL; time_t cur_time; time(&cur_time); te->time = cur_time + timeout - _base_time; te->subroutine_id = subroutine_id; first = _first_time_struct; while (first) { if (te->time <= first->time) { if (last) { last->next = te; te->next = first; return; } te->next = _first_time_struct; _first_time_struct = te; return; } last = first; first = first->next; } if (last) { last->next = te; te->next = NULL; } else { _first_time_struct = te; te->next = NULL; } } void SimonState::delTimeEvent(TimeEvent *te) { TimeEvent *cur; if (te == _pending_delete_time_event) _pending_delete_time_event = NULL; if (te == _first_time_struct) { _first_time_struct = te->next; free(te); return; } cur = _first_time_struct; if (cur == NULL) error("delTimeEvent: none available"); for (;;) { if (cur->next == NULL) error("delTimeEvent: no such te"); if (te == cur->next) { cur->next = te->next; free(te); return; } cur = cur->next; } } void SimonState::killAllTimers() { TimeEvent *cur, *next; for (cur = _first_time_struct; cur; cur = next) { next = cur->next; delTimeEvent(cur); } } bool SimonState::kickoffTimeEvents() { time_t cur_time; TimeEvent *te; bool result = false; time(&cur_time); cur_time -= _base_time; while ((te = _first_time_struct) != NULL && te->time <= (uint32)cur_time) { result = true; _pending_delete_time_event = te; invokeTimeEvent(te); if (_pending_delete_time_event) { _pending_delete_time_event = NULL; delTimeEvent(te); } } return result; } void SimonState::invokeTimeEvent(TimeEvent *te) { Subroutine *sub; _script_cond_a = 0; if (_run_script_return_1) return; sub = getSubroutineByID(te->subroutine_id); if (sub != NULL) startSubroutineEx(sub); _run_script_return_1 = false; } void SimonState::o_setup_cond_c() { Item *item = _item_1; setup_cond_c_helper(); _item_1_ptr = item; _object_item = _hitarea_object_item; if (_object_item == _dummy_item_2) _object_item = getItem1Ptr(); if (_object_item == _dummy_item_3) _object_item = derefItem(getItem1Ptr()->parent); if (_object_item != NULL) { _script_cond_c = _object_item->unk1; } else { _script_cond_c = -1; } } void SimonState::setup_cond_c_helper() { HitArea *last; if ((_game == GAME_SIMON2WIN) || (_game == GAME_SIMON2DOS)) { _mouse_cursor = 0; if (_hitarea_unk_4 != 999) { _mouse_cursor = 9; _need_hitarea_recalc++; _hitarea_unk_4 = 0; } } _last_hitarea = 0; _hitarea_object_item = NULL; _hitarea_unk_6 = true; last = _last_hitarea_2_ptr; defocusHitarea(); _last_hitarea_2_ptr = last; for (;;) { _last_hitarea = NULL; _last_hitarea_3 = 0; _left_button_down = 0; do { #ifdef WIN32 if (GetAsyncKeyState(VK_F5) != 0 && _bit_array[0] & 0x200) { #else if (_bit_array[0] & 0x200) { #endif startSubroutine170(); goto out_of_here; } delay(100); } while (_last_hitarea_3 == (HitArea *) 0xFFFFFFFF || _last_hitarea_3 == 0); if (_last_hitarea == NULL) { } else if (_last_hitarea->id == 0x7FFB) { handle_unk2_hitarea(_last_hitarea->fcs); } else if (_last_hitarea->id == 0x7FFC) { handle_unk_hitarea(_last_hitarea->fcs); } else if (_last_hitarea->item_ptr != NULL) { _hitarea_object_item = _last_hitarea->item_ptr; _variableArray[60] = (_last_hitarea->flags & 1) ? (_last_hitarea->flags >> 8) : 0xFFFF; break; } } out_of_here: _last_hitarea_3 = 0; _last_hitarea = 0; _last_hitarea_2_ptr = NULL; _hitarea_unk_6 = false; } void SimonState::startSubroutine170() { Subroutine *sub; /* XXX: stop speech */ sub = getSubroutineByID(170); if (sub != NULL) startSubroutineEx(sub); _run_script_return_1 = true; } uint SimonState::get_fcs_ptr_3_index(FillOrCopyStruct *fcs) { uint i; for (i = 0; i != ARRAYSIZE(_fcs_ptr_array_3); i++) if (_fcs_ptr_array_3[i] == fcs) return i; error("get_fcs_ptr_3_index: not found"); } void SimonState::lock() { _lock_counter++; } void SimonState::unlock() { _lock_word |= 1; if (_lock_counter != 0) { if (_lock_counter == 1) { #ifdef WIN32 GetAsyncKeyState(VK_LBUTTON); #endif } _lock_counter--; } _lock_word &= ~1; } void SimonState::handle_mouse_moved() { uint x; if (_lock_counter) return; pollMouseXY(); if (_mouse_x >= 32768) _mouse_x = 0; if (_mouse_x >= 638 / 2) _mouse_x = 638 / 2; if (_mouse_y >= 32768) _mouse_y = 0; if (_mouse_y >= 199) _mouse_y = 199; if (_hitarea_unk_4) { uint id = 101; if (_mouse_y >= 136) id = 102; if (_hitarea_unk_4 != id) hitarea_proc_1(); } if (_game & GAME_SIMON2) { if (_bit_array[4] & 0x8000) { if (!_vga_var9) { if (_mouse_x >= 630 / 2 || _mouse_x < 9) goto get_out2; _vga_var9 = 1; } if (_vga_var2 == 0) { if (_mouse_x >= 631 / 2) { if (_x_scroll != _vga_var1) _vga_var3 = 1; } else if (_mouse_x < 8) { if (_x_scroll != 0) _vga_var3 = -1; } } } else { get_out2:; _vga_var9 = 0; } } if (_mouse_x != _mouse_x_old || _mouse_y != _mouse_y_old) _need_hitarea_recalc++; x = 0; if (_last_hitarea_3 == 0 && _left_button_down != 0) { _left_button_down = 0; x = 1; } else { if (_hitarea_unk_3 == 0 && _need_hitarea_recalc == 0) goto get_out; } setup_hitarea_from_pos(_mouse_x, _mouse_y, x); _last_hitarea_3 = _last_hitarea; if (x == 1 && _last_hitarea == NULL) _last_hitarea_3 = (HitArea *) - 1; get_out: draw_mouse_pointer(); _need_hitarea_recalc = 0; } void SimonState::fcs_unk_proc_1(uint fcs_index, Item *item_ptr, int unk1, int unk2) { Item *item_ptr_org = item_ptr; FillOrCopyStruct *fcs_ptr; uint width_div_3, height_div_3; uint j, k, i, num_sibs_with_flag; bool item_again; uint x_pos, y_pos; fcs_ptr = _fcs_ptr_array_3[fcs_index & 7]; if (!(_game & GAME_SIMON2)) { width_div_3 = fcs_ptr->width / 3; height_div_3 = fcs_ptr->height / 3; } else { width_div_3 = 100; height_div_3 = 40; } i = 0; if (fcs_ptr == NULL) return; if (fcs_ptr->fcs_data) fcs_unk1(fcs_index); fcs_ptr->fcs_data = (FillOrCopyData *) malloc(sizeof(FillOrCopyData)); fcs_ptr->fcs_data->item_ptr = item_ptr; fcs_ptr->fcs_data->unk3 = -1; fcs_ptr->fcs_data->unk4 = -1; fcs_ptr->fcs_data->unk1 = unk1; fcs_ptr->fcs_data->unk2 = unk2; item_ptr = derefItem(item_ptr->child); while (item_ptr && unk1-- != 0) { num_sibs_with_flag = 0; while (item_ptr && width_div_3 > num_sibs_with_flag) { if ((unk2 == 0 || item_ptr->unk4 & unk2) && has_item_childflag_0x10(item_ptr)) if (!(_game & GAME_SIMON2)) { num_sibs_with_flag++; } else { num_sibs_with_flag += 20; } item_ptr = derefItem(item_ptr->sibling); } } if (item_ptr == NULL) { fcs_ptr->fcs_data->unk1 = 0; item_ptr = derefItem(item_ptr_org->child); } x_pos = 0; y_pos = 0; item_again = false; k = 0; j = 0; while (item_ptr) { if ((unk2 == 0 || item_ptr->unk4 & unk2) && has_item_childflag_0x10(item_ptr)) { if (item_again == false) { fcs_ptr->fcs_data->e[k].item = item_ptr; if (!(_game & GAME_SIMON2)) { draw_icon_c(fcs_ptr, item_get_icon_number(item_ptr), x_pos * 3, y_pos); fcs_ptr->fcs_data->e[k].hit_area = setup_icon_hit_area(fcs_ptr, x_pos * 3, y_pos, item_get_icon_number(item_ptr), item_ptr); } else { draw_icon_c(fcs_ptr, item_get_icon_number(item_ptr), x_pos, y_pos); fcs_ptr->fcs_data->e[k].hit_area = setup_icon_hit_area(fcs_ptr, x_pos, y_pos, item_get_icon_number(item_ptr), item_ptr); } k++; } else { fcs_ptr->fcs_data->e[k].item = NULL; j = 1; } x_pos += (_game & GAME_SIMON2) ? 20 : 1; if (x_pos >= width_div_3) { x_pos = 0; y_pos += (_game & GAME_SIMON2) ? 20 : 1; if (y_pos >= height_div_3) item_again = true; } } item_ptr = derefItem(item_ptr->sibling); } fcs_ptr->fcs_data->e[k].item = NULL; if (j != 0 || fcs_ptr->fcs_data->unk1 != 0) { fcs_unk_proc_2(fcs_ptr, fcs_index); } } void SimonState::fcs_unk_proc_2(FillOrCopyStruct *fcs, uint fcs_index) { setup_hit_areas(fcs, fcs_index); fcs->fcs_data->unk3 = _scroll_up_hit_area; fcs->fcs_data->unk4 = _scroll_down_hit_area; } void SimonState::setup_hit_areas(FillOrCopyStruct *fcs, uint fcs_index) { HitArea *ha; ha = findEmptyHitArea(); _scroll_up_hit_area = ha - _hit_areas; if (!(_game & GAME_SIMON2)) { ha->x = 308; ha->y = 149; ha->width = 12; ha->height = 17; ha->flags = 0x24; ha->id = 0x7FFB; ha->layer = 100; ha->fcs = fcs; ha->unk3 = 1; } else { ha->x = 81; ha->y = 158; ha->width = 12; ha->height = 26; ha->flags = 36; ha->id = 0x7FFB; ha->layer = 100; ha->fcs = fcs; ha->unk3 = 1; } ha = findEmptyHitArea(); _scroll_down_hit_area = ha - _hit_areas; if (!(_game & GAME_SIMON2)) { ha->x = 308; ha->y = 176; ha->width = 12; ha->height = 17; ha->flags = 0x24; ha->id = 0x7FFC; ha->layer = 100; ha->fcs = fcs; ha->unk3 = 1; /* Simon1 specific */ o_unk_99_simon1(0x80); start_vga_code(0, 1, 0x80, 0, 0, 0xE); } else { ha->x = 227; ha->y = 162; ha->width = 12; ha->height = 26; ha->flags = 36; ha->id = 0x7FFC; ha->layer = 100; ha->fcs = fcs; ha->unk3 = 1; } } bool SimonState::has_item_childflag_0x10(Item *item) { Child2 *child = findChildOfType2(item); return child && (child->avail_props & 0x10) != 0; } uint SimonState::item_get_icon_number(Item *item) { Child2 *child = findChildOfType2(item); uint offs; if (child == NULL || !(child->avail_props & 0x10)) return 0; offs = getOffsetOfChild2Param(child, 0x10); return child->array[offs]; } void SimonState::loadIconFile() { File in; in.open("ICON.DAT", _gameDataPath); uint size; if (in.isOpen() == false) error("Cannot open icon.dat"); in.seek(0, SEEK_END); size = in.pos(); _icon_file_ptr = (byte *)malloc(size); if (_icon_file_ptr == NULL) error("Out of icon memory"); in.seek(0, SEEK_SET); in.read(_icon_file_ptr, size); in.close(); } uint SimonState::setup_icon_hit_area(FillOrCopyStruct *fcs, uint x, uint y, uint icon_number, Item *item_ptr) { HitArea *ha; ha = findEmptyHitArea(); if (!(_game & GAME_SIMON2)) { ha->x = (x + fcs->x) << 3; ha->y = y * 25 + fcs->y; ha->item_ptr = item_ptr; ha->width = 24; ha->height = 24; ha->flags = 0xB0; ha->id = 0x7FFD; ha->layer = 100; ha->unk3 = 0xD0; } else { ha->x = x + 110; ha->y = fcs->y + y; ha->item_ptr = item_ptr; ha->width = 20; ha->height = 20; ha->flags = 0xB0; ha->id = 0x7FFD; ha->layer = 100; ha->unk3 = 0xD0; } return ha - _hit_areas; } void SimonState::hitarea_stuff() { HitArea *ha; uint id; _left_button_down = 0; _last_hitarea = 0; _verb_hitarea = 0; _hitarea_subject_item = NULL; _hitarea_object_item = NULL; hitarea_proc_1(); startOver: for (;;) { _last_hitarea = NULL; _last_hitarea_3 = NULL; for (;;) { processSpecialKeys(); if (_last_hitarea_3 == (HitArea *) 0xFFFFFFFF) goto startOver; if (_last_hitarea_3 != 0) break; hitarea_stuff_helper(); delay(100); } ha = _last_hitarea; if (ha == NULL) { } else if (ha->id == 0x7FFB) { handle_unk2_hitarea(ha->fcs); } else if (ha->id == 0x7FFC) { handle_unk_hitarea(ha->fcs); } else if (ha->id >= 101 && ha->id < 113) { _verb_hitarea = ha->unk3; handle_verb_hitarea(ha); _hitarea_unk_4 = 0; } else { if ((_verb_hitarea != 0 || _hitarea_subject_item != ha->item_ptr && ha->flags & 0x80) && ha->item_ptr) { if_1:; _hitarea_subject_item = ha->item_ptr; id = 0xFFFF; if (ha->flags & 1) id = ha->flags >> 8; _variableArray[60] = id; new_current_hitarea(ha); if (_verb_hitarea != 0) break; } else { /* else 1 */ if (ha->unk3 == 0) { if (ha->item_ptr) goto if_1; } else { _verb_hitarea = ha->unk3 & 0xBFFF; if (ha->unk3 & 0x4000) { _hitarea_subject_item = ha->item_ptr; break; } if (_hitarea_subject_item != NULL) break; } } } } _need_hitarea_recalc++; } void SimonState::hitarea_stuff_helper() { time_t cur_time; if (!(_game & GAME_SIMON2)) { uint subr_id = _variableArray[0x1FC / 2]; if (subr_id != 0) { Subroutine *sub = getSubroutineByID(subr_id); if (sub != NULL) { startSubroutineEx(sub); startUp_helper_2(); } _variableArray[0x1FC / 2] = 0; _run_script_return_1 = false; } } else { if (_variableArray[0x1FC / 2] || _variableArray[0x1F2 / 2]) { hitarea_stuff_helper_2(); } } time(&cur_time); if ((uint) cur_time != _last_time) { _last_time = cur_time; if (kickoffTimeEvents()) startUp_helper_2(); } } /* Simon 2 specific */ void SimonState::hitarea_stuff_helper_2() { uint subr_id; Subroutine *sub; subr_id = _variableArray[0x1F2 / 2]; if (subr_id != 0) { sub = getSubroutineByID(subr_id); if (sub != NULL) { _variableArray[0x1F2 / 2] = 0; startSubroutineEx(sub); startUp_helper_2(); } _variableArray[0x1F2 / 2] = 0; } subr_id = _variableArray[0x1FC / 2]; if (subr_id != 0) { sub = getSubroutineByID(subr_id); if (sub != NULL) { _variableArray[0x1FC / 2] = 0; startSubroutineEx(sub); startUp_helper_2(); } _variableArray[0x1FC / 2] = 0; } _run_script_return_1 = false; } void SimonState::startUp_helper_2() { if (!_mortal_flag) { _mortal_flag = true; startUp_helper_3(); _fcs_unk_1 = 0; if (_fcs_ptr_array_3[0] != 0) { _fcs_ptr_1 = _fcs_ptr_array_3[0]; showmessage_helper_3(_fcs_ptr_1->textLength, _fcs_ptr_1->textMaxLength); } _mortal_flag = false; } } void SimonState::startUp_helper_3() { showmessage_print_char(0); } void SimonState::showmessage_helper_3(uint a, uint b) { _print_char_unk_1 = a; _print_char_unk_2 = b; _num_letters_to_print = 0; } void SimonState::pollMouseXY() { _mouse_x = _sdl_mouse_x; _mouse_y = _sdl_mouse_y; } void SimonState::handle_verb_clicked(uint verb) { Subroutine *sub; int result; _item_1_ptr = _item_1; _object_item = _hitarea_object_item; if (_object_item == _dummy_item_2) { _object_item = getItem1Ptr(); } if (_object_item == _dummy_item_3) { _object_item = derefItem(getItem1Ptr()->parent); } _subject_item = _hitarea_subject_item; if (_subject_item == _dummy_item_2) { _subject_item = getItem1Ptr(); } if (_subject_item == _dummy_item_3) { _subject_item = derefItem(getItem1Ptr()->parent); } if (_subject_item) { _script_cond_b = _subject_item->unk1; } else { _script_cond_b = -1; } if (_object_item) { _script_cond_c = _object_item->unk1; } else { _script_cond_c = -1; } _script_cond_a = _verb_hitarea; sub = getSubroutineByID(0); if (sub == NULL) return; result = startSubroutine(sub); if (result == -1) showMessageFormat("I don't understand"); _run_script_return_1 = false; sub = getSubroutineByID(100); if (sub) startSubroutine(sub); if (_game & GAME_SIMON2) _run_script_return_1 = false; startUp_helper_2(); } void SimonState::o_print_str() { uint num_1 = getVarOrByte(); uint num_2 = getVarOrByte(); uint string_id = getNextStringID(); const byte *string_ptr = NULL; uint speech_id = 0; ThreeValues *tv; switch (_game) { case GAME_SIMON1WIN: if (string_id != 0xFFFF) string_ptr = getStringPtrByID(string_id); speech_id = (uint16)getNextWord(); break; case GAME_SIMON2WIN: if (string_id != 0xFFFF) string_ptr = getStringPtrByID(string_id); speech_id = (uint16)getNextWord(); break; case GAME_SIMON2DOS: if (string_id != 0xFFFF) string_ptr = getStringPtrByID(string_id); speech_id = (uint16)getNextWord(); break; case GAME_SIMON1DOS: string_ptr = getStringPtrByID(string_id); break; } switch (num_1) { case 1: tv = &_threevalues_1; break; case 2: tv = &_threevalues_2; break; case 101: tv = &_threevalues_3; break; case 102: tv = &_threevalues_4; break; default: error("o_print_str, invalid value %d", num_1); } switch (_game) { case GAME_SIMON1WIN: #ifdef USE_TEXT_HACK if (speech_id != 0) { if (string_ptr == NULL) talk_with_speech(speech_id, num_1); else if (speech_id != 9999) playVoice(speech_id); } if (string_ptr != NULL) { talk_with_text(num_1, num_2, (char *)string_ptr, tv->a, tv->b, tv->c); } #else if (speech_id != 0) { talk_with_speech(speech_id, num_1); } else if (string_ptr != NULL) { talk_with_text(num_1, num_2, (char *)string_ptr, tv->a, tv->b, tv->c); } #endif break; case GAME_SIMON1DOS: talk_with_text(num_1, num_2, (char *)string_ptr, tv->a, tv->b, tv->c); break; case GAME_SIMON2DOS: if (speech_id != 0 && num_1 == 1 && !_vk_t_toggle) talk_with_speech(speech_id, num_1); if (speech_id != 0 && !_vk_t_toggle) return; if (speech_id == 0) o_unk_99_simon2(2, num_1 + 2); talk_with_text(num_1, num_2, (char *)string_ptr, tv->a, tv->b, tv->c); break; case GAME_SIMON2WIN: if (speech_id != 0 && num_1 == 1 && !_vk_t_toggle) talk_with_speech(speech_id, num_1); if (speech_id != 0 && !_vk_t_toggle) return; if (speech_id == 0) o_unk_99_simon2(2, num_1 + 2); talk_with_text(num_1, num_2, (char *)string_ptr, tv->a, tv->b, tv->c); break; } } void SimonState::ensureVgaResLoadedC(uint vga_res) { _lock_word |= 0x80; ensureVgaResLoaded(vga_res); _lock_word &= ~0x80; } void SimonState::ensureVgaResLoaded(uint vga_res) { VgaPointersEntry *vpe; CHECK_BOUNDS(vga_res, _vga_buffer_pointers); vpe = _vga_buffer_pointers + vga_res; if (vpe->vgaFile1 != NULL) return; vpe->vgaFile2 = read_vga_from_datfile_2(vga_res * 2 + 1); vpe->vgaFile1 = read_vga_from_datfile_2(vga_res * 2); } byte *SimonState::setup_vga_destination(uint32 size) { byte *dest, *end; _video_var_4 = 0; for (;;) { dest = _vga_buf_free_start; end = dest + size; if (end >= _vga_buf_end) { _vga_buf_free_start = _vga_buf_start; } else { _video_var_5 = false; vga_buf_unk_proc3(end); if (_video_var_5) continue; vga_buf_unk_proc1(end); if (_video_var_5) continue; delete_memptr_range(end); _vga_buf_free_start = end; return dest; } } } void SimonState::setup_vga_file_buf_pointers() { byte *alloced; alloced = (byte *)malloc(gss->VGA_MEM_SIZE); _vga_buf_free_start = alloced; _vga_buf_start = alloced; _vga_file_buf_org = alloced; _vga_file_buf_org_2 = alloced; _vga_buf_end = alloced + gss->VGA_MEM_SIZE; } void SimonState::vga_buf_unk_proc3(byte *end) { VgaPointersEntry *vpe; if (_video_var_7 == 0xFFFF) return; if (_video_var_4 == 2) error("vga_buf_unk_proc3: _video_var_4 == 2"); vpe = &_vga_buffer_pointers[_video_var_7]; if (_vga_buf_free_start <= vpe->vgaFile1 && end >= vpe->vgaFile1 || _vga_buf_free_start <= vpe->vgaFile2 && end >= vpe->vgaFile2) { _video_var_5 = 1; _video_var_4++; _vga_buf_free_start = vpe->vgaFile1 + 0x5000; } else { _video_var_5 = 0; } } void SimonState::vga_buf_unk_proc1(byte *end) { VgaSprite *vsp; if (_lock_word & 0x20) return; for (vsp = _vga_sprites; vsp->id; vsp++) { vga_buf_unk_proc2(vsp->unk7, end); if (_video_var_5 == true) return; } } void SimonState::delete_memptr_range(byte *end) { uint count = ARRAYSIZE(_vga_buffer_pointers); VgaPointersEntry *vpe = _vga_buffer_pointers; do { if (_vga_buf_free_start <= vpe->vgaFile1 && end >= vpe->vgaFile1 || _vga_buf_free_start <= vpe->vgaFile2 && end >= vpe->vgaFile2) { vpe->dd = 0; vpe->vgaFile1 = NULL; vpe->vgaFile2 = NULL; } } while (++vpe, --count); } void SimonState::vga_buf_unk_proc2(uint a, byte *end) { VgaPointersEntry *vpe; vpe = &_vga_buffer_pointers[a]; if (_vga_buf_free_start <= vpe->vgaFile1 && end >= vpe->vgaFile1 || _vga_buf_free_start <= vpe->vgaFile2 && end >= vpe->vgaFile2) { _video_var_5 = true; _video_var_4++; _vga_buf_free_start = vpe->vgaFile1 + 0x5000; } else { _video_var_5 = false; } } void SimonState::o_clear_vgapointer_entry(uint a) { VgaPointersEntry *vpe; vpe = &_vga_buffer_pointers[a]; vpe->dd = 0; vpe->vgaFile1 = NULL; vpe->vgaFile2 = NULL; } void SimonState::o_set_video_mode(uint mode, uint vga_res) { if (mode == 4) vc_29_stop_all_sounds(); if (_lock_word & 0x10) { error("o_set_video_mode_ex: _lock_word & 0x10"); // _unk21_word_array[a] = b; } else { set_video_mode(mode, vga_res); } } void SimonState::set_video_mode_internal(uint mode, uint vga_res_id) { uint num; VgaPointersEntry *vpe; byte *bb, *b; uint16 c; byte *vc_ptr_org; warning("Set video mode internal: %d, %d", mode, vga_res_id); _video_palette_mode = mode; _lock_word |= 0x20; if (vga_res_id == 0) { if (!(_game & GAME_SIMON2)) { _unk_pal_flag = true; } else { _dx_use_3_or_4_for_lock = true; _vga_var6 = true; } } _vga_cur_file_2 = num = vga_res_id / 100; for (;;) { vpe = &_vga_buffer_pointers[num]; _cur_vga_file_1 = vpe->vgaFile1; _cur_vga_file_2 = vpe->vgaFile2; if (vpe->vgaFile1 != NULL) break; ensureVgaResLoaded(num); } /* ensure flipping complete */ bb = _cur_vga_file_1; b = bb + READ_BE_UINT16_UNALIGNED(&((VgaFile1Header *) bb)->hdr2_start); c = READ_BE_UINT16_UNALIGNED(&((VgaFile1Header2 *) b)->unk1); b = bb + READ_BE_UINT16_UNALIGNED(&((VgaFile1Header2 *) b)->unk2_offs); while (READ_BE_UINT16_UNALIGNED(&((VgaFile1Struct0x8 *) b)->id) != vga_res_id) b += sizeof(VgaFile1Struct0x8); if (!(_game & GAME_SIMON2)) { if (num == 16300) { dx_clear_attached_from_top(134); _use_palette_delay = true; } } else { _x_scroll = 0; _vga_var1 = 0; _vga_var2 = 0; _vga_var3 = 0; _vga_var5 = 134; if (_variableArray[34] != -1) _variableArray[502 / 2] = 0; } vc_ptr_org = _vc_ptr; _vc_ptr = _cur_vga_file_1 + READ_BE_UINT16_UNALIGNED(&((VgaFile1Struct0x8 *) b)->script_offs); // dump_vga_script(_vc_ptr, num, vga_res_id); run_vga_script(); _vc_ptr = vc_ptr_org; if (_game & GAME_SIMON2) { if (!_dx_use_3_or_4_for_lock) { uint num_lines = _video_palette_mode == 4 ? 134 : 200; _vga_var8 = num_lines; dx_copy_from_attached_to_2(0, 0, 320, num_lines); dx_copy_from_attached_to_3(num_lines); _sync_flag_2 = 1; } _dx_use_3_or_4_for_lock = false; } else { uint num_lines = _video_palette_mode == 4 ? 134 : 200; dx_copy_from_attached_to_2(0, 0, 320, num_lines); dx_copy_from_attached_to_3(num_lines); _sync_flag_2 = 1; _timer_5 = 0; } _lock_word &= ~0x20; /* XXX: fix */ if (!(_game & GAME_SIMON2)) { if (_unk_pal_flag) { _unk_pal_flag = false; while (*(volatile int *)&_palette_color_count != 0) { delay(10); } } } } void SimonState::set_video_mode(uint mode, uint vga_res_id) { if (_lock_counter == 0) { lock(); if (_lock_word == 0) { _sync_flag_1 = true; while ((*(volatile bool *)&_sync_flag_1) == true) { delay(10); } } } _lock_word |= 0x20; // while ((*(volatile uint16*)&_lock_word) & 2) { // delay(10); // } unlock(); set_video_mode_internal(mode, vga_res_id); } void SimonState::o_fade_to_black() { uint i; memcpy(_video_buf_1, _palette_backup, 256 * sizeof(uint32)); i = NUM_PALETTE_FADEOUT; do { palette_fadeout((uint32 *)_video_buf_1, 32); palette_fadeout((uint32 *)_video_buf_1 + 32 + 16, 144); palette_fadeout((uint32 *)_video_buf_1 + 32 + 16 + 144 + 16, 48); _system->set_palette(_video_buf_1, 0, 256); _system->update_screen(); delay(5); } while (--i); memcpy(_palette_backup, _video_buf_1, 256 * sizeof(uint32)); memcpy(_palette, _video_buf_1, 256 * sizeof(uint32)); } void SimonState::delete_vga_timer(VgaTimerEntry * vte) { _lock_word |= 1; if (vte + 1 <= _next_vga_timer_to_process) { _next_vga_timer_to_process--; } do { memcpy(vte, vte + 1, sizeof(VgaTimerEntry)); vte++; } while (vte->delay); _lock_word &= ~1; } void SimonState::expire_vga_timers() { if (_game & GAME_SIMON2) { VgaTimerEntry *vte = _vga_timer_list; _vga_tick_counter++; while (vte->delay) { /* not quite ok, good enough */ if ((int16)(vte->delay -= 5) <= 0) { uint16 cur_file = vte->cur_vga_file; uint16 cur_unk = vte->sprite_id; byte *script_ptr = vte->script_pointer; _next_vga_timer_to_process = vte + 1; delete_vga_timer(vte); if (script_ptr == NULL) { /* special scroll timer */ scroll_timeout(); } else { vc_resume_thread(script_ptr, cur_file, cur_unk); } vte = _next_vga_timer_to_process; } else { vte++; } } } else { VgaTimerEntry *vte = _vga_timer_list; _vga_tick_counter++; while (vte->delay) { if (!--vte->delay) { uint16 cur_file = vte->cur_vga_file; uint16 cur_unk = vte->sprite_id; byte *script_ptr = vte->script_pointer; _next_vga_timer_to_process = vte + 1; delete_vga_timer(vte); vc_resume_thread(script_ptr, cur_file, cur_unk); vte = _next_vga_timer_to_process; } else { vte++; } } } } /* Simon2 specific */ void SimonState::scroll_timeout() { if (_vga_var2 == 0) return; if (_vga_var2 < 0) { if (_vga_var3 != -1) { _vga_var3 = -1; if (++_vga_var2 == 0) return; } } else { if (_vga_var3 != 1) { _vga_var3 = 1; if (--_vga_var2 == 0) return; } } add_vga_timer(10, NULL, 0, 0); } void SimonState::vc_resume_thread(byte *code_ptr, uint16 cur_file, uint16 cur_sprite) { VgaPointersEntry *vpe; _vga_cur_sprite_id = cur_sprite; _vga_cur_file_id = cur_file; _vga_cur_file_2 = cur_file; vpe = &_vga_buffer_pointers[cur_file]; _cur_vga_file_1 = vpe->vgaFile1; _cur_vga_file_2 = vpe->vgaFile2; _vc_ptr = code_ptr; run_vga_script(); } void SimonState::add_vga_timer(uint num, byte *code_ptr, uint cur_sprite, uint cur_file) { VgaTimerEntry *vte; // assert( (uint)READ_BE_UINT16_UNALIGNED(&*(uint16*)code_ptr) <= 63); _lock_word |= 1; for (vte = _vga_timer_list; vte->delay; vte++) { } vte->delay = num; vte->script_pointer = code_ptr; vte->sprite_id = cur_sprite; vte->cur_vga_file = cur_file; _lock_word &= ~1; } void SimonState::o_force_unlock() { if (_game & GAME_SIMON2 && _bit_array[4] & 0x8000) _mouse_cursor = 0; _lock_counter = 0; } void SimonState::o_force_lock() { _lock_word |= 0x4000; vc_34(); _lock_word &= ~0x4000; } void SimonState::o_save_game() { save_or_load_dialog(false); } void SimonState::o_load_game() { save_or_load_dialog(true); } int SimonState::display_savegame_list(int curpos, bool load, char *dst) { int slot, last_slot; File in; showMessageFormat("\xC"); memset(dst, 0, 18 * 6); slot = curpos; while (curpos + 6 > slot) { in.open(gen_savename(slot), getSavePath()); if (in.isOpen() == false) break; in.read(dst, 18); in.close(); last_slot = slot; if (slot < 10) showMessageFormat(" "); showMessageFormat("%d", slot); showMessageFormat(".%s\n", dst); dst += 18; slot++; } /* while_break */ if (!load) { if (curpos + 6 == slot) slot++; else { if (slot < 10) showMessageFormat(" "); showMessageFormat("%d.\n", slot); } } else { if (curpos + 6 == slot) { in.open(gen_savename(slot), getSavePath()); if (in.isOpen() == true) { slot++; in.close(); } } } return slot - curpos; } void SimonState::savegame_dialog(char *buf) { int i; o_unk_132_helper_3(); i = display_savegame_list(_saveload_row_curpos, _save_or_load, buf); _savedialog_flag = true; if (i != 7) { i++; if (!_save_or_load) i++; _savedialog_flag = false; } if (!--i) return; do { clear_hitarea_bit_0x40(0xd0 + i - 1); } while (--i); } void SimonState::save_or_load_dialog(bool load) { time_t save_time; int num = _number_of_savegames; int i; int unk132_result; FillOrCopyStruct *fcs; char *name; int name_len; bool b; char buf[108]; _save_or_load = load; save_time = time(NULL); _copy_partial_mode = 1; num = _number_of_savegames; if (!load) num++; num -= 6; if (num < 0) num = 0; num++; _num_savegame_rows = num; _saveload_row_curpos = 1; if (!load) _saveload_row_curpos = num; _saveload_flag = false; restart:; do { i = o_unk_132_helper(&b, buf); } while (!b); if (i == 205) goto get_out; if (!load) { /* if_1 */ if_1:; unk132_result = i; set_hitarea_bit_0x40(0xd0 + i); leaveHitAreaById(0xd0 + i); /* some code here */ fcs = _fcs_ptr_array_3[5]; fcs->textRow = unk132_result; // init x offset with a 2 character savegame number + a period (18 pix) fcs->textColumn = 2; fcs->textColumnOffset = 2; fcs->textLength = 3; name = buf + i * 18; // now process entire savegame name to get correct x offset for cursor name_len = 0; while (name[name_len]) { fcs->textLength++; fcs->textColumnOffset += 6; if (name[name_len] == 'i' || name[name_len] == 'l') fcs->textColumnOffset -= 2; if (fcs->textColumnOffset >= 8) { fcs->textColumnOffset -= 8; fcs->textColumn++; } name_len++; } /* while_1_end */ /* do_3_start */ for (;;) { video_putchar(fcs, 0x7f); _saveload_flag = true; /* do_2 */ do { i = o_unk_132_helper(&b, buf); if (b) { if (i == 205) goto get_out; clear_hitarea_bit_0x40(0xd0 + unk132_result); if (_saveload_flag) { o_unk_132_helper_2(_fcs_ptr_array_3[5], 8); /* move code */ } goto if_1; } /* is_not_b */ if (!_saveload_flag) { clear_hitarea_bit_0x40(0xd0 + unk132_result); goto restart; } } while (i >= 0x80 || i == 0); /* after_do_2 */ o_unk_132_helper_2(_fcs_ptr_array_3[5], 8); if (i == 10 || i == 13) break; if (i == 8) { /* do_backspace */ if (name_len != 0) { int x; name_len--; x = (name[name_len] == 'i' || name[name_len] == 'l') ? 1 : 8; name[name_len] = 0; o_unk_132_helper_2(_fcs_ptr_array_3[5], x); } } else if (i >= 32 && name_len != 17) { name[name_len++] = i; video_putchar(_fcs_ptr_array_3[5], i); } } /* do_save */ if (!save_game(_saveload_row_curpos + unk132_result, buf + unk132_result * 18)) warning("Save failed"); } else { if (!load_game(_saveload_row_curpos + i)) warning("Load failed"); } get_out:; o_unk_132_helper_3(); // clear_keydowns(); _base_time = time(NULL) - save_time + _base_time; _copy_partial_mode = 0; dx_copy_rgn_from_3_to_2(94, 208, 46, 80); i = _timer_4; do { delay(10); } while (i == _timer_4); #ifdef _WIN32_WCE if (draw_keyboard) { draw_keyboard = false; toolbar_drawn = false; } #endif } void SimonState::o_wait_for_vga(uint a) { _vga_wait_for = a; _timer_1 = 0; _exit_cutscene = false; while (_vga_wait_for != 0) { if (_exit_cutscene) { if (vc_get_bit(9)) { startSubroutine170(); break; } } else { processSpecialKeys(); } delay(10); // if (_timer_1 >= 500) { // warning("wait timed out"); // break; // } } // warning("waiting on %d done", a); } void SimonState::timer_vga_sprites() { VgaSprite *vsp; VgaPointersEntry *vpe; byte *vc_ptr_org = _vc_ptr; uint16 params[5]; /* parameters to vc_10 */ if (_video_var_9 == 2) _video_var_9 = 1; #ifdef DRAW_THREE_STARS fprintf(_dump_file, "***\n"); #endif if (_game & GAME_SIMON2 && _vga_var3) { timer_vga_sprites_helper(); } vsp = _vga_sprites; while (vsp->id != 0) { vsp->unk6 &= 0x7FFF; vpe = &_vga_buffer_pointers[vsp->unk7]; _cur_vga_file_1 = vpe->vgaFile1; _cur_vga_file_2 = vpe->vgaFile2; _video_palette_mode = vsp->unk6; _vga_cur_sprite_id = vsp->id; params[0] = READ_BE_UINT16_UNALIGNED(&vsp->image); params[1] = READ_BE_UINT16_UNALIGNED(&vsp->base_color); params[2] = READ_BE_UINT16_UNALIGNED(&vsp->x); params[3] = READ_BE_UINT16_UNALIGNED(&vsp->y); if (_game & GAME_SIMON2) { *(byte *)(¶ms[4]) = (byte)vsp->unk4; } else { params[4] = READ_BE_UINT16_UNALIGNED(&vsp->unk4); } _vc_ptr = (byte *)params; vc_10(); vsp++; } #ifdef DRAW_IMAGES_DEBUG memset(_sdl_buf_attached, 0, 320 * 200); #endif _video_var_8++; _vc_ptr = vc_ptr_org; } void SimonState::timer_vga_sprites_helper() { byte *dst = dx_lock_2(), *src; uint x; if (_vga_var3 < 0) { memmove(dst + 8, dst, 320 * _vga_var5 - 8); } else { memmove(dst, dst + 8, 320 * _vga_var5 - 8); } x = _x_scroll - 1; if (_vga_var3 > 0) { dst += 320 - 8; x += 41; } src = _vga_var7 + x * 4; vc_10_helper_8(dst, src + READ_BE_UINT32_UNALIGNED(&*((uint32 *)src))); dx_unlock_2(); memcpy(_sdl_buf_attached, _sdl_buf, 320 * 200); dx_copy_from_attached_to_3(_vga_var5); _x_scroll += _vga_var3; vc_write_var(0xfB, _x_scroll); _vga_var3 = 0; } #ifdef DRAW_IMAGES_DEBUG void SimonState::timer_vga_sprites_2() { VgaSprite *vsp; VgaPointersEntry *vpe; byte *vc_ptr_org = _vc_ptr; uint16 params[5]; /* parameters to vc_10 */ if (_video_var_9 == 2) _video_var_9 = 1; vsp = _vga_sprites; while (vsp->id != 0) { vsp->unk6 &= 0x7FFF; vpe = &_vga_buffer_pointers[vsp->unk7]; _cur_vga_file_1 = vpe->vgaFile1; _cur_vga_file_2 = vpe->vgaFile2; _video_palette_mode = vsp->unk6; _vga_cur_sprite_id = vsp->id; if (vsp->image) fprintf(_dump_file, "id:%5d image:%3d base-color:%3d x:%3d y:%3d flags:%x\n", vsp->id, vsp->image, vsp->base_color, vsp->x, vsp->y, vsp->unk4); params[0] = READ_BE_UINT16_UNALIGNED(&vsp->image); params[1] = READ_BE_UINT16_UNALIGNED(&vsp->base_color); params[2] = READ_BE_UINT16_UNALIGNED(&vsp->x); params[3] = READ_BE_UINT16_UNALIGNED(&vsp->y); params[4] = READ_BE_UINT16_UNALIGNED(&vsp->unk4); _vc_ptr = (byte *)params; vc_10(); vsp++; } #ifdef DRAW_THREE_STARS fprintf(_dump_file, "***\n"); #endif _video_var_8++; _vc_ptr = vc_ptr_org; } #endif void SimonState::timer_proc1() { _timer_4++; if (_lock_word & 0xC0E9 || _lock_word & 2) return; _timer_1++; _lock_word |= 2; if (!(_lock_word & 0x10)) { if (!(_game & GAME_SIMON2)) { expire_vga_timers(); expire_vga_timers(); _cepe_flag ^= 1; if (!_cepe_flag) expire_vga_timers(); _sync_flag_2 ^= 1; } else { _sync_flag_2 ^= 1; if (!_sync_flag_2) expire_vga_timers(); if (_lock_counter != 0 && !_sync_flag_2) { _lock_word &= ~2; return; } } // if (_lock_counter !=0 && _sync_flag_2==1) { // printf("skipping draw...\n"); // goto get_out; // } } timer_vga_sprites(); #ifdef DRAW_IMAGES_DEBUG timer_vga_sprites_2(); #endif if (_copy_partial_mode == 1) { dx_copy_from_2_to_attached(80, 46, 208 - 80, 94 - 46); } if (_copy_partial_mode == 2) { /* copy partial from attached to 2 */ dx_copy_from_attached_to_2(176, 61, 320 - 176, 134 - 61); _copy_partial_mode = 0; } /* XXX: more stuff here */ if (_video_var_8) { handle_mouse_moved(); /* XXX: more stuff here */ dx_update_screen_and_palette(); _sync_flag_1 = false; _video_var_8 = false; } _lock_word &= ~2; } void SimonState::timer_callback() { // uint32 start, end; if (_timer_5 != 0) { _sync_flag_2 = true; _timer_5--; } else { // start = timeGetTime(); timer_proc1(); // end = timeGetTime(); // if (start + 45 < end) { // _timer_5 = (uint16)( (end - start) / 45); // } } } void SimonState::checkTimerCallback() { if (_invoke_timer_callback && !_in_callback) { _in_callback = true; _invoke_timer_callback = 0; timer_callback(); _in_callback = false; } } void SimonState::fcs_setTextColor(FillOrCopyStruct *fcs, uint value) { fcs->text_color = value; } void SimonState::o_vga_reset() { _lock_word |= 0x4000; vc_27_reset(); _lock_word &= ~0x4000; } bool SimonState::vc_maybe_skip_proc_3(uint16 a) { Item *item; CHECK_BOUNDS(a, _vc_item_array); item = _vc_item_array[a]; if (item == NULL) return true; return getItem1Ptr()->parent == item->parent; } bool SimonState::vc_maybe_skip_proc_2(uint16 a, uint16 b) { Item *item_a, *item_b; CHECK_BOUNDS(a, _vc_item_array); CHECK_BOUNDS(b, _vc_item_array); item_a = _vc_item_array[a]; item_b = _vc_item_array[b]; if (item_a == NULL || item_b == NULL) return true; return derefItem(item_a->parent) == item_b; } bool SimonState::vc_maybe_skip_proc_1(uint16 a, int16 b) { Item *item; CHECK_BOUNDS(a, _vc_item_array); item = _vc_item_array[a]; if (item == NULL) return true; return item->unk3 == b; } /* OK */ void SimonState::fcs_delete(uint a) { if (_fcs_ptr_array_3[a] == NULL) return; fcs_unk1(a); video_copy_if_flag_0x8_c(_fcs_ptr_array_3[a]); _fcs_ptr_array_3[a] = NULL; if (_fcs_unk_1 == a) { _fcs_ptr_1 = NULL; fcs_unk_2(0); } } /* OK */ void SimonState::fcs_unk_2(uint a) { a &= 7; if (_fcs_ptr_array_3[a] == NULL || _fcs_unk_1 == a) return; _fcs_unk_1 = a; startUp_helper_3(); _fcs_ptr_1 = _fcs_ptr_array_3[a]; showmessage_helper_3(_fcs_ptr_1->textLength, _fcs_ptr_1->textMaxLength); } /* OK */ FillOrCopyStruct *SimonState::fcs_alloc(uint x, uint y, uint w, uint h, uint flags, uint fill_color, uint unk4) { FillOrCopyStruct *fcs; fcs = _fcs_list; while (fcs->mode != 0) fcs++; fcs->mode = 2; fcs->x = x; fcs->y = y; fcs->width = w; fcs->height = h; fcs->flags = flags; fcs->fill_color = fill_color; fcs->text_color = unk4; fcs->textColumn = 0; fcs->textRow = 0; fcs->textColumnOffset = 0; fcs->textMaxLength = fcs->width * 8 / 6; // characters are 6 pixels return fcs; } Item *SimonState::derefItem(uint item) { if (item >= _itemarray_size) error("derefItem: invalid item %d", item); return _itemarray_ptr[item]; } uint SimonState::itemPtrToID(Item *id) { uint i; for (i = 0; i != _itemarray_size; i++) if (_itemarray_ptr[i] == id) return i; error("itemPtrToID: not found"); } void SimonState::o_pathfind(int x, int y, uint var_1, uint var_2) { uint16 *p; uint i, j; uint prev_i; uint x_diff, y_diff; uint best_i = 0, best_j = 0, best_dist = 0xFFFFFFFF; if (_game & GAME_SIMON2) { x += _x_scroll * 8; } prev_i = 21 - _variableArray[12]; for (i = 20; i != 0; --i) { p = (uint16 *)_pathfind_array[20 - i]; if (!p) continue; for (j = 0; READ_BE_UINT16_UNALIGNED(&p[0]) != 999; j++, p += 2) { /* 0xE703 = byteswapped 999 */ x_diff = abs((int)(READ_BE_UINT16_UNALIGNED(&p[0]) - x)); y_diff = abs((int)(READ_BE_UINT16_UNALIGNED(&p[1]) - 12 - y)); if (x_diff < y_diff) { x_diff >>= 2; y_diff <<= 2; } x_diff += y_diff >> 2; if (x_diff < best_dist || x_diff == best_dist && prev_i == i) { best_dist = x_diff; best_i = 21 - i; best_j = j; } } } _variableArray[var_1] = best_i; _variableArray[var_2] = best_j; } /* ok */ void SimonState::fcs_unk1(uint fcs_index) { FillOrCopyStruct *fcs; uint16 fcsunk1; uint16 i; fcs = _fcs_ptr_array_3[fcs_index & 7]; fcsunk1 = _fcs_unk_1; if (fcs == NULL || fcs->fcs_data == NULL) return; fcs_unk_2(fcs_index); fcs_putchar(12); fcs_unk_2(fcsunk1); for (i = 0; fcs->fcs_data->e[i].item != NULL; i++) { delete_hitarea_by_index(fcs->fcs_data->e[i].hit_area); } if (fcs->fcs_data->unk3 != -1) { delete_hitarea_by_index(fcs->fcs_data->unk3); } if (fcs->fcs_data->unk4 != -1) { delete_hitarea_by_index(fcs->fcs_data->unk4); fcs_unk_5(fcs, fcs_index); } free(fcs->fcs_data); fcs->fcs_data = NULL; _fcs_data_1[fcs_index] = 0; _fcs_data_2[fcs_index] = 0; } /* ok */ void SimonState::fcs_unk_5(FillOrCopyStruct *fcs, uint fcs_index) { if (!(_game & GAME_SIMON2)) { o_unk_99_simon1(0x80); } } void SimonState::delete_hitarea_by_index(uint index) { CHECK_BOUNDS(index, _hit_areas); _hit_areas[index].flags = 0; } /* ok */ void SimonState::fcs_putchar(uint a) { if (_fcs_ptr_1 != _fcs_ptr_array_3[0]) video_putchar(_fcs_ptr_1, a); } /* ok */ void SimonState::video_fill_or_copy_from_3_to_2(FillOrCopyStruct *fcs) { if (fcs->flags & 0x10) copy_img_from_3_to_2(fcs); else video_erase(fcs); fcs->textColumn = 0; fcs->textRow = 0; fcs->textColumnOffset = 0; fcs->textLength = 0; } /* ok */ void SimonState::copy_img_from_3_to_2(FillOrCopyStruct *fcs) { _lock_word |= 0x8000; if (!(_game & GAME_SIMON2)) { dx_copy_rgn_from_3_to_2(fcs->y + fcs->height * 8 + ((fcs == _fcs_ptr_array_3[2]) ? 1 : 0), (fcs->x + fcs->width) * 8, fcs->y, fcs->x * 8); } else { if (_vga_var6 && _fcs_ptr_array_3[2] == fcs) { fcs = _fcs_ptr_array_3[0x18 / 4]; _vga_var6 = 0; } dx_copy_rgn_from_3_to_2(fcs->y + fcs->height * 8, (fcs->x + fcs->width) * 8, fcs->y, fcs->x * 8); } _lock_word &= ~0x8000; } void SimonState::video_erase(FillOrCopyStruct *fcs) { byte *dst; uint h; _lock_word |= 0x8000; dst = dx_lock_2(); dst += _dx_surface_pitch * fcs->y + fcs->x * 8; h = fcs->height * 8; do { memset(dst, fcs->fill_color, fcs->width * 8); dst += _dx_surface_pitch; } while (--h); dx_unlock_2(); _lock_word &= ~0x8000; } VgaSprite *SimonState::find_cur_sprite() { if (_game & GAME_SIMON2) { VgaSprite *vsp = _vga_sprites; while (vsp->id) { if (vsp->id == _vga_cur_sprite_id && vsp->unk7 == _vga_cur_file_id) break; vsp++; } return vsp; } else { VgaSprite *vsp = _vga_sprites; while (vsp->id) { if (vsp->id == _vga_cur_sprite_id) break; vsp++; } return vsp; } } bool SimonState::has_vgastruct_with_id(uint16 id, uint16 file) { if (_game & GAME_SIMON2) { VgaSprite *vsp = _vga_sprites; while (vsp->id) { if (vsp->id == id && vsp->unk7 == file) return true; vsp++; } return false; } else { VgaSprite *vsp = _vga_sprites; while (vsp->id) { if (vsp->id == id) return true; vsp++; } return false; } } void SimonState::processSpecialKeys() { } void SimonState::draw_mouse_pointer() { } void decompress_icon(byte *dst, byte *src, uint w, uint h_org, byte base, uint pitch) { int8 reps; byte color_1, color_2; byte *dst_org = dst; uint h = h_org; for (;;) { reps = *src++; if (reps < 0) { reps--; color_1 = *src >> 4; if (color_1 != 0) color_1 |= base; color_2 = *src++ & 0xF; if (color_2 != 0) color_2 |= base; do { if (color_1 != 0) *dst = color_1; dst += pitch; if (color_2 != 0) *dst = color_2; dst += pitch; /* reached bottom? */ if (--h == 0) { /* reached right edge? */ if (--w == 0) return; dst = ++dst_org; h = h_org; } } while (++reps != 0); } else { do { color_1 = *src >> 4; if (color_1 != 0) *dst = color_1 | base; dst += pitch; color_2 = *src++ & 0xF; if (color_2 != 0) *dst = color_2 | base; dst += pitch; /* reached bottom? */ if (--h == 0) { /* reached right edge? */ if (--w == 0) return; dst = ++dst_org; h = h_org; } } while (--reps >= 0); } } } void SimonState::draw_icon_c(FillOrCopyStruct *fcs, uint icon, uint x, uint y) { byte *dst; byte *src; if (!(_game & GAME_SIMON2)) { _lock_word |= 0x8000; dst = dx_lock_2(); dst += (x + fcs->x) * 8; dst += (y * 25 + fcs->y) * _dx_surface_pitch; src = _icon_file_ptr; src += READ_LE_UINT16(&((uint16 *)src)[icon]); decompress_icon(dst, src, 24, 12, 0xE0, _dx_surface_pitch); dx_unlock_2(); _lock_word &= ~0x8000; } else { _lock_word |= 0x8000; dst = dx_lock_2(); dst += 110; dst += x; dst += (y + fcs->y) * _dx_surface_pitch; src = _icon_file_ptr; src += READ_LE_UINT16(&((uint16 *)src)[icon * 2 + 0]); decompress_icon(dst, src, 20, 10, 0xE0, _dx_surface_pitch); src = _icon_file_ptr; src += READ_LE_UINT16(&((uint16 *)src)[icon * 2 + 1]); decompress_icon(dst, src, 20, 10, 0xD0, _dx_surface_pitch); dx_unlock_2(); _lock_word &= ~0x8000; } } void SimonState::video_toggle_colors(HitArea * ha, byte a, byte b, byte c, byte d) { byte *src, color; uint w, h, i; _lock_word |= 0x8000; src = dx_lock_2() + ha->y * _dx_surface_pitch + ha->x; w = ha->width; h = ha->height; if (!(h > 0 && w > 0 && ha->x + w <= 320 && ha->y + h <= 200)) { warning("Invalid coordinates in video_toggle_colors (%d,%d,%d,%d)", ha->x, ha->y, ha->width, ha->height); _lock_word &= ~0x8000; return; } do { for (i = 0; i != w; ++i) { color = src[i]; if (a >= color && b < color) { if (c >= color) color += d; else color -= d; src[i] = color; } } src += _dx_surface_pitch; } while (--h); dx_unlock_2(); _lock_word &= ~0x8000; } bool SimonState::vc_59_helper() { #ifdef USE_TEXT_HACK return true; #else if (_voice_file == NULL) return false; return _voice_sound == 0; #endif } void SimonState::video_copy_if_flag_0x8_c(FillOrCopyStruct *fcs) { if (fcs->flags & 8) copy_img_from_3_to_2(fcs); fcs->mode = 0; } void SimonState::showMessageFormat(const char *s, ...) { char buf[1024], *str; va_list va; va_start(va, s); vsprintf(buf, s, va); va_end(va); if (!_fcs_data_1[_fcs_unk_1]) { showmessage_helper_2(); if (!_showmessage_flag) { _fcs_ptr_array_3[0] = _fcs_ptr_1; showmessage_helper_3(_fcs_ptr_1->textLength, _fcs_ptr_1->textMaxLength); } _showmessage_flag = true; _fcs_data_1[_fcs_unk_1] = 1; } for (str = buf; *str; str++) showmessage_print_char(*str); } void SimonState::showmessage_helper_2() { if (_fcs_ptr_1) return; _fcs_ptr_1 = fcs_alloc(8, 0x90, 0x18, 6, 1, 0, 0xF); } void SimonState::readSfxFile(const char *filename) { if (!(_game & GAME_SIMON2)) { File in; uint32 size; in.open(filename, _gameDataPath); if (in.isOpen() == false) { warning("readSfxFile: Cannot load sfx file %s", filename); return; } in.seek(0, SEEK_END); size = in.pos(); in.seek(0, SEEK_SET); /* stop all sounds */ _mixer->stopAll(); if (_sfx_heap) free(_sfx_heap); _sfx_heap = (byte *)malloc(size); if (_sfx_heap == NULL) error("readSfxFile: Not enough SFX memory"); in.read(_sfx_heap, size); in.close(); } else { int res; uint32 offs; int size; vc_29_stop_all_sounds(); if (_sfx_heap) free(_sfx_heap); res = atoi(filename + 6) + gss->SOUND_INDEX_BASE - 1; offs = _game_offsets_ptr[res]; size = _game_offsets_ptr[res + 1] - offs; if (size == 0) return; _sfx_heap = (byte *)malloc(size); resfile_read(_sfx_heap, offs, size); } } void SimonState::video_putchar(FillOrCopyStruct *fcs, byte c) { if (c == 0xC) { video_fill_or_copy_from_3_to_2(fcs); } else if (c == 0xD || c == 0xA) { video_putchar_newline(fcs); } else if (c == 8 || c == 1) { int8 val = (c == 8) ? 6 : 4; if (fcs->textLength != 0) { fcs->textLength--; fcs->textColumnOffset -= val; if ((int8)fcs->textColumnOffset < val) { fcs->textColumnOffset += 8; fcs->textColumn--; } } } else if (c >= 0x20) { if (fcs->textLength == fcs->textMaxLength) { video_putchar_newline(fcs); } else if (fcs->textRow == fcs->height) { video_putchar_newline(fcs); fcs->textRow--; } video_putchar_drawchar(fcs, fcs->textColumn + fcs->x, fcs->textRow * 8 + fcs->y, c); fcs->textLength++; fcs->textColumnOffset += 6; if (c == 'i' || c == 'l') fcs->textColumnOffset -= 2; if (fcs->textColumnOffset >= 8) { fcs->textColumnOffset -= 8; fcs->textColumn++; } } } void SimonState::video_putchar_newline(FillOrCopyStruct *fcs) { fcs->textColumnOffset = 0; fcs->textLength = 0; fcs->textColumn = 0; if (fcs->textRow != fcs->height) fcs->textRow++; } static const byte video_font[] = { 0, 0, 0, 0, 0, 0, 0, 0, 32, 112, 112, 32, 32, 0, 32, 0, 48, 48, 96, 0, 0, 0, 0, 0, 0, 144, 0, 96, 144, 144, 104, 0, 0, 144, 0, 96, 144, 144, 96, 0, 0, 144, 0, 144, 144, 144, 96, 0, 0, 16, 40, 16, 42, 68, 58, 0, 48, 48, 96, 0, 0, 0, 0, 0, 0, 4, 8, 8, 8, 8, 4, 0, 0, 32, 16, 16, 16, 16, 32, 0, 0, 0, 20, 8, 62, 8, 20, 0, 0, 112, 136, 240, 136, 136, 240, 0, 0, 0, 0, 0, 0, 48, 48, 96, 0, 0, 0, 240, 0, 0, 0, 0, 0, 0, 0, 0, 0, 48, 48, 0, 16, 32, 0, 120, 112, 64, 56, 0, 112, 136, 152, 168, 200, 136, 112, 0, 32, 96, 32, 32, 32, 32, 112, 0, 112, 136, 8, 48, 64, 136, 248, 0, 112, 136, 8, 48, 8, 136, 112, 0, 16, 48, 80, 144, 248, 16, 56, 0, 248, 128, 240, 8, 8, 136, 112, 0, 48, 64, 128, 240, 136, 136, 112, 0, 248, 136, 8, 16, 32, 32, 32, 0, 112, 136, 136, 112, 136, 136, 112, 0, 112, 136, 136, 120, 8, 16, 96, 0, 0, 0, 48, 48, 0, 48, 48, 0, 32, 16, 0, 112, 8, 248, 120, 0, 32, 80, 0, 144, 144, 144, 104, 0, 32, 16, 0, 112, 248, 128, 112, 0, 32, 80, 0, 112, 248, 128, 112, 0, 112, 136, 8, 16, 32, 0, 32, 0, 32, 80, 0, 192, 64, 64, 224, 0, 112, 136, 136, 248, 136, 136, 136, 0, 240, 72, 72, 112, 72, 72, 240, 0, 48, 72, 128, 128, 128, 72, 48, 0, 224, 80, 72, 72, 72, 80, 224, 0, 248, 72, 64, 112, 64, 72, 248, 0, 248, 72, 64, 112, 64, 64, 224, 0, 48, 72, 128, 152, 136, 72, 56, 0, 136, 136, 136, 248, 136, 136, 136, 0, 248, 32, 32, 32, 32, 32, 248, 0, 24, 8, 8, 8, 136, 136, 112, 0, 200, 72, 80, 96, 80, 72, 200, 0, 224, 64, 64, 64, 64, 72, 248, 0, 136, 216, 168, 168, 136, 136, 136, 0, 136, 200, 168, 152, 136, 136, 136, 0, 112, 136, 136, 136, 136, 136, 112, 0, 240, 72, 72, 112, 64, 64, 224, 0, 112, 136, 136, 136, 136, 168, 112, 8, 240, 72, 72, 112, 72, 72, 200, 0, 112, 136, 128, 112, 8, 136, 112, 0, 248, 168, 32, 32, 32, 32, 112, 0, 136, 136, 136, 136, 136, 136, 120, 0, 136, 136, 136, 80, 80, 32, 32, 0, 136, 136, 136, 136, 168, 216, 136, 0, 136, 136, 80, 32, 80, 136, 136, 0, 136, 136, 136, 112, 32, 32, 112, 0, 248, 136, 16, 32, 64, 136, 248, 0, 0, 14, 8, 8, 8, 8, 14, 0, 0, 128, 64, 32, 16, 8, 4, 0, 0, 112, 16, 16, 16, 16, 112, 0, 0, 48, 72, 64, 72, 48, 16, 48, 0, 80, 0, 96, 32, 40, 48, 0, 32, 16, 0, 152, 144, 144, 232, 0, 0, 0, 112, 8, 120, 136, 120, 0, 192, 64, 80, 104, 72, 72, 112, 0, 0, 0, 112, 136, 128, 136, 112, 0, 24, 16, 80, 176, 144, 144, 112, 0, 0, 0, 112, 136, 248, 128, 112, 0, 48, 72, 64, 224, 64, 64, 224, 0, 0, 0, 104, 144, 144, 112, 136, 112, 192, 64, 80, 104, 72, 72, 200, 0, 64, 0, 192, 64, 64, 64, 224, 0, 8, 0, 8, 8, 8, 8, 136, 112, 192, 64, 72, 80, 96, 80, 200, 0, 192, 64, 64, 64, 64, 64, 224, 0, 0, 0, 144, 216, 168, 136, 136, 0, 0, 0, 240, 136, 136, 136, 136, 0, 0, 0, 112, 136, 136, 136, 112, 0, 0, 0, 176, 72, 72, 112, 64, 224, 0, 0, 104, 144, 144, 112, 16, 56, 0, 0, 176, 72, 72, 64, 224, 0, 0, 0, 120, 128, 112, 8, 240, 0, 64, 64, 240, 64, 64, 72, 48, 0, 0, 0, 144, 144, 144, 144, 104, 0, 0, 0, 136, 136, 136, 80, 32, 0, 0, 0, 136, 136, 168, 216, 144, 0, 0, 0, 136, 80, 32, 80, 136, 0, 0, 0, 136, 136, 136, 112, 32, 192, 0, 0, 248, 144, 32, 72, 248, 0, 32, 80, 0, 96, 144, 144, 96, 0, 0, 14, 8, 48, 8, 8, 14, 0, 0, 8, 8, 8, 8, 8, 8, 0, 0, 112, 16, 12, 16, 16, 112, 0, 0, 0, 0, 0, 0, 0, 248, 0, 252, 252, 252, 252, 252, 252, 252, 252, 240, 240, 240, 240, 240, 240, 240, 240, }; void SimonState::video_putchar_drawchar(FillOrCopyStruct *fcs, uint x, uint y, byte chr) { const byte *src; byte color, *dst; uint h, i; _lock_word |= 0x8000; dst = dx_lock_2(); dst += y * _dx_surface_pitch + x * 8 + fcs->textColumnOffset; src = video_font + (chr - 0x20) * 8; color = fcs->text_color; h = 8; do { int8 b = *src++; i = 0; do { if (b < 0) dst[i] = color; b <<= 1; } while (++i != 6); dst += _dx_surface_pitch; } while (--h); dx_unlock_2(); _lock_word &= ~0x8000; } void SimonState::start_vga_code(uint b, uint vga_res, uint vga_struct_id, uint c, uint d, uint f) { VgaSprite *vsp; VgaPointersEntry *vpe; byte *p, *pp; uint count; _lock_word |= 0x40; if (has_vgastruct_with_id(vga_struct_id, vga_res)) { _lock_word &= ~0x40; return; } vsp = _vga_sprites; while (vsp->id != 0) vsp++; vsp->unk6 = b; vsp->unk5 = 0; vsp->unk4 = 0; vsp->y = d; vsp->x = c; vsp->image = 0; vsp->base_color = f; vsp->id = vga_struct_id; vsp->unk7 = vga_res; for (;;) { vpe = &_vga_buffer_pointers[vga_res]; _vga_cur_file_2 = vga_res; _cur_vga_file_1 = vpe->vgaFile1; if (vpe->vgaFile1 != NULL) break; ensureVgaResLoaded(vga_res); } pp = _cur_vga_file_1; p = pp + READ_BE_UINT16_UNALIGNED(&((VgaFile1Header *) pp)->hdr2_start); count = READ_BE_UINT16_UNALIGNED(&((VgaFile1Header2 *) p)->id_count); p = pp + READ_BE_UINT16_UNALIGNED(&((VgaFile1Header2 *) p)->id_table); for (;;) { if (READ_BE_UINT16_UNALIGNED(&((VgaFile1Struct0x6 *) p)->id) == vga_struct_id) { //dump_vga_script(pp + READ_BE_UINT16_UNALIGNED(&((VgaFile1Struct0x6*)p)->script_offs), vga_res, vga_struct_id); add_vga_timer(gss->VGA_DELAY_BASE, pp + READ_BE_UINT16_UNALIGNED(&((VgaFile1Struct0x6 *) p)->script_offs), vga_struct_id, vga_res); break; } p += sizeof(VgaFile1Struct0x6); if (!--count) { vsp->id = 0; break; } } _lock_word &= ~0x40; } void SimonState::talk_with_speech(uint speech_id, uint num_1) { if (!(_game & GAME_SIMON2)) { if (speech_id == 9999) { if (!(_bit_array[0] & 0x4000) && !(_bit_array[1] & 0x1000)) { _bit_array[0] |= 0x4000; _variableArray[0xc8 / 2] = 0xF; start_vga_code(4, 1, 0x82, 0, 0, 0); o_wait_for_vga(0x82); } _skip_vga_wait = true; return; } if (num_1 < 100) { o_unk_99_simon1(num_1 + 201); } playVoice(speech_id); if (num_1 < 100) { start_vga_code(4, 2, num_1 + 201, 0, 0, 0); } } else { if (speech_id == 0xFFFF) { if (_vk_t_toggle) return; if (!(_bit_array[0] & 0x4000 || _bit_array[1] & 0x1000)) { _bit_array[0] |= 0x4000; start_vga_code(4, 1, 0x1e, 0, 0, 0); o_wait_for_vga(0x82); } _skip_vga_wait = true; } else { if (_vk_t_toggle && _scriptvar_2) { start_vga_code(4, 2, 5, 0, 0, 0); o_wait_for_vga(0xcd); o_unk_99_simon2(2, 5); } o_unk_99_simon2(2, num_1 + 2); playVoice(speech_id); start_vga_code(4, 2, num_1 + 2, 0, 0, 0); } } } void SimonState::talk_with_text(uint num_1, uint num_2, const char *string_ptr, uint threeval_a, int threeval_b, uint width) { char print_str_buf[0x140]; char *char_buf; const char *string_ptr_2, *string_ptr_3; int j; uint letters_per_row, len_div_3, num_of_rows; uint m, n; uint height; if (num_1 >= 100) // FIXME: Simon1 Mine - Fix text for dwarf song num_1 -= 100; char_buf = print_str_buf; string_ptr_3 = string_ptr_2 = string_ptr; height = 10; j = 0; letters_per_row = width / 6; len_div_3 = (strlen(string_ptr) + 3) / 3; if (!(_game & GAME_SIMON2)) { if (_variableArray[141] == 0) _variableArray[141] = 9; _variableArray[85] = _variableArray[141] * len_div_3; } else { if (_variableArray[86] == 0) len_div_3 >>= 1; if (_variableArray[86] == 2) len_div_3 <<= 1; _variableArray[85] = len_div_3 * 5; } num_of_rows = strlen(string_ptr) / letters_per_row; while (num_of_rows == 1 && j != -1) { m = strlen(string_ptr) >> 1; m -= j; string_ptr_2 += m; while (*string_ptr_2++ != ' ' && m <= letters_per_row) m++; if (m <= letters_per_row && strlen(string_ptr_2) < letters_per_row) { /* if_1 */ n = (letters_per_row - m + 1) >> 1; while (n != 0) { *char_buf++ = ' '; n--; } strncpy(char_buf, string_ptr, m); char_buf += m; *char_buf++ = 10; height += 10; threeval_b -= 10; j = -1; } else { /* else_1 */ j -= 4; if (j == -12) { j = 0; num_of_rows = 2; } string_ptr_2 = string_ptr_3; } } if (j != -1 && width * 30 > 8000) num_of_rows = 4; while (num_of_rows == 2 && j != -1) { m = strlen(string_ptr) / 3; m += j; string_ptr_2 += m; while (*string_ptr_2++ != ' ' && m <= letters_per_row) m++; if (m <= letters_per_row) { /* if_4 */ n = (letters_per_row - m + 1) >> 1; while (n) { *char_buf++ = ' '; n--; } strncpy(char_buf, string_ptr, m); char_buf += m; *char_buf++ = 10; string_ptr = string_ptr_2; string_ptr_2 += m; while (*string_ptr_2-- != ' ' && m > 0) m--; /* while_6_end */ string_ptr_2 += 2; if (strlen(string_ptr_2) <= m && m > 0) { /* if_6 */ n = (letters_per_row - m + 1) >> 1; while (n) { *char_buf++ = ' '; n--; } strncpy(char_buf, string_ptr, m); char_buf += m; *char_buf++ = 10; height += 20; threeval_b -= 20; j = -1; } else { /* else_6 */ j += 2; string_ptr_2 = string_ptr_3; string_ptr = string_ptr_3; char_buf = print_str_buf; } } else { num_of_rows = 3; string_ptr_2 = string_ptr_3; string_ptr = string_ptr_3; char_buf = print_str_buf; j = 0; } } if (j != -1 && width * 40 > 8000) num_of_rows = 4; /* while_8 */ while (num_of_rows == 3 && j != -1) { m = strlen(string_ptr) >> 2; m += j; string_ptr_2 += m; while (*string_ptr_2++ != ' ' && m <= letters_per_row) m++; if (m <= letters_per_row) { /* if_10 */ n = (letters_per_row - m + 1) >> 1; while (n) { *char_buf++ = ' '; n--; } strncpy(char_buf, string_ptr, m); char_buf += m; *char_buf++ = '\n'; string_ptr = string_ptr_2; string_ptr_2 += m; while (*string_ptr_2-- != ' ' && m > 0) m--; string_ptr_2 += 2; if (strlen(string_ptr_2) < m * 2 && m > 0) { /* if_11 */ n = (letters_per_row - m + 1) >> 1; while (n) { *char_buf++ = ' '; n--; } strncpy(char_buf, string_ptr, m); char_buf += m; *char_buf++ = 10; string_ptr = string_ptr_2; string_ptr_2 += m; while (*string_ptr_2-- != ' ' && m > 0) m--; string_ptr_2 += 2; if (strlen(string_ptr_2) <= m && m > 0) { /* if_15 */ n = (letters_per_row - m + 1) >> 1; while (n) { *char_buf++ = ' '; n--; } strncpy(char_buf, string_ptr, m); char_buf += m; *char_buf++ = '\n'; height += 30; threeval_b -= 30; j = -1; } else { /* else_15 */ j += 2; string_ptr_2 = string_ptr_3; string_ptr = string_ptr_3; char_buf = print_str_buf; } } else { /* else_11 */ j += 2; string_ptr_2 = string_ptr_3; string_ptr = string_ptr_3; char_buf = print_str_buf; } } else { /* else_10 */ num_of_rows = 4; string_ptr = string_ptr_3; string_ptr_2 = string_ptr_3; char_buf = print_str_buf; } } /* while_8_end */ if (num_of_rows == 4) { while (strlen(string_ptr) > letters_per_row) { m = letters_per_row; string_ptr_2 += m; while (*string_ptr_2-- != ' ') m--; string_ptr_2 += 2; n = (letters_per_row - m + 1) >> 1; while (n) { *char_buf++ = ' '; n--; } strncpy(char_buf, string_ptr, m); char_buf += m; *char_buf++ = 10; height += 10; threeval_b -= 10; string_ptr = string_ptr_2; } } n = (letters_per_row - strlen(string_ptr_2) + 1) >> 1; while (n) { *char_buf++ = ' '; n--; } strcpy(char_buf, string_ptr_2); if (!(_game & GAME_SIMON2)) { o_unk_99_simon1(199 + num_1); } else { o_unk_99_simon2(2, num_1); } num_2 = num_2 * 3 + 192; render_string(num_1, num_2, width, height, print_str_buf); num_of_rows = 4; if (!(_bit_array[8] & 0x20)) num_of_rows = 3; if (threeval_b < 2) threeval_b = 2; // Fixme (pos): look at mine // ladder, look at gorge, etc if (!(_game & GAME_SIMON2)) { start_vga_code(num_of_rows, 2, 199 + num_1, threeval_a >> 3, threeval_b, 12); } else { start_vga_code(num_of_rows, 2, num_1, threeval_a >> 3, threeval_b, 12); } } void SimonState::render_string(uint num_1, uint color, uint width, uint height, const char *txt) { VgaPointersEntry *vpe = &_vga_buffer_pointers[2]; byte *src, *dst, *p, *dst_org, chr; uint count; if (num_1 >= 100) { num_1 -= 100; vpe++; } src = dst = vpe->vgaFile2; count = 4000; if (num_1 == 1) count *= 2; p = dst + num_1 * 8; *(uint16 *)(p + 4) = TO_BE_16(height); *(uint16 *)(p + 6) = TO_BE_16(width); dst += READ_BE_UINT32_UNALIGNED(p); memset(dst, 0, count); dst_org = dst; while ((chr = *txt++) != 0) { if (chr == 10) { dst_org += width * 10; dst = dst_org; } else if ((chr -= ' ') == 0) { dst += 6; } else { byte *img_hdr = src + 48 + chr * 4; uint img_height = img_hdr[2]; uint img_width = img_hdr[3], i; byte *img = src + READ_LE_UINT16(img_hdr); byte *cur_dst = dst; assert(img_width > 0 && img_width < 50 && img_height > 0 && img_height < 50); do { for (i = 0; i != img_width; i++) { chr = *img++; if (chr) { if (chr == 0xF) chr = 207; else chr += color; cur_dst[i] = chr; } } cur_dst += width; } while (--img_height); dst += img_width - 1; } } } void SimonState::showmessage_print_char(byte chr) { if (chr == 12) { _num_letters_to_print = 0; _print_char_unk_1 = 0; print_char_helper_1(&chr, 1); print_char_helper_5(_fcs_ptr_1); } else if (chr == 0 || chr == ' ' || chr == 10) { if (_print_char_unk_2 - _print_char_unk_1 >= _num_letters_to_print) { _print_char_unk_1 += _num_letters_to_print; print_char_helper_1(_letters_to_print_buf, _num_letters_to_print); if (_print_char_unk_1 == _print_char_unk_2) { _print_char_unk_1 = 0; } else { if (chr) print_char_helper_1(&chr, 1); if (chr == 10) _print_char_unk_1 = 0; else if (chr != 0) _print_char_unk_1++; } } else { const byte newline_character = 10; _print_char_unk_1 = _num_letters_to_print; print_char_helper_1(&newline_character, 1); print_char_helper_1(_letters_to_print_buf, _num_letters_to_print); if (chr == ' ') { print_char_helper_1(&chr, 1); _print_char_unk_1++; } else { print_char_helper_1(&chr, 1); _print_char_unk_1 = 0; } } _num_letters_to_print = 0; } else { _letters_to_print_buf[_num_letters_to_print++] = chr; } } void SimonState::print_char_helper_1(const byte *src, uint len) { uint ind; if (_fcs_ptr_1 == NULL) return; while (len-- != 0) { if (*src != 12 && _fcs_ptr_1->fcs_data != NULL && _fcs_data_1[ind = get_fcs_ptr_3_index(_fcs_ptr_1)] != 2) { _fcs_data_1[ind] = 2; _fcs_data_2[ind] = 1; } fcs_putchar(*src++); } } void SimonState::print_char_helper_5(FillOrCopyStruct *fcs) { uint index = get_fcs_ptr_3_index(fcs); print_char_helper_6(index); _fcs_data_1[index] = 0; } void SimonState::print_char_helper_6(uint i) { FillOrCopyStruct *fcs; if (_fcs_data_2[i]) { lock(); fcs = _fcs_ptr_array_3[i]; fcs_unk_proc_1(i, fcs->fcs_data->item_ptr, fcs->fcs_data->unk1, fcs->fcs_data->unk2); _fcs_data_2[i] = 0; unlock(); } } void SimonState::read_vga_from_datfile_1(uint vga_id) { if (_game == GAME_SIMON1DOS) { File in; char buf[50]; uint32 size; // FIXME - weird hack to make the beard show up when wearing it (see bug #590800) if (vga_id == 328) sprintf(buf, "0119.VGA"); else sprintf(buf, "%.3d%d.VGA", vga_id >> 1, (vga_id & 1) + 1); in.open(buf, _gameDataPath); if (in.isOpen() == false) { warning("read_vga_from_datfile_1: cannot open %s", buf); return; } in.seek(0, SEEK_END); size = in.pos(); in.seek(0, SEEK_SET); if (in.read(_vga_buffer_pointers[11].vgaFile2, size) != size) error("read_vga_from_datfile_1: read failed"); in.close(); } else { uint32 offs_a = _game_offsets_ptr[vga_id]; uint32 size = _game_offsets_ptr[vga_id + 1] - offs_a; resfile_read(_vga_buffer_pointers[11].vgaFile2, offs_a, size); } } byte *SimonState::read_vga_from_datfile_2(uint id) { if (_game == GAME_SIMON1DOS) { File in; char buf[50]; uint32 size; byte *dst; sprintf(buf, "%.3d%d.VGA", id >> 1, (id & 1) + 1); in.open(buf, _gameDataPath); if (in.isOpen() == false) error("read_vga_from_datfile_2: cannot open %s", buf); in.seek(0, SEEK_END); size = in.pos(); in.seek(0, SEEK_SET); dst = setup_vga_destination(size); if (in.read(dst, size) != size) error("read_vga_from_datfile_2: read failed"); in.close(); return dst; } else { uint32 offs_a = _game_offsets_ptr[id]; uint32 size = _game_offsets_ptr[id + 1] - offs_a; byte *dst; dst = setup_vga_destination(size); resfile_read(dst, offs_a, size); return dst; } } void SimonState::resfile_read(void *dst, uint32 offs, uint32 size) { _game_file->seek(offs, SEEK_SET); if (_game_file->read(dst, size) != size) error("resfile_read(%d,%d) read failed", offs, size); } void SimonState::openGameFile() { if (_game != GAME_SIMON1DOS) { _game_file = new File(); _game_file->open(gss->gme_filename, _gameDataPath); if (_game_file->isOpen() == false) error("cannot open game file '%s'", gss->gme_filename); _game_offsets_ptr = (uint32 *)malloc(gss->NUM_GAME_OFFSETS * sizeof(uint32)); if (_game_offsets_ptr == NULL) error("out of memory, game offsets"); resfile_read(_game_offsets_ptr, 0, gss->NUM_GAME_OFFSETS * sizeof(uint32)); #if defined(SCUMM_BIG_ENDIAN) for (uint r = 0; r < gss->NUM_GAME_OFFSETS; r++) _game_offsets_ptr[r] = READ_LE_UINT32(&_game_offsets_ptr[r]); #endif } loadIconFile(); _system->init_size(320, 200); startUp(1); } void SimonState::startUp(uint a) { if (a == 1) startUp_helper(); } void SimonState::startUp_helper() { runSubroutine101(); startUp_helper_2(); } void SimonState::runSubroutine101() { Subroutine *sub; sub = getSubroutineByID(101); if (sub != NULL) startSubroutineEx(sub); startUp_helper_2(); } #if 0 void SimonState::generateSound(byte *ptr, int len) { uint cur; cur = _voice_size; if (cur > (uint) len) cur = (uint) len; _voice_size -= cur; if (cur != 0) { fread(ptr, cur, 1, _voice_file); } memset(ptr + cur, 0x80, len - cur); cur = _sound_size; if (cur) { uint i; if (cur > (uint) len) cur = (uint) len; for (i = 0; i != cur; i++) { ptr[i] += _sound_ptr[i] ^ 0x80; } _sound_size -= cur; _sound_ptr += cur; } } #endif //static void fill_sound(void *userdata, int16 *stream, int len) { // ((SimonState*)userdata)->generateSound((byte*)stream, len*2); //} void SimonState::dx_copy_rgn_from_3_to_2(uint b, uint r, uint y, uint x) { byte *dst, *src; uint i; dst = dx_lock_2(); src = _sdl_buf_3; dst += y * _dx_surface_pitch; src += y * _dx_surface_pitch; while (y < b) { for (i = x; i < r; i++) dst[i] = src[i]; y++; dst += _dx_surface_pitch; src += _dx_surface_pitch; } dx_unlock_2(); } void SimonState::dx_clear_surfaces(uint num_lines) { memset(_sdl_buf_attached, 0, num_lines * 320); _system->copy_rect(_sdl_buf_attached, 320, 0, 0, 320, 200); if (_dx_use_3_or_4_for_lock) { memset(_sdl_buf, 0, num_lines * 320); memset(_sdl_buf_3, 0, num_lines * 320); } } void SimonState::dx_clear_attached_from_top(uint lines) { memset(_sdl_buf_attached, 0, lines * 320); } void SimonState::dx_copy_from_attached_to_2(uint x, uint y, uint w, uint h) { uint offs = x + y * 320; byte *s = _sdl_buf_attached + offs; byte *d = _sdl_buf + offs; do { memcpy(d, s, w); d += 320; s += 320; } while (--h); } void SimonState::dx_copy_from_2_to_attached(uint x, uint y, uint w, uint h) { uint offs = x + y * 320; byte *s = _sdl_buf + offs; byte *d = _sdl_buf_attached + offs; do { memcpy(d, s, w); d += 320; s += 320; } while (--h); } void SimonState::dx_copy_from_attached_to_3(uint lines) { memcpy(_sdl_buf_3, _sdl_buf_attached, lines * 320); } void SimonState::dx_update_screen_and_palette() { _num_screen_updates++; if (_palette_color_count == 0 && _video_var_9 == 1) { _video_var_9 = 0; if (memcmp(_palette, _palette_backup, 256 * 4) != 0) { memcpy(_palette_backup, _palette, 256 * 4); _system->set_palette(_palette, 0, 256); } } if (!_fast_mode || !(rand() & 7)) { if (_mouse_pos_changed) { _mouse_pos_changed = false; _system->set_mouse_pos(_sdl_mouse_x, _sdl_mouse_y); } _system->copy_rect(_sdl_buf_attached, 320, 0, 0, 320, 200); _system->update_screen(); } memcpy(_sdl_buf_attached, _sdl_buf, 320 * 200); if (_palette_color_count != 0) { if (!(_game & GAME_SIMON2) && _use_palette_delay) { delay(100); _use_palette_delay = false; } realizePalette(); } } void SimonState::realizePalette() { if (_palette_color_count & 0x8000) { error("_palette_color_count&0x8000"); } _video_var_9 = false; memcpy(_palette_backup, _palette, 256 * 4); _system->set_palette(_palette, 0, _palette_color_count); _palette_color_count = 0; } void SimonState::go() { OSystem::Property prop; if (!_dump_file) _dump_file = stdout; /* allocate buffers */ _sdl_buf_3 = (byte *)calloc(320 * 200, 1); _sdl_buf = (byte *)calloc(320 * 200, 1); _sdl_buf_attached = (byte *)calloc(320 * 200, 1); if (_game == GAME_SIMON2WIN) { gss = &simon2win_settings; } else if (_game == GAME_SIMON2DOS) { gss = &simon2dos_settings; } else { gss = &simon1_settings; } allocItemHeap(); allocTablesHeap(); setup_vga_file_buf_pointers(); initSound(); if (!loadGamePcFile(gss->gamepc_filename)) error("Error loading gamepc file '%s' (or one of the files it depends on)", gss->gamepc_filename); addTimeEvent(0, 1); openGameFile(); _last_music_played = (uint) - 1; _vga_base_delay = 1; _vk_t_toggle = true; prop.show_cursor = true; _system->property(OSystem::PROP_SHOW_DEFAULT_CURSOR, &prop); while (1) { hitarea_stuff(); handle_verb_clicked(_verb_hitarea); delay(100); } } void SimonState::shutdown() { if (_game_file) { delete _game_file; _game_file = NULL; } } void SimonState::delay(uint delay) { OSystem::Event event; uint32 start = _system->get_msecs(); uint32 cur = start; const uint vga_period = _fast_mode ? 10 : 50; do { while (!_in_callback && cur >= _last_vga_tick + vga_period) { _last_vga_tick += vga_period; /* don't get too many frames behind */ if (cur >= _last_vga_tick + vga_period * 2) _last_vga_tick = cur; _in_callback = true; timer_callback(); _in_callback = false; } while (_system->poll_event(&event)) { switch (event.event_code) { case OSystem::EVENT_KEYDOWN: if (event.kbd.keycode == 't') { _vk_t_toggle ^= 1; } else if (event.kbd.flags == OSystem::KBD_CTRL) { if (event.kbd.keycode == 'f') { _fast_mode ^= 1; } } _key_pressed = (byte)event.kbd.ascii; break; case OSystem::EVENT_MOUSEMOVE: _sdl_mouse_x = event.mouse.x; _sdl_mouse_y = event.mouse.y; _mouse_pos_changed = true; break; case OSystem::EVENT_LBUTTONDOWN: _left_button_down++; #ifdef _WIN32_WCE _sdl_mouse_x = event.mouse.x; _sdl_mouse_y = event.mouse.y; #endif break; case OSystem::EVENT_RBUTTONDOWN: _exit_cutscene = true; break; } } if (delay == 0) break; { uint this_delay = _fast_mode ? 1 : 20; if (this_delay > delay) this_delay = delay; _system->delay_msecs(this_delay); } cur = _system->get_msecs(); } while (cur < start + delay); } bool SimonState::save_game(uint slot, const char *caption) { File f; uint item_index, num_item, i; TimeEvent *te; _lock_word |= 0x100; #ifndef _WIN32_WCE errno = 0; #endif f.open(gen_savename(slot), getSavePath(), 2); if (f.isOpen() == false) { _lock_word &= ~0x100; return false; } f.write((char*)caption, 0x12); f.writeDwordBE(_itemarray_inited - 1); f.writeDwordBE(0xFFFFFFFF); f.writeDwordBE(0); f.writeDwordBE(0); i = 0; for (te = _first_time_struct; te; te = te->next) i++; f.writeDwordBE(i); for (te = _first_time_struct; te; te = te->next) { f.writeDwordBE(te->time + _base_time); f.writeWordBE(te->subroutine_id); } item_index = 1; for (num_item = _itemarray_inited - 1; num_item; num_item--) { Item *item = _itemarray_ptr[item_index++]; f.writeWordBE(item->parent); f.writeWordBE(item->sibling); f.writeWordBE(item->unk3); f.writeWordBE(item->unk4); { Child1 *child1 = findChildOfType1(item); if (child1) { f.writeWordBE(child1->fr2); } } { Child2 *child2 = findChildOfType2(item); uint i, j; if (child2) { f.writeDwordBE(child2->avail_props); i = child2->avail_props & 1; for (j = 1; j < 16; j++) { if ((1 << j) & child2->avail_props) { f.writeWordBE(child2->array[i++]); } } } } { Child9 *child9 = (Child9 *) findChildOfType(item, 9); if (child9) { uint i; for (i = 0; i != 4; i++) { f.writeWordBE(child9->array[i]); } } } } /* write the 255 variables */ for (i = 0; i != 255; i++) { f.writeWordBE(readVariable(i)); } /* write the items in array 6 */ for (i = 0; i != 10; i++) { f.writeWordBE(itemPtrToID(_item_array_6[i])); } /* Write the bits in array 1 & 2 */ for (i = 0; i != 32; i++) f.writeWordBE(_bit_array[i]); f.close(); _lock_word &= ~0x100; return true; } char *SimonState::gen_savename(int slot) { static char buf[256]; sprintf(buf, "SAVE.%.3d", slot); return buf; } bool SimonState::load_game(uint slot) { char ident[18]; File f; uint num, item_index, i; _lock_word |= 0x100; #ifndef _WIN32_WCE errno = 0; #endif f.open(gen_savename(slot), getSavePath(), 1); if (f.isOpen() == false) { _lock_word &= ~0x100; return false; } f.read(ident, 18); num = f.readDwordBE(); if (f.readDwordBE() != 0xFFFFFFFF || num != _itemarray_inited - 1) { f.close(); _lock_word &= ~0x100; return false; } f.readDwordBE(); f.readDwordBE(); _no_parent_notify = true; /* add all timers */ killAllTimers(); for (num = f.readDwordBE(); num; num--) { uint32 timeout = f.readDwordBE(); uint16 func_to_call = f.readWordBE(); addTimeEvent(timeout, func_to_call); } item_index = 1; for (num = _itemarray_inited - 1; num; num--) { Item *item = _itemarray_ptr[item_index++], *parent_item; uint parent = f.readWordBE(); uint sibling = f.readWordBE(); parent_item = derefItem(parent); setItemParent(item, parent_item); if (parent_item == NULL) { item->parent = parent; item->sibling = sibling; } item->unk3 = f.readWordBE(); item->unk4 = f.readWordBE(); { Child1 *child1 = findChildOfType1(item); if (child1 != NULL) { child1->fr2 = f.readWordBE(); } } { Child2 *child2 = findChildOfType2(item); uint i, j; if (child2 != NULL) { child2->avail_props = f.readDwordBE(); i = child2->avail_props & 1; for (j = 1; j < 16; j++) { if ((1 << j) & child2->avail_props) { child2->array[i++] = f.readWordBE(); } } } } { Child9 *child9 = (Child9 *) findChildOfType(item, 9); if (child9) { uint i; for (i = 0; i != 4; i++) { child9->array[i] = f.readWordBE(); } } } } /* read the 255 variables */ for (i = 0; i != 255; i++) { writeVariable(i, f.readWordBE()); } /* write the items in array 6 */ for (i = 0; i != 10; i++) { _item_array_6[i] = derefItem(f.readWordBE()); } /* Write the bits in array 1 & 2 */ for (i = 0; i != 32; i++) _bit_array[i] = f.readWordBE(); f.close(); _no_parent_notify = false; _lock_word &= ~0x100; #ifndef _WIN32_WCE if (errno != 0) error("load failed"); #endif return true; } void SimonState::initSound() { /* only read voice file in windows game */ if (_game & GAME_WIN) { const char *s = gss->wav_filename; const char *s2 = gss->wav_filename2; const char *e = gss->effects_filename; _voice_offsets = NULL; _voice_file = new File(); _voice_file->open(s, _gameDataPath); if (_voice_file->isOpen() == false) { warning("Cannot open voice file %s, trying %s", s, s2); if (s2) { _voice_file->open(s2, _gameDataPath); if (_voice_file->isOpen() == false) { warning("Cannot open voice file %s", s2); return; } } else return; } _voice_offsets = (uint32 *)malloc(gss->NUM_VOICE_RESOURCES * sizeof(uint32)); if (_voice_offsets == NULL) error("Out of memory for voice offsets"); if (_voice_file->read(_voice_offsets, gss->NUM_VOICE_RESOURCES * sizeof(uint32)) != gss->NUM_VOICE_RESOURCES * sizeof(uint32)) error("Cannot read voice offsets"); _effects_offsets = NULL; _effects_file = new File(); _effects_file->open(e, _gameDataPath); if (_effects_file->isOpen() == true) { _effects_offsets = (uint32 *)malloc(gss->NUM_EFFECTS_RESOURCES * sizeof(uint32)); if (_effects_offsets == NULL) error("Out of memory for effects offsets"); if (_effects_file->read(_effects_offsets, gss->NUM_EFFECTS_RESOURCES * sizeof(uint32)) != gss->NUM_EFFECTS_RESOURCES * sizeof(uint32)) error("Cannot read effects offsets"); } #if defined(SCUMM_BIG_ENDIAN) uint r; for (r = 0; r < gss->NUM_VOICE_RESOURCES; r++) _voice_offsets[r] = READ_LE_UINT32(&_voice_offsets[r]); if (_effects_offsets) for (r = 0; r < gss->NUM_EFFECTS_RESOURCES; r++) _effects_offsets[r] = READ_LE_UINT32(&_effects_offsets[r]); #endif } } #if !defined(__GNUC__) #pragma START_PACK_STRUCTS #endif struct WaveHeader { uint32 riff; uint32 unk; uint32 wave; uint32 fmt; uint32 size; uint16 format_tag; uint16 channels; uint32 samples_per_sec; uint32 avg_bytes; uint16 block_align; uint16 bits_per_sample; } GCC_PACK; struct VocHeader { uint8 desc[20]; uint16 datablock_offset; uint16 version; uint16 id; uint8 blocktype; } GCC_PACK; struct VocBlockHeader { uint8 tc; uint8 pack; } GCC_PACK; #if !defined(__GNUC__) #pragma END_PACK_STRUCTS #endif void SimonState::playVoice(uint voice) { _mixer->stop(_voice_sound); _voice_file->seek(_voice_offsets[voice], SEEK_SET); if (!_effects_offsets) { /* WAVE audio */ WaveHeader wave_hdr; uint32 data[2]; if (_voice_file->read(&wave_hdr, sizeof(wave_hdr)) != sizeof(wave_hdr) || wave_hdr.riff != MKID('RIFF') || wave_hdr.wave != MKID('WAVE') || wave_hdr.fmt != MKID('fmt ') || READ_LE_UINT16(&wave_hdr.format_tag) != 1 || READ_LE_UINT16(&wave_hdr.channels) != 1 || READ_LE_UINT16(&wave_hdr.bits_per_sample) != 8) { warning("playVoice(%d): cannot read RIFF header", voice); return; } _voice_file->seek(READ_LE_UINT32(&wave_hdr.size) - sizeof(wave_hdr) + 20, SEEK_CUR); data[0] = _voice_file->readDwordLE(); data[1] = _voice_file->readDwordLE(); if ( //fread(data, sizeof(data), 1, _voice_file) != 1 || data[0] != 'atad') { warning("playVoice(%d): cannot read data header", voice); return; } byte *buffer = (byte *)malloc(data[1]); _voice_file->read(buffer, data[1]); _mixer->playRaw(&_voice_sound, buffer, data[1], READ_LE_UINT32(&wave_hdr.samples_per_sec), SoundMixer::FLAG_UNSIGNED); } else { /* VOC audio */ VocHeader voc_hdr; VocBlockHeader voc_block_hdr; uint32 size; if (_voice_file->read(&voc_hdr, sizeof(voc_hdr)) != sizeof(voc_hdr) || strncmp((char *)voc_hdr.desc, "Creative Voice File\x1A", 10) != 0) { warning("playVoice(%d): cannot read voc header", voice); return; } _voice_file->read(&size, 4); size = size & 0xffffff; _voice_file->seek(-1, SEEK_CUR); _voice_file->read(&voc_block_hdr, sizeof(voc_block_hdr)); uint32 samples_per_sec = 1000000L / (256L - (long)voc_block_hdr.tc); byte *buffer = (byte *)malloc(size); _voice_file->read(buffer, size); _mixer->playRaw(&_voice_sound, buffer, size, samples_per_sec, SoundMixer::FLAG_UNSIGNED); } } void SimonState::playSound(uint sound) { if (_game & GAME_WIN) { if (_effects_offsets) { /* VOC sound file */ VocHeader voc_hdr; VocBlockHeader voc_block_hdr; uint32 size; _mixer->stop(_effects_sound); _effects_file->seek(_effects_offsets[sound], SEEK_SET); if (_effects_file->read(&voc_hdr, sizeof(voc_hdr)) != sizeof(voc_hdr) || strncmp((char *)voc_hdr.desc, "Creative Voice File\x1A", 10) != 0) { warning("playSound(%d): cannot read voc header", sound); return; } _effects_file->read(&size, 4); size = size & 0xffffff; _effects_file->seek(-1, SEEK_CUR); _effects_file->read(&voc_block_hdr, sizeof(voc_block_hdr)); uint32 samples_per_sec = 1000000L / (256L - (long)voc_block_hdr.tc); byte *buffer = (byte *)malloc(size); _effects_file->read(buffer, size); _mixer->playRaw(&_effects_sound, buffer, size, samples_per_sec, SoundMixer::FLAG_UNSIGNED); } else { byte *p; _mixer->stop(_playing_sound); /* Check if _sfx_heap is NULL */ if (_sfx_heap == NULL) { warning("playSound(%d) cannot play. No voice file loaded", sound); return; } p = _sfx_heap + READ_LE_UINT32(&((uint32 *)_sfx_heap)[sound]); for (;;) { p = (byte *)memchr(p, 'd', 1000); if (!p) { error("playSound(%d): didn't find", sound); return; } if (p[1] == 'a' && p[2] == 't' && p[3] == 'a') break; p++; } _mixer->playRaw(&_playing_sound, p + 8, READ_LE_UINT32(p + 4), 22050, SoundMixer::FLAG_UNSIGNED); } } else { warning("playSound(%d)", sound); } } void SimonState::playMusic(uint music) { midi.shutdown(); /* FIXME: not properly implemented */ if (_game & GAME_WIN) { _game_file->seek(_game_offsets_ptr[gss->MUSIC_INDEX_BASE + music] - 1, SEEK_SET); File *f = _game_file; midi.read_all_songs(f); } else { char buf[50]; File *f = new File(); sprintf(buf, "MOD%d.MUS", music); f->open(buf, _gameDataPath); if (f->isOpen() == false) { warning("Cannot load music from '%s'", buf); return; } midi.read_all_songs_old(f); f->close(); } midi.initialize(); midi.play(); } byte *SimonState::dx_lock_2() { _dx_surface_pitch = 320; return _sdl_buf; } void SimonState::dx_unlock_2() { } byte *SimonState::dx_lock_attached() { _dx_surface_pitch = 320; return _dx_use_3_or_4_for_lock ? _sdl_buf_3 : _sdl_buf_attached; } void SimonState::dx_unlock_attached() { } void SimonState::set_volume(byte volume) { _mixer->setVolume(volume); } byte SimonState::getByte() { return *_code_ptr++; }