#include <Unit.hpp>

Inheritance diagram for Horizon::Zone::Unit:

Collaboration diagram for Horizon::Zone::Unit:

Classes
struct	s_lockon_after_walk_completed

Public Member Functions
	Unit (uint64_t uuid, unit_type type, unit_type_mask type_mask, std::shared_ptr< Map > map, MapCoords map_coords)

	Unit (uint64_t uuid, unit_type type, unit_type_mask type_mask)

virtual	~Unit ()

bool	initialize ()

virtual bool	finalize ()

bool	is_initialized () const

bool	is_finalized () const

void	set_finalized (bool finalized)

MapCoords const &	dest_coords () const
	Movement. More...

virtual bool	walk_to_coordinates (int16_t x, int16_t y)

virtual bool	walk_to_unit (std::shared_ptr< Unit > unit)

bool	is_walking () const

virtual void	stop_movement ()=0

bool	stop_walking (bool cancel=false, bool notify=false)

uint64_t	uuid () const
	Unit Data. More...

unit_uuid	s_uuid () const

void	set_uuid (uint64_t uuid)

uint32_t	guid ()

uint16_t	job_id () const

void	set_job_id (uint16_t job_id)

unit_posture_type	posture () const

void	set_posture (unit_posture_type posture)

const std::string &	name () const

void	set_name (const std::string &name)

directions	direction () const

void	set_direction (directions dir)

std::shared_ptr< Horizon::Zone::Traits::Status >	status ()

void	set_status (std::shared_ptr< Horizon::Zone::Traits::Status > st)

void	force_movement_stop_internal (bool stop=false)

std::shared_ptr< Map >	map ()
	Map & Map Container. More...

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

AStar::CoordinateList	get_walk_path ()

unit_type	type () const
	Unit applications. More...

unit_type_mask	type_mask () const

bool	is_of_type (int type_mask)

template<class T >
std::shared_ptr< T >	downcast ()

MapCoords const &	map_coords () const
	Grid applications. More...

void	set_map_coords (MapCoords const &coords)

GridCoords const &	grid_coords () const

void	set_grid_coords (GridCoords const &coords)

bool	is_in_range_of (std::shared_ptr< Unit > unit, uint8_t range=MAX_VIEW_RANGE)

void	notify_nearby_players_of_existence (unit_viewport_notification_type notif_type)

void	notify_nearby_players_of_spawn ()

void	notify_nearby_players_of_movement (bool new_entry=false)

void	notify_nearby_players_of_movement_stop (MapCoords stop_coords)

void	notify_nearby_players_of_skill_use (grid_unit_skill_use_notification_type notification_type, s_unit_skill_use_notifier_config config)

void	notify_nearby_players_of_basic_attack (s_grid_unit_basic_attack_config config)

void	notify_nearby_players_of_item_drop (s_grid_notify_item_drop_entry entry)

std::shared_ptr< Unit >	get_nearby_unit (uint32_t guid)

uint64_t	get_scheduler_task_id (unit_task_schedule_group group)

std::map< int16_t, std::shared_ptr< status_change_entry > > &	get_status_effects ()

void	apply_status_change_in_area (std::shared_ptr< Unit > target, s_grid_sc_apply_in_skill_area_config const &config, s_grid_apply_in_area_config const &aoe_config)

void	remove_status_change_in_area (std::shared_ptr< Unit > target, int sc_type, s_grid_apply_in_area_config const &aoe_config)

void	execute_skill_in_area (std::shared_ptr< Unit > target, std::shared_ptr< SkillExecution > skill_execution, s_grid_apply_in_area_config const &aoe_config)

void	execute_skill_in_cell (std::shared_ptr< Unit > target, MapCoords cell, std::shared_ptr< SkillExecution > skill_execution, s_grid_apply_in_area_config const &aoe_config)

void	use_skill_on_target (int16_t skill_lv, int16_t skill_id, int target_guid)

void	use_skill_on_ground (int16_t skill_lv, int16_t skill_id, int16_t pos_x, int16_t pos_y)

void	use_skill_on_ground (int16_t skill_lv, int16_t skill_id, int16_t pos_x, int16_t pos_y, std::string contents)

bool	status_effect_start (int type, int total_time, int val1, int val2, int val3, int val4)
	Status Effects. More...

bool	status_effect_end (int type)

virtual void	on_status_effect_start (std::shared_ptr< status_change_entry > sce)=0

virtual void	on_status_effect_end (std::shared_ptr< status_change_entry > sce)=0

virtual void	on_status_effect_change (std::shared_ptr< status_change_entry > sce)=0

std::shared_ptr< AStar::CoordinateList >	path_to (std::shared_ptr< Unit > e)

int	distance_from (std::shared_ptr< Unit > e)

virtual bool	attack (std::shared_ptr< Unit > target, bool continuous=false)

virtual bool	stop_attacking ()

bool	target_is_attackable (std::shared_ptr< Unit > target)

void	set_attacking (bool attacking)

bool	is_attacking ()

void	on_attack_end ()

bool	is_dead ()

virtual void	on_damage_received (std::shared_ptr< Unit > damage_dealer, int damage)

virtual void	on_killed (std::shared_ptr< Unit > killer, bool with_drops=false, bool with_exp=false)

std::shared_ptr< Combat >	combat ()
	Combat. More...

void	set_combat (std::shared_ptr< Combat > combat)

void	update (uint64_t tick)
	Extremely time-sensitive functions. More...

std::shared_ptr< CombatRegistry >	combat_registry ()

bool	has_damage_walk_delay ()
	Walk Delay. More...

void	set_damage_walk_delay (bool delay)

void	set_lockon_after_walk_completed (uint64_t target_guid, bool continuous=false)
	Lockon after walk completed. More...

void	clear_lockon_after_walk_completed ()

uint64_t	lockon_after_walk_completed_target_guid ()

Protected Member Functions
bool	schedule_walk ()

void	walk ()

virtual void	on_pathfinding_failure ()=0

virtual void	on_movement_begin (int32_t time)=0

virtual void	on_movement_step ()=0

virtual void	on_movement_end ()=0

Private Attributes
bool	_is_initialized {false}

bool	_jump_walk_stop {false}

bool	_is_finalized { false }

bool	_is_attacking {false}

struct Horizon::Zone::Unit::s_lockon_after_walk_completed	_lockon_after_walk_completed

struct Horizon::Zone::Unit::s_lockon_after_walk_completed	false

uint64_t	_uuid {0}

unit_uuid	_s_uuid { 0 }

unit_type	_type {UNIT_UNKNOWN}

unit_type_mask	_type_mask {UNIT_MASK_UNKNOWN}

std::weak_ptr< Map >	_map

MapCoords	_map_coords {0, 0}

GridCoords	_grid_coords {0, 0}

MapCoords	_changed_dest_pos {0, 0}

MapCoords	_dest_pos {0, 0}

AStar::CoordinateList	_walk_path

int16_t	_walk_path_index {0}

std::shared_ptr< Horizon::Zone::Traits::Status >	_status

std::string	_name {""}

uint16_t	_job_id {0}

unit_posture_type	_posture {POSTURE_STANDING}

directions	_facing_dir {DIR_SOUTH}

std::map< int16_t, std::shared_ptr< status_change_entry > >	_status_effects

int32_t	_attackable_time {0}

std::shared_ptr< Combat >	_combat

std::shared_ptr< CombatRegistry >	_combat_registry

bool	_damage_walk_delay {false}

Constructor & Destructor Documentation

◆ Unit() [1/2]

Unit::Unit	(	uint64_t	uuid,
		unit_type	type,
		unit_type_mask	type_mask,
		std::shared_ptr< Map >	map,
		MapCoords	map_coords
	)

    : _type(type), _type_mask(type_mask), _map_coords(map_coords)
{
    set_uuid(uuid);
    set_map(map);
}

References map(), set_map(), set_uuid(), and uuid().

Here is the call graph for this function:

◆ Unit() [2/2]

