eem.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 EEM_EEM_H
#define EEM_EEM_H

#include "common/array.h"
#include "common/events.h"
#include "common/keyboard.h"
#include "common/language.h"
#include "common/platform.h"
#include "common/random.h"
#include "common/rect.h"
#include "common/scummsys.h"

#include "common/serializer.h"

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

#include "graphics/paletteman.h"

#include "eem/animation.h"
#include "eem/font.h"
#include "eem/mystery.h"
#include "eem/resource.h"

namespace EEM {

class TravisScrollBar;

class AudioPlayer;
class MusicPlayer;

const uint kPalSize = 768;

// Keep game colors uncorrected for fades and color matching. Apply the Mac
// monitor gamma curve only when sending a palette to the backend.
class MacPaletteManager : public PaletteManager {
public:
    void setPalette(const byte *colors, uint start, uint num) override;
    void grabPalette(byte *colors, uint start, uint num) const override;

private:
    byte _colors[kPalSize] = {};
};

PaletteManager *getPaletteManager();

void fadeCurrentPaletteToBlack(uint delayMs = 8);
void fadePaletteFromBlack(const byte *target, uint delayMs = 8);

enum ScreenId {
    kScreenInvalid        = 0xFFFF,
    kScreenInitClues      = 0x00,
    kScreenMap            = 0x01,
    kScreenMapAlt         = 0x02,
    kScreenSite           = 0x03,
    kScreenNotebook       = 0x04,
    kScreenGallery        = 0x05,
    kScreenSetup          = 0x06,
    kScreenAccuse         = 0x07,
    kScreenProfile        = 0x08,
    kScreenChoosePartner  = 0x09,
    kScreenChooseMystery  = 0x0A,
    kScreenTitle          = 0x0B,
    kScreenAction         = 0x0C
};

enum Variant {
    kVariantCD        = 0,
    kVariantFloppy    = 1,
    kVariantLondonCD  = 2,
    kVariantMacFloppy = 3,
    kVariantMacCD     = 4,
};

enum Partner {
    kPartnerJake  = 0,
    kPartnerJenny = 1,
};

constexpr int kScreenWidth  = 320;
constexpr int kScreenHeight = 200;
constexpr int kMacScreenWidth  = 512;
constexpr int kMacScreenHeight = 384;

constexpr Common::Rect kPdaSiteRect             (Common::Point(35, 111), 21, 25);
constexpr Common::Rect kPdaPartnerFootMapRect   (Common::Point( 7, 177), 50, 23);
constexpr Common::Rect kPdaPartnerHeadHintRect  (Common::Point( 5,  80), 39, 30);

class EEMEngine : public Engine {
    friend class Debugger;

public:
    EEMEngine(OSystem *syst, const ADGameDescription *gameDesc);
    ~EEMEngine() override;

    Common::Error run() override;
    PaletteManager *getPaletteManager();

    const char *getGameId() const;
    Common::Platform getPlatform() const;
    Variant getVariant() const { return _variant; }
    bool isFloppy() const { return _variant == kVariantFloppy || isDemo(); }
    bool isLondon() const { return _variant == kVariantLondonCD; }
    bool isMacCD() const { return _variant == kVariantMacCD; }
    // London (game) and Macintosh (platform) are orthogonal -- the London CD
    // shipped for both DOS and Mac -- so derive Mac-ness from the platform
    // rather than the single-valued `_variant` (which can only hold one of
    // them at a time). This lets EEM2 Mac be both London and Macintosh.
    bool isMacintosh() const { return getPlatform() == Common::kPlatformMacintosh; }
    bool isMacTalkie() const { return isMacCD() || (isMacintosh() && isLondon()); }
    bool isDemo() const {
        return _gameDescription && (_gameDescription->flags & ADGF_DEMO);
    }
    int screenWidth() const { return isMacintosh() ? kMacScreenWidth : kScreenWidth; }
    int screenHeight() const { return isMacintosh() ? kMacScreenHeight : kScreenHeight; }
    int scaleX(int x) const {
        return isMacintosh() ? scaleCoord(x, kMacScreenWidth, kScreenWidth) : x;
    }
    int scaleY(int y) const {
        return isMacintosh() ? scaleCoord(y, kMacScreenHeight, kScreenHeight) : y;
    }
    int unscaleX(int x) const {
        return isMacintosh() ? scaleCoord(x, kScreenWidth, kMacScreenWidth) : x;
    }
    int unscaleY(int y) const {
        return isMacintosh() ? scaleCoord(y, kScreenHeight, kMacScreenHeight) : y;
    }
    Common::Point scalePoint(int x, int y) const {
        return Common::Point(scaleX(x), scaleY(y));
    }
    Common::Rect scaleRect(const Common::Rect &r) const {
        return Common::Rect(scaleX(r.left), scaleY(r.top),
                            scaleX(r.right), scaleY(r.bottom));
    }

