asylum.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 ASYLUM_ASYLUM_H
#define ASYLUM_ASYLUM_H

#include "common/file.h"
#include "common/language.h"
#include "common/random.h"
#include "common/rect.h"
#include "common/scummsys.h"
#include "common/serializer.h"
#include "common/system.h"

#include "engines/advancedDetector.h"
#include "engines/engine.h"

#include "asylum/resources/data.h"

#include "asylum/detection.h"
#include "asylum/eventhandler.h"
#include "asylum/shared.h"

struct ADGameDescription;

namespace Asylum {

class Cursor;
class Encounter;
class Menu;
class Puzzles;
class ResourceManager;
class Savegame;
class Scene;
class Screen;
class ScriptManager;
class Special;
class Speech;
class Sound;
class Text;
class VideoPlayer;

extern const char *const engineKeyMapId;
extern const char *const resviewerKeyMapId;

class AsylumEngine: public Engine, public Common::Serializable {
protected:
    // Engine APIs
    virtual Common::Error run() override;
    virtual bool hasFeature(EngineFeature f) const override;

public:
    enum StartGameType {
        kStartGamePlayIntro,
        kStartGameLoad,
        kStartGameScene
    };

    AsylumEngine(OSystem *system, const ADGameDescription *gd);
    virtual ~AsylumEngine();

    bool startGame(ResourcePackId sceneId, StartGameType type);

    void restart();

    void handleEvents();

    void switchScene(ResourcePackId sceneId) { (void)startGame(sceneId, kStartGameScene); }

    uint32 getTick() { return _system->getMillis() + _tickOffset; }

    void setTick(uint32 offset) { _tickOffset = offset - _system->getMillis(); }

    void reset();

    uint32 screenUpdateCount;
    uint32 lastScreenUpdate;

    // Game
    Cursor          *cursor()    { return _cursor; }
    Encounter       *encounter() { return _encounter; }
    Menu            *menu()      { return _menu; }
    ResourceManager *resource()  { return _resource; }
    Savegame        *savegame()  { return _savegame; }
    Scene           *scene()     { return _scene; }
    Screen          *screen()    { return _screen; }
    ScriptManager   *script()    { return _script; }
    Special         *special()   { return _special; }
    Speech          *speech()    { return _speech; }
    Sound           *sound()     { return _sound; }
    Text            *text()      { return _text; }
    VideoPlayer     *video()     { return _video; }

    SharedData      *data()      { return &_data; }
    Puzzles         *puzzles()   { return _puzzles; }

    // Flags
    void setGameFlag(GameFlag flag);
    void clearGameFlag(GameFlag flag);
    void toggleGameFlag(GameFlag flag);
    bool isGameFlagSet(GameFlag flag) const;
    bool isGameFlagNotSet(GameFlag flag) const;
    bool areGameFlagsSet(uint from, uint to) const;
    void resetFlags() { memset(_gameFlags, 0, sizeof(_gameFlags)); }

    // Misc
    uint getRandom(uint max) { return max ? _rnd->getRandomNumber(max - 1) : 0; }
    uint getRandomBit()      { return _rnd->getRandomBit(); }

    bool rectContains(const int16 (*rectPtr)[4], const Common::Point &p) const;

    // Steam achievements
    void unlockAchievement(const Common::String &id);
    void checkAchievements();

    void switchEventHandler(EventHandler *handler);

    void notify(AsylumEventType type, int32 param1 = 0, int32 param2 = 0);

    void updateReverseStereo();

    // Serializable
    void saveLoadWithSerializer(Common::Serializer &s) override;

    bool checkGameVersion(const char *version) { return !strcmp(_gameDescription->extra, version); }
    bool isAltDemo() { return Common::File::exists("asylum.dat"); }
    Common::Language getLanguage() { return _gameDescription->language; }
    Common::String getTargetName() { return _targetName; }
    Common::String getMoviesFileName() { return Common::String::format("%s.movies", _targetName.c_str()); }
    bool isMenuVisible() { return _handler == (EventHandler *)_menu; }
    EventHandler *getEventHandler() { return _handler; }

    // Save/Load
    int getAutosaveSlot() const override { return getMetaEngine()->getAutosaveSlot(); }
    bool canLoadGameStateCurrently(Common::U32String *msg = nullptr) override;
    Common::Error loadGameState(int slot) override;
    bool canSaveGameStateCurrently(Common::U32String *msg = nullptr) override;
    bool canSaveAutosaveCurrently() override;
    Common::Error saveGameState(int slot, const Common::String &desc, bool isAutosave = false) override;

private:
    const ADGameDescription *_gameDescription;

    // Misc
    Common::RandomSource *_rnd;

    // Game
    Cursor          *_cursor;
    Encounter       *_encounter;
    Menu            *_menu;
    ResourceManager *_resource;
    Savegame        *_savegame;
    Scene           *_scene;
    Screen          *_screen;
    ScriptManager   *_script;
    Special         *_special;
    Speech          *_speech;
    Sound           *_sound;
    Text            *_text;
    VideoPlayer     *_video;

    // Current EventHandler class instance
    EventHandler *_handler;

    // Game data
    Puzzles     *_puzzles;
    SharedData   _data;
    uint32       _gameFlags[130];
    bool         _introPlayed;
    int32        _tickOffset;

    void updateMouseCursor();
    void processDelayedEvents();

    void playIntro();

    // Debug
    friend class Console;
    Scene *_previousScene;
    ResourcePackId _delayedSceneIndex;
    int32 _delayedVideoIndex;
};

} // namespace Asylum

#endif // ASYLUM_ASYLUM_H