macs2.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 MACS2_MACS2_H
#define MACS2_MACS2_H

#include "advancedDetector.h"
#include "audio/audiostream.h"
#include "audio/mixer.h"
#include "common/array.h"
#include "common/error.h"
#include "common/file.h"
#include "common/fs.h"
#include "common/hashmap.h"
#include "common/memstream.h"
#include "common/random.h"
#include "common/scummsys.h"
#include "common/serializer.h"
#include "common/system.h"
#include "common/text-to-speech.h"
#include "common/util.h"
#include "engines/engine.h"
#include "graphics/palette.h"
#include "macs2/amiga_archive.h"
#include "macs2/events.h"
#include "macs2/macs2_constants.h"
#include "macs2/pathfinding.h"
#include "macs2/scriptexecutor.h"
#include "macs2/sprite.h"
#include "macs2/text.h"

namespace Macs2 {

class MacsAudioStream : public Audio::SeekableAudioStream {
public:
    Common::Array<byte> _data;
    int64 _pos = 0;
    int _rate = 0x1F40;

    virtual ~MacsAudioStream() {}

    virtual int readBuffer(int16 *buffer, const int numSamples);

    virtual bool isStereo() const;

    virtual int getRate() const;

    virtual bool endOfData() const;

    virtual bool seek(const Audio::Timestamp &where);

    virtual Audio::Timestamp getLength() const;
};

struct Macs2GameDescription;
class Music;

struct AnimFrame : public Sprite {
    int16 _offsetX = 0;
    int16 _offsetY = 0;

    void readFromeFile(Common::File &file);
    void readFromStream(Common::SeekableReadStream *stream);
    bool pixelHit(const Common::Point &point) const;
    Common::Point getBottomMiddleOffset(uint16 scale = 100) const;
};

enum class MenuMode : uint16 {
    Hidden = 0,
    Main = 1,
    Options = 2,
    DialogueList = 4
};

enum class OptionsSubMode : uint16 {
    None = 0,
    Save = 1,
    Load = 2
};

struct HudButton {
    int16 x = 0;
    int16 y = 0;
    uint16 inactiveStep = 0;
    uint16 activeStep = 0;
    uint16 hoverStep = 0;
    uint16 buttonId = 0; // 1=Walk, 2=Look, 3=Talk, 4=Use, 0x33=Options, ...
    uint16 menuId = 0;
    AnimFrame frame;
    AnimFrame activeFrame;
    AnimFrame hoverFrame;
    Common::Array<uint8> animBlob;
};

struct BackgroundAnimation {
    uint16 _x = 0;
    uint16 _y = 0;
    Common::Array<AnimFrame> _frames;
    uint32 _frameIndex = 0;
};

struct BackgroundAnimationBlob {
    uint16 _x = 0;
    uint16 _y = 0;
    Common::Array<uint8> _blob;
    Common::Array<uint8> _extraBlobs[8];
    uint16 _activeExtraSlot = 0; // 0 = primary _blob; 1..8 = _extraBlobs[slot-1]
    uint16 _unknown0C = 0; // +0x50F3: purpose unknown (word, read from file, not used at runtime)
    uint8 _unknown0E = 0;  // +0x50F5: purpose unknown (byte, read from file, not used at runtime)
    uint8 _unknown0F = 0;  // +0x50F6: purpose unknown (byte, read from file, not used at runtime)
    Common::Array<uint8> &activeBlob() {
        if (_activeExtraSlot >= 1 && _activeExtraSlot <= 8)
            return _extraBlobs[_activeExtraSlot - 1];
        return _blob;
    }
    const Common::Array<uint8> &activeBlob() const {
        if (_activeExtraSlot >= 1 && _activeExtraSlot <= 8)
            return _extraBlobs[_activeExtraSlot - 1];
        return _blob;
    }
    AnimFrame getCurrentFrame();
    static uint16 advanceAnimFrame(Common::Array<uint8> &blob, bool bpp6, uint16 bpp8);
    static uint16 getCurrentPixelFrameNumber(const Common::Array<uint8> &blob);
    static uint16 getAnimFrameCount(Common::Array<uint8> &blob);
    // Mirrors (horizontally flips) all frames in an animation blob in-place.
    // Matches binary decodeAnimBlob (1010:184d) which calls the row-flip at 1010:1319.
    static void mirrorAnimBlob(Common::Array<uint8> &blob);
};

struct AnimBlobView {
    const Common::Array<uint8> &_blob;

