Horizon::Zone::MonsterDatabase Class Reference

#include <MonsterDB.hpp>

Collaboration diagram for Horizon::Zone::MonsterDatabase:

Public Member Functions
	MonsterDatabase ()
	~MonsterDatabase ()
bool	load ()
std::shared_ptr< const monster_config_data >	get_monster_by_id (uint32_t id)
std::shared_ptr< const monster_config_data >	get_monster_by_name (std::string name)
std::shared_ptr< std::vector< std::shared_ptr< const monster_skill_config_data > > >	get_monster_skill_by_id (uint32_t monster_id)

Static Public Member Functions
static MonsterDatabase *	get_instance ()

Protected Member Functions
bool	load_internal (sol::object const &key, sol::object const &value)
bool	parse_level (sol::table const &table, monster_config_data &data)
bool	parse_hp (sol::table const &table, monster_config_data &data)
bool	parse_sp (sol::table const &table, monster_config_data &data)
bool	parse_reward_base_exp (sol::table const &table, monster_config_data &data)
bool	parse_reward_job_exp (sol::table const &table, monster_config_data &data)
bool	parse_attack_range (sol::table const &table, monster_config_data &data)
bool	parse_attack (sol::table const &table, monster_config_data &data)
bool	parse_defense (sol::table const &table, monster_config_data &data)
bool	parse_magic_defense (sol::table const &table, monster_config_data &data)
bool	parse_view_range (sol::table const &table, monster_config_data &data)
bool	parse_chase_range (sol::table const &table, monster_config_data &data)
bool	parse_size (sol::table const &table, monster_config_data &data)
bool	parse_race (sol::table const &table, monster_config_data &data)
bool	parse_element (sol::table const &table, monster_config_data &data)
bool	parse_mode (sol::table const &table, monster_config_data &data)
bool	parse_move_speed (sol::table const &table, monster_config_data &data)
bool	parse_attack_delay (sol::table const &table, monster_config_data &data)
bool	parse_attack_motion (sol::table const &table, monster_config_data &data)
bool	parse_damage_motion (sol::table const &table, monster_config_data &data)
bool	parse_mvp_exp (sol::table const &table, monster_config_data &data)
bool	parse_damage_taken_rate (sol::table const &table, monster_config_data &data)
bool	parse_stats (sol::table const &table, monster_config_data &data)
bool	parse_drops (sol::table const &table, monster_config_data &data, bool mvp)
bool	parse_view (sol::table const &table, monster_config_data &data)
bool	load_skill_internal (sol::object const &key, sol::object const &value)

Private Attributes
LockedLookupTable< uint32_t, std::shared_ptr< const monster_config_data > >	_monster_db
LockedLookupTable< std::string, std::shared_ptr< const monster_config_data > >	_monster_str_db
LockedLookupTable< uint32_t, std::shared_ptr< std::vector< std::shared_ptr< const monster_skill_config_data > > > >	_monster_skill_db

Constructor & Destructor Documentation

MonsterDatabase()

MonsterDatabase::MonsterDatabase

(

)

{
    //
}

~MonsterDatabase()

MonsterDatabase::~MonsterDatabase

(

)

{
    //
}

Member Function Documentation

get_instance()

static MonsterDatabase * Horizon::Zone::MonsterDatabase::get_instance ( )

inlinestatic

    {
        static MonsterDatabase instance;
        return &instance;
    }

get_monster_by_id()

std::shared_ptr< const monster_config_data > Horizon::Zone::MonsterDatabase::get_monster_by_id ( uint32_t  id )

inline

{ return _monster_db.at(id, nullptr); }

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

Here is the call graph for this function:

get_monster_by_name()

std::shared_ptr< const monster_config_data > Horizon::Zone::MonsterDatabase::get_monster_by_name ( std::string  name )

inline

{ return _monster_str_db.at(name); }

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

Here is the call graph for this function:

get_monster_skill_by_id()

std::shared_ptr< std::vector< std::shared_ptr< const monster_skill_config_data > > > Horizon::Zone::MonsterDatabase::get_monster_skill_by_id ( uint32_t  monster_id )

inline

{ return _monster_skill_db.at(monster_id); }

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

Here is the call graph for this function:

load()

bool MonsterDatabase::load

(

)

{
    std::shared_ptr<sol::state> lua = std::make_shared<sol::state>();
 
    lua->open_libraries(sol::lib::base);
    lua->open_libraries(sol::lib::package);
 
    std::shared_ptr<UnitComponent> unit_component = std::make_shared<UnitComponent>();
    std::shared_ptr<MonsterComponent> monster_component = std::make_shared<MonsterComponent>();
    std::shared_ptr<ItemComponent> item_component = std::make_shared<ItemComponent>();
 
    unit_component->sync_definitions(lua);
    unit_component->sync_data_types(lua);
    unit_component->sync_functions(lua);
 
    monster_component->sync_definitions(lua);
    monster_component->sync_data_types(lua);
 
    item_component->sync_definitions(lua);
    item_component->sync_data_types(lua);
    item_component->sync_functions(lua);
 
    try {
        int total_entries = 0;
        std::string file_path = sZone->config().get_static_db_path().string() + "monster_db.lua";
        sol::load_result fx = lua->load_file(file_path);
        sol::table mob_tbl = fx();
        mob_tbl.for_each([this, &total_entries] (sol::object const &key, sol::object const &value) {
            total_entries += load_internal(key, value);
        });
        HLog(info) << "Loaded " << total_entries << " entries from '" << file_path << "'.";
    } catch(const std::exception &e) {
        HLog(error) << "MonsterDatabase::load: " << e.what();
        return false;
    }
 
    try {
        int total_entries = 0;
        std::string file_path = sZone->config().get_static_db_path().string() + "monster_skill_db.lua";
        lua->script_file(file_path);
        sol::load_result fx = lua->load_file(file_path);
        sol::table mob_tbl = fx();
        mob_tbl.for_each([this, &total_entries] (sol::object const &key, sol::object const &value) {
            total_entries += load_skill_internal(key, value);
        });
        HLog(info) << "Loaded " << total_entries << " entries from '" << file_path << "'.";
    } catch(const std::exception &e) {
        HLog(error) << "MonsterDatabase::load: " << e.what();
        return false;
    }
 
    return true;
}

