Horizon::Zone::GameLogicProcess::MonsterSpawnAgent Class Reference

Collaboration diagram for Horizon::Zone::GameLogicProcess::MonsterSpawnAgent:

Public Member Functions
	~MonsterSpawnAgent ()
void	initialize (std::shared_ptr< GameLogicProcess > game_logic_process)
void	finalize ()
std::shared_ptr< GameLogicProcess >	get_container ()
void	spawn_monsters (std::string map_name)
void	reschedule_single_monster_spawn (std::shared_ptr< Horizon::Zone::Units::Monster > monster)
void	spawn_monster_internal (std::shared_ptr< Map > map, int spawn_dataset_id, int monster_id, int16_t amount, int16_t x, int16_t y, int16_t x_area, int16_t y_area)
void	despawn_monsters (std::string map_name)
void	register_monster_spawn_info (uint32_t id, std::shared_ptr< monster_spawn_data > data)
std::shared_ptr< monster_spawn_data >	get_monster_spawn_info (uint32_t id)
void	clear_monster_spawn_info ()

Public Attributes
int32_t	_last_monster_spawn_id {0}

Private Attributes
std::weak_ptr< GameLogicProcess >	_game_logic_process
LockedLookupTable< uint32_t, std::shared_ptr< monster_spawn_data > >	_monster_spawn_db

Constructor & Destructor Documentation

~MonsterSpawnAgent()

GameLogicProcess::MonsterSpawnAgent::~MonsterSpawnAgent

(

)

{
 
}

Member Function Documentation

clear_monster_spawn_info()

void Horizon::Zone::GameLogicProcess::MonsterSpawnAgent::clear_monster_spawn_info ( )

inline

{ _monster_spawn_db.clear(); }

References _monster_spawn_db, and LockedLookupTable< Key, Value, Hash >::clear().

Referenced by Horizon::Zone::GameLogicProcess::finalize().

Here is the call graph for this function:

Here is the caller graph for this function:

despawn_monsters()

void GameLogicProcess::MonsterSpawnAgent::despawn_monsters

(

std::string

map_name

)

{
    int segment_number = sZone->get_segment_number_for_resource<Horizon::Zone::GameLogicProcess, RESOURCE_PRIORITY_PRIMARY, std::string, std::shared_ptr<Map>>(Horizon::System::RUNTIME_GAMELOGIC, map_name, nullptr);
 
    if (segment_number == 0)
        return;
 
    std::shared_ptr<Horizon::Zone::GameLogicProcess> container = sZone->get_component_of_type<Horizon::Zone::GameLogicProcess>(Horizon::System::RUNTIME_GAMELOGIC, segment_number);
 
    if (container == nullptr)
        return;
 
    auto monster_spawned_map = container->get_resource_manager().get_medium<RESOURCE_PRIORITY_TERTIARY>().get_map();
 
    for (auto i = monster_spawned_map.begin(); i != monster_spawned_map.end();)
        if ((*i).second->map()->get_name() == map_name && (*i).second->type() == UNIT_MONSTER) {
            (*i).second->finalize();
            container->get_resource_manager().remove<RESOURCE_PRIORITY_TERTIARY>((*i).second->uuid());
            i = monster_spawned_map.erase(i);
        } else {
            i++;
        }
}

References SharedPriorityResourceManager< SharedPriorityResourceMediums >::get_medium(), Horizon::Zone::GameLogicProcess::get_resource_manager(), RESOURCE_PRIORITY_PRIMARY, RESOURCE_PRIORITY_TERTIARY, Horizon::System::RUNTIME_GAMELOGIC, sZone, and UNIT_MONSTER.

Here is the call graph for this function:

finalize()

void Horizon::Zone::GameLogicProcess::MonsterSpawnAgent::finalize

(

)

get_container()

std::shared_ptr< GameLogicProcess > Horizon::Zone::GameLogicProcess::MonsterSpawnAgent::get_container ( )

inline

{ return _game_logic_process.lock(); }

References _game_logic_process.

get_monster_spawn_info()

std::shared_ptr< monster_spawn_data > Horizon::Zone::GameLogicProcess::MonsterSpawnAgent::get_monster_spawn_info ( uint32_t  id )

inline

{ return _monster_spawn_db.at(id); }

References _monster_spawn_db, and LockedLookupTable< Key, Value, Hash >::at().

Here is the call graph for this function:

initialize()

void Horizon::Zone::GameLogicProcess::MonsterSpawnAgent::initialize ( std::shared_ptr< GameLogicProcess >  game_logic_process )

inline

    {
        _game_logic_process = game_logic_process;
    }

References _game_logic_process.

Referenced by Horizon::Zone::GameLogicProcess::initialize().

Here is the caller graph for this function:

register_monster_spawn_info()

