lastexpress.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 LASTEXPRESS_LASTEXPRESS_H
#define LASTEXPRESS_LASTEXPRESS_H

#include "lastexpress/debug.h"
#include "lastexpress/game/beetle.h"
#include "lastexpress/game/vcr.h"
#include "lastexpress/game/savegame.h"
#include "lastexpress/sound/slot.h"
#include "lastexpress/sound/sound.h"
#include "lastexpress/sound/subtitle.h"
#include "lastexpress/game/logic.h"
#include "lastexpress/data/sprites.h"
#include "lastexpress/game/nis.h"
#include "lastexpress/game/otis.h"
#include "lastexpress/game/events.h"
#include "lastexpress/fight/fight.h"
#include "lastexpress/menu/menu.h"
#include "lastexpress/graphics.h"
#include "lastexpress/memory.h"

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

#include "engines/engine.h"

#include "graphics/pixelformat.h"

struct ADGameDescription;

namespace LastExpress {

class ArchiveManager;
class GoldArchiveManager;
class CBeetle;
class CFight;
class Clock;
class GraphicsManager;
class LogicManager;
class MemoryManager;
class Menu;
class MessageManager;
class NISManager;
class OtisManager;
class ResourceManager;
class SaveManager;
class Slot;
class SoundManager;
class SpriteManager;
class SubtitleManager;
class VCR;

struct Extent;

enum {
    GF_COMPRESSED = 1 << 0
};

typedef struct Item {
    uint8 mnum;
    uint16 closeUp;
    int8 useable;
    int8 haveIt;
    int8 inPocket;
    int8 floating;

    Item() {
        clear();
    }

    void clear() {
        mnum = 0;
        closeUp = 0;
        useable = 0;
        haveIt = 0;
        inPocket = 0;
        floating = 0;
    }
} Item;

typedef struct Door {
    int8 who;
    int8 status;
    uint8 windowCursor;
    uint8 handleCursor;
    int8 model;

    Door() {
        clear();
    }

    void clear() {
        who = 0;
        status = 0;
        windowCursor = 0;
        handleCursor = 0;
        model = 0;
    }
} Door;

typedef struct Position {
    uint16 position;
    uint16 location;
    uint16 car;

    Position() {
        clear();
    }

    void clear() {
        position = 0;
        location = 0;
        car = 0;
    }
} Position;

typedef struct Sprite {
    byte *compData;
    byte *eraseMask;
    uint16 *colorPalette;
    Extent rect;
    uint16 hotspotX1;
    uint16 hotspotX2;
    uint16 hotspotY1;
    uint16 hotspotY2;
    byte compBits;
    byte compType;
    byte copyScreenAndRedrawFlag;
    byte spritesUnk3;
    byte ticksToWaitUntilCycleRestart;
    byte soundDelay;
    byte soundAction;
    byte flags;
    byte position;
    byte spritesUnk9;
    byte spritesUnk10;
    byte spritesUnk11;
    int spritesUnk8;
    uint16 visibilityDist;
    uint16 hotspotPriority;
    Sprite *nextSprite;

    Sprite() {
        compData = nullptr;
        eraseMask = nullptr;
        colorPalette = nullptr;
        hotspotX1 = 0;
        hotspotX2 = 0;
        hotspotY1 = 0;
        hotspotY2 = 0;
        compBits = 0;
        compType = 0;
        copyScreenAndRedrawFlag = 0;
        spritesUnk3 = 0;
        ticksToWaitUntilCycleRestart = 0;
        soundDelay = 0;
        soundAction = 0;
        flags = 0;
        position = 0;
        spritesUnk9 = 0;
        spritesUnk10 = 0;
        spritesUnk11 = 0;
        spritesUnk8 = 0;
        visibilityDist = 0;
        hotspotPriority = 0;
        nextSprite = nullptr;
    }
} Sprite;

typedef struct Seq {
    int numFrames;
    Sprite *sprites;
    Sprite spriteArrayStart;
    byte gap[18];
    byte *rawSeqData;

    Seq() {
        numFrames = 0;
        sprites = nullptr;
        memset(gap, 0, sizeof(gap));
        rawSeqData = nullptr;
    }

    ~Seq() {
        delete[] sprites;
        sprites = nullptr;
    }
} Seq;

typedef struct CharacterCallParams {
    int parameters[32];

    CharacterCallParams() {
        clear();
    }

    void clear() {
        for (int i = 0; i < 32; i++) {
            parameters[i] = 0;
        }
    }
} CharacterCallParams;

typedef struct Character {
    CharacterCallParams callParams[9];
    uint8 callbacks[16];
    uint8 currentCall;
    Position characterPosition;
    uint8 walkCounter;
    int8 attachedConductor;
    uint8 inventoryItem;
    int8 direction;
    int16 waitedTicksUntilCycleRestart;
    int16 currentFrameSeq1;
    int16 currentFrameSeq2;
    int16 elapsedFrames;
    int16 walkStepSize;
    int8 clothes;
    int8 position2;
    int8 car2;
    int8 doProcessEntity;
    int8 needsPosFudge;
    int8 needsSecondaryPosFudge;
    int8 directionSwitch;
    char sequenceName[13];
    char sequenceName2[13];
    char sequenceNamePrefix[7];
    char sequenceNameCopy[13];
    Sprite *frame1;
    Sprite *frame2;
    Seq *sequence1;
    Seq *sequence2;
    Seq *sequence3;

    Character() {
        reset();
    }

    void reset() {
        memset(callbacks, 0, sizeof(callbacks));
        currentCall = 0;
        walkCounter = 0;
        attachedConductor = 0;
        inventoryItem = 0;
        direction = 0;
        waitedTicksUntilCycleRestart = 0;
        currentFrameSeq1 = 0;
        currentFrameSeq2 = 0;
        elapsedFrames = 0;
        walkStepSize = 0;
        clothes = 0;
        position2 = 0;
        car2 = 0;
        doProcessEntity = 0;
        needsPosFudge = 0;
        needsSecondaryPosFudge = 0;
        directionSwitch = 0;

        memset(sequenceName, 0, sizeof(sequenceName));
        memset(sequenceName2, 0, sizeof(sequenceName2));
        memset(sequenceNamePrefix, 0, sizeof(sequenceNamePrefix));
        memset(sequenceNameCopy, 0, sizeof(sequenceNameCopy));

        frame1 = nullptr;
        frame2 = nullptr;
        sequence1 = nullptr;
        sequence2 = nullptr;
        sequence3 = nullptr;
    }

} Character;

typedef struct Characters {
    Character characters[40];
} Characters;

typedef struct Line7 {
    int slope;
    int intercept;
    char lineType;
    Line7 *next;

    Line7() {
        slope = 0;
        intercept = 0;
        lineType = 0;
        next = nullptr;
    }

    ~Line7() {
        if (next) {
            delete next;
            next = nullptr;
        }
    }

} Line7;

typedef struct Link {
    uint16 left;
    uint16 right;
    uint16 top;
    uint16 bottom;
    Line7 *lineList;
    uint16 scene;
    uint8 location;
    uint8 action;
    uint8 param1;
    uint8 param2;
    uint8 param3;
    uint8 cursor;
    Link *next;

    Link() {
        left = 0;
        right = 0;
        top = 0;
        bottom = 0;
        lineList = nullptr;
        scene = 0;
        location = 0;
        action = 0;
        param1 = 0;
        param2 = 0;
        param3 = 0;
        cursor = 0;
        next = nullptr;
    }

    ~Link() {
        if (lineList) {
            delete lineList;
            lineList = nullptr;
        }

        if (next) {
            delete next;
            next = nullptr;
        }
    }

    void copyFrom(Link *otherLink) {
        left = otherLink->left;
        right = otherLink->right;
        top = otherLink->top;
        bottom = otherLink->bottom;
        lineList = nullptr;
        scene = otherLink->scene;
        location = otherLink->location;
        action = otherLink->action;
        param1 = otherLink->param1;
        param2 = otherLink->param2;
        param3 = otherLink->param3;
        cursor = otherLink->cursor;
        next = nullptr;
    }
} Link;

typedef struct Node {
    char sceneFilename[9];
    Position nodePosition;
    uint8 cathDir;
    uint8 property;
    uint8 parameter1;
    uint8 parameter2;
    uint8 parameter3;
    Link *link;

    Node() {
        memset(sceneFilename, 0, sizeof(sceneFilename));
        cathDir = 0;
        property = 0;
        parameter1 = 0;
        parameter2 = 0;
        parameter3 = 0;
        link = nullptr;
    }

    ~Node() {
        if (link) {
            delete link;
            link = nullptr;
        }
    }
} Node;

#include "common/pack-start.h"
typedef struct TGAHeader {
    uint8 idLength;
    uint8 colorMapType;
    uint8 imageType;
    uint16 colorMapFirstEntryIndex;
    uint16 colorMapLength;
    uint8 colorMapEntrySize;
    uint16 xOrigin;
    uint16 yOrigin;
    uint16 width;
    uint16 height;
    uint8 bitsPerPixel;
    uint8 imageDescriptor;
    byte *rawDataPtr; // Not in the original, but we need it to avoid pointer fix-ups...

    TGAHeader() {
        idLength = 0;
        colorMapType = 0;
        imageType = 0;
        colorMapFirstEntryIndex = 0;
        colorMapLength = 0;
        colorMapEntrySize = 0;
        xOrigin = 0;
        yOrigin = 0;
        width = 0;
        height = 0;
        bitsPerPixel = 0;
        imageDescriptor = 0;
        rawDataPtr = nullptr;
    }
} TGAHeader;
#include "common/pack-end.h"

typedef struct FontData {
    uint16 palette[16];
    uint8 charMap[256];
    uint8 charKerning[256];
    byte *fontData;

    FontData() {
        memset(palette, 0, sizeof(palette));
        memset(charMap, 0, sizeof(charMap));
        memset(charKerning, 0, sizeof(charKerning));
        fontData = nullptr;
    }

    ~FontData() {
        memset(palette, 0, sizeof(palette));
        memset(charMap, 0, sizeof(charMap));
        memset(charKerning, 0, sizeof(charKerning));

        if (fontData) {
            free(fontData);
            fontData = nullptr;
        }
    }
} FontData;

typedef struct NisSprite {
    byte *compData;
    byte *eraseMask;
    uint16 *colorPalette;
    Extent rect;
    uint16 gammaPalette[128];
    byte compBits;

    NisSprite() {
        compData = nullptr;
        eraseMask = nullptr;
        colorPalette = nullptr;
        memset(gammaPalette, 0, sizeof(gammaPalette));
        compBits = 0;
    }
} NisSprite;

typedef struct NisEvents {
    int16 eventType;
    int16 eventTime;
    int32 eventSize;

    NisEvents() {
        eventType = 0;
        eventTime = 0;
        eventSize = 0;
    }
} NisEvents;

#define MEM_PAGE_SIZE  0x800

#define DEMO_TIMEOUT 2700

typedef uint16 PixMap;

class LastExpressEngine : public Engine {
    // AARGH! Remove!
    friend class VCR;
    friend class SubtitleManager;

protected:
    // Engine APIs
    Common::Error run() override;
    bool hasFeature(EngineFeature f) const override;

public:
    LastExpressEngine(OSystem *syst, const ADGameDescription *gd);
    ~LastExpressEngine() override;

