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

This allows task elements to update in any zone when it has an invalid
zone id <= 0. This has the same effect as leaving the zones field empty
except "Unknown Zone" instead of "ALL" will be shown in task windows.

Note that Titanium shows "ALL" for a zone id of 0 despite it being an
invalid zone id. This could be manipulated server side to match newer
clients but there isn't much benefit since any other invalid zone id
below 0 can be used to do the same.

CHANGELOG.md

@@ -1,3 +1,157 @@
+## [22.60.0] 11/25/2024
+
+### Bazaar
+
+* Further refinements for instanced bazaar ([#4544](https://github.com/EQEmu/Server/pull/4544)) @neckkola 2024-11-16
+
+### Code
+
+* Fix build with older C++ libraries ([#4549](https://github.com/EQEmu/Server/pull/4549)) @hgtw 2024-11-24
+
+### Config
+
+* Fix World TCP Address Configuration Default ([#4551](https://github.com/EQEmu/Server/pull/4551)) @Akkadius 2024-11-24
+
+### Fixes
+
+* Fix Issue with Perl EVENT_PAYLOAD ([#4545](https://github.com/EQEmu/Server/pull/4545)) @Kinglykrab 2024-11-24
+* Fix Possible Item Loss in Trades ([#4554](https://github.com/EQEmu/Server/pull/4554)) @Kinglykrab 2024-11-24
+* Fix Strings::Commify bug with #mystats ([#4547](https://github.com/EQEmu/Server/pull/4547)) @carolus21rex 2024-11-22
+* Fix an edge case with augmented items inside parceled containers ([#4546](https://github.com/EQEmu/Server/pull/4546)) @neckkola 2024-11-21
+* Fix for bazaar search of containers. ([#4540](https://github.com/EQEmu/Server/pull/4540)) @neckkola 2024-11-15
+* Fix for mult-instanced bazaar zones ([#4541](https://github.com/EQEmu/Server/pull/4541)) @neckkola 2024-11-15
+* Fix for sending money via Parcel, then changing your mind ([#4552](https://github.com/EQEmu/Server/pull/4552)) @neckkola 2024-11-24
+* Fix issue where NPC's are being hidden as traders ([#4539](https://github.com/EQEmu/Server/pull/4539)) @Akkadius 2024-11-15
+* Players could become flagged as a Trader when they were not trading ([#4553](https://github.com/EQEmu/Server/pull/4553)) @neckkola 2024-11-24
+
+### Rules
+
+* Add Rule to Disable NPCs Facing Target ([#4543](https://github.com/EQEmu/Server/pull/4543)) @Kinglykrab 2024-11-24
+
+### Tasks
+
+* Update tasks in all zones if invalid zone set ([#4550](https://github.com/EQEmu/Server/pull/4550)) @hgtw 2024-11-25
+
+## [22.59.1] 11/13/2024
+
+### Hotfix
+
+* Fix faulty database migration condition with databuckets (9285)
+
+## [22.59.0] 11/13/2024
+
+### Databuckets
+
+* Add database index to data_buckets ([#4535](https://github.com/EQEmu/Server/pull/4535)) @Akkadius 2024-11-09
+
+### Fixes
+
+* Bazaar two edge case issues resolved ([#4533](https://github.com/EQEmu/Server/pull/4533)) @neckkola 2024-11-09
+* Check if the mob is already in the close mobs list before inserting  @Akkadius 2024-11-11
+* ScanCloseMobs - Ensure scanning mob has an entity ID  @Akkadius 2024-11-10
+
+### Performance
+
+* Improvements to ScanCloseMobs logic ([#4534](https://github.com/EQEmu/Server/pull/4534)) @Akkadius 2024-11-08
+
+### Quest API
+
+* Add Native Database Querying Interface ([#4531](https://github.com/EQEmu/Server/pull/4531)) @hgtw 2024-11-13
+
+### Rules
+
+* Add Rule for restricting client versions to world server ([#4527](https://github.com/EQEmu/Server/pull/4527)) @knervous 2024-11-12
+
+## [22.58.0] 11/5/2024
+
+### Code
+
+* Add mysql prepared statement support ([#4530](https://github.com/EQEmu/Server/pull/4530)) @hgtw 2024-11-06
+* Update perlbind to 1.1.0 ([#4529](https://github.com/EQEmu/Server/pull/4529)) @hgtw 2024-11-06
+
+### Feature
+
+* Focus Skill Attack Spells ([#4528](https://github.com/EQEmu/Server/pull/4528)) @mmcgarvey 2024-10-31
+
+### Fixes
+
+* Add Missing Lua Registers ([#4525](https://github.com/EQEmu/Server/pull/4525)) @Kinglykrab 2024-10-24
+* Fix cross_zone_set_entity_variable_by_char_id in Lua ([#4526](https://github.com/EQEmu/Server/pull/4526)) @Kinglykrab 2024-10-24
+
+### Loginserver
+
+* Automatifc Opcode File Creation ([#4521](https://github.com/EQEmu/Server/pull/4521)) @KimLS 2024-10-22
+
+### Quest API
+
+* Add Spawn Circle/Grid Methods to Perl/Lua ([#4524](https://github.com/EQEmu/Server/pull/4524)) @Kinglykrab 2024-10-24
+
+## [22.57.1] 10/22/2024
+
+### Bots
+
+* Enable Bot Commands Only if Rule Enabled ([#4519](https://github.com/EQEmu/Server/pull/4519)) @Kinglykrab 2024-10-22
+* Fix pet buffs from saving duplicates every save ([#4520](https://github.com/EQEmu/Server/pull/4520)) @nytmyr 2024-10-22
+
+### Loginserver
+
+* Automatic Opcode File Creation ([#4521](https://github.com/EQEmu/Server/pull/4521)) @KimLS 2024-10-22
+
+## [22.57.0] 10/20/2024
+
+### Bots
+
+* Add "silent" option to ^spawn and mute raid spawn ([#4494](https://github.com/EQEmu/Server/pull/4494)) @nytmyr 2024-10-05
+* Add attack flag when told to attack ([#4490](https://github.com/EQEmu/Server/pull/4490)) @nytmyr 2024-09-29
+* Fix timers loading on spawn and zone ([#4516](https://github.com/EQEmu/Server/pull/4516)) @nytmyr 2024-10-20
+
+### Code
+
+* Fixed a typo in Zoning.cpp ([#4515](https://github.com/EQEmu/Server/pull/4515)) @carolus21rex 2024-10-20
+* Optimization Code Cleanup ([#4489](https://github.com/EQEmu/Server/pull/4489)) @Akkadius 2024-09-30
+* Remove Extra Skill in EQ::skills::GetExtraDamageSkills() ([#4486](https://github.com/EQEmu/Server/pull/4486)) @Kinglykrab 2024-10-03
+
+### Crash
+
+* Fixes a crash when the faction_list db table is empty. ([#4511](https://github.com/EQEmu/Server/pull/4511)) @KimLS 2024-10-14
+
+### Fixes
+
+* Add character_instance_safereturns to tables_to_zero_id ([#4485](https://github.com/EQEmu/Server/pull/4485)) @Morzain 2024-09-26
+* Correctly limit max targets of PBAOE ([#4507](https://github.com/EQEmu/Server/pull/4507)) @catapultam-habeo 2024-10-11
+* FindBestZ selecting false zone floor as bestz - Results in roambox failures ([#4504](https://github.com/EQEmu/Server/pull/4504)) @fryguy503 2024-10-13
+* Fix #set motd Crash ([#4495](https://github.com/EQEmu/Server/pull/4495)) @Kinglykrab 2024-10-05
+* Fix `character_exp_modifiers` Default Values ([#4502](https://github.com/EQEmu/Server/pull/4502)) @Kinglykrab 2024-10-09
+* Fix a display error regarding a few trader/buyer query errors ([#4514](https://github.com/EQEmu/Server/pull/4514)) @neckkola 2024-10-17
+* Fix Group ID 0 in Group::SaveGroupLeaderAA() ([#4487](https://github.com/EQEmu/Server/pull/4487)) @Kinglykrab 2024-10-03
+* Fix Mercenary Encounter Crash ([#4509](https://github.com/EQEmu/Server/pull/4509)) @Kinglykrab 2024-10-12
+* Fix NPC::CanTalk() Crash ([#4499](https://github.com/EQEmu/Server/pull/4499)) @Kinglykrab 2024-10-07
+* Fix Spells:DefaultAOEMaxTargets Default Value ([#4508](https://github.com/EQEmu/Server/pull/4508)) @Kinglykrab 2024-10-12
+* Fix Targeted AOE Max Targets Rule ([#4488](https://github.com/EQEmu/Server/pull/4488)) @Kinglykrab 2024-10-03
+* fixed a bug where it would use npc value instead of faction value in the database. ([#4491](https://github.com/EQEmu/Server/pull/4491)) @regneq 2024-09-29
+* Master of Disguise should apply to illusions casted by others. ([#4506](https://github.com/EQEmu/Server/pull/4506)) @fryguy503 2024-10-11
+* Spells - Self Only (Yellow) cast when non group member is targeted ([#4503](https://github.com/EQEmu/Server/pull/4503)) @fryguy503 2024-10-11
+
+### Loginserver
+
+* Larion loginserver support ([#4492](https://github.com/EQEmu/Server/pull/4492)) @KimLS 2024-10-03
+* Login Fatal Error Spamming ([#4476](https://github.com/EQEmu/Server/pull/4476)) @KimLS 2024-10-09
+
+### Logs
+
+* Add NPC Trades to Player Events ([#4505](https://github.com/EQEmu/Server/pull/4505)) @Kinglykrab 2024-10-13
+
+### Quest API
+
+* Add Buff Fade Methods to Perl/Lua ([#4501](https://github.com/EQEmu/Server/pull/4501)) @Kinglykrab 2024-10-09
+* Add EVENT_READ_ITEM to Perl/Lua ([#4497](https://github.com/EQEmu/Server/pull/4497)) @Kinglykrab 2024-10-08
+* Add NPC List Filter Methods to Perl/Lua ([#4493](https://github.com/EQEmu/Server/pull/4493)) @Kinglykrab 2024-10-04
+* Add Scripting Support to Mercenaries ([#4500](https://github.com/EQEmu/Server/pull/4500)) @Kinglykrab 2024-10-11
+
+### Rules
+
+* Add Rule to disable PVP Regions ([#4513](https://github.com/EQEmu/Server/pull/4513)) @Kinglykrab 2024-10-17
+
 ## [22.56.3] 9/23/2024
 
 ### Fixes

common/CMakeLists.txt

@@ -62,6 +62,7 @@ SET(common_sources
     mutex.cpp
     mysql_request_result.cpp
     mysql_request_row.cpp
+    mysql_stmt.cpp
     opcode_map.cpp
     opcodemgr.cpp
     packet_dump.cpp
@@ -586,6 +587,7 @@ SET(common_headers
     mutex.h
     mysql_request_result.h
     mysql_request_row.h
+    mysql_stmt.h
     op_codes.h
     opcode_dispatch.h
     opcodemgr.h

common/bazaar.cpp

@@ -235,7 +235,8 @@ Bazaar::GetSearchResults(
 		std::vector<ItemSearchType> item_search_types = {
 			{EQ::item::ItemType::ItemTypeAll,                  true},
 			{EQ::item::ItemType::ItemTypeBook,                 item->ItemClass == EQ::item::ItemType::ItemTypeBook},
-			{EQ::item::ItemType::ItemTypeContainer,            item->ItemClass == EQ::item::ItemType::ItemTypeContainer},
+			{EQ::item::ItemType::ItemTypeContainer,            item->ItemClass == EQ::item::ItemType::ItemTypeContainer ||
+			                                                   item->IsClassBag()},
 			{EQ::item::ItemType::ItemTypeAllEffects,           item->Scroll.Effect > 0 && item->Scroll.Effect < 65000},
 			{EQ::item::ItemType::ItemTypeUnknown9,             item->Worn.Effect == 998},
 			{EQ::item::ItemType::ItemTypeUnknown10,            item->Worn.Effect >= 1298 && item->Worn.Effect <= 1307},

common/database/database_update_manifest.cpp

@@ -5758,6 +5758,18 @@ ALTER TABLE `inventory_snapshots`
 ALTER TABLE `character_exp_modifiers`
 MODIFY COLUMN `aa_modifier` float NOT NULL DEFAULT 1.0 AFTER `instance_version`,
 MODIFY COLUMN `exp_modifier` float NOT NULL DEFAULT 1.0 AFTER `aa_modifier`;
+)"
+	},
+	ManifestEntry{
+		.version = 9285,
+		.description = "2024_11_08_data_buckets_indexes.sql",
+		.check = "SHOW CREATE TABLE `data_buckets`",
+		.condition = "missing",
+		.match = "idx_character_expires",
+		.sql = R"(
+CREATE INDEX idx_character_expires ON data_buckets (character_id, expires);
+CREATE INDEX idx_npc_expires ON data_buckets (npc_id, expires);
+CREATE INDEX idx_bot_expires ON data_buckets (bot_id, expires);
 )"
 	}
 // -- template; copy/paste this when you need to create a new entry

common/dbcore.cpp

@@ -7,6 +7,7 @@
 #include "timer.h"
 
 #include "dbcore.h"
+#include "mysql_stmt.h"
 
 #include <fstream>
 #include <iostream>
@@ -436,3 +437,8 @@ MySQLRequestResult DBcore::QueryDatabaseMulti(const std::string &query)
 
 	return r;
 }
+
+mysql::PreparedStmt DBcore::Prepare(std::string query)
+{
+	return mysql::PreparedStmt(*mysql, std::move(query), m_mutex);
+}

common/dbcore.h

@@ -17,6 +17,8 @@
 #define CR_SERVER_GONE_ERROR    2006
 #define CR_SERVER_LOST          2013
 
+namespace mysql { class PreparedStmt; }
+
 class DBcore {
 public:
 	enum eStatus {
@@ -48,6 +50,11 @@ public:
 	}
 	void SetMutex(Mutex *mutex);
 
+	// only safe on connections shared with other threads if results buffered
+	// unsafe to use off main thread due to internal server logging
+	// throws std::runtime_error on failure
+	mysql::PreparedStmt Prepare(std::string query);
+
 protected:
 	bool Open(
 		const char *iHost,

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

@@ -3221,6 +3221,7 @@ struct BuyerMessaging_Struct {
 	char   item_name[64];
 	uint32 slot;
 	uint32 seller_quantity;
+	uint32 purchase_method; // 0 direct merchant, 1 via /barter window
 };
 
 struct BuyerAddBuyertoBarterWindow_Struct {
@@ -4399,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;
@@ -6435,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/eqemu_config.cpp

@@ -94,7 +94,7 @@ void EQEmuConfig::parse_config()
 		auto_database_updates = true;
 	}
 
-	WorldIP      = _root["server"]["world"]["tcp"].get("host", "127.0.0.1").asString();
+	WorldIP      = _root["server"]["world"]["tcp"].get("ip", "127.0.0.1").asString();
 	WorldTCPPort = Strings::ToUnsignedInt(_root["server"]["world"]["tcp"].get("port", "9000").asString());
 
 	TelnetIP      = _root["server"]["world"]["telnet"].get("ip", "127.0.0.1").asString();
@@ -171,6 +171,7 @@ void EQEmuConfig::parse_config()
 	PluginDir    = _root["server"]["directories"].get("plugins", "plugins/").asString();
 	LuaModuleDir = _root["server"]["directories"].get("lua_modules", "lua_modules/").asString();
 	PatchDir     = _root["server"]["directories"].get("patches", "./").asString();
+	OpcodeDir    = _root["server"]["directories"].get("opcodes", "./").asString();
 	SharedMemDir = _root["server"]["directories"].get("shared_memory", "shared/").asString();
 	LogDir       = _root["server"]["directories"].get("logs", "logs/").asString();
 

common/eqemu_config.h

@@ -95,6 +95,7 @@ class EQEmuConfig
 		std::string PluginDir;
 		std::string LuaModuleDir;
 		std::string PatchDir;
+		std::string OpcodeDir;
 		std::string SharedMemDir;
 		std::string LogDir;
 

common/events/player_event_discord_formatter.cpp

@@ -789,50 +789,36 @@ std::string PlayerEventDiscordFormatter::FormatNPCHandinEvent(
 		);
 	}
 
+	std::string npc_info = fmt::format(
+		"{} ({})\n",
+		e.npc_name,
+		e.npc_id
+	);
+
+	npc_info += fmt::format(
+		"Is Quest Handin: {}",
+		e.is_quest_handin ? "Yes" : "No"
+	);
+
 	std::vector<DiscordField> f = {};
 
+
+	BuildDiscordField(&f, "NPC", npc_info);
+
 	if (!handin_items_info.empty()) {
-		BuildDiscordField(
-			&f,
-			"Handin Items",
-			fmt::format(
-				"{}",
-				handin_items_info
-			)
-		);
+		BuildDiscordField(&f, "Handin Items", handin_items_info);
 	}
 
 	if (!handin_money_info.empty()) {
-		BuildDiscordField(
-			&f,
-			"Handin Money",
-			fmt::format(
-				"{}",
-				handin_money_info
-			)
-		);
+		BuildDiscordField(&f, "Handin Money", handin_money_info);
 	}
 
 	if (!return_items_info.empty()) {
-		BuildDiscordField(
-			&f,
-			"Return Items",
-			fmt::format(
-				"{}",
-				return_items_info
-			)
-		);
+		BuildDiscordField(&f, "Return Items", return_items_info);
 	}
 
 	if (!return_money_info.empty()) {
-		BuildDiscordField(
-			&f,
-			"Return Money",
-			fmt::format(
-				"{}",
-				return_money_info
-			)
-		);
+		BuildDiscordField(&f, "Return Money", return_money_info);
 	}
 
 	std::vector<DiscordEmbed> embeds = {};

common/events/player_event_logs.cpp

@@ -654,53 +654,53 @@ const int32_t RETENTION_DAYS_DEFAULT = 7;
 
 void PlayerEventLogs::SetSettingsDefaults()
 {
-	m_settings[PlayerEvent::GM_COMMAND].event_enabled         = 1;
-	m_settings[PlayerEvent::ZONING].event_enabled             = 1;
-	m_settings[PlayerEvent::AA_GAIN].event_enabled            = 1;
-	m_settings[PlayerEvent::AA_PURCHASE].event_enabled        = 1;
-	m_settings[PlayerEvent::FORAGE_SUCCESS].event_enabled     = 0;
-	m_settings[PlayerEvent::FORAGE_FAILURE].event_enabled     = 0;
-	m_settings[PlayerEvent::FISH_SUCCESS].event_enabled       = 0;
-	m_settings[PlayerEvent::FISH_FAILURE].event_enabled       = 0;
-	m_settings[PlayerEvent::ITEM_DESTROY].event_enabled       = 1;
-	m_settings[PlayerEvent::WENT_ONLINE].event_enabled        = 0;
-	m_settings[PlayerEvent::WENT_OFFLINE].event_enabled       = 0;
-	m_settings[PlayerEvent::LEVEL_GAIN].event_enabled         = 1;
-	m_settings[PlayerEvent::LEVEL_LOSS].event_enabled         = 1;
-	m_settings[PlayerEvent::LOOT_ITEM].event_enabled          = 1;
-	m_settings[PlayerEvent::MERCHANT_PURCHASE].event_enabled  = 1;
-	m_settings[PlayerEvent::MERCHANT_SELL].event_enabled      = 1;
-	m_settings[PlayerEvent::GROUP_JOIN].event_enabled         = 0;
-	m_settings[PlayerEvent::GROUP_LEAVE].event_enabled        = 0;
-	m_settings[PlayerEvent::RAID_JOIN].event_enabled          = 0;
-	m_settings[PlayerEvent::RAID_LEAVE].event_enabled         = 0;
-	m_settings[PlayerEvent::GROUNDSPAWN_PICKUP].event_enabled = 1;
-	m_settings[PlayerEvent::NPC_HANDIN].event_enabled         = 1;
-	m_settings[PlayerEvent::SKILL_UP].event_enabled           = 0;
-	m_settings[PlayerEvent::TASK_ACCEPT].event_enabled        = 1;
-	m_settings[PlayerEvent::TASK_UPDATE].event_enabled        = 1;
-	m_settings[PlayerEvent::TASK_COMPLETE].event_enabled      = 1;
-	m_settings[PlayerEvent::TRADE].event_enabled              = 1;
-	m_settings[PlayerEvent::GIVE_ITEM].event_enabled          = 1;
-	m_settings[PlayerEvent::SAY].event_enabled                = 0;
-	m_settings[PlayerEvent::REZ_ACCEPTED].event_enabled       = 1;
-	m_settings[PlayerEvent::DEATH].event_enabled              = 1;
-	m_settings[PlayerEvent::COMBINE_FAILURE].event_enabled    = 1;
-	m_settings[PlayerEvent::COMBINE_SUCCESS].event_enabled    = 1;
-	m_settings[PlayerEvent::DROPPED_ITEM].event_enabled       = 1;
-	m_settings[PlayerEvent::SPLIT_MONEY].event_enabled        = 1;
-	m_settings[PlayerEvent::DZ_JOIN].event_enabled            = 1;
-	m_settings[PlayerEvent::DZ_LEAVE].event_enabled           = 1;
-	m_settings[PlayerEvent::TRADER_PURCHASE].event_enabled    = 1;
-	m_settings[PlayerEvent::TRADER_SELL].event_enabled        = 1;
-	m_settings[PlayerEvent::BANDOLIER_CREATE].event_enabled   = 0;
-	m_settings[PlayerEvent::BANDOLIER_SWAP].event_enabled     = 0;
-	m_settings[PlayerEvent::DISCOVER_ITEM].event_enabled      = 1;
-	m_settings[PlayerEvent::POSSIBLE_HACK].event_enabled      = 1;
-	m_settings[PlayerEvent::KILLED_NPC].event_enabled         = 0;
-	m_settings[PlayerEvent::KILLED_NAMED_NPC].event_enabled   = 1;
-	m_settings[PlayerEvent::KILLED_RAID_NPC].event_enabled    = 1;
-	m_settings[PlayerEvent::ITEM_CREATION].event_enabled      = 1;
+	m_settings[PlayerEvent::GM_COMMAND].event_enabled                = 1;
+	m_settings[PlayerEvent::ZONING].event_enabled                    = 1;
+	m_settings[PlayerEvent::AA_GAIN].event_enabled                   = 1;
+	m_settings[PlayerEvent::AA_PURCHASE].event_enabled               = 1;
+	m_settings[PlayerEvent::FORAGE_SUCCESS].event_enabled            = 0;
+	m_settings[PlayerEvent::FORAGE_FAILURE].event_enabled            = 0;
+	m_settings[PlayerEvent::FISH_SUCCESS].event_enabled              = 0;
+	m_settings[PlayerEvent::FISH_FAILURE].event_enabled              = 0;
+	m_settings[PlayerEvent::ITEM_DESTROY].event_enabled              = 1;
+	m_settings[PlayerEvent::WENT_ONLINE].event_enabled               = 0;
+	m_settings[PlayerEvent::WENT_OFFLINE].event_enabled              = 0;
+	m_settings[PlayerEvent::LEVEL_GAIN].event_enabled                = 1;
+	m_settings[PlayerEvent::LEVEL_LOSS].event_enabled                = 1;
+	m_settings[PlayerEvent::LOOT_ITEM].event_enabled                 = 1;
+	m_settings[PlayerEvent::MERCHANT_PURCHASE].event_enabled         = 1;
+	m_settings[PlayerEvent::MERCHANT_SELL].event_enabled             = 1;
+	m_settings[PlayerEvent::GROUP_JOIN].event_enabled                = 0;
+	m_settings[PlayerEvent::GROUP_LEAVE].event_enabled               = 0;
+	m_settings[PlayerEvent::RAID_JOIN].event_enabled                 = 0;
+	m_settings[PlayerEvent::RAID_LEAVE].event_enabled                = 0;
+	m_settings[PlayerEvent::GROUNDSPAWN_PICKUP].event_enabled        = 1;
+	m_settings[PlayerEvent::NPC_HANDIN].event_enabled                = 1;
+	m_settings[PlayerEvent::SKILL_UP].event_enabled                  = 0;
+	m_settings[PlayerEvent::TASK_ACCEPT].event_enabled               = 1;
+	m_settings[PlayerEvent::TASK_UPDATE].event_enabled               = 1;
+	m_settings[PlayerEvent::TASK_COMPLETE].event_enabled             = 1;
+	m_settings[PlayerEvent::TRADE].event_enabled                     = 1;
+	m_settings[PlayerEvent::GIVE_ITEM].event_enabled                 = 1;
+	m_settings[PlayerEvent::SAY].event_enabled                       = 0;
+	m_settings[PlayerEvent::REZ_ACCEPTED].event_enabled              = 1;
+	m_settings[PlayerEvent::DEATH].event_enabled                     = 1;
+	m_settings[PlayerEvent::COMBINE_FAILURE].event_enabled           = 1;
+	m_settings[PlayerEvent::COMBINE_SUCCESS].event_enabled           = 1;
+	m_settings[PlayerEvent::DROPPED_ITEM].event_enabled              = 1;
+	m_settings[PlayerEvent::SPLIT_MONEY].event_enabled               = 1;
+	m_settings[PlayerEvent::DZ_JOIN].event_enabled                   = 1;
+	m_settings[PlayerEvent::DZ_LEAVE].event_enabled                  = 1;
+	m_settings[PlayerEvent::TRADER_PURCHASE].event_enabled           = 1;
+	m_settings[PlayerEvent::TRADER_SELL].event_enabled               = 1;
+	m_settings[PlayerEvent::BANDOLIER_CREATE].event_enabled          = 0;
+	m_settings[PlayerEvent::BANDOLIER_SWAP].event_enabled            = 0;
+	m_settings[PlayerEvent::DISCOVER_ITEM].event_enabled             = 1;
+	m_settings[PlayerEvent::POSSIBLE_HACK].event_enabled             = 1;
+	m_settings[PlayerEvent::KILLED_NPC].event_enabled                = 0;
+	m_settings[PlayerEvent::KILLED_NAMED_NPC].event_enabled          = 1;
+	m_settings[PlayerEvent::KILLED_RAID_NPC].event_enabled           = 1;
+	m_settings[PlayerEvent::ITEM_CREATION].event_enabled             = 1;
 	m_settings[PlayerEvent::GUILD_TRIBUTE_DONATE_ITEM].event_enabled = 1;
 	m_settings[PlayerEvent::GUILD_TRIBUTE_DONATE_PLAT].event_enabled = 1;
 	m_settings[PlayerEvent::PARCEL_SEND].event_enabled               = 1;

common/events/player_events.h

@@ -860,10 +860,12 @@ namespace PlayerEvent {
 
 	class HandinEntry {
 	public:
-		uint32      item_id;
-		std::string item_name;
-		uint16      charges;
-		bool        attuned;
+		uint32                   item_id;
+		std::string              item_name;
+		std::vector<uint32>      augment_ids;
+		std::vector<std::string> augment_names;
+		uint16                   charges;
+		bool                     attuned;
 
 		// cereal
 		template<class Archive>
@@ -872,6 +874,8 @@ namespace PlayerEvent {
 			ar(
 				CEREAL_NVP(item_id),
 				CEREAL_NVP(item_name),
+				CEREAL_NVP(augment_ids),
+				CEREAL_NVP(augment_names),
 				CEREAL_NVP(charges),
 				CEREAL_NVP(attuned)
 			);
@@ -905,6 +909,7 @@ namespace PlayerEvent {
 		HandinMoney              handin_money;
 		std::vector<HandinEntry> return_items;
 		HandinMoney              return_money;
+		bool                     is_quest_handin;
 
 		// cereal
 		template<class Archive>
@@ -916,7 +921,8 @@ namespace PlayerEvent {
 				CEREAL_NVP(handin_items),
 				CEREAL_NVP(handin_money),
 				CEREAL_NVP(return_items),
-				CEREAL_NVP(return_money)
+				CEREAL_NVP(return_money),
+				CEREAL_NVP(is_quest_handin)
 			);
 		}
 	};

common/mysql_stmt.cpp

@@ -0,0 +1,600 @@
+#include "mysql_stmt.h"
+#include "eqemu_logsys.h"
+#include "mutex.h"
+#include "timer.h"
+#include <charconv>
+
+namespace mysql
+{
+
+void PreparedStmt::StmtDeleter::operator()(MYSQL_STMT* stmt) noexcept
+{
+	// The connection must be locked when closing the stmt to avoid mysql errors
+	// in case another thread tries to use it during the close. If the mutex is
+	// changed to one that throws then exceptions need to be caught here.
+	LockMutex lock(mutex);
+	mysql_stmt_close(stmt);
+}
+
+PreparedStmt::PreparedStmt(MYSQL& mysql, std::string query, Mutex* mutex, StmtOptions opts)
+	: m_stmt(mysql_stmt_init(&mysql), { mutex }), m_query(std::move(query)), m_mutex(mutex), m_options(opts)
+{
+	LockMutex lock(m_mutex);
+	if (mysql_stmt_prepare(m_stmt.get(), m_query.c_str(), static_cast<unsigned long>(m_query.size())) != 0)
+	{
+		ThrowError(fmt::format("Prepare error: {}", GetStmtError()));
+	}
+
+	m_params.resize(mysql_stmt_param_count(m_stmt.get()));
+	m_inputs.resize(m_params.size());
+}
+
+void PreparedStmt::ThrowError(const std::string& error)
+{
+	LogMySQLError("{}", error);
+	throw std::runtime_error(error);
+}
+
+std::string PreparedStmt::GetStmtError()
+{
+	auto err = mysql_stmt_errno(m_stmt.get());
+	auto str = mysql_stmt_error(m_stmt.get());
+	return fmt::format("({}) [{}] for query [{}]", err, str, m_query);
+}
+
+template <typename T>
+void PreparedStmt::BindInput(size_t index, T value)
+{
+	if (index >= m_inputs.size())
+	{
+		ThrowError(fmt::format("Cannot bind input, index {} out of range", index));
+	}
+
+	impl::Bind& arg  = m_inputs[index];
+	arg.is_null      = std::is_same_v<T, std::nullptr_t>;
+
+	MYSQL_BIND& bind = m_params[index];
+	bind.is_unsigned = std::is_unsigned_v<T>;
+	bind.is_null     = &arg.is_null;
+	bind.length      = &arg.length;
+
+	auto old_type = bind.buffer_type;
+
+	if constexpr (std::is_arithmetic_v<T>)
+	{
+		if (arg.buffer.size() < sizeof(T))
+		{
+			arg.buffer.resize(std::max(sizeof(T), sizeof(int64_t)));
+			bind.buffer = arg.buffer.data();
+			m_need_bind = true;
+		}
+		memcpy(arg.buffer.data(), &value, sizeof(T));
+	}
+
+	if constexpr (std::is_same_v<T, int8_t> || std::is_same_v<T, uint8_t> || std::is_same_v<T, bool>)
+	{
+		bind.buffer_type = MYSQL_TYPE_TINY;
+	}
+	else if constexpr (std::is_same_v<T, int16_t> || std::is_same_v<T, uint16_t>)
+	{
+		bind.buffer_type = MYSQL_TYPE_SHORT;
+	}
+	else if constexpr (std::is_same_v<T, int32_t> || std::is_same_v<T, uint32_t>)
+	{
+		bind.buffer_type = MYSQL_TYPE_LONG;
+	}
+	else if constexpr (std::is_same_v<T, int64_t> || std::is_same_v<T, uint64_t>)
+	{
+		bind.buffer_type = MYSQL_TYPE_LONGLONG;
+	}
+	else if constexpr (std::is_same_v<T, float>)
+	{
+		bind.buffer_type = MYSQL_TYPE_FLOAT;
+	}
+	else if constexpr (std::is_same_v<T, double>)
+	{
+		bind.buffer_type = MYSQL_TYPE_DOUBLE;
+	}
+	else if constexpr (std::is_same_v<T, std::string_view>)
+	{
+		bind.buffer_type = MYSQL_TYPE_STRING;
+		if (arg.buffer.empty() || arg.buffer.size() < value.size())
+		{
+			arg.buffer.resize(static_cast<size_t>((value.size() + 1) * 1.5));
+			bind.buffer = arg.buffer.data();
+			bind.buffer_length = static_cast<unsigned long>(arg.buffer.size());
+			m_need_bind = true;
+		}
+		std::copy(value.begin(), value.end(), arg.buffer.begin());
+		arg.length = static_cast<unsigned long>(value.size());
+	}
+	else if constexpr (!std::is_same_v<T, std::nullptr_t>)
+	{
+		static_assert(false_v<T>, "Cannot bind unsupported type");
+	}
+
+	if (old_type != bind.buffer_type)
+	{
+		m_need_bind = true;
+	}
+}
+
+void PreparedStmt::BindInput(size_t index, const char* str)
+{
+	BindInput(index, std::string_view(str));
+}
+
+void PreparedStmt::BindInput(size_t index, const std::string& str)
+{
+	BindInput(index, std::string_view(str));
+}
+
+StmtResult PreparedStmt::Execute()
+{
+	CheckArgs(0);
+	return DoExecute();
+}
+
+StmtResult PreparedStmt::Execute(const std::vector<param_t>& args)
+{
+	CheckArgs(args.size());
+	for (size_t i = 0; i < args.size(); ++i)
+	{
+		std::visit([&](const auto& arg) { BindInput(i, arg); }, args[i]);
+	}
+	return DoExecute();
+}
+
+template <typename T>
+StmtResult PreparedStmt::Execute(const std::vector<T>& args)
+{
+	CheckArgs(args.size());
+	for (size_t i = 0; i < args.size(); ++i)
+	{
+		BindInput(i, args[i]);
+	}
+	return DoExecute();
+}
+
+void PreparedStmt::CheckArgs(size_t argc)
+{
+	if (argc != m_params.size())
+	{
+		ThrowError(fmt::format("Bad arg count (got {}, expected {}) for [{}]", argc, m_params.size(), m_query));
+	}
+}
+
+StmtResult PreparedStmt::DoExecute()
+{
+	BenchTimer timer;
+	LockMutex lock(m_mutex);
+
+	if (m_need_bind && mysql_stmt_bind_param(m_stmt.get(), m_params.data()) != 0)
+	{
+		ThrowError(fmt::format("Bind param error: {}", GetStmtError()));
+	}
+
+	m_need_bind = false;
+
+	if (mysql_stmt_execute(m_stmt.get()) != 0)
+	{
+		ThrowError(fmt::format("Execute error: {}", GetStmtError()));
+	}
+
+	my_bool attr = m_options.use_max_length;
+	mysql_stmt_attr_set(m_stmt.get(), STMT_ATTR_UPDATE_MAX_LENGTH, &attr);
+
+	if (m_options.buffer_results && mysql_stmt_store_result(m_stmt.get()) != 0)
+	{
+		ThrowError(fmt::format("Store result error: {}", GetStmtError()));
+	}
+
+	// Result buffers are bound on first execute and re-used if needed
+	if (m_results.empty())
+	{
+		BindResults();
+	}
+
+	StmtResult res(m_stmt.get(), m_results.size());
+
+	if (m_results.empty())
+	{
+		LogMySQLQuery("{} -- ({} row(s) affected) ({:.6f}s)", m_query, res.RowsAffected(), timer.elapsed());
+	}
+	else
+	{
+		LogMySQLQuery("{} -- ({} row(s) returned) ({:.6f}s)", m_query, res.RowCount(), timer.elapsed());
+	}
+
+	return res;
+}
+
+void PreparedStmt::BindResults()
+{
+	MYSQL_RES* res = mysql_stmt_result_metadata(m_stmt.get());
+	if (!res)
+	{
+		return; // did not produce a result set
+	}
+
+	MYSQL_FIELD* fields = mysql_fetch_fields(res);
+	m_columns.resize(mysql_num_fields(res));
+	m_results.resize(m_columns.size());
+
+	for (int i = 0; i < static_cast<int>(m_columns.size()); ++i)
+	{
+		impl::BindColumn& col = m_columns[i].m_col;
+		MYSQL_BIND& bind = m_results[i];
+
+		col.index          = i;
+		col.name           = fields[i].name;
+		col.buffer_type    = fields[i].type;
+		col.is_unsigned    = (fields[i].flags & UNSIGNED_FLAG) != 0;
+		col.buffer.resize(GetResultBufferSize(fields[i]));
+
+		bind.buffer_type   = col.buffer_type;
+		bind.buffer        = col.buffer.data();
+		bind.buffer_length = static_cast<unsigned long>(col.buffer.size());
+		bind.is_unsigned   = col.is_unsigned;
+		bind.is_null       = &col.is_null;
+		bind.length        = &col.length;
+		bind.error         = &col.error;
+	}
+
+	mysql_free_result(res);
+
+	if (!m_results.empty() && mysql_stmt_bind_result(m_stmt.get(), m_results.data()) != 0)
+	{
+		ThrowError(fmt::format("Bind result error: {}", GetStmtError()));
+	}
+}
+
+int PreparedStmt::GetResultBufferSize(const MYSQL_FIELD& field) const
+{
+	switch (field.type)
+	{
+	case MYSQL_TYPE_TINY:
+		return sizeof(int8_t);
+	case MYSQL_TYPE_SHORT:
+		return sizeof(int16_t);
+	case MYSQL_TYPE_INT24:
+	case MYSQL_TYPE_LONG:
+		return sizeof(int32_t);
+	case MYSQL_TYPE_LONGLONG:
+		return sizeof(int64_t);
+	case MYSQL_TYPE_FLOAT:
+		return sizeof(float);
+	case MYSQL_TYPE_DOUBLE:
+		return sizeof(double);
+	case MYSQL_TYPE_TIME:
+	case MYSQL_TYPE_DATE:
+	case MYSQL_TYPE_DATETIME:
+	case MYSQL_TYPE_TIMESTAMP:
+		return sizeof(MYSQL_TIME);
+	default: // if max_length is unavailable for strings buffers are resized on fetch
+		return field.max_length + 1; // ensure valid buffer created
+	}
+}
+
+StmtRow PreparedStmt::Fetch()
+{
+	StmtRow row;
+	if (!m_columns.empty())
+	{
+		int rc = mysql_stmt_fetch(m_stmt.get());
+		if (rc == 1)
+		{
+			ThrowError(fmt::format("Fetch error: {}", GetStmtError()));
+		}
+
+		if (rc != MYSQL_NO_DATA)
+		{
+			if (rc == MYSQL_DATA_TRUNCATED)
+			{
+				FetchTruncated();
+			}
+			row = StmtRow(m_columns);
+		}
+	}
+	return row;
+}
+
+void PreparedStmt::FetchTruncated()
+{
+	for (int i = 0; i < static_cast<int>(m_columns.size()); ++i)
+	{
+		impl::BindColumn& col = m_columns[i].m_col;
+		if (col.error)
+		{
+			MYSQL_BIND& bind = m_results[i];
+			col.buffer.resize(static_cast<size_t>(col.length * 1.5));
+			bind.buffer = col.buffer.data();
+			bind.buffer_length = static_cast<unsigned long>(col.buffer.size());
+
+			mysql_stmt_fetch_column(m_stmt.get(), &bind, i, 0);
+		}
+	}
+
+	if (mysql_stmt_bind_result(m_stmt.get(), m_results.data()) != 0)
+	{
+		ThrowError(fmt::format("Fetch rebind result error: {}", GetStmtError()));
+	}
+}
+
+// ---------------------------------------------------------------------------
+
+StmtResult::StmtResult(MYSQL_STMT* stmt, size_t columns)
+{
+	m_num_cols  = static_cast<int>(columns);
+	m_num_rows  = mysql_stmt_num_rows(stmt); // requires buffered results
+	m_affected  = mysql_stmt_affected_rows(stmt);
+	m_insert_id = mysql_stmt_insert_id(stmt);
+}
+
+// ---------------------------------------------------------------------------
+
+const StmtColumn* StmtRow::GetColumn(size_t index) const
+{
+	return index < m_columns.size() ? &m_columns[index] : nullptr;
+}
+
+const StmtColumn* StmtRow::GetColumn(std::string_view name) const
+{
+	auto it = std::ranges::find_if(m_columns,
+		[name](const StmtColumn& col) { return col.Name() == name; });
+
+	return it != m_columns.end() ? &(*it) : nullptr;
+}
+
+std::optional<std::string> StmtRow::operator[](size_t index) const
+{
+	return GetStr(index);
+}
+
+std::optional<std::string> StmtRow::operator[](std::string_view name) const
+{
+	return GetStr(name);
+}
+
+std::optional<std::string> StmtRow::GetStr(size_t index) const
+{
+	const StmtColumn* col = GetColumn(index);
+	return col ? col->GetStr() : std::nullopt;
+}
+
+std::optional<std::string> StmtRow::GetStr(std::string_view name) const
+{
+	const StmtColumn* col = GetColumn(name);
+	return col ? col->GetStr() : std::nullopt;
+}
+
+template <typename T> requires std::is_arithmetic_v<T>
+std::optional<T> StmtRow::Get(size_t index) const
+{
+	const StmtColumn* col = GetColumn(index);
+	return col ? col->Get<T>() : std::nullopt;
+}
+
+template <typename T> requires std::is_arithmetic_v<T>
+std::optional<T> StmtRow::Get(std::string_view name) const
+{
+	const StmtColumn* col = GetColumn(name);
+	return col ? col->Get<T>() : std::nullopt;
+}
+
+// ---------------------------------------------------------------------------
+
+static time_t MakeTime(const MYSQL_TIME& mt)
+{
+	// buffer mt given in mysql session time zone (assumes local)
+	std::tm tm{};
+	tm.tm_year  = mt.year - 1900;
+	tm.tm_mon   = mt.month - 1;
+	tm.tm_mday  = mt.day;
+	tm.tm_hour  = mt.hour;
+	tm.tm_min   = mt.minute;
+	tm.tm_sec   = mt.second;
+	tm.tm_isdst = -1;
+	return std::mktime(&tm);
+}
+
+static int MakeSeconds(const MYSQL_TIME& mt)
+{
+	return (mt.neg ? -1 : 1) * static_cast<int>(mt.hour * 3600 + mt.minute * 60 + mt.second);
+}
+
+static uint64_t MakeBits(std::span<const uint8_t> data)
+{
+	// byte stream for bits is in big endian
+	uint64_t bits = 0;
+	for (size_t i = 0; i < data.size() && i < sizeof(uint64_t); ++i)
+	{
+		bits |= static_cast<uint64_t>(data[data.size() - i - 1] & 0xff) << (i * 8);
+	}
+	return bits;
+}
+
+template <typename T>
+concept has_from_chars = requires (const char* first, const char* last, T value)
+{
+	std::from_chars(first, last, value);
+};
+
+template <typename T>
+static T FromString(std::string_view sv)
+{
+	if constexpr (std::is_same_v<T, bool>)
+	{
+		// return false for empty (zero-length) strings
+		return !sv.empty();
+	}
+	else if constexpr (std::is_same_v<T, float> && !has_from_chars<T>)
+	{
+		return std::strtof(std::string(sv).c_str(), nullptr);
+	}
+	else if constexpr (std::is_same_v<T, double> && !has_from_chars<T>)
+	{
+		return std::strtod(std::string(sv).c_str(), nullptr);
+	}
+	else
+	{
+		// non numbers return a zero initialized T (could return nullopt instead)
+		T value = {};
+		std::from_chars(sv.data(), sv.data() + sv.size(), value);
+		return value;
+	}
+}
+
+static std::string FormatTime(enum_field_types type, const MYSQL_TIME& mt)
+{
+	switch (type)
+	{
+	case MYSQL_TYPE_TIME: // hhh:mm:ss '-838:59:59' to '838:59:59'
+		return fmt::format("{}{:02d}:{:02d}:{:02d}", mt.neg ? "-" : "", mt.hour, mt.minute, mt.second);
+	case MYSQL_TYPE_DATE: // YYYY-MM-DD '1000-01-01' to '9999-12-31'
+		return fmt::format("{}-{:02d}-{:02d}", mt.year, mt.month, mt.day);
+	case MYSQL_TYPE_DATETIME:  // YYYY-MM-DD hh:mm:ss '1000-01-01 00:00:00' to '9999-12-31 23:59:59'
+	case MYSQL_TYPE_TIMESTAMP: // YYYY-MM-DD hh:mm:ss '1970-01-01 00:00:01' UTC to '2038-01-19 03:14:07' UTC
+		return fmt::format("{}-{:02d}-{:02d} {:02d}:{:02d}:{:02d}", mt.year, mt.month, mt.day, mt.hour, mt.minute, mt.second);
+	default:
+		return std::string();
+	}
+}
+
+std::optional<std::string_view> StmtColumn::GetStrView() const
+{
+	if (m_col.is_null)
+	{
+		return std::nullopt;
+	}
+
+	switch (m_col.buffer_type)
+	{
+	case MYSQL_TYPE_NEWDECIMAL:
+	case MYSQL_TYPE_TINY_BLOB:
+	case MYSQL_TYPE_MEDIUM_BLOB:
+	case MYSQL_TYPE_LONG_BLOB:
+	case MYSQL_TYPE_BLOB:
+	case MYSQL_TYPE_VAR_STRING:
+	case MYSQL_TYPE_STRING:
+		return std::make_optional<std::string_view>(reinterpret_cast<const char*>(m_col.buffer.data()), m_col.length);
+	default:
+		return std::nullopt;
+	}
+}
+
+std::optional<std::string> StmtColumn::GetStr() const
+{
+	if (m_col.is_null)
+	{
+		return std::nullopt;
+	}
+
+	switch (m_col.buffer_type)
+	{
+	case MYSQL_TYPE_TINY:
+		return m_col.is_unsigned ? fmt::format_int(BitCast<uint8_t>()).c_str() : fmt::format_int(BitCast<int8_t>()).c_str();
+	case MYSQL_TYPE_SHORT:
+		return m_col.is_unsigned ? fmt::format_int(BitCast<uint16_t>()).c_str() : fmt::format_int(BitCast<int16_t>()).c_str();
+	case MYSQL_TYPE_INT24:
+	case MYSQL_TYPE_LONG:
+		return m_col.is_unsigned ? fmt::format_int(BitCast<uint32_t>()).c_str() : fmt::format_int(BitCast<int32_t>()).c_str();
+	case MYSQL_TYPE_LONGLONG:
+		return m_col.is_unsigned ? fmt::format_int(BitCast<uint64_t>()).c_str() : fmt::format_int(BitCast<int64_t>()).c_str();
+	case MYSQL_TYPE_FLOAT:
+		return fmt::format("{}", BitCast<float>());
+	case MYSQL_TYPE_DOUBLE:
+		return fmt::format("{}", BitCast<double>());
+	case MYSQL_TYPE_TIME:
+	case MYSQL_TYPE_DATE:
+	case MYSQL_TYPE_DATETIME:
+	case MYSQL_TYPE_TIMESTAMP:
+		return FormatTime(m_col.buffer_type, BitCast<MYSQL_TIME>());
+	case MYSQL_TYPE_BIT:
+		return fmt::format_int(*Get<uint64_t>()).c_str();
+	case MYSQL_TYPE_NEWDECIMAL:
+	case MYSQL_TYPE_TINY_BLOB:
+	case MYSQL_TYPE_MEDIUM_BLOB:
+	case MYSQL_TYPE_LONG_BLOB:
+	case MYSQL_TYPE_BLOB:
+	case MYSQL_TYPE_VAR_STRING:
+	case MYSQL_TYPE_STRING:
+		return std::make_optional<std::string>(reinterpret_cast<const char*>(m_col.buffer.data()), m_col.length);
+	default:
+		return std::nullopt;
+	}
+}
+
+template <typename T> requires std::is_arithmetic_v<T>
+std::optional<T> StmtColumn::Get() const
+{
+	if (m_col.is_null)
+	{
+		return std::nullopt;
+	}
+
+	switch (m_col.buffer_type)
+	{
+	case MYSQL_TYPE_TINY:
+		return m_col.is_unsigned ? static_cast<T>(BitCast<uint8_t>()) : static_cast<T>(BitCast<int8_t>());
+	case MYSQL_TYPE_SHORT:
+		return m_col.is_unsigned ? static_cast<T>(BitCast<uint16_t>()) : static_cast<T>(BitCast<int16_t>());
+	case MYSQL_TYPE_INT24:
+	case MYSQL_TYPE_LONG:
+		return m_col.is_unsigned ? static_cast<T>(BitCast<uint32_t>()) : static_cast<T>(BitCast<int32_t>());
+	case MYSQL_TYPE_LONGLONG:
+		return m_col.is_unsigned ? static_cast<T>(BitCast<uint64_t>()) : static_cast<T>(BitCast<int64_t>());
+	case MYSQL_TYPE_FLOAT:
+		return static_cast<T>(BitCast<float>());
+	case MYSQL_TYPE_DOUBLE:
+		return static_cast<T>(BitCast<double>());
+	case MYSQL_TYPE_TIME: // return as total seconds
+		return static_cast<T>(MakeSeconds(BitCast<MYSQL_TIME>()));
+	case MYSQL_TYPE_DATE:
+	case MYSQL_TYPE_DATETIME:
+	case MYSQL_TYPE_TIMESTAMP: // return as epoch timestamp
+		return static_cast<T>(MakeTime(BitCast<MYSQL_TIME>()));
+	case MYSQL_TYPE_BIT:
+		return static_cast<T>(MakeBits({ m_col.buffer.data(), m_col.length }));
+	case MYSQL_TYPE_NEWDECIMAL:
+	case MYSQL_TYPE_TINY_BLOB:
+	case MYSQL_TYPE_MEDIUM_BLOB:
+	case MYSQL_TYPE_LONG_BLOB:
+	case MYSQL_TYPE_BLOB:
+	case MYSQL_TYPE_VAR_STRING:
+	case MYSQL_TYPE_STRING:
+		return FromString<T>({ reinterpret_cast<const char*>(m_col.buffer.data()), m_col.length });
+	default:
+		return std::nullopt;
+	}
+}
+
+// ---------------------------------------------------------------------------
+
+// explicit template instantiations for supported types
+template void PreparedStmt::BindInput(size_t, std::string_view);
+template void PreparedStmt::BindInput(size_t, std::nullptr_t);
+template StmtResult PreparedStmt::Execute(const std::vector<std::string_view>&);
+template StmtResult PreparedStmt::Execute(const std::vector<std::string>&);
+template StmtResult PreparedStmt::Execute(const std::vector<const char*>&);
+
+#define INSTANTIATE(T) \
+	template void PreparedStmt::BindInput(size_t, T); \
+	template StmtResult PreparedStmt::Execute(const std::vector<T>&); \
+	template std::optional<T> StmtRow::Get(size_t) const; \
+	template std::optional<T> StmtRow::Get(std::string_view) const; \
+	template std::optional<T> StmtColumn::Get() const;
+
+INSTANTIATE(bool);
+INSTANTIATE(int8_t);
+INSTANTIATE(uint8_t);
+INSTANTIATE(int16_t);
+INSTANTIATE(uint16_t);
+INSTANTIATE(int32_t);
+INSTANTIATE(uint32_t);
+INSTANTIATE(int64_t);
+INSTANTIATE(uint64_t);
+INSTANTIATE(float);
+INSTANTIATE(double);
+
+} // namespace mysql

common/mysql_stmt.h

@@ -0,0 +1,221 @@
+#pragma once
+
+#include "mysql.h"
+#include <cassert>
+#include <cstring>
+#include <memory>
+#include <optional>
+#include <span>
+#include <string>
+#include <string_view>
+#include <variant>
+#include <vector>
+
+class Mutex;
+
+namespace mysql
+{
+
+// support MySQL 8.0.1+ API which removed the my_bool type
+#if !defined(MARIADB_VERSION_ID) && MYSQL_VERSION_ID >= 80001
+using my_bool = bool;
+#endif
+
+template <typename>
+inline constexpr bool false_v = false;
+
+namespace impl
+{
+
+struct Bind
+{
+	std::vector<uint8_t> buffer;
+	unsigned long length = 0;
+	my_bool is_null = false;
+	my_bool error = false;
+};
+
+struct BindColumn : Bind
+{
+	int index = 0;
+	std::string name;
+	bool is_unsigned = false;
+	enum_field_types buffer_type = {};
+};
+
+} // namespace impl
+
+// ---------------------------------------------------------------------------
+
+struct StmtOptions
+{
+	// Enable buffering (storing) entire result set after executing a statement
+	bool buffer_results = true;
+
+	// Enable MySQL to update max_length of fields in execute result set (requires buffering)
+	bool use_max_length = true;
+};
+
+// ---------------------------------------------------------------------------
+
+// Holds ownership of bound column value buffer
+class StmtColumn
+{
+public:
+	int Index() const { return m_col.index; }
+	bool IsNull() const { return m_col.is_null; }
+	bool IsUnsigned() const { return m_col.is_unsigned; }
+	enum_field_types Type() const { return m_col.buffer_type; }
+	const std::string& Name() const { return m_col.name; }
+
+	// Get view of column value buffer
+	std::span<const uint8_t> GetBuf() const { return { m_col.buffer.data(), m_col.length }; }
+
+	// Get view of column string value. Returns nullopt if value is NULL or not a string
+	std::optional<std::string_view> GetStrView() const;
+
+	// Get column value as string. Returns nullopt if value is NULL or field type unsupported
+	std::optional<std::string> GetStr() const;
+
+	// Get column value as numeric T. Returns nullopt if value NULL or field type unsupported
+	template <typename T> requires std::is_arithmetic_v<T>
+	std::optional<T> Get() const;
+
+private:
+	// uses memcpy for type punning buffer data to avoid UB with strict aliasing
+	template <typename T>
+	T BitCast() const
+	{
+		T val;
+		assert(sizeof(T) == m_col.length);
+		memcpy(&val, m_col.buffer.data(), sizeof(T));
+		return val;
+	}
+
+	friend class PreparedStmt; // access to allocate and bind buffers
+	friend class StmtResult; // access to resize truncated buffers
+	impl::BindColumn m_col;
+};
+
+// ---------------------------------------------------------------------------
+
+// Provides a non-owning view of PreparedStmt column value buffers
+// Evaluates false if it does not contain a valid row
+class StmtRow
+{
+public:
+	StmtRow() = default;
+	StmtRow(std::span<const StmtColumn> columns) : m_columns(columns) {};
+
+	explicit operator bool() const noexcept { return !m_columns.empty(); }
+
+	int ColumnCount() const { return static_cast<int>(m_columns.size()); }
+	const StmtColumn* GetColumn(size_t index) const;
+	const StmtColumn* GetColumn(std::string_view name) const;
+
+	// Get specified column value as string
+	// Returns nullopt if column invalid, value is NULL, or field type unsupported
+	std::optional<std::string> operator[](size_t index) const;
+	std::optional<std::string> operator[](std::string_view name) const;
+	std::optional<std::string> GetStr(size_t index) const;
+	std::optional<std::string> GetStr(std::string_view name) const;
+
+	// Get specified column value as numeric T
+	// Returns nullopt if column invalid, value is NULL, or field type unsupported
+	template <typename T> requires std::is_arithmetic_v<T>
+	std::optional<T> Get(size_t index) const;
+
+	template <typename T> requires std::is_arithmetic_v<T>
+	std::optional<T> Get(std::string_view name) const;
+
+	auto begin() const { return m_columns.begin(); }
+	auto end()   const { return m_columns.end(); }
+
+private:
+	std::span<const StmtColumn> m_columns;
+};
+
+// ---------------------------------------------------------------------------
+
+// Result meta data for an executed prepared statement
+class StmtResult
+{
+public:
+	StmtResult() = default;
+	StmtResult(MYSQL_STMT* stmt, size_t columns);
+
+	int ColumnCount() const { return m_num_cols; }
+	uint64_t RowCount() const { return m_num_rows; }
+	uint64_t RowsAffected() const { return m_affected; }
+	uint64_t LastInsertID() const { return m_insert_id; }
+
+private:
+	int m_num_cols = 0;
+	uint64_t m_num_rows = 0;
+	uint64_t m_affected = 0;
+	uint64_t m_insert_id = 0;
+};
+
+// ---------------------------------------------------------------------------
+
+class PreparedStmt
+{
+public:
+	// Supported argument types for execute
+	using param_t = std::variant<int8_t, uint8_t, int16_t, uint16_t, int32_t, uint32_t,
+		int64_t, uint64_t, float, double, bool, std::string_view, std::nullptr_t>;
+
+	PreparedStmt() = delete;
+	PreparedStmt(MYSQL& mysql, std::string query, Mutex* mutex, StmtOptions opts = {});
+
+	const std::string& GetQuery() const { return m_query; }
+	StmtOptions GetOptions() const { return m_options; }
+	void SetOptions(StmtOptions options) { m_options = options; }
+	void FreeResult() { mysql_stmt_free_result(m_stmt.get()); }
+
+	// Execute the prepared statement with specified arguments
+	// Throws exception on error
+	template <typename T>
+	StmtResult Execute(const std::vector<T>& args);
+	StmtResult Execute(const std::vector<param_t>& args);
+	StmtResult Execute();
+
+	// Fetch the next row into column buffers (overwrites previous row values)
+	// Return value evaluates false if no more rows to fetch
+	// Throws exception on error
+	StmtRow Fetch();
+
+private:
+	void CheckArgs(size_t argc);
+	StmtResult DoExecute();
+	void BindResults();
+	void FetchTruncated();
+	int GetResultBufferSize(const MYSQL_FIELD& field) const;
+	void ThrowError(const std::string& error);
+	std::string GetStmtError();
+
+	// bind an input value to a query parameter by index
+	template <typename T>
+	void BindInput(size_t index, T value);
+	void BindInput(size_t index, const char* str);
+	void BindInput(size_t index, const std::string& str);
+
+	struct StmtDeleter
+	{
+		Mutex* mutex = nullptr;
+		void operator()(MYSQL_STMT* stmt) noexcept;
+	};
+
+private:
+	std::unique_ptr<MYSQL_STMT, StmtDeleter> m_stmt;
+	std::vector<MYSQL_BIND> m_params;  // input binds
+	std::vector<MYSQL_BIND> m_results; // result binds
+	std::vector<impl::Bind> m_inputs;  // execute buffers (addresses bound)
+	std::vector<StmtColumn> m_columns; // fetch buffers (addresses bound)
+	std::string m_query;
+	StmtOptions m_options = {};
+	bool m_need_bind = true;
+	Mutex* m_mutex = nullptr; // connection mutex
+};
+
+} // namespace mysql

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;
-/*04*/	uint32	npc_id;
-/*08*/	uint32	unknown08;
-/*12*/	uint32	unknown12;
+/*00*/	FindLocationType type;
+/*04*/	int32 id;
+/*08*/	int32 unknown08;
+/*12*/	int32 unknown12;
 /*16*/	FindPerson_Point client_pos;
-/*28*/	uint32	unknown28;
-/*32*/	uint32	unknown32;
-/*36*/	uint32	unknown36;
+/*28*/	FindPerson_Point target_pos;
+/*40*/
 };
 
 //variable length packet of points

common/patches/rof_structs.h

@@ -3779,14 +3779,13 @@ struct FindPerson_Point {
 };
 
 struct FindPersonRequest_Struct {
-/*00*/	uint32	unknown00;
-/*04*/	uint32	npc_id;
-/*08*/	uint32	unknown08;
-/*12*/	uint32	unknown12;
-/*16*/	FindPerson_Point client_pos;
-/*28*/	uint32	unknown28;
-/*32*/	uint32	unknown32;
-/*36*/	uint32	unknown36;
+	/*00*/	FindLocationType type;
+	/*04*/	int32 id;
+	/*08*/	int32 unknown08;
+	/*12*/	int32 unknown12;
+	/*16*/	FindPerson_Point client_pos;
+	/*28*/	FindPerson_Point target_pos;
+	/*40*/
 };
 
 //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/path_manager.cpp

@@ -74,6 +74,11 @@ void PathManager::LoadPaths()
 		m_patch_path = fs::relative(fs::path{m_server_path + "/" + c->PatchDir}).string();
 	}
 
+	// patches
+	if (File::Exists(fs::path{ m_server_path + "/" + c->OpcodeDir }.string())) {
+		m_opcode_path = fs::relative(fs::path{ m_server_path + "/" + c->OpcodeDir }).string();
+	}
+
 	// shared_memory_path
 	if (File::Exists(fs::path{m_server_path + "/" + c->SharedMemDir}.string())) {
 		m_shared_memory_path = fs::relative(fs::path{ m_server_path + "/" + c->SharedMemDir }).string();
@@ -89,6 +94,7 @@ void PathManager::LoadPaths()
 	LogInfo("lua_modules path [{}]", m_lua_modules_path);
 	LogInfo("maps path [{}]", m_maps_path);
 	LogInfo("patches path [{}]", m_patch_path);
+	LogInfo("opcode path [{}]", m_opcode_path);
 	LogInfo("plugins path [{}]", m_plugins_path);
 	LogInfo("quests path [{}]", m_quests_path);
 	LogInfo("shared_memory path [{}]", m_shared_memory_path);
@@ -129,6 +135,11 @@ const std::string &PathManager::GetPatchPath() const
 	return m_patch_path;
 }
 
+const std::string &PathManager::GetOpcodePath() const
+{
+	return m_opcode_path;
+}
+
 const std::string &PathManager::GetLuaModulesPath() const
 {
 	return m_lua_modules_path;

common/path_manager.h

@@ -13,6 +13,7 @@ public:
 	[[nodiscard]] const std::string &GetLuaModulesPath() const;
 	[[nodiscard]] const std::string &GetMapsPath() const;
 	[[nodiscard]] const std::string &GetPatchPath() const;
+	[[nodiscard]] const std::string &GetOpcodePath() const;
 	[[nodiscard]] const std::string &GetPluginsPath() const;
 	[[nodiscard]] const std::string &GetQuestsPath() const;
 	[[nodiscard]] const std::string &GetServerPath() const;
@@ -24,6 +25,7 @@ private:
 	std::string m_lua_modules_path;
 	std::string m_maps_path;
 	std::string m_patch_path;
+	std::string m_opcode_path;
 	std::string m_plugins_path;
 	std::string m_quests_path;
 	std::string m_server_path;

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/buyer_buy_lines_repository.h

@@ -236,6 +236,10 @@ public:
 				)
 			);
 
+			if (buyers.empty()) {
+				return all_entries;
+			}
+
 			std::vector<std::string> char_ids{};
 			for (auto const &bl : buyers) {
 				char_ids.push_back((std::to_string(bl.char_id)));

common/repositories/buyer_repository.h

@@ -120,6 +120,10 @@ public:
 			}
 
 			DeleteWhere(db, fmt::format("`char_id` = '{}';", char_id));
+			if (buy_line_ids.empty()) {
+				return false;
+			}
+
 			BaseBuyerBuyLinesRepository::DeleteWhere(
 				db,
 				fmt::format("`id` IN({})", Strings::Implode(", ", buy_line_ids))

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/repositories/trader_repository.h

@@ -164,37 +164,35 @@ public:
 		return UpdateOne(db, m);
 	}
 
-	static Trader GetItemBySerialNumber(Database &db, uint32 serial_number)
+	static Trader GetItemBySerialNumber(Database &db, uint32 serial_number, uint32 trader_id)
 	{
 		Trader     e{};
 		const auto trader_item = GetWhere(
 			db,
-			fmt::format("`item_sn` = '{}' LIMIT 1", serial_number)
+			fmt::format("`char_id` = '{}' AND `item_sn` = '{}' LIMIT 1", trader_id, serial_number)
 		);
 
 		if (trader_item.empty()) {
 			return e;
 		}
-		else {
-			return trader_item.at(0);
-		}
+
+		return trader_item.at(0);
 	}
 
-	static Trader GetItemBySerialNumber(Database &db, std::string serial_number)
+	static Trader GetItemBySerialNumber(Database &db, std::string serial_number, uint32 trader_id)
 	{
 		Trader     e{};
 		auto       sn          = Strings::ToUnsignedBigInt(serial_number);
 		const auto trader_item = GetWhere(
 			db,
-			fmt::format("`item_sn` = '{}' LIMIT 1", sn)
+			fmt::format("`char_id` = '{}' AND `item_sn` = '{}' LIMIT 1", trader_id, sn)
 		);
 
 		if (trader_item.empty()) {
 			return e;
 		}
-		else {
-			return trader_item.at(0);
-		}
+
+		return trader_item.at(0);
 	}
 
 	static int UpdateActiveTransaction(Database &db, uint32 id, bool status)
@@ -217,6 +215,10 @@ public:
 			delete_ids.push_back(std::to_string(e.id));
 		}
 
+		if (delete_ids.empty()) {
+			return 0;
+		}
+
 		return DeleteWhere(db, fmt::format("`id` IN({})", Strings::Implode(",", delete_ids)));
 	}
 };

common/ruletypes.h

@@ -338,6 +338,8 @@ RULE_STRING(World, IPExemptionZones, "", "Comma-delimited list of zones to exclu
 RULE_STRING(World, MOTD, "", "Server MOTD sent on login, change from empty to have this be used instead of variables table 'motd' value")
 RULE_STRING(World, Rules, "", "Server Rules, change from empty to have this be used instead of variables table 'rules' value, lines are pipe (|) separated, example: A|B|C")
 RULE_BOOL(World, EnableAutoLogin, false, "Enables or disables auto login of characters, allowing people to log characters in directly from loginserver to ingame")
+RULE_BOOL(World, EnablePVPRegions, true, "Enables or disables PVP Regions automatically setting your PVP flag")
+RULE_STRING(World, SupportedClients, "", "Comma-delimited list of clients to restrict to. Supported values are Titanium | SoF | SoD | UF | RoF | RoF2. Example: Titanium,RoF2")
 RULE_CATEGORY_END()
 
 RULE_CATEGORY(Zone)
@@ -516,7 +518,8 @@ RULE_INT(Spells, HealAmountMessageFilterThreshold, 100, "Lifetaps below this thr
 RULE_BOOL(Spells, SnareOverridesSpeedBonuses, false, "Enabling will allow snares to override any speed bonuses the entity may have. Default: False")
 RULE_INT(Spells, TargetedAOEMaxTargets, 4, "Max number of targets a Targeted AOE spell can cast on. Set to 0 for no limit.")
 RULE_INT(Spells, PointBlankAOEMaxTargets, 0, "Max number of targets a Point-Blank AOE spell can cast on. Set to 0 for no limit.")
-RULE_INT(Spells, DefaultAOEMaxTargets, 4, "Max number of targets that an AOE spell which does not meet other descriptions can cast on. Set to 0 for no limit.")
+RULE_INT(Spells, DefaultAOEMaxTargets, 0, "Max number of targets that an AOE spell which does not meet other descriptions can cast on. Set to 0 for no limit.")
+RULE_BOOL(Spells, AllowFocusOnSkillDamageSpells, false, "Allow focus effects 185, 459, and 482 to enhance SkillAttack spell effect 193")
 RULE_CATEGORY_END()
 
 RULE_CATEGORY(Combat)
@@ -678,6 +681,7 @@ RULE_BOOL(NPC, DisableLastNames, false, "Enable to disable NPC Last Names")
 RULE_BOOL(NPC, NPCIgnoreLevelBasedHasteCaps, false, "Ignores hard coded level based haste caps.")
 RULE_INT(NPC, NPCHasteCap, 150, "Haste cap for non-v3(over haste) haste")
 RULE_INT(NPC, NPCHastev3Cap, 25, "Haste cap for v3(over haste) haste")
+RULE_STRING(NPC, ExcludedFaceTargetRaces, "52,72,73,141,233,328,329,372,376,377,378,379,380,381,382,383,404,422,423,424,425,426,428,429,445,449,460,462,463,500,501,502,503,504,505,506,507,508,509,510,511,513,514,515,516,533,534,535,536,537,538,539,540,541,542,543,544,545,546,550,551,552,553,554,555,556,557,567,573,577,586,589,590,591,592,593,595,596,599,601,616,619,621,628,629,630,633,634,635,636,665,683,684,685,691,692,693,694,702,703,705,706,707,710,711,714,720,2250,2254", "Race IDs excluded from facing target when hailed")
 RULE_CATEGORY_END()
 
 RULE_CATEGORY(Aggro)

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
@@ -1945,6 +1946,7 @@ struct ServerOP_GuildMessage_Struct {
 struct TraderMessaging_Struct {
 	uint32 action;
 	uint32 zone_id;
+	uint32 instance_id;
 	uint32 trader_id;
 	uint32 entity_id;
 	char   trader_name[64];

common/tasks.h

@@ -83,7 +83,8 @@ struct ActivityInformation {
 		if (zone_ids.empty()) {
 			return true;
 		}
-		bool found_zone = std::find(zone_ids.begin(), zone_ids.end(), zone_id) != zone_ids.end();
+		bool found_zone = std::any_of(zone_ids.begin(), zone_ids.end(),
+			[zone_id](int id) { return id <= 0 || id == zone_id; });
 
 		return found_zone && (zone_version == version || zone_version == -1);
 	}
@@ -100,7 +101,7 @@ struct ActivityInformation {
 			out.WriteInt32(activity_type == TaskActivityType::GiveCash ? 1 : goal_count);
 			out.WriteLengthString(skill_list); // used in SkillOn objective type string, "-1" for none
 			out.WriteLengthString(spell_list); // used in CastOn objective type string, "0" for none
-			out.WriteString(zones);            // used in objective zone column and task select "begins in" (may have multiple, "0" for "unknown zone", empty for "ALL")
+			out.WriteString(zones);            // used in ui zone columns and task select "begins in" (may have multiple, invalid id for "Unknown Zone", empty for "ALL")
 		}
 		else
 		{
@@ -114,7 +115,7 @@ struct ActivityInformation {
 		out.WriteString(description_override);
 
 		if (client_version >= EQ::versions::ClientVersion::RoF) {
-			out.WriteString(zones); // serialized again after description (seems unused)
+			out.WriteString(zones); // target zone version internal id (unused client side)
 		}
 	}
 

common/version.h

@@ -25,7 +25,7 @@
 
 // Build variables
 // these get injected during the build pipeline
-#define CURRENT_VERSION "22.56.3-dev" // always append -dev to the current version for custom-builds
+#define CURRENT_VERSION "22.60.0-dev" // always append -dev to the current version for custom-builds
 #define LOGIN_VERSION "0.8.0"
 #define COMPILE_DATE    __DATE__
 #define COMPILE_TIME    __TIME__
@@ -42,7 +42,7 @@
  * Manifest: https://github.com/EQEmu/Server/blob/master/utils/sql/db_update_manifest.txt
  */
 
-#define CURRENT_BINARY_DATABASE_VERSION 9284
+#define CURRENT_BINARY_DATABASE_VERSION 9285
 #define CURRENT_BINARY_BOTS_DATABASE_VERSION 9045
 
 #endif

libs/perlbind/include/perlbind/scalar.h

@@ -251,4 +251,6 @@ private:
   scalar m_value;
 };
 
+using ref = reference;
+
 } // namespace perlbind

libs/perlbind/include/perlbind/stack_push.h

@@ -28,8 +28,8 @@ struct pusher
     ++m_pushed;
   }
   void push(const std::string& value) { mPUSHp(value.c_str(), value.size()); ++m_pushed; }
-  void push(scalar value) { mPUSHs(value.release()); ++m_pushed; };
-  void push(reference value) { mPUSHs(value.release()); ++m_pushed; };
+  void push(scalar value) { mPUSHs(value.release()); ++m_pushed; }
+  void push(reference value) { mPUSHs(value.release()); ++m_pushed; }
 
   void push(array value)
   {
@@ -38,7 +38,8 @@ struct pusher
     for (int i = 0; i < count; ++i)
     {
       // mortalizes one reference to array element to avoid copying
-      PUSHs(sv_2mortal(SvREFCNT_inc(value[i].sv())));
+      SV** sv = av_fetch(static_cast<AV*>(value), i, true);
+      mPUSHs(SvREFCNT_inc(*sv));
     }
     m_pushed += count;
   }

libs/perlbind/include/perlbind/stack_read.h

@@ -242,7 +242,7 @@ struct read_as<hash>
   static bool check(PerlInterpreter* my_perl, int i, int ax, int items)
   {
     int remaining = items - i;
-    return remaining > 0 && remaining % 2 == 0 && SvTYPE(ST(i)) == SVt_PV;
+    return remaining > 0 && remaining % 2 == 0 && SvTYPE(ST(i)) < SVt_PVAV;
   }
 
   static hash get(PerlInterpreter* my_perl, int i, int ax, int items)

libs/perlbind/include/perlbind/version.h

@@ -1,7 +1,7 @@
 #pragma once
 
 constexpr int perlbind_version_major = 1;
-constexpr int perlbind_version_minor = 0;
+constexpr int perlbind_version_minor = 1;
 constexpr int perlbind_version_patch = 0;
 
 constexpr int perlbind_version()

loginserver/client_manager.cpp

@@ -7,6 +7,79 @@ extern bool        run_server;
 #include "../common/eqemu_logsys.h"
 #include "../common/misc.h"
 #include "../common/path_manager.h"
+#include "../common/file.h"
+
+void CheckTitaniumOpcodeFile(const std::string &path) {
+	if (File::Exists(path)) {
+		return;
+	}
+
+	auto f = fopen(path.c_str(), "w");
+	if (f) {
+		fprintf(f, "#EQEmu Public Login Server OPCodes\n");
+		fprintf(f, "OP_SessionReady=0x0001\n");
+		fprintf(f, "OP_Login=0x0002\n");
+		fprintf(f, "OP_ServerListRequest=0x0004\n");
+		fprintf(f, "OP_PlayEverquestRequest=0x000d\n");
+		fprintf(f, "OP_PlayEverquestResponse=0x0021\n");
+		fprintf(f, "OP_ChatMessage=0x0016\n");
+		fprintf(f, "OP_LoginAccepted=0x0017\n");
+		fprintf(f, "OP_ServerListResponse=0x0018\n");
+		fprintf(f, "OP_Poll=0x0029\n");
+		fprintf(f, "OP_EnterChat=0x000f\n");
+		fprintf(f, "OP_PollResponse=0x0011\n");
+		fclose(f);
+	}
+}
+
+void CheckSoDOpcodeFile(const std::string& path) {
+	if (File::Exists(path)) {
+		return;
+	}
+
+	auto f = fopen(path.c_str(), "w");
+	if (f) {
+		fprintf(f, "#EQEmu Public Login Server OPCodes\n");
+		fprintf(f, "OP_SessionReady=0x0001\n");
+		fprintf(f, "OP_Login=0x0002\n");
+		fprintf(f, "OP_ServerListRequest=0x0004\n");
+		fprintf(f, "OP_PlayEverquestRequest=0x000d\n");
+		fprintf(f, "OP_PlayEverquestResponse=0x0022\n");
+		fprintf(f, "OP_ChatMessage=0x0017\n");
+		fprintf(f, "OP_LoginAccepted=0x0018\n");
+		fprintf(f, "OP_ServerListResponse=0x0019\n");
+		fprintf(f, "OP_Poll=0x0029\n");
+		fprintf(f, "OP_LoginExpansionPacketData=0x0031\n");
+		fprintf(f, "OP_EnterChat=0x000f\n");
+		fprintf(f, "OP_PollResponse=0x0011\n");
+		fclose(f);
+	}
+}
+
+void CheckLarionOpcodeFile(const std::string& path) {
+	if (File::Exists(path)) {
+		return;
+	}
+
+	auto f = fopen(path.c_str(), "w");
+	if (f) {
+		fprintf(f, "#EQEmu Public Login Server OPCodes\n");
+		fprintf(f, "OP_SessionReady=0x0001\n");
+		fprintf(f, "OP_Login=0x0002\n");
+		fprintf(f, "OP_ServerListRequest=0x0004\n");
+		fprintf(f, "OP_PlayEverquestRequest=0x000d\n");
+		fprintf(f, "OP_PlayEverquestResponse=0x0022\n");
+		fprintf(f, "OP_ChatMessage=0x0017\n");
+		fprintf(f, "OP_LoginAccepted=0x0018\n");
+		fprintf(f, "OP_ServerListResponse=0x0019\n");
+		fprintf(f, "OP_Poll=0x0029\n");
+		fprintf(f, "OP_EnterChat=0x000f\n");
+		fprintf(f, "OP_PollResponse=0x0011\n");
+		fprintf(f, "OP_SystemFingerprint=0x0016\n");
+		fprintf(f, "OP_ExpansionList=0x0030\n");
+		fclose(f);
+	}
+}
 
 ClientManager::ClientManager()
 {
@@ -19,14 +92,12 @@ ClientManager::ClientManager()
 
 	std::string opcodes_path = fmt::format(
 		"{}/{}",
-		path.GetServerPath(),
-		server.config.GetVariableString(
-			"client_configuration",
-			"titanium_opcodes",
-			"login_opcodes.conf"
-		)
+		path.GetOpcodePath(),
+		"login_opcodes.conf"
 	);
 
+	CheckTitaniumOpcodeFile(opcodes_path);
+
 	if (!titanium_ops->LoadOpcodes(opcodes_path.c_str())) {
 		LogError(
 			"ClientManager fatal error: couldn't load opcodes for Titanium file [{0}]",
@@ -58,14 +129,12 @@ ClientManager::ClientManager()
 
 	opcodes_path = fmt::format(
 		"{}/{}",
-		path.GetServerPath(),
-		server.config.GetVariableString(
-			"client_configuration",
-			"sod_opcodes",
-			"login_opcodes.conf"
-		)
+		path.GetOpcodePath(),
+		"login_opcodes_sod.conf"
 	);
 
+	CheckSoDOpcodeFile(opcodes_path);
+
 	if (!sod_ops->LoadOpcodes(opcodes_path.c_str())) {
 		LogError(
 			"ClientManager fatal error: couldn't load opcodes for SoD file {0}",
@@ -98,14 +167,12 @@ ClientManager::ClientManager()
 
 	opcodes_path = fmt::format(
 		"{}/{}",
-		path.GetServerPath(),
-		server.config.GetVariableString(
-			"client_configuration",
-			"larion_opcodes",
-			"login_opcodes.conf"
-		)
+		path.GetOpcodePath(),
+		"login_opcodes_larion.conf"
 	);
 
+	CheckLarionOpcodeFile(opcodes_path);
+
 	if (!larion_ops->LoadOpcodes(opcodes_path.c_str())) {
 		LogError(
 			"ClientManager fatal error: couldn't load opcodes for Larion file [{0}]",

package.json

@@ -1,6 +1,6 @@
 {
   "name": "eqemu-server",
-  "version": "22.56.3",
+  "version": "22.60.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/EQEmu/Server.git"

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/client.cpp

@@ -526,9 +526,27 @@ bool Client::HandleSendLoginInfoPacket(const EQApplicationPacket *app)
 		SendEnterWorld(cle->name());
 		SendPostEnterWorld();
 		if (!is_player_zoning) {
-			SendExpansionInfo();
-			SendCharInfo();
-			database.LoginIP(cle->AccountID(), long2ip(GetIP()));
+			const auto supported_clients = RuleS(World, SupportedClients);
+			bool skip_char_info = false;
+			if (!supported_clients.empty()) {
+				const std::string& name = EQ::versions::ClientVersionName(m_ClientVersion);
+				const auto& clients = Strings::Split(supported_clients, ",");
+				if (std::find(clients.begin(), clients.end(), name) == clients.end()) {
+					SendUnsupportedClientPacket(
+						fmt::format(
+							"Client Not In Supported List [{}]",
+							supported_clients
+						)
+					);
+					skip_char_info = true;
+				}
+			}
+
+			if (!skip_char_info) {
+				SendExpansionInfo();
+				SendCharInfo();
+				database.LoginIP(cle->AccountID(), long2ip(GetIP()));
+			}
 		}
 
 		cle->SetIP(GetIP());
@@ -2453,3 +2471,34 @@ void Client::SendGuildTributeOptInToggle(const GuildTributeMemberToggle *in)
 	QueuePacket(outapp);
 	safe_delete(outapp);
 }
+
+void Client::SendUnsupportedClientPacket(const std::string& message)
+{
+	EQApplicationPacket packet(OP_SendCharInfo, sizeof(CharacterSelect_Struct) + sizeof(CharacterSelectEntry_Struct));
+
+	unsigned char* buff_ptr = packet.pBuffer;
+	auto cs = (CharacterSelect_Struct*) buff_ptr;
+
+	cs->CharCount  = 1;
+	cs->TotalChars = 1;
+
+	buff_ptr += sizeof(CharacterSelect_Struct);
+
+	auto e = (CharacterSelectEntry_Struct*) buff_ptr;
+
+	strcpy(e->Name, message.c_str());
+
+	e->Race        = Race::Human;
+	e->Class       = Class::Warrior;
+	e->Level       = 1;
+	e->ShroudClass = e->Class;
+	e->ShroudRace  = e->Race;
+	e->Zone        = std::numeric_limits<uint16>::max();
+	e->Instance    = 0;
+	e->Gender      = Gender::Male;
+	e->GoHome      = 0;
+	e->Tutorial    = 0;
+	e->Enabled     = 0;
+
+	QueuePacket(&packet);
+}

world/client.h

@@ -120,6 +120,7 @@ private:
 	EQStreamInterface* eqs;
 	bool CanTradeFVNoDropItem();
 	void RecordPossibleHack(const std::string& message);
+	void SendUnsupportedClientPacket(const std::string& message);
 };
 
 bool CheckCharCreateInfoSoF(CharCreate_Struct *cc);

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/world_boot.cpp

@@ -294,6 +294,13 @@ bool WorldBoot::DatabaseLoadRoutines(int argc, char **argv)
 	database.ClearBuyerDetails();
 	LogInfo("Clearing buyer table details");
 
+	if (RuleB(Bots, Enabled)) {
+		LogInfo("Clearing [bot_pet_buffs] table of stale entries");
+		database.QueryDatabase(
+			"DELETE FROM bot_pet_buffs WHERE NOT EXISTS (SELECT * FROM bot_pets WHERE bot_pets.pets_index = bot_pet_buffs.pets_index)"
+		);
+	}
+
 	if (!content_db.LoadItems(hotfix_name)) {
 		LogError("Error: Could not load item data. But ignoring");
 	}

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:
@@ -1755,7 +1756,11 @@ void ZoneServer::HandleMessage(uint16 opcode, const EQ::Net::Packet &p) {
 				return;
 			}
 
-			zoneserver_list.SendPacket(Zones::BAZAAR, pack);
+			auto trader = client_list.FindCLEByCharacterID(in->trader_buy_struct.trader_id);
+			if (trader) {
+				zoneserver_list.SendPacket(trader->zone(), trader->instance(), pack);
+			}
+
 			break;
 		}
 		case ServerOP_BuyerMessaging: {
@@ -1775,12 +1780,20 @@ void ZoneServer::HandleMessage(uint16 opcode, const EQ::Net::Packet &p) {
 					break;
 				}
 				case Barter_SellItem: {
-					zoneserver_list.SendPacket(Zones::BAZAAR, pack);
+					auto buyer = client_list.FindCharacter(in->buyer_name);
+					if (buyer) {
+						zoneserver_list.SendPacket(buyer->zone(), buyer->instance(), pack);
+					}
+
 					break;
 				}
 				case Barter_FailedTransaction:
 				case Barter_BuyerTransactionComplete: {
-					zoneserver_list.SendPacket(in->zone_id, pack);
+					auto seller = client_list.FindCharacter(in->seller_name);
+					if (seller) {
+						zoneserver_list.SendPacket(seller->zone(), seller->instance(), pack);
+					}
+
 					break;
 				}
 				default:

zone/CMakeLists.txt

@@ -54,6 +54,7 @@ SET(zone_sources
     lua_buff.cpp
     lua_corpse.cpp
     lua_client.cpp
+    lua_database.cpp
     lua_door.cpp
     lua_encounter.cpp
     lua_entity.cpp
@@ -110,6 +111,7 @@ SET(zone_sources
     perl_bot.cpp
     perl_buff.cpp
     perl_client.cpp
+    perl_database.cpp
     perl_doors.cpp
     perl_entity.cpp
     perl_expedition.cpp
@@ -135,6 +137,7 @@ SET(zone_sources
     qglobals.cpp
     queryserv.cpp
     questmgr.cpp
+    quest_db.cpp
     quest_parser_collection.cpp
     raids.cpp
     raycast_mesh.cpp
@@ -167,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
@@ -215,6 +219,7 @@ SET(zone_headers
     lua_buff.h
     lua_client.h
     lua_corpse.h
+    lua_database.h
     lua_door.h
     lua_encounter.h
     lua_entity.h
@@ -251,6 +256,7 @@ SET(zone_headers
     pathfinder_interface.h
     pathfinder_nav_mesh.h
     pathfinder_null.h
+    perl_database.h
     perlpacket.h
     petitions.h
     pets.h
@@ -260,6 +266,7 @@ SET(zone_headers
     queryserv.h
     quest_interface.h
     questmgr.h
+    quest_db.h
     quest_parser_collection.h
     raids.h
     raycast_mesh.h

zone/bot.cpp

@@ -1578,7 +1578,10 @@ bool Bot::Process()
 		return false;
 	}
 
-	ScanCloseMobProcess();
+	if (m_scan_close_mobs_timer.Check()) {
+		entity_list.ScanCloseMobs(this);
+	}
+
 	SpellProcess();
 
 	if (tic_timer.Check()) {

zone/bot_database.cpp

@@ -828,7 +828,7 @@ bool BotDatabase::LoadTimers(Bot* b)
 	BotTimer_Struct t{ };
 
 	for (const auto& e : l) {
-		if (t.timer_value < (Timer::GetCurrentTime() + t.recast_time)) {
+		if (e.timer_value < (Timer::GetCurrentTime() + e.recast_time)) {
 			t.timer_id    = e.timer_id;
 			t.timer_value = e.timer_value;
 			t.recast_time = e.recast_time;
@@ -1451,7 +1451,7 @@ bool BotDatabase::DeletePetBuffs(const uint32 bot_id)
 		return true;
 	}
 
-	BotPetBuffsRepository::DeleteOne(database, saved_pet_index);
+	BotPetBuffsRepository::DeleteWhere(database, fmt::format("pets_index = {}", saved_pet_index));
 
 	return true;
 }

zone/client.cpp

@@ -8677,14 +8677,16 @@ int Client::GetAccountAge() {
 
 void Client::CheckRegionTypeChanges()
 {
-	if (!zone->HasWaterMap())
+	if (!zone->HasWaterMap()) {
 		return;
+	}
 
 	auto new_region = zone->watermap->ReturnRegionType(glm::vec3(m_Position));
 
 	// still same region, do nothing
-	if (last_region_type == new_region)
+	if (last_region_type == new_region) {
 		return;
+	}
 
 	// If we got out of water clear any water aggro for water only npcs
 	if (last_region_type == RegionTypeWater) {
@@ -8695,13 +8697,15 @@ void Client::CheckRegionTypeChanges()
 	last_region_type = new_region;
 
 	// PVP is the only state we need to keep track of, so we can just return now for PVP servers
-	if (RuleI(World, PVPSettings) > 0)
+	if (RuleI(World, PVPSettings) > 0) {
 		return;
+	}
 
-	if (last_region_type == RegionTypePVP)
+	if (last_region_type == RegionTypePVP && RuleB(World, EnablePVPRegions)) {
 		temp_pvp = true;
-	else if (temp_pvp)
+	} else if (temp_pvp) {
 		temp_pvp = false;
+	}
 }
 
 void Client::ProcessAggroMeter()
@@ -11991,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) &&
@@ -12007,7 +12009,7 @@ void Client::SendPath(Mob* target)
 		(
 			target->CastToClient()->IsTrader() ||
 			target->CastToClient()->IsBuyer()
-		)
+			)
 		) {
 		Message(
 			Chat::Yellow,
@@ -12027,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) {
@@ -12037,9 +12050,9 @@ void Client::SendPath(Mob* target)
 		a.x = GetX();
 		a.y = GetY();
 		a.z = GetZ();
-		b.x = target->GetX();
-		b.y = target->GetY();
-		b.z = target->GetZ();
+		b.x = loc.x;
+		b.y = loc.y;
+		b.z = loc.z;
 
 		points.push_back(a);
 		points.push_back(b);
@@ -12052,9 +12065,9 @@ void Client::SendPath(Mob* target)
 		);
 
 		glm::vec3 path_end(
-			target->GetX(),
-			target->GetY(),
-			target->GetZ() + (target->GetSize() < 6.0 ? 6 : target->GetSize()) * HEAD_POSITION
+			loc.x,
+			loc.y,
+			loc.z
 		);
 
 		bool partial   = false;
@@ -12077,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;
@@ -12104,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);
@@ -12316,6 +12309,248 @@ void Client::PlayerTradeEventLog(Trade *t, Trade *t2)
 	RecordPlayerEventLogWithClient(trader2, PlayerEvent::TRADE, e);
 }
 
+void Client::NPCHandinEventLog(Trade* t, NPC* n)
+{
+	Client* c = t->GetOwner()->CastToClient();
+
+	std::vector<PlayerEvent::HandinEntry> hi = {};
+	std::vector<PlayerEvent::HandinEntry> ri = {};
+	PlayerEvent::HandinMoney              hm{};
+	PlayerEvent::HandinMoney              rm{};
+
+	if (
+		c->EntityVariableExists("HANDIN_ITEMS") &&
+		c->EntityVariableExists("HANDIN_MONEY") &&
+		c->EntityVariableExists("RETURN_ITEMS") &&
+		c->EntityVariableExists("RETURN_MONEY")
+	) {
+		const std::string& handin_items = c->GetEntityVariable("HANDIN_ITEMS");
+		const std::string& return_items = c->GetEntityVariable("RETURN_ITEMS");
+		const std::string& handin_money = c->GetEntityVariable("HANDIN_MONEY");
+		const std::string& return_money = c->GetEntityVariable("RETURN_MONEY");
+
+		// Handin Items
+		if (!handin_items.empty()) {
+			if (Strings::Contains(handin_items, ",")) {
+				const auto handin_data = Strings::Split(handin_items, ",");
+				for (const auto& h : handin_data) {
+					const auto item_data = Strings::Split(h, "|");
+					if (
+						item_data.size() == 3 &&
+						Strings::IsNumber(item_data[0]) &&
+						Strings::IsNumber(item_data[1]) &&
+						Strings::IsNumber(item_data[2])
+					) {
+						const uint32 item_id = Strings::ToUnsignedInt(item_data[0]);
+						if (item_id != 0) {
+							const auto* item = database.GetItem(item_id);
+
+							if (item) {
+								hi.emplace_back(
+									PlayerEvent::HandinEntry{
+										.item_id = item_id,
+										.item_name = item->Name,
+										.charges = static_cast<uint16>(Strings::ToUnsignedInt(item_data[1])),
+										.attuned = Strings::ToInt(item_data[2]) ? true : false
+									}
+								);
+							}
+						}
+					}
+				}
+			} else if (Strings::Contains(handin_items, "|")) {
+				const auto item_data = Strings::Split(handin_items, "|");
+				if (
+					item_data.size() == 3 &&
+					Strings::IsNumber(item_data[0]) &&
+					Strings::IsNumber(item_data[1]) &&
+					Strings::IsNumber(item_data[2])
+				) {
+					const uint32 item_id = Strings::ToUnsignedInt(item_data[0]);
+					const auto*  item    = database.GetItem(item_id);
+
+					if (item) {
+						hi.emplace_back(
+							PlayerEvent::HandinEntry{
+								.item_id = item_id,
+								.item_name = item->Name,
+								.charges = static_cast<uint16>(Strings::ToUnsignedInt(item_data[1])),
+								.attuned = Strings::ToInt(item_data[2]) ? true : false
+							}
+						);
+					}
+				}
+			}
+		}
+
+		// Handin Money
+		if (!handin_money.empty()) {
+			const auto hms = Strings::Split(handin_money, "|");
+
+			hm.copper   = Strings::ToUnsignedInt(hms[0]);
+			hm.silver   = Strings::ToUnsignedInt(hms[1]);
+			hm.gold     = Strings::ToUnsignedInt(hms[2]);
+			hm.platinum = Strings::ToUnsignedInt(hms[3]);
+		}
+
+		// Return Items
+		if (!return_items.empty()) {
+			if (Strings::Contains(return_items, ",")) {
+				const auto return_data = Strings::Split(return_items, ",");
+				for (const auto& r : return_data) {
+					const auto item_data = Strings::Split(r, "|");
+					if (
+						item_data.size() == 3 &&
+						Strings::IsNumber(item_data[0]) &&
+						Strings::IsNumber(item_data[1]) &&
+						Strings::IsNumber(item_data[2])
+					) {
+						const uint32 item_id = Strings::ToUnsignedInt(item_data[0]);
+						const auto*  item    = database.GetItem(item_id);
+
+						if (item) {
+							ri.emplace_back(
+								PlayerEvent::HandinEntry{
+									.item_id = item_id,
+									.item_name = item->Name,
+									.charges = static_cast<uint16>(Strings::ToUnsignedInt(item_data[1])),
+									.attuned = Strings::ToInt(item_data[2]) ? true : false
+								}
+							);
+						}
+					}
+				}
+			} else if (Strings::Contains(return_items, "|")) {
+				const auto item_data = Strings::Split(return_items, "|");
+				if (
+					item_data.size() == 3 &&
+					Strings::IsNumber(item_data[0]) &&
+					Strings::IsNumber(item_data[1]) &&
+					Strings::IsNumber(item_data[2])
+				) {
+					const uint32 item_id = Strings::ToUnsignedInt(item_data[0]);
+					const auto*  item    = database.GetItem(item_id);
+
+					if (item) {
+						ri.emplace_back(
+							PlayerEvent::HandinEntry{
+								.item_id = item_id,
+								.item_name = item->Name,
+								.charges = static_cast<uint16>(Strings::ToUnsignedInt(item_data[1])),
+								.attuned = Strings::ToInt(item_data[2]) ? true : false
+							}
+						);
+					}
+				}
+			}
+		}
+
+		// Return Money
+		if (!return_money.empty()) {
+			const auto rms = Strings::Split(return_money, "|");
+			rm.copper   = static_cast<uint32>(Strings::ToUnsignedInt(rms[0]));
+			rm.silver   = static_cast<uint32>(Strings::ToUnsignedInt(rms[1]));
+			rm.gold     = static_cast<uint32>(Strings::ToUnsignedInt(rms[2]));
+			rm.platinum = static_cast<uint32>(Strings::ToUnsignedInt(rms[3]));
+		}
+
+		c->DeleteEntityVariable("HANDIN_ITEMS");
+		c->DeleteEntityVariable("HANDIN_MONEY");
+		c->DeleteEntityVariable("RETURN_ITEMS");
+		c->DeleteEntityVariable("RETURN_MONEY");
+
+		const bool handed_in_money = hm.platinum > 0 || hm.gold > 0 || hm.silver > 0 || hm.copper > 0;
+
+		const bool event_has_data_to_record = (
+			!hi.empty() || handed_in_money
+		);
+
+		if (player_event_logs.IsEventEnabled(PlayerEvent::NPC_HANDIN) && event_has_data_to_record) {
+			auto e = PlayerEvent::HandinEvent{
+				.npc_id = n->GetNPCTypeID(),
+				.npc_name = n->GetCleanName(),
+				.handin_items = hi,
+				.handin_money = hm,
+				.return_items = ri,
+				.return_money = rm,
+				.is_quest_handin = true
+			};
+
+			RecordPlayerEventLogWithClient(c, PlayerEvent::NPC_HANDIN, e);
+		}
+
+		return;
+	}
+
+	uint8 item_count = 0;
+
+	hm.platinum = t->pp;
+	hm.gold     = t->gp;
+	hm.silver   = t->sp;
+	hm.copper   = t->cp;
+
+	for (uint16 i = EQ::invslot::TRADE_BEGIN; i <= EQ::invslot::TRADE_NPC_END; i++) {
+		if (c->GetInv().GetItem(i)) {
+			item_count++;
+		}
+	}
+
+	hi.reserve(item_count);
+
+	if (item_count > 0) {
+		for (uint16 i = EQ::invslot::TRADE_BEGIN; i <= EQ::invslot::TRADE_NPC_END; i++) {
+			const EQ::ItemInstance* inst = c->GetInv().GetItem(i);
+			if (inst) {
+				hi.emplace_back(
+					PlayerEvent::HandinEntry{
+						.item_id = inst->GetItem()->ID,
+						.item_name = inst->GetItem()->Name,
+						.charges = static_cast<uint16>(inst->GetCharges()),
+						.attuned = inst->IsAttuned()
+					}
+				);
+
+				if (inst->IsClassBag()) {
+					for (uint8 j = EQ::invbag::SLOT_BEGIN; j <= EQ::invbag::SLOT_END; j++) {
+						inst = c->GetInv().GetItem(i, j);
+						if (inst) {
+							hi.emplace_back(
+								PlayerEvent::HandinEntry{
+									.item_id = inst->GetItem()->ID,
+									.item_name = inst->GetItem()->Name,
+									.charges = static_cast<uint16>(inst->GetCharges()),
+									.attuned = inst->IsAttuned()
+								}
+							);
+						}
+					}
+				}
+			}
+		}
+	}
+
+	const bool handed_in_money = hm.platinum > 0 || hm.gold > 0 || hm.silver > 0 || hm.copper > 0;
+
+	ri = hi;
+	rm = hm;
+
+	const bool event_has_data_to_record = !hi.empty() || handed_in_money;
+
+	if (player_event_logs.IsEventEnabled(PlayerEvent::NPC_HANDIN) && event_has_data_to_record) {
+		auto e = PlayerEvent::HandinEvent{
+			.npc_id = n->GetNPCTypeID(),
+			.npc_name = n->GetCleanName(),
+			.handin_items = hi,
+			.handin_money = hm,
+			.return_items = ri,
+			.return_money = rm,
+			.is_quest_handin = false
+		};
+
+		RecordPlayerEventLogWithClient(c, PlayerEvent::NPC_HANDIN, e);
+	}
+}
+
 void Client::ShowSpells(Client* c, ShowSpellType show_spell_type)
 {
 	std::string spell_string;

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);
@@ -2227,6 +2228,7 @@ private:
 	bool CanTradeFVNoDropItem();
 	void SendMobPositions();
 	void PlayerTradeEventLog(Trade *t, Trade *t2);
+	void NPCHandinEventLog(Trade* t, NPC* n);
 
 	// full and partial mail key cache
 	std::string m_mail_key_full;

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);
@@ -2731,6 +2734,14 @@ void Client::Handle_OP_AltCurrencyReclaim(const EQApplicationPacket *app)
 		return;
 	}
 
+	if (IsTrader()) {
+		TraderEndTrader();
+	}
+
+	if (IsBuyer()) {
+		ToggleBuyerMode(false);
+	}
+
 	/* Item to Currency Storage */
 	if (reclaim->reclaim_flag == 1) {
 		uint32 removed = NukeItem(item_id, invWhereWorn | invWherePersonal | invWhereCursor);
@@ -5013,7 +5024,11 @@ void Client::Handle_OP_ClientUpdate(const EQApplicationPacket *app) {
 	SetMoving(!(cy == m_Position.y && cx == m_Position.x));
 
 	CheckClientToNpcAggroTimer();
-	CheckScanCloseMobsMovingTimer();
+
+	if (m_mob_check_moving_timer.Check()) {
+		CheckScanCloseMobsMovingTimer();
+	}
+
 	CheckSendBulkClientPositionUpdate();
 
 	int32 new_animation = ppu->animation;
@@ -6462,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/client_process.cpp

@@ -281,7 +281,9 @@ bool Client::Process() {
 			}
 		}
 
-		ScanCloseMobProcess();
+		if (m_scan_close_mobs_timer.Check()) {
+			entity_list.ScanCloseMobs(this);
+		}
 
 		if (RuleB(Inventory, LazyLoadBank)) {
 			// poll once a second to see if we are close to a banker and we haven't loaded the bank yet

zone/command.cpp

@@ -40,7 +40,7 @@ extern FastMath g_Math;
 void CatchSignal(int sig_num);
 
 
-int                                                           command_count; // how many commands we have
+int command_count; // how many commands we have
 
 // this is the pointer to the dispatch function, updated once
 // init has been performed to point at the real function
@@ -96,7 +96,7 @@ int command_init(void)
 		command_add("augmentitem", "Force augments an item. Must have the augment item window open.", AccountStatus::GMImpossible, command_augmentitem) ||
 		command_add("ban", "[Character Name] [Reason] - Ban by character name", AccountStatus::GMLeadAdmin, command_ban) ||
 		command_add("bugs", "[Close|Delete|Review|Search|View] - Handles player bug reports", AccountStatus::QuestTroupe, command_bugs) ||
-		command_add("bot", "Type \"#bot help\" or \"^help\" to the see the list of available commands for bots.", AccountStatus::Player, command_bot) ||
+		(RuleB(Bots, Enabled) && command_add("bot", "Type \"#bot help\" or \"^help\" to the see the list of available commands for bots.", AccountStatus::Player, command_bot)) ||
 		command_add("camerashake", "[Duration (Milliseconds)] [Intensity (1-10)] - Shakes the camera on everyone's screen globally.", AccountStatus::QuestTroupe, command_camerashake) ||
 		command_add("castspell", "[Spell ID] [Instant (0 = False, 1 = True, Default is 1 if Unused)] - Cast a spell", AccountStatus::Guide, command_castspell) ||
 		command_add("chat", "[Channel ID] [Message] - Send a channel message to all zones", AccountStatus::GMMgmt, command_chat) ||

zone/embparser.cpp

@@ -58,6 +58,7 @@ void perl_register_expedition_lock_messages();
 void perl_register_bot();
 void perl_register_buff();
 void perl_register_merc();
+void perl_register_database();
 #endif // EMBPERL_XS_CLASSES
 #endif // EMBPERL_XS
 
@@ -1185,6 +1186,7 @@ void PerlembParser::MapFunctions()
 	perl_register_bot();
 	perl_register_buff();
 	perl_register_merc();
+	perl_register_database();
 #endif // EMBPERL_XS_CLASSES
 }
 
@@ -1734,7 +1736,7 @@ void PerlembParser::ExportEventVariables(
 		case EVENT_PAYLOAD: {
 			Seperator sep(data);
 			ExportVar(package_name.c_str(), "payload_id", sep.arg[0]);
-			ExportVar(package_name.c_str(), "payload_value", sep.arg[1]);
+			ExportVar(package_name.c_str(), "payload_value", sep.argplus[1]);
 			break;
 		}
 

zone/embparser_api.cpp

@@ -5978,6 +5978,16 @@ bool Perl__aretaskscompleted(perl::array task_ids)
 	return quest_manager.aretaskscompleted(v);
 }
 
+void Perl__SpawnCircle(uint32 npc_id, float x, float y, float z, float heading, float radius, uint32 points)
+{
+	quest_manager.SpawnCircle(npc_id, glm::vec4(x, y, z, heading), radius, points);
+}
+
+void Perl__SpawnGrid(uint32 npc_id, float x, float y, float z, float heading, float spacing, uint32 spawn_count)
+{
+	quest_manager.SpawnGrid(npc_id, glm::vec4(x, y, z, heading), spacing, spawn_count);
+}
+
 void perl_register_quest()
 {
 	perl::interpreter perl(PERL_GET_THX);
@@ -6287,6 +6297,8 @@ void perl_register_quest()
 	package.add("SendMail", &Perl__SendMail);
 	package.add("SetAutoLoginCharacterNameByAccountID", &Perl__SetAutoLoginCharacterNameByAccountID);
 	package.add("SetRunning", &Perl__SetRunning);
+	package.add("SpawnCircle", &Perl__SpawnCircle);
+	package.add("SpawnGrid", &Perl__SpawnGrid);
 	package.add("activespeakactivity", &Perl__activespeakactivity);
 	package.add("activespeaktask", &Perl__activespeaktask);
 	package.add("activetasksinset", &Perl__activetasksinset);

zone/embperl.h

@@ -21,6 +21,8 @@ Eglin
 #include <perlbind/perlbind.h>
 namespace perl = perlbind;
 
+#undef connect
+#undef bind
 #undef Null
 
 #ifdef WIN32

zone/entity.cpp

@@ -2945,8 +2945,22 @@ void EntityList::RemoveAuraFromMobs(Mob *aura)
 // entity list (zone wide)
 void EntityList::ScanCloseMobs(Mob *scanning_mob)
 {
+	if (!scanning_mob) {
+		return;
+	}
+
+	if (scanning_mob->GetID() <= 0) {
+		return;
+	}
+
 	float scan_range = RuleI(Range, MobCloseScanDistance) * RuleI(Range, MobCloseScanDistance);
 
+	// Reserve memory in m_close_mobs to avoid frequent re-allocations if not already reserved.
+	// Assuming mob_list.size() as an upper bound for reservation.
+	if (scanning_mob->m_close_mobs.bucket_count() < mob_list.size()) {
+		scanning_mob->m_close_mobs.reserve(mob_list.size());
+	}
+
 	scanning_mob->m_close_mobs.clear();
 
 	for (auto &e : mob_list) {
@@ -2957,28 +2971,17 @@ void EntityList::ScanCloseMobs(Mob *scanning_mob)
 
 		float distance = DistanceSquared(scanning_mob->GetPosition(), mob->GetPosition());
 		if (distance <= scan_range || mob->GetAggroRange() >= scan_range) {
-			scanning_mob->m_close_mobs.emplace(std::pair<uint16, Mob *>(mob->GetID(), mob));
-
-			// add self to other mobs close list
-			if (scanning_mob->GetID() > 0) {
-				bool has_mob = false;
-
-				for (auto &cm: mob->m_close_mobs) {
-					if (scanning_mob->GetID() == cm.first) {
-						has_mob = true;
-						break;
-					}
-				}
-
-				if (!has_mob) {
-					mob->m_close_mobs.insert(std::pair<uint16, Mob *>(scanning_mob->GetID(), scanning_mob));
-				}
+			// add mob to scanning_mob's close list and vice versa
+			// check if the mob is already in the close mobs list before inserting
+			if (mob->m_close_mobs.find(scanning_mob->GetID()) == mob->m_close_mobs.end()) {
+				mob->m_close_mobs[scanning_mob->GetID()] = scanning_mob;
 			}
+			scanning_mob->m_close_mobs[mob->GetID()] = mob;
 		}
 	}
 
-	LogAIScanCloseDetail(
-		"[{}] Scanning Close List | list_size [{}] moving [{}]",
+	LogAIScanClose(
+		"[{}] Scanning close list > list_size [{}] moving [{}]",
 		scanning_mob->GetCleanName(),
 		scanning_mob->m_close_mobs.size(),
 		scanning_mob->IsMoving() ? "true" : "false"

zone/lua_database.cpp

@@ -0,0 +1,214 @@
+#ifdef LUA_EQEMU
+
+#include "lua_database.h"
+#include "zonedb.h"
+#include <luabind/luabind.hpp>
+#include <luabind/adopt_policy.hpp>
+
+// Luabind adopts the PreparedStmt wrapper object allocated with new and deletes it via GC
+// Lua GC is non-deterministic so handles should be closed explicitly to free db resources
+// Script errors/exceptions will hold resources until GC deletes the wrapper object
+
+Lua_MySQLPreparedStmt* Lua_Database::Prepare(lua_State* L, std::string query)
+{
+	return m_db ? new Lua_MySQLPreparedStmt(L, m_db->Prepare(std::move(query))) : nullptr;
+}
+
+void Lua_Database::Close()
+{
+	m_db.reset();
+}
+
+// ---------------------------------------------------------------------------
+
+void Lua_MySQLPreparedStmt::Close()
+{
+	m_stmt.reset();
+}
+
+void Lua_MySQLPreparedStmt::Execute(lua_State* L)
+{
+	if (m_stmt)
+	{
+		m_res = m_stmt->Execute();
+	}
+}
+
+void Lua_MySQLPreparedStmt::Execute(lua_State* L, luabind::object args)
+{
+	if (m_stmt)
+	{
+		std::vector<mysql::PreparedStmt::param_t> inputs;
+
+		// iterate table until nil like ipairs to guarantee traversal order
+		for (int i = 1, type; (type = luabind::type(args[i])) != LUA_TNIL; ++i)
+		{
+			switch (type)
+			{
+			case LUA_TBOOLEAN:
+				inputs.emplace_back(luabind::object_cast<bool>(args[i]));
+				break;
+			case LUA_TNUMBER: // all numbers are doubles in lua before 5.3
+				inputs.emplace_back(luabind::object_cast<lua_Number>(args[i]));
+				break;
+			case LUA_TSTRING:
+				inputs.emplace_back(luabind::object_cast<const char*>(args[i]));
+				break;
+			case LUA_TTABLE: // let tables substitute for null since nils can't exist
+				inputs.emplace_back(nullptr);
+				break;
+			default:
+				break;
+			}
+		}
+
+		m_res = m_stmt->Execute(inputs);
+	}
+}
+
+void Lua_MySQLPreparedStmt::SetOptions(luabind::object table)
+{
+	if (m_stmt)
+	{
+		mysql::StmtOptions opts = m_stmt->GetOptions();
+		if (luabind::type(table["buffer_results"]) == LUA_TBOOLEAN)
+		{
+			opts.buffer_results = luabind::object_cast<bool>(table["buffer_results"]);
+		}
+		if (luabind::type(table["use_max_length"]) == LUA_TBOOLEAN)
+		{
+			opts.use_max_length = luabind::object_cast<bool>(table["use_max_length"]);
+		}
+		m_stmt->SetOptions(opts);
+	}
+}
+
+static void PushValue(lua_State* L, const mysql::StmtColumn& col)
+{
+	if (col.IsNull())
+	{
+		lua_pushnil(L); // clear entry in cache from any previous row
+		return;
+	}
+
+	// 64-bit ints are pushed as strings since lua 5.1 only has 53-bit precision
+	switch (col.Type())
+	{
+	case MYSQL_TYPE_TINY:
+	case MYSQL_TYPE_SHORT:
+	case MYSQL_TYPE_INT24:
+	case MYSQL_TYPE_LONG:
+	case MYSQL_TYPE_FLOAT:
+	case MYSQL_TYPE_DOUBLE:
+		lua_pushnumber(L, col.Get<lua_Number>().value());
+		break;
+	case MYSQL_TYPE_LONGLONG:
+	case MYSQL_TYPE_BIT:
+	case MYSQL_TYPE_TIME:
+	case MYSQL_TYPE_DATE:
+	case MYSQL_TYPE_DATETIME:
+	case MYSQL_TYPE_TIMESTAMP:
+		{
+			std::string str = col.GetStr().value();
+			lua_pushlstring(L, str.data(), str.size());
+		}
+		break;
+	default: // string types, push raw buffer to avoid copy
+		{
+			std::string_view str = col.GetStrView().value();
+			lua_pushlstring(L, str.data(), str.size());
+		}
+		break;
+	}
+}
+
+luabind::object Lua_MySQLPreparedStmt::FetchArray(lua_State* L)
+{
+	auto row = m_stmt ? m_stmt->Fetch() : mysql::StmtRow();
+	if (!row)
+	{
+		return luabind::object();
+	}
+
+	// perf: bypass luabind operator[]
+	m_row_array.push(L);
+	for (const mysql::StmtColumn& col : row)
+	{
+		PushValue(L, col);
+		lua_rawseti(L, -2, col.Index() + 1);
+	}
+	lua_pop(L, 1);
+
+	return m_row_array;
+}
+
+luabind::object Lua_MySQLPreparedStmt::FetchHash(lua_State* L)
+{
+	auto row = m_stmt ? m_stmt->Fetch() : mysql::StmtRow();
+	if (!row)
+	{
+		return luabind::object();
+	}
+
+	// perf: bypass luabind operator[]
+	m_row_hash.push(L);
+	for (const mysql::StmtColumn& col : row)
+	{
+		PushValue(L, col);
+		lua_setfield(L, -2, col.Name().c_str());
+	}
+	lua_pop(L, 1);
+
+	return m_row_hash;
+}
+
+int Lua_MySQLPreparedStmt::ColumnCount()
+{
+	return m_res.ColumnCount();
+}
+
+uint64_t Lua_MySQLPreparedStmt::LastInsertID()
+{
+	return m_res.LastInsertID();
+}
+
+uint64_t Lua_MySQLPreparedStmt::RowCount()
+{
+	return m_res.RowCount();
+}
+
+uint64_t Lua_MySQLPreparedStmt::RowsAffected()
+{
+	return m_res.RowsAffected();
+}
+
+luabind::scope lua_register_database()
+{
+	return luabind::class_<Lua_Database>("Database")
+		.enum_("constants")
+		[(
+			luabind::value("Default", static_cast<int>(QuestDB::Connection::Default)),
+			luabind::value("Content", static_cast<int>(QuestDB::Connection::Content))
+		)]
+		.def(luabind::constructor<>())
+		.def(luabind::constructor<QuestDB::Connection>())
+		.def(luabind::constructor<QuestDB::Connection, bool>())
+		.def(luabind::constructor<const char*, const char*, const char*, const char*, uint32_t>())
+		.def("close", &Lua_Database::Close)
+		.def("prepare", &Lua_Database::Prepare, luabind::adopt(luabind::result)),
+
+	luabind::class_<Lua_MySQLPreparedStmt>("MySQLPreparedStmt")
+		.def("close", &Lua_MySQLPreparedStmt::Close)
+		.def("execute", static_cast<void(Lua_MySQLPreparedStmt::*)(lua_State*)>(&Lua_MySQLPreparedStmt::Execute))
+		.def("execute", static_cast<void(Lua_MySQLPreparedStmt::*)(lua_State*, luabind::object)>(&Lua_MySQLPreparedStmt::Execute))
+		.def("fetch", &Lua_MySQLPreparedStmt::FetchArray)
+		.def("fetch_array", &Lua_MySQLPreparedStmt::FetchArray)
+		.def("fetch_hash", &Lua_MySQLPreparedStmt::FetchHash)
+		.def("insert_id", &Lua_MySQLPreparedStmt::LastInsertID)
+		.def("num_fields", &Lua_MySQLPreparedStmt::ColumnCount)
+		.def("num_rows", &Lua_MySQLPreparedStmt::RowCount)
+		.def("rows_affected", &Lua_MySQLPreparedStmt::RowsAffected)
+		.def("set_options", &Lua_MySQLPreparedStmt::SetOptions);
+}
+
+#endif // LUA_EQEMU

zone/lua_database.h

@@ -0,0 +1,51 @@
+#pragma once
+
+#ifdef LUA_EQEMU
+
+#include "quest_db.h"
+#include "../common/mysql_stmt.h"
+#include <luabind/object.hpp>
+
+namespace luabind { struct scope; }
+luabind::scope lua_register_database();
+
+class Lua_MySQLPreparedStmt;
+
+class Lua_Database : public QuestDB
+{
+public:
+	using QuestDB::QuestDB;
+
+	void Close();
+	Lua_MySQLPreparedStmt* Prepare(lua_State*, std::string query);
+};
+
+class Lua_MySQLPreparedStmt
+{
+public:
+	Lua_MySQLPreparedStmt(lua_State* L, mysql::PreparedStmt&& stmt)
+		: m_stmt(std::make_unique<mysql::PreparedStmt>(std::move(stmt)))
+		, m_row_array(luabind::newtable(L))
+		, m_row_hash(luabind::newtable(L)) {}
+
+	void Close();
+	void Execute(lua_State*);
+	void Execute(lua_State*, luabind::object args);
+	void SetOptions(luabind::object table_opts);
+	luabind::object FetchArray(lua_State*);
+	luabind::object FetchHash(lua_State*);
+
+	// StmtResult functions accessible through this class to simplify api
+	int ColumnCount();
+	uint64_t LastInsertID();
+	uint64_t RowCount();
+	uint64_t RowsAffected();
+
+private:
+	std::unique_ptr<mysql::PreparedStmt> m_stmt;
+	mysql::StmtResult m_res = {};
+	luabind::object m_row_array; // perf: table cache for fetches
+	luabind::object m_row_hash;
+};
+
+#endif // LUA_EQEMU

zone/lua_general.cpp

@@ -5635,6 +5635,16 @@ int lua_are_tasks_completed(luabind::object task_ids)
 	return quest_manager.aretaskscompleted(v);
 }
 
+void lua_spawn_circle(uint32 npc_id, float x, float y, float z, float heading, float radius, uint32 points)
+{
+	quest_manager.SpawnCircle(npc_id, glm::vec4(x, y, z, heading), radius, points);
+}
+
+void lua_spawn_grid(uint32 npc_id, float x, float y, float z, float heading, float spacing, uint32 spawn_count)
+{
+	quest_manager.SpawnGrid(npc_id, glm::vec4(x, y, z, heading), spacing, spawn_count);
+}
+
 #define LuaCreateNPCParse(name, c_type, default_value) do { \
 	cur = table[#name]; \
 	if(luabind::type(cur) != LUA_TNIL) { \
@@ -6442,6 +6452,8 @@ luabind::scope lua_register_general() {
 		luabind::def("send_parcel", &lua_send_parcel),
 		luabind::def("get_zone_uptime", &lua_get_zone_uptime),
 		luabind::def("are_tasks_completed", &lua_are_tasks_completed),
+		luabind::def("spawn_circle", &lua_spawn_circle),
+		luabind::def("spawn_grid", &lua_spawn_grid),
 		/*
 			Cross Zone
 		*/
@@ -6583,7 +6595,7 @@ luabind::scope lua_register_general() {
 		luabind::def("cross_zone_reset_activity_by_guild_id", &lua_cross_zone_reset_activity_by_guild_id),
 		luabind::def("cross_zone_reset_activity_by_expedition_id", &lua_cross_zone_reset_activity_by_expedition_id),
 		luabind::def("cross_zone_reset_activity_by_client_name", &lua_cross_zone_reset_activity_by_client_name),
-		luabind::def("cross_zone_set_entity_variable_by_client_name", &lua_cross_zone_set_entity_variable_by_client_name),
+		luabind::def("cross_zone_set_entity_variable_by_char_id", &lua_cross_zone_set_entity_variable_by_char_id),
 		luabind::def("cross_zone_set_entity_variable_by_group_id", &lua_cross_zone_set_entity_variable_by_group_id),
 		luabind::def("cross_zone_set_entity_variable_by_raid_id", &lua_cross_zone_set_entity_variable_by_raid_id),
 		luabind::def("cross_zone_set_entity_variable_by_guild_id", &lua_cross_zone_set_entity_variable_by_guild_id),
@@ -6772,7 +6784,6 @@ luabind::scope lua_register_random() {
 		)];
 }
 
-
 luabind::scope lua_register_events() {
 	return luabind::class_<Events>("Event")
 		.enum_("constants")
@@ -8008,7 +8019,6 @@ luabind::scope lua_register_journal_mode() {
 		)];
 }
 
-
 luabind::scope lua_register_exp_source() {
 	return luabind::class_<ExpSource>("ExpSource")
 		.enum_("constants")

zone/lua_general.h

@@ -21,8 +21,10 @@ luabind::scope lua_register_rules_const();
 luabind::scope lua_register_rulei();
 luabind::scope lua_register_ruler();
 luabind::scope lua_register_ruleb();
+luabind::scope lua_register_rules();
 luabind::scope lua_register_journal_speakmode();
 luabind::scope lua_register_journal_mode();
+luabind::scope lua_register_exp_source();
 
 #endif
 #endif

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/lua_parser.cpp

@@ -42,6 +42,7 @@
 #include "lua_spawn.h"
 #include "lua_spell.h"
 #include "lua_stat_bonuses.h"
+#include "lua_database.h"
 
 const char *LuaEvents[_LargestEventID] = {
 	"event_say",
@@ -1312,11 +1313,14 @@ void LuaParser::MapFunctions(lua_State *L) {
 			lua_register_rulei(),
 			lua_register_ruler(),
 			lua_register_ruleb(),
+			lua_register_rules(),
 			lua_register_journal_speakmode(),
 			lua_register_journal_mode(),
 			lua_register_expedition(),
 			lua_register_expedition_lock_messages(),
-			lua_register_buff()
+			lua_register_buff(),
+			lua_register_exp_source(),
+			lua_register_database()
 		)];
 
 	} catch(std::exception &ex) {

zone/map.cpp

@@ -31,12 +31,14 @@ Map::~Map() {
 }
 
 float Map::FindBestZ(glm::vec3 &start, glm::vec3 *result) const {
-	if (!imp)
+	if (!imp) {
 		return BEST_Z_INVALID;
+	}
 
 	glm::vec3 tmp;
-	if(!result)
+	if (!result) {
 		result = &tmp;
+	}
 
 	start.z += RuleI(Map, FindBestZHeightAdjust);
 	glm::vec3 from(start.x, start.y, start.z);
@@ -45,16 +47,22 @@ float Map::FindBestZ(glm::vec3 &start, glm::vec3 *result) const {
 	bool hit = false;
 
 	hit = imp->rm->raycast((const RmReal*)&from, (const RmReal*)&to, (RmReal*)result, nullptr, &hit_distance);
-	if(hit) {
+	if (hit && zone->newzone_data.underworld != 0.0f && result->z < zone->newzone_data.underworld) {
+		hit = false;
+	}
+
+	if (hit) {
 		return result->z;
 	}
 
 	// Find nearest Z above us
-
 	to.z = -BEST_Z_INVALID;
 	hit = imp->rm->raycast((const RmReal*)&from, (const RmReal*)&to, (RmReal*)result, nullptr, &hit_distance);
-	if (hit)
-	{
+	if (zone->newzone_data.max_z != 0.0f && result->z > zone->newzone_data.max_z) {
+		hit = false;
+	}
+
+	if (hit) {
 		return result->z;
 	}
 

zone/mob.cpp

@@ -1266,8 +1266,6 @@ void Mob::CreateSpawnPacket(EQApplicationPacket* app, NewSpawn_Struct* ns) {
 	} else {
 		strcpy(ns2->spawn.lastName, ns->spawn.lastName);
 	}
-
-	memset(&app->pBuffer[sizeof(Spawn_Struct)-7], 0xFF, 7);
 }
 
 void Mob::FillSpawnStruct(NewSpawn_Struct* ns, Mob* ForWho)
@@ -2050,19 +2048,19 @@ void Mob::SendStatsWindow(Client* c, bool use_window)
 			case 0: {
 				mod2a_name = "Avoidance";
 				mod2b_name = "Combat Effects";
-				mod2a_cap  = Strings::Commify(RuleI(Character, ItemAvoidanceCap));
-				mod2b_cap  = Strings::Commify(RuleI(Character, ItemCombatEffectsCap));
+				mod2a_cap  = RuleI(Character, ItemAvoidanceCap);
+				mod2b_cap  = RuleI(Character, ItemCombatEffectsCap);
 
 				if (IsBot()) {
-					mod2a = Strings::Commify(CastToBot()->GetAvoidance());
+					mod2a = CastToBot()->GetAvoidance();
 				} else if (IsClient()) {
-					mod2a = Strings::Commify(CastToClient()->GetAvoidance());
+					mod2a = CastToClient()->GetAvoidance();
 				}
 
 				if (IsBot()) {
-					mod2b = Strings::Commify(CastToBot()->GetCombatEffects());
+					mod2b = CastToBot()->GetCombatEffects();
 				} else if (IsClient()) {
-					mod2b = Strings::Commify(CastToClient()->GetCombatEffects());
+					mod2b = CastToClient()->GetCombatEffects();
 				}
 
 				break;
@@ -2070,19 +2068,19 @@ void Mob::SendStatsWindow(Client* c, bool use_window)
 			case 1: {
 				mod2a_name = "Accuracy";
 				mod2b_name = "Strikethrough";
-				mod2a_cap  = Strings::Commify(RuleI(Character, ItemAccuracyCap));
-				mod2b_cap  = Strings::Commify(RuleI(Character, ItemStrikethroughCap));
+				mod2a_cap  = RuleI(Character, ItemAccuracyCap);
+				mod2b_cap  = RuleI(Character, ItemStrikethroughCap);
 
 				if (IsBot()) {
-					mod2a = Strings::Commify(CastToBot()->GetAccuracy());
+					mod2a = CastToBot()->GetAccuracy();
 				} else if (IsClient()) {
-					mod2a = Strings::Commify(CastToClient()->GetAccuracy());
+					mod2a = CastToClient()->GetAccuracy();
 				}
 
 				if (IsBot()) {
-					mod2b = Strings::Commify(CastToBot()->GetStrikeThrough());
+					mod2b = CastToBot()->GetStrikeThrough();
 				} else if (IsClient()) {
-					mod2b = Strings::Commify(CastToClient()->GetStrikeThrough());
+					mod2b = CastToClient()->GetStrikeThrough();
 				}
 
 				break;
@@ -2090,20 +2088,20 @@ void Mob::SendStatsWindow(Client* c, bool use_window)
 			case 2: {
 				mod2a_name = "Shielding";
 				mod2b_name = "Spell Shielding";
-				mod2a_cap  = Strings::Commify(RuleI(Character, ItemShieldingCap));
-				mod2b_cap  = Strings::Commify(RuleI(Character, ItemSpellShieldingCap));
+				mod2a_cap  = RuleI(Character, ItemShieldingCap);
+				mod2b_cap  = RuleI(Character, ItemSpellShieldingCap);
 
 				if (IsBot()) {
-					mod2a = Strings::Commify(CastToBot()->GetShielding());
+					mod2a = CastToBot()->GetShielding();
 				} else if (IsClient()) {
-					mod2a = Strings::Commify(CastToClient()->GetShielding());
+					mod2a = CastToClient()->GetShielding();
 				}
 
 
 				if (IsBot()) {
-					mod2b = Strings::Commify(CastToBot()->GetSpellShield());
+					mod2b = CastToBot()->GetSpellShield();
 				} else if (IsClient()) {
-					mod2b = Strings::Commify(CastToClient()->GetSpellShield());
+					mod2b = CastToClient()->GetSpellShield();
 				}
 
 				break;
@@ -2111,19 +2109,19 @@ void Mob::SendStatsWindow(Client* c, bool use_window)
 			case 3: {
 				mod2a_name = "Stun Resist";
 				mod2b_name = "DOT Shielding";
-				mod2a_cap  = Strings::Commify(RuleI(Character, ItemStunResistCap));
-				mod2b_cap  = Strings::Commify(RuleI(Character, ItemDoTShieldingCap));
+				mod2a_cap  = RuleI(Character, ItemStunResistCap);
+				mod2b_cap  = RuleI(Character, ItemDoTShieldingCap);
 
 				if (IsBot()) {
-					mod2a = Strings::Commify(CastToBot()->GetStunResist());
+					mod2a = CastToBot()->GetStunResist();
 				} else if (IsClient()) {
-					mod2a = Strings::Commify(CastToClient()->GetStunResist());
+					mod2a = CastToClient()->GetStunResist();
 				}
 
 				if (IsBot()) {
-					mod2b = Strings::Commify(CastToBot()->GetDoTShield());
+					mod2b = CastToBot()->GetDoTShield();
 				} else if (IsClient()) {
-					mod2b = Strings::Commify(CastToClient()->GetDoTShield());
+					mod2b = CastToClient()->GetDoTShield();
 				}
 
 				break;
@@ -8584,6 +8582,7 @@ bool Mob::HasBotAttackFlag(Mob* tar) {
 const uint16 scan_close_mobs_timer_moving = 6000; // 6 seconds
 const uint16 scan_close_mobs_timer_idle   = 60000; // 60 seconds
 
+// If the moving timer triggers, lets see if we are moving or idle to restart the appropriate dynamic timer
 void Mob::CheckScanCloseMobsMovingTimer()
 {
 	LogAIScanCloseDetail(
@@ -8593,31 +8592,20 @@ void Mob::CheckScanCloseMobsMovingTimer()
 		m_scan_close_mobs_timer.GetRemainingTime()
 	);
 
-	// If the moving timer triggers, lets see if we are moving or idle to restart the appropriate
-	// dynamic timer
-	if (m_mob_check_moving_timer.Check()) {
-		// If the mob is still moving, restart the moving timer
-		if (moving) {
-			if (m_scan_close_mobs_timer.GetRemainingTime() > scan_close_mobs_timer_moving) {
-				LogAIScanCloseDetail("Mob [{}] Restarting with moving timer", GetCleanName());
-				m_scan_close_mobs_timer.Disable();
-				m_scan_close_mobs_timer.Start(scan_close_mobs_timer_moving);
-				m_scan_close_mobs_timer.Trigger();
-			}
-		}
-		// If the mob is not moving, restart the idle timer
-		else if (m_scan_close_mobs_timer.GetDuration() == scan_close_mobs_timer_moving) {
-			LogAIScanCloseDetail("Mob [{}] Restarting with idle timer", GetCleanName());
+	// If the mob is still moving, restart the moving timer
+	if (moving) {
+		if (m_scan_close_mobs_timer.GetRemainingTime() > scan_close_mobs_timer_moving) {
+			LogAIScanCloseDetail("Mob [{}] Restarting with moving timer", GetCleanName());
 			m_scan_close_mobs_timer.Disable();
-			m_scan_close_mobs_timer.Start(scan_close_mobs_timer_idle);
+			m_scan_close_mobs_timer.Start(scan_close_mobs_timer_moving);
+			m_scan_close_mobs_timer.Trigger();
 		}
 	}
-}
-
-void Mob::ScanCloseMobProcess()
-{
-	if (m_scan_close_mobs_timer.Check()) {
-		entity_list.ScanCloseMobs(this);
+		// If the mob is not moving, restart the idle timer
+	else if (m_scan_close_mobs_timer.GetDuration() == scan_close_mobs_timer_moving) {
+		LogAIScanCloseDetail("Mob [{}] Restarting with idle timer", GetCleanName());
+		m_scan_close_mobs_timer.Disable();
+		m_scan_close_mobs_timer.Start(scan_close_mobs_timer_idle);
 	}
 }
 

zone/mob.h

@@ -1488,7 +1488,6 @@ public:
 
 	bool IsCloseToBanker();
 
-	void ScanCloseMobProcess();
 	std::unordered_map<uint16, Mob *> &GetCloseMobList(float distance = 0.0f);
 	void CheckScanCloseMobsMovingTimer();
 

zone/mob_ai.cpp

@@ -1815,12 +1815,18 @@ void Mob::AI_Event_NoLongerEngaged() {
 	StopNavigation();
 	ClearRampage();
 
-	parse->EventBotMercNPC(EVENT_COMBAT, this, nullptr, [&]() { return "0"; });
-
 	if (IsNPC()) {
 		SetPrimaryAggro(false);
 		SetAssistAggro(false);
-		if (CastToNPC()->GetCombatEvent() && GetHP() > 0) {
+		if (
+			CastToNPC()->GetCombatEvent() &&
+			GetHP() > 0 &&
+			entity_list.GetNPCByID(GetID())
+		) {
+			if (parse->HasQuestSub(GetNPCTypeID(), EVENT_COMBAT)) {
+				parse->EventNPC(EVENT_COMBAT, CastToNPC(), nullptr, "0", 0);
+			}
+
 			const uint32 emote_id = CastToNPC()->GetEmoteID();
 			if (emote_id) {
 				CastToNPC()->DoNPCEmote(EQ::constants::EmoteEventTypes::LeaveCombat, emote_id);
@@ -1829,6 +1835,8 @@ void Mob::AI_Event_NoLongerEngaged() {
 			m_combat_record.Stop();
 			CastToNPC()->SetCombatEvent(false);
 		}
+	} else {
+		parse->EventBotMerc(EVENT_COMBAT, this, nullptr, [&]() { return "0"; });
 	}
 }
 

zone/npc.cpp

@@ -601,8 +601,13 @@ bool NPC::Process()
 		DepopSwarmPets();
 	}
 
-	ScanCloseMobProcess();
-	CheckScanCloseMobsMovingTimer();
+	if (m_scan_close_mobs_timer.Check()) {
+		entity_list.ScanCloseMobs(this);
+	}
+
+	if (m_mob_check_moving_timer.Check()) {
+		CheckScanCloseMobsMovingTimer();
+	}
 
 	if (hp_regen_per_second > 0 && hp_regen_per_second_timer.Check()) {
 		if (GetHP() < GetMaxHP()) {
@@ -2151,6 +2156,7 @@ void NPC::FillSpawnStruct(NewSpawn_Struct* ns, Mob* ForWho)
 	UpdateActiveLight();
 	ns->spawn.light = GetActiveLightType();
 	ns->spawn.show_name = NPCTypedata->show_name;
+	ns->spawn.trader = false;
 }
 
 void NPC::PetOnSpawn(NewSpawn_Struct* ns)
@@ -3291,16 +3297,28 @@ uint32 NPC::GetSpawnKillCount()
 	return(0);
 }
 
-void NPC::DoQuestPause(Mob *other) {
-	if(IsMoving() && !IsOnHatelist(other)) {
-		PauseWandering(RuleI(NPC, SayPauseTimeInSec));
-		if (other && !other->sneaking)
-			FaceTarget(other);
-	} else if(!IsMoving()) {
-		if (other && !other->sneaking && GetAppearance() != eaSitting && GetAppearance() != eaDead)
-			FaceTarget(other);
+void NPC::DoQuestPause(Mob* m)
+{
+	if (!m) {
+		return;
 	}
 
+	if (IsMoving() && !IsOnHatelist(m)) {
+		PauseWandering(RuleI(NPC, SayPauseTimeInSec));
+
+		if (FacesTarget() && !m->sneaking) {
+			FaceTarget(m);
+		}
+	} else if (!IsMoving()) {
+		if (
+			FacesTarget() &&
+			!m->sneaking &&
+			GetAppearance() != eaSitting &&
+			GetAppearance() != eaDead
+		) {
+			FaceTarget(m);
+		}
+	}
 }
 
 void NPC::ChangeLastName(std::string last_name)
@@ -4232,3 +4250,17 @@ void NPC::DoNpcToNpcAggroScan()
 		false
 	);
 }
+
+bool NPC::FacesTarget()
+{
+	const std::string& excluded_races_rule = RuleS(NPC, ExcludedFaceTargetRaces);
+
+	if (excluded_races_rule.empty()) {
+		return true;
+	}
+
+	const auto& v = Strings::Split(excluded_races_rule, ",");
+
+	return std::find(v.begin(), v.end(), std::to_string(GetBaseRace())) == v.end();
+}
+

zone/npc.h

@@ -482,7 +482,8 @@ public:
 	NPC_Emote_Struct* GetNPCEmote(uint32 emote_id, uint8 event_);
 	void DoNPCEmote(uint8 event_, uint32 emote_id, Mob* t = nullptr);
 	bool CanTalk();
-	void DoQuestPause(Mob *other);
+	void DoQuestPause(Mob* m);
+	bool FacesTarget();
 
 	inline void SetSpellScale(float amt)		{ spellscale = amt; }
 	inline float GetSpellScale()				{ return spellscale; }

zone/parcels.cpp

@@ -278,6 +278,19 @@ void Client::DoParcelSend(const Parcel_Struct *parcel_in)
 		return;
 	}
 
+	if (parcel_in->money_flag && parcel_in->item_slot != INVALID_INDEX) {
+		Message(
+			Chat::Yellow,
+			fmt::format(
+				"{} tells you, 'I am confused!  Do you want to send money or an item?'",
+				merchant->GetCleanName()
+			).c_str()
+		);
+		DoParcelCancel();
+		SendParcelAck();
+		return;
+	}
+
 	auto num_of_parcels = GetParcelCount();
 	if (num_of_parcels >= RuleI(Parcel, ParcelMaxItems)) {
 		SendParcelIconStatus();
@@ -406,9 +419,8 @@ void Client::DoParcelSend(const Parcel_Struct *parcel_in)
 
 			std::vector<CharacterParcelsContainersRepository::CharacterParcelsContainers> all_entries{};
 			if (inst->IsNoneEmptyContainer()) {
-				CharacterParcelsContainersRepository::CharacterParcelsContainers cpc{};
-
 				for (auto const &kv: *inst->GetContents()) {
+					CharacterParcelsContainersRepository::CharacterParcelsContainers cpc{};
 					cpc.parcels_id = result.id;
 					cpc.slot_id    = kv.first;
 					cpc.item_id    = kv.second->GetID();

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/perl_database.cpp

@@ -0,0 +1,255 @@
+#include "../common/features.h"
+
+#ifdef EMBPERL_XS_CLASSES
+
+#include "embperl.h"
+#include "perl_database.h"
+#include "zonedb.h"
+
+// Perl takes ownership of returned objects allocated with new and deletes
+// them via the DESTROY method when the last perl reference goes out of scope
+
+void Perl_Database::Destroy(Perl_Database* ptr)
+{
+	delete ptr;
+}
+
+Perl_Database* Perl_Database::Connect()
+{
+	return new Perl_Database();
+}
+
+Perl_Database* Perl_Database::Connect(Connection type)
+{
+	return new Perl_Database(type);
+}
+
+Perl_Database* Perl_Database::Connect(Connection type, bool connect)
+{
+	return new Perl_Database(type, connect);
+}
+
+Perl_Database* Perl_Database::Connect(const char* host, const char* user, const char* pass, const char* db, uint32_t port)
+{
+	return new Perl_Database(host, user, pass, db, port);
+}
+
+Perl_MySQLPreparedStmt* Perl_Database::Prepare(std::string query)
+{
+	return m_db ? new Perl_MySQLPreparedStmt(m_db->Prepare(std::move(query))) : nullptr;
+}
+
+void Perl_Database::Close()
+{
+	m_db.reset();
+}
+
+// ---------------------------------------------------------------------------
+
+void Perl_MySQLPreparedStmt::Destroy(Perl_MySQLPreparedStmt* ptr)
+{
+	delete ptr;
+}
+
+void Perl_MySQLPreparedStmt::Close()
+{
+	m_stmt.reset();
+}
+
+void Perl_MySQLPreparedStmt::Execute()
+{
+	if (m_stmt)
+	{
+		m_res = m_stmt->Execute();
+	}
+}
+
+void Perl_MySQLPreparedStmt::Execute(perl::array args)
+{
+	// passes all script args as strings
+	if (m_stmt)
+	{
+		std::vector<mysql::PreparedStmt::param_t> inputs;
+		for (const perl::scalar& arg : args)
+		{
+			if (arg.is_null())
+			{
+				inputs.emplace_back(nullptr);
+			}
+			else
+			{
+				inputs.emplace_back(arg.c_str());
+			}
+		}
+		m_res = m_stmt->Execute(inputs);
+	}
+}
+
+void Perl_MySQLPreparedStmt::SetOptions(perl::hash hash)
+{
+	if (m_stmt)
+	{
+		mysql::StmtOptions opts = m_stmt->GetOptions();
+		if (hash.exists("buffer_results"))
+		{
+			opts.buffer_results = hash["buffer_results"].as<bool>();
+		}
+		if (hash.exists("use_max_length"))
+		{
+			opts.use_max_length = hash["use_max_length"].as<bool>();
+		}
+		m_stmt->SetOptions(opts);
+	}
+}
+
+static void PushValue(PerlInterpreter* my_perl, SV* sv, const mysql::StmtColumn& col)
+{
+	if (col.IsNull())
+	{
+		sv_setsv(sv, &PL_sv_undef);
+		return;
+	}
+
+	switch (col.Type())
+	{
+	case MYSQL_TYPE_TINY:
+	case MYSQL_TYPE_SHORT:
+	case MYSQL_TYPE_INT24:
+	case MYSQL_TYPE_LONG:
+	case MYSQL_TYPE_LONGLONG:
+	case MYSQL_TYPE_BIT:
+		if (col.IsUnsigned())
+		{
+			sv_setuv(sv, col.Get<UV>().value());
+		}
+		else
+		{
+			sv_setiv(sv, col.Get<IV>().value());
+		}
+		break;
+	case MYSQL_TYPE_FLOAT:
+	case MYSQL_TYPE_DOUBLE:
+		sv_setnv(sv, col.Get<NV>().value());
+		break;
+	case MYSQL_TYPE_TIME:
+	case MYSQL_TYPE_DATE:
+	case MYSQL_TYPE_DATETIME:
+	case MYSQL_TYPE_TIMESTAMP:
+		{
+			std::string str = col.GetStr().value();
+			sv_setpvn(sv, str.data(), str.size());
+		}
+		break;
+	default: // string types, push raw buffer to avoid copy
+		{
+			std::string_view str = col.GetStrView().value();
+			sv_setpvn(sv, str.data(), str.size());
+		}
+		break;
+	}
+}
+
+perl::array Perl_MySQLPreparedStmt::FetchArray()
+{
+	auto row = m_stmt ? m_stmt->Fetch() : mysql::StmtRow();
+	if (!row)
+	{
+		return perl::array();
+	}
+
+	// perf: bypass perlbind operator[]/push and use cache to limit SV allocs
+	dTHX;
+	AV* av = static_cast<AV*>(m_row_array);
+	for (const mysql::StmtColumn& col : row)
+	{
+		SV** sv = av_fetch(av, col.Index(), true);
+		PushValue(my_perl, *sv, col);
+	}
+
+	SvREFCNT_inc(av); // return a ref to our cache (no copy)
+	return perl::array(std::move(av));
+}
+
+perl::reference Perl_MySQLPreparedStmt::FetchArrayRef()
+{
+	perl::array array = FetchArray();
+	return array.size() == 0 ? perl::reference() : perl::reference(array);
+}
+
+perl::reference Perl_MySQLPreparedStmt::FetchHashRef()
+{
+	auto row = m_stmt ? m_stmt->Fetch() : mysql::StmtRow();
+	if (!row)
+	{
+		return perl::reference();
+	}
+
+	// perf: bypass perlbind operator[] and use cache to limit SV allocs
+	dTHX;
+	HV* hv = static_cast<HV*>(m_row_hash);
+	for (const mysql::StmtColumn& col : row)
+	{
+		SV** sv = hv_fetch(hv, col.Name().c_str(), static_cast<I32>(col.Name().size()), true);
+		PushValue(my_perl, *sv, col);
+	}
+
+	SvREFCNT_inc(hv); // return a ref to our cache (no copy)
+	return perl::reference(std::move(hv));
+}
+
+int Perl_MySQLPreparedStmt::ColumnCount()
+{
+	return m_res.ColumnCount();
+}
+
+uint64_t Perl_MySQLPreparedStmt::LastInsertID()
+{
+	return m_res.LastInsertID();
+}
+
+uint64_t Perl_MySQLPreparedStmt::RowCount()
+{
+	return m_res.RowCount();
+}
+
+uint64_t Perl_MySQLPreparedStmt::RowsAffected()
+{
+	return m_res.RowsAffected();
+}
+
+void perl_register_database()
+{
+	perl::interpreter perl(PERL_GET_THX);
+
+	{
+		auto package = perl.new_class<Perl_Database>("Database");
+		package.add_const("Default", static_cast<int>(QuestDB::Connection::Default));
+		package.add_const("Content", static_cast<int>(QuestDB::Connection::Content));
+		package.add("DESTROY", &Perl_Database::Destroy);
+		package.add("new", static_cast<Perl_Database*(*)()>(&Perl_Database::Connect));
+		package.add("new", static_cast<Perl_Database*(*)(QuestDB::Connection)>(&Perl_Database::Connect));
+		package.add("new", static_cast<Perl_Database*(*)(QuestDB::Connection, bool)>(&Perl_Database::Connect));
+		package.add("new", static_cast<Perl_Database*(*)(const char*, const char*, const char*, const char*, uint32_t)>(&Perl_Database::Connect));
+		package.add("close", &Perl_Database::Close);
+		package.add("prepare", &Perl_Database::Prepare);
+	}
+
+	{
+		auto package = perl.new_class<Perl_MySQLPreparedStmt>("MySQLPreparedStmt");
+		package.add("DESTROY", &Perl_MySQLPreparedStmt::Destroy);
+		package.add("close", &Perl_MySQLPreparedStmt::Close);
+		package.add("execute", static_cast<void(Perl_MySQLPreparedStmt::*)()>(&Perl_MySQLPreparedStmt::Execute));
+		package.add("execute", static_cast<void(Perl_MySQLPreparedStmt::*)(perl::array)>(&Perl_MySQLPreparedStmt::Execute));
+		package.add("fetch", &Perl_MySQLPreparedStmt::FetchArray);
+		package.add("fetch_array", &Perl_MySQLPreparedStmt::FetchArray);
+		package.add("fetch_arrayref", &Perl_MySQLPreparedStmt::FetchArrayRef);
+		package.add("fetch_hashref", &Perl_MySQLPreparedStmt::FetchHashRef);
+		package.add("insert_id", &Perl_MySQLPreparedStmt::LastInsertID);
+		package.add("num_fields", &Perl_MySQLPreparedStmt::ColumnCount);
+		package.add("num_rows", &Perl_MySQLPreparedStmt::RowCount);
+		package.add("rows_affected", &Perl_MySQLPreparedStmt::RowsAffected);
+		package.add("set_options", &Perl_MySQLPreparedStmt::SetOptions);
+	}
+}
+
+#endif // EMBPERL_XS_CLASSES

zone/perl_database.h

@@ -0,0 +1,50 @@
+#pragma once
+
+#include "quest_db.h"
+#include "../common/mysql_stmt.h"
+
+class Perl_MySQLPreparedStmt;
+
+class Perl_Database : public QuestDB
+{
+public:
+	using QuestDB::QuestDB;
+
+	static void Destroy(Perl_Database* ptr);
+	static Perl_Database* Connect();
+	static Perl_Database* Connect(Connection type);
+	static Perl_Database* Connect(Connection type, bool connect);
+	static Perl_Database* Connect(const char* host, const char* user, const char* pass, const char* db, uint32_t port);
+
+	void Close();
+	Perl_MySQLPreparedStmt* Prepare(std::string query);
+};
+
+class Perl_MySQLPreparedStmt
+{
+public:
+	Perl_MySQLPreparedStmt(mysql::PreparedStmt&& stmt)
+		: m_stmt(std::make_unique<mysql::PreparedStmt>(std::move(stmt))) {}
+
+	static void Destroy(Perl_MySQLPreparedStmt* ptr);
+
+	void Close();
+	void Execute();
+	void Execute(perl::array args);
+	void SetOptions(perl::hash hash_opts);
+	perl::array FetchArray();
+	perl::reference FetchArrayRef();
+	perl::reference FetchHashRef();
+
+	// StmtResult functions accessible through this class to simplify api
+	int ColumnCount();
+	uint64_t LastInsertID();
+	uint64_t RowCount();
+	uint64_t RowsAffected();
+
+private:
+	std::unique_ptr<mysql::PreparedStmt> m_stmt;
+	mysql::StmtResult m_res = {};
+	perl::array m_row_array; // perf: cache for fetches
+	perl::hash  m_row_hash;
+};

zone/quest_db.cpp

@@ -0,0 +1,57 @@
+#include "quest_db.h"
+#include "zonedb.h"
+#include "zone_config.h"
+
+// New connections avoid concurrency issues and allow use of unbuffered results
+// with prepared statements. Using zone connections w/o buffering would cause
+// "Commands out of sync" errors if any queries occur before results consumed.
+QuestDB::QuestDB(Connection type, bool connect)
+{
+	if (connect)
+	{
+		m_db = std::unique_ptr<Database, Deleter>(new Database(), Deleter(true));
+
+		const auto config = EQEmuConfig::get();
+
+		if (type == Connection::Default || type == Connection::Content && config->ContentDbHost.empty())
+		{
+			m_db->Connect(config->DatabaseHost, config->DatabaseUsername, config->DatabasePassword,
+				config->DatabaseDB, config->DatabasePort, "questdb");
+		}
+		else if (type == Connection::Content)
+		{
+			m_db->Connect(config->ContentDbHost, config->ContentDbUsername, config->ContentDbPassword,
+				config->ContentDbName, config->ContentDbPort, "questdb");
+		}
+	}
+	else if (type == Connection::Default)
+	{
+		m_db = std::unique_ptr<Database, Deleter>(&database, Deleter(false));
+	}
+	else if (type == Connection::Content)
+	{
+		m_db = std::unique_ptr<Database, Deleter>(&content_db, Deleter(false));
+	}
+
+	if (!m_db || (connect && m_db->GetStatus() != DBcore::Connected))
+	{
+		throw std::runtime_error(fmt::format("Failed to connect to db type [{}]", static_cast<int>(type)));
+	}
+}
+
+QuestDB::QuestDB(const char* host, const char* user, const char* pass, const char* db, uint32_t port)
+	: m_db(new Database(), Deleter(true))
+{
+	if (!m_db->Connect(host, user, pass, db, port, "questdb"))
+	{
+		throw std::runtime_error(fmt::format("Failed to connect to db [{}:{}]", host, port));
+	}
+}
+
+void QuestDB::Deleter::operator()(Database* ptr) noexcept
+{
+	if (owner)
+	{
+		delete ptr;
+	}
+};

zone/quest_db.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include <memory>
+
+class Database;
+
+// Base class for quest apis to manage connection to a MySQL database
+class QuestDB
+{
+public:
+	enum class Connection { Default = 0, Content };
+
+	// Throws std::runtime_error on connection failure
+	QuestDB() : QuestDB(Connection::Default) {}
+	QuestDB(Connection type) : QuestDB(type, false) {}
+	QuestDB(Connection type, bool connect);
+	QuestDB(const char* host, const char* user, const char* pass, const char* db, uint32_t port);
+
+protected:
+	// allow optional ownership of pointer to support using zone db connections
+	struct Deleter
+	{
+		Deleter() : owner(true) {}
+		Deleter(bool owner_) : owner(owner_) {}
+		bool owner = true;
+		void operator()(Database* ptr) noexcept;
+	};
+
+	std::unique_ptr<Database, Deleter> m_db;
+};

zone/questmgr.cpp

@@ -4611,179 +4611,7 @@ int8 QuestManager::DoesAugmentFit(EQ::ItemInstance* inst, uint32 augment_id, uin
 }
 
 void QuestManager::SendPlayerHandinEvent() {
-	QuestManagerCurrentQuestVars();
-	if (!owner || !owner->IsNPC() || !initiator) {
-		return;
-	}
-
-	if (
-		!initiator->EntityVariableExists("HANDIN_ITEMS") &&
-		!initiator->EntityVariableExists("HANDIN_MONEY") &&
-		!initiator->EntityVariableExists("RETURN_ITEMS") &&
-		!initiator->EntityVariableExists("RETURN_MONEY")
-	) {
-		return;
-	}
-
-	auto handin_items = initiator->GetEntityVariable("HANDIN_ITEMS");
-	auto return_items = initiator->GetEntityVariable("RETURN_ITEMS");
-	auto handin_money = initiator->GetEntityVariable("HANDIN_MONEY");
-	auto return_money = initiator->GetEntityVariable("RETURN_MONEY");
-
-	std::vector<PlayerEvent::HandinEntry> hi = {};
-	std::vector<PlayerEvent::HandinEntry> ri = {};
-	PlayerEvent::HandinMoney              hm{};
-	PlayerEvent::HandinMoney              rm{};
-
-	// Handin Items
-	if (!handin_items.empty()) {
-		if (Strings::Contains(handin_items, ",")) {
-			const auto handin_data = Strings::Split(handin_items, ",");
-			for (const auto &h: handin_data) {
-				const auto item_data = Strings::Split(h, "|");
-				if (
-					item_data.size() == 3 &&
-					Strings::IsNumber(item_data[0]) &&
-					Strings::IsNumber(item_data[1]) &&
-					Strings::IsNumber(item_data[2])
-					) {
-					const auto item_id = static_cast<uint32>(Strings::ToUnsignedInt(item_data[0]));
-					if (item_id != 0) {
-						const auto *item = database.GetItem(item_id);
-
-						if (item) {
-							hi.emplace_back(
-								PlayerEvent::HandinEntry{
-									.item_id = item_id,
-									.item_name = item->Name,
-									.charges = static_cast<uint16>(Strings::ToUnsignedInt(item_data[1])),
-									.attuned = Strings::ToInt(item_data[2]) ? true : false
-								}
-							);
-						}
-					}
-				}
-			}
-		}
-		else if (Strings::Contains(handin_items, "|")) {
-			const auto item_data = Strings::Split(handin_items, "|");
-			if (
-				item_data.size() == 3 &&
-				Strings::IsNumber(item_data[0]) &&
-				Strings::IsNumber(item_data[1]) &&
-				Strings::IsNumber(item_data[2])
-				) {
-				const auto item_id = static_cast<uint32>(Strings::ToUnsignedInt(item_data[0]));
-				const auto *item = database.GetItem(item_id);
-
-				if (item) {
-					hi.emplace_back(
-						PlayerEvent::HandinEntry{
-							.item_id = item_id,
-							.item_name = item->Name,
-							.charges = static_cast<uint16>(Strings::ToUnsignedInt(item_data[1])),
-							.attuned = Strings::ToInt(item_data[2]) ? true : false
-						}
-					);
-				}
-			}
-		}
-	}
-
-	// Handin Money
-	if (!handin_money.empty()) {
-		const auto hms = Strings::Split(handin_money, "|");
-		hm.copper   = static_cast<uint32>(Strings::ToUnsignedInt(hms[0]));
-		hm.silver   = static_cast<uint32>(Strings::ToUnsignedInt(hms[1]));
-		hm.gold     = static_cast<uint32>(Strings::ToUnsignedInt(hms[2]));
-		hm.platinum = static_cast<uint32>(Strings::ToUnsignedInt(hms[3]));
-	}
-
-	// Return Items
-	if (!return_items.empty()) {
-		if (Strings::Contains(return_items, ",")) {
-			const auto return_data = Strings::Split(return_items, ",");
-			for (const auto &r: return_data) {
-				const auto item_data = Strings::Split(r, "|");
-				if (
-					item_data.size() == 3 &&
-					Strings::IsNumber(item_data[0]) &&
-					Strings::IsNumber(item_data[1]) &&
-					Strings::IsNumber(item_data[2])
-					) {
-					const auto item_id = static_cast<uint32>(Strings::ToUnsignedInt(item_data[0]));
-					const auto *item   = database.GetItem(item_id);
-
-					if (item) {
-						ri.emplace_back(
-							PlayerEvent::HandinEntry{
-								.item_id = item_id,
-								.item_name = item->Name,
-								.charges = static_cast<uint16>(Strings::ToUnsignedInt(item_data[1])),
-								.attuned = Strings::ToInt(item_data[2]) ? true : false
-							}
-						);
-					}
-				}
-			}
-		}
-		else if (Strings::Contains(return_items, "|")) {
-			const auto item_data = Strings::Split(return_items, "|");
-			if (
-				item_data.size() == 3 &&
-				Strings::IsNumber(item_data[0]) &&
-				Strings::IsNumber(item_data[1]) &&
-				Strings::IsNumber(item_data[2])
-				) {
-				const auto item_id = static_cast<uint32>(Strings::ToUnsignedInt(item_data[0]));
-				const auto *item   = database.GetItem(item_id);
-
-				if (item) {
-					ri.emplace_back(
-						PlayerEvent::HandinEntry{
-							.item_id = item_id,
-							.item_name = item->Name,
-							.charges = static_cast<uint16>(Strings::ToUnsignedInt(item_data[1])),
-							.attuned = Strings::ToInt(item_data[2]) ? true : false
-						}
-					);
-				}
-			}
-		}
-	}
-
-	// Return Money
-	if (!return_money.empty()) {
-		const auto rms = Strings::Split(return_money, "|");
-		rm.copper   = static_cast<uint32>(Strings::ToUnsignedInt(rms[0]));
-		rm.silver   = static_cast<uint32>(Strings::ToUnsignedInt(rms[1]));
-		rm.gold     = static_cast<uint32>(Strings::ToUnsignedInt(rms[2]));
-		rm.platinum = static_cast<uint32>(Strings::ToUnsignedInt(rms[3]));
-	}
-
-	initiator->DeleteEntityVariable("HANDIN_ITEMS");
-	initiator->DeleteEntityVariable("HANDIN_MONEY");
-	initiator->DeleteEntityVariable("RETURN_ITEMS");
-	initiator->DeleteEntityVariable("RETURN_MONEY");
-
-	bool handed_in_money = hm.platinum > 0 || hm.gold > 0 || hm.silver > 0 || hm.copper > 0;
-
-	bool event_has_data_to_record = (
-		!hi.empty() || handed_in_money
-	);
-
-	if (player_event_logs.IsEventEnabled(PlayerEvent::NPC_HANDIN) && event_has_data_to_record) {
-		auto e = PlayerEvent::HandinEvent{
-			.npc_id = owner->CastToNPC()->GetNPCTypeID(),
-			.npc_name = owner->GetCleanName(),
-			.handin_items = hi,
-			.handin_money = hm,
-			.return_items = ri,
-			.return_money = rm
-		};
-
-		RecordPlayerEventLogWithClient(initiator, PlayerEvent::NPC_HANDIN, e);
-	}
+	return;
 }
 
 std::string QuestManager::GetAutoLoginCharacterNameByAccountID(uint32 account_id)
@@ -4795,3 +4623,78 @@ bool QuestManager::SetAutoLoginCharacterNameByAccountID(uint32 account_id, const
 {
 	return AccountRepository::SetAutoLoginCharacterNameByAccountID(database, account_id, character_name);
 }
+
+void QuestManager::SpawnCircle(uint32 npc_id, glm::vec4 position, float radius, uint32 points)
+{
+	const NPCType* t = content_db.LoadNPCTypesData(npc_id);
+	if (!t) {
+		return;
+	}
+
+	glm::vec4 npc_position = position;
+
+	for (uint32 i = 0; i < points; i++) {
+		float angle = 2 * M_PI * i / points;
+
+		npc_position.x = position.x + radius * std::cos(angle);
+		npc_position.y = position.y + radius * std::sin(angle);
+
+		NPC* n = new NPC(t, nullptr, npc_position, GravityBehavior::Water);
+
+		n->FixZ();
+
+		n->AddLootTable();
+
+		if (n->DropsGlobalLoot()) {
+			n->CheckGlobalLootTables();
+		}
+
+		entity_list.AddNPC(n, true, true);
+	}
+}
+
+void QuestManager::SpawnGrid(uint32 npc_id, glm::vec4 position, float spacing, uint32 spawn_count)
+{
+	const NPCType* t = content_db.LoadNPCTypesData(npc_id);
+	if (!t) {
+		return;
+	}
+
+	glm::vec4 npc_position = position;
+
+	uint32 columns = std::ceil(std::sqrt(spawn_count));
+	uint32 rows    = std::ceil(spawn_count / columns);
+
+	float total_width  = ((columns - 1) * spacing);
+	float total_height = ((rows - 1) * spacing);
+
+	float start_x = position.x - total_width / 2;
+	float start_y = position.y - total_height / 2;
+
+	uint32 spawned = 0;
+
+	for (uint32 row = 0; row < rows; row++) {
+		for (uint32 column = 0; column < columns; column++) {
+			if (spawned >= spawn_count) {
+				break;
+			}
+
+			npc_position.x = start_x + column * spacing;
+			npc_position.y = start_y + row * spacing;
+
+			NPC* n = new NPC(t, nullptr, npc_position, GravityBehavior::Water);
+
+			n->FixZ();
+
+			n->AddLootTable();
+
+			if (n->DropsGlobalLoot()) {
+				n->CheckGlobalLootTables();
+			}
+
+			entity_list.AddNPC(n, true, true);
+
+			spawned++;
+		}
+	}
+}

zone/questmgr.h

@@ -357,6 +357,8 @@ public:
 	void SendChannelMessage(Client* from, const char* to, uint8 channel_number, uint32 guild_id, uint8 language_id, uint8 language_skill, const char* message);
 	std::string GetAutoLoginCharacterNameByAccountID(uint32 account_id);
 	bool SetAutoLoginCharacterNameByAccountID(uint32 account_id, const std::string& character_name);
+	void SpawnCircle(uint32 npc_id, glm::vec4 position, float radius, uint32 points);
+	void SpawnGrid(uint32 npc_id, glm::vec4 position, float spacing, uint32 spawn_count);
 
 	Bot *GetBot() const;
 	Client *GetInitiator() const;

zone/spell_effects.cpp

@@ -2416,16 +2416,18 @@ bool Mob::SpellEffect(Mob* caster, uint16 spell_id, float partial, int level_ove
 					break;
 				}
 
+				int16 focus = RuleB(Spells, AllowFocusOnSkillDamageSpells) ? caster->GetMeleeDamageMod_SE(spells[spell_id].skill) : 0;
+
 				switch(spells[spell_id].skill) {
-				case EQ::skills::SkillThrowing:
-					caster->DoThrowingAttackDmg(this, nullptr, nullptr, spells[spell_id].base_value[i],spells[spell_id].limit_value[i], 0, ReuseTime, 0, 0, 4.0f, true);
-					break;
-				case EQ::skills::SkillArchery:
-					caster->DoArcheryAttackDmg(this, nullptr, nullptr, spells[spell_id].base_value[i],spells[spell_id].limit_value[i], 0, ReuseTime, 0, 0, nullptr, 0, 4.0f, true);
-					break;
-				default:
-					caster->DoMeleeSkillAttackDmg(this, spells[spell_id].base_value[i], spells[spell_id].skill, spells[spell_id].limit_value[i], 0, false, ReuseTime);
-					break;
+					case EQ::skills::SkillThrowing:
+						caster->DoThrowingAttackDmg(this, nullptr, nullptr, spells[spell_id].base_value[i],spells[spell_id].limit_value[i], focus, ReuseTime, 0, 0, 4.0f, true);
+						break;
+					case EQ::skills::SkillArchery:
+						caster->DoArcheryAttackDmg(this, nullptr, nullptr, spells[spell_id].base_value[i],spells[spell_id].limit_value[i], focus, ReuseTime, 0, 0, nullptr, 0, 4.0f, true);
+						break;
+					default:
+						caster->DoMeleeSkillAttackDmg(this, spells[spell_id].base_value[i], spells[spell_id].skill, spells[spell_id].limit_value[i], focus, false, ReuseTime);
+						break;
 				}
 				break;
 			}

zone/trading.cpp

@@ -664,6 +664,8 @@ void Client::FinishTrade(Mob* tradingWith, bool finalizer, void* event_entry, st
 		}
 	}
 	else if(tradingWith && tradingWith->IsNPC()) {
+		NPCHandinEventLog(trade, tradingWith->CastToNPC());
+
 		QSPlayerLogHandin_Struct* qs_audit = nullptr;
 		bool qs_log = false;
 
@@ -775,6 +777,8 @@ void Client::FinishTrade(Mob* tradingWith, bool finalizer, void* event_entry, st
 				tradingWith->SayString(TRADE_BACK, GetCleanName());
 				PushItemOnCursor(*inst, true);
 			}
+
+			items.clear();
 		}
 		// Only enforce trade rules if the NPC doesn't have an EVENT_TRADE
 		// subroutine.  That overrides all.
@@ -832,13 +836,13 @@ void Client::FinishTrade(Mob* tradingWith, bool finalizer, void* event_entry, st
 										);
 									}
 
-									auto loot_drop_entry = LootdropEntriesRepository::NewNpcEntity();
-									loot_drop_entry.equip_item = 1;
-									loot_drop_entry.item_charges = static_cast<int8>(baginst->GetCharges());
+									auto lde = LootdropEntriesRepository::NewNpcEntity();
+									lde.equip_item   = 1;
+									lde.item_charges = static_cast<int8>(baginst->GetCharges());
 
 									tradingWith->CastToNPC()->AddLootDrop(
 										bagitem,
-										loot_drop_entry,
+										lde,
 										true
 									);
 									// Return quest items being traded to non-quest NPC when the rule is true
@@ -857,17 +861,17 @@ void Client::FinishTrade(Mob* tradingWith, bool finalizer, void* event_entry, st
 								}
 							}
 						}
+					} else {
+						auto lde = LootdropEntriesRepository::NewNpcEntity();
+						lde.equip_item   = 1;
+						lde.item_charges = static_cast<int8>(inst->GetCharges());
+
+						tradingWith->CastToNPC()->AddLootDrop(
+							item,
+							lde,
+							true
+						);
 					}
-
-					auto new_loot_drop_entry = LootdropEntriesRepository::NewNpcEntity();
-					new_loot_drop_entry.equip_item = 1;
-					new_loot_drop_entry.item_charges = static_cast<int8>(inst->GetCharges());
-
-					tradingWith->CastToNPC()->AddLootDrop(
-						item,
-						new_loot_drop_entry,
-						true
-					);
 				}
 				// Return quest items being traded to non-quest NPC when the rule is true
 				else if (restrict_quest_items_to_quest_npc && (!is_quest_npc && item->IsQuestItem())) {
@@ -2382,7 +2386,7 @@ void Client::ShowBuyLines(const EQApplicationPacket *app)
 			ss.str("");
 			ss.clear();
 		}
-		
+
 		return;
 	}
 }
@@ -2604,6 +2608,7 @@ void Client::SellToBuyer(const EQApplicationPacket *app)
 				data->zone_id          = GetZoneID();
 				data->slot             = sell_line.slot;
 				data->seller_quantity  = sell_line.seller_quantity;
+				data->purchase_method  = sell_line.purchase_method;
 				strn0cpy(data->item_name, sell_line.item_name, sizeof(data->item_name));
 				strn0cpy(data->buyer_name, sell_line.buyer_name.c_str(), sizeof(data->buyer_name));
 				strn0cpy(data->seller_name, GetCleanName(), sizeof(data->seller_name));
@@ -2910,10 +2915,11 @@ void Client::SendBecomeTraderToWorld(Client *trader, BazaarTraderBarterActions a
 	auto outapp = new ServerPacket(ServerOP_TraderMessaging, sizeof(TraderMessaging_Struct));
 	auto data   = (TraderMessaging_Struct *) outapp->pBuffer;
 
-	data->action    = action;
-	data->entity_id = trader->GetID();
-	data->trader_id = trader->CharacterID();
-	data->zone_id   = trader->GetZoneID();
+	data->action      = action;
+	data->entity_id   = trader->GetID();
+	data->trader_id   = trader->CharacterID();
+	data->zone_id     = trader->GetZoneID();
+	data->instance_id = trader->GetInstanceID();
 	strn0cpy(data->trader_name, trader->GetName(), sizeof(data->trader_name));
 
 	worldserver.SendPacket(outapp);
@@ -3232,7 +3238,10 @@ void Client::SendBulkBazaarTraders()
 
 void Client::DoBazaarInspect(const BazaarInspect_Struct &in)
 {
-	auto items = TraderRepository::GetWhere(database, fmt::format("item_sn = {}", in.serial_number));
+	auto items = TraderRepository::GetWhere(
+		database, fmt::format("`char_id` = '{}' AND `item_sn` = '{}'", in.trader_id, in.serial_number)
+	);
+
 	if (items.empty()) {
 		LogInfo("Failed to find item with serial number [{}]", in.serial_number);
 		return;
@@ -3301,7 +3310,7 @@ std::string Client::DetermineMoneyString(uint64 cp)
 void Client::BuyTraderItemOutsideBazaar(TraderBuy_Struct *tbs, const EQApplicationPacket *app)
 {
 	auto in          = (TraderBuy_Struct *) app->pBuffer;
-	auto trader_item = TraderRepository::GetItemBySerialNumber(database, tbs->serial_number);
+	auto trader_item = TraderRepository::GetItemBySerialNumber(database, tbs->serial_number, tbs->trader_id);
 	if (!trader_item.id) {
 		LogTrading("Attempt to purchase an item outside of the Bazaar trader_id <red>[{}] item serial_number "
 				   "<red>[{}] The Traders data was outdated.",
@@ -3495,7 +3504,7 @@ void Client::BuyTraderItemOutsideBazaar(TraderBuy_Struct *tbs, const EQApplicati
 	ps.item_slot = parcel_out.slot_id;
 	strn0cpy(ps.send_to, GetCleanName(), sizeof(ps.send_to));
 
-	if (trader_item.item_charges <= static_cast<int32>(tbs->quantity)) {
+	if (trader_item.item_charges <= static_cast<int32>(tbs->quantity) || !buy_item->IsStackable()) {
 		TraderRepository::DeleteOne(database, trader_item.id);
 	} else {
 		TraderRepository::UpdateQuantity(
@@ -4250,6 +4259,14 @@ bool Client::DoBarterSellerChecks(BuyerLineSellItem_Struct &sell_line)
 		Message(Chat::Red, "The item that you are trying to sell is augmented. Please remove augments first");
 	}
 
+	if (sell_item && !sell_item->IsDroppable()) {
+		seller_error = true;
+		LogTradingDetail("Seller item <red>[{}] is non-tradeable therefore cannot be sold.",
+						 sell_line.item_name
+		);
+		Message(Chat::Red, "The item that you are trying to sell is non-tradeable and therefore cannot be sold.");
+	}
+
 	if (seller_error) {
 		LogTradingDetail("Seller Error <red>[{}]  Barter Sell/Buy Transaction Failed.", seller_error);
 		SendBarterBuyerClientMessage(sell_line, Barter_SellerTransactionComplete, Barter_Failure, Barter_Failure);
@@ -4257,4 +4274,4 @@ bool Client::DoBarterSellerChecks(BuyerLineSellItem_Struct &sell_line)
 	}
 
 	return true;
-}
+}

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()) {
@@ -3942,7 +3951,7 @@ void WorldServer::HandleMessage(uint16 opcode, const EQ::Net::Packet &p)
 					c.second->QueuePacket(outapp);
 					safe_delete(outapp);
 				}
-				if (zone && zone->GetZoneID() == Zones::BAZAAR) {
+				if (zone && zone->GetZoneID() == Zones::BAZAAR && in->instance_id == zone->GetInstanceID()) {
 					if (in->action == TraderOn) {
 						c.second->SendBecomeTrader(TraderOn, in->entity_id);
 					}
@@ -4044,6 +4053,7 @@ void WorldServer::HandleMessage(uint16 opcode, const EQ::Net::Packet &p)
 					sell_line.buyer_name      = in->buyer_name;
 					sell_line.seller_quantity = in->seller_quantity;
 					sell_line.slot            = in->slot;
+					sell_line.purchase_method = in->purchase_method;
 					strn0cpy(sell_line.item_name, in->item_name, sizeof(sell_line.item_name));
 
 					uint64 total_cost = (uint64) sell_line.item_cost * (uint64) sell_line.seller_quantity;

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(
@@ -3472,6 +3480,9 @@ bool ZoneDatabase::LoadFactionData()
 	}
 
     auto& fmr_row = faction_max_results.begin();
+	if (fmr_row[0] == nullptr) {
+		return false;
+	}
 
 	max_faction = Strings::ToUnsignedInt(fmr_row[0]);
 	faction_array = new Faction *[max_faction + 1];

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

zone/zoning.cpp

@@ -737,7 +737,7 @@ void Client::ProcessMovePC(uint32 zoneID, uint32 instance_id, float x, float y,
 			ZonePC(zoneID, instance_id, x, y, z, heading, ignorerestrictions, zm);
 			break;
 		default:
-			LogError("Client::ProcessMovePC received a reguest to perform an unsupported client zone operation");
+			LogError("Received a request to perform an unsupported client zone operation");
 			break;
 	}
 }