dialog.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 TWP_DIALOG_H
#define TWP_DIALOG_H
 
#include "common/array.h"
#include "common/str.h"
#include "twp/yack.h"
#include "twp/scenegraph.h"
#include "twp/font.h"
#include "twp/motor.h"
 
#define MAXDIALOGSLOTS 9
#define MAXCHOICES 6
#define SLIDINGSPEED 25.f
#define SLOTMARGIN 4.f
 
namespace Twp {
 
class Dialog;
class DialogSlot : public Node {
public:
    DialogSlot();
    virtual ~DialogSlot() override {}
 
public:
    bool _isValid = false;
    Text _text;
    Common::SharedPtr<YStatement> _stmt;
    Dialog *_dlg = nullptr;
    float _shakeTime = 0.f;
    bool _over = false;
    Common::ScopedPtr<Motor> _shake;
};
 
struct DialogContext {
    Common::String actor;
    Common::String dialogName;
    bool parrot = true;
    int limit = MAXCHOICES;
};
 
enum DialogState {
    None,
    Active,
    WaitingForChoice
};
 
enum DialogConditionMode {
    Once,
    ShowOnce,
    OnceEver,
    ShowOnceEver,
    TempOnce
};
 
enum DialogSelMode {
    Choose,
    Show
};
 
struct DialogConditionState {
    DialogConditionMode mode;
    Common::String actorKey, dialog;
    int line;
 
    DialogConditionState();
    DialogConditionState(DialogConditionMode mode, const Common::String &actorKey, const Common::String &dialog, int line);
};
 
class DialogTarget {
public:
    virtual ~DialogTarget() {}
 
    virtual Color actorColor(const Common::String &actor) = 0;
    virtual Color actorColorHover(const Common::String &actor) = 0;
    virtual Common::SharedPtr<Motor> say(const Common::String &actor, const Common::String &text) = 0;
    virtual Common::SharedPtr<Motor> waitWhile(const Common::String &cond) = 0;
    virtual void shutup() = 0;
    virtual Common::SharedPtr<Motor> pause(float time) = 0;
    virtual bool execCond(const Common::String &cond) = 0;
};
 
class CondStateVisitor : public YackVisitor {
public:
    CondStateVisitor(Dialog *dlg, DialogSelMode mode);
    DialogConditionState createState(int line, DialogConditionMode mode);
 
private:
    void visit(const YOnce &node) override;
    void visit(const YShowOnce &node) override;
    void visit(const YOnceEver &node) override;
    void visit(const YTempOnce &node) override;
 
private:
    DialogSelMode _mode;
    Dialog *_dlg = nullptr;
};
 
class IsGoto : public YackVisitor {
public:
    virtual ~IsGoto() override {}
    void visit(const YGoto &node) override { _isGoto = true; }
 
public:
    bool _isGoto = false;
};
 
class IsChoice : public YackVisitor {
public:
    virtual ~IsChoice() override {}
    void visit(const YChoice &node) override { _isChoice = true; }
 
public:
    bool _isChoice = false;
};
 
class IsShutup : public YackVisitor {
public:
    virtual ~IsShutup() override {}
    void visit(const YShutup &node) override { _isShutup = true; }
 
public:
    bool _isShutup = false;
};
 
class ExpVisitor : public YackVisitor {
public:
    explicit ExpVisitor(Dialog *dialog);
    virtual ~ExpVisitor() override;
 
private:
    void visit(const YCodeExp &node) override;
    void visit(const YGoto &node) override;
    void visit(const YSay &node) override;
    void visit(const YPause &node) override;
    void visit(const YParrot &node) override;
    void visit(const YDialog &node) override;
    void visit(const YOverride &node) override;
    void visit(const YAllowObjects &node) override;
    void visit(const YLimit &node) override;
    void visit(const YWaitWhile &node) override;
    void visit(const YWaitFor &node) override;
    void visit(const YShutup &node) override;
 
private:
    Dialog *_dialog = nullptr;
};
 
class CondVisitor : public YackVisitor {
public:
    CondVisitor(Dialog *dialog);
    virtual ~CondVisitor() override;
 
private:
    void visit(const YCodeCond &node) override;
    void visit(const YOnce &node) override;
    void visit(const YShowOnce &node) override;
    void visit(const YOnceEver &node) override;
    void visit(const YTempOnce &node) override;
 
public:
    bool _accepted = true;
 
private:
    Dialog *_dialog = nullptr;
};
 
class Dialog : public Node {
public:
    Dialog();
    virtual ~Dialog() override;
 
    void choose(int choice);
    void update(float dt);
    DialogState getState() const { return _state; }
 
    void setMousePos(const Math::Vector2d &pos) { _mousePos = pos; }
    Math::Vector2d getNextChoicePos(const Math::Vector2d &pos);
    Math::Vector2d getPreviousChoicePos(const Math::Vector2d &pos);
 
    void start(const Common::String &actor, const Common::String &name, const Common::String &node);
    void selectLabel(int line, const Common::String &name);
    bool isOnce(int line) const;
    bool isShowOnce(int line) const;
    bool isOnceEver(int line) const;
    bool isTempOnce(int line) const;
    bool isCond(const Common::String &cond) const;
 
private:
    void choose(DialogSlot *slot);
    Common::SharedPtr<YLabel> label(int line, const Common::String &name) const;
    void gotoNextLabel();
    bool choicesReady() const { return numSlots() > 0; }
    void updateChoiceStates();
    void run(Common::SharedPtr<YStatement> stmt);
    bool acceptConditions(Common::SharedPtr<YStatement> stmt);
    void running(float dt);
 
    void addSlot(Common::SharedPtr<YStatement> stmt);
    int numSlots() const;
    void clearSlots();
 
    Math::Vector2d getChoicePos(int index) const;
    int getActiveSlot(const Math::Vector2d &pos) const;
 
    virtual void drawCore(const Math::Matrix4 &trsf) override final;
 
public:
    Common::Array<DialogConditionState> _states;
    DialogContext _context;
    unique_ptr<DialogTarget> _tgt;
    Common::SharedPtr<Motor> _action;
 
private:
    DialogState _state = DialogState::None;
    size_t _currentStatement = 0;
    unique_ptr<YCompilationUnit> _cu;
    Common::SharedPtr<YLabel> _lbl;
    DialogSlot _slots[MAXDIALOGSLOTS];
    Math::Vector2d _mousePos;
    float _fadeTime = 0.f;
};
 
} // namespace Twp
 
#endif