    // Misc
    Common::RandomSource& getRandom() {return _random; }

    // Managers
    ArchiveManager  *getArchiveManager()  const { return _archiveMan;  }
    GraphicsManager *getGraphicsManager() const { return _graphicsMan; }
    SubtitleManager *getSubtitleManager() const { return _subtitleMan; }

    MemoryManager  *getMemoryManager()  const { return _memMan;    }
    MessageManager *getMessageManager() const { return _msgMan;    }
    NISManager     *getNISManager()     const { return _nisMan;    }
    SoundManager   *getSoundManager()   const { return _soundMan;  }
    LogicManager   *getLogicManager()   const { return _logicMan;  }
    OtisManager    *getOtisManager()    const { return _otisMan;   }
    SpriteManager  *getSpriteManager()  const { return _spriteMan; }
    SaveManager    *getSaveManager()    const { return _saveMan;   }

    VCR   *getVCR()   const { return _vcr;   }
    Menu  *getMenu()  const { return _menu;  }
    Clock *getClock() const { return _clock; }

    // Event handling
    bool handleEvents();

    bool isDemo() const;
    bool isGoldEdition() const;
    bool isCompressed() const;

    Common::String getTargetName() const;

    // NEW STUFF
    static void soundTimerHandler(void *refCon);

    int32 _soundFrameCounter = 0;

