Horizon::Zone::GameLogicProcess Class Reference

#include <GameLogicProcess.hpp>

Inheritance diagram for Horizon::Zone::GameLogicProcess:

Collaboration diagram for Horizon::Zone::GameLogicProcess:

Classes
class	MonsterSpawnAgent

Public Member Functions
	GameLogicProcess (struct s_game_process_configuration config)
void	initialize (int segment_number=1) override
void	finalize () override
void	update (uint64_t diff)
bool	is_initialized () override
bool	is_finalized () override
bool	load_map_cache ()
void	start_internal ()
TaskScheduler &	getScheduler ()
void	on_map_update (int64_t diff)
MonsterSpawnAgent &	get_monster_spawn_agent ()
struct s_game_process_configuration &	game_config ()
ResourceManager &	get_resource_manager ()
Public Member Functions inherited from KernelComponent
	KernelComponent (Kernel *kernel, Horizon::System::runtime_module_type module_type)
virtual void	initialize (int segment_number=1)
virtual void	finalize ()
virtual bool	is_initialized ()
virtual bool	is_finalized ()
void	set_segment_number (int64_t segment_number)
int64_t	get_segment_number ()
void	system_routine_queue_push (std::shared_ptr< Horizon::System::RuntimeContext > context)
void	system_routine_queue_push (std::shared_ptr< Horizon::System::RuntimeContextChain > context)
void	system_routine_process_queue ()
void	system_routine_register (Horizon::System::runtime_module_type module_t, Horizon::System::runtime_synchronization_method sync_t, std::shared_ptr< Horizon::System::RuntimeContext > context)
const std::string	get_uuid_string ()
const std::string	get_type_string ()
Horizon::System::SystemRoutineManager &	get_system_routine_manager ()
Kernel *	get_kernel ()
void	set_thread_cpu_id (int cpu_id)
int	get_thread_cpu_id ()
void	set_thread_update_rate (double rate)
double	get_thread_update_rate ()
void	set_total_execution_time (int time)
int	get_total_execution_time ()
void	calculate_and_set_cpu_load ()

Protected Types
using	PrimaryResource = SharedPriorityResourceMedium< s_segment_storage< std::string, std::shared_ptr< Map > > >
using	SecondaryResource = SharedPriorityResourceMedium< s_segment_storage< uint64_t, std::shared_ptr< Units::Player > > >
using	TertiaryResource = SharedPriorityResourceMedium< s_segment_storage< uint64_t, std::shared_ptr< Unit > > >
using	ResourceManager = SharedPriorityResourceManager< PrimaryResource, SecondaryResource, TertiaryResource >

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

Private Attributes
MonsterSpawnAgent	_monster_spawn_agent
TaskScheduler	_scheduler
std::thread	_thread
std::map< std::string, map_data >	_maps
struct s_game_process_configuration	_config

Member Typedef Documentation

PrimaryResource

using Horizon::Zone::GameLogicProcess::PrimaryResource = SharedPriorityResourceMedium<s_segment_storage<std::string , std::shared_ptr<Map> >>

protected

ResourceManager

using Horizon::Zone::GameLogicProcess::ResourceManager = SharedPriorityResourceManager<PrimaryResource, SecondaryResource, TertiaryResource>

protected

SecondaryResource

using Horizon::Zone::GameLogicProcess::SecondaryResource = SharedPriorityResourceMedium<s_segment_storage<uint64_t, std::shared_ptr<Units::Player> >>

protected

TertiaryResource

using Horizon::Zone::GameLogicProcess::TertiaryResource = SharedPriorityResourceMedium<s_segment_storage<uint64_t, std::shared_ptr<Unit> >>

protected

Constructor & Destructor Documentation

GameLogicProcess()

GameLogicProcess::GameLogicProcess

(

struct s_game_process_configuration

config

)

: KernelComponent(sZone, Horizon::System::RUNTIME_GAMELOGIC),
_resource_manager(
    PrimaryResource(RESOURCE_PRIORITY_PRIMARY, std::make_shared<s_segment_storage<std::string, std::shared_ptr<Map>>>()),
    SecondaryResource(RESOURCE_PRIORITY_SECONDARY, std::make_shared<s_segment_storage<uint64_t, std::shared_ptr<Units::Player>>>()),
    TertiaryResource(RESOURCE_PRIORITY_TERTIARY, std::make_shared<s_segment_storage<uint64_t, std::shared_ptr<Unit>>>())
),
_config(config)
{
}

Member Function Documentation

finalize()

void GameLogicProcess::finalize ( )

overridevirtual

Reimplemented from KernelComponent.

{
    this->get_resource_manager().clear<RESOURCE_PRIORITY_PRIMARY>();
    this->get_resource_manager().clear<RESOURCE_PRIORITY_SECONDARY>();
    this->get_resource_manager().clear<RESOURCE_PRIORITY_TERTIARY>();
 
    get_monster_spawn_agent().clear_monster_spawn_info();
 
    if (_thread.joinable()) {
        try {
            _thread.join();
        } catch(std::exception &e) {
            HLog(error) << "GameLogicProcess::finalize: " << e.what();
        }
    }
 
    _is_finalized.exchange(true);
}

