immortal.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 IMMORTAL_H
#define IMMORTAL_H
 
// Audio is only handled in kernel, therefore it is only needed here
#include "audio/mixer.h"
 
// Immortal.h is the engine, so it needs the engine headers
#include "engines/engine.h"
#include "engines/savestate.h"
 
// Theorectically, all graphics should be handled through driver, which is part of kernel, which is in immortal.h
#include "graphics/screen.h"
#include "graphics/surface.h"
 
// Detection is only needed by the main engine
#include "immortal/detection.h"
 
#include "common/formats/prodos.h"
#include "common/debug-channels.h"
#include "common/events.h"
#include "common/scummsys.h"
#include "common/system.h"
#include "common/fs.h"
#include "common/hash-str.h"
#include "common/random.h"
#include "common/serializer.h"
#include "common/util.h"
#include "common/platform.h"
 
// Utilities.h contains many things used by all objects, not just immortal
#include "immortal/utilities.h"
 
// Room also includes story.h
#include "immortal/room.h"
 
namespace Immortal {
 
// Needed by kernel for input
enum InputAction {
    kActionNothing,
    kActionKey,
    kActionRestart,                                     // Key "R" <-- Debug?
    kActionSound,
    kActionFire,
    kActionButton,                                      // Does this just refer to whatever is not the fire button?
    kActionDBGStep                                      // Debug key for moving engine forward one frame at a time
};
 
enum ButtonHeldMask {
    kButton0Held = 2,
    kButton1Held = 4
};
 
enum InputDirection {
    kDirectionUp,
    kDirectionLeft,
    kDirectionDown,
    kDirectionRight
};
 
// Needed by kernel for text
enum FadeType {
    kTextFadeIn,
    kTextDontFadeIn
};
 
// Needed by kernel for music
enum Song {
    kSongNothing,
    kSongMaze,
    kSongCombat,
    kSongText
};
 
enum Sound {
    kSoundSwish = 6,
    kSoundAwe,
    kSoundHuh,
    kSoundClank,
    kSoundFireBall,
    kSoundDoor
};
 
// Needed by logic for various things
enum MonsterID {
    kPlayerID
};
 
// Needed by logic for certificate processing
enum CertificateIndex : uint8 {
    kCertHits,
    kCertLevel,
    kCertLoGameFlags,
    kCertHiGameFlags,
    kCertQuickness,
    kCertInvLo,
    kCertInvHi,
    kCertGoldLo,
    kCertGoldHi
};
 
// Needed by logic for various things
enum GameFlags : uint8 {
    kSavedNone,
    kSavedKing,
    kSavedAna
};
 
// Needed by level (maybe?)
enum LevelType {
    kRoomType,
    kMonsterType,
    kObjectType
};
 
// Basically the equivalent of the explosion from a projectile in other games I think
struct Spark {
};
 
// Generic sprites can be used anywhere, just sort of misc sprites
struct GenericSprite {
};
 
// Doors are a property of the level, not the room, they define the connections between rooms
struct Door {
    uint8 _x           = 0;
    uint8 _y           = 0;
    uint8 _fromRoom    = 0;
    uint8 _toRoom      = 0;
    uint8 _busyOnRight = 0;
    uint8 _on          = 0;
};
 
// Universe is a set of properties for the entire level, nor just the room
struct Univ {
    uint16  _rectX     = 0;
    uint16  _rectY     = 0;
    uint16  _numAnims  = 0;
    uint16  _numCols   = 0;
    uint16  _numRows   = 0;
    uint16  _numChrs   = 0;
    uint16  _num2Cols  = 0;
    uint16  _num2Rows  = 0;
    uint16  _num2Cells = 0;
    uint16  _num2Chrs  = 0;
};
 
struct Chr {
    byte *_scanlines[32];
};
 
struct ImmortalGameDescription;
 
// Forward declaration because we will need the Disk and Room classes
class ProDosDisk;
class Room;
 
class ImmortalEngine : public Engine {
private:
    Common::RandomSource _randomSource;
 
protected:
    // Engine APIs
    Common::Error run() override;
 
public:
    ImmortalEngine(OSystem *syst, const ADGameDescription *gameDesc);
    ~ImmortalEngine() override;
 
