#include <Monster.hpp>

Inheritance diagram for Horizon::Zone::Units::Monster:

Collaboration diagram for Horizon::Zone::Units::Monster:

Public Member Functions
	Monster (int16_t spawn_dataset_id, int8_t spawn_id, std::shared_ptr< Map > map, MapCoords mcoords, std::shared_ptr< const monster_config_data > md, std::shared_ptr< std::vector< std::shared_ptr< const monster_skill_config_data > > > mskd)

	~Monster () override

bool	initialize ()

virtual bool	finalize () override

virtual void	stop_movement () override

virtual void	on_pathfinding_failure () override

virtual void	on_movement_begin (int32_t time) override

virtual void	on_movement_step () override

virtual void	on_movement_end () override

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

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

void	set_spotted (bool spotted)

bool	was_spotted_once ()

std::shared_ptr< const monster_config_data >	monster_config ()

void	set_monster_config (std::shared_ptr< const monster_config_data > md)

void	on_status_effect_start (std::shared_ptr< status_change_entry > sce) override
	Status Effect. More...

void	on_status_effect_end (std::shared_ptr< status_change_entry > sce) override

void	on_status_effect_change (std::shared_ptr< status_change_entry > sce) override

void	behavior_passive ()

void	behavior_active (std::shared_ptr< Player > pl)

void	set_next_walk_time (int walk_time)

int	next_walk_time ()

void	set_target (std::shared_ptr< Unit > &target)

std::shared_ptr< Unit >	target ()

void	unlock_target ()

Public Member Functions inherited from Horizon::Zone::Units::Mob
	Mob (uint64_t uuid, unit_type type, unit_type_mask type_mask, std::shared_ptr< Map > map, MapCoords mcoords)

	~Mob () override

bool	initialize (std::shared_ptr< const monster_config_data > md)

virtual bool	finalize () override

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

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

Public Member Functions inherited from Horizon::Zone::Unit
	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 ()

Public Member Functions inherited from Horizon::Zone::GridObject< Monster >
virtual	~GridObject ()

bool	has_valid_grid_reference () const

void	add_grid_reference (GridRefManager< Monster > &m)

void	remove_grid_reference ()

GridReference< Monster > &	get_reference ()

Private Attributes
bool	_was_spotted_once {false}

int	_next_walk_time {0}

int	_last_spotted_time {0}

int	_last_think_time {0}

std::weak_ptr< const monster_config_data >	_wmd_data

std::weak_ptr< std::vector< std::shared_ptr< const monster_skill_config_data > > >	_wms_data

std::shared_ptr< Unit >	_target {nullptr}

Additional Inherited Members
Protected Member Functions inherited from Horizon::Zone::Unit
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

Constructor & Destructor Documentation

◆ Monster()

Monster::Monster	(	int16_t	spawn_dataset_id,
		int8_t	spawn_id,
		std::shared_ptr< Map >	map,
		MapCoords	mcoords,
		std::shared_ptr< const monster_config_data >	md,
		std::shared_ptr< std::vector< std::shared_ptr< const monster_skill_config_data > > >	mskd
	)

explicit

: Mob(sZone->to_uuid((uint8_t) UNIT_MONSTER, ++_last_np_unit_guid, spawn_dataset_id, spawn_id), UNIT_MONSTER, UNIT_MASK_MONSTER, map, mcoords), _wmd_data(md), _wms_data(mskd)
{
    set_name(md->name);
    set_job_id(md->monster_id);
    set_direction(DIR_SOUTH);
}

References DIR_SOUTH, Horizon::Zone::Unit::set_direction(), Horizon::Zone::Unit::set_job_id(), and Horizon::Zone::Unit::set_name().

Here is the call graph for this function:

◆ ~Monster()

Monster::~Monster ( )

override

56{

57}

Member Function Documentation

◆ behavior_active()

void Monster::behavior_active ( std::shared_ptr< Player > pl )

