[Quest API] Add Zone Support to Perl and Lua (#4662)

* [Quest API] Add Zone Support to Perl and Lua

* Final

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

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());

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
 		*/

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) {

zone/lua_zone.cpp

@@ -0,0 +1,805 @@
+#include "../common/features.h"
+#include "zone.h"
+
+
+#include <luabind/luabind.hpp>
+#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_<Lua_Zone>("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);
+}
+

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<Zone>
+{
+	typedef Zone NativeType;
+public:
+	Lua_Zone() : Lua_Ptr(nullptr) { }
+	Lua_Zone(Zone* d) : Lua_Ptr(d) { }
+	virtual ~Lua_Zone() { }
+
+	operator Zone*() {
+		return reinterpret_cast<Zone*>(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

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>("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
+