Add wip SQL for findable_locations so people don't have to guess.

common/emu_oplist.h

@@ -465,6 +465,7 @@ N(OP_SendAAStats),
 N(OP_SendAATable),
 N(OP_SendCharInfo),
 N(OP_SendExpZonein),
+N(OP_SendFindableLocations),
 N(OP_SendFindableNPCs),
 N(OP_SendGuildTributes),
 N(OP_SendLoginInfo),

common/eq_packet_structs.h

@@ -4400,11 +4400,6 @@ struct FindPerson_Point {
 	float z;
 };
 
-struct FindPersonRequest_Struct {
-	uint32	npc_id;
-	FindPerson_Point client_pos;
-};
-
 //variable length packet of points
 struct FindPersonResult_Struct {
 	FindPerson_Point dest;
@@ -6436,6 +6431,38 @@ 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*/
+};
+
+struct FindPersonRequest_Struct {
+	FindLocationType type;
+	int32 id;
+	FindPerson_Point client_pos;
+	FindPerson_Point target_pos;
+};
+
 // Restore structure packing to default
 #pragma pack()
 

common/patches/rof.cpp

@@ -4538,10 +4538,14 @@ namespace RoF
 		DECODE_LENGTH_EXACT(structs::FindPersonRequest_Struct);
 		SETUP_DIRECT_DECODE(FindPersonRequest_Struct, structs::FindPersonRequest_Struct);
 
-		IN(npc_id);
+		IN(type)
+		IN(id);
 		IN(client_pos.x);
 		IN(client_pos.y);
 		IN(client_pos.z);
+		IN(target_pos.x);
+		IN(target_pos.y);
+		IN(target_pos.z);
 
 		FINISH_DIRECT_DECODE();
 	}

common/patches/rof2.cpp

@@ -5517,10 +5517,14 @@ namespace RoF2
 		DECODE_LENGTH_EXACT(structs::FindPersonRequest_Struct);
 		SETUP_DIRECT_DECODE(FindPersonRequest_Struct, structs::FindPersonRequest_Struct);
 
-		IN(npc_id);
+		IN(type)
+		IN(id);
 		IN(client_pos.x);
 		IN(client_pos.y);
 		IN(client_pos.z);
+		IN(target_pos.x);
+		IN(target_pos.y);
+		IN(target_pos.z);
 
 		FINISH_DIRECT_DECODE();
 	}

common/patches/rof2_structs.h

@@ -4016,14 +4016,13 @@ struct FindPerson_Point {
 };
 
 struct FindPersonRequest_Struct {
-/*00*/	uint32	unknown00;
+/*00*/	FindLocationType type;
-/*04*/	uint32	npc_id;
+/*04*/	int32 id;
-/*08*/	uint32	unknown08;
+/*08*/	int32 unknown08;
-/*12*/	uint32	unknown12;
+/*12*/	int32 unknown12;
 /*16*/	FindPerson_Point client_pos;
-/*28*/	uint32	unknown28;
+/*28*/	FindPerson_Point target_pos;
-/*32*/	uint32	unknown32;
+/*40*/
-/*36*/	uint32	unknown36;
 };
 
 //variable length packet of points

common/patches/rof_structs.h

@@ -3779,14 +3779,13 @@ struct FindPerson_Point {
 };
 
 struct FindPersonRequest_Struct {
-/*00*/	uint32	unknown00;
+	/*00*/	FindLocationType type;
-/*04*/	uint32	npc_id;
+	/*04*/	int32 id;
-/*08*/	uint32	unknown08;
+	/*08*/	int32 unknown08;
-/*12*/	uint32	unknown12;
+	/*12*/	int32 unknown12;
-/*16*/	FindPerson_Point client_pos;
+	/*16*/	FindPerson_Point client_pos;
-/*28*/	uint32	unknown28;
+	/*28*/	FindPerson_Point target_pos;
-/*32*/	uint32	unknown32;
+	/*40*/
-/*36*/	uint32	unknown36;
 };
 
 //variable length packet of points