{
    set_spotted(true);
 
    int can_move = monster_config()->mode & MONSTER_MODE_MASK_CANMOVE;
 
    if (monster_config()->mode & MONSTER_MODE_MASK_AGGRESSIVE) {
        GridMonsterAIActiveSearchTarget target_search(shared_from_this()->downcast<Monster>());
        GridReferenceContainerVisitor<GridMonsterAIActiveSearchTarget, GridReferenceContainer<AllUnitTypes>> ai_executor_caller(target_search);
 
        map()->visit_in_range(map_coords(), ai_executor_caller);
    } else if (monster_config()->mode & MONSTER_MODE_MASK_CHANGECHASE) {
        GridMonsterAIChangeChaseTarget target_search(shared_from_this()->downcast<Monster>());
        GridReferenceContainerVisitor<GridMonsterAIChangeChaseTarget, GridReferenceContainer<AllUnitTypes>> ai_executor_caller(target_search);
 
        map()->visit_in_range(map_coords(), ai_executor_caller);
    }
 
    // BL_ITEM
 
    // Attempt to attack
    if (_target != nullptr) {
        HLog(debug) << "Monster " << name() << " is attempting to attack target " << _target->name() << " (guid: ." << _target->guid() << ", distance: " << distance_from(_target) << ", attack_range: " << monster_config()->attack_range << ")";
        attack(_target);
    }
}

References _target, Horizon::Zone::Unit::attack(), Horizon::Zone::Unit::distance_from(), HLog, Horizon::Zone::Unit::map(), Horizon::Zone::Unit::map_coords(), monster_config(), MONSTER_MODE_MASK_AGGRESSIVE, MONSTER_MODE_MASK_CANMOVE, MONSTER_MODE_MASK_CHANGECHASE, Horizon::Zone::Unit::name(), and set_spotted().

Here is the call graph for this function:

◆ behavior_passive()

void Monster::behavior_passive ( )

{
    if (monster_config()->mode & MONSTER_MODE_MASK_CANMOVE 
        && (next_walk_time() - std::time(nullptr) < 0)
        && !is_walking()
        && !is_attacking()) {
        try {
            MapCoords move_c = map()->get_random_coordinates_in_walkable_range(map_coords().x(), map_coords().y(), 5, 7);
            std::chrono::steady_clock::time_point start = std::chrono::steady_clock::now();
            if (walk_to_coordinates(move_c.x(), move_c.y()) == false) {
                //HLog(error) << "Monster (" << guid() << ") " << name() << " could not move to coordinates.";
                return;
            }
            std::chrono::steady_clock::time_point end = std::chrono::steady_clock::now();
            std::chrono::microseconds duration = std::chrono::duration_cast<std::chrono::microseconds>(end - start);
            //HLog(debug) << "Monster::behavior_passive: behavior invocation time " << duration.count() << "us";
            //HLog(debug) << "Monster::behavior_passive: Monster (" << guid() << ") " << name() << " is walking to (" << move_c.x() << ", " << move_c.y() << ").";
            set_next_walk_time(std::time(nullptr) + std::rand() % (MIN_RANDOM_TRAVEL_TIME / 1000) + 1);
        } catch (sol::error &e) {
            HLog(error) << "Monster::behavior_passive: " << e.what();
        }
    }
}

References HLog, Horizon::Zone::Unit::is_attacking(), Horizon::Zone::Unit::is_walking(), Horizon::Zone::Unit::map(), Horizon::Zone::Unit::map_coords(), MIN_RANDOM_TRAVEL_TIME, monster_config(), MONSTER_MODE_MASK_CANMOVE, next_walk_time(), set_next_walk_time(), Horizon::Zone::Unit::walk_to_coordinates(), Coordinates< MAX_COORDINATES >::x(), and Coordinates< MAX_COORDINATES >::y().

Referenced by initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ finalize()

bool Monster::finalize ( )

overridevirtual

Reimplemented from Horizon::Zone::Units::Mob.

{
    if (!Mob::finalize())
        return false;
 
    if (has_valid_grid_reference())
        remove_grid_reference();
        
    return true;
}

References Horizon::Zone::Units::Mob::finalize(), Horizon::Zone::GridObject< Monster >::has_valid_grid_reference(), and Horizon::Zone::GridObject< Monster >::remove_grid_reference().

Here is the call graph for this function:

◆ initialize()

bool Monster::initialize ( )

{
    std::shared_ptr<const monster_config_data> md = _wmd_data.lock();
 
    if (Mob::initialize(md) == false)
        return false;
 
    map()->ensure_grid_for_unit(this, map_coords());
 
    map()->container()->getScheduler().Schedule(
        Seconds(0),
        get_scheduler_task_id(UNIT_SCHEDULE_AI_THINK),
        [this] (TaskContext context)
    {
        behavior_passive();
        context.Repeat(Milliseconds(MOB_MIN_THINK_TIME_LAZY));
    });
 
    return true;
}

