site.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_SITE_H
#define EEM_SITE_H

#include "common/events.h"
#include "common/rect.h"
#include "common/scummsys.h"

#include "graphics/managed_surface.h"

#include "eem/resource.h"  // Picture / Animation

namespace EEM {

class EEMEngine;
class Mystery;

uint partnerFrameAtTick(uint16 seqnum, uint numFrames, uint32 tickMs);

uint oneShotFrameAtTick(uint16 seqnum, uint numFrames, uint32 tickMs);

uint32 oneShotDurationMs(uint16 seqnum, uint numFrames);

void setLondonAnimScripts(bool enabled);

uint bigMapPartnerFrameAtTick(uint numFrames, uint32 elapsedMs, bool london);

uint bigMapDetailPartnerFrameAtTick(uint numFrames, uint32 elapsedMs);

void blitAnimFrameAnchored(Graphics::Surface *screen, const Picture &p,
                           int anchorX, int anchorY);

struct MacSpritePaletteMap {
    byte white;
    byte black;
};

MacSpritePaletteMap getMacSpritePaletteMap();
byte mapMacSpriteColor(byte color, const MacSpritePaletteMap &paletteMap);
void blitMacMaskedSurface(Graphics::Surface *dst, const Picture &p,
                          int x, int y, bool flipX = false);
void blitMacMaskedSurface(Graphics::Surface *dst, const Picture &p,
                          int x, int y, bool flipX,
                          const MacSpritePaletteMap &paletteMap);
void blitMacAnimFrameAnchored(Graphics::Surface *dst, const Picture &p,
                              int anchorX, int anchorY);
void blitMacAnimFrameAnchored(Graphics::Surface *dst, const Picture &p,
                              int anchorX, int anchorY,
                              const MacSpritePaletteMap &paletteMap);

void remapMacSurfaceEndpoints(Graphics::ManagedSurface &surface,
                              const MacSpritePaletteMap &paletteMap);

void cyclePaletteRange(uint8 start, uint8 end);

void cyclePaletteRangeReverse(uint8 start, uint8 end);

void applyHotspotGlowPalette();

struct Hotspot {
    int16  x1, y1, x2, y2;     
    uint16 clueOffset;          
    uint16 hotspotIndex;        
    uint16 extra;               

    Common::Rect rect() const { return Common::Rect(x1, y1, x2, y2); }
};

class SiteScreen : public Common::EventObserver {
public:
    SiteScreen(EEMEngine *vm, Mystery *mystery)
        : _vm(vm), _mystery(mystery) {}

    void enter(uint siteNum, bool resetPartnerMood = true);

    void run();

private:
    bool notifyEvent(const Common::Event &event) override;

    void renderBackground(uint siteNum);
    void renderHotspots(uint siteNum);
    int  hotspotAtPoint(uint siteNum, int x, int y) const;
    int  hotspotCursorId(uint siteNum, int idx) const;
    void updateHotspotCursor(uint siteNum, int x, int y);
    void onHotspotClicked(uint siteNum, uint hotIdx);
    void displayClueAndAutosave(const byte *clueBlock, bool forceSave = false);
    void initImpatienceCounter();
    bool checkImpatienceCounter();
    void notePartnerActivity();
    bool playLondonTravelAnimation(uint fromSite, uint toSite);

    bool enterSiteAnim();

    void renderPartner(uint siteNum, uint32 tickMs);

    bool partnerIdleAnimParams(uint siteNum, uint16 &animId, int &x, int &y);

    bool renderFloppyHotspotPartnerPose(uint siteNum);

    void renderStaticDrops(uint siteNum);
    void renderFloppyDrops(uint siteNum);
    void renderAnimatedDrops(uint siteNum, uint32 tickMs);

    void captureBgSnapshot();

    void restoreBgSnapshot();

    void syncCompositedScreen();

    void scanColorCycles(uint siteNum);

    void applyColorCycles();

    EEMEngine *_vm;
    Mystery *_mystery;
    enum PartnerWaitMood {
        kPartnerWaitDefault,
        kPartnerWaitPatient,
        kPartnerWaitImpatient
    };
    int _snapshotSite = -1;        
    Graphics::ManagedSurface _bgSnapshot;
    uint32 _lastTickMs = 0;        
    uint32 _impatientDeadlineMs = 0; 
    PartnerWaitMood _partnerWaitMood = kPartnerWaitDefault;

    uint32 _waitPhaseAnchor = 0;

    struct ColorCycleRange { uint8 start, end; };
    Common::Array<ColorCycleRange> _colorCycles;
};

} // End of namespace EEM

#endif