    Common::Mutex *_soundMutex;
    const char *_savegameFilename = nullptr;
    const char *_savegameTempNames[7] = {
        "blue.tmp",
        "red.tmp",
        "green.tmp",
        "purple.tmp",
        "teal.tmp",
        "gold.tmp",
        "temp.tmp"
    };

    const char *_savegameNames[6] = {
        "blue.egg",
        "red.egg",
        "green.egg",
        "purple.egg",
        "teal.egg",
        "gold.egg"
    };

    CVCRFile *_savegame = nullptr;

    int32 _currentGameFileColorId = -1;
    int32 _gracePeriodTimer = 0;
    bool _eventTickInternal = false;
    
    bool _doShowCredits = false;
    int32 _currentSavePoint = 0;
    int32 _lastSavePointIdInFile = 0;
    int32 _gameTimeOfLastSavePointInFile = 0;
    int32 _gracePeriodIndex = 0;
    int32 _fightSkipCounter = 0;
    
    bool _navigationEngineIsRunning = false;
    bool _stopUpdatingCharacters = false;
    bool _charactersUpdateRecursionFlag = false;
    bool _mouseHasLeftClicked = false;
    bool _mouseHasRightClicked = false;
    bool _fastWalkJustDeactivated = false;

    int32 _cursorX  = 320;
    int32 _cursorY  = 240;
    int32 _cursorXOffscreenOffset = 0;
    int32 _cursorYOffscreenOffset = 0;
    int _cursorType = 0;