References HLog, load_internal(), load_skill_internal(), and sZone.

Here is the call graph for this function:

load_internal()

bool MonsterDatabase::load_internal ( sol::object const &  key, sol::object const &  value  )

protected

{
    monster_config_data data;
 
//  -- ================ Mandatory fields ==============================
    std::string sprite_name = key.as<std::string>();
    std::strncpy(data.sprite_name, sprite_name.c_str(), MAX_UNIT_NAME_LENGTH);
 
    if (value.get_type() != sol::type::table) {
        HLog(error) << "Value for '" << data.sprite_name << "' is not a table... skipping.";
        return false;
    }
 
    sol::table m_tbl = value.as<sol::table>();
    
    data.monster_id = m_tbl.get_or<uint16_t>("Id", 0);
 
    if (data.monster_id <= 0 || data.monster_id > MAX_MOB_DB) {
        HLog(warning) << "Monster ID for '" << data.name << "' is out of range... skipping.";
        return false;
    }
 
    std::string name = m_tbl.get_or<std::string>("Name", "");
    std::strncpy(data.name, name.c_str(), MAX_UNIT_NAME_LENGTH);
 
    if (name.size() == 0) {
        HLog(warning) << "Monster Name for '" << data.monster_id << "' is a mandatory field... skipping.";
        return false;
    }
 
//  -- ================ Optional fields ==============================
    std::string alt_name = m_tbl.get_or<std::string>("JName", "");
    std::strncpy(data.alt_name, alt_name.c_str(), MAX_UNIT_NAME_LENGTH);
 
    if (parse_level(m_tbl, data) == false)
        return false;
 
    if (parse_hp(m_tbl, data) == false)
        return false;
 
    if (parse_sp(m_tbl, data) == false)
        return false;
 
    if (parse_reward_base_exp(m_tbl, data) == false)
        return false;
 
    if (parse_reward_job_exp(m_tbl, data) == false)
        return false;
 
    if (parse_attack_range(m_tbl, data) == false)
        return false;
 
    if (parse_attack(m_tbl, data) == false)
        return false;
 
    if (parse_defense(m_tbl, data) == false)
        return false;
 
    if (parse_magic_defense(m_tbl, data) == false)
        return false;
 
    if (parse_view_range(m_tbl, data) == false)
        return false;
 
    if (parse_chase_range(m_tbl, data) == false)
        return false;
 
    if (parse_size(m_tbl, data) == false)
        return false;
 
    if (parse_race(m_tbl, data) == false)
        return false;
 
    if (parse_element(m_tbl, data) == false)
        return false;
 
    if (parse_mode(m_tbl, data) == false)
        return false;
 
    if (parse_move_speed(m_tbl, data) == false)
        return false;
 
    if (parse_attack_delay(m_tbl, data) == false)
        return false;
 
    if (parse_attack_motion(m_tbl, data) == false)
        return false;
 
    if (parse_damage_motion(m_tbl, data) == false)
        return false;
 
    if (parse_mvp_exp(m_tbl, data) == false)
        return false;
 
    if (parse_damage_taken_rate(m_tbl, data) == false)
        return false;
 
    if (parse_stats(m_tbl, data) == false)
        return false;
 
    if (parse_drops(m_tbl, data, false) == false)
        return false;
 
    if (parse_drops(m_tbl, data, true) == false)
        return false;
 
    if (parse_view(m_tbl, data) == false)
        return false;
 
    _monster_db.insert(data.monster_id, std::make_shared<monster_config_data>(data));
 
    _monster_str_db.insert(data.sprite_name, std::make_shared<monster_config_data>(data));
 
    return true;
}

References _monster_db, _monster_str_db, monster_config_data::alt_name, HLog, LockedLookupTable< Key, Value, Hash >::insert(), MAX_MOB_DB, MAX_UNIT_NAME_LENGTH, monster_config_data::monster_id, monster_config_data::name, parse_attack(), parse_attack_delay(), parse_attack_motion(), parse_attack_range(), parse_chase_range(), parse_damage_motion(), parse_damage_taken_rate(), parse_defense(), parse_drops(), parse_element(), parse_hp(), parse_level(), parse_magic_defense(), parse_mode(), parse_move_speed(), parse_mvp_exp(), parse_race(), parse_reward_base_exp(), parse_reward_job_exp(), parse_size(), parse_sp(), parse_stats(), parse_view(), parse_view_range(), and monster_config_data::sprite_name.

Referenced by load().

Here is the call graph for this function:

