zvision.h

/* 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;
}
 
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;
 
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);
 
    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:
    Common::Error initialize();
    void initFonts();
 
    void initializePath(const Common::FSNode &gamePath) override;
 
    void parseStrFile(const Common::String &fileName);
 
    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