Unit::Unit	(	uint64_t	uuid,
		unit_type	type,
		unit_type_mask	type_mask
	)

    : _type(type), _type_mask(type_mask), _map_coords(MapCoords(0, 0))
{
    set_uuid(uuid);
    // Map is set in player::load()
}

References set_uuid(), and uuid().

Here is the call graph for this function:

◆ ~Unit()

Unit::~Unit ( )

virtual

{
    _combat = nullptr;
    _combat_registry = nullptr;
}

References _combat, and _combat_registry.

Member Function Documentation

◆ apply_status_change_in_area()

void Unit::apply_status_change_in_area	(	std::shared_ptr< Unit >	target,
		s_grid_sc_apply_in_skill_area_config const &	config,
		s_grid_apply_in_area_config const &	aoe_config
	)

{
    GridSCApplyInSkillArea sc_apply_in_skill_area(shared_from_this(), target, config, aoe_config);
    GridReferenceContainerVisitor<GridSCApplyInSkillArea, GridReferenceContainer<AllUnitTypes>> container(sc_apply_in_skill_area);
 
    map()->visit_in_range(map_coords(), container, MAX_VIEW_RANGE);
}

References map(), map_coords(), and MAX_VIEW_RANGE.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ attack()

bool Unit::attack	(	std::shared_ptr< Unit >	target,
		bool	continuous = `false`
	)

virtual

Reimplemented in Horizon::Zone::Units::Player.

{
    if (target == nullptr) {
        HLog(debug) << "Unit::attack:4: target is null.";
        on_attack_end();
        return false;
    }
 
    set_combat(std::make_shared<Combat>(shared_from_this(), target));
 
    map()->container()->getScheduler().Schedule(
        Milliseconds(0), get_scheduler_task_id(UNIT_SCHEDULE_ATTACK),
        [this, continuous, target](TaskContext context)
        {
            if (!target_is_attackable(target)) {
                on_attack_end();
                return;
            }
 
            std::shared_ptr<AStar::CoordinateList> wp = path_to(target);
            if (wp && (wp->size() == 0 || wp->size() > MAX_VIEW_RANGE)) {
                on_attack_end();
                HLog(debug) << "Unit::attack:5: Path to target is invalid.";
                return;
            }
 
            int range = this->status()->attack_range()->get_base();
 
            _attackable_time = status()->attack_delay()->total();
            
            // If target is not in range of the attacker when source is already attacking, repeat the attack.
            if (!is_in_range_of(target, range)) {
                if (is_attacking()) {
                    stop_attacking();
                }
                set_lockon_after_walk_completed(target->guid(), continuous);
                walk_to_unit(target);
                HLog(debug) << "Unit::attack:6: Target is out of range, stopped attacking and walking to target.";
                return;
            }
 
            //if (!is_in_range_of(target, range) && is_walking()) {
            //  context.Repeat(Milliseconds(_attackable_time));
            //  return;
            //}
 
            if (is_in_range_of(target, range) && is_walking())
                stop_walking();
 
            if (!is_attacking())
                set_attacking(true);
 
            // Let the target start attacking back.
            combat_retaliate_type result = combat()->weapon_attack();
            if (target->type() == UNIT_MONSTER && result == CBT_RET_DEF && target->is_attacking() == false)
                target->attack(shared_from_this(), true);
            if (result == CBT_RET_DEF) {
                target->set_damage_walk_delay(true);
            }
 
            if (continuous)
                context.Repeat(Milliseconds(_attackable_time));
        });
 
    return true;
}

References _attackable_time, CBT_RET_DEF, combat(), get_scheduler_task_id(), HLog, is_attacking(), is_in_range_of(), is_walking(), map(), MAX_VIEW_RANGE, on_attack_end(), path_to(), TaskContext::Repeat(), set_attacking(), set_combat(), set_lockon_after_walk_completed(), status(), stop_attacking(), stop_walking(), target_is_attackable(), UNIT_MONSTER, UNIT_SCHEDULE_ATTACK, and walk_to_unit().

Referenced by Horizon::Zone::Units::Player::attack(), Horizon::Zone::Units::Monster::behavior_active(), and walk().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ clear_lockon_after_walk_completed()

void Horizon::Zone::Unit::clear_lockon_after_walk_completed ( )

inline

273{ _lockon_after_walk_completed.target_guid = 0; }

Horizon::Zone::Unit::_lockon_after_walk_completed

struct Horizon::Zone::Unit::s_lockon_after_walk_completed _lockon_after_walk_completed

Horizon::Zone::Unit::s_lockon_after_walk_completed::target_guid

uint64_t target_guid

Definition: Unit.hpp:282

References _lockon_after_walk_completed, and Horizon::Zone::Unit::s_lockon_after_walk_completed::target_guid.

Referenced by walk().

Here is the caller graph for this function:

◆ combat()

std::shared_ptr< Combat > Horizon::Zone::Unit::combat ( )

inline

Combat.

246{ return _combat; }

References _combat.

Referenced by attack(), set_combat(), stop_attacking(), and Horizon::Zone::UnitComponent::sync_data_types().

Here is the caller graph for this function:

◆ combat_registry()

std::shared_ptr< CombatRegistry > Horizon::Zone::Unit::combat_registry ( )

inline

257{ return _combat_registry; }

References _combat_registry.

Referenced by Horizon::Zone::UnitComponent::sync_data_types(), and update().

Here is the caller graph for this function:

◆ dest_coords()

MapCoords const & Horizon::Zone::Unit::dest_coords ( ) const

inline

Movement.

118{ return _dest_pos; }

Horizon::Zone::Unit::_dest_pos

MapCoords _dest_pos

Definition: Unit.hpp:294

References _dest_pos.

Referenced by is_walking(), Horizon::Zone::Units::Player::on_movement_begin(), and Horizon::Zone::UnitComponent::sync_data_types().

Here is the caller graph for this function:

◆ direction()

directions Horizon::Zone::Unit::direction ( ) const

inline

155{ return _facing_dir; }

Horizon::Zone::Unit::_facing_dir

directions _facing_dir

Definition: Unit.hpp:304

References _facing_dir.

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

Here is the caller graph for this function:

◆ distance_from()

int Horizon::Zone::Unit::distance_from ( std::shared_ptr< Unit > e )

inline

228{ return path_to(e)->size(); }

References path_to().

Referenced by Horizon::Zone::Units::Monster::behavior_active().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ downcast()

template<class T >

std::shared_ptr< T > Horizon::Zone::Unit::downcast ( )

inline

    {
        return std::dynamic_pointer_cast<T>(shared_from_this());
    }

◆ execute_skill_in_area()

void Unit::execute_skill_in_area	(	std::shared_ptr< Unit >	target,
		std::shared_ptr< SkillExecution >	skill_execution,
		s_grid_apply_in_area_config const &	aoe_config
	)

{
    GridExecuteSkillInArea execute_skill_in_area(shared_from_this(), target, skill_execution, aoe_config);
    GridReferenceContainerVisitor<GridExecuteSkillInArea, GridReferenceContainer<AllUnitTypes>> container(execute_skill_in_area);
 
    map()->visit_in_range(map_coords(), container, MAX_VIEW_RANGE);
}

References execute_skill_in_area(), map(), map_coords(), and MAX_VIEW_RANGE.

Referenced by execute_skill_in_area(), and Horizon::Zone::UnitComponent::sync_data_types().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ execute_skill_in_cell()

void Unit::execute_skill_in_cell	(	std::shared_ptr< Unit >	target,
		MapCoords	cell,
		std::shared_ptr< SkillExecution >	skill_execution,
		s_grid_apply_in_area_config const &	aoe_config
	)

{
    GridExecuteSkillInCell execute_skill_in_cell(shared_from_this(), cell, skill_execution, aoe_config);
    GridReferenceContainerVisitor<GridExecuteSkillInCell, GridReferenceContainer<AllUnitTypes>> container(execute_skill_in_cell);
 
    map()->visit_in_range(map_coords(), container, MAX_VIEW_RANGE);
}

References cell, execute_skill_in_cell(), map(), map_coords(), and MAX_VIEW_RANGE.

