base_game.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/>.
 *
 */

/*
 * This file is based on WME Lite.
 * http://dead-code.org/redir.php?target=wmelite
 * Copyright (c) 2011 Jan Nedoma
 */

#ifndef WINTERMUTE_BASE_GAME_H
#define WINTERMUTE_BASE_GAME_H

#include "engines/wintermute/base/base_object.h"
#include "engines/wintermute/base/base_game_custom_actions.h"
#include "engines/wintermute/base/base_string_table.h"
#include "engines/wintermute/ext/plugin_event.h"
#include "engines/wintermute/persistent.h"
#include "engines/wintermute/coll_templ.h"
#include "engines/wintermute/debugger.h"
#if EXTENDED_DEBUGGER_ENABLED
#include "engines/wintermute/base/scriptables/debuggable/debuggable_script_engine.h"
#endif

#include "common/events.h"
#include "common/random.h"

namespace Wintermute {

typedef void (*ENGINE_LOG_CALLBACK)(char *text, bool result, void *data);

class BaseSoundMgr;
class BaseFader;
class BaseFont;
class BaseFileManager;
class BaseTransitionMgr;
class BaseFontStorage;
class BaseGameMusic;
class BaseQuickMsg;
class BaseViewport;
class BaseRenderer;
class BaseRegistry;
class BaseSurfaceStorage;
class BaseKeyboardState;
class BaseGameSettings;
class BaseAccessMgr;
class ScEngine;
class SXMath;
class SXDirectory;
class UIWindow;
class VideoPlayer;
class VideoTheoraPlayer;
class SaveThumbHelper;

#ifdef ENABLE_WME3D
class BaseRenderer3D;
struct FogParameters;
#endif

#define NUM_MUSIC_CHANNELS 5

class BaseGame : public BaseObject {
public:


    DECLARE_PERSISTENT(BaseGame, BaseObject)

    virtual bool onScriptShutdown(ScScript *script);

    virtual bool getLayerSize(int *LayerWidth, int *LayerHeight, Common::Rect32 *viewport, bool *customViewport);
#ifdef ENABLE_WME3D
    virtual uint32 getAmbientLightColor();
    virtual bool getFogParams(bool *fogEnabled, uint32 *fogColor, float *start, float *end);
#endif
    virtual BaseObject *getNextAccessObject(BaseObject *currObject);
    virtual BaseObject *getPrevAccessObject(BaseObject *currObject);

    virtual bool onActivate(bool activate, bool refreshMouse);
    virtual bool onMouseLeftDown();
    virtual bool onMouseLeftUp();
    virtual bool onMouseLeftDblClick();
    virtual bool onMouseRightDblClick();
    virtual bool onMouseRightDown();
    virtual bool onMouseRightUp();
    virtual bool onMouseMiddleDown();
    virtual bool onMouseMiddleUp();
    virtual bool onPaint();
    virtual bool onWindowClose();

    bool isLeftDoubleClick();
    bool isRightDoubleClick();

    bool _autorunDisabled;
    uint32 _lastMiniUpdate;
    bool _miniUpdateEnabled;
    virtual bool miniUpdate();

    void getMousePos(Common::Point32 *pos);
    Common::Rect32 _mouseLockRect;

    bool _shuttingDown;

    virtual bool displayDebugInfo();
    bool _debugShowFPS;

    bool _suspendedRendering;
    int32 _soundBufferSizeSec;
    virtual bool renderShadowGeometry();

    TTextEncoding _textEncoding;
    bool _textRTL;

    BaseSprite *_loadingIcon;
    int32 _loadingIconX;
    int32 _loadingIconY;
    int32 _loadingIconPersistent;

    virtual bool resetContent();

    void DEBUG_DumpClassRegistry();
    bool setWaitCursor(const char *filename);

    char *_localSaveDir;
    bool _saveDirChecked;

#ifdef ENABLE_WME3D
    bool _supportsRealTimeShadows;
    TShadowType _maxShadowType;
    bool setMaxShadowType(TShadowType maxShadowType);
    virtual TShadowType getMaxShadowType(BaseObject *object = nullptr);
#endif

    bool _indicatorDisplay;
    uint32 _indicatorColor;
    int32 _indicatorProgress;
    int32 _indicatorX;
    int32 _indicatorY;
    int32 _indicatorWidth;
    int32 _indicatorHeight;

    bool _richSavedGames;
    char *_savedGameExt;

    int32 _editorResolutionWidth;
    int32 _editorResolutionHeight;

    char *_loadImageName;
    char *_saveImageName;
    int32 _saveImageX;
    int32 _saveImageY;
    int32 _loadImageX;
    int32 _loadImageY;
    BaseSurface *_saveLoadImage;
    bool _hasDrawnSaveLoadImage;

    bool displayIndicator();
#ifdef ENABLE_FOXTAIL
    bool displayIndicatorFoxTail();
#endif
    uint32 _thumbnailWidth;
    uint32 _thumbnailHeight;

    bool _reportTextureFormat;

