ngi.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 NGI_FULLPIPE_H
#define NGI_FULLPIPE_H
 
#include "audio/mixer.h"
#include "common/scummsys.h"
#include "common/events.h"
#include "common/keyboard.h"
#include "common/ptr.h"
#include "common/random.h"
#include "common/savefile.h"
#include "common/system.h"
#include "graphics/managed_surface.h"
 
#include "engines/engine.h"
#include "ngi/console.h"
 
namespace Audio {
class SoundHandle;
}
 
namespace NGI {
 
enum {
    kDebugPathfinding = 1,
    kDebugDrawing,
    kDebugLoading,
    kDebugAnimation,
    kDebugMemory,
    kDebugEvents,
    kDebugBehavior,
    kDebugInventory,
    kDebugSceneLogic,
    kDebugInteractions,
    kDebugXML,
};
 
enum NGIActions {
    kActionNone,
    kActionPause,
    kActionStopSounds,
    kActionToggleMute,
    kActionMapOpen,
    kActionMapClose,
    kActionHelp,
    kActionInventory,
    kActionSkipIntro,
    kActionSkipCredits,
    kActionCloseDialog,
};
 
#define MAXGAMEOBJH 10000
 
struct NGIGameDescription;
 
 
class BehaviorManager;
class BaseModalObject;
class GameLoader;
class GameVar;
class InputController;
class Inventory2;
struct CursorInfo;
struct EntranceInfo;
class ExCommand;
class Floaters;
class GameProject;
class GameObject;
class GlobalMessageQueueList;
struct MessageHandler;
class MessageQueue;
class AniHandler;
class NGIArchive;
class PictureObject;
struct PreloadItem;
class Scene;
class SoundList;
class StaticANIObject;
class Vars;
typedef Common::Array<int16> MovTable;
typedef Common::Array<Common::Point> PointList;
 
struct Palette {
    uint32 pal[256];
    uint size;
 
    Palette() {
        size = 0;
        memset(pal, 0, 256 * 4);
    }
 
    void copy(const Palette &src) {
        size = src.size;
        memcpy(pal, src.pal, 256 * 4);
    }
};
 
typedef Common::HashMap<uint16, Common::String> GameObjHMap;
 
int global_messageHandler1(ExCommand *cmd);
int global_messageHandler2(ExCommand *cmd);
int global_messageHandler3(ExCommand *cmd);
int global_messageHandler4(ExCommand *cmd);
void global_messageHandler_handleSound(ExCommand *cmd);
 
 
class NGIEngine : public ::Engine {
protected:
 
    Common::Error run() override;
 
public:
    NGIEngine(OSystem *syst, const NGIGameDescription *gameDesc);
    ~NGIEngine() override;
 
    void initialize();
    void restartGame();
    bool shouldQuit();
 
    void setMusicAllowed(int val) { _musicAllowed = val; }
 
    // Detection related functions
    const NGIGameDescription *_gameDescription;
    uint32 getFeatures() const;
    bool isDemo();
    Common::Language getLanguage() const;
    const char *getGameId() const;
    int getGameGID() const;
 
    Common::RandomSource _rnd;
 
    Common::KeyCode _keyState;
    uint16 _buttonState;
 
    void updateEvents();
 
    Graphics::ManagedSurface _backgroundSurface;
 
    Common::ScopedPtr<GameLoader> _gameLoader;
    GameProject *_gameProject;
    bool loadGam(const char *fname, int scene = 0);
 
    void loadGameObjH();
    Common::String gameIdToStr(uint16 id);
 
    GameVar *getGameLoaderGameVar();
    InputController *getGameLoaderInputController();
 
    int _gameProjectVersion;
    int _pictureScale;
    int _scrollSpeed;
    bool _updateFlag;
    bool _flgCanOpenMap;
    bool _gamePaused;
    bool _flgGameIsRunning;
    bool _inputArFlag;
    bool _recordEvents;
    bool _mainMenu_debugEnabled;
 
    Common::Rect _sceneRect;
    int _sceneWidth;
    int _sceneHeight;
    Scene *_currentScene;
    Scene *_loaderScene;
    Scene *_scene2;
    Scene *_scene3;
    StaticANIObject *_aniMan;
    StaticANIObject *_aniMan2;
    Palette _defaultPalette;
    const Palette *_globalPalette;
 
    InputController *_inputController;
    bool _inputDisabled;
 
    int _currentCheat;
    int _currentCheatPos;
 
    void defHandleKeyDown(int key);
 
    SoundList *_currSoundList1[11];
    int _currSoundListCount;
    bool _soundEnabled;
    bool _flgSoundList;
    Common::Path _sceneTracks[10];
    int _numSceneTracks;
    bool _sceneTrackHasSequence;
    int _musicMinDelay;
    int _musicMaxDelay;
    int _musicLocal;
    Common::String _trackName;
    int _trackStartDelay;
    Common::Path _sceneTracksCurrentTrack;
    bool _sceneTrackIsPlaying;
 
    void stopAllSounds();
    void toggleMute();
    void playSound(int id, int flag);
    void playTrack(GameVar *sceneVar, const char *name, bool delayed);
    int getSceneTrack();
    void updateTrackDelay();
    void startSceneTrack();
    void startSoundStream1(const Common::Path &trackName);
    void playOggSound(const Common::Path &trackName, Audio::SoundHandle &stream);
    void stopSoundStream2();
    void stopAllSoundStreams();
    void stopAllSoundInstances(int id);
    void updateSoundVolume();
    void setMusicVolume(int vol);
 
