Horizon::Zone::ScriptManager Class Reference

#include <ScriptManager.hpp>

Inheritance diagram for Horizon::Zone::ScriptManager:

Collaboration diagram for Horizon::Zone::ScriptManager:

Public Member Functions
	ScriptManager ()
	~ScriptManager ()
void	initialize_basic_state (std::shared_ptr< sol::state > state)
void	initialize_player_state (std::shared_ptr< sol::state > state)
void	initialize_npc_state (std::shared_ptr< sol::state > state)
void	initialize_monster_state (std::shared_ptr< sol::state > state)
std::shared_ptr< PlayerComponent >	player ()
std::shared_ptr< NPCComponent >	npc ()
std::shared_ptr< MonsterComponent >	monster ()
std::shared_ptr< MapComponent >	map ()
std::shared_ptr< ItemComponent >	item ()
std::shared_ptr< UnitComponent >	unit ()
std::shared_ptr< SkillComponent >	skill ()
std::shared_ptr< StatusEffectComponent >	status_effect ()
std::shared_ptr< CombatComponent >	combat ()
std::shared_ptr< sol::state >	lua_state ()
bool	is_initialized () override
bool	is_finalized () override
void	initialize (int segment_number=1) override
void	finalize () override
void	prepare_lua_state (std::shared_ptr< sol::state > &lua)
void	start ()
void	update (uint64_t diff)
TaskScheduler &	getScheduler ()
ResourceManager &	get_resource_manager ()
Public Member Functions inherited from KernelComponent
	KernelComponent (Kernel *kernel, Horizon::System::runtime_module_type module_type)
virtual void	initialize (int segment_number=1)
virtual void	finalize ()
virtual bool	is_initialized ()
virtual bool	is_finalized ()
void	set_segment_number (int64_t segment_number)
int64_t	get_segment_number ()
void	system_routine_queue_push (std::shared_ptr< Horizon::System::RuntimeContext > context)
void	system_routine_queue_push (std::shared_ptr< Horizon::System::RuntimeContextChain > context)
void	system_routine_process_queue ()
void	system_routine_register (Horizon::System::runtime_module_type module_t, Horizon::System::runtime_synchronization_method sync_t, std::shared_ptr< Horizon::System::RuntimeContext > context)
const std::string	get_uuid_string ()
const std::string	get_type_string ()
Horizon::System::SystemRoutineManager &	get_system_routine_manager ()
Kernel *	get_kernel ()
void	set_thread_cpu_id (int cpu_id)
int	get_thread_cpu_id ()
void	set_thread_update_rate (double rate)
double	get_thread_update_rate ()
void	set_total_execution_time (int time)
int	get_total_execution_time ()
void	calculate_and_set_cpu_load ()

Protected Types
using	PrimaryResource = SharedPriorityResourceMedium< s_segment_storage< uint64_t, std::shared_ptr< Units::NPC > > >
using	ResourceManager = SharedPriorityResourceManager< PrimaryResource >

Protected Attributes
std::atomic< bool >	_is_initialized {false}
std::atomic< bool >	_is_finalized {false}
ResourceManager	_resource_manager
TaskScheduler	_scheduler

Private Member Functions
void	load_constants ()
void	load_scripts ()
void	load_scripts_internal ()

Private Attributes
std::vector< std::string >	_script_files
std::shared_ptr< sol::state >	_lua_state
std::shared_ptr< PlayerComponent >	_player_component
std::shared_ptr< NPCComponent >	_npc_component
std::shared_ptr< MonsterComponent >	_monster_component
std::shared_ptr< MapComponent >	_map_component
std::shared_ptr< ItemComponent >	_item_component
std::shared_ptr< UnitComponent >	_unit_component
std::shared_ptr< SkillComponent >	_skill_component
std::shared_ptr< StatusEffectComponent >	_status_effect_component
std::shared_ptr< CombatComponent >	_combat_component
std::thread	_thread

Member Typedef Documentation

PrimaryResource

using Horizon::Zone::ScriptManager::PrimaryResource = SharedPriorityResourceMedium<s_segment_storage<uint64_t , std::shared_ptr<Units::NPC> >>

protected

ResourceManager

using Horizon::Zone::ScriptManager::ResourceManager = SharedPriorityResourceManager<PrimaryResource>

protected

Constructor & Destructor Documentation

ScriptManager()

ScriptManager::ScriptManager

(

)