References _is_finalized, _thread, SharedPriorityResourceManager< SharedPriorityResourceMediums >::clear(), Horizon::Zone::GameLogicProcess::MonsterSpawnAgent::clear_monster_spawn_info(), get_monster_spawn_agent(), get_resource_manager(), HLog, RESOURCE_PRIORITY_PRIMARY, RESOURCE_PRIORITY_SECONDARY, and RESOURCE_PRIORITY_TERTIARY.

Here is the call graph for this function:

game_config()

struct s_game_process_configuration & Horizon::Zone::GameLogicProcess::game_config ( )

inline

{ return _config; }

References _config.

get_monster_spawn_agent()

MonsterSpawnAgent & Horizon::Zone::GameLogicProcess::get_monster_spawn_agent ( )

inline

{ return _monster_spawn_agent; }

References _monster_spawn_agent.

Referenced by finalize(), and initialize().

Here is the caller graph for this function:

get_resource_manager()

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

inline

{ return _resource_manager; }

References _resource_manager.

Referenced by Horizon::Zone::GameLogicProcess::MonsterSpawnAgent::despawn_monsters(), finalize(), Horizon::Zone::GameLogicProcess::MonsterSpawnAgent::spawn_monsters(), start_internal(), and update().

Here is the caller graph for this function:

getScheduler()

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

inline

{ return _scheduler; }

References _scheduler.

Referenced by update().

Here is the caller graph for this function:

initialize()

void GameLogicProcess::initialize ( int  segment_number = 1 )

overridevirtual

Static Databases

Reimplemented from KernelComponent.

{
    set_segment_number(segment_number);
 
    if (static_db_loaded == false) {
        ExpDB->load();
        ExpDB->load_status_point_table();
        JobDB->load();
        ItemDB->load();
        ItemDB->load_refine_db();
        ItemDB->load_weapon_target_size_modifiers_db();
        ItemDB->load_weapon_attribute_modifiers_db();
        StatusEffectDB->load();
        SkillDB->load();
        MonsterDB->load();
        StorageDB->load();
        static_db_loaded = true;
    }
 
    load_map_cache();
    start_internal();
 
    get_monster_spawn_agent().initialize(std::static_pointer_cast<GameLogicProcess>(shared_from_this()));
 
    _is_initialized.exchange(true);
}

References _is_initialized, ExpDB, get_monster_spawn_agent(), Horizon::Zone::GameLogicProcess::MonsterSpawnAgent::initialize(), ItemDB, JobDB, load_map_cache(), MonsterDB, KernelComponent::set_segment_number(), SkillDB, start_internal(), static_db_loaded, StatusEffectDB, and StorageDB.

Here is the call graph for this function:

is_finalized()

bool Horizon::Zone::GameLogicProcess::is_finalized ( )

inlineoverridevirtual

Reimplemented from KernelComponent.

{ return _is_finalized.load(); }

References _is_finalized.

is_initialized()

bool Horizon::Zone::GameLogicProcess::is_initialized ( )

inlineoverridevirtual

Reimplemented from KernelComponent.

{ return _is_initialized.load(); }

References _is_initialized.

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

Here is the caller graph for this function:

load_map_cache()

bool GameLogicProcess::load_map_cache

(

)

{
    Horizon::Libraries::MapCache m;
    std::string db_path = sZone->config().get_static_db_path().string();
 
    m.setMapListPath(db_path + "map_list.lua");
    m.setMapCachePath(sZone->config().get_mapcache_path().string());
 
    if (m.ReadMapListConfig() != MCACHE_CONFIG_OK) {
        HLog(error) <<"Could not read map config file '" << m.getMapListPath().string() << "'.";
        return false;
    }
 
    switch (m.ImportFromCacheFile())
    {
        default:
            break;
        case MCACHE_IMPORT_NONEXISTENT_FILE:
            HLog(error) << "Could not open file '" << m.getMapCachePath().string() << "'.";
            return false;
        case MCACHE_IMPORT_READ_ERROR:
            HLog(error) << "Could not read file '" << m.getMapCachePath().string() << "', rebuilding...";
            return false;
        case MCACHE_IMPORT_INVALID_CHECKSUM:
            HLog(error) << "File cache file '" << m.getMapCachePath().string() << "' is corrupted (invalid checksum), rebuilding...";
            return false;
        case MCACHE_IMPORT_DECOMPRESS_ERROR:
            HLog(error) << "File cache file '" << m.getMapCachePath().string() << "' could not be decompressed, rebuilding...";
            return false;
        case MCACHE_IMPORT_MAPINFO_ERROR:
            HLog(error) << "Could not read map information for a map while importing file '" << m.getMapCachePath().string() << "', rebuilding...";
            return false;
        case MCACHE_IMPORT_CELLINFO_ERROR:
            HLog(error) << "Could not read cell information for a map while importing file '" << m.getMapCachePath().string() << "', rebuilding...";
            return false;
    }
 
    _maps = m.getMCache()->maps;
    
    return true;
}