    void setEngineLogCallback(ENGINE_LOG_CALLBACK callback = nullptr, void *data = nullptr);
    ENGINE_LOG_CALLBACK _engineLogCallback;
    void *_engineLogCallbackData;

    bool _editorMode;
    void getOffset(int *offsetX, int *offsetY) const;
    void setOffset(int32 offsetX, int32 offsetY);
    int getSequence();
    int32 _offsetY;
    int32 _offsetX;
    float _offsetPercentX;
    float _offsetPercentY;
    BaseObject *_mainObject;
    bool initInput();
    bool initLoop();
    uint32 _currentTime{};
    uint32 _deltaTime;
    BaseFont *_systemFont;
    BaseFont *_videoFont;
    bool initConfManSettings();
    bool initRenderer();
    bool initialize1();
    bool initialize2();
    bool initialize3();
    BaseAccessMgr *_accessMgr;
    BaseFileManager *_fileManager;
    BaseTransitionMgr *_transMgr;

    void LOG(bool res, const char *fmt, ...);
    BaseRenderer *_renderer;
#ifdef ENABLE_WME3D
    BaseRenderer3D *_renderer3D;
    bool _playing3DGame;
#endif
    BaseSoundMgr *_soundMgr;
#if EXTENDED_DEBUGGER_ENABLED
    DebuggableScEngine *_scEngine;
#else
    ScEngine *_scEngine;
#endif
    BaseScriptable *_mathClass;
    BaseScriptable *_directoryClass;
    BaseSurfaceStorage *_surfaceStorage;
    BaseFontStorage *_fontStorage;
    BaseGame(const Common::String &targetName);
    ~BaseGame() override;
    void debugDisable();
    void debugEnable(const char *filename = nullptr);
    bool _debugMode;
    void *_debugLogFile;
    int32 _sequence;
    virtual bool loadFile(const char *filename);
    virtual bool loadBuffer(char *buffer, bool complete = true);
    BaseArray<BaseQuickMsg *> _quickMessages;
    BaseArray<UIWindow *> _windows;
    BaseArray<BaseViewport *> _viewportStack;
    int32 _viewportSP;
    bool _mouseLeftDown;
    bool _mouseRightDown;
    bool _mouseMidlleDown;
    BaseStringTable *_stringTable;

    int _settingsResWidth;
    int _settingsResHeight;
    bool _settingsRequireAcceleration;
    bool _settingsAllowWindowed;
    bool _settingsAllowAdvanced;
    bool _settingsAllowAccessTab;
    bool _settingsAllowAboutTab;
    bool _settingsRequireSound;
    bool _settingsAllowDesktopRes;
    int32 _settingsTLMode;
    char *_settingsGameFile;
    BaseFader *_fader;
    bool _suppressScriptErrors;

    bool invalidateDeviceObjects() override;
    bool restoreDeviceObjects() override;

    virtual bool externalCall(ScScript *script, ScStack *stack, ScStack *thisStack, char *name);

    // scripting interface
    ScValue *scGetProperty(const char *name) override;
    bool scSetProperty(const char *name, ScValue *value) override;
    bool scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack, const char *name) override;
    const char *scToString() override;

    // compatibility bits
    bool _compatKillMethodThreads;

private:
    // FPS stuff
    uint32 _lastTime;
    uint32 _fpsTime;
    uint32 _framesRendered;

public:
    uint32 _surfaceGCCycleTime;
    bool _smartCache; // RO
    bool _videoSubtitles;
    bool _subtitles; // RO
    uint32 _musicStartTime[NUM_MUSIC_CHANNELS];
    bool _compressedSavegames;
    int32 _scheduledLoadSlot;
    bool _loading;
    bool _personalizedSave;
    static bool emptySaveSlot(int slot);
    static bool isSaveSlotUsed(int slot);
    static bool getSaveSlotDescription(int slot, Common::String &desc);
    static void getSaveSlotTimestamp(int slot, TimeDate *time);
    static bool getSaveSlotFilename(int slot, Common::String &desc);
    void setWindowTitle();
    bool handleMouseWheel(int32 delta) override;
    bool _quitting;
    virtual bool getVersion(byte *verMajor, byte *verMinor, byte *extMajor, byte *extMinor);
    bool handleKeypress(Common::Event *event, bool printable = false) override;
    virtual void handleKeyRelease(Common::Event *event);
    bool handleAccessKey(Common::Event *event, bool printable);
    virtual bool handleCustomActionStart(BaseGameCustomAction action);
    virtual bool handleCustomActionEnd(BaseGameCustomAction action);
    int32 _freezeLevel;
    bool unfreeze();
    bool freeze(bool includingMusic = true);
    bool focusWindow(UIWindow *window);
    VideoPlayer *_videoPlayer;
    VideoTheoraPlayer *_theoraPlayer;
    bool _loadInProgress;
    UIWindow *_focusedWindow;
    bool _editorForceScripts;
    static void afterLoadRegion(void *region, void *data);
    static void afterLoadSubFrame(void *subframe, void *data);
    static void afterLoadSound(void *sound, void *data);
    static void afterLoadFont(void *font, void *data);
#ifdef ENABLE_WME3D
    static void afterLoadXModel(void *model, void *data);
#endif
    static void afterLoadScript(void *script, void *data);
    static void afterLoadScene(void *scene, void *data);
    static void invalidateValues(void *value, void *data);
    bool loadSettings(const char *filename);
    bool resumeMusic(int channel);
    bool setMusicStartTime(int channel, uint32 time);
    bool pauseMusic(int channel);
    bool stopMusic(int channel);
    bool playMusic(int channel, const char *filename, bool looping = true, uint32 loopStart = 0, uint32 privVolume = 100);
    BaseSound *_music[NUM_MUSIC_CHANNELS];
    bool _musicCrossfadeRunning;
    bool _musicCrossfadeSwap;
    uint32 _musicCrossfadeStartTime;
    uint32 _musicCrossfadeLength;
    int32 _musicCrossfadeChannel1;
    int32 _musicCrossfadeChannel2;
    int32 _musicCrossfadeVolume1;
    int32 _musicCrossfadeVolume2;
    bool displayWindows(bool inGame = false);
    Common::String readRegistryString(const Common::String &key, const Common::String &initValue) const;
    bool _useD3D;
    virtual bool cleanup();
    bool loadGame(uint32 slot);
    bool loadGame(const char *filename);
    bool saveGame(int32 slot, const char *desc, bool quickSave = false);
    bool showCursor() override;
    BaseSprite *_cursorNoninteractive;
    BaseObject *_activeObject;
    BaseKeyboardState *_keyboardState;
    bool _interactive;
    TGameState _state;
    TGameState _origState;
    bool _origInteractive;
    uint32 _timer;
    uint32 _timerDelta;
    uint32 _timerLast;