Here is the caller graph for this function:

load_skill_internal()

bool MonsterDatabase::load_skill_internal ( sol::object const &  key, sol::object const &  value  )

protected

{
    try {
        std::vector<std::shared_ptr<const monster_skill_config_data>> skills;
        std::shared_ptr<const monster_config_data> monster = nullptr;
        if (key.is<std::string>()) {
            std::string mob_name = key.as<std::string>();
            if ((monster = MonsterDB->get_monster_by_name(mob_name)) == nullptr) {
                HLog(error) << "Error parsing skills for non-existent monster '" << mob_name << "'.";
                return false;
            }
        } else if (key.is<int>()) {
            int mob_id = key.as<int>();
            if ((monster = MonsterDB->get_monster_by_id(mob_id)) == nullptr) {
                HLog(error) << "Error parsing skills for non-existent monster with ID " << mob_id << ".";
                return false;
            }
        }
 
        if (value.get_type() != sol::type::table) {
                HLog(error) << "MonsterDatabase::load_skill_internal: Error parsing value of unexpected type, value should be a table.";
                return false;
        }
 
        sol::table skill_tbl = value.as<sol::table>();
 
        for (auto const &s : skill_tbl) {
            sol::object const &k = s.first;
            sol::object const &v = s.second;
            monster_skill_config_data mskd;
 
            std::shared_ptr<const skill_config_data> skill = nullptr;
            if (k.is<std::string>()) {
                std::string skill_name = k.as<std::string>();
 
                if ((skill = SkillDB->get_skill_by_name(skill_name)) == nullptr) {
                    HLog(error) << "Error loading non-existent skill '" << skill_name << "' for monster '" << monster->sprite_name << "'.";
                    continue;
                }
            } else if (k.is<int>()) {
                int skill_id = k.as<int>();
 
                if ((skill = SkillDB->get_skill_by_id(skill_id)) == nullptr) {
                    HLog(error) << "Error loading non-existent skill with Id " << skill_id << " for monster '" << monster->sprite_name << "'.";
                    continue;
                }
            }
 
            mskd.skill_id = skill->skill_id;
 
            if (v.get_type() != sol::type::table) {
                HLog(error) << "MonsterDatabase::load_skill_internal: Error loading value for skill '" << skill->name << "' of monster '" << monster->sprite_name << "'.";
                continue;
            }
 
            sol::table stbl = v.as<sol::table>();
 
            sol::optional<int> maybe_val = stbl.get<sol::optional<int>>("SkillLevel");
            if (maybe_val)
                mskd.skill_level = maybe_val.value();
            else
                mskd.skill_level = 1;
 
            maybe_val = stbl.get<sol::optional<int>>("SkillTarget");
            if (maybe_val)
                mskd.target = (monster_skill_target_type) maybe_val.value();
            else
                mskd.target = MONSTER_SKILL_TARGET_CURRENT;
 
            maybe_val = stbl.get<sol::optional<int>>("SkillState");
            if (maybe_val)
                mskd.state = (monster_skill_state_type) maybe_val.value();
            else
                mskd.state = MONSTER_SKILL_STATE_ANY;
 
            maybe_val = stbl.get<sol::optional<int>>("Rate");
            if (maybe_val)
                mskd.skill_invoke_rate = maybe_val.value();
            else
                mskd.skill_invoke_rate = 500;
 
            maybe_val = stbl.get<sol::optional<int>>("CastTime");
            if (maybe_val)
                mskd.cast_time = maybe_val.value();
            else
                mskd.cast_time = 0;
 
            maybe_val = stbl.get<sol::optional<int>>("Delay");
            if (maybe_val)
                mskd.delay = maybe_val.value();
            else
                mskd.delay = 0;
 
            sol::optional<bool> maybe_bool = stbl.get<sol::optional<bool>>("Cancellable");
            if (maybe_bool)
                mskd.cancelable = maybe_bool.value();
 
            maybe_val = stbl.get<sol::optional<int>>("CastCondition");
            if (maybe_val)
                mskd.cast_condition = maybe_val.value();
            else
                mskd.cast_condition = 0;
 
            maybe_val = stbl.get<sol::optional<int>>("ConditionData");
            if (maybe_val)
                mskd.condition_data = maybe_val.value();
            else
                mskd.condition_data = 0;
 
            maybe_val = stbl.get<sol::optional<int>>("val0");
            if (maybe_val)
                mskd.val[0] = maybe_val.value();
            else
                mskd.val[0] = 0;
 
            maybe_val = stbl.get<sol::optional<int>>("val1");
            if (maybe_val)
                mskd.val[1] = maybe_val.value();
            else
                mskd.val[1] = 0;
 
            maybe_val = stbl.get<sol::optional<int>>("val2");
            if (maybe_val)
                mskd.val[2] = maybe_val.value();
            else
                mskd.val[2] = 0;
 
            maybe_val = stbl.get<sol::optional<int>>("val3");
            if (maybe_val)
                mskd.val[3] = maybe_val.value();
            else
                mskd.val[3] = 0;
 
            maybe_val = stbl.get<sol::optional<int>>("val4");
            if (maybe_val)
                mskd.val[4] = maybe_val.value();
            else
                mskd.val[4] = 0;
 
            maybe_val = stbl.get<sol::optional<int>>("Emotion");
            if (maybe_val)
                mskd.emotion_id = maybe_val.value();
            else
                mskd.emotion_id = 0;
 
            maybe_val = stbl.get<sol::optional<int>>("ChatMsgID");
            if (maybe_val)
                mskd.msg_id = maybe_val.value();
            else
                mskd.msg_id = 0;
 
            skills.push_back(std::make_shared<const monster_skill_config_data>(mskd));
        }
 
        _monster_skill_db.insert(monster->monster_id, std::make_shared<std::vector<std::shared_ptr<const monster_skill_config_data>>>(skills));
        
    }   catch (sol::error &e) { 
        HLog(error) << "MonsterDatabase::load_skill_internal:" << e.what();
    }
 
    return true;
}

