alcachofa.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 ALCACHOFA_H
#define ALCACHOFA_H
 
#include "common/system.h"
#include "common/error.h"
#include "common/fs.h"
#include "common/hash-str.h"
#include "common/random.h"
#include "common/serializer.h"
#include "common/util.h"
#include "engines/engine.h"
#include "engines/savestate.h"
#include "graphics/screen.h"
 
#include "alcachofa/detection.h"
#include "alcachofa/camera.h"
#include "alcachofa/input.h"
#include "alcachofa/sounds.h"
#include "alcachofa/player.h"
#include "alcachofa/scheduler.h"
#include "alcachofa/console.h"
#include "alcachofa/game.h"
 
namespace Alcachofa {
 
class IDebugHandler;
class IRenderer;
class DrawQueue;
class World;
class Script;
class GlobalUI;
class Menu;
class Game;
struct AlcachofaGameDescription;
 
constexpr int16 kSmallThumbnailWidth = 160; // for ScummVM
constexpr int16 kSmallThumbnailHeight = 120;
// the in-game save thumbnail size is determined by engine verison
 
namespace SaveVersion {
    static constexpr const Common::Serializer::Version kInitial = 0;
    static constexpr const Common::Serializer::Version kWithEngineV10 = 1;
}
static constexpr const Common::Serializer::Version kCurrentSaveVersion = SaveVersion::kWithEngineV10;
 
class MySerializer : public Common::Serializer {
public:
    MySerializer(Common::SeekableReadStream *in, Common::WriteStream *out) : Common::Serializer(in, out) {}
 
    Common::SeekableReadStream &readStream() {
        assert(isLoading() && _loadStream != nullptr);
        return *_loadStream;
    }
 
    Common::WriteStream &writeStream() {
        assert(isSaving() && _saveStream != nullptr);
        return *_saveStream;
    }
};
 
class Config {
public:
    static constexpr const uint8 kMaxCursor = 3;
 
    inline bool &subtitles() { return _subtitles; }
    inline bool &highQuality() { return _highQuality; }
    inline bool &bits32() { return _bits32; }
    inline bool &texFilter() { return _texFilter; }
    inline uint8 &musicVolume() { return _musicVolume; }
    inline uint8 &speechVolume() { return _speechVolume; }
    inline uint8 &cursor() { return _cursor; } // only used in V2
 
    static void registerDefaults();
    void loadFromScummVM();
    void saveToScummVM();
 
private:
    bool
        _subtitles = true,
        _highQuality = true,
        _bits32 = true,
        _texFilter = true;
    uint8
        _musicVolume = 255,
        _speechVolume = 255,
        _cursor = 0;
};
 
class AlcachofaEngine : public Engine {
protected:
    // Engine APIs
    Common::Error run() override;
public:
    AlcachofaEngine(OSystem *syst, const AlcachofaGameDescription *gameDesc);
    ~AlcachofaEngine() override;
 
    inline EngineVersion version() const { return gameDescription().engineVersion; }
    inline bool isV1() const { return gameDescription().isVersionBetween(10, 19); }
    inline bool isV2() const { return gameDescription().isVersionBetween(20, 29); }
    inline bool isV20() const { return gameDescription().isVersionBetween(20, 20); }
    inline bool isV3() const { return gameDescription().isVersionBetween(30, 39); }
 
    inline const AlcachofaGameDescription &gameDescription() const { return *_gameDescription; }
    inline IRenderer &renderer() { return *_renderer; }
    inline DrawQueue &drawQueue() { return *_drawQueue; }
    inline Camera &camera() { return *_camera; }
    inline Input &input() { return _input; }
    inline Sounds &sounds() { return _sounds; }
    inline Player &player() { return *_player; }
    inline World &world() { return _world; }
    inline Script &script() { return *_script; }
    inline GlobalUI &globalUI() { return *_globalUI; }
    inline Menu &menu() { return *_menu; }
    inline Scheduler &scheduler() { return _scheduler; }
    inline Console &console() { return *_console; }
    inline Game &game() { return *_game; }
    inline Config &config() { return _config; }
    inline bool isDebugModeActive() const { return _debugHandler != nullptr; }
 
    template<class T> inline T &cameraAs() {
        auto result = dynamic_cast<T *>(_camera.get());
        scumm_assert(result != nullptr);
        return *result;
    }
    inline CameraV1 &cameraV1() { return cameraAs<CameraV1>(); }
    inline CameraV3 &cameraV3() { return cameraAs<CameraV3>(); }
 
    uint32 getMillis() const;
    void setMillis(uint32 newMillis);
    void pauseEngineIntern(bool pause) override;
    void playVideo(int32 videoId);
    void fadeExit();
    void setDebugMode(DebugMode debugMode, int32 param);
 
    uint32 getFeatures() const;
    Common::String getGameId() const;
 
    bool hasFeature(EngineFeature f) const override {
        return
            (f == kSupportsLoadingDuringRuntime) ||
            (f == kSupportsSavingDuringRuntime) ||
            (f == kSupportsReturnToLauncher);
    };
 
    bool isInSpecialGameLoop() const { return !_eventLoopSemaphore.isReleased(); }
    bool canLoadGameStateCurrently(Common::U32String *msg = nullptr) override;
    bool canSaveGameStateCurrently(Common::U32String *msg = nullptr) override {
        return canLoadGameStateCurrently(msg);
    }
 
    Common::String getSaveStatePattern();
    Common::Error syncGame(MySerializer &s);
    Common::Error saveGameStream(Common::WriteStream *stream, bool isAutosave = false) override {
        assert(stream != nullptr);
        MySerializer s(nullptr, stream);
        return syncGame(s);
    }
    Common::Error loadGameStream(Common::SeekableReadStream *stream) override {
        assert(stream != nullptr);
        MySerializer s(stream, nullptr);
        return syncGame(s);
    }
    bool syncThumbnail(MySerializer &s, Graphics::ManagedSurface *thumbnail);
    void getSavegameThumbnail(Graphics::Surface &thumbnail);
 
private:
    bool tryLoadFromLauncher();
 
    const AlcachofaGameDescription *_gameDescription;
    Console *_console = new Console();
    Common::ScopedPtr<IDebugHandler> _debugHandler;
    Common::ScopedPtr<IRenderer> _renderer;
    Common::ScopedPtr<DrawQueue> _drawQueue;
    Common::ScopedPtr<Script> _script;
    Common::ScopedPtr<Player> _player;
    Common::ScopedPtr<GlobalUI> _globalUI;
    Common::ScopedPtr<Menu> _menu;
    Common::ScopedPtr<Game> _game;
    Common::ScopedPtr<Camera> _camera;
    World _world;
    Input _input;
    Sounds _sounds;
    Scheduler _scheduler;
    Config _config;
 
    FakeSemaphore _eventLoopSemaphore; // for special states like playVideo and fadeExit
    uint32 _timeNegOffset = 0, _timePosOffset = 0;
    uint32 _timeBeforePause = 0;
};
 
extern AlcachofaEngine *g_engine;
#define SHOULD_QUIT ::Alcachofa::g_engine->shouldQuit()
 
} // End of namespace Alcachofa
 
#endif // ALCACHOFA_H