hugo.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 HUGO_HUGO_H
#define HUGO_HUGO_H

#include "engines/engine.h"

// This include is here temporarily while the engine is being refactored.
#include "hugo/game.h"
#include "hugo/detection.h"

#define HUGO_DAT_VER_MAJ 0                          // 1 byte
#define HUGO_DAT_VER_MIN 42                         // 1 byte
#define DATAALIGNMENT    4

namespace Common {
class SeekableReadStream;
class RandomSource;
}

namespace Hugo {

static const int kSavegameVersion = 6;
static const int kInvDx = 32;                       // Width of an inventory icon
static const int kInvDy = 32;                       // Height of inventory icon
static const int kMaxTunes = 16;                    // Max number of tunes
static const int kStepDx = 5;                       // Num pixels moved in x by HERO per step
static const int kStepDy = 4;                       // Num pixels moved in y by HERO per step
static const int kXPix = 320;                       // Width of pcx background file
static const int kYPix = 200;                       // Height of pcx background file
static const int kViewSizeX = kXPix;                // Width of window view
static const int kViewSizeY = 192;                  // Height of window view. In original game: 184
static const int kDibOffY = 0;                      // Offset into dib SrcY (old status line area). In original game: 8
static const int kCompLineSize = 40;                // number of bytes in a compressed line
static const int kMaxLineSize = kCompLineSize - 2;  // Max length of user input line
static const int kMaxTextRows = 25;                 // Number of text lines in display
static const int kMaxBoxChar = kMaxLineSize * kMaxTextRows; // Max chars on screen
static const int kOvlSize = kCompLineSize * kYPix;  // Size of an overlay file
static const int kStateDontCare = 0xFF;             // Any state allowed in command verb
static const int kHeroIndex = 0;                    // In all enums, HERO is the first element
static const int kArrowNumb = 2;                    // Number of arrows (left/right)
static const int kLeftArrow = -2;                   // Cursor over Left arrow in inventory icon bar
static const int kRightArrow = -3;                  // Cursor over Right arrow in inventory icon bar
static const int kMaxPath = 256;                    // Max length of a full path name
static const int kHeroMaxWidth = 24;                // Maximum width of hero
static const int kHeroMinWidth = 16;                // Minimum width of hero

typedef char Command[kMaxLineSize + 8];             // Command line (+spare for prompt,cursor)

struct Config {                                     // User's config (saved)
    bool _musicFl;                                    // State of Music button/menu item
    bool _soundFl;                                    // State of Sound button/menu item
    bool _turboFl;                                    // State of Turbo button/menu item
    bool _playlist[kMaxTunes];                        // Tune playlist
};

typedef byte Icondib[kXPix * kInvDy];               // Icon bar dib
typedef byte Viewdib[(long)kXPix * kYPix];          // Viewport dib
typedef byte Overlay[kOvlSize];                     // Overlay file

enum HUGOAction {
    kActionNone,
    kActionEscape,
    kActionMoveTop,
    kActionMoveBottom,
    kActionMoveLeft,
    kActionMoveRight,
    kActionMoveTopRight,
    kActionMoveTopLeft,
    kActionMoveBottomRight,
    kActionMoveBottomLeft,
    kActionUserHelp,
    kActionToggleSound,
    kActionRepeatLine,
    kActionSaveGame,
    kActionRestoreGame,
    kActionNewGame,
    kActionInventory,
    kActionToggleTurbo
};

enum HugoDebugChannels {
    kDebugSchedule  = 1 <<  0,
    kDebugEngine    = 1 <<  1,
    kDebugDisplay   = 1 <<  2,
    kDebugMouse     = 1 <<  3,
    kDebugParser    = 1 <<  4,
    kDebugFile      = 1 <<  5,
    kDebugRoute     = 1 <<  6,
    kDebugInventory = 1 <<  7,
    kDebugObject    = 1 <<  8,
    kDebugMusic     = 1 <<  9
};

enum HugoRegistered {
    kRegShareware = 0,
    kRegRegistered,
    kRegFreeware
};

enum Istate {kInventoryOff, kInventoryUp, kInventoryDown, kInventoryActive};

enum Vstate {kViewIdle, kViewIntroInit, kViewIntro, kViewPlay, kViewInvent, kViewExit};

enum {kPriorityForeground, kPriorityBackground, kPriorityFloating, kPriorityOverOverlay};

enum Dupdate {kDisplayInit, kDisplayAdd, kDisplayDisplay, kDisplayRestore};

enum Priority {kSoundPriorityLow, kSoundPriorityMedium, kSoundPriorityHigh};

// Strings used by the engine
enum seqTextEngine {
    kEsAdvertise = 0
};

struct Status {                                     // Game status (not saved)
    bool     _storyModeFl;                          // Game is telling story - no commands
    bool     _gameOverFl;                           // Game is over - hero knobbled
    bool     _lookFl;                               // Toolbar "look" button pressed
    bool     _recallFl;                             // Toolbar "recall" button pressed
    bool     _newScreenFl;                          // New screen just loaded in dib_a
    bool     _godModeFl;                            // Allow DEBUG features in live version
    bool     _showBoundariesFl;                     // Flag used to show and hide boundaries,
                                                    // used by the console
    bool     _doQuitFl;
    bool     _skipIntroFl;
    bool     _helpFl;
    uint32   _tick;                                 // Current time in ticks
    Vstate   _viewState;                            // View state machine
    int16    _song;                                 // Current song
};

struct Hotspot {
    int        _screenIndex;                        // Screen in which hotspot appears
    int        _x1, _y1, _x2, _y2;                  // Bounding box of hotspot
    uint16     _actIndex;                           // Actions to carry out if a 'hit'
    int16      _viewx, _viewy, _direction;          // Used in auto-route mode
};

class FileManager;
class Scheduler;
class Screen;
class MouseHandler;
class InventoryHandler;
class Parser;
class Route;
class SoundHandler;
class IntroHandler;
class ObjectHandler;
class TextHandler;
class TopMenu;
class HugoConsole;

class HugoEngine : public Engine {
public:
    HugoEngine(OSystem *syst, const HugoGameDescription *gd);
    ~HugoEngine() override;

