diff --git a/common/net/daybreak_connection.cpp b/common/net/daybreak_connection.cpp index 68fc24ad2..b203c0155 100644 --- a/common/net/daybreak_connection.cpp +++ b/common/net/daybreak_connection.cpp @@ -277,7 +277,7 @@ EQ::Net::DaybreakConnection::DaybreakConnection(DaybreakConnectionManager *owner m_encode_passes[1] = owner->m_options.encode_passes[1]; m_hold_time = Clock::now(); m_buffered_packets_length = 0; - m_rolling_ping = 500; + m_rolling_ping = 900; m_resend_delay = (m_rolling_ping * m_owner->m_options.resend_delay_factor) + m_owner->m_options.resend_delay_ms; m_combined.reset(new char[512]); m_combined[0] = 0; @@ -300,7 +300,7 @@ EQ::Net::DaybreakConnection::DaybreakConnection(DaybreakConnectionManager *owner m_crc_bytes = 0; m_hold_time = Clock::now(); m_buffered_packets_length = 0; - m_rolling_ping = 500; + m_rolling_ping = 900; m_resend_delay = (m_rolling_ping * m_owner->m_options.resend_delay_factor) + m_owner->m_options.resend_delay_ms; m_combined.reset(new char[512]); m_combined[0] = 0; @@ -1026,7 +1026,7 @@ void EQ::Net::DaybreakConnection::ProcessResend(int stream) InternalBufferedSend(entry.second.packet); entry.second.last_sent = now; entry.second.times_resent++; - m_rolling_ping += 100; + m_rolling_ping += 300; } } else { @@ -1040,7 +1040,7 @@ void EQ::Net::DaybreakConnection::ProcessResend(int stream) InternalBufferedSend(entry.second.packet); entry.second.last_sent = now; entry.second.times_resent++; - m_rolling_ping += 100; + m_rolling_ping += 300; } } } @@ -1061,7 +1061,7 @@ void EQ::Net::DaybreakConnection::Ack(int stream, uint16_t seq) m_stats.max_ping = std::max(m_stats.max_ping, round_time); m_stats.min_ping = std::min(m_stats.min_ping, round_time); m_stats.last_ping = round_time; - m_rolling_ping = (m_rolling_ping * 2 + round_time) / 3; + m_rolling_ping = (m_rolling_ping * 3 + round_time) / 4; iter = s->sent_packets.erase(iter); } diff --git a/common/net/daybreak_connection.h b/common/net/daybreak_connection.h index 409471589..ecbd1569c 100644 --- a/common/net/daybreak_connection.h +++ b/common/net/daybreak_connection.h @@ -205,10 +205,10 @@ namespace EQ DaybreakConnectionManagerOptions() { max_connection_count = 0; keepalive_delay_ms = 9000; - resend_delay_ms = 150; + resend_delay_ms = 300; resend_delay_factor = 1.5; - resend_delay_min = 150; - resend_delay_max = 1000; + resend_delay_min = 300; + resend_delay_max = 6000; connect_delay_ms = 500; stale_connection_ms = 90000; connect_stale_ms = 5000; @@ -282,4 +282,4 @@ namespace EQ friend class DaybreakConnection; }; } -} \ No newline at end of file +} diff --git a/zone/CMakeLists.txt b/zone/CMakeLists.txt index b267ae11b..afa58f50c 100644 --- a/zone/CMakeLists.txt +++ b/zone/CMakeLists.txt @@ -59,6 +59,7 @@ SET(zone_sources lua_raid.cpp lua_spawn.cpp lua_spell.cpp + lua_stat_bonuses.cpp embperl.cpp embxs.cpp entity.cpp @@ -182,6 +183,7 @@ SET(zone_headers lua_raid.h lua_spawn.h lua_spell.h + lua_stat_bonuses.h map.h masterentity.h maxskill.h diff --git a/zone/attack.cpp b/zone/attack.cpp index 0cdce489f..b0465553a 100644 --- a/zone/attack.cpp +++ b/zone/attack.cpp @@ -272,6 +272,16 @@ int Mob::GetTotalDefense() // and does other mitigation checks. 'this' is the mob being attacked. bool Mob::CheckHitChance(Mob* other, DamageHitInfo &hit) { +#ifdef LUA_EQEMU + bool lua_ret = false; + bool ignoreDefault = false; + lua_ret = LuaParser::Instance()->CheckHitChance(this, other, hit, ignoreDefault); + + if(ignoreDefault) { + return lua_ret; + } +#endif + Mob *attacker = other; Mob *defender = this; Log(Logs::Detail, Logs::Attack, "CheckHitChance(%s) attacked by %s", defender->GetName(), attacker->GetName()); @@ -302,6 +312,16 @@ bool Mob::CheckHitChance(Mob* other, DamageHitInfo &hit) bool Mob::AvoidDamage(Mob *other, DamageHitInfo &hit) { +#ifdef LUA_EQEMU + bool lua_ret = false; + bool ignoreDefault = false; + lua_ret = LuaParser::Instance()->AvoidDamage(this, other, hit, ignoreDefault); + + if (ignoreDefault) { + return lua_ret; + } +#endif + /* called when a mob is attacked, does the checks to see if it's a hit * and does other mitigation checks. 'this' is the mob being attacked. * @@ -872,6 +892,15 @@ double Mob::RollD20(int offense, int mitigation) void Mob::MeleeMitigation(Mob *attacker, DamageHitInfo &hit, ExtraAttackOptions *opts) { +#ifdef LUA_EQEMU + bool ignoreDefault = false; + LuaParser::Instance()->MeleeMitigation(this, attacker, hit, opts, ignoreDefault); + + if (ignoreDefault) { + return; + } +#endif + if (hit.damage_done < 0 || hit.base_damage == 0) return; @@ -1239,14 +1268,6 @@ void Mob::DoAttack(Mob *other, DamageHitInfo &hit, ExtraAttackOptions *opts) Log(Logs::Detail, Logs::Combat, "%s::DoAttack vs %s base %d min %d offense %d tohit %d skill %d", GetName(), other->GetName(), hit.base_damage, hit.min_damage, hit.offense, hit.tohit, hit.skill); -#ifdef LUA_EQEMU - try { - LuaParser::Instance()->DoAttack(this, other, hit, opts); - } catch(IgnoreDefaultException) { - return; - } -#endif - // check to see if we hit.. if (other->AvoidDamage(this, hit)) { int strike_through = itembonuses.StrikeThrough + spellbonuses.StrikeThrough + aabonuses.StrikeThrough; @@ -4537,6 +4558,15 @@ const DamageTable &Mob::GetDamageTable() const void Mob::ApplyDamageTable(DamageHitInfo &hit) { +#ifdef LUA_EQEMU + bool ignoreDefault = false; + LuaParser::Instance()->ApplyDamageTable(this, hit, ignoreDefault); + + if (ignoreDefault) { + return; + } +#endif + // someone may want to add this to custom servers, can remove this if that's the case if (!IsClient() #ifdef BOTS diff --git a/zone/lua_mob.cpp b/zone/lua_mob.cpp index 190db1f18..86c8f564c 100644 --- a/zone/lua_mob.cpp +++ b/zone/lua_mob.cpp @@ -10,6 +10,7 @@ #include "lua_mob.h" #include "lua_hate_list.h" #include "lua_client.h" +#include "lua_stat_bonuses.h" struct SpecialAbilities { }; @@ -1985,6 +1986,41 @@ int32 Lua_Mob::GetMeleeMitigation() { return self->GetMeleeMitigation(); } +int Lua_Mob::GetWeaponDamageBonus(Lua_Item weapon, bool offhand) { + Lua_Safe_Call_Int(); + return self->GetWeaponDamageBonus(weapon, offhand); +} + +Lua_StatBonuses Lua_Mob::GetItemBonuses() +{ + Lua_Safe_Call_Class(Lua_StatBonuses); + return self->GetItemBonusesPtr(); +} + +Lua_StatBonuses Lua_Mob::GetSpellBonuses() +{ + Lua_Safe_Call_Class(Lua_StatBonuses); + return self->GetSpellBonusesPtr(); +} + +Lua_StatBonuses Lua_Mob::GetAABonuses() +{ + Lua_Safe_Call_Class(Lua_StatBonuses); + return self->GetAABonusesPtr(); +} + +int16 Lua_Mob::GetMeleeDamageMod_SE(uint16 skill) +{ + Lua_Safe_Call_Int(); + return self->GetMeleeDamageMod_SE(skill); +} + +int16 Lua_Mob::GetMeleeMinDamageMod_SE(uint16 skill) +{ + Lua_Safe_Call_Int(); + return self->GetMeleeMinDamageMod_SE(skill); +} + luabind::scope lua_register_mob() { return luabind::class_("Mob") .def(luabind::constructor<>()) @@ -2330,7 +2366,13 @@ luabind::scope lua_register_mob() { .def("HasPet", (bool(Lua_Mob::*)(void))&Lua_Mob::HasPet) .def("IsSilenced", (bool(Lua_Mob::*)(void))&Lua_Mob::IsSilenced) .def("IsAmnesiad", (bool(Lua_Mob::*)(void))&Lua_Mob::IsAmnesiad) - .def("GetMeleeMitigation", (int32(Lua_Mob::*)(void))&Lua_Mob::GetMeleeMitigation); + .def("GetMeleeMitigation", (int32(Lua_Mob::*)(void))&Lua_Mob::GetMeleeMitigation) + .def("GetWeaponDamageBonus", &Lua_Mob::GetWeaponDamageBonus) + .def("GetItemBonuses", &Lua_Mob::GetItemBonuses) + .def("GetSpellBonuses", &Lua_Mob::GetSpellBonuses) + .def("GetAABonuses", &Lua_Mob::GetAABonuses) + .def("GetMeleeDamageMod_SE", &Lua_Mob::GetMeleeDamageMod_SE) + .def("GetMeleeMinDamageMod_SE", &Lua_Mob::GetMeleeMinDamageMod_SE); } luabind::scope lua_register_special_abilities() { diff --git a/zone/lua_mob.h b/zone/lua_mob.h index 08502b1a9..f83583ac3 100644 --- a/zone/lua_mob.h +++ b/zone/lua_mob.h @@ -8,6 +8,7 @@ class Mob; struct Lua_HateList; class Lua_Item; class Lua_ItemInst; +class Lua_StatBonuses; namespace luabind { struct scope; @@ -381,6 +382,12 @@ public: bool IsSilenced(); bool IsAmnesiad(); int32 GetMeleeMitigation(); + int GetWeaponDamageBonus(Lua_Item weapon, bool offhand); + Lua_StatBonuses GetItemBonuses(); + Lua_StatBonuses GetSpellBonuses(); + Lua_StatBonuses GetAABonuses(); + int16 GetMeleeDamageMod_SE(uint16 skill); + int16 GetMeleeMinDamageMod_SE(uint16 skill); }; #endif diff --git a/zone/lua_parser.cpp b/zone/lua_parser.cpp index 201563ec9..12a02623e 100644 --- a/zone/lua_parser.cpp +++ b/zone/lua_parser.cpp @@ -11,7 +11,6 @@ #include #include "../common/spdat.h" -#include "../common/util/directory.h" #include "masterentity.h" #include "questmgr.h" #include "zone.h" @@ -38,6 +37,7 @@ #include "lua_packet.h" #include "lua_general.h" #include "lua_encounter.h" +#include "lua_stat_bonuses.h" const char *LuaEvents[_LargestEventID] = { "event_say", @@ -137,77 +137,6 @@ std::map> lua_encounter_events_regi std::map lua_encounters_loaded; std::map lua_encounters; -void LuaParser::DoAttack(Mob *self, Mob *other, DamageHitInfo &hit, ExtraAttackOptions *opts) -{ - int start = lua_gettop(L); - bool ignoreDefault = false; - - for (auto &mod : mods_) { - try { - lua_getfield(L, LUA_REGISTRYINDEX, mod.c_str()); - lua_getfield(L, -1, "DoAttack"); - - Lua_Mob l_self(self); - Lua_Mob l_other(other); - - luabind::adl::object e = luabind::newtable(L); - luabind::adl::object lua_hit = luabind::newtable(L); - lua_hit["base_damage"] = hit.base_damage; - lua_hit["damage_done"] = hit.damage_done; - lua_hit["offense"] = hit.offense; - lua_hit["tohit"] = hit.tohit; - lua_hit["hand"] = hit.hand; - lua_hit["skill"] = (int)hit.skill; - - e["self"] = luabind::adl::object(L, l_self); - e["other"] = luabind::adl::object(L, l_other); - e["hit"] = lua_hit; - if (opts) { - luabind::adl::object lua_opts = luabind::newtable(L); - lua_opts["damage_percent"] = opts->damage_percent; - lua_opts["damage_flat"] = opts->damage_flat; - lua_opts["armor_pen_percent"] = opts->armor_pen_percent; - lua_opts["armor_pen_flat"] = opts->armor_pen_flat; - lua_opts["crit_percent"] = opts->crit_percent; - lua_opts["crit_flat"] = opts->crit_flat; - lua_opts["hate_percent"] = opts->hate_percent; - lua_opts["hate_flat"] = opts->hate_flat; - lua_opts["hit_chance"] = opts->hit_chance; - lua_opts["melee_damage_bonus_flat"] = opts->melee_damage_bonus_flat; - lua_opts["skilldmgtaken_bonus_flat"] = opts->skilldmgtaken_bonus_flat; - e["opts"] = lua_opts; - } - else { - e["opts"] = luabind::nil; - } - - e.push(L); - - if (lua_pcall(L, 1, 1, 0)) { - std::string error = lua_tostring(L, -1); - AddError(error); - } - - - } - catch (std::exception &ex) { - std::string error = "Lua Exception: "; - error += std::string(ex.what()); - AddError(error); - } - - int end = lua_gettop(L); - int n = end - start; - if (n > 0) { - lua_pop(L, n); - } - } - - if (ignoreDefault) { - throw IgnoreDefaultException(); - } -} - LuaParser::LuaParser() { for(int i = 0; i < _LargestEventID; ++i) { NPCArgumentDispatch[i] = handle_npc_null; @@ -877,6 +806,7 @@ void LuaParser::ReloadQuests() { for (auto encounter : lua_encounters) { encounter.second->Depop(); } + lua_encounters.clear(); // so the Depop function above depends on the Process being called again so ... // And there is situations where it wouldn't be :P @@ -889,6 +819,8 @@ void LuaParser::ReloadQuests() { L = luaL_newstate(); luaL_openlibs(L); + auto top = lua_gettop(L); + if(luaopen_bit(L) != 1) { std::string error = lua_tostring(L, -1); AddError(error); @@ -1005,35 +937,41 @@ void LuaParser::ReloadQuests() { std::string error = lua_tostring(L, -1); AddError(error); } - - return; } + else { + zone_script = Config->QuestDir; + zone_script += "/"; + zone_script += zone->GetShortName(); + zone_script += "/script_init.lua"; + f = fopen(zone_script.c_str(), "r"); + if (f) { + fclose(f); - zone_script = Config->QuestDir; - zone_script += "/"; - zone_script += zone->GetShortName(); - zone_script += "/script_init.lua"; - f = fopen(zone_script.c_str(), "r"); - if(f) { - fclose(f); - - if(luaL_dofile(L, zone_script.c_str())) { - std::string error = lua_tostring(L, -1); - AddError(error); + if (luaL_dofile(L, zone_script.c_str())) { + std::string error = lua_tostring(L, -1); + AddError(error); + } } } } - EQ::Directory dir("mods"); - std::vector mods; - dir.GetFiles(mods); - - for (auto &mod : mods) { - if (mod.find_first_of(".lua") != std::string::npos) { - LoadScript("mods/" + mod, mod); - mods_.push_back(mod); + FILE *load_order = fopen("mods/load_order.txt", "r"); + if (load_order) { + char file_name[256] = { 0 }; + while (fgets(file_name, 256, load_order) != nullptr) { + LoadScript("mods/" + std::string(file_name), file_name); + mods_.push_back(file_name); } + + fclose(load_order); } + + auto end = lua_gettop(L); + int n = end - top; + if (n > 0) { + lua_pop(L, n); + } + } void LuaParser::LoadScript(std::string filename, std::string package_name) { @@ -1042,6 +980,7 @@ void LuaParser::LoadScript(std::string filename, std::string package_name) { return; } + auto top = lua_gettop(L); if(luaL_loadfile(L, filename.c_str())) { std::string error = lua_tostring(L, -1); AddError(error); @@ -1069,14 +1008,20 @@ void LuaParser::LoadScript(std::string filename, std::string package_name) { std::string error = lua_tostring(L, -1); AddError(error); lua_pop(L, 1); - return; + } + else { + loaded_[package_name] = true; } - loaded_[package_name] = true; + auto end = lua_gettop(L); + int n = end - top; + if (n > 0) { + lua_pop(L, n); + } } bool LuaParser::HasFunction(std::string subname, std::string package_name) { - std::transform(subname.begin(), subname.end(), subname.begin(), ::tolower); + //std::transform(subname.begin(), subname.end(), subname.begin(), ::tolower); auto iter = loaded_.find(package_name); if(iter == loaded_.end()) { @@ -1137,7 +1082,8 @@ void LuaParser::MapFunctions(lua_State *L) { lua_register_door(), lua_register_object(), lua_register_packet(), - lua_register_packet_opcodes() + lua_register_packet_opcodes(), + lua_register_stat_bonuses() ]; } catch(std::exception &ex) { @@ -1310,6 +1256,355 @@ int LuaParser::DispatchEventSpell(QuestEventID evt, NPC* npc, Client *client, ui return ret; } +void PutDamageHitInfo(lua_State *L, luabind::adl::object &e, DamageHitInfo &hit) { + luabind::adl::object lua_hit = luabind::newtable(L); + lua_hit["base_damage"] = hit.base_damage; + lua_hit["damage_done"] = hit.damage_done; + lua_hit["offense"] = hit.offense; + lua_hit["tohit"] = hit.tohit; + lua_hit["hand"] = hit.hand; + lua_hit["skill"] = (int)hit.skill; + e["hit"] = lua_hit; +} + +void GetDamageHitInfo(luabind::adl::object &ret, DamageHitInfo &hit) { + auto luaHitTable = ret["hit"]; + if (luabind::type(luaHitTable) == LUA_TTABLE) { + auto base_damage = luaHitTable["base_damage"]; + auto damage_done = luaHitTable["damage_done"]; + auto offense = luaHitTable["offense"]; + auto tohit = luaHitTable["tohit"]; + auto hand = luaHitTable["hand"]; + auto skill = luaHitTable["skill"]; + + if (luabind::type(base_damage) == LUA_TNUMBER) { + hit.base_damage = luabind::object_cast(base_damage); + } + + if (luabind::type(damage_done) == LUA_TNUMBER) { + hit.damage_done = luabind::object_cast(damage_done); + } + + if (luabind::type(offense) == LUA_TNUMBER) { + hit.offense = luabind::object_cast(offense); + } + + if (luabind::type(tohit) == LUA_TNUMBER) { + hit.tohit = luabind::object_cast(tohit); + } + + if (luabind::type(hand) == LUA_TNUMBER) { + hit.hand = luabind::object_cast(hand); + } + + if (luabind::type(skill) == LUA_TNUMBER) { + hit.skill = (EQEmu::skills::SkillType)luabind::object_cast(skill); + } + } +} + +void PutExtraAttackOptions(lua_State *L, luabind::adl::object &e, ExtraAttackOptions *opts) { + if (opts) { + luabind::adl::object lua_opts = luabind::newtable(L); + lua_opts["damage_percent"] = opts->damage_percent; + lua_opts["damage_flat"] = opts->damage_flat; + lua_opts["armor_pen_percent"] = opts->armor_pen_percent; + lua_opts["armor_pen_flat"] = opts->armor_pen_flat; + lua_opts["crit_percent"] = opts->crit_percent; + lua_opts["crit_flat"] = opts->crit_flat; + lua_opts["hate_percent"] = opts->hate_percent; + lua_opts["hate_flat"] = opts->hate_flat; + lua_opts["hit_chance"] = opts->hit_chance; + lua_opts["melee_damage_bonus_flat"] = opts->melee_damage_bonus_flat; + lua_opts["skilldmgtaken_bonus_flat"] = opts->skilldmgtaken_bonus_flat; + e["opts"] = lua_opts; + } +} + +void GetExtraAttackOptions(luabind::adl::object &ret, ExtraAttackOptions *opts) { + if (opts) { + auto luaOptsTable = ret["opts"]; + if (luabind::type(luaOptsTable) == LUA_TTABLE) { + auto damage_percent = luaOptsTable["damage_percent"]; + auto damage_flat = luaOptsTable["damage_flat"]; + auto armor_pen_percent = luaOptsTable["armor_pen_percent"]; + auto armor_pen_flat = luaOptsTable["armor_pen_flat"]; + auto crit_percent = luaOptsTable["crit_percent"]; + auto crit_flat = luaOptsTable["crit_flat"]; + auto hate_percent = luaOptsTable["hate_percent"]; + auto hate_flat = luaOptsTable["hate_flat"]; + auto hit_chance = luaOptsTable["hit_chance"]; + auto melee_damage_bonus_flat = luaOptsTable["melee_damage_bonus_flat"]; + auto skilldmgtaken_bonus_flat = luaOptsTable["skilldmgtaken_bonus_flat"]; + + if (luabind::type(damage_percent) == LUA_TNUMBER) { + opts->damage_percent = luabind::object_cast(damage_percent); + } + + if (luabind::type(damage_flat) == LUA_TNUMBER) { + opts->damage_flat = luabind::object_cast(damage_flat); + } + + if (luabind::type(armor_pen_percent) == LUA_TNUMBER) { + opts->armor_pen_percent = luabind::object_cast(armor_pen_percent); + } + + if (luabind::type(armor_pen_flat) == LUA_TNUMBER) { + opts->armor_pen_flat = luabind::object_cast(armor_pen_flat); + } + + if (luabind::type(crit_percent) == LUA_TNUMBER) { + opts->crit_percent = luabind::object_cast(crit_percent); + } + + if (luabind::type(crit_flat) == LUA_TNUMBER) { + opts->crit_flat = luabind::object_cast(crit_flat); + } + + if (luabind::type(hate_percent) == LUA_TNUMBER) { + opts->hate_percent = luabind::object_cast(hate_percent); + } + + if (luabind::type(hate_flat) == LUA_TNUMBER) { + opts->hate_flat = luabind::object_cast(hate_flat); + } + + if (luabind::type(hit_chance) == LUA_TNUMBER) { + opts->hit_chance = luabind::object_cast(hit_chance); + } + + if (luabind::type(melee_damage_bonus_flat) == LUA_TNUMBER) { + opts->melee_damage_bonus_flat = luabind::object_cast(melee_damage_bonus_flat); + } + + if (luabind::type(skilldmgtaken_bonus_flat) == LUA_TNUMBER) { + opts->skilldmgtaken_bonus_flat = luabind::object_cast(skilldmgtaken_bonus_flat); + } + } + } +} + +void LuaParser::MeleeMitigation(Mob *self, Mob *attacker, DamageHitInfo &hit, ExtraAttackOptions *opts, bool &ignoreDefault) { + int start = lua_gettop(L); + ignoreDefault = false; + + for (auto &mod : mods_) { + try { + if (!HasFunction("MeleeMitigation", mod)) { + continue; + } + + lua_getfield(L, LUA_REGISTRYINDEX, mod.c_str()); + lua_getfield(L, -1, "MeleeMitigation"); + + Lua_Mob l_self(self); + Lua_Mob l_other(attacker); + luabind::adl::object e = luabind::newtable(L); + e["self"] = l_self; + e["other"] = l_other; + + PutDamageHitInfo(L, e, hit); + PutExtraAttackOptions(L, e, opts); + + e.push(L); + + if (lua_pcall(L, 1, 1, 0)) { + std::string error = lua_tostring(L, -1); + AddError(error); + lua_pop(L, 1); + continue; + } + + if (lua_type(L, -1) == LUA_TTABLE) { + luabind::adl::object ret(luabind::from_stack(L, -1)); + auto IgnoreDefaultObj = ret["IgnoreDefault"]; + if (luabind::type(IgnoreDefaultObj) == LUA_TBOOLEAN) { + ignoreDefault = ignoreDefault || luabind::object_cast(IgnoreDefaultObj); + } + + GetDamageHitInfo(ret, hit); + GetExtraAttackOptions(ret, opts); + } + } + catch (std::exception &ex) { + AddError(ex.what()); + } + } + + int end = lua_gettop(L); + int n = end - start; + if (n > 0) { + lua_pop(L, n); + } +} + +void LuaParser::ApplyDamageTable(Mob *self, DamageHitInfo &hit, bool &ignoreDefault) { + int start = lua_gettop(L); + ignoreDefault = false; + + for (auto &mod : mods_) { + try { + if (!HasFunction("ApplyDamageTable", mod)) { + continue; + } + + lua_getfield(L, LUA_REGISTRYINDEX, mod.c_str()); + lua_getfield(L, -1, "ApplyDamageTable"); + + Lua_Mob l_self(self); + luabind::adl::object e = luabind::newtable(L); + e["self"] = l_self; + + PutDamageHitInfo(L, e, hit); + e.push(L); + + if (lua_pcall(L, 1, 1, 0)) { + std::string error = lua_tostring(L, -1); + AddError(error); + lua_pop(L, 1); + continue; + } + + if (lua_type(L, -1) == LUA_TTABLE) { + luabind::adl::object ret(luabind::from_stack(L, -1)); + auto IgnoreDefaultObj = ret["IgnoreDefault"]; + if (luabind::type(IgnoreDefaultObj) == LUA_TBOOLEAN) { + ignoreDefault = ignoreDefault || luabind::object_cast(IgnoreDefaultObj); + } + + GetDamageHitInfo(ret, hit); + } + } + catch (std::exception &ex) { + AddError(ex.what()); + } + } + + int end = lua_gettop(L); + int n = end - start; + if (n > 0) { + lua_pop(L, n); + } +} + +bool LuaParser::AvoidDamage(Mob *self, Mob *other, DamageHitInfo &hit, bool &ignoreDefault) { + int start = lua_gettop(L); + ignoreDefault = false; + bool retval = false; + + for (auto &mod : mods_) { + try { + if (!HasFunction("AvoidDamage", mod)) { + continue; + } + + lua_getfield(L, LUA_REGISTRYINDEX, mod.c_str()); + lua_getfield(L, -1, "AvoidDamage"); + + Lua_Mob l_self(self); + Lua_Mob l_other(other); + luabind::adl::object e = luabind::newtable(L); + e["self"] = l_self; + e["other"] = l_other; + + PutDamageHitInfo(L, e, hit); + e.push(L); + + if (lua_pcall(L, 1, 1, 0)) { + std::string error = lua_tostring(L, -1); + AddError(error); + lua_pop(L, 1); + continue; + } + + if (lua_type(L, -1) == LUA_TTABLE) { + luabind::adl::object ret(luabind::from_stack(L, -1)); + auto IgnoreDefaultObj = ret["IgnoreDefault"]; + if (luabind::type(IgnoreDefaultObj) == LUA_TBOOLEAN) { + ignoreDefault = ignoreDefault || luabind::object_cast(IgnoreDefaultObj); + } + + auto returnValueObj = ret["ReturnValue"]; + if (luabind::type(returnValueObj) == LUA_TBOOLEAN) { + retval = luabind::object_cast(returnValueObj); + } + + GetDamageHitInfo(ret, hit); + } + } + catch (std::exception &ex) { + AddError(ex.what()); + } + } + + int end = lua_gettop(L); + int n = end - start; + if (n > 0) { + lua_pop(L, n); + } + + return retval; +} + +bool LuaParser::CheckHitChance(Mob *self, Mob* other, DamageHitInfo &hit, bool &ignoreDefault) { + int start = lua_gettop(L); + ignoreDefault = false; + bool retval = false; + + for (auto &mod : mods_) { + try { + if (!HasFunction("CheckHitChance", mod)) { + continue; + } + + lua_getfield(L, LUA_REGISTRYINDEX, mod.c_str()); + lua_getfield(L, -1, "CheckHitChance"); + + Lua_Mob l_self(self); + Lua_Mob l_other(other); + luabind::adl::object e = luabind::newtable(L); + e["self"] = l_self; + e["other"] = l_other; + + PutDamageHitInfo(L, e, hit); + e.push(L); + + if (lua_pcall(L, 1, 1, 0)) { + std::string error = lua_tostring(L, -1); + AddError(error); + lua_pop(L, 1); + continue; + } + + if (lua_type(L, -1) == LUA_TTABLE) { + luabind::adl::object ret(luabind::from_stack(L, -1)); + auto IgnoreDefaultObj = ret["IgnoreDefault"]; + if (luabind::type(IgnoreDefaultObj) == LUA_TBOOLEAN) { + ignoreDefault = ignoreDefault || luabind::object_cast(IgnoreDefaultObj); + } + + auto returnValueObj = ret["ReturnValue"]; + if (luabind::type(returnValueObj) == LUA_TBOOLEAN) { + retval = luabind::object_cast(returnValueObj); + } + + GetDamageHitInfo(ret, hit); + } + } + catch (std::exception &ex) { + AddError(ex.what()); + } + } + + int end = lua_gettop(L); + int n = end - start; + if (n > 0) { + lua_pop(L, n); + } + + return retval; +} + QuestEventID LuaParser::ConvertLuaEvent(QuestEventID evt) { switch(evt) { case EVENT_SLAY: diff --git a/zone/lua_parser.h b/zone/lua_parser.h index d23d963dd..a0f0fea89 100644 --- a/zone/lua_parser.h +++ b/zone/lua_parser.h @@ -31,15 +31,6 @@ namespace luabind { } } -class IgnoreDefaultException : std::exception { -public: - IgnoreDefaultException() { }; - IgnoreDefaultException(const exception&) { }; - IgnoreDefaultException& operator= (const exception&) { return *this; } - virtual ~IgnoreDefaultException() { } - virtual const char* what() const { return "Ignore Default Action"; } -}; - class LuaParser : public QuestInterface { public: ~LuaParser(); @@ -96,7 +87,10 @@ public: } //Mod Extensions - void DoAttack(Mob *self, Mob *other, DamageHitInfo &hit, ExtraAttackOptions *opts); + void MeleeMitigation(Mob *self, Mob *attacker, DamageHitInfo &hit, ExtraAttackOptions *opts, bool &ignoreDefault); + void ApplyDamageTable(Mob *self, DamageHitInfo &hit, bool &ignoreDefault); + bool AvoidDamage(Mob *self, Mob *other, DamageHitInfo &hit, bool &ignoreDefault); + bool CheckHitChance(Mob *self, Mob* other, DamageHitInfo &hit, bool &ignoreDefault); private: LuaParser(); diff --git a/zone/lua_stat_bonuses.cpp b/zone/lua_stat_bonuses.cpp new file mode 100644 index 000000000..bf3f22586 --- /dev/null +++ b/zone/lua_stat_bonuses.cpp @@ -0,0 +1,1539 @@ +#include "lua.hpp" +#include + +#include "lua_stat_bonuses.h" + +int32 Lua_StatBonuses::GetAC() const { + Lua_Safe_Call_Int(); + return self->AC; +} + +int32 Lua_StatBonuses::GetHP() const { + Lua_Safe_Call_Int(); + return self->HP; +} + +int32 Lua_StatBonuses::GetHPRegen() const { + Lua_Safe_Call_Int(); + return self->HPRegen; +} + +int32 Lua_StatBonuses::GetMaxHP() const { + Lua_Safe_Call_Int(); + return self->MaxHP; +} + +int32 Lua_StatBonuses::GetManaRegen() const { + Lua_Safe_Call_Int(); + return self->ManaRegen; +} + +int32 Lua_StatBonuses::GetEnduranceRegen() const { + Lua_Safe_Call_Int(); + return self->EnduranceRegen; +} + +int32 Lua_StatBonuses::GetMana() const { + Lua_Safe_Call_Int(); + return self->Mana; +} + +int32 Lua_StatBonuses::GetEndurance() const { + Lua_Safe_Call_Int(); + return self->Endurance; +} + +int32 Lua_StatBonuses::GetATK() const { + Lua_Safe_Call_Int(); + return self->ATK; +} + +int32 Lua_StatBonuses::GetSTR() const { + Lua_Safe_Call_Int(); + return self->STR; +} + +int32 Lua_StatBonuses::GetSTRCapMod() const { + Lua_Safe_Call_Int(); + return self->STRCapMod; +} + +int32 Lua_StatBonuses::GetHeroicSTR() const { + Lua_Safe_Call_Int(); + return self->HeroicSTR; +} + +int32 Lua_StatBonuses::GetSTA() const { + Lua_Safe_Call_Int(); + return self->STA; +} + +int32 Lua_StatBonuses::GetSTACapMod() const { + Lua_Safe_Call_Int(); + return self->STACapMod; +} + +int32 Lua_StatBonuses::GetHeroicSTA() const { + Lua_Safe_Call_Int(); + return self->HeroicSTA; +} + +int32 Lua_StatBonuses::GetDEX() const { + Lua_Safe_Call_Int(); + return self->DEX; +} + +int32 Lua_StatBonuses::GetDEXCapMod() const { + Lua_Safe_Call_Int(); + return self->DEXCapMod; +} + +int32 Lua_StatBonuses::GetHeroicDEX() const { + Lua_Safe_Call_Int(); + return self->HeroicDEX; +} + +int32 Lua_StatBonuses::GetAGI() const { + Lua_Safe_Call_Int(); + return self->AGI; +} + +int32 Lua_StatBonuses::GetAGICapMod() const { + Lua_Safe_Call_Int(); + return self->AGICapMod; +} + +int32 Lua_StatBonuses::GetHeroicAGI() const { + Lua_Safe_Call_Int(); + return self->HeroicAGI; +} + +int32 Lua_StatBonuses::GetINT() const { + Lua_Safe_Call_Int(); + return self->INT; +} + +int32 Lua_StatBonuses::GetINTCapMod() const { + Lua_Safe_Call_Int(); + return self->INTCapMod; +} + +int32 Lua_StatBonuses::GetHeroicINT() const { + Lua_Safe_Call_Int(); + return self->HeroicINT; +} + +int32 Lua_StatBonuses::GetWIS() const { + Lua_Safe_Call_Int(); + return self->WIS; +} + +int32 Lua_StatBonuses::GetWISCapMod() const { + Lua_Safe_Call_Int(); + return self->WISCapMod; +} + +int32 Lua_StatBonuses::GetHeroicWIS() const { + Lua_Safe_Call_Int(); + return self->HeroicWIS; +} + +int32 Lua_StatBonuses::GetCHA() const { + Lua_Safe_Call_Int(); + return self->CHA; +} + +int32 Lua_StatBonuses::GetCHACapMod() const { + Lua_Safe_Call_Int(); + return self->CHACapMod; +} + +int32 Lua_StatBonuses::GetHeroicCHA() const { + Lua_Safe_Call_Int(); + return self->HeroicCHA; +} + +int32 Lua_StatBonuses::GetMR() const { + Lua_Safe_Call_Int(); + return self->MR; +} + +int32 Lua_StatBonuses::GetMRCapMod() const { + Lua_Safe_Call_Int(); + return self->MRCapMod; +} + +int32 Lua_StatBonuses::GetHeroicMR() const { + Lua_Safe_Call_Int(); + return self->HeroicMR; +} + +int32 Lua_StatBonuses::GetFR() const { + Lua_Safe_Call_Int(); + return self->FR; +} + +int32 Lua_StatBonuses::GetFRCapMod() const { + Lua_Safe_Call_Int(); + return self->FRCapMod; +} + +int32 Lua_StatBonuses::GetHeroicFR() const { + Lua_Safe_Call_Int(); + return self->HeroicFR; +} + +int32 Lua_StatBonuses::GetCR() const { + Lua_Safe_Call_Int(); + return self->CR; +} + +int32 Lua_StatBonuses::GetCRCapMod() const { + Lua_Safe_Call_Int(); + return self->CRCapMod; +} + +int32 Lua_StatBonuses::GetHeroicCR() const { + Lua_Safe_Call_Int(); + return self->HeroicCR; +} + +int32 Lua_StatBonuses::GetPR() const { + Lua_Safe_Call_Int(); + return self->PR; +} + +int32 Lua_StatBonuses::GetPRCapMod() const { + Lua_Safe_Call_Int(); + return self->PRCapMod; +} + +int32 Lua_StatBonuses::GetHeroicPR() const { + Lua_Safe_Call_Int(); + return self->HeroicPR; +} + +int32 Lua_StatBonuses::GetDR() const { + Lua_Safe_Call_Int(); + return self->DR; +} + +int32 Lua_StatBonuses::GetDRCapMod() const { + Lua_Safe_Call_Int(); + return self->DRCapMod; +} + +int32 Lua_StatBonuses::GetHeroicDR() const { + Lua_Safe_Call_Int(); + return self->HeroicDR; +} + +int32 Lua_StatBonuses::GetCorrup() const { + Lua_Safe_Call_Int(); + return self->Corrup; +} + +int32 Lua_StatBonuses::GetCorrupCapMod() const { + Lua_Safe_Call_Int(); + return self->CorrupCapMod; +} + +int32 Lua_StatBonuses::GetHeroicCorrup() const { + Lua_Safe_Call_Int(); + return self->HeroicCorrup; +} + +uint16 Lua_StatBonuses::GetDamageShieldSpellID() const { + Lua_Safe_Call_Int(); + return self->DamageShieldSpellID; +} + +int Lua_StatBonuses::GetDamageShield() const { + Lua_Safe_Call_Int(); + return self->DamageShield; +} + +int Lua_StatBonuses::GetDamageShieldType() const { + Lua_Safe_Call_Int(); + return self->DamageShieldType; +} + +int Lua_StatBonuses::GetSpellDamageShield() const { + Lua_Safe_Call_Int(); + return self->SpellDamageShield; +} + +int Lua_StatBonuses::GetSpellShield() const { + Lua_Safe_Call_Int(); + return self->SpellShield; +} + +int Lua_StatBonuses::GetReverseDamageShield() const { + Lua_Safe_Call_Int(); + return self->ReverseDamageShield; +} + +uint16 Lua_StatBonuses::GetReverseDamageShieldSpellID() const { + Lua_Safe_Call_Int(); + return self->ReverseDamageShieldSpellID; +} + +int Lua_StatBonuses::GetReverseDamageShieldType() const { + Lua_Safe_Call_Int(); + return self->ReverseDamageShieldType; +} + +int Lua_StatBonuses::Getmovementspeed() const { + Lua_Safe_Call_Int(); + return self->movementspeed; +} + +int32 Lua_StatBonuses::Gethaste() const { + Lua_Safe_Call_Int(); + return self->haste; +} + +int32 Lua_StatBonuses::Gethastetype2() const { + Lua_Safe_Call_Int(); + return self->hastetype2; +} + +int32 Lua_StatBonuses::Gethastetype3() const { + Lua_Safe_Call_Int(); + return self->hastetype3; +} + +int32 Lua_StatBonuses::Getinhibitmelee() const { + Lua_Safe_Call_Int(); + return self->inhibitmelee; +} + +float Lua_StatBonuses::GetAggroRange() const { + Lua_Safe_Call_Real(); + return self->AggroRange; +} + +float Lua_StatBonuses::GetAssistRange() const { + Lua_Safe_Call_Real(); + return self->AssistRange; +} + +int32 Lua_StatBonuses::Getskillmod(int idx) const { + Lua_Safe_Call_Int(); + return self->skillmod[idx]; +} + +int32 Lua_StatBonuses::Getskillmodmax(int idx) const { + Lua_Safe_Call_Int(); + return self->skillmodmax[idx]; +} + +int Lua_StatBonuses::Geteffective_casting_level() const { + Lua_Safe_Call_Int(); + return self->effective_casting_level; +} + +int Lua_StatBonuses::Getreflect_chance() const { + Lua_Safe_Call_Int(); + return self->reflect_chance; +} + +uint32 Lua_StatBonuses::GetsingingMod() const { + Lua_Safe_Call_Int(); + return self->singingMod; +} + +uint32 Lua_StatBonuses::GetAmplification() const { + Lua_Safe_Call_Int(); + return self->Amplification; +} + +uint32 Lua_StatBonuses::GetbrassMod() const { + Lua_Safe_Call_Int(); + return self->brassMod; +} + +uint32 Lua_StatBonuses::GetpercussionMod() const { + Lua_Safe_Call_Int(); + return self->percussionMod; +} + +uint32 Lua_StatBonuses::GetwindMod() const { + Lua_Safe_Call_Int(); + return self->windMod; +} + +uint32 Lua_StatBonuses::GetstringedMod() const { + Lua_Safe_Call_Int(); + return self->stringedMod; +} + +uint32 Lua_StatBonuses::GetsongModCap() const { + Lua_Safe_Call_Int(); + return self->songModCap; +} + +int8 Lua_StatBonuses::Gethatemod() const { + Lua_Safe_Call_Int(); + return self->hatemod; +} + +int32 Lua_StatBonuses::GetEnduranceReduction() const { + Lua_Safe_Call_Int(); + return self->EnduranceReduction; +} + +int32 Lua_StatBonuses::GetStrikeThrough() const { + Lua_Safe_Call_Int(); + return self->StrikeThrough; +} + +int32 Lua_StatBonuses::GetMeleeMitigation() const { + Lua_Safe_Call_Int(); + return self->MeleeMitigation; +} + +int32 Lua_StatBonuses::GetMeleeMitigationEffect() const { + Lua_Safe_Call_Int(); + return self->MeleeMitigationEffect; +} + +int32 Lua_StatBonuses::GetCriticalHitChance(int idx) const { + Lua_Safe_Call_Int(); + return self->CriticalHitChance[idx]; +} + +int32 Lua_StatBonuses::GetCriticalSpellChance() const { + Lua_Safe_Call_Int(); + return self->CriticalSpellChance; +} + +int32 Lua_StatBonuses::GetSpellCritDmgIncrease() const { + Lua_Safe_Call_Int(); + return self->SpellCritDmgIncrease; +} + +int32 Lua_StatBonuses::GetSpellCritDmgIncNoStack() const { + Lua_Safe_Call_Int(); + return self->SpellCritDmgIncNoStack; +} + +int32 Lua_StatBonuses::GetDotCritDmgIncrease() const { + Lua_Safe_Call_Int(); + return self->DotCritDmgIncrease; +} + +int32 Lua_StatBonuses::GetCriticalHealChance() const { + Lua_Safe_Call_Int(); + return self->CriticalHealChance; +} + +int32 Lua_StatBonuses::GetCriticalHealOverTime() const { + Lua_Safe_Call_Int(); + return self->CriticalHealOverTime; +} + +int32 Lua_StatBonuses::GetCriticalDoTChance() const { + Lua_Safe_Call_Int(); + return self->CriticalDoTChance; +} + +int32 Lua_StatBonuses::GetCrippBlowChance() const { + Lua_Safe_Call_Int(); + return self->CrippBlowChance; +} + +int32 Lua_StatBonuses::GetAvoidMeleeChance() const { + Lua_Safe_Call_Int(); + return self->AvoidMeleeChance; +} + +int32 Lua_StatBonuses::GetAvoidMeleeChanceEffect() const { + Lua_Safe_Call_Int(); + return self->AvoidMeleeChanceEffect; +} + +int32 Lua_StatBonuses::GetRiposteChance() const { + Lua_Safe_Call_Int(); + return self->RiposteChance; +} + +int32 Lua_StatBonuses::GetDodgeChance() const { + Lua_Safe_Call_Int(); + return self->DodgeChance; +} + +int32 Lua_StatBonuses::GetParryChance() const { + Lua_Safe_Call_Int(); + return self->ParryChance; +} + +int32 Lua_StatBonuses::GetDualWieldChance() const { + Lua_Safe_Call_Int(); + return self->DualWieldChance; +} + +int32 Lua_StatBonuses::GetDoubleAttackChance() const { + Lua_Safe_Call_Int(); + return self->DoubleAttackChance; +} + +int32 Lua_StatBonuses::GetTripleAttackChance() const { + Lua_Safe_Call_Int(); + return self->TripleAttackChance; +} + +int32 Lua_StatBonuses::GetDoubleRangedAttack() const { + Lua_Safe_Call_Int(); + return self->DoubleRangedAttack; +} + +int32 Lua_StatBonuses::GetResistSpellChance() const { + Lua_Safe_Call_Int(); + return self->ResistSpellChance; +} + +int32 Lua_StatBonuses::GetResistFearChance() const { + Lua_Safe_Call_Int(); + return self->ResistFearChance; +} + +bool Lua_StatBonuses::GetFearless() const { + Lua_Safe_Call_Bool(); + return self->Fearless; +} + +bool Lua_StatBonuses::GetIsFeared() const { + Lua_Safe_Call_Bool(); + return self->IsFeared; +} + +bool Lua_StatBonuses::GetIsBlind() const { + Lua_Safe_Call_Bool(); + return self->IsBlind; +} + +int32 Lua_StatBonuses::GetStunResist() const { + Lua_Safe_Call_Int(); + return self->StunResist; +} + +int32 Lua_StatBonuses::GetMeleeSkillCheck() const { + Lua_Safe_Call_Int(); + return self->MeleeSkillCheck; +} + +uint8 Lua_StatBonuses::GetMeleeSkillCheckSkill() const { + Lua_Safe_Call_Int(); + return self->MeleeSkillCheckSkill; +} + +int32 Lua_StatBonuses::GetHitChance() const { + Lua_Safe_Call_Int(); + return self->HitChance; +} + +int32 Lua_StatBonuses::GetHitChanceEffect(int idx) const { + Lua_Safe_Call_Int(); + return self->HitChanceEffect[idx]; +} + +int32 Lua_StatBonuses::GetDamageModifier(int idx) const { + Lua_Safe_Call_Int(); + return self->DamageModifier[idx]; +} + +int32 Lua_StatBonuses::GetDamageModifier2(int idx) const { + Lua_Safe_Call_Int(); + return self->DamageModifier2[idx]; +} + +int32 Lua_StatBonuses::GetMinDamageModifier(int idx) const { + Lua_Safe_Call_Int(); + return self->MinDamageModifier[idx]; +} + +int32 Lua_StatBonuses::GetProcChance() const { + Lua_Safe_Call_Int(); + return self->ProcChance; +} + +int32 Lua_StatBonuses::GetProcChanceSPA() const { + Lua_Safe_Call_Int(); + return self->ProcChanceSPA; +} + +int32 Lua_StatBonuses::GetExtraAttackChance() const { + Lua_Safe_Call_Int(); + return self->ExtraAttackChance; +} + +int32 Lua_StatBonuses::GetDoTShielding() const { + Lua_Safe_Call_Int(); + return self->DoTShielding; +} + +int32 Lua_StatBonuses::GetFlurryChance() const { + Lua_Safe_Call_Int(); + return self->FlurryChance; +} + +int32 Lua_StatBonuses::GetHundredHands() const { + Lua_Safe_Call_Int(); + return self->HundredHands; +} + +int32 Lua_StatBonuses::GetMeleeLifetap() const { + Lua_Safe_Call_Int(); + return self->MeleeLifetap; +} + +int32 Lua_StatBonuses::GetVampirism() const { + Lua_Safe_Call_Int(); + return self->Vampirism; +} + +int32 Lua_StatBonuses::GetHealRate() const { + Lua_Safe_Call_Int(); + return self->HealRate; +} + +int32 Lua_StatBonuses::GetMaxHPChange() const { + Lua_Safe_Call_Int(); + return self->MaxHPChange; +} + +int32 Lua_StatBonuses::GetHealAmt() const { + Lua_Safe_Call_Int(); + return self->HealAmt; +} + +int32 Lua_StatBonuses::GetSpellDmg() const { + Lua_Safe_Call_Int(); + return self->SpellDmg; +} + +int32 Lua_StatBonuses::GetClairvoyance() const { + Lua_Safe_Call_Int(); + return self->Clairvoyance; +} + +int32 Lua_StatBonuses::GetDSMitigation() const { + Lua_Safe_Call_Int(); + return self->DSMitigation; +} + +int32 Lua_StatBonuses::GetDSMitigationOffHand() const { + Lua_Safe_Call_Int(); + return self->DSMitigationOffHand; +} + +int32 Lua_StatBonuses::GetTwoHandBluntBlock() const { + Lua_Safe_Call_Int(); + return self->TwoHandBluntBlock; +} + +uint32 Lua_StatBonuses::GetItemManaRegenCap() const { + Lua_Safe_Call_Int(); + return self->ItemManaRegenCap; +} + +int32 Lua_StatBonuses::GetGravityEffect() const { + Lua_Safe_Call_Int(); + return self->GravityEffect; +} + +bool Lua_StatBonuses::GetAntiGate() const { + Lua_Safe_Call_Bool(); + return self->AntiGate; +} + +bool Lua_StatBonuses::GetMagicWeapon() const { + Lua_Safe_Call_Bool(); + return self->MagicWeapon; +} + +int32 Lua_StatBonuses::GetIncreaseBlockChance() const { + Lua_Safe_Call_Int(); + return self->IncreaseBlockChance; +} + +uint32 Lua_StatBonuses::GetPersistantCasting() const { + Lua_Safe_Call_Int(); + return self->PersistantCasting; +} + +int Lua_StatBonuses::GetXPRateMod() const { + Lua_Safe_Call_Int(); + return self->XPRateMod; +} + +bool Lua_StatBonuses::GetBlockNextSpell() const { + Lua_Safe_Call_Bool(); + return self->BlockNextSpell; +} + +bool Lua_StatBonuses::GetImmuneToFlee() const { + Lua_Safe_Call_Bool(); + return self->ImmuneToFlee; +} + +uint32 Lua_StatBonuses::GetVoiceGraft() const { + Lua_Safe_Call_Int(); + return self->VoiceGraft; +} + +int32 Lua_StatBonuses::GetSpellProcChance() const { + Lua_Safe_Call_Int(); + return self->SpellProcChance; +} + +int32 Lua_StatBonuses::GetCharmBreakChance() const { + Lua_Safe_Call_Int(); + return self->CharmBreakChance; +} + +int32 Lua_StatBonuses::GetSongRange() const { + Lua_Safe_Call_Int(); + return self->SongRange; +} + +uint32 Lua_StatBonuses::GetHPToManaConvert() const { + Lua_Safe_Call_Int(); + return self->HPToManaConvert; +} + +bool Lua_StatBonuses::GetNegateEffects() const { + Lua_Safe_Call_Bool(); + return self->NegateEffects; +} + +bool Lua_StatBonuses::GetTriggerMeleeThreshold() const { + Lua_Safe_Call_Bool(); + return self->TriggerMeleeThreshold; +} + +bool Lua_StatBonuses::GetTriggerSpellThreshold() const { + Lua_Safe_Call_Bool(); + return self->TriggerSpellThreshold; +} + +int32 Lua_StatBonuses::GetShieldBlock() const { + Lua_Safe_Call_Int(); + return self->ShieldBlock; +} + +int32 Lua_StatBonuses::GetBlockBehind() const { + Lua_Safe_Call_Int(); + return self->BlockBehind; +} + +bool Lua_StatBonuses::GetCriticalRegenDecay() const { + Lua_Safe_Call_Bool(); + return self->CriticalRegenDecay; +} + +bool Lua_StatBonuses::GetCriticalHealDecay() const { + Lua_Safe_Call_Bool(); + return self->CriticalHealDecay; +} + +bool Lua_StatBonuses::GetCriticalDotDecay() const { + Lua_Safe_Call_Bool(); + return self->CriticalDotDecay; +} + +bool Lua_StatBonuses::GetDivineAura() const { + Lua_Safe_Call_Bool(); + return self->DivineAura; +} + +bool Lua_StatBonuses::GetDistanceRemoval() const { + Lua_Safe_Call_Bool(); + return self->DistanceRemoval; +} + +int32 Lua_StatBonuses::GetFrenziedDevastation() const { + Lua_Safe_Call_Int(); + return self->FrenziedDevastation; +} + +bool Lua_StatBonuses::GetNegateIfCombat() const { + Lua_Safe_Call_Bool(); + return self->NegateIfCombat; +} + +int8 Lua_StatBonuses::GetScreech() const { + Lua_Safe_Call_Int(); + return self->Screech; +} + +int32 Lua_StatBonuses::GetAlterNPCLevel() const { + Lua_Safe_Call_Int(); + return self->AlterNPCLevel; +} + +bool Lua_StatBonuses::GetBerserkSPA() const { + Lua_Safe_Call_Bool(); + return self->BerserkSPA; +} + +int32 Lua_StatBonuses::GetMetabolism() const { + Lua_Safe_Call_Int(); + return self->Metabolism; +} + +bool Lua_StatBonuses::GetSanctuary() const { + Lua_Safe_Call_Bool(); + return self->Sanctuary; +} + +int32 Lua_StatBonuses::GetFactionModPct() const { + Lua_Safe_Call_Int(); + return self->FactionModPct; +} + +uint32 Lua_StatBonuses::GetPC_Pet_Flurry() const { + Lua_Safe_Call_Int(); + return self->PC_Pet_Flurry; +} + +int8 Lua_StatBonuses::GetPackrat() const { + Lua_Safe_Call_Int(); + return self->Packrat; +} + +uint8 Lua_StatBonuses::GetBuffSlotIncrease() const { + Lua_Safe_Call_Int(); + return self->BuffSlotIncrease; +} + +uint32 Lua_StatBonuses::GetDelayDeath() const { + Lua_Safe_Call_Int(); + return self->DelayDeath; +} + +int8 Lua_StatBonuses::GetBaseMovementSpeed() const { + Lua_Safe_Call_Int(); + return self->BaseMovementSpeed; +} + +uint8 Lua_StatBonuses::GetIncreaseRunSpeedCap() const { + Lua_Safe_Call_Int(); + return self->IncreaseRunSpeedCap; +} + +int32 Lua_StatBonuses::GetDoubleSpecialAttack() const { + Lua_Safe_Call_Int(); + return self->DoubleSpecialAttack; +} + +uint8 Lua_StatBonuses::GetFrontalStunResist() const { + Lua_Safe_Call_Int(); + return self->FrontalStunResist; +} + +int32 Lua_StatBonuses::GetBindWound() const { + Lua_Safe_Call_Int(); + return self->BindWound; +} + +int32 Lua_StatBonuses::GetMaxBindWound() const { + Lua_Safe_Call_Int(); + return self->MaxBindWound; +} + +int32 Lua_StatBonuses::GetChannelChanceSpells() const { + Lua_Safe_Call_Int(); + return self->ChannelChanceSpells; +} + +int32 Lua_StatBonuses::GetChannelChanceItems() const { + Lua_Safe_Call_Int(); + return self->ChannelChanceItems; +} + +uint8 Lua_StatBonuses::GetSeeInvis() const { + Lua_Safe_Call_Int(); + return self->SeeInvis; +} + +uint8 Lua_StatBonuses::GetTripleBackstab() const { + Lua_Safe_Call_Int(); + return self->TripleBackstab; +} + +bool Lua_StatBonuses::GetFrontalBackstabMinDmg() const { + Lua_Safe_Call_Bool(); + return self->FrontalBackstabMinDmg; +} + +uint8 Lua_StatBonuses::GetFrontalBackstabChance() const { + Lua_Safe_Call_Int(); + return self->FrontalBackstabChance; +} + +uint8 Lua_StatBonuses::GetConsumeProjectile() const { + Lua_Safe_Call_Int(); + return self->ConsumeProjectile; +} + +uint8 Lua_StatBonuses::GetForageAdditionalItems() const { + Lua_Safe_Call_Int(); + return self->ForageAdditionalItems; +} + +uint8 Lua_StatBonuses::GetSalvageChance() const { + Lua_Safe_Call_Int(); + return self->SalvageChance; +} + +uint32 Lua_StatBonuses::GetArcheryDamageModifier() const { + Lua_Safe_Call_Int(); + return self->ArcheryDamageModifier; +} + +bool Lua_StatBonuses::GetSecondaryDmgInc() const { + Lua_Safe_Call_Bool(); + return self->SecondaryDmgInc; +} + +uint32 Lua_StatBonuses::GetGiveDoubleAttack() const { + Lua_Safe_Call_Int(); + return self->GiveDoubleAttack; +} + +int32 Lua_StatBonuses::GetPetCriticalHit() const { + Lua_Safe_Call_Int(); + return self->PetCriticalHit; +} + +int32 Lua_StatBonuses::GetPetAvoidance() const { + Lua_Safe_Call_Int(); + return self->PetAvoidance; +} + +int32 Lua_StatBonuses::GetCombatStability() const { + Lua_Safe_Call_Int(); + return self->CombatStability; +} + +int32 Lua_StatBonuses::GetDoubleRiposte() const { + Lua_Safe_Call_Int(); + return self->DoubleRiposte; +} + +int32 Lua_StatBonuses::GetAmbidexterity() const { + Lua_Safe_Call_Int(); + return self->Ambidexterity; +} + +int32 Lua_StatBonuses::GetPetMaxHP() const { + Lua_Safe_Call_Int(); + return self->PetMaxHP; +} + +int32 Lua_StatBonuses::GetPetFlurry() const { + Lua_Safe_Call_Int(); + return self->PetFlurry; +} + +uint8 Lua_StatBonuses::GetMasteryofPast() const { + Lua_Safe_Call_Int(); + return self->MasteryofPast; +} + +bool Lua_StatBonuses::GetGivePetGroupTarget() const { + Lua_Safe_Call_Bool(); + return self->GivePetGroupTarget; +} + +int32 Lua_StatBonuses::GetRootBreakChance() const { + Lua_Safe_Call_Int(); + return self->RootBreakChance; +} + +int32 Lua_StatBonuses::GetUnfailingDivinity() const { + Lua_Safe_Call_Int(); + return self->UnfailingDivinity; +} + +int32 Lua_StatBonuses::GetItemHPRegenCap() const { + Lua_Safe_Call_Int(); + return self->ItemHPRegenCap; +} + +int32 Lua_StatBonuses::GetOffhandRiposteFail() const { + Lua_Safe_Call_Int(); + return self->OffhandRiposteFail; +} + +int32 Lua_StatBonuses::GetItemATKCap() const { + Lua_Safe_Call_Int(); + return self->ItemATKCap; +} + +int32 Lua_StatBonuses::GetShieldEquipDmgMod() const { + Lua_Safe_Call_Int(); + return self->ShieldEquipDmgMod; +} + +bool Lua_StatBonuses::GetTriggerOnValueAmount() const { + Lua_Safe_Call_Bool(); + return self->TriggerOnValueAmount; +} + +int8 Lua_StatBonuses::GetStunBashChance() const { + Lua_Safe_Call_Int(); + return self->StunBashChance; +} + +int8 Lua_StatBonuses::GetIncreaseChanceMemwipe() const { + Lua_Safe_Call_Int(); + return self->IncreaseChanceMemwipe; +} + +int8 Lua_StatBonuses::GetCriticalMend() const { + Lua_Safe_Call_Int(); + return self->CriticalMend; +} + +int32 Lua_StatBonuses::GetImprovedReclaimEnergy() const { + Lua_Safe_Call_Int(); + return self->ImprovedReclaimEnergy; +} + +int32 Lua_StatBonuses::GetPetMeleeMitigation() const { + Lua_Safe_Call_Int(); + return self->PetMeleeMitigation; +} + +bool Lua_StatBonuses::GetIllusionPersistence() const { + Lua_Safe_Call_Bool(); + return self->IllusionPersistence; +} + +uint16 Lua_StatBonuses::Getextra_xtargets() const { + Lua_Safe_Call_Int(); + return self->extra_xtargets; +} + +bool Lua_StatBonuses::GetShroudofStealth() const { + Lua_Safe_Call_Bool(); + return self->ShroudofStealth; +} + +uint16 Lua_StatBonuses::GetReduceFallDamage() const { + Lua_Safe_Call_Int(); + return self->ReduceFallDamage; +} + +uint8 Lua_StatBonuses::GetTradeSkillMastery() const { + Lua_Safe_Call_Int(); + return self->TradeSkillMastery; +} + +int16 Lua_StatBonuses::GetNoBreakAESneak() const { + Lua_Safe_Call_Int(); + return self->NoBreakAESneak; +} + +int16 Lua_StatBonuses::GetFeignedCastOnChance() const { + Lua_Safe_Call_Int(); + return self->FeignedCastOnChance; +} + +int32 Lua_StatBonuses::GetDivineSaveChance(int idx) const { + Lua_Safe_Call_Int(); + return self->DivineSaveChance[idx]; +} + +uint32 Lua_StatBonuses::GetDeathSave(int idx) const { + Lua_Safe_Call_Int(); + return self->DeathSave[idx]; +} + +int32 Lua_StatBonuses::GetAccuracy(int idx) const { + Lua_Safe_Call_Int(); + return self->Accuracy[idx]; +} + +int16 Lua_StatBonuses::GetSkillDmgTaken(int idx) const { + Lua_Safe_Call_Int(); + return self->SkillDmgTaken[idx]; +} + +uint32 Lua_StatBonuses::GetSpellTriggers(int idx) const { + Lua_Safe_Call_Int(); + return self->SpellTriggers[idx]; +} + +uint32 Lua_StatBonuses::GetSpellOnKill(int idx) const { + Lua_Safe_Call_Int(); + return self->SpellOnKill[idx]; +} + +uint32 Lua_StatBonuses::GetSpellOnDeath(int idx) const { + Lua_Safe_Call_Int(); + return self->SpellOnDeath[idx]; +} + +int32 Lua_StatBonuses::GetCritDmgMob(int idx) const { + Lua_Safe_Call_Int(); + return self->CritDmgMob[idx]; +} + +int32 Lua_StatBonuses::GetSkillReuseTime(int idx) const { + Lua_Safe_Call_Int(); + return self->SkillReuseTime[idx]; +} + +int32 Lua_StatBonuses::GetSkillDamageAmount(int idx) const { + Lua_Safe_Call_Int(); + return self->SkillDamageAmount[idx]; +} + +int Lua_StatBonuses::GetHPPercCap(int idx) const { + Lua_Safe_Call_Int(); + return self->HPPercCap[idx]; +} + +int Lua_StatBonuses::GetManaPercCap(int idx) const { + Lua_Safe_Call_Int(); + return self->ManaPercCap[idx]; +} + +int Lua_StatBonuses::GetEndPercCap(int idx) const { + Lua_Safe_Call_Int(); + return self->EndPercCap[idx]; +} + +uint8 Lua_StatBonuses::GetFocusEffects(int idx) const { + Lua_Safe_Call_Int(); + return self->FocusEffects[idx]; +} + +int16 Lua_StatBonuses::GetFocusEffectsWorn(int idx) const { + Lua_Safe_Call_Int(); + return self->FocusEffectsWorn[idx]; +} + +int32 Lua_StatBonuses::GetSkillDamageAmount2(int idx) const { + Lua_Safe_Call_Int(); + return self->SkillDamageAmount2[idx]; +} + +uint32 Lua_StatBonuses::GetNegateAttacks(int idx) const { + Lua_Safe_Call_Int(); + return self->NegateAttacks[idx]; +} + +uint32 Lua_StatBonuses::GetMitigateMeleeRune(int idx) const { + Lua_Safe_Call_Int(); + return self->MitigateMeleeRune[idx]; +} + +uint32 Lua_StatBonuses::GetMeleeThresholdGuard(int idx) const { + Lua_Safe_Call_Int(); + return self->MeleeThresholdGuard[idx]; +} + +uint32 Lua_StatBonuses::GetSpellThresholdGuard(int idx) const { + Lua_Safe_Call_Int(); + return self->SpellThresholdGuard[idx]; +} + +uint32 Lua_StatBonuses::GetMitigateSpellRune(int idx) const { + Lua_Safe_Call_Int(); + return self->MitigateSpellRune[idx]; +} + +uint32 Lua_StatBonuses::GetMitigateDotRune(int idx) const { + Lua_Safe_Call_Int(); + return self->MitigateDotRune[idx]; +} + +uint32 Lua_StatBonuses::GetManaAbsorbPercentDamage(int idx) const { + Lua_Safe_Call_Int(); + return self->ManaAbsorbPercentDamage[idx]; +} + +int32 Lua_StatBonuses::GetImprovedTaunt(int idx) const { + Lua_Safe_Call_Int(); + return self->ImprovedTaunt[idx]; +} + +int8 Lua_StatBonuses::GetRoot(int idx) const { + Lua_Safe_Call_Int(); + return self->Root[idx]; +} + +uint32 Lua_StatBonuses::GetAbsorbMagicAtt(int idx) const { + Lua_Safe_Call_Int(); + return self->AbsorbMagicAtt[idx]; +} + +uint32 Lua_StatBonuses::GetMeleeRune(int idx) const { + Lua_Safe_Call_Int(); + return self->MeleeRune[idx]; +} + +int32 Lua_StatBonuses::GetAStacker(int idx) const { + Lua_Safe_Call_Int(); + return self->AStacker[idx]; +} + +int32 Lua_StatBonuses::GetBStacker(int idx) const { + Lua_Safe_Call_Int(); + return self->BStacker[idx]; +} + +int32 Lua_StatBonuses::GetCStacker(int idx) const { + Lua_Safe_Call_Int(); + return self->CStacker[idx]; +} + +int32 Lua_StatBonuses::GetDStacker(int idx) const { + Lua_Safe_Call_Int(); + return self->DStacker[idx]; +} + +bool Lua_StatBonuses::GetLimitToSkill(int idx) const { + Lua_Safe_Call_Bool(); + return self->LimitToSkill[idx]; +} + +uint32 Lua_StatBonuses::GetSkillProc(int idx) const { + Lua_Safe_Call_Int(); + return self->SkillProc[idx]; +} + +uint32 Lua_StatBonuses::GetSkillProcSuccess(int idx) const { + Lua_Safe_Call_Int(); + return self->SkillProcSuccess[idx]; +} + +uint32 Lua_StatBonuses::GetPC_Pet_Rampage(int idx) const { + Lua_Safe_Call_Int(); + return self->PC_Pet_Rampage[idx]; +} + +int32 Lua_StatBonuses::GetSkillAttackProc(int idx) const { + Lua_Safe_Call_Int(); + return self->SkillAttackProc[idx]; +} + +int32 Lua_StatBonuses::GetSlayUndead(int idx) const { + Lua_Safe_Call_Int(); + return self->SlayUndead[idx]; +} + +int32 Lua_StatBonuses::GetGiveDoubleRiposte(int idx) const { + Lua_Safe_Call_Int(); + return self->GiveDoubleRiposte[idx]; +} + +uint32 Lua_StatBonuses::GetRaiseSkillCap(int idx) const { + Lua_Safe_Call_Int(); + return self->RaiseSkillCap[idx]; +} + +int32 Lua_StatBonuses::GetSEResist(int idx) const { + Lua_Safe_Call_Int(); + return self->SEResist[idx]; +} + +int32 Lua_StatBonuses::GetFinishingBlow(int idx) const { + Lua_Safe_Call_Int(); + return self->FinishingBlow[idx]; +} + +uint32 Lua_StatBonuses::GetFinishingBlowLvl(int idx) const { + Lua_Safe_Call_Int(); + return self->FinishingBlowLvl[idx]; +} + +uint32 Lua_StatBonuses::GetHeadShot(int idx) const { + Lua_Safe_Call_Int(); + return self->HeadShot[idx]; +} + +uint8 Lua_StatBonuses::GetHSLevel(int idx) const { + Lua_Safe_Call_Int(); + return self->HSLevel[idx]; +} + +uint32 Lua_StatBonuses::GetAssassinate(int idx) const { + Lua_Safe_Call_Int(); + return self->Assassinate[idx]; +} + +uint8 Lua_StatBonuses::GetAssassinateLevel(int idx) const { + Lua_Safe_Call_Int(); + return self->AssassinateLevel[idx]; +} + +int32 Lua_StatBonuses::GetReduceTradeskillFail(int idx) const { + Lua_Safe_Call_Int(); + return self->ReduceTradeskillFail[idx]; +} + +luabind::scope lua_register_stat_bonuses() { + return luabind::class_("StatBonuses") + .def(luabind::constructor<>()) + .def("GetAC", &Lua_StatBonuses::GetAC) + .def("GetHP", &Lua_StatBonuses::GetHP) + .def("GetHPRegen", &Lua_StatBonuses::GetHPRegen) + .def("GetMaxHP", &Lua_StatBonuses::GetMaxHP) + .def("GetManaRegen", &Lua_StatBonuses::GetManaRegen) + .def("GetEnduranceRegen", &Lua_StatBonuses::GetEnduranceRegen) + .def("GetMana", &Lua_StatBonuses::GetMana) + .def("GetEndurance", &Lua_StatBonuses::GetEndurance) + .def("GetATK", &Lua_StatBonuses::GetATK) + .def("GetSTR", &Lua_StatBonuses::GetSTR) + .def("GetSTRCapMod", &Lua_StatBonuses::GetSTRCapMod) + .def("GetHeroicSTR", &Lua_StatBonuses::GetHeroicSTR) + .def("GetSTA", &Lua_StatBonuses::GetSTA) + .def("GetSTACapMod", &Lua_StatBonuses::GetSTACapMod) + .def("GetHeroicSTA", &Lua_StatBonuses::GetHeroicSTA) + .def("GetDEX", &Lua_StatBonuses::GetDEX) + .def("GetDEXCapMod", &Lua_StatBonuses::GetDEXCapMod) + .def("GetHeroicDEX", &Lua_StatBonuses::GetHeroicDEX) + .def("GetAGI", &Lua_StatBonuses::GetAGI) + .def("GetAGICapMod", &Lua_StatBonuses::GetAGICapMod) + .def("GetHeroicAGI", &Lua_StatBonuses::GetHeroicAGI) + .def("GetINT", &Lua_StatBonuses::GetINT) + .def("GetINTCapMod", &Lua_StatBonuses::GetINTCapMod) + .def("GetHeroicINT", &Lua_StatBonuses::GetHeroicINT) + .def("GetWIS", &Lua_StatBonuses::GetWIS) + .def("GetWISCapMod", &Lua_StatBonuses::GetWISCapMod) + .def("GetHeroicWIS", &Lua_StatBonuses::GetHeroicWIS) + .def("GetCHA", &Lua_StatBonuses::GetCHA) + .def("GetCHACapMod", &Lua_StatBonuses::GetCHACapMod) + .def("GetHeroicCHA", &Lua_StatBonuses::GetHeroicCHA) + .def("GetMR", &Lua_StatBonuses::GetMR) + .def("GetMRCapMod", &Lua_StatBonuses::GetMRCapMod) + .def("GetHeroicMR", &Lua_StatBonuses::GetHeroicMR) + .def("GetFR", &Lua_StatBonuses::GetFR) + .def("GetFRCapMod", &Lua_StatBonuses::GetFRCapMod) + .def("GetHeroicFR", &Lua_StatBonuses::GetHeroicFR) + .def("GetCR", &Lua_StatBonuses::GetCR) + .def("GetCRCapMod", &Lua_StatBonuses::GetCRCapMod) + .def("GetHeroicCR", &Lua_StatBonuses::GetHeroicCR) + .def("GetPR", &Lua_StatBonuses::GetPR) + .def("GetPRCapMod", &Lua_StatBonuses::GetPRCapMod) + .def("GetHeroicPR", &Lua_StatBonuses::GetHeroicPR) + .def("GetDR", &Lua_StatBonuses::GetDR) + .def("GetDRCapMod", &Lua_StatBonuses::GetDRCapMod) + .def("GetHeroicDR", &Lua_StatBonuses::GetHeroicDR) + .def("GetCorrup", &Lua_StatBonuses::GetCorrup) + .def("GetCorrupCapMod", &Lua_StatBonuses::GetCorrupCapMod) + .def("GetHeroicCorrup", &Lua_StatBonuses::GetHeroicCorrup) + .def("GetDamageShieldSpellID", &Lua_StatBonuses::GetDamageShieldSpellID) + .def("GetDamageShield", &Lua_StatBonuses::GetDamageShield) + .def("GetDamageShieldType", &Lua_StatBonuses::GetDamageShieldType) + .def("GetSpellDamageShield", &Lua_StatBonuses::GetSpellDamageShield) + .def("GetSpellShield", &Lua_StatBonuses::GetSpellShield) + .def("GetReverseDamageShield", &Lua_StatBonuses::GetReverseDamageShield) + .def("GetReverseDamageShieldSpellID", &Lua_StatBonuses::GetReverseDamageShieldSpellID) + .def("GetReverseDamageShieldType", &Lua_StatBonuses::GetReverseDamageShieldType) + .def("Getmovementspeed", &Lua_StatBonuses::Getmovementspeed) + .def("Gethaste", &Lua_StatBonuses::Gethaste) + .def("Gethastetype2", &Lua_StatBonuses::Gethastetype2) + .def("Gethastetype3", &Lua_StatBonuses::Gethastetype3) + .def("Getinhibitmelee", &Lua_StatBonuses::Getinhibitmelee) + .def("GetAggroRange", &Lua_StatBonuses::GetAggroRange) + .def("GetAssistRange", &Lua_StatBonuses::GetAssistRange) + .def("Getskillmod", &Lua_StatBonuses::Getskillmod) + .def("Getskillmodmax", &Lua_StatBonuses::Getskillmodmax) + .def("Geteffective_casting_level", &Lua_StatBonuses::Geteffective_casting_level) + .def("Getreflect_chance", &Lua_StatBonuses::Getreflect_chance) + .def("GetsingingMod", &Lua_StatBonuses::GetsingingMod) + .def("GetAmplification", &Lua_StatBonuses::GetAmplification) + .def("GetbrassMod", &Lua_StatBonuses::GetbrassMod) + .def("GetpercussionMod", &Lua_StatBonuses::GetpercussionMod) + .def("GetwindMod", &Lua_StatBonuses::GetwindMod) + .def("GetstringedMod", &Lua_StatBonuses::GetstringedMod) + .def("GetsongModCap", &Lua_StatBonuses::GetsongModCap) + .def("Gethatemod", &Lua_StatBonuses::Gethatemod) + .def("GetEnduranceReduction", &Lua_StatBonuses::GetEnduranceReduction) + .def("GetStrikeThrough", &Lua_StatBonuses::GetStrikeThrough) + .def("GetMeleeMitigation", &Lua_StatBonuses::GetMeleeMitigation) + .def("GetMeleeMitigationEffect", &Lua_StatBonuses::GetMeleeMitigationEffect) + .def("GetCriticalHitChance", &Lua_StatBonuses::GetCriticalHitChance) + .def("GetCriticalSpellChance", &Lua_StatBonuses::GetCriticalSpellChance) + .def("GetSpellCritDmgIncrease", &Lua_StatBonuses::GetSpellCritDmgIncrease) + .def("GetSpellCritDmgIncNoStack", &Lua_StatBonuses::GetSpellCritDmgIncNoStack) + .def("GetDotCritDmgIncrease", &Lua_StatBonuses::GetDotCritDmgIncrease) + .def("GetCriticalHealChance", &Lua_StatBonuses::GetCriticalHealChance) + .def("GetCriticalHealOverTime", &Lua_StatBonuses::GetCriticalHealOverTime) + .def("GetCriticalDoTChance", &Lua_StatBonuses::GetCriticalDoTChance) + .def("GetCrippBlowChance", &Lua_StatBonuses::GetCrippBlowChance) + .def("GetAvoidMeleeChance", &Lua_StatBonuses::GetAvoidMeleeChance) + .def("GetAvoidMeleeChanceEffect", &Lua_StatBonuses::GetAvoidMeleeChanceEffect) + .def("GetRiposteChance", &Lua_StatBonuses::GetRiposteChance) + .def("GetDodgeChance", &Lua_StatBonuses::GetDodgeChance) + .def("GetParryChance", &Lua_StatBonuses::GetParryChance) + .def("GetDualWieldChance", &Lua_StatBonuses::GetDualWieldChance) + .def("GetDoubleAttackChance", &Lua_StatBonuses::GetDoubleAttackChance) + .def("GetTripleAttackChance", &Lua_StatBonuses::GetTripleAttackChance) + .def("GetDoubleRangedAttack", &Lua_StatBonuses::GetDoubleRangedAttack) + .def("GetResistSpellChance", &Lua_StatBonuses::GetResistSpellChance) + .def("GetResistFearChance", &Lua_StatBonuses::GetResistFearChance) + .def("GetFearless", &Lua_StatBonuses::GetFearless) + .def("GetIsFeared", &Lua_StatBonuses::GetIsFeared) + .def("GetIsBlind", &Lua_StatBonuses::GetIsBlind) + .def("GetStunResist", &Lua_StatBonuses::GetStunResist) + .def("GetMeleeSkillCheck", &Lua_StatBonuses::GetMeleeSkillCheck) + .def("GetMeleeSkillCheckSkill", &Lua_StatBonuses::GetMeleeSkillCheckSkill) + .def("GetHitChance", &Lua_StatBonuses::GetHitChance) + .def("GetHitChanceEffect", &Lua_StatBonuses::GetHitChanceEffect) + .def("GetDamageModifier", &Lua_StatBonuses::GetDamageModifier) + .def("GetDamageModifier2", &Lua_StatBonuses::GetDamageModifier2) + .def("GetMinDamageModifier", &Lua_StatBonuses::GetMinDamageModifier) + .def("GetProcChance", &Lua_StatBonuses::GetProcChance) + .def("GetProcChanceSPA", &Lua_StatBonuses::GetProcChanceSPA) + .def("GetExtraAttackChance", &Lua_StatBonuses::GetExtraAttackChance) + .def("GetDoTShielding", &Lua_StatBonuses::GetDoTShielding) + .def("GetFlurryChance", &Lua_StatBonuses::GetFlurryChance) + .def("GetHundredHands", &Lua_StatBonuses::GetHundredHands) + .def("GetMeleeLifetap", &Lua_StatBonuses::GetMeleeLifetap) + .def("GetVampirism", &Lua_StatBonuses::GetVampirism) + .def("GetHealRate", &Lua_StatBonuses::GetHealRate) + .def("GetMaxHPChange", &Lua_StatBonuses::GetMaxHPChange) + .def("GetHealAmt", &Lua_StatBonuses::GetHealAmt) + .def("GetSpellDmg", &Lua_StatBonuses::GetSpellDmg) + .def("GetClairvoyance", &Lua_StatBonuses::GetClairvoyance) + .def("GetDSMitigation", &Lua_StatBonuses::GetDSMitigation) + .def("GetDSMitigationOffHand", &Lua_StatBonuses::GetDSMitigationOffHand) + .def("GetTwoHandBluntBlock", &Lua_StatBonuses::GetTwoHandBluntBlock) + .def("GetItemManaRegenCap", &Lua_StatBonuses::GetItemManaRegenCap) + .def("GetGravityEffect", &Lua_StatBonuses::GetGravityEffect) + .def("GetAntiGate", &Lua_StatBonuses::GetAntiGate) + .def("GetMagicWeapon", &Lua_StatBonuses::GetMagicWeapon) + .def("GetIncreaseBlockChance", &Lua_StatBonuses::GetIncreaseBlockChance) + .def("GetPersistantCasting", &Lua_StatBonuses::GetPersistantCasting) + .def("GetXPRateMod", &Lua_StatBonuses::GetXPRateMod) + .def("GetBlockNextSpell", &Lua_StatBonuses::GetBlockNextSpell) + .def("GetImmuneToFlee", &Lua_StatBonuses::GetImmuneToFlee) + .def("GetVoiceGraft", &Lua_StatBonuses::GetVoiceGraft) + .def("GetSpellProcChance", &Lua_StatBonuses::GetSpellProcChance) + .def("GetCharmBreakChance", &Lua_StatBonuses::GetCharmBreakChance) + .def("GetSongRange", &Lua_StatBonuses::GetSongRange) + .def("GetHPToManaConvert", &Lua_StatBonuses::GetHPToManaConvert) + .def("GetNegateEffects", &Lua_StatBonuses::GetNegateEffects) + .def("GetTriggerMeleeThreshold", &Lua_StatBonuses::GetTriggerMeleeThreshold) + .def("GetTriggerSpellThreshold", &Lua_StatBonuses::GetTriggerSpellThreshold) + .def("GetShieldBlock", &Lua_StatBonuses::GetShieldBlock) + .def("GetBlockBehind", &Lua_StatBonuses::GetBlockBehind) + .def("GetCriticalRegenDecay", &Lua_StatBonuses::GetCriticalRegenDecay) + .def("GetCriticalHealDecay", &Lua_StatBonuses::GetCriticalHealDecay) + .def("GetCriticalDotDecay", &Lua_StatBonuses::GetCriticalDotDecay) + .def("GetDivineAura", &Lua_StatBonuses::GetDivineAura) + .def("GetDistanceRemoval", &Lua_StatBonuses::GetDistanceRemoval) + .def("GetFrenziedDevastation", &Lua_StatBonuses::GetFrenziedDevastation) + .def("GetNegateIfCombat", &Lua_StatBonuses::GetNegateIfCombat) + .def("GetScreech", &Lua_StatBonuses::GetScreech) + .def("GetAlterNPCLevel", &Lua_StatBonuses::GetAlterNPCLevel) + .def("GetBerserkSPA", &Lua_StatBonuses::GetBerserkSPA) + .def("GetMetabolism", &Lua_StatBonuses::GetMetabolism) + .def("GetSanctuary", &Lua_StatBonuses::GetSanctuary) + .def("GetFactionModPct", &Lua_StatBonuses::GetFactionModPct) + .def("GetPC_Pet_Flurry", &Lua_StatBonuses::GetPC_Pet_Flurry) + .def("GetPackrat", &Lua_StatBonuses::GetPackrat) + .def("GetBuffSlotIncrease", &Lua_StatBonuses::GetBuffSlotIncrease) + .def("GetDelayDeath", &Lua_StatBonuses::GetDelayDeath) + .def("GetBaseMovementSpeed", &Lua_StatBonuses::GetBaseMovementSpeed) + .def("GetIncreaseRunSpeedCap", &Lua_StatBonuses::GetIncreaseRunSpeedCap) + .def("GetDoubleSpecialAttack", &Lua_StatBonuses::GetDoubleSpecialAttack) + .def("GetFrontalStunResist", &Lua_StatBonuses::GetFrontalStunResist) + .def("GetBindWound", &Lua_StatBonuses::GetBindWound) + .def("GetMaxBindWound", &Lua_StatBonuses::GetMaxBindWound) + .def("GetChannelChanceSpells", &Lua_StatBonuses::GetChannelChanceSpells) + .def("GetChannelChanceItems", &Lua_StatBonuses::GetChannelChanceItems) + .def("GetSeeInvis", &Lua_StatBonuses::GetSeeInvis) + .def("GetTripleBackstab", &Lua_StatBonuses::GetTripleBackstab) + .def("GetFrontalBackstabMinDmg", &Lua_StatBonuses::GetFrontalBackstabMinDmg) + .def("GetFrontalBackstabChance", &Lua_StatBonuses::GetFrontalBackstabChance) + .def("GetConsumeProjectile", &Lua_StatBonuses::GetConsumeProjectile) + .def("GetForageAdditionalItems", &Lua_StatBonuses::GetForageAdditionalItems) + .def("GetSalvageChance", &Lua_StatBonuses::GetSalvageChance) + .def("GetArcheryDamageModifier", &Lua_StatBonuses::GetArcheryDamageModifier) + .def("GetSecondaryDmgInc", &Lua_StatBonuses::GetSecondaryDmgInc) + .def("GetGiveDoubleAttack", &Lua_StatBonuses::GetGiveDoubleAttack) + .def("GetPetCriticalHit", &Lua_StatBonuses::GetPetCriticalHit) + .def("GetPetAvoidance", &Lua_StatBonuses::GetPetAvoidance) + .def("GetCombatStability", &Lua_StatBonuses::GetCombatStability) + .def("GetDoubleRiposte", &Lua_StatBonuses::GetDoubleRiposte) + .def("GetAmbidexterity", &Lua_StatBonuses::GetAmbidexterity) + .def("GetPetMaxHP", &Lua_StatBonuses::GetPetMaxHP) + .def("GetPetFlurry", &Lua_StatBonuses::GetPetFlurry) + .def("GetMasteryofPast", &Lua_StatBonuses::GetMasteryofPast) + .def("GetGivePetGroupTarget", &Lua_StatBonuses::GetGivePetGroupTarget) + .def("GetRootBreakChance", &Lua_StatBonuses::GetRootBreakChance) + .def("GetUnfailingDivinity", &Lua_StatBonuses::GetUnfailingDivinity) + .def("GetItemHPRegenCap", &Lua_StatBonuses::GetItemHPRegenCap) + .def("GetOffhandRiposteFail", &Lua_StatBonuses::GetOffhandRiposteFail) + .def("GetItemATKCap", &Lua_StatBonuses::GetItemATKCap) + .def("GetShieldEquipDmgMod", &Lua_StatBonuses::GetShieldEquipDmgMod) + .def("GetTriggerOnValueAmount", &Lua_StatBonuses::GetTriggerOnValueAmount) + .def("GetStunBashChance", &Lua_StatBonuses::GetStunBashChance) + .def("GetIncreaseChanceMemwipe", &Lua_StatBonuses::GetIncreaseChanceMemwipe) + .def("GetCriticalMend", &Lua_StatBonuses::GetCriticalMend) + .def("GetImprovedReclaimEnergy", &Lua_StatBonuses::GetImprovedReclaimEnergy) + .def("GetPetMeleeMitigation", &Lua_StatBonuses::GetPetMeleeMitigation) + .def("GetIllusionPersistence", &Lua_StatBonuses::GetIllusionPersistence) + .def("Getextra_xtargets", &Lua_StatBonuses::Getextra_xtargets) + .def("GetShroudofStealth", &Lua_StatBonuses::GetShroudofStealth) + .def("GetReduceFallDamage", &Lua_StatBonuses::GetReduceFallDamage) + .def("GetTradeSkillMastery", &Lua_StatBonuses::GetTradeSkillMastery) + .def("GetNoBreakAESneak", &Lua_StatBonuses::GetNoBreakAESneak) + .def("GetFeignedCastOnChance", &Lua_StatBonuses::GetFeignedCastOnChance) + .def("GetDivineSaveChance", &Lua_StatBonuses::GetDivineSaveChance) + .def("GetDeathSave", &Lua_StatBonuses::GetDeathSave) + .def("GetAccuracy", &Lua_StatBonuses::GetAccuracy) + .def("GetSkillDmgTaken", &Lua_StatBonuses::GetSkillDmgTaken) + .def("GetSpellTriggers", &Lua_StatBonuses::GetSpellTriggers) + .def("GetSpellOnKill", &Lua_StatBonuses::GetSpellOnKill) + .def("GetSpellOnDeath", &Lua_StatBonuses::GetSpellOnDeath) + .def("GetCritDmgMob", &Lua_StatBonuses::GetCritDmgMob) + .def("GetSkillReuseTime", &Lua_StatBonuses::GetSkillReuseTime) + .def("GetSkillDamageAmount", &Lua_StatBonuses::GetSkillDamageAmount) + .def("GetHPPercCap", &Lua_StatBonuses::GetHPPercCap) + .def("GetManaPercCap", &Lua_StatBonuses::GetManaPercCap) + .def("GetEndPercCap", &Lua_StatBonuses::GetEndPercCap) + .def("GetFocusEffects", &Lua_StatBonuses::GetFocusEffects) + .def("GetFocusEffectsWorn", &Lua_StatBonuses::GetFocusEffectsWorn) + .def("GetSkillDamageAmount2", &Lua_StatBonuses::GetSkillDamageAmount2) + .def("GetNegateAttacks", &Lua_StatBonuses::GetNegateAttacks) + .def("GetMitigateMeleeRune", &Lua_StatBonuses::GetMitigateMeleeRune) + .def("GetMeleeThresholdGuard", &Lua_StatBonuses::GetMeleeThresholdGuard) + .def("GetSpellThresholdGuard", &Lua_StatBonuses::GetSpellThresholdGuard) + .def("GetMitigateSpellRune", &Lua_StatBonuses::GetMitigateSpellRune) + .def("GetMitigateDotRune", &Lua_StatBonuses::GetMitigateDotRune) + .def("GetManaAbsorbPercentDamage", &Lua_StatBonuses::GetManaAbsorbPercentDamage) + .def("GetImprovedTaunt", &Lua_StatBonuses::GetImprovedTaunt) + .def("GetRoot", &Lua_StatBonuses::GetRoot) + .def("GetAbsorbMagicAtt", &Lua_StatBonuses::GetAbsorbMagicAtt) + .def("GetMeleeRune", &Lua_StatBonuses::GetMeleeRune) + .def("GetAStacker", &Lua_StatBonuses::GetAStacker) + .def("GetBStacker", &Lua_StatBonuses::GetBStacker) + .def("GetCStacker", &Lua_StatBonuses::GetCStacker) + .def("GetDStacker", &Lua_StatBonuses::GetDStacker) + .def("GetLimitToSkill", &Lua_StatBonuses::GetLimitToSkill) + .def("GetSkillProc", &Lua_StatBonuses::GetSkillProc) + .def("GetSkillProcSuccess", &Lua_StatBonuses::GetSkillProcSuccess) + .def("GetPC_Pet_Rampage", &Lua_StatBonuses::GetPC_Pet_Rampage) + .def("GetSkillAttackProc", &Lua_StatBonuses::GetSkillAttackProc) + .def("GetSlayUndead", &Lua_StatBonuses::GetSlayUndead) + .def("GetGiveDoubleRiposte", &Lua_StatBonuses::GetGiveDoubleRiposte) + .def("GetRaiseSkillCap", &Lua_StatBonuses::GetRaiseSkillCap) + .def("GetSEResist", &Lua_StatBonuses::GetSEResist) + .def("GetFinishingBlow", &Lua_StatBonuses::GetFinishingBlow) + .def("GetFinishingBlowLvl", &Lua_StatBonuses::GetFinishingBlowLvl) + .def("GetHeadShot", &Lua_StatBonuses::GetHeadShot) + .def("GetHSLevel", &Lua_StatBonuses::GetHSLevel) + .def("GetAssassinate", &Lua_StatBonuses::GetAssassinate) + .def("GetAssassinateLevel", &Lua_StatBonuses::GetAssassinateLevel) + .def("GetReduceTradeskillFail", &Lua_StatBonuses::GetReduceTradeskillFail); +} \ No newline at end of file diff --git a/zone/lua_stat_bonuses.h b/zone/lua_stat_bonuses.h new file mode 100644 index 000000000..52aa53f8c --- /dev/null +++ b/zone/lua_stat_bonuses.h @@ -0,0 +1,285 @@ +#pragma once + +#ifdef LUA_EQEMU + +#include "lua_ptr.h" +#include "common.h" + +struct StatBonuses; + +namespace luabind { + struct scope; +} + +luabind::scope lua_register_stat_bonuses(); + +class Lua_StatBonuses : public Lua_Ptr +{ + typedef StatBonuses NativeType; +public: + Lua_StatBonuses() : Lua_Ptr(nullptr) { } + Lua_StatBonuses(StatBonuses *d) : Lua_Ptr(d) { } + virtual ~Lua_StatBonuses() { } + + operator StatBonuses*() { + return reinterpret_cast(GetLuaPtrData()); + } + + int32 GetAC() const; + int32 GetHP() const; + int32 GetHPRegen() const; + int32 GetMaxHP() const; + int32 GetManaRegen() const; + int32 GetEnduranceRegen() const; + int32 GetMana() const; + int32 GetEndurance() const; + int32 GetATK() const; + int32 GetSTR() const; + int32 GetSTRCapMod() const; + int32 GetHeroicSTR() const; + int32 GetSTA() const; + int32 GetSTACapMod() const; + int32 GetHeroicSTA() const; + int32 GetDEX() const; + int32 GetDEXCapMod() const; + int32 GetHeroicDEX() const; + int32 GetAGI() const; + int32 GetAGICapMod() const; + int32 GetHeroicAGI() const; + int32 GetINT() const; + int32 GetINTCapMod() const; + int32 GetHeroicINT() const; + int32 GetWIS() const; + int32 GetWISCapMod() const; + int32 GetHeroicWIS() const; + int32 GetCHA() const; + int32 GetCHACapMod() const; + int32 GetHeroicCHA() const; + int32 GetMR() const; + int32 GetMRCapMod() const; + int32 GetHeroicMR() const; + int32 GetFR() const; + int32 GetFRCapMod() const; + int32 GetHeroicFR() const; + int32 GetCR() const; + int32 GetCRCapMod() const; + int32 GetHeroicCR() const; + int32 GetPR() const; + int32 GetPRCapMod() const; + int32 GetHeroicPR() const; + int32 GetDR() const; + int32 GetDRCapMod() const; + int32 GetHeroicDR() const; + int32 GetCorrup() const; + int32 GetCorrupCapMod() const; + int32 GetHeroicCorrup() const; + uint16 GetDamageShieldSpellID() const; + int GetDamageShield() const; + int GetDamageShieldType() const; + int GetSpellDamageShield() const; + int GetSpellShield() const; + int GetReverseDamageShield() const; + uint16 GetReverseDamageShieldSpellID() const; + int GetReverseDamageShieldType() const; + int Getmovementspeed() const; + int32 Gethaste() const; + int32 Gethastetype2() const; + int32 Gethastetype3() const; + int32 Getinhibitmelee() const; + float GetAggroRange() const; + float GetAssistRange() const; + int32 Getskillmod(int idx) const; + int32 Getskillmodmax(int idx) const; + int Geteffective_casting_level() const; + int Getreflect_chance() const; + uint32 GetsingingMod() const; + uint32 GetAmplification() const; + uint32 GetbrassMod() const; + uint32 GetpercussionMod() const; + uint32 GetwindMod() const; + uint32 GetstringedMod() const; + uint32 GetsongModCap() const; + int8 Gethatemod() const; + int32 GetEnduranceReduction() const; + int32 GetStrikeThrough() const; + int32 GetMeleeMitigation() const; + int32 GetMeleeMitigationEffect() const; + int32 GetCriticalHitChance(int idx) const; + int32 GetCriticalSpellChance() const; + int32 GetSpellCritDmgIncrease() const; + int32 GetSpellCritDmgIncNoStack() const; + int32 GetDotCritDmgIncrease() const; + int32 GetCriticalHealChance() const; + int32 GetCriticalHealOverTime() const; + int32 GetCriticalDoTChance() const; + int32 GetCrippBlowChance() const; + int32 GetAvoidMeleeChance() const; + int32 GetAvoidMeleeChanceEffect() const; + int32 GetRiposteChance() const; + int32 GetDodgeChance() const; + int32 GetParryChance() const; + int32 GetDualWieldChance() const; + int32 GetDoubleAttackChance() const; + int32 GetTripleAttackChance() const; + int32 GetDoubleRangedAttack() const; + int32 GetResistSpellChance() const; + int32 GetResistFearChance() const; + bool GetFearless() const; + bool GetIsFeared() const; + bool GetIsBlind() const; + int32 GetStunResist() const; + int32 GetMeleeSkillCheck() const; + uint8 GetMeleeSkillCheckSkill() const; + int32 GetHitChance() const; + int32 GetHitChanceEffect(int idx) const; + int32 GetDamageModifier(int idx) const; + int32 GetDamageModifier2(int idx) const; + int32 GetMinDamageModifier(int idx) const; + int32 GetProcChance() const; + int32 GetProcChanceSPA() const; + int32 GetExtraAttackChance() const; + int32 GetDoTShielding() const; + int32 GetFlurryChance() const; + int32 GetHundredHands() const; + int32 GetMeleeLifetap() const; + int32 GetVampirism() const; + int32 GetHealRate() const; + int32 GetMaxHPChange() const; + int32 GetHealAmt() const; + int32 GetSpellDmg() const; + int32 GetClairvoyance() const; + int32 GetDSMitigation() const; + int32 GetDSMitigationOffHand() const; + int32 GetTwoHandBluntBlock() const; + uint32 GetItemManaRegenCap() const; + int32 GetGravityEffect() const; + bool GetAntiGate() const; + bool GetMagicWeapon() const; + int32 GetIncreaseBlockChance() const; + uint32 GetPersistantCasting() const; + int GetXPRateMod() const; + bool GetBlockNextSpell() const; + bool GetImmuneToFlee() const; + uint32 GetVoiceGraft() const; + int32 GetSpellProcChance() const; + int32 GetCharmBreakChance() const; + int32 GetSongRange() const; + uint32 GetHPToManaConvert() const; + bool GetNegateEffects() const; + bool GetTriggerMeleeThreshold() const; + bool GetTriggerSpellThreshold() const; + int32 GetShieldBlock() const; + int32 GetBlockBehind() const; + bool GetCriticalRegenDecay() const; + bool GetCriticalHealDecay() const; + bool GetCriticalDotDecay() const; + bool GetDivineAura() const; + bool GetDistanceRemoval() const; + int32 GetFrenziedDevastation() const; + bool GetNegateIfCombat() const; + int8 GetScreech() const; + int32 GetAlterNPCLevel() const; + bool GetBerserkSPA() const; + int32 GetMetabolism() const; + bool GetSanctuary() const; + int32 GetFactionModPct() const; + uint32 GetPC_Pet_Flurry() const; + int8 GetPackrat() const; + uint8 GetBuffSlotIncrease() const; + uint32 GetDelayDeath() const; + int8 GetBaseMovementSpeed() const; + uint8 GetIncreaseRunSpeedCap() const; + int32 GetDoubleSpecialAttack() const; + uint8 GetFrontalStunResist() const; + int32 GetBindWound() const; + int32 GetMaxBindWound() const; + int32 GetChannelChanceSpells() const; + int32 GetChannelChanceItems() const; + uint8 GetSeeInvis() const; + uint8 GetTripleBackstab() const; + bool GetFrontalBackstabMinDmg() const; + uint8 GetFrontalBackstabChance() const; + uint8 GetConsumeProjectile() const; + uint8 GetForageAdditionalItems() const; + uint8 GetSalvageChance() const; + uint32 GetArcheryDamageModifier() const; + bool GetSecondaryDmgInc() const; + uint32 GetGiveDoubleAttack() const; + int32 GetPetCriticalHit() const; + int32 GetPetAvoidance() const; + int32 GetCombatStability() const; + int32 GetDoubleRiposte() const; + int32 GetAmbidexterity() const; + int32 GetPetMaxHP() const; + int32 GetPetFlurry() const; + uint8 GetMasteryofPast() const; + bool GetGivePetGroupTarget() const; + int32 GetRootBreakChance() const; + int32 GetUnfailingDivinity() const; + int32 GetItemHPRegenCap() const; + int32 GetOffhandRiposteFail() const; + int32 GetItemATKCap() const; + int32 GetShieldEquipDmgMod() const; + bool GetTriggerOnValueAmount() const; + int8 GetStunBashChance() const; + int8 GetIncreaseChanceMemwipe() const; + int8 GetCriticalMend() const; + int32 GetImprovedReclaimEnergy() const; + int32 GetPetMeleeMitigation() const; + bool GetIllusionPersistence() const; + uint16 Getextra_xtargets() const; + bool GetShroudofStealth() const; + uint16 GetReduceFallDamage() const; + uint8 GetTradeSkillMastery() const; + int16 GetNoBreakAESneak() const; + int16 GetFeignedCastOnChance() const; + int32 GetDivineSaveChance(int idx) const; + uint32 GetDeathSave(int idx) const; + int32 GetAccuracy(int idx) const; + int16 GetSkillDmgTaken(int idx) const; + uint32 GetSpellTriggers(int idx) const; + uint32 GetSpellOnKill(int idx) const; + uint32 GetSpellOnDeath(int idx) const; + int32 GetCritDmgMob(int idx) const; + int32 GetSkillReuseTime(int idx) const; + int32 GetSkillDamageAmount(int idx) const; + int GetHPPercCap(int idx) const; + int GetManaPercCap(int idx) const; + int GetEndPercCap(int idx) const; + uint8 GetFocusEffects(int idx) const; + int16 GetFocusEffectsWorn(int idx) const; + int32 GetSkillDamageAmount2(int idx) const; + uint32 GetNegateAttacks(int idx) const; + uint32 GetMitigateMeleeRune(int idx) const; + uint32 GetMeleeThresholdGuard(int idx) const; + uint32 GetSpellThresholdGuard(int idx) const; + uint32 GetMitigateSpellRune(int idx) const; + uint32 GetMitigateDotRune(int idx) const; + uint32 GetManaAbsorbPercentDamage(int idx) const; + int32 GetImprovedTaunt(int idx) const; + int8 GetRoot(int idx) const; + uint32 GetAbsorbMagicAtt(int idx) const; + uint32 GetMeleeRune(int idx) const; + int32 GetAStacker(int idx) const; + int32 GetBStacker(int idx) const; + int32 GetCStacker(int idx) const; + int32 GetDStacker(int idx) const; + bool GetLimitToSkill(int idx) const; + uint32 GetSkillProc(int idx) const; + uint32 GetSkillProcSuccess(int idx) const; + uint32 GetPC_Pet_Rampage(int idx) const; + int32 GetSkillAttackProc(int idx) const; + int32 GetSlayUndead(int idx) const; + int32 GetGiveDoubleRiposte(int idx) const; + uint32 GetRaiseSkillCap(int idx) const; + int32 GetSEResist(int idx) const; + int32 GetFinishingBlow(int idx) const; + uint32 GetFinishingBlowLvl(int idx) const; + uint32 GetHeadShot(int idx) const; + uint8 GetHSLevel(int idx) const; + uint32 GetAssassinate(int idx) const; + uint8 GetAssassinateLevel(int idx) const; + int32 GetReduceTradeskillFail(int idx) const; +}; + +#endif diff --git a/zone/mob.h b/zone/mob.h index 4d43a9572..f280f5600 100644 --- a/zone/mob.h +++ b/zone/mob.h @@ -446,6 +446,9 @@ public: inline StatBonuses GetItemBonuses() const { return itembonuses; } inline StatBonuses GetSpellBonuses() const { return spellbonuses; } inline StatBonuses GetAABonuses() const { return aabonuses; } + inline StatBonuses* GetItemBonusesPtr() { return &itembonuses; } + inline StatBonuses* GetSpellBonusesPtr() { return &spellbonuses; } + inline StatBonuses* GetAABonusesPtr() { return &aabonuses; } inline virtual int32 GetMaxSTR() const { return GetSTR(); } inline virtual int32 GetMaxSTA() const { return GetSTA(); } inline virtual int32 GetMaxDEX() const { return GetDEX(); }