References _monster_skill_db, monster_skill_config_data::cancelable, monster_skill_config_data::cast_condition, monster_skill_config_data::cast_time, monster_skill_config_data::condition_data, monster_skill_config_data::delay, monster_skill_config_data::emotion_id, HLog, LockedLookupTable< Key, Value, Hash >::insert(), MONSTER_SKILL_STATE_ANY, MONSTER_SKILL_TARGET_CURRENT, MonsterDB, monster_skill_config_data::msg_id, monster_skill_config_data::skill_id, monster_skill_config_data::skill_invoke_rate, monster_skill_config_data::skill_level, SkillDB, and monster_skill_config_data::val.

Referenced by load().

Here is the call graph for this function:

Here is the caller graph for this function:

parse_attack()

bool MonsterDatabase::parse_attack ( sol::table const &  table, monster_config_data &  data  )

protected

{
    try {
        sol::optional<sol::table> maybe_val = table.get<sol::optional<sol::table>>("Attack");
        if (maybe_val) {
            sol::table r_tbl = maybe_val.value();
            if (r_tbl[1].get_type() != sol::type::number || r_tbl[2].get_type() != sol::type::number) {
                HLog(error) << "Attack for monster '" << data.sprite_name << "' is not a numeric type... skipping.";
                return false;
            }
            data.attack_damage[0] = r_tbl[1];
            data.attack_damage[1] = r_tbl[2];
        } else {
            data.attack_damage[0] = 0;
            data.attack_damage[1] = 0;
        }
    } catch (sol::error &error) {
        HLog(error) << "Error parsing Attack for monster '" << data.sprite_name << "' - " << error.what() << ".";
    }
 
    return true;
}

References monster_config_data::attack_damage, HLog, and monster_config_data::sprite_name.

Referenced by load_internal().

Here is the caller graph for this function:

parse_attack_delay()

bool MonsterDatabase::parse_attack_delay ( sol::table const &  table, monster_config_data &  data  )

protected

{
    try {
        sol::optional<int> maybe_val = table.get<sol::optional<int>>("AttackDelay");
        if (maybe_val)
            data.attack_delay = maybe_val.value();
        else
            data.attack_delay = 0;
    } catch (sol::error &error) {
        HLog(error) << "Error parsing AttackDelay for monster '" << data.sprite_name << "' - " << error.what() << ".";
    }
 
    return true;
}

References monster_config_data::attack_delay, HLog, and monster_config_data::sprite_name.

Referenced by load_internal().

Here is the caller graph for this function:

parse_attack_motion()

bool MonsterDatabase::parse_attack_motion ( sol::table const &  table, monster_config_data &  data  )

protected

{
    try {
        sol::optional<int> maybe_val = table.get<sol::optional<int>>("AttackMotion");
        if (maybe_val)
            data.attack_motion = maybe_val.value();
        else
            data.attack_motion = 0;
    } catch (sol::error &error) {
        HLog(error) << "Error parsing AttackMotion for monster '" << data.sprite_name << "' - " << error.what() << ".";
    }
 
    return true;
}

References monster_config_data::attack_motion, HLog, and monster_config_data::sprite_name.

Referenced by load_internal().

Here is the caller graph for this function:

parse_attack_range()

bool MonsterDatabase::parse_attack_range ( sol::table const &  table, monster_config_data &  data  )

protected

{
    try {
        sol::optional<int> maybe_val = table.get<sol::optional<int>>("AttackRange");
        if (maybe_val)
            data.attack_range = maybe_val.value();
        else
            data.attack_range = 1;
    } catch (sol::error &error) {
        HLog(error) << "Error parsing AttackRange for monster '" << data.sprite_name << "' - " << error.what() << ".";
    }
 
    return true;
}

References monster_config_data::attack_range, HLog, and monster_config_data::sprite_name.

Referenced by load_internal().

Here is the caller graph for this function:

parse_chase_range()

bool MonsterDatabase::parse_chase_range ( sol::table const &  table, monster_config_data &  data  )

protected

{
    try {
        sol::optional<int> maybe_val = table.get<sol::optional<int>>("ChaseRange");
        if (maybe_val)
            data.chase_range = maybe_val.value();
        else
            data.chase_range = 1;
    } catch (sol::error &error) {
        HLog(error) << "Error parsing ChaseRange for monster '" << data.sprite_name << "' - " << error.what() << ".";
    }
 
    return true;
}

References monster_config_data::chase_range, HLog, and monster_config_data::sprite_name.

Referenced by load_internal().

Here is the caller graph for this function:

parse_damage_motion()

bool MonsterDatabase::parse_damage_motion ( sol::table const &  table, monster_config_data &  data  )

protected