    uint32 _liveTimer;
    uint32 _liveTimerDelta;
    uint32 _liveTimerLast;

    BaseObject *_capturedObject;
    Common::Point32 _mousePos;
    bool validObject(BaseObject *object);
    bool unregisterObject(BaseObject *object);
    bool registerObject(BaseObject *object);
    void quickMessage(const char *text);
    void quickMessageForm(char *fmt, ...);
    bool displayQuickMsg();
    uint32 _fps;
    bool updateMusicCrossfade();

    bool isVideoPlaying();
    bool stopVideo();

    BaseArray<BaseObject *> _regObjects;

    // accessibility flags
    bool _accessTTSEnabled;
    bool _accessTTSTalk;
    bool _accessTTSCaptions;
    bool _accessTTSKeypress;
    bool _accessKeyboardEnabled;
    bool _accessKeyboardCursorSkip;
    bool _accessKeyboardPause;

    bool _accessGlobalPaused;

    UIWindow *_accessShieldWin;
    bool accessPause();
    bool accessUnpause();

public:
    virtual bool displayContent(bool update = true, bool displayAll = false);
    virtual bool displayContentSimple();
    bool _forceNonStreamedSounds;
    void resetMousePos();
    int32 _subtitlesSpeed;
    void setInteractive(bool state);
    virtual bool windowLoadHook(UIWindow *win, char **buf, char **params);
    virtual bool windowScriptMethodHook(UIWindow *win, ScScript *script, ScStack *stack, const char *name);
    bool getCurrentViewportOffset(int *offsetX = nullptr, int *offsetY = nullptr);
    bool getCurrentViewportRect(Common::Rect32 *rect, bool *custom = nullptr);
    bool popViewport();
    bool pushViewport(BaseViewport *viewport);
    bool setActiveObject(BaseObject *obj);

    BaseSprite *_lastCursor;
    bool drawCursor(BaseSprite *cursor);

    virtual bool initAfterLoad();

    SaveThumbHelper *_cachedThumbnail;

private:
    bool getSaveDir(char *Buffer);



public:
    BaseGameMusic *_musicSystem;
    Common::String _targetName;

    void setIndicatorVal(int value);
    bool getBilinearFiltering() { return _bilinearFiltering; }
    void addMem(int32 bytes);

    bool _touchInterface;
    bool _bilinearFiltering{};
#ifdef ENABLE_WME3D
    bool _force2dRenderer{};
#endif

    AnsiString getDeviceType() const;

    struct LastClickInfo {
        LastClickInfo() {
            posX = posY = 0;
            time = 0;
        }

        int32 posX;
        int32 posY;
        uint32 time;
    };

    LastClickInfo _lastClick[2];
    bool isDoubleClick(int32 buttonIndex);
    uint32 _usedMem;

protected:
    // WME Lite specific
    bool _autoSaveOnExit;
    uint32 _autoSaveSlot;
    bool _cursorHidden;

public:
    void autoSaveOnExit();
    PluginEvent &pluginEvents() { return _pluginEvents; }

private:

#ifdef ENABLE_HEROCRAFT
    // HeroCraft games specific random source with ability a in-script function to set the seed
    Common::RandomSource *_rndHc;

    // HeroCraft games specific checksum function, used in Papa's Daughters 2 selfcheck
    uint8 getFilePartChecksumHc(const char *filename, uint32 begin, uint32 end);
#endif

    PluginEvent _pluginEvents;
};

} // End of namespace Wintermute

#endif