    bool hasFeature(EngineFeature f) const override;
    bool canLoadGameStateCurrently(Common::U32String *msg = nullptr) override;
    bool canSaveGameStateCurrently(Common::U32String *msg = nullptr) override;

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

    Common::Error saveGameStream(Common::WriteStream *stream,
                                  bool isAutosave = false) override;
    Common::Error loadGameStream(Common::SeekableReadStream *stream) override;

    Common::Error saveProfile(const Common::String &name);

    bool loadProfile(const Common::String &name);

    SaveStateList listProfiles() const;

    const ADGameDescription *_gameDescription;
    Variant _variant = kVariantCD;
    Common::Language _language = Common::EN_ANY;

    bool isSpanish() const { return _language == Common::ES_ESP; }

    DBDArchive &getPics()    { return _picsArchive; }
    DBDArchive &getAni()     { return _aniArchive; }
    DBDArchive &getSites()   { return _sitesArchive; }
    DBDArchive &getBalloons() { return _balloonArchive; }
    DBDArchive &getButtons() { return _buttonArchive; }
    Mystery    &getMystery() { return _mystery; }
    const EEMFont &getFont() const { return _font; }
    uint8       getPartnerIndex() const { return _partner; }

    void setInteractiveMouseCursor(bool active);

    void setHotspotMouseCursor(bool active);

    void setSiteHotspotCursorId(int cursorId);

    void displayClue(const byte *clueBlock, uint maxEntries = 32);

    bool doPuzzle(uint puzzleId);
    bool doMacLondonPuzzle(Common::SeekableReadStream &stream);

    void displayFloppyHotspotDialog(uint siteNum, uint hotIdx);

    bool floppyHotspotSearched(uint siteNum, uint hotspotIdx) const;

    const Common::String &playerName() const { return _playerName; }

    void applyClueSideEffects(const byte *entry);

    void doNotebook();
    void doGallery();
    bool moreInfo(const byte *gd, uint suspectIdx,
                   const Picture &galBg, bool haveBg);
    void doBigMap();

    void doAccuse();
    void doAccuseFloppy();

    bool doAccuseNotes();

    void drawKDBalloonOverCurrentScreen(Common::String text);

    void doHelp();

    void doInterfaceHelp(uint num = 0);

    uint16 getKDTextBalloon(byte firstChar) const;

    uint16 fitBalloonToText(uint16 bubNum, const Common::String &text);

    uint getBalloonLineCapacity(uint16 balloonId, int lineH) const;

    Common::String parseString(const Common::String &raw,
                               const Common::String &playerName,
                               uint partner) const;

    bool loadKdAnim(uint16 num, Animation &anim, int &px, int &py,
                    uint16 &animId);

    void setPartnerEraseBg(const Graphics::ManagedSurface *bg);

    void setPartnerIdleAnim(bool has, uint16 animId, int x, int y) {
        _hasPartnerIdle = has;
        _partnerIdleAnimId = animId;
        _partnerIdleX = x;
        _partnerIdleY = y;
    }

    bool getBalloonInsets(uint16 bubNum, uint16 &xInset, uint16 &yInset,
                          uint16 &textW) const;
    bool getBalloonIndicatorPos(uint16 bubNum, uint16 &dx,
                                 uint16 &dy) const;

    void drawFloppyBubbleIndicator(Graphics::ManagedSurface &dst,
                                   uint16 bubNum, int ballX, int ballY,
                                   bool endIndicator);

    bool areYouSure();

private:
    void applyStartupTestOverrides();
    bool areYouSureMac();
    bool areMysteriesSolved(uint lo, uint hi) const;

    bool anyMysterySolved(uint lo, uint hi) const;

    uint mysteryTierCount() const { return isLondon() ? 2 : 3; }

    bool mysteryTierRange(uint stage, uint &lo, uint &hi) const;

    void advanceChainStageAfterSolve(uint mysteryNum);
    void applySkipRepeatedCasesOption();

    void screenDriver();

    void drawNotebookFrame(int &page, TravisScrollBar *scrollBar = nullptr);

    Common::String notebookNoteText(uint clueId, const byte *ni,
                                    uint16 niCount, bool floppyNb,
                                    const byte *bufBase,
                                    uint32 mysSz) const;

