twine.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 TWINE_TWINE_H
#define TWINE_TWINE_H
 
#include "common/platform.h"
#include "common/random.h"
#include "common/rect.h"
#include "engines/advancedDetector.h"
#include "engines/engine.h"
 
#include "engines/metaengine.h"
#include "graphics/managed_surface.h"
#include "graphics/screen.h"
#include "graphics/surface.h"
#include "twine/detection.h"
#include "twine/input.h"
#include "twine/scene/actor.h"
#include "twine/script/script_life.h"
#include "twine/script/script_move.h"
#include "twine/shared.h"
 
namespace TwinE {
 
#define EUROPE_VERSION 0
#define USA_VERSION 1
#define MODIFICATION_VERSION 2
 
#define DEFAULT_FRAMES_PER_SECOND 20
#define DEFAULT_HZ (1000 / DEFAULT_FRAMES_PER_SECOND)
 
#define ORIGINAL_WIDTH 640
#define ORIGINAL_HEIGHT 480
 
static const struct TwinELanguage {
    const char *name;
    const char *id;
    const int voice;
} ListLanguage[] = { // TabLanguage
    {"English", "EN_", 1},
    {"French", "FR_", 2},
    {"German", "DE_", 3},
    {"Spanish", "SP_", 1},
    {"Italian", "IT_", 1},
    {"Portuguese", "", 1}};
 
enum MidiFileType {
    MIDIFILE_NONE,
    MIDIFILE_DOS,
    MIDIFILE_WIN
};
 
enum MovieType {
    CONF_MOVIE_NONE = 0,
    CONF_MOVIE_FLA = 1,
    CONF_MOVIE_FLAWIDE = 2,
    CONF_MOVIE_FLAGIF = 3
};
 
struct ConfigFile {
    int32 _languageId = 0;
    bool FlagDisplayText = false;
    MidiFileType MidiType = MIDIFILE_NONE;
    int32 Version = EUROPE_VERSION;
    int32 Sound = 0;
    int32 Movie = CONF_MOVIE_FLA;
    int32 Fps = 0;
 
    // these settings are not available in the original version
    bool WallCollision = false;
    bool UseAutoSaving = false;
    bool Mouse = true;
 
    // these settings can be changed in-game - and must be persisted
    int32 ShadowMode = 0;
    int32 PolygonDetails = 2;
    bool SceZoom = false;
};
 
class Actor;
class Animations;
class Collision;
class Extra;
class GameState;
class Grid;
class Movements;
class Interface;
class Menu;
class Movies;
class MenuOptions;
class Music;
class Redraw;
class Renderer;
class Resources;
class Scene;
class Screens;
class ScriptLifeV1;
class ScriptMoveV1;
class Holomap;
class Sound;
class Text;
class DebugGrid;
struct Keyboard;
class Debug;
class DebugState;
 
// lba2
class Buggy;
class Dart;
class Rain;
class Wagon;
 
enum class EngineState {
    Menu,
    GameLoop,
    LoadedGame,
    QuitGame
};
 
enum class SceneLoopState {
    Continue = -1,
    ReturnToMenu = 0,
    Finished = 1
};
 
struct ScopedCursor {
    TwinEEngine *_engine;
    ScopedCursor(TwinEEngine *engine);
    ~ScopedCursor();
};
 
class FrameMarker {
private:
    TwinEEngine *_engine;
    uint32 _fps;
    uint32 _start;
public:
    FrameMarker(TwinEEngine *engine, uint32 fps = DEFAULT_FRAMES_PER_SECOND);
    ~FrameMarker();
};
 
class TwineScreen : public Graphics::Screen {
private:
    using Super = Graphics::Screen;
    TwinEEngine *_engine;
    int _lastFrame = -1;
 
public:
    TwineScreen(TwinEEngine *engine);
 
    void update() override;
};
 
 
int32 boundRuleThree(int32 val1, int32 val2, int32 nbstep, int32 step);
 
int32 ruleThree32(int32 value, int32 start, int32 end, int32 t);
 
class TwinEEngine : public Engine {
private:
    int32 _isTimeFreezed = 0;
    int32 _saveFreezedTime = 0;
    int32 _mouseCursorState = 0;
    RealValue _realFalling; // mainLoopVar1
    PauseToken _pauseToken;
    TwineGameType _gameType;
    EngineState _state = EngineState::Menu;
    Common::String _queuedFlaMovie;
 
    Common::RandomSource _rnd;
    Common::Language _gameLang;
 
    void processBookOfBu();
    void processBonusList();
    void processInventoryAction();
    void processOptionsMenu();
 
    void initConfigurations();
    void initAll();
    void introduction();
    void processActorSamplePosition(int32 actorIdx);
    void allocVideoMemory(int32 w, int32 h);
 
    bool runGameEngine();
public:
    TwinEEngine(OSystem *system, Common::Language language, uint32 flagsTwineGameType, Common::Platform platform, TwineGameType gameType);
    ~TwinEEngine() override;
 
    Common::Error run() override;
    bool hasFeature(EngineFeature f) const override;
 
    bool canLoadGameStateCurrently(Common::U32String *msg = nullptr) override { return true; }
    bool canSaveGameStateCurrently(Common::U32String *msg = nullptr) override;
 