References _wmd_data, behavior_passive(), Horizon::Zone::Unit::get_scheduler_task_id(), Horizon::Zone::Unit::initialize(), Horizon::Zone::Unit::map(), Horizon::Zone::Unit::map_coords(), MOB_MIN_THINK_TIME_LAZY, TaskContext::Repeat(), and UNIT_SCHEDULE_AI_THINK.

Here is the call graph for this function:

◆ monster_config()

std::shared_ptr< const monster_config_data > Horizon::Zone::Units::Monster::monster_config ( )

inline

69{ return _wmd_data.lock(); }

References _wmd_data.

Referenced by behavior_active(), and behavior_passive().

Here is the caller graph for this function:

◆ next_walk_time()

int Horizon::Zone::Units::Monster::next_walk_time ( )

inline

83{ return _next_walk_time; }

Horizon::Zone::Units::Monster::_next_walk_time

int _next_walk_time

Definition: Monster.hpp:91

References _next_walk_time.

Referenced by behavior_passive().

Here is the caller graph for this function:

◆ on_damage_received()

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

overridevirtual

Reimplemented from Horizon::Zone::Units::Mob.

{
    Mob::on_damage_received(damage_dealer, damage);
}

References Horizon::Zone::Units::Mob::on_damage_received().

Here is the call graph for this function:

◆ on_killed()

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

overridevirtual

Reimplemented from Horizon::Zone::Units::Mob.

{
    Mob::on_killed(killer, with_drops, with_exp);
 
    std::shared_ptr<const monster_config_data> md = _wmd_data.lock();
 
    if (md == nullptr)
        return;
 
    switch (killer->type())
    {
    case UNIT_PLAYER:
    {
        std::shared_ptr<Player> player = killer->downcast<Player>();
 
        try {
            std::string script_root_path = sZone->config().get_script_root_path().string();
            sol::load_result fx = player->lua_state()->load_file(script_root_path + "internal/on_monster_killed.lua");
            sol::protected_function_result result = fx(player, shared_from_this()->downcast<Monster>(), with_drops, with_exp);
            if (!result.valid()) {
                sol::error err = result;
                HLog(error) << "Monster::on_killed: " << err.what();
            }
        }
        catch (sol::error& e) {
            HLog(error) << "Monster::on_killed: " << e.what();
        }
    }
        break;
    default:
        HLog(warning) << "Monster::on_killed: Unknown unit type killed monster " << uuid() << " at " << map()->get_name() << " (" << map_coords().x() << ", " << map_coords().y() << ").";
        break;
    }
 
    map()->container()->get_resource_manager().remove<RESOURCE_PRIORITY_TERTIARY>(uuid());
    return;
}

References _wmd_data, HLog, Horizon::Zone::Unit::map(), Horizon::Zone::Unit::map_coords(), Horizon::Zone::Units::Mob::on_killed(), RESOURCE_PRIORITY_TERTIARY, sZone, UNIT_PLAYER, Horizon::Zone::Unit::uuid(), Coordinates< MAX_COORDINATES >::x(), and Coordinates< MAX_COORDINATES >::y().

Here is the call graph for this function:

◆ on_movement_begin()

void Monster::on_movement_begin ( int32_t time )

overridevirtual

Implements Horizon::Zone::Unit.

{
 
}

◆ on_movement_end()

void Monster::on_movement_end ( )

overridevirtual

Implements Horizon::Zone::Unit.

163{

164}

◆ on_movement_step()

void Monster::on_movement_step ( )

overridevirtual

Implements Horizon::Zone::Unit.

{
    map()->ensure_grid_for_unit(this, map_coords());
}

References Horizon::Zone::Unit::map(), and Horizon::Zone::Unit::map_coords().

Here is the call graph for this function:

◆ on_pathfinding_failure()

void Monster::on_pathfinding_failure ( )

overridevirtual

Implements Horizon::Zone::Unit.

{
    //HLog(debug) << "Monster " << name() << " has failed to find path from (" << map_coords().x() << "," << map_coords().y() << ") to (" << dest_coords().x() << ", " << dest_coords().y() << ").";
}