    struct AccuseNotesCtx {
        const byte *ni;
        uint16 niCount;
        bool floppyNote;
        const byte *bufBaseNotes;
        const Common::Array<uint> *found;
        int rectX, rectY, rectW, rectH;
        uint expected;
        bool haveBg;
        const Picture *accuseBg;
        Common::Array<Common::Rect> *slotRects;
        Common::Array<uint> *slotClues;
        int *pageBreaks;
        int pageBreaksCap;
        int *numPages;
        int *page;
        TravisScrollBar *scrollBar = nullptr;
    };

    Common::String accuseNoteText(uint clueId, const AccuseNotesCtx &ctx) const;

    void accuseRebuildPagination(const AccuseNotesCtx &ctx);

    void accuseDrawScreen(const AccuseNotesCtx &ctx);

    void floppyKDHint(uint kdSlot, const byte *kdIdx,
                      const byte *bufBase, uint32 mysSize);
    void displayScrapbookExtra(uint mysteryNum);
    void displayMacPracticeScrapbook();
    void accuseDrawGallery(int highlighted,
                           Common::Array<Common::Rect> &rects,
                           Common::Array<int> &suspects, uint8 num,
                           bool haveAccuseBg, const Picture &accuseBg);
    void drawGalleryFrame(const byte *gd, uint8 numSuspects,
                          Common::Array<Common::Rect> &slotRects,
                          Common::Array<int> &slotSuspect);

    struct BigMapOverviewState {
        Common::Rect window;
        int zoomX = 0;
        int zoomY = 0;
    };

    struct BigMapDetailState {
        const Common::Array<byte> *mapPixels = nullptr;
        uint16 mapW = 0;
        uint16 mapH = 0;

        int scrollX = 0;
        int scrollY = 0;
        int maxScrollX = 0;
        int maxScrollY = 0;

        int mapWinX = 0;
        int mapWinY = 0;
        int mapWinW = 0;
        int mapWinH = 0;

        Common::Rect returnRect;
        Common::Rect setupRect;
        Common::Rect arrowYUp;
        Common::Rect arrowYDown;
        Common::Rect arrowXLeft;
        Common::Rect arrowXRight;
        Common::Rect xSlider;
        Common::Rect ySlider;

        int arrowStepX = 0;
        int arrowStepY = 0;

        uint32 startTick = 0;
        uint32 lastDrawTick = 0;
        uint32 lastCycleTick = 0;
    };

    bool bigMapRunOverview(BigMapOverviewState &state);
    bool bigMapLoadDetailPixels(Common::Array<byte> &mapPixels,
                                uint16 &mapW, uint16 &mapH);
    void bigMapInitDetailState(BigMapDetailState &state,
                               const Common::Array<byte> &mapPixels,
                               uint16 mapW, uint16 mapH,
                               const BigMapOverviewState &overview);
    bool bigMapRunDetail(BigMapDetailState &state);
    bool bigMapHandleDetailEvent(const Common::Event &ev,
                                 BigMapDetailState &state,
                                 bool &returnToOverview, bool &dirty);
    void bigMapHandleDetailKey(const Common::Event &ev,
                               BigMapDetailState &state, bool &dirty);
    bool bigMapHandleDetailMouseDown(const Common::Event &ev,
                                     BigMapDetailState &state,
                                     bool &returnToOverview, bool &dirty);
    bool bigMapTrySelectDetailSite(int mouseX, int mouseY,
                                   const BigMapDetailState &state);
    void bigMapCycleOverviewPalette(bool mac);
    void bigMapCycleDetailPalette(bool mac);
    void drawBigMapOverview(uint32 elapsedMs);
    void drawBigMapDetail(int scrollX, int scrollY,
                          const Common::Array<byte> &mapPixels,
                          uint16 mapW, uint16 mapH,
                          uint32 elapsedMs);
    void drawAccuseGallery(uint8 numSuspects, const byte *gd,
                           int highlighted,
                           Common::Array<Common::Rect> &slotRects,
                           Common::Array<int> &slotSuspect);

    bool openArchives();

    bool loadSitePalettes();

    void setSitePalette(uint num);

    bool getSitePalette(uint num, byte *out) const;

    bool setAnmPalette(const Common::Path &anmPath);

public:
    void setSitePaletteForSite(uint siteNum) { setSitePalette(siteNum + 1); }
private:

    void blitAt(const Picture &pic, int x, int y);

    void blitAtScaled(const Picture &pic, int x, int y, int scale);

public:
    void waitForInput(uint32 maxMs);

    bool playAnm(const Common::Path &path, uint frameDelayMs = 120,
                 bool holdLastFrame = false, bool fadeIn = false,
                 bool setSkipIntroOnEsc = true, bool showLastFrameOnSkip = false);

    void playFlc(const Common::Path &path, bool fadeIn = false,
                 bool holdLastFrame = false, uint16 backgroundPict = 0);

private:
    void interruptAudio(bool stopMusicToo = true);