: KernelComponent(sZone, Horizon::System::RUNTIME_SCRIPTVM),
_lua_state(std::make_shared<sol::state>()),
_player_component(std::make_shared<PlayerComponent>()),
_npc_component(std::make_shared<NPCComponent>()),
_monster_component(std::make_shared<MonsterComponent>()),
_map_component(std::make_shared<MapComponent>()),
_item_component(std::make_shared<ItemComponent>()),
_unit_component(std::make_shared<UnitComponent>()),
_skill_component(std::make_shared<SkillComponent>()),
_status_effect_component(std::make_shared<StatusEffectComponent>()),
_combat_component(std::make_shared<CombatComponent>()),
_resource_manager(PrimaryResource(RESOURCE_PRIORITY_PRIMARY, std::make_shared<s_segment_storage<uint64_t, std::shared_ptr<Units::NPC>>>()))
{
}

~ScriptManager()

ScriptManager::~ScriptManager

(

)

{
    if (_lua_state != nullptr)
        _lua_state.reset();
}

References _lua_state.

Member Function Documentation

combat()

std::shared_ptr< CombatComponent > Horizon::Zone::ScriptManager::combat ( )

inline

{ return _combat_component; }

References _combat_component.

finalize()

void ScriptManager::finalize ( )

overridevirtual

Reimplemented from KernelComponent.

{
    if (_thread.joinable()) {
        try {
            _thread.join();
        } catch(std::exception &e) {
            HLog(error) << "ScriptManager::finalize: " << e.what();
        }
    }
 
    _lua_state->collect_garbage();
    
    _script_files.clear();
 
    _is_finalized.exchange(true);
}

References _is_finalized, _lua_state, _script_files, _thread, and HLog.

get_resource_manager()

ResourceManager & Horizon::Zone::ScriptManager::get_resource_manager ( )

inline

{ return _resource_manager; }

References _resource_manager.

getScheduler()

TaskScheduler & Horizon::Zone::ScriptManager::getScheduler ( )

inline

{ return _scheduler; }

References _scheduler.

Referenced by initialize_basic_state(), and update().

Here is the caller graph for this function:

initialize()

void ScriptManager::initialize ( int  segment_number = 1 )

overridevirtual

Reimplemented from KernelComponent.

{
    set_segment_number(segment_number);
    _thread = std::thread(&ScriptManager::start, this);
    
    for (int i = 0; i < sZone->get_registered_component_count_of_type(Horizon::System::RUNTIME_GAMELOGIC); i++)
        while (sZone->get_component_of_type<Horizon::Zone::GameLogicProcess>(Horizon::System::RUNTIME_GAMELOGIC, i + 1)->is_initialized() == false)
            std::this_thread::sleep_for(std::chrono::milliseconds(1));
            
    initialize_basic_state(_lua_state);
    initialize_monster_state(_lua_state);
    initialize_npc_state(_lua_state);
    initialize_player_state(_lua_state);
 
    load_constants();
    load_scripts();
 
    _is_initialized.exchange(true);
 
}

References _is_initialized, _lua_state, _thread, initialize_basic_state(), initialize_monster_state(), initialize_npc_state(), initialize_player_state(), Horizon::Zone::GameLogicProcess::is_initialized(), load_constants(), load_scripts(), Horizon::System::RUNTIME_GAMELOGIC, KernelComponent::set_segment_number(), start(), and sZone.

Here is the call graph for this function:

initialize_basic_state()

void ScriptManager::initialize_basic_state

(

std::shared_ptr< sol::state >

state

)

