composer.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 COMPOSER_COMPOSER_H
#define COMPOSER_COMPOSER_H

#include "common/formats/ini-file.h"
#include "common/random.h"
#include "common/system.h"
#include "common/debug.h"
#include "common/debug-channels.h"
#include "common/error.h"
#include "common/serializer.h"
#include "common/textconsole.h"
#include "common/rect.h"

#include "engines/engine.h"
#include "engines/util.h"

#include "gui/debugger.h"

#include "graphics/surface.h"

#include "audio/mixer.h"

#include "composer/resource.h"
#include "composer/console.h"
#include "composer/detection.h"

namespace Audio {
    class QueuingAudioStream;
}

namespace Composer {

class Archive;
struct Animation;
class ComposerEngine;
class Pipe;
struct Sprite;

enum {
    kButtonRect = 0,
    kButtonEllipse = 1,
    kButtonSprites = 4
};

class Button {
public:
    Button() { }
    Button(Common::SeekableReadStream *stream, uint16 id, uint gameType);
    Button(Common::SeekableReadStream *stream);

    bool contains(const Common::Point &pos) const;

    uint16 _id;
    uint16 _type;
    uint16 _zorder;
    uint16 _scriptId;
    uint16 _scriptIdRollOn;
    uint16 _scriptIdRollOff;
    bool _active;

    Common::Rect _rect;
    Common::Array<uint16> _spriteIds;
};

enum {
    kEventAnimStarted = 1,
    kEventAnimDone = 2,
    kEventLoad = 3,
    kEventUnload = 4,
    kEventKeyDown = 5,
    kEventChar = 6,
    kEventKeyUp = 7
};

struct KeyboardHandler {
    uint16 keyId;
    uint16 modifierId;
    uint16 scriptId;
};

struct RandomEvent {
    uint16 weight;
    uint16 scriptId;
};

struct Library {
    uint _id;
    Archive *_archive;

    Common::String _group;
    Common::List<Button> _buttons;
    Common::List<KeyboardHandler> _keyboardHandlers;
};

struct QueuedScript {
    uint32 _baseTime;
    uint32 _duration;
    uint32 _count;
    uint16 _scriptId;
};

struct PendingPageChange {
    PendingPageChange() { }
    PendingPageChange(uint16 id, bool remove) : _pageId(id), _remove(remove) { }

    uint16 _pageId;
    bool _remove;
};

struct OldScript {
    OldScript(uint16 id, Common::SeekableReadStream *stream);
    ~OldScript();

    uint16 _id;

    uint32 _size;
    Common::SeekableReadStream *_stream;

    uint16 _zorder;
    uint32 _currDelay;
};

class ComposerEngine : public Engine {
protected:
    Common::Error run() override;

    template <typename T>
    void syncArray(Common::Serializer &ser, Common::Array<T> &data, Common::Serializer::Version minVersion = 0, Common::Serializer::Version maxVersion = Common::Serializer::kLastVersion);
    template <typename T>
    void syncList(Common::Serializer &ser, Common::List<T> &data, Common::Serializer::Version minVersion = 0, Common::Serializer::Version maxVersion = Common::Serializer::kLastVersion);
    template <typename T>
    void syncListReverse(Common::Serializer &ser, Common::List<T> &data, Common::Serializer::Version minVersion = 0, Common::Serializer::Version maxVersion = Common::Serializer::kLastVersion);
    template <typename T>
    void sync(Common::Serializer &ser, T &data, Common::Serializer::Version minVersion, Common::Serializer::Version maxVersion);
    bool canLoadGameStateCurrently(Common::U32String *msg = nullptr) override { return true; }
    Common::Error loadGameState(int slot) override;
    bool canSaveGameStateCurrently(Common::U32String *msg = nullptr) override { return true; }
    Common::Error saveGameState(int slot, const Common::String &desc, bool isAutosave = false) override;

public:
    ComposerEngine(OSystem *syst, const ComposerGameDescription *gameDesc);
    ~ComposerEngine() override;

    bool hasFeature(EngineFeature f) const override;

