riven_scripts.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 RIVEN_SCRIPTS_H
#define RIVEN_SCRIPTS_H

#include "mohawk/riven_stack.h"

#include "common/str-array.h"
#include "common/ptr.h"
#include "common/textconsole.h"

#define DECLARE_OPCODE(x) void x(uint16 op, const ArgumentArray &args)

namespace Common {
class ReadStream;
}

namespace Mohawk {

// Script Types
enum {
    kMouseDownScript   = 0,
    kMouseDragScript   = 1,
    kMouseUpScript     = 2,
    kMouseEnterScript  = 3,
    kMouseInsideScript = 4,
    kMouseLeaveScript  = 5,

    kCardLoadScript    = 6,
    kCardLeaveScript   = 7,
    kCardFrameScript   = 8,
    kCardEnterScript   = 9,
    kCardUpdateScript  = 10
};

enum RivenCommandType {
    kRivenCommandDrawBitmap          = 1,
    kRivenCommandChangeCard          = 2,
    kRivenCommandPlayScriptSLST      = 3,
    kRivenCommandPlaySound           = 4,
    kRivenCommandSetVariable         = 7,
    kRivenCommandSwitch              = 8,
    kRivenCommandEnableHotspot       = 9,
    kRivenCommandDisableHotspot      = 10,
    kRivenCommandStopSound           = 12,
    kRivenCommandChangeCursor        = 13,
    kRivenCommandDelay               = 14,
    kRivenCommandRunExternal         = 17,
    kRivenCommandTransition          = 18,
    kRivenCommandRefreshCard         = 19,
    kRivenCommandBeginScreenUpdate   = 20,
    kRivenCommandApplyScreenUpdate   = 21,
    kRivenCommandIncrementVariable   = 24,
    kRivenCommandChangeStack         = 27,
    kRivenCommandDisableMovie        = 28,
    kRivenCommandDisableAllMovies    = 29,
    kRivenCommandEnableMovie         = 31,
    kRivenCommandPlayMovieBlocking   = 32,
    kRivenCommandPlayMovie           = 33,
    kRivenCommandStopMovie           = 34,
    kRivenCommandUnk36               = 36,
    kRivenCommandFadeAmbientSounds   = 37,
    kRivenCommandStoreMovieOpcode    = 38,
    kRivenCommandActivatePLST        = 39,
    kRivenCommandActivateSLST        = 40,
    kRivenCommandActivateMLSTAndPlay = 41,
    kRivenCommandActivateBLST        = 43,
    kRivenCommandActivateFLST        = 44,
    kRivenCommandZipMode             = 45,
    kRivenCommandActivateMLST        = 46,
    kRivenCommandTimer               = 1001
};

class MohawkEngine_Riven;
class RivenCommand;
class RivenScript;
class RivenScriptManager;
struct MLSTRecord;

typedef Common::SharedPtr<RivenScript> RivenScriptPtr;
typedef Common::SharedPtr<RivenCommand> RivenCommandPtr;

class RivenScript {
public:
    RivenScript();
    ~RivenScript();

    void addCommand(RivenCommandPtr command);

    bool empty() const;

    void run(RivenScriptManager *scriptManager);

    void dumpScript(byte tabs);

    void applyCardPatches(MohawkEngine_Riven *vm, uint32 cardGlobalId, uint16 scriptType, uint16 hotspotId);

    RivenScript &operator+=(const RivenScript &other);

    static const char *getTypeName(uint16 type);

private:
    Common::Array<RivenCommandPtr> _commands;
};

RivenScriptPtr &operator+=(RivenScriptPtr &lhs, const RivenScriptPtr &rhs);

struct RivenTypedScript {
    uint16 type;
    RivenScriptPtr script;
};

typedef Common::Array<RivenTypedScript> RivenScriptList;

class RivenScriptManager {
public:
    RivenScriptManager(MohawkEngine_Riven *vm);
    ~RivenScriptManager();

    RivenScriptPtr readScript(Common::ReadStream *stream);

    RivenScriptPtr readScriptFromData(uint16 *data, uint16 size);

    RivenScriptPtr createScriptFromData(uint commandCount, ...);

    RivenScriptPtr createScriptWithCommand(RivenCommand *command);

    RivenScriptList readScripts(Common::ReadStream *stream);

    void runScript(const RivenScriptPtr &script, bool queue);

    bool hasQueuedScripts() const;

    void runQueuedScripts();

    bool runningQueuedScripts() const;

    void stopAllScripts();

    bool stoppingAllScripts() const;

    struct StoredMovieOpcode {
        RivenScriptPtr script;
        uint32 time;
        uint16 slot;
    };

    uint16 getStoredMovieOpcodeSlot() { return _storedMovieOpcode.slot; }
    uint32 getStoredMovieOpcodeTime() { return _storedMovieOpcode.time; }
    void setStoredMovieOpcode(const StoredMovieOpcode &op);
    void runStoredMovieOpcode();
    void clearStoredMovieOpcode();

private:
    MohawkEngine_Riven *_vm;

    Common::Array<RivenScriptPtr> _queue;
    bool _runningQueuedScripts;
    bool _stoppingAllScripts;

