Initial commit

engines/zvision/zvision.h

@@ -0,0 +1,310 @@
+/* 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 3 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, see <http://www.gnu.org/licenses/>.
+ *
+ *
+ */
+
+#ifndef ZVISION_ZVISION_H
+#define ZVISION_ZVISION_H
+
+#include "common/events.h"
+#include "common/random.h"
+#include "common/system.h"
+#include "engines/engine.h"
+#include "graphics/pixelformat.h"
+#include "gui/debugger.h"
+#include "zvision/detection.h"
+#include "zvision/core/clock.h"
+
+namespace Common {
+class Keymap;
+}
+
+namespace Video {
+class VideoDecoder;
+}
+
+/**
+ * This is the namespace of the ZVision engine.
+ *
+ * Status of this engine: complete
+ *
+ * Games using this engine:
+ * - Zork Nemesis: The Forbidden Lands
+ * - Zork: Grand Inquisitor
+ *
+ */
+namespace ZVision {
+
+struct ZvisionGameDescription;
+
+class Console;
+class ScriptManager;
+class RenderManager;
+class CursorManager;
+class StringManager;
+class FileManager;
+class SaveManager;
+class RLFDecoder;
+class MenuManager;
+class SubtitleManager;
+class TextRenderer;
+class Subtitle;
+class MidiManager;
+class VolumeManager;
+
+struct ScreenLayout {
+	Common::Rect screenArea;  // Original screen resolution
+	Common::Rect menuArea;  // Menu display area, relative to original screen
+	Common::Rect workingArea;   // Playfield & video playback area, relative to original screen
+	Common::Rect textArea;  // Subtitle & message area, relative to original screen
+};
+
+// NB Footage of original DOS Nemesis engine indicates playfield was centrally placed on screen.
+// Subtitle scripts, however, suggest playfield was higher up, otherwise they run off the bottom of the screen.
+// This could just be an error in the scripts or an artefact of the original game's development, so we will continue to use as-released central placement.
+
+static const ScreenLayout nemesisLayout {
+	Common::Rect(640, 480), // Screen
+	Common::Rect(Common::Point(64, 0), 512, 32), // Menu
+	Common::Rect(Common::Point(64, 80), 512, 320), // Working; aspect ratio 1.6
+	Common::Rect(Common::Point(64, 420), 512, 60) // Text
+};
+
+static const ScreenLayout zgiLayout {
+	Common::Rect(640, 480), // Screen
+	Common::Rect(Common::Point(0, 0), 640, 32), // Menu
+	Common::Rect(Common::Point(0, 68), 640, 344), // Working; aspect ratio 1.86
+	Common::Rect(Common::Point(0, 412), 640, 68) // Text
+};
+
+enum {
+
+	ROTATION_SCREEN_EDGE_OFFSET = 60,
+	MAX_ROTATION_SPEED = 400, // Pixels per second
+
+	KEYBUF_SIZE = 20
+};
+
+enum ZVisionAction {
+	kZVisionActionNone,
+	kZVisionActionUp,
+	kZVisionActionDown,
+	kZVisionActionLeft,
+	kZVisionActionRight,
+	kZVisionActionSave,
+	kZVisionActionRestore,
+	kZVisionActionQuit,
+	kZVisionActionPreferences,
+	kZVisionActionShowFPS,
+	kZVisionActionSkipCutscene,
+
+	kZVisionActionCount
+};
+
+extern const char *mainKeymapId;
+extern const char *gameKeymapId;
+extern const char *cutscenesKeymapId;
+
+class ZVision : public Engine {
+public:
+	ZVision(OSystem *syst, const ZVisionGameDescription *gameDesc);
+	~ZVision() override;
+
+public:
+	const Graphics::PixelFormat _resourcePixelFormat;
+	const Graphics::PixelFormat _screenPixelFormat;
+
+private:
+	const ZVisionGameDescription *_gameDescription;
+
+
+	// We need random numbers
+	Common::RandomSource *_rnd;
+
+	// Managers
+	ScriptManager *_scriptManager;
+	RenderManager *_renderManager;
+	CursorManager *_cursorManager;
+	StringManager *_stringManager;
+	TextRenderer *_textRenderer;
+	MidiManager *_midiManager;
+	FileManager *_fileManager;
+	SaveManager *_saveManager;
+	MenuManager *_menu;
+	SubtitleManager *_subtitleManager;
+	VolumeManager *_volumeManager;
+
+	// Clock
+	Clock _clock;
+
+	// Audio ID
+	int _audioId;
+
+	// To prevent allocation every time we process events
+	Common::Event _event;
+
+	Common::Keymap *_gameKeymap, *_cutscenesKeymap;
+
+	int _frameRenderDelay;
+	int _renderedFrameCount;
+	int _fps;
+	int16 _mouseVelocity;
+	int16 _keyboardVelocity;
+	bool _doubleFPS;
+	bool _widescreen;
+	bool _videoIsPlaying;
+	bool _breakMainLoop = false;
+
+	uint8 _cheatBuffer[KEYBUF_SIZE];
+
+public:
+	Common::Error run() override;
+	void pauseEngineIntern(bool pause) override;
+
+	ZVisionGameId getGameId() const;
+	Common::Language getLanguage() const;
+	uint32 getFeatures() const;
+
+	ScriptManager *getScriptManager() const {
+		return _scriptManager;
+	}
+	RenderManager *getRenderManager() const {
+		return _renderManager;
+	}
+	CursorManager *getCursorManager() const {
+		return _cursorManager;
+	}
+	FileManager *getFileManager() const {
+		return _fileManager;
+	}
+	SaveManager *getSaveManager() const {
+		return _saveManager;
+	}
+	StringManager *getStringManager() const {
+		return _stringManager;
+	}
+	TextRenderer *getTextRenderer() const {
+		return _textRenderer;
+	}
+	MidiManager *getMidiManager() const {
+		return _midiManager;
+	}
+	MenuManager *getMenuManager() const {
+		return _menu;
+	}
+	SubtitleManager *getSubtitleManager() const {
+		return _subtitleManager;
+	}
+	VolumeManager *getVolumeManager() const {
+		return _volumeManager;
+	}
+	Common::Keymap *getGameKeymap() const {
+		return _gameKeymap;
+	}
+	Common::RandomSource *getRandomSource() const {
+		return _rnd;
+	}
+	int16 getKeyboardVelocity() const {
+		return _keyboardVelocity;
+	}
+	int16 getMouseVelocity() const {
+		return _mouseVelocity;
+	}
+
+	uint8 getZvisionKey(Common::KeyCode scummKeyCode);
+
+	void startClock() {
+		_clock.start();
+	}
+
+	void stopClock() {
+		_clock.stop();
+	}
+
+	void initScreen(bool hiRes = false);
+
+	/**
+	 * Play a video until it is finished. This is a blocking call. It will call
+	 * _clock.stop() when the video starts and _clock.start() when the video finishes.
+	 * It will also consume all events during video playback.
+	 *
+	 * @param videoDecoder    The video to play
+	 * @param destRect        Where to put the video. (In working window coords)
+	 * @param srcRect         What subset of video to blit to destRect (In video frame coords)  // TODO implement
+	 * @param skippable       If true, the video can be skipped at any time using [Spacebar]
+	 */
+	void playVideo(Video::VideoDecoder &videoDecoder, Common::Rect destRect = Common::Rect(0, 0, 0, 0), bool skippable = true, uint16 sub = 0, Common::Rect srcRect = Common::Rect(0, 0, 0, 0));
+	Video::VideoDecoder *loadAnimation(const Common::Path &fileName);
+
+	void setRenderDelay(uint);
+	bool canRender();
+	static void fpsTimerCallback(void *refCon);
+	void fpsTimer();
+	int getFPS() const {
+		return _fps;
+	}
+
+	bool isWidescreen() {
+		return _widescreen;
+	}
+
+	void syncSoundSettings() override;
+
+	void loadSettings();
+	void saveSettings();
+
+	bool quit(bool askFirst = true, bool streaming = false);
+
+	// Engine features
+	bool hasFeature(EngineFeature f) const override;
+	bool canLoadGameStateCurrently(Common::U32String *msg = nullptr) override;
+	bool canSaveGameStateCurrently(Common::U32String *msg = nullptr) override;
+	Common::Error loadGameState(int slot) override;
+	Common::Error saveGameState(int slot, const Common::String &desc, bool isAutosave = false) override;
+
+	// Used to update cursor on a location change
+	void onMouseMove() {
+		onMouseMove(_system->getEventManager()->getMousePos());
+	}
+
+private:
+	void initialize();
+	void initFonts();
+
+	void initializePath(const Common::FSNode &gamePath) override;
+
+	void parseStrFile(const Common::String &fileName);
+
+	/** Called every frame from ZVision::run() to process any events from EventMan */
+	void processEvents();
+
+	void onMouseMove(const Common::Point &pos);
+
+	void registerDefaultSettings();
+
+	void cheatCodes(uint8 key);
+	void pushKeyToCheatBuf(uint8 key);
+	bool checkCode(const char *code);
+	uint8 getBufferedKey(uint8 pos);
+};
+
+} // End of namespace ZVision
+
+#endif