{
    sol::protected_function_result res{};
 
    state->open_libraries(sol::lib::base);
    state->open_libraries(sol::lib::string);
    state->open_libraries(sol::lib::math);
    state->open_libraries(sol::lib::coroutine);
    state->open_libraries(sol::lib::jit);
    state->open_libraries(sol::lib::table);
    state->open_libraries(sol::lib::package);
    state->open_libraries(sol::lib::os);
 
    // Load timer function
    
    state->set_function("get_time", get_sys_time);
    // @TODO Schedule Function
    state->set_function("schedule", [this] (uint32_t time, sol::function fn) {
        getScheduler().Schedule(
          Milliseconds(time),
          [fn] (TaskContext context) {
            sol::protected_function_result result = fn();
            if (!result.valid()) {
                    sol::error err = result;
                    HLog(error) << "ScriptManager::initialize_basic_state: Error on scheduled function: " << err.what();
                }
          }
        );
    });
 
    _map_component->sync_definitions(state);
    _map_component->sync_data_types(state);
    _map_component->sync_functions(state);
 
    _item_component->sync_definitions(state);
    _item_component->sync_data_types(state);
    _item_component->sync_functions(state);
 
    _skill_component->sync_definitions(state);
    _skill_component->sync_data_types(state);
    _skill_component->sync_functions(state);
 
    _status_effect_component->sync_definitions(state);
    _status_effect_component->sync_data_types(state);
    _status_effect_component->sync_functions(state);
 
    _combat_component->sync_definitions(state);
    _combat_component->sync_data_types(state);
    _combat_component->sync_functions(state);
 
    _unit_component->sync_definitions(state);
    _unit_component->sync_data_types(state);
    _unit_component->sync_functions(state);
 
    std::string script_root_path = sZone->config().get_script_root_path().string();
    std::string static_db_root_path = sZone->config().get_static_db_path().string();
    std::vector<std::string> _loadable_files = {
        script_root_path + "utils/strutils.lua",
        static_db_root_path + "definitions/constants.lua"
    };
 
    for (auto &file : _loadable_files) {
        try {
            res = state->script_file(file);
 
            if (!res.valid()) {
                sol::error error = res;
                HLog(error) << "ScriptManager::initialize_state: " << error.what();
            }
        } catch (sol::error &error) {
            HLog(error) << "ScriptManager::initialize_state: " << error.what();
        }
    }
 
    // Macro to constants
    (*state)["MAX_LEVEL"]            = MAX_LEVEL;
    (*state)["MAX_STATUS_POINTS"]    = MAX_STATUS_POINTS;
    (*state)["MAX_CHARACTER_SLOTS"]  = MAX_CHARACTER_SLOTS;
    (*state)["MAX_VIEW_RANGE"]       = MAX_VIEW_RANGE;
    (*state)["MIN_INVENTORY_SIZE"]   = MIN_INVENTORY_SIZE;
    (*state)["MAX_INVENTORY_SIZE"]   = MAX_INVENTORY_SIZE;
    (*state)["MIN_STORAGE_SIZE"]     = MIN_STORAGE_SIZE;
    (*state)["MAX_STORAGE_SIZE"]     = MAX_STORAGE_SIZE;
    (*state)["MAX_INVENTORY_STACK_LIMIT"]  = MAX_INVENTORY_STACK_LIMIT;
    (*state)["MAX_CART_STACK_LIMIT"]  = MAX_CART_STACK_LIMIT;
    (*state)["MAX_STORAGE_STACK_LIMIT"]  = MAX_STORAGE_STACK_LIMIT;
    (*state)["MAX_GSTORAGE_STACK_LIMIT"]  = MAX_GSTORAGE_STACK_LIMIT;
 
#ifdef RENEWAL
    (*state)["RENEWAL"]              = true;
#else
    (*state)["RENEWAL"]              = false;
#endif
 
    (*state)["basic_component"] = true;
}

References _combat_component, _item_component, _map_component, _skill_component, _status_effect_component, _unit_component, get_sys_time(), getScheduler(), HLog, MAX_CART_STACK_LIMIT, MAX_CHARACTER_SLOTS, MAX_GSTORAGE_STACK_LIMIT, MAX_INVENTORY_SIZE, MAX_INVENTORY_STACK_LIMIT, MAX_LEVEL, MAX_STATUS_POINTS, MAX_STORAGE_SIZE, MAX_STORAGE_STACK_LIMIT, MAX_VIEW_RANGE, MIN_INVENTORY_SIZE, MIN_STORAGE_SIZE, TaskScheduler::Schedule(), and sZone.

Referenced by initialize(), initialize_monster_state(), initialize_npc_state(), and initialize_player_state().

Here is the call graph for this function:

Here is the caller graph for this function:

initialize_monster_state()

void ScriptManager::initialize_monster_state

(

std::shared_ptr< sol::state >

state

)

{
    if ((*state)["basic_component"] == sol::lua_nil)
        initialize_basic_state(state);
 
    _monster_component->sync_definitions(state);
    _monster_component->sync_data_types(state);
    // @TODO Monster component functions
    _monster_component->sync_functions(state);
 
 
    (*state)["monster_component"] = true;
}

References _monster_component, and initialize_basic_state().

Referenced by initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

initialize_npc_state()

void ScriptManager::initialize_npc_state

(

std::shared_ptr< sol::state >

state

)

{
    if ((*state)["basic_component"] == sol::lua_nil)
        initialize_basic_state(state);
 
    _npc_component->sync_definitions(state);
    _npc_component->sync_data_types(state);
    // @TODO NPC Component Functions
    _npc_component->sync_functions(state);
 
    (*state)["npc_component"] = true;
}

References _npc_component, and initialize_basic_state().

Referenced by initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

initialize_player_state()