    const ADGameDescription *_gameDescription;
 
    /* Terrible functions because C doesn't like
     * bit manipulation enough
     */
    uint16 xba(uint16 ab);                              // This just replicates the XBA command from the 65816, because flipping the byte order is somehow not a common library function???
    uint16 rol(uint16 ab, int n);                       // Rotate bits left by n
    uint16 ror(uint16 ab, int n);                       // Rotate bits right by n
    uint16 mult16(uint16 a, uint16 b);                  // Just avoids using (uint16) everywhere, and is slightly closer to the original
 
    /*
     * --- Members ---
     *
     */
 
    /*
     * Constants
     */
 
    // Misc constants
    const int kNumLengths     = 21;
    const int kNiceTime       = 36;
    const int kMaxCertificate = 16;
 
    // Screen constants
    const int    kScreenW__   = 128;                    // ??? labeled in source as SCREENWIDTH
    const int    kScreenH__   = 128;                    // ???
    const int    kViewPortW   = 256;
    const int    kViewPortH   = 128;
    const int    kScreenSize  = (kResH * kResV) * 2;     // The size of the screen buffer is (320x200) * 2 byte words
    const uint16 kScreenLeft  = 32;
    const uint16 kScreenTop   = 20;
    const uint8  kTextLeft    = 8;
    const uint8  kTextTop     = 4;
    const uint8  kGaugeX      = 0;
    const uint8  kGaugeY      = static_cast<uint8>((-13) & 0xff);                    // ???
    const uint16 kScreenBMW   = 160;                    // Screen BitMap Width?
    const uint16 kChrW        = 64;
    const uint16 kChrH        = 32;
    const uint16 kChrH2       = kChrH * 2;
    const uint16 kChrH3       = kChrH * 3;
    const uint16 kChrLen      = (kChrW / 2) * kChrH;
    const uint16 kChrBMW      = kChrW / 2;
    const uint16 kLCutaway    = 4;
    const uint16 kLDrawSolid  = 32 * ((3 * 16) + 5);
 
    const uint16 kChrDy[19] = {kChr0, kChrH, kChrH2, kChrH, kChrH2,
                               kChrH2, kChrH, kChrH2, kChrH2, kChr0,
                               kChr0, kChrH2, kChrH, kChrH2, kChrH2,
                               kChrH2, kChrH, kChrH2, kChrH2
                              };
 
    const uint16 kChrMask[19] = {kChr0, kChr0,  kChr0,  kChr0,
                                 kChrR, kChrL,  kChr0,  kChrL,
                                 kChrR, kChr0,  kChr0,  kChrLD,
                                 kChr0, kChrR,  kChrLD, kChrRD,
                                 kChr0, kChrRD, kChrL
                                };
 
    const uint16 kIsBackground[36] = {1, 0, 0, 0, 0, 0,
                                      0, 0, 0, 1, 1, 0,
                                      0, 0, 0, 0, 0, 0,
                                      0, 0, 0, 0, 0, 0,
                                      0, 0, 0, 0, 0, 0,
                                      0, 0, 0, 0, 0, 0
                                     };
 
    // Disk offsets
    const int kPaletteOffset    = 21205;                // This is the byte position of the palette data in the disk
 
    // Sprite constants
    const uint16 kMaxSpriteW    = 64;
    const uint16 kMaxSpriteH    = 64;
    const uint16 kSpriteDY      = 32;
    const uint16 kVSX           = kMaxSpriteW;
    const uint16 kVSY           = kSpriteDY;
    const uint16 kVSBMW         = (kViewPortW + kMaxSpriteW) / 2;
    const uint16 kVSLen         = kVSBMW * (kViewPortH + kMaxSpriteH);
    const uint16 kVSDY          = 32;                   // difference from top of screen to top of viewport in the virtual screen buffer
    const uint16 kMySuperBottom = kVSDY + kViewPortH;
    const uint16 kSuperBottom   = 200;
    const uint16 kMySuperTop    = kVSDY;
    const uint16 kSuperTop      = 0;
    const uint16 kViewPortSpX   = 32;
    const uint16 kViewPortSpY   = 0;
    const uint16 kWizardX       = 28;                   // Common sprite center for some reason
    const uint16 kWizardY       = 37;
    const uint16 kObjectY       = 24;
    const uint16 kObjectX       = 32;
    const uint16 kObjectHeight  = 48;
    const uint16 kObjectWidth   = 64;
 