References _maps, Horizon::Libraries::MapCache::getMapCachePath(), Horizon::Libraries::MapCache::getMapListPath(), Horizon::Libraries::MapCache::getMCache(), HLog, Horizon::Libraries::MapCache::ImportFromCacheFile(), MCACHE_CONFIG_OK, MCACHE_IMPORT_CELLINFO_ERROR, MCACHE_IMPORT_DECOMPRESS_ERROR, MCACHE_IMPORT_INVALID_CHECKSUM, MCACHE_IMPORT_MAPINFO_ERROR, MCACHE_IMPORT_NONEXISTENT_FILE, MCACHE_IMPORT_READ_ERROR, Horizon::Libraries::MapCache::ReadMapListConfig(), Horizon::Libraries::MapCache::setMapCachePath(), Horizon::Libraries::MapCache::setMapListPath(), and sZone.

Referenced by initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

on_map_update()

void Horizon::Zone::GameLogicProcess::on_map_update

(

int64_t

diff

)

start_internal()

void GameLogicProcess::start_internal

(

)

{
    int total_maps = 0;
    int mcache_size = _maps.size();
    int max_maps_per_thread = std::ceil((double) mcache_size / sZone->config().max_game_logic_threads());
    int container_max = get_segment_number() * max_maps_per_thread;
    int container_min = (get_segment_number() - 1) * max_maps_per_thread;
 
    auto map_i = _maps.begin();
    std::advance(map_i, container_min);
    for (int i = container_min; i < container_max; i++)
    {
        if (map_i == _maps.end())
            break;
            
        std::shared_ptr<Map> map = std::make_shared<Map>(std::static_pointer_cast<GameLogicProcess>(shared_from_this()), map_i->second.name(), map_i->second.width(), map_i->second.height(), map_i->second.getCells());
        
        this->get_resource_manager().add<RESOURCE_PRIORITY_PRIMARY>(map_i->second.name(), map);
 
        total_maps++;
        map_i++;
    }
    
    HLog(info) << "Started map container " << get_segment_number() << " (" << container_min + 1 << " to " << container_max << " maps) for a total of " << container_max - container_min << " out of "  << mcache_size << " maps.";
 
    _maps.clear();
 
    _thread = std::thread([this]() {
        while (!sZone->general_conf().is_test_run_minimal() && get_shutdown_stage() == SHUTDOWN_NOT_STARTED) {
            this->update(std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::high_resolution_clock::now().time_since_epoch()).count());
            std::this_thread::sleep_for(std::chrono::microseconds(MAX_CORE_UPDATE_INTERVAL));
        };
    });
}

References _maps, _thread, SharedPriorityResourceManager< SharedPriorityResourceMediums >::add(), GridTypeListIterator::count(), get_resource_manager(), KernelComponent::get_segment_number(), get_shutdown_stage(), HLog, MAX_CORE_UPDATE_INTERVAL, RESOURCE_PRIORITY_PRIMARY, SHUTDOWN_NOT_STARTED, sZone, and update().

Referenced by initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

update()

void GameLogicProcess::update

(

uint64_t

diff

)

{
    std::chrono::high_resolution_clock::time_point start = std::chrono::high_resolution_clock::now();
    // Update the entities.
    for (auto unit_it : this->get_resource_manager().get_medium<RESOURCE_PRIORITY_TERTIARY>().get_map())
        unit_it.second->update(diff);
 
    getScheduler().Update();
 
    get_system_routine_manager().process_queue();
    
#if WIN32
    DWORD cpu = GetCurrentProcessorNumber();
    if (get_thread_cpu_id() != (int) cpu) 
        set_thread_cpu_id(cpu);
#elif __linux__
    int cpu = sched_getcpu();
    if (get_thread_cpu_id() != cpu)
        set_thread_cpu_id(cpu);
#endif
    calculate_and_set_cpu_load();
    std::chrono::high_resolution_clock::time_point end = std::chrono::high_resolution_clock::now();
    std::chrono::nanoseconds time_span = std::chrono::duration_cast<std::chrono::nanoseconds>(end - start);
    set_total_execution_time(time_span.count());
}

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

Referenced by start_internal().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

_config

struct s_game_process_configuration Horizon::Zone::GameLogicProcess::_config

private

Referenced by game_config().

_is_finalized

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

protected

Referenced by finalize(), and is_finalized().

_is_initialized

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

protected

Referenced by initialize(), and is_initialized().

_maps

std::map<std::string, map_data> Horizon::Zone::GameLogicProcess::_maps

private

Referenced by load_map_cache(), and start_internal().

_monster_spawn_agent

MonsterSpawnAgent Horizon::Zone::GameLogicProcess::_monster_spawn_agent

private

Referenced by get_monster_spawn_agent().

_resource_manager

ResourceManager Horizon::Zone::GameLogicProcess::_resource_manager

protected

Referenced by get_resource_manager().

_scheduler

TaskScheduler Horizon::Zone::GameLogicProcess::_scheduler

private

Referenced by getScheduler().

_thread

std::thread Horizon::Zone::GameLogicProcess::_thread

private

Referenced by finalize(), and start_internal().

---

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

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