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

/*
 * This code is based on original Sfinx source code
 * Copyright (c) 1994-1997 Janusz B. Wisniewski and L.K. Avalon
 */

#ifndef CGE2_CGE2_H
#define CGE2_CGE2_H

#include "common/random.h"
#include "common/savefile.h"
#include "common/serializer.h"
#include "engines/engine.h"
#include "common/system.h"
#include "cge2/fileio.h"
#include "cge2/console.h"
#include "audio/mixer.h"

struct ADGameDescription;

namespace CGE2 {

class Vga;
class Sprite;
class MusicPlayer;
class Fx;
class Sound;
class Text;
struct HeroTab;
class FXP;
class V3D;
class V2D;
struct Dac;
class Spare;
class CommandHandler;
class InfoLine;
class Mouse;
class Keyboard;
class Talk;
class Hero;
class Bitmap;
class System;
class EventManager;
class Font;
class Map;
struct SavegameHeader;

#define kScrWidth         320
#define kScrHeight        240
#define kScrDepth         480
#define kPanHeight         40
#define kWorldHeight      (kScrHeight - kPanHeight)
#define kMaxFile          128
#define kPathMax          128
#define kDimMax             8
#define kWayMax            10
#define kPocketMax          4
#define kSceneMax         100
#define kMaxPoint           4
#define kInfoX            160
#define kInfoY            -11
#define kInfoW            180
#define kPocketsWidth      59
#define kLineMax          512

#define kIntroExt         ".I80"
#define kTabName          "CGE.TAB"
#define kPocketFull       170
#define kGameFrameDelay   (750 / 50)
#define kGameTickDelay    (750 / 62)

#define kMusicRef         122
#define kPowerRef         123
#define kDvolRef          124
#define kMvolRef          125
#define kBusyRef          127

#define kOffUseCount      130
#define kOffUseText       131

#define kSysTimeRate        6 // 12 Hz
#define kBlinkRate          4 //  3 Hz

#define kQuitTitle        200
#define kQuitText         201
#define kNoQuitText       202

#define kSavegameVersion    2
#define kSavegameStrSize   12
#define kSavegameStr       "SCUMMVM_CGE2"

#define kColorNum           6

enum CGEAction {
    kActionNone,
    kActionInfo,
    kActionEscape,
    kActionSave,
    kActionLoad,
    kActionQuit
};

struct SavegameHeader {
    uint8 version;
    Common::String saveName;
    Graphics::Surface *thumbnail;
    int16 saveYear, saveMonth, saveDay;
    int16 saveHour, saveMinutes;
    uint32 playTime;
};

enum ColorBank { kCBRel, kCBStd, kCBSay, kCBInf, kCBMnu, kCBWar };

enum GamePhase { kPhaseInGame, kPhaseIntro, kPhaseOver };

// our engine debug channels
enum {
    kCGE2DebugOpcode = 1 << 0
};

enum CallbackType {
    kNullCB = 0, kQGame, kXScene
};

enum Action { kNear, kMTake, kFTake, kActions };

typedef void (CGE2Engine::*NotifyFunctionType)();

class CGE2Engine : public Engine {
private:
    uint32 _lastFrame, _lastTick;
    void tick();

    void init();
    void deinit();

    void writeSavegameHeader(Common::OutSaveFile *out, SavegameHeader &header);
    void saveGame(int slotNumber, const Common::String &desc);
    bool loadGame(int slotNumber);
    void syncHeader(Common::Serializer &s);
    void syncGame(Common::SeekableReadStream *readStream, Common::WriteStream *writeStream);
    void resetGame();
public:
    CGE2Engine(OSystem *syst, const ADGameDescription *gameDescription);
    bool hasFeature(EngineFeature f) const override;
    bool canSaveGameStateCurrently(Common::U32String *msg = nullptr) override;
    bool canLoadGameStateCurrently(Common::U32String *msg = nullptr) override;
    Common::Language getLanguage() const;
    Common::Error saveGameState(int slot, const Common::String &desc, bool isAutosave = false) override;
    Common::Error loadGameState(int slot) override;
    Common::Error run() override;

    WARN_UNUSED_RESULT static bool readSavegameHeader(Common::InSaveFile *in, SavegameHeader &header, bool skipThumbnail = true);