    int _sfxVolume;
    int _musicVolume;
 
    Common::ScopedPtr<GlobalMessageQueueList> _globalMessageQueueList;
    MessageHandler *_messageHandlers;
 
    int _msgX;
    int _msgY;
    int _msgObjectId2;
    int _msgId;
 
    Common::List<ExCommand *> _exCommandList;
    bool _isProcessingMessages;
 
    int _mouseVirtX;
    int _mouseVirtY;
    Common::Point _mouseScreenPos;
 
    Common::ScopedPtr<BehaviorManager> _behaviorManager;
 
    Common::ScopedPtr<MovTable> _movTable;
 
    Common::ScopedPtr<Floaters> _floaters;
    Common::ScopedPtr<AniHandler> _aniHandler;
 
    Common::Array<Common::Point> _arcadeKeys;
 
    void deleteModalObject();
 
    void initMap();
    void updateMap(PreloadItem *pre);
    void updateMapPiece(int mapId, int update);
    void updateScreen();
 
    void freeGameLoader();
    void cleanup();
 
    bool _gameContinue;
    bool _needRestart;
    bool _flgPlayIntro;
    int _musicAllowed;
    bool _normalSpeed;
 
    void enableSaves() { _isSaveAllowed = true; }
    void disableSaves(ExCommand *ex);
    bool isSaveAllowed();
 
    void initObjectStates();
    void setLevelStates();
    void setSwallowedEggsState();
    void loadAllScenes();
 
    void initCursors();
    void addCursor(CursorInfo *cursorInfo, Scene *inv, int pictureId, int hotspotX, int hotspotY, int itemPictureOffsX, int itemPictureOffsY);
 
    int32 _mapTable[200];
 
    Scene *_inventoryScene;
    Inventory2 *_inventory;
    int _currSelectedInventoryItemId;
 
    int32 _updateTicks;
    int32 _lastInputTicks;
    int32 _lastButtonUpTicks;
 
    BaseModalObject *_modalObject;
 
    int (*_updateScreenCallback)();
    int (*_updateCursorCallback)();
 
    void drawAlphaRectangle(int x1, int y1, int x2, int y2, int alpha);
    void sceneFade(Scene *sc, bool direction);
 
    int _cursorId;
    int _minCursorId;
    int _maxCursorId;
    Common::Array<int> _objectIdCursors;
    GameObject *_objectAtCursor;
    int _objectIdAtCursor;
 
    void setCursor(int id);
    void updateCursorCommon();
 
    int getObjectState(const Common::String &objname);
    void setObjectState(const Common::String &name, int state);
    int getObjectEnumState(const Common::String &name, const char *state);
 
    void sceneAutoScrolling();
    bool sceneSwitcher(const EntranceInfo &entrance);
    Scene *accessScene(int sceneId);
    void setSceneMusicParameters(GameVar *var);
    int convertScene(int scene);
    int getSceneEntrance(int scene);
    int getSceneFromTag(int tag);
 
    NGIArchive *_currArchive;
 
    void openMap();
    void openHelp();
    void openMainMenu();
 
    PictureObject *_arcadeOverlay;
    PictureObject *_arcadeOverlayHelper;
    int _arcadeOverlayX;
    int _arcadeOverlayY;
    int _arcadeOverlayMidX;
    int _arcadeOverlayMidY;
 
    void initArcadeKeys(const char *varname);
    void processArcade(ExCommand *ex);
    void winArcade();
    void setArcadeOverlay(int picId);
    int drawArcadeOverlay(int adjust);
 
    void getAllInventory();
 
    StaticANIObject *_lastLiftButton;
    MessageQueue *_liftEnterMQ;
    MessageQueue *_liftExitMQ;
    StaticANIObject *_lift;
    int _liftX;
    int _liftY;
 
    int lift_getButtonIdP(int objid);
    int lift_getButtonIdH(int objid);
    int lift_getButtonIdN(int objid);
    void lift_setButton(const char *name, int state);
    void lift_init(Scene *sc, int qu1, int qu2);
    void lift_setButtonStatics(Scene *sc, int buttonId);
    void lift_exitSeq(ExCommand *ex);
    void lift_closedoorSeq();
    void lift_clickButton();
    void lift_walkAndGo();
    void lift_goAnimation();
    void lift_animateButton(StaticANIObject *button);
    void lift_startExitQueue();
    void lift_hoverButton(ExCommand *ex);
    bool lift_checkButton(const char *varname);
    void lift_openLift();
 
    GameVar *_musicGameVar;
    Audio::SoundHandle _soundStream1;
    Audio::SoundHandle _soundStream2;
    Audio::SoundHandle _soundStream3;
    Audio::SoundHandle _soundStream4;
 
    bool _stream2playing;
 
    GameObjHMap _gameObjH;
 
public:
 
    bool _isSaveAllowed;
 
    Common::Error loadGameState(int slot) override;
    Common::Error saveGameState(int slot, const Common::String &description, bool isAutosave = false) override;
    Common::String getSaveStateName(int slot) const override;
 
    bool canLoadGameStateCurrently(Common::U32String *msg = nullptr) override { return true; }
    bool canSaveGameStateCurrently(Common::U32String *msg = nullptr) override { return _isSaveAllowed; }
    bool hasFeature(EngineFeature f) const override;
 
};
 
extern NGIEngine *g_nmi;
extern Vars *g_vars;
 
} // End of namespace NGI
 
#endif /* NGI_FULLPIPE_H */