    // Text constants
    const uint8 kMaxRows        = 5;
    const uint8 kMaxCollumns    = 26;
 
    const uint16 kYesNoY        = 88;
    const uint16 kYesNoX1       = 8;
    const uint16 kYesNoX2       = 182;
 
    // Asset constants
    const char kGaugeOn         = 1;                    // On uses the sprite at index 1 of the font spriteset
    const char kGaugeOff        = 0;                    // Off uses the sprite at index 0 of the font spriteset
    const char kGaugeStop       = 1;                    // Literally just means the final kGaugeOn char to draw
    const char kGaugeStart      = 1;                    // First kGaugeOn char to draw
 
    // Level constants
    const int kStoryNull        = 5;
    const int kMaxFilesPerLevel = 16;
    const int kMaxPartInstances = 4;
    const int kLevelToMaze[8]   = {0, 0, 1, 1, 2, 2, 2, 3};
 
    /*
     * 'global' members
     */
 
    // Misc
    Common::ErrorCode _err;                             // If this is not kNoError at any point, the engine will stop
    uint8 _certificate[16];                             // The certificate (password) is basically the inventory/equipment array
    uint8 _lastCertLen = 0;
    bool _draw         = 0;                         // Whether the screen should draw this frame
    int _zero          = 0;                         // No idea what this is yet
    bool _gameOverFlag = false;
    uint8 _gameFlags   = 0;                         // Bitflag array of event flags, but only two were used (saving ana and saving the king) <-- why is gameOverFlag not in this? Lol
    bool _themePaused  = false;                     // In the source, this is actually considered a bit flag array of 2 bits (b0 and b1). However, it only ever checks for non-zero, so it's effectively only 1 bit.
    int _titlesShown   = 0;
    int _time          = 0;
    int _promoting     = 0;                         // I think promoting means the title stuff
    bool _restart      = false;
 
    // Story members
    Story _stories[8];
 
    // Level members
    int _maxLevels       = 0;                         // This is determined when loading in story files
    int _level           = 0;
    bool _levelOver      = false;
    int _count           = 0;
    int _lastLevelLoaded = 0;
    int _lastSongLoaded  = 0;
    int _storyLevel      = 0;
    int _storyX          = 0;
    int _loadA           = 0;
    int _loadY           = 0;
    uint16 _initialX     = 0;
    uint16 _initialY     = 0;
    int _initialBX       = 0;
    int _initialBY       = 0;
    int _dRoomNum        = 0;
    int _initialRoom     = 0;
    int _currentRoom     = 0;
    int _lastType        = 0;
    int _roomCellX       = 0;
    int _roomCellY       = 0;
    Room *_rooms[kMaxRooms];                            // Rooms within the level
    Common::Array<SFlame> _allFlames[kMaxRooms];        // The level needs it's own set of flames so that the flames can be turned on/off permanently. This is technically more like a hashmap in the source, but it could also be seen as a 2d array, just hashed together in the source
 
    // Door members
    Common::Array<Door> _doors;
    uint8 _numDoors        = 0;
    uint8 _doorRoom        = 0;
    uint8 _doorToNextLevel = 0;
    uint8 _doorCameInFrom  = 0;
    uint8 _ladders         = 0;
    uint8 _numLadders      = 0;
    uint8 _ladderInUse     = 0;
    uint8 _secretLadder    = 0;
    uint8 _secretCount     = 0;
    uint8 _secretDelta     = 0;
 
    // Debug members
    bool _singleStep = false;                           // Flag for _singleStep mode
 
    // Input members
    int _pressedAction    = 0;
    int _heldAction       = 0;
    int _pressedDirection = 0;
    int _heldDirection    = 0;
 
    // Text printing members
    uint8 _slowText  = 0;
    uint8 _formatted = 0;
    uint8 _collumn   = 0;
    uint8 _row       = 0;
    uint8 _myButton  = 0;
    uint8 _lastYes   = 0;
 