    explicit AnimBlobView(const Common::Array<uint8> &blob) : _blob(blob) {}

    bool isValid() const {
        return _blob.size() >= 14;
    }

    uint16 sequencePosition() const {
        return READ_LE_UINT16(&_blob[0x02]);
    }

    uint16 repeatCounter() const {
        return READ_LE_UINT16(&_blob[0x04]);
    }

    uint16 loopStartPosition() const {
        return READ_LE_UINT16(&_blob[0x06]);
    }

    uint16 delayCounter() const {
        return READ_LE_UINT16(&_blob[0x08]);
    }

    uint16 sequenceLength() const {
        return READ_LE_UINT16(&_blob[0x0A]) + 1;
    }

    uint32 frameDataOffset() const {
        return 0x0B + sequenceLength();
    }

    uint16 frameCount() const {
        const uint32 off = frameDataOffset();
        if (off + 2 > _blob.size()) {
            return 0;
        }
        return READ_LE_UINT16(&_blob[off]);
    }

    // Get frame info at index (0-based). Returns false if out of bounds.
    struct FrameInfo {
        int16 offsetX;
        int16 offsetY;
        uint16 unknown;
        uint16 width;
        uint16 height;
        const byte *pixels; // pointer into blob data
    };

    bool getFrameInfo(uint16 index, FrameInfo &out) const {
        uint32 pos = frameDataOffset() + 2; // skip frame count word
        for (uint16 i = 0; i <= index; i++) {
            if (pos + 10 > _blob.size()) {
                return false;
            }
            const int16 ox = (int16)READ_LE_UINT16(&_blob[pos]);
            const int16 oy = (int16)READ_LE_UINT16(&_blob[pos + 2]);
            const uint16 unk = READ_LE_UINT16(&_blob[pos + 4]);
            const uint16 w = READ_LE_UINT16(&_blob[pos + 6]);
            const uint16 h = READ_LE_UINT16(&_blob[pos + 8]);
            pos += 10;
            if (w == 0 || h == 0 || pos + (uint32)w * h > _blob.size()) {
                return false;
            }
            if (i == index) {
                out = {ox, oy, unk, w, h, &_blob[pos]};
                return true;
            }
            pos += (uint32)w * h;
        }
        return false;
    }
};

class Macs2Engine : public Engine, public Events {
private:
    const ADGameDescription *_gameDescription;

    Music *_music = nullptr;

protected:
    // Engine APIs
    Common::Error run() override;

    bool shouldQuit() const override {
        return Engine::shouldQuit();
    }

public:
    Graphics::ManagedSurface readRLEImage(int64 offs, Common::SeekableReadStream *stream);

    void readResourceFile();
    enum class McsFileVersion {
        Unknown = 0,
        V1, // AHFFMACS0100
        V2  // AHFFMACS0200
    };
    McsFileVersion detectMcsFileVersion(Common::SeekableReadStream &stream) const;
    void loadResourceFileV1();
    void loadResourceFileV2();
    void bootstrapMcsActorsObjectsAndScene();
    void softRestart();
    const char *getResourceMcsFilename() const;
    void readAmigaResources();
    void applyAmigaUiPalette();
    void installAmigaPortraitPalette(bool copyFromPlayfield);
    void buildAmigaPanelRemapTable();
    bool loadAmigaCursorResource(uint16 resourceId, AnimFrame &out);
    bool loadAmigaMxffFont();
    bool loadAmigaOverlayFont(uint8 resourceIndex);
    bool loadAmigaOverlayFontResource(uint16 ffId);
    bool loadAmigaSceneBackground(uint32 sceneResourceId);

    void initInventoryIconIndices();

    // Assumes that the stream is at the location of the number of background animations
    void readBackgroundAnimations(Common::SeekableReadStream *stream);