{
    try {
        sol::optional<int> maybe_val = table.get<sol::optional<int>>("DamageMotion");
        if (maybe_val)
            data.damage_motion = maybe_val.value();
        else
            data.damage_motion = 0;
    } catch (sol::error &error) {
        HLog(error) << "Error parsing DamageMotion for monster '" << data.sprite_name << "' - " << error.what() << ".";
    }
 
    return true;
}

References monster_config_data::damage_motion, HLog, and monster_config_data::sprite_name.

Referenced by load_internal().

Here is the caller graph for this function:

parse_damage_taken_rate()

bool MonsterDatabase::parse_damage_taken_rate ( sol::table const &  table, monster_config_data &  data  )

protected

{
    try {
        sol::optional<int> maybe_val = table.get<sol::optional<int>>("DamageTakenRate");
        if (maybe_val)
            data.damage_taken_rate = maybe_val.value();
        else
            data.damage_taken_rate = 100;
    } catch (sol::error &error) {
        HLog(error) << "Error parsing DamageTakenRate for monster '" << data.sprite_name << "' - " << error.what() << ".";
    }
 
    return true;
}

References monster_config_data::damage_taken_rate, HLog, and monster_config_data::sprite_name.

Referenced by load_internal().

Here is the caller graph for this function:

parse_defense()

bool MonsterDatabase::parse_defense ( sol::table const &  table, monster_config_data &  data  )

protected

{
    try {
        sol::optional<int> maybe_val = table.get<sol::optional<int>>("Def");
        if (maybe_val)
            data.defense = maybe_val.value();
        else
            data.defense = 0;
    } catch (sol::error &error) {
        HLog(error) << "Error parsing Def for monster '" << data.sprite_name << "' - " << error.what() << ".";
    }
 
    return true;
}

References monster_config_data::defense, HLog, and monster_config_data::sprite_name.

Referenced by load_internal().

Here is the caller graph for this function:

parse_drops()

bool MonsterDatabase::parse_drops ( sol::table const &  table, monster_config_data &  data, bool  mvp  )

protected

{
    try {
        sol::optional<sol::table> maybe_tbl = table.get<sol::optional<sol::table>>(mvp ? "MvpDrops" : "Drops");
        if (maybe_tbl) {
            sol::table drop_tbl = maybe_tbl.value();
            int i = 0;
            std::vector<monster_config_data::rewards::drops> items;
            for (auto const &d : drop_tbl) {
                sol::object const &k = d.first;
                sol::object const &v = d.second;
                std::shared_ptr<const item_config_data> it = nullptr;
                monster_config_data::rewards::drops drop;
 
                if (k.is<std::string>()) {
                    std::string name = k.as<std::string>();
                    it = ItemDB->get_item_by_key_name(name);
                    if (it == nullptr) {
                        HLog(error) << "Error parsing MvpDrop for monster '" << data.sprite_name << "', item '" << name << "' doesn't exist.";
                        continue;
                    }
                } else if (k.is<int>()) {
                    int item_id = k.as<int>();
                    it = ItemDB->get_item_by_id(item_id);
                    if (it == nullptr) {
                        HLog(error) << "Error parsing MvpDrop for monster '" << data.sprite_name << "', item with ID '" << item_id << "' doesn't exist.";
                        continue;
                    }
                }
 
                if (v.get_type() != sol::type::number) {
                    HLog(error) << "Error parsing chance for item '" << it->key_name << "', non-numeric value provided.";
                    continue;
                }
 
                if ((mvp && i >= MAX_MVP_DROP) || (!mvp && i >= MAX_MOB_DROP)) {
                    HLog(warning) << "Number of "<< (mvp ? "mvp " : "") << "drops for monster '" << data.sprite_name << "', exceeds maximum limit... skipping.";
                    continue;
                }
 
                drop.item_id = it->item_id;
                drop.chance = v.as<int>();
 
                i++;
 
                items.push_back(drop);
            }
 
            i = 0;
            for (auto it : items) {
                if (mvp) {
                    data.rewards.items_mvp[i] = items[i];
                } else {
                    data.rewards.items[i] = items[i];
                }
                i++;
            }
        }
    } catch (sol::error &error) {
        HLog(error) << "Error parsing " << (mvp ? "MvpDrops" : "Drops") << " for monster '" << data.sprite_name << "' - " << error.what() << ".";
    }
 
    return true;
}

References monster_config_data::rewards::drops::chance, HLog, monster_config_data::rewards::drops::item_id, ItemDB, monster_config_data::rewards::items, monster_config_data::rewards::items_mvp, MAX_MOB_DROP, MAX_MVP_DROP, monster_config_data::rewards, and monster_config_data::sprite_name.

Referenced by load_internal().

Here is the caller graph for this function:

parse_element()

bool MonsterDatabase::parse_element ( sol::table const &  table, monster_config_data &  data  )

protected

{
    try {
        sol::optional<sol::table> maybe_tbl = table.get<sol::optional<sol::table>>("Element");
        if (maybe_tbl) {
            sol::table r_tbl = maybe_tbl.value();
            if (r_tbl[1].get_type() != sol::type::number || r_tbl[2].get_type() != sol::type::number) {
                HLog(error) << "Element for monster '" << data.sprite_name << "' is not a numeric type... skipping.";
                return false;
            }
            data.element = (element_type) r_tbl[1];
            data.element_level = r_tbl[2];
        } else {
            data.element = ELE_NEUTRAL;
            data.element_level = 1;
        }
    } catch (sol::error &error) {
        HLog(error) << "Error parsing Element for monster '" << data.sprite_name << "' - " << error.what() << ".";
    }
 
    return true;
}

