Horizon::Zone::SkillExecution Class Reference

#include <SkillExecution.hpp>

Inheritance diagram for Horizon::Zone::SkillExecution:

Collaboration diagram for Horizon::Zone::SkillExecution:

Public Member Functions
	SkillExecution (std::shared_ptr< Unit > initial_source, int16_t skill_id, int16_t skill_lv)
	~SkillExecution ()
void	execute (int initial_target_guid)
void	execute (MapCoords map_coords)
void	execute (int16_t x, int16_t y)
void	execute (MapCoords map_coords, std::string message)
void	execute (int16_t x, int16_t y, std::string message)
sol::table	get_skill_cast_data ()

Private Member Functions
void	start_execution (enum skill_target_type target_type)
std::shared_ptr< Map >	map ()
void	set_map (std::shared_ptr< Map > map)
std::shared_ptr< GameLogicProcess >	map_container ()
std::shared_ptr< ScriptManager >	lua_manager ()
std::shared_ptr< sol::state >	lua_state ()

Private Attributes
std::weak_ptr< Map >	_map
std::weak_ptr< GameLogicProcess >	_map_container_thread
std::weak_ptr< ScriptManager >	_lua_mgr
std::weak_ptr< sol::state >	_lua_state
std::shared_ptr< Unit >	_initial_source {nullptr}
std::shared_ptr< Unit >	_initial_target {nullptr}
int16_t	_skill_id
int16_t	_skill_lv
MapCoords	_map_coords
std::string	_message
sol::table	_scd

Constructor & Destructor Documentation

SkillExecution()

SkillExecution::SkillExecution	(	std::shared_ptr< Unit >	initial_source,
		int16_t	skill_id,
		int16_t	skill_lv
	)

: _initial_source(initial_source), _skill_id(skill_id), _skill_lv(skill_lv), _map_coords(MapCoords(0, 0)), _message("")
{
    set_map(initial_source->map());
}

References set_map().

Here is the call graph for this function:

~SkillExecution()

SkillExecution::~SkillExecution

(

)

{
}

Member Function Documentation

execute() [1/5]

void SkillExecution::execute

(

int

initial_target_guid

)

{
    _initial_target = _initial_source->get_nearby_unit(initial_target_guid);
    start_execution(SKTT_SINGLE_TARGETED);
}

References _initial_source, _initial_target, SKTT_SINGLE_TARGETED, and start_execution().

Referenced by execute(), and Horizon::Zone::SkillComponent::sync_data_types().

Here is the call graph for this function:

Here is the caller graph for this function:

execute() [2/5]

void SkillExecution::execute	(	int16_t	x,
		int16_t	y
	)

{
    execute(MapCoords(x, y));
}

References execute().

Here is the call graph for this function:

execute() [3/5]

void SkillExecution::execute	(	int16_t	x,
		int16_t	y,
		std::string	message
	)

{
    execute(MapCoords(x, y), message);
}

References execute().

Here is the call graph for this function:

execute() [4/5]

void SkillExecution::execute

(

MapCoords

map_coords

)

{
    _map_coords = map_coords;
    start_execution(SKTT_GROUND_TARGETED);
}

References _map_coords, SKTT_GROUND_TARGETED, and start_execution().

Here is the call graph for this function:

execute() [5/5]

void SkillExecution::execute	(	MapCoords	map_coords,
		std::string	message
	)

{
    _map_coords = map_coords;
    _message = message;
    start_execution(SKTT_GROUND_TARGETED);
}

References _map_coords, _message, SKTT_GROUND_TARGETED, and start_execution().

Here is the call graph for this function:

get_skill_cast_data()

sol::table Horizon::Zone::SkillExecution::get_skill_cast_data ( )

inline

{ return _scd; }

References _scd.

Referenced by Horizon::Zone::SkillComponent::sync_data_types().

Here is the caller graph for this function:

lua_manager()

std::shared_ptr< ScriptManager > Horizon::Zone::SkillExecution::lua_manager ( )

inlineprivate

{ return _lua_mgr.lock(); }

References _lua_mgr.

lua_state()

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

inlineprivate

{ return _lua_state.lock(); }

References _lua_state.

Referenced by set_map(), and start_execution().

Here is the caller graph for this function:

map()

std::shared_ptr< Map > Horizon::Zone::SkillExecution::map ( )

inlineprivate

{ return _map.expired() ? nullptr : _map.lock(); }

References _map.

Referenced by set_map().

Here is the caller graph for this function:

map_container()

std::shared_ptr< GameLogicProcess > Horizon::Zone::SkillExecution::map_container ( )