    // Assumes that the stream is at the start of the right section
    void readImageResources(Common::SeekableReadStream *stream);

public:
    Macs2Engine(OSystem *osystem, const ADGameDescription *gameDesc);
    ~Macs2Engine() override;

    void changeScene(uint32 newSceneIndex, bool executeScript = true);

    Script::ScriptExecutor *_scriptExecutor = nullptr;
    Graphics::ManagedSurface _sceneBackground;
    Graphics::ManagedSurface _hotspotMap;

    // This is the depth map
    Graphics::ManagedSurface _depthMap;
    // Scene-load snapshot used to restore depth under background animation frame 0.
    Graphics::ManagedSurface _sceneDepthMap;

    // Shadow/shading intensity map (scene+0x301B). Per-pixel values 0-32
    // control character sprite darkening via the shading table.
    // Only scenes with shadow regions have non-zero data.
    Graphics::ManagedSurface _shadowMap;

    // _palVanilla: raw 6-bit VGA source. _pal: 8-bit display (darkened + expanded).
    Graphics::Palette _pal{Graphics::PALETTE_COUNT};
    Graphics::Palette _palVanilla{Graphics::PALETTE_COUNT};

    Common::Array<Common::String> _debugOutput;
    Common::Array<Common::String> _textLog;

    Pathfinding _pathfinding;

    void updateBackgroundAnimationDepthMap(size_t animIndex);
    void updateAllBackgroundAnimationDepthMaps();

    // This is the override list living at [5BD1]
    // Savegames sync 16 words into indices 1..16 (array size 0x11 during sync).
    // Runtime capacity is 0x21 for later growth after load.
    Common::Array<uint16> _hotspotOverrides;

    Common::Array<Macs2::AnimFrame> _imageResources;
    Common::Point _cursorHotspots[33];

    Text _text;
    bool loadOverlayFont(uint8 resourceIndex, uint16 executingObjectID);
    bool resolveResourceFileOffset(uint8 resourceIndex, uint16 executingObjectId, uint32 &outOffset) const;
    bool loadSizedResourcePayload(uint8 resourceIndex, uint16 executingObjectId, Common::Array<uint8> &outPayload);
    bool loadAhffAnimResource(uint8 resourceIndex, uint16 executingObjectId, Common::Array<uint8> &outBlob);
    bool readMegaPicImage(Common::SeekableReadStream *stream, int width, int height, Graphics::ManagedSurface &out);
    bool loadMaskFromResource(uint8 resourceIndex, uint16 executingObjectId, Graphics::ManagedSurface &dest,
                              int megapicW, int megapicH, bool upscaleHalfRes = false);

    struct DeltaStrip {
        uint16 y = 0;
        Common::Array<uint8> rle;
    };
    struct DeltaFrame {
        Common::Array<DeltaStrip> strips;
    };
    struct DeltaSfxEvent {
        uint16 frameIndex = 0;
        bool duckMusic = false;
        Common::String fileName;
    };
    struct DeltaAnimState {
        bool loaded = false;
        bool playing = false;
        bool applyPaletteOnStart = false;
        uint16 frameCount = 0;
        uint16 startFrame = 0;
        uint16 endFrame = 0;
        uint16 speedTicks = 1;
        uint16 tickCounter = 0;
        uint16 currentFrame = 0;
        uint16 clipMiX = 0;
        uint16 clipMiY = 0;
        uint16 clipMaX = 0;
        uint16 clipMaY = 0;
        Graphics::Palette palette{Graphics::PALETTE_COUNT};
        Common::Array<DeltaFrame> frames;
        Common::Array<DeltaSfxEvent> sfxEvents;
        void clear(int screenW, int screenH) {
            loaded = false;
            playing = false;
            frameCount = 0;
            startFrame = endFrame = currentFrame = 0;
            speedTicks = 1;
            tickCounter = 0;
            applyPaletteOnStart = false;
            frames.clear();
            sfxEvents.clear();
            clipMiX = clipMiY = 0;
            clipMaX = (uint16)MAX(0, screenW - 1);
            clipMaY = (uint16)MAX(0, screenH - 1);
            palette = Graphics::Palette(Graphics::PALETTE_COUNT);
        }
    };
    DeltaAnimState _deltaAnim;
    bool loadDeltaAnimResource(uint8 resourceIndex, uint16 executingObjectId, bool forceSkipSpeed1 = false);
    void clearDeltaAnim();
    bool startDeltaPlayback(uint16 startFrame, uint16 endFrame, uint16 speedTicks, bool applyPalette);
    bool tickDeltaPlayback();
    void applyDeltaFrameToBackground(const DeltaFrame &frame);
    void playDeltaFrameSfx(uint16 displayFrame);
    AnimFrame _animFrames[6];
    // 6 flag/decoration animation frames at fixed file offset 0x6A5941, each followed by 6 padding bytes

