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 XEEN_SCRIPTS_H
#define XEEN_SCRIPTS_H

#include "common/scummsys.h"
#include "common/system.h"
#include "common/serializer.h"
#include "common/stack.h"
#include "common/str-array.h"
#include "xeen/files.h"
#include "xeen/party.h"

namespace Xeen {

enum Opcode {
    OP_None                  = 0x00,
    OP_Display0x01           = 0x01,
    OP_DoorTextSml           = 0x02,
    OP_DoorTextLrg           = 0x03,
    OP_SignText              = 0x04,
    OP_NPC                   = 0x05,
    OP_PlayFX                = 0x06,
    OP_TeleportAndExit       = 0x07,
    OP_If1                   = 0x08,
    OP_If2                   = 0x09,
    OP_If3                   = 0x0A,
    OP_MoveObj               = 0x0B,
    OP_TakeOrGive            = 0x0C,
    OP_NoAction              = 0x0D,
    OP_Remove                = 0x0E,
    OP_SetChar               = 0x0F,
    OP_Spawn                 = 0x10,
    OP_DoTownEvent           = 0x11,
    OP_Exit                  = 0x12,
    OP_AfterMap              = 0x13,
    OP_GiveMulti             = 0x14,
    OP_ConfirmWord           = 0x15,
    OP_Damage                = 0x16,
    OP_JumpRnd               = 0x17,
    OP_AfterEvent            = 0x18,
    OP_CallEvent             = 0x19,
    OP_Return                = 0x1A,
    OP_SetVar                = 0x1B,
    OP_TakeOrGive_2          = 0x1C,
    OP_TakeOrGive_3          = 0x1D,
    OP_CutsceneEndClouds     = 0x1E,
    OP_TeleportAndContinue   = 0x1F,
    OP_WhoWill               = 0x20,
    OP_RndDamage             = 0x21,
    OP_MoveWallObj           = 0x22,
    OP_AlterCellFlag         = 0x23,
    OP_AlterHed              = 0x24,
    OP_DisplayStat           = 0x25,
    OP_TakeOrGive_4          = 0x26,
    OP_SeatTextSml           = 0x27,
    OP_PlayEventVoc          = 0x28,
    OP_DisplayBottom         = 0x29,
    OP_IfMapFlag             = 0x2A,
    OP_SelectRandomChar      = 0x2B,
    OP_GiveEnchanted         = 0x2C,
    OP_ItemType              = 0x2D,
    OP_MakeNothingHere       = 0x2E,
    OP_NoAction_2            = 0x2F,
    OP_ChooseNumeric         = 0x30,
    OP_DisplayBottomTwoLines = 0x31,
    OP_DisplayLarge          = 0x32,
    OP_ExchObj               = 0x33,
    OP_FallToMap             = 0x34,
    OP_DisplayMain           = 0x35,
    OP_Goto                  = 0x36,
    OP_ConfirmWord_2         = 0x37,
    OP_GotoRandom            = 0x38,
    OP_CutsceneEndDarkside   = 0x39,
    OP_CutsceneEdWorld       = 0x3A,
    OP_FlipWorld             = 0x3B,
    OP_PlayCD                = 0x3C
};

enum {
    SCRIPT_ABORT = -1,
    SCRIPT_RESET = -2
};

class XeenEngine;

class EventParameters : public Common::Array<byte> {
public:
    class Iterator {
    private:
        uint _index;
        const EventParameters &_data;
    public:
        Iterator(const EventParameters &owner) : _data(owner), _index(0) {}
        Iterator(const Iterator &it) : _data(it._data), _index(0) {}

        byte readByte();

        int8 readShort() { return (int8)readByte(); }

        uint16 readUint16LE();

        uint32 readUint32LE();
    };
public:
    Iterator getIterator() const {
        return Iterator(*this);
    }
};

class MazeEvent {
public:
    Common::Point _position;
    int _direction;
    int _line;
    Opcode _opcode;
    EventParameters _parameters;
public:
    MazeEvent();

    void synchronize(Common::Serializer &s);
};

class MazeEvents : public Common::Array<MazeEvent> {
public:
    Common::StringArray _text;
public:
    void synchronize(XeenSerializer &s);
};

struct StackEntry : public Common::Point {
    int line;

    StackEntry(const Common::Point &pt, int l) : Common::Point(pt), line(l) {}
};

struct MirrorEntry {
    Common::String _name;
    int _mapId;
    Common::Point _position;
    int _direction;

    MirrorEntry() : _mapId(0), _direction(DIR_ALL) {}