    // Music members
    Song _playing;                                      // Currently playing song
    int _themeID  = 0;                                  // Not sure yet tbh
    int _combatID = 0;
 
    // Asset members
    int _numSprites = 0;                                // This is more accurately actually the index within the sprite array, so _numSprites + 1 is the current number of sprites
    DataSprite _dataSprites[kFont + 1];                 // All the sprite data, indexed by SpriteName
    Sprite _sprites[kMaxSprites];                       // All the sprites shown on screen
    Cycle _cycles[kMaxCycles];
    Common::Array<Common::String> _strPtrs;             // Str should really be a char array, but inserting frame values will be stupid so it's just a string instead
    Common::Array<Motive>  _motivePtrs;
    Common::Array<Damage>  _damagePtrs;
    Common::Array<Use>     _usePtrs;
    Common::Array<Pickup>  _pickupPtrs;
    Common::Array<SCycle>  _cycPtrs;                    // This is not actually a set of pointers, but it is serving the function of what was called cycPtrs in the source
    CArray2D<Motive>       _programPtrs;
    Common::Array<ObjType> _objTypePtrs;
 
    // Universe members
    Univ   *_univ;                                      // Pointer to the struct that contains the universe properties
    uint16 *_logicalCNM;                                // Draw-type data for the CNM (indexes into )
    uint16 *_CNM;                                       // Stands for CHARACTER NUMBER MAP, but really it should be TILE NUMBER MAP, because it points to tiles, which are made of characters
    byte   *_oldCBM;                                    // Stands for CHARACTER BIT MAP, but should probably be called like, TILE CHARACTER MAP, because it is the full gfx data for all tiles
    Common::Array<Chr> _Draw;                           // In the source this contained the Linear Coded Chr Routines, but here it just contains the expanded pixel data
    uint16 *_Solid;
    uint16 *_Right;
    uint16 *_Left;
    Common::SeekableReadStream *_dataBuffer;            // This contains the uncompressed CNM + CBM
 
    uint16 *_modCNM;
    uint16 *_modLogicalCNM;
 
    uint16  _myCNM[(kViewPortCW + 1)][(kViewPortCH + 1)];
    uint16  _myModCNM[(kViewPortCW + 1)][(kViewPortCH + 1)];
    uint16  _myModLCNM[(kViewPortCW + 1)][(kViewPortCH + 1)];
 
    // Screen members
    byte *_screenBuff;                                  // The final buffer that will transfer to the screen
    Graphics::Surface *_mainSurface;                    // The ScummVM Surface
 
    uint16  _columnX[kViewPortCW + 1];
    uint16  _columnTop[kViewPortCW + 1];
    uint16  _columnIndex[kViewPortCW + 1];              // Why the heck is this an entire array, when it's just an index that gets zeroed before it gets used anyway...
    uint16  _tIndex[kMaxDrawItems];
    uint16  _tPriority[kMaxDrawItems];
    uint16  _viewPortX     = 0;
    uint16  _viewPortY     = 0;
    uint16  _myViewPortX   = 0;                         // Probably mirror of viewportX
    uint16  _myViewPortY   = 0;
    int     _lastGauge     = 0;                         // Mirror for player health, used to update health gauge display
    uint16  _lastBMW       = 0;                         // Mirrors used to determine where bitmap width needs to be re-calculated
    uint16  _lastY         = 0;
    uint16  _lastPoint     = 0;
    uint16  _penX          = 0;                         // Basically where in the screen we are currently drawing
    uint16  _penY          = 0;
    uint16  _myUnivPointX  = 0;
    uint16  _myUnivPointY  = 0;
    int     _num2DrawItems = 0;
    GenericSprite _genSprites[6];
 
    // Palette members
    int  _dontResetColors = 0;                          // Not sure yet
    bool _usingNormal     = 0;                          // Whether the palette is using normal
    bool _dim             = 0;                          // Whether the palette is dim
    uint16 _palUniv[16];
    uint16 _palDefault[16];
    uint16 _palWhite[16];
    uint16 _palBlack[16];
    uint16 _palDim[16];
    byte   _palRGB[48];                                 // Palette that ScummVM actually uses, which is an RGB conversion of the original
 
 
    /*
     * --- Functions ---
     *
     */
 
