diff options
66 files changed, 30832 insertions, 0 deletions
diff --git a/engines/gnap/datarchive.cpp b/engines/gnap/datarchive.cpp new file mode 100644 index 0000000000..d480d31e67 --- /dev/null +++ b/engines/gnap/datarchive.cpp @@ -0,0 +1,121 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "common/dcl.h" +#include "common/file.h" +#include "common/stream.h" +#include "common/substream.h" +#include "gnap/datarchive.h" + +#include "engines/util.h" + +namespace Gnap { + +// DatArchive + +DatArchive::DatArchive(const char *filename) { + _fd = new Common::File(); + if (!_fd->open(filename)) + error("DatArchive::DatArchive() Could not open %s", filename); + _fd->skip(8); // Skip signature + _fd->skip(2); // Skip unknown + _fd->skip(2); // Skip unknown + _entriesCount = _fd->readUint32LE(); + debug(1, "_entriesCount: %d", _entriesCount); + _fd->skip(4); // Skip unknown + _entries = new DatEntry[_entriesCount]; + for (int i = 0; i < _entriesCount; ++i) { + _entries[i].ofs = _fd->readUint32LE(); + _entries[i].outSize1 = _fd->readUint32LE(); + _entries[i].type = _fd->readUint32LE(); + _entries[i].outSize2 = _fd->readUint32LE(); + } +} + +DatArchive::~DatArchive() { + _fd->close(); + delete _fd; + delete[] _entries; +} + +byte *DatArchive::load(int index) { + _fd->seek(_entries[index].ofs); + debug(1, "_entries[index].outSize2: %d; _entries[index].outSize1: %d", _entries[index].outSize2, _entries[index].outSize1); + byte *buffer = new byte[_entries[index].outSize1]; + if (!Common::decompressDCL(_fd, buffer, 0, _entries[index].outSize1)) + error("DatArchive::load() Error during decompression of entry %d", index); + return buffer; +} + +// DatManager + +DatManager::DatManager() { + for (int i = 0; i < kMaxDatArchives; ++i) + _datArchives[i] = 0; +} + +DatManager::~DatManager() { + for (int i = 0; i < kMaxDatArchives; ++i) + delete _datArchives[i]; +} + +void DatManager::open(int index, const char *filename) { + close(index); + _datArchives[index] = new DatArchive(filename); +} + +void DatManager::close(int index) { + delete _datArchives[index]; + _datArchives[index] = 0; +} + +byte *DatManager::loadResource(int resourceId) { + const int datIndex = ridToDatIndex(resourceId); + const int entryIndex = ridToEntryIndex(resourceId); + return _datArchives[datIndex] ? _datArchives[datIndex]->load(entryIndex) : 0; +} + +uint32 DatManager::getResourceType(int resourceId) { + const int datIndex = ridToDatIndex(resourceId); + const int entryIndex = ridToEntryIndex(resourceId); + return _datArchives[datIndex] ? _datArchives[datIndex]->getEntryType(entryIndex) : 0; +} + +uint32 DatManager::getResourceSize(int resourceId) { + const int datIndex = ridToDatIndex(resourceId); + const int entryIndex = ridToEntryIndex(resourceId); + return _datArchives[datIndex] ? _datArchives[datIndex]->getEntrySize(entryIndex) : 0; +} + +int ridToDatIndex(int resourceId) { + return (resourceId & 0xFFFF0000) >> 16; +} + +int ridToEntryIndex(int resourceId) { + return resourceId & 0xFFFF; +} + +int makeRid(int datIndex, int entryIndex) { + return (datIndex << 16) | entryIndex; +} + +} // End of namespace Gnap diff --git a/engines/gnap/datarchive.h b/engines/gnap/datarchive.h new file mode 100644 index 0000000000..2fd431bf70 --- /dev/null +++ b/engines/gnap/datarchive.h @@ -0,0 +1,80 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#ifndef GNAP_DATARCHIVE_H +#define GNAP_DATARCHIVE_H + +#include "common/array.h" +#include "common/events.h" +#include "common/file.h" +#include "common/memstream.h" +#include "common/random.h" +#include "common/str.h" +#include "common/substream.h" +#include "common/system.h" +#include "engines/engine.h" + +namespace Gnap { + +struct DatEntry { + uint32 ofs; + uint32 outSize1; + uint32 type; + uint32 outSize2; +}; + +class DatArchive { +public: + DatArchive(const char *filename); + ~DatArchive(); + byte *load(int index); + int getCount() const { return _entriesCount; } + uint32 getEntryType(int index) { return _entries[index].type; } + uint32 getEntrySize(int index) { return _entries[index].outSize1; } +protected: + Common::File *_fd; + int _entriesCount; + DatEntry *_entries; +}; + +const int kMaxDatArchives = 2; + +class DatManager { +public: + DatManager(); + ~DatManager(); + void open(int index, const char *filename); + void close(int index); + byte *loadResource(int resourceId); + uint32 getResourceType(int resourceId); + uint32 getResourceSize(int resourceId); +protected: + DatArchive *_datArchives[kMaxDatArchives]; +}; + +int ridToDatIndex(int resourceId); +int ridToEntryIndex(int resourceId); +int makeRid(int datIndex, int entryIndex); + +} // End of namespace Gnap + +#endif // GNAP_DATARCHIVE_H diff --git a/engines/gnap/detection.cpp b/engines/gnap/detection.cpp new file mode 100644 index 0000000000..8898d9069a --- /dev/null +++ b/engines/gnap/detection.cpp @@ -0,0 +1,195 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "gnap/gnap.h" + +#include "common/config-manager.h" +#include "engines/advancedDetector.h" +#include "common/savefile.h" +#include "common/system.h" +#include "base/plugins.h" +#include "graphics/thumbnail.h" + +static const PlainGameDescriptor gnapGames[] = { + { "gnap", "Gnap" }, + { 0, 0 } +}; + +namespace Gnap { + +static const ADGameDescription gameDescriptions[] = { + { + "gnap", "", + { + {"stock_n.dat", 0, "46819043d019a2f36b727cc2bdd6980f", 12515823}, + AD_LISTEND + }, + Common::EN_ANY, Common::kPlatformWindows, ADGF_NO_FLAGS, GUIO0() + }, + + AD_TABLE_END_MARKER +}; + +} // End of namespace Gnap + +class GnapMetaEngine : public AdvancedMetaEngine { +public: + GnapMetaEngine() : AdvancedMetaEngine(Gnap::gameDescriptions, sizeof(ADGameDescription), gnapGames) { + _singleid = "gnap"; + _maxScanDepth = 3; + } + + virtual const char *getName() const { + return "Gnap"; + } + + virtual const char *getOriginalCopyright() const { + return "Gnap (C) 1999"; + } + + virtual bool hasFeature(MetaEngineFeature f) const; + virtual bool createInstance(OSystem *syst, Engine **engine, const ADGameDescription *desc) const; + virtual int getMaximumSaveSlot() const; + virtual SaveStateList listSaves(const char *target) const; + SaveStateDescriptor querySaveMetaInfos(const char *target, int slot) const; + virtual void removeSaveState(const char *target, int slot) const; +}; + +bool GnapMetaEngine::hasFeature(MetaEngineFeature f) const { + return + false; +#if 0 + (f == kSupportsListSaves) || + (f == kSupportsLoadingDuringStartup) || + (f == kSupportsDeleteSave) || + (f == kSavesSupportMetaInfo) || + (f == kSavesSupportThumbnail) || + (f == kSavesSupportCreationDate); +#endif +} + +void GnapMetaEngine::removeSaveState(const char *target, int slot) const { + Common::String fileName = Common::String::format("%s.%03d", target, slot); + g_system->getSavefileManager()->removeSavefile(fileName); +} + +int GnapMetaEngine::getMaximumSaveSlot() const { return 99; } + +SaveStateList GnapMetaEngine::listSaves(const char *target) const { + Common::SaveFileManager *saveFileMan = g_system->getSavefileManager(); + Common::StringArray filenames; + Common::String pattern = target; + pattern += ".???"; + + filenames = saveFileMan->listSavefiles(pattern); + sort(filenames.begin(), filenames.end()); // Sort (hopefully ensuring we are sorted numerically..) + + SaveStateList saveList; +#if 0 + int slotNum = 0; + for (Common::StringArray::const_iterator filename = filenames.begin(); filename != filenames.end(); ++filename) { + // Obtain the last 3 digits of the filename, since they correspond to the save slot + slotNum = atoi(filename->c_str() + filename->size() - 3); + + if (slotNum >= 0 && slotNum <= 99) { + Common::InSaveFile *file = saveFileMan->openForLoading(*filename); + if (file) { + int32 version = file->readSint32BE(); + if (version != GNAP_SAVEGAME_VERSION) { + delete file; + continue; + } + + // read name + uint16 nameSize = file->readUint16BE(); + if (nameSize >= 255) { + delete file; + continue; + } + char name[256]; + file->read(name, nameSize); + name[nameSize] = 0; + + saveList.push_back(SaveStateDescriptor(slotNum, name)); + delete file; + } + } + } +#endif + return saveList; +} + +SaveStateDescriptor GnapMetaEngine::querySaveMetaInfos(const char *target, int slot) const { +#if 0 + Common::String fileName = Common::String::format("%s.%03d", target, slot); + Common::InSaveFile *file = g_system->getSavefileManager()->openForLoading(fileName); + if (file) { + + int32 version = file->readSint32BE(); + if (version != GNAP_SAVEGAME_VERSION) { + delete file; + return SaveStateDescriptor(); + } + + uint32 saveNameLength = file->readUint16BE(); + char saveName[256]; + file->read(saveName, saveNameLength); + saveName[saveNameLength] = 0; + + SaveStateDescriptor desc(slot, saveName); + + Graphics::Surface *const thumbnail = Graphics::loadThumbnail(*file); + desc.setThumbnail(thumbnail); + + uint32 saveDate = file->readUint32BE(); + uint16 saveTime = file->readUint16BE(); + + int day = (saveDate >> 24) & 0xFF; + int month = (saveDate >> 16) & 0xFF; + int year = saveDate & 0xFFFF; + + desc.setSaveDate(year, month, day); + + int hour = (saveTime >> 8) & 0xFF; + int minutes = saveTime & 0xFF; + + desc.setSaveTime(hour, minutes); + + delete file; + return desc; + } +#endif + return SaveStateDescriptor(); +} + +bool GnapMetaEngine::createInstance(OSystem *syst, Engine **engine, const ADGameDescription *desc) const { + if (desc) { + *engine = new Gnap::GnapEngine(syst, desc); + } + return desc != 0; +} + +#if PLUGIN_ENABLED_DYNAMIC(GNAP) + REGISTER_PLUGIN_DYNAMIC(GNAP, PLUGIN_TYPE_ENGINE, GnapMetaEngine); +#else + REGISTER_PLUGIN_STATIC(GNAP, PLUGIN_TYPE_ENGINE, GnapMetaEngine); +#endif diff --git a/engines/gnap/fontdata.h b/engines/gnap/fontdata.h new file mode 100644 index 0000000000..9ad0d23ae8 --- /dev/null +++ b/engines/gnap/fontdata.h @@ -0,0 +1,851 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#ifndef GNAP_FONTDATA_H +#define GNAP_FONTDATA_H + +namespace Gnap { + +struct FONT_CHAR_INFO { + const byte width; // width, in bits (or pixels), of the character + const uint16 offset; // offset of the character's bitmap, in bytes, into the the FONT_INFO's data array +}; + +/* +** Font data for DejaVu Sans 9pt +*/ + +/* Character bitmaps for DejaVu Sans 9pt */ +const byte dejaVuSans9ptCharBitmaps[] = +{ + /* @0 ' ' (5 pixels wide) */ + 0x00, 0x00, /* */ + 0x00, 0x00, /* */ + 0x00, 0x00, /* */ + 0x00, 0x00, /* */ + 0x00, 0x00, /* */ + + /* @10 '!' (1 pixels wide) */ + 0x1B, 0xF0, /* ## ###### */ + + /* @12 '"' (3 pixels wide) */ + 0x00, 0x70, /* ### */ + 0x00, 0x00, /* */ + 0x00, 0x70, /* ### */ + + /* @18 '#' (8 pixels wide) */ + 0x04, 0x00, /* # */ + 0x14, 0x80, /* # # # */ + 0x0F, 0x80, /* ##### */ + 0x04, 0xE0, /* # ### */ + 0x1C, 0x80, /* ### # */ + 0x07, 0xC0, /* ##### */ + 0x04, 0xA0, /* # # # */ + 0x00, 0x80, /* # */ + + /* @34 '$' (5 pixels wide) */ + 0x09, 0xC0, /* # ### */ + 0x11, 0x20, /* # # # */ + 0x7F, 0xF0, /* ########### */ + 0x12, 0x20, /* # # # */ + 0x0E, 0x40, /* ### # */ + + /* @44 '%' (10 pixels wide) */ + 0x00, 0xE0, /* ### */ + 0x01, 0x10, /* # # */ + 0x11, 0x10, /* # # # */ + 0x0C, 0xE0, /* ## ### */ + 0x03, 0x00, /* ## */ + 0x01, 0x80, /* ## */ + 0x0E, 0x60, /* ### ## */ + 0x11, 0x10, /* # # # */ + 0x11, 0x00, /* # # */ + 0x0E, 0x00, /* ### */ + + /* @64 '&' (8 pixels wide) */ + 0x0E, 0x00, /* ### */ + 0x19, 0xE0, /* ## #### */ + 0x10, 0x90, /* # # # */ + 0x11, 0x10, /* # # # */ + 0x12, 0x20, /* # # # */ + 0x0C, 0x00, /* ## */ + 0x14, 0x00, /* # # */ + 0x13, 0x00, /* # ## */ + + /* @80 ''' (1 pixels wide) */ + 0x00, 0x70, /* ### */ + + /* @82 '(' (3 pixels wide) */ + 0x07, 0xC0, /* ##### */ + 0x38, 0x38, /* ### ### */ + 0x20, 0x08, /* # # */ + + /* @88 ')' (3 pixels wide) */ + 0x20, 0x08, /* # # */ + 0x38, 0x38, /* ### ### */ + 0x07, 0xC0, /* ##### */ + + /* @94 '*' (5 pixels wide) */ + 0x01, 0x20, /* # # */ + 0x00, 0xC0, /* ## */ + 0x03, 0xF0, /* ###### */ + 0x00, 0xC0, /* ## */ + 0x01, 0x20, /* # # */ + + /* @104 '+' (7 pixels wide) */ + 0x02, 0x00, /* # */ + 0x02, 0x00, /* # */ + 0x02, 0x00, /* # */ + 0x1F, 0xC0, /* ####### */ + 0x02, 0x00, /* # */ + 0x02, 0x00, /* # */ + 0x02, 0x00, /* # */ + + /* @118 ',' (1 pixels wide) */ + 0x38, 0x00, /* ### */ + + /* @120 '-' (3 pixels wide) */ + 0x02, 0x00, /* # */ + 0x02, 0x00, /* # */ + 0x02, 0x00, /* # */ + + /* @126 '.' (1 pixels wide) */ + 0x18, 0x00, /* ## */ + + /* @128 '/' (4 pixels wide) */ + 0x30, 0x00, /* ## */ + 0x0E, 0x00, /* ### */ + 0x01, 0xC0, /* ### */ + 0x00, 0x30, /* ## */ + + /* @136 '0' (6 pixels wide) */ + 0x07, 0xC0, /* ##### */ + 0x18, 0x30, /* ## ## */ + 0x10, 0x10, /* # # */ + 0x10, 0x10, /* # # */ + 0x18, 0x30, /* ## ## */ + 0x07, 0xC0, /* ##### */ + + /* @148 '1' (5 pixels wide) */ + 0x10, 0x10, /* # # */ + 0x10, 0x10, /* # # */ + 0x1F, 0xF0, /* ######### */ + 0x10, 0x00, /* # */ + 0x10, 0x00, /* # */ + + /* @158 '2' (6 pixels wide) */ + 0x10, 0x20, /* # # */ + 0x18, 0x10, /* ## # */ + 0x14, 0x10, /* # # # */ + 0x12, 0x10, /* # # # */ + 0x11, 0x30, /* # # ## */ + 0x10, 0xE0, /* # ### */ + + /* @170 '3' (6 pixels wide) */ + 0x08, 0x20, /* # # */ + 0x10, 0x10, /* # # */ + 0x11, 0x10, /* # # # */ + 0x11, 0x10, /* # # # */ + 0x11, 0x10, /* # # # */ + 0x0E, 0xE0, /* ### ### */ + + /* @182 '4' (6 pixels wide) */ + 0x06, 0x00, /* ## */ + 0x05, 0x80, /* # ## */ + 0x04, 0x40, /* # # */ + 0x04, 0x30, /* # ## */ + 0x1F, 0xF0, /* ######### */ + 0x04, 0x00, /* # */ + + /* @194 '5' (6 pixels wide) */ + 0x08, 0xF0, /* # #### */ + 0x10, 0x90, /* # # # */ + 0x10, 0x90, /* # # # */ + 0x10, 0x90, /* # # # */ + 0x19, 0x90, /* ## ## # */ + 0x0F, 0x00, /* #### */ + + /* @206 '6' (6 pixels wide) */ + 0x07, 0xC0, /* ##### */ + 0x19, 0x20, /* ## # # */ + 0x10, 0x90, /* # # # */ + 0x10, 0x90, /* # # # */ + 0x19, 0x90, /* ## ## # */ + 0x0F, 0x20, /* #### # */ + + /* @218 '7' (6 pixels wide) */ + 0x00, 0x10, /* # */ + 0x10, 0x10, /* # # */ + 0x0C, 0x10, /* ## # */ + 0x03, 0x10, /* ## # */ + 0x00, 0xD0, /* ## # */ + 0x00, 0x30, /* ## */ + + /* @230 '8' (6 pixels wide) */ + 0x0E, 0xE0, /* ### ### */ + 0x11, 0x10, /* # # # */ + 0x11, 0x10, /* # # # */ + 0x11, 0x10, /* # # # */ + 0x11, 0x10, /* # # # */ + 0x0E, 0xE0, /* ### ### */ + + /* @242 '9' (6 pixels wide) */ + 0x09, 0xE0, /* # #### */ + 0x13, 0x30, /* # ## ## */ + 0x12, 0x10, /* # # # */ + 0x12, 0x10, /* # # # */ + 0x09, 0x30, /* # # ## */ + 0x07, 0xC0, /* ##### */ + + /* @254 ':' (1 pixels wide) */ + 0x19, 0x80, /* ## ## */ + + /* @256 ';' (1 pixels wide) */ + 0x39, 0x80, /* ### ## */ + + /* @258 '<' (8 pixels wide) */ + 0x03, 0x00, /* ## */ + 0x03, 0x00, /* ## */ + 0x03, 0x00, /* ## */ + 0x04, 0x80, /* # # */ + 0x04, 0x80, /* # # */ + 0x04, 0x80, /* # # */ + 0x0C, 0xC0, /* ## ## */ + 0x08, 0x40, /* # # */ + + /* @274 '=' (8 pixels wide) */ + 0x05, 0x00, /* # # */ + 0x05, 0x00, /* # # */ + 0x05, 0x00, /* # # */ + 0x05, 0x00, /* # # */ + 0x05, 0x00, /* # # */ + 0x05, 0x00, /* # # */ + 0x05, 0x00, /* # # */ + 0x05, 0x00, /* # # */ + + /* @290 '>' (8 pixels wide) */ + 0x08, 0x40, /* # # */ + 0x0C, 0xC0, /* ## ## */ + 0x04, 0x80, /* # # */ + 0x04, 0x80, /* # # */ + 0x04, 0x80, /* # # */ + 0x03, 0x00, /* ## */ + 0x03, 0x00, /* ## */ + 0x03, 0x00, /* ## */ + + /* @306 '?' (5 pixels wide) */ + 0x00, 0x20, /* # */ + 0x00, 0x10, /* # */ + 0x1B, 0x10, /* ## ## # */ + 0x00, 0x90, /* # # */ + 0x00, 0x60, /* ## */ + + /* @316 '@' (11 pixels wide) */ + 0x0F, 0x80, /* ##### */ + 0x10, 0x40, /* # # */ + 0x20, 0x20, /* # # */ + 0x47, 0x10, /* # ### # */ + 0x48, 0x90, /* # # # # */ + 0x48, 0x90, /* # # # # */ + 0x48, 0x90, /* # # # # */ + 0x4F, 0x90, /* # ##### # */ + 0x28, 0x20, /* # # # */ + 0x04, 0x60, /* # ## */ + 0x03, 0x80, /* ### */ + + /* @338 'A' (8 pixels wide) */ + 0x10, 0x00, /* # */ + 0x0E, 0x00, /* ### */ + 0x05, 0xC0, /* # ### */ + 0x04, 0x30, /* # ## */ + 0x04, 0x30, /* # ## */ + 0x05, 0xC0, /* # ### */ + 0x0E, 0x00, /* ### */ + 0x10, 0x00, /* # */ + + /* @354 'B' (6 pixels wide) */ + 0x1F, 0xF0, /* ######### */ + 0x11, 0x10, /* # # # */ + 0x11, 0x10, /* # # # */ + 0x11, 0x10, /* # # # */ + 0x11, 0x10, /* # # # */ + 0x0E, 0xE0, /* ### ### */ + + /* @366 'C' (6 pixels wide) */ + 0x07, 0xC0, /* ##### */ + 0x08, 0x20, /* # # */ + 0x10, 0x10, /* # # */ + 0x10, 0x10, /* # # */ + 0x10, 0x10, /* # # */ + 0x08, 0x20, /* # # */ + + /* @378 'D' (7 pixels wide) */ + 0x1F, 0xF0, /* ######### */ + 0x10, 0x10, /* # # */ + 0x10, 0x10, /* # # */ + 0x10, 0x10, /* # # */ + 0x10, 0x10, /* # # */ + 0x08, 0x20, /* # # */ + 0x07, 0xC0, /* ##### */ + + /* @392 'E' (6 pixels wide) */ + 0x1F, 0xF0, /* ######### */ + 0x11, 0x10, /* # # # */ + 0x11, 0x10, /* # # # */ + 0x11, 0x10, /* # # # */ + 0x11, 0x10, /* # # # */ + 0x11, 0x10, /* # # # */ + + /* @404 'F' (5 pixels wide) */ + 0x1F, 0xF0, /* ######### */ + 0x01, 0x10, /* # # */ + 0x01, 0x10, /* # # */ + 0x01, 0x10, /* # # */ + 0x01, 0x10, /* # # */ + + /* @414 'G' (7 pixels wide) */ + 0x07, 0xC0, /* ##### */ + 0x08, 0x20, /* # # */ + 0x10, 0x10, /* # # */ + 0x10, 0x10, /* # # */ + 0x11, 0x10, /* # # # */ + 0x11, 0x10, /* # # # */ + 0x0F, 0x20, /* #### # */ + + /* @428 'H' (7 pixels wide) */ + 0x1F, 0xF0, /* ######### */ + 0x01, 0x00, /* # */ + 0x01, 0x00, /* # */ + 0x01, 0x00, /* # */ + 0x01, 0x00, /* # */ + 0x01, 0x00, /* # */ + 0x1F, 0xF0, /* ######### */ + + /* @442 'I' (1 pixels wide) */ + 0x1F, 0xF0, /* ######### */ + + /* @444 'J' (3 pixels wide) */ + 0x40, 0x00, /* # */ + 0x40, 0x00, /* # */ + 0x3F, 0xF0, /* ########## */ + + /* @450 'K' (6 pixels wide) */ + 0x1F, 0xF0, /* ######### */ + 0x01, 0x00, /* # */ + 0x02, 0x80, /* # # */ + 0x04, 0x40, /* # # */ + 0x08, 0x20, /* # # */ + 0x10, 0x10, /* # # */ + + /* @462 'L' (5 pixels wide) */ + 0x1F, 0xF0, /* ######### */ + 0x10, 0x00, /* # */ + 0x10, 0x00, /* # */ + 0x10, 0x00, /* # */ + 0x10, 0x00, /* # */ + + /* @472 'M' (8 pixels wide) */ + 0x1F, 0xF0, /* ######### */ + 0x00, 0x60, /* ## */ + 0x01, 0x80, /* ## */ + 0x06, 0x00, /* ## */ + 0x06, 0x00, /* ## */ + 0x01, 0x80, /* ## */ + 0x00, 0x60, /* ## */ + 0x1F, 0xF0, /* ######### */ + + /* @488 'N' (7 pixels wide) */ + 0x1F, 0xF0, /* ######### */ + 0x00, 0x30, /* ## */ + 0x00, 0xC0, /* ## */ + 0x01, 0x00, /* # */ + 0x06, 0x00, /* ## */ + 0x18, 0x00, /* ## */ + 0x1F, 0xF0, /* ######### */ + + /* @502 'O' (7 pixels wide) */ + 0x07, 0xC0, /* ##### */ + 0x08, 0x20, /* # # */ + 0x10, 0x10, /* # # */ + 0x10, 0x10, /* # # */ + 0x10, 0x10, /* # # */ + 0x08, 0x20, /* # # */ + 0x07, 0xC0, /* ##### */ + + /* @516 'P' (6 pixels wide) */ + 0x1F, 0xF0, /* ######### */ + 0x01, 0x10, /* # # */ + 0x01, 0x10, /* # # */ + 0x01, 0x10, /* # # */ + 0x01, 0x10, /* # # */ + 0x00, 0xE0, /* ### */ + + /* @528 'Q' (7 pixels wide) */ + 0x07, 0xC0, /* ##### */ + 0x08, 0x20, /* # # */ + 0x10, 0x10, /* # # */ + 0x10, 0x10, /* # # */ + 0x30, 0x10, /* ## # */ + 0x48, 0x20, /* # # # */ + 0x07, 0xC0, /* ##### */ + + /* @542 'R' (7 pixels wide) */ + 0x1F, 0xF0, /* ######### */ + 0x01, 0x10, /* # # */ + 0x01, 0x10, /* # # */ + 0x01, 0x10, /* # # */ + 0x03, 0x10, /* ## # */ + 0x0C, 0xE0, /* ## ### */ + 0x10, 0x00, /* # */ + + /* @556 'S' (6 pixels wide) */ + 0x08, 0xE0, /* # ### */ + 0x11, 0x90, /* # ## # */ + 0x11, 0x10, /* # # # */ + 0x11, 0x10, /* # # # */ + 0x11, 0x10, /* # # # */ + 0x0E, 0x20, /* ### # */ + + /* @568 'T' (7 pixels wide) */ + 0x00, 0x10, /* # */ + 0x00, 0x10, /* # */ + 0x00, 0x10, /* # */ + 0x1F, 0xF0, /* ######### */ + 0x00, 0x10, /* # */ + 0x00, 0x10, /* # */ + 0x00, 0x10, /* # */ + + /* @582 'U' (7 pixels wide) */ + 0x0F, 0xF0, /* ######## */ + 0x18, 0x00, /* ## */ + 0x10, 0x00, /* # */ + 0x10, 0x00, /* # */ + 0x10, 0x00, /* # */ + 0x18, 0x00, /* ## */ + 0x0F, 0xF0, /* ######## */ + + /* @596 'V' (8 pixels wide) */ + 0x00, 0x30, /* ## */ + 0x01, 0xC0, /* ### */ + 0x06, 0x00, /* ## */ + 0x18, 0x00, /* ## */ + 0x18, 0x00, /* ## */ + 0x06, 0x00, /* ## */ + 0x01, 0xC0, /* ### */ + 0x00, 0x30, /* ## */ + + /* @612 'W' (11 pixels wide) */ + 0x00, 0x10, /* # */ + 0x00, 0xE0, /* ### */ + 0x07, 0x00, /* ### */ + 0x18, 0x00, /* ## */ + 0x07, 0x80, /* #### */ + 0x00, 0x70, /* ### */ + 0x07, 0x80, /* #### */ + 0x18, 0x00, /* ## */ + 0x07, 0x00, /* ### */ + 0x00, 0xE0, /* ### */ + 0x00, 0x10, /* # */ + + /* @634 'X' (7 pixels wide) */ + 0x10, 0x10, /* # # */ + 0x08, 0x30, /* # ## */ + 0x06, 0xC0, /* ## ## */ + 0x01, 0x00, /* # */ + 0x06, 0xC0, /* ## ## */ + 0x08, 0x30, /* # ## */ + 0x10, 0x10, /* # # */ + + /* @648 'Y' (7 pixels wide) */ + 0x00, 0x10, /* # */ + 0x00, 0x60, /* ## */ + 0x01, 0x80, /* ## */ + 0x1E, 0x00, /* #### */ + 0x01, 0x80, /* ## */ + 0x00, 0x60, /* ## */ + 0x00, 0x10, /* # */ + + /* @662 'Z' (7 pixels wide) */ + 0x18, 0x10, /* ## # */ + 0x14, 0x10, /* # # # */ + 0x12, 0x10, /* # # # */ + 0x11, 0x10, /* # # # */ + 0x10, 0x90, /* # # # */ + 0x10, 0x50, /* # # # */ + 0x10, 0x30, /* # ## */ + + /* @676 '[' (2 pixels wide) */ + 0x7F, 0xF0, /* ########### */ + 0x40, 0x10, /* # # */ + + /* @680 '\' (4 pixels wide) */ + 0x00, 0x30, /* ## */ + 0x01, 0xC0, /* ### */ + 0x0E, 0x00, /* ### */ + 0x30, 0x00, /* ## */ + + /* @688 ']' (2 pixels wide) */ + 0x40, 0x10, /* # # */ + 0x7F, 0xF0, /* ########### */ + + /* @692 '^' (6 pixels wide) */ + 0x00, 0x40, /* # */ + 0x00, 0x20, /* # */ + 0x00, 0x10, /* # */ + 0x00, 0x10, /* # */ + 0x00, 0x20, /* # */ + 0x00, 0x40, /* # */ + + /* @704 '_' (6 pixels wide) */ + 0x80, 0x00, /* # */ + 0x80, 0x00, /* # */ + 0x80, 0x00, /* # */ + 0x80, 0x00, /* # */ + 0x80, 0x00, /* # */ + 0x80, 0x00, /* # */ + + /* @716 '`' (2 pixels wide) */ + 0x00, 0x08, /* # */ + 0x00, 0x10, /* # */ + + /* @720 'a' (6 pixels wide) */ + 0x0C, 0x80, /* ## # */ + 0x12, 0x40, /* # # # */ + 0x12, 0x40, /* # # # */ + 0x12, 0x40, /* # # # */ + 0x0A, 0x40, /* # # # */ + 0x1F, 0x80, /* ###### */ + + /* @732 'b' (6 pixels wide) */ + 0x1F, 0xF8, /* ########## */ + 0x18, 0xC0, /* ## ## */ + 0x10, 0x40, /* # # */ + 0x10, 0x40, /* # # */ + 0x18, 0xC0, /* ## ## */ + 0x0F, 0x80, /* ##### */ + + /* @744 'c' (5 pixels wide) */ + 0x0F, 0x80, /* ##### */ + 0x18, 0xC0, /* ## ## */ + 0x10, 0x40, /* # # */ + 0x10, 0x40, /* # # */ + 0x08, 0x80, /* # # */ + + /* @754 'd' (6 pixels wide) */ + 0x0F, 0x80, /* ##### */ + 0x18, 0xC0, /* ## ## */ + 0x10, 0x40, /* # # */ + 0x10, 0x40, /* # # */ + 0x18, 0xC0, /* ## ## */ + 0x1F, 0xF8, /* ########## */ + + /* @766 'e' (6 pixels wide) */ + 0x0F, 0x80, /* ##### */ + 0x0A, 0xC0, /* # # ## */ + 0x12, 0x40, /* # # # */ + 0x12, 0x40, /* # # # */ + 0x12, 0xC0, /* # # ## */ + 0x0B, 0x80, /* # ### */ + + /* @778 'f' (4 pixels wide) */ + 0x00, 0x40, /* # */ + 0x1F, 0xF0, /* ######### */ + 0x00, 0x48, /* # # */ + 0x00, 0x48, /* # # */ + + /* @786 'g' (6 pixels wide) */ + 0x0F, 0x80, /* ##### */ + 0x58, 0xC0, /* # ## ## */ + 0x90, 0x40, /* # # # */ + 0x90, 0x40, /* # # # */ + 0xD8, 0xC0, /* ## ## ## */ + 0x7F, 0xC0, /* ######### */ + + /* @798 'h' (6 pixels wide) */ + 0x1F, 0xF8, /* ########## */ + 0x00, 0x80, /* # */ + 0x00, 0x40, /* # */ + 0x00, 0x40, /* # */ + 0x00, 0x40, /* # */ + 0x1F, 0x80, /* ###### */ + + /* @810 'i' (1 pixels wide) */ + 0x1F, 0xD0, /* ####### # */ + + /* @812 'j' (2 pixels wide) */ + 0x80, 0x00, /* # */ + 0xFF, 0xD0, /* ########## # */ + + /* @816 'k' (5 pixels wide) */ + 0x1F, 0xF8, /* ########## */ + 0x02, 0x00, /* # */ + 0x05, 0x00, /* # # */ + 0x08, 0x80, /* # # */ + 0x10, 0x40, /* # # */ + + /* @826 'l' (1 pixels wide) */ + 0x1F, 0xF8, /* ########## */ + + /* @828 'm' (9 pixels wide) */ + 0x1F, 0xC0, /* ####### */ + 0x00, 0x40, /* # */ + 0x00, 0x40, /* # */ + 0x00, 0x40, /* # */ + 0x1F, 0x80, /* ###### */ + 0x00, 0x40, /* # */ + 0x00, 0x40, /* # */ + 0x00, 0x40, /* # */ + 0x1F, 0x80, /* ###### */ + + /* @846 'n' (6 pixels wide) */ + 0x1F, 0xC0, /* ####### */ + 0x00, 0x80, /* # */ + 0x00, 0x40, /* # */ + 0x00, 0x40, /* # */ + 0x00, 0x40, /* # */ + 0x1F, 0x80, /* ###### */ + + /* @858 'o' (6 pixels wide) */ + 0x0F, 0x80, /* ##### */ + 0x18, 0xC0, /* ## ## */ + 0x10, 0x40, /* # # */ + 0x10, 0x40, /* # # */ + 0x18, 0xC0, /* ## ## */ + 0x0F, 0x80, /* ##### */ + + /* @870 'p' (6 pixels wide) */ + 0xFF, 0xC0, /* ########## */ + 0x18, 0xC0, /* ## ## */ + 0x10, 0x40, /* # # */ + 0x10, 0x40, /* # # */ + 0x18, 0xC0, /* ## ## */ + 0x0F, 0x80, /* ##### */ + + /* @882 'q' (6 pixels wide) */ + 0x0F, 0x80, /* ##### */ + 0x18, 0xC0, /* ## ## */ + 0x10, 0x40, /* # # */ + 0x10, 0x40, /* # # */ + 0x18, 0xC0, /* ## ## */ + 0xFF, 0xC0, /* ########## */ + + /* @894 'r' (4 pixels wide) */ + 0x1F, 0xC0, /* ####### */ + 0x00, 0x80, /* # */ + 0x00, 0x40, /* # */ + 0x00, 0x40, /* # */ + + /* @902 's' (5 pixels wide) */ + 0x09, 0x80, /* # ## */ + 0x12, 0x40, /* # # # */ + 0x12, 0x40, /* # # # */ + 0x12, 0x40, /* # # # */ + 0x0C, 0x80, /* ## # */ + + /* @912 't' (4 pixels wide) */ + 0x00, 0x40, /* # */ + 0x1F, 0xF0, /* ######### */ + 0x10, 0x40, /* # # */ + 0x10, 0x40, /* # # */ + + /* @920 'u' (6 pixels wide) */ + 0x0F, 0xC0, /* ###### */ + 0x10, 0x00, /* # */ + 0x10, 0x00, /* # */ + 0x10, 0x00, /* # */ + 0x08, 0x00, /* # */ + 0x1F, 0xC0, /* ####### */ + + /* @932 'v' (6 pixels wide) */ + 0x00, 0xC0, /* ## */ + 0x07, 0x00, /* ### */ + 0x18, 0x00, /* ## */ + 0x18, 0x00, /* ## */ + 0x07, 0x00, /* ### */ + 0x00, 0xC0, /* ## */ + + /* @944 'w' (9 pixels wide) */ + 0x00, 0xC0, /* ## */ + 0x07, 0x00, /* ### */ + 0x18, 0x00, /* ## */ + 0x07, 0x00, /* ### */ + 0x00, 0xC0, /* ## */ + 0x07, 0x00, /* ### */ + 0x18, 0x00, /* ## */ + 0x07, 0x00, /* ### */ + 0x00, 0xC0, /* ## */ + + /* @962 'x' (6 pixels wide) */ + 0x10, 0x40, /* # # */ + 0x0D, 0x80, /* ## ## */ + 0x02, 0x00, /* # */ + 0x02, 0x00, /* # */ + 0x0D, 0x80, /* ## ## */ + 0x10, 0x40, /* # # */ + + /* @974 'y' (6 pixels wide) */ + 0x80, 0xC0, /* # ## */ + 0x83, 0x00, /* # ## */ + 0x4C, 0x00, /* # ## */ + 0x38, 0x00, /* ### */ + 0x07, 0x00, /* ### */ + 0x00, 0xC0, /* ## */ + + /* @986 'z' (5 pixels wide) */ + 0x18, 0x40, /* ## # */ + 0x14, 0x40, /* # # # */ + 0x12, 0x40, /* # # # */ + 0x11, 0x40, /* # # # */ + 0x10, 0xC0, /* # ## */ + + /* @996 '{' (5 pixels wide) */ + 0x02, 0x00, /* # */ + 0x02, 0x00, /* # */ + 0x7D, 0xF0, /* ##### ##### */ + 0x40, 0x10, /* # # */ + 0x40, 0x10, /* # # */ + + /* @1006 '|' (1 pixels wide) */ + 0xFF, 0xF0, /* ############ */ + + /* @1008 '}' (5 pixels wide) */ + 0x40, 0x10, /* # # */ + 0x40, 0x10, /* # # */ + 0x7D, 0xF0, /* ##### ##### */ + 0x02, 0x00, /* # */ + 0x02, 0x00, /* # */ + + /* @1018 '~' (8 pixels wide) */ + 0x02, 0x00, /* # */ + 0x01, 0x00, /* # */ + 0x01, 0x00, /* # */ + 0x01, 0x00, /* # */ + 0x02, 0x00, /* # */ + 0x02, 0x00, /* # */ + 0x02, 0x00, /* # */ + 0x01, 0x00, /* # */ +}; + +/* Character descriptors for DejaVu Sans 9pt */ +/* { [Char width in bits], [Offset into dejaVuSans9ptCharBitmaps in bytes] } */ +const FONT_CHAR_INFO dejaVuSans9ptCharDescriptors[] = +{ + {5, 0}, /* */ + {1, 10}, /* ! */ + {3, 12}, /* " */ + {8, 18}, /* # */ + {5, 34}, /* $ */ + {10, 44}, /* % */ + {8, 64}, /* & */ + {1, 80}, /* ' */ + {3, 82}, /* ( */ + {3, 88}, /* ) */ + {5, 94}, /* * */ + {7, 104}, /* + */ + {1, 118}, /* , */ + {3, 120}, /* - */ + {1, 126}, /* . */ + {4, 128}, /* / */ + {6, 136}, /* 0 */ + {5, 148}, /* 1 */ + {6, 158}, /* 2 */ + {6, 170}, /* 3 */ + {6, 182}, /* 4 */ + {6, 194}, /* 5 */ + {6, 206}, /* 6 */ + {6, 218}, /* 7 */ + {6, 230}, /* 8 */ + {6, 242}, /* 9 */ + {1, 254}, /* : */ + {1, 256}, /* ; */ + {8, 258}, /* < */ + {8, 274}, /* = */ + {8, 290}, /* > */ + {5, 306}, /* ? */ + {11, 316}, /* @ */ + {8, 338}, /* A */ + {6, 354}, /* B */ + {6, 366}, /* C */ + {7, 378}, /* D */ + {6, 392}, /* E */ + {5, 404}, /* F */ + {7, 414}, /* G */ + {7, 428}, /* H */ + {1, 442}, /* I */ + {3, 444}, /* J */ + {6, 450}, /* K */ + {5, 462}, /* L */ + {8, 472}, /* M */ + {7, 488}, /* N */ + {7, 502}, /* O */ + {6, 516}, /* P */ + {7, 528}, /* Q */ + {7, 542}, /* R */ + {6, 556}, /* S */ + {7, 568}, /* T */ + {7, 582}, /* U */ + {8, 596}, /* V */ + {11, 612}, /* W */ + {7, 634}, /* X */ + {7, 648}, /* Y */ + {7, 662}, /* Z */ + {2, 676}, /* [ */ + {4, 680}, /* \ */ + {2, 688}, /* ] */ + {6, 692}, /* ^ */ + {6, 704}, /* _ */ + {2, 716}, /* ` */ + {6, 720}, /* a */ + {6, 732}, /* b */ + {5, 744}, /* c */ + {6, 754}, /* d */ + {6, 766}, /* e */ + {4, 778}, /* f */ + {6, 786}, /* g */ + {6, 798}, /* h */ + {1, 810}, /* i */ + {2, 812}, /* j */ + {5, 816}, /* k */ + {1, 826}, /* l */ + {9, 828}, /* m */ + {6, 846}, /* n */ + {6, 858}, /* o */ + {6, 870}, /* p */ + {6, 882}, /* q */ + {4, 894}, /* r */ + {5, 902}, /* s */ + {4, 912}, /* t */ + {6, 920}, /* u */ + {6, 932}, /* v */ + {9, 944}, /* w */ + {6, 962}, /* x */ + {6, 974}, /* y */ + {5, 986}, /* z */ + {5, 996}, /* { */ + {1, 1006}, /* | */ + {5, 1008}, /* } */ + {8, 1018}, /* ~ */ +}; + +} // End of namespace Gnap + +#endif // GNAP_RESOURCE_H diff --git a/engines/gnap/gamesys.cpp b/engines/gnap/gamesys.cpp new file mode 100644 index 0000000000..d6f8db8c7a --- /dev/null +++ b/engines/gnap/gamesys.cpp @@ -0,0 +1,1303 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "gnap/gamesys.h" +#include "gnap/fontdata.h" +#include "graphics/fontman.h" +#include "graphics/font.h" +#include "graphics/decoders/bmp.h" + +namespace Gnap { + +void GfxItem::testUpdRect(const Common::Rect &updRect) { + Common::Rect intersectingRect; + if (!updFlag && prevFrame.spriteId != -1 && + updRectsCount < 20 && intersectRect(intersectingRect, prevFrame.rect, updRect)) + updRects[updRectsCount++] = intersectingRect; +} + +// GameSys + +GameSys::GameSys(GnapEngine *vm) + : _vm(vm) { + + _newSpriteDrawItemsCount = 0; + _removeSequenceItemsCount = 0; + _removeSpriteDrawItemsCount = 0; + _grabSpriteId = -1; + _grabSpriteChanged = false; + _reqRemoveSequenceItem = false; + _removeSequenceItemSequenceId = -1; + _removeSequenceItemValue = 0; + _gfxItemsCount = 0; + _animationsCount = 0; + _backgroundImageValue3 = 0; + _backgroundImageValue1 = 0; + _backgroundImageValue4 = 0; + _backgroundImageValue2 = 0; + _backgroundImageError = true; + _gameSysClock = 0; + _lastUpdateClock = 0; + _backgroundSurface = 0; + _frontSurface = 0; + for (int i = 0; i < kMaxAnimations; ++i) { + _animations[i].sequenceId = -1; + _animations[i].id = 0; + _animations[i].status = 0; + } + _screenRect = Common::Rect(0, 0, 800, 600); +} + +GameSys::~GameSys() { +} + +void GameSys::insertSequence(int sequenceId, int a2, int sequenceId2, int a4, int flags, int totalDuration, int16 x, int16 y) { + debug(0, "GameSys::insertSequence() [%08X, %d] -> [%08X, %d] (%d, %d)", sequenceId, a2, sequenceId2, a4, x, y); + Sequence sequence; + SequenceResource *sequenceResource = _vm->_sequenceCache->get(sequenceId); + sequenceResource->_sequenceId = sequenceId; + sequence.sequenceId = sequenceId; + sequence.id = a2 != -1 ? a2 : sequenceResource->_field_8; + sequence.sequenceId2 = sequenceId2 != (int32)0x80000000 ? sequenceId2 : sequenceResource->_sequenceId2; + sequence.id2 = a4 != -1 ? a4 : sequenceResource->_field_10; + sequence.flags = flags != -1 ? flags : sequenceResource->_flags; + sequence.totalDuration = totalDuration != -1 ? totalDuration : sequenceResource->_totalDuration; + sequence.x = (x < 10000 && x > -10000) ? x : sequenceResource->_xOffs; + sequence.y = (y < 10000 && y > -10000) ? y : sequenceResource->_yOffs; + _fatSequenceItems.push_back(sequence); +} + +void GameSys::insertDirtyRect(const Common::Rect &rect) { + _dirtyRects.push_back(rect); +} + +void GameSys::removeSequence(int sequenceId, int a2, int a3) { + //WaitForSingleObject(removeSequence2Mutex, INFINITE); + if (_removeSequenceItemsCount < kMaxSequenceItems) { + _removeSequenceItems[_removeSequenceItemsCount].sequenceId = sequenceId; + _removeSequenceItems[_removeSequenceItemsCount].id = a2; + _removeSequenceItems[_removeSequenceItemsCount].a3 = a3; + ++_removeSequenceItemsCount; + //ResetEvent(removeSequenceItemsEvent); + //ReleaseMutex(removeSequence2Mutex); + //WaitForSingleObject(removeSequenceItemsEvent, INFINITE); + } +} + +void GameSys::invalidateGrabCursorSprite(int id, Common::Rect &rect, Graphics::Surface *surface1, Graphics::Surface *surface2) { + //WaitForSingleObject(grabSpriteMutex, INFINITE); + _grabSpriteId = id; + _grabSpriteRect = rect; + _grabSpriteSurface2 = surface2; + _grabSpriteSurface1 = surface1; + //ResetEvent(grabSpriteEvent); + _grabSpriteChanged = true; + //ReleaseMutex(grabSpriteMutex); + //WaitForSingleObject(grabSpriteEvent, INFINITE); +} + +void GameSys::requestClear2(int a1) { + _fatSequenceItems.clear(); + _seqItems.clear(); + for (int i = 0; i < _gfxItemsCount; ++i) { + GfxItem *gfxItem = &_gfxItems[i]; + gfxItem->sequenceId = -1; + gfxItem->animation = 0; + gfxItem->soundValue = 0; + if (a1) { + gfxItem->currFrame.duration = 0; + gfxItem->currFrame.spriteId = -1; + gfxItem->currFrame.soundId = -1; + gfxItem->currFrame.unkValue = -1; + gfxItem->updFlag = true; + } else { + gfxItem->updFlag = false; + } + } + _lastUpdateClock = 0; + _gameSysClock = 0; +} + +void GameSys::requestClear1() { + _gfxItemsCount = 0; + _fatSequenceItems.clear(); + _seqItems.clear(); + _lastUpdateClock = 0; + _gameSysClock = 0; +} + +void GameSys::requestRemoveSequence(int sequenceId, int a2) { + //WaitForSingleObject(removeSequence2Mutex, INFINITE); + _reqRemoveSequenceItem = true; + _removeSequenceItemSequenceId = sequenceId; + _removeSequenceItemValue = a2; + + handleReqRemoveSequenceItem();//CHECKME? + + //ResetEvent(reqClearEvent); + //ReleaseMutex(removeSequence2Mutex); + //WaitForSingleObject(reqClearEvent, INFINITE); +} + +void GameSys::waitForUpdate() { + //ResetEvent(updateEvent); + //WaitForSingleObject(updateEvent, INFINITE); +} + +int GameSys::isSequenceActive(int sequenceId, int a2) { + for (uint i = 0; i < _seqItems.size(); ++i) + if (_seqItems[i].sequenceId == sequenceId && _seqItems[i].id == a2) + return true; + return false; +} + +void GameSys::setBackgroundSurface(Graphics::Surface *surface, int a4, int a5, int a6, int a7) { + + debug(1, "GameSys::setBackgroundSurface() Setting background image"); + + _backgroundSurface = surface; + if (!_backgroundSurface) { + _backgroundImageError = true; + return; + } + + if (!_frontSurface || _frontSurface->w != surface->w || _frontSurface->h != surface->h) { + debug(1, "GameSys::setBackgroundSurface() Creating background working surface"); + if (_frontSurface) + _frontSurface->free(); + delete _frontSurface; + _frontSurface = new Graphics::Surface(); + _frontSurface->create(surface->w, surface->h, surface->format); + } + + memcpy(_frontSurface->getPixels(), surface->getPixels(), surface->pitch * surface->h); + + _vm->_system->copyRectToScreen(_frontSurface->getPixels(), _frontSurface->pitch, 0, 0, _frontSurface->w, _frontSurface->h); + + _backgroundImageError = false; + _backgroundImageValue1 = a4; + _backgroundImageValue3 = a6; + _backgroundImageValue2 = a5; + _backgroundImageValue4 = a7; + _lastUpdateClock = 0; + _gameSysClock = 0; + +} + +void GameSys::setScaleValues(int a1, int a2, int a3, int a4) { + _backgroundImageValue1 = a1; + _backgroundImageValue3 = a3; + _backgroundImageValue2 = a2; + _backgroundImageValue4 = a4; +} + +void GameSys::insertSpriteDrawItem(Graphics::Surface *surface, int x, int y, int id) { + if (surface && _newSpriteDrawItemsCount < kMaxSpriteDrawItems) { + _newSpriteDrawItems[_newSpriteDrawItemsCount].id = id; + _newSpriteDrawItems[_newSpriteDrawItemsCount].rect = Common::Rect(x, y, x + surface->w, y + surface->h); + _newSpriteDrawItems[_newSpriteDrawItemsCount].surface = surface; + ++_newSpriteDrawItemsCount; + } +} + +void GameSys::removeSpriteDrawItem(Graphics::Surface *surface, int a2) { + if (surface && _removeSpriteDrawItemsCount < kMaxSpriteDrawItems) { + _removeSpriteDrawItems[_removeSpriteDrawItemsCount].id = a2; + _removeSpriteDrawItems[_removeSpriteDrawItemsCount].surface = surface; + ++_removeSpriteDrawItemsCount; + } +} + +void GameSys::drawSpriteToBackground(int x, int y, int resourceId) { + + SpriteResource *spriteResource = _vm->_spriteCache->get(resourceId); + uint32 *sourcePalette = spriteResource->_palette; + byte *sourcePixels = spriteResource->_pixels; + int spriteWidth = spriteResource->_width; + int spriteHeight = spriteResource->_height; + Common::Rect dstRect(0, 0, spriteWidth, spriteHeight); + blitSprite32(_backgroundSurface, x, y, sourcePixels, spriteResource->_width, dstRect, sourcePalette, true);//spriteResource->_transparent != 0); + _vm->_spriteCache->release(resourceId); + + // Add dirty rect so the modified background is redrawn + insertDirtyRect(Common::Rect(x, y, x + spriteWidth, y + spriteHeight)); +} + +Graphics::Surface *GameSys::allocSurface(int width, int height) { + Graphics::Surface *surface = new Graphics::Surface(); + surface->create(width, height, _backgroundSurface->format); + surface->fillRect(Common::Rect(0, 0, surface->w, surface->h), 0xFFFF00FF); + return surface; +} + +Graphics::Surface *GameSys::createSurface(int resourceId) { + debug(0, "GameSys::createSurface() resourceId: %08X", resourceId); + + SpriteResource *spriteResource = _vm->_spriteCache->get(resourceId); + Graphics::Surface *surface = allocSurface(spriteResource->_width, spriteResource->_height); + _vm->_spriteCache->release(resourceId); + + drawSpriteToSurface(surface, 0, 0, resourceId); + + return surface; +} + +void GameSys::drawSpriteToSurface(Graphics::Surface *surface, int x, int y, int resourceId) { + SpriteResource *spriteResource = _vm->_spriteCache->get(resourceId); + uint32 *sourcePalette = spriteResource->_palette; + byte *sourcePixels = spriteResource->_pixels; + Common::Rect dstRect(0, 0, spriteResource->_width, spriteResource->_height); + blitSprite32(surface, x, y, sourcePixels, spriteResource->_width, dstRect, sourcePalette, true);//spriteResource->_transparent != 0); + _vm->_spriteCache->release(resourceId); +} + +void GameSys::drawTextToSurface(Graphics::Surface *surface, int x, int y, byte r, byte g, byte b, const char *text) { + + // NOTE Not that nice but will have to do for now + + bool doDirty = false; + + if (!surface) { + surface = _backgroundSurface; + doDirty = true; + } + + uint32 color = surface->format.RGBToColor(r, g, b); + + for (const char *cp = text; *cp != 0; ++cp) { + byte c = *cp; + if (c < 32 || c > 127) + c = (byte)'_'; + c -= 32; + int w = dejaVuSans9ptCharDescriptors[c].width; + const byte *data = dejaVuSans9ptCharBitmaps + dejaVuSans9ptCharDescriptors[c].offset; + for (int xc = 0; xc < w; ++xc) { + for (int yc = 15; yc >= 0; --yc) { + byte *dst = (byte*)surface->getBasePtr(x + xc, y + yc); + if (data[1 - (yc >> 3)] & (1 << (yc & 7))) + WRITE_LE_UINT32(dst, color); + } + data += 2; + } + x += w + 1; + } + + if (doDirty) { + insertDirtyRect(Common::Rect(x, y, x + getTextWidth(text), y + 16)); + } + +} + +int GameSys::getTextWidth(const char *text) { + int width = 0; + for (const char *cp = text; *cp != 0; ++cp) { + byte c = *cp; + if (c < 32 || c > 127) + c = (byte)'_'; + c -= 32; + width += dejaVuSans9ptCharDescriptors[c].width + 1; + } + return width; +} + +void GameSys::fillSurface(Graphics::Surface *surface, int x, int y, int width, int height, byte r, byte g, byte b) { + Common::Rect rect(x, y, x + width, y + height); + if (!surface) { + _backgroundSurface->fillRect(rect, _backgroundSurface->format.RGBToColor(r, g, b)); + insertDirtyRect(rect); + } else { + surface->fillRect(rect, surface->format.RGBToColor(r, g, b)); + } +} + +void GameSys::setAnimation(int sequenceId, int id, int animationIndex) { + if (animationIndex < kMaxAnimations) { + _animations[animationIndex].sequenceId = sequenceId; + _animations[animationIndex].id = id; + _animations[animationIndex].status = 0; + } +} + +int GameSys::getAnimationStatus(int animationIndex) { + int result = -1; + if (animationIndex < kMaxAnimations) + result = _animations[animationIndex].status; + return result; +} + +int GameSys::getSpriteWidthById(int resourceId) { + SpriteResource *spriteResource = _vm->_spriteCache->get(resourceId); + const int width = spriteResource->_width; + _vm->_spriteCache->release(resourceId); + return width; +} + +int GameSys::getSpriteHeightById(int resourceId) { + SpriteResource *spriteResource = _vm->_spriteCache->get(resourceId); + const int height = spriteResource->_height; + _vm->_spriteCache->release(resourceId); + return height; +} + +Graphics::Surface *GameSys::loadBitmap(int resourceId) { + debug("GameSys::loadBitmap() resourceId: %08X", resourceId); + if (_vm->_dat->getResourceType(resourceId) != 1) + return 0; + byte *resourceData = _vm->_dat->loadResource(resourceId); + uint32 resourceSize = _vm->_dat->getResourceSize(resourceId); + Common::MemoryReadStream stream(resourceData, resourceSize, DisposeAfterUse::NO); + Graphics::Surface *bmpSurface; + Graphics::BitmapDecoder bmp; + if (!bmp.loadStream(stream)) + error("GameSys::loadBitmap() Could not load bitmap resource %08X", resourceId); + bmpSurface = bmp.getSurface()->convertTo(_vm->_system->getScreenFormat()); + delete[] resourceData; + return bmpSurface; +} + +void GameSys::drawBitmap(int resourceId) { + Graphics::Surface *bmpSurface = loadBitmap(resourceId); + if (!bmpSurface || !_backgroundSurface) { + debug("GameSys::drawBitmap() Error loading the bitmap"); + return; + } + if (bmpSurface->format != _backgroundSurface->format || + bmpSurface->w != _backgroundSurface->w || bmpSurface->h != _backgroundSurface->h) { + debug("GameSys::drawBitmap() Different bitmap properties than current background"); + } else { + byte *src = (byte*)bmpSurface->getPixels(); + byte *dst = (byte*)_backgroundSurface->getPixels(); + const int pitch = bmpSurface->pitch; + int height = bmpSurface->h; + while (height--) { + memcpy(dst, src, pitch); + src += pitch; + dst += pitch; + } + } + bmpSurface->free(); + delete bmpSurface; + + insertDirtyRect(Common::Rect(0, 0, 800, 600)); +} + +Sequence *GameSys::seqFind(int sequenceId, int a2, int *outIndex) { + for (uint i = 0; i < _seqItems.size(); ++i) + if (_seqItems[i].sequenceId == sequenceId && _seqItems[i].id == a2) { + if (outIndex) + *outIndex = i; + return &_seqItems[i]; + } + return 0; +} + +int GameSys::seqLocateGfx(int sequenceId, int id, int *outGfxIndex) { + for (int i = 0; i < _gfxItemsCount; ++i) { + GfxItem *gfxItem = &_gfxItems[i]; + if (gfxItem->sequenceId == sequenceId && gfxItem->id == id) { + if (outGfxIndex) + *outGfxIndex = i; + return gfxItem->sequenceId; + } + if (gfxItem->id > id) { + if (outGfxIndex) + *outGfxIndex = i; + return 0; + } + } + if (outGfxIndex) + *outGfxIndex = _gfxItemsCount; + return 0; +} + +void GameSys::seqInsertGfx(int index, int duration) { + + Sequence *seqItem = &_seqItems[index]; + SequenceResource *sequenceResource = _vm->_sequenceCache->get(seqItem->sequenceId); + + if (sequenceResource->_animationsCount > 50 - _gfxItemsCount) + return; + + int gfxIndex; + seqLocateGfx(seqItem->sequenceId, seqItem->id, &gfxIndex); + + if (gfxIndex != _gfxItemsCount) + memcpy(&_gfxItems[gfxIndex + sequenceResource->_animationsCount], &_gfxItems[gfxIndex], sizeof(GfxItem) * (_gfxItemsCount - gfxIndex)); + _gfxItemsCount += sequenceResource->_animationsCount; + + for (int i = 0; i < sequenceResource->_animationsCount; ++i) { + int totalDuration; + GfxItem *gfxItem = &_gfxItems[i + gfxIndex]; + SequenceAnimation *animation = &sequenceResource->_animations[i]; + + debug(0, "GameSys::seqInsertGfx() seqItem->sequenceId: %08X", seqItem->sequenceId); + + gfxItem->sequenceId = seqItem->sequenceId; + gfxItem->id = seqItem->id; + gfxItem->animation = animation; + gfxItem->currFrameNum = 0; + gfxItem->flags = 0; + gfxItem->delayTicks = seqItem->totalDuration + animation->field_4; + gfxItem->updFlag = false; + gfxItem->updRectsCount = 0; + gfxItem->prevFrame.duration = 0; + gfxItem->prevFrame.spriteId = -1; + gfxItem->prevFrame.soundId = -1; + gfxItem->prevFrame.unkValue = -1; + totalDuration = duration; + if ((seqItem->flags & 4) && totalDuration > 0) { + gfxItem->prevFrame.duration = 1; + if (gfxItem->delayTicks <= totalDuration) + gfxItem->delayTicks = 0; + else + gfxItem->delayTicks -= totalDuration + 1; + gfxItem->updFlag = false; + } else if (gfxItem->delayTicks <= totalDuration) { + int j; + totalDuration -= gfxItem->delayTicks; + gfxItem->delayTicks = 0; + for (j = gfxItem->currFrameNum; j < animation->framesCount && animation->frames[j].duration <= totalDuration; ++j) { + if (animation->frames[j].soundId != -1) + _soundIds.push_back((gfxItem->sequenceId & 0xFFFF0000) | animation->frames[j].soundId); + totalDuration -= animation->frames[j].duration; + } + if (animation->framesCount > j) + gfxItem->currFrame = animation->frames[j++]; + else + gfxItem->currFrame = animation->frames[j - 1]; + if (gfxItem->currFrame.spriteId != -1 && (seqItem->x != 0 || seqItem->y != 0)) + gfxItem->currFrame.rect.translate(seqItem->x, seqItem->y); + // Update sprite scaling + if ((seqItem->flags & 1) && gfxItem->currFrame.rect.bottom >= _backgroundImageValue1 && gfxItem->currFrame.rect.bottom <= _backgroundImageValue3) { + int v2 = _backgroundImageValue2 + (gfxItem->currFrame.rect.bottom - _backgroundImageValue1) * + (_backgroundImageValue4 - _backgroundImageValue2) / + (_backgroundImageValue3 - _backgroundImageValue1); + gfxItem->currFrame.rect.top = gfxItem->currFrame.rect.bottom - v2 * (gfxItem->currFrame.rect.bottom - gfxItem->currFrame.rect.top) / 1000; + gfxItem->currFrame.rect.right = v2 * (gfxItem->currFrame.rect.right - gfxItem->currFrame.rect.left) / 1000 + gfxItem->currFrame.rect.left; + gfxItem->currFrame.isScaled = 1; + } + gfxItem->currFrame.duration -= totalDuration; + if (gfxItem->currFrame.soundId != -1) + _soundIds.push_back((gfxItem->sequenceId & 0xFFFF0000) | gfxItem->currFrame.soundId); + gfxItem->currFrameNum = j; + gfxItem->updFlag = true; + } else { + gfxItem->delayTicks -= totalDuration + 1; + gfxItem->updFlag = false; + } + } + + for (int k = 0; k < kMaxAnimations; ++k) { + if (_animations[k].sequenceId != -1 && _animations[k].sequenceId == seqItem->sequenceId && _animations[k].id == seqItem->id) { + _animations[k].status = 1; + break; + } + } + +} + +void GameSys::seqRemoveGfx(int sequenceId, int id) { + int gfxIndex; + if (seqLocateGfx(sequenceId, id, &gfxIndex)) { + GfxItem *gfxItem = &_gfxItems[gfxIndex]; + while (gfxIndex < _gfxItemsCount && gfxItem->sequenceId == sequenceId && gfxItem->id == id) { + if (gfxItem->prevFrame.spriteId == -1) { + --_gfxItemsCount; + if (gfxIndex != _gfxItemsCount) + memcpy(&_gfxItems[gfxIndex], &_gfxItems[gfxIndex + 1], sizeof(GfxItem) * (_gfxItemsCount - gfxIndex)); + } else { + gfxItem->sequenceId = -1; + gfxItem->animation = 0; + gfxItem->currFrame.duration = 0; + gfxItem->currFrame.spriteId = -1; + gfxItem->currFrame.soundId = -1; + gfxItem->currFrame.unkValue = -1; + gfxItem->updFlag = true; + ++gfxIndex; + gfxItem = &_gfxItems[gfxIndex]; + } + } + } +} + +bool GameSys::updateSequenceDuration(int sequenceId, int id, int *outDuration) { + bool found = false; + int duration = 0x7FFFFFFF; + for (int i = 0; i < _gfxItemsCount; ++i) { + GfxItem *gfxItem = &_gfxItems[i]; + if (gfxItem->sequenceId == sequenceId && gfxItem->id == id) { + found = true; + SequenceAnimation *animation = gfxItem->animation; + if (animation) { + if (gfxItem->currFrameNum < animation->framesCount) + return false; + if (gfxItem->updFlag) { + if (gfxItem->currFrame.duration > 0) + return false; + if (-gfxItem->currFrame.duration < duration) + duration = -gfxItem->currFrame.duration; + } else { + if (gfxItem->prevFrame.duration > 0) + return false; + if (-gfxItem->prevFrame.duration < duration) + duration = -gfxItem->prevFrame.duration; + } + } + } + } + if (found) + *outDuration = duration; + return found; +} + +void GameSys::updateAnimationsStatus(int sequenceId, int a2) { + + Animation *foundAnimation = 0; + for (int animationIndex = 0; animationIndex < kMaxAnimations; ++animationIndex) { + Animation *animation = &_animations[animationIndex]; + if (animation->sequenceId != -1 && animation->sequenceId == sequenceId && animation->id == a2) { + foundAnimation = animation; + break; + } + } + + if (!foundAnimation) + return; + + bool foundSequence = false; + for (int i = 0; i < _gfxItemsCount; ++i) { + GfxItem *gfxItem = &_gfxItems[i]; + SequenceAnimation *animation = gfxItem->animation; + if (gfxItem->sequenceId == sequenceId && gfxItem->id == a2 && animation) { + foundSequence = true; + if (animation->framesCount > gfxItem->currFrameNum || + (gfxItem->updFlag && gfxItem->currFrame.duration > 1) || + gfxItem->prevFrame.duration > 1) + foundSequence = false; + break; + } + } + + if (foundSequence) { + foundAnimation->sequenceId = -1; + foundAnimation->status = 2; + } + +} + +void GameSys::restoreBackgroundRect(const Common::Rect &rect) { + Common::Rect clipRect; + if (!intersectRect(clipRect, rect, _screenRect)) + return; + byte *src = (byte*)_backgroundSurface->getBasePtr(clipRect.left, clipRect.top); + byte *dst = (byte*)_frontSurface->getBasePtr(clipRect.left, clipRect.top); + const int bytes = _backgroundSurface->format.bytesPerPixel * clipRect.width(); + int height = clipRect.height(); + while (height--) { + memcpy(dst, src, bytes); + src += _backgroundSurface->pitch; + dst += _frontSurface->pitch; + } +} + +void GameSys::blitSurface32(Graphics::Surface *destSurface, int x, int y, Graphics::Surface *sourceSurface, + Common::Rect &sourceRect, bool transparent) { + + const int sourcePitch = sourceSurface->pitch; + byte *dst = (byte*)destSurface->getBasePtr(x, y); + byte *src = (byte*)sourceSurface->getBasePtr(sourceRect.left, sourceRect.top); + int width = sourceRect.width(); + int height = sourceRect.height(); + while (height--) { + byte *rsrc = src; + byte *rdst = dst; + for (int xc = 0; xc < width; ++xc) { + uint32 pixel = READ_LE_UINT32(rsrc); + if (!transparent || pixel != 0xFFFF00FF) + WRITE_LE_UINT32(rdst, pixel); + rsrc += 4; + rdst += 4; + } + dst += destSurface->pitch; + src += sourcePitch; + } +} + +void GameSys::blitSprite32(Graphics::Surface *destSurface, int x, int y, byte *sourcePixels, + int sourceWidth, Common::Rect &sourceRect, uint32 *sourcePalette, bool transparent) { + + const int sourcePitch = (sourceWidth + 3) & 0xFFFFFFFC; + byte *dst = (byte*)destSurface->getBasePtr(x, y); + byte *src = sourcePixels + sourceRect.left + sourcePitch * sourceRect.top; + int width = sourceRect.width(); + int height = sourceRect.height(); + while (height--) { + byte *rdst = dst; + for (int xc = 0; xc < width; ++xc) { + byte srcPixel = src[xc]; + if (!transparent || srcPixel) { + uint32 rgb = sourcePalette[srcPixel]; + rdst[0] = rgb & 0x000000FF; + rdst[1] = (rgb & 0x0000FF00) >> 8; + rdst[2] = (rgb & 0x00FF0000) >> 16; + } + rdst += 4; + } + dst += destSurface->pitch; + src += sourcePitch; + } +} + +void GameSys::blitSpriteScaled32(Graphics::Surface *destSurface, Common::Rect &frameRect, + Common::Rect &destRect, byte *sourcePixels, int sourceWidth, Common::Rect &sourceRect, uint32 *sourcePalette) { + + if (frameRect.height() <= 0 || frameRect.width() <= 0) + return; + + const int ys = ((sourceRect.bottom - sourceRect.top - 1) << 16) / (frameRect.bottom - frameRect.top - 1); + const int xs = ((sourceRect.right - sourceRect.left - 1) << 16) / (frameRect.right - frameRect.left - 1); + const int destPitch = destSurface->pitch; + const int sourcePitch = (sourceWidth + 3) & 0xFFFFFFFC; + + if (!frameRect.equals(destRect)) { + byte *dst = (byte*)destSurface->getBasePtr(destRect.left, destRect.top); + byte *src = sourcePixels + sourcePitch * sourceRect.top + sourceRect.left; + const int height = destRect.bottom - destRect.top; + const int width = destRect.right - destRect.left; + int yi = ys * (destRect.top - frameRect.top); + byte *hsrc = src + sourcePitch * ((yi + 0x8000) >> 16); + for (int i = 0; i < height; ++i) { + byte *wdst = dst; + int xi = xs * (destRect.left - frameRect.left); + byte *wsrc = hsrc + ((xi + 0x8000) >> 16); + for (int j = 0; j < width; ++j) { + byte srcPixel = *wsrc; + if (srcPixel) { + uint32 rgb = sourcePalette[srcPixel]; + wdst[0] = rgb & 0x000000FF; + wdst[1] = (rgb & 0x0000FF00) >> 8; + wdst[2] = (rgb & 0x00FF0000) >> 16; + } + wdst += 4; + xi += xs; + wsrc = hsrc + ((xi + 0x8000) >> 16); + } + dst += destPitch; + yi += ys; + hsrc = src + sourcePitch * ((yi + 0x8000) >> 16); + } + } else { + byte *dst = (byte*)destSurface->getBasePtr(frameRect.left, frameRect.top); + byte *src = sourcePixels + sourcePitch * sourceRect.top + sourceRect.left; + const int height = frameRect.bottom - frameRect.top; + const int width = frameRect.right - frameRect.left; + byte *hsrc = sourcePixels + sourcePitch * sourceRect.top + sourceRect.left; + int yi = 0; + for (int i = 0; i < height; ++i) { + byte *wdst = dst; + byte *wsrc = hsrc; + int xi = 0; + for (int j = 0; j < width; ++j) { + byte srcPixel = *wsrc; + if (srcPixel) { + uint32 rgb = sourcePalette[srcPixel]; + wdst[0] = rgb & 0x000000FF; + wdst[1] = (rgb & 0x0000FF00) >> 8; + wdst[2] = (rgb & 0x00FF0000) >> 16; + } + wdst += 4; + xi += xs; + wsrc = hsrc + ((xi + 0x8000) >> 16); + } + dst += destPitch; + yi += ys; + hsrc = src + sourcePitch * ((yi + 0x8000) >> 16); + } + } + +} + +void GameSys::seqDrawStaticFrame(Graphics::Surface *surface, SequenceFrame &frame, Common::Rect *subRect) { + debug(1, "GameSys::seqDrawStaticFrame() rect: (%d, %d, %d, %d)", + frame.rect.left, frame.rect.top, frame.rect.right, frame.rect.bottom); + + Common::Rect srcRect = subRect ? *subRect : frame.rect; + Common::Rect clipRect; + + if (!intersectRect(clipRect, srcRect, _screenRect)) { + debug(1, "GameSys::seqDrawStaticFrame() Surface not inside screen"); + return; + } + + const int x = clipRect.left, y = clipRect.top; + + clipRect.translate(-frame.rect.left, -frame.rect.top); + + // TODO Save transparent flag somewhere + blitSurface32(_frontSurface, x, y, surface, clipRect, true); + +} + +void GameSys::seqDrawSpriteFrame(SpriteResource *spriteResource, SequenceFrame &frame, Common::Rect *subRect) { + debug(1, "GameSys::seqDrawSpriteFrame() spriteId: %04X; rect: (%d, %d, %d, %d)", + frame.spriteId, frame.rect.left, frame.rect.top, frame.rect.right, frame.rect.bottom); + + Common::Rect srcRect = subRect ? *subRect : frame.rect; + Common::Rect clipRect; + + if (!intersectRect(clipRect, srcRect, _screenRect)) { + debug(1, "GameSys::seqDrawSpriteFrame() Sprite not inside screen"); + return; + } + + uint32 *sourcePalette = spriteResource->_palette; + byte *sourcePixels = spriteResource->_pixels; + + const int x = clipRect.left, y = clipRect.top; + + debug(1, "GameSys::seqDrawSpriteFrame() destX: %d; destY: %d; frame.isScaled: %d", x, y, frame.isScaled); + + // 32bit sprite drawing + if (frame.isScaled) { + Common::Rect sourceRect(0, 0, spriteResource->_width, spriteResource->_height); + blitSpriteScaled32(_frontSurface, frame.rect, clipRect, sourcePixels, spriteResource->_width, sourceRect, sourcePalette); + } else { + clipRect.translate(-frame.rect.left, -frame.rect.top); + blitSprite32(_frontSurface, x, y, sourcePixels, spriteResource->_width, clipRect, sourcePalette, true);//spriteResource->_transparent != 0); + } + +} + +void GameSys::drawSprites() { + + debug(1, "GameSys::drawSprites() _gfxItemsCount: %d", _gfxItemsCount); + + // TODO Split into multiple functions for clarity + + // Restore dirty background and collect rects to be redrawn for all sprites + // which aren't marked to be redrawn yet + Common::Rect intersectingRect; + for (uint i = 0; i < _dirtyRects.size(); ++i) { + restoreBackgroundRect(_dirtyRects[i]); + for (int j = 0; j < _gfxItemsCount; ++j) + _gfxItems[j].testUpdRect(_dirtyRects[i]); + } + + for (int k = 0; k < _gfxItemsCount; ++k) { + GfxItem *gfxItem2 = &_gfxItems[k]; + + if (!gfxItem2->updFlag) + continue; + + if (gfxItem2->prevFrame.spriteId != -1) { + int transparent = 0; + if (gfxItem2->currFrame.spriteId != -1 && !(gfxItem2->flags & 2)) { + if (gfxItem2->flags & 1) { + transparent = 1; + } else { + int resourceId = (gfxItem2->sequenceId & 0xFFFF0000) | gfxItem2->currFrame.spriteId; + SpriteResource *spriteResource = _vm->_spriteCache->get(resourceId); + transparent = spriteResource->_transparent; + _vm->_spriteCache->release(resourceId); + } + } + if ((gfxItem2->flags & 8) || gfxItem2->currFrame.spriteId == -1 || + (!(gfxItem2->flags & 2) && (!gfxItem2->prevFrame.rect.equals(gfxItem2->currFrame.rect) || !transparent))) { + restoreBackgroundRect(gfxItem2->prevFrame.rect); + for (int l = 0; l < _gfxItemsCount; ++l) + _gfxItems[l].testUpdRect(gfxItem2->prevFrame.rect); + } + } + + if (gfxItem2->currFrame.spriteId != -1) { + int transparent = 0; + if (gfxItem2->flags & 1) { + transparent = 1; + } else if (!(gfxItem2->flags & 2)) { + int resourceId = (gfxItem2->sequenceId & 0xFFFF0000) | gfxItem2->currFrame.spriteId; + SpriteResource *spriteResource = _vm->_spriteCache->get(resourceId); + transparent = spriteResource->_transparent; + _vm->_spriteCache->release(resourceId); + } + if (((gfxItem2->flags & 2) && !(gfxItem2->flags & 8)) || + gfxItem2->prevFrame.spriteId == -1 || + !gfxItem2->prevFrame.rect.equals(gfxItem2->currFrame.rect) || transparent) { + for (int l = k; l < _gfxItemsCount; ++l) + _gfxItems[l].testUpdRect(gfxItem2->currFrame.rect); + } + } + + } + + for (int m = 0; m < _gfxItemsCount; ++m) { + GfxItem *gfxItem5 = &_gfxItems[m]; + + debug(0, "DrawGfxItem(%d) updFlag: %d; currFrame.spriteId: %04X; updRectsCount: %d; flags: %04X; sequenceId: %08X", + m, gfxItem5->updFlag, gfxItem5->currFrame.spriteId, gfxItem5->updRectsCount, gfxItem5->flags, gfxItem5->sequenceId); + + if (gfxItem5->updFlag) { + if (gfxItem5->currFrame.spriteId != -1) { + if (gfxItem5->flags & 1) { + seqDrawStaticFrame(gfxItem5->surface, gfxItem5->currFrame, 0); + //debug("seqDrawStaticFrame"); + } else if (gfxItem5->flags & 2) { + // TODO seqDrawAviFrame(gfxItem5->currFrame.spriteId, &gfxItem5->currFrame, 0, gfxItem5->flags & 8); + } else { + int resourceId = (gfxItem5->sequenceId & 0xFFFF0000) | gfxItem5->currFrame.spriteId; + SpriteResource *spriteResource = _vm->_spriteCache->get(resourceId); + seqDrawSpriteFrame(spriteResource, gfxItem5->currFrame, 0); + _vm->_spriteCache->release(resourceId); + } + } + } else if (gfxItem5->updRectsCount > 0) { + if (gfxItem5->flags & 1) { + for (int n = 0; n < gfxItem5->updRectsCount; ++n) + seqDrawStaticFrame(gfxItem5->surface, gfxItem5->prevFrame, &gfxItem5->updRects[n]); + } else if (gfxItem5->flags & 2) { + /* TODO + spriteData4 = gfxItem5->prevFrame.spriteId; + for (int n = 0; n < gfxItem5->updRectsCount; ++n) + seqDrawAviFrame(spriteData4, &gfxItem5->prevFrame, &gfxItem5->updRects[n], gfxItem5->flags & 8); + */ + } else { + int resourceId = (gfxItem5->sequenceId & 0xFFFF0000) | gfxItem5->prevFrame.spriteId; + SpriteResource *spriteResource = _vm->_spriteCache->get(resourceId); + for (int n = 0; n < gfxItem5->updRectsCount; ++n) + seqDrawSpriteFrame(spriteResource, gfxItem5->prevFrame, &gfxItem5->updRects[n]); + _vm->_spriteCache->release(resourceId); + } + } + } + + debug(1, "GameSys::drawSprites() OK"); + +} + +void GameSys::updateRect(const Common::Rect &r) { + debug(1, "GameSys::updateRect() %d, %d, %d, %d [%d, %d]", r.left, r.top, r.right, r.bottom, r.width(), r.height()); + if (r.width() > 0 && r.height() > 0) { + byte *pixels = (byte*)_frontSurface->getBasePtr(r.left, r.top); + _vm->_system->copyRectToScreen(pixels, _frontSurface->pitch, r.left, r.top, + r.width(), r.height()); + } +} + +void GameSys::updateScreen() { + + debug(1, "GameSys::updateScreen()"); + + for (uint i = 0; i < _dirtyRects.size(); ++i) + updateRect(_dirtyRects[i]); + + if (_dirtyRects.size() > 0) { + _dirtyRects.clear(); + _lastUpdateClock = 0; + _gameSysClock = 0; + } + + Common::Rect dstRect, srcRect, rcSrc2; + + for (int j = 0; j < _gfxItemsCount; ++j) { + + GfxItem *gfxItem = &_gfxItems[j]; + + if (!gfxItem->updFlag) + continue; + + if (gfxItem->prevFrame.spriteId == -1 || + !intersectRect(srcRect, _screenRect, gfxItem->prevFrame.rect)) { + if (gfxItem->currFrame.spriteId != -1 && intersectRect(rcSrc2, _screenRect, gfxItem->currFrame.rect)) + updateRect(rcSrc2); + } else if (gfxItem->currFrame.spriteId != -1 && + intersectRect(rcSrc2, _screenRect, gfxItem->currFrame.rect)) { + updateRect(srcRect); + updateRect(rcSrc2); + } + gfxItem->prevFrame = gfxItem->currFrame; + } + + updateRect(Common::Rect(0, 0, 800, 600)); + + debug(1, "GameSys::updateScreen() OK"); + +} + +void GameSys::handleReqRemoveSequenceItem() { + if (_reqRemoveSequenceItem) { + int gfxIndex2; + _reqRemoveSequenceItem = false; + if (seqFind(_removeSequenceItemSequenceId, _removeSequenceItemValue, &gfxIndex2)) + _seqItems.remove_at(gfxIndex2); + if (seqLocateGfx(_removeSequenceItemSequenceId, _removeSequenceItemValue, &gfxIndex2)) { + int gfxIndex2a = gfxIndex2; + for (GfxItem *gfxItem = &_gfxItems[gfxIndex2a]; + gfxIndex2a < _gfxItemsCount && gfxItem->sequenceId == _removeSequenceItemSequenceId && gfxItem->id == _removeSequenceItemValue; + gfxItem = &_gfxItems[gfxIndex2a]) + ++gfxIndex2a; + _gfxItemsCount -= gfxIndex2a - gfxIndex2; + if (_gfxItemsCount != gfxIndex2) + memcpy(&_gfxItems[gfxIndex2], &_gfxItems[gfxIndex2a], sizeof(GfxItem) * (_gfxItemsCount - gfxIndex2)); + } + } +} + +void GameSys::handleReqRemoveSequenceItems() { + if (_removeSequenceItemsCount > 0) { + for (int i = 0; i < _removeSequenceItemsCount; ++i) { + int gfxIndex; + if (seqFind(_removeSequenceItems[i].sequenceId, _removeSequenceItems[i].id, &gfxIndex)) + _seqItems.remove_at(gfxIndex); + seqLocateGfx(_removeSequenceItems[i].sequenceId, _removeSequenceItems[i].id, &gfxIndex); + for (GfxItem *gfxItem = &_gfxItems[gfxIndex]; + gfxIndex < _gfxItemsCount && gfxItem->sequenceId == _removeSequenceItems[i].sequenceId && gfxItem->id == _removeSequenceItems[i].id; + gfxItem = &_gfxItems[gfxIndex]) { + gfxItem->sequenceId = -1; + gfxItem->animation = 0; + gfxItem->soundValue = 0; + if (_removeSequenceItems[i].a3) { + gfxItem->currFrame.duration = 0; + gfxItem->currFrame.spriteId = -1; + gfxItem->currFrame.soundId = -1; + gfxItem->currFrame.unkValue = -1; + gfxItem->updFlag = true; + } else { + gfxItem->updFlag = false; + } + ++gfxIndex; + } + } + _removeSequenceItemsCount = 0; + } +} + +void GameSys::handleReqRemoveSpriteDrawItems() { + if (_removeSpriteDrawItemsCount > 0) { + for (int j = 0; j < _removeSpriteDrawItemsCount; ++j) { + for (int i = 0; i < _gfxItemsCount; ++i) { + GfxItem *gfxItem = &_gfxItems[i]; + if (gfxItem->sequenceId == -1 && !gfxItem->animation && (gfxItem->flags & 1) && + gfxItem->id == _removeSpriteDrawItems[j].id && _removeSpriteDrawItems[j].surface == gfxItem->surface) { + gfxItem->flags = 0; + gfxItem->currFrame.duration = 0; + gfxItem->currFrame.spriteId = -1; + gfxItem->currFrame.soundId = -1; + gfxItem->currFrame.unkValue = -1; + gfxItem->updFlag = true; + } + } + } + _removeSpriteDrawItemsCount = 0; + } +} + +void GameSys::fatUpdateFrame() { + + debug(1, "GameSys::fatUpdateFrame()"); + + int32 clockDelta = _gameSysClock - _lastUpdateClock; + _lastUpdateClock = _gameSysClock; + + debug(1, "GameSys::fatUpdateFrame() clockDelta: %d", clockDelta); + + if (clockDelta <= 0) + return; + + bool updFlag = true; + int duration, v20, currFrameNum; + + // NOTE Skipped avi code (reqAviStart) + + for (int i = 0; i < _gfxItemsCount; ++i) { + GfxItem *gfxItem = &_gfxItems[i]; + SequenceAnimation *animation = gfxItem->animation; + if ((gfxItem->sequenceId != -1 && animation) || (gfxItem->flags & 2) || + gfxItem->prevFrame.spriteId != -1 || gfxItem->prevFrame.duration > 0) { + if (gfxItem->sequenceId == -1 || gfxItem->updFlag) { + if ((gfxItem->flags & 2) && !gfxItem->updFlag) { + // NOTE Skipped avi code + } + } else { + Sequence *seqItem = seqFind(gfxItem->sequenceId, gfxItem->id, 0); + if (!animation) { + updFlag = false; + gfxItem->sequenceId = -1; + gfxItem->animation = 0; + gfxItem->currFrame.duration = 0; + gfxItem->currFrame.spriteId = -1; + gfxItem->currFrame.soundId = -1; + gfxItem->currFrame.unkValue = -1; + gfxItem->updFlag = true; + } else if (!seqItem) { + updFlag = false; + gfxItem->animation = 0; + gfxItem->currFrame.duration = 0; + gfxItem->currFrame.spriteId = -1; + gfxItem->currFrame.soundId = -1; + gfxItem->currFrame.unkValue = -1; + gfxItem->updFlag = true; + } else if ((seqItem->flags & 4) && clockDelta > 1) { + updFlag = false; + if (gfxItem->delayTicks < clockDelta) { + duration = clockDelta - gfxItem->delayTicks; + gfxItem->delayTicks = 0; + if (gfxItem->prevFrame.duration <= duration) + gfxItem->prevFrame.duration = 1; + else + gfxItem->prevFrame.duration -= duration; + } else { + gfxItem->delayTicks -= clockDelta; + } + gfxItem->updFlag = false; + } else if (gfxItem->delayTicks < clockDelta) { + duration = clockDelta - gfxItem->delayTicks; + gfxItem->delayTicks = 0; + if (gfxItem->prevFrame.duration <= duration) { + v20 = 0; + if (gfxItem->prevFrame.duration > 0) { + duration -= gfxItem->prevFrame.duration; + gfxItem->prevFrame.duration = -duration; + } else { + gfxItem->prevFrame.duration = 0; + v20 = 1; + } + currFrameNum = gfxItem->currFrameNum; + if (animation->framesCount > currFrameNum) { + updFlag = false; + while (animation->framesCount > currFrameNum && + animation->frames[currFrameNum].duration <= duration) { + if (animation->frames[currFrameNum].soundId != -1) + _soundIds.push_back((gfxItem->sequenceId & 0xFFFF0000) | animation->frames[currFrameNum].soundId); + duration -= animation->frames[currFrameNum].duration; + ++currFrameNum; + } + if (animation->framesCount > currFrameNum) + gfxItem->currFrame = animation->frames[currFrameNum++]; + else + gfxItem->currFrame = animation->frames[currFrameNum - 1]; + if (gfxItem->currFrame.spriteId != -1 && (seqItem->x != 0 || seqItem->y != 0)) + gfxItem->currFrame.rect.translate(seqItem->x, seqItem->y); + // Update sprite scaling + if ((seqItem->flags & 1) && gfxItem->currFrame.rect.bottom >= _backgroundImageValue1 && gfxItem->currFrame.rect.bottom <= _backgroundImageValue3) { + int v17 = _backgroundImageValue2 + (gfxItem->currFrame.rect.bottom - _backgroundImageValue1) * + (_backgroundImageValue4 - _backgroundImageValue2) / + (_backgroundImageValue3 - _backgroundImageValue1); + gfxItem->currFrame.rect.top = gfxItem->currFrame.rect.bottom - v17 * (gfxItem->currFrame.rect.bottom - gfxItem->currFrame.rect.top) / 1000; + gfxItem->currFrame.rect.right = v17 * (gfxItem->currFrame.rect.right - gfxItem->currFrame.rect.left) / 1000 + gfxItem->currFrame.rect.left; + gfxItem->currFrame.isScaled = 1; + } + gfxItem->currFrame.duration -= duration; + if (gfxItem->currFrame.soundId != -1) + _soundIds.push_back((gfxItem->sequenceId & 0xFFFF0000) | gfxItem->currFrame.soundId); + gfxItem->currFrameNum = currFrameNum; + gfxItem->updFlag = true; + } else if (v20 && gfxItem->prevFrame.spriteId == -1) { + --_gfxItemsCount; + if (_gfxItemsCount != i) + memcpy(&_gfxItems[i], &_gfxItems[i + 1], sizeof(GfxItem) * (_gfxItemsCount - i)); + --i; + } else { + gfxItem->updFlag = false; + } + } else { + updFlag = false; + gfxItem->prevFrame.duration -= duration; + gfxItem->updFlag = false; + } + } else { + updFlag = false; + gfxItem->delayTicks -= clockDelta; + gfxItem->updFlag = false; + } + } + } else { + --_gfxItemsCount; + if (_gfxItemsCount != i) + memcpy(&_gfxItems[i], &_gfxItems[i + 1], sizeof(GfxItem) * (_gfxItemsCount - i)); + --i; + } + } + + if (_newSpriteDrawItemsCount > 0) { + debug(0, "_newSpriteDrawItemsCount: %d", _newSpriteDrawItemsCount); + for (int k = 0; k < _newSpriteDrawItemsCount; ++k) { + if (_gfxItemsCount < 50) { + int insertIndex; + seqLocateGfx(-1, _newSpriteDrawItems[k].id, &insertIndex); + if (_gfxItemsCount != insertIndex) + memcpy(&_gfxItems[insertIndex + 1], &_gfxItems[insertIndex], sizeof(GfxItem) * (_gfxItemsCount - insertIndex)); + ++_gfxItemsCount; + GfxItem *gfxItem = &_gfxItems[insertIndex]; + gfxItem->sequenceId = -1; + gfxItem->id = _newSpriteDrawItems[k].id; + gfxItem->animation = 0; + gfxItem->currFrameNum = 0; + gfxItem->flags = 1; + gfxItem->delayTicks = 0; + gfxItem->updFlag = true; + gfxItem->updRectsCount = 0; + gfxItem->surface = _newSpriteDrawItems[k].surface; + gfxItem->prevFrame.duration = 0; + gfxItem->prevFrame.spriteId = -1; + gfxItem->prevFrame.soundId = -1; + gfxItem->prevFrame.unkValue = -1; + gfxItem->currFrame.duration = 0; + gfxItem->currFrame.isScaled = 0; + gfxItem->currFrame.rect = _newSpriteDrawItems[k].rect; + gfxItem->currFrame.spriteId = _newSpriteDrawItems[k].surface ? 0xCAFEBABE : -1;// TODO + gfxItem->currFrame.soundId = -1; + gfxItem->currFrame.unkValue = -1; + } + } + _newSpriteDrawItemsCount = 0; + } + + if (_grabSpriteChanged) { + for (int i = 0; i < _gfxItemsCount; ++i) { + GfxItem *gfxItem = &_gfxItems[i]; + if (gfxItem->sequenceId == -1 && !gfxItem->animation && (gfxItem->flags & 1) && + gfxItem->id == _grabSpriteId && gfxItem->surface == _grabSpriteSurface1) { + gfxItem->currFrame.duration = 0; + gfxItem->currFrame.isScaled = 0; + gfxItem->currFrame.rect = _grabSpriteRect; + gfxItem->currFrame.spriteId = _grabSpriteSurface2 ? 1 : -1;// TODO + gfxItem->currFrame.soundId = -1; + gfxItem->currFrame.unkValue = -1; + gfxItem->updFlag = true; + gfxItem->surface = _grabSpriteSurface2; + break; + } + } + _grabSpriteChanged = false; + } + + // NOTE Skipped avi code (reqAviStart) + + debug(1, "GameSys::fatUpdateFrame() _fatSequenceItems.size(): %d", _fatSequenceItems.size()); + + for (uint i = 0; i < _fatSequenceItems.size(); ++i) { + Sequence *seqItem = &_fatSequenceItems[i]; + if (((seqItem->flags & 8) || (seqItem->flags & 0x20)) && seqItem->sequenceId2 != -1) { + duration = 0; + if (((seqItem->flags & 0x20) && seqLocateGfx(seqItem->sequenceId2, seqItem->id2, 0)) || + updateSequenceDuration(seqItem->sequenceId2, seqItem->id2, &duration)) { + int index; + bool found = false; + if (seqItem->sequenceId2 == seqItem->sequenceId && seqItem->id == seqItem->id2 && + seqFind(seqItem->sequenceId, seqItem->id, &index)) { + _seqItems[index] = *seqItem; + found = true; + } else if (_seqItems.size() < 50) { + index = _seqItems.size(); + _seqItems.push_back(*seqItem); + found = true; + } + if (found) { + updFlag = false; + seqRemoveGfx(seqItem->sequenceId2, seqItem->id2); + seqRemoveGfx(seqItem->sequenceId, seqItem->id); + _fatSequenceItems.remove_at(i); + --i; + seqInsertGfx(index, duration); + } + } + } else { + updFlag = false; + if (seqItem->totalDuration < clockDelta) { + int index; + bool found = false; + duration = clockDelta - seqItem->totalDuration; + seqItem->totalDuration = 0; + if (seqFind(seqItem->sequenceId, seqItem->id, &index)) { + _seqItems[index] = *seqItem; + found = true; + } else if (_seqItems.size() < 50) { + index = _seqItems.size(); + _seqItems.push_back(*seqItem); + found = true; + } + if (found) { + seqRemoveGfx(seqItem->sequenceId, seqItem->id); + _fatSequenceItems.remove_at(i); + --i; + seqInsertGfx(index, duration - 1); + } + } else { + seqItem->totalDuration -= clockDelta; + } + } + } + + debug(1, "GameSys::fatUpdateFrame() _seqItems.size(): %d", _seqItems.size()); + + for (uint i = 0; i < _seqItems.size(); ++i) { + Sequence *seqItem = &_seqItems[i]; + if (seqLocateGfx(seqItem->sequenceId, seqItem->id, 0)) { + updateAnimationsStatus(seqItem->sequenceId, seqItem->id); + if (seqItem->flags & 2) { + int gfxDuration; + updFlag = false; + if (updateSequenceDuration(seqItem->sequenceId, seqItem->id, &gfxDuration)) { + seqRemoveGfx(seqItem->sequenceId, seqItem->id); + seqInsertGfx(i, gfxDuration); + } + } + } else { + _seqItems.remove_at(i); + --i; + } + } + +} + +void GameSys::fatUpdate() { + + debug(1, "GameSys::fatUpdate() _gfxItemsCount: %d", _gfxItemsCount); + + for (int i = 0; i < _gfxItemsCount; ++i) { + _gfxItems[i].updFlag = false; + _gfxItems[i].updRectsCount = 0; + } + + handleReqRemoveSequenceItem(); + handleReqRemoveSequenceItems(); + handleReqRemoveSpriteDrawItems(); + // NOTE Skipped avi stuff (reqAviStop) + + fatUpdateFrame(); + +} + +void GameSys::updatePlaySounds() { + for (uint i = 0; i < _soundIds.size(); ++i) + _vm->playSound(_soundIds[i], false); + _soundIds.clear(); +} + +bool intersectRect(Common::Rect &intersectingRect, const Common::Rect &r1, const Common::Rect &r2) { + if (r1.intersects(r2)) { + intersectingRect = r1.findIntersectingRect(r2); + return true; + } else + return false; +} + +} // End of namespace Gnap diff --git a/engines/gnap/gamesys.h b/engines/gnap/gamesys.h new file mode 100644 index 0000000000..5e996bf844 --- /dev/null +++ b/engines/gnap/gamesys.h @@ -0,0 +1,216 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#ifndef GNAP_GAMESYS_H +#define GNAP_GAMESYS_H + +#include "gnap/gnap.h" +#include "gnap/resource.h" +#include "common/array.h" +#include "common/rect.h" +#include "graphics/surface.h" + +namespace Gnap { + +const int kMaxSequenceItems = 40; +const int kMaxSpriteDrawItems = 30; +const int kMaxSoundIds = 50; +const int kMaxSeqItems = 50; +const int kMaxUpdRects = 20; +const int kMaxGfxItems = 50; +const int kMaxAnimations = 12; + +enum { + kSeqNone = 0x00, + kSeqScale = 0x01, // Enable scaling + kSeqLoop = 0x02, // Loop + kSeqUnk = 0x04, // Unknown + kSeqSyncWait = 0x08, // Start if other sequence is done + kSeqSyncExists = 0x20 // Start if other sequence exists +}; + +struct Sequence { + int32 sequenceId; + int32 id; + int32 sequenceId2; + int32 id2; + uint32 flags; + int32 totalDuration; + int16 x, y; +}; + +struct SpriteDrawItem { + int id; + Common::Rect rect; + Graphics::Surface *surface; +}; + +struct RemoveSequenceItem { + int sequenceId; + int id; + int a3; +}; + +struct RemoveSpriteDrawItem { + int id; + Graphics::Surface *surface; +}; + +struct GfxItem { + int sequenceId; + int id; + int flags; + SequenceAnimation *animation; + int soundValue; + int field_18; + int field_1C; + int currFrameNum; + int delayTicks; + bool updFlag; + int updRectsCount; + Graphics::Surface *surface; + Common::Rect updRects[kMaxUpdRects]; + SequenceFrame prevFrame; + SequenceFrame currFrame; + void testUpdRect(const Common::Rect &updRect); +}; + +struct Animation { + int sequenceId; + int id; + int status; +}; + +class GameSys { +public: + GameSys(GnapEngine *vm); + ~GameSys(); + void insertSequence(int sequenceId, int a2, int sequenceId2, int a4, int flags, int totalDuration, int16 x, int16 y); + void insertDirtyRect(const Common::Rect &rect); + void removeSequence(int sequenceId, int a2, int a3); + void invalidateGrabCursorSprite(int id, Common::Rect &rect, Graphics::Surface *surface1, Graphics::Surface *surface2); + void requestClear2(int a1); + void requestClear1(); + void requestRemoveSequence(int sequenceId, int a2); + void waitForUpdate(); + int isSequenceActive(int sequenceId, int a2); + void setBackgroundSurface(Graphics::Surface *surface, int a4, int a5, int a6, int a7); + void setScaleValues(int a1, int a2, int a3, int a4); + void insertSpriteDrawItem(Graphics::Surface *surface, int x, int y, int id); + void removeSpriteDrawItem(Graphics::Surface *surface, int a2); + void drawSpriteToBackground(int x, int y, int resourceId); + Graphics::Surface *allocSurface(int width, int height); + Graphics::Surface *createSurface(int resourceId); + void drawSpriteToSurface(Graphics::Surface *surface, int x, int y, int resourceId); + void drawTextToSurface(Graphics::Surface *surface, int x, int y, byte r, byte g, byte b, const char *text); + int getTextWidth(const char *text); + void fillSurface(Graphics::Surface *surface, int x, int y, int width, int height, byte r, byte g, byte b); + void setAnimation(int sequenceId, int id, int animationIndex); + int getAnimationStatus(int animationIndex); + int getSpriteWidthById(int resourceId); + int getSpriteHeightById(int resourceId); + Graphics::Surface *loadBitmap(int resourceId); + void drawBitmap(int resourceId); +public: + GnapEngine *_vm; + + Common::Array<Common::Rect> _dirtyRects; + + SpriteDrawItem _newSpriteDrawItems[kMaxSpriteDrawItems]; + int _newSpriteDrawItemsCount; + + bool _spriteDrawItems1Changed; + + RemoveSequenceItem _removeSequenceItems[kMaxSequenceItems]; + int _removeSequenceItemsCount; + + RemoveSpriteDrawItem _removeSpriteDrawItems[kMaxSpriteDrawItems]; + int _removeSpriteDrawItemsCount; + + int _grabSpriteId; + Common::Rect _grabSpriteRect; + bool _grabSpriteChanged; + Graphics::Surface *_grabSpriteSurface1, *_grabSpriteSurface2; + + bool _reqRemoveSequenceItem; + int _removeSequenceItemSequenceId, _removeSequenceItemValue; + + Common::Array<int> _soundIds; + + //////////////////////////////////////////////////////////////////////////// + + Common::Array<Sequence> _seqItems; + Common::Array<Sequence> _fatSequenceItems; + + GfxItem _gfxItems[kMaxGfxItems]; + int _gfxItemsCount; + + Animation _animations[kMaxAnimations]; + int _animationsCount; + + int _backgroundImageValue3, _backgroundImageValue1; + int _backgroundImageValue4, _backgroundImageValue2; + bool _backgroundImageError; + + int32 _gameSysClock, _lastUpdateClock; + + Graphics::Surface *_backgroundSurface; + Graphics::Surface *_frontSurface; + Common::Rect _screenRect; + + Sequence *seqFind(int sequenceId, int a2, int *outIndex); + int seqLocateGfx(int sequenceId, int id, int *outGfxIndex); + void seqInsertGfx(int index, int duration); + void seqRemoveGfx(int sequenceId, int id); + bool updateSequenceDuration(int sequenceId, int id, int *outDuration); + void updateAnimationsStatus(int sequenceId, int a2); + + void restoreBackgroundRect(const Common::Rect &rect); + + void blitSurface32(Graphics::Surface *destSurface, int x, int y, Graphics::Surface *sourceSurface, + Common::Rect &sourceRect, bool transparent); + void blitSprite32(Graphics::Surface *destSurface, int x, int y, byte *sourcePixels, + int sourceWidth, Common::Rect &sourceRect, uint32 *sourcePalette, bool transparent); + void blitSpriteScaled32(Graphics::Surface *destSurface, Common::Rect &frameRect, + Common::Rect &destRect, byte *sourcePixels, int sourceWidth, Common::Rect &sourceRect, uint32 *sourcePalette); + + void seqDrawStaticFrame(Graphics::Surface *surface, SequenceFrame &frame, Common::Rect *subRect); + void seqDrawSpriteFrame(SpriteResource *spriteResource, SequenceFrame &frame, Common::Rect *subRect); + + void drawSprites(); + void updateRect(const Common::Rect &r); + void updateScreen(); + + void handleReqRemoveSequenceItem(); + void handleReqRemoveSequenceItems(); + void handleReqRemoveSpriteDrawItems(); + void fatUpdateFrame(); + void fatUpdate(); + void updatePlaySounds(); + +}; + +bool intersectRect(Common::Rect &intersectingRect, const Common::Rect &r1, const Common::Rect &r2); + +} // End of namespace Gnap + +#endif // GNAP_GAMESYS_H diff --git a/engines/gnap/gnap.cpp b/engines/gnap/gnap.cpp new file mode 100644 index 0000000000..08f598551e --- /dev/null +++ b/engines/gnap/gnap.cpp @@ -0,0 +1,2404 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "gnap/gnap.h" +#include "gnap/datarchive.h" +#include "gnap/gamesys.h" +#include "gnap/resource.h" +#include "gnap/sound.h" + +#include "common/config-manager.h" +#include "common/debug-channels.h" +#include "common/error.h" +#include "common/fs.h" +#include "common/timer.h" + +#include "engines/util.h" + +#include "graphics/cursorman.h" + +namespace Gnap { + +static const int kCursors[] = { + LOOK_CURSOR, + GRAB_CURSOR, + TALK_CURSOR, + PLAT_CURSOR +}; + +static const int kDisabledCursors[] = { + NOLOOK_CURSOR, + NOGRAB_CURSOR, + NOTALK_CURSOR, + NOPLAT_CURSOR +}; + +static const char *kCursorNames[] = { + "LOOK_CURSOR", + "GRAB_CURSOR", + "TALK_CURSOR", + "PLAT_CURSOR", + "NOLOOK_CURSOR", + "NOGRAB_CURSOR", + "NOTALK_CURSOR", + "NOPLAT_CURSOR", + "EXIT_L_CURSOR", + "EXIT_R_CURSOR", + "EXIT_U_CURSOR", + "EXIT_D_CURSOR", + "EXIT_NE_CURSOR", + "EXIT_NW_CURSOR", + "EXIT_SE_CURSOR", + "EXIT_SW_CURSOR", + "WAIT_CURSOR" +}; + + +static const int kCursorSpriteIds[30] = { + 0x005, 0x008, 0x00A, 0x004, 0x009, 0x003, + 0x006, 0x007, 0x00D, 0x00F, 0x00B, 0x00C, + 0x019, 0x01C, 0x015, 0x014, 0x010, 0x01A, + 0x018, 0x013, 0x011, 0x012, 0x01B, 0x016, + 0x017, 0x01D, 0x01E, 0x01F, 0x76A, 0x76B +}; + +static const char *kSceneNames[] = { + "open", "pigpn", "truck", "creek", "mafrm", "frbrn", "inbrn", "crash", + "porch", "barbk", "kitch", "bar", "juke", "wash", "john", "jkbox", + "brawl", "stret", "frtoy", "intoy", "frgro", "park", "cash", "ingro", + "frcir", "booth", "circ", "outcl", "incln", "monk", "elcir", "beer", + "pig2", "trk2", "creek", "frbrn", "inbrn", "mafrm", "infrm", "efair", + "fair", "souv", "chick", "ship", "kiss", "disco", "boot", "can", + "can2", "drive", "tung", "puss", "space", "phone", "can3" +}; + +GnapEngine::GnapEngine(OSystem *syst, const ADGameDescription *gd) : + Engine(syst), _gameDescription(gd) { + + _random = new Common::RandomSource("gnap"); + + Engine::syncSoundSettings(); + +} + +GnapEngine::~GnapEngine() { + + delete _random; + +} + +Common::Error GnapEngine::run() { + // Initialize the graphics mode to ARGB8888 + Graphics::PixelFormat format = Graphics::PixelFormat(4, 8, 8, 8, 8, 16, 8, 0, 24); + initGraphics(800, 600, true, &format); + + // We do not support color conversion yet + if (_system->getScreenFormat() != format) + return Common::kUnsupportedColorMode; + + _lastUpdateClock = 0; + + // >>>>> Variable initialization + _cursorIndex = -1; + _verbCursor = 1; + invClear(); + clearFlags(); + _grabCursorSprite = 0; + _newGrabCursorSpriteIndex = -1; + _backgroundSurface = 0; + _isStockDatLoaded = false; + _gameDone = false; + _isPaused = false; + _pauseSprite = 0; + + //////////////////////////////////////////////////////////////////////////// + + _exe = new Common::PEResources(); + if (!_exe->loadFromEXE("ufos.exe")) + error("Could not load ufos.exe"); + + _dat = new DatManager(); + _spriteCache = new SpriteCache(_dat); + _soundCache = new SoundCache(_dat); + _sequenceCache = new SequenceCache(_dat); + _gameSys = new GameSys(this); + _soundMan = new SoundMan(this); + + _menuBackgroundSurface = 0; + + initGlobalSceneVars(); + +#if 1 + + mainLoop(); + +#else + + Graphics::Surface *testBack = new Graphics::Surface(); + testBack->create(800, 600, _system->getScreenFormat()); + //testBack->fillRect(Common::Rect(0, 0, 800, 600), 0xFFFFFFFF); + testBack->fillRect(Common::Rect(0, 0, 800, 600), 0xFF000000); + + _currentSceneNum = 26; + + Common::String datFilename = Common::String::format("%s_n.dat", kSceneNames[_currentSceneNum]); + _dat->open(0, datFilename.c_str()); + + _gameSys->setBackgroundSurface(testBack, 0, 500, 1, 1000); + + _gameSys->insertSequence(0x5b, 100, -1, -1, 0, 0, 0, 0); + + CursorMan.showMouse(true); + + while (!shouldQuit()) { + Common::Event event; + + while (_eventMan->pollEvent(event)) { + switch (event.type) { + case Common::EVENT_KEYDOWN: + break; + case Common::EVENT_LBUTTONUP: + case Common::EVENT_LBUTTONDOWN: + case Common::EVENT_RBUTTONUP: + case Common::EVENT_RBUTTONDOWN: + case Common::EVENT_MOUSEMOVE: + break; + case Common::EVENT_QUIT: + quitGame(); + break; + default: + break; + } + } + + _gameSys->fatUpdate(); + _gameSys->drawSprites(); + _gameSys->updateScreen(); + _gameSys->_gameSysClock++; + updateTimers(); + + _system->updateScreen(); + _system->delayMillis(100); + + } + + _dat->close(0); + + testBack->free(); + delete testBack; + + return Common::kNoError; + +#endif + + delete _soundMan; + delete _gameSys; + delete _sequenceCache; + delete _soundCache; + delete _spriteCache; + delete _dat; + + delete _exe; + + debug("run() done"); + + return Common::kNoError; +} + +bool GnapEngine::hasFeature(EngineFeature f) const { + return + false; +} + +void GnapEngine::updateEvents() { + Common::Event event; + + while (_eventMan->pollEvent(event)) { + switch (event.type) { + case Common::EVENT_KEYDOWN: + _keyPressState[event.kbd.keycode] = 1; + _keyDownState[event.kbd.keycode] = 1; + break; + case Common::EVENT_KEYUP: + _keyDownState[event.kbd.keycode] = 0; + break; + case Common::EVENT_MOUSEMOVE: + _mouseX = event.mouse.x; + _mouseY = event.mouse.y; + break; + case Common::EVENT_LBUTTONUP: + _mouseButtonState.left = false; + break; + case Common::EVENT_LBUTTONDOWN: + _leftClickMouseX = event.mouse.x; + _leftClickMouseY = event.mouse.y; + _mouseButtonState.left = true; + _mouseClickState.left = true; + break; + case Common::EVENT_RBUTTONUP: + _mouseButtonState.right = false; + break; + case Common::EVENT_RBUTTONDOWN: + _mouseButtonState.right = true; + _mouseClickState.right = true; + break; + case Common::EVENT_QUIT: + quitGame(); + break; + default: + break; + } + } +} + +void GnapEngine::gameUpdateTick() { + updateEvents(); + + // TODO Check _gameDone in the various game loops + if (shouldQuit()) { + _gameDone = true; + _sceneDone = true; + } + + // TODO Improve this (variable frame delay to keep ~15fps) + int currClock = _system->getMillis(); + if (currClock >= _lastUpdateClock + 66) { + _gameSys->fatUpdate(); + _gameSys->drawSprites(); + _gameSys->updateScreen(); + _gameSys->updatePlaySounds(); + _gameSys->_gameSysClock++; + updateTimers(); + _lastUpdateClock = currClock; + } + + _soundMan->update(); + _system->updateScreen(); + _system->delayMillis(5); + +} + +void GnapEngine::saveTimers() { + for (int i = 0; i < kMaxTimers; ++i ) + _savedTimers[i] = _timers[i]; +} + +void GnapEngine::restoreTimers() { + for (int i = 0; i < kMaxTimers; ++i ) + _timers[i] = _savedTimers[i]; +} + +void GnapEngine::pauseGame() { + if (!_isPaused) { + saveTimers(); + hideCursor(); + setGrabCursorSprite(-1); + _pauseSprite = _gameSys->createSurface(0x1076C); + _gameSys->insertSpriteDrawItem(_pauseSprite, (800 - _pauseSprite->w) / 2, (600 - _pauseSprite->h) / 2, 356); + _lastUpdateClock = 0; + gameUpdateTick(); + // TODO playMidi("pause.mid"); + _isPaused = true; + } +} + +void GnapEngine::resumeGame() { + if (_isPaused) { + restoreTimers(); + _gameSys->removeSpriteDrawItem(_pauseSprite, 356); + _lastUpdateClock = 0; + gameUpdateTick(); + deleteSurface(&_pauseSprite); + // TODO stopMidi(); + _isPaused = false; + clearAllKeyStatus1(); + _mouseClickState.left = false; + _mouseClickState.right = false; + showCursor(); + _gameSys->_gameSysClock = 0; + _gameSys->_lastUpdateClock = 0; + } +} + +void GnapEngine::updatePause() { + while (_isPaused) { + gameUpdateTick(); + if (isKeyStatus1(Common::KEYCODE_p)) { + clearKeyStatus1(Common::KEYCODE_p); + resumeGame(); + } + //_system->delayMillis(100); + } +} + +int GnapEngine::getRandom(int max) { + return _random->getRandomNumber(max - 1); +} + +int GnapEngine::readSavegameDescription(int savegameNum, Common::String &description) { + description = Common::String::format("Savegame %d", savegameNum); + return 0; +} + +int GnapEngine::loadSavegame(int savegameNum) { + return 1; +} + +void GnapEngine::delayTicks(int a1) { + // TODO + gameUpdateTick(); +} + +void GnapEngine::delayTicksCursor(int a1) { + // TODO + gameUpdateTick(); +} + +void GnapEngine::setHotspot(int index, int16 x1, int16 y1, int16 x2, int16 y2, uint16 flags, + int16 walkX, int16 walkY) { + _hotspots[index].x1 = x1; + _hotspots[index].y1 = y1; + _hotspots[index].x2 = x2; + _hotspots[index].y2 = y2; + _hotspots[index].flags = flags; + _hotspots[index].id = index; + _hotspotsWalkPos[index].x = walkX; + _hotspotsWalkPos[index].y = walkY; +} + +int GnapEngine::getHotspotIndexAtPos(int16 x, int16 y) { + for (int i = 0; i < _hotspotsCount; ++i) + if (!_hotspots[i].isFlag(SF_DISABLED) && _hotspots[i].isPointInside(x, y)) + return i; + return -1; +} + +void GnapEngine::updateCursorByHotspot() { + if (!_isWaiting) { + int hotspotIndex = getHotspotIndexAtPos(_mouseX, _mouseY); + +#if 1 + // NOTE This causes some display glitches so don't worry + char t[256]; + sprintf(t, "hotspot = %d", hotspotIndex); + _gameSys->fillSurface(0, 10, 10, 80, 16, 0, 0, 0); + _gameSys->drawTextToSurface(0, 10, 10, 255, 255, 255, t); +#endif + + if (hotspotIndex < 0) + setCursor(kDisabledCursors[_verbCursor]); + else if (_hotspots[hotspotIndex].flags & SF_EXIT_L_CURSOR) + setCursor(EXIT_L_CURSOR); + else if (_hotspots[hotspotIndex].flags & SF_EXIT_R_CURSOR) + setCursor(EXIT_R_CURSOR); + else if (_hotspots[hotspotIndex].flags & SF_EXIT_U_CURSOR) + setCursor(EXIT_U_CURSOR); + else if (_hotspots[hotspotIndex].flags & SF_EXIT_D_CURSOR) + setCursor(EXIT_D_CURSOR); + else if (_hotspots[hotspotIndex].flags & SF_EXIT_NE_CURSOR) + setCursor(EXIT_NE_CURSOR); + else if (_hotspots[hotspotIndex].flags & SF_EXIT_NW_CURSOR) + setCursor(EXIT_NW_CURSOR); + else if (_hotspots[hotspotIndex].flags & SF_EXIT_SE_CURSOR) + setCursor(EXIT_SE_CURSOR); + else if (_hotspots[hotspotIndex].flags & SF_EXIT_SW_CURSOR) + setCursor(EXIT_SW_CURSOR); + else if (_hotspots[hotspotIndex].flags & (1 << _verbCursor)) + setCursor(kCursors[_verbCursor]); + else + setCursor(kDisabledCursors[_verbCursor]); + } + // Update platypus hotspot + _hotspots[0].x1 = _gridMinX + 75 * _platX - 30; + _hotspots[0].y1 = _gridMinY + 48 * _platY - 100; + _hotspots[0].x2 = _gridMinX + 75 * _platX + 30; + _hotspots[0].y2 = _gridMinY + 48 * _platY; +} + +int GnapEngine::getClickedHotspotId() { + int result = -1; + if (_isWaiting) + _mouseClickState.left = false; + else if (_mouseClickState.left) { + int hotspotIndex = getHotspotIndexAtPos(_leftClickMouseX, _leftClickMouseY); + if (hotspotIndex >= 0) { + _mouseClickState.left = false; + _timers[3] = 300; + result = _hotspots[hotspotIndex].id; + } + } + return result; +} + +int GnapEngine::getInventoryItemSpriteNum(int index) { + return kCursorSpriteIds[index]; +} + +void GnapEngine::updateMouseCursor() { + if (_mouseClickState.right) { + // Switch through the verb cursors + _mouseClickState.right = false; + _timers[3] = 300; + _verbCursor = (_verbCursor + 1) % 4; + if (!isFlag(0) && _verbCursor == PLAT_CURSOR && _cursorValue == 1) + _verbCursor = (_verbCursor + 1) % 4; + if (!_isWaiting) + setCursor(kDisabledCursors[_verbCursor]); + setGrabCursorSprite(-1); + } + if (_isWaiting && ((_gnapActionStatus < 0 && _beaverActionStatus < 0) || _sceneWaiting)) { + setCursor(kDisabledCursors[_verbCursor]); + _isWaiting = false; + } else if (!_isWaiting && (_gnapActionStatus >= 0 || _beaverActionStatus >= 0) && !_sceneWaiting) { + setCursor(WAIT_CURSOR); + _isWaiting = true; + } +} + +void GnapEngine::setVerbCursor(int verbCursor) { + _verbCursor = verbCursor; + if (!_isWaiting) + setCursor(kDisabledCursors[_verbCursor]); +} + +void GnapEngine::setCursor(int cursorIndex) { + if (_cursorIndex != cursorIndex) { + const char *cursorName = kCursorNames[cursorIndex]; + Graphics::WinCursorGroup *cursorGroup = Graphics::WinCursorGroup::createCursorGroup(*_exe, Common::WinResourceID(cursorName)); + if (cursorGroup) { + Graphics::Cursor *cursor = cursorGroup->cursors[0].cursor; + CursorMan.replaceCursor(cursor->getSurface(), cursor->getWidth(), cursor->getHeight(), + cursor->getHotspotX(), cursor->getHotspotY(), cursor->getKeyColor()); + CursorMan.replaceCursorPalette(cursor->getPalette(), 0, 256); + delete cursorGroup; + } + _cursorIndex = cursorIndex; + } +} + +void GnapEngine::showCursor() { + CursorMan.showMouse(true); +} + +void GnapEngine::hideCursor() { + CursorMan.showMouse(false); +} + +void GnapEngine::setGrabCursorSprite(int index) { + freeGrabCursorSprite(); + if (index >= 0) { + createGrabCursorSprite(makeRid(1, kCursorSpriteIds[index])); + setVerbCursor(GRAB_CURSOR); + } + _grabCursorSpriteIndex = index; +} + +void GnapEngine::createGrabCursorSprite(int spriteId) { + _grabCursorSprite = _gameSys->createSurface(spriteId); + _gameSys->insertSpriteDrawItem(_grabCursorSprite, + _mouseX - (_grabCursorSprite->w / 2), + _mouseY - (_grabCursorSprite->h / 2), + 300); + delayTicks(5); +} + +void GnapEngine::freeGrabCursorSprite() { + if (_grabCursorSprite) { + _gameSys->removeSpriteDrawItem(_grabCursorSprite, 300); + _gameSys->removeSpriteDrawItem(_grabCursorSprite, 301); + delayTicks(5); + deleteSurface(&_grabCursorSprite); + } +} + +void GnapEngine::updateGrabCursorSprite(int x, int y) { + if (_grabCursorSprite) { + int newGrabCursorX = _mouseX - (_grabCursorSprite->w / 2) - x; + int newGrabCursorY = _mouseY - (_grabCursorSprite->h / 2) - y; + if (_currGrabCursorX != newGrabCursorX || _currGrabCursorY != newGrabCursorY) { + _currGrabCursorX = newGrabCursorX; + _currGrabCursorY = newGrabCursorY; + Common::Rect rect(newGrabCursorX, newGrabCursorY, + newGrabCursorX + _grabCursorSprite->w, newGrabCursorY + _grabCursorSprite->h); + _gameSys->invalidateGrabCursorSprite(300, rect, _grabCursorSprite, _grabCursorSprite); + } + } +} + +void GnapEngine::invClear() { + _inventory = 0; +} + +void GnapEngine::invAdd(int itemId) { + _inventory |= (1 << itemId); +} + +void GnapEngine::invRemove(int itemId) { + _inventory &= ~(1 << itemId); +} + +bool GnapEngine::invHas(int itemId) { + return (_inventory & (1 << itemId)) != 0; +} + +void GnapEngine::clearFlags() { + _gameFlags = 0; +} + +void GnapEngine::setFlag(int num) { + _gameFlags |= (1 << num); +} + +void GnapEngine::clearFlag(int num) { + _gameFlags &= ~(1 << num); +} + +bool GnapEngine::isFlag(int num) { + return (_gameFlags & (1 << num)) != 0; +} + +Graphics::Surface *GnapEngine::addFullScreenSprite(int resourceId, int id) { + _fullScreenSpriteId = id; + _fullScreenSprite = _gameSys->createSurface(resourceId); + _gameSys->insertSpriteDrawItem(_fullScreenSprite, 0, 0, id); + return _fullScreenSprite; +} + +void GnapEngine::removeFullScreenSprite() { + _gameSys->removeSpriteDrawItem(_fullScreenSprite, _fullScreenSpriteId); + deleteSurface(&_fullScreenSprite); +} + +void GnapEngine::showFullScreenSprite(int resourceId) { + hideCursor(); + setGrabCursorSprite(-1); + addFullScreenSprite(resourceId, 256); + while (!_mouseClickState.left && !isKeyStatus1(Common::KEYCODE_ESCAPE) && + !isKeyStatus1(Common::KEYCODE_SPACE) && !isKeyStatus1(29)) { + gameUpdateTick(); + } + _mouseClickState.left = false; + clearKeyStatus1(Common::KEYCODE_ESCAPE); + clearKeyStatus1(29); + clearKeyStatus1(Common::KEYCODE_SPACE); + removeFullScreenSprite(); + showCursor(); +} + +void GnapEngine::queueInsertDeviceIcon() { + _gameSys->insertSequence(0x10849, 20, 0, 0, kSeqNone, 0, _deviceX1, _deviceY1); +} + +void GnapEngine::insertDeviceIconActive() { + _gameSys->insertSequence(0x1084A, 21, 0, 0, kSeqNone, 0, _deviceX1, _deviceY1); +} + +void GnapEngine::removeDeviceIconActive() { + _gameSys->removeSequence(0x1084A, 21, 1); +} + +void GnapEngine::setDeviceHotspot(int hotspotIndex, int x1, int y1, int x2, int y2) { + _deviceX1 = x1; + _deviceX2 = x2; + _deviceY1 = y1; + _deviceY2 = y2; + if (x1 == -1) + _deviceX1 = 730; + if (x2 == -1) + _deviceX2 = 780; + if (y1 == -1) + _deviceY1 = 14; + if (y2 == -1) + _deviceY2 = 79; + _hotspots[hotspotIndex].x1 = _deviceX1; + _hotspots[hotspotIndex].y1 = _deviceY1; + _hotspots[hotspotIndex].x2 = _deviceX2; + _hotspots[hotspotIndex].y2 = _deviceY2; + _hotspots[hotspotIndex].flags = SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR; + _hotspots[hotspotIndex].id = hotspotIndex; +} + +int GnapEngine::getSequenceTotalDuration(int resourceId) { + SequenceResource *sequenceResource = _sequenceCache->get(resourceId); + int maxValue = 0; + for (int i = 0; i < sequenceResource->_animationsCount; ++i) { + SequenceAnimation *animation = &sequenceResource->_animations[i]; + if (animation->field_4 + animation->field_A > maxValue) + maxValue = animation->field_4 + animation->field_A; + } + int totalDuration = maxValue + sequenceResource->_totalDuration; + _sequenceCache->release(resourceId); + return totalDuration; +} + +bool GnapEngine::isSoundPlaying(int resourceId) { + return _soundMan->isSoundPlaying(resourceId); +} + +void GnapEngine::playSound(int resourceId, bool looping) { + debug(0, "playSound(%08X, %d)", resourceId, looping); + _soundMan->playSound(resourceId, looping); +} + +void GnapEngine::stopSound(int resourceId) { + _soundMan->stopSound(resourceId); +} + +void GnapEngine::setSoundVolume(int resourceId, int volume) { + _soundMan->setSoundVolume(resourceId, volume); +} + +void GnapEngine::updateTimers() { + for (int i = 0; i < kMaxTimers; ++i) + if (_timers[i] > 0) + --_timers[i]; +} + +void GnapEngine::initGameFlags(int num) { + invClear(); + invAdd(kItemMagazine); + switch (num) { + case 1: + setFlag(26); + break; + case 2: + clearFlags(); + break; + case 3: + invAdd(kItemDiceQuarterHole); + clearFlags(); + break; + case 4: + invAdd(kItemDiceQuarterHole); + invAdd(kItemHorn); + invAdd(kItemLightbulb); + clearFlags(); + setFlag(0); + setFlag(1); + setFlag(2); + setFlag(3); + setFlag(4); + setFlag(5); + setFlag(6); + setFlag(7); + break; + } + + //DEBUG! +// setFlag(0); // Enable platypus + setFlag(25); + invClear(); + invAdd(kItemMagazine); +#if 0 + invAdd(kItemDisguise); +#endif +#if 1 + //invAdd(kItemGas); + invAdd(kItemJoint); + //invAdd(kItemKeys); + invAdd(kItemWrench); + //invAdd(kItemTongs); + invAdd(kItemDiceQuarterHole); + //invAdd(kItemPill); + invAdd(kItemBucketWithBeer); + invAdd(kItemChickenBucket); + invAdd(kItemGum); + invAdd(kItemPicture); +#endif +} + +void GnapEngine::loadStockDat() { + if (!_isStockDatLoaded) { + _isStockDatLoaded = true; + _dat->open(1, "stock_n.dat"); + //createMenuSprite(); + // NOTE Skipped preloading of data + } +} + +void GnapEngine::mainLoop() { + + _newCursorValue = 1; + _cursorValue = -1; + _newSceneNum = 0; + _currentSceneNum = 55; + _prevSceneNum = 55; + invClear(); + clearFlags(); + _grabCursorSpriteIndex = -1; + _grabCursorSprite = 0; + + debug("MainLoop #1"); + + // > DEBUG BEGIN + _currentSceneNum = 53; + _newSceneNum = 27; + _newCursorValue = 3; + // < DEBUG END + + loadStockDat(); + + while (!_gameDone) { + + debug("New scene: %d", _newSceneNum); + + _prevSceneNum = _currentSceneNum; + _currentSceneNum = _newSceneNum; + + debug("GnapEngine::mainLoop() _prevSceneNum: %d; _currentSceneNum: %d", _prevSceneNum, _currentSceneNum); + + if (_newCursorValue != _cursorValue) { + debug("_newCursorValue: %d", _newCursorValue); + _cursorValue = _newCursorValue; + if (!_wasSavegameLoaded) + initGameFlags(_cursorValue); + } + + _sceneSavegameLoaded = _wasSavegameLoaded; + _wasSavegameLoaded = false; + + initScene(); + + runSceneLogic(); + afterScene(); + + _soundMan->stopAll(); + + // Force purge all resources + _sequenceCache->purge(true); + _soundCache->purge(true); + _spriteCache->purge(true); + + if (isKeyStatus1(28)) { + clearKeyStatus1(28); + if (_debugLevel == 4) + _gameDone = true; + } + + } + + if (_backgroundSurface) + deleteSurface(&_backgroundSurface); + + _dat->close(1); + // TODO freeMenuSprite(); + // TODO freeFont(); + + debug("MainLoop #XXX2"); + +} + +void GnapEngine::initScene() { + + Common::String datFilename; + + _isLeavingScene = false; + _sceneDone = false; + _newSceneNum = 55; + _gnapActionStatus = -1; + _beaverActionStatus = -1; + gnapInitBrainPulseRndValue(); + hideCursor(); + clearAllKeyStatus1(); + _mouseClickState.left = false; + _mouseClickState.right = false; + _sceneClickedHotspot = -1; + + datFilename = Common::String::format("%s_n.dat", kSceneNames[_currentSceneNum]); + + debug("GnapEngine::initScene() datFilename: %s", datFilename.c_str()); + + _dat->open(0, datFilename.c_str()); + + int backgroundId = initSceneLogic(); + + if (!_backgroundSurface) { + if (_currentSceneNum != 0) + _backgroundSurface = _gameSys->loadBitmap(makeRid(1, 0x8AA)); + else + _backgroundSurface = _gameSys->loadBitmap(makeRid(0, backgroundId)); + _gameSys->setBackgroundSurface(_backgroundSurface, 0, 500, 1, 1000); + } + + if (_currentSceneNum != 0 && _currentSceneNum != 16 && _currentSceneNum != 47 && + _currentSceneNum != 48 && _currentSceneNum != 54) { + _gameSys->drawBitmap(backgroundId); + } + + if ((_cursorValue == 4 && isFlag(12)) || _currentSceneNum == 41) + playSound(makeRid(1, 0x8F6), true); + +} + +void GnapEngine::endSceneInit() { + showCursor(); + if (_newGrabCursorSpriteIndex >= 0) + setGrabCursorSprite(_newGrabCursorSpriteIndex); +} + +void GnapEngine::afterScene() { + + if (_gameDone) + return; + + if (_newCursorValue == _cursorValue && _newSceneNum != 0 && _newSceneNum != 16 && + _newSceneNum != 47 && _newSceneNum != 48 && _newSceneNum != 54 && _newSceneNum != 49 && + _newSceneNum != 50 && _newSceneNum != 51 && _newSceneNum != 52) + _newGrabCursorSpriteIndex = _grabCursorSpriteIndex; + else + _newGrabCursorSpriteIndex = -1; + + setGrabCursorSprite(-1); + + _gameSys->requestClear2(0); + _gameSys->requestClear1(); + _gameSys->waitForUpdate(); + + _gameSys->requestClear2(0); + _gameSys->requestClear1(); + _gameSys->waitForUpdate(); + + screenEffect(0, 0, 0, 0); + + _dat->close(0); + + for (int animationIndex = 0; animationIndex < 12; ++animationIndex) + _gameSys->setAnimation(0, 0, animationIndex); + + clearKeyStatus1(Common::KEYCODE_p); + + _mouseClickState.left = false; + _mouseClickState.right = false; + +} + +void GnapEngine::checkGameKeys() { + if (isKeyStatus1(Common::KEYCODE_p)) { + clearKeyStatus1(Common::KEYCODE_p); + pauseGame(); + updatePause(); + } + // TODO? Debug input +} + +void GnapEngine::startSoundTimerA(int timerIndex) { + _soundTimerIndexA = timerIndex; + _timers[timerIndex] = getRandom(50) + 100; +} + +int GnapEngine::playSoundA() { + + static const int kSoundIdsA[] = { + 0x93E, 0x93F, 0x941, 0x942, 0x943, 0x944, + 0x945, 0x946, 0x947, 0x948, 0x949 + }; + + int soundId = -1; + + if (!_timers[_soundTimerIndexA]) { + _timers[_soundTimerIndexA] = getRandom(50) + 100; + soundId = kSoundIdsA[getRandom(11)]; + playSound(soundId | 0x10000, 0); + } + return soundId; +} + +void GnapEngine::startSoundTimerB(int timerIndex) { + _soundTimerIndexB = timerIndex; + _timers[timerIndex] = getRandom(50) + 150; +} + +int GnapEngine::playSoundB() { + + static const int kSoundIdsB[] = { + 0x93D, 0x929, 0x92A, 0x92B, 0x92C, 0x92D, + 0x92E, 0x92F, 0x930, 0x931, 0x932, 0x933, + 0x934, 0x935, 0x936, 0x937, 0x938, 0x939, + 0x93A + }; + + int soundId = -1; + + if (!_timers[_soundTimerIndexB]) { + _timers[_soundTimerIndexB] = getRandom(50) + 150; + soundId = kSoundIdsB[getRandom(19)]; + playSound(soundId | 0x10000, 0); + } + return soundId; +} + +void GnapEngine::startSoundTimerC(int timerIndex) { + _soundTimerIndexC = timerIndex; + _timers[timerIndex] = getRandom(50) + 150; +} + +int GnapEngine::playSoundC() { + + static const int kSoundIdsC[] = { + 0x918, 0x91F, 0x920, 0x922, 0x923, 0x924, + 0x926 + }; + + int soundId = -1; + + if (!_timers[_soundTimerIndexC]) { + _timers[_soundTimerIndexC] = getRandom(50) + 150; + soundId = kSoundIdsC[getRandom(7)] ; + playSound(soundId | 0x10000, 0); + } + return soundId; +} + +void GnapEngine::startIdleTimer(int timerIndex) { + _idleTimerIndex = timerIndex; + _timers[timerIndex] = 3000; +} + +void GnapEngine::updateIdleTimer() { + if (!_timers[_idleTimerIndex]) { + _timers[_idleTimerIndex] = 3000; + _gameSys->insertSequence(0x1088B, 255, 0, 0, kSeqNone, 0, 0, 75); + } +} + +void GnapEngine::screenEffect(int dir, byte r, byte g, byte b) { + if (dir == 1) { + for (int y = 300; y < 600; y += 50) { + _gameSys->fillSurface(0, 0, y, 800, 50, r, g, b); + _gameSys->fillSurface(0, 0, 549 - y + 1, 800, 50, r, g, b); + gameUpdateTick(); + _system->delayMillis(50); + } + } else { + for (int y = 0; y < 300; y += 50) { + _gameSys->fillSurface(0, 0, y, 800, 50, r, g, b); + _gameSys->fillSurface(0, 0, 549 - y + 1, 800, 50, r, g, b); + gameUpdateTick(); + _system->delayMillis(50); + } + } +} + +bool GnapEngine::isKeyStatus1(int key) { + return _keyPressState[key] != 0;; +} + +bool GnapEngine::isKeyStatus2(int key) { + return _keyDownState[key] != 0;; +} + +void GnapEngine::clearKeyStatus1(int key) { + _keyPressState[key] = 0; + _keyDownState[key] = 0; +} + +void GnapEngine::clearAllKeyStatus1() { + _keyStatus1[0] = 0; + _keyStatus1[1] = 0; + memset(_keyPressState, 0, sizeof(_keyPressState)); + memset(_keyDownState, 0, sizeof(_keyDownState)); +} + +void GnapEngine::deleteSurface(Graphics::Surface **surface) { + if (surface && *surface) { + (*surface)->free(); + delete *surface; + *surface = 0; + } +} + +int GnapEngine::getGnapSequenceId(int kind, int gridX, int gridY) { + int sequenceId = 0; + + switch (kind) { + + case gskPullOutDevice: + if (gridX > 0 && gridY > 0) { + if (_gnapY > gridY) { + if (_gnapX > gridX) { + sequenceId = 0x83F; + _gnapIdleFacing = 5; + } else { + sequenceId = 0x83D; + _gnapIdleFacing = 7; + } + } else { + if (_gnapX > gridX) { + sequenceId = 0x83B; + _gnapIdleFacing = 3; + } else { + sequenceId = 0x839; + _gnapIdleFacing = 1; + } + } + } else { + switch (_gnapIdleFacing) { + case 1: + sequenceId = 0x839; + break; + case 3: + sequenceId = 0x83B; + break; + case 7: + sequenceId = 0x83D; + break; + default: + sequenceId = 0x83F; + break; + } + } + break; + + case gskPullOutDeviceNonWorking: + if (gridX > 0 && gridY > 0) { + if (_gnapY > gridY) { + if (_gnapX > gridX) { + sequenceId = 0x829; + _gnapIdleFacing = 5; + } else { + sequenceId = 0x828; + _gnapIdleFacing = 7; + } + } else { + if (_gnapX > gridX) { + sequenceId = 0x827; + _gnapIdleFacing = 3; + } else { + sequenceId = 0x826; + _gnapIdleFacing = 1; + } + } + } else { + switch (_gnapIdleFacing) { + case 1: + sequenceId = 0x826; + break; + case 3: + sequenceId = 0x827; + break; + case 7: + sequenceId = 0x828; + break; + default: + sequenceId = 0x829; + break; + } + } + break; + + case gskScratchingHead: + if (gridX > 0 && gridY > 0) { + if (_gnapY > gridY) { + if (_gnapX > gridX) { + sequenceId = 0x834; + _gnapIdleFacing = 3; + } else { + sequenceId = 0x885; + _gnapIdleFacing = 7; + } + } else { + if (_gnapX > gridX) { + sequenceId = 0x834; + _gnapIdleFacing = 3; + } else { + sequenceId = 0x833; + _gnapIdleFacing = 1; + } + } + } else { + switch (_gnapIdleFacing) { + case 1: + sequenceId = 0x833; + _gnapIdleFacing = 1; + break; + case 3: + sequenceId = 0x834; + _gnapIdleFacing = 3; + break; + case 7: + sequenceId = 0x885; + _gnapIdleFacing = 7; + break; + default: + sequenceId = 0x834; + _gnapIdleFacing = 3; + break; + } + } + break; + + case gskIdle: + if (gridX > 0 && gridY > 0) { + if (_gnapY > gridY) { + if (_gnapX > gridX) { + sequenceId = 0x7BC; + _gnapIdleFacing = 5; + } else { + sequenceId = 0x7BB; + _gnapIdleFacing = 7; + } + } else { + if (_gnapX > gridX) { + sequenceId = 0x7BA; + _gnapIdleFacing = 3; + } else { + sequenceId = 0x7B9; + _gnapIdleFacing = 1; + } + } + } else { + switch (_gnapIdleFacing) { + case 1: + sequenceId = 0x7B9; + break; + case 3: + sequenceId = 0x7BA; + break; + case 7: + sequenceId = 0x7BB; + break; + default: + sequenceId = 0x7BC; + break; + } + } + break; + + case gskBrainPulsating: + _gnapBrainPulseNum = (_gnapBrainPulseNum + 1) & 1; + if (gridX > 0 && gridY > 0) { + if (_gnapY > gridY) { + if (_gnapX > gridX) { + sequenceId = _gnapBrainPulseRndValue + _gnapBrainPulseNum + 0x812; + _gnapIdleFacing = 5; + } else { + sequenceId = _gnapBrainPulseRndValue + _gnapBrainPulseNum + 0x7FE; + _gnapIdleFacing = 7; + } + } else { + if (_gnapX > gridX) { + sequenceId = _gnapBrainPulseRndValue + _gnapBrainPulseNum + 0x7D6; + _gnapIdleFacing = 3; + } else { + sequenceId = _gnapBrainPulseRndValue + _gnapBrainPulseNum + 0x7EA; + _gnapIdleFacing = 1; + } + } + } else { + switch (_gnapIdleFacing) { + case 1: + sequenceId = _gnapBrainPulseRndValue + _gnapBrainPulseNum + 0x7EA; + break; + case 3: + sequenceId = _gnapBrainPulseRndValue + _gnapBrainPulseNum + 0x7D6; + break; + case 7: + sequenceId = _gnapBrainPulseRndValue + _gnapBrainPulseNum + 0x7FE; + break; + default: + sequenceId = _gnapBrainPulseRndValue + _gnapBrainPulseNum + 0x812; + break; + } + } + break; + + case gskImpossible: + if (gridX > 0 && gridY > 0) { + if (_gnapY > gridY) { + if (_gnapX > gridX) { + sequenceId = 0x831; + _gnapIdleFacing = 3; + } else { + sequenceId = 0x7A8; + _gnapIdleFacing = 1; + } + } else { + if (_gnapX > gridX) { + sequenceId = 0x831; + _gnapIdleFacing = 3; + } else { + if (_gnapX % 2) + sequenceId = 0x7A8; + else + sequenceId = 0x89A; + _gnapIdleFacing = 1; + } + } + } else if (_gnapIdleFacing != 1 && _gnapIdleFacing != 7) { + sequenceId = 0x831; + _gnapIdleFacing = 3; + } else { + if (_currentSceneNum % 2) + sequenceId = 0x7A8; + else + sequenceId = 0x89A; + _gnapIdleFacing = 1; + } + break; + + case gskDeflect: + if (gridX > 0 && gridY > 0) { + if (_gnapY > gridY) { + if (_gnapX > gridX) { + sequenceId = 0x830; + _gnapIdleFacing = 5; + } else { + sequenceId = 0x82F; + _gnapIdleFacing = 7; + } + } else { + if (_gnapX > gridX) { + sequenceId = 0x82E; + _gnapIdleFacing = 3; + } else { + sequenceId = 0x7A7; + _gnapIdleFacing = 1; + } + } + } else { + switch (_gnapIdleFacing) { + case 1: + sequenceId = 0x7A7; + break; + case 3: + sequenceId = 0x82E; + break; + case 5: + sequenceId = 0x830; + break; + case 7: + sequenceId = 0x82F; + break; + } + } + break; + + case gskUseDevice: + switch (_gnapIdleFacing) { + case 1: + sequenceId = 0x83A; + break; + case 3: + sequenceId = 0x83C; + break; + case 5: + sequenceId = 0x840; + break; + case 7: + sequenceId = 0x83E; + break; + } + break; + + case gskMoan1: + if (gridX > 0 && gridY > 0) { + if (_gnapY > gridY) { + if (_gnapX > gridX) { + sequenceId = 0x832; + _gnapIdleFacing = 3; + } else { + sequenceId = 0x7AA; + _gnapIdleFacing = 1; + } + } else { + if (_gnapX > gridX) { + sequenceId = 0x832; + _gnapIdleFacing = 3; + } else { + sequenceId = 0x7AA; + _gnapIdleFacing = 1; + } + } + } else if (_gnapIdleFacing != 1 && _gnapIdleFacing != 7) { + sequenceId = 0x832; + _gnapIdleFacing = 3; + } else { + sequenceId = 0x7AA; + _gnapIdleFacing = 1; + } + break; + + case gskMoan2: + if (gridX > 0 && gridY > 0) { + if (_gnapY > gridY) { + if (_gnapX > gridX) { + sequenceId = 0x832; + _gnapIdleFacing = 3; + } else { + sequenceId = 0x7AA; + _gnapIdleFacing = 1; + } + } else { + if (_gnapX > gridX) { + sequenceId = 0x832; + _gnapIdleFacing = 3; + } else { + sequenceId = 0x7AA; + _gnapIdleFacing = 1; + } + } + } else if (_gnapIdleFacing != 1 && _gnapIdleFacing != 7) { + sequenceId = 0x832; + _gnapIdleFacing = 3; + } else { + sequenceId = 0x7AA; + _gnapIdleFacing = 1; + } + break; + + } + + return sequenceId | 0x10000; +} + +int GnapEngine::getGnapShowSequenceId(int index, int gridX, int gridY) { + + int sequenceId; + int facing = _gnapIdleFacing; + + if (gridY > 0 && gridX > 0) { + if (_gnapY > gridY) { + if (_gnapX > gridX) + _gnapIdleFacing = 5; + else + _gnapIdleFacing = 7; + } else { + if (_gnapX > gridX) + _gnapIdleFacing = 5; + else + _gnapIdleFacing = 7; + } + } else if (_gnapIdleFacing != 1 && _gnapIdleFacing != 7) { + _gnapIdleFacing = 5; + } else { + _gnapIdleFacing = 7; + } + + switch (index) { + case 0: + if (_gnapIdleFacing == 7) + sequenceId = 0x8A0; + else + sequenceId = 0x8A1; + break; + case 1: + if (_gnapIdleFacing == 7) + sequenceId = 0x880; + else + sequenceId = 0x895; + break; + case 2: + if (_gnapIdleFacing == 7) + sequenceId = 0x884; + else + sequenceId = 0x899; + break; + //Skip 3 + case 4: + if (_gnapIdleFacing == 7) + sequenceId = 0x881; + else + sequenceId = 0x896; + break; + case 5: + if (_gnapIdleFacing == 7) + sequenceId = 0x883; + else + sequenceId = 0x898; + break; + case 6: + if (_gnapIdleFacing == 7) + sequenceId = 0x87E; + else + sequenceId = 0x893; + break; + case 7: + if (_gnapIdleFacing == 7) + sequenceId = 0x848; + else + sequenceId = 0x890; + break; + case 8: + if (_gnapIdleFacing == 7) + sequenceId = 0x87D; + else + sequenceId = 0x892; + break; + case 9: + if (_gnapIdleFacing == 7) + sequenceId = 0x882; + else + sequenceId = 0x897; + break; + case 10: + if (_gnapIdleFacing == 7) + sequenceId = 0x87C; + else + sequenceId = 0x891; + break; + case 11: + if (_gnapIdleFacing == 7) + sequenceId = 0x87C; + else + sequenceId = 0x891; + break; + case 12: + if (_gnapIdleFacing == 7) + sequenceId = 0x87D; + else + sequenceId = 0x892; + break; + case 13: + if (_gnapIdleFacing == 7) + sequenceId = 0x888; + else + sequenceId = 0x89D; + break; + case 14: + if (_gnapIdleFacing == 7) + sequenceId = 0x87F; + else + sequenceId = 0x894; + break; + case 15: + if (_gnapIdleFacing == 7) + sequenceId = 0x87B; + else + sequenceId = 0x8A3; + break; + case 16: + if (_gnapIdleFacing == 7) + sequenceId = 0x877; + else + sequenceId = 0x88C; + break; + //Skip 17 + case 18: + sequenceId = 0x887; + break; + case 19: + if (_gnapIdleFacing == 7) + sequenceId = 0x87A; + else + sequenceId = 0x88F; + break; + case 20: + if (_gnapIdleFacing == 7) + sequenceId = 0x878; + else + sequenceId = 0x88D; + break; + case 21: + if (_gnapIdleFacing == 7) + sequenceId = 0x879; + else + sequenceId = 0x88E; + break; + case 22: + if (_gnapIdleFacing == 7) + sequenceId = 0x88A; + else + sequenceId = 0x89F; + break; + case 23: + if (_gnapIdleFacing == 7) + sequenceId = 0x889; + else + sequenceId = 0x89E; + break; + case 24: + if (_gnapIdleFacing == 7) + sequenceId = 0x886; + else + sequenceId = 0x89B; + break; + case 25: + if (_gnapIdleFacing == 7) + sequenceId = 0x87A; + else + sequenceId = 0x88F; + break; + //Skip 26 + //Skip 27 + //Skip 28 + //Skip 29 + default: + _gnapIdleFacing = facing; + sequenceId = getGnapSequenceId(gskImpossible, 0, 0); + break; + } + return sequenceId; +} + +void GnapEngine::gnapIdle() { + if (_gnapSequenceId != -1 && _gnapSequenceDatNum == 1 && + (_gnapSequenceId == 0x7A6 || _gnapSequenceId == 0x7AA || + _gnapSequenceId == 0x832 || _gnapSequenceId == 0x841 || + _gnapSequenceId == 0x842 || _gnapSequenceId == 0x8A2 || + _gnapSequenceId == 0x833 || _gnapSequenceId == 0x834 || + _gnapSequenceId == 0x885 || _gnapSequenceId == 0x7A8 || + _gnapSequenceId == 0x831 || _gnapSequenceId == 0x89A)) { + _gameSys->insertSequence(getGnapSequenceId(gskIdle, 0, 0) | 0x10000, _gnapId, + makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, + 32, 0, 75 * _gnapX - _gnapGridX, 48 * _gnapY - _gnapGridY); + _gnapSequenceId = getGnapSequenceId(gskIdle, 0, 0); + _gnapSequenceDatNum = 1; + } +} + +void GnapEngine::gnapActionIdle(int sequenceId) { + if (_gnapSequenceId != -1 && ridToDatIndex(sequenceId) == _gnapSequenceDatNum && + ridToEntryIndex(sequenceId) == _gnapSequenceId) { + _gameSys->insertSequence(getGnapSequenceId(gskIdle, 0, 0) | 0x10000, _gnapId, + makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, + 32, 0, 75 * _gnapX - _gnapGridX, 48 * _gnapY - _gnapGridY); + _gnapSequenceId = getGnapSequenceId(gskIdle, 0, 0); + _gnapSequenceDatNum = 1; + } +} + +void GnapEngine::playGnapSequence(int sequenceId) { + _timers[2] = getRandom(30) + 20; + _timers[3] = 300; + gnapIdle(); + _gameSys->insertSequence(sequenceId, _gnapId, + makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, + 9, 0, 75 * _gnapX - _gnapGridX, 48 * _gnapY - _gnapGridY); + _gnapSequenceId = ridToEntryIndex(sequenceId); + _gnapSequenceDatNum = ridToDatIndex(sequenceId); +} + +void GnapEngine::playGnapImpossible(int gridX, int gridY) { + playGnapSequence(getGnapSequenceId(gskImpossible, gridX, gridY) | 0x10000); +} + +void GnapEngine::playGnapScratchingHead(int gridX, int gridY) { + playGnapSequence(getGnapSequenceId(gskScratchingHead, gridX, gridY) | 0x10000); +} + +void GnapEngine::playGnapMoan1(int gridX, int gridY) { + playGnapSequence(getGnapSequenceId(gskMoan1, gridX, gridY) | 0x10000); +} + +void GnapEngine::playGnapMoan2(int gridX, int gridY) { + playGnapSequence(getGnapSequenceId(gskMoan2, gridX, gridY) | 0x10000); +} + +void GnapEngine::playGnapBrainPulsating(int gridX, int gridY) { + playGnapSequence(getGnapSequenceId(gskBrainPulsating, gridX, gridY) | 0x10000); +} + +void GnapEngine::playGnapPullOutDevice(int gridX, int gridY) { + playGnapSequence(getGnapSequenceId(gskPullOutDevice, gridX, gridY) | 0x10000); +} + +void GnapEngine::playGnapPullOutDeviceNonWorking(int gridX, int gridY) { + playGnapSequence(getGnapSequenceId(gskPullOutDeviceNonWorking, gridX, gridY) | 0x10000); +} + +void GnapEngine::playGnapUseDevice(int gridX, int gridY) { + playGnapSequence(getGnapSequenceId(gskUseDevice, gridX, gridY) | 0x10000); +} + +void GnapEngine::playGnapIdle(int gridX, int gridY) { + playGnapSequence(getGnapSequenceId(gskIdle, gridX, gridY) | 0x10000); +} + +void GnapEngine::playGnapShowItem(int itemIndex, int gridLookX, int gridLookY) { + playGnapSequence(getGnapShowSequenceId(itemIndex, gridLookX, gridLookY) | 0x10000); +} + +void GnapEngine::playGnapShowCurrItem(int gridX, int gridY, int gridLookX, int gridLookY) { + if (_platX == gridX && _platY == gridY) + beaverMakeRoom(); + gnapWalkTo(gridX, gridY, -1, -1, 1); + playGnapShowItem(_grabCursorSpriteIndex, gridLookX, gridLookY); +} + +void GnapEngine::updateGnapIdleSequence() { + if (_gnapActionStatus < 0) { + if (_timers[2] > 0) { + if (_timers[3] == 0) { + _timers[2] = 60; + _timers[3] = 300; + _gnapRandomValue = getRandom(5); + if (_gnapIdleFacing == 1) { + switch (_gnapRandomValue) { + case 0: + playGnapSequence(0x107A6); + break; + case 1: + playGnapSequence(0x107AA); + break; + case 2: + playGnapSequence(0x10841); + break; + default: + playGnapSequence(0x108A2); + break; + } + } else if (_gnapIdleFacing == 3) { + if (_gnapRandomValue > 2) + playGnapSequence(0x10832); + else + playGnapSequence(0x10842); + } + } + } else { + _timers[2] = getRandom(30) + 20; + if (_gnapIdleFacing == 1) { + _gameSys->insertSequence(0x107BD, _gnapId, + makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, + 8, 0, 75 * _gnapX - _gnapGridX, 48 * _gnapY - _gnapGridY); + _gnapSequenceId = 0x7BD; + _gnapSequenceDatNum = 1; + } else if (_gnapIdleFacing == 3) { + _gameSys->insertSequence(0x107BE, _gnapId, + makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, + 8, 0, 75 * _gnapX - _gnapGridX, 48 * _gnapY - _gnapGridY); + _gnapSequenceId = 0x7BE; + _gnapSequenceDatNum = 1; + } + } + } else { + _timers[2] = getRandom(30) + 20; + _timers[3] = 300; + } +} + +void GnapEngine::updateGnapIdleSequence2() { + if (_gnapActionStatus < 0) { + if (_timers[2] > 0) { + if (_timers[3] == 0) { + _timers[2] = 60; + _timers[3] = 300; + if (_gnapIdleFacing == 1) { + playGnapSequence(0x107AA); + } else if (_gnapIdleFacing == 3) { + playGnapSequence(0x10832); + } + } + } else { + _timers[2] = getRandom(30) + 20; + if (_gnapIdleFacing == 1) { + _gameSys->insertSequence(0x107BD, _gnapId, + makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, + 8, 0, 75 * _gnapX - _gnapGridX, 48 * _gnapY - _gnapGridY); + _gnapSequenceId = 0x7BD; + _gnapSequenceDatNum = 1; + } else if (_gnapIdleFacing == 3) { + _gameSys->insertSequence(0x107BE, _gnapId, + makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, + 8, 0, 75 * _gnapX - _gnapGridX, 48 * _gnapY - _gnapGridY); + _gnapSequenceId = 0x7BE; + _gnapSequenceDatNum = 1; + } + } + } else { + _timers[2] = getRandom(30) + 20; + _timers[3] = 300; + } +} + +bool GnapEngine::testWalk(int animationIndex, int someStatus, int gridX1, int gridY1, int gridX2, int gridY2) { + if (_mouseClickState.left && someStatus == _gnapActionStatus) { + _isLeavingScene = false; + _gameSys->setAnimation(0, 0, animationIndex); + _gnapActionStatus = -1; + _beaverActionStatus = -1; + gnapWalkTo(gridX1, gridY1, -1, -1, 1); + platypusWalkTo(gridX2, gridY2, -1, -1, 1); + _mouseClickState.left = false; + return true; + } + return false; +} + +void GnapEngine::initGnapPos(int gridX, int gridY, int facing) { + _timers[2] = 30; + _timers[3] = 300; + _gnapX = gridX; + _gnapY = gridY; + if (facing <= 0) + _gnapIdleFacing = 1; + else + _gnapIdleFacing = facing; + if (_gnapIdleFacing == 3) { + _gnapSequenceId = 0x7B8; + } else { + _gnapSequenceId = 0x7B5; + _gnapIdleFacing = 1; + } + _gnapId = 20 * _gnapY; + _gnapSequenceDatNum = 1; + _gameSys->insertSequence(makeRid(1, _gnapSequenceId), 20 * _gnapY, + 0, 0, + 1, 0, 75 * _gnapX - _gnapGridX, 48 * _gnapY - _gnapGridY); +} + +void GnapEngine::gnapInitBrainPulseRndValue() { + _gnapBrainPulseRndValue = 2 * getRandom(10); +} + +void GnapEngine::gnapUseDeviceOnBeaver() { + + playGnapSequence(makeRid(1, getGnapSequenceId(gskPullOutDevice, _platX, _platY))); + + if (_beaverFacing != 0) { + _gameSys->insertSequence(makeRid(1, 0x7D5), _beaverId, + makeRid(_beaverSequenceDatNum, _beaverSequenceId), _beaverId, + 8, 0, 75 * _platX - _platGridX, 48 * _platY - _platGridY); + _beaverSequenceId = 0x7D5; + _beaverSequenceDatNum = 1; + } else { + _gameSys->insertSequence(makeRid(1, 0x7D4), _beaverId, + makeRid(_beaverSequenceDatNum, _beaverSequenceId), _beaverId, + 8, 0, 75 * _platX - _platGridX, 48 * _platY - _platGridY); + _beaverSequenceId = 0x7D4; + _beaverSequenceDatNum = 1; + } + + int newSequenceId = getGnapSequenceId(gskUseDevice, 0, 0); + _gameSys->insertSequence(makeRid(1, newSequenceId), _gnapId, + makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, + 8, 0, 75 * _gnapX - _gnapGridX, 48 * _gnapY - _gnapGridY); + _gnapSequenceId = newSequenceId; + _gnapSequenceDatNum = 1; + +} + +void GnapEngine::doCallback(int callback) { + switch (callback) { + case 8: + scene08_updateAnimationsCb(); + break; + case 10: + scene10_updateAnimationsCb(); + break; + case 20: + scene20_updateAnimationsCb(); + break; + } +} + +bool GnapEngine::gnapPlatypusAction(int gridX, int gridY, int platSequenceId, int callback) { + bool result = false; + + if (_gnapActionStatus <= -1 && _beaverActionStatus <= -1) { + _gnapActionStatus = 100; + if (isPointBlocked(_platX + gridX, _platY + gridY) && (_platX + gridX != _gnapX || _platY + gridY != _gnapY)) + platypusWalkStep(); + if (!isPointBlocked(_platX + gridX, _platY + gridY) && (_platX + gridX != _gnapX || _platY + gridY != _gnapY)) { + gnapWalkTo(_platX + gridX, _platY + gridY, 0, 0x107B9, 1); + while (_gameSys->getAnimationStatus(0) != 2) { + updateMouseCursor(); + doCallback(callback); + gameUpdateTick(); + } + _gameSys->setAnimation(0, 0, 0); + if (_platX + gridX == _gnapX && _platY + gridY == _gnapY) { + _gameSys->setAnimation(platSequenceId, _beaverId, 1); + playBeaverSequence(platSequenceId); + while (_gameSys->getAnimationStatus(1) != 2) { + updateMouseCursor(); + doCallback(callback); + gameUpdateTick(); + } + result = true; + } + } + _gnapActionStatus = -1; + } + return result; +} + +void GnapEngine::gnapKissPlatypus(int callback) { + if (gnapPlatypusAction(-1, 0, 0x107D1, callback)) { + _gnapActionStatus = 100; + _gameSys->setAnimation(0, 0, 1); + _gameSys->setAnimation(0x10847, _gnapId, 0); + _gameSys->insertSequence(0x10847, _gnapId, + makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, + 8, 0, 15 * (5 * _gnapX - 20) - (21 - _gridMinX), 48 * (_gnapY - 6) - (146 - _gridMinY)); + _gnapSequenceDatNum = 1; + _gnapSequenceId = 0x847; + _gameSys->insertSequence(0x107CB, _beaverId, + makeRid(_beaverSequenceDatNum, _beaverSequenceId), _beaverId, + 8, getSequenceTotalDuration(0x10847), 75 * _platX - _platGridX, 48 * _platY - _platGridY); + _beaverSequenceDatNum = 1; + _beaverSequenceId = 0x7CB; + _beaverFacing = 0; + playGnapSequence(0x107B5); + while (_gameSys->getAnimationStatus(0) != 2) { + updateMouseCursor(); + doCallback(callback); + gameUpdateTick(); + } + _gameSys->setAnimation(0, 0, 0); + _gnapActionStatus = -1; + } else { + playGnapSequence(getGnapSequenceId(gskScratchingHead, _platX, _platY) | 0x10000); + } +} + +void GnapEngine::gnapUseJointOnPlatypus() { + setGrabCursorSprite(-1); + if (gnapPlatypusAction(1, 0, 0x107C1, 0)) { + _gnapActionStatus = 100; + _gameSys->setAnimation(0, 0, 1); + _gameSys->setAnimation(0x10876, _beaverId, 0); + _gameSys->insertSequence(0x10875, _gnapId, + makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, + 8, 0, 15 * (5 * _gnapX - 30), 48 * (_gnapY - 7)); + _gnapSequenceDatNum = 1; + _gnapSequenceId = 0x875; + _gameSys->insertSequence(0x10876, _beaverId, + _beaverSequenceId | (_beaverSequenceDatNum << 16), _beaverId, + 8, 0, 15 * (5 * _platX - 25), 48 * (_platY - 7)); + _beaverSequenceDatNum = 1; + _beaverSequenceId = 0x876; + _beaverFacing = 0; + playGnapSequence(0x107B5); + gnapWalkStep(); + while (_gameSys->getAnimationStatus(0) != 2) { + updateMouseCursor(); + gameUpdateTick(); + } + _gameSys->setAnimation(0, 0, 0); + _gnapActionStatus = -1; + } else { + playGnapSequence(getGnapSequenceId(gskScratchingHead, _platX, _platY) | 0x10000); + } +} + +void GnapEngine::gnapUseDisguiseOnPlatypus() { + _gameSys->setAnimation(0x10846, _gnapId, 0); + playGnapSequence(0x10846); + while (_gameSys->getAnimationStatus(0) != 2) + gameUpdateTick(); + _newSceneNum = 47; + _isLeavingScene = true; + _sceneDone = true; + setFlag(10); +} + +int GnapEngine::getBeaverSequenceId(int kind, int gridX, int gridY) { + int sequenceId; + + // TODO kind is always 0, remove that parameter + if (kind != 0) + return 0; + + if (gridX > 0 && gridY > 0) { + if (gridX < _platX) { + sequenceId = 0x7CC; + _beaverFacing = 4; + } else { + sequenceId = 0x7CB; + _beaverFacing = 0; + } + } else if (_beaverFacing != 0) { + sequenceId = 0x7CC; + _beaverFacing = 4; + } else { + sequenceId = 0x7CB; + _beaverFacing = 0; + } + return sequenceId | 0x10000; +} + +void GnapEngine::playBeaverSequence(int sequenceId) { + _gameSys->insertSequence(sequenceId, _beaverId, + makeRid(_beaverSequenceDatNum, _beaverSequenceId), _beaverId, + 9, 0, 75 * _platX - _platGridX, 48 * _platY - _platGridY); + _beaverSequenceId = ridToEntryIndex(sequenceId); + _beaverSequenceDatNum = ridToDatIndex(sequenceId); +} + +void GnapEngine::updateBeaverIdleSequence() { + if (_beaverActionStatus < 0 && _gnapActionStatus < 0) { + if (_timers[0] > 0) { + if (_timers[1] == 0) { + _timers[1] = getRandom(20) + 30; + _gnapRandomValue = getRandom(10); + if (_beaverFacing != 0) { + if (_gnapRandomValue != 0 || _beaverSequenceId != 0x7CA) { + if (_gnapRandomValue != 1 || _beaverSequenceId != 0x7CA) + playBeaverSequence(0x107CA); + else + playBeaverSequence(0x10845); + } else { + playBeaverSequence(0x107CC); + } + } else if (_gnapRandomValue != 0 || _beaverSequenceId != 0x7C9) { + if (_gnapRandomValue != 1 || _beaverSequenceId != 0x7C9) { + if (_gnapRandomValue != 2 || _beaverSequenceId != 0x7C9) + playBeaverSequence(0x107C9); + else + playBeaverSequence(0x108A4); + } else { + playBeaverSequence(0x10844); + } + } else { + playBeaverSequence(0x107CB); + } + } + } else { + _timers[0] = getRandom(75) + 75; + beaverMakeRoom(); + } + } else { + _timers[0] = 100; + _timers[1] = 35; + } +} + +void GnapEngine::beaverSub426234() { + if (_beaverActionStatus < 0 && _gnapActionStatus < 0) { + if (_timers[0]) { + if (!_timers[1]) { + _timers[1] = getRandom(20) + 30; + _gnapRandomValue = getRandom(10); + if (_beaverFacing != 0) { + if (_gnapRandomValue >= 2 || _beaverSequenceId != 0x7CA) + playBeaverSequence(0x107CA); + else + playBeaverSequence(0x107CC); + } else { + if (_gnapRandomValue >= 2 || _beaverSequenceId != 0x7C9) { + playBeaverSequence(0x107C9); + } else { + playBeaverSequence(0x107CB); + } + } + } + } else { + _timers[0] = getRandom(75) + 75; + beaverMakeRoom(); + } + } else { + _timers[0] = 100; + _timers[1] = 35; + } +} + +void GnapEngine::initBeaverPos(int gridX, int gridY, int facing) { + _timers[0] = 50; + _timers[1] = 20; + _platX = gridX; + _platY = gridY; + if (facing <= 0) + _beaverFacing = 0; + else + _beaverFacing = facing; + if (_beaverFacing == 4) { + _beaverSequenceId = 0x7D1; + } else { + _beaverSequenceId = 0x7C1; + _beaverFacing = 0; + } + _beaverId = 20 * _platY; + _beaverSequenceDatNum = 1; + _gameSys->insertSequence(makeRid(1, _beaverSequenceId), 20 * _platY, + 0, 0, + 1, 0, 75 * _platX - _platGridX, 48 * _platY - _platGridY); +} + +//////////////////////////////////////////////////////////////////////////////// + +void GnapEngine::initGlobalSceneVars() { + + // Scene 1 + _s01_pigsIdCtr = 0; + _s01_smokeIdCtr = 0; + _s01_spaceshipSurface = 0; + + // Scene 2 + _s02_truckGrillCtr = 0; + + // Scene 3 + _s03_nextPlatSequenceId = -1; + _s03_platypusScared = false; + _s03_platypusHypnotized = false; + + // Scene 4 + _s04_dogIdCtr = 0; + //_s04_triedWindow = true;//?? + _s04_triedWindow = false; + + // Scene 5 + _s05_nextChickenSequenceId = -1; + + // Scene 6 + _s06_nextPlatSequenceId = -1; + + // Scene 11 + _s11_billardBallCtr = 0; + + // Scene 13 + _s13_backToiletCtr = -1; + + // Scene 17 + _s17_platTryGetWrenchCtr = 0; + _s17_wrenchCtr = 2; + _s17_nextCarWindowSequenceId = -1; + _s17_nextWrenchSequenceId = -1; + _s17_canTryGetWrench = true; + _s17_platPhoneCtr = 0; + _s17_nextPhoneSequenceId = -1; + _s17_currPhoneSequenceId = -1; + + // Scene 18 + _s18_garbageCanPos = 8; + _s18_platPhoneCtr = 0; + _s18_platPhoneIter = 0; + _s18_nextPhoneSequenceId = -1; + _s18_currPhoneSequenceId = -1; + + // Scene 19 + _s19_toyGrabCtr = 0; + _s19_pictureSurface = 0; + _s19_shopAssistantCtr = 0; + + // Scene 20 + _s20_stonerGuyCtr = 3; + _s20_stonerGuyShowingJoint = false; + _s20_groceryStoreGuyCtr = 0; + + // Scene 22 + _s22_caughtBefore = false; + _s22_cashierCtr = 3; + + // Scene 50 + _s50_timesPlayed = 0; + _s50_timesPlayedModifier = 0; + _s50_attackCounter = 0; + _s50_leftTongueEnergyBarPos = 10; + _s50_leftTongueNextIdCtr = 0; + _s50_rightTongueEnergyBarPos = 10; + _s50_rightTongueNextIdCtr = 0; + + // Scene 52 + _s52_gameScore = 0; + _s52_aliensInitialized = false; + _s52_alienDirection = 0; + _s52_soundToggle = false; + + // Scene 53 + _s53_callsMadeCtr = 0; + _s53_callsRndUsed = 0; + + // Toy UFO + _toyUfoId = 0; + _toyUfoActionStatus = -1; + _toyUfoX = 0; + _toyUfoY = 50; + +} + +bool GnapEngine::sceneXX_sub_4466B1() { + + if (isKeyStatus1(Common::KEYCODE_ESCAPE)) { + clearKeyStatus1(Common::KEYCODE_ESCAPE); + clearKeyStatus1(Common::KEYCODE_UP); + clearKeyStatus1(Common::KEYCODE_RIGHT); + clearKeyStatus1(Common::KEYCODE_LEFT); + clearKeyStatus1(Common::KEYCODE_p); + return true; + } + + if (isKeyStatus1(Common::KEYCODE_p)) { + clearKeyStatus1(Common::KEYCODE_p); + pauseGame(); + updatePause(); + } + return false; + +} + +void GnapEngine::sceneXX_playRandomSound(int timerIndex) { + if (!_timers[timerIndex]) { + _timers[timerIndex] = getRandom(40) + 50; + _gnapRandomValue = getRandom(4); + switch (_gnapRandomValue) { + case 0: + playSound(0x1091B, 0); + break; + case 1: + playSound(0x10921, 0); + break; + case 2: + playSound(0x10927, 0); + break; + case 3: + playSound(0x1091D, 0); + break; + } + } +} + +void GnapEngine::playSequences(int fullScreenSpriteId, int sequenceId1, int sequenceId2, int sequenceId3) { + setGrabCursorSprite(-1); + _gameSys->setAnimation(sequenceId2, _gnapId, 0); + _gameSys->insertSequence(sequenceId2, _gnapId, + makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, + 8, 0, 15 * (5 * _gnapX - 25), 48 * (_gnapY - 8)); + _gnapSequenceId = sequenceId2; + _gnapSequenceDatNum = 0; + while (_gameSys->getAnimationStatus(0) != 2) + gameUpdateTick(); + hideCursor(); + addFullScreenSprite(fullScreenSpriteId, 255); + _gameSys->setAnimation(sequenceId1, 256, 0); + _gameSys->insertSequence(sequenceId1, 256, 0, 0, kSeqNone, 0, 0, 0); + while (_gameSys->getAnimationStatus(0) != 2) + gameUpdateTick(); + _gameSys->setAnimation(sequenceId3, _gnapId, 0); + _gameSys->insertSequence(sequenceId3, _gnapId, + makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, + 8, 0, 15 * (5 * _gnapX - 25), 48 * (_gnapY - 8)); + removeFullScreenSprite(); + showCursor(); + _gnapSequenceId = sequenceId3; +} + +// Scene 0 + +int GnapEngine::scene00_init() { + return 0x37C; +} + +void GnapEngine::toyUfoSetStatus(int a1) { + clearFlag(16); + clearFlag(17); + clearFlag(18); + clearFlag(19); + setFlag(a1); +} + +int GnapEngine::toyUfoGetSequenceId() { + if (isFlag(16)) + return 0x84E; + if (isFlag(17)) + return 0x84B; + if (isFlag(18)) + return 0x84D; + if (isFlag(19)) + return 0x84C; + return 0x84E; +} + +bool GnapEngine::toyUfoCheckTimer() { + if (!isFlag(12) || isFlag(18) || _timers[9] || + _toyUfoSequenceId == 0x870 || _toyUfoSequenceId == 0x871 || _toyUfoSequenceId == 0x872 || _toyUfoSequenceId == 0x873) + return false; + _sceneDone = true; + _newSceneNum = 41; + return true; +} + +void GnapEngine::toyUfoFlyTo(int destX, int destY, int a3, int a4, int a5, int a6, int animationIndex) { + int v21 = 0; + int v14 = 0; + int v17 = 36; + int v15 = 32; + int i = 0; + GridStruct v16[34]; + + if (destX == -1) + destX = _leftClickMouseX; + + if (destY == -1) + destY = _leftClickMouseY; + + //CHECKME + + int v25 = CLIP(destX, a3, a4); + int v26 = CLIP(destY, a5, a6); + int v24, v23; + int v13, v20; + + if (v25 == _toyUfoX) + v24 = 0; + else + v24 = (v25 - _toyUfoX) / ABS(v25 - _toyUfoX); + + if (v26 == _toyUfoY) + v23 = 0; + else + v23 = (v26 - _toyUfoY) / ABS(v26 - _toyUfoY); + + v13 = ABS(v25 - _toyUfoX); + v20 = ABS(v26 - _toyUfoY); + + if (v20 > v13) { + int v22 = v20 / v15; + while (v14 < v20 && i < 34) { + if (v22 - 5 >= i) { + v15 = MIN(36, 8 * i + 8); + } else { + v15 = MAX(6, v15 - 3); + } + v14 += v15; + v16[i].gridX1 = _toyUfoX + v24 * v13 * v14 / v20; + v16[i].gridY1 = _toyUfoY + v23 * v14; + ++i; + } + } else { + int v22 = v13 / v17; + while (v14 < v13 && i < 34) { + if (v22 - 5 >= i) { + v17 = MIN(38, 8 * i + 8); + } else { + v17 = MAX(6, v17 - 3); + } + v14 += v17; + v16[i].gridX1 = _toyUfoX + v24 * v14; + v16[i].gridY1 = _toyUfoY + v23 * v20 * v14 / v13; + ++i; + } + } + + v21 = i - 1; + + _toyUfoX = v25; + _toyUfoY = v26; + + debug("v21: %d", v21); + + if (i - 1 > 0) { + int v18; + if (isFlag(16)) + v18 = 0x867; + else if (isFlag(17)) + v18 = 0x84F; + else if (isFlag(18)) + v18 = 0x85F; + else if (isFlag(19)) + v18 = 0x857; + v16[0].sequenceId = v18; + v16[0].id = 0; + _gameSys->insertSequence(v18 | 0x10000, 0, + _toyUfoSequenceId | 0x10000, _toyUfoId, + 8, 0, v16[0].gridX1 - 365, v16[0].gridY1 - 128); + for (i = 1; i < v21; ++i) { + v16[i].sequenceId = v18 + (i % 8); + v16[i].id = i; + _gameSys->insertSequence(v16[i].sequenceId | 0x10000, v16[i].id, + v16[i - 1].sequenceId | 0x10000, v16[i - 1].id, + 8, 0, + v16[i].gridX1 - 365, v16[i].gridY1 - 128); + } + + _toyUfoSequenceId = v16[v21 - 1].sequenceId; + _toyUfoId = v16[v21 - 1].id; + + if (animationIndex >= 0) + _gameSys->setAnimation(_toyUfoSequenceId | 0x10000, _toyUfoId, animationIndex); + + } + +} + +// Scene 99 + +int GnapEngine::cutscene_init() { + return -1; +} + +void GnapEngine::cutscene_run() { + + int itemIndex = 0; + int soundId = -1; + int volume = 100; + int duration = 0; + bool skip = false; + + int v1 = 0; + + if (_prevSceneNum == 2) { + soundId = 0x36B; + duration = MAX(1, 300 / getSequenceTotalDuration(_s99_dword_47F370[_s99_itemsCount - 1]));//CHECKME + _timers[0] = 0; + } + + if (soundId != -1) + playSound(soundId, 0); + + hideCursor(); + + _gameSys->drawSpriteToBackground(0, 0, _s99_dword_47F2F0[0]); + + for (int j = 0; j < _s99_dword_47F330[0]; ++j) + _gameSys->insertSequence(_s99_dword_47F370[j], j + 2, 0, 0, kSeqNone, 0, 0, 0); + _gameSys->setAnimation(_s99_dword_47F370[0], 2, 0); + + clearKeyStatus1(Common::KEYCODE_ESCAPE); + clearKeyStatus1(Common::KEYCODE_SPACE); + clearKeyStatus1(29); + + _mouseClickState.left = false; + + while (!_sceneDone) { + + gameUpdateTick(); + + if (_gameSys->getAnimationStatus(0) == 2 || skip) { + skip = 0; + _gameSys->requestClear2(0); + _gameSys->requestClear1(); + _gameSys->setAnimation(0, 0, 0); + v1 += _s99_dword_47F330[itemIndex++]; + if (itemIndex >= _s99_itemsCount) { + _sceneDone = true; + } else { + for (int m = 0; m < _s99_dword_47F330[itemIndex]; ++m) + _gameSys->insertSequence(_s99_dword_47F370[v1 + m], m + 2, 0, 0, kSeqNone, 0, 0, 0); + _gameSys->drawSpriteToBackground(0, 0, _s99_dword_47F2F0[itemIndex]); + _gameSys->setAnimation(_s99_dword_47F370[v1], 2, 0); + } + } + + if (isKeyStatus1(Common::KEYCODE_ESCAPE) || isKeyStatus1(Common::KEYCODE_SPACE) || isKeyStatus1(29)) { + clearKeyStatus1(Common::KEYCODE_ESCAPE); + clearKeyStatus1(Common::KEYCODE_SPACE); + clearKeyStatus1(29); + if (_s99_canSkip[itemIndex] & 1) + skip = true; + else + _sceneDone = true; + } + + if (!_timers[0] && itemIndex == _s99_itemsCount - 1) { + _timers[0] = 2; + volume = MAX(1, volume - duration); + setSoundVolume(soundId, volume); + } + + } + + if (soundId != -1) + stopSound(soundId); + +} + +} // End of namespace Gnap diff --git a/engines/gnap/gnap.h b/engines/gnap/gnap.h new file mode 100644 index 0000000000..e1d13eca41 --- /dev/null +++ b/engines/gnap/gnap.h @@ -0,0 +1,1117 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#ifndef GNAP_H +#define GNAP_H + +#include "common/array.h" +#include "common/events.h" +#include "common/file.h" +#include "common/memstream.h" +#include "common/random.h" +#include "common/str.h" +#include "common/substream.h" +#include "common/system.h" +#include "common/winexe.h" +#include "common/winexe_pe.h" +#include "engines/engine.h" +#include "graphics/pixelformat.h" +#include "graphics/wincursor.h" + +#include "gnap/resource.h" + +struct ADGameDescription; + +namespace Gnap { + +class DatManager; +class SequenceResource; +class SpriteResource; +class GameSys; +class SoundMan; + +struct MouseButtonState { + bool left; + bool right; + bool middle; + MouseButtonState() : left(false), right(false), middle(false) { + } +}; + +struct Hotspot { + int16 x1, y1, x2, y2; + int16 field_10; + int16 field_12; + uint16 flags; + int id; + bool isPointInside(int16 x, int16 y) const { + return x >= x1 && x <= x2 && y >= y1 && y <= y2; + } + bool isFlag(uint16 flag) const { + return (flags & flag) != 0; + } +}; + +struct GridStruct { + int deltaX, deltaY; + int gridX1, gridY1; + int sequenceId; + int id; +}; + +const int kMaxGridStructs = 30; +const int kMaxTimers = 10; + +enum { + SF_LOOK_CURSOR = 0x0001, + SF_GRAB_CURSOR = 0x0002, + SF_TALK_CURSOR = 0x0004, + SF_PLAT_CURSOR = 0x0008, + SF_DISABLED = 0x0010, + SF_WALKABLE = 0x0020, + SF_EXIT_L_CURSOR = 0x0040, + SF_EXIT_R_CURSOR = 0x0080, + SF_EXIT_U_CURSOR = 0x0100, + SF_EXIT_D_CURSOR = 0x0200, + SF_EXIT_NW_CURSOR = 0x0400, + SF_EXIT_NE_CURSOR = 0x0800, + SF_EXIT_SW_CURSOR = 0x1000, + SF_EXIT_SE_CURSOR = 0x2000 +}; + +enum { + LOOK_CURSOR = 0, + GRAB_CURSOR = 1, + TALK_CURSOR = 2, + PLAT_CURSOR = 3, + NOLOOK_CURSOR = 4, + NOGRAB_CURSOR = 5, + NOTALK_CURSOR = 6, + NOPLAT_CURSOR = 7, + EXIT_L_CURSOR = 8, + EXIT_R_CURSOR = 9, + EXIT_U_CURSOR = 10, + EXIT_D_CURSOR = 11, + EXIT_NE_CURSOR = 12, + EXIT_NW_CURSOR = 13, + EXIT_SE_CURSOR = 14, + EXIT_SW_CURSOR = 15, + WAIT_CURSOR = 16 +}; + +enum { + gskPullOutDevice = 0, + gskPullOutDeviceNonWorking = 1, + gskIdle = 2, + gskBrainPulsating = 3, + gskImpossible = 4, + gskScratchingHead = 5, + gskDeflect = 6, + gskUseDevice = 7, + gskMoan1 = 8, + gskMoan2 = 9 +}; + +enum { + kItemMagazine = 0, + kItemMud = 1, + kItemGrass = 2, + kItemDisguise = 3, + kItemNeedle = 4, + kItemTwig = 5, + kItemGas = 6, + kItemKeys = 7, + kItemDice = 8, + kItemTongs = 9, + kItemQuarter = 10, + kItemQuarterWithHole = 11, + kItemDiceQuarterHole = 12, + kItemWrench = 13, + kItemCowboyHat = 14, + kItemGroceryStoreHat = 15, + kItemBanana = 16, + kItemTickets = 17, + kItemPicture = 18, + kItemEmptyBucket = 19, + kItemBucketWithBeer = 20, + kItemBucketWithPill = 21, + kItemPill = 22, + kItemHorn = 23, + kItemJoint = 24, + kItemChickenBucket = 25, + kItemGum = 26, + kItemSpring = 27, + kItemLightbulb = 28, + kItemCereals = 29 +}; + +enum { + kGFPlatypus = 0, + kGFMudTaken = 1, + + + kGFEnd +}; + +/* + Game flags + 0 1 With Platypus + 1 2 Mud taken + 2 4 Needle taken + 3 8 Twig taken + 4 0x10 + 5 0x20 Keys taken + 6 0x40 Grass taken + 7 0x80 Barn padlock open + 8 0x100 Truck filled with gas + 9 0x200 Truck keys used + 10 0x400 Platypus disguised + 11 0x800 Scene flag 1 + 12 0x1000 Gnap controls toy ufo + 13 0x2000 + 14 0x4000 + 15 0x8000 Spring taken + 16 0x10000 + 17 0x20000 Joint taken + 18 0x40000 + 19 0x80000 Grocery store hat taken + 20 0x100000 Picture taken + 21 0x200000 + 22 0x400000 + 23 0x800000 + 24 0x1000000 + 25 0x2000000 + 26 0x4000000 Platypus talking with toy shop assistant + 27 0x8000000 + 28 0x10000000 + 29 0x20000000 Gas taken + 30 0x40000000 + 31 0x80000000 + + +*/ + + // 0x7AB Gnap walks to the right 1 + // 0x7AC Gnap walks to the right 2 + // 0x7AF Gnap walks to the left 1 + // 0x7B0 Gnap walks to the left 2 + +struct Scene49Obstacle { + int currSequenceId; + int closerSequenceId; + int passedSequenceId; + int splashSequenceId; + int collisionSequenceId; + int prevId; + int currId; + int laneNum; +}; + +struct Scene51Item { + int currSequenceId; + int droppedSequenceId; + int x, y; + int collisionX; + int canCatch; + int isCollision; + int x2; + int id; +}; + +class GnapEngine : public Engine { +protected: + Common::Error run(); + virtual bool hasFeature(EngineFeature f) const; +public: + GnapEngine(OSystem *syst, const ADGameDescription *gd); + ~GnapEngine(); +private: + const ADGameDescription *_gameDescription; + Graphics::PixelFormat _pixelFormat; +public: + Common::RandomSource *_random; + + Common::PEResources *_exe; + + DatManager *_dat; + SpriteCache *_spriteCache; + SoundCache *_soundCache; + SequenceCache *_sequenceCache; + GameSys *_gameSys; + SoundMan *_soundMan; + + int _lastUpdateClock; + + int _debugLevel; + bool _gameDone; + + byte _keyPressState[512]; + byte _keyDownState[512]; + + bool _isPaused; + Graphics::Surface *_pauseSprite; + int _timers[kMaxTimers], _savedTimers[kMaxTimers]; + + MouseButtonState _mouseButtonState; + MouseButtonState _mouseClickState; + + uint32 _keyStatus1[2]; + + bool _sceneSavegameLoaded, _wasSavegameLoaded; + + Graphics::Surface *_backgroundSurface; + int _prevSceneNum, _currentSceneNum, _newSceneNum; + bool _sceneDone, _sceneWaiting; + + uint32 _inventory, _gameFlags; + + Hotspot _hotspots[20]; + Common::Point _hotspotsWalkPos[20]; + int _hotspotsCount; + int _sceneClickedHotspot; + + bool _isWaiting; + bool _isLeavingScene; + + bool _isStockDatLoaded; + + int _newCursorValue, _cursorValue; + + int _verbCursor, _cursorIndex; + int _mouseX, _mouseY; + int _leftClickMouseX, _leftClickMouseY; + + Graphics::Surface *_grabCursorSprite; + int _currGrabCursorX, _currGrabCursorY; + int _grabCursorSpriteIndex, _newGrabCursorSpriteIndex; + + Graphics::Surface *_fullScreenSprite; + int _fullScreenSpriteId; + + int _deviceX1, _deviceY1, _deviceX2, _deviceY2; + + int _soundTimerIndexA; + int _soundTimerIndexB; + int _soundTimerIndexC; + int _idleTimerIndex; + + void updateEvents(); + void gameUpdateTick(); + void saveTimers(); + void restoreTimers(); + + void pauseGame(); + void resumeGame(); + void updatePause(); + + int getRandom(int max); + + int readSavegameDescription(int savegameNum, Common::String &description); + int loadSavegame(int savegameNum); + + void delayTicks(int a1); + void delayTicksCursor(int a1); + + void setHotspot(int index, int16 x1, int16 y1, int16 x2, int16 y2, uint16 flags = 0, + int16 walkX = -1, int16 walkY = -1); + int getHotspotIndexAtPos(int16 x, int16 y); + void updateCursorByHotspot(); + int getClickedHotspotId(); + + int getInventoryItemSpriteNum(int index); + + void updateMouseCursor(); + void setVerbCursor(int verbCursor); + void setCursor(int cursorIndex); + void showCursor(); + void hideCursor(); + + void setGrabCursorSprite(int index); + void createGrabCursorSprite(int spriteId); + void freeGrabCursorSprite(); + void updateGrabCursorSprite(int x, int y); + + void invClear(); + void invAdd(int itemId); + void invRemove(int itemId); + bool invHas(int itemId); + + void clearFlags(); + void setFlag(int num); + void clearFlag(int num); + bool isFlag(int num); + + Graphics::Surface *addFullScreenSprite(int resourceId, int id); + void removeFullScreenSprite(); + void showFullScreenSprite(int resourceId); + + void queueInsertDeviceIcon(); + void insertDeviceIconActive(); + void removeDeviceIconActive(); + void setDeviceHotspot(int hotspotIndex, int x1, int y1, int x2, int y2); + + int getSequenceTotalDuration(int resourceId); + + bool isSoundPlaying(int resourceId); + void playSound(int resourceId, bool looping); + void stopSound(int resourceId); + void setSoundVolume(int resourceId, int volume); + + void updateTimers(); + + void initGameFlags(int num); + void loadStockDat(); + + void mainLoop(); + void initScene(); + void endSceneInit(); + void afterScene(); + + int initSceneLogic(); + void runSceneLogic(); + + void checkGameKeys(); + + void startSoundTimerA(int timerIndex); + int playSoundA(); + void startSoundTimerB(int timerIndex); + int playSoundB(); + void startSoundTimerC(int timerIndex); + int playSoundC(); + void startIdleTimer(int timerIndex); + void updateIdleTimer(); + + void screenEffect(int dir, byte r, byte g, byte b); + + bool isKeyStatus1(int key); + bool isKeyStatus2(int key); + void clearKeyStatus1(int key); + void clearAllKeyStatus1(); + + void deleteSurface(Graphics::Surface **surface); + + // Menu + int _menuStatus; + int _menuSpritesIndex; + bool _menuDone; + Graphics::Surface *_menuBackgroundSurface; + Graphics::Surface *_menuQuitQuerySprite; + Graphics::Surface *_largeSprite; + Graphics::Surface *_menuSaveLoadSprite; + Graphics::Surface *_menuSprite2; + Graphics::Surface *_menuSprite1; + char _savegameFilenames[7][30]; + Graphics::Surface *_savegameSprites[7]; + Graphics::Surface *_spriteHandle; + Graphics::Surface *_cursorSprite; + int _menuInventoryIndices[30]; + Graphics::Surface *_menuInventorySprites[30]; + int _savegameIndex; + void createMenuSprite(); + void freeMenuSprite(); + void initMenuHotspots1(); + void initMenuHotspots2(); + void initMenuQuitQueryHotspots(); + void initSaveLoadHotspots(); + void drawInventoryFrames(); + void insertInventorySprites(); + void removeInventorySprites(); + void runMenu(); + void updateMenuStatusInventory(); + void updateMenuStatusMainMenu(); + void updateMenuStatusSaveGame(); + void updateMenuStatusLoadGame(); + void updateMenuStatusQueryQuit(); + + // Grid common + int _gnapGridX, _gnapGridY; + int _platGridX, _platGridY; + int _gridMinX, _gridMinY; + int _gridMaxX, _gridMaxY; + bool isPointBlocked(int gridX, int gridY); + void initSceneGrid(int gridMinX, int gridMinY, int gridMaxX, int gridMaxY); + bool testWalk(int animationIndex, int someStatus, int gridX1, int gridY1, int gridX2, int gridY2); + + // Gnap walking + int _gnapWalkNodesCount; + GridStruct _gnapWalkNodes[kMaxGridStructs]; + int _gnapX, _gnapY; + int _gnapWalkDestX, _gnapWalkDestY; + int _gnapWalkDeltaX, _gnapWalkDeltaY, _gnapWalkDirX, _gnapWalkDirY, _gnapWalkDirXIncr, _gnapWalkDirYIncr; + + int getGnapWalkSequenceId(int deltaX, int deltaY); + int getGnapWalkStopSequenceId(int deltaX, int deltaY); + int getGnapWalkFacing(int deltaX, int deltaY); + bool gridSub41F08B(int gridX, int gridY); + bool gridSub41F5FC(int gridX, int gridY, int index); + bool gridSub41FAD5(int gridX, int gridY, int index); + bool gnapFindPath3(int gridX, int gridY); + bool gnapWalkTo(int gridX, int gridY, int animationIndex, int sequenceId, int flags); + void gnapWalkStep(); + + // Beaver walking + int _platWalkNodesCount; + GridStruct _platWalkNodes[kMaxGridStructs]; + int _platX, _platY; + int _platWalkDestX, _platWalkDestY; + int _platWalkDeltaX, _platWalkDeltaY, _platWalkDirX, _platWalkDirY, _platWalkDirXIncr, _platWalkDirYIncr; + + int getBeaverWalkSequenceId(int deltaX, int deltaY); + bool gridSub423750(int gridX, int gridY); + bool gridSub423CC1(int gridX, int gridY, int index); + bool gridSub42419A(int gridX, int gridY, int index); + bool platFindPath3(int gridX, int gridY); + bool platypusWalkTo(int gridX, int gridY, int animationIndex, int sequenceId, int flags); + void platypusWalkStep(); + void beaverMakeRoom(); + + // Gnap + int _gnapIdleFacing; + int _gnapActionStatus; + int _gnapBrainPulseNum, _gnapBrainPulseRndValue; + int _gnapSequenceId, _gnapSequenceDatNum, _gnapId; + int _gnapRandomValue; + + int getGnapSequenceId(int kind, int gridX, int gridY); + int getGnapShowSequenceId(int index, int gridX, int gridY); + void gnapIdle(); + void gnapActionIdle(int sequenceId); + void playGnapSequence(int sequenceId); + void playGnapImpossible(int gridX, int gridY); + void playGnapScratchingHead(int gridX, int gridY); + void playGnapMoan1(int gridX, int gridY); + void playGnapMoan2(int gridX, int gridY); + void playGnapBrainPulsating(int gridX, int gridY); + void playGnapPullOutDevice(int gridX, int gridY); + void playGnapPullOutDeviceNonWorking(int gridX, int gridY); + void playGnapUseDevice(int gridX, int gridY); + void playGnapIdle(int gridX, int gridY); + void playGnapShowItem(int itemIndex, int gridLookX, int gridLookY); + void playGnapShowCurrItem(int gridX, int gridY, int gridLookX, int gridLookY); + void updateGnapIdleSequence(); + void updateGnapIdleSequence2(); + void initGnapPos(int gridX, int gridY, int facing); + void gnapInitBrainPulseRndValue(); + void gnapUseDeviceOnBeaver(); + void doCallback(int callback); + bool gnapPlatypusAction(int gridX, int gridY, int platSequenceId, int callback); + void gnapKissPlatypus(int callback); + void gnapUseJointOnPlatypus(); + void gnapUseDisguiseOnPlatypus(); + + // Beaver + int _beaverFacing; + int _beaverActionStatus; + int _beaverSequenceId, _beaverSequenceDatNum, _beaverId; + int getBeaverSequenceId(int kind, int gridX, int gridY); + void playBeaverSequence(int sequenceId); + void updateBeaverIdleSequence(); + void beaverSub426234(); + void initBeaverPos(int gridX, int gridY, int facing); + + // Scenes + + int _toyUfoNextSequenceId, _toyUfoSequenceId; + int _toyUfoId; + int _toyUfoActionStatus; + int _toyUfoX; + int _toyUfoY; + + void initGlobalSceneVars(); + + bool sceneXX_sub_4466B1(); + void sceneXX_playRandomSound(int timerIndex); + void playSequences(int fullScreenSpriteId, int sequenceId1, int sequenceId2, int sequenceId3); + + // Scene 0 + int scene00_init(); + + // Scene 1 + int _s01_pigsIdCtr, _s01_smokeIdCtr; + Graphics::Surface *_s01_spaceshipSurface; + int scene01_init(); + void scene01_updateHotspots(); + void scene01_run(); + void scene01_updateAnimations(); + + // Scene 2 + int _s02_truckGrillCtr; + int _s02_nextChickenSequenceId, _s02_currChickenSequenceId; + int _s02_gnapTruckSequenceId; + int scene02_init(); + void scene02_updateHotspots(); + void scene02_run(); + void scene02_updateAnimations(); + + // Scene 3 + bool _s03_platypusHypnotized; + bool _s03_platypusScared; + int _s03_nextPlatSequenceId; + int _s03_nextFrogSequenceId, _s03_currFrogSequenceId; + int scene03_init(); + void scene03_updateHotspots(); + void scene03_run(); + void scene03_updateAnimations(); + + // Scene 4 + bool _s04_triedWindow; + int _s04_dogIdCtr; + int _s04_nextDogSequenceId, _s04_currDogSequenceId; + int scene04_init(); + void scene04_updateHotspots(); + void scene04_run(); + void scene04_updateAnimations(); + + // Scene 5 + int _s05_nextChickenSequenceId, _s05_currChickenSequenceId; + int scene05_init(); + void scene05_updateHotspots(); + void scene05_run(); + void scene05_updateAnimations(); + + // Scene 6 + bool _s06_horseTurnedBack; + int _s06_nextPlatSequenceId; + int _s06_nextHorseSequenceId, _s06_currHorseSequenceId; + int scene06_init(); + void scene06_updateHotspots(); + void scene06_run(); + void scene06_updateAnimations(); + + // Scene 7 + int scene07_init(); + void scene07_updateHotspots(); + void scene07_run(); + void scene07_updateAnimations(); + + // Scene 8 + int _s08_nextDogSequenceId, _s08_currDogSequenceId; + int _s08_nextManSequenceId, _s08_currManSequenceId; + int scene08_init(); + void scene08_updateHotspots(); + void scene08_updateAnimationsCb(); + void scene08_run(); + void scene08_updateAnimations(); + + // Scene 9 + int scene09_init(); + void scene09_updateHotspots(); + void scene09_run(); + void scene09_updateAnimations(); + + // Scene 10 + int _s10_nextCookSequenceId, _s10_currCookSequenceId; + int scene10_init(); + void scene10_updateHotspots(); + void scene10_run(); + void scene10_updateAnimations(); + void scene10_updateAnimationsCb(); + + // Scene 11 + int _s11_billardBallCtr; + int _s11_nextHookGuySequenceId, _s11_currHookGuySequenceId; + int _s11_nextGoggleGuySequenceId, _s11_currGoggleGuySequenceId; + int scene11_init(); + void scene11_updateHotspots(); + void scene11_run(); + void scene11_updateAnimations(); + + // Scene 12 + int _s12_nextBeardGuySequenceId, _s12_currBeardGuySequenceId; + int _s12_nextToothGuySequenceId, _s12_currToothGuySequenceId; + int _s12_nextBarkeeperSequenceId, _s12_currBarkeeperSequenceId; + int scene12_init(); + void scene12_updateHotspots(); + void scene12_run(); + void scene12_updateAnimations(); + + // Scene 13 + int _s13_backToiletCtr; + int scene13_init(); + void scene13_updateHotspots(); + void scene13_showScribble(); + void scene13_run(); + void scene13_updateAnimations(); + + // Scene 14 + int scene14_init(); + void scene14_updateHotspots(); + void scene14_run(); + void scene14_updateAnimations(); + + // Scene 15 + int _s15_nextRecordSequenceId, _s15_currRecordSequenceId; + int _s15_nextSlotSequenceId, _s15_currSlotSequenceId; + int _s15_nextUpperButtonSequenceId, _s15_currUpperButtonSequenceId; + int _s15_nextLowerButtonSequenceId, _s15_currLowerButtonSequenceId; + int scene15_init(); + void scene15_updateHotspots(); + void scene15_run(); + void scene15_updateAnimations(); + + // Scene 16 + void scene16_initCutscene(); + + // Scene 17 + bool _s17_canTryGetWrench; + int _s17_wrenchCtr, _s17_platPhoneCtr, _s17_platTryGetWrenchCtr; + int _s17_nextPhoneSequenceId, _s17_currPhoneSequenceId; + int _s17_nextWrenchSequenceId, _s17_currWrenchSequenceId; + int _s17_nextCarWindowSequenceId, _s17_currCarWindowSequenceId; + int scene17_init(); + void scene17_updateHotspots(); + void scene17_update(); + void scene17_platHangUpPhone(); + void scene17_run(); + void scene17_updateAnimations(); + + // Scene 18 + int _s18_garbageCanPos; + int _s18_platPhoneCtr; + int _s18_platPhoneIter; + int _s18_nextPhoneSequenceId, _s18_currPhoneSequenceId; + Graphics::Surface *_s18_cowboyHatSurface; + int scene18_init(); + void scene18_updateHotspots(); + void scene18_gnapCarryGarbageCanTo(int a1, int arg4, int animationIndex, int argC, int a5); + void scene18_putDownGarbageCan(int animationIndex); + void scene18_platEndPhoning(int a1); + void scene18_closeHydrantValve(); + void scene18_waitForGnapAction(); + void scene18_run(); + void scene18_updateAnimations(); + + // Scene 19 + int _s19_currShopAssistantSequenceId, _s19_nextShopAssistantSequenceId; + int _s19_toyGrabCtr; + int _s19_shopAssistantCtr; + Graphics::Surface *_s19_pictureSurface; + int scene19_init(); + void scene19_updateHotspots(); + void scene19_run(); + void scene19_updateAnimations(); + + // Scene 20 + int _s20_currStonerGuySequenceId, _s20_nextStonerGuySequenceId; + int _s20_currGroceryStoreGuySequenceId, _s20_nextGroceryStoreGuySequenceId; + int _s20_stonerGuyCtr; + bool _s20_stonerGuyShowingJoint; + int _s20_groceryStoreGuyCtr; + int scene20_init(); + void scene20_updateHotspots(); + void scene20_updateAnimationsCb(); + void scene20_stopSounds(); + void scene20_run(); + void scene20_updateAnimations(); + + // Scene 21 + int _s21_currOldLadySequenceId, _s21_nextOldLadySequenceId; + int scene21_init(); + void scene21_updateHotspots(); + void scene21_run(); + void scene21_updateAnimations(); + + // Scene 22 + int _s22_currCashierSequenceId, _s22_nextCashierSequenceId; + bool _s22_caughtBefore; + int _s22_cashierCtr; + int scene22_init(); + void scene22_updateHotspots(); + void scene22_run(); + void scene22_updateAnimations(); + + // Scene 23 + int _s23_currStoreClerkSequenceId, _s23_nextStoreClerkSequenceId; + int scene23_init(); + void scene23_updateHotspots(); + void scene23_run(); + void scene23_updateAnimations(); + + // Scene 24 + int _s24_currWomanSequenceId, _s24_nextWomanSequenceId; + int _s24_boySequenceId; + int _s24_girlSequenceId; + int scene24_init(); + void scene24_updateHotspots(); + void scene24_run(); + void scene24_updateAnimations(); + + // Scene 25 + int _s25_currTicketVendorSequenceId, _s25_nextTicketVendorSequenceId; + int scene25_init(); + void scene25_updateHotspots(); + void scene25_playAnims(int index); + void scene25_run(); + void scene25_updateAnimations(); + + // Scene 26 + int _s26_currKidSequenceId, _s26_nextKidSequenceId; + int scene26_init(); + void scene26_updateHotspots(); + void scene26_run(); + void scene26_updateAnimations(); + + // Scene 27 + int _s27_nextJanitorSequenceId; + int _s27_currJanitorSequenceId; + int scene27_init(); + void scene27_updateHotspots(); + void scene27_run(); + void scene27_updateAnimations(); + + // Scene 28 + int _s28_dword_47EA5C; + int _s28_dword_47EA60; + int _s28_dword_474938; + int scene28_init(); + void scene28_updateHotspots(); + void scene28_run(); + void scene28_updateAnimations(); + + // Scene 29 + int _s29_dword_47EA74; + int _s29_dword_47EA78; + int _s29_dword_47EA7C; + int _s29_dword_47EA80; + int scene29_init(); + void scene29_updateHotspots(); + void scene29_run(); + void scene29_updateAnimations(); + + // Scene 30 + int _s30_dword_47EA88; + int _s30_dword_47EA8C; + int scene30_init(); + void scene30_updateHotspots(); + void scene30_run(); + void scene30_updateAnimations(); + + // Scene 31 + int _s31_dword_47EAA8; + int _s31_dword_47EAAC; + int _s31_dword_47EAB0; + bool _s31_beerGuyDistracted; + int _s31_dword_474940; + int _s31_dword_47EAB4; + int scene31_init(); + void scene31_updateHotspots(); + void scene31_run(); + void scene31_updateAnimations(); + + // Scene 32 + int _s32_dword_47EADC; + int scene32_init(); + void scene32_updateHotspots(); + void scene32_run(); + void scene32_updateAnimations(); + + int _s33_dword_47EAE4; + int _s33_dword_47EAE8; + int _s33_dword_47EAEC; + int scene33_init(); + void scene33_updateHotspots(); + void scene33_run(); + void scene33_updateAnimations(); + + // Scene 38 + int scene38_init(); + void scene38_updateHotspots(); + void scene38_run(); + void scene38_updateAnimations(); + + // Scene 39 + int _s39_dword_47EAF8; + int _s39_dword_47EAFC; + int scene39_init(); + void scene39_updateHotspots(); + void scene39_run(); + void scene39_updateAnimations(); + + // Scene 40 + int scene40_init(); + void scene40_updateHotspots(); + void scene40_run(); + void scene40_updateAnimations(); + + // Scene 4x + void toyUfoSetStatus(int a1); + int toyUfoGetSequenceId(); + bool toyUfoCheckTimer(); + void toyUfoFlyTo(int destX, int destY, int a3, int a4, int a5, int a6, int animationIndex); + + // Scene 41 + int _s41_dword_47F2C0; + int _s41_dword_47F2C4; + int _s41_dword_47F2C8; + int _s41_dword_47F2CC; + int scene41_init(); + void scene41_updateHotspots(); + void scene41_run(); + void scene41_updateAnimations(); + + // Scene 42 + int _s42_dword_47F2B8; + int _s42_dword_47F2BC; + int scene42_init(); + void scene42_updateHotspots(); + void scene42_run(); + void scene42_updateAnimations(); + + // Scene 43 + int _s43_dword_47F2B0; + int _s43_dword_47F2B4; + int scene43_init(); + void scene43_updateHotspots(); + void scene43_run(); + void scene43_updateAnimations(); + + // Scene 44 + int _s44_dword_47EB04; + int _s44_dword_47EB08; + int _s44_dword_47EB0C; + int _s44_dword_47EB10; + int scene44_init(); + void scene44_updateHotspots(); + void scene44_run(); + void scene44_updateAnimations(); + + // Scene 45 + int _s45_dword_4749BC; + int _s45_dword_4749C0; + int scene45_init(); + void scene45_updateHotspots(); + void scene45_run(); + void scene45_updateAnimations(); + + // Scene 46 + int _s46_dword_47EB18; + int _s46_dword_47EB1C; + int _s46_dword_47EB20; + int _s46_dword_47EB24; + int scene46_init(); + void scene46_updateHotspots(); + void scene46_run(); + void scene46_updateAnimations(); + + // Scene 47 + void scene47_initCutscene1(); + void scene47_initCutscene2(); + void scene47_initCutscene3(); + void scene47_initCutscene4(); + void scene47_initCutscene5(); + void scene47_initCutscene6(); + void scene47_initCutscene7(); + + // Scene 48 + void scene48_initCutscene(); + + // Scene 49 + int _s49_scoreBarPos, _s49_scoreLevel, _s49_scoreBarFlash; + int _s49_obstacleIndex; + Scene49Obstacle _s49_obstacles[5]; + int _s49_truckSequenceId, _s49_truckId, _s49_truckLaneNum; + int scene49_init(); + void scene49_updateHotspots(); + void scene49_checkObstacles(); + void scene49_updateObstacle(int i); + void scene49_increaseScore(int amount); + void scene49_decreaseScore(int amount); + void scene49_refreshScoreBar(); + void scene49_clearObstacle(int index); + void scene49_run(); + void scene49_updateAnimations(); + + // Scene 50 + bool _s50_fightDone; + int _s50_timesPlayed, _s50_timesPlayedModifier; + int _s50_attackCounter; + int _s50_roundNum, _s50_timeRemaining; + int _s50_leftTongueRoundsWon, _s50_rightTongueRoundsWon; + int _s50_leftTongueEnergyBarPos, _s50_rightTongueEnergyBarPos; + int _s50_leftTongueSequenceId, _s50_leftTongueId; + int _s50_leftTongueNextSequenceId, _s50_leftTongueNextId, _s50_leftTongueNextIdCtr; + int _s50_rightTongueSequenceId, _s50_rightTongueId; + int _s50_rightTongueNextSequenceId, _s50_rightTongueNextId, _s50_rightTongueNextIdCtr; + int _s50_leftTongueEnergy, _s50_rightTongueEnergy; + int scene50_init(); + void scene50_updateHotspots(); + bool scene50_tongueWinsRound(int tongueNum); + void scene50_playWinAnim(int tongueNum, bool fightOver); + void scene50_delayTicks(); + void scene50_initRound(); + bool scene50_updateCountdown(); + void scene50_drawCountdown(int value); + void scene50_playTonguesIdle(); + void scene50_playRoundAnim(int roundNum); + bool scene50_updateEnergyBars(int newLeftBarPos, int newRightBarPos); + void scene50_waitForAnim(int animationIndex); + int scene50_checkInput(); + int scene50_getRightTongueAction(); + void scene50_updateAnimations(); + int scene50_getRightTongueActionTicks(); + int scene50_getLeftTongueNextId(); + int scene50_getRightTongueNextId(); + void scene50_playWinBadgeAnim(int tongueNum); + void scene50_run(); + + // Scene 51 + int _s51_cashAmount; + int _s51_digits[4]; + int _s51_digitSequenceIds[4]; + int _s51_guySequenceId, _s51_guyNextSequenceId; + int _s51_itemsCaughtCtr; + int _s51_dropSpeedTicks; + int _s51_nextDropItemKind, _s51_itemInsertX, _s51_itemInsertDirection; + int _s51_platypusSequenceId, _s51_platypusNextSequenceId, _s51_platypusJumpSequenceId; + bool _s51_dropLoseCash; + int _s51_itemsCtr,_s51_itemsCtr1, _s51_itemsCtr2; + Scene51Item _s51_items[6]; + + int scene51_init(); + void scene51_updateHotspots(); + void scene51_clearItem(Scene51Item *item); + void scene51_dropNextItem(); + void scene51_updateItemAnimations(); + int scene51_checkCollision(int sequenceId); + void scene51_updateItemAnimation(Scene51Item *item, int index); + void scene51_removeCollidedItems(); + int scene51_itemIsCaught(Scene51Item *item); + bool scene51_isJumpingRight(int sequenceId); + bool scene51_isJumpingLeft(int sequenceId); + bool scene51_isJumping(int sequenceId); + void scene51_waitForAnim(int animationIndex); + int scene51_getPosRight(int sequenceId); + int scene51_getPosLeft(int sequenceId); + void scene51_playIntroAnim(); + void scene51_updateGuyAnimation(); + int scene51_incCashAmount(int sequenceId); + void scene51_winMinigame(); + void scene51_playCashAppearAnim(); + void scene51_updateCash(int amount); + void scene51_drawDigit(int digit, int position); + void scene51_initCashDisplay(); + void scene51_run(); + + // Scene 52 + int _s52_liveAlienRows; + int _s52_gameScore; + bool _s52_soundToggle; + int _s52_arcadeScreenLeft; + int _s52_arcadeScreenRight; + int _s52_arcadeScreenBottom; + int _s52_shipsLeft; + int _s52_shieldSpriteIds[3]; + int _s52_shieldPosX[3]; + int _s52_shipPosX; + int _s52_shipCannonFired, _s52_shipCannonPosX, _s52_shipCannonPosY; + int _s52_shipCannonFiring; + int _s52_shipCannonWidth, _s52_shipCannonHeight; + int _s52_shipCannonTopY; + int _s52_shipMidX, _s52_shipMidY; + bool _s52_shipFlag; + bool _s52_aliensInitialized; + int _s52_alienSpeed, _s52_alienDirection; + int _s52_alienWidth, _s52_alienHeight; + int _s52_alienLeftX, _s52_alienTopY; + int _s52_alienRowDownCtr; + int _s52_alienRowKind[7]; + int _s52_alienRowAnims[7]; + int _s52_alienRowIds[7]; + int _s52_alienRowXOfs[7]; + int _s52_alienCannonFired[3]; + int _s52_alienCannonPosX[3]; + int _s52_alienCannonPosY[3]; + int _s52_alienCannonSequenceIds[3]; + int _s52_alienCannonIds[3]; + bool _s52_alienWave, _s52_alienSingle; + int _s52_alienCounter; + bool _s52_bottomAlienFlag; + int _s52_aliensCount; + int _s52_items[8][5]; + int _s52_nextUfoSequenceId, _s52_ufoSequenceId; + int scene52_init(); + void scene52_updateHotspots(); + void scene52_update(); + void scene52_initShipCannon(int bottomY); + void scene52_initAlienCannons(); + void scene52_fireShipCannon(int posX); + void scene52_fireAlienCannon(); + int scene52_getFreeShipCannon(); + int scene52_getFreeAlienCannon(); + void scene52_updateShipCannon(); + void scene52_updateAlienCannons(); + void scene52_initAliens(); + void scene52_initAlienRowKind(int rowNum, int alienKind); + void scene52_insertAlienRow(int rowNum); + void scene52_insertAlienRowAliens(int rowNum); + void scene52_updateAlienRow(int rowNum); + void scene52_moveDownAlienRow(); + int scene52_updateHitAlien(); + int scene52_getHitAlienNum(int rowNum); + int scene52_alienCannonHitShip(int cannonNum); + int scene52_alienCannonHitShield(int cannonNum); + int scene52_shipCannonHitShield(int cannonNum); + int scene52_shipCannonHitAlien(); + void scene52_shipExplode(); + int scene52_checkAlienRow(int a1); + void scene52_updateAlienRowXOfs(); + void scene52_initAlienSize(); + void scene52_playSound(); + void scene52_updateAliens(); + void scene52_updateAlien(int rowNum); + void scene52_loseShip(); + void scene52_initShields(); + void scene52_initAnims(); + void scene52_drawScore(int a1); + void scene52_run(); + + // Scene 53 + int _s53_currHandSequenceId; + bool _s53_isGnapPhoning; + int _s53_callsMadeCtr; + uint _s53_callsRndUsed; + int scene53_init(); + void scene53_updateHotspots(); + int scene53_pressPhoneNumberButton(int phoneNumber, int buttonNum); + int scene53_getRandomCallIndex(); + void scene53_runRandomCall(); + void scene53_runChitChatLine(); + void scene53_run(); + + // Scene 54 + void scene54_initCutscene1(); + void scene54_initCutscene2(); + + // Scene 99 + int _s99_itemsCount; + int _s99_dword_47F2F0[16]; + int _s99_dword_47F330[16]; + int _s99_dword_47F370[50]; + byte _s99_canSkip[16]; + int cutscene_init(); + void cutscene_run(); + +}; + +} // End of namespace Gnap + +#endif // GNAP_H diff --git a/engines/gnap/grid.cpp b/engines/gnap/grid.cpp new file mode 100644 index 0000000000..522c72c491 --- /dev/null +++ b/engines/gnap/grid.cpp @@ -0,0 +1,1392 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "gnap/gnap.h" +#include "gnap/datarchive.h" +#include "gnap/gamesys.h" +#include "gnap/resource.h" + +namespace Gnap { + +void GnapEngine::initSceneGrid(int gridMinX, int gridMinY, int gridMaxX, int gridMaxY) { + _gridMinX = gridMinX; + _gridMinY = gridMinY; + _gridMaxX = gridMaxX; + _gridMaxY = gridMaxY; + _gnapGridX = 410 - gridMinX; + _gnapGridY = 450 - gridMinY; + _platGridX = 396 - gridMinX; + _platGridY = 347 - gridMinY; +} + +int GnapEngine::getGnapWalkSequenceId(int deltaX, int deltaY) { + static const int _gnapWalkSequenceIds[9] = { + 0x7B2, 0x000, 0x7B4, + 0x7AD, 0x000, 0x7AE, + 0x7B1, 0x000, 0x7B3 + }; + // CHECKME This is a little weird + return _gnapWalkSequenceIds[3 * deltaX + 3 + 1 + deltaY]; +} + +int GnapEngine::getGnapWalkStopSequenceId(int deltaX, int deltaY) { + static const int _gnapWalkStopSequenceIds[9] = { + 0x7BC, 0x7BA, 0x7BA, + 0x7BC, 0x000, 0x7BA, + 0x7BB, 0x7B9, 0x7B9 + }; + // CHECKME This is a little weird + return _gnapWalkStopSequenceIds[3 * deltaX + 3 + 1 + deltaY]; +} + +int GnapEngine::getGnapWalkFacing(int deltaX, int deltaY) { + static const int _gnapWalkFacings[9] = { + 5, 3, 3, + 5, 0, 3, + 7, 1, 1 + }; + // CHECKME This is a little weird + return _gnapWalkFacings[3 * deltaX + 3 + 1 + deltaY]; +} + +bool GnapEngine::isPointBlocked(int gridX, int gridY) { + + if (gridX < 0 || gridX >= _gridMaxX || gridY < 0 || gridY >= _gridMaxY) + return true; + + if ((gridX == _gnapX && gridY == _gnapY) || (gridX == _platX && gridY == _platY)) + return true; + + const int x = _gridMinX + 75 * gridX; + const int y = _gridMinY + 48 * gridY; + + for (int i = 0; i < _hotspotsCount; ++i) { + if (x >= _hotspots[i].x1 && x <= _hotspots[i].x2 && + y >= _hotspots[i].y1 && y <= _hotspots[i].y2 && + !(_hotspots[i].flags & SF_WALKABLE)) + return true; + } + + return false; + +} + +bool GnapEngine::gridSub41F08B(int gridX, int gridY) { + bool result = false; + + _gnapWalkNodesCount = 0; + _gnapWalkDirXIncr = 0; + _gnapWalkDirYIncr = 0; + _gnapWalkDeltaX = ABS(_gnapWalkDestX - gridX); + _gnapWalkDeltaY = ABS(_gnapWalkDestY - gridY); + + if (_gnapWalkDeltaX) + _gnapWalkDirX = (_gnapWalkDestX - gridX) / _gnapWalkDeltaX; + else + _gnapWalkDirX = 0; + + if (_gnapWalkDeltaY) + _gnapWalkDirY = (_gnapWalkDestY - gridY) / _gnapWalkDeltaY; + else + _gnapWalkDirY = 0; + + while (_gnapWalkDirXIncr < _gnapWalkDeltaX && _gnapWalkDirYIncr < _gnapWalkDeltaY) { + _gnapWalkNodes[_gnapWalkNodesCount].gridX1 = gridX + _gnapWalkDirX * _gnapWalkDirXIncr; + _gnapWalkNodes[_gnapWalkNodesCount].gridY1 = gridY + _gnapWalkDirY * _gnapWalkDirYIncr; + if (!isPointBlocked(_gnapWalkDirX + _gnapWalkNodes[_gnapWalkNodesCount].gridX1, _gnapWalkDirY + _gnapWalkNodes[_gnapWalkNodesCount].gridY1)) { + _gnapWalkNodes[_gnapWalkNodesCount].deltaX = _gnapWalkDirX; + _gnapWalkNodes[_gnapWalkNodesCount].deltaY = _gnapWalkDirY; + ++_gnapWalkDirXIncr; + ++_gnapWalkDirYIncr; + } else if (_gnapWalkDeltaY - _gnapWalkDirYIncr > _gnapWalkDeltaX - _gnapWalkDirXIncr) { + if (!isPointBlocked(_gnapWalkNodes[_gnapWalkNodesCount].gridX1, _gnapWalkDirY + _gnapWalkNodes[_gnapWalkNodesCount].gridY1)) { + _gnapWalkNodes[_gnapWalkNodesCount].deltaX = 0; + _gnapWalkNodes[_gnapWalkNodesCount].deltaY = _gnapWalkDirY; + ++_gnapWalkDirYIncr; + } else if (!isPointBlocked(_gnapWalkDirX + _gnapWalkNodes[_gnapWalkNodesCount].gridX1, _gnapWalkNodes[_gnapWalkNodesCount].gridY1)) { + _gnapWalkNodes[_gnapWalkNodesCount].deltaX = _gnapWalkDirX; + _gnapWalkNodes[_gnapWalkNodesCount].deltaY = 0; + ++_gnapWalkDirXIncr; + } else { + _gnapWalkDeltaX = _gnapWalkDirXIncr; + _gnapWalkDeltaY = _gnapWalkDirYIncr; + --_gnapWalkNodesCount; + } + } else { + if (!isPointBlocked(_gnapWalkDirX + _gnapWalkNodes[_gnapWalkNodesCount].gridX1, _gnapWalkNodes[_gnapWalkNodesCount].gridY1)) { + _gnapWalkNodes[_gnapWalkNodesCount].deltaX = _gnapWalkDirX; + _gnapWalkNodes[_gnapWalkNodesCount].deltaY = 0; + ++_gnapWalkDirXIncr; + } else if (!isPointBlocked(_gnapWalkNodes[_gnapWalkNodesCount].gridX1, _gnapWalkDirY + _gnapWalkNodes[_gnapWalkNodesCount].gridY1)) { + _gnapWalkNodes[_gnapWalkNodesCount].deltaX = 0; + _gnapWalkNodes[_gnapWalkNodesCount].deltaY = _gnapWalkDirY; + ++_gnapWalkDirYIncr; + } else { + _gnapWalkDeltaX = _gnapWalkDirXIncr; + _gnapWalkDeltaY = _gnapWalkDirYIncr; + --_gnapWalkNodesCount; + } + } + ++_gnapWalkNodesCount; + } + + while (_gnapWalkDirXIncr < _gnapWalkDeltaX) { + _gnapWalkNodes[_gnapWalkNodesCount].gridX1 = gridX + _gnapWalkDirX * _gnapWalkDirXIncr; + _gnapWalkNodes[_gnapWalkNodesCount].gridY1 = _gnapWalkDestY; + if (!isPointBlocked(_gnapWalkDirX + _gnapWalkNodes[_gnapWalkNodesCount].gridX1, _gnapWalkDestY)) { + _gnapWalkNodes[_gnapWalkNodesCount].deltaX = _gnapWalkDirX; + _gnapWalkNodes[_gnapWalkNodesCount].deltaY = 0; + ++_gnapWalkDirXIncr; + ++_gnapWalkNodesCount; + } else { + _gnapWalkDeltaX = _gnapWalkDirXIncr; + } + } + + while (_gnapWalkDirYIncr < _gnapWalkDeltaY) { + _gnapWalkNodes[_gnapWalkNodesCount].gridX1 = _gnapWalkDestX; + _gnapWalkNodes[_gnapWalkNodesCount].gridY1 = gridY + _gnapWalkDirY * _gnapWalkDirYIncr; + if (!isPointBlocked(_gnapWalkDestX, _gnapWalkDirY + _gnapWalkNodes[_gnapWalkNodesCount].gridY1)) { + _gnapWalkNodes[_gnapWalkNodesCount].deltaX = 0; + _gnapWalkNodes[_gnapWalkNodesCount].deltaY = _gnapWalkDirY; + ++_gnapWalkDirYIncr; + ++_gnapWalkNodesCount; + } else { + _gnapWalkDeltaY = _gnapWalkDirYIncr; + } + } + + if (gridX + _gnapWalkDirX * _gnapWalkDirXIncr != _gnapWalkDestX || gridY + _gnapWalkDirY * _gnapWalkDirYIncr != _gnapWalkDestY) { + _gnapWalkDestX = gridX + _gnapWalkDirX * _gnapWalkDirXIncr; + _gnapWalkDestY = gridY + _gnapWalkDirY * _gnapWalkDirYIncr; + result = false; + } else { + result = true; + } + + return result; +} + +bool GnapEngine::gridSub41F5FC(int gridX, int gridY, int index) { + _gnapWalkNodesCount = index; + _gnapWalkDirXIncr = 0; + _gnapWalkDirYIncr = 0; + _gnapWalkDeltaX = ABS(_gnapWalkDestX - gridX); + _gnapWalkDeltaY = ABS(_gnapWalkDestY - gridY); + + if (_gnapWalkDeltaX) + _gnapWalkDirX = (_gnapWalkDestX - gridX) / _gnapWalkDeltaX; + else + _gnapWalkDirX = 0; + + if (_gnapWalkDeltaY) + _gnapWalkDirY = (_gnapWalkDestY - gridY) / _gnapWalkDeltaY; + else + _gnapWalkDirY = 0; + + while (_gnapWalkDirXIncr < _gnapWalkDeltaX && _gnapWalkDirYIncr < _gnapWalkDeltaY) { + _gnapWalkNodes[_gnapWalkNodesCount].gridX1 = gridX + _gnapWalkDirX * _gnapWalkDirXIncr; + _gnapWalkNodes[_gnapWalkNodesCount].gridY1 = gridY + _gnapWalkDirY * _gnapWalkDirYIncr; + if (!isPointBlocked(_gnapWalkDirX + _gnapWalkNodes[_gnapWalkNodesCount].gridX1, _gnapWalkDirY + _gnapWalkNodes[_gnapWalkNodesCount].gridY1)) { + _gnapWalkNodes[_gnapWalkNodesCount].deltaX = _gnapWalkDirX; + _gnapWalkNodes[_gnapWalkNodesCount].deltaY = _gnapWalkDirY; + ++_gnapWalkDirXIncr; + ++_gnapWalkDirYIncr; + } else if (_gnapWalkDeltaY - _gnapWalkDirYIncr > _gnapWalkDeltaX - _gnapWalkDirXIncr) { + if (!isPointBlocked(_gnapWalkNodes[_gnapWalkNodesCount].gridX1, _gnapWalkDirY + _gnapWalkNodes[_gnapWalkNodesCount].gridY1)) { + _gnapWalkNodes[_gnapWalkNodesCount].deltaX = 0; + _gnapWalkNodes[_gnapWalkNodesCount].deltaY = _gnapWalkDirY; + ++_gnapWalkDirYIncr; + } else if (!isPointBlocked(_gnapWalkDirX + _gnapWalkNodes[_gnapWalkNodesCount].gridX1, _gnapWalkNodes[_gnapWalkNodesCount].gridY1)) { + _gnapWalkNodes[_gnapWalkNodesCount].deltaX = _gnapWalkDirX; + _gnapWalkNodes[_gnapWalkNodesCount].deltaY = 0; + ++_gnapWalkDirXIncr; + } else + return false; + } else { + if (!isPointBlocked(_gnapWalkDirX + _gnapWalkNodes[_gnapWalkNodesCount].gridX1, _gnapWalkNodes[_gnapWalkNodesCount].gridY1)) { + _gnapWalkNodes[_gnapWalkNodesCount].deltaX = _gnapWalkDirX; + _gnapWalkNodes[_gnapWalkNodesCount].deltaY = 0; + ++_gnapWalkDirXIncr; + } else if (!isPointBlocked(_gnapWalkNodes[_gnapWalkNodesCount].gridX1, _gnapWalkDirY + _gnapWalkNodes[_gnapWalkNodesCount].gridY1)) { + _gnapWalkNodes[_gnapWalkNodesCount].deltaX = 0; + _gnapWalkNodes[_gnapWalkNodesCount].deltaY = _gnapWalkDirY; + ++_gnapWalkDirYIncr; + } else + return false; + } + ++_gnapWalkNodesCount; + } + + while (_gnapWalkDirXIncr < _gnapWalkDeltaX) { + _gnapWalkNodes[_gnapWalkNodesCount].gridX1 = gridX + _gnapWalkDirX * _gnapWalkDirXIncr; + _gnapWalkNodes[_gnapWalkNodesCount].gridY1 = _gnapWalkDestY; + if (!isPointBlocked(_gnapWalkDirX + _gnapWalkNodes[_gnapWalkNodesCount].gridX1, _gnapWalkDestY)) { + _gnapWalkNodes[_gnapWalkNodesCount].deltaX = _gnapWalkDirX; + _gnapWalkNodes[_gnapWalkNodesCount].deltaY = 0; + ++_gnapWalkDirXIncr; + ++_gnapWalkNodesCount; + } else + return false; + } + + while (_gnapWalkDirYIncr < _gnapWalkDeltaY) { + _gnapWalkNodes[_gnapWalkNodesCount].gridX1 = _gnapWalkDestX; + _gnapWalkNodes[_gnapWalkNodesCount].gridY1 = gridY + _gnapWalkDirY * _gnapWalkDirYIncr; + if (!isPointBlocked(_gnapWalkDestX, _gnapWalkDirY + _gnapWalkNodes[_gnapWalkNodesCount].gridY1)) { + _gnapWalkNodes[_gnapWalkNodesCount].deltaX = 0; + _gnapWalkNodes[_gnapWalkNodesCount].deltaY = _gnapWalkDirY; + ++_gnapWalkDirYIncr; + ++_gnapWalkNodesCount; + } else + return false; + } + + return true; +} + +bool GnapEngine::gridSub41FAD5(int gridX, int gridY, int index) { + _gnapWalkNodesCount = index; + _gnapWalkDirXIncr = 0; + _gnapWalkDirYIncr = 0; + _gnapWalkDeltaX = ABS(_gnapWalkDestX - gridX); + _gnapWalkDeltaY = ABS(_gnapWalkDestY - gridY); + + if (_gnapWalkDeltaX) + _gnapWalkDirX = (_gnapWalkDestX - gridX) / _gnapWalkDeltaX; + else + _gnapWalkDirX = 0; + + if (_gnapWalkDeltaY) + _gnapWalkDirY = (_gnapWalkDestY - gridY) / _gnapWalkDeltaY; + else + _gnapWalkDirY = 0; + + while (_gnapWalkDeltaY < _gnapWalkDeltaX - _gnapWalkDirXIncr) { + _gnapWalkNodes[_gnapWalkNodesCount].gridX1 = gridX + _gnapWalkDirX * _gnapWalkDirXIncr; + _gnapWalkNodes[_gnapWalkNodesCount].gridY1 = gridY; + if (!isPointBlocked(_gnapWalkDirX + _gnapWalkNodes[_gnapWalkNodesCount].gridX1, gridY)) { + _gnapWalkNodes[_gnapWalkNodesCount].deltaX = _gnapWalkDirX; + _gnapWalkNodes[_gnapWalkNodesCount].deltaY = 0; + ++_gnapWalkDirXIncr; + ++_gnapWalkNodesCount; + } else + return false; + } + + while (_gnapWalkDeltaX < _gnapWalkDeltaY - _gnapWalkDirYIncr) { + _gnapWalkNodes[_gnapWalkNodesCount].gridX1 = gridX; + _gnapWalkNodes[_gnapWalkNodesCount].gridY1 = gridY + _gnapWalkDirY * _gnapWalkDirYIncr; + if (!isPointBlocked(gridX, _gnapWalkDirY + _gnapWalkNodes[_gnapWalkNodesCount].gridY1)) { + _gnapWalkNodes[_gnapWalkNodesCount].deltaX = 0; + _gnapWalkNodes[_gnapWalkNodesCount].deltaY = _gnapWalkDirY; + ++_gnapWalkDirYIncr; + ++_gnapWalkNodesCount; + } else + return false; + } + + while (_gnapWalkDirXIncr < _gnapWalkDeltaX && _gnapWalkDirYIncr < _gnapWalkDeltaY) { + _gnapWalkNodes[_gnapWalkNodesCount].gridX1 = gridX + _gnapWalkDirX * _gnapWalkDirXIncr; + _gnapWalkNodes[_gnapWalkNodesCount].gridY1 = gridY + _gnapWalkDirY * _gnapWalkDirYIncr; + if (!isPointBlocked(_gnapWalkDirX + _gnapWalkNodes[_gnapWalkNodesCount].gridX1, _gnapWalkDirY + _gnapWalkNodes[_gnapWalkNodesCount].gridY1)) { + _gnapWalkNodes[_gnapWalkNodesCount].deltaX = _gnapWalkDirX; + _gnapWalkNodes[_gnapWalkNodesCount].deltaY = _gnapWalkDirY; + ++_gnapWalkDirXIncr; + ++_gnapWalkDirYIncr; + } else if (_gnapWalkDeltaY - _gnapWalkDirYIncr > _gnapWalkDeltaX - _gnapWalkDirXIncr) { + if (!isPointBlocked(_gnapWalkNodes[_gnapWalkNodesCount].gridX1, _gnapWalkDirY + _gnapWalkNodes[_gnapWalkNodesCount].gridY1)) { + _gnapWalkNodes[_gnapWalkNodesCount].deltaX = 0; + _gnapWalkNodes[_gnapWalkNodesCount].deltaY = _gnapWalkDirY; + ++_gnapWalkDirYIncr; + } else if (!isPointBlocked(_gnapWalkDirX + _gnapWalkNodes[_gnapWalkNodesCount].gridX1, _gnapWalkNodes[_gnapWalkNodesCount].gridY1)) { + _gnapWalkNodes[_gnapWalkNodesCount].deltaX = _gnapWalkDirX; + _gnapWalkNodes[_gnapWalkNodesCount].deltaY = 0; + ++_gnapWalkDirXIncr; + } else + return false; + } else { + if (!isPointBlocked(_gnapWalkDirX + _gnapWalkNodes[_gnapWalkNodesCount].gridX1, _gnapWalkNodes[_gnapWalkNodesCount].gridY1)) { + _gnapWalkNodes[_gnapWalkNodesCount].deltaX = _gnapWalkDirX; + _gnapWalkNodes[_gnapWalkNodesCount].deltaY = 0; + ++_gnapWalkDirXIncr; + } else if (!isPointBlocked(_gnapWalkNodes[_gnapWalkNodesCount].gridX1, _gnapWalkDirY + _gnapWalkNodes[_gnapWalkNodesCount].gridY1)) { + _gnapWalkNodes[_gnapWalkNodesCount].deltaX = 0; + _gnapWalkNodes[_gnapWalkNodesCount].deltaY = _gnapWalkDirY; + ++_gnapWalkDirYIncr; + } else + return false; + } + ++_gnapWalkNodesCount; + } + + while (_gnapWalkDirXIncr < _gnapWalkDeltaX) { + _gnapWalkNodes[_gnapWalkNodesCount].gridX1 = gridX + _gnapWalkDirX * _gnapWalkDirXIncr; + _gnapWalkNodes[_gnapWalkNodesCount].gridY1 = _gnapWalkDestY; + if (!isPointBlocked(_gnapWalkDirX + _gnapWalkNodes[_gnapWalkNodesCount].gridX1, _gnapWalkDestY)) { + _gnapWalkNodes[_gnapWalkNodesCount].deltaX = _gnapWalkDirX; + _gnapWalkNodes[_gnapWalkNodesCount].deltaY = 0; + ++_gnapWalkDirXIncr; + ++_gnapWalkNodesCount; + } else + return false; + } + + while (_gnapWalkDirYIncr < _gnapWalkDeltaY) { + _gnapWalkNodes[_gnapWalkNodesCount].gridX1 = _gnapWalkDestX; + _gnapWalkNodes[_gnapWalkNodesCount].gridY1 = gridY + _gnapWalkDirY * _gnapWalkDirYIncr; + if (!isPointBlocked(_gnapWalkDestX, _gnapWalkDirY + _gnapWalkNodes[_gnapWalkNodesCount].gridY1)) { + _gnapWalkNodes[_gnapWalkNodesCount].deltaX = 0; + _gnapWalkNodes[_gnapWalkNodesCount].deltaY = _gnapWalkDirY; + ++_gnapWalkDirYIncr; + ++_gnapWalkNodesCount; + } else + return false; + } + + return true; +} + +bool GnapEngine::gnapFindPath3(int gridX, int gridY) { + int gridIncr = 1; + bool done = false; + + while (!done && gridIncr < _gridMaxX) { + if (!isPointBlocked(gridX + gridIncr, gridY) && gridSub41F5FC(gridX + gridIncr, gridY, gridIncr)) { + for (int i = 0; i < gridIncr; ++i) { + _gnapWalkNodes[i].gridX1 = gridX + i; + _gnapWalkNodes[i].gridY1 = gridY; + _gnapWalkNodes[i].deltaX = 1; + _gnapWalkNodes[i].deltaY = 0; + } + done = true; + break; + } + if (!isPointBlocked(gridX - gridIncr, gridY) && gridSub41F5FC(gridX - gridIncr, gridY, gridIncr)) { + for (int i = 0; i < gridIncr; ++i) { + _gnapWalkNodes[i].gridX1 = gridX - i; + _gnapWalkNodes[i].gridY1 = gridY; + _gnapWalkNodes[i].deltaX = -1; + _gnapWalkNodes[i].deltaY = 0; + } + done = true; + break; + } + if (!isPointBlocked(gridX, gridY + gridIncr) && gridSub41F5FC(gridX, gridY + gridIncr, gridIncr)) { + for (int i = 0; i < gridIncr; ++i) { + _gnapWalkNodes[i].gridX1 = gridX; + _gnapWalkNodes[i].gridY1 = gridY + i; + _gnapWalkNodes[i].deltaX = 0; + _gnapWalkNodes[i].deltaY = 1; + } + done = true; + break; + } + if (!isPointBlocked(gridX, gridY - gridIncr) && gridSub41F5FC(gridX, gridY - gridIncr, gridIncr)) { + for (int i = 0; i < gridIncr; ++i) { + _gnapWalkNodes[i].gridX1 = gridX; + _gnapWalkNodes[i].gridY1 = gridY - i; + _gnapWalkNodes[i].deltaX = 0; + _gnapWalkNodes[i].deltaY = -1; + } + done = true; + break; + } + if (!isPointBlocked(gridX + gridIncr, gridY + gridIncr) && gridSub41F5FC(gridX + gridIncr, gridY + gridIncr, gridIncr)) { + for (int i = 0; i < gridIncr; ++i) { + _gnapWalkNodes[i].gridX1 = gridX + i; + _gnapWalkNodes[i].gridY1 = gridY + i; + _gnapWalkNodes[i].deltaX = 1; + _gnapWalkNodes[i].deltaY = 1; + } + done = true; + break; + } + if (!isPointBlocked(gridX - gridIncr, gridY + gridIncr) && gridSub41F5FC(gridX - gridIncr, gridY + gridIncr, gridIncr)) { + for (int i = 0; i < gridIncr; ++i) { + _gnapWalkNodes[i].gridX1 = gridX - i; + _gnapWalkNodes[i].gridY1 = gridY + i; + _gnapWalkNodes[i].deltaX = -1; + _gnapWalkNodes[i].deltaY = 1; + } + done = true; + break; + } + if (!isPointBlocked(gridX + gridIncr, gridY - gridIncr) && gridSub41F5FC(gridX + gridIncr, gridY - gridIncr, gridIncr)) { + for (int i = 0; i < gridIncr; ++i) { + _gnapWalkNodes[i].gridX1 = gridX + i; + _gnapWalkNodes[i].gridY1 = gridY - i; + _gnapWalkNodes[i].deltaX = 1; + _gnapWalkNodes[i].deltaY = -1; + } + done = true; + break; + } + if (!isPointBlocked(gridX - gridIncr, gridY - gridIncr) && gridSub41F5FC(gridX - gridIncr, gridY - gridIncr, gridIncr)) { + for (int i = 0; i < gridIncr; ++i) { + _gnapWalkNodes[i].gridX1 = gridX - i; + _gnapWalkNodes[i].gridY1 = gridY - i; + _gnapWalkNodes[i].deltaX = -1; + _gnapWalkNodes[i].deltaY = -1; + } + done = true; + break; + } + if (!isPointBlocked(gridX + gridIncr, gridY) && gridSub41FAD5(gridX + gridIncr, gridY, gridIncr)) { + for (int i = 0; i < gridIncr; ++i) { + _gnapWalkNodes[i].gridX1 = gridX + i; + _gnapWalkNodes[i].gridY1 = gridY; + _gnapWalkNodes[i].deltaX = 1; + _gnapWalkNodes[i].deltaY = 0; + } + done = true; + break; + } + if (!isPointBlocked(gridX - gridIncr, gridY) && gridSub41FAD5(gridX - gridIncr, gridY, gridIncr)) { + for (int i = 0; i < gridIncr; ++i) { + _gnapWalkNodes[i].gridX1 = gridX - i; + _gnapWalkNodes[i].gridY1 = gridY; + _gnapWalkNodes[i].deltaX = -1; + _gnapWalkNodes[i].deltaY = 0; + } + done = true; + break; + } + if (!isPointBlocked(gridX, gridY + gridIncr) && gridSub41FAD5(gridX, gridY + gridIncr, gridIncr)) { + for (int i = 0; i < gridIncr; ++i) { + _gnapWalkNodes[i].gridX1 = gridX; + _gnapWalkNodes[i].gridY1 = gridY + i; + _gnapWalkNodes[i].deltaX = 0; + _gnapWalkNodes[i].deltaY = 1; + } + done = true; + break; + } + if (!isPointBlocked(gridX, gridY - gridIncr) && gridSub41FAD5(gridX, gridY - gridIncr, gridIncr)) { + for (int i = 0; i < gridIncr; ++i) { + _gnapWalkNodes[i].gridX1 = gridX; + _gnapWalkNodes[i].gridY1 = gridY - i; + _gnapWalkNodes[i].deltaX = 0; + _gnapWalkNodes[i].deltaY = -1; + } + done = true; + break; + } + if (!isPointBlocked(gridX + gridIncr, gridY + gridIncr) && gridSub41FAD5(gridX + gridIncr, gridY + gridIncr, gridIncr)) { + for (int i = 0; i < gridIncr; ++i) { + _gnapWalkNodes[i].gridX1 = gridX + i; + _gnapWalkNodes[i].gridY1 = gridY + i; + _gnapWalkNodes[i].deltaX = 1; + _gnapWalkNodes[i].deltaY = 1; + } + done = true; + break; + } + if (!isPointBlocked(gridX - gridIncr, gridY + gridIncr) && gridSub41FAD5(gridX - gridIncr, gridY + gridIncr, gridIncr)) { + for (int i = 0; i < gridIncr; ++i) { + _gnapWalkNodes[i].gridX1 = gridX - i; + _gnapWalkNodes[i].gridY1 = gridY + i; + _gnapWalkNodes[i].deltaX = -1; + _gnapWalkNodes[i].deltaY = 1; + } + done = true; + break; + } + if (!isPointBlocked(gridX + gridIncr, gridY - gridIncr) && gridSub41FAD5(gridX + gridIncr, gridY - gridIncr, gridIncr)) { + for (int i = 0; i < gridIncr; ++i) { + _gnapWalkNodes[i].gridX1 = gridX + i; + _gnapWalkNodes[i].gridY1 = gridY - i; + _gnapWalkNodes[i].deltaX = 1; + _gnapWalkNodes[i].deltaY = -1; + } + done = true; + break; + } + if (!isPointBlocked(gridX - gridIncr, gridY - gridIncr) && gridSub41FAD5(gridX - gridIncr, gridY - gridIncr, gridIncr)) { + for (int i = 0; i < gridIncr; ++i) { + _gnapWalkNodes[i].gridX1 = gridX - i; + _gnapWalkNodes[i].gridY1 = gridY - i; + _gnapWalkNodes[i].deltaX = -1; + _gnapWalkNodes[i].deltaY = -1; + } + done = true; + break; + } + ++gridIncr; + } + + return done; +} + +bool GnapEngine::gnapWalkTo(int gridX, int gridY, int animationIndex, int sequenceId, int flags) { + + int datNum = flags & 3; + bool done = false; + + _timers[2] = 200; + _timers[3] = 300; + + if (gridX < 0) + gridX = (_leftClickMouseX - _gridMinX + 37) / 75; + + if (gridY < 0) + gridY = (_leftClickMouseY - _gridMinY + 24) / 48; + + _gnapWalkDestX = CLIP(gridX, 0, _gridMaxX - 1); + _gnapWalkDestY = CLIP(gridY, 0, _gridMaxY - 1); + + if (animationIndex >= 0 && _gnapWalkDestX == _platX && _gnapWalkDestY == _platY) + beaverMakeRoom(); + + if (gridSub41F5FC(_gnapX, _gnapY, 0)) + done = true; + + if (!done && gridSub41FAD5(_gnapX, _gnapY, 0)) + done = true; + + if (!done && gnapFindPath3(_gnapX, _gnapY)) + done = true; + + if (!done && gridSub41F08B(_gnapX, _gnapY)) + done = true; + + gnapIdle(); + + int gnapSequenceId = _gnapSequenceId; + int gnapId = _gnapId; + int gnapSequenceDatNum = _gnapSequenceDatNum; + + debug(0, "_gnapWalkNodesCount: %d", _gnapWalkNodesCount); + + for (int index = 0; index < _gnapWalkNodesCount; ++index) { + _gnapWalkNodes[index].id = index + 20 * _gnapWalkNodes[index].gridY1; + if (_gnapWalkNodes[index].deltaX == 1 && _gnapWalkNodes[index].deltaY == 0) { + if (index % 2) { + _gameSys->insertSequence(makeRid(datNum, 0x7AB), _gnapWalkNodes[index].id, + makeRid(gnapSequenceDatNum, gnapSequenceId), gnapId, + 9, 0, 75 * _gnapWalkNodes[index].gridX1 - _gnapGridX, 48 * _gnapWalkNodes[index].gridY1 - _gnapGridY); + _gnapWalkNodes[index].sequenceId = 0x7AB; + gnapSequenceId = 0x7AB; + } else { + _gameSys->insertSequence(makeRid(datNum, 0x7AC), _gnapWalkNodes[index].id, + makeRid(gnapSequenceDatNum, gnapSequenceId), gnapId, + 9, 0, 75 * _gnapWalkNodes[index].gridX1 - _gnapGridX, 48 * _gnapWalkNodes[index].gridY1 - _gnapGridY); + _gnapWalkNodes[index].sequenceId = 0x7AC; + gnapSequenceId = 0x7AC; + } + } else if (_gnapWalkNodes[index].deltaX == -1 && _gnapWalkNodes[index].deltaY == 0) { + if (index % 2) { + _gameSys->insertSequence(makeRid(datNum, 0x7AF), _gnapWalkNodes[index].id, + makeRid(gnapSequenceDatNum, gnapSequenceId), gnapId, + 9, 0, 75 * _gnapWalkNodes[index].gridX1 - _gnapGridX, 48 * _gnapWalkNodes[index].gridY1 - _gnapGridY); + _gnapWalkNodes[index].sequenceId = 0x7AF; + gnapSequenceId = 0x7AF; + } else { + _gameSys->insertSequence(makeRid(datNum, 0x7B0), _gnapWalkNodes[index].id, + makeRid(gnapSequenceDatNum, gnapSequenceId), gnapId, + 9, 0, 75 * _gnapWalkNodes[index].gridX1 - _gnapGridX, 48 * _gnapWalkNodes[index].gridY1 - _gnapGridY); + _gnapWalkNodes[index].sequenceId = 0x7B0; + gnapSequenceId = 0x7B0; + } + } else { + if (_gnapWalkNodes[index].deltaY == -1) + _gnapWalkNodes[index].id -= 10; + else + _gnapWalkNodes[index].id += 10; + int newSequenceId = getGnapWalkSequenceId(_gnapWalkNodes[index].deltaX, _gnapWalkNodes[index].deltaY); + _gameSys->insertSequence(makeRid(datNum, newSequenceId), _gnapWalkNodes[index].id, + makeRid(gnapSequenceDatNum, gnapSequenceId), gnapId, + 9, 0, 75 * _gnapWalkNodes[index].gridX1 - _gnapGridX, 48 * _gnapWalkNodes[index].gridY1 - _gnapGridY); + _gnapWalkNodes[index].sequenceId = newSequenceId; + gnapSequenceId = newSequenceId; + } + gnapId = _gnapWalkNodes[index].id; + gnapSequenceDatNum = datNum; + } + + if (flags & 8) { + if (_gnapWalkNodesCount > 0) { + _gnapSequenceId = gnapSequenceId; + _gnapId = gnapId; + _gnapIdleFacing = getGnapWalkFacing(_gnapWalkNodes[_gnapWalkNodesCount - 1].deltaX, _gnapWalkNodes[_gnapWalkNodesCount - 1].deltaY); + _gnapSequenceDatNum = datNum; + if (animationIndex >= 0) + _gameSys->setAnimation(makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, animationIndex); + } else if (animationIndex >= 0) { + _gameSys->setAnimation(0x107D3, 1, animationIndex); + _gameSys->insertSequence(0x107D3, 1, 0, 0, 0, 0, 0, 0); + } + } else { + if (sequenceId >= 0 && sequenceId != -1) { + _gnapSequenceId = ridToEntryIndex(sequenceId); + _gnapSequenceDatNum = ridToDatIndex(sequenceId); + if (_gnapSequenceId == 0x7B9) { + _gnapIdleFacing = 1; + } else { + switch (_gnapSequenceId) { + case 0x7BA: + _gnapIdleFacing = 3; + break; + case 0x7BB: + _gnapIdleFacing = 7; + break; + case 0x7BC: + _gnapIdleFacing = 5; + break; + } + } + } else { + if (_gnapWalkNodesCount > 0) { + _gnapSequenceId = getGnapWalkStopSequenceId(_gnapWalkNodes[_gnapWalkNodesCount - 1].deltaX, _gnapWalkNodes[_gnapWalkNodesCount - 1].deltaY); + _gnapIdleFacing = getGnapWalkFacing(_gnapWalkNodes[_gnapWalkNodesCount - 1].deltaX, _gnapWalkNodes[_gnapWalkNodesCount - 1].deltaY); + } else if (gridX >= 0 || gridY >= 0) { + switch (_gnapIdleFacing) { + case 1: + _gnapSequenceId = 0x7B9; + break; + case 3: + _gnapSequenceId = 0x7BA; + break; + case 7: + _gnapSequenceId = 0x7BB; + break; + default: + _gnapSequenceId = 0x7BC; + break; + } + } else { + int v10 = _leftClickMouseX - (_gridMinX + 75 * _gnapX); + int v11 = _leftClickMouseY - (_gridMinY + 48 * _gnapY); + if (_leftClickMouseX == _gridMinX + 75 * _gnapX) + ++v10; + if (_leftClickMouseY == _gridMinY + 48 * _gnapY) + v11 = 1; + _gnapSequenceId = getGnapWalkStopSequenceId(v10 / abs(v10), v11 / abs(v11)); + _gnapIdleFacing = getGnapWalkFacing(v10 / abs(v10), v11 / abs(v11)); + } + _gnapSequenceDatNum = datNum; + } + + if (animationIndex < 0) { + _gnapId = 20 * _gnapWalkDestY + 1; + } else { + _gnapId = _gnapWalkNodesCount + animationIndex + 20 * _gnapWalkDestY; + _gameSys->setAnimation(makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapWalkNodesCount + animationIndex + 20 * _gnapWalkDestY, animationIndex); + } + + if (flags & 4) { + _gameSys->insertSequence(makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, + makeRid(gnapSequenceDatNum, gnapSequenceId), gnapId, + 9, 0, 0, 0); + } else { + _gameSys->insertSequence(makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, + makeRid(gnapSequenceDatNum, gnapSequenceId), gnapId, + 9, 0, 75 * _gnapWalkDestX - _gnapGridX, 48 * _gnapWalkDestY - _gnapGridY); + } + + } + + _gnapX = _gnapWalkDestX; + _gnapY = _gnapWalkDestY; + + return done; +} + +void GnapEngine::gnapWalkStep() { + bool done = false; + for (int i = 1; i < _gridMaxX && !done; ++i) { + done = true; + if (!isPointBlocked(_gnapX + i, _gnapY)) + gnapWalkTo(_gnapX + i, _gnapY, -1, -1, 1); + else if (!isPointBlocked(_gnapX - i, _gnapY)) + gnapWalkTo(_gnapX - i, _gnapY, -1, -1, 1); + else if (!isPointBlocked(_gnapX, _gnapY + 1)) + gnapWalkTo(_gnapX, _gnapY + 1, -1, -1, 1); + else if (!isPointBlocked(_gnapX, _gnapY - 1)) + gnapWalkTo(_gnapX, _gnapY - 1, -1, -1, 1); + else if (!isPointBlocked(_gnapX + 1, _gnapY + 1)) + gnapWalkTo(_gnapX + 1, _gnapY + 1, -1, -1, 1); + else if (!isPointBlocked(_gnapX - 1, _gnapY + 1)) + gnapWalkTo(_gnapX - 1, _gnapY + 1, -1, -1, 1); + else if (!isPointBlocked(_gnapX + 1, _gnapY - 1)) + gnapWalkTo(_gnapX + 1, _gnapY - 1, -1, -1, 1); + else if (!isPointBlocked(_gnapX - 1, _gnapY - 1)) + gnapWalkTo(_gnapX - 1, _gnapY - 1, -1, -1, 1); + else + done = false; + } +} + +//////////////////////////////////////////////////////////////////////////////// + +int GnapEngine::getBeaverWalkSequenceId(int deltaX, int deltaY) { + static const int _beaverWalkSequenceIds[9] = { + 0x7C5, 0x000, 0x7C8, + 0x7C4, 0x000, 0x7C7, + 0x7C3, 0x000, 0x7C6 + }; + // CHECKME This is a little weird + return _beaverWalkSequenceIds[3 * deltaX + 3 + 1 + deltaY]; +} + +bool GnapEngine::gridSub423750(int gridX, int gridY) { + bool result = false; + + _platWalkNodesCount = 0; + _platWalkDirXIncr = 0; + _platWalkDirYIncr = 0; + _platWalkDeltaX = ABS(_platWalkDestX - gridX); + _platWalkDeltaY = ABS(_platWalkDestY - gridY); + + if (_platWalkDeltaX) + _platWalkDirX = (_platWalkDestX - gridX) / _platWalkDeltaX; + else + _platWalkDirX = 0; + + if (_platWalkDeltaY) + _platWalkDirY = (_platWalkDestY - gridY) / _platWalkDeltaY; + else + _platWalkDirY = 0; + + while (_platWalkDirXIncr < _platWalkDeltaX && _platWalkDirYIncr < _platWalkDeltaY) { + _platWalkNodes[_platWalkNodesCount].gridX1 = gridX + _platWalkDirX * _platWalkDirXIncr; + _platWalkNodes[_platWalkNodesCount].gridY1 = gridY + _platWalkDirY * _platWalkDirYIncr; + if (!isPointBlocked(_platWalkDirX + _platWalkNodes[_platWalkNodesCount].gridX1, _platWalkDirY + _platWalkNodes[_platWalkNodesCount].gridY1)) { + _platWalkNodes[_platWalkNodesCount].deltaX = _platWalkDirX; + _platWalkNodes[_platWalkNodesCount].deltaY = _platWalkDirY; + ++_platWalkDirXIncr; + ++_platWalkDirYIncr; + } else if (_platWalkDeltaY - _platWalkDirYIncr > _platWalkDeltaX - _platWalkDirXIncr) { + if (!isPointBlocked(_platWalkNodes[_platWalkNodesCount].gridX1, _platWalkDirY + _platWalkNodes[_platWalkNodesCount].gridY1)) { + _platWalkNodes[_platWalkNodesCount].deltaX = 0; + _platWalkNodes[_platWalkNodesCount].deltaY = _platWalkDirY; + ++_platWalkDirYIncr; + } else if (!isPointBlocked(_platWalkDirX + _platWalkNodes[_platWalkNodesCount].gridX1, _platWalkNodes[_platWalkNodesCount].gridY1)) { + _platWalkNodes[_platWalkNodesCount].deltaX = _platWalkDirX; + _platWalkNodes[_platWalkNodesCount].deltaY = 0; + ++_platWalkDirXIncr; + } else { + _platWalkDeltaX = _platWalkDirXIncr; + _platWalkDeltaY = _platWalkDirYIncr; + --_platWalkNodesCount; + } + } else { + if (!isPointBlocked(_platWalkDirX + _platWalkNodes[_platWalkNodesCount].gridX1, _platWalkNodes[_platWalkNodesCount].gridY1)) { + _platWalkNodes[_platWalkNodesCount].deltaX = _platWalkDirX; + _platWalkNodes[_platWalkNodesCount].deltaY = 0; + ++_platWalkDirXIncr; + } else if (!isPointBlocked(_platWalkNodes[_platWalkNodesCount].gridX1, _platWalkDirY + _platWalkNodes[_platWalkNodesCount].gridY1)) { + _platWalkNodes[_platWalkNodesCount].deltaX = 0; + _platWalkNodes[_platWalkNodesCount].deltaY = _platWalkDirY; + ++_platWalkDirYIncr; + } else { + _platWalkDeltaX = _platWalkDirXIncr; + _platWalkDeltaY = _platWalkDirYIncr; + --_platWalkNodesCount; + } + } + ++_platWalkNodesCount; + } + + while (_platWalkDirXIncr < _platWalkDeltaX) { + _platWalkNodes[_platWalkNodesCount].gridX1 = gridX + _platWalkDirX * _platWalkDirXIncr; + _platWalkNodes[_platWalkNodesCount].gridY1 = _platWalkDestY; + if (!isPointBlocked(_platWalkDirX + _platWalkNodes[_platWalkNodesCount].gridX1, _platWalkDestY)) { + _platWalkNodes[_platWalkNodesCount].deltaX = _platWalkDirX; + _platWalkNodes[_platWalkNodesCount].deltaY = 0; + ++_platWalkDirXIncr; + ++_platWalkNodesCount; + } else { + _platWalkDeltaX = _platWalkDirXIncr; + } + } + + while (_platWalkDirYIncr < _platWalkDeltaY) { + _platWalkNodes[_platWalkNodesCount].gridX1 = _platWalkDestX; + _platWalkNodes[_platWalkNodesCount].gridY1 = gridY + _platWalkDirY * _platWalkDirYIncr; + if (!isPointBlocked(_platWalkDestX, _platWalkDirY + _platWalkNodes[_platWalkNodesCount].gridY1)) { + _platWalkNodes[_platWalkNodesCount].deltaX = 0; + _platWalkNodes[_platWalkNodesCount].deltaY = _platWalkDirY; + ++_platWalkDirYIncr; + ++_platWalkNodesCount; + } else { + _platWalkDeltaY = _platWalkDirYIncr; + } + } + + if (gridX + _platWalkDirX * _platWalkDirXIncr != _platWalkDestX || gridY + _platWalkDirY * _platWalkDirYIncr != _platWalkDestY) { + _platWalkDestX = gridX + _platWalkDirX * _platWalkDirXIncr; + _platWalkDestY = gridY + _platWalkDirY * _platWalkDirYIncr; + result = false; + } else { + result = true; + } + + return result; +} + +bool GnapEngine::gridSub423CC1(int gridX, int gridY, int index) { + _platWalkNodesCount = index; + _platWalkDirXIncr = 0; + _platWalkDirYIncr = 0; + _platWalkDeltaX = ABS(_platWalkDestX - gridX); + _platWalkDeltaY = ABS(_platWalkDestY - gridY); + + if (_platWalkDeltaX) + _platWalkDirX = (_platWalkDestX - gridX) / _platWalkDeltaX; + else + _platWalkDirX = 0; + + if (_platWalkDeltaY) + _platWalkDirY = (_platWalkDestY - gridY) / _platWalkDeltaY; + else + _platWalkDirY = 0; + + while (_platWalkDirXIncr < _platWalkDeltaX && _platWalkDirYIncr < _platWalkDeltaY) { + _platWalkNodes[_platWalkNodesCount].gridX1 = gridX + _platWalkDirX * _platWalkDirXIncr; + _platWalkNodes[_platWalkNodesCount].gridY1 = gridY + _platWalkDirY * _platWalkDirYIncr; + if (!isPointBlocked(_platWalkDirX + _platWalkNodes[_platWalkNodesCount].gridX1, _platWalkDirY + _platWalkNodes[_platWalkNodesCount].gridY1)) { + _platWalkNodes[_platWalkNodesCount].deltaX = _platWalkDirX; + _platWalkNodes[_platWalkNodesCount].deltaY = _platWalkDirY; + ++_platWalkDirXIncr; + ++_platWalkDirYIncr; + } else if (_platWalkDeltaY - _platWalkDirYIncr > _platWalkDeltaX - _platWalkDirXIncr) { + if (!isPointBlocked(_platWalkNodes[_platWalkNodesCount].gridX1, _platWalkDirY + _platWalkNodes[_platWalkNodesCount].gridY1)) { + _platWalkNodes[_platWalkNodesCount].deltaX = 0; + _platWalkNodes[_platWalkNodesCount].deltaY = _platWalkDirY; + ++_platWalkDirYIncr; + } else if (!isPointBlocked(_platWalkDirX + _platWalkNodes[_platWalkNodesCount].gridX1, _platWalkNodes[_platWalkNodesCount].gridY1)) { + _platWalkNodes[_platWalkNodesCount].deltaX = _platWalkDirX; + _platWalkNodes[_platWalkNodesCount].deltaY = 0; + ++_platWalkDirXIncr; + } else + return false; + } else { + if (!isPointBlocked(_platWalkDirX + _platWalkNodes[_platWalkNodesCount].gridX1, _platWalkNodes[_platWalkNodesCount].gridY1)) { + _platWalkNodes[_platWalkNodesCount].deltaX = _platWalkDirX; + _platWalkNodes[_platWalkNodesCount].deltaY = 0; + ++_platWalkDirXIncr; + } else if (!isPointBlocked(_platWalkNodes[_platWalkNodesCount].gridX1, _platWalkDirY + _platWalkNodes[_platWalkNodesCount].gridY1)) { + _platWalkNodes[_platWalkNodesCount].deltaX = 0; + _platWalkNodes[_platWalkNodesCount].deltaY = _platWalkDirY; + ++_platWalkDirYIncr; + } else + return false; + } + ++_platWalkNodesCount; + } + + while (_platWalkDirXIncr < _platWalkDeltaX) { + _platWalkNodes[_platWalkNodesCount].gridX1 = gridX + _platWalkDirX * _platWalkDirXIncr; + _platWalkNodes[_platWalkNodesCount].gridY1 = _platWalkDestY; + if (!isPointBlocked(_platWalkDirX + _platWalkNodes[_platWalkNodesCount].gridX1, _platWalkDestY)) { + _platWalkNodes[_platWalkNodesCount].deltaX = _platWalkDirX; + _platWalkNodes[_platWalkNodesCount].deltaY = 0; + ++_platWalkDirXIncr; + ++_platWalkNodesCount; + } else + return false; + } + + while (_platWalkDirYIncr < _platWalkDeltaY) { + _platWalkNodes[_platWalkNodesCount].gridX1 = _platWalkDestX; + _platWalkNodes[_platWalkNodesCount].gridY1 = gridY + _platWalkDirY * _platWalkDirYIncr; + if (!isPointBlocked(_platWalkDestX, _platWalkDirY + _platWalkNodes[_platWalkNodesCount].gridY1)) { + _platWalkNodes[_platWalkNodesCount].deltaX = 0; + _platWalkNodes[_platWalkNodesCount].deltaY = _platWalkDirY; + ++_platWalkDirYIncr; + ++_platWalkNodesCount; + } else + return false; + } + + return true; +} + +bool GnapEngine::gridSub42419A(int gridX, int gridY, int index) { + _platWalkNodesCount = index; + _platWalkDirXIncr = 0; + _platWalkDirYIncr = 0; + _platWalkDeltaX = ABS(_platWalkDestX - gridX); + _platWalkDeltaY = ABS(_platWalkDestY - gridY); + + if (_platWalkDeltaX) + _platWalkDirX = (_platWalkDestX - gridX) / _platWalkDeltaX; + else + _platWalkDirX = 0; + + if (_platWalkDeltaY) + _platWalkDirY = (_platWalkDestY - gridY) / _platWalkDeltaY; + else + _platWalkDirY = 0; + + while (_platWalkDeltaY < _platWalkDeltaX - _platWalkDirXIncr) { + _platWalkNodes[_platWalkNodesCount].gridX1 = gridX + _platWalkDirX * _platWalkDirXIncr; + _platWalkNodes[_platWalkNodesCount].gridY1 = gridY; + if (!isPointBlocked(_platWalkDirX + _platWalkNodes[_platWalkNodesCount].gridX1, gridY)) { + _platWalkNodes[_platWalkNodesCount].deltaX = _platWalkDirX; + _platWalkNodes[_platWalkNodesCount].deltaY = 0; + ++_platWalkDirXIncr; + ++_platWalkNodesCount; + } else + return false; + } + + while (_platWalkDeltaX < _platWalkDeltaY - _platWalkDirYIncr) { + _platWalkNodes[_platWalkNodesCount].gridX1 = gridX; + _platWalkNodes[_platWalkNodesCount].gridY1 = gridY + _platWalkDirY * _platWalkDirYIncr; + if (!isPointBlocked(gridX, _platWalkDirY + _platWalkNodes[_platWalkNodesCount].gridY1)) { + _platWalkNodes[_platWalkNodesCount].deltaX = 0; + _platWalkNodes[_platWalkNodesCount].deltaY = _platWalkDirY; + ++_platWalkDirYIncr; + ++_platWalkNodesCount; + } else + return false; + } + + while (_platWalkDirXIncr < _platWalkDeltaX && _platWalkDirYIncr < _platWalkDeltaY) { + _platWalkNodes[_platWalkNodesCount].gridX1 = gridX + _platWalkDirX * _platWalkDirXIncr; + _platWalkNodes[_platWalkNodesCount].gridY1 = gridY + _platWalkDirY * _platWalkDirYIncr; + if (!isPointBlocked(_platWalkDirX + _platWalkNodes[_platWalkNodesCount].gridX1, _platWalkDirY + _platWalkNodes[_platWalkNodesCount].gridY1)) { + _platWalkNodes[_platWalkNodesCount].deltaX = _platWalkDirX; + _platWalkNodes[_platWalkNodesCount].deltaY = _platWalkDirY; + ++_platWalkDirXIncr; + ++_platWalkDirYIncr; + } else if (_platWalkDeltaY - _platWalkDirYIncr > _platWalkDeltaX - _platWalkDirXIncr) { + if (!isPointBlocked(_platWalkNodes[_platWalkNodesCount].gridX1, _platWalkDirY + _platWalkNodes[_platWalkNodesCount].gridY1)) { + _platWalkNodes[_platWalkNodesCount].deltaX = 0; + _platWalkNodes[_platWalkNodesCount].deltaY = _platWalkDirY; + ++_platWalkDirYIncr; + } else if (!isPointBlocked(_platWalkDirX + _platWalkNodes[_platWalkNodesCount].gridX1, _platWalkNodes[_platWalkNodesCount].gridY1)) { + _platWalkNodes[_platWalkNodesCount].deltaX = _platWalkDirX; + _platWalkNodes[_platWalkNodesCount].deltaY = 0; + ++_platWalkDirXIncr; + } else + return false; + } else { + if (!isPointBlocked(_platWalkDirX + _platWalkNodes[_platWalkNodesCount].gridX1, _platWalkNodes[_platWalkNodesCount].gridY1)) { + _platWalkNodes[_platWalkNodesCount].deltaX = _platWalkDirX; + _platWalkNodes[_platWalkNodesCount].deltaY = 0; + ++_platWalkDirXIncr; + } else if (!isPointBlocked(_platWalkNodes[_platWalkNodesCount].gridX1, _platWalkDirY + _platWalkNodes[_platWalkNodesCount].gridY1)) { + _platWalkNodes[_platWalkNodesCount].deltaX = 0; + _platWalkNodes[_platWalkNodesCount].deltaY = _platWalkDirY; + ++_platWalkDirYIncr; + } else + return false; + } + ++_platWalkNodesCount; + } + + while (_platWalkDirXIncr < _platWalkDeltaX) { + _platWalkNodes[_platWalkNodesCount].gridX1 = gridX + _platWalkDirX * _platWalkDirXIncr; + _platWalkNodes[_platWalkNodesCount].gridY1 = _platWalkDestY; + if (!isPointBlocked(_platWalkDirX + _platWalkNodes[_platWalkNodesCount].gridX1, _platWalkDestY)) { + _platWalkNodes[_platWalkNodesCount].deltaX = _platWalkDirX; + _platWalkNodes[_platWalkNodesCount].deltaY = 0; + ++_platWalkDirXIncr; + ++_platWalkNodesCount; + } else + return false; + } + + while (_platWalkDirYIncr < _platWalkDeltaY) { + _platWalkNodes[_platWalkNodesCount].gridX1 = _platWalkDestX; + _platWalkNodes[_platWalkNodesCount].gridY1 = gridY + _platWalkDirY * _platWalkDirYIncr; + if (!isPointBlocked(_platWalkDestX, _platWalkDirY + _platWalkNodes[_platWalkNodesCount].gridY1)) { + _platWalkNodes[_platWalkNodesCount].deltaX = 0; + _platWalkNodes[_platWalkNodesCount].deltaY = _platWalkDirY; + ++_platWalkDirYIncr; + ++_platWalkNodesCount; + } else + return false; + } + + return true; +} + +bool GnapEngine::platFindPath3(int gridX, int gridY) { + int gridIncr = 1; + bool done = false; + + while (!done && gridIncr < _gridMaxX) { + if (!isPointBlocked(_platX + gridIncr, _platY) && gridSub423CC1(_platX + gridIncr, _platY, gridIncr)) { + for (int i = 0; i < gridIncr; ++i) { + _platWalkNodes[i].gridX1 = _platX + i; + _platWalkNodes[i].gridY1 = _platY; + _platWalkNodes[i].deltaX = 1; + _platWalkNodes[i].deltaY = 0; + } + done = true; + break; + } + if (!isPointBlocked(_platX - gridIncr, _platY) && gridSub423CC1(_platX - gridIncr, _platY, gridIncr)) { + for (int i = 0; i < gridIncr; ++i) { + _platWalkNodes[i].gridX1 = _platX - i; + _platWalkNodes[i].gridY1 = _platY; + _platWalkNodes[i].deltaX = -1; + _platWalkNodes[i].deltaY = 0; + } + done = true; + break; + } + if (!isPointBlocked(_platX, _platY + gridIncr) && gridSub423CC1(_platX, _platY + gridIncr, gridIncr)) { + for (int i = 0; i < gridIncr; ++i) { + _platWalkNodes[i].gridX1 = _platX; + _platWalkNodes[i].gridY1 = _platY + i; + _platWalkNodes[i].deltaX = 0; + _platWalkNodes[i].deltaY = 1; + } + done = true; + break; + } + if (!isPointBlocked(_platX, _platY - gridIncr) && gridSub423CC1(_platX, _platY - gridIncr, gridIncr)) { + for (int i = 0; i < gridIncr; ++i) { + _platWalkNodes[i].gridX1 = _platX; + _platWalkNodes[i].gridY1 = _platY - i; + _platWalkNodes[i].deltaX = 0; + _platWalkNodes[i].deltaY = -1; + } + done = true; + break; + } + if (!isPointBlocked(_platX + gridIncr, _platY + gridIncr) && gridSub423CC1(_platX + gridIncr, _platY + gridIncr, gridIncr)) { + for (int i = 0; i < gridIncr; ++i) { + _platWalkNodes[i].gridX1 = _platX + i; + _platWalkNodes[i].gridY1 = _platY + i; + _platWalkNodes[i].deltaX = 1; + _platWalkNodes[i].deltaY = 1; + } + done = true; + break; + } + if (!isPointBlocked(_platX - gridIncr, _platY + gridIncr) && gridSub423CC1(_platX - gridIncr, _platY + gridIncr, gridIncr)) { + for (int i = 0; i < gridIncr; ++i) { + _platWalkNodes[i].gridX1 = _platX - i; + _platWalkNodes[i].gridY1 = _platY + i; + _platWalkNodes[i].deltaX = -1; + _platWalkNodes[i].deltaY = 1; + } + done = true; + break; + } + if (!isPointBlocked(_platX + gridIncr, _platY - gridIncr) && gridSub423CC1(_platX + gridIncr, _platY - gridIncr, gridIncr)) { + for (int i = 0; i < gridIncr; ++i) { + _platWalkNodes[i].gridX1 = _platX + i; + _platWalkNodes[i].gridY1 = _platY - i; + _platWalkNodes[i].deltaX = 1; + _platWalkNodes[i].deltaY = -1; + } + done = true; + break; + } + if (!isPointBlocked(_platX - gridIncr, _platY - gridIncr) && gridSub423CC1(_platX - gridIncr, _platY - gridIncr, gridIncr)) { + for (int i = 0; i < gridIncr; ++i) { + _platWalkNodes[i].gridX1 = _platX - i; + _platWalkNodes[i].gridY1 = _platY - i; + _platWalkNodes[i].deltaX = -1; + _platWalkNodes[i].deltaY = -1; + } + done = true; + break; + } + if (!isPointBlocked(_platX + gridIncr, _platY) && gridSub42419A(_platX + gridIncr, _platY, gridIncr)) { + for (int i = 0; i < gridIncr; ++i) { + _platWalkNodes[i].gridX1 = _platX + i; + _platWalkNodes[i].gridY1 = _platY; + _platWalkNodes[i].deltaX = 1; + _platWalkNodes[i].deltaY = 0; + } + done = true; + break; + } + if (!isPointBlocked(_platX - gridIncr, _platY) && gridSub42419A(_platX - gridIncr, _platY, gridIncr)) { + for (int i = 0; i < gridIncr; ++i) { + _platWalkNodes[i].gridX1 = _platX - i; + _platWalkNodes[i].gridY1 = _platY; + _platWalkNodes[i].deltaX = -1; + _platWalkNodes[i].deltaY = 0; + } + done = true; + break; + } + if (!isPointBlocked(_platX, _platY + gridIncr) && gridSub42419A(_platX, _platY + gridIncr, gridIncr)) { + for (int i = 0; i < gridIncr; ++i) { + _platWalkNodes[i].gridX1 = _platX; + _platWalkNodes[i].gridY1 = _platY + i; + _platWalkNodes[i].deltaX = 0; + _platWalkNodes[i].deltaY = 1; + } + done = true; + break; + } + if (!isPointBlocked(_platX, _platY - gridIncr) && gridSub42419A(_platX, _platY - gridIncr, gridIncr)) { + for (int i = 0; i < gridIncr; ++i) { + _platWalkNodes[i].gridX1 = _platX; + _platWalkNodes[i].gridY1 = _platY - i; + _platWalkNodes[i].deltaX = 0; + _platWalkNodes[i].deltaY = -1; + } + done = true; + break; + } + if (!isPointBlocked(_platX + gridIncr, _platY + gridIncr) && gridSub42419A(_platX + gridIncr, _platY + gridIncr, gridIncr)) { + for (int i = 0; i < gridIncr; ++i) { + _platWalkNodes[i].gridX1 = _platX + i; + _platWalkNodes[i].gridY1 = _platY + i; + _platWalkNodes[i].deltaX = 1; + _platWalkNodes[i].deltaY = 1; + } + done = true; + break; + } + if (!isPointBlocked(_platX - gridIncr, _platY + gridIncr) && gridSub42419A(_platX - gridIncr, _platY + gridIncr, gridIncr)) { + for (int i = 0; i < gridIncr; ++i) { + _platWalkNodes[i].gridX1 = _platX - i; + _platWalkNodes[i].gridY1 = _platY + i; + _platWalkNodes[i].deltaX = -1; + _platWalkNodes[i].deltaY = 1; + } + done = true; + break; + } + if (!isPointBlocked(_platX + gridIncr, _platY - gridIncr) && gridSub42419A(_platX + gridIncr, _platY - gridIncr, gridIncr)) { + for (int i = 0; i < gridIncr; ++i) { + _platWalkNodes[i].gridX1 = _platX + i; + _platWalkNodes[i].gridY1 = _platY - i; + _platWalkNodes[i].deltaX = 1; + _platWalkNodes[i].deltaY = -1; + } + done = true; + break; + } + if (!isPointBlocked(_platX - gridIncr, _platY - gridIncr) && gridSub42419A(_platX - gridIncr, _platY - gridIncr, gridIncr)) { + for (int i = 0; i < gridIncr; ++i) { + _platWalkNodes[i].gridX1 = _platX - i; + _platWalkNodes[i].gridY1 = _platY - i; + _platWalkNodes[i].deltaX = -1; + _platWalkNodes[i].deltaY = -1; + } + done = true; + break; + } + ++gridIncr; + } + + return done; +} + +bool GnapEngine::platypusWalkTo(int gridX, int gridY, int animationIndex, int sequenceId, int flags) { + + int datNum = flags & 3; + bool done = false; + + _timers[1] = 60; + + if (gridX < 0) + gridX = (_leftClickMouseX - _gridMinX + 37) / 75; + + if (gridY < 0) + gridY = (_leftClickMouseY - _gridMinY + 24) / 48; + + _platWalkDestX = CLIP(gridX, 0, _gridMaxX - 1); + _platWalkDestY = CLIP(gridY, 0, _gridMaxY - 1); + + if (animationIndex >= 0 && _platWalkDestX == _gnapX && _platWalkDestY == _gnapY) + gnapWalkStep(); + + if (gridSub423CC1(_platX, _platY, 0)) + done = true; + + if (!done && gridSub42419A(_platX, _platY, 0)) + done = true; + + if (!done && platFindPath3(_platX, _platY)) + done = true; + + if (!done) + gridSub423750(_platX, _platY); + + int platSequenceId = _beaverSequenceId; + int platId = _beaverId; + int platSequenceDatNum = _beaverSequenceDatNum; + + for (int index = 0; index < _platWalkNodesCount; ++index) { + _platWalkNodes[index].id = index + 20 * _platWalkNodes[index].gridY1; + if (_platWalkNodes[index].deltaX == 1 && _platWalkNodes[index].deltaY == 0) { + if (index % 2) { + _gameSys->insertSequence(makeRid(datNum, 0x7CD), _platWalkNodes[index].id, + makeRid(platSequenceDatNum, platSequenceId), platId, + 9, 0, 75 * _platWalkNodes[index].gridX1 - _platGridX, 48 * _platWalkNodes[index].gridY1 - _platGridY); + _platWalkNodes[index].sequenceId = 0x7CD; + platSequenceId = 0x7CD; + } else { + _gameSys->insertSequence(makeRid(datNum, 0x7CE), _platWalkNodes[index].id, + makeRid(platSequenceDatNum, platSequenceId), platId, + 9, 0, 75 * _platWalkNodes[index].gridX1 - _platGridX, 48 * _platWalkNodes[index].gridY1 - _platGridY); + _platWalkNodes[index].sequenceId = 0x7CE; + platSequenceId = 0x7CE; + } + } else if (_platWalkNodes[index].deltaX == -1 && _platWalkNodes[index].deltaY == 0) { + if (index % 2) { + _gameSys->insertSequence(makeRid(datNum, 0x7CF), _platWalkNodes[index].id, + makeRid(platSequenceDatNum, platSequenceId), platId, + 9, 0, 75 * _platWalkNodes[index].gridX1 - _platGridX, 48 * _platWalkNodes[index].gridY1 - _platGridY); + _platWalkNodes[index].sequenceId = 0x7CF; + platSequenceId = 0x7CF; + } else { + _gameSys->insertSequence(makeRid(datNum, 0x7D0), _platWalkNodes[index].id, + makeRid(platSequenceDatNum, platSequenceId), platId, + 9, 0, 75 * _platWalkNodes[index].gridX1 - _platGridX, 48 * _platWalkNodes[index].gridY1 - _platGridY); + _platWalkNodes[index].sequenceId = 0x7D0; + platSequenceId = 0x7D0; + } + } else { + if (_platWalkNodes[index].deltaY == -1) + _platWalkNodes[index].id -= 10; + else + _platWalkNodes[index].id += 10; + int newSequenceId = getBeaverWalkSequenceId(_platWalkNodes[index].deltaX, _platWalkNodes[index].deltaY); + _gameSys->insertSequence(makeRid(datNum, newSequenceId), _platWalkNodes[index].id, + makeRid(platSequenceDatNum, platSequenceId), platId, + 9, 0, 75 * _platWalkNodes[index].gridX1 - _platGridX, 48 * _platWalkNodes[index].gridY1 - _platGridY); + _platWalkNodes[index].sequenceId = newSequenceId; + platSequenceId = newSequenceId; + } + platId = _platWalkNodes[index].id; + platSequenceDatNum = datNum; + } + + if (flags & 8) { + if (_platWalkNodesCount > 0) { + _beaverSequenceId = platSequenceId; + _beaverId = platId; + _beaverSequenceDatNum = datNum; + // CHECKME Not sure if this is correct... + if (_platWalkNodes[_platWalkNodesCount - 1].deltaX > 0) + _beaverFacing = 0; + else if (_platWalkNodes[_platWalkNodesCount - 1].deltaX < 0) + _beaverFacing = 4; + else if (_platWalkNodes[_platWalkNodesCount - 1].gridX1 % 2) + _beaverFacing = 4; + else + _beaverFacing = 0; + if (animationIndex >= 0) + _gameSys->setAnimation(makeRid(_beaverSequenceDatNum, _beaverSequenceId), _beaverId, animationIndex); + } else if (animationIndex >= 0) { + _gameSys->setAnimation(0x107D3, 1, animationIndex); + _gameSys->insertSequence(0x107D3, 1, 0, 0, 0, 0, 0, 0); + } + } else { + if (sequenceId >= 0 && sequenceId != -1) { + _beaverSequenceId = ridToEntryIndex(sequenceId); + _beaverSequenceDatNum = ridToDatIndex(sequenceId); + if (_beaverSequenceId == 0x7C2) { + _beaverFacing = 0; + } else if (_beaverSequenceId == 0x7D2) { + _beaverFacing = 4; + } + } else { + if (_platWalkNodesCount > 0) { + if (_platWalkNodes[_platWalkNodesCount - 1].deltaX > 0) { + _beaverSequenceId = 0x7C2; + _beaverFacing = 0; + } else if (_platWalkNodes[_platWalkNodesCount - 1].deltaX < 0) { + _beaverSequenceId = 0x7D2; + _beaverFacing = 4; + } else if (_platWalkNodes[0].deltaX > 0) { + _beaverSequenceId = 0x7C2; + _beaverFacing = 0; + } else if (_platWalkNodes[0].deltaX < 0) { + _beaverSequenceId = 0x7D2; + _beaverFacing = 4; + } else { + _beaverSequenceId = 0x7D2; + _beaverFacing = 4; + } + } else if (_beaverFacing > 0) { + _beaverSequenceId = 0x7D2; + } else { + _beaverSequenceId = 0x7C2; + } + _beaverSequenceDatNum = datNum; + } + + if (animationIndex < 0) { + _beaverId = 20 * _platWalkDestY; + } else { + _beaverId = animationIndex + 20 * _platWalkDestY; + _gameSys->setAnimation(makeRid(_beaverSequenceDatNum, _beaverSequenceId), animationIndex + 20 * _platWalkDestY, animationIndex); + } + + if (flags & 4) + _gameSys->insertSequence(makeRid(_beaverSequenceDatNum, _beaverSequenceId), _beaverId, + makeRid(platSequenceDatNum, platSequenceId), platId, + 9, 0, 0, 0); + else + _gameSys->insertSequence(makeRid(_beaverSequenceDatNum, _beaverSequenceId), _beaverId, + makeRid(platSequenceDatNum, platSequenceId), platId, + 9, 0, 75 * _platWalkDestX - _platGridX, 48 * _platWalkDestY - _platGridY); + } + + _platX = _platWalkDestX; + _platY = _platWalkDestY; + + return done; +} + +void GnapEngine::platypusWalkStep() { + bool done = false; + for (int i = 1; !done && i < _gridMaxX; ++i) { + done = true; + if (!isPointBlocked(_platX + i, _platY)) + platypusWalkTo(_platX + i, _platY, -1, -1, 1); + else if (!isPointBlocked(_platX - i, _platY)) + platypusWalkTo(_platX - i, _platY, -1, -1, 1); + else if (!isPointBlocked(_platX, _platY + 1)) + platypusWalkTo(_platX, _platY + 1, -1, -1, 1); + else if (!isPointBlocked(_platX, _platY - 1)) + platypusWalkTo(_platX, _platY - 1, -1, -1, 1); + else if (!isPointBlocked(_platX + 1, _platY + 1)) + platypusWalkTo(_platX + 1, _platY + 1, -1, -1, 1); + else if (!isPointBlocked(_platX - 1, _platY + 1)) + platypusWalkTo(_platX - 1, _platY + 1, -1, -1, 1); + else if (!isPointBlocked(_platX + 1, _platY - 1)) + platypusWalkTo(_platX + 1, _platY - 1, -1, -1, 1); + else if (!isPointBlocked(_platX - 1, _platY - 1)) + platypusWalkTo(_platX - 1, _platY - 1, -1, -1, 1); + else + done = false; + } +} + +void GnapEngine::beaverMakeRoom() { + int rndGridX, rndGridY; + do { + rndGridY = getRandom(_gridMaxY); + rndGridX = getRandom(_gridMaxX); + } while (ABS(rndGridX - _platX) > 4 || ABS(rndGridY - _platY) > 3 || + isPointBlocked(rndGridX, rndGridY)); + platypusWalkTo(rndGridX, rndGridY, -1, -1, 1); +} + +} // End of namespace Gnap diff --git a/engines/gnap/menu.cpp b/engines/gnap/menu.cpp new file mode 100644 index 0000000000..e6fc073c53 --- /dev/null +++ b/engines/gnap/menu.cpp @@ -0,0 +1,811 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "gnap/gnap.h" +#include "gnap/datarchive.h" +#include "gnap/gamesys.h" +#include "gnap/resource.h" + +namespace Gnap { + +void GnapEngine::createMenuSprite() { + _menuBackgroundSurface = _gameSys->createSurface(0x10002); +} + +void GnapEngine::freeMenuSprite() { + _gameSys->removeSpriteDrawItem(_menuBackgroundSurface, 260); + delayTicksCursor(5); + deleteSurface(&_menuBackgroundSurface); +} + +void GnapEngine::initMenuHotspots1() { + + int v0, v2 = 0; + + for (int i = 0; i < 3; ++i) { + int v1 = 0; + while (v1 < 3) { + _hotspots[v2].x1 = 87 * v1 + 262; + _hotspots[v2].y1 = 74 * i + 69; + _hotspots[v2].x2 = _hotspots[v2].x1 + 79; + _hotspots[v2].y2 = _hotspots[v2].y1 + 66; + _hotspots[v2].flags = 0; + _hotspots[v2].id = v2; + ++v1; + ++v2; + } + } + + _hotspots[v2].x1 = 330; + _hotspots[v2].y1 = 350; + _hotspots[v2].x2 = 430; + _hotspots[v2].y2 = 460; + _hotspots[v2].flags = 2; + _hotspots[v2].id = v2; + + v0 = v2 + 1; + _hotspots[v0].x1 = 180; + _hotspots[v0].y1 = 15; + _hotspots[v0].x2 = 620; + _hotspots[v0].y2 = 580; + _hotspots[v0].flags = 0; + _hotspots[v0].id = v0; + + ++v0; + _hotspots[v0].x1 = 0; + _hotspots[v0].y1 = 0; + _hotspots[v0].x2 = 799; + _hotspots[v0].y2 = 599; + _hotspots[v0].flags = 0; + _hotspots[v0].id = v0; + + _hotspotsCount = v0 + 1; +} + +void GnapEngine::initMenuHotspots2() { + int i, v0; + + for (i = 0; i < 4; ++i) { + _hotspots[i].x1 = 312; + _hotspots[i].y1 = 48 * i + 85; + _hotspots[i].x2 = _hotspots[i].x1 + 153; + _hotspots[i].y2 = _hotspots[i].y1 + 37; + _hotspots[i].flags = SF_GRAB_CURSOR; + _hotspots[i].id = i; + } + _hotspots[i].x1 = 500; + _hotspots[i].y1 = 72; + _hotspots[i].x2 = 527; + _hotspots[i].y2 = 99; + _hotspots[i].flags = SF_DISABLED; + _hotspots[i].id = i; + v0 = i + 1; + _hotspots[v0].x1 = 330; + _hotspots[v0].y1 = 350; + _hotspots[v0].x2 = 430; + _hotspots[v0].y2 = 460; + _hotspots[v0].flags = SF_GRAB_CURSOR; + _hotspots[v0].id = v0; + ++v0; + _hotspots[v0].x1 = 180; + _hotspots[v0].y1 = 15; + _hotspots[v0].x2 = 620; + _hotspots[v0].y2 = 580; + _hotspots[v0].flags = 0; + _hotspots[v0].id = v0; + ++v0; + _hotspots[v0].x1 = 0; + _hotspots[v0].y1 = 0; + _hotspots[v0].x2 = 799; + _hotspots[v0].y2 = 599; + _hotspots[v0].flags = 0; + _hotspots[v0].id = v0; + _hotspotsCount = v0 + 1; +} + +void GnapEngine::initMenuQuitQueryHotspots() { + _hotspots[0].x1 = 311; + _hotspots[0].y1 = 197; + _hotspots[0].x2 = 377; + _hotspots[0].y2 = 237; + _hotspots[0].flags = SF_GRAB_CURSOR; + _hotspots[0].id = 0; + _hotspots[1].x1 = 403; + _hotspots[1].y1 = 197; + _hotspots[1].x2 = 469; + _hotspots[1].y2 = 237; + _hotspots[1].flags = SF_GRAB_CURSOR; + _hotspots[1].id = 1; + _hotspots[2].x1 = 330; + _hotspots[2].y1 = 350; + _hotspots[2].x2 = 430; + _hotspots[2].y2 = 460; + _hotspots[2].flags = SF_GRAB_CURSOR; + _hotspots[2].id = 2; + _hotspots[3].x1 = 180; + _hotspots[3].y1 = 15; + _hotspots[3].x2 = 620; + _hotspots[3].y2 = 580; + _hotspots[3].flags = 0; + _hotspots[3].id = 3; + _hotspots[4].x1 = 0; + _hotspots[4].y1 = 0; + _hotspots[4].x2 = 799; + _hotspots[4].y2 = 599; + _hotspots[4].flags = 0; + _hotspots[4].id = 4; + _hotspotsCount = 5; +} + +void GnapEngine::initSaveLoadHotspots() { + int i, v0; + for (i = 0; i < 7; ++i ) { + _hotspots[i].x1 = 288; + _hotspots[i].y1 = 31 * i + 74; + _hotspots[i].x2 = _hotspots[i].x1 + 91; + _hotspots[i].y2 = _hotspots[i].y1 + 22; + _hotspots[i].flags = SF_GRAB_CURSOR; + _hotspots[i].id = i; + } + if (_menuStatus == 2) { + _hotspots[i].x1 = 416; + _hotspots[i].y1 = 160; + _hotspots[i].x2 = 499; + _hotspots[i].y2 = 188; + _hotspots[i].flags = SF_GRAB_CURSOR; + _hotspots[i].id = i; + ++i; + } + _hotspots[i].x1 = 416; + _hotspots[i].y1 = 213; + _hotspots[i].x2 = 499; + _hotspots[i].y2 = 241; + _hotspots[i].flags = SF_GRAB_CURSOR; + _hotspots[i].id = i; + v0 = i + 1; + _hotspots[v0].x1 = 330; + _hotspots[v0].y1 = 350; + _hotspots[v0].x2 = 430; + _hotspots[v0].y2 = 460; + _hotspots[v0].flags = SF_GRAB_CURSOR; + _hotspots[v0].id = v0; + ++v0; + _hotspots[v0].x1 = 180; + _hotspots[v0].y1 = 15; + _hotspots[v0].x2 = 620; + _hotspots[v0].y2 = 580; + _hotspots[v0].flags = 0; + _hotspots[v0].id = v0; + ++v0; + _hotspots[v0].x1 = 0; + _hotspots[v0].y1 = 0; + _hotspots[v0].x2 = 799; + _hotspots[v0].y2 = 599; + _hotspots[v0].flags = 0; + _hotspots[v0].id = v0; + _hotspotsCount = v0 + 1; +} + +void GnapEngine::drawInventoryFrames() { + for (int i = 0; i < 9; ++i) + _gameSys->drawSpriteToSurface(_menuBackgroundSurface, _hotspots[i].x1 - 93, _hotspots[i].y1, 0x10001); +} + +void GnapEngine::insertInventorySprites() { + + for (int i = 0; i < 9; ++i) { + _menuInventoryIndices[i] = -1; + _gameSys->removeSpriteDrawItem(_menuInventorySprites[_sceneClickedHotspot], 261); + _menuInventorySprites[i] = 0; + } + + _menuSpritesIndex = 0; + + for (int index = 0; index < 30 && _menuSpritesIndex < 9; ++index) { + if (invHas(index)) { + _gameSys->drawSpriteToSurface(_menuBackgroundSurface, + _hotspots[_menuSpritesIndex].x1 - 93, _hotspots[_menuSpritesIndex].y1, 0x10000); + _menuInventorySprites[_menuSpritesIndex] = _gameSys->createSurface(getInventoryItemSpriteNum(index) | 0x10000); + if (index != _grabCursorSpriteIndex) { + _menuInventoryIndices[_menuSpritesIndex] = index; + _gameSys->insertSpriteDrawItem(_menuInventorySprites[_menuSpritesIndex], + _hotspots[_menuSpritesIndex].x1 + ((79 - _menuInventorySprites[_menuSpritesIndex]->w) / 2), + _hotspots[_menuSpritesIndex].y1 + ((66 - _menuInventorySprites[_menuSpritesIndex]->h) / 2), + 261); + } + _hotspots[_menuSpritesIndex].flags = SF_GRAB_CURSOR; + ++_menuSpritesIndex; + } + } + +} + +void GnapEngine::removeInventorySprites() { + for (int i = 0; i < _menuSpritesIndex; ++i) + if (_menuInventorySprites[i]) + _gameSys->removeSpriteDrawItem(_menuInventorySprites[i], 261); + delayTicksCursor(5); + for (int j = 0; j < _menuSpritesIndex; ++j) { + if (_menuInventorySprites[j]) { + deleteSurface(&_menuInventorySprites[j]); + _menuInventorySprites[j] = 0; + _menuInventoryIndices[j] = -1; + } + } + _menuSpritesIndex = 0; +} + +void GnapEngine::runMenu() { + + int v43; + + _spriteHandle = 0; + _cursorSprite = 0; + _menuSprite1 = 0; + _menuSprite2 = 0; + _menuSaveLoadSprite = 0; + _menuQuitQuerySprite = 0; + + _menuStatus = 0; + _menuDone = false; + + createMenuSprite();//??? CHECKME Crashes when done in loadStockDat() find out why + + insertDeviceIconActive(); + + for (int i = 0; i < 7; ++i) { + _savegameFilenames[i][0] = 0; + _savegameSprites[i] = 0; + } + + v43 = 0; + + if (_menuStatus == 0) { + invAdd(kItemMagazine); + setGrabCursorSprite(-1); + hideCursor(); + initMenuHotspots1(); + drawInventoryFrames(); + insertInventorySprites(); + _gameSys->insertSpriteDrawItem(_menuBackgroundSurface, 93, 0, 260); + showCursor(); + // SetCursorPos(400, 300); + setVerbCursor(GRAB_CURSOR); + // pollMessages(); + } + + _timers[2] = 10; + + while (!isKeyStatus1(8) && !isKeyStatus1(28) && !_sceneDone && !_menuDone) { + + updateCursorByHotspot(); + + switch (_menuStatus) { + case 0: + updateMenuStatusInventory(); + break; + case 1: + updateMenuStatusMainMenu(); + break; + case 2: + updateMenuStatusSaveGame(); + break; + case 3: + updateMenuStatusLoadGame(); + break; + case 4: + updateMenuStatusQueryQuit(); + break; + } + + gameUpdateTick(); + + } + + removeInventorySprites(); + if (_spriteHandle) + _gameSys->removeSpriteDrawItem(_spriteHandle, 261); + if (_menuSprite1) + _gameSys->removeSpriteDrawItem(_menuSprite1, 262); + if (_menuSprite2) + _gameSys->removeSpriteDrawItem(_menuSprite2, 262); + for (int i = 0; i < 7; ++i) + if (_savegameSprites[i]) + _gameSys->removeSpriteDrawItem(_savegameSprites[i], 263); + if (_cursorSprite) + _gameSys->removeSpriteDrawItem(_cursorSprite, 264); + if (_menuSaveLoadSprite) + _gameSys->removeSpriteDrawItem(_menuSaveLoadSprite, 262); + if (_menuQuitQuerySprite) + _gameSys->removeSpriteDrawItem(_menuQuitQuerySprite, 262); + if (_menuBackgroundSurface) + _gameSys->removeSpriteDrawItem(_menuBackgroundSurface, 260); + + delayTicksCursor(5); + + deleteSurface(&_spriteHandle); + deleteSurface(&_menuSprite1); + deleteSurface(&_menuSprite2); + for (int i = 0; i < 7; ++i) + deleteSurface(&_savegameSprites[i]); + deleteSurface(&_cursorSprite); + deleteSurface(&_menuSaveLoadSprite); + deleteSurface(&_menuQuitQuerySprite); + + _sceneClickedHotspot = -1; + + _timers[2] = getRandom(20) + 30; + _timers[3] = getRandom(200) + 50; + _timers[0] = getRandom(75) + 75; + _timers[1] = getRandom(20) + 30; + + clearAllKeyStatus1(); + + _mouseClickState.left = false; + + removeDeviceIconActive(); + + freeMenuSprite();//??? CHECKME +} + +void GnapEngine::updateMenuStatusInventory() { + + static const struct { + int item1, item2, resultItem; + } kCombineItems[] = { + {kItemGrass, kItemMud, kItemDisguise}, + {kItemDice, kItemQuarterWithHole, kItemDiceQuarterHole}, + {kItemPill, kItemBucketWithBeer, kItemBucketWithPill} + }; + + updateGrabCursorSprite(0, 0); + _hotspots[0].x1 = 262; + _hotspots[0].y1 = 69; + _hotspots[0].x2 = 341; + _hotspots[0].y2 = 135; + _sceneClickedHotspot = -1; + if (_timers[2] == 0) + _sceneClickedHotspot = getClickedHotspotId(); + if (_sceneClickedHotspot == -1 || _sceneClickedHotspot >= _menuSpritesIndex) { + if (_sceneClickedHotspot == _hotspotsCount - 3) { + if (_grabCursorSpriteIndex == -1) { + _timers[2] = 10; + playSound(0x108F4, 0); + _menuStatus = 1; + Common::Rect dirtyRect(_hotspots[0].x1, _hotspots[0].y1, _hotspots[2].x2, _hotspots[_hotspotsCount - 4].y2); + drawInventoryFrames(); + initMenuHotspots2(); + removeInventorySprites(); + if (!_menuSprite1) + _menuSprite1 = _gameSys->createSurface(0x104F8); + _gameSys->insertSpriteDrawItem(_menuSprite1, 288, 79, 262); + _gameSys->insertDirtyRect(dirtyRect); + } else { + playSound(0x108F5, 0); + } + } else if (_sceneClickedHotspot == _hotspotsCount - 1) { + _timers[2] = 10; + playSound(0x108F5, 0); + _menuDone = true; + } + } else if (_sceneClickedHotspot != -1 && _menuInventoryIndices[_sceneClickedHotspot] != -1 && _grabCursorSpriteIndex == -1) { + _gameSys->removeSpriteDrawItem(_menuInventorySprites[_sceneClickedHotspot], 261); + setGrabCursorSprite(_menuInventoryIndices[_sceneClickedHotspot]); + _menuInventoryIndices[_sceneClickedHotspot] = -1; + } else if (_sceneClickedHotspot != -1 && _menuInventoryIndices[_sceneClickedHotspot] == -1 && _grabCursorSpriteIndex != -1) { + _menuInventoryIndices[_sceneClickedHotspot] = _grabCursorSpriteIndex; + _gameSys->insertSpriteDrawItem(_menuInventorySprites[_sceneClickedHotspot], + _hotspots[_sceneClickedHotspot].x1 + ((79 - _menuInventorySprites[_sceneClickedHotspot]->w) / 2), + _hotspots[_sceneClickedHotspot].y1 + (66 - _menuInventorySprites[_sceneClickedHotspot]->h) / 2, + 261); + setGrabCursorSprite(-1); + } else if (_sceneClickedHotspot != -1 && _menuInventoryIndices[_sceneClickedHotspot] != -1 && _grabCursorSpriteIndex != -1) { + int combineIndex = -1; + for (int i = 0; i < ARRAYSIZE(kCombineItems); ++i) { + if ((_grabCursorSpriteIndex == kCombineItems[i].item1 && _menuInventoryIndices[_sceneClickedHotspot] == kCombineItems[i].item2) || + (_grabCursorSpriteIndex == kCombineItems[i].item2 && _menuInventoryIndices[_sceneClickedHotspot] == kCombineItems[i].item1)) { + combineIndex = i; + break; + } + } + if (combineIndex >= 0) { + invRemove(kCombineItems[combineIndex].item1); + invRemove(kCombineItems[combineIndex].item2); + invAdd(kCombineItems[combineIndex].resultItem); + playSound(0x108AE, 0); + deleteSurface(&_spriteHandle); // CHECKME + _spriteHandle = _gameSys->createSurface(0x10001); + _gameSys->insertSpriteDrawItem(_spriteHandle, _hotspots[_menuSpritesIndex - 1].x1, _hotspots[_menuSpritesIndex - 1].y1, 261); + setGrabCursorSprite(kCombineItems[combineIndex].resultItem); + removeInventorySprites(); + insertInventorySprites(); + delayTicksCursor(5); + } else { + playSound(0x108F5, 0); + } + } +} + +void GnapEngine::updateMenuStatusMainMenu() { + _hotspots[0].x1 = 312; + _hotspots[0].y1 = 85; + _hotspots[0].x2 = 465; + _hotspots[0].y2 = 122; + _sceneClickedHotspot = -1; + if (!_timers[2]) + _sceneClickedHotspot = getClickedHotspotId(); + + if (_sceneClickedHotspot != 1 && _sceneClickedHotspot != 0) { + if (_sceneClickedHotspot != 2 && _hotspotsCount - 1 != _sceneClickedHotspot) { + if (_sceneClickedHotspot == 3) { + _timers[2] = 10; + playSound(0x108F4, 0); + _gameSys->removeSpriteDrawItem(_menuSprite1, 262); + initMenuQuitQueryHotspots(); + _menuStatus = 4; + if (!_menuQuitQuerySprite) + _menuQuitQuerySprite = _gameSys->createSurface(0x104FC); + _gameSys->insertSpriteDrawItem(_menuQuitQuerySprite, 254, 93, 262); + } else if (_sceneClickedHotspot == 4) { + playSound(0x108F4, 0); + Common::Rect dirtyRect(0, 0, 799, 599); + hideCursor(); + _largeSprite = _gameSys->allocSurface(800, 600); + + for (int i = 0; i < 3; ++i) { + + _timers[2] = 10; + + if (i == 0) { + _gameSys->drawSpriteToSurface(_largeSprite, 0, 0, 0x1078D); + _gameSys->insertSpriteDrawItem(_largeSprite, 0, 0, 300); + /* TODO + if (_midiFlag) { + playMidi("pause.mid", 0); + } + */ + } else if (i == 1) { + _gameSys->drawSpriteToSurface(_largeSprite, 0, 0, 0x1078E); + _gameSys->insertDirtyRect(dirtyRect); + } else if (i == 2) { + _gameSys->drawSpriteToSurface(_largeSprite, 0, 0, 0x1078F); + _gameSys->insertDirtyRect(dirtyRect); + } + + while (!_mouseClickState.left && !isKeyStatus1(28) && !isKeyStatus1(30) && !isKeyStatus1(29) && !_timers[2]) { + gameUpdateTick(); + } + + playSound(0x108F5, 0); + _mouseClickState.left = false; + clearKeyStatus1(28); + clearKeyStatus1(29); + clearKeyStatus1(30); + } + + _gameSys->removeSpriteDrawItem(_largeSprite, 300); + delayTicksCursor(5); + deleteSurface(&_largeSprite); + showCursor(); + } else if (_hotspotsCount - 3 == _sceneClickedHotspot) { + _timers[2] = 10; + playSound(0x108F4, 0); + initMenuHotspots1(); + /* TODO + if (_mouseX < 93 || _mouseX > 638 || _mouseY < 0 || _mouseY > 600) + SetCursorPos(400, 300); + */ + _menuStatus = 0; + if (_menuSprite1) + _gameSys->removeSpriteDrawItem(_menuSprite1, 262); + insertInventorySprites(); + Common::Rect dirtyRect(_hotspots[0].x1, _hotspots[0].y1, _hotspots[2].x2, _hotspots[_hotspotsCount - 4].y2); + _gameSys->insertDirtyRect(dirtyRect); + } + } else { + playSound(0x108F5, 0); + _menuDone = true; + } + } else { + _timers[2] = 10; + playSound(0x108F4, 0); + _gameSys->removeSpriteDrawItem(_menuSprite1, 262); + if (_menuSaveLoadSprite) + deleteSurface(&_menuSaveLoadSprite); + if (_sceneClickedHotspot == 1) { + _menuStatus = 2; + initSaveLoadHotspots(); + _menuSaveLoadSprite = _gameSys->createSurface(0x104FB); + } else { + _menuStatus = 3; + initSaveLoadHotspots(); + _menuSaveLoadSprite = _gameSys->createSurface(0x104FA); + } + _gameSys->insertSpriteDrawItem(_menuSaveLoadSprite, 403, 72, 262); + if (!_menuSprite2) + _menuSprite2 = _gameSys->createSurface(0x104F9); + _gameSys->insertSpriteDrawItem(_menuSprite2, 277, 66, 262); + for (int i = 0; i < 7; ++i) { + Common::String savegameDescription; + if (!_savegameSprites[i]) + _savegameSprites[i] = _gameSys->allocSurface(111, 40); + if (readSavegameDescription(i + 1, savegameDescription) == 0) + strncpy(_savegameFilenames[i], savegameDescription.c_str(), 40); + _gameSys->drawTextToSurface(_savegameSprites[i], 0, 0, 255, 0, 0, _savegameFilenames[i]); + _gameSys->insertSpriteDrawItem(_savegameSprites[i], 288, _hotspots[i].y1, 263); + } + _savegameIndex = -1; + } +} + +void GnapEngine::updateMenuStatusSaveGame() { +#if 0 // TODO + _hotspots[0].x1 = 288; + _hotspots[0].y1 = 74; + _hotspots[0].x2 = 379; + _hotspots[0].y2 = 96; + _sceneClickedHotspot = -1; + if (!_timers[2]) + _sceneClickedHotspot = getClickedHotspotId(); + if (_hotspotsCount - 3 == _sceneClickedHotspot) + { + _timers[2] = 10; + playSound(0x108F4, 0); + _menuStatus = 1; + writeSavegame(_savegameIndex + 1, (int)&_savegameFilenames[30 * _savegameIndex], 1); + } + else if (_hotspotsCount - 4 == _sceneClickedHotspot) + { + _timers[2] = 10; + playSound(0x108F5, 0); + _menuStatus = 1; + if (strcmp(&v43, &_savegameFilenames[30 * _savegameIndex]) && _savegameIndex != -1) + { + strcpy((char *)&_savegameFilenames[30 * _savegameIndex], &v43); + if (_savegameSprites[_savegameIndex] != -1) + { + _gameSys->removeSpriteDrawItem(_savegameSprites[_savegameIndex], 263); + delayTicksCursor(5); + memFreeHandle(_savegameSprites[_savegameIndex]); + } + v16 = getSpriteWidthById(0x104F9); + _savegameSprites[_savegameIndex] = allocSprite(v16, 40, 128, 0); + } + } + else if (_hotspotsCount - 5 == _sceneClickedHotspot) + { + _timers[2] = 10; + playSound(0x108F4, 0); + if ((signed int)_savegameIndex > -1) + writeSavegame(_savegameIndex + 1, (int)&_savegameFilenames[30 * _savegameIndex], 1); + _menuStatus = 1; + } + else if (_hotspotsCount - 1 == _sceneClickedHotspot) + { + _menuDone = true; + } + else if (_sceneClickedHotspot != -1 && _hotspotsCount - 2 != _sceneClickedHotspot) + { + _timers[2] = 10; + playSound(0x108F4, 0); + v17 = strcmp(&v43, &_savegameFilenames[30 * _savegameIndex]); + if (!v17) + LOBYTE(v17) = 0; + if ((unsigned int8)v17 & (_savegameIndex < 0xFFFFFFFF)) + { + strcpy((char *)&_savegameFilenames[30 * _savegameIndex], &v43); + if (_savegameSprites[_savegameIndex] != -1) + { + _gameSys->removeSpriteDrawItem(_savegameSprites[_savegameIndex], 263); + delayTicksCursor(5); + memFreeHandle(_savegameSprites[_savegameIndex]); + } + v18 = getSpriteWidthById(0x104F9); + _savegameSprites[_savegameIndex] = allocSprite(v18, 40, 128, 0); + drawTextToSurface(_savegameSprites[_savegameIndex], 0, 0, 255, 0, 0, &_savegameFilenames[30 * _savegameIndex]); + insertSpriteDrawItem(_savegameSprites[_savegameIndex], 288, _hotspots[_savegameIndex].y1, 263); + } + _savegameIndex = _sceneClickedHotspot; + v46 = strlen(&_savegameFilenames[30 * _sceneClickedHotspot]); + strcpy(&v43, &_savegameFilenames[30 * _sceneClickedHotspot]); + if (_cursorSprite == -1) + { + v19 = getTextHeight("_"); + v20 = getTextWidth("_"); + _cursorSprite = allocSprite(v20, v19, 128, 0); + drawTextToSurface(_cursorSprite, 0, 0, 255, 0, 0, "_"); + } + else + { + _gameSys->removeSpriteDrawItem(_cursorSprite, 264); + } + v21 = _hotspots[_savegameIndex].x2; + v22 = v21 - getTextWidth("_"); + if (v22 > getTextWidth(&_savegameFilenames[30 * _savegameIndex]) + 288) + { + v25 = getTextWidth(&_savegameFilenames[30 * _savegameIndex]) + 288; + insertSpriteDrawItem(_cursorSprite, v25, _hotspots[_savegameIndex].y1, 264); + } + else + { + v23 = _hotspots[_savegameIndex].x2; + v24 = v23 - getTextWidth("_"); + insertSpriteDrawItem(_cursorSprite, v24, _hotspots[_savegameIndex].y1, 264); + } + } + if ((signed int)_savegameIndex > -1 && keybChar) + { + if ((keybChar < 'A' || keybChar > 'Z') && (keybChar < '0' || keybChar > '9') && keybChar != ' ') + { + if (keybChar == 8) + { + if ((signed int)v46 > 0) + --v46; + *(&_savegameFilenames[30 * _savegameIndex] + v46) = 0; + if (_savegameSprites[_savegameIndex] != -1) + { + _gameSys->removeSpriteDrawItem(_savegameSprites[_savegameIndex], 263); + memFreeHandle(_savegameSprites[_savegameIndex]); + } + v32 = getSpriteWidthById(0x104F9); + _savegameSprites[_savegameIndex] = allocSprite(v32, 40, 128, 0); + drawTextToSurface(_savegameSprites[_savegameIndex], 0, 0, 255, 0, 0, &_savegameFilenames[30 * _savegameIndex]); + insertSpriteDrawItem(_savegameSprites[_savegameIndex], 288, _hotspots[_savegameIndex].y1, 263); + _gameSys->removeSpriteDrawItem(_cursorSprite, 264); + v33 = _hotspots[_savegameIndex].y1; + v34 = getTextWidth(&_savegameFilenames[30 * _savegameIndex]); + insertSpriteDrawItem(_cursorSprite, LOWORD(_hotspots[_savegameIndex].x1) + v34, v33, 264); + } + else if (keybChar == 13) + { + _menuStatus = 1; + writeSavegame(_savegameIndex + 1, (int)&_savegameFilenames[30 * _savegameIndex], 1); + } + } + else + { + *(&_savegameFilenames[30 * _savegameIndex] + v46) = keybChar; + if ((signed int)v46 < 28) + ++v46; + *(&_savegameFilenames[30 * _savegameIndex] + v46) = 0; + if (getTextWidth(&_savegameFilenames[30 * _savegameIndex]) > 91) + { + --v46; + *(&_savegameFilenames[30 * _savegameIndex] + v46) = 0; + } + drawTextToSurface(_savegameSprites[_savegameIndex], 0, 0, 255, 0, 0, &_savegameFilenames[30 * _savegameIndex]); + v26 = getTextWidth(&_savegameFilenames[30 * _savegameIndex]); + rect.right = _hotspots[_savegameIndex].x1 + v26; + v27 = rect.right; + rect.left = v27 - 2 * getTextWidth("W"); + rect.top = _hotspots[_savegameIndex].y1; + rect.bottom = _hotspots[_savegameIndex].y2; + insertDirtyRect(&rect); + _gameSys->removeSpriteDrawItem(_cursorSprite, 264); + v28 = _hotspots[_savegameIndex].x2; + v29 = getTextWidth("_"); + if (v28 - v29 > rect.right) + { + insertSpriteDrawItem(_cursorSprite, SLOWORD(rect.right), SLOWORD(rect.top), 264); + } + else + { + v30 = _hotspots[_savegameIndex].x2; + v31 = v30 - getTextWidth("_"); + insertSpriteDrawItem(_cursorSprite, v31, SLOWORD(rect.top), 264); + } + clearKeyStatus1(8); + } + } + keybChar = 0; + if (_menuStatus == 1 || _menuDone) + { + _gameSys->removeSpriteDrawItem(_menuSprite2, 262); + _gameSys->removeSpriteDrawItem(_menuSaveLoadSprite, 262); + for (i = 0; i < 7; ++i) + _gameSys->removeSpriteDrawItem(_savegameSprites[i], 263); + _gameSys->removeSpriteDrawItem(_cursorSprite, 264); + if (!_menuDone) + { + initMenuHotspots2(); + insertSpriteDrawItem(_menuSprite1, 288, 79, 262); + } + } +#endif +} + +void GnapEngine::updateMenuStatusLoadGame() { + _hotspots[0].x1 = 288; + _hotspots[0].y1 = 74; + _hotspots[0].x2 = 379; + _hotspots[0].y2 = 96; + _sceneClickedHotspot = -1; + if (!_timers[2]) + _sceneClickedHotspot = getClickedHotspotId(); + if (_sceneClickedHotspot != -1 && _hotspotsCount - 2 != _sceneClickedHotspot) { + _timers[2] = 10; + if (_hotspotsCount - 4 <= _sceneClickedHotspot) { + playSound(0x108F5, 0); + _gameSys->removeSpriteDrawItem(_menuSprite2, 262); + _gameSys->removeSpriteDrawItem(_menuSaveLoadSprite, 262); + for (int i = 0; i < 7; ++i) + _gameSys->removeSpriteDrawItem(_savegameSprites[i], 263); + if (_hotspotsCount - 1 == _sceneClickedHotspot) { + _menuDone = true; + } else { + _menuStatus = 1; + initMenuHotspots2(); + _gameSys->insertSpriteDrawItem(_menuSprite1, 288, 79, 262); + } + } else if (loadSavegame(_sceneClickedHotspot + 1)) { + playSound(0x108F5, 0); + } else { + playSound(0x108F4, 0); + _sceneDone = true; + } + } +} + +void GnapEngine::updateMenuStatusQueryQuit() { + + _hotspots[0].x1 = 311; + _hotspots[0].y1 = 197; + _hotspots[0].x2 = 377; + _hotspots[0].y2 = 237; + + _sceneClickedHotspot = -1; + + if (!_timers[2]) + _sceneClickedHotspot = getClickedHotspotId(); + + /* _sceneClickedHotspot + 0 Yes + 1 No + 2 Button + 3 Display + 4 Background + */ + + if (_sceneClickedHotspot == 0) { + // Quit the game + playSound(0x108F5, 0); + _gameSys->removeSpriteDrawItem(_menuQuitQuerySprite, 262); + _sceneDone = true; + _gameDone = true; + } else if (_sceneClickedHotspot == 4) { + // Exit the device + playSound(0x108F4, 0); + _gameSys->removeSpriteDrawItem(_menuQuitQuerySprite, 262); + _menuDone = true; + } else if (_sceneClickedHotspot != -1) { + // Return to the main menu + playSound(0x108F4, 0); + _gameSys->removeSpriteDrawItem(_menuQuitQuerySprite, 262); + _timers[2] = 10; + _menuStatus = 1; + initMenuHotspots2(); + _gameSys->insertSpriteDrawItem(_menuSprite1, 288, 79, 262); + } + +} + +} // End of namespace Gnap diff --git a/engines/gnap/module.mk b/engines/gnap/module.mk new file mode 100644 index 0000000000..78e2cce736 --- /dev/null +++ b/engines/gnap/module.mk @@ -0,0 +1,70 @@ +MODULE := engines/gnap + +MODULE_OBJS := \ + datarchive.o \ + detection.o \ + gamesys.o \ + gnap.o \ + grid.o \ + menu.o \ + resource.o \ + sound.o \ + scenes/scene01.o \ + scenes/scene02.o \ + scenes/scene03.o \ + scenes/scene04.o \ + scenes/scene05.o \ + scenes/scene06.o \ + scenes/scene07.o \ + scenes/scene08.o \ + scenes/scene09.o \ + scenes/scene10.o \ + scenes/scene11.o \ + scenes/scene12.o \ + scenes/scene13.o \ + scenes/scene14.o \ + scenes/scene15.o \ + scenes/scene16.o \ + scenes/scene17.o \ + scenes/scene18.o \ + scenes/scene19.o \ + scenes/scene20.o \ + scenes/scene21.o \ + scenes/scene22.o \ + scenes/scene23.o \ + scenes/scene24.o \ + scenes/scene25.o \ + scenes/scene26.o \ + scenes/scene27.o \ + scenes/scene28.o \ + scenes/scene29.o \ + scenes/scene30.o \ + scenes/scene31.o \ + scenes/scene32.o \ + scenes/scene33.o \ + scenes/scene38.o \ + scenes/scene39.o \ + scenes/scene40.o \ + scenes/scene41.o \ + scenes/scene42.o \ + scenes/scene43.o \ + scenes/scene44.o \ + scenes/scene45.o \ + scenes/scene46.o \ + scenes/scene47.o \ + scenes/scene48.o \ + scenes/scene49.o \ + scenes/scene50.o \ + scenes/scene51.o \ + scenes/scene52.o \ + scenes/scene53.o \ + scenes/scene54.o \ + scenes/scenecore.o + +# This module can be built as a plugin +ifeq ($(ENABLE_GNAP), DYNAMIC_PLUGIN) +PLUGIN := 1 +endif + +# Include common rules +include $(srcdir)/rules.mk diff --git a/engines/gnap/resource.cpp b/engines/gnap/resource.cpp new file mode 100644 index 0000000000..ab83b1376b --- /dev/null +++ b/engines/gnap/resource.cpp @@ -0,0 +1,118 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "gnap/resource.h" + +namespace Gnap { + +// SequenceFrame + +void SequenceFrame::loadFromStream(Common::MemoryReadStream &stream) { + duration = stream.readUint16LE(); + isScaled = stream.readUint16LE(); + rect.left = stream.readUint32LE(); + rect.top = stream.readUint32LE(); + rect.right = stream.readUint32LE(); + rect.bottom = stream.readUint32LE(); + spriteId = stream.readUint32LE(); + soundId = stream.readUint32LE(); + unkValue = stream.readUint32LE(); + //isScaled = 0;//DEBUG + debug(1, "SequenceFrame() spriteId: %d; soundId: %d", spriteId, soundId); +} + +// SequenceAnimation + +void SequenceAnimation::loadFromStream(Common::MemoryReadStream &stream) { + field_0 = stream.readUint16LE(); + field_2 = stream.readUint16LE(); + field_4 = stream.readUint32LE(); + framesCount = stream.readUint16LE(); + field_A = stream.readUint16LE(); + debug(1, "SequenceAnimation() framesCount: %d", framesCount); + frames = new SequenceFrame[framesCount]; + for (int i = 0; i < framesCount; ++i) + frames[i].loadFromStream(stream); +} + +// SequenceResource + +SequenceResource::SequenceResource(int resourceId, byte *data, uint32 size) { + Common::MemoryReadStream stream(data, size, DisposeAfterUse::NO); + _field_0 = stream.readUint32LE(); + _sequenceId = stream.readUint32LE(); + _field_8 = stream.readUint32LE(); + _sequenceId2 = stream.readUint32LE(); + _field_10 = stream.readUint32LE(); + _flags = stream.readUint32LE(); + _totalDuration = stream.readUint32LE(); + _xOffs = stream.readUint16LE(); + _yOffs = stream.readUint16LE(); + _animationsCount = stream.readUint32LE(); + _animations = new SequenceAnimation[_animationsCount]; + debug(1, "SequenceResource() _animationsCount: %d", _animationsCount); + for (int i = 0; i < _animationsCount; ++i) { + uint32 animationOffs = stream.readUint32LE(); + debug(1, "animationOffs: %08X", animationOffs); + uint32 oldOffs = stream.pos(); + stream.seek(animationOffs); + _animations[i].loadFromStream(stream); + stream.seek(oldOffs); + } + // TODO Convert resourceIds +} + +SequenceResource::~SequenceResource() { + delete[] _animations; +} + +// SpriteResource + +SpriteResource::SpriteResource(int resourceId, byte *data, uint32 size) { + _data = data; + _width = READ_LE_UINT16(_data); + _height = READ_LE_UINT16(_data + 2); + _unk1 = READ_LE_UINT16(_data + 4); + _unk2 = READ_LE_UINT16(_data + 6); + _transparent = READ_LE_UINT16(_data + 8); + _colorsCount = READ_LE_UINT16(_data + 10); + _palette = (uint32*)(_data + 12); + _pixels = _data + 12 + _colorsCount * 4; + debug(1, "SpriteResource() width: %d; height: %d; colorsCount: %d", _width, _height, _colorsCount); +} + +SpriteResource::~SpriteResource() { + delete[] _data; +} + +// SoundResource + +SoundResource::SoundResource(int resourceId, byte *data, uint32 size) { + _data = data; + _size = size; +} + +SoundResource::~SoundResource() { + delete[] _data; +} + +} // End of namespace Gnap diff --git a/engines/gnap/resource.h b/engines/gnap/resource.h new file mode 100644 index 0000000000..b0f6a6169b --- /dev/null +++ b/engines/gnap/resource.h @@ -0,0 +1,196 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#ifndef GNAP_RESOURCE_H +#define GNAP_RESOURCE_H + +#include "common/array.h" +#include "common/events.h" +#include "common/file.h" +#include "common/memstream.h" +#include "common/str.h" +#include "common/stream.h" +#include "common/substream.h" +#include "common/system.h" + +#include "graphics/surface.h" + +#include "gnap/datarchive.h" + +namespace Gnap { + +enum { + kResTypeSprite = 0, + kResTypeBitmap = 1, + kResTypeSound = 2, + kResTypeSequence = 3 +}; + +struct SequenceFrame { + int16 duration; + int16 isScaled; + Common::Rect rect; + int32 spriteId; + int32 soundId; + int32 unkValue; + void loadFromStream(Common::MemoryReadStream &stream); +}; + +struct SequenceAnimation { + int16 field_0; + int16 field_2; + int32 field_4; + int16 framesCount; + int16 field_A; + SequenceFrame *frames; + SequenceAnimation() : frames(0) {} + ~SequenceAnimation() { delete[] frames; } + void loadFromStream(Common::MemoryReadStream &stream); +}; + +class SequenceResource { +public: + SequenceResource(int resourceId, byte *data, uint32 size); + ~SequenceResource(); +public: + uint32 _field_0; + int32 _sequenceId; + int32 _field_8; + int32 _sequenceId2; + uint32 _field_10; + uint32 _flags; + int32 _totalDuration; + int16 _xOffs; + int16 _yOffs; + int32 _animationsCount; + SequenceAnimation *_animations; +}; + +class SpriteResource { +public: + SpriteResource(int resourceId, byte *data, uint32 size); + ~SpriteResource(); +public: + byte *_data; + byte *_pixels; + uint32 *_palette; + int16 _width, _height; + uint16 _unk1; + uint16 _unk2; + uint16 _transparent; + uint16 _colorsCount; +}; + +class SoundResource { +public: + SoundResource(int resourceId, byte *data, uint32 size); + ~SoundResource(); +public: + byte *_data; + uint32 _size; +}; + +template <class ResourceClass, int ResourceType, bool FreeAfterLoad> +class ResourceCacheTemplate { +public: + + ResourceCacheTemplate(DatManager *dat) : _dat(dat) { + } + + ~ResourceCacheTemplate() { + } + + ResourceClass *get(int resourceId) { + Resource *resource = find(resourceId); + if (!resource) { + debug(1, "Loading resource type %d with ID %08X from disk", ResourceType, resourceId); + resource = new Resource(load(resourceId)); + _cache[resourceId] = resource; + } else { + debug(1, "Resource type %d with ID %08X was in cache", ResourceType, resourceId); + } + resource->_isLocked = true; + return resource->_obj; + } + + void release(int resourceId) { + Resource *resource = find(resourceId); + if (resource) + resource->_isLocked = false; + } + + void purge(bool force = false) { + debug("Count before purge: %d", _cache.size()); + for (CacheMapIterator it = _cache.begin(); it != _cache.end(); ++it) { + Resource *resource = it->_value; + if (force || !resource->_isLocked) { + delete resource; + _cache.erase(it); + } + } + debug("Count after purge: %d", _cache.size()); + } + +protected: + + struct Resource { + ResourceClass *_obj; + bool _isLocked; + Resource(ResourceClass *obj) : _obj(obj), _isLocked(false) {} + ~Resource() { delete _obj; } + }; + + typedef Common::HashMap<int, Resource*> CacheMap; + typedef typename CacheMap::iterator CacheMapIterator; + + DatManager *_dat; + CacheMap _cache; + + Resource *find(int resourceId) { + CacheMapIterator it = _cache.find(resourceId); + if (it != _cache.end()) + return it->_value; + return 0; + } + + ResourceClass *load(int resourceId) { + if (_dat->getResourceType(resourceId) != ResourceType) { + error("ResourceCache::load() Wrong resource type: Expected %d, got %d", ResourceType, _dat->getResourceType(resourceId)); + return 0; + } + byte *resourceData = _dat->loadResource(resourceId); + uint32 resourceSize = _dat->getResourceSize(resourceId); + ResourceClass *obj = new ResourceClass(resourceId, resourceData, resourceSize); + if (FreeAfterLoad) + delete[] resourceData; + return obj; + } + +}; + +typedef ResourceCacheTemplate<SpriteResource, kResTypeSprite, false> SpriteCache; +typedef ResourceCacheTemplate<SoundResource, kResTypeSound, false> SoundCache; +typedef ResourceCacheTemplate<SequenceResource, kResTypeSequence, true> SequenceCache; + +} // End of namespace Gnap + +#endif // GNAP_RESOURCE_H diff --git a/engines/gnap/scenes/scene01.cpp b/engines/gnap/scenes/scene01.cpp new file mode 100644 index 0000000000..0e4695c619 --- /dev/null +++ b/engines/gnap/scenes/scene01.cpp @@ -0,0 +1,373 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "gnap/gnap.h" +#include "gnap/gamesys.h" +#include "gnap/resource.h" + +namespace Gnap { + +enum { + kHSPlatypus = 0, + kHSExitTruck = 1, + kHSMud = 2, + kHSPigs = 3, + kHSSpaceship = 4, + kHSDevice = 5, + kHSWalkArea1 = 6, + kHSWalkArea2 = 7, + kHSWalkArea3 = 8, + kHSWalkArea4 = 9, + kHSWalkArea5 = 10, + kHSWalkArea6 = 11, + kHSWalkArea7 = 12, + kHSWalkArea8 = 13 +}; + +enum { + kASLookSpaceship = 1, + kASLookSpaceshipDone = 2, + kASLeaveScene = 3, + kASTakeMud = 5, + kASLookPigs = 6, + kASUsePigs = 7 +}; + +int GnapEngine::scene01_init() { + _gameSys->setAnimation(0, 0, 0); + _gameSys->setAnimation(0, 0, 3); + return 0x88; +} + +void GnapEngine::scene01_updateHotspots() { + setHotspot(kHSPlatypus, 0, 0, 0, 0, SF_DISABLED | SF_WALKABLE | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSExitTruck, 780, 226, 800, 455, SF_EXIT_R_CURSOR | SF_WALKABLE, 10, 6); + setHotspot(kHSMud, 138, 282, 204, 318, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR, 3, 5); + setHotspot(kHSPigs, 408, 234, 578, 326, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR, 6, 4); + setHotspot(kHSSpaceship, 0, 200, 94, 292, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR, 1, 6); + setHotspot(kHSWalkArea1, 0, 0, 162, 426); + setHotspot(kHSWalkArea2, 162, 0, 237, 396); + setHotspot(kHSWalkArea3, 237, 0, 319, 363); + setHotspot(kHSWalkArea4, 520, 0, 800, 404); + setHotspot(kHSWalkArea5, 300, 447, 800, 600); + setHotspot(kHSWalkArea6, 678, 0, 800, 404); + setHotspot(kHSWalkArea7, 0, 0, 520, 351); + setHotspot(kHSWalkArea8, 0, 546, 300, 600); + setDeviceHotspot(kHSDevice, -1, -1, -1, -1); + if (isFlag(0)) + _hotspots[kHSPlatypus].flags = SF_WALKABLE | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR; + if (isFlag(1)) + _hotspots[kHSMud].flags = SF_WALKABLE | SF_DISABLED; + _hotspotsCount = 14; +} + +void GnapEngine::scene01_run() { + + // NOTE Removed _s01_dword_474380 which was set when the mud was taken + // which is also set in the global game flags. + + playSound(0x1091C, 1); + startSoundTimerC(5); + + _gameSys->setAnimation(134, 20, 4); + _gameSys->insertSequence(134, 20, 0, 0, kSeqNone, 0, 0, 0); + + _gameSys->setAnimation(0x7F, 40, 2); + _gameSys->insertSequence(0x7F, 40, 0, 0, kSeqNone, 0, 0, 0); + + _timers[4] = getRandom(100) + 300; + + if (!isFlag(1)) + _gameSys->insertSequence(129, 40, 0, 0, kSeqNone, 0, 0, 0); + + queueInsertDeviceIcon(); + + if (_prevSceneNum == 2) { + initGnapPos(11, 6, 3); + if (isFlag(0)) + initBeaverPos(12, 6, 4); + endSceneInit(); + if (isFlag(0)) + platypusWalkTo(9, 6, -1, 0x107C2, 1); + gnapWalkTo(8, 6, -1, 0x107B9, 1); + } else { + initGnapPos(1, 6, 1); + if (isFlag(0)) + initBeaverPos(1, 7, 0); + endSceneInit(); + } + + while (!_sceneDone) { + + updateMouseCursor(); + updateCursorByHotspot(); + testWalk(0, 3, -1, -1, -1, -1); + + _sceneClickedHotspot = getClickedHotspotId(); + updateGrabCursorSprite(0, 0); + + switch (_sceneClickedHotspot) { + + case kHSDevice: + if (_gnapActionStatus < 0) { + runMenu(); + scene01_updateHotspots(); + } + break; + + case kHSPlatypus: + if (_gnapActionStatus < 0 && isFlag(0)) { + if (_grabCursorSpriteIndex == kItemDisguise) { + gnapUseDisguiseOnPlatypus(); + } else if (_grabCursorSpriteIndex >= 0) { + playGnapImpossible(0, 0); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + if (isFlag(5)) + playGnapMoan1(_platX, _platY); + else + playGnapScratchingHead(_platX, _platY); + break; + case GRAB_CURSOR: + gnapKissPlatypus(0); + break; + case TALK_CURSOR: + playGnapBrainPulsating(_platX, _platY); + playBeaverSequence(getBeaverSequenceId(0, 0, 0) | 0x10000); + break; + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + } + break; + + case kHSSpaceship: + if (_gnapActionStatus < 0) { + if (_grabCursorSpriteIndex >= 0) { + playGnapShowCurrItem(_hotspotsWalkPos[4].x, _hotspotsWalkPos[4].y, 0, 2); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + _gnapIdleFacing = 5; + if (gnapWalkTo(_hotspotsWalkPos[4].x, _hotspotsWalkPos[4].y, 0, getGnapSequenceId(gskIdle, 0, 0) | 0x10000, 1)) + _gnapActionStatus = kASLookSpaceship; + break; + case GRAB_CURSOR: + case TALK_CURSOR: + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + } + break; + + case kHSMud: + if (_gnapActionStatus < 0) { + if (_grabCursorSpriteIndex >= 0) { + playGnapShowCurrItem(_hotspotsWalkPos[2].x, _hotspotsWalkPos[2].y, 2, 3); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapScratchingHead(3, 3); + break; + case GRAB_CURSOR: + gnapWalkTo(_hotspotsWalkPos[2].x, _hotspotsWalkPos[2].y, 0, getGnapSequenceId(gskIdle, 2, 3) | 0x10000, 1); + _gnapActionStatus = kASTakeMud; + break; + case TALK_CURSOR: + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + } + break; + + case kHSPigs: + if (_gnapActionStatus < 0) { + if (_grabCursorSpriteIndex >= 0) { + playGnapShowCurrItem(_hotspotsWalkPos[3].x, _hotspotsWalkPos[3].y, 7, 2); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + _gnapIdleFacing = 7; + gnapWalkTo(_hotspotsWalkPos[3].x, _hotspotsWalkPos[3].y, 0, getGnapSequenceId(gskIdle, 7, 2) | 0x10000, 1); + _gnapActionStatus = kASLookPigs; + break; + case GRAB_CURSOR: + _gnapIdleFacing = 7; + gnapWalkTo(_hotspotsWalkPos[3].x, _hotspotsWalkPos[3].y, 0, getGnapSequenceId(gskIdle, 7, 2) | 0x10000, 1); + _gnapActionStatus = kASUsePigs; + break; + case TALK_CURSOR: + _gnapIdleFacing = 7; + gnapWalkTo(_hotspotsWalkPos[3].x, _hotspotsWalkPos[3].y, 0, getGnapSequenceId(gskBrainPulsating, 7, 2) | 0x10000, 1); + _gnapActionStatus = kASLookPigs; + break; + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + } + break; + + case kHSExitTruck: + if (_gnapActionStatus < 0) { + _isLeavingScene = true; + gnapWalkTo(_hotspotsWalkPos[1].x, _hotspotsWalkPos[1].y, 0, 0x107AB, 1); + _gnapActionStatus = kASLeaveScene; + if (isFlag(0)) + platypusWalkTo(_hotspotsWalkPos[1].x, _hotspotsWalkPos[1].y + 1, -1, 0x107CD, 1); + _newSceneNum = 2; + } + break; + + case kHSWalkArea1: + case kHSWalkArea2: + case kHSWalkArea3: + case kHSWalkArea4: + case kHSWalkArea5: + case kHSWalkArea6: + case kHSWalkArea7: + case kHSWalkArea8: + if (_gnapActionStatus < 0) + gnapWalkTo(-1, -1, -1, -1, 1); + break; + + default: + if (_mouseClickState.left && _gnapActionStatus < 0) { + gnapWalkTo(-1, -1, -1, -1, 1); + _mouseClickState.left = false; + } + break; + + } + + scene01_updateAnimations(); + + if (!isSoundPlaying(0x1091C)) + playSound(0x1091C, 1); + + if (!_isLeavingScene) { + if (_beaverActionStatus < 0 && isFlag(0)) + updateBeaverIdleSequence(); + if (_gnapActionStatus < 0) + updateGnapIdleSequence(); + if (_timers[4] == 0) { + // Update bird animation + _timers[4] = getRandom(100) + 300; + if (getRandom(1) == 0) + _gameSys->insertSequence(0x84, 180, 0, 0, kSeqNone, 0, 0, 0); + else + _gameSys->insertSequence(0x83, 180, 0, 0, kSeqNone, 0, 0, 0); + } + playSoundC(); + } + + checkGameKeys(); + if (isKeyStatus1(8)) { + clearKeyStatus1(8); + runMenu(); + scene01_updateHotspots(); + } + + gameUpdateTick(); + + } + +} + +void GnapEngine::scene01_updateAnimations() { + + if (_gameSys->getAnimationStatus(0) == 2) { + _gameSys->setAnimation(0, 0, 0); + switch (_gnapActionStatus) { + case kASLookSpaceship: + _s01_spaceshipSurface = _gameSys->createSurface(47); + _gameSys->insertSpriteDrawItem(_s01_spaceshipSurface, 0, 0, 255); + _gameSys->setAnimation(133, 256, 0); + _gameSys->insertSequence(133, 256, 0, 0, kSeqNone, 0, 0, 0); + _gnapActionStatus = kASLookSpaceshipDone; + break; + case kASLookSpaceshipDone: + _gameSys->removeSequence(133, 256, 1); + _gameSys->removeSpriteDrawItem(_s01_spaceshipSurface, 255); + deleteSurface(&_s01_spaceshipSurface); + _gnapActionStatus = -1; + break; + case kASLeaveScene: + _sceneDone = true; + break; + case kASTakeMud: + playGnapPullOutDevice(2, 3); + playGnapUseDevice(0, 0); + _gameSys->insertSequence(128, 40, 129, 40, kSeqSyncWait, 0, 0, 0); + _gameSys->setAnimation(128, 40, 3); + _gnapActionStatus = -1; + break; + case kASLookPigs: + playSound(138, 0); + playSound(139, 0); + playSound(140, 0); + _gnapActionStatus = -1; + break; + case kASUsePigs: + playGnapPullOutDevice(7, 2); + playGnapUseDevice(0, 0); + _gameSys->insertSequence(135, 39, 0, 0, kSeqNone, 25, getRandom(140) - 40, 0); + _gnapActionStatus = -1; + break; + } + } + + if (_gameSys->getAnimationStatus(3) == 2) { + _gameSys->setAnimation(0, 0, 3); + invAdd(kItemMud); + setGrabCursorSprite(kItemMud); + setFlag(1); + scene01_updateHotspots(); + } + + if (_gameSys->getAnimationStatus(4) == 2) { + _s01_smokeIdCtr = (_s01_smokeIdCtr + 1) % 2; + _gameSys->setAnimation(0x86, _s01_smokeIdCtr + 20, 4); + _gameSys->insertSequence(0x86, _s01_smokeIdCtr + 20, + 0x86, (_s01_smokeIdCtr + 1) % 2 + 20, + kSeqSyncWait, 0, 0, 0); + } + + if (_gameSys->getAnimationStatus(2) == 2) { + _s01_pigsIdCtr = (_s01_pigsIdCtr + 1) % 2; + _gameSys->setAnimation(0x7F, _s01_pigsIdCtr + 40, 2); + _gameSys->insertSequence(0x7F, _s01_pigsIdCtr + 40, + 0x7F, (_s01_pigsIdCtr + 1) % 2 + 40, + kSeqSyncWait, 0, 0, 0); + } + +} + +} // End of namespace Gnap diff --git a/engines/gnap/scenes/scene02.cpp b/engines/gnap/scenes/scene02.cpp new file mode 100644 index 0000000000..5d740b906f --- /dev/null +++ b/engines/gnap/scenes/scene02.cpp @@ -0,0 +1,539 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "gnap/gnap.h" +#include "gnap/gamesys.h" +#include "gnap/resource.h" + +namespace Gnap { + +enum { + kHSPlatypus = 0, + kHSChicken = 1, + kHSTruck1 = 2, + kHSTruck2 = 3, + kHSTruckGrill = 4, + kHSDevice = 5, + kHSExitHouse = 6, + kHSExitBarn = 7, + kHSExitCreek = 8, + kHSExitPigpen = 9, + kHSWalkArea1 = 10, + kHSWalkArea2 = 11, + kHSWalkArea3 = 12, + kHSWalkArea4 = 13 +}; + +enum { + kASUseTruckNoKeys = 0, + kASUseGasWithTruck = 1, + kASUseTruckGas = 2, + kASUseTruckNoGas = 3, + kASGrabTruckGrill = 5, + kASLeaveScene = 6, + kASTalkChicken = 7, + kASGrabChicken = 8, + kASGrabChickenDone = 9, + kASUseTruckNoKeysDone = 11, + kASUseGasWithTruckDone = 12, + kASUseTwigWithChicken = 16 +}; + +int GnapEngine::scene02_init() { + _gameSys->setAnimation(0, 0, 0); + return isFlag(9) ? 0x15A : 0x15B; +} + +void GnapEngine::scene02_updateHotspots() { + setHotspot(kHSPlatypus, 0, 0, 0, 0, SF_DISABLED | SF_WALKABLE); + setHotspot(kHSChicken, 606, 455, 702, 568, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR, 7, 8); + setHotspot(kHSTruck1, 385, 258, 464, 304, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR, 6, 5); + setHotspot(kHSTruck2, 316, 224, 390, 376, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR, 5, 6); + setHotspot(kHSTruckGrill, 156, 318, 246, 390, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR, 2, 7); + setHotspot(kHSExitHouse, 480, 120, 556, 240, SF_EXIT_U_CURSOR, 7, 5); + setHotspot(kHSExitBarn, 610, 0, 800, 164, SF_EXIT_U_CURSOR, 10, 5); + setHotspot(kHSExitCreek, 780, 336, 800, 556, SF_EXIT_R_CURSOR | SF_WALKABLE, 10, 8); + setHotspot(kHSExitPigpen, 0, 300, 20, 600, SF_EXIT_L_CURSOR | SF_WALKABLE, 0, 8); + setHotspot(kHSWalkArea1, 92, 140, 304, 430, 0, 3, 1); + setHotspot(kHSWalkArea2, 0, 0, 800, 380); + setHotspot(kHSWalkArea3, 0, 0, 386, 445); + setHotspot(kHSWalkArea4, 386, 0, 509, 410); + setDeviceHotspot(kHSDevice, -1, -1, -1, -1); + if (isFlag(0)) + _hotspots[kHSPlatypus].flags = SF_WALKABLE | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR; + _hotspotsCount = 14; +} + +void GnapEngine::scene02_run() { + + playSound(0x1091C, 1); + startSoundTimerC(6); + + _s02_currChickenSequenceId = 0x14B; + _gameSys->setAnimation(0x14B, 179, 2); + _gameSys->insertSequence(0x14B, 179, 0, 0, kSeqNone, 0, 0, 0); + + _s02_nextChickenSequenceId = -1; + _timers[5] = getRandom(20) + 30; + _timers[4] = getRandom(100) + 300; + + queueInsertDeviceIcon(); + + switch (_prevSceneNum) { + case 3: + initGnapPos(11, 6, 3); + if (isFlag(0)) + initBeaverPos(12, 6, 4); + endSceneInit(); + if (isFlag(0)) + platypusWalkTo(9, 6, -1, 0x107C2, 1); + gnapWalkTo(8, 6, -1, 0x107BA, 1); + break; + case 4: + initGnapPos(_hotspotsWalkPos[6].x, _hotspotsWalkPos[6].y, 3); + if (isFlag(0)) + initBeaverPos(_hotspotsWalkPos[6].x + 1, _hotspotsWalkPos[6].y, 4); + endSceneInit(); + gnapWalkTo(7, 6, 0, 0x107B9, 1); + if (isFlag(0)) + platypusWalkTo(8, 6, 1, 0x107C2, 1); + scene02_updateHotspots(); + _gameSys->waitForUpdate(); + break; + case 47: + clearFlag(25); + initGnapPos(5, 6, 3); + initBeaverPos(6, 7, 4); + endSceneInit(); + break; + case 49: + initGnapPos(5, 6, 1); + if (isFlag(0)) + initBeaverPos(6, 7, 0); + endSceneInit(); + break; + default: + initGnapPos(-1, 6, 1); + if (isFlag(0)) + initBeaverPos(-1, 7, 0); + endSceneInit(); + if (isFlag(0)) + platypusWalkTo(2, 7, -1, 0x107C2, 1); + gnapWalkTo(2, 8, -1, 0x107B9, 1); + break; + } + + while (!_sceneDone) { + + updateMouseCursor(); + + updateCursorByHotspot(); + + testWalk(0, 6, 7, 6, 8, 6); + + _sceneClickedHotspot = getClickedHotspotId(); + updateGrabCursorSprite(0, 0); + + switch (_sceneClickedHotspot) { + + case kHSDevice: + if (_gnapActionStatus < 0) { + runMenu(); + scene02_updateHotspots(); + } + break; + + case kHSPlatypus: + if (_gnapActionStatus < 0 && isFlag(0)) { + if (_grabCursorSpriteIndex == kItemDisguise) { + gnapUseDisguiseOnPlatypus(); + } else if (_grabCursorSpriteIndex >= 0) { + playGnapImpossible(0, 0); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + if (isFlag(5)) + playGnapMoan1(_platX, _platY); + else + playGnapScratchingHead(_platX, _platY); + break; + case GRAB_CURSOR: + gnapKissPlatypus(0); + break; + case TALK_CURSOR: + playGnapBrainPulsating(_platX, _platY); + playBeaverSequence(getBeaverSequenceId(0, 0, 0) | 0x10000); + break; + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + } + break; + + case kHSChicken: + if (_gnapActionStatus < 0) { + if (_grabCursorSpriteIndex == kItemTwig) { + _gnapIdleFacing = 7; + gnapWalkTo(_hotspotsWalkPos[_sceneClickedHotspot].x, _hotspotsWalkPos[_sceneClickedHotspot].y + 1, + 0, getGnapSequenceId(gskIdle, 0, 0) | 0x10000, 1); + _gnapActionStatus = kASUseTwigWithChicken; + } else if (_grabCursorSpriteIndex >= 0) { + playGnapShowCurrItem(_hotspotsWalkPos[1].x, _hotspotsWalkPos[1].y + 1, 9, 8); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapMoan2(9, 8); + break; + case GRAB_CURSOR: + _gnapIdleFacing = 1; + if (gnapWalkTo(_hotspotsWalkPos[1].x, _hotspotsWalkPos[1].y, 0, getGnapSequenceId(gskIdle, 0, 0) | 0x10000, 1)) + _gnapActionStatus = kASGrabChicken; + else + _gnapActionStatus = -1; + break; + case TALK_CURSOR: + _gnapIdleFacing = 1; + gnapWalkTo(_hotspotsWalkPos[1].x, _hotspotsWalkPos[1].y, 0, getGnapSequenceId(gskBrainPulsating, 0, 0) | 0x10000, 1); + _gnapActionStatus = kASTalkChicken; + break; + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + } + break; + + case kHSTruck1: + case kHSTruck2: + if (_gnapActionStatus < 0) { + if (_grabCursorSpriteIndex == kItemKeys) { + if (gnapWalkTo(_hotspotsWalkPos[3].x, _hotspotsWalkPos[3].y, 0, getGnapSequenceId(gskIdle, 2, 2) | 0x10000, 1)) { + setGrabCursorSprite(-1); + invRemove(kItemKeys); + if (isFlag(8)) + _gnapActionStatus = kASUseTruckGas; + else + _gnapActionStatus = kASUseTruckNoGas; + } + } else if (_grabCursorSpriteIndex == kItemGas) { + _hotspots[kHSWalkArea4].flags |= SF_WALKABLE; + if (gnapWalkTo(_hotspotsWalkPos[2].x, _hotspotsWalkPos[2].y, 0, getGnapSequenceId(gskIdle, 2, 2) | 0x10000, 1)) + _gnapActionStatus = kASUseGasWithTruck; + _hotspots[kHSWalkArea4].flags &= ~SF_WALKABLE; + } else if (_grabCursorSpriteIndex >= 0) { + playGnapShowCurrItem(_hotspotsWalkPos[2].x, _hotspotsWalkPos[2].y, 2, 2); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapScratchingHead(2, 2); + break; + case GRAB_CURSOR: + if (isFlag(9)) { + if (gnapWalkTo(_hotspotsWalkPos[3].x, _hotspotsWalkPos[3].y, 0, getGnapSequenceId(gskIdle, 2, 2) | 0x10000, 1)) { + if (isFlag(8)) + _gnapActionStatus = kASUseTruckGas; + else + _gnapActionStatus = kASUseTruckNoGas; + } + } else { + _gnapIdleFacing = 4; + if (gnapWalkTo(_hotspotsWalkPos[3].x, _hotspotsWalkPos[3].y, 0, getGnapSequenceId(gskIdle, 2, 2) | 0x10000, 1)) + _gnapActionStatus = kASUseTruckNoKeys; + } + break; + case TALK_CURSOR: + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + } + break; + + case kHSTruckGrill: + if (_gnapActionStatus < 0) { + if (_grabCursorSpriteIndex >= 0) { + playGnapShowCurrItem(_hotspotsWalkPos[4].x, _hotspotsWalkPos[4].y, 2, 4); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapMoan2(2, 4); + break; + case GRAB_CURSOR: + _gnapIdleFacing = 7; + gnapWalkTo(_hotspotsWalkPos[4].x, _hotspotsWalkPos[4].y, 0, getGnapSequenceId(gskIdle, 0, 0) | 0x10000, 1); + _gnapActionStatus = kASGrabTruckGrill; + break; + case TALK_CURSOR: + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + } + break; + + case kHSExitHouse: + if (_gnapActionStatus < 0) { + _isLeavingScene = 1; + gnapWalkTo(_hotspotsWalkPos[6].x, _hotspotsWalkPos[6].y, 0, 0x107AD, 1); + _gnapActionStatus = kASLeaveScene; + if (isFlag(0)) + platypusWalkTo(_hotspotsWalkPos[6].x + 1, _hotspotsWalkPos[6].y, -1, 0x107C1, 1); + scene02_updateHotspots(); + _newSceneNum = 4; + } + break; + + case kHSExitBarn: + if (_gnapActionStatus < 0) { + _isLeavingScene = 1; + gnapWalkTo(_hotspotsWalkPos[7].x, _hotspotsWalkPos[7].y, 0, 0x107AD, 1); + _gnapActionStatus = kASLeaveScene; + if (isFlag(0)) + platypusWalkTo(_hotspotsWalkPos[7].x + 1, _hotspotsWalkPos[7].y, -1, 0x107C1, 1); + scene02_updateHotspots(); + _newSceneNum = 5; + } + break; + + case kHSExitCreek: + if (_gnapActionStatus < 0) { + _isLeavingScene = 1; + gnapWalkTo(_hotspotsWalkPos[8].x, _hotspotsWalkPos[8].y, 0, 0x107AB, 1); + _gnapActionStatus = kASLeaveScene; + if (isFlag(0)) + platypusWalkTo(_hotspotsWalkPos[8].x, _hotspotsWalkPos[8].y, -1, 0x107CD, 1); + _newSceneNum = 3; + } + break; + + case kHSExitPigpen: + if (_gnapActionStatus < 0) { + _isLeavingScene = 1; + gnapWalkTo(_hotspotsWalkPos[9].x, _hotspotsWalkPos[9].y, 0, 0x107AF, 1); + _gnapActionStatus = kASLeaveScene; + if (isFlag(0)) + platypusWalkTo(_hotspotsWalkPos[9].x, _hotspotsWalkPos[9].y, -1, 0x107CF, 1); + _newSceneNum = 1; + } + break; + + case kHSWalkArea1: + case kHSWalkArea2: + case kHSWalkArea3: + case kHSWalkArea4: + if (_gnapActionStatus < 0) + gnapWalkTo(-1, -1, -1, -1, 1); + break; + + default: + if (_mouseClickState.left && _gnapActionStatus < 0) { + gnapWalkTo(-1, -1, -1, -1, 1); + _mouseClickState.left = false; + } + break; + + } + + scene02_updateAnimations(); + + if (!isSoundPlaying(0x1091C)) + playSound(0x1091C, 1); + + if (!_isLeavingScene) { + if (_beaverActionStatus < 0 && isFlag(0)) + updateBeaverIdleSequence(); + if (_gnapActionStatus < 0) + updateGnapIdleSequence(); + if (!_timers[4]) { + // Update bird animation + _timers[4] = getRandom(100) + 300; + if (getRandom(2) != 0) + _gameSys->insertSequence(0x156, 256, 0, 0, kSeqNone, 0, 0, 0); + else + _gameSys->insertSequence(0x154, 256, 0, 0, kSeqNone, 0, 0, 0); + } + if (!_timers[5] && _s02_nextChickenSequenceId == -1 && _gnapActionStatus != 7 && _gnapActionStatus != 8) { + if (getRandom(6) != 0) { + _s02_nextChickenSequenceId = 0x14B; + _timers[5] = getRandom(20) + 30; + } else { + _s02_nextChickenSequenceId = 0x14D; + _timers[5] = getRandom(20) + 50; + } + } + playSoundC(); + } + + checkGameKeys(); + + if (isKeyStatus1(8)) { + clearKeyStatus1(8); + runMenu(); + scene02_updateHotspots(); + } + + gameUpdateTick(); + + } + +} + +void GnapEngine::scene02_updateAnimations() { + + if (_gameSys->getAnimationStatus(0) == 2) { + switch (_gnapActionStatus) { + case kASUseTruckNoKeys: + _gameSys->insertSequence(0x14E, _gnapId, makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, kSeqSyncWait, 0, 0, 0); + _gameSys->setAnimation(0x14E, _gnapId, 0); + _gnapSequenceId = 0x14E; + _gnapSequenceDatNum = 0; + _gnapActionStatus = kASUseTruckNoKeysDone; + break; + case kASUseGasWithTruck: + _gameSys->insertSequence(0x151, _gnapId, makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, kSeqSyncWait, 0, 0, 0); + _gameSys->setAnimation(0x151, _gnapId, 0); + _gnapSequenceId = 0x151; + _gnapSequenceDatNum = 0; + invRemove(kItemGas); + setGrabCursorSprite(-1); + setFlag(8); + _gnapActionStatus = kASUseGasWithTruckDone; + break; + case kASUseTruckGas: + _timers[5] = 9999; + _timers[4] = 9999; + hideCursor(); + setGrabCursorSprite(-1); + if (!isFlag(9)) { + _gameSys->insertSequence(0x14F, _gnapId, makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, kSeqSyncWait, 0, 0, 0); + _gameSys->waitForUpdate(); + setFlag(9); + _gnapSequenceId = 0x14F; + _gnapSequenceDatNum = 0; + invRemove(kItemKeys); + setGrabCursorSprite(-1); + } + _newSceneNum = 47; + _sceneDone = true; + break; + case kASUseTruckNoGas: + hideCursor(); + setGrabCursorSprite(-1); + _timers[4] = 250; + if (!isFlag(9)) { + _gameSys->insertSequence(0x14F, _gnapId, makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, kSeqSyncWait, 0, 0, 0); + _gameSys->waitForUpdate(); + setFlag(9); + _gnapSequenceId = 0x14F; + _gnapSequenceDatNum = 0; + invRemove(kItemKeys); + setGrabCursorSprite(-1); + } + _newSceneNum = 47; + _sceneDone = true; + setFlag(25); + break; + case kASGrabTruckGrill: + switch (_s02_truckGrillCtr) { + case 0: + _s02_gnapTruckSequenceId = 0x158; + break; + case 1: + _s02_gnapTruckSequenceId = 0x159; + break; + case 2: + _s02_gnapTruckSequenceId = 0x157; + break; + } + _s02_truckGrillCtr = (_s02_truckGrillCtr + 1) % 3; + _gameSys->insertSequence(_s02_gnapTruckSequenceId, _gnapId, makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, kSeqSyncWait, 0, 0, 0); + _gameSys->setAnimation(_s02_gnapTruckSequenceId, _gnapId, 0); + _gnapSequenceId = _s02_gnapTruckSequenceId; + _gnapSequenceDatNum = 0; + _gnapActionStatus = -1; + break; + case kASLeaveScene: + _sceneDone = true; + break; + case kASTalkChicken: + _s02_nextChickenSequenceId = 0x14C; + break; + case kASGrabChicken: + _s02_nextChickenSequenceId = 0x150; + _timers[2] = 100; + break; + case kASGrabChickenDone: + _gameSys->insertSequence(0x107B5, _gnapId, 0x150, 179, kSeqSyncWait, 0, 75 * _gnapX - _gnapGridX, 48 * _gnapY - _gnapGridY); + _gnapSequenceId = 0x7B5; + _gnapSequenceDatNum = 1; + _s02_currChickenSequenceId = 0x14B; + _gameSys->setAnimation(0x14B, 179, 2); + _gameSys->insertSequence(_s02_currChickenSequenceId, 179, 0, 0, kSeqNone, 0, 0, 0); + _gnapActionStatus = -1; + _timers[5] = 30; + break; + case kASUseTwigWithChicken: + playGnapShowItem(5, 0, 0); + _gameSys->insertSequence(0x155, 179, _s02_currChickenSequenceId, 179, 32, 0, 0, 0); + _s02_currChickenSequenceId = 0x155; + _s02_nextChickenSequenceId = -1; + _gnapActionStatus = -1; + break; + case kASUseTruckNoKeysDone: + case kASUseGasWithTruckDone: + default: + _gnapActionStatus = -1; + break; + } + } + + if (_gameSys->getAnimationStatus(2) == 2) { + if (_s02_nextChickenSequenceId == 0x150) { + _gameSys->setAnimation(_s02_nextChickenSequenceId, 179, 0); + _gameSys->insertSequence(_s02_nextChickenSequenceId, 179, makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, kSeqSyncWait, 0, 0, 0); + _gameSys->removeSequence(_s02_currChickenSequenceId, 179, 1); + _s02_nextChickenSequenceId = -1; + _s02_currChickenSequenceId = -1; + _gnapActionStatus = kASGrabChickenDone; + _timers[5] = 500; + } else if (_s02_nextChickenSequenceId == 0x14C) { + _gameSys->setAnimation(_s02_nextChickenSequenceId, 179, 2); + _gameSys->insertSequence(_s02_nextChickenSequenceId, 179, _s02_currChickenSequenceId, 179, kSeqSyncWait, 0, 0, 0); + _s02_currChickenSequenceId = _s02_nextChickenSequenceId; + _s02_nextChickenSequenceId = -1; + _gnapActionStatus = -1; + } else if (_s02_nextChickenSequenceId != -1) { + _gameSys->setAnimation(_s02_nextChickenSequenceId, 179, 2); + _gameSys->insertSequence(_s02_nextChickenSequenceId, 179, _s02_currChickenSequenceId, 179, kSeqSyncWait, 0, 0, 0); + _s02_currChickenSequenceId = _s02_nextChickenSequenceId; + _s02_nextChickenSequenceId = -1; + } + } + +} + +} // End of namespace Gnap diff --git a/engines/gnap/scenes/scene03.cpp b/engines/gnap/scenes/scene03.cpp new file mode 100644 index 0000000000..6f191dc6e3 --- /dev/null +++ b/engines/gnap/scenes/scene03.cpp @@ -0,0 +1,517 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "gnap/gnap.h" +#include "gnap/gamesys.h" +#include "gnap/resource.h" + +namespace Gnap { + +enum { + kHSPlatypus = 0, + kHSGrass = 1, + kHSExitTruck = 2, + kHSCreek = 3, + kHSTrappedPlatypus = 4, + kHSDevice = 5, + kHSWalkAreas1 = 6, + kHSWalkAreas2 = 7, + kHSPlatypusWalkArea = 8, + kHSWalkAreas3 = 9 +}; + +enum { + kASLeaveScene = 0, + kASFreePlatypus = 1, + kASHypnotizePlat = 2, + kASHypnotizeScaredPlat = 3, + kASFreePlatypusDone = 4, + kASGrabPlatypus = 5, + kASGrabCreek = 6, + kASGrabCreekDone = 7, + kASGrabScaredPlatypus = 8 +}; + +int GnapEngine::scene03_init() { + _gameSys->setAnimation(0, 0, 0); + _gameSys->setAnimation(0, 0, 1); + _gameSys->setAnimation(0, 0, 5); + return 0x1CC; +} + +void GnapEngine::scene03_updateHotspots() { + setHotspot(kHSPlatypus, 0, 0, 0, 0, SF_DISABLED | SF_WALKABLE | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSGrass, 646, 408, 722, 458, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR, 9, 6); + setHotspot(kHSExitTruck, 218, 64, 371, 224, SF_EXIT_U_CURSOR | SF_WALKABLE, 4, 4); + setHotspot(kHSCreek, 187, 499, 319, 587, SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR, 3, 7); + setHotspot(kHSTrappedPlatypus, 450, 256, 661, 414, SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR, 2, 5); + setHotspot(kHSWalkAreas1, 0, 500, 300, 600); + setHotspot(kHSWalkAreas2, 300, 447, 800, 600); + setHotspot(kHSPlatypusWalkArea, 235, 0, 800, 600); + setHotspot(kHSWalkAreas3, 0, 0, 800, 354); + setDeviceHotspot(kHSDevice, -1, -1, -1, -1); + if (isFlag(0)) + _hotspots[kHSPlatypus].flags = SF_WALKABLE | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR; + if (isFlag(6)) + _hotspots[kHSGrass].flags = SF_WALKABLE | SF_DISABLED; + if (isFlag(0)) + _hotspots[kHSTrappedPlatypus].flags = SF_DISABLED; + if (isFlag(0) || _s03_platypusHypnotized) + _hotspots[kHSPlatypusWalkArea].flags |= SF_WALKABLE; + _hotspotsCount = 10; +} + +void GnapEngine::scene03_run() { + + playSound(0x10925, 1); + + startSoundTimerC(7); + + _gameSys->insertSequence(0x1CA, 251, 0, 0, kSeqLoop, 0, 0, 0); + _gameSys->insertSequence(0x1CB, 251, 0, 0, kSeqLoop, 0, 0, 0); + + _s03_platypusHypnotized = false; + + initGnapPos(3, 4, 1); + + _gameSys->insertSequence(0x1C6, 253, 0, 0, kSeqNone, 0, 0, 0); + + _s03_currFrogSequenceId = 0x1C6; + _s03_nextFrogSequenceId = -1; + _gameSys->setAnimation(0x1C6, 253, 2); + + _timers[6] = getRandom(20) + 30; + _timers[4] = getRandom(100) + 300; + _timers[5] = getRandom(100) + 200; + + if (isFlag(0)) { + initBeaverPos(5, 4, 0); + } else { + _timers[1] = getRandom(40) + 20; + _gameSys->setAnimation(0x1C2, 99, 1); + _gameSys->insertSequence(0x1C2, 99, 0, 0, kSeqNone, 0, 0, 0); + _beaverSequenceId = 0x1C2; + _beaverSequenceDatNum = 0; + } + + _gameSys->insertSequence(0x1C4, 255, 0, 0, kSeqNone, 0, 0, 0); + + if (!isFlag(6)) + _gameSys->insertSequence(0x1B2, 253, 0, 0, kSeqNone, 0, 0, 0); + + queueInsertDeviceIcon(); + + endSceneInit(); + + if (isFlag(0)) + platypusWalkTo(4, 7, -1, 0x107C2, 1); + gnapWalkTo(3, 6, -1, 0x107B9, 1); + + while (!_sceneDone) { + + updateMouseCursor(); + updateCursorByHotspot(); + + _sceneClickedHotspot = getClickedHotspotId(); + updateGrabCursorSprite(0, 0); + + switch (_sceneClickedHotspot) { + + case kHSPlatypus: + if (_gnapActionStatus < 0 && isFlag(0)) { + if (_grabCursorSpriteIndex == kItemDisguise) { + gnapUseDisguiseOnPlatypus(); + } else if (_grabCursorSpriteIndex >= 0) { + playGnapImpossible(0, 0); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + if (isFlag(5)) + playGnapMoan1(_platX, _platY); + else + playGnapScratchingHead(_platX, _platY); + break; + case GRAB_CURSOR: + gnapKissPlatypus(0); + break; + case TALK_CURSOR: + playGnapBrainPulsating(_platX, _platY); + playBeaverSequence(getBeaverSequenceId(0, 0, 0) | 0x10000); + break; + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + } + break; + + case kHSGrass: + if (_gnapActionStatus < 0) { + if (isFlag(6)) { + gnapWalkTo(-1, -1, -1, -1, 1); + } else if (_grabCursorSpriteIndex >= 0) { + playGnapShowItem(_grabCursorSpriteIndex, 9, 6); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapScratchingHead(9, 6); + break; + case GRAB_CURSOR: + playGnapPullOutDevice(9, 6); + playGnapUseDevice(0, 0); + _gameSys->insertSequence(0x1B3, 253, 0x1B2, 253, kSeqSyncWait, 0, 0, 0); + _gameSys->setAnimation(0x1B3, 253, 5); + _hotspots[kHSGrass].flags |= SF_WALKABLE | SF_DISABLED; + break; + case TALK_CURSOR: + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + } + break; + + case kHSExitTruck: + if (_gnapActionStatus < 0) { + _isLeavingScene = 1; + _hotspots[kHSPlatypusWalkArea].flags |= SF_WALKABLE; + gnapWalkTo(_hotspotsWalkPos[2].x, _hotspotsWalkPos[2].y, 0, 0x107AD, 1); + _gnapActionStatus = kASLeaveScene; + if (isFlag(0)) + platypusWalkTo(_hotspotsWalkPos[2].x, _hotspotsWalkPos[2].y, -1, 0x107C2, 1); + _hotspots[kHSPlatypusWalkArea].flags &= ~SF_WALKABLE; + if (_cursorValue == 1) + _newSceneNum = 2; + else + _newSceneNum = 33; + } + break; + + case kHSCreek: + if (_gnapActionStatus == -1) { + if (_grabCursorSpriteIndex >= 0) { + playGnapImpossible(0, 0); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapMoan2(2, 8); + break; + case GRAB_CURSOR: + if (!isFlag(0)) + _hotspots[kHSPlatypusWalkArea].flags |= SF_WALKABLE; + if (gnapWalkTo(_hotspotsWalkPos[3].x, _hotspotsWalkPos[3].y, 0, getGnapSequenceId(gskIdle, _hotspotsWalkPos[3].x + 1, _hotspotsWalkPos[3].y + 1) | 0x10000, 1)) + _gnapActionStatus = kASGrabCreek; + if (!isFlag(0)) + _hotspots[kHSPlatypusWalkArea].flags &= ~SF_WALKABLE; + break; + case TALK_CURSOR: + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + } + break; + + case kHSTrappedPlatypus: + if (_gnapActionStatus < 0) { + if (isFlag(0)) { + gnapWalkTo(-1, -1, -1, -1, 1); + } else if (_grabCursorSpriteIndex >= 0) { + playGnapShowItem(_grabCursorSpriteIndex, 8, 4); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapScratchingHead(8, 4); + break; + case GRAB_CURSOR: + if (_s03_platypusHypnotized) { + gnapWalkTo(7, 6, 0, 0x107B5, 1); + _gnapActionStatus = kASFreePlatypus; + } else { + gnapWalkTo(_hotspotsWalkPos[4].x, _hotspotsWalkPos[4].y, 0, getGnapSequenceId(gskIdle, 0, 0) | 0x10000, 1); + if (_s03_platypusScared) + _gnapActionStatus = kASGrabScaredPlatypus; + else + _gnapActionStatus = kASGrabPlatypus; + } + break; + case TALK_CURSOR: + if (_s03_platypusHypnotized) { + playGnapBrainPulsating(8, 4); + } else { + _gnapIdleFacing = 1; + gnapWalkTo(_hotspotsWalkPos[4].x, _hotspotsWalkPos[4].y, 0, getGnapSequenceId(gskIdle, 0, 0) | 0x10000, 1); + if (_s03_platypusScared) + _gnapActionStatus = kASHypnotizeScaredPlat; + else + _gnapActionStatus = kASHypnotizePlat; + } + break; + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + } + break; + + case kHSDevice: + if (_gnapActionStatus < 0) { + runMenu(); + scene03_updateHotspots(); + } + break; + + case kHSWalkAreas1: + case kHSWalkAreas2: + case kHSWalkAreas3: + if (_gnapActionStatus < 0) + gnapWalkTo(-1, -1, -1, -1, 1); + break; + + case kHSPlatypusWalkArea: + if (_gnapActionStatus < 0) { + if (isFlag(0) || _s03_platypusHypnotized) { + gnapWalkTo(-1, -1, -1, -1, 1); + } else { + gnapWalkTo(_hotspotsWalkPos[4].x, _hotspotsWalkPos[4].y, 0, 0x107B5, 1); + if (_s03_platypusScared) + _gnapActionStatus = kASGrabScaredPlatypus; + else + _gnapActionStatus = kASGrabPlatypus; + } + } + break; + + default: + if (_mouseClickState.left && _gnapActionStatus < 0) { + gnapWalkTo(-1, -1, -1, -1, 1); + _mouseClickState.left = false; + } + break; + + } + + scene03_updateAnimations(); + + if (!isSoundPlaying(0x10925)) + playSound(0x10925, 1); + + if (!_isLeavingScene) { + if (_beaverActionStatus < 0 && isFlag(0)) + updateBeaverIdleSequence(); + if (_gnapActionStatus < 0) + updateGnapIdleSequence(); + if (!_timers[1] && !_s03_platypusScared) { + _timers[1] = getRandom(40) + 20; + if (_gnapActionStatus < 0 && _beaverActionStatus < 0 && !isFlag(0) && !_s03_platypusHypnotized) + _s03_nextPlatSequenceId = 450; + } + if (!_timers[6]) { + _timers[6] = getRandom(20) + 30; + if (_gnapActionStatus < 0 && _beaverActionStatus < 0 && _s03_nextFrogSequenceId == -1) { + if (getRandom(5) == 1) + _s03_nextFrogSequenceId = 0x1C6; + else + _s03_nextFrogSequenceId = 0x1C7; + } + } + if (!_timers[4]) { + // Update bird animation + _timers[4] = getRandom(100) + 300; + if (_gnapActionStatus < 0 && _beaverActionStatus < 0) + _gameSys->insertSequence(getRandom(2) != 0 ? 0x1C8 : 0x1C3, 253, 0, 0, kSeqNone, 0, 0, 0); + } + if (!_timers[5]) { + _timers[5] = getRandom(100) + 200; + if (_gnapActionStatus < 0 && _beaverActionStatus < 0) { + _gameSys->setAnimation(0x1C5, 253, 4); + _gameSys->insertSequence(0x1C5, 253, 0, 0, kSeqNone, 0, 0, 0); + } + } + playSoundC(); + } + + checkGameKeys(); + + if (isKeyStatus1(8)) { + clearKeyStatus1(8); + runMenu(); + scene03_updateHotspots(); + _timers[5] = getRandom(100) + 200; + _timers[4] = getRandom(100) + 300; + _timers[6] = getRandom(20) + 30; + } + + gameUpdateTick(); + + } + +} + +void GnapEngine::scene03_updateAnimations() { + + if (_gameSys->getAnimationStatus(0) == 2) { + _gameSys->setAnimation(0, 0, 0); + switch (_gnapActionStatus) { + case kASLeaveScene: + _sceneDone = true; + break; + case kASFreePlatypus: + _s03_nextPlatSequenceId = 0x1BC; + break; + case kASFreePlatypusDone: + _gnapActionStatus = -1; + _platX = 6; + _platY = 6; + _beaverFacing = 4; + _beaverId = 120; + _gameSys->insertSequence(0x107CA, _beaverId, 0x1BC, 99, + kSeqSyncWait, 0, 75 * _platX - _platGridX, 48 * _platY - _platGridY); + _gameSys->insertSequence(0x1B7, 99, 0, 0, kSeqNone, 0, 0, 0); + _beaverSequenceDatNum = 1; + _beaverSequenceId = 0x7CA; + setFlag(0); + _s03_nextPlatSequenceId = -1; + scene03_updateHotspots(); + break; + case kASHypnotizePlat: + playGnapBrainPulsating(0, 0); + addFullScreenSprite(0x106, 255); + _gameSys->setAnimation(0x1C9, 256, 1); + _gameSys->insertSequence(0x1C9, 256, 0, 0, kSeqNone, 0, 0, 0); + while (_gameSys->getAnimationStatus(1) != 2) + gameUpdateTick(); + removeFullScreenSprite(); + _gameSys->setAnimation(0x1BA, 99, 1); + _gameSys->insertSequence(0x1BA, 99, _beaverSequenceId | (_beaverSequenceDatNum << 16), 99, 32, 0, 0, 0); + _beaverSequenceDatNum = 0; + _beaverSequenceId = 0x1BA; + _gnapActionStatus = -1; + _s03_platypusHypnotized = true; + scene03_updateHotspots(); + break; + case kASHypnotizeScaredPlat: + playGnapBrainPulsating(0, 0); + _gameSys->insertSequence(0x1BF, 99, _beaverSequenceId | (_beaverSequenceDatNum << 16), 99, 32, 0, 0, 0); + _gameSys->setAnimation(0x1BF, 99, 1); + while (_gameSys->getAnimationStatus(1) != 2) + gameUpdateTick(); + addFullScreenSprite(0x106, 255); + _gameSys->setAnimation(0x1C9, 256, 1); + _gameSys->insertSequence(0x1C9, 256, 0, 0, kSeqNone, 0, 0, 0); + while (_gameSys->getAnimationStatus(1) != 2) + gameUpdateTick(); + removeFullScreenSprite(); + _gameSys->setAnimation(0x1BA, 99, 1); + _gameSys->insertSequence(0x1BA, 99, 447, 99, kSeqSyncWait, 0, 0, 0); + _beaverSequenceDatNum = 0; + _beaverSequenceId = 0x1BA; + _gnapActionStatus = -1; + _s03_platypusHypnotized = true; + scene03_updateHotspots(); + break; + case kASGrabPlatypus: + _s03_nextPlatSequenceId = 0x1BD; + _s03_platypusHypnotized = false; + break; + case kASGrabScaredPlatypus: + _s03_nextPlatSequenceId = 0x1C0; + _s03_platypusHypnotized = false; + break; + case kASGrabCreek: + _gameSys->insertSequence(0x1B4, _gnapId, makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, kSeqSyncWait, 0, 0, 0); + _gameSys->setAnimation(0x1B4, _gnapId, 0); + _gnapSequenceId = 0x1B4; + _gnapSequenceDatNum = 0; + _gnapActionStatus = kASGrabCreekDone; + break; + default: + _gnapActionStatus = -1; + break; + } + } + + if (_gameSys->getAnimationStatus(1) == 2) { + if (_s03_nextPlatSequenceId == 0x1BD || _s03_nextPlatSequenceId == 0x1C0) { + _gameSys->setAnimation(0, 0, 1); + _s03_platypusScared = true; + _gameSys->insertSequence(0x1B5, _gnapId, makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, kSeqSyncWait, 0, 0, 0); + _gameSys->insertSequence(_s03_nextPlatSequenceId, 99, _beaverSequenceId | (_beaverSequenceDatNum << 16), 99, kSeqSyncWait, 0, 0, 0); + _gnapSequenceId = 0x1B5; + _gnapSequenceDatNum = 0; + _gnapIdleFacing = 0; + _beaverSequenceId = _s03_nextPlatSequenceId; + _beaverSequenceDatNum = 0; + _gameSys->setAnimation(_s03_nextPlatSequenceId, 99, 1); + _s03_nextPlatSequenceId = -1; + _gnapActionStatus = -1; + } else if (_s03_nextPlatSequenceId == 0x1BC) { + _gnapX = 3; + _gnapY = 6; + _gameSys->insertSequence(0x1B6, 120, makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, kSeqSyncWait, 0, 0, 0); + _gameSys->insertSequence(0x1BC, 99, _beaverSequenceId | (_beaverSequenceDatNum << 16), 99, kSeqSyncWait, 0, 0, 0); + _gameSys->setAnimation(0x1BC, 99, 0); + _gnapId = 20 * _gnapY; + _gnapSequenceId = 0x1B6; + _gnapSequenceDatNum = 0; + _gnapIdleFacing = 0; + _gnapActionStatus = kASFreePlatypusDone; + _s03_nextPlatSequenceId = -1; + } else if (_s03_nextPlatSequenceId == 0x1C2 && !_s03_platypusScared) { + _gameSys->setAnimation(0, 0, 1); + _gameSys->insertSequence(0x1C2, 99, _beaverSequenceId | (_beaverSequenceDatNum << 16), 99, kSeqSyncWait, 0, 0, 0); + _beaverSequenceId = 0x1C2; + _beaverSequenceDatNum = 0; + _gameSys->setAnimation(0x1C2, 99, 1); + _s03_nextPlatSequenceId = -1; + } else if (_s03_nextPlatSequenceId == -1 && _s03_platypusScared && !_s03_platypusHypnotized) { + _gameSys->setAnimation(0, 0, 1); + _gameSys->setAnimation(0x1BE, 99, 1); + _gameSys->insertSequence(0x1BE, 99, _beaverSequenceId | (_beaverSequenceDatNum << 16), 99, kSeqSyncWait, 0, 0, 0); + _beaverSequenceId = 0x1BE; + _beaverSequenceDatNum = 0; + _s03_nextPlatSequenceId = -1; + } + } + + if (_gameSys->getAnimationStatus(2) == 2 && _s03_nextFrogSequenceId != -1) { + _gameSys->setAnimation(_s03_nextFrogSequenceId, 253, 2); + _gameSys->insertSequence(_s03_nextFrogSequenceId, 253, _s03_currFrogSequenceId, 253, kSeqSyncWait, 0, 0, 0); + _s03_currFrogSequenceId = _s03_nextFrogSequenceId; + _s03_nextFrogSequenceId = -1; + } + + if (_gameSys->getAnimationStatus(5) == 2) { + _gameSys->setAnimation(0, 0, 5); + invAdd(kItemGrass); + setGrabCursorSprite(kItemGrass); + setFlag(6); + scene03_updateHotspots(); + } + +} + +} // End of namespace Gnap diff --git a/engines/gnap/scenes/scene04.cpp b/engines/gnap/scenes/scene04.cpp new file mode 100644 index 0000000000..bc5ee855d3 --- /dev/null +++ b/engines/gnap/scenes/scene04.cpp @@ -0,0 +1,571 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "gnap/gnap.h" +#include "gnap/gamesys.h" +#include "gnap/resource.h" + +namespace Gnap { + +enum { + kHSPlatypus = 0, + kHSTwig = 1, + kHSDog = 2, + kHSAxe = 3, + kHSDoor = 4, + kHSExitTruck = 5, + kHSDevice = 6, + kHSWindow = 7, + kHSExitBarn = 8, + kHSWalkArea1 = 9, + kHSWalkArea2 = 10 +}; + +enum { + kASOpenDoor = 1, + kASGetKeyFirst = 2, + kASGetKeyAnother = 3, + kASLeaveScene = 4, + kASGetKeyFirstDone = 6, + kASGetKeyFirst2 = 7, + kASGetKeyAnother2 = 8, + kASGetKeyAnotherDone = 9, + kASOpenDoorDone = 10, + kASGrabDog = 12, + kASGrabAxe = 13 +}; + +int GnapEngine::scene04_init() { + _gameSys->setAnimation(0, 0, 0); + _gameSys->setAnimation(0, 0, 1); + _gameSys->setAnimation(0, 0, 2); + return 0x214; +} + +void GnapEngine::scene04_updateHotspots() { + setHotspot(kHSPlatypus, 0, 0, 0, 0, SF_DISABLED | SF_WALKABLE | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSTwig, 690, 394, 769, 452, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR, 9, 6); + setHotspot(kHSDog, 550, 442, 680, 552, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR, 6, 8); + setHotspot(kHSAxe, 574, 342, 680, 412, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR, 6, 7); + setHotspot(kHSDoor, 300, 244, 386, 410, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR, 6, 7); + setHotspot(kHSExitTruck, 226, 580, 688, 600, SF_EXIT_D_CURSOR | SF_WALKABLE, 5, 9); + setHotspot(kHSWindow, 121, 295, 237, 342, SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR, 3, 7); + setHotspot(kHSExitBarn, 585, 154, 800, 276, SF_EXIT_U_CURSOR, 10, 8); + setHotspot(kHSWalkArea1, 0, 0, 562, 461); + setHotspot(kHSWalkArea2, 562, 0, 800, 500); + setDeviceHotspot(kHSDevice, -1, -1, -1, -1); + if (isFlag(0)) + _hotspots[kHSPlatypus].flags = SF_WALKABLE | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR; + if (isFlag(3)) + _hotspots[kHSTwig].flags = SF_WALKABLE | SF_DISABLED; + if (isFlag(26) || _cursorValue == 1) + _hotspots[kHSAxe].flags = SF_DISABLED; + _hotspotsCount = 11; +} + +void GnapEngine::scene04_run() { + + playSound(0x1091C, 1); + startSoundTimerC(4); + + _gameSys->insertSequence(0x210, 139 - _s04_dogIdCtr, 0, 0, kSeqNone, 0, 0, 0); + + _s04_currDogSequenceId = 0x210; + _s04_nextDogSequenceId = -1; + + _gameSys->setAnimation(0x210, 139 - _s04_dogIdCtr, 3); + _s04_dogIdCtr = (_s04_dogIdCtr + 1) % 2; + _timers[6] = getRandom(20) + 60; + _timers[5] = getRandom(150) + 300; + _timers[7] = getRandom(150) + 200; + _timers[8] = getRandom(150) + 400; + + if (!isFlag(26) && _cursorValue == 4) + _gameSys->insertSequence(0x212, 100, 0, 0, kSeqNone, 0, 0, 0); + + if (!isFlag(3)) + _gameSys->insertSequence(0x1FE, 100, 0, 0, kSeqNone, 0, 0, 0); + + queueInsertDeviceIcon(); + + if (isFlag(10)) { + _timers[3] = 300; + // TODO setCursor((LPCSTR)IDC_WAIT); + setGrabCursorSprite(kItemKeys); + _gnapX = 4; + _gnapY = 7; + _gnapId = 140; + _platX = 6; + _platY = 7; + _beaverId = 141; + _gameSys->insertSequence(0x107B5, 140, 0, 0, kSeqNone, 0, 300 - _gnapGridX, 336 - _gnapGridY); + _gameSys->insertSequence(0x20C, 141, 0, 0, kSeqNone, 0, 0, 0); + _gameSys->insertSequence(0x208, 121, 0, 0, kSeqNone, 0, 0, 0); + _gameSys->insertSequence(0x209, 121, 0x208, 121, kSeqSyncWait, 0, 0, 0); + endSceneInit(); + invRemove(kItemDisguise); + invAdd(kItemKeys); + setFlag(5); + clearFlag(10); + _beaverSequenceId = 0x20C; + _beaverSequenceDatNum = 0; + _beaverFacing = 1; + _gnapSequenceId = 0x7B5; + _gnapSequenceDatNum = 1; + _gameSys->waitForUpdate(); + } else { + _gameSys->insertSequence(0x209, 121, 0, 0, kSeqNone, 0, 0, 0); + if (_prevSceneNum == 2) { + initGnapPos(5, 11, 7); + if (isFlag(0)) + initBeaverPos(6, 11, 5); + endSceneInit(); + if (isFlag(0)) + platypusWalkTo(5, 8, -1, 0x107C2, 1); + gnapWalkTo(6, 9, -1, 0x107BA, 1); + } else if (_prevSceneNum == 38) { + initGnapPos(5, 7, 1); + initBeaverPos(4, 7, 0); + endSceneInit(); + } else { + initGnapPos(12, 9, 1); + if (isFlag(0)) + initBeaverPos(12, 8, 0); + endSceneInit(); + if (isFlag(0)) + platypusWalkTo(9, 8, -1, 0x107C2, 1); + gnapWalkTo(9, 9, -1, 0x107BA, 1); + } + } + + while (!_sceneDone) { + + updateMouseCursor(); + updateCursorByHotspot(); + + testWalk(0, 4, -1, -1, -1, -1); + + _sceneClickedHotspot = getClickedHotspotId(); + updateGrabCursorSprite(0, 0); + + switch (_sceneClickedHotspot) { + + case kHSDevice: + if (_gnapActionStatus < 0) { + runMenu(); + scene04_updateHotspots(); + } + break; + + case kHSPlatypus: + if (_gnapActionStatus < 0 && isFlag(0)) { + if (_grabCursorSpriteIndex == kItemDisguise) { + gnapUseDisguiseOnPlatypus(); + } else if (_grabCursorSpriteIndex >= 0) { + playGnapImpossible(0, 0); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + if (isFlag(5)) + playGnapMoan1(_platX, _platY); + else + playGnapScratchingHead(_platX, _platY); + break; + case GRAB_CURSOR: + if (_cursorValue == 4) + gnapKissPlatypus(0); + else + playGnapMoan1(_platX, _platY); + break; + case TALK_CURSOR: + playGnapBrainPulsating(_platX, _platY); + playBeaverSequence(getBeaverSequenceId(0, 0, 0) | 0x10000); + break; + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + } + break; + + case kHSTwig: + if (_gnapActionStatus < 0) { + if (_grabCursorSpriteIndex >= 0) { + playGnapShowItem(_grabCursorSpriteIndex, 9, 6); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapScratchingHead(_hotspotsWalkPos[1].x, _hotspotsWalkPos[1].y); + break; + case GRAB_CURSOR: + playGnapPullOutDevice(_hotspotsWalkPos[1].x, _hotspotsWalkPos[1].y); + playGnapUseDevice(_hotspotsWalkPos[1].x, _hotspotsWalkPos[1].y); + _gameSys->insertSequence(0x1FD, 100, 510, 100, kSeqSyncWait, 0, 0, 0); + _gameSys->setAnimation(0x1FD, 100, 2); + break; + case TALK_CURSOR: + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + } + break; + + case kHSAxe: + if (_gnapActionStatus < 0) { + if (_grabCursorSpriteIndex >= 0) { + playGnapShowCurrItem(_hotspotsWalkPos[3].x, _hotspotsWalkPos[3].y, 9, 5); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapMoan2(_hotspotsWalkPos[3].x, _hotspotsWalkPos[3].y); + break; + case GRAB_CURSOR: + _gnapIdleFacing = 7; + gnapWalkTo(_hotspotsWalkPos[3].x, _hotspotsWalkPos[3].y, 0, getGnapSequenceId(gskIdle, 0, 0) | 0x10000, 1); + _gnapActionStatus = kASGrabAxe; + setFlag(26); + scene04_updateHotspots(); + break; + case TALK_CURSOR: + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + } + break; + + case kHSDog: + if (_gnapActionStatus < 0) { + if (_grabCursorSpriteIndex >= 0) { + playGnapShowCurrItem(_hotspotsWalkPos[2].x, _hotspotsWalkPos[2].y, 9, 7); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + if (gnapWalkTo(_gnapX, _gnapY, 0, -1, 1)) { + playGnapMoan2(_hotspotsWalkPos[2].x, _hotspotsWalkPos[2].y); + _s04_nextDogSequenceId = 0x20F; + } + break; + case GRAB_CURSOR: + _gnapIdleFacing = 1; + if (gnapWalkTo(_hotspotsWalkPos[2].x, _hotspotsWalkPos[2].y, 0, getGnapSequenceId(gskIdle, 0, 0) | 0x10000, 1)) + _gnapActionStatus = kASGrabDog; + break; + case TALK_CURSOR: + _gnapIdleFacing = 1; + if (gnapWalkTo(_gnapX, _gnapY, 0, -1, 1)) { + playGnapBrainPulsating(_hotspotsWalkPos[2].x, _hotspotsWalkPos[2].y); + _s04_nextDogSequenceId = 0x20E; + } + break; + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + } + break; + + case kHSDoor: + if (_gnapActionStatus < 0) { + if (_grabCursorSpriteIndex >= 0) { + playGnapShowCurrItem(_hotspotsWalkPos[_sceneClickedHotspot].x, _hotspotsWalkPos[_sceneClickedHotspot].y, 4, 3); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + case PLAT_CURSOR: + playGnapScratchingHead(4, 3); + break; + case GRAB_CURSOR: + if (_cursorValue == 1) { + gnapWalkTo(_hotspotsWalkPos[4].x, _hotspotsWalkPos[4].y, 0, 0x107BC, 1); + _gnapActionStatus = kASOpenDoor; + _timers[5] = 300; + _gnapIdleFacing = 5; + } else { + _isLeavingScene = true; + gnapWalkTo(_hotspotsWalkPos[4].x, _hotspotsWalkPos[4].y, 0, 0x107BC, 1); + _gnapActionStatus = kASLeaveScene; + _newSceneNum = 38; + } + break; + case TALK_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + } + break; + + case kHSExitTruck: + if (_gnapActionStatus < 0) { + _isLeavingScene = 1; + gnapWalkTo(_hotspotsWalkPos[5].x, _hotspotsWalkPos[5].y, 0, 0x107AE, 1); + _gnapActionStatus = kASLeaveScene; + if (isFlag(0)) + platypusWalkTo(_hotspotsWalkPos[5].x, _hotspotsWalkPos[5].y, -1, 0x107C7, 1); + if (_cursorValue == 1) + _newSceneNum = 2; + else + _newSceneNum = 33; + } + break; + + case kHSWindow: + if (_gnapActionStatus < 0) { + if (_grabCursorSpriteIndex >= 0) { + playGnapShowCurrItem(_hotspotsWalkPos[_sceneClickedHotspot].x, _hotspotsWalkPos[_sceneClickedHotspot].y, 2, 3); + } else if (isFlag(5)) { + playGnapImpossible(0, 0); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + if (gnapWalkTo(_hotspotsWalkPos[7].x, _hotspotsWalkPos[7].y, 0, getGnapSequenceId(gskIdle, 10, 2) | 0x10000, 1)) { + if (_s04_triedWindow) { + _gnapActionStatus = kASGetKeyAnother; + } else { + _gnapActionStatus = kASGetKeyFirst; + _s04_triedWindow = true; + } + } + break; + case GRAB_CURSOR: + playGnapScratchingHead(_hotspotsWalkPos[7].x, _hotspotsWalkPos[7].y); + break; + case TALK_CURSOR: + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + } + break; + + case kHSExitBarn: + if (_gnapActionStatus < 0) { + _isLeavingScene = 1; + gnapWalkTo(_hotspotsWalkPos[8].x, _hotspotsWalkPos[8].y, 0, 0x107AB, 1); + _gnapActionStatus = kASLeaveScene; + if (isFlag(0)) + platypusWalkTo(_hotspotsWalkPos[8].x, _hotspotsWalkPos[8].y + 1, -1, 0x107C1, 1); + if (_cursorValue == 1) + _newSceneNum = 5; + else + _newSceneNum = 35; + } + break; + + case kHSWalkArea1: + case kHSWalkArea2: + if (_gnapActionStatus < 0) + gnapWalkTo(-1, -1, -1, -1, 1); + break; + + default: + if (_mouseClickState.left && _gnapActionStatus < 0) { + gnapWalkTo(-1, -1, -1, -1, 1); + _mouseClickState.left = false; + } + break; + + } + + scene04_updateAnimations(); + + if (!isSoundPlaying(0x1091C)) + playSound(0x1091C, 1); + + if (!_isLeavingScene) { + if (_beaverActionStatus < 0 && isFlag(0)) + beaverSub426234(); + if (_gnapActionStatus < 0) + updateGnapIdleSequence2(); + if (!_timers[5]) { + _timers[5] = getRandom(150) + 300; + if (_gnapActionStatus < 0) + _gameSys->insertSequence(0x20D, 79, 0, 0, kSeqNone, 0, 0, 0); + } + if (!_timers[7]) { + _timers[7] = getRandom(150) + 200; + _gameSys->insertSequence(0x1FC, 59, 0, 0, kSeqNone, 0, 0, 0); + } + if (!_timers[6]) { + _timers[6] = getRandom(20) + 60; + if (_s04_nextDogSequenceId == -1) + _s04_nextDogSequenceId = 0x210; + } + if (!_timers[8]) { + _timers[8] = getRandom(150) + 400; + _gameSys->insertSequence(0x213, 20, 0, 0, kSeqNone, 0, 0, 0); + } + playSoundC(); + } + + checkGameKeys(); + + if (isKeyStatus1(8)) { + clearKeyStatus1(8); + runMenu(); + scene04_updateHotspots(); + } + + gameUpdateTick(); + + } + +} + +void GnapEngine::scene04_updateAnimations() { + + if (_gameSys->getAnimationStatus(0) == 2) { + _gameSys->setAnimation(0, 0, 0); + switch (_gnapActionStatus) { + case kASLeaveScene: + _sceneDone = true; + break; + case kASOpenDoor: + _gameSys->insertSequence(0x205, _gnapId, 0, 0, kSeqNone, 0, 0, 0); + _gameSys->insertSequence(0x207, 121, 521, 121, kSeqSyncWait, 0, 0, 0); + _gnapX = 6; + _gnapY = 7; + _gameSys->insertSequence(0x107B5, _gnapId, + makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, + kSeqSyncWait, getSequenceTotalDuration(0x205) - 1, 450 - _gnapGridX, 336 - _gnapGridY); + _gameSys->setAnimation(0x107B5, _gnapId, 0); + _gnapSequenceId = 0x7B5; + _gnapSequenceDatNum = 1; + _gnapActionStatus = kASOpenDoorDone; + break; + case kASOpenDoorDone: + _gameSys->insertSequence(0x209, 121, 0x207, 121, kSeqSyncWait, 0, 0, 0); + _gnapActionStatus = -1; + break; + case kASGetKeyFirst: + _gameSys->insertSequence(0x204, _gnapId, makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, kSeqSyncWait, 0, 0, 0); + _gameSys->setAnimation(0x204, _gnapId, 0); + _gnapSequenceId = 0x204; + _gnapSequenceDatNum = 0; + _gnapActionStatus = kASGetKeyFirst2; + break; + case kASGetKeyFirst2: + _gameSys->insertSequence(0x206, 255, makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, kSeqSyncWait, 0, 0, 0); + _gameSys->insertSequence(0x1FF, 256, 0, 0, kSeqNone, 0, 0, 0); + _gameSys->insertSequence(0x20B, 256, 0, 0, kSeqNone, 0, 0, 0); + _gameSys->setAnimation(0x20B, 256, 0); + _gnapSequenceId = 0x206; + _gnapSequenceDatNum = 0; + _gnapActionStatus = kASGetKeyFirstDone; + break; + case kASGetKeyFirstDone: + _gameSys->requestRemoveSequence(0x1FF, 256); + _gameSys->requestRemoveSequence(0x20B, 256); + _gameSys->insertSequence(0x107B5, _gnapId, + makeRid(_gnapSequenceDatNum, _gnapSequenceId), 255, + kSeqSyncWait, 0, 75 * _gnapX - _gnapGridX, 48 * _gnapY - _gnapGridY); + _gnapIdleFacing = 1; + _gnapSequenceId = 0x7B5; + _gnapSequenceDatNum = 1; + _gnapActionStatus = -1; + break; + case kASGetKeyAnother: + _gameSys->insertSequence(0x202, _gnapId, makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, kSeqSyncWait, 0, 0, 0); + _gameSys->setAnimation(0x202, _gnapId, 0); + _gnapSequenceId = 0x202; + _gnapSequenceDatNum = 0; + _gnapActionStatus = kASGetKeyAnother2; + break; + case kASGetKeyAnother2: + _gameSys->insertSequence(0x203, 255, makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, kSeqSyncWait, 0, 0, 0); + _gameSys->insertSequence(0x1FF, 256, 0, 0, kSeqNone, 0, 0, 0); + _gameSys->insertSequence(0x20A, 256, 0, 0, kSeqNone, 0, 0, 0); + _gameSys->setAnimation(0x20A, 256, 0); + _gnapSequenceId = 0x203; + _gnapSequenceDatNum = 0; + _gnapActionStatus = kASGetKeyAnotherDone; + break; + case kASGetKeyAnotherDone: + _gameSys->removeSequence(0x1FF, 256, 1); + _gameSys->removeSequence(0x20A, 256, 1); + _gameSys->insertSequence(0x107B5, _gnapId, + makeRid(_gnapSequenceDatNum, _gnapSequenceId), 255, + kSeqSyncWait, 0, 75 * _gnapX - _gnapGridX, 48 * _gnapY - _gnapGridY); + _gnapSequenceId = 0x7B5; + _gnapSequenceDatNum = 1; + _gnapIdleFacing = 1; + _gnapActionStatus = -1; + break; + case kASGrabDog: + _s04_nextDogSequenceId = 0x201; + break; + case kASGrabAxe: + _gameSys->insertSequence(0x211, _gnapId, makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, kSeqSyncWait, 0, 0, 0); + _gameSys->requestRemoveSequence(0x212, 100); + _gnapSequenceDatNum = 0; + _gnapSequenceId = 0x211; + _gnapActionStatus = -1; + break; + default: + _gnapActionStatus = -1; + break; + } + } + + if (_gameSys->getAnimationStatus(2) == 2) { + _gameSys->setAnimation(0, 0, 2); + invAdd(kItemTwig); + setGrabCursorSprite(kItemTwig); + setFlag(3); + scene04_updateHotspots(); + } + + if (_gameSys->getAnimationStatus(3) == 2) { + if (_s04_nextDogSequenceId == 0x201) { + _gameSys->insertSequence(_s04_nextDogSequenceId, 139 - _s04_dogIdCtr, + _s04_currDogSequenceId, 139 - (_s04_dogIdCtr + 1) % 2, + kSeqSyncWait, 0, 0, 0); + _gameSys->insertSequence(0x200, _gnapId, makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, kSeqSyncWait, 0, 0, 0); + _gameSys->setAnimation(_s04_nextDogSequenceId, 139 - _s04_dogIdCtr, 3); + _s04_dogIdCtr = (_s04_dogIdCtr + 1) % 2; + _s04_currDogSequenceId = 0x201; + _gnapSequenceId = 0x200; + _gnapSequenceDatNum = 0; + _gnapActionStatus = -1; + _timers[6] = getRandom(20) + 60; + _s04_nextDogSequenceId = -1; + } else if (_s04_nextDogSequenceId != -1) { + _gameSys->insertSequence(_s04_nextDogSequenceId, 139 - _s04_dogIdCtr, + _s04_currDogSequenceId, 139 - (_s04_dogIdCtr + 1) % 2, + kSeqSyncWait, 0, 0, 0); + _gameSys->setAnimation(_s04_nextDogSequenceId, 139 - _s04_dogIdCtr, 3); + _s04_dogIdCtr = (_s04_dogIdCtr + 1) % 2; + _s04_currDogSequenceId = _s04_nextDogSequenceId; + _s04_nextDogSequenceId = -1; + } + } + +} + +} // End of namespace Gnap diff --git a/engines/gnap/scenes/scene05.cpp b/engines/gnap/scenes/scene05.cpp new file mode 100644 index 0000000000..fdc6ba16fe --- /dev/null +++ b/engines/gnap/scenes/scene05.cpp @@ -0,0 +1,467 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "gnap/gnap.h" +#include "gnap/gamesys.h" +#include "gnap/resource.h" + +namespace Gnap { + +enum { + kHSPlatypus = 0, + kHSHaystack = 1, + kHSPadlock = 2, + kHSLadder = 3, + kHSExitHouse = 4, + kHSChicken = 5, + kHSDevice = 6, + kHSWalkArea1 = 7, + kHSWalkArea2 = 8, + kHSWalkArea3 = 9 +}; + +enum { + kASPlatSearchHaystack = 0, + kASTryPickPadlock = 1, + kASPickPadlock = 2, + kASTalkChicken = 3, + kASGrabChicken = 4, + kASGrabLadder = 5, + kASEnterBarn = 6, + kASUseTwigWithChicken = 11, + kASLeaveScene = 12 +}; + +int GnapEngine::scene05_init() { + _gameSys->setAnimation(0, 0, 0); + _gameSys->setAnimation(0, 0, 1); + _gameSys->setAnimation(0, 0, 3); + return isFlag(7) ? 0x151 : 0x150; +} + +void GnapEngine::scene05_updateHotspots() { + setHotspot(kHSPlatypus, 0, 0, 0, 0, SF_DISABLED | SF_WALKABLE | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSHaystack, 236, 366, 372, 442, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR, 5, 7); + setHotspot(kHSPadlock, 386, 230, 626, 481, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR, 5, 7); + setHotspot(kHSLadder, 108, 222, 207, 444, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR, 4, 7); + setHotspot(kHSExitHouse, 0, 395, 20, 600, SF_EXIT_L_CURSOR | SF_WALKABLE, 0, 8); + setHotspot(kHSChicken, 612, 462, 722, 564, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR, 7, 8); + setHotspot(kHSWalkArea1, 104, 0, 421, 480); + setHotspot(kHSWalkArea2, 422, 0, 800, 487); + setHotspot(kHSWalkArea3, 0, 0, 104, 499); + setDeviceHotspot(kHSDevice, -1, -1, -1, -1); + if (isFlag(0)) + _hotspots[kHSPlatypus].flags = SF_WALKABLE | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR; + if (isFlag(7)) + _hotspots[kHSPadlock].flags = SF_EXIT_U_CURSOR; + _hotspotsCount = 10; +} + +void GnapEngine::scene05_run() { + + playSound(0x1091C, 1); + startSoundTimerC(7); + + _s05_currChickenSequenceId = 0x142; + _gameSys->setAnimation(0x142, 100, 3); + _gameSys->insertSequence(0x142, 100, 0, 0, kSeqNone, 0, 0, 0); + + _s05_nextChickenSequenceId = -1; + + _timers[5] = getRandom(10) + 30; + _timers[6] = getRandom(150) + 300; + + if (isFlag(7)) + _gameSys->insertSequence(0x14A, 141, 0, 0, kSeqNone, 0, 0, 0); + + queueInsertDeviceIcon(); + + if (_prevSceneNum != 6 && _prevSceneNum != 36) { + initGnapPos(-1, 8, 1); + if (isFlag(0)) + initBeaverPos(-1, 9, 0); + endSceneInit(); + if (isFlag(0)) + platypusWalkTo(2, 8, -1, 0x107C2, 1); + gnapWalkTo(2, 9, -1, 0x107B9, 1); + } else { + initGnapPos(6, 8, 1); + if (isFlag(0)) + initBeaverPos(7, 9, 0); + endSceneInit(); + } + + while (!_sceneDone) { + + updateMouseCursor(); + updateCursorByHotspot(); + + testWalk(0, 12, -1, -1, -1, -1); + + _sceneClickedHotspot = getClickedHotspotId(); + updateGrabCursorSprite(0, 0); + + switch (_sceneClickedHotspot) { + + case kHSDevice: + if (_gnapActionStatus < 0) { + runMenu(); + scene05_updateHotspots(); + } + break; + + case kHSPlatypus: + if (_gnapActionStatus < 0 && isFlag(0)) { + if (_grabCursorSpriteIndex == kItemDisguise) { + gnapUseDisguiseOnPlatypus(); + } else if (_grabCursorSpriteIndex >= 0) { + playGnapImpossible(0, 0); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + if (isFlag(5)) + playGnapMoan1(_platX, _platY); + else + playGnapScratchingHead(_platX, _platY); + break; + case GRAB_CURSOR: + gnapKissPlatypus(0); + break; + case TALK_CURSOR: + playGnapBrainPulsating(_platX, _platY); + playBeaverSequence(getBeaverSequenceId(0, 0, 0) | 0x10000); + break; + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + } + break; + + case kHSHaystack: + if (_gnapActionStatus < 0 && _beaverActionStatus < 0) { + if (_grabCursorSpriteIndex >= 0) { + playGnapShowCurrItem(_hotspotsWalkPos[1].x - 2, _hotspotsWalkPos[1].y, 4, 5); + } else if (isFlag(2)) { + playGnapImpossible(0, 0); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapScratchingHead(_hotspotsWalkPos[1].x, _hotspotsWalkPos[1].y - 1); + break; + case GRAB_CURSOR: + case TALK_CURSOR: + playGnapImpossible(0, 0); + break; + case PLAT_CURSOR: + if (isFlag(0)) { + gnapUseDeviceOnBeaver(); + if (platypusWalkTo(_hotspotsWalkPos[1].x, _hotspotsWalkPos[1].y, 1, 0x107C2, 1)) { + _beaverActionStatus = kASPlatSearchHaystack; + _beaverFacing = 4; + } + if (_gnapX == 4 && (_gnapY == 8 || _gnapY == 7)) + gnapWalkStep(); + playGnapIdle(_platX, _platY); + } + break; + } + } + } + break; + + case kHSChicken: + if (_gnapActionStatus < 0) { + if (_grabCursorSpriteIndex == kItemTwig) { + _gnapIdleFacing = 7; + gnapWalkTo(_hotspotsWalkPos[_sceneClickedHotspot].x, _hotspotsWalkPos[_sceneClickedHotspot].y + 1, + 0, getGnapSequenceId(gskIdle, 0, 0) | 0x10000, 1); + _gnapActionStatus = kASUseTwigWithChicken; + } else if (_grabCursorSpriteIndex >= 0) { + playGnapShowCurrItem(_hotspotsWalkPos[_sceneClickedHotspot].x, _hotspotsWalkPos[_sceneClickedHotspot].y + 1, 9, 7); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapMoan2(9, 7); + break; + case GRAB_CURSOR: + _gnapIdleFacing = 1; + gnapWalkTo(_hotspotsWalkPos[5].x, _hotspotsWalkPos[5].y, 0, getGnapSequenceId(gskIdle, 0, 0) | 0x10000, 1); + _gnapActionStatus = kASGrabChicken; + break; + case TALK_CURSOR: + _gnapIdleFacing = 1; + gnapWalkTo(_hotspotsWalkPos[5].x, _hotspotsWalkPos[5].y, 0, getGnapSequenceId(gskBrainPulsating, 0, 0) | 0x10000, 1); + _gnapActionStatus = kASTalkChicken; + break; + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + } + break; + + case kHSLadder: + if (_gnapActionStatus < 0) { + if (_grabCursorSpriteIndex >= 0) { + playGnapShowCurrItem(_hotspotsWalkPos[_sceneClickedHotspot].x, _hotspotsWalkPos[_sceneClickedHotspot].y, 2, 5); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapMoan2(2, 4); + break; + case GRAB_CURSOR: + _gnapIdleFacing = 3; + gnapWalkTo(_hotspotsWalkPos[3].x, _hotspotsWalkPos[3].y, 0, getGnapSequenceId(gskIdle, 0, 0) | 0x10000, 1); + _gnapActionStatus = kASGrabLadder; + break; + case TALK_CURSOR: + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + } + break; + + case kHSPadlock: + if (isFlag(7)) { + _isLeavingScene = true; + gnapWalkTo(_hotspotsWalkPos[2].x - 1, _hotspotsWalkPos[2].y + 1, 0, -1, 1); + _gnapActionStatus = kASEnterBarn; + if (_cursorValue == 1) + _newSceneNum = 6; + else + _newSceneNum = 36; + } else if (_gnapActionStatus < 0) { + if (_grabCursorSpriteIndex == kItemNeedle) { + if (gnapWalkTo(_hotspotsWalkPos[2].x, _hotspotsWalkPos[2].y, 0, + getGnapSequenceId(gskIdle, _hotspotsWalkPos[2].x, _hotspotsWalkPos[2].y) | 0x10000, 1)) + _gnapActionStatus = kASPickPadlock; + } else if (_grabCursorSpriteIndex >= 0) { + playGnapShowCurrItem(_hotspotsWalkPos[2].x, _hotspotsWalkPos[2].y, 7, 4); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapScratchingHead(7, 4); + break; + case GRAB_CURSOR: + _gnapIdleFacing = 7; + gnapWalkTo(_hotspotsWalkPos[_sceneClickedHotspot].x, _hotspotsWalkPos[_sceneClickedHotspot].y, + 0, getGnapSequenceId(gskIdle, 0, 0) | 0x10000, 1); + _gnapActionStatus = kASTryPickPadlock; + break; + case TALK_CURSOR: + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + } + break; + + case kHSExitHouse: + if (_gnapActionStatus < 0) { + _isLeavingScene = true; + gnapWalkTo(_hotspotsWalkPos[4].x, _hotspotsWalkPos[4].y, 0, 0x107AF, 1); + _gnapActionStatus = kASLeaveScene; + if (isFlag(0)) + platypusWalkTo(_hotspotsWalkPos[4].x, _hotspotsWalkPos[4].y + 1, -1, 0x107C7, 1); + if (_cursorValue == 1) + _newSceneNum = 4; + else + _newSceneNum = 37; + } + break; + + case kHSWalkArea1: + case kHSWalkArea2: + if (_gnapActionStatus < 0) + gnapWalkTo(-1, -1, -1, -1, 1); + break; + + case kHSWalkArea3: + // Nothing + break; + + default: + if (_mouseClickState.left && _gnapActionStatus < 0) { + gnapWalkTo(-1, -1, -1, -1, 1); + _mouseClickState.left = false; + } + break; + + } + + scene05_updateAnimations(); + + if (!isSoundPlaying(0x1091C)) + playSound(0x1091C, 1); + + if (!_isLeavingScene) { + if (isFlag(0)) + updateBeaverIdleSequence(); + updateGnapIdleSequence(); + if (!_timers[5]) { + _timers[5] = getRandom(20) + 30; + if (_gnapActionStatus != kASTalkChicken && _s05_nextChickenSequenceId == -1) { + if (getRandom(4) != 0) + _s05_nextChickenSequenceId = 0x142; + else + _s05_nextChickenSequenceId = 0x143; + } + } + if (!_timers[6]) { + _timers[6] = getRandom(150) + 300; + if (_gnapActionStatus < 0) + _gameSys->insertSequence(0x149, 39, 0, 0, kSeqNone, 0, 0, 0); + } + playSoundC(); + } + + checkGameKeys(); + + if (isKeyStatus1(8)) { + clearKeyStatus1(8); + runMenu(); + scene05_updateHotspots(); + _timers[5] = getRandom(20) + 30; + } + + gameUpdateTick(); + + } + +} + +void GnapEngine::scene05_updateAnimations() { + + if (_gameSys->getAnimationStatus(0) == 2) { + _gameSys->setAnimation(0, 0, 0); + switch (_gnapActionStatus) { + case kASLeaveScene: + _sceneDone = true; + _gnapActionStatus = -1; + break; + case kASTryPickPadlock: + _gameSys->insertSequence(0x148, _gnapId, makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, kSeqSyncWait, 0, 0, 0); + _gnapSequenceId = 0x148; + _gnapSequenceDatNum = 0; + _gnapActionStatus = -1; + break; + case kASPickPadlock: + _gameSys->setAnimation(0x147, _gnapId, 0); + _gameSys->insertSequence(0x147, _gnapId, makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, kSeqSyncWait, 0, 0, 0); + _gnapSequenceId = 0x147; + _gnapSequenceDatNum = 0; + setFlag(7); + setFlag(11); + setGrabCursorSprite(-1); + _newSceneNum = 6; + _timers[2] = 100; + invRemove(kItemNeedle); + _gnapActionStatus = kASLeaveScene; + break; + case kASTalkChicken: + _s05_nextChickenSequenceId = 0x144; + _gnapActionStatus = -1; + break; + case kASGrabChicken: + _s05_nextChickenSequenceId = 0x14B; + break; + case kASGrabLadder: + while (_gameSys->isSequenceActive(0x149, 39)) + gameUpdateTick(); + _gameSys->insertSequence(0x14E, _gnapId + 1, 0, 0, kSeqNone, 0, 0, 0); + _gameSys->insertSequence(0x14D, _gnapId, makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, kSeqSyncWait, 0, 0, 0); + _gnapSequenceId = 0x14D; + _gnapSequenceDatNum = 0; + _timers[2] = 200; + _timers[6] = 300; + _gnapActionStatus = -1; + break; + case kASEnterBarn: + _gameSys->insertSequence(0x107B1, 1, + makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, + kSeqSyncWait, 0, 75 * _gnapX - _gnapGridX, 48 * _gnapY - _gnapGridY); + _gameSys->setAnimation(0x107B1, 1, 0); + _gnapActionStatus = kASLeaveScene; + break; + case kASUseTwigWithChicken: + playGnapShowItem(5, 0, 0); + _s05_nextChickenSequenceId = 0x14F; + _gnapActionStatus = -1; + break; + } + } + + if (_gameSys->getAnimationStatus(1) == 2) { + if (_beaverSequenceId == 0x146) { + _platX = 4; + _platY = 8; + _gameSys->insertSequence(0x107C1, 160, 0x146, 256, kSeqSyncWait, 0, 300 - _platGridX, 384 - _platGridY); + _beaverSequenceId = 0x7C1; + _beaverSequenceDatNum = 1; + _beaverId = 20 * _platY; + invAdd(kItemNeedle); + setFlag(2); + setGrabCursorSprite(kItemNeedle); + showCursor(); + _timers[1] = 30; + _beaverActionStatus = -1; + } + if (_beaverActionStatus == kASPlatSearchHaystack) { + _gameSys->setAnimation(0, 0, 1); + _gameSys->insertSequence(0x145, _beaverId, _beaverSequenceId | (_beaverSequenceDatNum << 16), _beaverId, kSeqSyncWait, 0, 0, 0); + _gameSys->insertSequence(0x146, 256, 0x145, _beaverId, kSeqSyncWait, 0, 0, 0); + hideCursor(); + setGrabCursorSprite(-1); + _beaverSequenceId = 0x146; + _beaverSequenceDatNum = 0; + _gameSys->setAnimation(0x146, 256, 1); + _timers[1] = 300; + } + } + + if (_gameSys->getAnimationStatus(3) == 2) { + if (_s05_nextChickenSequenceId == 0x14B) { + _gameSys->setAnimation(_s05_nextChickenSequenceId, 100, 3); + _gameSys->insertSequence(_s05_nextChickenSequenceId, 100, _s05_currChickenSequenceId, 100, kSeqSyncWait, 0, 0, 0); + _gameSys->insertSequence(0x14C, _gnapId, makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, kSeqSyncWait, 0, 0, 0); + _gnapSequenceDatNum = 0; + _gnapSequenceId = 0x14C; + _s05_currChickenSequenceId = _s05_nextChickenSequenceId; + _s05_nextChickenSequenceId = -1; + _gnapActionStatus = -1; + } else if (_s05_nextChickenSequenceId != -1) { + _gameSys->setAnimation(_s05_nextChickenSequenceId, 100, 3); + _gameSys->insertSequence(_s05_nextChickenSequenceId, 100, _s05_currChickenSequenceId, 100, kSeqSyncWait, 0, 0, 0); + _s05_currChickenSequenceId = _s05_nextChickenSequenceId; + _s05_nextChickenSequenceId = -1; + } + } + +} + +} // End of namespace Gnap diff --git a/engines/gnap/scenes/scene06.cpp b/engines/gnap/scenes/scene06.cpp new file mode 100644 index 0000000000..3878d3514e --- /dev/null +++ b/engines/gnap/scenes/scene06.cpp @@ -0,0 +1,446 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "gnap/gnap.h" +#include "gnap/gamesys.h" +#include "gnap/resource.h" + +namespace Gnap { + +enum { + kHSPlatypus = 0, + kHSGas = 1, + kHSLadder = 2, + kHSHorse = 3, + kHSExitOutsideBarn = 4, + kHSDevice = 5, + kHSWalkArea1 = 6, + kHSWalkArea2 = 7, + kHSWalkArea3 = 8, + kHSWalkArea4 = 9, + kHSWalkArea5 = 10 +}; + +enum { + kASTryToGetGas = 0, + kASTryToClimbLadder = 1, + kASTryToClimbLadderDone = 2, + kASTalkToHorse = 3, + kASUseTwigOnHorse = 4, + kASLeaveScene = 5 +}; + +int GnapEngine::scene06_init() { + _gameSys->setAnimation(0, 0, 0); + _gameSys->setAnimation(0, 0, 1); + _gameSys->setAnimation(0, 0, 2); + if (isFlag(11)) { + playSound(0x11B, 0); + clearFlag(11); + } + return 0x101; +} + +void GnapEngine::scene06_updateHotspots() { + setHotspot(kHSPlatypus, 0, 0, 0, 0, SF_WALKABLE | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSGas, 300, 120, 440, 232, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR, 4, 7); + setHotspot(kHSLadder, 497, 222, 614, 492, SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR, 6, 8); + setHotspot(kHSHorse, 90, 226, 259, 376, SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR, 4, 7); + setHotspot(kHSExitOutsideBarn, 226, 580, 688, 600, SF_EXIT_D_CURSOR | SF_WALKABLE, 5, 10); + setHotspot(kHSWalkArea1, 0, 0, 200, 515); + setHotspot(kHSWalkArea2, 200, 0, 285, 499); + setHotspot(kHSWalkArea3, 688, 0, 800, 499); + setHotspot(kHSWalkArea4, 475, 469, 800, 505); + setHotspot(kHSWalkArea5, 0, 0, 800, 504); + setDeviceHotspot(kHSDevice, -1, -1, -1, -1); + if (isFlag(29)) + _hotspots[kHSLadder].flags = SF_DISABLED; + if (_cursorValue == 4) { + _hotspots[kHSLadder].flags = SF_DISABLED; + _hotspots[kHSGas].flags = SF_DISABLED; + } + _hotspotsCount = 11; +} + +void GnapEngine::scene06_run() { + bool triedDeviceOnGas = false; + + startSoundTimerC(7); + + _s06_horseTurnedBack = false; + _gameSys->insertSequence(0xF1, 120, 0, 0, kSeqNone, 0, 0, 0); + + _s06_currHorseSequenceId = 0xF1; + _s06_nextHorseSequenceId = -1; + + _gameSys->setAnimation(0xF1, 120, 2); + + _timers[4] = getRandom(40) + 25; + + if (isFlag(4)) + _gameSys->insertSequence(0xF7, 20, 0, 0, kSeqNone, 0, 0, 0); + else + _gameSys->insertSequence(0xF8, 20, 0, 0, kSeqNone, 0, 0, 0); + + if (!isFlag(29) && _cursorValue != 4) + _gameSys->insertSequence(0xFE, 20, 0, 0, kSeqNone, 0, 0, 0); + + queueInsertDeviceIcon(); + + initGnapPos(5, 12, 1); + initBeaverPos(6, 12, 0); + endSceneInit(); + + platypusWalkTo(6, 8, -1, 0x107C2, 1); + gnapWalkTo(5, 8, -1, 0x107B9, 1); + + while (!_sceneDone) { + + updateMouseCursor(); + updateCursorByHotspot(); + + testWalk(0, 5, -1, -1, -1, -1); + + _sceneClickedHotspot = getClickedHotspotId(); + updateGrabCursorSprite(0, 0); + + switch (_sceneClickedHotspot) { + + case kHSDevice: + if (_gnapActionStatus < 0) { + runMenu(); + scene06_updateHotspots(); + } + break; + + case kHSPlatypus: + if (_gnapActionStatus < 0) { + if (_grabCursorSpriteIndex == kItemDisguise) { + gnapUseDisguiseOnPlatypus(); + } else if (_grabCursorSpriteIndex >= 0) { + playGnapImpossible(0, 0); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + if (isFlag(5)) + playGnapMoan1(_platX, _platY); + else + playGnapScratchingHead(_platX, _platY); + break; + case GRAB_CURSOR: + gnapKissPlatypus(0); + break; + case TALK_CURSOR: + playGnapBrainPulsating(_platX, _platY); + playBeaverSequence(getBeaverSequenceId(0, 0, 0) | 0x10000); + break; + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + } + break; + + case kHSGas: + if (_gnapActionStatus < 0) { + if (_grabCursorSpriteIndex >= 0) { + playGnapShowCurrItem(_hotspotsWalkPos[_sceneClickedHotspot].x, _hotspotsWalkPos[_sceneClickedHotspot].y, 5, 0); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapScratchingHead(5, 0); + break; + case GRAB_CURSOR: + if (isFlag(4)) { + playGnapImpossible(0, 0); + } else if (triedDeviceOnGas) { + _hotspots[kHSWalkArea5].flags |= SF_WALKABLE; + gnapWalkTo(_hotspotsWalkPos[1].x, _hotspotsWalkPos[1].y, 0, 0x107BC, 1); + _hotspots[kHSWalkArea5].flags &= ~SF_WALKABLE; + _gnapActionStatus = kASTryToGetGas; + } else { + triedDeviceOnGas = true; + playGnapPullOutDeviceNonWorking(_hotspotsWalkPos[1].x, _hotspotsWalkPos[1].y); + } + break; + case TALK_CURSOR: + case PLAT_CURSOR: + if (isFlag(4)) + playGnapImpossible(0, 0); + else + playGnapScratchingHead(5, 0); + break; + } + } + } + break; + + case kHSLadder: + if (_gnapActionStatus < 0) { + if (_grabCursorSpriteIndex >= 0) { + playGnapShowCurrItem(_hotspotsWalkPos[_sceneClickedHotspot].x, _hotspotsWalkPos[_sceneClickedHotspot].y, 8, 4); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapScratchingHead(8, 4); + break; + case GRAB_CURSOR: + if (isFlag(29)) + playGnapImpossible(0, 0); + else { + gnapWalkTo(_hotspotsWalkPos[2].x, _hotspotsWalkPos[2].y, 0, 0x107BB, 1); + _gnapActionStatus = kASTryToClimbLadder; + setFlag(29); + } + break; + case TALK_CURSOR: + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + } + break; + + case kHSHorse: + if (_gnapActionStatus < 0) { + if (_grabCursorSpriteIndex == kItemTwig && _s06_horseTurnedBack) { + _hotspots[kHSWalkArea5].flags |= SF_WALKABLE; + gnapWalkTo(_hotspotsWalkPos[3].x, _hotspotsWalkPos[3].y, 0, 0x107BC, 1); + _hotspots[kHSWalkArea5].flags &= ~SF_WALKABLE; + _gnapIdleFacing = 5; + platypusWalkTo(6, 8, 1, 0x107C2, 1); + _beaverFacing = 0; + _gnapActionStatus = kASUseTwigOnHorse; + setGrabCursorSprite(-1); + } else if (_grabCursorSpriteIndex >= 0) { + playGnapShowCurrItem(_hotspotsWalkPos[_sceneClickedHotspot].x, _hotspotsWalkPos[_sceneClickedHotspot].y, 3, 2); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapScratchingHead(3, 2); + break; + case TALK_CURSOR: + if (_s06_horseTurnedBack) { + gnapWalkTo(_hotspotsWalkPos[3].x, _hotspotsWalkPos[3].y, 0, getGnapSequenceId(gskBrainPulsating, 3, 2) | 0x10000, 1); + } else { + _gnapIdleFacing = 3; + _hotspots[kHSWalkArea5].flags |= SF_WALKABLE; + gnapWalkTo(_hotspotsWalkPos[3].x, _hotspotsWalkPos[3].y, 0, getGnapSequenceId(gskBrainPulsating, 0, 0) | 0x10000, 1); + _hotspots[kHSWalkArea5].flags &= ~SF_WALKABLE; + _gnapActionStatus = kASTalkToHorse; + } + break; + case GRAB_CURSOR: + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + } + break; + + case kHSExitOutsideBarn: + if (_gnapActionStatus < 0) { + _isLeavingScene = 1; + gnapWalkTo(_hotspotsWalkPos[4].x, _hotspotsWalkPos[4].y, 0, 0x107AE, 1); + _gnapActionStatus = kASLeaveScene; + if (_cursorValue == 1) + _newSceneNum = 5; + else + _newSceneNum = 35; + } + break; + + case kHSWalkArea1: + case kHSWalkArea2: + case kHSWalkArea3: + case kHSWalkArea4: + case kHSWalkArea5: + if (_gnapActionStatus < 0) + gnapWalkTo(-1, -1, -1, -1, 1); + break; + + default: + if (_mouseClickState.left && _gnapActionStatus < 0) { + gnapWalkTo(-1, -1, -1, -1, 1); + _mouseClickState.left = false; + } + break; + + } + + + scene06_updateAnimations(); + + if (!_isLeavingScene) { + if (_beaverActionStatus < 0) + updateBeaverIdleSequence(); + if (_gnapActionStatus < 0) + updateGnapIdleSequence(); + if (!_timers[4]) { + _timers[4] = getRandom(40) + 25; + if (_gnapActionStatus < 0 && _beaverActionStatus < 0 && _s06_nextHorseSequenceId == -1) { + if (_s06_horseTurnedBack) { + _s06_nextHorseSequenceId = 0xF5; + } else { + switch (getRandom(5)) { + case 0: + case 1: + case 2: + _s06_nextHorseSequenceId = 0xF1; + break; + case 3: + _s06_nextHorseSequenceId = 0xF3; + break; + case 4: + _s06_nextHorseSequenceId = 0xF4; + break; + } + } + } + } + playSoundC(); + } + + checkGameKeys(); + + if (isKeyStatus1(8)) { + clearKeyStatus1(8); + runMenu(); + scene06_updateHotspots(); + } + + gameUpdateTick(); + + } + +} + +void GnapEngine::scene06_updateAnimations() { + + if (_gameSys->getAnimationStatus(0) == 2) { + _gameSys->setAnimation(0, 0, 0); + switch (_gnapActionStatus) { + case kASLeaveScene: + _sceneDone = true; + _gnapActionStatus = -1; + break; + case kASTryToGetGas: + _gameSys->insertSequence(0xFC, _gnapId, makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, kSeqSyncWait, 0, 0, 0); + _gnapSequenceId = 0xFC; + _gnapSequenceDatNum = 0; + _gnapActionStatus = -1; + break; + case kASTryToClimbLadder: + _gameSys->insertSequence(0xFF, 20, 0xFE, 20, kSeqSyncWait, 0, 0, 0); + _gameSys->setAnimation(0xFD, _gnapId, 0); + _gameSys->insertSequence(0xFD, _gnapId, makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, kSeqSyncWait, 0, 0, 0); + _gnapSequenceId = 0xFD; + _gnapSequenceDatNum = 0; + _gnapActionStatus = kASTryToClimbLadderDone; + break; + case kASTryToClimbLadderDone: + _gnapX = 6; + _gnapY = 7; + _gnapActionStatus = -1; + break; + case kASTalkToHorse: + _s06_nextHorseSequenceId = 0xF6; + break; + case kASUseTwigOnHorse: + _s06_nextPlatSequenceId = 0xFB; + break; + default: + _gnapActionStatus = -1; + break; + } + } + + if (_gameSys->getAnimationStatus(1) == 2) { + _gameSys->setAnimation(0, 0, 1); + if (_beaverSequenceId == 0xFA) { + _gameSys->setAnimation(0, 0, 1); + invAdd(kItemGas); + setFlag(29); + _hotspots[kHSLadder].flags = SF_DISABLED; + setGrabCursorSprite(kItemGas); + _beaverActionStatus = -1; + _platX = 6; + _platY = 8; + _gameSys->insertSequence(0x107C1, _beaverId, 0, 0, kSeqNone, 0, 450 - _platGridX, 384 - _platGridY); + _beaverSequenceId = 0x7C1; + _beaverSequenceDatNum = 1; + setFlag(4); + _gnapActionStatus = -1; + showCursor(); + } + if (_s06_nextPlatSequenceId == 0xFB) { + _gameSys->setAnimation(0, 0, 1); + _s06_nextHorseSequenceId = 0xF2; + _beaverActionStatus = 6; + } + } + + if (_gameSys->getAnimationStatus(2) == 2 && _s06_nextHorseSequenceId != -1) { + switch (_s06_nextHorseSequenceId) { + case 0xF2: + setGrabCursorSprite(-1); + hideCursor(); + _gameSys->setAnimation(0xFA, 256, 1); + _gameSys->insertSequence(0xF2, 120, _s06_currHorseSequenceId, 120, kSeqSyncWait, 0, 0, 0); + _gameSys->insertSequence(0x100, _gnapId, makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, kSeqSyncWait, 0, 0, 0); + _gameSys->insertSequence(0xF7, 20, 0xF8, 20, kSeqSyncWait, 0, 0, 0); + _gameSys->insertSequence(0xFB, _beaverId, _beaverSequenceId | (_beaverSequenceDatNum << 16), _beaverId, kSeqSyncWait, 0, 0, 0); + _gameSys->insertSequence(0xFA, 256, 0xFB, _beaverId, kSeqSyncWait, 0, 0, 0); + _beaverSequenceId = 0xFA; + _beaverSequenceDatNum = 0; + _gameSys->insertSequence(0x107B7, _gnapId, 0x100, _gnapId, + kSeqSyncWait, 0, 75 * _gnapX - _gnapGridX, 48 * _gnapY - _gnapGridY); + _gnapSequenceId = 0x7B7; + _gnapSequenceDatNum = 1; + _s06_currHorseSequenceId = _s06_nextHorseSequenceId; + _s06_nextHorseSequenceId = -1; + _s06_nextPlatSequenceId = -1; + invRemove(kItemTwig); + break; + case 0xF6: + _gameSys->setAnimation(_s06_nextHorseSequenceId, 120, 2); + _gameSys->insertSequence(0xF6, 120, _s06_currHorseSequenceId, 120, kSeqSyncWait, 0, 0, 0); + _s06_horseTurnedBack = true; + _s06_currHorseSequenceId = _s06_nextHorseSequenceId; + _s06_nextHorseSequenceId = -1; + _gnapActionStatus = -1; + break; + default: + _gameSys->setAnimation(_s06_nextHorseSequenceId, 120, 2); + _gameSys->insertSequence(_s06_nextHorseSequenceId, 120, _s06_currHorseSequenceId, 120, kSeqSyncWait, 0, 0, 0); + _s06_currHorseSequenceId = _s06_nextHorseSequenceId; + _s06_nextHorseSequenceId = -1; + break; + } + } + +} + +} // End of namespace Gnap diff --git a/engines/gnap/scenes/scene07.cpp b/engines/gnap/scenes/scene07.cpp new file mode 100644 index 0000000000..9b8ee2975b --- /dev/null +++ b/engines/gnap/scenes/scene07.cpp @@ -0,0 +1,275 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "gnap/gnap.h" +#include "gnap/gamesys.h" +#include "gnap/resource.h" + +namespace Gnap { + +enum { + kHSPlatypus = 0, + kHSExitHouse = 1, + kHSDice = 2, + kHSDevice = 3, + kHSWalkArea1 = 4, + kHSWalkArea2 = 5, + kHSWalkArea3 = 6 +}; + +enum { + kASWait = 0, + kASLeaveScene = 1 +}; + +int GnapEngine::scene07_init() { + return 0x92; +} + +void GnapEngine::scene07_updateHotspots() { + setHotspot(kHSPlatypus, 0, 0, 0, 0, SF_WALKABLE | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSExitHouse, 700, 125, 799, 290, SF_EXIT_NE_CURSOR); + setHotspot(kHSDice, 200, 290, 270, 360, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSWalkArea1, 0, 0, 325, 445); + setHotspot(kHSWalkArea2, 325, 0, 799, 445, _isLeavingScene ? SF_WALKABLE : 0); + setHotspot(kHSWalkArea3, 160, 0, 325, 495); + setDeviceHotspot(kHSDevice, -1, -1, -1, -1); + if (isFlag(0)) + _hotspots[kHSDice].flags = SF_DISABLED; + _hotspotsCount = 7; +} + +void GnapEngine::scene07_run() { + + queueInsertDeviceIcon(); + _gameSys->insertSequence(0x8C, 1, 0, 0, kSeqLoop, 0, 0, 0); + _gameSys->insertSequence(0x90, 1, 0, 0, kSeqLoop, 0, 0, 0); + + invRemove(kItemGas); + invRemove(kItemNeedle); + + if (!isFlag(0)) + _gameSys->insertSequence(0x8D, 1, 0, 0, kSeqNone, 0, 0, 0); + + if (_prevSceneNum == 8) { + initGnapPos(7, 7, 3); + initBeaverPos(9, 7, 4); + endSceneInit(); + } else { + _gnapX = 6; + _gnapY = 7; + _gnapId = 140; + _gnapSequenceId = 0x8F; + _gnapSequenceDatNum = 0; + _gnapIdleFacing = 1; + _gameSys->insertSequence(0x8F, 140, 0, 0, kSeqNone, 0, 0, 0); + _gameSys->setAnimation(makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, 0); + _gnapActionStatus = kASWait; + _platX = 3; + _platY = 8; + _beaverId = 160; + _beaverSequenceId = 0x91; + _beaverSequenceDatNum = 0; + _beaverFacing = 0; + _gameSys->insertSequence(0x91, 160, 0, 0, kSeqNone, 0, 0, 0); + endSceneInit(); + } + + _timers[3] = 600; + _timers[4] = getRandom(40) + 50; + + while (!_sceneDone) { + + if (!isSoundPlaying(0x10919)) + playSound(0x10919, 1); + + if (testWalk(0, 1, 8, 7, 6, 7)) + scene07_updateHotspots(); + + updateMouseCursor(); + updateCursorByHotspot(); + + _sceneClickedHotspot = getClickedHotspotId(); + updateGrabCursorSprite(0, 0); + + switch (_sceneClickedHotspot) { + + case kHSPlatypus: + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapMoan1(_platX, _platY); + break; + case GRAB_CURSOR: + gnapKissPlatypus(0); + break; + case TALK_CURSOR: + playGnapBrainPulsating(_platX, _platY); + playBeaverSequence(getBeaverSequenceId(0, 0, 0) | 0x10000); + break; + case PLAT_CURSOR: + break; + } + break; + + case kHSExitHouse: + _isLeavingScene = true; + if (_gnapX > 8) + gnapWalkTo(_gnapX, 7, 0, 0x107AD, 1); + else + gnapWalkTo(8, 7, 0, 0x107AD, 1); + _gnapActionStatus = kASLeaveScene; + break; + + case kHSDice: + if (_grabCursorSpriteIndex >= 0) { + playGnapShowCurrItem(4, 8, 3, 3); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + break; + case GRAB_CURSOR: + setFlag(0); + invAdd(kItemDice); + scene07_updateHotspots(); + playGnapPullOutDevice(3, 3); + _gameSys->setAnimation(0x8E, 1, 2); + _gameSys->insertSequence(0x8E, 1, 141, 1, kSeqSyncWait, 0, 0, 0); + _gameSys->insertSequence(getGnapSequenceId(gskUseDevice, 0, 0) | 0x10000, _gnapId, + makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, + kSeqSyncWait, 0, 75 * _gnapX - _gnapGridX, 48 * _gnapY - _gnapGridY); + _gnapSequenceId = getGnapSequenceId(gskUseDevice, 0, 0); + _gnapSequenceDatNum = 1; + break; + case TALK_CURSOR: + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + break; + + case kHSDevice: + if (_gnapActionStatus < 0) { + runMenu(); + scene07_updateHotspots(); + _timers[4] = getRandom(40) + 50; + } + break; + + case kHSWalkArea1: + case kHSWalkArea2: + gnapWalkTo(-1, -1, -1, -1, 1); + break; + + case kHSWalkArea3: + // Nothing + break; + + default: + if (_mouseClickState.left) { + gnapWalkTo(-1, -1, -1, -1, 1); + _mouseClickState.left = false; + } + break; + + } + + scene07_updateAnimations(); + + if (!_isLeavingScene) { + updateGnapIdleSequence(); + if (_beaverActionStatus < 0 && _gnapActionStatus < 0) { + if (_timers[0]) { + if (!_timers[1]) { + _timers[1] = getRandom(20) + 30; + _gnapRandomValue = getRandom(20); + // TODO Cleanup + if (_beaverFacing != 0) { + if (_gnapRandomValue != 0 || _beaverSequenceId != 0x7CA) { + if (_gnapRandomValue != 1 || _beaverSequenceId != 0x7CA) { + if (_platY == 9) + playBeaverSequence(0x107CA); + } else { + playBeaverSequence(0x10845); + } + } else { + playBeaverSequence(0x107CC); + } + } else if (_gnapRandomValue != 0 || _beaverSequenceId != 0x7C9) { + if (_gnapRandomValue != 1 || _beaverSequenceId != 0x7C9) { + if (_platY == 9) + playBeaverSequence(0x107C9); + } else { + playBeaverSequence(0x10844); + } + } else { + playBeaverSequence(0x107CB); + } + _gameSys->setAnimation(_beaverSequenceId | (_beaverSequenceDatNum << 16), _beaverId, 1); + } + } else { + _timers[0] = getRandom(75) + 75; + beaverMakeRoom(); + } + } else { + _timers[0] = 100; + _timers[1] = 35; + } + sceneXX_playRandomSound(4); + } + + checkGameKeys(); + + if (isKeyStatus1(8)) { + clearKeyStatus1(8); + runMenu(); + scene07_updateHotspots(); + _timers[4] = getRandom(40) + 50; + } + + gameUpdateTick(); + + } + +} + +void GnapEngine::scene07_updateAnimations() { + + if (_gameSys->getAnimationStatus(0) == 2) { + _gameSys->setAnimation(0, 0, 0); + switch (_gnapActionStatus) { + case kASLeaveScene: + _newSceneNum = 8; + _sceneDone = true; + break; + } + _gnapActionStatus = -1; + } + + if (_gameSys->getAnimationStatus(2) == 2) { + _gameSys->setAnimation(0, 0, 2); + setGrabCursorSprite(kItemDice); + } + +} + +} // End of namespace Gnap diff --git a/engines/gnap/scenes/scene08.cpp b/engines/gnap/scenes/scene08.cpp new file mode 100644 index 0000000000..a4ebf92c71 --- /dev/null +++ b/engines/gnap/scenes/scene08.cpp @@ -0,0 +1,527 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "gnap/gnap.h" +#include "gnap/gamesys.h" +#include "gnap/resource.h" + +namespace Gnap { + +enum { + kHSPlatypus = 0, + kHSExitBackdoor = 1, + kHSExitCrash = 2, + kHSMan = 3, + kHSDoor = 4, + kHSMeat = 5, + kHSBone = 6, + kHSToy = 7, + kHSWalkArea1 = 8, + kHSDevice = 9, + kHSWalkArea2 = 10 +}; + +enum { + kASLeaveScene = 0, + kASTalkMan = 1, + kASLookMan = 2, + kASLookDog = 3, + kASGrabDog = 4, + kASTalkDog = 5, + kASPlatWithMan = 6, + kASPlatWithDog = 7 +}; + +int GnapEngine::scene08_init() { + return 0x150; +} + +void GnapEngine::scene08_updateHotspots() { + setHotspot(kHSPlatypus, 0, 0, 0, 0, SF_WALKABLE | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSExitBackdoor, 0, 280, 10, 400, SF_EXIT_L_CURSOR | SF_WALKABLE); + setHotspot(kHSExitCrash, 200, 590, 400, 599, SF_EXIT_D_CURSOR | SF_WALKABLE); + setHotspot(kHSMan, 510, 150, 610, 380, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSDoor, 350, 170, 500, 410, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSMeat, 405, 450, 480, 485, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSBone, 200, 405, 270, 465, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSToy, 540, 430, 615, 465, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSWalkArea1, 290, 340, -1, -1); + setHotspot(kHSWalkArea2, 0, 0, 799, 420); + setDeviceHotspot(kHSDevice, -1, -1, -1, -1); + if (isFlag(7)) + _hotspots[kHSMeat].flags = SF_WALKABLE | SF_DISABLED; + if (isFlag(8)) + _hotspots[kHSBone].flags = SF_WALKABLE | SF_DISABLED; + if (isFlag(9)) + _hotspots[kHSToy].flags = SF_WALKABLE | SF_DISABLED; + _hotspotsCount = 11; +} + +void GnapEngine::scene08_updateAnimationsCb() { + if (_gameSys->getAnimationStatus(3) == 2) { + _gameSys->setAnimation(_s08_nextDogSequenceId, 100, 3); + _gameSys->insertSequence(_s08_nextDogSequenceId, 100, _s08_currDogSequenceId, 100, kSeqSyncWait, 0, 0, 0); + _s08_currDogSequenceId = _s08_nextDogSequenceId; + if ( _s08_nextDogSequenceId != 0x135 ) + _s08_nextDogSequenceId = 0x134; + } +} + +void GnapEngine::scene08_run() { + + queueInsertDeviceIcon(); + + _gameSys->insertSequence(0x14F, 1, 0, 0, kSeqLoop, 0, 0, 0); + _gameSys->insertSequence(0x14E, 256, 0, 0, kSeqNone, 0, 0, 0); + + _s08_currDogSequenceId = 0x135; + _s08_nextDogSequenceId = 0x135; + + _gameSys->setAnimation(0x135, 100, 3); + _gameSys->insertSequence(_s08_currDogSequenceId, 100, 0, 0, kSeqNone, 0, 0, 0); + + _s08_currManSequenceId = 0x140; + _s08_nextManSequenceId = -1; + + _gameSys->setAnimation(0x140, 100, 2); + _gameSys->insertSequence(_s08_currManSequenceId, 100, 0, 0, kSeqNone, 0, 0, 0); + + _timers[4] = getRandom(50) + 75; + + if (!isFlag(7)) + _gameSys->insertSequence(0x144, 1, 0, 0, kSeqNone, 0, 0, 0); + + if (!isFlag(8)) + _gameSys->insertSequence(0x145, 1, 0, 0, kSeqNone, 0, 0, 0); + + if (!isFlag(9)) + _gameSys->insertSequence(0x146, 1, 0, 0, kSeqNone, 0, 0, 0); + + initGnapPos(-1, 8, 1); + initBeaverPos(-1, 7, 0); + + endSceneInit(); + + gnapWalkTo(1, 8, -1, 0x107B9, 1); + platypusWalkTo(1, 7, -1, 0x107C2, 1); + + _timers[5] = getRandom(40) + 50; + + while (!_sceneDone) { + + if (!isSoundPlaying(0x10919)) + playSound(0x10919, 1); + + testWalk(0, 0, -1, -1, -1, -1); + + updateMouseCursor(); + updateCursorByHotspot(); + + _sceneClickedHotspot = getClickedHotspotId(); + updateGrabCursorSprite(0, 0); + + switch (_sceneClickedHotspot) { + + case kHSDevice: + if (_gnapActionStatus < 0) { + runMenu(); + scene08_updateHotspots(); + _timers[4] = getRandom(50) + 75; + _timers[5] = getRandom(40) + 50; + } + break; + + case kHSPlatypus: + if (_grabCursorSpriteIndex >= 0) { + playGnapImpossible(0, 0); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + if (isFlag(11)) + playGnapMoan1(_platX, _platY); + else + playGnapScratchingHead(_platX, _platY); + break; + case GRAB_CURSOR: + gnapActionIdle(0x14D); + gnapKissPlatypus(8); + break; + case TALK_CURSOR: + playGnapBrainPulsating(_platX, _platY); + playBeaverSequence(getBeaverSequenceId(0, 0, 0) | 0x10000); + break; + case PLAT_CURSOR: + break; + } + } + break; + + case kHSExitBackdoor: + _isLeavingScene = 1; + gnapActionIdle(0x14D); + gnapWalkTo(0, 6, 0, 0x107AF, 1); + _gnapActionStatus = kASLeaveScene; + platypusWalkTo(0, 7, 1, 0x107CF, 1); + _newSceneNum = 9; + break; + + case kHSExitCrash: + _isLeavingScene = 1; + gnapActionIdle(0x14D); + gnapWalkTo(3, 9, 0, 0x107AE, 1); + _gnapActionStatus = kASLeaveScene; + platypusWalkTo(4, 9, 1, 0x107C1, 1); + _newSceneNum = 7; + break; + + case kHSMan: + if (_grabCursorSpriteIndex >= 0) { + playGnapShowCurrItem(6, 6, 7, 0); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + gnapActionIdle(0x14D); + gnapWalkTo(6, 6, 0, 0x107BB, 1); + _gnapActionStatus = kASLookMan; + _gnapIdleFacing = 7; + break; + case GRAB_CURSOR: + playGnapImpossible(0, 0); + break; + case TALK_CURSOR: + _gnapIdleFacing = 5; + gnapActionIdle(0x14D); + gnapWalkTo(8, 6, 0, getGnapSequenceId(gskBrainPulsating, 0, 0) | 0x10000, 1); + _gnapActionStatus = kASTalkMan; + break; + case PLAT_CURSOR: + gnapActionIdle(0x14D); + gnapUseDeviceOnBeaver(); + platypusWalkTo(6, 6, 1, 0x107C2, 1); + _beaverActionStatus = kASPlatWithMan; + _beaverFacing = 0; + playGnapIdle(6, 6); + break; + } + } + break; + + case kHSDoor: + if (_grabCursorSpriteIndex >= 0) { + playGnapShowCurrItem(4, 7, 5, 0); + _gameSys->setAnimation(makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, 0); + _gnapActionStatus = kASGrabDog; + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapScratchingHead(6, 0); + _gameSys->setAnimation(makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, 0); + _gnapActionStatus = kASLookDog; + break; + case GRAB_CURSOR: + gnapWalkTo(4, 7, 0, 0x107BB, 1); + _gnapActionStatus = kASGrabDog; + _gnapIdleFacing = 7; + break; + case TALK_CURSOR: + _gnapIdleFacing = 7; + gnapActionIdle(0x14D); + gnapWalkTo(4, 7, 0, getGnapSequenceId(gskBrainPulsating, 0, 0) | 0x10000, 1); + _gnapActionStatus = kASTalkDog; + break; + case PLAT_CURSOR: + setFlag(11); + gnapActionIdle(0x14D); + gnapUseDeviceOnBeaver(); + platypusWalkTo(3, 7, 1, 0x107C2, 1); + _beaverActionStatus = kASPlatWithDog; + _beaverFacing = 0; + playGnapIdle(3, 7); + break; + } + } + break; + + case kHSMeat: + if (_grabCursorSpriteIndex >= 0) { + playGnapShowCurrItem(6, 8, 5, 6); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapScratchingHead(6, 7); + break; + case GRAB_CURSOR: + if (_s08_currDogSequenceId == 0x135) { + playGnapScratchingHead(6, 7); + } else { + gnapActionIdle(0x14D); + playGnapPullOutDevice(6, 7); + playGnapUseDevice(0, 0); + _s08_nextDogSequenceId = 0x149; + } + break; + case TALK_CURSOR: + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + break; + + case kHSBone: + if (_grabCursorSpriteIndex >= 0) { + playGnapShowCurrItem(2, 7, 3, 6); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapScratchingHead(3, 6); + break; + case GRAB_CURSOR: + if (_s08_currDogSequenceId == 0x135) { + playGnapScratchingHead(3, 6); + } else { + gnapActionIdle(0x14D); + playGnapPullOutDevice(3, 6); + playGnapUseDevice(0, 0); + _s08_nextDogSequenceId = 0x14A; + } + break; + case TALK_CURSOR: + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + break; + + case kHSToy: + if (_grabCursorSpriteIndex >= 0) { + playGnapShowCurrItem(8, 7, 7, 6); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapScratchingHead(7, 6); + break; + case GRAB_CURSOR: + if (_s08_currDogSequenceId == 0x135) { + playGnapScratchingHead(7, 6); + } else { + gnapActionIdle(0x14D); + playGnapPullOutDevice(7, 6); + playGnapUseDevice(0, 0); + _s08_nextDogSequenceId = 0x14B; + } + break; + case TALK_CURSOR: + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + break; + + case kHSWalkArea1: + case kHSWalkArea2: + gnapActionIdle(0x14D); + gnapWalkTo(-1, 6, -1, -1, 1); + break; + + default: + if (_mouseClickState.left) { + gnapActionIdle(0x14D); + gnapWalkTo(-1, -1, -1, -1, 1); + _mouseClickState.left = false; + } + break; + + } + + scene08_updateAnimations(); + + if (!_isLeavingScene) { + updateBeaverIdleSequence(); + updateGnapIdleSequence(); + if (!_timers[4]) { + _timers[4] = getRandom(50) + 125; + if (_gnapActionStatus < 0 && _beaverActionStatus < 0 && _s08_nextManSequenceId == -1 && + (_s08_currDogSequenceId == 0x134 || _s08_currDogSequenceId == 0x135)) { + _gnapRandomValue = getRandom(4); + switch (_gnapRandomValue) { + case 0: + _s08_nextManSequenceId = 0x138; + break; + case 1: + _s08_nextManSequenceId = 0x136; + break; + case 2: + _s08_nextManSequenceId = 0x13B; + break; + case 3: + _s08_nextManSequenceId = 0x13A; + break; + } + } + } + sceneXX_playRandomSound(5); + } + + checkGameKeys(); + + if (isKeyStatus1(8)) { + clearKeyStatus1(8); + runMenu(); + scene08_updateHotspots(); + _timers[4] = getRandom(50) + 75; + _timers[5] = getRandom(40) + 50; + } + + gameUpdateTick(); + + } + +} + +void GnapEngine::scene08_updateAnimations() { + + if (_gameSys->getAnimationStatus(0) == 2) { + _gameSys->setAnimation(0, 0, 0); + switch (_gnapActionStatus) { + case kASLeaveScene: + _sceneDone = true; + _gnapActionStatus = -1; + break; + case kASTalkMan: + _s08_nextManSequenceId = 0x13F; + _gnapActionStatus = -1; + break; + case kASLookMan: + _s08_nextManSequenceId = 0x140; + _gnapActionStatus = -1; + break; + case kASLookDog: + _s08_nextManSequenceId = 0x137; + _gnapActionStatus = -1; + break; + case kASGrabDog: + if (_s08_currDogSequenceId == 0x135) + _s08_nextDogSequenceId = 0x133; + else + _s08_nextDogSequenceId = 0x13C; + _gnapActionStatus = -1; + break; + case kASTalkDog: + if (_s08_currDogSequenceId == 0x135) + _s08_nextDogSequenceId = 0x133; + else + _s08_nextDogSequenceId = 0x13C; + _gnapActionStatus = -1; + break; + } + } + + if (_gameSys->getAnimationStatus(1) == 2) { + _gameSys->setAnimation(0, 0, 1); + switch (_beaverActionStatus) { + case kASPlatWithDog: + _s08_nextDogSequenceId = 0x147; + break; + case kASPlatWithMan: + _s08_nextManSequenceId = 0x140; + _beaverActionStatus = -1; + break; + } + } + + if (_gameSys->getAnimationStatus(2) == 2 && _s08_nextManSequenceId != -1) { + _gameSys->setAnimation(_s08_nextManSequenceId, 100, 2); + _gameSys->insertSequence(_s08_nextManSequenceId, 100, _s08_currManSequenceId, 100, kSeqSyncWait, 0, 0, 0); + _s08_currManSequenceId = _s08_nextManSequenceId; + _s08_nextManSequenceId = -1; + } + + if (_gameSys->getAnimationStatus(3) == 2) { + if (_s08_currDogSequenceId == 0x147) + _beaverActionStatus = -1; + if (_s08_currDogSequenceId == 0x149 || _s08_currDogSequenceId == 0x14A || _s08_currDogSequenceId == 0x14B) { + if (getRandom(2) != 0) + _s08_nextManSequenceId = 0x13D; + else + _s08_nextManSequenceId = 0x13E; + } else if (_s08_currDogSequenceId == 0x133) + _s08_nextManSequenceId = 0x139; + if (_s08_nextDogSequenceId == 0x149 || _s08_nextDogSequenceId == 0x14A || _s08_nextDogSequenceId == 0x14B) { + _gameSys->setAnimation(_s08_nextDogSequenceId, 100, 3); + _gameSys->insertSequence(_s08_nextDogSequenceId, 100, _s08_currDogSequenceId, 100, kSeqSyncWait, 0, 0, 0); + switch (_s08_nextDogSequenceId) { + case 0x149: + setFlag(7); + _hotspots[kHSMeat].flags = SF_DISABLED | SF_WALKABLE; + _gameSys->removeSequence(0x144, 1, 1); + break; + case 0x14A: + setFlag(8); + _hotspots[kHSBone].flags = SF_DISABLED | SF_WALKABLE; + _gameSys->removeSequence(0x145, 1, 1); + break; + case 0x14B: + setFlag(9); + _hotspots[kHSToy].flags = SF_DISABLED | SF_WALKABLE; + _gameSys->removeSequence(0x146, 1, 1); + break; + } + _s08_currDogSequenceId = _s08_nextDogSequenceId; + _s08_nextDogSequenceId = 0x134; + } else if (_s08_nextDogSequenceId == 0x147) { + _gameSys->setAnimation(_s08_nextDogSequenceId, 100, 3); + _gameSys->insertSequence(_s08_nextDogSequenceId, 100, _s08_currDogSequenceId, 100, kSeqSyncWait, 0, 0, 0); + _gameSys->insertSequence(0x148, 160, _beaverSequenceId | (_beaverSequenceDatNum << 16), _beaverId, kSeqSyncWait, 0, 0, 0); + _s08_currDogSequenceId = _s08_nextDogSequenceId; + _s08_nextDogSequenceId = 0x134; + _platX = 1; + _platY = 8; + _beaverId = 160; + _beaverSequenceId = 0x148; + _beaverFacing = 4; + _beaverSequenceDatNum = 0; + if (_gnapX == 1 && _gnapY == 8) + gnapWalkStep(); + } else if (_s08_nextDogSequenceId != -1) { + _gameSys->setAnimation(_s08_nextDogSequenceId, 100, 3); + _gameSys->insertSequence(_s08_nextDogSequenceId, 100, _s08_currDogSequenceId, 100, kSeqSyncWait, 0, 0, 0); + _s08_currDogSequenceId = _s08_nextDogSequenceId; + if (_s08_nextDogSequenceId != 0x135) + _s08_nextDogSequenceId = 0x134; + if (_s08_currDogSequenceId == 0x133) { + _timers[2] = getRandom(30) + 20; + _timers[3] = getRandom(50) + 200; + _gameSys->insertSequence(0x14D, _gnapId, makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, kSeqSyncWait, 0, 0, 0); + _gnapSequenceId = 0x14D; + _gnapIdleFacing = 7; + _gnapSequenceDatNum = 0; + _gnapActionStatus = -1; + } + } + } + +} + +} // End of namespace Gnap diff --git a/engines/gnap/scenes/scene09.cpp b/engines/gnap/scenes/scene09.cpp new file mode 100644 index 0000000000..4436d1e436 --- /dev/null +++ b/engines/gnap/scenes/scene09.cpp @@ -0,0 +1,241 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "gnap/gnap.h" +#include "gnap/gamesys.h" +#include "gnap/resource.h" + +namespace Gnap { + +enum { + kHSPlatypus = 0, + kHSExitKitchen = 1, + kHSExitHouse = 2, + kHSTrash = 3, + kHSDevice = 4, + kHSWalkArea1 = 5, + kHSWalkArea2 = 6, + kHSWalkArea3 = 7 +}; + +enum { + kASLeaveScene = 0, + kASSearchTrash = 1, + kASSearchTrashDone = 2 +}; + +int GnapEngine::scene09_init() { + return 0x4E; +} + +void GnapEngine::scene09_updateHotspots() { + setHotspot(kHSPlatypus, 0, 200, 0, 0, SF_WALKABLE | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSExitKitchen, 280, 200, 380, 400, SF_EXIT_U_CURSOR); + setHotspot(kHSExitHouse, 790, 200, 799, 450, SF_EXIT_R_CURSOR | SF_WALKABLE); + setHotspot(kHSTrash, 440, 310, 680, 420, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSWalkArea1, 0, 0, 799, 400); + setHotspot(kHSWalkArea2, 0, 0, 630, 450); + setHotspot(kHSWalkArea2, 0, 0, 175, 495); + setDeviceHotspot(kHSDevice, -1, -1, -1, -1); + _hotspotsCount = 8; +} + +void GnapEngine::scene09_run() { + + queueInsertDeviceIcon(); + + _gameSys->insertSequence(0x4D, 1, 0, 0, kSeqLoop, 0, 0, 0); + _gameSys->insertSequence(0x4B, 2, 0, 0, kSeqNone, 0, 0, 0); + + if (_prevSceneNum == 8) { + initGnapPos(11, 8, 3); + initBeaverPos(12, 7, 4); + endSceneInit(); + gnapWalkTo(9, 8, -1, 0x107BA, 1); + platypusWalkTo(9, 7, -1, 0x107D2, 1); + } else { + initGnapPos(4, 7, 1); + initBeaverPos(5, 7, 0); + endSceneInit(); + } + + _timers[4] = getRandom(150) + 50; + _timers[5] = getRandom(40) + 50; + + while (!_sceneDone) { + + if (!isSoundPlaying(0x10919)) + playSound(0x10919, 1); + + testWalk(0, 0, -1, -1, -1, -1); + + updateMouseCursor(); + updateCursorByHotspot(); + + _sceneClickedHotspot = getClickedHotspotId(); + updateGrabCursorSprite(0, 0); + + switch (_sceneClickedHotspot) { + + case kHSDevice: + if (_gnapActionStatus < 0) { + runMenu(); + scene09_updateHotspots(); + _timers[4] = getRandom(150) + 50; + _timers[5] = getRandom(40) + 50; + } + break; + + case kHSPlatypus: + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapMoan1(_platX, _platY); + break; + case GRAB_CURSOR: + gnapKissPlatypus(0); + break; + case TALK_CURSOR: + playGnapBrainPulsating(_platX, _platY); + playBeaverSequence(getBeaverSequenceId(0, 0, 0) | 0x10000); + break; + case PLAT_CURSOR: + break; + } + break; + + case kHSExitKitchen: + _isLeavingScene = 1; + _newSceneNum = 10; + gnapWalkTo(4, 7, 0, 0x107BF, 1); + _gnapActionStatus = kASLeaveScene; + platypusWalkTo(4, 8, -1, 0x107D2, 1); + _beaverFacing = 4; + break; + + case kHSExitHouse: + _isLeavingScene = 1; + _newSceneNum = 8; + gnapWalkTo(10, -1, 0, 0x107AB, 1); + _gnapActionStatus = kASLeaveScene; + platypusWalkTo(10, -1, -1, 0x107CD, 1); + _beaverFacing = 4; + break; + + case kHSTrash: + if (_grabCursorSpriteIndex >= 0) { + playGnapShowCurrItem(9, 6, 8, 0); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapScratchingHead(8, 3); + break; + case GRAB_CURSOR: + _gnapActionStatus = kASSearchTrash; + gnapWalkTo(9, 6, 0, 0x107BC, 1); + break; + case TALK_CURSOR: + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + break; + + case kHSWalkArea1: + case kHSWalkArea2: + case kHSWalkArea3: + gnapWalkTo(-1, -1, -1, -1, 1); + break; + + default: + if (_mouseClickState.left) { + gnapWalkTo(-1, -1, -1, -1, 1); + _mouseClickState.left = false; + } + break; + + } + + scene09_updateAnimations(); + + if (!_isLeavingScene && _gnapActionStatus != 1 && _gnapActionStatus != 2) { + updateBeaverIdleSequence(); + updateGnapIdleSequence(); + if (!_timers[4]) { + _timers[4] = getRandom(150) + 100; + if (_timers[4] & 1) + _gameSys->insertSequence(0x49, 1, 0, 0, kSeqNone, 0, 0, 0); + else + _gameSys->insertSequence(0x4A, 1, 0, 0, kSeqNone, 0, 0, 0); + } + sceneXX_playRandomSound(5); + } + + checkGameKeys(); + + if (isKeyStatus1(8)) { + clearKeyStatus1(8); + runMenu(); + scene09_updateHotspots(); + _timers[4] = getRandom(150) + 50; + _timers[5] = getRandom(40) + 50; + } + + gameUpdateTick(); + + } + +} + +void GnapEngine::scene09_updateAnimations() { + + if (_gameSys->getAnimationStatus(0) == 2) { + _gameSys->setAnimation(0, 0, 0); + switch (_gnapActionStatus) { + case kASLeaveScene: + _sceneDone = true; + _gnapActionStatus = -1; + break; + case kASSearchTrash: + _gameSys->setAnimation(0x4C, 120, 0); + _gameSys->insertSequence(0x4C, 120, makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, kSeqSyncWait, 0, 0, 0); + _gameSys->removeSequence(0x4B, 2, 1); + _gnapSequenceId = 0x4C; + _gnapId = 120; + _gnapIdleFacing = 5; + _gnapSequenceDatNum = 0; + _gnapX = 9; + _gnapY = 6; + _gnapActionStatus = kASSearchTrashDone; + break; + case kASSearchTrashDone: + _gameSys->insertSequence(0x4B, 2, 0, 0, kSeqNone, 0, 0, 0); + _timers[2] = 360; + _timers[4] = getRandom(150) + 100; + _gnapActionStatus = -1; + break; + } + } + +} + +} // End of namespace Gnap diff --git a/engines/gnap/scenes/scene10.cpp b/engines/gnap/scenes/scene10.cpp new file mode 100644 index 0000000000..c6faf5a0ca --- /dev/null +++ b/engines/gnap/scenes/scene10.cpp @@ -0,0 +1,500 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "gnap/gnap.h" +#include "gnap/gamesys.h" +#include "gnap/resource.h" + +namespace Gnap { + +enum { + kHSPlatypus = 0, + kHSExitBar = 1, + kHSExitBackdoor = 2, + kHSCook = 3, + kHSTongs = 4, + kHSBox = 5, + kHSOven = 6, + kHSWalkArea1 = 7, + kHSDevice = 8, + kHSWalkArea2 = 9, + kHSWalkArea3 = 10, + kHSWalkArea4 = 11 +}; + +enum { + kASLeaveScene = 0, + kASAnnoyCook = 1, + kASPlatWithBox = 4 +}; + +int GnapEngine::scene10_init() { + _gameSys->setAnimation(0, 0, 0); + _gameSys->setAnimation(0, 0, 1); + _gameSys->setAnimation(0, 0, 2); + return 0x10F; +} + +void GnapEngine::scene10_updateHotspots() { + setHotspot(kHSPlatypus, 0, 0, 0, 0, SF_WALKABLE | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSExitBar, 0, 75, 85, 455, SF_EXIT_NW_CURSOR); + setHotspot(kHSExitBackdoor, 75, 590, 500, 599, SF_EXIT_D_CURSOR | SF_WALKABLE); + setHotspot(kHSCook, 370, 205, 495, 460, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSTongs, 250, 290, 350, 337, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSBox, 510, 275, 565, 330, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSOven, 690, 280, 799, 420, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSWalkArea1, 59, 0, 495, 460); + setHotspot(kHSWalkArea2, 495, 0, 650, 420); + setHotspot(kHSWalkArea3, 651, 0, 725, 400); + setHotspot(kHSWalkArea4, 725, 0, 799, 441); + setDeviceHotspot(kHSDevice, -1, -1, -1, -1); + _hotspotsCount = 12; +} + +void GnapEngine::scene10_run() { + + _s10_currCookSequenceId = 0x103; + + _gameSys->setAnimation(0x103, 100, 2); + _gameSys->insertSequence(0x103, 100, 0, 0, kSeqNone, 0, 0, 0); + + _s10_nextCookSequenceId = 0x106; + if (!isFlag(1)) + _gameSys->insertSequence(0x107, 100, 0, 0, kSeqNone, 0, 0, 0); + + queueInsertDeviceIcon(); + + if (_prevSceneNum == 9) { + initGnapPos(11, 8, 3); + initBeaverPos(12, 7, 4); + endSceneInit(); + gnapWalkTo(9, 8, -1, 0x107BA, 1); + platypusWalkTo(9, 7, -1, 0x107D2, 1); + } else { + initGnapPos(-1, 7, 1); + initBeaverPos(-2, 8, 0); + endSceneInit(); + gnapWalkTo(1, 7, -1, 0x107B9, 1); + platypusWalkTo(1, 8, -1, 0x107C2, 1); + } + + _timers[4] = getRandom(80) + 150; + _timers[5] = getRandom(100) + 100; + + while (!_sceneDone) { + + if (!isSoundPlaying(0x1091E)) + playSound(0x1091E, 1); + + if (!isSoundPlaying(0x1091A)) + playSound(0x1091A, 1); + + updateMouseCursor(); + + testWalk(0, 0, -1, -1, -1, -1); + + updateCursorByHotspot(); + + _sceneClickedHotspot = getClickedHotspotId(); + updateGrabCursorSprite(0, 0); + + switch (_sceneClickedHotspot) { + + case kHSPlatypus: + if (_grabCursorSpriteIndex >= 0) { + playGnapImpossible(0, 0); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + if (isFlag(1)) + playGnapMoan1(_platX, _platY); + else + playGnapScratchingHead(_platX, _platY); + break; + case GRAB_CURSOR: + gnapKissPlatypus(10); + break; + case TALK_CURSOR: + playGnapBrainPulsating(_platX, _platY); + playBeaverSequence(getBeaverSequenceId(0, 0, 0) | 0x10000); + break; + case PLAT_CURSOR: + break; + } + } + break; + + case kHSExitBar: + _isLeavingScene = 1; + gnapActionIdle(0x10C); + gnapWalkTo(0, 7, 0, 0x107AF, 1); + _gnapActionStatus = kASLeaveScene; + platypusWalkTo(0, 7, -1, 0x107CF, 1); + _newSceneNum = 11; + break; + + case kHSExitBackdoor: + _isLeavingScene = 1; + gnapActionIdle(0x10C); + gnapWalkTo(2, 9, 0, 0x107AE, 1); + _gnapActionStatus = kASLeaveScene; + platypusWalkTo(3, 9, -1, 0x107C7, 1); + _newSceneNum = 9; + break; + + case kHSCook: + if (_grabCursorSpriteIndex >= 0) { + playGnapShowCurrItem(4, 8, 6, 0); + _gameSys->setAnimation(makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, 0); + _gnapActionStatus = kASAnnoyCook; + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapScratchingHead(6, 0); + break; + case GRAB_CURSOR: + playGnapImpossible(0, 0); + _gnapIdleFacing = 1; + break; + case TALK_CURSOR: + _gnapIdleFacing = 7; + gnapActionIdle(0x10C); + gnapWalkTo(4, 8, 0, getGnapSequenceId(gskBrainPulsating, 0, 0) | 0x10000, 1); + _gnapActionStatus = kASAnnoyCook; + break; + case PLAT_CURSOR: + gnapActionIdle(0x10C); + gnapUseDeviceOnBeaver(); + platypusWalkTo(4, 6, -1, -1, 1); + gnapWalkTo(4, 8, 0, 0x107BB, 1); + _gnapActionStatus = kASAnnoyCook; + break; + } + } + break; + + case kHSTongs: + if (_grabCursorSpriteIndex >= 0) { + playGnapShowCurrItem(3, 7, 4, 0); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + if (isFlag(1)) + playGnapMoan2(-1, -1); + else + playGnapScratchingHead(4, 3); + break; + case GRAB_CURSOR: + if (isFlag(1)) + playGnapMoan2(-1, -1); + else { + gnapActionIdle(0x10C); + gnapWalkTo(4, 8, 0, 0x107BB, 1); + _gnapActionStatus = kASAnnoyCook; + } + break; + case TALK_CURSOR: + playGnapImpossible(0, 0); + break; + case PLAT_CURSOR: + if (isFlag(1)) + playGnapMoan2(-1, -1); + else { + gnapActionIdle(0x10C); + gnapUseDeviceOnBeaver(); + platypusWalkTo(3, 7, -1, -1, 1); + gnapWalkTo(4, 8, 0, 0x107BB, 1); + _gnapActionStatus = kASAnnoyCook; + } + break; + } + } + break; + + case kHSBox: + if (_grabCursorSpriteIndex >= 0) { + playGnapShowCurrItem(7, 6, 6, 0); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapScratchingHead(7, 3); + break; + case GRAB_CURSOR: + gnapActionIdle(0x10C); + gnapWalkTo(4, 8, 0, 0x107BB, 1); + _gnapActionStatus = kASAnnoyCook; + break; + case TALK_CURSOR: + playGnapImpossible(0, 0); + break; + case PLAT_CURSOR: + if (isFlag(1)) + playGnapMoan2(-1, -1); + else { + invAdd(kItemTongs); + setFlag(1); + gnapActionIdle(0x10C); + gnapUseDeviceOnBeaver(); + platypusWalkTo(7, 6, 1, 0x107D2, 1); + _beaverActionStatus = kASPlatWithBox; + _beaverFacing = 4; + _largeSprite = _gameSys->createSurface(0xC3); + playGnapIdle(7, 6); + } + break; + } + } + break; + + case kHSOven: + if (_grabCursorSpriteIndex >= 0) { + playGnapShowCurrItem(9, 6, 10, 0); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapSequence(getGnapSequenceId(gskDeflect, 10, 5) | 0x10000); + break; + case GRAB_CURSOR: + gnapActionIdle(0x10C); + gnapWalkTo(9, 6, 0, 0x107BB, 1); + _gameSys->insertSequence(0x10E, 120, makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, kSeqSyncWait, 0, 0, 0); + _gnapSequenceId = 0x10E; + _gnapId = 120; + _gnapIdleFacing = 7; + _gnapSequenceDatNum = 0; + _gnapX = 9; + _gnapY = 6; + _timers[2] = 360; + break; + case TALK_CURSOR: + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + break; + + case kHSWalkArea1: + case kHSWalkArea2: + case kHSWalkArea3: + case kHSWalkArea4: + gnapActionIdle(0x10C); + gnapWalkTo(-1, -1, -1, -1, 1); + break; + + case kHSDevice: + if (_gnapActionStatus < 0) { + runMenu(); + scene10_updateHotspots(); + } + break; + + default: + if (_mouseClickState.left) { + gnapActionIdle(0x10C); + gnapWalkTo(-1, -1, -1, -1, 1); + _mouseClickState.left = false; + } + break; + + } + + scene10_updateAnimations(); + + if (!_isLeavingScene) { + updateBeaverIdleSequence(); + updateGnapIdleSequence(); + if (!_timers[4]) { + _timers[4] = getRandom(80) + 150; + playSound(0x12B, 0); + } + if (!_timers[5]) { + int sequenceId; + _timers[5] = getRandom(100) + 100; + _gnapRandomValue = getRandom(4); + if (_gnapRandomValue) { + if (_gnapRandomValue == 1) { + sequenceId = 0x8A5; + } else if (_gnapRandomValue == 2) { + sequenceId = 0x8A6; + } else { + sequenceId = 0x8A7; + } + _gameSys->insertSequence(sequenceId | 0x10000, 179, 0, 0, kSeqNone, 0, 0, 0); + } + } + } + + checkGameKeys(); + + if (isKeyStatus1(8)) { + clearKeyStatus1(8); + runMenu(); + scene10_updateHotspots(); + } + + gameUpdateTick(); + + } + +} + +void GnapEngine::scene10_updateAnimations() { + + if (_gameSys->getAnimationStatus(0) == 2) { + _gameSys->setAnimation(0, 0, 0); + switch (_gnapActionStatus) { + case kASLeaveScene: + _sceneDone = true; + break; + case kASAnnoyCook: + _s10_nextCookSequenceId = 0x105; + break; + } + } + + if (_gameSys->getAnimationStatus(1) == 2) { + _gameSys->setAnimation(0, 0, 1); + switch (_beaverActionStatus) { + case kASPlatWithBox: + _s10_nextCookSequenceId = 0x109; + break; + } + } + + if (_gameSys->getAnimationStatus(2) == 2 && _s10_nextCookSequenceId != -1) { + + switch (_s10_nextCookSequenceId) { + case 0x109: + _platX = 4; + _platY = 8; + _gameSys->insertSequence(0x109, 100, _s10_currCookSequenceId, 100, kSeqSyncWait, 0, 0, 0); + _gameSys->insertSequence(0x107C9, 160, + _beaverSequenceId | (_beaverSequenceDatNum << 16), _beaverId, + kSeqSyncWait, getSequenceTotalDuration(0x109) + getSequenceTotalDuration(0x10A) + getSequenceTotalDuration(0x10843), + 75 * _platX - _platGridX, 48 * _platY - _platGridY); + _gameSys->removeSequence(0x107, 100, 1); + _s10_currCookSequenceId = 0x109; + _s10_nextCookSequenceId = 0x843; + _beaverSequenceId = 0x7C9; + _beaverId = 160; + _beaverFacing = 0; + _beaverSequenceDatNum = 1; + break; + case 0x843: + hideCursor(); + _gameSys->insertSpriteDrawItem(_largeSprite, 0, 0, 300); + _gameSys->insertSequence(0x10843, 301, _s10_currCookSequenceId, 100, kSeqSyncWait, 0, 0, 0); + _s10_currCookSequenceId = 0x843; + _s10_nextCookSequenceId = 0x10A; + break; + case 0x10A: + _gameSys->insertSequence(_s10_nextCookSequenceId, 100, 0x10843, 301, kSeqSyncWait, 0, 0, 0); + _s10_currCookSequenceId = _s10_nextCookSequenceId; + _s10_nextCookSequenceId = 0x104; + showCursor(); + _gameSys->removeSpriteDrawItem(_largeSprite, 300); + delayTicksCursor(5); + deleteSurface(&_largeSprite); + setGrabCursorSprite(kItemTongs); + if (_beaverActionStatus == kASPlatWithBox) + _beaverActionStatus = -1; + if (_gnapX == 4 && _gnapY == 8) + gnapWalkStep(); + break; + default: + _gameSys->insertSequence(_s10_nextCookSequenceId, 100, _s10_currCookSequenceId, 100, kSeqSyncWait, 0, 0, 0); + _s10_currCookSequenceId = _s10_nextCookSequenceId; + break; + } + + switch (_s10_currCookSequenceId) { + case 0x106: + _gnapRandomValue = getRandom(7); + if (_gnapActionStatus >= 0 || _beaverActionStatus >= 0) + _s10_nextCookSequenceId = 0x106; + else if (_gnapRandomValue == 0) + _s10_nextCookSequenceId = 0x104; + else if (_gnapRandomValue == 1) + _s10_nextCookSequenceId = 0x103; + else if (_gnapRandomValue == 2) { + _s10_nextCookSequenceId = 0x106; + _gameSys->insertSequence(0x10D, 1, 0, 0, kSeqNone, 0, 0, 0); + } else + _s10_nextCookSequenceId = 0x106; + break; + case 0x103: + _gnapRandomValue = getRandom(7); + if (_gnapActionStatus >= 0 || _beaverActionStatus >= 0) + _s10_nextCookSequenceId = 0x106; + else if (_gnapRandomValue == 0) + _s10_nextCookSequenceId = 0x104; + else + _s10_nextCookSequenceId = 0x106; + break; + case 0x104: + _gnapRandomValue = getRandom(7); + if (_gnapActionStatus >= 0 || _beaverActionStatus >= 0) + _s10_nextCookSequenceId = 0x106; + else if (_gnapRandomValue == 0) + _s10_nextCookSequenceId = 0x103; + else + _s10_nextCookSequenceId = 0x106; + break; + case 0x105: + _gnapRandomValue = getRandom(7); + if (_gnapActionStatus >= 0 || _beaverActionStatus >= 0) + _s10_nextCookSequenceId = 0x106; + else if (_gnapRandomValue == 0) + _s10_nextCookSequenceId = 0x104; + else if (_gnapRandomValue == 1) + _s10_nextCookSequenceId = 0x103; + else + _s10_nextCookSequenceId = 0x106; + _timers[2] = getRandom(30) + 20; + _timers[3] = 300; + _gameSys->insertSequence(0x10C, _gnapId, makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, kSeqSyncWait, 0, 0, 0); + _gnapSequenceId = 0x10C; + _gnapIdleFacing = 7; + _gnapSequenceDatNum = 0; + _gnapActionStatus = -1; + _beaverActionStatus = -1; + break; + } + if (_s10_currCookSequenceId == 0x843) + _gameSys->setAnimation(_s10_currCookSequenceId | 0x10000, 301, 2); + else + _gameSys->setAnimation(_s10_currCookSequenceId, 100, 2); + } + +} + +void GnapEngine::scene10_updateAnimationsCb() { + if (_gameSys->getAnimationStatus(2) == 2) { + _gameSys->setAnimation(_s10_nextCookSequenceId, 100, 2); + _gameSys->insertSequence(_s10_nextCookSequenceId, 100, _s10_currCookSequenceId, 100, kSeqSyncWait, 0, 0, 0); + _s10_currCookSequenceId = _s10_nextCookSequenceId; + _s10_nextCookSequenceId = 0x106; + } +} + +} // End of namespace Gnap diff --git a/engines/gnap/scenes/scene11.cpp b/engines/gnap/scenes/scene11.cpp new file mode 100644 index 0000000000..6bbc542e90 --- /dev/null +++ b/engines/gnap/scenes/scene11.cpp @@ -0,0 +1,488 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "gnap/gnap.h" +#include "gnap/gamesys.h" +#include "gnap/resource.h" + +namespace Gnap { + +enum { + kHSPlatypus = 0, + kHSExitKitchen = 1, + kHSExitToilet = 2, + kHSExitLeft = 3, + kHSGoggleGuy = 4, + kHSHookGuy = 5, + kHSBillard = 6, + kHSWalkArea1 = 7, + kHSDevice = 8, + kHSWalkArea2 = 9, + kHSWalkArea3 = 10, + kHSWalkArea4 = 11, + kHSWalkArea5 = 12 +}; + +enum { + kASLeaveScene = 0, + kASShowMagazineToGoggleGuy = 3, + kASTalkGoggleGuy = 4, + kASGrabHookGuy = 6, + kASShowItemToHookGuy = 8, + kASTalkHookGuy = 9, + kASGrabBillardBall = 11 +}; + +int GnapEngine::scene11_init() { + _gameSys->setAnimation(0, 0, 0); + _gameSys->setAnimation(0, 0, 3); + _gameSys->setAnimation(0, 0, 2); + if (_prevSceneNum == 10 || _prevSceneNum == 13) { + playSound(0x108EC, 0); + playSound(0x10928, 0); + } + return 0x209; +} + +void GnapEngine::scene11_updateHotspots() { + setHotspot(kHSPlatypus, 0, 0, 0, 0, SF_WALKABLE | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSExitKitchen, 420, 140, 520, 345, SF_EXIT_U_CURSOR); + setHotspot(kHSExitToilet, 666, 130, 740, 364, SF_EXIT_R_CURSOR); + setHotspot(kHSExitLeft, 0, 350, 10, 599, SF_EXIT_L_CURSOR | SF_WALKABLE); + setHotspot(kHSGoggleGuy, 90, 185, 185, 340, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSHookGuy, 210, 240, 340, 430, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSBillard, 640, 475, 700, 530, SF_WALKABLE | SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSWalkArea1, 0, 0, 365, 453); + setHotspot(kHSWalkArea2, 0, 0, 629, 353); + setHotspot(kHSWalkArea3, 629, 0, 799, 364); + setHotspot(kHSWalkArea4, 735, 0, 799, 397); + setHotspot(kHSWalkArea5, 510, 540, 799, 599); + setDeviceHotspot(kHSDevice, -1, -1, -1, -1); + _hotspotsCount = 13; +} + +void GnapEngine::scene11_run() { + bool flag = true; + + _timers[7] = 50; + + _hotspots[kHSBillard].flags |= SF_DISABLED; + + _s11_currGoggleGuySequenceId = 0x1F9; + + _s11_currHookGuySequenceId = 0x201; + + switch (_prevSceneNum) { + case 13: + initGnapPos(8, 5, 3); + initBeaverPos(9, 6, 4); + break; + case 47: + initGnapPos(8, 5, 3); + initBeaverPos(9, 5, 4); + _s11_currGoggleGuySequenceId = 0x1FA; + _s11_currHookGuySequenceId = 0x1FF; + _timers[7] = 180; + break; + case 12: + initGnapPos(-1, 9, 1); + initBeaverPos(-2, 8, 0); + break; + default: + initGnapPos(6, 6, 3); + initBeaverPos(6, 5, 4); + break; + } + + queueInsertDeviceIcon(); + + _gameSys->insertSequence(_s11_currHookGuySequenceId, 120, 0, 0, kSeqNone, 0, 0, 0); + + _s11_nextHookGuySequenceId = -1; + + _gameSys->setAnimation(_s11_currHookGuySequenceId, 120, 3); + _gameSys->insertSequence(_s11_currGoggleGuySequenceId, 121, 0, 0, kSeqNone, 0, 0, 0); + + _s11_nextGoggleGuySequenceId = -1; + + _gameSys->setAnimation(_s11_currGoggleGuySequenceId, 121, 2); + + _timers[5] = getRandom(100) + 75; + _timers[4] = getRandom(40) + 20; + _timers[6] = getRandom(100) + 100; + endSceneInit(); + + if (_prevSceneNum == 12) { + gnapWalkTo(2, 8, -1, 0x107B9, 1); + platypusWalkTo(1, 8, -1, 0x107C2, 1); + } + + _gameSys->insertSequence(0x208, 256, 0, 0, kSeqNone, 40, 0, 0); + + while (!_sceneDone) { + + testWalk(0, 0, -1, -1, -1, -1); + + updateMouseCursor(); + updateCursorByHotspot(); + + _sceneClickedHotspot = getClickedHotspotId(); + updateGrabCursorSprite(0, 0); + + switch (_sceneClickedHotspot) { + + case kHSPlatypus: + if (_grabCursorSpriteIndex >= 0) { + playGnapImpossible(0, 0); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapMoan1(_platX, _platY); + break; + case GRAB_CURSOR: + gnapKissPlatypus(0); + break; + case TALK_CURSOR: + playGnapBrainPulsating(_platX, _platY); + playBeaverSequence(getBeaverSequenceId(0, 0, 0) | 0x10000); + break; + case PLAT_CURSOR: + break; + } + } + break; + + case kHSExitKitchen: + _isLeavingScene = true; + gnapWalkTo(6, 5, 0, 0x107BF, 1); + _gnapActionStatus = kASLeaveScene; + platypusWalkTo(6, 6, -1, -1, 1); + _newSceneNum = 10; + break; + + case kHSExitToilet: + _isLeavingScene = true; + gnapWalkTo(8, 5, 0, 0x107BF, 1); + _gnapActionStatus = kASLeaveScene; + platypusWalkTo(8, 6, -1, -1, 1); + _newSceneNum = 13; + break; + + case kHSExitLeft: + _isLeavingScene = true; + gnapWalkTo(-1, 8, 0, 0x107AF, 1); + _gnapActionStatus = kASLeaveScene; + platypusWalkTo(-1, 9, -1, 0x107CF, 1); + _newSceneNum = 12; + break; + + case kHSGoggleGuy: + if (_gnapActionStatus < 0) { + if (_grabCursorSpriteIndex == kItemMagazine) { + gnapWalkTo(3, 7, 0, 0x107BC, 1); + _gnapActionStatus = kASShowMagazineToGoggleGuy; + playGnapShowItem(_grabCursorSpriteIndex, 2, 0); + } else if (_grabCursorSpriteIndex >= 0) { + playGnapShowCurrItem(3, 7, 2, 0); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapScratchingHead(1, 6); + break; + case GRAB_CURSOR: + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + case TALK_CURSOR: + _gnapIdleFacing = 5; + gnapWalkTo(3, 7, 0, getGnapSequenceId(gskBrainPulsating, 0, 0) | 0x10000, 1); + _gnapActionStatus = kASTalkGoggleGuy; + break; + } + } + } + break; + + case kHSHookGuy: + if (_gnapActionStatus < 0) { + _gnapIdleFacing = 7; + if (_grabCursorSpriteIndex >= 0) { + gnapWalkTo(5, 6, 0, 0x107BC, 9); + _gnapActionStatus = kASShowItemToHookGuy; + playGnapShowItem(_grabCursorSpriteIndex, 4, 0); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapSequence(getGnapSequenceId(gskDeflect, 3, 6) | 0x10000); + break; + case GRAB_CURSOR: + gnapWalkTo(5, 6, 0, 0x107BC, 1); + _gnapActionStatus = kASGrabHookGuy; + break; + case TALK_CURSOR: + _gnapIdleFacing = 3; + gnapWalkTo(5, 6, 0, getGnapSequenceId(gskBrainPulsating, 0, 0) | 0x10000, 1); + _gnapActionStatus = kASTalkHookGuy; + break; + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + } + break; + + case kHSBillard: + if (_gnapActionStatus < 0) { + if (_grabCursorSpriteIndex >= 0) { + playGnapImpossible(9, 8); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapScratchingHead(9, 8); + break; + case GRAB_CURSOR: + gnapWalkTo(9, 8, 0, 0x107BA, 1); + _gnapActionStatus = kASGrabBillardBall; + break; + case TALK_CURSOR: + case PLAT_CURSOR: + playGnapImpossible(9, 8); + break; + } + } + } + break; + + case kHSWalkArea1: + case kHSWalkArea2: + case kHSWalkArea3: + case kHSWalkArea4: + case kHSWalkArea5: + if (_gnapActionStatus < 0) + gnapWalkTo(-1, -1, -1, -1, 1); + break; + + case kHSDevice: + if (_gnapActionStatus < 0) { + runMenu(); + scene11_updateHotspots(); + } + break; + + default: + if (_mouseClickState.left && _gnapActionStatus < 0) { + gnapWalkTo(-1, -1, -1, -1, 1); + _mouseClickState.left = false; + } + break; + + } + + scene11_updateAnimations(); + + if (!_isLeavingScene) { + if (flag && !_timers[7]) { + flag = false; + _gameSys->setAnimation(0x207, 257, 4); + _gameSys->insertSequence(0x207, 257, 0, 0, kSeqNone, 0, 0, 0); + } + beaverSub426234(); + updateGnapIdleSequence2(); + if (!_timers[5]) { + _timers[5] = getRandom(100) + 75; + if (_gnapActionStatus < 0 && _beaverActionStatus < 0 && _s11_nextGoggleGuySequenceId == -1) { + _gnapRandomValue = getRandom(2); + if (_gnapRandomValue) + _s11_nextGoggleGuySequenceId = 0x1F6; + else + _s11_nextGoggleGuySequenceId = 0x1F9; + } + } + if (!_timers[4]) { + _timers[4] = getRandom(40) + 20; + if (_gnapActionStatus < 0 && _beaverActionStatus < 0 && _s11_nextHookGuySequenceId == -1) { + if (_s11_currHookGuySequenceId == 0x201) { + _gnapRandomValue = getRandom(7); + switch (_gnapRandomValue) { + case 0: + _s11_nextHookGuySequenceId = 0x200; + break; + case 1: + _s11_nextHookGuySequenceId = 0x205; + break; + case 2: + _s11_nextHookGuySequenceId = 0x202; + break; + default: + _s11_nextHookGuySequenceId = 0x201; + break; + } + } else { + _s11_nextHookGuySequenceId = 0x201; + } + } + } + if (!_timers[6]) { + _timers[6] = getRandom(100) + 100; + _gnapRandomValue = getRandom(3); + switch (_gnapRandomValue) { + case 0: + _gameSys->insertSequence(0x8A5 | 0x10000, 179, 0, 0, kSeqNone, 0, 0, 0); + break; + case 1: + _gameSys->insertSequence(0x8A7 | 0x10000, 179, 0, 0, kSeqNone, 0, 0, 0); + break; + case 2: + _gameSys->insertSequence(0x8A6 | 0x10000, 179, 0, 0, kSeqNone, 0, 0, 0); + break; + } + } + } + + checkGameKeys(); + + if (isKeyStatus1(8)) { + clearKeyStatus1(8); + runMenu(); + scene11_updateHotspots(); + _timers[5] = getRandom(50) + 75; + _timers[4] = getRandom(40) + 20; + } + + gameUpdateTick(); + + } + +} + +void GnapEngine::scene11_updateAnimations() { + + if (_gameSys->getAnimationStatus(0) == 2) { + if (_gnapActionStatus != kASGrabBillardBall) + _gameSys->setAnimation(0, 0, 0); + switch (_gnapActionStatus) { + case kASLeaveScene: + _sceneDone = true; + break; + case kASShowMagazineToGoggleGuy: + _s11_nextGoggleGuySequenceId = 0x1F7; + break; + case kASTalkGoggleGuy: + _s11_nextGoggleGuySequenceId = 0x1FB; + break; + case kASGrabHookGuy: + _s11_nextHookGuySequenceId = 0x204; + break; + case kASShowItemToHookGuy: + _s11_nextHookGuySequenceId = 0x203; + break; + case kASTalkHookGuy: + _s11_nextHookGuySequenceId = 0x206; + break; + case kASGrabBillardBall: + if (_gameSys->getAnimationStatus(2) == 2 && _gameSys->getAnimationStatus(3) == 2) { + _gameSys->setAnimation(0, 0, 0); + _timers[2] = getRandom(30) + 20; + _timers[3] = getRandom(50) + 200; + _gameSys->insertSequence(0x1F4, 255, makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, kSeqSyncWait, 0, 0, 0); + _gnapSequenceId = 0x1F4; + _gnapId = 255; + _gnapSequenceDatNum = 0; + _gameSys->removeSequence(0x207, 257, 1); + _gameSys->removeSequence(0x208, 256, 1); + _s11_nextGoggleGuySequenceId = 0x1F8; + _timers[5] = getRandom(100) + 75; + _gameSys->insertSequence(_s11_nextGoggleGuySequenceId, 121, _s11_currGoggleGuySequenceId, 121, kSeqSyncWait, 0, 0, 0); + _gameSys->setAnimation(_s11_nextGoggleGuySequenceId, 121, 2); + _s11_currGoggleGuySequenceId = _s11_nextGoggleGuySequenceId; + _s11_nextGoggleGuySequenceId = -1; + switch (_s11_billardBallCtr) { + case 0: + _s11_nextHookGuySequenceId = 0x1FC; + break; + case 1: + _s11_nextHookGuySequenceId = 0x1FD; + break; + default: + _s11_nextHookGuySequenceId = 0x1FE; + break; + } + ++_s11_billardBallCtr; + _gameSys->insertSequence(_s11_nextHookGuySequenceId, 120, _s11_currHookGuySequenceId, 120, kSeqSyncWait, 0, 0, 0); + _gameSys->setAnimation(_s11_nextHookGuySequenceId, 120, 3); + _s11_currHookGuySequenceId = _s11_nextHookGuySequenceId; + _s11_nextHookGuySequenceId = -1; + _timers[4] = getRandom(40) + 20; + _gameSys->insertSequence(0x208, 256, 0, 0, kSeqNone, getSequenceTotalDuration(0x1F4) - 5, 0, 0); + _hotspots[kHSBillard].flags |= SF_DISABLED; + _gameSys->setAnimation(0x207, 257, 4); + _gameSys->insertSequence(0x207, 257, 0, 0, kSeqNone, getSequenceTotalDuration(0x1FE), 0, 0); + _gnapActionStatus = -1; + } + break; + } + } + + if (_gameSys->getAnimationStatus(2) == 2 && _s11_nextGoggleGuySequenceId != -1) { + _timers[5] = getRandom(100) + 75; + _gameSys->insertSequence(_s11_nextGoggleGuySequenceId, 121, _s11_currGoggleGuySequenceId, 121, kSeqSyncWait, 0, 0, 0); + _gameSys->setAnimation(_s11_nextGoggleGuySequenceId, 121, 2); + _s11_currGoggleGuySequenceId = _s11_nextGoggleGuySequenceId; + _s11_nextGoggleGuySequenceId = -1; + if (_gnapActionStatus >= 1 && _gnapActionStatus <= 4) + _gnapActionStatus = -1; + } + + if (_gameSys->getAnimationStatus(3) == 2) { + if (_s11_nextHookGuySequenceId == 0x204) { + _gameSys->setAnimation(_s11_nextHookGuySequenceId, 120, 3); + _gameSys->insertSequence(0x204, 120, _s11_currHookGuySequenceId, 120, kSeqSyncWait, 0, 0, 0); + _gameSys->insertSequence(0x1F5, _gnapId, makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, kSeqSyncWait, 0, 0, 0); + _s11_currHookGuySequenceId = 0x204; + _s11_nextHookGuySequenceId = -1; + _gnapSequenceId = 0x1F5; + _gnapSequenceDatNum = 0; + _timers[4] = getRandom(40) + 20; + _timers[2] = getRandom(20) + 70; + _timers[3] = getRandom(50) + 200; + if (_gnapActionStatus == kASGrabHookGuy) + _gnapActionStatus = -1; + } else if (_s11_nextHookGuySequenceId != -1) { + _gameSys->insertSequence(_s11_nextHookGuySequenceId, 120, _s11_currHookGuySequenceId, 120, kSeqSyncWait, 0, 0, 0); + _gameSys->setAnimation(_s11_nextHookGuySequenceId, 120, 3); + _s11_currHookGuySequenceId = _s11_nextHookGuySequenceId; + _s11_nextHookGuySequenceId = -1; + _timers[4] = getRandom(40) + 20; + if (_gnapActionStatus >= 6 && _gnapActionStatus <= 9) + _gnapActionStatus = -1; + } + } + + if (_gameSys->getAnimationStatus(4) == 2) { + _gameSys->setAnimation(0, 0, 4); + _hotspots[kHSBillard].flags &= ~SF_DISABLED; + } + +} + +} // End of namespace Gnap diff --git a/engines/gnap/scenes/scene12.cpp b/engines/gnap/scenes/scene12.cpp new file mode 100644 index 0000000000..076fa0408d --- /dev/null +++ b/engines/gnap/scenes/scene12.cpp @@ -0,0 +1,564 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "gnap/gnap.h" +#include "gnap/gamesys.h" +#include "gnap/resource.h" + +namespace Gnap { + +enum { + kHSPlatypus = 0, + kHSExitRight = 1, + kHSToothGuy = 2, + kHSBarkeeper = 3, + kHSBeardGuy = 4, + kHSJukebox = 5, + kHSWalkArea1 = 6, + kHSDevice = 7, + kHSWalkArea2 = 8, + kHSWalkArea3 = 9, + kHSWalkArea4 = 10 +}; + +enum { + kASLeaveScene = 0, + kASQuarterToToothGuyDone = 1, + kASTalkToothGuy = 2, + kASGrabToothGuy = 4, + kASShowItemToToothGuy = 5, + kASQuarterWithHoleToToothGuy = 6, + kASQuarterToToothGuy = 7, + kASTalkBeardGuy = 8, + kASLookBeardGuy = 9, + kASGrabBeardGuy = 10, + kASShowItemToBeardGuy = 11, + kASTalkBarkeeper = 12, + kASLookBarkeeper = 13, + kASShowItemToBarkeeper = 15, + kASQuarterWithBarkeeper = 16, + kASPlatWithBarkeeper = 17, + kASPlatWithToothGuy = 18, + kASPlatWithBeardGuy = 19 +}; + +int GnapEngine::scene12_init() { + return 0x209; +} + +void GnapEngine::scene12_updateHotspots() { + setHotspot(kHSPlatypus, 0, 0, 0, 0, SF_WALKABLE | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSExitRight, 790, 360, 799, 599, SF_EXIT_R_CURSOR); + setHotspot(kHSToothGuy, 80, 180, 160, 380, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSBarkeeper, 490, 175, 580, 238, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSBeardGuy, 620, 215, 720, 350, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSJukebox, 300, 170, 410, 355, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSWalkArea1, 0, 0, 260, 460); + setHotspot(kHSWalkArea2, 0, 0, 380, 410); + setHotspot(kHSWalkArea3, 0, 0, 799, 395); + setHotspot(kHSWalkArea4, 585, 0, 799, 455); + setDeviceHotspot(kHSDevice, -1, -1, -1, -1); + _hotspotsCount = 11; +} + +void GnapEngine::scene12_run() { + int v18 = 1; + + queueInsertDeviceIcon(); + + _gameSys->insertSequence(0x207, 256, 0, 0, kSeqNone, 0, 0, 0); + _gameSys->insertSequence(0x200, 50, 0, 0, kSeqNone, 0, 0, 0); + + _s12_currToothGuySequenceId = 0x200; + _s12_nextToothGuySequenceId = -1; + + _gameSys->setAnimation(0x200, 50, 2); + _gameSys->insertSequence(0x202, 50, 0, 0, kSeqNone, 0, 0, 0); + + _s12_currBeardGuySequenceId = 0x202; + _s12_nextBeardGuySequenceId = -1; + + _gameSys->setAnimation(0x202, 50, 4); + _gameSys->insertSequence(0x203, 50, 0, 0, kSeqNone, 0, 0, 0); + + _s12_currBarkeeperSequenceId = 0x203; + _s12_nextBarkeeperSequenceId = -1; + + _gameSys->setAnimation(0x203, 50, 3); + + _timers[4] = 30; + _timers[6] = getRandom(30) + 20; + _timers[5] = getRandom(30) + 20; + _timers[7] = getRandom(100) + 100; + + if (_prevSceneNum == 15) { + initGnapPos(5, 6, 1); + initBeaverPos(3, 7, 0); + endSceneInit(); + } else { + initGnapPos(11, 8, 3); + initBeaverPos(12, 8, 4); + endSceneInit(); + gnapWalkTo(8, 8, -1, 0x107BA, 1); + platypusWalkTo(9, 8, -1, 0x107D2, 1); + } + + while (!_sceneDone) { + + testWalk(0, 0, -1, -1, -1, -1); + + updateMouseCursor(); + updateCursorByHotspot(); + updateGrabCursorSprite(0, 0); + + _sceneClickedHotspot = getClickedHotspotId(); + updateGrabCursorSprite(0, 0); + + switch (_sceneClickedHotspot) { + + case kHSDevice: + if (_gnapActionStatus < 0) { + runMenu(); + scene12_updateHotspots(); + } + break; + + case kHSPlatypus: + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapMoan1(_platX, _platY); + break; + case GRAB_CURSOR: + gnapKissPlatypus(0); + break; + case TALK_CURSOR: + playGnapBrainPulsating(_platX, _platY); + playBeaverSequence(getBeaverSequenceId(0, 0, 0) | 0x10000); + break; + case PLAT_CURSOR: + break; + } + break; + + case kHSExitRight: + _isLeavingScene = 1; + gnapWalkTo(10, -1, 0, 0x107AB, 1); + _gnapActionStatus = kASLeaveScene; + platypusWalkTo(10, -1, -1, -1, 1); + _newSceneNum = 11; + break; + + case kHSToothGuy: + if (_grabCursorSpriteIndex == kItemQuarter) { + _largeSprite = _gameSys->createSurface(0x141); + gnapWalkTo(3, 7, 0, 0x107BC, 9); + _gnapIdleFacing = 5; + _gnapActionStatus = kASQuarterToToothGuy; + playGnapShowItem(_grabCursorSpriteIndex, 2, 0); + setGrabCursorSprite(-1); + } else if (_grabCursorSpriteIndex == kItemQuarterWithHole) { + gnapWalkTo(3, 7, 0, 0x107BC, 9); + _gnapIdleFacing = 5; + _gnapActionStatus = kASQuarterWithHoleToToothGuy; + playGnapShowItem(_grabCursorSpriteIndex, 2, 0); + } else if (_grabCursorSpriteIndex >= 0) { + gnapWalkTo(3, 7, 0, 0x107BC, 9); + _gnapIdleFacing = 5; + _gnapActionStatus = kASShowItemToToothGuy; + playGnapShowItem(_grabCursorSpriteIndex, 2, 0); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapScratchingHead(1, 2); + break; + case GRAB_CURSOR: + gnapWalkTo(3, 7, 0, 0x107BC, 1); + _gnapActionStatus = kASGrabToothGuy; + break; + case TALK_CURSOR: + _gnapIdleFacing = 5; + gnapWalkTo(3, 7, 0, getGnapSequenceId(gskBrainPulsating, 0, 0) | 0x10000, 1); + _gnapActionStatus = kASTalkToothGuy; + break; + case PLAT_CURSOR: + gnapUseDeviceOnBeaver(); + platypusWalkTo(3, 7, 1, 0x107D2, 1); + _beaverActionStatus = kASPlatWithToothGuy; + _beaverFacing = 4; + playGnapIdle(2, 7); + break; + } + } + break; + + case kHSBarkeeper: + if (_grabCursorSpriteIndex == kItemQuarter || _grabCursorSpriteIndex == kItemQuarterWithHole) { + gnapWalkTo(6, 6, 0, 0x107BB, 9); + _gnapIdleFacing = 7; + _gnapActionStatus = kASQuarterWithBarkeeper; + playGnapShowItem(_grabCursorSpriteIndex, 7, 0); + } else if (_grabCursorSpriteIndex >= 0) { + gnapWalkTo(6, 6, 0, 0x107BB, 9); + _gnapIdleFacing = 7; + _gnapActionStatus = kASShowItemToBarkeeper; + playGnapShowItem(_grabCursorSpriteIndex, 7, 0); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + gnapWalkTo(6, 6, 0, 0x107BB, 1); + _gnapIdleFacing = 7; + _gnapActionStatus = kASLookBarkeeper; + break; + case GRAB_CURSOR: + playGnapImpossible(0, 0); + break; + case TALK_CURSOR: + _gnapIdleFacing = 7; + gnapWalkTo(6, 6, 0, getGnapSequenceId(gskBrainPulsating, 0, 0) | 0x10000, 1); + _gnapActionStatus = kASTalkBarkeeper; + break; + case PLAT_CURSOR: + playGnapPullOutDevice(_platX, _platY); + _gameSys->setAnimation(makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, 0); + _gnapActionStatus = kASPlatWithBarkeeper; + break; + } + } + break; + + case kHSBeardGuy: + if (_grabCursorSpriteIndex >= 0) { + gnapWalkTo(7, 6, 0, 0x107BB, 9); + _gnapIdleFacing = 7; + _gnapActionStatus = kASShowItemToBeardGuy; + playGnapShowItem(_grabCursorSpriteIndex, 8, 0); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + gnapWalkTo(7, 6, 0, 0x107BB, 1); + _gnapIdleFacing = 7; + _gnapActionStatus = kASLookBeardGuy; + break; + case GRAB_CURSOR: + // NOTE Bug in the original. It has 9 as flags which seems wrong here. + gnapWalkTo(7, 6, 0, 0x107BB, 1); + _gnapIdleFacing = 7; + _gnapActionStatus = kASGrabBeardGuy; + break; + case TALK_CURSOR: + _gnapIdleFacing = 7; + gnapWalkTo(7, 6, 0, getGnapSequenceId(gskBrainPulsating, 0, 0) | 0x10000, 1); + _gnapActionStatus = kASTalkBeardGuy; + break; + case PLAT_CURSOR: + gnapUseDeviceOnBeaver(); + platypusWalkTo(7, 6, 1, 0x107C2, 1); + _beaverActionStatus = kASPlatWithBeardGuy; + _beaverFacing = 0; + playGnapIdle(7, 6); + break; + } + } + break; + + case kHSJukebox: + _newSceneNum = 15; + _isLeavingScene = 1; + gnapWalkTo(5, 6, 0, 0x107BC, 1); + _gnapActionStatus = kASLeaveScene; + break; + + case kHSWalkArea1: + case kHSWalkArea2: + case kHSWalkArea3: + case kHSWalkArea4: + if (_gnapActionStatus < 0) + gnapWalkTo(-1, -1, -1, -1, 1); + break; + + default: + if (_mouseClickState.left && _gnapActionStatus < 0) { + gnapWalkTo(-1, -1, -1, -1, 1); + _mouseClickState.left = false; + } + break; + + } + + scene12_updateAnimations(); + + if (!_isLeavingScene) { + updateBeaverIdleSequence(); + updateGnapIdleSequence(); + if (!_timers[4]) { + _timers[4] = 15; + if (_s12_nextToothGuySequenceId == -1) { + if (v18 == 0 && _s12_currBeardGuySequenceId == 0x202 && _s12_currBarkeeperSequenceId == 0x203 && _gnapActionStatus < 0 && _beaverActionStatus < 0) { + if (getRandom(2) != 0) + _s12_nextToothGuySequenceId = 0x1EC; + else + _s12_nextToothGuySequenceId = 0x204; + } else if (_s12_currToothGuySequenceId != 0x200) + _s12_nextToothGuySequenceId = 0x200; + v18 = (v18 + 1) % 15; + } + } + if (!_timers[5]) { + _timers[5] = getRandom(30) + 20; + if (_s12_nextBarkeeperSequenceId == -1 && _gnapActionStatus < 0 && _beaverActionStatus < 0) { + if (v18 == 0 && _s12_currToothGuySequenceId == 0x200 && _s12_currBeardGuySequenceId == 0x202 && _gnapActionStatus < 0 && _beaverActionStatus < 0) { + if (getRandom(2) != 0) + _s12_nextBarkeeperSequenceId = 0x208; + else + _s12_nextBarkeeperSequenceId = 0x1FB; + } else + _s12_nextBarkeeperSequenceId = 0x203; + v18 = (v18 + 1) % 15; + } + } + if (!_timers[6]) { + _timers[6] = getRandom(30) + 15; + if (_s12_nextBeardGuySequenceId == -1 && _gnapActionStatus < 0 && _beaverActionStatus < 0) { + if (v18 == 0 && _s12_currToothGuySequenceId == 0x200 && _s12_currBarkeeperSequenceId == 0x203 && _gnapActionStatus < 0 && _beaverActionStatus < 0) + _s12_nextBeardGuySequenceId = 0x1F2; + else + _s12_nextBeardGuySequenceId = 0x202; + v18 = (v18 + 1) % 15; + } + } + if (!_timers[7]) { + _timers[7] = getRandom(100) + 100; + _gnapRandomValue = getRandom(3); + switch (_gnapRandomValue) { + case 0: + _gameSys->insertSequence(0x8A5 | 0x10000, 179, 0, 0, kSeqNone, 0, 0, 0); + break; + case 1: + _gameSys->insertSequence(0x8A7 | 0x10000, 179, 0, 0, kSeqNone, 0, 0, 0); + break; + case 2: + _gameSys->insertSequence(0x8A6 | 0x10000, 179, 0, 0, kSeqNone, 0, 0, 0); + break; + } + } + } + + checkGameKeys(); + + if (isKeyStatus1(8)) { + clearKeyStatus1(8); + runMenu(); + scene12_updateHotspots(); + _timers[4] = 30; + _timers[5] = getRandom(30) + 20; + _timers[6] = getRandom(30) + 20; + } + + gameUpdateTick(); + + } + +} + +void GnapEngine::scene12_updateAnimations() { + + if (_gameSys->getAnimationStatus(0) == 2) { + _gameSys->setAnimation(0, 0, 0); + switch (_gnapActionStatus) { + case kASLeaveScene: + _sceneDone = true; + break; + case kASTalkToothGuy: + if (isKeyStatus1(Common::KEYCODE_j)) { + // Easter egg + clearKeyStatus1(Common::KEYCODE_j); + _s12_nextToothGuySequenceId = 0x206; + } else { + _s12_nextToothGuySequenceId = 0x1EE; + } + break; + case 3: + break; + case kASGrabToothGuy: + if (isKeyStatus1(Common::KEYCODE_j)) { + clearKeyStatus1(Common::KEYCODE_j); + _s12_nextToothGuySequenceId = 0x206; + } else { + _s12_nextToothGuySequenceId = 0x1EF; + } + break; + case kASShowItemToToothGuy: + if (isKeyStatus1(Common::KEYCODE_j)) { + clearKeyStatus1(Common::KEYCODE_j); + _s12_nextToothGuySequenceId = 0x206; + } else { + _s12_nextToothGuySequenceId = 0x1ED; + } + break; + case kASQuarterWithHoleToToothGuy: + if (isKeyStatus1(Common::KEYCODE_j)) { + clearKeyStatus1(Common::KEYCODE_j); + _s12_nextToothGuySequenceId = 0x206; + } else { + _s12_nextToothGuySequenceId = 0x1EA; + } + break; + case kASQuarterToToothGuy: + if (isKeyStatus1(Common::KEYCODE_j)) { + clearKeyStatus1(Common::KEYCODE_j); + _s12_nextToothGuySequenceId = 0x206; + } else { + _s12_nextToothGuySequenceId = 0x1E9; + } + break; + case kASQuarterToToothGuyDone: + _gnapActionStatus = -1; + showCursor(); + _gameSys->removeSpriteDrawItem(_largeSprite, 300); + deleteSurface(&_largeSprite); + setGrabCursorSprite(kItemQuarterWithHole); + break; + case kASTalkBeardGuy: + _s12_nextBeardGuySequenceId = 0x1F4; + break; + case kASLookBeardGuy: + _s12_nextBeardGuySequenceId = 0x1F3; + break; + case kASGrabBeardGuy: + _s12_nextBeardGuySequenceId = 0x1F1; + break; + case kASShowItemToBeardGuy: + _s12_nextBeardGuySequenceId = 0x1F0; + break; + case kASTalkBarkeeper: + _gnapRandomValue = getRandom(2); + if (_gnapRandomValue != 0) + _s12_nextBarkeeperSequenceId = 0x1FD; + else + _s12_nextBarkeeperSequenceId = 0x1FF; + break; + case kASLookBarkeeper: + _s12_nextBarkeeperSequenceId = 0x1F8; + break; + case 14: + _s12_nextBarkeeperSequenceId = 0x1F6; + break; + case kASShowItemToBarkeeper: + _s12_nextBarkeeperSequenceId = 0x1F5; + break; + case kASQuarterWithBarkeeper: + _s12_nextBarkeeperSequenceId = 0x1FA; + break; + case kASPlatWithBarkeeper: + _s12_nextBarkeeperSequenceId = 0x1F9; + break; + } + } + + if (_gameSys->getAnimationStatus(1) == 2) { + _gameSys->setAnimation(0, 0, 1); + switch (_beaverActionStatus) { + case kASPlatWithToothGuy: + _s12_nextToothGuySequenceId = 0x1EB; + break; + case kASPlatWithBeardGuy: + _s12_nextBeardGuySequenceId = 0x1F3; + break; + } + } + + if (_gameSys->getAnimationStatus(2) == 2) { + if (_s12_currToothGuySequenceId == 0x1E9) { + _gameSys->setAnimation(0, 0, 2); + hideCursor(); + _gameSys->setAnimation(0x10843, 301, 0); + _gnapActionStatus = kASQuarterToToothGuyDone; + _gameSys->insertSpriteDrawItem(_largeSprite, 0, 0, 300); + _gameSys->insertSequence(0x10843, 301, makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, kSeqSyncWait, 0, 0, 0); + _gameSys->insertSequence(0x107B7, _gnapId, 0x10843, 301, + kSeqSyncWait, 0, 75 * _gnapX - _gnapGridX, 48 * _gnapY - _gnapGridY); + _gnapSequenceId = 0x7B7; + _gnapSequenceDatNum = 1; + setFlag(3); + invAdd(kItemQuarterWithHole); + invRemove(kItemQuarter); + } + if (_s12_nextToothGuySequenceId == 0x1EF) { + _gameSys->setAnimation(_s12_nextToothGuySequenceId, 50, 2); + _gameSys->insertSequence(_s12_nextToothGuySequenceId, 50, _s12_currToothGuySequenceId, 50, kSeqSyncWait, 0, 0, 0); + _gameSys->insertSequence(0x205, _gnapId, makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, kSeqSyncWait, 0, 0, 0); + _s12_currToothGuySequenceId = _s12_nextToothGuySequenceId; + _s12_nextToothGuySequenceId = -1; + _gnapSequenceId = 0x205; + _gnapSequenceDatNum = 0; + _timers[4] = 40; + _timers[2] = getRandom(20) + 70; + _timers[3] = getRandom(50) + 200; + if (_gnapActionStatus == kASGrabToothGuy) + _gnapActionStatus = -1; + } else if (_s12_nextToothGuySequenceId != -1) { + _gameSys->insertSequence(_s12_nextToothGuySequenceId, 50, _s12_currToothGuySequenceId, 50, kSeqSyncWait, 0, 0, 0); + _gameSys->setAnimation(_s12_nextToothGuySequenceId, 50, 2); + _s12_currToothGuySequenceId = _s12_nextToothGuySequenceId; + _s12_nextToothGuySequenceId = -1; + _timers[4] = 50; + if (_gnapActionStatus >= kASTalkToothGuy && _gnapActionStatus <= kASQuarterToToothGuy && _s12_currToothGuySequenceId != 0x1E9 && + _s12_currToothGuySequenceId != 0x1EC && _s12_currToothGuySequenceId != 0x200) + _gnapActionStatus = -1; + if (_beaverActionStatus == kASPlatWithToothGuy) + _beaverActionStatus = -1; + } + } + + if (_gameSys->getAnimationStatus(3) == 2) { + if (_gnapActionStatus == kASPlatWithBarkeeper && _s12_currBarkeeperSequenceId == 0x1F9) { + _gnapActionStatus = -1; + playGnapIdle(7, 6); + _timers[5] = 0; + } + if (_s12_nextBarkeeperSequenceId != -1) { + _gameSys->insertSequence(_s12_nextBarkeeperSequenceId, 50, _s12_currBarkeeperSequenceId, 50, kSeqSyncWait, 0, 0, 0); + _gameSys->setAnimation(_s12_nextBarkeeperSequenceId, 50, 3); + _s12_currBarkeeperSequenceId = _s12_nextBarkeeperSequenceId; + _s12_nextBarkeeperSequenceId = -1; + _timers[5] = getRandom(30) + 20; + if (_gnapActionStatus >= kASTalkBarkeeper && _gnapActionStatus <= kASQuarterWithBarkeeper && _s12_currBarkeeperSequenceId != 0x203 && + _s12_currBarkeeperSequenceId != 0x1FB && _s12_currBarkeeperSequenceId != 0x208) + _gnapActionStatus = -1; + } + } + + if (_gameSys->getAnimationStatus(4) == 2 && _s12_nextBeardGuySequenceId != -1) { + _gameSys->insertSequence(_s12_nextBeardGuySequenceId, 50, _s12_currBeardGuySequenceId, 50, kSeqSyncWait, 0, 0, 0); + _gameSys->setAnimation(_s12_nextBeardGuySequenceId, 50, 4); + _s12_currBeardGuySequenceId = _s12_nextBeardGuySequenceId; + _s12_nextBeardGuySequenceId = -1; + _timers[6] = getRandom(30) + 20; + if (_gnapActionStatus >= kASTalkBeardGuy && _gnapActionStatus <= kASShowItemToBeardGuy && _s12_currBeardGuySequenceId != 0x202 && _s12_currBeardGuySequenceId != 0x1F2) + _gnapActionStatus = -1; + if (_beaverActionStatus == kASPlatWithBeardGuy) + _beaverActionStatus = -1; + } + +} + +} // End of namespace Gnap diff --git a/engines/gnap/scenes/scene13.cpp b/engines/gnap/scenes/scene13.cpp new file mode 100644 index 0000000000..c9b4d53917 --- /dev/null +++ b/engines/gnap/scenes/scene13.cpp @@ -0,0 +1,455 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "gnap/gnap.h" +#include "gnap/gamesys.h" +#include "gnap/resource.h" + +namespace Gnap { + +enum { + kHSPlatypus = 0, + kHSExitBar = 1, + kHSWalkArea1 = 2, + kHSBackToilet = 3, + kHSFrontToilet = 4, + kHSUrinal = 5, + kHSScribble = 6, + kHSSink = 7, + kHSWalkArea2 = 8, + kHSDevice = 9, + kHSWalkArea3 = 10, + kHSWalkArea4 = 11, + kHSWalkArea5 = 12, + kHSWalkArea6 = 13, + kHSWalkArea7 = 14, + kHSWalkArea8 = 15, + kHSWalkArea9 = 16 +}; + +enum { + kASLeaveScene = 0, + kASBackToilet = 1, + kASFrontToilet = 2, + kASLookScribble = 6, + kASGrabSink = 7, + kASGrabSinkDone = 8, + kASWait = 12, + kASGrabUrinal = 13 +}; + +int GnapEngine::scene13_init() { + playSound(0x108EC, 0); + return 0xAC; +} + +void GnapEngine::scene13_updateHotspots() { + setHotspot(kHSPlatypus, 0, 0, 0, 0, SF_WALKABLE | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSExitBar, 113, 160, 170, 455, SF_EXIT_L_CURSOR); + setHotspot(kHSBackToilet, 385, 195, 478, 367, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSFrontToilet, 497, 182, 545, 432, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSUrinal, 680, 265, 760, 445, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSScribble, 560, 270, 660, 370, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSSink, 310, 520, 560, 599, SF_WALKABLE | SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSWalkArea1, 268, 270, 325, 385); + setHotspot(kHSWalkArea2, 0, 0, 52, 599); + setHotspot(kHSWalkArea3, 0, 0, 113, 550); + setHotspot(kHSWalkArea4, 0, 0, 226, 438); + setHotspot(kHSWalkArea5, 0, 0, 268, 400); + setHotspot(kHSWalkArea6, 0, 0, 799, 367); + setHotspot(kHSWalkArea7, 478, 0, 799, 401); + setHotspot(kHSWalkArea8, 545, 0, 799, 473); + setHotspot(kHSWalkArea9, 0, 549, 799, 599); + setDeviceHotspot(kHSDevice, -1, -1, -1, -1); + _hotspotsCount = 17; +} + +void GnapEngine::scene13_showScribble() { + hideCursor(); + _largeSprite = _gameSys->createSurface(0x6F); + _gameSys->insertSpriteDrawItem(_largeSprite, 0, 0, 300); + while (!_mouseClickState.left && !isKeyStatus1(Common::KEYCODE_ESCAPE) && + !isKeyStatus1(Common::KEYCODE_SPACE) && !isKeyStatus1(29)) + gameUpdateTick(); + _mouseClickState.left = false; + clearKeyStatus1(Common::KEYCODE_ESCAPE); + clearKeyStatus1(29); + clearKeyStatus1(Common::KEYCODE_SPACE); + _gameSys->removeSpriteDrawItem(_largeSprite, 300); + deleteSurface(&_largeSprite); + showCursor(); +} + +void GnapEngine::scene13_run() { + int currSoundId = 0; + + queueInsertDeviceIcon(); + + _gameSys->insertSequence(0xAA, 256, 0, 0, kSeqNone, 0, 0, 0); + + if (_prevSceneNum == 14) { + initGnapPos(6, 6, 3); + initBeaverPos(9, 8, 0); + } else { + initGnapPos(3, 7, 1); + initBeaverPos(2, 7, 0); + } + + endSceneInit(); + + _timers[4] = getRandom(20) + 20; + _timers[5] = getRandom(50) + 50; + + while (!_sceneDone) { + + if (!isSoundPlaying(0x1091A)) + playSound(0x1091A, 1); + + testWalk(0, 0, -1, -1, -1, -1); + + updateMouseCursor(); + updateCursorByHotspot(); + + _sceneClickedHotspot = getClickedHotspotId(); + updateGrabCursorSprite(0, 0); + + switch (_sceneClickedHotspot) { + + case kHSDevice: + if (_gnapActionStatus < 0) { + runMenu(); + scene13_updateHotspots(); + _timers[4] = getRandom(20) + 20; + _timers[5] = getRandom(50) + 50; + } + break; + + case kHSPlatypus: + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapMoan1(_platX, _platY); + break; + case GRAB_CURSOR: + gnapKissPlatypus(0); + break; + case TALK_CURSOR: + playGnapBrainPulsating(_platX, _platY); + playBeaverSequence(getBeaverSequenceId(0, 0, 0)); + break; + case PLAT_CURSOR: + break; + } + break; + + case kHSExitBar: + _isLeavingScene = 1; + gnapWalkTo(2, 7, 0, 0x107C0, 1); + _gnapActionStatus = kASLeaveScene; + platypusWalkTo(2, 8, -1, -1, 1); + if (isFlag(14) || isFlag(15)) { + _newSceneNum = 11; + } else { + setFlag(15); + _newSceneNum = 47; + } + break; + + case kHSBackToilet: + if (_grabCursorSpriteIndex >= 0) { + playGnapShowCurrItem(5, 5, 6, 0); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + case GRAB_CURSOR: + case TALK_CURSOR: + if (_gnapX == 5 && _gnapY == 5) { + _s13_backToiletCtr = MIN(5, _s13_backToiletCtr + 1); + _gameSys->setAnimation(_s13_backToiletCtr + 0xA3, _gnapId, 0); + _gameSys->insertSequence(_s13_backToiletCtr + 0xA3, _gnapId, + makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, + 9, 0, 0, 0); + _gnapActionStatus = kASWait; + _gnapSequenceId = _s13_backToiletCtr + 0xA3; + _gnapIdleFacing = 7; + _gnapSequenceDatNum = 0; + } else { + gnapWalkTo(5, 5, 0, 0x107BB, 1); + _gnapActionStatus = kASBackToilet; + _gnapIdleFacing = 7; + } + break; + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + break; + + case kHSFrontToilet: + if (_grabCursorSpriteIndex >= 0) { + playGnapShowCurrItem(6, 7, 7, 0); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + case GRAB_CURSOR: + case TALK_CURSOR: + case PLAT_CURSOR: + gnapWalkTo(6, 7, 0, 0xA9, 5); + _gnapActionStatus = kASFrontToilet; + _gnapIdleFacing = 1; + break; + } + } + break; + + case kHSScribble: + if (_grabCursorSpriteIndex >= 0) { + playGnapShowCurrItem(7, 7, 8, 0); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + gnapWalkTo(7, 7, 0, 0x107BB, 1); + _gnapActionStatus = kASLookScribble; + _gnapIdleFacing = 7; + break; + case GRAB_CURSOR: + playGnapScratchingHead(0, 0); + break; + case TALK_CURSOR: + _gnapIdleFacing = 7; + gnapWalkTo(7, 7, -1, getGnapSequenceId(gskBrainPulsating, 0, 0), 1); + break; + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + break; + + case kHSUrinal: + if (_grabCursorSpriteIndex >= 0) { + playGnapShowCurrItem(8, 7, 9, 0); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapSequence(getGnapSequenceId(gskDeflect, 9, 6)); + gnapWalkTo(_gnapX, _gnapY, 0, -1, 1); + _gnapActionStatus = kASWait; + break; + case GRAB_CURSOR: + gnapWalkTo(8, 7, 0, -1, 1); + _gnapActionStatus = kASGrabUrinal; + break; + case TALK_CURSOR: + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + break; + + case kHSSink: + if (_grabCursorSpriteIndex >= 0) { + playGnapImpossible(0, 0); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapSequence(getGnapSequenceId(gskDeflect, 5, 9)); + gnapWalkTo(_gnapX, _gnapY, 0, -1, 1); + _gnapActionStatus = kASWait; + break; + case GRAB_CURSOR: + gnapWalkTo(4, 8, 0, 0x107B9, 1); + _gnapActionStatus = kASGrabSink; + break; + case TALK_CURSOR: + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + break; + + case kHSWalkArea2: + case kHSWalkArea3: + case kHSWalkArea4: + case kHSWalkArea5: + case kHSWalkArea6: + case kHSWalkArea7: + case kHSWalkArea8: + case kHSWalkArea9: + gnapWalkTo(-1, -1, -1, -1, 1); + break; + + case kHSWalkArea1: + // Nothing + break; + + default: + if (_mouseClickState.left) { + gnapWalkTo(-1, -1, -1, -1, 1); + _mouseClickState.left = false; + } + break; + + } + + scene13_updateAnimations(); + + if (!_isLeavingScene) { + updateBeaverIdleSequence(); + if (_platY == 5 || _platY == 6) + platypusWalkTo(-1, 7, -1, -1, 1); + if (_gnapActionStatus < 0) + updateGnapIdleSequence(); + if (!_timers[4]) { + _timers[4] = getRandom(20) + 20; + _gnapRandomValue = getRandom(5); + switch (_gnapRandomValue) { + case 0: + playSound(0xD2, 0); + break; + case 1: + playSound(0xD3, 0); + break; + case 2: + playSound(0xD4, 0); + break; + case 3: + playSound(0xD5, 0); + break; + case 4: + playSound(0xD6, 0); + break; + } + } + if (!_timers[5]) { + int newSoundId; + _timers[5] = getRandom(50) + 50; + _gnapRandomValue = getRandom(7); + switch (_gnapRandomValue) { + case 0: + newSoundId = 0xD7; + _timers[5] = 2 * getRandom(50) + 100; + break; + case 1: + case 2: + newSoundId = 0xCF; + break; + case 3: + case 4: + newSoundId = 0xD0; + break; + default: + newSoundId = 0xD1; + break; + } + if (newSoundId != currSoundId) { + playSound(newSoundId, 0); + currSoundId = newSoundId; + } + } + } + + checkGameKeys(); + + if (isKeyStatus1(8)) { + clearKeyStatus1(8); + runMenu(); + scene13_updateHotspots(); + _timers[4] = getRandom(20) + 20; + _timers[5] = getRandom(50) + 50; + } + + gameUpdateTick(); + + } + +} + +void GnapEngine::scene13_updateAnimations() { + + if (_gameSys->getAnimationStatus(0) == 2) { + _gameSys->setAnimation(0, 0, 0); + switch (_gnapActionStatus) { + case kASLeaveScene: + _sceneDone = true; + _gnapActionStatus = -1; + break; + case kASBackToilet: + _s13_backToiletCtr = MIN(5, _s13_backToiletCtr + 1); + _gameSys->insertSequence(_s13_backToiletCtr + 0xA3, _gnapId, makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, 9, 0, 0, 0); + _gnapSequenceId = _s13_backToiletCtr + 0xA3; + _gnapSequenceDatNum = 0; + _gnapActionStatus = -1; + break; + case kASFrontToilet: + _sceneDone = true; + _newSceneNum = 14; + break; + case kASLookScribble: + _gnapActionStatus = -1; + scene13_showScribble(); + break; + case kASGrabSink: + _gameSys->setAnimation(0xAB, 160, 0); + _gameSys->insertSequence(0xAB, 160, makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, kSeqSyncWait, 0, 0, 0); + _gameSys->removeSequence(0xAA, 256, 1); + _gnapSequenceId = 0xAB; + _gnapId = 160; + _gnapIdleFacing = 1; + _gnapSequenceDatNum = 0; + _gnapX = 4; + _gnapY = 8; + _timers[2] = 360; + _gnapActionStatus = kASGrabSinkDone; + break; + case kASGrabSinkDone: + _gameSys->insertSequence(0xAA, 256, 0, 0, kSeqNone, 0, 0, 0); + _gnapActionStatus = -1; + break; + case kASWait: + _gnapActionStatus = -1; + break; + case kASGrabUrinal: + _gameSys->setAnimation(0xA2, 120, 0); + _gameSys->insertSequence(0xA2, 120, makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, kSeqSyncWait, 0, 0, 0); + _gnapSequenceId = 0xA2; + _gnapId = 120; + _gnapIdleFacing = 3; + _gnapSequenceDatNum = 0; + _gnapX = 4; + _gnapY = 6; + _timers[2] = 360; + _gnapActionStatus = kASWait; + break; + } + } + + if (_gameSys->getAnimationStatus(1) == 2) { + _gameSys->setAnimation(0, 0, 1); + _beaverActionStatus = -1; + } + +} + +} // End of namespace Gnap diff --git a/engines/gnap/scenes/scene14.cpp b/engines/gnap/scenes/scene14.cpp new file mode 100644 index 0000000000..4f799db977 --- /dev/null +++ b/engines/gnap/scenes/scene14.cpp @@ -0,0 +1,194 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "gnap/gnap.h" +#include "gnap/gamesys.h" +#include "gnap/resource.h" + +namespace Gnap { + +enum { + kHSPlatypus = 0, + kHSExit = 1, + kHSCoin = 2, + kHSToilet = 3, + kHSDevice = 4 +}; + +int GnapEngine::scene14_init() { + _gameSys->setAnimation(0, 0, 0); + _gameSys->setAnimation(0, 0, 1); + return 0x27; +} + +void GnapEngine::scene14_updateHotspots() { + setHotspot(kHSPlatypus, 0, 0, 0, 0); + setHotspot(kHSExit, 0, 590, 799, 599, SF_EXIT_D_CURSOR); + setHotspot(kHSCoin, 330, 390, 375, 440, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSToilet, 225, 250, 510, 500, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setDeviceHotspot(kHSDevice, -1, -1, -1, -1); + if (isFlag(2)) + _hotspots[kHSCoin].flags = SF_DISABLED; + _hotspotsCount = 5; +} + +void GnapEngine::scene14_run() { + + _largeSprite = 0; + + queueInsertDeviceIcon(); + + if (!isFlag(2)) + _gameSys->insertSequence(0x23, 10, 0, 0, kSeqNone, 0, 0, 0); + + endSceneInit(); + + if (!isFlag(2) && invHas(kItemTongs)) + _largeSprite = _gameSys->createSurface(1); + + if (!isFlag(2)) { + _gameSys->insertSequence(0x24, 10, 0x23, 10, kSeqSyncWait, 0, 0, 0); + _gnapSequenceId = 0x24; + _timers[2] = getRandom(40) + 50; + } + + while (!_sceneDone) { + + updateMouseCursor(); + updateCursorByHotspot(); + + _sceneClickedHotspot = getClickedHotspotId(); + updateGrabCursorSprite(0, 0); + + switch (_sceneClickedHotspot) { + + case kHSDevice: + if (_gnapActionStatus < 0) { + runMenu(); + scene14_updateHotspots(); + } + break; + + case kHSExit: + _sceneDone = true; + _newSceneNum = 13; + break; + + case kHSCoin: + if (_grabCursorSpriteIndex == kItemTongs) { + invAdd(kItemQuarter); + setFlag(2); + setGrabCursorSprite(-1); + hideCursor(); + _gameSys->setAnimation(0x26, 10, 0); + _gameSys->insertSequence(0x26, 10, _gnapSequenceId, 10, kSeqSyncWait, 0, 0, 0); + } else if (_grabCursorSpriteIndex >= 0) { + playSound(0x108E9, 0); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playSound(0x108E9, 0); + break; + case GRAB_CURSOR: + _gameSys->insertSequence(0x25, 10, _gnapSequenceId, 10, kSeqSyncWait, 0, 0, 0); + _gameSys->insertSequence(0x23, 10, 0x25, 10, kSeqSyncWait, 0, 0, 0); + _gnapSequenceId = 0x23; + break; + case TALK_CURSOR: + playSound((getRandom(5) + 0x8D5) | 0x10000, 0); + break; + case PLAT_CURSOR: + _gameSys->insertSequence(0x107A8, 1, 0, 0, kSeqNone, 0, 900 - _gnapGridX, 576 - _gnapGridY); + break; + } + } + break; + + case kHSToilet: + if (_grabCursorSpriteIndex >= 0) { + _gameSys->insertSequence(0x107A8, 1, 0, 0, kSeqNone, 0, 900 - _gnapGridX, 576 - _gnapGridY); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + case GRAB_CURSOR: + playSound(0x108B1, 0); + break; + case TALK_CURSOR: + playSound((getRandom(5) + 0x8D5) | 0x10000, 0); + break; + case PLAT_CURSOR: + _gameSys->insertSequence(0x107A8, 1, 0, 0, kSeqNone, 0, 900 - _gnapGridX, 576 - _gnapGridY); + break; + } + } + break; + + default: + _mouseClickState.left = false; + break; + + } + + scene14_updateAnimations(); + + checkGameKeys(); + + if (!isFlag(2) && !_timers[2]) { + _gameSys->insertSequence(0x24, 10, _gnapSequenceId, 10, kSeqSyncWait, 0, 0, 0); + _gnapSequenceId = 0x24; + _timers[2] = getRandom(40) + 50; + } + + if (isKeyStatus1(8)) { + clearKeyStatus1(8); + runMenu(); + scene14_updateHotspots(); + } + + gameUpdateTick(); + + } + + if (_largeSprite) + deleteSurface(&_largeSprite); + +} + +void GnapEngine::scene14_updateAnimations() { + + if (_gameSys->getAnimationStatus(0) == 2) { + _gameSys->setAnimation(0, 0, 0); + _gameSys->insertSpriteDrawItem(_largeSprite, 0, 0, 300); + _gameSys->setAnimation(0x10843, 301, 1); + _gameSys->insertSequence(0x10843, 301, 0x26, 10, kSeqSyncWait, 0, 0, 0); + } + + if (_gameSys->getAnimationStatus(1) == 2) { + _gameSys->setAnimation(0, 0, 1); + _sceneDone = true; + _newSceneNum = 13; + _grabCursorSpriteIndex = kItemQuarter; + } + +} + +} // End of namespace Gnap diff --git a/engines/gnap/scenes/scene15.cpp b/engines/gnap/scenes/scene15.cpp new file mode 100644 index 0000000000..54eb146fa5 --- /dev/null +++ b/engines/gnap/scenes/scene15.cpp @@ -0,0 +1,343 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "gnap/gnap.h" +#include "gnap/gamesys.h" +#include "gnap/resource.h" + +namespace Gnap { + +enum { + kHSPlatypus = 0, + kHSExit = 1, + kHSButton1 = 2, + kHSButton2 = 3, + kHSButton3 = 4, + kHSButton4 = 5, + kHSButton5 = 6, + kHSButton6 = 7, + kHSButtonA = 8, + kHSButtonB = 9, + kHSButtonC = 10, + kHSButtonD = 11, + kHSButtonE = 12, + kHSButtonF = 13, + kHSCoinSlot = 14, + kHSPlayButton = 15, + kHSDevice = 16 +}; + +int GnapEngine::scene15_init() { + return 0xDD; +} + +void GnapEngine::scene15_updateHotspots() { + setHotspot(kHSPlatypus, 0, 0, 0, 0, SF_DISABLED); + setHotspot(kHSExit, 50, 590, 750, 599, SF_EXIT_D_CURSOR); + setHotspot(kHSButton1, 210, 425, 260, 475, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSButton2, 280, 425, 325, 475, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSButton3, 340, 425, 385, 475, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSButton4, 400, 425, 445, 475, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSButton5, 460, 425, 510, 475, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSButton6, 520, 425, 560, 475, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSButtonA, 205, 480, 250, 535, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSButtonB, 270, 480, 320, 535, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSButtonC, 335, 480, 380, 535, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSButtonD, 395, 480, 445, 535, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSButtonE, 460, 480, 505, 535, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSButtonF, 515, 480, 560, 535, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSCoinSlot, 585, 475, 620, 535, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSPlayButton, 622, 431, 650, 482, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setDeviceHotspot(kHSDevice, -1, -1, -1, -1); + _hotspotsCount = 17; +} + +void GnapEngine::scene15_run() { + + _s15_currSlotSequenceId = -1; + _s15_currUpperButtonSequenceId = -1; + _s15_currLowerButtonSequenceId = -1; + _s15_nextSlotSequenceId = -1; + _s15_nextUpperButtonSequenceId = -1; + _s15_nextLowerButtonSequenceId = -1; + _s15_currRecordSequenceId = 0xD5; + _s15_nextRecordSequenceId = -1; + + _gameSys->setAnimation(0xD5, 1, 0); + _gameSys->insertSequence(_s15_currRecordSequenceId, 1, 0, 0, kSeqNone, 0, 0, 0); + + queueInsertDeviceIcon(); + + endSceneInit(); + + while (!_sceneDone) { + + updateMouseCursor(); + updateCursorByHotspot(); + + _hotspots[kHSPlatypus].x1 = 0; + _hotspots[kHSPlatypus].y1 = 0; + _hotspots[kHSPlatypus].x2 = 0; + _hotspots[kHSPlatypus].y2 = 0; + + _sceneClickedHotspot = getClickedHotspotId(); + updateGrabCursorSprite(0, 0); + + if (_sceneClickedHotspot >= 0) + debug("_sceneClickedHotspot: %d; _verbCursor: %d", _sceneClickedHotspot, _verbCursor); + + switch (_sceneClickedHotspot) { + + case kHSDevice: + if (_gnapActionStatus < 0) { + runMenu(); + scene15_updateHotspots(); + } + break; + + case kHSExit: + _newSceneNum = 12; + _isLeavingScene = true; + break; + + case kHSCoinSlot: + if (_grabCursorSpriteIndex == kItemQuarter || _grabCursorSpriteIndex == kItemQuarterWithHole) { + _s15_nextSlotSequenceId = 0xDC; // Insert coin + } else if (_grabCursorSpriteIndex == kItemDiceQuarterHole) { + _s15_nextSlotSequenceId = 0xDB; + } else if (_grabCursorSpriteIndex >= 0) { + _gameSys->insertSequence(0x107A8, 1, 0, 0, kSeqNone, 0, 900 - _gnapGridX, 576 - _gnapGridY); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + case GRAB_CURSOR: + playSound(0x108E9, 0); + break; + case TALK_CURSOR: + playSound((getRandom(5) + 0x8D5) | 0x10000, 0); + break; + case PLAT_CURSOR: + _gameSys->insertSequence(0x107A8, 1, 0, 0, kSeqNone, 0, 900 - _gnapGridX, 576 - _gnapGridY); + break; + } + } + break; + + case kHSPlayButton: + if (_grabCursorSpriteIndex >= 0) { + _gameSys->insertSequence(0x107A8, 1, 0, 0, kSeqNone, 0, 900 - _gnapGridX, 576 - _gnapGridY); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + if (isFlag(12) || isFlag(13)) + playSound(0x108E9, 0); + else + _s15_nextSlotSequenceId = 0xDA; + break; + case GRAB_CURSOR: + if (isFlag(12) || isFlag(13)) + _s15_nextSlotSequenceId = 0xD9; + else + _s15_nextSlotSequenceId = 0xDA; + break; + case TALK_CURSOR: + playSound((getRandom(5) + 0x8D5) | 0x10000, 0); + break; + case PLAT_CURSOR: + _gameSys->insertSequence(0x107A8, 1, 0, 0, kSeqNone, 0, 900 - _gnapGridX, 576 - _gnapGridY); + break; + } + } + break; + + case kHSButton1: + case kHSButton2: + case kHSButton3: + case kHSButton4: + case kHSButton5: + case kHSButton6: + if (_grabCursorSpriteIndex >= 0) { + _gameSys->insertSequence(0x107A8, 1, 0, 0, kSeqNone, 0, 900 - _gnapGridX, 576 - _gnapGridY); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playSound(0x108E9, 0); + break; + case GRAB_CURSOR: + _s15_nextUpperButtonSequenceId = _sceneClickedHotspot + 0xC5; + break; + case TALK_CURSOR: + playSound((getRandom(5) + 0x8D5) | 0x10000, 0); + break; + case PLAT_CURSOR: + _gameSys->insertSequence(0x107A8, 1, 0, 0, kSeqNone, 0, 900 - _gnapGridX, 576 - _gnapGridY); + break; + } + } + break; + + case kHSButtonA: + case kHSButtonB: + case kHSButtonC: + case kHSButtonD: + case kHSButtonE: + case kHSButtonF: + if (_grabCursorSpriteIndex >= 0) { + _gameSys->insertSequence(0x107A8, 1, 0, 0, kSeqNone, 0, 900 - _gnapGridX, 576 - _gnapGridY); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playSound(0x108E9, 0); + break; + case GRAB_CURSOR: + _s15_nextLowerButtonSequenceId = _sceneClickedHotspot + 0xC5; + break; + case TALK_CURSOR: + playSound((getRandom(5) + 0x8D5) | 0x10000, 0); + break; + case PLAT_CURSOR: + _gameSys->insertSequence(0x107A8, 1, 0, 0, kSeqNone, 0, 900 - _gnapGridX, 576 - _gnapGridY); + break; + } + } + break; + + default: + _mouseClickState.left = false; + break; + + } + + scene15_updateAnimations(); + + checkGameKeys(); + + if (isKeyStatus1(8)) { + clearKeyStatus1(8); + runMenu(); + scene15_updateHotspots(); + } + + gameUpdateTick(); + + } + +} + +void GnapEngine::scene15_updateAnimations() { + + if (_gameSys->getAnimationStatus(0) == 2) { + if (_isLeavingScene) { + _sceneDone = true; + } else if (_s15_nextSlotSequenceId != -1) { + _gameSys->setAnimation(_s15_nextSlotSequenceId, 1, 0); + _gameSys->insertSequence(_s15_nextSlotSequenceId, 1, 0, 0, kSeqNone, 0, 0, 0); + _s15_currSlotSequenceId = _s15_nextSlotSequenceId; + _s15_nextSlotSequenceId = -1; + switch (_s15_currSlotSequenceId) { + case 0xDC: + if (_grabCursorSpriteIndex == kItemQuarter) { + invRemove(kItemQuarter); + } else { + invRemove(kItemQuarterWithHole); + setFlag(13); + } + setGrabCursorSprite(-1); + break; + case 0xDB: + setFlag(14); + setGrabCursorSprite(-1); + _s15_nextSlotSequenceId = 0xD8; + break; + case 0xD9: + if (isFlag(12)) { + clearFlag(12); + invAdd(kItemQuarter); + _newGrabCursorSpriteIndex = kItemQuarter; + } else if (isFlag(13)) { + clearFlag(13); + invAdd(kItemQuarterWithHole); + _newGrabCursorSpriteIndex = kItemQuarterWithHole; + } + _newSceneNum = 12; + _isLeavingScene = true; + break; + case 0xD8: + case 0xDA: + if (_s15_currUpperButtonSequenceId != -1) { + _gameSys->removeSequence(_s15_currUpperButtonSequenceId, 1, 1); + _s15_currUpperButtonSequenceId = -1; + } + if (_s15_currLowerButtonSequenceId != -1) { + _gameSys->removeSequence(_s15_currLowerButtonSequenceId, 1, 1); + _s15_currLowerButtonSequenceId = -1; + } + break; + } + } else if (_s15_nextRecordSequenceId != -1) { + _gameSys->setAnimation(_s15_nextRecordSequenceId, 1, 0); + _gameSys->insertSequence(_s15_nextRecordSequenceId, 1, _s15_currRecordSequenceId, 1, kSeqSyncWait, 0, 0, 0); + _s15_currRecordSequenceId = _s15_nextRecordSequenceId; + _s15_nextRecordSequenceId = -1; + if (_s15_currRecordSequenceId == 0xD3) { + invRemove(kItemDiceQuarterHole); + _newSceneNum = 16; + _isLeavingScene = true; + } + _gameSys->removeSequence(_s15_currUpperButtonSequenceId, 1, 1); + _s15_currUpperButtonSequenceId = -1; + _gameSys->removeSequence(_s15_currLowerButtonSequenceId, 1, 1); + _s15_currLowerButtonSequenceId = -1; + } else if (_s15_nextUpperButtonSequenceId != -1) { + _gameSys->setAnimation(_s15_nextUpperButtonSequenceId, 1, 0); + if (_s15_currUpperButtonSequenceId == -1) + _gameSys->insertSequence(_s15_nextUpperButtonSequenceId, 1, 0, 0, kSeqNone, 0, 0, 0); + else + _gameSys->insertSequence(_s15_nextUpperButtonSequenceId, 1, _s15_currUpperButtonSequenceId, 1, kSeqSyncWait, 0, 0, 0); + _s15_currUpperButtonSequenceId = _s15_nextUpperButtonSequenceId; + _s15_nextUpperButtonSequenceId = -1; + if (_s15_currLowerButtonSequenceId != -1 && isFlag(14)) { + if (_s15_currUpperButtonSequenceId == 0xCC && _s15_currLowerButtonSequenceId == 0xCE) + _s15_nextRecordSequenceId = 0xD3; + else + _s15_nextRecordSequenceId = 0xD4; + } + } else if (_s15_nextLowerButtonSequenceId != -1) { + _gameSys->setAnimation(_s15_nextLowerButtonSequenceId, 1, 0); + if (_s15_currLowerButtonSequenceId == -1) + _gameSys->insertSequence(_s15_nextLowerButtonSequenceId, 1, 0, 0, kSeqNone, 0, 0, 0); + else + _gameSys->insertSequence(_s15_nextLowerButtonSequenceId, 1, _s15_currLowerButtonSequenceId, 1, kSeqSyncWait, 0, 0, 0); + _s15_currLowerButtonSequenceId = _s15_nextLowerButtonSequenceId; + _s15_nextLowerButtonSequenceId = -1; + if (_s15_currUpperButtonSequenceId != -1 && isFlag(14)) { + if (_s15_currUpperButtonSequenceId == 0xCC && _s15_currLowerButtonSequenceId == 0xCE) + _s15_nextRecordSequenceId = 0xD3; + else + _s15_nextRecordSequenceId = 0xD4; + } + } + } + +} + +} // End of namespace Gnap diff --git a/engines/gnap/scenes/scene16.cpp b/engines/gnap/scenes/scene16.cpp new file mode 100644 index 0000000000..dfc852293e --- /dev/null +++ b/engines/gnap/scenes/scene16.cpp @@ -0,0 +1,82 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "gnap/gnap.h" +#include "gnap/gamesys.h" +#include "gnap/resource.h" + +namespace Gnap { + +void GnapEngine::scene16_initCutscene() { + _s99_dword_47F370[0] = 0x1F2; + _s99_dword_47F370[1] = 0x201; + _s99_dword_47F370[2] = 0x1FC; + _s99_dword_47F370[3] = 0x1F4; + _s99_dword_47F370[4] = 0x1FB; + _s99_dword_47F370[5] = 0x1F0; + _s99_dword_47F370[6] = 0x1FD; + _s99_dword_47F370[7] = 0x1FE; + _s99_dword_47F370[8] = 0x1F7; + _s99_dword_47F370[9] = 0x1F9; + _s99_dword_47F370[10] = 0x1F8; + _s99_dword_47F370[11] = 0x1F1; + _s99_dword_47F370[12] = 0x202; + _s99_dword_47F370[13] = 0x1F6; + _s99_dword_47F370[14] = 0x1F3; + _s99_dword_47F370[15] = 0x1FA; + _s99_dword_47F370[16] = 0x1FF; + _s99_dword_47F370[17] = 0x200; + _s99_dword_47F370[18] = 0x203; + _s99_dword_47F370[19] = 0x206; + _s99_dword_47F370[20] = 0x207; + _s99_dword_47F370[21] = 0x204; + _s99_dword_47F370[22] = 0x205; + _s99_dword_47F2F0[0] = 0x1C; + _s99_dword_47F2F0[1] = 2; + _s99_dword_47F2F0[2] = 0x1B; + _s99_dword_47F2F0[3] = 0; + _s99_dword_47F2F0[4] = 0x167; + _s99_dword_47F2F0[5] = 1; + _s99_dword_47F2F0[6] = 0x15B; + _s99_dword_47F2F0[7] = 0x15A; + _s99_dword_47F2F0[8] = 0x170; + _s99_dword_47F2F0[9] = 0x1EB; + _s99_dword_47F2F0[10] = 0x1EC; + _s99_dword_47F2F0[11] = 0x1BE; + _s99_dword_47F2F0[12] = 0x1BF; + _s99_dword_47F330[0] = 4; + _s99_dword_47F330[1] = 1; + _s99_dword_47F330[2] = 1; + _s99_dword_47F330[3] = 6; + _s99_dword_47F330[4] = 1; + _s99_dword_47F330[5] = 3; + _s99_dword_47F330[6] = 1; + _s99_dword_47F330[7] = 1; + _s99_dword_47F330[8] = 1; + _s99_dword_47F330[9] = 1; + _s99_dword_47F330[10] = 1; + _s99_dword_47F330[11] = 1; + _s99_dword_47F330[12] = 1; + _s99_itemsCount = 13; +} + +} // End of namespace Gnap diff --git a/engines/gnap/scenes/scene17.cpp b/engines/gnap/scenes/scene17.cpp new file mode 100644 index 0000000000..5b7c54c0a8 --- /dev/null +++ b/engines/gnap/scenes/scene17.cpp @@ -0,0 +1,846 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "gnap/gnap.h" +#include "gnap/gamesys.h" +#include "gnap/resource.h" + +namespace Gnap { + +enum { + kHSPlatypus = 0, + kHSPhone1 = 1, + kHSPhone2 = 2, + kHSExitGrubCity = 3, + kHSDevice = 4, + kHSExitToyStore = 5, + kHSWrench = 6, + kHSWalkArea1 = 7, + kHSWalkArea2 = 8, + kHSWalkArea3 = 9 +}; + +enum { + kASTryGetWrench = 0, + kASGetWrench2 = 1, + kASGetWrenchDone = 2, + kASGetWrench1 = 3, + kASPlatUsePhone = 4, + kASPutCoinIntoPhone = 5, + kASGetCoinFromPhone = 6, + kASGetCoinFromPhoneDone = 7, + kASPutCoinIntoPhoneDone = 8, + kASGnapUsePhone = 9, + kASGetWrenchGnapReady = 10, + kASGnapHangUpPhone = 11, + kASPlatPhoningAssistant = 12, + kASPlatHangUpPhone = 14, + kASLeaveScene = 15 +}; + +int GnapEngine::scene17_init() { + return 0x263; +} + +void GnapEngine::scene17_updateHotspots() { + setHotspot(kHSPlatypus, 1, 0, 0, 0, SF_WALKABLE | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSPhone1, 61, 280, 97, 322, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR, 1, 7); + setHotspot(kHSPhone2, 80, 204, 178, 468, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR, 1, 7); + setHotspot(kHSExitGrubCity, 196, 207, 280, 304, SF_EXIT_U_CURSOR, 3, 5); + setHotspot(kHSExitToyStore, 567, 211, 716, 322, SF_EXIT_U_CURSOR, 5, 6); + setHotspot(kHSWrench, 586, 455, 681, 547, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR, 5, 7); + setHotspot(kHSWalkArea1, 0, 0, 800, 434); + setHotspot(kHSWalkArea2, 541, 0, 800, 600); + setHotspot(kHSWalkArea3, 0, 204, 173, 468); + setDeviceHotspot(kHSDevice, -1, -1, -1, -1); + if (isFlag(6)) + _hotspots[kHSWrench].flags = 0; + if (isFlag(26)) { + _hotspots[kHSDevice].flags = SF_DISABLED; + _hotspots[kHSPlatypus].flags = SF_DISABLED; + } + _hotspotsCount = 10; +} + +void GnapEngine::scene17_update() { + gameUpdateTick(); + updateMouseCursor(); + updateGrabCursorSprite(0, 0); + if (_mouseClickState.left) { + gnapWalkTo(-1, -1, -1, -1, 1); + _mouseClickState.left = false; + } +} + +void GnapEngine::scene17_platHangUpPhone() { + int savedGnapActionStatus = _gnapActionStatus; + + if (_beaverActionStatus == kASPlatPhoningAssistant) { + _gnapActionStatus = kASPlatHangUpPhone; + updateMouseCursor(); + _s17_platPhoneCtr = 0; + _beaverActionStatus = -1; + _gameSys->setAnimation(0x257, 254, 4); + _gameSys->insertSequence(0x257, 254, _s17_currPhoneSequenceId, 254, 32, 0, 0, 0); + while (_gameSys->getAnimationStatus(4) != 2) + gameUpdateTick(); + _gameSys->setAnimation(0x25B, _beaverId, 1); + _gameSys->insertSequence(0x25B, _beaverId, _beaverSequenceId | (_beaverSequenceDatNum << 16), _beaverId, kSeqSyncWait, 0, 0, 0); + _beaverSequenceId = 0x25B; + _beaverSequenceDatNum = 0; + _s17_currPhoneSequenceId = -1; + _s17_nextPhoneSequenceId = -1; + clearFlag(26); + while (_gameSys->getAnimationStatus(1) != 2) + gameUpdateTick(); + _gnapActionStatus = savedGnapActionStatus; + updateMouseCursor(); + } + scene17_updateHotspots(); +} + +void GnapEngine::scene17_run() { + + playSound(0x10940, 1); + startSoundTimerA(8); + _sceneWaiting = false; + _timers[4] = getRandom(100) + 200; + _timers[3] = 200; + _timers[5] = getRandom(30) + 80; + _timers[6] = getRandom(30) + 200; + _timers[7] = getRandom(100) + 100; + + if (isFlag(9)) { + _gameSys->insertSequence(0x25F, 20, 0, 0, kSeqNone, 0, 0, 0); + } else { + if (_s18_garbageCanPos >= 8) { + _gameSys->insertSequence(0x260, 20, 0, 0, kSeqNone, 0, 97, 1); + } else if (_s18_garbageCanPos >= 6) { + _gameSys->insertSequence(0x260, 20, 0, 0, kSeqNone, 0, 68, 2); + } else if (_s18_garbageCanPos >= 5) { + _gameSys->insertSequence(0x260, 20, 0, 0, kSeqNone, 0, 23, -1); + } else if (_s18_garbageCanPos >= 4) { + _gameSys->insertSequence(0x260, 20, 0, 0, kSeqNone, 0, -11, -5); + } else { + _gameSys->insertSequence(0x260, 20, 0, 0, kSeqNone, 0, -54, -8); + } + } + + if (isFlag(19)) + _gameSys->insertSequence(0x262, 1, 0, 0, kSeqNone, 0, 0, 0); + + queueInsertDeviceIcon(); + + if (isFlag(6)) + _s17_currWrenchSequenceId = 0x22D; + else + _s17_currWrenchSequenceId = 0x22F; + + _s17_currCarWindowSequenceId = 0x244; + + if (isFlag(14)) + _gameSys->insertSequence(0x261, 1, 0, 0, kSeqNone, 0, 0, 0); + + _gameSys->setAnimation(_s17_currWrenchSequenceId, 40, 2); + _gameSys->insertSequence(_s17_currWrenchSequenceId, 40, 0, 0, kSeqNone, 0, 0, 0); + + if (isFlag(6)) { + _gameSys->setAnimation(0, 0, 3); + } else { + _gameSys->setAnimation(_s17_currCarWindowSequenceId, 40, 3); + _gameSys->insertSequence(_s17_currCarWindowSequenceId, 40, 0, 0, kSeqNone, 0, 0, 0); + } + + _s17_canTryGetWrench = true; + + if (isFlag(18)) + _gameSys->insertSequence(0x24F, 100, 0, 0, kSeqNone, 0, 0, 0); + + if (_prevSceneNum == 53 || _prevSceneNum == 18 || _prevSceneNum == 20 || _prevSceneNum == 19) { + if (_prevSceneNum == 20) { + initGnapPos(4, 6, 1); + initBeaverPos(5, 6, 0); + endSceneInit(); + platypusWalkTo(5, 9, -1, 0x107C2, 1); + gnapWalkTo(4, 8, -1, 0x107B9, 1); + } else if (isFlag(27)) { + initGnapPos(3, 9, 5); + _platX = _hotspotsWalkPos[2].x; + _platY = _hotspotsWalkPos[2].y; + _beaverId = 20 * _hotspotsWalkPos[2].y; + _gameSys->insertSequence(0x25A, 20 * _hotspotsWalkPos[2].y, 0, 0, kSeqNone, 0, 0, 0); + _gameSys->insertSequence(0x257, 254, 0, 0, kSeqNone, 0, 0, 0); + _beaverSequenceId = 0x25A; + _beaverSequenceDatNum = 0; + endSceneInit(); + clearFlag(15); + clearFlag(16); + _beaverActionStatus = kASPlatPhoningAssistant; + scene17_platHangUpPhone(); + _gameSys->setAnimation(0, 0, 4); + clearFlag(26); + clearFlag(27); + scene17_updateHotspots(); + } else if (isFlag(25)) { + clearFlag(15); + clearFlag(16); + initBeaverPos(7, 9, 0); + _gnapX = _hotspotsWalkPos[2].x; + _gnapY = _hotspotsWalkPos[2].y; + _gnapId = 20 * _hotspotsWalkPos[2].y; + _gameSys->insertSequence(601, 20 * _hotspotsWalkPos[2].y, 0, 0, kSeqNone, 0, 0, 0); + _gnapSequenceDatNum = 0; + _gnapSequenceId = 601; + _gnapActionStatus = kASGnapHangUpPhone; + clearFlag(25); + _gameSys->insertSequence(0x251, 254, 0, 0, kSeqNone, 0, 0, 0); + endSceneInit(); + _gameSys->setAnimation(0x257, 254, 0); + _gameSys->insertSequence(0x257, 254, 0x251, 254, kSeqSyncWait, 0, 0, 0); + } else if (isFlag(26)) { + clearFlag(15); + clearFlag(16); + _sceneWaiting = true; + initGnapPos(3, 9, 5); + _platX = _hotspotsWalkPos[2].x; + _platY = _hotspotsWalkPos[2].y; + _beaverId = 20 * _hotspotsWalkPos[2].y; + _s17_currPhoneSequenceId = 0x251; + _gameSys->insertSequence(0x25A, 20 * _hotspotsWalkPos[2].y, 0, 0, kSeqNone, 0, 0, 0); + _gameSys->insertSequence(_s17_currPhoneSequenceId, 254, 0, 0, kSeqNone, 0, 0, 0); + _beaverSequenceId = 0x25A; + _beaverSequenceDatNum = 0; + endSceneInit(); + _gameSys->setAnimation(_s17_currPhoneSequenceId, 254, 1); + _beaverActionStatus = kASPlatPhoningAssistant; + scene17_updateHotspots(); + } else if (_prevSceneNum == 18) { + initGnapPos(6, 6, 1); + initBeaverPos(5, 6, 0); + endSceneInit(); + platypusWalkTo(5, 9, -1, 0x107C2, 1); + gnapWalkTo(4, 8, -1, 0x107B9, 1); + } else { + if (isFlag(15)) { + initGnapPos(_hotspotsWalkPos[2].x, _hotspotsWalkPos[2].y, 1); + initBeaverPos(1, 9, 0); + endSceneInit(); + } else { + initGnapPos(3, 7, 1); + initBeaverPos(1, 7, 0); + endSceneInit(); + } + clearFlag(15); + clearFlag(16); + endSceneInit(); + } + } else { + _gnapX = 3; + _gnapY = 6; + _gnapId = 120; + _gnapSequenceId = 0x23D; + _gnapSequenceDatNum = 0; + _gnapIdleFacing = 1; + _gameSys->insertSequence(makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, 0, 0, kSeqNone, 0, 0, 0); + _platX = -1; + _platY = 8; + _beaverId = 160; + _gameSys->insertSequence(0x241, 160, 0, 0, kSeqNone, 0, 0, 0); + _gameSys->insertSequence(0x107C1, _beaverId, 0x241, _beaverId, + 9, 0, 75 * _platX - _platGridX, 48 * _platY - _platGridY); + _gameSys->insertSequence(0x22C, 2, 0, 0, kSeqNone, 0, 0, 0); + // TODO delayTicksA(2, 9); + endSceneInit(); + _beaverSequenceId = 0x7C1; + _beaverSequenceDatNum = 1; + _beaverFacing = 1; + platypusWalkTo(2, 9, -1, 0x107C2, 1); + } + + while (!_sceneDone) { + + updateMouseCursor(); + updateCursorByHotspot(); + + _sceneClickedHotspot = getClickedHotspotId(); + updateGrabCursorSprite(0, 0); + + switch (_sceneClickedHotspot) { + + case kHSDevice: + if (_gnapActionStatus < 0 || _gnapActionStatus == 3) { + runMenu(); + scene17_updateHotspots(); + } + break; + + case kHSPlatypus: + if (_gnapActionStatus < 0) { + if (_grabCursorSpriteIndex == kItemJoint) { + if (isFlag(6)) { + gnapUseJointOnPlatypus(); + } else { + gnapUseDeviceOnBeaver(); + platypusWalkTo(_hotspotsWalkPos[6].x, _hotspotsWalkPos[6].y, 1, 0x107C2, 1); + gnapWalkTo(_hotspotsWalkPos[6].x + 1, _hotspotsWalkPos[6].y, 0, 0x107BA, 1); + _beaverActionStatus = kASGetWrench1; + _gnapActionStatus = kASGetWrench1; + _timers[5] = getRandom(30) + 80; + setGrabCursorSprite(-1); + invRemove(kItemJoint); + } + } else if (_grabCursorSpriteIndex >= 0) { + playGnapScratchingHead(_platX, _platY); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + case GRAB_CURSOR: + playGnapScratchingHead(_platX, _platY); + break; + case TALK_CURSOR: + playGnapBrainPulsating(_platX, _platY); + playBeaverSequence(getBeaverSequenceId(0, 0, 0) | 0x10000); + break; + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + } + break; + + case kHSWrench: + if (_gnapActionStatus < 0) { + if (isFlag(6)) { + playGnapImpossible(0, 0); + } else if (_grabCursorSpriteIndex >= 0) { + playGnapShowCurrItem(_hotspotsWalkPos[_sceneClickedHotspot].x, _hotspotsWalkPos[_sceneClickedHotspot].y, 8, 7); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + case GRAB_CURSOR: + playGnapScratchingHead(8, 7); + break; + case TALK_CURSOR: + playGnapImpossible(0, 0); + break; + case PLAT_CURSOR: + if (_s17_canTryGetWrench) { + scene17_platHangUpPhone(); + gnapUseDeviceOnBeaver(); + platypusWalkTo(_hotspotsWalkPos[6].x + 1, _hotspotsWalkPos[6].y, 1, 0x107C2, 1); + _beaverActionStatus = kASTryGetWrench; + _gnapActionStatus = kASTryGetWrench; + _timers[5] = getRandom(30) + 80; + } else + playGnapImpossible(0, 0); + break; + } + } + } + break; + + case kHSPhone1: + if (_gnapActionStatus < 0) { + if (_grabCursorSpriteIndex == kItemDiceQuarterHole) { + gnapWalkTo(_hotspotsWalkPos[2].x, _hotspotsWalkPos[2].y, 0, getGnapSequenceId(gskIdle, 0, 0) | 0x10000, 1); + _gnapActionStatus = kASPutCoinIntoPhone; + } else if (_grabCursorSpriteIndex >= 0) { + playGnapShowCurrItem(_hotspotsWalkPos[2].x, _hotspotsWalkPos[2].y, 1, 3); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapScratchingHead(1, 3); + break; + case GRAB_CURSOR: + if (isFlag(18)) { + scene17_platHangUpPhone(); + gnapWalkTo(_gnapX, _gnapY, 0, getGnapSequenceId(gskIdle, _hotspotsWalkPos[2].x, _hotspotsWalkPos[2].y) | 0x10000, 1); + _gnapActionStatus = kASGetCoinFromPhone; + } else + playGnapImpossible(0, 0); + break; + case TALK_CURSOR: + playGnapImpossible(0, 0); + break; + case PLAT_CURSOR: + if (isFlag(18)) { + scene17_platHangUpPhone(); + _isLeavingScene = true; + gnapUseDeviceOnBeaver(); + _beaverFacing = 5; + platypusWalkTo(_hotspotsWalkPos[2].x, _hotspotsWalkPos[2].y, 1, 0x107C2, 1); + setFlag(16); + _beaverActionStatus = kASPlatUsePhone; + _gnapActionStatus = kASPlatUsePhone; + } else + playGnapImpossible(0, 0); + break; + } + } + } + break; + + case kHSPhone2: + if (_gnapActionStatus < 0) { + if (_grabCursorSpriteIndex == kItemDiceQuarterHole) { + gnapWalkTo(_hotspotsWalkPos[2].x, _hotspotsWalkPos[2].y, 0, getGnapSequenceId(gskIdle, 0, 0) | 0x10000, 1); + _gnapActionStatus = kASPutCoinIntoPhone; + } else if (_grabCursorSpriteIndex >= 0) { + playGnapShowCurrItem(_hotspotsWalkPos[2].x, _hotspotsWalkPos[2].y, 1, 3); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapScratchingHead(1, 3); + break; + case GRAB_CURSOR: + if (isFlag(18)) { + scene17_platHangUpPhone(); + _isLeavingScene = true; + _gnapIdleFacing = 5; + gnapWalkTo(_hotspotsWalkPos[2].x, _hotspotsWalkPos[2].y, 0, getGnapSequenceId(gskIdle, 0, 0) | 0x10000, 1); + _gnapActionStatus = kASGnapUsePhone; + setFlag(15); + } else + playGnapImpossible(0, 0); + break; + case TALK_CURSOR: + playGnapImpossible(0, 0); + break; + case PLAT_CURSOR: + if (isFlag(18)) { + scene17_platHangUpPhone(); + _isLeavingScene = true; + gnapUseDeviceOnBeaver(); + _beaverFacing = 5; + platypusWalkTo(_hotspotsWalkPos[2].x, _hotspotsWalkPos[2].y, 1, 0x107C2, 1); + setFlag(16); + _beaverActionStatus = kASPlatUsePhone; + _gnapActionStatus = kASPlatUsePhone; + } else + playGnapImpossible(0, 0); + break; + } + } + } + break; + + case kHSExitToyStore: + if (_gnapActionStatus < 0) { + _isLeavingScene = true; + _newSceneNum = 18; + _gnapIdleFacing = 7; + gnapWalkTo(_hotspotsWalkPos[5].x, _hotspotsWalkPos[5].y, 0, 0x107BB, 1); + _gnapActionStatus = kASLeaveScene; + if (_beaverActionStatus != kASPlatPhoningAssistant) + platypusWalkTo(_hotspotsWalkPos[5].x - 1, _hotspotsWalkPos[5].y, -1, 0x107C2, 1); + } + break; + + case kHSExitGrubCity: + if (_gnapActionStatus < 0) { + scene17_platHangUpPhone(); + _isLeavingScene = true; + _newSceneNum = 20; + _gnapIdleFacing = 5; + gnapWalkTo(_hotspotsWalkPos[3].x, _hotspotsWalkPos[3].y, 0, 0x107BC, 1); + _gnapActionStatus = kASLeaveScene; + platypusWalkTo(_hotspotsWalkPos[3].x + 1, _hotspotsWalkPos[3].y, -1, 0x107C2, 1); + } + break; + + case kHSWalkArea1: + case kHSWalkArea2: + case kHSWalkArea3: + if (_gnapActionStatus < 0) + gnapWalkTo(-1, -1, -1, -1, 1); + break; + + default: + if (_mouseClickState.left && _gnapActionStatus < 0) { + gnapWalkTo(-1, -1, -1, -1, 1); + _mouseClickState.left = 0; + } + break; + } + + scene17_updateAnimations(); + + if (!isSoundPlaying(0x10940)) + playSound(0x10940, 1); + + if (!_isLeavingScene) { + if (_beaverActionStatus < 0) + beaverSub426234(); + updateGnapIdleSequence2(); + if (!_timers[4]) { + _timers[4] = getRandom(100) + 200; + if (_gnapActionStatus < 0 && _beaverActionStatus < 0) + _gameSys->insertSequence(0x22B, 21, 0, 0, kSeqNone, 0, 0, 0); + } + if (!_timers[7]) { + _timers[7] = getRandom(100) + 100; + if (_gnapActionStatus < 0 && _beaverActionStatus < 0) { + switch (getRandom(3)) { + case 0: + _gameSys->insertSequence(0x25C, 255, 0, 0, kSeqNone, 0, 0, 0); + break; + case 1: + _gameSys->insertSequence(0x25D, 255, 0, 0, kSeqNone, 0, 0, 0); + break; + case 2: + _gameSys->insertSequence(0x25E, 255, 0, 0, kSeqNone, 0, 0, 0); + break; + } + } + } + if (_beaverActionStatus < 0 && !_timers[5]) { + _timers[5] = getRandom(30) + 80; + if (isFlag(6) && _s17_nextWrenchSequenceId == -1) { + _s17_nextWrenchSequenceId = 0x236; + } else if (_s17_canTryGetWrench) { + switch (getRandom(6)) { + case 0: + _s17_nextWrenchSequenceId = 0x231; + break; + case 1: + _s17_nextWrenchSequenceId = 0x232; + break; + case 2: + case 3: + _s17_nextWrenchSequenceId = 0x23C; + break; + case 4: + case 5: + _s17_nextWrenchSequenceId = 0x22E; + break; + } + } else { + --_s17_wrenchCtr; + if (_s17_wrenchCtr) { + switch (getRandom(6)) { + case 0: + _s17_nextWrenchSequenceId = 0x237; + break; + case 1: + _s17_nextWrenchSequenceId = 0x238; + break; + case 2: + _s17_nextWrenchSequenceId = 0x239; + break; + case 3: + _s17_nextWrenchSequenceId = 0x23A; + break; + case 4: + _s17_nextWrenchSequenceId = 0x23B; + break; + case 5: + _s17_nextWrenchSequenceId = 0x235; + break; + } + } else { + _s17_wrenchCtr = 2; + _s17_nextWrenchSequenceId = 0x235; + } + } + } + if (!_timers[6]) { + _timers[6] = getRandom(30) + 200; + if (_s17_nextCarWindowSequenceId == -1 && !isFlag(6)) + _s17_nextCarWindowSequenceId = 0x246; + } + playSoundA(); + } + + checkGameKeys(); + + if (isKeyStatus1(8)) { + clearKeyStatus1(8); + runMenu(); + scene17_updateHotspots(); + } + + gameUpdateTick(); + + } + +} + +void GnapEngine::scene17_updateAnimations() { + + static const int kPlatPhoneSequenceIds[] = { + 0x251, 0x252, 0x253, 0x254, 0x255, 0x256, 0x257 + }; + + if (_gameSys->getAnimationStatus(0) == 2) { + _gameSys->setAnimation(0, 0, 0); + switch (_gnapActionStatus) { + case kASGetWrench1: + _gnapActionStatus = kASGetWrenchGnapReady; + break; + case kASGetCoinFromPhone: + playGnapPullOutDevice(1, 3); + playGnapUseDevice(0, 0); + _gameSys->setAnimation(0x250, 100, 0); + _gameSys->insertSequence(0x250, 100, 591, 100, kSeqSyncWait, 0, 0, 0); + invAdd(kItemDiceQuarterHole); + clearFlag(18); + _gnapActionStatus = kASGetCoinFromPhoneDone; + break; + case kASGetCoinFromPhoneDone: + setGrabCursorSprite(kItemDiceQuarterHole); + _gnapActionStatus = -1; + break; + case kASPutCoinIntoPhone: + _gameSys->setAnimation(0x24C, _gnapId, 0); + _gameSys->insertSequence(0x24C, _gnapId, makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, kSeqSyncWait, 0, 0, 0); + _gnapSequenceDatNum = 0; + _gnapSequenceId = 0x24C; + invRemove(kItemDiceQuarterHole); + setGrabCursorSprite(-1); + setFlag(18); + _gnapActionStatus = kASPutCoinIntoPhoneDone; + break; + case kASPutCoinIntoPhoneDone: + _gameSys->insertSequence(0x24F, 100, 0, 0, kSeqNone, 0, 0, 0); + _gnapActionStatus = -1; + break; + case kASGnapUsePhone: + _gameSys->setAnimation(0x24D, _gnapId, 0); + _gameSys->insertSequence(0x24D, _gnapId, makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, kSeqSyncWait, 0, 0, 0); + _gnapActionStatus = kASLeaveScene; + _newSceneNum = 53; + break; + case kASGnapHangUpPhone: + _gameSys->insertSequence(0x258, _gnapId, makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, kSeqSyncWait, 0, 0, 0); + _gnapSequenceDatNum = 0; + _gnapSequenceId = 0x258; + _gnapActionStatus = -1; + break; + case kASLeaveScene: + _sceneDone = true; + break; + } + } + + if (_gameSys->getAnimationStatus(1) == 2) { + _gameSys->setAnimation(0, 0, 1); + switch (_beaverActionStatus) { + case kASTryGetWrench: + _beaverActionStatus = -1; + ++_s17_platTryGetWrenchCtr; + if (_s17_platTryGetWrenchCtr % 2 != 0) + _s17_nextWrenchSequenceId = 0x233; + else + _s17_nextWrenchSequenceId = 0x234; + _s17_canTryGetWrench = false; + break; + case kASGetWrench1: + _s17_nextWrenchSequenceId = 0x230; + break; + case kASGetWrench2: + _s17_nextCarWindowSequenceId = 0x249; + break; + case kASGetWrenchDone: + _beaverActionStatus = -1; + invAdd(kItemWrench); + setGrabCursorSprite(kItemWrench); + break; + case kASPlatUsePhone: + _gameSys->setAnimation(0x24E, _beaverId, 1); + _gameSys->insertSequence(0x24E, _beaverId, _beaverSequenceId | (_beaverSequenceDatNum << 16), _beaverId, kSeqSyncWait, 0, 0, 0); + _beaverSequenceDatNum = 0; + _beaverSequenceId = 0x24E; + _beaverActionStatus = kASLeaveScene; + _newSceneNum = 53; + break; + case kASPlatPhoningAssistant: + ++_s17_platPhoneCtr; + if (_s17_platPhoneCtr >= 7) { + _s17_platPhoneCtr = 0; + _s17_nextPhoneSequenceId = -1; + _s17_currPhoneSequenceId = -1; + _gameSys->insertSequence(0x25B, _beaverId, 0x25A, _beaverId, kSeqSyncWait, 0, 0, 0); + _beaverSequenceDatNum = 0; + _beaverSequenceId = 0x25B; + _beaverActionStatus = -1; + clearFlag(26); + _sceneWaiting = false; + scene17_updateHotspots(); + } else { + _s17_nextPhoneSequenceId = kPlatPhoneSequenceIds[_s17_platPhoneCtr]; + _gameSys->setAnimation(_s17_nextPhoneSequenceId, 254, 1); + _gameSys->insertSequence(_s17_nextPhoneSequenceId, 254, _s17_currPhoneSequenceId, 254, kSeqSyncWait, 0, 0, 0); + _gameSys->insertSequence(0x25A, _beaverId, 0x25A, _beaverId, kSeqSyncWait, 0, 0, 0); + _beaverSequenceDatNum = 0; + _beaverSequenceId = 0x25A; + _s17_currPhoneSequenceId = _s17_nextPhoneSequenceId; + } + break; + case kASLeaveScene: + _sceneDone = true; + break; + } + } + + if (_gameSys->getAnimationStatus(2) == 2) { + switch (_s17_nextWrenchSequenceId) { + case 0x233: + _gnapActionStatus = -1; + _gameSys->insertSequence(0x243, _beaverId, + _beaverSequenceId | (_beaverSequenceDatNum << 16), _beaverId, + kSeqSyncWait, 0, 0, 0); + _gameSys->insertSequence(_s17_nextWrenchSequenceId, 40, _s17_currWrenchSequenceId, 40, kSeqSyncWait, 0, 0, 0); + _s17_currWrenchSequenceId = _s17_nextWrenchSequenceId; + _s17_nextWrenchSequenceId = -1; + _beaverSequenceId = 0x243; + _beaverSequenceDatNum = 0; + _gameSys->setAnimation(0x243, _beaverId, 1); + break; + case 0x234: + _gnapActionStatus = -1; + _gameSys->insertSequence(0x242, _beaverId, + _beaverSequenceId | (_beaverSequenceDatNum << 16), _beaverId, + kSeqSyncWait, 0, 0, 0); + _gameSys->insertSequence(_s17_nextWrenchSequenceId, 40, _s17_currWrenchSequenceId, 40, kSeqSyncWait, 0, 0, 0); + _s17_currWrenchSequenceId = _s17_nextWrenchSequenceId; + _s17_nextWrenchSequenceId = -1; + _beaverSequenceId = 0x242; + _beaverSequenceDatNum = 0; + _gameSys->setAnimation(0x242, _beaverId, 1); + break; + case 0x231: + if (getRandom(2) != 0) + _s17_nextCarWindowSequenceId = 0x245; + else + _s17_nextCarWindowSequenceId = 0x248; + _gameSys->setAnimation(0, 0, 2); + break; + case 0x232: + _s17_nextCarWindowSequenceId = 0x247; + _gameSys->setAnimation(0, 0, 2); + break; + case 0x22E: + case 0x235: + if (_s17_nextWrenchSequenceId == 0x235) + _hotspots[kHSWrench].flags &= ~SF_DISABLED; + else + _hotspots[kHSWrench].flags |= SF_DISABLED; + _s17_canTryGetWrench = !_s17_canTryGetWrench; + _gameSys->setAnimation(_s17_nextWrenchSequenceId, 40, 2); + _gameSys->insertSequence(_s17_nextWrenchSequenceId, 40, _s17_currWrenchSequenceId, 40, kSeqSyncWait, 0, 0, 0); + _s17_currWrenchSequenceId = _s17_nextWrenchSequenceId; + _s17_nextWrenchSequenceId = -1; + break; + case 0x230: + if (_gnapActionStatus == kASGetWrenchGnapReady) { + _gameSys->setAnimation(0, 0, 2); + if (_s17_canTryGetWrench) { + _gameSys->insertSequence(0x22E, 40, _s17_currWrenchSequenceId, 40, kSeqSyncWait, 0, 0, 0); + _s17_currWrenchSequenceId = 0x22E; + _s17_canTryGetWrench = false; + } + _gameSys->setAnimation(0x23F, _beaverId, 1); + _gameSys->insertSequence(0x10875, _gnapId, makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, kSeqSyncWait, 0, 0, 0); + _gameSys->insertSequence(0x23F, _beaverId, + _beaverSequenceId | (_beaverSequenceDatNum << 16), _beaverId, + kSeqSyncWait, 0, 0, 0); + _gnapSequenceDatNum = 1; + _beaverSequenceDatNum = 0; + _gnapSequenceId = 0x875; + _beaverSequenceId = 0x23F; + gnapWalkTo(3, 8, -1, 0x107B9, 1); + _beaverActionStatus = kASGetWrench2; + } + break; + default: + if (_s17_nextWrenchSequenceId != -1) { + _gameSys->setAnimation(_s17_nextWrenchSequenceId, 40, 2); + _gameSys->insertSequence(_s17_nextWrenchSequenceId, 40, _s17_currWrenchSequenceId, 40, kSeqSyncWait, 0, 0, 0); + _s17_currWrenchSequenceId = _s17_nextWrenchSequenceId; + _s17_nextWrenchSequenceId = -1; + } + break; + } + } + + if (_gameSys->getAnimationStatus(3) == 2) { + switch (_s17_nextCarWindowSequenceId) { + case 0x246: + _gameSys->setAnimation(_s17_nextCarWindowSequenceId, 40, 3); + _gameSys->insertSequence(_s17_nextCarWindowSequenceId, 40, _s17_currCarWindowSequenceId, 40, kSeqSyncWait, 0, 0, 0); + _s17_currCarWindowSequenceId = _s17_nextCarWindowSequenceId; + _s17_nextCarWindowSequenceId = -1; + break; + case 0x245: + case 0x247: + case 0x248: + _gameSys->setAnimation(_s17_nextWrenchSequenceId, 40, 2); + _gameSys->insertSequence(_s17_nextWrenchSequenceId, 40, _s17_currWrenchSequenceId, 40, kSeqSyncWait, 0, 0, 0); + while (_gameSys->getAnimationStatus(2) != 2) + scene17_update(); + _gameSys->setAnimation(_s17_nextCarWindowSequenceId, 40, 3); + _gameSys->insertSequence(_s17_nextCarWindowSequenceId, 40, _s17_currCarWindowSequenceId, 40, kSeqSyncWait, 0, 0, 0); + _s17_currCarWindowSequenceId = _s17_nextCarWindowSequenceId; + _s17_nextCarWindowSequenceId = -1; + _s17_currWrenchSequenceId = _s17_nextWrenchSequenceId; + _s17_nextWrenchSequenceId = -1; + break; + case 0x249: + _gameSys->setAnimation(0x230, 40, 2); + _gameSys->setAnimation(0x240, _beaverId, 1); + _gameSys->insertSequence(0x230, 40, _s17_currWrenchSequenceId, 40, kSeqSyncWait, 0, 0, 0); + _gameSys->insertSequence(_s17_nextCarWindowSequenceId, 40, _s17_currCarWindowSequenceId, 40, kSeqSyncWait, 0, 0, 0); + _gameSys->insertSequence(0x240, _beaverId, _beaverSequenceId, _beaverId, kSeqSyncWait, 0, 0, 0); + _gameSys->insertSequence(0x23E, _gnapId, makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, kSeqSyncWait, 0, 0, 0); + _gnapSequenceId = 0x23E; + _gnapSequenceDatNum = 0; + _beaverSequenceId = 0x240; + _beaverSequenceDatNum = 0; + _gameSys->setAnimation(0x24A, 40, 3); + _gameSys->insertSequence(0x24A, 40, _s17_nextCarWindowSequenceId, 40, kSeqSyncWait, 0, 0, 0); + while (_gameSys->getAnimationStatus(2) != 2) { + scene17_update(); + if (_gameSys->getAnimationStatus(3) == 2) { + _gameSys->setAnimation(0x24A, 40, 3); + _gameSys->insertSequence(0x24A, 40, 586, 40, kSeqSyncWait, 0, 0, 0); + } + } + _gameSys->insertSequence(0x22D, 40, 560, 40, kSeqSyncWait, 0, 0, 0); + _gameSys->setAnimation(0x24B, 40, 3); + _gameSys->insertSequence(0x24B, 40, 586, 40, kSeqSyncWait, 0, 0, 0); + _s17_currCarWindowSequenceId = 0x24B; + _s17_nextCarWindowSequenceId = -1; + _s17_currWrenchSequenceId = 0x22D; + _s17_nextWrenchSequenceId = -1; + setFlag(6); + _gnapActionStatus = -1; + _beaverActionStatus = 2; + scene17_updateHotspots(); + _timers[5] = getRandom(30) + 80; + break; + } + } + +} + +} // End of namespace Gnap diff --git a/engines/gnap/scenes/scene18.cpp b/engines/gnap/scenes/scene18.cpp new file mode 100644 index 0000000000..619d50f5e2 --- /dev/null +++ b/engines/gnap/scenes/scene18.cpp @@ -0,0 +1,1026 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "gnap/gnap.h" +#include "gnap/gamesys.h" +#include "gnap/resource.h" + +namespace Gnap { + +static const int kScene18SequenceIds[] = { + 0x219, 0x21A, 0x21B, 0x21C, 0x21D +}; + +enum { + kHSPlatypus = 0, + kHSGarbageCan = 1, + kHSDevice = 2, + kHSExitToyStore = 3, + kHSExitPhoneBooth = 4, + kHSExitGrubCity = 5, + kHSHydrantTopValve = 6, + kHSHydrantRightValve = 7, + kHSCowboyHat = 8, + kHSWalkArea1 = 9, + kHSWalkArea2 = 10 +}; + +enum { + kASOpenRightValveNoGarbageCanDone = 0, + kASOpenRightValveNoGarbageCan = 1, + kASCloseRightValveNoGarbageCan = 2, + kASOpenTopValveDone = 3, + kASOpenTopValve = 4, + kASCloseTopValve = 5, + kASGrabGarbageCanFromStreet = 6, + kASGrabCowboyHat = 7, + kASGrabGarbageCanFromHydrant = 8, + kASPutGarbageCanOnRunningHydrant = 9, + kASPutGarbageCanOnRunningHydrant2 = 10, + kASGrabCowboyHatDone = 11, + kASStandingOnHydrant = 12, + kASOpenRightValveWithGarbageCan = 13, + kASOpenRightValveWithGarbageCanDone = 14, + kASCloseRightValveWithGarbageCan = 15, + kASPutGarbageCanOnHydrant = 16, + kASPutGarbageCanOnHydrantDone = 17, + kASPlatComesHere = 18, + kASCloseRightValveWithGarbageCanDone = 19, + kASLeaveScene = 20 +}; + +int GnapEngine::scene18_init() { + _gameSys->setAnimation(0, 0, 3); + return 0x222; +} + +void GnapEngine::scene18_updateHotspots() { + setHotspot(kHSPlatypus, 0, 0, 0, 0, SF_WALKABLE | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSGarbageCan, _gridMinX + 75 * _s18_garbageCanPos - 35, _gridMinY + 230, _gridMinX + 75 * _s18_garbageCanPos + 35, _gridMinY + 318, + SF_WALKABLE | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR, _s18_garbageCanPos, 7); + setHotspot(kHSExitToyStore, 460, 238, 592, 442, SF_EXIT_U_CURSOR, 7, 7); + setHotspot(kHSExitPhoneBooth, 275, 585, 525, 600, SF_EXIT_D_CURSOR | SF_WALKABLE, 5, 10); + setHotspot(kHSExitGrubCity, 0, 350, 15, 600, SF_EXIT_L_CURSOR, 0, 9); + setHotspot(kHSHydrantTopValve, 100, 345, 182, 410, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR, 1, 8); + setHotspot(kHSHydrantRightValve, 168, 423, 224, 470, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR, 3, 7); + setHotspot(kHSCowboyHat, 184, 63, 289, 171, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR, 4, 7); + setHotspot(kHSWalkArea1, 0, 0, 800, 448); + setHotspot(kHSWalkArea2, 0, 0, 214, 515); + setDeviceHotspot(kHSDevice, -1, -1, -1, -1); + if (isFlag(8)) { + if (isFlag(9)) { + _hotspots[kHSHydrantTopValve].flags = SF_DISABLED; + _hotspots[kHSHydrantRightValve].x1 = 148; + _hotspots[kHSHydrantRightValve].y1 = 403; + _hotspots[kHSGarbageCan].flags = SF_DISABLED; + _hotspotsWalkPos[kHSGarbageCan].x = 3; + _hotspotsWalkPos[kHSGarbageCan].y = 7; + } else { + _hotspots[kHSHydrantTopValve].y1 = 246; + } + } else if (isFlag(7)) { + _hotspots[kHSHydrantRightValve].flags = SF_DISABLED; + _hotspots[kHSHydrantTopValve].x1 = 105; + _hotspots[kHSHydrantTopValve].x2 = 192; + } else if (isFlag(9)) { + _hotspots[kHSGarbageCan].x1 = 115; + _hotspots[kHSGarbageCan].y1 = 365; + _hotspots[kHSGarbageCan].x2 = 168; + _hotspots[kHSGarbageCan].y2 = 470; + _hotspots[kHSGarbageCan].flags = SF_WALKABLE | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR; + _hotspotsWalkPos[kHSGarbageCan].x = 3; + _hotspotsWalkPos[kHSGarbageCan].y = 7; + } + if (isFlag(10)) + _hotspots[kHSGarbageCan].flags = SF_DISABLED; + if (isFlag(26)) { + _hotspots[kHSDevice].flags = SF_DISABLED; + _hotspots[kHSHydrantTopValve].flags = SF_DISABLED; + _hotspots[kHSHydrantRightValve].flags = SF_DISABLED; + _hotspots[kHSPlatypus].flags = SF_DISABLED; + } + if (isFlag(14)) { + _hotspots[kHSHydrantTopValve].flags = SF_DISABLED; + _hotspots[kHSCowboyHat].flags = SF_DISABLED; + } + _hotspotsCount = 11; +} + +void GnapEngine::scene18_gnapCarryGarbageCanTo(int x, int y, int animationIndex, int argC, int a5) { + + // TODO Cleanup + + static const int kSequenceIds[] = { + 0x203, 0x204 + }; + + int gnapSeqId, gnapId, gnapDatNum, gnapGridX; + int v13, v12, v5, v10, v11, v15, v16, a2; + + if (x >= 0) + v13 = x; + else + v13 = (_leftClickMouseX - _gridMinX + 37) / 75; + if (v13 >= _gnapX) + v10 = v13 - 1; + else + v10 = v13 + 1; + + if (a5 < 0) + a5 = 4; + v5 = v10; + if (v10 <= a5) + v5 = a5; + v11 = v5; + v12 = _gridMaxX - 1; + if (_gridMaxX - 1 >= v11) + v12 = v11; + + if (v12 == _gnapX) { + gnapSeqId = _gnapSequenceId; + gnapId = _gnapId; + gnapDatNum = _gnapSequenceDatNum; + gnapGridX = _gnapX; + if (_gnapX <= v13) + v15 = 1; + else + v15 = -1; + } else { + if (_gnapY == _platY) { + if (v12 >= _gnapX) { + if (v12 >= _platX && _gnapX <= _platX) + beaverMakeRoom(); + } else if (v12 <= _platX && _gnapX >= _platX) { + beaverMakeRoom(); + } + } + gnapSeqId = _gnapSequenceId; + gnapId = _gnapId; + gnapDatNum = _gnapSequenceDatNum; + gnapGridX = _gnapX; + if (v12 < _gnapX) + v15 = -1; + else + v15 = 1; + v16 = v15 == -1; + a2 = 20 * _gnapY + 1; + do { + if (isPointBlocked(gnapGridX + v15, _gnapY)) + break; + a2 += v15; + _gameSys->insertSequence(kSequenceIds[v16], a2, + gnapSeqId | (gnapDatNum << 16), gnapId, + kSeqSyncWait, 0, 75 * gnapGridX - _gnapGridX, 48 * _gnapY - _gnapGridY); + gnapSeqId = kSequenceIds[v16]; + gnapId = a2; + gnapDatNum = 0; + gnapGridX += v15; + } while (v12 != gnapGridX); + } + + if (argC >= 0) { + _gnapSequenceId = ridToEntryIndex(argC); + _gnapSequenceDatNum = ridToDatIndex(argC); + } else { + if (v15 == 1) + _gnapSequenceId = 0x20A; + else + _gnapSequenceId = 0x209; + _gnapSequenceDatNum = 0; + } + + if (v15 == 1) + _gnapIdleFacing = 1; + else + _gnapIdleFacing = 3; + + _gnapId = 20 * _gnapY + 1; + + if (animationIndex >= 0) + _gameSys->setAnimation(makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, animationIndex); + + _gameSys->insertSequence(makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, + gnapSeqId | (gnapDatNum << 16), gnapId, + 9, 0, 75 * gnapGridX - _gnapGridX, 48 * _gnapY - _gnapGridY); + + _gnapX = gnapGridX; + +} + +void GnapEngine::scene18_putDownGarbageCan(int animationIndex) { + if (animationIndex >= 0) { + while (_gameSys->getAnimationStatus(animationIndex) != 2) + gameUpdateTick(); + } + if (_gnapIdleFacing != 0 && _gnapIdleFacing != 1 && _gnapIdleFacing != 7) + _s18_garbageCanPos = _gnapX - 1; + else + _s18_garbageCanPos = _gnapX + 1; + clearFlag(10); + scene18_updateHotspots(); + if (_gnapIdleFacing != 0 && _gnapIdleFacing != 1 && _gnapIdleFacing != 7) { + _gameSys->insertSequence(0x107BA, _gnapId, + makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, + kSeqSyncWait, 0, 75 * _gnapX - _gnapGridX, 48 * _gnapY - _gnapGridY); + _gnapSequenceId = 0x7BA; + } else { + _gameSys->insertSequence(0x107B9, _gnapId, + makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, + kSeqSyncWait, 0, 75 * _gnapX - _gnapGridX, 48 * _gnapY - _gnapGridY); + _gnapSequenceId = 0x7B9; + } + _gnapSequenceDatNum = 1; + _gameSys->insertSequence(0x1FB, 19, 0, 0, kSeqNone, 0, 15 * (5 * _s18_garbageCanPos - 40), 0); + _gameSys->setAnimation(0x1FA, 19, 4); + _gameSys->insertSequence(0x1FA, 19, 507, 19, kSeqSyncWait, 0, 15 * (5 * _s18_garbageCanPos - 40), 0); + while (_gameSys->getAnimationStatus(4) != 2) + gameUpdateTick(); +} + +void GnapEngine::scene18_platEndPhoning(int a1) { + if (isFlag(26)) { + _s18_platPhoneIter = 0; + _s18_platPhoneCtr = 0; + _beaverActionStatus = -1; + if (_s18_currPhoneSequenceId != -1) { + _gameSys->setAnimation(0x21E, 254, 3); + _gameSys->insertSequence(0x21E, 254, _s18_currPhoneSequenceId, 254, 32, 0, 0, 0); + while (_gameSys->getAnimationStatus(3) != 2) + gameUpdateTick(); + } + _gameSys->removeSequence(0x21F, 254, 1); + _gameSys->setAnimation(0, 0, 3); + clearFlag(26); + if (a1) { + _beaverActionStatus = kASPlatComesHere; + _timers[6] = 50; + _sceneWaiting = true; + } + _s18_currPhoneSequenceId = -1; + _s18_nextPhoneSequenceId = -1; + scene18_updateHotspots(); + } +} + +void GnapEngine::scene18_closeHydrantValve() { + _gnapActionStatus = kASLeaveScene; + updateMouseCursor(); + if (isFlag(8)) { + gnapWalkTo(_hotspotsWalkPos[kHSHydrantRightValve].x, _hotspotsWalkPos[kHSHydrantRightValve].y, 0, 0x107BA, 1); + if (isFlag(9)) { + _gnapActionStatus = kASCloseRightValveWithGarbageCan; + scene18_waitForGnapAction(); + } else { + _gnapActionStatus = kASCloseRightValveNoGarbageCan; + scene18_waitForGnapAction(); + } + } else if (isFlag(7)) { + gnapWalkTo(_hotspotsWalkPos[kHSHydrantTopValve].x, _hotspotsWalkPos[kHSHydrantTopValve].y, 0, 0x107BA, 1); + _gnapActionStatus = kASCloseTopValve; + scene18_waitForGnapAction(); + } +} + +void GnapEngine::scene18_waitForGnapAction() { + while (_gnapActionStatus >= 0) { + scene18_updateAnimations(); + gameUpdateTick(); + } +} + +void GnapEngine::scene18_run() { + + _s18_cowboyHatSurface = 0; + + playSound(0x10940, 1); + startSoundTimerA(4); + + _timers[5] = getRandom(100) + 100; + + queueInsertDeviceIcon(); + + clearFlag(10); + + if (!isFlag(14)) + _gameSys->insertSequence(0x1F8, 19, 0, 0, kSeqNone, 0, 0, 0); + + if (isFlag(9)) { + if (isFlag(8)) { + _gameSys->insertSequence(0x214, 39, 0, 0, kSeqLoop, 0, 0, 0); + _gameSys->insertSequence(0x20D, 39, 0, 0, kSeqLoop, 0, 0, 0); + playSound(0x22B, true); + } else { + _gameSys->insertSequence(0x1F9, 19, 0, 0, kSeqNone, 0, 0, 0); + } + } else { + _gameSys->insertSequence(0x1FA, 19, 0, 0, kSeqNone, 0, 15 * (5 * _s18_garbageCanPos - 40), 0); + if (isFlag(8)) { + _gameSys->insertSequence(0x212, 39, 0, 0, kSeqLoop, 0, 0, 0); + _gameSys->insertSequence(0x20D, 39, 0, 0, kSeqLoop, 0, 0, 0); + playSound(0x22B, true); + } else if (isFlag(7)) { + _gameSys->insertSequence(0x20E, 39, 0, 0, kSeqLoop, 0, 0, 0); + _gameSys->insertSequence(0x217, 39, 0, 0, kSeqLoop, 0, 0, 0); + playSound(0x22B, true); + } + } + + if (isFlag(26)) { + if (_prevSceneNum == 17) + initGnapPos(4, 11, 1); + else + initGnapPos(4, 7, 1); + _s18_platPhoneCtr = getRandom(5); + if (isFlag(27)) { + _gameSys->insertSequence(0x21E, 254, 0, 0, kSeqNone, 0, 0, 0); + endSceneInit(); + _s18_currPhoneSequenceId = -1; + scene18_platEndPhoning(1); + clearFlag(27); + } else { + _s18_currPhoneSequenceId = kScene18SequenceIds[_s18_platPhoneCtr]; + _s18_platPhoneIter = 0; + _gameSys->insertSequence(0x21F, 254, 0, 0, kSeqNone, 0, 0, 0); + _gameSys->insertSequence(_s18_currPhoneSequenceId, 254, 0, 0, kSeqNone, 0, 0, 0); + endSceneInit(); + } + if (isFlag(27)) { + scene18_platEndPhoning(1); + clearFlag(27); + } else { + _gameSys->setAnimation(_s18_currPhoneSequenceId, 254, 3); + } + gnapWalkTo(4, 8, -1, 0x107B9, 1); + } else { + if (isFlag(12)) { + clearFlag(12); + setGrabCursorSprite(kItemCowboyHat); + _prevSceneNum = 19; + } + if (_prevSceneNum == 17) { + initGnapPos(4, 11, 1); + initBeaverPos(5, 11, 0); + endSceneInit(); + gnapWalkTo(4, 8, -1, 0x107B9, 1); + platypusWalkTo(5, 9, -1, 0x107C2, 1); + } else if (_prevSceneNum == 19) { + initGnapPos(7, 7, 1); + initBeaverPos(8, 7, 0); + endSceneInit(); + gnapWalkTo(7, 8, -1, 0x107B9, 1); + platypusWalkTo(8, 8, -1, 0x107C2, 1); + } else { + initGnapPos(-1, 10, 1); + initBeaverPos(-1, 10, 0); + endSceneInit(); + gnapWalkTo(3, 7, -1, 0x107B9, 1); + platypusWalkTo(3, 8, -1, 0x107C2, 1); + } + } + + while (!_sceneDone) { + + updateMouseCursor(); + updateCursorByHotspot(); + + testWalk(0, 20, -1, -1, -1, -1); + + _sceneClickedHotspot = getClickedHotspotId(); + updateGrabCursorSprite(0, 0); + + if (_sceneClickedHotspot >= 0) + debug("_sceneClickedHotspot: %d", _sceneClickedHotspot); + + switch (_sceneClickedHotspot) { + + case kHSDevice: + if (_gnapActionStatus < 0) { + runMenu(); + scene18_updateHotspots(); + } + break; + + case kHSPlatypus: + if (_gnapActionStatus < 0) { + if (isFlag(10)) { + scene18_gnapCarryGarbageCanTo(-1, -1, 0, -1, -1); + scene18_putDownGarbageCan(0); + } + if (_grabCursorSpriteIndex == kItemJoint) { + gnapUseJointOnPlatypus(); + } else if (_grabCursorSpriteIndex >= 0) { + playGnapShowItem(_grabCursorSpriteIndex, _platX, _platY); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapMoan1(_platX, _platY); + break; + case GRAB_CURSOR: + gnapKissPlatypus(0); + break; + case TALK_CURSOR: + playGnapBrainPulsating(_platX, _platY); + playBeaverSequence(getBeaverSequenceId(0, 0, 0) | 0x10000); + break; + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + } + break; + + case kHSCowboyHat: + if (_gnapActionStatus == kASStandingOnHydrant) { + _gnapActionStatus = kASGrabCowboyHat; + _sceneWaiting = 0; + } else if (_gnapActionStatus < 0) { + if (isFlag(10)) { + scene18_gnapCarryGarbageCanTo(-1, -1, 0, -1, -1); + scene18_putDownGarbageCan(0); + } + if (_grabCursorSpriteIndex >= 0) { + playGnapShowCurrItem(_hotspotsWalkPos[kHSCowboyHat].x, _hotspotsWalkPos[kHSCowboyHat].y, 3, 2); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapScratchingHead(3, 2); + break; + case GRAB_CURSOR: + gnapWalkTo(_hotspotsWalkPos[kHSCowboyHat].x, _hotspotsWalkPos[kHSCowboyHat].y, 0, getGnapSequenceId(gskPullOutDeviceNonWorking, 3, 2) | 0x10000, 1); + break; + case TALK_CURSOR: + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + } + break; + + case kHSGarbageCan: + if (_gnapActionStatus < 0) { + if (isFlag(14)) { + if (_grabCursorSpriteIndex >= 0) + playGnapShowCurrItem(_hotspotsWalkPos[kHSGarbageCan].x, _hotspotsWalkPos[kHSGarbageCan].y, 1, 5); + else + playGnapImpossible(0, 0); + } else { + if (isFlag(26)) + scene18_platEndPhoning(1); + if (_grabCursorSpriteIndex >= 0) { + if (!isFlag(9)) + playGnapShowCurrItem(_hotspotsWalkPos[kHSGarbageCan].x - (_gnapX < _s18_garbageCanPos ? 1 : -1), + _hotspotsWalkPos[kHSGarbageCan].y, _hotspotsWalkPos[kHSGarbageCan].x, _hotspotsWalkPos[kHSGarbageCan].y); + else + playGnapShowCurrItem(_hotspotsWalkPos[kHSGarbageCan].x, _hotspotsWalkPos[kHSGarbageCan].y, 2, 4); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + if (!isFlag(9)) + playGnapScratchingHead(_hotspotsWalkPos[kHSGarbageCan].x - (_gnapX < _s18_garbageCanPos ? 1 : -1), _hotspotsWalkPos[kHSGarbageCan].y); + else if (!isFlag(8)) + playGnapScratchingHead(2, 4); + break; + case GRAB_CURSOR: + if (!isFlag(9)) { + gnapWalkTo(_hotspotsWalkPos[kHSGarbageCan].x - (_gnapX < _s18_garbageCanPos ? 1 : -1), _hotspotsWalkPos[kHSGarbageCan].y, + -1, -1, 1); + gnapWalkTo(_gnapX, _gnapY, 0, getGnapSequenceId(gskIdle, _s18_garbageCanPos, _gnapY) | 0x10000, 1); + _gnapActionStatus = kASGrabGarbageCanFromStreet; + } else if (!isFlag(8)) { + if (gnapWalkTo(_hotspotsWalkPos[kHSGarbageCan].x, _hotspotsWalkPos[kHSGarbageCan].y, 0, -1, 1)) + _gnapActionStatus = kASGrabGarbageCanFromHydrant; + } + break; + case TALK_CURSOR: + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + } + } + break; + + case kHSHydrantTopValve: + if (_gnapActionStatus < 0) { + if (isFlag(10)) { + // While carrying garbage can + if (_grabCursorSpriteIndex >= 0) { + scene18_gnapCarryGarbageCanTo(-1, -1, 0, -1, -1); + scene18_putDownGarbageCan(0); + playGnapShowItem(_grabCursorSpriteIndex, 0, 0); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + scene18_gnapCarryGarbageCanTo(-1, -1, 0, -1, -1); + scene18_putDownGarbageCan(0); + playGnapScratchingHead(0, 0); + break; + case GRAB_CURSOR: + if (isFlag(8)) { + scene18_gnapCarryGarbageCanTo(-1, -1, 0, -1, 2); + _gnapActionStatus = kASPutGarbageCanOnRunningHydrant; + } else if (!isFlag(7)) { + scene18_gnapCarryGarbageCanTo(-1, -1, 0, -1, 2); + _gnapActionStatus = kASPutGarbageCanOnHydrant; + } else { + scene18_gnapCarryGarbageCanTo(-1, -1, 0, -1, -1); + scene18_putDownGarbageCan(0); + playGnapImpossible(0, 0); + } + break; + case TALK_CURSOR: + case PLAT_CURSOR: + scene18_gnapCarryGarbageCanTo(-1, -1, 0, -1, -1); + scene18_putDownGarbageCan(0); + playGnapImpossible(0, 0); + break; + } + } + } else { + if (_grabCursorSpriteIndex == kItemWrench) { + gnapWalkTo(_gnapX, _gnapY, 0, getGnapSequenceId(gskIdle, 2, 8) | 0x10000, 1); + _gnapActionStatus = kASOpenTopValve; + } else if (_grabCursorSpriteIndex >= 0) { + playGnapShowCurrItem(_hotspotsWalkPos[kHSHydrantTopValve].x, _hotspotsWalkPos[kHSHydrantTopValve].y, 1, 5); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapScratchingHead(1, 5); + break; + case GRAB_CURSOR: + if (isFlag(7)) { + _hotspots[kHSWalkArea2].flags |= SF_WALKABLE; + gnapWalkTo(_hotspotsWalkPos[kHSHydrantTopValve].x, _hotspotsWalkPos[kHSHydrantTopValve].y, 0, 0x107BA, 1); + _hotspots[kHSWalkArea2].flags &= ~SF_WALKABLE; + _gnapActionStatus = kASCloseTopValve; + } else + playGnapImpossible(0, 0); + break; + case TALK_CURSOR: + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + } + } + break; + + case kHSHydrantRightValve: + if (_gnapActionStatus < 0) { + if (isFlag(14)) { + if (_grabCursorSpriteIndex == -1) { + playGnapImpossible(0, 0); + } else { + playGnapShowCurrItem(_hotspotsWalkPos[kHSHydrantRightValve].x, _hotspotsWalkPos[kHSHydrantRightValve].y, 1, 5); + } + } else { + if (isFlag(10)) { + scene18_gnapCarryGarbageCanTo(-1, -1, 0, -1, -1); + scene18_putDownGarbageCan(0); + } + if (_grabCursorSpriteIndex == kItemWrench) { + gnapWalkTo(_gnapX, _gnapY, 0, getGnapSequenceId(gskIdle, 2, 8) | 0x10000, 1); + if (isFlag(9)) + _gnapActionStatus = kASOpenRightValveWithGarbageCan; + else + _gnapActionStatus = kASOpenRightValveNoGarbageCan; + } else if (_grabCursorSpriteIndex >= 0) { + playGnapShowCurrItem(_hotspotsWalkPos[kHSHydrantRightValve].x, _hotspotsWalkPos[kHSHydrantRightValve].y, 1, 5); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapScratchingHead(1, 5); + break; + case GRAB_CURSOR: + if (isFlag(8)) { + gnapWalkTo(_hotspotsWalkPos[kHSHydrantRightValve].x, _hotspotsWalkPos[kHSHydrantRightValve].y, 0, 0x107BA, 1); + if (isFlag(9)) + _gnapActionStatus = kASCloseRightValveWithGarbageCan; + else + _gnapActionStatus = kASCloseRightValveNoGarbageCan; + } + break; + case TALK_CURSOR: + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + } + } + break; + + case kHSExitToyStore: + if (_gnapActionStatus < 0) { + if (isFlag(10)) { + scene18_gnapCarryGarbageCanTo(-1, -1, 0, -1, -1); + scene18_putDownGarbageCan(0); + } + if (isFlag(20)) { + playGnapImpossible(0, 0); + } else { + _isLeavingScene = 1; + _newSceneNum = 19; + gnapWalkTo(_hotspotsWalkPos[kHSExitToyStore].x, _hotspotsWalkPos[kHSExitToyStore].y, 0, 0x107C0, 1); + _gnapActionStatus = kASLeaveScene; + if (!isFlag(26)) + platypusWalkTo(_hotspotsWalkPos[kHSExitToyStore].x + 1, _hotspotsWalkPos[kHSExitToyStore].y, -1, 0x107C2, 1); + } + } + break; + + case kHSExitPhoneBooth: + if (_gnapActionStatus < 0) { + if (isFlag(10)) { + scene18_gnapCarryGarbageCanTo(-1, -1, 0, -1, -1); + scene18_putDownGarbageCan(0); + } + scene18_closeHydrantValve(); + _isLeavingScene = 1; + _newSceneNum = 17; + gnapWalkTo(_hotspotsWalkPos[kHSExitPhoneBooth].x, _hotspotsWalkPos[kHSExitPhoneBooth].y, 0, 0x107AE, 1); + _gnapActionStatus = kASLeaveScene; + if (isFlag(26)) + setFlag(27); + else + platypusWalkTo(_hotspotsWalkPos[kHSExitPhoneBooth].x + 1, _hotspotsWalkPos[kHSExitPhoneBooth].y, -1, 0x107C2, 1); + } + break; + + case kHSExitGrubCity: + if (_gnapActionStatus < 0) { + if (isFlag(10)) { + scene18_gnapCarryGarbageCanTo(-1, -1, 0, -1, -1); + scene18_putDownGarbageCan(0); + } + scene18_closeHydrantValve(); + _isLeavingScene = 1; + _newSceneNum = 20; + _hotspots[kHSWalkArea2].flags |= SF_WALKABLE; + gnapWalkTo(_hotspotsWalkPos[kHSExitGrubCity].x, _hotspotsWalkPos[kHSExitGrubCity].y, 0, 0x107B2, 1); + _gnapActionStatus = kASLeaveScene; + if (isFlag(26)) + scene18_platEndPhoning(0); + else + platypusWalkTo(_hotspotsWalkPos[kHSExitGrubCity].x, _hotspotsWalkPos[kHSExitGrubCity].y - 1, -1, 0x107CF, 1); + _hotspots[kHSWalkArea2].flags &= ~SF_WALKABLE; + } + break; + + case kHSWalkArea1: + case kHSWalkArea2: + if (_gnapActionStatus < 0) { + if (isFlag(10)) { + scene18_gnapCarryGarbageCanTo(-1, -1, 0, -1, -1); + scene18_putDownGarbageCan(0); + } else { + gnapWalkTo(-1, -1, -1, -1, 1); + } + _mouseClickState.left = false; + } + break; + + default: + if (_gnapActionStatus != kASStandingOnHydrant && _mouseClickState.left) { + if (isFlag(10)) { + scene18_gnapCarryGarbageCanTo(-1, -1, 0, -1, -1); + scene18_putDownGarbageCan(0); + } else { + gnapWalkTo(-1, -1, -1, -1, 1); + } + _mouseClickState.left = false; + } + break; + + } + + scene18_updateAnimations(); + + if (!isSoundPlaying(0x10940)) + playSound(0x10940, true); + + if ((isFlag(8) || isFlag(7)) && !isSoundPlaying(0x22B) && + _gnapActionStatus != kASOpenRightValveNoGarbageCanDone && _gnapActionStatus != kASOpenRightValveNoGarbageCan && + _gnapActionStatus != kASOpenTopValve && _gnapActionStatus != kASOpenTopValveDone && + _gnapActionStatus != kASOpenRightValveWithGarbageCan && _gnapActionStatus != kASOpenRightValveWithGarbageCanDone) + playSound(0x22B, true); + + if (!_isLeavingScene) { + if (!isFlag(26)) { + if (_beaverActionStatus == kASPlatComesHere) { + if (!_timers[6]) { + _beaverActionStatus = -1; + _sceneWaiting = false; + initBeaverPos(-1, 10, 0); + platypusWalkTo(3, 9, -1, 0x107C2, 1); + clearFlag(26); + } + } else { + _hotspots[kHSWalkArea1].y2 += 48; + _hotspots[kHSWalkArea2].x1 += 75; + updateBeaverIdleSequence(); + _hotspots[kHSWalkArea2].x1 -= 75; + _hotspots[kHSWalkArea1].y2 -= 48; + } + if (!_timers[5]) { + _timers[5] = getRandom(100) + 100; + if (_gnapActionStatus < 0) { + if (getRandom(2) == 1) + _gameSys->insertSequence(0x220, 255, 0, 0, kSeqNone, 0, 0, 0); + else + _gameSys->insertSequence(0x221, 255, 0, 0, kSeqNone, 0, 0, 0); + } + } + playSoundA(); + } + if (!isFlag(10)) + updateGnapIdleSequence(); + } + + checkGameKeys(); + + if (isKeyStatus1(8)) { + clearKeyStatus1(8); + runMenu(); + scene18_updateHotspots(); + } + + gameUpdateTick(); + + } + + if (isFlag(12)) + deleteSurface(&_s18_cowboyHatSurface); + +} + +void GnapEngine::scene18_updateAnimations() { + + if (_gameSys->getAnimationStatus(0) == 2) { + _gameSys->setAnimation(0, 0, 0); + switch (_gnapActionStatus) { + case kASGrabGarbageCanFromStreet: + if (_gnapIdleFacing != 7 && _gnapIdleFacing != 1) { + _gameSys->insertSequence(0x1FC, _gnapId, + makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, + kSeqSyncWait, 0, 75 * _gnapX - 675, 0); + _gnapSequenceDatNum = 0; + _gnapSequenceId = 0x1FC; + } else { + _gameSys->insertSequence(0x1FD, _gnapId, + makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, + kSeqSyncWait, 0, 75 * _gnapX - 525, 0); + _gnapSequenceDatNum = 0; + _gnapSequenceId = 0x1FD; + } + _gameSys->removeSequence(0x1FA, 19, 1); + setFlag(10); + scene18_updateHotspots(); + _gnapActionStatus = -1; + break; + case kASGrabGarbageCanFromHydrant: + _gameSys->insertSequence(0x1FE, _gnapId, makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, kSeqSyncWait, 0, 0, 0); + _gameSys->removeSequence(0x1F9, 19, 1); + _gnapSequenceDatNum = 0; + _gnapSequenceId = 0x1FE; + clearFlag(9); + setFlag(10); + scene18_updateHotspots(); + _gnapActionStatus = -1; + break; + case kASCloseRightValveNoGarbageCan: + _gameSys->insertSequence(0x205, _gnapId, makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, kSeqSyncWait, 0, 0, 0); + _gameSys->removeSequence(0x20D, 39, 1); + _gameSys->removeSequence(0x212, 39, 1); + _gameSys->removeSequence(0x211, 39, 1); + stopSound(0x22B); + _gnapSequenceDatNum = 0; + _gnapSequenceId = 0x205; + clearFlag(8); + invAdd(kItemWrench); + setGrabCursorSprite(kItemWrench); + scene18_updateHotspots(); + _gnapActionStatus = -1; + break; + case kASOpenTopValve: + setFlag(7); + scene18_updateHotspots(); + playGnapPullOutDevice(2, 7); + playGnapUseDevice(0, 0); + _gameSys->insertSequence(0x20C, 19, 0, 0, kSeqNone, 0, 0, 0); + _hotspots[kHSWalkArea2].flags |= SF_WALKABLE; + gnapWalkTo(_hotspotsWalkPos[kHSHydrantTopValve].x, _hotspotsWalkPos[kHSHydrantTopValve].y, 0, 0x107BB, 1); + _hotspots[kHSWalkArea2].flags &= ~SF_WALKABLE; + _gnapActionStatus = kASOpenTopValveDone; + break; + case kASOpenTopValveDone: + setGrabCursorSprite(-1); + _gameSys->insertSequence(0x208, _gnapId, makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, kSeqSyncWait, 0, 0, 0); + _gameSys->insertSequence(0x216, 39, 0, 0, kSeqNone, 21, 0, 0); + _gameSys->removeSequence(0x20C, 19, 1); + _gameSys->setAnimation(0x217, 39, 5); + _gameSys->insertSequence(0x217, 39, 0x216, 39, 10, 0, 0, 0); + while (_gameSys->getAnimationStatus(5) != 2) + gameUpdateTick(); + playSound(0x22B, true); + _gameSys->insertSequence(0x20E, 39, 0, 0, kSeqNone, 0, 0, 0); + _gnapSequenceDatNum = 0; + _gnapSequenceId = 0x208; + invRemove(kItemWrench); + setGrabCursorSprite(-1); + _gnapActionStatus = -1; + break; + case kASCloseTopValve: + _gameSys->insertSequence(0x206, _gnapId, makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, kSeqSyncWait, 0, 0, 0); + _gameSys->removeSequence(0x20E, 39, 1); + _gameSys->removeSequence(0x216, 39, 1); + _gameSys->removeSequence(0x217, 39, 1); + stopSound(0x22B); + _gnapSequenceDatNum = 0; + _gnapSequenceId = 0x206; + clearFlag(7); + invAdd(kItemWrench); + setGrabCursorSprite(kItemWrench); + scene18_updateHotspots(); + _gnapActionStatus = -1; + break; + case kASGrabCowboyHat: + _gameSys->setAnimation(0x200, _gnapId, 0); + _gameSys->insertSequence(0x200, _gnapId, makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, kSeqSyncWait, 0, 0, 0); + _gnapSequenceDatNum = 0; + _gnapSequenceId = 0x200; + _gnapActionStatus = kASGrabCowboyHatDone; + break; + case kASGrabCowboyHatDone: + hideCursor(); + setGrabCursorSprite(-1); + _s18_cowboyHatSurface = addFullScreenSprite(0x1D2, 255); + _gameSys->setAnimation(0x218, 256, 0); + _gameSys->insertSequence(0x218, 256, 0, 0, kSeqNone, 0, 0, 0); + while (_gameSys->getAnimationStatus(0) != 2) + gameUpdateTick(); + _newSceneNum = 18; + invAdd(kItemCowboyHat); + invAdd(kItemWrench); + setFlag(12); + setFlag(14); + clearFlag(8); + setFlag(9); + setFlag(14); + scene18_updateHotspots(); + _gnapActionStatus = kASLeaveScene; + break; + case kASLeaveScene: + _sceneDone = true; + _gnapActionStatus = -1; + break; + case kASPutGarbageCanOnRunningHydrant: + setFlag(9); + clearFlag(10); + _gameSys->requestRemoveSequence(0x211, 39); + _gameSys->requestRemoveSequence(0x212, 39); + _gameSys->insertSequence(0x210, _gnapId, makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, kSeqSyncWait, 0, 0, 0); + stopSound(0x22B); + _gameSys->setAnimation(0x210, _gnapId, 0); + _gnapSequenceDatNum = 0; + _gnapSequenceId = 0x210; + _gnapActionStatus = kASPutGarbageCanOnRunningHydrant2; + break; + case kASPutGarbageCanOnRunningHydrant2: + playSound(0x22B, true); + _gameSys->setAnimation(0x1FF, _gnapId, 0); + _gameSys->insertSequence(0x1FF, _gnapId, makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, kSeqSyncWait, 0, 0, 0); + _gnapSequenceDatNum = 0; + _gnapSequenceId = 0x1FF; + _sceneWaiting = true; + _gnapActionStatus = kASStandingOnHydrant; + break; + case kASStandingOnHydrant: + _gameSys->setAnimation(0x1FF, _gnapId, 0); + _gameSys->insertSequence(0x1FF, _gnapId, makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, kSeqSyncWait, 0, 0, 0); + break; + case kASOpenRightValveNoGarbageCan: + case kASOpenRightValveWithGarbageCan: + setFlag(8); + scene18_updateHotspots(); + playGnapPullOutDevice(2, 7); + playGnapUseDevice(0, 0); + _gameSys->insertSequence(0x20B, 19, 0, 0, kSeqNone, 0, 0, 0); + _hotspots[kHSWalkArea2].flags |= SF_WALKABLE; + gnapWalkTo(_hotspotsWalkPos[kHSHydrantRightValve].x, _hotspotsWalkPos[kHSHydrantRightValve].y, 0, 0x107BA, 1); + _hotspots[kHSWalkArea2].flags &= ~SF_WALKABLE; + if (_gnapActionStatus == kASOpenRightValveNoGarbageCan) + _gnapActionStatus = kASOpenRightValveNoGarbageCanDone; + else + _gnapActionStatus = kASOpenRightValveWithGarbageCanDone; + break; + case kASOpenRightValveWithGarbageCanDone: + setGrabCursorSprite(-1); + _gameSys->insertSequence(0x207, _gnapId, makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, kSeqSyncWait, 0, 0, 0); + _gameSys->insertSequence(0x213, 39, 0, 0, kSeqNone, 21, 0, 0); + _gameSys->requestRemoveSequence(0x1F9, 19); + _gameSys->removeSequence(0x20B, 19, 1); + _gameSys->setAnimation(0x213, 39, 5); + _gameSys->insertSequence(0x214, 39, 0x213, 39, 10, 0, 0, 0); + while (_gameSys->getAnimationStatus(5) != 2) + gameUpdateTick(); + playSound(555, true); + _gameSys->insertSequence(0x20D, 39, 0, 0, kSeqNone, 0, 0, 0); + _gnapSequenceDatNum = 0; + _gnapSequenceId = 0x207; + invRemove(kItemWrench); + _gnapActionStatus = -1; + break; + case kASOpenRightValveNoGarbageCanDone: + setGrabCursorSprite(-1); + _gameSys->insertSequence(0x207, _gnapId, makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, kSeqSyncWait, 0, 0, 0); + _gameSys->insertSequence(0x211, 39, 0, 0, kSeqNone, 21, 0, 0); + _gameSys->removeSequence(0x20B, 19, 1); + _gameSys->setAnimation(0x211, 39, 5); + _gameSys->insertSequence(0x212, 39, 0x211, 39, 10, 0, 0, 0); + while (_gameSys->getAnimationStatus(5) != 2) + gameUpdateTick(); + playSound(0x22B, true); + _gameSys->insertSequence(0x20D, 39, 0, 0, kSeqNone, 0, 0, 0); + _gnapSequenceDatNum = 0; + _gnapSequenceId = 0x207; + invRemove(kItemWrench); + _gnapActionStatus = -1; + break; + case kASCloseRightValveWithGarbageCan: + _gameSys->insertSequence(0x205, _gnapId, makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, kSeqSyncWait, 0, 0, 0); + _gameSys->removeSequence(0x20D, 39, 1); + _gameSys->insertSequence(0x215, 39, 0x214, 39, kSeqSyncWait, 0, 0, 0); + stopSound(0x22B); + _gameSys->setAnimation(0x1F9, 19, 0); + _gameSys->insertSequence(0x1F9, 19, 0x215, 39, kSeqSyncWait, 0, 0, 0); + clearFlag(8); + invAdd(kItemWrench); + setGrabCursorSprite(kItemWrench); + _gameSys->insertSequence(0x107B5, _gnapId, 517, _gnapId, kSeqSyncWait, 0, 75 * _gnapX - _gnapGridX, 48 * _gnapY - _gnapGridY); + scene18_updateHotspots(); + _gnapSequenceDatNum = 1; + _gnapSequenceId = 0x7B5; + _gnapActionStatus = kASCloseRightValveWithGarbageCanDone; + break; + case kASCloseRightValveWithGarbageCanDone: + _gnapActionStatus = -1; + break; + case kASPutGarbageCanOnHydrant: + setFlag(9); + clearFlag(10); + _gameSys->insertSequence(0x20F, _gnapId, makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, kSeqSyncWait, 0, 0, 0); + _gameSys->setAnimation(0x20F, _gnapId, 0); + _gnapSequenceDatNum = 0; + _gnapSequenceId = 0x20F; + _gnapActionStatus = kASPutGarbageCanOnHydrantDone; + break; + case kASPutGarbageCanOnHydrantDone: + _gameSys->insertSequence(0x1F9, 19, 0x20F, _gnapId, kSeqNone, 0, 0, 0); + scene18_updateHotspots(); + _gnapActionStatus = -1; + break; + } + } + + if (_gameSys->getAnimationStatus(3) == 2) { + _gameSys->setAnimation(0, 0, 3); + ++_s18_platPhoneIter; + if (_s18_platPhoneIter <= 4) { + ++_s18_platPhoneCtr; + _s18_nextPhoneSequenceId = kScene18SequenceIds[_s18_platPhoneCtr % 5]; + _gameSys->setAnimation(_s18_nextPhoneSequenceId, 254, 3); + _gameSys->insertSequence(_s18_nextPhoneSequenceId, 254, _s18_currPhoneSequenceId, 254, kSeqSyncWait, 0, 0, 0); + _gameSys->insertSequence(0x21F, 254, 0x21F, 254, kSeqSyncWait, 0, 0, 0); + _s18_currPhoneSequenceId = _s18_nextPhoneSequenceId; + } else { + scene18_platEndPhoning(1); + } + } + +} + +} // End of namespace Gnap diff --git a/engines/gnap/scenes/scene19.cpp b/engines/gnap/scenes/scene19.cpp new file mode 100644 index 0000000000..ebfdd728a1 --- /dev/null +++ b/engines/gnap/scenes/scene19.cpp @@ -0,0 +1,470 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "gnap/gnap.h" +#include "gnap/gamesys.h" +#include "gnap/resource.h" + +namespace Gnap { + +static const int kS19ShopAssistantSequenceIds[] = { + 0x6F, 0x70, 0x71, 0x72, 0x73 +}; + +enum { + kHSPlatypus = 0, + kHSExitOutsideToyStore = 1, + kHSDevice = 2, + kHSPicture = 3, + kHSShopAssistant = 4, + kHSToy1 = 5, + kHSToy2 = 6, + kHSToy3 = 7, + kHSPhone = 8, + kHSToy4 = 9, + kHSToy5 = 10, + kHSToy6 = 11, + kHSToy7 = 12, + kHSWalkArea1 = 13, + kHSWalkArea2 = 14, + kHSWalkArea3 = 15 +}; + +enum { + kASUsePhone = 0, + kASGrabToy = 1, + kASGrabPicture = 2, + kASGrabPictureDone = 3, + kASTalkShopAssistant = 4, + kASLeaveScene = 5 +}; + +int GnapEngine::scene19_init() { + playSound(0x79, 0); + return isFlag(26) ? 0x77 : 0x76; +} + +void GnapEngine::scene19_updateHotspots() { + setHotspot(kHSPlatypus, 0, 0, 0, 0, SF_WALKABLE | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSExitOutsideToyStore, 36, 154, 142, 338, SF_EXIT_NW_CURSOR, 4, 6); + setHotspot(kHSPicture, 471, 237, 525, 283, SF_DISABLED, 7, 2); + setHotspot(kHSShopAssistant, 411, 151, 575, 279, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR, 5, 7); + setHotspot(kHSPhone, 647, 166, 693, 234, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR, 9, 0); + setHotspot(kHSToy1, 181, 11, 319, 149, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR, 3, 0); + setHotspot(kHSToy2, 284, 85, 611, 216, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR, 6, 0); + setHotspot(kHSToy3, 666, 38, 755, 154, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR, 9, 0); + setHotspot(kHSToy4, 154, 206, 285, 327, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR, 3, 3); + setHotspot(kHSToy5, 494, 301, 570, 448, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR, 7, 5); + setHotspot(kHSToy6, 0, 320, 188, 600, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR, 1, 6); + setHotspot(kHSToy7, 597, 434, 800, 600, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR, 9, 8); + setHotspot(kHSWalkArea1, 0, 0, 170, 600); + setHotspot(kHSWalkArea2, 622, 0, 800, 600); + setHotspot(kHSWalkArea3, 0, 0, 800, 437); + setDeviceHotspot(kHSDevice, -1, -1, -1, -1); + if (isFlag(26)) { + _hotspots[kHSToy1].flags = SF_DISABLED; + _hotspots[kHSToy2].flags = SF_DISABLED; + _hotspots[kHSToy3].flags = SF_DISABLED; + _hotspots[kHSToy4].flags = SF_DISABLED; + _hotspots[kHSToy5].flags = SF_DISABLED; + _hotspots[kHSToy6].flags = SF_DISABLED; + _hotspots[kHSToy7].flags = SF_DISABLED; + _hotspots[kHSShopAssistant].flags = SF_DISABLED; + _hotspots[kHSPhone].flags = SF_DISABLED; + _hotspots[kHSPlatypus].flags = SF_DISABLED; + _hotspots[kHSPicture].flags = SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR; + } + _hotspotsCount = 16; +} + +void GnapEngine::scene19_run() { + + queueInsertDeviceIcon(); + + _s19_toyGrabCtr = 0; + _s19_pictureSurface = 0; + + _gameSys->insertSequence(0x74, 254, 0, 0, kSeqNone, 0, 0, 0); + _gameSys->insertSequence(0x75, 254, 0, 0, kSeqNone, 0, 0, 0); + + if (!isFlag(20)) + _gameSys->insertSequence(0x69, 19, 0, 0, kSeqNone, 0, 0, 0); + + if (isFlag(26)) { + initGnapPos(3, 6, 1); + _s19_currShopAssistantSequenceId = kS19ShopAssistantSequenceIds[getRandom(5)]; + _s19_nextShopAssistantSequenceId = _s19_currShopAssistantSequenceId; + _gameSys->setAnimation(_s19_currShopAssistantSequenceId, 20, 4); + _gameSys->insertSequence(0x6E, 254, 0, 0, kSeqNone, 0, 0, 0); + _gameSys->insertSequence(_s19_currShopAssistantSequenceId, 20, 0, 0, kSeqNone, 0, 0, 0); + _s19_shopAssistantCtr = 0; + endSceneInit(); + gnapWalkTo(4, 9, -1, 0x107B9, 1); + scene19_updateHotspots(); + } else { + _s19_currShopAssistantSequenceId = 0x6D; + _s19_nextShopAssistantSequenceId = -1; + _gameSys->setAnimation(0x6D, 20, 4); + _gameSys->insertSequence(_s19_currShopAssistantSequenceId, 20, 0, 0, kSeqNone, 0, 0, 0); + _timers[6] = getRandom(40) + 50; + initGnapPos(3, 6, 1); + initBeaverPos(4, 6, 0); + endSceneInit(); + gnapWalkTo(4, 9, -1, 0x107B9, 1); + platypusWalkTo(5, 9, -1, 0x107C2, 1); + } + + while (!_sceneDone) { + + updateMouseCursor(); + updateCursorByHotspot(); + + testWalk(0, 5, -1, -1, -1, -1); + + _sceneClickedHotspot = getClickedHotspotId(); + updateGrabCursorSprite(0, 0); + + switch (_sceneClickedHotspot) { + + case kHSDevice: + if (_gnapActionStatus < 0) { + runMenu(); + scene19_updateHotspots(); + } + break; + + case kHSPlatypus: + if (_gnapActionStatus < 0) { + if (_grabCursorSpriteIndex == kItemJoint) { + gnapUseJointOnPlatypus(); + } else if (_grabCursorSpriteIndex >= 0) { + playGnapImpossible(_platX, _platY); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapMoan1(_platX, _platY); + break; + case GRAB_CURSOR: + gnapKissPlatypus(0); + break; + case TALK_CURSOR: + playGnapBrainPulsating(_platX, _platY); + playBeaverSequence(getBeaverSequenceId(0, 0, 0) | 0x10000); + break; + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + } + break; + + case kHSExitOutsideToyStore: + if (_gnapActionStatus < 0) { + _isLeavingScene = true; + _newSceneNum = 18; + _hotspots[kHSWalkArea1].flags |= SF_WALKABLE; + gnapWalkTo(_hotspotsWalkPos[1].x, _hotspotsWalkPos[1].y, 0, 0x107B2, 1); + _gnapActionStatus = kASLeaveScene; + if (isFlag(26)) + setFlag(27); + else + platypusWalkTo(_hotspotsWalkPos[1].x + 1, _hotspotsWalkPos[1].y, -1, 0x107C5, 1); + _hotspots[kHSWalkArea1].flags &= ~SF_WALKABLE; + } + break; + + case kHSPicture: + if (_gnapActionStatus < 0) { + if (_grabCursorSpriteIndex >= 0) { + playGnapShowCurrItem(_hotspotsWalkPos[_sceneClickedHotspot].x, _hotspotsWalkPos[_sceneClickedHotspot].y, 6, 2); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapScratchingHead(6, 2); + break; + case GRAB_CURSOR: + if (!isFlag(20)) { + gnapWalkTo(_gnapX, _gnapY, 0, getGnapSequenceId(gskIdle, _hotspotsWalkPos[_sceneClickedHotspot].x, _hotspotsWalkPos[_sceneClickedHotspot].y) | 0x10000, 1); + _gnapActionStatus = kASGrabPicture; + } + break; + case TALK_CURSOR: + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + } + break; + + case kHSShopAssistant: + if (_gnapActionStatus < 0) { + if (_grabCursorSpriteIndex >= 0) { + playGnapShowCurrItem(_hotspotsWalkPos[_sceneClickedHotspot].x, _hotspotsWalkPos[_sceneClickedHotspot].y, 6, 2); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapScratchingHead(6, 2); + break; + case TALK_CURSOR: + _gnapIdleFacing = 7; + gnapWalkTo(_hotspotsWalkPos[_sceneClickedHotspot].x, _hotspotsWalkPos[_sceneClickedHotspot].y, 0, getGnapSequenceId(gskBrainPulsating, 0, 0) | 0x10000, 1); + _gnapActionStatus = kASTalkShopAssistant; + break; + case GRAB_CURSOR: + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + } + break; + + case kHSToy1: + case kHSToy2: + case kHSToy3: + case kHSToy4: + case kHSToy5: + case kHSToy6: + case kHSToy7: + if (_gnapActionStatus < 0) { + if (_grabCursorSpriteIndex >= 0) { + playGnapImpossible(_hotspotsWalkPos[_sceneClickedHotspot].x, _hotspotsWalkPos[_sceneClickedHotspot].y); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapMoan2(_hotspotsWalkPos[_sceneClickedHotspot].x, _hotspotsWalkPos[_sceneClickedHotspot].y); + break; + case GRAB_CURSOR: + gnapWalkTo(_hotspotsWalkPos[_sceneClickedHotspot].x, _hotspotsWalkPos[_sceneClickedHotspot].y, 0, -1, 1); + playGnapIdle(_hotspotsWalkPos[_sceneClickedHotspot].x, _hotspotsWalkPos[_sceneClickedHotspot].y); + _gnapActionStatus = kASGrabToy; + break; + case TALK_CURSOR: + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + } + break; + + case kHSPhone: + if (_gnapActionStatus < 0) { + if (_grabCursorSpriteIndex >= 0) { + playGnapShowCurrItem(_hotspotsWalkPos[_sceneClickedHotspot].x, _hotspotsWalkPos[_sceneClickedHotspot].y, 9, 1); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapScratchingHead(9, 1); + break; + case GRAB_CURSOR: + gnapWalkTo(_hotspotsWalkPos[_sceneClickedHotspot].x, _hotspotsWalkPos[_sceneClickedHotspot].y, 0, -1, 1); + playGnapIdle(8, 2); + _gnapActionStatus = kASUsePhone; + break; + case TALK_CURSOR: + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + } + break; + + case kHSWalkArea1: + case kHSWalkArea2: + case kHSWalkArea3: + if (_gnapActionStatus < 0) + gnapWalkTo(-1, -1, -1, -1, 1); + break; + + default: + if (_mouseClickState.left) { + gnapWalkTo(-1, -1, -1, -1, 1); + _mouseClickState.left = 0; + } + } + + scene19_updateAnimations(); + + if (!_isLeavingScene) { + updateGnapIdleSequence(); + if (!isFlag(26)) { + updateBeaverIdleSequence(); + if (!_timers[6] && _s19_nextShopAssistantSequenceId == -1) { + _timers[6] = getRandom(40) + 50; + if (getRandom(4) != 0) { + _s19_nextShopAssistantSequenceId = 0x64; + } else if (isFlag(20)) { + _s19_nextShopAssistantSequenceId = 0x64; + } else { + _s19_nextShopAssistantSequenceId = 0x6C; + } + } + } + } + + checkGameKeys(); + + if (isKeyStatus1(8)) { + clearKeyStatus1(8); + runMenu(); + scene19_updateHotspots(); + } + + gameUpdateTick(); + + } + + if (_s19_pictureSurface) + deleteSurface(&_s19_pictureSurface); + +} + +void GnapEngine::scene19_updateAnimations() { + + if (_gameSys->getAnimationStatus(0) == 2) { + _gameSys->setAnimation(0, 0, 0); + switch (_gnapActionStatus) { + case kASUsePhone: + _s19_nextShopAssistantSequenceId = 0x67; + break; + case kASGrabToy: + ++_s19_toyGrabCtr; + switch (_s19_toyGrabCtr) { + case 1: + _s19_nextShopAssistantSequenceId = 0x62; + break; + case 2: + _s19_nextShopAssistantSequenceId = 0x6B; + break; + case 3: + _s19_nextShopAssistantSequenceId = 0x66; + break; + default: + _s19_nextShopAssistantSequenceId = 0x65; + break; + } + break; + case kASGrabPicture: + playGnapPullOutDevice(6, 2); + playGnapUseDevice(0, 0); + _gameSys->setAnimation(0x68, 19, 0); + _gameSys->insertSequence(0x68, 19, 105, 19, kSeqSyncWait, 0, 0, 0); + invAdd(kItemPicture); + setFlag(20); + scene19_updateHotspots(); + _gnapActionStatus = kASGrabPictureDone; + break; + case kASGrabPictureDone: + setGrabCursorSprite(-1); + hideCursor(); + _s19_pictureSurface = addFullScreenSprite(0xF, 255); + _gameSys->setAnimation(0x61, 256, 0); + _gameSys->insertSequence(0x61, 256, 0, 0, kSeqNone, 0, 0, 0); + while (_gameSys->getAnimationStatus(0) != 2) { + // checkGameAppStatus(); + gameUpdateTick(); + } + setFlag(27); + showCursor(); + _newSceneNum = 17; + _isLeavingScene = true; + _sceneDone = true; + _s19_nextShopAssistantSequenceId = -1; + break; + case kASTalkShopAssistant: + _s19_nextShopAssistantSequenceId = 0x6D; + _gnapActionStatus = -1; + break; + case kASLeaveScene: + _sceneDone = true; + break; + } + } + + if (_gameSys->getAnimationStatus(4) == 2) { + switch (_s19_nextShopAssistantSequenceId) { + case 0x6F: + case 0x70: + case 0x71: + case 0x72: + case 0x73: + _s19_shopAssistantCtr = (_s19_shopAssistantCtr + 1) % 5; + _s19_nextShopAssistantSequenceId = kS19ShopAssistantSequenceIds[_s19_shopAssistantCtr]; + _gameSys->setAnimation(_s19_nextShopAssistantSequenceId, 20, 4); + _gameSys->insertSequence(_s19_nextShopAssistantSequenceId, 20, _s19_currShopAssistantSequenceId, 20, kSeqSyncWait, 0, 0, 0); + _gameSys->insertSequence(0x6E, 254, 0x6E, 254, kSeqSyncWait, 0, 0, 0); + _s19_currShopAssistantSequenceId = _s19_nextShopAssistantSequenceId; + break; + case 0x62: + case 0x66: + case 0x6B: + _gameSys->setAnimation(_s19_nextShopAssistantSequenceId, 20, 4); + _gameSys->insertSequence(_s19_nextShopAssistantSequenceId, 20, _s19_currShopAssistantSequenceId, 20, kSeqSyncWait, 0, 0, 0); + _s19_currShopAssistantSequenceId = _s19_nextShopAssistantSequenceId; + _s19_nextShopAssistantSequenceId = -1; + _timers[5] = 10; + while (_timers[5]) { + gameUpdateTick(); + } + playGnapIdle(6, 2); + _gnapActionStatus = -1; + break; + case 0x67: + _gameSys->setAnimation(_s19_nextShopAssistantSequenceId, 20, 4); + _gameSys->insertSequence(_s19_nextShopAssistantSequenceId, 20, _s19_currShopAssistantSequenceId, 20, kSeqSyncWait, 0, 0, 0); + _s19_currShopAssistantSequenceId = _s19_nextShopAssistantSequenceId; + _s19_nextShopAssistantSequenceId = -1; + _gnapActionStatus = -1; + break; + case 0x65: + playGnapIdle(6, 2); + _gameSys->setAnimation(_s19_nextShopAssistantSequenceId, 20, 0); + _gameSys->insertSequence(_s19_nextShopAssistantSequenceId, 20, _s19_currShopAssistantSequenceId, 20, kSeqSyncWait, 0, 0, 0); + _s19_currShopAssistantSequenceId = _s19_nextShopAssistantSequenceId; + _s19_nextShopAssistantSequenceId = -1; + _newSceneNum = 18; + _gnapActionStatus = kASLeaveScene; + break; + case 0x6D: + _gameSys->setAnimation(_s19_nextShopAssistantSequenceId, 20, 4); + _gameSys->insertSequence(_s19_nextShopAssistantSequenceId, 20, _s19_currShopAssistantSequenceId, 20, kSeqSyncWait, 0, 0, 0); + _gameSys->insertSequence(0x69, 19, 0x69, 19, kSeqSyncWait, getSequenceTotalDuration(_s19_nextShopAssistantSequenceId), 0, 0); + _s19_currShopAssistantSequenceId = _s19_nextShopAssistantSequenceId; + _s19_nextShopAssistantSequenceId = -1; + break; + case 0x64: + case 0x6C: + _gameSys->setAnimation(_s19_nextShopAssistantSequenceId, 20, 4); + _gameSys->insertSequence(_s19_nextShopAssistantSequenceId, 20, _s19_currShopAssistantSequenceId, 20, kSeqSyncWait, 0, 0, 0); + _s19_currShopAssistantSequenceId = _s19_nextShopAssistantSequenceId; + _s19_nextShopAssistantSequenceId = -1; + break; + } + } + +} + +} // End of namespace Gnap diff --git a/engines/gnap/scenes/scene20.cpp b/engines/gnap/scenes/scene20.cpp new file mode 100644 index 0000000000..136f234bce --- /dev/null +++ b/engines/gnap/scenes/scene20.cpp @@ -0,0 +1,736 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "gnap/gnap.h" +#include "gnap/gamesys.h" +#include "gnap/resource.h" + +namespace Gnap { + +enum { + kHSPlatypus = 0, + kHSGroceryStoreHat = 1, + kHSExitParkingLot = 2, + kHSStonerGuy = 3, + kHSGroceryStoreGuy = 4, + kHSDevice = 5, + kHSExitInsideGrubCity = 6, + kHSExitOutsideCircusWorld = 7, + kHSExitOutsideToyStore = 8, + kHSExitPhone = 9, + kHSWalkArea1 = 10, + kHSWalkArea2 = 11 +}; + +enum { + kASLeaveScene = 0, + kASTalkStonerGuyNoJoint = 2, + kASTalkStonerGuyHasJoint = 3, + kASGrabJoint = 4, + kASActionDone = 5, + kASTalkGroceryStoreGuy = 6, + kASGrabGroceryStoreGuy = 9, + kASGrabGroceryStoreHat = 10, + kASSwitchGroceryStoreHat = 11, + kASSwitchGroceryStoreHatDone = 12, + kASGrabJointDone = 13 +}; + +int GnapEngine::scene20_init() { + return 0x186; +} + +void GnapEngine::scene20_updateHotspots() { + setHotspot(kHSPlatypus, 0, 0, 0, 0, SF_WALKABLE | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSGroceryStoreHat, 114, 441, 174, 486, SF_WALKABLE | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR, 0, 7); + setHotspot(kHSExitParkingLot, 0, 300, 15, 600, SF_EXIT_L_CURSOR | SF_WALKABLE, 0, 7); + setHotspot(kHSStonerGuy, 276, 290, 386, 450, SF_WALKABLE | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR, 3, 8); + setHotspot(kHSGroceryStoreGuy, 123, 282, 258, 462, SF_WALKABLE | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR, 3, 7); + setHotspot(kHSExitInsideGrubCity, 519, 250, 581, 413, SF_EXIT_L_CURSOR, 8, 7); + setHotspot(kHSExitOutsideCircusWorld, 660, 222, 798, 442, SF_EXIT_NE_CURSOR, 9, 6); + setHotspot(kHSExitOutsideToyStore, 785, 350, 800, 600, SF_EXIT_R_CURSOR, 11, 8); + setHotspot(kHSExitPhone, 250, 585, 650, 600, SF_EXIT_D_CURSOR | SF_WALKABLE, 5, 10); + setHotspot(kHSWalkArea1, 0, 0, 800, 468); + setHotspot(kHSWalkArea2, 605, 0, 800, 600); + setDeviceHotspot(kHSDevice, -1, -1, -1, -1); + _hotspotsCount = 12; +} + +void GnapEngine::scene20_updateAnimationsCb() { + + if (_gameSys->getAnimationStatus(2) == 2) { + switch (_s20_nextStonerGuySequenceId) { + case 0x16B: + if (!_timers[4]) { + _s20_stonerGuyShowingJoint = false; + _gameSys->insertSequence(0x16B, 21, _s20_currStonerGuySequenceId, 21, kSeqSyncWait, 0, 0, 0); + _s20_currStonerGuySequenceId = 0x16B; + _s20_nextStonerGuySequenceId = -1; + } + break; + case 0x16A: + // Grab joint + playGnapPullOutDevice(4, 4); + playGnapUseDevice(0, 0); + _gameSys->setAnimation(0x16A, 21, 0); + _gameSys->insertSequence(0x16A, 21, _s20_currStonerGuySequenceId, 21, kSeqSyncWait, 0, 0, 0); + _s20_currStonerGuySequenceId = 0x16A; + _s20_nextStonerGuySequenceId = -1; + invAdd(kItemJoint); + setFlag(17); + _s20_stonerGuyShowingJoint = false; + _gnapActionStatus = kASGrabJointDone; + break; + case 0x16E: + _gameSys->setAnimation(0x16E, 21, 2); + _gameSys->insertSequence(0x16E, 21, _s20_currStonerGuySequenceId, 21, kSeqSyncWait, 0, 0, 0); + _s20_currStonerGuySequenceId = 0x16E; + _s20_nextStonerGuySequenceId = -1; + _s20_nextGroceryStoreGuySequenceId = 0x175; + break; + case 0x16D: + _gameSys->setAnimation(_s20_nextStonerGuySequenceId, 21, 2); + _gameSys->setAnimation(_s20_nextStonerGuySequenceId, 21, 0); + _gameSys->insertSequence(_s20_nextStonerGuySequenceId, 21, _s20_currStonerGuySequenceId, 21, kSeqSyncWait, 0, 0, 0); + _s20_currStonerGuySequenceId = _s20_nextStonerGuySequenceId; + _s20_nextStonerGuySequenceId = -1; + _gnapActionStatus = kASActionDone; + break; + case 0x16F: + _gameSys->setAnimation(_s20_nextStonerGuySequenceId, 21, 2); + _gameSys->setAnimation(0x17A, 20, 3); + _gameSys->insertSequence(_s20_nextStonerGuySequenceId, 21, _s20_currStonerGuySequenceId, 21, kSeqSyncWait, 0, 0, 0); + _gameSys->insertSequence(0x17A, 20, _s20_currGroceryStoreGuySequenceId, 20, kSeqSyncWait, 0, 0, 0); + _s20_currGroceryStoreGuySequenceId = 0x17A; + _s20_nextGroceryStoreGuySequenceId = -1; + _s20_currStonerGuySequenceId = _s20_nextStonerGuySequenceId; + _s20_nextStonerGuySequenceId = -1; + break; + case 0x171: + _s20_stonerGuyCtr = (_s20_stonerGuyCtr + 1) % 3; + switch (_s20_stonerGuyCtr) { + case 1: + _s20_nextStonerGuySequenceId = 0x171; + break; + case 2: + _s20_nextStonerGuySequenceId = 0x172; + break; + case 3: + _s20_nextStonerGuySequenceId = 0x173; + break; + default: + _s20_nextStonerGuySequenceId = 0x171; + break; + } + _gameSys->insertSequence(_s20_nextStonerGuySequenceId, 21, _s20_currStonerGuySequenceId, 21, kSeqSyncWait, 0, 0, 0); + _gameSys->insertSequence(0x17C, 20, _s20_currGroceryStoreGuySequenceId, 20, kSeqSyncWait, 0, 0, 0); + _gameSys->setAnimation(0x17C, 20, 3); + _gameSys->setAnimation(_s20_nextStonerGuySequenceId, 21, 2); + _s20_currGroceryStoreGuySequenceId = 0x17C; + _s20_nextGroceryStoreGuySequenceId = -1; + _s20_currStonerGuySequenceId = _s20_nextStonerGuySequenceId; + _s20_nextStonerGuySequenceId = -1; + break; + default: + _s20_nextStonerGuySequenceId = 0x16C; + _gameSys->setAnimation(0x16C, 21, 2); + _gameSys->insertSequence(_s20_nextStonerGuySequenceId, 21, _s20_currStonerGuySequenceId, 21, kSeqSyncWait, 0, 0, 0); + _s20_currStonerGuySequenceId = _s20_nextStonerGuySequenceId; + _s20_nextStonerGuySequenceId = -1; + break; + } + } + +} + +void GnapEngine::scene20_stopSounds() { + stopSound(0x18E); + stopSound(0x18F); + stopSound(0x190); + stopSound(0x191); + stopSound(0x194); + stopSound(0x195); + stopSound(0x192); + stopSound(0x193); + stopSound(0x196); + stopSound(0x197); + stopSound(0x198); + stopSound(0x199); + stopSound(0x19A); +} + +void GnapEngine::scene20_run() { + + playSound(0x10940, 1); + + startSoundTimerA(8); + + _s20_stonerGuyShowingJoint = false; + _timers[7] = getRandom(100) + 100; + + _s20_stonerGuyCtr = (_s20_stonerGuyCtr + 1) % 3; + switch (_s20_stonerGuyCtr) { + case 1: + _s20_currStonerGuySequenceId = 0x171; + break; + case 2: + _s20_currStonerGuySequenceId = 0x172; + break; + case 3: + _s20_currStonerGuySequenceId = 0x173; + break; + } + + _s20_nextStonerGuySequenceId = -1; + _gameSys->setAnimation(_s20_currStonerGuySequenceId, 21, 2); + _gameSys->insertSequence(_s20_currStonerGuySequenceId, 21, 0, 0, kSeqNone, 0, 0, 0); + + _timers[6] = getRandom(20) + 30; + + _s20_currGroceryStoreGuySequenceId = 0x17C; + _s20_nextGroceryStoreGuySequenceId = -1; + _gameSys->setAnimation(0x17C, 20, 3); + _gameSys->insertSequence(0x17C, 20, 0, 0, kSeqNone, 0, 0, 0); + + _timers[5] = getRandom(50) + 130; + if (isFlag(19)) + _gameSys->insertSequence(0x17F, 20, 0, 0, kSeqNone, 0, 0, 0); + else + _gameSys->insertSequence(0x174, 20, 0, 0, kSeqNone, 0, 0, 0); + + queueInsertDeviceIcon(); + + if (isFlag(11)) { + clearFlag(11); + endSceneInit(); + _gameSys->setAnimation(0x182, 140, 0); + _gameSys->insertSequence(0x182, 140, 0, 0, kSeqNone, 0, 0, 0); + while (_gameSys->getAnimationStatus(0) != 2) { + // checkGameAppStatus(); + gameUpdateTick(); + } + initGnapPos(11, 8, 3); + initBeaverPos(11, 9, 4); + gnapWalkTo(5, 8, -1, 0x107BA, 1); + platypusWalkTo(6, 9, -1, 0x107C2, 1); + } else { + switch (_prevSceneNum) { + case 17: + initGnapPos(5, 11, 1); + initBeaverPos(6, 11, 0); + endSceneInit(); + gnapWalkTo(5, 8, -1, 0x107B9, 1); + platypusWalkTo(6, 9, -1, 0x107C2, 1); + break; + case 18: + initGnapPos(11, 8, 3); + initBeaverPos(11, 9, 4); + endSceneInit(); + gnapWalkTo(5, 8, -1, 0x107BA, 1); + platypusWalkTo(6, 9, -1, 0x107C2, 1); + break; + case 21: + initGnapPos(-1, 8, 3); + initBeaverPos(-1, 9, 4); + endSceneInit(); + gnapWalkTo(3, 8, -1, 0x107B9, 1); + platypusWalkTo(3, 9, -1, 0x107C2, 1); + break; + case 22: + initGnapPos(7, 6, 1); + initBeaverPos(8, 6, 0); + endSceneInit(); + gnapWalkTo(8, 8, -1, 0x107B9, 1); + platypusWalkTo(9, 9, -1, 0x107C2, 1); + break; + default: + initGnapPos(8, 6, 3); + initBeaverPos(9, 6, 4); + endSceneInit(); + _hotspots[kHSWalkArea2].flags |= SF_WALKABLE; + gnapWalkTo(8, 8, -1, 0x107BA, 1); + platypusWalkTo(9, 9, -1, 0x107C2, 1); + _hotspots[kHSWalkArea2].flags &= ~SF_WALKABLE; + break; + } + } + + while (!_sceneDone) { + + updateMouseCursor(); + updateCursorByHotspot(); + + testWalk(0, 0, -1, -1, -1, -1); + testWalk(0, 1, 7, 9, 8, 9); + + _sceneClickedHotspot = getClickedHotspotId(); + updateGrabCursorSprite(0, 0); + + switch (_sceneClickedHotspot) { + + case kHSDevice: + if (_gnapActionStatus < 0) { + runMenu(); + scene20_updateHotspots(); + } + break; + + case kHSPlatypus: + if (_gnapActionStatus < 0) { + if (_grabCursorSpriteIndex == kItemJoint) { + gnapUseJointOnPlatypus(); + } else if (_grabCursorSpriteIndex >= 0) { + playGnapImpossible(0, 0); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapScratchingHead(_platX, _platY); + break; + case GRAB_CURSOR: + gnapKissPlatypus(20); + break; + case TALK_CURSOR: + playGnapBrainPulsating(_platX, _platY); + playBeaverSequence(getBeaverSequenceId(0, 0, 0) | 0x10000); + break; + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + } + break; + + case kHSExitParkingLot: + if (_gnapActionStatus < 0) { + if (_s20_stonerGuyShowingJoint) + _timers[4] = 0; + _isLeavingScene = 1; + _newSceneNum = 21; + gnapWalkTo(_hotspotsWalkPos[kHSExitParkingLot].x, _hotspotsWalkPos[kHSExitParkingLot].y, 0, 0x107AF, 1); + _gnapActionStatus = kASLeaveScene; + platypusWalkTo(_hotspotsWalkPos[kHSExitParkingLot].x, _hotspotsWalkPos[kHSExitParkingLot].y + 1, -1, 0x107CF, 1); + _beaverFacing = 4; + } + break; + + case kHSExitPhone: + if (_gnapActionStatus < 0) { + if (_s20_stonerGuyShowingJoint) + _timers[4] = 0; + _isLeavingScene = 1; + _newSceneNum = 17; + gnapWalkTo(_hotspotsWalkPos[kHSExitPhone].x, _hotspotsWalkPos[kHSExitPhone].y, 0, 0x107AE, 1); + _gnapActionStatus = kASLeaveScene; + platypusWalkTo(_hotspotsWalkPos[kHSExitPhone].x + 1, _hotspotsWalkPos[kHSExitPhone].y, -1, 0x107C2, 1); + } + break; + + case kHSExitOutsideToyStore: + if (_gnapActionStatus < 0) { + if (_s20_stonerGuyShowingJoint) + _timers[4] = 0; + _isLeavingScene = 1; + _newSceneNum = 18; + _hotspots[kHSWalkArea2].flags |= SF_WALKABLE; + gnapWalkTo(_hotspotsWalkPos[kHSExitOutsideToyStore].x, _hotspotsWalkPos[kHSExitOutsideToyStore].y, 0, 0x107AB, 1); + _gnapActionStatus = kASLeaveScene; + platypusWalkTo(_hotspotsWalkPos[kHSExitOutsideToyStore].x, _hotspotsWalkPos[kHSExitOutsideToyStore].y + 1, -1, 0x107CD, 1); + _hotspots[kHSWalkArea2].flags &= ~SF_WALKABLE; + } + break; + + case kHSExitInsideGrubCity: + if (_gnapActionStatus < 0) { + if (_s20_stonerGuyShowingJoint) + _timers[4] = 0; + _isLeavingScene = 1; + _newSceneNum = 22; + gnapWalkTo(_hotspotsWalkPos[kHSExitInsideGrubCity].x, _hotspotsWalkPos[kHSExitInsideGrubCity].y - 1, 0, 0x107BB, 1); + _gnapActionStatus = kASLeaveScene; + platypusWalkTo(_hotspotsWalkPos[kHSExitInsideGrubCity].x + 1, _hotspotsWalkPos[kHSExitInsideGrubCity].y, -1, 0x107C2, 1); + _beaverFacing = 4; + } + break; + + case kHSExitOutsideCircusWorld: + if (_gnapActionStatus < 0) { + if (_s20_stonerGuyShowingJoint) + _timers[4] = 0; + _isLeavingScene = 1; + _newSceneNum = 24; + gnapWalkTo(_hotspotsWalkPos[kHSExitOutsideCircusWorld].x, _hotspotsWalkPos[kHSExitOutsideCircusWorld].y, 0, 0x107BB, 1); + _gnapActionStatus = kASLeaveScene; + platypusWalkTo(_hotspotsWalkPos[kHSExitOutsideCircusWorld].x + 1, _hotspotsWalkPos[kHSExitOutsideCircusWorld].y, -1, 0x107C2, 1); + } + break; + + case kHSStonerGuy: + if (_gnapActionStatus < 0) { + if (_grabCursorSpriteIndex >= 0) { + playGnapShowCurrItem(_hotspotsWalkPos[kHSStonerGuy].x, _hotspotsWalkPos[kHSStonerGuy].y, 5, 4); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapMoan2(5, 4); + break; + case GRAB_CURSOR: + _gnapIdleFacing = 7; + gnapWalkTo(_hotspotsWalkPos[kHSStonerGuy].x, _hotspotsWalkPos[kHSStonerGuy].y, 0, getGnapSequenceId(gskIdle, 0, 0) | 0x10000, 1); + if (_s20_stonerGuyShowingJoint) + _gnapActionStatus = kASGrabJoint; + else + playGnapImpossible(0, 0); + break; + case TALK_CURSOR: + _gnapIdleFacing = 7; + gnapWalkTo(_hotspotsWalkPos[kHSStonerGuy].x, _hotspotsWalkPos[kHSStonerGuy].y, 0, getGnapSequenceId(gskBrainPulsating, 0, 0) | 0x10000, 1); + if (isFlag(17)) + _gnapActionStatus = kASTalkStonerGuyNoJoint; + else + _gnapActionStatus = kASTalkStonerGuyHasJoint; + break; + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + } + break; + + case kHSGroceryStoreGuy: + if (_gnapActionStatus < 0) { + if (_grabCursorSpriteIndex >= 0) { + playGnapShowCurrItem(_hotspotsWalkPos[kHSGroceryStoreGuy].x, _hotspotsWalkPos[kHSGroceryStoreGuy].y, 2, 4); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapScratchingHead(2, 3); + break; + case GRAB_CURSOR: + _s20_stonerGuyShowingJoint = false; + _gnapIdleFacing = 5; + gnapWalkTo(_hotspotsWalkPos[kHSGroceryStoreGuy].x, _hotspotsWalkPos[kHSGroceryStoreGuy].y, 0, getGnapSequenceId(gskIdle, 0, 0) | 0x10000, 1); + _gnapActionStatus = kASGrabGroceryStoreGuy; + break; + case TALK_CURSOR: + _gnapIdleFacing = 5; + gnapWalkTo(_hotspotsWalkPos[kHSGroceryStoreGuy].x, _hotspotsWalkPos[kHSGroceryStoreGuy].y, 0, getGnapSequenceId(gskBrainPulsating, 0, 0) | 0x10000, 1); + _gnapActionStatus = kASTalkGroceryStoreGuy; + break; + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + } + break; + + case kHSGroceryStoreHat: + if (_gnapActionStatus < 0) { + if (_grabCursorSpriteIndex == kItemCowboyHat) { + _gnapIdleFacing = 7; + gnapWalkTo(_hotspotsWalkPos[kHSGroceryStoreHat].x, _hotspotsWalkPos[kHSGroceryStoreHat].y, 0, getGnapSequenceId(gskIdle, 0, 0) | 0x10000, 1); + _gnapActionStatus = kASSwitchGroceryStoreHat; + } else if (_grabCursorSpriteIndex >= 0) { + playGnapShowCurrItem(_hotspotsWalkPos[kHSGroceryStoreHat].x, _hotspotsWalkPos[kHSGroceryStoreHat].y, 1, 6); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapScratchingHead(1, 6); + break; + case GRAB_CURSOR: + _s20_stonerGuyShowingJoint = false; + _gnapIdleFacing = 5; + gnapWalkTo(_hotspotsWalkPos[kHSGroceryStoreGuy].x, _hotspotsWalkPos[kHSGroceryStoreGuy].y, 0, getGnapSequenceId(gskIdle, 0, 0) | 0x10000, 1); + _gnapActionStatus = kASGrabGroceryStoreHat; + break; + case TALK_CURSOR: + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + } + break; + + case kHSWalkArea1: + case kHSWalkArea2: + gnapWalkTo(-1, -1, -1, -1, 1); + break; + + default: + if (_mouseClickState.left) { + gnapWalkTo(-1, -1, -1, -1, 1); + _mouseClickState.left = false; + } + break; + + } + + scene20_updateAnimations(); + + if (!isSoundPlaying(0x10940)) + playSound(0x10940, 1); + + if (!_isLeavingScene) { + if (_beaverActionStatus < 0) { + _hotspots[kHSWalkArea1].y2 += 48; + updateBeaverIdleSequence(); + _hotspots[kHSWalkArea1].y2 -= 48; + } + if (_gnapActionStatus < 0) + updateGnapIdleSequence(); + if (_gnapActionStatus < 0 && !_timers[5] && _s20_nextGroceryStoreGuySequenceId == -1) { + _timers[5] = getRandom(50) + 130; + if (getRandom(4) != 0) + _s20_nextGroceryStoreGuySequenceId = 0x17C; + else + _s20_nextGroceryStoreGuySequenceId = 0x17A; + } + if (!_timers[7]) { + _timers[7] = getRandom(100) + 100; + if (_gnapActionStatus < 0 && _beaverActionStatus < 0) { + switch (getRandom(3)) { + case 0: + _gameSys->insertSequence(0x183, 253, 0, 0, kSeqNone, 0, 0, 0); + break; + case 1: + _gameSys->insertSequence(0x184, 253, 0, 0, kSeqNone, 0, 0, 0); + break; + case 2: + _gameSys->insertSequence(0x185, 253, 0, 0, kSeqNone, 0, 0, 0); + break; + } + } + } + playSoundA(); + } + + checkGameKeys(); + + if (isKeyStatus1(8)) { + clearKeyStatus1(8); + runMenu(); + scene20_updateHotspots(); + } + + gameUpdateTick(); + + } + +} + +void GnapEngine::scene20_updateAnimations() { + + if (_gameSys->getAnimationStatus(0) == 2) { + _gameSys->setAnimation(0, 0, 0); + switch (_gnapActionStatus) { + case kASLeaveScene: + _sceneDone = true; + break; + case kASTalkStonerGuyNoJoint: + _gameSys->setAnimation(0x170, 21, 2); + _gameSys->setAnimation(0x17B, 20, 3); + _gameSys->insertSequence(0x17B, 20, _s20_currGroceryStoreGuySequenceId, 20, 32, 0, 0, 0); + _gameSys->insertSequence(0x170, 21, _s20_currStonerGuySequenceId, 21, 32, 0, 0, 0); + stopSound(0x1A1); + scene20_stopSounds(); + _s20_currGroceryStoreGuySequenceId = 0x17B; + _s20_currStonerGuySequenceId = 0x170; + _s20_nextGroceryStoreGuySequenceId = -1; + _s20_nextStonerGuySequenceId = 0x16E; + _timers[5] = 100; + _timers[6] = 100; + break; + case kASTalkStonerGuyHasJoint: + _gameSys->setAnimation(0x168, 21, 2); + _gameSys->setAnimation(379, 20, 3); + _gameSys->insertSequence(0x17B, 20, _s20_currGroceryStoreGuySequenceId, 20, 32, 0, 0, 0); + _gameSys->insertSequence(0x170, 21, _s20_currStonerGuySequenceId, 21, 32, 0, 0, 0); + _gameSys->insertSequence(0x168, 21, 0x170, 21, kSeqSyncWait, 0, 0, 0); + stopSound(0x1A1); + scene20_stopSounds(); + _s20_currGroceryStoreGuySequenceId = 0x17B; + _s20_currStonerGuySequenceId = 0x168; + _s20_nextGroceryStoreGuySequenceId = -1; + _s20_nextStonerGuySequenceId = 0x16B; + _timers[5] = 200; + _timers[6] = 200; + _timers[4] = 100; + _s20_stonerGuyShowingJoint = true; + _gnapActionStatus = -1; + break; + case kASGrabJoint: + _s20_nextStonerGuySequenceId = 0x16A; + break; + case kASActionDone: + _gnapActionStatus = -1; + break; + case kASTalkGroceryStoreGuy: + _gameSys->setAnimation(0x170, 21, 2); + _gameSys->setAnimation(0x17B, 20, 3); + _gameSys->insertSequence(0x17B, 20, _s20_currGroceryStoreGuySequenceId, 20, 32, 0, 0, 0); + _gameSys->insertSequence(0x170, 21, _s20_currStonerGuySequenceId, 21, 32, 0, 0, 0); + stopSound(0x1A1); + scene20_stopSounds(); + _s20_currGroceryStoreGuySequenceId = 0x17B; + _s20_currStonerGuySequenceId = 0x170; + _s20_groceryStoreGuyCtr = (_s20_groceryStoreGuyCtr + 1) % 2; + if (_s20_groceryStoreGuyCtr != 0) + _s20_nextGroceryStoreGuySequenceId = 0x176; + else + _s20_nextGroceryStoreGuySequenceId = 0x177; + _timers[5] = 100; + _timers[6] = 100; + break; + case kASGrabGroceryStoreGuy: + _gameSys->setAnimation(0x170, 21, 2); + _gameSys->setAnimation(0x17B, 20, 3); + _gameSys->insertSequence(0x170, 21, _s20_currStonerGuySequenceId, 21, 32, 0, 0, 0); + _gameSys->insertSequence(0x17B, 20, _s20_currGroceryStoreGuySequenceId, 20, 32, 0, 0, 0); + stopSound(0x1A1); + scene20_stopSounds(); + _s20_currGroceryStoreGuySequenceId = 0x17B; + _s20_currStonerGuySequenceId = 0x170; + _timers[5] = 120; + _timers[6] = 120; + _s20_nextGroceryStoreGuySequenceId = 0x178; + break; + case kASGrabGroceryStoreHat: + _gameSys->setAnimation(0x170, 21, 2); + _gameSys->setAnimation(0x17B, 20, 3); + _gameSys->insertSequence(0x17B, 20, _s20_currGroceryStoreGuySequenceId, 20, 32, 0, 0, 0); + _gameSys->insertSequence(0x170, 21, _s20_currStonerGuySequenceId, 21, 32, 0, 0, 0); + stopSound(0x1A1); + scene20_stopSounds(); + _s20_currGroceryStoreGuySequenceId = 0x17B; + _s20_currStonerGuySequenceId = 0x170; + _s20_nextGroceryStoreGuySequenceId = 0x179; + break; + case kASSwitchGroceryStoreHat: + setGrabCursorSprite(-1); + _gameSys->setAnimation(0x180, _gnapId, 0); + _gameSys->insertSequence(0x180, _gnapId, makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, kSeqSyncWait, 0, 0, 0); + _gnapSequenceId = 0x180; + _gnapSequenceDatNum = 0; + invRemove(kItemCowboyHat); + invAdd(kItemGroceryStoreHat); + _gnapActionStatus = kASSwitchGroceryStoreHatDone; + break; + case kASSwitchGroceryStoreHatDone: + _gameSys->insertSequence(0x17F, 20, 372, 20, kSeqSyncWait, 0, 0, 0); + setFlag(19); + hideCursor(); + setGrabCursorSprite(-1); + addFullScreenSprite(0x12C, 255); + _gameSys->setAnimation(0x181, 256, 0); + _gameSys->insertSequence(0x181, 256, 0, 0, kSeqNone, 0, 0, 0); + while (_gameSys->getAnimationStatus(0) != 2) + gameUpdateTick(); + removeFullScreenSprite(); + showCursor(); + setGrabCursorSprite(kItemGroceryStoreHat); + _gnapIdleFacing = 1; + gnapWalkTo(3, 8, -1, getGnapSequenceId(gskIdle, 0, 0) | 0x10000, 1); + _gnapActionStatus = -1; + break; + case kASGrabJointDone: + setGrabCursorSprite(kItemJoint); + _gnapActionStatus = -1; + break; + } + } + + if (_gameSys->getAnimationStatus(3) == 2) { + switch (_s20_nextGroceryStoreGuySequenceId) { + case 0x176: + case 0x177: + _gameSys->setAnimation(_s20_nextGroceryStoreGuySequenceId, 20, 3); + _gameSys->insertSequence(_s20_nextGroceryStoreGuySequenceId, 20, _s20_currGroceryStoreGuySequenceId, 20, kSeqSyncWait, 0, 0, 0); + _s20_currGroceryStoreGuySequenceId = _s20_nextGroceryStoreGuySequenceId; + _s20_nextGroceryStoreGuySequenceId = -1; + _s20_nextStonerGuySequenceId = 0x16D; + break; + case 0x178: + _gameSys->setAnimation(_s20_nextGroceryStoreGuySequenceId, 20, 3); + _gameSys->setAnimation(0x17D, _gnapId, 0); + _gameSys->insertSequence(_s20_nextGroceryStoreGuySequenceId, 20, _s20_currGroceryStoreGuySequenceId, 20, kSeqSyncWait, 0, 0, 0); + _gameSys->insertSequence(0x17D, _gnapId, makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, kSeqSyncWait, 0, 0, 0); + _gnapSequenceId = 0x17D; + _gnapSequenceDatNum = 0; + _gnapActionStatus = kASActionDone; + _gameSys->setAnimation(0x16D, 21, 2); + _gameSys->insertSequence(0x16D, 21, _s20_currStonerGuySequenceId, 21, kSeqSyncWait, 0, 0, 0); + _s20_currStonerGuySequenceId = 0x16D; + _s20_currGroceryStoreGuySequenceId = 0x178; + _s20_nextGroceryStoreGuySequenceId = -1; + _s20_nextStonerGuySequenceId = -1; + break; + case 0x179: + _gameSys->setAnimation(_s20_nextGroceryStoreGuySequenceId, 20, 3); + _gameSys->setAnimation(0x16D, 21, 0); + _gameSys->insertSequence(_s20_nextGroceryStoreGuySequenceId, 20, _s20_currGroceryStoreGuySequenceId, 20, kSeqSyncWait, 0, 0, 0); + _gameSys->insertSequence(0x17E, _gnapId, makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, kSeqSyncWait, 0, 0, 0); + _gnapSequenceId = 0x17E; + _gnapSequenceDatNum = 0; + _gnapActionStatus = kASActionDone; + _gameSys->setAnimation(0x16D, 21, 2); + _gameSys->insertSequence(0x16D, 21, _s20_currStonerGuySequenceId, 21, kSeqSyncWait, 0, 0, 0); + _s20_currStonerGuySequenceId = 0x16D; + _s20_currGroceryStoreGuySequenceId = 377; + _s20_nextGroceryStoreGuySequenceId = -1; + _s20_nextStonerGuySequenceId = -1; + gnapWalkTo(4, 8, -1, 0x107BB, 1); + break; + case 0x17C: + _gameSys->setAnimation(0, 0, 3); + _s20_nextStonerGuySequenceId = 0x171; + break; + case 0x17A: + _gameSys->setAnimation(0, 0, 3); + _s20_nextStonerGuySequenceId = 0x16F; + break; + case 0x175: + _gameSys->setAnimation(0x175, 20, 0); + _gameSys->setAnimation(0x175, 20, 3); + _gameSys->insertSequence(0x175, 20, _s20_currGroceryStoreGuySequenceId, 20, kSeqSyncWait, 0, 0, 0); + _s20_currGroceryStoreGuySequenceId = 0x175; + _s20_nextGroceryStoreGuySequenceId = -1; + _gnapActionStatus = kASActionDone; + break; + default: + if (_s20_nextGroceryStoreGuySequenceId != -1) { + _gameSys->setAnimation(_s20_nextGroceryStoreGuySequenceId, 20, 3); + _gameSys->insertSequence(_s20_nextGroceryStoreGuySequenceId, 20, _s20_currGroceryStoreGuySequenceId, 20, kSeqSyncWait, 0, 0, 0); + _s20_currGroceryStoreGuySequenceId = _s20_nextGroceryStoreGuySequenceId; + _s20_nextGroceryStoreGuySequenceId = -1; + } + break; + } + } + + scene20_updateAnimationsCb(); + +} + +} // End of namespace Gnap diff --git a/engines/gnap/scenes/scene21.cpp b/engines/gnap/scenes/scene21.cpp new file mode 100644 index 0000000000..56da904ce1 --- /dev/null +++ b/engines/gnap/scenes/scene21.cpp @@ -0,0 +1,345 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "gnap/gnap.h" +#include "gnap/gamesys.h" +#include "gnap/resource.h" + +namespace Gnap { + +enum { + kHSPlatypus = 0, + kHSBanana = 1, + kHSOldLady = 2, + kHSDevice = 3, + kHSExitOutsideGrubCity = 4, + kHSWalkArea1 = 5, + kHSWalkArea2 = 6 +}; + +enum { + kASTalkOldLady = 0, + kASGrabBanana = 1, + kASGrabBananaDone = 2, + kASGrabOldLady = 3, + kASUseHatWithOldLady = 4, + kASUseHatWithOldLadyDone = 5, + kASLeaveScene = 6 +}; + +int GnapEngine::scene21_init() { + _gameSys->setAnimation(0, 0, 3); + return isFlag(3) ? 0x94 : 0x93; +} + +void GnapEngine::scene21_updateHotspots() { + setHotspot(kHSPlatypus, 0, 0, 0, 0, SF_WALKABLE | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSBanana, 94, 394, 146, 430, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR, 2, 6); + setHotspot(kHSOldLady, 402, 220, 528, 430, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR, 4, 7); + setHotspot(kHSExitOutsideGrubCity, 522, 498, 800, 600, SF_EXIT_SE_CURSOR | SF_WALKABLE, 5, 10); + setHotspot(kHSWalkArea1, 0, 0, 800, 440); + setHotspot(kHSWalkArea2, 698, 0, 800, 600); + setDeviceHotspot(kHSDevice, -1, -1, -1, -1); + if (isFlag(4) || !isFlag(3)) + _hotspots[kHSBanana].flags = SF_WALKABLE | SF_DISABLED; + if (isFlag(3)) + _hotspots[kHSOldLady].flags = SF_DISABLED; + _hotspotsCount = 7; +} + +void GnapEngine::scene21_run() { + + playSound(0x10940, 1); + startSoundTimerA(6); + + _timers[5] = getRandom(100) + 100; + + queueInsertDeviceIcon(); + + if (isFlag(3)) { + if (isFlag(5)) { + initGnapPos(5, 8, 1); + initBeaverPos(6, 8, 0); + _gameSys->insertSequence(0x8E, 2, 0, 0, kSeqNone, 0, 0, 0); + if (!isFlag(4)) + _gameSys->insertSequence(0x8D, 59, 0, 0, kSeqNone, 0, 0, 0); + endSceneInit(); + clearFlag(5); + } else { + initGnapPos(5, 11, 1); + initBeaverPos(6, 11, 0); + if (!isFlag(4)) + _gameSys->insertSequence(0x8D, 59, 0, 0, kSeqNone, 0, 0, 0); + endSceneInit(); + gnapWalkTo(5, 8, -1, 0x107B9, 1); + platypusWalkTo(6, 8, -1, 0x107C2, 1); + } + } else { + initGnapPos(5, 11, 1); + initBeaverPos(6, 11, 0); + _s21_currOldLadySequenceId = 0x89; + _gameSys->setAnimation(0x89, 79, 3); + _gameSys->insertSequence(_s21_currOldLadySequenceId, 79, 0, 0, kSeqNone, 0, 0, 0); + _s21_nextOldLadySequenceId = -1; + _timers[4] = getRandom(30) + 50; + endSceneInit(); + gnapWalkTo(5, 8, -1, 0x107B9, 1); + platypusWalkTo(6, 8, -1, 0x107C2, 1); + } + + while (!_sceneDone) { + + updateMouseCursor(); + updateCursorByHotspot(); + + _sceneClickedHotspot = getClickedHotspotId(); + updateGrabCursorSprite(0, 0); + + switch (_sceneClickedHotspot) { + + case kHSDevice: + if (_gnapActionStatus < 0) { + runMenu(); + scene21_updateHotspots(); + } + break; + + case kHSPlatypus: + if (_gnapActionStatus < 0) { + if (_grabCursorSpriteIndex == kItemJoint) { + gnapUseJointOnPlatypus(); + } else if (_grabCursorSpriteIndex >= 0) { + playGnapImpossible(0, 0); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapScratchingHead(_platX, _platY); + break; + case GRAB_CURSOR: + gnapKissPlatypus(0); + break; + case TALK_CURSOR: + playGnapBrainPulsating(_platX, _platY); + playBeaverSequence(getBeaverSequenceId(0, 0, 0) | 0x10000); + break; + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + } + break; + + case kHSBanana: + if (_gnapActionStatus < 0) { + if (_grabCursorSpriteIndex >= 0) { + playGnapShowItem(_grabCursorSpriteIndex, 2, 5); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapScratchingHead(2, 5); + break; + case GRAB_CURSOR: + gnapWalkTo(_gnapX, _gnapY, 0, getGnapSequenceId(gskIdle, _hotspotsWalkPos[kHSBanana].x, _hotspotsWalkPos[kHSBanana].y) | 0x10000, 1); + playGnapPullOutDevice(2, 5); + playGnapUseDevice(0, 0); + _gnapActionStatus = kASGrabBanana; + break; + case TALK_CURSOR: + case PLAT_CURSOR: + break; + } + } + } + break; + + case kHSOldLady: + if (_gnapActionStatus < 0) { + if (_grabCursorSpriteIndex == kItemGroceryStoreHat) { + _newSceneNum = 47; + gnapWalkTo(4, 6, 0, getGnapSequenceId(gskIdle, 0, 0) | 0x10000, 1); + _gnapActionStatus = kASUseHatWithOldLady; + } else if (_grabCursorSpriteIndex >= 0) { + playGnapShowCurrItem(4, 6, 7, 4); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapScratchingHead(7, 4); + break; + case GRAB_CURSOR: + _gnapIdleFacing = 5; + _hotspots[kHSWalkArea1].flags |= SF_WALKABLE; + gnapWalkTo(7, 6, 0, getGnapSequenceId(gskIdle, 0, 0) | 0x10000, 1); + _gnapActionStatus = kASGrabOldLady; + _hotspots[kHSWalkArea1].flags &= ~SF_WALKABLE; + break; + case TALK_CURSOR: + _gnapIdleFacing = 7; + gnapWalkTo(_hotspotsWalkPos[kHSOldLady].x, _hotspotsWalkPos[kHSOldLady].y, 0, getGnapSequenceId(gskBrainPulsating, 0, 0) | 0x10000, 1); + _gnapActionStatus = kASTalkOldLady; + break; + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + } + break; + + case kHSExitOutsideGrubCity: + if (_gnapActionStatus < 0) { + _isLeavingScene = 1; + _newSceneNum = 20; + gnapWalkTo(_hotspotsWalkPos[kHSExitOutsideGrubCity].x, _hotspotsWalkPos[kHSExitOutsideGrubCity].y, 0, 0x107B3, 1); + _gnapActionStatus = kASLeaveScene; + platypusWalkTo(_hotspotsWalkPos[kHSExitOutsideGrubCity].x + 1, _hotspotsWalkPos[kHSExitOutsideGrubCity].y, -1, 0x107C2, 1); + } + break; + + case kHSWalkArea1: + case kHSWalkArea2: + gnapWalkTo(-1, -1, -1, -1, 1); + break; + + default: + if (_mouseClickState.left) { + gnapWalkTo(-1, -1, -1, -1, 1); + _mouseClickState.left = false; + } + break; + + } + + scene21_updateAnimations(); + + if (!isSoundPlaying(0x10940)) + playSound(0x10940, 1); + + if (!_isLeavingScene) { + updateBeaverIdleSequence(); + updateGnapIdleSequence(); + if (!isFlag(3) && !_timers[4] && _s21_nextOldLadySequenceId == -1 && _gnapActionStatus == -1) { + _timers[4] = getRandom(30) + 50; + switch (getRandom(5)) { + case 0: + _s21_nextOldLadySequenceId = 0x88; + break; + case 1: + _s21_nextOldLadySequenceId = 0x8A; + break; + default: + _s21_nextOldLadySequenceId = 0x89; + break; + } + } + if (!_timers[5]) { + _timers[5] = getRandom(100) + 100; + _gameSys->insertSequence(0x92, 255, 0, 0, kSeqNone, 0, 0, 0); + } + playSoundA(); + } + + checkGameKeys(); + + if (isKeyStatus1(8)) { + clearKeyStatus1(8); + runMenu(); + scene21_updateHotspots(); + } + + gameUpdateTick(); + + } + +} + +void GnapEngine::scene21_updateAnimations() { + + if (_gameSys->getAnimationStatus(0) == 2) { + _gameSys->setAnimation(0, 0, 0); + switch (_gnapActionStatus) { + case kASTalkOldLady: + _s21_nextOldLadySequenceId = 0x8B; + _gnapActionStatus = -1; + break; + case kASGrabBanana: + _gameSys->setAnimation(0x8C, 59, 0); + _gameSys->insertSequence(0x8C, 59, 141, 59, kSeqSyncWait, 0, 0, 0); + setFlag(4); + invAdd(kItemBanana); + scene21_updateHotspots(); + _gnapActionStatus = kASGrabBananaDone; + break; + case kASGrabBananaDone: + setGrabCursorSprite(kItemBanana); + _gnapActionStatus = -1; + break; + case kASGrabOldLady: + _timers[4] = getRandom(30) + 50; + _s21_nextOldLadySequenceId = 0x87; + break; + case kASUseHatWithOldLady: + _gameSys->setAnimation(0x8F, _gnapId, 0); + _gameSys->insertSequence(0x8F, _gnapId, makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, kSeqSyncWait, 0, 0, 0); + _gnapSequenceDatNum = 0; + _gnapSequenceId = 0x8F; + _gnapActionStatus = kASUseHatWithOldLadyDone; + invAdd(kItemTickets); + invRemove(kItemGroceryStoreHat); + setGrabCursorSprite(-1); + break; + case kASUseHatWithOldLadyDone: + _s21_nextOldLadySequenceId = 0x91; + break; + case kASLeaveScene: + _sceneDone = true; + break; + } + } + + if (_gameSys->getAnimationStatus(3) == 2 && _s21_nextOldLadySequenceId != -1) { + if (_s21_nextOldLadySequenceId == 0x87) { + _gameSys->setAnimation(_s21_nextOldLadySequenceId, 79, 3); + _gameSys->insertSequence(_s21_nextOldLadySequenceId, 79, _s21_currOldLadySequenceId, 79, kSeqSyncWait, 0, 0, 0); + _gameSys->insertSequence(0x86, _gnapId, makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, kSeqSyncWait, 0, 0, 0); + _gnapSequenceId = 0x86; + _gnapSequenceDatNum = 0; + _gnapActionStatus = -1; + _s21_currOldLadySequenceId = _s21_nextOldLadySequenceId; + _s21_nextOldLadySequenceId = -1; + } else if (_s21_nextOldLadySequenceId == 0x91) { + _gameSys->setAnimation(0x91, 79, 0); + _gameSys->insertSequence(_s21_nextOldLadySequenceId, 79, _s21_currOldLadySequenceId, 79, kSeqSyncWait, 0, 0, 0); + _gnapActionStatus = kASLeaveScene; + _s21_currOldLadySequenceId = _s21_nextOldLadySequenceId; + _s21_nextOldLadySequenceId = -1; + } else { + _gameSys->setAnimation(_s21_nextOldLadySequenceId, 79, 3); + _gameSys->insertSequence(_s21_nextOldLadySequenceId, 79, _s21_currOldLadySequenceId, 79, kSeqSyncWait, 0, 0, 0); + _s21_currOldLadySequenceId = _s21_nextOldLadySequenceId; + _s21_nextOldLadySequenceId = -1; + } + } + +} + +} // End of namespace Gnap diff --git a/engines/gnap/scenes/scene22.cpp b/engines/gnap/scenes/scene22.cpp new file mode 100644 index 0000000000..0290666daa --- /dev/null +++ b/engines/gnap/scenes/scene22.cpp @@ -0,0 +1,294 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "gnap/gnap.h" +#include "gnap/gamesys.h" +#include "gnap/resource.h" + +namespace Gnap { + +enum { + kHSPlatypus = 0, + kHSExitOutsideGrubCity = 1, + kHSExitBackGrubCity = 2, + kHSCashier = 3, + kHSDevice = 4, + kHSWalkArea1 = 5, + kHSWalkArea2 = 6 +}; + +enum { + kASLeaveScene = 0, + kASTalkCashier = 1 +}; + +int GnapEngine::scene22_init() { + return 0x5E; +} + +void GnapEngine::scene22_updateHotspots() { + setHotspot(kHSPlatypus, 0, 0, 0, 0, SF_WALKABLE | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSExitOutsideGrubCity, 0, 180, 184, 472, SF_EXIT_L_CURSOR, 3, 6); + setHotspot(kHSExitBackGrubCity, 785, 405, 800, 585, SF_EXIT_R_CURSOR, 11, 9); + setHotspot(kHSCashier, 578, 230, 660, 376, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR, 6, 8); + setHotspot(kHSWalkArea1, 553, 0, 800, 542); + setHotspot(kHSWalkArea2, 0, 0, 552, 488); + setDeviceHotspot(kHSDevice, -1, -1, -1, -1); + _hotspotsCount = 7; +} + +void GnapEngine::scene22_run() { + + _gameSys->insertSequence(0x5D, 254, 0, 0, kSeqNone, 0, 0, 0); + + _s22_currCashierSequenceId = 0x59; + _s22_nextCashierSequenceId = -1; + + _gameSys->setAnimation(0x59, 1, 3); + _gameSys->insertSequence(_s22_currCashierSequenceId, 1, 0, 0, kSeqNone, 0, 0, 0); + + _timers[6] = getRandom(30) + 20; + + queueInsertDeviceIcon(); + + if (_prevSceneNum == 20) { + initGnapPos(2, 8, 1); + initBeaverPos(1, 8, 0); + endSceneInit(); + } else { + initGnapPos(11, _hotspotsWalkPos[kHSExitBackGrubCity].y, 1); + initBeaverPos(11, _hotspotsWalkPos[kHSExitBackGrubCity].y + 1, 0); + endSceneInit(); + gnapWalkTo(8, 8, -1, 0x107B9, 1); + platypusWalkTo(9, 8, -1, 0x107C2, 1); + } + + if (isFlag(11)) { + int storeDetectiveSeqId; + setGrabCursorSprite(-1); + invRemove(kItemCereals); + if (_s22_caughtBefore) { + switch (getRandom(3)) { + case 0: + storeDetectiveSeqId = 0x55; + break; + case 1: + storeDetectiveSeqId = 0x56; + break; + case 2: + storeDetectiveSeqId = 0x57; + break; + } + } else { + _s22_caughtBefore = true; + storeDetectiveSeqId = 0x54; + } + _gameSys->waitForUpdate(); + _gameSys->requestClear1(); + _gameSys->drawSpriteToBackground(0, 0, 0x44); + _gameSys->setAnimation(storeDetectiveSeqId, 256, 4); + _gameSys->insertSequence(storeDetectiveSeqId, 256, 0, 0, kSeqNone, 0, 0, 0); + while (_gameSys->getAnimationStatus(4) != 2) { + gameUpdateTick(); + } + _sceneDone = true; + _newSceneNum = 20; + _s22_caughtBefore = true; + } + + while (!_sceneDone) { + + updateMouseCursor(); + updateCursorByHotspot(); + + testWalk(0, 0, -1, -1, -1, -1); + + _sceneClickedHotspot = getClickedHotspotId(); + updateGrabCursorSprite(0, 0); + + switch (_sceneClickedHotspot) { + + case kHSDevice: + if (_gnapActionStatus < 0) { + runMenu(); + scene22_updateHotspots(); + } + break; + + case kHSPlatypus: + if (_gnapActionStatus < 0) { + if (_grabCursorSpriteIndex == kItemJoint) { + gnapUseJointOnPlatypus(); + } else if (_grabCursorSpriteIndex >= 0) { + playGnapImpossible(0, 0); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapScratchingHead(_platX, _platY); + break; + case GRAB_CURSOR: + gnapKissPlatypus(0); + break; + case TALK_CURSOR: + playGnapBrainPulsating(_platX, _platY); + playBeaverSequence(getBeaverSequenceId(0, 0, 0) | 0x10000); + break; + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + } + break; + + case kHSExitOutsideGrubCity: + if (_gnapActionStatus < 0) { + _isLeavingScene = 1; + _newSceneNum = 20; + gnapWalkTo(_hotspotsWalkPos[kHSExitOutsideGrubCity].x, _hotspotsWalkPos[kHSExitOutsideGrubCity].y, 0, 0x107AF, 1); + _gnapActionStatus = kASLeaveScene; + platypusWalkTo(_hotspotsWalkPos[kHSExitOutsideGrubCity].x, _hotspotsWalkPos[kHSExitOutsideGrubCity].y + 1, -1, 0x107C2, 1); + } + break; + + case kHSExitBackGrubCity: + if (_gnapActionStatus < 0) { + _isLeavingScene = 1; + _newSceneNum = 23; + gnapWalkTo(_hotspotsWalkPos[kHSExitBackGrubCity].x, _hotspotsWalkPos[kHSExitBackGrubCity].y, 0, 0x107AB, 1); + _gnapActionStatus = kASLeaveScene; + platypusWalkTo(_hotspotsWalkPos[kHSExitBackGrubCity].x, _hotspotsWalkPos[kHSExitBackGrubCity].y + 1, -1, 0x107C2, 1); + } + break; + + case kHSCashier: + if (_gnapActionStatus < 0) { + if (_grabCursorSpriteIndex >= 0) { + playGnapShowCurrItem(_hotspotsWalkPos[kHSCashier].x, _hotspotsWalkPos[kHSCashier].y, 8, 4); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapScratchingHead(8, 4); + break; + case GRAB_CURSOR: + playGnapImpossible(0, 0); + break; + case TALK_CURSOR: + _gnapIdleFacing = 7; + gnapWalkTo(_hotspotsWalkPos[kHSCashier].x, _hotspotsWalkPos[kHSCashier].y, + 0, getGnapSequenceId(gskBrainPulsating, 0, 0) | 0x10000, 1); + _gnapActionStatus = kASTalkCashier; + break; + case PLAT_CURSOR: + gnapUseDeviceOnBeaver(); + break; + } + } + } + break; + + case kHSWalkArea1: + case kHSWalkArea2: + gnapWalkTo(-1, -1, -1, -1, 1); + break; + + default: + if (_mouseClickState.left) { + gnapWalkTo(-1, -1, -1, -1, 1); + _mouseClickState.left = false; + } + break; + + } + + scene22_updateAnimations(); + + if (!_isLeavingScene) { + updateBeaverIdleSequence(); + updateGnapIdleSequence(); + if (!_timers[6] && _s22_nextCashierSequenceId == -1) { + _timers[6] = getRandom(30) + 20; + if (getRandom(8) != 0) { + _s22_nextCashierSequenceId = 0x59; + } else { + _s22_cashierCtr = (_s22_cashierCtr + 1) % 3; + switch (_s22_cashierCtr) { + case 1: + _s22_nextCashierSequenceId = 0x58; + break; + case 2: + _s22_nextCashierSequenceId = 0x5A; + break; + case 3: + _s22_nextCashierSequenceId = 0x5B; + break; + default: + _s22_nextCashierSequenceId = 0x58; + break; + } + } + } + } + + checkGameKeys(); + + if (isKeyStatus1(8)) { + clearKeyStatus1(8); + runMenu(); + scene22_updateHotspots(); + _timers[2] = getRandom(30) + 20; + _timers[3] = 400; + _timers[1] = getRandom(20) + 30; + _timers[0] = getRandom(75) + 75; + } + + gameUpdateTick(); + + } + +} + +void GnapEngine::scene22_updateAnimations() { + + if (_gameSys->getAnimationStatus(0) == 2) { + _gameSys->setAnimation(0, 0, 0); + switch (_gnapActionStatus) { + case kASLeaveScene: + _sceneDone = true; + break; + case kASTalkCashier: + _s22_nextCashierSequenceId = 0x5C; + break; + } + _gnapActionStatus = -1; + } + + if (_gameSys->getAnimationStatus(3) == 2 && _s22_nextCashierSequenceId != -1) { + _gameSys->setAnimation(_s22_nextCashierSequenceId, 1, 3); + _gameSys->insertSequence(_s22_nextCashierSequenceId, 1, _s22_currCashierSequenceId, 1, kSeqSyncWait, 0, 0, 0); + _s22_currCashierSequenceId = _s22_nextCashierSequenceId; + _s22_nextCashierSequenceId = -1; + } + +} + +} // End of namespace Gnap diff --git a/engines/gnap/scenes/scene23.cpp b/engines/gnap/scenes/scene23.cpp new file mode 100644 index 0000000000..cafeb71a56 --- /dev/null +++ b/engines/gnap/scenes/scene23.cpp @@ -0,0 +1,297 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "gnap/gnap.h" +#include "gnap/gamesys.h" +#include "gnap/resource.h" + +namespace Gnap { + +enum { + kHSPlatypus = 0, + kHSExitFrontGrubCity = 1, + kHSDevice = 2, + kHSCereals = 3, + kHSWalkArea1 = 4, + kHSWalkArea2 = 5 +}; + +enum { + kASLookCereals = 0, + kASGrabCereals = 1, + kASGrabCerealsDone = 2, + kASLeaveScene = 3 +}; + +int GnapEngine::scene23_init() { + return 0xC0; +} + +void GnapEngine::scene23_updateHotspots() { + setHotspot(kHSPlatypus, 0, 0, 0, 0, SF_WALKABLE | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSExitFrontGrubCity, 0, 250, 15, 550, SF_EXIT_L_CURSOR | SF_WALKABLE, 0, 7); + setHotspot(kHSCereals, 366, 332, 414, 408, SF_WALKABLE | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR, 4, 7); + setHotspot(kHSWalkArea1, 0, 0, 340, 460); + setHotspot(kHSWalkArea2, 340, 0, 800, 501); + setDeviceHotspot(kHSDevice, -1, -1, -1, -1); + _hotspotsCount = 6; +} + +void GnapEngine::scene23_run() { + + _timers[4] = getRandom(100) + 200; + _timers[5] = getRandom(100) + 200; + + _s23_currStoreClerkSequenceId = 0xB4; + _s23_nextStoreClerkSequenceId = -1; + + _gameSys->setAnimation(0xB4, 1, 4); + _gameSys->insertSequence(_s23_currStoreClerkSequenceId, 1, 0, 0, kSeqNone, 0, 0, 0); + + queueInsertDeviceIcon(); + + initGnapPos(-1, 7, 1); + initBeaverPos(-2, 7, 0); + _gameSys->insertSequence(0xBD, 255, 0, 0, kSeqNone, 0, 0, 0); + _gameSys->insertSequence(0xBF, 2, 0, 0, kSeqNone, 0, 0, 0); + endSceneInit(); + + platypusWalkTo(1, 7, -1, 0x107C2, 1); + + if (isFlag(24)) { + gnapWalkTo(2, 7, -1, 0x107B9, 1); + } else { + gnapWalkTo(2, 7, 0, 0x107B9, 1); + while (_gameSys->getAnimationStatus(0) != 2) + gameUpdateTick(); + playSequences(0x48, 0xBA, 0xBB, 0xBC); + setFlag(24); + } + + while (!_sceneDone) { + + updateMouseCursor(); + updateCursorByHotspot(); + + testWalk(0, 3, -1, -1, -1, -1); + + _sceneClickedHotspot = getClickedHotspotId(); + updateGrabCursorSprite(0, 0); + + switch (_sceneClickedHotspot) { + + case kHSDevice: + if (_gnapActionStatus < 0) { + runMenu(); + scene23_updateHotspots(); + } + break; + + case kHSPlatypus: + if (_gnapActionStatus < 0) { + if (_grabCursorSpriteIndex == kItemJoint) { + gnapUseJointOnPlatypus(); + } else if (_grabCursorSpriteIndex >= 0) { + playGnapImpossible(0, 0); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapScratchingHead(_platX, _platY); + break; + case GRAB_CURSOR: + gnapKissPlatypus(0); + break; + case TALK_CURSOR: + playGnapBrainPulsating(_platX, _platY); + playBeaverSequence(getBeaverSequenceId(0, 0, 0) | 0x10000); + break; + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + } + break; + + case kHSCereals: + if (_gnapActionStatus < 0) { + if (_grabCursorSpriteIndex >= 0) { + playGnapShowCurrItem(_hotspotsWalkPos[kHSCereals].x, _hotspotsWalkPos[kHSCereals].y, 5, 4); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + if (isFlag(11)) + playGnapMoan2(0, 0); + else { + gnapWalkTo(_hotspotsWalkPos[kHSCereals].x, _hotspotsWalkPos[kHSCereals].y, + 0, getGnapSequenceId(gskIdle, 0, 0) | 0x10000, 1); + _gnapActionStatus = kASLookCereals; + } + break; + case GRAB_CURSOR: + if (isFlag(11)) + playGnapImpossible(0, 0); + else { + _gnapIdleFacing = 1; + gnapWalkTo(_hotspotsWalkPos[kHSCereals].x, _hotspotsWalkPos[kHSCereals].y, + 0, getGnapSequenceId(gskIdle, 0, 0) | 0x10000, 1); + setFlag(11); + _gnapActionStatus = kASGrabCereals; + invAdd(kItemCereals); + } + break; + case TALK_CURSOR: + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + } + break; + + case kHSExitFrontGrubCity: + if (_gnapActionStatus < 0) { + _isLeavingScene = true; + _newSceneNum = 22; + gnapWalkTo(_hotspotsWalkPos[kHSExitFrontGrubCity].x, _hotspotsWalkPos[kHSExitFrontGrubCity].y, 0, 0x107AF, 1); + _gnapActionStatus = kASLeaveScene; + platypusWalkTo(_hotspotsWalkPos[kHSExitFrontGrubCity].x, _hotspotsWalkPos[kHSExitFrontGrubCity].y - 1, -1, 0x107C2, 1); + } + break; + + case kHSWalkArea1: + case kHSWalkArea2: + if (_gnapActionStatus < 0) + gnapWalkTo(-1, -1, -1, -1, 1); + break; + + default: + if (_mouseClickState.left) { + gnapWalkTo(-1, -1, -1, -1, 1); + _mouseClickState.left = false; + } + break; + + } + + scene23_updateAnimations(); + + if (!_isLeavingScene) { + updateBeaverIdleSequence(); + updateGnapIdleSequence(); + if (!_timers[4] && _gnapActionStatus == -1) { + _timers[4] = getRandom(100) + 200; + switch (getRandom(4)) { + case 0: + _gameSys->insertSequence(0xB7, 256, 0, 0, kSeqNone, 0, 0, 0); + break; + case 1: + _gameSys->insertSequence(0xB8, 256, 0, 0, kSeqNone, 0, 0, 0); + break; + case 2: + case 3: + _gameSys->insertSequence(0xB9, 256, 0, 0, kSeqNone, 0, 0, 0); + break; + } + } + if (!_timers[5]) { + _timers[5] = getRandom(100) + 200; + switch (getRandom(3)) { + case 0: + playSound(0xCE, 0); + break; + case 1: + playSound(0xD0, 0); + break; + case 2: + playSound(0xCF, 0); + break; + } + } + } + + checkGameKeys(); + + if (isKeyStatus1(8)) { + clearKeyStatus1(8); + runMenu(); + scene23_updateHotspots(); + } + + gameUpdateTick(); + + } + +} + +void GnapEngine::scene23_updateAnimations() { + + if (_gameSys->getAnimationStatus(0) == 2) { + _gameSys->setAnimation(0, 0, 0); + switch (_gnapActionStatus) { + case kASLookCereals: + showFullScreenSprite(0x48); + _gnapActionStatus = -1; + break; + case kASGrabCereals: + _gameSys->setAnimation(0xBE, _gnapId, 0); + _gameSys->insertSequence(0xBE, _gnapId, makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, kSeqSyncWait, 0, 0, 0); + _gameSys->requestRemoveSequence(0xBF, 2); + _gnapSequenceDatNum = 0; + _gnapSequenceId = 0xBE; + _gnapActionStatus = kASGrabCerealsDone; + break; + case kASGrabCerealsDone: + setGrabCursorSprite(kItemCereals); + _gnapActionStatus = -1; + break; + case kASLeaveScene: + _sceneDone = true; + break; + } + } + + if (_gameSys->getAnimationStatus(4) == 2 && _s23_nextStoreClerkSequenceId == -1) { + switch (getRandom(8)) { + case 0: + case 1: + case 2: + _s23_nextStoreClerkSequenceId = 0xB4; + break; + case 3: + case 4: + case 5: + _s23_nextStoreClerkSequenceId = 0xB5; + break; + default: + _s23_nextStoreClerkSequenceId = 0xB6; + break; + } + _gameSys->setAnimation(_s23_nextStoreClerkSequenceId, 1, 4); + _gameSys->insertSequence(_s23_nextStoreClerkSequenceId, 1, _s23_currStoreClerkSequenceId, 1, kSeqSyncWait, 0, 0, 0); + _s23_currStoreClerkSequenceId = _s23_nextStoreClerkSequenceId; + _s23_nextStoreClerkSequenceId = -1; + } + +} + +} // End of namespace Gnap diff --git a/engines/gnap/scenes/scene24.cpp b/engines/gnap/scenes/scene24.cpp new file mode 100644 index 0000000000..236ee7d30a --- /dev/null +++ b/engines/gnap/scenes/scene24.cpp @@ -0,0 +1,261 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "gnap/gnap.h" +#include "gnap/gamesys.h" +#include "gnap/resource.h" + +namespace Gnap { + +enum { + kHSPlatypus = 0, + kHSExitCircusWorld = 1, + kHSExitOutsideGrubCity = 2, + kHSDevice = 3, + kHSWalkArea1 = 4, + kHSWalkArea2 = 5, + kHSWalkArea3 = 6 +}; + +enum { + kASLeaveScene = 0 +}; + +int GnapEngine::scene24_init() { + return 0x3B; +} + +void GnapEngine::scene24_updateHotspots() { + setHotspot(kHSPlatypus, 0, 0, 0, 0, SF_WALKABLE | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSExitCircusWorld, 785, 128, 800, 600, SF_EXIT_R_CURSOR, 8, 7); + setHotspot(kHSExitOutsideGrubCity, 0, 213, 91, 600, SF_EXIT_NW_CURSOR, 1, 8); + setHotspot(kHSWalkArea1, 0, 0, 0, 0); + setHotspot(kHSWalkArea2, 530, 0, 800, 600); + setHotspot(kHSWalkArea3, 0, 0, 800, 517); + setDeviceHotspot(kHSDevice, -1, -1, -1, -1); + _hotspotsCount = 7; +} + +void GnapEngine::scene24_run() { + int counter = 0; + + playSound(0x10940, 1); + + startSoundTimerA(9); + + _timers[7] = getRandom(100) + 100; + + _gameSys->insertSequence(0x2F, 256, 0, 0, kSeqNone, 0, 0, 0); + + _timers[4] = getRandom(20) + 50; + _timers[5] = getRandom(20) + 40; + _timers[6] = getRandom(50) + 30; + + _gameSys->insertSequence(0x36, 20, 0, 0, kSeqNone, 0, 0, 0); + _gameSys->insertSequence(0x30, 20, 0, 0, kSeqNone, 0, 0, 0); + _gameSys->insertSequence(0x35, 20, 0, 0, kSeqNone, 0, 0, 0); + + _s24_currWomanSequenceId = 0x35; + _s24_girlSequenceId = 0x36; + _s24_boySequenceId = 0x30; + + if (_debugLevel == 4) + startIdleTimer(8); + + queueInsertDeviceIcon(); + + if (_prevSceneNum == 20) { + initGnapPos(1, 8, 1); + initBeaverPos(2, 8, 0); + endSceneInit(); + gnapWalkTo(1, 9, -1, 0x107B9, 1); + platypusWalkTo(2, 9, -1, 0x107C2, 1); + } else { + initGnapPos(8, 8, 3); + initBeaverPos(8, 8, 4); + endSceneInit(); + gnapWalkTo(2, 8, -1, 0x107BA, 1); + platypusWalkTo(3, 8, -1, 0x107C2, 1); + } + + while (!_sceneDone) { + + updateMouseCursor(); + updateCursorByHotspot(); + + testWalk(0, 0, -1, -1, -1, -1); + + _sceneClickedHotspot = getClickedHotspotId(); + updateGrabCursorSprite(0, 0); + + switch (_sceneClickedHotspot) { + + case kHSDevice: + if (_gnapActionStatus < 0) { + runMenu(); + scene24_updateHotspots(); + } + break; + + case kHSPlatypus: + if (_gnapActionStatus < 0) { + if (_grabCursorSpriteIndex == kItemJoint) { + gnapUseJointOnPlatypus(); + } else if (_grabCursorSpriteIndex >= 0) { + playGnapImpossible(0, 0); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapScratchingHead(_platX, _platY); + break; + case GRAB_CURSOR: + gnapKissPlatypus(0); + break; + case TALK_CURSOR: + playGnapBrainPulsating(_platX, _platY); + playBeaverSequence(getBeaverSequenceId(0, 0, 0) | 0x10000); + break; + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + } + break; + + case kHSExitCircusWorld: + if (_gnapActionStatus < 0) { + _isLeavingScene = true; + _newSceneNum = 25; + gnapWalkTo(_hotspotsWalkPos[kHSExitCircusWorld].x, _hotspotsWalkPos[kHSExitCircusWorld].y, 0, 0x107AB, 1); + _gnapActionStatus = kASLeaveScene; + platypusWalkTo(_hotspotsWalkPos[kHSExitCircusWorld].x + 1, _hotspotsWalkPos[kHSExitCircusWorld].y, -1, 0x107C2, 1); + } + break; + + case kHSExitOutsideGrubCity: + if (_gnapActionStatus < 0) { + _isLeavingScene = true; + _newSceneNum = 20; + _gnapIdleFacing = 7; + gnapWalkTo(_hotspotsWalkPos[kHSExitOutsideGrubCity].x, _hotspotsWalkPos[kHSExitOutsideGrubCity].y, 0, getGnapSequenceId(gskIdle, 0, 0) | 0x10000, 1); + _gnapActionStatus = kASLeaveScene; + platypusWalkTo(_hotspotsWalkPos[kHSExitOutsideGrubCity].x + 1, _hotspotsWalkPos[kHSExitOutsideGrubCity].y, -1, 0x107C2, 1); + } + break; + + case kHSWalkArea1: + case kHSWalkArea2: + case kHSWalkArea3: + if (_gnapActionStatus == -1) + gnapWalkTo(-1, -1, -1, -1, 1); + break; + + default: + if (_mouseClickState.left) { + gnapWalkTo(-1, -1, -1, -1, 1); + _mouseClickState.left = false; + } + break; + + } + + scene24_updateAnimations(); + + if (!isSoundPlaying(0x10940)) + playSound(0x10940, 1); + + if (!_isLeavingScene) { + updateBeaverIdleSequence(); + updateGnapIdleSequence(); + if (!_timers[4]) { + _timers[4] = getRandom(20) + 50; + _gameSys->insertSequence(0x37, 20, _s24_girlSequenceId, 20, kSeqSyncWait, 0, 0, 0); + _s24_girlSequenceId = 0x37; + } + if (!_timers[5]) { + _timers[5] = getRandom(20) + 40; + _gameSys->insertSequence(0x31, 20, _s24_boySequenceId, 20, kSeqSyncWait, 0, 0, 0); + _s24_boySequenceId = 0x31; + } + if (!_timers[6]) { + _timers[6] = getRandom(50) + 30; + counter = (counter + 1) % 3; + switch (counter) { + case 0: + _s24_nextWomanSequenceId = 0x32; + break; + case 1: + _s24_nextWomanSequenceId = 0x33; + break; + case 2: + _s24_nextWomanSequenceId = 0x34; + break; + } + _gameSys->insertSequence(_s24_nextWomanSequenceId, 20, _s24_currWomanSequenceId, 20, kSeqSyncWait, 0, 0, 0); + _s24_currWomanSequenceId = _s24_nextWomanSequenceId; + } + if (!_timers[7]) { + _timers[7] = getRandom(100) + 100; + switch (getRandom(3)) { + case 0: + _gameSys->insertSequence(0x38, 253, 0, 0, kSeqNone, 0, 0, 0); + break; + case 1: + _gameSys->insertSequence(0x39, 253, 0, 0, kSeqNone, 0, 0, 0); + break; + case 2: + _gameSys->insertSequence(0x3A, 253, 0, 0, kSeqNone, 0, 0, 0); + break; + } + } + if (_debugLevel == 4) + updateIdleTimer(); + playSoundA(); + } + + checkGameKeys(); + + if (isKeyStatus1(8)) { + clearKeyStatus1(8); + runMenu(); + scene24_updateHotspots(); + } + + gameUpdateTick(); + + } + +} + +void GnapEngine::scene24_updateAnimations() { + + if (_gameSys->getAnimationStatus(0) == 2) { + _gameSys->setAnimation(0, 0, 0); + if (_gnapActionStatus == kASLeaveScene) + _sceneDone = true; + _gnapActionStatus = -1; + } + +} + +} // End of namespace Gnap diff --git a/engines/gnap/scenes/scene25.cpp b/engines/gnap/scenes/scene25.cpp new file mode 100644 index 0000000000..cb82658cc2 --- /dev/null +++ b/engines/gnap/scenes/scene25.cpp @@ -0,0 +1,401 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "gnap/gnap.h" +#include "gnap/gamesys.h" +#include "gnap/resource.h" + +namespace Gnap { + +enum { + kHSPlatypus = 0, + kHSTicketVendor = 1, + kHSExitOutsideCircusWorld = 2, + kHSExitInsideCircusWorld = 3, + kHSDevice = 4, + kHSPosters1 = 5, + kHSPosters2 = 6, + kHSPosters3 = 7, + kHSPosters4 = 8, + kHSWalkArea1 = 9, + kHSWalkArea2 = 10 +}; + +enum { + kASTalkTicketVendor = 0, + kASEnterCircusWihoutTicket = 1, + kASShowTicketToVendor = 2, + kASShowTicketToVendorDone = 3, + kASEnterCircusWihoutTicketDone = 4, + kASLeaveScene = 5 +}; + +int GnapEngine::scene25_init() { + return 0x62; +} + +void GnapEngine::scene25_updateHotspots() { + setHotspot(kHSPlatypus, 0, 0, 0, 0, SF_WALKABLE | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSTicketVendor, 416, 94, 574, 324, SF_WALKABLE | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR, 5, 5); + setHotspot(kHSExitOutsideCircusWorld, 0, 519, 205, 600, SF_EXIT_SW_CURSOR, 5, 10); + setHotspot(kHSExitInsideCircusWorld, 321, 70, 388, 350, SF_EXIT_NE_CURSOR, 3, 6); + setHotspot(kHSPosters1, 0, 170, 106, 326, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR, 1, 7); + setHotspot(kHSPosters2, 146, 192, 254, 306, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR, 3, 7); + setHotspot(kHSPosters3, 606, 162, 654, 368, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR, 7, 7); + setHotspot(kHSPosters4, 708, 114, 754, 490, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR, 7, 8); + setHotspot(kHSWalkArea1, 0, 0, 800, 439); + setHotspot(kHSWalkArea2, 585, 0, 800, 600); + setDeviceHotspot(kHSDevice, -1, -1, -1, -1); + _hotspotsCount = 11; +} + +void GnapEngine::scene25_playAnims(int index) { + + if (index > 4) + return; + + hideCursor(); + setGrabCursorSprite(-1); + switch (index) { + case 1: + _largeSprite = _gameSys->createSurface(0x25); + break; + case 2: + _largeSprite = _gameSys->createSurface(0x26); + break; + case 3: + _largeSprite = _gameSys->createSurface(0x27); + break; + case 4: + _largeSprite = _gameSys->createSurface(0x28); + break; + } + _gameSys->insertSpriteDrawItem(_largeSprite, 0, 0, 300); + delayTicksCursor(5); + while (!_mouseClickState.left && !isKeyStatus1(Common::KEYCODE_ESCAPE) && !isKeyStatus1(Common::KEYCODE_SPACE) && + !isKeyStatus1(29)) { + gameUpdateTick(); + } + _mouseClickState.left = false; + clearKeyStatus1(Common::KEYCODE_ESCAPE); + clearKeyStatus1(29); + clearKeyStatus1(Common::KEYCODE_SPACE); + _gameSys->removeSpriteDrawItem(_largeSprite, 300); + delayTicksCursor(5); + deleteSurface(&_largeSprite); + showCursor(); +} + +void GnapEngine::scene25_run() { + + playSound(0x10940, 1); + + startSoundTimerA(5); + + _s25_currTicketVendorSequenceId = 0x52; + _gameSys->setAnimation(0x52, 39, 3); + _gameSys->insertSequence(_s25_currTicketVendorSequenceId, 39, 0, 0, kSeqNone, 0, 0, 0); + + _s25_nextTicketVendorSequenceId = -1; + _timers[4] = getRandom(20) + 20; + + queueInsertDeviceIcon(); + + if (_prevSceneNum == 24) { + initGnapPos(5, 11, 5); + initBeaverPos(6, 11, 4); + endSceneInit(); + gnapWalkTo(5, 7, -1, 0x107BA, 1); + platypusWalkTo(6, 7, -1, 0x107C2, 1); + } else { + initGnapPos(5, 6, 1); + initBeaverPos(6, 6, 0); + endSceneInit(); + gnapWalkTo(5, 8, -1, 0x107B9, 1); + platypusWalkTo(6, 8, -1, 0x107C2, 1); + } + + while (!_sceneDone) { + + updateMouseCursor(); + updateCursorByHotspot(); + + _sceneClickedHotspot = getClickedHotspotId(); + updateGrabCursorSprite(0, 0); + + switch (_sceneClickedHotspot) { + + case kHSDevice: + if (_gnapActionStatus < 0) { + runMenu(); + scene25_updateHotspots(); + } + break; + + case kHSPlatypus: + if (_gnapActionStatus < 0) { + if (_grabCursorSpriteIndex == kItemJoint) { + gnapUseJointOnPlatypus(); + } else if (_grabCursorSpriteIndex >= 0) { + playGnapImpossible(0, 0); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapScratchingHead(_platX, _platY); + break; + case GRAB_CURSOR: + gnapKissPlatypus(0); + break; + case TALK_CURSOR: + playGnapBrainPulsating(_platX, _platY); + playBeaverSequence(getBeaverSequenceId(0, 0, 0) | 0x10000); + break; + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + } + break; + + case kHSTicketVendor: + if (_gnapActionStatus < 0) { + if (_grabCursorSpriteIndex == kItemTickets) { + _gnapActionStatus = kASShowTicketToVendor; + gnapWalkTo(_hotspotsWalkPos[kHSTicketVendor].x, _hotspotsWalkPos[kHSTicketVendor].y, + 0, getGnapSequenceId(gskIdle, 9, 4) | 0x10000, 1); + playGnapPullOutDevice(0, 0); + playGnapUseDevice(0, 0); + } else if (_grabCursorSpriteIndex >= 0) { + playGnapShowCurrItem(_hotspotsWalkPos[kHSTicketVendor].x, _hotspotsWalkPos[kHSTicketVendor].y, 6, 1); + _s25_nextTicketVendorSequenceId = 0x5B; + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapScratchingHead(6, 1); + _s25_nextTicketVendorSequenceId = (getRandom(2) == 1) ? 0x59 : 0x56; + break; + case TALK_CURSOR: + _gnapIdleFacing = 7; + gnapWalkTo(_hotspotsWalkPos[kHSTicketVendor].x, _hotspotsWalkPos[kHSTicketVendor].y, 0, getGnapSequenceId(gskBrainPulsating, 0, 0) | 0x10000, 1); + _gnapActionStatus = kASTalkTicketVendor; + break; + case GRAB_CURSOR: + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + } + break; + + case kHSExitOutsideCircusWorld: + if (_gnapActionStatus < 0) { + _isLeavingScene = true; + _newSceneNum = 24; + gnapWalkTo(_hotspotsWalkPos[kHSExitOutsideCircusWorld].x, _hotspotsWalkPos[kHSExitOutsideCircusWorld].y, 0, 0x107B4, 1); + _gnapActionStatus = kASLeaveScene; + platypusWalkTo(_hotspotsWalkPos[kHSExitOutsideCircusWorld].x + 1, _hotspotsWalkPos[kHSExitOutsideCircusWorld].y, -1, 0x107C2, 1); + } + break; + + case kHSExitInsideCircusWorld: + if (_gnapActionStatus < 0) { + if (isFlag(2)) { + _isLeavingScene = true; + _newSceneNum = 26; + _hotspots[kHSWalkArea1].flags |= SF_WALKABLE; + gnapWalkTo(_hotspotsWalkPos[kHSExitInsideCircusWorld].x, _hotspotsWalkPos[kHSExitInsideCircusWorld].y, 0, 0x107B1, 1); + _gnapActionStatus = kASLeaveScene; + platypusWalkTo(_hotspotsWalkPos[kHSExitInsideCircusWorld].x + 1, _hotspotsWalkPos[kHSExitInsideCircusWorld].y, -1, 0x107C2, 1); + _hotspots[kHSWalkArea1].flags &= ~SF_WALKABLE; + } else { + _hotspots[kHSWalkArea1].flags |= SF_WALKABLE; + gnapWalkTo(4, 5, 0, 0x107BB, 1); + _gnapActionStatus = kASEnterCircusWihoutTicket; + _hotspots[kHSWalkArea1].flags &= ~SF_WALKABLE; + } + } + break; + + case kHSPosters1: + case kHSPosters2: + case kHSPosters3: + case kHSPosters4: + if (_gnapActionStatus < 0) { + if (_grabCursorSpriteIndex >= 0) { + playGnapImpossible(0, 0); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + gnapWalkTo(_hotspotsWalkPos[_sceneClickedHotspot].x, _hotspotsWalkPos[_sceneClickedHotspot].y, -1, -1, 1); + if (_sceneClickedHotspot == 5 || _sceneClickedHotspot == 6) + _gnapIdleFacing = 5; + else if (_sceneClickedHotspot == 8) + _gnapIdleFacing = 1; + else + _gnapIdleFacing = 7; + playGnapIdle(0, 0); + scene25_playAnims(8 - _sceneClickedHotspot + 1); + break; + case GRAB_CURSOR: + case TALK_CURSOR: + case PLAT_CURSOR: + playGnapMoan2(0, 0); + break; + } + } + } + break; + + case kHSWalkArea1: + case kHSWalkArea2: + if (_gnapActionStatus < 0) + gnapWalkTo(-1, -1, -1, -1, 1); + break; + + default: + if (_mouseClickState.left) { + gnapWalkTo(-1, -1, -1, -1, 1); + _mouseClickState.left = false; + } + break; + + } + + scene25_updateAnimations(); + + if (!_isLeavingScene) { + updateBeaverIdleSequence(); + updateGnapIdleSequence(); + if (!_timers[4] && _s25_nextTicketVendorSequenceId == -1 && _gnapActionStatus == -1) { + _timers[4] = getRandom(20) + 20; + switch (getRandom(13)) { + case 0: + _s25_nextTicketVendorSequenceId = 0x54; + break; + case 1: + _s25_nextTicketVendorSequenceId = 0x58; + break; + case 2: + _s25_nextTicketVendorSequenceId = 0x55; + break; + case 3: + _s25_nextTicketVendorSequenceId = 0x5A; + break; + case 4: + case 5: + case 6: + case 7: + _s25_nextTicketVendorSequenceId = 0x5B; + break; + case 8: + case 9: + case 10: + case 11: + _s25_nextTicketVendorSequenceId = 0x5C; + break; + case 12: + _s25_nextTicketVendorSequenceId = 0x5D; + break; + default: + _s25_nextTicketVendorSequenceId = 0x52; + break; + } + } + playSoundA(); + } + + checkGameKeys(); + + if (isKeyStatus1(8)) { + clearKeyStatus1(8); + runMenu(); + scene25_updateHotspots(); + } + + gameUpdateTick(); + + } + +} + +void GnapEngine::scene25_updateAnimations() { + + if (_gameSys->getAnimationStatus(0) == 2) { + _gameSys->setAnimation(0, 0, 0); + switch (_gnapActionStatus) { + case kASTalkTicketVendor: + _s25_nextTicketVendorSequenceId = (getRandom(2) == 1) ? 0x57 : 0x5F; + _gnapActionStatus = -1; + break; + case kASEnterCircusWihoutTicket: + _s25_nextTicketVendorSequenceId = 0x5E; + _gameSys->setAnimation(0x5E, 39, 0); + _gameSys->setAnimation(_s25_nextTicketVendorSequenceId, 39, 3); + _gameSys->insertSequence(_s25_nextTicketVendorSequenceId, 39, _s25_currTicketVendorSequenceId, 39, 32, 0, 0, 0); + _gameSys->insertSequence(0x60, 2, 0, 0, kSeqNone, 0, 0, 0); + _s25_currTicketVendorSequenceId = _s25_nextTicketVendorSequenceId; + _s25_nextTicketVendorSequenceId = -1; + _hotspots[kHSWalkArea1].flags |= SF_WALKABLE; + playGnapIdle(0, 0); + gnapWalkTo(_hotspotsWalkPos[3].x, _hotspotsWalkPos[3].y, -1, 0x107BB, 1); + _hotspots[kHSWalkArea1].flags &= ~SF_WALKABLE; + _gnapActionStatus = kASEnterCircusWihoutTicketDone; + break; + case kASEnterCircusWihoutTicketDone: + _gnapActionStatus = -1; + break; + case kASShowTicketToVendor: + setGrabCursorSprite(-1); + invRemove(kItemTickets); + setFlag(2); + _gameSys->setAnimation(0x61, 40, 0); + _gameSys->insertSequence(0x61, 40, 0, 0, kSeqNone, 0, 0, 0); + _gnapActionStatus = kASShowTicketToVendorDone; + break; + case kASShowTicketToVendorDone: + _s25_nextTicketVendorSequenceId = 0x53; + break; + case kASLeaveScene: + _sceneDone = true; + break; + } + } + + if (_gameSys->getAnimationStatus(3) == 2) { + if (_s25_nextTicketVendorSequenceId == 0x53) { + _gameSys->insertSequence(_s25_nextTicketVendorSequenceId, 39, _s25_currTicketVendorSequenceId, 39, kSeqSyncWait, 0, 0, 0); + _s25_currTicketVendorSequenceId = _s25_nextTicketVendorSequenceId; + _s25_nextTicketVendorSequenceId = -1; + _gnapActionStatus = -1; + } else if (_s25_nextTicketVendorSequenceId != -1) { + _gameSys->setAnimation(_s25_nextTicketVendorSequenceId, 39, 3); + _gameSys->insertSequence(_s25_nextTicketVendorSequenceId, 39, _s25_currTicketVendorSequenceId, 39, kSeqSyncWait, 0, 0, 0); + _s25_currTicketVendorSequenceId = _s25_nextTicketVendorSequenceId; + _s25_nextTicketVendorSequenceId = -1; + } + } + +} + +} // End of namespace Gnap diff --git a/engines/gnap/scenes/scene26.cpp b/engines/gnap/scenes/scene26.cpp new file mode 100644 index 0000000000..644db6b3fd --- /dev/null +++ b/engines/gnap/scenes/scene26.cpp @@ -0,0 +1,256 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "gnap/gnap.h" +#include "gnap/gamesys.h" +#include "gnap/resource.h" + +namespace Gnap { + +enum { + kHSPlatypus = 0, + kHSExitOutsideCircusWorld = 1, + kHSExitOutsideClown = 2, + kHSExitArcade = 3, + kHSExitElephant = 4, + kHSExitBeerStand = 5, + kHSDevice = 6, + kHSWalkArea1 = 7, + kHSWalkArea2 = 8 +}; + +enum { + kASLeaveScene = 0 +}; + +int GnapEngine::scene26_init() { + return isFlag(23) ? 0x61 : 0x60; +} + +void GnapEngine::scene26_updateHotspots() { + setHotspot(kHSPlatypus, 0, 0, 0, 0, SF_WALKABLE | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSExitOutsideCircusWorld, 0, 590, 300, 600, SF_EXIT_D_CURSOR | SF_WALKABLE, 1, 10); + setHotspot(kHSExitOutsideClown, 200, 265, 265, 350, SF_EXIT_U_CURSOR, 3, 8); + setHotspot(kHSExitArcade, 0, 295, 150, 400, SF_EXIT_NW_CURSOR, 2, 8); + setHotspot(kHSExitElephant, 270, 290, 485, 375, SF_EXIT_U_CURSOR, 5, 8); + setHotspot(kHSExitBeerStand, 530, 290, 620, 350, SF_EXIT_NE_CURSOR, 5, 8); + setHotspot(kHSWalkArea1, 0, 0, 800, 500); + setHotspot(kHSWalkArea2, 281, 0, 800, 600); + setDeviceHotspot(kHSDevice, -1, -1, -1, -1); + _hotspotsCount = 9; +} + +void GnapEngine::scene26_run() { + + startSoundTimerB(7); + playSound(0x1093B, 1); + + _s26_currKidSequenceId = 0x5B; + _s26_nextKidSequenceId = -1; + _gameSys->setAnimation(0x5B, 160, 3); + _gameSys->insertSequence(_s26_currKidSequenceId, 160, 0, 0, kSeqNone, 0, 0, 0); + + _timers[5] = getRandom(20) + 50; + _timers[4] = getRandom(20) + 50; + _timers[6] = getRandom(50) + 100; + + queueInsertDeviceIcon(); + + _gameSys->insertSequence(0x58, 40, 0, 0, kSeqLoop, 0, 0, 0); + _gameSys->insertSequence(0x5C, 40, 0, 0, kSeqLoop, 0, 0, 0); + _gameSys->insertSequence(0x5D, 40, 0, 0, kSeqLoop, 0, 0, 0); + _gameSys->insertSequence(0x5E, 40, 0, 0, kSeqLoop, 0, 0, 0); + + if (_prevSceneNum == 25) { + initGnapPos(-1, 8, 1); + initBeaverPos(-2, 8, 0); + endSceneInit(); + gnapWalkTo(2, 8, -1, 0x107B9, 1); + platypusWalkTo(1, 8, -1, 0x107C2, 1); + } else { + initGnapPos(2, 8, 1); + initBeaverPos(3, 8, 0); + endSceneInit(); + } + + while (!_sceneDone) { + + updateMouseCursor(); + updateCursorByHotspot(); + + _sceneClickedHotspot = getClickedHotspotId(); + updateGrabCursorSprite(0, 0); + + switch (_sceneClickedHotspot) { + + case kHSDevice: + if (_gnapActionStatus < 0) { + runMenu(); + scene26_updateHotspots(); + } + break; + + case kHSPlatypus: + if (_gnapActionStatus < 0) { + if (_grabCursorSpriteIndex == kItemJoint) { + gnapUseJointOnPlatypus(); + } else if (_grabCursorSpriteIndex >= 0) { + playGnapImpossible(0, 0); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapMoan1(_platX, _platY); + break; + case GRAB_CURSOR: + gnapKissPlatypus(0); + break; + case TALK_CURSOR: + playGnapBrainPulsating(_platX, _platY); + playBeaverSequence(getBeaverSequenceId(0, 0, 0) | 0x10000); + break; + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + } + break; + + case kHSExitOutsideCircusWorld: + if (_gnapActionStatus < 0) { + _isLeavingScene = true; + _newSceneNum = 25; + gnapWalkTo(-1, _hotspotsWalkPos[kHSExitOutsideCircusWorld].y, 0, 0x107AE, 1); + _gnapActionStatus = kASLeaveScene; + } + break; + + case kHSExitOutsideClown: + if (_gnapActionStatus < 0) { + _isLeavingScene = true; + _newSceneNum = 27; + gnapWalkTo(-1, _hotspotsWalkPos[kHSExitOutsideClown].y, 0, 0x107BC, 1); + _gnapActionStatus = kASLeaveScene; + } + break; + + case kHSExitArcade: + if (_gnapActionStatus < 0) { + _isLeavingScene = true; + _newSceneNum = 29; + gnapWalkTo(-1, _hotspotsWalkPos[kHSExitArcade].y, 0, 0x107BC, 1); + _gnapActionStatus = kASLeaveScene; + } + break; + + case kHSExitElephant: + if (_gnapActionStatus < 0) { + _isLeavingScene = true; + _newSceneNum = 30; + gnapWalkTo(-1, _hotspotsWalkPos[4].y, 0, 0x107BC, 1); + _gnapActionStatus = kASLeaveScene; + } + break; + + case kHSExitBeerStand: + if (_gnapActionStatus < 0) { + _isLeavingScene = true; + _newSceneNum = 31; + gnapWalkTo(-1, _hotspotsWalkPos[kHSExitBeerStand].y, 0, 0x107BB, 1); + _gnapActionStatus = kASLeaveScene; + } + break; + + case kHSWalkArea1: + case kHSWalkArea2: + if (_gnapActionStatus < 0) + gnapWalkTo(-1, -1, -1, -1, 1); + break; + + default: + if (_mouseClickState.left) { + gnapWalkTo(-1, -1, -1, -1, 1); + _mouseClickState.left = false; + } + break; + + } + + scene26_updateAnimations(); + + if (!isSoundPlaying(0x1093B)) + playSound(0x1093B, 1); + + if (!_isLeavingScene) { + updateBeaverIdleSequence(); + updateGnapIdleSequence(); + if (!_timers[5] && _s26_nextKidSequenceId == -1) { + _timers[5] = getRandom(20) + 50; + if (getRandom(5) != 0) + _s26_nextKidSequenceId = 0x5B; + else + _s26_nextKidSequenceId = 0x5A; + } + if (!_timers[4]) { + _timers[4] = getRandom(20) + 130; + _gameSys->insertSequence(0x59, 40, 0, 0, kSeqNone, 0, 0, 0); + } + if (!_timers[6]) { + _timers[6] = getRandom(50) + 100; + _gameSys->insertSequence(0x5F, 40, 0, 0, kSeqNone, 0, 0, 0); + } + playSoundB(); + } + + checkGameKeys(); + + if (isKeyStatus1(8)) { + clearKeyStatus1(8); + runMenu(); + scene26_updateHotspots(); + } + + gameUpdateTick(); + + } + +} + +void GnapEngine::scene26_updateAnimations() { + + if (_gameSys->getAnimationStatus(0) == 2) { + _gameSys->setAnimation(0, 0, 0); + if (_gnapActionStatus == kASLeaveScene) + _sceneDone = true; + _gnapActionStatus = -1; + } + + if (_gameSys->getAnimationStatus(3) == 2 && _s26_nextKidSequenceId != -1) { + _gameSys->insertSequence(_s26_nextKidSequenceId, 160, _s26_currKidSequenceId, 160, kSeqSyncWait, 0, 0, 0); + _gameSys->setAnimation(_s26_nextKidSequenceId, 160, 3); + _s26_currKidSequenceId = _s26_nextKidSequenceId; + _s26_nextKidSequenceId = -1; + } + +} + +} // End of namespace Gnap diff --git a/engines/gnap/scenes/scene27.cpp b/engines/gnap/scenes/scene27.cpp new file mode 100644 index 0000000000..000a94203c --- /dev/null +++ b/engines/gnap/scenes/scene27.cpp @@ -0,0 +1,423 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "gnap/gnap.h" +#include "gnap/gamesys.h" +#include "gnap/resource.h" + +namespace Gnap { + +enum { + kHSPlatypus = 0, + kHSJanitor = 1, + kHSDevice = 2, + kHSBucket = 3, + kHSExitCircus = 4, + kHSExitArcade = 5, + kHSExitBeerStand = 6, + kHSExitClown = 7, + kHSWalkArea1 = 8 +}; + +enum { + kASTalkJanitor = 0, + kASGrabBucket = 1, + kASGrabBucketDone = 2, + kASShowPictureToJanitor = 3, + kASTryEnterClownTent = 4, + kASTryEnterClownTentDone = 5, + kASEnterClownTent = 6, + kASLeaveScene = 7 +}; + +int GnapEngine::scene27_init() { + return 0xD5; +} + +void GnapEngine::scene27_updateHotspots() { + setHotspot(kHSPlatypus, 0, 0, 0, 0, SF_WALKABLE | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSJanitor, 488, 204, 664, 450, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR, 8, 8); + setHotspot(kHSBucket, 129, 406, 186, 453, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR, 3, 6); + setHotspot(kHSExitCircus, 200, 585, 700, 600, SF_EXIT_D_CURSOR | SF_WALKABLE, 5, 9); + setHotspot(kHSExitArcade, 0, 0, 15, 600, SF_EXIT_L_CURSOR, 0, 6); + setHotspot(kHSExitBeerStand, 785, 0, 800, 600, SF_EXIT_R_CURSOR, 11, 7); + setHotspot(kHSExitClown, 340, 240, 460, 420, SF_EXIT_U_CURSOR, 6, 8); + setHotspot(kHSWalkArea1, 0, 0, 800, 507); + setDeviceHotspot(kHSDevice, -1, -1, -1, -1); + if (isFlag(13)) + _hotspots[kHSBucket].flags = SF_DISABLED; + _hotspotsCount = 9; +} + +void GnapEngine::scene27_run() { + + playSound(0x1093B, 1); + startSoundTimerB(4); + _timers[7] = getRandom(100) + 300; + queueInsertDeviceIcon(); + + if (!isFlag(13)) + _gameSys->insertSequence(0xD3, 39, 0, 0, kSeqNone, 0, 0, 0); + + if (_debugLevel == 4) + startIdleTimer(6); + + _gameSys->insertSequence(0xCB, 39, 0, 0, kSeqNone, 0, 0, 0); + + _s27_currJanitorSequenceId = 0xCB; + _s27_nextJanitorSequenceId = -1; + + _gameSys->setAnimation(0xCB, 39, 3); + + _timers[5] = getRandom(20) + 60; + + switch (_prevSceneNum) { + case 26: + initGnapPos(7, 12, 1); + initBeaverPos(6, 12, 0); + endSceneInit(); + gnapWalkTo(7, 8, -1, 0x107B9, 1); + platypusWalkTo(6, 8, -1, 0x107C2, 1); + break; + case 29: + initGnapPos(-1, 8, 1); + initBeaverPos(-1, 9, 0); + endSceneInit(); + gnapWalkTo(3, 8, -1, 0x107B9, 1); + platypusWalkTo(3, 9, -1, 0x107C2, 1); + break; + case 31: + initGnapPos(12, 8, 3); + initBeaverPos(12, 9, 4); + endSceneInit(); + gnapWalkTo(8, 8, -1, 0x107BA, 1); + platypusWalkTo(8, 9, -1, 0x107C2, 1); + break; + default: + initGnapPos(6, 8, 1); + initBeaverPos(5, 9, 0); + endSceneInit(); + break; + } + + while (!_sceneDone) { + + updateMouseCursor(); + updateCursorByHotspot(); + _sceneClickedHotspot = -1; + if (_gnapActionStatus < 0) + _sceneClickedHotspot = getClickedHotspotId(); + updateGrabCursorSprite(0, 0); + + switch (_sceneClickedHotspot) { + + case kHSDevice: + if (_gnapActionStatus < 0) { + runMenu(); + scene27_updateHotspots(); + } + break; + + case kHSPlatypus: + if (_gnapActionStatus < 0) { + if (_grabCursorSpriteIndex == kItemJoint) { + gnapUseJointOnPlatypus(); + } else if (_grabCursorSpriteIndex >= 0) { + playGnapImpossible(0, 0); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapMoan1(_platX, _platY); + break; + case GRAB_CURSOR: + gnapKissPlatypus(0); + break; + case TALK_CURSOR: + playGnapBrainPulsating(_platX, _platY); + playBeaverSequence(getBeaverSequenceId(0, 0, 0) | 0x10000); + break; + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + } + break; + + case kHSJanitor: + if (_gnapActionStatus < 0) { + if (_grabCursorSpriteIndex == kItemPicture) { + _gnapIdleFacing = 5; + if (gnapWalkTo(_hotspotsWalkPos[kHSJanitor].x, _hotspotsWalkPos[kHSJanitor].y, 0, 0x107BC, 1)) + _gnapActionStatus = kASShowPictureToJanitor; + } else if (_grabCursorSpriteIndex >= 0) { + playGnapShowCurrItem(_hotspotsWalkPos[kHSJanitor].x, _hotspotsWalkPos[kHSJanitor].y, 7, 3); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapScratchingHead(6, 3); + break; + case TALK_CURSOR: + _gnapIdleFacing = 5; + gnapWalkTo(_hotspotsWalkPos[kHSJanitor].x, _hotspotsWalkPos[kHSJanitor].y, 0, getGnapSequenceId(gskBrainPulsating, 0, 0) | 0x10000, 1); + _gnapActionStatus = kASTalkJanitor; + break; + case GRAB_CURSOR: + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + } + break; + + case kHSBucket: + if (_gnapActionStatus < 0) { + if (_grabCursorSpriteIndex >= 0) { + playGnapShowItem(_grabCursorSpriteIndex, 3, 3); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapScratchingHead(3, 3); + break; + case GRAB_CURSOR: + _gnapIdleFacing = 5; + gnapWalkTo(_gnapX, _gnapY, 0, getGnapSequenceId(gskIdle, _hotspotsWalkPos[kHSBucket].x, _hotspotsWalkPos[kHSBucket].y) | 0x10000, 1); + _gnapActionStatus = kASGrabBucket; + break; + case TALK_CURSOR: + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + } + break; + + case kHSExitCircus: + if (_gnapActionStatus < 0) { + _isLeavingScene = true; + _newSceneNum = 26; + gnapWalkTo(-1, _hotspotsWalkPos[kHSExitCircus].y, 0, 0x107AE, 1); + _gnapActionStatus = kASLeaveScene; + platypusWalkTo(_hotspotsWalkPos[kHSExitCircus].x + 1, _hotspotsWalkPos[kHSExitCircus].y, -1, 0x107C7, 1); + } + break; + + case kHSExitArcade: + if (_gnapActionStatus < 0) { + _isLeavingScene = true; + _newSceneNum = 29; + gnapWalkTo(-1, _hotspotsWalkPos[kHSExitArcade].y, 0, 0x107AF, 1); + _gnapActionStatus = kASLeaveScene; + platypusWalkTo(_hotspotsWalkPos[kHSExitArcade].x, _hotspotsWalkPos[kHSExitArcade].y + 1, -1, 0x107CF, 1); + } + break; + + case kHSExitBeerStand: + if (_gnapActionStatus < 0) { + _isLeavingScene = 1; + _newSceneNum = 31; + gnapWalkTo(-1, _hotspotsWalkPos[kHSExitBeerStand].y, 0, 0x107AB, 1); + _gnapActionStatus = kASLeaveScene; + platypusWalkTo(_hotspotsWalkPos[kHSExitBeerStand].x, _hotspotsWalkPos[kHSExitBeerStand].y + 1, -1, 0x107CD, 1); + } + break; + + case kHSExitClown: + if (_gnapActionStatus < 0) { + if (isFlag(0)) { + _isLeavingScene = true; + _newSceneNum = 28; + gnapWalkTo(_hotspotsWalkPos[kHSExitClown].x, _hotspotsWalkPos[kHSExitClown].y, 0, 0x107AD, 1); + _gnapActionStatus = kASLeaveScene; + platypusWalkTo(_hotspotsWalkPos[kHSExitClown].x + 1, _hotspotsWalkPos[kHSExitClown].y, -1, 0x107C4, 1); + } else { + _hotspots[kHSWalkArea1].flags |= SF_WALKABLE; + gnapWalkTo(_hotspotsWalkPos[kHSExitClown].x, 7, 0, 0x107BC, 1); + _hotspots[kHSWalkArea1].flags &= SF_WALKABLE; + _gnapActionStatus = kASTryEnterClownTent; + } + } + break; + + case kHSWalkArea1: + if (_gnapActionStatus < 0) + gnapWalkTo(-1, -1, -1, -1, 1); + break; + + default: + if (_mouseClickState.left && _gnapActionStatus < 0) { + gnapWalkTo(-1, -1, -1, -1, 1); + _mouseClickState.left = false; + } + break; + + } + + scene27_updateAnimations(); + + if (!isSoundPlaying(0x1093B)) + playSound(0x1093B, 1); + + if (!_isLeavingScene) { + updateBeaverIdleSequence(); + if (_gnapActionStatus < 0) + updateGnapIdleSequence(); + if (_debugLevel == 4) + updateIdleTimer(); + if (!_timers[5]) { + _timers[5] = getRandom(20) + 60; + if (_gnapActionStatus < 0) { + if (getRandom(3) != 0) + _s27_nextJanitorSequenceId = 0xCB; + else + _s27_nextJanitorSequenceId = 0xCF; + } + } + if (!_timers[7]) { + _timers[7] = getRandom(100) + 300; + if (_gnapActionStatus < 0) + _gameSys->insertSequence(0xD4, 120, 0, 0, kSeqNone, 0, 0, 0); + } + playSoundB(); + } + + checkGameKeys(); + + if (isKeyStatus1(8)) { + clearKeyStatus1(8); + runMenu(); + scene27_updateHotspots(); + } + + gameUpdateTick(); + + } + +} + +void GnapEngine::scene27_updateAnimations() { + + if (_gameSys->getAnimationStatus(0) == 2) { + _gameSys->setAnimation(0, 0, 0); + switch (_gnapActionStatus) { + case kASTalkJanitor: + switch (getRandom(3)) { + case 0: + _s27_nextJanitorSequenceId = 0xCC; + break; + case 1: + _s27_nextJanitorSequenceId = 0xCD; + break; + case 2: + _s27_nextJanitorSequenceId = 0xCE; + break; + } + break; + case kASGrabBucket: + playGnapPullOutDevice(0, 0); + playGnapUseDevice(0, 0); + _hotspots[kHSBucket].flags = SF_DISABLED; + invAdd(kItemEmptyBucket); + setFlag(13); + _gameSys->setAnimation(0xD2, 39, 0); + _gameSys->insertSequence(0xD2, 39, 211, 39, kSeqSyncWait, 0, 0, 0); + _gnapActionStatus = kASGrabBucketDone; + break; + case kASGrabBucketDone: + setGrabCursorSprite(kItemEmptyBucket); + _gnapActionStatus = -1; + break; + case kASShowPictureToJanitor: + _s27_nextJanitorSequenceId = 0xD0; + break; + case kASTryEnterClownTent: + _s27_nextJanitorSequenceId = 0xD1; + _gameSys->insertSequence(0xD1, 39, _s27_currJanitorSequenceId, 39, 32, 0, 0, 0); + _gameSys->setAnimation(_s27_nextJanitorSequenceId, 39, 3); + _gameSys->setAnimation(_s27_nextJanitorSequenceId, 39, 0); + _s27_currJanitorSequenceId = _s27_nextJanitorSequenceId; + _s27_nextJanitorSequenceId = -1; + _gnapActionStatus = kASTryEnterClownTentDone; + break; + case kASTryEnterClownTentDone: + _hotspots[kHSWalkArea1].flags |= SF_WALKABLE; + gnapWalkTo(_hotspotsWalkPos[7].x, 9, -1, 0x107BC, 1); + _hotspots[kHSWalkArea1].flags &= ~SF_WALKABLE; + _gnapActionStatus = -1; + break; + case kASEnterClownTent: + gnapWalkTo(_gnapX, _gnapY, 0, 0x107B2, 1); + _gnapActionStatus = kASLeaveScene; + break; + case kASLeaveScene: + _sceneDone = true; + break; + } + } + + if (_gameSys->getAnimationStatus(3) == 2) { + switch (_s27_nextJanitorSequenceId) { + case -1: + _s27_nextJanitorSequenceId = 0xCB; + _gameSys->insertSequence(0xCB, 39, _s27_currJanitorSequenceId, 39, kSeqSyncWait, 0, 0, 0); + _gameSys->setAnimation(_s27_nextJanitorSequenceId, 39, 3); + _s27_currJanitorSequenceId = _s27_nextJanitorSequenceId; + _s27_nextJanitorSequenceId = -1; + break; + case 0xCC: + case 0xCD: + case 0xCE: + _gnapActionStatus = -1; + _gameSys->insertSequence(_s27_nextJanitorSequenceId, 39, _s27_currJanitorSequenceId, 39, kSeqSyncWait, 0, 0, 0); + _gameSys->setAnimation(_s27_nextJanitorSequenceId, 39, 3); + _gameSys->setAnimation(_s27_nextJanitorSequenceId, 39, 0); + _s27_currJanitorSequenceId = _s27_nextJanitorSequenceId; + _s27_nextJanitorSequenceId = -1; + break; + case 0xD0: + // Show picture to janitor + playGnapPullOutDevice(0, 0); + playGnapUseDevice(0, 0); + _gameSys->insertSequence(_s27_nextJanitorSequenceId, 39, _s27_currJanitorSequenceId, 39, kSeqSyncWait, 0, 0, 0); + _gameSys->setAnimation(_s27_nextJanitorSequenceId, 39, 0); + _gnapActionStatus = kASEnterClownTent; + _s27_currJanitorSequenceId = _s27_nextJanitorSequenceId; + _s27_nextJanitorSequenceId = -1; + setFlag(0); + setGrabCursorSprite(-1); + invRemove(kItemPicture); + _newSceneNum = 28; + break; + default: + _gameSys->insertSequence(_s27_nextJanitorSequenceId, 39, _s27_currJanitorSequenceId, 39, kSeqSyncWait, 0, 0, 0); + _gameSys->setAnimation(_s27_nextJanitorSequenceId, 39, 3); + _s27_currJanitorSequenceId = _s27_nextJanitorSequenceId; + _s27_nextJanitorSequenceId = -1; + break; + } + } + +} + +} // End of namespace Gnap diff --git a/engines/gnap/scenes/scene28.cpp b/engines/gnap/scenes/scene28.cpp new file mode 100644 index 0000000000..23c3e52974 --- /dev/null +++ b/engines/gnap/scenes/scene28.cpp @@ -0,0 +1,435 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "gnap/gnap.h" +#include "gnap/gamesys.h" +#include "gnap/resource.h" + +namespace Gnap { + +enum { + kHSPlatypus = 0, + kHSHorn = 1, + kHSClown = 2, + kHSExitOutsideClown = 3, + kHSUnknown = 4, + kHSDevice = 5, + kHSWalkArea1 = 6, + kHSWalkArea2 = 7 +}; + +int GnapEngine::scene28_init() { + return 0x125; +} + +void GnapEngine::scene28_updateHotspots() { + setHotspot(kHSPlatypus, 0, 0, 0, 0, SF_WALKABLE | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSHorn, 148, 352, 215, 383, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR, 1, 7); + setHotspot(kHSClown, 130, 250, 285, 413, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR, 3, 5); + setHotspot(kHSExitOutsideClown, 660, 190, 799, 400, SF_EXIT_R_CURSOR, 9, 6); + setHotspot(kHSUnknown, 582, 421, 643, 478, SF_WALKABLE | SF_DISABLED, 9, 7); + setHotspot(kHSWalkArea1, 0, 0, 799, 523); + setHotspot(kHSWalkArea2, 0, 0, 0, 0, 7, SF_DISABLED); + setDeviceHotspot(kHSDevice, -1, -1, -1, -1); + if (invHas(kItemHorn)) + _hotspots[kHSHorn].flags = SF_DISABLED; + if (isFlag(22)) + _hotspots[kHSUnknown].flags = SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR; + _hotspotsCount = 8; +} + +void GnapEngine::scene28_run() { + + playSound(0x1093C, 1); + _s28_dword_47EA60 = -1; + queueInsertDeviceIcon(); + _gameSys->insertSequence(0x124, 255, 0, 0, kSeqNone, 0, 0, 0); + + if (isFlag(22)) + _gameSys->insertSequence(0x112, 99, 0, 0, kSeqNone, 0, 0, 0); + + if (isFlag(1)) { + if (isFlag(21)) { + _gameSys->setAnimation(0x11C, 39, 3); + _gameSys->insertSequence(0x11C, 39, 0, 0, kSeqNone, 0, 0, 0); + if (!invHas(kItemHorn)) + _gameSys->insertSequence(0x118, 59, 0, 0, kSeqNone, 0, 0, 0); + _s28_dword_47EA5C = 0x11C; + } else { + _s28_dword_47EA5C = 0x11B; + _gameSys->setAnimation(0x11B, 39, 3); + _gameSys->insertSequence(_s28_dword_47EA5C, 39, 0, 0, kSeqNone, 0, 0, 0); + _timers[4] = getRandom(20) + 80; + } + initGnapPos(8, 8, 3); + initBeaverPos(9, 8, 4); + endSceneInit(); + } else { + _gameSys->insertSequence(0x11B, 39, 0, 0, kSeqNone, 0, 0, 0); + initGnapPos(8, 8, 3); + initBeaverPos(9, 8, 4); + endSceneInit(); + playSequences(0xF7, 0x121, 0x122, 0x123); + _s28_dword_47EA5C = 0x115; + setFlag(1); + _gameSys->setAnimation(0x115, 39, 3); + _gameSys->insertSequence(_s28_dword_47EA5C, 39, 283, 39, kSeqSyncWait, 0, 0, 0); + _s28_dword_47EA60 = -1; + _timers[4] = getRandom(20) + 80; + _gnapActionStatus = 9; + while (_gameSys->getAnimationStatus(3) != 2) { + gameUpdateTick(); + updateMouseCursor(); + } + _gnapActionStatus = -1; + } + + while (!_sceneDone) { + + updateMouseCursor(); + updateCursorByHotspot(); + + _sceneClickedHotspot = getClickedHotspotId(); + updateGrabCursorSprite(0, 0); + + switch (_sceneClickedHotspot) { + + case kHSDevice: + if (_gnapActionStatus < 0) { + runMenu(); + scene28_updateHotspots(); + } + break; + + case kHSPlatypus: + if (_gnapActionStatus < 0) { + if (_grabCursorSpriteIndex == kItemJoint) { + gnapUseJointOnPlatypus(); + } else if (_grabCursorSpriteIndex >= 0) { + playGnapImpossible(0, 0); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapMoan1(_platX, _platY); + break; + case GRAB_CURSOR: + gnapKissPlatypus(0); + break; + case TALK_CURSOR: + playGnapBrainPulsating(_platX, _platY); + playBeaverSequence(getBeaverSequenceId(0, 0, 0) | 0x10000); + break; + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + } + break; + + case kHSHorn: + if (_gnapActionStatus < 0) { + if (_grabCursorSpriteIndex >= 0) { + playGnapShowCurrItem(2, 8, 3, 4); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapScratchingHead(2, 4); + break; + case GRAB_CURSOR: + if (isFlag(21)) { + if (!invHas(kItemHorn)) { + gnapWalkTo(_gnapX, _gnapY, 0, getGnapSequenceId(gskIdle, _hotspotsWalkPos[kHSHorn].x, _hotspotsWalkPos[kHSHorn].y) | 0x10000, 1); + _gnapActionStatus = 4; + } + } else { + _gnapIdleFacing = 5; + gnapWalkTo(2, 8, 0, 0x107BB, 1); + _hotspots[kHSWalkArea1].flags |= SF_WALKABLE; + gnapWalkTo(_hotspotsWalkPos[kHSHorn].x, _hotspotsWalkPos[kHSHorn].y, 0, 0x107BB, 1); + _hotspots[kHSWalkArea1].flags &= ~SF_WALKABLE; + _gnapActionStatus = 2; + } + break; + case TALK_CURSOR: + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + } + break; + + case kHSClown: + if (_gnapActionStatus < 0) { + if (isFlag(21)) { + if (_verbCursor == LOOK_CURSOR) + playGnapScratchingHead(5, 2); + else + playGnapImpossible(0, 0); + } else if (_grabCursorSpriteIndex == kItemBucketWithBeer) { + _gnapIdleFacing = 5; + gnapWalkTo(_hotspotsWalkPos[kHSClown].x, _hotspotsWalkPos[kHSClown].y, 0, 0x107BC, 1); + playGnapPullOutDevice(0, 0); + playGnapUseDevice(0, 0); + _gnapActionStatus = 0; + } else if (_grabCursorSpriteIndex == kItemBucketWithPill) { + _gnapIdleFacing = 5; + gnapWalkTo(_hotspotsWalkPos[kHSClown].x, _hotspotsWalkPos[kHSClown].y, 0, 0x107BC, 1); + playGnapPullOutDevice(0, 0); + playGnapUseDevice(0, 0); + _gnapActionStatus = 1; + } else if (_grabCursorSpriteIndex >= 0) { + playGnapShowCurrItem(_hotspotsWalkPos[kHSClown].x, _hotspotsWalkPos[kHSClown].y, 2, 4); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapScratchingHead(5, 2); + break; + case TALK_CURSOR: + _gnapIdleFacing = 5; + gnapWalkTo(5, 8, 0, getGnapSequenceId(gskBrainPulsating, 0, 0) | 0x10000, 1); + _gnapActionStatus = 8; + break; + case GRAB_CURSOR: + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + } + break; + + case kHSExitOutsideClown: + if (_gnapActionStatus < 0) { + _isLeavingScene = true; + _newSceneNum = 27; + _hotspots[kHSWalkArea1].flags |= SF_WALKABLE; + gnapWalkTo(_hotspotsWalkPos[kHSExitOutsideClown].x, _hotspotsWalkPos[kHSExitOutsideClown].y, 0, 0x107BF, 1); + _gnapActionStatus = 10; + _hotspots[kHSWalkArea1].flags &= ~SF_WALKABLE; + platypusWalkTo(_hotspotsWalkPos[kHSExitOutsideClown].x - 1, _hotspotsWalkPos[kHSExitOutsideClown].y, -1, 0x107C2, 1); + } + break; + + case kHSUnknown: + if (_gnapActionStatus < 0) { + if (_grabCursorSpriteIndex >= 0) { + playGnapShowItem(_grabCursorSpriteIndex, 8, 6); + } else if (isFlag(21)) { + playGnapImpossible(8, 6); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapScratchingHead(8, 6); + break; + case GRAB_CURSOR: + gnapWalkTo(_gnapX, _gnapY, 0, getGnapSequenceId(gskIdle, _hotspotsWalkPos[kHSUnknown].x, _hotspotsWalkPos[kHSUnknown].y) | 0x10000, 1); + _gnapActionStatus = 3; + break; + case TALK_CURSOR: + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + } + break; + + case kHSWalkArea1: + case kHSWalkArea2: + if (_gnapActionStatus < 0) + gnapWalkTo(-1, -1, -1, -1, 1); + break; + + default: + if (_mouseClickState.left && _gnapActionStatus < 0) { + gnapWalkTo(-1, -1, -1, -1, 1); + _mouseClickState.left = false; + } + break; + + } + + scene28_updateAnimations(); + + if (!isSoundPlaying(0x1093C)) + playSound(0x1093C, 1); + + if (!_isLeavingScene) { + updateBeaverIdleSequence(); + updateGnapIdleSequence(); + if (!_timers[4]) { + _timers[4] = getRandom(20) + 80; + if (_gnapActionStatus < 0 && !isFlag(21)) + _s28_dword_47EA60 = 0x114; + } + } + + checkGameKeys(); + + if (isKeyStatus1(8)) { + clearKeyStatus1(8); + runMenu(); + scene28_updateHotspots(); + } + + gameUpdateTick(); + + } + +} + +void GnapEngine::scene28_updateAnimations() { + + if (_gameSys->getAnimationStatus(0) == 2) { + _gameSys->setAnimation(0, 0, 0); + switch (_gnapActionStatus) { + case 0: + setFlag(22); + _s28_dword_47EA60 = 275; + invRemove(kItemBucketWithBeer); + scene28_updateHotspots(); + break; + case 1: + _s28_dword_47EA60 = 0x116; + invRemove(kItemBucketWithPill); + setFlag(22); + setFlag(21); + scene28_updateHotspots(); + break; + case 2: + _s28_dword_47EA60 = 0x119; + break; + case 3: + playGnapPullOutDevice(0, 0); + playGnapUseDevice(0, 0); + _gameSys->setAnimation(0x111, 99, 0); + _gameSys->insertSequence(0x111, 99, 274, 99, kSeqSyncWait, 0, 0, 0); + _gnapActionStatus = 6; + break; + case 4: + playGnapPullOutDevice(0, 0); + playGnapUseDevice(0, 0); + _gameSys->setAnimation(0x117, 59, 0); + _gameSys->insertSequence(0x117, 59, 280, 59, kSeqSyncWait, 0, 0, 0); + _gnapActionStatus = 5; + break; + case 5: + hideCursor(); + setGrabCursorSprite(-1); + addFullScreenSprite(0xF6, 255); + _gameSys->setAnimation(0x120, 256, 0); + _gameSys->insertSequence(0x120, 256, 0, 0, kSeqNone, 0, 0, 0); + while (_gameSys->getAnimationStatus(0) != 2) + gameUpdateTick(); + removeFullScreenSprite(); + showCursor(); + setGrabCursorSprite(kItemHorn); + invAdd(kItemHorn); + scene28_updateHotspots(); + _gnapActionStatus = -1; + break; + case 6: + setGrabCursorSprite(kItemEmptyBucket); + clearFlag(22);; + scene28_updateHotspots(); + invAdd(kItemEmptyBucket); + _gnapActionStatus = -1; + break; + case 7: + _gameSys->insertSequence(0x107B5, _gnapId, 281, 39, kSeqSyncWait, 0, 75 * _gnapX - _gnapGridX, 48 * _gnapY - _gnapGridY); + _gnapSequenceId = 0x7B5; + _gnapSequenceDatNum = 1; + _gameSys->insertSequence(0x11B, 39, 0, 0, kSeqNone, 0, 0, 0); + _s28_dword_47EA5C = 0x11B; + _s28_dword_47EA60 = -1; + _gnapActionStatus = -1; + gnapWalkTo(2, 8, -1, 0x107BB, 1); + break; + case 8: + _s28_dword_474938 = (_s28_dword_474938 + 1) % 2; + if (_s28_dword_474938 == 0) + _s28_dword_47EA60 = 0x11D; + else if (_s28_dword_474938 == 1) + _s28_dword_47EA60 = 0x11E; + else if (_s28_dword_474938 == 2) + _s28_dword_47EA60 = 0x11F; // NOTE CHECKME Never set, bug in the original? + break; + case 9: + _gnapActionStatus = -1; + break; + case 10: + _sceneDone = true; + break; + } + } + + if (_gameSys->getAnimationStatus(3) == 2) { + switch (_s28_dword_47EA60) { + case 0x113: + setGrabCursorSprite(-1); + _gameSys->setAnimation(_s28_dword_47EA60, 39, 0); + _gameSys->insertSequence(0x112, 99, 0, 0, kSeqNone, getSequenceTotalDuration(_s28_dword_47EA60), 0, 0); + _gameSys->insertSequence(_s28_dword_47EA60, 39, _s28_dword_47EA5C, 39, kSeqSyncWait, 0, 0, 0); + _gameSys->insertSequence(0x11B, 39, _s28_dword_47EA60, 39, kSeqSyncWait, 0, 0, 0); + _s28_dword_47EA5C = 0x11B; + _s28_dword_47EA60 = -1; + _gnapActionStatus = 9; + break; + case 0x116: + setGrabCursorSprite(-1); + _gameSys->setAnimation(_s28_dword_47EA60, 39, 0); + _gameSys->insertSequence(0x112, 99, 0, 0, kSeqNone, getSequenceTotalDuration(_s28_dword_47EA60), 0, 0); + _gameSys->insertSequence(_s28_dword_47EA60, 39, _s28_dword_47EA5C, 39, kSeqSyncWait, 0, 0, 0); + _gameSys->insertSequence(0x11C, 39, _s28_dword_47EA60, 39, kSeqSyncWait, 0, 0, 0); + _gameSys->insertSequence(0x118, 59, 0, 0, kSeqNone, getSequenceTotalDuration(_s28_dword_47EA60), 0, 0); + _s28_dword_47EA5C = _s28_dword_47EA60; + _s28_dword_47EA60 = -1; + _gnapActionStatus = 9; + break; + case 0x11D: + case 0x11E: + case 0x11F: + _gnapActionStatus = -1; + break; + case 0x119: + _gameSys->insertSequence(_s28_dword_47EA60, 39, makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, kSeqSyncWait, 0, 0, 0); + _gameSys->setAnimation(_s28_dword_47EA60, 39, 0); + _gameSys->removeSequence(_s28_dword_47EA5C, 39, 1); + _gnapActionStatus = 7; + _gnapSequenceId = _s28_dword_47EA60; + _gnapSequenceDatNum = 0; + _s28_dword_47EA60 = -1; + break; + } + if (_s28_dword_47EA60 != -1) { + _gameSys->insertSequence(_s28_dword_47EA60, 39, _s28_dword_47EA5C, 39, kSeqSyncWait, 0, 0, 0); + _gameSys->setAnimation(_s28_dword_47EA60, 39, 3); + _s28_dword_47EA5C = _s28_dword_47EA60; + _s28_dword_47EA60 = -1; + } + } + +} + +} // End of namespace Gnap diff --git a/engines/gnap/scenes/scene29.cpp b/engines/gnap/scenes/scene29.cpp new file mode 100644 index 0000000000..3a78107db5 --- /dev/null +++ b/engines/gnap/scenes/scene29.cpp @@ -0,0 +1,352 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "gnap/gnap.h" +#include "gnap/gamesys.h" +#include "gnap/resource.h" + +namespace Gnap { + +enum { + kHSPlatypus = 0, + kHSMonkey = 1, + kHSDevice = 2, + kHSExitCircus = 3, + kHSExitOutsideClown = 4, + kHSAracde = 5, + kHSWalkArea1 = 6 +}; + +int GnapEngine::scene29_init() { + return 0xF6; +} + +void GnapEngine::scene29_updateHotspots() { + setHotspot(kHSPlatypus, 0, 0, 0, 0, SF_WALKABLE | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSMonkey, 410, 374, 518, 516, SF_WALKABLE | SF_DISABLED, 3, 7); + setHotspot(kHSExitCircus, 150, 585, 650, 600, SF_EXIT_D_CURSOR | SF_WALKABLE, 5, 9); + setHotspot(kHSExitOutsideClown, 785, 0, 800, 600, SF_EXIT_R_CURSOR | SF_WALKABLE, 11, 9); + setHotspot(kHSAracde, 88, 293, 155, 384, SF_WALKABLE | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR, 3, 8); + setHotspot(kHSWalkArea1, 0, 0, 800, 478); + setDeviceHotspot(kHSDevice, -1, -1, -1, -1); + if (invHas(kItemHorn)) + _hotspots[kHSMonkey].flags = SF_WALKABLE | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR; + _hotspotsCount = 7; +} + +void GnapEngine::scene29_run() { + + playSound(0x1093B, 1); + startSoundTimerB(6); + queueInsertDeviceIcon(); + + if (invHas(kItemHorn)) { + _s29_dword_47EA74 = 0xE8; + _s29_dword_47EA78 = -1; + _gameSys->setAnimation(0xE8, 159, 4); + _gameSys->insertSequence(_s29_dword_47EA74, 159, 0, 0, kSeqNone, 0, 0, 0); + _gameSys->insertSequence(0xED, 39, 0, 0, kSeqNone, 0, 0, 0); + _s29_dword_47EA7C = 0xED; + _s29_dword_47EA80 = -1; + _gameSys->setAnimation(0xED, 39, 3); + _timers[4] = getRandom(20) + 60; + } else { + _gameSys->insertSequence(0xF4, 19, 0, 0, kSeqNone, 0, 0, 0); + _gameSys->setAnimation(0, 0, 4); + _gameSys->insertSequence(0xED, 39, 0, 0, kSeqNone, 0, 0, 0); + _gameSys->setAnimation(0, 0, 3); + } + + _gameSys->insertSequence(0xF3, 39, 0, 0, kSeqLoop, 0, 0, 0); + _gameSys->insertSequence(0xF5, 38, 0, 0, kSeqLoop, 0, 0, 0); + + if (_prevSceneNum == 27) { + initGnapPos(12, 7, 1); + initBeaverPos(12, 8, 0); + endSceneInit(); + gnapWalkTo(8, 7, -1, 0x107B9, 1); + platypusWalkTo(8, 8, -1, 0x107C2, 1); + } else { + initGnapPos(-1, 7, 1); + initBeaverPos(-2, 7, 0); + endSceneInit(); + gnapWalkTo(2, 7, -1, 0x107B9, 1); + platypusWalkTo(1, 7, -1, 0x107C2, 1); + } + + while (!_sceneDone) { + + updateMouseCursor(); + updateCursorByHotspot(); + + _sceneClickedHotspot = getClickedHotspotId(); + updateGrabCursorSprite(0, 0); + + switch (_sceneClickedHotspot) { + + case kHSDevice: + if (_gnapActionStatus < 0) { + runMenu(); + scene29_updateHotspots(); + } + break; + + case kHSPlatypus: + if (_gnapActionStatus < 0) { + if (_grabCursorSpriteIndex == kItemJoint) { + gnapUseJointOnPlatypus(); + } else if (_grabCursorSpriteIndex >= 0) { + playGnapImpossible(0, 0); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapMoan1(_platX, _platY); + break; + case GRAB_CURSOR: + gnapKissPlatypus(0); + break; + case TALK_CURSOR: + playGnapBrainPulsating(_platX, _platY); + playBeaverSequence(getBeaverSequenceId(0, 0, 0) | 0x10000); + break; + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + } + break; + + case kHSMonkey: + if (_gnapActionStatus < 0) { + if (_grabCursorSpriteIndex == kItemBanana) { + _gnapIdleFacing = 1; + gnapWalkTo(_hotspotsWalkPos[kHSMonkey].x, _hotspotsWalkPos[kHSMonkey].y, 0, getGnapSequenceId(gskIdle, 0, 0) | 0x10000, 1); + _gnapActionStatus = 0; + _newSceneNum = 51; + _isLeavingScene = 1; + setGrabCursorSprite(-1); + } else if (_grabCursorSpriteIndex >= 0) { + playGnapShowCurrItem(_hotspotsWalkPos[kHSMonkey].x, _hotspotsWalkPos[kHSMonkey].y, 5, 6); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapScratchingHead(5, 6); + break; + case TALK_CURSOR: + playGnapBrainPulsating(_hotspotsWalkPos[kHSMonkey].x, _hotspotsWalkPos[kHSMonkey].y); + break; + case GRAB_CURSOR: + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + } + break; + + case kHSExitCircus: + if (_gnapActionStatus < 0) { + _isLeavingScene = 1; + _newSceneNum = 26; + gnapWalkTo(_hotspotsWalkPos[kHSExitCircus].x, _hotspotsWalkPos[kHSExitCircus].y, 0, 0x107AE, 1); + _gnapActionStatus = 2; + platypusWalkTo(_hotspotsWalkPos[kHSExitCircus].x + 1, _hotspotsWalkPos[kHSExitCircus].y, -1, -1, 1); + } + break; + + case kHSExitOutsideClown: + if (_gnapActionStatus < 0) { + _isLeavingScene = 1; + _newSceneNum = 27; + gnapWalkTo(_hotspotsWalkPos[kHSExitOutsideClown].x, _hotspotsWalkPos[kHSExitOutsideClown].y, 0, 0x107AB, 1); + _gnapActionStatus = 2; + platypusWalkTo(_hotspotsWalkPos[kHSExitOutsideClown].x, _hotspotsWalkPos[kHSExitOutsideClown].y - 1, -1, 0x107CD, 1); + } + break; + + case kHSAracde: + if (_gnapActionStatus < 0) { + if (_grabCursorSpriteIndex == kItemDiceQuarterHole) { + setGrabCursorSprite(-1); + _isLeavingScene = 1; + _newSceneNum = 52; + gnapWalkTo(_hotspotsWalkPos[kHSAracde].x, _hotspotsWalkPos[kHSAracde].y, 0, -1, 1); + playGnapIdle(_hotspotsWalkPos[kHSAracde].x, _hotspotsWalkPos[kHSAracde].y); + _gnapActionStatus = 2; + } else if (_grabCursorSpriteIndex >= 0) { + playGnapShowCurrItem(_hotspotsWalkPos[kHSAracde].x, _hotspotsWalkPos[kHSAracde].y, 2, 3); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapMoan2(0, 0); + break; + case GRAB_CURSOR: + case TALK_CURSOR: + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + } + break; + + case kHSWalkArea1: + if (_gnapActionStatus < 0) + gnapWalkTo(-1, -1, -1, -1, 1); + break; + + default: + if (_mouseClickState.left) { + gnapWalkTo(-1, -1, -1, -1, 1); + _mouseClickState.left = false; + } + break; + } + + scene29_updateAnimations(); + + if (!isSoundPlaying(0x1093B)) + playSound(0x1093B, 1); + + if (!_isLeavingScene) { + if (_gnapActionStatus < 0) { + updateGnapIdleSequence(); + updateBeaverIdleSequence(); + } + if (!_timers[4]) { + if (invHas(kItemHorn)) { + _timers[4] = getRandom(20) + 60; + if (_gnapActionStatus < 0) { + switch (getRandom(5)) { + case 0: + _s29_dword_47EA80 = 0xED; + break; + case 1: + _s29_dword_47EA80 = 0xEE; + break; + case 2: + _s29_dword_47EA80 = 0xEF; + break; + case 3: + _s29_dword_47EA80 = 0xF0; + break; + case 4: + _s29_dword_47EA80 = 0xF1; + break; + } + } + } + } + playSoundB(); + } + + checkGameKeys(); + + if (isKeyStatus1(8)) { + clearKeyStatus1(8); + runMenu(); + scene29_updateHotspots(); + } + + gameUpdateTick(); + + } + +} + +void GnapEngine::scene29_updateAnimations() { + + if (_gameSys->getAnimationStatus(0) == 2) { + _gameSys->setAnimation(0, 0, 0); + switch (_gnapActionStatus) { + case 0: + _s29_dword_47EA78 = 0xE5; + break; + case 1: + case 2: + _sceneDone = true; + break; + } + } + + if (_gameSys->getAnimationStatus(3) == 2 && _s29_dword_47EA80 != -1) { + _gameSys->insertSequence(_s29_dword_47EA80, 39, _s29_dword_47EA7C, 39, kSeqSyncWait, 0, 0, 0); + _gameSys->setAnimation(_s29_dword_47EA80, 39, 3); + _s29_dword_47EA7C = _s29_dword_47EA80; + _s29_dword_47EA80 = -1; + } + + if (_gameSys->getAnimationStatus(4) == 2) { + if (_s29_dword_47EA78 == 0xE5) { + _gameSys->insertSequence(0xF2, _gnapId, makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, kSeqSyncWait, 0, 0, 0); + _gnapSequenceDatNum = 0; + _gnapSequenceId = 0xF2; + _gameSys->setAnimation(0xE6, 159, 0); + _gameSys->setAnimation(0, 159, 4); + _gameSys->insertSequence(_s29_dword_47EA78, 159, _s29_dword_47EA74, 159, kSeqSyncWait, 0, 0, 0); + _gameSys->insertSequence(0xE6, 159, _s29_dword_47EA78, 159, kSeqSyncWait, 0, 0, 0); + _gnapActionStatus = 1; + _s29_dword_47EA74 = 0xE6; + _s29_dword_47EA78 = -1; + _timers[5] = 30; + while (_timers[5]) + gameUpdateTick(); + platypusWalkTo(0, 8, 1, 0x107CF, 1); + while (_gameSys->getAnimationStatus(1) != 2) + gameUpdateTick(); + } else if (_s29_dword_47EA78 == -1) { + switch (getRandom(6)) { + case 0: + _s29_dword_47EA78 = 0xE8; + break; + case 1: + _s29_dword_47EA78 = 0xE9; + break; + case 2: + _s29_dword_47EA78 = 0xEA; + break; + case 3: + _s29_dword_47EA78 = 0xEB; + break; + case 4: + _s29_dword_47EA78 = 0xEC; + break; + case 5: + _s29_dword_47EA78 = 0xE7; + break; + } + _gameSys->insertSequence(_s29_dword_47EA78, 159, _s29_dword_47EA74, 159, kSeqSyncWait, 0, 0, 0); + _gameSys->setAnimation(_s29_dword_47EA78, 159, 4); + _s29_dword_47EA74 = _s29_dword_47EA78; + _s29_dword_47EA78 = -1; + } else { + _gameSys->insertSequence(_s29_dword_47EA78, 159, _s29_dword_47EA74, 159, kSeqSyncWait, 0, 0, 0); + _gameSys->setAnimation(_s29_dword_47EA78, 159, 4); + _s29_dword_47EA74 = _s29_dword_47EA78; + _s29_dword_47EA78 = -1; + } + } + +} + +} // End of namespace Gnap diff --git a/engines/gnap/scenes/scene30.cpp b/engines/gnap/scenes/scene30.cpp new file mode 100644 index 0000000000..341caee618 --- /dev/null +++ b/engines/gnap/scenes/scene30.cpp @@ -0,0 +1,281 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "gnap/gnap.h" +#include "gnap/gamesys.h" +#include "gnap/resource.h" + +namespace Gnap { + +enum { + kHSPlatypus = 0, + kHSPillMachine = 1, + kHSDevice = 2, + kHSExitCircus = 3, + kHSWalkArea1 = 4 +}; + +int GnapEngine::scene30_init() { + return isFlag(23) ? 0x10B : 0x10A; +} + +void GnapEngine::scene30_updateHotspots() { + setHotspot(kHSPlatypus, 0, 0, 0, 0, SF_WALKABLE | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSPillMachine, 598, 342, 658, 426, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR, 9, 7); + setHotspot(kHSExitCircus, 100, 590, 700, 600, SF_EXIT_D_CURSOR | SF_WALKABLE, 5, 9); + setHotspot(kHSExitCircus, 0, 0, 800, 514); + setDeviceHotspot(kHSDevice, -1, -1, -1, -1); + _hotspotsCount = 5; +} + +void GnapEngine::scene30_run() { + bool hasTakenPill = false; + + playSound(0x1093B, 1); + startSoundTimerB(6); + + queueInsertDeviceIcon(); + + if (isFlag(23)) + _gameSys->insertSequence(0x106, 1, 0, 0, kSeqNone, 0, 0, 0); + + if (!isFlag(13)) + _gameSys->insertSequence(0x107, 1, 0, 0, kSeqNone, 0, 0, 0); + _timers[5] = getRandom(50) + 180; + + _gameSys->insertSequence(0x101, 40, 0, 0, kSeqNone, 0, 0, 0); + _timers[4] = getRandom(100) + 300; + + _s30_dword_47EA88 = 0x101; + initGnapPos(7, 12, 1); + initBeaverPos(6, 12, 0); + endSceneInit(); + gnapWalkTo(7, 8, -1, 0x107B9, 1); + platypusWalkTo(6, 8, -1, 0x107C2, 1); + + while (!_sceneDone) { + + updateMouseCursor(); + updateCursorByHotspot(); + + _sceneClickedHotspot = getClickedHotspotId(); + updateGrabCursorSprite(0, 0); + + switch (_sceneClickedHotspot) { + + case kHSDevice: + if (_gnapActionStatus < 0) { + runMenu(); + scene30_updateHotspots(); + } + break; + + case kHSPlatypus: + if (_gnapActionStatus < 0) { + if (_grabCursorSpriteIndex == kItemJoint) { + gnapUseJointOnPlatypus(); + } else if (_grabCursorSpriteIndex >= 0) { + playGnapImpossible(0, 0); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapMoan1(_platX, _platY); + break; + case GRAB_CURSOR: + gnapKissPlatypus(0); + break; + case TALK_CURSOR: + playGnapBrainPulsating(_platX, _platY); + playBeaverSequence(getBeaverSequenceId(0, 0, 0) | 0x10000); + break; + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + } + break; + + case kHSPillMachine: + if (_gnapActionStatus < 0) { + if (_grabCursorSpriteIndex == kItemDiceQuarterHole && !isFlag(23)) { + _hotspots[kHSWalkArea1].flags |= SF_WALKABLE; + gnapWalkTo(_hotspotsWalkPos[kHSPillMachine].x, _hotspotsWalkPos[kHSPillMachine].y, 0, 0x107BC, 1); + _hotspots[kHSWalkArea1].flags &= ~SF_WALKABLE; + _gnapActionStatus = 1; + hasTakenPill = true; + } else if (_grabCursorSpriteIndex >= 0) { + playGnapShowCurrItem(_hotspotsWalkPos[kHSPillMachine].x, _hotspotsWalkPos[kHSPillMachine].y, 8, 5); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + gnapWalkTo(9, 8, 0, 0x107BC, 1); + _gnapActionStatus = 3; + break; + case GRAB_CURSOR: + playGnapScratchingHead(8, 5); + break; + case TALK_CURSOR: + case PLAT_CURSOR: + playGnapImpossible(8, 5); + break; + } + } + } + break; + + case kHSExitCircus: + if (_gnapActionStatus < 0) { + _isLeavingScene = true; + if (hasTakenPill) + _newSceneNum = 47; + else + _newSceneNum = 26; + gnapWalkTo(-1, _hotspotsWalkPos[kHSExitCircus].y, 0, 0x107AE, 1); + _gnapActionStatus = 0; + platypusWalkTo(_hotspotsWalkPos[kHSExitCircus].x + 1, _hotspotsWalkPos[kHSExitCircus].y, -1, 0x107C2, 1); + } + break; + + case kHSWalkArea1: + if (_gnapActionStatus < 0) + gnapWalkTo(-1, -1, -1, -1, 1); + break; + + default: + if (_mouseClickState.left) { + gnapWalkTo(-1, -1, -1, -1, 1); + _mouseClickState.left = false; + } + break; + + } + + scene30_updateAnimations(); + + if (!isSoundPlaying(0x1093B)) + playSound(0x1093B, 1); + + if (!_isLeavingScene) { + updateBeaverIdleSequence(); + if (_gnapActionStatus < 0) + updateGnapIdleSequence(); + if (!_timers[4]) { + _timers[4] = getRandom(100) + 300; + if (_gnapActionStatus < 0) { + if (getRandom(5) == 1) { + _gameSys->insertSequence(0xFF, 40, 0, 0, kSeqNone, 0, 0, 0); + _gameSys->insertSequence(0x100, 40, _s30_dword_47EA88, 40, kSeqSyncWait, 0, 0, 0); + _s30_dword_47EA88 = 0x100; + } else { + _gameSys->insertSequence(0xFE, 40, 0, 0, kSeqNone, 0, 0, 0); + } + } + } + if (!_timers[5]) { + _timers[5] = getRandom(50) + 180; + if (_gnapActionStatus < 0) { + if (!isFlag(23) || hasTakenPill) + _s30_dword_47EA8C = 0x109; + else + _s30_dword_47EA8C = 0x108; + _gameSys->insertSequence(_s30_dword_47EA8C, 20, 0, 0, kSeqNone, 0, 0, 0); + } + } + playSoundB(); + } + + checkGameKeys(); + + if (isKeyStatus1(8)) { + clearKeyStatus1(8); + runMenu(); + scene30_updateHotspots(); + } + + gameUpdateTick(); + + } + +} + +void GnapEngine::scene30_updateAnimations() { + + if (_gameSys->getAnimationStatus(0) == 2) { + _gameSys->setAnimation(0, 0, 0); + switch (_gnapActionStatus) { + case 0: + _sceneDone = true; + break; + case 1: + setGrabCursorSprite(-1); + _gameSys->setAnimation(0x105, _gnapId, 0); + _gameSys->insertSequence(0x105, _gnapId, makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, kSeqSyncWait, 0, 0, 0); + _gnapSequenceId = 0x105; + _gnapSequenceDatNum = 0; + _gnapActionStatus = 2; + break; + case 2: + hideCursor(); + setGrabCursorSprite(-1); + addFullScreenSprite(0x3F, 255); + _gameSys->removeSequence(0x105, _gnapId, 1); + _gameSys->setAnimation(0x102, 256, 0); + _gameSys->insertSequence(0x102, 256, 0, 0, kSeqNone, 0, 0, 0); + while (_gameSys->getAnimationStatus(0) != 2) { + // checkGameAppStatus(); + gameUpdateTick(); + } + _gameSys->setAnimation(0x103, _gnapId, 0); + _gameSys->insertSequence(0x103, _gnapId, 0, 0, kSeqNone, 0, 0, 0); + removeFullScreenSprite(); + showCursor(); + _gnapActionStatus = 4; + invAdd(kItemPill); + setFlag(23); + break; + case 3: + if (isFlag(23)) + showFullScreenSprite(0xE3); + else + showFullScreenSprite(0xE2); + _gnapActionStatus = -1; + break; + case 4: + _gameSys->setAnimation(0x104, _gnapId, 0); + _gameSys->insertSequence(0x104, _gnapId, makeRid(_gnapSequenceDatNum, 0x103), _gnapId, kSeqSyncWait, 0, 0, 0); + _gnapSequenceId = 0x104; + _gnapSequenceDatNum = 0; + _gnapActionStatus = 5; + setGrabCursorSprite(kItemDiceQuarterHole); + break; + case 5: + _gameSys->insertSequence(0x106, 1, 0, 0, kSeqNone, 0, 0, 0); + gnapWalkTo(_hotspotsWalkPos[kHSPillMachine].x, _hotspotsWalkPos[kHSPillMachine].y + 1, -1, 0x107BC, 1); + _gnapActionStatus = -1; + break; + } + } + +} + +} // End of namespace Gnap diff --git a/engines/gnap/scenes/scene31.cpp b/engines/gnap/scenes/scene31.cpp new file mode 100644 index 0000000000..864dbf90bc --- /dev/null +++ b/engines/gnap/scenes/scene31.cpp @@ -0,0 +1,398 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "gnap/gnap.h" +#include "gnap/gamesys.h" +#include "gnap/resource.h" + +namespace Gnap { + +enum { + kHSPlatypus = 0, + kHSMeasuringClown = 1, + kHSBeerBarrel = 2, + kHSDevice = 3, + kHSExitCircus = 4, + kHSExitOutsideClown = 5, + kHSWalkArea1 = 6 +}; + +int GnapEngine::scene31_init() { + return 0x105; +} + +void GnapEngine::scene31_updateHotspots() { + setHotspot(kHSPlatypus, 0, 0, 0, 0, SF_WALKABLE | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSMeasuringClown, 34, 150, 256, 436, SF_WALKABLE | SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR, 0, 6); + setHotspot(kHSBeerBarrel, 452, 182, 560, 306, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR, 6, 7); + setHotspot(kHSExitCircus, 150, 585, 650, 600, SF_EXIT_D_CURSOR | SF_WALKABLE, 5, 9); + setHotspot(kHSExitOutsideClown, 0, 0, 15, 600, SF_EXIT_L_CURSOR | SF_WALKABLE, 0, 8); + setHotspot(kHSWalkArea1, 0, 0, 800, 480); + setDeviceHotspot(kHSDevice, -1, -1, -1, -1); + _hotspotsCount = 7; +} + +void GnapEngine::scene31_run() { + + playSound(0x1093B, 1); + startSoundTimerB(6); + + queueInsertDeviceIcon(); + + _s31_beerGuyDistracted = false; + _gameSys->insertSequence(0xFB, 39, 0, 0, kSeqNone, 0, 0, 0); + + _s31_dword_47EAA8 = 0xFB; + _s31_dword_47EAAC = -1; + + _gameSys->setAnimation(0xFB, 39, 3); + + _timers[4] = getRandom(20) + 60; + _timers[5] = getRandom(50) + 180; + + if (_prevSceneNum == 27) { + initGnapPos(-1, 8, 3); + initBeaverPos(-1, 9, 4); + endSceneInit(); + gnapWalkTo(3, 8, -1, 0x107BA, 1); + platypusWalkTo(3, 9, -1, 0x107D2, 1); + } else { + initGnapPos(7, 12, 1); + initBeaverPos(6, 12, 0); + endSceneInit(); + gnapWalkTo(7, 8, -1, 0x107BA, 1); + platypusWalkTo(6, 8, -1, 0x107D2, 1); + } + + while (!_sceneDone) { + + updateMouseCursor(); + updateCursorByHotspot(); + + _sceneClickedHotspot = getClickedHotspotId(); + updateGrabCursorSprite(0, 0); + + switch (_sceneClickedHotspot) { + + case kHSDevice: + if (_gnapActionStatus < 0 || _gnapActionStatus == 4) { + runMenu(); + scene31_updateHotspots(); + } + break; + + case kHSPlatypus: + if (_gnapActionStatus < 0) { + if (_grabCursorSpriteIndex == kItemJoint) { + gnapUseJointOnPlatypus(); + } else if (_grabCursorSpriteIndex >= 0) { + playGnapImpossible(0, 0); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapMoan1(_platX, _platY); + break; + case GRAB_CURSOR: + gnapKissPlatypus(0); + break; + case TALK_CURSOR: + playGnapBrainPulsating(_platX, _platY); + playBeaverSequence(getBeaverSequenceId(0, 0, 0) | 0x10000); + break; + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + } + break; + + case kHSMeasuringClown: + if (_gnapActionStatus < 0 || _gnapActionStatus == 4) { + if (_gnapActionStatus == 4) { + if (_verbCursor == LOOK_CURSOR) + playGnapScratchingHead(2, 2); + else + playGnapImpossible(0, 0); + } else if (_grabCursorSpriteIndex >= 0) { + playGnapShowCurrItem(_hotspotsWalkPos[kHSMeasuringClown].x, _hotspotsWalkPos[kHSMeasuringClown].y + 1, 2, 2); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapScratchingHead(2, 2); + break; + case GRAB_CURSOR: + gnapWalkTo(_hotspotsWalkPos[kHSMeasuringClown].x, _hotspotsWalkPos[kHSMeasuringClown].y + 1, -1, -1, 1); + _hotspots[kHSWalkArea1].flags |= SF_WALKABLE; + gnapWalkTo(_hotspotsWalkPos[kHSMeasuringClown].x, _hotspotsWalkPos[kHSMeasuringClown].y, 0, 0x107B9, 1); + _hotspots[kHSWalkArea1].flags &= ~SF_WALKABLE; + _gnapActionStatus = 5; + _timers[4] = 300; + break; + case TALK_CURSOR: + playGnapImpossible(0, 0); + break; + case PLAT_CURSOR: + if (!invHas(kItemBucketWithBeer)) { + gnapUseDeviceOnBeaver(); + platypusWalkTo(_hotspotsWalkPos[kHSMeasuringClown].x, _hotspotsWalkPos[kHSMeasuringClown].y + 1, 1, 0x107C2, 1); + _hotspots[kHSWalkArea1].flags |= SF_WALKABLE; + platypusWalkTo(_hotspotsWalkPos[kHSMeasuringClown].x, _hotspotsWalkPos[kHSMeasuringClown].y, 1, 0x107C2, 1); + _hotspots[kHSWalkArea1].flags &= ~SF_WALKABLE; + _beaverActionStatus = 4; + _gnapActionStatus = 4; + _timers[4] = 300; + } else + playGnapImpossible(0, 0); + break; + } + } + } + break; + + case kHSBeerBarrel: + if (_gnapActionStatus < 0 || _gnapActionStatus == 4) { + if (_grabCursorSpriteIndex == kItemEmptyBucket && _s31_beerGuyDistracted) { + setGrabCursorSprite(-1); + gnapWalkTo(_gnapX, _gnapY, -1, getGnapSequenceId(gskIdle, _hotspotsWalkPos[kHSBeerBarrel].x, _hotspotsWalkPos[kHSBeerBarrel].y) | 0x10000, 1); + _s31_dword_474940 += 5; + _gameSys->insertSequence(0xF8, 59, 0, 0, kSeqNone, 0, 0, 0); + playGnapPullOutDevice(6, 8); + playGnapUseDevice(0, 0); + gnapWalkTo(_hotspotsWalkPos[kHSBeerBarrel].x, _hotspotsWalkPos[kHSBeerBarrel].y, 0, 0x107BC, 1); + _gnapActionStatus = 2; + _timers[4] = 300; + } else if (_grabCursorSpriteIndex >= 0) { + playGnapShowCurrItem(_hotspotsWalkPos[kHSBeerBarrel].x, _hotspotsWalkPos[kHSBeerBarrel].y, 6, 2); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapScratchingHead(6, 2); + break; + case GRAB_CURSOR: + if (_s31_beerGuyDistracted) { + playGnapScratchingHead(6, 2); + } else { + gnapWalkTo(_hotspotsWalkPos[kHSBeerBarrel].x, _hotspotsWalkPos[kHSBeerBarrel].y, 0, 0x107BC, 1); + _gnapActionStatus = 1; + _gnapIdleFacing = 5; + } + break; + case TALK_CURSOR: + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + } + break; + + case kHSExitCircus: + if (_gnapActionStatus < 0) { + _isLeavingScene = 1; + _newSceneNum = 26; + gnapWalkTo(-1, _hotspotsWalkPos[kHSExitCircus].y, 0, 0x107AE, 1); + _gnapActionStatus = 6; + platypusWalkTo(_hotspotsWalkPos[kHSExitCircus].x + 1, _hotspotsWalkPos[kHSExitCircus].y, -1, -1, 1); + } + break; + + case kHSExitOutsideClown: + if (_gnapActionStatus < 0) { + _isLeavingScene = 1; + _newSceneNum = 27; + gnapWalkTo(-1, _hotspotsWalkPos[kHSExitOutsideClown].y, 0, 0x107AF, 1); + _gnapActionStatus = 6; + platypusWalkTo(_hotspotsWalkPos[kHSExitOutsideClown].x, _hotspotsWalkPos[kHSExitOutsideClown].y + 1, -1, 0x107CF, 1); + } + break; + + case kHSWalkArea1: + if (_gnapActionStatus < 0) + gnapWalkTo(-1, -1, -1, -1, 1); + break; + + default: + if (_mouseClickState.left) { + gnapWalkTo(-1, -1, -1, -1, 1); + _mouseClickState.left = false; + } + break; + } + + scene31_updateAnimations(); + + if (!isSoundPlaying(0x1093B)) + playSound(0x1093B, 1); + + if (!_isLeavingScene) { + if (_beaverActionStatus < 0) + updateBeaverIdleSequence(); + if (_gnapActionStatus < 0) + updateGnapIdleSequence(); + if (!_timers[4]) { + _timers[4] = getRandom(20) + 60; + if (_gnapActionStatus < 0 && _s31_dword_47EAAC == -1) { + switch (getRandom(6)){ + case 0: + _s31_dword_47EAAC = 0xFF; + break; + case 1: + _s31_dword_47EAAC = 0x100; + break; + case 2: + _s31_dword_47EAAC = 0x101; + break; + default: + _s31_dword_47EAAC = 0xFB; + break; + } + } + } + if (!_timers[5]) { + _timers[5] = getRandom(50) + 180; + if (_gnapActionStatus < 0) { + if (getRandom(2) != 0) + _s31_dword_47EAB4 = 0x104; + else + _s31_dword_47EAB4 = 0x103; + _gameSys->insertSequence(_s31_dword_47EAB4, 20, 0, 0, kSeqNone, 0, 0, 0); + } + } + playSoundB(); + } + + checkGameKeys(); + + if (isKeyStatus1(8)) { + clearKeyStatus1(8); + runMenu(); + scene31_updateHotspots(); + } + + gameUpdateTick(); + + } + +} + +void GnapEngine::scene31_updateAnimations() { + + if (_gameSys->getAnimationStatus(0) == 2) { + _gameSys->setAnimation(0, 0, 0); + switch (_gnapActionStatus) { + case 1: + _s31_dword_47EAAC = 0xFE; + break; + case 2: + _gameSys->setAnimation(0x102, 59, 0); + _gameSys->insertSequence(0x102, 59, makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, kSeqSyncWait, 0, 0, 0); + _gnapX = 5; + _gnapY = 7; + _gnapSequenceDatNum = 0; + _gnapSequenceId = 0x102; + _gnapId = 59; + _gnapActionStatus = 3; + break; + case 3: + _gnapIdleFacing = 3; + playGnapPullOutDevice(0, 0); + playGnapUseDevice(0, 0); + _gameSys->insertSequence(0xF9, 59, 0xF8, 59, kSeqSyncWait, 0, 0, 0); + _gnapActionStatus = -1; + invAdd(kItemBucketWithBeer); + invRemove(kItemEmptyBucket); + setGrabCursorSprite(kItemBucketWithBeer); + break; + case 5: + _s31_dword_47EAAC = 0xFA; + _s31_dword_474940 = 1; + break; + case 6: + _sceneDone = true; + _gnapActionStatus = -1; + break; + } + } + + if (_gameSys->getAnimationStatus(1) == 2) { + _gameSys->setAnimation(0, 0, 1); + if (_beaverActionStatus == 4) { + _sceneWaiting = 1; + _s31_beerGuyDistracted = true; + _s31_dword_47EAAC = 0xFA; + } + } + + if (_gameSys->getAnimationStatus(3) == 2) { + switch (_s31_dword_47EAAC) { + case 0xFA: + _gameSys->insertSequence(_s31_dword_47EAAC, 39, _s31_dword_47EAA8, 39, kSeqSyncWait, 0, 0, 0); + _gameSys->insertSequence(0xFC, 39, _s31_dword_47EAAC, 39, kSeqSyncWait, 0, 0, 0); + _gameSys->setAnimation(0xFC, 39, 3); + _s31_dword_47EAA8 = 0xFC; + _s31_dword_47EAAC = 0xFC; + _s31_dword_47EAB0 = 0; + break; + case 0xFC: + ++_s31_dword_47EAB0; + if (_s31_dword_47EAB0 >= _s31_dword_474940) { + if (_gnapActionStatus != 5) + _beaverActionStatus = -1; + _timers[0] = 40; + _gameSys->insertSequence(0xFD, 39, _s31_dword_47EAA8, 39, kSeqSyncWait, 0, 0, 0); + _s31_dword_47EAA8 = 0xFD; + _s31_dword_47EAAC = -1; + if (_gnapActionStatus != 3 && _gnapActionStatus != 2) + _gnapActionStatus = -1; + _s31_beerGuyDistracted = false; + _s31_dword_474940 = 3; + _gameSys->setAnimation(0xFD, 39, 3); + _sceneWaiting = 0; + } else { + _gameSys->insertSequence(_s31_dword_47EAAC, 39, _s31_dword_47EAA8, 39, kSeqSyncWait, 0, 0, 0); + _s31_dword_47EAA8 = _s31_dword_47EAAC; + _s31_dword_47EAAC = 0xFC; + _gameSys->setAnimation(0xFC, 39, 3); + } + break; + case 0xFE: + _gameSys->insertSequence(_s31_dword_47EAAC, 39, _s31_dword_47EAA8, 39, kSeqSyncWait, 0, 0, 0); + _gameSys->setAnimation(_s31_dword_47EAAC, 39, 3); + _s31_dword_47EAA8 = _s31_dword_47EAAC; + _s31_dword_47EAAC = -1; + _gnapActionStatus = -1; + break; + default: + if (_s31_dword_47EAAC != -1) { + _gameSys->insertSequence(_s31_dword_47EAAC, 39, _s31_dword_47EAA8, 39, kSeqSyncWait, 0, 0, 0); + _gameSys->setAnimation(_s31_dword_47EAAC, 39, 3); + _s31_dword_47EAA8 = _s31_dword_47EAAC; + _s31_dword_47EAAC = -1; + } + break; + } + } + +} + +} // End of namespace Gnap diff --git a/engines/gnap/scenes/scene32.cpp b/engines/gnap/scenes/scene32.cpp new file mode 100644 index 0000000000..3edd3db2cd --- /dev/null +++ b/engines/gnap/scenes/scene32.cpp @@ -0,0 +1,201 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "gnap/gnap.h" +#include "gnap/gamesys.h" +#include "gnap/resource.h" + +namespace Gnap { + +enum { + kHSPlatypus = 0, + kHSExitTruck = 1, + kHSDevice = 2, + kHSWalkArea1 = 3, + kHSWalkArea2 = 4, + kHSWalkArea3 = 5, + kHSWalkArea4 = 6, + kHSWalkArea5 = 7, + kHSWalkArea6 = 8, + kHSWalkArea7 = 9, + kHSWalkArea8 = 10 +}; + +int GnapEngine::scene32_init() { + _gameSys->setAnimation(0, 0, 0); + return isFlag(26) ? 0xF : 0x10; +} + +void GnapEngine::scene32_updateHotspots() { + setHotspot(kHSPlatypus, 0, 0, 0, 0, SF_WALKABLE | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSExitTruck, 780, 226, 800, 455, SF_EXIT_R_CURSOR | SF_WALKABLE, 10, 6); + setHotspot(kHSWalkArea1, 0, 0, 162, 426); + setHotspot(kHSWalkArea2, 162, 0, 237, 396); + setHotspot(kHSWalkArea3, 237, 0, 319, 363); + setHotspot(kHSWalkArea4, 520, 0, 800, 404); + setHotspot(kHSWalkArea5, 300, 447, 800, 600); + setHotspot(kHSWalkArea6, 678, 0, 800, 404); + setHotspot(kHSWalkArea7, 0, 0, 520, 351); + setHotspot(kHSWalkArea8, 0, 546, 300, 600); + setDeviceHotspot(kHSDevice, -1, -1, -1, -1); + _hotspotsCount = 11; +} + +void GnapEngine::scene32_run() { + + playSound(0x1091C, 1); + startSoundTimerC(5); + queueInsertDeviceIcon(); + _s32_dword_47EADC = -1; + _timers[4] = getRandom(100) + 300; + + if (_prevSceneNum == 33) { + initGnapPos(11, 6, 3); + initBeaverPos(12, 6, 4); + endSceneInit(); + platypusWalkTo(9, 6, -1, 0x107D2, 1); + gnapWalkTo(8, 6, -1, 0x107BA, 1); + } else { + initGnapPos(1, 6, 1); + initBeaverPos(1, 7, 0); + endSceneInit(); + } + + while (!_sceneDone) { + + updateMouseCursor(); + updateCursorByHotspot(); + testWalk(0, 0, -1, -1, -1, -1); + + _sceneClickedHotspot = getClickedHotspotId(); + updateGrabCursorSprite(0, 0); + + switch (_sceneClickedHotspot) { + + case kHSDevice: + if (_gnapActionStatus < 0) { + runMenu(); + scene32_updateHotspots(); + } + break; + + case kHSPlatypus: + if (_gnapActionStatus < 0) { + if (_grabCursorSpriteIndex >= 0) { + playGnapImpossible(_platX, _platY); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapMoan1(_platX, _platY); + break; + case GRAB_CURSOR: + gnapKissPlatypus(0); + break; + case TALK_CURSOR: + playGnapBrainPulsating(_platX, _platY); + playBeaverSequence(getBeaverSequenceId(0, 0, 0) | 0x10000); + break; + case PLAT_CURSOR: + playGnapImpossible(_platX, _platY); + break; + } + } + } + break; + + case kHSExitTruck: + if (_gnapActionStatus < 0) { + _isLeavingScene = 1; + setGrabCursorSprite(-1); + gnapWalkTo(_hotspotsWalkPos[kHSExitTruck].x, _hotspotsWalkPos[kHSExitTruck].y, 0, 0x107AB, 1); + _gnapActionStatus = 0; + platypusWalkTo(_hotspotsWalkPos[kHSExitTruck].x, _hotspotsWalkPos[kHSExitTruck].y + 1, -1, 0x107CD, 1); + _newSceneNum = 33; + } + break; + + case kHSWalkArea1: + case kHSWalkArea2: + case kHSWalkArea3: + case kHSWalkArea4: + case kHSWalkArea5: + case kHSWalkArea6: + case kHSWalkArea7: + case kHSWalkArea8: + if (_gnapActionStatus < 0) + gnapWalkTo(-1, -1, -1, -1, 1); + break; + + } + + if (_mouseClickState.left && _gnapActionStatus < 0) { + gnapWalkTo(-1, -1, -1, -1, 1); + _mouseClickState.left = 0; + } + + scene32_updateAnimations(); + + if (!isSoundPlaying(0x1091C)) + playSound(0x1091C, 1); + + if (!_isLeavingScene) { + if (_beaverActionStatus < 0) + updateBeaverIdleSequence(); + if (_gnapActionStatus < 0) + updateGnapIdleSequence(); + if (!_timers[4]) { + _timers[4] = getRandom(100) + 300; + if (getRandom(2) != 0) + _s32_dword_47EADC = 14; + else + _s32_dword_47EADC = 13; + _gameSys->insertSequence(_s32_dword_47EADC, 180, 0, 0, kSeqNone, 0, 0, 0); + } + playSoundC(); + } + + checkGameKeys(); + + if (isKeyStatus1(8)) { + clearKeyStatus1(8); + runMenu(); + scene32_updateHotspots(); + } + + gameUpdateTick(); + + } + +} + +void GnapEngine::scene32_updateAnimations() { + + if (_gameSys->getAnimationStatus(0) == 2) { + _gameSys->setAnimation(0, 0, 0); + if (_gnapActionStatus == 0) + _sceneDone = true; + } + +} + +} // End of namespace Gnap +
\ No newline at end of file diff --git a/engines/gnap/scenes/scene33.cpp b/engines/gnap/scenes/scene33.cpp new file mode 100644 index 0000000000..f9471abcd5 --- /dev/null +++ b/engines/gnap/scenes/scene33.cpp @@ -0,0 +1,327 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "gnap/gnap.h" +#include "gnap/gamesys.h" +#include "gnap/resource.h" + +namespace Gnap { + +enum { + kHSPlatypus = 0, + kHSChicken = 1, + kHSDevice = 2, + kHSExitHouse = 3, + kHSExitBarn = 4, + kHSExitCreek = 5, + kHSExitPigpen = 6, + kHSWalkArea1 = 7, + kHSWalkArea2 = 8 +}; + +int GnapEngine::scene33_init() { + return isFlag(26) ? 0x84 : 0x85; +} + +void GnapEngine::scene33_updateHotspots() { + setHotspot(kHSPlatypus, 0, 0, 0, 0, SF_WALKABLE | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSChicken, 606, 455, 702, 568, SF_WALKABLE | SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR, 7, 8); + setHotspot(kHSExitHouse, 480, 120, 556, 240, SF_EXIT_U_CURSOR, 7, 3); + setHotspot(kHSExitBarn, 610, 75, 800, 164, SF_EXIT_U_CURSOR, 10, 3); + setHotspot(kHSExitCreek, 780, 336, 800, 556, SF_EXIT_R_CURSOR | SF_WALKABLE, 10, 8); + setHotspot(kHSExitPigpen, 0, 300, 20, 600, SF_EXIT_L_CURSOR | SF_WALKABLE, 0, 8); + setHotspot(kHSWalkArea1, 120, 0, 514, 458); + setHotspot(kHSWalkArea2, 0, 0, 800, 452); + setDeviceHotspot(kHSDevice, -1, -1, -1, -1); + _hotspotsCount = 9; +} + +void GnapEngine::scene33_run() { + + playSound(0x1091C, 1); + startSoundTimerC(6); + queueInsertDeviceIcon(); + + _s33_dword_47EAEC = 0x7E; + _gameSys->setAnimation(0x7E, 179, 2); + _gameSys->insertSequence(_s33_dword_47EAEC, 179, 0, 0, kSeqNone, 0, 0, 0); + _s33_dword_47EAE4 = -1; + _timers[5] = getRandom(20) + 30; + _s33_dword_47EAE8 = -1; + _timers[4] = getRandom(100) + 300; + + switch (_prevSceneNum) { + case 34: + initGnapPos(11, 7, 3); + initBeaverPos(12, 7, 4); + endSceneInit(); + gnapWalkTo(8, 7, -1, 0x107BA, 1); + platypusWalkTo(9, 7, -1, 0x107D2, 1); + break; + case 37: + initGnapPos(7, 7, 1); + initBeaverPos(8, 7, 0); + endSceneInit(); + break; + case 32: + initGnapPos(-1, 6, 1); + initBeaverPos(-1, 7, 0); + endSceneInit(); + platypusWalkTo(2, 7, -1, 0x107C2, 1); + gnapWalkTo(2, 8, -1, 0x107B9, 1); + break; + default: + initGnapPos(3, 7, 1); + initBeaverPos(2, 7, 0); + endSceneInit(); + break; + } + + while (!_sceneDone) { + + updateMouseCursor(); + updateCursorByHotspot(); + testWalk(0, 0, 7, 6, 8, 6); + + _sceneClickedHotspot = getClickedHotspotId(); + updateGrabCursorSprite(0, 0); + + switch (_sceneClickedHotspot) { + + case kHSDevice: + if (_gnapActionStatus < 0) { + runMenu(); + scene33_updateHotspots(); + } + break; + + case kHSPlatypus: + if (_gnapActionStatus < 0) { + if (_grabCursorSpriteIndex >= 0) { + playGnapImpossible(_platX, _platY); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapMoan1(_platX, _platY); + break; + case GRAB_CURSOR: + gnapKissPlatypus(0); + break; + case TALK_CURSOR: + playGnapBrainPulsating(_platX, _platY); + playBeaverSequence(getBeaverSequenceId(0, 0, 0) | 0x10000); + break; + case PLAT_CURSOR: + playGnapImpossible(_platX, _platY); + break; + } + } + } + break; + + case kHSChicken: + if (_gnapActionStatus < 0) { + if (_grabCursorSpriteIndex >= 0) { + playGnapShowCurrItem(7, 9, 9, 8); + } else { + switch (_verbCursor) { + case GRAB_CURSOR: + _gnapIdleFacing = 1; + if (gnapWalkTo(_hotspotsWalkPos[kHSChicken].x, _hotspotsWalkPos[kHSChicken].y, 0, getGnapSequenceId(gskIdle, 0, 0) | 0x10000, 1)) + _gnapActionStatus = 2; + else + _gnapActionStatus = -1; + break; + case TALK_CURSOR: + _gnapIdleFacing = 1; + gnapWalkTo(_hotspotsWalkPos[kHSChicken].x, _hotspotsWalkPos[kHSChicken].y, 0, getGnapSequenceId(gskBrainPulsating, 0, 0) | 0x10000, 1); + _gnapActionStatus = 1; + break; + case LOOK_CURSOR: + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + } + break; + + case kHSExitHouse: + if (_gnapActionStatus < 0) { + _isLeavingScene = 1; + _gnapActionStatus = 0; + _newSceneNum = 37; + if (_gnapX > 6) + gnapWalkTo(_gnapX, _gnapY, 0, 0x107AD, 1); + else + gnapWalkTo(6, 7, 0, 0x107B1, 1); + } + break; + + case kHSExitBarn: + if (_gnapActionStatus < 0) { + _isLeavingScene = 1; + _gnapActionStatus = 0; + _newSceneNum = 35; + if (_gnapX > 7) + gnapWalkTo(_gnapX, _gnapY, 0, 0x107AD, 1); + else + gnapWalkTo(7, 7, 0, 0x107B1, 1); + } + break; + + case kHSExitCreek: + if (_gnapActionStatus < 0) { + _isLeavingScene = 1; + gnapWalkTo(_hotspotsWalkPos[kHSExitCreek].x, _hotspotsWalkPos[kHSExitCreek].y, 0, 0x107AB, 1); + _gnapActionStatus = 0; + platypusWalkTo(_hotspotsWalkPos[kHSExitCreek].x, _hotspotsWalkPos[kHSExitCreek].y, -1, 0x107CD, 1); + _newSceneNum = 34; + } + break; + + case kHSExitPigpen: + if (_gnapActionStatus < 0) { + _isLeavingScene = 1; + gnapWalkTo(_hotspotsWalkPos[kHSExitPigpen].x, _hotspotsWalkPos[kHSExitPigpen].y, 0, 0x107AF, 1); + _gnapActionStatus = 0; + platypusWalkTo(_hotspotsWalkPos[kHSExitPigpen].x, _hotspotsWalkPos[kHSExitPigpen].y, -1, 0x107CF, 1); + _newSceneNum = 32; + } + break; + + case kHSWalkArea1: + case kHSWalkArea2: + if (_gnapActionStatus < 0) + gnapWalkTo(-1, -1, -1, -1, 1); + break; + + default: + if (_mouseClickState.left && _gnapActionStatus < 0) { + gnapWalkTo(-1, -1, -1, -1, 1); + _mouseClickState.left = false; + } + break; + + } + + scene33_updateAnimations(); + + if (!isSoundPlaying(0x1091C)) + playSound(0x1091C, 1); + + if (!_isLeavingScene) { + if (_beaverActionStatus < 0) + updateBeaverIdleSequence(); + if (_gnapActionStatus < 0) + updateGnapIdleSequence(); + if (!_timers[4]) { + _timers[4] = getRandom(100) + 300; + if (getRandom(2) != 0) + _s33_dword_47EAE8 = 0x83; + else + _s33_dword_47EAE8 = 0x82; + _gameSys->insertSequence(_s33_dword_47EAE8, 256, 0, 0, kSeqNone, 0, 0, 0); + } + if (!_timers[5] && _s33_dword_47EAE4 == -1 && _gnapActionStatus != 1 && _gnapActionStatus != 2) { + if (getRandom(6) != 0) { + _s33_dword_47EAE4 = 0x7E; + _timers[5] = getRandom(20) + 30; + } else { + _s33_dword_47EAE4 = 0x80; + _timers[5] = getRandom(20) + 50; + } + } + playSoundC(); + } + + checkGameKeys(); + + if (isKeyStatus1(8)) { + clearKeyStatus1(8); + runMenu(); + scene33_updateHotspots(); + } + + gameUpdateTick(); + + } + +} + +void GnapEngine::scene33_updateAnimations() { + + if (_gameSys->getAnimationStatus(0) == 2) { + switch (_gnapActionStatus) { + case 0: + _sceneDone = true; + break; + case 1: + _s33_dword_47EAE4 = 0x7F; + break; + case 2: + _s33_dword_47EAE4 = 0x81; + _timers[2] = 100; + break; + case 3: + _gameSys->insertSequence(0x107B5, _gnapId, 0x81, 179, kSeqSyncWait, 0, 75 * _gnapX - _gnapGridX, 48 * _gnapY - _gnapGridY); + _gnapSequenceId = 0x7B5; + _gnapSequenceDatNum = 1; + _s33_dword_47EAEC = 0x7E; + _gameSys->setAnimation(0x7E, 179, 2); + _gameSys->insertSequence(_s33_dword_47EAEC, 179, 0, 0, kSeqNone, 0, 0, 0); + _gnapActionStatus = -1; + _timers[5] = 30; + break; + default: + _gnapActionStatus = -1; + break; + } + } + + if (_gameSys->getAnimationStatus(2) == 2) { + if (_s33_dword_47EAE4 == 0x81) { + _gameSys->setAnimation(_s33_dword_47EAE4, 179, 0); + _gameSys->insertSequence(_s33_dword_47EAE4, 179, makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, kSeqSyncWait, 0, 0, 0); + _gameSys->removeSequence(_s33_dword_47EAEC, 179, 1); + _s33_dword_47EAE4 = -1; + _s33_dword_47EAEC = -1; + _gnapActionStatus = 3; + _timers[5] = 500; + } else if (_s33_dword_47EAE4 == 0x7F) { + _gameSys->setAnimation(_s33_dword_47EAE4, 179, 2); + _gameSys->insertSequence(_s33_dword_47EAE4, 179, _s33_dword_47EAEC, 179, kSeqSyncWait, 0, 0, 0); + _s33_dword_47EAEC = _s33_dword_47EAE4; + _s33_dword_47EAE4 = -1; + _gnapActionStatus = -1; + } else if (_s33_dword_47EAE4 != -1) { + _gameSys->setAnimation(_s33_dword_47EAE4, 179, 2); + _gameSys->insertSequence(_s33_dword_47EAE4, 179, _s33_dword_47EAEC, 179, kSeqSyncWait, 0, 0, 0); + _s33_dword_47EAEC = _s33_dword_47EAE4; + _s33_dword_47EAE4 = -1; + } + } + +} + +} // End of namespace Gnap +
\ No newline at end of file diff --git a/engines/gnap/scenes/scene38.cpp b/engines/gnap/scenes/scene38.cpp new file mode 100644 index 0000000000..cfbaf9dcaf --- /dev/null +++ b/engines/gnap/scenes/scene38.cpp @@ -0,0 +1,355 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "gnap/gnap.h" +#include "gnap/gamesys.h" +#include "gnap/resource.h" + +namespace Gnap { + +enum { + kHSPlatypus = 0, + kHSExitHouse = 1, + kHSExitCave = 2, + kHSTrapDoorLid1 = 3, + kHSTrapDoorLid2 = 4, + kHSHuntingTrophy = 5, + kHSWalkArea1 = 6, + kHSDevice = 7, + kHSWalkArea2 = 8, + kHSWalkArea3 = 9, + kHSWalkArea4 = 10, + kHSWalkArea5 = 11, + kHSWalkArea6 = 12 +}; + +int GnapEngine::scene38_init() { + _gameSys->setAnimation(0, 0, 0); + _gameSys->setAnimation(0, 0, 1); + return 0xA5; +} + +void GnapEngine::scene38_updateHotspots() { + setHotspot(kHSPlatypus, 0, 0, 0, 0, SF_WALKABLE | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSExitHouse, 150, 585, 650, 600, SF_EXIT_D_CURSOR, 0, 8); + setHotspot(kHSExitCave, 430, 440, 655, 470, SF_WALKABLE, 0, 8); + setHotspot(kHSTrapDoorLid1, 525, 265, 640, 350, SF_DISABLED); + setHotspot(kHSTrapDoorLid2, 555, 350, 670, 430, SF_DISABLED); + setHotspot(kHSHuntingTrophy, 170, 85, 250, 190, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR, 0, 8); + setHotspot(kHSWalkArea1, 330, 270, 640, 380, SF_DISABLED | SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR, 0, 8); + setHotspot(kHSWalkArea2, 0, 0, 799, 396); + setHotspot(kHSWalkArea3, 0, 585, 799, 599, SF_WALKABLE | SF_DISABLED); + setHotspot(kHSWalkArea4, 0, 0, 97, 445); + setHotspot(kHSWalkArea5, 770, 0, 799, 445); + setHotspot(kHSWalkArea6, 393, 0, 698, 445, SF_WALKABLE | SF_DISABLED); + setDeviceHotspot(kHSDevice, -1, -1, -1, -1); + if (_beaverActionStatus == 6) + _hotspots[kHSPlatypus].flags = SF_WALKABLE | SF_DISABLED; + if (_beaverActionStatus == 6) + _hotspots[kHSExitCave].flags = SF_EXIT_D_CURSOR; + else if (_gnapActionStatus == 3) + _hotspots[kHSExitCave].flags = SF_EXIT_D_CURSOR; + if (_beaverActionStatus == 6) + _hotspots[kHSTrapDoorLid1].flags = SF_DISABLED; + else if (_gnapActionStatus == 3) + _hotspots[kHSTrapDoorLid1].flags = SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR; + if (_beaverActionStatus == 6) + _hotspots[kHSTrapDoorLid2].flags = SF_DISABLED; + else if (_gnapActionStatus == 3) + _hotspots[kHSTrapDoorLid2].flags = SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR; + if (_beaverActionStatus == 6) + _hotspots[kHSWalkArea6].flags = 0; + _hotspotsCount = 13; +} + +void GnapEngine::scene38_run() { + + queueInsertDeviceIcon(); + _gameSys->insertSequence(0x9B, 0, 0, 0, kSeqNone, 0, 0, 0); + + if (_prevSceneNum == 39) { + initGnapPos(3, 7, 3); + initBeaverPos(4, 7, 4); + } else { + initGnapPos(3, 8, 1); + initBeaverPos(4, 8, 0); + } + endSceneInit(); + + while (!_sceneDone) { + + updateMouseCursor(); + updateCursorByHotspot(); + + _sceneClickedHotspot = getClickedHotspotId(); + updateGrabCursorSprite(0, 0); + + switch (_sceneClickedHotspot) { + + case kHSDevice: + runMenu(); + scene38_updateHotspots(); + break; + + case kHSPlatypus: + if (_gnapActionStatus == 3) { + _gnapActionStatus = 4; + } else if (_grabCursorSpriteIndex >= 0) { + playGnapImpossible(_platX, _platY); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapMoan1(_platX, _platY); + break; + case GRAB_CURSOR: + gnapKissPlatypus(0); + break; + case TALK_CURSOR: + playGnapBrainPulsating(_platX, _platY); + playBeaverSequence(getBeaverSequenceId(0, 0, 0) | 0x10000); + break; + case PLAT_CURSOR: + playGnapImpossible(_platX, _platY); + break; + } + } + break; + + case kHSExitHouse: + if (_gnapActionStatus == 3) { + _gnapActionStatus = 4; + } else { + _isLeavingScene = 1; + gnapWalkTo(-1, -1, 0, 0x107AE, 1); + _gnapActionStatus = 0; + _newSceneNum = 37; + } + break; + + case kHSExitCave: + if (_gnapActionStatus == 3) { + _gnapActionStatus = 4; + if (_beaverActionStatus == 6) + _isLeavingScene = 1; + } else if (_beaverActionStatus == 6) { + _sceneWaiting = 0; + _isLeavingScene = 1; + gnapWalkTo(5, 7, 0, 0x107BB, 1); + _newSceneNum = 39; + _gnapActionStatus = 1; + } + break; + + case kHSTrapDoorLid1: + case kHSTrapDoorLid2: + if (_gnapActionStatus == 3) { + if (_beaverActionStatus == 6 && _verbCursor == PLAT_CURSOR) + _gnapActionStatus = 5; + else + _gnapActionStatus = 4; + } + break; + + case kHSHuntingTrophy: + if (_gnapActionStatus != 3) { + if (_grabCursorSpriteIndex >= 0) { + playGnapShowCurrItem(3, 6, 2, 0); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapScratchingHead(0, 0); + break; + case GRAB_CURSOR: + if (_beaverActionStatus == 6) + playGnapImpossible(0, 0); + else { + gnapWalkTo(3, 6, 0, 0x107BB, 1); + platypusWalkTo(4, 8, -1, -1, 1); + _gnapActionStatus = 2; + } + break; + case TALK_CURSOR: + playGnapBrainPulsating(2, 0); + break; + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + } + break; + + case kHSWalkArea1: + // Nothing + break; + + case kHSWalkArea2: + case kHSWalkArea3: + case kHSWalkArea4: + case kHSWalkArea5: + case kHSWalkArea6: + if (_gnapActionStatus == 3) + _gnapActionStatus = 4; + else if (_gnapActionStatus < 0) + gnapWalkTo(-1, -1, -1, -1, 1); + break; + + default: + if (_mouseClickState.left) { + if (_gnapActionStatus == 3) + _gnapActionStatus = 4; + else if (_gnapActionStatus < 0) + gnapWalkTo(-1, -1, -1, -1, 1); + _mouseClickState.left = false; + } + break; + + } + + scene38_updateAnimations(); + + if (!_isLeavingScene) { + updateBeaverIdleSequence(); + updateGnapIdleSequence(); + } + + checkGameKeys(); + + if (isKeyStatus1(8)) { + clearKeyStatus1(8); + runMenu(); + scene38_updateHotspots(); + } + + gameUpdateTick(); + + } + +} + +void GnapEngine::scene38_updateAnimations() { + + if (_gameSys->getAnimationStatus(0) == 2) { + _gameSys->setAnimation(0, 0, 0); + switch (_gnapActionStatus) { + case 0: + _sceneDone = true; + break; + case 1: + _gameSys->removeSequence(_beaverSequenceId | (_beaverSequenceDatNum << 16), _beaverId, 1); + _gameSys->insertSequence(0xA3, _gnapId, makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, kSeqSyncWait, 0, 0, 0); + _gnapSequenceId = 0xA3; + _gnapSequenceDatNum = 0; + _gameSys->setAnimation(0xA3, _gnapId, 0); + _gnapActionStatus = 0; + break; + case 2: + _gameSys->removeSequence(0x9B, 0, 1); + _gameSys->insertSequence(0x9C, _gnapId, makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, kSeqSyncWait, 0, 0, 0); + _gnapSequenceId = 0x9C; + _gnapSequenceDatNum = 0; + _gameSys->setAnimation(0x9C, _gnapId, 0); + _gnapActionStatus = 3; + scene38_updateHotspots(); + break; + case 3: + if (_beaverActionStatus != 6) + _sceneWaiting = 1; + if (_gnapSequenceId == 0xA4) { + _gameSys->insertSequence(0x9D, _gnapId, makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, kSeqSyncWait, 0, 0, 0); + _gnapSequenceId = 0x9D; + } else { + _gameSys->insertSequence(0xA4, _gnapId, makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, kSeqSyncWait, 0, 0, 0); + _gnapSequenceId = 0xA4; + } + _gnapSequenceDatNum = 0; + _gameSys->setAnimation(_gnapSequenceId, _gnapId, 0); + break; + case 4: + if (_gnapSequenceId == 0x9E) { + _gameSys->insertSequence(0x9B, 0, 0, 0, kSeqNone, 0, 0, 0); + _gnapActionStatus = -1; + } else if (_beaverActionStatus == 6) { + _gameSys->insertSequence(0xA0, _gnapId, makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, kSeqSyncWait, 0, 0, 0); + _gnapSequenceId = 0xA0; + _gnapSequenceDatNum = 0; + _gnapX = 3; + _gnapY = 6; + _gnapIdleFacing = 1; + if (_isLeavingScene) { + _sceneWaiting = 0; + gnapWalkTo(5, 7, 0, 0x107BB, 1); + _newSceneNum = 39; + _gnapActionStatus = 1; + } else { + _gnapActionStatus = -1; + } + } else { + _gameSys->insertSequence(0x9E, _gnapId, makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, kSeqSyncWait, 0, 0, 0); + _gnapSequenceId = 0x9E; + _gnapSequenceDatNum = 0; + _gnapX = 3; + _gnapY = 6; + _gnapIdleFacing = 1; + _gameSys->setAnimation(0x9E, _gnapId, 0); + _sceneWaiting = 0; + scene38_updateHotspots(); + } + break; + case 5: + _sceneWaiting = 0; + _gameSys->insertSequence(0x9F, _gnapId, makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, kSeqSyncWait, 0, 0, 0); + _gnapSequenceId = 0x9F; + _gnapSequenceDatNum = 0; + _gameSys->setAnimation(0x9F, _gnapId, 0); + _gnapActionStatus = 3; + if (_beaverFacing) + playBeaverSequence(0x107D5); + else + playBeaverSequence(0x107D4); + platypusWalkTo(8, 7, -1, 0x107D2, 1); + _gameSys->insertSequence(0xA1, _gnapId + 1, _beaverSequenceId | (_beaverSequenceDatNum << 16), _beaverId, kSeqSyncWait, 0, 0, 0); + _beaverSequenceId = 0xA1; + _beaverSequenceDatNum = 0; + _beaverId = _gnapId + 1; + _gameSys->setAnimation(0xA1, _gnapId + 1, 1); + _beaverActionStatus = 6; + scene38_updateHotspots(); + break; + } + } + + if (_gameSys->getAnimationStatus(1) == 2) { + _gameSys->setAnimation(0, 0, 1); + if (_beaverActionStatus == 6) { + _gameSys->insertSequence(0xA2, _beaverId, _beaverSequenceId | (_beaverSequenceDatNum << 16), _beaverId, kSeqSyncWait, 0, 0, 0); + _beaverSequenceId = 0xA2; + _beaverSequenceDatNum = 0; + scene38_updateHotspots(); + _sceneWaiting = true; + } + } + +} + +} // End of namespace Gnap +
\ No newline at end of file diff --git a/engines/gnap/scenes/scene39.cpp b/engines/gnap/scenes/scene39.cpp new file mode 100644 index 0000000000..7bf04de240 --- /dev/null +++ b/engines/gnap/scenes/scene39.cpp @@ -0,0 +1,237 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "gnap/gnap.h" +#include "gnap/gamesys.h" +#include "gnap/resource.h" + +namespace Gnap { + +enum { + kHSPlatypus = 0, + kHSExitInsideHouse = 1, + kHSExitUfoParty = 2, + kHSSign = 3, + kHSDevice = 4, + kHSWalkArea1 = 5, + kHSWalkArea2 = 6 +}; + +int GnapEngine::scene39_init() { + _gameSys->setAnimation(0, 0, 0); + _gameSys->setAnimation(0, 0, 1); + return 0x35; +} + +void GnapEngine::scene39_updateHotspots() { + setHotspot(kHSPlatypus, 0, 0, 0, 0, SF_WALKABLE | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSExitInsideHouse, 0, 0, 140, 206, SF_EXIT_U_CURSOR, 4, 8); + setHotspot(kHSExitUfoParty, 360, 204, 480, 430, SF_EXIT_R_CURSOR, 6, 8); + setHotspot(kHSSign, 528, 232, 607, 397, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR, 7, 3); + setHotspot(kHSWalkArea1, 0, 0, 800, 466); + setHotspot(kHSWalkArea2, 502, 466, 800, 600); + setDeviceHotspot(kHSDevice, -1, -1, -1, -1); + _hotspotsCount = 7; +} + +void GnapEngine::scene39_run() { + + queueInsertDeviceIcon(); + _s39_dword_47EAF8 = 0x33; + + _gameSys->setAnimation(0x33, 21, 3); + _gameSys->insertSequence(_s39_dword_47EAF8, 21, 0, 0, kSeqNone, 0, 0, 0); + _gameSys->insertSequence(0x34, 21, 0, 0, kSeqLoop, 0, 0, 0); + + _s39_dword_47EAFC = -1; + if (_prevSceneNum == 38) { + initGnapPos(3, 7, 7); + initBeaverPos(2, 7, 5); + endSceneInit(); + } else { + initGnapPos(4, 7, 1); + initBeaverPos(5, 7, 0); + endSceneInit(); + } + + while (!_sceneDone) { + + if (!isSoundPlaying(0x1094B)) { + playSound(0x1094B, 1); + setSoundVolume(0x1094B, 60); + } + + updateMouseCursor(); + updateCursorByHotspot(); + + testWalk(0, 0, -1, -1, -1, -1); + + _sceneClickedHotspot = getClickedHotspotId(); + updateGrabCursorSprite(0, 0); + + switch (_sceneClickedHotspot) { + + case kHSDevice: + runMenu(); + scene39_updateHotspots(); + _timers[5] = getRandom(20) + 50; + break; + + case kHSPlatypus: + if (_gnapActionStatus < 0) { + if (_grabCursorSpriteIndex >= 0) { + playGnapImpossible(_platX, _platY); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapMoan1(_platX, _platY); + break; + case GRAB_CURSOR: + gnapKissPlatypus(0); + break; + case TALK_CURSOR: + playGnapBrainPulsating(_platX, _platY); + playBeaverSequence(getBeaverSequenceId(0, 0, 0) | 0x10000); + break; + case PLAT_CURSOR: + playGnapImpossible(_platX, _platY); + break; + } + } + } + break; + + case kHSExitUfoParty: + if (_gnapActionStatus < 0) { + _isLeavingScene = 1; + _sceneDone = true; + gnapWalkTo(_gnapX, _gnapY, 0, 0x107AB, 1); + _gnapActionStatus = 0; + _newSceneNum = 40; + } + break; + + case kHSSign: + if (_gnapActionStatus < 0) { + if (_grabCursorSpriteIndex >= 0) { + playGnapImpossible(0, 0); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + gnapWalkTo(_hotspotsWalkPos[kHSSign].x, _hotspotsWalkPos[kHSSign].y, 0, -1, 1); + playGnapIdle(_hotspotsWalkPos[kHSSign].x, _hotspotsWalkPos[kHSSign].y); + showFullScreenSprite(0x1C); + break; + case GRAB_CURSOR: + case TALK_CURSOR: + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + } + break; + + case kHSExitInsideHouse: + if (_gnapActionStatus < 0) { + _sceneDone = true; + _isLeavingScene = 1; + _newSceneNum = 38; + } + break; + + case kHSWalkArea1: + case kHSWalkArea2: + if (_gnapActionStatus < 0) + gnapWalkTo(-1, -1, -1, -1, 1); + break; + + default: + if (_mouseClickState.left && _gnapActionStatus < 0) { + gnapWalkTo(-1, -1, -1, -1, 1); + _mouseClickState.left = false; + } + break; + + } + + scene39_updateAnimations(); + + if (!_isLeavingScene) { + if (_beaverActionStatus < 0) + updateBeaverIdleSequence(); + if (_gnapActionStatus < 0) + updateGnapIdleSequence(); + if (!_timers[5]) { + _timers[5] = getRandom(20) + 50; + switch (getRandom(4)) { + case 0: + _s39_dword_47EAFC = 0x30; + break; + case 1: + _s39_dword_47EAFC = 0x31; + break; + case 2: + _s39_dword_47EAFC = 0x32; + break; + case 3: + _s39_dword_47EAFC = 0x33; + break; + } + } + } + + checkGameKeys(); + + if (isKeyStatus1(8)) { + clearKeyStatus1(8); + runMenu(); + scene39_updateHotspots(); + _timers[5] = getRandom(20) + 50; + } + + gameUpdateTick(); + + } + +} + +void GnapEngine::scene39_updateAnimations() { + + if (_gameSys->getAnimationStatus(0) == 2) { + _gameSys->setAnimation(0, 0, 0); + if (_gnapActionStatus == 0) + _sceneDone = true; + else + _gnapActionStatus = -1; + } + + if (_gameSys->getAnimationStatus(3) == 2 && _s39_dword_47EAFC != -1) { + _gameSys->setAnimation(_s39_dword_47EAFC, 21, 3); + _gameSys->insertSequence(_s39_dword_47EAFC, 21, _s39_dword_47EAF8, 21, kSeqSyncWait, 0, 0, 0); + _s39_dword_47EAF8 = _s39_dword_47EAFC; + _s39_dword_47EAFC = -1; + } + +} + +} // End of namespace Gnap diff --git a/engines/gnap/scenes/scene40.cpp b/engines/gnap/scenes/scene40.cpp new file mode 100644 index 0000000000..fe91dbf777 --- /dev/null +++ b/engines/gnap/scenes/scene40.cpp @@ -0,0 +1,193 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "gnap/gnap.h" +#include "gnap/gamesys.h" +#include "gnap/resource.h" + +namespace Gnap { + +enum { + kHSPlatypus = 0, + kHSExitCave = 1, + kHSExitToyStand = 2, + kHSExitBBQ = 3, + kHSExitUfo = 4, + kHSExitKissinBooth = 5, + kHSExitDancefloor = 6, + kHSExitShoe = 7, + kHSDevice = 8 +}; + +int GnapEngine::scene40_init() { + _gameSys->setAnimation(0, 0, 0); + _gameSys->setAnimation(0, 0, 1); + return isFlag(23) ? 0x01 : 0x00; +} + +void GnapEngine::scene40_updateHotspots() { + setHotspot(kHSPlatypus, 0, 0, 0, 0, SF_WALKABLE | SF_DISABLED | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSExitCave, 169, 510, 264, 600, SF_EXIT_D_CURSOR, 0, 8); + setHotspot(kHSExitToyStand, 238, 297, 328, 376, SF_EXIT_L_CURSOR, 0, 8); + setHotspot(kHSExitBBQ, 328, 220, 401, 306, SF_EXIT_L_CURSOR, 0, 8); + setHotspot(kHSExitUfo, 421, 215, 501, 282, SF_EXIT_U_CURSOR, 0, 8); + setHotspot(kHSExitKissinBooth, 476, 284, 556, 345, SF_EXIT_R_CURSOR, 0, 8); + setHotspot(kHSExitDancefloor, 317, 455, 445, 600, SF_EXIT_D_CURSOR, 0, 8); + setHotspot(kHSExitShoe, 455, 346, 549, 417, SF_EXIT_D_CURSOR, 0, 8); + setDeviceHotspot(kHSDevice, -1, -1, -1, -1); + _hotspotsCount = 9; +} + +void GnapEngine::scene40_run() { + + queueInsertDeviceIcon(); + endSceneInit(); + + while (!_sceneDone) { + + if (!isSoundPlaying(0x1094B)) + playSound(0x1094B, 1); + + updateMouseCursor(); + updateCursorByHotspot(); + + testWalk(0, 0, -1, -1, -1, -1); + + _sceneClickedHotspot = getClickedHotspotId(); + updateGrabCursorSprite(0, 0); + + switch (_sceneClickedHotspot) { + + case kHSDevice: + runMenu(); + scene40_updateHotspots(); + break; + + case kHSPlatypus: + if (_gnapActionStatus < 0) { + if (_grabCursorSpriteIndex >= 0) { + playGnapImpossible(_platX, _platY); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapMoan1(_platX, _platY); + break; + case GRAB_CURSOR: + gnapKissPlatypus(0); + break; + case TALK_CURSOR: + playGnapBrainPulsating(_platX, _platY); + playBeaverSequence(getBeaverSequenceId(0, 0, 0) | 0x10000); + break; + case PLAT_CURSOR: + playGnapImpossible(_platX, _platY); + break; + } + } + } + break; + + case kHSExitCave: + if (_gnapActionStatus < 0) { + _newSceneNum = 39; + _sceneDone = true; + } + break; + + case kHSExitToyStand: + if (_gnapActionStatus < 0) { + _newSceneNum = 41; + _sceneDone = true; + } + break; + + case kHSExitBBQ: + if (_gnapActionStatus < 0) { + _newSceneNum = 42; + _sceneDone = true; + } + break; + + case kHSExitUfo: + if (_gnapActionStatus < 0) { + _newSceneNum = 43; + _sceneDone = true; + } + break; + + case kHSExitKissinBooth: + if (_gnapActionStatus < 0) { + _newSceneNum = 44; + _sceneDone = true; + } + break; + + case kHSExitDancefloor: + if (_gnapActionStatus < 0) { + _newSceneNum = 45; + _sceneDone = true; + } + break; + + case kHSExitShoe: + if (_gnapActionStatus < 0) { + _newSceneNum = 46; + _sceneDone = true; + } + break; + + default: + if (_mouseClickState.left && _gnapActionStatus < 0) + _mouseClickState.left = false; + break; + + } + + scene40_updateAnimations(); + + checkGameKeys(); + + if (isKeyStatus1(8)) { + clearKeyStatus1(8); + runMenu(); + scene40_updateHotspots(); + } + + gameUpdateTick(); + + } + +} + +void GnapEngine::scene40_updateAnimations() { + + if (_gameSys->getAnimationStatus(0) == 2) { + _gameSys->setAnimation(0, 0, 0); + if (_gnapActionStatus) + _gnapActionStatus = -1; + else + _sceneDone = true; + } + +} + +} // End of namespace Gnap diff --git a/engines/gnap/scenes/scene41.cpp b/engines/gnap/scenes/scene41.cpp new file mode 100644 index 0000000000..60c5979ae7 --- /dev/null +++ b/engines/gnap/scenes/scene41.cpp @@ -0,0 +1,577 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "gnap/gnap.h" +#include "gnap/gamesys.h" +#include "gnap/resource.h" + +namespace Gnap { + +enum { + kHSPlatypus = 0, + kHSExitCave = 1, + kHSExit = 2, + kHSExitBBQ = 3, + kHSToyVendor = 4, + kHSKid = 5, + kHSToyUfo = 6, + kHSDevice = 7, + kHSWalkArea1 = 8 +}; + +enum { + kHSUfoExitLeft = 1, + kHSUfoExitRight = 2, + kHSUfoDevice = 3, + kHSUfoWalkArea1 = 4 +}; + +int GnapEngine::scene41_init() { + _gameSys->setAnimation(0, 0, 0); + _gameSys->setAnimation(0, 0, 1); + _gameSys->setAnimation(0, 0, 2); + return 0x129; +} + +void GnapEngine::scene41_updateHotspots() { + if (isFlag(12)) { + setHotspot(kHSPlatypus, 0, 0, 0, 0, SF_DISABLED); + setHotspot(kHSUfoExitLeft, 0, 0, 10, 500, SF_EXIT_L_CURSOR | SF_DISABLED); + setHotspot(kHSUfoExitRight, 790, 0, 799, 500, SF_EXIT_R_CURSOR); + setHotspot(kHSUfoWalkArea1, 0, 0, 800, 470, SF_DISABLED); + setDeviceHotspot(kHSUfoDevice, -1, -1, -1, -1); + _hotspotsCount = 5; + } else { + setHotspot(kHSPlatypus, 0, 0, 0, 0, SF_WALKABLE | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSExitCave, 150, 590, 650, 600, SF_EXIT_D_CURSOR | SF_WALKABLE, 5, 9); + setHotspot(kHSExit, 0, 100, 10, 599, SF_EXIT_L_CURSOR | SF_DISABLED, 0, 8); + setHotspot(kHSExitBBQ, 790, 100, 799, 599, SF_EXIT_R_CURSOR | SF_WALKABLE, 10, 8); + setHotspot(kHSToyVendor, 320, 150, 430, 310, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSKid, 615, 340, 710, 460, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSToyUfo, 0, 0, 0, 0, SF_GRAB_CURSOR); + setHotspot(kHSWalkArea1, 0, 0, 800, 470); + setDeviceHotspot(kHSDevice, -1, -1, -1, -1); + _hotspotsCount = 9; + } +} + +void GnapEngine::scene41_run() { + + queueInsertDeviceIcon(); + + if (isFlag(12)) { + _toyUfoX = 770; + if (_toyUfoY < 0 || _toyUfoY > 300) + _toyUfoY = 150; + if (!_timers[9]) + _gnapActionStatus = 6; + } else { + if (!isFlag(16) && !isFlag(17) && !isFlag(18) && !isFlag(19)) + toyUfoSetStatus(16); + _toyUfoX = 600; + _toyUfoY = 200; + } + + _toyUfoId = 0; + _toyUfoActionStatus = -1; + _toyUfoSequenceId = toyUfoGetSequenceId(); + _toyUfoNextSequenceId = _toyUfoSequenceId; + + _gameSys->setAnimation(_toyUfoSequenceId | 0x10000, _toyUfoId, 2); + _gameSys->insertSequence(_toyUfoSequenceId | 0x10000, _toyUfoId, 0, 0, kSeqNone, 0, _toyUfoX - 274, _toyUfoY - 128); + _gameSys->insertSequence(0x128, 0, 0, 0, kSeqLoop, 0, 0, 0); + + if (isFlag(12)) + _s41_dword_47F2C4 = 0x11B; + else + _s41_dword_47F2C4 = 0x11D; + + _s41_dword_47F2C0 = -1; + + _gameSys->setAnimation(_s41_dword_47F2C4, 1, 4); + _gameSys->insertSequence(_s41_dword_47F2C4, 1, 0, 0, kSeqNone, 0, 0, 0); + + _s41_dword_47F2CC = 0x118; + _s41_dword_47F2C8 = -1; + + _gameSys->setAnimation(0x118, 1, 3); + _gameSys->insertSequence(_s41_dword_47F2CC, 1, 0, 0, kSeqNone, 0, 0, 0); + _gameSys->insertSequence(0x127, 2, 0, 0, kSeqNone, 0, 0, 0); + + if (isFlag(12)) { + _gnapSequenceId = 0x120; + _gnapSequenceDatNum = 0; + _gnapIdleFacing = 7; + _gnapX = 7; + _gnapY = 7; + _gnapId = 140; + _gameSys->insertSequence(0x120, 140, 0, 0, kSeqNone, 0, 0, 0); + _gameSys->setAnimation(makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, 0); + initBeaverPos(8, 10, 3); + endSceneInit(); + } else if (_prevSceneNum == 45) { + initGnapPos(-1, 8, 7); + initBeaverPos(-2, 8, 5); + endSceneInit(); + platypusWalkTo(1, 8, -1, 0x107C2, 1); + gnapWalkTo(2, 8, -1, 0x107B9, 1); + } else if (_prevSceneNum == 42) { + initGnapPos(11, 8, 7); + initBeaverPos(11, 9, 5); + endSceneInit(); + gnapWalkTo(8, 8, -1, 0x107BA, 1); + platypusWalkTo(9, 8, -1, 0x107D2, 1); + } else { + initGnapPos(5, 8, 1); + initBeaverPos(6, 8, 3); + endSceneInit(); + } + + _timers[4] = getRandom(100) + 100; + _timers[5] = getRandom(30) + 20; + + while (!_sceneDone) { + + if (!isSoundPlaying(0x1094B)) + playSound(0x1094B, 1); + + if (!isFlag(12)) { + _hotspots[kHSToyUfo].x1 = _toyUfoX - 25; + _hotspots[kHSToyUfo].y1 = _toyUfoY - 20; + _hotspots[kHSToyUfo].x2 = _toyUfoX + 25; + _hotspots[kHSToyUfo].y2 = _toyUfoY + 20; + } + + updateMouseCursor(); + updateCursorByHotspot(); + + testWalk(0, 0, -1, -1, -1, -1); + + _sceneClickedHotspot = getClickedHotspotId(); + updateGrabCursorSprite(0, 0); + + if (isFlag(12)) { + + switch (_sceneClickedHotspot) { + + case kHSUfoExitLeft: + if (_toyUfoActionStatus < 0) { + _isLeavingScene = 1; + _toyUfoActionStatus = 7; + _newSceneNum = 45; + toyUfoFlyTo(-35, -1, -35, 799, 0, 300, 2); + } + break; + + case kHSUfoExitRight: + if (_toyUfoActionStatus < 0) { + _isLeavingScene = 1; + _toyUfoActionStatus = 7; + _newSceneNum = 42; + toyUfoFlyTo(835, -1, 0, 835, 0, 300, 2); + } + break; + + case kHSUfoDevice: + runMenu(); + scene41_updateHotspots(); + _timers[4] = getRandom(100) + 100; + _timers[5] = getRandom(30) + 20; + break; + + } + + } else { + + switch (_sceneClickedHotspot) { + + case kHSDevice: + runMenu(); + scene41_updateHotspots(); + _timers[4] = getRandom(100) + 100; + _timers[5] = getRandom(30) + 20; + break; + + case kHSPlatypus: + if (_gnapActionStatus < 0) { + if (_grabCursorSpriteIndex >= 0) { + playGnapImpossible(_platX, _platY); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapMoan1(_platX, _platY); + break; + case GRAB_CURSOR: + gnapKissPlatypus(0); + break; + case TALK_CURSOR: + playGnapBrainPulsating(_platX, _platY); + playBeaverSequence(getBeaverSequenceId(0, 0, 0) | 0x10000); + break; + case PLAT_CURSOR: + playGnapImpossible(_platX, _platY); + break; + } + } + } + break; + + case kHSExitCave: + _isLeavingScene = 1; + gnapWalkTo(_hotspotsWalkPos[kHSExitCave].x, _hotspotsWalkPos[kHSExitCave].y, 0, 0x107AE, 1); + _gnapActionStatus = 0; + _newSceneNum = 40; + break; + + case kHSExit: + _isLeavingScene = 1; + gnapWalkTo(_hotspotsWalkPos[kHSExit].x, -1, 0, 0x107AF, 1); + _gnapActionStatus = 0; + platypusWalkTo(_hotspotsWalkPos[kHSExit].x, -1, -1, 0x107CF, 1); + _newSceneNum = 45; + break; + + case kHSExitBBQ: + _isLeavingScene = 1; + gnapWalkTo(_hotspotsWalkPos[kHSExitBBQ].x, -1, 0, 0x107AB, 1); + _gnapActionStatus = 0; + platypusWalkTo(_hotspotsWalkPos[kHSExitBBQ].x, -1, -1, 0x107CD, 1); + _newSceneNum = 42; + break; + + case kHSToyVendor: + if (_grabCursorSpriteIndex == kItemDiceQuarterHole) { + _gnapActionStatus = 1; + gnapWalkTo(4, 7, 0, 0x107BB, 9); + playGnapShowItem(_grabCursorSpriteIndex, 5, 0); + } else if (_grabCursorSpriteIndex >= 0) { + playGnapShowCurrItem(4, 7, 5, 0); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapMoan1(5, 0); + break; + case GRAB_CURSOR: + playGnapImpossible(0, 0); + break; + case TALK_CURSOR: + _gnapIdleFacing = 7; + gnapWalkTo(4, 7, 0, getGnapSequenceId(gskBrainPulsating, 0, 0) | 0x10000, 1); + _gnapActionStatus = 2; + break; + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + break; + + case kHSKid: + if (_grabCursorSpriteIndex == kItemChickenBucket) { + gnapWalkTo(7, 7, 0, 0x107BB, 1); + _gnapIdleFacing = 7; + _gnapActionStatus = 4; + } else if (_grabCursorSpriteIndex >= 0) { + playGnapShowCurrItem(7, 7, 8, 0); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapScratchingHead(9, 0); + break; + case GRAB_CURSOR: + gnapWalkTo(7, 7, 0, 0x107BB, 1); + _gnapIdleFacing = 7; + _gnapActionStatus = 5; + break; + case TALK_CURSOR: + _gnapIdleFacing = 7; + gnapWalkTo(7, 7, 0, getGnapSequenceId(gskBrainPulsating, 0, 0) | 0x10000, 1); + break; + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + break; + + case kHSToyUfo: + if (_grabCursorSpriteIndex == kItemGum) { + playGnapPullOutDevice(9, 0); + _gameSys->setAnimation(makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, 0); + _gnapActionStatus = 3; + } + break; + + case kHSWalkArea1: + if (_gnapActionStatus < 0) + gnapWalkTo(-1, -1, -1, -1, 1); + break; + } + + } + + if (isFlag(12)) { + if (!_timers[9] && _gnapActionStatus < 0) { + _gnapActionStatus = 6; + if (_gnapSequenceId == 0x121 || _gnapSequenceId == 0x122) { + _gameSys->insertSequence(0x123, _gnapId, makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, kSeqSyncWait, 0, 0, 0); + _gnapSequenceId = 0x123; + _gnapSequenceDatNum = 0; + _gameSys->setAnimation(0x123, _gnapId, 0); + } + } + } + + if (_mouseClickState.left && _gnapActionStatus < 0) { + _mouseClickState.left = false; + if (isFlag(12)) { + int sequenceId; + if (_leftClickMouseX >= 400) { + if (_gnapSequenceId == 0x11F || _gnapSequenceId == 0x120 || _gnapSequenceId == 0x123 || _gnapSequenceId == 0x126) + sequenceId = 0x120; + else if (_leftClickMouseX - _toyUfoX >= 400) + sequenceId = 0x126; + else + sequenceId = 0x123; + } else { + if (_gnapSequenceId == 0x121 || _gnapSequenceId == 0x125 || _gnapSequenceId == 0x122) + sequenceId = 0x122; + else if (_toyUfoX - _leftClickMouseX >= 400) + sequenceId = 0x125; + else + sequenceId = 0x121; + } + _gameSys->insertSequence(sequenceId, _gnapId, makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, kSeqSyncWait, 0, 0, 0); + _gnapSequenceId = sequenceId; + _gnapSequenceDatNum = 0; + _gameSys->setAnimation(sequenceId, _gnapId, 0); + _toyUfoActionStatus = 8; + toyUfoFlyTo(-1, -1, 0, 799, 0, 300, 2); + } else { + gnapWalkTo(-1, -1, -1, -1, 1); + } + } + + scene41_updateAnimations(); + + if (!_isLeavingScene) { + if (_beaverActionStatus < 0) + updateBeaverIdleSequence(); + if (_gnapActionStatus < 0 && !isFlag(12)) + updateGnapIdleSequence(); + if (!_timers[4]) { + _timers[4] = getRandom(100) + 100; + if (_gnapActionStatus < 0 && _beaverActionStatus < 0 && _toyUfoActionStatus == -1 && _s41_dword_47F2C8 == -1) { + _gnapRandomValue = getRandom(3); + switch (_gnapRandomValue) { + case 0: + _s41_dword_47F2C8 = 0x113; + break; + case 1: + _s41_dword_47F2C8 = 0x117; + break; + case 2: + _s41_dword_47F2C8 = 0x119; + break; + } + if (_s41_dword_47F2C8 == _s41_dword_47F2CC) + _s41_dword_47F2C8 = -1; + } + } + if (!_timers[5]) { + _timers[5] = getRandom(30) + 20; + if (_gnapActionStatus < 0 && _beaverActionStatus < 0 && _toyUfoActionStatus == -1 && _s41_dword_47F2C0 == -1) { + if (isFlag(12)) + _s41_dword_47F2C0 = 0x11B; + else if (getRandom(3) != 0) + _s41_dword_47F2C0 = 0x11D; + else + _s41_dword_47F2C0 = 0x11E; + } + } + } + + checkGameKeys(); + + if (isKeyStatus1(8)) { + clearKeyStatus1(8); + runMenu(); + scene41_updateHotspots(); + _timers[4] = getRandom(100) + 100; + _timers[5] = getRandom(30) + 20; + } + + gameUpdateTick(); + + } + +} + +void GnapEngine::scene41_updateAnimations() { + + if (_gameSys->getAnimationStatus(0) == 2) { + switch (_gnapActionStatus) { + case 0: + _gameSys->setAnimation(0, 0, 0); + _sceneDone = true; + _gnapActionStatus = -1; + break; + case 1: + _gameSys->setAnimation(0, 0, 0); + _s41_dword_47F2C8 = 0x114; + _gnapActionStatus = -1; + break; + case 2: + _gameSys->setAnimation(0, 0, 0); + _s41_dword_47F2C8 = 0x116; + _gnapActionStatus = -1; + break; + case 3: + _gameSys->setAnimation(0, 0, 0); + playGnapUseDevice(9, 0); + _gnapActionStatus = -1; + setGrabCursorSprite(-1); + invRemove(kItemGum); + _toyUfoActionStatus = 9; + break; + case 4: + if (_gameSys->getAnimationStatus(4) == 2) { + _timers[2] = getRandom(30) + 20; + _timers[3] = getRandom(50) + 200; + setGrabCursorSprite(-1); + _gameSys->insertSequence(0x11F, _gnapId, makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, kSeqSyncWait, 0, 0, 0); + _gnapSequenceId = 0x11F; + _gnapSequenceDatNum = 0; + _gameSys->setAnimation(0x11F, _gnapId, 0); + _s41_dword_47F2C0 = 0x11A; + _gameSys->insertSequence(0x11A, 1, _s41_dword_47F2C4, 1, kSeqSyncWait, 0, 0, 0); + _gameSys->setAnimation(_s41_dword_47F2C0, 1, 4); + _s41_dword_47F2C4 = _s41_dword_47F2C0; + _s41_dword_47F2C0 = 0x11B; + _timers[5] = getRandom(30) + 20; + _gnapActionStatus = -1; + setFlag(12); + scene41_updateHotspots(); + _timers[9] = 600; + } + break; + case 5: + if (_gameSys->getAnimationStatus(3) == 2 && _gameSys->getAnimationStatus(4) == 2) { + _timers[2] = getRandom(30) + 20; + _timers[3] = getRandom(50) + 200; + _gameSys->insertSequence(0x110, _gnapId, makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, kSeqSyncWait, 0, 0, 0); + _gnapSequenceId = 0x110; + _gnapSequenceDatNum = 0; + _gameSys->setAnimation(0x110, _gnapId, 0); + _s41_dword_47F2C8 = 0x111; + _gameSys->insertSequence(0x111, 1, _s41_dword_47F2CC, 1, kSeqSyncWait, 0, 0, 0); + _gameSys->setAnimation(_s41_dword_47F2C8, 1, 3); + _s41_dword_47F2CC = _s41_dword_47F2C8; + _s41_dword_47F2C8 = -1; + _timers[4] = getRandom(100) + 100; + _s41_dword_47F2C0 = 0x10F; + _gameSys->insertSequence(0x10F, 1, _s41_dword_47F2C4, 1, kSeqSyncWait, 0, 0, 0); + _gameSys->setAnimation(_s41_dword_47F2C0, 1, 4); + _s41_dword_47F2C4 = _s41_dword_47F2C0; + _s41_dword_47F2C0 = -1; + _timers[5] = getRandom(30) + 20; + _gnapActionStatus = -1; + } + break; + case 6: + if (_gameSys->getAnimationStatus(3) == 2 && _gameSys->getAnimationStatus(4) == 2) { + _timers[2] = getRandom(30) + 20; + _timers[3] = getRandom(50) + 200; + _gameSys->insertSequence(0x124, _gnapId, + makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, + kSeqSyncWait, 0, 0, 0); + _gnapSequenceId = 0x124; + _gnapSequenceDatNum = 0; + _gameSys->setAnimation(0x124, _gnapId, 0); + _s41_dword_47F2C8 = 0x112; + _gameSys->insertSequence(0x112, 1, _s41_dword_47F2CC, 1, kSeqSyncWait, 0, 0, 0); + _gameSys->setAnimation(_s41_dword_47F2C8, 1, 3); + _s41_dword_47F2CC = _s41_dword_47F2C8; + _s41_dword_47F2C8 = -1; + _timers[4] = getRandom(100) + 100; + _s41_dword_47F2C0 = 0x11C; + _gameSys->insertSequence(0x11C, 1, _s41_dword_47F2C4, 1, kSeqSyncWait, 0, 0, 0); + _gameSys->setAnimation(_s41_dword_47F2C0, 1, 4); + _s41_dword_47F2C4 = _s41_dword_47F2C0; + _s41_dword_47F2C0 = -1; + _timers[5] = getRandom(30) + 20; + _gnapActionStatus = -1; + clearFlag(12); + scene41_updateHotspots(); + } + break; + } + } + + if (_gameSys->getAnimationStatus(2) == 2) { + switch (_toyUfoActionStatus) { + case 7: + _sceneDone = true; + break; + case 9: + _toyUfoNextSequenceId = 0x873; + _gameSys->insertSequence(0x10873, _toyUfoId, _toyUfoSequenceId | 0x10000, _toyUfoId, + kSeqSyncWait, 0, _toyUfoX - 365, _toyUfoY - 128); + _toyUfoSequenceId = _toyUfoNextSequenceId; + _gameSys->setAnimation(_toyUfoNextSequenceId | 0x10000, _toyUfoId, 2); + toyUfoSetStatus(17); + break; + default: + _toyUfoNextSequenceId = toyUfoGetSequenceId(); + _gameSys->insertSequence(_toyUfoNextSequenceId | 0x10000, _toyUfoId + 1, _toyUfoSequenceId | 0x10000, _toyUfoId, + kSeqSyncWait, 0, _toyUfoX - 274, _toyUfoY - 128); + _toyUfoSequenceId = _toyUfoNextSequenceId; + ++_toyUfoId; + _gameSys->setAnimation(_toyUfoNextSequenceId | 0x10000, _toyUfoId, 2); + break; + } + _toyUfoActionStatus = -1; + } + + if (_gameSys->getAnimationStatus(3) == 2 && _s41_dword_47F2C8 != -1) { + _gameSys->insertSequence(_s41_dword_47F2C8, 1, _s41_dword_47F2CC, 1, kSeqSyncWait, 0, 0, 0); + _gameSys->setAnimation(_s41_dword_47F2C8, 1, 3); + _s41_dword_47F2CC = _s41_dword_47F2C8; + _s41_dword_47F2C8 = -1; + _timers[4] = getRandom(100) + 100; + } + + if (_gameSys->getAnimationStatus(4) == 2 && _s41_dword_47F2C0 != -1) { + _gameSys->insertSequence(_s41_dword_47F2C0, 1, _s41_dword_47F2C4, 1, kSeqSyncWait, 0, 0, 0); + _gameSys->setAnimation(_s41_dword_47F2C0, 1, 4); + _s41_dword_47F2C4 = _s41_dword_47F2C0; + _s41_dword_47F2C0 = -1; + _timers[5] = getRandom(30) + 20; + if (_s41_dword_47F2C4 == 0x11E) { + _toyUfoActionStatus = 8; + toyUfoFlyTo(getRandom(300) + 500, getRandom(225) + 75, 0, 799, 0, 300, 2); + } + } + +} + +} // End of namespace Gnap diff --git a/engines/gnap/scenes/scene42.cpp b/engines/gnap/scenes/scene42.cpp new file mode 100644 index 0000000000..2f98a820a2 --- /dev/null +++ b/engines/gnap/scenes/scene42.cpp @@ -0,0 +1,494 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "gnap/gnap.h" +#include "gnap/gamesys.h" +#include "gnap/resource.h" + +namespace Gnap { + +enum { + kHSPlatypus = 0, + kHSExitUfoParty = 1, + kHSExitToyStand = 2, + kHSExitUfo = 3, + kHSBBQVendor = 4, + kHSChickenLeg = 5, + kHSDevice = 6, + kHSWalkArea1 = 7, + kHSWalkArea2 = 8 +}; + +enum { + kHSUfoExitLeft = 1, + kHSUfoExitRight = 2, + kHSUfoHotSauce = 3, + kHSUfoDevice = 4 +}; + +int GnapEngine::scene42_init() { + _gameSys->setAnimation(0, 0, 0); + _gameSys->setAnimation(0, 0, 1); + _gameSys->setAnimation(0, 0, 2); + if (isFlag(20) || (isFlag(18) && isFlag(23))) + return 0x153; + return 0x152; +} + +void GnapEngine::scene42_updateHotspots() { + if (isFlag(12)) { + setHotspot(kHSPlatypus, 0, 0, 0, 0, SF_DISABLED); + setHotspot(kHSUfoExitLeft, 0, 0, 10, 599, SF_EXIT_L_CURSOR); + setHotspot(kHSUfoExitRight, 790, 0, 799, 599, SF_EXIT_R_CURSOR); + setHotspot(kHSUfoHotSauce, 335, 110, 440, 175, SF_DISABLED); + setDeviceHotspot(kHSUfoDevice, -1, 534, -1, 599); + if ((isFlag(20) || isFlag(18)) && isFlag(23) && !isFlag(24)) + _hotspots[kHSUfoHotSauce].flags = SF_GRAB_CURSOR; + _hotspotsCount = 5; + } else { + setHotspot(kHSPlatypus, 0, 0, 0, 0, SF_WALKABLE | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSExitUfoParty, 150, 585, 650, 600, SF_EXIT_D_CURSOR | SF_WALKABLE, 5, 9); + setHotspot(kHSExitToyStand, 0, 100, 10, 599, SF_EXIT_L_CURSOR, 0, 8); + setHotspot(kHSExitUfo, 790, 100, 799, 599, SF_EXIT_R_CURSOR, 10, 8); + setHotspot(kHSBBQVendor, 410, 200, 520, 365, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR, 4, 8); + setHotspot(kHSChickenLeg, 530, 340, 620, 430, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR, 8, 7); + setHotspot(kHSWalkArea1, 0, 0, 800, 445); + setHotspot(kHSWalkArea2, 240, 0, 550, 495); + setDeviceHotspot(kHSDevice, -1, -1, -1, -1); + _hotspotsCount = 9; + } +} + +void GnapEngine::scene42_run() { + + queueInsertDeviceIcon(); + + _s42_dword_47F2B8 = 0x14A; + _s42_dword_47F2BC = -1; + + _gameSys->setAnimation(0x14A, 1, 2); + _gameSys->insertSequence(_s42_dword_47F2B8, 1, 0, 0, kSeqNone, 0, 0, 0); + + if (isFlag(12)) { + _toyUfoId = 0; + _toyUfoActionStatus = -1; + if (_prevSceneNum == 43 && isFlag(18)) { + _toyUfoSequenceId = 0x872; + _toyUfoNextSequenceId = toyUfoGetSequenceId(); + _gameSys->insertSequence(_toyUfoSequenceId | 0x10000, _toyUfoId, 0, 0, kSeqNone, 0, 0, 0); + _toyUfoX = 317; + _toyUfoY = 61; + toyUfoSetStatus(17); + setFlag(20); + _timers[9] = 600; + } else { + _toyUfoSequenceId = toyUfoGetSequenceId(); + _toyUfoNextSequenceId = _toyUfoSequenceId; + if (_prevSceneNum == 41) + _toyUfoX = 30; + else + _toyUfoX = 770; + _gameSys->insertSequence(_toyUfoSequenceId | 0x10000, _toyUfoId, 0, 0, kSeqNone, 0, _toyUfoX - 274, _toyUfoY - 128); + } + _gameSys->setAnimation(_toyUfoSequenceId | 0x10000, _toyUfoId, 3); + endSceneInit(); + if (_toyUfoSequenceId == 0x872) + setGrabCursorSprite(-1); + } else if (_prevSceneNum == 41) { + initGnapPos(-1, 8, 7); + initBeaverPos(-1, 9, 5); + endSceneInit(); + gnapWalkTo(2, 8, -1, 0x107B9, 1); + platypusWalkTo(1, 8, -1, 0x107C2, 1); + } else if (_prevSceneNum == 43) { + initGnapPos(11, 8, 7); + initBeaverPos(11, 9, 5); + endSceneInit(); + gnapWalkTo(8, 8, -1, 0x107BA, 1); + platypusWalkTo(9, 8, -1, 0x107D2, 1); + } else { + initGnapPos(5, 11, 7); + initBeaverPos(6, 11, 5); + endSceneInit(); + gnapWalkTo(5, 8, -1, 0x107BA, 1); + platypusWalkTo(6, 8, -1, 0x107C2, 1); + } + + while (!_sceneDone) { + + if (!isSoundPlaying(0x1094B)) + playSound(0x1094B, 1); + + updateMouseCursor(); + updateCursorByHotspot(); + + testWalk(0, 0, -1, -1, -1, -1); + + _sceneClickedHotspot = getClickedHotspotId(); + updateGrabCursorSprite(0, 0); + + if (isFlag(12)) { + + switch (_sceneClickedHotspot) { + + case kHSUfoExitLeft: + if (_toyUfoActionStatus < 0) { + _isLeavingScene = true; + _toyUfoActionStatus = 5; + _newSceneNum = 41; + toyUfoFlyTo(-35, -1, -35, 799, 0, 300, 3); + } + break; + + case kHSUfoExitRight: + if (_toyUfoActionStatus < 0) { + _isLeavingScene = true; + _toyUfoActionStatus = 5; + _newSceneNum = 43; + toyUfoFlyTo(835, -1, 0, 835, 0, 300, 3); + } + break; + + case kHSUfoHotSauce: + if (isFlag(17)) { + _toyUfoActionStatus = 7; + toyUfoFlyTo(384, 77, 0, 799, 0, 300, 3); + _timers[9] = 600; + } else { + _toyUfoActionStatus = 6; + toyUfoFlyTo(-1, -1, 0, 799, 0, 300, 3); + } + break; + + case kHSUfoDevice: + runMenu(); + scene42_updateHotspots(); + break; + + } + + } else { + + switch (_sceneClickedHotspot) { + + case kHSDevice: + runMenu(); + scene42_updateHotspots(); + _timers[4] = getRandom(20) + 30; + break; + + case kHSPlatypus: + if (_gnapActionStatus < 0) { + if (_grabCursorSpriteIndex >= 0) { + playGnapImpossible(_platX, _platY); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapMoan1(_platX, _platY); + break; + case GRAB_CURSOR: + gnapKissPlatypus(0); + break; + case TALK_CURSOR: + playGnapBrainPulsating(_platX, _platY); + playBeaverSequence(getBeaverSequenceId(0, 0, 0) | 0x10000); + break; + case PLAT_CURSOR: + playGnapImpossible(_platX, _platY); + break; + } + } + } + break; + + case kHSExitUfoParty: + _isLeavingScene = true; + gnapWalkTo(_gnapX, _hotspotsWalkPos[kHSExitUfoParty].y, 0, 0x107AE, 1); + _gnapActionStatus = 0; + platypusWalkTo(_platX, _hotspotsWalkPos[kHSExitUfoParty].y, -1, 0x107C7, 1); + _newSceneNum = 40; + break; + + case kHSExitToyStand: + _isLeavingScene = true; + gnapWalkTo(_hotspotsWalkPos[kHSExitToyStand].x, _gnapY, 0, 0x107AF, 1); + _gnapActionStatus = 0; + platypusWalkTo(_hotspotsWalkPos[kHSExitToyStand].x, _hotspotsWalkPos[kHSExitToyStand].y, -1, 0x107CF, 1); + _newSceneNum = 41; + break; + + case kHSExitUfo: + _isLeavingScene = true; + gnapWalkTo(_hotspotsWalkPos[kHSExitUfo].x, _gnapY, 0, 0x107AB, 1); + _gnapActionStatus = 0; + platypusWalkTo(_hotspotsWalkPos[kHSExitUfo].x, _hotspotsWalkPos[kHSExitUfo].y, -1, 0x107CD, 1); + _newSceneNum = 43; + break; + + case kHSBBQVendor: + if (_grabCursorSpriteIndex == kItemDiceQuarterHole) { + gnapWalkTo(_hotspotsWalkPos[kHSBBQVendor].x, _hotspotsWalkPos[kHSBBQVendor].y, 0, 0x107BB, 1); + _gnapActionStatus = 2; + if (_platY < 9) + platypusWalkTo(_platX, 9, -1, -1, 1); + } else if (_grabCursorSpriteIndex >= 0) { + playGnapShowCurrItem(_hotspotsWalkPos[kHSBBQVendor].x, _hotspotsWalkPos[kHSBBQVendor].y, _hotspotsWalkPos[kHSBBQVendor].x + 1, 0); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapScratchingHead(_hotspotsWalkPos[kHSBBQVendor].x - 1, 0); + break; + case TALK_CURSOR: + _gnapIdleFacing = 7; + gnapWalkTo(_hotspotsWalkPos[kHSBBQVendor].x, _hotspotsWalkPos[kHSBBQVendor].y, 0, getGnapSequenceId(gskBrainPulsating, 0, 0) | 0x10000, 1); + _gnapActionStatus = 1; + break; + case GRAB_CURSOR: + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + break; + + case kHSChickenLeg: + if (_grabCursorSpriteIndex >= 0) { + playGnapShowCurrItem(_hotspotsWalkPos[kHSChickenLeg].x, _hotspotsWalkPos[kHSChickenLeg].y, _hotspotsWalkPos[kHSChickenLeg].x - 1, 0); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapScratchingHead(_hotspotsWalkPos[kHSChickenLeg].x - 1, 0); + break; + case GRAB_CURSOR: + gnapWalkTo(_hotspotsWalkPos[kHSChickenLeg].x, _hotspotsWalkPos[kHSChickenLeg].y, 0, 0x107BC, 1); + _gnapActionStatus = 4; + break; + case TALK_CURSOR: + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + break; + + case kHSWalkArea1: + case kHSWalkArea2: + if (_gnapActionStatus < 0) + gnapWalkTo(-1, -1, -1, -1, 1); + break; + + } + + } + + if (_mouseClickState.left && _gnapActionStatus < 0) { + _mouseClickState.left = false; + if (isFlag(12)) { + _toyUfoActionStatus = 6; + toyUfoFlyTo(-1, -1, 0, 799, 0, 300, 3); + } else { + gnapWalkTo(-1, -1, -1, -1, 1); + } + } + + scene42_updateAnimations(); + + toyUfoCheckTimer(); + + if (!_isLeavingScene) { + if (_beaverActionStatus < 0 && !isFlag(12)) + updateBeaverIdleSequence(); + if (_gnapActionStatus < 0 && !isFlag(12)) + updateGnapIdleSequence(); + if (!_timers[4]) { + _timers[4] = getRandom(20) + 30; + if (_gnapActionStatus < 0 && _beaverActionStatus < 0 && _s42_dword_47F2BC == -1) { + _gnapRandomValue = getRandom(8); + switch (_gnapRandomValue) { + case 0: + _s42_dword_47F2BC = 0x14C; + break; + case 1: + case 2: + _s42_dword_47F2BC = 0x149; + break; + case 3: + case 4: + case 5: + case 6: + _s42_dword_47F2BC = 0x14D; + break; + case 7: + _s42_dword_47F2BC = 0x14A; + break; + } + if (_s42_dword_47F2BC == _s42_dword_47F2B8 && _s42_dword_47F2BC != 0x14D) + _s42_dword_47F2BC = -1; + } + } + } + + checkGameKeys(); + + if (isKeyStatus1(8)) { + clearKeyStatus1(8); + runMenu(); + scene42_updateHotspots(); + _timers[4] = getRandom(20) + 30; + } + + gameUpdateTick(); + + } + +} + +void GnapEngine::scene42_updateAnimations() { + int sequenceId; + + if (_gameSys->getAnimationStatus(0) == 2) { + switch (_gnapActionStatus) { + case 0: + _gameSys->setAnimation(0, 0, 0); + _gnapActionStatus = -1; + _sceneDone = true; + break; + case 1: + _gameSys->setAnimation(0, 0, 0); + _gnapActionStatus = -1; + _s42_dword_47F2BC = 0x14B; + break; + case 3: + _gameSys->setAnimation(0, 0, 0); + setGrabCursorSprite(kItemChickenBucket); + _gnapActionStatus = -1; + break; + case 2: + case 4: + if (_gameSys->getAnimationStatus(2) == 2) { + if (_gnapActionStatus == 2) { + invRemove(kItemDiceQuarterHole); + invAdd(kItemChickenBucket); + setGrabCursorSprite(-1); + sequenceId = 0x150; + _s42_dword_47F2BC = 0x148; + } else if (isFlag(27)) { + if (isFlag(28)) { + sequenceId = 0x7B7; + _s42_dword_47F2BC = 0x145; + } else { + setFlag(28); + sequenceId = 0x14F; + _s42_dword_47F2BC = 0x147; + } + } else { + setFlag(27); + sequenceId = 0x14E; + _s42_dword_47F2BC = 0x146; + } + if (sequenceId == 0x7B7) { + _gameSys->insertSequence(0x107B7, _gnapId, + makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, + kSeqSyncWait, getSequenceTotalDuration(_s42_dword_47F2BC), + 75 * _gnapX - _gnapGridX, 48 * _gnapY - _gnapGridY); + _gnapSequenceDatNum = 1; + } else { + _gameSys->insertSequence(sequenceId, _gnapId, + makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, + kSeqSyncWait, 0, 0, 0); + _gnapSequenceDatNum = 0; + } + _gnapSequenceId = sequenceId; + _gameSys->setAnimation(sequenceId | (_gnapSequenceDatNum << 16), _gnapId, 0); + if (_gnapActionStatus == 2) + _gnapActionStatus = 3; + else + _gnapActionStatus = -1; + _gameSys->insertSequence(_s42_dword_47F2BC, 1, _s42_dword_47F2B8, 1, kSeqSyncWait, 0, 0, 0); + _gameSys->setAnimation(_s42_dword_47F2BC, 1, 2); + _s42_dword_47F2B8 = _s42_dword_47F2BC; + if (_s42_dword_47F2BC == 0x145) + _s42_dword_47F2BC = 0x14A; + else + _s42_dword_47F2BC = -1; + _timers[4] = getRandom(20) + 30; + _timers[2] = getRandom(30) + 20; + _timers[3] = getRandom(50) + 200; + } + break; + default: + _gameSys->setAnimation(0, 0, 0); + _gnapActionStatus = -1; + break; + } + } + + if (_gameSys->getAnimationStatus(2) == 2 && _s42_dword_47F2BC != -1) { + _gameSys->insertSequence(_s42_dword_47F2BC, 1, _s42_dword_47F2B8, 1, kSeqSyncWait, 0, 0, 0); + _gameSys->setAnimation(_s42_dword_47F2BC, 1, 2); + _s42_dword_47F2B8 = _s42_dword_47F2BC; + _s42_dword_47F2BC = -1; + _timers[4] = getRandom(20) + 30; + } + + if (_gameSys->getAnimationStatus(3) == 2) { + switch (_toyUfoActionStatus) { + case 5: + _sceneDone = true; + break; + case 7: + _gameSys->insertSequence(0x10870, _toyUfoId, _toyUfoSequenceId | 0x10000, _toyUfoId, kSeqSyncWait, 0, 0, 0); + setFlag(24); + scene42_updateHotspots(); + toyUfoSetStatus(19); + _toyUfoSequenceId = 0x870; + _gameSys->setAnimation(0x10870, _toyUfoId, 3); + _toyUfoActionStatus = -1; + _toyUfoX = 0x181; + _toyUfoY = 53; + break; + default: + if (_toyUfoSequenceId == 0x872) { + hideCursor(); + addFullScreenSprite(0x13E, 255); + _gameSys->setAnimation(0x151, 256, 0); + _gameSys->insertSequence(0x151, 256, 0, 0, kSeqNone, 0, 0, 0); + while (_gameSys->getAnimationStatus(0) != 2) + gameUpdateTick(); + removeFullScreenSprite(); + showCursor(); + } + _toyUfoNextSequenceId = toyUfoGetSequenceId(); + _gameSys->setAnimation(_toyUfoNextSequenceId | 0x10000, (_toyUfoId + 1) % 10, 3); + _gameSys->insertSequence(_toyUfoNextSequenceId | 0x10000, (_toyUfoId + 1) % 10, + _toyUfoSequenceId | 0x10000, _toyUfoId, + kSeqSyncWait, 0, _toyUfoX - 274, _toyUfoY - 128); + _toyUfoSequenceId = _toyUfoNextSequenceId; + _toyUfoId = (_toyUfoId + 1) % 10; + break; + } + _toyUfoActionStatus = -1; + } + +} + +} // End of namespace Gnap diff --git a/engines/gnap/scenes/scene43.cpp b/engines/gnap/scenes/scene43.cpp new file mode 100644 index 0000000000..3510cb4d99 --- /dev/null +++ b/engines/gnap/scenes/scene43.cpp @@ -0,0 +1,484 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "gnap/gnap.h" +#include "gnap/gamesys.h" +#include "gnap/resource.h" + +namespace Gnap { + +enum { + kHSPlatypus = 0, + kHSDevice = 1, + kHSExitUfoParty = 2, + kHSExitBBQ = 3, + kHSExitKissinBooth = 4, + kHSTwoHeadedGuy = 5, + kHSKey = 6, + kHSUfo = 7, + kHSWalkArea1 = 8, + kHSWalkArea2 = 9 +}; + +enum { + kHSUfoExitLeft = 1, + kHSUfoExitRight = 2, + kHSUfoKey = 3, + kHSUfoBucket = 4, + kHSUfoDevice = 5 +}; + +int GnapEngine::scene43_init() { + _gameSys->setAnimation(0, 0, 0); + _gameSys->setAnimation(0, 0, 1); + _gameSys->setAnimation(0, 0, 2); + return 0x13F; +} + +void GnapEngine::scene43_updateHotspots() { + if (isFlag(12)) { + setHotspot(kHSPlatypus, 0, 0, 0, 0, SF_DISABLED); + setHotspot(kHSUfoExitLeft, 0, 0, 10, 599, SF_EXIT_L_CURSOR); + setHotspot(kHSUfoExitRight, 790, 0, 799, 599, SF_EXIT_R_CURSOR); + setHotspot(kHSUfoKey, 140, 170, 185, 260, SF_GRAB_CURSOR); + setHotspot(kHSUfoBucket, 475, 290, 545, 365, SF_DISABLED); + setDeviceHotspot(kHSUfoDevice, -1, 534, -1, 599); + if (isFlag(19)) + _hotspots[kHSUfoBucket].flags = SF_GRAB_CURSOR; + // NOTE Bug in the original. Key hotspot wasn't disabled. + if (isFlag(14)) + _hotspots[kHSUfoKey].flags = SF_DISABLED; + _hotspotsCount = 6; + } else { + setHotspot(kHSPlatypus, 0, 0, 0, 0, SF_WALKABLE | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSExitUfoParty, 150, 580, 650, 600, SF_EXIT_D_CURSOR | SF_WALKABLE, 5, 9); + setHotspot(kHSExitBBQ, 0, 100, 10, 599, SF_EXIT_L_CURSOR, 0, 8); + setHotspot(kHSExitKissinBooth, 790, 100, 799, 599, SF_EXIT_R_CURSOR, 10, 8); + setHotspot(kHSTwoHeadedGuy, 470, 240, 700, 470, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSKey, 140, 170, 185, 260, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSUfo, 110, 0, 690, 350, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSWalkArea1, 0, 0, 800, 445); + setHotspot(kHSWalkArea2, 465, 0, 800, 493); + setDeviceHotspot(kHSDevice, -1, -1, -1, -1); + if (isFlag(14)) + _hotspots[kHSKey].flags = SF_DISABLED; + _hotspotsCount = 10; + } +} + +void GnapEngine::scene43_run() { + + queueInsertDeviceIcon(); + + if (!isFlag(14)) + _gameSys->insertSequence(0x1086F, 1, 0, 0, kSeqNone, 0, 0, 0); + + _s43_dword_47F2B0 = 0x13C; + _s43_dword_47F2B4 = -1; + + _gameSys->setAnimation(0x13C, 1, 2); + _gameSys->insertSequence(_s43_dword_47F2B0, 1, 0, 0, kSeqNone, 0, 0, 0); + + if (isFlag(12)) { + _toyUfoId = 0; + _toyUfoActionStatus = -1; + _toyUfoSequenceId = toyUfoGetSequenceId(); + _toyUfoNextSequenceId = _toyUfoSequenceId; + if (_prevSceneNum == 42) + _toyUfoX = 30; + else + _toyUfoX = 770; + _gameSys->setAnimation(_toyUfoSequenceId | 0x10000, _toyUfoId, 3); + _gameSys->insertSequence(_toyUfoSequenceId | 0x10000, _toyUfoId, 0, 0, kSeqNone, 0, _toyUfoX - 274, _toyUfoY - 128); + endSceneInit(); + } else { + switch (_prevSceneNum) { + case 42: + initGnapPos(-1, 8, 7); + initBeaverPos(-1, 9, 5); + endSceneInit(); + gnapWalkTo(2, 8, -1, 0x107B9, 1); + platypusWalkTo(1, 8, -1, 0x107C2, 1); + break; + case 44: + initGnapPos(11, 8, 7); + initBeaverPos(11, 9, 5); + endSceneInit(); + gnapWalkTo(8, 8, -1, 0x107BA, 1); + platypusWalkTo(9, 8, -1, 0x107D2, 1); + break; + case 54: + initGnapPos(4, 7, 3); + initBeaverPos(11, 8, 5); + endSceneInit(); + platypusWalkTo(9, 8, -1, 0x107D2, 1); + break; + default: + initGnapPos(5, 11, 7); + initBeaverPos(6, 11, 5); + endSceneInit(); + gnapWalkTo(5, 8, -1, 0x107BA, 1); + platypusWalkTo(6, 8, -1, 0x107C2, 1); + break; + } + } + + while (!_sceneDone) { + + if (!isSoundPlaying(0x1094B)) + playSound(0x1094B, 1); + + updateMouseCursor(); + updateCursorByHotspot(); + + testWalk(0, 0, -1, -1, -1, -1); + + _sceneClickedHotspot = getClickedHotspotId(); + updateGrabCursorSprite(0, 0); + + if (isFlag(12)) { + + switch (_sceneClickedHotspot) { + + case kHSUfoDevice: + runMenu(); + scene43_updateHotspots(); + _timers[4] = getRandom(100) + 100; + break; + + case kHSUfoExitLeft: + if (_toyUfoActionStatus < 0) { + _isLeavingScene = 1; + _toyUfoActionStatus = 4; + _newSceneNum = 42; + toyUfoFlyTo(-35, -1, -35, 799, 0, 300, 3); + } + break; + + case kHSUfoExitRight: + if (_toyUfoActionStatus < 0) { + _isLeavingScene = 1; + _toyUfoActionStatus = 4; + _newSceneNum = 44; + toyUfoFlyTo(835, -1, 0, 835, 0, 300, 3); + } + break; + + case kHSUfoKey: + if (isFlag(17)) { + _toyUfoActionStatus = 6; + toyUfoFlyTo(163, 145, 0, 799, 0, 300, 3); + } else { + _toyUfoActionStatus = 5; + toyUfoFlyTo(-1, -1, 0, 799, 0, 300, 3); + } + break; + + case kHSUfoBucket: + _toyUfoActionStatus = 7; + toyUfoFlyTo(497, 143, 0, 799, 0, 300, 3); + _timers[9] = 600; + break; + } + + } else { + + switch (_sceneClickedHotspot) { + + case kHSDevice: + runMenu(); + scene43_updateHotspots(); + _timers[4] = getRandom(100) + 100; + break; + + case kHSPlatypus: + if (_gnapActionStatus < 0) { + if (_grabCursorSpriteIndex >= 0) { + playGnapImpossible(_platX, _platY); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapMoan1(_platX, _platY); + break; + case GRAB_CURSOR: + gnapKissPlatypus(0); + break; + case TALK_CURSOR: + playGnapBrainPulsating(_platX, _platY); + playBeaverSequence(getBeaverSequenceId(0, 0, 0) | 0x10000); + break; + case PLAT_CURSOR: + playGnapImpossible(_platX, _platY); + break; + } + } + } + break; + + case kHSExitUfoParty: + _isLeavingScene = 1; + gnapWalkTo(_hotspotsWalkPos[kHSExitUfoParty].x, _hotspotsWalkPos[kHSExitUfoParty].y, 0, 0x107AE, 1); + _gnapActionStatus = 0; + platypusWalkTo(_hotspotsWalkPos[kHSExitUfoParty].x, _hotspotsWalkPos[kHSExitUfoParty].y, -1, 0x107C7, 1); + _newSceneNum = 40; + break; + + case kHSExitBBQ: + _isLeavingScene = 1; + gnapWalkTo(_hotspotsWalkPos[kHSExitBBQ].x, _gnapY, 0, 0x107AF, 1); + _gnapActionStatus = 0; + platypusWalkTo(_hotspotsWalkPos[kHSExitBBQ].x, _hotspotsWalkPos[kHSExitBBQ].y, -1, 0x107CF, 1); + _newSceneNum = 42; + break; + + case kHSExitKissinBooth: + _isLeavingScene = 1; + gnapWalkTo(_hotspotsWalkPos[kHSExitKissinBooth].x, _gnapY, 0, 0x107AB, 1); + _gnapActionStatus = 0; + platypusWalkTo(_hotspotsWalkPos[kHSExitKissinBooth].x, _hotspotsWalkPos[kHSExitKissinBooth].y, -1, 0x107CD, 1); + _newSceneNum = 44; + break; + + case kHSTwoHeadedGuy: + if (_grabCursorSpriteIndex >= 0) { + playGnapShowCurrItem(6, 8, 7, 0); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapScratchingHead(7, 0); + break; + case TALK_CURSOR: + _gnapIdleFacing = 7; + gnapWalkTo(5, 8, 0, getGnapSequenceId(gskBrainPulsating, 0, 0) | 0x10000, 1); + _gnapActionStatus = 2; + break; + case GRAB_CURSOR: + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + break; + + case kHSKey: + case kHSUfo: + if (_grabCursorSpriteIndex >= 0) { + playGnapShowCurrItem(3, 7, 2, 0); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapScratchingHead(0, 0); + break; + case GRAB_CURSOR: + _gnapIdleFacing = 7; + gnapWalkTo(3, 7, 0, 67515, 1); + _gnapActionStatus = 1; + break; + case TALK_CURSOR: + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + break; + + case kHSWalkArea1: + case kHSWalkArea2: + if (_gnapActionStatus < 0) + gnapWalkTo(-1, -1, -1, -1, 1); + break; + + } + + } + + if (_mouseClickState.left && _gnapActionStatus < 0) { + _mouseClickState.left = false; + if (isFlag(12) && (_toyUfoActionStatus == 5 || _toyUfoActionStatus == -1)) { + _toyUfoActionStatus = 5; + toyUfoFlyTo(-1, -1, 0, 799, 0, 300, 3); + } else { + gnapWalkTo(-1, -1, -1, -1, 1); + } + } + + scene43_updateAnimations(); + + toyUfoCheckTimer(); + + if (!_isLeavingScene) { + if (_beaverActionStatus < 0 && !isFlag(12)) + updateBeaverIdleSequence(); + if (_gnapActionStatus < 0 && !isFlag(12)) + updateGnapIdleSequence(); + if (!_timers[4] && (!isFlag(12) || !isFlag(19))) { + _timers[4] = getRandom(100) + 100; + if (_gnapActionStatus < 0 && _beaverActionStatus < 0 && _s43_dword_47F2B4 == -1) { + _gnapRandomValue = getRandom(5); + switch (_gnapRandomValue) { + case 0: + _s43_dword_47F2B4 = 0x13C; + break; + case 1: + _s43_dword_47F2B4 = 0x134; + break; + case 2: + _s43_dword_47F2B4 = 0x135; + break; + case 3: + _s43_dword_47F2B4 = 0x136; + break; + case 4: + _s43_dword_47F2B4 = 0x13A; + break; + } + if (_s43_dword_47F2B4 == _s43_dword_47F2B0) + _s43_dword_47F2B4 = -1; + } + } + } + + checkGameKeys(); + + if (isKeyStatus1(8)) { + clearKeyStatus1(8); + runMenu(); + scene43_updateHotspots(); + _timers[4] = getRandom(100) + 100; + } + + gameUpdateTick(); + + } + + if (_newSceneNum == 54) + clearFlag(12); + +} + +void GnapEngine::scene43_updateAnimations() { + + if (_gameSys->getAnimationStatus(0) == 2) { + switch (_gnapActionStatus) { + case 0: + _gameSys->setAnimation(0, 0, 0); + _sceneDone = true; + break; + case 1: + if (_gameSys->getAnimationStatus(2) == 2) { + _timers[2] = getRandom(30) + 20; + _timers[3] = getRandom(50) + 200; + _gameSys->insertSequence(0x13D, _gnapId, makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, kSeqSyncWait, 0, 0, 0); + _gnapSequenceId = 0x13D; + _gnapSequenceDatNum = 0; + _gameSys->setAnimation(0x13D, _gnapId, 0); + _s43_dword_47F2B4 = 0x13B; + _gameSys->insertSequence(0x13B, 1, _s43_dword_47F2B0, 1, kSeqSyncWait, 0, 0, 0); + _gameSys->setAnimation(_s43_dword_47F2B4, 1, 2); + _s43_dword_47F2B0 = _s43_dword_47F2B4; + _s43_dword_47F2B4 = -1; + _timers[4] = getRandom(100) + 100; + _gnapActionStatus = -1; + } + break; + default: + _gameSys->setAnimation(0, 0, 0); + _gnapActionStatus = -1; + break; + } + } + + if (_gameSys->getAnimationStatus(2) == 2) { + if (_s43_dword_47F2B0 == 0x13A) { + if (isFlag(19)) { + _s43_dword_47F2B4 = 0x13E; + stopSound(0x108F6); + } else if (getRandom(2) != 0) { + _s43_dword_47F2B4 = 0x137; + } else { + _s43_dword_47F2B4 = 0x138; + } + } else if (_s43_dword_47F2B0 == 0x13E) { + _sceneDone = true; + _newSceneNum = 54; + } + if (_s43_dword_47F2B4 != -1) { + _gameSys->insertSequence(_s43_dword_47F2B4, 1, _s43_dword_47F2B0, 1, kSeqSyncWait, 0, 0, 0); + _gameSys->setAnimation(_s43_dword_47F2B4, 1, 2); + _s43_dword_47F2B0 = _s43_dword_47F2B4; + _s43_dword_47F2B4 = -1; + _timers[4] = getRandom(100) + 100; + } + } + + if (_gameSys->getAnimationStatus(3) == 2) { + switch (_toyUfoActionStatus) { + case 4: + _sceneDone = true; + _toyUfoActionStatus = -1; + break; + case 6: + _gameSys->insertSequence(0x10871, _toyUfoId, _toyUfoSequenceId | 0x10000, _toyUfoId, kSeqSyncWait, 0, 0, 0); + _gameSys->removeSequence(0x1086F, 1, 1); + setFlag(14); + scene43_updateHotspots(); + toyUfoSetStatus(18); + _toyUfoSequenceId = 0x871; + _gameSys->setAnimation(0x10871, _toyUfoId, 3); + _toyUfoActionStatus = -1; + _toyUfoX = 96; + _toyUfoY = 131; + break; + case 7: + _gameSys->insertSequence(0x10874, _toyUfoId, _toyUfoSequenceId | 0x10000, _toyUfoId, kSeqSyncWait, 0, 0, 0); + _toyUfoSequenceId = 0x874; + _gameSys->setAnimation(0x10874, _toyUfoId, 3); + _toyUfoActionStatus = 8; + setFlag(17); + _gnapActionStatus = 3; + break; + case 8: + _s43_dword_47F2B4 = 0x13A; + _toyUfoX = 514; + _toyUfoY = 125; + toyUfoFlyTo(835, 125, 0, 835, 0, 300, 3); + _toyUfoActionStatus = 9; + break; + case 9: + // Nothing + break; + default: + _toyUfoNextSequenceId = toyUfoGetSequenceId(); + _gameSys->insertSequence(_toyUfoNextSequenceId | 0x10000, _toyUfoId + 1, + _toyUfoSequenceId | 0x10000, _toyUfoId, + kSeqSyncWait, 0, _toyUfoX - 274, _toyUfoY - 128); + _toyUfoSequenceId = _toyUfoNextSequenceId; + ++_toyUfoId; + _gameSys->setAnimation(_toyUfoNextSequenceId | 0x10000, _toyUfoId, 3); + _toyUfoActionStatus = -1; + break; + } + } + +} + +} // End of namespace Gnap diff --git a/engines/gnap/scenes/scene44.cpp b/engines/gnap/scenes/scene44.cpp new file mode 100644 index 0000000000..b2c711898c --- /dev/null +++ b/engines/gnap/scenes/scene44.cpp @@ -0,0 +1,529 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "gnap/gnap.h" +#include "gnap/gamesys.h" +#include "gnap/resource.h" + +namespace Gnap { + +enum { + kHSPlatypus = 0, + kHSExitUfoParty = 1, + kHSExitUfo = 2, + kHSExitShow = 3, + kHSKissingLady = 4, + kHSSpring = 5, + kHSSpringGuy = 6, + kHSDevice = 7, + kHSWalkArea1 = 8, + kHSWalkArea2 = 9 +}; + +enum { + kHSUfoExitLeft = 1, + kHSUfoExitRight = 2, + kHSUfoDevice = 3 +}; + +int GnapEngine::scene44_init() { + _gameSys->setAnimation(0, 0, 0); + _gameSys->setAnimation(0, 0, 1); + _gameSys->setAnimation(0, 0, 2); + _gameSys->setAnimation(0, 0, 3); + return 0xFF; +} + +void GnapEngine::scene44_updateHotspots() { + if (isFlag(12)) { + setHotspot(kHSPlatypus, 0, 0, 0, 0, SF_DISABLED); + setHotspot(kHSUfoExitLeft, 0, 0, 10, 599, SF_EXIT_L_CURSOR); + setHotspot(kHSUfoExitRight, 790, 0, 799, 599, SF_EXIT_R_CURSOR); + setDeviceHotspot(kHSUfoDevice, -1, 534, -1, 599); + _hotspotsCount = 4; + } else { + setHotspot(kHSPlatypus, 0, 0, 0, 0, SF_WALKABLE | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSExitUfoParty, 150, 580, 650, 600, SF_EXIT_D_CURSOR | SF_WALKABLE, 5, 9); + setHotspot(kHSExitUfo, 0, 100, 10, 599, SF_EXIT_L_CURSOR, 0, 8); + setHotspot(kHSExitShow, 790, 100, 799, 599, SF_EXIT_R_CURSOR, 10, 8); + setHotspot(kHSKissingLady, 300, 160, 400, 315, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR, 5, 7); + setHotspot(kHSSpring, 580, 310, 635, 375, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR, 7, 8); + setHotspot(kHSSpringGuy, 610, 375, 690, 515, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR, 7, 8); + setHotspot(kHSWalkArea1, 0, 0, 800, 445); + setHotspot(kHSWalkArea2, 617, 0, 800, 600); + setDeviceHotspot(kHSDevice, -1, -1, -1, -1); + if (isFlag(13)) + _hotspots[kHSKissingLady].flags = SF_DISABLED; + if (isFlag(15)) + _hotspots[kHSSpring].flags = SF_DISABLED; + _hotspotsCount = 10; + } +} + +void GnapEngine::scene44_run() { + + queueInsertDeviceIcon(); + + _gameSys->insertSequence(0xF7, 0, 0, 0, kSeqLoop, 0, 0, 0); + _gameSys->insertSequence(0xFC, 256, 0, 0, kSeqNone, 0, 0, 0); + + if (isFlag(15)) + _s44_dword_47EB0C = 0xF8; + else + _s44_dword_47EB0C = 0xF9; + + _s44_dword_47EB04 = -1; + _gameSys->setAnimation(_s44_dword_47EB0C, 1, 4); + _gameSys->insertSequence(_s44_dword_47EB0C, 1, 0, 0, kSeqNone, 0, 0, 0); + + if (isFlag(13)) { + if (_prevSceneNum != 50 || _sceneSavegameLoaded) { + _s44_dword_47EB10 = 0xF6; + _s44_dword_47EB08 = -1; + } else { + setGrabCursorSprite(kItemGum); + _s44_dword_47EB10 = 0xF5; + _s44_dword_47EB08 = 0xF6; + _gameSys->setAnimation(0xF5, 1, 2); + } + } else { + _s44_dword_47EB10 = 0xEC; + _s44_dword_47EB08 = -1; + _gameSys->setAnimation(0xEC, 1, 2); + } + + _gameSys->insertSequence(_s44_dword_47EB10, 1, 0, 0, kSeqNone, 0, 0, 0); + + if (isFlag(12)) { + _toyUfoId = 0; + _toyUfoActionStatus = -1; + _toyUfoSequenceId = toyUfoGetSequenceId(); + _toyUfoNextSequenceId = _toyUfoSequenceId; + if (_prevSceneNum == 43) + _toyUfoX = 30; + else + _toyUfoX = 770; + _gameSys->setAnimation(_toyUfoSequenceId | 0x10000, _toyUfoId, 3); + _gameSys->insertSequence(_toyUfoSequenceId | 0x10000, _toyUfoId, 0, 0, kSeqNone, 0, _toyUfoX - 274, _toyUfoY - 128); + endSceneInit(); + } else { + switch (_prevSceneNum) { + case 43: + initGnapPos(-1, 8, 7); + initBeaverPos(-1, 7, 5); + endSceneInit(); + gnapWalkTo(2, 8, -1, 0x107B9, 1); + platypusWalkTo(1, 8, -1, 0x107C2, 1); + break; + case 46: + initGnapPos(11, 8, 7); + initBeaverPos(11, 8, 5); + endSceneInit(); + gnapWalkTo(6, 8, -1, 0x107BA, 1); + platypusWalkTo(7, 8, -1, 0x107D2, 1); + break; + case 50: + initGnapPos(4, 8, 1); + if (_sceneSavegameLoaded) { + initBeaverPos(_hotspotsWalkPos[4].x, _hotspotsWalkPos[4].y, 4); + } else if (!isFlag(13)) { + _timers[0] = 50; + _timers[1] = 20; + _platX = 5; + _platY = 8; + _beaverSequenceId = 0xFD; + _beaverFacing = 0; + _beaverId = 160; + _beaverSequenceDatNum = 0; + _gameSys->insertSequence(0xFD, 160, 0, 0, kSeqNone, 0, 0, 0); + } + endSceneInit(); + break; + default: + initGnapPos(5, 11, 7); + initBeaverPos(6, 11, 5); + endSceneInit(); + platypusWalkTo(6, 8, -1, 0x107C2, 1); + gnapWalkTo(5, 8, -1, 0x107BA, 1); + break; + } + } + + while (!_sceneDone) { + + if (!isSoundPlaying(0x1094B)) + playSound(0x1094B, 1); + + updateMouseCursor(); + updateCursorByHotspot(); + + testWalk(0, 0, -1, -1, -1, -1); + + _sceneClickedHotspot = getClickedHotspotId(); + updateGrabCursorSprite(0, 0); + + if (isFlag(12)) { + + switch (_sceneClickedHotspot) { + + case kHSUfoExitLeft: + if (_toyUfoActionStatus < 0) { + _isLeavingScene = 1; + _toyUfoActionStatus = 6; + _newSceneNum = 43; + toyUfoFlyTo(-35, -1, -35, 799, 0, 300, 3); + } + break; + + case kHSUfoExitRight: + if (_toyUfoActionStatus < 0) { + _isLeavingScene = 1; + _toyUfoActionStatus = 6; + _newSceneNum = 46; + toyUfoFlyTo(835, -1, 0, 835, 0, 300, 3); + } + break; + + case kHSUfoDevice: + runMenu(); + scene44_updateHotspots(); + _timers[4] = getRandom(20) + 20; + break; + + } + + } else if (_sceneClickedHotspot <= 9) { + + switch (_sceneClickedHotspot) { + + case kHSDevice: + runMenu(); + scene44_updateHotspots(); + _timers[4] = getRandom(20) + 20; + break; + + case kHSPlatypus: + if (_gnapActionStatus < 0) { + if (_grabCursorSpriteIndex >= 0) { + playGnapImpossible(_platX, _platY); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapMoan1(_platX, _platY); + break; + case GRAB_CURSOR: + gnapKissPlatypus(0); + break; + case TALK_CURSOR: + playGnapBrainPulsating(_platX, _platY); + playBeaverSequence(getBeaverSequenceId(0, 0, 0) | 0x10000); + break; + case PLAT_CURSOR: + playGnapImpossible(_platX, _platY); + break; + } + } + } + break; + + case kHSExitUfoParty: + _isLeavingScene = 1; + gnapWalkTo(_hotspotsWalkPos[kHSExitUfoParty].x, _hotspotsWalkPos[kHSExitUfoParty].y, 0, 0x107AE, 1); + _gnapActionStatus = 0; + _newSceneNum = 40; + break; + + case kHSExitUfo: + _isLeavingScene = 1; + gnapWalkTo(_hotspotsWalkPos[kHSExitUfo].x, _gnapY, 0, 0x107AF, 1); + _gnapActionStatus = 0; + platypusWalkTo(_hotspotsWalkPos[kHSExitUfo].x, _platY, -1, 0x107CF, 1); + _newSceneNum = 43; + break; + + case kHSExitShow: + _isLeavingScene = 1; + gnapWalkTo(_hotspotsWalkPos[kHSExitShow].x, _hotspotsWalkPos[kHSExitShow].y, 0, 0x107AB, 1); + _gnapActionStatus = 0; + _newSceneNum = 46; + break; + + case kHSKissingLady: + if (_grabCursorSpriteIndex >= 0) { + _gnapActionStatus = 2; + gnapWalkTo(_hotspotsWalkPos[kHSKissingLady].x, _hotspotsWalkPos[kHSKissingLady].y, 0, -1, 9); + playGnapShowItem(_grabCursorSpriteIndex, _hotspotsWalkPos[kHSKissingLady].x - 1, _hotspotsWalkPos[kHSKissingLady].y); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapScratchingHead(4, 3); + break; + case GRAB_CURSOR: + playGnapImpossible(0, 0); + break; + case TALK_CURSOR: + _gnapIdleFacing = 5; + gnapWalkTo(_hotspotsWalkPos[kHSKissingLady].x, _hotspotsWalkPos[kHSKissingLady].y, 0, getGnapSequenceId(gskBrainPulsating, 0, 0) | 0x10000, 1); + _gnapActionStatus = 1; + break; + case PLAT_CURSOR: + gnapUseDeviceOnBeaver(); + platypusWalkTo(6, 7, 1, 0x107D2, 1); + if (_gnapX == 7 && _gnapY == 7) + gnapWalkStep(); + playGnapIdle(5, 7); + _beaverActionStatus = 4; + break; + } + } + break; + + case kHSSpring: + if (_grabCursorSpriteIndex >= 0) { + playGnapShowCurrItem(_hotspotsWalkPos[kHSSpring].x, _hotspotsWalkPos[kHSSpring].y, 8, 0); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapScratchingHead(8, 7); + break; + case GRAB_CURSOR: + playGnapPullOutDevice(8, 0); + playGnapUseDevice(8, 0); + _s44_dword_47EB04 = 0xFB; + invAdd(kItemSpring); + setFlag(15); + scene44_updateHotspots(); + break; + case TALK_CURSOR: + playGnapImpossible(0, 0); + break; + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + break; + + case kHSSpringGuy: + if (_grabCursorSpriteIndex >= 0) { + playGnapShowCurrItem(_hotspotsWalkPos[kHSSpringGuy].x, _hotspotsWalkPos[kHSSpringGuy].y, 8, 0); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + if (isFlag(15)) + playGnapMoan1(8, 7); + else + playGnapScratchingHead(8, 7); + break; + case TALK_CURSOR: + _gnapIdleFacing = 7; + gnapWalkTo(_hotspotsWalkPos[kHSSpringGuy].x, _hotspotsWalkPos[kHSSpringGuy].y, -1, getGnapSequenceId(gskBrainPulsating, 0, 0) | 0x10000, 1); + break; + case GRAB_CURSOR: + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + break; + + case kHSWalkArea1: + case kHSWalkArea2: + if (_gnapActionStatus < 0) + gnapWalkTo(-1, -1, -1, -1, 1); + break; + + } + + } + + if (_mouseClickState.left && _gnapActionStatus < 0) { + _mouseClickState.left = false; + if (isFlag(12)) { + _toyUfoActionStatus = 7; + toyUfoFlyTo(-1, -1, 0, 799, 0, 300, 3); + } else { + gnapWalkTo(-1, -1, -1, -1, 1); + } + } + + scene44_updateAnimations(); + + toyUfoCheckTimer(); + + if (!_isLeavingScene) { + if (_beaverActionStatus < 0 && !isFlag(12) && _s44_dword_47EB10 != 0xF5) + updateBeaverIdleSequence(); + if (_gnapActionStatus < 0 && !isFlag(12)) + updateGnapIdleSequence(); + if (!_timers[4]) { + _timers[4] = getRandom(20) + 20; + if (_gnapActionStatus < 0 && _beaverActionStatus < 0 && _s44_dword_47EB08 == -1) { + _gnapRandomValue = getRandom(20); + switch (_gnapRandomValue) { + case 0: + _s44_dword_47EB08 = 0xED; + break; + case 1: + _s44_dword_47EB08 = 0xEE; + break; + case 2: + _s44_dword_47EB08 = 0xF0; + break; + case 3: + _s44_dword_47EB08 = 0xF3; + break; + case 4: + _s44_dword_47EB08 = 0xF4; + break; + default: + _s44_dword_47EB08 = 0xEC; + break; + } + if (_s44_dword_47EB08 != 0xEC && _s44_dword_47EB08 == _s44_dword_47EB10) + _s44_dword_47EB08 = -1; + } + } + if (!_timers[5]) { + _timers[5] = getRandom(20) + 20; + if (_gnapActionStatus < 0 && _beaverActionStatus < 0 && _s44_dword_47EB04 == -1) { + _gnapRandomValue = getRandom(5); + if (_gnapRandomValue != 0) { + if (!isFlag(15)) + _s44_dword_47EB04 = 0xF9; + } else { + if (isFlag(15)) + _s44_dword_47EB04 = 0xF8; + else + _s44_dword_47EB04 = 0xFA; + } + } + } + } + + checkGameKeys(); + + if (isKeyStatus1(8)) { + clearKeyStatus1(8); + runMenu(); + scene44_updateHotspots(); + _timers[4] = getRandom(20) + 20; + } + + gameUpdateTick(); + + } + +} + +void GnapEngine::scene44_updateAnimations() { + + if (_gameSys->getAnimationStatus(0) == 2) { + _gameSys->setAnimation(0, 0, 0); + switch (_gnapActionStatus) { + case 0: + _sceneDone = true; + break; + case 1: + _s44_dword_47EB08 = 0xEF; + break; + case 2: + _s44_dword_47EB08 = 0xF2; + break; + } + _gnapActionStatus = -1; + } + + if (_gameSys->getAnimationStatus(1) == 2) { + _gameSys->setAnimation(0, 0, 1); + switch (_beaverActionStatus) { + case 4: + if (_gameSys->getAnimationStatus(2) == 2) { + _gameSys->insertSequence(0xFE, _beaverId, _beaverSequenceId | (_beaverSequenceDatNum << 16), _beaverId, kSeqSyncWait, 0, 0, 0); + _beaverSequenceId = 0xFE; + _beaverSequenceDatNum = 0; + _gameSys->setAnimation(0xFE, _beaverId, 1); + _gameSys->removeSequence(_s44_dword_47EB10, 1, 1); + _beaverActionStatus = 5; + } + break; + case 5: + _sceneDone = true; + _newSceneNum = 50; + break; + default: + _beaverActionStatus = -1; + break; + } + } + + if (_gameSys->getAnimationStatus(2) == 2) { + if (_s44_dword_47EB08 == 0xF6) { + _gameSys->insertSequence(_s44_dword_47EB08, 1, _s44_dword_47EB10, 1, kSeqSyncWait, 0, 0, 0); + initBeaverPos(5, 8, 0); + _s44_dword_47EB10 = _s44_dword_47EB08; + _s44_dword_47EB08 = -1; + _gameSys->setAnimation(0, 0, 2); + } else if (_s44_dword_47EB08 != -1) { + _gameSys->insertSequence(_s44_dword_47EB08, 1, _s44_dword_47EB10, 1, kSeqSyncWait, 0, 0, 0); + _gameSys->setAnimation(_s44_dword_47EB08, 1, 2); + _s44_dword_47EB10 = _s44_dword_47EB08; + _s44_dword_47EB08 = -1; + _timers[4] = getRandom(20) + 20; + } + } + + if (_gameSys->getAnimationStatus(4) == 2) { + if (_s44_dword_47EB0C == 0xFB) { + setGrabCursorSprite(kItemSpring); + _s44_dword_47EB04 = 0xF8; + } + if (_s44_dword_47EB04 != -1) { + _gameSys->insertSequence(_s44_dword_47EB04, 1, _s44_dword_47EB0C, 1, kSeqSyncWait, 0, 0, 0); + _gameSys->setAnimation(_s44_dword_47EB04, 1, 4); + _s44_dword_47EB0C = _s44_dword_47EB04; + _s44_dword_47EB04 = -1; + _timers[5] = getRandom(20) + 20; + } + } + + if (_gameSys->getAnimationStatus(3) == 2) { + switch (_toyUfoActionStatus) { + case 6: + _sceneDone = true; + break; + default: + _toyUfoNextSequenceId = toyUfoGetSequenceId(); + _gameSys->insertSequence(_toyUfoNextSequenceId | 0x10000, _toyUfoId + 1, + _toyUfoSequenceId | 0x10000, _toyUfoId, + kSeqSyncWait, 0, _toyUfoX - 274, _toyUfoY - 128); + _toyUfoSequenceId = _toyUfoNextSequenceId; + ++_toyUfoId; + _gameSys->setAnimation(_toyUfoNextSequenceId | 0x10000, _toyUfoId, 3); + break; + } + _toyUfoActionStatus = -1; + } + +} + +} // End of namespace Gnap diff --git a/engines/gnap/scenes/scene45.cpp b/engines/gnap/scenes/scene45.cpp new file mode 100644 index 0000000000..ba583045e5 --- /dev/null +++ b/engines/gnap/scenes/scene45.cpp @@ -0,0 +1,430 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "gnap/gnap.h" +#include "gnap/gamesys.h" +#include "gnap/resource.h" + +namespace Gnap { + +enum { + kHSPlatypus = 0, + kHSExitUfoParty = 1, + kHSExitShoe = 2, + kHSExitRight = 3, + kHSExitDiscoBall = 4, + kHSDiscoBall = 5, + kHSDevice = 6, + kHSWalkArea1 = 7 +}; + +enum { + kHSUfoExitLeft = 1, + kHSUfoExitRight = 2, + kHSUfoDevice = 3 +}; + +int GnapEngine::scene45_init() { + _gameSys->setAnimation(0, 0, 0); + _gameSys->setAnimation(0, 0, 1); + _gameSys->setAnimation(0, 0, 2); + _gameSys->setAnimation(0, 0, 3); + _gameSys->setAnimation(0, 0, 4); + _gameSys->setAnimation(0, 0, 5); + return isFlag(23) ? 0xA2 : 0xA1; +} + +void GnapEngine::scene45_updateHotspots() { + if (isFlag(12)) { + setHotspot(kHSPlatypus, 0, 0, 0, 0, SF_DISABLED); + setHotspot(kHSUfoExitLeft, 0, 0, 10, 599, SF_EXIT_L_CURSOR); + setHotspot(kHSUfoExitRight, 794, 0, 799, 599, SF_EXIT_R_CURSOR | SF_DISABLED); + setDeviceHotspot(kHSUfoDevice, -1, 534, -1, 599); + _hotspotsCount = 4; + } else { + setHotspot(kHSPlatypus, 0, 0, 0, 0, SF_WALKABLE | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSExitUfoParty, 150, 580, 650, 600, SF_EXIT_D_CURSOR | SF_WALKABLE, 5, 9); + setHotspot(kHSExitShoe, 0, 100, 10, 599, SF_EXIT_L_CURSOR, 0, 8); + setHotspot(kHSExitRight, 794, 100, 799, 599, SF_EXIT_R_CURSOR | SF_DISABLED, 10, 8); + setHotspot(kHSExitDiscoBall, 200, 0, 600, 10, SF_DISABLED); + setHotspot(kHSDiscoBall, 370, 10, 470, 125, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR, 6, 7); + setHotspot(kHSWalkArea1, 0, 0, 800, 472); + setDeviceHotspot(kHSDevice, -1, -1, -1, -1); + if (isFlag(22)) { + _hotspots[kHSPlatypus].flags = SF_DISABLED; + _hotspots[kHSExitUfoParty].flags = SF_DISABLED; + _hotspots[kHSExitShoe].flags = SF_DISABLED; + _hotspots[kHSExitRight].flags = SF_DISABLED; + _hotspots[kHSExitDiscoBall].flags = SF_EXIT_U_CURSOR; + } + if (isFlag(23) || isFlag(22)) + _hotspots[kHSDiscoBall].flags = SF_DISABLED; + _hotspotsCount = 8; + } +} + +void GnapEngine::scene45_run() { + + if (!isSoundPlaying(0x1094A)) + playSound(0x1094A, 1); + + queueInsertDeviceIcon(); + + _gameSys->insertSequence(0x96, 1, 0, 0, kSeqNone, 0, 0, 0); + _gameSys->setAnimation(0x96, 1, 3); + _gameSys->insertSequence(0x99, 1, 0, 0, kSeqNone, 0, 0, 0); + _gameSys->setAnimation(0x99, 1, 4); + _s45_dword_4749BC = 0x8F; + _gameSys->setAnimation(0x8F, 1, 2); + _gameSys->insertSequence(_s45_dword_4749BC, 1, 0, 0, kSeqNone, 0, 0, 0); + + if (isFlag(12)) { + _toyUfoId = 0; + _toyUfoActionStatus = -1; + _toyUfoSequenceId = toyUfoGetSequenceId(); + _toyUfoNextSequenceId = _toyUfoSequenceId; + if (_prevSceneNum == 46) + _toyUfoX = 30; + else + _toyUfoX = 770; + _gameSys->setAnimation(_toyUfoSequenceId | 0x10000, _toyUfoId, 5); + _gameSys->insertSequence(_toyUfoSequenceId | 0x10000, _toyUfoId, 0, 0, kSeqNone, 0, _toyUfoX - 274, _toyUfoY - 128); + endSceneInit(); + } else if (isFlag(22)) { + _gnapSequenceId = 0x9E; + _gnapSequenceDatNum = 0; + _gnapId = 1; + _gameSys->setAnimation(0x9E, 1, 0); + _gnapActionStatus = 1; + _gameSys->insertSequence(_gnapSequenceId, _gnapId, 0, 0, kSeqNone, 0, 0, 0); + initBeaverPos(4, 8, 0); + endSceneInit(); + } else if (_prevSceneNum == 46) { + initGnapPos(-1, 8, 7); + initBeaverPos(-1, 9, 5); + endSceneInit(); + platypusWalkTo(4, 8, -1, 0x107C2, 1); + gnapWalkTo(2, 7, -1, 0x107B9, 1); + } else if (_prevSceneNum == 41) { + initGnapPos(11, 8, 7); + initBeaverPos(11, 9, 5); + endSceneInit(); + platypusWalkTo(4, 8, -1, 0x107D2, 1); + gnapWalkTo(10, 9, -1, 0x107BA, 1); + } else { + initGnapPos(2, 11, 7); + initBeaverPos(6, 11, 5); + endSceneInit(); + platypusWalkTo(4, 8, -1, 0x107C2, 1); + gnapWalkTo(2, 7, -1, 0x107B9, 1); + } + + if (!isFlag(21) && !isFlag(12)) { + setFlag(21); + setGrabCursorSprite(-1); + _gameSys->setAnimation(0x9D, _gnapId, 0); + _gameSys->insertSequence(0x9D, _gnapId, makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, kSeqSyncWait, 0, 0, 0); + while (_gameSys->getAnimationStatus(0) != 2) { + gameUpdateTick(); + if (_gameSys->getAnimationStatus(2) == 2) { + _gameSys->setAnimation(0, 0, 2); + _gnapRandomValue = getRandom(7); + _s45_dword_4749C0 = _gnapRandomValue + 0x8F; + _gameSys->insertSequence(_gnapRandomValue + 0x8F, 1, _s45_dword_4749BC, 1, kSeqSyncWait, 0, 0, 0); + _gameSys->setAnimation(_s45_dword_4749C0, 1, 2); + _s45_dword_4749BC = _s45_dword_4749C0; + } + if (_gameSys->getAnimationStatus(3) == 2 && _gameSys->getAnimationStatus(4) == 2) { + _gameSys->insertSequence(0x96, 1, 0x96, 1, kSeqSyncWait, 0, 0, 0); + _gameSys->setAnimation(0x96, 1, 3); + _gameSys->insertSequence(0x99, 1, 0x99, 1, kSeqSyncWait, 0, 0, 0); + _gameSys->setAnimation(0x99, 1, 4); + } + } + _gnapSequenceId = 0x9D; + _gnapSequenceDatNum = 0; + hideCursor(); + addFullScreenSprite(0x8A, 255); + _gameSys->setAnimation(0xA0, 256, 0); + _gameSys->insertSequence(0xA0, 256, 0, 0, kSeqNone, 0, 0, 0); + while (_gameSys->getAnimationStatus(0) != 2) + gameUpdateTick(); + _gameSys->setAnimation(0x107BD, _gnapId, 0); + _gameSys->insertSequence(0x107BD, _gnapId, + makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, + kSeqSyncWait, 0, 75 * _gnapX - _gnapGridX, 48 * _gnapY - _gnapGridY); + removeFullScreenSprite(); + showCursor(); + _gnapSequenceId = 0x7BD; + _gnapSequenceDatNum = 1; + } + + playBeaverSequence(0x9A); + _gameSys->setAnimation(_beaverSequenceId, _beaverId, 1); + + while (!_sceneDone) { + + if (!isSoundPlaying(0x1094A)) + playSound(0x1094A, 1); + + updateMouseCursor(); + updateCursorByHotspot(); + + testWalk(0, 0, -1, -1, -1, -1); + + _sceneClickedHotspot = getClickedHotspotId(); + updateGrabCursorSprite(0, 0); + + if (isFlag(12)) { + + switch (_sceneClickedHotspot) { + + case kHSUfoExitLeft: + if (_toyUfoActionStatus < 0) { + _isLeavingScene = 1; + _toyUfoActionStatus = 2; + _newSceneNum = 46; + toyUfoFlyTo(-35, -1, -35, 799, 0, 300, 5); + } + break; + + case kHSUfoExitRight: + if (_toyUfoActionStatus < 0) { + _isLeavingScene = 1; + _toyUfoActionStatus = 2; + _newSceneNum = 41; + toyUfoFlyTo(835, -1, 0, 835, 0, 300, 5); + } + break; + + case kHSUfoDevice: + runMenu(); + scene45_updateHotspots(); + break; + + } + + } else { + + switch (_sceneClickedHotspot) { + + case kHSDevice: + runMenu(); + scene45_updateHotspots(); + break; + + case kHSPlatypus: + if (_gnapActionStatus < 0) { + if (_grabCursorSpriteIndex >= 0) { + playGnapImpossible(_platX, _platY); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapMoan1(_platX, _platY); + break; + case GRAB_CURSOR: + gnapKissPlatypus(0); + playBeaverSequence(0x9A); + _gameSys->setAnimation(_beaverSequenceId, _beaverId, 1); + break; + case TALK_CURSOR: + playGnapBrainPulsating(_platX, _platY); + playBeaverSequence(getBeaverSequenceId(0, 0, 0) | 0x10000); + break; + case PLAT_CURSOR: + playGnapImpossible(_platX, _platY); + break; + } + } + } + break; + + case kHSExitUfoParty: + if (_gnapActionStatus < 0) { + _isLeavingScene = 1; + gnapWalkTo(_gnapX, _hotspotsWalkPos[kHSExitUfoParty].y, 0, 0x107AE, 1); + _gnapActionStatus = 0; + _newSceneNum = 40; + } + break; + + case kHSExitShoe: + if (_gnapActionStatus < 0) { + _isLeavingScene = 1; + gnapWalkTo(_hotspotsWalkPos[kHSExitShoe].x, _gnapY, 0, 0x107AF, 1); + _gnapActionStatus = 0; + platypusWalkTo(_hotspotsWalkPos[kHSExitShoe].x, _platY, -1, 0x107CF, 1); + _newSceneNum = 46; + } + break; + + case kHSExitRight: + if (_gnapActionStatus < 0) { + _isLeavingScene = 1; + gnapWalkTo(_hotspotsWalkPos[kHSExitRight].x, _gnapY, 0, 0x107AB, 1); + _gnapActionStatus = 0; + platypusWalkTo(_hotspotsWalkPos[kHSExitRight].x, _platY, -1, 0x107CD, 1); + _newSceneNum = 41; + } + break; + + case kHSExitDiscoBall: + clearFlag(22); + setFlag(23); + _sceneDone = true; + _newSceneNum = 54; + break; + + case kHSDiscoBall: + if (_gnapActionStatus < 0) { + if (_grabCursorSpriteIndex == kItemSpring) { + gnapWalkTo(_hotspotsWalkPos[kHSDiscoBall].x, _hotspotsWalkPos[kHSDiscoBall].y, 0, 0x9F, 5); + _gnapActionStatus = 1; + setGrabCursorSprite(-1); + invRemove(kItemSpring); + } else if (_grabCursorSpriteIndex >= 0) { + playGnapShowItem(_grabCursorSpriteIndex, 5, 0); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapScratchingHead(5, 0); + break; + case GRAB_CURSOR: + case TALK_CURSOR: + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + } + break; + + case kHSWalkArea1: + if (_gnapActionStatus < 0) + gnapWalkTo(-1, -1, -1, -1, 1); + break; + + } + + } + + if (_mouseClickState.left && _gnapActionStatus < 0) { + _mouseClickState.left = false; + if (isFlag(12)) { + _toyUfoActionStatus = 3; + toyUfoFlyTo(-1, -1, 0, 799, 0, 300, 5); + } else { + gnapWalkTo(-1, -1, -1, -1, 1); + } + } + + scene45_updateAnimations(); + toyUfoCheckTimer(); + + if (!_isLeavingScene && _gnapActionStatus < 0 && !isFlag(12)) + updateGnapIdleSequence(); + + checkGameKeys(); + + if (isKeyStatus1(8)) { + clearKeyStatus1(8); + runMenu(); + scene45_updateHotspots(); + } + + gameUpdateTick(); + + } + + _sceneWaiting = 0; + +} + +void GnapEngine::scene45_updateAnimations() { + + if (_gameSys->getAnimationStatus(0) == 2) { + _gameSys->setAnimation(0, 0, 0); + switch (_gnapActionStatus) { + case 0: + _sceneDone = true; + break; + case 1: + _sceneWaiting = 1; + setFlag(22); + scene45_updateHotspots(); + _gameSys->insertSequence(0x9E, _gnapId, makeRid(_gnapSequenceDatNum, _gnapSequenceId), _gnapId, kSeqSyncWait, 0, 0, 0); + _gnapSequenceId = 0x9E; + _gnapSequenceDatNum = 0; + _gameSys->setAnimation(0x9E, _gnapId, 0); + break; + default: + _gnapActionStatus = -1; + break; + } + } + + if (_gameSys->getAnimationStatus(1) == 2) { + _gameSys->setAnimation(0, 0, 1); + if (getRandom(2) != 0) + playBeaverSequence(0x9B); + else + playBeaverSequence(0x9C); + _gameSys->setAnimation(_beaverSequenceId, _beaverId, 1); + } + + if (_gameSys->getAnimationStatus(2) == 2) { + _gameSys->setAnimation(0, 0, 2); + _gnapRandomValue = getRandom(7); + _s45_dword_4749C0 = _gnapRandomValue + 0x8F; + _gameSys->insertSequence(_gnapRandomValue + 0x8F, 1, _s45_dword_4749BC, 1, kSeqSyncWait, 0, 0, 0); + _gameSys->setAnimation(_s45_dword_4749C0, 1, 2); + _s45_dword_4749BC = _s45_dword_4749C0; + } + + if (_gameSys->getAnimationStatus(3) == 2 && _gameSys->getAnimationStatus(4) == 2) { + _gameSys->insertSequence(0x96, 1, 0x96, 1, kSeqSyncWait, 0, 0, 0); + _gameSys->setAnimation(0x96, 1, 3); + _gameSys->insertSequence(0x99, 1, 0x99, 1, kSeqSyncWait, 0, 0, 0); + _gameSys->setAnimation(0x99, 1, 4); + } + + if (_gameSys->getAnimationStatus(5) == 2) { + switch (_toyUfoActionStatus) { + case 2: + _sceneDone = true; + break; + default: + _toyUfoNextSequenceId = toyUfoGetSequenceId(); + _gameSys->insertSequence(_toyUfoNextSequenceId | 0x10000, _toyUfoId + 1, + _toyUfoSequenceId | 0x10000, _toyUfoId, + kSeqSyncWait, 0, _toyUfoX - 274, _toyUfoY - 128); + _toyUfoSequenceId = _toyUfoNextSequenceId; + ++_toyUfoId; + _gameSys->setAnimation(_toyUfoNextSequenceId | 0x10000, _toyUfoId, 5); + break; + } + _toyUfoActionStatus = -1; + } + +} + +} // End of namespace Gnap diff --git a/engines/gnap/scenes/scene46.cpp b/engines/gnap/scenes/scene46.cpp new file mode 100644 index 0000000000..86855bbdf2 --- /dev/null +++ b/engines/gnap/scenes/scene46.cpp @@ -0,0 +1,378 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "gnap/gnap.h" +#include "gnap/gamesys.h" +#include "gnap/resource.h" + +namespace Gnap { + +enum { + kHSPlatypus = 0, + kHSExitUfoParty = 1, + kHSExitKissinBooth = 2, + kHSExitDisco = 3, + kHSSackGuy = 4, + kHSItchyGuy = 5, + kHSDevice = 6, + kHSWalkArea1 = 7 +}; + +enum { + kHSUfoExitLeft = 1, + kHSUfoExitRight = 2, + kHSUfoDevice = 3 +}; + +int GnapEngine::scene46_init() { + _gameSys->setAnimation(0, 0, 0); + _gameSys->setAnimation(0, 0, 1); + _gameSys->setAnimation(0, 0, 2); + _gameSys->setAnimation(0, 0, 3); + _gameSys->setAnimation(0, 0, 4); + return 0x4E; +} + +void GnapEngine::scene46_updateHotspots() { + if (isFlag(12)) { + setHotspot(kHSPlatypus, 0, 0, 0, 0, SF_DISABLED); + setHotspot(kHSUfoExitLeft, 0, 0, 10, 599, SF_EXIT_L_CURSOR); + setHotspot(kHSUfoExitRight, 790, 0, 799, 599, SF_EXIT_R_CURSOR); + setDeviceHotspot(kHSUfoDevice, -1, 534, -1, 599); + _hotspotsCount = 4; + } else { + setHotspot(kHSPlatypus, 0, 0, 0, 0, SF_WALKABLE | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(kHSExitUfoParty, 150, 580, 650, 600, SF_EXIT_D_CURSOR | SF_WALKABLE, 5, 9); + setHotspot(kHSExitKissinBooth, 0, 100, 10, 599, SF_EXIT_L_CURSOR, 0, 8); + setHotspot(kHSExitDisco, 790, 100, 799, 599, SF_EXIT_R_CURSOR, 10, 8); + setHotspot(kHSSackGuy, 180, 370, 235, 490, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR, 3, 8); + setHotspot(kHSItchyGuy, 535, 210, 650, 480, SF_PLAT_CURSOR | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR, 6, 8); + setHotspot(kHSWalkArea1, 0, 0, 800, 485); + setDeviceHotspot(kHSDevice, -1, -1, -1, -1); + _hotspotsCount = 8; + } +} + +void GnapEngine::scene46_run() { + + queueInsertDeviceIcon(); + + _gameSys->insertSequence(0x4D, 0, 0, 0, kSeqLoop, 0, 0, 0); + + _s46_dword_47EB18 = 0x4B; + _s46_dword_47EB20 = -1; + _gameSys->setAnimation(0x4B, 1, 3); + _gameSys->insertSequence(_s46_dword_47EB18, 1, 0, 0, kSeqNone, 0, 0, 0); + + _s46_dword_47EB24 = 0x47; + _s46_dword_47EB1C = -1; + _gameSys->setAnimation(0x47, 1, 4); + _gameSys->insertSequence(_s46_dword_47EB24, 1, 0, 0, kSeqNone, 0, 0, 0); + + if (isFlag(12)) { + _toyUfoId = 0; + _toyUfoActionStatus = -1; + _toyUfoSequenceId = toyUfoGetSequenceId(); + _toyUfoNextSequenceId = _toyUfoSequenceId; + if (_prevSceneNum == 44) + _toyUfoX = 30; + else + _toyUfoX = 770; + _gameSys->setAnimation(_toyUfoSequenceId | 0x10000, _toyUfoId, 2); + _gameSys->insertSequence(_toyUfoSequenceId | 0x10000, _toyUfoId, 0, 0, kSeqNone, 0, _toyUfoX - 274, _toyUfoY - 128); + endSceneInit(); + } else if (_prevSceneNum == 44) { + initGnapPos(-1, 8, 7); + initBeaverPos(-1, 8, 5); + endSceneInit(); + platypusWalkTo(1, 8, -1, 0x107C2, 1); + gnapWalkTo(2, 8, -1, 0x107B9, 1); + } else if (_prevSceneNum == 45) { + initGnapPos(11, 8, 7); + initBeaverPos(12, 8, 5); + endSceneInit(); + gnapWalkTo(8, 8, -1, 0x107BA, 1); + platypusWalkTo(9, 8, -1, 0x107D2, 1); + } else { + initGnapPos(5, 11, 7); + initBeaverPos(6, 11, 5); + endSceneInit(); + platypusWalkTo(5, 8, -1, 0x107C2, 1); + gnapWalkTo(6, 8, -1, 0x107BA, 1); + } + + _timers[4] = getRandom(50) + 80; + _timers[5] = getRandom(50) + 80; + + while (!_sceneDone) { + + if (!isSoundPlaying(0x1094B)) + playSound(0x1094B, 1); + + updateMouseCursor(); + updateCursorByHotspot(); + + testWalk(0, 0, -1, -1, -1, -1); + + _sceneClickedHotspot = getClickedHotspotId(); + updateGrabCursorSprite(0, 0); + + if (isFlag(12)) { + + switch (_sceneClickedHotspot) { + + case kHSUfoExitLeft: + if (_toyUfoActionStatus < 0) { + _isLeavingScene = 1; + _toyUfoActionStatus = 3; + _newSceneNum = 44; + toyUfoFlyTo(-35, -1, -35, 799, 0, 300, 2); + } + break; + + case kHSUfoExitRight: + if (_toyUfoActionStatus < 0) { + _isLeavingScene = 1; + _toyUfoActionStatus = 3; + _newSceneNum = 45; + toyUfoFlyTo(835, -1, 0, 835, 0, 300, 2); + } + break; + + case kHSUfoDevice: + runMenu(); + scene46_updateHotspots(); + break; + } + + } else { + + switch (_sceneClickedHotspot) { + + case kHSDevice: + runMenu(); + scene46_updateHotspots(); + break; + + case kHSPlatypus: + if (_gnapActionStatus < 0) { + if (_grabCursorSpriteIndex >= 0) { + playGnapImpossible(_platX, _platY); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapMoan1(_platX, _platY); + break; + case GRAB_CURSOR: + gnapKissPlatypus(0); + break; + case TALK_CURSOR: + playGnapBrainPulsating(_platX, _platY); + playBeaverSequence(getBeaverSequenceId(0, 0, 0) | 0x10000); + break; + case PLAT_CURSOR: + playGnapImpossible(_platX, _platY); + break; + } + } + } + break; + + case kHSSackGuy: + if (_grabCursorSpriteIndex >= 0) { + playGnapShowCurrItem(_hotspotsWalkPos[kHSSackGuy].x, _hotspotsWalkPos[kHSSackGuy].y, 2, 0); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapMoan1(_hotspotsWalkPos[kHSSackGuy].x + 1, 0); + break; + case TALK_CURSOR: + _gnapIdleFacing = 5; + gnapWalkTo(_hotspotsWalkPos[kHSSackGuy].x, _hotspotsWalkPos[kHSSackGuy].y, 0, getGnapSequenceId(gskBrainPulsating, 0, 0) | 0x10000, 1); + _gnapActionStatus = 2; + break; + case GRAB_CURSOR: + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + break; + + case kHSItchyGuy: + if (_grabCursorSpriteIndex >= 0) { + playGnapShowCurrItem(_hotspotsWalkPos[kHSItchyGuy].x, _hotspotsWalkPos[kHSItchyGuy].y, 7, 0); + } else { + switch (_verbCursor) { + case LOOK_CURSOR: + playGnapMoan1(_hotspotsWalkPos[kHSItchyGuy].x - 1, 0); + break; + case TALK_CURSOR: + _gnapIdleFacing = 7; + gnapWalkTo(_hotspotsWalkPos[kHSItchyGuy].x, _hotspotsWalkPos[kHSItchyGuy].y, 0, getGnapSequenceId(gskBrainPulsating, 0, 0) | 0x10000, 1); + _gnapActionStatus = 1; + break; + case GRAB_CURSOR: + case PLAT_CURSOR: + playGnapImpossible(0, 0); + break; + } + } + break; + + case kHSExitUfoParty: + _isLeavingScene = 1; + gnapWalkTo(_gnapX, _hotspotsWalkPos[kHSExitUfoParty].y, 0, 0x107AE, 1); + _gnapActionStatus = 0; + _newSceneNum = 40; + break; + + case kHSExitKissinBooth: + _isLeavingScene = 1; + gnapWalkTo(_hotspotsWalkPos[kHSExitKissinBooth].x, _gnapY, 0, 0x107AF, 1); + _gnapActionStatus = 0; + platypusWalkTo(_hotspotsWalkPos[kHSExitKissinBooth].x, _platY, -1, 0x107CF, 1); + _newSceneNum = 44; + break; + + case kHSExitDisco: + _isLeavingScene = 1; + gnapWalkTo(_hotspotsWalkPos[kHSExitDisco].x, _gnapY, 0, 0x107AB, 1); + _gnapActionStatus = 0; + platypusWalkTo(_hotspotsWalkPos[kHSExitDisco].x, _platY, -1, 0x107CD, 1); + _newSceneNum = 45; + break; + + case kHSWalkArea1: + if (_gnapActionStatus < 0) + gnapWalkTo(-1, -1, -1, -1, 1); + break; + + } + + } + + if (_mouseClickState.left && _gnapActionStatus < 0) { + _mouseClickState.left = false; + if (isFlag(12)) { + _toyUfoActionStatus = 4; + toyUfoFlyTo(-1, -1, 0, 799, 0, 300, 2); + } else { + gnapWalkTo(-1, -1, -1, -1, 1); + } + } + + scene46_updateAnimations(); + + toyUfoCheckTimer(); + + if (!_isLeavingScene) { + if (_beaverActionStatus < 0 && !isFlag(12)) + updateBeaverIdleSequence(); + if (_gnapActionStatus < 0 && !isFlag(12)) + updateGnapIdleSequence(); + if (!_timers[4]) { + _timers[4] = getRandom(50) + 80; + if (_gnapActionStatus < 0 && _beaverActionStatus < 0 && _s46_dword_47EB1C == -1) { + _gnapRandomValue = getRandom(2); + if (_gnapRandomValue != 0) + _s46_dword_47EB1C = 0x49; + else + _s46_dword_47EB1C = 0x48; + } + } + if (!_timers[5]) { + _timers[5] = getRandom(50) + 80; + if (_gnapActionStatus < 0 && _beaverActionStatus < 0 && _s46_dword_47EB20 == -1) + _s46_dword_47EB20 = 0x4C; + } + } + + checkGameKeys(); + + if (isKeyStatus1(8)) { + clearKeyStatus1(8); + runMenu(); + scene46_updateHotspots(); + } + + gameUpdateTick(); + + } + +} + +void GnapEngine::scene46_updateAnimations() { + + if (_gameSys->getAnimationStatus(0) == 2) { + _gameSys->setAnimation(0, 0, 0); + switch (_gnapActionStatus) { + case 0: + _sceneDone = true; + break; + case 1: + _s46_dword_47EB1C = 0x46; + break; + case 2: + _s46_dword_47EB20 = 0x4A; + break; + } + _gnapActionStatus = -1; + } + + if (_gameSys->getAnimationStatus(3) == 2 && _s46_dword_47EB20 != -1) { + _gameSys->insertSequence(_s46_dword_47EB20, 1, _s46_dword_47EB18, 1, kSeqSyncWait, 0, 0, 0); + _gameSys->setAnimation(_s46_dword_47EB20, 1, 3); + _s46_dword_47EB18 = _s46_dword_47EB20; + _s46_dword_47EB20 = -1; + _timers[5] = getRandom(50) + 80; + } + + if (_gameSys->getAnimationStatus(4) == 2 && _s46_dword_47EB1C != -1) { + _gameSys->insertSequence(_s46_dword_47EB1C, 1, _s46_dword_47EB24, 1, kSeqSyncWait, 0, 0, 0); + _gameSys->setAnimation(_s46_dword_47EB1C, 1, 4); + _s46_dword_47EB24 = _s46_dword_47EB1C; + _s46_dword_47EB1C = -1; + _timers[4] = getRandom(50) + 80; + } + + if (_gameSys->getAnimationStatus(2) == 2) { + switch (_toyUfoActionStatus) { + case 3: + _sceneDone = true; + break; + default: + _toyUfoNextSequenceId = toyUfoGetSequenceId(); + _gameSys->insertSequence(_toyUfoNextSequenceId | 0x10000, _toyUfoId + 1, + _toyUfoSequenceId | 0x10000, _toyUfoId, + kSeqSyncWait, 0, _toyUfoX - 274, _toyUfoY - 128); + _toyUfoSequenceId = _toyUfoNextSequenceId; + ++_toyUfoId; + _gameSys->setAnimation(_toyUfoNextSequenceId | 0x10000, _toyUfoId, 2); + break; + } + _toyUfoActionStatus = -1; + } + +} + +} // End of namespace Gnap diff --git a/engines/gnap/scenes/scene47.cpp b/engines/gnap/scenes/scene47.cpp new file mode 100644 index 0000000000..2e735e3650 --- /dev/null +++ b/engines/gnap/scenes/scene47.cpp @@ -0,0 +1,171 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "gnap/gnap.h" +#include "gnap/gamesys.h" +#include "gnap/resource.h" + +namespace Gnap { + +void GnapEngine::scene47_initCutscene1() { + _s99_dword_47F370[0] = 0x301; + _s99_dword_47F370[1] = 0x305; + _s99_dword_47F370[2] = 0x302; + _s99_dword_47F370[3] = 0x304; + _s99_dword_47F370[4] = 0x300; + _s99_dword_47F2F0[0] = 3; + _s99_dword_47F2F0[1] = 0; + _s99_dword_47F2F0[2] = 1; + _s99_dword_47F2F0[3] = 0; + _s99_dword_47F2F0[4] = 2; + _s99_dword_47F330[0] = 1; + _s99_dword_47F330[1] = 1; + _s99_dword_47F330[2] = 1; + _s99_dword_47F330[3] = 1; + _s99_dword_47F330[4] = 1; + _s99_canSkip[0] = 0; + _s99_canSkip[1] = 0; + _s99_canSkip[2] = 0; + _s99_canSkip[3] = 0; + _s99_canSkip[4] = 0; + _s99_itemsCount = 5; +} + +void GnapEngine::scene47_initCutscene2() { + _s99_dword_47F370[0] = 0x306; + _s99_dword_47F370[1] = 0x309; + _s99_dword_47F370[2] = 0x307; + _s99_dword_47F370[3] = 0x308; + _s99_dword_47F370[4] = 0x30A; + _s99_dword_47F2F0[0] = 0x8E; + _s99_dword_47F2F0[1] = 0x90; + _s99_dword_47F2F0[2] = 0x8F; + _s99_dword_47F2F0[3] = 0x91; + _s99_dword_47F330[0] = 2; + _s99_dword_47F330[1] = 1; + _s99_dword_47F330[2] = 1; + _s99_dword_47F330[3] = 1; + _s99_canSkip[0] = 0; + _s99_canSkip[1] = 0; + _s99_canSkip[2] = 0; + _s99_canSkip[3] = 0; + _s99_itemsCount = 4; +} + +void GnapEngine::scene47_initCutscene3() { + _s99_dword_47F370[0] = 0x320; + _s99_dword_47F370[1] = 0x321; + _s99_dword_47F2F0[0] = 0x142; + _s99_dword_47F2F0[1] = 0x143; + _s99_dword_47F330[0] = 1; + _s99_dword_47F330[1] = 1; + _s99_canSkip[0] = 0; + _s99_canSkip[1] = 0; + _s99_itemsCount = 2; +} + +void GnapEngine::scene47_initCutscene4() { + _s99_dword_47F370[0] = 0x30C; + _s99_dword_47F370[1] = 0x30D; + _s99_dword_47F370[2] = 0x30B; + _s99_dword_47F2F0[0] = 0x142; + _s99_dword_47F2F0[1] = 0x141; + _s99_dword_47F2F0[2] = 0x177; + _s99_dword_47F330[0] = 1; + _s99_dword_47F330[1] = 1; + _s99_dword_47F330[2] = 1; + _s99_canSkip[0] = 0; + _s99_canSkip[1] = 0; + _s99_canSkip[2] = 0; + _s99_itemsCount = 3; +} + +void GnapEngine::scene47_initCutscene5() { + _s99_dword_47F370[0] = 0x30E; + _s99_dword_47F370[1] = 0x30F; + _s99_dword_47F370[2] = 0x310; + _s99_dword_47F370[3] = 0x311; + _s99_dword_47F2F0[0] = 0x206; + _s99_dword_47F2F0[1] = 0x207; + _s99_dword_47F330[0] = 3; + _s99_dword_47F330[1] = 1; + _s99_canSkip[0] = 0; + _s99_canSkip[1] = 0; + _s99_itemsCount = 2; +} + +void GnapEngine::scene47_initCutscene6() { + _s99_dword_47F370[0] = 0x31E; + _s99_dword_47F370[1] = 0x31F; + _s99_dword_47F2F0[0] = 0x2FA; + _s99_dword_47F330[0] = 2; + _s99_canSkip[0] = 0; + _s99_itemsCount = 1; +} + +void GnapEngine::scene47_initCutscene7() { + int v1 = 4, v0, v4, v2, v3; + + _s99_dword_47F370[0] = 0x316; + _s99_dword_47F370[1] = 0x31A; + _s99_dword_47F370[2] = 0x314; + _s99_dword_47F370[3] = 0x31B; + v1 = 4; + if (!isFlag(3)) { + _s99_dword_47F370[4] = 0x31C; + v1 = 5; + } + if (!isFlag(26)) + _s99_dword_47F370[v1++] = 0x31D; + v4 = v1; + _s99_dword_47F370[v1] = 0x319; + v0 = v1 + 1; + v3 = v0; + _s99_dword_47F370[v0++] = 0x317; + _s99_dword_47F370[v0++] = 0x312; + _s99_dword_47F370[v0] = 0x31A; + v2 = v0 + 1; + if (!isFlag(3)) + _s99_dword_47F370[v2++] = 0x31C; + if (!isFlag(26)) + _s99_dword_47F370[v2++] = 0x31D; + _s99_dword_47F370[v2] = 0x313; + _s99_dword_47F370[v2 + 1] = 0x315; + _s99_dword_47F2F0[0] = 0x2B8; + _s99_dword_47F2F0[1] = 0x20C; + _s99_dword_47F2F0[2] = 0x2B8; + _s99_dword_47F2F0[3] = 0x20B; + _s99_dword_47F2F0[4] = 0x20B; + _s99_dword_47F330[0] = v4; + _s99_dword_47F330[1] = 1; + _s99_dword_47F330[2] = v2 - v3; + _s99_dword_47F330[3] = 1; + _s99_dword_47F330[4] = 1; + _s99_canSkip[0] = 0; + _s99_canSkip[1] = 0; + _s99_canSkip[2] = 0; + _s99_canSkip[3] = 0; + _s99_canSkip[4] = 0; + _s99_itemsCount = 5; +} + +} // End of namespace Gnap diff --git a/engines/gnap/scenes/scene48.cpp b/engines/gnap/scenes/scene48.cpp new file mode 100644 index 0000000000..3b24d57a8c --- /dev/null +++ b/engines/gnap/scenes/scene48.cpp @@ -0,0 +1,85 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "gnap/gnap.h" +#include "gnap/gamesys.h" +#include "gnap/resource.h" + +namespace Gnap { + +void GnapEngine::scene48_initCutscene() { + _s99_dword_47F370[0] = 390; + _s99_dword_47F370[1] = 391; + _s99_dword_47F370[2] = 392; + _s99_dword_47F370[3] = 393; + _s99_dword_47F370[4] = 394; + _s99_dword_47F370[5] = 395; + _s99_dword_47F370[6] = 396; + _s99_dword_47F370[7] = 397; + _s99_dword_47F370[8] = 398; + _s99_dword_47F370[9] = 399; + _s99_dword_47F370[10] = 400; + _s99_dword_47F370[11] = 401; + _s99_dword_47F370[12] = 402; + _s99_dword_47F2F0[0] = 238; + _s99_dword_47F2F0[1] = 42; + _s99_dword_47F2F0[2] = 2; + _s99_dword_47F2F0[3] = 37; + _s99_dword_47F2F0[4] = 35; + _s99_dword_47F2F0[5] = 38; + _s99_dword_47F2F0[6] = 39; + _s99_dword_47F2F0[7] = 40; + _s99_dword_47F2F0[8] = 41; + _s99_dword_47F2F0[9] = 36; + _s99_dword_47F2F0[10] = 41; + _s99_dword_47F2F0[11] = 388; + _s99_dword_47F2F0[12] = 387; + _s99_dword_47F330[0] = 1; + _s99_dword_47F330[1] = 1; + _s99_dword_47F330[2] = 1; + _s99_dword_47F330[3] = 1; + _s99_dword_47F330[4] = 1; + _s99_dword_47F330[5] = 1; + _s99_dword_47F330[6] = 1; + _s99_dword_47F330[7] = 1; + _s99_dword_47F330[8] = 1; + _s99_dword_47F330[9] = 1; + _s99_dword_47F330[10] = 1; + _s99_dword_47F330[11] = 1; + _s99_dword_47F330[12] = 1; + _s99_canSkip[0] = 0; + _s99_canSkip[1] = 0; + _s99_canSkip[2] = 0; + _s99_canSkip[3] = 0; + _s99_canSkip[4] = 0; + _s99_canSkip[5] = 0; + _s99_canSkip[6] = 0; + _s99_canSkip[7] = 0; + _s99_canSkip[8] = 0; + _s99_canSkip[9] = 0; + _s99_canSkip[10] = 0; + _s99_canSkip[11] = 0; + _s99_canSkip[12] = 0; + _s99_itemsCount = 13; +} + +} // End of namespace Gnap diff --git a/engines/gnap/scenes/scene49.cpp b/engines/gnap/scenes/scene49.cpp new file mode 100644 index 0000000000..e8415bbc9f --- /dev/null +++ b/engines/gnap/scenes/scene49.cpp @@ -0,0 +1,513 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "gnap/gnap.h" +#include "gnap/gamesys.h" +#include "gnap/resource.h" + +namespace Gnap { + +struct ObstacleDef { + int sequenceId, ticks; +}; + +static const ObstacleDef kObstacleDefs[] = { + {0xB4, 15}, {0xCB, 14}, {0xCD, 13}, {0xCF, 15}, {0xBA, 14}, + {0xCD, 13}, {0xCF, 12}, {0xCB, 15}, {0xBD, 13}, {0xCF, 12}, + {0xCD, 11}, {0xCB, 15}, {0xB7, 12}, {0xCD, 11}, {0xCB, 10}, + {0xCF, 15}, {0xCF, 14}, {0xBD, 13}, {0xCF, 12}, {0xCD, 11}, + {0xCB, 15}, {0xCB, 13}, {0xB4, 12}, {0xCB, 11}, {0xCD, 10}, + {0xCF, 15}, {0xCD, 12}, {0xBA, 12}, {0xCD, 12}, {0xCF, 12}, + {0xCB, 15}, {0xCB, 9}, {0xCD, 9}, {0xCF, 9}, {0xCD, 9}, + {0xCB, 9}, {0xCD, 9}, {0xCF, 5}, {0xBD, 13}, {0xCF, 8}, + {0xCB, 8}, {0xCD, 15}, {0xB4, 1}, {0xBD, 7}, {0xCF, 7}, + {0xCD, 7}, {0xCB, 7}, {0xCD, 7}, {0xCF, 15}, {0xCF, 15} +}; + +int GnapEngine::scene49_init() { + _gameSys->setAnimation(0, 0, 0); + _gameSys->setAnimation(0, 0, 1); + for (int i = 0; i < 5; ++i) + _gameSys->setAnimation(0, 0, i + 2); + _timers[2] = 0; + _timers[0] = 0; + _timers[1] = 0; + clearKeyStatus1(28); + clearKeyStatus1(54); + clearKeyStatus1(52); + return 0xD5; +} + +void GnapEngine::scene49_updateHotspots() { + _hotspotsCount = 0; +} + +void GnapEngine::scene49_checkObstacles() { + + if (_timers[2] == 0) { + + if (_timers[3] == 0) + for (int i = 0; i < 5; ++i) + scene49_clearObstacle(i); + + for (int j = 0; j < 5; ++j) { + if (_s49_obstacles[j].currSequenceId == 0) { + _timers[3] = 35; + _s49_obstacles[j].currSequenceId = kObstacleDefs[_s49_obstacleIndex].sequenceId; + switch (_s49_obstacles[j].currSequenceId) { + case 0xB4: + _s49_obstacles[j].laneNum = 1; + _s49_obstacles[j].closerSequenceId = 180; + _s49_obstacles[j].passedSequenceId = 181; + _s49_obstacles[j].splashSequenceId = 182; + _s49_obstacles[j].collisionSequenceId = 192; + break; + case 0xB7: + _s49_obstacles[j].laneNum = 2; + _s49_obstacles[j].closerSequenceId = 183; + _s49_obstacles[j].passedSequenceId = 184; + _s49_obstacles[j].splashSequenceId = 185; + _s49_obstacles[j].collisionSequenceId = 193; + break; + case 0xBD: + _s49_obstacles[j].laneNum = 3; + _s49_obstacles[j].closerSequenceId = 189; + _s49_obstacles[j].passedSequenceId = 190; + _s49_obstacles[j].splashSequenceId = 191; + _s49_obstacles[j].collisionSequenceId = 195; + break; + case 0xBA: + _s49_obstacles[j].laneNum = 2; + _s49_obstacles[j].closerSequenceId = 186; + _s49_obstacles[j].passedSequenceId = 187; + _s49_obstacles[j].splashSequenceId = 188; + _s49_obstacles[j].collisionSequenceId = 194; + break; + case 0xCB: + _s49_obstacles[j].laneNum = 1; + _s49_obstacles[j].closerSequenceId = 203; + _s49_obstacles[j].passedSequenceId = 204; + _s49_obstacles[j].splashSequenceId = 0; + _s49_obstacles[j].collisionSequenceId = 209; + break; + case 0xCD: + _s49_obstacles[j].laneNum = 2; + _s49_obstacles[j].closerSequenceId = 205; + _s49_obstacles[j].passedSequenceId = 206; + _s49_obstacles[j].splashSequenceId = 0; + _s49_obstacles[j].collisionSequenceId = 210; + break; + case 0xCF: + _s49_obstacles[j].laneNum = 3; + _s49_obstacles[j].closerSequenceId = 207; + _s49_obstacles[j].passedSequenceId = 208; + _s49_obstacles[j].splashSequenceId = 0; + _s49_obstacles[j].collisionSequenceId = 211; + break; + } + _s49_obstacles[j].prevId = _s49_truckId; + _s49_obstacles[j].currId = _s49_obstacles[j].prevId; + _gameSys->setAnimation(_s49_obstacles[j].currSequenceId, _s49_obstacles[j].currId, j + 2); + _gameSys->insertSequence(_s49_obstacles[j].currSequenceId, _s49_obstacles[j].currId, 0, 0, kSeqNone, 0, 0, -50); + _timers[2] = kObstacleDefs[_s49_obstacleIndex].ticks; + ++_s49_obstacleIndex; + if (_s49_obstacleIndex == 50) + _s49_obstacleIndex = 0; + break; + } + } + + } + +} + +void GnapEngine::scene49_updateObstacle(int i) { + + Scene49Obstacle &obstacle = _s49_obstacles[i]; + + obstacle.currId = obstacle.prevId; + + switch (obstacle.laneNum) { + case 1: + obstacle.prevId = _s49_truckId + 1; + break; + case 2: + if (_s49_truckLaneNum != 2 && _s49_truckLaneNum != 3) + obstacle.prevId = _s49_truckId - 1; + else + obstacle.prevId = _s49_truckId + 1; + break; + case 3: + if (_s49_truckLaneNum != 1 && _s49_truckLaneNum != 2) + obstacle.prevId = _s49_truckId; + else + obstacle.prevId = _s49_truckId - 1; + break; + } + + if (obstacle.currSequenceId == obstacle.closerSequenceId) { + if (_s49_truckLaneNum == obstacle.laneNum) { + if (obstacle.splashSequenceId) { + _gameSys->setAnimation(obstacle.collisionSequenceId, obstacle.prevId, i + 2); + _gameSys->insertSequence(obstacle.collisionSequenceId, obstacle.prevId, + obstacle.currSequenceId, obstacle.currId, + kSeqSyncWait, 0, 0, -50); + obstacle.currSequenceId = obstacle.collisionSequenceId; + playSound(224, 0); + scene49_increaseScore(30); + } else if ((obstacle.laneNum == 1 && _s49_truckSequenceId == 0xB0) || + (obstacle.laneNum == 2 && (_s49_truckSequenceId == 0xB1 || _s49_truckSequenceId == 0xB2)) || + (obstacle.laneNum == 3 && _s49_truckSequenceId == 0xB3)) { + _gameSys->setAnimation(obstacle.passedSequenceId, obstacle.prevId, i + 2); + _gameSys->insertSequence(obstacle.passedSequenceId, obstacle.prevId, + obstacle.currSequenceId, obstacle.currId, + kSeqSyncWait, 0, 0, -50); + obstacle.currSequenceId = obstacle.passedSequenceId; + } else { + _gameSys->setAnimation(obstacle.collisionSequenceId, 256, 0); + _gameSys->setAnimation(obstacle.passedSequenceId, obstacle.prevId, i + 2); + _gameSys->insertSequence(obstacle.passedSequenceId, obstacle.prevId, + obstacle.currSequenceId, obstacle.currId, + kSeqSyncWait, 0, 0, -50); + _gameSys->insertSequence(obstacle.collisionSequenceId, 256, + _s49_truckSequenceId, _s49_truckId, + 32, 0, 0, -50); + _s49_truckSequenceId = obstacle.collisionSequenceId; + _s49_truckId = 256; + obstacle.currSequenceId = obstacle.passedSequenceId; + playSound(225, 0); + scene49_decreaseScore(30); + } + } else { + _gameSys->setAnimation(obstacle.passedSequenceId, obstacle.prevId, i + 2); + _gameSys->insertSequence(obstacle.passedSequenceId, obstacle.prevId, + obstacle.currSequenceId, obstacle.currId, + kSeqSyncWait, 0, 0, -50); + obstacle.currSequenceId = obstacle.passedSequenceId; + } + } else if (obstacle.currSequenceId == obstacle.passedSequenceId) { + if (_s49_truckLaneNum == obstacle.laneNum) { + if (obstacle.splashSequenceId) { + _gameSys->setAnimation(obstacle.collisionSequenceId, obstacle.prevId, i + 2); + _gameSys->insertSequence(obstacle.collisionSequenceId, obstacle.prevId, + obstacle.currSequenceId, obstacle.currId, + kSeqSyncWait, 0, 0, -50); + obstacle.currSequenceId = obstacle.collisionSequenceId; + playSound(224, 0); + scene49_increaseScore(30); + } + } else if (obstacle.splashSequenceId) { + _gameSys->setAnimation(obstacle.splashSequenceId, obstacle.prevId, i + 2); + _gameSys->insertSequence(obstacle.splashSequenceId, obstacle.prevId, + obstacle.currSequenceId, obstacle.currId, + kSeqSyncWait, 0, 0, -50); + obstacle.currSequenceId = obstacle.splashSequenceId; + } + } else { + _gameSys->setAnimation(0, 0, i + 2); + scene49_clearObstacle(i); + } + +} + +void GnapEngine::scene49_increaseScore(int amount) { + if (_s49_scoreBarPos + amount <= 556) { + _s49_scoreBarPos += amount; + _gameSys->fillSurface(0, _s49_scoreBarPos, 508, amount, 22, 255, 0, 0); + } + _s49_scoreLevel = _s49_scoreBarPos + amount >= 556; +} + +void GnapEngine::scene49_decreaseScore(int amount) { + if (_s49_scoreBarPos >= 226 && _s49_scoreLevel == 0) { + if (_s49_scoreBarFlash) + scene49_refreshScoreBar(); + _gameSys->fillSurface(0, _s49_scoreBarPos, 508, amount, 22, 89, 0, 5); + _s49_scoreBarPos -= amount; + _s49_scoreLevel = 0; + } +} + +void GnapEngine::scene49_refreshScoreBar() { + if (_s49_scoreBarFlash) + _gameSys->fillSurface(0, 226, 508, 330, 22, 255, 0, 0); + else + _gameSys->fillSurface(0, 226, 508, 330, 22, 89, 0, 5); + _s49_scoreBarFlash = !_s49_scoreBarFlash; +} + +void GnapEngine::scene49_clearObstacle(int index) { + _s49_obstacles[index].currSequenceId = 0; + _s49_obstacles[index].closerSequenceId = 0; + _s49_obstacles[index].passedSequenceId = 0; + _s49_obstacles[index].splashSequenceId = 0; + _s49_obstacles[index].collisionSequenceId = 0; + _s49_obstacles[index].prevId = 0; + _s49_obstacles[index].currId = 0; + _s49_obstacles[index].laneNum = 0; +} + +void GnapEngine::scene49_run() { + + bool animToggle6 = false; + bool animToggle5 = false; + bool animToggle4 = false; + bool animToggle3 = false; + bool streetAnimToggle = false; + bool bgAnimToggle = false; + + playSound(0xE2, 1); + setSoundVolume(0xE2, 75); + + hideCursor(); + setGrabCursorSprite(-1); + + _s49_scoreBarPos = 196; + _s49_scoreLevel = 0; + _s49_scoreBarFlash = false; + + switch (getRandom(3)) { + case 0: + _s49_truckSequenceId = 0xAD; + _s49_truckLaneNum = 1; + break; + case 1: + _s49_truckSequenceId = 0xAE; + _s49_truckLaneNum = 2; + break; + case 2: + _s49_truckSequenceId = 0xAF; + _s49_truckLaneNum = 3; + break; + } + + int bgWidth1 = _gameSys->getSpriteWidthById(0x5E); + int bgX1 = 600; + + int bgWidth2 = _gameSys->getSpriteWidthById(0x5F); + int bgX2 = 400; + + int bgWidth3 = _gameSys->getSpriteWidthById(4); + int bgX3 = 700; + + int bgWidth4 = _gameSys->getSpriteWidthById(5); + int bgX4 = 500; + + int bgWidth5 = _gameSys->getSpriteWidthById(6); + int bgX5 = 300; + + int bgWidth6 = _gameSys->getSpriteWidthById(7); + int bgX6 = 100; + + _gameSys->setAnimation(0xC8, 251, 1); + _gameSys->setAnimation(_s49_truckSequenceId, 256, 0); + _gameSys->insertSequence(0xC9, 256, 0, 0, kSeqNone, 0, 600, 85); + _gameSys->insertSequence(0xCA, 257, 0, 0, kSeqNone, 0, 400, 100); + _gameSys->insertSequence(0xC4, 256, 0, 0, kSeqNone, 0, 700, 140); + _gameSys->insertSequence(0xC5, 257, 0, 0, kSeqNone, 0, 500, 160); + _gameSys->insertSequence(0xC6, 258, 0, 0, kSeqNone, 0, 300, 140); + _gameSys->insertSequence(0xC7, 259, 0, 0, kSeqNone, 0, 100, 140); + _gameSys->insertSequence(0xC8, 251, 0, 0, kSeqNone, 0, 0, -50); + _gameSys->insertSequence(_s49_truckSequenceId, 256, 0, 0, kSeqNone, 0, 0, -50); + + _timers[0] = 2; + + for (int i = 0; i < 5; ++i) + scene49_clearObstacle(i); + + _s49_obstacleIndex = 0; + + _timers[2] = getRandom(20) + 10; + + _s49_truckId = 256; + _timers[3] = 35; + + while (!_sceneDone) { + + if (_timers[0] == 0) { + // Update background animations (clouds etc.) + --bgX1; + bgX2 -= 2; + bgX3 -= 5; + --bgX4; + --bgX5; + --bgX6; + if (bgX1 <= -bgWidth1) + bgX1 = 799; + if (bgX2 <= -bgWidth2) + bgX2 = 799; + if (bgX3 <= -bgWidth3) + bgX3 = 799; + if (bgX4 <= -bgWidth4) + bgX4 = 799; + if (bgX5 <= -bgWidth5) + bgX5 = 799; + if (bgX6 <= -bgWidth6) + bgX6 = 799; + bgAnimToggle = !bgAnimToggle; + _gameSys->insertSequence(0xC9, (bgAnimToggle ? 1 : 0) + 256, 0xC9, (bgAnimToggle ? 0 : 1) + 256, kSeqSyncWait, 0, bgX1, 85); + _gameSys->insertSequence(0xCA, (bgAnimToggle ? 1 : 0) + 257, 0xCA, (bgAnimToggle ? 0 : 1) + 257, kSeqSyncWait, 0, bgX2, 100); + _gameSys->insertSequence(0xC4, (bgAnimToggle ? 1 : 0) + 256, 0xC4, (bgAnimToggle ? 0 : 1) + 256, kSeqSyncWait, 0, bgX3, 140); + _gameSys->insertSequence(0xC5, (bgAnimToggle ? 1 : 0) + 257, 0xC5, (bgAnimToggle ? 0 : 1) + 257, kSeqSyncWait, 0, bgX4, 160); + _gameSys->insertSequence(0xC6, (bgAnimToggle ? 1 : 0) + 258, 0xC6, (bgAnimToggle ? 0 : 1) + 258, kSeqSyncWait, 0, bgX5, 140); + _gameSys->insertSequence(0xC7, (bgAnimToggle ? 1 : 0) + 259, 0xC7, (bgAnimToggle ? 0 : 1) + 259, kSeqSyncWait, 0, bgX6, 140); + _timers[0] = 2; + } + + if (_gameSys->getAnimationStatus(1) == 2) { + streetAnimToggle = !streetAnimToggle; + _gameSys->setAnimation(0xC8, (streetAnimToggle ? 1 : 0) + 251, 1); + _gameSys->insertSequence(0xC8, (streetAnimToggle ? 1 : 0) + 251, 200, (streetAnimToggle ? 0 : 1) + 251, kSeqSyncWait, 0, 0, -50); + } + + scene49_checkObstacles(); + + if (_gameSys->getAnimationStatus(0) == 2) { + switch (_s49_truckSequenceId) { + case 0xB1: + _s49_truckLaneNum = 1; + break; + case 0xB0: + case 0xB3: + _s49_truckLaneNum = 2; + break; + case 0xB2: + _s49_truckLaneNum = 3; + break; + } + animToggle3 = !animToggle3; + if (_s49_truckLaneNum == 1) { + _gameSys->setAnimation(0xAD, (animToggle3 ? 1 : 0) + 256, 0); + _gameSys->insertSequence(0xAD, (animToggle3 ? 1 : 0) + 256, _s49_truckSequenceId, _s49_truckId, kSeqSyncWait, 0, 0, -50); + _s49_truckSequenceId = 0xAD; + } else if (_s49_truckLaneNum == 2) { + _gameSys->setAnimation(0xAE, (animToggle3 ? 1 : 0) + 256, 0); + _gameSys->insertSequence(0xAE, (animToggle3 ? 1 : 0) + 256, _s49_truckSequenceId, _s49_truckId, kSeqSyncWait, 0, 0, -50); + _s49_truckSequenceId = 0xAE; + } else { + _gameSys->setAnimation(0xAF, (animToggle3 ? 1 : 0) + 256, 0); + _gameSys->insertSequence(0xAF, (animToggle3 ? 1 : 0) + 256, _s49_truckSequenceId, _s49_truckId, kSeqSyncWait, 0, 0, -50); + _s49_truckSequenceId = 0xAF; + } + _s49_truckId = (animToggle3 ? 1 : 0) + 256; + if (_s49_scoreLevel == 1) { + if (!_gameSys->isSequenceActive(0xD4, 266)) { + _gameSys->setAnimation(0xD4, 266, 8); + _gameSys->insertSequence(0xD4, 266, 0, 0, kSeqNone, 0, 0, -50); + } + ++_s49_scoreLevel; + _timers[1] = 2; + animToggle4 = false; + animToggle5 = false; + animToggle6 = false; + _s49_scoreBarFlash = false; + } + } + + if (_s49_scoreLevel != 0 && !_timers[1]) { + scene49_refreshScoreBar(); + _timers[1] = 8; + if (animToggle6) { + if (animToggle5) { + if (animToggle4 && !_gameSys->isSequenceActive(212, 266)) + _gameSys->insertSequence(212, 266, 0, 0, kSeqNone, 0, 0, -50); + animToggle4 = !animToggle4; + } + animToggle5 = !animToggle5; + } + animToggle6 = !animToggle6; + } + + scene49_updateAnimations(); + + if (sceneXX_sub_4466B1()) { + _sceneDone = true; + _newSceneNum = 2; + _newCursorValue = 1; + } + + if (isKeyStatus1(Common::KEYCODE_RIGHT)) { + // Steer right + if (_s49_truckSequenceId == 0xB3) + _s49_truckLaneNum = 2; + if (_s49_truckSequenceId == 0xB1) + _s49_truckLaneNum = 1; + if (_s49_truckLaneNum != 3 && _s49_truckLaneNum != 2) { + if (_s49_scoreLevel) { + _sceneDone = true; + _newSceneNum = 47; + } + } else { + int steerSequenceId = (_s49_truckLaneNum == 3) ? 0xB3 : 0xB1; + if (_s49_truckSequenceId == 0xAE || _s49_truckSequenceId == 0xAF) { + _gameSys->setAnimation(steerSequenceId, 256, 0); + _gameSys->insertSequence(steerSequenceId, 256, _s49_truckSequenceId, _s49_truckId, 32, 0, 0, -50); + _s49_truckSequenceId = steerSequenceId; + _s49_truckId = 256; + } + } + clearKeyStatus1(Common::KEYCODE_RIGHT); + } + + if (isKeyStatus1(Common::KEYCODE_LEFT)) { + // Steer left + if (_s49_truckSequenceId == 0xB0) + _s49_truckLaneNum = 2; + if (_s49_truckSequenceId == 0xB2) + _s49_truckLaneNum = 3; + if (_s49_truckLaneNum == 1 || _s49_truckLaneNum == 2) { + int steerSequenceId = (_s49_truckLaneNum == 1) ? 0xB0 : 0xB2; + if (_s49_truckSequenceId == 0xAD || _s49_truckSequenceId == 0xAE) { + _gameSys->setAnimation(steerSequenceId, 256, 0); + _gameSys->insertSequence(steerSequenceId, 256, _s49_truckSequenceId, _s49_truckId, 32, 0, 0, -50); + _s49_truckSequenceId = steerSequenceId; + _s49_truckId = 256; + } + } + clearKeyStatus1(Common::KEYCODE_LEFT); + } + + gameUpdateTick(); + + } + + stopSound(0xE2); + +} + +void GnapEngine::scene49_updateAnimations() { + + for (int i = 0; i < 5; ++i) { + if (_gameSys->getAnimationStatus(i + 2) == 2) { + if (_s49_obstacles[i].currSequenceId) + scene49_updateObstacle(i); + } + } + + if (_gameSys->getAnimationStatus(8) == 2) { + _sceneDone = true; + _newSceneNum = 47; + } + +} + +} // End of namespace Gnap diff --git a/engines/gnap/scenes/scene50.cpp b/engines/gnap/scenes/scene50.cpp new file mode 100644 index 0000000000..ce24354be0 --- /dev/null +++ b/engines/gnap/scenes/scene50.cpp @@ -0,0 +1,479 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "gnap/gnap.h" +#include "gnap/gamesys.h" +#include "gnap/resource.h" + +namespace Gnap { + +int GnapEngine::scene50_init() { + return 0xC7; +} + +void GnapEngine::scene50_updateHotspots() { + _hotspotsCount = 0; +} + +bool GnapEngine::scene50_tongueWinsRound(int tongueNum) { + if (tongueNum == 1) + ++_s50_leftTongueRoundsWon; + else + ++_s50_rightTongueRoundsWon; + scene50_playWinBadgeAnim(tongueNum); + bool fightOver = _s50_rightTongueRoundsWon == 2 || _s50_leftTongueRoundsWon == 2; + scene50_playWinAnim(tongueNum, fightOver); + return fightOver; +} + +void GnapEngine::scene50_playWinAnim(int tongueNum, bool fightOver) { + if (tongueNum == 1) { + if (fightOver) { + _gameSys->insertSequence(0xAD, 140, 0xAC, 140, kSeqSyncWait, 0, 0, 0); + _gameSys->insertSequence(0xB4, 100, _s50_leftTongueSequenceId, _s50_leftTongueId, kSeqSyncWait, 0, 0, 0); + _gameSys->insertSequence(0xBD, 100, _s50_rightTongueSequenceId, _s50_rightTongueId, kSeqSyncWait, 0, 0, 0); + _gameSys->insertSequence(0xBC, 100, 0xBD, 100, kSeqSyncWait, 0, 0, 0); + _s50_leftTongueSequenceId = 0xB4; + _s50_rightTongueSequenceId = 0xBC; + _s50_rightTongueId = 100; + _s50_leftTongueId = 100; + _gameSys->setAnimation(0xB4, 100, 6); + _gameSys->setAnimation(_s50_rightTongueSequenceId, 100, 5); + scene50_waitForAnim(6); + scene50_waitForAnim(5); + invAdd(kItemGum); + setFlag(13); + } else { + _gameSys->insertSequence(0xB4, 100, _s50_leftTongueSequenceId, _s50_leftTongueId, kSeqSyncWait, 0, 0, 0); + _gameSys->insertSequence(0xBD, 100, _s50_rightTongueSequenceId, _s50_rightTongueId, kSeqSyncWait, 0, 0, 0); + _gameSys->insertSequence(0xBC, 100, 0xBD, 100, kSeqSyncWait, 0, 0, 0); + _s50_leftTongueSequenceId = 0xB4; + _s50_rightTongueSequenceId = 0xBC; + _s50_rightTongueId = 100; + _s50_leftTongueId = 100; + _gameSys->setAnimation(0xB4, 100, 6); + _gameSys->setAnimation(_s50_rightTongueSequenceId, 100, 5); + scene50_waitForAnim(6); + scene50_waitForAnim(5); + } + } else { + _gameSys->insertSequence(0xBE, 100, _s50_rightTongueSequenceId, _s50_rightTongueId, kSeqSyncWait, 0, 0, 0); + _gameSys->setAnimation(0xBE, 100, 5); + scene50_waitForAnim(5); + _gameSys->insertSequence(0xBF, 100, 0xBE, 100, kSeqSyncWait, 0, 0, 0); + _gameSys->insertSequence(0xB5, 100, _s50_leftTongueSequenceId, _s50_leftTongueId, kSeqSyncWait, 0, 0, 0); + _s50_rightTongueSequenceId = 0xBF; + _s50_leftTongueSequenceId = 0xB5; + _s50_rightTongueId = 100; + _s50_leftTongueId = 100; + _gameSys->setAnimation(0xB5, 100, 6); + _gameSys->setAnimation(_s50_rightTongueSequenceId, 100, 5); + scene50_waitForAnim(6); + scene50_waitForAnim(5); + } + // TODO delayTicksA(1, 7); +} + +void GnapEngine::scene50_delayTicks() { + // TODO delayTicksA(3, 7); +} + +void GnapEngine::scene50_initRound() { + _s50_leftTongueEnergy = 10; + _s50_rightTongueEnergy = 10; + _s50_fightDone = false; + _timers[3] = scene50_getRightTongueActionTicks(); + _timers[4] = 0; + _timers[6] = 0; + _gameSys->fillSurface(0, 91, 73, 260, 30, 212, 0, 0); + _gameSys->fillSurface(0, 450, 73, 260, 30, 212, 0, 0); + _s50_timeRemaining = 40; + scene50_drawCountdown(40); +} + +bool GnapEngine::scene50_updateCountdown() { + if (!_timers[5]) { + --_s50_timeRemaining; + if (_s50_timeRemaining < 0) { + return true; + } else { + _timers[5] = 15; + scene50_drawCountdown(_s50_timeRemaining); + } + } + return false; +} + +void GnapEngine::scene50_drawCountdown(int value) { + char str[8]; + sprintf(str, "%02d", value); + _gameSys->fillSurface(0, 371, 505, 50, 27, 0, 0, 0); + _gameSys->drawTextToSurface(0, 381, 504, 255, 255, 255, str); +} + +void GnapEngine::scene50_playTonguesIdle() { + _gameSys->insertSequence(0xBA, 100, _s50_leftTongueSequenceId, _s50_leftTongueId, kSeqSyncWait, 0, 0, 0); + _gameSys->insertSequence(0xC2, 100, _s50_rightTongueSequenceId, _s50_rightTongueId, kSeqSyncWait, 0, 0, 0); + _s50_leftTongueSequenceId = 0xBA; + _s50_rightTongueSequenceId = 0xC2; + _s50_rightTongueNextSequenceId = -1; + _s50_leftTongueNextSequenceId = -1; + _s50_leftTongueId = 100; + _s50_rightTongueId = 100; + _gameSys->setAnimation(0xC2, 100, 5); + _gameSys->setAnimation(_s50_leftTongueSequenceId, _s50_leftTongueId, 6); +} + +void GnapEngine::scene50_playRoundAnim(int roundNum) { + int sequenceId; + + switch (roundNum) { + case 1: + sequenceId = 0xAF; + break; + case 2: + sequenceId = 0xB0; + break; + case 3: + sequenceId = 0xB1; + break; + } + + _gameSys->insertSequence(sequenceId, 256, 0, 0, kSeqNone, 0, 0, 0); + _gameSys->setAnimation(sequenceId, 256, 7); + scene50_waitForAnim(7); + + _gameSys->insertSequence(0xAB, 256, sequenceId, 256, kSeqSyncWait, 0, 0, 0); + _gameSys->setAnimation(0xAB, 256, 7); + scene50_waitForAnim(7); + +} + +bool GnapEngine::scene50_updateEnergyBars(int newLeftBarPos, int newRightBarPos) { + + if (newLeftBarPos != _s50_leftTongueEnergyBarPos) { + if (newLeftBarPos < 0) + newLeftBarPos = 0; + _s50_leftTongueEnergyBarPos = newLeftBarPos; + _gameSys->fillSurface(0, 26 * newLeftBarPos + 91, 73, 260 - 26 * newLeftBarPos, 30, 0, 0, 0); + } + + if (newRightBarPos != _s50_rightTongueEnergyBarPos) { + if (newRightBarPos < 0) + newRightBarPos = 0; + _s50_rightTongueEnergyBarPos = newRightBarPos; + if (newRightBarPos != 10) + _gameSys->fillSurface(0, 26 * (9 - newRightBarPos) + 450, 73, 26, 30, 0, 0, 0); + } + + if (newLeftBarPos * newRightBarPos > 0) + return false; + + _s50_leftTongueEnergyBarPos = 10; + _s50_rightTongueEnergyBarPos = 10; + return true; +} + +void GnapEngine::scene50_waitForAnim(int animationIndex) { + while (_gameSys->getAnimationStatus(animationIndex) != 2) { + gameUpdateTick(); + } + _gameSys->setAnimation(0, 0, animationIndex); +} + +int GnapEngine::scene50_checkInput() { + int sequenceId = -1; + + if (isKeyStatus1(Common::KEYCODE_RIGHT)) { + clearKeyStatus1(Common::KEYCODE_RIGHT); + sequenceId = 0xB6; + } else if (isKeyStatus1(Common::KEYCODE_LEFT)) { + clearKeyStatus1(Common::KEYCODE_LEFT); + sequenceId = 0xB3; + } else if (isKeyStatus1(Common::KEYCODE_ESCAPE)) { + clearKeyStatus1(Common::KEYCODE_ESCAPE); + _s50_fightDone = true; + } + + return sequenceId; +} + +int GnapEngine::scene50_getRightTongueAction() { + int sequenceId = -1; + + if (!_timers[3]) { + _timers[3] = scene50_getRightTongueActionTicks(); + if (_s50_rightTongueEnergy >= _s50_leftTongueEnergy) { + switch (getRandom(5)) { + case 0: + sequenceId = 0xBE; + break; + case 1: + sequenceId = 0xBE; + break; + case 2: + sequenceId = 0xBB; + break; + case 3: + sequenceId = 0xBB; + break; + case 4: + sequenceId = 0xBB; + break; + } + } else { + switch (getRandom(4)) { + case 0: + sequenceId = 0xBE; + break; + case 1: + sequenceId = 0xBB; + break; + case 2: + sequenceId = 0xBE; + break; + case 3: + sequenceId = 0xBE; + break; + } + } + } + + return sequenceId; +} + +void GnapEngine::scene50_updateAnimations() { + + if (!_timers[4]) + _s50_attackCounter = 0; + + if (_gameSys->getAnimationStatus(5) == 2) { + if (_s50_rightTongueSequenceId == 0xBE) { + if (_s50_leftTongueSequenceId != 0xB3 && _s50_leftTongueSequenceId != 0xB8) + _s50_rightTongueNextSequenceId = 0xBF; + else + _s50_rightTongueNextSequenceId = 0xC0; + } + if (_s50_rightTongueNextSequenceId == -1) + _s50_rightTongueNextSequenceId = 0xC2; + if (_s50_rightTongueNextSequenceId == 0xBF) { + _s50_leftTongueNextId = scene50_getLeftTongueNextId(); + _s50_rightTongueNextId = scene50_getRightTongueNextId(); + _gameSys->setAnimation(_s50_rightTongueNextSequenceId, _s50_rightTongueNextId, 5); + _gameSys->setAnimation(0xB9, _s50_leftTongueNextId, 6); + _gameSys->insertSequence(_s50_rightTongueNextSequenceId, _s50_rightTongueNextId, _s50_rightTongueSequenceId, _s50_rightTongueId, kSeqSyncWait, 0, 0, 0); + _gameSys->insertSequence(0xB9, _s50_leftTongueNextId, _s50_leftTongueSequenceId, _s50_leftTongueId, 32, 0, 0, 0); + _s50_rightTongueSequenceId = _s50_rightTongueNextSequenceId; + _s50_rightTongueNextSequenceId = -1; + _s50_leftTongueSequenceId = 0xB9; + _s50_leftTongueNextSequenceId = -1; + _s50_rightTongueId = _s50_rightTongueNextId; + _s50_leftTongueId = _s50_leftTongueNextId; + _s50_leftTongueEnergy -= getRandom(2) + 1;//CHECKME + } else { + _s50_rightTongueNextId = scene50_getRightTongueNextId(); + _gameSys->setAnimation(_s50_rightTongueNextSequenceId, _s50_rightTongueNextId, 5); + _gameSys->insertSequence(_s50_rightTongueNextSequenceId, _s50_rightTongueNextId, _s50_rightTongueSequenceId, _s50_rightTongueId, kSeqSyncWait, 0, 0, 0); + _s50_rightTongueSequenceId = _s50_rightTongueNextSequenceId; + _s50_rightTongueNextSequenceId = -1; + _s50_rightTongueId = _s50_rightTongueNextId; + } + } + + if (_gameSys->getAnimationStatus(6) == 2) { + if (_s50_leftTongueSequenceId == 0xB6) { + ++_s50_attackCounter; + if (_s50_timesPlayedModifier + 3 <= _s50_attackCounter) { + _s50_leftTongueNextSequenceId = 0xB8; + } else { + _timers[4] = 20; + //CHECKME + if (_s50_rightTongueSequenceId != 0xBB && _s50_rightTongueSequenceId != 0xC0 && getRandom(8) != _s50_roundNum) + _s50_leftTongueNextSequenceId = 0xB7; + else + _s50_leftTongueNextSequenceId = 0xB8; + } + } + if (_s50_leftTongueNextSequenceId == 0xB3) + --_s50_attackCounter; + if (_s50_leftTongueNextSequenceId == -1) + _s50_leftTongueNextSequenceId = 0xBA; + if (_s50_leftTongueNextSequenceId == 0xB7) { + _s50_leftTongueNextId = scene50_getLeftTongueNextId(); + _s50_rightTongueNextId = scene50_getRightTongueNextId(); + _gameSys->setAnimation(_s50_leftTongueNextSequenceId, _s50_leftTongueNextId, 6); + _gameSys->setAnimation(0xC1, _s50_rightTongueNextId, 5); + _gameSys->insertSequence(_s50_leftTongueNextSequenceId, _s50_leftTongueNextId, _s50_leftTongueSequenceId, _s50_leftTongueId, kSeqSyncWait, 0, 0, 0); + _gameSys->insertSequence(0xC1, _s50_rightTongueNextId, _s50_rightTongueSequenceId, _s50_rightTongueId, 32, 0, 0, 0); + _s50_leftTongueSequenceId = _s50_leftTongueNextSequenceId; + _s50_leftTongueNextSequenceId = -1; + _s50_rightTongueSequenceId = 0xC1; + _s50_rightTongueNextSequenceId = -1; + _s50_rightTongueId = _s50_rightTongueNextId; + _s50_leftTongueId = _s50_leftTongueNextId; + --_s50_rightTongueEnergy; + } else if (_s50_leftTongueNextSequenceId != 0xB8 || _s50_rightTongueSequenceId != 0xC2) { + _s50_leftTongueNextId = scene50_getLeftTongueNextId(); + _gameSys->setAnimation(_s50_leftTongueNextSequenceId, _s50_leftTongueNextId, 6); + _gameSys->insertSequence(_s50_leftTongueNextSequenceId, _s50_leftTongueNextId, _s50_leftTongueSequenceId, _s50_leftTongueId, kSeqSyncWait, 0, 0, 0); + _s50_leftTongueSequenceId = _s50_leftTongueNextSequenceId; + _s50_leftTongueNextSequenceId = -1; + _s50_leftTongueId = _s50_leftTongueNextId; + } else { + _s50_leftTongueNextId = scene50_getLeftTongueNextId(); + _s50_rightTongueNextId = scene50_getRightTongueNextId(); + _gameSys->setAnimation(0xBB, _s50_rightTongueNextId, 5); + _gameSys->setAnimation(_s50_leftTongueNextSequenceId, _s50_leftTongueNextId, 6); + _gameSys->insertSequence(_s50_leftTongueNextSequenceId, _s50_leftTongueNextId, _s50_leftTongueSequenceId, _s50_leftTongueId, kSeqSyncWait, 0, 0, 0); + _gameSys->insertSequence(0xBB, _s50_rightTongueNextId, _s50_rightTongueSequenceId, _s50_rightTongueId, 32, 0, 0, 0); + _s50_rightTongueSequenceId = 0xBB; + _s50_rightTongueId = _s50_rightTongueNextId; + _s50_rightTongueNextSequenceId = -1; + _s50_leftTongueSequenceId = _s50_leftTongueNextSequenceId; + _s50_leftTongueNextSequenceId = -1; + _s50_leftTongueId = _s50_leftTongueNextId; + } + } + +} + +int GnapEngine::scene50_getRightTongueActionTicks() { + return 15 - 5 * _s50_roundNum + 1; +} + +int GnapEngine::scene50_getLeftTongueNextId() { + _s50_leftTongueNextIdCtr = (_s50_leftTongueNextIdCtr + 1) % 3; + return _s50_leftTongueNextIdCtr + 100; +} + +int GnapEngine::scene50_getRightTongueNextId() { + _s50_rightTongueNextIdCtr = (_s50_rightTongueNextIdCtr + 1) % 3; + return _s50_rightTongueNextIdCtr + 100; +} + +void GnapEngine::scene50_playWinBadgeAnim(int tongueNum) { + int sequenceId; + + if (tongueNum == 1) { + if (_s50_leftTongueRoundsWon == 1) + sequenceId = 0xC3; + else + sequenceId = 0xC4; + } else { + if (_s50_rightTongueRoundsWon == 1) + sequenceId = 0xC5; + else + sequenceId = 0xC6; + } + + _gameSys->setAnimation(sequenceId, 120, 7); + _gameSys->insertSequence(sequenceId, 120, 0, 0, kSeqNone, 0, 0, 0); + scene50_waitForAnim(7); + +} + +void GnapEngine::scene50_run() { + + ++_s50_timesPlayed; + _s50_timesPlayedModifier = _s50_timesPlayed / 4; + _s50_leftTongueRoundsWon = 0; + _s50_rightTongueRoundsWon = 0; + // scene50_initFont(); + _s50_leftTongueSequenceId = 186; + _s50_rightTongueSequenceId = 194; + _s50_rightTongueNextSequenceId = -1; + _s50_leftTongueNextSequenceId = -1; + _s50_leftTongueId = 100; + _s50_rightTongueId = 100; + + _gameSys->setAnimation(194, 100, 5); + _gameSys->setAnimation(_s50_leftTongueSequenceId, _s50_leftTongueId, 6); + _gameSys->insertSequence(_s50_leftTongueSequenceId, _s50_leftTongueId, 0, 0, kSeqNone, 0, 0, 0); + _gameSys->insertSequence(_s50_rightTongueSequenceId, _s50_rightTongueId, 0, 0, kSeqNone, 0, 0, 0); + _gameSys->insertSequence(172, 140, 0, 0, kSeqNone, 0, 0, 0); + endSceneInit(); + + scene50_initRound(); + + _s50_roundNum = 1; + + setGrabCursorSprite(-1); + hideCursor(); + + // TODO delayTicksA(1, 7); + + scene50_playRoundAnim(_s50_roundNum); + + _timers[5] = 15; + + while (!_s50_fightDone) { + + /* TODO + if (sceneXX_sub_4466B1()) + _s50_fightDone = true; + */ + + int playerSequenceId = scene50_checkInput(); + if (playerSequenceId != -1) + _s50_leftTongueNextSequenceId = playerSequenceId; + + int rightSequenceId = scene50_getRightTongueAction(); + if (rightSequenceId != -1) + _s50_rightTongueNextSequenceId = rightSequenceId; + + scene50_updateAnimations(); + + if (scene50_updateCountdown() || + scene50_updateEnergyBars(_s50_leftTongueEnergy, _s50_rightTongueEnergy)) { + int v0; + if (_s50_rightTongueEnergy < _s50_leftTongueEnergy) + v0 = scene50_tongueWinsRound(1); + else + v0 = scene50_tongueWinsRound(2); + if (v0) { + scene50_delayTicks(); + _s50_fightDone = true; + } else { + ++_s50_roundNum; + scene50_initRound(); + scene50_playTonguesIdle(); + scene50_updateEnergyBars(_s50_leftTongueEnergy, _s50_rightTongueEnergy); + scene50_playRoundAnim(_s50_roundNum); + _timers[5] = 15; + } + } + + gameUpdateTick(); + + } + + // scene50_freeFont(); + + _gameSys->setAnimation(0, 0, 7); + _gameSys->setAnimation(0, 0, 6); + _gameSys->setAnimation(0, 0, 5); + _gameSys->setAnimation(0, 0, 3); + + showCursor(); +} + +} // End of namespace Gnap diff --git a/engines/gnap/scenes/scene51.cpp b/engines/gnap/scenes/scene51.cpp new file mode 100644 index 0000000000..1313c1d2db --- /dev/null +++ b/engines/gnap/scenes/scene51.cpp @@ -0,0 +1,880 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "gnap/gnap.h" +#include "gnap/gamesys.h" +#include "gnap/resource.h" + +namespace Gnap { + +static const int kDigitSequenceIds[] = { + 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, + 0xCF, 0xD0, 0xD1, 0xD2, 0xD3 +}; + +static const int kDigitPositions[4] = { + 0, 34, 83, 119 +}; + +/* + 0xBA Falling banana peel + 0xBC Banana peel goes away + 0xBD Falling coin + 0xBE Fallen coin + 0xC0 Falling banknote + 0xB6 Platypus tripping (right) + 0xB7 Platypus tripping (left) + 0x76 Platypus jumping (right) +*/ + +int GnapEngine::scene51_init() { + _gameSys->setAnimation(0, 0, 0); + for (int i = 0; i < 6; ++i) + _gameSys->setAnimation(0, 0, i + 1); + return 0xD4; +} + +void GnapEngine::scene51_updateHotspots() { + _hotspotsCount = 0; +} + +void GnapEngine::scene51_clearItem(Scene51Item *item) { + item->currSequenceId = 0; + item->droppedSequenceId = 0; + item->x = 0; + item->y = 0; + item->x2 = 0; + item->collisionX = 0; + item->canCatch = 0; +} + +void GnapEngine::scene51_dropNextItem() { + + if (_timers[0]) + return; + + int index = 0; + + while (index < 6 && _s51_items[index].currSequenceId) + ++index; + + if (index == 6) + return; + + switch (_s51_nextDropItemKind) { + + case 0: + if (getRandom(10) != 0 || _s51_itemsCtr2 >= 2) { + _s51_items[index].currSequenceId = 0xBD; + } else { + --_s51_itemsCtr1; + _s51_items[index].currSequenceId = 0xBA; + ++_s51_itemsCtr2; + } + break; + + case 1: + if (getRandom(8) != 0 || _s51_itemsCtr2 >= 2) { + if (getRandom(5) == 0) { + if (_s51_itemInsertDirection) + _s51_itemInsertX -= 70; + else + _s51_itemInsertX += 70; + } + _s51_items[index].currSequenceId = 0xBD; + } else { + --_s51_itemsCtr1; + _s51_items[index].currSequenceId = 0xBA; + ++_s51_itemsCtr2; + } + break; + + case 2: + if (getRandom(6) != 0 || _s51_itemsCtr2 >= 2) { + _s51_items[index].currSequenceId = 0xBD; + } else { + --_s51_itemsCtr1; + _s51_items[index].currSequenceId = 0xBA; + ++_s51_itemsCtr2; + } + break; + + case 3: + case 4: + if (_s51_itemsCtr == 0) + _s51_itemsCtr1 = 3; + _s51_items[index].currSequenceId = 0xC0; + break; + + case 5: + case 6: + if (getRandom(5) != 0 || _s51_itemsCtr2 >= 2) { + if (getRandom(5) != 0) + _s51_items[index].currSequenceId = 0xBD; + else + _s51_items[index].currSequenceId = 0xC0; + } else { + --_s51_itemsCtr1; + _s51_items[index].currSequenceId = 0xBA; + ++_s51_itemsCtr2; + } + break; + + case 7: + if (getRandom(5) != 0 || _s51_itemsCtr2 >= 2) { + if (getRandom(5) == 0) { + if (_s51_itemInsertDirection) + _s51_itemInsertX -= 40; + else + _s51_itemInsertX += 40; + } + if (getRandom(9) != 0) + _s51_items[index].currSequenceId = 0xBD; + else + _s51_items[index].currSequenceId = 0xC0; + } else { + --_s51_itemsCtr1; + _s51_items[index].currSequenceId = 0xBA; + ++_s51_itemsCtr2; + } + break; + + default: + if (getRandom(4) != 0 || _s51_itemsCtr2 >= 2) { + if (getRandom(9) != 0) + _s51_items[index].currSequenceId = 0xBD; + else + _s51_items[index].currSequenceId = 0xC0; + } else { + --_s51_itemsCtr1; + _s51_items[index].currSequenceId = 0xBA; + ++_s51_itemsCtr2; + } + break; + + } + + if (_s51_itemInsertDirection) { + _s51_itemInsertX -= 73; + if (_s51_itemInsertX < 129) { + _s51_itemInsertX += 146; + _s51_itemInsertDirection = 0; + } + } else { + _s51_itemInsertX += 73; + if (_s51_itemInsertX > 685) { + _s51_itemInsertX -= 146; + _s51_itemInsertDirection = 1; + } + } + + if (_s51_itemInsertX > 685) + _s51_itemInsertX = 685; + + if (_s51_itemInsertX < 129) + _s51_itemInsertX = 129; + + if (_s51_items[index].currSequenceId == 0xBA) { + _s51_items[index].x2 = getRandom(350) + 200; + _s51_items[index].x = _s51_items[index].x2 - 362; + _s51_items[index].y = 15; + _s51_items[index].id = 249 - index; + } else { + _s51_items[index].collisionX = _s51_itemInsertX; + _s51_items[index].x = _s51_items[index].collisionX - 395; + if (_s51_items[index].currSequenceId == 0xC0) + _s51_items[index].x -= 65; + _s51_items[index].id = index + 250; + _s51_items[index].canCatch = 1; + } + + _gameSys->setAnimation(_s51_items[index].currSequenceId, _s51_items[index].id, index + 1); + _gameSys->insertSequence(_s51_items[index].currSequenceId, _s51_items[index].id, 0, 0, + kSeqNone, 0, _s51_items[index].x, _s51_items[index].y); + + _timers[0] = _s51_dropSpeedTicks; + + if (_s51_nextDropItemKind >= 3) + _timers[0] = 20; + + if (_s51_nextDropItemKind >= 5) + _timers[0] = 5; + + if (_s51_nextDropItemKind == 8) + _timers[0] = 4; + + ++_s51_itemsCtr; + +} + +void GnapEngine::scene51_updateItemAnimations() { + for (int i = 0; i < 6; ++i) + if (_gameSys->getAnimationStatus(i + 1) == 2) + scene51_updateItemAnimation(&_s51_items[i], i); +} + +int GnapEngine::scene51_checkCollision(int sequenceId) { + bool jumpingLeft = false, jumpingRight = false; + int v6 = 0; + int v2 = 0; + int v5 = 0; + int v8, v4; + int result = 0; + + if (!scene51_isJumping(sequenceId)) + return false; + + while (v6 < 6) + v2 += _s51_items[v6++].isCollision; + + if (!v2) + return false; + + if (scene51_isJumpingRight(sequenceId)) { + v8 = scene51_getPosRight(sequenceId); + v4 = scene51_getPosRight(sequenceId + 1); + jumpingRight = true; + } else if (scene51_isJumpingLeft(sequenceId)) { + v4 = scene51_getPosLeft(sequenceId - 1) + 33; + v8 = scene51_getPosLeft(sequenceId) + 33; + jumpingLeft = true; + } + + if (jumpingRight || jumpingLeft) { + int i; + for (i = 0; i < 6; ++i) { + if (_s51_items[i].isCollision) { + if (jumpingRight && _s51_items[i].x2 > v8 && _s51_items[i].x2 < v4) { + v5 = v8 - 359; + if (v8 == 359) + v5 = 1; + _s51_platypusNextSequenceId = 0xB6; + break; + } else if (jumpingLeft && _s51_items[i].x2 < v4 && _s51_items[i].x2 > v8) { + v5 = v8 - 344; + if (v8 == 344) + v5 = 1; + _s51_platypusNextSequenceId = 0xB7; + break; + } + } + } + if (v5) { + _gameSys->setAnimation(0xBC, _s51_items[i].id, i + 1); + _gameSys->insertSequence(0xBC, _s51_items[i].id, _s51_items[i].currSequenceId, _s51_items[i].id, kSeqSyncWait, 0, _s51_items[i].x, 15); + _s51_items[i].isCollision = 0; + _s51_items[i].currSequenceId = 0xBC; + --_s51_itemsCtr2; + } + result = v5; + } + + return result; +} + +void GnapEngine::scene51_updateItemAnimation(Scene51Item *item, int index) { + + switch (item->currSequenceId) { + + case 0xBD: + case 0xC0: + case 0xC1: + // Falling coin and banknote + if (!scene51_itemIsCaught(item)) { + if (_s51_dropLoseCash) { + if (item->currSequenceId == 0xBD) + _s51_cashAmount -= 2; + else + _s51_cashAmount -= 25; + if (_s51_cashAmount < 0) + _s51_cashAmount = 0; + scene51_updateCash(_s51_cashAmount); + } + item->droppedSequenceId = item->currSequenceId + 1; + if (item->currSequenceId != 0xC0) { + item->canCatch = 0; + _s51_dropLoseCash = true; + _s51_itemsCtr = 0; + _timers[0] = 10; + } + if (item->droppedSequenceId) { + _gameSys->setAnimation(item->droppedSequenceId, item->id, index + 1); + _gameSys->insertSequence(item->droppedSequenceId, item->id, item->currSequenceId, item->id, kSeqSyncWait, 0, item->x, item->y); + item->currSequenceId = item->droppedSequenceId; + item->y = 0; + } + } else { + _gameSys->removeSequence(item->currSequenceId, item->id, 1); + _gameSys->setAnimation(0, 0, index + 1); + playSound(218, 0); + if (scene51_incCashAmount(item->currSequenceId) == 1995) { + scene51_winMinigame(); + _sceneDone = true; + } else { + scene51_clearItem(item); + ++_s51_itemsCaughtCtr; + if (_s51_itemsCaughtCtr == 5) + --_s51_dropSpeedTicks; + if (_s51_itemsCaughtCtr == 8) + --_s51_dropSpeedTicks; + if (_s51_itemsCaughtCtr == 11) + --_s51_dropSpeedTicks; + if (_s51_itemsCaughtCtr == 14) + --_s51_dropSpeedTicks; + if (_s51_itemsCaughtCtr >= 15 && _s51_dropSpeedTicks > 4) + --_s51_dropSpeedTicks; + if (_s51_itemsCtr1 <= _s51_itemsCaughtCtr) { + ++_s51_nextDropItemKind; + _s51_dropSpeedTicks = 10; + _s51_itemsCtr = 0; + _s51_itemsCtr1 = 20; + _s51_dropLoseCash = false; + _s51_itemsCaughtCtr = 0; + scene51_removeCollidedItems(); + } + } + } + break; + + case 0xBE: + // Fallen coin + item->droppedSequenceId = item->currSequenceId + 1; + if (item->droppedSequenceId) { + _gameSys->setAnimation(item->droppedSequenceId, item->id, index + 1); + _gameSys->insertSequence(item->droppedSequenceId, item->id, item->currSequenceId, item->id, kSeqSyncWait, 0, item->x, item->y); + item->currSequenceId = item->droppedSequenceId; + item->y = 0; + } + break; + + case 0xBF: + case 0xC2: + // Bouncing coin and banknote + _gameSys->setAnimation(0, 0, index + 1); + _gameSys->removeSequence(item->currSequenceId, item->id, 1); + scene51_clearItem(item); + break; + + case 0xBA: + // Falling banana peel + item->droppedSequenceId = 0xBB; + item->y = 15; + if (item->droppedSequenceId) { + _gameSys->setAnimation(item->droppedSequenceId, item->id, index + 1); + _gameSys->insertSequence(item->droppedSequenceId, item->id, item->currSequenceId, item->id, kSeqSyncWait, 0, item->x, item->y); + item->currSequenceId = item->droppedSequenceId; + item->y = 0; + } + break; + + case 0xBB: + item->isCollision = 1; + item->droppedSequenceId = 0; + _gameSys->setAnimation(0, 0, index + 1); + break; + + case 0xBC: + _gameSys->removeSequence(item->currSequenceId, item->id, 1); + _gameSys->setAnimation(0, 0, index + 1); + scene51_clearItem(item); + break; + + default: + if (item->droppedSequenceId) { + _gameSys->setAnimation(item->droppedSequenceId, item->id, index + 1); + _gameSys->insertSequence(item->droppedSequenceId, item->id, item->currSequenceId, item->id, kSeqSyncWait, 0, item->x, item->y); + item->currSequenceId = item->droppedSequenceId; + item->y = 0; + } + break; + + } + +} + +void GnapEngine::scene51_removeCollidedItems() { + for (int i = 0; i < 6; ++i) { + if (_s51_items[i].isCollision) { + _gameSys->removeSequence(_s51_items[i].currSequenceId, _s51_items[i].id, 1); + _gameSys->setAnimation(0, 0, i + 1); + scene51_clearItem(&_s51_items[i]); + } + } + _s51_itemsCtr2 = 0; +} + +int GnapEngine::scene51_itemIsCaught(Scene51Item *item) { + + if (!item->canCatch) + return 0; + + if (scene51_isJumpingRight(_s51_platypusJumpSequenceId)) { + int v4 = scene51_getPosRight(_s51_platypusJumpSequenceId) + 97; + if (item->collisionX < v4 && v4 - item->collisionX < 56) + return 1; + } else { + int v2 = scene51_getPosLeft(_s51_platypusJumpSequenceId); + if (item->collisionX > v2 && item->collisionX - v2 < 56) + return 1; + } + + if (item->currSequenceId == 0xC1) { + int v3 = item->collisionX + 100; + if (scene51_isJumpingRight(_s51_platypusJumpSequenceId)) { + if (ABS(scene51_getPosRight(_s51_platypusJumpSequenceId) + 46 - v3) < 56) + return 1; + } else if (ABS(scene51_getPosLeft(_s51_platypusJumpSequenceId) + 46 - v3) < 56) { + return 1; + } + } + + return 0; +} + +bool GnapEngine::scene51_isJumpingRight(int sequenceId) { + return sequenceId >= 0x76 && sequenceId <= 0x95; +} + +bool GnapEngine::scene51_isJumpingLeft(int sequenceId) { + return sequenceId >= 0x96 && sequenceId <= 0xB5; +} + +bool GnapEngine::scene51_isJumping(int sequenceId) { + return sequenceId >= 0x76 && sequenceId <= 0xB5; +} + +void GnapEngine::scene51_waitForAnim(int animationIndex) { + while (_gameSys->getAnimationStatus(animationIndex) != 2) { + // pollMessages(); + scene51_updateItemAnimations(); + gameUpdateTick(); + } +} + +int GnapEngine::scene51_getPosRight(int sequenceId) { + static const int kRightPosTbl[] = { + 131, 159, 178, 195, 203, 219, 238, 254, + 246, 274, 293, 310, 318, 334, 353, 369, + 362, 390, 409, 426, 434, 450, 469, 485, + 477, 505, 524, 541, 549, 565, 584, 600 + }; + + if (sequenceId >= 118 && sequenceId <= 149) + return kRightPosTbl[sequenceId - 118]; + return -1; +} + +int GnapEngine::scene51_getPosLeft(int sequenceId) { + static const int kLeftPosTbl[] = { + 580, 566, 550, 536, 526, 504, 488, 469, + 460, 446, 430, 416, 406, 384, 368, 349, + 342, 328, 312, 298, 288, 266, 250, 231, + 220, 206, 190, 176, 166, 144, 128, 109 + }; + + if (sequenceId >= 150 && sequenceId <= 181) + return kLeftPosTbl[sequenceId - 150]; + return -1; +} + +void GnapEngine::scene51_playIntroAnim() { + int soundCtr = 0; + + _s51_platypusSequenceId = 0x76; + _s51_platypusNextSequenceId = 0x76; + + for (int i = 0; i < 6; ++i) + scene51_clearItem(&_s51_items[i]); + + _s51_items[0].currSequenceId = 0xBA; + _s51_items[0].x2 = 320; + _s51_items[0].x = -42; + _s51_items[0].y = 15; + _s51_items[0].id = 249; + _s51_items[0].isCollision = 1; + + _gameSys->insertSequence(_s51_platypusSequenceId, 256, 0, 0, kSeqNone, 0, -179, 0); + _gameSys->insertSequence(0xBA, 249, 0, 0, kSeqNone, 0, _s51_items[0].x, _s51_items[0].y); + _gameSys->setAnimation(0xBA, 249, 1); + _gameSys->setAnimation(_s51_platypusSequenceId, 256, 0); + + while (_s51_platypusSequenceId < 0x80) { + scene51_waitForAnim(0); + ++_s51_platypusNextSequenceId; + _gameSys->setAnimation(_s51_platypusNextSequenceId, 256, 0); + _gameSys->insertSequence(_s51_platypusNextSequenceId, 256, _s51_platypusSequenceId, 256, kSeqSyncWait, 0, -179, 0); + _s51_platypusSequenceId = _s51_platypusNextSequenceId; + ++soundCtr; + if (soundCtr % 4 == 0) + playSound(214, 0); + } + + _s51_platypusNextSequenceId = 0x75; + + while (_s51_platypusSequenceId != 0x84) { + scene51_waitForAnim(0); + ++_s51_platypusNextSequenceId; + int oldSequenceId = _s51_platypusNextSequenceId; + int v0 = scene51_checkCollision(_s51_platypusNextSequenceId); + _gameSys->setAnimation(_s51_platypusNextSequenceId, 256, 0); + _gameSys->insertSequence(_s51_platypusNextSequenceId, 256, _s51_platypusSequenceId, 256, kSeqSyncWait, 0, v0, 0); + _s51_platypusSequenceId = _s51_platypusNextSequenceId; + if (v0) { + _s51_platypusNextSequenceId = oldSequenceId; + } else { + ++soundCtr; + if (soundCtr % 4 == 0) + playSound(214, 0); + } + } + + scene51_waitForAnim(0); + +} + +void GnapEngine::scene51_updateGuyAnimation() { + + if (!_timers[4]) { + _timers[4] = getRandom(20) + 60; + + switch (getRandom(5)) { + case 0: + _s51_guyNextSequenceId = 0xC3; + break; + case 1: + _s51_guyNextSequenceId = 0xC4; + break; + case 2: + _s51_guyNextSequenceId = 0xC5; + break; + case 3: + _s51_guyNextSequenceId = 0xC6; + break; + case 4: + _s51_guyNextSequenceId = 0xC7; + break; + } + + _gameSys->insertSequence(_s51_guyNextSequenceId, 39, _s51_guySequenceId, 39, kSeqSyncWait, 0, 0, 0); + _s51_guySequenceId = _s51_guyNextSequenceId; + _s51_guyNextSequenceId = -1; + + } + +} + +int GnapEngine::scene51_incCashAmount(int sequenceId) { + switch (sequenceId) { + case 0xBD: + _s51_cashAmount += 10; + break; + case 0xC0: + case 0xC1: + _s51_cashAmount += 100; + break; + case 0xB6: + case 0xB7: + _s51_cashAmount -= 10 * getRandom(5) + 50; + if (_s51_cashAmount < 0) + _s51_cashAmount = 0; + break; + } + if (_s51_cashAmount > 1995) + _s51_cashAmount = 1995; + scene51_updateCash(_s51_cashAmount); + return _s51_cashAmount; +} + +void GnapEngine::scene51_winMinigame() { + scene51_updateCash(1995); + playSound(218, 0); + // TODO delayTicksA(1, 5); + _newSceneNum = 48; + invRemove(kItemBanana); +} + +void GnapEngine::scene51_playCashAppearAnim() { + _gameSys->setAnimation(0xC8, 252, 0); + _gameSys->insertSequence(0xC8, 252, 0, 0, kSeqNone, 0, -20, -20); + while (_gameSys->getAnimationStatus(0) != 2) { + gameUpdateTick(); + // checkGameAppStatus(); + } +} + +void GnapEngine::scene51_updateCash(int amount) { + scene51_drawDigit(amount / 1000, 0); + scene51_drawDigit(amount / 100 % 10, 1); + scene51_drawDigit(amount / 10 % 10, 2); + scene51_drawDigit(amount % 10, 3); +} + +void GnapEngine::scene51_drawDigit(int digit, int position) { + if (digit != _s51_digits[position]) { + _gameSys->insertSequence(kDigitSequenceIds[digit], 253, + _s51_digitSequenceIds[position], 253, + kSeqSyncWait, 0, kDigitPositions[position] - 20, -20); + _s51_digitSequenceIds[position] = kDigitSequenceIds[digit]; + _s51_digits[position] = digit; + } +} + +void GnapEngine::scene51_initCashDisplay() { + for (int position = 0; position < 4; ++position) { + _s51_digits[position] = 0; + _s51_digitSequenceIds[position] = kDigitSequenceIds[0]; + _gameSys->insertSequence(kDigitSequenceIds[0], 253, 0, 0, + kSeqNone, 0, kDigitPositions[position] - 20, -20); + } + _s51_cashAmount = 0; +} + +void GnapEngine::scene51_run() { + + int soundCtr = 0; + bool isIdle = true; + + _s51_itemsCtr = 0; + _newSceneNum = _prevSceneNum; + _s51_cashAmount = 0; + _s51_platypusJumpSequenceId = 0x84; + endSceneInit(); + + hideCursor(); + setGrabCursorSprite(-1); + + _s51_guySequenceId = 0xC3; + _s51_guyNextSequenceId = -1; + + _gameSys->insertSequence(0xC3, 39, 0, 0, kSeqNone, 0, 0, 0); + + _timers[4] = getRandom(20) + 60; + + scene51_playCashAppearAnim(); + scene51_initCashDisplay(); + scene51_playIntroAnim(); + + _s51_platypusNextSequenceId = 0x74; + _gameSys->setAnimation(0x74, 256, 0); + _gameSys->insertSequence(_s51_platypusNextSequenceId, 256, _s51_platypusSequenceId, 256, kSeqSyncWait, 0, scene51_getPosRight(_s51_platypusJumpSequenceId) - 362, 0); + _s51_platypusSequenceId = _s51_platypusNextSequenceId; + + _s51_itemInsertDirection = 0; + _s51_itemInsertX = 685; + _s51_dropSpeedTicks = 10; + _s51_nextDropItemKind = 0; + + for (int i = 0; i < 6; ++i) + scene51_clearItem(&_s51_items[i]); + + _s51_itemInsertX = getRandom(556) + 129; + + _timers[0] = 15; + + _s51_itemsCaughtCtr = 0; + _s51_dropLoseCash = false; + _s51_itemsCtr1 = 20; + + clearKeyStatus1(Common::KEYCODE_RIGHT); + clearKeyStatus1(Common::KEYCODE_LEFT); + clearKeyStatus1(Common::KEYCODE_UP); + clearKeyStatus1(Common::KEYCODE_SPACE); + clearKeyStatus1(Common::KEYCODE_ESCAPE); + + bool isCollision = false; + bool startWalk = true; + + while (!_sceneDone) { + + if (sceneXX_sub_4466B1()) + _sceneDone = true; + + gameUpdateTick(); + + scene51_updateGuyAnimation(); + scene51_dropNextItem(); + scene51_updateItemAnimations(); + + if (isKeyStatus2(Common::KEYCODE_UP) || isKeyStatus2(Common::KEYCODE_SPACE)) { + clearKeyStatus1(Common::KEYCODE_UP); + clearKeyStatus1(Common::KEYCODE_SPACE); + if (scene51_isJumpingRight(_s51_platypusJumpSequenceId)) { + scene51_waitForAnim(0); + _gameSys->setAnimation(0xB8, 256, 0); + _gameSys->insertSequence(0xB8, 256, _s51_platypusSequenceId, 256, kSeqSyncWait, 0, scene51_getPosRight(_s51_platypusJumpSequenceId) - 348, 0); + _s51_platypusSequenceId = 0xB8; + scene51_waitForAnim(0); + _s51_platypusNextSequenceId += 6; + if (_s51_platypusNextSequenceId > 0x95) + _s51_platypusNextSequenceId = 0x95; + _s51_platypusJumpSequenceId = _s51_platypusNextSequenceId; + } else { + scene51_waitForAnim(0); + _gameSys->setAnimation(0xB9, 256, 0); + _gameSys->insertSequence(0xB9, 256, _s51_platypusSequenceId, 256, kSeqSyncWait, 0, scene51_getPosLeft(_s51_platypusJumpSequenceId) - 338, 0); + _s51_platypusSequenceId = 0xB9; + scene51_waitForAnim(0); + _s51_platypusNextSequenceId += 6; + if (_s51_platypusNextSequenceId > 0xB5) + _s51_platypusNextSequenceId = 0xB5; + _s51_platypusJumpSequenceId = _s51_platypusNextSequenceId; + } + isIdle = false; + } + + while (isKeyStatus2(Common::KEYCODE_RIGHT) && _s51_platypusNextSequenceId != 0x96) { + // pollMessages(); + if (_s51_platypusNextSequenceId == 0xB6) + _s51_platypusNextSequenceId = 0x76; + scene51_updateItemAnimations(); + if (startWalk) { + _s51_platypusNextSequenceId = 0x86; + startWalk = false; + } + + if (_gameSys->getAnimationStatus(0) == 2) { + int collisionX = scene51_checkCollision(_s51_platypusNextSequenceId); + if (collisionX) + scene51_incCashAmount(_s51_platypusNextSequenceId); + _gameSys->setAnimation(_s51_platypusNextSequenceId, 256, 0); + _gameSys->insertSequence(_s51_platypusNextSequenceId, 256, _s51_platypusSequenceId, 256, kSeqSyncWait, 0, collisionX, 0); + _s51_platypusSequenceId = _s51_platypusNextSequenceId; + if (collisionX) { + isCollision = true; + ++_s51_platypusJumpSequenceId; + _s51_platypusNextSequenceId = _s51_platypusJumpSequenceId; + } else { + _s51_platypusJumpSequenceId = _s51_platypusNextSequenceId; + } + if (scene51_isJumpingRight(_s51_platypusJumpSequenceId)) { + ++_s51_platypusNextSequenceId; + if (!isCollision) { + if (isKeyStatus2(Common::KEYCODE_UP) || isKeyStatus2(Common::KEYCODE_SPACE)) { + clearKeyStatus1(Common::KEYCODE_UP); + clearKeyStatus1(Common::KEYCODE_SPACE); + scene51_waitForAnim(0); + _gameSys->setAnimation(0xB8, 256, 0); + _gameSys->insertSequence(0xB8, 256, _s51_platypusSequenceId, 256, kSeqSyncWait, 0, scene51_getPosRight(_s51_platypusJumpSequenceId) - 348, 0); + _s51_platypusSequenceId = 0xB8; + scene51_waitForAnim(0); + _s51_platypusNextSequenceId += 6; + if (_s51_platypusNextSequenceId > 0x95) + _s51_platypusNextSequenceId = 0x95; + _s51_platypusJumpSequenceId = _s51_platypusNextSequenceId; + } else { + ++soundCtr; + if (soundCtr % 4 == 0) + playSound(214, 0); + } + } + } else { + _s51_platypusNextSequenceId = 150 - (_s51_platypusJumpSequenceId - 150); + } + isCollision = false; + isIdle = false; + } + gameUpdateTick(); + } + + while (isKeyStatus2(Common::KEYCODE_LEFT) && _s51_platypusNextSequenceId != 0xB6) { + // pollMessages(); + scene51_updateItemAnimations(); + if (startWalk) { + _s51_platypusNextSequenceId = 0xA5; + startWalk = false; + } + + if (_gameSys->getAnimationStatus(0) == 2) { + int collisionX = scene51_checkCollision(_s51_platypusNextSequenceId); + if (collisionX) + scene51_incCashAmount(_s51_platypusNextSequenceId); + _gameSys->setAnimation(_s51_platypusNextSequenceId, 256, 0); + _gameSys->insertSequence(_s51_platypusNextSequenceId, 256, _s51_platypusSequenceId, 256, kSeqSyncWait, 0, collisionX, 0); + _s51_platypusSequenceId = _s51_platypusNextSequenceId; + if (collisionX) { + isCollision = true; + ++_s51_platypusJumpSequenceId; + _s51_platypusNextSequenceId = _s51_platypusJumpSequenceId; + } else { + _s51_platypusJumpSequenceId = _s51_platypusNextSequenceId; + } + if (scene51_isJumpingLeft(_s51_platypusJumpSequenceId)) { + ++_s51_platypusNextSequenceId; + if (!isCollision) { + if (isKeyStatus2(Common::KEYCODE_UP) || isKeyStatus2(Common::KEYCODE_SPACE)) { + clearKeyStatus1(Common::KEYCODE_UP); + clearKeyStatus1(Common::KEYCODE_SPACE); + scene51_waitForAnim(0); + _gameSys->setAnimation(0xB9, 256, 0); + _gameSys->insertSequence(0xB9, 256, _s51_platypusSequenceId, 256, kSeqSyncWait, 0, scene51_getPosLeft(_s51_platypusJumpSequenceId) - 338, 0); + _s51_platypusSequenceId = 0xB9; + scene51_waitForAnim(0); + _s51_platypusNextSequenceId += 6; + if (_s51_platypusNextSequenceId > 0xB5) + _s51_platypusNextSequenceId = 0xB5; + _s51_platypusJumpSequenceId = _s51_platypusNextSequenceId; + } else { + ++soundCtr; + if (soundCtr % 4 == 0) + playSound(214, 0); + } + } + } else { + _s51_platypusNextSequenceId = 182 - (_s51_platypusJumpSequenceId - 118); + } + isCollision = false; + isIdle = false; + } + gameUpdateTick(); + } + + if (!isIdle && _gameSys->getAnimationStatus(0) == 2) { + if (scene51_isJumpingRight(_s51_platypusJumpSequenceId)) { + _gameSys->setAnimation(0x74, 256, 0); + _gameSys->insertSequence(0x74, 256, _s51_platypusSequenceId, 256, kSeqSyncWait, 0, scene51_getPosRight(_s51_platypusJumpSequenceId) - 362, 0); + _s51_platypusSequenceId = 0x74; + } else { + _gameSys->setAnimation(0x75, 256, 0); + _gameSys->insertSequence(0x75, 256, _s51_platypusSequenceId, 256, kSeqSyncWait, 0, scene51_getPosLeft(_s51_platypusJumpSequenceId) - 341, 0); + _s51_platypusSequenceId = 0x75; + } + scene51_waitForAnim(0); + isIdle = true; + } + + } + + clearKeyStatus1(Common::KEYCODE_ESCAPE); + clearKeyStatus1(Common::KEYCODE_UP); + clearKeyStatus1(Common::KEYCODE_SPACE); + clearKeyStatus1(Common::KEYCODE_RIGHT); + clearKeyStatus1(Common::KEYCODE_LEFT); + + _gameSys->setAnimation(0, 0, 0); + for (int i = 0; i < 6; ++i) + _gameSys->setAnimation(0, 0, i + 1); + + showCursor(); + +} + +} // End of namespace Gnap diff --git a/engines/gnap/scenes/scene52.cpp b/engines/gnap/scenes/scene52.cpp new file mode 100644 index 0000000000..62cc2f3728 --- /dev/null +++ b/engines/gnap/scenes/scene52.cpp @@ -0,0 +1,907 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "gnap/gnap.h" +#include "gnap/gamesys.h" +#include "gnap/resource.h" + +namespace Gnap { + +int GnapEngine::scene52_init() { + scene52_initAnims(); + return 0x2B; +} + +void GnapEngine::scene52_updateHotspots() { + _hotspotsCount = 0; +} + +void GnapEngine::scene52_update() { + + for (int rowNum = 0; rowNum < 7; ++rowNum) { + gameUpdateTick(); + if (_gameSys->getAnimationStatus(_s52_alienRowAnims[rowNum]) == 2) { + scene52_updateAlienRow(rowNum); + rowNum = 0; + } + } + + if (_s52_liveAlienRows == 0 && !_s52_alienSingle) { + _s52_alienWave = false; + playSound(48, 0); + ++_s52_alienCounter; + if (_s52_alienCounter != 3) { + _timers[0] = 50; + _timers[2] = 100; + _s52_alienRowDownCtr = 0; + _s52_alienSingle = true; + } + } + + if (_s52_alienSingle && !_timers[0]) { + scene52_initAliens(); + _s52_alienSingle = false; + _timers[2] = 5; + _s52_alienWave = true; + } + + if ((_s52_alienRowDownCtr || _s52_liveAlienRows == 0) && !_s52_alienSingle) { + scene52_moveDownAlienRow(); + _s52_alienRowDownCtr = 0; + } + + if (isKeyStatus1(Common::KEYCODE_UP) || isKeyStatus1(Common::KEYCODE_SPACE)) { + clearKeyStatus1(Common::KEYCODE_SPACE); + clearKeyStatus1(Common::KEYCODE_UP); + if (!_s52_aliensCount) + scene52_fireShipCannon(_s52_shipPosX); + } + + if (_s52_shipCannonFiring) + scene52_updateShipCannon(); + + scene52_fireAlienCannon(); + scene52_updateAlienCannons(); + + if (_s52_aliensCount == 1) { + _s52_alienWave = false; + _timers[3] = 20; + _timers[2] = 100; + ++_s52_aliensCount; + } + + if (_s52_aliensCount && !_timers[3]) { + scene52_updateAliens(); + scene52_loseShip(); + if (_s52_shipsLeft != 0) { + _timers[3] = 40; + while (_timers[3]) { + scene52_updateAlienCannons(); + if (_s52_shipCannonFiring) + scene52_updateShipCannon(); + gameUpdateTick(); + } + scene52_initAliens(); + _s52_shipPosX = (800 - _s52_shipMidX) / 2; + _gameSys->setAnimation(_s52_nextUfoSequenceId, 256, 7); + _gameSys->insertSequence(_s52_nextUfoSequenceId, 256, 0, 0, kSeqNone, 0, _s52_shipPosX, _s52_arcadeScreenBottom); + _s52_ufoSequenceId = _s52_nextUfoSequenceId; + _timers[2] = 5; + _s52_alienWave = true; + } else { + _sceneDone = true; + } + } + + if (_timers[1] || scene52_getFreeShipCannon() == -1) { + _s52_nextUfoSequenceId = 34; + if (_s52_ufoSequenceId != 34) + _s52_shipFlag = true; + } else { + _s52_nextUfoSequenceId = 34; + if (_s52_ufoSequenceId != 34) + _s52_shipFlag = true; + } + + if (_s52_shipFlag) { + if (_gameSys->getAnimationStatus(7) == 2) { + _gameSys->setAnimation(_s52_nextUfoSequenceId, 256, 7); + _gameSys->insertSequence(_s52_nextUfoSequenceId, 256, _s52_ufoSequenceId, 256, kSeqSyncWait, 0, _s52_shipPosX, _s52_arcadeScreenBottom); + _s52_ufoSequenceId = _s52_nextUfoSequenceId; + } + _s52_shipFlag = false; + } + + if (_s52_alienWave && !_timers[0]) { + scene52_playSound(); + int v0 = _s52_alienSpeed; + if (_s52_alienSpeed >= 10) + v0 = 10; + int v1 = v0; + if (v0 < 2) + v1 = 2; + _timers[0] = v1; + } +} + +void GnapEngine::scene52_initShipCannon(int bottomY) { + _s52_shipCannonFired = 0; + _s52_shipCannonWidth = MAX(_gameSys->getSpriteWidthById(14), _gameSys->getSpriteWidthById(16)); + _s52_shipCannonHeight = MAX(_gameSys->getSpriteHeightById(14), _gameSys->getSpriteHeightById(16)); + _s52_shipCannonTopY = bottomY - _s52_shipCannonHeight; + _s52_shipCannonFiring = 0; +} + +void GnapEngine::scene52_initAlienCannons() { + for (int i = 0; i < 3; ++i) { + _s52_alienCannonIds[i] = 0; + _s52_alienCannonFired[i] = 0; + } + _s52_alienCannonSequenceIds[0] = 30; + _s52_alienCannonSequenceIds[1] = 31; + _s52_alienCannonSequenceIds[2] = 32; +} + +void GnapEngine::scene52_fireShipCannon(int posX) { + + if (_timers[1]) + return; + + int cannonNum = scene52_getFreeShipCannon(); + if (cannonNum != -1) { + _s52_shipCannonPosX = _s52_shipMidX / 2 + posX - _s52_shipCannonWidth / 2; + _s52_shipCannonPosY = _s52_shipCannonTopY; + _gameSys->setAnimation(0x23, cannonNum + 256, cannonNum + 8); + _gameSys->insertSequence(0x23, cannonNum + 256, 0, 0, kSeqNone, 0, _s52_shipCannonPosX, _s52_shipCannonPosY); + playSound(0x2D, 0); + if (scene52_shipCannonHitShield(cannonNum)) { + _gameSys->setAnimation(0, 0, cannonNum + 8); + _gameSys->removeSequence(0x23, cannonNum + 256, 1); + } else { + _s52_shipCannonFired = 1; + _s52_shipCannonPosY -= 13; + _s52_shipCannonFiring = 1; + } + _timers[1] = 5; + } + +} + +void GnapEngine::scene52_fireAlienCannon() { + + if (_timers[2]) + return; + + int cannonNum = scene52_getFreeAlienCannon(); + if (cannonNum != -1) { + int alienX1 = _s52_alienLeftX + _s52_alienRowXOfs[0]; + int alienX2 = _s52_alienLeftX + _s52_alienRowXOfs[0] + 5 * _s52_alienWidth - (_s52_alienWidth / 2 - 15); + _s52_alienCannonPosX[cannonNum] = getRandom(alienX2 - alienX1) + alienX1; + _s52_alienCannonPosY[cannonNum] = 104; + _s52_alienCannonFired[cannonNum] = 1; + _gameSys->setAnimation(_s52_alienCannonSequenceIds[cannonNum], _s52_alienCannonIds[cannonNum] + 256, cannonNum + 9); + _gameSys->insertSequence(_s52_alienCannonSequenceIds[cannonNum], _s52_alienCannonIds[cannonNum] + 256, 0, 0, + kSeqNone, 0, _s52_alienCannonPosX[cannonNum], _s52_alienCannonPosY[cannonNum]); + _s52_alienCannonPosY[cannonNum] -= 13; + _timers[2] = 5; + } + +} + +int GnapEngine::scene52_getFreeShipCannon() { + if (!_s52_shipCannonFired) + return 0; + return -1; +} + +int GnapEngine::scene52_getFreeAlienCannon() { + for (int i = 0; i < 3; ++i) + if (!_s52_alienCannonFired[i]) + return i; + return -1; +} + +void GnapEngine::scene52_updateShipCannon() { + if (_s52_shipCannonFired && _gameSys->getAnimationStatus(8) == 2) { + _s52_shipCannonPosY -= 13; + if (_s52_shipCannonPosY - 13 >= 135) { + if (scene52_updateHitAlien()) { + _gameSys->setAnimation(0, 0, 8); + _gameSys->removeSequence(35, 256, 1); + _s52_shipCannonFired = 0; + scene52_drawScore(_s52_gameScore); + } else { + _gameSys->setAnimation(35, 256, 8); + _gameSys->insertSequence(35, 256, 35, 256, kSeqSyncWait, 0, _s52_shipCannonPosX, _s52_shipCannonPosY); + _s52_shipCannonPosY -= 13; + } + } else { + _gameSys->setAnimation(0, 0, 8); + _gameSys->removeSequence(35, 256, 1); + _s52_shipCannonFired = 0; + } + } +} + +void GnapEngine::scene52_updateAlienCannons() { + for (int i = 0; i < 3; ++i) { + if (_s52_alienCannonFired[i] && _gameSys->getAnimationStatus(i + 9) == 2) { + _s52_alienCannonPosY[i] += 13; + if (_s52_shipCannonHeight + _s52_alienCannonPosY[i] + 13 <= 550) { + if (scene52_alienCannonHitShip(i)) { + _gameSys->setAnimation(0, 0, i + 9); + _s52_alienCannonFired[i] = 0; + scene52_shipExplode(); + } else if (scene52_alienCannonHitShield(i)) { + _s52_alienCannonFired[i] = 0; + } else { + _gameSys->insertSequence(_s52_alienCannonSequenceIds[i], 1 - _s52_alienCannonIds[i] + 256, 0, 0, + kSeqNone, 0, _s52_alienCannonPosX[i], _s52_alienCannonPosY[i]); + _gameSys->setAnimation(_s52_alienCannonSequenceIds[i], 1 - _s52_alienCannonIds[i] + 256, i + 9); + _s52_alienCannonIds[i] = 1 - _s52_alienCannonIds[i]; + _s52_alienCannonPosY[i] += 13; + } + } else { + _gameSys->setAnimation(0, 0, i + 9); + _s52_alienCannonFired[i] = 0; + } + } + } +} + +void GnapEngine::scene52_initAliens() { + + if (!_s52_aliensInitialized) { + scene52_initAlienSize(); + _s52_aliensInitialized = true; + } + + _s52_liveAlienRows = 0; + _s52_alienSpeed = 0; + _s52_bottomAlienFlag = false; + _s52_aliensCount = 0; + _s52_alienSingle = false; + _s52_alienRowDownCtr = 0; + + scene52_initShields(); + + _s52_alienRowKind[0] = -1; + _s52_alienRowKind[1] = -1; + _s52_alienRowKind[2] = -1; + _s52_alienRowKind[3] = -1; + _s52_alienRowKind[4] = getRandom(2) != 0 ? 24 : 27; + _s52_alienRowKind[5] = getRandom(2) != 0 ? 25 : 28; + _s52_alienRowKind[6] = getRandom(2) != 0 ? 26 : 29; + + for (int i = 0; i < 7; ++i) { + _s52_alienRowAnims[i] = i; + _s52_alienRowXOfs[i] = 0; + scene52_initAlienRowKind(i, _s52_alienRowKind[i]); + scene52_insertAlienRow(i); + } + +} + +void GnapEngine::scene52_initAlienRowKind(int rowNum, int alienKind) { + for (int i = 0; i < 5; ++i) + _s52_items[rowNum][i] = alienKind; +} + +void GnapEngine::scene52_insertAlienRow(int rowNum) { + if (_s52_alienRowKind[rowNum] >= 0) { + scene52_insertAlienRowAliens(rowNum); + _s52_alienRowIds[rowNum] = 256; + _gameSys->setAnimation(_s52_alienRowKind[rowNum], _s52_alienRowIds[rowNum], _s52_alienRowAnims[rowNum]); + ++_s52_liveAlienRows; + } +} + +void GnapEngine::scene52_insertAlienRowAliens(int rowNum) { + int xOffs = _s52_alienLeftX; + int yOffs = _s52_alienTopY - 52 * rowNum - _s52_alienHeight + 10; + for (int i = 0; i < 5; ++i) { + if (_s52_items[rowNum][i] >= 0) { + _gameSys->insertSequence(_s52_items[rowNum][i], i + 256, 0, 0, kSeqNone, 0, xOffs, yOffs); + ++_s52_alienSpeed; + } + xOffs += _s52_alienWidth; + } +} + +void GnapEngine::scene52_updateAlienRow(int rowNum) { + + if (_s52_alienRowKind[rowNum] != -1 && !scene52_checkAlienRow(rowNum)) { + scene52_updateAlienRowXOfs(); + _s52_alienRowIds[rowNum] = -1; + int xOffs = _s52_alienLeftX + _s52_alienRowXOfs[rowNum]; + int yOffs = _s52_alienTopY - 52 * rowNum - _s52_alienHeight + 10; + for (int i = 0; i < 5; ++i) { + if (_s52_items[rowNum][i] >= 0) { + _gameSys->insertSequence(_s52_items[rowNum][i], i + 256, _s52_items[rowNum][i], i + 256, kSeqSyncWait, 0, xOffs, yOffs); + if (_s52_alienRowIds[rowNum] == -1) + _s52_alienRowIds[rowNum] = i + 256; + } else if (_s52_items[rowNum][i] == -2) { + _gameSys->removeSequence(_s52_alienRowKind[rowNum], i + 256, 1); + _s52_items[rowNum][i] = -1; + --_s52_alienSpeed; + } + xOffs += _s52_alienWidth; + } + if (_s52_alienRowIds[rowNum] == -1) { + _gameSys->setAnimation(0, 0, _s52_alienRowAnims[rowNum]); + // MessageBoxA(0, "No live aliens!", "Error 3:", 0x30u); + } else { + _gameSys->setAnimation(_s52_alienRowKind[rowNum], _s52_alienRowIds[rowNum], _s52_alienRowAnims[rowNum]); + } + if (rowNum == 1) { + for (int j = 0; j < 3; ++j) { + if (_s52_shieldSpriteIds[j] != -1) { + _gameSys->fillSurface(0, _s52_shieldPosX[j], _s52_arcadeScreenBottom - 44, 33, 44, 0, 0, 0); + _s52_shieldSpriteIds[j] = -1; + } + } + } + if (rowNum == 0 && _s52_bottomAlienFlag) + scene52_shipExplode(); + } +} + +void GnapEngine::scene52_moveDownAlienRow() { + + int v2[5], v3, v1, v0, v4; + + for (int i = 0; i < 5; ++i) + v2[i] = _s52_items[0][i]; + + v3 = _s52_alienRowIds[0]; + v1 = _s52_alienRowAnims[0]; + v0 = _s52_alienRowKind[0]; + v4 = _s52_alienRowXOfs[0]; + + for (int j = 0; j < 7; ++j) { + for (int i = 0; i < 5; ++i) + _s52_items[j][i] = _s52_items[j + 1][i]; + _s52_alienRowIds[j] = _s52_alienRowIds[j + 1]; + _s52_alienRowAnims[j] = _s52_alienRowAnims[j + 1]; + _s52_alienRowKind[j] = _s52_alienRowKind[j + 1]; + _s52_alienRowXOfs[j] = _s52_alienRowXOfs[j + 1]; + } + + for (int i = 0; i < 5; ++i) + _s52_items[6][i] = v2[i]; + + _s52_alienRowIds[6] = v3; + _s52_alienRowAnims[6] = v1; + _s52_alienRowKind[6] = v0; + _s52_alienRowXOfs[6] = v4; + + scene52_updateAlien(6); + scene52_initAlienRowKind(6, _s52_alienRowKind[6]); + scene52_insertAlienRow(6); + + _s52_bottomAlienFlag = _s52_alienRowKind[0] > -1; +} + +int GnapEngine::scene52_updateHitAlien() { + int result = 0, rowNum, ya; + + int y = _s52_shipCannonTopY - _s52_shipCannonPosY; + + if (y == 26) { + rowNum = 1; + ya = _s52_shipCannonPosY + 26; + } else { + if (y % 52) + return 0; + rowNum = y / 52 + 1; + ya = _s52_shipCannonPosY; + } + + if (rowNum < 7) { + int hitAlienNum = scene52_getHitAlienNum(rowNum); + if (hitAlienNum != -1 && _s52_items[rowNum][hitAlienNum] >= 0) { + _s52_gameScore = ((_s52_items[rowNum][hitAlienNum] - 24) % 3 + _s52_gameScore + 1) % 1000; + _s52_items[rowNum][hitAlienNum] = -2; + playSound(44, 0); + _gameSys->insertSequence(0x21, 266, 0, 0, + kSeqNone, 0, _s52_alienLeftX + hitAlienNum * _s52_alienWidth + _s52_alienRowXOfs[rowNum] - 10, ya - _s52_alienHeight); + result = 1; + } + } + + return result; +} + +int GnapEngine::scene52_getHitAlienNum(int rowNum) { + + int result = -1; + + int v3 = _s52_alienLeftX + _s52_alienRowXOfs[rowNum]; + + if (_s52_shipCannonPosX >= v3) { + int v8 = _s52_alienWidth / 2 - 15; + if (v3 + 5 * _s52_alienWidth - v8 >= _s52_shipCannonPosX) { + int v4 = v3 + _s52_alienWidth; + if (_s52_shipCannonPosX >= v4 - v8) { + int v5 = v4 + _s52_alienWidth; + if (_s52_shipCannonPosX >= v5 - v8) { + int v6 = v5 + _s52_alienWidth; + if (_s52_shipCannonPosX >= v6 - v8) { + int v7 = v6 + _s52_alienWidth; + if (_s52_shipCannonPosX >= v7 - v8) { + if (_s52_shipCannonPosX >= v7 + _s52_alienWidth - v8) + result = -1; + else + result = 4; + } else { + result = 3; + } + } else { + result = 2; + } + } else { + result = 1; + } + } else { + result = 0; + } + } else { + result = -1; + } + } else { + result = -1; + } + return result; +} + +int GnapEngine::scene52_alienCannonHitShip(int cannonNum) { + int result = 0; + + if (_s52_aliensCount) { + result = 0; + } else { + int cannonY = _s52_alienCannonPosY[cannonNum] - 13; + if (_s52_arcadeScreenBottom <= cannonY) { + if (_s52_shipMidY + _s52_arcadeScreenBottom > cannonY) { + if (_s52_alienCannonPosX[cannonNum] >= _s52_shipPosX) + result = _s52_alienCannonPosX[cannonNum] < _s52_shipMidX + _s52_shipPosX; + else + result = 0; + } else { + result = 0; + } + } else { + result = 0; + } + } + return result; +} + +int GnapEngine::scene52_alienCannonHitShield(int cannonNum) { + int result = 0; + + int v3 = _s52_alienCannonPosY[cannonNum] + 39; + if (_s52_arcadeScreenBottom - 44 > v3) + return 0; + + if (_s52_arcadeScreenBottom <= v3) + return 0; + + if (_s52_alienCannonPosX[cannonNum] < _s52_shieldPosX[0]) + return 0; + + if (_s52_alienCannonPosX[cannonNum] > _s52_shieldPosX[2] + 33) + return 0; + + int shieldNum = -1; + if (_s52_alienCannonPosX[cannonNum] < _s52_shieldPosX[0] + 33) + shieldNum = 0; + + if (shieldNum < 0 && _s52_alienCannonPosX[cannonNum] < _s52_shieldPosX[1]) + return 0; + + if (shieldNum < 0 && _s52_alienCannonPosX[cannonNum] < _s52_shieldPosX[1] + 33) + shieldNum = 1; + + if (shieldNum < 0) { + if (_s52_alienCannonPosX[cannonNum] < _s52_shieldPosX[2]) + return 0; + shieldNum = 2; + } + + if (_s52_shieldSpriteIds[shieldNum] == -1) { + result = 0; + } else { + ++_s52_shieldSpriteIds[shieldNum]; + if (_s52_shieldSpriteIds[shieldNum] <= 21) { + _gameSys->drawSpriteToBackground(_s52_shieldPosX[shieldNum], _s52_arcadeScreenBottom - 44, _s52_shieldSpriteIds[shieldNum]); + } else { + _gameSys->fillSurface(0, _s52_shieldPosX[shieldNum], _s52_arcadeScreenBottom - 44, 33, 44, 0, 0, 0); + _s52_shieldSpriteIds[shieldNum] = -1; + } + _gameSys->setAnimation(0, 0, cannonNum + 9); + _gameSys->insertSequence(0x21, shieldNum + 257, 0, 0, kSeqNone, 0, _s52_alienCannonPosX[cannonNum] - 18, _s52_arcadeScreenBottom - 44); + playSound(0x2C, 0); + result = 1; + } + + return result; +} + +int GnapEngine::scene52_shipCannonHitShield(int cannonNum) { + int result = 0; + + if (_s52_shipCannonPosX < _s52_shieldPosX[0]) + return 0; + + if (_s52_shipCannonPosX > _s52_shieldPosX[2] + 33) + return 0; + + int shieldNum = -1; + if (_s52_shipCannonPosX < _s52_shieldPosX[0] + 33) + shieldNum = 0; + + if (shieldNum < 0 && _s52_shipCannonPosX < _s52_shieldPosX[1]) + return 0; + + if (shieldNum < 0 && _s52_shipCannonPosX < _s52_shieldPosX[1] + 33) + shieldNum = 1; + + if (shieldNum < 0) { + if (_s52_shipCannonPosX < _s52_shieldPosX[2]) + return 0; + shieldNum = 2; + } + + if (_s52_shieldSpriteIds[shieldNum] == -1) { + result = 0; + } else { + ++_s52_shieldSpriteIds[shieldNum]; + if (_s52_shieldSpriteIds[shieldNum] <= 21) { + _gameSys->drawSpriteToBackground(_s52_shieldPosX[shieldNum], _s52_arcadeScreenBottom - 44, _s52_shieldSpriteIds[shieldNum]); + } else { + _gameSys->fillSurface(0, _s52_shieldPosX[shieldNum], _s52_arcadeScreenBottom - 44, 33, 44, 0, 0, 0); + _s52_shieldSpriteIds[shieldNum] = -1; + } + _gameSys->insertSequence(0x21, shieldNum + 257, 0, 0, kSeqNone, 0, _s52_shipCannonPosX - 18, _s52_arcadeScreenBottom - 44); + playSound(0x2C, 0); + result = 1; + } + + return result; +} + +int GnapEngine::scene52_shipCannonHitAlien() { + int result = 0; + + if (_s52_aliensCount) { + result = 0; + } else if (scene52_checkAlienRow(0)) { + result = 0; + } else { + int v1 = _s52_alienLeftX + _s52_alienRowXOfs[0]; + if (_s52_shipMidX + _s52_shipPosX >= _s52_alienLeftX + _s52_alienRowXOfs[0]) { + int v7 = _s52_alienWidth / 2 - 15; + if (v1 + 5 * _s52_alienWidth - v7 >= _s52_shipPosX) { + int v2 = v1 + _s52_alienWidth; + if (_s52_items[0][0] <= -1 || v2 - v7 <= _s52_shipPosX) { + int v3 = v2 + _s52_alienWidth; + if (_s52_items[0][1] <= -1 || v3 - v7 <= _s52_shipPosX) { + int v4 = v3 + _s52_alienWidth; + if (_s52_items[0][2] <= -1 || v4 - v7 <= _s52_shipPosX) { + int v5 = v4 + _s52_alienWidth; + if (_s52_items[0][3] <= -1 || v5 - v7 <= _s52_shipPosX) { + int v6 = v5 + _s52_alienWidth; + result = _s52_items[0][4] > -1 && v6 - v7 > _s52_shipPosX; + } else { + result = 1; + } + } else { + result = 1; + } + } else { + result = 1; + } + } else { + result = 1; + } + } else { + result = 0; + } + } else { + result = 0; + } + } + + return result; +} + +void GnapEngine::scene52_shipExplode() { + if (!_s52_aliensCount) { + _gameSys->setAnimation(0, 0, 7); + _gameSys->removeSequence(_s52_ufoSequenceId, 256, 1); + playSound(44, 0); + _gameSys->insertSequence(0x21, 266, 0, 0, kSeqNone, 0, _s52_shipPosX, _s52_arcadeScreenBottom); + _s52_aliensCount = 1; + playSound(0x31, 0); + } +} + +int GnapEngine::scene52_checkAlienRow(int rowNum) { + + int v4 = 0; + + for (int i = 0; i < 5; ++i) + if (_s52_items[rowNum][i] >= 0) + return 0; + + for (int j = 0; j < 5; ++j) + if (_s52_items[rowNum][j] == -2) { + _gameSys->removeSequence(_s52_alienRowKind[rowNum], j + 256, 1); + _s52_items[rowNum][j] = -1; + --_s52_alienSpeed; + v4 = 1; + } + + if (v4) { + _gameSys->setAnimation(0, 0, _s52_alienRowAnims[rowNum]); + --_s52_liveAlienRows; + } + + if (_s52_liveAlienRows < 0) + _s52_liveAlienRows = 0; + + return 1; +} + +void GnapEngine::scene52_updateAlienRowXOfs() { + + int amount = 2 * (3 - _s52_liveAlienRows) + 1; + + if (_s52_alienSpeed == 2) + amount *= 4; + else if (_s52_alienSpeed == 1) + amount *= 10; + + if (_s52_alienDirection) { + for (int i = 0; i < 7; ++i) { + _s52_alienRowXOfs[i] -= amount; + if (_s52_alienRowXOfs[i] <= -100) { + _s52_alienRowXOfs[i] = -100; + _s52_alienDirection = 0; + ++_s52_alienRowDownCtr; + } + } + } else { + for (int j = 0; j < 7; ++j) { + _s52_alienRowXOfs[j] += amount; + if (_s52_alienRowXOfs[j] >= 100) { + _s52_alienRowXOfs[j] = 100; + _s52_alienDirection = 1; + ++_s52_alienRowDownCtr; + } + } + } + +} + +void GnapEngine::scene52_initAlienSize() { + + _s52_alienWidth = _gameSys->getSpriteWidthById(0); + if (_gameSys->getSpriteWidthById(1) > _s52_alienWidth) + _s52_alienWidth = _gameSys->getSpriteWidthById(1); + if (_gameSys->getSpriteWidthById(4) > _s52_alienWidth) + _s52_alienWidth = _gameSys->getSpriteWidthById(4); + if (_gameSys->getSpriteWidthById(5) > _s52_alienWidth) + _s52_alienWidth = _gameSys->getSpriteWidthById(5); + if (_gameSys->getSpriteWidthById(12) > _s52_alienWidth) + _s52_alienWidth = _gameSys->getSpriteWidthById(12); + if (_gameSys->getSpriteWidthById(13) > _s52_alienWidth) + _s52_alienWidth = _gameSys->getSpriteWidthById(13); + + _s52_alienHeight = _gameSys->getSpriteHeightById(0); + if (_gameSys->getSpriteHeightById(1) > _s52_alienHeight) + _s52_alienHeight = _gameSys->getSpriteHeightById(1); + if (_gameSys->getSpriteHeightById(4) > _s52_alienHeight) + _s52_alienHeight = _gameSys->getSpriteHeightById(4); + if (_gameSys->getSpriteHeightById(5) > _s52_alienHeight) + _s52_alienHeight = _gameSys->getSpriteHeightById(5); + if (_gameSys->getSpriteHeightById(12) > _s52_alienHeight) + _s52_alienHeight = _gameSys->getSpriteHeightById(12); + if (_gameSys->getSpriteHeightById(13) > _s52_alienHeight) + _s52_alienHeight = _gameSys->getSpriteHeightById(13); + + _s52_alienTopY = _s52_shipCannonTopY + 52; + _s52_alienLeftX = (800 - 5 * _s52_alienWidth) / 2; + +} + +void GnapEngine::scene52_playSound() { + if (_s52_soundToggle) { + playSound(0x2F, 0); + _s52_soundToggle = false; + } else { + playSound(0x2E, 0); + _s52_soundToggle = true; + } +} + +void GnapEngine::scene52_updateAliens() { + for (int i = 0; i < 7; ++i) + scene52_updateAlien(i); +} + +void GnapEngine::scene52_updateAlien(int rowNum) { + if (_s52_alienRowKind[rowNum] >= 0 && !scene52_checkAlienRow(rowNum)) { + for (int i = 0; i < 5; ++i) + if (_s52_items[rowNum][i] >= 0) + _s52_items[rowNum][i] = -2; + scene52_checkAlienRow(rowNum); + } +} + +void GnapEngine::scene52_loseShip() { + --_s52_shipsLeft; + if (_s52_shipsLeft == 2) { + _gameSys->fillSurface(0, 120, 140, _s52_shipMidX, _s52_shipMidY, 0, 0, 0); + } else if (_s52_shipsLeft == 1) { + _gameSys->fillSurface(0, 120, 185, _s52_shipMidX, _s52_shipMidY, 0, 0, 0); + } +} + +void GnapEngine::scene52_initShields() { + for (int i = 0; i < 3; ++i) { + _gameSys->drawSpriteToBackground(_s52_shieldPosX[i], _s52_arcadeScreenBottom - 44, 17); + _s52_shieldSpriteIds[i] = 17; + } +} + +void GnapEngine::scene52_initAnims() { + for (int i = 0; i < 7; ++i) + _gameSys->setAnimation(0, 0, i); + _gameSys->setAnimation(0, 0, 7); + for (int j = 0; j < 1; ++j) + _gameSys->setAnimation(0, 0, j + 8); + for (int k = 0; k < 3; ++k) + _gameSys->setAnimation(0, 0, k + 9); +} + +void GnapEngine::scene52_drawScore(int a1) { + char str[4]; + sprintf(str, "%03d", a1); + _gameSys->fillSurface(0, 420, 80, 48, 30, 0, 0, 0); + _gameSys->drawTextToSurface(0, 420, 80, 255, 255, 255, str); +} + +void GnapEngine::scene52_run() { + + _timers[1] = 0; + + hideCursor(); + + // TODO loadFont("maturasc", "Matura MT Script Capitals", 2000); + // TODO setFontSize(24); + + _s52_gameScore = 0; + _gameSys->drawTextToSurface(0, 300, 80, 255, 255, 255, "SCORE"); + _gameSys->drawTextToSurface(0, 468, 80, 255, 255, 255, "0"); + + scene52_drawScore(0); + + _s52_shipMidX = 33; + _s52_shipMidY = _gameSys->getSpriteHeightById(15); + _s52_shipPosX = (800 - _s52_shipMidX) / 2; + _s52_arcadeScreenBottom = 496; + _s52_arcadeScreenRight = 595 - _s52_shipMidX; + _s52_arcadeScreenLeft = 210; + _s52_shipsLeft = 3; + _s52_alienCounter = 0; + + _s52_shieldPosX[0] = 247; + _s52_shieldPosX[1] = 387; + _s52_shieldPosX[2] = 525; + + for (int i = 0; i < 3; ++i) + _s52_shieldSpriteIds[i] = -1; + + _gameSys->drawSpriteToBackground(120, 140, 0xF); + _gameSys->drawSpriteToBackground(120, 185, 0xF); + + scene52_initShipCannon(_s52_arcadeScreenBottom); + scene52_initAlienCannons(); + scene52_initAliens(); + + _s52_nextUfoSequenceId = 0x22; + _gameSys->setAnimation(0x22, 256, 7); + _gameSys->insertSequence(_s52_nextUfoSequenceId, 256, 0, 0, kSeqNone, 0, _s52_shipPosX, _s52_arcadeScreenBottom); + + _s52_ufoSequenceId = _s52_nextUfoSequenceId; + + clearKeyStatus1(Common::KEYCODE_RIGHT); + clearKeyStatus1(Common::KEYCODE_LEFT); + clearKeyStatus1(Common::KEYCODE_SPACE); + clearKeyStatus1(Common::KEYCODE_UP); + clearKeyStatus1(Common::KEYCODE_ESCAPE); + + _timers[2] = 5; + _s52_shipFlag = false; + + _timers[0] = 10; + _s52_alienWave = true; + + while (!_sceneDone) { + + gameUpdateTick(); + + while (isKeyStatus2(Common::KEYCODE_RIGHT)) { + scene52_update(); + if (_gameSys->getAnimationStatus(7) == 2) { + if (_s52_shipPosX < _s52_arcadeScreenRight) { + _s52_shipPosX += 15; + if (_s52_shipPosX > _s52_arcadeScreenRight) + _s52_shipPosX = _s52_arcadeScreenRight; + _gameSys->setAnimation(_s52_nextUfoSequenceId, 256, 7); + _gameSys->insertSequence(_s52_nextUfoSequenceId, 256, _s52_ufoSequenceId, 256, kSeqSyncWait, 0, _s52_shipPosX, _s52_arcadeScreenBottom); + _s52_ufoSequenceId = _s52_nextUfoSequenceId; + if (_s52_bottomAlienFlag && scene52_shipCannonHitAlien()) + scene52_shipExplode(); + } + break; + } + } + + while (isKeyStatus2(Common::KEYCODE_LEFT)) { + scene52_update(); + if (_gameSys->getAnimationStatus(7) == 2) { + if (_s52_shipPosX > _s52_arcadeScreenLeft) { + _s52_shipPosX -= 15; + if (_s52_shipPosX < _s52_arcadeScreenLeft) + _s52_shipPosX = _s52_arcadeScreenLeft; + _gameSys->setAnimation(_s52_nextUfoSequenceId, 256, 7); + _gameSys->insertSequence(_s52_nextUfoSequenceId, 256, _s52_ufoSequenceId, 256, kSeqSyncWait, 0, _s52_shipPosX, _s52_arcadeScreenBottom); + _s52_ufoSequenceId = _s52_nextUfoSequenceId; + if (_s52_bottomAlienFlag && scene52_shipCannonHitAlien()) + scene52_shipExplode(); + } + break; + } + } + + scene52_update(); + + if (sceneXX_sub_4466B1()) { + _s52_alienWave = false; + _gameSys->waitForUpdate(); + scene52_initAnims(); + clearKeyStatus1(30); + _sceneDone = true; + } + + } + + // TODO freeFont(); + + _gameSys->waitForUpdate(); + +} + +} // End of namespace Gnap diff --git a/engines/gnap/scenes/scene53.cpp b/engines/gnap/scenes/scene53.cpp new file mode 100644 index 0000000000..20486eb34e --- /dev/null +++ b/engines/gnap/scenes/scene53.cpp @@ -0,0 +1,383 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "gnap/gnap.h" +#include "gnap/gamesys.h" +#include "gnap/resource.h" + +namespace Gnap { + +int GnapEngine::scene53_init() { + _gameSys->setAnimation(0, 0, 0); + _gameSys->setAnimation(0, 0, 1); + return 0x75; +} + +void GnapEngine::scene53_updateHotspots() { + setHotspot(0, 0, 0, 0, 0, SF_WALKABLE | SF_TALK_CURSOR | SF_GRAB_CURSOR | SF_LOOK_CURSOR); + setHotspot(2, 336, 361, 238, 270, SF_GRAB_CURSOR); + setHotspot(3, 376, 405, 243, 274, SF_GRAB_CURSOR); + setHotspot(4, 415, 441, 248, 276, SF_GRAB_CURSOR); + setHotspot(5, 329, 358, 276, 303, SF_GRAB_CURSOR); + setHotspot(6, 378, 408, 282, 311, SF_GRAB_CURSOR); + setHotspot(7, 417, 446, 286, 319, SF_GRAB_CURSOR); + setHotspot(8, 332, 361, 311, 342, SF_GRAB_CURSOR); + setHotspot(9, 376, 407, 318, 349, SF_GRAB_CURSOR); + setHotspot(10, 417, 447, 320, 353, SF_GRAB_CURSOR); + setHotspot(11, 377, 405, 352, 384, SF_GRAB_CURSOR); + setHotspot(12, 419, 450, 358, 394, SF_GRAB_CURSOR); + setHotspot(13, 328, 359, 346, 379, SF_GRAB_CURSOR); + setHotspot(14, 150, 650, 585, 600, SF_EXIT_D_CURSOR); + setDeviceHotspot(1, -1, -1, -1, -1); + _hotspotsCount = 15; +} + +int GnapEngine::scene53_pressPhoneNumberButton(int phoneNumber, int buttonNum) { + + static const int kGnapHandSequenceIds[13] = { + 0x00, + 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, + 0x4C, 0x4D, 0x4E, 0x50, 0x51, 0x4F + }; + + static const int kPlatypusHandSequenceIds[13] = { + 0x00, + 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, + 0x58, 0x59, 0x5A, 0x5C, 0x5D, 0x5B + }; + + if (_s53_isGnapPhoning) { + _gameSys->setAnimation(kGnapHandSequenceIds[buttonNum], 40, 6); + _gameSys->insertSequence(kGnapHandSequenceIds[buttonNum], 40, _s53_currHandSequenceId, 40, kSeqSyncWait, 0, 0, 0); + _s53_currHandSequenceId = kGnapHandSequenceIds[buttonNum]; + } else { + _gameSys->setAnimation(kPlatypusHandSequenceIds[buttonNum], 40, 6); + _gameSys->insertSequence(kPlatypusHandSequenceIds[buttonNum], 40, _s53_currHandSequenceId, 40, kSeqSyncWait, 0, 0, 0); + _s53_currHandSequenceId = kPlatypusHandSequenceIds[buttonNum]; + } + + _gnapActionStatus = 6; + while (_gameSys->getAnimationStatus(6) != 2) { + // checkGameAppStatus(); + updateMouseCursor(); + gameUpdateTick(); + } + _gnapActionStatus = -1; + + if (buttonNum < 11) + phoneNumber = buttonNum % 10 + 10 * phoneNumber; + + return phoneNumber; +} + +int GnapEngine::scene53_getRandomCallIndex() { + int index, tries = 0; + if (_s53_callsRndUsed == 0x7FFF) + _s53_callsRndUsed = 0; + do { + index = getRandom(16); + if (++tries == 300) + _s53_callsRndUsed = 0; + } while (_s53_callsRndUsed & (1 << index)); + _s53_callsRndUsed |= (1 << index); + return index; +} + +void GnapEngine::scene53_runRandomCall() { + + static const int kCallSequenceIds[15] = { + 0x60, 0x61, 0x62, 0x63, 0x64, + 0x65, 0x66, 0x67, 0x68, 0x69, + 0x6A, 0x6B, 0x6C, 0x6D, 0x71 + }; + + int index; + + ++_s53_callsMadeCtr; + + if (_s53_callsMadeCtr <= 10) { + do { + index = scene53_getRandomCallIndex(); + } while (!_s53_isGnapPhoning && (index == 0 || index == 3 || index == 4 || index == 11)); + _gameSys->setAnimation(kCallSequenceIds[index], 1, 6); + _gameSys->insertSequence(kCallSequenceIds[index], 1, 0, 0, kSeqNone, 16, 0, 0); + } else { + _gameSys->setAnimation(0x74, 1, 6); + _gameSys->insertSequence(0x74, 1, 0, 0, kSeqNone, 16, 0, 0); + _s53_callsMadeCtr = 0; + } + + _gnapActionStatus = 1; + while (_gameSys->getAnimationStatus(6) != 2) { + updateMouseCursor(); + // checkGameAppStatus(); + gameUpdateTick(); + } + _gnapActionStatus = -1; + +} + +void GnapEngine::scene53_runChitChatLine() { + bool flag = false; + int sequenceId; + + _gameSys->setAnimation(0x6E, 1, 6); + _gameSys->insertSequence(0x6E, 1, 0, 0, kSeqNone, 16, 0, 0); + + _gnapActionStatus = 1; + while (_gameSys->getAnimationStatus(6) != 2) { + updateMouseCursor(); + // checkGameAppStatus(); + gameUpdateTick(); + } + _gnapActionStatus = -1; + + if (isFlag(15)) { + _gameSys->insertSequence(0x45, 40, _s53_currHandSequenceId, 40, kSeqSyncWait, 0, 0, 0); + _s53_currHandSequenceId = 0x45; + } else { + _gameSys->insertSequence(0x45, 40, _s53_currHandSequenceId, 40, kSeqSyncWait, 0, 0, 0); + _s53_currHandSequenceId = 0x5E; + } + + _hotspots[1].flags = SF_DISABLED; + + while (!flag) { + + updateMouseCursor(); + updateCursorByHotspot(); + + testWalk(0, 0, -1, -1, -1, -1); + + _sceneClickedHotspot = getClickedHotspotId(); + + updateGrabCursorSprite(0, 0); + + switch (_sceneClickedHotspot) { + case 2: + sequenceId = 0x6F; + flag = 1; + break; + case 3: + sequenceId = 0x70; + flag = 1; + break; + case 4: + sequenceId = 0x71; + flag = 1; + break; + case 14: + sequenceId = -1; + flag = 1; + _isLeavingScene = true; + _sceneDone = 1; + _gnapActionStatus = 0; + _newSceneNum = 17; + break; + case 5: + case 6: + case 7: + case 8: + case 9: + case 10: + case 11: + case 12: + case 13: + scene53_pressPhoneNumberButton(0, _sceneClickedHotspot - 1); + break; + } + + if (flag && sequenceId != -1) { + stopSound(0xA0); + scene53_pressPhoneNumberButton(0, _sceneClickedHotspot - 1); + _gnapActionStatus = 1; + _gameSys->setAnimation(sequenceId, 1, 6); + _gameSys->insertSequence(sequenceId, 1, 0, 0, kSeqNone, 16, 0, 0); + _gnapActionStatus = 1; + while (_gameSys->getAnimationStatus(6) != 2) { + updateMouseCursor(); + // checkGameAppStatus(); + gameUpdateTick(); + } + _gnapActionStatus = -1; + _gameSys->setAnimation(0x72, 1, 6); + _gameSys->insertSequence(0x72, 1, 0, 0, kSeqNone, 16, 0, 0); + _gnapActionStatus = 1; + while (_gameSys->getAnimationStatus(6) != 2) { + updateMouseCursor(); + // checkGameAppStatus(); + gameUpdateTick(); + } + _gnapActionStatus = -1; + } + + } + + scene53_updateHotspots(); + + _gnapActionStatus = 1; + + if (isFlag(15)) { + _gameSys->setAnimation(0x73, 40, 6); + _gameSys->insertSequence(0x73, 40, _s53_currHandSequenceId, 40, kSeqSyncWait, 0, 0, 0); + while (_gameSys->getAnimationStatus(6) != 2) { + updateMouseCursor(); + // checkGameAppStatus(); + gameUpdateTick(); + } + _s53_currHandSequenceId = 0x73; + _gnapActionStatus = -1; + } + +} + +void GnapEngine::scene53_run() { + int phoneNumber = 0; + int phoneNumberLen = 0; + + queueInsertDeviceIcon(); + + if (isFlag(15)) { + _s53_currHandSequenceId = 0x45; + _s53_isGnapPhoning = true; + } else { + _s53_currHandSequenceId = 0x5E; + _s53_isGnapPhoning = false; + } + + _gameSys->insertSequence(_s53_currHandSequenceId, 40, 0, 0, kSeqNone, 0, 0, 0); + + endSceneInit(); + + setVerbCursor(GRAB_CURSOR); + + playSound(0xA0, 1); + + while (!_sceneDone) { + + updateMouseCursor(); + updateCursorByHotspot(); + + testWalk(0, 0, -1, -1, -1, -1); + + _sceneClickedHotspot = getClickedHotspotId(); + updateGrabCursorSprite(0, 0); + + switch (_sceneClickedHotspot) { + case 1: + if (_gnapActionStatus < 0) { + runMenu(); + scene53_updateHotspots(); + } + break; + case 2: + case 3: + case 4: + case 5: + case 6: + case 7: + case 8: + case 9: + case 10: + case 11: + stopSound(0xA0); + ++phoneNumberLen; + phoneNumber = scene53_pressPhoneNumberButton(phoneNumber, _sceneClickedHotspot - 1); + debug("phoneNumber: %d", phoneNumber); + if (phoneNumberLen == 7) { + _gnapActionStatus = 1; + if (isFlag(15)) { + _gameSys->setAnimation(0x73, 40, 6); + _gameSys->insertSequence(0x73, 40, _s53_currHandSequenceId, 40, kSeqSyncWait, 0, 0, 0); + while (_gameSys->getAnimationStatus(6) != 2) { + updateMouseCursor(); + // checkGameAppStatus(); + gameUpdateTick(); + } + _s53_currHandSequenceId = 0x73; + _gnapActionStatus = -1; + } + if (phoneNumber == 7284141) { + scene53_runChitChatLine(); + phoneNumber = 0; + phoneNumberLen = 0; + _sceneDone = 1; + _newSceneNum = 17; + } else if (phoneNumber != 5556789 || isFlag(20)) { + scene53_runRandomCall(); + phoneNumber = 0; + phoneNumberLen = 0; + _sceneDone = 1; + _newSceneNum = 17; + } else { + phoneNumber = 0; + phoneNumberLen = 0; + _sceneDone = 1; + _newSceneNum = 17; + if (_s53_isGnapPhoning) + setFlag(25); + else + setFlag(26); + } + } + break; + case 12: + case 13: + scene53_pressPhoneNumberButton(0, _sceneClickedHotspot - 1); + break; + case 14: + if (_gnapActionStatus < 0) { + _gnapActionStatus = 1; + if (isFlag(15)) { + _gameSys->setAnimation(0x73, 40, 6); + _gameSys->insertSequence(0x73, 40, _s53_currHandSequenceId, 40, kSeqSyncWait, 0, 0, 0); + while (_gameSys->getAnimationStatus(6) != 2) { + updateMouseCursor(); + // checkGameAppStatus(); + gameUpdateTick(); + } + _s53_currHandSequenceId = 0x73; + _gnapActionStatus = -1; + } + _isLeavingScene = true; + _sceneDone = 1; + _gnapActionStatus = 0; + _newSceneNum = 17; + } + break; + } + + checkGameKeys(); + + if (isKeyStatus1(8)) { + clearKeyStatus1(8); + runMenu(); + scene53_updateHotspots(); + } + + gameUpdateTick(); + + } + +} + +} // End of namespace Gnap diff --git a/engines/gnap/scenes/scene54.cpp b/engines/gnap/scenes/scene54.cpp new file mode 100644 index 0000000000..76bc66b9f3 --- /dev/null +++ b/engines/gnap/scenes/scene54.cpp @@ -0,0 +1,127 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "gnap/gnap.h" +#include "gnap/gamesys.h" +#include "gnap/resource.h" + +namespace Gnap { + +void GnapEngine::scene54_initCutscene1() { + _s99_dword_47F370[0] = 0x1BE; + _s99_dword_47F370[1] = 0x1BF; + _s99_dword_47F370[2] = 0x1BA; + _s99_dword_47F370[3] = 0x1BB; + _s99_dword_47F370[4] = 0x1BD; + _s99_dword_47F370[5] = 0x1BC; + _s99_dword_47F2F0[0] = 0x3C; + _s99_dword_47F2F0[1] = 0x43; + _s99_dword_47F2F0[2] = 0x44; + if (isFlag(20)) + _s99_dword_47F2F0[3] = 0x47; + else + _s99_dword_47F2F0[3] = 0x46; + _s99_dword_47F2F0[4] = 0x45; + _s99_dword_47F330[0] = 1; + _s99_dword_47F330[1] = 1; + _s99_dword_47F330[2] = 1; + _s99_dword_47F330[3] = 2; + _s99_dword_47F330[4] = 1; + _s99_canSkip[0] = 0; + _s99_canSkip[1] = 0; + _s99_canSkip[2] = 0; + _s99_canSkip[3] = 0; + _s99_canSkip[4] = 0; + _s99_itemsCount = 5; +} + +void GnapEngine::scene54_initCutscene2() { + _s99_dword_47F370[0] = 0x1C9; + _s99_dword_47F370[1] = 0x1C7; + _s99_dword_47F370[2] = 0x1CC; + _s99_dword_47F370[3] = 0x1C8; + _s99_dword_47F370[4] = 0x1CB; + _s99_dword_47F370[5] = 0x1C0; + _s99_dword_47F370[6] = 0x1CA; + _s99_dword_47F370[7] = 0x1CE; + _s99_dword_47F370[8] = 0x1CD; + _s99_dword_47F370[9] = 0x1C1; + _s99_dword_47F370[10] = 0x1C2; + _s99_dword_47F370[11] = 0x1C3; + _s99_dword_47F370[12] = 0x1C4; + _s99_dword_47F370[13] = 0x1C6; + _s99_dword_47F370[14] = 0x1C5; + _s99_dword_47F370[15] = 0x1D0; + _s99_dword_47F370[16] = 0x1D0; + _s99_dword_47F370[17] = 0x1D0; + _s99_dword_47F2F0[0] = 0xD5; + _s99_dword_47F2F0[1] = 0x14C; + _s99_dword_47F2F0[2] = 0xD5; + _s99_dword_47F2F0[3] = 0xBF; + _s99_dword_47F2F0[4] = 0xD6; + _s99_dword_47F2F0[5] = 0x154; + _s99_dword_47F2F0[6] = 0x155; + _s99_dword_47F2F0[7] = 0xB9; + _s99_dword_47F2F0[8] = 0xBA; + _s99_dword_47F2F0[9] = 0x17B; + _s99_dword_47F2F0[10] = 0x17A; + _s99_dword_47F2F0[11] = 0x17C; + _s99_dword_47F2F0[12] = 0x17A; + _s99_dword_47F2F0[13] = 0x1B7; + _s99_dword_47F2F0[14] = 0x1B8; + _s99_dword_47F2F0[15] = 0x1B9; + _s99_dword_47F330[0] = 2; + _s99_dword_47F330[1] = 1; + _s99_dword_47F330[2] = 2; + _s99_dword_47F330[3] = 1; + _s99_dword_47F330[4] = 1; + _s99_dword_47F330[5] = 1; + _s99_dword_47F330[6] = 1; + _s99_dword_47F330[7] = 1; + _s99_dword_47F330[8] = 1; + _s99_dword_47F330[9] = 1; + _s99_dword_47F330[10] = 1; + _s99_dword_47F330[11] = 1; + _s99_dword_47F330[12] = 1; + _s99_dword_47F330[13] = 1; + _s99_dword_47F330[14] = 1; + _s99_dword_47F330[15] = 1; + _s99_canSkip[0] = 0; + _s99_canSkip[1] = 0; + _s99_canSkip[2] = 0; + _s99_canSkip[3] = 0; + _s99_canSkip[4] = 0; + _s99_canSkip[5] = 0; + _s99_canSkip[6] = 0; + _s99_canSkip[7] = 0; + _s99_canSkip[8] = 0; + _s99_canSkip[9] = 0; + _s99_canSkip[10] = 0; + _s99_canSkip[11] = 0; + _s99_canSkip[12] = 0; + _s99_canSkip[13] = 1; + _s99_canSkip[14] = 1; + _s99_canSkip[15] = 0; + _s99_itemsCount = 16; +} + +} // End of namespace Gnap diff --git a/engines/gnap/scenes/scenecore.cpp b/engines/gnap/scenes/scenecore.cpp new file mode 100644 index 0000000000..2736addb31 --- /dev/null +++ b/engines/gnap/scenes/scenecore.cpp @@ -0,0 +1,658 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "gnap/gnap.h" +#include "gnap/gamesys.h" +#include "gnap/resource.h" + +namespace Gnap { + +int GnapEngine::initSceneLogic() { + + int backgroundId = -1; + + switch (_currentSceneNum) { +#if 0 // TODO + case 0: + backgroundId = scene00_init(); + _gameSys->setScaleValues(0, 500, 1, 1000); + break; +#endif + case 1: + backgroundId = scene01_init(); + scene01_updateHotspots(); + _gameSys->setScaleValues(0, 500, 1, 1000); + initSceneGrid(21, 146, 11, 10); + break; + case 2: + backgroundId = scene02_init(); + scene02_updateHotspots(); + _gameSys->setScaleValues(0, 500, 1, 1000); + initSceneGrid(21, 146, 11, 10); + break; + case 3: + backgroundId = scene03_init(); + scene03_updateHotspots(); + _gameSys->setScaleValues(0, 500, 1, 1000); + initSceneGrid(21, 146, 11, 10); + break; + case 4: + backgroundId = scene04_init(); + scene04_updateHotspots(); + _gameSys->setScaleValues(0, 500, 1, 1000); + initSceneGrid(21, 146, 11, 10); + break; + case 5: + backgroundId = scene05_init(); + scene05_updateHotspots(); + _gameSys->setScaleValues(0, 500, 1, 1000); + initSceneGrid(21, 146, 11, 10); + break; + case 6: + backgroundId = scene06_init(); + scene06_updateHotspots(); + _gameSys->setScaleValues(0, 500, 1, 1000); + initSceneGrid(21, 146, 11, 10); + break; + case 7: + backgroundId = scene07_init(); + scene07_updateHotspots(); + _gameSys->setScaleValues(0, 500, 1, 1000); + initSceneGrid(21, 146, 11, 10); + break; + case 8: + backgroundId = scene08_init(); + scene08_updateHotspots(); + _gameSys->setScaleValues(0, 500, 1, 1000); + initSceneGrid(21, 146, 11, 10); + break; + case 9: + backgroundId = scene09_init(); + scene09_updateHotspots(); + _gameSys->setScaleValues(0, 500, 1, 1000); + initSceneGrid(21, 146, 11, 10); + break; + case 10: + backgroundId = scene10_init(); + scene10_updateHotspots(); + _gameSys->setScaleValues(0, 500, 1, 1000); + initSceneGrid(21, 146, 11, 10); + break; + case 11: + backgroundId = scene11_init(); + scene11_updateHotspots(); + _gameSys->setScaleValues(0, 500, 1, 1000); + initSceneGrid(21, 146, 11, 10); + break; + case 12: + backgroundId = scene12_init(); + scene12_updateHotspots(); + _gameSys->setScaleValues(0, 500, 1, 1000); + initSceneGrid(21, 146, 11, 10); + break; + case 13: + backgroundId = scene13_init(); + scene13_updateHotspots(); + _gameSys->setScaleValues(0, 500, 1, 1000); + initSceneGrid(21, 146, 11, 10); + break; + case 14: + backgroundId = scene14_init(); + scene14_updateHotspots(); + _gameSys->setScaleValues(0, 500, 1, 1000); + break; + case 15: + backgroundId = scene15_init(); + scene15_updateHotspots(); + _gameSys->setScaleValues(0, 500, 1, 1000); + break; + case 16: + case 47: + case 48: + case 54: + backgroundId = cutscene_init(); + _gameSys->setScaleValues(0, 500, 1, 1000); + break; + case 17: + backgroundId = scene17_init(); + scene17_updateHotspots(); + _gameSys->setScaleValues(0, 500, 1, 1000); + initSceneGrid(21, 146, 11, 10); + break; + case 18: + backgroundId = scene18_init(); + _gameSys->setScaleValues(0, 500, 1, 1000); + initSceneGrid(21, 146, 11, 10); + scene18_updateHotspots(); + break; + case 19: + backgroundId = scene19_init(); + scene19_updateHotspots(); + _gameSys->setScaleValues(0, 500, 1, 1000); + initSceneGrid(21, 146, 11, 10); + break; + case 20: + backgroundId = scene20_init(); + scene20_updateHotspots(); + _gameSys->setScaleValues(0, 500, 1, 1000); + initSceneGrid(21, 146, 11, 10); + break; + case 21: + backgroundId = scene21_init(); + scene21_updateHotspots(); + _gameSys->setScaleValues(0, 500, 1, 1000); + initSceneGrid(21, 146, 11, 10); + break; + case 22: + backgroundId = scene22_init(); + scene22_updateHotspots(); + _gameSys->setScaleValues(0, 500, 1, 1000); + initSceneGrid(21, 146, 11, 10); + break; + case 23: + backgroundId = scene23_init(); + scene23_updateHotspots(); + _gameSys->setScaleValues(0, 500, 1, 1000); + initSceneGrid(21, 146, 11, 10); + break; + case 24: + backgroundId = scene24_init(); + scene24_updateHotspots(); + _gameSys->setScaleValues(0, 500, 1, 1000); + initSceneGrid(21, 136, 11, 10); + break; + case 25: + backgroundId = scene25_init(); + scene25_updateHotspots(); + _gameSys->setScaleValues(0, 500, 1, 1000); + initSceneGrid(21, 146, 11, 10); + break; + case 26: + backgroundId = scene26_init(); + scene26_updateHotspots(); + _gameSys->setScaleValues(0, 500, 1, 1000); + initSceneGrid(21, 146, 11, 10); + break; + case 27: + backgroundId = scene27_init(); + scene27_updateHotspots(); + _gameSys->setScaleValues(0, 500, 1, 1000); + initSceneGrid(21, 146, 11, 10); + break; + case 28: + backgroundId = scene28_init(); + scene28_updateHotspots(); + _gameSys->setScaleValues(0, 500, 1, 1000); + initSceneGrid(21, 146, 11, 10); + break; + case 29: + backgroundId = scene29_init(); + scene29_updateHotspots(); + _gameSys->setScaleValues(0, 500, 1, 1000); + initSceneGrid(21, 146, 11, 10); + break; + case 30: + backgroundId = scene30_init(); + scene30_updateHotspots(); + _gameSys->setScaleValues(0, 500, 1, 1000); + initSceneGrid(21, 146, 11, 10); + break; + case 31: + backgroundId = scene31_init(); + scene31_updateHotspots(); + _gameSys->setScaleValues(0, 500, 1, 1000); + initSceneGrid(21, 146, 11, 10); + break; + case 32: + backgroundId = scene32_init(); + scene32_updateHotspots(); + _gameSys->setScaleValues(0, 500, 1, 1000); + initSceneGrid(21, 146, 11, 10); + break; + case 33: + backgroundId = scene33_init(); + scene33_updateHotspots(); + _gameSys->setScaleValues(0, 500, 1, 1000); + initSceneGrid(21, 146, 11, 10); + break; + case 34: + backgroundId = scene03_init(); + scene03_updateHotspots(); + _gameSys->setScaleValues(0, 500, 1, 1000); + initSceneGrid(21, 146, 11, 10); + break; + case 35: + backgroundId = scene05_init(); + scene05_updateHotspots(); + _gameSys->setScaleValues(0, 500, 1, 1000); + initSceneGrid(21, 146, 11, 10); + break; + case 36: + backgroundId = scene06_init(); + scene06_updateHotspots(); + _gameSys->setScaleValues(0, 500, 1, 1000); + initSceneGrid(21, 146, 11, 10); + break; + case 37: + backgroundId = scene04_init(); + scene04_updateHotspots(); + _gameSys->setScaleValues(0, 500, 1, 1000); + initSceneGrid(21, 146, 11, 10); + break; + case 38: + backgroundId = scene38_init(); + scene38_updateHotspots(); + _gameSys->setScaleValues(0, 500, 1, 1000); + initSceneGrid(21, 146, 11, 10); + break; + case 39: + backgroundId = scene39_init(); + scene39_updateHotspots(); + _gameSys->setScaleValues(0, 500, 1, 1000); + initSceneGrid(21, 146, 11, 10); + break; + case 40: + backgroundId = scene40_init(); + scene40_updateHotspots(); + _gameSys->setScaleValues(0, 500, 1, 1000); + initSceneGrid(21, 146, 11, 10); + break; + case 41: + backgroundId = scene41_init(); + scene41_updateHotspots(); + _gameSys->setScaleValues(0, 500, 1, 1000); + initSceneGrid(21, 146, 11, 10); + break; + case 42: + backgroundId = scene42_init(); + scene42_updateHotspots(); + _gameSys->setScaleValues(0, 500, 1, 1000); + initSceneGrid(21, 146, 11, 10); + break; + case 43: + backgroundId = scene43_init(); + scene43_updateHotspots(); + _gameSys->setScaleValues(0, 500, 1, 1000); + initSceneGrid(21, 146, 11, 10); + break; + case 44: + backgroundId = scene44_init(); + scene44_updateHotspots(); + _gameSys->setScaleValues(0, 500, 1, 1000); + initSceneGrid(21, 146, 11, 10); + break; + case 45: + backgroundId = scene45_init(); + scene45_updateHotspots(); + _gameSys->setScaleValues(0, 500, 1, 1000); + initSceneGrid(21, 146, 11, 10); + break; + case 46: + backgroundId = scene46_init(); + scene46_updateHotspots(); + _gameSys->setScaleValues(0, 500, 1, 1000); + initSceneGrid(21, 146, 11, 10); + break; + case 49: + backgroundId = scene49_init(); + scene49_updateHotspots(); + _gameSys->setScaleValues(0, 500, 1, 1000); + initSceneGrid(21, 146, 11, 10); + break; + case 50: + backgroundId = scene50_init(); + _gameSys->setScaleValues(0, 500, 1, 1000); + initSceneGrid(21, 146, 11, 10); + break; + case 51: + backgroundId = scene51_init(); + _gameSys->setScaleValues(0, 500, 1, 1000); + initSceneGrid(21, 146, 11, 10); + break; + case 52: + backgroundId = scene52_init(); + _gameSys->setScaleValues(0, 500, 1, 1000); + initSceneGrid(21, 146, 11, 10); + break; + case 53: + backgroundId = scene53_init(); + scene53_updateHotspots(); + _gameSys->setScaleValues(0, 500, 1, 1000); + initSceneGrid(21, 146, 11, 10); + break; + } + + return backgroundId; +} + +void GnapEngine::runSceneLogic() { + switch (_currentSceneNum) { + case 0: +#if 0 // TODO + scene00_run(); + if (_newSceneNum == 55) + _newSceneNum = 8; + break; +#endif + case 1: + scene01_run(); + if (_newSceneNum == 55) + _newSceneNum = 4; + break; + case 2: + scene02_run(); + if (_newSceneNum == 55) + _newSceneNum = 4; + break; + case 3: + scene03_run(); + if (_newSceneNum == 55) + _newSceneNum = 4; + break; + case 4: + scene04_run(); + if (_newSceneNum == 55) + _newSceneNum = 4; + break; + case 5: + scene05_run(); + if (_newSceneNum == 55) + _newSceneNum = 4; + break; + case 6: + scene06_run(); + if (_newSceneNum == 55) + _newSceneNum = 4; + break; + case 7: + scene07_run(); + if (_newSceneNum == 55) + _newSceneNum = 8; + break; + case 8: + scene08_run(); + if (_newSceneNum == 55) + _newSceneNum = 9; + break; + case 9: + scene09_run(); + if (_newSceneNum == 55) + _newSceneNum = 10; + break; + case 10: + scene10_run(); + if (_newSceneNum == 55) + _newSceneNum = 11; + break; + case 11: + scene11_run(); + if (_newSceneNum == 55) + _newSceneNum = 12; + break; + case 12: + scene12_run(); + if (_newSceneNum == 55) + _newSceneNum = 11; + break; + case 13: + scene13_run(); + if (_newSceneNum == 55) + _newSceneNum = 11; + break; + case 14: + scene14_run(); + if (_newSceneNum == 55) + _newSceneNum = 13; + break; + case 15: + scene15_run(); + if (_newSceneNum == 55) + _newSceneNum = 12; + break; + case 16: + scene16_initCutscene(); + _newSceneNum = 17; + _newCursorValue = 3; + cutscene_run(); + break; + case 17: + scene17_run(); + if (_newSceneNum == 55) + _newSceneNum = 20; + break; + case 18: + scene18_run(); + if (_newSceneNum == 55) + _newSceneNum = 20; + break; + case 19: + scene19_run(); + if (_newSceneNum == 55) + _newSceneNum = 19; + break; + case 20: + scene20_run(); + if (_newSceneNum == 55) + _newSceneNum = 22; + break; + case 21: + scene21_run(); + if (_newSceneNum == 55) + _newSceneNum = 20; + break; + case 22: + scene22_run(); + if (_newSceneNum == 55) + _newSceneNum = 20; + break; + case 23: + scene23_run(); + if (_newSceneNum == 55) + _newSceneNum = 20; + break; + case 24: + scene24_run(); + if (_newSceneNum == 55) + _newSceneNum = 20; + break; + case 25: + scene25_run(); + if (_newSceneNum == 55) + _newSceneNum = 20; + break; + case 26: + scene26_run(); + if (_newSceneNum == 55) + _newSceneNum = 20; + break; + case 27: + scene27_run(); + if (_newSceneNum == 55) + _newSceneNum = 20; + break; + case 28: + scene28_run(); + if (_newSceneNum == 55) + _newSceneNum = 20; + break; + case 29: + scene29_run(); + if (_newSceneNum == 55) + _newSceneNum = 20; + break; + case 30: + scene30_run(); + if (_newSceneNum == 55) + _newSceneNum = 20; + break; + case 31: + scene31_run(); + if (_newSceneNum == 55) + _newSceneNum = 20; + break; + case 32: + scene32_run(); + if (_newSceneNum == 55) + _newSceneNum = 37; + break; + case 33: + scene33_run(); + if (_newSceneNum == 55) + _newSceneNum = 37; + break; + case 34: + scene03_run(); + if (_newSceneNum == 55) + _newSceneNum = 37; + break; + case 35: + scene05_run(); + if (_newSceneNum == 55) + _newSceneNum = 37; + break; + case 36: + scene06_run(); + if (_newSceneNum == 55) + _newSceneNum = 37; + break; + case 37: + scene04_run(); + if (_newSceneNum == 55) + _newSceneNum = 37; + break; + case 38: + scene38_run(); + if (_newSceneNum == 55) + _newSceneNum = 37; + break; + case 39: + scene39_run(); + if (_newSceneNum == 55) + _newSceneNum = 37; + break; + case 40: + scene40_run(); + if (_newSceneNum == 55) + _newSceneNum = 37; + break; + case 41: + scene41_run(); + if (_newSceneNum == 55) + _newSceneNum = 37; + break; + case 42: + scene42_run(); + if (_newSceneNum == 55) + _newSceneNum = 37; + break; + case 43: + scene43_run(); + if (_newSceneNum == 55) + _newSceneNum = 37; + break; + case 44: + scene44_run(); + if (_newSceneNum == 55) + _newSceneNum = 37; + break; + case 45: + scene45_run(); + if (_newSceneNum == 55) + _newSceneNum = 37; + break; + case 46: + scene46_run(); + if (_newSceneNum == 55) + _newSceneNum = 37; + break; + case 47: + if (_prevSceneNum == 49) { + scene47_initCutscene1(); + _newSceneNum = 7; + _newCursorValue = 2; + } else if (_prevSceneNum == 13) { + scene47_initCutscene2(); + _newSceneNum = 11; + } else if (!isFlag(10) && _prevSceneNum == 2) {//CHECKME + if (isFlag(25)) { + scene47_initCutscene3(); + _newSceneNum = 2; + } else { + scene47_initCutscene4(); + _newSceneNum = 49; + } + } else if (_prevSceneNum == 21) { + scene47_initCutscene5(); + _newSceneNum = 21; + setFlag(3); + setFlag(5); + } else if (_prevSceneNum == 30) { + scene47_initCutscene6(); + _newSceneNum = 26; + } else if (isFlag(10) && _cursorValue == 1) { + scene47_initCutscene7(); + _newSceneNum = 4; + } + cutscene_run(); + break; + case 48: + scene48_initCutscene(); + _newSceneNum = 33; + _newCursorValue = 4; + cutscene_run(); + break; + case 49: + scene49_run(); + if (_newSceneNum == 55) + _newSceneNum = 47; + break; + case 50: + scene50_run(); + _newSceneNum = _prevSceneNum; + break; + case 51: + scene51_run(); + break; + case 52: + scene52_run(); + _newSceneNum = _prevSceneNum; + break; + case 53: + scene53_run(); + if (_newSceneNum == 55) + _newSceneNum = 53; + break; + case 54: + if (_prevSceneNum == 45) { + scene54_initCutscene1(); + _newSceneNum = 43; + cutscene_run(); + } else { + scene54_initCutscene2(); + cutscene_run(); + _gameDone = true; + } + break; + } +} + +} // End of namespace Gnap diff --git a/engines/gnap/sound.cpp b/engines/gnap/sound.cpp new file mode 100644 index 0000000000..9471d12a67 --- /dev/null +++ b/engines/gnap/sound.cpp @@ -0,0 +1,91 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "gnap/sound.h" +#include "audio/audiostream.h" +#include "audio/decoders/wave.h" + +namespace Gnap { + +SoundMan::SoundMan(GnapEngine *vm) + : _vm(vm) { +} + +SoundMan::~SoundMan() { +} + +void SoundMan::playSound(int resourceId, bool looping) { + SoundItem soundItem; + soundItem.resourceId = resourceId; + + SoundResource *soundResource = _vm->_soundCache->get(resourceId); + Common::MemoryReadStream *stream = new Common::MemoryReadStream(soundResource->_data, soundResource->_size, DisposeAfterUse::NO); + Audio::AudioStream *audioStream = Audio::makeLoopingAudioStream(Audio::makeWAVStream(stream, DisposeAfterUse::YES), looping ? 0 : 1); + + _vm->_mixer->playStream(Audio::Mixer::kPlainSoundType, &soundItem.handle, audioStream); + + _items.push_back(soundItem); + +} + +void SoundMan::stopSound(int resourceId) { + const int index = find(resourceId); + if (index >= 0) { + _vm->_soundCache->release(_items[index].resourceId); + _vm->_mixer->stopHandle(_items[index].handle); + _items.remove_at(index); + } +} + +void SoundMan::setSoundVolume(int resourceId, int volume) { + // TODO +} + +bool SoundMan::isSoundPlaying(int resourceId) { + const int index = find(resourceId); + return index >= 0 && _vm->_mixer->isSoundHandleActive(_items[index].handle); +} + +void SoundMan::stopAll() { + for (int index = 0; index < (int)_items.size(); ++index) { + _vm->_soundCache->release(_items[index].resourceId); + _vm->_mixer->stopHandle(_items[index].handle); + } +} + +void SoundMan::update() { + for (int index = 0; index < (int)_items.size(); ++index) + if (!_vm->_mixer->isSoundHandleActive(_items[index].handle)) { + _vm->_soundCache->release(_items[index].resourceId); + _items.remove_at(index); + --index; + } +} + +int SoundMan::find(int resourceId) { + for (int index = 0; index < (int)_items.size(); ++index) + if (_items[index].resourceId == resourceId) + return index; + return -1; +} + +} // End of namespace Gnap diff --git a/engines/gnap/sound.h b/engines/gnap/sound.h new file mode 100644 index 0000000000..ec5888ed1b --- /dev/null +++ b/engines/gnap/sound.h @@ -0,0 +1,56 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#ifndef GNAP_SOUND_H +#define GNAP_SOUND_H + +#include "gnap/gnap.h" +#include "gnap/resource.h" +#include "audio/mixer.h" +#include "common/array.h" + +namespace Gnap { + +struct SoundItem { + int resourceId; + Audio::SoundHandle handle; +}; + +class SoundMan { +public: + SoundMan(GnapEngine *vm); + ~SoundMan(); + void playSound(int resourceId, bool looping); + void stopSound(int resourceId); + void setSoundVolume(int resourceId, int volume); + bool isSoundPlaying(int resourceId); + void stopAll(); + void update(); +protected: + GnapEngine *_vm; + Common::Array<SoundItem> _items; + int find(int resourceId); +}; + +} // End of namespace Gnap + +#endif // GNAP_SOUND_H |