void ScriptManager::initialize_player_state

(

std::shared_ptr< sol::state >

state

)

{
    if ((*state)["basic_component"] == sol::lua_nil)
        initialize_basic_state(state);
 
    _player_component->sync_definitions(state);
    _player_component->sync_data_types(state);
    _player_component->sync_functions(state);
 
    (*state)["player_component"] = true;
}

References _player_component, and initialize_basic_state().

Referenced by initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

is_finalized()

bool Horizon::Zone::ScriptManager::is_finalized ( )

inlineoverridevirtual

Reimplemented from KernelComponent.

{ return _is_finalized.load(); }

References _is_finalized.

is_initialized()

bool Horizon::Zone::ScriptManager::is_initialized ( )

inlineoverridevirtual

Reimplemented from KernelComponent.

{ return _is_initialized.load(); }

References _is_initialized.

item()

std::shared_ptr< ItemComponent > Horizon::Zone::ScriptManager::item ( )

inline

{ return _item_component; }

References _item_component.

load_constants()

void ScriptManager::load_constants ( )

private

{
    std::string file_path = sZone->config().get_static_db_path().string();
 
    // Constants loader acquired, the other threads do not need to load the constants as one has already done it.
    if (_constants_loader.exchange(true) == true)
        return;
 
    try {
        _lua_state->script_file(file_path + "definitions/constants.lua");
        sol::table const_table = _lua_state->get<sol::table>("constants");
        HLog(info) << "Read constants from '" << file_path << "'.";
    } catch (sol::error &e) {
        HLog(error) << "Failed to read constants from '" << file_path << "', reason: " << e.what();
    }
}

References _constants_loader, _lua_state, HLog, and sZone.

Referenced by initialize().

Here is the caller graph for this function:

load_scripts()

void ScriptManager::load_scripts ( )

private

{
    std::string script_root_path = sZone->config().get_script_root_path().string();
 
    // Script loader acquired, the other threads do not need to load the scripts as one has already done it.
    if (_script_loader.exchange(true) == true)
        return;
 
    try {
        _lua_state->script_file(script_root_path + "include.lua");
 
        sol::table scripts = (*_lua_state)["scripts"];
 
        int count = 0;
        scripts.for_each([this, &count, &script_root_path](sol::object const &/*key*/, sol::object const& value) {
            std::string script_file = value.as<std::string>();
            sol::protected_function fn = _lua_state->load_file(script_root_path + script_file);
            sol::protected_function_result result = fn();
            if (!result.valid()) {
                sol::error error = result;
                HLog(warning) << "Failed to load file '" << script_file << "' from '" << script_root_path << "', reason: " << error.what();
                return;
            }
            count++;
        });
        HLog(info) << "Read " << count << " NPC scripts from '" << script_root_path << "'.";
    } catch (sol::error &e) {
        HLog(warning) << "Failed to load included script files from '" << script_root_path << "', reason: " << e.what();
    }
}

References _lua_state, _script_loader, GridTypeListIterator::count(), HLog, and sZone.

Referenced by initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

load_scripts_internal()

void Horizon::Zone::ScriptManager::load_scripts_internal ( )

private

lua_state()

std::shared_ptr< sol::state > Horizon::Zone::ScriptManager::lua_state ( )

inline

{ return _lua_state; }

References _lua_state.

map()

std::shared_ptr< MapComponent > Horizon::Zone::ScriptManager::map ( )

inline

{ return _map_component; }

References _map_component.

monster()

std::shared_ptr< MonsterComponent > Horizon::Zone::ScriptManager::monster ( )

inline

{ return _monster_component; }

References _monster_component.

npc()

std::shared_ptr< NPCComponent > Horizon::Zone::ScriptManager::npc ( )

inline

{ return _npc_component; }

References _npc_component.

player()

std::shared_ptr< PlayerComponent > Horizon::Zone::ScriptManager::player ( )

inline

{ return _player_component; }

References _player_component.

prepare_lua_state()

void Horizon::Zone::ScriptManager::prepare_lua_state

(

std::shared_ptr< sol::state > &

lua

)

skill()

std::shared_ptr< SkillComponent > Horizon::Zone::ScriptManager::skill ( )

inline

{ return _skill_component; }

References _skill_component.

start()

void ScriptManager::start

(

)

{
 
    while (!sZone->general_conf().is_test_run_minimal() && get_shutdown_stage() == SHUTDOWN_NOT_STARTED) {
        update(std::time(nullptr));
        std::this_thread::sleep_for(std::chrono::microseconds(MAX_CORE_UPDATE_INTERVAL));
    }
}