void Horizon::Zone::GameLogicProcess::MonsterSpawnAgent::register_monster_spawn_info ( uint32_t  id, std::shared_ptr< monster_spawn_data >  data  )

inline

{ _monster_spawn_db.insert(id, data); }

References _monster_spawn_db, and LockedLookupTable< Key, Value, Hash >::insert().

Here is the call graph for this function:

reschedule_single_monster_spawn()

void GameLogicProcess::MonsterSpawnAgent::reschedule_single_monster_spawn

(

std::shared_ptr< Horizon::Zone::Units::Monster >

monster

)

{
    uint8_t type = 0;
    uint32_t guid = 0;
    uint16_t spawn_dataset_id = 0;
    uint8_t spawn_id = 0;
 
    sZone->from_uuid(monster->uuid(), type, guid, spawn_dataset_id, spawn_id);
 
    std::shared_ptr<monster_spawn_data> msd = get_monster_spawn_info(spawn_dataset_id);
 
    if (msd == nullptr) {
        HLog(error) << "Couldn't find monster spawn data for monster " << monster->uuid() << ", spawn_dataset_id " << spawn_dataset_id << ", monster_id " << monster->job_id() << " and spawn_id " << spawn_id << ".";
        return;
    }
 
    std::shared_ptr<Map> map = monster->map();
 
    msd->dead_amount++;
    // Set the spawn time cache. This is used to calculate the time to spawn the monster.
    monster_spawn_data::s_monster_spawn_time_cache spawn_time_cache;
    spawn_time_cache.dead_time = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count();
 
    spawn_time_cache.spawn_time = msd->spawn_delay_base + std::rand() % (msd->spawn_delay_variance + 1);
    msd->dead_spawn_time_list.emplace(monster->uuid(), spawn_time_cache);
 
    get_container()->getScheduler().Schedule(
        Milliseconds(spawn_time_cache.spawn_time), 
        monster->get_scheduler_task_id(UNIT_SCHEDULE_MONSTER_RESPAWN),
        [this, monster, map, msd](TaskContext /*&context*/) {
            if (map->get_user_count() == 0)
                return;
 
            this->spawn_monster_internal(map, msd->spawn_dataset_id, msd->monster_id, 1, msd->x, msd->y, msd->x_area, msd->y_area);
            msd->dead_spawn_time_list.erase(monster->uuid());
            msd->dead_amount--;
        });
}

References monster_spawn_data::s_monster_spawn_time_cache::dead_time, HLog, monster_spawn_data::s_monster_spawn_time_cache::spawn_time, sZone, and UNIT_SCHEDULE_MONSTER_RESPAWN.

spawn_monster_internal()

void GameLogicProcess::MonsterSpawnAgent::spawn_monster_internal	(	std::shared_ptr< Map >	map,
		int	spawn_dataset_id,
		int	monster_id,
		int16_t	amount,
		int16_t	x,
		int16_t	y,
		int16_t	x_area,
		int16_t	y_area
	)

{
    std::shared_ptr<const monster_config_data> md = MonsterDB->get_monster_by_id(monster_id);
    
    if (md == nullptr) {
        HLog(warning) << "Monster " << monster_id << " set for spawn in " << map->get_name() << " does not exist in the database.";
        return;
    }
 
    std::shared_ptr<std::vector<std::shared_ptr<const monster_skill_config_data>>> mskd = MonsterDB->get_monster_skill_by_id(monster_id);
    
    for (int i = 0; i < amount; i++) {
        MapCoords mcoords = MapCoords(x, y);
        if (mcoords == MapCoords(0, 0))
            mcoords = map->get_random_accessible_coordinates();
        else if (x_area && y_area) {
            if ((mcoords = map->get_random_coordinates_in_walkable_area(x, y, x_area, y_area)) == MapCoords(0, 0)) {
                HLog(warning) << "Couldn't spawn monster " << md->name << " in area, spawning it on random co-ordinates.";
                mcoords = map->get_random_accessible_coordinates();
            }
        }
        std::shared_ptr<Horizon::Zone::Units::Monster> monster = std::make_shared<Horizon::Zone::Units::Monster>(spawn_dataset_id, i, map, mcoords, md, mskd);
        
        monster->initialize();
        map->container()->get_resource_manager().add<RESOURCE_PRIORITY_TERTIARY>(monster->guid(), monster);
    }
 
    return;
}

References HLog, MonsterDB, and RESOURCE_PRIORITY_TERTIARY.

spawn_monsters()

void GameLogicProcess::MonsterSpawnAgent::spawn_monsters

(

std::string

map_name

)