    bool synchronize(Common::SeekableReadStream &s);
};

class Scripts {
private:
    XeenEngine *_vm;
    int _treasureItems;
    int _lineNum;
    int _charIndex;
    int _mirrorId;
    int _refreshIcons;
    int _scriptResult;
    bool _scriptExecuted;
    bool _dirFlag;
    int _windowIndex;
    bool _redrawDone;
    MazeEvent *_event;
    Common::Point _currentPos;
    Common::Stack<StackEntry> _stack;
    Common::String _displayMessage;

    typedef EventParameters::Iterator ParamsIterator;

    bool doOpcode(MazeEvent &event);

    bool cmdDoNothing(ParamsIterator &params);

    bool cmdDisplay1(ParamsIterator &params);

    bool cmdDoorTextSml(ParamsIterator &params);

    bool cmdDoorTextLrg(ParamsIterator &params);

    bool cmdSignText(ParamsIterator &params);

    bool cmdNPC(ParamsIterator &params);

    bool cmdPlayFX(ParamsIterator &params);

    bool cmdTeleport(ParamsIterator &params);

    bool cmdIf(ParamsIterator &params);

    bool cmdMoveObj(ParamsIterator &params);

    bool cmdTakeOrGive(ParamsIterator &params);

    bool cmdRemove(ParamsIterator &params);

    bool cmdSetChar(ParamsIterator &params);

    bool cmdSpawn(ParamsIterator &params);

    bool cmdDoTownEvent(ParamsIterator &params);

    bool cmdExit(ParamsIterator &params);

    bool cmdAlterMap(ParamsIterator &params);

    bool cmdGiveMulti(ParamsIterator &params);

    bool cmdConfirmWord(ParamsIterator &params);

    bool cmdDamage(ParamsIterator &params);

    bool cmdJumpRnd(ParamsIterator &params);

    bool cmdAlterEvent(ParamsIterator &params);

    bool cmdCallEvent(ParamsIterator &params);

    bool cmdReturn(ParamsIterator &params);

    bool cmdSetVar(ParamsIterator &params);

    bool cmdCutsceneEndClouds(ParamsIterator &params);

    bool cmdWhoWill(ParamsIterator &params);

    bool cmdRndDamage(ParamsIterator &params);

    bool cmdMoveWallObj(ParamsIterator &params);

    bool cmdAlterCellFlag(ParamsIterator &params);

    bool cmdAlterHed(ParamsIterator &params);

    bool cmdDisplayStat(ParamsIterator &params);

    bool cmdSignTextSml(ParamsIterator &params);

    bool cmdPlayEventVoc(ParamsIterator &params);

    bool cmdDisplayBottom(ParamsIterator &params);

    bool cmdIfMapFlag(ParamsIterator &params);

    bool cmdSelectRandomChar(ParamsIterator &params);

    bool cmdGiveEnchanted(ParamsIterator &params);

    bool cmdItemType(ParamsIterator &params);

    bool cmdMakeNothingHere(ParamsIterator &params);

    bool cmdCheckProtection(ParamsIterator &params);

    bool cmdChooseNumeric(ParamsIterator &params);

    bool cmdDisplayBottomTwoLines(ParamsIterator &params);

    bool cmdDisplayLarge(ParamsIterator &params);

    bool cmdExchObj(ParamsIterator &params);

    bool cmdFallToMap(ParamsIterator &params);

    bool cmdDisplayMain(ParamsIterator &params);

    bool cmdGoto(ParamsIterator &params);

    bool cmdGotoRandom(ParamsIterator &params);

    bool cmdCutsceneEndDarkside(ParamsIterator &params);

    bool cmdCutsceneEndWorld(ParamsIterator &params);

    bool cmdFlipWorld(ParamsIterator &params);

    bool cmdPlayCD(ParamsIterator &params);

    int whoWill(int v1, int v2, int v3);

    void doCloudsEnding();

    void doDarkSideEnding();

    void doWorldEnding();

    void doEnding(const Common::String &endStr);

    bool ifProc(int action, uint32 val, int mode, int charIndex);

    bool copyProtectionCheck();

    void display(bool justifyFlag, int var46);

    uint convertCDTime(uint srcTime);
public:
    int _animCounter;
    bool _eventSkipped;
    int _whoWill;
    DamageType _nEdamageType;
    Common::Array<MirrorEntry> _mirror;
    Common::String _message;
public:
    Scripts(XeenEngine *vm);

    int checkEvents();

    bool openGrate(int wallVal, int action);
};

} // End of namespace Xeen

#endif /* XEEN_SCRIPTS_H */