aboutsummaryrefslogtreecommitdiff
path: root/engines
diff options
context:
space:
mode:
Diffstat (limited to 'engines')
-rw-r--r--engines/agos/installshield_cab.cpp220
-rw-r--r--engines/agos/module.mk1
-rw-r--r--engines/agos/res.cpp8
-rw-r--r--engines/configure.engines1
-rw-r--r--engines/engines.mk5
-rw-r--r--engines/plugins_table.h3
-rw-r--r--engines/tony/custom.cpp2581
-rw-r--r--engines/tony/custom.h71
-rw-r--r--engines/tony/debugger.cpp130
-rw-r--r--engines/tony/debugger.h (renamed from engines/agos/installshield_cab.h)30
-rw-r--r--engines/tony/detection.cpp194
-rw-r--r--engines/tony/detection_tables.h145
-rw-r--r--engines/tony/font.cpp1200
-rw-r--r--engines/tony/font.h379
-rw-r--r--engines/tony/game.cpp1617
-rw-r--r--engines/tony/game.h340
-rw-r--r--engines/tony/gfxcore.cpp2212
-rw-r--r--engines/tony/gfxcore.h516
-rw-r--r--engines/tony/gfxengine.cpp862
-rw-r--r--engines/tony/gfxengine.h139
-rw-r--r--engines/tony/globals.cpp135
-rw-r--r--engines/tony/globals.h286
-rw-r--r--engines/tony/input.cpp157
-rw-r--r--engines/tony/input.h88
-rw-r--r--engines/tony/inventory.cpp953
-rw-r--r--engines/tony/inventory.h241
-rw-r--r--engines/tony/loc.cpp2322
-rw-r--r--engines/tony/loc.h582
-rw-r--r--engines/tony/module.mk33
-rw-r--r--engines/tony/mpal/expr.cpp433
-rw-r--r--engines/tony/mpal/expr.h79
-rw-r--r--engines/tony/mpal/loadmpc.cpp790
-rw-r--r--engines/tony/mpal/loadmpc.h59
-rw-r--r--engines/tony/mpal/lzo.cpp511
-rw-r--r--engines/tony/mpal/lzo.h111
-rw-r--r--engines/tony/mpal/memory.cpp129
-rw-r--r--engines/tony/mpal/memory.h76
-rw-r--r--engines/tony/mpal/mpal.cpp2102
-rw-r--r--engines/tony/mpal/mpal.h516
-rw-r--r--engines/tony/mpal/mpaldll.h251
-rw-r--r--engines/tony/mpal/mpalutils.cpp115
-rw-r--r--engines/tony/mpal/mpalutils.h74
-rw-r--r--engines/tony/resid.h71
-rw-r--r--engines/tony/sound.cpp688
-rw-r--r--engines/tony/sound.h377
-rw-r--r--engines/tony/tony.cpp795
-rw-r--r--engines/tony/tony.h243
-rw-r--r--engines/tony/tonychar.cpp1945
-rw-r--r--engines/tony/tonychar.h482
-rw-r--r--engines/tony/utils.cpp448
-rw-r--r--engines/tony/utils.h176
-rw-r--r--engines/tony/window.cpp336
-rw-r--r--engines/tony/window.h98
53 files changed, 26119 insertions, 237 deletions
diff --git a/engines/agos/installshield_cab.cpp b/engines/agos/installshield_cab.cpp
deleted file mode 100644
index d4e636f7b3..0000000000
--- a/engines/agos/installshield_cab.cpp
+++ /dev/null
@@ -1,220 +0,0 @@
-/* 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.
- *
- */
-
-// The following code is based on unshield
-// Original copyright:
-
-// Copyright (c) 2003 David Eriksson <twogood@users.sourceforge.net>
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy of
-// this software and associated documentation files (the "Software"), to deal in
-// the Software without restriction, including without limitation the rights to
-// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-// of the Software, and to permit persons to whom the Software is furnished to do
-// so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#include "agos/installshield_cab.h"
-
-#include "common/debug.h"
-#include "common/file.h"
-#include "common/memstream.h"
-#include "common/zlib.h"
-
-namespace AGOS {
-
-class InstallShieldCabinet : public Common::Archive {
- Common::String _installShieldFilename;
-
-public:
- InstallShieldCabinet(const Common::String &filename);
- ~InstallShieldCabinet();
-
- // Common::Archive API implementation
- bool hasFile(const Common::String &name) const;
- int listMembers(Common::ArchiveMemberList &list) const;
- const Common::ArchiveMemberPtr getMember(const Common::String &name) const;
- Common::SeekableReadStream *createReadStreamForMember(const Common::String &name) const;
-
-private:
- struct FileEntry {
- uint32 uncompressedSize;
- uint32 compressedSize;
- uint32 offset;
- uint16 flags;
- };
-
- typedef Common::HashMap<Common::String, FileEntry, Common::IgnoreCase_Hash, Common::IgnoreCase_EqualTo> FileMap;
- FileMap _map;
-};
-
-InstallShieldCabinet::~InstallShieldCabinet() {
- _map.clear();
-}
-
-InstallShieldCabinet::InstallShieldCabinet(const Common::String &filename) : _installShieldFilename(filename) {
- Common::File installShieldFile;
-
- if (!installShieldFile.open(_installShieldFilename)) {
- warning("InstallShieldCabinet::InstallShieldCabinet(): Could not find the archive file %s", _installShieldFilename.c_str());
- return;
- }
-
- // Note that we only support a limited subset of cabinet files
- // Only single cabinet files and ones without data shared between
- // cabinets.
-
- // Check for the magic uint32
- if (installShieldFile.readUint32LE() != 0x28635349) {
- warning("InstallShieldCabinet::InstallShieldCabinet(): Magic ID doesn't match");
- return;
- }
-
- uint32 version = installShieldFile.readUint32LE();
-
- if (version != 0x01000004) {
- warning("Unsupported CAB version %08x", version);
- return;
- }
-
- /* uint32 volumeInfo = */ installShieldFile.readUint32LE();
- uint32 cabDescriptorOffset = installShieldFile.readUint32LE();
- /* uint32 cabDescriptorSize = */ installShieldFile.readUint32LE();
-
- installShieldFile.seek(cabDescriptorOffset);
-
- installShieldFile.skip(12);
- uint32 fileTableOffset = installShieldFile.readUint32LE();
- installShieldFile.skip(4);
- uint32 fileTableSize = installShieldFile.readUint32LE();
- uint32 fileTableSize2 = installShieldFile.readUint32LE();
- uint32 directoryCount = installShieldFile.readUint32LE();
- installShieldFile.skip(8);
- uint32 fileCount = installShieldFile.readUint32LE();
-
- if (fileTableSize != fileTableSize2)
- warning("file table sizes do not match");
-
- // We're ignoring file groups and components since we
- // should not need them. Moving on to the files...
-
- installShieldFile.seek(cabDescriptorOffset + fileTableOffset);
- uint32 fileTableCount = directoryCount + fileCount;
- uint32 *fileTableOffsets = new uint32[fileTableCount];
- for (uint32 i = 0; i < fileTableCount; i++)
- fileTableOffsets[i] = installShieldFile.readUint32LE();
-
- for (uint32 i = directoryCount; i < fileCount + directoryCount; i++) {
- installShieldFile.seek(cabDescriptorOffset + fileTableOffset + fileTableOffsets[i]);
- uint32 nameOffset = installShieldFile.readUint32LE();
- /* uint32 directoryIndex = */ installShieldFile.readUint32LE();
-
- // First read in data needed by us to get at the file data
- FileEntry entry;
- entry.flags = installShieldFile.readUint16LE();
- entry.uncompressedSize = installShieldFile.readUint32LE();
- entry.compressedSize = installShieldFile.readUint32LE();
- installShieldFile.skip(20);
- entry.offset = installShieldFile.readUint32LE();
-
- // Then let's get the string
- installShieldFile.seek(cabDescriptorOffset + fileTableOffset + nameOffset);
- Common::String fileName;
-
- char c = installShieldFile.readByte();
- while (c) {
- fileName += c;
- c = installShieldFile.readByte();
- }
- _map[fileName] = entry;
- }
-
- delete[] fileTableOffsets;
-}
-
-bool InstallShieldCabinet::hasFile(const Common::String &name) const {
- return _map.contains(name);
-}
-
-int InstallShieldCabinet::listMembers(Common::ArchiveMemberList &list) const {
- for (FileMap::const_iterator it = _map.begin(); it != _map.end(); it++)
- list.push_back(getMember(it->_key));
-
- return _map.size();
-}
-
-const Common::ArchiveMemberPtr InstallShieldCabinet::getMember(const Common::String &name) const {
- return Common::ArchiveMemberPtr(new Common::GenericArchiveMember(name, this));
-}
-
-Common::SeekableReadStream *InstallShieldCabinet::createReadStreamForMember(const Common::String &name) const {
- if (!_map.contains(name))
- return 0;
-
- const FileEntry &entry = _map[name];
-
- Common::File archiveFile;
- archiveFile.open(_installShieldFilename);
- archiveFile.seek(entry.offset);
-
- if (!(entry.flags & 0x04)) {
- // Not compressed
- return archiveFile.readStream(entry.uncompressedSize);
- }
-
-#ifdef USE_ZLIB
- byte *src = (byte *)malloc(entry.compressedSize);
- byte *dst = (byte *)malloc(entry.uncompressedSize);
-
- archiveFile.read(src, entry.compressedSize);
-
- bool result = Common::inflateZlibHeaderless(dst, entry.uncompressedSize, src, entry.compressedSize);
- free(src);
-
- if (!result) {
- warning("failed to inflate CAB file '%s'", name.c_str());
- free(dst);
- return 0;
- }
-
- return new Common::MemoryReadStream(dst, entry.uncompressedSize, DisposeAfterUse::YES);
-#else
- warning("zlib required to extract compressed CAB file '%s'", name.c_str());
- return 0;
-#endif
-}
-
-Common::Archive *makeInstallShieldArchive(const Common::String &name) {
- return new InstallShieldCabinet(name);
-}
-
-} // End of namespace AGOS
diff --git a/engines/agos/module.mk b/engines/agos/module.mk
index 7ae5e17bf2..7069d8005b 100644
--- a/engines/agos/module.mk
+++ b/engines/agos/module.mk
@@ -51,7 +51,6 @@ ifdef ENABLE_AGOS2
MODULE_OBJS += \
animation.o \
feeble.o \
- installshield_cab.o \
oracle.o \
script_dp.o \
script_ff.o \
diff --git a/engines/agos/res.cpp b/engines/agos/res.cpp
index 0305879390..2e44a6575c 100644
--- a/engines/agos/res.cpp
+++ b/engines/agos/res.cpp
@@ -23,6 +23,8 @@
// Resource file routines for Simon1/Simon2
+#include "common/archive.h"
+#include "common/installshield_cab.h"
#include "common/file.h"
#include "common/memstream.h"
#include "common/textconsole.h"
@@ -31,7 +33,6 @@
#include "agos/agos.h"
#include "agos/intern.h"
#include "agos/sound.h"
-#include "agos/installshield_cab.h"
#include "common/zlib.h"
@@ -43,7 +44,10 @@ ArchiveMan::ArchiveMan() {
#ifdef ENABLE_AGOS2
void ArchiveMan::registerArchive(const Common::String &filename, int priority) {
- add(filename, makeInstallShieldArchive(filename), priority);
+ Common::SeekableReadStream *stream = SearchMan.createReadStreamForMember(filename);
+
+ if (stream)
+ add(filename, makeInstallShieldArchive(stream, DisposeAfterUse::YES), priority);
}
#endif
diff --git a/engines/configure.engines b/engines/configure.engines
index b8b1677e2a..81cf1766f3 100644
--- a/engines/configure.engines
+++ b/engines/configure.engines
@@ -43,6 +43,7 @@ add_engine tinsel "Tinsel" yes
add_engine toltecs "3 Skulls of the Toltecs" no
add_engine toon "Toonstruck" yes
add_engine touche "Touche: The Adventures of the Fifth Musketeer" yes
+add_engine tony "Tony Tough and the Night of Roasted Moths" no
add_engine tsage "TsAGE" yes
add_engine tucker "Bud Tucker in Double Trouble" yes
add_engine wintermute "Wintermute" no "" "png zlib vorbis"
diff --git a/engines/engines.mk b/engines/engines.mk
index d5d912f8b7..fd97f67c08 100644
--- a/engines/engines.mk
+++ b/engines/engines.mk
@@ -197,6 +197,11 @@ DEFINES += -DENABLE_TOLTECS=$(ENABLE_TOLTECS)
MODULES += engines/toltecs
endif
+ifdef ENABLE_TONY
+DEFINES += -DENABLE_TONY=$(ENABLE_TONY)
+MODULES += engines/tony
+endif
+
ifdef ENABLE_TOON
DEFINES += -DENABLE_TOON=$(ENABLE_TOON)
MODULES += engines/toon
diff --git a/engines/plugins_table.h b/engines/plugins_table.h
index fb35969b0b..9e6dd4ac80 100644
--- a/engines/plugins_table.h
+++ b/engines/plugins_table.h
@@ -89,6 +89,9 @@ LINK_PLUGIN(TINSEL)
#if PLUGIN_ENABLED_STATIC(TOLTECS)
LINK_PLUGIN(TOLTECS)
#endif
+#if PLUGIN_ENABLED_STATIC(TONY)
+LINK_PLUGIN(TONY)
+#endif
#if PLUGIN_ENABLED_STATIC(TOON)
LINK_PLUGIN(TOON)
#endif
diff --git a/engines/tony/custom.cpp b/engines/tony/custom.cpp
new file mode 100644
index 0000000000..f0a9197c6d
--- /dev/null
+++ b/engines/tony/custom.cpp
@@ -0,0 +1,2581 @@
+/* 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.
+ *
+ *
+ */
+
+/*
+ * This code is based on original Tony Tough source code
+ *
+ * Copyright (c) 1997-2003 Nayma Software
+ */
+
+#include "common/system.h"
+#include "common/savefile.h"
+#include "tony/mpal/mpal.h"
+#include "tony/mpal/memory.h"
+#include "tony/custom.h"
+#include "tony/font.h"
+#include "tony/game.h"
+#include "tony/gfxcore.h"
+#include "tony/tony.h"
+#include "tony/tonychar.h"
+#include "tony/utils.h"
+
+namespace Tony {
+
+const char *ambianceFile[] = {
+ "None",
+ "1.ADP", // Grilli.WAV
+ "2.ADP", // Grilli-Ovattati.WAV
+ "3.ADP", // Grilli-Vento.WAV
+ "3.ADP", // Grilli-Vento1.WAV
+ "5.ADP", // Vento1.WAV
+ "4.ADP", // Mare1.WAV
+ "6.ADP" // Mare1.WAV half volume
+};
+
+struct MusicFileEntry {
+ const char *name;
+ int sync;
+};
+
+const MusicFileEntry musicFiles[] = {
+ {"00.ADP", 0}, {"01.ADP", 0},
+ {"02.ADP", 0}, {"03.ADP", 0},
+ {"04.ADP", 0}, {"05.ADP", 0},
+ {"06.ADP", 0}, {"07.ADP", 0},
+ {"08.ADP", 2450}, {"09.ADP", 0},
+ {"10.ADP", 0}, {"11.ADP", 0},
+ {"12.ADP", 0}, {"13.ADP", 0},
+ {"14.ADP", 0}, {"15.ADP", 0},
+ {"16.ADP", 0}, {"17.ADP", 0},
+ {"18.ADP", 0}, {"19.ADP", 0},
+ {"20.ADP", 0}, {"21.ADP", 0},
+ {"22.ADP", 0}, {"23.ADP", 0},
+ {"24.ADP", 0}, {"25.ADP", 0},
+ {"26.ADP", 0}, {"27.ADP", 0},
+ {"28.ADP", 1670}, {"29.ADP", 0},
+ {"30.ADP", 0}, {"31.ADP", 0},
+ {"32.ADP", 2900}, {"33.ADP", 0},
+ {"34.ADP", 0}, {"35.ADP", 0},
+ {"36.ADP", 0}, {"37.ADP", 0},
+ {"38.ADP", 0}, {"39.ADP", 0},
+ {"40.ADP", 0}, {"41.ADP", 1920},
+ {"42.ADP", 1560}, {"43.ADP", 1920},
+ {"44.ADP", 1920}, {"45.ADP", 1920},
+ {"46.ADP", 1920}, {"47.ADP", 1920},
+ {"48.ADP", 1920}, {"49.ADP", 1920},
+ {"50.ADP", 1920}, {"51.ADP", 1920},
+ {"52.ADP", 1920}, {"53.ADP", 0},
+ {"54.ADP", 0}, {"55.ADP", 0},
+ {"56.ADP", 0}, {"57.ADP", 0},
+ {"58.ADP", 0}, {"59.ADP", 0}
+};
+
+
+const char *jingleFileNames[] = {
+ "S00.ADP", "S01.ADP",
+ "S02.ADP", "S03.ADP",
+ "S04.ADP", "S05.ADP",
+ "S06.ADP", "S07.ADP",
+ "S08.ADP", "S09.ADP",
+ "S10.ADP", "S11.ADP",
+ "S12.ADP", "S13.ADP",
+ "S14.ADP", "S15.ADP",
+ "S16.ADP", "S17.ADP",
+ "S18.ADP"
+};
+
+
+void ReapplyChangedHotspot() {
+ int i;
+ for (i = 0; i < GLOBALS._curChangedHotspot; i++)
+ GLOBALS._loc->getItemFromCode(GLOBALS._changedHotspot[i]._dwCode)->changeHotspot(RMPoint(GLOBALS._changedHotspot[i]._nX, GLOBALS._changedHotspot[i]._nY));
+}
+
+void SaveChangedHotspot(Common::OutSaveFile *f) {
+ f->writeByte(GLOBALS._curChangedHotspot);
+ if (GLOBALS._curChangedHotspot > 0) {
+ for (int i = 0; i < GLOBALS._curChangedHotspot; ++i)
+ GLOBALS._changedHotspot[i].save(f);
+ }
+}
+
+void LoadChangedHotspot(Common::InSaveFile *f) {
+ GLOBALS._curChangedHotspot = f->readByte();
+
+ if (GLOBALS._curChangedHotspot > 0) {
+ for (int i = 0; i < GLOBALS._curChangedHotspot; ++i)
+ GLOBALS._changedHotspot[i].load(f);
+ }
+}
+
+
+/**
+ * Classes required for custom functions
+ *
+ * Tony (To Move him) -> You can do MPAL through the animation? I really think so
+ *
+ * SendMessage -> I'd say just theEngine.SendMessage()
+ * ChangeLocation -> theEngine.ChangeLocation()
+ * AddInventory -> theEngine.AddInventory()
+*/
+
+void MCharResetCodes() {
+ for (int i = 0; i < 10; i++)
+ GLOBALS._mCharacter[i]._item = GLOBALS._loc->getItemFromCode(GLOBALS._mCharacter[i]._code);
+ for (int i = 0; i < 10; i++)
+ GLOBALS._character[i]._item = GLOBALS._loc->getItemFromCode(GLOBALS._character[i]._code);
+}
+
+void CharsSaveAll(Common::OutSaveFile *f) {
+ for (int i = 0; i < 10; i++) {
+ f->writeByte(GLOBALS._isMChar[i]);
+ if (GLOBALS._isMChar[i]) {
+ GLOBALS._mCharacter[i].save(f);
+ } else {
+ GLOBALS._character[i].save(f);
+ }
+ }
+}
+
+void CharsLoadAll(Common::InSaveFile *f) {
+ for (int i = 0; i < 10; i++) {
+ GLOBALS._isMChar[i] = f->readByte();
+ if (GLOBALS._isMChar[i])
+ GLOBALS._mCharacter[i].load(f);
+ else
+ GLOBALS._character[i].load(f);
+ }
+}
+
+DECLARE_CUSTOM_FUNCTION(FaceToMe)(CORO_PARAM, uint32, uint32, uint32, uint32) {
+ GLOBALS._tony->setPattern(GLOBALS._tony->PAT_STANDDOWN);
+}
+
+DECLARE_CUSTOM_FUNCTION(BackToMe)(CORO_PARAM, uint32, uint32, uint32, uint32) {
+ GLOBALS._tony->setPattern(GLOBALS._tony->PAT_STANDUP);
+}
+
+DECLARE_CUSTOM_FUNCTION(LeftToMe)(CORO_PARAM, uint32, uint32, uint32, uint32) {
+ GLOBALS._tony->setPattern(GLOBALS._tony->PAT_STANDLEFT);
+}
+
+DECLARE_CUSTOM_FUNCTION(RightToMe)(CORO_PARAM, uint32, uint32, uint32, uint32) {
+ GLOBALS._tony->setPattern(GLOBALS._tony->PAT_STANDRIGHT);
+}
+
+
+DECLARE_CUSTOM_FUNCTION(TonySetPerorate)(CORO_PARAM, uint32 bStatus, uint32, uint32, uint32) {
+ g_vm->getEngine()->setPerorate(bStatus);
+}
+
+DECLARE_CUSTOM_FUNCTION(MySleep)(CORO_PARAM, uint32 dwTime, uint32, uint32, uint32) {
+ CORO_BEGIN_CONTEXT;
+ int i;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ if (!GLOBALS._bSkipIdle)
+ CORO_INVOKE_1(CoroScheduler.sleep, dwTime);
+
+ CORO_END_CODE;
+}
+
+DECLARE_CUSTOM_FUNCTION(SetAlwaysDisplay)(CORO_PARAM, uint32 val, uint32, uint32, uint32) {
+ GLOBALS._bAlwaysDisplay = (val != 0);
+}
+
+
+DECLARE_CUSTOM_FUNCTION(SetPointer)(CORO_PARAM, uint32 dwPointer, uint32, uint32, uint32) {
+ switch (dwPointer) {
+ case 1:
+ GLOBALS._pointer->setSpecialPointer(GLOBALS._pointer->PTR_ARROWUP);
+ break;
+ case 2:
+ GLOBALS._pointer->setSpecialPointer(GLOBALS._pointer->PTR_ARROWDOWN);
+ break;
+ case 3:
+ GLOBALS._pointer->setSpecialPointer(GLOBALS._pointer->PTR_ARROWLEFT);
+ break;
+ case 4:
+ GLOBALS._pointer->setSpecialPointer(GLOBALS._pointer->PTR_ARROWRIGHT);
+ break;
+ case 5:
+ GLOBALS._pointer->setSpecialPointer(GLOBALS._pointer->PTR_ARROWMAP);
+ break;
+
+ default:
+ GLOBALS._pointer->setSpecialPointer(GLOBALS._pointer->PTR_NONE);
+ break;
+ }
+}
+
+VoiceHeader *SearchVoiceHeader(uint32 codehi, uint32 codelo) {
+ int code = (codehi << 16) | codelo;
+
+ if (g_vm->_voices.size() == 0)
+ return NULL;
+
+ for (uint i = 0; i < g_vm->_voices.size(); i++) {
+ if (g_vm->_voices[i]._code == code)
+ return &g_vm->_voices[i];
+ }
+
+ return NULL;
+}
+
+
+DECLARE_CUSTOM_FUNCTION(SendTonyMessage)(CORO_PARAM, uint32 dwMessage, uint32 nX, uint32 nY, uint32) {
+ CORO_BEGIN_CONTEXT;
+ RMMessage msg;
+ int i;
+ int curOffset;
+ VoiceHeader *curVoc;
+ FPSfx *voice;
+ RMTextDialog text;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ _ctx->curOffset = 0;
+
+ if (GLOBALS._bSkipIdle)
+ return;
+
+ _ctx->msg.load(dwMessage);
+ if (!_ctx->msg.isValid())
+ return;
+
+ _ctx->curVoc = SearchVoiceHeader(0, dwMessage);
+ _ctx->voice = NULL;
+ if (_ctx->curVoc) {
+ // Is positioned within the database of entries beginning at the first
+ _ctx->curOffset = _ctx->curVoc->_offset;
+
+ // First time allocation
+ g_vm->_vdbFP.seek(_ctx->curOffset);
+ g_vm->_theSound.createSfx(&_ctx->voice);
+
+ _ctx->voice->loadVoiceFromVDB(g_vm->_vdbFP);
+ _ctx->curOffset = g_vm->_vdbFP.pos();
+
+ _ctx->voice->setLoop(false);
+ }
+
+ if (GLOBALS._nTonyNextTalkType != GLOBALS._tony->TALK_NORMAL) {
+ CORO_INVOKE_1(GLOBALS._tony->startTalk, GLOBALS._nTonyNextTalkType);
+
+ if (!GLOBALS._bStaticTalk)
+ GLOBALS._nTonyNextTalkType = GLOBALS._tony->TALK_NORMAL;
+ } else {
+ if (_ctx->msg.numPeriods() > 1)
+ CORO_INVOKE_1(GLOBALS._tony->startTalk, GLOBALS._tony->TALK_HIPS);
+ else
+ CORO_INVOKE_1(GLOBALS._tony->startTalk, GLOBALS._tony->TALK_NORMAL);
+ }
+
+ if (GLOBALS._curBackText)
+ CORO_INVOKE_0(GLOBALS._curBackText->hide);
+
+ GLOBALS._bTonyIsSpeaking = true;
+
+ for (_ctx->i = 0; _ctx->i < _ctx->msg.numPeriods() && !GLOBALS._bSkipIdle; _ctx->i++) {
+ _ctx->text.setInput(GLOBALS._input);
+
+ // Alignment
+ _ctx->text.setAlignType(RMText::HCENTER, RMText::VBOTTOM);
+
+ // Color
+ _ctx->text.setColor(0, 255, 0);
+
+ // Writes the text
+ _ctx->text.writeText(_ctx->msg[_ctx->i], 0);
+
+ // Set the position
+ if (nX == 0 && nY == 0)
+ _ctx->text.setPosition(GLOBALS._tony->position() - RMPoint(0, 130) - GLOBALS._loc->scrollPosition());
+ else
+ _ctx->text.setPosition(RMPoint(nX, nY) - GLOBALS._loc->scrollPosition());
+
+ // Handling for always display
+ if (GLOBALS._bAlwaysDisplay) {
+ _ctx->text.setAlwaysDisplay();
+ _ctx->text.forceTime();
+ }
+
+ // Record the text
+ g_vm->getEngine()->linkGraphicTask(&_ctx->text);
+
+ if (_ctx->curVoc) {
+ if (_ctx->i == 0) {
+ _ctx->voice->play();
+ _ctx->text.setCustomSkipHandle2(_ctx->voice->_hEndOfBuffer);
+ } else {
+ g_vm->_vdbFP.seek(_ctx->curOffset);
+ g_vm->_theSound.createSfx(&_ctx->voice);
+ _ctx->voice->loadVoiceFromVDB(g_vm->_vdbFP);
+
+ _ctx->curOffset = g_vm->_vdbFP.pos();
+ _ctx->voice->setLoop(false);
+ _ctx->voice->play();
+ _ctx->text.setCustomSkipHandle2(_ctx->voice->_hEndOfBuffer);
+ }
+ }
+
+ // Wait for the end of the display
+ _ctx->text.setCustomSkipHandle(GLOBALS._hSkipIdle);
+ CORO_INVOKE_0(_ctx->text.waitForEndDisplay);
+
+ if (_ctx->curVoc) {
+ _ctx->voice->stop();
+ _ctx->voice->release();
+ _ctx->voice = NULL;
+ }
+ }
+
+ GLOBALS._bTonyIsSpeaking = false;
+ if (GLOBALS._curBackText)
+ GLOBALS._curBackText->show();
+
+ CORO_INVOKE_0(GLOBALS._tony->endTalk);
+
+ CORO_END_CODE;
+}
+
+DECLARE_CUSTOM_FUNCTION(ChangeBoxStatus)(CORO_PARAM, uint32 nLoc, uint32 nBox, uint32 nStatus, uint32) {
+ GLOBALS._boxes->changeBoxStatus(nLoc, nBox, nStatus);
+}
+
+
+DECLARE_CUSTOM_FUNCTION(CustLoadLocation)(CORO_PARAM, uint32 nLoc, uint32 tX, uint32 tY, uint32 bUseStartPos) {
+ CORO_BEGIN_CONTEXT;
+ uint32 h;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ GLOBALS._curChangedHotspot = 0;
+ if (bUseStartPos != 0)
+ g_vm->getEngine()->loadLocation(nLoc, RMPoint(tX, tY), GLOBALS._startLocPos[nLoc]);
+ else
+ g_vm->getEngine()->loadLocation(nLoc, RMPoint(tX, tY), RMPoint(-1, -1));
+
+ _ctx->h = mpalQueryDoAction(0, nLoc, 0);
+
+ // On Enter?
+ if (_ctx->h != CORO_INVALID_PID_VALUE)
+ CORO_INVOKE_2(CoroScheduler.waitForSingleObject, _ctx->h, CORO_INFINITE);
+
+ CORO_END_CODE;
+}
+
+
+DECLARE_CUSTOM_FUNCTION(SendFullscreenMsgStart)(CORO_PARAM, uint32 nMsg, uint32 nFont, uint32, uint32) {
+ CORO_BEGIN_CONTEXT;
+ RMMessage *msg;
+ RMGfxClearTask clear;
+ int i;
+ RMTextDialog text;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ _ctx->msg = new RMMessage(nMsg);
+
+ GLOBALS._fullScreenMessageLoc = GLOBALS._loc->TEMPGetNumLoc();
+ GLOBALS._fullScreenMessagePt = GLOBALS._tony->position();
+
+ if (GLOBALS._bSkipIdle)
+ return;
+
+ CORO_INVOKE_2(g_vm->getEngine()->unloadLocation, false, NULL);
+ GLOBALS._tony->hide();
+
+ for (_ctx->i = 0; _ctx->i < _ctx->msg->numPeriods() && !GLOBALS._bSkipIdle; _ctx->i++) {
+ _ctx->text.setInput(GLOBALS._input);
+
+ // Alignment
+ _ctx->text.setAlignType(RMText::HCENTER, RMText::VCENTER);
+
+ // Forces the text to disappear in time
+ _ctx->text.forceTime();
+
+ // Color
+ _ctx->text.setColor(255, 255, 255);
+
+ // Write the text
+ if (nFont == 0)
+ _ctx->text.writeText((*_ctx->msg)[_ctx->i], 1);
+ else if (nFont == 1)
+ _ctx->text.writeText((*_ctx->msg)[_ctx->i], 0);
+
+ // Set the position
+ _ctx->text.setPosition(RMPoint(320, 240));
+
+ _ctx->text.setAlwaysDisplay();
+ _ctx->text.forceTime();
+
+ // Record the text
+ g_vm->getEngine()->linkGraphicTask(&_ctx->clear);
+ g_vm->getEngine()->linkGraphicTask(&_ctx->text);
+
+ // Wait for the end of display
+ _ctx->text.setCustomSkipHandle(GLOBALS._hSkipIdle);
+ CORO_INVOKE_0(_ctx->text.waitForEndDisplay);
+ }
+
+ delete _ctx->msg;
+
+ CORO_END_CODE;
+}
+
+DECLARE_CUSTOM_FUNCTION(ClearScreen)(CORO_PARAM, uint32, uint32, uint32, uint32) {
+ CORO_BEGIN_CONTEXT;
+ char buf[256];
+ RMGfxClearTask clear;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ g_vm->getEngine()->linkGraphicTask(&_ctx->clear);
+
+ CORO_INVOKE_2(CoroScheduler.waitForSingleObject, g_vm->_hEndOfFrame, CORO_INFINITE);
+
+ // WORKAROUND: This fixes a bug in the original source where the linked clear task
+ // didn't have time to be drawn and removed from the draw list before the method
+ // ended, thus remaining in the draw list and causing a later crash
+ CORO_INVOKE_2(CoroScheduler.waitForSingleObject, g_vm->_hEndOfFrame, CORO_INFINITE);
+
+ CORO_END_CODE;
+}
+
+DECLARE_CUSTOM_FUNCTION(SendFullscreenMsgEnd)(CORO_PARAM, uint32 bNotEnableTony, uint32, uint32, uint32) {
+ g_vm->getEngine()->loadLocation(GLOBALS._fullScreenMessageLoc, RMPoint(GLOBALS._fullScreenMessagePt._x, GLOBALS._fullScreenMessagePt._y), RMPoint(-1, -1));
+ if (!bNotEnableTony)
+ GLOBALS._tony->show();
+
+ MCharResetCodes();
+ ReapplyChangedHotspot();
+}
+
+
+DECLARE_CUSTOM_FUNCTION(SendFullscreenMessage)(CORO_PARAM, uint32 nMsg, uint32 nFont, uint32, uint32) {
+ CORO_BEGIN_CONTEXT;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ CORO_INVOKE_4(SendFullscreenMsgStart, nMsg, nFont, 0, 0);
+ CORO_INVOKE_4(SendFullscreenMsgEnd, 0, 0, 0, 0);
+
+ CORO_END_CODE;
+}
+
+DECLARE_CUSTOM_FUNCTION(NoBullsEye)(CORO_PARAM, uint32, uint32, uint32, uint32) {
+ GLOBALS._bNoBullsEye = true;
+}
+
+DECLARE_CUSTOM_FUNCTION(CloseLocation)(CORO_PARAM, uint32, uint32, uint32, uint32) {
+ CORO_BEGIN_CONTEXT;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ if (!GLOBALS._bNoBullsEye) {
+ g_vm->getEngine()->initWipe(1);
+ CORO_INVOKE_0(g_vm->getEngine()->waitWipeEnd);
+ }
+
+ g_vm->stopMusic(4);
+
+ // On exit, unload
+ CORO_INVOKE_2(g_vm->getEngine()->unloadLocation, true, NULL);
+
+ CORO_END_CODE;
+}
+
+
+DECLARE_CUSTOM_FUNCTION(ChangeLocation)(CORO_PARAM, uint32 nLoc, uint32 tX, uint32 tY, uint32 bUseStartPos) {
+ CORO_BEGIN_CONTEXT;
+ uint32 h;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ if (!GLOBALS._bNoBullsEye) {
+ g_vm->getEngine()->initWipe(1);
+ CORO_INVOKE_0(g_vm->getEngine()->waitWipeEnd);
+ }
+
+ if (GLOBALS._lastTappeto != GLOBALS._ambiance[nLoc]) {
+ g_vm->stopMusic(4);
+ }
+
+ // On exit, unfreeze
+ CORO_INVOKE_2(g_vm->getEngine()->unloadLocation, true, NULL);
+
+ GLOBALS._curChangedHotspot = 0;
+ if (bUseStartPos != 0)
+ g_vm->getEngine()->loadLocation(nLoc, RMPoint(tX, tY), GLOBALS._startLocPos[nLoc]);
+ else
+ g_vm->getEngine()->loadLocation(nLoc, RMPoint(tX, tY), RMPoint(-1, -1));
+
+ if (GLOBALS._lastTappeto != GLOBALS._ambiance[nLoc]) {
+ GLOBALS._lastTappeto = GLOBALS._ambiance[nLoc];
+ if (GLOBALS._lastTappeto != 0)
+ g_vm->playMusic(4, ambianceFile[GLOBALS._lastTappeto], 0, true, 2000);
+ }
+
+ if (!GLOBALS._bNoBullsEye) {
+ g_vm->getEngine()->initWipe(2);
+ }
+
+ _ctx->h = mpalQueryDoAction(0, nLoc, 0);
+
+ if (!GLOBALS._bNoBullsEye) {
+ CORO_INVOKE_0(g_vm->getEngine()->waitWipeEnd);
+ g_vm->getEngine()->closeWipe();
+ }
+
+ GLOBALS._bNoBullsEye = false;
+
+ // On Enter?
+ if (_ctx->h != CORO_INVALID_PID_VALUE)
+ CORO_INVOKE_2(CoroScheduler.waitForSingleObject, _ctx->h, CORO_INFINITE);
+
+ CORO_END_CODE;
+}
+
+DECLARE_CUSTOM_FUNCTION(SetLocStartPosition)(CORO_PARAM, uint32 nLoc, uint32 lX, uint32 lY, uint32) {
+ GLOBALS._startLocPos[nLoc].set(lX, lY);
+}
+
+DECLARE_CUSTOM_FUNCTION(SaveTonyPosition)(CORO_PARAM, uint32, uint32, uint32, uint32) {
+ GLOBALS._saveTonyPos = GLOBALS._tony->position();
+ GLOBALS._saveTonyLoc = GLOBALS._loc->TEMPGetNumLoc();
+}
+
+DECLARE_CUSTOM_FUNCTION(RestoreTonyPosition)(CORO_PARAM, uint32, uint32, uint32, uint32) {
+ CORO_BEGIN_CONTEXT;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ CORO_INVOKE_4(ChangeLocation, GLOBALS._saveTonyLoc, GLOBALS._saveTonyPos._x, GLOBALS._saveTonyPos._y, 0);
+
+ MCharResetCodes();
+
+ CORO_END_CODE;
+}
+
+DECLARE_CUSTOM_FUNCTION(DisableInput)(CORO_PARAM, uint32, uint32, uint32, uint32) {
+ g_vm->getEngine()->disableInput();
+}
+
+DECLARE_CUSTOM_FUNCTION(EnableInput)(CORO_PARAM, uint32, uint32, uint32, uint32) {
+ g_vm->getEngine()->enableInput();
+}
+
+DECLARE_CUSTOM_FUNCTION(StopTony)(CORO_PARAM, uint32, uint32, uint32, uint32) {
+ GLOBALS._tony->stopNoAction(coroParam);
+}
+
+DECLARE_CUSTOM_FUNCTION(CustEnableGUI)(CORO_PARAM, uint32, uint32, uint32, uint32) {
+ GLOBALS.EnableGUI();
+}
+
+DECLARE_CUSTOM_FUNCTION(CustDisableGUI)(CORO_PARAM, uint32, uint32, uint32, uint32) {
+ GLOBALS.DisableGUI();
+}
+
+
+
+void TonyGenericTake1(CORO_PARAM, uint32 nDirection) {
+ CORO_BEGIN_CONTEXT;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ GLOBALS._tony->take(nDirection, 0);
+
+ if (!GLOBALS._bSkipIdle)
+ CORO_INVOKE_0(GLOBALS._tony->waitForEndPattern);
+
+ CORO_END_CODE;
+}
+
+void TonyGenericTake2(CORO_PARAM, uint32 nDirection) {
+ CORO_BEGIN_CONTEXT;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ GLOBALS._tony->take(nDirection, 1);
+
+ if (!GLOBALS._bSkipIdle)
+ CORO_INVOKE_0(GLOBALS._tony->waitForEndPattern);
+
+ GLOBALS._tony->take(nDirection, 2);
+
+ CORO_END_CODE;
+}
+
+void TonyGenericPut1(CORO_PARAM, uint32 nDirection) {
+ CORO_BEGIN_CONTEXT;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ GLOBALS._tony->put(nDirection, 0);
+
+ if (!GLOBALS._bSkipIdle)
+ CORO_INVOKE_0(GLOBALS._tony->waitForEndPattern);
+
+ CORO_END_CODE;
+}
+
+void TonyGenericPut2(CORO_PARAM, uint32 nDirection) {
+ CORO_BEGIN_CONTEXT;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ GLOBALS._tony->put(nDirection, 1);
+
+ if (!GLOBALS._bSkipIdle)
+ CORO_INVOKE_0(GLOBALS._tony->waitForEndPattern);
+
+ GLOBALS._tony->put(nDirection, 2);
+
+ CORO_END_CODE;
+}
+
+
+DECLARE_CUSTOM_FUNCTION(TonyTakeUp1)(CORO_PARAM, uint32, uint32, uint32, uint32) {
+ TonyGenericTake1(coroParam, 0);
+}
+
+
+DECLARE_CUSTOM_FUNCTION(TonyTakeMid1)(CORO_PARAM, uint32, uint32, uint32, uint32) {
+ TonyGenericTake1(coroParam, 1);
+}
+
+DECLARE_CUSTOM_FUNCTION(TonyTakeDown1)(CORO_PARAM, uint32, uint32, uint32, uint32) {
+ TonyGenericTake1(coroParam, 2);
+}
+
+
+
+DECLARE_CUSTOM_FUNCTION(TonyTakeUp2)(CORO_PARAM, uint32, uint32, uint32, uint32) {
+ TonyGenericTake2(coroParam, 0);
+}
+
+
+DECLARE_CUSTOM_FUNCTION(TonyTakeMid2)(CORO_PARAM, uint32, uint32, uint32, uint32) {
+ TonyGenericTake2(coroParam, 1);
+}
+
+DECLARE_CUSTOM_FUNCTION(TonyTakeDown2)(CORO_PARAM, uint32, uint32, uint32, uint32) {
+ TonyGenericTake2(coroParam, 2);
+}
+
+
+
+DECLARE_CUSTOM_FUNCTION(TonyPutUp1)(CORO_PARAM, uint32, uint32, uint32, uint32) {
+ TonyGenericPut1(coroParam, 0);
+}
+
+
+DECLARE_CUSTOM_FUNCTION(TonyPutMid1)(CORO_PARAM, uint32, uint32, uint32, uint32) {
+ TonyGenericPut1(coroParam, 1);
+}
+
+DECLARE_CUSTOM_FUNCTION(TonyPutDown1)(CORO_PARAM, uint32, uint32, uint32, uint32) {
+ TonyGenericPut1(coroParam, 2);
+}
+
+DECLARE_CUSTOM_FUNCTION(TonyPutUp2)(CORO_PARAM, uint32, uint32, uint32, uint32) {
+ TonyGenericPut2(coroParam, 0);
+}
+
+
+DECLARE_CUSTOM_FUNCTION(TonyPutMid2)(CORO_PARAM, uint32, uint32, uint32, uint32) {
+ TonyGenericPut2(coroParam, 1);
+}
+
+DECLARE_CUSTOM_FUNCTION(TonyPutDown2)(CORO_PARAM, uint32, uint32, uint32, uint32) {
+ TonyGenericPut2(coroParam, 2);
+}
+
+
+DECLARE_CUSTOM_FUNCTION(TonyOnTheFloor)(CORO_PARAM, uint32 dwParte, uint32, uint32, uint32) {
+ if (dwParte == 0)
+ GLOBALS._tony->setPattern(GLOBALS._tony->PAT_ONTHEFLOORLEFT);
+ else
+ GLOBALS._tony->setPattern(GLOBALS._tony->PAT_ONTHEFLOORRIGHT);
+}
+
+DECLARE_CUSTOM_FUNCTION(TonyGetUp)(CORO_PARAM, uint32 dwParte, uint32, uint32, uint32) {
+ CORO_BEGIN_CONTEXT;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ if (dwParte == 0)
+ GLOBALS._tony->setPattern(GLOBALS._tony->PAT_GETUPLEFT);
+ else
+ GLOBALS._tony->setPattern(GLOBALS._tony->PAT_GETUPRIGHT);
+
+ if (!GLOBALS._bSkipIdle)
+ CORO_INVOKE_0(GLOBALS._tony->waitForEndPattern);
+
+ CORO_END_CODE;
+}
+
+DECLARE_CUSTOM_FUNCTION(TonyShepherdess)(CORO_PARAM, uint32 bIsPast, uint32, uint32, uint32) {
+ GLOBALS._tony->setShepherdess(bIsPast);
+}
+
+DECLARE_CUSTOM_FUNCTION(TonyWhistle)(CORO_PARAM, uint32, uint32, uint32, uint32) {
+ CORO_BEGIN_CONTEXT;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ GLOBALS._tony->setPattern(GLOBALS._tony->PAT_WHISTLERIGHT);
+ if (!GLOBALS._bSkipIdle)
+ CORO_INVOKE_0(GLOBALS._tony->waitForEndPattern);
+
+ GLOBALS._tony->setPattern(GLOBALS._tony->PAT_STANDRIGHT);
+
+ CORO_END_CODE;
+}
+
+
+void TonySetNumTexts(uint32 dwText) {
+ GLOBALS._dwTonyNumTexts = dwText;
+ GLOBALS._bTonyInTexts = false;
+}
+
+DECLARE_CUSTOM_FUNCTION(TonyLaugh)(CORO_PARAM, uint32 dwText, uint32, uint32, uint32) {
+ TonySetNumTexts(dwText);
+ GLOBALS._nTonyNextTalkType = GLOBALS._tony->TALK_LAUGH;
+}
+
+DECLARE_CUSTOM_FUNCTION(TonyGiggle)(CORO_PARAM, uint32 dwText, uint32, uint32, uint32) {
+ TonySetNumTexts(dwText);
+ GLOBALS._nTonyNextTalkType = GLOBALS._tony->TALK_LAUGH2;
+}
+
+DECLARE_CUSTOM_FUNCTION(TonyHips)(CORO_PARAM, uint32 dwText, uint32, uint32, uint32) {
+ TonySetNumTexts(dwText);
+ GLOBALS._nTonyNextTalkType = GLOBALS._tony->TALK_HIPS;
+}
+
+DECLARE_CUSTOM_FUNCTION(TonySing)(CORO_PARAM, uint32 dwText, uint32, uint32, uint32) {
+ TonySetNumTexts(dwText);
+ GLOBALS._nTonyNextTalkType = GLOBALS._tony->TALK_SING;
+}
+
+DECLARE_CUSTOM_FUNCTION(TonyIndicate)(CORO_PARAM, uint32 dwText, uint32, uint32, uint32) {
+ TonySetNumTexts(dwText);
+ GLOBALS._nTonyNextTalkType = GLOBALS._tony->TALK_INDICATE;
+}
+
+DECLARE_CUSTOM_FUNCTION(TonyScaredWithHands)(CORO_PARAM, uint32 dwText, uint32, uint32, uint32) {
+ TonySetNumTexts(dwText);
+ GLOBALS._nTonyNextTalkType = GLOBALS._tony->TALK_SCARED;
+}
+
+DECLARE_CUSTOM_FUNCTION(TonyScaredWithoutHands)(CORO_PARAM, uint32 dwText, uint32, uint32, uint32) {
+ TonySetNumTexts(dwText);
+ GLOBALS._nTonyNextTalkType = GLOBALS._tony->TALK_SCARED2;
+}
+
+DECLARE_CUSTOM_FUNCTION(TonyWithHammer)(CORO_PARAM, uint32 dwText, uint32, uint32, uint32) {
+ TonySetNumTexts(dwText);
+ GLOBALS._nTonyNextTalkType = GLOBALS._tony->TALK_WITHHAMMER;
+ GLOBALS._tony->setPattern(GLOBALS._tony->PAT_WITHHAMMER);
+}
+
+DECLARE_CUSTOM_FUNCTION(TonyWithGlasses)(CORO_PARAM, uint32 dwText, uint32, uint32, uint32) {
+ TonySetNumTexts(dwText);
+ GLOBALS._nTonyNextTalkType = GLOBALS._tony->TALK_WITHGLASSES;
+ GLOBALS._tony->setPattern(GLOBALS._tony->PAT_WITHGLASSES);
+}
+
+DECLARE_CUSTOM_FUNCTION(TonyWithWorm)(CORO_PARAM, uint32 dwText, uint32, uint32, uint32) {
+ TonySetNumTexts(dwText);
+ GLOBALS._nTonyNextTalkType = GLOBALS._tony->TALK_WITHWORM;
+ GLOBALS._tony->setPattern(GLOBALS._tony->PAT_WITHWORM);
+}
+
+DECLARE_CUSTOM_FUNCTION(TonyWithRope)(CORO_PARAM, uint32 dwText, uint32, uint32, uint32) {
+ TonySetNumTexts(dwText);
+ GLOBALS._nTonyNextTalkType = GLOBALS._tony->TALK_WITHROPE;
+ GLOBALS._tony->setPattern(GLOBALS._tony->PAT_WITHROPE);
+}
+
+DECLARE_CUSTOM_FUNCTION(TonyWithSecretary)(CORO_PARAM, uint32 dwText, uint32, uint32, uint32) {
+ TonySetNumTexts(dwText);
+ GLOBALS._nTonyNextTalkType = GLOBALS._tony->TALK_WITHSECRETARY;
+ GLOBALS._tony->setPattern(GLOBALS._tony->PAT_WITHSECRETARY);
+}
+
+DECLARE_CUSTOM_FUNCTION(TonyWithRabbitANIM)(CORO_PARAM, uint32 dwText, uint32, uint32, uint32) {
+ TonySetNumTexts(dwText);
+ GLOBALS._nTonyNextTalkType = GLOBALS._tony->TALK_WITHRABBIT;
+}
+
+DECLARE_CUSTOM_FUNCTION(TonyWithRecipeANIM)(CORO_PARAM, uint32 dwText, uint32, uint32, uint32) {
+ TonySetNumTexts(dwText);
+ GLOBALS._nTonyNextTalkType = GLOBALS._tony->TALK_WITHRECIPE;
+}
+
+DECLARE_CUSTOM_FUNCTION(TonyWithCardsANIM)(CORO_PARAM, uint32 dwText, uint32, uint32, uint32) {
+ TonySetNumTexts(dwText);
+ GLOBALS._nTonyNextTalkType = GLOBALS._tony->TALK_WITHCARDS;
+}
+
+DECLARE_CUSTOM_FUNCTION(TonyWithSnowmanANIM)(CORO_PARAM, uint32 dwText, uint32, uint32, uint32) {
+ TonySetNumTexts(dwText);
+ GLOBALS._nTonyNextTalkType = GLOBALS._tony->TALK_WITHSNOWMAN;
+}
+
+DECLARE_CUSTOM_FUNCTION(TonyWithSnowmanStart)(CORO_PARAM, uint32, uint32, uint32, uint32) {
+ CORO_BEGIN_CONTEXT;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ GLOBALS._nTonyNextTalkType = GLOBALS._tony->TALK_WITHSNOWMANSTATIC;
+ GLOBALS._bStaticTalk = true;
+ CORO_INVOKE_1(GLOBALS._tony->startStatic, GLOBALS._tony->TALK_WITHSNOWMANSTATIC);
+
+ CORO_END_CODE;
+}
+
+DECLARE_CUSTOM_FUNCTION(TonyWithSnowmanEnd)(CORO_PARAM, uint32, uint32, uint32, uint32) {
+ CORO_BEGIN_CONTEXT;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ CORO_INVOKE_1(GLOBALS._tony->endStatic, GLOBALS._tony->TALK_WITHSNOWMANSTATIC);
+ GLOBALS._bStaticTalk = false;
+ GLOBALS._nTonyNextTalkType = GLOBALS._tony->TALK_NORMAL;
+
+ CORO_END_CODE;
+}
+
+DECLARE_CUSTOM_FUNCTION(TonyWithRabbitStart)(CORO_PARAM, uint32, uint32, uint32, uint32) {
+ CORO_BEGIN_CONTEXT;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ GLOBALS._nTonyNextTalkType = GLOBALS._tony->TALK_WITHRABBITSTATIC;
+ GLOBALS._bStaticTalk = true;
+ CORO_INVOKE_1(GLOBALS._tony->startStatic, GLOBALS._tony->TALK_WITHRABBITSTATIC);
+
+ CORO_END_CODE;
+}
+
+DECLARE_CUSTOM_FUNCTION(TonyWithRabbitEnd)(CORO_PARAM, uint32, uint32, uint32, uint32) {
+ CORO_BEGIN_CONTEXT;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ CORO_INVOKE_1(GLOBALS._tony->endStatic, GLOBALS._tony->TALK_WITHRABBITSTATIC);
+ GLOBALS._bStaticTalk = false;
+ GLOBALS._nTonyNextTalkType = GLOBALS._tony->TALK_NORMAL;
+
+ CORO_END_CODE;
+}
+
+DECLARE_CUSTOM_FUNCTION(TonyWithRecipeStart)(CORO_PARAM, uint32, uint32, uint32, uint32) {
+ CORO_BEGIN_CONTEXT;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ GLOBALS._nTonyNextTalkType = GLOBALS._tony->TALK_WITHRECIPESTATIC;
+ GLOBALS._bStaticTalk = true;
+ CORO_INVOKE_1(GLOBALS._tony->startStatic, GLOBALS._tony->TALK_WITHRECIPESTATIC);
+
+ CORO_END_CODE;
+}
+
+DECLARE_CUSTOM_FUNCTION(TonyWithRecipeEnd)(CORO_PARAM, uint32, uint32, uint32, uint32) {
+ CORO_BEGIN_CONTEXT;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ CORO_INVOKE_1(GLOBALS._tony->endStatic, GLOBALS._tony->TALK_WITHRECIPESTATIC);
+ GLOBALS._bStaticTalk = false;
+ GLOBALS._nTonyNextTalkType = GLOBALS._tony->TALK_NORMAL;
+
+ CORO_END_CODE;
+}
+
+DECLARE_CUSTOM_FUNCTION(TonyWithCardsStart)(CORO_PARAM, uint32, uint32, uint32, uint32) {
+ CORO_BEGIN_CONTEXT;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ GLOBALS._nTonyNextTalkType = GLOBALS._tony->TALK_WITHCARDSSTATIC;
+ GLOBALS._bStaticTalk = true;
+ CORO_INVOKE_1(GLOBALS._tony->startStatic, GLOBALS._tony->TALK_WITHCARDSSTATIC);
+
+ CORO_END_CODE;
+}
+
+DECLARE_CUSTOM_FUNCTION(TonyWithCardsEnd)(CORO_PARAM, uint32, uint32, uint32, uint32) {
+ CORO_BEGIN_CONTEXT;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ CORO_INVOKE_1(GLOBALS._tony->endStatic, GLOBALS._tony->TALK_WITHCARDSSTATIC);
+ GLOBALS._bStaticTalk = false;
+ GLOBALS._nTonyNextTalkType = GLOBALS._tony->TALK_NORMAL;
+
+ CORO_END_CODE;
+}
+
+DECLARE_CUSTOM_FUNCTION(TonyWithNotebookStart)(CORO_PARAM, uint32, uint32, uint32, uint32) {
+ CORO_BEGIN_CONTEXT;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ GLOBALS._nTonyNextTalkType = GLOBALS._tony->TALK_WITH_NOTEBOOK;
+ GLOBALS._bStaticTalk = true;
+ CORO_INVOKE_1(GLOBALS._tony->startStatic, GLOBALS._tony->TALK_WITH_NOTEBOOK);
+
+ CORO_END_CODE;
+}
+
+DECLARE_CUSTOM_FUNCTION(TonyWithNotebookEnd)(CORO_PARAM, uint32, uint32, uint32, uint32) {
+ CORO_BEGIN_CONTEXT;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ CORO_INVOKE_1(GLOBALS._tony->endStatic, GLOBALS._tony->TALK_WITH_NOTEBOOK);
+ GLOBALS._bStaticTalk = false;
+ GLOBALS._nTonyNextTalkType = GLOBALS._tony->TALK_NORMAL;
+
+ CORO_END_CODE;
+}
+
+DECLARE_CUSTOM_FUNCTION(TonyWithMegaphoneStart)(CORO_PARAM, uint32, uint32, uint32, uint32) {
+ CORO_BEGIN_CONTEXT;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ GLOBALS._nTonyNextTalkType = GLOBALS._tony->TALK_WITHMEGAPHONESTATIC;
+ GLOBALS._bStaticTalk = true;
+ CORO_INVOKE_1(GLOBALS._tony->startStatic, GLOBALS._tony->TALK_WITHMEGAPHONESTATIC);
+
+ CORO_END_CODE;
+}
+
+DECLARE_CUSTOM_FUNCTION(TonyWithMegaphoneEnd)(CORO_PARAM, uint32, uint32, uint32, uint32) {
+ CORO_BEGIN_CONTEXT;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ CORO_INVOKE_1(GLOBALS._tony->endStatic, GLOBALS._tony->TALK_WITHMEGAPHONESTATIC);
+ GLOBALS._bStaticTalk = false;
+ GLOBALS._nTonyNextTalkType = GLOBALS._tony->TALK_NORMAL;
+
+ CORO_END_CODE;
+}
+
+DECLARE_CUSTOM_FUNCTION(TonyWithBeardStart)(CORO_PARAM, uint32, uint32, uint32, uint32) {
+ CORO_BEGIN_CONTEXT;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ GLOBALS._nTonyNextTalkType = GLOBALS._tony->TALK_WITHBEARDSTATIC;
+ GLOBALS._bStaticTalk = true;
+ CORO_INVOKE_1(GLOBALS._tony->startStatic, GLOBALS._tony->TALK_WITHBEARDSTATIC);
+
+ CORO_END_CODE;
+}
+
+DECLARE_CUSTOM_FUNCTION(TonyWithBeardEnd)(CORO_PARAM, uint32, uint32, uint32, uint32) {
+ CORO_BEGIN_CONTEXT;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ CORO_INVOKE_1(GLOBALS._tony->endStatic, GLOBALS._tony->TALK_WITHBEARDSTATIC);
+ GLOBALS._bStaticTalk = false;
+ GLOBALS._nTonyNextTalkType = GLOBALS._tony->TALK_NORMAL;
+
+ CORO_END_CODE;
+}
+
+DECLARE_CUSTOM_FUNCTION(TonyScaredStart)(CORO_PARAM, uint32, uint32, uint32, uint32) {
+ CORO_BEGIN_CONTEXT;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ GLOBALS._nTonyNextTalkType = GLOBALS._tony->TALK_SCAREDSTATIC;
+ GLOBALS._bStaticTalk = true;
+ CORO_INVOKE_1(GLOBALS._tony->startStatic, GLOBALS._tony->TALK_SCAREDSTATIC);
+
+ CORO_END_CODE;
+}
+
+DECLARE_CUSTOM_FUNCTION(TonyScaredEnd)(CORO_PARAM, uint32, uint32, uint32, uint32) {
+ CORO_BEGIN_CONTEXT;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ CORO_INVOKE_1(GLOBALS._tony->endStatic, GLOBALS._tony->TALK_SCAREDSTATIC);
+ GLOBALS._bStaticTalk = false;
+ GLOBALS._nTonyNextTalkType = GLOBALS._tony->TALK_NORMAL;
+
+ CORO_END_CODE;
+}
+
+
+DECLARE_CUSTOM_FUNCTION(TonyDisgusted)(CORO_PARAM, uint32 dwText, uint32, uint32, uint32) {
+ TonySetNumTexts(dwText);
+ GLOBALS._nTonyNextTalkType = GLOBALS._tony->TALK_DISGUSTED;
+}
+
+DECLARE_CUSTOM_FUNCTION(TonySniffLeft)(CORO_PARAM, uint32, uint32, uint32, uint32) {
+ CORO_BEGIN_CONTEXT;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ GLOBALS._tony->setPattern(GLOBALS._tony->PAT_SNIFF_LEFT);
+ CORO_INVOKE_0(GLOBALS._tony->waitForEndPattern);
+ CORO_INVOKE_4(LeftToMe, 0, 0, 0, 0);
+
+ CORO_END_CODE;
+}
+
+DECLARE_CUSTOM_FUNCTION(TonySniffRight)(CORO_PARAM, uint32, uint32, uint32, uint32) {
+ CORO_BEGIN_CONTEXT;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ GLOBALS._tony->setPattern(GLOBALS._tony->PAT_SNIFF_RIGHT);
+ CORO_INVOKE_0(GLOBALS._tony->waitForEndPattern);
+ CORO_INVOKE_4(RightToMe, 0, 0, 0, 0);
+
+ CORO_END_CODE;
+}
+
+DECLARE_CUSTOM_FUNCTION(TonySarcastic)(CORO_PARAM, uint32 dwText, uint32, uint32, uint32) {
+ TonySetNumTexts(dwText);
+ GLOBALS._nTonyNextTalkType = GLOBALS._tony->TALK_SARCASTIC;
+}
+
+DECLARE_CUSTOM_FUNCTION(TonyMacbeth)(CORO_PARAM, uint32 nPos, uint32, uint32, uint32) {
+ switch (nPos) {
+ case 1:
+ GLOBALS._nTonyNextTalkType = GLOBALS._tony->TALK_MACBETH1;
+ break;
+ case 2:
+ GLOBALS._nTonyNextTalkType = GLOBALS._tony->TALK_MACBETH2;
+ break;
+ case 3:
+ GLOBALS._nTonyNextTalkType = GLOBALS._tony->TALK_MACBETH3;
+ break;
+ case 4:
+ GLOBALS._nTonyNextTalkType = GLOBALS._tony->TALK_MACBETH4;
+ break;
+ case 5:
+ GLOBALS._nTonyNextTalkType = GLOBALS._tony->TALK_MACBETH5;
+ break;
+ case 6:
+ GLOBALS._nTonyNextTalkType = GLOBALS._tony->TALK_MACBETH6;
+ break;
+ case 7:
+ GLOBALS._nTonyNextTalkType = GLOBALS._tony->TALK_MACBETH7;
+ break;
+ case 8:
+ GLOBALS._nTonyNextTalkType = GLOBALS._tony->TALK_MACBETH8;
+ break;
+ case 9:
+ GLOBALS._nTonyNextTalkType = GLOBALS._tony->TALK_MACBETH9;
+ break;
+ }
+}
+
+
+DECLARE_CUSTOM_FUNCTION(EnableTony)(CORO_PARAM, uint32, uint32, uint32, uint32) {
+ GLOBALS._tony->show();
+}
+
+DECLARE_CUSTOM_FUNCTION(DisableTony)(CORO_PARAM, uint32 bShowShadow, uint32, uint32, uint32) {
+ GLOBALS._tony->hide(bShowShadow);
+}
+
+DECLARE_CUSTOM_FUNCTION(WaitForPatternEnd)(CORO_PARAM, uint32 nItem, uint32, uint32, uint32) {
+ CORO_BEGIN_CONTEXT;
+ RMItem *item;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ _ctx->item = GLOBALS._loc->getItemFromCode(nItem);
+
+ if (!GLOBALS._bSkipIdle && _ctx->item != NULL)
+ CORO_INVOKE_1(_ctx->item->waitForEndPattern, GLOBALS._hSkipIdle);
+
+ CORO_END_CODE;
+}
+
+
+DECLARE_CUSTOM_FUNCTION(SetTonyPosition)(CORO_PARAM, uint32 nX, uint32 nY, uint32 nLoc, uint32) {
+ GLOBALS._tony->setPosition(RMPoint(nX, nY), nLoc);
+}
+
+DECLARE_CUSTOM_FUNCTION(MoveTonyAndWait)(CORO_PARAM, uint32 nX, uint32 nY, uint32, uint32) {
+ CORO_BEGIN_CONTEXT;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ // WORKAROUND: Delay for a frame before starting the move to give any previous move time to finish.
+ // This fixes a bug in the first scene where if you immediately 'Use Door', Tony moves to the door,
+ // and then floats to the right rather than properly walking.
+ CORO_SLEEP(1);
+
+ CORO_INVOKE_1(GLOBALS._tony->move, RMPoint(nX, nY));
+
+ if (!GLOBALS._bSkipIdle)
+ CORO_INVOKE_0(GLOBALS._tony->waitForEndMovement);
+
+ CORO_END_CODE;
+}
+
+DECLARE_CUSTOM_FUNCTION(MoveTony)(CORO_PARAM, uint32 nX, uint32 nY, uint32, uint32) {
+ GLOBALS._tony->move(coroParam, RMPoint(nX, nY));
+}
+
+DECLARE_CUSTOM_FUNCTION(ScrollLocation)(CORO_PARAM, uint32 nX, uint32 nY, uint32 sX, uint32 sY) {
+ CORO_BEGIN_CONTEXT;
+ int lx, ly;
+ RMPoint pt;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ // Take the scroll coordinates
+ _ctx->lx = (int32)nX;
+ _ctx->ly = (int32)nY;
+
+ _ctx->pt = GLOBALS._loc->scrollPosition();
+
+ while ((_ctx->lx != 0 || _ctx->ly != 0) && !GLOBALS._bSkipIdle) {
+ if (_ctx->lx > 0) {
+ _ctx->lx -= (int32)sX;
+ if (_ctx->lx < 0)
+ _ctx->lx = 0;
+ _ctx->pt.offset((int32)sX, 0);
+ } else if (_ctx->lx < 0) {
+ _ctx->lx += (int32)sX;
+ if (_ctx->lx > 0)
+ _ctx->lx = 0;
+ _ctx->pt.offset(-(int32)sX, 0);
+ }
+
+ if (_ctx->ly > 0) {
+ _ctx->ly -= sY;
+ if (_ctx->ly < 0)
+ _ctx->ly = 0;
+ _ctx->pt.offset(0, sY);
+ } else if (_ctx->ly < 0) {
+ _ctx->ly += sY;
+ if (_ctx->ly > 0)
+ _ctx->ly = 0;
+ _ctx->pt.offset(0, -(int32)sY);
+ }
+
+ CORO_INVOKE_2(CoroScheduler.waitForSingleObject, g_vm->_hEndOfFrame, CORO_INFINITE);
+
+ GLOBALS._loc->setScrollPosition(_ctx->pt);
+ GLOBALS._tony->setScrollPosition(_ctx->pt);
+ }
+
+ CORO_END_CODE;
+}
+
+DECLARE_CUSTOM_FUNCTION(SyncScrollLocation)(CORO_PARAM, uint32 nX, uint32 nY, uint32 sX, uint32 sY) {
+ CORO_BEGIN_CONTEXT;
+ int lx, ly;
+ RMPoint pt, startpt;
+ uint32 dwStartTime, dwCurTime, dwTotalTime;
+ uint32 stepX, stepY;
+ int dimx, dimy;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ // Take the scroll coordinates
+ _ctx->lx = (int32)nX;
+ _ctx->ly = (int32)nY;
+ _ctx->dimx = _ctx->lx;
+ _ctx->dimy = _ctx->ly;
+ if (_ctx->lx < 0)
+ _ctx->dimx = -_ctx->lx;
+
+ if (_ctx->ly < 0)
+ _ctx->dimy = -_ctx->ly;
+
+ _ctx->stepX = sX;
+ _ctx->stepY = sY;
+
+ _ctx->startpt = GLOBALS._loc->scrollPosition();
+
+ _ctx->dwStartTime = g_vm->getTime();
+
+ if (sX)
+ _ctx->dwTotalTime = _ctx->dimx * (1000 / 35) / sX;
+ else
+ _ctx->dwTotalTime = _ctx->dimy * (1000 / 35) / sY;
+
+ while ((_ctx->lx != 0 || _ctx->ly != 0) && !GLOBALS._bSkipIdle) {
+ _ctx->dwCurTime = g_vm->getTime() - _ctx->dwStartTime;
+ if (_ctx->dwCurTime > _ctx->dwTotalTime)
+ break;
+
+ _ctx->pt = _ctx->startpt;
+
+ if (sX) {
+ if (_ctx->lx > 0)
+ _ctx->pt._x += (_ctx->dimx * _ctx->dwCurTime) / _ctx->dwTotalTime;
+ else
+ _ctx->pt._x -= (_ctx->dimx * _ctx->dwCurTime) / _ctx->dwTotalTime;
+ } else {
+ if (_ctx->ly > 0)
+ _ctx->pt._y += (_ctx->dimy * _ctx->dwCurTime) / _ctx->dwTotalTime;
+ else
+ _ctx->pt._y -= (_ctx->dimy * _ctx->dwCurTime) / _ctx->dwTotalTime;
+
+ }
+
+ CORO_INVOKE_2(CoroScheduler.waitForSingleObject, g_vm->_hEndOfFrame, CORO_INFINITE);
+
+ GLOBALS._loc->setScrollPosition(_ctx->pt);
+ GLOBALS._tony->setScrollPosition(_ctx->pt);
+
+ }
+
+
+ // Set the position finale
+ if (sX) {
+ if (_ctx->lx > 0)
+ _ctx->pt._x = _ctx->startpt._x + _ctx->dimx;
+ else
+ _ctx->pt._x = _ctx->startpt._x - _ctx->dimx;
+ } else {
+ if (_ctx->ly > 0)
+ _ctx->pt._y = _ctx->startpt._y + _ctx->dimy;
+ else
+ _ctx->pt._y = _ctx->startpt._y - _ctx->dimy;
+ }
+
+ GLOBALS._loc->setScrollPosition(_ctx->pt);
+ GLOBALS._tony->setScrollPosition(_ctx->pt);
+
+ CORO_END_CODE;
+}
+
+
+DECLARE_CUSTOM_FUNCTION(ChangeHotspot)(CORO_PARAM, uint32 dwCode, uint32 nX, uint32 nY, uint32) {
+ int i;
+
+ for (i = 0; i < GLOBALS._curChangedHotspot; i++) {
+ if (GLOBALS._changedHotspot[i]._dwCode == dwCode) {
+ GLOBALS._changedHotspot[i]._nX = nX;
+ GLOBALS._changedHotspot[i]._nY = nY;
+ break;
+ }
+ }
+
+ if (i == GLOBALS._curChangedHotspot) {
+ GLOBALS._changedHotspot[i]._dwCode = dwCode;
+ GLOBALS._changedHotspot[i]._nX = nX;
+ GLOBALS._changedHotspot[i]._nY = nY;
+ GLOBALS._curChangedHotspot++;
+ }
+
+ GLOBALS._loc->getItemFromCode(dwCode)->changeHotspot(RMPoint(nX, nY));
+}
+
+
+DECLARE_CUSTOM_FUNCTION(AutoSave)(CORO_PARAM, uint32, uint32, uint32, uint32) {
+ g_vm->autoSave(coroParam);
+}
+
+DECLARE_CUSTOM_FUNCTION(AbortGame)(CORO_PARAM, uint32, uint32, uint32, uint32) {
+ g_vm->abortGame();
+}
+
+DECLARE_CUSTOM_FUNCTION(ShakeScreen)(CORO_PARAM, uint32 nScosse, uint32, uint32, uint32) {
+ CORO_BEGIN_CONTEXT;
+ uint32 i;
+ uint32 curTime;
+ int dirx, diry;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ _ctx->curTime = g_vm->getTime();
+
+ _ctx->dirx = 1;
+ _ctx->diry = 1;
+
+ while (g_vm->getTime() < _ctx->curTime + nScosse) {
+ CORO_INVOKE_2(CoroScheduler.waitForSingleObject, g_vm->_hEndOfFrame, CORO_INFINITE);
+
+ GLOBALS._loc->setFixedScroll(RMPoint(1 * _ctx->dirx, 1 * _ctx->diry));
+ GLOBALS._tony->setFixedScroll(RMPoint(1 * _ctx->dirx, 1 * _ctx->diry));
+
+ _ctx->i = g_vm->_randomSource.getRandomNumber(2);
+
+ if (_ctx->i == 0 || _ctx->i == 2)
+ _ctx->dirx = -_ctx->dirx;
+ else if (_ctx->i == 1 || _ctx->i == 2)
+ _ctx->diry = -_ctx->diry;
+ }
+
+ GLOBALS._loc->setFixedScroll(RMPoint(0, 0));
+ GLOBALS._tony->setFixedScroll(RMPoint(0, 0));
+
+ CORO_END_CODE;
+}
+
+/*
+ * Characters
+ */
+
+DECLARE_CUSTOM_FUNCTION(CharSetCode)(CORO_PARAM, uint32 nChar, uint32 nCode, uint32, uint32) {
+ assert(nChar < 16);
+ GLOBALS._character[nChar]._code = nCode;
+ GLOBALS._character[nChar]._item = GLOBALS._loc->getItemFromCode(nCode);
+ GLOBALS._character[nChar]._r = 255;
+ GLOBALS._character[nChar]._g = 255;
+ GLOBALS._character[nChar]._b = 255;
+ GLOBALS._character[nChar]._talkPattern = 0;
+ GLOBALS._character[nChar]._startTalkPattern = 0;
+ GLOBALS._character[nChar]._endTalkPattern = 0;
+ GLOBALS._character[nChar]._standPattern = 0;
+
+ GLOBALS._isMChar[nChar] = false;
+}
+
+DECLARE_CUSTOM_FUNCTION(CharSetColor)(CORO_PARAM, uint32 nChar, uint32 r, uint32 g, uint32 b) {
+ assert(nChar < 16);
+ GLOBALS._character[nChar]._r = r;
+ GLOBALS._character[nChar]._g = g;
+ GLOBALS._character[nChar]._b = b;
+}
+
+DECLARE_CUSTOM_FUNCTION(CharSetTalkPattern)(CORO_PARAM, uint32 nChar, uint32 tp, uint32 sp, uint32) {
+ assert(nChar < 16);
+ GLOBALS._character[nChar]._talkPattern = tp;
+ GLOBALS._character[nChar]._standPattern = sp;
+}
+
+DECLARE_CUSTOM_FUNCTION(CharSetStartEndTalkPattern)(CORO_PARAM, uint32 nChar, uint32 sp, uint32 ep, uint32) {
+ assert(nChar < 16);
+ GLOBALS._character[nChar]._startTalkPattern = sp;
+ GLOBALS._character[nChar]._endTalkPattern = ep;
+}
+
+DECLARE_CUSTOM_FUNCTION(CharSendMessage)(CORO_PARAM, uint32 nChar, uint32 dwMessage, uint32 bIsBack, uint32) {
+ CORO_BEGIN_CONTEXT;
+ RMMessage *msg;
+ int i;
+ RMPoint pt;
+ RMTextDialog *text;
+ int curOffset;
+ VoiceHeader *curVoc;
+ FPSfx *voice;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ _ctx->msg = new RMMessage(dwMessage);
+ _ctx->curOffset = 0;
+
+ assert(nChar < 16);
+ _ctx->pt = GLOBALS._character[nChar]._item->calculatePos() - RMPoint(-60, 20) - GLOBALS._loc->scrollPosition();
+
+ if (GLOBALS._character[nChar]._startTalkPattern != 0) {
+ GLOBALS._character[nChar]._item->setPattern(GLOBALS._character[nChar]._startTalkPattern);
+
+ CORO_INVOKE_0(GLOBALS._character[nChar]._item->waitForEndPattern);
+ }
+
+ GLOBALS._character[nChar]._item->setPattern(GLOBALS._character[nChar]._talkPattern);
+
+ _ctx->curVoc = SearchVoiceHeader(0, dwMessage);
+ _ctx->voice = NULL;
+ if (_ctx->curVoc) {
+ // Position within the database of entries, beginning at the first
+ g_vm->_vdbFP.seek(_ctx->curVoc->_offset);
+ _ctx->curOffset = _ctx->curVoc->_offset;
+ }
+
+ for (_ctx->i = 0; _ctx->i < _ctx->msg->numPeriods() && !GLOBALS._bSkipIdle; _ctx->i++) {
+ if (bIsBack) {
+ GLOBALS._curBackText = _ctx->text = new RMTextDialogScrolling(GLOBALS._loc);
+ if (GLOBALS._bTonyIsSpeaking)
+ CORO_INVOKE_0(GLOBALS._curBackText->hide);
+ } else
+ _ctx->text = new RMTextDialog;
+
+ _ctx->text->setInput(GLOBALS._input);
+
+ // Skipping
+ _ctx->text->setSkipStatus(!bIsBack);
+
+ // Alignment
+ _ctx->text->setAlignType(RMText::HCENTER, RMText::VBOTTOM);
+
+ // Color
+ _ctx->text->setColor(GLOBALS._character[nChar]._r, GLOBALS._character[nChar]._g, GLOBALS._character[nChar]._b);
+
+ // Write the text
+ _ctx->text->writeText((*_ctx->msg)[_ctx->i], 0);
+
+ // Set the position
+ _ctx->text->setPosition(_ctx->pt);
+
+ // Set the always display
+ if (GLOBALS._bAlwaysDisplay) {
+ _ctx->text->setAlwaysDisplay();
+ _ctx->text->forceTime();
+ }
+
+ // Record the text
+ g_vm->getEngine()->linkGraphicTask(_ctx->text);
+
+ if (_ctx->curVoc) {
+ g_vm->_theSound.createSfx(&_ctx->voice);
+ g_vm->_vdbFP.seek(_ctx->curOffset);
+ _ctx->voice->loadVoiceFromVDB(g_vm->_vdbFP);
+ _ctx->voice->setLoop(false);
+ if (bIsBack)
+ _ctx->voice->setVolume(55);
+ _ctx->voice->play();
+ _ctx->text->setCustomSkipHandle2(_ctx->voice->_hEndOfBuffer);
+ _ctx->curOffset = g_vm->_vdbFP.pos();
+ }
+
+ // Wait for the end of display
+ _ctx->text->setCustomSkipHandle(GLOBALS._hSkipIdle);
+ CORO_INVOKE_0(_ctx->text->waitForEndDisplay);
+
+ if (_ctx->curVoc) {
+ _ctx->voice->stop();
+ _ctx->voice->release();
+ _ctx->voice = NULL;
+ }
+
+
+ GLOBALS._curBackText = NULL;
+ delete _ctx->text;
+ }
+
+ if (GLOBALS._character[nChar]._endTalkPattern != 0) {
+ GLOBALS._character[nChar]._item->setPattern(GLOBALS._character[nChar]._endTalkPattern);
+ CORO_INVOKE_0(GLOBALS._character[nChar]._item->waitForEndPattern);
+ }
+
+ GLOBALS._character[nChar]._item->setPattern(GLOBALS._character[nChar]._standPattern);
+ delete _ctx->msg;
+
+ CORO_END_CODE;
+}
+
+DECLARE_CUSTOM_FUNCTION(AddInventory)(CORO_PARAM, uint32 dwCode, uint32, uint32, uint32) {
+ GLOBALS._inventory->addItem(dwCode);
+}
+
+DECLARE_CUSTOM_FUNCTION(RemoveInventory)(CORO_PARAM, uint32 dwCode, uint32, uint32, uint32) {
+ GLOBALS._inventory->removeItem(dwCode);
+}
+
+DECLARE_CUSTOM_FUNCTION(ChangeInventoryStatus)(CORO_PARAM, uint32 dwCode, uint32 dwStatus, uint32, uint32) {
+ GLOBALS._inventory->changeItemStatus(dwCode, dwStatus);
+}
+
+
+/*
+ * Master Characters
+ */
+
+DECLARE_CUSTOM_FUNCTION(MCharSetCode)(CORO_PARAM, uint32 nChar, uint32 nCode, uint32, uint32) {
+ assert(nChar < 10);
+ GLOBALS._mCharacter[nChar]._code = nCode;
+ if (nCode == 0)
+ GLOBALS._mCharacter[nChar]._item = NULL;
+ else
+ GLOBALS._mCharacter[nChar]._item = GLOBALS._loc->getItemFromCode(nCode);
+ GLOBALS._mCharacter[nChar]._r = 255;
+ GLOBALS._mCharacter[nChar]._g = 255;
+ GLOBALS._mCharacter[nChar]._b = 255;
+ GLOBALS._mCharacter[nChar]._x = -1;
+ GLOBALS._mCharacter[nChar]._y = -1;
+ GLOBALS._mCharacter[nChar]._bAlwaysBack = 0;
+
+ for (int i = 0; i < 10; i++)
+ GLOBALS._mCharacter[nChar]._numTalks[i] = 1;
+
+ GLOBALS._mCharacter[nChar]._curGroup = 0;
+
+ GLOBALS._isMChar[nChar] = true;
+}
+
+DECLARE_CUSTOM_FUNCTION(MCharResetCode)(CORO_PARAM, uint32 nChar, uint32, uint32, uint32) {
+ GLOBALS._mCharacter[nChar]._item = GLOBALS._loc->getItemFromCode(GLOBALS._mCharacter[nChar]._code);
+}
+
+
+DECLARE_CUSTOM_FUNCTION(MCharSetPosition)(CORO_PARAM, uint32 nChar, uint32 nX, uint32 nY, uint32) {
+ assert(nChar < 10);
+ GLOBALS._mCharacter[nChar]._x = nX;
+ GLOBALS._mCharacter[nChar]._y = nY;
+}
+
+
+DECLARE_CUSTOM_FUNCTION(MCharSetColor)(CORO_PARAM, uint32 nChar, uint32 r, uint32 g, uint32 b) {
+ assert(nChar < 10);
+ GLOBALS._mCharacter[nChar]._r = r;
+ GLOBALS._mCharacter[nChar]._g = g;
+ GLOBALS._mCharacter[nChar]._b = b;
+}
+
+
+DECLARE_CUSTOM_FUNCTION(MCharSetNumTalksInGroup)(CORO_PARAM, uint32 nChar, uint32 nGroup, uint32 nTalks, uint32) {
+ assert(nChar < 10);
+ assert(nGroup < 10);
+
+ GLOBALS._mCharacter[nChar]._numTalks[nGroup] = nTalks;
+}
+
+
+DECLARE_CUSTOM_FUNCTION(MCharSetCurrentGroup)(CORO_PARAM, uint32 nChar, uint32 nGroup, uint32, uint32) {
+ assert(nChar < 10);
+ assert(nGroup < 10);
+
+ GLOBALS._mCharacter[nChar]._curGroup = nGroup;
+}
+
+DECLARE_CUSTOM_FUNCTION(MCharSetNumTexts)(CORO_PARAM, uint32 nChar, uint32 nTexts, uint32, uint32) {
+ assert(nChar < 10);
+
+ GLOBALS._mCharacter[nChar]._numTexts = nTexts - 1;
+ GLOBALS._mCharacter[nChar]._bInTexts = false;
+}
+
+DECLARE_CUSTOM_FUNCTION(MCharSetAlwaysBack)(CORO_PARAM, uint32 nChar, uint32 bAlwaysBack, uint32, uint32) {
+ assert(nChar < 10);
+
+ GLOBALS._mCharacter[nChar]._bAlwaysBack = bAlwaysBack;
+}
+
+
+DECLARE_CUSTOM_FUNCTION(MCharSendMessage)(CORO_PARAM, uint32 nChar, uint32 dwMessage, uint32 bIsBack, uint32 nFont) {
+ CORO_BEGIN_CONTEXT;
+ RMMessage *msg;
+ int i;
+ int parm;
+ RMPoint pt;
+ uint32 h;
+ RMTextDialog *text;
+ int curOffset;
+ VoiceHeader *curVoc;
+ FPSfx *voice;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ _ctx->msg = new RMMessage(dwMessage);
+ _ctx->curOffset = 0;
+
+ assert(nChar < 10);
+
+ bIsBack |= GLOBALS._mCharacter[nChar]._bAlwaysBack ? 1 : 0;
+
+ // Calculates the position of the text according to the current frame
+ if (GLOBALS._mCharacter[nChar]._x == -1)
+ _ctx->pt = GLOBALS._mCharacter[nChar]._item->calculatePos() - RMPoint(-60, 20) - GLOBALS._loc->scrollPosition();
+ else
+ _ctx->pt = RMPoint(GLOBALS._mCharacter[nChar]._x, GLOBALS._mCharacter[nChar]._y);
+
+ // Parameter for special actions: random between the spoken
+ _ctx->parm = (GLOBALS._mCharacter[nChar]._curGroup * 10) + g_vm->_randomSource.getRandomNumber(
+ GLOBALS._mCharacter[nChar]._numTalks[GLOBALS._mCharacter[nChar]._curGroup] - 1) + 1;
+
+ // Try to run the custom function to initialize the speech
+ if (GLOBALS._mCharacter[nChar]._item) {
+ _ctx->h = mpalQueryDoAction(30, GLOBALS._mCharacter[nChar]._item->mpalCode(), _ctx->parm);
+ if (_ctx->h != CORO_INVALID_PID_VALUE) {
+ CORO_INVOKE_2(CoroScheduler.waitForSingleObject, _ctx->h, CORO_INFINITE);
+ }
+ }
+
+ _ctx->curVoc = SearchVoiceHeader(0, dwMessage);
+ _ctx->voice = NULL;
+ if (_ctx->curVoc) {
+ // Position within the database of entries, beginning at the first
+ // fseek(g_vm->m_vdbFP, curVoc->offset, SEEK_SET);
+ g_vm->_vdbFP.seek(_ctx->curVoc->_offset);
+ _ctx->curOffset = _ctx->curVoc->_offset;
+ }
+
+ for (_ctx->i = 0; _ctx->i < _ctx->msg->numPeriods() && !GLOBALS._bSkipIdle; _ctx->i++) {
+ // Create a different object depending on whether it's background or not
+ if (bIsBack) {
+ GLOBALS._curBackText = _ctx->text = new RMTextDialogScrolling(GLOBALS._loc);
+ if (GLOBALS._bTonyIsSpeaking)
+ CORO_INVOKE_0(GLOBALS._curBackText->hide);
+ } else
+ _ctx->text = new RMTextDialog;
+
+ _ctx->text->setInput(GLOBALS._input);
+
+ // Skipping
+ _ctx->text->setSkipStatus(!bIsBack);
+
+ // Alignment
+ _ctx->text->setAlignType(RMText::HCENTER, RMText::VBOTTOM);
+
+ // Color
+ _ctx->text->setColor(GLOBALS._mCharacter[nChar]._r, GLOBALS._mCharacter[nChar]._g, GLOBALS._mCharacter[nChar]._b);
+
+ // Write the text
+ _ctx->text->writeText((*_ctx->msg)[_ctx->i], nFont);
+
+ // Set the position
+ _ctx->text->setPosition(_ctx->pt);
+
+ // Set the always display
+ if (GLOBALS._bAlwaysDisplay) {
+ _ctx->text->setAlwaysDisplay();
+ _ctx->text->forceTime();
+ }
+
+ // Record the text
+ g_vm->getEngine()->linkGraphicTask(_ctx->text);
+
+ if (_ctx->curVoc) {
+ g_vm->_theSound.createSfx(&_ctx->voice);
+ g_vm->_vdbFP.seek(_ctx->curOffset);
+ _ctx->voice->loadVoiceFromVDB(g_vm->_vdbFP);
+ _ctx->voice->setLoop(false);
+ if (bIsBack)
+ _ctx->voice->setVolume(55);
+ _ctx->voice->play();
+ _ctx->text->setCustomSkipHandle2(_ctx->voice->_hEndOfBuffer);
+ _ctx->curOffset = g_vm->_vdbFP.pos();
+ }
+
+ // Wait for the end of display
+ _ctx->text->setCustomSkipHandle(GLOBALS._hSkipIdle);
+ CORO_INVOKE_0(_ctx->text->waitForEndDisplay);
+
+ if (_ctx->curVoc) {
+ _ctx->voice->stop();
+ _ctx->voice->release();
+ _ctx->voice = NULL;
+ }
+
+ GLOBALS._curBackText = NULL;
+ delete _ctx->text;
+ }
+
+ delete _ctx->msg;
+
+ // Try to run the custom function to close the speech
+ if (GLOBALS._mCharacter[nChar]._item) {
+ _ctx->h = mpalQueryDoAction(31, GLOBALS._mCharacter[nChar]._item->mpalCode(), _ctx->parm);
+ if (_ctx->h != CORO_INVALID_PID_VALUE)
+ CORO_INVOKE_2(CoroScheduler.waitForSingleObject, _ctx->h, CORO_INFINITE);
+ }
+
+ CORO_END_CODE;
+}
+
+/*
+ * Dialogs
+ */
+
+int g_curDialog;
+
+DECLARE_CUSTOM_FUNCTION(SendDialogMessage)(CORO_PARAM, uint32 nPers, uint32 nMsg, uint32, uint32) {
+ CORO_BEGIN_CONTEXT;
+ char *string;
+ RMTextDialog *text;
+ int parm;
+ uint32 h;
+ bool bIsBack;
+ VoiceHeader *curVoc;
+ FPSfx *voice;
+ RMPoint pt;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ _ctx->bIsBack = false;
+
+ // The SendDialogMessage can go in the background if it is a character
+ if (nPers != 0 && GLOBALS._isMChar[nPers] && GLOBALS._mCharacter[nPers]._bAlwaysBack)
+ _ctx->bIsBack = true;
+
+ _ctx->curVoc = SearchVoiceHeader(g_curDialog, nMsg);
+ _ctx->voice = NULL;
+
+ if (_ctx->curVoc) {
+ // Position within the database of entries, beginning at the first
+ g_vm->_vdbFP.seek(_ctx->curVoc->_offset);
+ g_vm->_theSound.createSfx(&_ctx->voice);
+ _ctx->voice->loadVoiceFromVDB(g_vm->_vdbFP);
+ _ctx->voice->setLoop(false);
+ if (_ctx->bIsBack)
+ _ctx->voice->setVolume(55);
+ }
+
+ _ctx->string = mpalQueryDialogPeriod(nMsg);
+
+ if (nPers == 0) {
+ _ctx->text = new RMTextDialog;
+ _ctx->text->setColor(0, 255, 0);
+ _ctx->text->setPosition(GLOBALS._tony->position() - RMPoint(0, 130) - GLOBALS._loc->scrollPosition());
+ _ctx->text->writeText(_ctx->string, 0);
+
+ if (GLOBALS._dwTonyNumTexts > 0) {
+ if (!GLOBALS._bTonyInTexts) {
+ if (GLOBALS._nTonyNextTalkType != GLOBALS._tony->TALK_NORMAL) {
+ CORO_INVOKE_1(GLOBALS._tony->startTalk, GLOBALS._nTonyNextTalkType);
+ if (!GLOBALS._bStaticTalk)
+ GLOBALS._nTonyNextTalkType = GLOBALS._tony->TALK_NORMAL;
+ } else
+ CORO_INVOKE_1(GLOBALS._tony->startTalk, GLOBALS._tony->TALK_NORMAL);
+
+ GLOBALS._bTonyInTexts = true;
+ }
+ GLOBALS._dwTonyNumTexts--;
+ } else {
+ CORO_INVOKE_1(GLOBALS._tony->startTalk, GLOBALS._nTonyNextTalkType);
+ if (!GLOBALS._bStaticTalk)
+ GLOBALS._nTonyNextTalkType = GLOBALS._tony->TALK_NORMAL;
+ }
+ } else if (!GLOBALS._isMChar[nPers]) {
+ _ctx->text = new RMTextDialog;
+
+ _ctx->pt = GLOBALS._character[nPers]._item->calculatePos() - RMPoint(-60, 20) - GLOBALS._loc->scrollPosition();
+
+ if (GLOBALS._character[nPers]._startTalkPattern != 0) {
+ GLOBALS._character[nPers]._item->setPattern(GLOBALS._character[nPers]._startTalkPattern);
+ CORO_INVOKE_0(GLOBALS._character[nPers]._item->waitForEndPattern);
+ }
+
+ GLOBALS._character[nPers]._item->setPattern(GLOBALS._character[nPers]._talkPattern);
+
+ _ctx->text->setColor(GLOBALS._character[nPers]._r, GLOBALS._character[nPers]._g, GLOBALS._character[nPers]._b);
+ _ctx->text->writeText(_ctx->string, 0);
+ _ctx->text->setPosition(_ctx->pt);
+ } else {
+ if (GLOBALS._mCharacter[nPers]._x == -1)
+ _ctx->pt = GLOBALS._mCharacter[nPers]._item->calculatePos() - RMPoint(-60, 20) - GLOBALS._loc->scrollPosition();
+ else
+ _ctx->pt = RMPoint(GLOBALS._mCharacter[nPers]._x, GLOBALS._mCharacter[nPers]._y);
+
+ // Parameter for special actions. Random between the spoken.
+ _ctx->parm = (GLOBALS._mCharacter[nPers]._curGroup * 10) + g_vm->_randomSource.getRandomNumber(
+ GLOBALS._mCharacter[nPers]._numTalks[GLOBALS._mCharacter[nPers]._curGroup] - 1) + 1;
+
+ if (GLOBALS._mCharacter[nPers]._numTexts != 0 && GLOBALS._mCharacter[nPers]._bInTexts) {
+ GLOBALS._mCharacter[nPers]._numTexts--;
+ } else {
+ // Try to run the custom function to initialize the speech
+ _ctx->h = mpalQueryDoAction(30, GLOBALS._mCharacter[nPers]._item->mpalCode(), _ctx->parm);
+ if (_ctx->h != CORO_INVALID_PID_VALUE)
+ CORO_INVOKE_2(CoroScheduler.waitForSingleObject, _ctx->h, CORO_INFINITE);
+
+ GLOBALS._mCharacter[nPers]._curTalk = _ctx->parm;
+
+ if (GLOBALS._mCharacter[nPers]._numTexts != 0) {
+ GLOBALS._mCharacter[nPers]._bInTexts = true;
+ GLOBALS._mCharacter[nPers]._numTexts--;
+ }
+ }
+
+ if (GLOBALS._mCharacter[nPers]._bAlwaysBack) {
+ _ctx->text = GLOBALS._curBackText = new RMTextDialogScrolling(GLOBALS._loc);
+ if (GLOBALS._bTonyIsSpeaking)
+ CORO_INVOKE_0(GLOBALS._curBackText->hide);
+
+ _ctx->bIsBack = true;
+ } else
+ _ctx->text = new RMTextDialog;
+
+ _ctx->text->setSkipStatus(!GLOBALS._mCharacter[nPers]._bAlwaysBack);
+ _ctx->text->setColor(GLOBALS._mCharacter[nPers]._r, GLOBALS._mCharacter[nPers]._g, GLOBALS._mCharacter[nPers]._b);
+ _ctx->text->writeText(_ctx->string, 0);
+ _ctx->text->setPosition(_ctx->pt);
+ }
+
+ if (!GLOBALS._bSkipIdle) {
+ _ctx->text->setInput(GLOBALS._input);
+ if (GLOBALS._bAlwaysDisplay) {
+ _ctx->text->setAlwaysDisplay();
+ _ctx->text->forceTime();
+ }
+ _ctx->text->setAlignType(RMText::HCENTER, RMText::VBOTTOM);
+ g_vm->getEngine()->linkGraphicTask(_ctx->text);
+
+ if (_ctx->curVoc) {
+ _ctx->voice->play();
+ _ctx->text->setCustomSkipHandle2(_ctx->voice->_hEndOfBuffer);
+ }
+
+ // Wait for the end of display
+ _ctx->text->setCustomSkipHandle(GLOBALS._hSkipIdle);
+ CORO_INVOKE_0(_ctx->text->waitForEndDisplay);
+ }
+
+ if (_ctx->curVoc) {
+ _ctx->voice->stop();
+ _ctx->voice->release();
+ _ctx->voice = NULL;
+ }
+
+ if (nPers != 0) {
+ if (!GLOBALS._isMChar[nPers]) {
+ if (GLOBALS._character[nPers]._endTalkPattern != 0) {
+ GLOBALS._character[nPers]._item->setPattern(GLOBALS._character[nPers]._endTalkPattern);
+ CORO_INVOKE_0(GLOBALS._character[nPers]._item->waitForEndPattern);
+ }
+
+ GLOBALS._character[nPers]._item->setPattern(GLOBALS._character[nPers]._standPattern);
+ delete _ctx->text;
+ } else {
+ if ((GLOBALS._mCharacter[nPers]._bInTexts && GLOBALS._mCharacter[nPers]._numTexts == 0) || !GLOBALS._mCharacter[nPers]._bInTexts) {
+ // Try to run the custom function to close the speech
+ GLOBALS._mCharacter[nPers]._curTalk = (GLOBALS._mCharacter[nPers]._curTalk % 10) + GLOBALS._mCharacter[nPers]._curGroup * 10;
+ _ctx->h = mpalQueryDoAction(31, GLOBALS._mCharacter[nPers]._item->mpalCode(), GLOBALS._mCharacter[nPers]._curTalk);
+ if (_ctx->h != CORO_INVALID_PID_VALUE)
+ CORO_INVOKE_2(CoroScheduler.waitForSingleObject, _ctx->h, CORO_INFINITE);
+
+ GLOBALS._mCharacter[nPers]._bInTexts = false;
+ GLOBALS._mCharacter[nPers]._numTexts = 0;
+ }
+
+ GLOBALS._curBackText = NULL;
+ delete _ctx->text;
+ }
+ } else {
+ if ((GLOBALS._dwTonyNumTexts == 0 && GLOBALS._bTonyInTexts) || !GLOBALS._bTonyInTexts) {
+ CORO_INVOKE_0(GLOBALS._tony->endTalk);
+ GLOBALS._dwTonyNumTexts = 0;
+ GLOBALS._bTonyInTexts = false;
+ }
+
+ delete _ctx->text;
+ }
+
+ globalDestroy(_ctx->string);
+
+ CORO_END_CODE;
+}
+
+
+// @@@@ This cannot be skipped!!!!!!!!!!!!!!!!!!!
+
+DECLARE_CUSTOM_FUNCTION(StartDialog)(CORO_PARAM, uint32 nDialog, uint32 nStartGroup, uint32, uint32) {
+ CORO_BEGIN_CONTEXT;
+ uint32 nChoice;
+ uint32 *sl;
+ uint32 i, num;
+ char *string;
+ RMDialogChoice dc;
+ int sel;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ g_curDialog = nDialog;
+
+ // Call MPAL to start the dialog
+ mpalQueryDoDialog(nDialog, nStartGroup);
+
+ // Wait until a choice is selected
+ mpalQueryDialogWaitForChoice(&_ctx->nChoice);
+ while (_ctx->nChoice != (uint32) - 1) {
+ // Get the list of options
+ _ctx->sl = mpalQueryDialogSelectList(_ctx->nChoice);
+ for (_ctx->num = 0; _ctx->sl[_ctx->num] != 0; _ctx->num++)
+ ;
+
+ // If there is only one option, do it automatically, and wait for the next choice
+ if (_ctx->num == 1) {
+ mpalQueryDialogSelectionDWORD(_ctx->nChoice, _ctx->sl[0]);
+ globalDestroy(_ctx->sl);
+
+ // Wait for the next choice to be made
+ mpalQueryDialogWaitForChoice(&_ctx->nChoice);
+ continue;
+ }
+
+ // Making a choice for dialog
+ _ctx->dc.init();
+ _ctx->dc.setNumChoices(_ctx->num);
+
+ // Writeall the possible options
+ for (_ctx->i = 0; _ctx->i < _ctx->num; _ctx->i++) {
+ _ctx->string = mpalQueryDialogPeriod(_ctx->sl[_ctx->i]);
+ assert(_ctx->string != NULL);
+ _ctx->dc.addChoice(_ctx->string);
+ globalDestroy(_ctx->string);
+ }
+
+ // Activate the object
+ g_vm->getEngine()->linkGraphicTask(&_ctx->dc);
+ CORO_INVOKE_0(_ctx->dc.show);
+
+ // Draw the pointer
+ GLOBALS._pointer->setSpecialPointer(GLOBALS._pointer->PTR_NONE);
+ g_vm->getEngine()->enableMouse();
+
+ while (!(GLOBALS._input->mouseLeftClicked() && ((_ctx->sel = _ctx->dc.getSelection()) != -1))) {
+ CORO_INVOKE_2(CoroScheduler.waitForSingleObject, g_vm->_hEndOfFrame, CORO_INFINITE);
+ CORO_INVOKE_1(_ctx->dc.doFrame, GLOBALS._input->mousePos());
+ }
+
+ // Hide the pointer
+ g_vm->getEngine()->disableMouse();
+
+ CORO_INVOKE_0(_ctx->dc.hide);
+ mpalQueryDialogSelectionDWORD(_ctx->nChoice, _ctx->sl[_ctx->sel]);
+
+ // Closes the choice
+ _ctx->dc.close();
+
+ globalDestroy(_ctx->sl);
+
+ // Wait for the next choice to be made
+ mpalQueryDialogWaitForChoice(&_ctx->nChoice);
+ }
+
+ CORO_END_CODE;
+}
+
+
+/*
+ * Sync between idle and mpal
+ */
+
+DECLARE_CUSTOM_FUNCTION(TakeOwnership)(CORO_PARAM, uint32 num, uint32, uint32, uint32) {
+ CORO_BEGIN_CONTEXT;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ if (GLOBALS._mut[num]._ownerPid != (uint32)CoroScheduler.getCurrentPID()) {
+ // The mutex is currently owned by a different process.
+ // Wait for the event to be signalled, which means the mutex is free.
+ CORO_INVOKE_2(CoroScheduler.waitForSingleObject, GLOBALS._mut[num]._eventId, CORO_INFINITE);
+ GLOBALS._mut[num]._ownerPid = (uint32)CoroScheduler.getCurrentPID();
+ }
+
+ GLOBALS._mut[num]._lockCount++;
+
+ CORO_END_CODE;
+}
+
+DECLARE_CUSTOM_FUNCTION(ReleaseOwnership)(CORO_PARAM, uint32 num, uint32, uint32, uint32) {
+ if (!GLOBALS._mut[num]._lockCount) {
+ warning("ReleaseOwnership tried to release mutex %d, which isn't held", num);
+ return;
+ }
+
+ if (GLOBALS._mut[num]._ownerPid != (uint32)CoroScheduler.getCurrentPID())
+ error("ReleaseOwnership tried to release mutex %d, which is held by a different process", num);
+
+ GLOBALS._mut[num]._lockCount--;
+ if (!GLOBALS._mut[num]._lockCount) {
+ GLOBALS._mut[num]._ownerPid = 0;
+
+ // Signal the event, to wake up processes waiting for the lock.
+ CoroScheduler.setEvent(GLOBALS._mut[num]._eventId);
+ }
+}
+
+/*
+ * Music
+ * -----
+ *
+ * Fadeout effects supposed:
+ *
+ * nFX = 0 - The new music replaces the old one
+ * nFX=1 - The new music interfades with the old one
+ * nFX=2 - The new music takes over in time from the old
+ *
+ */
+
+void ThreadFadeInMusic(CORO_PARAM, const void *nMusic) {
+ CORO_BEGIN_CONTEXT;
+ int i;
+ CORO_END_CONTEXT(_ctx);
+
+ int nChannel = *(const int *)nMusic;
+
+ CORO_BEGIN_CODE(_ctx);
+
+ debug("Start FadeIn Music");
+
+ for (_ctx->i = 0; _ctx->i < 16; _ctx->i++) {
+ g_vm->setMusicVolume(nChannel, _ctx->i * 4);
+
+ CORO_INVOKE_1(CoroScheduler.sleep, 100);
+ }
+ g_vm->setMusicVolume(nChannel, 64);
+
+ debug("End FadeIn Music");
+
+ CORO_KILL_SELF();
+
+ CORO_END_CODE;
+}
+
+void ThreadFadeOutMusic(CORO_PARAM, const void *nMusic) {
+ CORO_BEGIN_CONTEXT;
+ int i;
+ int startVolume;
+ CORO_END_CONTEXT(_ctx);
+
+ int nChannel = *(const int *)nMusic;
+
+ CORO_BEGIN_CODE(_ctx);
+
+ _ctx->startVolume = g_vm->getMusicVolume(nChannel);
+
+ for (_ctx->i = 16; _ctx->i > 0 && !GLOBALS._bFadeOutStop; _ctx->i--) {
+ if (_ctx->i * 4 < _ctx->startVolume)
+ g_vm->setMusicVolume(nChannel, _ctx->i * 4);
+
+ CORO_INVOKE_1(CoroScheduler.sleep, 100);
+ }
+
+ if (!GLOBALS._bFadeOutStop)
+ g_vm->setMusicVolume(nChannel, 0);
+
+ // If a jingle is played, stop it
+ if (nChannel == 2)
+ g_vm->stopMusic(2);
+
+ CORO_KILL_SELF();
+
+ CORO_END_CODE;
+}
+
+DECLARE_CUSTOM_FUNCTION(FadeInSoundEffect)(CORO_PARAM, uint32, uint32, uint32, uint32) {
+ CoroScheduler.createProcess(ThreadFadeInMusic, &GLOBALS._curSoundEffect, sizeof(int));
+}
+
+DECLARE_CUSTOM_FUNCTION(FadeOutSoundEffect)(CORO_PARAM, uint32, uint32, uint32, uint32) {
+ GLOBALS._bFadeOutStop = false;
+ CoroScheduler.createProcess(ThreadFadeOutMusic, &GLOBALS._curSoundEffect, sizeof(int));
+}
+
+DECLARE_CUSTOM_FUNCTION(FadeOutJingle)(CORO_PARAM, uint32, uint32, uint32, uint32) {
+ GLOBALS._bFadeOutStop = false;
+ int channel = 2;
+ CoroScheduler.createProcess(ThreadFadeOutMusic, &channel, sizeof(int));
+}
+
+DECLARE_CUSTOM_FUNCTION(FadeInJingle)(CORO_PARAM, uint32, uint32, uint32, uint32) {
+ int channel = 2;
+ CoroScheduler.createProcess(ThreadFadeInMusic, &channel, sizeof(int));
+}
+
+DECLARE_CUSTOM_FUNCTION(StopSoundEffect)(CORO_PARAM, uint32, uint32, uint32, uint32) {
+ g_vm->stopMusic(GLOBALS._curSoundEffect);
+}
+
+DECLARE_CUSTOM_FUNCTION(StopJingle)(CORO_PARAM, uint32, uint32, uint32, uint32) {
+ g_vm->stopMusic(2);
+}
+
+DECLARE_CUSTOM_FUNCTION(MuteSoundEffect)(CORO_PARAM, uint32, uint32, uint32, uint32) {
+ g_vm->setMusicVolume(GLOBALS._curSoundEffect, 0);
+}
+
+DECLARE_CUSTOM_FUNCTION(DemuteSoundEffect)(CORO_PARAM, uint32, uint32, uint32, uint32) {
+ GLOBALS._bFadeOutStop = true;
+ g_vm->setMusicVolume(GLOBALS._curSoundEffect, 64);
+}
+
+DECLARE_CUSTOM_FUNCTION(MuteJingle)(CORO_PARAM, uint32, uint32, uint32, uint32) {
+ g_vm->setMusicVolume(2, 0);
+}
+
+DECLARE_CUSTOM_FUNCTION(DemuteJingle)(CORO_PARAM, uint32, uint32, uint32, uint32) {
+ g_vm->setMusicVolume(2, 64);
+}
+
+void CustPlayMusic(uint32 nChannel, const char *mFN, uint32 nFX, bool bLoop, int nSync = 0) {
+ if (nSync == 0)
+ nSync = 2000;
+ debugC(DEBUG_INTERMEDIATE, kTonyDebugMusic, "Start CustPlayMusic");
+ g_vm->playMusic(nChannel, mFN, nFX, bLoop, nSync);
+ debugC(DEBUG_INTERMEDIATE, kTonyDebugMusic, "End CustPlayMusic");
+}
+
+DECLARE_CUSTOM_FUNCTION(PlaySoundEffect)(CORO_PARAM, uint32 nMusic, uint32 nFX, uint32 bNoLoop, uint32) {
+ if (nFX == 0 || nFX == 1 || nFX == 2) {
+ debugC(DEBUG_INTERMEDIATE, kTonyDebugSound, "PlaySoundEffect stop fadeout");
+ GLOBALS._bFadeOutStop = true;
+ }
+
+ GLOBALS._lastMusic = nMusic;
+ CustPlayMusic(GLOBALS._curSoundEffect, musicFiles[nMusic].name, nFX, bNoLoop ? false : true, musicFiles[nMusic].sync);
+}
+
+DECLARE_CUSTOM_FUNCTION(PlayJingle)(CORO_PARAM, uint32 nMusic, uint32 nFX, uint32 bLoop, uint32) {
+ CustPlayMusic(2, jingleFileNames[nMusic], nFX, bLoop);
+}
+
+DECLARE_CUSTOM_FUNCTION(PlayItemSfx)(CORO_PARAM, uint32 nItem, uint32 nSFX, uint32, uint32) {
+ if (nItem == 0) {
+ GLOBALS._tony->playSfx(nSFX);
+ } else {
+ RMItem *item = GLOBALS._loc->getItemFromCode(nItem);
+ if (item)
+ item->playSfx(nSFX);
+ }
+}
+
+
+void RestoreMusic(CORO_PARAM) {
+ CORO_BEGIN_CONTEXT;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ CORO_INVOKE_4(PlaySoundEffect, GLOBALS._lastMusic, 0, 0, 0);
+
+ if (GLOBALS._lastTappeto != 0)
+ CustPlayMusic(4, ambianceFile[GLOBALS._lastTappeto], 0, true);
+
+ CORO_END_CODE;
+}
+
+void SaveMusic(Common::OutSaveFile *f) {
+ f->writeByte(GLOBALS._lastMusic);
+ f->writeByte(GLOBALS._lastTappeto);
+}
+
+void LoadMusic(Common::InSaveFile *f) {
+ GLOBALS._lastMusic = f->readByte();
+ GLOBALS._lastTappeto = f->readByte();
+}
+
+
+DECLARE_CUSTOM_FUNCTION(JingleFadeStart)(CORO_PARAM, uint32 nJingle, uint32 bLoop, uint32, uint32) {
+ CORO_BEGIN_CONTEXT;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ CORO_INVOKE_4(FadeOutSoundEffect, 0, 0, 0, 0);
+ CORO_INVOKE_4(MuteJingle, 0, 0, 0, 0);
+ CORO_INVOKE_4(PlayJingle, nJingle, 0, bLoop, 0);
+ CORO_INVOKE_4(FadeInJingle, 0, 0, 0, 0);
+
+ CORO_END_CODE;
+}
+
+DECLARE_CUSTOM_FUNCTION(JingleFadeEnd)(CORO_PARAM, uint32 nJingle, uint32 bLoop, uint32, uint32) {
+ CORO_BEGIN_CONTEXT;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ CORO_INVOKE_4(FadeOutJingle, 0, 0, 0, 0);
+ CORO_INVOKE_4(FadeInSoundEffect, 0, 0, 0, 0);
+
+ CORO_END_CODE;
+}
+
+
+
+
+DECLARE_CUSTOM_FUNCTION(MustSkipIdleStart)(CORO_PARAM, uint32, uint32, uint32, uint32) {
+ GLOBALS._bSkipIdle = true;
+ CoroScheduler.setEvent(GLOBALS._hSkipIdle);
+}
+
+DECLARE_CUSTOM_FUNCTION(MustSkipIdleEnd)(CORO_PARAM, uint32, uint32, uint32, uint32) {
+ GLOBALS._bSkipIdle = false;
+ CoroScheduler.resetEvent(GLOBALS._hSkipIdle);
+}
+
+DECLARE_CUSTOM_FUNCTION(PatIrqFreeze)(CORO_PARAM, uint32 bStatus, uint32, uint32, uint32) {
+ // Unused in ScummVM.
+}
+
+DECLARE_CUSTOM_FUNCTION(OpenInitLoadMenu)(CORO_PARAM, uint32, uint32, uint32, uint32) {
+ CORO_BEGIN_CONTEXT;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ CORO_INVOKE_0(g_vm->openInitLoadMenu);
+
+ CORO_END_CODE;
+}
+
+DECLARE_CUSTOM_FUNCTION(OpenInitOptions)(CORO_PARAM, uint32, uint32, uint32, uint32) {
+ CORO_BEGIN_CONTEXT;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ CORO_INVOKE_0(g_vm->openInitOptions);
+
+ CORO_END_CODE;
+}
+
+
+DECLARE_CUSTOM_FUNCTION(DoCredits)(CORO_PARAM, uint32 nMsg, uint32 dwTime, uint32, uint32) {
+ CORO_BEGIN_CONTEXT;
+ RMMessage *msg;
+ RMTextDialog *text;
+ uint32 hDisable;
+ int i;
+ uint32 startTime;
+
+ ~CoroContextTag() {
+ delete msg;
+ delete[] text;
+ }
+
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ _ctx->msg = new RMMessage(nMsg);
+ _ctx->hDisable = CoroScheduler.createEvent(true, false);
+
+ _ctx->text = new RMTextDialog[_ctx->msg->numPeriods()];
+
+ for (_ctx->i = 0; _ctx->i < _ctx->msg->numPeriods(); _ctx->i++) {
+ _ctx->text[_ctx->i].setInput(GLOBALS._input);
+
+ // Alignment
+ if ((*_ctx->msg)[_ctx->i][0] == '@') {
+ _ctx->text[_ctx->i].setAlignType(RMText::HCENTER, RMText::VTOP);
+ _ctx->text[_ctx->i].writeText(&(*_ctx->msg)[_ctx->i][1], 3);
+ _ctx->text[_ctx->i].setPosition(RMPoint(414, 70 + _ctx->i * 26)); // 70
+ } else {
+ _ctx->text[_ctx->i].setAlignType(RMText::HLEFT, RMText::VTOP);
+ _ctx->text[_ctx->i].writeText((*_ctx->msg)[_ctx->i], 3);
+ _ctx->text[_ctx->i].setPosition(RMPoint(260, 70 + _ctx->i * 26));
+ }
+
+
+ // Set the position
+ _ctx->text[_ctx->i].setAlwaysDisplay();
+ _ctx->text[_ctx->i].setForcedTime(dwTime * 1000);
+ _ctx->text[_ctx->i].setNoTab();
+
+ // Wait for the end of display
+ _ctx->text[_ctx->i].setCustomSkipHandle(_ctx->hDisable);
+
+ // Record the text
+ g_vm->getEngine()->linkGraphicTask(&_ctx->text[_ctx->i]);
+ }
+
+ _ctx->startTime = g_vm->getTime();
+
+ while (_ctx->startTime + dwTime * 1000 > g_vm->getTime()) {
+ CORO_INVOKE_2(CoroScheduler.waitForSingleObject, g_vm->_hEndOfFrame, CORO_INFINITE);
+ if (GLOBALS._input->mouseLeftClicked() || GLOBALS._input->mouseRightClicked())
+ break;
+ if (g_vm->getEngine()->getInput().getAsyncKeyState(Common::KEYCODE_TAB))
+ break;
+ }
+
+ CoroScheduler.setEvent(_ctx->hDisable);
+
+ CORO_INVOKE_2(CoroScheduler.waitForSingleObject, g_vm->_hEndOfFrame, CORO_INFINITE);
+ CORO_INVOKE_2(CoroScheduler.waitForSingleObject, g_vm->_hEndOfFrame, CORO_INFINITE);
+
+ delete[] _ctx->text;
+ delete _ctx->msg;
+ _ctx->text = NULL;
+ _ctx->msg = NULL;
+
+ CORO_END_CODE;
+}
+
+
+
+BEGIN_CUSTOM_FUNCTION_MAP()
+
+ASSIGN(1, CustLoadLocation)
+ASSIGN(2, MySleep)
+ASSIGN(3, SetPointer)
+ASSIGN(5, MoveTony)
+ASSIGN(6, FaceToMe)
+ASSIGN(7, BackToMe)
+ASSIGN(8, LeftToMe)
+ASSIGN(9, RightToMe)
+ASSIGN(10, SendTonyMessage)
+ASSIGN(11, ChangeBoxStatus)
+ASSIGN(12, ChangeLocation)
+ASSIGN(13, DisableTony)
+ASSIGN(14, EnableTony)
+ASSIGN(15, WaitForPatternEnd)
+ASSIGN(16, SetLocStartPosition)
+ASSIGN(17, ScrollLocation)
+ASSIGN(18, MoveTonyAndWait)
+ASSIGN(19, ChangeHotspot)
+ASSIGN(20, AddInventory)
+ASSIGN(21, RemoveInventory)
+ASSIGN(22, ChangeInventoryStatus)
+ASSIGN(23, SetTonyPosition)
+ASSIGN(24, SendFullscreenMessage)
+ASSIGN(25, SaveTonyPosition)
+ASSIGN(26, RestoreTonyPosition)
+ASSIGN(27, DisableInput)
+ASSIGN(28, EnableInput)
+ASSIGN(29, StopTony)
+
+ASSIGN(30, TonyTakeUp1)
+ASSIGN(31, TonyTakeMid1)
+ASSIGN(32, TonyTakeDown1)
+ASSIGN(33, TonyTakeUp2)
+ASSIGN(34, TonyTakeMid2)
+ASSIGN(35, TonyTakeDown2)
+
+ASSIGN(72, TonyPutUp1)
+ASSIGN(73, TonyPutMid1)
+ASSIGN(74, TonyPutDown1)
+ASSIGN(75, TonyPutUp2)
+ASSIGN(76, TonyPutMid2)
+ASSIGN(77, TonyPutDown2)
+
+ASSIGN(36, TonyOnTheFloor)
+ASSIGN(37, TonyGetUp)
+ASSIGN(38, TonyShepherdess)
+ASSIGN(39, TonyWhistle)
+
+ASSIGN(40, TonyLaugh)
+ASSIGN(41, TonyHips)
+ASSIGN(42, TonySing)
+ASSIGN(43, TonyIndicate)
+ASSIGN(44, TonyScaredWithHands)
+ASSIGN(49, TonyScaredWithoutHands)
+ASSIGN(45, TonyWithGlasses)
+ASSIGN(46, TonyWithWorm)
+ASSIGN(47, TonyWithHammer)
+ASSIGN(48, TonyWithRope)
+ASSIGN(90, TonyWithRabbitANIM)
+ASSIGN(91, TonyWithRecipeANIM)
+ASSIGN(92, TonyWithCardsANIM)
+ASSIGN(93, TonyWithSnowmanANIM)
+ASSIGN(94, TonyWithSnowmanStart)
+ASSIGN(95, TonyWithSnowmanEnd)
+ASSIGN(96, TonyWithRabbitStart)
+ASSIGN(97, TonyWithRabbitEnd)
+ASSIGN(98, TonyWithRecipeStart)
+ASSIGN(99, TonyWithRecipeEnd)
+ASSIGN(100, TonyWithCardsStart)
+ASSIGN(101, TonyWithCardsEnd)
+ASSIGN(102, TonyWithNotebookStart)
+ASSIGN(103, TonyWithNotebookEnd)
+ASSIGN(104, TonyWithMegaphoneStart)
+ASSIGN(105, TonyWithMegaphoneEnd)
+ASSIGN(106, TonyWithBeardStart)
+ASSIGN(107, TonyWithBeardEnd)
+ASSIGN(108, TonyGiggle)
+ASSIGN(109, TonyDisgusted)
+ASSIGN(110, TonySarcastic)
+ASSIGN(111, TonyMacbeth)
+ASSIGN(112, TonySniffLeft)
+ASSIGN(113, TonySniffRight)
+ASSIGN(114, TonyScaredStart)
+ASSIGN(115, TonyScaredEnd)
+ASSIGN(116, TonyWithSecretary)
+
+ASSIGN(50, CharSetCode)
+ASSIGN(51, CharSetColor)
+ASSIGN(52, CharSetTalkPattern)
+ASSIGN(53, CharSendMessage)
+ASSIGN(54, CharSetStartEndTalkPattern)
+
+ASSIGN(60, MCharSetCode)
+ASSIGN(61, MCharSetColor)
+ASSIGN(62, MCharSetCurrentGroup)
+ASSIGN(63, MCharSetNumTalksInGroup)
+ASSIGN(64, MCharSetNumTexts)
+ASSIGN(65, MCharSendMessage)
+ASSIGN(66, MCharSetPosition)
+ASSIGN(67, MCharSetAlwaysBack)
+ASSIGN(68, MCharResetCode)
+
+ASSIGN(70, StartDialog)
+ASSIGN(71, SendDialogMessage)
+
+ASSIGN(80, TakeOwnership)
+ASSIGN(81, ReleaseOwnership)
+
+ASSIGN(86, PlaySoundEffect)
+ASSIGN(87, PlayJingle)
+ASSIGN(88, FadeInSoundEffect)
+ASSIGN(89, FadeOutSoundEffect)
+ASSIGN(123, FadeInJingle)
+ASSIGN(124, FadeOutJingle)
+ASSIGN(125, MuteSoundEffect)
+ASSIGN(126, DemuteSoundEffect)
+ASSIGN(127, MuteJingle)
+ASSIGN(128, DemuteJingle)
+ASSIGN(84, StopSoundEffect)
+ASSIGN(85, StopJingle)
+ASSIGN(83, PlayItemSfx)
+ASSIGN(129, JingleFadeStart)
+ASSIGN(130, JingleFadeEnd)
+
+ASSIGN(120, ShakeScreen)
+ASSIGN(121, AutoSave)
+ASSIGN(122, AbortGame)
+ASSIGN(131, NoBullsEye)
+ASSIGN(132, SendFullscreenMsgStart)
+ASSIGN(133, SendFullscreenMsgEnd)
+ASSIGN(134, CustEnableGUI)
+ASSIGN(135, CustDisableGUI)
+ASSIGN(136, ClearScreen)
+ASSIGN(137, PatIrqFreeze)
+ASSIGN(138, TonySetPerorate)
+ASSIGN(139, OpenInitLoadMenu)
+ASSIGN(140, OpenInitOptions)
+ASSIGN(141, SyncScrollLocation)
+ASSIGN(142, CloseLocation)
+ASSIGN(143, SetAlwaysDisplay)
+ASSIGN(144, DoCredits)
+
+ASSIGN(200, MustSkipIdleStart);
+ASSIGN(201, MustSkipIdleEnd);
+
+END_CUSTOM_FUNCTION_MAP()
+
+void processKilledCallback(Common::PROCESS *p) {
+ for (uint i = 0; i < 10; i++)
+ if (GLOBALS._mut[i]._ownerPid == p->pid) {
+ // Handle scripts which don't call ReleaseOwnership, such as
+ // the one in loc37's vEnter when Tony is chasing the mouse.
+ debug(DEBUG_BASIC, "Force-releasing mutex %d after process died", i);
+
+ GLOBALS._mut[i]._ownerPid = 0;
+ GLOBALS._mut[i]._lockCount = 0;
+ CoroScheduler.setEvent(GLOBALS._mut[i]._eventId);
+ }
+}
+
+void setupGlobalVars(RMTony *tony, RMPointer *ptr, RMGameBoxes *box, RMLocation *loc, RMInventory *inv, RMInput *input) {
+ GLOBALS._tony = tony;
+ GLOBALS._pointer = ptr;
+ GLOBALS._boxes = box;
+ GLOBALS._loc = loc;
+ GLOBALS._inventory = inv;
+ GLOBALS._input = input;
+
+ GLOBALS.DisableGUI = mainDisableGUI;
+ GLOBALS.EnableGUI = mainEnableGUI;
+
+ GLOBALS._bAlwaysDisplay = false;
+ int i;
+
+ CoroScheduler.setResourceCallback(processKilledCallback);
+ for (i = 0; i < 10; i++)
+ GLOBALS._mut[i]._eventId = CoroScheduler.createEvent(false, true);
+
+ for (i = 0; i < 200; i++)
+ GLOBALS._ambiance[i] = 0;
+
+ GLOBALS._ambiance[6] = AMBIANCE_CRICKETS;
+ GLOBALS._ambiance[7] = AMBIANCE_CRICKETS;
+ GLOBALS._ambiance[8] = AMBIANCE_CRICKETSMUFFLED;
+ GLOBALS._ambiance[10] = AMBIANCE_CRICKETS;
+ GLOBALS._ambiance[12] = AMBIANCE_CRICKETS;
+ GLOBALS._ambiance[13] = AMBIANCE_CRICKETSMUFFLED;
+ GLOBALS._ambiance[15] = AMBIANCE_CRICKETS;
+ GLOBALS._ambiance[16] = AMBIANCE_CRICKETSWIND;
+ GLOBALS._ambiance[18] = AMBIANCE_CRICKETS;
+ GLOBALS._ambiance[19] = AMBIANCE_CRICKETSWIND;
+ GLOBALS._ambiance[20] = AMBIANCE_CRICKETS;
+ GLOBALS._ambiance[23] = AMBIANCE_CRICKETS;
+ GLOBALS._ambiance[26] = AMBIANCE_SEAHALFVOLUME;
+ GLOBALS._ambiance[27] = AMBIANCE_CRICKETS;
+ GLOBALS._ambiance[28] = AMBIANCE_CRICKETSWIND;
+ GLOBALS._ambiance[31] = AMBIANCE_CRICKETS;
+ GLOBALS._ambiance[33] = AMBIANCE_SEA;
+ GLOBALS._ambiance[35] = AMBIANCE_SEA;
+ GLOBALS._ambiance[36] = AMBIANCE_CRICKETS;
+ GLOBALS._ambiance[37] = AMBIANCE_CRICKETS;
+ GLOBALS._ambiance[40] = AMBIANCE_CRICKETS;
+ GLOBALS._ambiance[41] = AMBIANCE_CRICKETS;
+ GLOBALS._ambiance[42] = AMBIANCE_CRICKETS;
+ GLOBALS._ambiance[45] = AMBIANCE_CRICKETS;
+ GLOBALS._ambiance[51] = AMBIANCE_CRICKETS;
+ GLOBALS._ambiance[52] = AMBIANCE_CRICKETSWIND1;
+ GLOBALS._ambiance[53] = AMBIANCE_CRICKETS;
+ GLOBALS._ambiance[54] = AMBIANCE_CRICKETS;
+ GLOBALS._ambiance[57] = AMBIANCE_WIND;
+ GLOBALS._ambiance[58] = AMBIANCE_WIND;
+ GLOBALS._ambiance[60] = AMBIANCE_WIND;
+
+
+
+ // Create an event for the idle skipping
+ GLOBALS._hSkipIdle = CoroScheduler.createEvent(true, false);
+}
+
+} // end of namespace Tony
diff --git a/engines/tony/custom.h b/engines/tony/custom.h
new file mode 100644
index 0000000000..524ab14aab
--- /dev/null
+++ b/engines/tony/custom.h
@@ -0,0 +1,71 @@
+/* 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.
+ *
+ */
+
+/*
+ * This code is based on original Tony Tough source code
+ *
+ * Copyright (c) 1997-2003 Nayma Software
+ */
+
+#ifndef TONY_CUSTOM_H
+#define TONY_CUSTOM_H
+
+#include "common/str.h"
+#include "tony/mpal/mpal.h"
+
+namespace Tony {
+
+using namespace MPAL;
+
+#define INIT_CUSTOM_FUNCTION MapCustomFunctions
+
+#define DECLARE_CUSTOM_FUNCTION(x) void x
+
+#define BEGIN_CUSTOM_FUNCTION_MAP() \
+ static void AssignError(int num) { \
+ error("Custom function %u has been already assigned!", num); \
+ } \
+ void INIT_CUSTOM_FUNCTION(LPCUSTOMFUNCTION *lpMap, Common::String *lpStrMap) \
+ {
+
+#define END_CUSTOM_FUNCTION_MAP() \
+ }
+
+#define ASSIGN(num, func) \
+ if (lpMap[num] != NULL) \
+ AssignError(num); \
+ lpMap[num] = func; \
+ lpStrMap[num] = #func;
+
+class RMTony;
+class RMPointer;
+class RMGameBoxes;
+class RMLocation;
+class RMInventory;
+class RMInput;
+
+void INIT_CUSTOM_FUNCTION(LPCUSTOMFUNCTION *lpMap, Common::String *lpStrMap);
+void setupGlobalVars(RMTony *tony, RMPointer *ptr, RMGameBoxes *box, RMLocation *loc, RMInventory *inv, RMInput *input);
+
+#endif
+
+} // end of namespace Tony
diff --git a/engines/tony/debugger.cpp b/engines/tony/debugger.cpp
new file mode 100644
index 0000000000..85d9469519
--- /dev/null
+++ b/engines/tony/debugger.cpp
@@ -0,0 +1,130 @@
+/* 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/coroutines.h"
+#include "tony/debugger.h"
+#include "tony/globals.h"
+#include "tony/tony.h"
+
+namespace Tony {
+
+Debugger::Debugger() : GUI::Debugger() {
+ DCmd_Register("continue", WRAP_METHOD(Debugger, Cmd_Exit));
+ DCmd_Register("scene", WRAP_METHOD(Debugger, Cmd_Scene));
+ DCmd_Register("dirty_rects", WRAP_METHOD(Debugger, Cmd_DirtyRects));
+}
+
+static int strToInt(const char *s) {
+ if (!*s)
+ // No string at all
+ return 0;
+ else if (toupper(s[strlen(s) - 1]) != 'H')
+ // Standard decimal string
+ return atoi(s);
+
+ // Hexadecimal string
+ uint tmp = 0;
+ int read = sscanf(s, "%xh", &tmp);
+ if (read < 1)
+ error("strToInt failed on string \"%s\"", s);
+ return (int)tmp;
+}
+
+/**
+ * Support process for changing the scene
+ */
+struct ChangeSceneDetails {
+ int sceneNumber;
+ int x;
+ int y;
+};
+
+void DebugChangeScene(CORO_PARAM, const void *param) {
+ CORO_BEGIN_CONTEXT;
+ CORO_END_CONTEXT(_ctx);
+
+ uint32 result;
+ const ChangeSceneDetails *details = (const ChangeSceneDetails *)param;
+ RMPoint scenePos(details->x, details->y);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ CORO_INVOKE_2(g_vm->getEngine()->unloadLocation, false, &result);
+
+ g_vm->getEngine()->loadLocation(details->sceneNumber, scenePos, RMPoint(-1, -1));
+
+ mainEnableGUI();
+
+ CORO_END_CODE;
+}
+
+
+/**
+ * This command loads up the specified new scene number
+ */
+bool Debugger::Cmd_Scene(int argc, const char **argv) {
+ if (argc < 2) {
+ DebugPrintf("Usage: %s <scene number> [<x> <y>]\n", argv[0]);
+ return true;
+ }
+
+ int sceneNumber = strToInt(argv[1]);
+ if (sceneNumber >= g_vm->_theBoxes.getLocBoxesCount()) {
+ DebugPrintf("Invalid scene\n");
+ return true;
+ }
+
+ RMPoint scenePos;
+ if (argc >= 4) {
+ scenePos._x = strToInt(argv[2]);
+ scenePos._y = strToInt(argv[3]);
+ } else {
+ // Get the box areas for the scene, and choose one so as to have a default
+ // position for Tony that will be in the walkable areas
+ RMBoxLoc *box = g_vm->_theBoxes.getBoxes(sceneNumber);
+ scenePos.set(box->_boxes[0]._hotspot[0]._hotx, box->_boxes[0]._hotspot[0]._hoty);
+ }
+
+ // Set up a process to change the scene
+ ChangeSceneDetails details;
+ details.sceneNumber = sceneNumber;
+ details.x = scenePos._x;
+ details.y = scenePos._y;
+ CoroScheduler.createProcess(DebugChangeScene, &details, sizeof(ChangeSceneDetails));
+
+ return false;
+}
+
+/**
+ * Turns showing dirty rects on or off
+ */
+bool Debugger::Cmd_DirtyRects(int argc, const char **argv) {
+ if (argc != 2) {
+ DebugPrintf("Usage; %s [on | off]\n", argv[0]);
+ return true;
+ } else {
+ g_vm->_window.showDirtyRects(strcmp(argv[1], "on") == 0);
+ return false;
+ }
+}
+
+} // End of namespace Tony
diff --git a/engines/agos/installshield_cab.h b/engines/tony/debugger.h
index f7e8bed277..85ba9d75b6 100644
--- a/engines/agos/installshield_cab.h
+++ b/engines/tony/debugger.h
@@ -11,7 +11,7 @@
* 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
+ * 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
@@ -20,22 +20,24 @@
*
*/
-#include "common/archive.h"
-#include "common/str.h"
+#ifndef TONY_DEBUGGER_H
+#define TONY_DEBUGGER_H
-#ifndef AGOS_INSTALLSHIELD_CAB_H
-#define AGOS_INSTALLSHIELD_CAB_H
+#include "common/scummsys.h"
+#include "gui/debugger.h"
-namespace AGOS {
+namespace Tony {
-/**
- * This factory method creates an Archive instance corresponding to the content
- * of the InstallShield compressed file with the given name.
- *
- * May return 0 in case of a failure.
- */
-Common::Archive *makeInstallShieldArchive(const Common::String &name);
+class Debugger : public GUI::Debugger {
+public:
+ Debugger();
+ virtual ~Debugger() {}
+
+protected:
+ bool Cmd_Scene(int argc, const char **argv);
+ bool Cmd_DirtyRects(int argc, const char **argv);
+};
-} // End of namespace AGOS
+} // End of namespace Tony
#endif
diff --git a/engines/tony/detection.cpp b/engines/tony/detection.cpp
new file mode 100644
index 0000000000..8e6d5a64c3
--- /dev/null
+++ b/engines/tony/detection.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 "base/plugins.h"
+
+#include "common/memstream.h"
+#include "engines/advancedDetector.h"
+#include "common/system.h"
+#include "graphics/colormasks.h"
+#include "graphics/surface.h"
+
+#include "tony/tony.h"
+#include "tony/game.h"
+
+namespace Tony {
+
+enum {
+ GF_COMPRESSED = (1 << 0)
+};
+
+struct TonyGameDescription {
+ ADGameDescription desc;
+};
+
+uint32 TonyEngine::getFeatures() const {
+ return _gameDescription->desc.flags;
+}
+
+Common::Language TonyEngine::getLanguage() const {
+ return _gameDescription->desc.language;
+}
+
+bool TonyEngine::getIsDemo() const {
+ return _gameDescription->desc.flags & ADGF_DEMO;
+}
+
+bool TonyEngine::isCompressed() const {
+ return _gameDescription->desc.flags & GF_COMPRESSED;
+}
+
+} // End of namespace Tony
+
+static const PlainGameDescriptor tonyGames[] = {
+ {"tony", "Tony Tough and the Night of Roasted Moths"},
+ {0, 0}
+};
+
+#include "tony/detection_tables.h"
+
+class TonyMetaEngine : public AdvancedMetaEngine {
+public:
+ TonyMetaEngine() : AdvancedMetaEngine(Tony::gameDescriptions, sizeof(Tony::TonyGameDescription), tonyGames) {
+ }
+
+ virtual const char *getName() const {
+ return "Tony Engine";
+ }
+
+ virtual const char *getOriginalCopyright() const {
+ return "Tony Engine (C) Protonic Interactive";
+ }
+
+ virtual bool hasFeature(MetaEngineFeature f) const;
+ virtual bool createInstance(OSystem *syst, Engine **engine, const ADGameDescription *desc) const;
+ virtual SaveStateList listSaves(const char *target) const;
+ virtual int getMaximumSaveSlot() const;
+ virtual void removeSaveState(const char *target, int slot) const;
+ SaveStateDescriptor querySaveMetaInfos(const char *target, int slot) const;
+};
+
+bool TonyMetaEngine::hasFeature(MetaEngineFeature f) const {
+ return
+ (f == kSupportsListSaves) ||
+ (f == kSupportsLoadingDuringStartup) ||
+ (f == kSupportsDeleteSave) ||
+ (f == kSavesSupportMetaInfo) ||
+ (f == kSavesSupportThumbnail);
+}
+
+bool Tony::TonyEngine::hasFeature(EngineFeature f) const {
+ return
+ (f == kSupportsRTL) ||
+ (f == kSupportsLoadingDuringRuntime) ||
+ (f == kSupportsSavingDuringRuntime);
+}
+
+bool TonyMetaEngine::createInstance(OSystem *syst, Engine **engine, const ADGameDescription *desc) const {
+ const Tony::TonyGameDescription *gd = (const Tony::TonyGameDescription *)desc;
+ if (gd) {
+ *engine = new Tony::TonyEngine(syst, gd);
+ }
+ return gd != 0;
+}
+
+SaveStateList TonyMetaEngine::listSaves(const char *target) const {
+ Common::SaveFileManager *saveFileMan = g_system->getSavefileManager();
+ Common::StringArray filenames;
+ Common::String saveDesc;
+ Common::String pattern = "tony.0??";
+
+ filenames = saveFileMan->listSavefiles(pattern);
+ sort(filenames.begin(), filenames.end()); // Sort (hopefully ensuring we are sorted numerically..)
+
+ SaveStateList saveList;
+ for (Common::StringArray::const_iterator file = filenames.begin(); file != filenames.end(); ++file) {
+ // Obtain the last 3 digits of the filename, since they correspond to the save slot
+ int slotNum = atoi(file->c_str() + file->size() - 3);
+
+ if (slotNum >= 0 && slotNum <= 999) {
+ byte thumbnailData[160 * 120 * 2];
+ Common::String saveName;
+ byte difficulty;
+
+ if (Tony::RMOptionScreen::loadThumbnailFromSaveState(slotNum, thumbnailData, saveName, difficulty)) {
+ // Add the save name to the savegame list
+ saveList.push_back(SaveStateDescriptor(slotNum, saveName));
+ }
+ }
+ }
+
+ return saveList;
+}
+
+int TonyMetaEngine::getMaximumSaveSlot() const {
+ return 99;
+}
+
+void TonyMetaEngine::removeSaveState(const char *target, int slot) const {
+ Common::String filename = Tony::TonyEngine::getSaveStateFileName(slot);
+
+ g_system->getSavefileManager()->removeSavefile(filename);
+}
+
+SaveStateDescriptor TonyMetaEngine::querySaveMetaInfos(const char *target, int slot) const {
+ Common::String saveName;
+ byte difficulty;
+ byte thumbData[160 * 120 * 2];
+
+ if (Tony::RMOptionScreen::loadThumbnailFromSaveState(slot, thumbData, saveName, difficulty)) {
+ // Convert the 565 thumbnail data to the needed overlay format
+ Common::MemoryReadStream thumbStream(thumbData, 160 * 120 * 2);
+ Graphics::PixelFormat destFormat = g_system->getOverlayFormat();
+ Graphics::Surface *to = new Graphics::Surface();
+ to->create(160, 120, destFormat);
+
+ OverlayColor *pixels = (OverlayColor *)to->pixels;
+ for (int y = 0; y < to->h; ++y) {
+ for (int x = 0; x < to->w; ++x) {
+ uint8 r, g, b;
+ Graphics::colorToRGB<Graphics::ColorMasks<555> >(thumbStream.readUint16LE(), r, g, b);
+
+ // converting to current OSystem Color
+ *pixels++ = destFormat.RGBToColor(r, g, b);
+ }
+ }
+
+ // Create the return descriptor
+ SaveStateDescriptor desc(slot, saveName);
+ desc.setDeletableFlag(true);
+ desc.setWriteProtectedFlag(false);
+ desc.setThumbnail(to);
+
+ return desc;
+ }
+
+ return SaveStateDescriptor();
+}
+
+
+#if PLUGIN_ENABLED_DYNAMIC(TONY)
+REGISTER_PLUGIN_DYNAMIC(TONY, PLUGIN_TYPE_ENGINE, TonyMetaEngine);
+#else
+REGISTER_PLUGIN_STATIC(TONY, PLUGIN_TYPE_ENGINE, TonyMetaEngine);
+#endif
diff --git a/engines/tony/detection_tables.h b/engines/tony/detection_tables.h
new file mode 100644
index 0000000000..f9881c29f2
--- /dev/null
+++ b/engines/tony/detection_tables.h
@@ -0,0 +1,145 @@
+/* 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.
+ *
+ */
+
+namespace Tony {
+
+static const TonyGameDescription gameDescriptions[] = {
+ {
+ // Tony Tough English
+ {
+ "tony",
+ 0,
+ {
+ // TODO: AdvancedDetector seems to have a problem where it thinks data1.cab is unrecognized.
+ // Is it perhaps because the Agos engine also has detection entries for data1.cab?
+ {"data1.cab", 0, "ce82907242166bfb594d97bdb68f96d2", 4350},
+ /*{"roasted.mpr", 0, "06203dbbc85fdd1e6dc8fc211c1a6207", 135911071},
+ {"roasted.mpc", 0, "57c4a3860cf899443c357e0078ea6f49", 366773},*/
+ AD_LISTEND
+ },
+ Common::EN_ANY,
+ Common::kPlatformWindows,
+ ADGF_NO_FLAGS,
+ GUIO1(GUIO_NONE)
+ },
+ },
+
+ {
+ // Tony Tough English Demo
+ {
+ "tony",
+ "Extracted Demo",
+ {
+ {"roasted.mpr", 0, "06203dbbc85fdd1e6dc8fc211c1a6207", 14972409},
+ {"roasted.mpc", 0, "1e247922ec869712bfd96625bc4d3c7c", 39211},
+ AD_LISTEND
+ },
+ Common::EN_ANY,
+ Common::kPlatformWindows,
+ ADGF_DEMO,
+ GUIO1(GUIO_NONE)
+ },
+ },
+
+ {
+ // Tony Tough English Demo (Compressed)
+ {
+ "tony",
+ "Demo",
+ {
+ {"data1.cab", 0, "7d8b6d308f96aee3968ad7910fb11e6d", 58660608},
+ AD_LISTEND
+ },
+ Common::EN_ANY,
+ Common::kPlatformWindows,
+ ADGF_DEMO | GF_COMPRESSED,
+ GUIO1(GUIO_NONE)
+ },
+ },
+ {
+ // Tony Tough French "Collection Aventure" provided by Strangerke
+ {
+ "tony",
+ 0,
+ {
+ {"roasted.mpr", 0, "06203dbbc85fdd1e6dc8fc211c1a6207", 135911071},
+ {"roasted.mpc", 0, "e890c6a41238827bdfa9874a65618b69", 374135},
+ AD_LISTEND
+ },
+ Common::FR_FRA,
+ Common::kPlatformWindows,
+ ADGF_NO_FLAGS,
+ GUIO1(GUIO_NONE)
+ },
+ },
+ {
+ // Tony Tough German "Shoe Box" provided by Strangerke
+ {
+ "tony",
+ 0,
+ {
+ {"roasted.mpr", 0, "06203dbbc85fdd1e6dc8fc211c1a6207", 135911071},
+ {"roasted.mpc", 0, "ccf7ab939a34de1b13df538596431684", 389554},
+ AD_LISTEND
+ },
+ Common::DE_DEU,
+ Common::kPlatformWindows,
+ ADGF_NO_FLAGS,
+ GUIO1(GUIO_NONE)
+ },
+ },
+ {
+ // Tony Tough Italian provided by Fabio Barzagli
+ {
+ "tony",
+ 0,
+ {
+ {"roasted.mpr", 0, "06203dbbc85fdd1e6dc8fc211c1a6207", 135911071},
+ {"roasted.mpc", 0, "1dc896cdb945170d7408598f803411c1", 380001},
+ AD_LISTEND
+ },
+ Common::IT_ITA,
+ Common::kPlatformWindows,
+ ADGF_NO_FLAGS,
+ GUIO1(GUIO_NONE)
+ },
+ },
+ {
+ // Tony Tough Polish provided by Fabio Barzagli
+ {
+ "tony",
+ 0,
+ {
+ {"roasted.mpr", 0, "06203dbbc85fdd1e6dc8fc211c1a6207", 135911071},
+ {"roasted.mpc", 0, "89733ea710669acc8e7900b115f4afef", 389625},
+ AD_LISTEND
+ },
+ Common::PL_POL,
+ Common::kPlatformWindows,
+ ADGF_NO_FLAGS,
+ GUIO1(GUIO_NONE)
+ },
+ },
+ { AD_TABLE_END_MARKER }
+};
+
+} // End of namespace Tony
diff --git a/engines/tony/font.cpp b/engines/tony/font.cpp
new file mode 100644
index 0000000000..927adf9006
--- /dev/null
+++ b/engines/tony/font.cpp
@@ -0,0 +1,1200 @@
+/* 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.
+ *
+ */
+
+/*
+ * This code is based on original Tony Tough source code
+ *
+ * Copyright (c) 1997-2003 Nayma Software
+ */
+
+#include "common/textconsole.h"
+#include "tony/mpal/mpalutils.h"
+#include "tony/font.h"
+#include "tony/input.h"
+#include "tony/inventory.h"
+#include "tony/loc.h"
+#include "tony/tony.h"
+
+namespace Tony {
+
+/****************************************************************************\
+* RMFont Methods
+\****************************************************************************/
+
+RMFont::RMFont() {
+ _letter = NULL;
+ _nLetters = _fontDimx = _fontDimy = _dimx = _dimy = 0;
+}
+
+RMFont::~RMFont() {
+ unload();
+}
+
+void RMFont::load(const byte *buf, int nChars, int dimx, int dimy, uint32 palResID) {
+ _letter = new RMGfxSourceBuffer8RLEByte[nChars];
+
+ // Initialize the fonts
+ for (int i = 0; i < nChars; i++) {
+ // Initialize the buffer with the letters
+ _letter[i].init(buf + i * (dimx * dimy + 8) + 8, dimx, dimy);
+ _letter[i].loadPaletteWA(palResID);
+ }
+
+ _fontDimx = dimx;
+ _fontDimy = dimy;
+
+ _nLetters = nChars;
+}
+
+void RMFont::load(uint32 resID, int nChars, int dimx, int dimy, uint32 palResID) {
+ RMRes res(resID);
+
+ if ((int)res.size() < nChars * (dimy * dimx + 8))
+ nChars = res.size() / (dimy * dimx + 8);
+
+ load(res, nChars, dimx, dimy, palResID);
+}
+
+void RMFont::unload() {
+ if (_letter != NULL) {
+ delete[] _letter;
+ _letter = NULL;
+ }
+}
+
+
+RMGfxPrimitive *RMFont::makeLetterPrimitive(byte bChar, int &nLength) {
+ RMFontPrimitive *prim;
+ int nLett;
+
+ // Convert from character to glyph index
+ nLett = convertToLetter(bChar);
+ assert(nLett < _nLetters);
+
+ // Create primitive font
+ prim = new RMFontPrimitive(this);
+ prim->_nChar = nLett;
+
+ // Get the length of the character in pixels
+ nLength = letterLength(bChar);
+
+ return prim;
+}
+
+void RMFont::draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim2) {
+ CORO_BEGIN_CONTEXT;
+ CORO_END_CONTEXT(_ctx);
+
+ RMFontPrimitive *prim = (RMFontPrimitive *)prim2;
+
+ CORO_BEGIN_CODE(_ctx);
+
+ // Call the draw method of the letter assigned to the primitive
+ if (prim->_nChar != -1)
+ CORO_INVOKE_2(_letter[prim->_nChar].draw, bigBuf, prim);
+
+ CORO_END_CODE;
+}
+
+void RMFont::close() {
+ unload();
+}
+
+int RMFont::stringLen(const Common::String &text) {
+ uint len, i;
+
+ if (text.empty())
+ return letterLength('\0');
+
+ len = 0;
+ for (i = 0; i < text.size() - 1; i++)
+ len += letterLength(text[i], text[i + 1]);
+ len += letterLength(text[i]);
+
+ return len;
+}
+
+int RMFont::stringLen(char bChar, char bNext) {
+ return letterLength(bChar, bNext);
+}
+
+/****************************************************************************\
+* RMFontColor Methods
+\****************************************************************************/
+
+RMFontColor::RMFontColor() : RMFont() {
+ _fontR = _fontG = _fontB = 255;
+}
+
+RMFontColor::~RMFontColor() {
+}
+
+void RMFontColor::setBaseColor(byte r1, byte g1, byte b1) {
+ int r = (int)r1 << 16;
+ int g = (int)g1 << 16;
+ int b = (int)b1 << 16;
+
+ int rstep = r / 14;
+ int gstep = g / 14;
+ int bstep = b / 14;
+
+ int i;
+ byte pal[768 * 3];
+
+ // Check if we are already on the right color
+ if (_fontR == r1 && _fontG == g1 && _fontB == b1)
+ return;
+
+ _fontR = r1;
+ _fontG = g1;
+ _fontB = b1;
+
+ // Constructs a new palette for the font
+ for (i = 1; i < 16; i++) {
+ pal[i * 3 + 0] = r >> 16;
+ pal[i * 3 + 1] = g >> 16;
+ pal[i * 3 + 2] = b >> 16;
+
+ r -= rstep;
+ g -= gstep;
+ b -= bstep;
+ }
+
+ pal[15 * 3 + 0] += 8;
+ pal[15 * 3 + 1] += 8;
+ pal[15 * 3 + 2] += 8;
+
+ // Puts in all the letters
+ for (i = 0; i < _nLetters; i++)
+ _letter[i].loadPaletteWA(pal);
+}
+
+/***************************************************************************\
+* RMFontWithTables Methods
+\****************************************************************************/
+int RMFontWithTables::convertToLetter(byte nChar) {
+ return _cTable[nChar];
+}
+
+int RMFontWithTables::letterLength(int nChar, int nNext) {
+ return (nChar != -1 ? _lTable[(byte)nChar] + _l2Table[(byte)nChar][(byte)nNext] : _lDefault);
+}
+
+/***************************************************************************\
+* RMFontDialog Methods
+\****************************************************************************/
+
+void RMFontDialog::init() {
+ int i;
+
+ // bernie: Number of characters in the font
+ int nchars =
+ 112 // base
+ + 18 // polish
+ + 66 // russian
+ + 30 // czech
+ + 8 // french
+ + 5; // deutsch
+
+ load(RES_F_PARL, nchars, 20, 20);
+
+ // Initialize the font table
+ _lDefault = 13;
+ _hDefault = 18;
+ Common::fill(&_l2Table[0][0], &_l2Table[0][0] + (256 * 256), '\0');
+
+ for (i = 0; i < 256; i++) {
+ _cTable[i] = g_vm->_cTableDialog[i];
+ _lTable[i] = g_vm->_lTableDialog[i];
+ }
+}
+
+
+/***************************************************************************\
+* RMFontMacc Methods
+\****************************************************************************/
+
+void RMFontMacc::init() {
+ int i;
+
+ // bernie: Number of characters in the font
+ int nchars =
+ 102 // base
+ + 18 // polish
+ + 66 // russian
+ + 30 // czech
+ + 8 // francais
+ + 5; // deutsch
+
+
+ load(RES_F_MACC, nchars, 11, 16);
+
+ // Default
+ _lDefault = 10;
+ _hDefault = 17;
+ Common::fill(&_l2Table[0][0], &_l2Table[0][0] + (256 * 256), '\0');
+
+ for (i = 0; i < 256; i++) {
+ _cTable[i] = g_vm->_cTableMacc[i];
+ _lTable[i] = g_vm->_lTableMacc[i];
+ }
+}
+
+/***************************************************************************\
+* RMFontCredits Methods
+\****************************************************************************/
+
+void RMFontCredits::init() {
+ int i;
+
+ // bernie: Number of characters in the font
+ int nchars =
+ 112 // base
+ + 18 // polish
+ + 66 // russian
+ + 30 // czech
+ + 8 // french
+ + 2; // deutsch
+
+
+ load(RES_F_CREDITS, nchars, 27, 28, RES_F_CPAL);
+
+ // Default
+ _lDefault = 10;
+ _hDefault = 28;
+ Common::fill(&_l2Table[0][0], &_l2Table[0][0] + (256 * 256), '\0');
+
+ for (i = 0; i < 256; i++) {
+ _cTable[i] = g_vm->_cTableCred[i];
+ _lTable[i] = g_vm->_lTableCred[i];
+ }
+}
+
+
+
+/***************************************************************************\
+* RMFontObj Methods
+\****************************************************************************/
+
+#define TOUPPER(a) ((a) >= 'a' && (a) <= 'z' ? (a) + 'A' - 'a' : (a))
+#define TOLOWER(a) ((a) >= 'A' && (a) <= 'Z' ? (a) + 'a' - 'A' : (a))
+
+void RMFontObj::setBothCase(int nChar, int nNext, signed char spiazz) {
+ _l2Table[TOUPPER(nChar)][TOUPPER(nNext)] = spiazz;
+ _l2Table[TOUPPER(nChar)][TOLOWER(nNext)] = spiazz;
+ _l2Table[TOLOWER(nChar)][TOUPPER(nNext)] = spiazz;
+ _l2Table[TOLOWER(nChar)][TOLOWER(nNext)] = spiazz;
+}
+
+
+void RMFontObj::init() {
+ int i;
+
+ //bernie: Number of characters in the font (solo maiuscolo)
+ int nchars =
+ 85 // base
+ + 9 // polish
+ + 33 // russian
+ + 15 // czech
+ + 0 // francais (no uppercase chars)
+ + 1; // deutsch
+
+
+ load(RES_F_OBJ, nchars, 25, 30);
+
+ // Initialize the font table
+ _lDefault = 26;
+ _hDefault = 30;
+ Common::fill(&_l2Table[0][0], &_l2Table[0][0] + (256 * 256), '\0');
+
+ for (i = 0; i < 256; i++) {
+ _cTable[i] = g_vm->_cTableObj[i];
+ _lTable[i] = g_vm->_lTableObj[i];
+ }
+
+ // Special case
+ setBothCase('C', 'C', 2);
+ setBothCase('A', 'T', -2);
+ setBothCase('R', 'S', 2);
+ setBothCase('H', 'I', -2);
+ setBothCase('T', 'S', 2);
+ setBothCase('O', 'R', 2);
+ setBothCase('O', 'L', 2);
+ setBothCase('O', 'G', 2);
+ setBothCase('Z', 'A', -1);
+ setBothCase('R', 'R', 1);
+ setBothCase('R', 'U', 3);
+}
+
+
+/****************************************************************************\
+* RMText Methods
+\****************************************************************************/
+
+RMFontColor *RMText::_fonts[4] = { NULL, NULL, NULL, NULL };
+
+void RMText::initStatics() {
+ Common::fill(&_fonts[0], &_fonts[4], (RMFontColor *)NULL);
+}
+
+RMText::RMText() {
+ // Default color: white
+ _textR = _textG = _textB = 255;
+
+ // Default length
+ _maxLineLength = 350;
+
+ _bTrasp0 = true;
+ _aHorType = HCENTER;
+ _aVerType = VTOP;
+ setPriority(150);
+}
+
+RMText::~RMText() {
+}
+
+void RMText::unload() {
+ if (_fonts[0] != NULL) {
+ delete _fonts[0];
+ delete _fonts[1];
+ delete _fonts[2];
+ delete _fonts[3];
+ _fonts[0] = _fonts[1] = _fonts[2] = _fonts[3] = 0;
+ }
+}
+
+void RMText::setMaxLineLength(int max) {
+ _maxLineLength = max;
+}
+
+void RMText::removeThis(CORO_PARAM, bool &result) {
+ // Here we can do checks on the number of frames, time spent, etc.
+ result = true;
+}
+
+void RMText::writeText(const Common::String &text, int nFont, int *time) {
+ // Initializes the font (only once)
+ if (_fonts[0] == NULL) {
+ _fonts[0] = new RMFontDialog;
+ _fonts[0]->init();
+ _fonts[1] = new RMFontObj;
+ _fonts[1]->init();
+ _fonts[2] = new RMFontMacc;
+ _fonts[2]->init();
+ _fonts[3] = new RMFontCredits;
+ _fonts[3]->init();
+ }
+
+ writeText(text, _fonts[nFont], time);
+}
+
+void RMText::writeText(Common::String text, RMFontColor *font, int *time) {
+ RMGfxPrimitive *prim;
+ uint p, old_p;
+ int j, x, y;
+ int len;
+ int numchar;
+ int width, height;
+
+ // Set the base color
+ font->setBaseColor(_textR, _textG, _textB);
+
+ // Destroy the buffer before starting
+ destroy();
+
+ // If the string is empty, do nothing
+ if (text.empty())
+ return;
+
+ // Divide the words into lines. In this cycle, X contains the maximum length reached by a line,
+ // and the number of lines
+ Common::Array<Common::String> lines;
+ p = 0;
+ j = x = 0;
+ while (p < text.size()) {
+ j += font->stringLen(text[p]);
+ if (j > (((_aHorType == HLEFTPAR) && (lines.size() > 0)) ? _maxLineLength - 25 : _maxLineLength)) {
+ j -= font->stringLen(text[p], (p + 1 == text.size()) ? '\0' : text[p + 1]);
+ if (j > x)
+ x = j;
+
+ // Back to the first usable space
+ //
+ // BERNIE: In the original, sentences containing words that exceed the
+ // width of a line caused discontinuation of the whole sentence.
+ // This workaround has the partial word broken up so it will still display
+ //
+ old_p = p;
+ while (text[p] != ' ' && text[p] != '-' && p > 0)
+ p--;
+
+ if (p == 0)
+ p = old_p;
+
+ // Check if there are any blanks to end
+ while ((text[p] == ' ' || text[p] == '-') && p + 1 < text.size())
+ p++;
+ if (p == text.size())
+ break;
+ lines.push_back(Common::String(text.c_str(), p));
+ if (text[p] == ' ')
+ p++;
+ text = text.c_str() + p;
+ p = 0;
+ j = 0;
+ continue;
+ }
+ p++;
+ }
+
+ if (j > x)
+ x = j;
+
+ // Add the last line of text.
+ lines.push_back(text);
+
+ x += 8;
+
+ // Starting position for the surface: X1, Y
+ width = x;
+ height = (lines.size() - 1) * font->letterHeight() + font->_fontDimy;
+
+ // Create the surface
+ create(width, height);
+ Common::fill(_buf, _buf + width * height * 2, 0);
+
+ p = 0;
+
+ y = 0;
+ numchar = 0;
+ for (uint i = 0; i < lines.size(); ++i) {
+ const Common::String &line = lines[i];
+
+ // Measure the length of the line
+ x = 0;
+ j = font->stringLen(line);
+
+ switch (_aHorType) {
+ case HLEFT:
+ x = 0;
+ break;
+
+ case HLEFTPAR:
+ if (i == 0)
+ x = 0;
+ else
+ x = 25;
+ break;
+
+ case HCENTER:
+ x = width / 2 - j / 2;
+ break;
+
+ case HRIGHT:
+ x = width - j - 1;
+ break;
+ }
+
+ p = 0;
+ while (p < line.size()) {
+ if (line[p] == ' ') {
+ x += font->stringLen(line[p]);
+ p++;
+ continue;
+ }
+
+ prim = font->makeLetterPrimitive(line[p], len);
+ prim->getDst()._x1 = x;
+ prim->getDst()._y1 = y;
+ addPrim(prim);
+
+ numchar++;
+
+ x += font->stringLen(line[p], (p + 1 == line.size()) ? '\0' : line[p + 1]);
+ p++;
+ }
+ p++;
+ y += font->letterHeight();
+ }
+
+ if (time != NULL)
+ *time = 1000 + numchar * (11 - GLOBALS._nCfgTextSpeed) * 14;
+}
+
+void RMText::clipOnScreen(RMGfxPrimitive *prim) {
+ // Don't let it go outside the screen
+ if (prim->getDst()._x1 < 5)
+ prim->getDst()._x1 = 5;
+ if (prim->getDst()._y1 < 5)
+ prim->getDst()._y1 = 5;
+ if (prim->getDst()._x1 + _dimx > 635)
+ prim->getDst()._x1 = 635 - _dimx;
+ if (prim->getDst()._y1 + _dimy > 475)
+ prim->getDst()._y1 = 475 - _dimy;
+}
+
+void RMText::draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim) {
+ CORO_BEGIN_CONTEXT;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+ // Horizontally
+ if (_aHorType == HCENTER)
+ prim->getDst().topLeft() -= RMPoint(_dimx / 2, 0);
+ else if (_aHorType == HRIGHT)
+ prim->getDst().topLeft() -= RMPoint(_dimx, 0);
+
+
+ // Vertically
+ if (_aVerType == VTOP) {
+
+ } else if (_aVerType == VCENTER) {
+ prim->getDst()._y1 -= _dimy / 2;
+
+ } else if (_aVerType == VBOTTOM) {
+ prim->getDst()._y1 -= _dimy;
+ }
+
+ clipOnScreen(prim);
+
+ CORO_INVOKE_2(RMGfxWoodyBuffer::draw, bigBuf, prim);
+
+ CORO_END_CODE;
+}
+
+/**
+ * Set the alignment type
+ */
+void RMText::setAlignType(HorAlign aHor, VerAlign aVer) {
+ _aHorType = aHor;
+ _aVerType = aVer;
+}
+
+/**
+ * Set the base color
+ */
+void RMText::setColor(byte r, byte g, byte b) {
+ _textR = r;
+ _textG = g;
+ _textB = b;
+}
+
+/****************************************************************************\
+* RMTextDialog Methods
+\****************************************************************************/
+
+RMTextDialog::RMTextDialog() : RMText() {
+ _time = _startTime = 0;
+ _dst = RMPoint(0, 0);
+
+ _bSkipStatus = true;
+ _bShowed = true;
+ _bForceTime = false;
+ _bForceNoTime = false;
+ _bAlwaysDisplay = false;
+ _bNoTab = false;
+ _hCustomSkip = CORO_INVALID_PID_VALUE;
+ _hCustomSkip2 = CORO_INVALID_PID_VALUE;
+ _input = NULL;
+
+ // Create the event for displaying the end
+ _hEndDisplay = CoroScheduler.createEvent(false, false);
+}
+
+RMTextDialog::~RMTextDialog() {
+ CoroScheduler.closeEvent(_hEndDisplay);
+}
+
+void RMTextDialog::show() {
+ _bShowed = true;
+}
+
+void RMTextDialog::hide(CORO_PARAM) {
+ _bShowed = false;
+}
+
+void RMTextDialog::writeText(const Common::String &text, int font, int *time) {
+ RMText::writeText(text, font, &_time);
+
+ if (time != NULL)
+ *time = _time;
+}
+
+void RMTextDialog::writeText(const Common::String &text, RMFontColor *font, int *time) {
+ RMText::writeText(text, font, &_time);
+
+ if (time != NULL)
+ *time = _time;
+}
+
+
+void RMTextDialog::setSkipStatus(bool bEnabled) {
+ _bSkipStatus = bEnabled;
+}
+
+void RMTextDialog::forceTime() {
+ _bForceTime = true;
+}
+
+void RMTextDialog::forceNoTime() {
+ _bForceNoTime = true;
+}
+
+void RMTextDialog::setNoTab() {
+ _bNoTab = true;
+}
+
+void RMTextDialog::setForcedTime(uint32 dwTime) {
+ _time = dwTime;
+}
+
+void RMTextDialog::setAlwaysDisplay() {
+ _bAlwaysDisplay = true;
+}
+
+void RMTextDialog::removeThis(CORO_PARAM, bool &result) {
+ CORO_BEGIN_CONTEXT;
+ bool expired;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ // Presume successful result
+ result = true;
+
+ // Don't erase the background
+ if (_bSkipStatus) {
+ if (!(GLOBALS._bCfgDubbing && _hCustomSkip2 != CORO_INVALID_PID_VALUE)) {
+ if (GLOBALS._bCfgTimerizedText) {
+ if (!_bForceNoTime) {
+ if (g_vm->getTime() > (uint32)_time + _startTime)
+ return;
+ }
+ }
+ }
+
+ if (!_bNoTab) {
+ if (g_vm->getEngine()->getInput().getAsyncKeyState(Common::KEYCODE_TAB))
+ return;
+ }
+
+ if (!_bNoTab) {
+ if (_input) {
+ if (_input->mouseLeftClicked() || _input->mouseRightClicked())
+ return;
+ }
+ }
+ }
+ // Erase the background
+ else if (!(GLOBALS._bCfgDubbing && _hCustomSkip2 != CORO_INVALID_PID_VALUE)) {
+ if (!_bForceNoTime) {
+ if (g_vm->getTime() > (uint32)_time + _startTime)
+ return;
+ }
+ }
+
+ // If time is forced
+ if (_bForceTime) {
+ if (g_vm->getTime() > (uint32)_time + _startTime)
+ return;
+ }
+
+ if (_hCustomSkip != CORO_INVALID_PID_VALUE) {
+ CORO_INVOKE_3(CoroScheduler.waitForSingleObject, _hCustomSkip, 0, &_ctx->expired);
+ // == WAIT_OBJECT_0
+ if (!_ctx->expired)
+ return;
+ }
+
+ if (GLOBALS._bCfgDubbing && _hCustomSkip2 != CORO_INVALID_PID_VALUE) {
+ CORO_INVOKE_3(CoroScheduler.waitForSingleObject, _hCustomSkip2, 0, &_ctx->expired);
+ // == WAIT_OBJECT_0
+ if (!_ctx->expired)
+ return;
+ }
+
+ result = false;
+
+ CORO_END_CODE;
+}
+
+void RMTextDialog::Unregister() {
+ RMGfxTask::Unregister();
+ assert(_nInList == 0);
+ CoroScheduler.setEvent(_hEndDisplay);
+}
+
+void RMTextDialog::draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim) {
+ CORO_BEGIN_CONTEXT;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ if (_startTime == 0)
+ _startTime = g_vm->getTime();
+
+ if (_bShowed) {
+ if (GLOBALS._bShowSubtitles || _bAlwaysDisplay) {
+ prim->getDst().topLeft() = _dst;
+ CORO_INVOKE_2(RMText::draw, bigBuf, prim);
+ }
+ }
+
+ CORO_END_CODE;
+}
+
+void RMTextDialog::setCustomSkipHandle(uint32 hCustom) {
+ _hCustomSkip = hCustom;
+}
+
+void RMTextDialog::setCustomSkipHandle2(uint32 hCustom) {
+ _hCustomSkip2 = hCustom;
+}
+
+void RMTextDialog::waitForEndDisplay(CORO_PARAM) {
+ CoroScheduler.waitForSingleObject(coroParam, _hEndDisplay, CORO_INFINITE);
+}
+
+void RMTextDialog::setInput(RMInput *input) {
+ _input = input;
+}
+
+/**
+ * Set the position
+ */
+void RMTextDialog::setPosition(const RMPoint &pt) {
+ _dst = pt;
+}
+
+/****************************************************************************\
+* RMTextDialogScrolling Methods
+\****************************************************************************/
+
+RMTextDialogScrolling::RMTextDialogScrolling() {
+ _curLoc = NULL;
+}
+
+RMTextDialogScrolling::RMTextDialogScrolling(RMLocation *loc) {
+ _curLoc = loc;
+ _startScroll = loc->scrollPosition();
+}
+
+RMTextDialogScrolling::~RMTextDialogScrolling() {
+}
+
+void RMTextDialogScrolling::draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim) {
+ CORO_BEGIN_CONTEXT;
+ RMPoint curDst;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ _ctx->curDst = _dst;
+
+ if (_curLoc != NULL)
+ _dst -= _curLoc->scrollPosition() - _startScroll;
+
+ CORO_INVOKE_2(RMTextDialog::draw, bigBuf, prim);
+
+ _dst = _ctx->curDst;
+
+ CORO_END_CODE;
+}
+
+void RMTextDialogScrolling::clipOnScreen(RMGfxPrimitive *prim) {
+ // We must not do anything!
+}
+
+
+/****************************************************************************\
+* RMTextItemName Methods
+\****************************************************************************/
+
+RMTextItemName::RMTextItemName() : RMText() {
+ _item = NULL;
+ setPriority(220);
+}
+
+RMTextItemName::~RMTextItemName() {
+}
+
+void RMTextItemName::doFrame(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMLocation &loc, RMPointer &ptr, RMInventory &inv) {
+ CORO_BEGIN_CONTEXT;
+ RMItem *lastItem;
+ uint32 hThread;
+ CORO_END_CONTEXT(_ctx);
+
+ Common::String itemName;
+
+ CORO_BEGIN_CODE(_ctx);
+
+ _ctx->lastItem = _item;
+
+ // Adds to the list if there is need
+ if (!_nInList)
+ bigBuf.addPrim(new RMGfxPrimitive(this));
+
+ // Update the scrolling co-ordinates
+ _curscroll = loc.scrollPosition();
+
+ // Check if we are on the inventory
+ if (inv.itemInFocus(_mpos))
+ _item = inv.whichItemIsIn(_mpos);
+ else
+ _item = loc.whichItemIsIn(_mpos);
+
+ // If there an item, get its name
+ if (_item != NULL)
+ _item->getName(itemName);
+
+ // Write it
+ writeText(itemName, 1);
+
+ // Handle the change If the selected item is different from the previous one
+ if (_ctx->lastItem != _item) {
+ if (_item == NULL)
+ ptr.setSpecialPointer(RMPointer::PTR_NONE);
+ else {
+ _ctx->hThread = mpalQueryDoAction(20, _item->mpalCode(), 0);
+ if (_ctx->hThread == CORO_INVALID_PID_VALUE)
+ ptr.setSpecialPointer(RMPointer::PTR_NONE);
+ else
+ CORO_INVOKE_2(CoroScheduler.waitForSingleObject, _ctx->hThread, CORO_INFINITE);
+ }
+ }
+
+ CORO_END_CODE;
+}
+
+
+void RMTextItemName::draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim) {
+ CORO_BEGIN_CONTEXT;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ // If there is no text, it's pointless to continue
+ if (_buf == NULL)
+ return;
+
+ // Set the destination coordinates of the mouse
+ prim->getDst().topLeft() = _mpos - RMPoint(0, 30);
+
+ CORO_INVOKE_2(RMText::draw, bigBuf, prim);
+
+ CORO_END_CODE;
+}
+
+RMPoint RMTextItemName::getHotspot() {
+ if (_item == NULL)
+ return _mpos + _curscroll;
+ else
+ return _item->hotspot();
+}
+
+RMItem *RMTextItemName::getSelectedItem() {
+ return _item;
+}
+
+bool RMTextItemName::isItemSelected() {
+ return _item != NULL;
+}
+
+void RMTextItemName::setMouseCoord(const RMPoint &m) {
+ _mpos = m;
+}
+
+void RMTextItemName::removeThis(CORO_PARAM, bool &result) {
+ result = true;
+}
+
+/****************************************************************************\
+* RMDialogChoice Methods
+\****************************************************************************/
+
+RMDialogChoice::RMDialogChoice() {
+ RMResRaw dlg1(RES_I_DLGTEXT);
+ RMResRaw dlg2(RES_I_DLGTEXTLINE);
+ RMRes dlgpal(RES_I_DLGTEXTPAL);
+
+ _dlgText.init(dlg1, dlg1.width(), dlg1.height());
+ _dlgTextLine.init(dlg2, dlg2.width(), dlg2.height());
+
+ _dlgText.loadPaletteWA(dlgpal);
+ _dlgTextLine.loadPaletteWA(dlgpal);
+
+ _hUnreg = CoroScheduler.createEvent(false, false);
+ _bRemoveFromOT = false;
+
+ _curAdded = 0;
+ _bShow = false;
+}
+
+RMDialogChoice::~RMDialogChoice() {
+ CoroScheduler.closeEvent(_hUnreg);
+}
+
+void RMDialogChoice::Unregister() {
+ RMGfxWoodyBuffer::Unregister();
+ assert(!_nInList);
+ CoroScheduler.pulseEvent(_hUnreg);
+
+ _bRemoveFromOT = false;
+}
+
+void RMDialogChoice::init() {
+ _numChoices = 0;
+ _drawedStrings = NULL;
+ _ptDrawStrings = NULL;
+ _curSelection = -1;
+
+ create(640, 477);
+ setPriority(140);
+}
+
+
+void RMDialogChoice::close() {
+ if (_drawedStrings != NULL) {
+ delete[] _drawedStrings;
+ _drawedStrings = NULL;
+ }
+
+ if (_ptDrawStrings != NULL) {
+ delete[] _ptDrawStrings;
+ _ptDrawStrings = NULL;
+ }
+
+ destroy();
+}
+
+void RMDialogChoice::setNumChoices(int num) {
+ int i;
+
+ _numChoices = num;
+ _curAdded = 0;
+
+ // Allocate space for drawn strings
+ _drawedStrings = new RMText[num];
+ _ptDrawStrings = new RMPoint[num];
+
+ // Initialization
+ for (i = 0; i < _numChoices; i++) {
+ _drawedStrings[i].setColor(0, 255, 0);
+ _drawedStrings[i].setAlignType(RMText::HLEFTPAR, RMText::VTOP);
+ _drawedStrings[i].setMaxLineLength(600);
+ _drawedStrings[i].setPriority(10);
+ }
+}
+
+void RMDialogChoice::addChoice(const Common::String &string) {
+ // Draw the string
+ assert(_curAdded < _numChoices);
+ _drawedStrings[_curAdded++].writeText(string, 0);
+}
+
+void RMDialogChoice::prepare(CORO_PARAM) {
+ CORO_BEGIN_CONTEXT;
+ int i;
+ RMPoint ptPos;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ addPrim(new RMGfxPrimitive(&_dlgText, RMPoint(0, 0)));
+ addPrim(new RMGfxPrimitive(&_dlgTextLine, RMPoint(0, 155)));
+ addPrim(new RMGfxPrimitive(&_dlgTextLine, RMPoint(0, 155 + 83)));
+ addPrim(new RMGfxPrimitive(&_dlgTextLine, RMPoint(0, 155 + 83 + 83)));
+ addPrim(new RMGfxPrimitive(&_dlgTextLine, RMPoint(0, 155 + 83 + 83 + 83)));
+
+ _ctx->ptPos.set(20, 90);
+
+ for (_ctx->i = 0; _ctx->i < _numChoices; _ctx->i++) {
+ addPrim(new RMGfxPrimitive(&_drawedStrings[_ctx->i], _ctx->ptPos));
+ _ptDrawStrings[_ctx->i] = _ctx->ptPos;
+ _ctx->ptPos.offset(0, _drawedStrings[_ctx->i].getDimy() + 15);
+ }
+
+ CORO_INVOKE_0(drawOT);
+ clearOT();
+
+ _ptDrawPos.set(0, 480 - _ctx->ptPos._y);
+
+ CORO_END_CODE;
+}
+
+void RMDialogChoice::setSelected(CORO_PARAM, int pos) {
+ CORO_BEGIN_CONTEXT;
+ RMGfxBox box;
+ RMRect rc;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ if (pos == _curSelection)
+ return;
+
+ _ctx->box.setPriority(5);
+
+ if (_curSelection != -1) {
+ _ctx->box.setColor(0xCC, 0xCC, 0xFF);
+ _ctx->rc.topLeft() = RMPoint(18, _ptDrawStrings[_curSelection]._y);
+ _ctx->rc.bottomRight() = _ctx->rc.topLeft() + RMPoint(597, _drawedStrings[_curSelection].getDimy());
+ addPrim(new RMGfxPrimitive(&_ctx->box, _ctx->rc));
+
+ addPrim(new RMGfxPrimitive(&_drawedStrings[_curSelection], _ptDrawStrings[_curSelection]));
+ CORO_INVOKE_0(drawOT);
+ clearOT();
+ }
+
+ if (pos != -1) {
+ _ctx->box.setColor(100, 100, 100);
+ _ctx->rc.topLeft() = RMPoint(18, _ptDrawStrings[pos]._y);
+ _ctx->rc.bottomRight() = _ctx->rc.topLeft() + RMPoint(597, _drawedStrings[pos].getDimy());
+ addPrim(new RMGfxPrimitive(&_ctx->box, _ctx->rc));
+ addPrim(new RMGfxPrimitive(&_drawedStrings[pos], _ptDrawStrings[pos]));
+ }
+
+ CORO_INVOKE_0(drawOT);
+ clearOT();
+
+ _curSelection = pos;
+
+ CORO_END_CODE;
+}
+
+void RMDialogChoice::show(CORO_PARAM, RMGfxTargetBuffer *bigBuf) {
+ CORO_BEGIN_CONTEXT;
+ RMPoint destpt;
+ int deltay;
+ int starttime;
+ int elaps;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ CORO_INVOKE_0(prepare);
+ _bShow = false;
+
+ if (!_nInList && bigBuf != NULL)
+ bigBuf->addPrim(new RMGfxPrimitive(this));
+
+ if (0) {
+ _bShow = true;
+ } else {
+ _ctx->starttime = g_vm->getTime();
+ _ctx->deltay = 480 - _ptDrawPos._y;
+ _ctx->destpt = _ptDrawPos;
+ _ptDrawPos.set(0, 480);
+
+ if (!_nInList && bigBuf != NULL)
+ bigBuf->addPrim(new RMGfxPrimitive(this));
+ _bShow = true;
+
+ _ctx->elaps = 0;
+ while (_ctx->elaps < 700) {
+ CORO_INVOKE_2(CoroScheduler.waitForSingleObject, g_vm->_hEndOfFrame, CORO_INFINITE);
+ _ctx->elaps = g_vm->getTime() - _ctx->starttime;
+ _ptDrawPos._y = 480 - ((_ctx->deltay * 100) / 700 * _ctx->elaps) / 100;
+ }
+
+ _ptDrawPos._y = _ctx->destpt._y;
+ }
+
+ CORO_END_CODE;
+}
+
+void RMDialogChoice::draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim) {
+ CORO_BEGIN_CONTEXT;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ if (_bShow == false)
+ return;
+
+ prim->setDst(_ptDrawPos);
+ CORO_INVOKE_2(RMGfxSourceBuffer16::draw, bigBuf, prim);
+
+ CORO_END_CODE;
+}
+
+
+void RMDialogChoice::hide(CORO_PARAM) {
+ CORO_BEGIN_CONTEXT;
+ int deltay;
+ int starttime;
+ int elaps;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ if (1) {
+ _ctx->starttime = g_vm->getTime();
+
+ _ctx->deltay = 480 - _ptDrawPos._y;
+ _ctx->elaps = 0;
+ while (_ctx->elaps < 700) {
+ CORO_INVOKE_2(CoroScheduler.waitForSingleObject, g_vm->_hEndOfFrame, CORO_INFINITE);
+ _ctx->elaps = g_vm->getTime() - _ctx->starttime;
+ _ptDrawPos._y = 480 - ((_ctx->deltay * 100) / 700 * (700 - _ctx->elaps)) / 100;
+ }
+ }
+
+ _bShow = false;
+ _bRemoveFromOT = true;
+ CORO_INVOKE_2(CoroScheduler.waitForSingleObject, _hUnreg, CORO_INFINITE);
+
+ CORO_END_CODE;
+}
+
+
+void RMDialogChoice::removeThis(CORO_PARAM, bool &result) {
+ result = _bRemoveFromOT;
+}
+
+void RMDialogChoice::doFrame(CORO_PARAM, RMPoint ptMousePos) {
+ CORO_BEGIN_CONTEXT;
+ int i;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ if (ptMousePos._y > _ptDrawPos._y) {
+ for (_ctx->i = 0; _ctx->i < _numChoices; _ctx->i++) {
+ if ((ptMousePos._y >= _ptDrawPos._y + _ptDrawStrings[_ctx->i]._y) && (ptMousePos._y < _ptDrawPos._y + _ptDrawStrings[_ctx->i]._y + _drawedStrings[_ctx->i].getDimy())) {
+ CORO_INVOKE_1(setSelected, _ctx->i);
+ break;
+ }
+ }
+
+ if (_ctx->i == _numChoices)
+ CORO_INVOKE_1(setSelected, -1);
+ }
+
+ CORO_END_CODE;
+}
+
+int RMDialogChoice::getSelection() {
+ return _curSelection;
+}
+
+} // End of namespace Tony
diff --git a/engines/tony/font.h b/engines/tony/font.h
new file mode 100644
index 0000000000..99b20571b1
--- /dev/null
+++ b/engines/tony/font.h
@@ -0,0 +1,379 @@
+/* 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.
+ *
+ */
+/*
+ * This code is based on original Tony Tough source code
+ *
+ * Copyright (c) 1997-2003 Nayma Software
+ */
+
+#ifndef TONY_FONT_H
+#define TONY_FONT_H
+
+#include "common/system.h"
+#include "common/coroutines.h"
+#include "tony/gfxcore.h"
+#include "tony/resid.h"
+
+namespace Tony {
+
+class RMInput;
+class RMInventory;
+class RMItem;
+class RMLoc;
+class RMLocation;
+class RMPointer;
+
+/**
+ * Manages a font, in which there is a different surface for each letter
+ */
+class RMFont : public RMGfxTaskSetPrior {
+protected:
+ int _nLetters;
+ RMGfxSourceBuffer8RLEByte *_letter;
+public:
+ int _fontDimx, _fontDimy;
+
+private:
+ int _dimx, _dimy;
+
+ class RMFontPrimitive : public RMGfxPrimitive {
+ public:
+ RMFontPrimitive() : RMGfxPrimitive() { _nChar = 0; }
+ RMFontPrimitive(RMGfxTask *task) : RMGfxPrimitive(task) { _nChar = 0; }
+ virtual ~RMFontPrimitive() { }
+ virtual RMGfxPrimitive *duplicate() {
+ return new RMFontPrimitive(*this);
+ }
+
+ int _nChar;
+ };
+
+protected:
+ // Loads the font
+ void load(uint32 resID, int nChars, int dimx, int dimy, uint32 palResID = RES_F_PAL);
+ void load(const byte *buf, int nChars, int dimx, int dimy, uint32 palResID = RES_F_PAL);
+
+ // Remove the font
+ void unload();
+
+protected:
+ // Conversion form character to font index
+ virtual int convertToLetter(byte nChar) = 0;
+
+ // Character width
+ virtual int letterLength(int nChar, int nNext = 0) = 0;
+
+public:
+ virtual int letterHeight() = 0;
+
+public:
+ RMFont();
+ virtual ~RMFont();
+
+ // Initialization and closing
+ virtual void init() = 0;
+ virtual void close();
+
+ // Drawing
+ virtual void draw(CORO_PARAM, RMGfxTargetBuffer &bigBug, RMGfxPrimitive *prim);
+
+ // Create a primitive for a letter
+ RMGfxPrimitive *makeLetterPrimitive(byte bChar, int &nLength);
+
+ // Length in pixels of a string with the current font
+ int stringLen(const Common::String &text);
+ int stringLen(char bChar, char bNext = 0);
+};
+
+
+class RMFontColor : public virtual RMFont {
+private:
+ byte _fontR, _fontG, _fontB;
+
+public:
+ RMFontColor();
+ virtual ~RMFontColor();
+ virtual void setBaseColor(byte r, byte g, byte b);
+};
+
+
+class RMFontWithTables : public virtual RMFont {
+protected:
+ int _cTable[256];
+ int _lTable[256];
+ int _lDefault;
+ int _hDefault;
+ signed char _l2Table[256][256];
+
+protected:
+ // Overloaded methods
+ int convertToLetter(byte nChar);
+ int letterLength(int nChar, int nNext = 0);
+
+public:
+ int letterHeight() {
+ return _hDefault;
+ }
+ virtual ~RMFontWithTables() {}
+};
+
+
+class RMFontDialog : public RMFontColor, public RMFontWithTables {
+public:
+ void init();
+ virtual ~RMFontDialog() {}
+};
+
+class RMFontObj : public RMFontColor, public RMFontWithTables {
+private:
+ void setBothCase(int nChar, int nNext, signed char spiazz);
+
+public:
+ void init();
+ virtual ~RMFontObj() {}
+};
+
+class RMFontMacc : public RMFontColor, public RMFontWithTables {
+public:
+ void init();
+ virtual ~RMFontMacc() {}
+};
+
+class RMFontCredits : public RMFontColor, public RMFontWithTables {
+public:
+ void init();
+ virtual ~RMFontCredits() {}
+ virtual void setBaseColor(byte r, byte g, byte b) {}
+};
+
+/**
+ * Manages writing text onto9 the screen
+ */
+class RMText : public RMGfxWoodyBuffer {
+private:
+ static RMFontColor *_fonts[4];
+ int _maxLineLength;
+
+public:
+ enum HorAlign {
+ HLEFT,
+ HLEFTPAR,
+ HCENTER,
+ HRIGHT
+ };
+
+ enum VerAlign {
+ VTOP,
+ VCENTER,
+ VBOTTOM
+ };
+
+private:
+ HorAlign _aHorType;
+ VerAlign _aVerType;
+ byte _textR, _textG, _textB;
+
+protected:
+ virtual void clipOnScreen(RMGfxPrimitive *prim);
+
+public:
+ RMText();
+ virtual ~RMText();
+ static void initStatics();
+ static void unload();
+
+ // Set the alignment type
+ void setAlignType(HorAlign aHor, VerAlign aVer);
+
+ // Sets the maximum length of a line in pixels (used to format the text)
+ void setMaxLineLength(int max);
+
+ // Write the text
+ void writeText(const Common::String &text, int font, int *time = NULL);
+ void writeText(Common::String text, RMFontColor *font, int *time = NULL);
+
+ // Overloaded function to decide when you delete the object from the OT list
+ virtual void removeThis(CORO_PARAM, bool &result);
+
+ // Overloading of the Draw to center the text, if necessary
+ virtual void draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim);
+
+ // Set the base color
+ void setColor(byte r, byte g, byte b);
+};
+
+/**
+ * Manages text in a dialog
+ */
+class RMTextDialog : public RMText {
+protected:
+ int _startTime;
+ int _time;
+ bool _bSkipStatus;
+ RMPoint _dst;
+ uint32 _hEndDisplay;
+ bool _bShowed;
+ bool _bForceTime;
+ bool _bForceNoTime;
+ uint32 _hCustomSkip;
+ uint32 _hCustomSkip2;
+ RMInput *_input;
+ bool _bAlwaysDisplay;
+ bool _bNoTab;
+
+public:
+ RMTextDialog();
+ virtual ~RMTextDialog();
+
+ // Write the text
+ void writeText(const Common::String &text, int font, int *time = NULL);
+ void writeText(const Common::String &text, RMFontColor *font, int *time = NULL);
+
+ // Overloaded function to decide when you delete the object from the OT list
+ virtual void removeThis(CORO_PARAM, bool &result);
+
+ // Overloaded de-registration
+ virtual void Unregister();
+
+ // Overloading of the Draw to center the text, if necessary
+ virtual void draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim);
+
+ // Set the position
+ void setPosition(const RMPoint &pt);
+
+ // Waiting
+ void waitForEndDisplay(CORO_PARAM);
+ void setCustomSkipHandle(uint32 hCustomSkip);
+ void setCustomSkipHandle2(uint32 hCustomSkip);
+ void setSkipStatus(bool bEnabled);
+ void setForcedTime(uint32 dwTime);
+ void setNoTab();
+ void forceTime();
+ void forceNoTime();
+ void setAlwaysDisplay();
+
+ // Set the input device, to allow skip from mouse
+ void setInput(RMInput *input);
+
+ void show();
+ void hide(CORO_PARAM);
+};
+
+class RMTextDialogScrolling : public RMTextDialog {
+protected:
+ RMLocation *_curLoc;
+ RMPoint _startScroll;
+
+ virtual void clipOnScreen(RMGfxPrimitive *prim);
+
+public:
+ RMTextDialogScrolling();
+ RMTextDialogScrolling(RMLocation *loc);
+ virtual ~RMTextDialogScrolling();
+
+ virtual void draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim);
+};
+
+
+/**
+ * Manages the name of a selected item on the screen
+ */
+class RMTextItemName : protected RMText {
+protected:
+ RMPoint _mpos;
+ RMPoint _curscroll;
+ RMItem *_item;
+
+public:
+ RMTextItemName();
+ virtual ~RMTextItemName();
+
+ void setMouseCoord(const RMPoint &m);
+
+ void doFrame(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMLocation &loc, RMPointer &ptr, RMInventory &inv);
+ virtual void draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim);
+
+ RMPoint getHotspot();
+ RMItem *getSelectedItem();
+ bool isItemSelected();
+
+ virtual void removeThis(CORO_PARAM, bool &result);
+};
+
+
+/**
+ * Manages the selection of screen items in a box
+ */
+class RMDialogChoice : public RMGfxWoodyBuffer {
+private:
+ int _curSelection;
+ int _numChoices;
+ RMText *_drawedStrings;
+ RMPoint *_ptDrawStrings;
+ int _curAdded;
+ bool _bShow;
+ RMGfxSourceBuffer8 _dlgText;
+ RMGfxSourceBuffer8 _dlgTextLine;
+ RMPoint _ptDrawPos;
+ uint32 _hUnreg;
+ bool _bRemoveFromOT;
+
+protected:
+ void prepare(CORO_PARAM);
+ void setSelected(CORO_PARAM, int pos);
+
+public:
+ virtual void removeThis(CORO_PARAM, bool &result);
+ virtual void draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim);
+ void Unregister();
+
+public:
+ // Initialization
+ RMDialogChoice();
+ virtual ~RMDialogChoice();
+
+ // Initialization and closure
+ void init();
+ void close();
+
+ // Sets the number of possible sentences, which then be added with AddChoice()
+ void setNumChoices(int num);
+
+ // Adds a string with the choice
+ void addChoice(const Common::String &string);
+
+ // Show and hide the selection, with possible animations.
+ // NOTE: If no parameter is passed to Show(), it is the obligation of
+ // caller to ensure that the class is inserted into OT list
+ void show(CORO_PARAM, RMGfxTargetBuffer *bigBuf = NULL);
+ void hide(CORO_PARAM);
+
+ // Polling Update
+ void doFrame(CORO_PARAM, RMPoint ptMousePos);
+
+ // Returns the currently selected item, or -1 if none is selected
+ int getSelection();
+};
+
+} // End of namespace Tony
+
+#endif
diff --git a/engines/tony/game.cpp b/engines/tony/game.cpp
new file mode 100644
index 0000000000..2bcfdc7fc2
--- /dev/null
+++ b/engines/tony/game.cpp
@@ -0,0 +1,1617 @@
+/* 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.
+ *
+ */
+
+/*
+ * This code is based on original Tony Tough source code
+ *
+ * Copyright (c) 1997-2003 Nayma Software
+ */
+
+#include "common/file.h"
+#include "common/savefile.h"
+#include "common/textconsole.h"
+#include "graphics/cursorman.h"
+#include "tony/mpal/lzo.h"
+#include "tony/mpal/memory.h"
+#include "tony/mpal/mpal.h"
+#include "tony/mpal/mpalutils.h"
+#include "tony/custom.h"
+#include "tony/game.h"
+#include "tony/gfxengine.h"
+#include "tony/tony.h"
+
+namespace Tony {
+
+using namespace MPAL;
+
+// Global functions
+void mainEnableGUI() {
+ g_vm->getEngine()->_bGUIInterface = true;
+ g_vm->getEngine()->_bGUIInventory = true;
+ g_vm->getEngine()->_bGUIOption = true;
+}
+
+void mainDisableGUI() {
+ g_vm->getEngine()->_bGUIInterface = false;
+ g_vm->getEngine()->_bGUIInventory = false;
+ g_vm->getEngine()->_bGUIOption = false;
+}
+
+/****************************************************************************\
+* RMOptionButton Methods
+\****************************************************************************/
+
+RMOptionButton::RMOptionButton(uint32 dwRes, RMPoint pt, bool bDoubleState) {
+ RMResRaw raw(dwRes);
+ assert(raw.isValid());
+ _buf = new RMGfxSourceBuffer16(false);
+ _buf->init(raw, raw.width(), raw.height());
+
+ _rect.setRect(pt._x, pt._y, pt._x + raw.width() - 1, pt._y + raw.height() - 1);
+ _bActive = false;
+ _bHasGfx = true;
+ _bDoubleState = bDoubleState;
+}
+
+RMOptionButton::RMOptionButton(const RMRect &pt) {
+ _rect = pt;
+ _bActive = false;
+ _bHasGfx = false;
+ _bDoubleState = false;
+ _buf = NULL;
+}
+
+RMOptionButton::~RMOptionButton() {
+ if (_bHasGfx)
+ delete _buf;
+}
+
+bool RMOptionButton::doFrame(const RMPoint &mousePos, bool bLeftClick, bool bRightClick) {
+ if (!_bDoubleState) {
+ if (_rect.ptInRect(mousePos)) {
+ if (!_bActive) {
+ _bActive = true;
+ return true;
+ }
+ } else {
+ if (_bActive) {
+ _bActive = false;
+ return true;
+ }
+ }
+ } else {
+ if (bLeftClick && _rect.ptInRect(mousePos)) {
+ _bActive = !_bActive;
+ return true;
+ }
+ }
+
+ return false;
+}
+
+void RMOptionButton::draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim) {
+ CORO_BEGIN_CONTEXT;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ if (!_bActive)
+ return;
+
+ if (_bHasGfx)
+ CORO_INVOKE_2(_buf->draw, bigBuf, prim);
+
+ CORO_END_CODE;
+}
+
+void RMOptionButton::addToList(RMGfxTargetBuffer &bigBuf) {
+ if (_bHasGfx)
+ bigBuf.addPrim(new RMGfxPrimitive(this, _rect));
+}
+
+bool RMOptionButton::isActive() {
+ return _bActive;
+}
+
+void RMOptionButton::setActiveState(bool bState) {
+ _bActive = bState;
+}
+
+/****************************************************************************\
+* RMOptionSlide Methods
+\****************************************************************************/
+
+RMOptionSlide::RMOptionSlide(const RMPoint &pt, int nRange, int nStartValue, int slideSize) {
+ RMResRaw *raw;
+
+ _pos = pt;
+ _nSlideSize = slideSize;
+ _nMax = nRange;
+ _nStep = 100 / _nMax;
+ _nValue = nStartValue;
+
+ _sliderCenter = NULL;
+ _sliderLeft = NULL;
+ _sliderRight = NULL;
+ _sliderSingle = NULL;
+
+ // Sliders
+ INIT_GFX16_FROMRAW(20029, _sliderCenter);
+ INIT_GFX16_FROMRAW(20030, _sliderLeft);
+ INIT_GFX16_FROMRAW(20031, _sliderRight);
+ INIT_GFX16_FROMRAW(20032, _sliderSingle);
+
+ // Buttons
+ _pushLeft = new RMOptionButton(RMRect(pt._x - 23, pt._y, pt._x - 23 + 22, pt._y + 26));
+ _pushRight = new RMOptionButton(RMRect(pt._x + _nSlideSize, pt._y, pt._x + _nSlideSize + 5 + 22, pt._y + 26));
+}
+
+
+RMOptionSlide::~RMOptionSlide() {
+ delete _sliderCenter;
+ _sliderCenter = NULL;
+ delete _sliderLeft;
+ _sliderLeft = NULL;
+ delete _sliderRight;
+ _sliderRight = NULL;
+ delete _sliderSingle;
+ _sliderSingle = NULL;
+
+ delete _pushLeft;
+ _pushLeft = NULL;
+ delete _pushRight;
+ _pushRight = NULL;
+}
+
+bool RMOptionSlide::doFrame(const RMPoint &mousePos, bool bLeftClick, bool bRightClick) {
+ bool bRefresh = false;
+
+ // Do the button DoFrame's
+ _pushLeft->doFrame(mousePos, bLeftClick, bRightClick);
+ _pushRight->doFrame(mousePos, bLeftClick, bRightClick);
+
+ if (_pushLeft->isActive()) {
+ if (bLeftClick) {
+ bRefresh = true;
+ _nValue--;
+ } else if (bRightClick) {
+ bRefresh = true;
+ _nValue -= 3;
+ }
+ if (_nValue < 1)
+ _nValue = 1;
+ } else if (_pushRight->isActive()) {
+ bRefresh = true;
+
+ if (bLeftClick) {
+ bRefresh = true;
+ _nValue++;
+ } else if (bRightClick) {
+ bRefresh = true;
+ _nValue += 3;
+ }
+ if (_nValue > _nMax)
+ _nValue = _nMax;
+ }
+
+ return bRefresh;
+}
+
+void RMOptionSlide::draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim) {
+ CORO_BEGIN_CONTEXT;
+ int i;
+ int val;
+ RMPoint pos;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ _ctx->pos = _pos;
+ _ctx->pos._x += 4;
+ _ctx->pos._y += 4;
+
+ _ctx->val = _nValue * _nStep;
+ if (_ctx->val < 1)
+ _ctx->val = 1;
+ else if (_ctx->val > 100)
+ _ctx->val = 100;
+
+ if (_ctx->val == 1) {
+ prim->setDst(_ctx->pos);
+ CORO_INVOKE_2(_sliderSingle->draw, bigBuf, prim);
+ } else {
+ prim->setDst(_ctx->pos);
+ CORO_INVOKE_2(_sliderLeft->draw, bigBuf, prim);
+ _ctx->pos._x += 3;
+
+ for (_ctx->i = 1; _ctx->i < _ctx->val - 1; _ctx->i++) {
+ prim->setDst(_ctx->pos);
+ CORO_INVOKE_2(_sliderCenter->draw, bigBuf, prim);
+ _ctx->pos._x += 3;
+ }
+
+ prim->setDst(_ctx->pos);
+ CORO_INVOKE_2(_sliderRight->draw, bigBuf, prim);
+ _ctx->pos._x += 3;
+ }
+
+ CORO_END_CODE;
+}
+
+void RMOptionSlide::addToList(RMGfxTargetBuffer &bigBuf) {
+ bigBuf.addPrim(new RMGfxPrimitive(this));
+}
+
+int RMOptionSlide::getValue() {
+ return _nValue;
+}
+
+/****************************************************************************\
+* RMOptionScreen Methods
+\****************************************************************************/
+
+RMOptionScreen::RMOptionScreen() {
+ _nState = MENUNONE;
+ _menu = NULL;
+ _hideLoadSave = NULL;
+ _quitConfirm = NULL;
+ _bQuitConfirm = false;
+
+ create(RM_SX, RM_SY);
+
+ _buttonExit = NULL;
+ _buttonLoad = NULL;
+ _buttonSave = NULL;
+ _buttonGameMenu = NULL;
+ _buttonGfxMenu = NULL;
+ _buttonSoundMenu = NULL;
+ _buttonSave_ArrowLeft = NULL;
+ _buttonSave_ArrowRight = NULL;
+ _bEditSaveName = false;
+
+ int i;
+
+ for (i = 0; i < 6; i++) {
+ _curThumb[i] = NULL;
+ _buttonSave_States[i] = NULL;
+ }
+
+ _statePos = 0;
+ _buttonQuitYes = NULL;
+ _buttonQuitNo = NULL;
+ _buttonQuit = NULL;
+ _saveEasy = NULL;
+ _saveHard = NULL;
+ _buttonGfx_Tips = NULL;
+ _buttonSound_DubbingOn = NULL;
+ _buttonSound_MusicOn = NULL;
+ _buttonSound_SFXOn = NULL;
+ _slideTonySpeed = NULL;
+ _slideTextSpeed = NULL;
+ _buttonGame_Lock = NULL;
+ _buttonGfx_Anni30 = NULL;
+ _sliderSound_Music = NULL;
+ _buttonGame_TimerizedText = NULL;
+ _buttonGfx_AntiAlias = NULL;
+ _sliderSound_SFX = NULL;
+ _buttonGame_Scrolling = NULL;
+ _buttonGfx_Sottotitoli = NULL;
+ _sliderSound_Dubbing = NULL;
+ _buttonGame_InterUp = NULL;
+ _buttonGfx_Trans = NULL;
+
+ _fadeStep = 0;
+ _fadeY = 0;
+ _fadeTime = 0;
+ _nEditPos = 0;
+ _nLastState = MENUGAME;
+}
+
+RMOptionScreen::~RMOptionScreen() {
+ closeState();
+}
+
+void RMOptionScreen::refreshAll(CORO_PARAM) {
+ CORO_BEGIN_CONTEXT;
+ RMGfxSourceBuffer16 *thumb;
+ RMText *title;
+ RMText *num[6];
+ int i;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+ clearOT();
+
+ addPrim(new RMGfxPrimitive(_menu));
+
+ if (_bNoLoadSave)
+ addPrim(new RMGfxPrimitive(_hideLoadSave, RMPoint(0, 401)));
+
+ if (_bQuitConfirm) {
+ addPrim(new RMGfxPrimitive(_quitConfirm, RMPoint(270, 200)));
+ _buttonQuitYes->addToList(*this);
+ _buttonQuitNo->addToList(*this);
+ }
+
+ _buttonExit->addToList(*this);
+
+ if (_nState == MENUGAME || _nState == MENUGFX || _nState == MENUSOUND) {
+ _buttonQuit->addToList(*this);
+ _buttonLoad->addToList(*this);
+ _buttonSave->addToList(*this);
+ }
+
+ if (_nState == MENUGAME) {
+ _buttonGame_Lock->addToList(*this);
+ _buttonGame_TimerizedText->addToList(*this);
+ _buttonGame_Scrolling->addToList(*this);
+ _buttonGame_InterUp->addToList(*this);
+ _slideTextSpeed->addToList(*this);
+ _slideTonySpeed->addToList(*this);
+ } else if (_nState == MENUGFX) {
+ _buttonGfx_Anni30->addToList(*this);
+ _buttonGfx_AntiAlias->addToList(*this);
+ _buttonGfx_Sottotitoli->addToList(*this);
+ _buttonGfx_Trans->addToList(*this);
+ _buttonGfx_Tips->addToList(*this);
+ } else if (_nState == MENUSOUND) {
+ _sliderSound_Dubbing->addToList(*this);
+ _sliderSound_Music->addToList(*this);
+ _sliderSound_SFX->addToList(*this);
+ _buttonSound_DubbingOn->addToList(*this);
+ _buttonSound_MusicOn->addToList(*this);
+ _buttonSound_SFXOn->addToList(*this);
+ }
+
+ _ctx->thumb = NULL;
+ _ctx->title = NULL;
+ Common::fill(&_ctx->num[0], &_ctx->num[6], (RMText *)NULL);
+
+ if (_nState == MENULOAD || _nState == MENUSAVE) {
+ _ctx->title = new RMText;
+ if (_nState == MENULOAD) {
+ RMMessage msg(10);
+ _ctx->title->writeText(msg[0], 1);
+ } else {
+ RMMessage msg(11);
+ _ctx->title->writeText(msg[0], 1);
+ }
+
+ addPrim(new RMGfxPrimitive(_ctx->title, RMPoint(320, 10)));
+
+ if (_curThumbDiff[0] == 0)
+ addPrim(new RMGfxPrimitive(_saveHard, RMPoint(48, 57)));
+ else if (_curThumbDiff[0] == 1)
+ addPrim(new RMGfxPrimitive(_saveEasy, RMPoint(48, 57)));
+ if (_curThumbDiff[1] == 0)
+ addPrim(new RMGfxPrimitive(_saveHard, RMPoint(240, 57)));
+ else if (_curThumbDiff[1] == 1)
+ addPrim(new RMGfxPrimitive(_saveEasy, RMPoint(240, 57)));
+ if (_curThumbDiff[2] == 0)
+ addPrim(new RMGfxPrimitive(_saveHard, RMPoint(432, 57)));
+ else if (_curThumbDiff[2] == 1)
+ addPrim(new RMGfxPrimitive(_saveEasy, RMPoint(432, 57)));
+ if (_curThumbDiff[3] == 0)
+ addPrim(new RMGfxPrimitive(_saveHard, RMPoint(48, 239)));
+ else if (_curThumbDiff[3] == 1)
+ addPrim(new RMGfxPrimitive(_saveEasy, RMPoint(48, 239)));
+ if (_curThumbDiff[4] == 0)
+ addPrim(new RMGfxPrimitive(_saveHard, RMPoint(240, 239)));
+ else if (_curThumbDiff[4] == 1)
+ addPrim(new RMGfxPrimitive(_saveEasy, RMPoint(240, 239)));
+ if (_curThumbDiff[5] == 0)
+ addPrim(new RMGfxPrimitive(_saveHard, RMPoint(432, 239)));
+ else if (_curThumbDiff[5] == 1)
+ addPrim(new RMGfxPrimitive(_saveEasy, RMPoint(432, 239)));
+
+ if (_curThumb[0] && !(_bEditSaveName && _nEditPos == 0))
+ addPrim(new RMGfxPrimitive(_curThumb[0], RMPoint(48, 57)));
+ if (_curThumb[1] && !(_bEditSaveName && _nEditPos == 1))
+ addPrim(new RMGfxPrimitive(_curThumb[1], RMPoint(240, 57)));
+ if (_curThumb[2] && !(_bEditSaveName && _nEditPos == 2))
+ addPrim(new RMGfxPrimitive(_curThumb[2], RMPoint(432, 57)));
+ if (_curThumb[3] && !(_bEditSaveName && _nEditPos == 3))
+ addPrim(new RMGfxPrimitive(_curThumb[3], RMPoint(48, 239)));
+ if (_curThumb[4] && !(_bEditSaveName && _nEditPos == 4))
+ addPrim(new RMGfxPrimitive(_curThumb[4], RMPoint(240, 239)));
+ if (_curThumb[5] && !(_bEditSaveName && _nEditPos == 5))
+ addPrim(new RMGfxPrimitive(_curThumb[5], RMPoint(432, 239)));
+
+ if (_bEditSaveName) {
+ _ctx->thumb = new RMGfxSourceBuffer16;
+ _ctx->thumb->init((byte *)g_vm->getThumbnail(), 640 / 4, 480 / 4);
+
+ if (_nEditPos == 0)
+ addPrim(new RMGfxPrimitive(_ctx->thumb, RMPoint(48, 57)));
+ else if (_nEditPos == 1)
+ addPrim(new RMGfxPrimitive(_ctx->thumb, RMPoint(240, 57)));
+ else if (_nEditPos == 2)
+ addPrim(new RMGfxPrimitive(_ctx->thumb, RMPoint(432, 57)));
+ else if (_nEditPos == 3)
+ addPrim(new RMGfxPrimitive(_ctx->thumb, RMPoint(48, 239)));
+ else if (_nEditPos == 4)
+ addPrim(new RMGfxPrimitive(_ctx->thumb, RMPoint(240, 239)));
+ else if (_nEditPos == 5)
+ addPrim(new RMGfxPrimitive(_ctx->thumb, RMPoint(432, 239)));
+ }
+
+ for (_ctx->i = 0; _ctx->i < 6; _ctx->i++) {
+ Common::String s;
+
+ if (_bEditSaveName && _nEditPos == _ctx->i)
+ s = Common::String::format("%02d)%s*", _statePos + _ctx->i, _editName);
+ else {
+ if (_statePos == 0 && _ctx->i == 0)
+ s = "Autosave";
+ else
+ s = Common::String::format("%02d)%s", _statePos + _ctx->i, _curThumbName[_ctx->i].c_str());
+ }
+
+ _ctx->num[_ctx->i] = new RMText;
+ _ctx->num[_ctx->i]->setAlignType(RMText::HLEFT, RMText::VTOP);
+ _ctx->num[_ctx->i]->writeText(s, 2);
+ }
+
+ addPrim(new RMGfxPrimitive(_ctx->num[0], RMPoint(55 - 3, 180 + 14)));
+ addPrim(new RMGfxPrimitive(_ctx->num[1], RMPoint(247 - 3, 180 + 14)));
+ addPrim(new RMGfxPrimitive(_ctx->num[2], RMPoint(439 - 3, 180 + 14)));
+ addPrim(new RMGfxPrimitive(_ctx->num[3], RMPoint(55 - 3, 362 + 14)));
+ addPrim(new RMGfxPrimitive(_ctx->num[4], RMPoint(247 - 3, 362 + 14)));
+ addPrim(new RMGfxPrimitive(_ctx->num[5], RMPoint(439 - 3, 362 + 14)));
+
+ _buttonSave_ArrowLeft->addToList(*this);
+ _buttonSave_ArrowRight->addToList(*this);
+ }
+
+ CORO_INVOKE_0(drawOT);
+
+ if (_nState == MENULOAD || _nState == MENUSAVE) {
+ if (_ctx->thumb)
+ delete _ctx->thumb;
+
+ if (_ctx->title)
+ delete _ctx->title;
+
+ for (_ctx->i = 0; _ctx->i < 6; _ctx->i++) {
+ if (_ctx->num[_ctx->i])
+ delete _ctx->num[_ctx->i];
+ }
+ }
+
+ CORO_END_CODE;
+}
+
+void RMOptionScreen::refreshThumbnails() {
+ int i;
+
+ for (i = 0; i < 6; i++) {
+ if (_curThumb[i])
+ delete _curThumb[i];
+
+ _curThumb[i] = new RMGfxSourceBuffer16;
+ _curThumb[i]->create(640 / 4, 480 / 4);
+ if (!loadThumbnailFromSaveState(_statePos + i, *_curThumb[i], _curThumbName[i], _curThumbDiff[i])) {
+ delete _curThumb[i];
+ _curThumb[i] = NULL;
+ _curThumbName[i].clear();
+ _curThumbDiff[i] = 11;
+ }
+ }
+}
+
+void RMOptionScreen::initState(CORO_PARAM) {
+ CORO_BEGIN_CONTEXT;
+ RMResRaw *raw;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ if (_nState == MENUGAME || _nState == MENUGFX || _nState == MENUSOUND)
+ _ctx->raw = new RMResRaw(20000 + _nState);
+ else if (_nState == MENULOAD || _nState == MENUSAVE) {
+ if (_bAlterGfx)
+ _ctx->raw = new RMResRaw(20024);
+ else
+ _ctx->raw = new RMResRaw(20003);
+ } else {
+ error("Invalid state");
+ }
+
+ assert(_ctx->raw->isValid());
+ assert(_menu == NULL);
+ _menu = new RMGfxSourceBuffer16(false);
+ _menu->init(*_ctx->raw, _ctx->raw->width(), _ctx->raw->height());
+ delete _ctx->raw;
+
+ if (_nState == MENULOAD || _nState == MENUSAVE) {
+ if (_bAlterGfx) {
+ assert(_buttonExit == NULL);
+ _buttonExit = new RMOptionButton(20025, RMPoint(561, 406));
+ } else {
+ assert(_buttonExit == NULL);
+ _buttonExit = new RMOptionButton(20012, RMPoint(560, 404));
+ }
+
+ INIT_GFX8_FROMRAW(_ctx->raw, 20036, _saveEasy);
+ INIT_GFX8_FROMRAW(_ctx->raw, 20037, _saveHard);
+
+ refreshThumbnails();
+
+ assert(_buttonSave_States[0] == NULL);
+ _buttonSave_States[0] = new RMOptionButton(RMRect(48, 57, 48 + 160, 57 + 120));
+ assert(_buttonSave_States[1] == NULL);
+ _buttonSave_States[1] = new RMOptionButton(RMRect(240, 57, 240 + 160, 57 + 120));
+ assert(_buttonSave_States[2] == NULL);
+ _buttonSave_States[2] = new RMOptionButton(RMRect(432, 57, 432 + 160, 57 + 120));
+ assert(_buttonSave_States[3] == NULL);
+ _buttonSave_States[3] = new RMOptionButton(RMRect(48, 239, 48 + 160, 239 + 120));
+ assert(_buttonSave_States[4] == NULL);
+ _buttonSave_States[4] = new RMOptionButton(RMRect(240, 239, 240 + 160, 239 + 120));
+ assert(_buttonSave_States[5] == NULL);
+ _buttonSave_States[5] = new RMOptionButton(RMRect(432, 239, 432 + 160, 239 + 120));
+
+ if (_bAlterGfx) {
+ assert(_buttonSave_ArrowLeft == NULL);
+ _buttonSave_ArrowLeft = new RMOptionButton(20026, RMPoint(3, 196));
+ assert(_buttonSave_ArrowRight == NULL);
+ _buttonSave_ArrowRight = new RMOptionButton(20027, RMPoint(601, 197));
+ } else {
+ assert(_buttonSave_ArrowLeft == NULL);
+ _buttonSave_ArrowLeft = new RMOptionButton(20013, RMPoint(0, 197));
+ assert(_buttonSave_ArrowRight == NULL);
+ _buttonSave_ArrowRight = new RMOptionButton(20014, RMPoint(601, 197));
+ }
+ } else if (_nState == MENUGAME || _nState == MENUGFX || _nState == MENUSOUND) {
+ assert(_buttonExit == NULL);
+ _buttonExit = new RMOptionButton(20005, RMPoint(560, 405));
+ assert(_buttonQuit == NULL);
+ _buttonQuit = new RMOptionButton(20020, RMPoint(7, 408));
+ assert(_buttonLoad == NULL);
+ _buttonLoad = new RMOptionButton(20006, RMPoint(231, 401));
+ assert(_buttonSave == NULL);
+ _buttonSave = new RMOptionButton(20007, RMPoint(325, 401));
+
+ assert(_buttonGameMenu == NULL);
+ _buttonGameMenu = new RMOptionButton(RMRect(24, 32, 118, 64));
+ assert(_buttonGfxMenu == NULL);
+ _buttonGfxMenu = new RMOptionButton(RMRect(118, 32, 212, 64));
+ assert(_buttonSoundMenu == NULL);
+ _buttonSoundMenu = new RMOptionButton(RMRect(212, 32, 306, 64));
+
+ _ctx->raw = new RMResRaw(20021);
+ assert(_ctx->raw->isValid());
+ assert(_quitConfirm == NULL);
+ _quitConfirm = new RMGfxSourceBuffer16(false);
+ _quitConfirm->init(*_ctx->raw, _ctx->raw->width(), _ctx->raw->height());
+ delete _ctx->raw;
+
+ assert(_buttonQuitYes == NULL);
+ _buttonQuitYes = new RMOptionButton(20022, RMPoint(281, 265));
+ _buttonQuitYes->setPriority(30);
+ assert(_buttonQuitNo == NULL);
+ _buttonQuitNo = new RMOptionButton(20023, RMPoint(337, 264));
+ _buttonQuitNo->setPriority(30);
+
+ if (_bNoLoadSave) {
+ _ctx->raw = new RMResRaw(20028);
+ assert(_ctx->raw->isValid());
+ assert(_hideLoadSave == NULL);
+ _hideLoadSave = new RMGfxSourceBuffer16(false);
+ _hideLoadSave->init(*_ctx->raw, _ctx->raw->width(), _ctx->raw->height());
+ delete _ctx->raw;
+ }
+
+ // Menu GAME
+ if (_nState == MENUGAME) {
+ assert(_buttonGame_Lock == NULL);
+ _buttonGame_Lock = new RMOptionButton(20008, RMPoint(176, 262), true);
+ _buttonGame_Lock->setActiveState(GLOBALS._bCfgInvLocked);
+ assert(_buttonGame_TimerizedText == NULL);
+ _buttonGame_TimerizedText = new RMOptionButton(20009, RMPoint(463, 273), true);
+ _buttonGame_TimerizedText->setActiveState(!GLOBALS._bCfgTimerizedText);
+ assert(_buttonGame_Scrolling == NULL);
+ _buttonGame_Scrolling = new RMOptionButton(20010, RMPoint(315, 263), true);
+ _buttonGame_Scrolling->setActiveState(GLOBALS._bCfgInvNoScroll);
+ assert(_buttonGame_InterUp == NULL);
+ _buttonGame_InterUp = new RMOptionButton(20011, RMPoint(36, 258), true);
+ _buttonGame_InterUp->setActiveState(GLOBALS._bCfgInvUp);
+
+ assert(_slideTextSpeed == NULL);
+ _slideTextSpeed = new RMOptionSlide(RMPoint(165, 122), 10, GLOBALS._nCfgTextSpeed);
+ assert(_slideTonySpeed == NULL);
+ _slideTonySpeed = new RMOptionSlide(RMPoint(165, 226), 5, GLOBALS._nCfgTonySpeed);
+ }
+ // Menu Graphics
+ else if (_nState == MENUGFX) {
+ assert(_buttonGfx_Anni30 == NULL);
+ _buttonGfx_Anni30 = new RMOptionButton(20015, RMPoint(247, 178), true);
+ _buttonGfx_Anni30->setActiveState(GLOBALS._bCfgAnni30);
+ assert(_buttonGfx_AntiAlias == NULL);
+ _buttonGfx_AntiAlias = new RMOptionButton(20016, RMPoint(430, 83), true);
+ _buttonGfx_AntiAlias->setActiveState(!GLOBALS._bCfgAntiAlias);
+ assert(_buttonGfx_Sottotitoli == NULL);
+ _buttonGfx_Sottotitoli = new RMOptionButton(20017, RMPoint(98, 82), true);
+ _buttonGfx_Sottotitoli->setActiveState(!GLOBALS._bShowSubtitles);
+ assert(_buttonGfx_Tips == NULL);
+ _buttonGfx_Tips = new RMOptionButton(20018, RMPoint(431, 246), true);
+ _buttonGfx_Tips->setActiveState(GLOBALS._bCfgInterTips);
+ assert(_buttonGfx_Trans == NULL);
+ _buttonGfx_Trans = new RMOptionButton(20019, RMPoint(126, 271), true);
+ _buttonGfx_Trans->setActiveState(!GLOBALS._bCfgTransparence);
+
+ } else if (_nState == MENUSOUND) {
+ assert(_sliderSound_Dubbing == NULL);
+ _sliderSound_Dubbing = new RMOptionSlide(RMPoint(165, 122), 10, GLOBALS._nCfgDubbingVolume);
+ assert(_sliderSound_Music == NULL);
+ _sliderSound_Music = new RMOptionSlide(RMPoint(165, 226), 10, GLOBALS._nCfgMusicVolume);
+ assert(_sliderSound_SFX == NULL);
+ _sliderSound_SFX = new RMOptionSlide(RMPoint(165, 330), 10, GLOBALS._nCfgSFXVolume);
+
+ assert(_buttonSound_DubbingOn == NULL);
+ _buttonSound_DubbingOn = new RMOptionButton(20033, RMPoint(339, 75), true);
+ _buttonSound_DubbingOn->setActiveState(GLOBALS._bCfgDubbing);
+ assert(_buttonSound_MusicOn == NULL);
+ _buttonSound_MusicOn = new RMOptionButton(20034, RMPoint(338, 179), true);
+ _buttonSound_MusicOn->setActiveState(GLOBALS._bCfgMusic);
+ assert(_buttonSound_SFXOn == NULL);
+ _buttonSound_SFXOn = new RMOptionButton(20035, RMPoint(338, 283), true);
+ _buttonSound_SFXOn->setActiveState(GLOBALS._bCfgSFX);
+ }
+ }
+
+ CORO_INVOKE_0(refreshAll);
+
+ CORO_END_CODE;
+}
+
+void RMOptionScreen::closeState() {
+ delete _menu;
+ _menu = NULL;
+
+ delete _buttonExit;
+ _buttonExit = NULL;
+
+ if (_nState == MENULOAD || _nState == MENUSAVE) {
+ int i;
+
+ for (i = 0; i < 6; i++) {
+ if (_curThumb[i] != NULL) {
+ delete _curThumb[i];
+ _curThumb[i] = NULL;
+ }
+
+ delete _buttonSave_States[i];
+ _buttonSave_States[i] = NULL;
+ }
+
+ delete _buttonSave_ArrowLeft;
+ _buttonSave_ArrowLeft = NULL;
+ delete _buttonSave_ArrowRight;
+ _buttonSave_ArrowRight = NULL;
+
+ delete _saveEasy;
+ _saveEasy = NULL;
+ delete _saveHard;
+ _saveHard = NULL;
+ }
+
+ if (_nState == MENUGAME || _nState == MENUGFX || _nState == MENUSOUND) {
+ delete _buttonQuit;
+ _buttonQuit = NULL;
+ delete _buttonLoad;
+ _buttonLoad = NULL;
+ delete _buttonSave;
+ _buttonSave = NULL;
+ delete _buttonGameMenu;
+ _buttonGameMenu = NULL;
+ delete _buttonGfxMenu;
+ _buttonGfxMenu = NULL;
+ delete _buttonSoundMenu;
+ _buttonSoundMenu = NULL;
+ delete _quitConfirm;
+ _quitConfirm = NULL;
+ delete _buttonQuitYes;
+ _buttonQuitYes = NULL;
+ delete _buttonQuitNo;
+ _buttonQuitNo = NULL;
+
+ if (_bNoLoadSave) {
+ delete _hideLoadSave;
+ _hideLoadSave = NULL;
+ }
+
+ if (_nState == MENUGAME) {
+ GLOBALS._bCfgInvLocked = _buttonGame_Lock->isActive();
+ delete _buttonGame_Lock;
+ _buttonGame_Lock = NULL;
+
+ GLOBALS._bCfgTimerizedText = !_buttonGame_TimerizedText->isActive();
+ delete _buttonGame_TimerizedText;
+ _buttonGame_TimerizedText = NULL;
+
+ GLOBALS._bCfgInvNoScroll = _buttonGame_Scrolling->isActive();
+ delete _buttonGame_Scrolling;
+ _buttonGame_Scrolling = NULL;
+
+ GLOBALS._bCfgInvUp = _buttonGame_InterUp->isActive();
+ delete _buttonGame_InterUp;
+ _buttonGame_InterUp = NULL;
+
+ GLOBALS._nCfgTextSpeed = _slideTextSpeed->getValue();
+ delete _slideTextSpeed;
+ _slideTextSpeed = NULL;
+
+ GLOBALS._nCfgTonySpeed = _slideTonySpeed->getValue();
+ delete _slideTonySpeed;
+ _slideTonySpeed = NULL;
+ } else if (_nState == MENUGFX) {
+ GLOBALS._bCfgAnni30 = _buttonGfx_Anni30->isActive();
+ delete _buttonGfx_Anni30;
+ _buttonGfx_Anni30 = NULL;
+
+ GLOBALS._bCfgAntiAlias = !_buttonGfx_AntiAlias->isActive();
+ delete _buttonGfx_AntiAlias;
+ _buttonGfx_AntiAlias = NULL;
+
+ GLOBALS._bShowSubtitles = !_buttonGfx_Sottotitoli->isActive();
+ delete _buttonGfx_Sottotitoli;
+ _buttonGfx_Sottotitoli = NULL;
+
+ GLOBALS._bCfgInterTips = _buttonGfx_Tips->isActive();
+ delete _buttonGfx_Tips;
+ _buttonGfx_Tips = NULL;
+
+ GLOBALS._bCfgTransparence = !_buttonGfx_Trans->isActive();
+ delete _buttonGfx_Trans;
+ _buttonGfx_Trans = NULL;
+ } else if (_nState == MENUSOUND) {
+ GLOBALS._nCfgDubbingVolume = _sliderSound_Dubbing->getValue();
+ delete _sliderSound_Dubbing;
+ _sliderSound_Dubbing = NULL;
+
+ GLOBALS._nCfgMusicVolume = _sliderSound_Music->getValue();
+ delete _sliderSound_Music;
+ _sliderSound_Music = NULL;
+
+ GLOBALS._nCfgSFXVolume = _sliderSound_SFX->getValue();
+ delete _sliderSound_SFX;
+ _sliderSound_SFX = NULL;
+
+ GLOBALS._bCfgDubbing = _buttonSound_DubbingOn->isActive();
+ delete _buttonSound_DubbingOn;
+ _buttonSound_DubbingOn = NULL;
+
+ GLOBALS._bCfgMusic = _buttonSound_MusicOn->isActive();
+ delete _buttonSound_MusicOn;
+ _buttonSound_MusicOn = NULL;
+
+ GLOBALS._bCfgSFX = _buttonSound_SFXOn->isActive();
+ delete _buttonSound_SFXOn;
+ _buttonSound_SFXOn = NULL;
+ }
+
+ // Save the new settings to ScummVM
+ g_vm->saveSoundSettings();
+ }
+
+ _nState = MENUNONE;
+}
+
+void RMOptionScreen::reInit(RMGfxTargetBuffer &bigBuf) {
+ bigBuf.addPrim(new RMGfxPrimitive(this));
+}
+
+void RMOptionScreen::init(CORO_PARAM, RMGfxTargetBuffer &bigBuf, bool &result) {
+ CORO_BEGIN_CONTEXT;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ if (_fadeStep != 0) {
+ result = false;
+ return;
+ }
+
+ _fadeStep = 1;
+ _fadeY = -20;
+ _fadeTime = -1;
+ _bExit = false;
+ _bLoadMenuOnly = false;
+ _bNoLoadSave = false;
+ _bAlterGfx = false;
+
+ bigBuf.addPrim(new RMGfxPrimitive(this));
+
+ if (_nState == MENULOAD || _nState == MENUSAVE || _nState == MENUNONE)
+ _nState = MENUGAME;
+
+ CORO_INVOKE_0(initState);
+
+ result = true;
+
+ CORO_END_CODE;
+}
+
+void RMOptionScreen::initLoadMenuOnly(CORO_PARAM, RMGfxTargetBuffer &bigBuf, bool bAlternateGfx, bool &result) {
+ CORO_BEGIN_CONTEXT;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ if (_fadeStep != 0) {
+ result = false;
+ return;
+ }
+
+ _fadeStep = 1;
+ _fadeY = -20;
+ _fadeTime = -1;
+ _bExit = false;
+ _bLoadMenuOnly = true;
+ _bNoLoadSave = false;
+ _bAlterGfx = bAlternateGfx;
+
+ bigBuf.addPrim(new RMGfxPrimitive(this));
+
+ _nState = MENULOAD;
+ CORO_INVOKE_0(initState);
+
+ result = true;
+
+ CORO_END_CODE;
+}
+
+void RMOptionScreen::initSaveMenuOnly(CORO_PARAM, RMGfxTargetBuffer &bigBuf, bool bAlternateGfx, bool &result) {
+ CORO_BEGIN_CONTEXT;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ if (_fadeStep != 0) {
+ result = false;
+ return;
+ }
+
+ _fadeStep = 1;
+ _fadeY = -20;
+ _fadeTime = -1;
+ _bExit = false;
+ _bLoadMenuOnly = true;
+ _bNoLoadSave = false;
+ _bAlterGfx = bAlternateGfx;
+
+ bigBuf.addPrim(new RMGfxPrimitive(this));
+
+ _nState = MENUSAVE;
+ CORO_INVOKE_0(initState);
+
+ result = true;
+
+ CORO_END_CODE;
+}
+
+void RMOptionScreen::initNoLoadSave(CORO_PARAM, RMGfxTargetBuffer &bigBuf, bool &result) {
+ CORO_BEGIN_CONTEXT;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ if (_fadeStep != 0) {
+ result = false;
+ return;
+ }
+
+ _fadeStep = 1;
+ _fadeY = -20;
+ _fadeTime = -1;
+ _bExit = false;
+ _bLoadMenuOnly = false;
+ _bNoLoadSave = true;
+
+ bigBuf.addPrim(new RMGfxPrimitive(this));
+
+ _nState = MENUGAME;
+ CORO_INVOKE_0(initState);
+
+ result = true;
+
+ CORO_END_CODE;
+}
+
+bool RMOptionScreen::close() {
+ if (_fadeStep != 6)
+ return false;
+
+ // Start fade out
+ _fadeStep++;
+ _fadeTime = g_vm->getTime();
+ return true;
+}
+
+bool RMOptionScreen::isClosing() {
+ return _bExit;
+}
+
+int RMOptionScreen::priority() {
+ // Just below the mouse
+ return 190;
+}
+
+void RMOptionScreen::changeState(CORO_PARAM, OptionScreenState newState) {
+ CORO_BEGIN_CONTEXT;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ _nLastState = _nState;
+ closeState();
+ _nState = newState;
+ CORO_INVOKE_0(initState);
+
+ CORO_END_CODE;
+}
+
+void RMOptionScreen::doFrame(CORO_PARAM, RMInput *input) {
+ CORO_BEGIN_CONTEXT;
+ bool bLeftClick, bRightClick;
+ RMPoint mousePos;
+ bool bRefresh;
+ int i;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+
+ // If it is fully open, do nothing
+ if (_fadeStep != 6)
+ return;
+
+ // Reads input
+ _ctx->mousePos = input->mousePos();
+ _ctx->bLeftClick = input->mouseLeftClicked();
+ _ctx->bRightClick = input->mouseRightClicked();
+
+ _ctx->bRefresh = false;
+
+ if (_bQuitConfirm) {
+ _ctx->bRefresh |= _buttonQuitYes->doFrame(_ctx->mousePos, _ctx->bLeftClick, _ctx->bRightClick);
+ _ctx->bRefresh |= _buttonQuitNo->doFrame(_ctx->mousePos, _ctx->bLeftClick, _ctx->bRightClick);
+ } else {
+ _ctx->bRefresh |= _buttonExit->doFrame(_ctx->mousePos, _ctx->bLeftClick, _ctx->bRightClick);
+
+ // Check if you have clicked on the output
+ if (_nState == MENUGAME || _nState == MENUGFX || _nState == MENUSOUND) {
+ // Buttons without graphics...
+ _buttonGameMenu->doFrame(_ctx->mousePos, _ctx->bLeftClick, _ctx->bRightClick);
+ _buttonGfxMenu->doFrame(_ctx->mousePos, _ctx->bLeftClick, _ctx->bRightClick);
+ _buttonSoundMenu->doFrame(_ctx->mousePos, _ctx->bLeftClick, _ctx->bRightClick);
+
+ // Buttons with graphics
+ if (!_bNoLoadSave) {
+ if (!g_vm->getIsDemo()) {
+ _ctx->bRefresh |= _buttonLoad->doFrame(_ctx->mousePos, _ctx->bLeftClick, _ctx->bRightClick);
+ _ctx->bRefresh |= _buttonSave->doFrame(_ctx->mousePos, _ctx->bLeftClick, _ctx->bRightClick);
+ }
+
+ _ctx->bRefresh |= _buttonQuit->doFrame(_ctx->mousePos, _ctx->bLeftClick, _ctx->bRightClick);
+ }
+ }
+
+ if (_nState == MENUGAME) {
+ _ctx->bRefresh |= _buttonGame_Lock->doFrame(_ctx->mousePos, _ctx->bLeftClick, _ctx->bRightClick);
+ _ctx->bRefresh |= _buttonGame_TimerizedText->doFrame(_ctx->mousePos, _ctx->bLeftClick, _ctx->bRightClick);
+ _ctx->bRefresh |= _buttonGame_Scrolling->doFrame(_ctx->mousePos, _ctx->bLeftClick, _ctx->bRightClick);
+ _ctx->bRefresh |= _buttonGame_InterUp->doFrame(_ctx->mousePos, _ctx->bLeftClick, _ctx->bRightClick);
+ _ctx->bRefresh |= _slideTextSpeed->doFrame(_ctx->mousePos, _ctx->bLeftClick, _ctx->bRightClick);
+ _ctx->bRefresh |= _slideTonySpeed->doFrame(_ctx->mousePos, _ctx->bLeftClick, _ctx->bRightClick);
+
+ } else if (_nState == MENUGFX) {
+ _ctx->bRefresh |= _buttonGfx_Anni30->doFrame(_ctx->mousePos, _ctx->bLeftClick, _ctx->bRightClick);
+ _ctx->bRefresh |= _buttonGfx_AntiAlias->doFrame(_ctx->mousePos, _ctx->bLeftClick, _ctx->bRightClick);
+ _ctx->bRefresh |= _buttonGfx_Sottotitoli->doFrame(_ctx->mousePos, _ctx->bLeftClick, _ctx->bRightClick);
+ _ctx->bRefresh |= _buttonGfx_Tips->doFrame(_ctx->mousePos, _ctx->bLeftClick, _ctx->bRightClick);
+ _ctx->bRefresh |= _buttonGfx_Trans->doFrame(_ctx->mousePos, _ctx->bLeftClick, _ctx->bRightClick);
+
+ } else if (_nState == MENUSOUND) {
+ _ctx->bRefresh |= _sliderSound_Dubbing->doFrame(_ctx->mousePos, _ctx->bLeftClick, _ctx->bRightClick);
+ _ctx->bRefresh |= _sliderSound_Music->doFrame(_ctx->mousePos, _ctx->bLeftClick, _ctx->bRightClick);
+ _ctx->bRefresh |= _sliderSound_SFX->doFrame(_ctx->mousePos, _ctx->bLeftClick, _ctx->bRightClick);
+ _ctx->bRefresh |= _buttonSound_DubbingOn->doFrame(_ctx->mousePos, _ctx->bLeftClick, _ctx->bRightClick);
+ _ctx->bRefresh |= _buttonSound_MusicOn->doFrame(_ctx->mousePos, _ctx->bLeftClick, _ctx->bRightClick);
+ _ctx->bRefresh |= _buttonSound_SFXOn->doFrame(_ctx->mousePos, _ctx->bLeftClick, _ctx->bRightClick);
+
+ } else if (_nState == MENULOAD || _nState == MENUSAVE) {
+ for (_ctx->i = 0; _ctx->i < 6; _ctx->i++)
+ _buttonSave_States[_ctx->i]->doFrame(_ctx->mousePos, _ctx->bLeftClick, _ctx->bRightClick);
+
+ if (_statePos > 0)
+ _ctx->bRefresh |= _buttonSave_ArrowLeft->doFrame(_ctx->mousePos, _ctx->bLeftClick, _ctx->bRightClick);
+ if (_statePos < 90)
+ _ctx->bRefresh |= _buttonSave_ArrowRight->doFrame(_ctx->mousePos, _ctx->bLeftClick, _ctx->bRightClick);
+ }
+ }
+
+#define KEYPRESS(c) (g_vm->getEngine()->getInput().getAsyncKeyState(c))
+#define PROCESS_CHAR(cod, c) if (KEYPRESS(cod)) { \
+ _editName[strlen(_editName) + 1] = '\0'; _editName[strlen(_editName)] = c; _ctx->bRefresh = true; }
+
+ // State Buttons
+ if (_bEditSaveName) {
+ if (KEYPRESS(Common::KEYCODE_BACKSPACE)) {
+ if (_editName[0] != '\0') {
+ _editName[strlen(_editName) - 1] = '\0';
+ _ctx->bRefresh = true;
+ }
+ }
+
+ for (_ctx->i = 0; _ctx->i < 26 && strlen(_editName) < 12; _ctx->i++) {
+ if (KEYPRESS(Common::KEYCODE_LSHIFT) ||
+ KEYPRESS(Common::KEYCODE_RSHIFT)) {
+ PROCESS_CHAR((Common::KeyCode)((int)'a' + _ctx->i), _ctx->i + 'A');
+ } else {
+ PROCESS_CHAR((Common::KeyCode)((int)'a' + _ctx->i), _ctx->i + 'a');
+ }
+ }
+
+ for (_ctx->i = 0; _ctx->i < 10 && strlen(_editName) < 12; _ctx->i++)
+ PROCESS_CHAR((Common::KeyCode)((int)'0' + _ctx->i), _ctx->i + '0');
+
+ if (strlen(_editName) < 12)
+ PROCESS_CHAR(Common::KEYCODE_SPACE, ' ');
+
+ if (strlen(_editName) < 12)
+ PROCESS_CHAR(Common::KEYCODE_KP0, '0');
+ if (strlen(_editName) < 12)
+ PROCESS_CHAR(Common::KEYCODE_KP1, '1');
+ if (strlen(_editName) < 12)
+ PROCESS_CHAR(Common::KEYCODE_KP2, '2');
+ if (strlen(_editName) < 12)
+ PROCESS_CHAR(Common::KEYCODE_KP3, '3');
+ if (strlen(_editName) < 12)
+ PROCESS_CHAR(Common::KEYCODE_KP4, '4');
+ if (strlen(_editName) < 12)
+ PROCESS_CHAR(Common::KEYCODE_KP5, '5');
+ if (strlen(_editName) < 12)
+ PROCESS_CHAR(Common::KEYCODE_KP6, '6');
+ if (strlen(_editName) < 12)
+ PROCESS_CHAR(Common::KEYCODE_KP7, '7');
+ if (strlen(_editName) < 12)
+ PROCESS_CHAR(Common::KEYCODE_KP8, '8');
+ if (strlen(_editName) < 12)
+ PROCESS_CHAR(Common::KEYCODE_KP9, '9');
+
+ // Cancel
+ if (KEYPRESS(Common::KEYCODE_ESCAPE)) {
+ _bEditSaveName = false;
+ _ctx->bRefresh = true;
+ }
+
+ // OK
+ if (KEYPRESS(Common::KEYCODE_RETURN)) {
+ _bEditSaveName = false;
+ g_vm->saveState(_statePos + _nEditPos, _editName);
+ close();
+ }
+
+ } else if (_ctx->bLeftClick) {
+ if (_nState == MENULOAD || _nState == MENUSAVE) {
+ if (_buttonExit->isActive()) {
+ if (_bLoadMenuOnly) {
+ // If only the loading menu, close
+ close();
+ } else {
+ CORO_INVOKE_1(changeState, _nLastState);
+ _ctx->bRefresh = true;
+ }
+ } else if (_buttonSave_ArrowLeft->isActive()) {
+ if (_statePos > 0) {
+ _statePos -= 6;
+ if (_statePos < 0)
+ _statePos = 0;
+ _buttonSave_ArrowLeft->setActiveState(false);
+ _ctx->bRefresh = true;
+ refreshThumbnails();
+ }
+ } else if (_buttonSave_ArrowRight->isActive()) {
+ if (_statePos < 90) {
+ _statePos += 6;
+ if (_statePos > 90)
+ _statePos = 90;
+ _buttonSave_ArrowRight->setActiveState(false);
+ _ctx->bRefresh = true;
+ refreshThumbnails();
+ }
+ } else {
+ for (_ctx->i = 0; _ctx->i < 6; _ctx->i++)
+ if (_buttonSave_States[_ctx->i]->isActive()) {
+ // There by saving or loading!!!
+ if (_nState == MENULOAD && _curThumb[_ctx->i] != NULL) {
+ // Loading
+ CORO_INVOKE_1(g_vm->loadState, _statePos + _ctx->i);
+ close();
+ } else if (_nState == MENUSAVE && (_statePos != 0 || _ctx->i != 0)) {
+ // Turn on edit mode
+ _bEditSaveName = true;
+ _nEditPos = _ctx->i;
+ strcpy(_editName, _curThumbName[_ctx->i].c_str());
+ _ctx->bRefresh = true;
+ }
+
+ break;
+ }
+ }
+ }
+
+ if (_nState == MENUGAME || _nState == MENUGFX || _nState == MENUSOUND) {
+ if (_bQuitConfirm) {
+ if (_buttonQuitNo->isActive()) {
+ _bQuitConfirm = false;
+ _ctx->bRefresh = true;
+ } else if (_buttonQuitYes->isActive()) {
+ _bQuitConfirm = false;
+ _ctx->bRefresh = true;
+
+ g_vm->quitGame();
+ }
+ } else {
+ if (_buttonQuit->isActive()) {
+ _bQuitConfirm = true;
+ _buttonQuitNo->setActiveState(false);
+ _buttonQuitYes->setActiveState(false);
+ _ctx->bRefresh = true;
+ } else if (_buttonExit->isActive())
+ close();
+ else if (_buttonLoad->isActive()) {
+ CORO_INVOKE_1(changeState, MENULOAD);
+ _ctx->bRefresh = true;
+ } else if (_buttonSave->isActive()) {
+ CORO_INVOKE_1(changeState, MENUSAVE);
+ _ctx->bRefresh = true;
+ } else if (_buttonGameMenu->isActive() && _nState != MENUGAME) {
+ CORO_INVOKE_1(changeState, MENUGAME);
+ _ctx->bRefresh = true;
+ } else if (_buttonGfxMenu->isActive() && _nState != MENUGFX) {
+ CORO_INVOKE_1(changeState, MENUGFX);
+ _ctx->bRefresh = true;
+ } else if (_buttonSoundMenu->isActive() && _nState != MENUSOUND) {
+ CORO_INVOKE_1(changeState, MENUSOUND);
+ _ctx->bRefresh = true;
+ }
+
+ if (_nState == MENUGFX) {
+ // These options take effect immediately
+ if (_buttonGfx_Anni30->isActive())
+ GLOBALS._bCfgAnni30 = true;
+ else
+ GLOBALS._bCfgAnni30 = false;
+
+ if (_buttonGfx_AntiAlias->isActive())
+ GLOBALS._bCfgAntiAlias = false;
+ else
+ GLOBALS._bCfgAntiAlias = true;
+
+ if (_buttonGfx_Trans->isActive())
+ GLOBALS._bCfgTransparence = false;
+ else
+ GLOBALS._bCfgTransparence = true;
+ }
+ }
+ }
+ }
+
+ if (_nState == MENUGAME || _nState == MENUGFX || _nState == MENUSOUND) {
+ if (!_bQuitConfirm && KEYPRESS(Common::KEYCODE_ESCAPE))
+ close();
+ }
+
+ if (_ctx->bRefresh)
+ CORO_INVOKE_0(refreshAll);
+
+ CORO_END_CODE;
+}
+
+
+void RMOptionScreen::draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim) {
+ CORO_BEGIN_CONTEXT;
+ int curTime;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ _ctx->curTime = g_vm->getTime();
+
+#define FADE_SPEED 20
+#define SYNC (_ctx->curTime - _fadeTime) / 25
+
+ if (_bExit)
+ return;
+
+ if (_fadeStep == 1) {
+ // Downhill fast
+ if (_fadeTime == -1)
+ _fadeY += FADE_SPEED;
+ else
+ _fadeY += FADE_SPEED * SYNC;
+ if (_fadeY > 480) {
+ _fadeY = 480;
+ _fadeStep++;
+ }
+
+ // Set the part to draw the scrolling
+ prim->setSrc(RMRect(0, 480 - _fadeY, 640, 480));
+
+ } else if (_fadeStep == 2) {
+ // Bounce 1
+ _fadeY -= FADE_SPEED / 2 * SYNC;
+ if (_fadeY < 400) {
+ _fadeY = 400;
+ _fadeStep++;
+ }
+
+ prim->setSrc(RMRect(0, 480 - _fadeY, 640, 480));
+
+ } else if (_fadeStep == 3) {
+ _fadeY -= FADE_SPEED / 4 * SYNC;
+ if (_fadeY < 380) {
+ _fadeY = 380;
+ _fadeStep++;
+ }
+
+ prim->setSrc(RMRect(0, 480 - _fadeY, 640, 480));
+
+ } else if (_fadeStep == 4) {
+ // Bounce 1 - 2
+ _fadeY += FADE_SPEED / 3 * SYNC;
+ if (_fadeY > 420) {
+ _fadeY = 420;
+ _fadeStep++;
+ }
+
+ prim->setSrc(RMRect(0, 480 - _fadeY, 640, 480));
+
+ } else if (_fadeStep == 5) {
+ _fadeY += FADE_SPEED / 2 * SYNC;
+ if (_fadeY > 480) {
+ _fadeY = 480;
+ _fadeStep++;
+ g_vm->hideLocation();
+ }
+
+ prim->setSrc(RMRect(0, 480 - _fadeY, 640, 480));
+
+ } else if (_fadeStep == 6) {
+ // Menu ON
+
+ } else if (_fadeStep == 7) {
+ // Menu OFF
+ g_vm->showLocation();
+ _fadeStep++;
+
+ } else if (_fadeStep == 8) {
+ _fadeY -= FADE_SPEED * SYNC;
+ if (_fadeY < 0) {
+ _fadeY = 0;
+ _fadeStep++;
+ }
+ prim->setSrc(RMRect(0, 480 - _fadeY, 640, 480));
+
+ } else if (_fadeStep == 9) {
+ // Hello hello!
+ _bExit = true;
+ _fadeStep = 0;
+
+ // Free memory
+ closeState();
+ return;
+
+ } else {
+ _fadeStep = 0;
+ }
+
+ _fadeTime = _ctx->curTime;
+
+ CORO_INVOKE_2(RMGfxWoodyBuffer::draw, bigBuf, prim);
+
+ CORO_END_CODE;
+}
+
+void RMOptionScreen::removeThis(CORO_PARAM, bool &result) {
+ if (_bExit)
+ result = true;
+ else
+ result = false;
+}
+
+
+bool RMOptionScreen::loadThumbnailFromSaveState(int nState, byte *lpDestBuf, Common::String &name, byte &diff) {
+ Common::String buf;
+ char namebuf[256];
+ int i;
+ Common::InSaveFile *f;
+ char id[4];
+
+ // Cleans the destination
+ Common::fill(lpDestBuf, lpDestBuf + 160 * 120 * 2, 0);
+ name = "No name";
+ diff = 10;
+
+ // Get the savegame filename for the given slot
+ buf = g_vm->getSaveStateFileName(nState);
+
+ // Try and open the savegame
+ f = g_system->getSavefileManager()->openForLoading(buf);
+ if (f == NULL)
+ return false;
+
+ // Check to see if the file has a valid header
+ f->read(id, 4);
+ if (id[0] != 'R' || id[1] != 'M' || id[2] != 'S') {
+ delete f;
+ return false;
+ }
+
+ if (id[3] < 0x3) {
+ // Very old version that doesn't have screenshots
+ delete f;
+ return true;
+ }
+
+ // Load the screenshot
+ if ((id[3] >= 0x5) && (id[3] < 0x8)) {
+ // Read it as an LZO compressed data block
+ byte *cmpbuf;
+ uint32 cmpsize, size;
+
+ cmpbuf = new byte[160 * 120 * 4];
+
+ // Read in the compressed data
+ cmpsize = f->readUint32LE();
+ f->read(cmpbuf, cmpsize);
+
+ lzo1x_decompress(cmpbuf, cmpsize, lpDestBuf, &size);
+
+ delete[] cmpbuf;
+ } else {
+ // Read in the screenshot as an uncompressed data block
+ if (id[3] >= 8)
+ // Recent versions use hardcoded 160x120 uncomrpessed data, so size can be skipped
+ f->skip(4);
+
+ f->read(lpDestBuf, 160 * 120 * 2);
+ }
+
+ if (id[3] >= 0x5) {
+ // Read in the difficulty level
+ diff = f->readByte();
+ }
+
+ if (id[3] < 0x4) {
+ // Savegame version doesn't have a stored name
+ delete f;
+ return true;
+ }
+
+ i = f->readByte();
+ f->read(namebuf, i);
+ namebuf[i] = '\0';
+ name = namebuf;
+
+ delete f;
+ return true;
+}
+
+/****************************************************************************\
+* RMPointer Methods
+\****************************************************************************/
+
+RMPointer::RMPointer() {
+ Common::fill(_pointer, _pointer + 16, (RMGfxSourceBuffer8 *)NULL);
+ Common::fill(_specialPointer, _specialPointer + 16, (RMItem *)NULL);
+
+ _nCurPointer = _nCurSpecialPointer = 0;
+ _nCurCustomPointer = NULL;
+}
+
+RMPointer::~RMPointer() {
+ close();
+}
+
+void RMPointer::init() {
+ int i;
+
+ for (i = 0; i < 5; i++) {
+ RMResRaw res(RES_P_GO + i);
+
+ _pointer[i] = new RMGfxSourceBuffer8RLEByteAA;
+ _pointer[i]->init(res, res.width(), res.height(), false);
+ _pointer[i]->loadPaletteWA(RES_P_PAL);
+ }
+
+ for (i = 0; i < 5; i++) {
+ RMRes res(RES_P_PAP1 + i);
+ Common::SeekableReadStream *ds = res.getReadStream();
+ _specialPointer[i] = new RMItem;
+ _specialPointer[i]->readFromStream(*ds);
+ delete ds;
+ }
+
+ //m_hotspot[0].set(19,5);
+ _hotspot[0].set(5, 1);
+ _hotspot[1].set(32, 28);
+ _hotspot[2].set(45, 23);
+ _hotspot[3].set(35, 25);
+ _hotspot[4].set(32, 28);
+
+ // Default=GO
+ _nCurPointer = 0;
+ _nCurSpecialPointer = 0;
+}
+
+void RMPointer::close() {
+ int i;
+
+ for (i = 0; i < 5; i++) {
+ if (_pointer[i] != NULL) {
+ delete _pointer[i];
+ _pointer[i] = NULL;
+ }
+
+ if (_specialPointer[i] != NULL) {
+ delete _specialPointer[i];
+ _specialPointer[i] = NULL;
+ }
+ }
+}
+
+void RMPointer::draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim) {
+ CORO_BEGIN_CONTEXT;
+ int n;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ // Check the pointer
+ _ctx->n = _nCurPointer;
+ if (_ctx->n == TA_COMBINE)
+ _ctx->n = TA_USE;
+
+ _cursorHotspot = _hotspot[_ctx->n];
+
+ // Call the Draw method of the pointer
+ if (_nCurSpecialPointer == 0) {
+ // WORKAROUND: updateCursor gets called too early sometimes (for example, when
+ // the cursor is released over the TA_PERORATE option), via setAction.
+ if (_ctx->n > 4)
+ _ctx->n = 0;
+
+ CORO_INVOKE_2(_pointer[_ctx->n]->draw, bigBuf, prim);
+ } else {
+ if (_nCurSpecialPointer == PTR_CUSTOM)
+ CORO_INVOKE_2(_nCurCustomPointer->draw, bigBuf, prim);
+ else
+ // Call the draw on the special pointer
+ CORO_INVOKE_2(_specialPointer[_nCurSpecialPointer - 1]->draw, bigBuf, prim);
+ }
+
+ CORO_END_CODE;
+}
+
+int RMPointer::curAction() {
+ if (_nCurSpecialPointer != 0)
+ return 0;
+
+ return _nCurPointer;
+}
+
+/**
+ * Show the cursor
+ */
+void RMPointer::showCursor() {
+ if (!CursorMan.isVisible()) {
+ CursorMan.showMouse(true);
+
+ updateCursor();
+ }
+}
+
+/**
+ * Hide the cursor
+ */
+void RMPointer::hideCursor() {
+ if (CursorMan.isVisible()) {
+ CursorMan.showMouse(false);
+ }
+}
+
+void RMPointer::doFrame() {
+ // Update the cursor animation if needed.
+ if (_nCurSpecialPointer == 0 || _nCurSpecialPointer == PTR_CUSTOM)
+ return;
+
+ RMGfxTargetBuffer buf;
+ if (_specialPointer[_nCurSpecialPointer - 1]->doFrame(&buf, false))
+ updateCursor();
+}
+
+void RMPointer::updateCursor() {
+ // Create an intermediate buffer and draw the cursor onto it
+ RMGfxTargetBuffer buf;
+ buf.create(64, 64, 16);
+ RMGfxPrimitive prim;
+
+ draw(Common::nullContext, buf, &prim);
+
+ // Get a pointer to the cursor data
+ byte *cursorData = buf;
+
+ // If in black & white mode, convert the cursor
+ if (GLOBALS._bCfgAnni30) {
+ if (!RMGfxTargetBuffer::_precalcTable) {
+ RMGfxTargetBuffer::createBWPrecalcTable();
+ }
+ uint16 *src = (uint16 *)cursorData;
+ for (int i = 0; i < 64; i++) {
+ uint16 *lineP = src;
+ for (int j = 0; j < 64; j++) {
+ lineP[j] = RMGfxTargetBuffer::_precalcTable[lineP[j] & 0x7FFF];
+ }
+ src += 64;
+ }
+ }
+
+ // Get the raw pixel data and set the cursor to it
+ Graphics::PixelFormat pixelFormat(2, 5, 5, 5, 0, 10, 5, 0, 0);
+ CursorMan.replaceCursor(cursorData, 64, 64, _cursorHotspot._x, _cursorHotspot._y, 0, 1, &pixelFormat);
+}
+
+/**
+ * Sets a new action as current
+ */
+void RMPointer::setAction(RMTonyAction action) {
+ _nCurPointer = action;
+ updateCursor();
+}
+
+/**
+ * Sets a new pointer
+ */
+void RMPointer::setSpecialPointer(PointerType ptr) {
+ _nCurSpecialPointer = ptr;
+ if (_nCurSpecialPointer && _nCurSpecialPointer != PTR_CUSTOM)
+ _specialPointer[ptr - 1]->setPattern(1);
+
+ updateCursor();
+}
+
+RMPointer::PointerType RMPointer::getSpecialPointer() {
+ return (PointerType)_nCurSpecialPointer;
+}
+
+/**
+ * Set the new custom pointer
+ */
+void RMPointer::setCustomPointer(RMGfxSourceBuffer8 *ptr) {
+ _nCurCustomPointer = ptr;
+ updateCursor();
+}
+
+} // End of namespace Tony
diff --git a/engines/tony/game.h b/engines/tony/game.h
new file mode 100644
index 0000000000..83a1ddaea1
--- /dev/null
+++ b/engines/tony/game.h
@@ -0,0 +1,340 @@
+/* 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.
+ *
+ */
+
+/*
+ * This code is based on original Tony Tough source code
+ *
+ * Copyright (c) 1997-2003 Nayma Software
+ */
+
+#ifndef TONY_GAME_H
+#define TONY_GAME_H
+
+#include "tony/gfxcore.h"
+#include "tony/input.h"
+#include "tony/loc.h"
+#include "tony/utils.h"
+
+namespace Tony {
+
+#define INIT_GFX16_FROMRAW(dwRes, buf16) \
+ raw = new RMResRaw(dwRes); \
+ assert(raw->isValid()); \
+ assert((buf16) == NULL); \
+ (buf16) = new RMGfxSourceBuffer16(false); \
+ (buf16)->init(*raw, raw->width(), raw->height()); \
+ delete raw;
+
+#define INIT_GFX8_FROMRAW(raw, dwRes, buf8) \
+ raw = new RMResRaw(dwRes); \
+ assert(raw->isValid()); \
+ assert((buf8) == NULL); \
+ (buf8) = new RMGfxSourceBuffer8RLEByte(); \
+ (buf8)->init(*raw, raw->width(), raw->height(), true); \
+ delete raw;
+
+// X & Y dimensions of the adventure
+#define RM_SX 640
+#define RM_SY 480
+
+// X & Y dimensions of bigbuf
+#define RM_BBX (RM_SX)
+#define RM_BBY (RM_SY)
+
+// Skipping X & Y
+#define RM_SKIPY ((RM_BBY - RM_SY) / 2)
+#define RM_SKIPX 0
+
+// Tony's actions
+enum RMTonyAction {
+ TA_GOTO = 0,
+ TA_TAKE,
+ TA_USE,
+ TA_EXAMINE,
+ TA_TALK,
+ TA_PERORATE,
+
+ TA_COMBINE = 10,
+ TA_RECEIVECOMBINE,
+ TA_COMBINEGIVE,
+ TA_RECEIVECOMBINEGIVE
+};
+
+// Global Functions
+void mainEnableGUI();
+void mainDisableGUI();
+
+// Classes
+class RMPointer {
+public:
+ enum PointerType {
+ PTR_NONE = 0,
+ PTR_ARROWUP,
+ PTR_ARROWDOWN,
+ PTR_ARROWLEFT,
+ PTR_ARROWRIGHT,
+ PTR_ARROWMAP,
+ PTR_CUSTOM
+ };
+
+private:
+ RMGfxSourceBuffer8 *_pointer[16];
+ RMPoint _hotspot[16];
+ RMPoint _cursorHotspot;
+
+ RMItem *_specialPointer[16];
+
+ int _nCurPointer;
+ int _nCurSpecialPointer;
+
+ RMGfxSourceBuffer8 *_nCurCustomPointer;
+
+public:
+ /**
+ * Constructor & destructor
+ */
+ RMPointer();
+ virtual ~RMPointer();
+
+ /**
+ * Initialization
+ */
+ void init();
+
+ /**
+ * Deinitialization
+ */
+ void close();
+
+ /**
+ * Process a frame
+ */
+ void doFrame();
+
+ /**
+ * draw method
+ */
+ void draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim);
+
+ /**
+ * Sets a new action as current
+ */
+ void setAction(RMTonyAction action);
+
+ /**
+ * Sets a new pointer
+ */
+ void setSpecialPointer(PointerType ptr);
+
+ PointerType getSpecialPointer();
+
+ /**
+ * Set the new custom pointer
+ */
+ void setCustomPointer(RMGfxSourceBuffer8 *ptr);
+
+ /**
+ * Return the current action to be applied according to the pointer
+ */
+ int curAction();
+
+ /**
+ * Update the cursor
+ */
+ void updateCursor();
+
+ /**
+ * Show the cursor
+ */
+ void showCursor();
+
+ /**
+ * Hide the cursor
+ */
+ void hideCursor();
+};
+
+class RMOptionButton: public RMGfxTaskSetPrior {
+public:
+ RMRect _rect;
+ RMGfxSourceBuffer16 *_buf;
+ bool _bActive;
+ bool _bHasGfx;
+ bool _bDoubleState;
+
+public:
+ RMOptionButton(uint32 dwRes, RMPoint pt, bool bDoubleState = false);
+ RMOptionButton(const RMRect &pt);
+ virtual ~RMOptionButton();
+
+ bool doFrame(const RMPoint &mousePos, bool bLeftClick, bool bRightClick);
+ virtual void draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim);
+ void addToList(RMGfxTargetBuffer &bigBuf);
+ bool isActive();
+ void setActiveState(bool bState);
+};
+
+class RMOptionSlide : public RMGfxTaskSetPrior {
+private:
+ RMOptionButton *_pushLeft;
+ RMOptionButton *_pushRight;
+ RMGfxSourceBuffer16 *_sliderCenter;
+ RMGfxSourceBuffer16 *_sliderLeft;
+ RMGfxSourceBuffer16 *_sliderRight;
+ RMGfxSourceBuffer16 *_sliderSingle;
+ int _nSlideSize;
+ RMPoint _pos;
+ int _nValue;
+ int _nMax;
+ int _nStep;
+
+public:
+ RMOptionSlide(const RMPoint &pt, int m_nRange = 100, int m_nStartValue = 0, int slideSize = 300);
+ virtual ~RMOptionSlide();
+
+ bool doFrame(const RMPoint &mousePos, bool bLeftClick, bool bRightClick);
+ virtual void draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim);
+ void addToList(RMGfxTargetBuffer &bigBuf);
+
+ int getValue();
+};
+
+class RMOptionScreen : public RMGfxWoodyBuffer {
+private:
+ RMGfxSourceBuffer16 *_menu;
+ RMGfxSourceBuffer16 *_quitConfirm;
+ RMGfxSourceBuffer16 *_hideLoadSave;
+ RMOptionButton *_buttonQuitYes;
+ RMOptionButton *_buttonQuitNo;
+ RMOptionButton *_buttonExit;
+ RMOptionButton *_buttonQuit;
+ RMOptionButton *_buttonLoad;
+ RMOptionButton *_buttonSave;
+ RMOptionButton *_buttonGameMenu;
+ RMOptionButton *_buttonGfxMenu;
+ RMOptionButton *_buttonSoundMenu;
+ RMGfxSourceBuffer8 *_saveEasy;
+ RMGfxSourceBuffer8 *_saveHard;
+ RMGfxSourceBuffer16 *_curThumb[6];
+ Common::String _curThumbName[6];
+ byte _curThumbDiff[6];
+ RMOptionButton *_buttonSave_States[6];
+ RMOptionButton *_buttonSave_ArrowLeft;
+ RMOptionButton *_buttonSave_ArrowRight;
+ RMOptionButton *_buttonGfx_Tips;
+
+ RMOptionButton *_buttonSound_DubbingOn;
+ RMOptionButton *_buttonSound_MusicOn;
+ RMOptionButton *_buttonSound_SFXOn;
+
+ RMOptionSlide *_slideTonySpeed;
+ RMOptionSlide *_slideTextSpeed;
+
+
+ int _statePos;
+ bool _bEditSaveName;
+ int _nEditPos;
+ char _editName[256];
+
+ union {
+ RMOptionButton *_buttonGame_Lock;
+ RMOptionButton *_buttonGfx_Anni30;
+ RMOptionSlide *_sliderSound_Music;
+ };
+ union {
+ RMOptionButton *_buttonGame_TimerizedText;
+ RMOptionButton *_buttonGfx_AntiAlias;
+ RMOptionSlide *_sliderSound_SFX;
+ };
+ union {
+ RMOptionButton *_buttonGame_Scrolling;
+ RMOptionButton *_buttonGfx_Sottotitoli;
+ RMOptionSlide *_sliderSound_Dubbing;
+ };
+ union {
+ RMOptionButton *_buttonGame_InterUp;
+ RMOptionButton *_buttonGfx_Trans;
+ };
+
+ int _fadeStep;
+ bool _bExit;
+ bool _bQuitConfirm;
+ int _fadeY;
+ int _fadeTime;
+ bool _bLoadMenuOnly;
+ bool _bNoLoadSave;
+ bool _bAlterGfx;
+
+ enum OptionScreenState {
+ MENUGAME,
+ MENUGFX,
+ MENUSOUND,
+ MENULOAD,
+ MENUSAVE,
+ MENUNONE
+ };
+
+ OptionScreenState _nState;
+ OptionScreenState _nLastState;
+
+public:
+ RMOptionScreen();
+ virtual ~RMOptionScreen();
+
+ void init(CORO_PARAM, RMGfxTargetBuffer &bigBuf, bool &result);
+ void initLoadMenuOnly(CORO_PARAM, RMGfxTargetBuffer &bigBuf, bool bAlternateGfx, bool &result);
+ void initSaveMenuOnly(CORO_PARAM, RMGfxTargetBuffer &bigBuf, bool bAlternateGfx, bool &result);
+ void initNoLoadSave(CORO_PARAM, RMGfxTargetBuffer &bigBuf, bool &result);
+ void reInit(RMGfxTargetBuffer &bigBuf);
+ bool close();
+ bool isClosing();
+
+ // Overloaded methods
+ virtual int priority();
+ virtual void draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim);
+ virtual void removeThis(CORO_PARAM, bool &result);
+
+ /**
+ * Polling for the option screen
+ */
+ void doFrame(CORO_PARAM, RMInput *m_input);
+
+ /**
+ * Retrieves a savegame's thumbnail, description, and difficulty level
+ */
+ static bool loadThumbnailFromSaveState(int numState, byte *lpDestBuf, Common::String &name, byte &diff);
+
+protected:
+
+ // Initialization and state change
+ void initState(CORO_PARAM);
+ void closeState();
+ void changeState(CORO_PARAM, OptionScreenState newState);
+
+ // Repaint the options menu
+ void refreshAll(CORO_PARAM);
+ void refreshThumbnails();
+};
+
+} // End of namespace Tony
+
+#endif
diff --git a/engines/tony/gfxcore.cpp b/engines/tony/gfxcore.cpp
new file mode 100644
index 0000000000..71bf31396c
--- /dev/null
+++ b/engines/tony/gfxcore.cpp
@@ -0,0 +1,2212 @@
+/* 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.
+ *
+ */
+
+/*
+ * This code is based on original Tony Tough source code
+ *
+ * Copyright (c) 1997-2003 Nayma Software
+ */
+
+#include "tony/gfxengine.h"
+#include "tony/mpal/mpalutils.h"
+#include "tony/tony.h"
+
+namespace Tony {
+
+/****************************************************************************\
+* RMGfxTask Methods
+\****************************************************************************/
+
+RMGfxTask::RMGfxTask() {
+ _nPrior = 0;
+ _nInList = 0;
+}
+
+int RMGfxTask::priority() {
+ return _nPrior;
+}
+
+void RMGfxTask::removeThis(CORO_PARAM, bool &result) {
+ result = true;
+}
+
+/**
+ * Registration
+ */
+void RMGfxTask::Register() {
+ _nInList++;
+}
+
+void RMGfxTask::Unregister() {
+ _nInList--;
+ assert(_nInList >= 0);
+}
+
+/****************************************************************************\
+* RMGfxTaskSetPrior Methods
+\****************************************************************************/
+
+void RMGfxTaskSetPrior::setPriority(int nPrior) {
+ _nPrior = nPrior;
+}
+
+
+/****************************************************************************\
+* RMGfxBuffer Methods
+\****************************************************************************/
+
+RMGfxBuffer::RMGfxBuffer() {
+ _dimx = _dimy = 0;
+ _origBuf = _buf = NULL;
+}
+
+RMGfxBuffer::~RMGfxBuffer() {
+ destroy();
+}
+
+void RMGfxBuffer::create(int dimx, int dimy, int nBpp) {
+ // Destroy the buffer it is already exists
+ if (_buf != NULL)
+ destroy();
+
+ // Copy the parameters in the private members
+ _dimx = dimx;
+ _dimy = dimy;
+
+ // Allocate a buffer
+ _origBuf = _buf = new byte[_dimx * _dimy * nBpp / 8];
+ assert(_buf != NULL);
+ Common::fill(_origBuf, _origBuf + _dimx * _dimy * nBpp / 8, 0);
+}
+
+void RMGfxBuffer::destroy() {
+ if (_origBuf != NULL && _origBuf == _buf) {
+ delete[] _origBuf;
+ _origBuf = _buf = NULL;
+ }
+}
+
+void RMGfxBuffer::offsetY(int nLines, int nBpp) {
+ _buf += nLines * getDimx() * nBpp / 8;
+}
+
+
+RMGfxBuffer::operator byte *() {
+ return _buf;
+}
+
+RMGfxBuffer::operator void *() {
+ return (void *)_buf;
+}
+
+RMGfxBuffer::RMGfxBuffer(int dimx, int dimy, int nBpp) {
+ create(dimx, dimy, nBpp);
+}
+
+int RMGfxBuffer::getDimx() {
+ return _dimx;
+}
+
+int RMGfxBuffer::getDimy() {
+ return _dimy;
+}
+
+
+/****************************************************************************\
+* RMGfxSourceBuffer Methods
+\****************************************************************************/
+
+int RMGfxSourceBuffer::init(const byte *buf, int dimx, int dimy, bool bLoadPalette) {
+ create(dimx, dimy, getBpp());
+ memcpy(_buf, buf, dimx * dimy * getBpp() / 8);
+
+ // Invokes the method for preparing the surface (inherited)
+ prepareImage();
+
+ return dimx * dimy * getBpp() / 8;
+}
+
+void RMGfxSourceBuffer::init(Common::ReadStream &ds, int dimx, int dimy, bool bLoadPalette) {
+ create(dimx, dimy, getBpp());
+ ds.read(_buf, dimx * dimy * getBpp() / 8);
+
+ // Invokes the method for preparing the surface (inherited)
+ prepareImage();
+}
+
+RMGfxSourceBuffer::~RMGfxSourceBuffer() {
+}
+
+void RMGfxSourceBuffer::prepareImage() {
+ // Do nothing. Can be overloaded if necessary
+}
+
+bool RMGfxSourceBuffer::clip2D(int &x1, int &y1, int &u, int &v, int &width, int &height, bool bUseSrc, RMGfxTargetBuffer *buf) {
+ int destw, desth;
+
+ destw = buf->getDimx();
+ desth = buf->getDimy();
+
+ if (!bUseSrc) {
+ u = v = 0;
+ width = _dimx;
+ height = _dimy;
+ }
+
+ if (x1 > destw - 1)
+ return false;
+
+ if (y1 > desth - 1)
+ return false;
+
+ if (x1 < 0) {
+ width += x1;
+ if (width < 0)
+ return false;
+ u -= x1;
+ x1 = 0;
+ }
+
+ if (y1 < 0) {
+ height += y1;
+ if (height < 0)
+ return false;
+ v -= y1;
+ y1 = 0;
+ }
+
+ if (x1 + width - 1 > destw - 1)
+ width = destw - x1;
+
+ if (y1 + height - 1 > desth - 1)
+ height = desth - y1;
+
+ return (width > 1 && height > 1);
+}
+
+/**
+ * Initializes a surface by resource Id
+ *
+ * @param resID Resource ID
+ * @param dimx Buffer X dimension
+ * @param dimy Buffer Y dimension
+ */
+int RMGfxSourceBuffer::init(uint32 resID, int dimx, int dimy, bool bLoadPalette) {
+ return init(RMRes(resID), dimx, dimy, bLoadPalette);
+}
+
+void RMGfxSourceBuffer::offsetY(int nLines) {
+ RMGfxBuffer::offsetY(nLines, getBpp());
+}
+
+/****************************************************************************\
+* RMGfxWoodyBuffer Methods
+\****************************************************************************/
+
+RMGfxWoodyBuffer::~RMGfxWoodyBuffer() {
+
+}
+
+void RMGfxWoodyBuffer::draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim) {
+ CORO_BEGIN_CONTEXT;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ // Draw the OT list
+ CORO_INVOKE_0(drawOT);
+
+ // Draw itself into the target buffer
+ CORO_INVOKE_2(RMGfxSourceBuffer16::draw, bigBuf, prim);
+
+ CORO_END_CODE;
+}
+
+RMGfxWoodyBuffer::RMGfxWoodyBuffer() {
+
+}
+
+RMGfxWoodyBuffer::RMGfxWoodyBuffer(int dimx, int dimy)
+ : RMGfxBuffer(dimx, dimy, 16) {
+}
+
+/****************************************************************************\
+* RMGfxTargetBuffer Methods
+\****************************************************************************/
+
+RMGfxTargetBuffer::RMGfxTargetBuffer() {
+ _otlist = NULL;
+ _otSize = 0;
+ _trackDirtyRects = false;
+}
+
+RMGfxTargetBuffer::~RMGfxTargetBuffer() {
+ clearOT();
+}
+
+void RMGfxTargetBuffer::clearOT() {
+ OTList *cur, *n;
+
+ cur = _otlist;
+
+ while (cur != NULL) {
+ cur->_prim->_task->Unregister();
+ delete cur->_prim;
+ n = cur->_next;
+ delete cur;
+ cur = n;
+ }
+
+ _otlist = NULL;
+}
+
+void RMGfxTargetBuffer::drawOT(CORO_PARAM) {
+ CORO_BEGIN_CONTEXT;
+ OTList *cur;
+ OTList *prev;
+ OTList *next;
+ RMGfxPrimitive *myprim;
+ bool result;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ _ctx->prev = NULL;
+ _ctx->cur = _otlist;
+
+ while (_ctx->cur != NULL) {
+ // Call the task Draw method, passing it a copy of the original
+ _ctx->myprim = _ctx->cur->_prim->duplicate();
+ CORO_INVOKE_2(_ctx->cur->_prim->_task->draw, *this, _ctx->myprim);
+ delete _ctx->myprim;
+
+ // Check if it's time to remove the task from the OT list
+ CORO_INVOKE_1(_ctx->cur->_prim->_task->removeThis, _ctx->result);
+ if (_ctx->result) {
+ // De-register the task
+ _ctx->cur->_prim->_task->Unregister();
+
+ // Delete task, freeing the memory
+ delete _ctx->cur->_prim;
+ _ctx->next = _ctx->cur->_next;
+ delete _ctx->cur;
+
+ // If it was the first item, update the list head
+ if (_ctx->prev == NULL)
+ _otlist = _ctx->next;
+ // Otherwise update the next pinter of the previous item
+ else
+ _ctx->prev->_next = _ctx->next;
+
+ _ctx->cur = _ctx->next;
+ } else {
+ // Update the pointer to the previous item, and the current to the next
+ _ctx->prev = _ctx->cur;
+ _ctx->cur = _ctx->cur->_next;
+ }
+ }
+
+ CORO_END_CODE;
+}
+
+void RMGfxTargetBuffer::addPrim(RMGfxPrimitive *prim) {
+ int nPrior;
+ OTList *cur, *n;
+
+ // Warn of the OT listing
+ prim->_task->Register();
+
+ // Check the priority
+ nPrior = prim->_task->priority();
+ n = new OTList(prim);
+
+ // Empty list
+ if (_otlist == NULL) {
+ _otlist = n;
+ _otlist->_next = NULL;
+ }
+ // Inclusion in the head
+ else if (nPrior < _otlist->_prim->_task->priority()) {
+ n->_next = _otlist;
+ _otlist = n;
+ } else {
+ cur = _otlist;
+ while (cur->_next != NULL && nPrior > cur->_next->_prim->_task->priority())
+ cur = cur->_next;
+
+ n->_next = cur->_next;
+ cur->_next = n;
+ }
+}
+
+void RMGfxTargetBuffer::addDirtyRect(const Common::Rect &r) {
+ assert(r.isValidRect());
+ if (_trackDirtyRects && r.width() > 0 && r.height() > 0)
+ _currentDirtyRects.push_back(r);
+}
+
+Common::List<Common::Rect> &RMGfxTargetBuffer::getDirtyRects() {
+ // Copy rects from both the current and previous frame into the output dirty rects list
+ Common::List<Common::Rect>::iterator i;
+ _dirtyRects.clear();
+ for (i = _previousDirtyRects.begin(); i != _previousDirtyRects.end(); ++i)
+ _dirtyRects.push_back(*i);
+ for (i = _currentDirtyRects.begin(); i != _currentDirtyRects.end(); ++i)
+ _dirtyRects.push_back(*i);
+
+ mergeDirtyRects();
+ return _dirtyRects;
+}
+
+/**
+ * Move the set of dirty rects from the finished current frame into the previous frame list.
+ */
+void RMGfxTargetBuffer::clearDirtyRects() {
+ Common::List<Common::Rect>::iterator i;
+ _previousDirtyRects.clear();
+ for (i = _currentDirtyRects.begin(); i != _currentDirtyRects.end(); ++i)
+ _previousDirtyRects.push_back(*i);
+
+ _currentDirtyRects.clear();
+}
+
+/**
+ * Merges any clipping rectangles that overlap to try and reduce
+ * the total number of clip rectangles.
+ */
+void RMGfxTargetBuffer::mergeDirtyRects() {
+ if (_dirtyRects.size() <= 1)
+ return;
+
+ Common::List<Common::Rect>::iterator rOuter, rInner;
+
+ for (rOuter = _dirtyRects.begin(); rOuter != _dirtyRects.end(); ++rOuter) {
+ rInner = rOuter;
+ while (++rInner != _dirtyRects.end()) {
+
+ if ((*rOuter).intersects(*rInner)) {
+ // these two rectangles overlap or
+ // are next to each other - merge them
+
+ (*rOuter).extend(*rInner);
+
+ // remove the inner rect from the list
+ _dirtyRects.erase(rInner);
+
+ // move back to beginning of list
+ rInner = rOuter;
+ }
+ }
+ }
+}
+
+uint16 *RMGfxTargetBuffer::_precalcTable = NULL;
+
+/**
+ * Set up the black & white precalculated mapping table. This is only
+ * called if the user selects the black & white option.
+ */
+void RMGfxTargetBuffer::createBWPrecalcTable() {
+ _precalcTable = new uint16[0x8000];
+
+ for (int i = 0; i < 0x8000; i++) {
+ int r = (i >> 10) & 0x1F;
+ int g = (i >> 5) & 0x1F;
+ int b = i & 0x1F;
+
+ int min = MIN(r, MIN(g, b));
+ int max = MAX(r, MAX(g, b));
+
+ min = (min + max) / 2;
+
+ r = CLIP(min + 8 - 8, 0, 31);
+ g = CLIP(min + 5 - 8, 0, 31);
+ b = CLIP(min + 0 - 8, 0, 31);
+
+ _precalcTable[i] = (r << 10) | (g << 5) | b;
+ }
+}
+
+/**
+ * Frees the black & white precalculated mapping table.
+ */
+void RMGfxTargetBuffer::freeBWPrecalcTable() {
+ delete[] _precalcTable;
+ _precalcTable = NULL;
+}
+
+RMGfxTargetBuffer::operator byte *() {
+ return _buf;
+}
+
+RMGfxTargetBuffer::operator void *() {
+ return (void *)_buf;
+}
+
+RMGfxTargetBuffer::operator uint16 *() {
+ // FIXME: This may not be endian safe
+ return (uint16 *)_buf;
+}
+
+/**
+ * Offseting buffer
+ */
+void RMGfxTargetBuffer::offsetY(int nLines) {
+ RMGfxBuffer::offsetY(nLines, 16);
+}
+
+void RMGfxTargetBuffer::setTrackDirtyRects(bool v) {
+ _trackDirtyRects = v;
+}
+
+bool RMGfxTargetBuffer::getTrackDirtyRects() const {
+ return _trackDirtyRects;
+}
+
+/****************************************************************************\
+* RMGfxSourceBufferPal Methods
+\****************************************************************************/
+
+RMGfxSourceBufferPal::~RMGfxSourceBufferPal() {
+
+}
+
+int RMGfxSourceBufferPal::loadPaletteWA(const byte *buf, bool bSwapped) {
+ if (bSwapped) {
+ for (int i = 0; i < (1 << getBpp()); i++) {
+ _pal[i * 3 + 0] = buf[i * 3 + 2];
+ _pal[i * 3 + 1] = buf[i * 3 + 1];
+ _pal[i * 3 + 2] = buf[i * 3 + 0];
+ }
+ } else {
+ memcpy(_pal, buf, (1 << getBpp()) * 3);
+ }
+
+ preparePalette();
+
+ return (1 << getBpp()) * 3;
+}
+
+int RMGfxSourceBufferPal::loadPalette(const byte *buf) {
+ int i;
+
+ for (i = 0; i < 256; i++)
+ memcpy(_pal + i * 3, buf + i * 4, 3);
+
+ preparePalette();
+
+ return (1 << getBpp()) * 4;
+}
+
+void RMGfxSourceBufferPal::preparePalette() {
+ int i;
+
+ for (i = 0; i < 256; i++) {
+ _palFinal[i] = (((int)_pal[i * 3 + 0] >> 3) << 10) |
+ (((int)_pal[i * 3 + 1] >> 3) << 5) |
+ (((int)_pal[i * 3 + 2] >> 3) << 0);
+ }
+}
+
+int RMGfxSourceBufferPal::init(const byte *buf, int dimx, int dimy, bool bLoadPalette) {
+ int read;
+
+ // Load the RAW image
+ read = RMGfxSourceBuffer::init(buf, dimx, dimy);
+
+ // Load the palette if necessary
+ if (bLoadPalette)
+ read += loadPaletteWA(&buf[read]);
+
+ return read;
+}
+
+void RMGfxSourceBufferPal::init(Common::ReadStream &ds, int dimx, int dimy, bool bLoadPalette) {
+ // Load the RAW image
+ RMGfxSourceBuffer::init(ds, dimx, dimy);
+
+ // Load the palette if necessary
+ if (bLoadPalette) {
+ byte *suxpal = new byte[256 * 3];
+ ds.read(suxpal, 256 * 3);
+ loadPaletteWA(suxpal);
+ delete[] suxpal;
+ }
+}
+
+int RMGfxSourceBufferPal::loadPalette(uint32 resID) {
+ return loadPalette(RMRes(resID));
+}
+
+int RMGfxSourceBufferPal::loadPaletteWA(uint32 resID, bool bSwapped) {
+ return loadPaletteWA(RMRes(resID), bSwapped);
+}
+
+/****************************************************************************\
+* RMGfxSourceBuffer4 Methods
+\****************************************************************************/
+
+void RMGfxSourceBuffer4::draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim) {
+}
+
+RMGfxSourceBuffer4::RMGfxSourceBuffer4(int dimx, int dimy)
+ : RMGfxBuffer(dimx, dimy, 4) {
+ setPriority(0);
+}
+
+
+/**
+ * Returns the number of bits per pixel of the surface
+ *
+ * @returns Bit per pixel
+ */
+int RMGfxSourceBuffer4::getBpp() {
+ return 4;
+}
+
+void RMGfxSourceBuffer4::create(int dimx, int dimy) {
+ RMGfxBuffer::create(dimx, dimy, 4);
+}
+
+/****************************************************************************\
+* RMGfxSourceBuffer8 Methods
+\****************************************************************************/
+
+RMGfxSourceBuffer8::~RMGfxSourceBuffer8() {
+
+}
+
+void RMGfxSourceBuffer8::draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim) {
+ int x, y, width, height, u, v;
+ int bufx = bigBuf.getDimx();
+ uint16 *buf = bigBuf;
+ byte *raw = _buf;
+
+ // Destination buffer
+ RMRect dst;
+ if (prim->haveDst())
+ dst = prim->getDst();
+
+ // Clipping
+ if (prim->haveSrc()) {
+ u = prim->getSrc()._x1;
+ v = prim->getSrc()._y1;
+
+ width = prim->getSrc().width();
+ height = prim->getSrc().height();
+ }
+
+ if (!clip2D(dst._x1, dst._y1, u, v, width, height, prim->haveSrc(), &bigBuf))
+ return;
+
+ // Starting offset into the buffer
+ buf += dst._y1 * bufx + dst._x1;
+
+ // Normal step
+ if (_bTrasp0) {
+ for (y = 0; y < height; y++) {
+ raw = _buf + (y + v) * _dimx + u;
+
+ for (x = 0; x < width; x++) {
+ if (*raw)
+ *buf = _palFinal[*raw];
+ buf++;
+ raw++;
+ }
+
+ buf += bufx - width;
+ }
+ } else {
+ for (y = 0; y < height; y++) {
+ raw = _buf + (y + v) * _dimx + u;
+
+ for (x = 0; x < width; x += 2) {
+ buf[0] = _palFinal[raw[0]];
+ buf[1] = _palFinal[raw[1]];
+
+ buf += 2;
+ raw += 2;
+ }
+
+ buf += bufx - width;
+ }
+ }
+
+ // Specify the drawn area
+ bigBuf.addDirtyRect(Common::Rect(dst._x1, dst._y1, dst._x1 + width, dst._y1 + height));
+}
+
+RMGfxSourceBuffer8::RMGfxSourceBuffer8(int dimx, int dimy)
+ : RMGfxBuffer(dimx, dimy, 8) {
+ setPriority(0);
+ _bTrasp0 = false;
+}
+
+RMGfxSourceBuffer8::RMGfxSourceBuffer8(bool bTrasp0) {
+ _bTrasp0 = bTrasp0;
+}
+
+
+/**
+ * Returns the number of bits per pixel of the surface
+ *
+ * @returns Bit per pixel
+ */
+int RMGfxSourceBuffer8::getBpp() {
+ return 8;
+}
+
+void RMGfxSourceBuffer8::create(int dimx, int dimy) {
+ RMGfxBuffer::create(dimx, dimy, 8);
+}
+
+#define GETRED(x) (((x) >> 10) & 0x1F)
+#define GETGREEN(x) (((x) >> 5) & 0x1F)
+#define GETBLUE(x) ((x) & 0x1F)
+
+
+/****************************************************************************\
+* RMGfxSourceBuffer8AB Methods
+\****************************************************************************/
+
+RMGfxSourceBuffer8AB::~RMGfxSourceBuffer8AB() {
+
+}
+
+int RMGfxSourceBuffer8AB::calcTrasp(int fore, int back) {
+ int r, g, b;
+
+ r = (GETRED(fore) >> 2) + (GETRED(back) >> 1);
+ g = (GETGREEN(fore) >> 2) + (GETGREEN(back) >> 1);
+ b = (GETBLUE(fore) >> 2) + (GETBLUE(back) >> 1);
+
+ if (r > 0x1F)
+ r = 0x1F;
+
+ if (g > 0x1F)
+ g = 0x1F;
+
+ if (b > 0x1F)
+ b = 0x1F;
+
+ return (r << 10) | (g << 5) | b;
+}
+
+
+void RMGfxSourceBuffer8AB::draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim) {
+ int x, y, width, height, u, v;
+ int bufx = bigBuf.getDimx();
+ uint16 *buf = bigBuf;
+ byte *raw = _buf;
+
+ // Destination buffer
+ RMRect dst;
+ if (prim->haveDst())
+ dst = prim->getDst();
+
+ // Clipping
+ if (prim->haveSrc()) {
+ u = prim->getSrc()._x1;
+ v = prim->getSrc()._y1;
+
+ width = prim->getSrc().width();
+ height = prim->getSrc().height();
+ }
+
+ if (!clip2D(dst._x1, dst._y1, u, v, width, height, prim->haveSrc(), &bigBuf))
+ return;
+
+ // Starting offset into the buffer
+ buf += dst._y1 * bufx + dst._x1;
+
+ // Passaggio normale
+ if (_bTrasp0) {
+ for (y = 0; y < height; y++) {
+ raw = _buf + (y + v) * _dimx + u;
+
+ for (x = 0; x < width; x++) {
+ if (*raw)
+ *buf = calcTrasp(_palFinal[*raw], *buf);
+
+ buf++;
+ raw++;
+ }
+
+ buf += bufx - width;
+ }
+ } else {
+ for (y = 0; y < height; y++) {
+ raw = _buf + (y + v) * _dimx + u;
+
+ for (x = 0; x < width; x += 2) {
+ buf[0] = calcTrasp(_palFinal[raw[0]], buf[0]);
+ buf[1] = calcTrasp(_palFinal[raw[1]], buf[1]);
+
+ buf += 2;
+ raw += 2;
+ }
+
+ buf += bufx - width;
+ }
+ }
+
+ // Specify the drawn area
+ bigBuf.addDirtyRect(Common::Rect(dst._x1, dst._y1, dst._x1 + width, dst._y1 + height));
+}
+
+
+
+/****************************************************************************\
+* RMGfxSourceBuffer8RLE Methods
+\****************************************************************************/
+
+byte RMGfxSourceBuffer8RLE::_megaRLEBuf[512 * 1024];
+
+void RMGfxSourceBuffer8RLE::setAlphaBlendColor(int color) {
+ _alphaBlendColor = color;
+}
+
+RMGfxSourceBuffer8RLE::RMGfxSourceBuffer8RLE() {
+ _alphaBlendColor = -1;
+ _bNeedRLECompress = true;
+ _buf = NULL;
+
+ _alphaR = _alphaG = _alphaB = 0;
+}
+
+RMGfxSourceBuffer8RLE::~RMGfxSourceBuffer8RLE() {
+ if (_buf != NULL) {
+ delete[] _buf;
+ _buf = NULL;
+ }
+}
+
+
+int RMGfxSourceBuffer8RLE::init(const byte *buf, int dimx, int dimy, bool bLoadPalette) {
+ return RMGfxSourceBufferPal::init(buf, dimx, dimy, bLoadPalette);
+}
+
+void RMGfxSourceBuffer8RLE::init(Common::ReadStream &ds, int dimx, int dimy, bool bLoadPalette) {
+ if (_bNeedRLECompress) {
+ RMGfxSourceBufferPal::init(ds, dimx, dimy, bLoadPalette);
+ } else {
+ int size;
+
+ size = ds.readSint32LE();
+ _buf = new byte[size];
+ ds.read(_buf, size);
+
+ _dimx = dimx;
+ _dimy = dimy;
+ }
+}
+
+void RMGfxSourceBuffer8RLE::preparePalette() {
+ // Invoke the parent method
+ RMGfxSourceBuffer8::preparePalette();
+
+ // Handle RGB alpha blending
+ if (_alphaBlendColor != -1) {
+ _alphaR = (_palFinal[_alphaBlendColor] >> 10) & 0x1F;
+ _alphaG = (_palFinal[_alphaBlendColor] >> 5) & 0x1F;
+ _alphaB = (_palFinal[_alphaBlendColor]) & 0x1F;
+ }
+}
+
+void RMGfxSourceBuffer8RLE::prepareImage() {
+ // Invoke the parent method
+ RMGfxSourceBuffer::prepareImage();
+
+ // Compress
+ compressRLE();
+}
+
+void RMGfxSourceBuffer8RLE::setAlreadyCompressed() {
+ _bNeedRLECompress = false;
+}
+
+void RMGfxSourceBuffer8RLE::compressRLE() {
+ int x, y;
+ byte *startline;
+ byte *cur;
+ byte curdata;
+ byte *src;
+ byte *startsrc;
+ int rep;
+
+ // Perform RLE compression for lines
+ cur = _megaRLEBuf;
+ src = _buf;
+ for (y = 0; y < _dimy; y++) {
+ // Save the beginning of the line
+ startline = cur;
+
+ // Leave space for the length of the line
+ cur += 2;
+
+ // It starts from the empty space
+ curdata = 0;
+ rep = 0;
+ startsrc = src;
+ for (x = 0; x < _dimx;) {
+ if ((curdata == 0 && *src == 0) || (curdata == 1 && *src == _alphaBlendColor)
+ || (curdata == 2 && (*src != _alphaBlendColor && *src != 0))) {
+ src++;
+ rep++;
+ x++;
+ } else {
+ if (curdata == 0) {
+ RLEWriteTrasp(cur, rep);
+ curdata++;
+ } else if (curdata == 1) {
+ RLEWriteAlphaBlend(cur, rep);
+ curdata++;
+ } else {
+ RLEWriteData(cur, rep, startsrc);
+ curdata = 0;
+ }
+
+ rep = 0;
+ startsrc = src;
+ }
+ }
+
+ // Pending data?
+ if (curdata == 1) {
+ RLEWriteAlphaBlend(cur, rep);
+ RLEWriteData(cur, 0, NULL);
+ }
+
+ if (curdata == 2) {
+ RLEWriteData(cur, rep, startsrc);
+ }
+
+ // End of line
+ RLEWriteEOL(cur);
+
+ // Write the length of the line
+ WRITE_LE_UINT16(startline, (uint16)(cur - startline));
+ }
+
+ // Delete the original image
+ delete[] _buf;
+
+ // Copy the compressed image
+ x = cur - _megaRLEBuf;
+ _buf = new byte[x];
+ Common::copy(_megaRLEBuf, _megaRLEBuf + x, _buf);
+}
+
+void RMGfxSourceBuffer8RLE::draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim) {
+ int y;
+ byte *src;
+ uint16 *buf = bigBuf;
+ int x1, y1, u, v, width, height;
+
+ // Clipping
+ x1 = prim->getDst()._x1;
+ y1 = prim->getDst()._y1;
+ if (!clip2D(x1, y1, u, v, width, height, false, &bigBuf))
+ return;
+
+ // Go forward through the RLE lines
+ src = _buf;
+ for (y = 0; y < v; y++)
+ src += READ_LE_UINT16(src);
+
+ // Calculate the position in the destination buffer
+ buf += y1 * bigBuf.getDimx();
+
+ // Loop
+ if (prim->isFlipped()) {
+// Eliminate horizontal clipping
+// width = m_dimx;
+// x1=prim->Dst().x1;
+
+ // Clipping
+ u = _dimx - (width + u);
+ x1 = (prim->getDst()._x1 + _dimx - 1) - u;
+
+ if (width > x1)
+ width = x1;
+
+ // Specify the drawn area
+ bigBuf.addDirtyRect(Common::Rect(x1 - width, y1, x1 + 1, y1 + height));
+
+ for (y = 0; y < height; y++) {
+ // Decompression
+ RLEDecompressLineFlipped(buf + x1, src + 2, u, width);
+
+ // Next line
+ src += READ_LE_UINT16(src);
+
+ // Skip to the next line
+ buf += bigBuf.getDimx();
+ }
+ } else {
+ // Specify the drawn area
+ bigBuf.addDirtyRect(Common::Rect(x1, y1, x1 + width, y1 + height));
+
+ for (y = 0; y < height; y++) {
+ // Decompression
+ RLEDecompressLine(buf + x1, src + 2, u, width);
+
+ // Next line
+ src += READ_LE_UINT16(src);
+
+ // Skip to the next line
+ buf += bigBuf.getDimx();
+ }
+ }
+}
+
+
+/****************************************************************************\
+* RMGfxSourceBuffer8RLEByte Methods
+\****************************************************************************/
+
+RMGfxSourceBuffer8RLEByte::~RMGfxSourceBuffer8RLEByte() {
+
+}
+
+void RMGfxSourceBuffer8RLEByte::RLEWriteTrasp(byte *&cur, int rep) {
+ assert(rep < 255);
+ *cur ++ = rep;
+}
+
+void RMGfxSourceBuffer8RLEByte::RLEWriteAlphaBlend(byte *&cur, int rep) {
+ assert(rep < 255);
+ *cur ++ = rep;
+}
+
+void RMGfxSourceBuffer8RLEByte::RLEWriteData(byte *&cur, int rep, byte *src) {
+ assert(rep < 256);
+
+ *cur ++ = rep;
+ if (rep > 0) {
+ memcpy(cur, src, rep);
+ cur += rep;
+ src += rep;
+ }
+
+ return;
+}
+
+void RMGfxSourceBuffer8RLEByte::RLEWriteEOL(byte *&cur) {
+ *cur ++ = 0xFF;
+}
+
+void RMGfxSourceBuffer8RLEByte::RLEDecompressLine(uint16 *dst, byte *src, int nStartSkip, int nLength) {
+ int i, n;
+ int r, g, b;
+
+ if (nStartSkip == 0)
+ goto RLEByteDoTrasp;
+
+ while (1) {
+ assert(nStartSkip > 0);
+
+ // TRASP
+ n = *src++;
+ if (n == 0xFF)
+ return;
+
+ if (n >= nStartSkip) {
+ dst += n - nStartSkip;
+ nLength -= n - nStartSkip;
+ if (nLength > 0)
+ goto RLEByteDoAlpha;
+ else
+ return;
+ }
+ nStartSkip -= n;
+
+
+ assert(nStartSkip > 0);
+
+ // ALPHA
+ n = *src++;
+ if (n >= nStartSkip) {
+ n -= nStartSkip;
+ goto RLEByteDoAlpha2;
+ }
+ nStartSkip -= n;
+
+ assert(nStartSkip > 0);
+
+ // DATA
+ n = *src++;
+ if (n >= nStartSkip) {
+ src += nStartSkip;
+ n -= nStartSkip;
+ goto RLEByteDoCopy2;
+ }
+ nStartSkip -= n;
+ src += n;
+ }
+
+
+ while (1) {
+RLEByteDoTrasp:
+ // Get the trasp of s**t
+ n = *src++;
+
+ // EOL?
+ if (n == 0xFF)
+ return;
+
+ dst += n;
+ nLength -= n;
+ if (nLength <= 0)
+ return;
+
+RLEByteDoAlpha:
+ // Alpha
+ n = *src++;
+
+RLEByteDoAlpha2:
+ if (n > nLength)
+ n = nLength;
+ for (i = 0; i < n; i++) {
+ r = (*dst >> 10) & 0x1F;
+ g = (*dst >> 5) & 0x1F;
+ b = *dst & 0x1F;
+
+ r = (r >> 2) + (_alphaR >> 1);
+ g = (g >> 2) + (_alphaG >> 1);
+ b = (b >> 2) + (_alphaB >> 1);
+
+ *dst ++ = (r << 10) | (g << 5) | b;
+ }
+
+ nLength -= n;
+ if (!nLength)
+ return;
+ assert(nLength > 0);
+
+//RLEByteDoCopy:
+ // Copy the stuff
+ n = *src++;
+
+RLEByteDoCopy2:
+ if (n > nLength)
+ n = nLength;
+
+ for (i = 0; i < n; i++)
+ *dst ++ = _palFinal[*src++];
+
+ nLength -= n;
+ if (!nLength)
+ return;
+ assert(nLength > 0);
+ }
+}
+
+void RMGfxSourceBuffer8RLEByte::RLEDecompressLineFlipped(uint16 *dst, byte *src, int nStartSkip, int nLength) {
+ int i, n;
+ int r, g, b;
+
+ if (nStartSkip == 0)
+ goto RLEByteFlippedDoTrasp;
+
+ while (1) {
+ assert(nStartSkip > 0);
+
+ // TRASP
+ n = *src++;
+ if (n == 0xFF)
+ return;
+
+ if (n >= nStartSkip) {
+ dst -= n - nStartSkip;
+ nLength -= n - nStartSkip;
+ if (nLength > 0)
+ goto RLEByteFlippedDoAlpha;
+ else
+ return;
+ }
+ nStartSkip -= n;
+
+
+ assert(nStartSkip > 0);
+
+ // ALPHA
+ n = *src++;
+ if (n >= nStartSkip) {
+ n -= nStartSkip;
+ goto RLEByteFlippedDoAlpha2;
+ }
+ nStartSkip -= n;
+
+ assert(nStartSkip > 0);
+
+ // DATA
+ n = *src++;
+ if (n >= nStartSkip) {
+ src += nStartSkip;
+ n -= nStartSkip;
+ goto RLEByteFlippedDoCopy2;
+ }
+ nStartSkip -= n;
+ src += n;
+ }
+
+
+ while (1) {
+RLEByteFlippedDoTrasp:
+ // Get the trasp of s**t
+ n = *src++;
+
+ // EOL?
+ if (n == 0xFF)
+ return;
+
+ dst -= n;
+ nLength -= n;
+ if (nLength <= 0)
+ return;
+
+RLEByteFlippedDoAlpha:
+ // Alpha
+ n = *src++;
+
+RLEByteFlippedDoAlpha2:
+ if (n > nLength)
+ n = nLength;
+ for (i = 0; i < n; i++) {
+ r = (*dst >> 10) & 0x1F;
+ g = (*dst >> 5) & 0x1F;
+ b = *dst & 0x1F;
+
+ r = (r >> 2) + (_alphaR >> 1);
+ g = (g >> 2) + (_alphaG >> 1);
+ b = (b >> 2) + (_alphaB >> 1);
+
+ *dst-- = (r << 10) | (g << 5) | b;
+ }
+
+ nLength -= n;
+ if (!nLength)
+ return;
+ assert(nLength > 0);
+
+//RLEByteFlippedDoCopy:
+ // Copy the data
+ n = *src++;
+
+RLEByteFlippedDoCopy2:
+ if (n > nLength)
+ n = nLength;
+
+ for (i = 0; i < n; i++)
+ *dst-- = _palFinal[*src++];
+
+ nLength -= n;
+ if (!nLength)
+ return;
+ assert(nLength > 0);
+ }
+}
+
+
+/****************************************************************************\
+* RMGfxSourceBuffer8RLEWord Methods
+\****************************************************************************/
+
+RMGfxSourceBuffer8RLEWord::~RMGfxSourceBuffer8RLEWord() {
+
+}
+
+void RMGfxSourceBuffer8RLEWord::RLEWriteTrasp(byte *&cur, int rep) {
+ WRITE_LE_UINT16(cur, rep);
+ cur += 2;
+}
+
+void RMGfxSourceBuffer8RLEWord::RLEWriteAlphaBlend(byte *&cur, int rep) {
+ WRITE_LE_UINT16(cur, rep);
+ cur += 2;
+}
+
+void RMGfxSourceBuffer8RLEWord::RLEWriteData(byte *&cur, int rep, byte *src) {
+ WRITE_LE_UINT16(cur, rep);
+ cur += 2;
+
+ if (rep > 0) {
+ memcpy(cur, src, rep);
+ cur += rep;
+ src += rep;
+ }
+}
+
+void RMGfxSourceBuffer8RLEWord::RLEWriteEOL(byte *&cur) {
+ *cur ++ = 0xFF;
+ *cur ++ = 0xFF;
+}
+
+void RMGfxSourceBuffer8RLEWord::RLEDecompressLine(uint16 *dst, byte *src, int nStartSkip, int nLength) {
+ int i, n;
+ int r, g, b;
+
+ if (nStartSkip == 0)
+ goto RLEWordDoTrasp;
+
+ while (1) {
+ assert(nStartSkip > 0);
+
+ // TRASP
+ n = READ_LE_UINT16(src);
+ src += 2;
+
+ if (n == 0xFFFF)
+ return;
+
+ if (n >= nStartSkip) {
+ dst += n - nStartSkip;
+ nLength -= n - nStartSkip;
+
+ if (nLength > 0)
+ goto RLEWordDoAlpha;
+ else
+ return;
+ }
+ nStartSkip -= n;
+
+ assert(nStartSkip > 0);
+
+ // ALPHA
+ n = READ_LE_UINT16(src);
+ src += 2;
+
+ if (n >= nStartSkip) {
+ n -= nStartSkip;
+ goto RLEWordDoAlpha2;
+ }
+ nStartSkip -= n;
+
+ // DATA
+ n = READ_LE_UINT16(src);
+ src += 2;
+
+ if (n >= nStartSkip) {
+ src += nStartSkip;
+ n -= nStartSkip;
+ goto RLEWordDoCopy2;
+ }
+ nStartSkip -= n;
+ src += n;
+ }
+
+
+ while (1) {
+RLEWordDoTrasp:
+ // Get the trasp of s**t
+ n = READ_LE_UINT16(src);
+ src += 2;
+
+ // EOL?
+ if (n == 0xFFFF)
+ return;
+
+ dst += n;
+
+ nLength -= n;
+ if (nLength <= 0)
+ return;
+
+RLEWordDoAlpha:
+ n = READ_LE_UINT16(src);
+ src += 2;
+
+RLEWordDoAlpha2:
+
+ if (n > nLength)
+ n = nLength;
+
+ for (i = 0; i < n; i++) {
+ r = (*dst >> 10) & 0x1F;
+ g = (*dst >> 5) & 0x1F;
+ b = *dst & 0x1F;
+
+ r = (r >> 2) + (_alphaR >> 1);
+ g = (g >> 2) + (_alphaG >> 1);
+ b = (b >> 2) + (_alphaB >> 1);
+
+ *dst++ = (r << 10) | (g << 5) | b;
+ }
+
+ nLength -= n;
+ if (!nLength)
+ return;
+
+ assert(nLength > 0);
+
+//RLEWordDoCopy:
+ // Copy the data
+ n = READ_LE_UINT16(src);
+ src += 2;
+
+RLEWordDoCopy2:
+ if (n > nLength)
+ n = nLength;
+
+ for (i = 0; i < n; i++)
+ *dst++ = _palFinal[*src++];
+
+ nLength -= n;
+ if (!nLength)
+ return;
+
+ assert(nLength > 0);
+
+ }
+}
+
+void RMGfxSourceBuffer8RLEWord::RLEDecompressLineFlipped(uint16 *dst, byte *src, int nStartSkip, int nLength) {
+ int i, n;
+ int r, g, b;
+
+ if (nStartSkip == 0)
+ goto RLEWordFlippedDoTrasp;
+
+ while (1) {
+ assert(nStartSkip > 0);
+
+ // TRASP
+ n = READ_LE_UINT16(src);
+ src += 2;
+
+ if (n == 0xFFFF)
+ return;
+
+ if (n >= nStartSkip) {
+ dst -= n - nStartSkip;
+ nLength -= n - nStartSkip;
+
+ if (nLength > 0)
+ goto RLEWordFlippedDoAlpha;
+ else
+ return;
+ }
+ nStartSkip -= n;
+
+ assert(nStartSkip > 0);
+
+ // ALPHA
+ n = READ_LE_UINT16(src);
+ src += 2;
+
+ if (n >= nStartSkip) {
+ n -= nStartSkip;
+ goto RLEWordFlippedDoAlpha2;
+ }
+ nStartSkip -= n;
+
+ // DATA
+ n = READ_LE_UINT16(src);
+ src += 2;
+
+ if (n >= nStartSkip) {
+ src += nStartSkip;
+ n -= nStartSkip;
+ goto RLEWordFlippedDoCopy2;
+ }
+ nStartSkip -= n;
+ src += n;
+ }
+
+
+ while (1) {
+RLEWordFlippedDoTrasp:
+ // Get the trasp of s**t
+ n = READ_LE_UINT16(src);
+ src += 2;
+
+ // EOL?
+ if (n == 0xFFFF)
+ return;
+
+ dst -= n;
+
+ nLength -= n;
+ if (nLength <= 0)
+ return;
+
+RLEWordFlippedDoAlpha:
+ n = READ_LE_UINT16(src);
+ src += 2;
+
+RLEWordFlippedDoAlpha2:
+
+ if (n > nLength)
+ n = nLength;
+
+ for (i = 0; i < n; i++) {
+ r = (*dst >> 10) & 0x1F;
+ g = (*dst >> 5) & 0x1F;
+ b = *dst & 0x1F;
+
+ r = (r >> 2) + (_alphaR >> 1);
+ g = (g >> 2) + (_alphaG >> 1);
+ b = (b >> 2) + (_alphaB >> 1);
+
+ *dst-- = (r << 10) | (g << 5) | b;
+ }
+
+ nLength -= n;
+ if (!nLength)
+ return;
+
+ assert(nLength > 0);
+
+//RLEWordFlippedDoCopy:
+ // Copy the data
+ n = READ_LE_UINT16(src);
+ src += 2;
+
+RLEWordFlippedDoCopy2:
+ if (n > nLength)
+ n = nLength;
+
+ for (i = 0; i < n; i++)
+ *dst-- = _palFinal[*src++];
+
+ nLength -= n;
+ if (!nLength)
+ return;
+
+ assert(nLength > 0);
+ }
+}
+
+/****************************************************************************\
+* Methods for RMGfxSourceBuffer8RLEWord
+\****************************************************************************/
+
+RMGfxSourceBuffer8RLEWordAB::~RMGfxSourceBuffer8RLEWordAB() {
+
+}
+
+void RMGfxSourceBuffer8RLEWordAB::RLEDecompressLine(uint16 *dst, byte *src, int nStartSkip, int nLength) {
+ int i, n;
+ int r, g, b, r2, g2, b2;
+
+ if (!GLOBALS._bCfgTransparence) {
+ RMGfxSourceBuffer8RLEWord::RLEDecompressLine(dst, src, nStartSkip, nLength);
+ return;
+ }
+
+ if (nStartSkip == 0)
+ goto RLEWordDoTrasp;
+
+ while (1) {
+ assert(nStartSkip > 0);
+
+ // TRASP
+ n = READ_LE_UINT16(src);
+ src += 2;
+
+ if (n == 0xFFFF)
+ return;
+
+ if (n >= nStartSkip) {
+ dst += n - nStartSkip;
+ nLength -= n - nStartSkip;
+
+ if (nLength > 0)
+ goto RLEWordDoAlpha;
+ else
+ return;
+ }
+ nStartSkip -= n;
+
+ assert(nStartSkip > 0);
+
+ // ALPHA
+ n = READ_LE_UINT16(src);
+ src += 2;
+
+ if (n >= nStartSkip) {
+ n -= nStartSkip;
+ goto RLEWordDoAlpha2;
+ }
+ nStartSkip -= n;
+
+ // DATA
+ n = READ_LE_UINT16(src);
+ src += 2;
+
+ if (n >= nStartSkip) {
+ src += nStartSkip;
+ n -= nStartSkip;
+ goto RLEWordDoCopy2;
+ }
+ nStartSkip -= n;
+ src += n;
+ }
+
+
+ while (1) {
+RLEWordDoTrasp:
+ // Get the trasp of s**t
+ n = READ_LE_UINT16(src);
+ src += 2;
+
+ // EOL?
+ if (n == 0xFFFF)
+ return;
+
+ dst += n;
+
+ nLength -= n;
+ if (nLength <= 0)
+ return;
+
+RLEWordDoAlpha:
+ n = READ_LE_UINT16(src);
+ src += 2;
+
+RLEWordDoAlpha2:
+
+ if (n > nLength)
+ n = nLength;
+
+ // @@@ SHOULD NOT BE THERE !!!!!
+ for (i = 0; i < n; i++) {
+ r = (*dst >> 10) & 0x1F;
+ g = (*dst >> 5) & 0x1F;
+ b = *dst & 0x1F;
+
+ r = (r >> 2) + (_alphaR >> 1);
+ g = (g >> 2) + (_alphaG >> 1);
+ b = (b >> 2) + (_alphaB >> 1);
+
+ *dst++ = (r << 10) | (g << 5) | b;
+ }
+
+ nLength -= n;
+ if (!nLength)
+ return;
+
+ assert(nLength > 0);
+
+//RLEWordDoCopy:
+ // Copy the data
+ n = READ_LE_UINT16(src);
+ src += 2;
+
+RLEWordDoCopy2:
+ if (n > nLength)
+ n = nLength;
+
+ for (i = 0; i < n; i++) {
+ r = (*dst >> 10) & 0x1F;
+ g = (*dst >> 5) & 0x1F;
+ b = *dst & 0x1F;
+
+ r2 = (_palFinal[*src] >> 10) & 0x1F;
+ g2 = (_palFinal[*src] >> 5) & 0x1F;
+ b2 = _palFinal[*src] & 0x1F;
+
+ r = (r >> 1) + (r2 >> 1);
+ g = (g >> 1) + (g2 >> 1);
+ b = (b >> 1) + (b2 >> 1);
+
+ *dst ++ = (r << 10) | (g << 5) | b;
+ src++;
+ }
+
+ nLength -= n;
+ if (!nLength)
+ return;
+
+ assert(nLength > 0);
+ }
+}
+
+/****************************************************************************\
+* Methods for RMGfxSourceBuffer8AA
+\****************************************************************************/
+
+byte RMGfxSourceBuffer8AA::_megaAABuf[256 * 1024];
+byte RMGfxSourceBuffer8AA::_megaAABuf2[64 * 1024];
+
+void RMGfxSourceBuffer8AA::prepareImage() {
+ // Invoke the parent method
+ RMGfxSourceBuffer::prepareImage();
+
+ // Prepare the buffer for anti-aliasing
+ calculateAA();
+}
+
+void RMGfxSourceBuffer8AA::calculateAA() {
+ int x, y;
+ byte *src, *srcaa;
+
+ // First pass: fill the edges
+ Common::fill(_megaAABuf, _megaAABuf + _dimx * _dimy, 0);
+
+ src = _buf;
+ srcaa = _megaAABuf;
+ for (y = 0; y < _dimy; y++) {
+ for (x = 0; x < _dimx; x++) {
+ if (*src == 0) {
+ if ((y > 0 && src[-_dimx] != 0) ||
+ (y < _dimy - 1 && src[_dimx] != 0) ||
+ (x > 0 && src[-1] != 0) ||
+ (x < _dimx - 1 && src[1] != 0))
+ *srcaa = 1;
+ }
+
+ src++;
+ srcaa++;
+ }
+ }
+
+ src = _buf;
+ srcaa = _megaAABuf;
+ for (y = 0; y < _dimy; y++) {
+ for (x = 0; x < _dimx; x++) {
+ if (*src != 0) {
+ if ((y > 0 && srcaa[-_dimx] == 1) ||
+ (y < _dimy - 1 && srcaa[_dimx] == 1) ||
+ (x > 0 && srcaa[-1] == 1) ||
+ (x < _dimx - 1 && srcaa[1] == 1))
+ *srcaa = 2;
+ }
+
+ src++;
+ srcaa++;
+ }
+ }
+
+ if (_aabuf != NULL)
+ delete[] _aabuf;
+
+ _aabuf = new byte[_dimx * _dimy];
+ memcpy(_aabuf, _megaAABuf, _dimx * _dimy);
+}
+
+RMGfxSourceBuffer8AA::RMGfxSourceBuffer8AA() : RMGfxSourceBuffer8() {
+ _aabuf = NULL;
+}
+
+RMGfxSourceBuffer8AA::~RMGfxSourceBuffer8AA() {
+ if (_aabuf != NULL)
+ delete[] _aabuf;
+}
+
+void RMGfxSourceBuffer8AA::drawAA(RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim) {
+ int x, y;
+ byte *src;
+ uint16 *mybuf;
+ uint16 *buf;
+ int x1, y1, u, v, width, height;
+ int r, g, b;
+ int step;
+
+ // Clip the sprite
+ x1 = prim->getDst()._x1;
+ y1 = prim->getDst()._y1;
+ if (!clip2D(x1, y1, u, v, width, height, false, &bigBuf))
+ return;
+
+ // Go forward through the RLE lines
+ src = _buf;
+ for (y = 0; y < v; y++)
+ src += READ_LE_UINT16(src);
+
+ // Eliminate horizontal clipping
+
+ if (prim->isFlipped()) {
+ u = _dimx - (width + u);
+ x1 = (prim->getDst()._x1 + _dimx - 1) - u;
+
+ if (width > x1)
+ width = x1;
+
+ // Specify the drawn area
+ bigBuf.addDirtyRect(Common::Rect(x1 - width, y1, x1 + 1, y1 + height));
+ } else {
+ // Specify the drawn area
+ bigBuf.addDirtyRect(Common::Rect(x1, y1, x1 + width, y1 + height));
+ }
+
+// width = _dimx;
+// x1 = prim->Dst().x1;
+
+
+ // Position into the destination buffer
+ buf = bigBuf;
+ buf += y1 * bigBuf.getDimx();
+
+ if (prim->isFlipped())
+ step = -1;
+ else
+ step = 1;
+
+ // Loop
+ buf += bigBuf.getDimx(); // Skip the first line
+ for (y = 1; y < height - 1; y++) {
+ // if (prim->IsFlipped())
+ // mybuf=&buf[x1+m_dimx-1];
+ // else
+ mybuf = &buf[x1];
+
+ for (x = 0; x < width; x++, mybuf += step) {
+ if (_aabuf[(y + v) * _dimx + x + u] == 2 && x != 0 && x != width - 1) {
+ r = GETRED(mybuf[1]) + GETRED(mybuf[-1]) + GETRED(mybuf[-bigBuf.getDimx()]) + GETRED(mybuf[bigBuf.getDimx()]);
+ g = GETGREEN(mybuf[1]) + GETGREEN(mybuf[-1]) + GETGREEN(mybuf[-bigBuf.getDimx()]) + GETGREEN(mybuf[bigBuf.getDimx()]);
+ b = GETBLUE(mybuf[1]) + GETBLUE(mybuf[-1]) + GETBLUE(mybuf[-bigBuf.getDimx()]) + GETBLUE(mybuf[bigBuf.getDimx()]);
+
+ r += GETRED(mybuf[0]);
+ g += GETGREEN(mybuf[0]);
+ b += GETBLUE(mybuf[0]);
+
+ r /= 5;
+ g /= 5;
+ b /= 5;
+
+ if (r > 31) r = 31;
+ if (g > 31) g = 31;
+ if (b > 31) b = 31;
+
+ mybuf[0] = (r << 10) | (g << 5) | b;
+ }
+ }
+
+ // Skip to the next line
+ buf += bigBuf.getDimx();
+ }
+
+ // Position into the destination buffer
+ buf = bigBuf;
+ buf += y1 * bigBuf.getDimx();
+
+ // Looppone
+ buf += bigBuf.getDimx();
+ for (y = 1; y < height - 1; y++) {
+ // if (prim->IsFlipped())
+ // mybuf=&buf[x1+m_dimx-1];
+ // else
+ mybuf = &buf[x1];
+
+ for (x = 0; x < width; x++, mybuf += step) {
+ if (_aabuf[(y + v) * _dimx + x + u] == 1 && x != 0 && x != width - 1) {
+ r = GETRED(mybuf[1]) + GETRED(mybuf[-1]) + GETRED(mybuf[-bigBuf.getDimx()]) + GETRED(mybuf[bigBuf.getDimx()]);
+ g = GETGREEN(mybuf[1]) + GETGREEN(mybuf[-1]) + GETGREEN(mybuf[-bigBuf.getDimx()]) + GETGREEN(mybuf[bigBuf.getDimx()]);
+ b = GETBLUE(mybuf[1]) + GETBLUE(mybuf[-1]) + GETBLUE(mybuf[-bigBuf.getDimx()]) + GETBLUE(mybuf[bigBuf.getDimx()]);
+
+ r += GETRED(mybuf[0]) * 2;
+ g += GETGREEN(mybuf[0]) * 2;
+ b += GETBLUE(mybuf[0]) * 2;
+
+ r /= 6;
+ g /= 6;
+ b /= 6;
+
+ if (r > 31) r = 31;
+ if (g > 31) g = 31;
+ if (b > 31) b = 31;
+
+ mybuf[0] = (r << 10) | (g << 5) | b;
+ }
+ }
+
+ // Skip to the next line
+ buf += bigBuf.getDimx();
+ }
+}
+
+
+
+void RMGfxSourceBuffer8AA::draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim) {
+ CORO_BEGIN_CONTEXT;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ CORO_INVOKE_2(RMGfxSourceBuffer8::draw, bigBuf, prim);
+ drawAA(bigBuf, prim);
+
+ CORO_END_CODE;
+}
+
+/****************************************************************************\
+* RMGfxSourceBuffer8RLEAA Methods
+\****************************************************************************/
+
+RMGfxSourceBuffer8RLEByteAA::~RMGfxSourceBuffer8RLEByteAA() {
+}
+
+void RMGfxSourceBuffer8RLEByteAA::prepareImage() {
+ RMGfxSourceBuffer::prepareImage();
+ calculateAA();
+ compressRLE();
+}
+
+void RMGfxSourceBuffer8RLEByteAA::draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim) {
+ CORO_BEGIN_CONTEXT;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ CORO_INVOKE_2(RMGfxSourceBuffer8RLE::draw, bigBuf, prim);
+ if (GLOBALS._bCfgAntiAlias)
+ drawAA(bigBuf, prim);
+
+ CORO_END_CODE;
+}
+
+int RMGfxSourceBuffer8RLEByteAA::init(const byte *buf, int dimx, int dimy, bool bLoadPalette) {
+ return RMGfxSourceBuffer8RLE::init(buf, dimx, dimy, bLoadPalette);
+}
+
+void RMGfxSourceBuffer8RLEByteAA::init(Common::ReadStream &ds, int dimx, int dimy, bool bLoadPalette) {
+ RMGfxSourceBuffer8RLE::init(ds, dimx, dimy, bLoadPalette);
+
+ if (!_bNeedRLECompress) {
+ // Load the anti-aliasing mask
+ _aabuf = new byte[dimx * dimy];
+ ds.read(_aabuf, dimx * dimy);
+ }
+}
+
+RMGfxSourceBuffer8RLEWordAA::~RMGfxSourceBuffer8RLEWordAA() {
+}
+
+void RMGfxSourceBuffer8RLEWordAA::prepareImage() {
+ RMGfxSourceBuffer::prepareImage();
+ calculateAA();
+ compressRLE();
+}
+
+void RMGfxSourceBuffer8RLEWordAA::draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim) {
+ CORO_BEGIN_CONTEXT;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ CORO_INVOKE_2(RMGfxSourceBuffer8RLE::draw, bigBuf, prim);
+ if (GLOBALS._bCfgAntiAlias)
+ drawAA(bigBuf, prim);
+
+ CORO_END_CODE;
+}
+
+int RMGfxSourceBuffer8RLEWordAA::init(byte *buf, int dimx, int dimy, bool bLoadPalette) {
+ return RMGfxSourceBuffer8RLE::init(buf, dimx, dimy, bLoadPalette);
+}
+
+void RMGfxSourceBuffer8RLEWordAA::init(Common::ReadStream &ds, int dimx, int dimy, bool bLoadPalette) {
+ RMGfxSourceBuffer8RLE::init(ds, dimx, dimy, bLoadPalette);
+
+ if (!_bNeedRLECompress) {
+ // Load the anti-aliasing mask
+ _aabuf = new byte[dimx * dimy];
+ ds.read(_aabuf, dimx * dimy);
+ }
+}
+
+
+/****************************************************************************\
+* RMGfxSourceBuffer16 Methods
+\****************************************************************************/
+
+RMGfxSourceBuffer16::RMGfxSourceBuffer16(bool bTrasp0) {
+ _bTrasp0 = bTrasp0;
+}
+
+RMGfxSourceBuffer16::~RMGfxSourceBuffer16() {
+}
+
+void RMGfxSourceBuffer16::draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim) {
+ uint16 *buf = bigBuf;
+ uint16 *raw = (uint16 *)_buf;
+ int dimx, dimy;
+ int u, v;
+ int x1, y1;
+
+ dimx = _dimx;
+ dimy = _dimy;
+ u = 0;
+ v = 0;
+ x1 = 0;
+ y1 = 0;
+
+ if (prim->haveSrc()) {
+ u = prim->getSrc()._x1;
+ v = prim->getSrc()._y1;
+ dimx = prim->getSrc().width();
+ dimy = prim->getSrc().height();
+ }
+
+ if (prim->haveDst()) {
+ x1 = prim->getDst()._x1;
+ y1 = prim->getDst()._y1;
+ }
+
+ if (!clip2D(x1, y1, u, v, dimx, dimy, true, &bigBuf))
+ return;
+
+ raw += v * _dimx + u;
+ buf += y1 * bigBuf.getDimx() + x1;
+
+ if (_bTrasp0) {
+ for (int y = 0; y < dimy; y++) {
+ for (int x = 0; x < dimx;) {
+ while (x < dimx && raw[x] == 0)
+ x++;
+
+ while (x < dimx && raw[x] != 0) {
+ buf[x] = raw[x];
+ x++;
+ }
+ }
+
+ raw += _dimx;
+ buf += bigBuf.getDimx();
+ }
+ } else {
+ for (int y = 0; y < dimy; y++) {
+ Common::copy(raw, raw + dimx, buf);
+ buf += bigBuf.getDimx();
+ raw += _dimx;
+ }
+ }
+
+ // Specify the drawn area
+ bigBuf.addDirtyRect(Common::Rect(x1, y1, x1 + dimx, y1 + dimy));
+}
+
+void RMGfxSourceBuffer16::prepareImage() {
+ // Color space conversion if necessary!
+ int i;
+ uint16 *buf = (uint16 *)_buf;
+
+ for (i = 0; i < _dimx * _dimy; i++)
+ WRITE_LE_UINT16(&buf[i], FROM_LE_16(buf[i]) & 0x7FFF);
+}
+
+RMGfxSourceBuffer16::RMGfxSourceBuffer16(int dimx, int dimy)
+ : RMGfxBuffer(dimx, dimy, 16) {
+ setPriority(0);
+ _bTrasp0 = false;
+}
+
+/**
+ * Returns the number of bits per pixel of the surface
+ *
+ * @returns Bit per pixel
+ */
+int RMGfxSourceBuffer16::getBpp() {
+ return 16;
+}
+
+void RMGfxSourceBuffer16::create(int dimx, int dimy) {
+ RMGfxBuffer::create(dimx, dimy, 16);
+}
+
+/****************************************************************************\
+* RMGfxBox Methods
+\****************************************************************************/
+
+void RMGfxBox::removeThis(CORO_PARAM, bool &result) {
+ result = true;
+}
+
+void RMGfxBox::setColor(byte r, byte g, byte b) {
+ r >>= 3;
+ g >>= 3;
+ b >>= 3;
+ _wFillColor = (r << 10) | (g << 5) | b;
+}
+
+void RMGfxBox::draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim) {
+ int i, j;
+ uint16 *buf = bigBuf;
+ RMRect rcDst;
+
+ // It takes the destination rectangle
+ rcDst = prim->getDst();
+ buf += rcDst._y1 * bigBuf.getDimx() + rcDst._x1;
+
+ // Loop through the pixels
+ for (j = 0; j < rcDst.height(); j++) {
+ for (i = 0; i < rcDst.width(); i++)
+ *buf++ = _wFillColor;
+
+ buf += bigBuf.getDimx() - rcDst.width();
+ }
+
+ // Specify the drawn area
+ bigBuf.addDirtyRect(rcDst);
+}
+
+
+/****************************************************************************\
+* RMGfxClearTask Methods
+\****************************************************************************/
+
+int RMGfxClearTask::priority() {
+ // Maximum priority (must be done first)
+ return 1;
+}
+
+void RMGfxClearTask::draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *) {
+ // Clean the target buffer
+ Common::fill((byte *)bigBuf, (byte *)bigBuf + (bigBuf.getDimx() * bigBuf.getDimy() * 2), 0x0);
+ bigBuf.addDirtyRect(Common::Rect(bigBuf.getDimx(), bigBuf.getDimy()));
+}
+
+void RMGfxClearTask::removeThis(CORO_PARAM, bool &result) {
+ // The task is fine to be removed
+ result = true;
+}
+
+/****************************************************************************\
+* RMGfxPrimitive Methods
+\****************************************************************************/
+
+RMGfxPrimitive::RMGfxPrimitive() {
+ _bFlag = 0;
+ _task = NULL;
+ _src.setEmpty();
+ _dst.setEmpty();
+ _bStretch = false;
+}
+
+RMGfxPrimitive::RMGfxPrimitive(RMGfxTask *task) {
+ _task = task;
+ _bFlag = 0;
+ _bStretch = false;
+}
+
+RMGfxPrimitive::RMGfxPrimitive(RMGfxTask *task, const RMRect &src, RMRect &dst) {
+ _task = task;
+ _src = src;
+ _dst = dst;
+ _bFlag = 0;
+ _bStretch = (src.width() != dst.width() || src.height() != dst.height());
+}
+
+RMGfxPrimitive::RMGfxPrimitive(RMGfxTask *task, const RMPoint &src, RMRect &dst) {
+ _task = task;
+ _src.topLeft() = src;
+ _dst = dst;
+ _bFlag = 0;
+ _bStretch = false;
+}
+
+RMGfxPrimitive::RMGfxPrimitive(RMGfxTask *task, const RMPoint &src, RMPoint &dst) {
+ _task = task;
+ _src.topLeft() = src;
+ _dst.topLeft() = dst;
+ _bFlag = 0;
+ _bStretch = false;
+}
+
+RMGfxPrimitive::RMGfxPrimitive(RMGfxTask *task, const RMRect &src, RMPoint &dst) {
+ _task = task;
+ _src = src;
+ _dst.topLeft() = dst;
+ _bFlag = 0;
+ _bStretch = false;
+}
+
+RMGfxPrimitive::RMGfxPrimitive(RMGfxTask *task, const RMRect &dst) {
+ _task = task;
+ _dst = dst;
+ _src.setEmpty();
+ _bFlag = 0;
+ _bStretch = false;
+}
+
+RMGfxPrimitive::RMGfxPrimitive(RMGfxTask *task, const RMPoint &dst) {
+ _task = task;
+ _dst.topLeft() = dst;
+ _src.setEmpty();
+ _bFlag = 0;
+ _bStretch = false;
+}
+
+RMGfxPrimitive::~RMGfxPrimitive() {
+}
+
+void RMGfxPrimitive::setFlag(byte bFlag) {
+ _bFlag = bFlag;
+}
+
+void RMGfxPrimitive::setTask(RMGfxTask *task) {
+ _task = task;
+}
+
+void RMGfxPrimitive::setSrc(const RMRect &src) {
+ _src = src;
+}
+
+void RMGfxPrimitive::setSrc(const RMPoint &src) {
+ _src.topLeft() = src;
+}
+
+void RMGfxPrimitive::setDst(const RMRect &dst) {
+ _dst = dst;
+}
+
+void RMGfxPrimitive::setDst(const RMPoint &dst) {
+ _dst.topLeft() = dst;
+}
+
+void RMGfxPrimitive::setStretch(bool bStretch) {
+ _bStretch = bStretch;
+}
+
+bool RMGfxPrimitive::haveDst() {
+ return !_dst.isEmpty();
+}
+
+RMRect &RMGfxPrimitive::getDst() {
+ return _dst;
+}
+
+bool RMGfxPrimitive::haveSrc() {
+ return !_src.isEmpty();
+}
+
+RMRect &RMGfxPrimitive::getSrc() {
+ return _src;
+}
+
+/**
+ * Flags
+ */
+bool RMGfxPrimitive::isFlipped() {
+ return _bFlag & 1;
+}
+
+/**
+ * Duplicate
+ */
+RMGfxPrimitive *RMGfxPrimitive::duplicate() {
+ return new RMGfxPrimitive(*this);
+}
+
+} // End of namespace Tony
diff --git a/engines/tony/gfxcore.h b/engines/tony/gfxcore.h
new file mode 100644
index 0000000000..ac4eee05e4
--- /dev/null
+++ b/engines/tony/gfxcore.h
@@ -0,0 +1,516 @@
+/* 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.
+ *
+ */
+
+/*
+ * This code is based on original Tony Tough source code
+ *
+ * Copyright (c) 1997-2003 Nayma Software
+ */
+
+#ifndef TONY_GFXCORE_H
+#define TONY_GFXCORE_H
+
+#include "common/system.h"
+#include "common/coroutines.h"
+#include "tony/utils.h"
+
+namespace Tony {
+
+/****************************************************************************\
+* Class prototype
+\****************************************************************************/
+
+// Class Name Family Treee Abstract?
+class RMGfxTask; // Yes
+class RMGfxTaskSetPrior; // Task Yes
+class RMGfxBuffer; //
+class RMGfxSourceBuffer; // TaskP+[Buffer] Yes
+class RMGfxTargetBuffer; // [Buffer]
+class RMGfxSourceBufferPal; // Source Yes
+class RMGfxSourceBuffer4; // SourcePal
+class RMGfxSourceBuffer8; // SourcePal
+class RMGfxSourceBuffer16; // Source
+class RMGfxWoodyBuffer; // Source16+Target
+class RMGfxClearTask; // Task
+
+
+/**
+ * Graphics buffer
+ */
+class RMGfxBuffer {
+protected:
+ int _dimx, _dimy;
+ byte *_buf;
+ byte *_origBuf;
+
+public:
+ RMGfxBuffer();
+ RMGfxBuffer(int dimx, int dimy, int nBpp);
+ virtual ~RMGfxBuffer();
+
+ // Attributes
+ int getDimx();
+ int getDimy();
+
+ // Creation
+ virtual void create(int dimx, int dimy, int nBpp);
+ virtual void destroy();
+
+ // These are valid only if the buffer is locked
+ operator byte *();
+ operator void *();
+
+ // Getting the offset for a given Y position
+ void offsetY(int nLines, int nBpp);
+};
+
+/**
+ * Graphics primitive
+ */
+class RMGfxPrimitive {
+public:
+ RMGfxTask *_task;
+
+protected:
+ RMRect _src;
+ RMRect _dst;
+
+ bool _bStretch;
+ byte _bFlag;
+
+public:
+ RMGfxPrimitive();
+ RMGfxPrimitive(RMGfxTask *task);
+ RMGfxPrimitive(RMGfxTask *task, const RMRect &src, RMRect &dst);
+ RMGfxPrimitive(RMGfxTask *task, const RMPoint &src, RMRect &dst);
+ RMGfxPrimitive(RMGfxTask *task, const RMPoint &src, RMPoint &dst);
+ RMGfxPrimitive(RMGfxTask *task, const RMRect &src, RMPoint &dst);
+ RMGfxPrimitive(RMGfxTask *task, const RMRect &dst);
+ RMGfxPrimitive(RMGfxTask *task, const RMPoint &dst);
+ virtual ~RMGfxPrimitive();
+ void setFlag(byte bFlag);
+ void setTask(RMGfxTask *task);
+ void setSrc(const RMRect &src);
+ void setSrc(const RMPoint &src);
+ void setDst(const RMRect &dst);
+ void setDst(const RMPoint &dst);
+ void setStretch(bool bStretch);
+ bool haveDst();
+ RMRect &getDst();
+ bool haveSrc();
+ RMRect &getSrc();
+
+ // Flags
+ bool isFlipped();
+
+ // Duplicate
+ virtual RMGfxPrimitive *duplicate();
+};
+
+
+/**
+ * Graphic drawing task
+ */
+class RMGfxTask {
+protected:
+ int _nPrior;
+ int _nInList;
+
+public:
+ // Standard constructor
+ RMGfxTask();
+ virtual ~RMGfxTask() { }
+
+ virtual int priority();
+ virtual void draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim) = 0;
+ virtual void removeThis(CORO_PARAM, bool &result);
+
+ // Registration
+ virtual void Register();
+ virtual void Unregister();
+};
+
+
+/**
+ * Graphic drawing with priority
+ */
+class RMGfxTaskSetPrior : public RMGfxTask {
+public:
+ virtual ~RMGfxTaskSetPrior() { }
+ void setPriority(int nPrior);
+};
+
+
+/**
+ * Task that cleans the destination buffer
+ */
+class RMGfxClearTask : public RMGfxTask {
+public:
+ virtual ~RMGfxClearTask() { }
+
+ int priority();
+ virtual void draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim);
+ virtual void removeThis(CORO_PARAM, bool &result);
+};
+
+
+/**
+ * Task that draws a colored box
+ */
+class RMGfxBox : public RMGfxTaskSetPrior {
+protected:
+ uint16 _wFillColor;
+
+public:
+ virtual ~RMGfxBox() { }
+
+ void setColor(byte r, byte g, byte b);
+ virtual void draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim);
+ virtual void removeThis(CORO_PARAM, bool &result);
+};
+
+
+/**
+ * Buffer source for the design, which is a task. This is an abstract base.
+ */
+class RMGfxSourceBuffer : public virtual RMGfxBuffer, public RMGfxTaskSetPrior {
+public:
+ // Load the data for the surface
+ virtual int init(uint32 resID, int dimx, int dimy, bool bLoadPalette = false);
+ virtual int init(const byte *buf, int dimx, int dimy, bool bLoadPalette = false);
+ virtual void init(Common::ReadStream &ds, int dimx, int dimy, bool bLoadPalette = false);
+
+ virtual ~RMGfxSourceBuffer();
+
+protected:
+ virtual void prepareImage();
+ bool clip2D(int &x1, int &y1, int &u, int &v, int &width, int &height, bool bUseSrc, RMGfxTargetBuffer *buf);
+ void offsetY(int nLines);
+
+public:
+ virtual int getBpp() = 0;
+};
+
+
+/**
+ * 16-bit color source
+ */
+class RMGfxSourceBuffer16 : public RMGfxSourceBuffer {
+protected:
+ virtual void prepareImage();
+ bool _bTrasp0;
+
+public:
+ RMGfxSourceBuffer16(bool bUseTrasp = false);
+ RMGfxSourceBuffer16(int dimx, int dimy);
+ virtual ~RMGfxSourceBuffer16();
+
+ // Initialization
+ void create(int dimx, int dimy);
+
+ int getBpp();
+ virtual void draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim);
+};
+
+
+/**
+ * Buffer source with palette
+ */
+class RMGfxSourceBufferPal : public RMGfxSourceBuffer {
+protected:
+ // The size of the palette is (1 << Bpp()) * 4
+ byte _pal[256 * 3];
+ uint16 _palFinal[256];
+
+ // Post process to prepare the palette for drawing
+ virtual void preparePalette();
+
+public:
+ virtual ~RMGfxSourceBufferPal();
+
+ virtual int init(const byte *buf, int dimx, int dimy, bool bLoadPalette = false);
+ virtual void init(Common::ReadStream &ds, int dimx, int dimy, bool bLoadPalette = false);
+
+ int loadPaletteWA(uint32 resID, bool bSwapped = false);
+ int loadPaletteWA(const byte *buf, bool bSwapped = false);
+ int loadPalette(uint32 resID);
+ int loadPalette(const byte *buf);
+};
+
+
+/**
+ * Buffer source with a 256 color palette
+ */
+class RMGfxSourceBuffer8 : public RMGfxSourceBufferPal {
+protected:
+ bool _bTrasp0;
+
+public:
+ RMGfxSourceBuffer8(bool bTrasp0 = true);
+ RMGfxSourceBuffer8(int dimx, int dimy);
+ virtual ~RMGfxSourceBuffer8();
+
+ // Initialization
+ void create(int dimx, int dimy);
+
+ int getBpp();
+ virtual void draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim);
+};
+
+
+/**
+ * Buffer source with a 256 color palette, and alpha blending
+ */
+class RMGfxSourceBuffer8AB : public RMGfxSourceBuffer8 {
+protected:
+ int calcTrasp(int f, int b);
+
+public:
+ virtual ~RMGfxSourceBuffer8AB();
+ virtual void draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim);
+};
+
+
+/**
+ * Buffer source with a 256 color palette, RLE compressed
+ */
+
+class RMGfxSourceBuffer8RLE : public virtual RMGfxSourceBuffer8 {
+protected:
+ int _alphaBlendColor;
+ int _alphaR, _alphaB, _alphaG;
+ bool _bNeedRLECompress;
+
+protected:
+ static byte _megaRLEBuf[];
+
+ virtual void RLEWriteTrasp(byte *&cur, int rep) = 0;
+ virtual void RLEWriteData(byte *&cur, int rep, byte *src) = 0;
+ virtual void RLEWriteEOL(byte *&cur) = 0;
+ virtual void RLEWriteAlphaBlend(byte *&cur, int rep) = 0;
+ virtual void RLEDecompressLine(uint16 *dst, byte *src, int nStartSkip, int nLength) = 0;
+ virtual void RLEDecompressLineFlipped(uint16 *dst, byte *src, int nStartSkip, int nLength) = 0;
+
+ // Perform image compression in RLE
+ void compressRLE();
+
+protected:
+ // Overriding initialization methods
+ virtual void prepareImage();
+ virtual void preparePalette();
+
+public:
+ RMGfxSourceBuffer8RLE();
+ virtual ~RMGfxSourceBuffer8RLE();
+
+ // Overload of the initialization method
+ virtual void init(Common::ReadStream &ds, int dimx, int dimy, bool bLoadPalette = false);
+ virtual int init(const byte *buf, int dimx, int dimy, bool bLoadPalette = false);
+
+ // Draw image with RLE decompression
+ virtual void draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim);
+
+ // Sets the color that will be alpha blended
+ void setAlphaBlendColor(int color);
+
+ // Warn if the data is already compressed
+ void setAlreadyCompressed();
+};
+
+class RMGfxSourceBuffer8RLEByte : public RMGfxSourceBuffer8RLE {
+protected:
+ void RLEWriteTrasp(byte * &cur, int rep);
+ void RLEWriteAlphaBlend(byte * &cur, int rep);
+ void RLEWriteData(byte * &cur, int rep, byte *src);
+ void RLEWriteEOL(byte * &cur);
+ void RLEDecompressLine(uint16 *dst, byte *src, int nStartSkip, int nLength);
+ void RLEDecompressLineFlipped(uint16 *dst, byte *src, int nStartSkip, int nLength);
+
+public:
+ virtual ~RMGfxSourceBuffer8RLEByte();
+};
+
+class RMGfxSourceBuffer8RLEWord : public RMGfxSourceBuffer8RLE {
+protected:
+ void RLEWriteTrasp(byte * &cur, int rep);
+ void RLEWriteAlphaBlend(byte * &cur, int rep);
+ void RLEWriteData(byte * &cur, int rep, byte *src);
+ void RLEWriteEOL(byte * &cur);
+ virtual void RLEDecompressLine(uint16 *dst, byte *src, int nStartSkip, int nLength);
+ virtual void RLEDecompressLineFlipped(uint16 *dst, byte *src, int nStartSkip, int nLength);
+
+public:
+ virtual ~RMGfxSourceBuffer8RLEWord();
+};
+
+class RMGfxSourceBuffer8RLEWordAB : public RMGfxSourceBuffer8RLEWord {
+protected:
+ virtual void RLEDecompressLine(uint16 *dst, byte *src, int nStartSkip, int nLength);
+
+public:
+ virtual ~RMGfxSourceBuffer8RLEWordAB();
+};
+
+
+/**
+ * Buffer source with a 256 color palette, with anti-aliasing
+ */
+class RMGfxSourceBuffer8AA : public virtual RMGfxSourceBuffer8 {
+protected:
+ static byte _megaAABuf[];
+ static byte _megaAABuf2[];
+ byte *_aabuf;
+
+ // Calculate the buffer for the anti-aliasing
+ void calculateAA();
+
+ // Draw the AA
+ void drawAA(RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim);
+
+protected:
+ void prepareImage();
+
+public:
+ RMGfxSourceBuffer8AA();
+ virtual ~RMGfxSourceBuffer8AA();
+
+ // Draw with anti-aliasing
+ virtual void draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim);
+};
+
+
+class RMGfxSourceBuffer8RLEByteAA : public RMGfxSourceBuffer8RLEByte, public RMGfxSourceBuffer8AA {
+protected:
+ void prepareImage();
+
+public:
+ virtual void draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim);
+
+ // Overloaded initialization methods
+ virtual void init(Common::ReadStream &ds, int dimx, int dimy, bool bLoadPalette = false);
+ virtual int init(const byte *buf, int dimx, int dimy, bool bLoadPalette = false);
+
+ virtual ~RMGfxSourceBuffer8RLEByteAA();
+};
+
+class RMGfxSourceBuffer8RLEWordAA : public RMGfxSourceBuffer8RLEWord, public RMGfxSourceBuffer8AA {
+protected:
+ void prepareImage();
+
+public:
+ virtual void draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim);
+
+ // Overloaded initialization methods
+ virtual void init(Common::ReadStream &ds, int dimx, int dimy, bool bLoadPalette = false);
+ virtual int init(byte *buf, int dimx, int dimy, bool bLoadPalette = false);
+
+ virtual ~RMGfxSourceBuffer8RLEWordAA();
+};
+
+
+/**
+ * Source buffer with 16 colors
+ */
+class RMGfxSourceBuffer4 : public RMGfxSourceBufferPal {
+public:
+ RMGfxSourceBuffer4();
+ RMGfxSourceBuffer4(int dimx, int dimy);
+
+ // Initialization
+ void create(int dimx, int dimy);
+
+ int getBpp();
+ virtual void draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim);
+};
+
+
+/**
+ * Destination buffer which manages its own internal list of tasks
+ */
+class RMGfxTargetBuffer : public virtual RMGfxBuffer {
+private:
+ struct OTList {
+ RMGfxPrimitive *_prim;
+ OTList *_next;
+
+ OTList();
+ OTList(RMGfxPrimitive *pr) {
+ _prim = pr;
+ }
+ };
+
+ bool _trackDirtyRects;
+ Common::List<Common::Rect> _currentDirtyRects, _previousDirtyRects, _dirtyRects;
+
+ void mergeDirtyRects();
+
+private:
+// OSystem::MutexRef csModifyingOT;
+
+protected:
+ OTList *_otlist;
+ int _otSize;
+
+public:
+ RMGfxTargetBuffer();
+ virtual ~RMGfxTargetBuffer();
+
+ static uint16 *_precalcTable;
+ static void createBWPrecalcTable();
+ static void freeBWPrecalcTable();
+
+ // management of the OT list
+ void clearOT();
+ void drawOT(CORO_PARAM);
+ void addPrim(RMGfxPrimitive *prim); // The pointer must be delted
+
+ operator byte *();
+ operator void *();
+ operator uint16 *();
+
+ // Offseting buffer
+ void offsetY(int nLines);
+
+ // Dirty rect methods
+ void addDirtyRect(const Common::Rect &r);
+ Common::List<Common::Rect> &getDirtyRects();
+ void clearDirtyRects();
+ void setTrackDirtyRects(bool v);
+ bool getTrackDirtyRects() const;
+};
+
+
+/**
+ * Ring buffer, which is both source and by destination
+ */
+class RMGfxWoodyBuffer: public RMGfxSourceBuffer16, public RMGfxTargetBuffer {
+public:
+ RMGfxWoodyBuffer();
+ RMGfxWoodyBuffer(int dimx, int dimy);
+ virtual ~RMGfxWoodyBuffer();
+
+ virtual void draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim);
+};
+
+} // End of namespace Tony
+
+#endif
diff --git a/engines/tony/gfxengine.cpp b/engines/tony/gfxengine.cpp
new file mode 100644
index 0000000000..5c038e154d
--- /dev/null
+++ b/engines/tony/gfxengine.cpp
@@ -0,0 +1,862 @@
+/* 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.
+ *
+ */
+
+/*
+ * This code is based on original Tony Tough source code
+ *
+ * Copyright (c) 1997-2003 Nayma Software
+ */
+
+#include "common/savefile.h"
+#include "tony/mpal/lzo.h"
+#include "tony/mpal/mpalutils.h"
+#include "tony/custom.h"
+#include "tony/gfxengine.h"
+#include "tony/tony.h"
+
+namespace Tony {
+
+
+/****************************************************************************\
+* RMGfxEngine Methods
+\****************************************************************************/
+
+void ExitAllIdles(CORO_PARAM, const void *param) {
+ CORO_BEGIN_CONTEXT;
+ CORO_END_CONTEXT(_ctx);
+
+ int nCurLoc = *(const int *)param;
+
+ CORO_BEGIN_CODE(_ctx);
+
+ // Closes idle
+ GLOBALS._bSkipSfxNoLoop = true;
+
+ CORO_INVOKE_2(mpalEndIdlePoll, nCurLoc, NULL);
+
+ GLOBALS._bIdleExited = true;
+ GLOBALS._bSkipSfxNoLoop = false;
+
+ CORO_END_CODE;
+}
+
+RMGfxEngine::RMGfxEngine() {
+ // Create big buffer where the frame will be rendered
+ _bigBuf.create(RM_BBX, RM_BBY, 16);
+ _bigBuf.offsetY(RM_SKIPY);
+ _bigBuf.setTrackDirtyRects(true);
+
+ _nCurLoc = 0;
+ _curAction = TA_GOTO;
+ _curActionObj = 0;
+ _nWipeType = 0;
+ _hWipeEvent = 0;
+ _nWipeStep = 0;
+ _bMustEnterMenu = false;
+ _bWiping = false;
+ _bGUIOption = false;
+ _bGUIInterface = false;
+ _bGUIInventory = false;
+ _bAlwaysDrawMouse = false;
+ _bOption = false;
+ _bLocationLoaded = false;
+ _bInput = false;
+}
+
+RMGfxEngine::~RMGfxEngine() {
+ // Close the buffer
+ _bigBuf.destroy();
+}
+
+void RMGfxEngine::openOptionScreen(CORO_PARAM, int type) {
+ CORO_BEGIN_CONTEXT;
+ bool bRes;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ _ctx->bRes = false;
+
+ if (type == 0)
+ CORO_INVOKE_2(_opt.init, _bigBuf, _ctx->bRes);
+ else if (type == 1)
+ CORO_INVOKE_3(_opt.initLoadMenuOnly, _bigBuf, true, _ctx->bRes);
+ else if (type == 2)
+ CORO_INVOKE_2(_opt.initNoLoadSave, _bigBuf, _ctx->bRes);
+ else if (type == 3)
+ CORO_INVOKE_3(_opt.initLoadMenuOnly, _bigBuf, false, _ctx->bRes);
+ else if (type == 4)
+ CORO_INVOKE_3(_opt.initSaveMenuOnly, _bigBuf, false, _ctx->bRes);
+
+ if (_ctx->bRes) {
+ g_vm->pauseSound(true);
+
+ disableInput();
+ _inv.endCombine();
+ _curActionObj = 0;
+ _curAction = TA_GOTO;
+ _point.setAction(_curAction);
+ _point.setSpecialPointer(RMPointer::PTR_NONE);
+ _point.setCustomPointer(NULL);
+ enableMouse();
+ g_vm->grabThumbnail();
+
+ // Exists the IDLE to avoid premature death in loading
+ _bMustEnterMenu = true;
+ if (type == 1 || type == 2) {
+ GLOBALS._bIdleExited = true;
+ } else {
+ CORO_INVOKE_0(_tony.stopNoAction);
+
+ GLOBALS._bIdleExited = false;
+
+ CoroScheduler.createProcess(ExitAllIdles, &_nCurLoc, sizeof(int));
+ }
+ }
+
+ CORO_END_CODE;
+}
+
+void RMGfxEngine::doFrame(CORO_PARAM, bool bDrawLocation) {
+ CORO_BEGIN_CONTEXT;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ // Poll of input devices
+ _input.poll();
+
+ if (_bMustEnterMenu && GLOBALS._bIdleExited) {
+ _bOption = true;
+ _bMustEnterMenu = false;
+ GLOBALS._bIdleExited = false;
+ }
+
+ if (_bOption) {
+ CORO_INVOKE_1(_opt.doFrame, &_input);
+ _bOption = !_opt.isClosing();
+ if (!_bOption) {
+ disableMouse();
+ enableInput();
+ mpalStartIdlePoll(_nCurLoc);
+ g_vm->pauseSound(false);
+ }
+ }
+
+ if (bDrawLocation && _bLocationLoaded) {
+ // Location and objects
+ _loc.doFrame(&_bigBuf);
+
+ // Check the mouse input
+ if (_bInput && !_tony.inAction()) {
+ // If we are on the inventory, it is it who controls all input
+ if (_inv.haveFocus(_input.mousePos()) && !_inter.active()) {
+ // Left Click
+ // **********
+ if (_input.mouseLeftClicked()/* && m_itemName.IsItemSelected()*/) {
+ // Left click activates the combine, if we are on an object
+ if (_inv.leftClick(_input.mousePos(), _curActionObj)) {
+ _curAction = TA_COMBINE;
+ _point.setAction(_curAction);
+ }
+ } else
+
+ // Right Click
+ // ***********
+ if (_input.mouseRightClicked()) {
+ if (_itemName.isItemSelected()) {
+ _curActionObj = 0;
+ _inv.rightClick(_input.mousePos());
+ } else
+ _inv.rightClick(_input.mousePos());
+ } else
+
+ // Right Release
+ // *************
+ if (_input.mouseRightReleased()) {
+ if (_inv.rightRelease(_input.mousePos(), _curAction)) {
+ CORO_INVOKE_3(_tony.moveAndDoAction, _itemName.getHotspot(), _itemName.getSelectedItem(), _curAction);
+
+ _curAction = TA_GOTO;
+ _point.setAction(_curAction);
+ }
+ }
+ } else {
+ // Options Menu
+ // ************
+ if (_bGUIOption) {
+ if (!_tony.inAction() && _bInput) {
+ if ((_input.mouseLeftClicked() && _input.mousePos()._x < 3 && _input.mousePos()._y < 3)) {
+ CORO_INVOKE_1(openOptionScreen, 0);
+ goto SKIPCLICKSINISTRO;
+ } else if (_input.getAsyncKeyState(Common::KEYCODE_ESCAPE))
+ CORO_INVOKE_1(openOptionScreen, 0);
+ else if (!g_vm->getIsDemo()) {
+ if (_input.getAsyncKeyState(Common::KEYCODE_F3) || _input.getAsyncKeyState(Common::KEYCODE_F5))
+ // Save game screen
+ CORO_INVOKE_1(openOptionScreen, 4);
+ else if (_input.getAsyncKeyState(Common::KEYCODE_F2) || _input.getAsyncKeyState(Common::KEYCODE_F7))
+ // Load game screen
+ CORO_INVOKE_1(openOptionScreen, 3);
+ }
+ }
+ }
+
+ // Left Click
+ // **************
+ if (_input.mouseLeftClicked() && !_inter.active()) {
+
+ if (_curAction != TA_COMBINE)
+ CORO_INVOKE_3(_tony.moveAndDoAction, _itemName.getHotspot(), _itemName.getSelectedItem(), _point.curAction());
+ else if (_itemName.getSelectedItem() != NULL)
+ CORO_INVOKE_4(_tony.moveAndDoAction, _itemName.getHotspot(), _itemName.getSelectedItem(), TA_COMBINE, _curActionObj);
+
+ if (_curAction == TA_COMBINE) {
+ _inv.endCombine();
+ _point.setSpecialPointer(RMPointer::PTR_NONE);
+ }
+
+ _curAction = TA_GOTO;
+ _point.setAction(_curAction);
+ }
+
+SKIPCLICKSINISTRO:
+ // Right Click
+ // ************
+ if (_curAction == TA_COMBINE) {
+ // During a combine, it cancels it
+ if (_input.mouseRightClicked()) {
+ _inv.endCombine();
+ _curActionObj = 0;
+ _curAction = TA_GOTO;
+ _point.setAction(_curAction);
+ _point.setSpecialPointer(RMPointer::PTR_NONE);
+ }
+ } else if (_input.mouseRightClicked() && _itemName.isItemSelected() && _point.getSpecialPointer() == RMPointer::PTR_NONE) {
+ if (_bGUIInterface) {
+ // Before opening the interface, replaces GOTO
+ _curAction = TA_GOTO;
+ _curActionObj = 0;
+ _point.setAction(_curAction);
+ _inter.clicked(_input.mousePos());
+ }
+ }
+
+
+ // Right Release
+ // *************
+ if (_input.mouseRightReleased()) {
+ if (_bGUIInterface) {
+ if (_inter.released(_input.mousePos(), _curAction)) {
+ _point.setAction(_curAction);
+ CORO_INVOKE_3(_tony.moveAndDoAction, _itemName.getHotspot(), _itemName.getSelectedItem(), _curAction);
+
+ _curAction = TA_GOTO;
+ _point.setAction(_curAction);
+ }
+ }
+ }
+ }
+
+ // Update the name under the mouse pointer
+ _itemName.setMouseCoord(_input.mousePos());
+ if (!_inter.active() && !_inv.miniActive())
+ CORO_INVOKE_4(_itemName.doFrame, _bigBuf, _loc, _point, _inv);
+ }
+
+ // Interface & Inventory
+ _inter.doFrame(_bigBuf, _input.mousePos());
+ _inv.doFrame(_bigBuf, _point, _input.mousePos(), (!_tony.inAction() && !_inter.active() && _bGUIInventory));
+ }
+
+ // Animate Tony
+ CORO_INVOKE_2(_tony.doFrame, &_bigBuf, _nCurLoc);
+
+ // Update screen scrolling to keep Tony in focus
+ if (_tony.mustUpdateScrolling() && _bLocationLoaded) {
+ RMPoint showThis = _tony.position();
+ showThis._y -= 60;
+ _loc.updateScrolling(showThis);
+ }
+
+ if (_bLocationLoaded)
+ _tony.setScrollPosition(_loc.scrollPosition());
+
+ if ((!_tony.inAction() && _bInput) || _bAlwaysDrawMouse) {
+ _point.showCursor();
+ } else {
+ _point.hideCursor();
+ }
+ _point.doFrame();
+
+ // **********************
+ // Draw the list in the OT
+ // **********************
+ CORO_INVOKE_0(_bigBuf.drawOT);
+
+#define FSTEP (480/32)
+
+ // Wipe
+ if (_bWiping) {
+ switch (_nWipeType) {
+ case 1:
+ if (!(_rcWipeEllipse.bottom - _rcWipeEllipse.top >= FSTEP * 2)) {
+ CoroScheduler.setEvent(_hWipeEvent);
+ _nWipeType = 3;
+ break;
+ }
+
+ _rcWipeEllipse.top += FSTEP;
+ _rcWipeEllipse.left += FSTEP;
+ _rcWipeEllipse.right -= FSTEP;
+ _rcWipeEllipse.bottom -= FSTEP;
+ break;
+
+ case 2:
+ if (!(_rcWipeEllipse.bottom - _rcWipeEllipse.top < 480 - FSTEP)) {
+ CoroScheduler.setEvent(_hWipeEvent);
+ _nWipeType = 3;
+ break;
+ }
+
+ _rcWipeEllipse.top -= FSTEP;
+ _rcWipeEllipse.left -= FSTEP;
+ _rcWipeEllipse.right += FSTEP;
+ _rcWipeEllipse.bottom += FSTEP;
+ break;
+ }
+ }
+
+ CORO_END_CODE;
+}
+
+void RMGfxEngine::initCustomDll() {
+ setupGlobalVars(&_tony, &_point, &g_vm->_theBoxes, &_loc, &_inv, &_input);
+}
+
+void RMGfxEngine::itemIrq(uint32 dwItem, int nPattern, int nStatus) {
+ RMItem *item;
+ assert(GLOBALS._gfxEngine);
+
+ if (GLOBALS._gfxEngine->_bLocationLoaded) {
+ item = GLOBALS._gfxEngine->_loc.getItemFromCode(dwItem);
+ if (item != NULL) {
+ if (nPattern != -1) {
+ item->setPattern(nPattern, true);
+ }
+ if (nStatus != -1)
+ item->setStatus(nStatus);
+ }
+ }
+}
+
+void RMGfxEngine::initForNewLocation(int nLoc, RMPoint ptTonyStart, RMPoint start) {
+ if (start._x == -1 || start._y == -1) {
+ start._x = ptTonyStart._x - RM_SX / 2;
+ start._y = ptTonyStart._y - RM_SY / 2;
+ }
+
+ _loc.setScrollPosition(start);
+
+ if (ptTonyStart._x == 0 && ptTonyStart._y == 0) {
+ } else {
+ _tony.setPosition(ptTonyStart, nLoc);
+ _tony.setScrollPosition(start);
+ }
+
+ _curAction = TA_GOTO;
+ _point.setCustomPointer(NULL);
+ _point.setSpecialPointer(RMPointer::PTR_NONE);
+ _point.setAction(_curAction);
+ _inter.reset();
+ _inv.reset();
+
+ mpalStartIdlePoll(_nCurLoc);
+}
+
+uint32 RMGfxEngine::loadLocation(int nLoc, RMPoint ptTonyStart, RMPoint start) {
+ bool bLoaded;
+ int i;
+
+ _nCurLoc = nLoc;
+
+ bLoaded = false;
+ for (i = 0; i < 5; i++) {
+ // Try the loading of the location
+ RMRes res(_nCurLoc);
+ if (!res.isValid())
+ continue;
+
+ Common::SeekableReadStream *ds = res.getReadStream();
+ _loc.load(*ds);
+ delete ds;
+
+ initForNewLocation(nLoc, ptTonyStart, start);
+ bLoaded = true;
+ break;
+ }
+
+ if (!bLoaded)
+ error("Location was not loaded");
+
+ if (_bOption)
+ _opt.reInit(_bigBuf);
+
+ _bLocationLoaded = true;
+
+ // On entering the location
+ return CORO_INVALID_PID_VALUE; //mpalQueryDoAction(0, m_nCurLoc, 0);
+}
+
+void RMGfxEngine::unloadLocation(CORO_PARAM, bool bDoOnExit, uint32 *result) {
+ CORO_BEGIN_CONTEXT;
+ uint32 h;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ // Release the location
+ CORO_INVOKE_2(mpalEndIdlePoll, _nCurLoc, NULL);
+
+ // On Exit?
+ if (bDoOnExit) {
+ _ctx->h = mpalQueryDoAction(1, _nCurLoc, 0);
+ if (_ctx->h != CORO_INVALID_PID_VALUE)
+ CORO_INVOKE_2(CoroScheduler.waitForSingleObject, _ctx->h, CORO_INFINITE);
+ }
+
+ _bLocationLoaded = false;
+
+ _bigBuf.clearOT();
+ _loc.unload();
+
+ if (result != NULL)
+ *result = CORO_INVALID_PID_VALUE;
+
+ CORO_END_CODE;
+}
+
+void RMGfxEngine::init() {
+ // Screen loading
+ RMResRaw *raw;
+ RMGfxSourceBuffer16 *load = NULL;
+ INIT_GFX16_FROMRAW(20038, load);
+ _bigBuf.addPrim(new RMGfxPrimitive(load));
+ _bigBuf.drawOT(Common::nullContext);
+ _bigBuf.clearOT();
+ delete load;
+
+ // Display 'Loading' screen
+ _bigBuf.addDirtyRect(Common::Rect(0, 0, RM_SX, RM_SY));
+ g_vm->_window.getNewFrame(*this, NULL);
+ g_vm->_window.repaint();
+
+ // Activate GUI
+ _bGUIOption = true;
+ _bGUIInterface = true;
+ _bGUIInventory = true;
+
+ GLOBALS._bSkipSfxNoLoop = false;
+ _bMustEnterMenu = false;
+ GLOBALS._bIdleExited = false;
+ _bOption = false;
+ _bWiping = false;
+ _hWipeEvent = CoroScheduler.createEvent(false, false);
+
+ // Initialize the IRQ function for items for MPAL
+ GLOBALS._gfxEngine = this;
+ mpalInstallItemIrq(itemIrq);
+
+ // Initialize the mouse pointer
+ _point.init();
+
+ // Initialize Tony
+ _tony.init();
+ _tony.linkToBoxes(&g_vm->_theBoxes);
+
+ // Initialize the inventory and the interface
+ _inv.init();
+ _inter.init();
+
+ // Download the location and set priorities @@@@@
+ _bLocationLoaded = false;
+
+ enableInput();
+
+ // Starting the game
+ _tony.executeAction(20, 1, 0);
+}
+
+void RMGfxEngine::close() {
+ _bigBuf.clearOT();
+
+ _inter.close();
+ _inv.close();
+ _tony.close();
+ _point.close();
+}
+
+void RMGfxEngine::enableInput() {
+ _bInput = true;
+}
+
+void RMGfxEngine::disableInput() {
+ _bInput = false;
+ _inter.reset();
+}
+
+void RMGfxEngine::enableMouse() {
+ _bAlwaysDrawMouse = true;
+}
+
+void RMGfxEngine::disableMouse() {
+ _bAlwaysDrawMouse = false;
+}
+
+void CharsSaveAll(Common::OutSaveFile *f);
+void CharsLoadAll(Common::InSaveFile *f);
+void MCharResetCodes();
+void SaveChangedHotspot(Common::OutSaveFile *f);
+void LoadChangedHotspot(Common::InSaveFile *f);
+void ReapplyChangedHotspot();
+
+void RestoreMusic(CORO_PARAM);
+void SaveMusic(Common::OutSaveFile *f);
+void LoadMusic(Common::InSaveFile *f);
+
+#define TONY_SAVEGAME_VERSION 8
+
+void RMGfxEngine::saveState(const Common::String &fn, byte *curThumb, const Common::String &name) {
+ Common::OutSaveFile *f;
+ byte *state;
+ uint thumbsize;
+ uint size;
+ int i;
+ char buf[4];
+ RMPoint tp = _tony.position();
+
+ // Saving: MPAL variables, current location, and Tony inventory position
+
+ // For now, we only save the MPAL state
+ size = mpalGetSaveStateSize();
+ state = new byte[size];
+ mpalSaveState(state);
+
+ thumbsize = 160 * 120 * 2;
+
+ buf[0] = 'R';
+ buf[1] = 'M';
+ buf[2] = 'S';
+ buf[3] = TONY_SAVEGAME_VERSION;
+
+ f = g_system->getSavefileManager()->openForSaving(fn);
+ if (f == NULL)
+ return;
+
+ f->write(buf, 4);
+ f->writeUint32LE(thumbsize);
+ f->write(curThumb, thumbsize);
+
+ // Difficulty level
+ i = mpalQueryGlobalVar("VERSIONEFACILE");
+ f->writeByte(i);
+
+ i = strlen(name.c_str());
+ f->writeByte(i);
+ f->write(name.c_str(), i);
+ f->writeUint32LE(_nCurLoc);
+ f->writeUint32LE(tp._x);
+ f->writeUint32LE(tp._y);
+
+ f->writeUint32LE(size);
+ f->write(state, size);
+ delete[] state;
+
+ // Inventory
+ size = _inv.getSaveStateSize();
+ state = new byte[size];
+ _inv.saveState(state);
+ f->writeUint32LE(size);
+ f->write(state, size);
+ delete[] state;
+
+ // boxes
+ size = g_vm->_theBoxes.getSaveStateSize();
+ state = new byte[size];
+ g_vm->_theBoxes.saveState(state);
+ f->writeUint32LE(size);
+ f->write(state, size);
+ delete[] state;
+
+ // New Ver5
+ bool bStat;
+
+ // Saves the state of the shepherdess and show yourself
+ bStat = _tony.getShepherdess();
+ f->writeByte(bStat);
+ bStat = _inter.getPerorate();
+ f->writeByte(bStat);
+
+ // Save the chars
+ CharsSaveAll(f);
+
+ // Save the options
+ f->writeByte(GLOBALS._bCfgInvLocked);
+ f->writeByte(GLOBALS._bCfgInvNoScroll);
+ f->writeByte(GLOBALS._bCfgTimerizedText);
+ f->writeByte(GLOBALS._bCfgInvUp);
+ f->writeByte(GLOBALS._bCfgAnni30);
+ f->writeByte(GLOBALS._bCfgAntiAlias);
+ f->writeByte(GLOBALS._bShowSubtitles);
+ f->writeByte(GLOBALS._bCfgTransparence);
+ f->writeByte(GLOBALS._bCfgInterTips);
+ f->writeByte(GLOBALS._bCfgDubbing);
+ f->writeByte(GLOBALS._bCfgMusic);
+ f->writeByte(GLOBALS._bCfgSFX);
+ f->writeByte(GLOBALS._nCfgTonySpeed);
+ f->writeByte(GLOBALS._nCfgTextSpeed);
+ f->writeByte(GLOBALS._nCfgDubbingVolume);
+ f->writeByte(GLOBALS._nCfgMusicVolume);
+ f->writeByte(GLOBALS._nCfgSFXVolume);
+
+ // Save the hotspots
+ SaveChangedHotspot(f);
+
+ // Save the music
+ SaveMusic(f);
+
+ f->finalize();
+ delete f;
+}
+
+void RMGfxEngine::loadState(CORO_PARAM, const Common::String &fn) {
+ // PROBLEM: You should change the location in a separate process to do the OnEnter
+ CORO_BEGIN_CONTEXT;
+ Common::InSaveFile *f;
+ byte *state, *statecmp;
+ uint size, sizecmp;
+ char buf[4];
+ RMPoint tp;
+ int loc;
+ int ver;
+ int i;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ _ctx->f = g_system->getSavefileManager()->openForLoading(fn);
+ if (_ctx->f == NULL)
+ return;
+ _ctx->f->read(_ctx->buf, 4);
+
+ if (_ctx->buf[0] != 'R' || _ctx->buf[1] != 'M' || _ctx->buf[2] != 'S') {
+ delete _ctx->f;
+ return;
+ }
+
+ _ctx->ver = _ctx->buf[3];
+
+ if (_ctx->ver == 0 || _ctx->ver > TONY_SAVEGAME_VERSION) {
+ delete _ctx->f;
+ return;
+ }
+
+ if (_ctx->ver >= 0x3) {
+ // There is a thumbnail. If the version is between 5 and 7, it's compressed
+ if ((_ctx->ver >= 0x5) && (_ctx->ver <= 0x7)) {
+ _ctx->i = 0;
+ _ctx->i = _ctx->f->readUint32LE();
+ _ctx->f->seek(_ctx->i);
+ } else {
+ if (_ctx->ver >= 8)
+ // Skip thumbnail size
+ _ctx->f->skip(4);
+
+ _ctx->f->seek(160 * 120 * 2, SEEK_CUR);
+ }
+ }
+
+ if (_ctx->ver >= 0x5) {
+ // Skip the difficulty level
+ _ctx->f->seek(1, SEEK_CUR);
+ }
+
+ if (_ctx->ver >= 0x4) { // Skip the savegame name, which serves no purpose
+ _ctx->i = _ctx->f->readByte();
+ _ctx->f->seek(_ctx->i, SEEK_CUR);
+ }
+
+ _ctx->loc = _ctx->f->readUint32LE();
+ _ctx->tp._x = _ctx->f->readUint32LE();
+ _ctx->tp._y = _ctx->f->readUint32LE();
+ _ctx->size = _ctx->f->readUint32LE();
+
+ if ((_ctx->ver >= 0x5) && (_ctx->ver <= 7)) {
+ // MPAL was packed!
+ _ctx->sizecmp = _ctx->f->readUint32LE();
+ _ctx->state = new byte[_ctx->size];
+ _ctx->statecmp = new byte[_ctx->sizecmp];
+ _ctx->f->read(_ctx->statecmp, _ctx->sizecmp);
+ lzo1x_decompress(_ctx->statecmp, _ctx->sizecmp, _ctx->state, &_ctx->size);
+ delete[] _ctx->statecmp;
+ } else {
+ // Read uncompressed MPAL data
+ _ctx->state = new byte[_ctx->size];
+ _ctx->f->read(_ctx->state, _ctx->size);
+ }
+
+ mpalLoadState(_ctx->state);
+ delete[] _ctx->state;
+
+ // Inventory
+ _ctx->size = _ctx->f->readUint32LE();
+ _ctx->state = new byte[_ctx->size];
+ _ctx->f->read(_ctx->state, _ctx->size);
+ _inv.loadState(_ctx->state);
+ delete[] _ctx->state;
+
+ if (_ctx->ver >= 0x2) { // Versione 2: box please
+ _ctx->size = _ctx->f->readUint32LE();
+ _ctx->state = new byte[_ctx->size];
+ _ctx->f->read(_ctx->state, _ctx->size);
+ g_vm->_theBoxes.loadState(_ctx->state);
+ delete[] _ctx->state;
+ }
+
+ if (_ctx->ver >= 5) {
+ // Versione 5
+ bool bStat = false;
+
+ bStat = _ctx->f->readByte();
+ _tony.setShepherdess(bStat);
+ bStat = _ctx->f->readByte();
+ _inter.setPerorate(bStat);
+
+ CharsLoadAll(_ctx->f);
+ }
+
+ if (_ctx->ver >= 6) {
+ // Load options
+ GLOBALS._bCfgInvLocked = _ctx->f->readByte();
+ GLOBALS._bCfgInvNoScroll = _ctx->f->readByte();
+ GLOBALS._bCfgTimerizedText = _ctx->f->readByte();
+ GLOBALS._bCfgInvUp = _ctx->f->readByte();
+ GLOBALS._bCfgAnni30 = _ctx->f->readByte();
+ GLOBALS._bCfgAntiAlias = _ctx->f->readByte();
+ GLOBALS._bShowSubtitles = _ctx->f->readByte();
+ GLOBALS._bCfgTransparence = _ctx->f->readByte();
+ GLOBALS._bCfgInterTips = _ctx->f->readByte();
+ GLOBALS._bCfgDubbing = _ctx->f->readByte();
+ GLOBALS._bCfgMusic = _ctx->f->readByte();
+ GLOBALS._bCfgSFX = _ctx->f->readByte();
+ GLOBALS._nCfgTonySpeed = _ctx->f->readByte();
+ GLOBALS._nCfgTextSpeed = _ctx->f->readByte();
+ GLOBALS._nCfgDubbingVolume = _ctx->f->readByte();
+ GLOBALS._nCfgMusicVolume = _ctx->f->readByte();
+ GLOBALS._nCfgSFXVolume = _ctx->f->readByte();
+
+ // Load hotspots
+ LoadChangedHotspot(_ctx->f);
+ }
+
+ if (_ctx->ver >= 7) {
+ LoadMusic(_ctx->f);
+ }
+
+ delete _ctx->f;
+
+ CORO_INVOKE_2(unloadLocation, false, NULL);
+ loadLocation(_ctx->loc, _ctx->tp, RMPoint(-1, -1));
+ _tony.setPattern(RMTony::PAT_STANDRIGHT);
+
+ // On older versions, need to an enter action
+ if (_ctx->ver < 5)
+ mpalQueryDoAction(0, _ctx->loc, 0);
+ else {
+ // In the new ones, we just reset the mcode
+ MCharResetCodes();
+ }
+
+ if (_ctx->ver >= 6)
+ ReapplyChangedHotspot();
+
+ CORO_INVOKE_0(RestoreMusic);
+
+ _bGUIInterface = true;
+ _bGUIInventory = true;
+ _bGUIOption = true;
+
+ CORO_END_CODE;
+}
+
+void RMGfxEngine::pauseSound(bool bPause) {
+ if (_bLocationLoaded)
+ _loc.pauseSound(bPause);
+}
+
+void RMGfxEngine::initWipe(int type) {
+ _bWiping = true;
+ _nWipeType = type;
+ _nWipeStep = 0;
+
+ if (_nWipeType == 1)
+ _rcWipeEllipse = Common::Rect(80, 0, 640 - 80, 480);
+ else if (_nWipeType == 2)
+ _rcWipeEllipse = Common::Rect(320 - FSTEP, 240 - FSTEP, 320 + FSTEP, 240 + FSTEP);
+}
+
+void RMGfxEngine::closeWipe() {
+ _bWiping = false;
+}
+
+void RMGfxEngine::waitWipeEnd(CORO_PARAM) {
+ CoroScheduler.waitForSingleObject(coroParam, _hWipeEvent, CORO_INFINITE);
+}
+
+bool RMGfxEngine::canLoadSave() {
+ return _bInput && !_tony.inAction() && !g_vm->getIsDemo();
+}
+
+RMGfxEngine::operator RMGfxTargetBuffer &() {
+ return _bigBuf;
+}
+
+RMInput &RMGfxEngine::getInput() {
+ return _input;
+}
+
+RMPointer &RMGfxEngine::getPointer() {
+ return _point;
+}
+
+/**
+ * Link to graphic task
+ */
+void RMGfxEngine::linkGraphicTask(RMGfxTask *task) {
+ _bigBuf.addPrim(new RMGfxPrimitive(task));
+}
+
+void RMGfxEngine::setPerorate(bool bpal) {
+ _inter.setPerorate(bpal);
+}
+
+} // End of namespace Tony
diff --git a/engines/tony/gfxengine.h b/engines/tony/gfxengine.h
new file mode 100644
index 0000000000..ab32a01972
--- /dev/null
+++ b/engines/tony/gfxengine.h
@@ -0,0 +1,139 @@
+/* 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.
+ *
+ */
+
+/*
+ * This code is based on original Tony Tough source code
+ *
+ * Copyright (c) 1997-2003 Nayma Software
+ */
+
+#ifndef TONY_GFXENGINE_H
+#define TONY_GFXENGINE_H
+
+#include "common/scummsys.h"
+#include "common/system.h"
+#include "common/rect.h"
+#include "tony/mpal/memory.h"
+#include "tony/game.h"
+#include "tony/gfxcore.h"
+#include "tony/input.h"
+#include "tony/inventory.h"
+#include "tony/tonychar.h"
+#include "tony/utils.h"
+
+namespace Tony {
+
+class RMGfxEngine {
+private:
+ RMGfxTargetBuffer _bigBuf;
+ RMInput _input;
+ RMPointer _point;
+ RMLocation _loc;
+ RMOptionScreen _opt;
+ RMTony _tony;
+ RMInventory _inv;
+ RMInterface _inter;
+ RMTextItemName _itemName;
+
+ bool _bOption;
+ bool _bLocationLoaded;
+
+ bool _bInput;
+ bool _bAlwaysDrawMouse;
+
+ int _nCurLoc;
+ RMTonyAction _curAction;
+ int _curActionObj;
+
+ int _nWipeType;
+ uint32 _hWipeEvent;
+ int _nWipeStep;
+
+ bool _bMustEnterMenu;
+protected:
+ static void itemIrq(uint32 dwItem, int nPattern, int nStatus);
+ void initForNewLocation(int nLoc, RMPoint ptTonyStart, RMPoint start);
+public:
+ bool _bWiping;
+ Common::Rect _rcWipeEllipse;
+ bool _bGUIOption;
+ bool _bGUIInterface;
+ bool _bGUIInventory;
+public:
+ RMGfxEngine();
+ virtual ~RMGfxEngine();
+
+ // Draw the next frame
+ void doFrame(CORO_PARAM, bool bDrawLocation);
+
+ // Initializes the graphics engine
+ void init();
+
+ // Closes the graphics engine
+ void close();
+
+ // Warns when entering or exits the options menu
+ void openOptionScreen(CORO_PARAM, int type);
+
+ // Enables or disables mouse input
+ void enableInput();
+ void disableInput();
+
+ // Enables and disables mouse draw
+ void enableMouse();
+ void disableMouse();
+
+ operator RMGfxTargetBuffer &();
+ RMInput &getInput();
+ RMPointer &getPointer();
+
+ // Link to the custom function list
+ void initCustomDll();
+
+ // Link to graphic task
+ void linkGraphicTask(RMGfxTask *task);
+
+ // Manage a location
+ uint32 loadLocation(int nLoc, RMPoint ptTonyStart, RMPoint start);
+ void unloadLocation(CORO_PARAM, bool bDoOnExit, uint32 *result);
+ int getCurrentLocation() const { return _nCurLoc; }
+
+ // State management
+ void saveState(const Common::String &fn, byte *curThumb, const Common::String &name);
+ void loadState(CORO_PARAM, const Common::String &fn);
+
+ // Pauses sound
+ void pauseSound(bool bPause);
+
+ // Wipe
+ void initWipe(int type);
+ void closeWipe();
+ void waitWipeEnd(CORO_PARAM);
+
+ void setPerorate(bool bpal);
+
+ bool canLoadSave();
+};
+
+} // End of namespace Tony
+
+#endif
diff --git a/engines/tony/globals.cpp b/engines/tony/globals.cpp
new file mode 100644
index 0000000000..8e4ae240a0
--- /dev/null
+++ b/engines/tony/globals.cpp
@@ -0,0 +1,135 @@
+/* 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/algorithm.h"
+#include "tony/globals.h"
+
+namespace Tony {
+
+Globals::Globals() {
+ _nextLoop = false;
+ _nextChannel = 0;
+ _nextSync = 0;
+ _curChannel = 0;
+ _flipflop = 0;
+ _curBackText = NULL;
+ _bTonyIsSpeaking = false;
+ _curChangedHotspot = 0;
+ _tony = NULL;
+ _pointer = NULL;
+ _boxes = NULL;
+ _loc = NULL;
+ _inventory = NULL;
+ _input = NULL;
+ _gfxEngine = NULL;
+ EnableGUI = NULL;
+ DisableGUI = NULL;
+
+ _dwTonyNumTexts = 0;
+ _bTonyInTexts = false;
+ _bStaticTalk = false;
+ _bAlwaysDisplay = false;
+ _bIdleExited = false;
+ _bSkipSfxNoLoop = false;
+ _bNoBullsEye = false;
+ _curDialog = 0;
+ _curSoundEffect = 0;
+ _bFadeOutStop = false;
+
+ _bSkipIdle = false;
+ _hSkipIdle = 0;
+ _lastMusic = 0;
+ _lastTappeto = 0;
+ Common::fill(&_ambiance[0], &_ambiance[200], 0);
+ _fullScreenMessageLoc = 0;
+
+ // MPAL global variables
+ _mpalError = 0;
+ _lpiifCustom = NULL;
+ _lplpFunctions = NULL;
+ _lplpFunctionStrings = NULL;
+ _nObjs = 0;
+ _nVars = 0;
+ _hVars = NULL;
+ _lpmvVars = NULL;
+ _nMsgs = 0;
+ _hMsgs = NULL;
+ _lpmmMsgs = NULL;
+ _nDialogs = 0;
+ _hDialogs = NULL;
+ _lpmdDialogs = NULL;
+ _nItems = 0;
+ _hItems = NULL;
+ _lpmiItems = NULL;
+ _nLocations = 0;
+ _hLocations = NULL;
+ _lpmlLocations = NULL;
+ _nScripts = 0;
+ _hScripts = NULL;
+ _lpmsScripts = NULL;
+ _nResources = 0;
+ _lpResources = NULL;
+ _bExecutingAction = false;
+ _bExecutingDialog = false;
+ Common::fill(&_nPollingLocations[0], &_nPollingLocations[MAXPOLLINGLOCATIONS], 0);
+ Common::fill(&_hEndPollingLocations[0], &_hEndPollingLocations[MAXPOLLINGLOCATIONS], 0);
+ Common::fill(&_pollingThreads[0], &_pollingThreads[MAXPOLLINGLOCATIONS], 0);
+ _hAskChoice = 0;
+ _hDoneChoice = 0;
+ _nExecutingAction = 0;
+ _nExecutingDialog = 0;
+ _nExecutingChoice = 0;
+ _nSelectedChoice = 0;
+ _nTonyNextTalkType = RMTony::TALK_NORMAL;
+ _saveTonyLoc = 0;
+
+ for (int i = 0; i < 16; ++i) {
+ Common::fill((byte *)&_character[i], (byte *)&_character[i] + sizeof(CharacterStruct), 0);
+ _isMChar[i] = false;
+ }
+
+ for (int i = 0; i < 10; ++i)
+ Common::fill((byte *)&_mCharacter[i], (byte *)&_mCharacter[i] + sizeof(MCharacterStruct), 0);
+ for (int i = 0; i < 256; ++i)
+ Common::fill((byte *)&_changedHotspot[i], (byte *)&_changedHotspot[i] + sizeof(ChangedHotspotStruct), 0);
+
+ // Set up globals that have explicit initial values
+ _bCfgInvLocked = false;
+ _bCfgInvNoScroll = false;
+ _bCfgTimerizedText = true;
+ _bCfgInvUp = false;
+ _bCfgAnni30 = false;
+ _bCfgAntiAlias = false;
+ _bCfgTransparence = true;
+ _bCfgInterTips = true;
+ _bShowSubtitles = true;
+ _nCfgTonySpeed = 3;
+ _nCfgTextSpeed = 5;
+ _bCfgDubbing = true;
+ _bCfgMusic = true;
+ _bCfgSFX = true;
+ _nCfgDubbingVolume = 10;
+ _nCfgMusicVolume = 7;
+ _nCfgSFXVolume = 10;
+}
+
+} // End of namespace Tony
diff --git a/engines/tony/globals.h b/engines/tony/globals.h
new file mode 100644
index 0000000000..d8d8d3eba5
--- /dev/null
+++ b/engines/tony/globals.h
@@ -0,0 +1,286 @@
+/* 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 TONY_GLOBALS
+#define TONY_GLOBALS
+
+#include "common/savefile.h"
+#include "tony/gfxengine.h"
+#include "tony/input.h"
+#include "tony/inventory.h"
+#include "tony/loc.h"
+#include "tony/tonychar.h"
+#include "tony/mpal/mpal.h"
+#include "tony/mpal/mpaldll.h"
+
+namespace Tony {
+
+#define AMBIANCE_CRICKETS 1
+#define AMBIANCE_CRICKETSMUFFLED 2
+#define AMBIANCE_CRICKETSWIND 3
+#define AMBIANCE_CRICKETSWIND1 4
+#define AMBIANCE_WIND 5
+#define AMBIANCE_SEA 6
+#define AMBIANCE_SEAHALFVOLUME 7
+
+struct CharacterStruct {
+ uint32 _code;
+ RMItem *_item;
+ byte _r, _g, _b;
+ int _talkPattern;
+ int _standPattern;
+ int _startTalkPattern, _endTalkPattern;
+ int _numTexts;
+
+ void save(Common::OutSaveFile *f) {
+ f->writeUint32LE(_code);
+ f->writeUint32LE(0);
+ f->writeByte(_r);
+ f->writeByte(_g);
+ f->writeByte(_b);
+ f->writeUint32LE(_talkPattern);
+ f->writeUint32LE(_standPattern);
+ f->writeUint32LE(_startTalkPattern);
+ f->writeUint32LE(_endTalkPattern);
+ f->writeUint32LE(_numTexts);
+ }
+ void load(Common::InSaveFile *f) {
+ _code = f->readUint32LE();
+ f->readUint32LE();
+ _item = NULL;
+ _r = f->readByte();
+ _g = f->readByte();
+ _b = f->readByte();
+ _talkPattern = f->readUint32LE();
+ _standPattern = f->readUint32LE();
+ _startTalkPattern = f->readUint32LE();
+ _endTalkPattern = f->readUint32LE();
+ _numTexts = f->readUint32LE();
+ }
+};
+
+struct MCharacterStruct {
+ uint32 _code;
+ RMItem *_item;
+ byte _r, _g, _b;
+ int _x, _y;
+ int _numTalks[10];
+ int _curGroup;
+ int _numTexts;
+ bool _bInTexts;
+ int _curTalk;
+ bool _bAlwaysBack;
+
+ void save(Common::OutSaveFile *f) {
+ f->writeUint32LE(_code);
+ f->writeUint32LE(0);
+ f->writeByte(_r);
+ f->writeByte(_g);
+ f->writeByte(_b);
+ f->writeUint32LE(_x);
+ f->writeUint32LE(_y);
+ for (int i = 0; i < 10; ++i)
+ f->writeUint32LE(_numTalks[i]);
+ f->writeUint32LE(_curGroup);
+ f->writeUint32LE(_numTexts);
+ f->writeByte(_bInTexts);
+ f->writeUint32LE(_curTalk);
+ f->writeByte(_bAlwaysBack);
+ }
+ void load(Common::InSaveFile *f) {
+ _code = f->readUint32LE();
+ f->readUint32LE();
+ _item = NULL;
+ _r = f->readByte();
+ _g = f->readByte();
+ _b = f->readByte();
+ _x = f->readUint32LE();
+ _y = f->readUint32LE();
+ for (int i = 0; i < 10; ++i)
+ _numTalks[i] = f->readUint32LE();
+ _curGroup = f->readUint32LE();
+ _numTexts = f->readUint32LE();
+ _bInTexts = f->readByte();
+ _curTalk = f->readUint32LE();
+ _bAlwaysBack = f->readByte();
+ }
+};
+
+struct ChangedHotspotStruct {
+ uint32 _dwCode;
+ uint32 _nX, _nY;
+
+ void save(Common::OutSaveFile *f) {
+ f->writeUint32LE(_dwCode);
+ f->writeUint32LE(_nX);
+ f->writeUint32LE(_nY);
+ }
+ void load(Common::InSaveFile *f) {
+ _dwCode = f->readUint32LE();
+ _nX = f->readUint32LE();
+ _nY = f->readUint32LE();
+ }
+};
+
+
+/**
+ * Description of a call to a custom function.
+ */
+typedef struct {
+ int _nCf;
+ int _arg1, _arg2, _arg3, _arg4;
+} CfCall;
+
+typedef CfCall *LpCfCall;
+
+struct CoroutineMutex {
+ CoroutineMutex() : _eventId(0), _ownerPid(0), _lockCount(0) { }
+
+ uint32 _eventId;
+ uint32 _ownerPid;
+ uint32 _lockCount;
+};
+
+/****************************************************************************\
+* Global variables
+\****************************************************************************/
+
+/**
+ * Globals class
+ */
+class Globals {
+public:
+ Globals();
+
+ Common::String _nextMusic;
+ bool _nextLoop;
+ int _nextChannel;
+ int _nextSync;
+ int _curChannel;
+ int _flipflop;
+ CharacterStruct _character[16];
+ MCharacterStruct _mCharacter[10];
+ ChangedHotspotStruct _changedHotspot[256];
+ bool _isMChar[16];
+ bool _bAlwaysDisplay;
+ RMPoint _saveTonyPos;
+ int _saveTonyLoc;
+ RMTextDialog *_curBackText;
+ bool _bTonyIsSpeaking;
+ int _curChangedHotspot;
+ bool _bCfgInvLocked;
+ bool _bCfgInvNoScroll;
+ bool _bCfgTimerizedText;
+ bool _bCfgInvUp;
+ bool _bCfgAnni30;
+ bool _bCfgAntiAlias;
+ bool _bShowSubtitles;
+ bool _bCfgTransparence;
+ bool _bCfgInterTips;
+ bool _bCfgDubbing;
+ bool _bCfgMusic;
+ bool _bCfgSFX;
+ int _nCfgTonySpeed;
+ int _nCfgTextSpeed;
+ int _nCfgDubbingVolume;
+ int _nCfgMusicVolume;
+ int _nCfgSFXVolume;
+ bool _bSkipSfxNoLoop;
+ bool _bIdleExited;
+ bool _bNoBullsEye;
+ int _curDialog;
+ int _curSoundEffect;
+ bool _bFadeOutStop;
+
+ RMTony *_tony;
+ RMPointer *_pointer;
+ RMGameBoxes *_boxes;
+ RMLocation *_loc;
+ RMInventory *_inventory;
+ RMInput *_input;
+ RMGfxEngine *_gfxEngine;
+
+ void (*EnableGUI)();
+ void (*DisableGUI)();
+
+ uint32 _dwTonyNumTexts;
+ bool _bTonyInTexts;
+ bool _bStaticTalk;
+ RMTony::CharacterTalkType _nTonyNextTalkType;
+
+ RMPoint _startLocPos[256];
+ CoroutineMutex _mut[10];
+
+ bool _bSkipIdle;
+ uint32 _hSkipIdle;
+
+ int _lastMusic, _lastTappeto;
+
+ int _ambiance[200];
+ RMPoint _fullScreenMessagePt;
+ int _fullScreenMessageLoc;
+
+ /**
+ * @defgroup MPAL variables
+ */
+ uint32 _mpalError;
+ LPITEMIRQFUNCTION _lpiifCustom;
+ LPLPCUSTOMFUNCTION _lplpFunctions;
+ Common::String *_lplpFunctionStrings;
+ uint16 _nObjs;
+ uint16 _nVars;
+ MpalHandle _hVars;
+ LpMpalVar _lpmvVars;
+ uint16 _nMsgs;
+ MpalHandle _hMsgs;
+ LpMpalMsg _lpmmMsgs;
+ uint16 _nDialogs;
+ MpalHandle _hDialogs;
+ LpMpalDialog _lpmdDialogs;
+ uint16 _nItems;
+ MpalHandle _hItems;
+ LpMpalItem _lpmiItems;
+ uint16 _nLocations;
+ MpalHandle _hLocations;
+ LpMpalLocation _lpmlLocations;
+ uint16 _nScripts;
+ MpalHandle _hScripts;
+ LpMpalScript _lpmsScripts;
+ Common::File _hMpr;
+ uint16 _nResources;
+ uint32 *_lpResources;
+ bool _bExecutingAction;
+ bool _bExecutingDialog;
+ uint32 _nPollingLocations[MAXPOLLINGLOCATIONS];
+ uint32 _hEndPollingLocations[MAXPOLLINGLOCATIONS];
+ uint32 _pollingThreads[MAXPOLLINGLOCATIONS];
+ uint32 _hAskChoice;
+ uint32 _hDoneChoice;
+ uint32 _nExecutingAction;
+ uint32 _nExecutingDialog;
+ uint32 _nExecutingChoice;
+ uint32 _nSelectedChoice;
+};
+
+} // End of namespace Tony
+
+#endif // TONY_GLOBALS
diff --git a/engines/tony/input.cpp b/engines/tony/input.cpp
new file mode 100644
index 0000000000..b96ccaf842
--- /dev/null
+++ b/engines/tony/input.cpp
@@ -0,0 +1,157 @@
+/* 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.
+ *
+ */
+
+/*
+ * This code is based on original Tony Tough source code
+ *
+ * Copyright (c) 1997-2003 Nayma Software
+ */
+
+#include "tony/gfxengine.h"
+#include "tony/tony.h"
+
+namespace Tony {
+
+RMInput::RMInput() {
+ // Setup mouse fields
+ _clampMouse = false;
+ _mousePos.set(0, 0);
+ _leftButton = _rightButton = false;
+ _leftClickMouse = _leftReleaseMouse = false;
+ _rightClickMouse = _rightReleaseMouse = false;
+
+ Common::fill((byte *)&_event, (byte *)&_event + sizeof(Common::Event), 0);
+
+ // Setup keyboard fields
+ Common::fill(&_keyDown[0], &_keyDown[350], 0);
+}
+
+RMInput::~RMInput() {
+}
+
+void RMInput::poll() {
+ _leftClickMouse = _leftReleaseMouse = _rightClickMouse = _rightReleaseMouse = false;
+
+ // Get pending events
+ while (g_system->getEventManager()->pollEvent(_event) && !g_vm->shouldQuit()) {
+ switch (_event.type) {
+ case Common::EVENT_MOUSEMOVE:
+ case Common::EVENT_LBUTTONDOWN:
+ case Common::EVENT_LBUTTONUP:
+ case Common::EVENT_RBUTTONDOWN:
+ case Common::EVENT_RBUTTONUP:
+ _mousePos.set(_event.mouse.x, _event.mouse.y);
+
+ if (_event.type == Common::EVENT_LBUTTONDOWN) {
+ _leftButton = true;
+ _leftClickMouse = true;
+ } else if (_event.type == Common::EVENT_LBUTTONUP) {
+ _leftButton = false;
+ _leftReleaseMouse = true;
+ } else if (_event.type == Common::EVENT_RBUTTONDOWN) {
+ _rightButton = true;
+ _rightClickMouse = true;
+ } else if (_event.type == Common::EVENT_RBUTTONUP) {
+ _rightButton = false;
+ _rightReleaseMouse = true;
+ } else
+ continue;
+
+ // Since a mouse button has changed, don't do any further event processing this frame
+ return;
+
+ case Common::EVENT_KEYDOWN:
+ // Check for debugger
+ if ((_event.kbd.keycode == Common::KEYCODE_d) && (_event.kbd.flags & Common::KBD_CTRL)) {
+ // Attach to the debugger
+ g_vm->_debugger->attach();
+ g_vm->_debugger->onFrame();
+ } else {
+ // Flag the given key as being down
+ _keyDown[(int)_event.kbd.keycode] = true;
+ }
+ return;
+
+ case Common::EVENT_KEYUP:
+ _keyDown[(int)_event.kbd.keycode] = false;
+ return;
+
+ default:
+ break;
+ }
+ }
+}
+
+bool RMInput::mouseLeft() {
+ return _leftButton;
+}
+
+bool RMInput::mouseRight() {
+ return _rightButton;
+}
+
+/**
+ * Return true if a key has been pressed
+ */
+bool RMInput::getAsyncKeyState(Common::KeyCode kc) {
+ // The act of testing for a particular key automatically clears the state, to prevent
+ // the same key being registered in multiple different frames
+ bool result = _keyDown[(int)kc];
+ _keyDown[(int)kc] = false;
+ return result;
+}
+
+/**
+ * Reading of the mouse
+ */
+RMPoint RMInput::mousePos() {
+ return _mousePos;
+}
+
+/**
+ * Events of mouse clicks
+ */
+bool RMInput::mouseLeftClicked() {
+ return _leftClickMouse;
+}
+
+bool RMInput::mouseRightClicked() {
+ return _rightClickMouse;
+}
+
+bool RMInput::mouseBothClicked() {
+ return _leftClickMouse && _rightClickMouse;
+}
+
+bool RMInput::mouseLeftReleased() {
+ return _leftReleaseMouse;
+}
+
+bool RMInput::mouseRightReleased() {
+ return _rightReleaseMouse;
+}
+
+bool RMInput::mouseBothReleased() {
+ return _leftReleaseMouse && _rightReleaseMouse;
+}
+
+} // End of namespace Tony
diff --git a/engines/tony/input.h b/engines/tony/input.h
new file mode 100644
index 0000000000..d07eaefe34
--- /dev/null
+++ b/engines/tony/input.h
@@ -0,0 +1,88 @@
+/* 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.
+ *
+ */
+
+/*
+ * This code is based on original Tony Tough source code
+ *
+ * Copyright (c) 1997-2003 Nayma Software
+ */
+
+#ifndef TONY_INPUT_H
+#define TONY_INPUT_H
+
+#include "common/events.h"
+#include "tony/utils.h"
+
+namespace Tony {
+
+class RMInput {
+private:
+ Common::Event _event;
+
+ // Mouse related fields
+ RMPoint _mousePos;
+ bool _clampMouse;
+ bool _leftButton, _rightButton;
+ bool _leftClickMouse, _leftReleaseMouse, _rightClickMouse, _rightReleaseMouse;
+
+ // Keyboard related fields
+ bool _keyDown[350];
+
+public:
+ RMInput();
+ ~RMInput();
+
+ /**
+ * Polling (must be performed once per frame)
+ */
+ void poll();
+
+ /**
+ * Reading of the mouse
+ */
+ RMPoint mousePos();
+
+ /**
+ * Current status of the mouse buttons
+ */
+ bool mouseLeft();
+ bool mouseRight();
+
+ /**
+ * Events of mouse clicks
+ */
+ bool mouseLeftClicked();
+ bool mouseRightClicked();
+ bool mouseBothClicked();
+ bool mouseLeftReleased();
+ bool mouseRightReleased();
+ bool mouseBothReleased();
+
+ /**
+ * Returns true if the given key is pressed
+ */
+ bool getAsyncKeyState(Common::KeyCode kc);
+};
+
+} // End of namespace Tony
+
+#endif
diff --git a/engines/tony/inventory.cpp b/engines/tony/inventory.cpp
new file mode 100644
index 0000000000..81d62a035c
--- /dev/null
+++ b/engines/tony/inventory.cpp
@@ -0,0 +1,953 @@
+/* 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.
+ *
+ */
+
+/*
+ * This code is based on original Tony Tough source code
+ *
+ * Copyright (c) 1997-2003 Nayma Software
+ */
+
+#include "common/textconsole.h"
+#include "tony/mpal/mpalutils.h"
+#include "tony/inventory.h"
+#include "tony/game.h"
+#include "tony/tony.h"
+
+namespace Tony {
+
+
+/****************************************************************************\
+* RMInventory Methods
+\****************************************************************************/
+
+RMInventory::RMInventory() {
+ _items = NULL;
+ _state = CLOSED;
+ _bCombining = false;
+ _csModifyInterface = g_system->createMutex();
+ _nItems = 0;
+
+ Common::fill(_inv, _inv + 256, 0);
+ _nInv = 0;
+ _curPutY = 0;
+ _curPutTime = 0;
+ _curPos = 0;
+ _bHasFocus = false;
+ _nSelectObj = 0;
+ _nCombine = 0;
+ _bBlinkingRight = false;
+ _bBlinkingLeft = false;
+ _miniAction = 0;
+}
+
+RMInventory::~RMInventory() {
+ close();
+ g_system->deleteMutex(_csModifyInterface);
+}
+
+bool RMInventory::checkPointInside(const RMPoint &pt) {
+ if (!GLOBALS._bCfgInvUp)
+ return pt._y > RM_SY - 70;
+ else
+ return pt._y < 70;
+}
+
+
+void RMInventory::init() {
+ int i, j;
+ int curres;
+
+ // Create the main buffer
+ create(RM_SX, 68);
+ setPriority(185);
+
+ // Setup the inventory
+ _nInv = 0;
+ _curPos = 0;
+ _bCombining = false;
+
+ // New items
+ _nItems = 78; // @@@ Number of takeable items
+ _items = new RMInventoryItem[_nItems + 1];
+
+ curres = 10500;
+
+ // Loop through the items
+ for (i = 0; i <= _nItems; i++) {
+ // Load the items from the resource
+ RMRes res(curres);
+ assert(res.isValid());
+ Common::SeekableReadStream *ds = res.getReadStream();
+
+ // Initialize the MPAL inventory item by reading it in.
+ _items[i]._icon.setInitCurPattern(false);
+ _items[i]._icon.readFromStream(*ds);
+ delete ds;
+
+ // Puts in the default pattern 1
+ _items[i]._pointer = NULL;
+ _items[i]._status = 1;
+ _items[i]._icon.setPattern(1);
+ _items[i]._icon.doFrame(this, false);
+
+ curres++;
+ if (i == 0 || i == 28 || i == 29)
+ continue;
+
+ _items[i]._pointer = new RMGfxSourceBuffer8RLEByteAA[_items[i]._icon.numPattern()];
+
+ for (j = 0; j < _items[i]._icon.numPattern(); j++) {
+ RMResRaw raw(curres);
+
+ assert(raw.isValid());
+
+ _items[i]._pointer[j].init((const byte *)raw, raw.width(), raw.height(), true);
+ curres++;
+ }
+ }
+
+ _items[28]._icon.setPattern(1);
+ _items[29]._icon.setPattern(1);
+
+ // Download interface
+ RMRes res(RES_I_MINIINTER);
+ assert(res.isValid());
+ Common::SeekableReadStream *ds = res.getReadStream();
+ _miniInterface.readFromStream(*ds);
+ _miniInterface.setPattern(1);
+ delete ds;
+
+ // Create the text for hints on the mini interface
+ _hints[0].setAlignType(RMText::HCENTER, RMText::VTOP);
+ _hints[1].setAlignType(RMText::HCENTER, RMText::VTOP);
+ _hints[2].setAlignType(RMText::HCENTER, RMText::VTOP);
+
+ // The text is taken from MPAL for translation
+ RMMessage msg1(15);
+ RMMessage msg2(13);
+ RMMessage msg3(14);
+
+ _hints[0].writeText(msg1[0], 1); // Examine
+ _hints[1].writeText(msg2[0], 1); // Take
+ _hints[2].writeText(msg3[0], 1); // Use
+
+
+ // Prepare initial inventory
+ prepare();
+ drawOT(Common::nullContext);
+ clearOT();
+}
+
+void RMInventory::close() {
+ // Has memory
+ if (_items != NULL) {
+ // Delete the item pointers
+ for (int i = 0; i <= _nItems; i++)
+ delete[] _items[i]._pointer;
+
+ // Delete the items array
+ delete[] _items;
+ _items = NULL;
+ }
+
+ destroy();
+}
+
+void RMInventory::reset() {
+ _state = CLOSED;
+ endCombine();
+}
+
+void RMInventory::draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim) {
+ CORO_BEGIN_CONTEXT;
+ RMPoint pos;
+ RMPoint pos2;
+ RMGfxPrimitive *p;
+ RMGfxPrimitive *p2;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ prim->setDst(RMPoint(0, _curPutY));
+ g_system->lockMutex(_csModifyInterface);
+ CORO_INVOKE_2(RMGfxWoodyBuffer::draw, bigBuf, prim);
+ g_system->unlockMutex(_csModifyInterface);
+
+ if (_state == SELECTING) {
+
+ if (!GLOBALS._bCfgInvUp) {
+ _ctx->pos.set((_nSelectObj + 1) * 64 - 20, RM_SY - 113);
+ _ctx->pos2.set((_nSelectObj + 1) * 64 + 34, RM_SY - 150);
+ } else {
+ _ctx->pos.set((_nSelectObj + 1) * 64 - 20, 72 - 4); // The brown part is at the top :(
+ _ctx->pos2.set((_nSelectObj + 1) * 64 + 34, 119 - 4);
+ }
+
+ _ctx->p = new RMGfxPrimitive(prim->_task, _ctx->pos);
+ _ctx->p2 = new RMGfxPrimitive(prim->_task, _ctx->pos2);
+
+ // Draw the mini interface
+ CORO_INVOKE_2(_miniInterface.draw, bigBuf, _ctx->p);
+
+ if (GLOBALS._bCfgInterTips) {
+ if (_miniAction == 1) // Examine
+ CORO_INVOKE_2(_hints[0].draw, bigBuf, _ctx->p2);
+ else if (_miniAction == 2) // Talk
+ CORO_INVOKE_2(_hints[1].draw, bigBuf, _ctx->p2);
+ else if (_miniAction == 3) // Use
+ CORO_INVOKE_2(_hints[2].draw, bigBuf, _ctx->p2);
+ }
+
+ delete _ctx->p;
+ delete _ctx->p2;
+ }
+
+ CORO_END_CODE;
+}
+
+void RMInventory::removeThis(CORO_PARAM, bool &result) {
+ if (_state == CLOSED)
+ result = true;
+ else
+ result = false;
+}
+
+void RMInventory::removeItem(int code) {
+ int i;
+
+ for (i = 0; i < _nInv; i++)
+ if (_inv[i] == code - 10000) {
+ g_system->lockMutex(_csModifyInterface);
+
+ Common::copy(&_inv[i + 1], &_inv[i + 1] + (_nInv - i), &_inv[i]);
+ _nInv--;
+
+ prepare();
+ drawOT(Common::nullContext);
+ clearOT();
+ g_system->unlockMutex(_csModifyInterface);
+ return;
+ }
+}
+
+void RMInventory::addItem(int code) {
+ if (code <= 10000 || code >= 10101) {
+ // If we are here, it means that we are adding an item that should not be in the inventory
+ warning("RMInventory::addItem(%d) - Cannot find a valid icon for this item, and then it will not be added to the inventory", code);
+ } else {
+ g_system->lockMutex(_csModifyInterface);
+ if (_curPos + 8 == _nInv) {
+ // Break through the inventory! On the flashing pattern
+ _items[28]._icon.setPattern(2);
+ }
+
+ _inv[_nInv++] = code - 10000;
+
+ prepare();
+ drawOT(Common::nullContext);
+ clearOT();
+ g_system->unlockMutex(_csModifyInterface);
+ }
+}
+
+void RMInventory::changeItemStatus(uint32 code, uint32 dwStatus) {
+ if (code <= 10000 || code >= 10101) {
+ error("RMInventory::changeItemStatus(%d) - Specified object code is not valid", code);
+ } else {
+ g_system->lockMutex(_csModifyInterface);
+ _items[code - 10000]._icon.setPattern(dwStatus);
+ _items[code - 10000]._status = dwStatus;
+
+ prepare();
+ drawOT(Common::nullContext);
+ clearOT();
+ g_system->unlockMutex(_csModifyInterface);
+ }
+}
+
+
+void RMInventory::prepare() {
+ int i;
+
+ for (i = 1; i < RM_SX / 64 - 1; i++) {
+ if (i - 1 + _curPos < _nInv)
+ addPrim(new RMGfxPrimitive(&_items[_inv[i - 1 + _curPos]]._icon, RMPoint(i * 64, 0)));
+ else
+ addPrim(new RMGfxPrimitive(&_items[0]._icon, RMPoint(i * 64, 0)));
+ }
+
+ // Frecce
+ addPrim(new RMGfxPrimitive(&_items[29]._icon, RMPoint(0, 0)));
+ addPrim(new RMGfxPrimitive(&_items[28]._icon, RMPoint(640 - 64, 0)));
+}
+
+bool RMInventory::miniActive() {
+ return _state == SELECTING;
+}
+
+bool RMInventory::haveFocus(const RMPoint &mpos) {
+ // When we combine, have the focus only if we are on an arrow (to scroll)
+ if (_state == OPENED && _bCombining && checkPointInside(mpos) && (mpos._x < 64 || mpos._x > RM_SX - 64))
+ return true;
+
+ // If the inventory is open, focus we we go over it
+ if (_state == OPENED && !_bCombining && checkPointInside(mpos))
+ return true;
+
+ // If we are selecting a verb (and then right down), we always focus
+ if (_state == SELECTING)
+ return true;
+
+ return false;
+}
+
+void RMInventory::endCombine() {
+ _bCombining = false;
+}
+
+bool RMInventory::leftClick(const RMPoint &mpos, int &nCombineObj) {
+ int n;
+
+ // The left click picks an item from your inventory to use it with the background
+ n = mpos._x / 64;
+
+ if (_state == OPENED) {
+ if (n > 0 && n < RM_SX / 64 - 1 && _inv[n - 1 + _curPos] != 0) {
+ _bCombining = true; //m_state = COMBINING;
+ _nCombine = _inv[n - 1 + _curPos];
+ nCombineObj = _nCombine + 10000;
+
+ g_vm->playUtilSFX(1);
+ return true;
+ }
+ }
+
+ // Click the right arrow
+ if ((_state == OPENED) && _bBlinkingRight) {
+ g_system->lockMutex(_csModifyInterface);
+ _curPos++;
+
+ if (_curPos + 8 >= _nInv) {
+ _bBlinkingRight = false;
+ _items[28]._icon.setPattern(1);
+ }
+
+ if (_curPos > 0) {
+ _bBlinkingLeft = true;
+ _items[29]._icon.setPattern(2);
+ }
+
+ prepare();
+ drawOT(Common::nullContext);
+ clearOT();
+ g_system->unlockMutex(_csModifyInterface);
+ }
+ // Click the left arrow
+ else if ((_state == OPENED) && _bBlinkingLeft) {
+ assert(_curPos > 0);
+ g_system->lockMutex(_csModifyInterface);
+ _curPos--;
+
+ if (_curPos == 0) {
+ _bBlinkingLeft = false;
+ _items[29]._icon.setPattern(1);
+ }
+
+ if (_curPos + 8 < _nInv) {
+ _bBlinkingRight = true;
+ _items[28]._icon.setPattern(2);
+ }
+
+ prepare();
+ drawOT(Common::nullContext);
+ clearOT();
+ g_system->unlockMutex(_csModifyInterface);
+ }
+
+
+ return false;
+}
+
+void RMInventory::rightClick(const RMPoint &mpos) {
+ assert(checkPointInside(mpos));
+
+ if (_state == OPENED && !_bCombining) {
+ // Open the context interface
+ int n = mpos._x / 64;
+
+ if (n > 0 && n < RM_SX / 64 - 1 && _inv[n - 1 + _curPos] != 0) {
+ _state = SELECTING;
+ _miniAction = 0;
+ _nSelectObj = n - 1;
+
+ g_vm->playUtilSFX(0);
+ }
+ }
+
+ if ((_state == OPENED) && _bBlinkingRight) {
+ g_system->lockMutex(_csModifyInterface);
+ _curPos += 7;
+ if (_curPos + 8 > _nInv)
+ _curPos = _nInv - 8;
+
+ if (_curPos + 8 <= _nInv) {
+ _bBlinkingRight = false;
+ _items[28]._icon.setPattern(1);
+ }
+
+ if (_curPos > 0) {
+ _bBlinkingLeft = true;
+ _items[29]._icon.setPattern(2);
+ }
+
+ prepare();
+ drawOT(Common::nullContext);
+ clearOT();
+ g_system->unlockMutex(_csModifyInterface);
+ } else if ((_state == OPENED) && _bBlinkingLeft) {
+ assert(_curPos > 0);
+ g_system->lockMutex(_csModifyInterface);
+ _curPos -= 7;
+ if (_curPos < 0)
+ _curPos = 0;
+
+ if (_curPos == 0) {
+ _bBlinkingLeft = false;
+ _items[29]._icon.setPattern(1);
+ }
+
+ if (_curPos + 8 < _nInv) {
+ _bBlinkingRight = true;
+ _items[28]._icon.setPattern(2);
+ }
+
+ prepare();
+ drawOT(Common::nullContext);
+ clearOT();
+ g_system->unlockMutex(_csModifyInterface);
+ }
+}
+
+bool RMInventory::rightRelease(const RMPoint &mpos, RMTonyAction &curAction) {
+ if (_state == SELECTING) {
+ _state = OPENED;
+
+ if (_miniAction == 1) { // Examine
+ curAction = TA_EXAMINE;
+ return true;
+ } else if (_miniAction == 2) { // Talk
+ curAction = TA_TALK;
+ return true;
+ } else if (_miniAction == 3) { // Use
+ curAction = TA_USE;
+ return true;
+ }
+ }
+
+ return false;
+}
+
+#define INVSPEED 20
+
+void RMInventory::doFrame(RMGfxTargetBuffer &bigBuf, RMPointer &ptr, RMPoint mpos, bool bCanOpen) {
+ bool bNeedRedraw = false;
+
+ if (_state != CLOSED) {
+ // Clean up the OT list
+ g_system->lockMutex(_csModifyInterface);
+ clearOT();
+
+ // DoFrame makes all the objects currently in the inventory be displayed
+ // @@@ Maybe we should do all takeable objects? Please does not help
+ for (int i = 0; i < _nInv; i++) {
+ if (_items[_inv[i]]._icon.doFrame(this, false) && (i >= _curPos && i <= _curPos + 7))
+ bNeedRedraw = true;
+ }
+
+ if ((_state == CLOSING || _state == OPENING || _state == OPENED) && checkPointInside(mpos)) {
+ if (mpos._x > RM_SX - 64) {
+ if (_curPos + 8 < _nInv && !_bBlinkingRight) {
+ _items[28]._icon.setPattern(3);
+ _bBlinkingRight = true;
+ bNeedRedraw = true;
+ }
+ } else if (_bBlinkingRight) {
+ _items[28]._icon.setPattern(2);
+ _bBlinkingRight = false;
+ bNeedRedraw = true;
+ }
+
+ if (mpos._x < 64) {
+ if (_curPos > 0 && !_bBlinkingLeft) {
+ _items[29]._icon.setPattern(3);
+ _bBlinkingLeft = true;
+ bNeedRedraw = true;
+ }
+ } else if (_bBlinkingLeft) {
+ _items[29]._icon.setPattern(2);
+ _bBlinkingLeft = false;
+ bNeedRedraw = true;
+ }
+ }
+
+ if (_items[28]._icon.doFrame(this, false))
+ bNeedRedraw = true;
+
+ if (_items[29]._icon.doFrame(this, false))
+ bNeedRedraw = true;
+
+ if (bNeedRedraw)
+ prepare();
+
+ g_system->unlockMutex(_csModifyInterface);
+ }
+
+ if (g_vm->getEngine()->getInput().getAsyncKeyState(Common::KEYCODE_i)) {
+ GLOBALS._bCfgInvLocked = !GLOBALS._bCfgInvLocked;
+ }
+
+ if (_bCombining) {//m_state == COMBINING)
+ ptr.setCustomPointer(&_items[_nCombine]._pointer[_items[_nCombine]._status - 1]);
+ ptr.setSpecialPointer(RMPointer::PTR_CUSTOM);
+ }
+
+ if (!GLOBALS._bCfgInvUp) {
+ if ((_state == CLOSED) && (mpos._y > RM_SY - 10 || GLOBALS._bCfgInvLocked) && bCanOpen) {
+ if (!GLOBALS._bCfgInvNoScroll) {
+ _state = OPENING;
+ _curPutY = RM_SY - 1;
+ _curPutTime = g_vm->getTime();
+ } else {
+ _state = OPENED;
+ _curPutY = RM_SY - 68;
+ }
+ } else if (_state == OPENED) {
+ if ((mpos._y < RM_SY - 70 && !GLOBALS._bCfgInvLocked) || !bCanOpen) {
+ if (!GLOBALS._bCfgInvNoScroll) {
+ _state = CLOSING;
+ _curPutY = RM_SY - 68;
+ _curPutTime = g_vm->getTime();
+ } else {
+ _state = CLOSED;
+ }
+ }
+ } else if (_state == OPENING) {
+ while (_curPutTime + INVSPEED < g_vm->getTime()) {
+ _curPutY -= 3;
+ _curPutTime += INVSPEED;
+ }
+
+ if (_curPutY <= RM_SY - 68) {
+ _state = OPENED;
+ _curPutY = RM_SY - 68;
+ }
+
+ } else if (_state == CLOSING) {
+ while (_curPutTime + INVSPEED < g_vm->getTime()) {
+ _curPutY += 3;
+ _curPutTime += INVSPEED;
+ }
+
+ if (_curPutY > 480)
+ _state = CLOSED;
+ }
+ } else {
+ if ((_state == CLOSED) && (mpos._y < 10 || GLOBALS._bCfgInvLocked) && bCanOpen) {
+ if (!GLOBALS._bCfgInvNoScroll) {
+ _state = OPENING;
+ _curPutY = - 68;
+ _curPutTime = g_vm->getTime();
+ } else {
+ _state = OPENED;
+ _curPutY = 0;
+ }
+ } else if (_state == OPENED) {
+ if ((mpos._y > 70 && !GLOBALS._bCfgInvLocked) || !bCanOpen) {
+ if (!GLOBALS._bCfgInvNoScroll) {
+ _state = CLOSING;
+ _curPutY = -2;
+ _curPutTime = g_vm->getTime();
+ } else {
+ _state = CLOSED;
+ }
+ }
+ } else if (_state == OPENING) {
+ while (_curPutTime + INVSPEED < g_vm->getTime()) {
+ _curPutY += 3;
+ _curPutTime += INVSPEED;
+ }
+
+ if (_curPutY >= 0) {
+ _state = OPENED;
+ _curPutY = 0;
+ }
+ } else if (_state == CLOSING) {
+ while (_curPutTime + INVSPEED < g_vm->getTime()) {
+ _curPutY -= 3;
+ _curPutTime += INVSPEED;
+ }
+
+ if (_curPutY < -68)
+ _state = CLOSED;
+ }
+ }
+
+ if (_state == SELECTING) {
+ int startx = (_nSelectObj + 1) * 64 - 20;
+ int starty;
+
+ if (!GLOBALS._bCfgInvUp)
+ starty = RM_SY - 109;
+ else
+ starty = 70;
+
+ // Make sure it is on one of the verbs
+ if (mpos._y > starty && mpos._y < starty + 45) {
+ if (mpos._x > startx && mpos._x < startx + 40) {
+ if (_miniAction != 1) {
+ _miniInterface.setPattern(2);
+ _miniAction = 1;
+ g_vm->playUtilSFX(1);
+ }
+ } else if (mpos._x >= startx + 40 && mpos._x < startx + 80) {
+ if (_miniAction != 2) {
+ _miniInterface.setPattern(3);
+ _miniAction = 2;
+ g_vm->playUtilSFX(1);
+ }
+ } else if (mpos._x >= startx + 80 && mpos._x < startx + 108) {
+ if (_miniAction != 3) {
+ _miniInterface.setPattern(4);
+ _miniAction = 3;
+ g_vm->playUtilSFX(1);
+ }
+ } else {
+ _miniInterface.setPattern(1);
+ _miniAction = 0;
+ }
+ } else {
+ _miniInterface.setPattern(1);
+ _miniAction = 0;
+ }
+
+ // Update the mini-interface
+ _miniInterface.doFrame(&bigBuf, false);
+ }
+
+ if ((_state != CLOSED) && !_nInList) {
+ bigBuf.addPrim(new RMGfxPrimitive(this));
+ }
+}
+
+bool RMInventory::itemInFocus(const RMPoint &mpt) {
+ if ((_state == OPENED || _state == OPENING) && checkPointInside(mpt))
+ return true;
+ else
+ return false;
+}
+
+RMItem *RMInventory::whichItemIsIn(const RMPoint &mpt) {
+ if (_state == OPENED) {
+ if (checkPointInside(mpt)) {
+ int n = mpt._x / 64;
+ if (n > 0 && n < RM_SX / 64 - 1 && _inv[n - 1 + _curPos] != 0 && (!_bCombining || _inv[n - 1 + _curPos] != _nCombine))
+ return &_items[_inv[n - 1 + _curPos]]._icon;
+ }
+ }
+
+ return NULL;
+}
+
+int RMInventory::getSaveStateSize() {
+ // m_inv pattern m_nInv
+ return 256 * 4 + 256 * 4 + 4 ;
+}
+
+void RMInventory::saveState(byte *state) {
+ int i, x;
+
+ WRITE_LE_UINT32(state, _nInv);
+ state += 4;
+ Common::copy(_inv, _inv + 256, (uint32 *)state);
+ state += 256 * 4;
+
+ for (i = 0; i < 256; i++) {
+ if (i < _nItems)
+ x = _items[i]._status;
+ else
+ x = 0;
+
+ WRITE_LE_UINT32(state, x);
+ state += 4;
+ }
+}
+
+int RMInventory::loadState(byte *state) {
+ int i, x;
+
+ _nInv = READ_LE_UINT32(state);
+ state += 4;
+ Common::copy((uint32 *)state, (uint32 *)state + 256, _inv);
+ state += 256 * 4;
+
+ for (i = 0; i < 256; i++) {
+ x = READ_LE_UINT32(state);
+ state += 4;
+
+ if (i < _nItems) {
+ _items[i]._status = x;
+ _items[i]._icon.setPattern(x);
+ }
+ }
+
+ _curPos = 0;
+ _bCombining = false;
+
+ _items[29]._icon.setPattern(1);
+
+ if (_nInv > 8)
+ _items[28]._icon.setPattern(2);
+ else
+ _items[28]._icon.setPattern(1);
+
+ prepare();
+ drawOT(Common::nullContext);
+ clearOT();
+
+ return getSaveStateSize();
+}
+
+RMInventory &RMInventory::operator+=(RMItem *item) {
+ addItem(item->mpalCode());
+ return *this;
+}
+
+RMInventory &RMInventory::operator+=(RMItem &item) {
+ addItem(item.mpalCode());
+ return *this;
+}
+
+RMInventory &RMInventory::operator+=(int code) {
+ addItem(code);
+ return *this;
+}
+
+/****************************************************************************\
+* RMInterface methods
+\****************************************************************************/
+
+RMInterface::RMInterface() : RMGfxSourceBuffer8RLEByte() {
+ _bActive = _bPerorate = false;
+ _lastHotZone = -1;
+}
+
+RMInterface::~RMInterface() {
+}
+
+bool RMInterface::active() {
+ return _bActive;
+}
+
+int RMInterface::onWhichBox(RMPoint pt) {
+ int max, i;
+
+ pt -= _openStart;
+
+ // Check how many verbs you have to consider
+ max = 4;
+ if (_bPerorate)
+ max = 5;
+
+ // Find the verb
+ for (i = 0; i < max; i++) {
+ if (_hotbbox[i].ptInRect(pt))
+ return i;
+ }
+
+ // Found no verb
+ return -1;
+}
+
+void RMInterface::draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim) {
+ CORO_BEGIN_CONTEXT;
+ int h;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ prim->getDst().topLeft() = _openStart;
+ CORO_INVOKE_2(RMGfxSourceBuffer8RLEByte::draw, bigBuf, prim);
+
+ // Check if there is a draw hot zone
+ _ctx->h = onWhichBox(_mpos);
+ if (_ctx->h != -1) {
+ prim->getDst().topLeft() = _openStart;
+ CORO_INVOKE_2(_hotzone[_ctx->h].draw, bigBuf, prim);
+
+ if (_lastHotZone != _ctx->h) {
+ _lastHotZone = _ctx->h;
+ g_vm->playUtilSFX(1);
+ }
+
+ if (GLOBALS._bCfgInterTips) {
+ prim->getDst().topLeft() = _openStart + RMPoint(70, 177);
+ CORO_INVOKE_2(_hints[_ctx->h].draw, bigBuf, prim);
+ }
+ } else
+ _lastHotZone = -1;
+
+ CORO_END_CODE;
+}
+
+void RMInterface::doFrame(RMGfxTargetBuffer &bigBuf, RMPoint mousepos) {
+ // If needed, add to the OT schedule list
+ if (!_nInList && _bActive)
+ bigBuf.addPrim(new RMGfxPrimitive(this));
+
+ _mpos = mousepos;
+}
+
+void RMInterface::clicked(const RMPoint &mousepos) {
+ _bActive = true;
+ _openPos = mousepos;
+
+ // Calculate the top left corner of the interface
+ _openStart = _openPos - RMPoint(_dimx / 2, _dimy / 2);
+ _lastHotZone = -1;
+
+ // Keep it inside the screen
+ if (_openStart._x < 0)
+ _openStart._x = 0;
+ if (_openStart._y < 0)
+ _openStart._y = 0;
+ if (_openStart._x + _dimx > RM_SX)
+ _openStart._x = RM_SX - _dimx;
+ if (_openStart._y + _dimy > RM_SY)
+ _openStart._y = RM_SY - _dimy;
+
+ // Play the sound effect
+ g_vm->playUtilSFX(0);
+}
+
+bool RMInterface::released(const RMPoint &mousepos, RMTonyAction &action) {
+ if (!_bActive)
+ return false;
+
+ _bActive = false;
+
+ switch (onWhichBox(mousepos)) {
+ case 0:
+ action = TA_TAKE;
+ break;
+
+ case 1:
+ action = TA_TALK;
+ break;
+
+ case 2:
+ action = TA_USE;
+ break;
+
+ case 3:
+ action = TA_EXAMINE;
+ break;
+
+ case 4:
+ action = TA_PERORATE;
+ break;
+
+ default: // No verb
+ return false;
+ }
+
+ return true;
+}
+
+void RMInterface::reset() {
+ _bActive = false;
+}
+
+void RMInterface::setPerorate(bool bOn) {
+ _bPerorate = bOn;
+}
+
+bool RMInterface::getPerorate() {
+ return _bPerorate;
+}
+
+void RMInterface::init() {
+ int i;
+ RMResRaw inter(RES_I_INTERFACE);
+ RMRes pal(RES_I_INTERPPAL);
+
+ setPriority(191);
+
+ RMGfxSourceBuffer::init(inter, inter.width(), inter.height());
+ loadPaletteWA(RES_I_INTERPAL);
+
+ for (i = 0; i < 5; i++) {
+ RMResRaw part(RES_I_INTERP1 + i);
+
+ _hotzone[i].init(part, part.width(), part.height());
+ _hotzone[i].loadPaletteWA(pal);
+ }
+
+ _hotbbox[0].setRect(126, 123, 159, 208); // Take
+ _hotbbox[1].setRect(90, 130, 125, 186); // About
+ _hotbbox[2].setRect(110, 60, 152, 125);
+ _hotbbox[3].setRect(56, 51, 93, 99);
+ _hotbbox[4].setRect(51, 105, 82, 172);
+
+ _hints[0].setAlignType(RMText::HRIGHT, RMText::VTOP);
+ _hints[1].setAlignType(RMText::HRIGHT, RMText::VTOP);
+ _hints[2].setAlignType(RMText::HRIGHT, RMText::VTOP);
+ _hints[3].setAlignType(RMText::HRIGHT, RMText::VTOP);
+ _hints[4].setAlignType(RMText::HRIGHT, RMText::VTOP);
+
+ // The text is taken from MPAL for translation
+ RMMessage msg0(12);
+ RMMessage msg1(13);
+ RMMessage msg2(14);
+ RMMessage msg3(15);
+ RMMessage msg4(16);
+
+ _hints[0].writeText(msg0[0], 1); // Take
+ _hints[1].writeText(msg1[0], 1); // Talk
+ _hints[2].writeText(msg2[0], 1); // Use
+ _hints[3].writeText(msg3[0], 1); // Examine
+ _hints[4].writeText(msg4[0], 1); // Show Yourself
+
+ _bActive = false;
+ _bPerorate = false;
+ _lastHotZone = 0;
+}
+
+void RMInterface::close() {
+ int i;
+
+ destroy();
+
+ for (i = 0; i < 5; i++)
+ _hotzone[i].destroy();
+}
+
+} // End of namespace Tony
diff --git a/engines/tony/inventory.h b/engines/tony/inventory.h
new file mode 100644
index 0000000000..ce94c86c1b
--- /dev/null
+++ b/engines/tony/inventory.h
@@ -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.
+ *
+ */
+
+/*
+ * This code is based on original Tony Tough source code
+ *
+ * Copyright (c) 1997-2003 Nayma Software
+ */
+
+#ifndef TONY_INVENTORY_H
+#define TONY_INVENTORY_H
+
+#include "common/scummsys.h"
+#include "common/system.h"
+#include "tony/font.h"
+#include "tony/game.h"
+#include "tony/gfxcore.h"
+#include "tony/loc.h"
+
+namespace Tony {
+
+struct RMInventoryItem {
+ RMItem _icon;
+ RMGfxSourceBuffer8RLEByteAA *_pointer;
+ int _status;
+};
+
+class RMInventory : public RMGfxWoodyBuffer {
+private:
+ enum InventoryState {
+ CLOSED,
+ OPENING,
+ OPENED,
+ CLOSING,
+ SELECTING
+ };
+
+protected:
+ int _nItems;
+ RMInventoryItem *_items;
+
+ int _inv[256];
+ int _nInv;
+ int _curPutY;
+ uint32 _curPutTime;
+
+ int _curPos;
+ InventoryState _state;
+ bool _bHasFocus;
+ int _nSelectObj;
+ int _nCombine;
+ bool _bCombining;
+
+ bool _bBlinkingRight, _bBlinkingLeft;
+
+ int _miniAction;
+ RMItem _miniInterface;
+ RMText _hints[3];
+
+ OSystem::MutexRef _csModifyInterface;
+
+protected:
+ /**
+ * Prepare the image inventory. It should be recalled whenever the inventory changes
+ */
+ void prepare();
+
+ /**
+ * Check if the mouse Y position is conrrect, even under the inventory portion of the screen
+ */
+ bool checkPointInside(const RMPoint &pt);
+
+public:
+ RMInventory();
+ virtual ~RMInventory();
+
+ /**
+ * Prepare a frame
+ */
+ void doFrame(RMGfxTargetBuffer &bigBuf, RMPointer &ptr, RMPoint mpos, bool bCanOpen);
+
+ /**
+ * Initialization and closing
+ */
+ void init();
+ void close();
+ void reset();
+
+ /**
+ * Overload test for removal from OT list
+ */
+ virtual void removeThis(CORO_PARAM, bool &result);
+
+ /**
+ * Overload the drawing of the inventory
+ */
+ virtual void draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim);
+
+ /**
+ * Method for determining whether the inventory currently has the focus
+ */
+ bool haveFocus(const RMPoint &mpos);
+
+ /**
+ * Method for determining if the mini interface is active
+ */
+ bool miniActive();
+
+ /**
+ * Handle the left mouse click (only when the inventory has the focus)
+ */
+ bool leftClick(const RMPoint &mpos, int &nCombineObj);
+
+ /**
+ * Handle the right mouse button (only when the inventory has the focus)
+ */
+ void rightClick(const RMPoint &mpos);
+ bool rightRelease(const RMPoint &mpos, RMTonyAction &curAction);
+
+ /**
+ * Warn that an item combine is over
+ */
+ void endCombine();
+
+public:
+ /**
+ * Add an item to the inventory
+ */
+ void addItem(int code);
+ RMInventory &operator+=(RMItem *item);
+ RMInventory &operator+=(RMItem &item);
+ RMInventory &operator+=(int code);
+
+ /**
+ * Removes an item
+ */
+ void removeItem(int code);
+
+ /**
+ * We are on an object?
+ */
+ RMItem *whichItemIsIn(const RMPoint &mpt);
+ bool itemInFocus(const RMPoint &mpt);
+
+ /**
+ * Change the icon of an item
+ */
+ void changeItemStatus(uint32 dwCode, uint32 dwStatus);
+
+ /**
+ * Save methods
+ */
+ int getSaveStateSize();
+ void saveState(byte *state);
+ int loadState(byte *state);
+};
+
+
+class RMInterface : public RMGfxSourceBuffer8RLEByte {
+private:
+ bool _bActive;
+ RMPoint _mpos;
+ RMPoint _openPos;
+ RMPoint _openStart;
+ RMText _hints[5];
+ RMGfxSourceBuffer8RLEByte _hotzone[5];
+ RMRect _hotbbox[5];
+ bool _bPerorate;
+ int _lastHotZone;
+
+protected:
+ /**
+ * Return which box a given point is in
+ */
+ int onWhichBox(RMPoint pt);
+
+public:
+ RMInterface();
+ virtual ~RMInterface();
+
+ /**
+ * The usual DoFrame (poll the graphics engine)
+ */
+ void doFrame(RMGfxTargetBuffer &bigBuf, RMPoint mousepos);
+
+ /**
+ * TRUE if it is active (you can select items)
+ */
+ bool active();
+
+ /**
+ * Initialization
+ */
+ void init();
+ void close();
+
+ /**
+ * Reset the interface
+ */
+ void reset();
+
+ /**
+ * Warns of mouse clicks and releases
+ */
+ void clicked(const RMPoint &mousepos);
+ bool released(const RMPoint &mousepos, RMTonyAction &action);
+
+ /**
+ * Enables or disables the fifth verb
+ */
+ void setPerorate(bool bOn);
+ bool getPerorate();
+
+ /**
+ * Overloaded Draw
+ */
+ virtual void draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim);
+};
+
+} // End of namespace Tony
+
+#endif
diff --git a/engines/tony/loc.cpp b/engines/tony/loc.cpp
new file mode 100644
index 0000000000..4fe19594f9
--- /dev/null
+++ b/engines/tony/loc.cpp
@@ -0,0 +1,2322 @@
+/* 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.
+ *
+ */
+
+/*
+ * This code is based on original Tony Tough source code
+ *
+ * Copyright (c) 1997-2003 Nayma Software
+ */
+
+#include "common/memstream.h"
+#include "common/scummsys.h"
+#include "tony/mpal/mpalutils.h"
+#include "tony/game.h"
+#include "tony/loc.h"
+#include "tony/tony.h"
+
+namespace Tony {
+
+using namespace ::Tony::MPAL;
+
+
+/****************************************************************************\
+* RMPalette Methods
+\****************************************************************************/
+
+void RMPalette::readFromStream(Common::ReadStream &ds) {
+ ds.read(_data, 1024);
+}
+
+/****************************************************************************\
+* RMSlot Methods
+\****************************************************************************/
+
+void RMPattern::RMSlot::readFromStream(Common::ReadStream &ds, bool bLOX) {
+ byte type;
+
+ // Type
+ type = ds.readByte();
+ _type = (RMPattern::RMSlotType)type;
+
+ // Data
+ _data = ds.readSint32LE();
+
+ // Position
+ _pos.readFromStream(ds);
+
+ // Generic flag
+ _flag = ds.readByte();
+}
+
+
+/****************************************************************************\
+* RMPattern Methods
+\****************************************************************************/
+
+void RMPattern::readFromStream(Common::ReadStream &ds, bool bLOX) {
+ int i;
+
+ // Pattern name
+ if (!bLOX)
+ _name = readString(ds);
+
+ // Velocity
+ _speed = ds.readSint32LE();
+
+ // Position
+ _pos.readFromStream(ds);
+
+ // Flag for pattern looping
+ _bLoop = ds.readSint32LE();
+
+ // Number of slots
+ _nSlots = ds.readSint32LE();
+
+ // Create and read the slots
+ _slots = new RMSlot[_nSlots];
+
+ for (i = 0; i < _nSlots && !ds.err(); i++) {
+ if (bLOX)
+ _slots[i].readFromStream(ds, true);
+ else
+ _slots[i].readFromStream(ds, false);
+ }
+}
+
+void RMPattern::updateCoord() {
+ _curPos = _pos + _slots[_nCurSlot].pos();
+}
+
+void RMPattern::stopSfx(RMSfx *sfx) {
+ for (int i = 0; i < _nSlots; i++) {
+ if (_slots[i]._type == SOUND) {
+ if (!sfx[_slots[i]._data]._name.empty() && sfx[_slots[i]._data]._name[0] == '_')
+ sfx[_slots[i]._data].stop();
+ else if (GLOBALS._bSkipSfxNoLoop)
+ sfx[_slots[i]._data].stop();
+ }
+ }
+}
+
+int RMPattern::init(RMSfx *sfx, bool bPlayP0, byte *bFlag) {
+ int i;
+
+ // Read the current time
+ _nStartTime = g_vm->getTime();
+ _nCurSlot = 0;
+
+ // Find the first frame of the pattern
+ i = 0;
+ while (_slots[i]._type != SPRITE) {
+ assert(i + 1 < _nSlots);
+ i++;
+ }
+
+ _nCurSlot = i;
+ _nCurSprite = _slots[i]._data;
+ if (bFlag)
+ *bFlag = _slots[i]._flag;
+
+ // Calculate the current coordinates
+ updateCoord();
+
+ // Check for sound:
+ // If the slot is 0, play
+ // If speed == 0, must play unless it goes into loop '_', or if specified by the parameter
+ // If speed != 0, play only the loop
+ for (i = 0; i < _nSlots; i++) {
+ if (_slots[i]._type == SOUND) {
+ if (i == 0) {
+ if (!sfx[_slots[i]._data]._name.empty() && sfx[_slots[i]._data]._name[0] == '_') {
+ sfx[_slots[i]._data].setVolume(_slots[i].pos()._x);
+ sfx[_slots[i]._data].play(true);
+ } else {
+ sfx[_slots[i]._data].setVolume(_slots[i].pos()._x);
+ sfx[_slots[i]._data].play();
+ }
+ } else if (_speed == 0) {
+ if (bPlayP0) {
+ sfx[_slots[i]._data].setVolume(_slots[i].pos()._x);
+ sfx[_slots[i]._data].play();
+ } else if (!sfx[_slots[i]._data]._name.empty() && sfx[_slots[i]._data]._name[0] == '_') {
+ sfx[_slots[i]._data].setVolume(_slots[i].pos()._x);
+ sfx[_slots[i]._data].play(true);
+ }
+ } else {
+ if (_bLoop && !sfx[_slots[i]._data]._name.empty() && sfx[_slots[i]._data]._name[0] == '_') {
+ sfx[_slots[i]._data].setVolume(_slots[i].pos()._x);
+ sfx[_slots[i]._data].play(true);
+ }
+ }
+ }
+ }
+
+ return _nCurSprite;
+}
+
+int RMPattern::update(uint32 hEndPattern, byte &bFlag, RMSfx *sfx) {
+ int CurTime = g_vm->getTime();
+
+ // If the speed is 0, then the pattern never advances
+ if (_speed == 0) {
+ CoroScheduler.pulseEvent(hEndPattern);
+ bFlag = _slots[_nCurSlot]._flag;
+ return _nCurSprite;
+ }
+
+ // Is it time to change the slots?
+ while (_nStartTime + _speed <= (uint32)CurTime) {
+ _nStartTime += _speed;
+ if (_slots[_nCurSlot]._type == SPRITE)
+ _nCurSlot++;
+ if (_nCurSlot == _nSlots) {
+ _nCurSlot = 0;
+ bFlag = _slots[_nCurSlot]._flag;
+
+ CoroScheduler.pulseEvent(hEndPattern);
+
+ // @@@ If there is no loop pattern, and there's a warning that it's the final
+ // frame, then remain on the last frame
+ if (!_bLoop) {
+ _nCurSlot = _nSlots - 1;
+ bFlag = _slots[_nCurSlot]._flag;
+ return _nCurSprite;
+ }
+ }
+
+ for (;;) {
+ switch (_slots[_nCurSlot]._type) {
+ case SPRITE:
+ // Read the next sprite
+ _nCurSprite = _slots[_nCurSlot]._data;
+
+ // Update the parent & child coordinates
+ updateCoord();
+ break;
+
+ case SOUND:
+ if (sfx != NULL) {
+ sfx[_slots[_nCurSlot]._data].setVolume(_slots[_nCurSlot].pos()._x);
+
+ if (sfx[_slots[_nCurSlot]._data]._name.empty() || sfx[_slots[_nCurSlot]._data]._name[0] != '_')
+ sfx[_slots[_nCurSlot]._data].play(false);
+ else
+ sfx[_slots[_nCurSlot]._data].play(true);
+ }
+ break;
+
+ case COMMAND:
+ assert(0);
+ break;
+
+ default:
+ assert(0);
+ break;
+ }
+
+ if (_slots[_nCurSlot]._type == SPRITE)
+ break;
+ _nCurSlot++;
+ }
+ }
+
+ // Return the current sprite
+ bFlag = _slots[_nCurSlot]._flag;
+ return _nCurSprite;
+}
+
+RMPattern::RMPattern() {
+ _slots = NULL;
+ _speed = 0;
+ _bLoop = 0;
+ _nSlots = 0;
+ _nCurSlot = 0;
+ _nCurSprite = 0;
+ _nStartTime = 0;
+ _slots = NULL;
+}
+
+/**
+ * Reads the position of the pattern
+ */
+RMPoint RMPattern::pos() {
+ return _curPos;
+}
+
+RMPattern::~RMPattern() {
+ if (_slots != NULL) {
+ delete[] _slots;
+ _slots = NULL;
+ }
+}
+
+/****************************************************************************\
+* RMSprite Methods
+\****************************************************************************/
+
+void RMSprite::init(RMGfxSourceBuffer *buf) {
+ _buf = buf;
+}
+
+void RMSprite::LOXGetSizeFromStream(Common::SeekableReadStream &ds, int *dimx, int *dimy) {
+ uint32 pos = ds.pos();
+
+ *dimx = ds.readSint32LE();
+ *dimy = ds.readSint32LE();
+
+ ds.seek(pos);
+}
+
+void RMSprite::getSizeFromStream(Common::SeekableReadStream &ds, int *dimx, int *dimy) {
+ uint32 pos = ds.pos();
+
+ _name = readString(ds);
+ *dimx = ds.readSint32LE();
+ *dimy = ds.readSint32LE();
+
+ ds.seek(pos);
+}
+
+void RMSprite::readFromStream(Common::SeekableReadStream &ds, bool bLOX) {
+ int dimx, dimy;
+
+ // Sprite name
+ if (!bLOX)
+ _name = readString(ds);
+
+ // Dimensions
+ dimx = ds.readSint32LE();
+ dimy = ds.readSint32LE();
+
+ // Bounding box
+ _rcBox.readFromStream(ds);
+
+ // Unused space
+ if (!bLOX)
+ ds.skip(32);
+
+ // Create buffer and read
+ _buf->init(ds, dimx, dimy);
+}
+
+void RMSprite::draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim) {
+ _buf->draw(coroParam, bigBuf, prim);
+}
+
+void RMSprite::setPalette(byte *buf) {
+ ((RMGfxSourceBufferPal *)_buf)->loadPalette(buf);
+}
+
+RMSprite::RMSprite() {
+ _buf = NULL;
+}
+
+RMSprite::~RMSprite() {
+ if (_buf) {
+ delete _buf;
+ _buf = NULL;
+ }
+}
+
+
+/****************************************************************************\
+* RMSfx Methods
+\****************************************************************************/
+
+void RMSfx::readFromStream(Common::ReadStream &ds, bool bLOX) {
+ int size;
+
+ // sfx name
+ _name = readString(ds);
+
+ size = ds.readSint32LE();
+
+ // Read the entire buffer into a MemoryReadStream
+ byte *buffer = (byte *)malloc(size);
+ ds.read(buffer, size);
+ Common::SeekableReadStream *stream = new Common::MemoryReadStream(buffer, size, DisposeAfterUse::YES);
+
+ // Create the sound effect
+ _fx = g_vm->createSFX(stream);
+ _fx->setLoop(false);
+}
+
+RMSfx::RMSfx() {
+ _fx = NULL;
+ _bPlayingLoop = false;
+}
+
+RMSfx::~RMSfx() {
+ if (_fx) {
+ _fx->release();
+ _fx = NULL;
+ }
+}
+
+void RMSfx::play(bool bLoop) {
+ if (_fx && !_bPlayingLoop) {
+ _fx->setLoop(bLoop);
+ _fx->play();
+
+ if (bLoop)
+ _bPlayingLoop = true;
+ }
+}
+
+void RMSfx::setVolume(int vol) {
+ if (_fx) {
+ _fx->setVolume(vol);
+ }
+}
+
+void RMSfx::pause(bool bPause) {
+ if (_fx) {
+ _fx->pause(bPause);
+ }
+}
+
+void RMSfx::stop() {
+ if (_fx) {
+ _fx->stop();
+ _bPlayingLoop = false;
+ }
+}
+
+
+
+/****************************************************************************\
+* RMItem Methods
+\****************************************************************************/
+
+int RMItem::getCurPattern() {
+ return _nCurPattern;
+}
+
+RMGfxSourceBuffer *RMItem::newItemSpriteBuffer(int dimx, int dimy, bool bPreRLE) {
+ if (_cm == CM_256) {
+ RMGfxSourceBuffer8RLE *spr;
+
+ if (_FX == 2) { // AB
+ spr = new RMGfxSourceBuffer8RLEWordAB;
+ } else if (_FX == 1) { // OMBRA+AA
+ if (dimx == -1 || dimx > 255)
+ spr = new RMGfxSourceBuffer8RLEWordAA;
+ else
+ spr = new RMGfxSourceBuffer8RLEByteAA;
+
+ spr->setAlphaBlendColor(_FXparm);
+ if (bPreRLE)
+ spr->setAlreadyCompressed();
+ } else {
+ if (dimx == -1 || dimx > 255)
+ spr = new RMGfxSourceBuffer8RLEWord;
+ else
+ spr = new RMGfxSourceBuffer8RLEByte;
+
+ if (bPreRLE)
+ spr->setAlreadyCompressed();
+ }
+
+ return spr;
+ } else
+ return new RMGfxSourceBuffer16;
+}
+
+bool RMItem::isIn(const RMPoint &pt, int *size) {
+ RMRect rc;
+
+ if (!_bIsActive)
+ return false;
+
+ // Search for the right bounding box to use - use the sprite's if it has one, otherwise use the generic one
+ if (_nCurPattern != 0 && !_sprites[_nCurSprite]._rcBox.isEmpty())
+ rc = _sprites[_nCurSprite]._rcBox + calculatePos();
+ else if (!_rcBox.isEmpty())
+ rc = _rcBox;
+ // If no box, return immediately
+ else
+ return false;
+
+ if (size != NULL)
+ *size = rc.size();
+
+ return rc.ptInRect(pt + _curScroll);
+}
+
+void RMItem::readFromStream(Common::SeekableReadStream &ds, bool bLOX) {
+ int i, dimx, dimy;
+ byte cm;
+
+ // MPAL code
+ _mpalCode = ds.readSint32LE();
+
+ // Object name
+ _name = readString(ds);
+
+ // Z (signed)
+ _z = ds.readSint32LE();
+
+ // Parent position
+ _pos.readFromStream(ds);
+
+ // Hotspot
+ _hot.readFromStream(ds);
+
+ // Bounding box
+ _rcBox.readFromStream(ds);
+
+ // Number of sprites, sound effects, and patterns
+ _nSprites = ds.readSint32LE();
+ _nSfx = ds.readSint32LE();
+ _nPatterns = ds.readSint32LE();
+
+ // Color mode
+ cm = ds.readByte();
+ _cm = (RMColorMode)cm;
+
+ // Flag for the presence of custom palette differences
+ _bPal = ds.readByte();
+
+ if (_cm == CM_256) {
+ // If there is a palette, read it in
+ if (_bPal)
+ _pal.readFromStream(ds);
+ }
+
+ // MPAL data
+ if (!bLOX)
+ ds.skip(20);
+
+ _FX = ds.readByte();
+ _FXparm = ds.readByte();
+
+ if (!bLOX)
+ ds.skip(106);
+
+ // Create sub-classes
+ if (_nSprites > 0)
+ _sprites = new RMSprite[_nSprites];
+ if (_nSfx > 0)
+ _sfx = new RMSfx[_nSfx];
+ _patterns = new RMPattern[_nPatterns + 1];
+
+ // Read in class data
+ if (!ds.err())
+ for (i = 0; i < _nSprites && !ds.err(); i++) {
+ // Download the sprites
+ if (bLOX) {
+ _sprites[i].LOXGetSizeFromStream(ds, &dimx, &dimy);
+ _sprites[i].init(newItemSpriteBuffer(dimx, dimy, true));
+ _sprites[i].readFromStream(ds, true);
+ } else {
+ _sprites[i].getSizeFromStream(ds, &dimx, &dimy);
+ _sprites[i].init(newItemSpriteBuffer(dimx, dimy, false));
+ _sprites[i].readFromStream(ds, false);
+ }
+
+ if (_cm == CM_256 && _bPal)
+ _sprites[i].setPalette(_pal._data);
+ }
+
+ if (!ds.err())
+ for (i = 0; i < _nSfx && !ds.err(); i++) {
+ if (bLOX)
+ _sfx[i].readFromStream(ds, true);
+ else
+ _sfx[i].readFromStream(ds, false);
+ }
+
+ // Read the pattern from pattern 1
+ if (!ds.err())
+ for (i = 1; i <= _nPatterns && !ds.err(); i++) {
+ if (bLOX)
+ _patterns[i].readFromStream(ds, true);
+ else
+ _patterns[i].readFromStream(ds, false);
+ }
+
+ // Initialize the current pattern
+ if (_bInitCurPattern)
+ setPattern(mpalQueryItemPattern(_mpalCode));
+
+ // Initialize the current activation state
+ _bIsActive = mpalQueryItemIsActive(_mpalCode);
+}
+
+
+RMGfxPrimitive *RMItem::newItemPrimitive() {
+ return new RMGfxPrimitive(this);
+}
+
+void RMItem::setScrollPosition(const RMPoint &scroll) {
+ _curScroll = scroll;
+}
+
+bool RMItem::doFrame(RMGfxTargetBuffer *bigBuf, bool bAddToList) {
+ int oldSprite = _nCurSprite;
+
+ // Pattern 0 = Do not draw anything!
+ if (_nCurPattern == 0)
+ return false;
+
+ // We do an update of the pattern, which also returns the current frame
+ if (_nCurPattern != 0) {
+ _nCurSprite = _patterns[_nCurPattern].update(_hEndPattern, _bCurFlag, _sfx);
+
+ // WORKAROUND: Currently, m_nCurSprite = -1 is used to flag that an item should be removed.
+ // However, this seems to be done inside a process waiting on an event pulsed inside the pattern
+ // Update method. So the value of m_nCurSprite = -1 is being destroyed with the return value
+ // replacing it. It may be that the current coroutine PulseEvent implementation is wrong somehow.
+ // In any case, a special check here is done for items that have ended
+ if (_nCurPattern == 0)
+ _nCurSprite = -1;
+ }
+
+ // If the function returned -1, it means that the pattern has finished
+ if (_nCurSprite == -1) {
+ // We have pattern 0, so leave. The class will self de-register from the OT list
+ _nCurPattern = 0;
+ return false;
+ }
+
+ // If we are not in the OT list, add ourselves
+ if (!_nInList && bAddToList)
+ bigBuf->addPrim(newItemPrimitive());
+
+ return oldSprite != _nCurSprite;
+}
+
+RMPoint RMItem::calculatePos() {
+ return _pos + _patterns[_nCurPattern].pos();
+}
+
+void RMItem::draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim) {
+ CORO_BEGIN_CONTEXT;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ // If CurSprite == -1, then the pattern is finished
+ if (_nCurSprite == -1)
+ return;
+
+ // Set the flag
+ prim->setFlag(_bCurFlag);
+
+ // Offset direction for scrolling
+ prim->getDst().offset(-_curScroll);
+
+ // We must offset the cordinates of the item inside the primitive
+ // It is estimated as nonno + (babbo + figlio)
+ prim->getDst().offset(calculatePos());
+
+ // No stretching, please
+ prim->setStretch(false);
+
+ // Now we turn to the generic surface drawing routines
+ CORO_INVOKE_2(_sprites[_nCurSprite].draw, bigBuf, prim);
+
+ CORO_END_CODE;
+}
+
+/**
+ * Overloaded priority: it's based on Z ordering
+ */
+int RMItem::priority() {
+ return _z;
+}
+
+/**
+ * Pattern number
+ */
+int RMItem::numPattern() {
+ return _nPatterns;
+}
+
+void RMItem::removeThis(CORO_PARAM, bool &result) {
+ // Remove from the OT list if the current frame is -1 (pattern over)
+ result = (_nCurSprite == -1);
+}
+
+
+void RMItem::setStatus(int nStatus) {
+ _bIsActive = (nStatus > 0);
+}
+
+RMPoint RMItem::hotspot() {
+ return _hot;
+}
+
+int RMItem::mpalCode() {
+ return _mpalCode;
+}
+
+void RMItem::setPattern(int nPattern, bool bPlayP0) {
+ assert(nPattern >= 0 && nPattern <= _nPatterns);
+
+ if (_sfx) {
+ if (_nCurPattern > 0)
+ _patterns[_nCurPattern].stopSfx(_sfx);
+ }
+
+ // Remember the current pattern
+ _nCurPattern = nPattern;
+
+ // Start the pattern to start the animation
+ if (_nCurPattern != 0)
+ _nCurSprite = _patterns[_nCurPattern].init(_sfx, bPlayP0, &_bCurFlag);
+ else {
+ _nCurSprite = -1;
+
+ // Look for the sound effect for pattern 0
+ if (bPlayP0) {
+ for (int i = 0; i < _nSfx; i++) {
+ if (_sfx[i]._name == "p0")
+ _sfx[i].play();
+ }
+ }
+ }
+}
+
+bool RMItem::getName(Common::String &name) {
+ char buf[256];
+
+ mpalQueryItemName(_mpalCode, buf);
+ name = buf;
+ if (buf[0] == '\0')
+ return false;
+ return true;
+}
+
+void RMItem::unload() {
+ if (_patterns != NULL) {
+ delete[] _patterns;
+ _patterns = NULL;
+ }
+
+ if (_sprites != NULL) {
+ delete[] _sprites;
+ _sprites = NULL;
+ }
+
+ if (_sfx != NULL) {
+ delete[] _sfx;
+ _sfx = NULL;
+ }
+}
+
+RMItem::RMItem() {
+ _bCurFlag = 0;
+ _patterns = NULL;
+ _sprites = NULL;
+ _sfx = NULL;
+ _curScroll.set(0, 0);
+ _bInitCurPattern = true;
+ _nCurPattern = 0;
+ _z = 0;
+ _cm = CM_256;
+ _FX = 0;
+ _FXparm = 0;
+ _mpalCode = 0;
+ _nSprites = 0;
+ _nSfx = 0;
+ _nPatterns = 0;
+ _bPal = 0;
+ _nCurSprite = 0;
+
+ _bIsActive = false;
+ memset(_pal._data, 0, sizeof(_pal._data));
+
+ _hEndPattern = CoroScheduler.createEvent(false, false);
+}
+
+RMItem::~RMItem() {
+ unload();
+ CoroScheduler.closeEvent(_hEndPattern);
+}
+
+
+void RMItem::waitForEndPattern(CORO_PARAM, uint32 hCustomSkip) {
+ CORO_BEGIN_CONTEXT;
+ uint32 h[2];
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ if (_nCurPattern != 0) {
+ if (hCustomSkip == CORO_INVALID_PID_VALUE)
+ CORO_INVOKE_2(CoroScheduler.waitForSingleObject, _hEndPattern, CORO_INFINITE);
+ else {
+ _ctx->h[0] = hCustomSkip;
+ _ctx->h[1] = _hEndPattern;
+ CORO_INVOKE_4(CoroScheduler.waitForMultipleObjects, 2, &_ctx->h[0], false, CORO_INFINITE);
+ }
+ }
+
+ CORO_END_CODE;
+}
+
+void RMItem::changeHotspot(const RMPoint &pt) {
+ _hot = pt;
+}
+
+void RMItem::setInitCurPattern(bool status) {
+ _bInitCurPattern = status;
+}
+
+void RMItem::playSfx(int nSfx) {
+ if (nSfx < _nSfx)
+ _sfx[nSfx].play();
+}
+
+void RMItem::pauseSound(bool bPause) {
+ int i;
+
+ for (i = 0; i < _nSfx; i++)
+ _sfx[i].pause(bPause);
+}
+
+
+
+/****************************************************************************\
+* RMWipe Methods
+\****************************************************************************/
+
+
+RMWipe::RMWipe() {
+ _hUnregistered = CoroScheduler.createEvent(false, false);
+ _hEndOfFade = CoroScheduler.createEvent(false, false);
+
+ _bMustRegister = false;
+ _bUnregister = false;
+ _bEndFade = false;
+ _bFading = false;
+ _nFadeStep = 0;
+
+}
+
+RMWipe::~RMWipe() {
+ CoroScheduler.closeEvent(_hUnregistered);
+ CoroScheduler.closeEvent(_hEndOfFade);
+}
+
+int RMWipe::priority() {
+ return 200;
+}
+
+void RMWipe::Unregister() {
+ RMGfxTask::Unregister();
+ assert(_nInList == 0);
+ CoroScheduler.setEvent(_hUnregistered);
+}
+
+void RMWipe::removeThis(CORO_PARAM, bool &result) {
+ result = _bUnregister;
+}
+
+void RMWipe::waitForFadeEnd(CORO_PARAM) {
+ CORO_BEGIN_CONTEXT;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ CORO_INVOKE_2(CoroScheduler.waitForSingleObject, _hEndOfFade, CORO_INFINITE);
+
+ _bEndFade = true;
+ _bFading = false;
+
+ CORO_INVOKE_2(CoroScheduler.waitForSingleObject, g_vm->_hEndOfFrame, CORO_INFINITE);
+ CORO_INVOKE_2(CoroScheduler.waitForSingleObject, g_vm->_hEndOfFrame, CORO_INFINITE);
+
+ CORO_END_CODE;
+}
+
+void RMWipe::closeFade() {
+ _wip0r.unload();
+}
+
+void RMWipe::initFade(int type) {
+ // Activate the fade
+ _bUnregister = false;
+ _bEndFade = false;
+
+ _nFadeStep = 0;
+
+ _bMustRegister = true;
+
+ RMRes res(RES_W_CIRCLE);
+ Common::SeekableReadStream *ds = res.getReadStream();
+ _wip0r.readFromStream(*ds);
+ delete ds;
+
+ _wip0r.setPattern(1);
+
+ _bFading = true;
+}
+
+void RMWipe::doFrame(RMGfxTargetBuffer &bigBuf) {
+ if (_bMustRegister) {
+ bigBuf.addPrim(new RMGfxPrimitive(this));
+ _bMustRegister = false;
+ }
+
+ if (_bFading) {
+ _wip0r.doFrame(&bigBuf, false);
+
+ _nFadeStep++;
+
+ if (_nFadeStep == 10) {
+ CoroScheduler.setEvent(_hEndOfFade);
+ }
+ }
+}
+
+void RMWipe::draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim) {
+ CORO_BEGIN_CONTEXT;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ if (_bFading) {
+ CORO_INVOKE_2(_wip0r.draw, bigBuf, prim);
+ }
+
+ if (_bEndFade)
+ Common::fill((byte *)bigBuf, (byte *)bigBuf + bigBuf.getDimx() * bigBuf.getDimy() * 2, 0x0);
+
+ CORO_END_CODE;
+}
+
+/****************************************************************************\
+* RMCharacter Methods
+\****************************************************************************/
+
+/****************************************************************************/
+/* Find the shortest path between two nodes of the graph connecting the BOX */
+/* Returns path along the vector path path[] */
+/****************************************************************************/
+
+short RMCharacter::findPath(short source, short destination) {
+ static RMBox box[MAXBOXES]; // Matrix of adjacent boxes
+ static short nodeCost[MAXBOXES]; // Cost per node
+ static short valid[MAXBOXES]; // 0:Invalid 1:Valid 2:Saturated
+ static short nextNode[MAXBOXES]; // Next node
+ short minCost, error = 0;
+ RMBoxLoc *cur;
+
+ g_system->lockMutex(_csMove);
+
+ if (source == -1 || destination == -1) {
+ g_system->unlockMutex(_csMove);
+ return 0;
+ }
+
+ // Get the boxes
+ cur = _theBoxes->getBoxes(_curLocation);
+
+ // Make a backup copy to work on
+ for (int i = 0; i < cur->_numbBox; i++)
+ memcpy(&box[i], &cur->_boxes[i], sizeof(RMBox));
+
+ // Invalidate all nodes
+ for (int i = 0; i < cur->_numbBox; i++)
+ valid[i] = 0;
+
+ // Prepare source and variables for the procedure
+ nodeCost[source] = 0;
+ valid[source] = 1;
+ bool finish = false;
+
+ // Find the shortest path
+ while (!finish) {
+ minCost = 32000; // Reset the minimum cost
+ error = 1; // Possible error
+
+ // 1st cycle: explore possible new nodes
+ for (int i = 0; i < cur->_numbBox; i++)
+ if (valid[i] == 1) {
+ error = 0; // Failure de-bunked
+ int j = 0;
+ while (((box[i]._adj[j]) != 1) && (j < cur->_numbBox))
+ j++;
+
+ if (j >= cur->_numbBox)
+ valid[i] = 2; // nodo saturated?
+ else {
+ nextNode[i] = j;
+ if (nodeCost[i] + 1 < minCost)
+ minCost = nodeCost[i] + 1;
+ }
+ }
+
+ if (error)
+ finish = true; // All nodes saturated
+
+ // 2nd cycle: adding new nodes that were found, saturate old nodes
+ for (int i = 0; i < cur->_numbBox; i++)
+ if ((valid[i] == 1) && ((nodeCost[i] + 1) == minCost)) {
+ box[i]._adj[nextNode[i]] = 2;
+ nodeCost[nextNode[i]] = minCost;
+ valid[nextNode[i]] = 1;
+ for (int j = 0; j < cur->_numbBox; j++)
+ if (box[j]._adj[nextNode[i]] == 1)
+ box[j]._adj[nextNode[i]] = 0;
+
+ if (nextNode[i] == destination)
+ finish = true;
+ }
+ }
+
+ // Remove the path from the adjacent modified matrixes
+ if (!error) {
+ _pathLength = nodeCost[destination];
+ short k = _pathLength;
+ _path[k] = destination;
+
+ while (_path[k] != source) {
+ int i = 0;
+ while (box[i]._adj[_path[k]] != 2)
+ i++;
+ k--;
+ _path[k] = i;
+ }
+
+ _pathLength++;
+ }
+
+ g_system->unlockMutex(_csMove);
+
+ return !error;
+}
+
+
+void RMCharacter::goTo(CORO_PARAM, RMPoint destcoord, bool bReversed) {
+ CORO_BEGIN_CONTEXT;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ if (_pos == destcoord) {
+ if (_minPath == 0) {
+ CORO_INVOKE_0(stop);
+ CoroScheduler.pulseEvent(_hEndOfPath);
+ return;
+ }
+ }
+
+ _status = WALK;
+ _lineStart = _pos;
+ _lineEnd = destcoord;
+ _dx = _lineStart._x - _lineEnd._x;
+ _dy = _lineStart._y - _lineEnd._y;
+ _fx = _dx;
+ _fy = _dy;
+ _dx = ABS(_dx);
+ _dy = ABS(_dy);
+ _walkSpeed = _curSpeed;
+ _walkCount = 0;
+
+ if (bReversed) {
+ while (0) ;
+ }
+
+ int nPatt = getCurPattern();
+
+ if (_dx > _dy) {
+ _slope = _fy / _fx;
+ if (_lineEnd._x < _lineStart._x)
+ _walkSpeed = -_walkSpeed;
+ _walkStatus = 1;
+
+ // Change the pattern for the new direction
+ _bNeedToStop = true;
+ if ((_walkSpeed < 0 && !bReversed) || (_walkSpeed >= 0 && bReversed)) {
+ if (nPatt != PAT_WALKLEFT)
+ setPattern(PAT_WALKLEFT);
+ } else {
+ if (nPatt != PAT_WALKRIGHT)
+ setPattern(PAT_WALKRIGHT);
+ }
+ } else {
+ _slope = _fx / _fy;
+ if (_lineEnd._y < _lineStart._y)
+ _walkSpeed = -_walkSpeed;
+ _walkStatus = 0;
+
+ _bNeedToStop = true;
+ if ((_walkSpeed < 0 && !bReversed) || (_walkSpeed >= 0 && bReversed)) {
+ if (nPatt != PAT_WALKUP)
+ setPattern(PAT_WALKUP);
+ } else {
+ if (nPatt != PAT_WALKDOWN)
+ setPattern(PAT_WALKDOWN);
+ }
+ }
+
+ _olddx = _dx;
+ _olddy = _dy;
+
+ CORO_END_CODE;
+}
+
+
+RMPoint RMCharacter::searching(char UP, char DOWN, char RIGHT, char LEFT, RMPoint punto) {
+ short passi, minimo;
+ RMPoint nuovo, trovato;
+ minimo = 32000;
+
+ if (UP) {
+ nuovo = punto;
+ passi = 0;
+ while ((inWhichBox(nuovo) == -1) && (nuovo._y >= 0)) {
+ nuovo._y--;
+ passi++;
+ }
+ if ((inWhichBox(nuovo) != -1) && (passi < minimo) &&
+ findPath(inWhichBox(_pos), inWhichBox(nuovo))) {
+ minimo = passi;
+ nuovo._y--; // to avoid error?
+ trovato = nuovo;
+ }
+ }
+
+ if (DOWN) {
+ nuovo = punto;
+ passi = 0;
+ while ((inWhichBox(nuovo) == -1) && (nuovo._y < 480)) {
+ nuovo._y++;
+ passi++;
+ }
+ if ((inWhichBox(nuovo) != -1) && (passi < minimo) &&
+ findPath(inWhichBox(_pos), inWhichBox(nuovo))) {
+ minimo = passi;
+ nuovo._y++; // to avoid error?
+ trovato = nuovo;
+ }
+ }
+
+ if (RIGHT) {
+ nuovo = punto;
+ passi = 0;
+ while ((inWhichBox(nuovo) == -1) && (nuovo._x < 640)) {
+ nuovo._x++;
+ passi++;
+ }
+ if ((inWhichBox(nuovo) != -1) && (passi < minimo) &&
+ findPath(inWhichBox(_pos), inWhichBox(nuovo))) {
+ minimo = passi;
+ nuovo._x++; // to avoid error?
+ trovato = nuovo;
+ }
+ }
+
+ if (LEFT) {
+ nuovo = punto;
+ passi = 0;
+ while ((inWhichBox(nuovo) == -1) && (nuovo._x >= 0)) {
+ nuovo._x--;
+ passi++;
+ }
+ if ((inWhichBox(nuovo) != -1) && (passi < minimo) &&
+ findPath(inWhichBox(_pos), inWhichBox(nuovo))) {
+ minimo = passi;
+ nuovo._x--; // to avoid error?
+ trovato = nuovo;
+ }
+ }
+
+ if (minimo == 32000)
+ trovato = punto;
+
+ return trovato;
+}
+
+
+RMPoint RMCharacter::nearestPoint(const RMPoint &punto) {
+ return searching(1, 1, 1, 1, punto);
+}
+
+
+short RMCharacter::scanLine(const RMPoint &punto) {
+ int Ldx, Ldy, Lcount;
+ float Lfx, Lfy, Lslope;
+ RMPoint Lstart, Lend, Lscan;
+ signed char Lspeed, Lstatus;
+
+ Lstart = _pos;
+ Lend = punto;
+ Ldx = Lstart._x - Lend._x;
+ Ldy = Lstart._y - Lend._y;
+ Lfx = Ldx;
+ Lfy = Ldy;
+ Ldx = ABS(Ldx);
+ Ldy = ABS(Ldy);
+ Lspeed = 1;
+ Lcount = 0;
+
+ if (Ldx > Ldy) {
+ Lslope = Lfy / Lfx;
+ if (Lend._x < Lstart._x)
+ Lspeed = -Lspeed;
+ Lstatus = 1;
+ } else {
+ Lslope = Lfx / Lfy;
+ if (Lend._y < Lstart._y)
+ Lspeed = - Lspeed;
+ Lstatus = 0;
+ }
+
+ Lscan = Lstart; // Start scanning
+ while (inWhichBox(Lscan) != -1) {
+ Lcount++;
+ if (Lstatus) {
+ Ldx = Lspeed * Lcount;
+ Ldy = (int)(Lslope * Ldx);
+ } else {
+ Ldy = Lspeed * Lcount;
+ Ldx = (int)(Lslope * Ldy);
+ }
+
+ Lscan._x = Lstart._x + Ldx;
+ Lscan._y = Lstart._y + Ldy;
+
+ if ((ABS(Lscan._x - Lend._x) <= 1) && (ABS(Lscan._y - Lend._y) <= 1))
+ return 1;
+ }
+
+ return 0;
+}
+
+/**
+ * Calculates intersections between the straight line and the closest BBOX
+ */
+RMPoint RMCharacter::invScanLine(const RMPoint &punto) {
+ int Ldx, Ldy, Lcount;
+ float Lfx, Lfy, Lslope;
+ RMPoint Lstart, Lend, Lscan;
+ signed char Lspeed, Lstatus, Lbox = -1;
+
+ Lstart = punto; // Exchange!
+ Lend = _pos; // :-)
+ Ldx = Lstart._x - Lend._x;
+ Ldy = Lstart._y - Lend._y;
+ Lfx = Ldx;
+ Lfy = Ldy;
+ Ldx = ABS(Ldx);
+ Ldy = ABS(Ldy);
+ Lspeed = 1;
+ Lcount = 0;
+
+ if (Ldx > Ldy) {
+ Lslope = Lfy / Lfx;
+ if (Lend._x < Lstart._x)
+ Lspeed = -Lspeed;
+ Lstatus = 1;
+ } else {
+ Lslope = Lfx / Lfy;
+ if (Lend._y < Lstart._y)
+ Lspeed = -Lspeed;
+ Lstatus = 0;
+ }
+ Lscan = Lstart;
+
+ for (;;) {
+ if (inWhichBox(Lscan) != -1) {
+ if (inWhichBox(Lscan) != Lbox) {
+ if (inWhichBox(_pos) == inWhichBox(Lscan) || findPath(inWhichBox(_pos), inWhichBox(Lscan)))
+ return Lscan;
+ else
+ Lbox = inWhichBox(Lscan);
+ }
+ }
+
+ Lcount++;
+ if (Lstatus) {
+ Ldx = Lspeed * Lcount;
+ Ldy = (int)(Lslope * Ldx);
+ } else {
+ Ldy = Lspeed * Lcount;
+ Ldx = (int)(Lslope * Ldy);
+ }
+ Lscan._x = Lstart._x + Ldx;
+ Lscan._y = Lstart._y + Ldy;
+
+ // WORKAROUND: Handles cases where the points never fall inside a bounding box
+ if (Lscan._x < -100 || Lscan._y < -100 || Lscan._x >= 1000 || Lscan._y >= 1000)
+ return punto;
+ }
+}
+
+
+/**
+ * Returns the HotSpot coordinate closest to the player
+ */
+
+RMPoint RMCharacter::nearestHotSpot(int sourcebox, int destbox) {
+ RMPoint puntocaldo;
+ short cc;
+ int x, y, distanzaminima;
+ distanzaminima = 10000000;
+ RMBoxLoc *cur = _theBoxes->getBoxes(_curLocation);
+
+ for (cc = 0; cc < cur->_boxes[sourcebox]._numHotspot; cc++)
+ if ((cur->_boxes[sourcebox]._hotspot[cc]._destination) == destbox) {
+ x = ABS(cur->_boxes[sourcebox]._hotspot[cc]._hotx - _pos._x);
+ y = ABS(cur->_boxes[sourcebox]._hotspot[cc]._hoty - _pos._y);
+
+ if ((x * x + y * y) < distanzaminima) {
+ distanzaminima = x * x + y * y;
+ puntocaldo._x = cur->_boxes[sourcebox]._hotspot[cc]._hotx;
+ puntocaldo._y = cur->_boxes[sourcebox]._hotspot[cc]._hoty;
+ }
+ }
+
+ return puntocaldo;
+}
+
+void RMCharacter::draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim) {
+ CORO_BEGIN_CONTEXT;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ if (_bDrawNow) {
+ prim->getDst() += _fixedScroll;
+
+ CORO_INVOKE_2(RMItem::draw, bigBuf, prim);
+ }
+
+ CORO_END_CODE;
+}
+
+void RMCharacter::newBoxEntered(int nBox) {
+ RMBoxLoc *cur;
+ bool bOldReverse;
+
+ // Recall on ExitBox
+ mpalQueryDoAction(3, _curLocation, _curBox);
+
+ cur = _theBoxes->getBoxes(_curLocation);
+ bOldReverse = cur->_boxes[_curBox]._bReversed;
+ _curBox = nBox;
+
+ // If Z is changed, we must remove it from the OT
+ if (cur->_boxes[_curBox]._destZ != _z) {
+ _bRemoveFromOT = true;
+ _z = cur->_boxes[_curBox]._destZ;
+ }
+
+ // Movement management is reversed, only if we are not in the shortest path. If we are in the shortest
+ // path, directly do the DoFrame
+ if (_bMovingWithoutMinpath) {
+ if ((cur->_boxes[_curBox]._bReversed && !bOldReverse) || (!cur->_boxes[_curBox]._bReversed && bOldReverse)) {
+ switch (getCurPattern()) {
+ case PAT_WALKUP:
+ setPattern(PAT_WALKDOWN);
+ break;
+ case PAT_WALKDOWN:
+ setPattern(PAT_WALKUP);
+ break;
+ case PAT_WALKRIGHT:
+ setPattern(PAT_WALKLEFT);
+ break;
+ case PAT_WALKLEFT:
+ setPattern(PAT_WALKRIGHT);
+ break;
+ }
+ }
+ }
+
+ // Recall On EnterBox
+ mpalQueryDoAction(2, _curLocation, _curBox);
+}
+
+void RMCharacter::doFrame(CORO_PARAM, RMGfxTargetBuffer *bigBuf, int loc) {
+ CORO_BEGIN_CONTEXT;
+ bool bEndNow;
+ RMBoxLoc *cur;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ _ctx->bEndNow = false;
+ _bEndOfPath = false;
+ _bDrawNow = (_curLocation == loc);
+
+ g_system->lockMutex(_csMove);
+
+ // If we're walking..
+ if (_status != STAND) {
+ // If we are going horizontally
+ if (_walkStatus == 1) {
+ _dx = _walkSpeed * _walkCount;
+ _dy = (int)(_slope * _dx);
+ _pos._x = _lineStart._x + _dx;
+ _pos._y = _lineStart._y + _dy;
+
+ // Right
+ if (((_walkSpeed > 0) && (_pos._x > _lineEnd._x)) || ((_walkSpeed < 0) && (_pos._x < _lineEnd._x))) {
+ _pos = _lineEnd;
+ _status = STAND;
+ _ctx->bEndNow = true;
+ }
+ }
+
+ // If we are going vertical
+ if (_walkStatus == 0) {
+ _dy = _walkSpeed * _walkCount;
+ _dx = (int)(_slope * _dy);
+ _pos._x = _lineStart._x + _dx;
+ _pos._y = _lineStart._y + _dy;
+
+ // Down
+ if (((_walkSpeed > 0) && (_pos._y > _lineEnd._y)) || ((_walkSpeed < 0) && (_pos._y < _lineEnd._y))) {
+ _pos = _lineEnd;
+ _status = STAND;
+ _ctx->bEndNow = true;
+ }
+ }
+
+ // Check if the character came out of the BOX in error, in which case he returns immediately
+ if (inWhichBox(_pos) == -1) {
+ _pos._x = _lineStart._x + _olddx;
+ _pos._y = _lineStart._y + _olddy;
+ }
+
+ // If we have just moved to a temporary location, and is over the shortest path, we stop permanently
+ if (_ctx->bEndNow && _minPath == 0) {
+ if (!_bEndOfPath)
+ CORO_INVOKE_0(stop);
+ _bEndOfPath = true;
+ CoroScheduler.pulseEvent(_hEndOfPath);
+ }
+
+ _walkCount++;
+
+ // Update the character Z. @@@ Should remove only if the Z was changed
+
+ // Check if the box was changed
+ if (!_theBoxes->isInBox(_curLocation, _curBox, _pos))
+ newBoxEntered(inWhichBox(_pos));
+
+ // Update the old coordinates
+ _olddx = _dx;
+ _olddy = _dy;
+ }
+
+ // If we stop
+ if (_status == STAND) {
+ // Check if there is still the shortest path to calculate
+ if (_minPath == 1) {
+ _ctx->cur = _theBoxes->getBoxes(_curLocation);
+
+ // If we still have to go through a box
+ if (_pathCount < _pathLength) {
+ // Check if the box we're going into is active
+ if (_ctx->cur->_boxes[_path[_pathCount - 1]]._bActive) {
+ // Move in a straight line towards the nearest hotspot, taking into account the reversing
+ // NEWBOX = path[pathcount-1]
+ CORO_INVOKE_2(goTo, nearestHotSpot(_path[_pathCount - 1], _path[_pathCount]), _ctx->cur->_boxes[_path[_pathCount - 1]]._bReversed);
+ _pathCount++;
+ } else {
+ // If the box is off, we can only block all
+ // @@@ Whilst this should not happen, because have improved
+ // the search for the minimum path
+ _minPath = 0;
+ if (!_bEndOfPath)
+ CORO_INVOKE_0(stop);
+ _bEndOfPath = true;
+ CoroScheduler.pulseEvent(_hEndOfPath);
+ }
+ } else {
+ // If we have already entered the last box, we just have to move in a straight line towards the
+ // point of arrival
+ // NEWBOX = InWhichBox(pathend)
+ _minPath = 0;
+ CORO_INVOKE_2(goTo, _pathEnd, _ctx->cur->_boxes[inWhichBox(_pathEnd)]._bReversed);
+ }
+ }
+ }
+
+ g_system->unlockMutex(_csMove);
+
+ // Invoke the DoFrame of the item
+ RMItem::doFrame(bigBuf);
+
+ CORO_END_CODE;
+}
+
+bool RMCharacter::endOfPath() {
+ return _bEndOfPath;
+}
+
+void RMCharacter::stop(CORO_PARAM) {
+ CORO_BEGIN_CONTEXT;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ _bMoving = false;
+
+ // You never know..
+ _status = STAND;
+ _minPath = 0;
+
+ if (!_bNeedToStop)
+ return;
+
+ _bNeedToStop = false;
+
+ switch (getCurPattern()) {
+ case PAT_WALKUP:
+ setPattern(PAT_STANDUP);
+ break;
+
+ case PAT_WALKDOWN:
+ setPattern(PAT_STANDDOWN);
+ break;
+
+ case PAT_WALKLEFT:
+ setPattern(PAT_STANDLEFT);
+ break;
+
+ case PAT_WALKRIGHT:
+ setPattern(PAT_STANDRIGHT);
+ break;
+
+ default:
+ setPattern(PAT_STANDDOWN);
+ break;
+ }
+
+ CORO_END_CODE;
+}
+
+/**
+ * Check if the character is moving
+ */
+bool RMCharacter::isMoving() {
+ return _bMoving;
+}
+
+inline int RMCharacter::inWhichBox(const RMPoint &pt) {
+ return _theBoxes->whichBox(_curLocation, pt);
+}
+
+
+void RMCharacter::move(CORO_PARAM, RMPoint pt, bool *result) {
+ CORO_BEGIN_CONTEXT;
+ RMPoint dest;
+ int numbox;
+ RMBoxLoc *cur;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ _bMoving = true;
+
+ // 0, 0 does not do anything, just stops the character
+ if (pt._x == 0 && pt._y == 0) {
+ _minPath = 0;
+ _status = STAND;
+ CORO_INVOKE_0(stop);
+ if (result)
+ *result = true;
+ return;
+ }
+
+ // If clicked outside the box
+ _ctx->numbox = inWhichBox(pt);
+ if (_ctx->numbox == -1) {
+ // Find neareste point inside the box
+ _ctx->dest = nearestPoint(pt);
+
+ // ???!??
+ if (_ctx->dest == pt)
+ _ctx->dest = invScanLine(pt);
+
+ pt = _ctx->dest;
+ _ctx->numbox = inWhichBox(pt);
+ }
+
+ _ctx->cur = _theBoxes->getBoxes(_curLocation);
+
+ _minPath = 0;
+ _status = STAND;
+ _bMovingWithoutMinpath = true;
+ if (scanLine(pt))
+ CORO_INVOKE_2(goTo, pt, _ctx->cur->_boxes[_ctx->numbox]._bReversed);
+ else if (findPath(inWhichBox(_pos), inWhichBox(pt))) {
+ _bMovingWithoutMinpath = false;
+ _minPath = 1;
+ _pathCount = 1;
+ _pathEnd = pt;
+ } else {
+ // @@@ This case is whether a hotspot is inside a box, but there is
+ // a path to get there. We use the InvScanLine to search around a point
+ _ctx->dest = invScanLine(pt);
+ pt = _ctx->dest;
+
+ if (scanLine(pt))
+ CORO_INVOKE_2(goTo, pt, _ctx->cur->_boxes[_ctx->numbox]._bReversed);
+ else if (findPath(inWhichBox(_pos), inWhichBox(pt))) {
+ _bMovingWithoutMinpath = false;
+ _minPath = 1;
+ _pathCount = 1;
+ _pathEnd = pt;
+ if (result)
+ *result = true;
+ } else {
+ if (result)
+ *result = false;
+ }
+
+ return;
+ }
+
+ if (result)
+ *result = true;
+
+ CORO_END_CODE;
+}
+
+void RMCharacter::setPosition(const RMPoint &pt, int newloc) {
+ RMBoxLoc *box;
+
+ _minPath = 0;
+ _status = STAND;
+ _pos = pt;
+
+ if (newloc != -1)
+ _curLocation = newloc;
+
+ // Update the character's Z value
+ box = _theBoxes->getBoxes(_curLocation);
+ _curBox = inWhichBox(_pos);
+ assert(_curBox != -1);
+ _z = box->_boxes[_curBox]._destZ;
+ _bRemoveFromOT = true;
+}
+
+void RMCharacter::waitForEndMovement(CORO_PARAM) {
+ CORO_BEGIN_CONTEXT;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ if (_bMoving)
+ CORO_INVOKE_2(CoroScheduler.waitForSingleObject, _hEndOfPath, CORO_INFINITE);
+
+ CORO_END_CODE;
+}
+
+void RMCharacter::setFixedScroll(const RMPoint &fix) {
+ _fixedScroll = fix;
+}
+
+void RMCharacter::setSpeed(int speed) {
+ _curSpeed = speed;
+}
+
+void RMCharacter::removeThis(CORO_PARAM, bool &result) {
+ CORO_BEGIN_CONTEXT;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ if (_bRemoveFromOT)
+ result = true;
+ else
+ CORO_INVOKE_1(RMItem::removeThis, result);
+
+ CORO_END_CODE;
+}
+
+RMCharacter::RMCharacter() {
+ _csMove = g_system->createMutex();
+ _hEndOfPath = CoroScheduler.createEvent(false, false);
+ _minPath = 0;
+ _curSpeed = 3;
+ _bRemoveFromOT = false;
+ _bMoving = false;
+ _curLocation = 0;
+ _curBox = 0;
+ _dx = _dy = 0;
+ _olddx = _olddy = 0;
+ _fx = _fy = _slope = 0;
+ _walkSpeed = _walkStatus = 0;
+ _nextBox = 0;
+ _pathLength = _pathCount = 0;
+ _status = STAND;
+ _theBoxes = NULL;
+ _walkCount = 0;
+ _bEndOfPath = false;
+ _bMovingWithoutMinpath = false;
+ _bDrawNow = false;
+ _bNeedToStop = false;
+
+ memset(_path, 0, sizeof(_path));
+
+ _pos.set(0, 0);
+}
+
+RMCharacter::~RMCharacter() {
+ g_system->deleteMutex(_csMove);
+ CoroScheduler.closeEvent(_hEndOfPath);
+}
+
+void RMCharacter::linkToBoxes(RMGameBoxes *boxes) {
+ _theBoxes = boxes;
+}
+
+/****************************************************************************\
+* RMBox Methods
+\****************************************************************************/
+
+void RMBox::readFromStream(Common::ReadStream &ds) {
+ uint16 w;
+ int i;
+ byte b;
+
+ // Bbox
+ _left = ds.readSint32LE();
+ _top = ds.readSint32LE();
+ _right = ds.readSint32LE();
+ _bottom = ds.readSint32LE();
+
+ // Adjacency
+ for (i = 0; i < MAXBOXES; i++) {
+ _adj[i] = ds.readSint32LE();
+ }
+
+ // Misc
+ _numHotspot = ds.readSint32LE();
+ _destZ = ds.readByte();
+ b = ds.readByte();
+ _bActive = b;
+ b = ds.readByte();
+ _bReversed = b;
+
+ // Reversed expansion space
+ for (i = 0; i < 30; i++)
+ ds.readByte();
+
+ // Hotspots
+ for (i = 0; i < _numHotspot; i++) {
+ w = ds.readUint16LE();
+ _hotspot[i]._hotx = w;
+ w = ds.readUint16LE();
+ _hotspot[i]._hoty = w;
+ w = ds.readUint16LE();
+ _hotspot[i]._destination = w;
+ }
+}
+
+/****************************************************************************\
+* RMBoxLoc Methods
+\****************************************************************************/
+
+RMBoxLoc::RMBoxLoc() {
+ _boxes = NULL;
+ _numbBox = 0;
+}
+
+RMBoxLoc::~RMBoxLoc() {
+ delete[] _boxes;
+}
+
+void RMBoxLoc::readFromStream(Common::ReadStream &ds) {
+ int i;
+ char buf[2];
+ byte ver;
+
+ // ID and version
+ buf[0] = ds.readByte();
+ buf[1] = ds.readByte();
+ ver = ds.readByte();
+ assert(buf[0] == 'B' && buf[1] == 'X');
+ assert(ver == 3);
+
+ // Number of boxes
+ _numbBox = ds.readSint32LE();
+
+ // Allocate memory for the boxes
+ _boxes = new RMBox[_numbBox];
+
+ // Read in boxes
+ for (i = 0; i < _numbBox; i++)
+ _boxes[i].readFromStream(ds);
+}
+
+void RMBoxLoc::recalcAllAdj() {
+ int i, j;
+
+ for (i = 0; i < _numbBox; i++) {
+ Common::fill(_boxes[i]._adj, _boxes[i]._adj + MAXBOXES, 0);
+
+ for (j = 0; j < _boxes[i]._numHotspot; j++)
+ if (_boxes[_boxes[i]._hotspot[j]._destination]._bActive)
+ _boxes[i]._adj[_boxes[i]._hotspot[j]._destination] = 1;
+ }
+}
+
+/****************************************************************************\
+* RMGameBoxes methods
+\****************************************************************************/
+
+RMGameBoxes::RMGameBoxes() {
+ _nLocBoxes = 0;
+ Common::fill(_allBoxes, _allBoxes + GAME_BOXES_SIZE, (RMBoxLoc *)NULL);
+}
+
+RMGameBoxes::~RMGameBoxes() {
+ for (int i = 1; i <= _nLocBoxes; ++i)
+ delete _allBoxes[i];
+}
+
+void RMGameBoxes::init() {
+ int i;
+
+ // Load boxes from disk
+ _nLocBoxes = 130;
+ for (i = 1; i <= _nLocBoxes; i++) {
+ RMRes res(10000 + i);
+
+ Common::SeekableReadStream *ds = res.getReadStream();
+
+ _allBoxes[i] = new RMBoxLoc();
+ _allBoxes[i]->readFromStream(*ds);
+
+ _allBoxes[i]->recalcAllAdj();
+
+ delete ds;
+ }
+}
+
+void RMGameBoxes::close() {
+}
+
+RMBoxLoc *RMGameBoxes::getBoxes(int nLoc) {
+ return _allBoxes[nLoc];
+}
+
+int RMGameBoxes::getLocBoxesCount() const {
+ return _nLocBoxes;
+}
+
+bool RMGameBoxes::isInBox(int nLoc, int nBox, const RMPoint &pt) {
+ RMBoxLoc *cur = getBoxes(nLoc);
+
+ if ((pt._x >= cur->_boxes[nBox]._left) && (pt._x <= cur->_boxes[nBox]._right) &&
+ (pt._y >= cur->_boxes[nBox]._top) && (pt._y <= cur->_boxes[nBox]._bottom))
+ return true;
+ else
+ return false;
+}
+
+int RMGameBoxes::whichBox(int nLoc, const RMPoint &punto) {
+ int i;
+ RMBoxLoc *cur = getBoxes(nLoc);
+
+ if (!cur)
+ return -1;
+
+ for (i = 0; i < cur->_numbBox; i++) {
+ if (cur->_boxes[i]._bActive) {
+ if ((punto._x >= cur->_boxes[i]._left) && (punto._x <= cur->_boxes[i]._right) &&
+ (punto._y >= cur->_boxes[i]._top) && (punto._y <= cur->_boxes[i]._bottom))
+ return i;
+ }
+ }
+
+ return -1;
+}
+
+void RMGameBoxes::changeBoxStatus(int nLoc, int nBox, int status) {
+ _allBoxes[nLoc]->_boxes[nBox]._bActive = status;
+ _allBoxes[nLoc]->recalcAllAdj();
+}
+
+int RMGameBoxes::getSaveStateSize() {
+ int size;
+ int i;
+
+ size = 4;
+
+ for (i = 1; i <= _nLocBoxes; i++) {
+ size += 4;
+ size += _allBoxes[i]->_numbBox;
+ }
+
+ return size;
+}
+
+void RMGameBoxes::saveState(byte *state) {
+ int i, j;
+
+ // Save the number of locations with boxes
+ WRITE_LE_UINT32(state, _nLocBoxes);
+ state += 4;
+
+ // For each location, write out the number of boxes and their status
+ for (i = 1; i <= _nLocBoxes; i++) {
+ WRITE_LE_UINT32(state, _allBoxes[i]->_numbBox);
+ state += 4;
+
+ for (j = 0; j < _allBoxes[i]->_numbBox; j++)
+ *state++ = _allBoxes[i]->_boxes[j]._bActive;
+ }
+}
+
+void RMGameBoxes::loadState(byte *state) {
+ int i, j;
+ int nloc, nbox;
+
+ // Load number of items
+ nloc = READ_LE_UINT32(state);
+ state += 4;
+
+ assert(nloc <= _nLocBoxes);
+
+ // For each location, read the number of boxes and their status
+ for (i = 1; i <= nloc; i++) {
+ nbox = READ_LE_UINT32(state);
+ state += 4;
+
+ for (j = 0; j < nbox ; j++) {
+ if (j < _allBoxes[i]->_numbBox)
+ _allBoxes[i]->_boxes[j]._bActive = *state;
+
+ state++;
+ }
+
+ _allBoxes[i]->recalcAllAdj();
+ }
+}
+
+/****************************************************************************\
+* RMLocation Methods
+\****************************************************************************/
+
+/**
+ * Standard constructor
+ */
+RMLocation::RMLocation() {
+ _nItems = 0;
+ _items = NULL;
+ _buf = NULL;
+ TEMPNumLoc = 0;
+ _cmode = CM_256;
+}
+
+RMPoint RMLocation::TEMPGetTonyStart() {
+ return TEMPTonyStart;
+}
+
+int RMLocation::TEMPGetNumLoc() {
+ return TEMPNumLoc;
+}
+
+/**
+ * Load a location (.LOC) from a given data stream
+ *
+ * @param ds Data stream
+ * @returns True if succeeded OK, false in case of error.
+ */
+bool RMLocation::load(Common::SeekableReadStream &ds) {
+ char id[3];
+ int dimx, dimy;
+ byte ver;
+ byte cm;
+ int i;
+
+ // Reset dirty rectangling
+ _prevScroll.set(-1, -1);
+ _prevFixedScroll.set(-1, -1);
+
+ // Check the ID
+ ds.read(id, 3);
+
+ // Check if we are in a LOX
+ if (id[0] == 'L' && id[1] == 'O' && id[2] == 'X')
+ return loadLOX(ds);
+
+ // Otherwise, check that it is a normal LOC
+ if (id[0] != 'L' || id[1] != 'O' || id[2] != 'C')
+ return false;
+
+ // Version
+ ver = ds.readByte();
+ assert(ver == 6);
+
+ // Location name
+ _name = readString(ds);
+
+ // Skip the MPAL bailouts (64 bytes)
+ TEMPNumLoc = ds.readSint32LE();
+ TEMPTonyStart._x = ds.readSint32LE();
+ TEMPTonyStart._y = ds.readSint32LE();
+ ds.skip(64 - 4 * 3);
+
+ // Skip flag associated with the background (?)
+ ds.skip(1);
+
+ // Location dimensions
+ dimx = ds.readSint32LE();
+ dimy = ds.readSint32LE();
+ _curScroll.set(0, 0);
+
+ // Read the color mode
+ cm = ds.readByte();
+ _cmode = (RMColorMode)cm;
+
+ // Initialize the source buffer and read the location
+ switch (_cmode) {
+ case CM_256:
+ _buf = new RMGfxSourceBuffer8;
+ break;
+
+ case CM_65K:
+ _buf = new RMGfxSourceBuffer16;
+ break;
+
+ default:
+ assert(0);
+ break;
+ };
+
+ // Initialize the surface, loading the palette if necessary
+ _buf->init(ds, dimx, dimy, true);
+
+ // Check the size of the location
+// assert(dimy!=512);
+
+ // Number of objects
+ _nItems = ds.readSint32LE();
+
+ // Create and read in the objects
+ if (_nItems > 0)
+ _items = new RMItem[_nItems];
+
+
+ g_vm->freezeTime();
+ for (i = 0; i < _nItems && !ds.err(); i++)
+ _items[i].readFromStream(ds);
+ g_vm->unfreezeTime();
+
+ return ds.err();
+}
+
+
+bool RMLocation::loadLOX(Common::SeekableReadStream &ds) {
+ int dimx, dimy;
+ byte ver;
+ int i;
+
+ // Version
+ ver = ds.readByte();
+ assert(ver == 1);
+
+ // Location name
+ _name = readString(ds);
+
+ // Location number
+ TEMPNumLoc = ds.readSint32LE();
+ TEMPTonyStart._x = ds.readSint32LE();
+ TEMPTonyStart._y = ds.readSint32LE();
+
+ // Dimensions
+ dimx = ds.readSint32LE();
+ dimy = ds.readSint32LE();
+ _curScroll.set(0, 0);
+
+ // It's always 65K (16-bit) mode
+ _cmode = CM_65K;
+ _buf = new RMGfxSourceBuffer16;
+
+ // Initialize the surface, loading in the palette if necessary
+ _buf->init(ds, dimx, dimy, true);
+
+ // Number of items
+ _nItems = ds.readSint32LE();
+
+ // Create and read objects
+ if (_nItems > 0)
+ _items = new RMItem[_nItems];
+
+ for (i = 0; i < _nItems && !ds.err(); i++)
+ _items[i].readFromStream(ds, true);
+
+ return ds.err();
+}
+
+
+/**
+ * Draw method overloaded from RMGfxSourceBUffer8
+ */
+void RMLocation::draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim) {
+ CORO_BEGIN_CONTEXT;
+ bool priorTracking;
+ bool hasChanges;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ // Set the position of the source scrolling
+ if (_buf->getDimy() > RM_SY || _buf->getDimx() > RM_SX) {
+ prim->setSrc(RMRect(_curScroll, _curScroll + RMPoint(640, 480)));
+ }
+
+ prim->setDst(_fixedScroll);
+
+ // Check whether dirty rects are being tracked, and if there are changes, leave tracking
+ // turned on so a dirty rect will be added for the entire background
+ _ctx->priorTracking = bigBuf.getTrackDirtyRects();
+ _ctx->hasChanges = (_prevScroll != _curScroll) || (_prevFixedScroll != _fixedScroll);
+ bigBuf.setTrackDirtyRects(_ctx->priorTracking && _ctx->hasChanges);
+
+ // Invoke the drawing method fo the image class, which will draw the location background
+ CORO_INVOKE_2(_buf->draw, bigBuf, prim);
+
+ if (_ctx->hasChanges) {
+ _prevScroll = _curScroll;
+ _prevFixedScroll = _fixedScroll;
+ }
+ bigBuf.setTrackDirtyRects(_ctx->priorTracking);
+
+ CORO_END_CODE;
+}
+
+
+/**
+ * Prepare a frame, adding the location to the OT list, and all the items that have changed animation frame.
+ */
+void RMLocation::doFrame(RMGfxTargetBuffer *bigBuf) {
+ int i;
+
+ // If the location is not in the OT list, add it in
+ if (!_nInList)
+ bigBuf->addPrim(new RMGfxPrimitive(this));
+
+ // Process all the location items
+ for (i = 0; i < _nItems; i++)
+ _items[i].doFrame(bigBuf);
+}
+
+
+RMItem *RMLocation::getItemFromCode(uint32 dwCode) {
+ int i;
+
+ for (i = 0; i < _nItems; i++) {
+ if (_items[i].mpalCode() == (int)dwCode)
+ return &_items[i];
+ }
+
+ return NULL;
+}
+
+RMItem *RMLocation::whichItemIsIn(const RMPoint &pt) {
+ int found = -1;
+ int foundSize = 0;
+ int size;
+
+ for (int i = 0; i < _nItems; i++) {
+ size = 0;
+ if (_items[i].isIn(pt, &size)) {
+ if (found == -1 || size < foundSize) {
+ foundSize = size;
+ found = i;
+ }
+ }
+ }
+
+ if (found == -1)
+ return NULL;
+ else
+ return &_items[found];
+}
+
+RMLocation::~RMLocation() {
+ unload();
+}
+
+void RMLocation::unload() {
+ // Clear memory
+ if (_items) {
+ delete[] _items;
+ _items = NULL;
+ }
+
+ // Destroy the buffer
+ if (_buf) {
+ delete _buf;
+ _buf = NULL;
+ }
+}
+
+void RMLocation::updateScrolling(const RMPoint &ptShowThis) {
+ RMPoint oldScroll = _curScroll;
+
+ if (_curScroll._x + 250 > ptShowThis._x) {
+ _curScroll._x = ptShowThis._x - 250;
+ } else if (_curScroll._x + RM_SX - 250 < ptShowThis._x) {
+ _curScroll._x = ptShowThis._x + 250 - RM_SX;
+ } else if (ABS(_curScroll._x + RM_SX / 2 - ptShowThis._x) > 32 && _buf->getDimx() > RM_SX) {
+ if (_curScroll._x + RM_SX / 2 < ptShowThis._x)
+ _curScroll._x++;
+ else
+ _curScroll._x--;
+ }
+
+ if (_curScroll._y + 180 > ptShowThis._y) {
+ _curScroll._y = ptShowThis._y - 180;
+ } else if (_curScroll._y + RM_SY - 180 < ptShowThis._y) {
+ _curScroll._y = ptShowThis._y + 180 - RM_SY;
+ } else if (ABS(_curScroll._y + RM_SY / 2 - ptShowThis._y) > 16 && _buf->getDimy() > RM_SY) {
+ if (_curScroll._y + RM_SY / 2 < ptShowThis._y)
+ _curScroll._y++;
+ else
+ _curScroll._y--;
+ }
+
+ if (_curScroll._x < 0)
+ _curScroll._x = 0;
+ if (_curScroll._y < 0)
+ _curScroll._y = 0;
+ if (_curScroll._x + RM_SX > _buf->getDimx())
+ _curScroll._x = _buf->getDimx() - RM_SX;
+ if (_curScroll._y + RM_SY > _buf->getDimy())
+ _curScroll._y = _buf->getDimy() - RM_SY;
+
+ if (oldScroll != _curScroll) {
+ for (int i = 0; i < _nItems; i++)
+ _items[i].setScrollPosition(_curScroll);
+ }
+}
+
+void RMLocation::setFixedScroll(const RMPoint &scroll) {
+ _fixedScroll = scroll;
+
+ for (int i = 0; i < _nItems; i++)
+ _items[i].setScrollPosition(_curScroll - _fixedScroll);
+}
+
+void RMLocation::setScrollPosition(const RMPoint &scroll) {
+ RMPoint pt = scroll;
+ if (pt._x < 0)
+ pt._x = 0;
+ if (pt._y < 0)
+ pt._y = 0;
+ if (pt._x + RM_SX > _buf->getDimx())
+ pt._x = _buf->getDimx() - RM_SX;
+ if (pt._y + RM_SY > _buf->getDimy())
+ pt._y = _buf->getDimy() - RM_SY;
+
+ _curScroll = pt;
+
+ for (int i = 0; i < _nItems; i++)
+ _items[i].setScrollPosition(_curScroll);
+}
+
+
+void RMLocation::pauseSound(bool bPause) {
+ int i;
+
+ for (i = 0; i < _nItems; i++)
+ _items[i].pauseSound(bPause);
+}
+
+/**
+ * Read the current scroll position
+ */
+RMPoint RMLocation::scrollPosition() {
+ return _curScroll;
+}
+
+/****************************************************************************\
+* RMMessage Methods
+\****************************************************************************/
+
+RMMessage::RMMessage(uint32 dwId) {
+ load(dwId);
+}
+
+RMMessage::RMMessage() {
+ _lpMessage = NULL;
+ _nPeriods = 0;
+ for (int i = 0; i < 256; i++)
+ _lpPeriods[i] = 0;
+}
+
+RMMessage::~RMMessage() {
+ if (_lpMessage)
+ globalDestroy(_lpMessage);
+}
+
+void RMMessage::load(uint32 dwId) {
+ _lpMessage = mpalQueryMessage(dwId);
+ assert(_lpMessage != NULL);
+
+ if (_lpMessage)
+ parseMessage();
+}
+
+void RMMessage::parseMessage() {
+ char *p;
+
+ assert(_lpMessage != NULL);
+
+ _nPeriods = 1;
+ p = _lpPeriods[0] = _lpMessage;
+
+ for (;;) {
+ // Find the end of the current period
+ while (*p != '\0')
+ p++;
+
+ // If there is another '0' at the end of the string, the end has been found
+ p++;
+ if (*p == '\0')
+ break;
+
+ // Otherwise there is another line, and remember it's start
+ _lpPeriods[_nPeriods++] = p;
+ }
+}
+
+bool RMMessage::isValid() {
+ return _lpMessage != NULL;
+}
+
+int RMMessage::numPeriods() {
+ return _nPeriods;
+}
+
+char *RMMessage::period(int num) {
+ return _lpPeriods[num];
+}
+
+char *RMMessage::operator[](int num) {
+ return _lpPeriods[num];
+}
+
+} // End of namespace Tony
diff --git a/engines/tony/loc.h b/engines/tony/loc.h
new file mode 100644
index 0000000000..61eece2440
--- /dev/null
+++ b/engines/tony/loc.h
@@ -0,0 +1,582 @@
+/* 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.
+ *
+ */
+
+/*
+ * This code is based on original Tony Tough source code
+ *
+ * Copyright (c) 1997-2003 Nayma Software
+ */
+
+#ifndef TONY_LOC_H
+#define TONY_LOC_H
+
+#include "common/scummsys.h"
+#include "common/system.h"
+#include "common/file.h"
+#include "tony/sound.h"
+#include "tony/utils.h"
+
+namespace Tony {
+
+/****************************************************************************\
+* Various defines
+\****************************************************************************/
+
+/**
+ * Valid color modes
+ */
+typedef enum {
+ CM_256,
+ CM_65K
+} RMColorMode;
+
+
+/****************************************************************************\
+* Class declarations
+\****************************************************************************/
+
+/**
+ * Generic palette
+ */
+class RMPalette {
+public:
+ byte _data[1024];
+
+public:
+ void readFromStream(Common::ReadStream &ds);
+};
+
+
+/**
+ * Sound effect of an object
+ */
+class RMSfx {
+public:
+ Common::String _name;
+ FPSfx *_fx;
+ bool _bPlayingLoop;
+
+public:
+ RMSfx();
+ virtual ~RMSfx();
+
+ void play(bool bLoop = false);
+ void setVolume(int vol);
+ void pause(bool bPause);
+ void stop();
+
+ void readFromStream(Common::ReadStream &ds, bool bLOX = false);
+};
+
+
+/**
+ * Object pattern
+ */
+class RMPattern {
+public:
+ // Type of slot
+ enum RMSlotType {
+ DUMMY1 = 0,
+ DUMMY2,
+ SPRITE,
+ SOUND,
+ COMMAND,
+ SPECIAL
+ };
+
+ // Class slot
+ class RMSlot {
+ private:
+ RMPoint _pos; // Child co-ordinates
+
+ public:
+ RMSlotType _type;
+ int _data;
+ byte _flag;
+
+ public:
+ RMPoint pos() {
+ return _pos;
+ }
+
+ void readFromStream(Common::ReadStream &ds, bool bLOX = false);
+ };
+
+public:
+ Common::String _name;
+
+private:
+ int _speed;
+ RMPoint _pos; // Parent coordinates
+ RMPoint _curPos; // Parent + child coordinates
+ int _bLoop;
+ int _nSlots;
+ int _nCurSlot;
+ int _nCurSprite;
+
+ RMSlot *_slots;
+
+ uint32 _nStartTime;
+
+public:
+ RMPattern();
+ virtual ~RMPattern();
+
+ // A warning that the pattern now and the current
+ int init(RMSfx *sfx, bool bPlayP0 = false, byte *bFlag = NULL);
+
+ // Update the pattern, checking to see if it's time to change slot and executing
+ // any associated commands
+ int update(uint32 hEndPattern, byte &bFlag, RMSfx *sfx);
+
+ // Stop a sound effect
+ void stopSfx(RMSfx *sfx);
+
+ // Reads the position of the pattern
+ RMPoint pos();
+
+ void readFromStream(Common::ReadStream &ds, bool bLOX = false);
+
+private:
+ void updateCoord();
+};
+
+
+/**
+ * Sprite (frame) animation of an item
+ */
+class RMSprite : public RMGfxTask {
+public:
+ Common::String _name;
+ RMRect _rcBox;
+
+protected:
+ RMGfxSourceBuffer *_buf;
+
+public:
+ RMSprite();
+ virtual ~RMSprite();
+
+ void init(RMGfxSourceBuffer *buf);
+ virtual void draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim);
+ void setPalette(byte *lpBuf);
+ void getSizeFromStream(Common::SeekableReadStream &ds, int *dimx, int *dimy);
+ void LOXGetSizeFromStream(Common::SeekableReadStream &ds, int *dimx, int *dimy);
+
+ void readFromStream(Common::SeekableReadStream &ds, bool bLOX = false);
+};
+
+
+/**
+ * Data on an item
+ */
+class RMItem : public RMGfxTask {
+public:
+ Common::String _name;
+
+protected:
+ int _z;
+ RMPoint _pos; // Coordinate ancestor
+ RMColorMode _cm;
+ RMPoint _curScroll;
+
+ byte _FX;
+ byte _FXparm;
+
+ virtual int getCurPattern();
+
+private:
+ int _nCurPattern;
+ int _mpalCode;
+ RMPoint _hot;
+ RMRect _rcBox;
+ int _nSprites, _nSfx, _nPatterns;
+ byte _bPal;
+ RMPalette _pal;
+
+ RMSprite *_sprites;
+ RMSfx *_sfx;
+ RMPattern *_patterns;
+
+ byte _bCurFlag;
+ int _nCurSprite;
+ bool _bIsActive;
+ uint32 _hEndPattern;
+ bool _bInitCurPattern;
+
+public:
+ RMPoint calculatePos();
+
+public:
+ RMItem();
+ virtual ~RMItem();
+
+ // Process to make the object move on any animations.
+ // Returns TRUE if it should be redrawn on the next frame
+ bool doFrame(RMGfxTargetBuffer *bigBuf, bool bAddToList = true);
+
+ // Sets the current scrolling position
+ void setScrollPosition(const RMPoint &scroll);
+
+ // Overloading of check whether to remove from active list
+ virtual void removeThis(CORO_PARAM, bool &result);
+
+ // Overloaded Draw
+ virtual void draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim);
+
+ // Overloaded priority: it's based on Z ordering
+ virtual int priority();
+
+ // Pattern number
+ int numPattern();
+
+ // Set anew animation pattern, changing abruptly from the current
+ virtual void setPattern(int nPattern, bool bPlayP0 = false);
+
+ // Set a new status
+ void setStatus(int nStatus);
+
+ bool isIn(const RMPoint &pt, int *size = NULL);
+ RMPoint hotspot();
+ bool getName(Common::String &name);
+ int mpalCode();
+
+ // Unload
+ void unload();
+
+ // Wait for the end of the current pattern
+ void waitForEndPattern(CORO_PARAM, uint32 hCustomSkip = CORO_INVALID_PID_VALUE);
+
+ // Sets a new hotspot fro the object
+ void changeHotspot(const RMPoint &pt);
+
+ void setInitCurPattern(bool status);
+
+ void playSfx(int nSfx);
+
+ void readFromStream(Common::SeekableReadStream &ds, bool bLOX = false);
+
+ void pauseSound(bool bPause);
+
+protected:
+ // Create a primitive that has as it's task this item
+ virtual RMGfxPrimitive *newItemPrimitive();
+
+ // Allocate memory for the sprites
+ virtual RMGfxSourceBuffer *newItemSpriteBuffer(int dimx, int dimy, bool bPreRLE);
+};
+
+
+#define MAXBOXES 50 // Maximum number of allowed boxes
+#define MAXHOTSPOT 20 // Maximum nimber of allowed hotspots
+
+class RMBox {
+public:
+ struct Hotspot {
+ int _hotx, _hoty; // Hotspot coordinates
+ int _destination; // Hotspot destination
+ };
+
+public:
+ int _left, _top, _right, _bottom; // Vertici bounding boxes
+ int _adj[MAXBOXES]; // List of adjacent bounding boxes
+ int _numHotspot; // Hotspot number
+ uint8 _destZ; // Z value for the bounding box
+ Hotspot _hotspot[MAXHOTSPOT]; // List of hotspots
+
+ bool _bActive;
+ bool _bReversed;
+
+ void readFromStream(Common::ReadStream &ds);
+};
+
+
+class RMBoxLoc {
+public:
+ int _numbBox;
+ RMBox *_boxes;
+
+ void readFromStream(Common::ReadStream &ds);
+
+public:
+ RMBoxLoc();
+ virtual ~RMBoxLoc();
+
+ void recalcAllAdj();
+};
+
+#define GAME_BOXES_SIZE 200
+
+class RMGameBoxes {
+protected:
+ RMBoxLoc *_allBoxes[GAME_BOXES_SIZE];
+ int _nLocBoxes;
+
+public:
+ RMGameBoxes();
+ ~RMGameBoxes();
+
+ void init();
+ void close();
+
+ // Get binding boxes for a given location
+ RMBoxLoc *getBoxes(int nLoc);
+ int getLocBoxesCount() const;
+
+ // Return the box which contains a given point
+ int whichBox(int nLoc, const RMPoint &pt);
+
+ // Check whether a point is inside a given box
+ bool isInBox(int nLoc, int nBox, const RMPoint &pt);
+
+ // Change the status of a box
+ void changeBoxStatus(int nLoc, int nBox, int status);
+
+ // Save state handling
+ int getSaveStateSize();
+ void saveState(byte *buf);
+ void loadState(byte *buf);
+};
+
+class RMCharacter : protected RMItem {
+public:
+ enum Patterns {
+ PAT_STANDUP = 1,
+ PAT_STANDDOWN,
+ PAT_STANDLEFT,
+ PAT_STANDRIGHT,
+ PAT_WALKUP,
+ PAT_WALKDOWN,
+ PAT_WALKLEFT,
+ PAT_WALKRIGHT
+ };
+
+private:
+ enum CharacterStatus {
+ STAND,
+ WALK
+ };
+
+ signed short _walkCount;
+ int _dx, _dy, _olddx, _olddy;
+ float _fx, _fy, _slope;
+ RMPoint _lineStart, _lineEnd, _pathEnd;
+ signed char _walkSpeed, _walkStatus;
+ char _minPath;
+ short _nextBox;
+ short _path[MAXBOXES];
+ short _pathLength, _pathCount;
+ int _curBox;
+
+ CharacterStatus _status;
+ int _curSpeed;
+ bool _bEndOfPath;
+ uint32 _hEndOfPath;
+ OSystem::MutexRef _csMove;
+ int _curLocation;
+ bool _bRemoveFromOT;
+ bool _bMovingWithoutMinpath;
+ RMGameBoxes *_theBoxes;
+
+ RMPoint _fixedScroll;
+
+private:
+ int inWhichBox(const RMPoint &pt);
+
+ short findPath(short source, short destination);
+ RMPoint searching(char UP, char DOWN, char RIGHT, char LEFT, RMPoint punto);
+ RMPoint nearestPoint(const RMPoint &punto);
+
+ void goTo(CORO_PARAM, RMPoint destcoord, bool bReversed = false);
+ short scanLine(const RMPoint &punto);
+ RMPoint invScanLine(const RMPoint &punto);
+ RMPoint nearestHotSpot(int sourcebox, int destbox);
+
+ void newBoxEntered(int nBox);
+
+protected:
+ bool _bMoving;
+ bool _bDrawNow;
+ bool _bNeedToStop;
+
+public:
+ RMCharacter();
+ virtual ~RMCharacter();
+
+ void linkToBoxes(RMGameBoxes *theBoxes);
+
+ virtual void removeThis(CORO_PARAM, bool &result);
+
+ // Update the position of a character
+ void doFrame(CORO_PARAM, RMGfxTargetBuffer *bigBuf, int loc);
+
+ // Overloaded draw
+ virtual void draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim);
+
+ // TRUE if you just stopped
+ bool endOfPath();
+
+ // Change the pattern of a character to STOP
+ virtual void stop(CORO_PARAM);
+
+ // Check if the character is moving
+ bool isMoving();
+
+ // Move the character to a certain position
+ void move(CORO_PARAM, RMPoint pt, bool *result = NULL);
+
+ // Place the character in a certain position WITHOUT moving
+ void setPosition(const RMPoint &pt, int newloc = -1);
+
+ // Wait for the end of movement
+ void waitForEndMovement(CORO_PARAM);
+
+ void setFixedScroll(const RMPoint &fix);
+ void setSpeed(int speed);
+};
+
+
+class RMWipe : public RMGfxTask {
+private:
+ bool _bFading;
+ bool _bEndFade;
+ bool _bUnregister;
+ uint32 _hUnregistered;
+ int _nFadeStep;
+ uint32 _hEndOfFade;
+ bool _bMustRegister;
+
+ RMItem _wip0r;
+
+public:
+ RMWipe();
+ virtual ~RMWipe();
+
+ void doFrame(RMGfxTargetBuffer &bigBuf);
+ virtual void draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim);
+
+ void initFade(int type);
+ void closeFade();
+ void waitForFadeEnd(CORO_PARAM);
+
+ virtual void Unregister();
+ virtual void removeThis(CORO_PARAM, bool &result);
+ virtual int priority();
+};
+
+
+/**
+ * Location
+ */
+class RMLocation : public RMGfxTaskSetPrior {
+public:
+ Common::String _name; // Name
+
+private:
+ RMColorMode _cmode; // Color mode
+ RMGfxSourceBuffer *_buf; // Location picture
+
+ int _nItems; // Number of objects
+ RMItem *_items; // Objects
+
+ RMPoint _curScroll; // Current scroll position
+ RMPoint _fixedScroll;
+
+ RMPoint _prevScroll; // Previous scroll position
+ RMPoint _prevFixedScroll;
+
+public:
+ // @@@@@@@@@@@@@@@@@@@@@@@
+
+ RMPoint TEMPTonyStart;
+ RMPoint TEMPGetTonyStart();
+
+ int TEMPNumLoc;
+ int TEMPGetNumLoc();
+
+public:
+ RMLocation();
+ virtual ~RMLocation();
+
+ // Load variations
+ bool load(Common::SeekableReadStream &ds);
+ bool loadLOX(Common::SeekableReadStream &ds);
+
+ // Unload
+ void unload();
+
+ // Overloaded draw
+ virtual void draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim);
+
+ // Prepare a frame by drawing the location and all it's items
+ void doFrame(RMGfxTargetBuffer *bigBuf);
+
+ // Return the item at a given point
+ RMItem *whichItemIsIn(const RMPoint &pt);
+
+ // Return the item based on it's MPAL code
+ RMItem *getItemFromCode(uint32 dwCode);
+
+ // Set the current scroll position
+ void setScrollPosition(const RMPoint &scroll);
+
+ // Sets an additinal offset for scrolling
+ void setFixedScroll(const RMPoint &scroll);
+
+ // Update the scrolling coordinates to display the specified point
+ void updateScrolling(const RMPoint &ptShowThis);
+
+ // Read the current scroll position
+ RMPoint scrollPosition();
+
+ // Pause sound
+ void pauseSound(bool bPause);
+};
+
+
+/**
+ * MPAL message, composed of more ASCIIZ
+ */
+class RMMessage {
+private:
+ char *_lpMessage;
+ char *_lpPeriods[256];
+ int _nPeriods;
+
+private:
+ void parseMessage();
+
+public:
+ RMMessage();
+ RMMessage(uint32 dwId);
+ virtual ~RMMessage();
+
+ void load(uint32 dwId);
+ bool isValid();
+ int numPeriods();
+ char *period(int num);
+ char *operator[](int num);
+};
+
+} // End of namespace Tony
+
+#endif /* TONY_H */
diff --git a/engines/tony/module.mk b/engines/tony/module.mk
new file mode 100644
index 0000000000..d66cf6f065
--- /dev/null
+++ b/engines/tony/module.mk
@@ -0,0 +1,33 @@
+MODULE := engines/tony
+
+MODULE_OBJS := \
+ custom.o \
+ debugger.o \
+ detection.o \
+ font.o \
+ game.o \
+ gfxcore.o \
+ gfxengine.o \
+ globals.o \
+ input.o \
+ inventory.o \
+ loc.o \
+ sound.o \
+ tony.o \
+ tonychar.o \
+ utils.o \
+ window.o \
+ mpal/expr.o \
+ mpal/loadmpc.o \
+ mpal/memory.o \
+ mpal/mpal.o \
+ mpal/mpalutils.o \
+ mpal/lzo.o
+
+# This module can be built as a plugin
+ifeq ($(ENABLE_TONY), DYNAMIC_PLUGIN)
+PLUGIN := 1
+endif
+
+# Include common rules
+include $(srcdir)/rules.mk
diff --git a/engines/tony/mpal/expr.cpp b/engines/tony/mpal/expr.cpp
new file mode 100644
index 0000000000..7923d263c0
--- /dev/null
+++ b/engines/tony/mpal/expr.cpp
@@ -0,0 +1,433 @@
+/* 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.
+ *
+ *
+ */
+/*
+ * This code is based on original Tony Tough source code
+ *
+ * Copyright (c) 1997-2003 Nayma Software
+ */
+
+#include "tony/mpal/mpal.h"
+#include "tony/mpal/memory.h"
+#include "tony/mpal/mpaldll.h"
+#include "tony/tony.h"
+
+namespace Tony {
+
+namespace MPAL {
+
+/**
+ * @defgroup Mathamatical operations
+ */
+//@{
+
+#define OP_MUL ((1 << 4) | 0)
+#define OP_DIV ((1 << 4) | 1)
+#define OP_MODULE ((1 << 4) | 2)
+#define OP_ADD ((2 << 4) | 0)
+#define OP_SUB ((2 << 4) | 1)
+#define OP_SHL ((3 << 4) | 0)
+#define OP_SHR ((3 << 4) | 1)
+#define OP_MINOR ((4 << 4) | 0)
+#define OP_MAJOR ((4 << 4) | 1)
+#define OP_MINEQ ((4 << 4) | 2)
+#define OP_MAJEQ ((4 << 4) | 3)
+#define OP_EQUAL ((5 << 4) | 0)
+#define OP_NOEQUAL ((5 << 4) | 1)
+#define OP_BITAND ((6 << 4) | 0)
+#define OP_BITXOR ((7 << 4) | 0)
+#define OP_BITOR ((8 << 4) | 0)
+#define OP_AND ((9 << 4) | 0)
+#define OP_OR ((10 << 4) | 0)
+
+
+/**
+ * Object types that can be contained in an EXPRESSION structure
+ */
+enum ExprListTypes {
+ ELT_NUMBER = 1,
+ ELT_VAR = 2,
+ ELT_PARENTH = 3,
+ ELT_PARENTH2 = 4
+};
+
+//@}
+
+/**
+ * @defgroup Structures
+ */
+//@{
+
+/**
+ * Mathamatical framework to manage operations
+ */
+typedef struct {
+ byte _type; // Tipo di oggetto (vedi enum ExprListTypes)
+ byte _unary; // Unary operatore (NON SUPPORTATO)
+
+ union {
+ int _num; // Numero (se type==ELT_NUMBER)
+ char *_name; // Nome variabile (se type==ELT_VAR)
+ MpalHandle _son; // Handle a espressione (type==ELT_PARENTH)
+ byte *_pson; // Handle lockato (type==ELT_PARENTH2)
+ } _val;
+
+ byte _symbol; // Simbolo matematico (vedi #define OP_*)
+
+} Expression;
+typedef Expression *LpExpression;
+
+//@}
+
+/**
+ * Duplicate a mathematical expression.
+ *
+ * @param h Handle to the original expression
+ * @retruns Pointer to the cloned expression
+ */
+static byte *duplicateExpression(MpalHandle h) {
+ byte *orig, *clone;
+ LpExpression one, two;
+
+ orig = (byte *)globalLock(h);
+
+ int num = *(byte *)orig;
+ one = (LpExpression)(orig+1);
+
+ clone = (byte *)globalAlloc(GMEM_FIXED, sizeof(Expression) * num + 1);
+ two = (LpExpression)(clone + 1);
+
+ memcpy(clone, orig, sizeof(Expression) * num + 1);
+
+ for (int i = 0; i < num; i++) {
+ if (one->_type == ELT_PARENTH) {
+ two->_type = ELT_PARENTH2;
+ two->_val._pson = duplicateExpression(two->_val._son);
+ }
+
+ ++one;
+ ++two;
+ }
+
+ globalUnlock(h);
+ return clone;
+}
+
+static int Compute(int a, int b, byte symbol) {
+ switch (symbol) {
+ case OP_MUL:
+ return a * b;
+ case OP_DIV:
+ return a / b;
+ case OP_MODULE:
+ return a % b;
+ case OP_ADD:
+ return a + b;
+ case OP_SUB:
+ return a - b;
+ case OP_SHL:
+ return a << b;
+ case OP_SHR:
+ return a >> b;
+ case OP_MINOR:
+ return a < b;
+ case OP_MAJOR:
+ return a > b;
+ case OP_MINEQ:
+ return a <= b;
+ case OP_MAJEQ:
+ return a >= b;
+ case OP_EQUAL:
+ return a == b;
+ case OP_NOEQUAL:
+ return a != b;
+ case OP_BITAND:
+ return a & b;
+ case OP_BITXOR:
+ return a ^ b;
+ case OP_BITOR:
+ return a | b;
+ case OP_AND:
+ return a && b;
+ case OP_OR:
+ return a || b;
+ default:
+ GLOBALS._mpalError = 1;
+ break;
+ }
+
+ return 0;
+}
+
+static void solve(LpExpression one, int num) {
+ LpExpression two, three;
+ int j;
+
+ while (num > 1) {
+ two = one + 1;
+ if ((two->_symbol == 0) || (one->_symbol & 0xF0) <= (two->_symbol & 0xF0)) {
+ two->_val._num = Compute(one->_val._num, two->_val._num, one->_symbol);
+ memmove(one, two, (num - 1) * sizeof(Expression));
+ --num;
+ } else {
+ j = 1;
+ three = two + 1;
+ while ((three->_symbol != 0) && (two->_symbol & 0xF0) > (three->_symbol & 0xF0)) {
+ ++two;
+ ++three;
+ ++j;
+ }
+
+ three->_val._num = Compute(two->_val._num, three->_val._num, two->_symbol);
+ memmove(two, three, (num - j - 1) * sizeof(Expression));
+ --num;
+ }
+ }
+}
+
+
+/**
+ * Calculates the result of a mathematical expression, replacing the current
+ * value of any variable.
+ *
+ * @param expr Pointer to an expression duplicated by DuplicateExpression
+ * @returns Value
+ */
+static int evaluateAndFreeExpression(byte *expr) {
+ LpExpression one, cur;
+
+ int num = *expr;
+ one = (LpExpression)(expr + 1);
+
+ // 1) Substitutions of variables
+ cur = one;
+ for (int i = 0; i < num; i++, cur++) {
+ if (cur->_type == ELT_VAR) {
+ cur->_type = ELT_NUMBER;
+ cur->_val._num = varGetValue(cur->_val._name);
+ }
+ }
+
+ // 2) Replacement of brackets (using recursive calls)
+ cur = one;
+ for (int i = 0; i < num; i++, cur++) {
+ if (cur->_type == ELT_PARENTH2) {
+ cur->_type = ELT_NUMBER;
+ cur->_val._num = evaluateAndFreeExpression(cur->_val._pson);
+ }
+ }
+
+ // 3) algebraic resolution
+ solve(one, num);
+ int val = one->_val._num;
+ globalDestroy(expr);
+
+ return val;
+}
+
+
+/**
+ * Parses a mathematical expression from the MPC file
+ *
+ * @param buf Buffer containing the expression to evaluate
+ * @param h Pointer to a handle that, at the end of execution,
+ * will point to the area of memory containing the parsed expression
+ * @returns Pointer to the buffer immediately after the expression, or NULL if error.
+ */
+const byte *parseExpression(const byte *lpBuf, MpalHandle *h) {
+ LpExpression cur;
+ byte *start;
+
+ uint32 num = *lpBuf;
+ lpBuf++;
+
+ if (num == 0)
+ return NULL;
+
+ *h = globalAllocate(GMEM_MOVEABLE | GMEM_ZEROINIT, num * sizeof(Expression) + 1);
+ if (*h == NULL)
+ return NULL;
+
+ start = (byte *)globalLock(*h);
+ *start = (byte)num;
+
+ cur = (LpExpression)(start + 1);
+
+ for (uint32 i = 0;i < num; i++) {
+ cur->_type = *(lpBuf);
+ cur->_unary = *(lpBuf + 1);
+ lpBuf += 2;
+ switch (cur->_type) {
+ case ELT_NUMBER:
+ cur->_val._num = (int32)READ_LE_UINT32(lpBuf);
+ lpBuf += 4;
+ break;
+
+ case ELT_VAR:
+ cur->_val._name = (char *)globalAlloc(GMEM_FIXED | GMEM_ZEROINIT, (*lpBuf) + 1);
+ if (cur->_val._name == NULL)
+ return NULL;
+ memcpy(cur->_val._name, lpBuf + 1, *lpBuf);
+ lpBuf += *lpBuf + 1;
+ break;
+
+ case ELT_PARENTH:
+ lpBuf = parseExpression(lpBuf, &cur->_val._son);
+ if (lpBuf == NULL)
+ return NULL;
+ break;
+
+ default:
+ return NULL;
+ }
+
+ cur->_symbol = *lpBuf;
+ lpBuf++;
+
+ cur++;
+ }
+
+ if (*lpBuf != 0)
+ return NULL;
+
+ lpBuf++;
+
+ return lpBuf;
+}
+
+
+/**
+ * Calculate the value of a mathamatical expression
+ *
+ * @param h Handle to the expression
+ * @returns Numeric value
+ */
+int evaluateExpression(MpalHandle h) {
+ int ret;
+
+ lockVar();
+ ret = evaluateAndFreeExpression(duplicateExpression(h));
+ unlockVar();
+
+ return ret;
+}
+
+/**
+ * Compare two mathematical expressions together
+ *
+ * @param h1 Expression to be compared
+ * @param h2 Expression to be compared
+ */
+bool compareExpressions(MpalHandle h1, MpalHandle h2) {
+ byte *e1, *e2;
+ LpExpression one, two;
+
+ e1 = (byte *)globalLock(h1);
+ e2 = (byte *)globalLock(h2);
+
+ int num1 = *(byte *)e1;
+ int num2 = *(byte *)e2;
+
+ if (num1 != num2) {
+ globalUnlock(h1);
+ globalUnlock(h2);
+ return false;
+ }
+
+ one = (LpExpression)(e1 + 1);
+ two = (LpExpression)(e2 + 1);
+
+ for (int i = 0; i < num1; i++) {
+ if (one->_type != two->_type || (i != num1 - 1 && one->_symbol != two->_symbol)) {
+ globalUnlock(h1);
+ globalUnlock(h2);
+ return false;
+ }
+
+ switch (one->_type) {
+ case ELT_NUMBER:
+ if (one->_val._num != two->_val._num) {
+ globalUnlock(h1);
+ globalUnlock(h2);
+ return false;
+ }
+ break;
+
+ case ELT_VAR:
+ if (strcmp(one->_val._name, two->_val._name) != 0) {
+ globalUnlock(h1);
+ globalUnlock(h2);
+ return false;
+ }
+ break;
+
+ case ELT_PARENTH:
+ if (!compareExpressions(one->_val._son, two->_val._son)) {
+ globalUnlock(h1);
+ globalUnlock(h2);
+ return false;
+ }
+ break;
+ }
+
+ ++one;
+ ++two;
+ }
+
+ globalUnlock(h1);
+ globalUnlock(h2);
+
+ return true;
+}
+
+/**
+ * Frees an expression that was previously parsed
+ *
+ * @param h Handle for the expression
+ */
+void freeExpression(MpalHandle h) {
+ byte *data = (byte *)globalLock(h);
+ int num = *data;
+ LpExpression cur = (LpExpression)(data + 1);
+
+ for (int i = 0; i < num; ++i, ++cur) {
+ switch (cur->_type) {
+ case ELT_VAR:
+ globalDestroy(cur->_val._name);
+ break;
+
+ case ELT_PARENTH:
+ freeExpression(cur->_val._son);
+ break;
+
+ default:
+ break;
+ }
+ }
+
+ globalUnlock(h);
+ globalFree(h);
+}
+
+} // end of namespace MPAL
+
+} // end of namespace Tony
diff --git a/engines/tony/mpal/expr.h b/engines/tony/mpal/expr.h
new file mode 100644
index 0000000000..9036099993
--- /dev/null
+++ b/engines/tony/mpal/expr.h
@@ -0,0 +1,79 @@
+/* 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.
+ *
+ *
+ */
+/*
+ * This code is based on original Tony Tough source code
+ *
+ * Copyright (c) 1997-2003 Nayma Software
+ */
+
+#ifndef MPAL_EXPR_H
+#define MPAL_EXPR_H
+
+#include "tony/mpal/memory.h"
+
+namespace Tony {
+
+namespace MPAL {
+
+/****************************************************************************\
+* Function Prototypes
+\****************************************************************************/
+
+/**
+ * Parses a mathematical expression from the MPC file
+ *
+ * @param buf Buffer containing the expression to evaluate
+ * @param h Pointer to a handle that, at the end of execution,
+ * will point to the area of memory containing the parsed expression
+ * @returns Pointer to the buffer immediately after the expression, or NULL if error.
+ */
+const byte *parseExpression(const byte *lpBuf, MpalHandle *h);
+
+/**
+ * Calculate the value of a mathamatical expression
+ *
+ * @param h Handle to the expression
+ * @returns Numeric value
+ */
+int evaluateExpression(MpalHandle h);
+
+/**
+ * Compare two mathematical expressions together
+ *
+ * @param h1 Expression to be compared
+ * @param h2 Expression to be compared
+ */
+bool compareExpressions(MpalHandle h1, MpalHandle h2);
+
+/**
+ * Frees an expression that was previously parsed
+ *
+ * @param h Handle for the expression
+ */
+void freeExpression(MpalHandle h);
+
+} // end of namespace MPAL
+
+} // end of namespace Tony
+
+#endif
diff --git a/engines/tony/mpal/loadmpc.cpp b/engines/tony/mpal/loadmpc.cpp
new file mode 100644
index 0000000000..953820be74
--- /dev/null
+++ b/engines/tony/mpal/loadmpc.cpp
@@ -0,0 +1,790 @@
+/* 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.
+ *
+ *
+ */
+/*
+ * This code is based on original Tony Tough source code
+ *
+ * Copyright (c) 1997-2003 Nayma Software
+ */
+
+#include "mpal.h"
+#include "mpaldll.h"
+#include "memory.h"
+#include "tony/tony.h"
+
+namespace Tony {
+
+namespace MPAL {
+
+/****************************************************************************\
+* Static functions
+\****************************************************************************/
+
+static bool compareCommands(struct Command *cmd1, struct Command *cmd2) {
+ if (cmd1->_type == 2 && cmd2->_type == 2) {
+ if (strcmp(cmd1->_lpszVarName, cmd2->_lpszVarName) == 0 &&
+ compareExpressions(cmd1->_expr, cmd2->_expr))
+ return true;
+ else
+ return false;
+ } else
+ return (memcmp(cmd1, cmd2, sizeof(struct Command)) == 0);
+}
+
+/**
+ * Parses a script from the MPC file, and inserts its data into a structure
+ *
+ * @param lpBuf Buffer containing the compiled script.
+ * @param lpmsScript Pointer to a structure that will be filled with the
+ * data of the script.
+ * @returns Pointer to the buffer after the item, or NULL on failure.
+ */
+static const byte *ParseScript(const byte *lpBuf, LpMpalScript lpmsScript) {
+ lpmsScript->_nObj = (int32)READ_LE_UINT32(lpBuf);
+ lpBuf += 4;
+
+ lpmsScript->_nMoments = READ_LE_UINT16(lpBuf);
+ lpBuf += 2;
+
+ int curCmd = 0;
+
+ for (uint i = 0; i < lpmsScript->_nMoments; i++) {
+ lpmsScript->_moment[i]._dwTime = (int32)READ_LE_UINT32(lpBuf);
+ lpBuf += 4;
+ lpmsScript->_moment[i]._nCmds = *lpBuf;
+ lpBuf++;
+
+ for (int j = 0; j < lpmsScript->_moment[i]._nCmds; j++) {
+ lpmsScript->_command[curCmd]._type = *lpBuf;
+ lpBuf++;
+ switch (lpmsScript->_command[curCmd]._type) {
+ case 1:
+ lpmsScript->_command[curCmd]._nCf = READ_LE_UINT16(lpBuf);
+ lpBuf += 2;
+ lpmsScript->_command[curCmd]._arg1 = (int32)READ_LE_UINT32(lpBuf);
+ lpBuf += 4;
+ lpmsScript->_command[curCmd]._arg2 = (int32)READ_LE_UINT32(lpBuf);
+ lpBuf += 4;
+ lpmsScript->_command[curCmd]._arg3 = (int32)READ_LE_UINT32(lpBuf);
+ lpBuf += 4;
+ lpmsScript->_command[curCmd]._arg4 = (int32)READ_LE_UINT32(lpBuf);
+ lpBuf += 4;
+ break;
+
+ case 2: { // Variable assign
+ int len = *lpBuf;
+ lpBuf++;
+ lpmsScript->_command[curCmd]._lpszVarName = (char *)globalAlloc(GMEM_FIXED | GMEM_ZEROINIT, len + 1);
+ if (lpmsScript->_command[curCmd]._lpszVarName == NULL)
+ return NULL;
+ memcpy(lpmsScript->_command[curCmd]._lpszVarName, lpBuf, len);
+ lpBuf += len;
+
+ lpBuf = parseExpression(lpBuf, &lpmsScript->_command[curCmd]._expr);
+ if (lpBuf == NULL)
+ return NULL;
+ break;
+ }
+ default:
+ return NULL;
+ }
+
+ lpmsScript->_moment[i]._cmdNum[j] = curCmd;
+ curCmd++;
+ }
+ }
+ return lpBuf;
+}
+
+/**
+ * Frees a script allocated via a previous call to ParseScript
+ *
+ * @param lpmsScript Pointer to a script structure
+ */
+static void FreeScript(LpMpalScript lpmsScript) {
+ for (int i = 0; i < MAX_COMMANDS_PER_SCRIPT && (lpmsScript->_command[i]._type); ++i, ++lpmsScript) {
+ if (lpmsScript->_command[i]._type == 2) {
+ // Variable Assign
+ globalDestroy(lpmsScript->_command[i]._lpszVarName);
+ freeExpression(lpmsScript->_command[i]._expr);
+ }
+ }
+}
+
+/**
+ * Parses a dialog from the MPC file, and inserts its data into a structure
+ *
+ * @param lpBuf Buffer containing the compiled dialog.
+ * @param lpmdDialog Pointer to a structure that will be filled with the
+ * data of the dialog.
+ * @returns Pointer to the buffer after the item, or NULL on failure.
+ */
+static const byte *parseDialog(const byte *lpBuf, LpMpalDialog lpmdDialog) {
+ uint32 num2, num3;
+ byte *lpLock;
+
+ lpmdDialog->_nObj = READ_LE_UINT32(lpBuf);
+ lpBuf += 4;
+
+ // Periods
+ uint32 num = READ_LE_UINT16(lpBuf);
+ lpBuf += 2;
+
+ if (num >= MAX_PERIODS_PER_DIALOG - 1)
+ error("Too much periods in dialog #%d", lpmdDialog->_nObj);
+
+ uint32 i;
+ for (i = 0; i < num; i++) {
+ lpmdDialog->_periodNums[i] = READ_LE_UINT16(lpBuf);
+ lpBuf += 2;
+ lpmdDialog->_periods[i] = globalAllocate(GMEM_MOVEABLE | GMEM_ZEROINIT, *lpBuf + 1);
+ lpLock = (byte *)globalLock(lpmdDialog->_periods[i]);
+ Common::copy(lpBuf + 1, lpBuf + 1 + *lpBuf, lpLock);
+ globalUnlock(lpmdDialog->_periods[i]);
+ lpBuf += (*lpBuf) + 1;
+ }
+
+ lpmdDialog->_periodNums[i] = 0;
+ lpmdDialog->_periods[i] = NULL;
+
+ // Groups
+ num = READ_LE_UINT16(lpBuf);
+ lpBuf += 2;
+ uint32 curCmd = 0;
+
+ if (num >= MAX_GROUPS_PER_DIALOG)
+ error("Too much groups in dialog #%d", lpmdDialog->_nObj);
+
+ for (i = 0; i < num; i++) {
+ lpmdDialog->_group[i]._num = READ_LE_UINT16(lpBuf);
+ lpBuf += 2;
+ lpmdDialog->_group[i]._nCmds = *lpBuf; lpBuf++;
+
+ if (lpmdDialog->_group[i]._nCmds >= MAX_COMMANDS_PER_GROUP)
+ error("Too much commands in group #%d in dialog #%d", lpmdDialog->_group[i]._num, lpmdDialog->_nObj);
+
+ for (uint32 j = 0; j < lpmdDialog->_group[i]._nCmds; j++) {
+ lpmdDialog->_command[curCmd]._type = *lpBuf;
+ lpBuf++;
+
+ switch (lpmdDialog->_command[curCmd]._type) {
+ // Call custom function
+ case 1:
+ lpmdDialog->_command[curCmd]._nCf = READ_LE_UINT16(lpBuf);
+ lpBuf += 2;
+ lpmdDialog->_command[curCmd]._arg1 = READ_LE_UINT32(lpBuf);
+ lpBuf += 4;
+ lpmdDialog->_command[curCmd]._arg2 = READ_LE_UINT32(lpBuf);
+ lpBuf += 4;
+ lpmdDialog->_command[curCmd]._arg3 = READ_LE_UINT32(lpBuf);
+ lpBuf += 4;
+ lpmdDialog->_command[curCmd]._arg4 = READ_LE_UINT32(lpBuf);
+ lpBuf += 4;
+ break;
+
+ // Variable assign
+ case 2: {
+ uint32 len = *lpBuf;
+ lpBuf++;
+ lpmdDialog->_command[curCmd]._lpszVarName = (char *)globalAlloc(GMEM_FIXED | GMEM_ZEROINIT, len + 1);
+ if (lpmdDialog->_command[curCmd]._lpszVarName == NULL)
+ return NULL;
+
+ Common::copy(lpBuf, lpBuf + len, lpmdDialog->_command[curCmd]._lpszVarName);
+ lpBuf += len;
+
+ lpBuf = parseExpression(lpBuf, &lpmdDialog->_command[curCmd]._expr);
+ if (lpBuf == NULL)
+ return NULL;
+ break;
+ }
+ // Do Choice
+ case 3:
+ lpmdDialog->_command[curCmd]._nChoice = READ_LE_UINT16(lpBuf);
+ lpBuf += 2;
+ break;
+
+ default:
+ return NULL;
+ }
+
+ uint32 kk;
+ for (kk = 0;kk < curCmd; kk++) {
+ if (compareCommands(&lpmdDialog->_command[kk], &lpmdDialog->_command[curCmd])) {
+ lpmdDialog->_group[i]._cmdNum[j] = kk;
+
+ // Free any data allocated for the duplictaed command
+ if (lpmdDialog->_command[curCmd]._type == 2) {
+ globalDestroy(lpmdDialog->_command[curCmd]._lpszVarName);
+ freeExpression(lpmdDialog->_command[curCmd]._expr);
+
+ lpmdDialog->_command[curCmd]._lpszVarName = NULL;
+ lpmdDialog->_command[curCmd]._expr = 0;
+ lpmdDialog->_command[curCmd]._type = 0;
+ }
+ break;
+ }
+ }
+
+ if (kk == curCmd) {
+ lpmdDialog->_group[i]._cmdNum[j] = curCmd;
+ curCmd++;
+ }
+ }
+ }
+
+ if (curCmd >= MAX_COMMANDS_PER_DIALOG)
+ error("Too much commands in dialog #%d", lpmdDialog->_nObj);
+
+ // Choices
+ num = READ_LE_UINT16(lpBuf);
+ lpBuf += 2;
+
+ if (num >= MAX_CHOICES_PER_DIALOG)
+ error("Too much choices in dialog #%d", lpmdDialog->_nObj);
+
+ for (i = 0; i < num; i++) {
+ lpmdDialog->_choice[i]._nChoice = READ_LE_UINT16(lpBuf);
+ lpBuf += 2;
+
+ num2 = *lpBuf++;
+
+ if (num2 >= MAX_SELECTS_PER_CHOICE)
+ error("Too much selects in choice #%d in dialog #%d", lpmdDialog->_choice[i]._nChoice, lpmdDialog->_nObj);
+
+ for (uint32 j = 0; j < num2; j++) {
+ // When
+ switch (*lpBuf++) {
+ case 0:
+ lpmdDialog->_choice[i]._select[j]._when = NULL;
+ break;
+
+ case 1:
+ lpBuf = parseExpression(lpBuf, &lpmdDialog->_choice[i]._select[j]._when);
+ if (lpBuf == NULL)
+ return NULL;
+ break;
+
+ case 2:
+ return NULL;
+ }
+
+ // Attrib
+ lpmdDialog->_choice[i]._select[j]._attr = *lpBuf++;
+
+ // Data
+ lpmdDialog->_choice[i]._select[j]._dwData = READ_LE_UINT32(lpBuf);
+ lpBuf += 4;
+
+ // PlayGroup
+ num3 = *lpBuf++;
+
+ if (num3 >= MAX_PLAYGROUPS_PER_SELECT)
+ error("Too much playgroups in select #%d in choice #%d in dialog #%d", j, lpmdDialog->_choice[i]._nChoice, lpmdDialog->_nObj);
+
+ for (uint32 z = 0; z < num3; z++) {
+ lpmdDialog->_choice[i]._select[j]._wPlayGroup[z] = READ_LE_UINT16(lpBuf);
+ lpBuf += 2;
+ }
+
+ lpmdDialog->_choice[i]._select[j]._wPlayGroup[num3] = 0;
+ }
+
+ // Mark the last selection
+ lpmdDialog->_choice[i]._select[num2]._dwData = 0;
+ }
+
+ lpmdDialog->_choice[num]._nChoice = 0;
+
+ return lpBuf;
+}
+
+
+/**
+ * Parses an item from the MPC file, and inserts its data into a structure
+ *
+ * @param lpBuf Buffer containing the compiled dialog.
+ * @param lpmiItem Pointer to a structure that will be filled with the
+ * data of the item.
+ * @returns Pointer to the buffer after the item, or NULL on failure.
+ * @remarks It's necessary that the structure that is passed has been
+ * completely initialized to 0 beforehand.
+ */
+static const byte *parseItem(const byte *lpBuf, LpMpalItem lpmiItem) {
+ lpmiItem->_nObj = (int32)READ_LE_UINT32(lpBuf);
+ lpBuf += 4;
+
+ byte len = *lpBuf;
+ lpBuf++;
+ memcpy(lpmiItem->_lpszDescribe, lpBuf, MIN((byte)127, len));
+ lpBuf += len;
+
+ if (len >= MAX_DESCRIBE_SIZE)
+ error("Describe too long in item #%d", lpmiItem->_nObj);
+
+ lpmiItem->_nActions=*lpBuf;
+ lpBuf++;
+
+ // Allocation action
+ if (lpmiItem->_nActions > 0)
+ lpmiItem->_action = (ItemAction *)globalAlloc(GMEM_FIXED | GMEM_ZEROINIT, sizeof(struct ItemAction) * (int)lpmiItem->_nActions);
+
+ uint32 curCmd = 0;
+
+ for (uint32 i = 0; i < lpmiItem->_nActions; i++) {
+ lpmiItem->_action[i]._num = *lpBuf;
+ lpBuf++;
+
+ lpmiItem->_action[i]._wParm = READ_LE_UINT16(lpBuf);
+ lpBuf += 2;
+
+ if (lpmiItem->_action[i]._num == 0xFF) {
+ lpmiItem->_action[i]._wTime = READ_LE_UINT16(lpBuf);
+ lpBuf += 2;
+
+ lpmiItem->_action[i]._perc = *lpBuf;
+ lpBuf++;
+ }
+
+
+ if (*lpBuf == 0) {
+ lpBuf++;
+ lpmiItem->_action[i]._when = NULL;
+ } else {
+ lpBuf++;
+ lpBuf = parseExpression(lpBuf,&lpmiItem->_action[i]._when);
+ if (lpBuf == NULL)
+ return NULL;
+ }
+
+ lpmiItem->_action[i]._nCmds=*lpBuf;
+ lpBuf++;
+
+ if (lpmiItem->_action[i]._nCmds >= MAX_COMMANDS_PER_ACTION)
+ error("Too much commands in action #%d in item #%d", lpmiItem->_action[i]._num, lpmiItem->_nObj);
+
+ for (uint32 j = 0; j < lpmiItem->_action[i]._nCmds; j++) {
+ lpmiItem->_command[curCmd]._type = *lpBuf;
+ lpBuf++;
+ switch (lpmiItem->_command[curCmd]._type) {
+ case 1: // Call custom function
+ lpmiItem->_command[curCmd]._nCf = READ_LE_UINT16(lpBuf);
+ lpBuf += 2;
+ lpmiItem->_command[curCmd]._arg1 = (int32)READ_LE_UINT32(lpBuf);
+ lpBuf += 4;
+ lpmiItem->_command[curCmd]._arg2 = (int32)READ_LE_UINT32(lpBuf);
+ lpBuf += 4;
+ lpmiItem->_command[curCmd]._arg3 = (int32)READ_LE_UINT32(lpBuf);
+ lpBuf += 4;
+ lpmiItem->_command[curCmd]._arg4 = (int32)READ_LE_UINT32(lpBuf);
+ lpBuf += 4;
+ break;
+
+ case 2: // Variable assign
+ len = *lpBuf;
+ lpBuf++;
+ lpmiItem->_command[curCmd]._lpszVarName = (char *)globalAlloc(GMEM_FIXED | GMEM_ZEROINIT, len + 1);
+ if (lpmiItem->_command[curCmd]._lpszVarName == NULL)
+ return NULL;
+ memcpy(lpmiItem->_command[curCmd]._lpszVarName, lpBuf, len);
+ lpBuf += len;
+
+ lpBuf = parseExpression(lpBuf, &lpmiItem->_command[curCmd]._expr);
+ if (lpBuf == NULL)
+ return NULL;
+ break;
+
+ default:
+ return NULL;
+ }
+
+ uint32 kk;
+ for (kk = 0; kk < curCmd; kk++) {
+ if (compareCommands(&lpmiItem->_command[kk], &lpmiItem->_command[curCmd])) {
+ lpmiItem->_action[i]._cmdNum[j] = kk;
+
+ // Free any data allocated for the duplictaed command
+ if (lpmiItem->_command[curCmd]._type == 2) {
+ globalDestroy(lpmiItem->_command[curCmd]._lpszVarName);
+ freeExpression(lpmiItem->_command[curCmd]._expr);
+
+ lpmiItem->_command[curCmd]._lpszVarName = NULL;
+ lpmiItem->_command[curCmd]._expr = 0;
+ lpmiItem->_command[curCmd]._type = 0;
+ }
+ break;
+ }
+ }
+
+ if (kk == curCmd) {
+ lpmiItem->_action[i]._cmdNum[j] = curCmd;
+ curCmd++;
+
+ if (curCmd >= MAX_COMMANDS_PER_ITEM) {
+ error("Too much commands in item #%d", lpmiItem->_nObj);
+ //curCmd=0;
+ }
+ }
+ }
+ }
+
+ lpmiItem->_dwRes = READ_LE_UINT32(lpBuf);
+ lpBuf += 4;
+
+ return lpBuf;
+}
+
+/**
+ * Frees an item parsed from a prior call to ParseItem
+ *
+ * @param lpmiItem Pointer to an item structure
+ */
+static void freeItem(LpMpalItem lpmiItem) {
+ // Free the actions
+ if (lpmiItem->_action) {
+ for (int i = 0; i < lpmiItem->_nActions; ++i) {
+ if (lpmiItem->_action[i]._when != 0)
+ freeExpression(lpmiItem->_action[i]._when);
+ }
+
+ globalDestroy(lpmiItem->_action);
+ }
+
+ // Free the commands
+ for (int i = 0; i < MAX_COMMANDS_PER_ITEM && (lpmiItem->_command[i]._type); ++i) {
+ if (lpmiItem->_command[i]._type == 2) {
+ // Variable Assign
+ globalDestroy(lpmiItem->_command[i]._lpszVarName);
+ freeExpression(lpmiItem->_command[i]._expr);
+ }
+ }
+}
+
+/**
+ * Parses a location from the MPC file, and inserts its data into a structure
+ *
+ * @param lpBuf Buffer containing the compiled location.
+ * @param lpmiLocation Pointer to a structure that will be filled with the
+ * data of the location.
+ * @returns Pointer to the buffer after the location, or NULL on failure.
+ */
+static const byte *ParseLocation(const byte *lpBuf, LpMpalLocation lpmlLocation) {
+ lpmlLocation->_nObj = (int32)READ_LE_UINT32(lpBuf);
+ lpBuf += 4;
+ lpmlLocation->_dwXlen = READ_LE_UINT16(lpBuf);
+ lpBuf += 2;
+ lpmlLocation->_dwYlen = READ_LE_UINT16(lpBuf);
+ lpBuf += 2;
+ lpmlLocation->_dwPicRes = READ_LE_UINT32(lpBuf);
+ lpBuf += 4;
+
+ return lpBuf;
+}
+
+
+/****************************************************************************\
+* Exported functions
+\****************************************************************************/
+/**
+ * @defgroup Exported functions
+ */
+//@{
+
+/**
+ * Reads and interprets the MPC file, and create structures for various directives
+ * in the global variables
+ *
+ * @param lpBuf Buffer containing the MPC file data, excluding the header.
+ * @returns True if succeeded OK, false if failure.
+ */
+bool parseMpc(const byte *lpBuf) {
+ byte *lpTemp;
+
+ // 1. Variables
+ if (lpBuf[0] != 'V' || lpBuf[1] != 'A' || lpBuf[2] != 'R' || lpBuf[3] != 'S')
+ return false;
+
+ lpBuf += 4;
+ GLOBALS._nVars = READ_LE_UINT16(lpBuf);
+ lpBuf += 2;
+
+ GLOBALS._hVars = globalAllocate(GMEM_MOVEABLE | GMEM_ZEROINIT, sizeof(MpalVar) * (uint32)GLOBALS._nVars);
+ if (GLOBALS._hVars == NULL)
+ return false;
+
+ GLOBALS._lpmvVars = (LpMpalVar)globalLock(GLOBALS._hVars);
+
+ for (uint16 i = 0; i < GLOBALS._nVars; i++) {
+ uint16 wLen = *(const byte *)lpBuf;
+ lpBuf++;
+ memcpy(GLOBALS._lpmvVars->_lpszVarName, lpBuf, MIN(wLen, (uint16)32));
+ lpBuf += wLen;
+ GLOBALS._lpmvVars->_dwVal = READ_LE_UINT32(lpBuf);
+ lpBuf += 4;
+
+ lpBuf++; // Skip 'ext'
+ GLOBALS._lpmvVars++;
+ }
+
+ globalUnlock(GLOBALS._hVars);
+
+ // 2. Messages
+ if (lpBuf[0] != 'M' || lpBuf[1] != 'S' || lpBuf[2] != 'G' || lpBuf[3] != 'S')
+ return false;
+
+ lpBuf += 4;
+ GLOBALS._nMsgs = READ_LE_UINT16(lpBuf);
+ lpBuf += 2;
+
+#ifdef NEED_LOCK_MSGS
+ GLOBALS._hMsgs = globalAllocate(GMEM_MOVEABLE | GMEM_ZEROINIT, sizeof(MpalMsg) * (uint32)GLOBALS._nMsgs);
+ if (GLOBALS._hMsgs == NULL)
+ return false;
+
+ GLOBALS._lpmmMsgs = (LpMpalMsg)globalLock(GLOBALS._hMsgs);
+#else
+ GLOBALS._lpmmMsgs=(LPMPALMSG)globalAlloc(GMEM_FIXED | GMEM_ZEROINIT, sizeof(MPALMSG) * (uint32)GLOBALS._nMsgs);
+ if (GLOBALS._lpmmMsgs==NULL)
+ return false;
+#endif
+
+ for (uint16 i = 0; i < GLOBALS._nMsgs; i++) {
+ GLOBALS._lpmmMsgs->_wNum = READ_LE_UINT16(lpBuf);
+ lpBuf += 2;
+
+ uint16 j;
+ for (j = 0; lpBuf[j] != 0;)
+ j += lpBuf[j] + 1;
+
+ GLOBALS._lpmmMsgs->_hText = globalAllocate(GMEM_MOVEABLE | GMEM_ZEROINIT, j + 1);
+ lpTemp = (byte *)globalLock(GLOBALS._lpmmMsgs->_hText);
+
+ for (j = 0; lpBuf[j] != 0;) {
+ memcpy(lpTemp, &lpBuf[j + 1], lpBuf[j]);
+ lpTemp += lpBuf[j];
+ *lpTemp ++= '\0';
+ j += lpBuf[j] + 1;
+ }
+
+ lpBuf += j + 1;
+ *lpTemp = '\0';
+
+ globalUnlock(GLOBALS._lpmmMsgs->_hText);
+ GLOBALS._lpmmMsgs++;
+ }
+
+#ifdef NEED_LOCK_MSGS
+ globalUnlock(GLOBALS._hMsgs);
+#endif
+
+ // 3. Objects
+ if (lpBuf[0] != 'O' || lpBuf[1] != 'B' || lpBuf[2] != 'J' || lpBuf[3] != 'S')
+ return false;
+
+ lpBuf += 4;
+ GLOBALS._nObjs = READ_LE_UINT16(lpBuf);
+ lpBuf += 2;
+
+ // Check out the dialogs
+ GLOBALS._nDialogs = 0;
+ GLOBALS._hDialogs = GLOBALS._lpmdDialogs = NULL;
+ if (*((const byte *)lpBuf + 2) == 6 && strncmp((const char *)lpBuf + 3, "Dialog", 6) == 0) {
+ GLOBALS._nDialogs = READ_LE_UINT16(lpBuf);
+ lpBuf += 2;
+
+ GLOBALS._hDialogs = globalAllocate(GMEM_MOVEABLE | GMEM_ZEROINIT, (uint32)GLOBALS._nDialogs * sizeof(MpalDialog));
+ if (GLOBALS._hDialogs == NULL)
+ return false;
+
+ GLOBALS._lpmdDialogs = (LpMpalDialog)globalLock(GLOBALS._hDialogs);
+
+ for (uint16 i = 0; i < GLOBALS._nDialogs; i++) {
+ if ((lpBuf = parseDialog(lpBuf + 7, &GLOBALS._lpmdDialogs[i])) == NULL)
+ return false;
+ }
+
+ globalUnlock(GLOBALS._hDialogs);
+ }
+
+ // Check the items
+ GLOBALS._nItems = 0;
+ GLOBALS._hItems = GLOBALS._lpmiItems = NULL;
+ if (*(lpBuf + 2) == 4 && strncmp((const char *)lpBuf + 3, "Item", 4) == 0) {
+ GLOBALS._nItems = READ_LE_UINT16(lpBuf);
+ lpBuf += 2;
+
+ // Allocate memory and read them in
+ GLOBALS._hItems = globalAllocate(GMEM_MOVEABLE | GMEM_ZEROINIT, (uint32)GLOBALS._nItems * sizeof(MpalItem));
+ if (GLOBALS._hItems == NULL)
+ return false;
+
+ GLOBALS._lpmiItems = (LpMpalItem)globalLock(GLOBALS._hItems);
+
+ for (uint16 i = 0; i < GLOBALS._nItems; i++) {
+ if ((lpBuf = parseItem(lpBuf + 5, &GLOBALS._lpmiItems[i])) == NULL)
+ return false;
+ }
+
+ globalUnlock(GLOBALS._hItems);
+ }
+
+ // Check the locations
+ GLOBALS._nLocations = 0;
+ GLOBALS._hLocations = GLOBALS._lpmlLocations = NULL;
+ if (*(lpBuf + 2) == 8 && strncmp((const char *)lpBuf + 3, "Location", 8) == 0) {
+ GLOBALS._nLocations = READ_LE_UINT16(lpBuf);
+ lpBuf += 2;
+
+ // Allocate memory and read them in
+ GLOBALS._hLocations = globalAllocate(GMEM_MOVEABLE | GMEM_ZEROINIT, (uint32)GLOBALS._nLocations * sizeof(MpalLocation));
+ if (GLOBALS._hLocations == NULL)
+ return false;
+
+ GLOBALS._lpmlLocations = (LpMpalLocation)globalLock(GLOBALS._hLocations);
+
+ for (uint16 i = 0; i < GLOBALS._nLocations; i++) {
+ if ((lpBuf = ParseLocation(lpBuf + 9, &GLOBALS._lpmlLocations[i])) == NULL)
+ return false;
+ }
+
+ globalUnlock(GLOBALS._hLocations);
+ }
+
+ // Check the scripts
+ GLOBALS._nScripts = 0;
+ GLOBALS._hScripts = GLOBALS._lpmsScripts = NULL;
+ if (*(lpBuf + 2) == 6 && strncmp((const char *)lpBuf + 3, "Script", 6) == 0) {
+ GLOBALS._nScripts = READ_LE_UINT16(lpBuf);
+ lpBuf += 2;
+
+ // Allocate memory
+ GLOBALS._hScripts = globalAllocate(GMEM_MOVEABLE | GMEM_ZEROINIT, (uint32)GLOBALS._nScripts * sizeof(MpalScript));
+ if (GLOBALS._hScripts == NULL)
+ return false;
+
+ GLOBALS._lpmsScripts = (LpMpalScript)globalLock(GLOBALS._hScripts);
+
+ for (uint16 i = 0; i < GLOBALS._nScripts; i++) {
+ if ((lpBuf = ParseScript(lpBuf + 7, &GLOBALS._lpmsScripts[i])) == NULL)
+ return false;
+
+ // Sort the various moments of the script
+ //qsort(
+ //GLOBALS.lpmsScripts[i].Moment,
+ //GLOBALS.lpmsScripts[i].nMoments,
+ //sizeof(GLOBALS.lpmsScripts[i].Moment[0]),
+ //(int (*)(const void *, const void *))CompareMoments
+ //);
+ }
+
+ globalUnlock(GLOBALS._hScripts);
+ }
+
+ if (lpBuf[0] != 'E' || lpBuf[1] != 'N' || lpBuf[2] != 'D' || lpBuf[3] != '0')
+ return false;
+
+ return true;
+}
+
+/**
+ * Free the given dialog
+ */
+static void freeDialog(LpMpalDialog lpmdDialog) {
+ // Free the periods
+ for (int i = 0; i < MAX_PERIODS_PER_DIALOG && (lpmdDialog->_periods[i]); ++i)
+ globalFree(lpmdDialog->_periods[i]);
+
+ for (int i = 0; i < MAX_COMMANDS_PER_DIALOG && (lpmdDialog->_command[i]._type); i++) {
+ if (lpmdDialog->_command[i]._type == 2) {
+ // Variable assign
+ globalDestroy(lpmdDialog->_command[i]._lpszVarName);
+ freeExpression(lpmdDialog->_command[i]._expr);
+ }
+ }
+
+ // Free the choices
+ for (int i = 0; i < MAX_CHOICES_PER_DIALOG; ++i) {
+ for (int j = 0; j < MAX_SELECTS_PER_CHOICE; j++) {
+ if (lpmdDialog->_choice[i]._select[j]._when)
+ freeExpression(lpmdDialog->_choice[i]._select[j]._when);
+ }
+ }
+}
+
+/**
+ * Frees any data allocated from the parsing of the MPC file
+ */
+void freeMpc() {
+ // Free variables
+ globalFree(GLOBALS._hVars);
+
+ // Free messages
+ LpMpalMsg lpmmMsgs = (LpMpalMsg)globalLock(GLOBALS._hMsgs);
+ for (int i = 0; i < GLOBALS._nMsgs; i++, ++lpmmMsgs)
+ globalFree(lpmmMsgs->_hText);
+
+ globalUnlock(GLOBALS._hMsgs);
+ globalFree(GLOBALS._hMsgs);
+
+ // Free objects
+ if (GLOBALS._hDialogs) {
+ LpMpalDialog lpmdDialogs = (LpMpalDialog)globalLock(GLOBALS._hDialogs);
+
+ for (int i = 0; i < GLOBALS._nDialogs; i++, ++lpmdDialogs)
+ freeDialog(lpmdDialogs);
+
+ globalFree(GLOBALS._hDialogs);
+ }
+
+ // Free items
+ if (GLOBALS._hItems) {
+ LpMpalItem lpmiItems = (LpMpalItem)globalLock(GLOBALS._hItems);
+
+ for (int i = 0; i < GLOBALS._nItems; ++i, ++lpmiItems)
+ freeItem(lpmiItems);
+
+ globalUnlock(GLOBALS._hItems);
+ globalFree(GLOBALS._hItems);
+ }
+
+ // Free the locations
+ if (GLOBALS._hLocations) {
+ globalFree(GLOBALS._hLocations);
+ }
+
+ // Free the scripts
+ if (GLOBALS._hScripts) {
+ LpMpalScript lpmsScripts = (LpMpalScript)globalLock(GLOBALS._hScripts);
+
+ for (int i = 0; i < GLOBALS._nScripts; ++i, ++lpmsScripts) {
+ FreeScript(lpmsScripts);
+ }
+
+ globalUnlock(GLOBALS._hScripts);
+ }
+}
+
+//@}
+
+} // end of namespace MPAL
+
+} // end of namespace Tony
diff --git a/engines/tony/mpal/loadmpc.h b/engines/tony/mpal/loadmpc.h
new file mode 100644
index 0000000000..20956288aa
--- /dev/null
+++ b/engines/tony/mpal/loadmpc.h
@@ -0,0 +1,59 @@
+/* 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.
+ *
+ *
+ */
+/*
+ * This code is based on original Tony Tough source code
+ *
+ * Copyright (c) 1997-2003 Nayma Software
+ */
+
+#ifndef __LOADMPC_H
+#define __LOADMPC_H
+
+namespace Tony {
+
+namespace MPAL {
+
+/****************************************************************************\
+* Function prototypes
+\****************************************************************************/
+
+/**
+ * Reads and interprets the MPC file, and create structures for various directives
+ * in the global variables
+ *
+ * @param lpBuf Buffer containing the MPC file data, excluding the header.
+ * @returns True if succeeded OK, false if failure.
+ */
+bool parseMpc(const byte *lpBuf);
+
+/**
+ * Frees any data allocated from the parsing of the MPC file
+ */
+void freeMpc();
+
+} // end of namespace MPAL
+
+} // end of namespace Tony
+
+#endif
+
diff --git a/engines/tony/mpal/lzo.cpp b/engines/tony/mpal/lzo.cpp
new file mode 100644
index 0000000000..3d0751a5ca
--- /dev/null
+++ b/engines/tony/mpal/lzo.cpp
@@ -0,0 +1,511 @@
+/* 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.
+ *
+ *
+ */
+/* minilzo.c -- mini subset of the LZO real-time data compression library
+
+ This file is part of the LZO real-time data compression library.
+
+ Copyright (C) 2011 Markus Franz Xaver Johannes Oberhumer
+ Copyright (C) 2010 Markus Franz Xaver Johannes Oberhumer
+ Copyright (C) 2009 Markus Franz Xaver Johannes Oberhumer
+ Copyright (C) 2008 Markus Franz Xaver Johannes Oberhumer
+ Copyright (C) 2007 Markus Franz Xaver Johannes Oberhumer
+ Copyright (C) 2006 Markus Franz Xaver Johannes Oberhumer
+ Copyright (C) 2005 Markus Franz Xaver Johannes Oberhumer
+ Copyright (C) 2004 Markus Franz Xaver Johannes Oberhumer
+ Copyright (C) 2003 Markus Franz Xaver Johannes Oberhumer
+ Copyright (C) 2002 Markus Franz Xaver Johannes Oberhumer
+ Copyright (C) 2001 Markus Franz Xaver Johannes Oberhumer
+ Copyright (C) 2000 Markus Franz Xaver Johannes Oberhumer
+ Copyright (C) 1999 Markus Franz Xaver Johannes Oberhumer
+ Copyright (C) 1998 Markus Franz Xaver Johannes Oberhumer
+ Copyright (C) 1997 Markus Franz Xaver Johannes Oberhumer
+ Copyright (C) 1996 Markus Franz Xaver Johannes Oberhumer
+ All Rights Reserved.
+
+ The LZO library 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.
+
+ The LZO library 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 the LZO library; see the file COPYING.
+ If not, write to the Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+
+ Markus F.X.J. Oberhumer
+ <markus@oberhumer.com>
+ http://www.oberhumer.com/opensource/lzo/
+ */
+
+#include "lzo.h"
+#include "common/textconsole.h"
+
+namespace Tony {
+
+namespace MPAL {
+
+#define pd(a, b) ((uint32) ((a) - (b)))
+
+#define TEST_IP (ip < ip_end)
+#define TEST_OP 1
+#define NEED_IP(x) ((void) 0)
+#define NEED_OP(x) ((void) 0)
+#define TEST_LB(m_pos) ((void) 0)
+
+#define M2_MAX_OFFSET 0x0800
+#define LZO1X
+
+/**
+ * Decompresses an LZO compressed resource
+ */
+int lzo1x_decompress(const byte *in, uint32 in_len, byte *out, uint32 *out_len) {
+ register byte *op;
+ register const byte *ip;
+ register uint32 t = 0;
+#if defined(COPY_DICT)
+ uint32 m_off;
+ const byte *dict_end;
+#else
+ register const byte *m_pos;
+#endif
+
+ const byte * const ip_end = in + in_len;
+#if defined(HAVE_ANY_OP)
+ byte * const op_end = out + *out_len;
+#endif
+#if defined(LZO1Z)
+ uint32 last_m_off = 0;
+#endif
+
+#if defined(COPY_DICT)
+ if (dict)
+ {
+ if (dict_len > M4_MAX_OFFSET)
+ {
+ dict += dict_len - M4_MAX_OFFSET;
+ dict_len = M4_MAX_OFFSET;
+ }
+ dict_end = dict + dict_len;
+ }
+ else
+ {
+ dict_len = 0;
+ dict_end = NULL;
+ }
+#endif
+
+ *out_len = 0;
+
+ op = out;
+ ip = in;
+
+ if (*ip > 17)
+ {
+ t = *ip++ - 17;
+ if (t < 4)
+ goto match_next;
+ assert(t > 0); NEED_OP(t); NEED_IP(t+1);
+ do *op++ = *ip++; while (--t > 0);
+ goto first_literal_run;
+ }
+
+ while (TEST_IP && TEST_OP)
+ {
+ t = *ip++;
+ if (t >= 16)
+ goto match;
+ if (t == 0)
+ {
+ NEED_IP(1);
+ while (*ip == 0)
+ {
+ t += 255;
+ ip++;
+ NEED_IP(1);
+ }
+ t += 15 + *ip++;
+ }
+ assert(t > 0); NEED_OP(t+3); NEED_IP(t+4);
+#if defined(LZO_UNALIGNED_OK_8) && defined(LZO_UNALIGNED_OK_4)
+ t += 3;
+ if (t >= 8) do
+ {
+ UA_COPY64(op, ip);
+ op += 8; ip += 8; t -= 8;
+ } while (t >= 8);
+ if (t >= 4)
+ {
+ UA_COPY32(op, ip);
+ op += 4; ip += 4; t -= 4;
+ }
+ if (t > 0)
+ {
+ *op++ = *ip++;
+ if (t > 1) { *op++ = *ip++; if (t > 2) { *op++ = *ip++; } }
+ }
+#elif defined(LZO_UNALIGNED_OK_4) || defined(LZO_ALIGNED_OK_4)
+#if !defined(LZO_UNALIGNED_OK_4)
+ if (PTR_ALIGNED2_4(op, ip))
+ {
+#endif
+ UA_COPY32(op, ip);
+ op += 4; ip += 4;
+ if (--t > 0)
+ {
+ if (t >= 4)
+ {
+ do {
+ UA_COPY32(op, ip);
+ op += 4; ip += 4; t -= 4;
+ } while (t >= 4);
+ if (t > 0) do *op++ = *ip++; while (--t > 0);
+ }
+ else
+ do *op++ = *ip++; while (--t > 0);
+ }
+#if !defined(LZO_UNALIGNED_OK_4)
+ }
+ else
+#endif
+#endif
+#if !defined(LZO_UNALIGNED_OK_4) && !defined(LZO_UNALIGNED_OK_8)
+ {
+ *op++ = *ip++; *op++ = *ip++; *op++ = *ip++;
+ do *op++ = *ip++; while (--t > 0);
+ }
+#endif
+
+first_literal_run:
+
+ t = *ip++;
+ if (t >= 16)
+ goto match;
+#if defined(COPY_DICT)
+#if defined(LZO1Z)
+ m_off = (1 + M2_MAX_OFFSET) + (t << 6) + (*ip++ >> 2);
+ last_m_off = m_off;
+#else
+ m_off = (1 + M2_MAX_OFFSET) + (t >> 2) + (*ip++ << 2);
+#endif
+ NEED_OP(3);
+ t = 3; COPY_DICT(t, m_off)
+#else
+#if defined(LZO1Z)
+ t = (1 + M2_MAX_OFFSET) + (t << 6) + (*ip++ >> 2);
+ m_pos = op - t;
+ last_m_off = t;
+#else
+ m_pos = op - (1 + M2_MAX_OFFSET);
+ m_pos -= t >> 2;
+ m_pos -= *ip++ << 2;
+#endif
+ TEST_LB(m_pos); NEED_OP(3);
+ *op++ = *m_pos++; *op++ = *m_pos++; *op++ = *m_pos;
+#endif
+ goto match_done;
+
+ do {
+match:
+ if (t >= 64)
+ {
+#if defined(COPY_DICT)
+#if defined(LZO1X)
+ m_off = 1 + ((t >> 2) & 7) + (*ip++ << 3);
+ t = (t >> 5) - 1;
+#elif defined(LZO1Y)
+ m_off = 1 + ((t >> 2) & 3) + (*ip++ << 2);
+ t = (t >> 4) - 3;
+#elif defined(LZO1Z)
+ m_off = t & 0x1f;
+ if (m_off >= 0x1c)
+ m_off = last_m_off;
+ else
+ {
+ m_off = 1 + (m_off << 6) + (*ip++ >> 2);
+ last_m_off = m_off;
+ }
+ t = (t >> 5) - 1;
+#endif
+#else
+#if defined(LZO1X)
+ m_pos = op - 1;
+ m_pos -= (t >> 2) & 7;
+ m_pos -= *ip++ << 3;
+ t = (t >> 5) - 1;
+#elif defined(LZO1Y)
+ m_pos = op - 1;
+ m_pos -= (t >> 2) & 3;
+ m_pos -= *ip++ << 2;
+ t = (t >> 4) - 3;
+#elif defined(LZO1Z)
+ {
+ uint32 off = t & 0x1f;
+ m_pos = op;
+ if (off >= 0x1c)
+ {
+ assert(last_m_off > 0);
+ m_pos -= last_m_off;
+ }
+ else
+ {
+ off = 1 + (off << 6) + (*ip++ >> 2);
+ m_pos -= off;
+ last_m_off = off;
+ }
+ }
+ t = (t >> 5) - 1;
+#endif
+ TEST_LB(m_pos); assert(t > 0); NEED_OP(t+3-1);
+ goto copy_match;
+#endif
+ }
+ else if (t >= 32)
+ {
+ t &= 31;
+ if (t == 0)
+ {
+ NEED_IP(1);
+ while (*ip == 0)
+ {
+ t += 255;
+ ip++;
+ NEED_IP(1);
+ }
+ t += 31 + *ip++;
+ }
+#if defined(COPY_DICT)
+#if defined(LZO1Z)
+ m_off = 1 + (ip[0] << 6) + (ip[1] >> 2);
+ last_m_off = m_off;
+#else
+ m_off = 1 + (ip[0] >> 2) + (ip[1] << 6);
+#endif
+#else
+#if defined(LZO1Z)
+ {
+ uint32 off = 1 + (ip[0] << 6) + (ip[1] >> 2);
+ m_pos = op - off;
+ last_m_off = off;
+ }
+#elif defined(LZO_UNALIGNED_OK_2) && defined(LZO_ABI_LITTLE_ENDIAN)
+ m_pos = op - 1;
+ m_pos -= UA_GET16(ip) >> 2;
+#else
+ m_pos = op - 1;
+ m_pos -= (ip[0] >> 2) + (ip[1] << 6);
+#endif
+#endif
+ ip += 2;
+ }
+ else if (t >= 16)
+ {
+#if defined(COPY_DICT)
+ m_off = (t & 8) << 11;
+#else
+ m_pos = op;
+ m_pos -= (t & 8) << 11;
+#endif
+ t &= 7;
+ if (t == 0)
+ {
+ NEED_IP(1);
+ while (*ip == 0)
+ {
+ t += 255;
+ ip++;
+ NEED_IP(1);
+ }
+ t += 7 + *ip++;
+ }
+#if defined(COPY_DICT)
+#if defined(LZO1Z)
+ m_off += (ip[0] << 6) + (ip[1] >> 2);
+#else
+ m_off += (ip[0] >> 2) + (ip[1] << 6);
+#endif
+ ip += 2;
+ if (m_off == 0)
+ goto eof_found;
+ m_off += 0x4000;
+#if defined(LZO1Z)
+ last_m_off = m_off;
+#endif
+#else
+#if defined(LZO1Z)
+ m_pos -= (ip[0] << 6) + (ip[1] >> 2);
+#elif defined(LZO_UNALIGNED_OK_2) && defined(LZO_ABI_LITTLE_ENDIAN)
+ m_pos -= UA_GET16(ip) >> 2;
+#else
+ m_pos -= (ip[0] >> 2) + (ip[1] << 6);
+#endif
+ ip += 2;
+ if (m_pos == op)
+ goto eof_found;
+ m_pos -= 0x4000;
+#if defined(LZO1Z)
+ last_m_off = pd((const byte *)op, m_pos);
+#endif
+#endif
+ }
+ else
+ {
+#if defined(COPY_DICT)
+#if defined(LZO1Z)
+ m_off = 1 + (t << 6) + (*ip++ >> 2);
+ last_m_off = m_off;
+#else
+ m_off = 1 + (t >> 2) + (*ip++ << 2);
+#endif
+ NEED_OP(2);
+ t = 2; COPY_DICT(t, m_off)
+#else
+#if defined(LZO1Z)
+ t = 1 + (t << 6) + (*ip++ >> 2);
+ m_pos = op - t;
+ last_m_off = t;
+#else
+ m_pos = op - 1;
+ m_pos -= t >> 2;
+ m_pos -= *ip++ << 2;
+#endif
+ TEST_LB(m_pos); NEED_OP(2);
+ *op++ = *m_pos++; *op++ = *m_pos;
+#endif
+ goto match_done;
+ }
+
+#if defined(COPY_DICT)
+
+ NEED_OP(t+3-1);
+ t += 3-1; COPY_DICT(t, m_off)
+
+#else
+
+ TEST_LB(m_pos); assert(t > 0); NEED_OP(t+3-1);
+#if defined(LZO_UNALIGNED_OK_8) && defined(LZO_UNALIGNED_OK_4)
+ if (op - m_pos >= 8)
+ {
+ t += (3 - 1);
+ if (t >= 8) do
+ {
+ UA_COPY64(op, m_pos);
+ op += 8; m_pos += 8; t -= 8;
+ } while (t >= 8);
+ if (t >= 4)
+ {
+ UA_COPY32(op, m_pos);
+ op += 4; m_pos += 4; t -= 4;
+ }
+ if (t > 0)
+ {
+ *op++ = m_pos[0];
+ if (t > 1) { *op++ = m_pos[1]; if (t > 2) { *op++ = m_pos[2]; } }
+ }
+ }
+ else
+#elif defined(LZO_UNALIGNED_OK_4) || defined(LZO_ALIGNED_OK_4)
+#if !defined(LZO_UNALIGNED_OK_4)
+ if (t >= 2 * 4 - (3 - 1) && PTR_ALIGNED2_4(op, m_pos))
+ {
+ assert((op - m_pos) >= 4);
+#else
+ if (t >= 2 * 4 - (3 - 1) && (op - m_pos) >= 4)
+ {
+#endif
+ UA_COPY32(op, m_pos);
+ op += 4; m_pos += 4; t -= 4 - (3 - 1);
+ do {
+ UA_COPY32(op, m_pos);
+ op += 4; m_pos += 4; t -= 4;
+ } while (t >= 4);
+ if (t > 0) do *op++ = *m_pos++; while (--t > 0);
+ }
+ else
+#endif
+ {
+copy_match:
+ *op++ = *m_pos++; *op++ = *m_pos++;
+ do *op++ = *m_pos++; while (--t > 0);
+ }
+
+#endif
+
+match_done:
+#if defined(LZO1Z)
+ t = ip[-1] & 3;
+#else
+ t = ip[-2] & 3;
+#endif
+ if (t == 0)
+ break;
+
+match_next:
+ assert(t > 0); assert(t < 4); NEED_OP(t); NEED_IP(t+1);
+#if 0
+ do *op++ = *ip++; while (--t > 0);
+#else
+ *op++ = *ip++;
+ if (t > 1) { *op++ = *ip++; if (t > 2) { *op++ = *ip++; } }
+#endif
+ t = *ip++;
+ } while (TEST_IP && TEST_OP);
+ }
+
+#if defined(HAVE_TEST_IP) || defined(HAVE_TEST_OP)
+ *out_len = pd(op, out);
+ return LZO_E_EOF_NOT_FOUND;
+#endif
+
+eof_found:
+ assert(t == 1);
+ *out_len = pd(op, out);
+ return (ip == ip_end ? LZO_E_OK :
+ (ip < ip_end ? LZO_E_INPUT_NOT_CONSUMED : LZO_E_INPUT_OVERRUN));
+
+#if defined(HAVE_NEED_IP)
+input_overrun:
+ *out_len = pd(op, out);
+ return LZO_E_INPUT_OVERRUN;
+#endif
+
+#if defined(HAVE_NEED_OP)
+output_overrun:
+ *out_len = pd(op, out);
+ return LZO_E_OUTPUT_OVERRUN;
+#endif
+
+#if defined(LZO_TEST_OVERRUN_LOOKBEHIND)
+lookbehind_overrun:
+ *out_len = pd(op, out);
+ return LZO_E_LOOKBEHIND_OVERRUN;
+#endif
+}
+
+} // end of namespace MPAL
+
+} // end of namespace Tony
diff --git a/engines/tony/mpal/lzo.h b/engines/tony/mpal/lzo.h
new file mode 100644
index 0000000000..ebb1c4b516
--- /dev/null
+++ b/engines/tony/mpal/lzo.h
@@ -0,0 +1,111 @@
+/* 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.
+ *
+ *
+ */
+/* minilzo.c -- mini subset of the LZO real-time data compression library
+
+ This file is part of the LZO real-time data compression library.
+
+ Copyright (C) 2011 Markus Franz Xaver Johannes Oberhumer
+ Copyright (C) 2010 Markus Franz Xaver Johannes Oberhumer
+ Copyright (C) 2009 Markus Franz Xaver Johannes Oberhumer
+ Copyright (C) 2008 Markus Franz Xaver Johannes Oberhumer
+ Copyright (C) 2007 Markus Franz Xaver Johannes Oberhumer
+ Copyright (C) 2006 Markus Franz Xaver Johannes Oberhumer
+ Copyright (C) 2005 Markus Franz Xaver Johannes Oberhumer
+ Copyright (C) 2004 Markus Franz Xaver Johannes Oberhumer
+ Copyright (C) 2003 Markus Franz Xaver Johannes Oberhumer
+ Copyright (C) 2002 Markus Franz Xaver Johannes Oberhumer
+ Copyright (C) 2001 Markus Franz Xaver Johannes Oberhumer
+ Copyright (C) 2000 Markus Franz Xaver Johannes Oberhumer
+ Copyright (C) 1999 Markus Franz Xaver Johannes Oberhumer
+ Copyright (C) 1998 Markus Franz Xaver Johannes Oberhumer
+ Copyright (C) 1997 Markus Franz Xaver Johannes Oberhumer
+ Copyright (C) 1996 Markus Franz Xaver Johannes Oberhumer
+ All Rights Reserved.
+
+ The LZO library 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.
+
+ The LZO library 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 the LZO library; see the file COPYING.
+ If not, write to the Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+
+ Markus F.X.J. Oberhumer
+ <markus@oberhumer.com>
+ http://www.oberhumer.com/opensource/lzo/
+ */
+
+#ifndef TONY_MPAL_LZO_H
+#define TONY_MPAL_LZO_H
+
+#include "common/scummsys.h"
+
+namespace Tony {
+
+namespace MPAL {
+
+/* Error codes for the compression/decompression functions. Negative
+ * values are errors, positive values will be used for special but
+ * normal events.
+ */
+#define LZO_E_OK 0
+#define LZO_E_ERROR (-1)
+#define LZO_E_OUT_OF_MEMORY (-2) /* [lzo_alloc_func_t failure] */
+#define LZO_E_NOT_COMPRESSIBLE (-3) /* [not used right now] */
+#define LZO_E_INPUT_OVERRUN (-4)
+#define LZO_E_OUTPUT_OVERRUN (-5)
+#define LZO_E_LOOKBEHIND_OVERRUN (-6)
+#define LZO_E_EOF_NOT_FOUND (-7)
+#define LZO_E_INPUT_NOT_CONSUMED (-8)
+#define LZO_E_NOT_YET_IMPLEMENTED (-9) /* [not used right now] */
+#define LZO_E_INVALID_ARGUMENT (-10)
+
+#define LZO1X_999_MEM_COMPRESS ((uint32) (14 * 16384L * sizeof(uint16)))
+
+/**
+ * Decompresses an LZO compressed resource
+ */
+int lzo1x_decompress(const byte *src, uint32 src_len, byte *dst, uint32 *dst_len);
+
+/**
+ * Comrpess a data block into an LZO stream
+ */
+int lzo1x_1_compress(const byte *src, uint32 src_len, byte *dst, uint32 *dst_len, void *wrkmem);
+
+/**
+ * better compression ratio at the cost of more memory and time
+ */
+int lzo1x_999_compress(const byte *src, uint32 src_len, byte *dst, uint32 *dst_len, void *wrkmem);
+
+} // end of namespace MPAL
+
+} // end of namespace Tony
+
+#endif /* already included */
diff --git a/engines/tony/mpal/memory.cpp b/engines/tony/mpal/memory.cpp
new file mode 100644
index 0000000000..428c07b3b7
--- /dev/null
+++ b/engines/tony/mpal/memory.cpp
@@ -0,0 +1,129 @@
+/* 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/algorithm.h"
+#include "common/textconsole.h"
+#include "tony/mpal/memory.h"
+
+namespace Tony {
+
+namespace MPAL {
+
+/****************************************************************************\
+* MemoryManager methods
+\****************************************************************************/
+
+const uint32 BLOCK_ID = 0x12345678;
+
+/**
+ * Allocates a new memory block
+ * @return Returns a MemoryItem instance for the new block
+ */
+MpalHandle MemoryManager::allocate(uint32 size, uint flags) {
+ MemoryItem *newItem = (MemoryItem *)malloc(sizeof(MemoryItem) + size);
+ newItem->_id = BLOCK_ID;
+ newItem->_size = size;
+ newItem->_lockCount = 0;
+
+ // If requested, clear the allocated data block
+ if ((flags & GMEM_ZEROINIT) != 0) {
+ byte *dataP = newItem->_data;
+ Common::fill(dataP, dataP + size, 0);
+ }
+
+ return (MpalHandle)newItem;
+}
+
+/**
+ * Allocates a new memory block and returns its data pointer
+ * @return Data pointer to allocated block
+ */
+void *MemoryManager::alloc(uint32 size, uint flags) {
+ MemoryItem *item = (MemoryItem *)allocate(size, flags);
+ ++item->_lockCount;
+ return &item->_data[0];
+}
+
+#define OFFSETOF(type, field) ((unsigned long) &(((type *) 0)->field))
+
+/**
+ * Returns a reference to the MemoryItem for a gien byte pointer
+ * @param block Byte pointer
+ */
+MemoryItem *MemoryManager::getItem(MpalHandle handle) {
+ MemoryItem *rec = (MemoryItem *)((byte *)handle - OFFSETOF(MemoryItem, _data));
+ assert(rec->_id == BLOCK_ID);
+ return rec;
+}
+
+/**
+ * Returns a size of a memory block given its pointer
+ */
+uint32 MemoryManager::getSize(MpalHandle handle) {
+ MemoryItem *item = (MemoryItem *)handle;
+ assert(item->_id == BLOCK_ID);
+ return item->_size;
+}
+
+/**
+ * Erases a given item
+ */
+void MemoryManager::freeBlock(MpalHandle handle) {
+ MemoryItem *item = (MemoryItem *)handle;
+ assert(item->_id == BLOCK_ID);
+ free(item);
+}
+
+/**
+ * Erases a given item
+ */
+void MemoryManager::destroyItem(MpalHandle handle) {
+ MemoryItem *item = getItem(handle);
+ assert(item->_id == BLOCK_ID);
+ free(item);
+}
+
+/**
+ * Locks an item for access
+ */
+byte *MemoryManager::lockItem(MpalHandle handle) {
+ MemoryItem *item = (MemoryItem *)handle;
+ assert(item->_id == BLOCK_ID);
+ ++item->_lockCount;
+ return &item->_data[0];
+}
+
+/**
+ * Unlocks a locked item
+ */
+void MemoryManager::unlockItem(MpalHandle handle) {
+ MemoryItem *item = (MemoryItem *)handle;
+ assert(item->_id == BLOCK_ID);
+ assert(item->_lockCount > 0);
+ --item->_lockCount;
+}
+
+
+} // end of namespace MPAL
+
+} // end of namespace Tony
diff --git a/engines/tony/mpal/memory.h b/engines/tony/mpal/memory.h
new file mode 100644
index 0000000000..ba7865938f
--- /dev/null
+++ b/engines/tony/mpal/memory.h
@@ -0,0 +1,76 @@
+/* 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 TONY_MPAL_MEMORY
+#define TONY_MPAL_MEMORY
+
+#include "common/scummsys.h"
+#include "common/list.h"
+
+namespace Tony {
+
+namespace MPAL {
+
+typedef void *MpalHandle;
+
+struct MemoryItem {
+ uint32 _id;
+ uint32 _size;
+ int _lockCount;
+ byte _data[1];
+
+ // Casting for access to data
+ operator void *() { return &_data[0]; }
+};
+
+class MemoryManager {
+private:
+ static MemoryItem *getItem(MpalHandle handle);
+public:
+ static MpalHandle allocate(uint32 size, uint flags);
+ static void *alloc(uint32 size, uint flags);
+ static void freeBlock(MpalHandle handle);
+ static void destroyItem(MpalHandle handle);
+ static uint32 getSize(MpalHandle handle);
+ static byte *lockItem(MpalHandle handle);
+ static void unlockItem(MpalHandle handle);
+};
+
+// defines
+#define globalAlloc(flags, size) MemoryManager::alloc(size, flags)
+#define globalAllocate(flags, size) MemoryManager::allocate(size, flags)
+#define globalFree(handle) MemoryManager::freeBlock(handle)
+#define globalDestroy(handle) MemoryManager::destroyItem(handle)
+#define globalLock(handle) MemoryManager::lockItem(handle)
+#define globalUnlock(handle) MemoryManager::unlockItem(handle)
+#define globalSize(handle) MemoryManager::getSize(handle)
+
+#define GMEM_FIXED 1
+#define GMEM_MOVEABLE 2
+#define GMEM_ZEROINIT 4
+
+} // end of namespace MPAL
+
+} // end of namespace Tony
+
+#endif
diff --git a/engines/tony/mpal/mpal.cpp b/engines/tony/mpal/mpal.cpp
new file mode 100644
index 0000000000..533a4d22b9
--- /dev/null
+++ b/engines/tony/mpal/mpal.cpp
@@ -0,0 +1,2102 @@
+/* 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.
+ *
+ *
+ */
+/*
+ * This code is based on original Tony Tough source code
+ *
+ * Copyright (c) 1997-2003 Nayma Software
+ */
+
+#include "common/scummsys.h"
+#include "common/file.h"
+#include "common/savefile.h"
+#include "common/system.h"
+#include "tony/tony.h"
+#include "tony/mpal/lzo.h"
+#include "tony/mpal/mpal.h"
+#include "tony/mpal/mpaldll.h"
+
+namespace Tony {
+
+namespace MPAL {
+
+#define GETARG(type) va_arg(v, type)
+
+/****************************************************************************\
+* Copyright
+\****************************************************************************/
+
+const char *mpalCopyright =
+ "\n\nMPAL - MultiPurpose Adventure Language for Windows 95\n"
+ "Copyright 1997-98 Giovanni Bajo and Luca Giusti\n"
+ "ALL RIGHTS RESERVED\n"
+ "\n"
+ "\n";
+
+/****************************************************************************\
+* Internal functions
+\****************************************************************************/
+
+/**
+ * Locks the variables for access
+ */
+void lockVar() {
+ GLOBALS._lpmvVars = (LpMpalVar)globalLock(GLOBALS._hVars);
+}
+
+/**
+ * Unlocks variables after use
+ */
+void unlockVar() {
+ globalUnlock(GLOBALS._hVars);
+}
+
+/**
+ * Locks the messages for access
+ */
+static void LockMsg() {
+#ifdef NEED_LOCK_MSGS
+ GLOBALS._lpmmMsgs = (LpMpalMsg)globalLock(GLOBALS._hMsgs);
+#endif
+}
+
+/**
+ * Unlocks the messages after use
+ */
+static void UnlockMsg() {
+#ifdef NEED_LOCK_MSGS
+ globalUnlock(GLOBALS._hMsgs);
+#endif
+}
+
+/**
+ * Locks the dialogs for access
+ */
+static void lockDialogs() {
+ GLOBALS._lpmdDialogs = (LpMpalDialog)globalLock(GLOBALS._hDialogs);
+}
+
+/**
+ * Unlocks the dialogs after use
+ */
+static void unlockDialogs() {
+ globalUnlock(GLOBALS._hDialogs);
+}
+
+/**
+ * Locks the location data structures for access
+ */
+static void lockLocations() {
+ GLOBALS._lpmlLocations = (LpMpalLocation)globalLock(GLOBALS._hLocations);
+}
+
+/**
+ * Unlocks the location structures after use
+ */
+static void unlockLocations() {
+ globalUnlock(GLOBALS._hLocations);
+}
+
+/**
+ * Locks the items structures for use
+ */
+static void lockItems() {
+ GLOBALS._lpmiItems = (LpMpalItem)globalLock(GLOBALS._hItems);
+}
+
+/**
+ * Unlocks the items structures after use
+ */
+static void unlockItems() {
+ globalUnlock(GLOBALS._hItems);
+}
+
+/**
+ * Locks the script data structures for use
+ */
+static void LockScripts() {
+ GLOBALS._lpmsScripts = (LpMpalScript)globalLock(GLOBALS._hScripts);
+}
+
+/**
+ * Unlocks the script data structures after use
+ */
+static void unlockScripts() {
+ globalUnlock(GLOBALS._hScripts);
+}
+
+/**
+ * Returns the current value of a global variable
+ *
+ * @param lpszVarName Name of the variable
+ * @returns Current value
+ * @remarks Before using this method, you must call lockVar() to
+ * lock the global variablves for use. Then afterwards, you will
+ * need to remember to call UnlockVar()
+ */
+int32 varGetValue(const char *lpszVarName) {
+ LpMpalVar v = GLOBALS._lpmvVars;
+
+ for (int i = 0; i < GLOBALS._nVars; v++, i++)
+ if (strcmp(lpszVarName, v->_lpszVarName) == 0)
+ return v->_dwVal;
+
+ GLOBALS._mpalError = 1;
+ return 0;
+}
+
+/**
+ * Sets the value of a MPAL global variable
+ * @param lpszVarName Name of the variable
+ * @param val Value to set
+ */
+void varSetValue(const char *lpszVarName, int32 val) {
+ LpMpalVar v = GLOBALS._lpmvVars;
+
+ for (uint i = 0; i < GLOBALS._nVars; v++, i++)
+ if (strcmp(lpszVarName, v->_lpszVarName) == 0) {
+ v->_dwVal = val;
+ if (GLOBALS._lpiifCustom != NULL && strncmp(v->_lpszVarName, "Pattern.", 8) == 0) {
+ i = 0;
+ sscanf(v->_lpszVarName, "Pattern.%u", &i);
+ GLOBALS._lpiifCustom(i, val, -1);
+ } else if (GLOBALS._lpiifCustom != NULL && strncmp(v->_lpszVarName, "Status.", 7) == 0) {
+ i = 0;
+ sscanf(v->_lpszVarName,"Status.%u", &i);
+ GLOBALS._lpiifCustom(i, -1, val);
+ }
+ return;
+ }
+
+ GLOBALS._mpalError = 1;
+ return;
+}
+
+/**
+ * Find the index of a location within the location array. Remember to call LockLoc() beforehand.
+ *
+ * @param nLoc Location number to search for
+ * @returns Index, or -1 if the location is not present
+ * @remarks This function requires the location list to have
+ * first been locked with a call to LockLoc().
+ */
+static int locGetOrderFromNum(uint32 nLoc) {
+ LpMpalLocation loc = GLOBALS._lpmlLocations;
+
+ for (int i = 0; i < GLOBALS._nLocations; i++, loc++)
+ if (loc->_nObj == nLoc)
+ return i;
+
+ return -1;
+}
+
+
+/**
+ * Find the index of a message within the messages array
+ * @param nMsg Message number to search for
+ * @returns Index, or -1 if the message is not present
+ * @remarks This function requires the message list to have
+ * first been locked with a call to LockMsg()
+ */
+static int msgGetOrderFromNum(uint32 nMsg) {
+ LpMpalMsg msg = GLOBALS._lpmmMsgs;
+
+ for (int i = 0; i < GLOBALS._nMsgs; i++, msg++) {
+ if (msg->_wNum == nMsg)
+ return i;
+ }
+
+ return -1;
+}
+
+/**
+ * Find the index of an item within the items array
+ * @param nItem Item number to search for
+ * @returns Index, or -1 if the item is not present
+ * @remarks This function requires the item list to have
+ * first been locked with a call to LockItems()
+ */
+static int itemGetOrderFromNum(uint32 nItem) {
+ LpMpalItem item = GLOBALS._lpmiItems;
+
+ for (int i = 0; i < GLOBALS._nItems; i++, item++) {
+ if (item->_nObj == nItem)
+ return i;
+ }
+
+ return -1;
+}
+
+
+/**
+ * Find the index of a script within the scripts array
+ * @param nScript Script number to search for
+ * @returns Index, or -1 if the script is not present
+ * @remarks This function requires the script list to have
+ * first been locked with a call to LockScripts()
+ */
+static int scriptGetOrderFromNum(uint32 nScript) {
+ LpMpalScript script = GLOBALS._lpmsScripts;
+
+ for (int i = 0; i < GLOBALS._nScripts; i++, script++) {
+ if (script->_nObj == nScript)
+ return i;
+ }
+
+ return -1;
+}
+
+
+/**
+ * Find the index of a dialog within the dialogs array
+ * @param nDialog Dialog number to search for
+ * @returns Index, or -1 if the dialog is not present
+ * @remarks This function requires the dialog list to have
+ * first been locked with a call to LockDialogs()
+ */
+static int dialogGetOrderFromNum(uint32 nDialog) {
+ LpMpalDialog dialog = GLOBALS._lpmdDialogs;
+
+ for (int i = 0; i < GLOBALS._nDialogs; i++, dialog++) {
+ if (dialog->_nObj == nDialog)
+ return i;
+ }
+
+ return -1;
+}
+
+
+/**
+ * Duplicates a message
+ * @param nMsgOrd Index of the message inside the messages array
+ * @returns Pointer to the duplicated message.
+ * @remarks Remember to free the duplicated message when done with it.
+ */
+static char *DuplicateMessage(uint32 nMsgOrd) {
+ const char *origmsg;
+ char *clonemsg;
+
+ if (nMsgOrd == (uint32)-1)
+ return NULL;
+
+ origmsg = (const char *)globalLock(GLOBALS._lpmmMsgs[nMsgOrd]._hText);
+
+ int j = 0;
+ while (origmsg[j] != '\0' || origmsg[j + 1] != '\0')
+ j++;
+ j += 2;
+
+ clonemsg = (char *)globalAlloc(GMEM_FIXED | GMEM_ZEROINIT, j);
+ if (clonemsg == NULL)
+ return NULL;
+
+ memcpy(clonemsg, origmsg, j);
+ globalUnlock(GLOBALS._lpmmMsgs[nMsgOrd]._hText);
+
+ return clonemsg;
+}
+
+
+/**
+ * Duplicate a sentence of a dialog
+ * @param nDlgOrd Index of the dialog in the dialogs array
+ * @param nPeriod Sentence number to be duplicated.
+ * @returns Pointer to the duplicated phrase. Remember to free it
+ * when done with it.
+ */
+static char *duplicateDialogPeriod(uint32 nPeriod) {
+ const char *origmsg;
+ char *clonemsg;
+ LpMpalDialog dialog = GLOBALS._lpmdDialogs + GLOBALS._nExecutingDialog;
+
+ for (int j = 0; dialog->_periods[j] != NULL; j++) {
+ if (dialog->_periodNums[j] == nPeriod) {
+ // Found the phrase, it should be duplicated
+ origmsg = (const char *)globalLock(dialog->_periods[j]);
+
+ // Calculate the length and allocate memory
+ int i = 0;
+ while (origmsg[i] != '\0')
+ i++;
+
+ clonemsg = (char *)globalAlloc(GMEM_FIXED | GMEM_ZEROINIT, i + 1);
+ if (clonemsg == NULL)
+ return NULL;
+
+ memcpy(clonemsg, origmsg, i);
+
+ globalUnlock(dialog->_periods[j]);
+
+ return clonemsg;
+ }
+ }
+
+ return NULL;
+}
+
+
+/**
+ * Load a resource from the MPR file
+ *
+ * @param dwId ID of the resource to load
+ * @returns Handle to the loaded resource
+ */
+MpalHandle resLoad(uint32 dwId) {
+ MpalHandle h;
+ char head[4];
+ uint32 nBytesRead;
+ uint32 nSizeComp, nSizeDecomp;
+ byte *temp, *buf;
+
+ for (int i = 0; i < GLOBALS._nResources; i++)
+ if (GLOBALS._lpResources[i * 2] == dwId) {
+ GLOBALS._hMpr.seek(GLOBALS._lpResources[i * 2 + 1]);
+ nBytesRead = GLOBALS._hMpr.read(head, 4);
+ if (nBytesRead != 4)
+ return NULL;
+ if (head[0] != 'R' || head[1] != 'E' || head[2] != 'S' || head[3] != 'D')
+ return NULL;
+
+ nSizeDecomp = GLOBALS._hMpr.readUint32LE();
+ if (GLOBALS._hMpr.err())
+ return NULL;
+
+ nSizeComp = GLOBALS._hMpr.readUint32LE();
+ if (GLOBALS._hMpr.err())
+ return NULL;
+
+ h = globalAllocate(GMEM_MOVEABLE | GMEM_ZEROINIT, nSizeDecomp + (nSizeDecomp / 1024) * 16);
+ buf = (byte *)globalLock(h);
+ temp = (byte *)globalAlloc(GMEM_FIXED | GMEM_ZEROINIT, nSizeComp);
+
+ nBytesRead = GLOBALS._hMpr.read(temp, nSizeComp);
+ if (nBytesRead != nSizeComp)
+ return NULL;
+
+ lzo1x_decompress(temp, nSizeComp, buf, &nBytesRead);
+ if (nBytesRead != nSizeDecomp)
+ return NULL;
+
+ globalDestroy(temp);
+ globalUnlock(h);
+ return h;
+ }
+
+ return NULL;
+}
+
+static uint32 *getSelectList(uint32 i) {
+ uint32 *sl;
+ LpMpalDialog dialog = GLOBALS._lpmdDialogs + GLOBALS._nExecutingDialog;
+
+ // Count how many are active selects
+ int num = 0;
+ for (int j = 0; dialog->_choice[i]._select[j]._dwData != 0; j++) {
+ if (dialog->_choice[i]._select[j]._curActive)
+ num++;
+ }
+
+ // If there are 0, it's a mistake
+ if (num == 0)
+ return NULL;
+
+ sl = (uint32 *)globalAlloc(GMEM_FIXED | GMEM_ZEROINIT, sizeof(uint32) * (num + 1));
+ if (sl == NULL)
+ return NULL;
+
+ // Copy all the data inside the active select list
+ int k = 0;
+ for (int j = 0; dialog->_choice[i]._select[j]._dwData != 0; j++) {
+ if (dialog->_choice[i]._select[j]._curActive)
+ sl[k++] = dialog->_choice[i]._select[j]._dwData;
+ }
+
+ sl[k] = (uint32)NULL;
+ return sl;
+}
+
+static uint32 *GetItemList(uint32 nLoc) {
+ uint32 *il;
+ LpMpalVar v = GLOBALS._lpmvVars;
+
+ uint32 num = 0;
+ for (uint32 i = 0; i < GLOBALS._nVars; i++, v++) {
+ if (strncmp(v->_lpszVarName, "Location", 8) == 0 && v->_dwVal == nLoc)
+ num++;
+ }
+
+ il = (uint32 *)globalAlloc(GMEM_FIXED | GMEM_ZEROINIT, sizeof(uint32) * (num + 1));
+ if (il == NULL)
+ return NULL;
+
+ v = GLOBALS._lpmvVars;
+ uint32 j = 0;
+ for (uint32 i = 0; i < GLOBALS._nVars; i++, v++) {
+ if (strncmp(v->_lpszVarName, "Location", 8) == 0 && v->_dwVal == nLoc) {
+ sscanf(v->_lpszVarName, "Location.%u", &il[j]);
+ j++;
+ }
+ }
+
+ il[j] = (uint32)NULL;
+ return il;
+}
+
+static LpItem getItemData(uint32 nOrdItem) {
+ LpMpalItem curitem = GLOBALS._lpmiItems + nOrdItem;
+ LpItem ret;
+ MpalHandle hDat;
+ char *dat;
+ char *patlength;
+
+ // Zeroing out the allocated memory is required!!!
+ ret = (LpItem)globalAlloc(GMEM_FIXED | GMEM_ZEROINIT, sizeof(Item));
+ if (ret == NULL)
+ return NULL;
+ ret->_speed = 150;
+
+ hDat = resLoad(curitem->_dwRes);
+ dat = (char *)globalLock(hDat);
+
+ if (dat[0] == 'D' && dat[1] == 'A' && dat[2] == 'T') {
+ int i = dat[3]; // For version 1.0!!
+ dat += 4;
+
+ if (i >= 0x10) { // From 1.0, there's a destination point for each object
+ ret->_destX = (int16)READ_LE_UINT16(dat);
+ ret->_destY = (int16)READ_LE_UINT16(dat + 2);
+ dat += 4;
+ }
+
+ if (i >= 0x11) { // From 1.1, there's animation speed
+ ret->_speed = READ_LE_UINT16(dat);
+ dat += 2;
+ } else
+ ret->_speed = 150;
+ }
+
+ ret->_numframe = *dat++;
+ ret->_numpattern = *dat++;
+ ret->_destZ = *dat++;
+
+ // Upload the left & top co-ordinates of each frame
+ for (int i = 0; i < ret->_numframe; i++) {
+ ret->_frameslocations[i].left = (int16)READ_LE_UINT16(dat);
+ ret->_frameslocations[i].top = (int16)READ_LE_UINT16(dat + 2);
+ dat += 4;
+ }
+
+ // Upload the size of each frame and calculate the right & bottom
+ for (int i = 0; i < ret->_numframe; i++) {
+ ret->_frameslocations[i].right = (int16)READ_LE_UINT16(dat) + ret->_frameslocations[i].left;
+ ret->_frameslocations[i].bottom = (int16)READ_LE_UINT16(dat + 2) + ret->_frameslocations[i].top;
+ dat += 4;
+ }
+
+ // Upload the bounding boxes of each frame
+ for (int i = 0; i < ret->_numframe; i++) {
+ ret->_bbox[i].left = (int16)READ_LE_UINT16(dat);
+ ret->_bbox[i].top = (int16)READ_LE_UINT16(dat + 2);
+ ret->_bbox[i].right = (int16)READ_LE_UINT16(dat + 4);
+ ret->_bbox[i].bottom = (int16)READ_LE_UINT16(dat + 6);
+ dat += 8;
+ }
+
+ // Load the animation pattern
+ patlength = dat;
+ dat += ret->_numpattern;
+
+ for (int i = 1; i < ret->_numpattern; i++) {
+ for (int j = 0; j < patlength[i]; j++)
+ ret->_pattern[i][j] = dat[j];
+ ret->_pattern[i][(int)patlength[i]] = 255; // Terminate pattern
+ dat += patlength[i];
+ }
+
+ // Upload the individual frames of animations
+ for (int i = 1; i < ret->_numframe; i++) {
+ uint32 dim = (uint32)(ret->_frameslocations[i].right - ret->_frameslocations[i].left) *
+ (uint32)(ret->_frameslocations[i].bottom - ret->_frameslocations[i].top);
+ ret->_frames[i] = (char *)globalAlloc(GMEM_FIXED, dim);
+
+ if (ret->_frames[i] == NULL)
+ return NULL;
+ memcpy(ret->_frames[i], dat, dim);
+ dat += dim;
+ }
+
+ // Check if we've got to the end of the file
+ int i = READ_LE_UINT16(dat);
+ if (i != 0xABCD)
+ return NULL;
+
+ globalUnlock(hDat);
+ globalFree(hDat);
+
+ return ret;
+}
+
+
+/**
+ * Thread that calls a custom function. It is used in scripts, so that each script
+ * function is executed without delaying the others.
+ *
+ * @param param pointer to a pointer to the structure that defines the call.
+ * @remarks The passed structure is freed when the process finishes.
+ */
+void CustomThread(CORO_PARAM, const void *param) {
+ CORO_BEGIN_CONTEXT;
+ LpCfCall p;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ _ctx->p = *(LpCfCall *)param;
+
+ CORO_INVOKE_4(GLOBALS._lplpFunctions[_ctx->p->_nCf], _ctx->p->_arg1, _ctx->p->_arg2, _ctx->p->_arg3, _ctx->p->_arg4);
+
+ globalFree(_ctx->p);
+
+ CORO_END_CODE;
+}
+
+
+/**
+ * Main process for running a script.
+ *
+ * @param param Pointer to a pointer to a structure containing the script data.
+ * @remarks The passed structure is freed when the process finishes.
+ */
+void ScriptThread(CORO_PARAM, const void *param) {
+ CORO_BEGIN_CONTEXT;
+ uint i, j, k;
+ uint32 dwStartTime;
+ uint32 dwCurTime;
+ uint32 dwId;
+ int numHandles;
+ LpCfCall p;
+ CORO_END_CONTEXT(_ctx);
+
+ static uint32 cfHandles[MAX_COMMANDS_PER_MOMENT];
+ LpMpalScript s = *(const LpMpalScript *)param;
+
+ CORO_BEGIN_CODE(_ctx);
+
+ _ctx->dwStartTime = g_vm->getTime();
+ _ctx->numHandles = 0;
+
+// debugC(DEBUG_BASIC, kTonyDebugMPAL, "PlayScript(): Moments: %u\n", s->_nMoments);
+ for (_ctx->i = 0; _ctx->i < s->_nMoments; _ctx->i++) {
+ // Sleep for the required time
+ if (s->_moment[_ctx->i]._dwTime == -1) {
+ CORO_INVOKE_4(CoroScheduler.waitForMultipleObjects, _ctx->numHandles, cfHandles, true, CORO_INFINITE);
+ _ctx->dwStartTime = g_vm->getTime();
+ } else {
+ _ctx->dwCurTime = g_vm->getTime();
+ if (_ctx->dwCurTime < _ctx->dwStartTime + (s->_moment[_ctx->i]._dwTime * 100)) {
+ // debugC(DEBUG_BASIC, kTonyDebugMPAL, "PlayScript(): Sleeping %lums\n",_ctx->dwStartTime + (s->_moment[_ctx->i]._dwTime*100) - _ctx->dwCurTime);
+ CORO_INVOKE_1(CoroScheduler.sleep, _ctx->dwStartTime + (s->_moment[_ctx->i]._dwTime * 100) - _ctx->dwCurTime);
+ }
+ }
+
+ _ctx->numHandles = 0;
+ for (_ctx->j = 0; _ctx->j < s->_moment[_ctx->i]._nCmds; _ctx->j++) {
+ _ctx->k = s->_moment[_ctx->i]._cmdNum[_ctx->j];
+
+ if (s->_command[_ctx->k]._type == 1) {
+ _ctx->p = (LpCfCall)globalAlloc(GMEM_FIXED, sizeof(CfCall));
+ if (_ctx->p == NULL) {
+ GLOBALS._mpalError = 1;
+
+ CORO_KILL_SELF();
+ return;
+ }
+
+ _ctx->p->_nCf = s->_command[_ctx->k]._nCf;
+ _ctx->p->_arg1 = s->_command[_ctx->k]._arg1;
+ _ctx->p->_arg2 = s->_command[_ctx->k]._arg2;
+ _ctx->p->_arg3 = s->_command[_ctx->k]._arg3;
+ _ctx->p->_arg4 = s->_command[_ctx->k]._arg4;
+
+ // !!! New process management
+ if ((cfHandles[_ctx->numHandles++] = CoroScheduler.createProcess(CustomThread, &_ctx->p, sizeof(LpCfCall))) == 0) {
+ GLOBALS._mpalError = 1;
+
+ CORO_KILL_SELF();
+ return;
+ }
+ } else if (s->_command[_ctx->k]._type == 2) {
+ lockVar();
+ varSetValue(
+ s->_command[_ctx->k]._lpszVarName,
+ evaluateExpression(s->_command[_ctx->k]._expr)
+ );
+ unlockVar();
+
+ } else {
+ GLOBALS._mpalError = 1;
+ globalFree(s);
+
+ CORO_KILL_SELF();
+ return;
+ }
+ }
+ }
+
+ globalFree(s);
+
+ CORO_KILL_SELF();
+
+ CORO_END_CODE;
+}
+
+
+/**
+ * Thread that performs an action on an item. the thread always executes the action,
+ * so it should create a new item in which the action is the one required.
+ * Furthermore, the expression is not checked, but it is always performed the action.
+ *
+ * @param param Pointer to a pointer to a structure containing the action.
+ */
+void ActionThread(CORO_PARAM, const void *param) {
+ // COROUTINE
+ CORO_BEGIN_CONTEXT;
+ int j, k;
+ LpMpalItem item;
+
+ ~CoroContextTag() {
+ if (item)
+ globalDestroy(item);
+ }
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ // The ActionThread owns the data block pointed to, so we need to make sure it's
+ // freed when the process exits
+ _ctx->item = *(LpMpalItem *)param;
+
+ GLOBALS._mpalError = 0;
+ for (_ctx->j = 0; _ctx->j < _ctx->item->_action[_ctx->item->_dwRes]._nCmds; _ctx->j++) {
+ _ctx->k = _ctx->item->_action[_ctx->item->_dwRes]._cmdNum[_ctx->j];
+
+ if (_ctx->item->_command[_ctx->k]._type == 1) {
+ // Custom function
+ debugC(DEBUG_DETAILED, kTonyDebugActions, "Action Process %d Call=%s params=%d,%d,%d,%d",
+ CoroScheduler.getCurrentPID(), GLOBALS._lplpFunctionStrings[_ctx->item->_command[_ctx->k]._nCf].c_str(),
+ _ctx->item->_command[_ctx->k]._arg1, _ctx->item->_command[_ctx->k]._arg2,
+ _ctx->item->_command[_ctx->k]._arg3, _ctx->item->_command[_ctx->k]._arg4
+ );
+
+ CORO_INVOKE_4(GLOBALS._lplpFunctions[_ctx->item->_command[_ctx->k]._nCf],
+ _ctx->item->_command[_ctx->k]._arg1,
+ _ctx->item->_command[_ctx->k]._arg2,
+ _ctx->item->_command[_ctx->k]._arg3,
+ _ctx->item->_command[_ctx->k]._arg4
+
+ );
+ } else if (_ctx->item->_command[_ctx->k]._type == 2) {
+ // Variable assign
+ debugC(DEBUG_DETAILED, kTonyDebugActions, "Action Process %d Variable=%s",
+ CoroScheduler.getCurrentPID(), _ctx->item->_command[_ctx->k]._lpszVarName);
+
+ lockVar();
+ varSetValue(_ctx->item->_command[_ctx->k]._lpszVarName, evaluateExpression(_ctx->item->_command[_ctx->k]._expr));
+ unlockVar();
+
+ } else {
+ GLOBALS._mpalError = 1;
+ break;
+ }
+ }
+
+ globalDestroy(_ctx->item);
+ _ctx->item = NULL;
+
+ debugC(DEBUG_DETAILED, kTonyDebugActions, "Action Process %d ended", CoroScheduler.getCurrentPID());
+
+ CORO_END_CODE;
+}
+
+/**
+ * This thread monitors a created action to detect when it ends.
+ * @remarks Since actions can spawn sub-actions, this needs to be a
+ * separate thread to determine when the outer action is done
+ */
+void ShutUpActionThread(CORO_PARAM, const void *param) {
+ // COROUTINE
+ CORO_BEGIN_CONTEXT;
+ int slotNumber;
+ CORO_END_CONTEXT(_ctx);
+
+ uint32 pid = *(const uint32 *)param;
+
+ CORO_BEGIN_CODE(_ctx);
+
+ CORO_INVOKE_2(CoroScheduler.waitForSingleObject, pid, CORO_INFINITE);
+
+ GLOBALS._bExecutingAction = false;
+
+ if (g_vm->_initialLoadSlotNumber != -1) {
+ _ctx->slotNumber = g_vm->_initialLoadSlotNumber;
+ g_vm->_initialLoadSlotNumber = -1;
+
+ CORO_INVOKE_1(g_vm->loadState, _ctx->slotNumber);
+ }
+
+
+ CORO_END_CODE;
+}
+
+
+/**
+ * Polls one location (starting point of a process)
+ *
+ * @param param Pointer to an index in the array of polling locations.
+ */
+void LocationPollThread(CORO_PARAM, const void *param) {
+ typedef struct {
+ uint32 _nItem, _nAction;
+
+ uint16 _wTime;
+ byte _perc;
+ MpalHandle _when;
+ byte _nCmds;
+ uint16 _cmdNum[MAX_COMMANDS_PER_ACTION];
+ uint32 _dwLastTime;
+ } MYACTION;
+
+ typedef struct {
+ uint32 _nItem;
+ uint32 _hThread;
+ } MYTHREAD;
+
+ CORO_BEGIN_CONTEXT;
+ uint32 *il;
+ int i, j, k;
+ int numitems;
+ int nRealItems;
+ LpMpalItem curItem, newItem;
+ int nIdleActions;
+ uint32 curTime;
+ uint32 dwSleepTime;
+ uint32 dwId;
+ int ord;
+ bool delayExpired;
+ bool expired;
+
+ MYACTION *myActions;
+ MYTHREAD *myThreads;
+
+ ~CoroContextTag() {
+ // Free data blocks
+ if (myThreads)
+ globalDestroy(myThreads);
+ if (myActions)
+ globalDestroy(myActions);
+ }
+ CORO_END_CONTEXT(_ctx);
+
+ uint32 id = *((const uint32 *)param);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ // Initialize data pointers
+ _ctx->myActions = NULL;
+ _ctx->myThreads = NULL;
+
+ // To begin with, we need to request the item list from the location
+ _ctx->il = mpalQueryItemList(GLOBALS._nPollingLocations[id]);
+
+ // Count the items
+ for (_ctx->numitems = 0; _ctx->il[_ctx->numitems] != 0; _ctx->numitems++)
+ ;
+
+ // We look for items without idle actions, and eliminate them from the list
+ lockItems();
+ _ctx->nIdleActions = 0;
+ _ctx->nRealItems = 0;
+ for (_ctx->i = 0; _ctx->i < _ctx->numitems; _ctx->i++) {
+ _ctx->ord = itemGetOrderFromNum(_ctx->il[_ctx->i]);
+
+ if (_ctx->ord == -1)
+ continue;
+
+ _ctx->curItem = GLOBALS._lpmiItems + _ctx->ord;
+
+ _ctx->k = 0;
+ for (_ctx->j = 0; _ctx->j < _ctx->curItem->_nActions; _ctx->j++) {
+ if (_ctx->curItem->_action[_ctx->j]._num == 0xFF)
+ _ctx->k++;
+ }
+
+ _ctx->nIdleActions += _ctx->k;
+
+ if (_ctx->k == 0)
+ // We can remove this item from the list
+ _ctx->il[_ctx->i] = (uint32)NULL;
+ else
+ _ctx->nRealItems++;
+ }
+ unlockItems();
+
+ // If there is nothing left, we can exit
+ if (_ctx->nRealItems == 0) {
+ globalDestroy(_ctx->il);
+ CORO_KILL_SELF();
+ return;
+ }
+
+ _ctx->myThreads = (MYTHREAD *)globalAlloc(GMEM_FIXED | GMEM_ZEROINIT, _ctx->nRealItems * sizeof(MYTHREAD));
+ if (_ctx->myThreads == NULL) {
+ globalDestroy(_ctx->il);
+ CORO_KILL_SELF();
+ return;
+ }
+
+
+ // We have established that there is at least one item that contains idle actions.
+ // Now we created the mirrored copies of the idle actions.
+ _ctx->myActions = (MYACTION *)globalAlloc(GMEM_FIXED | GMEM_ZEROINIT, _ctx->nIdleActions * sizeof(MYACTION));
+ if (_ctx->myActions == NULL) {
+ globalDestroy(_ctx->myThreads);
+ globalDestroy(_ctx->il);
+ CORO_KILL_SELF();
+ return;
+ }
+
+ lockItems();
+ _ctx->k = 0;
+
+ for (_ctx->i = 0; _ctx->i < _ctx->numitems; _ctx->i++) {
+ if (_ctx->il[_ctx->i] == 0)
+ continue;
+
+ _ctx->curItem = GLOBALS._lpmiItems + itemGetOrderFromNum(_ctx->il[_ctx->i]);
+
+ for (_ctx->j = 0; _ctx->j < _ctx->curItem->_nActions; _ctx->j++) {
+ if (_ctx->curItem->_action[_ctx->j]._num == 0xFF) {
+ _ctx->myActions[_ctx->k]._nItem = _ctx->il[_ctx->i];
+ _ctx->myActions[_ctx->k]._nAction = _ctx->j;
+
+ _ctx->myActions[_ctx->k]._wTime = _ctx->curItem->_action[_ctx->j]._wTime;
+ _ctx->myActions[_ctx->k]._perc = _ctx->curItem->_action[_ctx->j]._perc;
+ _ctx->myActions[_ctx->k]._when = _ctx->curItem->_action[_ctx->j]._when;
+ _ctx->myActions[_ctx->k]._nCmds = _ctx->curItem->_action[_ctx->j]._nCmds;
+ memcpy(_ctx->myActions[_ctx->k]._cmdNum, _ctx->curItem->_action[_ctx->j]._cmdNum,
+ MAX_COMMANDS_PER_ACTION * sizeof(uint16));
+
+ _ctx->myActions[_ctx->k]._dwLastTime = g_vm->getTime();
+ _ctx->k++;
+ }
+ }
+ }
+
+ unlockItems();
+
+ // We don't need the item list anymore
+ globalDestroy(_ctx->il);
+
+
+ // Here's the main loop
+ while (1) {
+ // Searching for idle actions requiring time to execute
+ _ctx->curTime = g_vm->getTime();
+ _ctx->dwSleepTime = (uint32)-1L;
+
+ for (_ctx->k = 0;_ctx->k<_ctx->nIdleActions;_ctx->k++) {
+ if (_ctx->curTime >= _ctx->myActions[_ctx->k]._dwLastTime + _ctx->myActions[_ctx->k]._wTime) {
+ _ctx->dwSleepTime = 0;
+ break;
+ } else
+ _ctx->dwSleepTime = MIN(_ctx->dwSleepTime, _ctx->myActions[_ctx->k]._dwLastTime + _ctx->myActions[_ctx->k]._wTime - _ctx->curTime);
+ }
+
+ // We fall alseep, but always checking that the event is set when prompted for closure
+ CORO_INVOKE_3(CoroScheduler.waitForSingleObject, GLOBALS._hEndPollingLocations[id], _ctx->dwSleepTime, &_ctx->expired);
+
+ //if (_ctx->k == WAIT_OBJECT_0)
+ if (!_ctx->expired)
+ break;
+
+ for (_ctx->i = 0; _ctx->i < _ctx->nRealItems; _ctx->i++) {
+ if (_ctx->myThreads[_ctx->i]._nItem != 0) {
+ CORO_INVOKE_3(CoroScheduler.waitForSingleObject, _ctx->myThreads[_ctx->i]._hThread, 0, &_ctx->delayExpired);
+
+ // if result == WAIT_OBJECT_0)
+ if (!_ctx->delayExpired)
+ _ctx->myThreads[_ctx->i]._nItem = 0;
+ }
+ }
+
+ _ctx->curTime = g_vm->getTime();
+
+ // Loop through all the necessary idle actions
+ for (_ctx->k = 0; _ctx->k < _ctx->nIdleActions; _ctx->k++) {
+ if (_ctx->curTime >= _ctx->myActions[_ctx->k]._dwLastTime + _ctx->myActions[_ctx->k]._wTime) {
+ _ctx->myActions[_ctx->k]._dwLastTime += _ctx->myActions[_ctx->k]._wTime;
+
+ // It's time to check to see if fortune is on the side of the idle action
+ byte randomVal = (byte)g_vm->_randomSource.getRandomNumber(99);
+ if (randomVal < _ctx->myActions[_ctx->k]._perc) {
+ // Check if there is an action running on the item
+ if ((GLOBALS._bExecutingAction) && (GLOBALS._nExecutingAction == _ctx->myActions[_ctx->k]._nItem))
+ continue;
+
+ // Check to see if there already another idle funning running on the item
+ for (_ctx->i = 0; _ctx->i < _ctx->nRealItems; _ctx->i++) {
+ if (_ctx->myThreads[_ctx->i]._nItem == _ctx->myActions[_ctx->k]._nItem)
+ break;
+ }
+
+ if (_ctx->i < _ctx->nRealItems)
+ continue;
+
+ // Ok, we are the only ones :)
+ lockItems();
+ _ctx->curItem = GLOBALS._lpmiItems + itemGetOrderFromNum(_ctx->myActions[_ctx->k]._nItem);
+
+ // Check if there is a WhenExecute expression
+ _ctx->j=_ctx->myActions[_ctx->k]._nAction;
+ if (_ctx->curItem->_action[_ctx->j]._when != NULL) {
+ if (!evaluateExpression(_ctx->curItem->_action[_ctx->j]._when)) {
+ unlockItems();
+ continue;
+ }
+ }
+
+ // Ok, we can perform the action. For convenience, we do it in a new process
+ _ctx->newItem = (LpMpalItem)globalAlloc(GMEM_FIXED | GMEM_ZEROINIT, sizeof(MpalItem));
+ if (_ctx->newItem == false) {
+ globalDestroy(_ctx->myThreads);
+ globalDestroy(_ctx->myActions);
+
+ CORO_KILL_SELF();
+ return;
+ }
+
+ memcpy(_ctx->newItem,_ctx->curItem, sizeof(MpalItem));
+ unlockItems();
+
+ // We copy the action in #0
+ //_ctx->newItem->Action[0].nCmds = _ctx->curItem->Action[_ctx->j].nCmds;
+ //memcpy(_ctx->newItem->Action[0].CmdNum,_ctx->curItem->Action[_ctx->j].CmdNum,_ctx->newItem->Action[0].nCmds*sizeof(_ctx->newItem->Action[0].CmdNum[0]));
+ _ctx->newItem->_dwRes = _ctx->j;
+
+ // We will create an action, and will provide the necessary details
+ for (_ctx->i = 0; _ctx->i < _ctx->nRealItems; _ctx->i++) {
+ if (_ctx->myThreads[_ctx->i]._nItem == 0)
+ break;
+ }
+
+ _ctx->myThreads[_ctx->i]._nItem = _ctx->myActions[_ctx->k]._nItem;
+
+ // Create the process
+ if ((_ctx->myThreads[_ctx->i]._hThread = CoroScheduler.createProcess(ActionThread, &_ctx->newItem, sizeof(LpMpalItem))) == CORO_INVALID_PID_VALUE) {
+ //if ((_ctx->myThreads[_ctx->i]._hThread = (void*)_beginthread(ActionThread, 10240, (void *)_ctx->newItem)) == (void*)-1)
+ globalDestroy(_ctx->newItem);
+ globalDestroy(_ctx->myThreads);
+ globalDestroy(_ctx->myActions);
+
+ CORO_KILL_SELF();
+ return;
+ }
+
+ // Skip all idle actions of the same item
+ }
+ }
+ }
+ }
+
+
+ // Set idle skip on
+ CORO_INVOKE_4(GLOBALS._lplpFunctions[200], 0, 0, 0, 0);
+
+ for (_ctx->i = 0; _ctx->i < _ctx->nRealItems; _ctx->i++) {
+ if (_ctx->myThreads[_ctx->i]._nItem != 0) {
+ CORO_INVOKE_3(CoroScheduler.waitForSingleObject, _ctx->myThreads[_ctx->i]._hThread, 5000, &_ctx->delayExpired);
+
+ //if (result != WAIT_OBJECT_0)
+ //if (_ctx->delayExpired)
+ // TerminateThread(_ctx->MyThreads[_ctx->i].hThread, 0);
+
+ CoroScheduler.killMatchingProcess(_ctx->myThreads[_ctx->i]._hThread);
+ }
+ }
+
+ // Set idle skip off
+ CORO_INVOKE_4(GLOBALS._lplpFunctions[201], 0, 0, 0, 0);
+
+ CORO_END_CODE;
+}
+
+
+/**
+ * Wait for the end of the dialog execution thread, and then restore global
+ * variables indicating that the dialogue has finished.
+ *
+ * @param param Pointer to a handle to the dialog
+ * @remarks This additional process is used, instead of clearing variables
+ * within the same dialog thread, because due to the recursive nature of a dialog,
+ * it would be difficult to know within it when the dialog is actually ending.
+ */
+void ShutUpDialogThread(CORO_PARAM, const void *param) {
+ CORO_BEGIN_CONTEXT;
+ CORO_END_CONTEXT(_ctx);
+
+ uint32 pid = *(const uint32 *)param;
+
+ CORO_BEGIN_CODE(_ctx);
+
+ CORO_INVOKE_2(CoroScheduler.waitForSingleObject, pid, CORO_INFINITE);
+
+ GLOBALS._bExecutingDialog = false;
+ GLOBALS._nExecutingDialog = 0;
+ GLOBALS._nExecutingChoice = 0;
+
+ CoroScheduler.setEvent(GLOBALS._hAskChoice);
+
+ CORO_KILL_SELF();
+
+ CORO_END_CODE;
+}
+
+void doChoice(CORO_PARAM, uint32 nChoice);
+
+
+/**
+ * Executes a group of the current dialog. Can 'be the Starting point of a process.
+ * @parm nGroup Number of the group to perform
+ */
+void GroupThread(CORO_PARAM, const void *param) {
+ CORO_BEGIN_CONTEXT;
+ LpMpalDialog dialog;
+ int i, j, k;
+ int type;
+ CORO_END_CONTEXT(_ctx);
+
+ uint32 nGroup = *(const uint32 *)param;
+
+ CORO_BEGIN_CODE(_ctx);
+
+ // Lock the _ctx->dialog
+ lockDialogs();
+
+ // Find the pointer to the current _ctx->dialog
+ _ctx->dialog = GLOBALS._lpmdDialogs + GLOBALS._nExecutingDialog;
+
+ // Search inside the group requesting the _ctx->dialog
+ for (_ctx->i = 0; _ctx->dialog->_group[_ctx->i]._num != 0; _ctx->i++) {
+ if (_ctx->dialog->_group[_ctx->i]._num == nGroup) {
+ // Cycle through executing the commands of the group
+ for (_ctx->j = 0; _ctx->j < _ctx->dialog->_group[_ctx->i]._nCmds; _ctx->j++) {
+ _ctx->k = _ctx->dialog->_group[_ctx->i]._cmdNum[_ctx->j];
+
+ _ctx->type = _ctx->dialog->_command[_ctx->k]._type;
+ if (_ctx->type == 1) {
+ // Call custom function
+ CORO_INVOKE_4(GLOBALS._lplpFunctions[_ctx->dialog->_command[_ctx->k]._nCf],
+ _ctx->dialog->_command[_ctx->k]._arg1,
+ _ctx->dialog->_command[_ctx->k]._arg2,
+ _ctx->dialog->_command[_ctx->k]._arg3,
+ _ctx->dialog->_command[_ctx->k]._arg4
+ );
+
+ } else if (_ctx->type == 2) {
+ // Set a variable
+ lockVar();
+ varSetValue(_ctx->dialog->_command[_ctx->k]._lpszVarName, evaluateExpression(_ctx->dialog->_command[_ctx->k]._expr));
+ unlockVar();
+
+ } else if (_ctx->type == 3) {
+ // DoChoice: call the chosen function
+ CORO_INVOKE_1(doChoice, (uint32)_ctx->dialog->_command[_ctx->k]._nChoice);
+
+ } else {
+ GLOBALS._mpalError = 1;
+ unlockDialogs();
+
+ CORO_KILL_SELF();
+ return;
+ }
+ }
+
+ // The gruop is finished, so we can return to the calling function.
+ // If the group was the first called, then the process will automatically
+ // end. Otherwise it returns to the caller method
+
+ return;
+ }
+ }
+
+ // If we are here, it means that we have not found the requested group
+ GLOBALS._mpalError = 1;
+ unlockDialogs();
+
+ CORO_KILL_SELF();
+
+ CORO_END_CODE;
+}
+
+
+/**
+ * Make a choice in the current dialog.
+ *
+ * @param nChoice Number of choice to perform
+ */
+void doChoice(CORO_PARAM, uint32 nChoice) {
+ CORO_BEGIN_CONTEXT;
+ LpMpalDialog dialog;
+ int i, j, k;
+ uint32 nGroup;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ // Lock the dialogs
+ lockDialogs();
+
+ // Get a pointer to the current dialog
+ _ctx->dialog = GLOBALS._lpmdDialogs + GLOBALS._nExecutingDialog;
+
+ // Search the choice between those required in the dialog
+ for (_ctx->i = 0; _ctx->dialog->_choice[_ctx->i]._nChoice != 0; _ctx->i++) {
+ if (_ctx->dialog->_choice[_ctx->i]._nChoice == nChoice)
+ break;
+ }
+
+ // If nothing has been found, exit with an error
+ if (_ctx->dialog->_choice[_ctx->i]._nChoice == 0) {
+ // If we're here, we did not find the required choice
+ GLOBALS._mpalError = 1;
+ unlockDialogs();
+
+ CORO_KILL_SELF();
+ return;
+ }
+
+ // We've found the requested choice. Remember what in global variables
+ GLOBALS._nExecutingChoice = _ctx->i;
+
+ while (1) {
+ GLOBALS._nExecutingChoice = _ctx->i;
+
+ _ctx->k = 0;
+ // Calculate the expression of each selection, to see if they're active or inactive
+ for (_ctx->j = 0; _ctx->dialog->_choice[_ctx->i]._select[_ctx->j]._dwData != 0; _ctx->j++) {
+ if (_ctx->dialog->_choice[_ctx->i]._select[_ctx->j]._when == NULL) {
+ _ctx->dialog->_choice[_ctx->i]._select[_ctx->j]._curActive = 1;
+ _ctx->k++;
+ } else if (evaluateExpression(_ctx->dialog->_choice[_ctx->i]._select[_ctx->j]._when)) {
+ _ctx->dialog->_choice[_ctx->i]._select[_ctx->j]._curActive = 1;
+ _ctx->k++;
+ } else
+ _ctx->dialog->_choice[_ctx->i]._select[_ctx->j]._curActive = 0;
+ }
+
+ // If there are no choices activated, then the dialog is finished.
+ if (_ctx->k == 0) {
+ unlockDialogs();
+ break;
+ }
+
+ // There are choices available to the user, so wait for them to make one
+ CoroScheduler.resetEvent(GLOBALS._hDoneChoice);
+ CoroScheduler.setEvent(GLOBALS._hAskChoice);
+ CORO_INVOKE_2(CoroScheduler.waitForSingleObject, GLOBALS._hDoneChoice, CORO_INFINITE);
+
+ // Now that the choice has been made, we can run the groups associated with the choice tbontbtitq
+ _ctx->j = GLOBALS._nSelectedChoice;
+ for (_ctx->k = 0; _ctx->dialog->_choice[_ctx->i]._select[_ctx->j]._wPlayGroup[_ctx->k] != 0; _ctx->k++) {
+ _ctx->nGroup = _ctx->dialog->_choice[_ctx->i]._select[_ctx->j]._wPlayGroup[_ctx->k];
+ CORO_INVOKE_1(GroupThread, &_ctx->nGroup);
+ }
+
+ // Control attribute
+ if (_ctx->dialog->_choice[_ctx->i]._select[_ctx->j]._attr & (1 << 0)) {
+ // Bit 0 set: the end of the choice
+ unlockDialogs();
+ break;
+ }
+
+ if (_ctx->dialog->_choice[_ctx->i]._select[_ctx->j]._attr & (1 << 1)) {
+ // Bit 1 set: the end of the dialog
+ unlockDialogs();
+
+ CORO_KILL_SELF();
+ return;
+ }
+
+ // End of choic ewithout attributes. We must do it again
+ }
+
+ // If we're here, we found an end choice. Return to the caller group
+ return;
+
+ CORO_END_CODE;
+}
+
+
+/**
+ * Perform an action on a certain item.
+ *
+ * @param nAction Action number
+ * @param ordItem Index of the item in the items list
+ * @param dwParam Any parameter for the action.
+ * @returns Id of the process that was launched to perform the action, or
+ * CORO_INVALID_PID_VALUE if the action was not defined, or the item was inactive.
+ * @remarks You can get the index of an item from its number by using
+ * the itemGetOrderFromNum() function. The items list must first be locked
+ * by calling LockItem().
+ */
+static uint32 doAction(uint32 nAction, uint32 ordItem, uint32 dwParam) {
+ LpMpalItem item = GLOBALS._lpmiItems;
+ LpMpalItem newitem;
+
+ item+=ordItem;
+ Common::String buf = Common::String::format("Status.%u", item->_nObj);
+ if (varGetValue(buf.c_str()) <= 0)
+ return CORO_INVALID_PID_VALUE;
+
+ for (int i = 0; i < item->_nActions; i++) {
+ if (item->_action[i]._num != nAction)
+ continue;
+
+ if (item->_action[i]._wParm != dwParam)
+ continue;
+
+ if (item->_action[i]._when != NULL) {
+ if (!evaluateExpression(item->_action[i]._when))
+ continue;
+ }
+
+ // Now we find the right action to be performed
+ // Duplicate the item and copy the current action in #i into #0
+ newitem = (LpMpalItem)globalAlloc(GMEM_FIXED | GMEM_ZEROINIT, sizeof(MpalItem));
+ if (newitem == NULL)
+ return CORO_INVALID_PID_VALUE;
+
+ // In the new version number of the action in writing dwRes
+ Common::copy((byte *)item, (byte *)item + sizeof(MpalItem), (byte *)newitem);
+
+ //newitem->_action[0]._nCmds=item->_action[i]._nCmds;
+ //memcpy(newitem->_action[0]._cmdNum, item->_action[i]._cmdNum, newitem->Action[0].nCmds * sizeof(newitem->_action[0]._cmdNum[0]));
+
+ newitem->_dwRes = i;
+
+ // And finally we can laucnh the process that will execute the action,
+ // and a second process to free up the memory when the action is finished.
+
+ // !!! New process management
+ uint32 h;
+ if ((h = CoroScheduler.createProcess(ActionThread, &newitem, sizeof(LpMpalItem))) == CORO_INVALID_PID_VALUE)
+ return CORO_INVALID_PID_VALUE;
+
+ if (CoroScheduler.createProcess(ShutUpActionThread, &h, sizeof(uint32)) == CORO_INVALID_PID_VALUE)
+ return CORO_INVALID_PID_VALUE;
+
+ GLOBALS._nExecutingAction = item->_nObj;
+ GLOBALS._bExecutingAction = true;
+
+ return h;
+ }
+
+ return CORO_INVALID_PID_VALUE;
+}
+
+/**
+ * Shows a dialog in a separate process.
+ *
+ * @param nDlgOrd The index of the dialog in the dialog list
+ * @param nGroup Number of the group to perform
+ * @returns The process Id of the process running the dialog
+ * or CORO_INVALID_PID_VALUE on error
+ * @remarks The dialogue runs in a thread created on purpose,
+ * so that must inform through an event and when 'necessary to you make a choice.
+ * The data on the choices may be obtained through various queries.
+ */
+static uint32 doDialog(uint32 nDlgOrd, uint32 nGroup) {
+ // Store the running dialog in a global variable
+ GLOBALS._nExecutingDialog = nDlgOrd;
+
+ // Enables the flag to indicate that there is' a running dialogue
+ GLOBALS._bExecutingDialog = true;
+
+ CoroScheduler.resetEvent(GLOBALS._hAskChoice);
+ CoroScheduler.resetEvent(GLOBALS._hDoneChoice);
+
+ // Create a thread that performs the dialogue group
+
+ // Create the process
+ uint32 h;
+ if ((h = CoroScheduler.createProcess(GroupThread, &nGroup, sizeof(uint32))) == CORO_INVALID_PID_VALUE)
+ return CORO_INVALID_PID_VALUE;
+
+ // Create a thread that waits until the end of the dialog process, and will restore the global variables
+ if (CoroScheduler.createProcess(ShutUpDialogThread, &h, sizeof(uint32)) == CORO_INVALID_PID_VALUE) {
+ // Something went wrong, so kill the previously started dialog process
+ CoroScheduler.killMatchingProcess(h);
+ return CORO_INVALID_PID_VALUE;
+ }
+
+ return h;
+}
+
+
+/**
+ * Takes note of the selection chosen by the user, and warns the process that was running
+ * the box that it can continue.
+ *
+ * @param nChoice Number of choice that was in progress
+ * @param dwData Since combined with select selection
+ * @returns True if everything is OK, false on failure
+ */
+bool doSelection(uint32 i, uint32 dwData) {
+ LpMpalDialog dialog = GLOBALS._lpmdDialogs + GLOBALS._nExecutingDialog;
+ int j;
+
+ for (j = 0; dialog->_choice[i]._select[j]._dwData != 0; j++) {
+ if (dialog->_choice[i]._select[j]._dwData == dwData && dialog->_choice[i]._select[j]._curActive != 0)
+ break;
+ }
+
+ if (dialog->_choice[i]._select[j]._dwData == 0)
+ return false;
+
+ GLOBALS._nSelectedChoice = j;
+ CoroScheduler.setEvent(GLOBALS._hDoneChoice);
+ return true;
+}
+
+
+/**
+ * @defgroup Exported functions
+ */
+//@{
+
+/**
+ * Initializes the MPAL library and opens the .MPC file, which will be used for all queries.
+ *
+ * @param lpszMpcFileName Name of the MPC file
+ * @param lpszMprFileName Name of the MPR file
+ * @param lplpcfArray Array of pointers to custom functions.
+ * @returns True if everything is OK, false on failure
+ */
+bool mpalInit(const char *lpszMpcFileName, const char *lpszMprFileName,
+ LPLPCUSTOMFUNCTION lplpcfArray, Common::String *lpcfStrings) {
+ Common::File hMpc;
+ byte buf[5];
+ uint32 nBytesRead;
+ bool bCompress;
+ uint32 dwSizeDecomp, dwSizeComp;
+ byte *cmpbuf;
+
+ // Save the array of custom functions
+ GLOBALS._lplpFunctions = lplpcfArray;
+ GLOBALS._lplpFunctionStrings = lpcfStrings;
+
+ // OPen the MPC file for reading
+ if (!hMpc.open(lpszMpcFileName))
+ return false;
+
+ // Read and check the header
+ nBytesRead = hMpc.read(buf, 5);
+ if (nBytesRead != 5)
+ return false;
+
+ if (buf[0] != 'M' || buf[1] != 'P' || buf[2] != 'C' || buf[3] != 0x20)
+ return false;
+
+ bCompress = buf[4];
+
+ // Reads the size of the uncompressed file, and allocate memory
+ dwSizeDecomp = hMpc.readUint32LE();
+ if (hMpc.err())
+ return false;
+
+ byte *lpMpcImage = (byte *)globalAlloc(GMEM_FIXED, dwSizeDecomp + 16);
+ if (lpMpcImage == NULL)
+ return false;
+
+ if (bCompress) {
+ // Get the compressed size and read the data in
+ dwSizeComp = hMpc.readUint32LE();
+ if (hMpc.err())
+ return false;
+
+ cmpbuf = (byte *)globalAlloc(GMEM_FIXED, dwSizeComp);
+ if (cmpbuf == NULL)
+ return false;
+
+ nBytesRead = hMpc.read(cmpbuf, dwSizeComp);
+ if (nBytesRead != dwSizeComp)
+ return false;
+
+ // Decompress the data
+ lzo1x_decompress(cmpbuf, dwSizeComp, lpMpcImage, &nBytesRead);
+ if (nBytesRead != dwSizeDecomp)
+ return false;
+
+ globalDestroy(cmpbuf);
+ } else {
+ // If the file is not compressed, we directly read in the data
+ nBytesRead = hMpc.read(lpMpcImage, dwSizeDecomp);
+ if (nBytesRead != dwSizeDecomp)
+ return false;
+ }
+
+ // Close the file
+ hMpc.close();
+
+ // Process the data
+ if (parseMpc(lpMpcImage) == false)
+ return false;
+
+ globalDestroy(lpMpcImage);
+
+ // Open the MPR file
+ if (!GLOBALS._hMpr.open(lpszMprFileName))
+ return false;
+
+ // Seek to the end of the file to read overall information
+ GLOBALS._hMpr.seek(-12, SEEK_END);
+
+ dwSizeComp = GLOBALS._hMpr.readUint32LE();
+ if (GLOBALS._hMpr.err())
+ return false;
+
+ GLOBALS._nResources = GLOBALS._hMpr.readUint32LE();
+ if (GLOBALS._hMpr.err())
+ return false;
+
+ nBytesRead = GLOBALS._hMpr.read(buf, 4);
+ if (GLOBALS._hMpr.err())
+ return false;
+
+ if (buf[0] !='E' || buf[1] != 'N' || buf[2] != 'D' || buf[3] != '0')
+ return false;
+
+ // Move to the start of the resources header
+ GLOBALS._hMpr.seek(-(12 + (int)dwSizeComp), SEEK_END);
+
+ GLOBALS._lpResources = (uint32 *)globalAlloc(GMEM_FIXED | GMEM_ZEROINIT, GLOBALS._nResources * 8);
+ if (GLOBALS._lpResources == NULL)
+ return false;
+
+ cmpbuf = (byte *)globalAlloc(GMEM_FIXED | GMEM_ZEROINIT, dwSizeComp);
+ if (cmpbuf == NULL)
+ return false;
+
+ nBytesRead = GLOBALS._hMpr.read(cmpbuf, dwSizeComp);
+ if (nBytesRead != dwSizeComp)
+ return false;
+
+ lzo1x_decompress((const byte *)cmpbuf, dwSizeComp, (byte *)GLOBALS._lpResources, (uint32 *)&nBytesRead);
+ if (nBytesRead != (uint32)GLOBALS._nResources * 8)
+ return false;
+
+ globalDestroy(cmpbuf);
+
+ // Reset back to the start of the file, leaving it open
+ GLOBALS._hMpr.seek(0, SEEK_SET);
+
+ // There is no action or dialog running by default
+ GLOBALS._bExecutingAction = false;
+ GLOBALS._bExecutingDialog = false;
+
+ // There's no polling location
+ Common::fill(GLOBALS._nPollingLocations, GLOBALS._nPollingLocations + MAXPOLLINGLOCATIONS, 0);
+
+ // Create the event that will be used to co-ordinate making choices and choices finishing
+ GLOBALS._hAskChoice = CoroScheduler.createEvent(true, false);
+ GLOBALS._hDoneChoice = CoroScheduler.createEvent(true, false);
+
+ return true;
+}
+
+/**
+ * Frees resources allocated by the MPAL subsystem
+ */
+void mpalFree() {
+ // Free the resource list
+ globalDestroy(GLOBALS._lpResources);
+}
+
+/**
+ * This is a general function to communicate with the library, to request information
+ * about what is in the .MPC file
+ *
+ * @param wQueryType Type of query. The list is in the QueryTypes enum.
+ * @returns 4 bytes depending on the type of query
+ * @remarks This is the specialised version of the original single mpalQuery
+ * method that returns numeric results.
+ */
+uint32 mpalQueryDWORD(uint16 wQueryType, ...) {
+ Common::String buf;
+ uint32 dwRet = 0;
+ char *n;
+
+ va_list v;
+ va_start(v, wQueryType);
+
+ GLOBALS._mpalError = OK;
+
+ if (wQueryType == MPQ_VERSION) {
+
+ /*
+ * uint32 mpalQuery(MPQ_VERSION);
+ */
+ dwRet = HEX_VERSION;
+
+ } else if (wQueryType == MPQ_GLOBAL_VAR) {
+ /*
+ * uint32 mpalQuery(MPQ_GLOBAL_VAR, char * lpszVarName);
+ */
+ lockVar();
+ dwRet = (uint32)varGetValue(GETARG(char *));
+ unlockVar();
+
+ } else if (wQueryType == MPQ_MESSAGE) {
+ /*
+ * char * mpalQuery(MPQ_MESSAGE, uint32 nMsg);
+ */
+ error("mpalQuery(MPQ_MESSAGE, uint32 nMsg) used incorrect method variant");
+
+
+ } else if (wQueryType == MPQ_ITEM_PATTERN) {
+ /*
+ * uint32 mpalQuery(MPQ_ITEM_PATTERN, uint32 nItem);
+ */
+ lockVar();
+ buf = Common::String::format("Pattern.%u", GETARG(uint32));
+ dwRet = (uint32)varGetValue(buf.c_str());
+ unlockVar();
+
+ } else if (wQueryType == MPQ_LOCATION_SIZE) {
+ /*
+ * uint32 mpalQuery(MPQ_LOCATION_SIZE, uint32 nLoc, uint32 dwCoord);
+ */
+ lockLocations();
+ int x = locGetOrderFromNum(GETARG(uint32));
+ int y = GETARG(uint32);
+ if (x != -1) {
+ if (y == MPQ_X)
+ dwRet = GLOBALS._lpmlLocations[x]._dwXlen;
+ else if (y == MPQ_Y)
+ dwRet = GLOBALS._lpmlLocations[x]._dwYlen;
+ else
+ GLOBALS._mpalError = 1;
+ } else
+ GLOBALS._mpalError = 1;
+
+ unlockLocations();
+
+ } else if (wQueryType == MPQ_LOCATION_IMAGE) {
+ /*
+ * HGLOBAL mpalQuery(MPQ_LOCATION_IMAGE, uint32 nLoc);
+ */
+ error("mpalQuery(MPQ_LOCATION_IMAGE, uint32 nLoc) used incorrect variant");
+
+ } else if (wQueryType == MPQ_RESOURCE) {
+ /*
+ * HGLOBAL mpalQuery(MPQ_RESOURCE, uint32 dwRes);
+ */
+ error("mpalQuery(MPQ_RESOURCE, uint32 dwRes) used incorrect variant");
+
+ } else if (wQueryType == MPQ_ITEM_LIST) {
+ /*
+ * uint32 mpalQuery(MPQ_ITEM_LIST, uint32 nLoc);
+ */
+ error("mpalQuery(MPQ_ITEM_LIST, uint32 nLoc) used incorrect variant");
+
+ } else if (wQueryType == MPQ_ITEM_DATA) {
+ /*
+ * LpItem mpalQuery(MPQ_ITEM_DATA, uint32 nItem);
+ */
+ error("mpalQuery(MPQ_ITEM_DATA, uint32 nItem) used incorrect variant");
+
+ } else if (wQueryType == MPQ_ITEM_IS_ACTIVE) {
+ /*
+ * bool mpalQuery(MPQ_ITEM_IS_ACTIVE, uint32 nItem);
+ */
+ lockVar();
+ int x = GETARG(uint32);
+ buf = Common::String::format("Status.%u", x);
+ if (varGetValue(buf.c_str()) <= 0)
+ dwRet = (uint32)false;
+ else
+ dwRet = (uint32)true;
+
+ unlockVar();
+
+ } else if (wQueryType == MPQ_ITEM_NAME) {
+ /*
+ * uint32 mpalQuery(MPQ_ITEM_NAME, uint32 nItem, char * lpszName);
+ */
+ lockVar();
+ int x = GETARG(uint32);
+ n = GETARG(char *);
+ buf = Common::String::format("Status.%u", x);
+ if (varGetValue(buf.c_str()) <= 0)
+ n[0]='\0';
+ else {
+ lockItems();
+ int y = itemGetOrderFromNum(x);
+ memcpy(n, (char *)(GLOBALS._lpmiItems + y)->_lpszDescribe, MAX_DESCRIBE_SIZE);
+ unlockItems();
+ }
+
+ unlockVar();
+
+ } else if (wQueryType == MPQ_DIALOG_PERIOD) {
+ /*
+ * char *mpalQuery(MPQ_DIALOG_PERIOD, uint32 nDialog, uint32 nPeriod);
+ */
+ error("mpalQuery(MPQ_DIALOG_PERIOD, uint32 nDialog, uint32 nPeriod) used incorrect variant");
+
+ } else if (wQueryType == MPQ_DIALOG_WAITFORCHOICE) {
+ /*
+ * void mpalQuery(MPQ_DIALOG_WAITFORCHOICE);
+ */
+ error("mpalQuery(MPQ_DIALOG_WAITFORCHOICE) used incorrect variant");
+
+ } else if (wQueryType == MPQ_DIALOG_SELECTLIST) {
+ /*
+ * uint32 *mpalQuery(MPQ_DIALOG_SELECTLIST, uint32 nChoice);
+ */
+ error("mpalQuery(MPQ_DIALOG_SELECTLIST, uint32 nChoice) used incorrect variant");
+
+ } else if (wQueryType == MPQ_DIALOG_SELECTION) {
+ /*
+ * bool mpalQuery(MPQ_DIALOG_SELECTION, uint32 nChoice, uint32 dwData);
+ */
+ lockDialogs();
+ int x = GETARG(uint32);
+ int y = GETARG(uint32);
+ dwRet = (uint32)doSelection(x, y);
+
+ unlockDialogs();
+
+ } else if (wQueryType == MPQ_DO_ACTION) {
+ /*
+ * int mpalQuery(MPQ_DO_ACTION, uint32 nAction, uint32 nItem, uint32 dwParam);
+ */
+ lockItems();
+ lockVar();
+ int x = GETARG(uint32);
+ int z = GETARG(uint32);
+ int y = itemGetOrderFromNum(z);
+ if (y != -1) {
+ dwRet = doAction(x, y, GETARG(uint32));
+ } else {
+ dwRet = CORO_INVALID_PID_VALUE;
+ GLOBALS._mpalError = 1;
+ }
+
+ unlockVar();
+ unlockItems();
+
+ } else if (wQueryType == MPQ_DO_DIALOG) {
+ /*
+ * int mpalQuery(MPQ_DO_DIALOG, uint32 nDialog, uint32 nGroup);
+ */
+ if (!GLOBALS._bExecutingDialog) {
+ lockDialogs();
+
+ int x = dialogGetOrderFromNum(GETARG(uint32));
+ int y = GETARG(uint32);
+ dwRet = doDialog(x, y);
+ unlockDialogs();
+ }
+ } else {
+ /*
+ * DEFAULT -> ERROR
+ */
+ GLOBALS._mpalError = 1;
+ }
+
+ va_end(v);
+ return dwRet;
+}
+
+/**
+ * This is a general function to communicate with the library, to request information
+ * about what is in the .MPC file
+ *
+ * @param wQueryType Type of query. The list is in the QueryTypes enum.
+ * @returns 4 bytes depending on the type of query
+ * @remarks This is the specialised version of the original single mpalQuery
+ * method that returns a pointer or handle.
+ */
+MpalHandle mpalQueryHANDLE(uint16 wQueryType, ...) {
+ char *n;
+ Common::String buf;
+ va_list v;
+ va_start(v, wQueryType);
+ void *hRet = NULL;
+
+ GLOBALS._mpalError = OK;
+
+ if (wQueryType == MPQ_VERSION) {
+ /*
+ * uint32 mpalQuery(MPQ_VERSION);
+ */
+ error("mpalQuery(MPQ_VERSION) used incorrect variant");
+
+ } else if (wQueryType == MPQ_GLOBAL_VAR) {
+ /*
+ * uint32 mpalQuery(MPQ_GLOBAL_VAR, char * lpszVarName);
+ */
+ error("mpalQuery(MPQ_GLOBAL_VAR, char * lpszVarName) used incorrect variant");
+
+ } else if (wQueryType == MPQ_MESSAGE) {
+ /*
+ * char * mpalQuery(MPQ_MESSAGE, uint32 nMsg);
+ */
+ LockMsg();
+ hRet = DuplicateMessage(msgGetOrderFromNum(GETARG(uint32)));
+ UnlockMsg();
+
+ } else if (wQueryType == MPQ_ITEM_PATTERN) {
+ /*
+ * uint32 mpalQuery(MPQ_ITEM_PATTERN, uint32 nItem);
+ */
+ error("mpalQuery(MPQ_ITEM_PATTERN, uint32 nItem) used incorrect variant");
+
+ } else if (wQueryType == MPQ_LOCATION_SIZE) {
+ /*
+ * uint32 mpalQuery(MPQ_LOCATION_SIZE, uint32 nLoc, uint32 dwCoord);
+ */
+ error("mpalQuery(MPQ_LOCATION_SIZE, uint32 nLoc, uint32 dwCoord) used incorrect variant");
+
+ } else if (wQueryType == MPQ_LOCATION_IMAGE) {
+ /*
+ * HGLOBAL mpalQuery(MPQ_LOCATION_IMAGE, uint32 nLoc);
+ */
+ lockLocations();
+ int x = locGetOrderFromNum(GETARG(uint32));
+ hRet = resLoad(GLOBALS._lpmlLocations[x]._dwPicRes);
+ unlockLocations();
+
+ } else if (wQueryType == MPQ_RESOURCE) {
+ /*
+ * HGLOBAL mpalQuery(MPQ_RESOURCE, uint32 dwRes);
+ */
+ hRet = resLoad(GETARG(uint32));
+
+ } else if (wQueryType == MPQ_ITEM_LIST) {
+ /*
+ * uint32 mpalQuery(MPQ_ITEM_LIST, uint32 nLoc);
+ */
+ lockVar();
+ hRet = GetItemList(GETARG(uint32));
+ lockVar();
+
+ } else if (wQueryType == MPQ_ITEM_DATA) {
+ /*
+ * LpItem mpalQuery(MPQ_ITEM_DATA, uint32 nItem);
+ */
+ lockItems();
+ hRet = getItemData(itemGetOrderFromNum(GETARG(uint32)));
+ unlockItems();
+
+ } else if (wQueryType == MPQ_ITEM_IS_ACTIVE) {
+ /*
+ * bool mpalQuery(MPQ_ITEM_IS_ACTIVE, uint32 nItem);
+ */
+ error("mpalQuery(MPQ_ITEM_IS_ACTIVE, uint32 nItem) used incorrect variant");
+
+ } else if (wQueryType == MPQ_ITEM_NAME) {
+ /*
+ * uint32 mpalQuery(MPQ_ITEM_NAME, uint32 nItem, char *lpszName);
+ */
+ lockVar();
+ int x = GETARG(uint32);
+ n = GETARG(char *);
+ buf = Common::String::format("Status.%u", x);
+ if (varGetValue(buf.c_str()) <= 0)
+ n[0] = '\0';
+ else {
+ lockItems();
+ int y = itemGetOrderFromNum(x);
+ memcpy(n, (char *)(GLOBALS._lpmiItems + y)->_lpszDescribe, MAX_DESCRIBE_SIZE);
+ unlockItems();
+ }
+
+ unlockVar();
+
+ } else if (wQueryType == MPQ_DIALOG_PERIOD) {
+ /*
+ * char * mpalQuery(MPQ_DIALOG_PERIOD, uint32 nDialog, uint32 nPeriod);
+ */
+ lockDialogs();
+ int y = GETARG(uint32);
+ hRet = duplicateDialogPeriod(y);
+ unlockDialogs();
+
+ } else if (wQueryType == MPQ_DIALOG_WAITFORCHOICE) {
+ /*
+ * void mpalQuery(MPQ_DIALOG_WAITFORCHOICE);
+ */
+ error("mpalQuery(MPQ_DIALOG_WAITFORCHOICE) used incorrect variant");
+
+ } else if (wQueryType == MPQ_DIALOG_SELECTLIST) {
+ /*
+ * uint32 *mpalQuery(MPQ_DIALOG_SELECTLIST, uint32 nChoice);
+ */
+ lockDialogs();
+ hRet = getSelectList(GETARG(uint32));
+ unlockDialogs();
+
+ } else if (wQueryType == MPQ_DIALOG_SELECTION) {
+ /*
+ * bool mpalQuery(MPQ_DIALOG_SELECTION, uint32 nChoice, uint32 dwData);
+ */
+ error("mpalQuery(MPQ_DIALOG_SELECTION, uint32 nChoice, uint32 dwData) used incorrect variant");
+
+ } else if (wQueryType == MPQ_DO_ACTION) {
+ /*
+ * int mpalQuery(MPQ_DO_ACTION, uint32 nAction, uint32 nItem, uint32 dwParam);
+ */
+ error("mpalQuery(MPQ_DO_ACTION, uint32 nAction, uint32 nItem, uint32 dwParam) used incorrect variant");
+
+ } else if (wQueryType == MPQ_DO_DIALOG) {
+ /*
+ * int mpalQuery(MPQ_DO_DIALOG, uint32 nDialog, uint32 nGroup);
+ */
+ error("mpalQuery(MPQ_DO_DIALOG, uint32 nDialog, uint32 nGroup) used incorrect variant");
+ } else {
+ /*
+ * DEFAULT -> ERROR
+ */
+ GLOBALS._mpalError = 1;
+ }
+
+ va_end(v);
+ return hRet;
+}
+
+
+/**
+ * This is a general function to communicate with the library, to request information
+ * about what is in the .MPC file
+ *
+ * @param wQueryType Type of query. The list is in the QueryTypes enum.
+ * @returns 4 bytes depending on the type of query
+ * @remarks This is the specialised version of the original single mpalQuery
+ * method that needs to run within a co-routine context.
+ */
+void mpalQueryCORO(CORO_PARAM, uint16 wQueryType, uint32 *dwRet, ...) {
+ CORO_BEGIN_CONTEXT;
+ uint32 dwRet;
+ CORO_END_CONTEXT(_ctx);
+
+ va_list v;
+ va_start(v, dwRet);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ if (wQueryType == MPQ_DIALOG_WAITFORCHOICE) {
+ /*
+ * void mpalQuery(MPQ_DIALOG_WAITFORCHOICE);
+ */
+ CORO_INVOKE_2(CoroScheduler.waitForSingleObject, GLOBALS._hAskChoice, CORO_INFINITE);
+
+ // WORKAROUND: Introduce a single frame delay so that if there are multiple actions running,
+ // they all have time to be signalled before resetting the event. This fixes a problem where
+ // if you try to use the 'shrimp' on the parrot a second time after trying to first use it
+ // whilst the parrot was talking, the cursor wouldn't be re-enabled afterwards
+ CORO_SLEEP(1);
+
+ CoroScheduler.resetEvent(GLOBALS._hAskChoice);
+
+ if (GLOBALS._bExecutingDialog)
+ *dwRet = (uint32)GLOBALS._nExecutingChoice;
+ else
+ *dwRet = (uint32)((int)-1);
+ } else {
+ error("mpalQueryCORO called with unsupported query type");
+ }
+
+ CORO_END_CODE;
+
+ va_end(v);
+}
+
+/**
+ * Returns the current MPAL error code
+ *
+ * @returns Error code
+ */
+uint32 mpalGetError() {
+ return GLOBALS._mpalError;
+}
+
+/**
+ * Execute a script. The script runs on multitasking by a thread.
+ *
+ * @param nScript Script number to run
+ * @returns TRUE if the script 'was launched, FALSE on failure
+ */
+bool mpalExecuteScript(int nScript) {
+ LpMpalScript s;
+
+ LockScripts();
+ int n = scriptGetOrderFromNum(nScript);
+ s = (LpMpalScript)globalAlloc(GMEM_FIXED | GMEM_ZEROINIT, sizeof(MpalScript));
+ if (s == NULL)
+ return false;
+
+ memcpy(s, GLOBALS._lpmsScripts + n, sizeof(MpalScript));
+ unlockScripts();
+
+ // !!! New process management
+ if (CoroScheduler.createProcess(ScriptThread, &s, sizeof(LpMpalScript)) == CORO_INVALID_PID_VALUE)
+ return false;
+
+ return true;
+}
+
+/**
+ * Install a custom routine That will be called by MPAL every time the pattern
+ * of an item has been changed.
+ *
+ * @param lpiifCustom Custom function to install
+ */
+void mpalInstallItemIrq(LPITEMIRQFUNCTION lpiifCus) {
+ GLOBALS._lpiifCustom = lpiifCus;
+}
+
+/**
+ * Process the idle actions of the items on one location.
+ *
+ * @param nLoc Number of the location whose items must be processed
+ * for idle actions.
+ * @returns TRUE if all OK, and FALSE if it exceeded the maximum limit.
+ * @remarks The maximum number of locations that can be polled
+ * simultaneously is defined defined by MAXPOLLINGFUNCIONS
+ */
+bool mpalStartIdlePoll(int nLoc) {
+ for (uint32 i = 0; i < MAXPOLLINGLOCATIONS; i++) {
+ if (GLOBALS._nPollingLocations[i] == (uint32)nLoc)
+ return false;
+ }
+
+ for (uint32 i = 0; i < MAXPOLLINGLOCATIONS; i++) {
+ if (GLOBALS._nPollingLocations[i] == 0) {
+ GLOBALS._nPollingLocations[i] = nLoc;
+
+ GLOBALS._hEndPollingLocations[i] = CoroScheduler.createEvent(true, false);
+// !!! New process management
+ if ((GLOBALS._pollingThreads[i] = CoroScheduler.createProcess(LocationPollThread, &i, sizeof(uint32))) == CORO_INVALID_PID_VALUE)
+// if ((GLOBALS.hEndPollingLocations[i] = (void*)_beginthread(LocationPollThread, 10240, (void *)i))= = (void*)-1)
+ return false;
+
+ return true;
+ }
+ }
+
+ return false;
+}
+
+
+/**
+ * Stop processing the idle actions of the items on one location.
+ *
+ * @param nLo Number of the location
+ * @returns TRUE if all OK, FALSE if the specified location was not
+ * in the process of polling
+ */
+void mpalEndIdlePoll(CORO_PARAM, int nLoc, bool *result) {
+ CORO_BEGIN_CONTEXT;
+ int i;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ for (_ctx->i = 0; _ctx->i < MAXPOLLINGLOCATIONS; _ctx->i++) {
+ if (GLOBALS._nPollingLocations[_ctx->i] == (uint32)nLoc) {
+ CoroScheduler.setEvent(GLOBALS._hEndPollingLocations[_ctx->i]);
+
+ CORO_INVOKE_2(CoroScheduler.waitForSingleObject, GLOBALS._pollingThreads[_ctx->i], CORO_INFINITE);
+
+ CoroScheduler.closeEvent(GLOBALS._hEndPollingLocations[_ctx->i]);
+ GLOBALS._nPollingLocations[_ctx->i] = 0;
+
+ if (result)
+ *result = true;
+ return;
+ }
+ }
+
+ if (result)
+ *result = false;
+
+ CORO_END_CODE;
+}
+
+/**
+ * Retrieve the length of a save state
+ *
+ * @returns Length in bytes
+ */
+int mpalGetSaveStateSize() {
+ return GLOBALS._nVars * sizeof(MpalVar) + 4;
+}
+
+/**
+ * Store the save state into a buffer. The buffer must be
+ * length at least the size specified with mpalGetSaveStateSize
+ *
+ * @param buf Buffer where to store the state
+ */
+void mpalSaveState(byte *buf) {
+ lockVar();
+ WRITE_LE_UINT32(buf, GLOBALS._nVars);
+ memcpy(buf + 4, (byte *)GLOBALS._lpmvVars, GLOBALS._nVars * sizeof(MpalVar));
+ unlockVar();
+}
+
+
+/**
+ * Load a save state from a buffer.
+ *
+ * @param buf Buffer where to store the state
+ * @returns Length of the state buffer in bytes
+ */
+int mpalLoadState(byte *buf) {
+ // We must destroy and recreate all the variables
+ globalFree(GLOBALS._hVars);
+
+ GLOBALS._nVars = READ_LE_UINT32(buf);
+
+ GLOBALS._hVars = globalAllocate(GMEM_ZEROINIT | GMEM_MOVEABLE, GLOBALS._nVars * sizeof(MpalVar));
+ lockVar();
+ memcpy((byte *)GLOBALS._lpmvVars, buf + 4, GLOBALS._nVars * sizeof(MpalVar));
+ unlockVar();
+
+ return GLOBALS._nVars * sizeof(MpalVar) + 4;
+}
+
+} // end of namespace MPAL
+
+} // end of namespace Tony
diff --git a/engines/tony/mpal/mpal.h b/engines/tony/mpal/mpal.h
new file mode 100644
index 0000000000..c5f505063f
--- /dev/null
+++ b/engines/tony/mpal/mpal.h
@@ -0,0 +1,516 @@
+/* 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.
+ *
+ *
+ */
+/*
+ * This code is based on original Tony Tough source code
+ *
+ * Copyright (c) 1997-2003 Nayma Software
+ */
+
+
+/****************************************************************************\
+* General Introduction
+\****************************************************************************/
+
+/*
+ * MPAL (MultiPurpose Adventure Language) is a high level language
+ * for the definition of adventure. Through the use of MPAL you can describe
+ * storyboard the adventure, and then use it with any user interface.
+ * In fact, unlike many other similar products, MPAL is not programmed through
+ * the whole adventure, but are defined only the locations, objects, as they may
+ * interact with each other, etc.. thus making MPAL useful for any type of adventure.
+ */
+
+/****************************************************************************\
+* Structure
+\****************************************************************************/
+
+/*
+ * MPAL consists of two main files: MPAL.DLL and MPAL.H
+ * The first is the DLL that contains the code to interface with MPAL
+ * adventures, the second is the header that defines the prototypes
+ * functions. MPAL is compiled for Win32, and it can therefore be used with
+ * any compiler that supports Win32 DLL (Watcom C++, Visual C++,
+ * Delphi, etc.), and therefore compatible with both Windows 95 and Windows NT.
+ *
+ * To use the DLL, and 'obviously need to create a library for symbols to export.
+ *
+ */
+
+
+/****************************************************************************\
+* Custom Functions
+\****************************************************************************/
+
+/*
+ * A custom function and a function specified by the program that uses the
+ * library, to perform the particular code. The custom functions are
+ * retrieved from the library as specified in the source MPAL, and in particular
+ * in defining the behavior of an item with some action.
+ *
+ * To use the custom functions, you need to prepare an array of
+ * pointers to functions (such as using the type casting LPCUSTOMFUNCTION,
+ * (defined below), and pass it as second parameter to mpalInit (). Note you
+ * must specify the size of the array, as elements of pointers and which do not
+ * contain the same: the library will call it only those functions specified in
+ * the source MPAL. It can be useful, for debugging reasons, do not bet
+ * the shares of arrays used to debugging function, to avoid unpleasant crash,
+ * if it has been made an error in source and / or some oversight in the code.
+ *
+ */
+
+#ifndef TONY_MPAL_H
+#define TONY_MPAL_H
+
+#include "common/scummsys.h"
+#include "common/coroutines.h"
+#include "common/rect.h"
+#include "common/str.h"
+#include "tony/mpal/memory.h"
+
+namespace Tony {
+
+namespace MPAL {
+
+/****************************************************************************\
+* Macro definitions and structures
+\****************************************************************************/
+
+// OK value for the error codes
+#define OK 0
+
+#define MAXFRAMES 400 // frame animation of an object
+#define MAXPATTERN 40 // pattern of animation of an object
+#define MAXPOLLINGLOCATIONS 64
+
+/**
+ * Macro for use with queries that may refer to X and Y co-ordinates
+ */
+enum QueryCoordinates {
+ MPQ_X,
+ MPQ_Y
+};
+
+/**
+ * Query can be used with mpalQuery methods. In practice corresponds all claims
+ * that can do at the library
+ */
+enum QueryTypes {
+ // General Query
+ MPQ_VERSION = 10,
+
+ MPQ_GLOBAL_VAR = 50,
+ MPQ_RESOURCE,
+ MPQ_MESSAGE,
+
+ // Query on leases
+ MPQ_LOCATION_IMAGE = 100,
+ MPQ_LOCATION_SIZE,
+
+ // Queries about items
+ MPQ_ITEM_LIST = 200,
+ MPQ_ITEM_DATA,
+ MPQ_ITEM_PATTERN,
+ MPQ_ITEM_NAME,
+ MPQ_ITEM_IS_ACTIVE,
+
+ // Query dialog
+ MPQ_DIALOG_PERIOD = 300,
+ MPQ_DIALOG_WAITFORCHOICE,
+ MPQ_DIALOG_SELECTLIST,
+ MPQ_DIALOG_SELECTION,
+
+ // Query execution
+ MPQ_DO_ACTION = 400,
+ MPQ_DO_DIALOG
+};
+
+/**
+ * Framework to manage the animation of an item
+ */
+typedef struct {
+ char *_frames[MAXFRAMES];
+ Common::Rect _frameslocations[MAXFRAMES];
+ Common::Rect _bbox[MAXFRAMES];
+ short _pattern[MAXPATTERN][MAXFRAMES];
+ short _speed;
+ char _numframe;
+ char _numpattern;
+ char _curframe;
+ char _curpattern;
+ short _destX, _destY;
+ signed char _destZ;
+ short _objectID;
+} Item;
+typedef Item *LpItem;
+
+
+/**
+ * Define a custom function, to use the language MPAL to perform various controls as a result of an action
+ */
+typedef void (*LPCUSTOMFUNCTION)(CORO_PARAM, uint32, uint32, uint32, uint32);
+typedef LPCUSTOMFUNCTION *LPLPCUSTOMFUNCTION;
+
+/**
+ *
+ * Define an IRQ of an item that is called when the pattern changes or the status of an item
+ */
+typedef void (*LPITEMIRQFUNCTION)(uint32, int, int);
+typedef LPITEMIRQFUNCTION* LPLPITEMIRQFUNCTION;
+
+/**
+ * @defgroup Macrofunctions query
+ *
+ * The following are defines used for simplifying calling the mpalQuery variants
+ */
+//@{
+
+/**
+ * Gets the current version of MPAL
+ *
+ * @returns Version number (0x1232 = 1.2.3b)
+ */
+#define mpalQueryVersion() \
+ (uint16)mpalQueryDWORD(MPQ_VERSION)
+
+/**
+ * Gets the numerical value of a global variable
+ *
+ * @param lpszVarName Variable name (ASCIIZ)
+ * @returns Global variable value
+ * @remarks This query was implemented for debugging. The program,
+ * if well designed, should not need to access variables from
+ * within the library.
+ */
+#define mpalQueryGlobalVar(lpszVarName) \
+ mpalQueryDWORD(MPQ_GLOBAL_VAR, (const char *)(lpszVarName))
+
+
+/**
+ * Provides access to a resource inside the .MPC file
+ *
+ * @param dwResId Resource Id
+ * @returns Handle to a memory area containing the resource, ready for use.
+ */
+#define mpalQueryResource(dwResId) \
+ mpalQueryHANDLE(MPQ_RESOURCE, (uint32)(dwResId))
+
+
+/**
+ * Returns a message.
+ *
+ * @param nMsg Message number
+ * @returns ASCIIZ message
+ * @remarks The returned pointer must be freed via the memory manager
+* after use. The message will be in ASCIIZ format.
+*/
+#define mpalQueryMessage(nMsg) \
+ (char *)mpalQueryHANDLE(MPQ_MESSAGE, (uint32)(nMsg))
+
+
+/**
+ * Provides a location image
+ * @return Returns a picture handle
+ */
+#define mpalQueryLocationImage(nLoc) \
+ mpalQueryHANDLE(MPQ_LOCATION_IMAGE, (uint32)(nLoc))
+
+
+/**
+ * Request the x or y size of a location in pixels
+ *
+ * @param nLoc Location number
+ * @param dwCoord MPQ_X or MPQ_Y coordinate to retrieve
+ * @returns Size
+ */
+#define mpalQueryLocationSize(nLoc, dwCoord) \
+ mpalQueryDWORD(MPQ_LOCATION_SIZE, (uint32)(nLoc), (uint32)(dwCoord))
+
+
+/**
+ * Provides the list of objects in a location.
+ *
+ * @param nLoc Location number
+ * @returns List of objects (accessible by Item [0], Item [1], etc.)
+ */
+// TODO: Determine if this is endian safe
+#define mpalQueryItemList(nLoc) \
+ (uint32 *)mpalQueryHANDLE(MPQ_ITEM_LIST, (uint32)(nLoc))
+
+
+/**
+ * Provides information on an item
+ *
+ * @param nItem Item number
+ * @returns Structure filled with requested information
+ */
+#define mpalQueryItemData(nItem) \
+ (LpItem)mpalQueryHANDLE(MPQ_ITEM_DATA, (uint32)(nItem))
+
+
+/**
+ * Provides the current pattern of an item
+ *
+ * @param nItem Item number
+ * @returns Number of animation patterns to be executed.
+ * @remarks By default, the pattern of 0 indicates that we should do nothing.
+ */
+#define mpalQueryItemPattern(nItem) \
+ mpalQueryDWORD(MPQ_ITEM_PATTERN, (uint32)(nItem))
+
+
+/**
+ * Returns true if an item is active
+ *
+ * @param nItem Item number
+ * @returns TRUE if the item is active, FALSE otherwise
+ */
+#define mpalQueryItemIsActive(nItem) \
+ (bool)mpalQueryDWORD(MPQ_ITEM_IS_ACTIVE, (uint32)(nItem))
+
+
+/**
+ * Returns the name of an item
+ *
+ * @param nItem Item number
+ * @param lpszName Pointer to a buffer of at least 33 bytes
+ * that will be filled with the name
+ * @remarks If the item is not active (ie. if its status or number
+ * is less than or equal to 0), the string will be empty.
+ */
+#define mpalQueryItemName(nItem, lpszName) \
+ mpalQueryHANDLE(MPQ_ITEM_NAME, (uint32)(nItem), (char *)(lpszName))
+
+
+/**
+ * Returns a sentence of dialog.
+ *
+ * @param nDialog Dialog number
+ * @param nPeriod Number of words
+ * @returns A pointer to the string of words, or NULL on failure.
+ * @remarks The string must be freed after use using the memory manager.
+ * Unlike normal messages, the sentences of dialogue are formed by a single
+ * string terminated with 0.
+ */
+#define mpalQueryDialogPeriod(nPeriod) \
+ (char *)mpalQueryHANDLE(MPQ_DIALOG_PERIOD, (uint32)(nPeriod))
+
+
+/**
+ * Wait until the moment in which the need is signaled to make a choice by the user.
+ * @returns Number of choice to be made, or -1 if the dialogue is finished.
+ */
+#define mpalQueryDialogWaitForChoice(dwRet) \
+ CORO_INVOKE_2(mpalQueryCORO, MPQ_DIALOG_WAITFORCHOICE, dwRet)
+
+/**
+ * Requires a list of various options for some choice within the current dialog.
+ *
+ * @param nChoice Choice number
+ * @returns A pointer to an array containing the data matched to each option.
+ * @remarks The figure 'a uint32 specified in the source to which MPAL
+ * You can assign meaning that the more' suits.
+ * The pointer msut be freed after use using the memory memory.
+ */
+#define mpalQueryDialogSelectList(nChoice) \
+ (uint32 *)mpalQueryHANDLE(MPQ_DIALOG_SELECTLIST, (uint32)(nChoice))
+
+/**
+ * Warns the library that the user has selected, in a certain choice of the current dialog,
+ * corresponding option at a certain given.
+ *
+ * @param nChoice Choice number of the choice that was in progress
+ * @param dwData Option that was selected by the user.
+ * @returns TRUE if all OK, FALSE on failure.
+ * @remarks After execution of this query, MPAL continue
+ * Groups according to the execution of the dialogue. And necessary so the game
+ * remains on hold again for another chosen by mpalQueryDialogWaitForChoice ().
+ */
+#define mpalQueryDialogSelection(nChoice, dwData) \
+ (bool)mpalQueryDWORD(MPQ_DIALOG_SELECTION, (uint32)(nChoice), (uint32)(dwData))
+
+#define mpalQueryDialogSelectionDWORD(nChoice, dwData) \
+ mpalQueryDWORD(MPQ_DIALOG_SELECTION, (uint32)(nChoice), (uint32)(dwData))
+
+/**
+ * Warns the library an action was performed on a Object.
+ * The library will call custom functions, if necessary.
+ *
+ * @param nAction Action number
+ * @param nItem Item number
+ * @param dwParam Action parameter
+ * @returns Handle to the thread that is performing the action, or CORO_INVALID_PID_VALUE
+ * if the action is not defined for the item, or the item is inactive.
+ * @remarks The parameter is used primarily to implement actions
+ * as "U.S." involving two objects together. The action will be executed only
+ * if the item is active, ie if its status is a positive number greater than 0.
+ */
+#define mpalQueryDoAction(nAction, nItem, dwParam) \
+ mpalQueryDWORD(MPQ_DO_ACTION, (uint32)(nAction), (uint32)(nItem), (uint32)(dwParam))
+
+/**
+ * Warns the library a dialogue was required.
+ *
+ * @param nDialog Dialog number
+ * @param nGroup Group number to use
+ * @returns Handle to the thread that is running the box, or
+ * CORO_INVALID_PID_VALUE if the dialogue does not exist.
+ */
+#define mpalQueryDoDialog(nDialog, nGroup) \
+ mpalQueryDWORD(MPQ_DO_DIALOG, (uint32)(nDialog), (uint32)(nGroup))
+
+/**
+ * @defgroup Functions exported to the main game
+ */
+//@{
+
+/**
+ * Initializes the MPAL library, and opens an .MPC file, which will be 'used for all queries
+ * @param lpszMpcFileName Name of the .MPC file, including extension
+ * @param lpszMprFileName Name of the .MPR file, including extension
+ * @param lplpcfArray Array of pointers to custom functions
+ * @returns TRUE if all OK, FALSE on failure
+ */
+bool mpalInit(const char *lpszFileName, const char *lpszMprFileName,
+ LPLPCUSTOMFUNCTION lplpcfArray, Common::String *lpcfStrings);
+
+/**
+ * Frees resources allocated by the MPAL subsystem
+ */
+void mpalFree();
+
+/**
+ * This is a general function to communicate with the library, to request information
+ * about what is in the .MPC file
+ *
+ * @param wQueryType Type of query. The list is in the QueryTypes enum.
+ * @returns 4 bytes depending on the type of query
+ * @remarks This is the specialised version of the original single mpalQuery
+ * method that returns numeric results.
+ */
+uint32 mpalQueryDWORD(uint16 wQueryType, ...);
+
+/**
+ * This is a general function to communicate with the library, to request information
+ * about what is in the .MPC file
+ *
+ * @param wQueryType Type of query. The list is in the QueryTypes enum.
+ * @returns 4 bytes depending on the type of query
+ * @remarks This is the specialised version of the original single mpalQuery
+ * method that returns a pointer or handle.
+ */
+MpalHandle mpalQueryHANDLE(uint16 wQueryType, ...);
+
+/**
+ * This is a general function to communicate with the library, to request information
+ * about what is in the .MPC file
+ *
+ * @param wQueryType Type of query. The list is in the QueryTypes enum.
+ * @returns 4 bytes depending on the type of query
+ * @remarks This is the specialised version of the original single mpalQuery
+ * method that needs to run within a co-routine context.
+ */
+void mpalQueryCORO(CORO_PARAM, uint16 wQueryType, uint32 *dwRet, ...);
+
+/**
+ * Execute a script. The script runs on multitasking by a thread.
+ *
+ * @param nScript Script number to run
+ * @returns TRUE if the script 'was launched, FALSE on failure
+ */
+bool mpalExecuteScript(int nScript);
+
+/**
+ * Returns the current MPAL error code
+ *
+ * @returns Error code
+ */
+uint32 mpalGetError();
+
+/**
+ * Install a custom routine That will be called by MPAL every time the pattern
+ * of an item has been changed.
+ *
+ * @param lpiifCustom Custom function to install
+ */
+void mpalInstallItemIrq(LPITEMIRQFUNCTION lpiifCustom);
+
+/**
+ * Process the idle actions of the items on one location.
+ *
+ * @param nLoc Number of the location whose items must be processed
+ * for idle actions.
+ * @returns TRUE if all OK, and FALSE if it exceeded the maximum limit.
+ * @remarks The maximum number of locations that can be polled
+ * simultaneously is defined defined by MAXPOLLINGFUNCIONS
+ */
+bool mpalStartIdlePoll(int nLoc);
+
+/**
+ * Stop processing the idle actions of the items on one location.
+ *
+ * @param nLo Number of the location
+ * @returns TRUE if all OK, FALSE if the specified location was not
+ * in the process of polling
+ */
+void mpalEndIdlePoll(CORO_PARAM, int nLoc, bool *result);
+
+
+/**
+ * Load a save state from a buffer.
+ *
+ * @param buf Buffer where to store the state
+ * @returns Length of the state buffer in bytes
+ */
+int mpalLoadState(byte *buf);
+
+/**
+ * Store the save state into a buffer. The buffer must be
+ * length at least the size specified with mpalGetSaveStateSize
+ *
+ * @param buf Buffer where to store the state
+ */
+void mpalSaveState(byte *buf);
+
+/**
+ * Retrieve the length of a save state
+ *
+ * @returns Length in bytes
+ */
+int mpalGetSaveStateSize();
+
+/**
+ * Locks the variables for access
+ */
+void lockVar();
+
+/**
+ * Unlocks variables after use
+ */
+void unlockVar();
+
+} // end of namespace MPAL
+
+} // end of namespace Tony
+
+#endif
+
diff --git a/engines/tony/mpal/mpaldll.h b/engines/tony/mpal/mpaldll.h
new file mode 100644
index 0000000000..8897096f51
--- /dev/null
+++ b/engines/tony/mpal/mpaldll.h
@@ -0,0 +1,251 @@
+/* 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.
+ *
+ *
+ */
+/*
+ * This code is based on original Tony Tough source code
+ *
+ * Copyright (c) 1997-2003 Nayma Software
+ */
+
+#ifndef __MPALDLL_H
+#define __MPALDLL_H
+
+#include "common/file.h"
+#include "tony/mpal/memory.h"
+#include "tony/mpal/loadmpc.h"
+#include "tony/mpal/expr.h"
+
+namespace Tony {
+
+namespace MPAL {
+
+/****************************************************************************\
+* Defines
+\****************************************************************************/
+
+#define HEX_VERSION 0x0170
+
+#define MAX_ACTIONS_PER_ITEM 40
+#define MAX_COMMANDS_PER_ITEM 128
+#define MAX_COMMANDS_PER_ACTION 128
+#define MAX_DESCRIBE_SIZE 64
+
+#define MAX_MOMENTS_PER_SCRIPT 256
+#define MAX_COMMANDS_PER_SCRIPT 256
+#define MAX_COMMANDS_PER_MOMENT 32
+
+#define MAX_GROUPS_PER_DIALOG 128
+#define MAX_COMMANDS_PER_DIALOG 480
+#define MAX_COMMANDS_PER_GROUP 64
+#define MAX_CHOICES_PER_DIALOG 64
+#define MAX_SELECTS_PER_CHOICE 64
+#define MAX_PLAYGROUPS_PER_SELECT 9
+#define MAX_PERIODS_PER_DIALOG 400
+
+#define NEED_LOCK_MSGS
+
+/****************************************************************************\
+* Structures
+\****************************************************************************/
+
+#include "common/pack-start.h"
+
+/**
+ * MPAL global variables
+ */
+struct MpalVar {
+ uint32 _dwVal; // Variable value
+ char _lpszVarName[33]; // Variable name
+} PACKED_STRUCT;
+typedef MpalVar *LpMpalVar;
+
+/**
+ * MPAL Messages
+ */
+struct MpalMsg {
+ MpalHandle _hText; // Handle to the message text
+ uint16 _wNum; // Message number
+} PACKED_STRUCT;
+typedef MpalMsg *LpMpalMsg;
+
+/**
+ * MPAL Locations
+ */
+struct MpalLocation {
+ uint32 _nObj; // Location number
+ uint32 _dwXlen, _dwYlen; // Dimensions
+ uint32 _dwPicRes; // Resource that contains the image
+} PACKED_STRUCT;
+typedef MpalLocation *LpMpalLocation;
+
+/**
+ * All the data for a command, ie. tags used by OnAction in the item, the time
+ * in the script, and in the group dialog.
+ */
+struct Command {
+ /*
+ * Types of commands that are recognized
+ *
+ * #1 -> Custom function call (ITEM, SCRIPT, DIALOG)
+ * #2 -> Variable assignment (ITEM, SCRIPT, DIALOG)
+ * #3 -> Making a choice (DIALOG)
+ *
+ */
+ byte _type; // Type of control
+
+ union {
+ int32 _nCf; // Custom function call [#1]
+ char *_lpszVarName; // Variable name [#2]
+ int32 _nChoice; // Number of choice you make [#3]
+ };
+
+ union {
+ int32 _arg1; // Argument for custom function [#1]
+ MpalHandle _expr; // Expression to assign to a variable [#2]
+ };
+
+ int32 _arg2, _arg3, _arg4; // Arguments for custom function [#1]
+} PACKED_STRUCT;
+
+
+/**
+ * MPAL dialog
+ */
+struct MpalDialog {
+ uint32 _nObj; // Dialog number
+
+ struct Command _command[MAX_COMMANDS_PER_DIALOG];
+
+ struct {
+ uint16 _num;
+ byte _nCmds;
+ uint16 _cmdNum[MAX_COMMANDS_PER_GROUP];
+
+ } _group[MAX_GROUPS_PER_DIALOG];
+
+ struct {
+ // The last choice has nChoice == 0
+ uint16 _nChoice;
+
+ // The select number (we're pretty stingy with RAM). The last select has dwData == 0
+ struct {
+ MpalHandle _when;
+ uint32 _dwData;
+ uint16 _wPlayGroup[MAX_PLAYGROUPS_PER_SELECT];
+
+ // Bit 0=endchoice Bit 1=enddialog
+ byte _attr;
+
+ // Modified at run-time: 0 if the select is currently disabled,
+ // and 1 if currently active
+ byte _curActive;
+ } _select[MAX_SELECTS_PER_CHOICE];
+
+ } _choice[MAX_CHOICES_PER_DIALOG];
+
+ uint16 _periodNums[MAX_PERIODS_PER_DIALOG];
+ MpalHandle _periods[MAX_PERIODS_PER_DIALOG];
+
+} PACKED_STRUCT;
+typedef MpalDialog *LpMpalDialog;
+
+/**
+ * MPAL Item
+ */
+struct ItemAction {
+ byte _num; // Action number
+ uint16 _wTime; // If idle, the time which must pass
+ byte _perc; // Percentage of the idle run
+ MpalHandle _when; // Expression to compute. If != 0, then
+ // action can be done
+ uint16 _wParm; // Parameter for action
+
+ byte _nCmds; // Number of commands to be executed
+ uint32 _cmdNum[MAX_COMMANDS_PER_ACTION]; // Commands to execute
+} PACKED_STRUCT;
+
+struct MpalItem {
+ uint32 _nObj; // Item number
+
+ byte _lpszDescribe[MAX_DESCRIBE_SIZE]; // Name
+ byte _nActions; // Number of managed actions
+ uint32 _dwRes; // Resource that contains frames and patterns
+
+ struct Command _command[MAX_COMMANDS_PER_ITEM];
+
+ // Pointer to array of structures containing various managed activities. In practice, of
+ // every action we know what commands to run, including those defined in structures above
+ struct ItemAction *_action;
+
+} PACKED_STRUCT;
+typedef MpalItem *LpMpalItem;
+
+/**
+ * MPAL Script
+ */
+struct MpalScript {
+ uint32 _nObj;
+ uint32 _nMoments;
+
+ struct Command _command[MAX_COMMANDS_PER_SCRIPT];
+
+ struct {
+ int32 _dwTime;
+ byte _nCmds;
+ uint32 _cmdNum[MAX_COMMANDS_PER_MOMENT];
+
+ } _moment[MAX_MOMENTS_PER_SCRIPT];
+
+} PACKED_STRUCT;
+typedef MpalScript *LpMpalScript;
+
+#include "common/pack-end.h"
+
+/****************************************************************************\
+* Function prototypes
+\****************************************************************************/
+
+/**
+ * Returns the current value of a global variable
+ *
+ * @param lpszVarName Name of the variable
+ * @returns Current value
+ * @remarks Before using this method, you must call LockVar() to
+ * lock the global variablves for use. Then afterwards, you will
+ * need to remember to call UnlockVar()
+ */
+extern int32 varGetValue(const char *lpszVarName);
+
+
+/**
+ * Sets the value of a MPAL global variable
+ * @param lpszVarName Name of the variable
+ * @param val Value to set
+ */
+extern void varSetValue(const char *lpszVarName, int32 val);
+
+} // end of namespace MPAL
+
+} // end of namespace Tony
+
+#endif
+
diff --git a/engines/tony/mpal/mpalutils.cpp b/engines/tony/mpal/mpalutils.cpp
new file mode 100644
index 0000000000..92d4af37fc
--- /dev/null
+++ b/engines/tony/mpal/mpalutils.cpp
@@ -0,0 +1,115 @@
+/* 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 "tony/mpal/mpalutils.h"
+#include "tony/tony.h"
+#include "common/memstream.h"
+
+namespace Tony {
+
+namespace MPAL {
+
+/****************************************************************************\
+* RMRes methods
+\****************************************************************************/
+
+/**
+ * Constructor
+ * @param resId MPAL resource to open
+ */
+RMRes::RMRes(uint32 resID) {
+ _h = g_vm->_resUpdate.queryResource(resID);
+ if (_h == NULL)
+ _h = mpalQueryResource(resID);
+ if (_h != NULL)
+ _buf = (byte *)globalLock(_h);
+}
+
+/**
+ * Destructor
+ */
+RMRes::~RMRes() {
+ if (_h != NULL) {
+ globalUnlock(_h);
+ globalFree(_h);
+ }
+}
+
+/**
+ * Returns a pointer to the resource
+ */
+const byte *RMRes::dataPointer() {
+ return _buf;
+}
+
+/**
+ * Returns a pointer to the resource
+ */
+RMRes::operator const byte *() {
+ return dataPointer();
+}
+
+/**
+ * Returns the size of the resource
+ */
+unsigned int RMRes::size() {
+ return globalSize(_h);
+}
+
+Common::SeekableReadStream *RMRes::getReadStream() {
+ return new Common::MemoryReadStream(_buf, size());
+}
+
+bool RMRes::isValid() {
+ return _h != NULL;
+}
+
+/****************************************************************************\
+* RMResRaw methods
+\****************************************************************************/
+
+RMResRaw::RMResRaw(uint32 resID) : RMRes(resID) {
+}
+
+RMResRaw::~RMResRaw() {
+}
+
+const byte *RMResRaw::dataPointer() {
+ return _buf + 8;
+}
+
+RMResRaw::operator const byte *() {
+ return dataPointer();
+}
+
+int RMResRaw::width() {
+ return READ_LE_UINT16(_buf + 4);
+}
+
+int RMResRaw::height() {
+ return READ_LE_UINT16(_buf + 6);
+}
+
+} // end of namespace MPAL
+
+} // end of namespace Tony
diff --git a/engines/tony/mpal/mpalutils.h b/engines/tony/mpal/mpalutils.h
new file mode 100644
index 0000000000..629e157e29
--- /dev/null
+++ b/engines/tony/mpal/mpalutils.h
@@ -0,0 +1,74 @@
+/* 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 TONY_MPAL_MPALUTILS
+#define TONY_MPAL_MPALUTILS
+
+#include "common/scummsys.h"
+#include "tony/mpal/memory.h"
+
+namespace Common {
+ class SeekableReadStream;
+}
+
+namespace Tony {
+
+namespace MPAL {
+
+class RMRes {
+protected:
+ MpalHandle _h;
+ byte *_buf;
+
+public:
+ RMRes(uint32 resID);
+ virtual ~RMRes();
+
+ // Attributes
+ unsigned int size();
+ const byte *dataPointer();
+ bool isValid();
+
+ // Casting for access to data
+ operator const byte*();
+
+ Common::SeekableReadStream *getReadStream();
+};
+
+class RMResRaw : public RMRes {
+public:
+ RMResRaw(uint32 resID);
+ virtual ~RMResRaw();
+
+ const byte *dataPointer();
+ operator const byte*();
+
+ int width();
+ int height();
+};
+
+} // end of namespace MPAL
+
+} // end of namespace Tony
+
+#endif
diff --git a/engines/tony/resid.h b/engines/tony/resid.h
new file mode 100644
index 0000000000..f4d2c9a4fa
--- /dev/null
+++ b/engines/tony/resid.h
@@ -0,0 +1,71 @@
+/* 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.
+ *
+ */
+
+/*
+ * This code is based on original Tony Tough source code
+ *
+ * Copyright (c) 1997-2003 Nayma Software
+ */
+
+// From 10500 onwards there are .OGG for inventory and scrap
+#ifndef TONY_RESID_H
+#define TONY_RESID_H
+
+
+#define RES_I_INTERFACE 10300
+#define RES_I_INTERPAL 10301
+#define RES_I_INTERPPAL 10302
+#define RES_I_INTERP1 10303
+#define RES_I_INTERP2 10304
+#define RES_I_INTERP3 10305
+#define RES_I_INTERP4 10306
+#define RES_I_INTERP5 10307
+
+#define RES_I_DLGTEXT 10350
+#define RES_I_DLGTEXTLINE 10351
+#define RES_I_DLGTEXTPAL 10352
+
+#define RES_I_MINIINTER 10360
+
+#define RES_P_PAL 10410
+#define RES_P_GO 10400
+#define RES_P_TAKE 10401
+#define RES_P_USE 10402
+#define RES_P_EXAM 10403
+#define RES_P_TALK 10404
+
+#define RES_P_PAP1 10420
+#define RES_P_PAP2 10421
+#define RES_P_PAP3 10422
+#define RES_P_PAP4 10423
+#define RES_P_FRMAP 10424
+
+#define RES_F_PAL 10700
+#define RES_F_PARL 10701
+#define RES_F_OBJ 10702
+#define RES_F_MACC 10703
+#define RES_F_CREDITS 10704
+#define RES_F_CPAL 10705
+
+#define RES_W_CIRCLE 10800
+
+#endif
diff --git a/engines/tony/sound.cpp b/engines/tony/sound.cpp
new file mode 100644
index 0000000000..2c2c280eb2
--- /dev/null
+++ b/engines/tony/sound.cpp
@@ -0,0 +1,688 @@
+/* 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.
+ *
+ */
+
+/*
+ * This code is based on original Tony Tough source code
+ *
+ * Copyright (c) 1997-2003 Nayma Software
+ */
+
+#include "audio/audiostream.h"
+#include "audio/decoders/adpcm.h"
+#include "audio/decoders/raw.h"
+#include "audio/decoders/wave.h"
+#include "common/textconsole.h"
+#include "tony/game.h"
+#include "tony/tony.h"
+
+namespace Tony {
+
+/****************************************************************************\
+* FPSOUND Methods
+\****************************************************************************/
+
+/**
+ * Default constructor. Initializes the attributes.
+ *
+ */
+FPSound::FPSound() {
+ _bSoundSupported = false;
+}
+
+/**
+ * Initializes the object, and prepare everything you need to create streams and sound effects.
+ *
+ * @returns True is everything is OK, False otherwise
+ */
+bool FPSound::init() {
+ _bSoundSupported = g_system->getMixer()->isReady();
+ return _bSoundSupported;
+}
+
+/**
+ * Destroy the object and free the memory
+ *
+ */
+
+FPSound::~FPSound() {
+}
+
+/**
+ * Allocates an object of type FPStream, and return its pointer
+ *
+ * @param lplpStream Will contain a pointer to the object you just created.
+ *
+ * @returns True is everything is OK, False otherwise
+ */
+
+bool FPSound::createStream(FPStream **lplpStream) {
+ (*lplpStream) = new FPStream(_bSoundSupported);
+
+ return (*lplpStream != NULL);
+}
+
+/**
+ * Allocates an object of type FpSfx, and return its pointer
+ *
+ * @param lplpSfx Will contain a pointer to the object you just created.
+ *
+ * @returns True is everything is OK, False otherwise
+ */
+
+bool FPSound::createSfx(FPSfx **lplpSfx) {
+ (*lplpSfx) = new FPSfx(_bSoundSupported);
+
+ return (*lplpSfx != NULL);
+}
+
+/**
+ * Set the general volume
+ *
+ * @param dwVolume Volume to set (0-63)
+ */
+
+void FPSound::setMasterVolume(int dwVolume) {
+ if (!_bSoundSupported)
+ return;
+
+ g_system->getMixer()->setVolumeForSoundType(Audio::Mixer::kPlainSoundType, CLIP<int>(dwVolume, 0, 63) * Audio::Mixer::kMaxChannelVolume / 63);
+}
+
+/**
+ * Get the general volume
+ *
+ * @param lpdwVolume Variable that will contain the volume (0-63)
+ */
+
+void FPSound::getMasterVolume(int *lpdwVolume) {
+ if (!_bSoundSupported)
+ return;
+
+ *lpdwVolume = g_system->getMixer()->getVolumeForSoundType(Audio::Mixer::kPlainSoundType) * 63 / Audio::Mixer::kMaxChannelVolume;
+}
+
+/**
+ * Default constructor.
+ *
+ * @remarks Do *NOT* declare an object directly, but rather
+ * create it using FPSound::CreateSfx()
+ *
+ */
+
+FPSfx::FPSfx(bool bSoundOn) {
+ _bSoundSupported = bSoundOn;
+ _bFileLoaded = false;
+ _lastVolume = 63;
+ _hEndOfBuffer = CoroScheduler.createEvent(true, false);
+ _bIsVoice = false;
+ _loopStream = 0;
+ _rewindableStream = 0;
+ _bPaused = false;
+
+ g_vm->_activeSfx.push_back(this);
+}
+
+/**
+ * Default Destructor.
+ *
+ * @remarks It is also stops the sound effect that may be
+ * currently played, and free the memory it uses.
+ *
+ */
+
+FPSfx::~FPSfx() {
+ if (!_bSoundSupported)
+ return;
+
+ g_system->getMixer()->stopHandle(_handle);
+ g_vm->_activeSfx.remove(this);
+
+ if (_loopStream)
+ delete _loopStream; // _rewindableStream is deleted by deleting _loopStream
+ else
+ delete _rewindableStream;
+
+ // Free the buffer end event
+ CoroScheduler.closeEvent(_hEndOfBuffer);
+}
+
+/**
+ * Releases the memory used by the object.
+ *
+ * @remarks Must be called when the object is no longer used and
+ * **ONLY** if the object was created by
+ * FPSound::CreateStream().
+ * Object pointers are no longer valid after this call.
+ */
+
+void FPSfx::release() {
+ delete this;
+}
+
+bool FPSfx::loadWave(Common::SeekableReadStream *stream) {
+ if (!stream)
+ return false;
+
+ _rewindableStream = Audio::makeWAVStream(stream, DisposeAfterUse::YES);
+
+ if (!_rewindableStream)
+ return false;
+
+ _bFileLoaded = true;
+ setVolume(_lastVolume);
+ return true;
+}
+
+bool FPSfx::loadVoiceFromVDB(Common::File &vdbFP) {
+ if (!_bSoundSupported)
+ return true;
+
+ uint32 size = vdbFP.readUint32LE();
+ uint32 rate = vdbFP.readUint32LE();
+ _bIsVoice = true;
+
+ _rewindableStream = Audio::makeADPCMStream(vdbFP.readStream(size), DisposeAfterUse::YES, 0, Audio::kADPCMDVI, rate, 1);
+
+ _bFileLoaded = true;
+ setVolume(62);
+ return true;
+}
+
+/**
+ * Opens a file and loads a sound effect.
+ *
+ * @param lpszFileName Sfx filename
+ * @param dwCodec CODEC used to uncompress the samples
+ *
+ * @returns True is everything is OK, False otherwise
+ */
+
+bool FPSfx::loadFile(const char *lpszFileName, uint32 dwCodec) {
+ if (!_bSoundSupported)
+ return true;
+
+ Common::File file;
+ if (!file.open(lpszFileName)) {
+ warning("FPSfx::LoadFile(): Cannot open sfx file!");
+ return false;
+ }
+
+ if (file.readUint32BE() != MKTAG('A', 'D', 'P', 0x10)) {
+ warning("FPSfx::LoadFile(): Invalid ADP header!");
+ return false;
+ }
+
+ uint32 rate = file.readUint32LE();
+ uint32 channels = file.readUint32LE();
+
+ Common::SeekableReadStream *buffer = file.readStream(file.size() - file.pos());
+
+ if (dwCodec == FPCODEC_ADPCM) {
+ _rewindableStream = Audio::makeADPCMStream(buffer, DisposeAfterUse::YES, 0, Audio::kADPCMDVI, rate, channels);
+ } else {
+ byte flags = Audio::FLAG_16BITS | Audio::FLAG_LITTLE_ENDIAN;
+
+ if (channels == 2)
+ flags |= Audio::FLAG_STEREO;
+
+ _rewindableStream = Audio::makeRawStream(buffer, rate, flags, DisposeAfterUse::YES);
+ }
+
+ _bFileLoaded = true;
+ return true;
+}
+
+/**
+ * Play the Sfx in memory.
+ *
+ * @returns True is everything is OK, False otherwise
+ */
+
+bool FPSfx::play() {
+ stop(); // sanity check
+
+ if (_bFileLoaded) {
+ CoroScheduler.resetEvent(_hEndOfBuffer);
+
+ _rewindableStream->rewind();
+
+ Audio::AudioStream *stream = _rewindableStream;
+
+ if (_bLoop) {
+ if (!_loopStream)
+ _loopStream = Audio::makeLoopingAudioStream(_rewindableStream, 0);
+
+ stream = _loopStream;
+ }
+
+ g_system->getMixer()->playStream(Audio::Mixer::kPlainSoundType, &_handle, stream, -1,
+ Audio::Mixer::kMaxChannelVolume, 0, DisposeAfterUse::NO);
+
+ setVolume(_lastVolume);
+
+ if (_bPaused)
+ g_system->getMixer()->pauseHandle(_handle, true);
+ }
+
+ return true;
+}
+
+/**
+ * Stops a Sfx.
+ *
+ * @returns True is everything is OK, False otherwise
+ */
+
+bool FPSfx::stop() {
+ if (_bFileLoaded) {
+ g_system->getMixer()->stopHandle(_handle);
+ _bPaused = false;
+ }
+
+ return true;
+}
+
+/**
+ * Enables or disables the Sfx loop.
+ *
+ * @param _bLoop True to enable the loop, False to disable
+ *
+ * @remarks The loop must be activated BEFORE the sfx starts
+ * playing. Any changes made during the play will have
+ * no effect until the sfx is stopped then played again.
+ */
+
+void FPSfx::setLoop(bool bLop) {
+ _bLoop = bLop;
+}
+
+/**
+ * Pauses a Sfx.
+ *
+ */
+
+void FPSfx::pause(bool bPause) {
+ if (_bFileLoaded) {
+ if (g_system->getMixer()->isSoundHandleActive(_handle) && (bPause ^ _bPaused))
+ g_system->getMixer()->pauseHandle(_handle, bPause);
+
+ _bPaused = bPause;
+ }
+}
+
+/**
+ * Change the volume of Sfx
+ *
+ * @param dwVolume Volume to be set (0-63)
+ *
+ */
+
+void FPSfx::setVolume(int dwVolume) {
+ if (dwVolume > 63)
+ dwVolume = 63;
+
+ if (dwVolume < 0)
+ dwVolume = 0;
+
+ _lastVolume = dwVolume;
+
+ if (_bIsVoice) {
+ if (!GLOBALS._bCfgDubbing)
+ dwVolume = 0;
+ else {
+ dwVolume -= (10 - GLOBALS._nCfgDubbingVolume) * 2;
+ if (dwVolume < 0)
+ dwVolume = 0;
+ }
+ } else {
+ if (!GLOBALS._bCfgSFX)
+ dwVolume = 0;
+ else {
+ dwVolume -= (10 - GLOBALS._nCfgSFXVolume) * 2;
+ if (dwVolume < 0)
+ dwVolume = 0;
+ }
+ }
+
+ if (g_system->getMixer()->isSoundHandleActive(_handle))
+ g_system->getMixer()->setChannelVolume(_handle, dwVolume * Audio::Mixer::kMaxChannelVolume / 63);
+}
+
+/**
+ * Gets the Sfx volume
+ *
+ * @param lpdwVolume Will contain the current Sfx volume
+ *
+ */
+
+void FPSfx::getVolume(int *lpdwVolume) {
+ if (g_system->getMixer()->isSoundHandleActive(_handle))
+ *lpdwVolume = g_system->getMixer()->getChannelVolume(_handle) * 63 / Audio::Mixer::kMaxChannelVolume;
+ else
+ *lpdwVolume = 0;
+}
+
+/**
+ * Returns true if the underlying sound has ended
+ */
+
+bool FPSfx::endOfBuffer() const {
+ return !g_system->getMixer()->isSoundHandleActive(_handle) && (!_rewindableStream || _rewindableStream->endOfData());
+}
+
+/**
+ * Continually checks to see if active sounds have finished playing
+ * Sets the event signalling the sound has ended
+ */
+void FPSfx::soundCheckProcess(CORO_PARAM, const void *param) {
+ CORO_BEGIN_CONTEXT;
+ Common::List<FPSfx *>::iterator i;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ for (;;) {
+ // Check each active sound
+ for (_ctx->i = g_vm->_activeSfx.begin(); _ctx->i != g_vm->_activeSfx.end(); ++_ctx->i) {
+ FPSfx *sfx = *_ctx->i;
+ if (sfx->endOfBuffer())
+ CoroScheduler.setEvent(sfx->_hEndOfBuffer);
+ }
+
+ // Delay until the next check is done
+ CORO_INVOKE_1(CoroScheduler.sleep, 50);
+ }
+
+ CORO_END_CODE;
+}
+
+/**
+ * Default constructor.
+ *
+ * @remarks Do *NOT* declare an object directly, but rather
+ * create it using FPSound::CreateStream()
+ */
+FPStream::FPStream(bool bSoundOn) {
+ _bSoundSupported = bSoundOn;
+ _bFileLoaded = false;
+ _bPaused = false;
+ _bLoop = false;
+ _bDoFadeOut = false;
+ _bSyncExit = false;
+ _dwBufferSize = _dwSize = 0;
+ _lastVolume = 0;
+ _syncToPlay = NULL;
+ _loopStream = NULL;
+ _rewindableStream = NULL;
+}
+
+/**
+ * Default destructor.
+ *
+ * @remarks It calls CloseFile() if needed.
+ */
+
+FPStream::~FPStream() {
+ if (!_bSoundSupported)
+ return;
+
+ if (g_system->getMixer()->isSoundHandleActive(_handle))
+ stop();
+
+ if (_bFileLoaded)
+ unloadFile();
+
+ _syncToPlay = NULL;
+}
+
+/**
+ * Releases the memory object.
+ *
+ * @remarks Must be called when the object is no longer used
+ * and **ONLY** if the object was created by
+ * FPSound::CreateStream().
+ * Object pointers are no longer valid after this call.
+ */
+void FPStream::release() {
+ delete this;
+}
+
+/**
+ * Opens a file stream
+ *
+ * @param fileName Filename to be opened
+ * @param dwCodec CODEC to be used to uncompress samples
+ *
+ * @returns True is everything is OK, False otherwise
+ */
+bool FPStream::loadFile(const Common::String &fileName, uint32 dwCodType, int nBufSize) {
+ if (!_bSoundSupported)
+ return true;
+
+ if (_bFileLoaded)
+ unloadFile();
+
+ // Save the codec type
+ _dwCodec = dwCodType;
+
+ // Open the file stream for reading
+ if (!_file.open(fileName)) {
+ // Fallback: try with an extra '0' prefix
+ if (!_file.open("0" + fileName))
+ return false;
+ }
+
+ // Save the size of the stream
+ _dwSize = _file.size();
+
+ switch (_dwCodec) {
+ case FPCODEC_RAW:
+ _rewindableStream = Audio::makeRawStream(&_file, 44100, Audio::FLAG_16BITS | Audio::FLAG_LITTLE_ENDIAN | Audio::FLAG_STEREO, DisposeAfterUse::NO);
+ break;
+
+ case FPCODEC_ADPCM:
+ _rewindableStream = Audio::makeADPCMStream(&_file, DisposeAfterUse::NO, 0, Audio::kADPCMDVI, 44100, 2);
+ break;
+
+ default:
+ _file.close();
+ return false;
+ }
+
+ // All done
+ _bFileLoaded = true;
+ _bPaused = false;
+
+ setVolume(63);
+
+ return true;
+}
+
+/**
+ * Closes a file stream (opened or not).
+ *
+ * @returns For safety, the destructor calls unloadFile() if it has not
+ * been mentioned explicitly.
+ *
+ * @remarks It is necessary to call this function to free the
+ * memory used by the stream.
+ */
+bool FPStream::unloadFile() {
+ if (!_bSoundSupported || !_bFileLoaded)
+ return true;
+
+ assert(!g_system->getMixer()->isSoundHandleActive(_handle));
+
+ // Closes the file handle stream
+ delete _loopStream;
+ delete _rewindableStream;
+ _loopStream = NULL;
+ _rewindableStream = NULL;
+ _file.close();
+
+ // Flag that the file is no longer in memory
+ _bFileLoaded = false;
+
+ return true;
+}
+
+/**
+ * Play the stream.
+ *
+ * @returns True is everything is OK, False otherwise
+ */
+
+bool FPStream::play() {
+ if (!_bSoundSupported || !_bFileLoaded)
+ return false;
+
+ stop();
+
+ _rewindableStream->rewind();
+
+ Audio::AudioStream *stream = _rewindableStream;
+
+ if (_bLoop) {
+ if (!_loopStream)
+ _loopStream = new Audio::LoopingAudioStream(_rewindableStream, 0, DisposeAfterUse::NO);
+
+ stream = _loopStream;
+ }
+
+ // FIXME: Should this be kMusicSoundType or KPlainSoundType?
+ g_system->getMixer()->playStream(Audio::Mixer::kMusicSoundType, &_handle, stream, -1, Audio::Mixer::kMaxChannelVolume, 0, DisposeAfterUse::NO);
+ setVolume(_lastVolume);
+ _bPaused = false;
+
+ return true;
+}
+
+/**
+ * Closes the stream.
+ *
+ * @returns True is everything is OK, False otherwise
+ *
+ */
+
+bool FPStream::stop() {
+ if (!_bSoundSupported)
+ return true;
+
+ if (!_bFileLoaded)
+ return false;
+
+ if (!g_system->getMixer()->isSoundHandleActive(_handle))
+ return false;
+
+ g_system->getMixer()->stopHandle(_handle);
+
+ _bPaused = false;
+
+ return true;
+}
+
+void FPStream::waitForSync(FPStream *toplay) {
+ // FIXME: The idea here is that you wait for this stream to reach
+ // a buffer which is a multiple of nBufSize/nSync, and then the
+ // thread stops it and immediately starts the 'toplay' stream.
+
+ stop();
+ toplay->play();
+}
+
+/**
+ * Unables or disables stream loop.
+ *
+ * @param _bLoop True enable loop, False disables it
+ *
+ * @remarks The loop must be activated BEFORE the stream starts
+ * playing. Any changes made during the play will have no
+ * effect until the stream is stopped then played again.
+ */
+void FPStream::setLoop(bool loop) {
+ _bLoop = loop;
+}
+
+/**
+ * Pause sound effect
+ *
+ * @param bPause True enables pause, False disables it
+ */
+void FPStream::pause(bool bPause) {
+ if (!_bFileLoaded)
+ return;
+
+ if (bPause == _bPaused)
+ return;
+
+ if (g_system->getMixer()->isSoundHandleActive(_handle))
+ g_system->getMixer()->pauseHandle(_handle, bPause);
+
+ _bPaused = bPause;
+
+ // Trick to reset the volume after a possible new sound configuration
+ setVolume(_lastVolume);
+}
+
+/**
+ * Change the volume of the stream
+ *
+ * @param dwVolume Volume to be set (0-63)
+ *
+ */
+
+void FPStream::setVolume(int dwVolume) {
+ if (dwVolume > 63)
+ dwVolume = 63;
+
+ if (dwVolume < 0)
+ dwVolume = 0;
+
+ _lastVolume = dwVolume;
+
+ if (!GLOBALS._bCfgMusic)
+ dwVolume = 0;
+ else {
+ dwVolume -= (10 - GLOBALS._nCfgMusicVolume) * 2;
+ if (dwVolume < 0)
+ dwVolume = 0;
+ }
+
+ if (g_system->getMixer()->isSoundHandleActive(_handle))
+ g_system->getMixer()->setChannelVolume(_handle, dwVolume * Audio::Mixer::kMaxChannelVolume / 63);
+}
+
+/**
+ * Gets the volume of the stream
+ *
+ * @param lpdwVolume Variable that will contain the current volume
+ *
+ */
+
+void FPStream::getVolume(int *lpdwVolume) {
+ if (g_system->getMixer()->isSoundHandleActive(_handle))
+ *lpdwVolume = g_system->getMixer()->getChannelVolume(_handle) * 63 / Audio::Mixer::kMaxChannelVolume;
+ else
+ *lpdwVolume = 0;
+}
+
+} // End of namespace Tony
diff --git a/engines/tony/sound.h b/engines/tony/sound.h
new file mode 100644
index 0000000000..c859f781f4
--- /dev/null
+++ b/engines/tony/sound.h
@@ -0,0 +1,377 @@
+/* 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.
+ *
+ */
+
+/*
+ * This code is based on original Tony Tough source code
+ *
+ * Copyright (c) 1997-2003 Nayma Software
+ */
+
+#ifndef TONY_SOUND_H
+#define TONY_SOUND_H
+
+#include "audio/mixer.h"
+#include "common/file.h"
+#include "tony/gfxcore.h"
+#include "tony/loc.h"
+#include "tony/utils.h"
+
+namespace Audio {
+class RewindableAudioStream;
+}
+
+namespace Tony {
+
+class FPStream;
+class FPSfx;
+
+enum SoundCodecs {
+ FPCODEC_RAW,
+ FPCODEC_ADPCM
+};
+
+/**
+ * Sound driver For Tony Tough
+ */
+
+class FPSound {
+private:
+ bool _bSoundSupported;
+
+public:
+ /**
+ * Default constructor. Initializes the attributes.
+ *
+ */
+
+ FPSound();
+
+ /**
+ * Destroy the object and free the memory
+ *
+ */
+
+ ~FPSound();
+
+ /**
+ * Initializes the object, and prepare everything you need to create streams and sound effects.
+ *
+ * @returns True is everything is OK, False otherwise
+ */
+
+ bool init();
+
+ /**
+ * Allocates an object of type FPStream, and return its pointer
+ *
+ * @param lplpStream Will contain a pointer to the object you just created.
+ *
+ * @returns True is everything is OK, False otherwise
+ */
+
+ bool createStream(FPStream **lplpStream);
+
+ /**
+ * Allocates an object of type FpSfx, and return its pointer
+ *
+ * @param lplpSfx Will contain a pointer to the object you just created.
+ *
+ * @returns True is everything is OK, False otherwise
+ */
+
+ bool createSfx(FPSfx **lplpSfx);
+
+ /**
+ * Set the general volume
+ *
+ * @param dwVolume Volume to set (0-63)
+ */
+
+ void setMasterVolume(int dwVolume);
+
+ /**
+ * Get the general volume
+ *
+ * @param lpdwVolume Variable that will contain the volume (0-63)
+ */
+
+ void getMasterVolume(int *lpdwVolume);
+};
+
+class FPSfx {
+private:
+ bool _bSoundSupported; // True if the sound is active
+ bool _bFileLoaded; // True is a file is opened
+ bool _bLoop; // True is sound effect should loop
+ int _lastVolume;
+
+ bool _bIsVoice;
+ bool _bPaused;
+
+ Audio::AudioStream *_loopStream;
+ Audio::RewindableAudioStream *_rewindableStream;
+ Audio::SoundHandle _handle;
+
+public:
+ uint32 _hEndOfBuffer;
+
+ /**
+ * Check process for whether sounds have finished playing
+ */
+ static void soundCheckProcess(CORO_PARAM, const void *param);
+
+ /**
+ * Default constructor.
+ *
+ * @remarks Do *NOT* declare an object directly, but rather
+ * create it using FPSound::CreateSfx()
+ *
+ */
+
+ FPSfx(bool bSoundOn);
+
+ /**
+ * Default Destructor.
+ *
+ * @remarks It is also stops the sound effect that may be
+ * currently played, and free the memory it uses.
+ *
+ */
+
+ ~FPSfx();
+
+ /**
+ * Releases the memory used by the object.
+ *
+ * @remarks Must be called when the object is no longer used and
+ * **ONLY** if the object was created by
+ * FPSound::CreateStream().
+ * Object pointers are no longer valid after this call.
+ */
+
+ void release();
+
+ /**
+ * Opens a file and loads a sound effect.
+ *
+ * @param lpszFileName Sfx filename
+ * @param dwCodec CODEC used to uncompress the samples
+ *
+ * @returns True is everything is OK, False otherwise
+ */
+
+ bool loadFile(const char *lpszFileName, uint32 dwCodec = FPCODEC_RAW);
+ bool loadWave(Common::SeekableReadStream *stream);
+ bool loadVoiceFromVDB(Common::File &vdbFP);
+
+ /**
+ * Play the Sfx in memory.
+ *
+ * @returns True is everything is OK, False otherwise
+ */
+
+ bool play();
+
+ /**
+ * Stops a Sfx.
+ *
+ * @returns True is everything is OK, False otherwise
+ */
+
+ bool stop();
+
+ /**
+ * Pauses a Sfx.
+ *
+ */
+
+ void pause(bool bPause);
+
+ /**
+ * Enables or disables the Sfx loop.
+ *
+ * @param bLoop True to enable the loop, False to disable
+ *
+ * @remarks The loop must be activated BEFORE the sfx starts
+ * playing. Any changes made during the play will have
+ * no effect until the sfx is stopped then played again.
+ */
+
+ void setLoop(bool bLoop);
+
+ /**
+ * Change the volume of Sfx
+ *
+ * @param dwVolume Volume to be set (0-63)
+ *
+ */
+
+ void setVolume(int dwVolume);
+
+ /**
+ * Gets the Sfx volume
+ *
+ * @param lpdwVolume Will contain the current Sfx volume
+ *
+ */
+
+ void getVolume(int *lpdwVolume);
+
+ /**
+ * Returns true if the underlying sound has ended
+ */
+ bool endOfBuffer() const;
+};
+
+class FPStream {
+private:
+ uint32 _dwBufferSize; // Buffer size (bytes)
+ uint32 _dwSize; // Stream size (bytes)
+ uint32 _dwCodec; // CODEC used
+
+ Common::File _file; // File handle used for the stream
+
+ bool _bSoundSupported; // True if the sound is active
+ bool _bFileLoaded; // True if the file is open
+ bool _bLoop; // True if the stream should loop
+ bool _bDoFadeOut; // True if fade out is required
+ bool _bSyncExit;
+ bool _bPaused;
+ int _lastVolume;
+ FPStream *_syncToPlay;
+
+ Audio::AudioStream *_loopStream;
+ Audio::RewindableAudioStream *_rewindableStream;
+ Audio::SoundHandle _handle;
+
+public:
+
+ /**
+ * Default constructor.
+ *
+ * @remarks Do *NOT* declare an object directly, but rather
+ * create it using FPSound::CreateStream()
+ */
+
+ FPStream(bool bSoundOn);
+
+ /**
+ * Default destructor.
+ *
+ * @remarks It calls CloseFile() if needed.
+ */
+
+ ~FPStream();
+
+ /**
+ * Releases the memory object.
+ *
+ * @remarks Must be called when the object is no longer used
+ * and **ONLY** if the object was created by
+ * FPSound::CreateStream().
+ * Object pointers are no longer valid after this call.
+ */
+
+ void release();
+
+ /**
+ * Opens a file stream
+ *
+ * @param fileName Filename to be opened
+ * @param dwCodec CODEC to be used to uncompress samples
+ *
+ * @returns True is everything is OK, False otherwise
+ */
+
+ bool loadFile(const Common::String &fileName, uint32 dwCodec = FPCODEC_RAW, int nSync = 2000);
+
+ /**
+ * Closes a file stream (opened or not).
+ *
+ * @returns For safety, the destructor calls unloadFile() if it has not
+ * been mentioned explicitly.
+ *
+ * @remarks It is necessary to call this function to free the
+ * memory used by the stream.
+ */
+
+ bool unloadFile();
+
+ /**
+ * Play the stream.
+ *
+ * @returns True is everything is OK, False otherwise
+ */
+
+ bool play();
+ void playFast();
+
+ /**
+ * Closes the stream.
+ *
+ * @returns True is everything is OK, False otherwise
+ */
+
+ bool stop();
+ void waitForSync(FPStream *toplay);
+
+ /**
+ * Pause sound effect
+ *
+ * @param bPause True enables pause, False disables it
+ */
+
+ void pause(bool bPause);
+
+ /**
+ * Unables or disables stream loop.
+ *
+ * @param bLoop True enable loop, False disables it
+ *
+ * @remarks The loop must be activated BEFORE the stream starts
+ * playing. Any changes made during the play will have no
+ * effect until the stream is stopped then played again.
+ */
+
+ void setLoop(bool bLoop);
+
+ /**
+ * Change the volume of the stream
+ *
+ * @param dwVolume Volume to be set (0-63)
+ */
+
+ void setVolume(int dwVolume);
+
+ /**
+ * Gets the volume of the stream
+ *
+ * @param lpdwVolume Variable that will contain the current volume
+ *
+ */
+
+ void getVolume(int *lpdwVolume);
+};
+
+} // End of namespace Tony
+
+#endif
diff --git a/engines/tony/tony.cpp b/engines/tony/tony.cpp
new file mode 100644
index 0000000000..4ffb84ced8
--- /dev/null
+++ b/engines/tony/tony.cpp
@@ -0,0 +1,795 @@
+/* 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/scummsys.h"
+#include "common/algorithm.h"
+#include "common/config-manager.h"
+#include "common/debug-channels.h"
+#include "common/events.h"
+#include "common/file.h"
+#include "common/installshield_cab.h"
+#include "tony/tony.h"
+#include "tony/custom.h"
+#include "tony/debugger.h"
+#include "tony/game.h"
+#include "tony/mpal/mpal.h"
+
+namespace Tony {
+
+TonyEngine *g_vm;
+
+TonyEngine::TonyEngine(OSystem *syst, const TonyGameDescription *gameDesc) : Engine(syst),
+ _gameDescription(gameDesc), _randomSource("tony") {
+ g_vm = this;
+ _loadSlotNumber = -1;
+
+ // Set the up the debugger
+ _debugger = new Debugger();
+ DebugMan.addDebugChannel(kTonyDebugAnimations, "animations", "Animations debugging");
+ DebugMan.addDebugChannel(kTonyDebugActions, "actions", "Actions debugging");
+ DebugMan.addDebugChannel(kTonyDebugSound, "sound", "Sound debugging");
+ DebugMan.addDebugChannel(kTonyDebugMusic, "music", "Music debugging");
+
+ // Add folders to the search directory list
+ const Common::FSNode gameDataDir(ConfMan.get("path"));
+ SearchMan.addSubDirectoryMatching(gameDataDir, "Voices");
+ SearchMan.addSubDirectoryMatching(gameDataDir, "Roasted");
+ SearchMan.addSubDirectoryMatching(gameDataDir, "Music");
+ SearchMan.addSubDirectoryMatching(gameDataDir, "Music/utilsfx");
+
+ // Set up load slot number
+ _initialLoadSlotNumber = -1;
+ if (ConfMan.hasKey("save_slot")) {
+ int slotNumber = ConfMan.getInt("save_slot");
+ if (slotNumber >= 0 && slotNumber <= 99)
+ _initialLoadSlotNumber = slotNumber;
+ }
+
+ // Load the ScummVM sound settings
+ syncSoundSettings();
+
+ _hEndOfFrame = 0;
+ for (int i = 0; i < 6; i++)
+ _stream[i] = NULL;
+ for (int i = 0; i < MAX_SFX_CHANNELS; i++) {
+ _sfx[i] = NULL;
+ _utilSfx[i] = NULL;
+ }
+ _bPaused = false;
+ _bDrawLocation = false;
+ _startTime = 0;
+ _curThumbnail = NULL;
+ _bQuitNow = false;
+ _bTimeFreezed = false;
+ _nTimeFreezed = 0;
+}
+
+TonyEngine::~TonyEngine() {
+ // Close the voice database
+ closeVoiceDatabase();
+
+ // Reset the coroutine scheduler
+ CoroScheduler.reset();
+ CoroScheduler.setResourceCallback(NULL);
+
+ delete _debugger;
+}
+
+/**
+ * Run the game
+ */
+Common::Error TonyEngine::run() {
+ Common::ErrorCode result = init();
+ if (result != Common::kNoError)
+ return result;
+
+ play();
+ close();
+
+ return Common::kNoError;
+}
+
+/**
+ * Initialize the game
+ */
+Common::ErrorCode TonyEngine::init() {
+ // Load DAT file (used by font manager)
+ if (!loadTonyDat())
+ return Common::kUnknownError;
+
+ if (isCompressed()) {
+ Common::SeekableReadStream *stream = SearchMan.createReadStreamForMember("data1.cab");
+ if (!stream)
+ error("Failed to open data1.cab");
+
+ Common::Archive *cabinet = Common::makeInstallShieldArchive(stream);
+ if (!cabinet)
+ error("Failed to parse data1.cab");
+
+ SearchMan.add("data1.cab", cabinet);
+ }
+
+ _hEndOfFrame = CoroScheduler.createEvent(false, false);
+
+ _bPaused = false;
+ _bDrawLocation = true;
+ _startTime = g_system->getMillis();
+
+ // Init static class fields
+ RMText::initStatics();
+ RMTony::initStatics();
+
+ // Reset the scheduler
+ CoroScheduler.reset();
+
+ // Initialize the graphics window
+ _window.init();
+
+ // Initialize the function list
+ Common::fill(_funcList, _funcList + 300, (LPCUSTOMFUNCTION)NULL);
+ initCustomFunctionMap();
+
+ // Initializes MPAL system, passing the custom functions list
+ Common::File f;
+ if (!f.open("ROASTED.MPC"))
+ return Common::kReadingFailed;
+ f.close();
+
+ if (!mpalInit("ROASTED.MPC", "ROASTED.MPR", _funcList, _funcListStrings))
+ return Common::kUnknownError;
+
+ // Initialize the update resources
+ _resUpdate.init("ROASTED.MPU");
+
+ // Initialize the music
+ initMusic();
+
+ // Initialize the voices database
+ if (!openVoiceDatabase())
+ return Common::kReadingFailed;
+
+ // Initialize the boxes
+ _theBoxes.init();
+
+ // Link to the custom graphics engine
+ _theEngine.initCustomDll();
+ _theEngine.init();
+
+ // Allocate space for thumbnails when saving the game
+ _curThumbnail = new uint16[160 * 120];
+
+ _bQuitNow = false;
+
+ return Common::kNoError;
+}
+
+bool TonyEngine::loadTonyDat() {
+ Common::String msg;
+ Common::File in;
+
+ in.open("tony.dat");
+
+ if (!in.isOpen()) {
+ msg = "You're missing the 'tony.dat' file. Get it from the ScummVM website";
+ GUIErrorMessage(msg);
+ warning("%s", msg.c_str());
+ return false;
+ }
+
+ // Read header
+ char buf[4+1];
+ in.read(buf, 4);
+ buf[4] = '\0';
+
+ if (strcmp(buf, "TONY")) {
+ msg = "File 'tony.dat' is corrupt. Get it from the ScummVM website";
+ GUIErrorMessage(msg);
+ warning("%s", msg.c_str());
+ return false;
+ }
+
+ int majVer = in.readByte();
+ int minVer = in.readByte();
+
+ if ((majVer != TONY_DAT_VER_MAJ) || (minVer != TONY_DAT_VER_MIN)) {
+ msg = Common::String::format("File 'tony.dat' is wrong version. Expected %d.%d but got %d.%d. Get it from the ScummVM website", TONY_DAT_VER_MAJ, TONY_DAT_VER_MIN, majVer, minVer);
+ GUIErrorMessage(msg);
+ warning("%s", msg.c_str());
+
+ return false;
+ }
+
+ int expectedLangVariant = -1;
+ switch (g_vm->getLanguage()) {
+ case Common::IT_ITA:
+ case Common::EN_ANY:
+ expectedLangVariant = 0;
+ break;
+ case Common::PL_POL:
+ expectedLangVariant = 1;
+ break;
+ case Common::RU_RUS:
+ expectedLangVariant = 2;
+ break;
+ case Common::CZ_CZE:
+ expectedLangVariant = 3;
+ break;
+ case Common::FR_FRA:
+ expectedLangVariant = 4;
+ break;
+ case Common::DE_DEU:
+ expectedLangVariant = 5;
+ break;
+ default:
+ warning("Unhandled language, falling back to English/Italian fonts.");
+ expectedLangVariant = 0;
+ break;
+ }
+
+ int numVariant = in.readUint16BE();
+ if (expectedLangVariant > numVariant) {
+ msg = Common::String::format("Font variant not present in 'tony.dat'. Get it from the ScummVM website");
+ GUIErrorMessage(msg);
+ warning("%s", msg.c_str());
+
+ return false;
+ }
+
+ in.seek(in.pos() + (2 * 256 * 8 * expectedLangVariant));
+ for (int i = 0; i < 256; i++) {
+ _cTableDialog[i] = in.readSint16BE();
+ _lTableDialog[i] = in.readSint16BE();
+ _cTableMacc[i] = in.readSint16BE();
+ _lTableMacc[i] = in.readSint16BE();
+ _cTableCred[i] = in.readSint16BE();
+ _lTableCred[i] = in.readSint16BE();
+ _cTableObj[i] = in.readSint16BE();
+ _lTableObj[i] = in.readSint16BE();
+ }
+
+ return true;
+}
+
+void TonyEngine::initCustomFunctionMap() {
+ INIT_CUSTOM_FUNCTION(_funcList, _funcListStrings);
+}
+
+/**
+ * Display an error message
+ */
+void TonyEngine::GUIError(const Common::String &msg) {
+ GUIErrorMessage(msg);
+}
+
+void TonyEngine::playMusic(int nChannel, const Common::String &fname, int nFX, bool bLoop, int nSync) {
+ if (nChannel < 4) {
+ if (GLOBALS._flipflop)
+ nChannel = nChannel + 1;
+ }
+
+ switch (nFX) {
+ case 0:
+ case 1:
+ case 2:
+ _stream[nChannel]->stop();
+ _stream[nChannel]->unloadFile();
+ break;
+
+ case 22:
+ break;
+ }
+
+ if (nFX == 22) { // Sync a tempo
+ GLOBALS._curChannel = nChannel;
+ GLOBALS._nextLoop = bLoop;
+ GLOBALS._nextSync = nSync;
+ GLOBALS._nextMusic = fname;
+
+ if (GLOBALS._flipflop)
+ GLOBALS._nextChannel = nChannel - 1;
+ else
+ GLOBALS._nextChannel = nChannel + 1;
+
+ uint32 hThread = CoroScheduler.createProcess(doNextMusic, NULL, 0);
+ assert(hThread != CORO_INVALID_PID_VALUE);
+
+ } else if (nFX == 44) { // Change the channel and let the first finish
+ if (GLOBALS._flipflop)
+ GLOBALS._nextChannel = nChannel - 1;
+ else
+ GLOBALS._nextChannel = nChannel + 1;
+
+ _stream[GLOBALS._nextChannel]->stop();
+ _stream[GLOBALS._nextChannel]->unloadFile();
+
+ if (!getIsDemo()) {
+ if (!_stream[GLOBALS._nextChannel]->loadFile(fname, FPCODEC_ADPCM, nSync))
+ g_vm->abortGame();
+ } else {
+ _stream[GLOBALS._nextChannel]->loadFile(fname, FPCODEC_ADPCM, nSync);
+ }
+
+ _stream[GLOBALS._nextChannel]->setLoop(bLoop);
+ _stream[GLOBALS._nextChannel]->play();
+
+ GLOBALS._flipflop = 1 - GLOBALS._flipflop;
+ } else {
+ if (!getIsDemo()) {
+ if (!_stream[nChannel]->loadFile(fname, FPCODEC_ADPCM, nSync))
+ g_vm->abortGame();
+ } else {
+ _stream[nChannel]->loadFile(fname, FPCODEC_ADPCM, nSync);
+ }
+
+ _stream[nChannel]->setLoop(bLoop);
+ _stream[nChannel]->play();
+ }
+}
+
+void TonyEngine::doNextMusic(CORO_PARAM, const void *param) {
+ CORO_BEGIN_CONTEXT;
+ Common::String fn;
+ CORO_END_CONTEXT(_ctx);
+
+ FPStream **streams = g_vm->_stream;
+
+ CORO_BEGIN_CODE(_ctx);
+
+ if (!g_vm->getIsDemo()) {
+ if (!streams[GLOBALS._nextChannel]->loadFile(GLOBALS._nextMusic, FPCODEC_ADPCM, GLOBALS._nextSync))
+ g_vm->abortGame();
+ } else {
+ streams[GLOBALS._nextChannel]->loadFile(GLOBALS._nextMusic, FPCODEC_ADPCM, GLOBALS._nextSync);
+ }
+
+ streams[GLOBALS._nextChannel]->setLoop(GLOBALS._nextLoop);
+ //streams[GLOBALS._nextChannel]->prefetch();
+
+ streams[GLOBALS._curChannel]->waitForSync(streams[GLOBALS._nextChannel]);
+
+ streams[GLOBALS._curChannel]->unloadFile();
+
+ GLOBALS._flipflop = 1 - GLOBALS._flipflop;
+
+ CORO_END_CODE;
+}
+
+void TonyEngine::playSFX(int nChannel, int nFX) {
+ if (_sfx[nChannel] == NULL)
+ return;
+
+ switch (nFX) {
+ case 0:
+ _sfx[nChannel]->setLoop(false);
+ break;
+
+ case 1:
+ _sfx[nChannel]->setLoop(true);
+ break;
+ }
+
+ _sfx[nChannel]->play();
+}
+
+void TonyEngine::stopMusic(int nChannel) {
+ if (nChannel < 4)
+ _stream[nChannel + GLOBALS._flipflop]->stop();
+ else
+ _stream[nChannel]->stop();
+}
+
+void TonyEngine::stopSFX(int nChannel) {
+ _sfx[nChannel]->stop();
+}
+
+void TonyEngine::playUtilSFX(int nChannel, int nFX) {
+ if (_utilSfx[nChannel] == NULL)
+ return;
+
+ switch (nFX) {
+ case 0:
+ _utilSfx[nChannel]->setLoop(false);
+ break;
+
+ case 1:
+ _utilSfx[nChannel]->setLoop(true);
+ break;
+ }
+
+ _utilSfx[nChannel]->setVolume(52);
+ _utilSfx[nChannel]->play();
+}
+
+void TonyEngine::stopUtilSFX(int nChannel) {
+ _utilSfx[nChannel]->stop();
+}
+
+void TonyEngine::preloadSFX(int nChannel, const char *fn) {
+ if (_sfx[nChannel] != NULL) {
+ _sfx[nChannel]->stop();
+ _sfx[nChannel]->release();
+ _sfx[nChannel] = NULL;
+ }
+
+ _theSound.createSfx(&_sfx[nChannel]);
+
+ _sfx[nChannel]->loadFile(fn, FPCODEC_ADPCM);
+}
+
+FPSfx *TonyEngine::createSFX(Common::SeekableReadStream *stream) {
+ FPSfx *sfx;
+
+ _theSound.createSfx(&sfx);
+ sfx->loadWave(stream);
+ return sfx;
+}
+
+void TonyEngine::preloadUtilSFX(int nChannel, const char *fn) {
+ if (_utilSfx[nChannel] != NULL) {
+ _utilSfx[nChannel]->stop();
+ _utilSfx[nChannel]->release();
+ _utilSfx[nChannel] = NULL;
+ }
+
+ _theSound.createSfx(&_utilSfx[nChannel]);
+
+ _utilSfx[nChannel]->loadFile(fn, FPCODEC_ADPCM);
+ _utilSfx[nChannel]->setVolume(63);
+}
+
+void TonyEngine::unloadAllSFX() {
+ for (int i = 0; i < MAX_SFX_CHANNELS; i++) {
+ if (_sfx[i] != NULL) {
+ _sfx[i]->stop();
+ _sfx[i]->release();
+ _sfx[i] = NULL;
+ }
+ }
+}
+
+void TonyEngine::unloadAllUtilSFX() {
+ for (int i = 0; i < MAX_SFX_CHANNELS; i++) {
+ if (_utilSfx[i] != NULL) {
+ _utilSfx[i]->stop();
+ _utilSfx[i]->release();
+ _utilSfx[i] = NULL;
+ }
+ }
+}
+
+void TonyEngine::initMusic() {
+ int i;
+
+ _theSound.init();
+ _theSound.setMasterVolume(63);
+
+ for (i = 0; i < 6; i++)
+ _theSound.createStream(&_stream[i]);
+
+ for (i = 0; i < MAX_SFX_CHANNELS; i++) {
+ _sfx[i] = _utilSfx[i] = NULL;
+ }
+
+ // Preload sound effects
+ preloadUtilSFX(0, "U01.ADP"); // Reversed!!
+ preloadUtilSFX(1, "U02.ADP");
+
+ // Start check processes for sound
+ CoroScheduler.createProcess(FPSfx::soundCheckProcess, NULL);
+}
+
+void TonyEngine::closeMusic() {
+ for (int i = 0; i < 6; i++) {
+ _stream[i]->stop();
+ _stream[i]->unloadFile();
+ _stream[i]->release();
+ }
+
+ unloadAllSFX();
+ unloadAllUtilSFX();
+}
+
+void TonyEngine::pauseSound(bool bPause) {
+ _theEngine.pauseSound(bPause);
+
+ for (uint i = 0; i < 6; i++)
+ if (_stream[i])
+ _stream[i]->pause(bPause);
+
+ for (uint i = 0; i < MAX_SFX_CHANNELS; i++) {
+ if (_sfx[i])
+ _sfx[i]->pause(bPause);
+ if (_utilSfx[i])
+ _utilSfx[i]->pause(bPause);
+ }
+}
+
+void TonyEngine::setMusicVolume(int nChannel, int volume) {
+ _stream[nChannel + GLOBALS._flipflop]->setVolume(volume);
+}
+
+int TonyEngine::getMusicVolume(int nChannel) {
+ int volume;
+ _stream[nChannel + GLOBALS._flipflop]->getVolume(&volume);
+ return volume;
+}
+
+Common::String TonyEngine::getSaveStateFileName(int n) {
+ return Common::String::format("tony.%03d", n);
+}
+
+void TonyEngine::autoSave(CORO_PARAM) {
+ CORO_BEGIN_CONTEXT;
+ Common::String buf;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ grabThumbnail();
+ CORO_INVOKE_2(CoroScheduler.waitForSingleObject, g_vm->_hEndOfFrame, CORO_INFINITE);
+ CORO_INVOKE_2(CoroScheduler.waitForSingleObject, g_vm->_hEndOfFrame, CORO_INFINITE);
+ _ctx->buf = getSaveStateFileName(0);
+ _theEngine.saveState(_ctx->buf, (byte *)_curThumbnail, "Autosave");
+
+ CORO_END_CODE;
+}
+
+void TonyEngine::saveState(int n, const char *name) {
+ Common::String buf = getSaveStateFileName(n);
+ _theEngine.saveState(buf.c_str(), (byte *)_curThumbnail, name);
+}
+
+void TonyEngine::loadState(CORO_PARAM, int n) {
+ CORO_BEGIN_CONTEXT;
+ Common::String buf;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ _ctx->buf = getSaveStateFileName(n);
+ CORO_INVOKE_1(_theEngine.loadState, _ctx->buf.c_str());
+
+ CORO_END_CODE;
+}
+
+bool TonyEngine::openVoiceDatabase() {
+ char id[4];
+ uint32 numfiles;
+
+ // Open the voices database
+ if (!_vdbFP.open("voices.vdb"))
+ return false;
+
+ _vdbFP.seek(-8, SEEK_END);
+ numfiles = _vdbFP.readUint32LE();
+ _vdbFP.read(id, 4);
+
+ if (id[0] != 'V' || id[1] != 'D' || id[2] != 'B' || id[3] != '1') {
+ _vdbFP.close();
+ return false;
+ }
+
+ // Read in the index
+ _vdbFP.seek(-8 - (numfiles * VOICE_HEADER_SIZE), SEEK_END);
+
+ for (uint32 i = 0; i < numfiles; ++i) {
+ VoiceHeader vh;
+ vh._offset = _vdbFP.readUint32LE();
+ vh._code = _vdbFP.readUint32LE();
+ vh._parts = _vdbFP.readUint32LE();
+
+ _voices.push_back(vh);
+ }
+
+ return true;
+}
+
+void TonyEngine::closeVoiceDatabase() {
+ if (_vdbFP.isOpen())
+ _vdbFP.close();
+
+ if (_voices.size() > 0)
+ _voices.clear();
+}
+
+void TonyEngine::grabThumbnail() {
+ _window.grabThumbnail(_curThumbnail);
+}
+
+uint16 *TonyEngine::getThumbnail() {
+ return _curThumbnail;
+}
+
+void TonyEngine::quitGame() {
+ _bQuitNow = true;
+}
+
+void TonyEngine::openInitLoadMenu(CORO_PARAM) {
+ _theEngine.openOptionScreen(coroParam, 1);
+}
+
+void TonyEngine::openInitOptions(CORO_PARAM) {
+ _theEngine.openOptionScreen(coroParam, 2);
+}
+
+void TonyEngine::abortGame() {
+ _bQuitNow = true;
+}
+
+/**
+ * Main process for playing the game.
+ *
+ * @remarks This needs to be in a separate process, since there are some things that can briefly
+ * block the execution of process. For now, all ScummVm event handling is dispatched to within the context of this
+ * process. If it ever proves a problem, we may have to look into whether it's feasible to have it still remain
+ * in the outer 'main' process.
+ */
+void TonyEngine::playProcess(CORO_PARAM, const void *param) {
+ CORO_BEGIN_CONTEXT;
+ Common::String fn;
+ CORO_END_CONTEXT(_ctx);
+
+
+ CORO_BEGIN_CODE(_ctx);
+
+ // Game loop. We rely on the outer main process to detect if a shutdown is required,
+ // and kill the scheudler and all the processes, including this one
+ for (;;) {
+ // If a savegame needs to be loaded, then do so
+ if (g_vm->_loadSlotNumber != -1 && GLOBALS._gfxEngine != NULL) {
+ _ctx->fn = getSaveStateFileName(g_vm->_loadSlotNumber);
+ CORO_INVOKE_1(GLOBALS._gfxEngine->loadState, _ctx->fn);
+ g_vm->_loadSlotNumber = -1;
+ }
+
+ // Wait for the next frame
+ CORO_INVOKE_1(CoroScheduler.sleep, 50);
+
+ // Call the engine to handle the next frame
+ CORO_INVOKE_1(g_vm->_theEngine.doFrame, g_vm->_bDrawLocation);
+
+ // Warns that a frame is finished
+ CoroScheduler.pulseEvent(g_vm->_hEndOfFrame);
+
+ // Handle drawing the frame
+ if (!g_vm->_bPaused) {
+ if (!g_vm->_theEngine._bWiping)
+ g_vm->_window.getNewFrame(g_vm->_theEngine, NULL);
+ else
+ g_vm->_window.getNewFrame(g_vm->_theEngine, &g_vm->_theEngine._rcWipeEllipse);
+ }
+
+ // Paint the frame onto the screen
+ g_vm->_window.repaint();
+
+ // Signal the ScummVM debugger
+ g_vm->_debugger->onFrame();
+ }
+
+ CORO_END_CODE;
+}
+
+/**
+ * Play the game
+ */
+void TonyEngine::play() {
+ // Create the game player process
+ CoroScheduler.createProcess(playProcess, NULL);
+
+ // Loop through calling the scheduler until it's time for the game to quit
+ while (!shouldQuit() && !_bQuitNow) {
+ // Delay for a brief amount
+ g_system->delayMillis(10);
+
+ // Call any scheduled processes
+ CoroScheduler.schedule();
+ }
+}
+
+void TonyEngine::close() {
+ closeMusic();
+ CoroScheduler.closeEvent(_hEndOfFrame);
+ _theBoxes.close();
+ _theEngine.close();
+ _window.close();
+ mpalFree();
+ freeMpc();
+ delete[] _curThumbnail;
+}
+
+void TonyEngine::freezeTime() {
+ _bTimeFreezed = true;
+ _nTimeFreezed = getTime() - _startTime;
+}
+
+void TonyEngine::unfreezeTime() {
+ _bTimeFreezed = false;
+}
+
+/**
+ * Returns the millisecond timer
+ */
+uint32 TonyEngine::getTime() {
+ return g_system->getMillis();
+}
+
+bool TonyEngine::canLoadGameStateCurrently() {
+ return GLOBALS._gfxEngine != NULL && GLOBALS._gfxEngine->canLoadSave();
+}
+bool TonyEngine::canSaveGameStateCurrently() {
+ return GLOBALS._gfxEngine != NULL && GLOBALS._gfxEngine->canLoadSave();
+}
+
+Common::Error TonyEngine::loadGameState(int slot) {
+ _loadSlotNumber = slot;
+ return Common::kNoError;
+}
+
+Common::Error TonyEngine::saveGameState(int slot, const Common::String &desc) {
+ if (!GLOBALS._gfxEngine)
+ return Common::kUnknownError;
+
+ RMGfxTargetBuffer &bigBuf = *GLOBALS._gfxEngine;
+ RMSnapshot s;
+ s.grabScreenshot(bigBuf, 4, _curThumbnail);
+
+ GLOBALS._gfxEngine->saveState(getSaveStateFileName(slot), (byte *)_curThumbnail, desc);
+ return Common::kNoError;
+}
+
+void TonyEngine::syncSoundSettings() {
+ Engine::syncSoundSettings();
+
+ GLOBALS._bCfgDubbing = !ConfMan.getBool("mute") && !ConfMan.getBool("speech_mute");
+ GLOBALS._bCfgSFX = !ConfMan.getBool("mute") && !ConfMan.getBool("sfx_mute");
+ GLOBALS._bCfgMusic = !ConfMan.getBool("mute") && !ConfMan.getBool("music_mute");
+
+ GLOBALS._nCfgDubbingVolume = ConfMan.getInt("speech_volume") * 10 / 256;
+ GLOBALS._nCfgSFXVolume = ConfMan.getInt("sfx_volume") * 10 / 256;
+ GLOBALS._nCfgMusicVolume = ConfMan.getInt("music_volume") * 10 / 256;
+
+ GLOBALS._bShowSubtitles = ConfMan.getBool("subtitles");
+ GLOBALS._nCfgTextSpeed = ConfMan.getInt("talkspeed") * 10 / 256;
+}
+
+void TonyEngine::saveSoundSettings() {
+ ConfMan.setBool("speech_mute", GLOBALS._bCfgDubbing);
+ ConfMan.setBool("sfx_mute", GLOBALS._bCfgSFX);
+ ConfMan.setBool("music_mute", GLOBALS._bCfgMusic);
+
+ ConfMan.setInt("speech_volume", GLOBALS._nCfgDubbingVolume * 256 / 10);
+ ConfMan.setInt("sfx_volume", GLOBALS._nCfgSFXVolume * 256 / 10);
+ ConfMan.setInt("music_volume", GLOBALS._nCfgMusicVolume * 256 / 10);
+
+ ConfMan.setBool("subtitles", GLOBALS._bShowSubtitles);
+ ConfMan.setInt("talkspeed", GLOBALS._nCfgTextSpeed * 256 / 10);
+}
+
+void TonyEngine::showLocation() {
+ _bDrawLocation = true;
+}
+
+void TonyEngine::hideLocation() {
+ _bDrawLocation = false;
+}
+
+} // End of namespace Tony
diff --git a/engines/tony/tony.h b/engines/tony/tony.h
new file mode 100644
index 0000000000..22090dfe51
--- /dev/null
+++ b/engines/tony/tony.h
@@ -0,0 +1,243 @@
+/* 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 TONY_H
+#define TONY_H
+
+#include "common/scummsys.h"
+#include "common/system.h"
+#include "common/array.h"
+#include "common/coroutines.h"
+#include "common/error.h"
+#include "common/random.h"
+#include "common/util.h"
+#include "engines/engine.h"
+
+#include "tony/mpal/mpal.h"
+#include "tony/mpal/memory.h"
+#include "tony/debugger.h"
+#include "tony/gfxengine.h"
+#include "tony/loc.h"
+#include "tony/utils.h"
+#include "tony/window.h"
+#include "tony/globals.h"
+
+/**
+ * This is the namespace of the Tony engine.
+ *
+ * Status of this engine: In Development
+ *
+ * Games using this engine:
+ * - Tony Tough
+ */
+namespace Tony {
+
+using namespace MPAL;
+
+class Globals;
+
+enum {
+ kTonyDebugAnimations = 1 << 0,
+ kTonyDebugActions = 1 << 1,
+ kTonyDebugSound = 1 << 2,
+ kTonyDebugMusic = 1 << 3,
+ kTonyDebugMPAL = 1 << 4
+};
+
+#define DEBUG_BASIC 1
+#define DEBUG_INTERMEDIATE 2
+#define DEBUG_DETAILED 3
+
+struct TonyGameDescription;
+
+#define MAX_SFX_CHANNELS 32
+#define TONY_DAT_VER_MAJ 0
+#define TONY_DAT_VER_MIN 1
+
+struct VoiceHeader {
+ int _offset;
+ int _code;
+ int _parts;
+};
+#define VOICE_HEADER_SIZE 12
+
+class TonyEngine : public Engine {
+private:
+ Common::ErrorCode init();
+ bool loadTonyDat();
+ void initMusic();
+ void closeMusic();
+ bool openVoiceDatabase();
+ void closeVoiceDatabase();
+ void initCustomFunctionMap();
+ static void playProcess(CORO_PARAM, const void *param);
+ static void doNextMusic(CORO_PARAM, const void *param);
+
+protected:
+ // Engine APIs
+ virtual Common::Error run();
+ virtual bool hasFeature(EngineFeature f) const;
+public:
+ LPCUSTOMFUNCTION _funcList[300];
+ Common::String _funcListStrings[300];
+ Common::RandomSource _randomSource;
+ RMResUpdate _resUpdate;
+ uint32 _hEndOfFrame;
+ Common::File _vdbFP;
+ Common::Array<VoiceHeader> _voices;
+ FPSound _theSound;
+ Common::List<FPSfx *> _activeSfx;
+ Globals _globals;
+ Debugger *_debugger;
+
+ int16 _cTableDialog[256];
+ int16 _lTableDialog[256];
+ int16 _cTableMacc[256];
+ int16 _lTableMacc[256];
+ int16 _cTableCred[256];
+ int16 _lTableCred[256];
+ int16 _cTableObj[256];
+ int16 _lTableObj[256];
+
+ enum DataDir {
+ DD_BASE = 1,
+ DD_SAVE,
+ DD_SHOTS,
+ DD_MUSIC,
+ DD_LAYER,
+ DD_UTILSFX,
+ DD_VOICES,
+ DD_BASE2
+ };
+
+ FPStream *_stream[6];
+ FPSfx *_sfx[MAX_SFX_CHANNELS];
+ FPSfx *_utilSfx[MAX_SFX_CHANNELS];
+ bool _bPaused;
+ bool _bDrawLocation;
+ int _startTime;
+ uint16 *_curThumbnail;
+ int _initialLoadSlotNumber;
+ int _loadSlotNumber;
+
+ // Bounding box list manager
+ RMGameBoxes _theBoxes;
+ RMWindow _window;
+ RMGfxEngine _theEngine;
+
+ bool _bQuitNow;
+ bool _bTimeFreezed;
+ int _nTimeFreezed;
+public:
+ TonyEngine(OSystem *syst, const TonyGameDescription *gameDesc);
+ virtual ~TonyEngine();
+
+ const TonyGameDescription *_gameDescription;
+ uint32 getFeatures() const;
+ Common::Language getLanguage() const;
+ uint16 getVersion() const;
+ bool getIsDemo() const;
+ bool isCompressed() const;
+ RMGfxEngine *getEngine() {
+ return &_theEngine;
+ }
+ void GUIError(const Common::String &msg);
+
+ virtual bool canLoadGameStateCurrently();
+ virtual bool canSaveGameStateCurrently();
+ Common::Error loadGameState(int slot);
+ Common::Error saveGameState(int slot, const Common::String &desc);
+
+ void play();
+ void close();
+ void abortGame();
+
+ void getDataDirectory(DataDir dir, char *path);
+
+ void showLocation();
+ void hideLocation();
+
+ /**
+ * Reads the time
+ */
+ uint32 getTime();
+ void freezeTime();
+ void unfreezeTime();
+
+ // Music
+ // ******
+ void playMusic(int nChannel, const Common::String &fn, int nFX, bool bLoop, int nSync);
+ void stopMusic(int nChannel);
+
+ void playSFX(int nSfx, int nFX = 0);
+ void stopSFX(int nSfx);
+
+ void playUtilSFX(int nSfx, int nFX = 0);
+ void stopUtilSFX(int nSfx);
+
+ FPSfx *createSFX(Common::SeekableReadStream *stream);
+
+ void preloadSFX(int nSfx, const char *fn);
+ void unloadAllSFX();
+
+ void preloadUtilSFX(int nSfx, const char *fn);
+ void unloadAllUtilSFX();
+
+ /**
+ * Stop all the audio
+ */
+ void pauseSound(bool bPause);
+
+ void setMusicVolume(int nChannel, int volume);
+ int getMusicVolume(int nChannel);
+
+ /**
+ * Handle saving
+ */
+ void autoSave(CORO_PARAM);
+ void saveState(int n, const char *name);
+ void loadState(CORO_PARAM, int n);
+ static Common::String getSaveStateFileName(int n);
+
+ /**
+ * Get a thumbnail
+ */
+ void grabThumbnail();
+ uint16 *getThumbnail();
+
+ void quitGame();
+
+ void openInitLoadMenu(CORO_PARAM);
+ void openInitOptions(CORO_PARAM);
+
+ virtual void syncSoundSettings();
+ void saveSoundSettings();
+};
+
+// Global reference to the TonyEngine object
+extern TonyEngine *g_vm;
+
+#define GLOBALS g_vm->_globals
+
+} // End of namespace Tony
+
+#endif /* TONY_H */
diff --git a/engines/tony/tonychar.cpp b/engines/tony/tonychar.cpp
new file mode 100644
index 0000000000..c7fa1e4a7b
--- /dev/null
+++ b/engines/tony/tonychar.cpp
@@ -0,0 +1,1945 @@
+/* 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.
+ *
+ */
+
+/*
+ * This code is based on original Tony Tough source code
+ *
+ * Copyright (c) 1997-2003 Nayma Software
+ */
+
+#include "tony/mpal/memory.h"
+#include "tony/mpal/mpalutils.h"
+#include "tony/game.h"
+#include "tony/tonychar.h"
+#include "tony/tony.h"
+
+namespace Tony {
+
+bool RMTony::_bAction = false;
+
+void RMTony::initStatics() {
+ _bAction = false;
+}
+
+RMTony::RMTony() {
+ _bShow = false;
+ _bShowShadow = false;
+ _bBodyFront = false;
+ _bActionPending = false;
+ _actionItem = NULL;
+ _action = 0;
+ _actionParm = 0;
+ _bShepherdess = false;
+ _bIsStaticTalk = false;
+ _bIsTalking = false;
+ _nPatB4Talking = 0;
+ _nTalkType = TALK_NORMAL;
+ _talkDirection = UP;
+ _nTimeLastStep = 0;
+ _hActionThread = CORO_INVALID_PID_VALUE;
+}
+
+void RMTony::waitEndOfAction(CORO_PARAM, const void *param) {
+ CORO_BEGIN_CONTEXT;
+ CORO_END_CONTEXT(_ctx);
+
+ uint32 pid = *(const uint32 *)param;
+
+ CORO_BEGIN_CODE(_ctx);
+
+ CORO_INVOKE_2(CoroScheduler.waitForSingleObject, pid, CORO_INFINITE);
+
+ _bAction = false;
+
+ CORO_END_CODE;
+}
+
+RMGfxSourceBuffer *RMTony::newItemSpriteBuffer(int dimx, int dimy, bool bPreRLE) {
+ RMGfxSourceBuffer8RLE *spr;
+
+ assert(_cm == CM_256);
+ spr = new RMGfxSourceBuffer8RLEByteAA;
+ spr->setAlphaBlendColor(1);
+ if (bPreRLE)
+ spr->setAlreadyCompressed();
+ return spr;
+}
+
+void RMTony::init() {
+ RMRes tony(0);
+ RMRes body(9999);
+
+ // Tony is shown by default
+ _bShow = _bShowShadow = true;
+
+ // No action pending
+ _bActionPending = false;
+ _bAction = false;
+
+ _bShepherdess = false;
+ _bIsTalking = false;
+ _bIsStaticTalk = false;
+
+ // Opens the buffer
+ Common::SeekableReadStream *ds = tony.getReadStream();
+
+ // Reads his details from the stream
+ readFromStream(*ds, true);
+
+ // Closes the buffer
+ delete ds;
+
+ // Reads Tony's body
+ ds = body.getReadStream();
+ _body.readFromStream(*ds, true);
+ delete ds;
+ _body.setPattern(0);
+
+ _nTimeLastStep = g_vm->getTime();
+}
+
+
+void RMTony::close() {
+ // Deallocation of missing item
+// _shadow.destroy();
+}
+
+void RMTony::doFrame(CORO_PARAM, RMGfxTargetBuffer *bigBuf, int curLoc) {
+ CORO_BEGIN_CONTEXT;
+ int time;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ if (!_nInList && _bShow)
+ bigBuf->addPrim(new RMGfxPrimitive(this));
+
+ setSpeed(GLOBALS._nCfgTonySpeed);
+
+ // Runs the normal character movement
+ _ctx->time = g_vm->getTime();
+
+ do {
+ _nTimeLastStep += (1000 / 40);
+ CORO_INVOKE_2(RMCharacter::doFrame, bigBuf, curLoc);
+ } while (_ctx->time > _nTimeLastStep + (1000 / 40));
+
+ // Check if we are at the end of a path
+ if (endOfPath() && _bActionPending) {
+ // Must perform the action on which we clicked
+ _bActionPending = false;
+ }
+
+ if (_bIsTalking || _bIsStaticTalk)
+ _body.doFrame(bigBuf, false);
+
+ CORO_END_CODE;
+}
+
+void RMTony::show() {
+ _bShow = true;
+ _bShowShadow = true;
+}
+
+void RMTony::hide(bool bShowShadow) {
+ _bShow = false;
+ _bShowShadow = bShowShadow;
+}
+
+
+void RMTony::draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim) {
+ CORO_BEGIN_CONTEXT;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ // Call the Draw() of the parent class if Tony is visible
+ if (_bShow && _bDrawNow) {
+ if (_bBodyFront) {
+ prim->getDst().setEmpty();
+ prim->getDst().offset(-44, -134);
+ if (_bShepherdess)
+ prim->getDst().offset(1, 4);
+ CORO_INVOKE_2(RMCharacter::draw, bigBuf, prim);
+ }
+
+ if (_bIsTalking || _bIsStaticTalk) {
+ // Offest direction from scrolling
+ prim->getDst().setEmpty();
+ prim->getDst().offset(-_curScroll);
+ prim->getDst().offset(_pos);
+ prim->getDst().offset(-44, -134);
+ prim->getDst() += _nBodyOffset;
+ CORO_INVOKE_2(_body.draw, bigBuf, prim);
+ }
+
+ if (!_bBodyFront) {
+ prim->getDst().setEmpty();
+ prim->getDst().offset(-44, -134);
+ if (_bShepherdess)
+ prim->getDst().offset(0, 3);
+ CORO_INVOKE_2(RMCharacter::draw, bigBuf, prim);
+ }
+ }
+
+ CORO_END_CODE;
+}
+
+void RMTony::moveAndDoAction(CORO_PARAM, RMPoint dst, RMItem *item, int nAction, int nActionParm) {
+ CORO_BEGIN_CONTEXT;
+ bool result;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ // Makes normal movement, but remember if you must then perform an action
+ if (item == NULL) {
+ _bActionPending = false;
+ _actionItem = NULL;
+ } else {
+ _actionItem = item;
+ _action = nAction;
+ _actionParm = nActionParm;
+ _bActionPending = true;
+ }
+
+ CORO_INVOKE_2(RMCharacter::move, dst, &_ctx->result);
+ if (!_ctx->result) {
+ _bActionPending = false;
+ _actionItem = NULL;
+ }
+
+ CORO_END_CODE;
+}
+
+
+void RMTony::executeAction(int nAction, int nActionItem, int nParm) {
+ uint32 pid;
+
+ if (nAction == TA_COMBINE) {
+ pid = mpalQueryDoAction(TA_COMBINE, nParm, nActionItem);
+
+ // If you failed the combine, we have RECEIVECOMBINE as a fallback
+ if (pid == CORO_INVALID_PID_VALUE) {
+ pid = mpalQueryDoAction(TA_RECEIVECOMBINE, nActionItem, nParm);
+
+ // If you failed with that, go with the generic
+ // @@@ CombineGive!
+ if (pid == CORO_INVALID_PID_VALUE) {
+ pid = mpalQueryDoAction(TA_COMBINE, nParm, 0);
+
+ if (pid == CORO_INVALID_PID_VALUE) {
+ pid = mpalQueryDoAction(TA_RECEIVECOMBINE, nActionItem, 0);
+ }
+ }
+ }
+ } else {
+ // Perform the action
+ pid = mpalQueryDoAction(nAction, nActionItem, 0);
+ }
+
+ if (pid != CORO_INVALID_PID_VALUE) {
+ _bAction = true;
+ CoroScheduler.createProcess(waitEndOfAction, &pid, sizeof(uint32));
+ _hActionThread = pid;
+ } else if (nAction != TA_GOTO) {
+ if (nAction == TA_TALK) {
+ pid = mpalQueryDoAction(6, 1, 0);
+ _bAction = true;
+ CoroScheduler.createProcess(waitEndOfAction, &pid, sizeof(uint32));
+ _hActionThread = pid;
+ } else if (nAction == TA_PERORATE) {
+ pid = mpalQueryDoAction(7, 1, 0);
+ _bAction = true;
+ CoroScheduler.createProcess(waitEndOfAction, &pid, sizeof(uint32));
+ _hActionThread = pid;
+ } else {
+ pid = mpalQueryDoAction(5, 1, 0);
+ _bAction = true;
+ CoroScheduler.createProcess(waitEndOfAction, &pid, sizeof(uint32));
+ _hActionThread = pid;
+ }
+ }
+}
+
+
+void RMTony::stopNoAction(CORO_PARAM) {
+ CORO_BEGIN_CONTEXT;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ if (_bAction)
+ CORO_INVOKE_2(CoroScheduler.waitForSingleObject, _hActionThread, CORO_INFINITE);
+
+ _bActionPending = false;
+ _actionItem = NULL;
+ CORO_INVOKE_0(stop);
+
+ CORO_END_CODE;
+}
+
+void RMTony::stop(CORO_PARAM) {
+ CORO_BEGIN_CONTEXT;
+ uint32 pid;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ if (_actionItem != NULL) {
+ // Call MPAL to choose the direction
+ _ctx->pid = mpalQueryDoAction(21, _actionItem->mpalCode(), 0);
+
+ if (_ctx->pid == CORO_INVALID_PID_VALUE)
+ CORO_INVOKE_0(RMCharacter::stop);
+ else {
+ _bNeedToStop = false; // If we make the OnWhichDirection, we don't need at least after the Stop().
+ _bMoving = false;
+ CORO_INVOKE_2(CoroScheduler.waitForSingleObject, _ctx->pid, CORO_INFINITE); // @@@ Put an assert after 10 seconds
+ }
+ } else {
+ CORO_INVOKE_0(RMCharacter::stop);
+ }
+
+ if (!_bActionPending)
+ return;
+
+ _bActionPending = false;
+
+ executeAction(_action, _actionItem->mpalCode(), _actionParm);
+
+ _actionItem = NULL;
+
+ CORO_END_CODE;
+}
+
+
+int RMTony::getCurPattern() {
+ int nPatt = RMCharacter::getCurPattern();
+
+ if (!_bShepherdess)
+ return nPatt;
+
+ switch (nPatt) {
+ case PAT_PAST_STANDUP:
+ return PAT_STANDUP;
+ case PAT_PAST_STANDDOWN:
+ return PAT_STANDDOWN;
+ case PAT_PAST_STANDLEFT:
+ return PAT_STANDLEFT;
+ case PAT_PAST_STANDRIGHT:
+ return PAT_STANDRIGHT;
+ case PAT_PAST_WALKUP:
+ return PAT_WALKUP;
+ case PAT_PAST_WALKDOWN:
+ return PAT_WALKDOWN;
+ case PAT_PAST_WALKLEFT:
+ return PAT_WALKLEFT;
+ case PAT_PAST_WALKRIGHT:
+ return PAT_WALKRIGHT;
+ }
+
+ return nPatt;
+}
+
+void RMTony::setPattern(int nPatt, bool bPlayP0) {
+ if (_bShepherdess) {
+ switch (nPatt) {
+ case PAT_STANDUP:
+ nPatt = PAT_PAST_STANDUP;
+ break;
+ case PAT_STANDDOWN:
+ nPatt = PAT_PAST_STANDDOWN;
+ break;
+ case PAT_STANDLEFT:
+ nPatt = PAT_PAST_STANDLEFT;
+ break;
+ case PAT_STANDRIGHT:
+ nPatt = PAT_PAST_STANDRIGHT;
+ break;
+ case PAT_WALKUP:
+ nPatt = PAT_PAST_WALKUP;
+ break;
+ case PAT_WALKDOWN:
+ nPatt = PAT_PAST_WALKDOWN;
+ break;
+ case PAT_WALKLEFT:
+ nPatt = PAT_PAST_WALKLEFT;
+ break;
+ case PAT_WALKRIGHT:
+ nPatt = PAT_PAST_WALKRIGHT;
+ break;
+ }
+ }
+
+ RMCharacter::setPattern(nPatt, bPlayP0);
+}
+
+
+void RMTony::take(int nWhere, int nPart) {
+ if (nPart == 0) {
+ switch (getCurPattern()) {
+ case PAT_STANDDOWN:
+ assert(0); // Not while you're doing a StandDown
+ break;
+
+ case PAT_STANDUP:
+ switch (nWhere) {
+ case 0:
+ setPattern(PAT_TAKEUP_UP1);
+ break;
+ case 1:
+ setPattern(PAT_TAKEUP_MID1);
+ break;
+ case 2:
+ setPattern(PAT_TAKEUP_DOWN1);
+ break;
+ }
+ break;
+
+ case PAT_STANDRIGHT:
+ switch (nWhere) {
+ case 0:
+ setPattern(PAT_TAKERIGHT_UP1);
+ break;
+ case 1:
+ setPattern(PAT_TAKERIGHT_MID1);
+ break;
+ case 2:
+ setPattern(PAT_TAKERIGHT_DOWN1);
+ break;
+ }
+ break;
+
+ case PAT_STANDLEFT:
+ switch (nWhere) {
+ case 0:
+ setPattern(PAT_TAKELEFT_UP1);
+ break;
+ case 1:
+ setPattern(PAT_TAKELEFT_MID1);
+ break;
+ case 2:
+ setPattern(PAT_TAKELEFT_DOWN1);
+ break;
+ }
+ break;
+ }
+ } else if (nPart == 1) {
+ setPattern(getCurPattern() + 1);
+ } else if (nPart == 2) {
+ switch (getCurPattern()) {
+ case PAT_TAKEUP_UP2:
+ case PAT_TAKEUP_MID2:
+ case PAT_TAKEUP_DOWN2:
+ setPattern(PAT_STANDUP);
+ break;
+
+ case PAT_TAKELEFT_UP2:
+ case PAT_TAKELEFT_MID2:
+ case PAT_TAKELEFT_DOWN2:
+ setPattern(PAT_STANDLEFT);
+ break;
+
+ case PAT_TAKERIGHT_UP2:
+ case PAT_TAKERIGHT_MID2:
+ case PAT_TAKERIGHT_DOWN2:
+ setPattern(PAT_STANDRIGHT);
+ break;
+ }
+ }
+}
+
+
+void RMTony::put(int nWhere, int nPart) {
+ if (nPart == 0) {
+ switch (getCurPattern()) {
+ case PAT_STANDDOWN:
+ break;
+
+ case PAT_STANDUP:
+ switch (nWhere) {
+ case 0:
+ setPattern(PAT_PUTUP_UP1);
+ break;
+ case 1:
+ setPattern(PAT_PUTUP_MID1);
+ break;
+ case 2:
+ setPattern(PAT_PUTUP_DOWN1);
+ break;
+ }
+ break;
+
+ case PAT_STANDRIGHT:
+ switch (nWhere) {
+ case 0:
+ setPattern(PAT_PUTRIGHT_UP1);
+ break;
+ case 1:
+ setPattern(PAT_PUTRIGHT_MID1);
+ break;
+ case 2:
+ setPattern(PAT_PUTRIGHT_DOWN1);
+ break;
+ }
+ break;
+
+ case PAT_STANDLEFT:
+ switch (nWhere) {
+ case 0:
+ setPattern(PAT_PUTLEFT_UP1);
+ break;
+ case 1:
+ setPattern(PAT_PUTLEFT_MID1);
+ break;
+ case 2:
+ setPattern(PAT_PUTLEFT_DOWN1);
+ break;
+ }
+ break;
+ }
+ } else if (nPart == 1) {
+ setPattern(getCurPattern() + 1);
+ } else if (nPart == 2) {
+ switch (getCurPattern()) {
+ case PAT_PUTUP_UP2:
+ case PAT_PUTUP_MID2:
+ case PAT_PUTUP_DOWN2:
+ setPattern(PAT_STANDUP);
+ break;
+
+ case PAT_PUTLEFT_UP2:
+ case PAT_PUTLEFT_MID2:
+ case PAT_PUTLEFT_DOWN2:
+ setPattern(PAT_STANDLEFT);
+ break;
+
+ case PAT_PUTRIGHT_UP2:
+ case PAT_PUTRIGHT_MID2:
+ case PAT_PUTRIGHT_DOWN2:
+ setPattern(PAT_STANDRIGHT);
+ break;
+ }
+ }
+}
+
+
+bool RMTony::startTalkCalculate(CharacterTalkType nTalkType, int &headStartPat, int &bodyStartPat,
+ int &headLoopPat, int &bodyLoopPat) {
+ assert(!_bIsTalking);
+
+ _bIsTalking = true;
+ _nPatB4Talking = getCurPattern();
+ _nTalkType = nTalkType;
+
+ // Set the direction of speech ONLY if we are not in a static animation (since it would have already been done)
+ if (!_bIsStaticTalk) {
+ switch (_nPatB4Talking) {
+ case PAT_STANDDOWN:
+ _talkDirection = DOWN;
+ break;
+
+ case PAT_TAKELEFT_UP2:
+ case PAT_TAKELEFT_MID2:
+ case PAT_TAKELEFT_DOWN2:
+ case PAT_GETUPLEFT:
+ case PAT_STANDLEFT:
+ _talkDirection = LEFT;
+ break;
+
+ case PAT_TAKERIGHT_UP2:
+ case PAT_TAKERIGHT_MID2:
+ case PAT_TAKERIGHT_DOWN2:
+ case PAT_GETUPRIGHT:
+ case PAT_STANDRIGHT:
+ _talkDirection = RIGHT;
+ break;
+
+ case PAT_TAKEUP_UP2:
+ case PAT_TAKEUP_MID2:
+ case PAT_TAKEUP_DOWN2:
+ case PAT_STANDUP:
+ _talkDirection = UP;
+ break;
+ }
+
+ // Puts the body in front by default
+ _bBodyFront = true;
+ }
+
+ if (_bShepherdess) {
+ // Talking whilst a shepherdess
+ switch (_talkDirection) {
+ case UP:
+ setPattern(PAT_PAST_TALKUP);
+ break;
+
+ case DOWN:
+ setPattern(PAT_PAST_TALKDOWN);
+ break;
+
+ case LEFT:
+ setPattern(PAT_PAST_TALKLEFT);
+ break;
+
+ case RIGHT:
+ setPattern(PAT_PAST_TALKRIGHT);
+ break;
+ }
+ return false;
+ }
+
+ headStartPat = bodyStartPat = 0;
+ bodyLoopPat = 0;
+
+ switch (nTalkType) {
+ case TALK_NORMAL:
+ _bBodyFront = false;
+ headStartPat = 0;
+ bodyStartPat = 0;
+
+ switch (_talkDirection) {
+ case DOWN:
+ headLoopPat = PAT_TALK_DOWN;
+ bodyLoopPat = BPAT_STANDDOWN;
+ _nBodyOffset.set(4, 53);
+ break;
+
+ case LEFT:
+ headLoopPat = PAT_TALK_LEFT;
+ bodyLoopPat = BPAT_STANDLEFT;
+ _nBodyOffset.set(6, 56);
+ break;
+
+ case RIGHT:
+ headLoopPat = PAT_TALK_RIGHT;
+ bodyLoopPat = BPAT_STANDRIGHT;
+ _nBodyOffset.set(6, 56);
+ break;
+
+ case UP:
+ headLoopPat = PAT_TALK_UP;
+ bodyLoopPat = BPAT_STANDUP;
+ _nBodyOffset.set(6, 53);
+ break;
+ }
+ break;
+
+ case TALK_HIPS:
+ _bBodyFront = false;
+ switch (_talkDirection) {
+ case UP:
+ _nBodyOffset.set(2, 42);
+ headStartPat = PAT_HEAD_UP;
+ bodyStartPat = BPAT_HIPSUP_START;
+ headLoopPat = PAT_TALK_UP;
+ bodyLoopPat = BPAT_HIPSUP_LOOP;
+ break;
+
+ case DOWN:
+ _nBodyOffset.set(2, 48);
+ headStartPat = PAT_HEAD_DOWN;
+ bodyStartPat = BPAT_HIPSDOWN_START;
+ headLoopPat = PAT_TALK_DOWN;
+ bodyLoopPat = BPAT_HIPSDOWN_LOOP;
+ break;
+
+ case LEFT:
+ _nBodyOffset.set(-3, 53);
+ headStartPat = PAT_HEAD_LEFT;
+ bodyStartPat = BPAT_HIPSLEFT_START;
+ headLoopPat = PAT_TALK_LEFT;
+ bodyLoopPat = BPAT_HIPSLEFT_LOOP;
+ break;
+
+ case RIGHT:
+ _nBodyOffset.set(2, 53);
+ headStartPat = PAT_HEAD_RIGHT;
+ bodyStartPat = BPAT_HIPSRIGHT_START;
+ headLoopPat = PAT_TALK_RIGHT;
+ bodyLoopPat = BPAT_HIPSRIGHT_LOOP;
+ break;
+ }
+ break;
+
+ case TALK_SING:
+ _nBodyOffset.set(-10, 25);
+ headStartPat = PAT_HEAD_LEFT;
+ bodyStartPat = BPAT_SINGLEFT_START;
+ headLoopPat = PAT_TALK_LEFT;
+ bodyLoopPat = BPAT_SINGLEFT_LOOP;
+ break;
+
+ case TALK_LAUGH:
+ _bBodyFront = false;
+ switch (_talkDirection) {
+ case UP:
+ case DOWN:
+ case LEFT:
+ _nBodyOffset.set(6, 56);
+ headStartPat = PAT_LAUGHLEFT_START;
+ bodyStartPat = BPAT_STANDLEFT;
+ headLoopPat = PAT_LAUGHLEFT_LOOP;
+ bodyLoopPat = BPAT_LAUGHLEFT;
+ break;
+
+ case RIGHT:
+ _nBodyOffset.set(6, 56);
+ headStartPat = PAT_LAUGHRIGHT_START;
+ bodyStartPat = BPAT_STANDRIGHT;
+ headLoopPat = PAT_LAUGHRIGHT_LOOP;
+ bodyLoopPat = BPAT_LAUGHRIGHT;
+ break;
+ }
+ break;
+
+ case TALK_LAUGH2:
+ _bBodyFront = false;
+ switch (_talkDirection) {
+ case UP:
+ case DOWN:
+ case LEFT:
+ _nBodyOffset.set(6, 56);
+ headStartPat = PAT_LAUGHLEFT_START;
+ bodyStartPat = BPAT_STANDLEFT;
+ headLoopPat = PAT_LAUGHLEFT_LOOP;
+ break;
+
+ case RIGHT:
+ _nBodyOffset.set(6, 56);
+ headStartPat = PAT_LAUGHRIGHT_START;
+ bodyStartPat = BPAT_STANDRIGHT;
+ headLoopPat = PAT_LAUGHRIGHT_LOOP;
+ bodyLoopPat = BPAT_LAUGHRIGHT;
+ break;
+ }
+ break;
+
+ case TALK_INDICATE:
+ switch (_talkDirection) {
+ case UP:
+ case DOWN:
+ case LEFT:
+ _nBodyOffset.set(-4, 40);
+ headLoopPat = PAT_TALK_LEFT;
+ bodyLoopPat = BPAT_INDICATELEFT;
+ break;
+
+ case RIGHT:
+ _nBodyOffset.set(5, 40);
+ headLoopPat = PAT_TALK_RIGHT;
+ bodyLoopPat = BPAT_INDICATERIGHT;
+ break;
+ }
+ break;
+
+ case TALK_SCARED:
+ switch (_talkDirection) {
+ case UP:
+ _nBodyOffset.set(-4, -11);
+ headStartPat = PAT_HEAD_UP;
+ bodyStartPat = BPAT_SCAREDUP_START;
+ headLoopPat = PAT_TALK_UP;
+ bodyLoopPat = BPAT_SCAREDUP_LOOP;
+ break;
+
+ case DOWN:
+ _nBodyOffset.set(-5, 45);
+ headStartPat = PAT_SCAREDDOWN_START;
+ bodyStartPat = BPAT_SCAREDDOWN_START;
+ headLoopPat = PAT_SCAREDDOWN_LOOP;
+ bodyLoopPat = BPAT_SCAREDDOWN_LOOP;
+ break;
+
+ case RIGHT:
+ _nBodyOffset.set(-4, 41);
+ headStartPat = PAT_SCAREDRIGHT_START;
+ bodyStartPat = BPAT_SCAREDRIGHT_START;
+ headLoopPat = PAT_SCAREDRIGHT_LOOP;
+ bodyLoopPat = BPAT_SCAREDRIGHT_LOOP;
+ break;
+
+ case LEFT:
+ _nBodyOffset.set(-10, 41);
+ headStartPat = PAT_SCAREDLEFT_START;
+ bodyStartPat = BPAT_SCAREDLEFT_START;
+ headLoopPat = PAT_SCAREDLEFT_LOOP;
+ bodyLoopPat = BPAT_SCAREDLEFT_LOOP;
+ break;
+ }
+ break;
+
+ case TALK_SCARED2:
+ _bBodyFront = false;
+ switch (_talkDirection) {
+ case UP:
+ bodyStartPat = BPAT_STANDUP;
+ bodyLoopPat = BPAT_STANDUP;
+ _nBodyOffset.set(6, 53);
+
+ headStartPat = PAT_HEAD_UP;
+ headLoopPat = PAT_TALK_UP;
+ break;
+
+ case DOWN:
+ bodyStartPat = BPAT_STANDDOWN;
+ bodyLoopPat = BPAT_STANDDOWN;
+ _nBodyOffset.set(4, 53);
+
+ headStartPat = PAT_SCAREDDOWN_START;
+ headLoopPat = PAT_SCAREDDOWN_LOOP;
+ break;
+
+ case RIGHT:
+ bodyStartPat = BPAT_STANDRIGHT;
+ bodyLoopPat = BPAT_STANDRIGHT;
+ _nBodyOffset.set(6, 56);
+
+ headStartPat = PAT_SCAREDRIGHT_START;
+ headLoopPat = PAT_SCAREDRIGHT_LOOP;
+ break;
+
+ case LEFT:
+ bodyStartPat = BPAT_STANDLEFT;
+ bodyLoopPat = BPAT_STANDLEFT;
+ _nBodyOffset.set(6, 56);
+
+ headStartPat = PAT_SCAREDLEFT_START;
+ headLoopPat = PAT_SCAREDLEFT_LOOP;
+ break;
+ }
+ break;
+
+ case TALK_WITHGLASSES:
+ _nBodyOffset.set(4, 53);
+ headLoopPat = PAT_TALK_DOWN;
+ bodyLoopPat = BPAT_GLASS;
+ break;
+ case TALK_WITHWORM:
+ _nBodyOffset.set(9, 56);
+ headLoopPat = PAT_TALK_RIGHT;
+ bodyLoopPat = BPAT_WORM;
+ break;
+ case TALK_WITHHAMMER:
+ _nBodyOffset.set(6, 56);
+ headLoopPat = PAT_TALK_LEFT;
+ bodyLoopPat = BPAT_HAMMER;
+ break;
+ case TALK_WITHROPE:
+ _nBodyOffset.set(-3, 38);
+ headLoopPat = PAT_TALK_RIGHT;
+ bodyLoopPat = BPAT_ROPE;
+ break;
+ case TALK_WITHSECRETARY:
+ _nBodyOffset.set(-17, 12);
+ headLoopPat = PAT_TALK_RIGHT;
+ bodyLoopPat = BPAT_WITHSECRETARY;
+ break;
+
+ case TALK_WITHRABBIT:
+ switch (_talkDirection) {
+ case LEFT:
+ case UP:
+ _nBodyOffset.set(-21, -5);
+ bodyStartPat = BPAT_WITHRABBITLEFT_START;
+ headLoopPat = PAT_TALK_LEFT;
+ bodyLoopPat = BPAT_WITHRABBITLEFT_LOOP;
+ break;
+
+ case DOWN:
+ case RIGHT:
+ _nBodyOffset.set(-4, -5);
+ bodyStartPat = BPAT_WITHRABBITRIGHT_START;
+ headLoopPat = PAT_TALK_RIGHT;
+ bodyLoopPat = BPAT_WITHRABBITRIGHT_LOOP;
+ break;
+ }
+ break;
+
+ case TALK_WITHRECIPE:
+ switch (_talkDirection) {
+ case LEFT:
+ case UP:
+ _nBodyOffset.set(-61, -7);
+ bodyStartPat = BPAT_WITHRECIPELEFT_START;
+ headLoopPat = PAT_TALK_LEFT;
+ bodyLoopPat = BPAT_WITHRECIPELEFT_LOOP;
+ break;
+
+ case DOWN:
+ case RIGHT:
+ _nBodyOffset.set(-5, -7);
+ bodyStartPat = BPAT_WITHRECIPERIGHT_START;
+ headLoopPat = PAT_TALK_RIGHT;
+ bodyLoopPat = BPAT_WITHRECIPERIGHT_LOOP;
+ break;
+ }
+ break;
+
+ case TALK_WITHCARDS:
+ switch (_talkDirection) {
+ case LEFT:
+ case UP:
+ _nBodyOffset.set(-34, -2);
+ bodyStartPat = BPAT_WITHCARDSLEFT_START;
+ headLoopPat = PAT_TALK_LEFT;
+ bodyLoopPat = BPAT_WITHCARDSLEFT_LOOP;
+ break;
+
+ case DOWN:
+ case RIGHT:
+ _nBodyOffset.set(-4, -2);
+ bodyStartPat = BPAT_WITHCARDSRIGHT_START;
+ headLoopPat = PAT_TALK_RIGHT;
+ bodyLoopPat = BPAT_WITHCARDSRIGHT_LOOP;
+ break;
+ }
+ break;
+
+ case TALK_WITHSNOWMAN:
+ switch (_talkDirection) {
+ case LEFT:
+ case UP:
+ _nBodyOffset.set(-35, 2);
+ bodyStartPat = BPAT_WITHSNOWMANLEFT_START;
+ headLoopPat = PAT_TALK_LEFT;
+ bodyLoopPat = BPAT_WITHSNOWMANLEFT_LOOP;
+ break;
+
+ case DOWN:
+ case RIGHT:
+ _nBodyOffset.set(-14, 2);
+ bodyStartPat = BPAT_WITHSNOWMANRIGHT_START;
+ headLoopPat = PAT_TALK_RIGHT;
+ bodyLoopPat = BPAT_WITHSNOWMANRIGHT_LOOP;
+ break;
+ }
+ break;
+
+ case TALK_WITHSNOWMANSTATIC:
+ case TALK_WITHRECIPESTATIC:
+ case TALK_WITHRABBITSTATIC:
+ case TALK_WITHCARDSSTATIC:
+ case TALK_WITH_NOTEBOOK:
+ case TALK_WITHMEGAPHONESTATIC:
+ switch (_talkDirection) {
+ case LEFT:
+ case UP:
+ headLoopPat = PAT_TALK_LEFT;
+ break;
+
+ case DOWN:
+ case RIGHT:
+ headLoopPat = PAT_TALK_RIGHT;
+ break;
+ }
+ break;
+
+ // The beard is the only case in which the head is animated separately while the body is the standard
+ case TALK_WITHBEARDSTATIC:
+ switch (_talkDirection) {
+ case LEFT:
+ case UP:
+ headLoopPat = PAT_TALKBEARD_LEFT;
+ bodyLoopPat = BPAT_STANDLEFT;
+ _nBodyOffset.set(6, 56);
+ break;
+
+ case DOWN:
+ case RIGHT:
+ headLoopPat = PAT_TALKBEARD_RIGHT;
+ bodyLoopPat = BPAT_STANDRIGHT;
+ _nBodyOffset.set(6, 56);
+ break;
+ }
+ break;
+
+ case TALK_DISGUSTED:
+ switch (_talkDirection) {
+ case LEFT:
+ case UP:
+ _nBodyOffset.set(6, 56);
+ headStartPat = PAT_DISGUSTEDLEFT_START;
+ bodyStartPat = BPAT_STANDLEFT;
+ headLoopPat = PAT_DISGUSTEDLEFT_LOOP;
+ break;
+
+ case DOWN:
+ case RIGHT:
+ _nBodyOffset.set(6, 56);
+ headStartPat = PAT_DISGUSTEDRIGHT_START;
+ bodyStartPat = BPAT_STANDRIGHT;
+ headLoopPat = PAT_DISGUSTEDRIGHT_LOOP;
+ break;
+ }
+ break;
+
+ case TALK_SARCASTIC:
+ switch (_talkDirection) {
+ case LEFT:
+ case UP:
+ _nBodyOffset.set(6, 56);
+ headStartPat = PAT_SARCASTICLEFT_START;
+ bodyStartPat = BPAT_STANDLEFT;
+ headLoopPat = PAT_SARCASTICLEFT_LOOP;
+ break;
+
+ case DOWN:
+ case RIGHT:
+ _nBodyOffset.set(6, 56);
+ headStartPat = PAT_SARCASTICRIGHT_START;
+ bodyStartPat = BPAT_STANDRIGHT;
+ headLoopPat = PAT_SARCASTICRIGHT_LOOP;
+ break;
+ }
+ break;
+
+ case TALK_MACBETH1:
+ _nBodyOffset.set(-33, -1);
+ headLoopPat = PAT_TALK_LEFT;
+ bodyLoopPat = BPAT_MACBETH1;
+ break;
+ case TALK_MACBETH2:
+ _nBodyOffset.set(-33, -1);
+ headLoopPat = PAT_TALK_LEFT;
+ bodyLoopPat = BPAT_MACBETH2;
+ break;
+ case TALK_MACBETH3:
+ _nBodyOffset.set(-33, -1);
+ headLoopPat = PAT_TALK_LEFT;
+ bodyLoopPat = BPAT_MACBETH3;
+ break;
+ case TALK_MACBETH4:
+ _nBodyOffset.set(-33, -1);
+ headLoopPat = PAT_TALK_LEFT;
+ bodyLoopPat = BPAT_MACBETH4;
+ break;
+ case TALK_MACBETH5:
+ _nBodyOffset.set(-33, -1);
+ headLoopPat = PAT_TALK_LEFT;
+ bodyLoopPat = BPAT_MACBETH5;
+ break;
+ case TALK_MACBETH6:
+ _nBodyOffset.set(-33, -1);
+ headLoopPat = PAT_TALK_LEFT;
+ bodyLoopPat = BPAT_MACBETH6;
+ break;
+ case TALK_MACBETH7:
+ _nBodyOffset.set(-33, -1);
+ headLoopPat = PAT_TALK_LEFT;
+ bodyLoopPat = BPAT_MACBETH7;
+ break;
+ case TALK_MACBETH8:
+ _nBodyOffset.set(-33, -1);
+ headLoopPat = PAT_TALK_LEFT;
+ bodyLoopPat = BPAT_MACBETH8;
+ break;
+ case TALK_MACBETH9:
+ _nBodyOffset.set(-33, -1);
+ headLoopPat = PAT_TALK_LEFT;
+ bodyLoopPat = BPAT_MACBETH9;
+ break;
+
+ case TALK_SCAREDSTATIC:
+ _bBodyFront = false;
+ switch (_talkDirection) {
+ case DOWN:
+ bodyStartPat = BPAT_STANDDOWN;
+ bodyLoopPat = BPAT_STANDDOWN;
+ _nBodyOffset.set(4, 53);
+
+ headStartPat = PAT_SCAREDDOWN_STAND;
+ headLoopPat = PAT_SCAREDDOWN_LOOP;
+ break;
+
+ case RIGHT:
+ bodyStartPat = BPAT_STANDRIGHT;
+ bodyLoopPat = BPAT_STANDRIGHT;
+ _nBodyOffset.set(6, 56);
+
+ headStartPat = PAT_SCAREDRIGHT_STAND;
+ headLoopPat = PAT_SCAREDRIGHT_LOOP;
+ break;
+
+ case LEFT:
+ bodyStartPat = BPAT_STANDLEFT;
+ bodyLoopPat = BPAT_STANDLEFT;
+ _nBodyOffset.set(6, 56);
+
+ headStartPat = PAT_SCAREDLEFT_STAND;
+ headLoopPat = PAT_SCAREDLEFT_LOOP;
+ break;
+
+ default:
+ break;
+ }
+ break;
+ }
+
+ return true;
+}
+
+void RMTony::startTalk(CORO_PARAM, CharacterTalkType nTalkType) {
+ CORO_BEGIN_CONTEXT;
+ int headStartPat, bodyStartPat;
+ int headLoopPat, bodyLoopPat;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ _ctx->headStartPat = _ctx->bodyStartPat = 0;
+ _ctx->headLoopPat = _ctx->bodyLoopPat = 0;
+
+ if (!startTalkCalculate(nTalkType, _ctx->headStartPat, _ctx->bodyStartPat,
+ _ctx->headLoopPat, _ctx->bodyLoopPat))
+ return;
+
+ // Perform the set pattern
+ if (_ctx->headStartPat != 0 || _ctx->bodyStartPat != 0) {
+ setPattern(_ctx->headStartPat);
+ _body.setPattern(_ctx->bodyStartPat);
+
+ if (_ctx->bodyStartPat != 0)
+ CORO_INVOKE_0(_body.waitForEndPattern);
+ if (_ctx->headStartPat != 0)
+ CORO_INVOKE_0(waitForEndPattern);
+ }
+
+ setPattern(_ctx->headLoopPat);
+ if (_ctx->bodyLoopPat)
+ _body.setPattern(_ctx->bodyLoopPat);
+
+ CORO_END_CODE;
+}
+
+
+bool RMTony::endTalkCalculate(int &headStandPat, int &headEndPat, int &bodyEndPat, int &finalPat, bool &bStatic) {
+ bodyEndPat = 0;
+ headEndPat = 0;
+
+ switch (_talkDirection) {
+ case UP:
+ finalPat = PAT_STANDUP;
+ headStandPat = PAT_HEAD_UP;
+ break;
+
+ case DOWN:
+ finalPat = PAT_STANDDOWN;
+ headStandPat = PAT_HEAD_DOWN;
+ break;
+
+ case LEFT:
+ finalPat = PAT_STANDLEFT;
+ headStandPat = PAT_HEAD_LEFT;
+ break;
+
+ case RIGHT:
+ finalPat = PAT_STANDRIGHT;
+ headStandPat = PAT_HEAD_RIGHT;
+ break;
+ }
+
+ if (_bShepherdess) {
+ setPattern(finalPat);
+ _bIsTalking = false;
+ return false;
+ }
+
+ bStatic = false;
+ switch (_nTalkType) {
+ case TALK_NORMAL:
+ bodyEndPat = 0;
+ break;
+
+ case TALK_HIPS:
+ switch (_talkDirection) {
+ case UP:
+ bodyEndPat = BPAT_HIPSUP_END;
+ break;
+
+ case DOWN:
+ bodyEndPat = BPAT_HIPSDOWN_END;
+ break;
+
+ case LEFT:
+ bodyEndPat = BPAT_HIPSLEFT_END;
+ break;
+
+ case RIGHT:
+ bodyEndPat = BPAT_HIPSRIGHT_END;
+ break;
+ }
+ break;
+
+ case TALK_SING:
+ bodyEndPat = BPAT_SINGLEFT_END;
+ break;
+
+ case TALK_LAUGH:
+ case TALK_LAUGH2:
+ if (_talkDirection == LEFT)
+ headEndPat = PAT_LAUGHLEFT_END;
+ else if (_talkDirection == RIGHT)
+ headEndPat = PAT_LAUGHRIGHT_END;
+
+ bodyEndPat = 0;
+ break;
+
+ case TALK_DISGUSTED:
+ switch (_talkDirection) {
+ case UP:
+ case LEFT:
+ headEndPat = PAT_DISGUSTEDLEFT_END;
+ break;
+
+ case DOWN:
+ case RIGHT:
+ headEndPat = PAT_DISGUSTEDRIGHT_END;
+ break;
+ }
+
+ bodyEndPat = 0;
+ break;
+
+ case TALK_SARCASTIC:
+ switch (_talkDirection) {
+ case UP:
+ case LEFT:
+ headEndPat = PAT_SARCASTICLEFT_END;
+ break;
+
+ case DOWN:
+ case RIGHT:
+ headEndPat = PAT_SARCASTICRIGHT_END;
+ break;
+ }
+
+ bodyEndPat = 0;
+ break;
+
+ case TALK_INDICATE:
+ break;
+
+ case TALK_SCARED:
+ switch (_talkDirection) {
+ case UP:
+ bodyEndPat = BPAT_SCAREDUP_END;
+ break;
+
+ case DOWN:
+ headEndPat = PAT_SCAREDDOWN_END;
+ bodyEndPat = BPAT_SCAREDDOWN_END;
+ break;
+
+ case RIGHT:
+ headEndPat = PAT_SCAREDRIGHT_END;
+ bodyEndPat = BPAT_SCAREDRIGHT_END;
+ break;
+
+ case LEFT:
+ headEndPat = PAT_SCAREDLEFT_END;
+ bodyEndPat = BPAT_SCAREDLEFT_END;
+ break;
+ }
+ break;
+
+ case TALK_SCARED2:
+ switch (_talkDirection) {
+ case UP:
+ bodyEndPat = 0;
+ break;
+
+ case DOWN:
+ headEndPat = PAT_SCAREDDOWN_END;
+ bodyEndPat = 0;
+ break;
+
+ case RIGHT:
+ headEndPat = PAT_SCAREDRIGHT_END;
+ bodyEndPat = 0;
+ break;
+
+ case LEFT:
+ headEndPat = PAT_SCAREDLEFT_END;
+ bodyEndPat = 0;
+ break;
+ }
+ break;
+
+ case TALK_WITHRABBIT:
+ switch (_talkDirection) {
+ case UP:
+ case LEFT:
+ finalPat = PAT_STANDLEFT;
+ bodyEndPat = BPAT_WITHRABBITLEFT_END;
+ break;
+
+ case RIGHT:
+ case DOWN:
+ finalPat = PAT_STANDRIGHT;
+ bodyEndPat = BPAT_WITHRABBITRIGHT_END;
+ break;
+ }
+ break;
+
+ case TALK_WITHRECIPE:
+ switch (_talkDirection) {
+ case UP:
+ case LEFT:
+ finalPat = PAT_STANDLEFT;
+ bodyEndPat = BPAT_WITHRECIPELEFT_END;
+ break;
+
+ case RIGHT:
+ case DOWN:
+ finalPat = PAT_STANDRIGHT;
+ bodyEndPat = BPAT_WITHRECIPERIGHT_END;
+ break;
+ }
+ break;
+
+ case TALK_WITHCARDS:
+ switch (_talkDirection) {
+ case UP:
+ case LEFT:
+ finalPat = PAT_STANDLEFT;
+ bodyEndPat = BPAT_WITHCARDSLEFT_END;
+ break;
+
+ case RIGHT:
+ case DOWN:
+ finalPat = PAT_STANDRIGHT;
+ bodyEndPat = BPAT_WITHCARDSRIGHT_END;
+ break;
+ }
+ break;
+
+ case TALK_WITHSNOWMAN:
+ switch (_talkDirection) {
+ case UP:
+ case LEFT:
+ finalPat = PAT_STANDLEFT;
+ bodyEndPat = BPAT_WITHSNOWMANLEFT_END;
+ break;
+
+ case RIGHT:
+ case DOWN:
+ finalPat = PAT_STANDRIGHT;
+ bodyEndPat = BPAT_WITHSNOWMANRIGHT_END;
+ break;
+ }
+ break;
+
+ case TALK_WITHWORM:
+ finalPat = PAT_WITHWORM;
+ break;
+ case TALK_WITHROPE:
+ finalPat = PAT_WITHROPE;
+ break;
+ case TALK_WITHSECRETARY:
+ finalPat = PAT_WITHSECRETARY;
+ break;
+ case TALK_WITHHAMMER:
+ finalPat = PAT_WITHHAMMER;
+ break;
+ case TALK_WITHGLASSES:
+ finalPat = PAT_WITHGLASSES;
+ break;
+
+ case TALK_MACBETH1:
+ case TALK_MACBETH2:
+ case TALK_MACBETH3:
+ case TALK_MACBETH4:
+ case TALK_MACBETH5:
+ case TALK_MACBETH6:
+ case TALK_MACBETH7:
+ case TALK_MACBETH8:
+ finalPat = 0;
+ break;
+
+ case TALK_SCAREDSTATIC:
+ switch (_talkDirection) {
+ case DOWN:
+ headStandPat = PAT_SCAREDDOWN_STAND;
+ bodyEndPat = 0;
+ break;
+
+ case RIGHT:
+ headStandPat = PAT_SCAREDRIGHT_STAND;
+ bodyEndPat = 0;
+ break;
+
+ case LEFT:
+ headStandPat = PAT_SCAREDLEFT_STAND;
+ bodyEndPat = 0;
+ break;
+
+
+ default:
+ break;
+ }
+ break;
+
+ default:
+ break;
+ }
+
+ return true;
+}
+
+void RMTony::endTalk(CORO_PARAM) {
+ CORO_BEGIN_CONTEXT;
+ int headStandPat, headEndPat;
+ int bodyEndPat, finalPat;
+ bool bStatic;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ _ctx->headStandPat = _ctx->headEndPat = 0;
+ _ctx->bodyEndPat = _ctx->finalPat = 0;
+ _ctx->bStatic = false;
+
+ _ctx->bodyEndPat = 0;
+ _ctx->headEndPat = 0;
+
+ if (!endTalkCalculate(_ctx->headStandPat, _ctx->headEndPat, _ctx->bodyEndPat, _ctx->finalPat, _ctx->bStatic))
+ return;
+
+ // Handles the end of an animated and static, leaving everything unchanged
+ if (_bIsStaticTalk) {
+ if (_nTalkType == TALK_WITHBEARDSTATIC) {
+ setPattern(0);
+ if (_talkDirection == UP || _talkDirection == LEFT) {
+ _body.setPattern(BPAT_WITHBEARDLEFT_STATIC);
+ _nBodyOffset.set(-41, -14);
+ } else if (_talkDirection == DOWN || _talkDirection == RIGHT) {
+ _body.setPattern(BPAT_WITHBEARDRIGHT_STATIC);
+ _nBodyOffset.set(-26, -14);
+ }
+ } else {
+ setPattern(_ctx->headStandPat);
+
+ CORO_INVOKE_0(_body.waitForEndPattern);
+ }
+
+ _bIsTalking = false;
+ return;
+ }
+
+ // Set the pattern
+ if (_ctx->headEndPat != 0 && _ctx->bodyEndPat != 0) {
+ setPattern(_ctx->headEndPat);
+
+ CORO_INVOKE_0(_body.waitForEndPattern);
+
+ _body.setPattern(_ctx->bodyEndPat);
+
+ CORO_INVOKE_0(waitForEndPattern);
+ CORO_INVOKE_0(_body.waitForEndPattern);
+ } else if (_ctx->bodyEndPat != 0) {
+ setPattern(_ctx->headStandPat);
+
+ CORO_INVOKE_0(_body.waitForEndPattern);
+
+ _body.setPattern(_ctx->bodyEndPat);
+
+ CORO_INVOKE_0(_body.waitForEndPattern);
+ } else if (_ctx->headEndPat != 0) {
+ CORO_INVOKE_0(_body.waitForEndPattern);
+
+ setPattern(_ctx->headEndPat);
+
+ CORO_INVOKE_0(waitForEndPattern);
+ } else {
+ CORO_INVOKE_0(_body.waitForEndPattern);
+ }
+
+ if (_ctx->finalPat != 0) {
+ _body.setPattern(0);
+ setPattern(_ctx->finalPat);
+ }
+
+ _bIsTalking = false;
+
+ CORO_END_CODE;
+}
+
+void RMTony::startStaticCalculate(CharacterTalkType nTalk, int &headPat, int &headLoopPat,
+ int &bodyStartPat, int &bodyLoopPat) {
+ int nPat = getCurPattern();
+
+ headLoopPat = -1;
+
+ switch (nPat) {
+ case PAT_STANDDOWN:
+ _talkDirection = DOWN;
+ headPat = PAT_HEAD_RIGHT;
+ break;
+
+ case PAT_TAKELEFT_UP2:
+ case PAT_TAKELEFT_MID2:
+ case PAT_TAKELEFT_DOWN2:
+ case PAT_GETUPLEFT:
+ case PAT_STANDLEFT:
+ _talkDirection = LEFT;
+ headPat = PAT_HEAD_LEFT;
+ break;
+
+ case PAT_TAKERIGHT_UP2:
+ case PAT_TAKERIGHT_MID2:
+ case PAT_TAKERIGHT_DOWN2:
+ case PAT_GETUPRIGHT:
+ case PAT_STANDRIGHT:
+ _talkDirection = RIGHT;
+ headPat = PAT_HEAD_RIGHT;
+ break;
+
+ case PAT_TAKEUP_UP2:
+ case PAT_TAKEUP_MID2:
+ case PAT_TAKEUP_DOWN2:
+ case PAT_STANDUP:
+ _talkDirection = UP;
+ headPat = PAT_HEAD_LEFT;
+ break;
+ }
+
+ _bBodyFront = true;
+
+ switch (nTalk) {
+ case TALK_WITHRABBITSTATIC:
+ switch (_talkDirection) {
+ case UP:
+ case LEFT:
+ _nBodyOffset.set(-21, -5);
+ bodyStartPat = BPAT_WITHRABBITLEFT_START;
+ bodyLoopPat = BPAT_WITHRABBITLEFT_LOOP;
+ break;
+
+ case DOWN:
+ case RIGHT:
+ _nBodyOffset.set(-4, -5);
+ bodyStartPat = BPAT_WITHRABBITRIGHT_START;
+ bodyLoopPat = BPAT_WITHRABBITRIGHT_LOOP;
+ break;
+ }
+ break;
+
+ case TALK_WITHCARDSSTATIC:
+ switch (_talkDirection) {
+ case UP:
+ case LEFT:
+ _nBodyOffset.set(-34, -2);
+ bodyStartPat = BPAT_WITHCARDSLEFT_START;
+ bodyLoopPat = BPAT_WITHCARDSLEFT_LOOP;
+ break;
+
+ case DOWN:
+ case RIGHT:
+ _nBodyOffset.set(-4, -2);
+ bodyStartPat = BPAT_WITHCARDSRIGHT_START;
+ bodyLoopPat = BPAT_WITHCARDSRIGHT_LOOP;
+ break;
+ }
+ break;
+
+ case TALK_WITHRECIPESTATIC:
+ switch (_talkDirection) {
+ case UP:
+ case LEFT:
+ _nBodyOffset.set(-61, -7);
+ bodyStartPat = BPAT_WITHRECIPELEFT_START;
+ bodyLoopPat = BPAT_WITHRECIPELEFT_LOOP;
+ break;
+
+ case DOWN:
+ case RIGHT:
+ _nBodyOffset.set(-5, -7);
+ bodyStartPat = BPAT_WITHRECIPERIGHT_START;
+ bodyLoopPat = BPAT_WITHRECIPERIGHT_LOOP;
+ break;
+ }
+ break;
+
+ case TALK_WITHSNOWMANSTATIC:
+ switch (_talkDirection) {
+ case UP:
+ case LEFT:
+ _nBodyOffset.set(-35, 2);
+ bodyStartPat = BPAT_WITHSNOWMANLEFT_START;
+ bodyLoopPat = BPAT_WITHSNOWMANLEFT_LOOP;
+ break;
+
+ case DOWN:
+ case RIGHT:
+ _nBodyOffset.set(-14, 2);
+ bodyStartPat = BPAT_WITHSNOWMANRIGHT_START;
+ bodyLoopPat = BPAT_WITHSNOWMANRIGHT_LOOP;
+ break;
+ }
+ break;
+
+ case TALK_WITH_NOTEBOOK:
+ switch (_talkDirection) {
+ case UP:
+ case LEFT:
+ _nBodyOffset.set(-16, -9);
+ bodyStartPat = BPAT_WITHNOTEBOOKLEFT_START;
+ bodyLoopPat = BPAT_WITHNOTEBOOKLEFT_LOOP;
+ break;
+
+ case DOWN:
+ case RIGHT:
+ _nBodyOffset.set(-6, -9);
+ bodyStartPat = BPAT_WITHNOTEBOOKRIGHT_START;
+ bodyLoopPat = BPAT_WITHNOTEBOOKRIGHT_LOOP;
+ break;
+ }
+ break;
+
+ case TALK_WITHMEGAPHONESTATIC:
+ switch (_talkDirection) {
+ case UP:
+ case LEFT:
+ _nBodyOffset.set(-41, -8);
+ bodyStartPat = BPAT_WITHMEGAPHONELEFT_START;
+ bodyLoopPat = BPAT_WITHMEGAPHONELEFT_LOOP;
+ break;
+
+ case DOWN:
+ case RIGHT:
+ _nBodyOffset.set(-14, -8);
+ bodyStartPat = BPAT_WITHMEGAPHONERIGHT_START;
+ bodyLoopPat = BPAT_WITHMEGAPHONERIGHT_LOOP;
+ break;
+ }
+ break;
+
+ case TALK_WITHBEARDSTATIC:
+ switch (_talkDirection) {
+ case UP:
+ case LEFT:
+ _nBodyOffset.set(-41, -14);
+ bodyStartPat = BPAT_WITHBEARDLEFT_START;
+ bodyLoopPat = BPAT_STANDLEFT;
+ headLoopPat = PAT_TALKBEARD_LEFT;
+ headPat = 0;
+ break;
+
+ case DOWN:
+ case RIGHT:
+ _nBodyOffset.set(-26, -14);
+ bodyStartPat = BPAT_WITHBEARDRIGHT_START;
+ bodyLoopPat = BPAT_STANDRIGHT;
+ headLoopPat = PAT_TALKBEARD_RIGHT;
+ headPat = 0;
+ break;
+ }
+ break;
+
+ case TALK_SCAREDSTATIC:
+ switch (_talkDirection) {
+ case DOWN:
+ headPat = PAT_SCAREDDOWN_START;
+ bodyLoopPat = BPAT_STANDDOWN;
+ bodyStartPat = BPAT_STANDDOWN;
+ headLoopPat = PAT_SCAREDDOWN_STAND;
+ _nBodyOffset.set(4, 53);
+ break;
+
+ case LEFT:
+ headPat = PAT_SCAREDLEFT_START;
+ bodyLoopPat = BPAT_STANDLEFT;
+ bodyStartPat = BPAT_STANDLEFT;
+ headLoopPat = PAT_SCAREDLEFT_STAND;
+ _nBodyOffset.set(6, 56);
+ break;
+
+ case RIGHT:
+ headPat = PAT_SCAREDRIGHT_START;
+ bodyLoopPat = BPAT_STANDRIGHT;
+ bodyStartPat = BPAT_STANDRIGHT;
+ headLoopPat = PAT_SCAREDRIGHT_STAND;
+ _nBodyOffset.set(6, 56);
+ break;
+
+ default:
+ break;
+ }
+
+ default:
+ break;
+ }
+}
+
+void RMTony::startStatic(CORO_PARAM, CharacterTalkType nTalk) {
+ CORO_BEGIN_CONTEXT;
+ int headPat, headLoopPat;
+ int bodyStartPat, bodyLoopPat;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ _ctx->headPat = _ctx->headLoopPat = 0;
+ _ctx->bodyStartPat = _ctx->bodyLoopPat = 0;
+
+ startStaticCalculate(nTalk, _ctx->headPat, _ctx->headLoopPat,
+ _ctx->bodyStartPat, _ctx->bodyLoopPat);
+
+ // e vai con i pattern
+ _bIsStaticTalk = true;
+
+ setPattern(_ctx->headPat);
+ _body.setPattern(_ctx->bodyStartPat);
+
+ CORO_INVOKE_0(_body.waitForEndPattern);
+ CORO_INVOKE_0(waitForEndPattern);
+
+ if (_ctx->headLoopPat != -1)
+ setPattern(_ctx->headLoopPat);
+ _body.setPattern(_ctx->bodyLoopPat);
+
+ CORO_END_CODE;
+}
+
+void RMTony::endStaticCalculate(CharacterTalkType nTalk, int &bodyEndPat, int &finalPat, int &headEndPat) {
+ switch (_talkDirection) {
+ case UP:
+ case LEFT:
+ finalPat = PAT_STANDLEFT;
+ break;
+
+ case RIGHT:
+ case DOWN:
+ finalPat = PAT_STANDRIGHT;
+ break;
+ }
+
+ switch (nTalk) {
+ case TALK_WITHSNOWMANSTATIC:
+ switch (_talkDirection) {
+ case UP:
+ case LEFT:
+ bodyEndPat = BPAT_WITHSNOWMANLEFT_END;
+ break;
+
+ case DOWN:
+ case RIGHT:
+ bodyEndPat = BPAT_WITHSNOWMANRIGHT_END;
+ break;
+ }
+ break;
+
+ case TALK_WITHRECIPESTATIC:
+ switch (_talkDirection) {
+ case UP:
+ case LEFT:
+ bodyEndPat = BPAT_WITHRECIPELEFT_END;
+ break;
+
+ case DOWN:
+ case RIGHT:
+ bodyEndPat = BPAT_WITHRECIPERIGHT_END;
+ break;
+ }
+ break;
+
+ case TALK_WITHRABBITSTATIC:
+ switch (_talkDirection) {
+ case UP:
+ case LEFT:
+ bodyEndPat = BPAT_WITHRABBITLEFT_END;
+ break;
+
+ case DOWN:
+ case RIGHT:
+ bodyEndPat = BPAT_WITHRABBITRIGHT_END;
+ break;
+ }
+ break;
+
+ case TALK_WITHCARDSSTATIC:
+ switch (_talkDirection) {
+ case UP:
+ case LEFT:
+ bodyEndPat = BPAT_WITHCARDSLEFT_END;
+ break;
+
+ case DOWN:
+ case RIGHT:
+ bodyEndPat = BPAT_WITHCARDSRIGHT_END;
+ break;
+ }
+ break;
+
+ case TALK_WITH_NOTEBOOK:
+ switch (_talkDirection) {
+ case UP:
+ case LEFT:
+ bodyEndPat = BPAT_WITHNOTEBOOKLEFT_END;
+ break;
+
+ case DOWN:
+ case RIGHT:
+ bodyEndPat = BPAT_WITHNOTEBOOKRIGHT_END;
+ break;
+ }
+ break;
+
+ case TALK_WITHMEGAPHONESTATIC:
+ switch (_talkDirection) {
+ case UP:
+ case LEFT:
+ bodyEndPat = BPAT_WITHMEGAPHONELEFT_END;
+ break;
+
+ case DOWN:
+ case RIGHT:
+ bodyEndPat = BPAT_WITHMEGAPHONERIGHT_END;
+ break;
+ }
+ break;
+
+ case TALK_WITHBEARDSTATIC:
+ switch (_talkDirection) {
+ case UP:
+ case LEFT:
+ bodyEndPat = BPAT_WITHBEARDLEFT_END;
+ break;
+
+ case DOWN:
+ case RIGHT:
+ bodyEndPat = BPAT_WITHBEARDRIGHT_END;
+ break;
+ }
+ break;
+
+ case TALK_SCAREDSTATIC:
+ switch (_talkDirection) {
+ case LEFT:
+ headEndPat = PAT_SCAREDLEFT_END;
+ break;
+
+ case DOWN:
+ headEndPat = PAT_SCAREDDOWN_END;
+ break;
+
+ case RIGHT:
+ headEndPat = PAT_SCAREDRIGHT_END;
+ break;
+
+ default:
+ break;
+ }
+ break;
+
+ default:
+ break;
+ }
+}
+
+void RMTony::endStatic(CORO_PARAM, CharacterTalkType nTalk) {
+ CORO_BEGIN_CONTEXT;
+ int bodyEndPat;
+ int finalPat;
+ int headEndPat;
+ CORO_END_CONTEXT(_ctx);
+
+ CORO_BEGIN_CODE(_ctx);
+
+ _ctx->bodyEndPat = 0;
+ _ctx->finalPat = 0;
+ _ctx->headEndPat = 0;
+
+ endStaticCalculate(nTalk, _ctx->bodyEndPat, _ctx->finalPat, _ctx->headEndPat);
+
+ if (_ctx->headEndPat != 0) {
+ setPattern(_ctx->headEndPat);
+
+ CORO_INVOKE_0(waitForEndPattern);
+ } else {
+ // Play please
+ _body.setPattern(_ctx->bodyEndPat);
+
+ CORO_INVOKE_0(_body.waitForEndPattern);
+ }
+
+ setPattern(_ctx->finalPat);
+ _body.setPattern(0);
+
+ _bIsStaticTalk = false;
+
+ CORO_END_CODE;
+}
+
+/**
+ * Waits until the end of a pattern
+ */
+void RMTony::waitForEndPattern(CORO_PARAM, uint32 hCustomSkip) {
+ RMCharacter::waitForEndPattern(coroParam, hCustomSkip);
+}
+
+/**
+ * Check if currently in an action
+ */
+bool RMTony::inAction() {
+ return (_bActionPending && _action != 0) | _bAction;
+}
+
+/**
+ * Check if there needs to be an update for scrolling movement
+ */
+bool RMTony::mustUpdateScrolling() {
+ return ((!inAction()) || (isMoving()));
+}
+
+/**
+ * Returns Tony's position
+ */
+RMPoint RMTony::position() {
+ return _pos;
+}
+
+/**
+ * Set the scrolling position
+ */
+void RMTony::setScrollPosition(const RMPoint &pt) {
+ RMCharacter::setScrollPosition(pt);
+}
+
+/**
+ * Tony disguises himself!
+ */
+void RMTony::setShepherdess(bool bIsPast) {
+ _bShepherdess = bIsPast;
+}
+
+int RMTony::getShepherdess() {
+ return _bShepherdess;
+}
+
+void RMTony::playSfx(int nSfx) {
+ RMItem::playSfx(nSfx);
+}
+
+} // End of namespace Tony
diff --git a/engines/tony/tonychar.h b/engines/tony/tonychar.h
new file mode 100644
index 0000000000..d9f18f61ec
--- /dev/null
+++ b/engines/tony/tonychar.h
@@ -0,0 +1,482 @@
+/* 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.
+ *
+ */
+
+/*
+ * This code is based on original Tony Tough source code
+ *
+ * Copyright (c) 1997-2003 Nayma Software
+ */
+
+#ifndef TONY_TONYCHAR_H
+#define TONY_TONYCHAR_H
+
+#include "common/coroutines.h"
+#include "tony/loc.h"
+
+namespace Tony {
+
+class RMTony : public RMCharacter {
+private:
+ enum CharacterDirection {
+ UP, DOWN, LEFT, RIGHT
+ };
+
+public:
+ enum CharacterTalkType {
+ TALK_NORMAL,
+ TALK_HIPS,
+ TALK_SING,
+ TALK_LAUGH,
+ TALK_INDICATE,
+ TALK_SCARED,
+ TALK_SCARED2,
+ TALK_WITHGLASSES,
+ TALK_WITHHAMMER,
+ TALK_WITHWORM,
+ TALK_WITHROPE,
+ TALK_WITHRABBIT,
+ TALK_WITHRECIPE,
+ TALK_WITHCARDS,
+ TALK_WITHSNOWMAN,
+ TALK_WITHSNOWMANSTATIC,
+ TALK_WITHRABBITSTATIC,
+ TALK_WITHRECIPESTATIC,
+ TALK_WITHCARDSSTATIC,
+ TALK_WITH_NOTEBOOK,
+ TALK_WITHMEGAPHONESTATIC,
+ TALK_WITHBEARDSTATIC,
+ TALK_LAUGH2,
+ TALK_DISGUSTED,
+ TALK_SARCASTIC,
+ TALK_MACBETH1,
+ TALK_MACBETH2,
+ TALK_MACBETH3,
+ TALK_MACBETH4,
+ TALK_MACBETH5,
+ TALK_MACBETH6,
+ TALK_MACBETH7,
+ TALK_MACBETH8,
+ TALK_MACBETH9,
+ TALK_SCAREDSTATIC,
+ TALK_WITHSECRETARY
+ };
+
+private:
+ bool _bShow;
+ bool _bShowShadow;
+ bool _bBodyFront;
+ // Useless variable?
+ // RMGfxSourceBuffer8AB _shadow;
+ bool _bActionPending;
+ RMItem *_actionItem;
+ int _action;
+ int _actionParm;
+ static bool _bAction;
+
+ bool _bShepherdess;
+
+ bool _bIsStaticTalk;
+ bool _bIsTalking;
+ int _nPatB4Talking;
+ CharacterTalkType _nTalkType;
+ CharacterDirection _talkDirection;
+ RMPoint _nBodyOffset;
+
+ int _nTimeLastStep;
+
+ RMItem _body;
+ uint32 _hActionThread;
+
+protected:
+ /**
+ * Overload of the allocation allocation of sprites
+ */
+ virtual RMGfxSourceBuffer *newItemSpriteBuffer(int dimx, int dimy, bool bPreRLE);
+
+ /**
+ * Watch thread which waits for the end of an action
+ */
+ static void waitEndOfAction(CORO_PARAM, const void *param);
+
+public:
+ enum CharacterPatterns {
+ PAT_TAKEUP_UP1 = 9,
+ PAT_TAKEUP_UP2,
+ PAT_TAKEUP_MID1,
+ PAT_TAKEUP_MID2,
+ PAT_TAKEUP_DOWN1,
+ PAT_TAKEUP_DOWN2,
+
+ PAT_TAKELEFT_UP1,
+ PAT_TAKELEFT_UP2,
+ PAT_TAKELEFT_MID1,
+ PAT_TAKELEFT_MID2,
+ PAT_TAKELEFT_DOWN1,
+ PAT_TAKELEFT_DOWN2,
+
+ PAT_TAKERIGHT_UP1,
+ PAT_TAKERIGHT_UP2,
+ PAT_TAKERIGHT_MID1,
+ PAT_TAKERIGHT_MID2,
+ PAT_TAKERIGHT_DOWN1,
+ PAT_TAKERIGHT_DOWN2,
+
+ PAT_GETUPLEFT,
+ PAT_ONTHEFLOORLEFT,
+ PAT_GETUPRIGHT,
+ PAT_ONTHEFLOORRIGHT,
+
+ // Sheperdess!
+ PAT_PAST_WALKUP,
+ PAT_PAST_WALKDOWN,
+ PAT_PAST_WALKLEFT,
+ PAT_PAST_WALKRIGHT,
+
+ PAT_PAST_STANDUP,
+ PAT_PAST_STANDDOWN,
+ PAT_PAST_STANDLEFT,
+ PAT_PAST_STANDRIGHT,
+
+ // Speech
+ PAT_TALK_UP,
+ PAT_TALK_DOWN,
+ PAT_TALK_LEFT,
+ PAT_TALK_RIGHT,
+
+ // Static head
+ PAT_HEAD_UP,
+ PAT_HEAD_DOWN,
+ PAT_HEAD_LEFT,
+ PAT_HEAD_RIGHT,
+
+ // Laugh
+ PAT_LAUGHLEFT_START,
+ PAT_LAUGHLEFT_LOOP,
+ PAT_LAUGHLEFT_END,
+ PAT_LAUGHRIGHT_START,
+ PAT_LAUGHRIGHT_LOOP,
+ PAT_LAUGHRIGHT_END,
+
+ // Speaking as a shepherdess
+ PAT_PAST_TALKUP,
+ PAT_PAST_TALKDOWN,
+ PAT_PAST_TALKLEFT,
+ PAT_PAST_TALKRIGHT,
+
+ // Fear
+ PAT_SCAREDLEFT_START,
+ PAT_SCAREDLEFT_LOOP,
+ PAT_SCAREDLEFT_END,
+ PAT_SCAREDRIGHT_START,
+ PAT_SCAREDRIGHT_LOOP,
+ PAT_SCAREDRIGHT_END,
+ PAT_SCAREDDOWN_START,
+ PAT_SCAREDDOWN_LOOP,
+ PAT_SCAREDDOWN_END,
+
+ // With objects: full body
+ PAT_WITHGLASSES,
+ PAT_WITHROPE,
+ PAT_WITHWORM,
+ PAT_WITHHAMMER,
+
+ // Sound the whistle
+ PAT_WHISTLERIGHT,
+
+ // Head with beard
+ PAT_TALKBEARD_LEFT,
+ PAT_TALKBEARD_RIGHT,
+
+ // Sniff
+ PAT_SNIFF_LEFT,
+ PAT_SNIFF_RIGHT,
+
+ // Disgusted
+ PAT_DISGUSTEDLEFT_START,
+ PAT_DISGUSTEDLEFT_LOOP,
+ PAT_DISGUSTEDLEFT_END,
+ PAT_DISGUSTEDRIGHT_START,
+ PAT_DISGUSTEDRIGHT_LOOP,
+ PAT_DISGUSTEDRIGHT_END,
+ PAT_SARCASTICLEFT_START,
+ PAT_SARCASTICLEFT_LOOP,
+ PAT_SARCASTICLEFT_END,
+ PAT_SARCASTICRIGHT_START,
+ PAT_SARCASTICRIGHT_LOOP,
+ PAT_SARCASTICRIGHT_END,
+
+ // Stand scared
+ PAT_SCAREDLEFT_STAND,
+ PAT_SCAREDRIGHT_STAND,
+ PAT_SCAREDDOWN_STAND,
+
+ PAT_PUTLEFT_UP1,
+ PAT_PUTLEFT_UP2,
+ PAT_PUTRIGHT_UP1,
+ PAT_PUTRIGHT_UP2,
+ PAT_PUTLEFT_MID1,
+ PAT_PUTLEFT_MID2,
+ PAT_PUTRIGHT_MID1,
+ PAT_PUTRIGHT_MID2,
+ PAT_PUTLEFT_DOWN1,
+ PAT_PUTLEFT_DOWN2,
+ PAT_PUTRIGHT_DOWN1,
+ PAT_PUTRIGHT_DOWN2,
+ PAT_PUTUP_UP1,
+ PAT_PUTUP_UP2,
+ PAT_PUTUP_MID1,
+ PAT_PUTUP_MID2,
+ PAT_PUTUP_DOWN1,
+ PAT_PUTUP_DOWN2,
+
+ PAT_WITHSECRETARY
+ };
+
+ enum CharacterBodyPatterns {
+ BPAT_STANDUP = 1,
+ BPAT_STANDDOWN,
+ BPAT_STANDLEFT,
+ BPAT_STANDRIGHT,
+
+ BPAT_HAMMER,
+ BPAT_SNOWMAN,
+ BPAT_WORM,
+ BPAT_GLASS,
+
+ BPAT_SINGLEFT_START,
+ BPAT_SINGLEFT_LOOP,
+ BPAT_SINGLEFT_END,
+
+ BPAT_HIPSLEFT_START,
+ BPAT_HIPSLEFT_LOOP,
+ BPAT_HIPSLEFT_END,
+ BPAT_HIPSRIGHT_START,
+ BPAT_HIPSRIGHT_LOOP,
+ BPAT_HIPSRIGHT_END,
+ BPAT_HIPSUP_START,
+ BPAT_HIPSUP_LOOP,
+ BPAT_HIPSUP_END,
+ BPAT_HIPSDOWN_START,
+ BPAT_HIPSDOWN_LOOP,
+ BPAT_HIPSDOWN_END,
+
+ BPAT_LAUGHLEFT,
+ BPAT_LAUGHRIGHT,
+
+ BPAT_INDICATELEFT,
+ BPAT_INDICATERIGHT,
+
+ BPAT_SCAREDDOWN_START,
+ BPAT_SCAREDDOWN_LOOP,
+ BPAT_SCAREDDOWN_END,
+ BPAT_SCAREDLEFT_START,
+ BPAT_SCAREDLEFT_LOOP,
+ BPAT_SCAREDLEFT_END,
+ BPAT_SCAREDRIGHT_START,
+ BPAT_SCAREDRIGHT_LOOP,
+ BPAT_SCAREDRIGHT_END,
+ BPAT_SCAREDUP_START,
+ BPAT_SCAREDUP_LOOP,
+ BPAT_SCAREDUP_END,
+
+ BPAT_ROPE,
+
+ BPAT_WITHRABBITLEFT_START,
+ BPAT_WITHRABBITLEFT_LOOP,
+ BPAT_WITHRABBITLEFT_END,
+ BPAT_WITHRABBITRIGHT_START,
+ BPAT_WITHRABBITRIGHT_LOOP,
+ BPAT_WITHRABBITRIGHT_END,
+
+ BPAT_WITHRECIPELEFT_START,
+ BPAT_WITHRECIPELEFT_LOOP,
+ BPAT_WITHRECIPELEFT_END,
+ BPAT_WITHRECIPERIGHT_START,
+ BPAT_WITHRECIPERIGHT_LOOP,
+ BPAT_WITHRECIPERIGHT_END,
+
+ BPAT_WITHCARDSLEFT_START,
+ BPAT_WITHCARDSLEFT_LOOP,
+ BPAT_WITHCARDSLEFT_END,
+ BPAT_WITHCARDSRIGHT_START,
+ BPAT_WITHCARDSRIGHT_LOOP,
+ BPAT_WITHCARDSRIGHT_END,
+
+ BPAT_WITHSNOWMANLEFT_START,
+ BPAT_WITHSNOWMANLEFT_LOOP,
+ BPAT_WITHSNOWMANLEFT_END,
+ BPAT_WITHSNOWMANRIGHT_START,
+ BPAT_WITHSNOWMANRIGHT_LOOP,
+ BPAT_WITHSNOWMANRIGHT_END,
+
+ BPAT_WITHNOTEBOOKLEFT_START,
+ BPAT_WITHNOTEBOOKLEFT_LOOP,
+ BPAT_WITHNOTEBOOKLEFT_END,
+ BPAT_WITHNOTEBOOKRIGHT_START,
+ BPAT_WITHNOTEBOOKRIGHT_LOOP,
+ BPAT_WITHNOTEBOOKRIGHT_END,
+
+ BPAT_WITHMEGAPHONELEFT_START,
+ BPAT_WITHMEGAPHONELEFT_LOOP,
+ BPAT_WITHMEGAPHONELEFT_END,
+ BPAT_WITHMEGAPHONERIGHT_START,
+ BPAT_WITHMEGAPHONERIGHT_LOOP,
+ BPAT_WITHMEGAPHONERIGHT_END,
+
+ BPAT_WITHBEARDLEFT_START,
+ BPAT_WITHBEARDLEFT_END,
+ BPAT_WITHBEARDRIGHT_START,
+ BPAT_WITHBEARDRIGHT_END,
+ BPAT_WITHBEARDLEFT_STATIC,
+ BPAT_WITHBEARDRIGHT_STATIC,
+
+ BPAT_MACBETH1,
+ BPAT_MACBETH2,
+ BPAT_MACBETH3,
+ BPAT_MACBETH4,
+ BPAT_MACBETH5,
+ BPAT_MACBETH6,
+ BPAT_MACBETH7,
+ BPAT_MACBETH8,
+ BPAT_MACBETH9,
+
+ BPAT_WITHSECRETARY
+ };
+
+public:
+ static void initStatics();
+ RMTony();
+
+ /**
+ * Initialize Tony
+ */
+ void init();
+
+ /**
+ * Free all memory
+ */
+ void close();
+
+ /**
+ * Tony makes a frame, updating the movement, etc.
+ */
+ void doFrame(CORO_PARAM, RMGfxTargetBuffer *bigBuf, int curLoc);
+
+ /**
+ * Draw method, which controls chararacter display
+ */
+ virtual void draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim);
+
+ /**
+ * Show or hide
+ */
+ void show();
+ void hide(bool bShowShadow = false);
+
+ /**
+ * Move and make an action, if necessary
+ */
+ void moveAndDoAction(CORO_PARAM, RMPoint dst, RMItem *item, int nAction, int nActionParm = 0);
+
+ /**
+ * Tony stops (on the right side with respect to any subject)
+ */
+ virtual void stop(CORO_PARAM);
+ void stopNoAction(CORO_PARAM);
+
+ /**
+ * Set a pattern
+ */
+ void setPattern(int npatt, bool bPlayP0 = false);
+
+ /**
+ * Reads the current pattern
+ */
+ int getCurPattern();
+
+ /**
+ * Waits until the end of a pattern
+ */
+ void waitForEndPattern(CORO_PARAM, uint32 hCustomSkip = CORO_INVALID_PID_VALUE);
+
+ /**
+ * Check if currently in an action
+ */
+ bool inAction();
+
+ /**
+ * Check if there needs to be an update for scrolling movement
+ */
+ bool mustUpdateScrolling();
+
+ /**
+ * Returns Tony's position
+ */
+ RMPoint position();
+
+ /**
+ * Set the scrolling position
+ */
+ void setScrollPosition(const RMPoint &pt);
+
+ /**
+ * Set the take animation
+ */
+ void take(int nWhere, int nPart);
+ void put(int nWhere, int nPart);
+
+ /**
+ * Start or End Talk
+ */
+ bool startTalkCalculate(CharacterTalkType nTalkType, int &headStartPat, int &bodyStartPat,
+ int &headLoopPat, int &bodyLoopPat);
+ void startTalk(CORO_PARAM, CharacterTalkType nTalkType);
+ bool endTalkCalculate(int &headStandPat, int &headEndPat, int &bodyEndPat, int &finalPat, bool &bStatic);
+ void endTalk(CORO_PARAM);
+
+ /**
+ * Start or End Static
+ */
+ void startStaticCalculate(CharacterTalkType nTalk, int &headPat, int &headLoopPat,
+ int &bodyStartPat, int &bodyLoopPat);
+ void startStatic(CORO_PARAM, CharacterTalkType nTalkType);
+ void endStaticCalculate(CharacterTalkType nTalk, int &bodyEndPat, int &finalPat, int &headEndPat);
+ void endStatic(CORO_PARAM, CharacterTalkType nTalkType);
+
+ /**
+ * Tony disguises himself!
+ */
+ void setShepherdess(bool bIsPast);
+
+ int getShepherdess();
+
+ /**
+ * Perform an action
+ */
+ void executeAction(int nAction, int nActionItem, int nParm);
+
+ void playSfx(int nSfx);
+};
+
+} // End of namespace Tony
+
+#endif
diff --git a/engines/tony/utils.cpp b/engines/tony/utils.cpp
new file mode 100644
index 0000000000..3cc09a1454
--- /dev/null
+++ b/engines/tony/utils.cpp
@@ -0,0 +1,448 @@
+/* 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.
+ *
+ */
+
+/*
+ * This code is based on original Tony Tough source code
+ *
+ * Copyright (c) 1997-2003 Nayma Software
+ */
+
+#include "tony/utils.h"
+#include "tony/tony.h"
+#include "tony/mpal/lzo.h"
+
+namespace Tony {
+
+/**
+ * Extracts a string from a data stream
+ * @param df data stream
+ */
+Common::String readString(Common::ReadStream &df) {
+ Common::String var;
+ uint8 len = df.readByte();
+
+ for (int i = 0; i < len; i++) {
+ char c;
+ c = df.readByte();
+ var += c;
+ }
+
+ return var;
+}
+
+/****************************************************************************\
+* RMPoint methods
+\****************************************************************************/
+
+/**
+ * Constructor
+ */
+RMPoint::RMPoint() {
+ _x = _y = 0;
+}
+
+/**
+ * Copy constructor
+ */
+RMPoint::RMPoint(const RMPoint &p) {
+ _x = p._x;
+ _y = p._y;
+}
+
+/**
+ * Constructor with integer parameters
+ */
+RMPoint::RMPoint(int x1, int y1) {
+ _x = x1;
+ _y = y1;
+}
+
+/**
+ * Copy operator
+ */
+RMPoint &RMPoint::operator=(RMPoint p) {
+ _x = p._x;
+ _y = p._y;
+
+ return *this;
+}
+
+/**
+ * Set a point
+ */
+void RMPoint::set(int x1, int y1) {
+ _x = x1;
+ _y = y1;
+}
+
+/**
+ * Offsets the point by another point
+ */
+void RMPoint::offset(const RMPoint &p) {
+ _x += p._x;
+ _y += p._y;
+}
+
+/**
+ * Offsets the point by a specified offset
+ */
+void RMPoint::offset(int xOff, int yOff) {
+ _x += xOff;
+ _y += yOff;
+}
+
+/**
+ * Sums together two points
+ */
+RMPoint operator+(RMPoint p1, RMPoint p2) {
+ RMPoint p(p1);
+
+ return (p += p2);
+}
+
+/**
+ * Subtracts two points
+ */
+RMPoint operator-(RMPoint p1, RMPoint p2) {
+ RMPoint p(p1);
+
+ return (p -= p2);
+}
+
+/**
+ * Sum (offset) of a point
+ */
+RMPoint &RMPoint::operator+=(RMPoint p) {
+ offset(p);
+ return *this;
+}
+
+/**
+ * Subtract (offset) of a point
+ */
+RMPoint &RMPoint::operator-=(RMPoint p) {
+ offset(-p);
+ return *this;
+}
+
+/**
+ * Inverts a point
+ */
+RMPoint RMPoint::operator-() {
+ RMPoint p;
+
+ p._x = -_x;
+ p._y = -_y;
+
+ return p;
+}
+
+/**
+ * Equality operator
+ */
+bool RMPoint::operator==(RMPoint p) {
+ return ((_x == p._x) && (_y == p._y));
+}
+
+/**
+ * Not equal operator
+ */
+bool RMPoint::operator!=(RMPoint p) {
+ return ((_x != p._x) || (_y != p._y));
+}
+
+/**
+ * Reads a point from a stream
+ */
+void RMPoint::readFromStream(Common::ReadStream &ds) {
+ _x = ds.readSint32LE();
+ _y = ds.readSint32LE();
+}
+
+/****************************************************************************\
+* RMPointReference methods
+\****************************************************************************/
+
+RMPointReference::RMPointReference(int &x, int &y): _x(x), _y(y) {
+}
+
+RMPointReference &RMPointReference::operator=(const RMPoint &p) {
+ _x = p._x; _y = p._y;
+ return *this;
+}
+
+RMPointReference &RMPointReference::operator-=(const RMPoint &p) {
+ _x -= p._x; _y -= p._y;
+ return *this;
+}
+
+RMPointReference::operator RMPoint() const {
+ return RMPoint(_x, _y);
+}
+
+/****************************************************************************\
+* RMRect methods
+\****************************************************************************/
+
+RMRect::RMRect(): _topLeft(_x1, _y1), _bottomRight(_x2, _y2) {
+ setEmpty();
+}
+
+void RMRect::setEmpty() {
+ _x1 = _y1 = _x2 = _y2 = 0;
+}
+
+RMRect::RMRect(const RMPoint &p1, const RMPoint &p2): _topLeft(_x1, _y1), _bottomRight(_x2, _y2) {
+ setRect(p1, p2);
+}
+
+RMRect::RMRect(int X1, int Y1, int X2, int Y2): _topLeft(_x1, _y1), _bottomRight(_x2, _y2) {
+ setRect(X1, Y1, X2, Y2);
+}
+
+RMRect::RMRect(const RMRect &rc): _topLeft(_x1, _y1), _bottomRight(_x2, _y2) {
+ copyRect(rc);
+}
+
+void RMRect::setRect(const RMPoint &p1, const RMPoint &p2) {
+ _x1 = p1._x;
+ _y1 = p1._y;
+ _x2 = p2._x;
+ _y2 = p2._y;
+}
+
+void RMRect::setRect(int X1, int Y1, int X2, int Y2) {
+ _x1 = X1;
+ _y1 = Y1;
+ _x2 = X2;
+ _y2 = Y2;
+}
+
+void RMRect::setRect(const RMRect &rc) {
+ copyRect(rc);
+}
+
+void RMRect::copyRect(const RMRect &rc) {
+ _x1 = rc._x1;
+ _y1 = rc._y1;
+ _x2 = rc._x2;
+ _y2 = rc._y2;
+}
+
+RMPointReference &RMRect::topLeft() {
+ return _topLeft;
+}
+
+RMPointReference &RMRect::bottomRight() {
+ return _bottomRight;
+}
+
+RMPoint RMRect::center() {
+ return RMPoint((_x2 - _x1) / 2, (_y2 - _y1) / 2);
+}
+
+int RMRect::width() const {
+ return _x2 - _x1;
+}
+
+int RMRect::height() const {
+ return _y2 - _y1;
+}
+
+int RMRect::size() const {
+ return width() * height();
+}
+
+RMRect::operator Common::Rect() const {
+ return Common::Rect(_x1, _y1, _x2, _y2);
+}
+
+bool RMRect::isEmpty() const {
+ return (_x1 == 0 && _y1 == 0 && _x2 == 0 && _y2 == 0);
+}
+
+const RMRect &RMRect::operator=(const RMRect &rc) {
+ copyRect(rc);
+ return *this;
+}
+
+void RMRect::offset(int xOff, int yOff) {
+ _x1 += xOff;
+ _y1 += yOff;
+ _x2 += xOff;
+ _y2 += yOff;
+}
+
+void RMRect::offset(const RMPoint &p) {
+ _x1 += p._x;
+ _y1 += p._y;
+ _x2 += p._x;
+ _y2 += p._y;
+}
+
+const RMRect &RMRect::operator+=(RMPoint p) {
+ offset(p);
+ return *this;
+}
+
+const RMRect &RMRect::operator-=(RMPoint p) {
+ offset(-p);
+ return *this;
+}
+
+RMRect operator+(const RMRect &rc, RMPoint p) {
+ RMRect r(rc);
+ return (r += p);
+}
+
+RMRect operator-(const RMRect &rc, RMPoint p) {
+ RMRect r(rc);
+
+ return (r -= p);
+}
+
+RMRect operator+(RMPoint p, const RMRect &rc) {
+ RMRect r(rc);
+
+ return (r += p);
+}
+
+RMRect operator-(RMPoint p, const RMRect &rc) {
+ RMRect r(rc);
+
+ return (r += p);
+}
+
+bool RMRect::operator==(const RMRect &rc) {
+ return ((_x1 == rc._x1) && (_y1 == rc._y1) && (_x2 == rc._x2) && (_y2 == rc._y2));
+}
+
+bool RMRect::operator!=(const RMRect &rc) {
+ return ((_x1 != rc._x1) || (_y1 != rc._y1) || (_x2 != rc._x2) || (_y2 != rc._y2));
+}
+
+void RMRect::normalizeRect() {
+ setRect(MIN(_x1, _x2), MIN(_y1, _y2), MAX(_x1, _x2), MAX(_y1, _y2));
+}
+
+void RMRect::readFromStream(Common::ReadStream &ds) {
+ _x1 = ds.readSint32LE();
+ _y1 = ds.readSint32LE();
+ _x2 = ds.readSint32LE();
+ _y2 = ds.readSint32LE();
+}
+
+/**
+ * Check if RMPoint is in RMRect
+ */
+bool RMRect::ptInRect(const RMPoint &pt) {
+ return (pt._x >= _x1 && pt._x <= _x2 && pt._y >= _y1 && pt._y <= _y2);
+}
+
+/****************************************************************************\
+* Resource Update
+\****************************************************************************/
+
+RMResUpdate::RMResUpdate() {
+ _infos = NULL;
+ _numUpd = 0;
+}
+
+RMResUpdate::~RMResUpdate() {
+ if (_infos) {
+ delete[] _infos;
+ _infos = NULL;
+ }
+
+ if (_hFile.isOpen())
+ _hFile.close();
+}
+
+void RMResUpdate::init(const Common::String &fileName) {
+ // Open the resource update file
+ if (!_hFile.open(fileName))
+ // It doesn't exist, so exit immediately
+ return;
+
+ uint8 version = _hFile.readByte();
+
+ _numUpd = _hFile.readUint32LE();
+
+ _infos = new ResUpdInfo[_numUpd];
+
+ // Load the index of the resources in the file
+ for (uint32 i = 0; i < _numUpd; ++i) {
+ ResUpdInfo &info = _infos[i];
+
+ info._dwRes = _hFile.readUint32LE();
+ info._offset = _hFile.readUint32LE();
+ info._size = _hFile.readUint32LE();
+ info._cmpSize = _hFile.readUint32LE();
+ }
+}
+
+MpalHandle RMResUpdate::queryResource(uint32 dwRes) {
+ // If there isn't an update file, return NULL
+ if (!_hFile.isOpen())
+ return NULL;
+
+ uint32 i;
+ for (i = 0; i < _numUpd; ++i)
+ if (_infos[i]._dwRes == dwRes)
+ // Found the index
+ break;
+
+ if (i == _numUpd)
+ // Couldn't find a matching resource, so return NULL
+ return NULL;
+
+ const ResUpdInfo &info = _infos[i];
+ byte *cmpBuf = new byte[info._cmpSize];
+ uint32 dwRead;
+
+ // Move to the correct offset and read in the compressed data
+ _hFile.seek(info._offset);
+ dwRead = _hFile.read(cmpBuf, info._cmpSize);
+
+ if (info._cmpSize > dwRead) {
+ // Error occurred reading data, so return NULL
+ delete[] cmpBuf;
+ return NULL;
+ }
+
+ // Allocate space for the output resource
+ MpalHandle destBuf = globalAllocate(0, info._size);
+ byte *lpDestBuf = (byte *)globalLock(destBuf);
+ uint32 dwSize;
+
+ // Decompress the data
+ lzo1x_decompress(cmpBuf, info._cmpSize, lpDestBuf, &dwSize);
+
+ // Delete buffer for compressed data
+ delete [] cmpBuf;
+
+ // Return the resource
+ globalUnlock(destBuf);
+ return destBuf;
+}
+
+} // End of namespace Tony
diff --git a/engines/tony/utils.h b/engines/tony/utils.h
new file mode 100644
index 0000000000..9f13e5f19b
--- /dev/null
+++ b/engines/tony/utils.h
@@ -0,0 +1,176 @@
+/* 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.
+ *
+ */
+
+/*
+ * This code is based on original Tony Tough source code
+ *
+ * Copyright (c) 1997-2003 Nayma Software
+ */
+
+#ifndef TONY_UTILS_H
+#define TONY_UTILS_H
+
+#include "common/scummsys.h"
+#include "common/file.h"
+#include "common/rect.h"
+#include "common/str.h"
+#include "tony/mpal/memory.h"
+
+namespace Tony {
+
+using namespace ::Tony::MPAL;
+
+Common::String readString(Common::ReadStream &ds);
+
+/**
+ * Point class
+ */
+class RMPoint {
+public:
+ int _x, _y;
+
+public:
+ // Constructor
+ RMPoint();
+ RMPoint(const RMPoint &p);
+ RMPoint(int x1, int y1);
+
+ // Copy
+ RMPoint &operator=(RMPoint p);
+
+ // Set
+ void set(int x1, int y1);
+
+ // Offset
+ void offset(int xOff, int yOff);
+ void offset(const RMPoint &p);
+ friend RMPoint operator+(RMPoint p1, RMPoint p2);
+ friend RMPoint operator-(RMPoint p1, RMPoint p2);
+ RMPoint &operator+=(RMPoint p);
+ RMPoint &operator-=(RMPoint p);
+ RMPoint operator-();
+
+ // Comparison
+ bool operator==(RMPoint p);
+ bool operator!=(RMPoint p);
+
+ // Casting a POINT
+ operator Common::Point() const;
+
+ // Extraction from data streams
+ void readFromStream(Common::ReadStream &ds);
+};
+
+class RMPointReference {
+public:
+ int &_x;
+ int &_y;
+
+ RMPointReference(int &x, int &y);
+ RMPointReference &operator=(const RMPoint &p);
+ RMPointReference &operator-=(const RMPoint &p);
+ operator RMPoint() const;
+};
+
+class RMRect {
+public:
+ int _x1, _y1;
+ int _x2, _y2;
+ RMPointReference _topLeft;
+ RMPointReference _bottomRight;
+
+public:
+ RMRect();
+ RMRect(int x1, int y1, int x2, int y2);
+ RMRect(const RMPoint &p1, const RMPoint &p2);
+ RMRect(const RMRect &rc);
+
+ // Attributes
+ RMPointReference &topLeft();
+ RMPointReference &bottomRight();
+ RMPoint center();
+ int width() const;
+ int height() const;
+ bool isEmpty() const;
+ int size() const;
+ operator Common::Rect() const;
+
+ // Set
+ void setRect(int x1, int y1, int x2, int y2);
+ void setRect(const RMPoint &p1, const RMPoint &p2);
+ void setEmpty();
+
+ // Copiers
+ void setRect(const RMRect &rc);
+ void copyRect(const RMRect &rc);
+ const RMRect &operator=(const RMRect &rc);
+
+ // Offset
+ void offset(int xOff, int yOff);
+ void offset(const RMPoint &p);
+ friend RMRect operator+(const RMRect &rc, RMPoint p);
+ friend RMRect operator-(const RMRect &rc, RMPoint p);
+ friend RMRect operator+(RMPoint p, const RMRect &rc);
+ friend RMRect operator-(RMPoint p, const RMRect &rc);
+ const RMRect &operator+=(RMPoint p);
+ const RMRect &operator-=(RMPoint p);
+
+ // Comparison
+ bool operator==(const RMRect &rc);
+ bool operator!=(const RMRect &rc);
+
+ // Normalize
+ void normalizeRect();
+
+ // Point in rect
+ bool ptInRect(const RMPoint &pt);
+
+ // Extract from data stream
+ void readFromStream(Common::ReadStream &ds);
+};
+
+/**
+ * Resource update manager
+ */
+class RMResUpdate {
+ struct ResUpdInfo {
+ uint32 _dwRes;
+ uint32 _offset;
+ uint32 _size;
+ uint32 _cmpSize;
+ };
+
+ uint32 _numUpd;
+ ResUpdInfo *_infos;
+ Common::File _hFile;
+
+public:
+ RMResUpdate();
+ ~RMResUpdate();
+
+ void init(const Common::String &fileName);
+ MpalHandle queryResource(uint32 dwRes);
+};
+
+} // End of namespace Tony
+
+#endif /* TONY_H */
diff --git a/engines/tony/window.cpp b/engines/tony/window.cpp
new file mode 100644
index 0000000000..013be84b4b
--- /dev/null
+++ b/engines/tony/window.cpp
@@ -0,0 +1,336 @@
+/* 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.
+ *
+ */
+
+/*
+ * This code is based on original Tony Tough source code
+ *
+ * Copyright (c) 1997-2003 Nayma Software
+ */
+
+#include "common/scummsys.h"
+#include "graphics/surface.h"
+#include "util.h"
+#include "tony/window.h"
+#include "tony/game.h"
+#include "tony/tony.h"
+
+namespace Tony {
+
+
+/****************************************************************************\
+* RMWindow Methods
+\****************************************************************************/
+
+RMWindow::RMWindow() {
+ _showDirtyRects = false;
+}
+
+RMWindow::~RMWindow() {
+ close();
+ RMText::unload();
+ RMGfxTargetBuffer::freeBWPrecalcTable();
+}
+
+/**
+ * Initializes the graphics window
+ */
+void RMWindow::init() {
+ Graphics::PixelFormat pixelFormat(2, 5, 5, 5, 0, 10, 5, 0, 0);
+ initGraphics(RM_SX, RM_SY, true, &pixelFormat);
+
+ _bGrabScreenshot = false;
+ _bGrabThumbnail = false;
+ _bGrabMovie = false;
+ _wiping = false;
+}
+
+void RMWindow::copyRectToScreen(const byte *buf, int pitch, int x, int y, int w, int h) {
+ if (GLOBALS._bCfgAnni30) {
+ if (!RMGfxTargetBuffer::_precalcTable) {
+ RMGfxTargetBuffer::createBWPrecalcTable();
+ g_vm->getEngine()->getPointer().updateCursor();
+ }
+ Graphics::Surface *screen = g_system->lockScreen();
+ const uint16 *src = (const uint16 *)buf;
+ for (int i = 0; i < h; i++) {
+ uint16 *dst = (uint16 *)screen->getBasePtr(x, y + i);
+ for (int j = 0; j < w; j++) {
+ dst[j] = RMGfxTargetBuffer::_precalcTable[src[j] & 0x7FFF];
+ }
+ src += (pitch / 2);
+ }
+ g_system->unlockScreen();
+ } else {
+ if (RMGfxTargetBuffer::_precalcTable) {
+ RMGfxTargetBuffer::freeBWPrecalcTable();
+ g_vm->getEngine()->getPointer().updateCursor();
+ }
+ g_system->copyRectToScreen(buf, pitch, x, y, w, h);
+ }
+ }
+
+/**
+ * Close the window
+ */
+void RMWindow::close() {
+}
+
+void RMWindow::grabThumbnail(uint16 *thumbmem) {
+ _bGrabThumbnail = true;
+ _wThumbBuf = thumbmem;
+}
+
+/**
+ * Repaint the screen
+ */
+void RMWindow::repaint() {
+ g_system->updateScreen();
+}
+
+/**
+ * Wipes an area of the screen
+ */
+void RMWindow::wipeEffect(Common::Rect &rcBoundEllipse) {
+ if ((rcBoundEllipse.left == 0) && (rcBoundEllipse.top == 0) &&
+ (rcBoundEllipse.right == RM_SX) && (rcBoundEllipse.bottom == RM_SY)) {
+ // Full screen clear wanted, so use shortcut method
+ g_system->fillScreen(0);
+ } else {
+ // Clear the designated area a line at a time
+ uint16 line[RM_SX];
+ Common::fill(line, line + RM_SX, 0);
+
+ // Loop through each line
+ for (int yp = rcBoundEllipse.top; yp < rcBoundEllipse.bottom; ++yp) {
+ copyRectToScreen((const byte *)&line[0], RM_SX * 2, rcBoundEllipse.left, yp, rcBoundEllipse.width(), 1);
+ }
+ }
+}
+
+void RMWindow::getNewFrame(RMGfxTargetBuffer &bigBuf, Common::Rect *rcBoundEllipse) {
+ // Get a pointer to the bytes of the source buffer
+ byte *lpBuf = bigBuf;
+
+ if (rcBoundEllipse != NULL) {
+ // Circular wipe effect
+ getNewFrameWipe(lpBuf, *rcBoundEllipse);
+ _wiping = true;
+ } else if (_wiping) {
+ // Just finished a wiping effect, so copy the full screen
+ copyRectToScreen(lpBuf, RM_SX * 2, 0, 0, RM_SX, RM_SY);
+ _wiping = false;
+
+ } else {
+ // Standard screen copy - iterate through the dirty rects
+ Common::List<Common::Rect> dirtyRects = bigBuf.getDirtyRects();
+ Common::List<Common::Rect>::iterator i;
+
+ // If showing dirty rects, copy the entire screen background and set up a surface pointer
+ Graphics::Surface *s = NULL;
+ if (_showDirtyRects) {
+ copyRectToScreen(lpBuf, RM_SX * 2, 0, 0, RM_SX, RM_SY);
+ s = g_system->lockScreen();
+ }
+
+ for (i = dirtyRects.begin(); i != dirtyRects.end(); ++i) {
+ Common::Rect &r = *i;
+ const byte *lpSrc = lpBuf + (RM_SX * 2) * r.top + (r.left * 2);
+ copyRectToScreen(lpSrc, RM_SX * 2, r.left, r.top, r.width(), r.height());
+ }
+
+ if (_showDirtyRects) {
+ for (i = dirtyRects.begin(); i != dirtyRects.end(); ++i) {
+ // Frame the copied area with a rectangle
+ s->frameRect(*i, 0xffffff);
+ }
+
+ g_system->unlockScreen();
+ }
+ }
+
+ if (_bGrabThumbnail) {
+ // Need to generate a thumbnail
+ RMSnapshot s;
+
+ s.grabScreenshot(lpBuf, 4, _wThumbBuf);
+ _bGrabThumbnail = false;
+ }
+
+ // Clear the dirty rect list
+ bigBuf.clearDirtyRects();
+}
+
+/**
+ * Copies a section of the game frame in a circle bounded by the specified rectangle
+ */
+void RMWindow::getNewFrameWipe(byte *lpBuf, Common::Rect &rcBoundEllipse) {
+ // Clear the screen
+ g_system->fillScreen(0);
+
+ if (!rcBoundEllipse.isValidRect())
+ return;
+
+ Common::Point center(rcBoundEllipse.left + rcBoundEllipse.width() / 2,
+ rcBoundEllipse.top + rcBoundEllipse.height() / 2);
+
+ // The rectangle technically defines the area inside the ellipse, with the corners touching
+ // the ellipse boundary. Since we're currently simulating the ellipse using a plain circle,
+ // we need to calculate a necessary width using the hypotenuse of X/2 & Y/2
+ int x2y2 = (rcBoundEllipse.width() / 2) * (rcBoundEllipse.width() / 2) +
+ (rcBoundEllipse.height() / 2) * (rcBoundEllipse.height() / 2);
+ int radius = 0;
+ while ((radius * radius) < x2y2)
+ ++radius;
+
+ // Proceed copying a circular area of the frame with the calculated radius onto the screen
+ int error = -radius;
+ int x = radius;
+ int y = 0;
+
+ while (x >= y) {
+ plotSplices(lpBuf, center, x, y);
+
+ error += y;
+ ++y;
+ error += y;
+
+ if (error >= 0) {
+ error -= x;
+ --x;
+ error -= x;
+ }
+ }
+}
+
+/**
+ * Handles drawing the line splices for the circle of viewable area
+ */
+void RMWindow::plotSplices(const byte *lpBuf, const Common::Point &center, int x, int y) {
+ plotLines(lpBuf, center, x, y);
+ if (x != y)
+ plotLines(lpBuf, center, y, x);
+}
+
+/**
+ * Handles drawing the line splices for the circle of viewable area
+ */
+void RMWindow::plotLines(const byte *lpBuf, const Common::Point &center, int x, int y) {
+ // Skips lines that have no width (i.e. at the top of the circle)
+ if ((x == 0) || (y > center.y))
+ return;
+
+ const byte *pSrc;
+ int xs = MAX(center.x - x, 0);
+ int width = MIN(RM_SX - xs, x * 2);
+
+ if ((center.y - y) >= 0) {
+ // Draw line in top half of circle
+ pSrc = lpBuf + ((center.y - y) * RM_SX * 2) + xs * 2;
+ copyRectToScreen(pSrc, RM_SX * 2, xs, center.y - y, width, 1);
+ }
+
+ if ((center.y + y) < RM_SY) {
+ // Draw line in bottom half of circle
+ pSrc = lpBuf + ((center.y + y) * RM_SX * 2) + xs * 2;
+ copyRectToScreen(pSrc, RM_SX * 2, xs, center.y + y, width, 1);
+ }
+}
+
+void RMWindow::showDirtyRects(bool v) {
+ _showDirtyRects = v;
+}
+
+/****************************************************************************\
+* RMSnapshot Methods
+\****************************************************************************/
+
+void RMSnapshot::grabScreenshot(byte *lpBuf, int dezoom, uint16 *lpDestBuf) {
+ uint16 *src = (uint16 *)lpBuf;
+
+ int dimx = RM_SX / dezoom;
+ int dimy = RM_SY / dezoom;
+
+ uint16 *cursrc;
+
+ if (lpDestBuf == NULL)
+ src += (RM_SY - 1) * RM_BBX;
+
+ if (dezoom == 1 && 0) {
+ byte *curOut = _rgb;
+
+ for (int y = 0; y < dimy; y++) {
+ for (int x = 0; x < dimx; x++) {
+ cursrc = &src[RM_SKIPX + x];
+
+ *curOut++ = ((*cursrc) & 0x1F) << 3;
+ *curOut++ = (((*cursrc) >> 5) & 0x1F) << 3;
+ *curOut++ = (((*cursrc) >> 10) & 0x1F) << 3;
+
+ if (lpDestBuf)
+ *lpDestBuf++ = *cursrc;
+ }
+
+ if (lpDestBuf == NULL)
+ src -= RM_BBX;
+ else
+ src += RM_BBX;
+ }
+ } else {
+ uint32 k = 0;
+ for (int y = 0; y < dimy; y++) {
+ for (int x = 0; x < dimx; x++) {
+ cursrc = &src[RM_SKIPX + x * dezoom];
+ int sommar, sommab, sommag, curv;
+ sommar = sommab = sommag = 0;
+
+ for (int v = 0; v < dezoom; v++) {
+ for (int u = 0; u < dezoom; u++) {
+ if (lpDestBuf == NULL)
+ curv = -v;
+ else
+ curv = v;
+
+ sommab += cursrc[curv * RM_BBX + u] & 0x1F;
+ sommag += (cursrc[curv * RM_BBX + u] >> 5) & 0x1F;
+ sommar += (cursrc[curv * RM_BBX + u] >> 10) & 0x1F;
+ }
+ }
+ _rgb[k + 0] = (byte)(sommab * 8 / (dezoom * dezoom));
+ _rgb[k + 1] = (byte)(sommag * 8 / (dezoom * dezoom));
+ _rgb[k + 2] = (byte)(sommar * 8 / (dezoom * dezoom));
+
+ if (lpDestBuf != NULL)
+ lpDestBuf[k / 3] = ((int)_rgb[k + 0] >> 3) | (((int)_rgb[k + 1] >> 3) << 5) |
+ (((int)_rgb[k + 2] >> 3) << 10);
+
+ k += 3;
+ }
+
+ if (lpDestBuf == NULL)
+ src -= RM_BBX * dezoom;
+ else
+ src += RM_BBX * dezoom;
+ }
+ }
+}
+
+} // End of namespace Tony
diff --git a/engines/tony/window.h b/engines/tony/window.h
new file mode 100644
index 0000000000..2e8769707f
--- /dev/null
+++ b/engines/tony/window.h
@@ -0,0 +1,98 @@
+/* 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.
+ *
+ */
+
+/*
+ * This code is based on original Tony Tough source code
+ *
+ * Copyright (c) 1997-2003 Nayma Software
+ */
+
+#ifndef TONY_WINDOW_H
+#define TONY_WINDOW_H
+
+#include "common/scummsys.h"
+#include "common/rect.h"
+#include "tony/game.h"
+
+namespace Tony {
+
+class RMSnapshot {
+private:
+ // Buffer used to convert to RGB
+ byte _rgb[RM_SX *RM_SY * 3];
+public:
+ /**
+ * Take a screenshot
+ */
+ void grabScreenshot(byte *lpBuf, int dezoom = 1, uint16 *lpDestBuf = NULL);
+};
+
+
+class RMWindow {
+private:
+ void plotSplices(const byte *lpBuf, const Common::Point &center, int x, int y);
+ void plotLines(const byte *lpBuf, const Common::Point &center, int x, int y);
+
+protected:
+ bool _wiping;
+ bool _showDirtyRects;
+
+ bool _bGrabScreenshot;
+ bool _bGrabThumbnail;
+ bool _bGrabMovie;
+ uint16 *_wThumbBuf;
+
+ void copyRectToScreen(const byte *buf, int pitch, int x, int y, int w, int h);
+ void wipeEffect(Common::Rect &rcBoundEllipse);
+ void getNewFrameWipe(byte *lpBuf, Common::Rect &rcBoundEllipse);
+
+public:
+ RMWindow();
+ ~RMWindow();
+
+ /**
+ * Initialization
+ */
+ void init();
+ void close();
+
+ /**
+ * Drawing
+ */
+ void repaint();
+
+ /**
+ * Reads the next frame
+ */
+ void getNewFrame(RMGfxTargetBuffer &lpBuf, Common::Rect *rcBoundEllipse);
+
+ /**
+ * Request a thumbnail be grabbed during the next frame
+ */
+ void grabThumbnail(uint16 *buf);
+
+ void showDirtyRects(bool v);
+};
+
+} // End of namespace Tony
+
+#endif /* TONY_WINDOW_H */