    StoredMovieOpcode _storedMovieOpcode;

    RivenCommandPtr readCommand(Common::ReadStream *stream);
};

class RivenCommand {
public:
    RivenCommand(MohawkEngine_Riven *vm);
    virtual ~RivenCommand();

    virtual void dump(byte tabs) = 0;

    virtual void execute() = 0;

    virtual RivenCommandType getType() const = 0;

    virtual void applyCardPatches(uint32 globalId, int scriptType, uint16 hotspotId) {}

protected:
    MohawkEngine_Riven *_vm;
};

class RivenSimpleCommand : public RivenCommand {
public:
    static RivenSimpleCommand *createFromStream(MohawkEngine_Riven *vm, RivenCommandType type, Common::ReadStream *stream);

    typedef Common::Array<uint16> ArgumentArray;

    RivenSimpleCommand(MohawkEngine_Riven *vm, RivenCommandType type, const ArgumentArray &arguments);
    ~RivenSimpleCommand() override;

    // RivenCommand API
    void dump(byte tabs) override;
    void execute() override;
    RivenCommandType getType() const override;

private:
    typedef void (RivenSimpleCommand::*OpcodeProcRiven)(uint16 op, const ArgumentArray &args);
    struct RivenOpcode {
        OpcodeProcRiven proc;
        const char *desc;
    };


    void setupOpcodes();
    Common::String describe() const;

    void activateMLST(const MLSTRecord &mlst) const;

    DECLARE_OPCODE(empty) { warning ("Unknown Opcode %04x", op); }

    // Opcodes
    DECLARE_OPCODE(drawBitmap);
    DECLARE_OPCODE(switchCard);
    DECLARE_OPCODE(playScriptSLST);
    DECLARE_OPCODE(playSound);
    DECLARE_OPCODE(setVariable);
    DECLARE_OPCODE(enableHotspot);
    DECLARE_OPCODE(disableHotspot);
    DECLARE_OPCODE(stopSound);
    DECLARE_OPCODE(changeCursor);
    DECLARE_OPCODE(delay);
    DECLARE_OPCODE(runExternalCommand);
    DECLARE_OPCODE(transition);
    DECLARE_OPCODE(refreshCard);
    DECLARE_OPCODE(beginScreenUpdate);
    DECLARE_OPCODE(applyScreenUpdate);
    DECLARE_OPCODE(incrementVariable);
    DECLARE_OPCODE(disableMovie);
    DECLARE_OPCODE(disableAllMovies);
    DECLARE_OPCODE(enableMovie);
    DECLARE_OPCODE(playMovieBlocking);
    DECLARE_OPCODE(playMovie);
    DECLARE_OPCODE(stopMovie);
    DECLARE_OPCODE(unk_36);
    DECLARE_OPCODE(fadeAmbientSounds);
    DECLARE_OPCODE(storeMovieOpcode);
    DECLARE_OPCODE(activatePLST);
    DECLARE_OPCODE(activateSLST);
    DECLARE_OPCODE(activateMLSTAndPlay);
    DECLARE_OPCODE(activateBLST);
    DECLARE_OPCODE(activateFLST);
    DECLARE_OPCODE(zipMode);
    DECLARE_OPCODE(activateMLST);

    const RivenOpcode *_opcodes;

    RivenCommandType _type;
    ArgumentArray _arguments;
};

class RivenSwitchCommand : public RivenCommand {
public:
    static RivenSwitchCommand *createFromStream(MohawkEngine_Riven *vm, Common::ReadStream *stream);
    ~RivenSwitchCommand() override;

    // RivenCommand API
    void dump(byte tabs) override;
    void execute() override;
    RivenCommandType getType() const override;
    void applyCardPatches(uint32 globalId, int scriptType, uint16 hotspotId) override;

private:
    RivenSwitchCommand(MohawkEngine_Riven *vm);

    struct Branch {
        uint16 value;
        RivenScriptPtr script;
    };

    uint16 _variableId;
    Common::Array<Branch> _branches;
};

class RivenStackChangeCommand : public RivenCommand {
public:
    RivenStackChangeCommand(MohawkEngine_Riven *vm, uint16 stackId, uint32 globalCardId,
                                bool byStackId, bool byStackCardId);

    static RivenStackChangeCommand *createFromStream(MohawkEngine_Riven *vm, Common::ReadStream *stream);
    ~RivenStackChangeCommand() override;

    // RivenCommand API
    void dump(byte tabs) override;
    void execute() override;
    RivenCommandType getType() const override;

private:
    uint16 _stackId;
    uint32 _cardId;
    bool _byStackId; // Otherwise by stack name id
    bool _byStackCardId; // Otherwise by global card id
};

class RivenTimerCommand : public RivenCommand {
public:
    RivenTimerCommand(MohawkEngine_Riven *vm, const Common::SharedPtr<RivenStack::TimerProc> &timerProc);

    // RivenCommand API
    void dump(byte tabs) override;
    void execute() override;
    RivenCommandType getType() const override;

private:
    Common::SharedPtr<RivenStack::TimerProc> _timerProc;
};

} // End of namespace Mohawk

#undef DECLARE_OPCODE

#endif