    Common::Error loadGameStream(Common::SeekableReadStream *stream) override;
    Common::Error saveGameStream(Common::WriteStream *stream, bool isAutosave = false) override;
 
    int32 toSeconds(int x) const;
    void wipeSaveSlot(int slot);
    SaveStateList getSaveSlots() const;
    void autoSave();
 
    void pushMouseCursorVisible();
    void popMouseCursorVisible();
 
    bool isCDROM() const { return true; /* TODO */}
    bool isLBA1() const { return _gameType == TwineGameType::GType_LBA; }
    bool isLBA2() const { return _gameType == TwineGameType::GType_LBA2; }
    bool isLBASlideShow() const { return _gameType == TwineGameType::GType_LBASHOW; }
    bool isPreview() const { return (_gameFlags & TwinE::TF_PREVIEW) != 0; }
    bool isMod() const { return (_gameFlags & TwinE::TF_MOD) != 0; }
    bool isDotEmuEnhanced() const { return (_gameFlags & TwinE::TF_DOTEMU_ENHANCED) != 0; }
    bool isLba1Classic() const { return (_gameFlags & TwinE::TF_LBA1_CLASSIC) != 0; }
    bool isDemo() const { return (_gameFlags & ADGF_DEMO) != 0; };
    bool isAndroid() const { return _platform == Common::Platform::kPlatformAndroid; };
    const char *getGameId() const;
    Common::Language getGameLang() const;
 
    inline int numHoloPos() const {
        const int maxLocations = isLBA1() ? MAX_HOLO_POS : MAX_HOLO_POS_2;
        return maxLocations;
    }
 
    inline int getMaxLife() const {
        return isLBA1() ? 50 : 255;
    }
 
    bool unlockAchievement(const Common::String &id);
 
    Actor *_actor;
    Animations *_animations;
    Collision *_collision;
    Extra *_extra;
    GameState *_gameState;
    Grid *_grid;
    Movements *_movements;
    Interface *_interface;
    Menu *_menu;
    Movies *_movie;
    MenuOptions *_menuOptions;
    Music *_music;
    Redraw *_redraw;
    Renderer *_renderer;
    Resources *_resources;
    Scene *_scene;
    Screens *_screens;
    Holomap *_holomap;
    Sound *_sound;
    Text *_text;
    Input *_input;
    Buggy *_buggy; // lba2
    Dart *_dart; // lba2
    Rain *_rain; // lba2
    Wagon *_wagon; // lba2
    DebugState *_debugState;
 
    ScriptLife *_scriptLife;
    ScriptMove *_scriptMove;
 
    ConfigFile _cfgfile;
 
    int32 _frameCounter = 0;
    SceneLoopState _sceneLoopState = SceneLoopState::ReturnToMenu; // FlagTheEnd
    int32 timerRef = 0;
 
    int32 _loopInventoryItem = 0;
    int32 _stepFalling = 0;
    uint32 _gameFlags = 0u;
    Common::Platform _platform;
    bool _flagRain = false;
 
    bool _cameraZone = false;
 
    Graphics::ManagedSurface _imageBuffer;
    Graphics::ManagedSurface _workVideoBuffer;
    TwineScreen _frontVideoBuffer;
 
    int width() const;
    int height() const;
 
    // the resolution the game was meant to be played with
    int originalWidth() const;
    int originalHeight() const;
 
    Common::Rect rect() const;
    Common::Rect centerOnScreen(int32 w, int32 h) const;
    Common::Rect centerOnScreenX(int32 w, int32 y, int32 h) const;
 
    void extInitMcga();
    void extInitSvga();
    void testRestoreModeSVGA(bool redraw);
 
    void queueMovie(const char *filename);
 
    void clearScreenMinMax(Common::Rect &rect);
    void adjustScreenMax(Common::Rect &rect, int16 x, int16 y);
 
    int getRandomNumber(uint max = 0x7FFF);
 
    void blitWorkToFront(const Common::Rect &rect);
    void copyBlock(const Common::Rect &rect);
    void restoreFrontBuffer();
    void saveFrontBuffer();
 
    void saveTimer(bool pause);
    void restoreTimer();
 
    bool mainLoop();
 
    bool delaySkip(uint32 time);
 
    void setPalette(const Graphics::Palette &palette, uint startColor = 0u);
 
    void setPalette(uint startColor, uint numColors, const byte *palette);
 
    void copyBlockPhys(int32 left, int32 top, int32 right, int32 bottom);
    void copyBlockPhys(const Common::Rect &rect);
 
    void readKeys();
 
    void drawText(int32 x, int32 y, const Common::String &text, bool center = false, bool bigFont = false, int width = 100);
};
 
inline int TwinEEngine::width() const {
    return _frontVideoBuffer.w;
}
 
inline int TwinEEngine::height() const {
    return _frontVideoBuffer.h;
}
 
inline Common::Rect TwinEEngine::rect() const {
    return Common::Rect(0, 0, _frontVideoBuffer.w - 1, _frontVideoBuffer.h - 1);
}
 
inline int TwinEEngine::originalWidth() const {
    return 640;
}
 
inline int TwinEEngine::originalHeight() const {
    return 480;
}
 
 
} // namespace TwinE
 
#endif