From 17e922b02669c71fb020cf3bf9a837338b56d8ba Mon Sep 17 00:00:00 2001 From: KimLS Date: Wed, 27 Nov 2024 20:14:11 -0800 Subject: [PATCH] Points load and send to client; find on them needs work because the decode on the packet is very wrong. --- common/eq_packet_structs.h | 25 + .../base/base_findable_location_repository.h | 547 ++++++++++++++++++ .../findable_location_repository.h | 50 ++ zone/zone.h | 2 + zone/zone_finable_locations.cpp | 29 + zone/zonedb.cpp | 12 +- zone/zonedb.h | 4 + 7 files changed, 667 insertions(+), 2 deletions(-) create mode 100644 common/repositories/base/base_findable_location_repository.h create mode 100644 common/repositories/findable_location_repository.h diff --git a/common/eq_packet_structs.h b/common/eq_packet_structs.h index 322bdf639..2ba4b7027 100644 --- a/common/eq_packet_structs.h +++ b/common/eq_packet_structs.h @@ -6436,6 +6436,31 @@ struct BuylineItemDetails_Struct { uint32 item_quantity; }; +/* Taken from libeq */ +enum FindLocationType : uint32 { + LocationUnknown, + LocationPlayer, + LocationPOI, + LocationRealEstateItem, + LocationRealEstatePlot, + LocationMapPoint, + LocationSwitch, + LocationLocation +}; + +//For reference +struct FindableLocation_Struct { +/*00*/ FindLocationType type; +/*04*/ int32 id; +/*08*/ int32 sub_id; +/*12*/ int32 zone_id; +/*16*/ int32 zone_point_identifier; +/*20*/ float y; +/*24*/ float x; +/*28*/ float z; +/*32*/ +}; + // Restore structure packing to default #pragma pack() diff --git a/common/repositories/base/base_findable_location_repository.h b/common/repositories/base/base_findable_location_repository.h new file mode 100644 index 000000000..a37424644 --- /dev/null +++ b/common/repositories/base/base_findable_location_repository.h @@ -0,0 +1,547 @@ +/** + * DO NOT MODIFY THIS FILE + * + * This repository was automatically generated and is NOT to be modified directly. + * Any repository modifications are meant to be made to the repository extending the base. + * Any modifications to base repositories are to be made by the generator only + * + * @generator ./utils/scripts/generators/repository-generator.pl + * @docs https://docs.eqemu.io/developer/repositories + */ + +#ifndef EQEMU_BASE_FINDABLE_LOCATION_REPOSITORY_H +#define EQEMU_BASE_FINDABLE_LOCATION_REPOSITORY_H + +#include "../../database.h" +#include "../../strings.h" +#include + +class BaseFindableLocationRepository { +public: + struct FindableLocation { + uint32_t id; + std::string zone; + int32_t version; + int32_t findable_id; + int32_t findable_sub_id; + int32_t type; + int32_t zone_id; + int32_t zone_id_index; + float x; + float y; + float z; + int8_t min_expansion; + int8_t max_expansion; + std::string content_flags; + std::string content_flags_disabled; + }; + + static std::string PrimaryKey() + { + return std::string("id"); + } + + static std::vector Columns() + { + return { + "id", + "zone", + "version", + "findable_id", + "findable_sub_id", + "type", + "zone_id", + "zone_id_index", + "x", + "y", + "z", + "min_expansion", + "max_expansion", + "content_flags", + "content_flags_disabled", + }; + } + + static std::vector SelectColumns() + { + return { + "id", + "zone", + "version", + "findable_id", + "findable_sub_id", + "type", + "zone_id", + "zone_id_index", + "x", + "y", + "z", + "min_expansion", + "max_expansion", + "content_flags", + "content_flags_disabled", + }; + } + + static std::string ColumnsRaw() + { + return std::string(Strings::Implode(", ", Columns())); + } + + static std::string SelectColumnsRaw() + { + return std::string(Strings::Implode(", ", SelectColumns())); + } + + static std::string TableName() + { + return std::string("findable_location"); + } + + static std::string BaseSelect() + { + return fmt::format( + "SELECT {} FROM {}", + SelectColumnsRaw(), + TableName() + ); + } + + static std::string BaseInsert() + { + return fmt::format( + "INSERT INTO {} ({}) ", + TableName(), + ColumnsRaw() + ); + } + + static FindableLocation NewEntity() + { + FindableLocation e{}; + + e.id = 0; + e.zone = ""; + e.version = 0; + e.findable_id = 0; + e.findable_sub_id = 0; + e.type = 0; + e.zone_id = 0; + e.zone_id_index = 0; + e.x = 0; + e.y = 0; + e.z = 0; + e.min_expansion = -1; + e.max_expansion = -1; + e.content_flags = ""; + e.content_flags_disabled = ""; + + return e; + } + + static FindableLocation GetFindableLocation( + const std::vector &findable_locations, + int findable_location_id + ) + { + for (auto &findable_location : findable_locations) { + if (findable_location.id == findable_location_id) { + return findable_location; + } + } + + return NewEntity(); + } + + static FindableLocation FindOne( + Database& db, + int findable_location_id + ) + { + auto results = db.QueryDatabase( + fmt::format( + "{} WHERE {} = {} LIMIT 1", + BaseSelect(), + PrimaryKey(), + findable_location_id + ) + ); + + auto row = results.begin(); + if (results.RowCount() == 1) { + FindableLocation e{}; + + e.id = row[0] ? static_cast(strtoul(row[0], nullptr, 10)) : 0; + e.zone = row[1] ? row[1] : ""; + e.version = row[2] ? static_cast(atoi(row[2])) : 0; + e.findable_id = row[3] ? static_cast(atoi(row[3])) : 0; + e.findable_sub_id = row[4] ? static_cast(atoi(row[4])) : 0; + e.type = row[5] ? static_cast(atoi(row[5])) : 0; + e.zone_id = row[6] ? static_cast(atoi(row[6])) : 0; + e.zone_id_index = row[7] ? static_cast(atoi(row[7])) : 0; + e.x = row[8] ? strtof(row[8], nullptr) : 0; + e.y = row[9] ? strtof(row[9], nullptr) : 0; + e.z = row[10] ? strtof(row[10], nullptr) : 0; + e.min_expansion = row[11] ? static_cast(atoi(row[11])) : -1; + e.max_expansion = row[12] ? static_cast(atoi(row[12])) : -1; + e.content_flags = row[13] ? row[13] : ""; + e.content_flags_disabled = row[14] ? row[14] : ""; + + return e; + } + + return NewEntity(); + } + + static int DeleteOne( + Database& db, + int findable_location_id + ) + { + auto results = db.QueryDatabase( + fmt::format( + "DELETE FROM {} WHERE {} = {}", + TableName(), + PrimaryKey(), + findable_location_id + ) + ); + + return (results.Success() ? results.RowsAffected() : 0); + } + + static int UpdateOne( + Database& db, + const FindableLocation &e + ) + { + std::vector v; + + auto columns = Columns(); + + v.push_back(columns[1] + " = '" + Strings::Escape(e.zone) + "'"); + v.push_back(columns[2] + " = " + std::to_string(e.version)); + v.push_back(columns[3] + " = " + std::to_string(e.findable_id)); + v.push_back(columns[4] + " = " + std::to_string(e.findable_sub_id)); + v.push_back(columns[5] + " = " + std::to_string(e.type)); + v.push_back(columns[6] + " = " + std::to_string(e.zone_id)); + v.push_back(columns[7] + " = " + std::to_string(e.zone_id_index)); + v.push_back(columns[8] + " = " + std::to_string(e.x)); + v.push_back(columns[9] + " = " + std::to_string(e.y)); + v.push_back(columns[10] + " = " + std::to_string(e.z)); + v.push_back(columns[11] + " = " + std::to_string(e.min_expansion)); + v.push_back(columns[12] + " = " + std::to_string(e.max_expansion)); + v.push_back(columns[13] + " = '" + Strings::Escape(e.content_flags) + "'"); + v.push_back(columns[14] + " = '" + Strings::Escape(e.content_flags_disabled) + "'"); + + auto results = db.QueryDatabase( + fmt::format( + "UPDATE {} SET {} WHERE {} = {}", + TableName(), + Strings::Implode(", ", v), + PrimaryKey(), + e.id + ) + ); + + return (results.Success() ? results.RowsAffected() : 0); + } + + static FindableLocation InsertOne( + Database& db, + FindableLocation e + ) + { + std::vector v; + + v.push_back(std::to_string(e.id)); + v.push_back("'" + Strings::Escape(e.zone) + "'"); + v.push_back(std::to_string(e.version)); + v.push_back(std::to_string(e.findable_id)); + v.push_back(std::to_string(e.findable_sub_id)); + v.push_back(std::to_string(e.type)); + v.push_back(std::to_string(e.zone_id)); + v.push_back(std::to_string(e.zone_id_index)); + v.push_back(std::to_string(e.x)); + v.push_back(std::to_string(e.y)); + v.push_back(std::to_string(e.z)); + v.push_back(std::to_string(e.min_expansion)); + v.push_back(std::to_string(e.max_expansion)); + v.push_back("'" + Strings::Escape(e.content_flags) + "'"); + v.push_back("'" + Strings::Escape(e.content_flags_disabled) + "'"); + + auto results = db.QueryDatabase( + fmt::format( + "{} VALUES ({})", + BaseInsert(), + Strings::Implode(",", v) + ) + ); + + if (results.Success()) { + e.id = results.LastInsertedID(); + return e; + } + + e = NewEntity(); + + return e; + } + + static int InsertMany( + Database& db, + const std::vector &entries + ) + { + std::vector insert_chunks; + + for (auto &e: entries) { + std::vector v; + + v.push_back(std::to_string(e.id)); + v.push_back("'" + Strings::Escape(e.zone) + "'"); + v.push_back(std::to_string(e.version)); + v.push_back(std::to_string(e.findable_id)); + v.push_back(std::to_string(e.findable_sub_id)); + v.push_back(std::to_string(e.type)); + v.push_back(std::to_string(e.zone_id)); + v.push_back(std::to_string(e.zone_id_index)); + v.push_back(std::to_string(e.x)); + v.push_back(std::to_string(e.y)); + v.push_back(std::to_string(e.z)); + v.push_back(std::to_string(e.min_expansion)); + v.push_back(std::to_string(e.max_expansion)); + v.push_back("'" + Strings::Escape(e.content_flags) + "'"); + v.push_back("'" + Strings::Escape(e.content_flags_disabled) + "'"); + + insert_chunks.push_back("(" + Strings::Implode(",", v) + ")"); + } + + std::vector v; + + auto results = db.QueryDatabase( + fmt::format( + "{} VALUES {}", + BaseInsert(), + Strings::Implode(",", insert_chunks) + ) + ); + + return (results.Success() ? results.RowsAffected() : 0); + } + + static std::vector All(Database& db) + { + std::vector all_entries; + + auto results = db.QueryDatabase( + fmt::format( + "{}", + BaseSelect() + ) + ); + + all_entries.reserve(results.RowCount()); + + for (auto row = results.begin(); row != results.end(); ++row) { + FindableLocation e{}; + + e.id = row[0] ? static_cast(strtoul(row[0], nullptr, 10)) : 0; + e.zone = row[1] ? row[1] : ""; + e.version = row[2] ? static_cast(atoi(row[2])) : 0; + e.findable_id = row[3] ? static_cast(atoi(row[3])) : 0; + e.findable_sub_id = row[4] ? static_cast(atoi(row[4])) : 0; + e.type = row[5] ? static_cast(atoi(row[5])) : 0; + e.zone_id = row[6] ? static_cast(atoi(row[6])) : 0; + e.zone_id_index = row[7] ? static_cast(atoi(row[7])) : 0; + e.x = row[8] ? strtof(row[8], nullptr) : 0; + e.y = row[9] ? strtof(row[9], nullptr) : 0; + e.z = row[10] ? strtof(row[10], nullptr) : 0; + e.min_expansion = row[11] ? static_cast(atoi(row[11])) : -1; + e.max_expansion = row[12] ? static_cast(atoi(row[12])) : -1; + e.content_flags = row[13] ? row[13] : ""; + e.content_flags_disabled = row[14] ? row[14] : ""; + + all_entries.push_back(e); + } + + return all_entries; + } + + static std::vector GetWhere(Database& db, const std::string &where_filter) + { + std::vector all_entries; + + auto results = db.QueryDatabase( + fmt::format( + "{} WHERE {}", + BaseSelect(), + where_filter + ) + ); + + all_entries.reserve(results.RowCount()); + + for (auto row = results.begin(); row != results.end(); ++row) { + FindableLocation e{}; + + e.id = row[0] ? static_cast(strtoul(row[0], nullptr, 10)) : 0; + e.zone = row[1] ? row[1] : ""; + e.version = row[2] ? static_cast(atoi(row[2])) : 0; + e.findable_id = row[3] ? static_cast(atoi(row[3])) : 0; + e.findable_sub_id = row[4] ? static_cast(atoi(row[4])) : 0; + e.type = row[5] ? static_cast(atoi(row[5])) : 0; + e.zone_id = row[6] ? static_cast(atoi(row[6])) : 0; + e.zone_id_index = row[7] ? static_cast(atoi(row[7])) : 0; + e.x = row[8] ? strtof(row[8], nullptr) : 0; + e.y = row[9] ? strtof(row[9], nullptr) : 0; + e.z = row[10] ? strtof(row[10], nullptr) : 0; + e.min_expansion = row[11] ? static_cast(atoi(row[11])) : -1; + e.max_expansion = row[12] ? static_cast(atoi(row[12])) : -1; + e.content_flags = row[13] ? row[13] : ""; + e.content_flags_disabled = row[14] ? row[14] : ""; + + all_entries.push_back(e); + } + + return all_entries; + } + + static int DeleteWhere(Database& db, const std::string &where_filter) + { + auto results = db.QueryDatabase( + fmt::format( + "DELETE FROM {} WHERE {}", + TableName(), + where_filter + ) + ); + + return (results.Success() ? results.RowsAffected() : 0); + } + + static int Truncate(Database& db) + { + auto results = db.QueryDatabase( + fmt::format( + "TRUNCATE TABLE {}", + TableName() + ) + ); + + return (results.Success() ? results.RowsAffected() : 0); + } + + static int64 GetMaxId(Database& db) + { + auto results = db.QueryDatabase( + fmt::format( + "SELECT COALESCE(MAX({}), 0) FROM {}", + PrimaryKey(), + TableName() + ) + ); + + return (results.Success() && results.begin()[0] ? strtoll(results.begin()[0], nullptr, 10) : 0); + } + + static int64 Count(Database& db, const std::string &where_filter = "") + { + auto results = db.QueryDatabase( + fmt::format( + "SELECT COUNT(*) FROM {} {}", + TableName(), + (where_filter.empty() ? "" : "WHERE " + where_filter) + ) + ); + + return (results.Success() && results.begin()[0] ? strtoll(results.begin()[0], nullptr, 10) : 0); + } + + static std::string BaseReplace() + { + return fmt::format( + "REPLACE INTO {} ({}) ", + TableName(), + ColumnsRaw() + ); + } + + static int ReplaceOne( + Database& db, + const FindableLocation &e + ) + { + std::vector v; + + v.push_back(std::to_string(e.id)); + v.push_back("'" + Strings::Escape(e.zone) + "'"); + v.push_back(std::to_string(e.version)); + v.push_back(std::to_string(e.findable_id)); + v.push_back(std::to_string(e.findable_sub_id)); + v.push_back(std::to_string(e.type)); + v.push_back(std::to_string(e.zone_id)); + v.push_back(std::to_string(e.zone_id_index)); + v.push_back(std::to_string(e.x)); + v.push_back(std::to_string(e.y)); + v.push_back(std::to_string(e.z)); + v.push_back(std::to_string(e.min_expansion)); + v.push_back(std::to_string(e.max_expansion)); + v.push_back("'" + Strings::Escape(e.content_flags) + "'"); + v.push_back("'" + Strings::Escape(e.content_flags_disabled) + "'"); + + auto results = db.QueryDatabase( + fmt::format( + "{} VALUES ({})", + BaseReplace(), + Strings::Implode(",", v) + ) + ); + + return (results.Success() ? results.RowsAffected() : 0); + } + + static int ReplaceMany( + Database& db, + const std::vector &entries + ) + { + std::vector insert_chunks; + + for (auto &e: entries) { + std::vector v; + + v.push_back(std::to_string(e.id)); + v.push_back("'" + Strings::Escape(e.zone) + "'"); + v.push_back(std::to_string(e.version)); + v.push_back(std::to_string(e.findable_id)); + v.push_back(std::to_string(e.findable_sub_id)); + v.push_back(std::to_string(e.type)); + v.push_back(std::to_string(e.zone_id)); + v.push_back(std::to_string(e.zone_id_index)); + v.push_back(std::to_string(e.x)); + v.push_back(std::to_string(e.y)); + v.push_back(std::to_string(e.z)); + v.push_back(std::to_string(e.min_expansion)); + v.push_back(std::to_string(e.max_expansion)); + v.push_back("'" + Strings::Escape(e.content_flags) + "'"); + v.push_back("'" + Strings::Escape(e.content_flags_disabled) + "'"); + + insert_chunks.push_back("(" + Strings::Implode(",", v) + ")"); + } + + std::vector v; + + auto results = db.QueryDatabase( + fmt::format( + "{} VALUES {}", + BaseReplace(), + Strings::Implode(",", insert_chunks) + ) + ); + + return (results.Success() ? results.RowsAffected() : 0); + } +}; + +#endif //EQEMU_BASE_FINDABLE_LOCATION_REPOSITORY_H diff --git a/common/repositories/findable_location_repository.h b/common/repositories/findable_location_repository.h new file mode 100644 index 000000000..fddb3ec73 --- /dev/null +++ b/common/repositories/findable_location_repository.h @@ -0,0 +1,50 @@ +#ifndef EQEMU_FINDABLE_LOCATION_REPOSITORY_H +#define EQEMU_FINDABLE_LOCATION_REPOSITORY_H + +#include "../database.h" +#include "../strings.h" +#include "base/base_findable_location_repository.h" + +class FindableLocationRepository: public BaseFindableLocationRepository { +public: + + /** + * This file was auto generated and can be modified and extended upon + * + * Base repository methods are automatically + * generated in the "base" version of this repository. The base repository + * is immutable and to be left untouched, while methods in this class + * are used as extension methods for more specific persistence-layer + * accessors or mutators. + * + * Base Methods (Subject to be expanded upon in time) + * + * Note: Not all tables are designed appropriately to fit functionality with all base methods + * + * InsertOne + * UpdateOne + * DeleteOne + * FindOne + * GetWhere(std::string where_filter) + * DeleteWhere(std::string where_filter) + * InsertMany + * All + * + * Example custom methods in a repository + * + * FindableLocationRepository::GetByZoneAndVersion(int zone_id, int zone_version) + * FindableLocationRepository::GetWhereNeverExpires() + * FindableLocationRepository::GetWhereXAndY() + * FindableLocationRepository::DeleteWhereXAndY() + * + * Most of the above could be covered by base methods, but if you as a developer + * find yourself re-using logic for other parts of the code, its best to just make a + * method that can be re-used easily elsewhere especially if it can use a base repository + * method and encapsulate filters there + */ + + // Custom extended repository methods here + +}; + +#endif //EQEMU_FINDABLE_LOCATION_REPOSITORY_H diff --git a/zone/zone.h b/zone/zone.h index 3160ab170..2c7299732 100755 --- a/zone/zone.h +++ b/zone/zone.h @@ -47,6 +47,7 @@ #include "../common/repositories/lootdrop_entries_repository.h" #include "../common/repositories/base_data_repository.h" #include "../common/repositories/skill_caps_repository.h" +#include "../common/repositories/findable_location_repository.h" struct EXPModifier { @@ -526,6 +527,7 @@ private: std::vector m_base_data = { }; // Findable Locations + std::vector m_findable_locations = { }; }; #endif diff --git a/zone/zone_finable_locations.cpp b/zone/zone_finable_locations.cpp index 25b83195c..ac9f7bd8e 100644 --- a/zone/zone_finable_locations.cpp +++ b/zone/zone_finable_locations.cpp @@ -1,13 +1,42 @@ #include "zone.h" void Zone::LoadFindableLocations() { + m_findable_locations = content_db.LoadFindableLocations(GetShortName(), GetInstanceVersion()); + if (m_findable_locations.empty()) { + LogInfo("No findable loacations loaded"); + return; + } } void Zone::ReloadFindableLocations() { + ClearFindableLocations(); + LoadFindableLocations(); } void Zone::ClearFindableLocations() { + m_findable_locations.clear(); } void Zone::SendFindableLocations(Client* client) { + if (m_findable_locations.empty()) { + return; + } + + size_t size = sizeof(uint32) + (m_findable_locations.size() * sizeof(FindableLocation_Struct)); + auto outapp = new EQApplicationPacket(OP_SendFindableLocations, size); + + outapp->WriteUInt32(m_findable_locations.size()); + + for (auto& location : m_findable_locations) { + outapp->WriteUInt32(location.type); + outapp->WriteSInt32(location.findable_id); + outapp->WriteSInt32(location.findable_sub_id); + outapp->WriteSInt32(location.zone_id); + outapp->WriteSInt32(location.zone_id_index); + outapp->WriteFloat(location.y); + outapp->WriteFloat(location.x); + outapp->WriteFloat(location.z); + } + + client->FastQueuePacket(&outapp); } diff --git a/zone/zonedb.cpp b/zone/zonedb.cpp index 3f0ac20e8..586cb9d59 100644 --- a/zone/zonedb.cpp +++ b/zone/zonedb.cpp @@ -50,9 +50,8 @@ #include "../common/repositories/character_corpses_repository.h" #include "../common/repositories/character_corpse_items_repository.h" #include "../common/repositories/zone_repository.h" - #include "../common/repositories/trader_repository.h" - +#include "../common/repositories/findable_location_repository.h" #include #include @@ -2875,6 +2874,15 @@ void ZoneDatabase::UpdateAltCurrencyValue(uint32 char_id, uint32 currency_id, ui CharacterAltCurrencyRepository::ReplaceOne(*this, e); } +std::vector ZoneDatabase::LoadFindableLocations(const std::string& zone_name, int16 version) { + auto findable_locations = FindableLocationRepository::GetWhere( + *this, fmt::format( + "zone = '{}' AND (version = {} OR version = -1) {} ORDER BY id ASC", + zone_name, version, ContentFilterCriteria::apply())); + + return findable_locations; +} + void ZoneDatabase::SaveBuffs(Client *client) { CharacterBuffsRepository::DeleteWhere( diff --git a/zone/zonedb.h b/zone/zonedb.h index ca0447758..169e3c933 100644 --- a/zone/zonedb.h +++ b/zone/zonedb.h @@ -13,6 +13,7 @@ #include "../common/repositories/doors_repository.h" #include "../common/races.h" #include "../common/repositories/npc_faction_entries_repository.h" +#include "../common/repositories/findable_location_repository.h" #include "bot_database.h" @@ -638,6 +639,9 @@ public: void LoadAltCurrencyValues(uint32 char_id, std::map ¤cy); void UpdateAltCurrencyValue(uint32 char_id, uint32 currency_id, uint32 value); + /* Findable Locations */ + std::vector LoadFindableLocations(const std::string& zone_name, int16 version); + /* * Misc stuff. * PLEASE DO NOT ADD TO THIS COLLECTION OF CRAP UNLESS YOUR METHOD