    bool _systemEventLeftMouseDown = false;
    bool _systemEventRightMouseDown = false;
    Common::Point _systemEventLastMouseCoords;

    bool _pendingExitEvent = false;
    bool _exitFromMenuButton = false;
    int32 _lastForcedScreenUpdateTicks = 0; // Not in the original

    Seq *_doorSeqs[8] = { nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr };
    Seq *_clockHandsSeqs[2] = { nullptr, nullptr };
    int32 _clockHandsValues[2] = { 0, 0 };

    int32 _fudgePosition[41] = {
           0,  851, 1430, 2110,    0, 2410, 2980, 3450,
        3760, 4100, 4680, 5140, 5440, 5810, 6410, 6850,
        7160, 7510, 8514,    0,    0,    0, 2086, 2690,
           0, 3110, 3390, 3890, 4460, 4770, 5090, 5610,
        6160, 6460, 6800, 7320, 7870, 8160, 8500, 9020,
        9269
    };

    // DYNAMIC ALLOC
    byte *_globalMemoryPool = nullptr;
    byte *_soundMemoryPool = nullptr;
    byte *_cursorsMemoryPool = nullptr;
    Characters *_characters = nullptr;

    SVCRSavePointHeader *_savePointHeaders = nullptr;

    // GENERAL
    void startUp();
    void shutDown();

    void waitForTimer(int millis);
    void initGameData();
    void startNewGame();
    void engineEventHandler(Event *event);

    int32 getSoundFrameCounter();

    bool getEventTickInternal();
    void setEventTickInternal(bool flag);

    void mouseSetLeftClicked(bool hasClicked);
    void mouseSetRightClicked(bool hasClicked);
    bool mouseHasLeftClicked();
    bool mouseHasRightClicked();

    // BEETLE
    CBeetle *_beetle = nullptr;
    void doBeetle();
    void endBeetle();
    void positionSprite(Sprite *sprite, Common::Point coord);

    // CREDITS
    void doCredits();
    void abortCredits();
    void creditsMouse(Event *event);
    void creditsTimer(Event *event);
    int32 readTGAIntoMemory(const char *filename, TGAHeader *tgaHeader);
    void constructPalette(TGAHeader *tgaHeader, uint16 *palette);

    // DEMO CREDITS
    bool demoEnding(bool wonGame);
    void demoEndingMouse(Event *event);
    void demoEndingTimer(Event *event);

    // EVENT HANDLERS
    void engineEventHandlerWrapper(Event *event);

    void nodeStepMouseWrapper(Event *event);
    void nodeStepTimerWrapper(Event *event);

    void eggMouseWrapper(Event *event);
    void eggTimerWrapper(Event *event);

    void nisMouseWrapper(Event *event);
    void nisTimerWrapper(Event *event);

    void creditsMouseWrapper(Event *event);
    void creditsTimerWrapper(Event *event);

    void demoEndingMouseWrapper(Event *event);
    void demoEndingTimerWrapper(Event *event);

    void fightMouseWrapper(Event *event);
    void fightTimerWrapper(Event *event);

    void emptyHandler(Event *event);

    int _savedFrameCounter = 0;
    int32 _savedFrameInterval = 0;
    int _doCredits = 0;

    void (LastExpressEngine::*_savedTimerEventHandle)(Event *) = nullptr;
    void (LastExpressEngine::*_savedMouseEventHandle)(Event *) = nullptr;

    // FIGHT
    int doFight(int fightId);
    void abortFight();

    CFight *_fight = nullptr;

    // DEBUGGER
    void showEngineInfo();

    bool _lockGracePeriod = false;

private:
    const ADGameDescription *_gameDescription;
    Graphics::PixelFormat _pixelFormat;

    // Misc
    Debugger *_debugger;
    Common::RandomSource _random;

    // Game
    Menu *_menu = nullptr;
    Clock *_clock = nullptr;
    VCR *_vcr = nullptr;

    // Managers
    ArchiveManager  *_archiveMan = nullptr;
    GraphicsManager *_graphicsMan = nullptr;
    SoundManager    *_soundMan = nullptr;
    LogicManager    *_logicMan = nullptr;
    OtisManager     *_otisMan = nullptr;
    SpriteManager   *_spriteMan = nullptr;
    MemoryManager   *_memMan = nullptr;
    MessageManager  *_msgMan = nullptr;
    NISManager      *_nisMan = nullptr;
    SaveManager     *_saveMan = nullptr;
    SubtitleManager *_subtitleMan = nullptr;
};

} // End of namespace LastExpress

#endif // LASTEXPRESS_LASTEXPRESS_H