common/patches/sod.cpp

@@ -3150,7 +3150,8 @@ namespace SoD
 		DECODE_LENGTH_EXACT(structs::FindPersonRequest_Struct);
 		SETUP_DIRECT_DECODE(FindPersonRequest_Struct, structs::FindPersonRequest_Struct);
 
-		IN(npc_id);
+		emu->type = FindLocationType::LocationPlayer;
+		emu->id = eq->npc_id;
 		IN(client_pos.x);
 		IN(client_pos.y);
 		IN(client_pos.z);

common/patches/sof.cpp

@@ -2605,7 +2605,8 @@ namespace SoF
 		DECODE_LENGTH_EXACT(structs::FindPersonRequest_Struct);
 		SETUP_DIRECT_DECODE(FindPersonRequest_Struct, structs::FindPersonRequest_Struct);
 
-		IN(npc_id);
+		emu->type = FindLocationType::LocationPlayer;
+		emu->id = eq->npc_id;
 		IN(client_pos.x);
 		IN(client_pos.y);
 		IN(client_pos.z);

common/patches/titanium.cpp

@@ -3327,6 +3327,20 @@ namespace Titanium
 		FINISH_DIRECT_DECODE();
 	}
 
+	DECODE(OP_FindPersonRequest)
+	{
+		DECODE_LENGTH_EXACT(structs::FindPersonRequest_Struct);
+		SETUP_DIRECT_DECODE(FindPersonRequest_Struct, structs::FindPersonRequest_Struct);
+
+		emu->type = FindLocationType::LocationPlayer;
+		emu->id = eq->npc_id;
+		IN(client_pos.x);
+		IN(client_pos.y);
+		IN(client_pos.z);
+
+		FINISH_DIRECT_DECODE();
+	}
+
 // file scope helper methods
 	void SerializeItem(EQ::OutBuffer& ob, const EQ::ItemInstance *inst, int16 slot_id_in, uint8 depth) {
 		const char *protection      = "\\\\\\\\\\";

common/patches/titanium_ops.h

@@ -132,6 +132,7 @@ D(OP_TradeSkillCombine)
 D(OP_TributeItem)
 D(OP_WearChange)
 D(OP_WhoAllRequest)
+D(OP_FindPersonRequest)
 
 #undef E
 #undef D

common/patches/uf.cpp

@@ -3982,7 +3982,8 @@ namespace UF
 		DECODE_LENGTH_EXACT(structs::FindPersonRequest_Struct);
 		SETUP_DIRECT_DECODE(FindPersonRequest_Struct, structs::FindPersonRequest_Struct);
 
-		IN(npc_id);
+		emu->type = FindLocationType::LocationPlayer;
+		emu->id = eq->npc_id;
 		IN(client_pos.x);
 		IN(client_pos.y);
 		IN(client_pos.z);

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 <ctime>
+
+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<std::string> 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<std::string> 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<FindableLocation> &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<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.zone                   = row[1] ? row[1] : "";
+			e.version                = row[2] ? static_cast<int32_t>(atoi(row[2])) : 0;
+			e.findable_id            = row[3] ? static_cast<int32_t>(atoi(row[3])) : 0;
+			e.findable_sub_id        = row[4] ? static_cast<int32_t>(atoi(row[4])) : 0;
+			e.type                   = row[5] ? static_cast<int32_t>(atoi(row[5])) : 0;
+			e.zone_id                = row[6] ? static_cast<int32_t>(atoi(row[6])) : 0;
+			e.zone_id_index          = row[7] ? static_cast<int32_t>(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<int8_t>(atoi(row[11])) : -1;
+			e.max_expansion          = row[12] ? static_cast<int8_t>(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<std::string> 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<std::string> 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<FindableLocation> &entries
+	)
+	{
+		std::vector<std::string> insert_chunks;
+
+		for (auto &e: entries) {
+			std::vector<std::string> 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<std::string> v;
+
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"{} VALUES {}",
+				BaseInsert(),
+				Strings::Implode(",", insert_chunks)
+			)
+		);
+
+		return (results.Success() ? results.RowsAffected() : 0);
+	}
+
+	static std::vector<FindableLocation> All(Database& db)
+	{
+		std::vector<FindableLocation> 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<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.zone                   = row[1] ? row[1] : "";
+			e.version                = row[2] ? static_cast<int32_t>(atoi(row[2])) : 0;
+			e.findable_id            = row[3] ? static_cast<int32_t>(atoi(row[3])) : 0;
+			e.findable_sub_id        = row[4] ? static_cast<int32_t>(atoi(row[4])) : 0;
+			e.type                   = row[5] ? static_cast<int32_t>(atoi(row[5])) : 0;
+			e.zone_id                = row[6] ? static_cast<int32_t>(atoi(row[6])) : 0;
+			e.zone_id_index          = row[7] ? static_cast<int32_t>(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<int8_t>(atoi(row[11])) : -1;
+			e.max_expansion          = row[12] ? static_cast<int8_t>(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<FindableLocation> GetWhere(Database& db, const std::string &where_filter)
+	{
+		std::vector<FindableLocation> 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<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.zone                   = row[1] ? row[1] : "";
+			e.version                = row[2] ? static_cast<int32_t>(atoi(row[2])) : 0;
+			e.findable_id            = row[3] ? static_cast<int32_t>(atoi(row[3])) : 0;
+			e.findable_sub_id        = row[4] ? static_cast<int32_t>(atoi(row[4])) : 0;
+			e.type                   = row[5] ? static_cast<int32_t>(atoi(row[5])) : 0;
+			e.zone_id                = row[6] ? static_cast<int32_t>(atoi(row[6])) : 0;
+			e.zone_id_index          = row[7] ? static_cast<int32_t>(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<int8_t>(atoi(row[11])) : -1;
+			e.max_expansion          = row[12] ? static_cast<int8_t>(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<std::string> 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<FindableLocation> &entries
+	)
+	{
+		std::vector<std::string> insert_chunks;
+
+		for (auto &e: entries) {
+			std::vector<std::string> 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<std::string> 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

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

common/servertalk.h

@@ -282,6 +282,7 @@
 #define ServerOP_ReloadBaseData 0x4128
 #define ServerOP_ReloadSkillCaps 0x4129
 #define ServerOP_ReloadNPCSpells 0x4130
+#define ServerOP_ReloadFindableLocations 0x4131
 
 #define ServerOP_CZDialogueWindow 0x4500
 #define ServerOP_CZLDoNUpdate 0x4501

utils/patches/patch_RoF2.conf

@@ -311,6 +311,7 @@ OP_SetGroupTarget=0x2814
 OP_Charm=0x5d92
 OP_Stun=0x36a4
 OP_SendFindableNPCs=0x4613
+OP_SendFindableLocations=0x6a68
 OP_FindPersonRequest=0x5cea
 OP_FindPersonReply=0x7e58
 OP_Sound=0x1a30

utils/sql/findable_locations_wip.sql

@@ -0,0 +1,33 @@
+CREATE TABLE `findable_location` (
+	`id` INT(10) UNSIGNED NOT NULL AUTO_INCREMENT,
+	`zone` VARCHAR(32) NOT NULL COLLATE 'utf8mb4_general_ci',
+	`version` INT(11) NOT NULL DEFAULT '0',
+	`findable_id` INT(11) NOT NULL DEFAULT '0',
+	`findable_sub_id` INT(11) NOT NULL DEFAULT '0',
+	`type` INT(11) NOT NULL DEFAULT '0',
+	`zone_id` INT(11) NOT NULL DEFAULT '0',
+	`zone_id_index` INT(11) NOT NULL DEFAULT '0',
+	`x` FLOAT NOT NULL DEFAULT '0',
+	`y` FLOAT NOT NULL DEFAULT '0',
+	`z` FLOAT NOT NULL DEFAULT '0',
+	`min_expansion` TINYINT(4) NOT NULL DEFAULT '-1',
+	`max_expansion` TINYINT(4) NOT NULL DEFAULT '-1',
+	`content_flags` VARCHAR(100) NULL DEFAULT NULL COLLATE 'utf8mb4_general_ci',
+	`content_flags_disabled` VARCHAR(100) NULL DEFAULT NULL COLLATE 'utf8mb4_general_ci',
+	PRIMARY KEY (`id`) USING BTREE,
+	INDEX `zone_version` (`zone`, `version`) USING BTREE
+);
+
+INSERT INTO `findable_location` (zone, version, findable_id, findable_sub_id, type, zone_id, zone_id_index, x, y, z) VALUES ('qeynos2', 0, 77, -1, 6, 202, 0, 484.484130859375, 183.69752502441406, 0.0020000000949949026);
+INSERT INTO `findable_location` (zone, version, findable_id, findable_sub_id, type, zone_id, zone_id_index, x, y, z) VALUES ('qeynos2', 0, 16, 0, 7, 45, 1, 342.86285400390625, 188.9244384765625, -181.92721557617188);
+INSERT INTO `findable_location` (zone, version, findable_id, findable_sub_id, type, zone_id, zone_id_index, x, y, z) VALUES ('qeynos2', 0, 17, 0, 7, 1, 1, -6.997137069702148, -174.92999267578125, 15.993850708007812);
+INSERT INTO `findable_location` (zone, version, findable_id, findable_sub_id, type, zone_id, zone_id_index, x, y, z) VALUES ('qeynos2', 0, 18, 0, 7, 1, 2, 356.8572692871094, -48.98040771484375, 15.993560791015625);
+INSERT INTO `findable_location` (zone, version, findable_id, findable_sub_id, type, zone_id, zone_id_index, x, y, z) VALUES ('qeynos2', 0, 19, 0, 7, 4, 1, 566.7733154296875, 1699.3203125, 54.97816467285156);
+INSERT INTO `findable_location` (zone, version, findable_id, findable_sub_id, type, zone_id, zone_id_index, x, y, z) VALUES ('qeynos2', 0, 19, 2, 7, 4, 2, 230.90762329101562, 1699.3203125, 59.97674560546875);
+INSERT INTO `findable_location` (zone, version, findable_id, findable_sub_id, type, zone_id, zone_id_index, x, y, z) VALUES ('qeynos2', 0, 20, 0, 7, 4, 3, 141.9432373046875, 1699.3203125, 20.986679077148438);
+INSERT INTO `findable_location` (zone, version, findable_id, findable_sub_id, type, zone_id, zone_id_index, x, y, z) VALUES ('qeynos2', 0, 21, 0, 7, 4, 4, -3.9984021186828613, 1699.3203125, 20.986663818359375);
+INSERT INTO `findable_location` (zone, version, findable_id, findable_sub_id, type, zone_id, zone_id_index, x, y, z) VALUES ('qeynos2', 0, 21, 3, 7, 4, 5, -333.866455078125, 1699.3203125, 59.97560119628906);
+INSERT INTO `findable_location` (zone, version, findable_id, findable_sub_id, type, zone_id, zone_id_index, x, y, z) VALUES ('qeynos2', 0, 22, 0, 7, 4, 6, 899.6401977539062, 1699.3203125, 54.97816467285156);
+INSERT INTO `findable_location` (zone, version, findable_id, findable_sub_id, type, zone_id, zone_id_index, x, y, z) VALUES ('qeynos2', 0, 23, 0, 7, 4, 7, -799.6800537109375, 1699.3203125, 54.97825622558594);
+INSERT INTO `findable_location` (zone, version, findable_id, findable_sub_id, type, zone_id, zone_id_index, x, y, z) VALUES ('qeynos2', 0, 53, 0, 7, 45, 2, 76.9692153930664, 174.9300537109375, -34.986000061035156);
+INSERT INTO `findable_location` (zone, version, findable_id, findable_sub_id, type, zone_id, zone_id_index, x, y, z) VALUES ('qeynos2', 0, 54, 0, 7, 45, 3, -160.9356231689453, 300.879638671875, -139.94403076171875);

world/eqemu_api_world_data_service.cpp

@@ -140,6 +140,7 @@ std::vector<Reload> reload_types = {
 	Reload{.command = "aa", .opcode = ServerOP_ReloadAAData, .desc = "Alternate Advancement"},
 	Reload{.command = "alternate_currencies", .opcode = ServerOP_ReloadAlternateCurrencies, .desc = "Alternate Currencies"},
 	Reload{.command = "base_data", .opcode = ServerOP_ReloadBaseData, .desc = "Base Data"},
+	Reload{.command = "finable_locations", .opcode = ServerOP_ReloadFindableLocations, .desc = "Findable Locations"},
 	Reload{.command = "blocked_spells", .opcode = ServerOP_ReloadBlockedSpells, .desc = "Blocked Spells"},
 	Reload{.command = "commands", .opcode = ServerOP_ReloadCommands, .desc = "Commands"},
 	Reload{.command = "content_flags", .opcode = ServerOP_ReloadContentFlags, .desc = "Content Flags"},

world/zoneserver.cpp

@@ -1401,6 +1401,7 @@ void ZoneServer::HandleMessage(uint16 opcode, const EQ::Net::Packet &p) {
 		case ServerOP_ReloadAAData:
 		case ServerOP_ReloadAlternateCurrencies:
 		case ServerOP_ReloadBaseData:
+		case ServerOP_ReloadFindableLocations:
 		case ServerOP_ReloadBlockedSpells:
 		case ServerOP_ReloadCommands:
 		case ServerOP_ReloadDoors:

zone/CMakeLists.txt

@@ -170,6 +170,7 @@ SET(zone_sources
     zonedb.cpp
     zone_base_data.cpp
     zone_event_scheduler.cpp
+	zone_finable_locations.cpp
     zone_npc_factions.cpp
     zone_reload.cpp
     zoning.cpp

zone/client.cpp

@@ -11995,15 +11995,13 @@ void Client::MaxSkills()
 	}
 }
 
-void Client::SendPath(Mob* target)
+void Client::SendPath(Mob* target) {
-{
 	if (!target) {
 		EQApplicationPacket outapp(OP_FindPersonReply, 0);
 		QueuePacket(&outapp);
 		return;
 	}
 
-
 	if (
 		!RuleB(Pathing, Find) &&
 		RuleB(Bazaar, EnableWarpToTrader) &&
@@ -12011,7 +12009,7 @@ void Client::SendPath(Mob* target)
 		(
 			target->CastToClient()->IsTrader() ||
 			target->CastToClient()->IsBuyer()
-		)
+			)
 		) {
 		Message(
 			Chat::Yellow,
@@ -12031,6 +12029,17 @@ void Client::SendPath(Mob* target)
 		return;
 	}
 
+	glm::vec3 target_loc(
+		target->GetX(),
+		target->GetY(),
+		target->GetZ() + (target->GetSize() < 6.0 ? 6 : target->GetSize()) * HEAD_POSITION
+	);
+
+	SendPath(target_loc);
+}
+
+void Client::SendPath(const glm::vec3& loc)
+{
 	std::vector<FindPerson_Point> points;
 
 	if (!RuleB(Pathing, Find) || !zone->pathing) {
@@ -12041,9 +12050,9 @@ void Client::SendPath(Mob* target)
 		a.x = GetX();
 		a.y = GetY();
 		a.z = GetZ();
-		b.x = target->GetX();
+		b.x = loc.x;
-		b.y = target->GetY();
+		b.y = loc.y;
-		b.z = target->GetZ();
+		b.z = loc.z;
 
 		points.push_back(a);
 		points.push_back(b);
@@ -12056,9 +12065,9 @@ void Client::SendPath(Mob* target)
 		);
 
 		glm::vec3 path_end(
-			target->GetX(),
+			loc.x,
-			target->GetY(),
+			loc.y,
-			target->GetZ() + (target->GetSize() < 6.0 ? 6 : target->GetSize()) * HEAD_POSITION
+			loc.z
 		);
 
 		bool partial   = false;
@@ -12081,18 +12090,6 @@ void Client::SendPath(Mob* target)
 
 		bool leads_to_teleporter = false;
 
-		auto v = path_list.back();
-
-		p.x = v.pos.x;
-		p.y = v.pos.y;
-		p.z = v.pos.z;
-		points.push_back(p);
-
-		p.x = GetX();
-		p.y = GetY();
-		p.z = GetZ();
-		points.push_back(p);
-
 		for (const auto &n: path_list) {
 			if (n.teleport) {
 				leads_to_teleporter = true;
@@ -12108,14 +12105,6 @@ void Client::SendPath(Mob* target)
 
 			++point_number;
 		}
-
-		if (!leads_to_teleporter) {
-			p.x = target->GetX();
-			p.y = target->GetY();
-			p.z = target->GetZ();
-
-			points.push_back(p);
-		}
 	}
 
 	SendPathPacket(points);

zone/client.h

@@ -869,6 +869,7 @@ public:
 	int GetAccountAge();
 
 	void SendPath(Mob* target);
+	void SendPath(const glm::vec3 &loc);
 
 	bool IsDiscovered(uint32 itemid);
 	void DiscoverItem(uint32 itemid);

zone/client_packet.cpp

@@ -858,6 +858,9 @@ void Client::CompleteConnect()
 	if (ClientVersion() >= EQ::versions::ClientVersion::SoD)
 		entity_list.SendFindableNPCList(this);
 
+	if (ClientVersion() >= EQ::versions::ClientVersion::RoF2)
+		zone->SendFindableLocations(this);
+
 	if (IsInAGuild()) {
 		if (firstlogon == 1) {
 			guild_mgr.UpdateDbMemberOnline(CharacterID(), true);
@@ -6474,9 +6477,40 @@ void Client::Handle_OP_FindPersonRequest(const EQApplicationPacket *app)
 	else {
 		auto* t = (FindPersonRequest_Struct*)app->pBuffer;
 
-		auto* m = entity_list.GetMob(t->npc_id);
+		switch (t->type) {
+		case FindLocationType::LocationPlayer: {
+			auto* m = entity_list.GetMob(t->id);
+			SendPath(m);
+			break;
+		}
+		case FindLocationType::LocationSwitch:
+		{
+			auto *d = entity_list.GetDoorsByDoorID(t->id);
+			if (d == nullptr) {
+				Message(Chat::Red, "Switch for find not found.");
+				return;
+			}
 
-		SendPath(m);
+			glm::vec3 door_loc;
+			door_loc.x = d->GetX();
+			door_loc.y = d->GetY();
+			door_loc.z = d->GetZ();
+			SendPath(door_loc);
+			break;
+		}
+		case FindLocationType::LocationLocation:
+		{
+			glm::vec3 target_pos;
+			target_pos.x = t->target_pos.x;
+			target_pos.y = t->target_pos.y;
+			target_pos.z = t->target_pos.z;
+
+			SendPath(target_pos);
+			break;
+		}
+		default:
+			break;
+		}
 	}
 }
 

zone/lua_packet.cpp

@@ -839,6 +839,7 @@ luabind::scope lua_register_packet_opcodes() {
 		luabind::value("GroupLeaderChange", static_cast<int>(OP_GroupLeaderChange)),
 		luabind::value("GroupLeadershipAAUpdate", static_cast<int>(OP_GroupLeadershipAAUpdate)),
 		luabind::value("GroupRoles", static_cast<int>(OP_GroupRoles)),
+		luabind::value("OP_SendFindableLocations", static_cast<int>(OP_SendFindableLocations)),
 		luabind::value("SendFindableNPCs", static_cast<int>(OP_SendFindableNPCs)),
 		luabind::value("HideCorpse", static_cast<int>(OP_HideCorpse)),
 		luabind::value("TargetBuffs", static_cast<int>(OP_TargetBuffs)),

zone/pathing.cpp

@@ -72,22 +72,19 @@ void Client::SendPathPacket(const std::vector<FindPerson_Point> &points) {
 			Message(Chat::System, "Total points %u", points.size());
 		}
 		
-		int len = sizeof(FindPersonResult_Struct) + (points.size() + 1) * sizeof(FindPerson_Point);
+		int len = (points.size() + 1) * sizeof(FindPerson_Point);
 		auto outapp = new EQApplicationPacket(OP_FindPersonReply, len);
-		FindPersonResult_Struct* fpr = (FindPersonResult_Struct*)outapp->pBuffer;
-		
-		std::vector<FindPerson_Point>::iterator cur, end;
-		cur = points.begin();
-		end = points.end();
-		unsigned int r;
-		for (r = 0; cur != end; ++cur, r++) {
-			fpr->path[r] = *cur;
 		
+		auto& last = points.back();
+		outapp->WriteFloat(last.y);
+		outapp->WriteFloat(last.x);
+		outapp->WriteFloat(last.z);
+
+		for (auto& p : points) {
+			outapp->WriteFloat(p.y);
+			outapp->WriteFloat(p.x);
+			outapp->WriteFloat(p.z);
 		}
-		//put the last element into the destination field
-		--cur;
-		fpr->path[r] = *cur;
-		fpr->dest = *cur;
 		
 		FastQueuePacket(&outapp);
 	})

zone/worldserver.cpp

@@ -2005,6 +2005,15 @@ void WorldServer::HandleMessage(uint16 opcode, const EQ::Net::Packet &p)
 
 		break;
 	}
+	case ServerOP_ReloadFindableLocations:
+	{
+		if (zone && zone->IsLoaded()) {
+			zone->SendReloadMessage("Findable Locations");
+			zone->ReloadFindableLocations();
+		}
+
+		break;
+	}
 	case ServerOP_ReloadBlockedSpells:
 	{
 		if (zone && zone->IsLoaded()) {

zone/zone.cpp

@@ -1200,6 +1200,7 @@ bool Zone::Init(bool is_static) {
 	LoadNPCEmotes(&npc_emote_list);
 	LoadAlternateAdvancement();
 	LoadBaseData();
+	LoadFindableLocations();
 	LoadMerchants();
 	LoadTempMerchantData();
 

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
 {
@@ -454,6 +455,12 @@ public:
 	void LoadBaseData();
 	void ReloadBaseData();
 
+	// Findable Locations
+	void LoadFindableLocations();
+	void ReloadFindableLocations();
+	void ClearFindableLocations();
+	void SendFindableLocations(Client* client = nullptr);
+
 
 private:
 	bool      allow_mercs;
@@ -518,6 +525,9 @@ private:
 
 	// Base Data
 	std::vector<BaseDataRepository::BaseData> m_base_data = { };
+
+	// Findable Locations
+	std::vector<FindableLocationRepository::FindableLocation> m_findable_locations = { };
 };
 
 #endif

zone/zone_finable_locations.cpp

@@ -0,0 +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);
+}

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 <ctime>
 #include <iostream>
@@ -2875,6 +2874,15 @@ void ZoneDatabase::UpdateAltCurrencyValue(uint32 char_id, uint32 currency_id, ui
 	CharacterAltCurrencyRepository::ReplaceOne(*this, e);
 }
 
+std::vector<FindableLocationRepository::FindableLocation> 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(

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<uint32, uint32> &currency);
 	void UpdateAltCurrencyValue(uint32 char_id, uint32 currency_id, uint32 value);
 
+	/* Findable Locations */
+	std::vector<FindableLocationRepository::FindableLocation> LoadFindableLocations(const std::string& zone_name, int16 version);
+
 	/*
 		* Misc stuff.
 		* PLEASE DO NOT ADD TO THIS COLLECTION OF CRAP UNLESS YOUR METHOD