{
    auto monster_spawn_map = _monster_spawn_db.get_map();
 
    for (auto i = monster_spawn_map.begin(); i != monster_spawn_map.end(); i++) {
        std::shared_ptr<monster_spawn_data> msd = (*i).second;
        if (map_name.compare(msd->map_name) == 0) {
            if (msd->dead_amount > 0) {
                for (auto dead_it = msd->dead_spawn_time_list.begin(); dead_it != msd->dead_spawn_time_list.end();) {
                    int64_t dead_monster_spawn_uuid = dead_it->first;
                    monster_spawn_data::s_monster_spawn_time_cache dead_stc = dead_it->second;
                    
                    uint8_t type = 0;
                    uint32_t guid = 0;
                    uint16_t spawn_dataset_id = 0;
                    uint8_t spawn_id = 0;
 
                    sZone->from_uuid(dead_monster_spawn_uuid, type, guid, spawn_dataset_id, spawn_id);
 
                    int64_t since_death_ms = (std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count() - dead_stc.dead_time);
 
                    int64_t time_to_spawn_ms = dead_stc.spawn_time - since_death_ms;
 
                    if (time_to_spawn_ms < 0)
                        time_to_spawn_ms = 0;
 
                    this->get_container()->getScheduler().Schedule(
                        Milliseconds(time_to_spawn_ms),
                        ((uint64_t) guid << 32) + (int) UNIT_SCHEDULE_MONSTER_RESPAWN,
                        [this, map_name, msd](TaskContext /*&context*/) {
                            int segment_number = sZone->get_segment_number_for_resource<Horizon::Zone::GameLogicProcess, RESOURCE_PRIORITY_PRIMARY, std::string, std::shared_ptr<Map>>(Horizon::System::RUNTIME_GAMELOGIC, map_name, nullptr);
 
                            if (segment_number == 0)
                                return;
 
                            std::shared_ptr<Horizon::Zone::GameLogicProcess> container = sZone->get_component_of_type<Horizon::Zone::GameLogicProcess>(Horizon::System::RUNTIME_GAMELOGIC, segment_number);
 
                            std::shared_ptr<Map> map = container->get_resource_manager().template get_resource<RESOURCE_PRIORITY_PRIMARY, std::string, std::shared_ptr<Map>>(map_name, nullptr);
 
                            if (map->get_user_count() == 0)
                                return;
 
                            this->spawn_monster_internal(map, msd->spawn_dataset_id, msd->monster_id, 1, msd->x, msd->y, msd->x_area, msd->y_area);
                        });
 
                    dead_it = msd->dead_spawn_time_list.erase(dead_it);
                    msd->dead_amount--;
                }
            }
 
            int segment_number = sZone->get_segment_number_for_resource<Horizon::Zone::GameLogicProcess, RESOURCE_PRIORITY_PRIMARY, std::string, std::shared_ptr<Map>>(Horizon::System::RUNTIME_GAMELOGIC, map_name, nullptr);
 
            if (segment_number == 0)
                return;
 
            std::shared_ptr<Horizon::Zone::GameLogicProcess> container = sZone->get_component_of_type<Horizon::Zone::GameLogicProcess>(Horizon::System::RUNTIME_GAMELOGIC, segment_number);
 
            std::shared_ptr<Map> map = container->get_resource_manager().template get_resource<RESOURCE_PRIORITY_PRIMARY, std::string, std::shared_ptr<Map>>(map_name, nullptr);
 
            this->spawn_monster_internal(map, msd->spawn_dataset_id, msd->monster_id, msd->amount - msd->dead_amount, msd->x, msd->y, msd->x_area, msd->y_area);
        }
    }
}

References monster_spawn_data::s_monster_spawn_time_cache::dead_time, Horizon::Zone::GameLogicProcess::get_resource_manager(), RESOURCE_PRIORITY_PRIMARY, Horizon::System::RUNTIME_GAMELOGIC, monster_spawn_data::s_monster_spawn_time_cache::spawn_time, sZone, and UNIT_SCHEDULE_MONSTER_RESPAWN.

Here is the call graph for this function:

Member Data Documentation

_game_logic_process

std::weak_ptr<GameLogicProcess> Horizon::Zone::GameLogicProcess::MonsterSpawnAgent::_game_logic_process

private

Referenced by get_container(), and initialize().

_last_monster_spawn_id

int32_t Horizon::Zone::GameLogicProcess::MonsterSpawnAgent::_last_monster_spawn_id {0}

_monster_spawn_db

LockedLookupTable<uint32_t, std::shared_ptr<monster_spawn_data> > Horizon::Zone::GameLogicProcess::MonsterSpawnAgent::_monster_spawn_db

private

Referenced by clear_monster_spawn_info(), get_monster_spawn_info(), and register_monster_spawn_info().

---

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

• src/Server/Zone/Game/GameLogicProcess.hpp
• src/Server/Zone/Game/GameLogicProcess.cpp