References ELE_NEUTRAL, monster_config_data::element, monster_config_data::element_level, HLog, and monster_config_data::sprite_name.

Referenced by load_internal().

Here is the caller graph for this function:

parse_hp()

bool MonsterDatabase::parse_hp ( sol::table const &  table, monster_config_data &  data  )

protected

{
    try {
        sol::optional<int> maybe_val = table.get<sol::optional<int>>("Hp");
        if (maybe_val)
            data.hp = maybe_val.value();
        else
            data.hp = 1;
    } catch (sol::error &error) {
        HLog(error) << "Error parsing Hp for monster '" << data.sprite_name << "' - " << error.what() << ".";
    }
 
    return true;
}

References HLog, monster_config_data::hp, and monster_config_data::sprite_name.

Referenced by load_internal().

Here is the caller graph for this function:

parse_level()

bool MonsterDatabase::parse_level ( sol::table const &  table, monster_config_data &  data  )

protected

{
    try {
        sol::optional<int> maybe_val = table.get<sol::optional<int>>("Lv");
        if (maybe_val)
            data.level = maybe_val.value();
        else
            data.level = 1;
    } catch (sol::error &error) {
        HLog(error) << "Error parsing Lv for monster '" << data.sprite_name << "' - " << error.what() << ".";
    }
 
    return true;
}

References HLog, monster_config_data::level, and monster_config_data::sprite_name.

Referenced by load_internal().

Here is the caller graph for this function:

parse_magic_defense()

bool MonsterDatabase::parse_magic_defense ( sol::table const &  table, monster_config_data &  data  )

protected

{
    try {
        sol::optional<int> maybe_val = table.get<sol::optional<int>>("MDef");
        if (maybe_val)
            data.magic_defense = maybe_val.value();
        else
            data.magic_defense = 0;
    } catch (sol::error &error) {
        HLog(error) << "Error parsing MDef for monster '" << data.sprite_name << "' - " << error.what() << ".";
    }
 
    return true;
}

References HLog, monster_config_data::magic_defense, and monster_config_data::sprite_name.

Referenced by load_internal().

Here is the caller graph for this function:

parse_mode()

bool MonsterDatabase::parse_mode ( sol::table const &  table, monster_config_data &  data  )

protected

{
    try {
        sol::optional<sol::table> maybe_tbl = table.get<sol::optional<sol::table>>("Mode");
        if (maybe_tbl) {
            sol::table mode_tbl = maybe_tbl.value();
            for (auto const &m : mode_tbl) {
                sol::object const &v = m.second;
                data.mode |= v.as<int>();
            }
        } else {
            data.mode = 0;
        }
    } catch (sol::error &error) {
        HLog(error) << "Error parsing Mode for monster '" << data.sprite_name << "' - " << error.what() << ".";
    }
 
    return true;
}

References HLog, monster_config_data::mode, and monster_config_data::sprite_name.

Referenced by load_internal().

Here is the caller graph for this function:

parse_move_speed()

bool MonsterDatabase::parse_move_speed ( sol::table const &  table, monster_config_data &  data  )

protected

{
    try {
        sol::optional<int> maybe_val = table.get<sol::optional<int>>("MoveSpeed");
        if (maybe_val)
            data.move_speed = maybe_val.value();
        else
            data.move_speed = 0;
    } catch (sol::error &error) {
        HLog(error) << "Error parsing MoveSpeed for monster '" << data.sprite_name << "' - " << error.what() << ".";
    }
 
    return true;
}

References HLog, monster_config_data::move_speed, and monster_config_data::sprite_name.

Referenced by load_internal().

Here is the caller graph for this function:

parse_mvp_exp()

bool MonsterDatabase::parse_mvp_exp ( sol::table const &  table, monster_config_data &  data  )

protected

{
    try {
        sol::optional<int> maybe_val = table.get<sol::optional<int>>("MvpExp");
        if (maybe_val)
            data.rewards.mvp_exp = maybe_val.value();
        else
            data.rewards.mvp_exp = 0;
    } catch (sol::error &error) {
        HLog(error) << "Error parsing MvpExp for monster '" << data.sprite_name << "' - " << error.what() << ".";
    }
 
    return true;
}

References HLog, monster_config_data::rewards::mvp_exp, monster_config_data::rewards, and monster_config_data::sprite_name.

Referenced by load_internal().

Here is the caller graph for this function:

parse_race()

bool MonsterDatabase::parse_race ( sol::table const &  table, monster_config_data &  data  )

protected

{
    try {
        sol::optional<int> maybe_val = table.get<sol::optional<int>>("Race");
        if (maybe_val)
            data.primary_race = (monster_primary_race_type) maybe_val.value();
        else
            data.primary_race = MONSTER_RACE_FORMLESS;
    } catch (sol::error &error) {
        HLog(error) << "Error parsing Race for monster '" << data.sprite_name << "' - " << error.what() << ".";
    }
 
    return true;
}

References HLog, MONSTER_RACE_FORMLESS, monster_config_data::primary_race, and monster_config_data::sprite_name.

Referenced by load_internal().

Here is the caller graph for this function:

parse_reward_base_exp()

bool MonsterDatabase::parse_reward_base_exp ( sol::table const &  table, monster_config_data &  data  )