References get_shutdown_stage(), MAX_CORE_UPDATE_INTERVAL, SHUTDOWN_NOT_STARTED, sZone, and update().

Referenced by initialize(), and update().

Here is the call graph for this function:

Here is the caller graph for this function:

status_effect()

std::shared_ptr< StatusEffectComponent > Horizon::Zone::ScriptManager::status_effect ( )

inline

{ return _status_effect_component; }

References _status_effect_component.

unit()

std::shared_ptr< UnitComponent > Horizon::Zone::ScriptManager::unit ( )

inline

{ return _unit_component; }

References _unit_component.

update()

void ScriptManager::update

(

uint64_t

diff

)

{
    std::chrono::high_resolution_clock::time_point start = std::chrono::high_resolution_clock::now();
    getScheduler().Update();
 
    get_system_routine_manager().process_queue();
    
#if WIN32
    DWORD cpu = GetCurrentProcessorNumber();
    if (get_thread_cpu_id() != (int) cpu) 
        set_thread_cpu_id(cpu);
#elif __linux__
    int cpu = sched_getcpu();
    if (get_thread_cpu_id() != cpu)
        set_thread_cpu_id(cpu);
#endif
    calculate_and_set_cpu_load();
    std::chrono::high_resolution_clock::time_point end = std::chrono::high_resolution_clock::now();
    std::chrono::nanoseconds time_span = std::chrono::duration_cast<std::chrono::nanoseconds>(end - start);
    set_total_execution_time(time_span.count());
}

References KernelComponent::calculate_and_set_cpu_load(), KernelComponent::get_system_routine_manager(), KernelComponent::get_thread_cpu_id(), getScheduler(), Horizon::System::SystemRoutineManager::process_queue(), KernelComponent::set_thread_cpu_id(), KernelComponent::set_total_execution_time(), start(), and TaskScheduler::Update().

Referenced by start().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

_combat_component

std::shared_ptr<CombatComponent> Horizon::Zone::ScriptManager::_combat_component

private

Referenced by combat(), and initialize_basic_state().

_is_finalized

std::atomic<bool> Horizon::Zone::ScriptManager::_is_finalized {false}

protected

Referenced by finalize(), and is_finalized().

_is_initialized

std::atomic<bool> Horizon::Zone::ScriptManager::_is_initialized {false}

protected

Referenced by initialize(), and is_initialized().

_item_component

std::shared_ptr<ItemComponent> Horizon::Zone::ScriptManager::_item_component

private

Referenced by initialize_basic_state(), and item().

_lua_state

std::shared_ptr<sol::state> Horizon::Zone::ScriptManager::_lua_state

private

Referenced by finalize(), initialize(), load_constants(), load_scripts(), lua_state(), and ~ScriptManager().

_map_component

std::shared_ptr<MapComponent> Horizon::Zone::ScriptManager::_map_component

private

Referenced by initialize_basic_state(), and map().

_monster_component

std::shared_ptr<MonsterComponent> Horizon::Zone::ScriptManager::_monster_component

private

Referenced by initialize_monster_state(), and monster().

_npc_component

std::shared_ptr<NPCComponent> Horizon::Zone::ScriptManager::_npc_component

private

Referenced by initialize_npc_state(), and npc().

_player_component

std::shared_ptr<PlayerComponent> Horizon::Zone::ScriptManager::_player_component

private

Referenced by initialize_player_state(), and player().

_resource_manager

ResourceManager Horizon::Zone::ScriptManager::_resource_manager

protected

Referenced by get_resource_manager().

_scheduler

TaskScheduler Horizon::Zone::ScriptManager::_scheduler

protected

Referenced by getScheduler().

_script_files

std::vector<std::string> Horizon::Zone::ScriptManager::_script_files

private

Referenced by finalize().

_skill_component

std::shared_ptr<SkillComponent> Horizon::Zone::ScriptManager::_skill_component

private

Referenced by initialize_basic_state(), and skill().

_status_effect_component

std::shared_ptr<StatusEffectComponent> Horizon::Zone::ScriptManager::_status_effect_component

private

Referenced by initialize_basic_state(), and status_effect().

_thread

std::thread Horizon::Zone::ScriptManager::_thread

private

Referenced by finalize(), and initialize().

_unit_component

std::shared_ptr<UnitComponent> Horizon::Zone::ScriptManager::_unit_component

private

Referenced by initialize_basic_state(), and unit().

---

The documentation for this class was generated from the following files:

• src/Server/Zone/Script/ScriptManager.hpp
• src/Server/Zone/Script/ScriptManager.cpp