    int getGameType() const;
    const char *getGameId() const;
    uint32 getFeatures() const;
    Common::Language getLanguage() const;
    Common::Platform getPlatform() const;
    bool loadDetectedConfigFile(Common::INIFile &configFile) const;

    const ComposerGameDescription *_gameDescription;

private:
    Common::RandomSource *_rnd;

    Audio::SoundHandle _soundHandle;
    Audio::QueuingAudioStream *_audioStream;
    uint16 _currSoundPriority;

    uint32 _currentTime, _lastTime, _timeDelta;

    bool _needsUpdate;
    Common::Array<Common::Rect> _dirtyRects;
    Graphics::Surface _screen;
    Common::List<Sprite> _sprites;

    uint _directoriesToStrip;
    Common::INIFile _bookIni;
    Common::String _bookGroup;
    Common::List<Library> _libraries;
    Common::Array<PendingPageChange> _pendingPageChanges;

    Common::Array<uint16> _stack;
    Common::Array<uint16> _vars;

    Common::List<OldScript *> _oldScripts;
    Common::Array<QueuedScript> _queuedScripts;
    Common::List<Animation *> _anims;
    Common::List<Pipe *> _pipes;
    Common::Array<Common::SeekableReadStream *> _pipeStreams;

    Common::HashMap<uint16, Common::Array<RandomEvent> > _randomEvents;

    void onMouseDown(const Common::Point &pos);
    void onMouseMove(const Common::Point &pos);
    void onKeyDown(uint16 keyCode);
    void setCursor(uint16 id, const Common::Point &offset);
    void setCursorVisible(bool visible);

    bool _mouseEnabled;
    bool _mouseVisible;
    Common::Point _lastMousePos;
    const Button *_lastButton;
    uint16 _mouseSpriteId;
    Common::Point _mouseOffset;

    Common::String getSaveStateName(int slot) const override;
    Common::String getStringFromConfig(const Common::String &section, const Common::String &key);
    Common::Path getFilename(const Common::String &section, uint id);
    Common::Path mangleFilename(Common::String filename);
    void loadLibrary(uint id);
    void unloadLibrary(uint id);

    bool hasResource(uint32 tag, uint16 id);
    Common::SeekableReadStream *getResource(uint32 tag, uint16 id);

    void runEvent(uint16 id, int16 param1, int16 param2, int16 param3);
    int16 runScript(uint16 id, int16 param1, int16 param2, int16 param3);

    int16 getArg(uint16 arg, uint16 type);
    void setArg(uint16 arg, uint16 type, uint16 val);
    void runScript(uint16 id);
    int16 scriptFuncCall(uint16 id, int16 param1, int16 param2, int16 param3);
    void runOldScript(uint16 id, uint16 wait);
    void stopOldScript(uint16 id);
    void tickOldScripts();
    bool tickOldScript(OldScript *script);

    void loadAnimation(Animation *&anim, uint16 animId, int16 x, int16 y, int16 eventParam, int32 size = 0);
    void playAnimation(uint16 animId, int16 param1, int16 param2, int16 param3);
    void stopAnimation(Animation *anim, bool localOnly = false, bool pipesOnly = false);
    void playWaveForAnim(uint16 id, uint16 priority, bool bufferingOnly);
    void processAnimFrame();

    void playPipe(uint16 id);
    void stopPipes();

    bool spriteVisible(uint16 id, uint16 animId);
    Sprite *addSprite(uint16 id, uint16 animId, uint16 zorder, const Common::Point &pos);
    void removeSprite(uint16 id, uint16 animId);
    const Sprite *getSpriteAtPos(const Common::Point &pos);
    const Button *getButtonFor(const Sprite *sprite, const Common::Point &pos);
    void setButtonActive(uint16 id, bool active);

    void dirtySprite(const Sprite &sprite);
    void redraw();
    void loadCTBL(uint16 id, uint fadePercent);
    void setBackground(uint16 id);
    void decompressBitmap(uint16 type, Common::SeekableReadStream *stream, byte *buffer, uint32 size, uint width, uint height);
    bool initSprite(Sprite &sprite);
    Common::SeekableReadStream *getStreamForSprite(uint16 id);
    void drawSprite(const Sprite &sprite);
};

} // End of namespace Composer

#endif