protected

{
    try {
        sol::optional<int> maybe_val = table.get<sol::optional<int>>("Exp");
        if (maybe_val)
            data.rewards.base_exp = maybe_val.value();
        else
            data.rewards.base_exp = 0;
    } catch (sol::error &error) {
        HLog(error) << "Error parsing Exp for monster '" << data.sprite_name << "' - " << error.what() << ".";
    }
 
    return true;
}

References monster_config_data::rewards::base_exp, HLog, monster_config_data::rewards, and monster_config_data::sprite_name.

Referenced by load_internal().

Here is the caller graph for this function:

parse_reward_job_exp()

bool MonsterDatabase::parse_reward_job_exp ( sol::table const &  table, monster_config_data &  data  )

protected

{
    try {
        sol::optional<int> maybe_val = table.get<sol::optional<int>>("JExp");
        if (maybe_val)
            data.rewards.job_exp = maybe_val.value();
        else
            data.rewards.job_exp = 1;
    } catch (sol::error &error) {
        HLog(error) << "Error parsing JExp for monster '" << data.sprite_name << "' - " << error.what() << ".";
    }
 
    return true;
}

References HLog, monster_config_data::rewards::job_exp, monster_config_data::rewards, and monster_config_data::sprite_name.

Referenced by load_internal().

Here is the caller graph for this function:

parse_size()

bool MonsterDatabase::parse_size ( sol::table const &  table, monster_config_data &  data  )

protected

{
    try {
        sol::optional<int> maybe_val = table.get<sol::optional<int>>("Size");
        if (maybe_val)
            data.size = (unit_size_type) maybe_val.value();
        else
            data.size = ESZ_SMALL;
    } catch (sol::error &error) {
        HLog(error) << "Error parsing Size for monster '" << data.sprite_name << "' - " << error.what() << ".";
    }
 
    return true;
}

References ESZ_SMALL, HLog, monster_config_data::size, and monster_config_data::sprite_name.

Referenced by load_internal().

Here is the caller graph for this function:

parse_sp()

bool MonsterDatabase::parse_sp ( sol::table const &  table, monster_config_data &  data  )

protected

{
    try {
        sol::optional<int> maybe_val = table.get<sol::optional<int>>("Sp");
        if (maybe_val)
            data.sp = maybe_val.value();
        else
            data.sp = 1;
    } catch (sol::error &error) {
        HLog(error) << "Error parsing Sp for monster '" << data.sprite_name << "' - " << error.what() << ".";
    }
    
    return true;
}

References HLog, monster_config_data::sp, and monster_config_data::sprite_name.

Referenced by load_internal().

Here is the caller graph for this function:

parse_stats()

bool MonsterDatabase::parse_stats ( sol::table const &  table, monster_config_data &  data  )

protected

{
    try {
        sol::optional<sol::table> maybe_tbl = table.get<sol::optional<sol::table>>("Stats");
        if (maybe_tbl) {
            sol::table s_tbl = maybe_tbl.value();
 
            sol::optional<int> maybe_val = s_tbl.get<sol::optional<int>>("Str");
            if (maybe_val)
                data.stats.str = maybe_val.value();
            else
                data.stats.str = 1;
 
            maybe_val = s_tbl.get<sol::optional<int>>("Agi");
            if (maybe_val)
                data.stats.agi = maybe_val.value();
            else
                data.stats.agi = 1;
 
            maybe_val = s_tbl.get<sol::optional<int>>("Vit");
            if (maybe_val)
                data.stats.vit = maybe_val.value();
            else
                data.stats.vit = 1;
 
            maybe_val = s_tbl.get<sol::optional<int>>("Int");
            if (maybe_val)
                data.stats.int_ = maybe_val.value();
            else
                data.stats.int_ = 1;
 
            maybe_val = s_tbl.get<sol::optional<int>>("Dex");
            if (maybe_val)
                data.stats.dex = maybe_val.value();
            else
                data.stats.dex = 1;
 
            maybe_val = s_tbl.get<sol::optional<int>>("Luk");
            if (maybe_val)
                data.stats.luk = maybe_val.value();
            else
                data.stats.luk = 1;
        } else {
            data.stats.str = 1;
            data.stats.agi = 1;
            data.stats.vit = 1;
            data.stats.int_ = 1;
            data.stats.dex = 1;
            data.stats.luk = 1;
        }
    } catch (sol::error &error) {
        HLog(error) << "Error parsing Stats for monster '" << data.sprite_name << "' - " << error.what() << ".";
    }
 
    return true;
}

References monster_config_data::agi, monster_config_data::dex, HLog, monster_config_data::int_, monster_config_data::luk, monster_config_data::sprite_name, monster_config_data::stats, monster_config_data::str, and monster_config_data::vit.

Referenced by load_internal().

Here is the caller graph for this function:

parse_view()

bool MonsterDatabase::parse_view ( sol::table const &  table, monster_config_data &  data  )

protected

