diff --git a/zone/CMakeLists.txt b/zone/CMakeLists.txt index 81112445e..7cf213e3e 100644 --- a/zone/CMakeLists.txt +++ b/zone/CMakeLists.txt @@ -52,6 +52,7 @@ SET(zone_sources lua_encounter.cpp lua_entity.cpp lua_entity_list.cpp + lua_expedition.cpp lua_general.cpp lua_group.cpp lua_hate_list.cpp @@ -195,6 +196,7 @@ SET(zone_headers lua_encounter.h lua_entity.h lua_entity_list.h + lua_expedition.h lua_general.h lua_group.h lua_hate_list.h diff --git a/zone/lua_client.cpp b/zone/lua_client.cpp index 9309c7cbb..e29caef70 100644 --- a/zone/lua_client.cpp +++ b/zone/lua_client.cpp @@ -4,7 +4,9 @@ #include #include "client.h" +#include "expedition_lockout_timer.h" #include "lua_client.h" +#include "lua_expedition.h" #include "lua_npc.h" #include "lua_item.h" #include "lua_iteminst.h" @@ -1644,7 +1646,76 @@ int Lua_Client::GetClientMaxLevel() { return self->GetClientMaxLevel(); } +Lua_Expedition Lua_Client::CreateExpedition(std::string name, uint32 min_players, uint32 max_players) { + Lua_Safe_Call_Class(Lua_Expedition); + return self->CreateExpedition(name, min_players, max_players); +} +Lua_Expedition Lua_Client::CreateExpedition(std::string name, uint32 min_players, uint32 max_players, bool has_replay_timer) { + Lua_Safe_Call_Class(Lua_Expedition); + return self->CreateExpedition(name, min_players, max_players, has_replay_timer); +} + +Lua_Expedition Lua_Client::GetExpedition() { + Lua_Safe_Call_Class(Lua_Expedition); + return self->GetExpedition(); +} + +luabind::object Lua_Client::GetExpeditionLockouts(lua_State* L) +{ + auto lua_table = luabind::newtable(L); + if (d_) + { + auto self = reinterpret_cast(d_); + auto lockouts = self->GetExpeditionLockouts(); + + for (const auto& lockout : lockouts) + { + auto lockout_table = lua_table[lockout.GetExpeditionName()]; + if (luabind::type(lockout_table) != LUA_TTABLE) + { + lockout_table = luabind::newtable(L); + } + lockout_table[lockout.GetEventName()] = lockout.GetSecondsRemaining(); + } + } + return lua_table; +} + +luabind::object Lua_Client::GetExpeditionLockouts(lua_State* L, std::string expedition_name) +{ + auto lua_table = luabind::newtable(L); + if (d_) + { + auto self = reinterpret_cast(d_); + auto lockouts = self->GetExpeditionLockouts(); + + for (const auto& lockout : lockouts) + { + if (lockout.GetExpeditionName() == expedition_name) + { + lua_table[lockout.GetEventName()] = lockout.GetSecondsRemaining(); + } + } + } + return lua_table; +} + +void Lua_Client::AddExpeditionLockout(std::string expedition_name, std::string event_name, uint32 seconds) { + Lua_Safe_Call_Void(); + self->AddNewExpeditionLockout(expedition_name, event_name, seconds); +} + +void Lua_Client::RemoveExpeditionLockout(std::string expedition_name, std::string event_name) { + Lua_Safe_Call_Void(); + self->RemoveExpeditionLockout(expedition_name, event_name, true); + self->SendExpeditionLockoutTimers(); +} + +bool Lua_Client::HasExpeditionLockout(std::string expedition_name, std::string event_name) { + Lua_Safe_Call_Bool(); + return self->HasExpeditionLockout(expedition_name, event_name); +} luabind::scope lua_register_client() { return luabind::class_("Client") @@ -1952,7 +2023,15 @@ luabind::scope lua_register_client() { .def("EnableAreaRegens", &Lua_Client::EnableAreaRegens) .def("DisableAreaRegens", &Lua_Client::DisableAreaRegens) .def("SetClientMaxLevel", (void(Lua_Client::*)(int))&Lua_Client::SetClientMaxLevel) - .def("GetClientMaxLevel", (int(Lua_Client::*)(void))&Lua_Client::GetClientMaxLevel); + .def("GetClientMaxLevel", (int(Lua_Client::*)(void))&Lua_Client::GetClientMaxLevel) + .def("CreateExpedition", (Lua_Expedition(Lua_Client::*)(std::string, uint32, uint32))&Lua_Client::CreateExpedition) + .def("CreateExpedition", (Lua_Expedition(Lua_Client::*)(std::string, uint32, uint32, bool))&Lua_Client::CreateExpedition) + .def("GetExpedition", (Lua_Expedition(Lua_Client::*)(void))&Lua_Client::GetExpedition) + .def("GetExpeditionLockouts", (luabind::object(Lua_Client::*)(lua_State* L))&Lua_Client::GetExpeditionLockouts) + .def("GetExpeditionLockouts", (luabind::object(Lua_Client::*)(lua_State* L, std::string))&Lua_Client::GetExpeditionLockouts) + .def("AddExpeditionLockout", (void(Lua_Client::*)(std::string, std::string, uint32))&Lua_Client::AddExpeditionLockout) + .def("RemoveExpeditionLockout", (void(Lua_Client::*)(std::string, std::string))&Lua_Client::RemoveExpeditionLockout) + .def("HasExpeditionLockout", (bool(Lua_Client::*)(std::string, std::string))&Lua_Client::HasExpeditionLockout); } luabind::scope lua_register_inventory_where() { diff --git a/zone/lua_client.h b/zone/lua_client.h index 2f5de4a59..8f60aaacb 100644 --- a/zone/lua_client.h +++ b/zone/lua_client.h @@ -5,6 +5,7 @@ #include "lua_mob.h" class Client; +class Lua_Expedition; class Lua_Group; class Lua_Raid; class Lua_Inventory; @@ -332,12 +333,20 @@ public: void EnableAreaRegens(int value); void DisableAreaRegens(); - void SetPrimaryWeaponOrnamentation(uint32 model_id); void SetSecondaryWeaponOrnamentation(uint32 model_id); void SetClientMaxLevel(int value); int GetClientMaxLevel(); + + Lua_Expedition CreateExpedition(std::string name, uint32 min_players, uint32 max_players); + Lua_Expedition CreateExpedition(std::string name, uint32 min_players, uint32 max_players, bool has_replay_timer); + Lua_Expedition GetExpedition(); + luabind::object GetExpeditionLockouts(lua_State* L); + luabind::object GetExpeditionLockouts(lua_State* L, std::string expedition_name); + void AddExpeditionLockout(std::string expedition_name, std::string event_name, uint32 seconds); + void RemoveExpeditionLockout(std::string expedition_name, std::string event_name); + bool HasExpeditionLockout(std::string expedition_name, std::string event_name); }; #endif diff --git a/zone/lua_expedition.cpp b/zone/lua_expedition.cpp new file mode 100644 index 000000000..5d4b05c04 --- /dev/null +++ b/zone/lua_expedition.cpp @@ -0,0 +1,152 @@ +/** + * EQEmulator: Everquest Server Emulator + * Copyright (C) 2001-2020 EQEmulator Development Team (https://github.com/EQEmu/Server) + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; version 2 of the License. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY except by those people which sell it, which + * are required to give you total support for your newly bought product; + * without even the implied warranty of MERCHANTABILITY or FITNESS FOR + * A PARTICULAR PURPOSE. See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +#ifdef LUA_EQEMU + +#include "lua_expedition.h" +#include "expedition.h" +#include "lua.hpp" +#include +#include + +void Lua_Expedition::AddLockout(std::string event_name, uint32_t seconds) { + Lua_Safe_Call_Void(); + self->AddLockout(event_name, seconds); +} + +void Lua_Expedition::AddReplayLockout(uint32_t seconds) { + Lua_Safe_Call_Void(); + self->AddReplayLockout(seconds); +} + +uint32_t Lua_Expedition::GetID() { + Lua_Safe_Call_Int(); + return self->GetID(); +} + +std::string Lua_Expedition::GetLeaderName() { + Lua_Safe_Call_String(); + return self->GetLeaderName(); +} + +luabind::object Lua_Expedition::GetLockouts(lua_State* L) { + luabind::object lua_table = luabind::newtable(L); + + if (d_) + { + auto self = reinterpret_cast(d_); + auto lockouts = self->GetLockouts(); + for (const auto& lockout : lockouts) + { + lua_table[lockout.first] = lockout.second.GetSecondsRemaining(); + } + } + return lua_table; +} + +uint32_t Lua_Expedition::GetMemberCount() { + Lua_Safe_Call_Int(); + return self->GetMemberCount(); +} + +luabind::object Lua_Expedition::GetMembers(lua_State* L) { + luabind::object lua_table = luabind::newtable(L); + + if (d_) + { + auto self = reinterpret_cast(d_); + for (const auto& member : self->GetMembers()) + { + lua_table[member.name] = member.char_id; + } + } + return lua_table; +} + +std::string Lua_Expedition::GetName() { + Lua_Safe_Call_String(); + return self->GetName(); +} + +int Lua_Expedition::GetType() { + Lua_Safe_Call_Int(); + return static_cast(self->GetType()); +} + +bool Lua_Expedition::HasLockout(std::string event_name) { + Lua_Safe_Call_Bool(); + return self->HasLockout(event_name); +} + +bool Lua_Expedition::HasReplayLockout() { + Lua_Safe_Call_Bool(); + return self->HasReplayLockout(); +} + +void Lua_Expedition::RemoveLockout(std::string event_name) { + Lua_Safe_Call_Void(); + self->RemoveLockout(event_name); +} + +luabind::scope lua_register_expedition() { + return luabind::class_("Expedition") + .def(luabind::constructor<>()) + .property("null", &Lua_Expedition::Null) + .property("valid", &Lua_Expedition::Valid) + .def("AddLockout", (void(Lua_Expedition::*)(std::string, uint32_t))&Lua_Expedition::AddLockout) + .def("AddReplayLockout", (void(Lua_Expedition::*)(uint32_t))&Lua_Expedition::AddReplayLockout) + .def("GetID", (uint32_t(Lua_Expedition::*)(void))&Lua_Expedition::GetID) + .def("GetLeaderName", (std::string(Lua_Expedition::*)(void))&Lua_Expedition::GetLeaderName) + .def("GetLockouts", &Lua_Expedition::GetLockouts) + .def("GetMemberCount", (uint32_t(Lua_Expedition::*)(void))&Lua_Expedition::GetMemberCount) + .def("GetMembers", &Lua_Expedition::GetMembers) + .def("GetName", (std::string(Lua_Expedition::*)(void))&Lua_Expedition::GetName) + .def("GetType", (int(Lua_Expedition::*)(void))&Lua_Expedition::GetType) + .def("HasLockout", (bool(Lua_Expedition::*)(std::string))&Lua_Expedition::HasLockout) + .def("HasReplayLockout", (bool(Lua_Expedition::*)())&Lua_Expedition::HasReplayLockout) + .def("RemoveLockout", (void(Lua_Expedition::*)(std::string))&Lua_Expedition::RemoveLockout); +} + +luabind::scope lua_register_expedition_member_status() { + return luabind::class_("ExpeditionMemberStatus") + .enum_("constants") + [ + luabind::value("Unknown", static_cast(ExpeditionMemberStatus::Unknown)), + luabind::value("Online", static_cast(ExpeditionMemberStatus::Online)), + luabind::value("Offline", static_cast(ExpeditionMemberStatus::Offline)), + luabind::value("InDynamicZone", static_cast(ExpeditionMemberStatus::InDynamicZone)), + luabind::value("LinkDead", static_cast(ExpeditionMemberStatus::LinkDead)) + ]; +} + +luabind::scope lua_register_dynamiczone_types() { + return luabind::class_("DynamicZoneType") + .enum_("constants") + [ + luabind::value("None", static_cast(DynamicZoneType::None)), + luabind::value("Expedition", static_cast(DynamicZoneType::Expedition)), + luabind::value("Tutorial", static_cast(DynamicZoneType::Tutorial)), + luabind::value("Task", static_cast(DynamicZoneType::Task)), + luabind::value("Mission", static_cast(DynamicZoneType::Mission)), + luabind::value("Quest", static_cast(DynamicZoneType::Quest)) + ]; +} + +#endif // LUA_EQEMU diff --git a/zone/lua_expedition.h b/zone/lua_expedition.h new file mode 100644 index 000000000..155c5bc09 --- /dev/null +++ b/zone/lua_expedition.h @@ -0,0 +1,72 @@ +/** + * EQEmulator: Everquest Server Emulator + * Copyright (C) 2001-2020 EQEmulator Development Team (https://github.com/EQEmu/Server) + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; version 2 of the License. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY except by those people which sell it, which + * are required to give you total support for your newly bought product; + * without even the implied warranty of MERCHANTABILITY or FITNESS FOR + * A PARTICULAR PURPOSE. See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +#ifndef EQEMU_LUA_EXPEDITION_H +#define EQEMU_LUA_EXPEDITION_H +#ifdef LUA_EQEMU + +#include "lua_ptr.h" +#include "../common/types.h" +#include + +class Expedition; +class Lua_Client; +struct lua_State; + +namespace luabind { + struct scope; + namespace adl { + class object; + } + using adl::object; +} + +luabind::scope lua_register_dynamiczone_types(); +luabind::scope lua_register_expedition(); +luabind::scope lua_register_expedition_member_status(); + +class Lua_Expedition : public Lua_Ptr +{ + typedef Expedition NativeType; +public: + Lua_Expedition() : Lua_Ptr(nullptr) { } + Lua_Expedition(Expedition *d) : Lua_Ptr(d) { } + virtual ~Lua_Expedition() { } + + operator Expedition*() { + return reinterpret_cast(GetLuaPtrData()); + } + + void AddLockout(std::string event_name, uint32_t seconds); + void AddReplayLockout(uint32_t seconds); + uint32_t GetID(); + std::string GetLeaderName(); + uint32_t GetMemberCount(); + luabind::object GetMembers(lua_State* L); + std::string GetName(); + int GetType(); + luabind::object GetLockouts(lua_State* L); + bool HasLockout(std::string event_name); + bool HasReplayLockout(); + void RemoveLockout(std::string event_name); +}; + +#endif // LUA_EQEMU +#endif // EQEMU_LUA_EXPEDITION_H diff --git a/zone/lua_general.cpp b/zone/lua_general.cpp index ecb072369..5dbb8108c 100644 --- a/zone/lua_general.cpp +++ b/zone/lua_general.cpp @@ -18,6 +18,7 @@ #include "lua_client.h" #include "lua_npc.h" #include "lua_entity_list.h" +#include "lua_expedition.h" #include "quest_parser_collection.h" #include "questmgr.h" #include "qglobals.h" @@ -2178,6 +2179,18 @@ void lua_set_content_flag(std::string flag_name, bool enabled){ ZoneStore::SetContentFlag(flag_name, enabled); } +Lua_Expedition lua_get_expedition() { + return quest_manager.GetExpeditionForCurrentInstance(); +} + +Lua_Expedition lua_get_expedition_by_char_id(uint32 char_id) { + return quest_manager.GetExpeditionByCharID(char_id); +} + +Lua_Expedition lua_get_expedition_by_instance_id(uint32 instance_id) { + return quest_manager.GetExpeditionByInstanceID(instance_id); +} + #define LuaCreateNPCParse(name, c_type, default_value) do { \ cur = table[#name]; \ if(luabind::type(cur) != LUA_TNIL) { \ @@ -2775,7 +2788,11 @@ luabind::scope lua_register_general() { * Content flags */ luabind::def("is_content_flag_enabled", (bool(*)(std::string))&lua_is_content_flag_enabled), - luabind::def("set_content_flag", (void(*)(std::string, bool))&lua_set_content_flag) + luabind::def("set_content_flag", (void(*)(std::string, bool))&lua_set_content_flag), + + luabind::def("get_expedition", (Lua_Expedition(*)())&lua_get_expedition), + luabind::def("get_expedition_by_char_id", (Lua_Expedition(*)(uint32 char_id))&lua_get_expedition_by_char_id), + luabind::def("get_expedition_by_instance_id", (Lua_Expedition(*)(uint32 instance_id))&lua_get_expedition_by_instance_id) ]; } diff --git a/zone/lua_parser.cpp b/zone/lua_parser.cpp index ebe88f32a..8ac469359 100644 --- a/zone/lua_parser.cpp +++ b/zone/lua_parser.cpp @@ -19,6 +19,7 @@ #include "lua_parser.h" #include "lua_bit.h" #include "lua_entity.h" +#include "lua_expedition.h" #include "lua_item.h" #include "lua_iteminst.h" #include "lua_mob.h" @@ -1108,7 +1109,10 @@ void LuaParser::MapFunctions(lua_State *L) { lua_register_ruler(), lua_register_ruleb(), lua_register_journal_speakmode(), - lua_register_journal_mode() + lua_register_journal_mode(), + lua_register_dynamiczone_types(), + lua_register_expedition(), + lua_register_expedition_member_status() ]; } catch(std::exception &ex) { diff --git a/zone/questmgr.cpp b/zone/questmgr.cpp index 631bb1218..a255d110f 100644 --- a/zone/questmgr.cpp +++ b/zone/questmgr.cpp @@ -26,6 +26,7 @@ #include "entity.h" #include "event_codes.h" +#include "expedition.h" #include "guild_mgr.h" #include "qglobals.h" #include "queryserv.h" @@ -4327,3 +4328,22 @@ void QuestManager::UpdateZoneHeader(std::string type, std::string value) { entity_list.QueueClients(0, outapp); safe_delete(outapp); } + +Expedition* QuestManager::GetExpeditionByCharID(uint32 char_id) +{ + return Expedition::FindCachedExpeditionByCharacterID(char_id); +} + +Expedition* QuestManager::GetExpeditionByInstanceID(uint32 instance_id) +{ + return Expedition::FindExpeditionByInstanceID(instance_id); +} + +Expedition* QuestManager::GetExpeditionForCurrentInstance() +{ + if (zone && zone->GetInstanceID() != 0) + { + return Expedition::FindExpeditionByInstanceID(zone->GetInstanceID()); + } + return nullptr; +} diff --git a/zone/questmgr.h b/zone/questmgr.h index f3f656e51..84dad5d02 100644 --- a/zone/questmgr.h +++ b/zone/questmgr.h @@ -366,6 +366,9 @@ public: bool DisableRecipe(uint32 recipe_id); void ClearNPCTypeCache(int npctype_id); void ReloadZoneStaticData(); + Expedition* GetExpeditionByCharID(uint32 char_id); + Expedition* GetExpeditionByInstanceID(uint32 instance_id); + Expedition* GetExpeditionForCurrentInstance(); Client *GetInitiator() const; NPC *GetNPC() const;