Referenced by execute_skill_in_cell(), and Horizon::Zone::UnitComponent::sync_data_types().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ finalize()

bool Unit::finalize ( )

virtual

Reimplemented in Horizon::Zone::Units::Item, Horizon::Zone::Units::Monster, and Horizon::Zone::Units::Mob.

{
    set_finalized(true);
 
    return _is_finalized;
}

References _is_finalized, and set_finalized().

Referenced by Horizon::Zone::Units::Mob::finalize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ force_movement_stop_internal()

void Horizon::Zone::Unit::force_movement_stop_internal ( bool stop = false )

inline

161{ _jump_walk_stop = stop; }

Horizon::Zone::Unit::_jump_walk_stop

bool _jump_walk_stop

Definition: Unit.hpp:277

References _jump_walk_stop.

Referenced by Horizon::Zone::Units::Player::move_to_map(), Horizon::Zone::UnitComponent::sync_data_types(), and walk().

Here is the caller graph for this function:

◆ get_nearby_unit()

std::shared_ptr< Unit > Unit::get_nearby_unit ( uint32_t guid )

{
    GridUnitSearcher searcher(guid);
    GridReferenceContainerVisitor<GridUnitSearcher, GridReferenceContainer<AllUnitTypes>> search_visitor(searcher);
 
    map()->visit_in_range(map_coords(), search_visitor);
 
    return searcher.get_result();
}

References GridUnitSearcher::get_result(), guid(), map(), and map_coords().

Referenced by Horizon::Zone::Units::Player::pickup_item(), Horizon::Zone::UnitComponent::sync_data_types(), and walk().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_scheduler_task_id()

uint64_t Horizon::Zone::Unit::get_scheduler_task_id ( unit_task_schedule_group group )

inline

204{ return ((uint64_t) guid() << 32) + (int) group; }

References guid().

Referenced by attack(), Horizon::Zone::Units::Monster::initialize(), status_effect_start(), Horizon::Zone::Units::Player::stop_attack(), stop_attacking(), stop_walking(), and walk().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_status_effects()

std::map< int16_t, std::shared_ptr< status_change_entry > > & Horizon::Zone::Unit::get_status_effects ( )

inline

205{ return _status_effects; }

Horizon::Zone::Unit::_status_effects

std::map< int16_t, std::shared_ptr< status_change_entry > > _status_effects

Definition: Unit.hpp:306

References _status_effects.

Referenced by status_effect_end(), and status_effect_start().

Here is the caller graph for this function:

◆ get_walk_path()

AStar::CoordinateList Horizon::Zone::Unit::get_walk_path ( )

inline

168{ return _walk_path; }

Horizon::Zone::Unit::_walk_path

AStar::CoordinateList _walk_path

Definition: Unit.hpp:295

References _walk_path.

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

Here is the caller graph for this function:

◆ grid_coords()

GridCoords const & Horizon::Zone::Unit::grid_coords ( ) const

inline

189{ return _grid_coords; }

Horizon::Zone::Unit::_grid_coords

GridCoords _grid_coords

Definition: Unit.hpp:292

References _grid_coords.

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

Here is the caller graph for this function:

◆ guid()

uint32_t Horizon::Zone::Unit::guid ( )

inline

144{ return _s_uuid.guid; }

Horizon::Zone::Unit::_s_uuid

unit_uuid _s_uuid

Definition: Unit.hpp:287

unit_uuid::guid

uint32_t guid

Definition: Unit.hpp:82

References _s_uuid, and unit_uuid::guid.

Referenced by get_nearby_unit(), get_scheduler_task_id(), notify_nearby_players_of_movement_stop(), Horizon::Zone::Units::Player::on_status_effect_end(), Horizon::Zone::Units::Player::on_status_effect_start(), Horizon::Zone::Units::Player::pickup_item(), Horizon::Zone::Units::Player::respawn(), Horizon::Zone::Units::Player::set_npc_contact_guid(), Horizon::Zone::Units::Player::stop_movement(), and Horizon::Zone::UnitComponent::sync_data_types().

Here is the caller graph for this function:

◆ has_damage_walk_delay()

bool Horizon::Zone::Unit::has_damage_walk_delay ( )

inline

Walk Delay.

262{ return _damage_walk_delay; }

Horizon::Zone::Unit::_damage_walk_delay

bool _damage_walk_delay

Definition: Unit.hpp:315

References _damage_walk_delay.

◆ initialize()

bool Unit::initialize ( )

{
    if (type() == UNIT_ITEM || type() == UNIT_SKILL) {
        _is_initialized = true;
        return _is_initialized;
    }
        
    _status = std::make_shared<Horizon::Zone::Traits::Status>(shared_from_this(), type());
    _combat_registry = std::make_shared<CombatRegistry>(shared_from_this());
    _is_initialized = true;
 
    return _is_initialized;
}

References _combat_registry, _is_initialized, _status, type(), UNIT_ITEM, and UNIT_SKILL.

Referenced by Horizon::Zone::Units::Item::initialize(), Horizon::Zone::Units::Monster::initialize(), Horizon::Zone::Units::NPC::initialize(), Horizon::Zone::Units::Player::initialize(), and Horizon::Zone::Units::Mob::initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_attacking()

bool Horizon::Zone::Unit::is_attacking ( )

inline

235{ return _is_attacking; }

Horizon::Zone::Unit::_is_attacking

bool _is_attacking

Definition: Unit.hpp:278

References _is_attacking.

Referenced by attack(), Horizon::Zone::Units::Monster::behavior_passive(), stop_attacking(), and walk_to_coordinates().

Here is the caller graph for this function:

◆ is_dead()

bool Unit::is_dead ( )

{
    if (status() == nullptr)
        return true;
        
    return status()->current_hp()->get_base() <= 0;
}

References status().

Referenced by Horizon::Zone::Units::Player::on_map_enter(), Horizon::Zone::Units::Player::remove_unit_from_viewport(), Horizon::Zone::Units::Player::respawn(), Horizon::Zone::UnitComponent::sync_data_types(), and target_is_attackable().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_finalized()

bool Horizon::Zone::Unit::is_finalized ( ) const

inline

112{ return _is_finalized; }

References _is_finalized.

◆ is_in_range_of()

bool Unit::is_in_range_of	(	std::shared_ptr< Unit >	unit,
		uint8_t	range = `MAX_VIEW_RANGE`
	)

{
    if (e->map()->get_name().compare(map()->get_name()))
        return false;
 
    return map_coords().is_within_range(e->map_coords(), range);
}

References Coordinates< MAX_COORDINATES >::is_within_range(), map(), and map_coords().

Referenced by attack(), and Horizon::Zone::UnitComponent::sync_data_types().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_initialized()

bool Horizon::Zone::Unit::is_initialized ( ) const

inline

111{ return _is_initialized; }

References _is_initialized.

Referenced by update().

Here is the caller graph for this function:

◆ is_of_type()

bool Horizon::Zone::Unit::is_of_type ( int type_mask )

inline

175{ return !((type_mask & (int) _type_mask) == 0); }

References _type_mask, and type_mask().

Here is the call graph for this function:

◆ is_walking()

bool Horizon::Zone::Unit::is_walking ( ) const

inline

121{ return (dest_coords() != MapCoords(0, 0)) || ((_changed_dest_pos) != MapCoords(0, 0)); }

Horizon::Zone::Unit::_changed_dest_pos

MapCoords _changed_dest_pos

Definition: Unit.hpp:294

Horizon::Zone::Unit::dest_coords

MapCoords const & dest_coords() const

Movement.

Definition: Unit.hpp:118

References _changed_dest_pos, and dest_coords().

Referenced by attack(), Horizon::Zone::Units::Monster::behavior_passive(), Horizon::Zone::Units::Player::move_to_map(), and Horizon::Zone::UnitComponent::sync_data_types().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ job_id()

uint16_t Horizon::Zone::Unit::job_id ( ) const

inline

146{ return _job_id; }

Horizon::Zone::Unit::_job_id

uint16_t _job_id

Definition: Unit.hpp:302

References _job_id.