    /*
     * [Kernel.cpp] Functions from Kernel.gs and Driver.gs
     */
 
    // Screen
    void clearScreen();                                 // Draws a black rectangle on the screen buffer but only inside the frame
    void whiteScreen();                                 // Draws a white rectanlge on the screen buffer (but does not do anything with resetColors)
    void rect(int x, int y, int w, int h);              // Draws a solid rectangle at x,y with size w,h. Also shadows for blit?
    void backspace();                                   // Moves draw position back and draws empty rect in place of char
    void printByte(int b);
    void printChr(char c);
    void loadWindow();                                  // Gets the window.bm file
    void drawUniv();                                    // Draw the background, add the sprites, determine draw order, draw the sprites
    void copyToScreen();                                // If draw is 0, just check input, otherwise also copy the screen buffer to the scummvm surface and update screen
    void mungeBM();                                     // Put together final bitmap?
    void blit();                                        // Will probably want this to be it's own function
    void blit40();                                      // Uses macro blit 40 times
    void sBlit();
    void scroll();
    void makeMyCNM();                                   // ?
    void drawBGRND();                                   // Draw floor parts of leftmask rightmask and maskers
    void addRows();                                     // Add rows to drawitem array
    void addSprite(uint16 vpX, uint16 vpY, SpriteName s, int img, uint16 x, uint16 y, uint16 p);
    void addSprites();                                  // Add all active sprites that are in the viewport, into a list that will be sorted by priority
    void sortDrawItems();                               // Sort said items
    void drawItems();                                   // Draw the items over the background
    void drawIcon(int img);
    void setPen(uint16 penX, uint16 penY);              // Sets the 'pen' x and y positions, including making y negative if above a certain point
    void center();
    void carriageReturn();
 
    // Music
    void toggleSound();                                 // Actually pauses the sound, doesn't just turn it off/mute
    void fixPause();
    Song getPlaying();
    void playMazeSong();
    void playCombatSong();
    void playTextSong();
    void doGroan();
    void stopMusic();
    void musicPause(int sID);
    void musicUnPause(int sID);
    void loadSingles(Common::String songName);          // Loads and then parse the maze song
    void standardBeep();
 
    // Palette
    void loadPalette();                                 // Get the static palette data from the disk
    void setColors(uint16 pal[]);                       // Applies the current palette to the ScummVM surface palette
    void fixColors();                                   // Determine whether the screen should be dim or normal
    void useNormal();
    void useDim();
    void useBlack();
    void useWhite();
    void pump();                                        // Alternates between white and black with delays in between (flashes screen)
    void fadePal(uint16 pal[], int count, uint16 target[]); // Fades the palette except the frame
    void fade(uint16 pal[], int dir, int delay);        // Calls fadePal() by a given delay each iteration
    void fadeOut(int j);                                // Calls Fade with a delay of j jiffies and direction 1
    void fadeIn(int j);                                 // || and direction 0
    void normalFadeOut();
    void slowFadeOut();
    void normalFadeIn();
 
    // Assets
    Common::SeekableReadStream *loadIFF(Common::String fileName); // Loads a file and uncompresses if it is compressed
    void initStoryStatic();                             // Sets up all of the global static story elements
    int loadUniv(char mazeNum);                        // Unpacks the .CNM and .UNV files into all the CNM stuff, returns the total length of everything
    void loadMazeGraphics(int m);                       // Creates a universe with a maze
    void makeBlisters(int povX, int povY);              // Turns the unmodified CNM/CBM/LCNM etc into the modified ones to actually be used for drawing the game
    void loadFont();                                    // Gets the font.spr file, and centers the sprite
    void clearSprites();                                // Clears all sprites before drawing the current frame
    void loadSprites();                                 // Loads all the sprite files and centers their sprites (in spritelist, but called from kernel)
 
