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 "common/file.h"
#include "common/list.h"
 
namespace Ultima {
namespace Ultima4 {
 
class Script {
public:
    class Provider {
    public:
        virtual ~Provider() {}
        virtual Common::String translate(Common::Array<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