conversations.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 MADS_CONVERSATIONS_H
#define MADS_CONVERSATIONS_H

#include "common/scummsys.h"
#include "common/array.h"
#include "common/str-array.h"
#include "mads/nebular/core/screen.h"
#include "mads/nebular/core/dialogs.h"

namespace MADS {
namespace Nebular {

#define MAX_CONVERSATIONS 5
#define MAX_SPEAKERS 5

enum ConversationMode {
    CONVMODE_NONE = -1,
    CONVMODE_NEXT = 0,
    CONVMODE_WAIT_AUTO = 1,
    CONVMODE_WAIT_ENTRY = 2,
    CONVMODE_EXECUTE = 3,
    CONVMODE_REPLY = 4,
    CONVMODE_5 = 5,
    CONVMODE_6 = 6,
    CONVMODE_7 = 7,
    CONVMODE_8 = 8,
    CONVMODE_9 = 9,
    CONVMODE_STOP = 10
};

enum DialogCommand {
    CMD_END = 0,
    CMD_1 = 1,
    CMD_HIDE = 2,
    CMD_UNHIDE = 3,
    CMD_MESSAGE1 = 4,
    CMD_MESSAGE2 = 5,
    CMD_ERROR = 6,
    CMD_NODE = 7,
    CMD_GOTO = 8,
    CMD_ASSIGN = 9,
    CMD_DIALOG_END = 255
};

enum ConvEntryFlag {
    ENTRYFLAG_2 = 2,
    ENTRYFLAG_4000 = 0x4000,
    ENTRYFLAG_8000 = 0x8000
};

enum ConditionalOperation {
    CONDOP_NONE = 0xff,
    CONDOP_VALUE = 0,
    CONDOP_ADD = 1,
    CONDOP_SUBTRACT = 2,
    CONDOP_MULTIPLY = 3,
    CONDOP_DIVIDE = 4,
    CONDOP_MODULUS = 5,
    CONDOP_LTEQ = 6,
    CONDOP_GTEQ = 7,
    CONDOP_LT = 8,
    CONDOP_GT = 9,
    CONDOP_NEQ = 10,
    CONDOP_EQ = 11,
    CONDOP_AND = 12,
    CONDOP_OR = 13,
    CONDOP_ABORT = 0xff
};

class RexNebularEngine;

struct ConversationVar {
    bool _isPtr;
    int _val;
    int *_valPtr;

    ConversationVar() : _isPtr(false), _val(0), _valPtr(nullptr) {
    }

    void setValue(int val);

    void setValue(int *val);

    int *getValue() {
        return _isPtr ? _valPtr : &_val;
    }

    bool isPtr() const {
        return _isPtr;
    }

    bool isNumeric() const {
        return !_isPtr;
    }
};

struct ScriptEntry {
    struct Conditional {
        struct CondtionalParamEntry {
            bool _isVariable;
            int _val;

            CondtionalParamEntry() : _isVariable(false), _val(0) {
            }
        };

        static Common::Array<ConversationVar> *_vars;
        ConditionalOperation _operation;
        CondtionalParamEntry _param1;
        CondtionalParamEntry _param2;

        Conditional() : _operation(CONDOP_NONE) {
        }

        void load(Common::SeekableReadStream &s);

        int get(int paramNum) const;

        int evaluate() const;
    };

    struct MessageEntry {
        int _size;
        int _v2;

        MessageEntry() : _size(0), _v2(0) {
        }
    };

    DialogCommand _command;
    Conditional _conditionals[3];

    // Extra parameters for different opcodes
    int _index;
    Common::Array<int> _entries;
    Common::Array<MessageEntry> _entries2;

    ScriptEntry() : _command(CMD_END), _index(0) {
    }

    void load(Common::SeekableReadStream &s);
};

class DialogScript : public Common::Array<ScriptEntry> {
public:
    void load(Common::SeekableReadStream &s, uint startingOffset);
};

struct ConvDialog {
    struct ScriptEntry {
        DialogCommand _command;
    };

    int16 _textLineIndex;   // 0-based
    int16 _speechIndex;     // 1-based
    uint16 _scriptOffset;   // offset of script entry
    uint16 _scriptSize;     // size of script entry