    void showEAKidsLogo();
    void showHighScoreLogo();
    void showFloppyStormLogo();

    bool waitIntroDelay(uint32 maxMs);
    void runMacStartup();
    void playMacCDIntro();
    void showMacEAKidsLogo();
    void showMacStillLogo(uint picId, uint palId, uint holdMs,
                          bool playThunder);
    void showMacTitleIntro();

    void runLondonStartup();
    void showMacLondonTitle();
    bool startLondonTrainingMystery();
    void showLondonEAKidsLogo();
    void showStillPicture(uint picId, uint palId, uint holdMs,
                          bool playThunder = false, bool holdLastFrame = false);
    void showLondonCharSelect();
    void playLondonInitCluesAnim(uint16 caseType, const Picture &bg,
                                 bool haveBriefingBg);
    void playMacLondonInitCluesAnim(uint16 caseType, const Picture &bg,
                                    bool haveBriefingBg);
    void playCdFloppyInitCluesAnim(uint16 caseType, bool floppy,
                                   const Picture &bg, bool haveBriefingBg);

    void doProfilePicker();
    void doNewPlayer();
    void doChoosePartner();

    int doShowEnding(uint num, bool firstPage = true);

    void doShowScrapbook(uint stage);

    void doActionScreen();
    void doCaseSelection();
    void doSiteLoop();

    void doSetup();

    void setupDrawScreen();
    Common::KeyCode setupShowFullscreenPic(uint16 picId, bool transparent);
    void setupLeave();

    void doSetupLondon();
    void setupDrawScreenLondon();
    void setupShowSavedConfirm();

    void doInitClues();

    void displayFloppyBriefing(const byte *initBlock);

    void displayFloppyDialogRecords(const byte *rec, uint count,
                                     uint lastIndicator = 0);

    bool floppyDialogWaitForClick();

public:
    void startTravelMusic();
    void finishTravelMusic(bool skipped);

    void waitForMusicDone(uint32 maxMs = 60000);

    void stopMusic();

    bool doLondonApproach(uint16 approachId);

    void syncSoundSettings() override;

    void startLondonTravelMusic(uint8 travelKind);
    bool playMacLondonTravelAnimation(uint8 travelKind);
private:
    static int scaleCoord(int value, int target, int source) {
        const bool negative = value < 0;
        const int magnitude = negative ? -value : value;
        const int scaled = (magnitude * target + source / 2) / source;
        return negative ? -scaled : scaled;
    }

    Common::String _playerName;  

    bool _playerFemale = false;

    uint8 _mysteriesSolved[55] = {};
    uint8 _chainStage = 1;
    // Applied on case selection to preserve the current case's difficulty.
    uint8 _pendingBookUnlock = 0;

    bool _voiceOn = true;
    bool _musicOn = true;

    bool _profileCreatedThisSession = false;

    Common::RandomSource _rng;

    DBDArchive _picsArchive;     
    DBDArchive _aniArchive;      
    DBDArchive _sitesArchive;    
    DBDArchive _balloonArchive;  
    DBDArchive _buttonArchive;   
    Mystery    _mystery;         
    EEMFont    _font;            
    EEMFont    _dialogFont;      
    EEMFont    _newspaperFont;

    Common::Array<byte> _sitePals; 
    MacPaletteManager _macPaletteManager;

    uint16 _lastScreen;  
    uint16 _nextScreen;  
    uint8  _partner;     

    bool _skipIntro = false;

    Graphics::ManagedSurface _partnerEraseBg;

    bool   _hasPartnerIdle = false;
    uint16 _partnerIdleAnimId = 0;
    int    _partnerIdleX = 0;
    int    _partnerIdleY = 0;

    bool _interactiveMouseCursor = false;
    int _siteCursorId = 0;

    int _lastSiteArrivalAnim = -1;

    bool _restoredContentDataLoaded = false;

    MusicPlayer *_music = nullptr;

public:
    AudioPlayer *_audio = nullptr;

    void setNextScreen(ScreenId s) { _nextScreen = s; }
    bool shouldPlaySiteArrival(uint siteNum) const {
        return _lastSiteArrivalAnim != (int)siteNum;
    }
    void markSiteArrivalPlayed(uint siteNum) {
        _lastSiteArrivalAnim = (int)siteNum;
    }
    void resetSiteArrivalState() {
        _lastSiteArrivalAnim = -1;
    }
    void setSiteArrivalState(uint siteNum) {
        _lastSiteArrivalAnim = (int)siteNum;
    }
};

Common::Rect pdaControlRect(const EEMEngine *vm, const Common::Rect &rect);

} // End of namespace EEM

#endif