    // Input
    void userIO();                                      // Get input
    void pollKeys();                                    // Buffer input
    void noNetwork();                                   // Setup input mirrors
    void waitKey();                                     // Waits until a key is pressed (until getInput() returns true)
    void waitClick();                                   // Waits until one of the two buttons is pressed
    void blit8();                                       // This is actually just input, but it is called blit because it does a 'paddle blit' 8 times
 
    // These will replace the myriad of hardware input handling from the source
    bool getInput();                                    // True if there was input, false if not
    void addKeyBuffer();
    void clearKeyBuff();
 
 
    /*
     * [DrawChr.cpp] Functions from DrawChr.cpp
     */
 
    // Main
    int mungeCBM(uint16 num2Chrs);
    void storeAddr(uint16 *drawType, uint16 chr2, uint16 drawIndex);
    void mungeSolid(int oldChr, uint16 &drawIndex);
    void mungeLRHC(int oldChr, uint16 &drawIndex);
    void mungeLLHC(int oldChr, uint16 &drawIndex);
    void mungeULHC(int oldChr, uint16 &drawIndex);
    void mungeURHC(int oldChr, uint16 &drawIndex);
    void drawSolid(int chr, int x, int y);
    void drawULHC(int chr, int x, int y);
    void drawURHC(int chr, int x, int y);
    void drawLLHC(int chr, int x, int y);
    void drawLRHC(int chr, int x, int y);
 
 
    /*
     * [Logic.cpp] Functions from Logic.GS
     */
 
    // Debug
    void doSingleStep();                                // Let the user advance the engine one frame at a time
 
    // Main
    void trapKeys();                                    // Poorly named, this checks if the player wants to restart/pause music/use debug step
    int keyOrButton();                                 // Returns value based on whether it was a keyboard key or a button press
    void logicInit();
    void logic();                                       // Keeps time, handles win and lose conditions, then general logic
    void restartLogic();                                // This is the actual logic init
    int logicFreeze();                                 // Overcomplicated way to check if game over or level over
    void updateHitGauge();
    void drawGauge(int h);
    void makeCertificate();
    void calcCheckSum(int l, uint8 checksum[]);         // Checksum is one word, but the source called it CheckSum
    bool getCertificate();
    void printCertificate();
 
    // Misc
    bool printAnd(Str s);
    bool fromOldGame();
    void setGameFlags(uint16 f);
    uint16 getGameFlags();
    void setSavedKing();
    bool isSavedKing();
    void setSavedAna();
    bool isSavedAna();
    int getLevel();                                    // Literally just return _level...
    void gameOverDisplay();
    void gameOver();
    void levelOver();
 
 
    /*
     * [Misc.cpp] Functions from Misc
     */
 
    // Misc
    void miscInit();
    void setRandomSeed();
    void getRandom();
 
    // Input related
    bool buttonPressed();
    bool firePressed();
 
    // Text printing
    void myFadeOut();
    void myFadeIn();
    bool textPrint(Str s, int n);
    bool textBeginning(Str s, int n);
    bool textSub(Str s, FadeType f, int n);
    void textEnd(Str s, int n);
    void textMiddle(Str s, int n);
 
    void textCR();
    void textPageBreak(Common::String s, int &index);
    void textAutoPageBreak();
    void textDoSpace(Common::String s, int index);
    void textBounceDelay();
 
    bool yesNo();
    void noOn();
    void yesOn();
 
    void myDelay(int j);
 
 
    /*
     * [Level.cpp] Functions from level.GS
     * < All functions implemented (in some capacity)! >
     */
    // Init
    void levelInitAtStartOfGameOnly();
    void levelInit();
    //void levelGetCount <-- lda count
 
    // Main
    void levelStory(int l);
    void levelLoadFile(int l);
    void levelNew(int l);
    void levelDrawAll();
    void levelShowRoom(int r, int bX, int bY);
    bool levelIsShowRoom(int r);
    bool levelIsLoaded(int l);
    void univAtNew(int l);
    //void getLastType <-- lda lastType
    //void setLastType <-- sta lastType
    //void getShowRoom <-- lda currentRoom
 
    /*
     * [Cycle.cpp] Functions from Cyc
     */
 
    // Misc
    void cycleFreeAll();                            // Delete all cycles
 
 
    /*
     * [Story.cpp] Functions related to Story.GS
     */
 