    bool showTitle(const char *name);
    void cge2_main();
    char *mergeExt(char *buf, const char *name, const char *ext);
    void inf(const char *text, ColorBank col = kCBInf);
    void movie(const char *ext);
    void runGame();
    void loadHeroes();
    void loadScript(const char *fname, bool onlyToolbar = false);
    Sprite *loadSprite(const char *fname, int ref, int scene, V3D &pos);
    void badLab(const char *fn);
    void sceneUp(int cav);
    void sceneDown();
    void closePocket();
    void switchScene(int scene);
    void storeHeroPos();
    void showBak(int ref);
    void loadTab();
    int newRandom(int range);
    void openPocket();
    void selectPocket(int n);
    void busy(bool on);
    void feedSnail(Sprite *spr, Action snq, Hero *hero);
    int freePockets(int sx);
    int findActivePocket(int ref);
    void pocFul();
    void killText();
    void mainLoop();
    void handleFrame();
    Sprite *locate(int ref);
    bool isHero(Sprite *spr);
    void loadUser();
    void loadPos();
    void releasePocket(Sprite *spr);
    void switchHero(int sex);
    void offUse();
    void setAutoColors();
    bool cross(const V2D &a, const V2D &b, const V2D &c, const V2D &d);
    bool contain(const V2D &a, const V2D &b, const V2D &p);
    long det(const V2D &a, const V2D &b, const V2D &c);
    int sgn(long n);
    int mapCross(const V2D &a, const V2D &b);
    Sprite *spriteAt(V2D pos);
    void keyClick();
    void swapInPocket(Sprite *spr, Sprite *xspr);
    void busyStep();

    void optionTouch(int opt, uint16 mask);
    void switchColorMode();
    void switchMusic();
    void quit();
    void setVolume(int idx, int cnt);
    void checkVolumeSwitches();
    void switchCap();
    void switchVox();
    void switchSay();
    void initToolbar();
    void initVolumeSwitch(Sprite *volSwitch, int val);
    void checkMute();

    void checkSounds();

    void setEye(const V3D &e);
    void setEye(const V2D& e2, int z = -kScrWidth);
    void setEye(const char *s);

    int number(char *s);
    char *token(char *s);
    char *tail(char *s);
    int takeEnum(const char *const *tab, const char *text);
    ID ident(const char *s);
    bool testBool(char *s);

    void snKill(Sprite *spr);
    void snHide(Sprite *spr, int val);
    void snMidi(int val);
    void snSeq(Sprite *spr, int val);
    void snRSeq(Sprite *spr, int val);
    void snSend(Sprite *spr, int val);
    void snSwap(Sprite *spr, int val);
    void snCover(Sprite *spr, int val);
    void snUncover(Sprite *spr, Sprite *spr2);
    void snKeep(Sprite *spr, int val);
    void snGive(Sprite *spr, int val);
    void snGoto(Sprite *spr, int val);
    void snPort(Sprite *spr, int port);
    void snMouse(bool on);
    void snNNext(Sprite *spr, Action act, int val);
    void snRNNext(Sprite *spr, int val);
    void snRMTNext(Sprite *spr, int val);
    void snRFTNext(Sprite *spr, int val);
    void snRmNear(Sprite *spr);
    void snRmMTake(Sprite *spr);
    void snRmFTake(Sprite *spr);
    void snSetRef(Sprite *spr, int val);
    void snFlash(bool on);
    void snCycle(int cnt);
    void snWalk(Sprite *spr, int val);
    void snReach(Sprite *spr, int val);
    void snSound(Sprite *spr, int wav, Audio::Mixer::SoundType soundType = Audio::Mixer::kSFXSoundType);
    void snRoom(Sprite *spr, bool on);
    void snGhost(Bitmap *bmp);
    void snSay(Sprite *spr, int val);

    void hide1(Sprite *spr);
    Sprite *expandSprite(Sprite *spr);
    void qGame();
    void xScene();

    const ADGameDescription *_gameDescription;

    Common::RandomSource _randomSource;

    bool _quitFlag;
    Dac *_bitmapPalette;
    GamePhase _gamePhase; // Original name: startupmode
    int _now;
    int _sex;
    int _mouseTop;
    bool _dark;
    int _waitSeq;
    int _waitRef;

    struct {
        int *_wait;
        int _ref[2];
    } _soundStat;

    bool _taken;
    bool _endGame;
    int _req;
    NotifyFunctionType _midiNotify;
    NotifyFunctionType _spriteNotify;
    int _startGameSlot;

    bool _sayCap;
    bool _sayVox;
    int _oldMusicVolume;
    int _oldSfxVolume;
    bool _music;
    bool _muteAll;

    ResourceManager *_resman;
    Vga *_vga;
    MusicPlayer *_midiPlayer;
    Fx *_fx;
    Sound *_sound;
    Text *_text;
    HeroTab *_heroTab[2];
    V3D *_eye;
    V3D *_eyeTab[kSceneMax];
    Spare *_spare;
    CommandHandler *_commandHandler;
    CommandHandler *_commandHandlerTurbo;
    Font *_font;
    InfoLine *_infoLine;
    Mouse *_mouse;
    Keyboard *_keyboard;
    Talk *_talk;
    V3D *_point[kMaxPoint];
    System *_sys;
    Sprite *_busyPtr;
    Sprite *_vol[2];
    EventManager *_eventManager;
    Map *_map;
};

} // End of namespace CGE2

#endif // CGE2_CGE2_H