    // Character shading remap (loadResourceFile @ 1008:2e8d -> scene+0x53D3).
    // Indexed as (color - 0xC0) * 0x20 + shadowIntensity (drawSpriteTransparent @ 1010:0ed1).
    Common::Array<byte> _shadingTable;
    // Per-scene 256-byte UI pixel remap (changeScene @ 1008:2574, drawAnimFrameScaled @ 1010:1399).
    Common::Array<byte> _panelRemapTable;

    // Map scene offsets from resource file (scene+0x5DDB, 256 entries x 4 bytes).
    // Each entry is a file offset to a scene preview image for map mode.
    uint32 _helpOffsets[256] = {0};

    Common::Array<BackgroundAnimation> _backgroundAnimations;
    Common::Array<BackgroundAnimationBlob> _backgroundAnimationsBlobs;

    Common::SeekableReadStream *_fileStream = nullptr;
    McsFileVersion _mcsFileVersion = McsFileVersion::Unknown;
    uint32 _mcsDirectoryOffset = kMcsV1DirectoryOffset;

    bool _amigaNativePlayfieldPalette = false;
    Common::Array<byte> _amigaLineCopperPal;
    Macs2AmigaArchive *_amigaArchive = nullptr;
    Common::Array<byte> _amigaPendingSceneScript;
    Common::Array<byte> _amigaPendingSceneStrings;

    mutable Common::String _ttsPreviousSaid;

    bool _bottomHudVisible = true;

    Graphics::ManagedSurface _hudMegapics[6];
    bool _hudMegapicLoaded[6] = {};
    Common::Array<HudButton> _hudButtons;
    uint16 _panelTopY = 0;
    uint16 _panelHeight = 0;
    MenuMode _menuMode = MenuMode::Main;
    OptionsSubMode _optionsSubMode = OptionsSubMode::None;
    Script::MouseMode _savedMenuCursorMode = Script::MouseMode::Walk;
    uint16 _inventScroll = 1;
    uint16 _inventOriginX = 0;
    uint16 _inventOriginY = 0;
    uint16 _inventCols = 4;
    uint16 _inventRows = 2;
    uint16 _inventSlotW = 64;
    uint16 _inventSlotH = 52;
    uint16 _inventLayoutMode = 0;
    uint16 _hudTextLayout[7] = {};
    uint16 _hudTextRecolor[4] = {};
    uint16 _saveListScroll = 1;
    Common::Array<Common::String> _saveSlotNames;
    uint16 _skipSpeed = 1;

    void setCursorMode(Script::MouseMode newMode);
    void nextCursorMode();

    Common::Array<uint16> _hotspotColorTable;

    uint16 _walkDepthThresholdY;
    uint16 _walkDepthScaleFactor;
    uint16 _walkBaseSpeedPct;

    // Scene palette/animation mode at sceneData+0x5203:
    //   1 = normal (no darkening, no bg animation)
    //   2 = slow bg animation + palette darkening
    //   3 = fast bg animation + palette darkening
    uint16 _scenePaletteMode;
    // Palette darken percentage (0-100) at sceneData+0x5205.
    // Formula: displayedPal[i] = sourcePal[i] * (100 - _paletteDarkenPercent) / 100
    uint16 _paletteDarkenPercent;