Referenced by Horizon::Zone::Units::Player::initialize(), Horizon::Zone::Units::Player::job_change(), Horizon::Zone::Units::NPC::NPC(), set_job_id(), and Horizon::Zone::UnitComponent::sync_data_types().

Here is the caller graph for this function:

◆ lockon_after_walk_completed_target_guid()

uint64_t Horizon::Zone::Unit::lockon_after_walk_completed_target_guid ( )

inline

274{ return _lockon_after_walk_completed.target_guid; }

References _lockon_after_walk_completed, and Horizon::Zone::Unit::s_lockon_after_walk_completed::target_guid.

Referenced by walk().

Here is the caller graph for this function:

◆ map()

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

inline

Map & Map Container.

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

Horizon::Zone::Unit::_map

std::weak_ptr< Map > _map

Definition: Unit.hpp:290

References _map.

Here is the caller graph for this function:

◆ map_coords()

MapCoords const & Horizon::Zone::Unit::map_coords ( ) const

inline

Grid applications.

186{ return _map_coords; }

References _map_coords.

Here is the caller graph for this function:

◆ name()

const std::string & Horizon::Zone::Unit::name ( ) const

inline

152{ return _name; }

Horizon::Zone::Unit::_name

std::string _name

Definition: Unit.hpp:301

References _name.

Referenced by Horizon::Zone::Units::Monster::behavior_active(), Horizon::Zone::Units::NPC::NPC(), Horizon::Zone::Units::Player::save(), set_name(), and Horizon::Zone::UnitComponent::sync_data_types().

Here is the caller graph for this function:

◆ notify_nearby_players_of_basic_attack()

void Unit::notify_nearby_players_of_basic_attack ( s_grid_unit_basic_attack_config config )

{
    GridUnitBasicAttackNotifier notifier(shared_from_this(), config);
    GridReferenceContainerVisitor<GridUnitBasicAttackNotifier, GridReferenceContainer<AllUnitTypes>> basic_attack_notifier(notifier);
 
    map()->visit_in_range(map_coords(), basic_attack_notifier);
}

References map(), and map_coords().

Here is the call graph for this function:

◆ notify_nearby_players_of_existence()

void Unit::notify_nearby_players_of_existence ( unit_viewport_notification_type notif_type )

{
    GridUnitExistenceNotifier existence_notify(shared_from_this(), notif_type);
    GridReferenceContainerVisitor<GridUnitExistenceNotifier, GridReferenceContainer<AllUnitTypes>> unit_visitor(existence_notify);
 
    map()->visit_in_range(map_coords(), unit_visitor);
}

References map(), and map_coords().

Referenced by Horizon::Zone::Units::Player::move_to_map(), on_killed(), Horizon::Zone::UnitComponent::sync_data_types(), and walk().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ notify_nearby_players_of_item_drop()

void Unit::notify_nearby_players_of_item_drop ( s_grid_notify_item_drop_entry entry )

{
    GridUnitItemDropNotifier notifier(entry);
    GridReferenceContainerVisitor<GridUnitItemDropNotifier, GridReferenceContainer<AllUnitTypes>> item_drop_notifier(notifier);
 
    map()->visit_in_range(map_coords(), item_drop_notifier);
}

References map(), and map_coords().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ notify_nearby_players_of_movement()

void Unit::notify_nearby_players_of_movement ( bool new_entry = false )

{
    GridUnitMovementNotifier movement_notify(shared_from_this(), new_entry);
    GridReferenceContainerVisitor<GridUnitMovementNotifier, GridReferenceContainer<AllUnitTypes>> unit_visitor(movement_notify);
 
    map()->visit_in_range(map_coords(), unit_visitor);
}

References map(), and map_coords().

Referenced by schedule_walk(), and Horizon::Zone::UnitComponent::sync_data_types().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ notify_nearby_players_of_movement_stop()

void Unit::notify_nearby_players_of_movement_stop ( MapCoords stop_coords )

{
    GridUnitMovementStopNotifier movement_stop_notify(guid(), stop_coords.x(), stop_coords.y());
    GridReferenceContainerVisitor<GridUnitMovementStopNotifier, GridReferenceContainer<AllUnitTypes>> unit_visitor(movement_stop_notify);
 
    map()->visit_in_range(map_coords(), unit_visitor);
}

References guid(), map(), map_coords(), Coordinates< MAX_COORDINATES >::x(), and Coordinates< MAX_COORDINATES >::y().

Referenced by stop_walking().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ notify_nearby_players_of_skill_use()

void Unit::notify_nearby_players_of_skill_use	(	grid_unit_skill_use_notification_type	notification_type,
		s_unit_skill_use_notifier_config	config
	)

{
    GridUnitSkillUseNotifier notifier(shared_from_this(), notification_type, config);
    GridReferenceContainerVisitor<GridUnitSkillUseNotifier, GridReferenceContainer<AllUnitTypes>> skill_use_notifier(notifier);
 
    map()->visit_in_range(map_coords(), skill_use_notifier);
}

References map(), and map_coords().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ notify_nearby_players_of_spawn()

void Unit::notify_nearby_players_of_spawn ( )

{
    GridUnitSpawnNotifier spawn_notify(shared_from_this());
    GridReferenceContainerVisitor<GridUnitSpawnNotifier, GridReferenceContainer<AllUnitTypes>> unit_visitor(spawn_notify);
 
    map()->visit_in_range(map_coords(), unit_visitor);
}

References map(), and map_coords().

Referenced by Horizon::Zone::Units::Player::on_map_enter(), and Horizon::Zone::UnitComponent::sync_data_types().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ on_attack_end()

void Unit::on_attack_end ( )

{
    stop_attacking();
    stop_walking(true, false);
}

References stop_attacking(), and stop_walking().

Referenced by attack().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ on_damage_received()

void Unit::on_damage_received	(	std::shared_ptr< Unit >	damage_dealer,
		int	damage
	)

virtual

Reimplemented in Horizon::Zone::Units::Monster, Horizon::Zone::Units::Mob, and Horizon::Zone::Units::Player.

{
    if (status()->current_hp()->total() < damage)
    {
        status()->current_hp()->set_base(0);
        on_killed(damage_dealer);
        return;
    }
}

References on_killed(), and status().

Referenced by Horizon::Zone::Units::Mob::on_damage_received(), and Horizon::Zone::Units::Player::on_damage_received().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ on_killed()

void Unit::on_killed	(	std::shared_ptr< Unit >	killer,
		bool	with_drops = `false`,
		bool	with_exp = `false`
	)

virtual

Reimplemented in Horizon::Zone::Units::Monster, Horizon::Zone::Units::Mob, and Horizon::Zone::Units::Player.

{
    stop_walking();
    stop_attacking();
    notify_nearby_players_of_existence(EVP_NOTIFY_DEAD);
}

References EVP_NOTIFY_DEAD, notify_nearby_players_of_existence(), stop_attacking(), and stop_walking().

Referenced by on_damage_received(), Horizon::Zone::Units::Mob::on_killed(), and Horizon::Zone::Units::Player::on_killed().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ on_movement_begin()

virtual void Horizon::Zone::Unit::on_movement_begin ( int32_t time )

protectedpure virtual

Implemented in Horizon::Zone::Units::Item, Horizon::Zone::Units::Elemental, Horizon::Zone::Units::Homunculus, Horizon::Zone::Units::Mercenary, Horizon::Zone::Units::Pet, Horizon::Zone::Units::Monster, Horizon::Zone::Units::NPC, Horizon::Zone::Units::Player, and Horizon::Zone::Units::Skill.

Referenced by walk().

Here is the caller graph for this function:

◆ on_movement_end()

virtual void Horizon::Zone::Unit::on_movement_end ( )

protectedpure virtual

Implemented in Horizon::Zone::Units::Item, Horizon::Zone::Units::Elemental, Horizon::Zone::Units::Homunculus, Horizon::Zone::Units::Mercenary, Horizon::Zone::Units::Pet, Horizon::Zone::Units::Monster, Horizon::Zone::Units::NPC, Horizon::Zone::Units::Player, and Horizon::Zone::Units::Skill.