    OSystem *_system;

    byte   _numVariant;
    byte   _gameVariant;
    int8   _soundSilence;
    int8   _soundTest;
    int8   _tunesNbr;
    uint16 _numScreens;
    uint16 _numStates;
    int8   _normalTPS;                              // Number of ticks (frames) per second.
                                                    // 8 for Win versions, 9 for DOS versions
    Object *_hero;
    byte  *_screenPtr;
    byte  _heroImage;
    byte  *_screenStates;
    Command _line;                                  // Line of user text input
    Config  _config;                                // User's config
    int16     *_defltTunes;
    uint16    _look;
    uint16    _take;
    uint16    _drop;

    Maze      _maze;                                // Maze control structure
    hugoBoot  _boot;                                // Boot info structure

    Common::RandomSource *_rnd;

    const char *_episode;
    Common::Path _picDir;

    Command _statusLine;
    Command _scoreLine;

    const HugoGameDescription *_gameDescription;
    uint32 getFeatures() const;
    const char *getGameId() const;

    GameType getGameType() const;
    Common::Platform getPlatform() const;
    bool isPacked() const;

    // Used by the qsort function
    static HugoEngine &get() {
        assert(s_Engine != nullptr);
        return *s_Engine;
    }

    bool canLoadGameStateCurrently(Common::U32String *msg = nullptr) override;
    bool canSaveGameStateCurrently(Common::U32String *msg = nullptr) override;
    bool loadHugoDat();

    int8 getTPS() const;

    void initGame(const HugoGameDescription *gd);
    void initGamePart(const HugoGameDescription *gd);
    void endGame();
    void gameOverMsg();
    void initStatus();
    void readScreenFiles(const int screen);
    void setNewScreen(const int screen);
    void shutdown();
    void syncSoundSettings() override;

    Status &getGameStatus();
    int getScore() const;
    void setScore(const int newScore);
    void adjustScore(const int adjustment);
    int getMaxScore() const;
    void setMaxScore(const int newScore);
    Common::Error saveGameState(int slot, const Common::String &desc, bool isAutosave = false) override;
    Common::Error loadGameState(int slot) override;
    bool hasFeature(EngineFeature f) const override;
    const char *getCopyrightString() const;

    Common::String getSaveStateName(int slot) const override;
    uint16 **loadLongArray(Common::SeekableReadStream &in);

    FileManager *_file;
    Scheduler *_scheduler;
    Screen *_screen;
    MouseHandler *_mouse;
    InventoryHandler *_inventory;
    Parser *_parser;
    Route *_route;
    SoundHandler *_sound;
    IntroHandler *_intro;
    ObjectHandler *_object;
    TextHandler *_text;
    TopMenu *_topMenu;

protected:

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

private:
    static const int kTurboTps = 16;                // This many in turbo mode

    Status _status;                                 // Game status structure
    uint32 _lastTime;
    uint32 _curTime;

    static HugoEngine *s_Engine;

    GameType _gameType;
    Common::Platform _platform;
    bool _packedFl;

    int _score;                                     // Holds current score
    int _maxscore;                                  // Holds maximum score

    void initPlaylist(bool playlist[kMaxTunes]);
    void initConfig();
    void initialize();
    void initMachine();
    void calcMaxScore();
    void resetConfig();
    void runMachine();

};

} // End of namespace Hugo

#endif // HUGO_HUGO_H