Add slot ID conversions

Resolves
- Parcels being delivered with incorrect item
- Inspecting an item from the bazaar window showing the incorrect item

CHANGELOG.md

@@ -1,3 +1,123 @@
+## [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,92 @@ 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);
+)"
+	},
+	ManifestEntry{
+		.version = 9286,
+		.description = "2024_10_24_sharedbank_guid_primary_key.sql",
+		.check = "SHOW COLUMN FROM `sharedbank` LIKE 'guid'",
+		.condition = "empty",
+		.match = "",
+		.sql = R"(
+ALTER TABLE `sharedbank`
+CHANGE COLUMN `acctid` `account_id` int(11) UNSIGNED NOT NULL DEFAULT 0 FIRST,
+CHANGE COLUMN `slotid` `slot_id` mediumint(7) UNSIGNED NOT NULL DEFAULT 0 AFTER `account_id`,
+CHANGE COLUMN `itemid` `item_id` int(11) UNSIGNED NOT NULL DEFAULT 0 AFTER `slot_id`,
+CHANGE COLUMN `augslot1` `augment_one` mediumint(7) UNSIGNED NOT NULL DEFAULT 0 AFTER `charges`,
+CHANGE COLUMN `augslot2` `augment_two` mediumint(7) UNSIGNED NOT NULL DEFAULT 0 AFTER `augment_one`,
+CHANGE COLUMN `augslot3` `augment_three` mediumint(7) UNSIGNED NOT NULL DEFAULT 0 AFTER `augment_two`,
+CHANGE COLUMN `augslot4` `augment_four` mediumint(7) UNSIGNED NOT NULL DEFAULT 0 AFTER `augment_three`,
+CHANGE COLUMN `augslot5` `augment_five` mediumint(7) UNSIGNED NOT NULL DEFAULT 0 AFTER `augment_four`,
+CHANGE COLUMN `augslot6` `augment_six` mediumint(7) UNSIGNED NOT NULL DEFAULT 0 AFTER `augment_five`,
+MODIFY COLUMN `charges` smallint(3) UNSIGNED NOT NULL DEFAULT 0 AFTER `item_id`,
+ADD COLUMN `color` int(11) UNSIGNED NOT NULL DEFAULT 0 AFTER `charges`,
+ADD COLUMN `ornament_icon` int(11) UNSIGNED NOT NULL AFTER `custom_data`,
+ADD COLUMN `ornament_idfile` int(11) UNSIGNED NOT NULL AFTER `ornament_icon`,
+ADD COLUMN `ornament_hero_model` int(11) NOT NULL AFTER `ornament_idfile`,
+ADD COLUMN `guid` bigint(20) UNSIGNED NOT NULL DEFAULT 0 AFTER `ornament_hero_model`,
+ADD PRIMARY KEY (`account_id`, `slot_id`);
+)"
+	},
+	ManifestEntry{
+		.version = 9287,
+		.description = "2024_10_24_inventory_changes.sql",
+		.check = "SHOW COLUMN FROM `inventory` LIKE 'charid'",
+		.condition = "empty",
+		.match = "",
+		.sql = R"(
+ALTER TABLE `inventory`
+CHANGE COLUMN `charid` `character_id` int(11) UNSIGNED NOT NULL DEFAULT 0 FIRST,
+CHANGE COLUMN `slotid` `slot_id` mediumint(7) UNSIGNED NOT NULL DEFAULT 0 AFTER `character_id`,
+CHANGE COLUMN `itemid` `item_id` int(11) UNSIGNED NULL DEFAULT 0 AFTER `slot_id`,
+CHANGE COLUMN `augslot1` `augment_one` mediumint(7) UNSIGNED NOT NULL DEFAULT 0 AFTER `color`,
+CHANGE COLUMN `augslot2` `augment_two` mediumint(7) UNSIGNED NOT NULL DEFAULT 0 AFTER `augment_one`,
+CHANGE COLUMN `augslot3` `augment_three` mediumint(7) UNSIGNED NOT NULL DEFAULT 0 AFTER `augment_two`,
+CHANGE COLUMN `augslot4` `augment_four` mediumint(7) UNSIGNED NOT NULL DEFAULT 0 AFTER `augment_three`,
+CHANGE COLUMN `augslot5` `augment_five` mediumint(7) UNSIGNED NOT NULL DEFAULT 0 AFTER `augment_four`,
+CHANGE COLUMN `augslot6` `augment_six` mediumint(7) UNSIGNED NOT NULL DEFAULT 0 AFTER `augment_five`,
+CHANGE COLUMN `ornamenticon` `ornament_icon` int(11) UNSIGNED NOT NULL DEFAULT 0 AFTER `custom_data`,
+CHANGE COLUMN `ornamentidfile` `ornament_idfile` int(11) UNSIGNED NOT NULL DEFAULT 0 AFTER `ornament_icon`,
+DROP PRIMARY KEY,
+ADD PRIMARY KEY (`character_id`, `slot_id`) USING BTREE;
+
+UPDATE `inventory` SET `slot_id` = ((`slot_id` - 251) + 4010) WHERE `slot_id` BETWEEN 251 AND 260; -- Bag 1
+UPDATE `inventory` SET `slot_id` = ((`slot_id` - 261) + 4210) WHERE `slot_id` BETWEEN 261 AND 270; -- Bag 2
+UPDATE `inventory` SET `slot_id` = ((`slot_id` - 271) + 4410) WHERE `slot_id` BETWEEN 271 AND 280; -- Bag 3
+UPDATE `inventory` SET `slot_id` = ((`slot_id` - 281) + 4610) WHERE `slot_id` BETWEEN 281 AND 290; -- Bag 4
+UPDATE `inventory` SET `slot_id` = ((`slot_id` - 291) + 4810) WHERE `slot_id` BETWEEN 291 AND 300; -- Bag 5
+UPDATE `inventory` SET `slot_id` = ((`slot_id` - 301) + 5010) WHERE `slot_id` BETWEEN 301 AND 310; -- Bag 6
+UPDATE `inventory` SET `slot_id` = ((`slot_id` - 311) + 5210) WHERE `slot_id` BETWEEN 311 AND 320; -- Bag 7
+UPDATE `inventory` SET `slot_id` = ((`slot_id` - 321) + 5410) WHERE `slot_id` BETWEEN 321 AND 330; -- Bag 8
+UPDATE `inventory` SET `slot_id` = ((`slot_id` - 331) + 5610) WHERE `slot_id` BETWEEN 331 AND 340; -- Bag 9
+UPDATE `inventory` SET `slot_id` = ((`slot_id` - 341) + 5810) WHERE `slot_id` BETWEEN 341 AND 350; -- Bag 10
+UPDATE `inventory` SET `slot_id` = ((`slot_id` - 351) + 6010) WHERE `slot_id` BETWEEN 351 AND 360; -- Cursor Bag
+UPDATE `inventory` SET `slot_id` = ((`slot_id` - 2031) + 6210) WHERE `slot_id` BETWEEN 2031 AND 2270; -- Bank Bags
+UPDATE `inventory` SET `slot_id` = ((`slot_id` - 2531) + 11010) WHERE `slot_id` BETWEEN 2531 AND 2550; -- Shared Bank Bags
+)"
+	},
+	ManifestEntry{
+		.version = 9288,
+		.description = "2024_10_24_merchantlist_temp_uncap.sql",
+		.check = "SHOW CREATE TABLE `merchantlist_temp`",
+		.condition = "contains",
+		.match = "`slot` tinyint(3)",
+		.sql = R"(
+ALTER TABLE `merchantlist_temp`
+MODIFY COLUMN `slot` int UNSIGNED NOT NULL DEFAULT 0 AFTER `npcid`;
 )"
 	}
 // -- 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_constants.h

@@ -132,7 +132,7 @@ namespace EQ
 		using RoF2::invtype::KRONO_SIZE;
 		using RoF2::invtype::OTHER_SIZE;
 
-		using Titanium::invtype::TRADE_NPC_SIZE;
+		using RoF2::invtype::TRADE_NPC_SIZE;
 
 		using RoF2::invtype::TYPE_INVALID;
 		using RoF2::invtype::TYPE_BEGIN;
@@ -159,7 +159,7 @@ namespace EQ
 		using RoF2::invslot::SLOT_INVALID;
 		using RoF2::invslot::SLOT_BEGIN;
 
-		using Titanium::invslot::SLOT_TRADESKILL_EXPERIMENT_COMBINE;
+		using RoF2::invslot::SLOT_TRADESKILL_EXPERIMENT_COMBINE;
 
 		const int16 SLOT_AUGMENT_GENERIC_RETURN = 1001; // clients don't appear to use this method... (internal inventory return value)
 
@@ -179,28 +179,28 @@ namespace EQ
 		using RoF2::invslot::BONUS_STAT_END;
 		using RoF2::invslot::BONUS_SKILL_END;
 
-		using Titanium::invslot::BANK_BEGIN;
-		using SoF::invslot::BANK_END;
+		using RoF2::invslot::BANK_BEGIN;
+		using RoF2::invslot::BANK_END;
 
-		using Titanium::invslot::SHARED_BANK_BEGIN;
-		using Titanium::invslot::SHARED_BANK_END;
+		using RoF2::invslot::SHARED_BANK_BEGIN;
+		using RoF2::invslot::SHARED_BANK_END;
 
-		using Titanium::invslot::TRADE_BEGIN;
-		using Titanium::invslot::TRADE_END;
+		using RoF2::invslot::TRADE_BEGIN;
+		using RoF2::invslot::TRADE_END;
 
-		using Titanium::invslot::TRADE_NPC_END;
+		using RoF2::invslot::TRADE_NPC_END;
 
-		using Titanium::invslot::WORLD_BEGIN;
-		using Titanium::invslot::WORLD_END;
+		using RoF2::invslot::WORLD_BEGIN;
+		using RoF2::invslot::WORLD_END;
 
-		using Titanium::invslot::TRIBUTE_BEGIN;
-		using Titanium::invslot::TRIBUTE_END;
+		using RoF2::invslot::TRIBUTE_BEGIN;
+		using RoF2::invslot::TRIBUTE_END;
 
-		using Titanium::invslot::GUILD_TRIBUTE_BEGIN;
-		using Titanium::invslot::GUILD_TRIBUTE_END;
+		using RoF2::invslot::GUILD_TRIBUTE_BEGIN;
+		using RoF2::invslot::GUILD_TRIBUTE_END;
 
 		const int16 CORPSE_BEGIN = invslot::slotGeneral1;
-		const int16 CORPSE_END = CORPSE_BEGIN + invslot::slotCursor;
+		const int16 CORPSE_END   = CORPSE_BEGIN + invslot::slotCursor;
 
 		using RoF2::invslot::EQUIPMENT_BITMASK;
 		using RoF2::invslot::GENERAL_BITMASK;
@@ -214,38 +214,40 @@ namespace EQ
 	} // namespace invslot
 
 	namespace invbag {
-		using Titanium::invbag::SLOT_INVALID;
-		using Titanium::invbag::SLOT_BEGIN;
-		using Titanium::invbag::SLOT_END;
-		using Titanium::invbag::SLOT_COUNT;
+		using RoF2::invbag::SLOT_INVALID;
+		using RoF2::invbag::SLOT_BEGIN;
+		using RoF2::invbag::SLOT_END;
+		using RoF2::invbag::SLOT_COUNT;
 
-		using Titanium::invbag::GENERAL_BAGS_BEGIN;
+		using RoF2::invslot::WORLD_END;
+
+		const int16 GENERAL_BAGS_BEGIN = WORLD_END + 1;
 		const int16 GENERAL_BAGS_COUNT = invslot::GENERAL_COUNT * SLOT_COUNT;
-		const int16 GENERAL_BAGS_END = (GENERAL_BAGS_BEGIN + GENERAL_BAGS_COUNT) - 1;
+		const int16 GENERAL_BAGS_END   = (GENERAL_BAGS_BEGIN + GENERAL_BAGS_COUNT) - 1;
 
 		const int16 GENERAL_BAGS_8_COUNT = 8 * SLOT_COUNT;
-		const int16 GENERAL_BAGS_8_END = (GENERAL_BAGS_BEGIN + GENERAL_BAGS_8_COUNT) - 1;
+		const int16 GENERAL_BAGS_8_END   = (GENERAL_BAGS_BEGIN + GENERAL_BAGS_8_COUNT) - 1;
 
-		const int16 CURSOR_BAG_BEGIN = 351;
+		const int16 CURSOR_BAG_BEGIN = GENERAL_BAGS_END + 1;
 		const int16 CURSOR_BAG_COUNT = SLOT_COUNT;
-		const int16 CURSOR_BAG_END = (CURSOR_BAG_BEGIN + CURSOR_BAG_COUNT) - 1;
+		const int16 CURSOR_BAG_END   = (CURSOR_BAG_BEGIN + CURSOR_BAG_COUNT) - 1;
 
-		using Titanium::invbag::BANK_BAGS_BEGIN;
+		const int16 BANK_BAGS_BEGIN = CURSOR_BAG_END + 1;
 		const int16 BANK_BAGS_COUNT = (invtype::BANK_SIZE * SLOT_COUNT);
-		const int16 BANK_BAGS_END = (BANK_BAGS_BEGIN + BANK_BAGS_COUNT) - 1;
+		const int16 BANK_BAGS_END   = (BANK_BAGS_BEGIN + BANK_BAGS_COUNT) - 1;
 
 		const int16 BANK_BAGS_16_COUNT = 16 * SLOT_COUNT;
-		const int16 BANK_BAGS_16_END = (BANK_BAGS_BEGIN + BANK_BAGS_16_COUNT) - 1;
+		const int16 BANK_BAGS_16_END   = (BANK_BAGS_BEGIN + BANK_BAGS_16_COUNT) - 1;
 
-		using Titanium::invbag::SHARED_BANK_BAGS_BEGIN;
+		const int16 SHARED_BANK_BAGS_BEGIN = BANK_BAGS_END + 1;
 		const int16 SHARED_BANK_BAGS_COUNT = invtype::SHARED_BANK_SIZE * SLOT_COUNT;
-		const int16 SHARED_BANK_BAGS_END = (SHARED_BANK_BAGS_BEGIN + SHARED_BANK_BAGS_COUNT) - 1;
+		const int16 SHARED_BANK_BAGS_END   = (SHARED_BANK_BAGS_BEGIN + SHARED_BANK_BAGS_COUNT) - 1;
 
-		using Titanium::invbag::TRADE_BAGS_BEGIN;
+		const int16 TRADE_BAGS_BEGIN = SHARED_BANK_BAGS_END + 1;
 		const int16 TRADE_BAGS_COUNT = invtype::TRADE_SIZE * SLOT_COUNT;
-		const int16 TRADE_BAGS_END = (TRADE_BAGS_BEGIN + TRADE_BAGS_COUNT) - 1;
+		const int16 TRADE_BAGS_END   = (TRADE_BAGS_BEGIN + TRADE_BAGS_COUNT) - 1;
 
-		using Titanium::invbag::GetInvBagIndexName;
+		using RoF2::invbag::GetInvBagIndexName;
 
 	} // namespace invbag
 

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 {

common/eqemu_config.cpp

@@ -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/inventory_profile.h

@@ -176,7 +176,6 @@ namespace EQ
 		// Locate an available inventory slot
 		int16 FindFreeSlot(bool for_bag, bool try_cursor, uint8 min_size = 0, bool is_arrow = false);
 		int16 FindFreeSlotForTradeItem(const ItemInstance* inst, int16 general_start = invslot::GENERAL_BEGIN, uint8 bag_start = invbag::SLOT_BEGIN);
-		std::vector<int16> FindAllFreeSlotsThatFitItem(const EQ::ItemData *inst);
 		int16 FindFirstFreeSlotThatFitsItem(const EQ::ItemData *inst);
 
 		// Calculate slot_id for an item within a bag
@@ -199,12 +198,6 @@ namespace EQ
 
 		uint8 FindBrightestLightType();
 
-		void dumpEntireInventory();
-		void dumpWornItems();
-		void dumpInventory();
-		void dumpBankItems();
-		void dumpSharedBankItems();
-
 		void SetCustomItemData(uint32 character_id, int16 slot_id, const std::string &identifier, const std::string& value);
 		void SetCustomItemData(uint32 character_id, int16 slot_id, const std::string &identifier, int value);
 		void SetCustomItemData(uint32 character_id, int16 slot_id, const std::string &identifier, float value);
@@ -217,8 +210,6 @@ namespace EQ
 		///////////////////////////////
 
 		int GetSlotByItemInstCollection(const std::map<int16, ItemInstance*> &collection, ItemInstance *inst);
-		void dumpItemCollection(const std::map<int16, ItemInstance*> &collection);
-		void dumpBagContents(ItemInstance *inst, std::map<int16, ItemInstance*>::const_iterator *it);
 
 		// Retrieves item within an inventory bucket
 		ItemInstance* _GetItem(const std::map<int16, ItemInstance*>& bucket, int16 slot_id) const;

common/mysql_stmt.cpp

@@ -0,0 +1,586 @@
+#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>
+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
+	{
+		// 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/rof2_limits.h

@@ -1,5 +1,5 @@
 /*	EQEMu: Everquest Server Emulator
-	
+
 	Copyright (C) 2001-2016 EQEMu Development Team (http://eqemulator.net)
 
 	This program is free software; you can redistribute it and/or modify
@@ -37,7 +37,7 @@ namespace RoF2
 
 		const bool AllowOverLevelEquipment = true;
 
-		const bool AllowEmptyBagInBag = true;
+		const bool AllowEmptyBagInBag    = true;
 		const bool AllowClickCastFromBag = true;
 
 	} /*inventory*/
@@ -77,38 +77,38 @@ namespace RoF2
 		} // namespace enum_
 		using namespace enum_;
 
-		const int16 POSSESSIONS_SIZE = 34;
-		const int16 BANK_SIZE = 24;
-		const int16 SHARED_BANK_SIZE = 2;
-		const int16 TRADE_SIZE = 8;
-		const int16 WORLD_SIZE = 10;
-		const int16 LIMBO_SIZE = 36;
-		const int16 TRIBUTE_SIZE = 5;
-		const int16 TROPHY_TRIBUTE_SIZE = 0;//unknown
-		const int16 GUILD_TRIBUTE_SIZE = 2;//unverified
-		const int16 MERCHANT_SIZE = 200;
-		const int16 DELETED_SIZE = 0;//unknown - "Recovery Tab"
-		const int16 CORPSE_SIZE = POSSESSIONS_SIZE;
-		const int16 BAZAAR_SIZE = 200;
-		const int16 INSPECT_SIZE = 23;
-		const int16 REAL_ESTATE_SIZE = 0;//unknown
-		const int16 VIEW_MOD_PC_SIZE = POSSESSIONS_SIZE;
-		const int16 VIEW_MOD_BANK_SIZE = BANK_SIZE;
+		const int16 POSSESSIONS_SIZE          = 34;
+		const int16 BANK_SIZE                 = 24;
+		const int16 SHARED_BANK_SIZE          = 2;
+		const int16 TRADE_SIZE                = 8;
+		const int16 WORLD_SIZE                = 10;
+		const int16 LIMBO_SIZE                = 36;
+		const int16 TRIBUTE_SIZE              = 5;
+		const int16 TROPHY_TRIBUTE_SIZE       = 0;//unknown
+		const int16 GUILD_TRIBUTE_SIZE        = 2;//unverified
+		const int16 MERCHANT_SIZE             = 500;
+		const int16 DELETED_SIZE              = 0;//unknown - "Recovery Tab"
+		const int16 CORPSE_SIZE               = POSSESSIONS_SIZE;
+		const int16 BAZAAR_SIZE               = 200;
+		const int16 INSPECT_SIZE              = 23;
+		const int16 REAL_ESTATE_SIZE          = 0;//unknown
+		const int16 VIEW_MOD_PC_SIZE          = POSSESSIONS_SIZE;
+		const int16 VIEW_MOD_BANK_SIZE        = BANK_SIZE;
 		const int16 VIEW_MOD_SHARED_BANK_SIZE = SHARED_BANK_SIZE;
-		const int16 VIEW_MOD_LIMBO_SIZE = LIMBO_SIZE;
-		const int16 ALT_STORAGE_SIZE = 0;//unknown - "Shroud Bank"
-		const int16 ARCHIVED_SIZE = 0;//unknown
-		const int16 MAIL_SIZE = 0;//unknown
+		const int16 VIEW_MOD_LIMBO_SIZE       = LIMBO_SIZE;
+		const int16 ALT_STORAGE_SIZE          = 0;//unknown - "Shroud Bank"
+		const int16 ARCHIVED_SIZE             = 0;//unknown
+		const int16 MAIL_SIZE                 = 0;//unknown
 		const int16 GUILD_TROPHY_TRIBUTE_SIZE = 0;//unknown
-		const int16 KRONO_SIZE = 0;//unknown
-		const int16 OTHER_SIZE = 0;//unknown
+		const int16 KRONO_SIZE                = 0;//unknown
+		const int16 OTHER_SIZE                = 0;//unknown
 
 		const int16 TRADE_NPC_SIZE = 4; // defined by implication
 
 		const int16 TYPE_INVALID = IINVALID;
-		const int16 TYPE_BEGIN = typePossessions;
-		const int16 TYPE_END = typeOther;
-		const int16 TYPE_COUNT = (TYPE_END - TYPE_BEGIN) + 1;
+		const int16 TYPE_BEGIN   = typePossessions;
+		const int16 TYPE_END     = typeOther;
+		const int16 TYPE_COUNT   = (TYPE_END - TYPE_BEGIN) + 1;
 
 		int16 GetInvTypeSize(int16 inv_type);
 		const char* GetInvTypeName(int16 inv_type);
@@ -162,33 +162,54 @@ namespace RoF2
 		} // namespace enum_
 		using namespace enum_;
 
