From c813fd25cb052da3367180ede8da03baef97e7ce Mon Sep 17 00:00:00 2001 From: neuromancer Date: Thu, 24 Dec 2020 16:10:32 -0300 Subject: [PATCH] PRIVATE: private-eye skeleton engine --- engines/private/configure.engine | 3 + engines/private/detection.cpp | 43 +++++++++++ engines/private/metaengine.cpp | 22 ++++++ engines/private/module.mk | 19 +++++ engines/private/private.cpp | 121 +++++++++++++++++++++++++++++++ engines/private/private.h | 49 +++++++++++++ 6 files changed, 257 insertions(+) create mode 100644 engines/private/configure.engine create mode 100644 engines/private/detection.cpp create mode 100644 engines/private/metaengine.cpp create mode 100644 engines/private/module.mk create mode 100644 engines/private/private.cpp create mode 100644 engines/private/private.h diff --git a/engines/private/configure.engine b/engines/private/configure.engine new file mode 100644 index 00000000000..92af010f059 --- /dev/null +++ b/engines/private/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 private "Private Eye" no diff --git a/engines/private/detection.cpp b/engines/private/detection.cpp new file mode 100644 index 00000000000..ff82729796a --- /dev/null +++ b/engines/private/detection.cpp @@ -0,0 +1,43 @@ +#include "base/plugins.h" +#include "engines/advancedDetector.h" + +namespace Private { +static const PlainGameDescriptor privateGames[] = { + { "private-eye", "Private Eye" }, + { 0, 0 } +}; + + +static const ADGameDescription gameDescriptions[] = { + { + "private-eye", + 0, + AD_ENTRY1s("game.dat", "7a3eb7d9dedf40680ac3d088524f976e", 190735), + Common::EN_ANY, + Common::kPlatformWindows, + ADGF_NO_FLAGS, + GUIO1(GUIO_NOMIDI) + }, + AD_TABLE_END_MARKER +}; +} // End of namespace Private + +class PrivateMetaEngineDetection : public AdvancedMetaEngineDetection { +public: + PrivateMetaEngineDetection() : AdvancedMetaEngineDetection(Private::gameDescriptions, sizeof(ADGameDescription), Private::privateGames) { + } + + const char *getEngineId() const override { + return "private"; + } + + const char *getName() const override { + return "Private Eye"; + } + + const char *getOriginalCopyright() const override { + return "Copyright (C) Brooklyn Multimedia"; + } +}; + +REGISTER_PLUGIN_STATIC(PRIVATE_DETECTION, PLUGIN_TYPE_ENGINE_DETECTION, PrivateMetaEngineDetection); diff --git a/engines/private/metaengine.cpp b/engines/private/metaengine.cpp new file mode 100644 index 00000000000..bb6777bb7f6 --- /dev/null +++ b/engines/private/metaengine.cpp @@ -0,0 +1,22 @@ +#include "private/private.h" +#include "engines/advancedDetector.h" + +class PrivateMetaEngine : public AdvancedMetaEngine { +public: + const char *getName() const override { + return "private"; + } + + Common::Error createInstance(OSystem *syst, Engine **engine, const ADGameDescription *desc) const override; +}; + +Common::Error PrivateMetaEngine::createInstance(OSystem *syst, Engine **engine, const ADGameDescription *desc) const { + *engine = new Private::PrivateEngine(syst); + return Common::kNoError; +} + +#if PLUGIN_ENABLED_DYNAMIC(PRIVATE) +REGISTER_PLUGIN_DYNAMIC(PRIVATE, PLUGIN_TYPE_ENGINE, PrivateMetaEngine); +#else +REGISTER_PLUGIN_STATIC(PRIVATE, PLUGIN_TYPE_ENGINE, PrivateMetaEngine); +#endif diff --git a/engines/private/module.mk b/engines/private/module.mk new file mode 100644 index 00000000000..14db34da134 --- /dev/null +++ b/engines/private/module.mk @@ -0,0 +1,19 @@ +MODULE := engines/private + +MODULE_OBJS := \ + metaengine.o \ + private.o + +MODULE_DIRS += \ + engines/private + +# This module can be built as a plugin +ifeq ($(ENABLE_QUUX), DYNAMIC_PLUGIN) +PLUGIN := 1 +endif + +# Include common rules +include $(srcdir)/rules.mk + +# Detection objects +DETECT_OBJS += $(MODULE)/detection.o diff --git a/engines/private/private.cpp b/engines/private/private.cpp new file mode 100644 index 00000000000..935aedd6163 --- /dev/null +++ b/engines/private/private.cpp @@ -0,0 +1,121 @@ +#include "common/scummsys.h" + +#include "common/config-manager.h" +#include "common/debug.h" +#include "common/debug-channels.h" +#include "common/error.h" +#include "common/events.h" +#include "common/file.h" +#include "common/fs.h" +#include "common/system.h" + +#include "engines/util.h" + +#include "private/private.h" + +namespace Private { + +PrivateEngine::PrivateEngine(OSystem *syst) + : Engine(syst) { + // Put your engine in a sane state, but do nothing big yet; + // in particular, do not load data from files; rather, if you + // need to do such things, do them from run(). + + // Do not initialize graphics here + // Do not initialize audio devices here + + // However this is the place to specify all default directories + const Common::FSNode gameDataDir(ConfMan.get("path")); + SearchMan.addSubDirectoryMatching(gameDataDir, "sound"); + + // Here is the right place to set up the engine specific debug channels + DebugMan.addDebugChannel(kPrivateDebugExample, "example", "this is just an example for a engine specific debug channel"); + DebugMan.addDebugChannel(kPrivateDebugExample2, "example2", "also an example"); + + // Don't forget to register your random source + _rnd = new Common::RandomSource("private"); + + debug("PrivateEngine::PrivateEngine"); +} + +PrivateEngine::~PrivateEngine() { + debug("PrivateEngine::~PrivateEngine"); + + // Dispose your resources here + delete _rnd; + + // Remove all of our debug levels here + DebugMan.clearAllDebugChannels(); +} + +Common::Error PrivateEngine::run() { + // Initialize graphics using following: + initGraphics(320, 200); + + // You could use backend transactions directly as an alternative, + // but it isn't recommended, until you want to handle the error values + // from OSystem::endGFXTransaction yourself. + // This is just an example template: + //_system->beginGFXTransaction(); + // // This setup the graphics mode according to users seetings + // initCommonGFX(false); + // + // // Specify dimensions of game graphics window. + // // In this example: 320x200 + // _system->initSize(320, 200); + //FIXME: You really want to handle + //OSystem::kTransactionSizeChangeFailed here + //_system->endGFXTransaction(); + + // Create debugger console. It requires GFX to be initialized + Console *console = new Console(this); + setDebugger(console); + + // Additional setup. + debug("PrivateEngine::init"); + + // Your main even loop should be (invoked from) here. + debug("PrivateEngine::go: Hello, World!"); + + // This test will show up if -d1 and --debugflags=example are specified on the commandline + debugC(1, kPrivateDebugExample, "Example debug call"); + + // This test will show up if --debugflags=example or --debugflags=example2 or both of them and -d3 are specified on the commandline + debugC(3, kPrivateDebugExample | kPrivateDebugExample2, "Example debug call two"); + + // Simple main event loop + Common::Event evt; + while (!shouldQuit()) { + g_system->getEventManager()->pollEvent(evt); + g_system->delayMillis(10); + } + + return Common::kNoError; +} + +bool PrivateEngine::hasFeature(EngineFeature f) const { + return + (f == kSupportsReturnToLauncher) || + (f == kSupportsLoadingDuringRuntime) || + (f == kSupportsSavingDuringRuntime); +} + +Common::Error PrivateEngine::loadGameStream(Common::SeekableReadStream *stream) { + Common::Serializer s(stream, nullptr); + syncGameStream(s); + return Common::kNoError; +} + +Common::Error PrivateEngine::saveGameStream(Common::WriteStream *stream, bool isAutosave) { + Common::Serializer s(nullptr, stream); + syncGameStream(s); + return Common::kNoError; +} + +void PrivateEngine::syncGameStream(Common::Serializer &s) { + // Use methods of Serializer to save/load fields + int dummy = 0; + s.syncAsUint16LE(dummy); +} + +} // End of namespace Private diff --git a/engines/private/private.h b/engines/private/private.h new file mode 100644 index 00000000000..c841c834c51 --- /dev/null +++ b/engines/private/private.h @@ -0,0 +1,49 @@ +#ifndef PRIVATE_H +#define PRIVATE_H + +#include "common/random.h" +#include "common/serializer.h" +#include "engines/engine.h" +#include "gui/debugger.h" + +namespace Private { + +class Console; + +// our engine debug channels +enum { + kPrivateDebugExample = 1 << 0, + kPrivateDebugExample2 = 1 << 1 + // next new channel must be 1 << 2 (4) + // the current limitation is 32 debug channels (1 << 31 is the last one) +}; + +class PrivateEngine : public Engine { +private: + // We need random numbers + Common::RandomSource *_rnd; +public: + PrivateEngine(OSystem *syst); + ~PrivateEngine(); + + Common::Error run() override; + bool hasFeature(EngineFeature f) const override; + bool canLoadGameStateCurrently() override { return true; } + bool canSaveGameStateCurrently() override { return true; } + Common::Error loadGameStream(Common::SeekableReadStream *stream) override; + Common::Error saveGameStream(Common::WriteStream *stream, bool isAutosave = false) override; + void syncGameStream(Common::Serializer &s); +}; + +// Example console class +class Console : public GUI::Debugger { +public: + Console(PrivateEngine *vm) { + } + virtual ~Console(void) { + } +}; + +} // End of namespace Quux + +#endif