    // Init
    void initStoryDynamic();
 
    /*
     * [Sprites.cpp] Functions from Sprites.GS and spriteList.GS
     */
 
    // Init
    void initDataSprite(Common::SeekableReadStream *f, DataSprite *d, int index, uint16 cenX, uint16 cenY); // Initializes the data sprite
 
    // Main
    void superSprite(DataSprite *dSprite, uint16 x, uint16 y, int img, uint16 bmw, byte *dst, uint16 superTop, uint16 superBottom);
    bool clipSprite(uint16 &height, uint16 &pointIndex, uint16 &skipY, DataSprite *dSprite, uint16 &pointX, uint16 &pointY, int img, uint16 bmw, uint16 superTop, uint16 superBottom);
    void spriteAligned(DataSprite *dSprite, Image &img, uint16 &skipY, uint16 &pointIndex, uint16 &height, uint16 bmw, byte *dst);
 
    /*
     * [Compression.cpp] Functions from Compression.GS
     */
 
    // Main routines
    Common::SeekableReadStream *unCompress(Common::File *source, int lSource);
 
    // Subroutines called by unCompress
    void setUpDictionary(uint16 *pCodes, uint16 *pTk, uint16 &findEmpty);
    int inputCode(uint16 &outCode, int &lSource, Common::File *source, uint16 &evenOdd);
    int member(uint16 &codeW, uint16 &k, uint16 *pCodes, uint16 *pTk, uint16 &findEmpty, uint16 &index);
 
    /*
     * [door.cpp] Functions from Door.GS
     */
 
    void roomTransfer(int r, int x, int y);     // Transfers the player from the current room to a new room at x,y
    void doorOpenSecret();
    void doorCloseSecret();
    //void doorToNextLevel();
    void doorInit();
    void doorClrLock();
    void doorNew(SDoor door);
    void doorDrawAll();
    void doorOnDoorMat();
    //void doorEnter(); // <-- this is actually a method of Player Monster, should probably move it there later
    int findDoorTop(int x, int y);
    int findDoor(int x, int y);
    bool doLockStuff(int d, MonsterID m, int top);
    bool inDoorTop(int x, int y, MonsterID m);
    bool inDoor(int x, int y, MonsterID m);
    int doorDoStep(MonsterID m, int d, int index);
    int doorSetOn(int d);
    int doorComeOut(MonsterID m);
    void doorSetLadders(MonsterID m);
 
 
    /*
     * [Music.cpp] Functions from music.GS and sound.GS
     */
 
    // Misc
 
 
    /*
     * --- ScummVM general engine Functions ---
     *
     */
 
    Common::ErrorCode initDisks();                      // Opens and parses IMMORTAL.dsk and IMMORTAL_GFX.dsk
    uint32 getFeatures() const;                         // Returns the game description flags
    Common::String getGameId() const;                   // Returns the game Id
 
    /* Gets a random number
     */
    uint32 getRandomNumber(uint maxNum) {
        return _randomSource.getRandomNumber(maxNum);
    }
 
    bool hasFeature(EngineFeature f) const override {
        return
            (f == kSupportsLoadingDuringRuntime) ||
            (f == kSupportsSavingDuringRuntime) ||
            (f == kSupportsReturnToLauncher);
    };
 
    bool canLoadGameStateCurrently(Common::U32String *msg = nullptr) override {
        return true;
    }
    bool canSaveGameStateCurrently(Common::U32String *msg = nullptr) override {
        return true;
    }
 
    /* Uses a serializer to allow implementing savegame
     * loading and saving using a single method
     */
    Common::Error syncGame(Common::Serializer &s);
 
    /* Common::Error saveGameStream(Common::WriteStream *stream, bool isAutosave = false) {
        Common::Serializer s(nullptr, stream);
        return syncGame(s);
    }
 
    Common::Error loadGameStream(Common::SeekableReadStream *stream) {
        Common::Serializer s(stream, nullptr);
        return syncGame(s);
    } */
};
 
extern ImmortalEngine *g_immortal;
#define SHOULD_QUIT ::Immortal::g_immortal->shouldQuit()
 
} // namespace Immortal
 
#endif