ScriptManager.h

Go to the documentation of this file.

/*
 * Copyright (C) 2022 The V-Gears Team
 *
 * This file is part of V-Gears
 *
 * V-Gears is free software: you can redistribute it and/or modify it under
 * terms of the GNU General Public License as published by the Free Software
 * Foundation, version 3.0 (GPLv3) of the License.
 *
 * V-Gears 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.
 */
 
#pragma once
 
#include <OgreSingleton.h>
#include <OgreString.h>
#include "Event.h"
#include "LuaIncludes.h"
#include "Manager.h"
 
class Entity;
 
struct ScriptId{
 
    ScriptId(): entity(""), function(""){}
 
    Ogre::String entity;
 
    Ogre::String function;
};
 
struct ScriptEntity;
 
struct QueueScript{
 
    QueueScript():
      function(""),
      argument1(""),
      argument2(""),
      priority(0),
      state(NULL),
      seconds_to_wait(0),
      wait(false),
      yield(false)
    {}
 
    Ogre::String function;
 
    Ogre::String argument1;
 
    Ogre::String argument2;
 
    int priority;
 
    lua_State* state;
 
    int state_id;
 
    float seconds_to_wait;
 
    bool wait;
 
    bool yield;
 
    ScriptId paused_script_start;
 
    ScriptId paused_script_end;
};
 
 
 
class ScriptManager : public Manager, public Ogre::Singleton<ScriptManager>{
 
    public:
 
        enum Type{
 
            SYSTEM,
 
            ENTITY,
 
            UI,
 
            BATTLE
        };
 
        ScriptManager();
 
        virtual ~ScriptManager();
 
        void Input(const VGears::Event& event) override;
 
        void Update(const Type type);
 
        void UpdateDebug() override;
 
        void OnResize() override;
 
        void ClearField() override;
 
        void ClearBattle() override;
 
        void ClearWorld() override;
 
        void RunString(const Ogre::String& lua);
 
        void RunFile(const Ogre::String& file);
 
        void InitBinds();
 
        void InitCmd();
 
        void AddEntity(const Type type, const Ogre::String& entity_name, Entity* entity);
 
        void RemoveEntity(const Type type, const Ogre::String& entity_name);
 
        void AddEntityScript(
          const Ogre::String& entity_name, const Ogre::String& function_name, int priority
        );
 
        void RemoveEntityTopScript(ScriptEntity& entity);
 
        luabind::object GetTableByEntityName(
          const ScriptManager::Type type, const Ogre::String& name, lua_State* state
        ) const;
 
        QueueScript* GetScriptByScriptId(const ScriptId& script) const;
 
        ScriptEntity* GetScriptEntityByName(const Type type, const Ogre::String& entity_name) const;
 
        const ScriptId GetCurrentScriptId() const;
 
        void ContinueScriptExecution(const ScriptId& script);
 
        int ScriptWait(const float seconds);
 
        void ScriptRequest(
          const Type type, const char* entity, const char* function, const int priority
        );
 
        int ScriptRequestStartSync(
          const Type type, const char* entity, const char* function, const int priority
        );
 
        int ScriptRequestEndSync(
          const Type type, const char* entity, const char* function, const int priority
        );
 
        bool ScriptRequest(
          ScriptEntity* script_entity, const Ogre::String& function,
          const int priority, const Ogre::String& argument1,
          const Ogre::String& argument2, bool start_sync, bool end_sync
        );
 
        void AddValueToStack(const float value);
 
    private:
 
        void UpdateField() override;
 
        void UpdateBattle() override;
 
        void UpdateWorld() override;
 
        lua_State* lua_state_;
 
        Ogre::String system_table_name_;
 
        Ogre::String entity_table_name_;
 
        Ogre::String battle_table_name_;
 
        Ogre::String ui_table_name_;
 
        std::vector<ScriptEntity> script_entity_;
 
        ScriptId current_script_id_;
};
 
struct ScriptEntity{
 
    ScriptEntity(): name(""), type(ScriptManager::SYSTEM), resort(false){}
 
    Ogre::String name;
 
    ScriptManager::Type type;
 
    std::vector<QueueScript> queue;
 
    bool resort;
};