    void applyPaletteDarkening();
    void readPalette(Common::SeekableReadStream *stream, Graphics::Palette &dest);
    void expandPalette6To8(Graphics::Palette &pal);
    // Palette quantization for g_wHelpButtonDisabled path (1000:103e).
    // Histograms scene pixels, keeps 16 rarest colors (0..0xBF) plus UI range
    // 0xC0..0xFF, remaps background + bg-anim blobs + palette via Manhattan RGB.
    void applyScenePaletteEffect();

    // Gradual palette brighten effect for _scenePaletteMode == 2, matching the
    // binary updateBackgroundAnimations (1008:2c05). Called from the game tick at
    // the mode-gated rate. Despite the name it does NOT advance animation frames
    // (that happens in the per-frame render); it decrements the darken percent
    // toward 60 and reapplies the palette darkening.
    void updateBackgroundAnimationPalette();

    // Binary g_bMovementFinishedFlag [1020:0000]: set by walkAlongPath on final arrival
    // (orientation < 9), checked after all characters processed in drawAllCharacters.
    bool _movementFinishedFlag = false;

    Common::Array<uint32> _sceneResourceOffsets;

    bool loadAnimationFromSceneData(uint16 objectIndex, uint16 slotIndex, uint8 arrayIndex, bool shouldMirror = false, uint16 executingScriptObjectId = 0);
    bool loadObjectData(GameObject *obj);
    void clearObjectRuntime(GameObject *obj);
    // sortObjectsByDepth @ 1008:0d79 - inventory cursor reset + free object runtime blobs.
    void sortObjectsByDepth(uint16 objectIndex);

    Music *getMusic() const { return _music; }
    // Returns the Music volume (0-63) scaled by the user's music_volume setting
    uint16 scaledMusicVolume(uint16 gameAttenuation) const;
    uint16 _talkVol = 0;
    void setCurrentSoundData(const Common::Array<uint8> &data, int rateHz = 0x1F40, int headerSkip = 2);
    void clearCurrentSoundData();
    bool hasCurrentSoundData() const { return !_currentSoundData.empty(); }
    void playSample();
    void stopSample();
    bool isSamplePlaying() const;
    void playAudioFile(const Common::Path &basename, bool speechBus);
    void stopSpeech();
    bool isSpeechPlaying() const;

    // Offset 50D3h - This is used in 0037:10C4 to terminate the loop
    uint16 _numHotspots;

    // Reserved/unused scene data fields at scene+0x53C3..+0x53CF (4 dwords).
    // Zeroed on scene change, saved/loaded, but never read or written with meaningful
    // values by any game logic. Kept only for save/load format compatibility.
    uint32 _sceneTimerParams[4] = {0};

    // Clip rect dirty flag [0xfec] - in the original DOS engine this signaled the VGA
    // blitter to reset the clip region to full screen before the next partial-region
    // updates (a dirty-rect optimization). Not used in ScummVM because we redraw the
    // full backbuffer each frame via ManagedSurface. Kept only for save/load compatibility.
    bool _clipRectDirty = false;

    uint16 getHotspotAtPoint(const Common::Point &p) const;

    Common::Array<uint16> inventoryIconIndices;
    Common::Array<uint16> containerInventoryIconIndices;

    void runScriptExecutor(bool firstRun = false) {
        _scriptExecutor->run(firstRun);
    }

    bool _runScheduled = false;
    // TODO: Feels like this should be more elegantly solved, also check how the game does this
    // Is required for example after a scene change
    bool _scheduledRunIsInitScene = false;

    // Game speed mode from original binary (g_wGameSpeedMode at 1020:0214).
    // Cycled by Ctrl+T: 0=normal, 1=fast (no frame wait), 2=slow (wait for tick>=0x12).
    uint16 _gameSpeedMode = 0;
    void setGameSpeedMode(uint16 mode);

    // Input record/playback system from original binary.
    // Original usage: MCSEXEC filename /rRecFile or /pPlayFile
    // Record writes per-frame: mouseX(2), mouseY(2), buttons(2)
    // Playback reads the same and also a leading frame-count word.
    enum class InputMode { None,
                           Record,
                           Playback };
    InputMode _inputMode = InputMode::None;
    Common::WriteStream *_inputRecordStream = nullptr;
    Common::SeekableReadStream *_inputPlaybackStream = nullptr;
    uint32 _inputFrameCounter = 0;
    uint32 _inputPlaybackEndFrame = 0;