inlineprivate

{ return _map_container_thread.lock(); }

References _map_container_thread.

set_map()

void SkillExecution::set_map ( std::shared_ptr< Map >  map )

private

{
    _map = map;
    _map_container_thread = map->container();
    _lua_mgr = sZone->get_component_of_type<ScriptManager>(Horizon::System::RUNTIME_SCRIPTVM);
    _lua_state = sZone->get_component_of_type<ScriptManager>(Horizon::System::RUNTIME_SCRIPTVM)->lua_state();
}

References _lua_mgr, _lua_state, _map, _map_container_thread, lua_state(), map(), Horizon::System::RUNTIME_SCRIPTVM, and sZone.

Referenced by SkillExecution().

Here is the call graph for this function:

Here is the caller graph for this function:

start_execution()

void SkillExecution::start_execution ( enum skill_target_type  target_type )

private

{
    std::shared_ptr<const struct skill_config_data> skd = SkillDB->get_skill_by_id(_skill_id);
 
    if (target_type == SKTT_SINGLE_TARGETED && _initial_target == nullptr)
        return;
 
    if (!skd) {
        HLog(debug) << "SkillExecution::start_execution: Could not find skill with id '" << _skill_id << "' in the database. Ignoring skill usage...";
        return;
    }
 
    try {
        sol::load_result fx = lua_state()->load_file(sZone->config().get_script_root_path().string() + "skills/" + skd->name + ".lua");
        sol::protected_function_result result = fx();
        if (!result.valid()) {
            sol::error err = result;
            HLog(error) << "SkillExecution::start_execution: " << err.what();
            return;
        }
 
        sol::table skill_functions = result;
        sol::protected_function initiate_skill_use = skill_functions["initiate_skill_use"];
 
        _scd = lua_state()->create_table();
        _scd["skill_execution"] = shared_from_this(); // ptr to self.
        _scd["initial_source"] = _initial_source;
        _scd["skill_id"] = _skill_id;
        _scd["skill_lv"] = _skill_lv;
        _scd["target_type"] = target_type;
 
        if (target_type == SKTT_SINGLE_TARGETED) {
            _scd["initial_target"] = _initial_target;
        } else {
            _scd["map_coords"] = _map_coords;
            if (_message.empty() == false)
                _scd["message"] = _message;
        }
 
        result = initiate_skill_use(_scd, skd);
        if (!result.valid()) {
            sol::error err = result;
            HLog(error) << "SkillExecution::start_execution: Error on initiate_skill_use function: " << err.what();
            return;
        }
    } catch (sol::error &e) {
        HLog(error) << "SkillExecution::start_execution: " << e.what();
        return;
    }
}

References _initial_source, _initial_target, _map_coords, _message, _scd, _skill_id, _skill_lv, HLog, lua_state(), SkillDB, SKTT_SINGLE_TARGETED, and sZone.

Referenced by execute().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

_initial_source

std::shared_ptr<Unit> Horizon::Zone::SkillExecution::_initial_source {nullptr}

private

Referenced by execute(), and start_execution().

_initial_target

std::shared_ptr<Unit> Horizon::Zone::SkillExecution::_initial_target {nullptr}

private

Referenced by execute(), and start_execution().

_lua_mgr

std::weak_ptr<ScriptManager> Horizon::Zone::SkillExecution::_lua_mgr

private

Referenced by lua_manager(), and set_map().

_lua_state

std::weak_ptr<sol::state> Horizon::Zone::SkillExecution::_lua_state

private

Referenced by lua_state(), and set_map().

_map

std::weak_ptr<Map> Horizon::Zone::SkillExecution::_map

private

Referenced by map(), and set_map().

_map_container_thread

std::weak_ptr<GameLogicProcess> Horizon::Zone::SkillExecution::_map_container_thread

private

Referenced by map_container(), and set_map().

_map_coords

MapCoords Horizon::Zone::SkillExecution::_map_coords

private

Referenced by execute(), and start_execution().

_message

std::string Horizon::Zone::SkillExecution::_message

private

Referenced by execute(), and start_execution().

_scd

sol::table Horizon::Zone::SkillExecution::_scd

private

Referenced by get_skill_cast_data(), and start_execution().

_skill_id

int16_t Horizon::Zone::SkillExecution::_skill_id

private

Referenced by start_execution().

_skill_lv

int16_t Horizon::Zone::SkillExecution::_skill_lv

private

Referenced by start_execution().

---

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

• src/Server/Zone/Game/SkillSystem/SkillExecution.hpp
• src/Server/Zone/Game/SkillSystem/SkillExecution.cpp