sci.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 SCI_SCI_H
#define SCI_SCI_H

#include "engines/engine.h"
#include "common/macresman.h"
#include "common/util.h"
#include "common/random.h"
#include "sci/engine/vm_types.h"    // for Selector
#include "sci/debug.h"  // for DebugState
#include "sci/detection.h" // Shared code between detection and engine

struct ADGameDescription;

namespace Sci {

struct EngineState;
class Vocabulary;
class ResourceManager;
class Kernel;
class GameFeatures;
class GuestAdditions;
class Console;
class AudioPlayer;
class SoundCommandParser;
class EventManager;
class SegManager;
class ScriptPatcher;
class Sync;

class GfxAnimate;
class GfxCache;
class GfxCompare;
class GfxControls16;
class GfxControls32;
class GfxCoordAdjuster16;
class GfxCursor;
class GfxMacFontManager;
class GfxMacIconBar;
class GfxMenu;
class GfxPaint16;
class GfxPaint32;
class GfxPalette;
class GfxPalette32;
class GfxRemap;
class GfxRemap32;
class GfxPorts;
class GfxScreen;
class GfxText16;
class GfxText32;
class GfxTransitions;
class SciTTS;

#ifdef ENABLE_SCI32
class GfxFrameout;
class Audio32;
class Video32;
class GfxTransitions32;
class GfxCursor32;
#endif

enum kDebugLevels {
    kDebugLevelError         = 1 << 0,
    kDebugLevelNodes         = 1 << 1,
    kDebugLevelGraphics      = 1 << 2,
    kDebugLevelStrings       = 1 << 3,
    kDebugLevelMemory        = 1 << 4,
    kDebugLevelFuncCheck     = 1 << 5,
    kDebugLevelBresen        = 1 << 6,
    kDebugLevelSound         = 1 << 7,
    kDebugLevelBaseSetter    = 1 << 8,
    kDebugLevelParser        = 1 << 9,
    kDebugLevelSaid          = 1 << 10,
    kDebugLevelFile          = 1 << 11,
    kDebugLevelTime          = 1 << 12,
    kDebugLevelRoom          = 1 << 13,
    kDebugLevelAvoidPath     = 1 << 14,
    kDebugLevelDclInflate    = 1 << 15,
    kDebugLevelVM            = 1 << 16,
    kDebugLevelScripts       = 1 << 17,
    kDebugLevelGC            = 1 << 18,
    kDebugLevelResMan        = 1 << 19,
    kDebugLevelOnStartup     = 1 << 20,
    kDebugLevelDebugMode     = 1 << 21,
    kDebugLevelPatcher       = 1 << 22,
    kDebugLevelWorkarounds   = 1 << 23,
    kDebugLevelVideo         = 1 << 24,
    kDebugLevelGame          = 1 << 25
};


enum kLanguage {
    K_LANG_NONE = 0,
    K_LANG_ENGLISH = 1,
    K_LANG_FRENCH = 33,
    K_LANG_SPANISH = 34,
    K_LANG_ITALIAN = 39,
    K_LANG_GERMAN = 49,
    K_LANG_JAPANESE = 81,
    K_LANG_PORTUGUESE = 351
};

class SciEngine : public Engine {
    friend class Console;
public:
    SciEngine(OSystem *syst, const ADGameDescription *desc, SciGameId gameId);
    ~SciEngine() override;

    // Engine APIs
    Common::Error run() override;
    bool hasFeature(EngineFeature f) const override;
    void pauseEngineIntern(bool pause) override;
    void severeError();
    Console *getSciDebugger();
    Common::Error loadGameState(int slot) override;
    Common::Error saveGameState(int slot, const Common::String &desc, bool isAutosave = false) override;
    bool canLoadGameStateCurrently(Common::U32String *msg = nullptr) override;
    bool canSaveGameStateCurrently(Common::U32String *msg = nullptr) override;
    void syncSoundSettings() override; 
    void updateSoundMixerVolumes();
    uint32 getTickCount();
    void setTickCount(const uint32 ticks);
    void errorString(const char *buf1, char *buf2, int size) override;

    int getAutosaveSlot() const override { return -1; }

    const SciGameId &getGameId() const { return _gameId; }
    const char *getGameIdStr() const;
    Common::Language getLanguage() const;
    
    bool isLanguageRTL() const;
    
    Common::Platform getPlatform() const;
    bool isDemo() const;
    bool isCD() const;
    bool useHiresGraphics() const;

    bool isBE() const;

    bool hasParser() const;

    bool hasMacFonts() const;
    
    bool hasMacIconBar() const;

    bool hasMacSaveRestoreDialogs() const;

    inline ResourceManager *getResMan() const { return _resMan; }
    inline ScriptPatcher *getScriptPatcher() const { return _scriptPatcher; }
    inline Kernel *getKernel() const { return _kernel; }
    inline EngineState *getEngineState() const { return _gamestate; }
    inline Vocabulary *getVocabulary() const { return _vocabulary; }
    inline EventManager *getEventManager() const { return _eventMan; }
    inline reg_t getGameObject() const { return _gameObjectAddress; } // Gets the game object VM address