Referenced by stop_walking().

Here is the caller graph for this function:

◆ on_movement_step()

virtual void Horizon::Zone::Unit::on_movement_step ( )

protectedpure virtual

Implemented in Horizon::Zone::Units::Item, Horizon::Zone::Units::Elemental, Horizon::Zone::Units::Homunculus, Horizon::Zone::Units::Mercenary, Horizon::Zone::Units::Pet, Horizon::Zone::Units::Monster, Horizon::Zone::Units::NPC, Horizon::Zone::Units::Player, and Horizon::Zone::Units::Skill.

Referenced by walk().

Here is the caller graph for this function:

◆ on_pathfinding_failure()

virtual void Horizon::Zone::Unit::on_pathfinding_failure ( )

protectedpure virtual

Implemented in Horizon::Zone::Units::Item, Horizon::Zone::Units::Elemental, Horizon::Zone::Units::Homunculus, Horizon::Zone::Units::Mercenary, Horizon::Zone::Units::Pet, Horizon::Zone::Units::Monster, Horizon::Zone::Units::NPC, Horizon::Zone::Units::Player, and Horizon::Zone::Units::Skill.

Referenced by schedule_walk().

Here is the caller graph for this function:

◆ on_status_effect_change()

virtual void Horizon::Zone::Unit::on_status_effect_change ( std::shared_ptr< status_change_entry > sce )

pure virtual

Implemented in Horizon::Zone::Units::Item, Horizon::Zone::Units::Elemental, Horizon::Zone::Units::Homunculus, Horizon::Zone::Units::Mercenary, Horizon::Zone::Units::Pet, Horizon::Zone::Units::Monster, Horizon::Zone::Units::NPC, and Horizon::Zone::Units::Player.

Referenced by status_effect_start().

Here is the caller graph for this function:

◆ on_status_effect_end()

virtual void Horizon::Zone::Unit::on_status_effect_end ( std::shared_ptr< status_change_entry > sce )

pure virtual

Implemented in Horizon::Zone::Units::Item, Horizon::Zone::Units::Elemental, Horizon::Zone::Units::Homunculus, Horizon::Zone::Units::Mercenary, Horizon::Zone::Units::Pet, Horizon::Zone::Units::Monster, Horizon::Zone::Units::NPC, and Horizon::Zone::Units::Player.

Referenced by status_effect_end().

Here is the caller graph for this function:

◆ on_status_effect_start()

virtual void Horizon::Zone::Unit::on_status_effect_start ( std::shared_ptr< status_change_entry > sce )

pure virtual

Implemented in Horizon::Zone::Units::Item, Horizon::Zone::Units::Elemental, Horizon::Zone::Units::Homunculus, Horizon::Zone::Units::Mercenary, Horizon::Zone::Units::Pet, Horizon::Zone::Units::Monster, Horizon::Zone::Units::NPC, and Horizon::Zone::Units::Player.

Referenced by status_effect_start().

Here is the caller graph for this function:

◆ path_to()

std::shared_ptr< AStar::CoordinateList > Unit::path_to ( std::shared_ptr< Unit > e )

{
    std::shared_ptr<AStar::CoordinateList> wp = std::make_shared<AStar::CoordinateList>(map()->get_pathfinder().findPath(map_coords(), e->map_coords()));
 
    if (wp->size() == 0 || wp->empty())
        return nullptr;
 
    return std::move(wp);
}

References map(), and map_coords().

Referenced by attack(), and distance_from().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ posture()

unit_posture_type Horizon::Zone::Unit::posture ( ) const

inline

149{ return _posture; }

Horizon::Zone::Unit::_posture

unit_posture_type _posture

Definition: Unit.hpp:303

References _posture.

Referenced by set_posture(), and Horizon::Zone::UnitComponent::sync_data_types().

Here is the caller graph for this function:

◆ remove_status_change_in_area()

void Unit::remove_status_change_in_area	(	std::shared_ptr< Unit >	target,
		int	sc_type,
		s_grid_apply_in_area_config const &	aoe_config
	)

{
    GridSCRemoveInSkillArea sc_remove_in_skill_area(shared_from_this(), target, sc_type, aoe_config);
    GridReferenceContainerVisitor<GridSCRemoveInSkillArea, GridReferenceContainer<AllUnitTypes>> container(sc_remove_in_skill_area);
 
    map()->visit_in_range(map_coords(), container, MAX_VIEW_RANGE);
}

References map(), map_coords(), and MAX_VIEW_RANGE.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ s_uuid()

unit_uuid Horizon::Zone::Unit::s_uuid ( ) const

inline

141{ return _s_uuid; }

References _s_uuid.

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

Here is the caller graph for this function:

◆ schedule_walk()

bool Unit::schedule_walk ( )

protected

~1us

{
    MapCoords source_pos = {map_coords().x(), map_coords().y()};
 
    if (!_walk_path.empty())
        _walk_path.clear();
 
    if (!map())
    {
        // HLog(error) << "Reference to map object has been lost for unit " << (void *) this << ".";
        _dest_pos = {0, 0};
        if (_type == UNIT_PLAYER) HLog(debug) << "Unit::walking:2: Map object has been lost.";
        return false;
    }
 
    // This method returns vector of coordinates from target to source.
    _walk_path = map()->get_pathfinder().findPath(source_pos, _dest_pos); // ~5us
 
    _changed_dest_pos = {0, 0};
 
    // If destination was a collision, nothing is returned.
    if (_walk_path.size() == 0)
    {
        // HLog(warning) << "Unit::schedule_walk: Destination was a collision, no walk path available.";
        _dest_pos = {0, 0};
        if (_type == UNIT_PLAYER) HLog(debug) << "Unit::walking:3: Destination was a collision.";
        return false;
    }
 
    std::reverse(_walk_path.begin(), _walk_path.end());
    _walk_path.erase(_walk_path.begin());
 
    if (_walk_path.empty())
    {
        on_pathfinding_failure();
        // HLog(warning) << "Unit::schedule_walk: Path too short or empty, failed to schedule movement.";
        _dest_pos = {0, 0};
        if (_type == UNIT_PLAYER) HLog(debug) << "Unit::walking:4: Path too short or empty.";
        return false;
    }
                 // 0us
    notify_nearby_players_of_movement(); // 3us
    walk();                              // 3~6 us
    return true;
}

References _changed_dest_pos, _dest_pos, _type, _walk_path, HLog, map(), map_coords(), notify_nearby_players_of_movement(), on_pathfinding_failure(), UNIT_PLAYER, walk(), Coordinates< MAX_COORDINATES >::x(), and Coordinates< MAX_COORDINATES >::y().

Referenced by walk(), and walk_to_coordinates().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_attacking()

void Horizon::Zone::Unit::set_attacking ( bool attacking )

inline

234{ _is_attacking = attacking; }

References _is_attacking.

Referenced by attack(), and stop_attacking().

Here is the caller graph for this function:

◆ set_combat()

void Horizon::Zone::Unit::set_combat ( std::shared_ptr< Combat > combat )

inline

    {
        _combat = combat;
    }

References _combat, and combat().

Referenced by attack().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_damage_walk_delay()

void Horizon::Zone::Unit::set_damage_walk_delay ( bool delay )

inline

263{ _damage_walk_delay = delay; }

References _damage_walk_delay.

◆ set_direction()

void Horizon::Zone::Unit::set_direction ( directions dir )

inline

156{ _facing_dir = dir; }

References _facing_dir.

Referenced by Horizon::Zone::Units::Monster::Monster(), and Horizon::Zone::Units::NPC::NPC().

Here is the caller graph for this function:

◆ set_finalized()

void Horizon::Zone::Unit::set_finalized ( bool finalized )

inline

113{ _is_finalized = finalized; }

References _is_finalized.

Referenced by finalize().

Here is the caller graph for this function:

◆ set_grid_coords()

void Horizon::Zone::Unit::set_grid_coords ( GridCoords const & coords )

inline

190{ _grid_coords = coords; }

References _grid_coords.

◆ set_job_id()

void Horizon::Zone::Unit::set_job_id ( uint16_t job_id )

