script.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 ULTIMA4_GAME_SCRIPT_H
#define ULTIMA4_GAME_SCRIPT_H

#include "ultima/ultima4/core/types.h"
#include "ultima/shared/conf/xml_node.h"
#include "ultima/shared/std/containers.h"
#include "common/file.h"
#include "common/list.h"

namespace Ultima {
namespace Ultima4 {

class Script {
public:
    class Provider {
    public:
        virtual ~Provider() {}
        virtual Common::String translate(Std::vector<Common::String> &parts) = 0;
    };

private:
    class Variable {
    public:
        Variable();
        Variable(const Common::String &v);
        Variable(const int &v);

        int    &getInt();
        Common::String &getString();

        void    setValue(const int &v);
        void    setValue(const Common::String &v);
        void    unset();

        bool    isInt() const;
        bool    isString() const;
        bool    isSet() const;

    private:
        int _iVal;
        Common::String _sVal;
        bool _set;
    };

public:
    enum ReturnCode {
        RET_OK,
        RET_REDIRECTED,
        RET_STOP
    };

    enum State {
        STATE_UNLOADED,
        STATE_NORMAL,
        STATE_DONE,
        STATE_INPUT
    };

    enum InputType {
        INPUT_CHOICE,
        INPUT_NUMBER,
        INPUT_STRING,
        INPUT_DIRECTION,
        INPUT_PLAYER,
        INPUT_KEYPRESS
    };

    enum Action {
        ACTION_SET_CONTEXT,
        ACTION_UNSET_CONTEXT,
        ACTION_END,
        ACTION_REDIRECT,
        ACTION_WAIT_FOR_KEY,
        ACTION_WAIT,
        ACTION_STOP,
        ACTION_INCLUDE,
        ACTION_FOR_LOOP,
        ACTION_RANDOM,
        ACTION_MOVE,
        ACTION_SLEEP,
        ACTION_CURSOR,
        ACTION_PAY,
        ACTION_IF,
        ACTION_INPUT,
        ACTION_ADD,
        ACTION_LOSE,
        ACTION_HEAL,
        ACTION_CAST_SPELL,
        ACTION_DAMAGE,
        ACTION_KARMA,
        ACTION_MUSIC,
        ACTION_SET_VARIABLE,
        ACTION_ZTATS
    };

    Script();
    ~Script();

    void addProvider(const Common::String &name, Provider *p);

    bool load(const Common::String &filename, const Common::String &baseId, const Common::String &subNodeName = "", const Common::String &subNodeId = "");

    void unload();

    void run(const Common::String &script);

    ReturnCode execute(Shared::XMLNode *script, Shared::XMLNode *currentItem = nullptr, Common::String *output = nullptr);

    void _continue();

    void resetState();
    void setState(State state);
    State getState();

    void setTarget(const Common::String &val);
    void setChoices(const Common::String &val);
    void setVar(const Common::String &name, const Common::String &val);
    void setVar(const Common::String &name, int val);
    void unsetVar(const Common::String &name);

    Common::String getTarget();
    InputType getInputType();
    Common::String getInputName();
    Common::String getChoices();
    int getInputMaxLen();

private:
    void translate(Common::String *script);

    Shared::XMLNode *find(Shared::XMLNode *node, const Common::String &script, const Common::String &choice = "", bool _default = false);

    Common::String getPropAsStr(Common::List<Shared::XMLNode *> &nodes, const Common::String &prop, bool recursive);

    Common::String getPropAsStr(Shared::XMLNode *node, const Common::String &prop, bool recursive = false);

    int getPropAsInt(Common::List<Shared::XMLNode *> &nodes, const Common::String &prop, bool recursive);

    int getPropAsInt(Shared::XMLNode *node, const Common::String &prop, bool recursive = false);

    Common::String getContent(Shared::XMLNode *node);

    /*
     * Action Functions
     */
    ReturnCode pushContext(Shared::XMLNode *script, Shared::XMLNode *current);

    ReturnCode popContext(Shared::XMLNode *script, Shared::XMLNode *current);

    ReturnCode end(Shared::XMLNode *script, Shared::XMLNode *current);

    ReturnCode waitForKeypress(Shared::XMLNode *script, Shared::XMLNode *current);

    ReturnCode redirect(Shared::XMLNode *script, Shared::XMLNode *current);

    ReturnCode include(Shared::XMLNode *script, Shared::XMLNode *current);

    ReturnCode wait(Shared::XMLNode *script, Shared::XMLNode *current);

    ReturnCode forLoop(Shared::XMLNode *script, Shared::XMLNode *current);

    ReturnCode randomScript(Shared::XMLNode *script, Shared::XMLNode *current);

    ReturnCode move(Shared::XMLNode *script, Shared::XMLNode *current);

    ReturnCode sleep(Shared::XMLNode *script, Shared::XMLNode *current);

    ReturnCode cursor(Shared::XMLNode *script, Shared::XMLNode *current);

    ReturnCode pay(Shared::XMLNode *script, Shared::XMLNode *current);

    ReturnCode _if(Shared::XMLNode *script, Shared::XMLNode *current);

    ReturnCode input(Shared::XMLNode *script, Shared::XMLNode *current);

    ReturnCode add(Shared::XMLNode *script, Shared::XMLNode *current);

    ReturnCode lose(Shared::XMLNode *script, Shared::XMLNode *current);

    ReturnCode heal(Shared::XMLNode *script, Shared::XMLNode *current);

    ReturnCode castSpell(Shared::XMLNode *script, Shared::XMLNode *current);

    ReturnCode damage(Shared::XMLNode *script, Shared::XMLNode *current);

    ReturnCode karma(Shared::XMLNode *script, Shared::XMLNode *current);

    ReturnCode music(Shared::XMLNode *script, Shared::XMLNode *current);

    ReturnCode setVar(Shared::XMLNode *script, Shared::XMLNode *current);

    ReturnCode ztats(Shared::XMLNode *script, Shared::XMLNode *current);

    /*
     * Math and comparison functions
     */

    void mathParseChildren(Shared::XMLNode *math, Common::String *result);

    int mathValue(const Common::String &str);

    int math(int lval, int rval, Common::String &op);

    bool mathParse(const Common::String &str, int *lval, int *rval, Common::String *op);

    void parseOperation(const Common::String &str, Common::String *lval, Common::String *rval, Common::String *op);

    bool compare(const Common::String &str);

    void funcParse(const Common::String &str, Common::String *funcName, Common::String *contents);

    /*
     * Static variables
     */
private:
    typedef Common::HashMap<Common::String, Action> ActionMap;
    ActionMap _actionMap;

private:
    void removeCurrentVariable(const Common::String &name);
    Shared::XMLNode *_vendorScriptDoc;
    Shared::XMLNode *_scriptNode;
    bool _debug;

    State _state;                    
    Shared::XMLNode *_currentScript;       
    Shared::XMLNode *_currentItem;         
    Common::List<Shared::XMLNode *> _translationContext;  
    Common::String _target;                  
    InputType _inputType;            
    Common::String _inputName;               
    int _inputMaxLen;                
    Common::String _nounName;                
    Common::String _idPropName;              
    Common::String _choices;
    int _iterator;

    Common::HashMap<Common::String, Variable *> _variables;
    Common::HashMap<Common::String, Provider *> _providers;
};

} // End of namespace Ultima4
} // End of namespace Ultima

#endif