scummvm/engines/hugo/hugo.h
2021-12-26 18:48:43 +01:00

318 lines
11 KiB
C++

/* 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;
}
/**
* This is the namespace of the Hugo engine.
*
* Status of this engine: ???
*
* Games using this engine:
* - Hugo's House of Horror
* - Whodunit?
* - Jungle of Doom
* - Hugo's Horrific Adventure
* - Hugo's Mystery Adventure
* - Hugo's Amazon Adventure
*/
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 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
};
/**
* Inventory icon bar states
*/
enum Istate {kInventoryOff, kInventoryUp, kInventoryDown, kInventoryActive};
/**
* Game view state machine
*/
enum Vstate {kViewIdle, kViewIntroInit, kViewIntro, kViewPlay, kViewInvent, kViewExit};
/**
* Enumerate whether object is foreground, background or 'floating'
* If floating, HERO can collide with it and fore/back ground is determined
* by relative y-coord of object base. This is the general case.
* If fore or background, no collisions can take place and object is either
* behind or in front of all others, although can still be hidden by the
* the overlay plane. OVEROVL means the object is FLOATING (to other
* objects) but is never hidden by the overlay plane
*/
enum {kPriorityForeground, kPriorityBackground, kPriorityFloating, kPriorityOverOverlay};
/**
* Display list functions
*/
enum Dupdate {kDisplayInit, kDisplayAdd, kDisplayDisplay, kDisplayRestore};
/**
* Priority for sound effect
*/
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
};
/**
* Structure to define an EXIT or other collision-activated hotspot
*/
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::String _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() override;
bool canSaveGameStateCurrently() 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