From 87a9ba5f2f5b9c3cde675c238ce718147417df03 Mon Sep 17 00:00:00 2001 From: Paul Gilbert Date: Sun, 15 Mar 2015 16:52:55 -0400 Subject: SHERLOCK: Initial commit --- engines/sherlock/configure.engine | 3 + engines/sherlock/decompress.cpp | 82 +++++++++++++ engines/sherlock/decompress.h | 36 ++++++ engines/sherlock/detection.cpp | 125 ++++++++++++++++++++ engines/sherlock/detection_tables.h | 47 ++++++++ engines/sherlock/graphics.cpp | 45 +++++++ engines/sherlock/graphics.h | 43 +++++++ engines/sherlock/inventory.h | 40 +++++++ engines/sherlock/journal.cpp | 40 +++++++ engines/sherlock/journal.h | 46 ++++++++ engines/sherlock/module.mk | 22 ++++ engines/sherlock/resources.cpp | 219 +++++++++++++++++++++++++++++++++++ engines/sherlock/resources.h | 86 ++++++++++++++ engines/sherlock/room.cpp | 32 +++++ engines/sherlock/room.h | 102 ++++++++++++++++ engines/sherlock/scalpel/scalpel.cpp | 40 +++++++ engines/sherlock/scalpel/scalpel.h | 45 +++++++ engines/sherlock/sherlock.cpp | 81 +++++++++++++ engines/sherlock/sherlock.h | 91 +++++++++++++++ engines/sherlock/sound.h | 39 +++++++ engines/sherlock/sprite.cpp | 142 +++++++++++++++++++++++ engines/sherlock/sprite.h | 56 +++++++++ engines/sherlock/talk.cpp | 30 +++++ engines/sherlock/talk.h | 49 ++++++++ engines/sherlock/tattoo/tattoo.cpp | 38 ++++++ engines/sherlock/tattoo/tattoo.h | 45 +++++++ engines/sherlock/vdaplayer.h | 34 ++++++ 27 files changed, 1658 insertions(+) create mode 100644 engines/sherlock/configure.engine create mode 100644 engines/sherlock/decompress.cpp create mode 100644 engines/sherlock/decompress.h create mode 100644 engines/sherlock/detection.cpp create mode 100644 engines/sherlock/detection_tables.h create mode 100644 engines/sherlock/graphics.cpp create mode 100644 engines/sherlock/graphics.h create mode 100644 engines/sherlock/inventory.h create mode 100644 engines/sherlock/journal.cpp create mode 100644 engines/sherlock/journal.h create mode 100644 engines/sherlock/module.mk create mode 100644 engines/sherlock/resources.cpp create mode 100644 engines/sherlock/resources.h create mode 100644 engines/sherlock/room.cpp create mode 100644 engines/sherlock/room.h create mode 100644 engines/sherlock/scalpel/scalpel.cpp create mode 100644 engines/sherlock/scalpel/scalpel.h create mode 100644 engines/sherlock/sherlock.cpp create mode 100644 engines/sherlock/sherlock.h create mode 100644 engines/sherlock/sound.h create mode 100644 engines/sherlock/sprite.cpp create mode 100644 engines/sherlock/sprite.h create mode 100644 engines/sherlock/talk.cpp create mode 100644 engines/sherlock/talk.h create mode 100644 engines/sherlock/tattoo/tattoo.cpp create mode 100644 engines/sherlock/tattoo/tattoo.h create mode 100644 engines/sherlock/vdaplayer.h diff --git a/engines/sherlock/configure.engine b/engines/sherlock/configure.engine new file mode 100644 index 0000000000..a56129a8f0 --- /dev/null +++ b/engines/sherlock/configure.engine @@ -0,0 +1,3 @@ +# This file is included from the main "configure" script +# add_engine [name] [desc] [build-by-default] [subengines] [base games] [deps] +add_engine sherlock "The Lost Files of Sherlock Holmes" no diff --git a/engines/sherlock/decompress.cpp b/engines/sherlock/decompress.cpp new file mode 100644 index 0000000000..61110be840 --- /dev/null +++ b/engines/sherlock/decompress.cpp @@ -0,0 +1,82 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "sherlock/decompress.h" + +namespace Sherlock { + +/** + * Decompresses an LZW compressed resource. If no outSize is specified, it will + * decompress the entire resource. If, however, an explicit size is specified, + * it will decompress only up to that many bytes from the stream starting at + * whatever position it was previously. + */ +Common::SeekableReadStream *decompressLZ(Common::SeekableReadStream &source, int32 outSize) { + if (outSize == -1) { + source.seek(5); + outSize = source.readSint32LE(); + } + + byte lzWindow[4096]; + uint16 lzWindowPos; + uint16 cmd; + + byte *outBuffer = new byte[outSize]; + byte *outBufferEnd = outBuffer + outSize; + Common::MemoryReadStream *outS = new Common::MemoryReadStream(outBuffer, outSize, DisposeAfterUse::YES); + + memset(lzWindow, 0xFF, 0xFEE); + lzWindowPos = 0xFEE; + cmd = 0; + + while (1) { + cmd >>= 1; + if (!(cmd & 0x100)) { + cmd = source.readByte() | 0xFF00; + } + if (cmd & 1) { + byte literal = source.readByte(); + *outBuffer++ = literal; + lzWindow[lzWindowPos] = literal; + lzWindowPos = (lzWindowPos + 1) & 0x0FFF; + } else { + int copyPos, copyLen; + copyPos = source.readByte(); + copyLen = source.readByte(); + copyPos = copyPos | ((copyLen & 0xF0) << 4); + copyLen = (copyLen & 0x0F) + 3; + while (copyLen--) { + byte literal = lzWindow[copyPos]; + copyPos = (copyPos + 1) & 0x0FFF; + *outBuffer++ = literal; + lzWindow[lzWindowPos] = literal; + lzWindowPos = (lzWindowPos + 1) & 0x0FFF; + } + } + if (outBuffer >= outBufferEnd) + break; + } + + return outS; +} + +} // namespace Sherlock diff --git a/engines/sherlock/decompress.h b/engines/sherlock/decompress.h new file mode 100644 index 0000000000..330e018115 --- /dev/null +++ b/engines/sherlock/decompress.h @@ -0,0 +1,36 @@ +/* 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 SHERLOCK_DECOMPRESS_H +#define SHERLOCK_DECOMPRESS_H + +#include "common/memstream.h" + +namespace Sherlock { + +#include "common/stream.h" + +Common::SeekableReadStream *decompressLZ(Common::SeekableReadStream &source, int32 outSize = -1); + +} // namespace Sherlock + +#endif diff --git a/engines/sherlock/detection.cpp b/engines/sherlock/detection.cpp new file mode 100644 index 0000000000..f207bb69d9 --- /dev/null +++ b/engines/sherlock/detection.cpp @@ -0,0 +1,125 @@ +/* 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 "sherlock/sherlock.h" +#include "sherlock/scalpel/scalpel.h" +#include "sherlock/tattoo/tattoo.h" +#include "engines/advancedDetector.h" + +namespace Sherlock { + +#define MAX_SAVES 99 + +struct SherlockGameDescription { + ADGameDescription desc; + + int gameID; + uint32 features; +}; + +uint32 SherlockEngine::getGameID() const { + return _gameDescription->gameID; +} + +uint32 SherlockEngine::getGameFeatures() const { + return _gameDescription->features; +} + +Common::Platform SherlockEngine::getPlatform() const { + return _gameDescription->desc.platform; +} + +} // End of namespace Sherlock + +static const PlainGameDescriptor sherlockGames[] = { + {"sherlock", "The Lost Files of Sherlock Holmes"}, + { "scalpel", "The Case of the Serrated Scalpel" }, + { "rosetattoo", "The Case of the Rose Tattoo" }, + {0, 0} +}; + +#include "sherlock/detection_tables.h" + +class SherlockMetaEngine : public AdvancedMetaEngine { +public: + SherlockMetaEngine() : AdvancedMetaEngine(Sherlock::gameDescriptions, sizeof(Sherlock::gameDescriptions), sherlockGames) {} + + virtual const char *getName() const { + return "Sherlock Engine"; + } + + virtual const char *getOriginalCopyright() const { + return "Sherlock Engine (C) 1992-1996 Mythos Software, 1992-1996 (C) Electronic Arts"; + } + + virtual bool createInstance(OSystem *syst, Engine **engine, const ADGameDescription *desc) const; + virtual bool hasFeature(MetaEngineFeature f) 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 SherlockMetaEngine::createInstance(OSystem *syst, Engine **engine, const ADGameDescription *desc) const { + const Sherlock::SherlockGameDescription *gd = (const Sherlock::SherlockGameDescription *)desc; + if (gd) { + switch (gd->gameID) { + case Sherlock::GType_SerratedScalpel: + *engine = new Sherlock::Scalpel::ScalpelEngine(syst, gd); + break; + case Sherlock::GType_RoseTattoo: + *engine = new Sherlock::Tattoo::TattooEngine(syst, gd); + break; + default: + error("Unknown game"); + break; + } + } + return gd != 0; +} + +bool SherlockMetaEngine::hasFeature(MetaEngineFeature f) const { + return false; +} + +SaveStateList SherlockMetaEngine::listSaves(const char *target) const { + SaveStateList saveList; + return saveList; +} + +int SherlockMetaEngine::getMaximumSaveSlot() const { + return MAX_SAVES; +} + +void SherlockMetaEngine::removeSaveState(const char *target, int slot) const { +} + +SaveStateDescriptor SherlockMetaEngine::querySaveMetaInfos(const char *target, int slot) const { + return SaveStateDescriptor(); +} + + +#if PLUGIN_ENABLED_DYNAMIC(SHERLOCK) +REGISTER_PLUGIN_DYNAMIC(SHERLOCK, PLUGIN_TYPE_ENGINE, SherlockMetaEngine); +#else +REGISTER_PLUGIN_STATIC(SHERLOCK, PLUGIN_TYPE_ENGINE, SherlockMetaEngine); +#endif diff --git a/engines/sherlock/detection_tables.h b/engines/sherlock/detection_tables.h new file mode 100644 index 0000000000..1d7326058e --- /dev/null +++ b/engines/sherlock/detection_tables.h @@ -0,0 +1,47 @@ +/* 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 Sherlock { + +static const SherlockGameDescription gameDescriptions[] = { + { + // Case of the Serrated Scalpel - English + { + "scalpel", + 0, + { + { "talk.lib", 0, "ad0c4d6865edf15da4e9204c08815875", 238928 }, + AD_LISTEND + }, + Common::EN_ANY, + Common::kPlatformDOS, + ADGF_NO_FLAGS, + GUIO1(GUIO_NOSPEECH) + }, + GType_SerratedScalpel, + 0 + }, + + { AD_TABLE_END_MARKER, 0, 0 } +}; + +} // End of namespace MADS diff --git a/engines/sherlock/graphics.cpp b/engines/sherlock/graphics.cpp new file mode 100644 index 0000000000..f4a5bf1864 --- /dev/null +++ b/engines/sherlock/graphics.cpp @@ -0,0 +1,45 @@ +/* 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 "sherlock/graphics.h" + +namespace Sherlock { + +Surface::Surface(uint16 width, uint16 height) { + create(width, height, Graphics::PixelFormat::createFormatCLUT8()); +} + +Surface::~Surface() { + free(); +} + +void Surface::fillRect(int x1, int y1, int x2, int y2, byte color) { + Graphics::Surface::fillRect(Common::Rect(x1, y1, x2, y2), color); +} + +void Surface::drawSprite(int x, int y, SpriteFrame *spriteFrame, bool flipped, bool altFlag) { + + +} + + +} // End of namespace Sherlock diff --git a/engines/sherlock/graphics.h b/engines/sherlock/graphics.h new file mode 100644 index 0000000000..64518a78c6 --- /dev/null +++ b/engines/sherlock/graphics.h @@ -0,0 +1,43 @@ +/* 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 SHERLOCK_GRAPHICS_H +#define SHERLOCK_GRAPHICS_H + +#include "common/rect.h" +#include "graphics/surface.h" + +#include "sherlock/sprite.h" + +namespace Sherlock { + +class Surface : public Graphics::Surface { +public: + Surface(uint16 width, uint16 height); + ~Surface(); + void fillRect(int x1, int y1, int x2, int y2, byte color); + void drawSprite(int x, int y, SpriteFrame *spriteFrame, bool flipped = false, bool altFlag = false); +}; + +} // End of namespace Sherlock + +#endif diff --git a/engines/sherlock/inventory.h b/engines/sherlock/inventory.h new file mode 100644 index 0000000000..de4a2d7758 --- /dev/null +++ b/engines/sherlock/inventory.h @@ -0,0 +1,40 @@ +/* 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 SHERLOCK_INVENTORY_H +#define SHERLOCK_INVENTORY_H + +#include "common/scummsys.h" + +namespace Sherlock { + +struct InventoryItem { + int stringIndex; + char name[12]; + char description[41]; + char name2[9]; + uint16 value; +}; + +} // End of namespace Sherlock + +#endif diff --git a/engines/sherlock/journal.cpp b/engines/sherlock/journal.cpp new file mode 100644 index 0000000000..ad7df48943 --- /dev/null +++ b/engines/sherlock/journal.cpp @@ -0,0 +1,40 @@ +/* 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 "sherlock/journal.h" + +namespace Sherlock { + +Journal::Journal() { + // Allow up to 1000 statements + _data.resize(1000); + + // Initialize fields + _count = 0; + _maxPage = 0; + _index = 0; + _sub = 0; + _up = _down = 0; + _page = 0; +} + +} // End of namespace Sherlock diff --git a/engines/sherlock/journal.h b/engines/sherlock/journal.h new file mode 100644 index 0000000000..64158ff123 --- /dev/null +++ b/engines/sherlock/journal.h @@ -0,0 +1,46 @@ +/* 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 SHERLOCK_JOURNAL_H +#define SHERLOCK_JOURNAL_H + +#include "common/scummsys.h" +#include "common/array.h" + +namespace Sherlock { + +class Journal { +public: + Common::Array _data; + int _count; + int _maxPage; + int _index; + int _sub; + int _up, _down; + int _page; +public: + Journal(); +}; + +} // End of namespace Sherlock + +#endif diff --git a/engines/sherlock/module.mk b/engines/sherlock/module.mk new file mode 100644 index 0000000000..1dfcb3a5af --- /dev/null +++ b/engines/sherlock/module.mk @@ -0,0 +1,22 @@ +MODULE := engines/sherlock + +MODULE_OBJS = \ + scalpel/scalpel.o \ + tattoo/tattoo.o \ + decompress.o \ + detection.o \ + graphics.o \ + journal.o \ + resources.o \ + room.o \ + sherlock.o \ + sprite.o \ + talk.o + +# This module can be built as a plugin +ifdef BUILD_PLUGINS +PLUGIN := 1 +endif + +# Include common rules +include $(srcdir)/rules.mk diff --git a/engines/sherlock/resources.cpp b/engines/sherlock/resources.cpp new file mode 100644 index 0000000000..e59e65abff --- /dev/null +++ b/engines/sherlock/resources.cpp @@ -0,0 +1,219 @@ +/* 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 "sherlock/resources.h" +#include "sherlock/decompress.h" +#include "common/debug.h" + +namespace Sherlock { + +Cache::Cache() { +} + +/** + * Returns true if a given file is currently being cached + */ +bool Cache::isCached(const Common::String &filename) const { + return _resources.contains(filename); +} + +/** + * Loads a file into the cache if it's not already present, and returns it. + * If the file is LZW compressed, automatically decompresses it and loads + * the uncompressed version into memory + */ +void Cache::load(const Common::String &filename) { + // First check if the entry already exists + if (_resources.contains(filename)) + return; + + // Allocate a new cache entry + _resources[filename] = CacheEntry(); + CacheEntry &cacheEntry = _resources[filename]; + + // Open the file for reading + Common::File f; + if (!f.open(filename)) + error("Could not read file - %s", filename.c_str()); + + // Check whether the file is compressed + const char LZW_HEADER[5] = { "LZV\x1a" }; + char header[5]; + f.read(header, 5); + bool isCompressed = !strncmp(header, LZW_HEADER, 5); + f.seek(0); + + if (isCompressed) { + // It's compressed, so decompress the file and store it's data in the cache entry + Common::SeekableReadStream *decompressed = decompressLZ(f); + cacheEntry.resize(decompressed->size()); + decompressed->read(&cacheEntry[0], decompressed->size()); + + delete decompressed; + } else { + // It's not, so read the raw data of the file into the cache entry + cacheEntry.resize(f.size()); + f.read(&cacheEntry[0], f.size()); + } + + f.close(); +} + +Common::SeekableReadStream *Cache::get(const Common::String &filename) const { + // Return a memory stream that encapsulates the data + const CacheEntry &cacheEntry = _resources[filename]; + return new Common::MemoryReadStream(&cacheEntry[0], cacheEntry.size()); +} + +/*----------------------------------------------------------------*/ + +Resources::Resources() { + _resourceIndex = -1; + + addToCache("vgs.lib"); + addToCache("talk.lib"); + addToCache("sequence.txt"); + addToCache("journal.txt"); + addToCache("portrait.lib"); +} + + +/** + * Adds the specified file to the cache. If it's a library file, takes care of + * loading it's index for future use + */ +void Resources::addToCache(const Common::String &filename) { + _cache.load(filename); + + // Check to see if the file is a library + Common::SeekableReadStream *stream = load(filename); + uint32 header = stream->readUint32BE(); + if (header == MKTAG('L', 'I', 'B', 26)) + loadLibraryIndex(filename, stream); + + delete stream; +} + +Common::SeekableReadStream *Resources::load(const Common::String &filename) { + // First check if the file is directly in the cache + if (_cache.isCached(filename)) + return _cache.get(filename); + + // Secondly, iterate through any loaded library file looking for a resource + // that has the same name + LibraryIndexes::iterator i; + for (i = _indexes.begin(); i != _indexes.end(); ++i) { + if ((*i)._value.contains(filename)) { + // Get a stream reference to the given library file + Common::SeekableReadStream *stream = load((*i)._key); + LibraryEntry &entry = (*i)._value[filename]; + _resourceIndex = entry._index; + + stream->seek(entry._offset); + Common::SeekableReadStream *resStream = stream->readStream(entry._size); + + delete stream; + return resStream; + } + } + + // At this point, fall back on a physical file with the given name + Common::File f; + if (!f.open(filename)) + error("Could not load file - %s", filename.c_str()); + + Common::SeekableReadStream *stream = f.readStream(f.size()); + f.close(); + + return stream; +} + +/** + * Loads a specific resource from a given library file + */ +Common::SeekableReadStream *Resources::load(const Common::String &filename, const Common::String &libraryFile) { + // Open up the library for access + Common::SeekableReadStream *libStream = load(libraryFile); + + // Check if the library has already had it's index read, and if not, load it + if (!_indexes.contains(libraryFile)) + loadLibraryIndex(libraryFile, libStream); + + // Extract the data for the specified resource and return it + LibraryEntry &entry = _indexes[libraryFile][filename]; + libStream->seek(entry._offset); + Common::SeekableReadStream *stream = libStream->readStream(entry._size); + + delete libStream; + return stream; +} + + +/** + * Reads in the index from a library file, and caches it's index for later use + */ +void Resources::loadLibraryIndex(const Common::String &libFilename, + Common::SeekableReadStream *stream) { + uint32 offset, nextOffset; + + // Create an index entry + _indexes[libFilename] = LibraryIndex(); + LibraryIndex &index = _indexes[libFilename]; + + // Read in the number of resources + stream->seek(4); + int count = stream->readUint16LE(); + + // Loop through reading in the entries + for (int idx = 0; idx < count; ++idx) { + // Read the name of the resource + char resName[13]; + stream->read(resName, 13); + resName[12] = '\0'; + + // Read the offset + offset = stream->readUint32LE(); + + if (idx == (count - 1)) { + nextOffset = stream->size(); + } else { + // Read the size by jumping forward to read the next entry's offset + stream->seek(13, SEEK_CUR); + nextOffset = stream->readUint32LE(); + stream->seek(-17, SEEK_CUR); + } + + // Add the entry to the index + index[resName] = LibraryEntry(idx, offset, nextOffset - offset); + } +} + +/** + * Returns the index of the last loaded resource in it's given library file. + * This will be used primarily when loading talk files, so the engine can + * update the given conversation number in the journal + */ +int Resources::resouceIndex() const { + return _resourceIndex; +} + +} // End of namespace Sherlock diff --git a/engines/sherlock/resources.h b/engines/sherlock/resources.h new file mode 100644 index 0000000000..bfd2eb300c --- /dev/null +++ b/engines/sherlock/resources.h @@ -0,0 +1,86 @@ +/* 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 SHERLOCK_RESOURCES_H +#define SHERLOCK_RESOURCES_H + +#include "common/array.h" +#include "common/file.h" +#include "common/hashmap.h" +#include "common/hash-str.h" +#include "common/str.h" +#include "common/stream.h" + +namespace Sherlock { + +typedef Common::Array CacheEntry; +typedef Common::HashMap CacheHash; + +struct LibraryEntry { + uint32 _offset, _size; + int _index; + + LibraryEntry() : _index(0), _offset(0), _size(0) {} + LibraryEntry(int index, uint32 offset, uint32 size) : + _index(index), _offset(offset), _size(size) {} +}; +typedef Common::HashMap LibraryIndex; +typedef Common::HashMap LibraryIndexes; + +class SherlockEngine; + +class Cache { +private: + CacheHash _resources; +public: + Cache(); + + bool isCached(const Common::String &filename) const; + + void load(const Common::String &name); + + Common::SeekableReadStream *get(const Common::String &filename) const; +}; + +class Resources { +private: + Cache _cache; + LibraryIndexes _indexes; + int _resourceIndex; + + void loadLibraryIndex(const Common::String &libFilename, Common::SeekableReadStream *stream); +public: + Resources(); + + void addToCache(const Common::String &filename); + + Common::SeekableReadStream *load(const Common::String &filename); + + Common::SeekableReadStream *load(const Common::String &filename, const Common::String &libraryFile); + + int resouceIndex() const; +}; + + +} // End of namespace Sherlock + +#endif diff --git a/engines/sherlock/room.cpp b/engines/sherlock/room.cpp new file mode 100644 index 0000000000..246a316562 --- /dev/null +++ b/engines/sherlock/room.cpp @@ -0,0 +1,32 @@ +/* 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 "sherlock/room.h" + +namespace Sherlock { + +Rooms::Rooms() { + for (int roomNum = 0; roomNum < ROOMS_COUNT; ++roomNum) + Common::fill(&_stats[roomNum][0], &_stats[roomNum][9], false); +} + +} // End of namespace Sherlock diff --git a/engines/sherlock/room.h b/engines/sherlock/room.h new file mode 100644 index 0000000000..46755c1a10 --- /dev/null +++ b/engines/sherlock/room.h @@ -0,0 +1,102 @@ +/* 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 SHERLOCK_ROOM_H +#define SHERLOCK_ROOM_H + +#include "common/scummsys.h" +#include "sherlock/sprite.h" + +namespace Sherlock { + +#define ROOMS_COUNT 63 + +/* +struct RoomBounds { + int x, y, width, height; +}; + +struct BgshapeSub { + uint16 value; +}; + +struct Bgshape { + char name[12]; + char description[41]; + char *textBufferPtr; + byte *seqBufPtr; + Sprite *sprite; + SpriteFrame *spriteFrame; + byte byte05; + byte seqBigCountFlag; + int16 seqIndex; + int16 canimIndex; + int16 x, y; + int16 xIncr, yIncr, + uint16 status; + int16 x2, y2; + int16 width2, height2; + uint16 word02; + uint16 word03; + byte flag; + byte itemValue; + uint16 word01; + uint16 word05; + uint16 stringIndex; + int16 width, height; + uint16 word04; + byte flagsAndIndex; + uint16 frameCount; + byte spriteFlags; + char string1[50]; + byte byte07; + byte byte01; + byte byte02; + int16 boundsX, boundsY; + byte direction; + byte animIndex; + char string2[50]; + byte byte06; + byte seqByte; + uint16 textBufferOfs; + byte byte03; + uint16 framesCopyCount; + byte byte08; + char string3[51]; + uint16 word06; + uint16 word07; + uint16 word08; + uint16 word09; + BgshapeSub subItems[4]; +}; +*/ +class Rooms { +public: + bool _stats[ROOMS_COUNT][9]; + bool _savedStats[ROOMS_COUNT][9]; +public: + Rooms(); +}; + +} // End of namespace Sherlock + +#endif diff --git a/engines/sherlock/scalpel/scalpel.cpp b/engines/sherlock/scalpel/scalpel.cpp new file mode 100644 index 0000000000..11b78946f9 --- /dev/null +++ b/engines/sherlock/scalpel/scalpel.cpp @@ -0,0 +1,40 @@ +/* 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 "sherlock/scalpel/scalpel.h" + +namespace Sherlock { + +namespace Scalpel { + +/** + * Initialises game flags + */ +void ScalpelEngine::initFlags() { + _flags.resize(100 * 8); + _flags[3] = true; // Turn on Alley + _flags[39] = true; // Turn on Baker Street +} + +} // End of namespace Scalpel + +} // End of namespace Scalpel diff --git a/engines/sherlock/scalpel/scalpel.h b/engines/sherlock/scalpel/scalpel.h new file mode 100644 index 0000000000..e9f9aa05a2 --- /dev/null +++ b/engines/sherlock/scalpel/scalpel.h @@ -0,0 +1,45 @@ +/* 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 SHERLOCK_SCALPEL_H +#define SHERLOCK_SCALPEL_H + +#include "sherlock/sherlock.h" + +namespace Sherlock { + +namespace Scalpel { + +class ScalpelEngine : public SherlockEngine { +public: + ScalpelEngine(OSystem *syst, const SherlockGameDescription *gameDesc) : + SherlockEngine(syst, gameDesc) {} + virtual ~ScalpelEngine() {} + + virtual void initFlags(); +}; + +} // End of namespace Scalpel + +} // End of namespace Sherlock + +#endif diff --git a/engines/sherlock/sherlock.cpp b/engines/sherlock/sherlock.cpp new file mode 100644 index 0000000000..a6ae6e215c --- /dev/null +++ b/engines/sherlock/sherlock.cpp @@ -0,0 +1,81 @@ +/* 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 "sherlock/sherlock.h" +#include "sherlock/graphics.h" +#include "common/scummsys.h" +#include "common/debug-channels.h" +#include "engines/util.h" + +namespace Sherlock { + +SherlockEngine::SherlockEngine(OSystem *syst, const SherlockGameDescription *gameDesc) : + Engine(syst), _gameDescription(gameDesc) { + _journal = nullptr; + _res = nullptr; + _rooms = nullptr; + _talk = nullptr; +} + + +SherlockEngine::~SherlockEngine() { + delete _journal; + delete _res; + delete _rooms; + delete _talk; +} + +void SherlockEngine::initialize() { + initGraphics(SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_HEIGHT, false); + + DebugMan.addDebugChannel(kDebugScript, "scripts", "Script debug level"); + + /* + int midiDriver = MidiDriver::detectMusicDriver(MDT_MIDI | MDT_ADLIB | MDT_PREFER_MIDI); + bool native_mt32 = ((midiDriver == MD_MT32) || ConfMan.getBool("native_mt32")); + + MidiDriver *driver = MidiDriver::createMidi(midiDriver); + if (native_mt32) + driver->property(MidiDriver::PROP_CHANNEL_MASK, 0x03FE); + + _midi = new MidiPlayer(this, driver); + _midi->setGM(true); + _midi->setNativeMT32(native_mt32); + */ + + _journal = new Journal(); + _res = new Resources(); + _rooms = new Rooms(); + _talk = new Talk(); + + initFlags(); +} + +Common::Error SherlockEngine::run() { + initialize(); + + // TODO: The rest of the game + + return Common::kNoError; +} + +} // End of namespace Comet diff --git a/engines/sherlock/sherlock.h b/engines/sherlock/sherlock.h new file mode 100644 index 0000000000..a68650c0a9 --- /dev/null +++ b/engines/sherlock/sherlock.h @@ -0,0 +1,91 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#ifndef SHERLOCK_HOLMES_H +#define SHERLOCK_HOLMES_H + +#include "common/scummsys.h" +#include "common/array.h" +#include "common/endian.h" +#include "common/util.h" +#include "common/savefile.h" +#include "common/hash-str.h" +#include "engines/engine.h" +#include "sherlock/journal.h" +#include "sherlock/resources.h" +#include "sherlock/room.h" +#include "sherlock/talk.h" + +namespace Sherlock { + +enum { + kFileTypeHash +}; + +enum { + kDebugScript = 1 << 0 +}; + +enum { + GType_SerratedScalpel = 0, + GType_RoseTattoo = 1 +}; + +#define SHERLOCK_SCREEN_WIDTH 320 +#define SHERLOCK_SCREEN_HEIGHT 200 + +struct SherlockGameDescription; + +class Resource; + +class SherlockEngine : public Engine { +private: + bool detectGame(); + + void initialize(); +public: + const SherlockGameDescription *_gameDescription; + Journal *_journal; + Resources *_res; + Rooms *_rooms; + Talk *_talk; + Common::Array _flags; +public: + SherlockEngine(OSystem *syst, const SherlockGameDescription *gameDesc); + virtual ~SherlockEngine(); + + virtual Common::Error run(); + + virtual void initFlags() = 0; + + int getGameType() const; + uint32 getGameID() const; + uint32 getGameFeatures() const; + Common::Language getLanguage() const; + Common::Platform getPlatform() const; + + Common::String getGameFile(int fileType); +}; + +} // End of namespace Sherlock + +#endif diff --git a/engines/sherlock/sound.h b/engines/sherlock/sound.h new file mode 100644 index 0000000000..f3b34345ef --- /dev/null +++ b/engines/sherlock/sound.h @@ -0,0 +1,39 @@ +/* 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 SHERLOCK_SOUND_H +#define SHERLOCK_SOUND_H + +namespace Sherlock { + +class Sound { +public + void playSound(const char *name); + void cacheSound(const char *name, int index); + void playCachedSound(int index); + void clearCache(); + +}; + +} // End of namespace Sherlock + +#endif diff --git a/engines/sherlock/sprite.cpp b/engines/sherlock/sprite.cpp new file mode 100644 index 0000000000..7aa2fdc71b --- /dev/null +++ b/engines/sherlock/sprite.cpp @@ -0,0 +1,142 @@ +/* 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 "sherlock/sprite.h" +#include "common/debug.h" + +namespace Sherlock { + +/* +struct SpriteFrame { + byte *data; + int width, height; + uint16 flags; + int xofs, yofs; + byte rleMarker; +}; +*/ + +Sprite::Sprite(Common::SeekableReadStream &stream) { + load(stream); +} + +Sprite::~Sprite() { +} + +int Sprite::getFrameCount() { + return _frames.size(); +} + +SpriteFrame *Sprite::getFrame(int index) { + return _frames[index]; +} + +void Sprite::load(Common::SeekableReadStream &stream) { + + while (!stream.eos()) { + + debug("frameNum = %d\n", _frames.size()); + + SpriteFrame *spriteFrame = new SpriteFrame(); + + uint32 startOfs = stream.pos(); + + debug("startOfs = %08X\n", startOfs); + + spriteFrame->frame = NULL; + spriteFrame->width = stream.readUint16LE() + 1; + spriteFrame->height = stream.readUint16LE() + 1; + spriteFrame->flags = stream.readUint16LE(); + stream.readUint16LE(); + + debug("width = %d; height = %d; flags = %04X\n", spriteFrame->width, spriteFrame->height, spriteFrame->flags); + + if (spriteFrame->flags & 0xFF) { + spriteFrame->size = (spriteFrame->width * spriteFrame->height) / 2; + } else if (spriteFrame->flags & 0x0100) { + // this size includes the header size, which we subtract + spriteFrame->size = stream.readUint16LE() - 11; + spriteFrame->rleMarker = stream.readByte(); + } else { + spriteFrame->size = spriteFrame->width * spriteFrame->height; + } + + spriteFrame->data = new byte[spriteFrame->size]; + stream.read(spriteFrame->data, spriteFrame->size); + + decompressFrame(spriteFrame); + + /* + debug("size = %d (%08X)\n", spriteFrame->size, spriteFrame->size); + if (spriteFrame->frame) { + char fn[128]; + sndebug(fn, 128, "%04d.spr", _frames.size()); + FILE *x = fopen(fn, "wb"); + fwrite(spriteFrame->frame->pixels, spriteFrame->frame->w * spriteFrame->frame->h, 1, x); + fclose(x); + } + */ + + _frames.push_back(spriteFrame); + + } + + // debug("Done: %08X\n", stream.pos()); fflush(stdout); + +} + +void Sprite::decompressFrame(SpriteFrame *frame) { + + frame->frame = new Graphics::Surface(); + frame->frame->create(frame->width, frame->height, Graphics::PixelFormat::createFormatCLUT8()); + + if (frame->flags & 0xFF) { + debug("Sprite::decompressFrame() 4-bits/pixel\n"); + debug("TODO\n"); + } else if (frame->flags & 0x0100) { + debug("Sprite::decompressFrame() RLE-compressed; rleMarker = %02X\n", frame->rleMarker); + const byte *src = frame->data; + byte *dst = (byte *)frame->frame->getPixels(); + for (uint16 h = 0; h < frame->height; h++) { + int16 w = frame->width; + while (w > 0) { + if (*src == frame->rleMarker) { + byte rleColor = src[1]; + byte rleCount = src[2]; + src += 3; + w -= rleCount; + while (rleCount--) + *dst++ = rleColor; + } else { + *dst++ = *src++; + w--; + } + } + } + } else { + debug("Sprite::decompressFrame() Uncompressed\n"); + memcpy(frame->data, frame->frame->getPixels(), frame->width * frame->height); + } + +} + +} // End of namespace Sherlock diff --git a/engines/sherlock/sprite.h b/engines/sherlock/sprite.h new file mode 100644 index 0000000000..f56ab588bb --- /dev/null +++ b/engines/sherlock/sprite.h @@ -0,0 +1,56 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#ifndef SHERLOCK_SPRITE_H +#define SHERLOCK_SPRITE_H + +#include "common/stream.h" +#include "common/array.h" +#include "graphics/surface.h" + +namespace Sherlock { + +struct SpriteFrame { + byte *data; + uint32 size; + uint16 width, height; + uint16 flags; + int xofs, yofs; + byte rleMarker; + Graphics::Surface *frame; +}; + +class Sprite { +public: + Sprite(Common::SeekableReadStream &stream); + ~Sprite(); + int getFrameCount(); + SpriteFrame *getFrame(int index); +protected: + Common::Array _frames; + void load(Common::SeekableReadStream &stream); + void decompressFrame(SpriteFrame *frame); +}; + +} // End of namespace Sherlock + +#endif diff --git a/engines/sherlock/talk.cpp b/engines/sherlock/talk.cpp new file mode 100644 index 0000000000..3122aff95f --- /dev/null +++ b/engines/sherlock/talk.cpp @@ -0,0 +1,30 @@ +/* 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 "sherlock/talk.h" + +namespace Sherlock { + +Talk::Talk() { +} + +} // End of namespace Sherlock diff --git a/engines/sherlock/talk.h b/engines/sherlock/talk.h new file mode 100644 index 0000000000..6ffbcdd8d4 --- /dev/null +++ b/engines/sherlock/talk.h @@ -0,0 +1,49 @@ +/* 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 SHERLOCK_TALK_H +#define SHERLOCK_TALK_H + +#include "common/scummsys.h" +#include "common/array.h" + +namespace Sherlock { + +struct TalkHistoryEntry { +private: + int _data[2]; +public: + TalkHistoryEntry() { _data[0] = _data[1] = 0; } + + int &operator[](int idx) { return _data[idx]; } +}; + +class Talk { +public: + Common::Array _history; +public: + Talk(); +}; + +} // End of namespace Sherlock + +#endif diff --git a/engines/sherlock/tattoo/tattoo.cpp b/engines/sherlock/tattoo/tattoo.cpp new file mode 100644 index 0000000000..bed6edb3d4 --- /dev/null +++ b/engines/sherlock/tattoo/tattoo.cpp @@ -0,0 +1,38 @@ +/* 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 "sherlock/tattoo/tattoo.h" + +namespace Sherlock { + +namespace Tattoo { + +/** + * Initialises game flags + */ +void TattooEngine::initFlags() { + _flags.resize(100 * 8); +} + +} // End of namespace Tattoo + +} // End of namespace Scalpel diff --git a/engines/sherlock/tattoo/tattoo.h b/engines/sherlock/tattoo/tattoo.h new file mode 100644 index 0000000000..e2977983f1 --- /dev/null +++ b/engines/sherlock/tattoo/tattoo.h @@ -0,0 +1,45 @@ +/* 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 SHERLOCK_TATTOO_H +#define SHERLOCK_TATTOO_H + +#include "sherlock/sherlock.h" + +namespace Sherlock { + +namespace Tattoo { + +class TattooEngine : public SherlockEngine { +public: + TattooEngine(OSystem *syst, const SherlockGameDescription *gameDesc) : + SherlockEngine(syst, gameDesc) {} + virtual ~TattooEngine() {} + + virtual void initFlags(); +}; + +} // End of namespace Tattoo + +} // End of namespace Sherlock + +#endif diff --git a/engines/sherlock/vdaplayer.h b/engines/sherlock/vdaplayer.h new file mode 100644 index 0000000000..9b755606d5 --- /dev/null +++ b/engines/sherlock/vdaplayer.h @@ -0,0 +1,34 @@ +/* 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 SHERLOCK_VDAPLAYER_H +#define SHERLOCK_VDAPLAYER_H + +namespace Sherlock { + +class VdaPlayer { + +}; + +} // End of namespace Sherlock + +#endif -- cgit v1.2.3