castle.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/>.
 *
 */

namespace Freescape {

class MusicPlayer;

struct RiddleText {
    int8 _dx;
    int8 _dy;
    Common::String _text;

    RiddleText(int8 dx, int8 dy, const Common::String &text) : _dx(dx), _dy(dy), _text(text) {}
};

struct Riddle {
    Common::Point _origin;
    Common::Array<RiddleText> _lines;
};

class CastleEngine : public FreescapeEngine {
public:
    CastleEngine(OSystem *syst, const ADGameDescription *gd);
    ~CastleEngine();

    // Only in DOS
    Graphics::ManagedSurface *_option;
    Graphics::ManagedSurface *_menuButtons;
    Graphics::ManagedSurface *_menuCrawlIndicator;
    Graphics::ManagedSurface *_menuWalkIndicator;
    Graphics::ManagedSurface *_menuRunIndicator;
    Graphics::ManagedSurface *_menuFxOnIndicator;
    Graphics::ManagedSurface *_menuFxOffIndicator;
    Graphics::ManagedSurface *_menu;
    byte *_cursorData;       // diagonal arrow (outside view area)
    byte *_crosshairData;    // crosshair (# pointer, inside view area)
    int _cursorW;
    int _cursorH;
    void setAmigaCursor(bool crosshair);

    void beforeStarting() override;
    void initKeymaps(Common::Keymap *engineKeyMap, Common::Keymap *infoScreenKeyMap, const char *target) override;
    void initGameState() override;
    bool triggerWinCondition() override;
    void endGame() override;
    void executeEscapeCameraSequence();

    void drawInfoMenu() override;
    void loadAssets() override;
    void loadAssetsDOSFullGame() override;
    void loadAssetsDOSDemo() override;
    void loadAssetsAmigaDemo() override;
    void loadAssetsAmigaFullGame() override;
    void loadAssetsAtariFullGame() override;
    void loadAssetsZXFullGame() override;
    void loadAssetsCPCFullGame() override;
    void borderScreen() override;
    void selectCharacterScreen();
    bool playAmigaIntro();
    bool playAtariIntro();
    void drawOption();

    void initZX();
    void initDOS();
    void initCPC();
    void initC64();

    void loadAssetsC64FullGame() override;
    void drawC64UI(Graphics::Surface *surface) override;

    void drawDOSUI(Graphics::Surface *surface) override;
    void drawZXUI(Graphics::Surface *surface) override;
    void drawCPCUI(Graphics::Surface *surface) override;
    void drawAmigaAtariSTUI(Graphics::Surface *surface) override;
    void drawEnergyMeter(Graphics::Surface *surface, Common::Point origin);
    void drawLiftingGate(Graphics::Surface *surface);
    void drawDroppingGate(Graphics::Surface *surface);
    void pressedKey(const int keycode) override;
    void releasedKey(const int keycode) override;
    void checkSensors() override;
    void updateTimeVariables() override;
    void drawBackground() override;

    bool checkIfGameEnded() override;
    void drawSensorShoot(Sensor *sensor) override;

    void executePrint(FCLInstruction &instruction) override;
    void executeDestroy(FCLInstruction &instruction) override;
    void executeRedraw(FCLInstruction &instruction) override;
    void gotoArea(uint16 areaID, int entranceID) override;
    Common::Error saveGameStreamExtended(Common::WriteStream *stream, bool isAutosave = false) override;
    Common::Error loadGameStreamExtended(Common::SeekableReadStream *stream) override;

    Common::Array<Riddle> _riddleList;
    Common::BitArray _fontPlane1;
    Common::BitArray _fontPlane2;
    Common::BitArray _fontPlane3;

    void drawRiddleStringInSurface(const Common::String &str, int x, int y, uint32 fontColor, uint32 backColor, Graphics::Surface *surface);
    Graphics::ManagedSurface *loadFrameWithHeaderDOS(Common::SeekableReadStream *file);
    Common::Array <Graphics::ManagedSurface *>loadFramesWithHeaderDOS(Common::SeekableReadStream *file, int numFrames);

    Common::Array<Graphics::ManagedSurface *> loadFramesWithHeader(Common::SeekableReadStream *file, int pos, int numFrames, uint32 front, uint32 back);
    Graphics::ManagedSurface *loadFrameWithHeader(Common::SeekableReadStream *file, int pos, uint32 front, uint32 back);

    // CPC-specific frame loading (Mode 1: 4 pixels per byte)
    // cpcPalette is a 4-entry array mapping CPC ink numbers (0-3) to ARGB colors
    Common::Array<Graphics::ManagedSurface *> loadFramesWithHeaderCPC(Common::SeekableReadStream *file, int pos, int numFrames, const uint32 *cpcPalette);
    Graphics::ManagedSurface *loadFrameWithHeaderCPC(Common::SeekableReadStream *file, int pos, const uint32 *cpcPalette);
    Graphics::ManagedSurface *loadFrameCPC(Common::SeekableReadStream *file, Graphics::ManagedSurface *surface, int width, int height, const uint32 *cpcPalette);