{
    try {
        sol::optional<sol::table> maybe_tbl = table.get<sol::optional<sol::table>>("ViewData");
        if (maybe_tbl) {
            sol::table s_tbl = maybe_tbl.value();
 
            sol::optional<int> maybe_val = s_tbl.get<sol::optional<int>>("SpriteId");
            if (maybe_val)
                data.view.sprite_id = maybe_val.value();
            else
                data.view.sprite_id = 0;
 
            maybe_val = s_tbl.get<sol::optional<int>>("WeaponId");
            if (maybe_val)
                data.view.weapon_id = maybe_val.value();
            else
                data.view.weapon_id = 0;
 
            maybe_val = s_tbl.get<sol::optional<int>>("ShieldId");
            if (maybe_val)
                data.view.shield_id = maybe_val.value();
            else
                data.view.shield_id = 0;
 
            maybe_val = s_tbl.get<sol::optional<int>>("RobeId");
            if (maybe_val)
                data.view.robe_id = maybe_val.value();
            else
                data.view.robe_id = 0;
 
            maybe_val = s_tbl.get<sol::optional<int>>("HeadTopId");
            if (maybe_val)
                data.view.headgear_top_id = maybe_val.value();
            else
                data.view.headgear_top_id = 0;
 
            maybe_val = s_tbl.get<sol::optional<int>>("HeadMidId");
            if (maybe_val)
                data.view.headgear_middle_id = maybe_val.value();
            else
                data.view.headgear_middle_id = 0;
 
            maybe_val = s_tbl.get<sol::optional<int>>("HeadLowId");
            if (maybe_val)
                data.view.headgear_bottom_id = maybe_val.value();
            else
                data.view.headgear_bottom_id = 0;
 
            maybe_val = s_tbl.get<sol::optional<int>>("HairStyleId");
            if (maybe_val)
                data.view.hair_style_id = maybe_val.value();
            else
                data.view.hair_style_id = 0;
 
            maybe_val = s_tbl.get<sol::optional<int>>("BodyStyleId");
            if (maybe_val)
                data.view.body_style_id = maybe_val.value();
            else
                data.view.body_style_id = 0;
 
            maybe_val = s_tbl.get<sol::optional<int>>("HairColorId");
            if (maybe_val)
                data.view.hair_color_id = maybe_val.value();
            else
                data.view.hair_color_id = 0;
 
            maybe_val = s_tbl.get<sol::optional<int>>("BodyColorId");
            if (maybe_val)
                data.view.body_color_id = maybe_val.value();
            else
                data.view.body_color_id = 0;
 
            maybe_val = s_tbl.get<sol::optional<int>>("Gender");
            if (maybe_val)
                data.view.gender = (unit_gender_types) maybe_val.value();
            else
                data.view.gender = UNIT_GENDER_FEMALE;
        } else {
            data.view.sprite_id = 0;
            data.view.weapon_id = 0;
            data.view.shield_id = 0;
            data.view.robe_id = 0;
            data.view.headgear_top_id = 0;
            data.view.headgear_middle_id = 0;
            data.view.headgear_bottom_id = 0;
            data.view.hair_style_id = 0;
            data.view.body_style_id = 0;
            data.view.hair_color_id = 0;
            data.view.body_color_id = 0;
            data.view.gender = UNIT_GENDER_FEMALE;
        }
    } catch (sol::error &error) {
        HLog(error) << "Error parsing Stats for monster '" << data.sprite_name << "' - " << error.what() << ".";
    }
 
    return true;
}

References monster_config_data::monster_view_data::body_color_id, monster_config_data::monster_view_data::body_style_id, monster_config_data::monster_view_data::gender, monster_config_data::monster_view_data::hair_color_id, monster_config_data::monster_view_data::hair_style_id, monster_config_data::monster_view_data::headgear_bottom_id, monster_config_data::monster_view_data::headgear_middle_id, monster_config_data::monster_view_data::headgear_top_id, HLog, monster_config_data::monster_view_data::robe_id, monster_config_data::monster_view_data::shield_id, monster_config_data::monster_view_data::sprite_id, monster_config_data::sprite_name, UNIT_GENDER_FEMALE, monster_config_data::view, and monster_config_data::monster_view_data::weapon_id.

Referenced by load_internal().

Here is the caller graph for this function:

parse_view_range()

bool MonsterDatabase::parse_view_range ( sol::table const &  table, monster_config_data &  data  )

protected

{
    try {
        sol::optional<int> maybe_val = table.get<sol::optional<int>>("ViewRange");
        if (maybe_val)
            data.view_range = maybe_val.value();
        else
            data.view_range = 1;
    } catch (sol::error &error) {
        HLog(error) << "Error parsing ViewRange for monster '" << data.sprite_name << "' - " << error.what() << ".";
    }
 
    return true;
}

References HLog, monster_config_data::sprite_name, and monster_config_data::view_range.

Referenced by load_internal().

Here is the caller graph for this function:

Member Data Documentation

_monster_db

LockedLookupTable<uint32_t, std::shared_ptr<const monster_config_data> > Horizon::Zone::MonsterDatabase::_monster_db

private

Referenced by get_monster_by_id(), and load_internal().

_monster_skill_db

LockedLookupTable<uint32_t, std::shared_ptr<std::vector<std::shared_ptr<const monster_skill_config_data> > > > Horizon::Zone::MonsterDatabase::_monster_skill_db

private

Referenced by get_monster_skill_by_id(), and load_skill_internal().

_monster_str_db

LockedLookupTable<std::string, std::shared_ptr<const monster_config_data> > Horizon::Zone::MonsterDatabase::_monster_str_db

private

Referenced by get_monster_by_name(), and load_internal().

---

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

• src/Server/Zone/Game/StaticDB/MonsterDB.hpp
• src/Server/Zone/Game/StaticDB/MonsterDB.cpp