diff --git a/zone/CMakeLists.txt b/zone/CMakeLists.txt index 798114399..dd9ef09d7 100644 --- a/zone/CMakeLists.txt +++ b/zone/CMakeLists.txt @@ -79,6 +79,7 @@ SET(zone_sources lua_spawn.cpp lua_spell.cpp lua_stat_bonuses.cpp + lua_zone.cpp embperl.cpp entity.cpp exp.cpp @@ -131,6 +132,7 @@ SET(zone_sources perl_spawn.cpp perl_spell.cpp perl_stat_bonuses.cpp + perl_zone.cpp perlpacket.cpp petitions.cpp pets.cpp @@ -244,6 +246,7 @@ SET(zone_headers lua_spawn.h lua_spell.h lua_stat_bonuses.h + lua_zone.h map.h masterentity.h merc.h diff --git a/zone/embparser.cpp b/zone/embparser.cpp index 55cf1a4ce..e42022146 100644 --- a/zone/embparser.cpp +++ b/zone/embparser.cpp @@ -59,6 +59,7 @@ void perl_register_bot(); void perl_register_buff(); void perl_register_merc(); void perl_register_database(); +void perl_register_zone(); #endif // EMBPERL_XS_CLASSES #endif // EMBPERL_XS @@ -1187,6 +1188,7 @@ void PerlembParser::MapFunctions() perl_register_buff(); perl_register_merc(); perl_register_database(); + perl_register_zone(); #endif // EMBPERL_XS_CLASSES } @@ -1579,6 +1581,7 @@ void PerlembParser::ExportZoneVariables(std::string& package_name) ExportVar(package_name.c_str(), "instanceversion", zone->GetInstanceVersion()); TimeOfDay_Struct eqTime{ }; zone->zone_time.GetCurrentEQTimeOfDay(time(0), &eqTime); + ExportVar(package_name.c_str(), "zone", "Zone", zone); ExportVar(package_name.c_str(), "zonehour", eqTime.hour - 1); ExportVar(package_name.c_str(), "zoneid", zone->GetZoneID()); ExportVar(package_name.c_str(), "zoneln", zone->GetLongName()); diff --git a/zone/lua_general.cpp b/zone/lua_general.cpp index bc1b04416..bc76bb38d 100644 --- a/zone/lua_general.cpp +++ b/zone/lua_general.cpp @@ -18,6 +18,7 @@ #include "lua_entity_list.h" #include "lua_expedition.h" #include "lua_spell.h" +#include "lua_zone.h" #include "quest_parser_collection.h" #include "questmgr.h" #include "qglobals.h" @@ -28,6 +29,7 @@ #include "dialogue_window.h" #include "../common/events/player_event_logs.h" #include "worldserver.h" +#include "zone.h" struct Events { }; struct Factions { }; @@ -5635,6 +5637,11 @@ void lua_spawn_grid(uint32 npc_id, float x, float y, float z, float heading, flo quest_manager.SpawnGrid(npc_id, glm::vec4(x, y, z, heading), spacing, spawn_count); } +Lua_Zone lua_get_zone() +{ + return Lua_Zone(zone); +} + #define LuaCreateNPCParse(name, c_type, default_value) do { \ cur = table[#name]; \ if(luabind::type(cur) != LUA_TNIL) { \ @@ -6442,6 +6449,7 @@ luabind::scope lua_register_general() { luabind::def("are_tasks_completed", &lua_are_tasks_completed), luabind::def("spawn_circle", &lua_spawn_circle), luabind::def("spawn_grid", &lua_spawn_grid), + luabind::def("get_zone", &lua_get_zone), /* Cross Zone */ diff --git a/zone/lua_parser.cpp b/zone/lua_parser.cpp index 6f624f149..050657bbc 100644 --- a/zone/lua_parser.cpp +++ b/zone/lua_parser.cpp @@ -43,6 +43,7 @@ #include "lua_spell.h" #include "lua_stat_bonuses.h" #include "lua_database.h" +#include "lua_zone.h" const char *LuaEvents[_LargestEventID] = { "event_say", @@ -1320,7 +1321,8 @@ void LuaParser::MapFunctions(lua_State *L) { lua_register_expedition_lock_messages(), lua_register_buff(), lua_register_exp_source(), - lua_register_database() + lua_register_database(), + lua_register_zone() )]; } catch(std::exception &ex) { diff --git a/zone/lua_zone.cpp b/zone/lua_zone.cpp new file mode 100644 index 000000000..21d45b213 --- /dev/null +++ b/zone/lua_zone.cpp @@ -0,0 +1,805 @@ +#include "../common/features.h" +#include "zone.h" + + +#include +#include "../common/global_define.h" +#include "embperl.h" +#include "lua_zone.h" + +bool Lua_Zone::BuffTimersSuspended() +{ + Lua_Safe_Call_Bool(); + return self->BuffTimersSuspended(); +} + +bool Lua_Zone::BypassesExpansionCheck() +{ + Lua_Safe_Call_Bool(); + return zone_store.GetZoneBypassExpansionCheck(self->GetZoneID(), self->GetInstanceVersion()); +} + +bool Lua_Zone::CanBind() +{ + Lua_Safe_Call_Bool(); + return self->CanBind(); +} + +bool Lua_Zone::CanCastOutdoor() +{ + Lua_Safe_Call_Bool(); + return self->CanCastOutdoor(); +} + +bool Lua_Zone::CanDoCombat() +{ + Lua_Safe_Call_Bool(); + return self->CanDoCombat(); +} + +bool Lua_Zone::CanLevitate() +{ + Lua_Safe_Call_Bool(); + return self->CanLevitate(); +} + +void Lua_Zone::ClearSpawnTimers() +{ + Lua_Safe_Call_Void(); + self->ClearSpawnTimers(); +} + +void Lua_Zone::Depop() +{ + Lua_Safe_Call_Void(); + self->Depop(); +} + +void Lua_Zone::Depop(bool start_spawn_timers) +{ + Lua_Safe_Call_Void(); + self->Depop(start_spawn_timers); +} + +void Lua_Zone::Despawn(uint32 spawngroup_id) +{ + Lua_Safe_Call_Void(); + self->Despawn(spawngroup_id); +} + +float Lua_Zone::GetAAEXPModifier(Lua_Client c) +{ + Lua_Safe_Call_Real(); + return self->GetAAEXPModifier(c); +} + +float Lua_Zone::GetAAEXPModifierByCharacterID(uint32 character_id) +{ + Lua_Safe_Call_Real(); + return self->GetAAEXPModifierByCharacterID(character_id); +} + +std::string Lua_Zone::GetContentFlags() +{ + Lua_Safe_Call_String(); + return zone_store.GetZoneContentFlags(self->GetZoneID(), self->GetInstanceVersion()); +} + +std::string Lua_Zone::GetContentFlagsDisabled() +{ + Lua_Safe_Call_String(); + return zone_store.GetZoneContentFlagsDisabled(self->GetZoneID(), self->GetInstanceVersion()); +} + +float Lua_Zone::GetExperienceMultiplier() +{ + Lua_Safe_Call_Real(); + return zone_store.GetZoneExperienceMultiplier(self->GetZoneID(), self->GetInstanceVersion()); +} + +int8 Lua_Zone::GetExpansion() +{ + Lua_Safe_Call_Int(); + return zone_store.GetZoneExpansion(self->GetZoneID(), self->GetInstanceVersion()); +} + +float Lua_Zone::GetEXPModifier(Lua_Client c) +{ + Lua_Safe_Call_Real(); + return self->GetEXPModifier(c); +} + +float Lua_Zone::GetEXPModifierByCharacterID(uint32 character_id) +{ + Lua_Safe_Call_Real(); + return self->GetEXPModifierByCharacterID(character_id); +} + +int Lua_Zone::GetFastRegenEndurance() +{ + Lua_Safe_Call_Int(); + return zone_store.GetZoneFastRegenEndurance(self->GetZoneID(), self->GetInstanceVersion()); +} + +int Lua_Zone::GetFastRegenHP() +{ + Lua_Safe_Call_Int(); + return zone_store.GetZoneFastRegenHP(self->GetZoneID(), self->GetInstanceVersion()); +} + +int Lua_Zone::GetFastRegenMana() +{ + Lua_Safe_Call_Int(); + return zone_store.GetZoneFastRegenMana(self->GetZoneID(), self->GetInstanceVersion()); +} + +std::string Lua_Zone::GetFileName() +{ + Lua_Safe_Call_String(); + return self->GetFileName(); +} + +std::string Lua_Zone::GetFlagNeeded() +{ + Lua_Safe_Call_String(); + return zone_store.GetZoneFlagNeeded(self->GetZoneID(), self->GetInstanceVersion()); +} + +uint8 Lua_Zone::GetFogBlue() +{ + Lua_Safe_Call_Int(); + return zone_store.GetZoneFogBlue(self->GetZoneID(), 0, self->GetInstanceVersion()); +} + +uint8 Lua_Zone::GetFogBlue(uint8 slot) +{ + Lua_Safe_Call_Int(); + return zone_store.GetZoneFogBlue(self->GetZoneID(), slot, self->GetInstanceVersion()); +} + +float Lua_Zone::GetFogDensity() +{ + Lua_Safe_Call_Real(); + return zone_store.GetZoneFogDensity(self->GetZoneID(), self->GetInstanceVersion()); +} + +uint8 Lua_Zone::GetFogGreen() +{ + Lua_Safe_Call_Int(); + return zone_store.GetZoneFogGreen(self->GetZoneID(), 0, self->GetInstanceVersion()); +} + +uint8 Lua_Zone::GetFogGreen(uint8 slot) +{ + Lua_Safe_Call_Int(); + return zone_store.GetZoneFogGreen(self->GetZoneID(), slot, self->GetInstanceVersion()); +} + +float Lua_Zone::GetFogMaximumClip() +{ + Lua_Safe_Call_Real(); + return zone_store.GetZoneFogMaximumClip(self->GetZoneID(), 0, self->GetInstanceVersion()); +} + +float Lua_Zone::GetFogMaximumClip(uint8 slot) +{ + Lua_Safe_Call_Real(); + return zone_store.GetZoneFogMaximumClip(self->GetZoneID(), slot, self->GetInstanceVersion()); +} + +float Lua_Zone::GetFogMinimumClip() +{ + Lua_Safe_Call_Real(); + return zone_store.GetZoneFogMinimumClip(self->GetZoneID(), 0, self->GetInstanceVersion()); +} + +float Lua_Zone::GetFogMinimumClip(uint8 slot) +{ + Lua_Safe_Call_Real(); + return zone_store.GetZoneFogMinimumClip(self->GetZoneID(), slot, self->GetInstanceVersion()); +} + +uint8 Lua_Zone::GetFogRed() +{ + Lua_Safe_Call_Int(); + return zone_store.GetZoneFogRed(self->GetZoneID(), 0, self->GetInstanceVersion()); +} + +uint8 Lua_Zone::GetFogRed(uint8 slot) +{ + Lua_Safe_Call_Int(); + return zone_store.GetZoneFogRed(self->GetZoneID(), slot, self->GetInstanceVersion()); +} + +float Lua_Zone::GetGraveyardHeading() +{ + Lua_Safe_Call_Real(); + return self->GetGraveyardPoint().w; +} + +uint32 Lua_Zone::GetGraveyardID() +{ + Lua_Safe_Call_Int(); + return self->graveyard_id(); +} + +float Lua_Zone::GetGraveyardX() +{ + Lua_Safe_Call_Real(); + return self->GetGraveyardPoint().x; +} + +float Lua_Zone::GetGraveyardY() +{ + Lua_Safe_Call_Real(); + return self->GetGraveyardPoint().y; +} + +float Lua_Zone::GetGraveyardZ() +{ + Lua_Safe_Call_Real(); + return self->GetGraveyardPoint().z; +} + +uint32 Lua_Zone::GetGraveyardZoneID() +{ + Lua_Safe_Call_Int(); + return self->graveyard_zoneid(); +} + +float Lua_Zone::GetGravity() +{ + Lua_Safe_Call_Real(); + return zone_store.GetZoneGravity(self->GetZoneID(), self->GetInstanceVersion()); +} + +uint32 Lua_Zone::GetInstanceID() +{ + Lua_Safe_Call_Int(); + return self->GetInstanceID(); +} + +uint8 Lua_Zone::GetInstanceType() +{ + Lua_Safe_Call_Int(); + return zone_store.GetZoneInstanceType(self->GetZoneID(), self->GetInstanceVersion()); +} + +uint16 Lua_Zone::GetInstanceVersion() +{ + Lua_Safe_Call_Int(); + return self->GetInstanceVersion(); +} + +uint32 Lua_Zone::GetInstanceTimeRemaining() +{ + Lua_Safe_Call_Int(); + return self->GetInstanceTimeRemaining(); +} + +int Lua_Zone::GetLavaDamage() +{ + Lua_Safe_Call_Int(); + return zone_store.GetZoneLavaDamage(self->GetZoneID(), self->GetInstanceVersion()); +} + +std::string Lua_Zone::GetLongName() +{ + Lua_Safe_Call_String(); + return self->GetLongName(); +} + +float Lua_Zone::GetMaximumClip() +{ + Lua_Safe_Call_Real(); + return zone_store.GetZoneMaximumClip(self->GetZoneID(), self->GetInstanceVersion()); +} + +int8 Lua_Zone::GetMaximumExpansion() +{ + Lua_Safe_Call_Int(); + return zone_store.GetZoneMaximumExpansion(self->GetZoneID(), self->GetInstanceVersion()); +} + +uint8 Lua_Zone::GetMaximumLevel() +{ + Lua_Safe_Call_Int(); + return zone_store.GetZoneMaximumLevel(self->GetZoneID(), self->GetInstanceVersion()); +} + +uint32 Lua_Zone::GetMaxClients() +{ + Lua_Safe_Call_Int(); + return self->GetMaxClients(); +} + +float Lua_Zone::GetMinimumClip() +{ + Lua_Safe_Call_Int(); + return zone_store.GetZoneMinimumClip(self->GetZoneID(), self->GetInstanceVersion()); +} + +int8 Lua_Zone::GetMinimumExpansion() +{ + Lua_Safe_Call_Int(); + return zone_store.GetZoneMinimumExpansion(self->GetZoneID(), self->GetInstanceVersion()); +} + +uint8 Lua_Zone::GetMinimumLevel() +{ + Lua_Safe_Call_Int(); + return zone_store.GetZoneMinimumLevel(self->GetZoneID(), self->GetInstanceVersion()); +} + +int Lua_Zone::GetMinimumLavaDamage() +{ + Lua_Safe_Call_Int(); + return zone_store.GetZoneMinimumLavaDamage(self->GetZoneID(), self->GetInstanceVersion()); +} + +uint8 Lua_Zone::GetMinimumStatus() +{ + Lua_Safe_Call_Int(); + return zone_store.GetZoneMinimumStatus(self->GetZoneID(), self->GetInstanceVersion()); +} + +std::string Lua_Zone::GetNote() +{ + Lua_Safe_Call_String(); + return zone_store.GetZoneNote(self->GetZoneID(), self->GetInstanceVersion()); +} + +int Lua_Zone::GetNPCMaximumAggroDistance() +{ + Lua_Safe_Call_Int(); + return zone_store.GetZoneNPCMaximumAggroDistance(self->GetZoneID(), self->GetInstanceVersion()); +} + +int8 Lua_Zone::GetPEQZone() +{ + Lua_Safe_Call_Int(); + return zone_store.GetZonePEQZone(self->GetZoneID(), self->GetInstanceVersion()); +} + +int Lua_Zone::GetRainChance() +{ + Lua_Safe_Call_Int(); + return zone_store.GetZoneRainChance(self->GetZoneID(), 0, self->GetInstanceVersion()); +} + +int Lua_Zone::GetRainChance(uint8 slot) +{ + Lua_Safe_Call_Int(); + return zone_store.GetZoneRainChance(self->GetZoneID(), slot, self->GetInstanceVersion()); +} + +int Lua_Zone::GetRainDuration() +{ + Lua_Safe_Call_Int(); + return zone_store.GetZoneRainDuration(self->GetZoneID(), 0, self->GetInstanceVersion()); +} + +int Lua_Zone::GetRainDuration(uint8 slot) +{ + Lua_Safe_Call_Int(); + return zone_store.GetZoneRainDuration(self->GetZoneID(), slot, self->GetInstanceVersion()); +} + +uint32 Lua_Zone::GetRuleSet() +{ + Lua_Safe_Call_Int(); + return zone_store.GetZoneRuleSet(self->GetZoneID(), self->GetInstanceVersion()); +} + +float Lua_Zone::GetSafeHeading() +{ + Lua_Safe_Call_Real(); + return self->GetSafePoint().w; +} + +float Lua_Zone::GetSafeX() +{ + Lua_Safe_Call_Real(); + return self->GetSafePoint().x; +} + +float Lua_Zone::GetSafeY() +{ + Lua_Safe_Call_Real(); + return self->GetSafePoint().y; +} + +float Lua_Zone::GetSafeZ() +{ + Lua_Safe_Call_Real(); + return self->GetSafePoint().z; +} + +std::string Lua_Zone::GetShortName() +{ + Lua_Safe_Call_String(); + return self->GetShortName(); +} + +uint32 Lua_Zone::GetSecondsBeforeIdle() +{ + Lua_Safe_Call_Int(); + return self->GetSecondsBeforeIdle(); +} + +uint64 Lua_Zone::GetShutdownDelay() +{ + Lua_Safe_Call_Int(); + return zone_store.GetZoneShutdownDelay(self->GetZoneID(), self->GetInstanceVersion()); +} + +uint8 Lua_Zone::GetSky() +{ + Lua_Safe_Call_Int(); + return zone_store.GetZoneSky(self->GetZoneID(), self->GetInstanceVersion()); +} + +int8 Lua_Zone::GetSkyLock() +{ + Lua_Safe_Call_Int(); + return zone_store.GetZoneSkyLock(self->GetZoneID(), self->GetInstanceVersion()); +} + +int Lua_Zone::GetSnowChance() +{ + Lua_Safe_Call_Int(); + return zone_store.GetZoneSnowChance(self->GetZoneID(), 0, self->GetInstanceVersion()); +} + +int Lua_Zone::GetSnowChance(uint8 slot) +{ + Lua_Safe_Call_Int(); + return zone_store.GetZoneSnowChance(self->GetZoneID(), slot, self->GetInstanceVersion()); +} + +int Lua_Zone::GetSnowDuration() +{ + Lua_Safe_Call_Int(); + return zone_store.GetZoneSnowDuration(self->GetZoneID(), 0, self->GetInstanceVersion()); +} + +int Lua_Zone::GetSnowDuration(uint8 slot) +{ + Lua_Safe_Call_Int(); + return zone_store.GetZoneSnowDuration(self->GetZoneID(), slot, self->GetInstanceVersion()); +} + +uint8 Lua_Zone::GetTimeType() +{ + Lua_Safe_Call_Int(); + return zone_store.GetZoneTimeType(self->GetZoneID(), self->GetInstanceVersion()); +} + +int Lua_Zone::GetTimeZone() +{ + Lua_Safe_Call_Int(); + return zone_store.GetZoneTimeZone(self->GetZoneID(), self->GetInstanceVersion()); +} + +std::string Lua_Zone::GetZoneDescription() +{ + Lua_Safe_Call_String(); + return self->GetZoneDescription(); +} + +uint32 Lua_Zone::GetZoneID() +{ + Lua_Safe_Call_Int(); + return self->GetZoneID(); +} + +uint8 Lua_Zone::GetZoneType() +{ + Lua_Safe_Call_Int(); + return self->GetZoneType(); +} + +float Lua_Zone::GetUnderworld() +{ + Lua_Safe_Call_Real(); + return zone_store.GetZoneUnderworld(self->GetZoneID(), self->GetInstanceVersion()); +} + +int Lua_Zone::GetUnderworldTeleportIndex() +{ + Lua_Safe_Call_Int(); + return zone_store.GetZoneUnderworldTeleportIndex(self->GetZoneID(), self->GetInstanceVersion()); +} + +float Lua_Zone::GetWalkSpeed() +{ + Lua_Safe_Call_Real(); + return zone_store.GetZoneWalkSpeed(self->GetZoneID(), self->GetInstanceVersion()); +} + +uint8 Lua_Zone::GetZoneZType() +{ + Lua_Safe_Call_Int(); + return zone_store.GetZoneZType(self->GetZoneID(), self->GetInstanceVersion()); +} + +int Lua_Zone::GetZoneTotalBlockedSpells() +{ + Lua_Safe_Call_Int(); + return self->GetZoneTotalBlockedSpells(); +} + +bool Lua_Zone::HasGraveyard() +{ + Lua_Safe_Call_Bool(); + return self->HasGraveyard(); +} + +bool Lua_Zone::HasMap() +{ + Lua_Safe_Call_Bool(); + return self->HasMap(); +} + +bool Lua_Zone::HasWaterMap() +{ + Lua_Safe_Call_Bool(); + return self->HasWaterMap(); +} + +bool Lua_Zone::HasWeather() +{ + Lua_Safe_Call_Bool(); + return self->HasWeather(); +} + +bool Lua_Zone::IsCity() +{ + Lua_Safe_Call_Bool(); + return self->IsCity(); +} + +bool Lua_Zone::IsHotzone() +{ + Lua_Safe_Call_Bool(); + return self->IsHotzone(); +} + +bool Lua_Zone::IsInstancePersistent() +{ + Lua_Safe_Call_Bool(); + return self->IsInstancePersistent(); +} + +bool Lua_Zone::IsIdleWhenEmpty() +{ + Lua_Safe_Call_Bool(); + return self->IsIdleWhenEmpty(); +} + +bool Lua_Zone::IsPVPZone() +{ + Lua_Safe_Call_Bool(); + return self->IsPVPZone(); +} + +bool Lua_Zone::IsRaining() +{ + Lua_Safe_Call_Bool(); + return self->IsRaining(); +} + +bool Lua_Zone::IsSnowing() +{ + Lua_Safe_Call_Bool(); + return self->IsSnowing(); +} + +bool Lua_Zone::IsSpecialBindLocation(float x, float y, float z, float heading) +{ + Lua_Safe_Call_Bool(); + return self->IsSpecialBindLocation(glm::vec4(x, y, z, heading)); +} + +bool Lua_Zone::IsSpellBlocked(uint32 spell_id, float x, float y, float z) +{ + Lua_Safe_Call_Bool(); + return self->IsSpellBlocked(spell_id, glm::vec3(x, y, z)); +} + +bool Lua_Zone::IsStaticZone() +{ + Lua_Safe_Call_Bool(); + return self->IsStaticZone(); +} + +bool Lua_Zone::IsUCSServerAvailable() +{ + Lua_Safe_Call_Bool(); + return self->IsUCSServerAvailable(); +} + +bool Lua_Zone::IsWaterZone(float z) +{ + Lua_Safe_Call_Bool(); + return self->IsWaterZone(z); +} + +void Lua_Zone::Repop() +{ + Lua_Safe_Call_Void(); + self->Repop(); +} + +void Lua_Zone::Repop(bool is_forced) +{ + Lua_Safe_Call_Void(); + self->Repop(is_forced); +} + +void Lua_Zone::SetAAEXPModifier(Lua_Client c, float aa_modifier) +{ + Lua_Safe_Call_Void(); + self->SetAAEXPModifier(c, aa_modifier); +} + +void Lua_Zone::SetAAEXPModifierByCharacterID(uint32 character_id, float aa_modifier) +{ + Lua_Safe_Call_Void(); + self->SetAAEXPModifierByCharacterID(character_id, aa_modifier); +} + +void Lua_Zone::SetEXPModifier(Lua_Client c, float exp_modifier) +{ + Lua_Safe_Call_Void(); + self->SetAAEXPModifier(c, exp_modifier); +} + +void Lua_Zone::SetEXPModifierByCharacterID(uint32 character_id, float exp_modifier) +{ + Lua_Safe_Call_Void(); + self->SetAAEXPModifierByCharacterID(character_id, exp_modifier); +} + +void Lua_Zone::SetInstanceTimer(uint32 new_duration) +{ + Lua_Safe_Call_Void(); + self->SetInstanceTimer(new_duration); +} + +void Lua_Zone::SetInstanceTimeRemaining(uint32 time_remaining) +{ + Lua_Safe_Call_Void(); + self->SetInstanceTimeRemaining(time_remaining); +} + +void Lua_Zone::SetIsHotzone(bool is_hotzone) +{ + Lua_Safe_Call_Void(); + self->SetIsHotzone(is_hotzone); +} + +void Lua_Zone::ShowZoneGlobalLoot(Lua_Client c) +{ + Lua_Safe_Call_Void(); + self->ShowZoneGlobalLoot(c); +} + +luabind::scope lua_register_zone() { + return luabind::class_("Zone") + .def(luabind::constructor<>()) + .def("BuffTimersSuspended", &Lua_Zone::BuffTimersSuspended) + .def("BypassesExpansionCheck", &Lua_Zone::BypassesExpansionCheck) + .def("CanBind", &Lua_Zone::CanBind) + .def("CanCastOutdoor", &Lua_Zone::CanCastOutdoor) + .def("CanDoCombat", &Lua_Zone::CanDoCombat) + .def("CanLevitate", &Lua_Zone::CanLevitate) + .def("ClearSpawnTimers", &Lua_Zone::ClearSpawnTimers) + .def("Depop", (void(Lua_Zone::*)(void))&Lua_Zone::Depop) + .def("Depop", (void(Lua_Zone::*)(bool))&Lua_Zone::Depop) + .def("Despawn", &Lua_Zone::Despawn) + .def("GetAAEXPModifier", &Lua_Zone::GetAAEXPModifier) + .def("GetAAEXPModifierByCharacterID", &Lua_Zone::GetAAEXPModifierByCharacterID) + .def("GetContentFlags", &Lua_Zone::GetContentFlags) + .def("GetContentFlagsDisabled", &Lua_Zone::GetContentFlagsDisabled) + .def("GetExperienceMultiplier", &Lua_Zone::GetExperienceMultiplier) + .def("GetExpansion", &Lua_Zone::GetExpansion) + .def("GetEXPModifier", &Lua_Zone::GetEXPModifier) + .def("GetEXPModifierByCharacterID", &Lua_Zone::GetEXPModifierByCharacterID) + .def("GetFastRegenEndurance", &Lua_Zone::GetFastRegenEndurance) + .def("GetFastRegenHP", &Lua_Zone::GetFastRegenHP) + .def("GetFastRegenMana", &Lua_Zone::GetFastRegenMana) + .def("GetFileName", &Lua_Zone::GetFileName) + .def("GetFlagNeeded", &Lua_Zone::GetFlagNeeded) + .def("GetFogBlue", (uint8(Lua_Zone::*)(void))&Lua_Zone::GetFogBlue) + .def("GetFogBlue", (uint8(Lua_Zone::*)(uint8))&Lua_Zone::GetFogBlue) + .def("GetFogDensity", &Lua_Zone::GetFogDensity) + .def("GetFogGreen", (uint8(Lua_Zone::*)(void))&Lua_Zone::GetFogGreen) + .def("GetFogGreen", (uint8(Lua_Zone::*)(uint8))&Lua_Zone::GetFogGreen) + .def("GetFogMaximumClip", (float(Lua_Zone::*)(void))&Lua_Zone::GetFogMaximumClip) + .def("GetFogMaximumClip", (float(Lua_Zone::*)(uint8))&Lua_Zone::GetFogMaximumClip) + .def("GetFogMinimumClip", (float(Lua_Zone::*)(void))&Lua_Zone::GetFogMinimumClip) + .def("GetFogMinimumClip", (float(Lua_Zone::*)(uint8))&Lua_Zone::GetFogMinimumClip) + .def("GetFogRed", (uint8(Lua_Zone::*)(void))&Lua_Zone::GetFogRed) + .def("GetFogRed", (uint8(Lua_Zone::*)(uint8))&Lua_Zone::GetFogRed) + .def("GetGraveyardHeading", &Lua_Zone::GetGraveyardHeading) + .def("GetGraveyardID", &Lua_Zone::GetGraveyardID) + .def("GetGraveyardX", &Lua_Zone::GetGraveyardX) + .def("GetGraveyardY", &Lua_Zone::GetGraveyardY) + .def("GetGraveyardZ", &Lua_Zone::GetGraveyardZ) + .def("GetGraveyardZoneID", &Lua_Zone::GetGraveyardZoneID) + .def("GetGravity", &Lua_Zone::GetGravity) + .def("GetInstanceID", &Lua_Zone::GetInstanceID) + .def("GetInstanceType", &Lua_Zone::GetInstanceType) + .def("GetInstanceVersion", &Lua_Zone::GetInstanceVersion) + .def("GetInstanceTimeRemaining", &Lua_Zone::GetInstanceTimeRemaining) + .def("GetLavaDamage", &Lua_Zone::GetLavaDamage) + .def("GetLongName", &Lua_Zone::GetLongName) + .def("GetMaximumClip", &Lua_Zone::GetMaximumClip) + .def("GetMaximumExpansion", &Lua_Zone::GetMaximumExpansion) + .def("GetMaximumLevel", &Lua_Zone::GetMaximumLevel) + .def("GetMaxClients", &Lua_Zone::GetMaxClients) + .def("GetMinimumClip", &Lua_Zone::GetMinimumClip) + .def("GetMinimumExpansion", &Lua_Zone::GetMinimumExpansion) + .def("GetMinimumLevel", &Lua_Zone::GetMinimumLevel) + .def("GetMinimumLavaDamage", &Lua_Zone::GetMinimumLavaDamage) + .def("GetMinimumStatus", &Lua_Zone::GetMinimumStatus) + .def("GetNote", &Lua_Zone::GetNote) + .def("GetNPCMaximumAggroDistance", &Lua_Zone::GetNPCMaximumAggroDistance) + .def("GetPEQZone", &Lua_Zone::GetPEQZone) + .def("GetRainChance", (int(Lua_Zone::*)(void))&Lua_Zone::GetRainChance) + .def("GetRainChance", (int(Lua_Zone::*)(uint8))&Lua_Zone::GetRainChance) + .def("GetRainDuration", (int(Lua_Zone::*)(void))&Lua_Zone::GetRainDuration) + .def("GetRainDuration", (int(Lua_Zone::*)(uint8))&Lua_Zone::GetRainDuration) + .def("GetRuleSet", &Lua_Zone::GetRuleSet) + .def("GetSafeHeading", &Lua_Zone::GetSafeHeading) + .def("GetSafeX", &Lua_Zone::GetSafeX) + .def("GetSafeY", &Lua_Zone::GetSafeY) + .def("GetSafeZ", &Lua_Zone::GetSafeZ) + .def("GetShortName", &Lua_Zone::GetShortName) + .def("GetSecondsBeforeIdle", &Lua_Zone::GetSecondsBeforeIdle) + .def("GetShutdownDelay", &Lua_Zone::GetShutdownDelay) + .def("GetSky", &Lua_Zone::GetSky) + .def("GetSkyLock", &Lua_Zone::GetSkyLock) + .def("GetSnowChance", (int(Lua_Zone::*)(void))&Lua_Zone::GetSnowChance) + .def("GetSnowChance", (int(Lua_Zone::*)(uint8))&Lua_Zone::GetSnowChance) + .def("GetSnowDuration", (int(Lua_Zone::*)(void))&Lua_Zone::GetSnowDuration) + .def("GetSnowDuration", (int(Lua_Zone::*)(uint8))&Lua_Zone::GetSnowDuration) + .def("GetTimeType", &Lua_Zone::GetTimeType) + .def("GetTimeZone", &Lua_Zone::GetTimeZone) + .def("GetZoneDescription", &Lua_Zone::GetZoneDescription) + .def("GetZoneID", &Lua_Zone::GetZoneID) + .def("GetZoneType", &Lua_Zone::GetZoneType) + .def("GetUnderworld", &Lua_Zone::GetUnderworld) + .def("GetUnderworldTeleportIndex", &Lua_Zone::GetUnderworldTeleportIndex) + .def("GetWalkSpeed", &Lua_Zone::GetWalkSpeed) + .def("GetZoneZType", &Lua_Zone::GetZoneZType) + .def("GetZoneTotalBlockedSpells", &Lua_Zone::GetZoneTotalBlockedSpells) + .def("HasGraveyard", &Lua_Zone::HasGraveyard) + .def("HasMap", &Lua_Zone::HasMap) + .def("HasWaterMap", &Lua_Zone::HasWaterMap) + .def("HasWeather", &Lua_Zone::HasWeather) + .def("IsCity", &Lua_Zone::IsCity) + .def("IsHotzone", &Lua_Zone::IsHotzone) + .def("IsInstancePersistent", &Lua_Zone::IsInstancePersistent) + .def("IsIdleWhenEmpty", &Lua_Zone::IsIdleWhenEmpty) + .def("IsPVPZone", &Lua_Zone::IsPVPZone) + .def("IsRaining", &Lua_Zone::IsRaining) + .def("IsSnowing", &Lua_Zone::IsSnowing) + .def("IsSpecialBindLocation", &Lua_Zone::IsSpecialBindLocation) + .def("IsSpellBlocked", &Lua_Zone::IsSpellBlocked) + .def("IsStaticZone", &Lua_Zone::IsStaticZone) + .def("IsUCSServerAvailable", &Lua_Zone::IsUCSServerAvailable) + .def("IsWaterZone", &Lua_Zone::IsWaterZone) + .def("Repop", (void(Lua_Zone::*)(void))&Lua_Zone::Repop) + .def("Repop", (void(Lua_Zone::*)(bool))&Lua_Zone::Repop) + .def("SetAAEXPModifier", &Lua_Zone::SetAAEXPModifier) + .def("SetAAEXPModifierByCharacterID", &Lua_Zone::SetAAEXPModifierByCharacterID) + .def("SetEXPModifier", &Lua_Zone::SetEXPModifier) + .def("SetEXPModifierByCharacterID", &Lua_Zone::SetEXPModifierByCharacterID) + .def("SetInstanceTimer", &Lua_Zone::SetInstanceTimer) + .def("SetInstanceTimeRemaining", &Lua_Zone::SetInstanceTimeRemaining) + .def("SetIsHotzone", &Lua_Zone::SetIsHotzone) + .def("ShowZoneGlobalLoot", &Lua_Zone::ShowZoneGlobalLoot); +} + diff --git a/zone/lua_zone.h b/zone/lua_zone.h new file mode 100644 index 000000000..a2dbb85b4 --- /dev/null +++ b/zone/lua_zone.h @@ -0,0 +1,146 @@ +#pragma once + +#ifdef LUA_EQEMU + +#include "lua_client.h" +#include "lua_ptr.h" +#include "common.h" +#include "zone.h" + +class Lua_Zone; + +namespace luabind { + struct scope; +} + +luabind::scope lua_register_zone(); + +class Lua_Zone : public Lua_Ptr +{ + typedef Zone NativeType; +public: + Lua_Zone() : Lua_Ptr(nullptr) { } + Lua_Zone(Zone* d) : Lua_Ptr(d) { } + virtual ~Lua_Zone() { } + + operator Zone*() { + return reinterpret_cast(GetLuaPtrData()); + } + + bool BuffTimersSuspended(); + bool BypassesExpansionCheck(); + bool CanBind(); + bool CanCastOutdoor(); + bool CanDoCombat(); + bool CanLevitate(); + void ClearSpawnTimers(); + void Depop(); + void Depop(bool start_spawn_timers); + void Despawn(uint32 spawngroup_id); + float GetAAEXPModifier(Lua_Client c); + float GetAAEXPModifierByCharacterID(uint32 character_id); + std::string GetContentFlags(); + std::string GetContentFlagsDisabled(); + float GetExperienceMultiplier(); + int8 GetExpansion(); + float GetEXPModifier(Lua_Client c); + float GetEXPModifierByCharacterID(uint32 character_id); + int GetFastRegenEndurance(); + int GetFastRegenHP(); + int GetFastRegenMana(); + std::string GetFileName(); + std::string GetFlagNeeded(); + uint8 GetFogBlue(); + uint8 GetFogBlue(uint8 slot); + float GetFogDensity(); + uint8 GetFogGreen(); + uint8 GetFogGreen(uint8 slot); + float GetFogMaximumClip(); + float GetFogMaximumClip(uint8 slot); + float GetFogMinimumClip(); + float GetFogMinimumClip(uint8 slot); + uint8 GetFogRed(); + uint8 GetFogRed(uint8 slot); + float GetGraveyardHeading(); + uint32 GetGraveyardID(); + float GetGraveyardX(); + float GetGraveyardY(); + float GetGraveyardZ(); + uint32 GetGraveyardZoneID(); + float GetGravity(); + uint32 GetInstanceID(); + uint8 GetInstanceType(); + uint16 GetInstanceVersion(); + uint32 GetInstanceTimeRemaining(); + int GetLavaDamage(); + std::string GetLongName(); + float GetMaximumClip(); + int8 GetMaximumExpansion(); + uint8 GetMaximumLevel(); + uint32 GetMaxClients(); + float GetMinimumClip(); + int8 GetMinimumExpansion(); + uint8 GetMinimumLevel(); + int GetMinimumLavaDamage(); + uint8 GetMinimumStatus(); + std::string GetNote(); + int GetNPCMaximumAggroDistance(); + int8 GetPEQZone(); + int GetRainChance(); + int GetRainChance(uint8 slot); + int GetRainDuration(); + int GetRainDuration(uint8 slot); + uint32 GetRuleSet(); + float GetSafeHeading(); + float GetSafeX(); + float GetSafeY(); + float GetSafeZ(); + std::string GetShortName(); + uint32 GetSecondsBeforeIdle(); + uint64 GetShutdownDelay(); + uint8 GetSky(); + int8 GetSkyLock(); + int GetSnowChance(); + int GetSnowChance(uint8 slot); + int GetSnowDuration(); + int GetSnowDuration(uint8 slot); + uint8 GetTimeType(); + int GetTimeZone(); + std::string GetZoneDescription(); + uint32 GetZoneID(); + uint8 GetZoneType(); + float GetUnderworld(); + int GetUnderworldTeleportIndex(); + float GetWalkSpeed(); + uint8 GetZoneZType(); + int GetZoneTotalBlockedSpells(); + bool HasGraveyard(); + bool HasMap(); + bool HasWaterMap(); + bool HasWeather(); + bool IsCity(); + bool IsHotzone(); + bool IsInstancePersistent(); + bool IsIdleWhenEmpty(); + bool IsPVPZone(); + bool IsRaining(); + bool IsSnowing(); + bool IsSpecialBindLocation(float x, float y, float z, float heading); + bool IsSpellBlocked(uint32 spell_id, float x, float y, float z); + bool IsStaticZone(); + bool IsUCSServerAvailable(); + bool IsWaterZone(float z); + void Repop(); + void Repop(bool is_forced); + void SetAAEXPModifier(Lua_Client c, float aa_modifier); + void SetAAEXPModifierByCharacterID(uint32 character_id, float aa_modifier); + void SetEXPModifier(Lua_Client c, float exp_modifier); + void SetEXPModifierByCharacterID(uint32 character_id, float exp_modifier); + void SetInstanceTimer(uint32 new_duration); + void SetInstanceTimeRemaining(uint32 time_remaining); + void SetIsHotzone(bool is_hotzone); + void ShowZoneGlobalLoot(Lua_Client c); + +}; + +#endif diff --git a/zone/perl_zone.cpp b/zone/perl_zone.cpp new file mode 100644 index 000000000..52e977651 --- /dev/null +++ b/zone/perl_zone.cpp @@ -0,0 +1,650 @@ +#include "../common/features.h" +#include "zone.h" + +#ifdef EMBPERL_XS_CLASSES + +#include "../common/global_define.h" +#include "embperl.h" + +bool Perl_Zone_BuffTimersSuspended(Zone* self) +{ + return self->BuffTimersSuspended(); +} + +bool Perl_Zone_BypassesExpansionCheck(Zone* self) +{ + return zone_store.GetZoneBypassExpansionCheck(self->GetZoneID(), self->GetInstanceVersion()); +} + +bool Perl_Zone_CanBind(Zone* self) +{ + return self->CanBind(); +} + +bool Perl_Zone_CanCastOutdoor(Zone* self) +{ + return self->CanCastOutdoor(); +} + +bool Perl_Zone_CanDoCombat(Zone* self) +{ + return self->CanDoCombat(); +} + +bool Perl_Zone_CanLevitate(Zone* self) +{ + return self->CanLevitate(); +} + +void Perl_Zone_ClearSpawnTimers(Zone* self) +{ + self->ClearSpawnTimers(); +} + +void Perl_Zone_Depop(Zone* self) +{ + self->Depop(); +} + +void Perl_Zone_Depop(Zone* self, bool start_spawn_timers) +{ + self->Depop(start_spawn_timers); +} + +void Perl_Zone_Despawn(Zone* self, uint32 spawngroup_id) +{ + self->Despawn(spawngroup_id); +} + +float Perl_Zone_GetAAEXPModifier(Zone* self, Client* c) +{ + return self->GetAAEXPModifier(c); +} + +float Perl_Zone_GetAAEXPModifierByCharacterID(Zone* self, uint32 character_id) +{ + return self->GetAAEXPModifierByCharacterID(character_id); +} + +std::string Perl_Zone_GetContentFlags(Zone* self) +{ + return zone_store.GetZoneContentFlags(self->GetZoneID(), self->GetInstanceVersion()); +} + +std::string Perl_Zone_GetContentFlagsDisabled(Zone* self) +{ + return zone_store.GetZoneContentFlagsDisabled(self->GetZoneID(), self->GetInstanceVersion()); +} + +float Perl_Zone_GetExperienceMultiplier(Zone* self) +{ + return zone_store.GetZoneExperienceMultiplier(self->GetZoneID(), self->GetInstanceVersion()); +} + +int8 Perl_Zone_GetExpansion(Zone* self) +{ + return zone_store.GetZoneExpansion(self->GetZoneID(), self->GetInstanceVersion()); +} + +float Perl_Zone_GetEXPModifier(Zone* self, Client* c) +{ + return self->GetEXPModifier(c); +} + +float Perl_Zone_GetEXPModifierByCharacterID(Zone* self, uint32 character_id) +{ + return self->GetEXPModifierByCharacterID(character_id); +} + +int Perl_Zone_GetFastRegenEndurance(Zone* self) +{ + return zone_store.GetZoneFastRegenEndurance(self->GetZoneID(), self->GetInstanceVersion()); +} + +int Perl_Zone_GetFastRegenHP(Zone* self) +{ + return zone_store.GetZoneFastRegenHP(self->GetZoneID(), self->GetInstanceVersion()); +} + +int Perl_Zone_GetFastRegenMana(Zone* self) +{ + return zone_store.GetZoneFastRegenMana(self->GetZoneID(), self->GetInstanceVersion()); +} + +std::string Perl_Zone_GetFileName(Zone* self) +{ + return self->GetFileName(); +} + +std::string Perl_Zone_GetFlagNeeded(Zone* self) +{ + return zone_store.GetZoneFlagNeeded(self->GetZoneID(), self->GetInstanceVersion()); +} + +uint8 Perl_Zone_GetFogBlue(Zone* self, uint8 slot = 0) +{ + return zone_store.GetZoneFogBlue(self->GetZoneID(), slot, self->GetInstanceVersion()); +} + +float Perl_Zone_GetFogDensity(Zone* self) +{ + return zone_store.GetZoneFogDensity(self->GetZoneID(), self->GetInstanceVersion()); +} + +uint8 Perl_Zone_GetFogGreen(Zone* self, uint8 slot = 0) +{ + return zone_store.GetZoneFogGreen(self->GetZoneID(), slot, self->GetInstanceVersion()); +} + +float Perl_Zone_GetFogMaximumClip(Zone* self, uint8 slot = 0) +{ + return zone_store.GetZoneFogMaximumClip(self->GetZoneID(), slot, self->GetInstanceVersion()); +} + +float Perl_Zone_GetFogMinimumClip(Zone* self, uint8 slot = 0) +{ + return zone_store.GetZoneFogMinimumClip(self->GetZoneID(), slot, self->GetInstanceVersion()); +} + +uint8 Perl_Zone_GetFogRed(Zone* self, uint8 slot = 0) +{ + return zone_store.GetZoneFogRed(self->GetZoneID(), slot, self->GetInstanceVersion()); +} + +float Perl_Zone_GetGraveyardHeading(Zone* self) +{ + return self->GetGraveyardPoint().w; +} + +uint32 Perl_Zone_GetGraveyardID(Zone* self) +{ + return self->graveyard_id(); +} + +float Perl_Zone_GetGraveyardX(Zone* self) +{ + return self->GetGraveyardPoint().x; +} + +float Perl_Zone_GetGraveyardY(Zone* self) +{ + return self->GetGraveyardPoint().y; +} + +float Perl_Zone_GetGraveyardZ(Zone* self) +{ + return self->GetGraveyardPoint().z; +} + +uint32 Perl_Zone_GetGraveyardZoneID(Zone* self) +{ + return self->graveyard_zoneid(); +} + +float Perl_Zone_GetGravity(Zone* self) +{ + return zone_store.GetZoneGravity(self->GetZoneID(), self->GetInstanceVersion()); +} + +uint32 Perl_Zone_GetInstanceID(Zone* self) +{ + return self->GetInstanceID(); +} + +uint8 Perl_Zone_GetInstanceType(Zone* self) +{ + return zone_store.GetZoneInstanceType(self->GetZoneID(), self->GetInstanceVersion()); +} + +uint16 Perl_Zone_GetInstanceVersion(Zone* self) +{ + return self->GetInstanceVersion(); +} + +uint32 Perl_Zone_GetInstanceTimeRemaining(Zone* self) +{ + return self->GetInstanceTimeRemaining(); +} + +int Perl_Zone_GetLavaDamage(Zone* self) +{ + return zone_store.GetZoneLavaDamage(self->GetZoneID(), self->GetInstanceVersion()); +} + +std::string Perl_Zone_GetLongName(Zone* self) +{ + return self->GetLongName(); +} + +float Perl_Zone_GetMaximumClip(Zone* self) +{ + return zone_store.GetZoneMaximumClip(self->GetZoneID(), self->GetInstanceVersion()); +} + +int8 Perl_Zone_GetMaximumExpansion(Zone* self) +{ + return zone_store.GetZoneMaximumExpansion(self->GetZoneID(), self->GetInstanceVersion()); +} + +uint8 Perl_Zone_GetMaximumLevel(Zone* self) +{ + return zone_store.GetZoneMaximumLevel(self->GetZoneID(), self->GetInstanceVersion()); +} + +uint32 Perl_Zone_GetMaxClients(Zone* self) +{ + return self->GetMaxClients(); +} + +float Perl_Zone_GetMinimumClip(Zone* self) +{ + return zone_store.GetZoneMinimumClip(self->GetZoneID(), self->GetInstanceVersion()); +} + +int8 Perl_Zone_GetMinimumExpansion(Zone* self) +{ + return zone_store.GetZoneMinimumExpansion(self->GetZoneID(), self->GetInstanceVersion()); +} + +uint8 Perl_Zone_GetMinimumLevel(Zone* self) +{ + return zone_store.GetZoneMinimumLevel(self->GetZoneID(), self->GetInstanceVersion()); +} + +int Perl_Zone_GetMinimumLavaDamage(Zone* self) +{ + return zone_store.GetZoneMinimumLavaDamage(self->GetZoneID(), self->GetInstanceVersion()); +} + +uint8 Perl_Zone_GetMinimumStatus(Zone* self) +{ + return zone_store.GetZoneMinimumStatus(self->GetZoneID(), self->GetInstanceVersion()); +} + +std::string Perl_Zone_GetNote(Zone* self) +{ + return zone_store.GetZoneNote(self->GetZoneID(), self->GetInstanceVersion()); +} + +int Perl_Zone_GetNPCMaximumAggroDistance(Zone* self) +{ + return zone_store.GetZoneNPCMaximumAggroDistance(self->GetZoneID(), self->GetInstanceVersion()); +} + +int8 Perl_Zone_GetPEQZone(Zone* self) +{ + return zone_store.GetZonePEQZone(self->GetZoneID(), self->GetInstanceVersion()); +} + +int Perl_Zone_GetRainChance(Zone* self, uint8 slot = 0) +{ + return zone_store.GetZoneRainChance(self->GetZoneID(), slot, self->GetInstanceVersion()); +} + +int Perl_Zone_GetRainDuration(Zone* self, uint8 slot = 0) +{ + return zone_store.GetZoneRainDuration(self->GetZoneID(), slot, self->GetInstanceVersion()); +} + +uint32 Perl_Zone_GetRuleSet(Zone* self) +{ + return zone_store.GetZoneRuleSet(self->GetZoneID(), self->GetInstanceVersion()); +} + +float Perl_Zone_GetSafeHeading(Zone* self) +{ + return self->GetSafePoint().w; +} + +float Perl_Zone_GetSafeX(Zone* self) +{ + return self->GetSafePoint().x; +} + +float Perl_Zone_GetSafeY(Zone* self) +{ + return self->GetSafePoint().y; +} + +float Perl_Zone_GetSafeZ(Zone* self) +{ + return self->GetSafePoint().z; +} + +std::string Perl_Zone_GetShortName(Zone* self) +{ + return self->GetShortName(); +} + +uint32 Perl_Zone_GetSecondsBeforeIdle(Zone* self) +{ + return self->GetSecondsBeforeIdle(); +} + +uint64 Perl_Zone_GetShutdownDelay(Zone* self) +{ + return zone_store.GetZoneShutdownDelay(self->GetZoneID(), self->GetInstanceVersion()); +} + +uint8 Perl_Zone_GetSky(Zone* self) +{ + return zone_store.GetZoneSky(self->GetZoneID(), self->GetInstanceVersion()); +} + +int8 Perl_Zone_GetSkyLock(Zone* self) +{ + return zone_store.GetZoneSkyLock(self->GetZoneID(), self->GetInstanceVersion()); +} + +int Perl_Zone_GetSnowChance(Zone* self, uint8 slot = 0) +{ + return zone_store.GetZoneSnowChance(self->GetZoneID(), slot, self->GetInstanceVersion()); +} + +int Perl_Zone_GetSnowDuration(Zone* self, uint8 slot = 0) +{ + return zone_store.GetZoneSnowDuration(self->GetZoneID(), slot, self->GetInstanceVersion()); +} + +uint8 Perl_Zone_GetTimeType(Zone* self) +{ + return zone_store.GetZoneTimeType(self->GetZoneID(), self->GetInstanceVersion()); +} + +int Perl_Zone_GetTimeZone(Zone* self) +{ + return zone_store.GetZoneTimeZone(self->GetZoneID(), self->GetInstanceVersion()); +} + +std::string Perl_Zone_GetZoneDescription(Zone* self) +{ + return self->GetZoneDescription(); +} + +uint32 Perl_Zone_GetZoneID(Zone* self) +{ + return self->GetZoneID(); +} + +uint8 Perl_Zone_GetZoneType(Zone* self) +{ + return self->GetZoneType(); +} + +float Perl_Zone_GetUnderworld(Zone* self) +{ + return zone_store.GetZoneUnderworld(self->GetZoneID(), self->GetInstanceVersion()); +} + +int Perl_Zone_GetUnderworldTeleportIndex(Zone* self) +{ + return zone_store.GetZoneUnderworldTeleportIndex(self->GetZoneID(), self->GetInstanceVersion()); +} + +float Perl_Zone_GetWalkSpeed(Zone* self) +{ + return zone_store.GetZoneWalkSpeed(self->GetZoneID(), self->GetInstanceVersion()); +} + +uint8 Perl_Zone_GetZoneZType(Zone* self) +{ + return zone_store.GetZoneZType(self->GetZoneID(), self->GetInstanceVersion()); +} + +int Perl_Zone_GetZoneTotalBlockedSpells(Zone* self) +{ + return self->GetZoneTotalBlockedSpells(); +} + +bool Perl_Zone_HasGraveyard(Zone* self) +{ + return self->HasGraveyard(); +} + +bool Perl_Zone_HasMap(Zone* self) +{ + return self->HasMap(); +} + +bool Perl_Zone_HasWaterMap(Zone* self) +{ + return self->HasWaterMap(); +} + +bool Perl_Zone_HasWeather(Zone* self) +{ + return self->HasWeather(); +} + +bool Perl_Zone_IsCity(Zone* self) +{ + return self->IsCity(); +} + +bool Perl_Zone_IsHotzone(Zone* self) +{ + return self->IsHotzone(); +} + +bool Perl_Zone_IsInstancePersistent(Zone* self) +{ + return self->IsInstancePersistent(); +} + +bool Perl_Zone_IsIdleWhenEmpty(Zone* self) +{ + return self->IsIdleWhenEmpty(); +} + +bool Perl_Zone_IsPVPZone(Zone* self) +{ + return self->IsPVPZone(); +} + +bool Perl_Zone_IsRaining(Zone* self) +{ + return self->IsRaining(); +} + +bool Perl_Zone_IsSnowing(Zone* self) +{ + return self->IsSnowing(); +} + +bool Perl_Zone_IsSpecialBindLocation(Zone* self, float x, float y, float z, float heading) +{ + return self->IsSpecialBindLocation(glm::vec4(x, y, z, heading)); +} + +bool Perl_Zone_IsSpellBlocked(Zone* self, uint32 spell_id, float x, float y, float z) +{ + return self->IsSpellBlocked(spell_id, glm::vec3(x, y, z)); +} + +bool Perl_Zone_IsStaticZone(Zone* self) +{ + return self->IsStaticZone(); +} + +bool Perl_Zone_IsUCSServerAvailable(Zone* self) +{ + return self->IsUCSServerAvailable(); +} + +bool Perl_Zone_IsWaterZone(Zone* self, float z) +{ + return self->IsWaterZone(z); +} + +void Perl_Zone_Repop(Zone* self) +{ + self->Repop(); +} + +void Perl_Zone_Repop(Zone* self, bool is_forced) +{ + self->Repop(is_forced); +} + +void Perl_Zone_SetAAEXPModifier(Zone* self, Client* c, float aa_modifier) +{ + self->SetAAEXPModifier(c, aa_modifier); +} + +void Perl_Zone_SetAAEXPModifierByCharacterID(Zone* self, uint32 character_id, float aa_modifier) +{ + self->SetAAEXPModifierByCharacterID(character_id, aa_modifier); +} + +void Perl_Zone_SetEXPModifier(Zone* self, Client* c, float exp_modifier) +{ + self->SetAAEXPModifier(c, exp_modifier); +} + +void Perl_Zone_SetEXPModifierByCharacterID(Zone* self, uint32 character_id, float exp_modifier) +{ + self->SetAAEXPModifierByCharacterID(character_id, exp_modifier); +} + +void Perl_Zone_SetInstanceTimer(Zone* self, uint32 new_duration) +{ + self->SetInstanceTimer(new_duration); +} + +void Perl_Zone_SetInstanceTimeRemaining(Zone* self, uint32 time_remaining) +{ + self->SetInstanceTimeRemaining(time_remaining); +} + +void Perl_Zone_SetIsHotzone(Zone* self, bool is_hotzone) +{ + self->SetIsHotzone(is_hotzone); +} + +void Perl_Zone_ShowZoneGlobalLoot(Zone* self, Client* c) +{ + self->ShowZoneGlobalLoot(c); +} + +void perl_register_zone() +{ + perl::interpreter perl(PERL_GET_THX); + + auto package = perl.new_class("Zone"); + package.add("BuffTimersSuspended", &Perl_Zone_BuffTimersSuspended); + package.add("BypassesExpansionCheck", &Perl_Zone_BypassesExpansionCheck); + package.add("CanBind", &Perl_Zone_CanBind); + package.add("CanCastOutdoor", &Perl_Zone_CanCastOutdoor); + package.add("CanDoCombat", &Perl_Zone_CanDoCombat); + package.add("CanLevitate", &Perl_Zone_CanLevitate); + package.add("ClearSpawnTimers", &Perl_Zone_ClearSpawnTimers); + package.add("Depop", (void(*)(Zone*))&Perl_Zone_Depop); + package.add("Depop", (void(*)(Zone*, bool))&Perl_Zone_Depop); + package.add("Despawn", &Perl_Zone_Despawn); + package.add("GetAAEXPModifier", &Perl_Zone_GetAAEXPModifier); + package.add("GetAAEXPModifierByCharacterID", &Perl_Zone_GetAAEXPModifierByCharacterID); + package.add("GetContentFlags", &Perl_Zone_GetContentFlags); + package.add("GetContentFlagsDisabled", &Perl_Zone_GetContentFlagsDisabled); + package.add("GetExperienceMultiplier", &Perl_Zone_GetExperienceMultiplier); + package.add("GetExpansion", &Perl_Zone_GetExpansion); + package.add("GetEXPModifier", &Perl_Zone_GetEXPModifier); + package.add("GetEXPModifierByCharacterID", &Perl_Zone_GetEXPModifierByCharacterID); + package.add("GetFastRegenEndurance", &Perl_Zone_GetFastRegenEndurance); + package.add("GetFastRegenHP", &Perl_Zone_GetFastRegenHP); + package.add("GetFastRegenMana", &Perl_Zone_GetFastRegenMana); + package.add("GetFileName", &Perl_Zone_GetFileName); + package.add("GetFlagNeeded", &Perl_Zone_GetFlagNeeded); + package.add("GetFogBlue", (uint8(*)(Zone*))&Perl_Zone_GetFogBlue); + package.add("GetFogBlue", (uint8(*)(Zone*, uint8))&Perl_Zone_GetFogBlue); + package.add("GetFogDensity", &Perl_Zone_GetFogDensity); + package.add("GetFogGreen", (uint8(*)(Zone*))&Perl_Zone_GetFogGreen); + package.add("GetFogGreen", (uint8(*)(Zone*, uint8))&Perl_Zone_GetFogGreen); + package.add("GetFogMaximumClip", (float(*)(Zone*))&Perl_Zone_GetFogMaximumClip); + package.add("GetFogMaximumClip", (float(*)(Zone*, uint8))&Perl_Zone_GetFogMaximumClip); + package.add("GetFogMinimumClip", (float(*)(Zone*))&Perl_Zone_GetFogMinimumClip); + package.add("GetFogMinimumClip", (float(*)(Zone*, uint8))&Perl_Zone_GetFogMinimumClip); + package.add("GetFogRed", (uint8(*)(Zone*))&Perl_Zone_GetFogRed); + package.add("GetFogRed", (uint8(*)(Zone*, uint8))&Perl_Zone_GetFogRed); + package.add("GetGraveyardHeading", &Perl_Zone_GetGraveyardHeading); + package.add("GetGraveyardID", &Perl_Zone_GetGraveyardID); + package.add("GetGraveyardX", &Perl_Zone_GetGraveyardX); + package.add("GetGraveyardY", &Perl_Zone_GetGraveyardY); + package.add("GetGraveyardZ", &Perl_Zone_GetGraveyardZ); + package.add("GetGraveyardZoneID", &Perl_Zone_GetGraveyardZoneID); + package.add("GetGravity", &Perl_Zone_GetGravity); + package.add("GetInstanceID", &Perl_Zone_GetInstanceID); + package.add("GetInstanceType", &Perl_Zone_GetInstanceType); + package.add("GetInstanceVersion", &Perl_Zone_GetInstanceVersion); + package.add("GetInstanceTimeRemaining", &Perl_Zone_GetInstanceTimeRemaining); + package.add("GetLavaDamage", &Perl_Zone_GetLavaDamage); + package.add("GetLongName", &Perl_Zone_GetLongName); + package.add("GetMaximumClip", &Perl_Zone_GetMaximumClip); + package.add("GetMaximumExpansion", &Perl_Zone_GetMaximumExpansion); + package.add("GetMaximumLevel", &Perl_Zone_GetMaximumLevel); + package.add("GetMaxClients", &Perl_Zone_GetMaxClients); + package.add("GetMinimumClip", &Perl_Zone_GetMinimumClip); + package.add("GetMinimumExpansion", &Perl_Zone_GetMinimumExpansion); + package.add("GetMinimumLevel", &Perl_Zone_GetMinimumLevel); + package.add("GetMinimumLavaDamage", &Perl_Zone_GetMinimumLavaDamage); + package.add("GetMinimumStatus", &Perl_Zone_GetMinimumStatus); + package.add("GetNote", &Perl_Zone_GetNote); + package.add("GetNPCMaximumAggroDistance", &Perl_Zone_GetNPCMaximumAggroDistance); + package.add("GetPEQZone", &Perl_Zone_GetPEQZone); + package.add("GetRainChance", (int(*)(Zone*))&Perl_Zone_GetRainChance); + package.add("GetRainChance", (int(*)(Zone*, uint8))&Perl_Zone_GetRainChance); + package.add("GetRainDuration", (int(*)(Zone*))&Perl_Zone_GetRainDuration); + package.add("GetRainDuration", (int(*)(Zone*, uint8))&Perl_Zone_GetRainDuration); + package.add("GetRuleSet", &Perl_Zone_GetRuleSet); + package.add("GetSafeHeading", &Perl_Zone_GetSafeHeading); + package.add("GetSafeX", &Perl_Zone_GetSafeX); + package.add("GetSafeY", &Perl_Zone_GetSafeY); + package.add("GetSafeZ", &Perl_Zone_GetSafeZ); + package.add("GetShortName", &Perl_Zone_GetShortName); + package.add("GetSecondsBeforeIdle", &Perl_Zone_GetSecondsBeforeIdle); + package.add("GetShutdownDelay", &Perl_Zone_GetShutdownDelay); + package.add("GetSky", &Perl_Zone_GetSky); + package.add("GetSkyLock", &Perl_Zone_GetSkyLock); + package.add("GetSnowChance", (int(*)(Zone*))&Perl_Zone_GetSnowChance); + package.add("GetSnowChance", (int(*)(Zone*, uint8))&Perl_Zone_GetSnowChance); + package.add("GetSnowDuration", (int(*)(Zone*))&Perl_Zone_GetSnowDuration); + package.add("GetSnowDuration", (int(*)(Zone*, uint8))&Perl_Zone_GetSnowDuration); + package.add("GetTimeType", &Perl_Zone_GetTimeType); + package.add("GetTimeZone", &Perl_Zone_GetTimeZone); + package.add("GetZoneDescription", &Perl_Zone_GetZoneDescription); + package.add("GetZoneID", &Perl_Zone_GetZoneID); + package.add("GetZoneType", &Perl_Zone_GetZoneType); + package.add("GetUnderworld", &Perl_Zone_GetUnderworld); + package.add("GetUnderworldTeleportIndex", &Perl_Zone_GetUnderworldTeleportIndex); + package.add("GetWalkSpeed", &Perl_Zone_GetWalkSpeed); + package.add("GetZoneZType", &Perl_Zone_GetZoneZType); + package.add("GetZoneTotalBlockedSpells", &Perl_Zone_GetZoneTotalBlockedSpells); + package.add("HasGraveyard", &Perl_Zone_HasGraveyard); + package.add("HasMap", &Perl_Zone_HasMap); + package.add("HasWaterMap", &Perl_Zone_HasWaterMap); + package.add("HasWeather", &Perl_Zone_HasWeather); + package.add("IsCity", &Perl_Zone_IsCity); + package.add("IsHotzone", &Perl_Zone_IsHotzone); + package.add("IsInstancePersistent", &Perl_Zone_IsInstancePersistent); + package.add("IsIdleWhenEmpty", &Perl_Zone_IsIdleWhenEmpty); + package.add("IsPVPZone", &Perl_Zone_IsPVPZone); + package.add("IsRaining", &Perl_Zone_IsRaining); + package.add("IsSnowing", &Perl_Zone_IsSnowing); + package.add("IsSpecialBindLocation", &Perl_Zone_IsSpecialBindLocation); + package.add("IsSpellBlocked", &Perl_Zone_IsSpellBlocked); + package.add("IsStaticZone", &Perl_Zone_IsStaticZone); + package.add("IsUCSServerAvailable", &Perl_Zone_IsUCSServerAvailable); + package.add("IsWaterZone", &Perl_Zone_IsWaterZone); + package.add("Repop", (void(*)(Zone*))&Perl_Zone_Repop); + package.add("Repop", (void(*)(Zone*, bool))&Perl_Zone_Repop); + package.add("SetAAEXPModifier", &Perl_Zone_SetAAEXPModifier); + package.add("SetAAEXPModifierByCharacterID", &Perl_Zone_SetAAEXPModifierByCharacterID); + package.add("SetEXPModifier", &Perl_Zone_SetEXPModifier); + package.add("SetEXPModifierByCharacterID", &Perl_Zone_SetEXPModifierByCharacterID); + package.add("SetInstanceTimer", &Perl_Zone_SetInstanceTimer); + package.add("SetInstanceTimeRemaining", &Perl_Zone_SetInstanceTimeRemaining); + package.add("SetIsHotzone", &Perl_Zone_SetIsHotzone); + package.add("ShowZoneGlobalLoot", &Perl_Zone_ShowZoneGlobalLoot); +} + +#endif //EMBPERL_XS_CLASSES +