    Graphics::ManagedSurface *loadFrameFromPlanes(Common::SeekableReadStream *file, int widthInBytes, int height);
    Graphics::ManagedSurface *loadFrameFromPlanesInternal(Common::SeekableReadStream *file, Graphics::ManagedSurface *surface, int width, int height);

    Graphics::ManagedSurface *loadFrameFromPlanesVertical(Common::SeekableReadStream *file, int widthInBytes, int height);
    Graphics::ManagedSurface *loadFrameFromPlanesInternalVertical(Common::SeekableReadStream *file, Graphics::ManagedSurface *surface, int width, int height, int plane);
    Graphics::ManagedSurface *loadFrameFromPlanesInterleaved(Common::SeekableReadStream *file, int widthInWords, int height);

    Common::Array<Graphics::ManagedSurface *>_keysBorderFrames;
    Common::Array<Graphics::ManagedSurface *>_keysMenuFrames;
    Graphics::ManagedSurface *_spiritsMeterIndicatorBackgroundFrame;
    Graphics::ManagedSurface *_spiritsMeterIndicatorFrame;
    Graphics::ManagedSurface *_spiritsMeterIndicatorSideFrame;
    Graphics::ManagedSurface *_strenghtBackgroundFrame;
    Graphics::ManagedSurface *_strenghtBarFrame;
    Common::Array<Graphics::ManagedSurface *> _strenghtWeightsFrames;
    Common::Array<Graphics::ManagedSurface *> _flagFrames;
    Common::Array<Graphics::ManagedSurface *> _thunderFrames;

    Graphics::ManagedSurface *_riddleTopFrame;
    Graphics::ManagedSurface *_riddleBackgroundFrame;
    Graphics::ManagedSurface *_riddleBottomFrame;
    Graphics::ManagedSurface *_riddleNailFrame;

    Graphics::ManagedSurface *_endGameThroneFrame;
    Graphics::ManagedSurface *_endGameBackgroundFrame;
    Graphics::ManagedSurface *_gameOverBackgroundFrame;

    // CPC: CLUT8 versions of UI sprites (indexed by ink 0-3). On area change,
    // we setPalette + convert to ARGB, like the border does in swapPalette.
    Graphics::ManagedSurface *_strenghtBackgroundCLUT8;
    Graphics::ManagedSurface *_strenghtBarCLUT8;
    Common::Array<Graphics::ManagedSurface *> _strenghtWeightsCLUT8;
    Graphics::ManagedSurface *_spiritsMeterBgCLUT8;
    Graphics::ManagedSurface *_spiritsMeterIndCLUT8;
    Graphics::ManagedSurface *_keysBorderCLUT8;
    Common::Array<Graphics::ManagedSurface *> _flagCLUT8;
    uint32 _cpcUIPalette[4]; // used by gate rendering
    void convertCPCSprite(Graphics::ManagedSurface *clut8, Graphics::ManagedSurface *&argb, bool transparentInk0 = false);
    Graphics::ManagedSurface *loadFrameWithHeaderCPCIndexed(Common::SeekableReadStream *file, int pos);
    Common::Array<Graphics::ManagedSurface *> loadFramesWithHeaderCPCIndexed(Common::SeekableReadStream *file, int pos, int numFrames);
    void updateCPCSpritesPalette();

    Common::String _notEnoughRoomMessage;
    Common::String _tooWeakMessage;
    Common::String _crawlSelectedMessage;
    Common::String _walkSelectedMessage;
    Common::String _runSelectedMessage;
    Common::String _ghostInAreaMessage;

    Common::Array<byte> _modData; // Embedded ProTracker module (Amiga demo)
    MusicPlayer *_playerMusic;
    Common::Array<int> _keysCollected;
    bool _useRockTravel;
    int _spiritsMeter;
    int _spiritsMeterPosition;
    int _spiritsMeterMax;
    int _spiritsToKill;

    int _lastTenSeconds;
    int _soundIndexStartFalling;
    bool _selectedPrincess;

private:
    Common::SeekableReadStream *decryptFile(const Common::Path &filename);
    Common::SeekableReadStream *decompressAtari(const Common::Path &filename);
    void loadRiddles(Common::SeekableReadStream *file, int offset, int number);
    void loadMessagesC64(Common::SeekableReadStream *file, int offset, int number);
    void loadRiddlesC64(Common::SeekableReadStream *file, int offset, int number);
    void loadDOSFonts(Common::SeekableReadStream *file, int pos);
    void drawFullscreenRiddleAndWait(uint16 riddle);
    void drawFullscreenEndGameAndWait();
    void drawFullscreenAmigaEndGameAndWait();
    void drawFullscreenGameOverAndWait();
    void drawRiddle(uint16 riddle, uint32 front, uint32 back, Graphics::Surface *surface);
    void tryToCollectKey();
    void addGhosts();
    bool hasEscaped();
    bool ghostInArea();
    void updateThunder();

    Audio::SoundHandle _soundFxGhostHandle;
    Texture *_optionTexture;
    Font _fontRiddle;
    int _droppingGateStartTicks;
    int _thunderTicks;
    int _thunderFrameDuration;
    int _thunderFrameIndex;
    Math::Vector3d _thunderOffset;
    Common::Array<Texture *>_thunderTextures;
};

}