PRIVATE: private-eye skeleton engine

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

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);

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

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

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

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