-		const int16 SLOT_INVALID = IINVALID;
-		const int16 SLOT_BEGIN = INULL;
+		const int16 SLOT_TRADESKILL_EXPERIMENT_COMBINE = 1000;
+		const int16 SLOT_INVALID                       = IINVALID;
+		const int16 SLOT_BEGIN                         = INULL;
+
+		const int16 BANK_BEGIN = 2000;
+		const int16 BANK_END   = (BANK_BEGIN + invtype::BANK_SIZE) - 1;
+
+		const int16 SHARED_BANK_BEGIN = 2500;
+		const int16 SHARED_BANK_END   = (SHARED_BANK_BEGIN + invtype::SHARED_BANK_SIZE) - 1;
+
+		const int16 TRADE_BEGIN = 3000;
+		const int16 TRADE_END   = (TRADE_BEGIN + invtype::TRADE_SIZE) - 1;
+
+		const int16 TRADE_NPC_END = (TRADE_BEGIN + invtype::TRADE_NPC_SIZE) - 1; // defined by implication
+
+		const int16 WORLD_BEGIN = 4000;
+		const int16 WORLD_END   = (WORLD_BEGIN + invtype::WORLD_SIZE) - 1;
+
+		const int16 TRIBUTE_BEGIN = 400;
+		const int16 TRIBUTE_END   = (TRIBUTE_BEGIN + invtype::TRIBUTE_SIZE) - 1;
+
+		const int16 GUILD_TRIBUTE_BEGIN = 450;
+		const int16 GUILD_TRIBUTE_END   = (GUILD_TRIBUTE_BEGIN + invtype::GUILD_TRIBUTE_SIZE) - 1;
 
 		const int16 POSSESSIONS_BEGIN = slotCharm;
-		const int16 POSSESSIONS_END = slotCursor;
+		const int16 POSSESSIONS_END   = slotCursor;
 		const int16 POSSESSIONS_COUNT = (POSSESSIONS_END - POSSESSIONS_BEGIN) + 1;
 
 		const int16 EQUIPMENT_BEGIN = slotCharm;
-		const int16 EQUIPMENT_END = slotAmmo;
+		const int16 EQUIPMENT_END   = slotAmmo;
 		const int16 EQUIPMENT_COUNT = (EQUIPMENT_END - EQUIPMENT_BEGIN) + 1;
 
 		const int16 GENERAL_BEGIN = slotGeneral1;
-		const int16 GENERAL_END = slotGeneral10;
+		const int16 GENERAL_END   = slotGeneral10;
 		const int16 GENERAL_COUNT = (GENERAL_END - GENERAL_BEGIN) + 1;
 
-		const int16 BONUS_BEGIN = invslot::slotCharm;
-		const int16 BONUS_STAT_END = invslot::slotPowerSource;
+		const int16 BONUS_BEGIN     = invslot::slotCharm;
+		const int16 BONUS_STAT_END  = invslot::slotPowerSource;
 		const int16 BONUS_SKILL_END = invslot::slotAmmo;
 
 		const int16 CORPSE_BEGIN = invslot::slotGeneral1;
-		const int16 CORPSE_END = invslot::slotGeneral1 + invslot::slotCursor;
+		const int16 CORPSE_END   = invslot::slotGeneral1 + invslot::slotCursor;
 
-		const uint64 EQUIPMENT_BITMASK = 0x00000000007FFFFF;
-		const uint64 GENERAL_BITMASK = 0x00000001FF800000;
-		const uint64 CURSOR_BITMASK = 0x0000000200000000;
+		const uint64 EQUIPMENT_BITMASK   = 0x00000000007FFFFF;
+		const uint64 GENERAL_BITMASK     = 0x00000001FF800000;
+		const uint64 CURSOR_BITMASK      = 0x0000000200000000;
 		const uint64 POSSESSIONS_BITMASK = (EQUIPMENT_BITMASK | GENERAL_BITMASK | CURSOR_BITMASK); // based on 34-slot count (RoF+)
-		const uint64 CORPSE_BITMASK = (GENERAL_BITMASK | CURSOR_BITMASK | (EQUIPMENT_BITMASK << 34)); // based on 34-slot count (RoF+)
+		const uint64 CORPSE_BITMASK      = (GENERAL_BITMASK | CURSOR_BITMASK | (EQUIPMENT_BITMASK << 34)); // based on 34-slot count (RoF+)
 
 
 		const char* GetInvPossessionsSlotName(int16 inv_slot);