inline

147{ _job_id = job_id; }

Horizon::Zone::Unit::job_id

uint16_t job_id() const

Definition: Unit.hpp:146

References _job_id, and job_id().

Referenced by Horizon::Zone::Units::Player::job_change(), Horizon::Zone::Units::Monster::Monster(), and Horizon::Zone::Units::NPC::NPC().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_lockon_after_walk_completed()

void Horizon::Zone::Unit::set_lockon_after_walk_completed	(	uint64_t	target_guid,
		bool	continuous = `false`
	)

inline

Lockon after walk completed.

    {
        _lockon_after_walk_completed.target_guid = target_guid;
        _lockon_after_walk_completed.continuous = continuous;
    }

References _lockon_after_walk_completed, Horizon::Zone::Unit::s_lockon_after_walk_completed::continuous, and Horizon::Zone::Unit::s_lockon_after_walk_completed::target_guid.

Referenced by attack().

Here is the caller graph for this function:

◆ set_map()

void Horizon::Zone::Unit::set_map ( std::shared_ptr< Map > map )

inline

166{ _map = map; }

References _map, and map().

Referenced by Horizon::Zone::Units::Player::load(), Horizon::Zone::Units::Player::move_to_map(), and Unit().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_map_coords()

void Horizon::Zone::Unit::set_map_coords ( MapCoords const & coords )

inline

187{ _map_coords = coords; }

References _map_coords.

Referenced by Horizon::Zone::Units::Player::load(), Horizon::Zone::Units::Player::move_to_map(), and walk().

Here is the caller graph for this function:

◆ set_name()

void Horizon::Zone::Unit::set_name ( const std::string & name )

inline

153{ _name = name; }

Horizon::Zone::Unit::name

const std::string & name() const

Definition: Unit.hpp:152

References _name, and name().

Referenced by Horizon::Zone::Units::Player::load(), Horizon::Zone::Units::Monster::Monster(), and Horizon::Zone::Units::NPC::NPC().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_posture()

void Horizon::Zone::Unit::set_posture ( unit_posture_type posture )

inline

150{ _posture = posture; }

Horizon::Zone::Unit::posture

unit_posture_type posture() const

Definition: Unit.hpp:149

References _posture, and posture().

Referenced by Horizon::Zone::Units::Player::load(), and Horizon::Zone::UnitComponent::sync_data_types().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_status()

void Horizon::Zone::Unit::set_status ( std::shared_ptr< Horizon::Zone::Traits::Status > st )

inline

159{ _status = st; }

References _status.

◆ set_uuid()

void Unit::set_uuid ( uint64_t uuid )

{
    sZone->from_uuid(uuid, _s_uuid.type, _s_uuid.guid, _s_uuid.uid2, _s_uuid.uid3);
    _uuid = uuid;
}

References _s_uuid, _uuid, unit_uuid::guid, sZone, unit_uuid::type, unit_uuid::uid2, unit_uuid::uid3, and uuid().

Referenced by Horizon::Zone::UnitComponent::sync_data_types(), and Unit().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ status()

std::shared_ptr< Horizon::Zone::Traits::Status > Horizon::Zone::Unit::status ( )

inline

158{ return _status; }

References _status.

Here is the caller graph for this function:

◆ status_effect_end()

bool Unit::status_effect_end ( int type )

{
    std::map<int16_t, std::shared_ptr<status_change_entry>>::iterator it = get_status_effects().find(type);
 
    if (it == get_status_effects().end())
    {
        HLog(warning) << "Trying to end status effect that doesn't exist. ID " << type << ", ignoring...";
        return false;
    }
 
    on_status_effect_end(it->second);
 
    get_status_effects().erase(it);
 
    return true;
}

References get_status_effects(), HLog, on_status_effect_end(), and type().

Referenced by status_effect_start(), and Horizon::Zone::UnitComponent::sync_data_types().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ status_effect_start()

bool Unit::status_effect_start	(	int	type,
		int	total_time,
		int	val1,
		int	val2,
		int	val3,
		int	val4
	)

Status Effects.

{
    std::map<int16_t, std::shared_ptr<status_change_entry>>::iterator it = get_status_effects().find(type);
 
    if (it == get_status_effects().end())
    {
        std::shared_ptr<status_change_entry> sce = std::make_shared<status_change_entry>();
        sce->type = type;
        sce->val1 = val1;
        sce->val2 = val2;
        sce->val3 = val3;
        sce->val4 = val4;
 
        if (total_time < 0)
        {
            sce->infinite_duration = true;
            sce->current_time = 0;
            sce->total_time = 0;
        }
        else
        {
            sce->current_time = std::time(nullptr) + total_time;
            sce->total_time = total_time;
        }
 
        get_status_effects().insert(std::pair(type, sce));
        on_status_effect_start(sce);
    }
    else
    {
        std::shared_ptr<status_change_entry> sce = it->second;
        sce->current_time = std::time(nullptr) + total_time;
        sce->total_time = total_time;
 
        on_status_effect_change(sce);
    }
 
    if (map()->container()->getScheduler().Count(get_scheduler_task_id(UNIT_SCHEDULE_STATUS_EFFECT_CLEAR)) == 0)
        map()->container()->getScheduler().Schedule(
            Milliseconds(UNIT_STATUS_EFFECT_CHECK_TIME),
            get_scheduler_task_id(UNIT_SCHEDULE_STATUS_EFFECT_CLEAR),
            [this](TaskContext context)
            {
                std::map<int16_t, std::shared_ptr<status_change_entry>>::iterator it = get_status_effects().begin();
 
                int infinite_statuses = 0;
                for (; it != get_status_effects().end(); it++)
                {
                    std::shared_ptr<status_change_entry> sce = it->second;
 
                    if (sce->infinite_duration == false)
                    {
                        infinite_statuses++;
                        continue;
                    }
 
                    if (sce->current_time - std::time(nullptr) <= 0)
                        status_effect_end(sce->type);
                }
 
                if (get_status_effects().size() > infinite_statuses)
                    context.Repeat(Milliseconds(UNIT_STATUS_EFFECT_CHECK_TIME));
            });
 
    return true;
}

References get_scheduler_task_id(), get_status_effects(), map(), on_status_effect_change(), on_status_effect_start(), TaskContext::Repeat(), status_effect_end(), type(), UNIT_SCHEDULE_STATUS_EFFECT_CLEAR, and UNIT_STATUS_EFFECT_CHECK_TIME.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ stop_attacking()

bool Unit::stop_attacking ( )

virtual

{
    if (!is_attacking())
        return false;
 
    set_attacking(false);
    map()->container()->getScheduler().CancelGroup(get_scheduler_task_id(UNIT_SCHEDULE_ATTACK));
    combat().reset();
 
    return true;
}

References combat(), get_scheduler_task_id(), is_attacking(), map(), set_attacking(), and UNIT_SCHEDULE_ATTACK.

Referenced by attack(), on_attack_end(), on_killed(), and walk_to_coordinates().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ stop_movement()

virtual void Horizon::Zone::Unit::stop_movement ( )

pure virtual

Implemented in Horizon::Zone::Units::Item, Horizon::Zone::Units::Elemental, Horizon::Zone::Units::Homunculus, Horizon::Zone::Units::Mercenary, Horizon::Zone::Units::Pet, Horizon::Zone::Units::Monster, Horizon::Zone::Units::NPC, Horizon::Zone::Units::Player, and Horizon::Zone::Units::Skill.

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

Here is the caller graph for this function:

◆ stop_walking()

bool Unit::stop_walking	(	bool	cancel = `false`,
		bool	notify = `false`
	)

{
    _dest_pos = {0, 0};
    _changed_dest_pos = {0, 0};
 
    if (cancel)
        map()->container()->getScheduler().CancelGroup(get_scheduler_task_id(UNIT_SCHEDULE_WALK));
 
    if (notify)
        this->notify_nearby_players_of_movement_stop(map_coords());
 
    on_movement_end();
 
    return true;
}