    DialogScript _script;
};

struct ConvNode {
    uint16 _index;
    uint16 _dialogCount;
    int16 _unk1;
    bool _active;
    int16 _unk3;

    Common::Array<ConvDialog> _dialogs;
};

struct ConvMessage {
    uint _stringIndex;
    uint _count;

    ConvMessage() : _stringIndex(0), _count(0) {
    }
};

struct ConversationData {
    uint16 _nodeCount;      // conversation nodes, each one containing several dialog options and messages
    uint16 _dialogCount;        // messages (non-selectable) + texts (selectable)
    uint16 _messageCount;   // messages (non-selectable)
    uint16 _textLineCount;
    uint16 _unk2;
    uint16 _maxImports;
    uint16 _speakerCount;
    int _textSize;
    int _commandsSize;

    Common::Path _portraits[MAX_SPEAKERS];
    int _speakerFrame[MAX_SPEAKERS];
    Common::Path _speechFile;
    Common::Array<ConvMessage> _messages;
    Common::StringArray _textLines;
    Common::Array<ConvNode> _nodes;
    Common::Array<ConvDialog> _dialogs;

    void load(const Common::Path &filename);
};

struct ConversationConditionals {
    Common::Array<uint> _importVariables;
    Common::Array<uint> _entryFlags;
    Common::Array<ConversationVar> _vars;
    int _numImports;

    int _currentNode;
    Common::Array<int> _playerMessageList;
    Common::Array<int> _actorMessageList;
    Common::Array<int> _playerSpeechList;
    Common::Array<int> _actorSpeechList;

    ConversationConditionals();

    void load(const Common::Path &filename);
};

struct ConversationEntry {
    int _convId;
    ConversationData _data;
    ConversationConditionals _cnd;
};

class MADSEngine;

class GameConversations {
private:
    RexNebularEngine *_vm;
    ConversationEntry _conversations[MAX_CONVERSATIONS];
    bool _speakerActive[MAX_SPEAKERS];
    int _speakerSeries[MAX_SPEAKERS];
    int _speakerFrame[MAX_SPEAKERS];
    int _popupX[MAX_SPEAKERS];
    int _popupY[MAX_SPEAKERS];
    int _popupMaxLen[MAX_SPEAKERS];
    InputMode _inputMode;
    bool _popupVisible;
    ConversationMode _currentMode;
    ConversationMode _priorMode;
    int _verbId;
    int _speakerVal;
    int _heroTrigger;
    TriggerMode _heroTriggerMode;
    int _interlocutorTrigger;
    TriggerMode _interlocutorTriggerMode;
    ConversationEntry *_runningConv;
    int _restoreRunning;
    bool _playerEnabled;
    uint32 _startFrameNumber;
    ConversationVar *_vars;
    ConversationVar *_nextStartNode;
    int _currentNode;
    int _dialogNodeOffset, _dialogNodeSize;
    int _personSpeaking;
    TextDialog *_dialog;
    bool _dialogAltFlag;

    ConversationEntry *getConv(int convId);

    void start();

    void removeActiveWindow();

    void flagEntry(DialogCommand mode, int entryIndex);

    ConversationMode generateMenu();

    void generateText(int textLineIndex, Common::Array<int> &messages);

    void generateMessage(Common::Array<int> &messageList, Common::Array<int> &voiecList);

    bool nextNode();

    int executeEntry(int index);

    void scriptMessage(ScriptEntry &scrEntry);

    bool scriptNode(ScriptEntry &scrEntry);
public:
    GameConversations(RexNebularEngine *vm);

    virtual ~GameConversations();

    void load(int id);

    void run(int id);

    void setVariable(uint idx, int val);

    void setVariable(uint idx, int *val);

    void setStartNode(uint nodeIndex);

    void setHeroTrigger(int val);

    void setInterlocutorTrigger(int val);

    int *getVariable(int idx);

    void hold();

    void release();

    void stop();

    void exportPointer(int *ptr);

    void exportValue(int val);

    void reset(int id);

    void update(bool flag);

    bool active() const {
        return _runningConv != nullptr;
    }

    int activeConvId() const {
        return !active() ? -1 : _runningConv->_convId;
    }

    int restoreRunning() const {
        return _restoreRunning;
    }

    ConversationMode currentMode() const {
        return _currentMode;
    }
};

} // namespace Nebular
} // namespace MADS

#endif