@@ -199,10 +220,21 @@ namespace RoF2
 	namespace invbag {
 		inline EQ::versions::ClientVersion GetInvBagRef() { return EQ::versions::ClientVersion::RoF2; }
 
-		const int16 SLOT_INVALID = IINVALID;
-		const int16 SLOT_BEGIN = INULL;
-		const int16 SLOT_END = 9; //254;
-		const int16 SLOT_COUNT = 10; //255; // server Size will be 255..unsure what actual client is (test)
+		const int16 SLOT_TRADESKILL_EXPERIMENT_COMBINE = 1000;
+		const int16 SLOT_INVALID                       = IINVALID;
+		const int16 SLOT_BEGIN                         = INULL;
+		const int16 SLOT_COUNT                         = 200;
+		const int16 SLOT_END                           = SLOT_COUNT - 1;
+
+		const int16 GENERAL_BAGS_BEGIN = 251;
+
+		const int16 CURSOR_BAG_BEGIN = 351;
+
+		const int16 BANK_BAGS_BEGIN = 2031;
+
+		const int16 SHARED_BANK_BAGS_BEGIN = 2531;
+
+		const int16 TRADE_BAGS_BEGIN = 3031;
 
 		const char* GetInvBagIndexName(int16 bag_index);
 
@@ -212,9 +244,9 @@ namespace RoF2
 		inline EQ::versions::ClientVersion GetInvAugRef() { return EQ::versions::ClientVersion::RoF2; }
 
 		const int16 SOCKET_INVALID = IINVALID;
-		const int16 SOCKET_BEGIN = INULL;
-		const int16 SOCKET_END = 5;
-		const int16 SOCKET_COUNT = 6;
+		const int16 SOCKET_BEGIN   = INULL;
+		const int16 SOCKET_END     = 5;
+		const int16 SOCKET_COUNT   = 6;
 
 		const char* GetInvAugIndexName(int16 aug_index);
 
@@ -291,7 +323,7 @@ namespace RoF2
 
 	namespace spells {
 		inline EQ::versions::ClientVersion GetSkillsRef() { return EQ::versions::ClientVersion::RoF2; }
-		
+
 		enum class CastingSlot : uint32 {
 			Gem1 = 0,
 			Gem2 = 1,
@@ -314,7 +346,7 @@ namespace RoF2
 		const int SPELL_ID_MAX = 45000;
 		const int SPELLBOOK_SIZE = 720;
 		const int SPELL_GEM_COUNT = static_cast<uint32>(CastingSlot::MaxGems);
-		
+
 		const int LONG_BUFFS = 42;
 		const int SHORT_BUFFS = 20;
 		const int DISC_BUFFS = 1;

common/patches/titanium_structs.h

@@ -2463,25 +2463,25 @@ struct WhoAllReturnStruct {
 struct BeginTrader_Struct {
 	uint32 action;
 	uint32 unknown04;
-	uint64 serial_number[80];
-	uint32 cost[80];
+	uint64 serial_number[EQ::invtype::BAZAAR_SIZE];
+	uint32 cost[EQ::invtype::BAZAAR_SIZE];
 };
 
 struct Trader_Struct {
 	uint32 action;
 	uint32 unknown004;
-	uint64 item_id[80];
-	uint32 item_cost[80];
+	uint64 item_id[EQ::invtype::BAZAAR_SIZE];
+	uint32 item_cost[EQ::invtype::BAZAAR_SIZE];
 };
 
 struct ClickTrader_Struct {
 	uint32	code;
 	uint32	unknown[161];//damn soe this is totally pointless :/ but at least your finally using memset! Good job :) -LE
-	uint32	itemcost[80];
+	uint32	itemcost[EQ::invtype::BAZAAR_SIZE];
 };
 
 struct GetItems_Struct{
-	uint32	items[80];
+	uint32	items[EQ::invtype::BAZAAR_SIZE];
 };
 
 struct BecomeTrader_Struct {

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_inventory_repository.h

@@ -19,48 +19,48 @@
 class BaseInventoryRepository {
 public:
 	struct Inventory {
-		uint32_t    charid;
-		uint32_t    slotid;
-		uint32_t    itemid;
+		uint32_t    character_id;
+		uint32_t    slot_id;
+		uint32_t    item_id;
 		uint16_t    charges;
 		uint32_t    color;
-		uint32_t    augslot1;
-		uint32_t    augslot2;
-		uint32_t    augslot3;
-		uint32_t    augslot4;
-		uint32_t    augslot5;
-		int32_t     augslot6;
+		uint32_t    augment_one;
+		uint32_t    augment_two;
+		uint32_t    augment_three;
+		uint32_t    augment_four;
+		uint32_t    augment_five;
+		uint32_t    augment_six;
 		uint8_t     instnodrop;
 		std::string custom_data;
-		uint32_t    ornamenticon;
-		uint32_t    ornamentidfile;
+		uint32_t    ornament_icon;
+		uint32_t    ornament_idfile;
 		int32_t     ornament_hero_model;
 		uint64_t    guid;
 	};
 
 	static std::string PrimaryKey()
 	{
-		return std::string("charid");
+		return std::string("character_id");
 	}
 
 	static std::vector<std::string> Columns()
 	{
 		return {
-			"charid",
-			"slotid",
-			"itemid",
+			"character_id",
+			"slot_id",
+			"item_id",
 			"charges",
 			"color",
-			"augslot1",
-			"augslot2",
-			"augslot3",
-			"augslot4",
-			"augslot5",
-			"augslot6",
+			"augment_one",
+			"augment_two",
+			"augment_three",
+			"augment_four",
+			"augment_five",
+			"augment_six",
 			"instnodrop",
 			"custom_data",
-			"ornamenticon",
-			"ornamentidfile",
+			"ornament_icon",
+			"ornament_idfile",
 			"ornament_hero_model",
 			"guid",
 		};
@@ -69,21 +69,21 @@ public:
 	static std::vector<std::string> SelectColumns()
 	{
 		return {
-			"charid",
-			"slotid",
-			"itemid",
+			"character_id",
+			"slot_id",
+			"item_id",
 			"charges",
 			"color",
-			"augslot1",
-			"augslot2",
-			"augslot3",
-			"augslot4",
-			"augslot5",
-			"augslot6",
+			"augment_one",
+			"augment_two",
+			"augment_three",
+			"augment_four",
+			"augment_five",
+			"augment_six",
 			"instnodrop",
 			"custom_data",
-			"ornamenticon",
-			"ornamentidfile",
+			"ornament_icon",
+			"ornament_idfile",
 			"ornament_hero_model",
 			"guid",
 		};
@@ -126,21 +126,21 @@ public:
 	{
 		Inventory e{};
 
-		e.charid              = 0;
-		e.slotid              = 0;
-		e.itemid              = 0;
+		e.character_id        = 0;
+		e.slot_id             = 0;
+		e.item_id             = 0;
 		e.charges             = 0;
 		e.color               = 0;
-		e.augslot1            = 0;
-		e.augslot2            = 0;
-		e.augslot3            = 0;
-		e.augslot4            = 0;
-		e.augslot5            = 0;
-		e.augslot6            = 0;
+		e.augment_one         = 0;
+		e.augment_two         = 0;
+		e.augment_three       = 0;
+		e.augment_four        = 0;
+		e.augment_five        = 0;
+		e.augment_six         = 0;
 		e.instnodrop          = 0;
 		e.custom_data         = "";
-		e.ornamenticon        = 0;
-		e.ornamentidfile      = 0;
+		e.ornament_icon       = 0;
+		e.ornament_idfile     = 0;
 		e.ornament_hero_model = 0;
 		e.guid                = 0;
 
@@ -153,7 +153,7 @@ public:
 	)
 	{
 		for (auto &inventory : inventorys) {
-			if (inventory.charid == inventory_id) {
+			if (inventory.character_id == inventory_id) {
 				return inventory;
 			}
 		}
@@ -179,21 +179,21 @@ public:
 		if (results.RowCount() == 1) {
 			Inventory e{};
 
-			e.charid              = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
-			e.slotid              = row[1] ? static_cast<uint32_t>(strtoul(row[1], nullptr, 10)) : 0;
-			e.itemid              = row[2] ? static_cast<uint32_t>(strtoul(row[2], nullptr, 10)) : 0;
+			e.character_id        = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.slot_id             = row[1] ? static_cast<uint32_t>(strtoul(row[1], nullptr, 10)) : 0;
+			e.item_id             = row[2] ? static_cast<uint32_t>(strtoul(row[2], nullptr, 10)) : 0;
 			e.charges             = row[3] ? static_cast<uint16_t>(strtoul(row[3], nullptr, 10)) : 0;
 			e.color               = row[4] ? static_cast<uint32_t>(strtoul(row[4], nullptr, 10)) : 0;
-			e.augslot1            = row[5] ? static_cast<uint32_t>(strtoul(row[5], nullptr, 10)) : 0;
-			e.augslot2            = row[6] ? static_cast<uint32_t>(strtoul(row[6], nullptr, 10)) : 0;
-			e.augslot3            = row[7] ? static_cast<uint32_t>(strtoul(row[7], nullptr, 10)) : 0;
-			e.augslot4            = row[8] ? static_cast<uint32_t>(strtoul(row[8], nullptr, 10)) : 0;
-			e.augslot5            = row[9] ? static_cast<uint32_t>(strtoul(row[9], nullptr, 10)) : 0;
-			e.augslot6            = row[10] ? static_cast<int32_t>(atoi(row[10])) : 0;
+			e.augment_one         = row[5] ? static_cast<uint32_t>(strtoul(row[5], nullptr, 10)) : 0;
+			e.augment_two         = row[6] ? static_cast<uint32_t>(strtoul(row[6], nullptr, 10)) : 0;
+			e.augment_three       = row[7] ? static_cast<uint32_t>(strtoul(row[7], nullptr, 10)) : 0;
+			e.augment_four        = row[8] ? static_cast<uint32_t>(strtoul(row[8], nullptr, 10)) : 0;
+			e.augment_five        = row[9] ? static_cast<uint32_t>(strtoul(row[9], nullptr, 10)) : 0;
+			e.augment_six         = row[10] ? static_cast<uint32_t>(strtoul(row[10], nullptr, 10)) : 0;
 			e.instnodrop          = row[11] ? static_cast<uint8_t>(strtoul(row[11], nullptr, 10)) : 0;
 			e.custom_data         = row[12] ? row[12] : "";
-			e.ornamenticon        = row[13] ? static_cast<uint32_t>(strtoul(row[13], nullptr, 10)) : 0;
-			e.ornamentidfile      = row[14] ? static_cast<uint32_t>(strtoul(row[14], nullptr, 10)) : 0;
+			e.ornament_icon       = row[13] ? static_cast<uint32_t>(strtoul(row[13], nullptr, 10)) : 0;
+			e.ornament_idfile     = row[14] ? static_cast<uint32_t>(strtoul(row[14], nullptr, 10)) : 0;
 			e.ornament_hero_model = row[15] ? static_cast<int32_t>(atoi(row[15])) : 0;
 			e.guid                = row[16] ? strtoull(row[16], nullptr, 10) : 0;
 
@@ -229,21 +229,21 @@ public:
 
 		auto columns = Columns();
 
-		v.push_back(columns[0] + " = " + std::to_string(e.charid));
-		v.push_back(columns[1] + " = " + std::to_string(e.slotid));
-		v.push_back(columns[2] + " = " + std::to_string(e.itemid));
+		v.push_back(columns[0] + " = " + std::to_string(e.character_id));
+		v.push_back(columns[1] + " = " + std::to_string(e.slot_id));
+		v.push_back(columns[2] + " = " + std::to_string(e.item_id));
 		v.push_back(columns[3] + " = " + std::to_string(e.charges));
 		v.push_back(columns[4] + " = " + std::to_string(e.color));
-		v.push_back(columns[5] + " = " + std::to_string(e.augslot1));
-		v.push_back(columns[6] + " = " + std::to_string(e.augslot2));
-		v.push_back(columns[7] + " = " + std::to_string(e.augslot3));
-		v.push_back(columns[8] + " = " + std::to_string(e.augslot4));
-		v.push_back(columns[9] + " = " + std::to_string(e.augslot5));
-		v.push_back(columns[10] + " = " + std::to_string(e.augslot6));
+		v.push_back(columns[5] + " = " + std::to_string(e.augment_one));
+		v.push_back(columns[6] + " = " + std::to_string(e.augment_two));
+		v.push_back(columns[7] + " = " + std::to_string(e.augment_three));
+		v.push_back(columns[8] + " = " + std::to_string(e.augment_four));
+		v.push_back(columns[9] + " = " + std::to_string(e.augment_five));
+		v.push_back(columns[10] + " = " + std::to_string(e.augment_six));
 		v.push_back(columns[11] + " = " + std::to_string(e.instnodrop));
 		v.push_back(columns[12] + " = '" + Strings::Escape(e.custom_data) + "'");
-		v.push_back(columns[13] + " = " + std::to_string(e.ornamenticon));
-		v.push_back(columns[14] + " = " + std::to_string(e.ornamentidfile));
+		v.push_back(columns[13] + " = " + std::to_string(e.ornament_icon));
+		v.push_back(columns[14] + " = " + std::to_string(e.ornament_idfile));
 		v.push_back(columns[15] + " = " + std::to_string(e.ornament_hero_model));
 		v.push_back(columns[16] + " = " + std::to_string(e.guid));
 
@@ -253,7 +253,7 @@ public:
 				TableName(),
 				Strings::Implode(", ", v),
 				PrimaryKey(),
-				e.charid
+				e.character_id
 			)
 		);
 
@@ -267,21 +267,21 @@ public:
 	{
 		std::vector<std::string> v;
 
-		v.push_back(std::to_string(e.charid));
-		v.push_back(std::to_string(e.slotid));
-		v.push_back(std::to_string(e.itemid));
+		v.push_back(std::to_string(e.character_id));
+		v.push_back(std::to_string(e.slot_id));
+		v.push_back(std::to_string(e.item_id));
 		v.push_back(std::to_string(e.charges));
 		v.push_back(std::to_string(e.color));
-		v.push_back(std::to_string(e.augslot1));
-		v.push_back(std::to_string(e.augslot2));
-		v.push_back(std::to_string(e.augslot3));
-		v.push_back(std::to_string(e.augslot4));
-		v.push_back(std::to_string(e.augslot5));
-		v.push_back(std::to_string(e.augslot6));
+		v.push_back(std::to_string(e.augment_one));
+		v.push_back(std::to_string(e.augment_two));
+		v.push_back(std::to_string(e.augment_three));
+		v.push_back(std::to_string(e.augment_four));
+		v.push_back(std::to_string(e.augment_five));
+		v.push_back(std::to_string(e.augment_six));
 		v.push_back(std::to_string(e.instnodrop));
 		v.push_back("'" + Strings::Escape(e.custom_data) + "'");
-		v.push_back(std::to_string(e.ornamenticon));
-		v.push_back(std::to_string(e.ornamentidfile));
+		v.push_back(std::to_string(e.ornament_icon));
+		v.push_back(std::to_string(e.ornament_idfile));
 		v.push_back(std::to_string(e.ornament_hero_model));
 		v.push_back(std::to_string(e.guid));
 
@@ -294,7 +294,7 @@ public:
 		);
 
 		if (results.Success()) {
-			e.charid = results.LastInsertedID();
+			e.character_id = results.LastInsertedID();
 			return e;
 		}
 
@@ -313,21 +313,21 @@ public:
 		for (auto &e: entries) {
 			std::vector<std::string> v;
 
-			v.push_back(std::to_string(e.charid));
-			v.push_back(std::to_string(e.slotid));
-			v.push_back(std::to_string(e.itemid));
+			v.push_back(std::to_string(e.character_id));
+			v.push_back(std::to_string(e.slot_id));
+			v.push_back(std::to_string(e.item_id));
 			v.push_back(std::to_string(e.charges));
 			v.push_back(std::to_string(e.color));
-			v.push_back(std::to_string(e.augslot1));
-			v.push_back(std::to_string(e.augslot2));
-			v.push_back(std::to_string(e.augslot3));
-			v.push_back(std::to_string(e.augslot4));
-			v.push_back(std::to_string(e.augslot5));
-			v.push_back(std::to_string(e.augslot6));
+			v.push_back(std::to_string(e.augment_one));
+			v.push_back(std::to_string(e.augment_two));
+			v.push_back(std::to_string(e.augment_three));
+			v.push_back(std::to_string(e.augment_four));
+			v.push_back(std::to_string(e.augment_five));
+			v.push_back(std::to_string(e.augment_six));
 			v.push_back(std::to_string(e.instnodrop));
 			v.push_back("'" + Strings::Escape(e.custom_data) + "'");
-			v.push_back(std::to_string(e.ornamenticon));
-			v.push_back(std::to_string(e.ornamentidfile));
+			v.push_back(std::to_string(e.ornament_icon));
+			v.push_back(std::to_string(e.ornament_idfile));
 			v.push_back(std::to_string(e.ornament_hero_model));
 			v.push_back(std::to_string(e.guid));
 
@@ -363,21 +363,21 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			Inventory e{};
 
-			e.charid              = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
-			e.slotid              = row[1] ? static_cast<uint32_t>(strtoul(row[1], nullptr, 10)) : 0;
-			e.itemid              = row[2] ? static_cast<uint32_t>(strtoul(row[2], nullptr, 10)) : 0;
+			e.character_id        = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.slot_id             = row[1] ? static_cast<uint32_t>(strtoul(row[1], nullptr, 10)) : 0;
+			e.item_id             = row[2] ? static_cast<uint32_t>(strtoul(row[2], nullptr, 10)) : 0;
 			e.charges             = row[3] ? static_cast<uint16_t>(strtoul(row[3], nullptr, 10)) : 0;
 			e.color               = row[4] ? static_cast<uint32_t>(strtoul(row[4], nullptr, 10)) : 0;
-			e.augslot1            = row[5] ? static_cast<uint32_t>(strtoul(row[5], nullptr, 10)) : 0;
-			e.augslot2            = row[6] ? static_cast<uint32_t>(strtoul(row[6], nullptr, 10)) : 0;
-			e.augslot3            = row[7] ? static_cast<uint32_t>(strtoul(row[7], nullptr, 10)) : 0;
-			e.augslot4            = row[8] ? static_cast<uint32_t>(strtoul(row[8], nullptr, 10)) : 0;
-			e.augslot5            = row[9] ? static_cast<uint32_t>(strtoul(row[9], nullptr, 10)) : 0;
-			e.augslot6            = row[10] ? static_cast<int32_t>(atoi(row[10])) : 0;
+			e.augment_one         = row[5] ? static_cast<uint32_t>(strtoul(row[5], nullptr, 10)) : 0;
+			e.augment_two         = row[6] ? static_cast<uint32_t>(strtoul(row[6], nullptr, 10)) : 0;
+			e.augment_three       = row[7] ? static_cast<uint32_t>(strtoul(row[7], nullptr, 10)) : 0;
+			e.augment_four        = row[8] ? static_cast<uint32_t>(strtoul(row[8], nullptr, 10)) : 0;
+			e.augment_five        = row[9] ? static_cast<uint32_t>(strtoul(row[9], nullptr, 10)) : 0;
+			e.augment_six         = row[10] ? static_cast<uint32_t>(strtoul(row[10], nullptr, 10)) : 0;
 			e.instnodrop          = row[11] ? static_cast<uint8_t>(strtoul(row[11], nullptr, 10)) : 0;
 			e.custom_data         = row[12] ? row[12] : "";
-			e.ornamenticon        = row[13] ? static_cast<uint32_t>(strtoul(row[13], nullptr, 10)) : 0;
-			e.ornamentidfile      = row[14] ? static_cast<uint32_t>(strtoul(row[14], nullptr, 10)) : 0;
+			e.ornament_icon       = row[13] ? static_cast<uint32_t>(strtoul(row[13], nullptr, 10)) : 0;
+			e.ornament_idfile     = row[14] ? static_cast<uint32_t>(strtoul(row[14], nullptr, 10)) : 0;
 			e.ornament_hero_model = row[15] ? static_cast<int32_t>(atoi(row[15])) : 0;
 			e.guid                = row[16] ? strtoull(row[16], nullptr, 10) : 0;
 
@@ -404,21 +404,21 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			Inventory e{};
 
-			e.charid              = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
-			e.slotid              = row[1] ? static_cast<uint32_t>(strtoul(row[1], nullptr, 10)) : 0;
-			e.itemid              = row[2] ? static_cast<uint32_t>(strtoul(row[2], nullptr, 10)) : 0;
+			e.character_id        = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.slot_id             = row[1] ? static_cast<uint32_t>(strtoul(row[1], nullptr, 10)) : 0;
+			e.item_id             = row[2] ? static_cast<uint32_t>(strtoul(row[2], nullptr, 10)) : 0;
 			e.charges             = row[3] ? static_cast<uint16_t>(strtoul(row[3], nullptr, 10)) : 0;
 			e.color               = row[4] ? static_cast<uint32_t>(strtoul(row[4], nullptr, 10)) : 0;
-			e.augslot1            = row[5] ? static_cast<uint32_t>(strtoul(row[5], nullptr, 10)) : 0;
-			e.augslot2            = row[6] ? static_cast<uint32_t>(strtoul(row[6], nullptr, 10)) : 0;
-			e.augslot3            = row[7] ? static_cast<uint32_t>(strtoul(row[7], nullptr, 10)) : 0;
-			e.augslot4            = row[8] ? static_cast<uint32_t>(strtoul(row[8], nullptr, 10)) : 0;
-			e.augslot5            = row[9] ? static_cast<uint32_t>(strtoul(row[9], nullptr, 10)) : 0;
-			e.augslot6            = row[10] ? static_cast<int32_t>(atoi(row[10])) : 0;
+			e.augment_one         = row[5] ? static_cast<uint32_t>(strtoul(row[5], nullptr, 10)) : 0;
+			e.augment_two         = row[6] ? static_cast<uint32_t>(strtoul(row[6], nullptr, 10)) : 0;
+			e.augment_three       = row[7] ? static_cast<uint32_t>(strtoul(row[7], nullptr, 10)) : 0;
+			e.augment_four        = row[8] ? static_cast<uint32_t>(strtoul(row[8], nullptr, 10)) : 0;
+			e.augment_five        = row[9] ? static_cast<uint32_t>(strtoul(row[9], nullptr, 10)) : 0;
+			e.augment_six         = row[10] ? static_cast<uint32_t>(strtoul(row[10], nullptr, 10)) : 0;
 			e.instnodrop          = row[11] ? static_cast<uint8_t>(strtoul(row[11], nullptr, 10)) : 0;
 			e.custom_data         = row[12] ? row[12] : "";
-			e.ornamenticon        = row[13] ? static_cast<uint32_t>(strtoul(row[13], nullptr, 10)) : 0;
-			e.ornamentidfile      = row[14] ? static_cast<uint32_t>(strtoul(row[14], nullptr, 10)) : 0;
+			e.ornament_icon       = row[13] ? static_cast<uint32_t>(strtoul(row[13], nullptr, 10)) : 0;
+			e.ornament_idfile     = row[14] ? static_cast<uint32_t>(strtoul(row[14], nullptr, 10)) : 0;
 			e.ornament_hero_model = row[15] ? static_cast<int32_t>(atoi(row[15])) : 0;
 			e.guid                = row[16] ? strtoull(row[16], nullptr, 10) : 0;
 
@@ -495,21 +495,21 @@ public:
 	{
 		std::vector<std::string> v;
 
-		v.push_back(std::to_string(e.charid));
-		v.push_back(std::to_string(e.slotid));
-		v.push_back(std::to_string(e.itemid));
+		v.push_back(std::to_string(e.character_id));
+		v.push_back(std::to_string(e.slot_id));
+		v.push_back(std::to_string(e.item_id));
 		v.push_back(std::to_string(e.charges));
 		v.push_back(std::to_string(e.color));
-		v.push_back(std::to_string(e.augslot1));
-		v.push_back(std::to_string(e.augslot2));
-		v.push_back(std::to_string(e.augslot3));
-		v.push_back(std::to_string(e.augslot4));
-		v.push_back(std::to_string(e.augslot5));
-		v.push_back(std::to_string(e.augslot6));
+		v.push_back(std::to_string(e.augment_one));
+		v.push_back(std::to_string(e.augment_two));
+		v.push_back(std::to_string(e.augment_three));
+		v.push_back(std::to_string(e.augment_four));
+		v.push_back(std::to_string(e.augment_five));
+		v.push_back(std::to_string(e.augment_six));
 		v.push_back(std::to_string(e.instnodrop));
 		v.push_back("'" + Strings::Escape(e.custom_data) + "'");
-		v.push_back(std::to_string(e.ornamenticon));
-		v.push_back(std::to_string(e.ornamentidfile));
+		v.push_back(std::to_string(e.ornament_icon));
+		v.push_back(std::to_string(e.ornament_idfile));
 		v.push_back(std::to_string(e.ornament_hero_model));
 		v.push_back(std::to_string(e.guid));
 
@@ -534,21 +534,21 @@ public:
 		for (auto &e: entries) {
 			std::vector<std::string> v;
 
-			v.push_back(std::to_string(e.charid));
-			v.push_back(std::to_string(e.slotid));
-			v.push_back(std::to_string(e.itemid));
+			v.push_back(std::to_string(e.character_id));
+			v.push_back(std::to_string(e.slot_id));
+			v.push_back(std::to_string(e.item_id));
 			v.push_back(std::to_string(e.charges));
 			v.push_back(std::to_string(e.color));
-			v.push_back(std::to_string(e.augslot1));
-			v.push_back(std::to_string(e.augslot2));
-			v.push_back(std::to_string(e.augslot3));
-			v.push_back(std::to_string(e.augslot4));
-			v.push_back(std::to_string(e.augslot5));
-			v.push_back(std::to_string(e.augslot6));
+			v.push_back(std::to_string(e.augment_one));
+			v.push_back(std::to_string(e.augment_two));
+			v.push_back(std::to_string(e.augment_three));
+			v.push_back(std::to_string(e.augment_four));
+			v.push_back(std::to_string(e.augment_five));
+			v.push_back(std::to_string(e.augment_six));
 			v.push_back(std::to_string(e.instnodrop));
 			v.push_back("'" + Strings::Escape(e.custom_data) + "'");
-			v.push_back(std::to_string(e.ornamenticon));
-			v.push_back(std::to_string(e.ornamentidfile));
+			v.push_back(std::to_string(e.ornament_icon));
+			v.push_back(std::to_string(e.ornament_idfile));
 			v.push_back(std::to_string(e.ornament_hero_model));
 			v.push_back(std::to_string(e.guid));
 

common/repositories/base/base_sharedbank_repository.h

@@ -0,0 +1,560 @@
+/**
+ * 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_SHAREDBANK_REPOSITORY_H
+#define EQEMU_BASE_SHAREDBANK_REPOSITORY_H
+
+#include "../../database.h"
+#include "../../strings.h"
+#include <ctime>
+
+class BaseSharedbankRepository {
+public:
+	struct Sharedbank {
+		uint32_t    account_id;
+		uint32_t    slot_id;
+		uint32_t    item_id;
+		uint16_t    charges;
+		uint32_t    color;
+		uint32_t    augment_one;
+		uint32_t    augment_two;
+		uint32_t    augment_three;
+		uint32_t    augment_four;
+		uint32_t    augment_five;
+		uint32_t    augment_six;
+		std::string custom_data;
+		uint32_t    ornament_icon;
+		uint32_t    ornament_idfile;
+		int32_t     ornament_hero_model;
+		uint64_t    guid;
+	};
+
+	static std::string PrimaryKey()
+	{
+		return std::string("account_id");
+	}
+
+	static std::vector<std::string> Columns()
+	{
+		return {
+			"account_id",
+			"slot_id",
+			"item_id",
+			"charges",
+			"color",
+			"augment_one",
+			"augment_two",
+			"augment_three",
+			"augment_four",
+			"augment_five",
+			"augment_six",
+			"custom_data",
+			"ornament_icon",
+			"ornament_idfile",
+			"ornament_hero_model",
+			"guid",
+		};
+	}
+
+	static std::vector<std::string> SelectColumns()
+	{
+		return {
+			"account_id",
+			"slot_id",
+			"item_id",
+			"charges",
+			"color",
+			"augment_one",
+			"augment_two",
+			"augment_three",
+			"augment_four",
+			"augment_five",
+			"augment_six",
+			"custom_data",
+			"ornament_icon",
+			"ornament_idfile",
+			"ornament_hero_model",
+			"guid",
+		};
+	}
+
+	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("sharedbank");
+	}
+
+	static std::string BaseSelect()
+	{
+		return fmt::format(
+			"SELECT {} FROM {}",
+			SelectColumnsRaw(),
+			TableName()
+		);
+	}
+
+	static std::string BaseInsert()
+	{
+		return fmt::format(
+			"INSERT INTO {} ({}) ",
+			TableName(),
+			ColumnsRaw()
+		);
+	}
+
+	static Sharedbank NewEntity()
+	{
+		Sharedbank e{};
+
+		e.account_id          = 0;
+		e.slot_id             = 0;
+		e.item_id             = 0;
+		e.charges             = 0;
+		e.color               = 0;
+		e.augment_one         = 0;
+		e.augment_two         = 0;
+		e.augment_three       = 0;
+		e.augment_four        = 0;
+		e.augment_five        = 0;
+		e.augment_six         = 0;
+		e.custom_data         = "";
+		e.ornament_icon       = 0;
+		e.ornament_idfile     = 0;
+		e.ornament_hero_model = 0;
+		e.guid                = 0;
+
+		return e;
+	}
+
+	static Sharedbank GetSharedbank(
+		const std::vector<Sharedbank> &sharedbanks,
+		int sharedbank_id
+	)
+	{
+		for (auto &sharedbank : sharedbanks) {
+			if (sharedbank.account_id == sharedbank_id) {
+				return sharedbank;
+			}
+		}
+
+		return NewEntity();
+	}
+
+	static Sharedbank FindOne(
+		Database& db,
+		int sharedbank_id
+	)
+	{
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"{} WHERE {} = {} LIMIT 1",
+				BaseSelect(),
+				PrimaryKey(),
+				sharedbank_id
+			)
+		);
+
+		auto row = results.begin();
+		if (results.RowCount() == 1) {
+			Sharedbank e{};
+
+			e.account_id          = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.slot_id             = row[1] ? static_cast<uint32_t>(strtoul(row[1], nullptr, 10)) : 0;
+			e.item_id             = row[2] ? static_cast<uint32_t>(strtoul(row[2], nullptr, 10)) : 0;
+			e.charges             = row[3] ? static_cast<uint16_t>(strtoul(row[3], nullptr, 10)) : 0;
+			e.color               = row[4] ? static_cast<uint32_t>(strtoul(row[4], nullptr, 10)) : 0;
+			e.augment_one         = row[5] ? static_cast<uint32_t>(strtoul(row[5], nullptr, 10)) : 0;
+			e.augment_two         = row[6] ? static_cast<uint32_t>(strtoul(row[6], nullptr, 10)) : 0;
+			e.augment_three       = row[7] ? static_cast<uint32_t>(strtoul(row[7], nullptr, 10)) : 0;
+			e.augment_four        = row[8] ? static_cast<uint32_t>(strtoul(row[8], nullptr, 10)) : 0;
+			e.augment_five        = row[9] ? static_cast<uint32_t>(strtoul(row[9], nullptr, 10)) : 0;
+			e.augment_six         = row[10] ? static_cast<uint32_t>(strtoul(row[10], nullptr, 10)) : 0;
+			e.custom_data         = row[11] ? row[11] : "";
+			e.ornament_icon       = row[12] ? static_cast<uint32_t>(strtoul(row[12], nullptr, 10)) : 0;
+			e.ornament_idfile     = row[13] ? static_cast<uint32_t>(strtoul(row[13], nullptr, 10)) : 0;
+			e.ornament_hero_model = row[14] ? static_cast<int32_t>(atoi(row[14])) : 0;
+			e.guid                = row[15] ? strtoull(row[15], nullptr, 10) : 0;
+
+			return e;
+		}
+
+		return NewEntity();
+	}
+
+	static int DeleteOne(
+		Database& db,
+		int sharedbank_id
+	)
+	{
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"DELETE FROM {} WHERE {} = {}",
+				TableName(),
+				PrimaryKey(),
+				sharedbank_id
+			)
+		);
+
+		return (results.Success() ? results.RowsAffected() : 0);
+	}
+
+	static int UpdateOne(
+		Database& db,
+		const Sharedbank &e
+	)
+	{
+		std::vector<std::string> v;
+
+		auto columns = Columns();
+
+		v.push_back(columns[0] + " = " + std::to_string(e.account_id));
+		v.push_back(columns[1] + " = " + std::to_string(e.slot_id));
+		v.push_back(columns[2] + " = " + std::to_string(e.item_id));
+		v.push_back(columns[3] + " = " + std::to_string(e.charges));
+		v.push_back(columns[4] + " = " + std::to_string(e.color));
+		v.push_back(columns[5] + " = " + std::to_string(e.augment_one));
+		v.push_back(columns[6] + " = " + std::to_string(e.augment_two));
+		v.push_back(columns[7] + " = " + std::to_string(e.augment_three));
+		v.push_back(columns[8] + " = " + std::to_string(e.augment_four));
+		v.push_back(columns[9] + " = " + std::to_string(e.augment_five));
+		v.push_back(columns[10] + " = " + std::to_string(e.augment_six));
+		v.push_back(columns[11] + " = '" + Strings::Escape(e.custom_data) + "'");
+		v.push_back(columns[12] + " = " + std::to_string(e.ornament_icon));
+		v.push_back(columns[13] + " = " + std::to_string(e.ornament_idfile));
+		v.push_back(columns[14] + " = " + std::to_string(e.ornament_hero_model));
+		v.push_back(columns[15] + " = " + std::to_string(e.guid));
+
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"UPDATE {} SET {} WHERE {} = {}",
+				TableName(),
+				Strings::Implode(", ", v),
+				PrimaryKey(),
+				e.account_id
+			)
+		);
+
+		return (results.Success() ? results.RowsAffected() : 0);
+	}
+
+	static Sharedbank InsertOne(
+		Database& db,
+		Sharedbank e
+	)
+	{
+		std::vector<std::string> v;
+
+		v.push_back(std::to_string(e.account_id));
+		v.push_back(std::to_string(e.slot_id));
+		v.push_back(std::to_string(e.item_id));
+		v.push_back(std::to_string(e.charges));
+		v.push_back(std::to_string(e.color));
+		v.push_back(std::to_string(e.augment_one));
+		v.push_back(std::to_string(e.augment_two));
+		v.push_back(std::to_string(e.augment_three));
+		v.push_back(std::to_string(e.augment_four));
+		v.push_back(std::to_string(e.augment_five));
+		v.push_back(std::to_string(e.augment_six));
+		v.push_back("'" + Strings::Escape(e.custom_data) + "'");
+		v.push_back(std::to_string(e.ornament_icon));
+		v.push_back(std::to_string(e.ornament_idfile));
+		v.push_back(std::to_string(e.ornament_hero_model));
+		v.push_back(std::to_string(e.guid));
+
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"{} VALUES ({})",
+				BaseInsert(),
+				Strings::Implode(",", v)
+			)
+		);
+
+		if (results.Success()) {
+			e.account_id = results.LastInsertedID();
+			return e;
+		}
+
+		e = NewEntity();
+
+		return e;
+	}
+
+	static int InsertMany(
+		Database& db,
+		const std::vector<Sharedbank> &entries
+	)
+	{
+		std::vector<std::string> insert_chunks;
+
+		for (auto &e: entries) {
+			std::vector<std::string> v;
+
+			v.push_back(std::to_string(e.account_id));
+			v.push_back(std::to_string(e.slot_id));
+			v.push_back(std::to_string(e.item_id));
+			v.push_back(std::to_string(e.charges));
+			v.push_back(std::to_string(e.color));
+			v.push_back(std::to_string(e.augment_one));
+			v.push_back(std::to_string(e.augment_two));
+			v.push_back(std::to_string(e.augment_three));
+			v.push_back(std::to_string(e.augment_four));
+			v.push_back(std::to_string(e.augment_five));
+			v.push_back(std::to_string(e.augment_six));
+			v.push_back("'" + Strings::Escape(e.custom_data) + "'");
+			v.push_back(std::to_string(e.ornament_icon));
+			v.push_back(std::to_string(e.ornament_idfile));
+			v.push_back(std::to_string(e.ornament_hero_model));
+			v.push_back(std::to_string(e.guid));
+
+			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<Sharedbank> All(Database& db)
+	{
+		std::vector<Sharedbank> all_entries;
+
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"{}",
+				BaseSelect()
+			)
+		);
+
+		all_entries.reserve(results.RowCount());
+
+		for (auto row = results.begin(); row != results.end(); ++row) {
+			Sharedbank e{};
+
+			e.account_id          = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.slot_id             = row[1] ? static_cast<uint32_t>(strtoul(row[1], nullptr, 10)) : 0;
+			e.item_id             = row[2] ? static_cast<uint32_t>(strtoul(row[2], nullptr, 10)) : 0;
+			e.charges             = row[3] ? static_cast<uint16_t>(strtoul(row[3], nullptr, 10)) : 0;
+			e.color               = row[4] ? static_cast<uint32_t>(strtoul(row[4], nullptr, 10)) : 0;
+			e.augment_one         = row[5] ? static_cast<uint32_t>(strtoul(row[5], nullptr, 10)) : 0;
+			e.augment_two         = row[6] ? static_cast<uint32_t>(strtoul(row[6], nullptr, 10)) : 0;
+			e.augment_three       = row[7] ? static_cast<uint32_t>(strtoul(row[7], nullptr, 10)) : 0;
+			e.augment_four        = row[8] ? static_cast<uint32_t>(strtoul(row[8], nullptr, 10)) : 0;
+			e.augment_five        = row[9] ? static_cast<uint32_t>(strtoul(row[9], nullptr, 10)) : 0;
+			e.augment_six         = row[10] ? static_cast<uint32_t>(strtoul(row[10], nullptr, 10)) : 0;
+			e.custom_data         = row[11] ? row[11] : "";
+			e.ornament_icon       = row[12] ? static_cast<uint32_t>(strtoul(row[12], nullptr, 10)) : 0;
+			e.ornament_idfile     = row[13] ? static_cast<uint32_t>(strtoul(row[13], nullptr, 10)) : 0;
+			e.ornament_hero_model = row[14] ? static_cast<int32_t>(atoi(row[14])) : 0;
+			e.guid                = row[15] ? strtoull(row[15], nullptr, 10) : 0;
+
+			all_entries.push_back(e);
+		}
+
+		return all_entries;
+	}
+
+	static std::vector<Sharedbank> GetWhere(Database& db, const std::string &where_filter)
+	{
+		std::vector<Sharedbank> 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) {
+			Sharedbank e{};
+
+			e.account_id          = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.slot_id             = row[1] ? static_cast<uint32_t>(strtoul(row[1], nullptr, 10)) : 0;
+			e.item_id             = row[2] ? static_cast<uint32_t>(strtoul(row[2], nullptr, 10)) : 0;
+			e.charges             = row[3] ? static_cast<uint16_t>(strtoul(row[3], nullptr, 10)) : 0;
+			e.color               = row[4] ? static_cast<uint32_t>(strtoul(row[4], nullptr, 10)) : 0;
+			e.augment_one         = row[5] ? static_cast<uint32_t>(strtoul(row[5], nullptr, 10)) : 0;
+			e.augment_two         = row[6] ? static_cast<uint32_t>(strtoul(row[6], nullptr, 10)) : 0;
+			e.augment_three       = row[7] ? static_cast<uint32_t>(strtoul(row[7], nullptr, 10)) : 0;
+			e.augment_four        = row[8] ? static_cast<uint32_t>(strtoul(row[8], nullptr, 10)) : 0;
+			e.augment_five        = row[9] ? static_cast<uint32_t>(strtoul(row[9], nullptr, 10)) : 0;
+			e.augment_six         = row[10] ? static_cast<uint32_t>(strtoul(row[10], nullptr, 10)) : 0;
+			e.custom_data         = row[11] ? row[11] : "";
+			e.ornament_icon       = row[12] ? static_cast<uint32_t>(strtoul(row[12], nullptr, 10)) : 0;
+			e.ornament_idfile     = row[13] ? static_cast<uint32_t>(strtoul(row[13], nullptr, 10)) : 0;
+			e.ornament_hero_model = row[14] ? static_cast<int32_t>(atoi(row[14])) : 0;
+			e.guid                = row[15] ? strtoull(row[15], nullptr, 10) : 0;
+
+			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 Sharedbank &e
+	)
+	{
+		std::vector<std::string> v;
+
+		v.push_back(std::to_string(e.account_id));
+		v.push_back(std::to_string(e.slot_id));
+		v.push_back(std::to_string(e.item_id));
+		v.push_back(std::to_string(e.charges));
+		v.push_back(std::to_string(e.color));
+		v.push_back(std::to_string(e.augment_one));
+		v.push_back(std::to_string(e.augment_two));
+		v.push_back(std::to_string(e.augment_three));
+		v.push_back(std::to_string(e.augment_four));
+		v.push_back(std::to_string(e.augment_five));
+		v.push_back(std::to_string(e.augment_six));
+		v.push_back("'" + Strings::Escape(e.custom_data) + "'");
+		v.push_back(std::to_string(e.ornament_icon));
+		v.push_back(std::to_string(e.ornament_idfile));
+		v.push_back(std::to_string(e.ornament_hero_model));
+		v.push_back(std::to_string(e.guid));
+
+		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<Sharedbank> &entries
+	)
+	{
+		std::vector<std::string> insert_chunks;
+
+		for (auto &e: entries) {
+			std::vector<std::string> v;
+
+			v.push_back(std::to_string(e.account_id));
+			v.push_back(std::to_string(e.slot_id));
+			v.push_back(std::to_string(e.item_id));
+			v.push_back(std::to_string(e.charges));
+			v.push_back(std::to_string(e.color));
+			v.push_back(std::to_string(e.augment_one));
+			v.push_back(std::to_string(e.augment_two));
+			v.push_back(std::to_string(e.augment_three));
+			v.push_back(std::to_string(e.augment_four));
+			v.push_back(std::to_string(e.augment_five));
+			v.push_back(std::to_string(e.augment_six));
+			v.push_back("'" + Strings::Escape(e.custom_data) + "'");
+			v.push_back(std::to_string(e.ornament_icon));
+			v.push_back(std::to_string(e.ornament_idfile));
+			v.push_back(std::to_string(e.ornament_hero_model));
+			v.push_back(std::to_string(e.guid));
+
+			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_SHAREDBANK_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/sharedbank_repository.h

@@ -3,310 +3,47 @@
 
 #include "../database.h"
 #include "../strings.h"
+#include "base/base_sharedbank_repository.h"
 
-class SharedbankRepository {
+class SharedbankRepository: public BaseSharedbankRepository {
 public:
-	struct Sharedbank {
-		int         acctid;
-		int         slotid;
-		int         itemid;
-		int16       charges;
-		int         augslot1;
-		int         augslot2;
-		int         augslot3;
-		int         augslot4;
-		int         augslot5;
-		int         augslot6;
-		std::string custom_data;
-	};
 
-	static std::string PrimaryKey()
-	{
-		return std::string("");
-	}
+    /**
+     * 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
+     *
+     * SharedbankRepository::GetByZoneAndVersion(int zone_id, int zone_version)
+     * SharedbankRepository::GetWhereNeverExpires()
+     * SharedbankRepository::GetWhereXAndY()
+     * SharedbankRepository::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
+     */
 
-	static std::vector<std::string> Columns()
-	{
-		return {
-			"acctid",
-			"slotid",
-			"itemid",
-			"charges",
-			"augslot1",
-			"augslot2",
-			"augslot3",
-			"augslot4",
-			"augslot5",
-			"augslot6",
-			"custom_data",
-		};
-	}
-
-	static std::string ColumnsRaw()
-	{
-		return std::string(Strings::Implode(", ", Columns()));
-	}
-
-	static std::string InsertColumnsRaw()
-	{
-		std::vector<std::string> insert_columns;
-
-		for (auto &column : Columns()) {
-			if (column == PrimaryKey()) {
-				continue;
-			}
-
-			insert_columns.push_back(column);
-		}
-
-		return std::string(Strings::Implode(", ", insert_columns));
-	}
-
-	static std::string TableName()
-	{
-		return std::string("sharedbank");
-	}
-
-	static std::string BaseSelect()
-	{
-		return fmt::format(
-			"SELECT {} FROM {}",
-			ColumnsRaw(),
-			TableName()
-		);
-	}
-
-	static std::string BaseInsert()
-	{
-		return fmt::format(
-			"INSERT INTO {} ({}) ",
-			TableName(),
-			InsertColumnsRaw()
-		);
-	}
-
-	static Sharedbank NewEntity()
-	{
-		Sharedbank entry{};
-
-		entry.acctid      = 0;
-		entry.slotid      = 0;
-		entry.itemid      = 0;
-		entry.charges     = 0;
-		entry.augslot1    = 0;
-		entry.augslot2    = 0;
-		entry.augslot3    = 0;
-		entry.augslot4    = 0;
-		entry.augslot5    = 0;
-		entry.augslot6    = 0;
-		entry.custom_data = 0;
-
-		return entry;
-	}
-
-	static Sharedbank GetSharedbankEntry(
-		const std::vector<Sharedbank> &sharedbanks,
-		int sharedbank_id
-	)
-	{
-		for (auto &sharedbank : sharedbanks) {
-			if (sharedbank. == sharedbank_id) {
-				return sharedbank;
-			}
-		}
-
-		return NewEntity();
-	}
-
-	static Sharedbank FindOne(
-		int sharedbank_id
-	)
-	{
-		auto results = database.QueryDatabase(
-			fmt::format(
-				"{} WHERE id = {} LIMIT 1",
-				BaseSelect(),
-				sharedbank_id
-			)
-		);
-
-		auto row = results.begin();
-		if (results.RowCount() == 1) {
-			Sharedbank entry{};
-
-			entry.acctid      = atoi(row[0]);
-			entry.slotid      = atoi(row[1]);
-			entry.itemid      = atoi(row[2]);
-			entry.charges     = atoi(row[3]);
-			entry.augslot1    = atoi(row[4]);
-			entry.augslot2    = atoi(row[5]);
-			entry.augslot3    = atoi(row[6]);
-			entry.augslot4    = atoi(row[7]);
-			entry.augslot5    = atoi(row[8]);
-			entry.augslot6    = atoi(row[9]);
-			entry.custom_data = row[10];
-
-			return entry;
-		}
-
-		return NewEntity();
-	}
-
-	static int DeleteOne(
-		int sharedbank_id
-	)
-	{
-		auto results = database.QueryDatabase(
-			fmt::format(
-				"DELETE FROM {} WHERE {} = {}",
-				TableName(),
-				PrimaryKey(),
-				sharedbank_id
-			)
-		);
-
-		return (results.Success() ? results.RowsAffected() : 0);
-	}
-
-	static int UpdateOne(
-		Sharedbank sharedbank_entry
-	)
-	{
-		std::vector<std::string> update_values;
-
-		auto columns = Columns();
-
-		update_values.push_back(columns[0] + " = " + std::to_string(sharedbank_entry.acctid));
-		update_values.push_back(columns[1] + " = " + std::to_string(sharedbank_entry.slotid));
-		update_values.push_back(columns[2] + " = " + std::to_string(sharedbank_entry.itemid));
-		update_values.push_back(columns[3] + " = " + std::to_string(sharedbank_entry.charges));
-		update_values.push_back(columns[4] + " = " + std::to_string(sharedbank_entry.augslot1));
-		update_values.push_back(columns[5] + " = " + std::to_string(sharedbank_entry.augslot2));
-		update_values.push_back(columns[6] + " = " + std::to_string(sharedbank_entry.augslot3));
-		update_values.push_back(columns[7] + " = " + std::to_string(sharedbank_entry.augslot4));
-		update_values.push_back(columns[8] + " = " + std::to_string(sharedbank_entry.augslot5));
-		update_values.push_back(columns[9] + " = " + std::to_string(sharedbank_entry.augslot6));
-		update_values.push_back(columns[10] + " = '" + Strings::Escape(sharedbank_entry.custom_data) + "'");
-
-		auto results = database.QueryDatabase(
-			fmt::format(
-				"UPDATE {} SET {} WHERE {} = {}",
-				TableName(),
-				Strings::Implode(", ", update_values),
-				PrimaryKey(),
-				sharedbank_entry.
-			)
-		);
-
-		return (results.Success() ? results.RowsAffected() : 0);
-	}
-
-	static Sharedbank InsertOne(
-		Sharedbank sharedbank_entry
-	)
-	{
-		std::vector<std::string> insert_values;
-
-		insert_values.push_back(std::to_string(sharedbank_entry.acctid));
-		insert_values.push_back(std::to_string(sharedbank_entry.slotid));
-		insert_values.push_back(std::to_string(sharedbank_entry.itemid));
-		insert_values.push_back(std::to_string(sharedbank_entry.charges));
-		insert_values.push_back(std::to_string(sharedbank_entry.augslot1));
-		insert_values.push_back(std::to_string(sharedbank_entry.augslot2));
-		insert_values.push_back(std::to_string(sharedbank_entry.augslot3));
-		insert_values.push_back(std::to_string(sharedbank_entry.augslot4));
-		insert_values.push_back(std::to_string(sharedbank_entry.augslot5));
-		insert_values.push_back(std::to_string(sharedbank_entry.augslot6));
-		insert_values.push_back("'" + Strings::Escape(sharedbank_entry.custom_data) + "'");
-
-		auto results = database.QueryDatabase(
-			fmt::format(
-				"{} VALUES ({})",
-				BaseInsert(),
-				Strings::Implode(",", insert_values)
-			)
-		);
-
-		if (results.Success()) {
-			sharedbank_entry.id = results.LastInsertedID();
-			return sharedbank_entry;
-		}
-
-		sharedbank_entry = InstanceListRepository::NewEntity();
-
-		return sharedbank_entry;
-	}
-
-	static int InsertMany(
-		std::vector<Sharedbank> sharedbank_entries
-	)
-	{
-		std::vector<std::string> insert_chunks;
-
-		for (auto &sharedbank_entry: sharedbank_entries) {
-			std::vector<std::string> insert_values;
-
-			insert_values.push_back(std::to_string(sharedbank_entry.acctid));
-			insert_values.push_back(std::to_string(sharedbank_entry.slotid));
-			insert_values.push_back(std::to_string(sharedbank_entry.itemid));
-			insert_values.push_back(std::to_string(sharedbank_entry.charges));
-			insert_values.push_back(std::to_string(sharedbank_entry.augslot1));
-			insert_values.push_back(std::to_string(sharedbank_entry.augslot2));
-			insert_values.push_back(std::to_string(sharedbank_entry.augslot3));
-			insert_values.push_back(std::to_string(sharedbank_entry.augslot4));
-			insert_values.push_back(std::to_string(sharedbank_entry.augslot5));
-			insert_values.push_back(std::to_string(sharedbank_entry.augslot6));
-			insert_values.push_back("'" + Strings::Escape(sharedbank_entry.custom_data) + "'");
-
-			insert_chunks.push_back("(" + Strings::Implode(",", insert_values) + ")");
-		}
-
-		std::vector<std::string> insert_values;
-
-		auto results = database.QueryDatabase(
-			fmt::format(
-				"{} VALUES {}",
-				BaseInsert(),
-				Strings::Implode(",", insert_chunks)
-			)
-		);
-
-		return (results.Success() ? results.RowsAffected() : 0);
-	}
-
-	static std::vector<Sharedbank> All()
-	{
-		std::vector<Sharedbank> all_entries;
-
-		auto results = database.QueryDatabase(
-			fmt::format(
-				"{}",
-				BaseSelect()
-			)
-		);
-
-		all_entries.reserve(results.RowCount());
-
-		for (auto row = results.begin(); row != results.end(); ++row) {
-			Sharedbank entry{};
-
-			entry.acctid      = atoi(row[0]);
-			entry.slotid      = atoi(row[1]);
-			entry.itemid      = atoi(row[2]);
-			entry.charges     = atoi(row[3]);
-			entry.augslot1    = atoi(row[4]);
-			entry.augslot2    = atoi(row[5]);
-			entry.augslot3    = atoi(row[6]);
-			entry.augslot4    = atoi(row[7]);
-			entry.augslot5    = atoi(row[8]);
-			entry.augslot6    = atoi(row[9]);
-			entry.custom_data = row[10];
-
-			all_entries.push_back(entry);
-		}
-
-		return all_entries;
-	}
+	// Custom extended repository methods here
 
 };
 

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, "RoF2", "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)

common/shareddb.cpp

@@ -48,6 +48,7 @@
 #include "repositories/skill_caps_repository.h"
 #include "repositories/inventory_repository.h"
 #include "repositories/books_repository.h"
+#include "repositories/sharedbank_repository.h"
 
 namespace ItemField
 {
@@ -190,242 +191,268 @@ SharedDatabase::MailKeys SharedDatabase::GetMailKey(int character_id)
 	return MailKeys{};
 }
 
-bool SharedDatabase::SaveCursor(uint32 char_id, std::list<EQ::ItemInstance*>::const_iterator &start, std::list<EQ::ItemInstance*>::const_iterator &end)
+bool SharedDatabase::SaveCursor(
+	uint32 char_id,
+	std::list<EQ::ItemInstance*>::const_iterator& start,
+	std::list<EQ::ItemInstance*>::const_iterator& end
+)
 {
-	// Delete cursor items
-	const std::string query = StringFormat("DELETE FROM inventory WHERE charid = %i "
-	                                       "AND ((slotid >= 8000 AND slotid <= 8999) "
-	                                       "OR slotid = %i OR (slotid >= %i AND slotid <= %i) )",
-	                                       char_id, EQ::invslot::slotCursor,
-	                                       EQ::invbag::CURSOR_BAG_BEGIN, EQ::invbag::CURSOR_BAG_END);
-	const auto results = QueryDatabase(query);
-    if (!results.Success()) {
-        std::cout << "Clearing cursor failed: " << results.ErrorMessage() << std::endl;
-        return false;
-    }
+	const int deleted = InventoryRepository::DeleteWhere(
+		*this,
+		fmt::format(
+			"`character_id` = {} AND (`slot_id` = {} OR `slot_id` BETWEEN {} AND {})",
+			char_id,
+			EQ::invslot::slotCursor,
+			EQ::invbag::CURSOR_BAG_BEGIN,
+			EQ::invbag::CURSOR_BAG_END
+		)
+	);
 
-    int i = 8000;
-    for(auto& it = start; it != end; ++it, i++) {
-		if (i > 8999) { break; } // shouldn't be anything in the queue that indexes this high
-		const EQ::ItemInstance *inst = *it;
-		const int16 use_slot = (i == 8000) ? EQ::invslot::slotCursor : i;
+	int16 i = EQ::invslot::slotCursor;
+	for (auto& it = start; it != end; ++it, i++) {
+		// shouldn't be anything in the queue that indexes this high
+		if (i > EQ::invbag::CURSOR_BAG_END) {
+			break;
+		}
+
+		const EQ::ItemInstance* inst   = *it;
+		const int16           use_slot = i == EQ::invslot::slotCursor ? EQ::invslot::slotCursor : i;
 		if (!SaveInventory(char_id, inst, use_slot)) {
 			return false;
 		}
-    }
+	}
 
 	return true;
 }
 
 bool SharedDatabase::VerifyInventory(uint32 account_id, int16 slot_id, const EQ::ItemInstance* inst)
 {
-	// Delete cursor items
-	const std::string query = StringFormat("SELECT itemid, charges FROM sharedbank "
-	                                       "WHERE acctid = %d AND slotid = %d",
-	                                       account_id, slot_id);
-    auto results = QueryDatabase(query);
-	if (!results.Success()) {
-		//returning true is less harmful in the face of a query error
-		return true;
+	if (!inst || !inst->GetItem()) {
+		return false;
 	}
 
-	if (results.RowCount() == 0)
-        return false;
+	const auto& l = SharedbankRepository::GetWhere(
+		*this,
+		fmt::format(
+			"`account_id` = {} AND `slot_id` = {} LIMIT 1",
+			account_id,
+			slot_id
+		)
+	);
 
-	auto& row = results.begin();
+	if (l.empty()) {
+		return false;
+	}
 
-	const uint32 id = Strings::ToUnsignedInt(row[0]);
-	const uint16 charges = Strings::ToUnsignedInt(row[1]);
+	const auto& e = l.front();
 
-    uint16 expect_charges;
+	uint16 expect_charges = inst->GetCharges() >= 0 ? inst->GetCharges() : std::numeric_limits<int16>::max();
 
-    if(inst->GetCharges() >= 0)
-        expect_charges = inst->GetCharges();
-    else
-        expect_charges = 0x7FFF;
-
-    if(id != inst->GetItem()->ID || charges != expect_charges)
-        return false;
-
-	return true;
+	return e.item_id == inst->GetID() && e.charges == expect_charges;
 }
 
-bool SharedDatabase::SaveInventory(uint32 char_id, const EQ::ItemInstance* inst, int16 slot_id) {
-
-	//never save tribute slots:
-	if (slot_id >= EQ::invslot::TRIBUTE_BEGIN && slot_id <= EQ::invslot::TRIBUTE_END)
-		return true;
-	if (slot_id >= EQ::invslot::GUILD_TRIBUTE_BEGIN && slot_id <= EQ::invslot::GUILD_TRIBUTE_END)
+bool SharedDatabase::SaveInventory(uint32 char_id, const EQ::ItemInstance* inst, int16 slot_id)
+{
+	// Don't save any Tribute slots
+	if (
+		EQ::ValueWithin(slot_id, EQ::invslot::GUILD_TRIBUTE_BEGIN, EQ::invslot::GUILD_TRIBUTE_END) ||
+		EQ::ValueWithin(slot_id, EQ::invslot::TRIBUTE_BEGIN, EQ::invslot::TRIBUTE_END)
+	) {
 		return true;
+	}
 
-	if (slot_id >= EQ::invslot::SHARED_BANK_BEGIN && slot_id <= EQ::invbag::SHARED_BANK_BAGS_END) {
-        // Shared bank inventory
+	if (
+		EQ::ValueWithin(slot_id, EQ::invslot::SHARED_BANK_BEGIN, EQ::invslot::SHARED_BANK_END) ||
+		EQ::ValueWithin(slot_id, EQ::invbag::SHARED_BANK_BAGS_BEGIN, EQ::invbag::SHARED_BANK_BAGS_END)
+	) {
 		if (!inst) {
 			return DeleteSharedBankSlot(char_id, slot_id);
-		}
-		else {
+		} else {
 			// Needed to clear out bag slots that 'REPLACE' in UpdateSharedBankSlot does not overwrite..otherwise, duplication occurs
 			// (This requires that parent then child items be sent..which should be how they are currently passed)
-			if (EQ::InventoryProfile::SupportsContainers(slot_id))
+			if (EQ::InventoryProfile::SupportsContainers(slot_id)) {
 				DeleteSharedBankSlot(char_id, slot_id);
+			}
+
 			return UpdateSharedBankSlot(char_id, inst, slot_id);
 		}
-	}
-	else if (!inst) { // All other inventory
+	} else if (!inst) { // All other inventory
 		return DeleteInventorySlot(char_id, slot_id);
 	}
 
 	// Needed to clear out bag slots that 'REPLACE' in UpdateInventorySlot does not overwrite..otherwise, duplication occurs
 	// (This requires that parent then child items be sent..which should be how they are currently passed)
-	if (EQ::InventoryProfile::SupportsContainers(slot_id))
+	if (EQ::InventoryProfile::SupportsContainers(slot_id)) {
 		DeleteInventorySlot(char_id, slot_id);
-    return UpdateInventorySlot(char_id, inst, slot_id);
-}
-
-bool SharedDatabase::UpdateInventorySlot(uint32 char_id, const EQ::ItemInstance* inst, int16 slot_id) {
-	// need to check 'inst' argument for valid pointer
-
-	uint32 augslot[EQ::invaug::SOCKET_COUNT] = { 0, 0, 0, 0, 0, 0 };
-	if (inst->IsClassCommon()) {
-		for (int i = EQ::invaug::SOCKET_BEGIN; i <= EQ::invaug::SOCKET_END; i++) {
-			const EQ::ItemInstance *auginst = inst->GetItem(i);
-			augslot[i] = (auginst && auginst->GetItem()) ? auginst->GetItem()->ID : 0;
-		}
 	}
 
-    uint16 charges;
-	if(inst->GetCharges() >= 0)
-		charges = inst->GetCharges();
-	else
-		charges = 0x7FFF;
-
-	// Update/Insert item
-	const std::string query = StringFormat("REPLACE INTO inventory "
-	                                       "(charid, slotid, itemid, charges, instnodrop, custom_data, color, "
-	                                       "augslot1, augslot2, augslot3, augslot4, augslot5, augslot6, ornamenticon, ornamentidfile, ornament_hero_model, guid) "
-	                                       "VALUES( %lu, %lu, %lu, %lu, %lu, '%s', %lu, "
-	                                       "%lu, %lu, %lu, %lu, %lu, %lu, %lu, %lu, %lu, %lu)",
-	                                       static_cast<unsigned long>(char_id), static_cast<unsigned long>(slot_id), static_cast<unsigned long>(inst->GetItem()->ID),
-	                                       static_cast<unsigned long>(charges), static_cast<unsigned long>(inst->IsAttuned() ? 1 : 0),
-	                                       inst->GetCustomDataString().c_str(), static_cast<unsigned long>(inst->GetColor()),
-	                                       static_cast<unsigned long>(augslot[0]), static_cast<unsigned long>(augslot[1]), static_cast<unsigned long>(augslot[2]),
-	                                       static_cast<unsigned long>(augslot[3]), static_cast<unsigned long>(augslot[4]), static_cast<unsigned long>(augslot[5]), static_cast<unsigned long>(inst->GetOrnamentationIcon()),
-	                                       static_cast<unsigned long>(inst->GetOrnamentationIDFile()), static_cast<unsigned long>(inst->GetOrnamentHeroModel()), inst->GetSerialNumber());
-	const auto results = QueryDatabase(query);
-
-    // Save bag contents, if slot supports bag contents
-	if (inst->IsClassBag() && EQ::InventoryProfile::SupportsContainers(slot_id))
-		// Limiting to bag slot count will get rid of 'hidden' duplicated items and 'Invalid Slot ID'
-		// messages through attrition (and the modded code in SaveInventory)
-		for (uint8 idx = EQ::invbag::SLOT_BEGIN; idx < inst->GetItem()->BagSlots && idx <= EQ::invbag::SLOT_END; idx++) {
-			const EQ::ItemInstance* baginst = inst->GetItem(idx);
-			SaveInventory(char_id, baginst, EQ::InventoryProfile::CalcSlotId(slot_id, idx));
-		}
-
-    if (!results.Success()) {
-        return false;
-    }
-
-	return true;
+	return UpdateInventorySlot(char_id, inst, slot_id);
 }
 
-bool SharedDatabase::UpdateSharedBankSlot(uint32 char_id, const EQ::ItemInstance* inst, int16 slot_id) {
-	// need to check 'inst' argument for valid pointer
-
-	uint32 augslot[EQ::invaug::SOCKET_COUNT] = { 0, 0, 0, 0, 0, 0 };
-	if (inst->IsClassCommon()) {
-		for (int i = EQ::invaug::SOCKET_BEGIN; i <= EQ::invaug::SOCKET_END; i++) {
-			const EQ::ItemInstance *auginst = inst->GetItem(i);
-			augslot[i] = (auginst && auginst->GetItem()) ? auginst->GetItem()->ID : 0;
-		}
+bool SharedDatabase::UpdateInventorySlot(uint32 char_id, const EQ::ItemInstance* inst, int16 slot_id)
+{
+	if (!inst || !inst->GetItem()) {
+		return false;
 	}
 
-// Update/Insert item
-	const uint32 account_id = GetAccountIDByChar(char_id);
-    uint16 charges;
-    if(inst->GetCharges() >= 0)
-        charges = inst->GetCharges();
-    else
-        charges = 0x7FFF;
+	std::vector<uint32> augment_ids = inst->GetAugmentIDs();
 
-	const std::string query = StringFormat("REPLACE INTO sharedbank "
-	                                       "(acctid, slotid, itemid, charges, custom_data, "
-	                                       "augslot1, augslot2, augslot3, augslot4, augslot5, augslot6) "
-	                                       "VALUES( %lu, %lu, %lu, %lu, '%s', "
-	                                       "%lu, %lu, %lu, %lu, %lu, %lu)",
-	                                       static_cast<unsigned long>(account_id), static_cast<unsigned long>(slot_id), static_cast<unsigned long>(inst->GetItem()->ID),
-	                                       static_cast<unsigned long>(charges), inst->GetCustomDataString().c_str(), static_cast<unsigned long>(augslot[0]),
-	                                       static_cast<unsigned long>(augslot[1]), static_cast<unsigned long>(augslot[2]), static_cast<unsigned long>(augslot[3]), static_cast<unsigned long>(augslot[4]),
-	                                       static_cast<unsigned long>(augslot[5]));
-	const auto results = QueryDatabase(query);
+	uint16 charges = inst->GetCharges() >= 0 ? inst->GetCharges() : std::numeric_limits<int16>::max();
 
-    // Save bag contents, if slot supports bag contents
+	auto e = InventoryRepository::NewEntity();
+
+	e.character_id        = char_id;
+	e.slot_id             = slot_id;
+	e.item_id             = inst->GetID();
+	e.charges             = charges;
+	e.color               = inst->GetColor();
+	e.augment_one         = augment_ids[0];
+	e.augment_two         = augment_ids[1];
+	e.augment_three       = augment_ids[2];
+	e.augment_four        = augment_ids[3];
+	e.augment_five        = augment_ids[4];
+	e.augment_six         = augment_ids[5];
+	e.instnodrop          = inst->IsAttuned() ? 1 : 0;
+	e.custom_data         = inst->GetCustomDataString();
+	e.ornament_icon       = inst->GetOrnamentationIcon();
+	e.ornament_idfile     = inst->GetOrnamentationIDFile();
+	e.ornament_hero_model = inst->GetOrnamentHeroModel();
+	e.guid                = inst->GetSerialNumber();
+
+	const int replaced = InventoryRepository::ReplaceOne(*this, e);
+
+	// Save bag contents, if slot supports bag contents
 	if (inst->IsClassBag() && EQ::InventoryProfile::SupportsContainers(slot_id)) {
 		// Limiting to bag slot count will get rid of 'hidden' duplicated items and 'Invalid Slot ID'
 		// messages through attrition (and the modded code in SaveInventory)
-		for (uint8 idx = EQ::invbag::SLOT_BEGIN; idx < inst->GetItem()->BagSlots && idx <= EQ::invbag::SLOT_END; idx++) {
-			const EQ::ItemInstance* baginst = inst->GetItem(idx);
-			SaveInventory(char_id, baginst, EQ::InventoryProfile::CalcSlotId(slot_id, idx));
+		for (
+			uint8 i = EQ::invbag::SLOT_BEGIN;
+			i < inst->GetItem()->BagSlots && i <= EQ::invbag::SLOT_END;
+			i++
+		) {
+			const EQ::ItemInstance* bag_inst = inst->GetItem(i);
+			SaveInventory(char_id, bag_inst, EQ::InventoryProfile::CalcSlotId(slot_id, i));
 		}
 	}
 
-    if (!results.Success()) {
-        return false;
-    }
-
-	return true;
+	return replaced;
 }
 
-bool SharedDatabase::DeleteInventorySlot(uint32 char_id, int16 slot_id) {
+bool SharedDatabase::UpdateSharedBankSlot(uint32 char_id, const EQ::ItemInstance* inst, int16 slot_id)
+{
+	if (!inst || !inst->GetItem()) {
+		return false;
+	}
 
-	// Delete item
-	std::string query = StringFormat("DELETE FROM inventory WHERE charid = %i AND slotid = %i", char_id, slot_id);
-    auto results = QueryDatabase(query);
-    if (!results.Success()) {
-        return false;
-    }
+	std::vector<uint32> augment_ids = inst->GetAugmentIDs();
 
-    // Delete bag slots, if need be
-	if (!EQ::InventoryProfile::SupportsContainers(slot_id))
-        return true;
+	uint16 charges = inst->GetCharges() >= 0 ? inst->GetCharges() : std::numeric_limits<int16>::max();
 
-	const int16 base_slot_id = EQ::InventoryProfile::CalcSlotId(slot_id, EQ::invbag::SLOT_BEGIN);
-    query = StringFormat("DELETE FROM inventory WHERE charid = %i AND slotid >= %i AND slotid < %i",
-                        char_id, base_slot_id, (base_slot_id+10));
-    results = QueryDatabase(query);
-    if (!results.Success()) {
-        return false;
-    }
+	const uint32 account_id = GetAccountIDByChar(char_id);
 
-    // @merth: need to delete augments here
-    return true;
+	auto e = SharedbankRepository::NewEntity();
+
+	e.account_id          = account_id;
+	e.slot_id             = slot_id;
+	e.item_id             = inst->GetID();
+	e.charges             = charges;
+	e.color               = inst->GetColor();
+	e.augment_one         = augment_ids[0];
+	e.augment_two         = augment_ids[1];
+	e.augment_three       = augment_ids[2];
+	e.augment_four        = augment_ids[3];
+	e.augment_five        = augment_ids[4];
+	e.augment_six         = augment_ids[5];
+	e.custom_data         = inst->GetCustomDataString();
+	e.ornament_icon       = inst->GetOrnamentationIcon();
+	e.ornament_idfile     = inst->GetOrnamentationIDFile();
+	e.ornament_hero_model = inst->GetOrnamentHeroModel();
+	e.guid                = inst->GetSerialNumber();
+
+	const int replaced = SharedbankRepository::ReplaceOne(*this, e);
+
+	// Save bag contents, if slot supports bag contents
+	if (inst->IsClassBag() && EQ::InventoryProfile::SupportsContainers(slot_id)) {
+		// Limiting to bag slot count will get rid of 'hidden' duplicated items and 'Invalid Slot ID'
+		// messages through attrition (and the modded code in SaveInventory)
+		for (
+			uint8 i = EQ::invbag::SLOT_BEGIN;
+			i < inst->GetItem()->BagSlots && i <= EQ::invbag::SLOT_END;
+			i++
+		) {
+			const EQ::ItemInstance* bag_inst = inst->GetItem(i);
+			SaveInventory(char_id, bag_inst, EQ::InventoryProfile::CalcSlotId(slot_id, i));
+		}
+	}
+
+	return replaced;
 }
 
-bool SharedDatabase::DeleteSharedBankSlot(uint32 char_id, int16 slot_id) {
+bool SharedDatabase::DeleteInventorySlot(uint32 char_id, int16 slot_id)
+{
+	const int deleted = InventoryRepository::DeleteWhere(
+		*this,
+		fmt::format(
+			"`character_id` = {} AND `slot_id` = {}",
+			char_id,
+			slot_id
+		)
+	);
 
-    // Delete item
-    const uint32 account_id = GetAccountIDByChar(char_id);
-	std::string query = StringFormat("DELETE FROM sharedbank WHERE acctid=%i AND slotid=%i", account_id, slot_id);
-    auto results = QueryDatabase(query);
-    if (!results.Success()) {
-        return false;
-    }
+	if (!deleted) {
+		return false;
+	}
 
 	// Delete bag slots, if need be
-	if (!EQ::InventoryProfile::SupportsContainers(slot_id))
-        return true;
+	if (!EQ::InventoryProfile::SupportsContainers(slot_id)) {
+		return true;
+	}
 
-    const int16 base_slot_id = EQ::InventoryProfile::CalcSlotId(slot_id, EQ::invbag::SLOT_BEGIN);
-    query = StringFormat("DELETE FROM sharedbank WHERE acctid = %i "
-                        "AND slotid >= %i AND slotid < %i",
-                        account_id, base_slot_id, (base_slot_id+10));
-    results = QueryDatabase(query);
-    if (!results.Success()) {
-        return false;
-    }
+	const int16 base_slot_id = EQ::InventoryProfile::CalcSlotId(slot_id, EQ::invbag::SLOT_BEGIN);
 
-    // @merth: need to delete augments here
-    return true;
+	return InventoryRepository::DeleteWhere(
+		*this,
+		fmt::format(
+			"`character_id` = {} AND `slot_id` BETWEEN {} AND {}",
+			char_id,
+			base_slot_id,
+			base_slot_id + (EQ::invbag::SLOT_COUNT - 1)
+		)
+	);
+}
+
+bool SharedDatabase::DeleteSharedBankSlot(uint32 char_id, int16 slot_id)
+{
+	const uint32 account_id = GetAccountIDByChar(char_id);
+
+	const int deleted = SharedbankRepository::DeleteWhere(
+		*this,
+		fmt::format(
+			"`account_id` = {} AND `slot_id` = {}",
+			account_id,
+			slot_id
+		)
+	);
+
+	if (!deleted) {
+		return false;
+	}
+
+	if (!EQ::InventoryProfile::SupportsContainers(slot_id)) {
+		return true;
+	}
+
+	const int16 base_slot_id = EQ::InventoryProfile::CalcSlotId(slot_id, EQ::invbag::SLOT_BEGIN);
+
+	return SharedbankRepository::DeleteWhere(
+		*this,
+		fmt::format(
+			"`account_id` = {} AND `slotid` BETWEEN {} AND {}",
+			account_id,
+			base_slot_id,
+			base_slot_id + (EQ::invbag::SLOT_COUNT - 1)
+		)
+	);
 }
 
 
@@ -550,96 +577,81 @@ bool SharedDatabase::SetStartingItems(
 // Retrieve shared bank inventory based on either account or character
 bool SharedDatabase::GetSharedBank(uint32 id, EQ::InventoryProfile *inv, bool is_charid)
 {
-	std::string query;
+	const uint32 account_id = is_charid ? GetAccountIDByChar(id) : id;
 
-	if (is_charid) {
-		query = fmt::format(
-			"SELECT sb.slotid, sb.itemid, sb.charges, "
-			"sb.augslot1, sb.augslot2, sb.augslot3, "
-			"sb.augslot4, sb.augslot5, sb.augslot6, sb.custom_data "
-			"FROM sharedbank sb INNER JOIN character_data ch "
-			"ON ch.account_id = sb.acctid WHERE ch.id = {} ORDER BY sb.slotid",
-			id
-		);
-	} else {
-		query = fmt::format(
-			"SELECT slotid, itemid, charges, "
-			"augslot1, augslot2, augslot3, "
-			"augslot4, augslot5, augslot6, custom_data "
-			"FROM sharedbank WHERE acctid = {} ORDER BY slotid",
-			id
-		);
-	}
-
-	auto results = QueryDatabase(query);
-	// If we have no results we still need to return true
-	if (!results.Success()) {
+	if (!account_id) {
 		return false;
 	}
 
-	for (auto row : results) {
-		int16 slot_id = static_cast<int16>(Strings::ToInt(row[0]));
-		uint32 item_id = Strings::ToUnsignedInt(row[1]);
-		const int16 charges = static_cast<int16>(Strings::ToInt(row[2]));
+	const auto& l = SharedbankRepository::GetWhere(
+		*this,
+		fmt::format(
+			"`account_id` = {}",
+			account_id
+		)
+	);
 
-		uint32 aug[EQ::invaug::SOCKET_COUNT];
-		aug[0] = Strings::ToUnsignedInt(row[3]);
-		aug[1] = Strings::ToUnsignedInt(row[4]);
-		aug[2] = Strings::ToUnsignedInt(row[5]);
-		aug[3] = Strings::ToUnsignedInt(row[6]);
-		aug[4] = Strings::ToUnsignedInt(row[7]);
-		aug[5] = Strings::ToUnsignedInt(row[8]);
+	if (l.empty()) {
+		return true;
+	}
 
-		const EQ::ItemData *item = GetItem(item_id);
+	for (const auto& e : l) {
+		uint32 augment_ids[EQ::invaug::SOCKET_COUNT] = {
+			e.augment_one,
+			e.augment_two,
+			e.augment_three,
+			e.augment_four,
+			e.augment_five,
+			e.augment_six
+		};
+
+		const EQ::ItemData* item = GetItem(e.item_id);
 
 		if (!item) {
 			LogError(
-				"Warning: [{}] [{}] has an invalid item_id [{}] in inventory slot [{}]",
-				is_charid ? "charid" : "acctid",
+				"Warning: {} [{}] has an invalid item_id [{}] in slot_id [{}]",
+				is_charid ? "character_id" : "account_id",
 				id,
-				item_id,
-				slot_id
+				e.item_id,
+				e.slot_id
 			);
 			continue;
 		}
 
-		auto inst = CreateBaseItem(item, charges);
+		EQ::ItemInstance* inst = CreateBaseItem(item, e.charges);
 		if (!inst) {
 			continue;
 		}
 
-		if (inst && item->IsClassCommon()) {
+		if (item->IsClassCommon()) {
 			for (int i = EQ::invaug::SOCKET_BEGIN; i <= EQ::invaug::SOCKET_END; i++) {
-				if (aug[i]) {
-					inst->PutAugment(this, i, aug[i]);
+				if (augment_ids[i]) {
+					inst->PutAugment(this, i, augment_ids[i]);
 				}
 			}
 		}
 
-		if (inst && row[9]) {
-			std::string data_str(row[9]);
-			inst->SetCustomDataString(data_str);
+		if (!e.custom_data.empty()) {
+			inst->SetCustomDataString(e.custom_data);
 		}
 
-		// theoretically inst can be nullptr ... this would be very bad ...
-		const int16 put_slot_id = inv->PutItem(slot_id, *inst);
+		const int16 put_slot_id = inv->PutItem(e.slot_id, *inst);
 		safe_delete(inst);
 
-		// Save ptr to item in inventory
 		if (put_slot_id != INVALID_INDEX) {
 			continue;
 		}
 
 		LogError(
-			"Warning: Invalid slot_id for item in shared bank inventory: [{}]=[{}], item_id=[{}], slot_id=[{}]",
-			is_charid ? "charid" : "acctid",
+			"Warning: Invalid slot_id for item in shared bank inventory for {} [{}] item_id [{}] slot_id [{}]",
+			is_charid ? "character_id" : "account_id",
 			id,
-			item_id,
-			slot_id
+			e.item_id,
+			e.slot_id
 		);
 
 		if (is_charid) {
-			SaveInventory(id, nullptr, slot_id);
+			SaveInventory(id, nullptr, e.slot_id);
 		}
 	}
 
@@ -647,72 +659,77 @@ bool SharedDatabase::GetSharedBank(uint32 id, EQ::InventoryProfile *inv, bool is
 }
 
 // Overloaded: Retrieve character inventory based on character id (zone entry)
-bool SharedDatabase::GetInventory(uint32 char_id, EQ::InventoryProfile *inv)
+bool SharedDatabase::GetInventory(uint32 char_id, EQ::InventoryProfile* inv)
 {
-	if (!char_id || !inv)
+	if (!char_id || !inv) {
 		return false;
+	}
 
 	// Retrieve character inventory
-	auto results = InventoryRepository::GetWhere(*this, fmt::format("`charid` = '{}' ORDER BY `slotid`;", char_id));
+	auto results = InventoryRepository::GetWhere(
+		*this,
+		fmt::format(
+			"`character_id` = '{}' ORDER BY `slot_id`",
+			char_id
+		)
+	);
+
 	if (results.empty()) {
 		LogError("Error loading inventory for char_id {} from the database.", char_id);
 		return false;
 	}
 
-	for (auto const &row: results) {
+	for (auto const& row: results) {
 		if (row.guid != 0) {
 			EQ::ItemInstance::AddGUIDToMap(row.guid);
 		}
 	}
 
-	const auto timestamps = GetItemRecastTimestamps(char_id);
-	auto cv_conflict      = false;
-	const auto pmask      = inv->GetLookup()->PossessionsBitmask;
-	const auto bank_size  = inv->GetLookup()->InventoryTypeSize.Bank;
+	const auto timestamps  = GetItemRecastTimestamps(char_id);
+	auto       cv_conflict = false;
+	const auto pmask       = inv->GetLookup()->PossessionsBitmask;
+	const auto bank_size   = inv->GetLookup()->InventoryTypeSize.Bank;
 
-	std::vector<InventoryRepository::Inventory> queue{};
-	for (auto &row: results) {
-		const int16 slot_id              = row.slotid;
-		const uint32 item_id             = row.itemid;
+	std::vector<InventoryRepository::Inventory> queue{ };
+	for (auto& row: results) {
+		const int16  slot_id             = row.slot_id;
+		const uint32 item_id             = row.item_id;
 		const uint16 charges             = row.charges;
 		const uint32 color               = row.color;
-		const bool instnodrop            = row.instnodrop;
-		const uint32 ornament_icon       = row.ornamenticon;
-		const uint32 ornament_idfile     = row.ornamentidfile;
+		const bool   instnodrop          = row.instnodrop;
+		const uint32 ornament_icon       = row.ornament_icon;
+		const uint32 ornament_idfile     = row.ornament_idfile;
 		const uint32 ornament_hero_model = row.ornament_hero_model;
 
-		uint32 aug[EQ::invaug::SOCKET_COUNT];
-		aug[0] = row.augslot1;
-		aug[1] = row.augslot2;
-		aug[2] = row.augslot3;
-		aug[3] = row.augslot4;
-		aug[4] = row.augslot5;
-		aug[5] = row.augslot6;
+		uint32 augment_ids[EQ::invaug::SOCKET_COUNT] = {
+			row.augment_one,
+			row.augment_two,
+			row.augment_three,
+			row.augment_four,
+			row.augment_five,
+			row.augment_six
+		};
 
-		if (slot_id <= EQ::invslot::POSSESSIONS_END && slot_id >= EQ::invslot::POSSESSIONS_BEGIN) {
+		if (EQ::ValueWithin(slot_id, EQ::invslot::POSSESSIONS_BEGIN, EQ::invslot::POSSESSIONS_END)) {
 			// Titanium thru UF check
 			if (((static_cast<uint64>(1) << slot_id) & pmask) == 0) {
 				cv_conflict = true;
 				continue;
 			}
-		}
-		else if (slot_id <= EQ::invbag::GENERAL_BAGS_END && slot_id >= EQ::invbag::GENERAL_BAGS_BEGIN) {
+		} else if (EQ::ValueWithin(slot_id, EQ::invbag::GENERAL_BAGS_BEGIN, EQ::invbag::GENERAL_BAGS_END)) {
 			// Titanium thru UF check
-			const auto parent_slot = EQ::invslot::GENERAL_BEGIN + (
-				                         (slot_id - EQ::invbag::GENERAL_BAGS_BEGIN) / EQ::invbag::SLOT_COUNT);
+			const auto parent_slot = EQ::invslot::GENERAL_BEGIN + ((slot_id - EQ::invbag::GENERAL_BAGS_BEGIN) / EQ::invbag::SLOT_COUNT);
 			if (((static_cast<uint64>(1) << parent_slot) & pmask) == 0) {
 				cv_conflict = true;
 				continue;
 			}
-		}
-		else if (slot_id <= EQ::invslot::BANK_END && slot_id >= EQ::invslot::BANK_BEGIN) {
+		} else if (EQ::ValueWithin(slot_id, EQ::invslot::BANK_BEGIN, EQ::invslot::BANK_END)) {
 			// Titanium check
 			if ((slot_id - EQ::invslot::BANK_BEGIN) >= bank_size) {
 				cv_conflict = true;
 				continue;
 			}
-		}
-		else if (slot_id <= EQ::invbag::BANK_BAGS_END && slot_id >= EQ::invbag::BANK_BAGS_BEGIN) {
+		} else if (EQ::ValueWithin(slot_id, EQ::invbag::BANK_BAGS_BEGIN, EQ::invbag::BANK_BAGS_END)) {
 			// Titanium check
 			const auto parent_index = ((slot_id - EQ::invbag::BANK_BAGS_BEGIN) / EQ::invbag::SLOT_COUNT);
 			if (parent_index >= bank_size) {
@@ -721,7 +738,7 @@ bool SharedDatabase::GetInventory(uint32 char_id, EQ::InventoryProfile *inv)
 			}
 		}
 
-		auto *item = GetItem(item_id);
+		auto* item = GetItem(item_id);
 		if (!item) {
 			LogError(
 				"Warning: charid [{}] has an invalid item_id [{}] in inventory slot [{}]",
@@ -732,7 +749,7 @@ bool SharedDatabase::GetInventory(uint32 char_id, EQ::InventoryProfile *inv)
 			continue;
 		}
 
-		auto *inst = CreateBaseItem(item, charges);
+		auto* inst = CreateBaseItem(item, charges);
 		if (!inst) {
 			continue;
 		}
@@ -745,8 +762,13 @@ bool SharedDatabase::GetInventory(uint32 char_id, EQ::InventoryProfile *inv)
 		inst->SetOrnamentationIDFile(ornament_idfile);
 		inst->SetOrnamentHeroModel(item->HerosForgeModel);
 
-		if (instnodrop || (inst->GetItem()->Attuneable && slot_id >= EQ::invslot::EQUIPMENT_BEGIN && slot_id <=
-		                   EQ::invslot::EQUIPMENT_END)) {
+		if (
+			instnodrop ||
+			(
+				inst->GetItem()->Attuneable &&
+				EQ::ValueWithin(slot_id, EQ::invslot::EQUIPMENT_BEGIN, EQ::invslot::EQUIPMENT_END)
+			)
+		) {
 			inst->SetAttuned(true);
 		}
 
@@ -754,52 +776,37 @@ bool SharedDatabase::GetInventory(uint32 char_id, EQ::InventoryProfile *inv)
 			inst->SetColor(color);
 		}
 
-		if (charges == 0x7FFF) {
+		if (charges == std::numeric_limits<int16>::max()) {
 			inst->SetCharges(-1);
-		}
-		else if (charges == 0 && inst->IsStackable()) {
+		} else if (charges == 0 && inst->IsStackable()) {
 			// Stackable items need a minimum charge of 1 remain moveable.
 			inst->SetCharges(1);
-		}
-		else {
+		} else {
 			inst->SetCharges(charges);
 		}
 
 		if (item->RecastDelay) {
 			if (item->RecastType != RECAST_TYPE_UNLINKED_ITEM && timestamps.count(item->RecastType)) {
 				inst->SetRecastTimestamp(timestamps.at(item->RecastType));
-			}
-			else if (item->RecastType == RECAST_TYPE_UNLINKED_ITEM && timestamps.count(item->ID)) {
+			} else if (item->RecastType == RECAST_TYPE_UNLINKED_ITEM && timestamps.count(item->ID)) {
 				inst->SetRecastTimestamp(timestamps.at(item->ID));
-			}
-			else {
+			} else {
 				inst->SetRecastTimestamp(0);
 			}
 		}
 
 		if (item->IsClassCommon()) {
 			for (int i = EQ::invaug::SOCKET_BEGIN; i <= EQ::invaug::SOCKET_END; i++) {
-				if (aug[i]) {
-					inst->PutAugment(this, i, aug[i]);
+				if (augment_ids[i]) {
+					inst->PutAugment(this, i, augment_ids[i]);
 				}
 			}
 		}
 
 		int16 put_slot_id;
-		if (slot_id >= 8000 && slot_id <= 8999) {
+		if (EQ::ValueWithin(slot_id, EQ::invbag::CURSOR_BAG_BEGIN, EQ::invbag::CURSOR_BAG_END)) {
 			put_slot_id = inv->PushCursor(*inst);
-		}
-		else if (slot_id >= 3111 && slot_id <= 3179) {
-			// Admins: please report any occurrences of this error
-			LogError(
-				"Warning: Defunct location for item in inventory: charid={}, item_id={}, slot_id={} .. pushing to cursor...",
-				char_id,
-				item_id,
-				slot_id
-			);
-			put_slot_id = inv->PushCursor(*inst);
-		}
-		else {
+		} else {
 			put_slot_id = inv->PutItem(slot_id, *inst);
 		}
 
@@ -811,7 +818,7 @@ bool SharedDatabase::GetInventory(uint32 char_id, EQ::InventoryProfile *inv)
 		// Save ptr to item in inventory
 		if (put_slot_id == INVALID_INDEX) {
 			LogError(
-				"Warning: Invalid slot_id for item in inventory: charid=[{}], item_id=[{}], slot_id=[{}]",
+				"Warning: Invalid slot_id for item in inventory for character_id [{}] item_id [{}] slot_id [{}]",
 				char_id,
 				item_id,
 				slot_id
@@ -820,7 +827,7 @@ bool SharedDatabase::GetInventory(uint32 char_id, EQ::InventoryProfile *inv)
 	}
 
 	if (cv_conflict) {
-		const std::string &char_name = GetCharName(char_id);
+		const std::string& char_name = GetCharName(char_id);
 		LogError(
 			"ClientVersion/Expansion conflict during inventory load at zone entry for [{}] (charid: [{}], inver: [{}], gmi: [{}])",
 			char_name,
@@ -840,94 +847,6 @@ bool SharedDatabase::GetInventory(uint32 char_id, EQ::InventoryProfile *inv)
 	return GetSharedBank(char_id, inv, true);
 }
 
-// Overloaded: Retrieve character inventory based on account_id and character name (char select)
-bool SharedDatabase::GetInventory(uint32 account_id, char *name, EQ::InventoryProfile *inv) // deprecated
-{
-	// Retrieve character inventory
-	const std::string query =
-	    StringFormat("SELECT slotid, itemid, charges, color, augslot1, "
-			 "augslot2, augslot3, augslot4, augslot5, augslot6, instnodrop, custom_data, ornamenticon, "
-			 "ornamentidfile, ornament_hero_model "
-			 "FROM inventory INNER JOIN character_data ch "
-			 "ON ch.id = charid WHERE ch.name = '%s' AND ch.account_id = %i ORDER BY slotid",
-			 name, account_id);
-	auto results = QueryDatabase(query);
-	if (!results.Success()) {
-		LogError("If you got an error related to the 'instnodrop' field, run the "
-						    "following SQL Queries:\nalter table inventory add instnodrop "
-						    "tinyint(1) unsigned default 0 not null;\n");
-		return false;
-	}
-
-	for (auto& row = results.begin(); row != results.end(); ++row) {
-		int16 slot_id = Strings::ToInt(row[0]);
-		uint32 item_id = Strings::ToUnsignedInt(row[1]);
-		const int8 charges = Strings::ToInt(row[2]);
-		const uint32 color = Strings::ToUnsignedInt(row[3]);
-
-		uint32 aug[EQ::invaug::SOCKET_COUNT];
-		aug[0] = Strings::ToUnsignedInt(row[4]);
-		aug[1] = Strings::ToUnsignedInt(row[5]);
-		aug[2] = Strings::ToUnsignedInt(row[6]);
-		aug[3] = Strings::ToUnsignedInt(row[7]);
-		aug[4] = Strings::ToUnsignedInt(row[8]);
-		aug[5] = Strings::ToUnsignedInt(row[9]);
-
-		const bool instnodrop = (row[10] && static_cast<uint16>(Strings::ToUnsignedInt(row[10])));
-		const uint32 ornament_icon = Strings::ToUnsignedInt(row[12]);
-		const uint32 ornament_idfile = Strings::ToUnsignedInt(row[13]);
-		uint32 ornament_hero_model = Strings::ToUnsignedInt(row[14]);
-
-		const EQ::ItemData *item = GetItem(item_id);
-		if (!item)
-			continue;
-
-		EQ::ItemInstance *inst = CreateBaseItem(item, charges);
-
-		if (inst == nullptr)
-			continue;
-
-		inst->SetAttuned(instnodrop);
-
-		if (row[11]) {
-			std::string data_str(row[11]);
-			inst->SetCustomDataString(data_str);
-		}
-
-		inst->SetOrnamentIcon(ornament_icon);
-		inst->SetOrnamentationIDFile(ornament_idfile);
-		inst->SetOrnamentHeroModel(item->HerosForgeModel);
-
-		if (color > 0)
-			inst->SetColor(color);
-
-		inst->SetCharges(charges);
-
-		if (item->IsClassCommon()) {
-			for (int i = EQ::invaug::SOCKET_BEGIN; i <= EQ::invaug::SOCKET_END; i++) {
-				if (aug[i])
-					inst->PutAugment(this, i, aug[i]);
-			}
-		}
-
-		int16 put_slot_id;
-		if (slot_id >= 8000 && slot_id <= 8999)
-			put_slot_id = inv->PushCursor(*inst);
-		else
-			put_slot_id = inv->PutItem(slot_id, *inst);
-
-		safe_delete(inst);
-
-		// Save ptr to item in inventory
-		if (put_slot_id == INVALID_INDEX)
-			LogError("Warning: Invalid slot_id for item in inventory: name={}, acctid={}, item_id={}, slot_id={}",
-				name, account_id, item_id, slot_id);
-	}
-
-	// Retrieve shared inventory
-	return GetSharedBank(account_id, inv, false);
-}
-
 std::map<uint32, uint32> SharedDatabase::GetItemRecastTimestamps(uint32 char_id)
 {
 	std::map<uint32, uint32> timers;
@@ -1279,7 +1198,7 @@ void SharedDatabase::LoadItems(void *data, uint32 size, int32 items, uint32 max_
 
 		// Bag
 		item.BagSize = static_cast<uint8>(Strings::ToUnsignedInt(row[ItemField::bagsize]));
-		item.BagSlots = static_cast<uint8>(EQ::Clamp(Strings::ToInt(row[ItemField::bagslots]), 0, 10)); // Will need to be changed from std::min to just use database value when bag slots are increased
+		item.BagSlots = static_cast<uint8>(EQ::Clamp(Strings::ToInt(row[ItemField::bagslots]), 0, static_cast<int>(EQ::invbag::SLOT_COUNT)));
 		item.BagType = static_cast<uint8>(Strings::ToUnsignedInt(row[ItemField::bagtype]));
 		item.BagWR = static_cast<uint8>(EQ::Clamp(Strings::ToInt(row[ItemField::bagwr]), 0, 100));
 

common/shareddb.h

@@ -104,7 +104,6 @@ public:
 	int32 GetSharedPlatinum(uint32 account_id);
 	bool SetSharedPlatinum(uint32 account_id, int32 amount_to_add);
 	bool GetInventory(uint32 char_id, EQ::InventoryProfile *inv);
-	bool GetInventory(uint32 account_id, char *name, EQ::InventoryProfile *inv); // deprecated
 	std::map<uint32, uint32> GetItemRecastTimestamps(uint32 char_id);
 	uint32 GetItemRecastTimestamp(uint32 char_id, uint32 recast_type);
 	void ClearOldRecastTimestamps(uint32 char_id);

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.59.1-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 9288
 #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.59.1",
   "repository": {
     "type": "git",
     "url": "https://github.com/EQEmu/Server.git"

utils/scripts/generators/repository-generator.pl

@@ -142,7 +142,6 @@ foreach my $table_to_generate (@tables) {
         "guild_bank",
         "inventory_versions",
         "raid_leaders",
-        "sharedbank",
         "trader_audit",
         "eqtime",
         "db_version",

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());
@@ -2351,21 +2369,26 @@ bool Client::StoreCharacter(
 
 	auto e = InventoryRepository::NewEntity();
 
-	e.charid = character_id;
+	e.character_id = character_id;
 
 	for (int16 slot_id = EQ::invslot::EQUIPMENT_BEGIN; slot_id <= EQ::invbag::BANK_BAGS_END;) {
 		const auto inst = p_inventory_profile->GetItem(slot_id);
 		if (inst) {
-			e.slotid   = slot_id;
-			e.itemid   = inst->GetItem()->ID;
-			e.charges  = inst->GetCharges();
-			e.color    = inst->GetColor();
-			e.augslot1 = inst->GetAugmentItemID(EQ::invaug::SOCKET_BEGIN);
-			e.augslot2 = inst->GetAugmentItemID(EQ::invaug::SOCKET_BEGIN + 1);
-			e.augslot3 = inst->GetAugmentItemID(EQ::invaug::SOCKET_BEGIN + 2);
-			e.augslot4 = inst->GetAugmentItemID(EQ::invaug::SOCKET_BEGIN + 3);
-			e.augslot5 = inst->GetAugmentItemID(EQ::invaug::SOCKET_BEGIN + 4);
-			e.augslot6 = inst->GetAugmentItemID(EQ::invaug::SOCKET_END);
+			e.slot_id             = slot_id;
+			e.item_id             = inst->GetItem()->ID;
+			e.charges             = inst->GetCharges();
+			e.color               = inst->GetColor();
+			e.augment_one         = inst->GetAugmentItemID(EQ::invaug::SOCKET_BEGIN);
+			e.augment_two         = inst->GetAugmentItemID(EQ::invaug::SOCKET_BEGIN + 1);
+			e.augment_three       = inst->GetAugmentItemID(EQ::invaug::SOCKET_BEGIN + 2);
+			e.augment_four        = inst->GetAugmentItemID(EQ::invaug::SOCKET_BEGIN + 3);
+			e.augment_five        = inst->GetAugmentItemID(EQ::invaug::SOCKET_BEGIN + 4);
+			e.augment_six         = inst->GetAugmentItemID(EQ::invaug::SOCKET_END);
+			e.instnodrop          = inst->IsAttuned() ? 1 : 0;
+			e.ornament_icon       = inst->GetOrnamentationIcon();
+			e.ornament_idfile     = inst->GetOrnamentationIDFile();
+			e.ornament_hero_model = inst->GetOrnamentHeroModel();
+			e.guid                = inst->GetSerialNumber();
 
 			v.emplace_back(e);
 		}
@@ -2453,3 +2476,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/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/worlddb.cpp

@@ -26,6 +26,7 @@
 #include <vector>
 #include "sof_char_create_data.h"
 #include "../common/repositories/character_instance_safereturns_repository.h"
+#include "../common/repositories/inventory_repository.h"
 #include "../common/repositories/criteria/content_filter_criteria.h"
 #include "../common/zone_store.h"
 
@@ -857,115 +858,90 @@ bool WorldDatabase::LoadCharacterCreateCombos()
 // this is a slightly modified version of SharedDatabase::GetInventory(...) for character select use-only
 bool WorldDatabase::GetCharSelInventory(uint32 account_id, char *name, EQ::InventoryProfile *inv)
 {
-	if (!account_id || !name || !inv)
+	if (!account_id || !name || !inv) {
 		return false;
+	}
 
-	std::string query = StringFormat(
-		"SELECT"
-		" slotid,"
-		" itemid,"
-		" charges,"
-		" color,"
-		" augslot1,"
-		" augslot2,"
-		" augslot3,"
-		" augslot4,"
-		" augslot5,"
-		" augslot6,"
-		" instnodrop,"
-		" custom_data,"
-		" ornamenticon,"
-		" ornamentidfile,"
-		" ornament_hero_model "
-		"FROM"
-		" inventory "
-		"INNER JOIN"
-		" character_data ch "
-		"ON"
-		" ch.id = charid "
-		"WHERE"
-		" ch.name = '%s' "
-		"AND"
-		" ch.account_id = %i "
-		"AND"
-		" slotid >= %i "
-		"AND"
-		" slotid <= %i",
-		name,
-		account_id,
-		EQ::invslot::slotHead,
-		EQ::invslot::slotFeet
+	const uint32 character_id = GetCharacterID(name);
+
+	if (!character_id) {
+		return false;
+	}
+
+	const auto& l = InventoryRepository::GetWhere(
+		*this,
+		fmt::format(
+			"`character_id` = {} AND `slot_id` BETWEEN {} AND {}",
+			character_id,
+			EQ::invslot::slotHead,
+			EQ::invslot::slotFeet
+		)
 	);
-	auto results = QueryDatabase(query);
-	if (!results.Success())
-		return false;
 
-	for (auto row = results.begin(); row != results.end(); ++row) {
-		int16 slot_id = Strings::ToInt(row[0]);
+	if (l.empty()) {
+		return true;
+	}
 
-		switch (slot_id) {
-		case EQ::invslot::slotFace:
-		case EQ::invslot::slotEar2:
-		case EQ::invslot::slotNeck:
-		case EQ::invslot::slotShoulders:
-		case EQ::invslot::slotBack:
-		case EQ::invslot::slotFinger1:
-		case EQ::invslot::slotFinger2:
-			continue;
-		default:
-			break;
+	for (const auto& e : l) {
+		switch (e.slot_id) {
+			case EQ::invslot::slotFace:
+			case EQ::invslot::slotEar2:
+			case EQ::invslot::slotNeck:
+			case EQ::invslot::slotShoulders:
+			case EQ::invslot::slotBack:
+			case EQ::invslot::slotFinger1:
+			case EQ::invslot::slotFinger2:
+				continue;
+			default:
+				break;
 		}
 
-		uint32 item_id = Strings::ToInt(row[1]);
-		int8 charges = Strings::ToInt(row[2]);
-		uint32 color = Strings::ToUnsignedInt(row[3]);
 
-		uint32 aug[EQ::invaug::SOCKET_COUNT];
-		aug[0] = (uint32)Strings::ToInt(row[4]);
-		aug[1] = (uint32)Strings::ToInt(row[5]);
-		aug[2] = (uint32)Strings::ToInt(row[6]);
-		aug[3] = (uint32)Strings::ToInt(row[7]);
-		aug[4] = (uint32)Strings::ToInt(row[8]);
-		aug[5] = (uint32)Strings::ToInt(row[9]);
+		uint32 augment_ids[EQ::invaug::SOCKET_COUNT] = {
+			e.augment_one,
+			e.augment_two,
+			e.augment_three,
+			e.augment_four,
+			e.augment_five,
+			e.augment_six
+		};
 
-		bool instnodrop = ((row[10] && (uint16)Strings::ToInt(row[10])) ? true : false);
-		uint32 ornament_icon = (uint32)Strings::ToUnsignedInt(row[12]);
-		uint32 ornament_idfile = (uint32)Strings::ToUnsignedInt(row[13]);
-		uint32 ornament_hero_model = (uint32)Strings::ToUnsignedInt(row[14]);
-
-		const EQ::ItemData *item = content_db.GetItem(item_id);
-		if (!item)
+		const EQ::ItemData* item = content_db.GetItem(e.item_id);
+		if (!item) {
 			continue;
-
-		EQ::ItemInstance *inst = content_db.CreateBaseItem(item, charges);
-
-		if (inst == nullptr)
-			continue;
-
-		inst->SetAttuned(instnodrop);
-
-		if (row[11]) {
-			std::string data_str(row[11]);
-			inst->SetCustomDataString(data_str);
 		}
 
-		inst->SetOrnamentIcon(ornament_icon);
-		inst->SetOrnamentationIDFile(ornament_idfile);
-		inst->SetOrnamentHeroModel(item->HerosForgeModel);
+		EQ::ItemInstance *inst = content_db.CreateBaseItem(item, e.charges);
 
-		if (color > 0)
-			inst->SetColor(color);
+		if (!inst) {
+			continue;
+		}
 
-		inst->SetCharges(charges);
+		inst->SetCharges(e.charges);
+
+		if (e.color > 0) {
+			inst->SetColor(e.color);
+		}
 
 		if (item->IsClassCommon()) {
 			for (int i = EQ::invaug::SOCKET_BEGIN; i <= EQ::invaug::SOCKET_END; i++) {
-				if (aug[i])
-					inst->PutAugment(this, i, aug[i]);
+				if (augment_ids[i]) {
+					inst->PutAugment(this, i, augment_ids[i]);
+				}
 			}
 		}
 
-		inv->PutItem(slot_id, *inst);
+		inst->SetAttuned(e.instnodrop);
+
+		if (!e.custom_data.empty()) {
+			inst->SetCustomDataString(e.custom_data);
+		}
+
+		inst->SetOrnamentIcon(e.ornament_icon);
+		inst->SetOrnamentationIDFile(e.ornament_idfile);
+		inst->SetOrnamentHeroModel(e.ornament_hero_model);
+
+		inv->PutItem(e.slot_id, *inst);
 
 		safe_delete(inst);
 	}

world/zoneserver.cpp

@@ -1755,7 +1755,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 +1779,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
@@ -215,6 +218,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 +255,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 +265,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()
@@ -9120,7 +9124,7 @@ void Client::SetPrimaryWeaponOrnamentation(uint32 model_id)
 		auto l = InventoryRepository::GetWhere(
 			database,
 			fmt::format(
-				"`charid` = {} AND `slotid` = {}",
+				"`character_id` = {} AND `slot_id` = {}",
 				character_id,
 				EQ::invslot::slotPrimary
 			)
@@ -9132,7 +9136,7 @@ void Client::SetPrimaryWeaponOrnamentation(uint32 model_id)
 
 		auto e = l.front();
 
-		e.ornamentidfile = model_id;
+		e.ornament_idfile = model_id;
 
 		const int updated = InventoryRepository::UpdateOne(database, e);
 
@@ -9153,7 +9157,7 @@ void Client::SetSecondaryWeaponOrnamentation(uint32 model_id)
 		auto l = InventoryRepository::GetWhere(
 			database,
 			fmt::format(
-				"`charid` = {} AND `slotid` = {}",
+				"`character_id` = {} AND `slot_id` = {}",
 				character_id,
 				EQ::invslot::slotSecondary
 			)
@@ -9165,7 +9169,7 @@ void Client::SetSecondaryWeaponOrnamentation(uint32 model_id)
 
 		auto e = l.front();
 
-		e.ornamentidfile = model_id;
+		e.ornament_idfile = model_id;
 
 		const int updated = InventoryRepository::UpdateOne(database, e);
 
@@ -12316,6 +12320,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

@@ -2227,6 +2227,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

@@ -1639,11 +1639,6 @@ void Client::Handle_Connect_OP_ZoneEntry(const EQApplicationPacket *app)
 			m_pp.abilitySlotRefresh = 0;
 	}
 
-#ifdef _EQDEBUG
-	printf("Dumping inventory on load:\n");
-	m_inv.dumpEntireInventory();
-#endif
-
 	/* Reset to max so they dont drown on zone in if its underwater */
 	m_pp.air_remaining = 60;
 	/* Check for PVP Zone status*/
@@ -2731,6 +2726,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 +5016,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;
@@ -10757,8 +10764,7 @@ void Client::Handle_OP_MoveCoin(const EQApplicationPacket *app)
 
 void Client::Handle_OP_MoveItem(const EQApplicationPacket *app)
 {
-	if (!CharacterID())
-	{
+	if (!CharacterID()) {
 		return;
 	}
 
@@ -10767,60 +10773,35 @@ void Client::Handle_OP_MoveItem(const EQApplicationPacket *app)
 		return;
 	}
 
-	MoveItem_Struct* mi = (MoveItem_Struct*)app->pBuffer;
-	if (spellend_timer.Enabled() && casting_spell_id && !IsBardSong(casting_spell_id))
-	{
-		if (mi->from_slot != mi->to_slot && (mi->from_slot <= EQ::invslot::GENERAL_END || mi->from_slot > 39) && IsValidSlot(mi->from_slot) && IsValidSlot(mi->to_slot))
-		{
-			const EQ::ItemInstance *itm_from = GetInv().GetItem(mi->from_slot);
-			const EQ::ItemInstance *itm_to = GetInv().GetItem(mi->to_slot);
-			auto message = fmt::format("Player issued a move item from {}(item id {}) to {}(item id {}) while casting {}.",
+	MoveItem_Struct* mi = (MoveItem_Struct*) app->pBuffer;
+	if (spellend_timer.Enabled() && casting_spell_id && !IsBardSong(casting_spell_id)) {
+		if (mi->from_slot != mi->to_slot && (mi->from_slot <= EQ::invslot::GENERAL_END || mi->from_slot > 39) &&
+			IsValidSlot(mi->from_slot) && IsValidSlot(mi->to_slot)) {
+			const EQ::ItemInstance* itm_from = GetInv().GetItem(mi->from_slot);
+			const EQ::ItemInstance* itm_to   = GetInv().GetItem(mi->to_slot);
+			auto message = fmt::format(
+				"Player issued a move item from {}(item id {}) to {}(item id {}) while casting {}.",
 				mi->from_slot,
 				itm_from ? itm_from->GetID() : 0,
 				mi->to_slot,
 				itm_to ? itm_to->GetID() : 0,
-				casting_spell_id);
-			RecordPlayerEventLog(PlayerEvent::POSSIBLE_HACK, PlayerEvent::PossibleHackEvent{.message = message});
+				casting_spell_id
+			);
+			RecordPlayerEventLog(PlayerEvent::POSSIBLE_HACK, PlayerEvent::PossibleHackEvent{ .message = message });
 			Kick("Inventory desync"); // Kick client to prevent client and server from getting out-of-sync inventory slots
 			return;
 		}
 	}
 
-	// Illegal bagslot usage checks. Currently, user only receives a message if this check is triggered.
-	bool mi_hack = false;
-
-	if (mi->from_slot >= EQ::invbag::GENERAL_BAGS_BEGIN && mi->from_slot <= EQ::invbag::CURSOR_BAG_END) {
-		if (mi->from_slot >= EQ::invbag::CURSOR_BAG_BEGIN) { mi_hack = true; }
-		else {
-			int16 from_parent = m_inv.CalcSlotId(mi->from_slot);
-			if (!m_inv[from_parent]) { mi_hack = true; }
-			else if (!m_inv[from_parent]->IsClassBag()) { mi_hack = true; }
-			else if (m_inv.CalcBagIdx(mi->from_slot) >= m_inv[from_parent]->GetItem()->BagSlots) { mi_hack = true; }
-		}
-	}
-
-	if (mi->to_slot >= EQ::invbag::GENERAL_BAGS_BEGIN && mi->to_slot <= EQ::invbag::CURSOR_BAG_END) {
-		if (mi->to_slot >= EQ::invbag::CURSOR_BAG_BEGIN) { mi_hack = true; }
-		else {
-			int16 to_parent = m_inv.CalcSlotId(mi->to_slot);
-			if (!m_inv[to_parent]) { mi_hack = true; }
-			else if (!m_inv[to_parent]->IsClassBag()) { mi_hack = true; }
-			else if (m_inv.CalcBagIdx(mi->to_slot) >= m_inv[to_parent]->GetItem()->BagSlots) { mi_hack = true; }
-		}
-	}
-
-	if (mi_hack) { Message(Chat::Yellow, "Caution: Illegal use of inaccessible bag slots!"); }
-
 	if (!SwapItem(mi) && IsValidSlot(mi->from_slot) && IsValidSlot(mi->to_slot)) {
 		SwapItemResync(mi);
 
 		bool error = false;
 		InterrogateInventory(this, false, true, false, error, false);
-		if (error)
+		if (error) {
 			InterrogateInventory(this, true, false, true, error);
+		}
 	}
-
-	return;
 }
 
 void Client::Handle_OP_MoveMultipleItems(const EQApplicationPacket *app)

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
@@ -768,65 +770,83 @@ void Client::BulkSendInventoryItems()
 	EQ::OutBuffer ob;
 	EQ::OutBuffer::pos_type last_pos = ob.tellp();
 
-	// Possessions items
-	for (int16 slot_id = EQ::invslot::POSSESSIONS_BEGIN; slot_id <= EQ::invslot::POSSESSIONS_END; slot_id++) {
+	// Equipment items
+	for (int16 slot_id = EQ::invslot::EQUIPMENT_BEGIN; slot_id <= EQ::invslot::EQUIPMENT_END; slot_id++) {
 		const EQ::ItemInstance* inst = m_inv[slot_id];
-		if (!inst)
+		if (!inst) {
 			continue;
+		}
 
 		inst->Serialize(ob, slot_id);
 
-		if (ob.tellp() == last_pos)
+		if (ob.tellp() == last_pos) {
 			LogInventory("Serialization failed on item slot [{}] during BulkSendInventoryItems. Item skipped", slot_id);
+		}
 
 		last_pos = ob.tellp();
 	}
 
-    if (!RuleB(Inventory, LazyLoadBank)) {
-        // Bank items
-        for (int16 slot_id = EQ::invslot::BANK_BEGIN; slot_id <= EQ::invslot::BANK_END; slot_id++) {
-            const EQ::ItemInstance* inst = m_inv[slot_id];
-            if (!inst)
-                continue;
+	// General items
+	for (int16 slot_id = EQ::invslot::GENERAL_BEGIN; slot_id <= EQ::invslot::GENERAL_END; slot_id++) {
+		const EQ::ItemInstance* inst = m_inv[slot_id];
+		if (!inst) {
+			continue;
+		}
 
-            inst->Serialize(ob, slot_id);
+		inst->Serialize(ob, slot_id);
 
-            if (ob.tellp() == last_pos)
-                LogInventory("Serialization failed on item slot [{}] during BulkSendInventoryItems. Item skipped", slot_id);
+		if (ob.tellp() == last_pos) {
+			LogInventory("Serialization failed on item slot [{}] during BulkSendInventoryItems. Item skipped", slot_id);
+		}
 
-            last_pos = ob.tellp();
-        }
+		last_pos = ob.tellp();
+	}
 
-        // SharedBank items
-        for (int16 slot_id = EQ::invslot::SHARED_BANK_BEGIN; slot_id <= EQ::invslot::SHARED_BANK_END; slot_id++) {
-            const EQ::ItemInstance* inst = m_inv[slot_id];
-            if (!inst)
-                continue;
+	if (!RuleB(Inventory, LazyLoadBank)) {
+		// Bank items
+		for (int16 slot_id = EQ::invslot::BANK_BEGIN; slot_id <= EQ::invslot::BANK_END; slot_id++) {
+			const EQ::ItemInstance* inst = m_inv[slot_id];
+			if (!inst) {
+				continue;
+			}
 
-            inst->Serialize(ob, slot_id);
+			inst->Serialize(ob, slot_id);
 
-            if (ob.tellp() == last_pos)
-                LogInventory("Serialization failed on item slot [{}] during BulkSendInventoryItems. Item skipped", slot_id);
+			if (ob.tellp() == last_pos) {
+				LogInventory("Serialization failed on item slot [{}] during BulkSendInventoryItems. Item skipped", slot_id);
+			}
 
-            last_pos = ob.tellp();
-        }
-    }
+			last_pos = ob.tellp();
+		}
 
-    auto outapp = new EQApplicationPacket(OP_CharInventory);
-    outapp->size = ob.size();
-    outapp->pBuffer = ob.detach();
-    QueuePacket(outapp);
-    safe_delete(outapp);
+		// SharedBank items
+		for (int16 slot_id = EQ::invslot::SHARED_BANK_BEGIN; slot_id <= EQ::invslot::SHARED_BANK_END; slot_id++) {
+			const EQ::ItemInstance* inst = m_inv[slot_id];
+			if (!inst) {
+				continue;
+			}
+
+			inst->Serialize(ob, slot_id);
+
+			if (ob.tellp() == last_pos) {
+				LogInventory("Serialization failed on item slot [{}] during BulkSendInventoryItems. Item skipped", slot_id);
+			}
+
+			last_pos = ob.tellp();
+		}
+	}
+
+	auto outapp = new EQApplicationPacket(OP_CharInventory);
+
+	outapp->size    = ob.size();
+	outapp->pBuffer = ob.detach();
+
+	QueuePacket(outapp);
+	safe_delete(outapp);
 }
 
 void Client::BulkSendMerchantInventory(int merchant_id, int npcid) {
 	const EQ::ItemData* handy_item = nullptr;
-
-	uint32 merchant_slots = 80; //The max number of items passed in the transaction.
-	if (m_ClientVersionBit & EQ::versions::maskRoFAndLater) { // RoF+ can send 200 items
-		merchant_slots = 200;
-	}
-
 	const EQ::ItemData *item = nullptr;
 	auto merchant_list = zone->merchanttable[merchant_id];
 	auto npc = entity_list.GetMobByNpcTypeID(npcid);
@@ -838,6 +858,8 @@ void Client::BulkSendMerchantInventory(int merchant_id, int npcid) {
 		}
 	}
 
+	const int16 merchant_slots = (m_ClientVersionBit & EQ::versions::maskRoFAndLater) ? EQ::invtype::MERCHANT_SIZE : 80;
+
 	auto temporary_merchant_list = zone->tmpmerchanttable[npcid];
 	uint32 slot_id = 1;
 	uint8 handy_chance = 0;

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

@@ -845,7 +845,7 @@ LootItem *Corpse::GetItem(uint16 lootslot, LootItem **bag_item_data)
 
 		// convert above code to for loop
 		for (const auto &item: m_item_list) {
-			if (item->equip_slot >= bagstart && item->equip_slot < bagstart + 10) {
+			if (item->equip_slot >= bagstart && item->equip_slot < bagstart + EQ::invbag::SLOT_COUNT) {
 				bag_item_data[item->equip_slot - bagstart] = item;
 			}
 		}
@@ -1472,7 +1472,7 @@ void Corpse::LootCorpseItem(Client *c, const EQApplicationPacket *app)
 
 	const EQ::ItemData *item      = nullptr;
 	EQ::ItemInstance   *inst      = nullptr;
-	LootItem           *item_data = nullptr, *bag_item_data[10] = {};
+	LootItem           *item_data = nullptr, *bag_item_data[EQ::invbag::SLOT_COUNT] = {};
 
 	memset(bag_item_data, 0, sizeof(bag_item_data));
 	if (GetPlayerKillItem() > 1) {

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
 }
 

zone/embparser_api.cpp

@@ -278,25 +278,25 @@ int Perl__getinventoryslotid(std::string identifier)
 		else if (identifier == "generalbags.begin")     result = EQ::invbag::GENERAL_BAGS_BEGIN;
 		else if (identifier == "generalbags.end")       result = EQ::invbag::GENERAL_BAGS_END;
 		else if (identifier == "general1bag.begin")     result = EQ::invbag::GENERAL_BAGS_BEGIN;
-		else if (identifier == "general1bag.end")       result = EQ::invbag::GENERAL_BAGS_BEGIN + 9;
-		else if (identifier == "general2bag.begin")     result = EQ::invbag::GENERAL_BAGS_BEGIN + 10;
-		else if (identifier == "general2bag.end")       result = EQ::invbag::GENERAL_BAGS_BEGIN + 19;
-		else if (identifier == "general3bag.begin")     result = EQ::invbag::GENERAL_BAGS_BEGIN + 20;
-		else if (identifier == "general3bag.end")       result = EQ::invbag::GENERAL_BAGS_BEGIN + 29;
-		else if (identifier == "general4bag.begin")     result = EQ::invbag::GENERAL_BAGS_BEGIN + 30;
-		else if (identifier == "general4bag.end")       result = EQ::invbag::GENERAL_BAGS_BEGIN + 39;
-		else if (identifier == "general5bag.begin")     result = EQ::invbag::GENERAL_BAGS_BEGIN + 40;
-		else if (identifier == "general5bag.end")       result = EQ::invbag::GENERAL_BAGS_BEGIN + 49;
-		else if (identifier == "general6bag.begin")     result = EQ::invbag::GENERAL_BAGS_BEGIN + 50;
-		else if (identifier == "general6bag.end")       result = EQ::invbag::GENERAL_BAGS_BEGIN + 59;
-		else if (identifier == "general7bag.begin")     result = EQ::invbag::GENERAL_BAGS_BEGIN + 60;
-		else if (identifier == "general7bag.end")       result = EQ::invbag::GENERAL_BAGS_BEGIN + 69;
-		else if (identifier == "general8bag.begin")     result = EQ::invbag::GENERAL_BAGS_BEGIN + 70;
-		else if (identifier == "general8bag.end")       result = EQ::invbag::GENERAL_BAGS_BEGIN + 79;
-		else if (identifier == "general9bag.begin")     result = EQ::invbag::GENERAL_BAGS_BEGIN + 80;
-		else if (identifier == "general9bag.end")       result = EQ::invbag::GENERAL_BAGS_BEGIN + 89;
-		else if (identifier == "general10bag.begin")    result = EQ::invbag::GENERAL_BAGS_BEGIN + 90;
-		else if (identifier == "general10bag.end")      result = EQ::invbag::GENERAL_BAGS_BEGIN + 99;
+		else if (identifier == "general1bag.end")       result = EQ::invbag::GENERAL_BAGS_BEGIN + (EQ::invbag::SLOT_COUNT - 1);
+		else if (identifier == "general2bag.begin")     result = EQ::invbag::GENERAL_BAGS_BEGIN + EQ::invbag::SLOT_COUNT;
+		else if (identifier == "general2bag.end")       result = EQ::invbag::GENERAL_BAGS_BEGIN + ((EQ::invbag::SLOT_COUNT * 2) - 1);
+		else if (identifier == "general3bag.begin")     result = EQ::invbag::GENERAL_BAGS_BEGIN + (EQ::invbag::SLOT_COUNT * 2);
+		else if (identifier == "general3bag.end")       result = EQ::invbag::GENERAL_BAGS_BEGIN + ((EQ::invbag::SLOT_COUNT * 3) - 1);
+		else if (identifier == "general4bag.begin")     result = EQ::invbag::GENERAL_BAGS_BEGIN + (EQ::invbag::SLOT_COUNT * 3);
+		else if (identifier == "general4bag.end")       result = EQ::invbag::GENERAL_BAGS_BEGIN + ((EQ::invbag::SLOT_COUNT * 4) - 1);
+		else if (identifier == "general5bag.begin")     result = EQ::invbag::GENERAL_BAGS_BEGIN + (EQ::invbag::SLOT_COUNT * 4);
+		else if (identifier == "general5bag.end")       result = EQ::invbag::GENERAL_BAGS_BEGIN + ((EQ::invbag::SLOT_COUNT * 5) - 1);
+		else if (identifier == "general6bag.begin")     result = EQ::invbag::GENERAL_BAGS_BEGIN + (EQ::invbag::SLOT_COUNT * 5);
+		else if (identifier == "general6bag.end")       result = EQ::invbag::GENERAL_BAGS_BEGIN + ((EQ::invbag::SLOT_COUNT * 6) - 1);
+		else if (identifier == "general7bag.begin")     result = EQ::invbag::GENERAL_BAGS_BEGIN + (EQ::invbag::SLOT_COUNT * 6);
+		else if (identifier == "general7bag.end")       result = EQ::invbag::GENERAL_BAGS_BEGIN + ((EQ::invbag::SLOT_COUNT * 7) - 1);
+		else if (identifier == "general8bag.begin")     result = EQ::invbag::GENERAL_BAGS_BEGIN + (EQ::invbag::SLOT_COUNT * 7);
+		else if (identifier == "general8bag.end")       result = EQ::invbag::GENERAL_BAGS_BEGIN + ((EQ::invbag::SLOT_COUNT * 8) - 1);
+		else if (identifier == "general9bag.begin")     result = EQ::invbag::GENERAL_BAGS_BEGIN + (EQ::invbag::SLOT_COUNT * 8);
+		else if (identifier == "general9bag.end")       result = EQ::invbag::GENERAL_BAGS_BEGIN + ((EQ::invbag::SLOT_COUNT * 9) - 1);
+		else if (identifier == "general10bag.begin")    result = EQ::invbag::GENERAL_BAGS_BEGIN + (EQ::invbag::SLOT_COUNT * 9);
+		else if (identifier == "general10bag.end")      result = EQ::invbag::GENERAL_BAGS_BEGIN + ((EQ::invbag::SLOT_COUNT * 10) - 1);
 		else if (identifier == "cursorbag.begin")       result = EQ::invbag::CURSOR_BAG_BEGIN;
 		else if (identifier == "cursorbag.end")         result = EQ::invbag::CURSOR_BAG_END;
 		else if (identifier == "bank.begin")            result = EQ::invslot::BANK_BEGIN;
@@ -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/gm_commands/show/inventory.cpp

@@ -310,7 +310,7 @@ void ShowInventory(Client *c, const Seperator *sep)
 						Chat::White,
 						fmt::format(
 							"Slot {} | {} ({}){}",
-							(8000 + limboIndex),
+							(14000 + limboIndex),
 							item_data->ID,
 							linker.GenerateLink(),
 							(
@@ -339,7 +339,7 @@ void ShowInventory(Client *c, const Seperator *sep)
 							Chat::White,
 							fmt::format(
 								"Slot {} (Augment Slot {}) | {} ({}){}",
-								(8000 + limboIndex),
+								(14000 + limboIndex),
 								augment_index,
 								linker.GenerateLink(),
 								item_data->ID,
@@ -375,7 +375,7 @@ void ShowInventory(Client *c, const Seperator *sep)
 							Chat::White,
 							fmt::format(
 								"Slot {} Bag Slot {} | {} ({}){}",
-								(8000 + limboIndex),
+								(14000 + limboIndex),
 								sub_index,
 								linker.GenerateLink(),
 								item_data->ID,
@@ -407,7 +407,7 @@ void ShowInventory(Client *c, const Seperator *sep)
 								Chat::White,
 								fmt::format(
 									"Slot {} Bag Slot {} (Augment Slot {}) | {} ({}){}",
-									(8000 + limboIndex),
+									(14000 + limboIndex),
 									sub_index,
 									augment_index,
 									linker.GenerateLink(),

zone/inventory.cpp

@@ -1909,13 +1909,20 @@ bool Client::SwapItem(MoveItem_Struct* move_in) {
 		return false;
 	}
 	//verify shared bank transactions in the database
-	if (src_inst && src_slot_id >= EQ::invslot::SHARED_BANK_BEGIN && src_slot_id <= EQ::invbag::SHARED_BANK_BAGS_END) {
+	if (
+		src_inst &&
+		(
+			EQ::ValueWithin(src_slot_id, EQ::invslot::SHARED_BANK_BEGIN, EQ::invslot::SHARED_BANK_END) ||
+			EQ::ValueWithin(src_slot_id, EQ::invbag::SHARED_BANK_BAGS_BEGIN, EQ::invbag::SHARED_BANK_BAGS_END)
+		)
+	) {
 		if(!database.VerifyInventory(account_id, src_slot_id, src_inst)) {
 			LogError("Player [{}] on account [{}] was found exploiting the shared bank.\n", GetName(), account_name);
 			DeleteItemInInventory(dst_slot_id,0,true);
 			return(false);
 		}
-		if (src_slot_id >= EQ::invslot::SHARED_BANK_BEGIN && src_slot_id <= EQ::invslot::SHARED_BANK_END && src_inst->IsClassBag()){
+
+		if (EQ::ValueWithin(src_slot_id, EQ::invslot::SHARED_BANK_BEGIN, EQ::invslot::SHARED_BANK_END) && src_inst->IsClassBag()){
 			for (uint8 idx = EQ::invbag::SLOT_BEGIN; idx <= EQ::invbag::SLOT_END; idx++) {
 				const EQ::ItemInstance* baginst = src_inst->GetItem(idx);
 				if (baginst && !database.VerifyInventory(account_id, EQ::InventoryProfile::CalcSlotId(src_slot_id, idx), baginst)){
@@ -1924,13 +1931,21 @@ bool Client::SwapItem(MoveItem_Struct* move_in) {
 			}
 		}
 	}
-	if (dst_inst && dst_slot_id >= EQ::invslot::SHARED_BANK_BEGIN && dst_slot_id <= EQ::invbag::SHARED_BANK_BAGS_END) {
+
+	if (
+		dst_inst &&
+		(
+			EQ::ValueWithin(dst_slot_id, EQ::invslot::SHARED_BANK_BEGIN, EQ::invslot::SHARED_BANK_END) ||
+			EQ::ValueWithin(dst_slot_id, EQ::invbag::SHARED_BANK_BAGS_BEGIN, EQ::invbag::SHARED_BANK_BAGS_END)
+		)
+	) {
 		if(!database.VerifyInventory(account_id, dst_slot_id, dst_inst)) {
 			LogError("Player [{}] on account [{}] was found exploting the shared bank.\n", GetName(), account_name);
 			DeleteItemInInventory(src_slot_id,0,true);
 			return(false);
 		}
-		if (dst_slot_id >= EQ::invslot::SHARED_BANK_BEGIN && dst_slot_id <= EQ::invslot::SHARED_BANK_END && dst_inst->IsClassBag()){
+
+		if (EQ::ValueWithin(dst_slot_id, EQ::invslot::SHARED_BANK_BEGIN, EQ::invslot::SHARED_BANK_END) && dst_inst->IsClassBag()){
 			for (uint8 idx = EQ::invbag::SLOT_BEGIN; idx <= EQ::invbag::SLOT_END; idx++) {
 				const EQ::ItemInstance* baginst = dst_inst->GetItem(idx);
 				if (baginst && !database.VerifyInventory(account_id, EQ::InventoryProfile::CalcSlotId(dst_slot_id, idx), baginst)){
@@ -1943,10 +1958,20 @@ bool Client::SwapItem(MoveItem_Struct* move_in) {
 
 	// Check for No Drop Hacks
 	Mob* with = trade->With();
-	if (((with && with->IsClient() && !with->CastToClient()->IsBecomeNPC() && dst_slot_id >= EQ::invslot::TRADE_BEGIN && dst_slot_id <= EQ::invslot::TRADE_END) ||
-		(dst_slot_id >= EQ::invslot::SHARED_BANK_BEGIN && dst_slot_id <= EQ::invbag::SHARED_BANK_BAGS_END))
-	&& GetInv().CheckNoDrop(src_slot_id)
-	&& !CanTradeFVNoDropItem()) {
+	if (
+		(
+			(
+				with &&
+				with->IsClient() &&
+				!with->CastToClient()->IsBecomeNPC() &&
+				EQ::ValueWithin(dst_slot_id, EQ::invslot::TRADE_BEGIN, EQ::invslot::TRADE_END)
+			) ||
+			EQ::ValueWithin(dst_slot_id, EQ::invslot::SHARED_BANK_BEGIN, EQ::invslot::SHARED_BANK_END) ||
+			EQ::ValueWithin(dst_slot_id, EQ::invbag::SHARED_BANK_BAGS_BEGIN, EQ::invbag::SHARED_BANK_BAGS_END)
+		) &&
+		GetInv().CheckNoDrop(src_slot_id) &&
+		!CanTradeFVNoDropItem()
+	) {
 		auto ndh_inst = m_inv[src_slot_id];
 		std::string ndh_item_data;
 		if (ndh_inst == nullptr) {
@@ -3641,7 +3666,7 @@ bool Client::InterrogateInventory(Client* requester, bool log, bool silent, bool
 		if (cursor_itr == m_inv.cursor_cbegin())
 			continue;
 
-		instmap[8000 + limbo] = *cursor_itr;
+		instmap[EQ::invbag::CURSOR_BAG_BEGIN + limbo] = *cursor_itr;
 	}
 
 	// call InterrogateInventory_ for error check
@@ -3744,11 +3769,12 @@ bool Client::InterrogateInventory_error(int16 head, int16 index, const EQ::ItemI
 	// very basic error checking - can be elaborated upon if more in-depth testing is needed...
 
 	if (
-		(head >= EQ::invslot::EQUIPMENT_BEGIN && head <= EQ::invslot::EQUIPMENT_END) ||
-		(head >= EQ::invslot::TRIBUTE_BEGIN && head <= EQ::invslot::TRIBUTE_END) ||
-		(head >= EQ::invslot::GUILD_TRIBUTE_BEGIN && head <= EQ::invslot::GUILD_TRIBUTE_END) ||
-		(head >= EQ::invslot::WORLD_BEGIN && head <= EQ::invslot::WORLD_END) ||
-		(head >= 8000 && head <= 8101)) {
+		EQ::ValueWithin(head, EQ::invslot::EQUIPMENT_BEGIN, EQ::invslot::EQUIPMENT_END) ||
+		EQ::ValueWithin(head, EQ::invslot::TRIBUTE_BEGIN, EQ::invslot::TRIBUTE_END) ||
+		EQ::ValueWithin(head, EQ::invslot::GUILD_TRIBUTE_BEGIN, EQ::invslot::GUILD_TRIBUTE_END) ||
+		EQ::ValueWithin(head, EQ::invslot::WORLD_BEGIN, EQ::invslot::WORLD_END) ||
+		EQ::ValueWithin(head, EQ::invbag::CURSOR_BAG_BEGIN, EQ::invbag::CURSOR_BAG_END)
+	) {
 		switch (depth)
 		{
 		case 0: // requirement: inst is extant

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_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)
@@ -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/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)

zone/parcels.cpp

@@ -406,9 +406,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/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;
 
@@ -832,13 +834,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 +859,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 +2384,7 @@ void Client::ShowBuyLines(const EQApplicationPacket *app)
 			ss.str("");
 			ss.clear();
 		}
-		
+
 		return;
 	}
 }
@@ -2604,6 +2606,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));
@@ -3232,7 +3235,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 +3307,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 +3501,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 +4256,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 +4271,4 @@ bool Client::DoBarterSellerChecks(BuyerLineSellItem_Struct &sell_line)
 	}
 
 	return true;
-}
+}

zone/worldserver.cpp

@@ -4044,6 +4044,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/zonedb.cpp

@@ -3472,6 +3472,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

@@ -208,10 +208,10 @@ struct ZoneSpellsBlocked {
 };
 
 struct TraderCharges_Struct {
-	uint32 ItemID[80];
-	int32 SerialNumber[80];
-	uint32 ItemCost[80];
-	int32 Charges[80];
+	uint32 ItemID[EQ::invtype::BAZAAR_SIZE];
+	int32  SerialNumber[EQ::invtype::BAZAAR_SIZE];
+	uint32 ItemCost[EQ::invtype::BAZAAR_SIZE];
+	int32  Charges[EQ::invtype::BAZAAR_SIZE];
 };
 
 const int MaxMercStanceID = 9;

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;
 	}
 }