References _changed_dest_pos, _dest_pos, get_scheduler_task_id(), map(), map_coords(), notify_nearby_players_of_movement_stop(), on_movement_end(), and UNIT_SCHEDULE_WALK.

Referenced by attack(), on_attack_end(), on_killed(), and walk().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ target_is_attackable()

bool Unit::target_is_attackable ( std::shared_ptr< Unit > target )

{
    if (target == nullptr) {
        HLog(debug) << "Unit::attack:1: Attack target is null.";
        return false;
    }
 
    if (is_dead()) {
        HLog(debug) << "Unit::attack:2: Attacker is dead.";
        return false;
    }
 
    if (target->is_dead()) {
        HLog(debug) << "Unit::attack:3: Target is dead.";
        return false;
    }
 
    return true;
}

References HLog, and is_dead().

Referenced by attack(), and walk().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ type()

unit_type Horizon::Zone::Unit::type ( ) const

inline

Unit applications.

173{ return _type; }

References _type.

Referenced by initialize(), Horizon::Zone::Units::Player::notify_in_area(), Horizon::Zone::Units::Player::remove_unit_from_viewport(), status_effect_end(), status_effect_start(), and Horizon::Zone::UnitComponent::sync_data_types().

Here is the caller graph for this function:

◆ type_mask()

unit_type_mask Horizon::Zone::Unit::type_mask ( ) const

inline

174{ return _type_mask; }

References _type_mask.

Referenced by is_of_type().

Here is the caller graph for this function:

◆ update()

void Unit::update ( uint64_t tick )

Extremely time-sensitive functions.

Extremely time-sensitive, do not use for any other purpose than to check for very small calculations.

{
    if (_combat_registry != nullptr)
        combat_registry()->process_queue();
    if (status() != nullptr && status()->is_initialized() != false) {
        status()->status_registry()->process_queue();
        status()->update(std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::high_resolution_clock::now().time_since_epoch()).count());
    }
}

References _combat_registry, combat_registry(), GridTypeListIterator::count(), is_initialized(), and status().

Here is the call graph for this function:

◆ use_skill_on_ground() [1/2]

void Unit::use_skill_on_ground	(	int16_t	skill_lv,
		int16_t	skill_id,
		int16_t	pos_x,
		int16_t	pos_y
	)

{
    auto ske = std::make_shared<SkillExecution>(shared_from_this(), skill_id, skill_lv);
    ske->execute(pos_x, pos_y);
}

◆ use_skill_on_ground() [2/2]

void Unit::use_skill_on_ground	(	int16_t	skill_lv,
		int16_t	skill_id,
		int16_t	pos_x,
		int16_t	pos_y,
		std::string	contents
	)

{
    auto ske = std::make_shared<SkillExecution>(shared_from_this(), skill_id, skill_lv);
    ske->execute(pos_x, pos_y, contents);
}

◆ use_skill_on_target()

void Unit::use_skill_on_target	(	int16_t	skill_lv,
		int16_t	skill_id,
		int	target_guid
	)

{
    auto ske = std::make_shared<SkillExecution>(shared_from_this(), skill_id, skill_lv);
    ske->execute(target_guid);
}

◆ uuid()

uint64_t Horizon::Zone::Unit::uuid ( ) const

inline

Unit Data.

140{ return _uuid; }

References _uuid.

Referenced by Horizon::Zone::Units::Monster::on_killed(), set_uuid(), Horizon::Zone::UnitComponent::sync_data_types(), and Unit().

Here is the caller graph for this function:

◆ walk()

void Unit::walk ( )

protected

{
    map()->container()->getScheduler().CancelGroup(get_scheduler_task_id(UNIT_SCHEDULE_WALK));
    
    if (status() == nullptr || status()->movement_speed() == nullptr) {
        if (_type == UNIT_PLAYER) HLog(debug) << "Unit::walking:5: Status or movement speed is null.";  
        return;
    }
 
    if (_walk_path.size() == 1) {
        stop_walking();
        if (_type == UNIT_PLAYER) HLog(debug) << "Unit::walking:6: Walk path size is 1.";
        return;
    }
 
    MapCoords c = _walk_path.at(0); // for the first step.
 
    // @NOTE It is possible that at the time of begining movement, that a creature is not in the viewport of the player.
    on_movement_begin((int32_t) get_sys_time());
    
    map()->container()->getScheduler().Schedule(
        Milliseconds(status()->movement_speed()->get_with_cost(_walk_path.at(1).move_cost())), get_scheduler_task_id(UNIT_SCHEDULE_WALK),
        [this](TaskContext context)
        {
            if (_walk_path.size() == 0) { // to fix the "invalid vector subscript" error.
                if (_type == UNIT_PLAYER) HLog(debug) << "Unit::walking:7:1: Walk path size is 0.";
                return;
            }
 
            MapCoords c = _walk_path.at(0);
 
            // Force stop as the current coordinates might asynchronously update after map has changed
            // and co-ordinates are reset to something in a previous walk path.
            // This force stop will return before changing co-ordinates and
            // prevent further movement updates after map has changed.
            if (_jump_walk_stop)
            {
                stop_walking(true);
                force_movement_stop_internal(false);
                if (_type == UNIT_PLAYER) HLog(debug) << "Unit::walking:7:2: Jump walk stop.";
                return;
            }
 
            MapCoords step_coords(c.x(), c.y());
 
            // set_direction((directions) my_coords.direction_to(step_coords));
 
            notify_nearby_players_of_existence(EVP_NOTIFY_OUT_OF_SIGHT);
            set_map_coords(step_coords);
            on_movement_step();
            notify_nearby_players_of_existence(EVP_NOTIFY_IN_SIGHT);
 
            _walk_path.erase(_walk_path.begin());
 
            if (_changed_dest_pos != MapCoords(0, 0))
            {
                _dest_pos = _changed_dest_pos;
                _changed_dest_pos = {0, 0};
                schedule_walk();
                if (_type == UNIT_PLAYER) HLog(debug) << "Unit::walking:7:3: Destination changed, rescheduling...";
                return;
            }
            else if (_dest_pos == MapCoords(c.x(), c.y()) || _walk_path.size() == 1)
            {
                stop_walking();
                if (_type == UNIT_PLAYER) HLog(debug) << "Unit::walking:7:4: Destination reached.";
                if (lockon_after_walk_completed_target_guid() > 0)
                {
                    std::shared_ptr<Unit> target = get_nearby_unit(lockon_after_walk_completed_target_guid());
                    if (target_is_attackable(target))
                    {
                        attack(target, _lockon_after_walk_completed.continuous);
                        clear_lockon_after_walk_completed();
                    }
                }
                return;
            }
 
            // std::chrono::milliseconds walk_delay = std::chrono::milliseconds(status()->movement_speed()->get_with_cost(_walk_path.at(1).move_cost()));
            
            // if (has_damage_walk_delay() && is_dead() == false)
            //  walk_delay += std::chrono::milliseconds(status()->damage_walk_delay()->total());
 
            // set_damage_walk_delay(false);
 
            if (!_walk_path.empty())
                context.Repeat();
        });
}

References _changed_dest_pos, _dest_pos, _jump_walk_stop, _lockon_after_walk_completed, _type, _walk_path, attack(), clear_lockon_after_walk_completed(), Horizon::Zone::Unit::s_lockon_after_walk_completed::continuous, EVP_NOTIFY_IN_SIGHT, EVP_NOTIFY_OUT_OF_SIGHT, force_movement_stop_internal(), get_nearby_unit(), get_scheduler_task_id(), get_sys_time(), HLog, lockon_after_walk_completed_target_guid(), map(), notify_nearby_players_of_existence(), on_movement_begin(), on_movement_step(), TaskContext::Repeat(), schedule_walk(), set_map_coords(), status(), stop_walking(), target_is_attackable(), UNIT_PLAYER, UNIT_SCHEDULE_WALK, Coordinates< MAX_COORDINATES >::x(), and Coordinates< MAX_COORDINATES >::y().

Referenced by schedule_walk().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ walk_to_coordinates()

bool Unit::walk_to_coordinates	(	int16_t	x,
		int16_t	y
	)

virtual