    Common::RandomSource &getRNG() { return _rng; }

    Common::String getSavegameName(int nr) const;
    Common::String getSavegamePattern() const;

    Common::String getFilePrefix() const;

    Common::String wrapFilename(const Common::String &name) const;

    Common::String unwrapFilename(const Common::String &name) const;

    const char *getGameObjectName();

    int inQfGImportRoom() const;

    void showQfgImportMessageBox() const;

    void sleep(uint32 msecs);

    void scriptDebug();
    bool checkExportBreakpoint(uint16 script, uint16 pubfunct);
    bool checkSelectorBreakpoint(BreakpointType breakpointType, reg_t send_obj, int selector);
    bool checkAddressBreakpoint(const reg_t &address);

public:
    bool checkKernelBreakpoint(const Common::String &name);

    Common::String strSplitLanguage(const char *str, uint16 *splitLanguage, const char *sep = "\r----------\r");
    Common::String strSplit(const char *str, const char *sep = "\r----------\r") {
        return strSplitLanguage(str, NULL, sep);
    }

    kLanguage getSciLanguage();
    void setSciLanguage(kLanguage lang);
    void setSciLanguage();

    Common::String getSciLanguageString(const Common::String &str, kLanguage requestedLanguage, kLanguage *secondaryLanguage = nullptr, uint16 *languageSplitter = nullptr) const;

    // Check if vocabulary needs to get switched (in multilingual parser games)
    void checkVocabularySwitch();

    // Initializes ports and paint16 for non-sci32 games, also sets default palette
    void initGraphics();

    // Suggest to download the GK2 subtitles patch
    // in the future, we might refactor it to something more generic, if needed
    void suggestDownloadGK2SubTitlesPatch();

public:
    GfxAnimate *_gfxAnimate; // Animate for 16-bit gfx
    GfxCache *_gfxCache;
    GfxCompare *_gfxCompare;
    GfxControls16 *_gfxControls16; // Controls for 16-bit gfx
    GfxCoordAdjuster16 *_gfxCoordAdjuster; // Coordinate adjuster for 16-bit gfx
    GfxCursor *_gfxCursor; // 16-bit cursor
    GfxMenu *_gfxMenu; // Menu for 16-bit gfx
    GfxPalette *_gfxPalette16;
    GfxRemap *_gfxRemap16;  // Remapping for the QFG4 demo
    GfxPaint16 *_gfxPaint16; // Painting in 16-bit gfx
    GfxPorts *_gfxPorts; // Port management for 16-bit gfx
    GfxScreen *_gfxScreen; // Screen class for 16-bit
    GfxText16 *_gfxText16;
    GfxTransitions *_gfxTransitions; // transitions between screens for 16-bit gfx
    GfxMacIconBar *_gfxMacIconBar; // Mac Icon Bar manager
    GfxMacFontManager *_gfxMacFontManager; // null when not applicable
    SciTTS *_tts;

#ifdef ENABLE_SCI32
    GfxControls32 *_gfxControls32; // Controls for 32-bit gfx
    GfxPalette32 *_gfxPalette32; // Palette for 32-bit gfx
    GfxRemap32 *_gfxRemap32; // Remapping for 32-bit gfx
    GfxPaint32 *_gfxPaint32; // Painting in 32-bit gfx
    GfxText32 *_gfxText32;

    Audio32 *_audio32;
    Video32 *_video32;
    GfxFrameout *_gfxFrameout; // kFrameout and the like for 32-bit gfx
    GfxTransitions32 *_gfxTransitions32;
    GfxCursor32 *_gfxCursor32;
#endif

    AudioPlayer *_audio;
    Sync *_sync;
    SoundCommandParser *_soundCmd;
    GameFeatures *_features;
    GuestAdditions *_guestAdditions;

    opcode_format (*_opcode_formats)[4];

    DebugState _debugState;
    uint32 _speedThrottleDelay; // kGameIsRestarting maximum delay

    Common::MacResManager *getMacExecutable() { return &_macExecutable; }

private:
    bool initGame();

    void runGame();
    
    void initStackBaseWithSelector(Selector selector);

    void loadMacExecutable();

    void loadMacFonts();

    bool gameHasFanMadePatch();
    
    void setLauncherLanguage();

    const ADGameDescription *_gameDescription;
    const SciGameId _gameId;
    ResourceManager *_resMan; 
    ScriptPatcher *_scriptPatcher; 
    EngineState *_gamestate;
    Kernel *_kernel;
    Vocabulary *_vocabulary;
    int16 _vocabularyLanguage;
    EventManager *_eventMan;
    reg_t _gameObjectAddress; 
    Console *_console;
    Common::RandomSource _rng;
    Common::MacResManager _macExecutable;
    bool _useHiresGraphics; // user-option for GK1, KQ6, PQ4
    bool _inErrorString; 
};

extern SciEngine *g_sci;

} // End of namespace Sci

#endif // SCI_SCI_H