    void startInputRecording(const Common::Path &filename);
    void startInputPlayback(const Common::Path &filename);
    void stopInputRecording();
    void recordInputFrame(uint16 mouseX, uint16 mouseY, uint16 buttons);
    bool readInputFrame(uint16 &mouseX, uint16 &mouseY, uint16 &buttons);

    Common::Array<uint8> _currentSoundData;
    int _currentSoundRate = 0x1F40;
    int _currentSoundHeaderSkip = 2;
    Audio::SoundHandle _currentSoundHandle;
    Audio::SoundHandle _speechSoundHandle;

    // Schedules a run of the script the next time the executor is ticked
    void scheduleRun(bool initScene = false);

    Common::StringArray decodeStrings(Common::MemoryReadStream *stream, int offset, int numStrings, int sceneId = 0, int objectId = 0);

    // --- Translation support ---
    struct TranslationEntry {
        Common::StringArray strings;
    };
    Common::HashMap<uint32, TranslationEntry> _sceneTranslations;
    Common::HashMap<uint32, TranslationEntry> _objectTranslations;
    Common::HashMap<Common::String, Common::String> _hotspotLabelTranslations;
    Common::HashMap<Common::String, Common::String> _uiLabelTranslations;
    void loadTranslation();
    Common::String translateHotspotLabel(const Common::String &cp850Name) const;
    Common::String translateUiLabel(const Common::String &source) const;
    // Compute the sequential string index at the given byte offset in a string blob
    int computeStringIndex(Common::MemoryReadStream *stream, int targetOffset);

    uint32 getFeatures() const;
    Common::Platform getPlatform() const { return _gameDescription->platform; }
    bool isAmiga() const { return getPlatform() == Common::kPlatformAmiga; }
    Macs2AmigaArchive *getAmigaArchive() const { return _amigaArchive; }

    bool isDemo() const { return getFeatures() & ADGF_DEMO; }

    bool isV1() const { return _mcsFileVersion == McsFileVersion::V1; }
    bool isV2() const { return _mcsFileVersion == McsFileVersion::V2; }

    uint32 getMcsDirectoryOffset() const { return _mcsDirectoryOffset; }
    McsFileVersion getMcsFileVersion() const { return _mcsFileVersion; }
    int screenWidth() const { return isV2() ? kWinScreenWidth : kScreenWidth; }
    int screenWidthLast() const { return screenWidth() - 1; }
    int gameHeight() const { return isV2() ? kWinGameHeight : kGameHeight; }
    int gameHeightLast() const { return gameHeight() - 1; }
    int screenHeight() {
        if (isV2()) {
            if (_panelTopY == 0 || _panelHeight == 0)
                return kWinGameHeight;
            return (int)_panelTopY + (int)_panelHeight;
        }
        if (enhancementEnabled(kEnhUIUX))
            return gameHeight() + kUIHeight;
        return gameHeight();
    }
    int screenHeightLast() { return screenHeight() - 1; }

    bool isBottomHudVisible() const { return _bottomHudVisible; }
    void setBottomHudVisible(bool visible);

    bool hasNativeHudAssets() const {
        return _panelTopY != 0 && _panelHeight != 0;
    }

    // --- Layout / dialect facades ---

    uint32 timerTickMs() const { return isV2() ? 55 : 46; }
    uint16 ticksPerGameFrame() const { return isV2() ? 1 : 2; }

    uint16 maxAnimSlots() const { return isV2() ? 38 : 21; }
    uint16 maxOrientations() const { return maxAnimSlots() - 1; }
    uint16 overloadAnimSlot() const { return maxAnimSlots(); }
    static uint16 specialAnimSlotToAnimSlot(uint16 specialSlot);
    uint16 maxHotspots() const { return isV2() ? 32 : 16; }
    uint maxObjectResources() const { return 32; }
    uint16 resolveAnimSlotIndex(const GameObject *obj) const;

    bool scriptValuesHaveHighWord() const { return isV2(); }
    bool scriptVarIndexHasPaddingWord() const { return isV2(); }
    int16 scaleScriptCoord(int16 coord) const { return isV2() ? (int16)(coord * 2) : coord; }