{
    if (_dest_pos.x() != 0 && _dest_pos.y() != 0 && _dest_pos.x() != x && _dest_pos.y() != y)
    {
        _changed_dest_pos = {x, y};
        if (_type == UNIT_PLAYER) HLog(debug) << "Unit::walking:1: Destination changed to (" << x << ", " << y << ").";
        return true;
    }
 
    if (is_attacking())
        stop_attacking();
 
    _dest_pos = {x, y};
 
    return schedule_walk();
}

References _changed_dest_pos, _dest_pos, _type, HLog, is_attacking(), schedule_walk(), stop_attacking(), UNIT_PLAYER, Coordinates< MAX_COORDINATES >::x(), and Coordinates< MAX_COORDINATES >::y().

Referenced by Horizon::Zone::Units::Monster::behavior_passive(), Horizon::Zone::UnitComponent::sync_data_types(), and walk_to_unit().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ walk_to_unit()

bool Unit::walk_to_unit ( std::shared_ptr< Unit > unit )

virtual

{
    if (unit == nullptr)
        return false;
 
    if (walk_to_coordinates(unit->map_coords().x(), unit->map_coords().y()))
    {
        // HLog(warning) << "Unit (" << guid() << ") could not walk to (" << unit->guid() << ").";
        return false;
    }
 
    return true;
}

References walk_to_coordinates().

Referenced by attack().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ _attackable_time

int32_t Horizon::Zone::Unit::_attackable_time {0}

private

Referenced by attack().

◆ _changed_dest_pos

MapCoords Horizon::Zone::Unit::_changed_dest_pos {0, 0}

private

Referenced by is_walking(), schedule_walk(), stop_walking(), walk(), and walk_to_coordinates().

◆ _combat

std::shared_ptr<Combat> Horizon::Zone::Unit::_combat

private

Referenced by combat(), set_combat(), and ~Unit().

◆ _combat_registry

std::shared_ptr<CombatRegistry> Horizon::Zone::Unit::_combat_registry

private

Referenced by combat_registry(), initialize(), update(), and ~Unit().

◆ _damage_walk_delay

bool Horizon::Zone::Unit::_damage_walk_delay {false}

private

Referenced by has_damage_walk_delay(), and set_damage_walk_delay().

◆ _dest_pos

MapCoords Horizon::Zone::Unit::_dest_pos {0, 0}

private

Referenced by dest_coords(), schedule_walk(), stop_walking(), walk(), and walk_to_coordinates().

◆ _facing_dir

directions Horizon::Zone::Unit::_facing_dir {DIR_SOUTH}

private

Referenced by direction(), and set_direction().

◆ _grid_coords

GridCoords Horizon::Zone::Unit::_grid_coords {0, 0}

private

Referenced by grid_coords(), and set_grid_coords().

◆ _is_attacking

bool Horizon::Zone::Unit::_is_attacking {false}

private

Referenced by is_attacking(), and set_attacking().

◆ _is_finalized

bool Horizon::Zone::Unit::_is_finalized { false }

private

Referenced by finalize(), is_finalized(), and set_finalized().

◆ _is_initialized

bool Horizon::Zone::Unit::_is_initialized {false}

private

Referenced by initialize(), and is_initialized().

◆ _job_id

uint16_t Horizon::Zone::Unit::_job_id {0}

private

Referenced by job_id(), and set_job_id().

◆ _jump_walk_stop

bool Horizon::Zone::Unit::_jump_walk_stop {false}

private

Referenced by force_movement_stop_internal(), and walk().

◆ _lockon_after_walk_completed

struct Horizon::Zone::Unit::s_lockon_after_walk_completed Horizon::Zone::Unit::_lockon_after_walk_completed

private

Referenced by clear_lockon_after_walk_completed(), lockon_after_walk_completed_target_guid(), set_lockon_after_walk_completed(), and walk().

◆ _map

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

private

Referenced by map(), and set_map().

◆ _map_coords

MapCoords Horizon::Zone::Unit::_map_coords {0, 0}

private

Referenced by map_coords(), and set_map_coords().

◆ _name

std::string Horizon::Zone::Unit::_name {""}

private

Referenced by name(), and set_name().

◆ _posture

unit_posture_type Horizon::Zone::Unit::_posture {POSTURE_STANDING}

private

Referenced by posture(), and set_posture().

◆ _s_uuid

unit_uuid Horizon::Zone::Unit::_s_uuid { 0 }

private

Referenced by guid(), s_uuid(), and set_uuid().

◆ _status

std::shared_ptr<Horizon::Zone::Traits::Status> Horizon::Zone::Unit::_status

private

Referenced by initialize(), set_status(), and status().

◆ _status_effects

std::map<int16_t, std::shared_ptr<status_change_entry> > Horizon::Zone::Unit::_status_effects

private

Referenced by get_status_effects().

◆ _type

unit_type Horizon::Zone::Unit::_type {UNIT_UNKNOWN}

private

Referenced by schedule_walk(), type(), walk(), and walk_to_coordinates().

◆ _type_mask

unit_type_mask Horizon::Zone::Unit::_type_mask {UNIT_MASK_UNKNOWN}

private

Referenced by is_of_type(), and type_mask().

◆ _uuid

uint64_t Horizon::Zone::Unit::_uuid {0}

private

Referenced by set_uuid(), and uuid().

◆ _walk_path

AStar::CoordinateList Horizon::Zone::Unit::_walk_path

private

Referenced by get_walk_path(), schedule_walk(), and walk().

◆ _walk_path_index

int16_t Horizon::Zone::Unit::_walk_path_index {0}

private

◆ false

struct Horizon::Zone::Unit::s_lockon_after_walk_completed Horizon::Zone::Unit::false

private

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

src/Server/Zone/Game/Units/Unit.hpp
src/Server/Zone/Game/Units/Unit.cpp

Classes

Public Member Functions

Protected Member Functions

Private Attributes

Constructor & Destructor Documentation

◆ Unit() [1/2]

◆ Unit() [2/2]

◆ ~Unit()

Member Function Documentation

◆ apply_status_change_in_area()

◆ attack()

◆ clear_lockon_after_walk_completed()

◆ combat()

◆ combat_registry()

◆ dest_coords()

◆ direction()

◆ distance_from()

◆ downcast()

◆ execute_skill_in_area()

◆ execute_skill_in_cell()

◆ finalize()

◆ force_movement_stop_internal()

◆ get_nearby_unit()

◆ get_scheduler_task_id()

◆ get_status_effects()

◆ get_walk_path()

◆ grid_coords()

◆ guid()

◆ has_damage_walk_delay()

◆ initialize()

◆ is_attacking()

◆ is_dead()

◆ is_finalized()

◆ is_in_range_of()

◆ is_initialized()

◆ is_of_type()

◆ is_walking()

◆ job_id()

◆ lockon_after_walk_completed_target_guid()

◆ map()

◆ map_coords()

◆ name()

◆ notify_nearby_players_of_basic_attack()

◆ notify_nearby_players_of_existence()

◆ notify_nearby_players_of_item_drop()

◆ notify_nearby_players_of_movement()

◆ notify_nearby_players_of_movement_stop()

◆ notify_nearby_players_of_skill_use()

◆ notify_nearby_players_of_spawn()

◆ on_attack_end()

◆ on_damage_received()

◆ on_killed()

◆ on_movement_begin()

◆ on_movement_end()

◆ on_movement_step()

◆ on_pathfinding_failure()

◆ on_status_effect_change()

◆ on_status_effect_end()

◆ on_status_effect_start()

◆ path_to()

◆ posture()

◆ remove_status_change_in_area()

◆ s_uuid()

◆ schedule_walk()

◆ set_attacking()

◆ set_combat()

◆ set_damage_walk_delay()

◆ set_direction()

◆ set_finalized()

◆ set_grid_coords()

◆ set_job_id()

◆ set_lockon_after_walk_completed()

◆ set_map()

◆ set_map_coords()

◆ set_name()

◆ set_posture()

◆ set_status()

◆ set_uuid()

◆ status()

◆ status_effect_end()