    int dialogPadW() const { return isAmiga() ? 8 : 18; }
    int dialogPadH() const { return isAmiga() ? 8 : 16; }
    int dialogTextInset() const { return isAmiga() ? 4 : 9; }
    int dialogLineGap() const { return 2; }
    int portraitBorderPad() const { return isAmiga() ? 2 : 13; }
    int portraitContentInset() const { return isAmiga() ? 1 : 7; }
    int portraitTextGap() const { return isAmiga() ? 10 : 18; }
    int dialogLineHeight() const {
        if (isAmiga())
            return _text.amigaTextLinePitch ? (int)_text.amigaTextLinePitch : (int)_text._maxGlyphHeight;
        return (int)_text._maxGlyphHeight + dialogLineGap();
    }

    uint8 depthThresholdForY(int16 charY) const {
        return isV2() ? (uint8)((uint16)charY >> 1) : (uint8)charY;
    }

    void loadBootstrapResources();
    bool loadSceneGraphics(uint32 sceneIndex);
    bool loadSceneGraphicsV1(uint32 sceneIndex);
    bool loadSceneGraphicsV2(uint32 sceneIndex);

    Common::String getGameId() const;

    bool hasFeature(EngineFeature f) const override {
        return (f == kSupportsLoadingDuringRuntime) ||
               (f == kSupportsSavingDuringRuntime) ||
               (f == kSupportsReturnToLauncher) ||
               (f == kSupportsChangingOptionsDuringRuntime);
    };

    void syncSoundSettings() override;

    bool canLoadGameStateCurrently(Common::U32String *msg = nullptr) override {
        return true;
    }
    bool canSaveGameStateCurrently(Common::U32String *msg = nullptr) override {
        return true;
    }

    Common::Error loadGameState(int slot) override;

    Common::Error syncGame(Common::Serializer &s);
    Common::Error syncGameV1(Common::Serializer &s);
    Common::Error syncGameV2(Common::Serializer &s);

    Common::Error saveGameStream(Common::WriteStream *stream, bool isAutosave = false) override {
        Common::Serializer s(nullptr, stream);
        return syncGame(s);
    }
    Common::Error loadGameStream(Common::SeekableReadStream *stream) override {
        Common::Serializer s(stream, nullptr);
        return syncGame(s);
    }

    // Write a raw original-DOS-format save file ("SAVEGAME.N", N=0..9) with no
    // ScummVM wrapper, so it can be loaded by the original game executable.
    // The byte layout is produced directly by syncGame (binary-compatible with
    // saveGameToFile at 1008:6859). Mirrors loadGameState(slot 100..109).
    Common::Error saveOriginalGameState(int dosSlot);

    bool tick() override;

    void sayText(const Common::String &text,
                 Common::TextToSpeechManager::Action action = Common::TextToSpeechManager::INTERRUPT_NO_REPEAT,
                 uint16 speakerObjectId = 0) const;
    void setTTSVoice(uint16 speakerObjectId) const;
    void stopTextToSpeech() const;

    void getHotspotPositions(Common::Array<Graphics::HotspotInfo> &hotspots) override;
    bool hotspotDirty() const override;
    void rebuildHotspotSnapshot() const;

    struct HotspotSnapshot {
        struct SceneHotspotEntry {
            uint16 index = 0;
            Common::Point center;
        };
        struct SceneObjectEntry {
            uint16 index = 0;
            Common::Point position;
            uint16 orientation = 0;
        };

        int currentSceneIndex = -1;
        uint16 numHotspots = 0;
        Common::Array<uint16> hotspotColorTable;
        Common::Array<uint16> hotspotOverrides;
        Common::Array<SceneHotspotEntry> sceneHotspots;
        Common::Array<SceneObjectEntry> sceneObjects;
        bool mapModeActive = false;
    };
    mutable HotspotSnapshot _hotspotSnapshot;
};

extern Macs2Engine *g_engine;
Common::String lookupInteractionDisplayName(uint16 interactionId);

} // End of namespace Macs2

#endif // MACS2_MACS2H