[Release] 23.1.0 (#4736 )

* [Release] 23.1.0 * Version * Pet table last minute add in
[Hotfix] Add character_pet_name to player tables schema
2026-05-23 09:02:29 +00:00 · 2025-03-01 19:23:50 -06:00 · 2025-03-01 18:56:38 -06:00 · 2025-03-01 18:32:43 -06:00 · 2025-03-01 18:32:35 -06:00 · 2025-03-01 18:05:28 -06:00
211 changed files with 9635 additions and 11575 deletions
@@ -1,3 +1,220 @@
+## [23.1.0] 3/1/2025
+
+### Bots
+
+* Fix unresponsive bots in groups upon group wipe ([#4712](https://github.com/EQEmu/Server/pull/4712)) @nytmyr 2025-02-28
+
+### Code
+
+* More login <-> world code cleanup ([#4724](https://github.com/EQEmu/Server/pull/4724)) @Akkadius 2025-02-28
+
+### Crash
+
+* Check for directory existence before traversing in CheckForCompatibleQuestPlugins ([#4730](https://github.com/EQEmu/Server/pull/4730)) @Akkadius 2025-03-02
+* Fix filesystem crash / exception in DatabaseDumpService::RemoveCredentialsFile() ([#4731](https://github.com/EQEmu/Server/pull/4731)) @Akkadius 2025-03-01
+* Fix large file size crash in File::GetContents for windows ([#4735](https://github.com/EQEmu/Server/pull/4735)) @Akkadius 2025-03-02
+* Fix reload concurrency crash when ran from Spire ([#4733](https://github.com/EQEmu/Server/pull/4733)) @Akkadius 2025-03-02
+* Validate item in SE_SummonItemIntoBag ([#4734](https://github.com/EQEmu/Server/pull/4734)) @Akkadius 2025-03-02
+* World CLI validation ([#4728](https://github.com/EQEmu/Server/pull/4728)) @Akkadius 2025-03-01
+
+### Database
+
+* Remove force_interactive from big bag updates ([#4727](https://github.com/EQEmu/Server/pull/4727)) @Akkadius 2025-03-01
+
+### Feature
+
+* Add a rule for spells to bypass stacking rules ([#4716](https://github.com/EQEmu/Server/pull/4716)) @catapultam-habeo 2025-02-28
+* Evolving items Additions ([#4725](https://github.com/EQEmu/Server/pull/4725)) @neckkola 2025-03-01
+
+### Fixes
+
+* Add character_pet_name to player tables schema  @Akkadius 2025-03-02
+* Add client packets to questmanager:setguild ([#4732](https://github.com/EQEmu/Server/pull/4732)) @neckkola 2025-03-01
+* Clear m_completed_shared_tasks before reloading  @Akkadius 2025-02-24
+* Fix AA Reset Error Message ([#4720](https://github.com/EQEmu/Server/pull/4720)) @Kinglykrab 2025-02-28
+* Fix Issue with Suffixes/Prefixes ([#4723](https://github.com/EQEmu/Server/pull/4723)) @Kinglykrab 2025-02-28
+* Fix Trading Items to Bot Pets ([#4721](https://github.com/EQEmu/Server/pull/4721)) @MortimerGreenwald 2025-02-28
+* Refactor ApplyItemBonuses to fix double-counting of ATK and recommended levels not correctly applying ([#4713](https://github.com/EQEmu/Server/pull/4713)) @catapultam-habeo 2025-03-01
+
+### Loginserver
+
+* Minor cleanup ([#4729](https://github.com/EQEmu/Server/pull/4729)) @Akkadius 2025-03-01
+
+### Quest API
+
+* Add Key Ring Methods to Perl and Lua ([#4719](https://github.com/EQEmu/Server/pull/4719)) @Kinglykrab 2025-02-28
+* Implement eq.handin() and quest::handin() ([#4718](https://github.com/EQEmu/Server/pull/4718)) @Akkadius 2025-02-28
+
+### Tasks
+
+* Extend IsTaskCompleted to also be aware of shared task completion ([#4714](https://github.com/EQEmu/Server/pull/4714)) @Akkadius 2025-02-24
+
+### Zone
+
+* Implement Zone State Saving on Shutdown ([#4715](https://github.com/EQEmu/Server/pull/4715)) @Akkadius 2025-02-28
+
+### Zone State
+
+* Wrap all serialization/deserialization in try/catch ([#4726](https://github.com/EQEmu/Server/pull/4726)) @Akkadius 2025-03-01
+
+## [23.0.2] 2/21/2025
+
+### Bots
+
+* Add checks to ensure bots and pets do not engage on ^pull ([#4708](https://github.com/EQEmu/Server/pull/4708)) @nytmyr 2025-02-22
+* Improve positioning ([#4709](https://github.com/EQEmu/Server/pull/4709)) @nytmyr 2025-02-22
+* Prevent medding in combat if any mob has bot targeted ([#4707](https://github.com/EQEmu/Server/pull/4707)) @nytmyr 2025-02-22
+
+### Client Mod
+
+* Adds a hacked fast camp rule for GMs ([#4697](https://github.com/EQEmu/Server/pull/4697)) @KimLS 2025-02-20
+
+### Fixes
+
+* Fix Lua Zone ID Exports ([#4700](https://github.com/EQEmu/Server/pull/4700)) @Kinglykrab 2025-02-22
+* Fix bad Mob reference in QuestManager::resumetimer() ([#4710](https://github.com/EQEmu/Server/pull/4710)) @zimp-wow 2025-02-22
+* Fix cursor load on zone ([#4704](https://github.com/EQEmu/Server/pull/4704)) @nytmyr 2025-02-22
+* Fix infinite loop in QuestManager::stoptimer() ([#4703](https://github.com/EQEmu/Server/pull/4703)) @zimp-wow 2025-02-21
+
+### Quest API
+
+* Add GetSpawn() to Perl and Lua ([#4702](https://github.com/EQEmu/Server/pull/4702)) @Kinglykrab 2025-02-22
+
+## [23.0.1] 2/20/2025
+
+### Fixes
+
+* Player event ordering merge fix ([#4699](https://github.com/EQEmu/Server/pull/4699)) @Akkadius 2025-02-20
+
+### Quest API
+
+* Add DisableRespawnTimers to Perl and Lua ([#4691](https://github.com/EQEmu/Server/pull/4691)) @Kinglykrab 2025-02-20
+
+## [23.0.0] 2/19/2025
+
+### Bots
+
+* Add AEHateLine to HateLine ParentType ([#4678](https://github.com/EQEmu/Server/pull/4678)) @nytmyr 2025-02-15
+* Add IsInRaidOrGroup checks to ^attack and ^pull ([#4654](https://github.com/EQEmu/Server/pull/4654)) @nytmyr 2025-02-07
+* Add missing stance options ([#4681](https://github.com/EQEmu/Server/pull/4681)) @nytmyr 2025-02-15
+* Bot Overhaul ([#4580](https://github.com/EQEmu/Server/pull/4580)) @nytmyr 2025-02-03
+* Command Cleanup ([#4676](https://github.com/EQEmu/Server/pull/4676)) @nytmyr 2025-02-15
+* Correct camp count on ^camp ([#4650](https://github.com/EQEmu/Server/pull/4650)) @nytmyr 2025-02-06
+* Correct helper message for forced casts ([#4656](https://github.com/EQEmu/Server/pull/4656)) @nytmyr 2025-02-07
+* Crash fixes related to GetNumberNeedingHealedInGroup ([#4684](https://github.com/EQEmu/Server/pull/4684)) @nytmyr 2025-02-15
+* Fix AE range calculation ([#4683](https://github.com/EQEmu/Server/pull/4683)) @nytmyr 2025-02-15
+* Fix Bards not casting ([#4638](https://github.com/EQEmu/Server/pull/4638)) @nytmyr 2025-02-03
+* Fix a couple potential crashes with GetNumberNeedingHealedInGroup ([#4652](https://github.com/EQEmu/Server/pull/4652)) @nytmyr 2025-02-07
+* Fix crash related to GetTempSpellType() ([#4649](https://github.com/EQEmu/Server/pull/4649)) @nytmyr 2025-02-06
+* Fix pets causing aggro ([#4677](https://github.com/EQEmu/Server/pull/4677)) @nytmyr 2025-02-15
+* Fix spell priority commands ([#4660](https://github.com/EQEmu/Server/pull/4660)) @nytmyr 2025-02-08
+* Fix typo in positioning ([#4659](https://github.com/EQEmu/Server/pull/4659)) @nytmyr 2025-02-08
+* Move BotGetSpellsByType to cache ([#4655](https://github.com/EQEmu/Server/pull/4655)) @nytmyr 2025-02-07
+* Prevents casting on ineligible targets due to target type, stacking, etc. ([#4680](https://github.com/EQEmu/Server/pull/4680)) @nytmyr 2025-02-15
+* Sanity checks for spell type updates ([#4641](https://github.com/EQEmu/Server/pull/4641)) @nytmyr 2025-02-05
+
+### Bug
+
+* Item Purchase Offset when multiple buyers are buying at the same time. ([#4628](https://github.com/EQEmu/Server/pull/4628)) @fryguy503 2025-02-06
+
+### CI
+
+* Fix database race condition ([#4646](https://github.com/EQEmu/Server/pull/4646)) @Akkadius 2025-02-06
+
+### Client Mod
+
+* Adds a hacked fast camp rule for GMs ([#4697](https://github.com/EQEmu/Server/pull/4697)) @KimLS 2025-02-20
+
+### Code
+
+* Bot RaidGroupSay ([#4653](https://github.com/EQEmu/Server/pull/4653)) @nytmyr 2025-02-07
+* Cleanup logic in cursor bag check ([#4642](https://github.com/EQEmu/Server/pull/4642)) @nytmyr 2025-02-04
+* Use Repositories for Titles ([#4608](https://github.com/EQEmu/Server/pull/4608)) @Kinglykrab 2025-02-07
+
+### Commands
+
+* Fix #goto not accepting proper heading ([#4685](https://github.com/EQEmu/Server/pull/4685)) @nytmyr 2025-02-15
+* Fix Illusion Block ([#4666](https://github.com/EQEmu/Server/pull/4666)) @nytmyr 2025-02-12
+
+### Crash
+
+* Fix raid/group crash regression ([#4671](https://github.com/EQEmu/Server/pull/4671)) @Akkadius 2025-02-12
+* Fix zone crash caused by NPC::MoveTo ([#4639](https://github.com/EQEmu/Server/pull/4639)) @catapultam-habeo 2025-02-03
+
+### Databuckets
+
+* Add Zone Scoped Databuckets ([#4690](https://github.com/EQEmu/Server/pull/4690)) @Akkadius 2025-02-18
+
+### Expeditions
+
+* Move expedition code into DynamicZone ([#4672](https://github.com/EQEmu/Server/pull/4672)) @hgtw 2025-02-16
+
+### Feature
+
+* Add Support for Tradeskill Recipe Inspect ([#4648](https://github.com/EQEmu/Server/pull/4648)) @Kinglykrab 2025-02-06
+* Add rule to allow /changepetname to function without being enabled by scripts.  @catapultam-habeo 2025-02-05
+* GuildBank Updates ([#4674](https://github.com/EQEmu/Server/pull/4674)) @neckkola 2025-02-15
+* Implement Big Bags ([#4606](https://github.com/EQEmu/Server/pull/4606)) @Kinglykrab 2025-02-03
+
+### Fixes
+
+* #rq and #reload quest alias ([#4694](https://github.com/EQEmu/Server/pull/4694)) @Akkadius 2025-02-18
+* Always spawn zone controller first ([#4669](https://github.com/EQEmu/Server/pull/4669)) @Akkadius 2025-02-12
+* Big Bag Cleanup ([#4643](https://github.com/EQEmu/Server/pull/4643)) @fryguy503 2025-02-05
+* Big Bag additional fixes ([#4644](https://github.com/EQEmu/Server/pull/4644)) @fryguy503 2025-02-05
+* Change logging level for no items found in a bazaar search to reduce spam logs. ([#4675](https://github.com/EQEmu/Server/pull/4675)) @neckkola 2025-02-13
+* Find Zone - Expansion Settings ([#4692](https://github.com/EQEmu/Server/pull/4692)) @MortimerGreenwald 2025-02-18
+* Fix Beastlord Warder Size Modifier ([#4665](https://github.com/EQEmu/Server/pull/4665)) @Kinglykrab 2025-02-12
+* Fix CI since hand-ins are merged  @Akkadius 2025-02-03
+* Fix Illusion Fade Texture Bug ([#4673](https://github.com/EQEmu/Server/pull/4673)) @Kinglykrab 2025-02-14
+* Fix Item Discovery ([#4663](https://github.com/EQEmu/Server/pull/4663)) @Kinglykrab 2025-02-10
+* Fix ST_GroupNoPets and ST_GroupClientAndPet ([#4667](https://github.com/EQEmu/Server/pull/4667)) @nytmyr 2025-02-10
+* Fix SendStatsWindow Mod2 Value Display ([#4658](https://github.com/EQEmu/Server/pull/4658)) @Kinglykrab 2025-02-07
+* Fix Tradeskill Queries ([#4661](https://github.com/EQEmu/Server/pull/4661)) @Kinglykrab 2025-02-09
+* Fix error in update manifest ([#4637](https://github.com/EQEmu/Server/pull/4637)) @nytmyr 2025-02-03
+* Fix issue with getting an unset nested databucket ([#4693](https://github.com/EQEmu/Server/pull/4693)) @Akkadius 2025-02-19
+* Fix non-error in player_event_logs ([#4695](https://github.com/EQEmu/Server/pull/4695)) @Akkadius 2025-02-18
+* GMMove Update Edge Case With Clients ([#4686](https://github.com/EQEmu/Server/pull/4686)) @Akkadius 2025-02-15
+* Item Handins to Pets ([#4687](https://github.com/EQEmu/Server/pull/4687)) @Akkadius 2025-02-15
+* Parcel Delivery Updates ([#4688](https://github.com/EQEmu/Server/pull/4688)) @neckkola 2025-02-16
+* Prevent zone from loading ETL ID's on bootup ([#4696](https://github.com/EQEmu/Server/pull/4696)) @Akkadius 2025-02-18
+* Update pre big bag corpse slot_id's to support big bags ([#4679](https://github.com/EQEmu/Server/pull/4679)) @nytmyr 2025-02-15
+
+### Inventory
+
+* Fix cursor bag saving to invalid slot_ids ([#4640](https://github.com/EQEmu/Server/pull/4640)) @nytmyr 2025-02-04
+
+### Items
+
+* Overhaul Item Hand-in System ([#4593](https://github.com/EQEmu/Server/pull/4593)) @Akkadius 2025-02-03
+
+### Loginserver
+
+* Fix iterator crash ([#4670](https://github.com/EQEmu/Server/pull/4670)) @Akkadius 2025-02-12
+* Modernize codebase ([#4647](https://github.com/EQEmu/Server/pull/4647)) @Akkadius 2025-02-06
+
+### NPC Handins
+
+* Fix MultiQuest Handins ([#4651](https://github.com/EQEmu/Server/pull/4651)) @Akkadius 2025-02-07
+
+### Performance
+
+* Server Reload Overhaul ([#4689](https://github.com/EQEmu/Server/pull/4689)) @Akkadius 2025-02-18
+
+### Player Event Logs
+
+* Migrate and Deprecate QS Legacy Logging ([#4542](https://github.com/EQEmu/Server/pull/4542)) @neckkola 2025-02-05
+
+### Quest API
+
+* Add Bandolier Methods ([#4635](https://github.com/EQEmu/Server/pull/4635)) @Kinglykrab 2025-02-03
+* Add Potion Belt Methods ([#4634](https://github.com/EQEmu/Server/pull/4634)) @Kinglykrab 2025-02-04
+* Add Zone Support to Perl and Lua ([#4662](https://github.com/EQEmu/Server/pull/4662)) @Kinglykrab 2025-02-09
+
+### Spells
+
+* Add all types to checks for max_targets_allowed rule for AEs ([#4682](https://github.com/EQEmu/Server/pull/4682)) @nytmyr 2025-02-15
+
 ## [22.62.2] 2/1/2025

 ### Fixes
@@ -22,6 +22,7 @@ SET(common_sources
    dbcore.cpp
    deity.cpp
    dynamic_zone_base.cpp
+    dynamic_zone_lockout.cpp
    emu_constants.cpp
    emu_limits.cpp
    emu_opcodes.cpp
@@ -40,7 +41,6 @@ SET(common_sources
    events/player_event_logs.cpp
    events/player_event_discord_formatter.cpp
    evolving_items.cpp
-    expedition_lockout_timer.cpp
    extprofile.cpp
    discord/discord_manager.cpp
    faction.cpp
@@ -213,10 +213,9 @@ SET(repositories
    repositories/base/base_discovered_items_repository.h
    repositories/base/base_doors_repository.h
    repositories/base/base_dynamic_zones_repository.h
+    repositories/base/base_dynamic_zone_lockouts_repository.h
    repositories/base/base_dynamic_zone_members_repository.h
    repositories/base/base_dynamic_zone_templates_repository.h
-    repositories/base/base_expeditions_repository.h
-    repositories/base/base_expedition_lockouts_repository.h
    repositories/base/base_faction_association_repository.h
    repositories/base/base_faction_base_data_repository.h
    repositories/base/base_faction_list_repository.h
@@ -410,10 +409,9 @@ SET(repositories
    repositories/discovered_items_repository.h
    repositories/doors_repository.h
    repositories/dynamic_zones_repository.h
+    repositories/dynamic_zone_lockouts_repository.h
    repositories/dynamic_zone_members_repository.h
    repositories/dynamic_zone_templates_repository.h
-    repositories/expeditions_repository.h
-    repositories/expedition_lockouts_repository.h
    repositories/faction_association_repository.h
    repositories/faction_base_data_repository.h
    repositories/faction_list_repository.h
@@ -561,6 +559,7 @@ SET(common_headers
    discord/discord.h
    discord/discord_manager.h
    dynamic_zone_base.h
+    dynamic_zone_lockout.h
    emu_constants.h
    emu_limits.h
    emu_opcodes.h
@@ -587,7 +586,6 @@ SET(common_headers
    events/player_events.h
    event_sub.h
    evolving_items.h
-    expedition_lockout_timer.h
    extprofile.h
    faction.h
    file.h
@@ -647,6 +645,7 @@ SET(common_headers
    server_event_scheduler.h
    serverinfo.h
    servertalk.h
+    server_reload_types.h
    shared_tasks.h
    shareddb.h
    skills.h
@@ -245,7 +245,7 @@ uint32 Database::CreateAccount(
 		e.password = password;
 	}

-	LogInfo("Account Attempting to be created: [{}:{}] status: {}", loginserver, name, status);
+	LogInfo("Account attempting to be created loginserver [{}] name [{}] status [{}]", loginserver, name, status);

 	e = AccountRepository::InsertOne(*this, e);

@@ -596,7 +596,12 @@ void DatabaseDumpService::BuildCredentialsFile()
 void DatabaseDumpService::RemoveCredentialsFile()
 {
 	if (File::Exists(CREDENTIALS_FILE)) {
-		std::filesystem::remove(CREDENTIALS_FILE);
+		try {
+			std::filesystem::remove(CREDENTIALS_FILE);
+		}
+		catch (std::exception &e) {
+			LogError("std::filesystem::remove err [{}]", e.what());
+		}
 	}
 }

@@ -6417,7 +6417,7 @@ ADD COLUMN `guid` bigint(20) UNSIGNED NOT NULL DEFAULT 0 AFTER `ornament_hero_mo
 ADD PRIMARY KEY (`account_id`, `slot_id`);
 )",
 		.content_schema_update = false,
-		.force_interactive = true
+		.force_interactive = false
 	},
 	ManifestEntry{
 		.version = 9298,
@@ -6481,7 +6481,7 @@ UPDATE `sharedbank` SET `slot_id` = ((`slot_id` - 2531) + 11010) WHERE `slot_id`
 UPDATE `sharedbank` SET `slot_id` = ((`slot_id` - 2541) + 11210) WHERE `slot_id` BETWEEN 2541 AND 2550; -- Shared Bank Bag 2
 )",
 		.content_schema_update = false,
-		.force_interactive = true
+		.force_interactive = false
 	},
 	ManifestEntry{
 		.version = 9299,
@@ -6770,7 +6770,174 @@ SET `aliases` =
 WHERE `command` = 'illusionblock'
 AND `aliases` NOT LIKE '%ib%';
 )",
-	}
+	},
+	ManifestEntry{
+		.version = 9303,
+		.description = "2025_02_13_corpse_slot_fix.sql",
+		.check = "SELECT * FROM `character_corpse_items` WHERE `equip_slot` BETWEEN 251 AND 350",
+		.condition = "not_empty",
+		.match = "",
+		.sql = R"(
+UPDATE `character_corpse_items` SET `equip_slot` = ((`equip_slot` - 251) + 4010) WHERE `equip_slot` BETWEEN 251 AND 260; -- Bag 1
+UPDATE `character_corpse_items` SET `equip_slot` = ((`equip_slot` - 261) + 4210) WHERE `equip_slot` BETWEEN 261 AND 270; -- Bag 2
+UPDATE `character_corpse_items` SET `equip_slot` = ((`equip_slot` - 271) + 4410) WHERE `equip_slot` BETWEEN 271 AND 280; -- Bag 3
+UPDATE `character_corpse_items` SET `equip_slot` = ((`equip_slot` - 281) + 4610) WHERE `equip_slot` BETWEEN 281 AND 290; -- Bag 4
+UPDATE `character_corpse_items` SET `equip_slot` = ((`equip_slot` - 291) + 4810) WHERE `equip_slot` BETWEEN 291 AND 300; -- Bag 5
+UPDATE `character_corpse_items` SET `equip_slot` = ((`equip_slot` - 301) + 5010) WHERE `equip_slot` BETWEEN 301 AND 310; -- Bag 6
+UPDATE `character_corpse_items` SET `equip_slot` = ((`equip_slot` - 311) + 5210) WHERE `equip_slot` BETWEEN 311 AND 320; -- Bag 7
+UPDATE `character_corpse_items` SET `equip_slot` = ((`equip_slot` - 321) + 5410) WHERE `equip_slot` BETWEEN 321 AND 330; -- Bag 8
+UPDATE `character_corpse_items` SET `equip_slot` = ((`equip_slot` - 331) + 5610) WHERE `equip_slot` BETWEEN 331 AND 340; -- Bag 9
+UPDATE `character_corpse_items` SET `equip_slot` = ((`equip_slot` - 341) + 5810) WHERE `equip_slot` BETWEEN 341 AND 350; -- Bag 10
+)",
+	},
+	ManifestEntry{
+		.version     = 9304,
+		.description = "2024_12_01_2024_update_guild_bank",
+		.check       = "SHOW COLUMNS FROM `guild_bank` LIKE 'augment_one_id'",
+		.condition   = "empty",
+		.match       = "",
+		.sql         = R"(
+ALTER TABLE `guild_bank`
+	DROP INDEX `guildid`,
+	CHANGE COLUMN `guildid` `guild_id` INT(10) UNSIGNED NOT NULL DEFAULT '0' AFTER `id`,
+	CHANGE COLUMN `itemid` `item_id` INT(10) UNSIGNED NOT NULL DEFAULT '0' AFTER `slot`,
+	CHANGE COLUMN `whofor` `who_for` VARCHAR(64) NULL DEFAULT NULL COLLATE 'utf8_general_ci' AFTER `permissions`,
+	ADD COLUMN `augment_one_id` INT UNSIGNED NULL DEFAULT '0' AFTER `item_id`,
+	ADD COLUMN `augment_two_id` INT UNSIGNED NULL DEFAULT '0' AFTER `augment_one_id`,
+	ADD COLUMN `augment_three_id` INT UNSIGNED NULL DEFAULT '0' AFTER `augment_two_id`,
+	ADD COLUMN `augment_four_id` INT UNSIGNED NULL DEFAULT '0' AFTER `augment_three_id`,
+	ADD COLUMN `augment_five_id` INT UNSIGNED NULL DEFAULT '0' AFTER `augment_four_id`,
+	ADD COLUMN `augment_six_id` INT UNSIGNED NULL DEFAULT '0' AFTER `augment_five_id`,
+	CHANGE COLUMN `qty` `quantity` INT(10) NOT NULL DEFAULT '0' AFTER `augment_six_id`;
+ALTER TABLE `guild_bank`
+	ADD INDEX `guild_id` (`guild_id`);
+)"
+	},
+	ManifestEntry{
+		.version = 9305,
+		.description = "2024_12_01_expedition_dz_merge.sql",
+		.check = "SHOW COLUMNS FROM `dynamic_zones` LIKE 'is_locked'",
+		.condition = "empty",
+		.match = "",
+		.sql = R"(
+ALTER TABLE `dynamic_zones`
+	ADD COLUMN `is_locked` TINYINT NOT NULL DEFAULT '0' AFTER `has_zone_in`,
+	ADD COLUMN `add_replay` TINYINT NOT NULL DEFAULT '1' AFTER `is_locked`;
+
+ALTER TABLE `expedition_lockouts`
+	CHANGE COLUMN `expedition_id` `dynamic_zone_id` INT(10) UNSIGNED NOT NULL AFTER `id`,
+	DROP INDEX `expedition_id_event_name`,
+	ADD UNIQUE INDEX `dz_id_event_name` (`dynamic_zone_id`, `event_name`) USING BTREE;
+
+UPDATE expedition_lockouts lockouts
+	INNER JOIN expeditions ON lockouts.dynamic_zone_id = expeditions.id
+	SET lockouts.dynamic_zone_id = expeditions.dynamic_zone_id;
+
+DROP TABLE `expeditions`;
+
+RENAME TABLE `expedition_lockouts` TO `dynamic_zone_lockouts`;
+)"
+	},
+	ManifestEntry{
+		.version = 9306,
+		.description = "2025_02_16_data_buckets_zone_id_instance_id.sql",
+		.check       = "SHOW COLUMNS FROM `data_buckets` LIKE 'zone_id'",
+		.condition   = "empty",
+		.match = "",
+		.sql = R"(
+-- ✅ Drop old indexes
+DROP INDEX IF EXISTS `keys` ON `data_buckets`;
+DROP INDEX IF EXISTS `idx_npc_expires` ON `data_buckets`;
+DROP INDEX IF EXISTS `idx_bot_expires` ON `data_buckets`;
+
+-- Add zone_id, instance_id
+ALTER TABLE `data_buckets`
+	MODIFY COLUMN `npc_id` int(11) NOT NULL DEFAULT 0 AFTER `character_id`,
+	MODIFY COLUMN `bot_id` int(11) NOT NULL DEFAULT 0 AFTER `npc_id`,
+	ADD COLUMN `zone_id` smallint(11) UNSIGNED NOT NULL DEFAULT 0 AFTER `bot_id`,
+	ADD COLUMN `instance_id` smallint(11) UNSIGNED NOT NULL DEFAULT 0 AFTER `zone_id`;
+
+ALTER TABLE `data_buckets`
+	MODIFY COLUMN `account_id` bigint(11) UNSIGNED NULL DEFAULT 0 AFTER `expires`,
+	MODIFY COLUMN `character_id` bigint(11) UNSIGNED NOT NULL DEFAULT 0 AFTER `account_id`,
+	MODIFY COLUMN `npc_id` int(11) UNSIGNED NOT NULL DEFAULT 0 AFTER `character_id`,
+	MODIFY COLUMN `bot_id` int(11) UNSIGNED NOT NULL DEFAULT 0 AFTER `npc_id`;
+
+-- ✅ Create optimized unique index with `key` first
+CREATE UNIQUE INDEX `keys` ON data_buckets (`key`, character_id, npc_id, bot_id, account_id, zone_id, instance_id);
+
+-- ✅ Create indexes for just instance_id (instance deletion)
+CREATE INDEX idx_instance_id ON data_buckets (instance_id);
+)",
+		.content_schema_update = false
+	},
+	ManifestEntry{
+		.version     = 9307,
+		.description = "2025_02_17_zone_state_spawns.sql",
+		.check       = "SHOW TABLES LIKE 'zone_state_spawns'",
+		.condition   = "empty",
+		.match       = "",
+		.sql         = R"(
+CREATE TABLE `zone_state_spawns` (
+  `id` bigint(20) NOT NULL AUTO_INCREMENT,
+  `zone_id` int(11) unsigned DEFAULT NULL,
+  `instance_id` int(11) unsigned DEFAULT NULL,
+  `is_corpse` tinyint(11) DEFAULT 0,
+  `decay_in_seconds` int(11) DEFAULT 0,
+  `npc_id` int(10) unsigned DEFAULT NULL,
+  `spawn2_id` int(10) unsigned NOT NULL,
+  `spawngroup_id` int(10) unsigned NOT NULL,
+  `x` float NOT NULL,
+  `y` float NOT NULL,
+  `z` float NOT NULL,
+  `heading` float NOT NULL,
+  `respawn_time` int(10) unsigned NOT NULL,
+  `variance` int(10) unsigned NOT NULL,
+  `grid` int(10) unsigned DEFAULT 0,
+  `current_waypoint` int(11) DEFAULT 0,
+  `path_when_zone_idle` smallint(6) DEFAULT 0,
+  `condition_id` smallint(5) unsigned DEFAULT 0,
+  `condition_min_value` smallint(6) DEFAULT 0,
+  `enabled` smallint(6) DEFAULT 1,
+  `anim` smallint(5) unsigned DEFAULT 0,
+  `loot_data` text DEFAULT NULL,
+  `entity_variables` text DEFAULT NULL,
+  `buffs` text DEFAULT NULL,
+  `hp` bigint(20) DEFAULT 0,
+  `mana` bigint(20) DEFAULT 0,
+  `endurance` bigint(20) DEFAULT 0,
+  `created_at` datetime DEFAULT NULL,
+  PRIMARY KEY (`id`)
+) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8mb4
+)",
+		.content_schema_update = false
+	},
+	ManifestEntry{
+		.version = 9308,
+		.description = "2025_add_multivalue_support_to_evolving_subtype.sql",
+		.check = "SHOW COLUMNS FROM `items_evolving_details` LIKE 'sub_type'",
+		.condition = "missing",
+		.match = "varchar(200)",
+		.sql = R"(
+ALTER TABLE `items_evolving_details`
+	CHANGE COLUMN `sub_type` `sub_type` VARCHAR(200) NULL DEFAULT '0' AFTER `type`;
+)",
+		.content_schema_update = true
+	},
+	// this one got missed being added to PEQ dumps so adding it again so it gets added when folks take a new release
+	ManifestEntry{
+		.version = 9309,
+		.description = "2025_03_1_create_pet_names_table_if_not_exist.sql",
+		.check = "SHOW TABLES LIKE 'character_pet_name'",
+		.condition = "empty",
+		.match = "",
+		.sql = R"(
+CREATE TABLE `character_pet_name` (
+    `character_id` INT(11) NOT NULL PRIMARY KEY,
+    `name` VARCHAR(64) NOT NULL
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
+)",
+	},
 // -- template; copy/paste this when you need to create a new entry
 //	ManifestEntry{
 //		.version = 9228,
@@ -30,7 +30,7 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 #include "../common/repositories/respawn_times_repository.h"
 #include "../common/repositories/spawn_condition_values_repository.h"
 #include "repositories/spawn2_disabled_repository.h"
-
+#include "repositories/data_buckets_repository.h"

 #include "database.h"

@@ -479,6 +479,7 @@ void Database::DeleteInstance(uint16 instance_id)
 	DynamicZoneMembersRepository::DeleteByInstance(*this, instance_id);
 	DynamicZonesRepository::DeleteWhere(*this, fmt::format("instance_id = {}", instance_id));
 	CharacterCorpsesRepository::BuryInstance(*this, instance_id);
+	DataBucketsRepository::DeleteWhere(*this, fmt::format("instance_id = {}", instance_id));
 }

 void Database::FlagInstanceByGroupLeader(uint32 zone_id, int16 version, uint32 character_id, uint32 group_id)
@@ -139,6 +139,7 @@ namespace DatabaseSchema {
 			"character_pet_buffs",
 			"character_pet_info",
 			"character_pet_inventory",
+			"character_pet_name",
 			"character_peqzone_flags",
 			"character_potionbelt",
 			"character_skills",
@@ -311,10 +312,9 @@ namespace DatabaseSchema {
 			"completed_shared_task_members",
 			"completed_shared_tasks",
 			"discord_webhooks",
+			"dynamic_zone_lockouts",
 			"dynamic_zone_members",
 			"dynamic_zones",
-			"expedition_lockouts",
-			"expeditions",
 			"gm_ips",
 			"group_id",
 			"group_leaders",
@@ -351,6 +351,7 @@ namespace DatabaseSchema {
 			"shared_task_dynamic_zones",
 			"shared_task_members",
 			"shared_tasks",
+			"zone_state_spawns",
 		};
 	}

@@ -1,11 +1,13 @@
 #include "dynamic_zone_base.h"
 #include "database.h"
 #include "eqemu_logsys.h"
-#include "repositories/instance_list_repository.h"
-#include "repositories/instance_list_player_repository.h"
 #include "rulesys.h"
 #include "servertalk.h"
 #include "util/uuid.h"
+#include "repositories/character_expedition_lockouts_repository.h"
+#include "repositories/dynamic_zone_lockouts_repository.h"
+#include "repositories/instance_list_repository.h"
+#include "repositories/instance_list_player_repository.h"

 DynamicZoneBase::DynamicZoneBase(DynamicZonesRepository::DynamicZoneInstance&& entry)
 {
@@ -93,13 +95,15 @@ void DynamicZoneBase::LoadRepositoryResult(DynamicZonesRepository::DynamicZoneIn
 	m_zonein.y           = dz_entry.zone_in_y;
 	m_zonein.z           = dz_entry.zone_in_z;
 	m_zonein.heading     = dz_entry.zone_in_heading;
-	m_has_zonein         = (dz_entry.has_zone_in != 0);
+	m_has_zonein         = dz_entry.has_zone_in != 0;
+	m_is_locked          = dz_entry.is_locked;
+	m_add_replay         = dz_entry.add_replay;
 	// instance_list portion
 	m_zone_id            = dz_entry.zone;
 	m_zone_version       = dz_entry.version;
 	m_start_time         = std::chrono::system_clock::from_time_t(dz_entry.start_time);
 	m_duration           = std::chrono::seconds(dz_entry.duration);
-	m_never_expires      = (dz_entry.never_expires != 0);
+	m_never_expires      = dz_entry.never_expires != 0;
 	m_expire_time        = m_start_time + m_duration;
 }

@@ -119,37 +123,40 @@ void DynamicZoneBase::AddMemberFromRepositoryResult(
 uint32_t DynamicZoneBase::SaveToDatabase()
 {
 	LogDynamicZonesDetail("Saving dz instance [{}] to database", m_instance_id);
-
-	if (m_instance_id != 0)
+	if (m_instance_id == 0)
 	{
-		auto insert_dz = DynamicZonesRepository::NewEntity();
-		insert_dz.uuid                = m_uuid;
-		insert_dz.name                = m_name;
-		insert_dz.leader_id           = m_leader.id;
-		insert_dz.min_players         = m_min_players;
-		insert_dz.max_players         = m_max_players;
-		insert_dz.instance_id         = m_instance_id,
-		insert_dz.type                = static_cast<int>(m_type);
-		insert_dz.dz_switch_id        = m_dz_switch_id;
-		insert_dz.compass_zone_id     = m_compass.zone_id;
-		insert_dz.compass_x           = m_compass.x;
-		insert_dz.compass_y           = m_compass.y;
-		insert_dz.compass_z           = m_compass.z;
-		insert_dz.safe_return_zone_id = m_safereturn.zone_id;
-		insert_dz.safe_return_x       = m_safereturn.x;
-		insert_dz.safe_return_y       = m_safereturn.y;
-		insert_dz.safe_return_z       = m_safereturn.z;
-		insert_dz.safe_return_heading = m_safereturn.heading;
-		insert_dz.zone_in_x           = m_zonein.x;
-		insert_dz.zone_in_y           = m_zonein.y;
-		insert_dz.zone_in_z           = m_zonein.z;
-		insert_dz.zone_in_heading     = m_zonein.heading;
-		insert_dz.has_zone_in         = m_has_zonein;
-
-		auto inserted_dz = DynamicZonesRepository::InsertOne(GetDatabase(), insert_dz);
-		return inserted_dz.id;
+		return 0;
 	}
-	return 0;
+
+	auto dz = DynamicZonesRepository::NewEntity();
+	dz.uuid                = m_uuid;
+	dz.name                = m_name;
+	dz.leader_id           = m_leader.id;
+	dz.min_players         = m_min_players;
+	dz.max_players         = m_max_players;
+	dz.instance_id         = static_cast<int32_t>(m_instance_id),
+	dz.type                = static_cast<uint8_t>(m_type);
+	dz.dz_switch_id        = m_dz_switch_id;
+	dz.compass_zone_id     = m_compass.zone_id;
+	dz.compass_x           = m_compass.x;
+	dz.compass_y           = m_compass.y;
+	dz.compass_z           = m_compass.z;
+	dz.safe_return_zone_id = m_safereturn.zone_id;
+	dz.safe_return_x       = m_safereturn.x;
+	dz.safe_return_y       = m_safereturn.y;
+	dz.safe_return_z       = m_safereturn.z;
+	dz.safe_return_heading = m_safereturn.heading;
+	dz.zone_in_x           = m_zonein.x;
+	dz.zone_in_y           = m_zonein.y;
+	dz.zone_in_z           = m_zonein.z;
+	dz.zone_in_heading     = m_zonein.heading;
+	dz.has_zone_in         = static_cast<uint8_t>(m_has_zonein);
+	dz.is_locked           = static_cast<int8_t>(m_is_locked);
+	dz.add_replay          = static_cast<int8_t>(m_add_replay);
+
+	dz = DynamicZonesRepository::InsertOne(GetDatabase(), std::move(dz));
+
+	return dz.id;
 }

 bool DynamicZoneBase::AddMember(const DynamicZoneMember& add_member)
@@ -196,10 +203,9 @@ bool DynamicZoneBase::RemoveMember(const DynamicZoneMember& remove_member)
 	return true;
 }

-bool DynamicZoneBase::SwapMember(
-	const DynamicZoneMember& add_member, const std::string& remove_char_name)
+bool DynamicZoneBase::SwapMember(const DynamicZoneMember& add_member, const std::string& remove_name)
 {
-	auto remove_member = GetMemberData(remove_char_name);
+	auto remove_member = GetMemberData(remove_name);
 	if (!add_member.IsValid() || !remove_member.IsValid())
 	{
 		return false;
@@ -230,9 +236,18 @@ void DynamicZoneBase::RemoveAllMembers()

 void DynamicZoneBase::SaveMembers(const std::vector<DynamicZoneMember>& members)
 {
+	if (members.empty())
+	{
+		return;
+	}
+
 	LogDynamicZonesDetail("Saving [{}] member(s) for dz [{}]", members.size(), m_id);

 	m_members = members;
+	if (m_members.size() > m_max_players)
+	{
+		m_members.resize(m_max_players);
+	}

 	// the lower level instance_list_players needs to be kept updated as well
 	std::vector<DynamicZoneMembersRepository::DynamicZoneMembers> insert_members;
@@ -242,12 +257,12 @@ void DynamicZoneBase::SaveMembers(const std::vector<DynamicZoneMember>& members)
 		DynamicZoneMembersRepository::DynamicZoneMembers member_entry{};
 		member_entry.dynamic_zone_id = m_id;
 		member_entry.character_id = member.id;
-		insert_members.emplace_back(member_entry);
+		insert_members.push_back(member_entry);

-		InstanceListPlayerRepository::InstanceListPlayer player_entry;
-		player_entry.id = static_cast<int>(m_instance_id);
-		player_entry.charid = static_cast<int>(member.id);
-		insert_players.emplace_back(player_entry);
+		InstanceListPlayerRepository::InstanceListPlayer player_entry{};
+		player_entry.id = m_instance_id;
+		player_entry.charid = member.id;
+		insert_players.push_back(player_entry);
 	}

 	DynamicZoneMembersRepository::InsertOrUpdateMany(GetDatabase(), insert_members);
@@ -339,6 +354,44 @@ void DynamicZoneBase::SetLeader(const DynamicZoneMember& new_leader, bool update
 	}
 }

+void DynamicZoneBase::SetLocked(bool lock, bool update_db, DzLockMsg lock_msg, uint32_t color)
+{
+	m_is_locked = lock;
+
+	if (update_db)
+	{
+		DynamicZonesRepository::UpdateLocked(GetDatabase(), m_id, lock);
+
+		ServerPacket pack(ServerOP_DzLock, sizeof(ServerDzLock_Struct));
+		auto buf = reinterpret_cast<ServerDzLock_Struct*>(pack.pBuffer);
+		buf->dz_id = GetID();
+		buf->sender_zone_id = GetCurrentZoneID();
+		buf->sender_instance_id = GetCurrentInstanceID();
+		buf->lock = m_is_locked;
+		buf->lock_msg = static_cast<uint8_t>(lock_msg);
+		buf->color = color;
+		SendServerPacket(&pack);
+	}
+}
+
+void DynamicZoneBase::SetReplayOnJoin(bool enabled, bool update_db)
+{
+	m_add_replay = enabled;
+
+	if (update_db)
+	{
+		DynamicZonesRepository::UpdateReplayOnJoin(GetDatabase(), m_id, enabled);
+
+		ServerPacket pack(ServerOP_DzReplayOnJoin, sizeof(ServerDzBool_Struct));
+		auto buf = reinterpret_cast<ServerDzBool_Struct*>(pack.pBuffer);
+		buf->dz_id = GetID();
+		buf->sender_zone_id = GetCurrentZoneID();
+		buf->sender_instance_id = GetCurrentInstanceID();
+		buf->enabled = enabled;
+		SendServerPacket(&pack);
+	}
+}
+
 uint32_t DynamicZoneBase::GetSecondsRemaining() const
 {
 	auto remaining = std::chrono::duration_cast<std::chrono::seconds>(GetDurationRemaining()).count();
@@ -478,13 +531,13 @@ void DynamicZoneBase::RemoveInternalMember(uint32_t character_id)
 	), m_members.end());
 }

-bool DynamicZoneBase::HasMember(uint32_t character_id)
+bool DynamicZoneBase::HasMember(uint32_t character_id) const
 {
 	return std::any_of(m_members.begin(), m_members.end(),
 		[&](const DynamicZoneMember& member) { return member.id == character_id; });
 }

-bool DynamicZoneBase::HasMember(const std::string& character_name)
+bool DynamicZoneBase::HasMember(const std::string& character_name) const
 {
 	return std::any_of(m_members.begin(), m_members.end(),
 		[&](const DynamicZoneMember& member) {
@@ -590,35 +643,34 @@ std::string DynamicZoneBase::GetDynamicZoneTypeName(DynamicZoneType dz_type)
 	}
 }

-EQ::Net::DynamicPacket DynamicZoneBase::GetSerializedDzPacket()
+std::unique_ptr<ServerPacket> DynamicZoneBase::CreateServerPacket(uint16_t zone_id, uint16_t instance_id)
 {
-	EQ::Net::DynamicPacket dyn_pack;
-	dyn_pack.PutSerialize(0, *this);
+	std::ostringstream ss = GetSerialized();
+	std::string_view sv = ss.view();

-	LogDynamicZonesDetail("Serialized server dz size [{}]", dyn_pack.Length());
-	return dyn_pack;
-}
-
-std::unique_ptr<ServerPacket> DynamicZoneBase::CreateServerDzCreatePacket(
-	uint16_t origin_zone_id, uint16_t origin_instance_id)
-{
-	EQ::Net::DynamicPacket dyn_pack = GetSerializedDzPacket();
-
-	auto pack_size = sizeof(ServerDzCreateSerialized_Struct) + dyn_pack.Length();
+	auto pack_size = sizeof(ServerDzCreate_Struct) + sv.size();
 	auto pack = std::make_unique<ServerPacket>(ServerOP_DzCreated, static_cast<uint32_t>(pack_size));
-	auto buf = reinterpret_cast<ServerDzCreateSerialized_Struct*>(pack->pBuffer);
-	buf->origin_zone_id = origin_zone_id;
-	buf->origin_instance_id = origin_instance_id;
-	buf->cereal_size = static_cast<uint32_t>(dyn_pack.Length());
-	memcpy(buf->cereal_data, dyn_pack.Data(), dyn_pack.Length());
+	auto buf = reinterpret_cast<ServerDzCreate_Struct*>(pack->pBuffer);
+	buf->origin_zone_id = zone_id;
+	buf->origin_instance_id = instance_id;
+	buf->dz_id = GetID();
+	buf->cereal_size = static_cast<uint32_t>(sv.size());
+	memcpy(buf->cereal_data, sv.data(), sv.size());

 	return pack;
 }

-void DynamicZoneBase::LoadSerializedDzPacket(char* cereal_data, uint32_t cereal_size)
+std::ostringstream DynamicZoneBase::GetSerialized()
 {
-	LogDynamicZonesDetail("Deserializing server dz size [{}]", cereal_size);
-	EQ::Util::MemoryStreamReader ss(cereal_data, cereal_size);
+	std::ostringstream ss;
+	cereal::BinaryOutputArchive archive(ss);
+	archive(*this);
+	return ss;
+}
+
+void DynamicZoneBase::Unserialize(std::span<char> buf)
+{
+	EQ::Util::MemoryStreamReader ss(buf.data(), buf.size());
 	cereal::BinaryInputArchive archive(ss);
 	archive(*this);
 }
@@ -647,3 +699,180 @@ void DynamicZoneBase::LoadTemplate(const DynamicZoneTemplatesRepository::Dynamic
 	m_zonein.z           = dz_template.zone_in_z;
 	m_zonein.heading     = dz_template.zone_in_h;
 }
+
+std::vector<uint32_t> DynamicZoneBase::GetMemberIds()
+{
+	std::vector<uint32_t> ids;
+	ids.reserve(m_members.size());
+	for (const auto& member : m_members)
+	{
+		ids.push_back(member.id);
+	}
+	return ids;
+}
+
+bool DynamicZoneBase::HasLockout(const std::string& event)
+{
+	return std::ranges::any_of(m_lockouts, [&](const auto& l) { return l.IsEvent(event); });
+}
+
+bool DynamicZoneBase::HasReplayLockout()
+{
+	return HasLockout(DzLockout::ReplayTimer);
+}
+
+void DynamicZoneBase::AddLockout(const std::string& event, uint32_t seconds)
+{
+	auto lockout = DzLockout::Create(m_name, event, seconds, m_uuid);
+	AddLockout(lockout);
+}
+
+void DynamicZoneBase::AddLockout(const DzLockout& lockout, bool members_only)
+{
+	if (!members_only)
+	{
+		DynamicZoneLockoutsRepository::InsertLockouts(GetDatabase(), GetID(), { lockout });
+	}
+
+	CharacterExpeditionLockoutsRepository::InsertLockout(GetDatabase(), GetMemberIds(), lockout);
+
+	HandleLockoutUpdate(lockout, false, members_only);
+	SendServerPacket(CreateLockoutPacket(lockout, false, members_only).get());
+}
+
+void DynamicZoneBase::AddLockoutDuration(const std::string& event, int seconds, bool members_only)
+{
+	auto lockout = DzLockout::Create(m_name, event, std::max(0, seconds), m_uuid);
+
+	// lockout has unsigned duration, pass original seconds to support reducing existing timers
+	int secs = static_cast<int>(seconds * RuleR(Expedition, LockoutDurationMultiplier));
+	CharacterExpeditionLockoutsRepository::AddLockoutDuration(GetDatabase(), GetMemberIds(), lockout, secs);
+
+	HandleLockoutDuration(lockout, seconds, members_only, true);
+	SendServerPacket(CreateLockoutDurationPacket(lockout, seconds, members_only).get());
+}
+
+void DynamicZoneBase::UpdateLockoutDuration(const std::string& event, uint32_t seconds, bool members_only)
+{
+	// some live expeditions update existing lockout timers during progression
+	auto it = std::ranges::find_if(m_lockouts, [&](const auto& l) { return l.IsEvent(event); });
+	if (it != m_lockouts.end())
+	{
+		seconds = static_cast<uint32_t>(seconds * RuleR(Expedition, LockoutDurationMultiplier));
+		DzLockout lockout(m_uuid, m_name, event, it->GetStartTime() + seconds, seconds);
+		AddLockout(lockout, members_only);
+	}
+}
+
+void DynamicZoneBase::RemoveLockout(const std::string& event)
+{
+	DynamicZoneLockoutsRepository::DeleteWhere(GetDatabase(), fmt::format(
+		"dynamic_zone_id = {} AND event_name = '{}'", GetID(), Strings::Escape(event)));
+
+	CharacterExpeditionLockoutsRepository::DeleteWhere(GetDatabase(), fmt::format(
+		"character_id IN ({}) AND expedition_name = '{}' AND event_name = '{}'",
+		fmt::join(GetMemberIds(), ","), Strings::Escape(m_name), Strings::Escape(event)));
+
+	DzLockout lockout{m_uuid, m_name, event, 0, 0};
+	HandleLockoutUpdate(lockout, true, false);
+	SendServerPacket(CreateLockoutPacket(lockout, true).get());
+}
+
+void DynamicZoneBase::HandleLockoutUpdate(const DzLockout& lockout, bool remove, bool members_only)
+{
+	if (!members_only)
+	{
+		std::erase_if(m_lockouts, [&](const auto& l) { return l.IsEvent(lockout.Event()); });
+		if (!remove)
+		{
+			m_lockouts.push_back(lockout);
+		}
+	}
+}
+
+void DynamicZoneBase::HandleLockoutDuration(const DzLockout& lockout, int seconds, bool members_only, bool insert_db)
+{
+	if (!members_only)
+	{
+		auto it = std::ranges::find_if(m_lockouts, [&](const auto& l) { return l.IsEvent(lockout.Event()); });
+		if (it != m_lockouts.end())
+		{
+			it->AddLockoutTime(seconds);
+		}
+		else
+		{
+			it = m_lockouts.insert(m_lockouts.end(), lockout);
+		}
+
+		if (insert_db)
+		{
+			DynamicZoneLockoutsRepository::InsertLockouts(GetDatabase(), GetID(), { *it });
+		}
+	}
+}
+
+std::unique_ptr<ServerPacket> DynamicZoneBase::CreateLockoutPacket(const DzLockout& lockout, bool remove, bool members_only) const
+{
+	uint32_t pack_size = sizeof(ServerDzLockout_Struct);
+	auto pack = std::make_unique<ServerPacket>(ServerOP_DzLockout, pack_size);
+	auto buf = reinterpret_cast<ServerDzLockout_Struct*>(pack->pBuffer);
+	buf->dz_id = GetID();
+	buf->expire_time = lockout.GetExpireTime();
+	buf->duration = lockout.GetDuration();
+	buf->sender_zone_id = GetCurrentZoneID();
+	buf->sender_instance_id = GetCurrentInstanceID();
+	buf->remove = remove;
+	buf->members_only = members_only;
+	strn0cpy(buf->event_name, lockout.Event().c_str(), sizeof(buf->event_name));
+	return pack;
+}
+
+std::unique_ptr<ServerPacket> DynamicZoneBase::CreateLockoutDurationPacket(const DzLockout& lockout, int seconds, bool members_only) const
+{
+	uint32_t pack_size = sizeof(ServerDzLockout_Struct);
+	auto pack = std::make_unique<ServerPacket>(ServerOP_DzLockoutDuration, pack_size);
+	auto buf = reinterpret_cast<ServerDzLockout_Struct*>(pack->pBuffer);
+	buf->dz_id = GetID();
+	buf->expire_time = lockout.GetExpireTime();
+	buf->duration = lockout.GetDuration();
+	buf->sender_zone_id = GetCurrentZoneID();
+	buf->sender_instance_id = GetCurrentInstanceID();
+	buf->members_only = members_only;
+	buf->seconds = seconds;
+	strn0cpy(buf->event_name, lockout.Event().c_str(), sizeof(buf->event_name));
+	return pack;
+}
+
+void DynamicZoneBase::SyncCharacterLockouts(uint32_t char_id, std::vector<DzLockout>& lockouts)
+{
+	// adds missing event lockouts to client for this expedition and updates
+	// client timers that are both shorter and from another expedition
+	bool modified = false;
+
+	for (const auto& lockout : m_lockouts)
+	{
+		if (lockout.IsReplay() || lockout.IsExpired() || lockout.UUID() != m_uuid)
+		{
+			continue;
+		}
+
+		auto it = std::find_if(lockouts.begin(), lockouts.end(), [&](const DzLockout& l) { return l.IsSame(lockout); });
+		if (it == lockouts.end())
+		{
+			modified = true;
+			lockouts.push_back(lockout); // insert missing
+		}
+		else if (it->GetSecondsRemaining() < lockout.GetSecondsRemaining() && it->UUID() != m_uuid)
+		{
+			// only update lockout timer not uuid so loot event apis still work
+			modified = true;
+			it->SetDuration(lockout.GetDuration());
+			it->SetExpireTime(lockout.GetExpireTime());
+		}
+	}
+
+	if (modified)
+	{
+		CharacterExpeditionLockoutsRepository::InsertLockouts(GetDatabase(), char_id, lockouts);
+	}
+}
@@ -1,8 +1,8 @@
 #ifndef COMMON_DYNAMIC_ZONE_BASE_H
 #define COMMON_DYNAMIC_ZONE_BASE_H

+#include "dynamic_zone_lockout.h"
 #include "eq_constants.h"
-#include "net/packet.h"
 #include "repositories/dynamic_zones_repository.h"
 #include "repositories/dynamic_zone_members_repository.h"
 #include "repositories/dynamic_zone_templates_repository.h"
@@ -10,12 +10,40 @@
 #include <chrono>
 #include <cstdint>
 #include <memory>
+#include <span>
 #include <string>
 #include <vector>

 class Database;
 class ServerPacket;

+// message string 8312 added in September 08 2020 Test patch (used by both dz and shared tasks)
+inline constexpr char DzNotAllAdded[] = "Not all players in your {0} were added to the {1}. The {1} can take a maximum of {2} players, and your {0} has {3}.";
+
+enum class DzLockMsg : uint8_t
+{
+	None = 0, Close, Begin
+};
+
+enum class DynamicZoneType
+{
+	None = 0,
+	Expedition,
+	Tutorial,
+	Task,
+	Mission, // Shared Task
+	Quest
+};
+
+enum class DynamicZoneMemberStatus
+{
+	Unknown = 0,
+	Online,
+	Offline,
+	InDynamicZone,
+	LinkDead
+};
+
 struct DynamicZoneMember
 {
 	uint32_t id = 0;
@@ -93,6 +121,7 @@ public:
 	const std::string& GetName() const { return m_name; }
 	const std::string& GetUUID() const { return m_uuid; }
 	const DynamicZoneMember& GetLeader() const { return m_leader; }
+	const std::vector<DzLockout>& GetLockouts() const { return m_lockouts; }
 	const std::vector<DynamicZoneMember>& GetMembers() const { return m_members; }
 	const DynamicZoneLocation& GetCompassLocation() const { return m_compass; }
 	const DynamicZoneLocation& GetSafeReturnLocation() const { return m_safereturn; }
@@ -104,31 +133,34 @@ public:
 	uint32_t GetDatabaseMemberCount();
 	DynamicZoneMember GetMemberData(uint32_t character_id);
 	DynamicZoneMember GetMemberData(const std::string& character_name);
-	EQ::Net::DynamicPacket GetSerializedDzPacket();
+	std::vector<uint32_t> GetMemberIds();
+	std::ostringstream GetSerialized();
 	bool HasDatabaseMember(uint32_t character_id);
-	bool HasMember(uint32_t character_id);
-	bool HasMember(const std::string& character_name);
+	bool HasMember(uint32_t character_id) const;
+	bool HasMember(const std::string& character_name) const;
 	bool HasMembers() const { return !m_members.empty(); }
 	bool HasZoneInLocation() const { return m_has_zonein; }
+	bool IsExpedition() const { return m_type == DynamicZoneType::Expedition; }
 	bool IsExpired() const { return m_expire_time < std::chrono::system_clock::now(); }
 	bool IsInstanceID(uint32_t instance_id) const { return (m_instance_id != 0 && m_instance_id == instance_id); }
+	bool IsLocked() const { return m_is_locked; }
 	bool IsValid() const { return m_instance_id != 0; }
 	bool IsSameDz(uint32_t zone_id, uint32_t instance_id) const { return zone_id == m_zone_id && instance_id == m_instance_id; }
-	void LoadSerializedDzPacket(char* cereal_data, uint32_t cereal_size);
 	void LoadTemplate(const DynamicZoneTemplatesRepository::DynamicZoneTemplates& dz_template);
 	void RemoveAllMembers();
 	bool RemoveMember(uint32_t character_id);
 	bool RemoveMember(const std::string& character_name);
 	bool RemoveMember(const DynamicZoneMember& remove_member);
-	void SaveMembers(const std::vector<DynamicZoneMember>& members);
 	void SetCompass(const DynamicZoneLocation& location, bool update_db = false);
 	void SetCompass(uint32_t zone_id, float x, float y, float z, bool update_db = false);
 	void SetDuration(uint32_t seconds) { m_duration = std::chrono::seconds(seconds); }
 	void SetLeader(const DynamicZoneMember& leader, bool update_db = false);
+	void SetLocked(bool lock, bool update_db = false, DzLockMsg lock_msg = DzLockMsg::None, uint32_t color = Chat::Yellow);
 	void SetMaxPlayers(uint32_t max_players) { m_max_players = max_players; }
 	void SetMemberStatus(uint32_t character_id, DynamicZoneMemberStatus status);
 	void SetMinPlayers(uint32_t min_players) { m_min_players = min_players; }
 	void SetName(const std::string& name) { m_name = name; }
+	void SetReplayOnJoin(bool enabled, bool update_db = false);
 	void SetSafeReturn(const DynamicZoneLocation& location, bool update_db = false);
 	void SetSafeReturn(uint32_t zone_id, float x, float y, float z, float heading, bool update_db = false);
 	void SetSwitchID(int dz_switch_id, bool update_db = false);
@@ -136,34 +168,48 @@ public:
 	void SetUUID(std::string uuid) { m_uuid = std::move(uuid); }
 	void SetZoneInLocation(const DynamicZoneLocation& location, bool update_db = false);
 	void SetZoneInLocation(float x, float y, float z, float heading, bool update_db = false);
-	bool SwapMember(const DynamicZoneMember& add_member, const std::string& remove_char_name);
+	bool SwapMember(const DynamicZoneMember& add_member, const std::string& remove_name);
+
+	void AddLockout(const std::string& event, uint32_t seconds);
+	void AddLockoutDuration(const std::string& event, int seconds, bool members_only = true);
+	bool HasLockout(const std::string& event);
+	bool HasReplayLockout();
+	void RemoveLockout(const std::string& event);
+	void SyncCharacterLockouts(uint32_t char_id, std::vector<DzLockout>& lockouts);
+	void UpdateLockoutDuration(const std::string& event, uint32_t seconds, bool members_only = true);

 protected:
-	virtual uint16_t GetCurrentInstanceID() { return 0; }
-	virtual uint16_t GetCurrentZoneID() { return 0; }
+	virtual uint16_t GetCurrentInstanceID() const { return 0; }
+	virtual uint16_t GetCurrentZoneID() const { return 0; }
 	virtual Database& GetDatabase() = 0;
+	virtual void HandleLockoutDuration(const DzLockout& lockout, int seconds, bool members_only, bool insert_db);
+	virtual void HandleLockoutUpdate(const DzLockout& lockout, bool remove, bool members_only);
 	virtual void ProcessCompassChange(const DynamicZoneLocation& location) { m_compass = location; }
 	virtual void ProcessMemberAddRemove(const DynamicZoneMember& member, bool removed);
-	virtual bool ProcessMemberStatusChange(uint32_t member_id, DynamicZoneMemberStatus status);
-	virtual void ProcessRemoveAllMembers(bool silent = false) { m_members.clear(); }
+	virtual bool ProcessMemberStatusChange(uint32_t character_id, DynamicZoneMemberStatus status);
+	virtual void ProcessRemoveAllMembers() { m_members.clear(); }
 	virtual void ProcessSetSwitchID(int dz_switch_id) { m_dz_switch_id = dz_switch_id; }
 	virtual bool SendServerPacket(ServerPacket* packet) = 0;

+	void AddLockout(const DzLockout& lockout, bool members_only = false);
 	void AddInternalMember(const DynamicZoneMember& member);
 	uint32_t Create();
 	uint32_t CreateInstance();
 	void LoadRepositoryResult(DynamicZonesRepository::DynamicZoneInstance&& dz_entry);
 	void RemoveInternalMember(uint32_t character_id);
+	void SaveMembers(const std::vector<DynamicZoneMember>& members);
 	uint32_t SaveToDatabase();
 	bool SetInternalMemberStatus(uint32_t character_id, DynamicZoneMemberStatus status);

-	std::unique_ptr<ServerPacket> CreateServerDzCreatePacket(uint16_t origin_zone_id, uint16_t origin_instance_id);
+	std::unique_ptr<ServerPacket> CreateServerPacket(uint16_t zone_id, uint16_t instance_id);
 	std::unique_ptr<ServerPacket> CreateServerDzLocationPacket(uint16_t server_opcode, const DynamicZoneLocation& location);
 	std::unique_ptr<ServerPacket> CreateServerDzSwitchIDPacket();
 	std::unique_ptr<ServerPacket> CreateServerMemberAddRemovePacket(const DynamicZoneMember& member, bool removed);
 	std::unique_ptr<ServerPacket> CreateServerMemberStatusPacket(uint32_t character_id, DynamicZoneMemberStatus status);
 	std::unique_ptr<ServerPacket> CreateServerMemberSwapPacket(const DynamicZoneMember& remove_member, const DynamicZoneMember& add_member);
 	std::unique_ptr<ServerPacket> CreateServerRemoveAllMembersPacket();
+	std::unique_ptr<ServerPacket> CreateLockoutPacket(const DzLockout& lockout, bool remove, bool members_only = false) const;
+	std::unique_ptr<ServerPacket> CreateLockoutDurationPacket(const DzLockout& lockout, int seconds, bool members_only = false) const;

 	uint32_t m_id = 0;
 	uint32_t m_zone_id = 0;
@@ -175,6 +221,8 @@ protected:
 	bool m_never_expires = false;
 	bool m_has_zonein = false;
 	bool m_has_member_statuses = false;
+	bool m_is_locked = false;
+	bool m_add_replay = true;
 	std::string m_name;
 	std::string m_uuid;
 	DynamicZoneMember m_leader;
@@ -182,12 +230,15 @@ protected:
 	DynamicZoneLocation m_compass;
 	DynamicZoneLocation m_safereturn;
 	DynamicZoneLocation m_zonein;
-	std::chrono::seconds m_duration;
+	std::chrono::seconds m_duration = {};
 	std::chrono::time_point<std::chrono::system_clock> m_start_time;
 	std::chrono::time_point<std::chrono::system_clock> m_expire_time;
 	std::vector<DynamicZoneMember> m_members;
+	std::vector<DzLockout> m_lockouts;

 public:
+	void Unserialize(std::span<char> buf);
+
 	template<class Archive>
 	void serialize(Archive& archive)
 	{
@@ -202,6 +253,8 @@ public:
 			m_never_expires,
 			m_has_zonein,
 			m_has_member_statuses,
+			m_is_locked,
+			m_add_replay,
 			m_name,
 			m_uuid,
 			m_leader,
@@ -212,7 +265,8 @@ public:
 			m_duration,
 			m_start_time,
 			m_expire_time,
-			m_members
+			m_members,
+			m_lockouts
 		);
 	}
 };
@@ -0,0 +1,92 @@
+#include "dynamic_zone_lockout.h"
+#include "strings.h"
+#include "rulesys.h"
+#include "util/uuid.h"
+#include <fmt/format.h>
+#include <cereal/types/chrono.hpp>
+
+DzLockout::DzLockout(std::string uuid, std::string expedition, std::string event, uint64_t expire_time, uint32_t duration)
+	: m_uuid(std::move(uuid))
+	, m_name(std::move(expedition))
+	, m_event(std::move(event))
+	, m_expire_time(std::chrono::system_clock::from_time_t(expire_time))
+	, m_duration(duration)
+{
+	m_is_replay = m_event == ReplayTimer;
+}
+
+DzLockout::DzLockout(std::string_view name, BaseDynamicZoneLockoutsRepository::DynamicZoneLockouts&& lockout)
+	: m_uuid(std::move(lockout.from_expedition_uuid))
+	, m_name(name)
+	, m_event(std::move(lockout.event_name))
+	, m_expire_time(std::chrono::system_clock::from_time_t(lockout.expire_time))
+	, m_duration(lockout.duration)
+{
+	m_is_replay = m_event == ReplayTimer;
+}
+
+DzLockout DzLockout::Create(const std::string& expedition, const std::string& event, uint32_t seconds, std::string uuid)
+{
+	seconds = static_cast<uint32_t>(seconds * RuleR(Expedition, LockoutDurationMultiplier));
+
+	if (uuid.empty())
+	{
+		uuid = EQ::Util::UUID::Generate().ToString();
+	}
+
+	DzLockout lockout{uuid, expedition, event, 0, seconds};
+	lockout.Reset(); // sets expire time
+	return lockout;
+}
+
+uint32_t DzLockout::GetSecondsRemaining() const
+{
+	auto now = std::chrono::system_clock::now();
+	if (m_expire_time > now)
+	{
+		auto remaining = m_expire_time - now;
+		return static_cast<uint32_t>(std::chrono::duration_cast<std::chrono::seconds>(remaining).count());
+	}
+	return 0;
+}
+
+DzLockout::TimeStrings DzLockout::GetTimeRemainingStrs() const
+{
+	auto seconds = GetSecondsRemaining();
+	return DzLockout::TimeStrings{
+		fmt::format_int(seconds / 86400).str(),     // days
+		fmt::format_int(seconds / 3600 % 24).str(), // hours
+		fmt::format_int(seconds / 60 % 60).str(),   // minutes
+		fmt::format_int(seconds % 60).str()         // seconds
+	};
+}
+
+bool DzLockout::IsSame(const DzLockout& other) const
+{
+	return other.IsSame(m_name, m_event);
+}
+
+bool DzLockout::IsSame(const std::string& expedition, const std::string& event) const
+{
+	return m_name == expedition && m_event == event;
+}
+
+void DzLockout::AddLockoutTime(int seconds)
+{
+	seconds = static_cast<int>(seconds * RuleR(Expedition, LockoutDurationMultiplier));
+
+	auto new_duration = std::max(0, static_cast<int>(m_duration.count()) + seconds);
+
+	auto start_time = m_expire_time - m_duration;
+	m_duration = std::chrono::seconds(new_duration);
+	m_expire_time = start_time + m_duration;
+}
+
+template <typename T>
+void DzLockout::serialize(T& archive)
+{
+	archive(m_is_replay, m_uuid, m_name, m_event, m_duration, m_expire_time);
+}
+
+template void DzLockout::serialize(cereal::BinaryOutputArchive&);
+template void DzLockout::serialize(cereal::BinaryInputArchive&);
@@ -0,0 +1,56 @@
+#pragma once
+
+#include <chrono>
+#include <string>
+#include "repositories/base/base_dynamic_zone_lockouts_repository.h"
+
+class DzLockout
+{
+public:
+	DzLockout() = default;
+	DzLockout(std::string uuid, std::string expedition, std::string event, uint64_t expire_time, uint32_t duration);
+	DzLockout(std::string_view name, BaseDynamicZoneLockoutsRepository::DynamicZoneLockouts&& lockout);
+
+	static constexpr char ReplayTimer[] = "Replay Timer";
+
+	static DzLockout Create(const std::string& expedition, const std::string& event, uint32_t seconds, std::string uuid = {});
+
+	struct TimeStrings
+	{
+		std::string days;
+		std::string hours;
+		std::string mins;
+		std::string secs;
+	};
+
+	void AddLockoutTime(int seconds);
+	uint32_t GetDuration() const { return static_cast<uint32_t>(m_duration.count()); }
+	uint64_t GetExpireTime() const { return std::chrono::system_clock::to_time_t(m_expire_time); }
+	uint64_t GetStartTime() const { return std::chrono::system_clock::to_time_t(m_expire_time - m_duration); }
+	uint32_t GetSecondsRemaining() const;
+	TimeStrings GetTimeRemainingStrs() const;
+	const std::string& DzName() const { return m_name; }
+	const std::string& Event() const { return m_event; }
+	const std::string& UUID() const { return m_uuid; }
+	bool IsEvent(std::string_view event) const { return m_event == event; }
+	bool IsExpired() const { return GetSecondsRemaining() == 0; }
+	bool IsReplay() const { return m_is_replay; }
+	bool IsSame(const DzLockout& other) const;
+	bool IsSame(const std::string& expedition, const std::string& event) const;
+	bool IsUUID(const std::string& uuid) const { return uuid == m_uuid; }
+	void Reset() { m_expire_time = std::chrono::system_clock::now() + m_duration; }
+	void SetDuration(uint32_t seconds) { m_duration = std::chrono::seconds(seconds); }
+	void SetExpireTime(uint64_t expire_time) { m_expire_time = std::chrono::system_clock::from_time_t(expire_time); }
+	void SetUUID(const std::string& uuid) { m_uuid = uuid; }
+
+	template <typename T>
+	void serialize(T& archive);
+
+private:
+	bool m_is_replay = false;
+	std::string m_uuid; // dz received in
+	std::string m_name;
+	std::string m_event;
+	std::chrono::seconds m_duration = {};
+	std::chrono::time_point<std::chrono::system_clock> m_expire_time;
+};
@@ -130,6 +130,8 @@ namespace EQ
 		using RoF2::invtype::MAIL_SIZE;
 		using RoF2::invtype::GUILD_TROPHY_TRIBUTE_SIZE;
 		using RoF2::invtype::KRONO_SIZE;
+		using RoF2::invtype::GUILD_BANK_MAIN_SIZE;
+		using RoF2::invtype::GUILD_BANK_DEPOSIT_SIZE;
 		using RoF2::invtype::OTHER_SIZE;

 		using RoF2::invtype::TRADE_NPC_SIZE;
@@ -974,25 +974,6 @@ namespace ZoneBlockedSpellTypes {
 	const uint8 Region   = 2;
 };

-enum class DynamicZoneType
-{
-	None = 0,
-	Expedition,
-	Tutorial,
-	Task,
-	Mission, // Shared Task
-	Quest
-};
-
-enum class DynamicZoneMemberStatus : uint8_t
-{
-	Unknown = 0,
-	Online,
-	Offline,
-	InDynamicZone,
-	LinkDead
-};
-
 enum StartZoneIndex {
    Odus = 0,
    Qeynos,
@@ -173,7 +173,7 @@ static const EQ::inventory::LookupEntry inventory_static_lookup_entries[EQ::vers
 			ClientUnknown::INULL, ClientUnknown::INULL, ClientUnknown::INULL,
 			ClientUnknown::INULL, ClientUnknown::INULL, ClientUnknown::INULL,
 			ClientUnknown::INULL, ClientUnknown::INULL, ClientUnknown::INULL,
-			ClientUnknown::INULL
+			ClientUnknown::INULL, ClientUnknown::INULL, ClientUnknown::INULL
 		),

 		ClientUnknown::INULL,
@@ -200,7 +200,7 @@ static const EQ::inventory::LookupEntry inventory_static_lookup_entries[EQ::vers
 			Client62::INULL, Client62::INULL, Client62::INULL,
 			Client62::INULL, Client62::INULL, Client62::INULL,
 			Client62::INULL, Client62::INULL, Client62::INULL,
-			Client62::INULL
+			Client62::INULL, Client62::INULL, Client62::INULL
 		),

 		Client62::INULL,
@@ -227,7 +227,7 @@ static const EQ::inventory::LookupEntry inventory_static_lookup_entries[EQ::vers
 			Titanium::invtype::VIEW_MOD_PC_SIZE,	Titanium::invtype::VIEW_MOD_BANK_SIZE,	Titanium::invtype::VIEW_MOD_SHARED_BANK_SIZE,
 			Titanium::invtype::VIEW_MOD_LIMBO_SIZE,	Titanium::invtype::ALT_STORAGE_SIZE,	Titanium::invtype::ARCHIVED_SIZE,
 			Titanium::INULL,						Titanium::INULL,						Titanium::INULL,
-			Titanium::invtype::OTHER_SIZE
+			Titanium::INULL,						Titanium::INULL,						Titanium::invtype::OTHER_SIZE
 		),

 		Titanium::invslot::EQUIPMENT_BITMASK,
@@ -254,7 +254,7 @@ static const EQ::inventory::LookupEntry inventory_static_lookup_entries[EQ::vers
 			SoF::invtype::VIEW_MOD_PC_SIZE,		SoF::invtype::VIEW_MOD_BANK_SIZE,	SoF::invtype::VIEW_MOD_SHARED_BANK_SIZE,
 			SoF::invtype::VIEW_MOD_LIMBO_SIZE,	SoF::invtype::ALT_STORAGE_SIZE,		SoF::invtype::ARCHIVED_SIZE,
 			SoF::INULL,							SoF::INULL,							SoF::INULL,
-			SoF::invtype::OTHER_SIZE
+			SoF::INULL,							SoF::INULL,							SoF::invtype::OTHER_SIZE
 		),

 		SoF::invslot::EQUIPMENT_BITMASK,
@@ -281,7 +281,7 @@ static const EQ::inventory::LookupEntry inventory_static_lookup_entries[EQ::vers
 			SoD::invtype::VIEW_MOD_PC_SIZE,		SoD::invtype::VIEW_MOD_BANK_SIZE,	SoD::invtype::VIEW_MOD_SHARED_BANK_SIZE,
 			SoD::invtype::VIEW_MOD_LIMBO_SIZE,	SoD::invtype::ALT_STORAGE_SIZE,		SoD::invtype::ARCHIVED_SIZE,
 			SoD::INULL,							SoD::INULL,							SoD::INULL,
-			SoD::invtype::OTHER_SIZE
+			SoD::INULL,							SoD::INULL,							SoD::invtype::OTHER_SIZE
 		),

 		SoD::invslot::EQUIPMENT_BITMASK,
@@ -308,7 +308,7 @@ static const EQ::inventory::LookupEntry inventory_static_lookup_entries[EQ::vers
 			UF::invtype::VIEW_MOD_PC_SIZE,		UF::invtype::VIEW_MOD_BANK_SIZE,	UF::invtype::VIEW_MOD_SHARED_BANK_SIZE,
 			UF::invtype::VIEW_MOD_LIMBO_SIZE,	UF::invtype::ALT_STORAGE_SIZE,		UF::invtype::ARCHIVED_SIZE,
 			UF::INULL,							UF::INULL,							UF::INULL,
-			UF::invtype::OTHER_SIZE
+			UF::INULL,							UF::INULL,							UF::invtype::OTHER_SIZE
 		),

 		UF::invslot::EQUIPMENT_BITMASK,
@@ -335,7 +335,7 @@ static const EQ::inventory::LookupEntry inventory_static_lookup_entries[EQ::vers
 			RoF::invtype::VIEW_MOD_PC_SIZE,		RoF::invtype::VIEW_MOD_BANK_SIZE,			RoF::invtype::VIEW_MOD_SHARED_BANK_SIZE,
 			RoF::invtype::VIEW_MOD_LIMBO_SIZE,	RoF::invtype::ALT_STORAGE_SIZE,				RoF::invtype::ARCHIVED_SIZE,
 			RoF::invtype::MAIL_SIZE,			RoF::invtype::GUILD_TROPHY_TRIBUTE_SIZE,	RoF::INULL,
-			RoF::invtype::OTHER_SIZE
+			RoF::INULL,RoF::INULL,RoF::invtype::OTHER_SIZE
 		),

 		RoF::invslot::EQUIPMENT_BITMASK,
@@ -362,7 +362,7 @@ static const EQ::inventory::LookupEntry inventory_static_lookup_entries[EQ::vers
 			RoF2::invtype::VIEW_MOD_PC_SIZE,	RoF2::invtype::VIEW_MOD_BANK_SIZE,			RoF2::invtype::VIEW_MOD_SHARED_BANK_SIZE,
 			RoF2::invtype::VIEW_MOD_LIMBO_SIZE,	RoF2::invtype::ALT_STORAGE_SIZE,			RoF2::invtype::ARCHIVED_SIZE,
 			RoF2::invtype::MAIL_SIZE,			RoF2::invtype::GUILD_TROPHY_TRIBUTE_SIZE,	RoF2::invtype::KRONO_SIZE,
-			RoF2::invtype::OTHER_SIZE
+			RoF2::invtype::GUILD_BANK_MAIN_SIZE,RoF2::invtype::GUILD_BANK_DEPOSIT_SIZE,     RoF2::invtype::OTHER_SIZE
 		),

 		RoF2::invslot::EQUIPMENT_BITMASK,
@@ -389,7 +389,7 @@ static const EQ::inventory::LookupEntry inventory_static_lookup_entries[EQ::vers
 			EntityLimits::NPC::INULL,				EntityLimits::NPC::INULL,	EntityLimits::NPC::INULL,
 			EntityLimits::NPC::INULL,				EntityLimits::NPC::INULL,	EntityLimits::NPC::INULL,
 			EntityLimits::NPC::INULL,				EntityLimits::NPC::INULL,	EntityLimits::NPC::INULL,
-			EntityLimits::NPC::INULL
+			EntityLimits::NPC::INULL,	EntityLimits::NPC::INULL,EntityLimits::NPC::INULL
 		),

 		EntityLimits::NPC::INULL,
@@ -416,7 +416,7 @@ static const EQ::inventory::LookupEntry inventory_static_lookup_entries[EQ::vers
 			EntityLimits::NPCMerchant::INULL,								EntityLimits::NPCMerchant::INULL,	EntityLimits::NPCMerchant::INULL,
 			EntityLimits::NPCMerchant::INULL,								EntityLimits::NPCMerchant::INULL,	EntityLimits::NPCMerchant::INULL,
 			EntityLimits::NPCMerchant::INULL,								EntityLimits::NPCMerchant::INULL,	EntityLimits::NPCMerchant::INULL,
-			EntityLimits::NPCMerchant::INULL
+			EntityLimits::NPCMerchant::INULL,								EntityLimits::NPCMerchant::INULL,   EntityLimits::NPCMerchant::INULL
 		),

 		EntityLimits::NPCMerchant::INULL,
@@ -443,7 +443,7 @@ static const EQ::inventory::LookupEntry inventory_static_lookup_entries[EQ::vers
 			EntityLimits::Merc::INULL,										EntityLimits::Merc::INULL,	EntityLimits::Merc::INULL,
 			EntityLimits::Merc::INULL,										EntityLimits::Merc::INULL,	EntityLimits::Merc::INULL,
 			EntityLimits::Merc::INULL,										EntityLimits::Merc::INULL,	EntityLimits::Merc::INULL,
-			EntityLimits::Merc::INULL
+			EntityLimits::Merc::INULL,										EntityLimits::Merc::INULL,	EntityLimits::Merc::INULL
 		),

 		EntityLimits::Merc::INULL,
@@ -470,7 +470,7 @@ static const EQ::inventory::LookupEntry inventory_static_lookup_entries[EQ::vers
 			EntityLimits::Bot::INULL,										EntityLimits::Bot::INULL,	EntityLimits::Bot::INULL,
 			EntityLimits::Bot::INULL,										EntityLimits::Bot::INULL,	EntityLimits::Bot::INULL,
 			EntityLimits::Bot::INULL,										EntityLimits::Bot::INULL,	EntityLimits::Bot::INULL,
-			EntityLimits::Bot::INULL
+			EntityLimits::Bot::INULL,										EntityLimits::Bot::INULL,	EntityLimits::Bot::INULL
 		),

 		EntityLimits::Bot::invslot::EQUIPMENT_BITMASK,
@@ -497,7 +497,7 @@ static const EQ::inventory::LookupEntry inventory_static_lookup_entries[EQ::vers
 			EntityLimits::ClientPet::INULL,									EntityLimits::ClientPet::INULL,	EntityLimits::ClientPet::INULL,
 			EntityLimits::ClientPet::INULL,									EntityLimits::ClientPet::INULL,	EntityLimits::ClientPet::INULL,
 			EntityLimits::ClientPet::INULL,									EntityLimits::ClientPet::INULL,	EntityLimits::ClientPet::INULL,
-			EntityLimits::ClientPet::INULL
+			EntityLimits::ClientPet::INULL,									EntityLimits::ClientPet::INULL,	EntityLimits::ClientPet::INULL
 		),

 		EntityLimits::ClientPet::INULL,
@@ -524,7 +524,7 @@ static const EQ::inventory::LookupEntry inventory_static_lookup_entries[EQ::vers
 			EntityLimits::NPCPet::INULL,									EntityLimits::NPCPet::INULL,	EntityLimits::NPCPet::INULL,
 			EntityLimits::NPCPet::INULL,									EntityLimits::NPCPet::INULL,	EntityLimits::NPCPet::INULL,
 			EntityLimits::NPCPet::INULL,									EntityLimits::NPCPet::INULL,	EntityLimits::NPCPet::INULL,
-			EntityLimits::NPCPet::INULL
+			EntityLimits::NPCPet::INULL,									EntityLimits::NPCPet::INULL,	EntityLimits::NPCPet::INULL
 		),

 		EntityLimits::NPCPet::INULL,
@@ -551,7 +551,7 @@ static const EQ::inventory::LookupEntry inventory_static_lookup_entries[EQ::vers
 			EntityLimits::MercPet::INULL,									EntityLimits::MercPet::INULL,	EntityLimits::MercPet::INULL,
 			EntityLimits::MercPet::INULL,									EntityLimits::MercPet::INULL,	EntityLimits::MercPet::INULL,
 			EntityLimits::MercPet::INULL,									EntityLimits::MercPet::INULL,	EntityLimits::MercPet::INULL,
-			EntityLimits::MercPet::INULL
+			EntityLimits::MercPet::INULL,									EntityLimits::MercPet::INULL,	EntityLimits::MercPet::INULL
 		),

 		EntityLimits::MercPet::INULL,
@@ -578,7 +578,7 @@ static const EQ::inventory::LookupEntry inventory_static_lookup_entries[EQ::vers
 			EntityLimits::BotPet::INULL,									EntityLimits::BotPet::INULL,	EntityLimits::BotPet::INULL,
 			EntityLimits::BotPet::INULL,									EntityLimits::BotPet::INULL,	EntityLimits::BotPet::INULL,
 			EntityLimits::BotPet::INULL,									EntityLimits::BotPet::INULL,	EntityLimits::BotPet::INULL,
-			EntityLimits::BotPet::INULL
+			EntityLimits::BotPet::INULL,									EntityLimits::BotPet::INULL,	EntityLimits::BotPet::INULL
 		),

 		EntityLimits::BotPet::INULL,
@@ -605,7 +605,7 @@ static const EQ::inventory::LookupEntry inventory_static_lookup_entries[EQ::vers
 			Titanium::invtype::VIEW_MOD_PC_SIZE,	Titanium::invtype::VIEW_MOD_BANK_SIZE,	Titanium::invtype::VIEW_MOD_SHARED_BANK_SIZE,
 			Titanium::invtype::VIEW_MOD_LIMBO_SIZE,	Titanium::INULL,						Titanium::INULL,
 			Titanium::INULL,						Titanium::INULL,						Titanium::INULL,
-			Titanium::INULL
+			Titanium::INULL,						Titanium::INULL,						Titanium::INULL
 		),

 		Titanium::INULL,
@@ -632,7 +632,7 @@ static const EQ::inventory::LookupEntry inventory_static_lookup_entries[EQ::vers
 			SoF::invtype::VIEW_MOD_PC_SIZE,		SoF::invtype::VIEW_MOD_BANK_SIZE,	SoF::invtype::VIEW_MOD_SHARED_BANK_SIZE,
 			SoF::invtype::VIEW_MOD_LIMBO_SIZE,	SoF::INULL,							SoF::INULL,
 			SoF::INULL,							SoF::INULL,							SoF::INULL,
-			SoF::INULL
+			SoF::INULL,							SoF::INULL,							SoF::INULL
 		),

 		SoF::INULL,
@@ -659,7 +659,7 @@ static const EQ::inventory::LookupEntry inventory_static_lookup_entries[EQ::vers
 			SoD::invtype::VIEW_MOD_PC_SIZE,		SoD::invtype::VIEW_MOD_BANK_SIZE,	SoD::invtype::VIEW_MOD_SHARED_BANK_SIZE,
 			SoD::invtype::VIEW_MOD_LIMBO_SIZE,	SoD::INULL,							SoD::INULL,
 			SoD::INULL,							SoD::INULL,							SoD::INULL,
-			SoD::INULL
+			SoD::INULL,							SoD::INULL,							SoD::INULL
 		),

 		SoD::INULL,
@@ -686,7 +686,7 @@ static const EQ::inventory::LookupEntry inventory_static_lookup_entries[EQ::vers
 			UF::invtype::VIEW_MOD_PC_SIZE,		UF::invtype::VIEW_MOD_BANK_SIZE,	UF::invtype::VIEW_MOD_SHARED_BANK_SIZE,
 			UF::invtype::VIEW_MOD_LIMBO_SIZE,	UF::INULL,							UF::INULL,
 			UF::INULL,							UF::INULL,							UF::INULL,
-			UF::INULL
+			UF::INULL,							UF::INULL,							UF::INULL
 		),

 		UF::INULL,
@@ -713,7 +713,7 @@ static const EQ::inventory::LookupEntry inventory_static_lookup_entries[EQ::vers
 			RoF::invtype::VIEW_MOD_PC_SIZE,		RoF::invtype::VIEW_MOD_BANK_SIZE,	RoF::invtype::VIEW_MOD_SHARED_BANK_SIZE,
 			RoF::invtype::VIEW_MOD_LIMBO_SIZE,	RoF::INULL,							RoF::INULL,
 			RoF::INULL,							RoF::INULL,							RoF::INULL,
-			RoF::INULL
+			RoF::INULL,							RoF::INULL,							RoF::INULL
 		),

 		RoF::INULL,
@@ -740,7 +740,7 @@ static const EQ::inventory::LookupEntry inventory_static_lookup_entries[EQ::vers
 			RoF2::invtype::VIEW_MOD_PC_SIZE,	RoF2::invtype::VIEW_MOD_BANK_SIZE,	RoF2::invtype::VIEW_MOD_SHARED_BANK_SIZE,
 			RoF2::invtype::VIEW_MOD_LIMBO_SIZE,	RoF2::INULL,						RoF2::INULL,
 			RoF2::INULL,						RoF2::INULL,						RoF2::INULL,
-			RoF2::INULL
+			RoF2::INULL,						RoF2::INULL,						RoF2::INULL
 		),

 		RoF2::INULL,
@@ -87,7 +87,7 @@ namespace EQ
 				int16 ViewMODPC,	ViewMODBank,		ViewMODSharedBank;
 				int16 ViewMODLimbo,	AltStorage,			Archived;
 				int16 Mail,			GuildTrophyTribute,	Krono;
-				int16 Other;
+				int16 GuildBankMain,GuildBankDeposit,   Other;

 				InventoryTypeSize_Struct(
 					int16 Possessions,	int16 Bank,					int16 SharedBank,
@@ -98,7 +98,7 @@ namespace EQ
 					int16 ViewMODPC,	int16 ViewMODBank,			int16 ViewMODSharedBank,
 					int16 ViewMODLimbo,	int16 AltStorage,			int16 Archived,
 					int16 Mail,			int16 GuildTrophyTribute,	int16 Krono,
-					int16 Other
+					int16 GuildBankMain,int16 GuildBankDeposit,     int16 Other
 				) :
 					Possessions(Possessions),	Bank(Bank),								SharedBank(SharedBank),
 					Trade(Trade),				World(World),							Limbo(Limbo),
@@ -108,7 +108,7 @@ namespace EQ
 					ViewMODPC(ViewMODPC),		ViewMODBank(ViewMODBank),				ViewMODSharedBank(ViewMODSharedBank),
 					ViewMODLimbo(ViewMODLimbo),	AltStorage(AltStorage),					Archived(Archived),
 					Mail(Mail),					GuildTrophyTribute(GuildTrophyTribute),	Krono(Krono),
-					Other(Other)
+					GuildBankMain(GuildBankMain), GuildBankDeposit(GuildBankDeposit),   Other(Other)
 				{ }
 			};

@@ -19,17 +19,17 @@
 #ifndef EQ_PACKET_STRUCTS_H
 #define EQ_PACKET_STRUCTS_H

-#include "types.h"
+#include <list>
 #include <string.h>
 #include <string>
-#include <list>
 #include <time.h>
-#include "../common/version.h"
-#include "emu_constants.h"
-#include "textures.h"
 #include "../cereal/include/cereal/archives/binary.hpp"
 #include "../cereal/include/cereal/types/string.hpp"
 #include "../cereal/include/cereal/types/vector.hpp"
+#include "../common/version.h"
+#include "emu_constants.h"
+#include "textures.h"
+#include "types.h"

 static const uint32 BUFF_COUNT = 42;
 static const uint32 PET_BUFF_COUNT = 30;
@@ -47,7 +47,7 @@ static const uint32 ADVANCED_LORE_LENGTH = 8192;
 */
 #pragma pack(1)

-struct LoginInfo_Struct {
+struct LoginInfo {
 /*000*/	char	login_info[64];
 /*064*/	uint8	unknown064[124];
 /*188*/	uint8	zoning;			// 01 if zoning, 00 if not
@@ -5529,56 +5529,65 @@ struct GuildBankWithdrawItem_Struct

 struct GuildBankItemUpdate_Struct
 {
-	void Init(uint32 inAction, uint32 inUnknown004, uint16 inSlotID, uint16 inArea, uint16 inUnknown012, uint32 inItemID, uint32 inIcon, uint32 inQuantity,
-			uint32 inPermissions, uint32 inAllowMerge, bool inUseable)
+	void Init(
+		uint32 inAction,
+		uint32 inUnknown004,
+		uint16 inSlotID,
+		uint16 inArea,
+		uint16 inUnknown012,
+		uint32 inItemID,
+		uint32 inIcon,
+		uint32 inQuantity,
+		uint32 inPermissions,
+		uint32 inAllowMerge,
+		bool   inUseable)
 	{
-		Action = inAction;
-		Unknown004 = inUnknown004;
-		SlotID = inSlotID;
-		Area = inArea;
-		Unknown012 = inUnknown012;
-		ItemID = inItemID;
-		Icon = inIcon;
-		Quantity = inQuantity;
-		Permissions = inPermissions;
-		AllowMerge = inAllowMerge;
-		Useable = inUseable;
-		ItemName[0] = '\0';
-		Donator[0] = '\0';
-		WhoFor[0] = '\0';
+		action       = inAction;
+		unknown004   = inUnknown004;
+		slot_id      = inSlotID;
+		area         = inArea;
+		display      = inUnknown012;
+		item_id      = inItemID;
+		icon_id      = inIcon;
+		quantity     = inQuantity;
+		permissions  = inPermissions;
+		allow_merge  = inAllowMerge;
+		is_useable   = inUseable;
+		item_name[0] = '\0';
+		donator[0]   = '\0';
+		who_for[0]   = '\0';
 	};

-/*000*/	uint32	Action;
-/*004*/	uint32	Unknown004;
-/*008*/	uint16	SlotID;
-/*010*/	uint16	Area;
-/*012*/	uint32	Unknown012;
-/*016*/	uint32	ItemID;
-/*020*/	uint32	Icon;
-/*024*/	uint32	Quantity;
-/*028*/	uint32	Permissions;
-/*032*/	uint8	AllowMerge;
-/*033*/	uint8	Useable;	// Used in conjunction with the Public-if-useable permission.
-/*034*/	char	ItemName[64];
-/*098*/	char	Donator[64];
-/*162*/ char	WhoFor[64];
-/*226*/	uint16	Unknown226;
+/*000*/	uint32	action;
+/*004*/	uint32	unknown004;
+/*008*/	uint16	slot_id;
+/*010*/	uint16	area;
+/*012*/	uint32	display;
+/*016*/	uint32	item_id;
+/*020*/	uint32	icon_id;
+/*024*/	uint32	quantity;
+/*028*/	uint32	permissions;
+/*032*/	uint8	allow_merge;
+/*033*/	uint8	is_useable;	// Used in conjunction with the Public-if-useable permission.
+/*034*/	char	item_name[64];
+/*098*/	char	donator[64];
+/*162*/ char	who_for[64];
+/*226*/	uint16	unknown226;
 };

 // newer clients (RoF+) send a list that contains 240 entries
 // The packets don't actually use all 64 chars in the strings, but we'll just overallocate for these
-struct GuildBankItemListEntry_Struct
-{
-	uint8 vaild;
+struct GuildBankItemListEntry_Struct {
+	uint8  vaild;
 	uint32 permissions;
-	char whofor[64];
-	char donator[64];
+	char   whofor[64];
+	char   donator[64];
 	uint32 item_id;
 	uint32 item_icon;
 	uint32 quantity;
-	uint8 allow_merge; // 1 here for non-full stacks
-	uint8 usable;
-	char item_name[64];
+	uint8  allow_merge; // 1 here for non-full stacks
+	uint8  usable;
+	char   item_name[64];
 };

 struct GuildBankClear_Struct
@@ -149,6 +149,7 @@ namespace Logs {
 		BotSpellChecks,
 		BotSpellTypeChecks,
 		NpcHandin,
+		ZoneState,
 		MaxCategoryID /* Don't Remove this */
 	};

@@ -256,7 +257,8 @@ namespace Logs {
 		"Bot Settings",
 		"Bot Spell Checks",
 		"Bot Spell Type Checks",
-		"NpcHandin"
+		"NpcHandin",
+		"ZoneState"
 	};
 }

@@ -914,6 +914,16 @@
        OutF(LogSys, Logs::Detail, Logs::NpcHandin, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)

+#define LogZoneState(message, ...) do {\
+    if (LogSys.IsLogEnabled(Logs::General, Logs::ZoneState))\
+        OutF(LogSys, Logs::General, Logs::ZoneState, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogZoneStateDetail(message, ...) do {\
+    if (LogSys.IsLogEnabled(Logs::Detail, Logs::ZoneState))\
+        OutF(LogSys, Logs::Detail, Logs::ZoneState, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
 #define Log(debug_level, log_category, message, ...) do {\
    if (LogSys.IsLogEnabled(debug_level, log_category))\
        LogSys.Out(debug_level, log_category, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
@@ -81,14 +81,13 @@ void PlayerEventLogs::Init()
 	if (!settings_to_insert.empty()) {
 		PlayerEventLogSettingsRepository::ReplaceMany(*m_database, settings_to_insert);
 	}
-
-	LoadEtlIds();
-
+	
 	bool processing_in_world = !RuleB(Logging, PlayerEventsQSProcess) && IsWorld();
 	bool processing_in_qs    = RuleB(Logging, PlayerEventsQSProcess) && IsQueryServ();

 	// on initial boot process truncation
 	if (processing_in_world || processing_in_qs) {
+		LoadEtlIds();
 		ProcessRetentionTruncation();
 	}
 }
@@ -402,7 +401,7 @@ void PlayerEventLogs::ProcessBatchQueue()
 				r.event_data = "{}"; // Clear event data
 			}
 			else {
-				LogError("Non-Implemented ETL routing [{}]", r.event_type_id);
+				LogPlayerEventsDetail("Non-Implemented ETL routing [{}]", r.event_type_id);
 			}
 		}
 	}
@@ -65,6 +65,9 @@ namespace PlayerEvent {
 		BARTER_TRANSACTION,
 		SPEECH,
 		EVOLVE_ITEM,
+		GUILD_BANK_DEPOSIT,
+		GUILD_BANK_WITHDRAWAL,
+		GUILD_BANK_MOVE_TO_BANK_AREA,
 		MAX // dont remove
 	};

@@ -129,7 +132,10 @@ namespace PlayerEvent {
 		"Parcel Prune Routine",
 		"Barter Transaction",
 		"Player Speech",
-		"Evolve Item Update"
+		"Evolve Item Update",
+		"Guild Bank Item Deposit",
+		"Guild Bank Item Withdrawal",
+		"Guild Bank Move From Deposit Area to Bank Area"
 	};

 	// Generic struct used by all events
@@ -875,8 +881,9 @@ namespace PlayerEvent {
 		uint32      trader_id;
 		std::string trader_name;
 		uint32      price;
-		uint32      charges;
-		uint32      total_cost;
+		uint32      quantity;
+		int32       charges;
+		uint64      total_cost;
 		uint64      player_money_balance;


@@ -896,6 +903,7 @@ namespace PlayerEvent {
 				CEREAL_NVP(trader_id),
 				CEREAL_NVP(trader_name),
 				CEREAL_NVP(price),
+				CEREAL_NVP(quantity),
 				CEREAL_NVP(charges),
 				CEREAL_NVP(total_cost),
 				CEREAL_NVP(player_money_balance)
@@ -915,8 +923,9 @@ namespace PlayerEvent {
 		uint32      buyer_id;
 		std::string buyer_name;
 		uint32      price;
-		uint32      charges;
-		uint32      total_cost;
+		uint32      quantity;
+		int32       charges;
+		uint64      total_cost;
 		uint64      player_money_balance;


@@ -936,6 +945,7 @@ namespace PlayerEvent {
 				CEREAL_NVP(buyer_id),
 				CEREAL_NVP(buyer_name),
 				CEREAL_NVP(price),
+				CEREAL_NVP(quantity),
 				CEREAL_NVP(charges),
 				CEREAL_NVP(total_cost),
 				CEREAL_NVP(player_money_balance)
@@ -1145,6 +1155,7 @@ namespace PlayerEvent {
 		uint32      augment_5_id;
 		uint32      augment_6_id;
 		uint32      quantity;
+		int32       charges;
 		std::string from_player_name;
 		std::string to_player_name;
 		uint32      sent_date;
@@ -1162,6 +1173,7 @@ namespace PlayerEvent {
 				CEREAL_NVP(augment_5_id),
 				CEREAL_NVP(augment_6_id),
 				CEREAL_NVP(quantity),
+				CEREAL_NVP(charges),
 				CEREAL_NVP(from_player_name),
 				CEREAL_NVP(to_player_name),
 				CEREAL_NVP(sent_date)
@@ -1274,6 +1286,38 @@ namespace PlayerEvent {
 			);
 		}
 	};
+
+	struct GuildBankTransaction {
+		uint32 char_id;
+		uint32 guild_id;
+		uint32 item_id;
+		uint32 aug_slot_one;
+		uint32 aug_slot_two;
+		uint32 aug_slot_three;
+		uint32 aug_slot_four;
+		uint32 aug_slot_five;
+		uint32 aug_slot_six;
+		uint32 quantity;
+		uint32 permission;
+
+		// cereal
+		template<class Archive>
+		void serialize(Archive &ar)
+		{
+			ar(
+				CEREAL_NVP(char_id),
+				CEREAL_NVP(guild_id),
+				CEREAL_NVP(item_id),
+				CEREAL_NVP(aug_slot_one),
+				CEREAL_NVP(aug_slot_two),
+				CEREAL_NVP(aug_slot_three),
+				CEREAL_NVP(aug_slot_four),
+				CEREAL_NVP(aug_slot_five),
+				CEREAL_NVP(aug_slot_six),
+				CEREAL_NVP(quantity)
+				);
+		}
+	};
 }

 #endif //EQEMU_PLAYER_EVENTS_H
@@ -1,101 +0,0 @@
-/**
- * EQEmulator: Everquest Server Emulator
- * Copyright (C) 2001-2020 EQEmulator Development Team (https://github.com/EQEmu/Server)
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 2 of the License.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY except by those people which sell it, which
- * are required to give you total support for your newly bought product;
- * without even the implied warranty of MERCHANTABILITY or FITNESS FOR
- * A PARTICULAR PURPOSE. See the GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
- *
- */
-
-#include "expedition_lockout_timer.h"
-#include "../common/strings.h"
-#include "../common/rulesys.h"
-#include "../common/util/uuid.h"
-#include <fmt/format.h>
-
-const char* const DZ_REPLAY_TIMER_NAME = "Replay Timer"; // see December 14, 2016 patch notes
-
-ExpeditionLockoutTimer::ExpeditionLockoutTimer(
-	std::string expedition_uuid, std::string expedition_name,
-	std::string event_name, uint64_t expire_time, uint32_t duration
-) :
-	m_expedition_uuid{std::move(expedition_uuid)},
-	m_expedition_name{std::move(expedition_name)},
-	m_event_name{std::move(event_name)},
-	m_expire_time(std::chrono::system_clock::from_time_t(expire_time)),
-	m_duration(duration)
-{
-	if (m_event_name == DZ_REPLAY_TIMER_NAME)
-	{
-		m_is_replay_timer = true;
-	}
-}
-
-ExpeditionLockoutTimer ExpeditionLockoutTimer::CreateLockout(
-	const std::string& expedition_name, const std::string& event_name, uint32_t seconds, std::string uuid)
-{
-	seconds = static_cast<uint32_t>(seconds * RuleR(Expedition, LockoutDurationMultiplier));
-
-	if (uuid.empty())
-	{
-		uuid = EQ::Util::UUID::Generate().ToString();
-	}
-
-	ExpeditionLockoutTimer lockout{uuid, expedition_name, event_name, 0, seconds};
-	lockout.Reset(); // sets expire time
-	return lockout;
-}
-
-uint32_t ExpeditionLockoutTimer::GetSecondsRemaining() const
-{
-	auto now = std::chrono::system_clock::now();
-	if (m_expire_time > now)
-	{
-		auto remaining = m_expire_time - now;
-		return static_cast<uint32_t>(std::chrono::duration_cast<std::chrono::seconds>(remaining).count());
-	}
-	return 0;
-}
-
-ExpeditionLockoutTimer::DaysHoursMinutes ExpeditionLockoutTimer::GetDaysHoursMinutesRemaining() const
-{
-	auto seconds = GetSecondsRemaining();
-	return ExpeditionLockoutTimer::DaysHoursMinutes{
-		fmt::format_int(seconds / 86400).str(),       // days
-		fmt::format_int((seconds / 3600) % 24).str(), // hours
-		fmt::format_int((seconds / 60) % 60).str()    // minutes
-	};
-}
-
-bool ExpeditionLockoutTimer::IsSameLockout(const ExpeditionLockoutTimer& compare_lockout) const
-{
-	return compare_lockout.IsSameLockout(GetExpeditionName(), GetEventName());
-}
-
-bool ExpeditionLockoutTimer::IsSameLockout(
-	const std::string& expedition_name, const std::string& event_name) const
-{
-	return GetExpeditionName() == expedition_name && GetEventName() == event_name;
-}
-
-void ExpeditionLockoutTimer::AddLockoutTime(int seconds)
-{
-	seconds = static_cast<uint32_t>(seconds * RuleR(Expedition, LockoutDurationMultiplier));
-
-	auto new_duration = std::max(0, static_cast<int>(m_duration.count()) + seconds);
-
-	auto start_time = m_expire_time - m_duration;
-	m_duration = std::chrono::seconds(new_duration);
-	m_expire_time = start_time + m_duration;
-}
@@ -1,76 +0,0 @@
-/**
- * EQEmulator: Everquest Server Emulator
- * Copyright (C) 2001-2020 EQEmulator Development Team (https://github.com/EQEmu/Server)
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 2 of the License.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY except by those people which sell it, which
- * are required to give you total support for your newly bought product;
- * without even the implied warranty of MERCHANTABILITY or FITNESS FOR
- * A PARTICULAR PURPOSE. See the GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
- *
- */
-
-#ifndef EXPEDITION_LOCKOUT_TIMER_H
-#define EXPEDITION_LOCKOUT_TIMER_H
-
-#include <chrono>
-#include <string>
-
-extern const char* const DZ_REPLAY_TIMER_NAME;
-
-class ExpeditionLockoutTimer
-{
-public:
-	ExpeditionLockoutTimer() = default;
-	ExpeditionLockoutTimer(
-		std::string expedition_uuid, std::string expedition_name,
-		std::string event_name, uint64_t expire_time, uint32_t duration);
-
-	static ExpeditionLockoutTimer CreateLockout(
-		const std::string& expedition_name, const std::string& event_name,
-		uint32_t seconds, std::string uuid = {});
-
-	struct DaysHoursMinutes
-	{
-		std::string days;
-		std::string hours;
-		std::string mins;
-	};
-
-	void AddLockoutTime(int seconds);
-	uint32_t GetDuration() const { return static_cast<uint32_t>(m_duration.count()); }
-	uint64_t GetExpireTime() const { return std::chrono::system_clock::to_time_t(m_expire_time); }
-	uint64_t GetStartTime() const { return std::chrono::system_clock::to_time_t(m_expire_time - m_duration); }
-	uint32_t GetSecondsRemaining() const;
-	DaysHoursMinutes GetDaysHoursMinutesRemaining() const;
-	const std::string& GetExpeditionName() const { return m_expedition_name; }
-	const std::string& GetExpeditionUUID() const { return m_expedition_uuid; }
-	const std::string& GetEventName() const { return m_event_name; }
-	bool IsExpired() const { return GetSecondsRemaining() == 0; }
-	bool IsFromExpedition(const std::string& uuid) const { return uuid == m_expedition_uuid; }
-	bool IsReplayTimer() const { return m_is_replay_timer; }
-	bool IsSameLockout(const ExpeditionLockoutTimer& compare_lockout) const;
-	bool IsSameLockout(const std::string& expedition_name, const std::string& event_name) const;
-	void Reset() { m_expire_time = std::chrono::system_clock::now() + m_duration; }
-	void SetDuration(uint32_t seconds) { m_duration = std::chrono::seconds(seconds); }
-	void SetExpireTime(uint64_t expire_time) { m_expire_time = std::chrono::system_clock::from_time_t(expire_time); }
-	void SetUUID(const std::string& uuid) { m_expedition_uuid = uuid; }
-
-private:
-	bool m_is_replay_timer = false;
-	std::string m_expedition_uuid; // expedition received in
-	std::string m_expedition_name;
-	std::string m_event_name;
-	std::chrono::seconds m_duration;
-	std::chrono::time_point<std::chrono::system_clock> m_expire_time;
-};
-
-#endif
@@ -39,6 +39,7 @@
 #include <filesystem>
 #include <iostream>
 #include <sys/stat.h>
+#include <vector>

 namespace fs = std::filesystem;

@@ -90,23 +91,21 @@ std::string File::GetCwd()

 FileContentsResult File::GetContents(const std::string &file_name)
 {
-	std::string   error;
-	std::ifstream f;
-	f.open(file_name);
-	std::string line;
-	std::string lines;
-	if (f.is_open()) {
-		while (f) {
-			std::getline(f, line);
-			lines += line + "\n";
-		}
+	std::ifstream f(file_name, std::ios::in | std::ios::binary);
+	if (!f) {
+		return { .error = fmt::format("Couldn't open file [{}]", file_name) };
 	}
-	else {
-		error = fmt::format("Couldn't open file [{}]", file_name);
+
+	constexpr size_t CHUNK_SIZE = 4096;  // Read 4KB chunks
+	std::string lines;
+	std::vector<char> buffer(CHUNK_SIZE);
+
+	while (f.read(buffer.data(), CHUNK_SIZE) || f.gcount() > 0) {
+		lines.append(buffer.data(), f.gcount());
 	}

 	return FileContentsResult{
 		.contents = lines,
-		.error = error,
+		.error = {}
 	};
 }
@@ -547,60 +547,62 @@ uint32 BaseGuildManager::UpdateDbCreateGuild(std::string name, uint32 leader)

 bool BaseGuildManager::UpdateDbDeleteGuild(uint32 guild_id, bool local_delete, bool db_delete)
 {
+	auto const where_filter = fmt::format("guild_id = {}", guild_id);
+	auto const bank_items   = GuildBankRepository::GetWhere(*m_db, where_filter);
+
 	if (local_delete) {
-		auto where_filter = fmt::format("guildid = {}", guild_id);
-		auto bank_items   = GuildBankRepository::GetWhere(*m_db, where_filter);
 		if (!bank_items.empty()) {
 			LogError(
-				"Attempt to delete guild id [{}] that still has [{}] items in the bank. Please remove them and try again.",
+				"Attempt to delete guild id [{}] that still has [{}] items in the bank. Please remove them and try "
+				"again.",
 				guild_id,
 				bank_items.size()
 			);
 			LogGuilds(
-				"Attempt to delete guild id [{}] that still has [{}] items in the bank. Please remove them and try again.",
+				"Attempt to delete guild id [{}] that still has [{}] items in the bank. Please remove them and try "
+				"again.",
 				guild_id,
 				bank_items.size()
 			);
+
 			return false;
 		}
-		else {
-			std::map<uint32, GuildInfo *>::iterator res;
-			res = m_guilds.find(guild_id);
-			if (res != m_guilds.end()) {
-				delete res->second;
-				m_guilds.erase(res);
-				LogGuilds("Deleted guild [{}] from memory", guild_id);
-				//Does this need to be sent to world?
-			}
+
+		auto res = m_guilds.find(guild_id);
+		if (res != m_guilds.end()) {
+			safe_delete(res->second);
+			m_guilds.erase(res);
+			LogGuilds("Deleted guild [{}] from memory", guild_id);
+			// Does this need to be sent to world?
 		}
 	}

 	if (db_delete) {
-		auto where_filter = fmt::format("guildid = {}", guild_id);
-		auto bank_items   = GuildBankRepository::GetWhere(*m_db, where_filter);
 		if (!bank_items.empty()) {
 			LogError(
-				"Attempt to delete guild id [{}] that still has [{}] items in the bank. Please remove them and try again.",
+				"Attempt to delete guild id [{}] that still has [{}] items in the bank. Please remove them and try "
+				"again.",
 				guild_id,
 				bank_items.size()
 			);
 			LogGuilds(
-				"Attempt to delete guild id [{}] that still has [{}] items in the bank. Please remove them and try again.",
+				"Attempt to delete guild id [{}] that still has [{}] items in the bank. Please remove them and try "
+				"again.",
 				guild_id,
 				bank_items.size()
 			);
+
 			return false;
 		}
-		else {
-			auto where_filter = fmt::format("guild_id = {}", guild_id);
-			GuildTributesRepository::DeleteOne(*m_db, guild_id);
-			GuildsRepository::DeleteOne(*m_db, guild_id);
-			GuildRanksRepository::DeleteWhere(*m_db, where_filter);
-			GuildPermissionsRepository::DeleteWhere(*m_db, where_filter);
-			GuildMembersRepository::DeleteWhere(*m_db, where_filter);
-			LogGuilds("Deleted guild [{}] from the database", guild_id);
-		}
+
+		GuildTributesRepository::DeleteOne(*m_db, guild_id);
+		GuildsRepository::DeleteOne(*m_db, guild_id);
+		GuildRanksRepository::DeleteWhere(*m_db, where_filter);
+		GuildPermissionsRepository::DeleteWhere(*m_db, where_filter);
+		GuildMembersRepository::DeleteWhere(*m_db, where_filter);
+		LogGuilds("Deleted guild [{}] from the database", guild_id);
 	}
+
 	return true;
 }

@@ -2028,3 +2028,57 @@ int16 EQ::InventoryProfile::_HasEvolvingItem(ItemInstQueue &iqueue, uint64 evolv

 	return INVALID_INDEX;
 }
+
+
+int16 EQ::InventoryProfile::FindFirstFreeSlotThatFitsItemWithStacking(ItemInstance *item_inst) const
+{
+	auto item_data = item_inst->GetItem();
+	if (!item_data) {
+		return INVALID_INDEX;
+	}
+
+	for (int16 i = invslot::GENERAL_BEGIN; i <= invslot::GENERAL_END; i++) {
+		auto const inv_item = GetItem(i);
+		if (!inv_item) {
+			// Found available slot in personal inventory
+			// Anything will fit here
+			return i;
+		}
+
+		if (item_data->IsClassBag() && item_inst->IsNoneEmptyContainer()) {
+			// If the inbound item is a bag with items, it cannot be stored within a bag
+			// Move to next potential slot
+			continue;
+		}
+
+		if (inv_item->GetID() == item_data->ID && item_data->Stackable) {
+			if (item_inst->GetCharges() + inv_item->GetCharges() <= item_data->StackSize) {
+				// Found a personal inventory slot that has room for a stackable addition
+				return i;
+			}
+		}
+
+		if (inv_item->IsClassBag() && CanItemFitInContainer(item_data, inv_item->GetItem())) {
+			int16 const base_slot_id = CalcSlotId(i, invbag::SLOT_BEGIN);
+			uint8 const bag_size     = inv_item->GetItem()->BagSlots;
+			uint8 const item_size    = item_data->Size;
+
+			for (uint8 bag_slot = invbag::SLOT_BEGIN; bag_slot < bag_size; bag_slot++) {
+				auto bag_item = GetItem(base_slot_id + bag_slot);
+				if (!bag_item) {
+					// Found available slot within bag that will hold inbound item
+					return base_slot_id + bag_slot;
+				}
+
+				if (bag_item && item_data->Stackable && bag_item->GetID() == item_data->ID) {
+					if (item_inst->GetCharges() + bag_item->GetCharges() <= item_data->StackSize) {
+						// Found a bag slot has room for a stackable addition
+						return base_slot_id + bag_slot;
+					}
+				}
+			}
+		}
+	}
+
+	return INVALID_INDEX;
+}
@@ -179,6 +179,7 @@ namespace EQ
 		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);
 		int16 FindFirstFreeSlotThatFitsItem(const EQ::ItemData *inst);
+		int16 FindFirstFreeSlotThatFitsItemWithStacking(ItemInstance *inst) const;

 		// Calculate slot_id for an item within a bag
 		static int16 CalcSlotId(int16 slot_id); // Calc parent bag's slot_id
@@ -25,6 +25,7 @@ struct LootItem {
 	uint16      trivial_max_level;
 	uint16      npc_min_level;
 	uint16      npc_max_level;
+	uint32      lootdrop_id; // required for zone state referencing
 };

 typedef std::list<LootItem*> LootItems;
@@ -25,7 +25,7 @@ void EQ::Net::ServertalkServerConnection::Send(uint16_t opcode, EQ::Net::Packet
 			return;

 		if (opcode == ServerOP_UsertoWorldReq) {
-			auto req_in = (UsertoWorldRequest_Struct*)p.Data();
+			auto req_in = (UsertoWorldRequest*)p.Data();

 			EQ::Net::DynamicPacket req;
 			size_t i = 0;
@@ -45,7 +45,7 @@ void EQ::Net::ServertalkServerConnection::Send(uint16_t opcode, EQ::Net::Packet
 		}

 		if (opcode == ServerOP_LSClientAuth) {
-			auto req_in = (ClientAuth_Struct*)p.Data();
+			auto req_in = (ClientAuth*)p.Data();

 			EQ::Net::DynamicPacket req;
 			size_t i = 0;
@@ -54,7 +54,7 @@ void EQ::Net::ServertalkServerConnection::Send(uint16_t opcode, EQ::Net::Packet
 			req.PutData(i, req_in->key, 30); i += 30;
 			req.PutUInt8(i, req_in->lsadmin); i += 1;
 			req.PutUInt16(i, req_in->is_world_admin); i += 2;
-			req.PutUInt32(i, req_in->ip); i += 4;
+			req.PutUInt32(i, req_in->ip_address); i += 4;
 			req.PutUInt8(i, req_in->is_client_from_local_network); i += 1;

 			EQ::Net::DynamicPacket out;
@@ -1213,22 +1213,22 @@ namespace RoF
 		case 1: { // GuildBankItemUpdate
 			auto emu = (GuildBankItemUpdate_Struct *)in->pBuffer;
 			auto eq = (structs::GuildBankItemUpdate_Struct *)outapp->pBuffer;
-			eq->Action = 0;
-			OUT(Unknown004);
-			eq->Unknown08 = 0;
-			OUT(SlotID);
-			OUT(Area);
-			OUT(Unknown012);
-			OUT(ItemID);
-			OUT(Icon);
-			OUT(Quantity);
-			OUT(Permissions);
-			OUT(AllowMerge);
-			OUT(Useable);
-			OUT_str(ItemName);
-			OUT_str(Donator);
-			OUT_str(WhoFor);
-			OUT(Unknown226);
+			eq->action = 0;
+			OUT(unknown004);
+			eq->unknown008 = 0;
+			OUT(slot_id);
+			OUT(area);
+			OUT(display);
+			OUT(item_id);
+			OUT(icon_id);
+			OUT(quantity);
+			OUT(permissions);
+			OUT(allow_merge);
+			OUT(is_useable);
+			OUT_str(item_name);
+			OUT_str(donator);
+			OUT_str(who_for);
+			OUT(unknown226);
 			break;
 		}
 		default:
@@ -1743,22 +1743,19 @@ namespace RoF2
 		case 1: { // GuildBankItemUpdate
 			auto emu = (GuildBankItemUpdate_Struct *)in->pBuffer;
 			auto eq = (structs::GuildBankItemUpdate_Struct *)outapp->pBuffer;
-			eq->Action = 0;
-			OUT(Unknown004);
-			eq->Unknown08 = 0;
-			OUT(SlotID);
-			OUT(Area);
-			OUT(Unknown012);
-			OUT(ItemID);
-			OUT(Icon);
-			OUT(Quantity);
-			OUT(Permissions);
-			OUT(AllowMerge);
-			OUT(Useable);
-			OUT_str(ItemName);
-			OUT_str(Donator);
-			OUT_str(WhoFor);
-			OUT(Unknown226);
+			eq->action = 0;
+			OUT(display);
+			OUT(slot_id);
+			OUT(area);
+			OUT(item_id);
+			OUT(icon_id);
+			OUT(quantity);
+			OUT(permissions);
+			OUT(allow_merge);
+			OUT(is_useable);
+			OUT_str(item_name);
+			OUT_str(donator);
+			OUT_str(who_for);
 			break;
 		}
 		default:
@@ -101,6 +101,8 @@ namespace RoF2
 		const int16 MAIL_SIZE                 = 0;//unknown
 		const int16 GUILD_TROPHY_TRIBUTE_SIZE = 0;//unknown
 		const int16 KRONO_SIZE                = 0;//unknown
+		const int16 GUILD_BANK_MAIN_SIZE      = 200;
+		const int16 GUILD_BANK_DEPOSIT_SIZE   = 40;
 		const int16 OTHER_SIZE                = 0;//unknown

 		const int16 TRADE_NPC_SIZE = 4; // defined by implication
@@ -1965,41 +1965,39 @@ struct GuildBankWithdrawItem_Struct

 struct GuildBankItemUpdate_Struct
 {
-	void Init(uint32 inAction, uint32 inUnknown004, uint16 inSlotID, uint16 inArea, uint16 inUnknown012, uint32 inItemID, uint32 inIcon, uint32 inQuantity,
+	void Init(uint32 inAction, uint32 inUnknown004, uint16 inSlotID, uint16 inArea, uint16 inUnknown016, uint32 inItemID, uint32 inIcon, uint32 inQuantity,
 			uint32 inPermissions, uint32 inAllowMerge, bool inUseable)
 	{
-		Action = inAction;
-		Unknown004 = inUnknown004;
-		SlotID = inSlotID;
-		Area = inArea;
-		Unknown012 = inUnknown012;
-		ItemID = inItemID;
-		Icon = inIcon;
-		Quantity = inQuantity;
-		Permissions = inPermissions;
-		AllowMerge = inAllowMerge;
-		Useable = inUseable;
-		ItemName[0] = '\0';
-		Donator[0] = '\0';
-		WhoFor[0] = '\0';
+		action       = inAction;
+		slot_id      = inSlotID;
+		area         = inArea;
+		display      = inUnknown016;
+		item_id      = inItemID;
+		icon_id      = inIcon;
+		quantity     = inQuantity;
+		permissions  = inPermissions;
+		allow_merge  = inAllowMerge;
+		is_useable   = inUseable;
+		item_name[0] = '\0';
+		donator[0]   = '\0';
+		who_for[0]   = '\0';
 	};

-/*000*/	uint32	Action;
-/*004*/	uint32	Unknown004;
-/*008*/	uint32	Unknown08;
-/*012*/	uint16	SlotID;
-/*014*/	uint16	Area;
-/*016*/	uint32	Unknown012;
-/*020*/	uint32	ItemID;
-/*024*/	uint32	Icon;
-/*028*/	uint32	Quantity;
-/*032*/	uint32	Permissions;
-/*036*/	uint8	AllowMerge;
-/*037*/	uint8	Useable;	// Used in conjunction with the Public-if-useable permission.
-/*038*/	char	ItemName[64];
-/*102*/	char	Donator[64];
-/*166*/ char	WhoFor[64];
-/*230*/	uint16	Unknown226;
+/*000*/	uint32	action;
+/*004*/	uint32	not_used004;  //disassemble of client did not use this
+/*008*/	uint32	not_used008;  //disassemble of client did not use this
+/*012*/	uint16	slot_id;
+/*014*/	uint16	area;
+/*016*/	uint32	display;
+/*020*/	uint32	item_id;
+/*024*/	uint32	icon_id;
+/*028*/	uint32	quantity;
+/*032*/	uint32	permissions;
+/*036*/	uint8	allow_merge;
+/*037*/	uint8	is_useable;	// Used in conjunction with the Public-if-useable permission.
+/*038*/	char	item_name[64];
+/*102*/	char	donator[64];
+/*166*/ char	who_for[64];
 };

 struct GuildBankClear_Struct
@@ -1946,38 +1946,38 @@ struct GuildBankItemUpdate_Struct
 	void Init(uint32 inAction, uint32 inUnknown004, uint16 inSlotID, uint16 inArea, uint16 inUnknown012, uint32 inItemID, uint32 inIcon, uint32 inQuantity,
 			uint32 inPermissions, uint32 inAllowMerge, bool inUseable)
 	{
-		Action = inAction;
-		Unknown004 = inUnknown004;
-		SlotID = inSlotID;
-		Area = inArea;
-		Unknown012 = inUnknown012;
-		ItemID = inItemID;
-		Icon = inIcon;
-		Quantity = inQuantity;
-		Permissions = inPermissions;
-		AllowMerge = inAllowMerge;
-		Useable = inUseable;
-		ItemName[0] = '\0';
-		Donator[0] = '\0';
-		WhoFor[0] = '\0';
+		action       = inAction;
+		unknown004   = inUnknown004;
+		slot_id      = inSlotID;
+		area         = inArea;
+		display      = inUnknown012;
+		item_id      = inItemID;
+		icon_id      = inIcon;
+		quantity     = inQuantity;
+		permissions  = inPermissions;
+		allow_merge  = inAllowMerge;
+		is_useable   = inUseable;
+		item_name[0] = '\0';
+		donator[0]   = '\0';
+		who_for[0]   = '\0';
 	};

-/*000*/	uint32	Action;
-/*004*/	uint32	Unknown004;
-/*008*/	uint32	Unknown08;
-/*012*/	uint16	SlotID;
-/*014*/	uint16	Area;
-/*016*/	uint32	Unknown012;
-/*020*/	uint32	ItemID;
-/*024*/	uint32	Icon;
-/*028*/	uint32	Quantity;
-/*032*/	uint32	Permissions;
-/*036*/	uint8	AllowMerge;
-/*037*/	uint8	Useable;	// Used in conjunction with the Public-if-useable permission.
-/*038*/	char	ItemName[64];
-/*102*/	char	Donator[64];
-/*166*/ char	WhoFor[64];
-/*230*/	uint16	Unknown226;
+/*000*/	uint32	action;
+/*004*/	uint32	unknown004;
+/*008*/	uint32	unknown008;
+/*012*/	uint16	slot_id;
+/*014*/	uint16	area;
+/*016*/	uint32	display;
+/*020*/	uint32	item_id;
+/*024*/	uint32	icon_id;
+/*028*/	uint32	quantity;
+/*032*/	uint32	permissions;
+/*036*/	uint8	allow_merge;
+/*037*/	uint8	is_useable;	// Used in conjunction with the Public-if-useable permission.
+/*038*/	char	item_name[64];
+/*102*/	char	donator[64];
+/*166*/ char	who_for[64];
+/*230*/	uint16	unknown226;
 };

 struct GuildBankClear_Struct
@@ -76,7 +76,7 @@ void PathManager::LoadPaths()
 	constexpr int path_width   = 0;
 	constexpr int break_length = 70;

-	std::cout << std::endl;
+	LogInfo("Loading server paths");
 	LogInfo("{}", Strings::Repeat("-", break_length));
 	for (const auto& [name, in_path] : paths) {
 		if (!in_path.empty()) {
@@ -23,10 +23,12 @@ public:
 		std::string key_;
 		std::string value;
 		uint32_t    expires;
-		int64_t     account_id;
-		int64_t     character_id;
-		int64_t     npc_id;
-		int64_t     bot_id;
+		uint64_t    account_id;
+		uint64_t    character_id;
+		uint32_t    npc_id;
+		uint32_t    bot_id;
+		uint16_t    zone_id;
+		uint16_t    instance_id;

 		// cereal
 		template<class Archive>
@@ -40,7 +42,9 @@ public:
 				CEREAL_NVP(account_id),
 				CEREAL_NVP(character_id),
 				CEREAL_NVP(npc_id),
-				CEREAL_NVP(bot_id)
+				CEREAL_NVP(bot_id),
+				CEREAL_NVP(zone_id),
+				CEREAL_NVP(instance_id)
 			);
 		}
 	};
@@ -61,6 +65,8 @@ public:
 			"character_id",
 			"npc_id",
 			"bot_id",
+			"zone_id",
+			"instance_id",
 		};
 	}

@@ -75,6 +81,8 @@ public:
 			"character_id",
 			"npc_id",
 			"bot_id",
+			"zone_id",
+			"instance_id",
 		};
 	}

@@ -123,6 +131,8 @@ public:
 		e.character_id = 0;
 		e.npc_id       = 0;
 		e.bot_id       = 0;
+		e.zone_id      = 0;
+		e.instance_id  = 0;

 		return e;
 	}
@@ -163,10 +173,12 @@ public:
 			e.key_         = row[1] ? row[1] : "";
 			e.value        = row[2] ? row[2] : "";
 			e.expires      = row[3] ? static_cast<uint32_t>(strtoul(row[3], nullptr, 10)) : 0;
-			e.account_id   = row[4] ? strtoll(row[4], nullptr, 10) : 0;
-			e.character_id = row[5] ? strtoll(row[5], nullptr, 10) : 0;
-			e.npc_id       = row[6] ? strtoll(row[6], nullptr, 10) : 0;
-			e.bot_id       = row[7] ? strtoll(row[7], nullptr, 10) : 0;
+			e.account_id   = row[4] ? strtoull(row[4], nullptr, 10) : 0;
+			e.character_id = row[5] ? strtoull(row[5], nullptr, 10) : 0;
+			e.npc_id       = row[6] ? static_cast<uint32_t>(strtoul(row[6], nullptr, 10)) : 0;
+			e.bot_id       = row[7] ? static_cast<uint32_t>(strtoul(row[7], nullptr, 10)) : 0;
+			e.zone_id      = row[8] ? static_cast<uint16_t>(strtoul(row[8], nullptr, 10)) : 0;
+			e.instance_id  = row[9] ? static_cast<uint16_t>(strtoul(row[9], nullptr, 10)) : 0;

 			return e;
 		}
@@ -207,6 +219,8 @@ public:
 		v.push_back(columns[5] + " = " + std::to_string(e.character_id));
 		v.push_back(columns[6] + " = " + std::to_string(e.npc_id));
 		v.push_back(columns[7] + " = " + std::to_string(e.bot_id));
+		v.push_back(columns[8] + " = " + std::to_string(e.zone_id));
+		v.push_back(columns[9] + " = " + std::to_string(e.instance_id));

 		auto results = db.QueryDatabase(
 			fmt::format(
@@ -236,6 +250,8 @@ public:
 		v.push_back(std::to_string(e.character_id));
 		v.push_back(std::to_string(e.npc_id));
 		v.push_back(std::to_string(e.bot_id));
+		v.push_back(std::to_string(e.zone_id));
+		v.push_back(std::to_string(e.instance_id));

 		auto results = db.QueryDatabase(
 			fmt::format(
@@ -273,6 +289,8 @@ public:
 			v.push_back(std::to_string(e.character_id));
 			v.push_back(std::to_string(e.npc_id));
 			v.push_back(std::to_string(e.bot_id));
+			v.push_back(std::to_string(e.zone_id));
+			v.push_back(std::to_string(e.instance_id));

 			insert_chunks.push_back("(" + Strings::Implode(",", v) + ")");
 		}
@@ -310,10 +328,12 @@ public:
 			e.key_         = row[1] ? row[1] : "";
 			e.value        = row[2] ? row[2] : "";
 			e.expires      = row[3] ? static_cast<uint32_t>(strtoul(row[3], nullptr, 10)) : 0;
-			e.account_id   = row[4] ? strtoll(row[4], nullptr, 10) : 0;
-			e.character_id = row[5] ? strtoll(row[5], nullptr, 10) : 0;
-			e.npc_id       = row[6] ? strtoll(row[6], nullptr, 10) : 0;
-			e.bot_id       = row[7] ? strtoll(row[7], nullptr, 10) : 0;
+			e.account_id   = row[4] ? strtoull(row[4], nullptr, 10) : 0;
+			e.character_id = row[5] ? strtoull(row[5], nullptr, 10) : 0;
+			e.npc_id       = row[6] ? static_cast<uint32_t>(strtoul(row[6], nullptr, 10)) : 0;
+			e.bot_id       = row[7] ? static_cast<uint32_t>(strtoul(row[7], nullptr, 10)) : 0;
+			e.zone_id      = row[8] ? static_cast<uint16_t>(strtoul(row[8], nullptr, 10)) : 0;
+			e.instance_id  = row[9] ? static_cast<uint16_t>(strtoul(row[9], nullptr, 10)) : 0;

 			all_entries.push_back(e);
 		}
@@ -342,10 +362,12 @@ public:
 			e.key_         = row[1] ? row[1] : "";
 			e.value        = row[2] ? row[2] : "";
 			e.expires      = row[3] ? static_cast<uint32_t>(strtoul(row[3], nullptr, 10)) : 0;
-			e.account_id   = row[4] ? strtoll(row[4], nullptr, 10) : 0;
-			e.character_id = row[5] ? strtoll(row[5], nullptr, 10) : 0;
-			e.npc_id       = row[6] ? strtoll(row[6], nullptr, 10) : 0;
-			e.bot_id       = row[7] ? strtoll(row[7], nullptr, 10) : 0;
+			e.account_id   = row[4] ? strtoull(row[4], nullptr, 10) : 0;
+			e.character_id = row[5] ? strtoull(row[5], nullptr, 10) : 0;
+			e.npc_id       = row[6] ? static_cast<uint32_t>(strtoul(row[6], nullptr, 10)) : 0;
+			e.bot_id       = row[7] ? static_cast<uint32_t>(strtoul(row[7], nullptr, 10)) : 0;
+			e.zone_id      = row[8] ? static_cast<uint16_t>(strtoul(row[8], nullptr, 10)) : 0;
+			e.instance_id  = row[9] ? static_cast<uint16_t>(strtoul(row[9], nullptr, 10)) : 0;

 			all_entries.push_back(e);
 		}
@@ -428,6 +450,8 @@ public:
 		v.push_back(std::to_string(e.character_id));
 		v.push_back(std::to_string(e.npc_id));
 		v.push_back(std::to_string(e.bot_id));
+		v.push_back(std::to_string(e.zone_id));
+		v.push_back(std::to_string(e.instance_id));

 		auto results = db.QueryDatabase(
 			fmt::format(
@@ -458,6 +482,8 @@ public:
 			v.push_back(std::to_string(e.character_id));
 			v.push_back(std::to_string(e.npc_id));
 			v.push_back(std::to_string(e.bot_id));
+			v.push_back(std::to_string(e.zone_id));
+			v.push_back(std::to_string(e.instance_id));

 			insert_chunks.push_back("(" + Strings::Implode(",", v) + ")");
 		}
@@ -9,18 +9,18 @@
 * @docs https://docs.eqemu.io/developer/repositories
 */

-#ifndef EQEMU_BASE_EXPEDITION_LOCKOUTS_REPOSITORY_H
-#define EQEMU_BASE_EXPEDITION_LOCKOUTS_REPOSITORY_H
+#ifndef EQEMU_BASE_DYNAMIC_ZONE_LOCKOUTS_REPOSITORY_H
+#define EQEMU_BASE_DYNAMIC_ZONE_LOCKOUTS_REPOSITORY_H

 #include "../../database.h"
 #include "../../strings.h"
 #include <ctime>

-class BaseExpeditionLockoutsRepository {
+class BaseDynamicZoneLockoutsRepository {
 public:
-	struct ExpeditionLockouts {
+	struct DynamicZoneLockouts {
 		uint32_t    id;
-		uint32_t    expedition_id;
+		uint32_t    dynamic_zone_id;
 		std::string event_name;
 		time_t      expire_time;
 		uint32_t    duration;
@@ -36,7 +36,7 @@ public:
 	{
 		return {
 			"id",
-			"expedition_id",
+			"dynamic_zone_id",
 			"event_name",
 			"expire_time",
 			"duration",
@@ -48,7 +48,7 @@ public:
 	{
 		return {
 			"id",
-			"expedition_id",
+			"dynamic_zone_id",
 			"event_name",
 			"UNIX_TIMESTAMP(expire_time)",
 			"duration",
@@ -68,7 +68,7 @@ public:

 	static std::string TableName()
 	{
-		return std::string("expedition_lockouts");
+		return std::string("dynamic_zone_lockouts");
 	}

 	static std::string BaseSelect()
@@ -89,12 +89,12 @@ public:
 		);
 	}

-	static ExpeditionLockouts NewEntity()
+	static DynamicZoneLockouts NewEntity()
 	{
-		ExpeditionLockouts e{};
+		DynamicZoneLockouts e{};

 		e.id                   = 0;
-		e.expedition_id        = 0;
+		e.dynamic_zone_id      = 0;
 		e.event_name           = "";
 		e.expire_time          = std::time(nullptr);
 		e.duration             = 0;
@@ -103,23 +103,23 @@ public:
 		return e;
 	}

-	static ExpeditionLockouts GetExpeditionLockouts(
-		const std::vector<ExpeditionLockouts> &expedition_lockoutss,
-		int expedition_lockouts_id
+	static DynamicZoneLockouts GetDynamicZoneLockouts(
+		const std::vector<DynamicZoneLockouts> &dynamic_zone_lockoutss,
+		int dynamic_zone_lockouts_id
 	)
 	{
-		for (auto &expedition_lockouts : expedition_lockoutss) {
-			if (expedition_lockouts.id == expedition_lockouts_id) {
-				return expedition_lockouts;
+		for (auto &dynamic_zone_lockouts : dynamic_zone_lockoutss) {
+			if (dynamic_zone_lockouts.id == dynamic_zone_lockouts_id) {
+				return dynamic_zone_lockouts;
 			}
 		}

 		return NewEntity();
 	}

-	static ExpeditionLockouts FindOne(
+	static DynamicZoneLockouts FindOne(
 		Database& db,
-		int expedition_lockouts_id
+		int dynamic_zone_lockouts_id
 	)
 	{
 		auto results = db.QueryDatabase(
@@ -127,16 +127,16 @@ public:
 				"{} WHERE {} = {} LIMIT 1",
 				BaseSelect(),
 				PrimaryKey(),
-				expedition_lockouts_id
+				dynamic_zone_lockouts_id
 			)
 		);

 		auto row = results.begin();
 		if (results.RowCount() == 1) {
-			ExpeditionLockouts e{};
+			DynamicZoneLockouts e{};

 			e.id                   = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
-			e.expedition_id        = row[1] ? static_cast<uint32_t>(strtoul(row[1], nullptr, 10)) : 0;
+			e.dynamic_zone_id      = row[1] ? static_cast<uint32_t>(strtoul(row[1], nullptr, 10)) : 0;
 			e.event_name           = row[2] ? row[2] : "";
 			e.expire_time          = strtoll(row[3] ? row[3] : "-1", nullptr, 10);
 			e.duration             = row[4] ? static_cast<uint32_t>(strtoul(row[4], nullptr, 10)) : 0;
@@ -150,7 +150,7 @@ public:

 	static int DeleteOne(
 		Database& db,
-		int expedition_lockouts_id
+		int dynamic_zone_lockouts_id
 	)
 	{
 		auto results = db.QueryDatabase(
@@ -158,7 +158,7 @@ public:
 				"DELETE FROM {} WHERE {} = {}",
 				TableName(),
 				PrimaryKey(),
-				expedition_lockouts_id
+				dynamic_zone_lockouts_id
 			)
 		);

@@ -167,14 +167,14 @@ public:

 	static int UpdateOne(
 		Database& db,
-		const ExpeditionLockouts &e
+		const DynamicZoneLockouts &e
 	)
 	{
 		std::vector<std::string> v;

 		auto columns = Columns();

-		v.push_back(columns[1] + " = " + std::to_string(e.expedition_id));
+		v.push_back(columns[1] + " = " + std::to_string(e.dynamic_zone_id));
 		v.push_back(columns[2] + " = '" + Strings::Escape(e.event_name) + "'");
 		v.push_back(columns[3] + " = FROM_UNIXTIME(" + (e.expire_time > 0 ? std::to_string(e.expire_time) : "null") + ")");
 		v.push_back(columns[4] + " = " + std::to_string(e.duration));
@@ -193,15 +193,15 @@ public:
 		return (results.Success() ? results.RowsAffected() : 0);
 	}

-	static ExpeditionLockouts InsertOne(
+	static DynamicZoneLockouts InsertOne(
 		Database& db,
-		ExpeditionLockouts e
+		DynamicZoneLockouts e
 	)
 	{
 		std::vector<std::string> v;

 		v.push_back(std::to_string(e.id));
-		v.push_back(std::to_string(e.expedition_id));
+		v.push_back(std::to_string(e.dynamic_zone_id));
 		v.push_back("'" + Strings::Escape(e.event_name) + "'");
 		v.push_back("FROM_UNIXTIME(" + (e.expire_time > 0 ? std::to_string(e.expire_time) : "null") + ")");
 		v.push_back(std::to_string(e.duration));
@@ -227,7 +227,7 @@ public:

 	static int InsertMany(
 		Database& db,
-		const std::vector<ExpeditionLockouts> &entries
+		const std::vector<DynamicZoneLockouts> &entries
 	)
 	{
 		std::vector<std::string> insert_chunks;
@@ -236,7 +236,7 @@ public:
 			std::vector<std::string> v;

 			v.push_back(std::to_string(e.id));
-			v.push_back(std::to_string(e.expedition_id));
+			v.push_back(std::to_string(e.dynamic_zone_id));
 			v.push_back("'" + Strings::Escape(e.event_name) + "'");
 			v.push_back("FROM_UNIXTIME(" + (e.expire_time > 0 ? std::to_string(e.expire_time) : "null") + ")");
 			v.push_back(std::to_string(e.duration));
@@ -258,9 +258,9 @@ public:
 		return (results.Success() ? results.RowsAffected() : 0);
 	}

-	static std::vector<ExpeditionLockouts> All(Database& db)
+	static std::vector<DynamicZoneLockouts> All(Database& db)
 	{
-		std::vector<ExpeditionLockouts> all_entries;
+		std::vector<DynamicZoneLockouts> all_entries;

 		auto results = db.QueryDatabase(
 			fmt::format(
@@ -272,10 +272,10 @@ public:
 		all_entries.reserve(results.RowCount());

 		for (auto row = results.begin(); row != results.end(); ++row) {
-			ExpeditionLockouts e{};
+			DynamicZoneLockouts e{};

 			e.id                   = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
-			e.expedition_id        = row[1] ? static_cast<uint32_t>(strtoul(row[1], nullptr, 10)) : 0;
+			e.dynamic_zone_id      = row[1] ? static_cast<uint32_t>(strtoul(row[1], nullptr, 10)) : 0;
 			e.event_name           = row[2] ? row[2] : "";
 			e.expire_time          = strtoll(row[3] ? row[3] : "-1", nullptr, 10);
 			e.duration             = row[4] ? static_cast<uint32_t>(strtoul(row[4], nullptr, 10)) : 0;
@@ -287,9 +287,9 @@ public:
 		return all_entries;
 	}

-	static std::vector<ExpeditionLockouts> GetWhere(Database& db, const std::string &where_filter)
+	static std::vector<DynamicZoneLockouts> GetWhere(Database& db, const std::string &where_filter)
 	{
-		std::vector<ExpeditionLockouts> all_entries;
+		std::vector<DynamicZoneLockouts> all_entries;

 		auto results = db.QueryDatabase(
 			fmt::format(
@@ -302,10 +302,10 @@ public:
 		all_entries.reserve(results.RowCount());

 		for (auto row = results.begin(); row != results.end(); ++row) {
-			ExpeditionLockouts e{};
+			DynamicZoneLockouts e{};

 			e.id                   = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
-			e.expedition_id        = row[1] ? static_cast<uint32_t>(strtoul(row[1], nullptr, 10)) : 0;
+			e.dynamic_zone_id      = row[1] ? static_cast<uint32_t>(strtoul(row[1], nullptr, 10)) : 0;
 			e.event_name           = row[2] ? row[2] : "";
 			e.expire_time          = strtoll(row[3] ? row[3] : "-1", nullptr, 10);
 			e.duration             = row[4] ? static_cast<uint32_t>(strtoul(row[4], nullptr, 10)) : 0;
@@ -379,13 +379,13 @@ public:

 	static int ReplaceOne(
 		Database& db,
-		const ExpeditionLockouts &e
+		const DynamicZoneLockouts &e
 	)
 	{
 		std::vector<std::string> v;

 		v.push_back(std::to_string(e.id));
-		v.push_back(std::to_string(e.expedition_id));
+		v.push_back(std::to_string(e.dynamic_zone_id));
 		v.push_back("'" + Strings::Escape(e.event_name) + "'");
 		v.push_back("FROM_UNIXTIME(" + (e.expire_time > 0 ? std::to_string(e.expire_time) : "null") + ")");
 		v.push_back(std::to_string(e.duration));
@@ -404,7 +404,7 @@ public:

 	static int ReplaceMany(
 		Database& db,
-		const std::vector<ExpeditionLockouts> &entries
+		const std::vector<DynamicZoneLockouts> &entries
 	)
 	{
 		std::vector<std::string> insert_chunks;
@@ -413,7 +413,7 @@ public:
 			std::vector<std::string> v;

 			v.push_back(std::to_string(e.id));
-			v.push_back(std::to_string(e.expedition_id));
+			v.push_back(std::to_string(e.dynamic_zone_id));
 			v.push_back("'" + Strings::Escape(e.event_name) + "'");
 			v.push_back("FROM_UNIXTIME(" + (e.expire_time > 0 ? std::to_string(e.expire_time) : "null") + ")");
 			v.push_back(std::to_string(e.duration));
@@ -436,4 +436,4 @@ public:
 	}
 };

-#endif //EQEMU_BASE_EXPEDITION_LOCKOUTS_REPOSITORY_H
+#endif //EQEMU_BASE_DYNAMIC_ZONE_LOCKOUTS_REPOSITORY_H
@@ -42,6 +42,8 @@ public:
 		float       zone_in_z;
 		float       zone_in_heading;
 		uint8_t     has_zone_in;
+		int8_t      is_locked;
+		int8_t      add_replay;
 	};

 	static std::string PrimaryKey()
@@ -75,6 +77,8 @@ public:
 			"zone_in_z",
 			"zone_in_heading",
 			"has_zone_in",
+			"is_locked",
+			"add_replay",
 		};
 	}

@@ -104,6 +108,8 @@ public:
 			"zone_in_z",
 			"zone_in_heading",
 			"has_zone_in",
+			"is_locked",
+			"add_replay",
 		};
 	}

@@ -167,6 +173,8 @@ public:
 		e.zone_in_z           = 0;
 		e.zone_in_heading     = 0;
 		e.has_zone_in         = 0;
+		e.is_locked           = 0;
+		e.add_replay          = 1;

 		return e;
 	}
@@ -226,6 +234,8 @@ public:
 			e.zone_in_z           = row[20] ? strtof(row[20], nullptr) : 0;
 			e.zone_in_heading     = row[21] ? strtof(row[21], nullptr) : 0;
 			e.has_zone_in         = row[22] ? static_cast<uint8_t>(strtoul(row[22], nullptr, 10)) : 0;
+			e.is_locked           = row[23] ? static_cast<int8_t>(atoi(row[23])) : 0;
+			e.add_replay          = row[24] ? static_cast<int8_t>(atoi(row[24])) : 1;

 			return e;
 		}
@@ -281,6 +291,8 @@ public:
 		v.push_back(columns[20] + " = " + std::to_string(e.zone_in_z));
 		v.push_back(columns[21] + " = " + std::to_string(e.zone_in_heading));
 		v.push_back(columns[22] + " = " + std::to_string(e.has_zone_in));
+		v.push_back(columns[23] + " = " + std::to_string(e.is_locked));
+		v.push_back(columns[24] + " = " + std::to_string(e.add_replay));

 		auto results = db.QueryDatabase(
 			fmt::format(
@@ -325,6 +337,8 @@ public:
 		v.push_back(std::to_string(e.zone_in_z));
 		v.push_back(std::to_string(e.zone_in_heading));
 		v.push_back(std::to_string(e.has_zone_in));
+		v.push_back(std::to_string(e.is_locked));
+		v.push_back(std::to_string(e.add_replay));

 		auto results = db.QueryDatabase(
 			fmt::format(
@@ -377,6 +391,8 @@ public:
 			v.push_back(std::to_string(e.zone_in_z));
 			v.push_back(std::to_string(e.zone_in_heading));
 			v.push_back(std::to_string(e.has_zone_in));
+			v.push_back(std::to_string(e.is_locked));
+			v.push_back(std::to_string(e.add_replay));

 			insert_chunks.push_back("(" + Strings::Implode(",", v) + ")");
 		}
@@ -433,6 +449,8 @@ public:
 			e.zone_in_z           = row[20] ? strtof(row[20], nullptr) : 0;
 			e.zone_in_heading     = row[21] ? strtof(row[21], nullptr) : 0;
 			e.has_zone_in         = row[22] ? static_cast<uint8_t>(strtoul(row[22], nullptr, 10)) : 0;
+			e.is_locked           = row[23] ? static_cast<int8_t>(atoi(row[23])) : 0;
+			e.add_replay          = row[24] ? static_cast<int8_t>(atoi(row[24])) : 1;

 			all_entries.push_back(e);
 		}
@@ -480,6 +498,8 @@ public:
 			e.zone_in_z           = row[20] ? strtof(row[20], nullptr) : 0;
 			e.zone_in_heading     = row[21] ? strtof(row[21], nullptr) : 0;
 			e.has_zone_in         = row[22] ? static_cast<uint8_t>(strtoul(row[22], nullptr, 10)) : 0;
+			e.is_locked           = row[23] ? static_cast<int8_t>(atoi(row[23])) : 0;
+			e.add_replay          = row[24] ? static_cast<int8_t>(atoi(row[24])) : 1;

 			all_entries.push_back(e);
 		}
@@ -577,6 +597,8 @@ public:
 		v.push_back(std::to_string(e.zone_in_z));
 		v.push_back(std::to_string(e.zone_in_heading));
 		v.push_back(std::to_string(e.has_zone_in));
+		v.push_back(std::to_string(e.is_locked));
+		v.push_back(std::to_string(e.add_replay));

 		auto results = db.QueryDatabase(
 			fmt::format(
@@ -622,6 +644,8 @@ public:
 			v.push_back(std::to_string(e.zone_in_z));
 			v.push_back(std::to_string(e.zone_in_heading));
 			v.push_back(std::to_string(e.has_zone_in));
+			v.push_back(std::to_string(e.is_locked));
+			v.push_back(std::to_string(e.add_replay));

 			insert_chunks.push_back("(" + Strings::Implode(",", v) + ")");
 		}
@@ -1,415 +0,0 @@
-/**
- * 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_EXPEDITIONS_REPOSITORY_H
-#define EQEMU_BASE_EXPEDITIONS_REPOSITORY_H
-
-#include "../../database.h"
-#include "../../strings.h"
-#include <ctime>
-
-class BaseExpeditionsRepository {
-public:
-	struct Expeditions {
-		uint32_t id;
-		uint32_t dynamic_zone_id;
-		uint8_t  add_replay_on_join;
-		uint8_t  is_locked;
-	};
-
-	static std::string PrimaryKey()
-	{
-		return std::string("id");
-	}
-
-	static std::vector<std::string> Columns()
-	{
-		return {
-			"id",
-			"dynamic_zone_id",
-			"add_replay_on_join",
-			"is_locked",
-		};
-	}
-
-	static std::vector<std::string> SelectColumns()
-	{
-		return {
-			"id",
-			"dynamic_zone_id",
-			"add_replay_on_join",
-			"is_locked",
-		};
-	}
-
-	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("expeditions");
-	}
-
-	static std::string BaseSelect()
-	{
-		return fmt::format(
-			"SELECT {} FROM {}",
-			SelectColumnsRaw(),
-			TableName()
-		);
-	}
-
-	static std::string BaseInsert()
-	{
-		return fmt::format(
-			"INSERT INTO {} ({}) ",
-			TableName(),
-			ColumnsRaw()
-		);
-	}
-
-	static Expeditions NewEntity()
-	{
-		Expeditions e{};
-
-		e.id                 = 0;
-		e.dynamic_zone_id    = 0;
-		e.add_replay_on_join = 1;
-		e.is_locked          = 0;
-
-		return e;
-	}
-
-	static Expeditions GetExpeditions(
-		const std::vector<Expeditions> &expeditionss,
-		int expeditions_id
-	)
-	{
-		for (auto &expeditions : expeditionss) {
-			if (expeditions.id == expeditions_id) {
-				return expeditions;
-			}
-		}
-
-		return NewEntity();
-	}
-
-	static Expeditions FindOne(
-		Database& db,
-		int expeditions_id
-	)
-	{
-		auto results = db.QueryDatabase(
-			fmt::format(
-				"{} WHERE {} = {} LIMIT 1",
-				BaseSelect(),
-				PrimaryKey(),
-				expeditions_id
-			)
-		);
-
-		auto row = results.begin();
-		if (results.RowCount() == 1) {
-			Expeditions e{};
-
-			e.id                 = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
-			e.dynamic_zone_id    = row[1] ? static_cast<uint32_t>(strtoul(row[1], nullptr, 10)) : 0;
-			e.add_replay_on_join = row[2] ? static_cast<uint8_t>(strtoul(row[2], nullptr, 10)) : 1;
-			e.is_locked          = row[3] ? static_cast<uint8_t>(strtoul(row[3], nullptr, 10)) : 0;
-
-			return e;
-		}
-
-		return NewEntity();
-	}
-
-	static int DeleteOne(
-		Database& db,
-		int expeditions_id
-	)
-	{
-		auto results = db.QueryDatabase(
-			fmt::format(
-				"DELETE FROM {} WHERE {} = {}",
-				TableName(),
-				PrimaryKey(),
-				expeditions_id
-			)
-		);
-
-		return (results.Success() ? results.RowsAffected() : 0);
-	}
-
-	static int UpdateOne(
-		Database& db,
-		const Expeditions &e
-	)
-	{
-		std::vector<std::string> v;
-
-		auto columns = Columns();
-
-		v.push_back(columns[1] + " = " + std::to_string(e.dynamic_zone_id));
-		v.push_back(columns[2] + " = " + std::to_string(e.add_replay_on_join));
-		v.push_back(columns[3] + " = " + std::to_string(e.is_locked));
-
-		auto results = db.QueryDatabase(
-			fmt::format(
-				"UPDATE {} SET {} WHERE {} = {}",
-				TableName(),
-				Strings::Implode(", ", v),
-				PrimaryKey(),
-				e.id
-			)
-		);
-
-		return (results.Success() ? results.RowsAffected() : 0);
-	}
-
-	static Expeditions InsertOne(
-		Database& db,
-		Expeditions e
-	)
-	{
-		std::vector<std::string> v;
-
-		v.push_back(std::to_string(e.id));
-		v.push_back(std::to_string(e.dynamic_zone_id));
-		v.push_back(std::to_string(e.add_replay_on_join));
-		v.push_back(std::to_string(e.is_locked));
-
-		auto results = db.QueryDatabase(
-			fmt::format(
-				"{} VALUES ({})",
-				BaseInsert(),
-				Strings::Implode(",", v)
-			)
-		);
-
-		if (results.Success()) {
-			e.id = results.LastInsertedID();
-			return e;
-		}
-
-		e = NewEntity();
-
-		return e;
-	}
-
-	static int InsertMany(
-		Database& db,
-		const std::vector<Expeditions> &entries
-	)
-	{
-		std::vector<std::string> insert_chunks;
-
-		for (auto &e: entries) {
-			std::vector<std::string> v;
-
-			v.push_back(std::to_string(e.id));
-			v.push_back(std::to_string(e.dynamic_zone_id));
-			v.push_back(std::to_string(e.add_replay_on_join));
-			v.push_back(std::to_string(e.is_locked));
-
-			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<Expeditions> All(Database& db)
-	{
-		std::vector<Expeditions> all_entries;
-
-		auto results = db.QueryDatabase(
-			fmt::format(
-				"{}",
-				BaseSelect()
-			)
-		);
-
-		all_entries.reserve(results.RowCount());
-
-		for (auto row = results.begin(); row != results.end(); ++row) {
-			Expeditions e{};
-
-			e.id                 = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
-			e.dynamic_zone_id    = row[1] ? static_cast<uint32_t>(strtoul(row[1], nullptr, 10)) : 0;
-			e.add_replay_on_join = row[2] ? static_cast<uint8_t>(strtoul(row[2], nullptr, 10)) : 1;
-			e.is_locked          = row[3] ? static_cast<uint8_t>(strtoul(row[3], nullptr, 10)) : 0;
-
-			all_entries.push_back(e);
-		}
-
-		return all_entries;
-	}
-
-	static std::vector<Expeditions> GetWhere(Database& db, const std::string &where_filter)
-	{
-		std::vector<Expeditions> 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) {
-			Expeditions e{};
-
-			e.id                 = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
-			e.dynamic_zone_id    = row[1] ? static_cast<uint32_t>(strtoul(row[1], nullptr, 10)) : 0;
-			e.add_replay_on_join = row[2] ? static_cast<uint8_t>(strtoul(row[2], nullptr, 10)) : 1;
-			e.is_locked          = row[3] ? static_cast<uint8_t>(strtoul(row[3], 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 Expeditions &e
-	)
-	{
-		std::vector<std::string> v;
-
-		v.push_back(std::to_string(e.id));
-		v.push_back(std::to_string(e.dynamic_zone_id));
-		v.push_back(std::to_string(e.add_replay_on_join));
-		v.push_back(std::to_string(e.is_locked));
-
-		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<Expeditions> &entries
-	)
-	{
-		std::vector<std::string> insert_chunks;
-
-		for (auto &e: entries) {
-			std::vector<std::string> v;
-
-			v.push_back(std::to_string(e.id));
-			v.push_back(std::to_string(e.dynamic_zone_id));
-			v.push_back(std::to_string(e.add_replay_on_join));
-			v.push_back(std::to_string(e.is_locked));
-
-			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_EXPEDITIONS_REPOSITORY_H
@@ -6,7 +6,7 @@
 * Any modifications to base repositories are to be made by the generator only
 *
 * @generator ./utils/scripts/generators/repository-generator.pl
- * @docs https://eqemu.gitbook.io/server/in-development/developer-area/repositories
+ * @docs https://docs.eqemu.io/developer/repositories
 */

 #ifndef EQEMU_BASE_GUILD_BANK_REPOSITORY_H
@@ -16,19 +16,24 @@
 #include "../../strings.h"
 #include <ctime>

-
 class BaseGuildBankRepository {
 public:
 	struct GuildBank {
 		uint32_t    id;
-		uint32_t    guildid;
+		uint32_t    guild_id;
 		uint8_t     area;
 		uint32_t    slot;
-		uint32_t    itemid;
-		uint32_t    qty;
+		uint32_t    item_id;
+		uint32_t    augment_one_id;
+		uint32_t    augment_two_id;
+		uint32_t    augment_three_id;
+		uint32_t    augment_four_id;
+		uint32_t    augment_five_id;
+		uint32_t    augment_six_id;
+		int32_t     quantity;
 		std::string donator;
 		uint8_t     permissions;
-		std::string whofor;
+		std::string who_for;
 	};

 	static std::string PrimaryKey()
@@ -40,14 +45,20 @@ public:
 	{
 		return {
 			"id",
-			"guildid",
+			"guild_id",
 			"area",
 			"slot",
-			"itemid",
-			"qty",
+			"item_id",
+			"augment_one_id",
+			"augment_two_id",
+			"augment_three_id",
+			"augment_four_id",
+			"augment_five_id",
+			"augment_six_id",
+			"quantity",
 			"donator",
 			"permissions",
-			"whofor",
+			"who_for",
 		};
 	}

@@ -55,14 +66,20 @@ public:
 	{
 		return {
 			"id",
-			"guildid",
+			"guild_id",
 			"area",
 			"slot",
-			"itemid",
-			"qty",
+			"item_id",
+			"augment_one_id",
+			"augment_two_id",
+			"augment_three_id",
+			"augment_four_id",
+			"augment_five_id",
+			"augment_six_id",
+			"quantity",
 			"donator",
 			"permissions",
-			"whofor",
+			"who_for",
 		};
 	}

@@ -103,15 +120,21 @@ public:
 	{
 		GuildBank e{};

-		e.id          = 0;
-		e.guildid     = 0;
-		e.area        = 0;
-		e.slot        = 0;
-		e.itemid      = 0;
-		e.qty         = 0;
-		e.donator     = "";
-		e.permissions = 0;
-		e.whofor      = "";
+		e.id               = 0;
+		e.guild_id         = 0;
+		e.area             = 0;
+		e.slot             = 0;
+		e.item_id          = 0;
+		e.augment_one_id   = 0;
+		e.augment_two_id   = 0;
+		e.augment_three_id = 0;
+		e.augment_four_id  = 0;
+		e.augment_five_id  = 0;
+		e.augment_six_id   = 0;
+		e.quantity         = 0;
+		e.donator          = "";
+		e.permissions      = 0;
+		e.who_for          = "";

 		return e;
 	}
@@ -148,15 +171,21 @@ public:
 		if (results.RowCount() == 1) {
 			GuildBank e{};

-			e.id          = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.guildid     = static_cast<uint32_t>(strtoul(row[1], nullptr, 10));
-			e.area        = static_cast<uint8_t>(strtoul(row[2], nullptr, 10));
-			e.slot        = static_cast<uint32_t>(strtoul(row[3], nullptr, 10));
-			e.itemid      = static_cast<uint32_t>(strtoul(row[4], nullptr, 10));
-			e.qty         = static_cast<uint32_t>(strtoul(row[5], nullptr, 10));
-			e.donator     = row[6] ? row[6] : "";
-			e.permissions = static_cast<uint8_t>(strtoul(row[7], nullptr, 10));
-			e.whofor      = row[8] ? row[8] : "";
+			e.id               = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.guild_id         = row[1] ? static_cast<uint32_t>(strtoul(row[1], nullptr, 10)) : 0;
+			e.area             = row[2] ? static_cast<uint8_t>(strtoul(row[2], nullptr, 10)) : 0;
+			e.slot             = row[3] ? static_cast<uint32_t>(strtoul(row[3], nullptr, 10)) : 0;
+			e.item_id          = row[4] ? static_cast<uint32_t>(strtoul(row[4], nullptr, 10)) : 0;
+			e.augment_one_id   = row[5] ? static_cast<uint32_t>(strtoul(row[5], nullptr, 10)) : 0;
+			e.augment_two_id   = row[6] ? static_cast<uint32_t>(strtoul(row[6], nullptr, 10)) : 0;
+			e.augment_three_id = row[7] ? static_cast<uint32_t>(strtoul(row[7], nullptr, 10)) : 0;
+			e.augment_four_id  = row[8] ? static_cast<uint32_t>(strtoul(row[8], nullptr, 10)) : 0;
+			e.augment_five_id  = row[9] ? static_cast<uint32_t>(strtoul(row[9], nullptr, 10)) : 0;
+			e.augment_six_id   = row[10] ? static_cast<uint32_t>(strtoul(row[10], nullptr, 10)) : 0;
+			e.quantity         = row[11] ? static_cast<int32_t>(atoi(row[11])) : 0;
+			e.donator          = row[12] ? row[12] : "";
+			e.permissions      = row[13] ? static_cast<uint8_t>(strtoul(row[13], nullptr, 10)) : 0;
+			e.who_for          = row[14] ? row[14] : "";

 			return e;
 		}
@@ -190,14 +219,20 @@ public:

 		auto columns = Columns();

-		v.push_back(columns[1] + " = " + std::to_string(e.guildid));
+		v.push_back(columns[1] + " = " + std::to_string(e.guild_id));
 		v.push_back(columns[2] + " = " + std::to_string(e.area));
 		v.push_back(columns[3] + " = " + std::to_string(e.slot));
-		v.push_back(columns[4] + " = " + std::to_string(e.itemid));
-		v.push_back(columns[5] + " = " + std::to_string(e.qty));
-		v.push_back(columns[6] + " = '" + Strings::Escape(e.donator) + "'");
-		v.push_back(columns[7] + " = " + std::to_string(e.permissions));
-		v.push_back(columns[8] + " = '" + Strings::Escape(e.whofor) + "'");
+		v.push_back(columns[4] + " = " + std::to_string(e.item_id));
+		v.push_back(columns[5] + " = " + std::to_string(e.augment_one_id));
+		v.push_back(columns[6] + " = " + std::to_string(e.augment_two_id));
+		v.push_back(columns[7] + " = " + std::to_string(e.augment_three_id));
+		v.push_back(columns[8] + " = " + std::to_string(e.augment_four_id));
+		v.push_back(columns[9] + " = " + std::to_string(e.augment_five_id));
+		v.push_back(columns[10] + " = " + std::to_string(e.augment_six_id));
+		v.push_back(columns[11] + " = " + std::to_string(e.quantity));
+		v.push_back(columns[12] + " = '" + Strings::Escape(e.donator) + "'");
+		v.push_back(columns[13] + " = " + std::to_string(e.permissions));
+		v.push_back(columns[14] + " = '" + Strings::Escape(e.who_for) + "'");

 		auto results = db.QueryDatabase(
 			fmt::format(
@@ -220,14 +255,20 @@ public:
 		std::vector<std::string> v;

 		v.push_back(std::to_string(e.id));
-		v.push_back(std::to_string(e.guildid));
+		v.push_back(std::to_string(e.guild_id));
 		v.push_back(std::to_string(e.area));
 		v.push_back(std::to_string(e.slot));
-		v.push_back(std::to_string(e.itemid));
-		v.push_back(std::to_string(e.qty));
+		v.push_back(std::to_string(e.item_id));
+		v.push_back(std::to_string(e.augment_one_id));
+		v.push_back(std::to_string(e.augment_two_id));
+		v.push_back(std::to_string(e.augment_three_id));
+		v.push_back(std::to_string(e.augment_four_id));
+		v.push_back(std::to_string(e.augment_five_id));
+		v.push_back(std::to_string(e.augment_six_id));
+		v.push_back(std::to_string(e.quantity));
 		v.push_back("'" + Strings::Escape(e.donator) + "'");
 		v.push_back(std::to_string(e.permissions));
-		v.push_back("'" + Strings::Escape(e.whofor) + "'");
+		v.push_back("'" + Strings::Escape(e.who_for) + "'");

 		auto results = db.QueryDatabase(
 			fmt::format(
@@ -258,14 +299,20 @@ public:
 			std::vector<std::string> v;

 			v.push_back(std::to_string(e.id));
-			v.push_back(std::to_string(e.guildid));
+			v.push_back(std::to_string(e.guild_id));
 			v.push_back(std::to_string(e.area));
 			v.push_back(std::to_string(e.slot));
-			v.push_back(std::to_string(e.itemid));
-			v.push_back(std::to_string(e.qty));
+			v.push_back(std::to_string(e.item_id));
+			v.push_back(std::to_string(e.augment_one_id));
+			v.push_back(std::to_string(e.augment_two_id));
+			v.push_back(std::to_string(e.augment_three_id));
+			v.push_back(std::to_string(e.augment_four_id));
+			v.push_back(std::to_string(e.augment_five_id));
+			v.push_back(std::to_string(e.augment_six_id));
+			v.push_back(std::to_string(e.quantity));
 			v.push_back("'" + Strings::Escape(e.donator) + "'");
 			v.push_back(std::to_string(e.permissions));
-			v.push_back("'" + Strings::Escape(e.whofor) + "'");
+			v.push_back("'" + Strings::Escape(e.who_for) + "'");

 			insert_chunks.push_back("(" + Strings::Implode(",", v) + ")");
 		}
@@ -299,15 +346,21 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			GuildBank e{};

-			e.id          = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.guildid     = static_cast<uint32_t>(strtoul(row[1], nullptr, 10));
-			e.area        = static_cast<uint8_t>(strtoul(row[2], nullptr, 10));
-			e.slot        = static_cast<uint32_t>(strtoul(row[3], nullptr, 10));
-			e.itemid      = static_cast<uint32_t>(strtoul(row[4], nullptr, 10));
-			e.qty         = static_cast<uint32_t>(strtoul(row[5], nullptr, 10));
-			e.donator     = row[6] ? row[6] : "";
-			e.permissions = static_cast<uint8_t>(strtoul(row[7], nullptr, 10));
-			e.whofor      = row[8] ? row[8] : "";
+			e.id               = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.guild_id         = row[1] ? static_cast<uint32_t>(strtoul(row[1], nullptr, 10)) : 0;
+			e.area             = row[2] ? static_cast<uint8_t>(strtoul(row[2], nullptr, 10)) : 0;
+			e.slot             = row[3] ? static_cast<uint32_t>(strtoul(row[3], nullptr, 10)) : 0;
+			e.item_id          = row[4] ? static_cast<uint32_t>(strtoul(row[4], nullptr, 10)) : 0;
+			e.augment_one_id   = row[5] ? static_cast<uint32_t>(strtoul(row[5], nullptr, 10)) : 0;
+			e.augment_two_id   = row[6] ? static_cast<uint32_t>(strtoul(row[6], nullptr, 10)) : 0;
+			e.augment_three_id = row[7] ? static_cast<uint32_t>(strtoul(row[7], nullptr, 10)) : 0;
+			e.augment_four_id  = row[8] ? static_cast<uint32_t>(strtoul(row[8], nullptr, 10)) : 0;
+			e.augment_five_id  = row[9] ? static_cast<uint32_t>(strtoul(row[9], nullptr, 10)) : 0;
+			e.augment_six_id   = row[10] ? static_cast<uint32_t>(strtoul(row[10], nullptr, 10)) : 0;
+			e.quantity         = row[11] ? static_cast<int32_t>(atoi(row[11])) : 0;
+			e.donator          = row[12] ? row[12] : "";
+			e.permissions      = row[13] ? static_cast<uint8_t>(strtoul(row[13], nullptr, 10)) : 0;
+			e.who_for          = row[14] ? row[14] : "";

 			all_entries.push_back(e);
 		}
@@ -332,15 +385,21 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			GuildBank e{};

-			e.id          = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.guildid     = static_cast<uint32_t>(strtoul(row[1], nullptr, 10));
-			e.area        = static_cast<uint8_t>(strtoul(row[2], nullptr, 10));
-			e.slot        = static_cast<uint32_t>(strtoul(row[3], nullptr, 10));
-			e.itemid      = static_cast<uint32_t>(strtoul(row[4], nullptr, 10));
-			e.qty         = static_cast<uint32_t>(strtoul(row[5], nullptr, 10));
-			e.donator     = row[6] ? row[6] : "";
-			e.permissions = static_cast<uint8_t>(strtoul(row[7], nullptr, 10));
-			e.whofor      = row[8] ? row[8] : "";
+			e.id               = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.guild_id         = row[1] ? static_cast<uint32_t>(strtoul(row[1], nullptr, 10)) : 0;
+			e.area             = row[2] ? static_cast<uint8_t>(strtoul(row[2], nullptr, 10)) : 0;
+			e.slot             = row[3] ? static_cast<uint32_t>(strtoul(row[3], nullptr, 10)) : 0;
+			e.item_id          = row[4] ? static_cast<uint32_t>(strtoul(row[4], nullptr, 10)) : 0;
+			e.augment_one_id   = row[5] ? static_cast<uint32_t>(strtoul(row[5], nullptr, 10)) : 0;
+			e.augment_two_id   = row[6] ? static_cast<uint32_t>(strtoul(row[6], nullptr, 10)) : 0;
+			e.augment_three_id = row[7] ? static_cast<uint32_t>(strtoul(row[7], nullptr, 10)) : 0;
+			e.augment_four_id  = row[8] ? static_cast<uint32_t>(strtoul(row[8], nullptr, 10)) : 0;
+			e.augment_five_id  = row[9] ? static_cast<uint32_t>(strtoul(row[9], nullptr, 10)) : 0;
+			e.augment_six_id   = row[10] ? static_cast<uint32_t>(strtoul(row[10], nullptr, 10)) : 0;
+			e.quantity         = row[11] ? static_cast<int32_t>(atoi(row[11])) : 0;
+			e.donator          = row[12] ? row[12] : "";
+			e.permissions      = row[13] ? static_cast<uint8_t>(strtoul(row[13], nullptr, 10)) : 0;
+			e.who_for          = row[14] ? row[14] : "";

 			all_entries.push_back(e);
 		}
@@ -399,6 +458,90 @@ public:
 		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 GuildBank &e
+	)
+	{
+		std::vector<std::string> v;
+
+		v.push_back(std::to_string(e.id));
+		v.push_back(std::to_string(e.guild_id));
+		v.push_back(std::to_string(e.area));
+		v.push_back(std::to_string(e.slot));
+		v.push_back(std::to_string(e.item_id));
+		v.push_back(std::to_string(e.augment_one_id));
+		v.push_back(std::to_string(e.augment_two_id));
+		v.push_back(std::to_string(e.augment_three_id));
+		v.push_back(std::to_string(e.augment_four_id));
+		v.push_back(std::to_string(e.augment_five_id));
+		v.push_back(std::to_string(e.augment_six_id));
+		v.push_back(std::to_string(e.quantity));
+		v.push_back("'" + Strings::Escape(e.donator) + "'");
+		v.push_back(std::to_string(e.permissions));
+		v.push_back("'" + Strings::Escape(e.who_for) + "'");
+
+		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<GuildBank> &entries
+	)
+	{
+		std::vector<std::string> insert_chunks;
+
+		for (auto &e: entries) {
+			std::vector<std::string> v;
+
+			v.push_back(std::to_string(e.id));
+			v.push_back(std::to_string(e.guild_id));
+			v.push_back(std::to_string(e.area));
+			v.push_back(std::to_string(e.slot));
+			v.push_back(std::to_string(e.item_id));
+			v.push_back(std::to_string(e.augment_one_id));
+			v.push_back(std::to_string(e.augment_two_id));
+			v.push_back(std::to_string(e.augment_three_id));
+			v.push_back(std::to_string(e.augment_four_id));
+			v.push_back(std::to_string(e.augment_five_id));
+			v.push_back(std::to_string(e.augment_six_id));
+			v.push_back(std::to_string(e.quantity));
+			v.push_back("'" + Strings::Escape(e.donator) + "'");
+			v.push_back(std::to_string(e.permissions));
+			v.push_back("'" + Strings::Escape(e.who_for) + "'");
+
+			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_GUILD_BANK_REPOSITORY_H
@@ -19,13 +19,13 @@
 class BaseItemsEvolvingDetailsRepository {
 public:
 	struct ItemsEvolvingDetails {
-		uint32_t id;
-		uint32_t item_evo_id;
-		uint32_t item_evolve_level;
-		uint32_t item_id;
-		uint32_t type;
-		uint32_t sub_type;
-		int64_t  required_amount;
+		uint32_t    id;
+		uint32_t    item_evo_id;
+		uint32_t    item_evolve_level;
+		uint32_t    item_id;
+		uint32_t    type;
+		std::string sub_type;
+		int64_t     required_amount;
 	};

 	static std::string PrimaryKey()
@@ -101,7 +101,7 @@ public:
 		e.item_evolve_level = 0;
 		e.item_id           = 0;
 		e.type              = 0;
-		e.sub_type          = 0;
+		e.sub_type          = "0";
 		e.required_amount   = 0;

 		return e;
@@ -144,7 +144,7 @@ public:
 			e.item_evolve_level = row[2] ? static_cast<uint32_t>(strtoul(row[2], nullptr, 10)) : 0;
 			e.item_id           = row[3] ? static_cast<uint32_t>(strtoul(row[3], nullptr, 10)) : 0;
 			e.type              = row[4] ? static_cast<uint32_t>(strtoul(row[4], nullptr, 10)) : 0;
-			e.sub_type          = row[5] ? static_cast<uint32_t>(strtoul(row[5], nullptr, 10)) : 0;
+			e.sub_type          = row[5] ? row[5] : "0";
 			e.required_amount   = row[6] ? strtoll(row[6], nullptr, 10) : 0;

 			return e;
@@ -183,7 +183,7 @@ public:
 		v.push_back(columns[2] + " = " + std::to_string(e.item_evolve_level));
 		v.push_back(columns[3] + " = " + std::to_string(e.item_id));
 		v.push_back(columns[4] + " = " + std::to_string(e.type));
-		v.push_back(columns[5] + " = " + std::to_string(e.sub_type));
+		v.push_back(columns[5] + " = '" + Strings::Escape(e.sub_type) + "'");
 		v.push_back(columns[6] + " = " + std::to_string(e.required_amount));

 		auto results = db.QueryDatabase(
@@ -211,7 +211,7 @@ public:
 		v.push_back(std::to_string(e.item_evolve_level));
 		v.push_back(std::to_string(e.item_id));
 		v.push_back(std::to_string(e.type));
-		v.push_back(std::to_string(e.sub_type));
+		v.push_back("'" + Strings::Escape(e.sub_type) + "'");
 		v.push_back(std::to_string(e.required_amount));

 		auto results = db.QueryDatabase(
@@ -247,7 +247,7 @@ public:
 			v.push_back(std::to_string(e.item_evolve_level));
 			v.push_back(std::to_string(e.item_id));
 			v.push_back(std::to_string(e.type));
-			v.push_back(std::to_string(e.sub_type));
+			v.push_back("'" + Strings::Escape(e.sub_type) + "'");
 			v.push_back(std::to_string(e.required_amount));

 			insert_chunks.push_back("(" + Strings::Implode(",", v) + ")");
@@ -287,7 +287,7 @@ public:
 			e.item_evolve_level = row[2] ? static_cast<uint32_t>(strtoul(row[2], nullptr, 10)) : 0;
 			e.item_id           = row[3] ? static_cast<uint32_t>(strtoul(row[3], nullptr, 10)) : 0;
 			e.type              = row[4] ? static_cast<uint32_t>(strtoul(row[4], nullptr, 10)) : 0;
-			e.sub_type          = row[5] ? static_cast<uint32_t>(strtoul(row[5], nullptr, 10)) : 0;
+			e.sub_type          = row[5] ? row[5] : "0";
 			e.required_amount   = row[6] ? strtoll(row[6], nullptr, 10) : 0;

 			all_entries.push_back(e);
@@ -318,7 +318,7 @@ public:
 			e.item_evolve_level = row[2] ? static_cast<uint32_t>(strtoul(row[2], nullptr, 10)) : 0;
 			e.item_id           = row[3] ? static_cast<uint32_t>(strtoul(row[3], nullptr, 10)) : 0;
 			e.type              = row[4] ? static_cast<uint32_t>(strtoul(row[4], nullptr, 10)) : 0;
-			e.sub_type          = row[5] ? static_cast<uint32_t>(strtoul(row[5], nullptr, 10)) : 0;
+			e.sub_type          = row[5] ? row[5] : "0";
 			e.required_amount   = row[6] ? strtoll(row[6], nullptr, 10) : 0;

 			all_entries.push_back(e);
@@ -399,7 +399,7 @@ public:
 		v.push_back(std::to_string(e.item_evolve_level));
 		v.push_back(std::to_string(e.item_id));
 		v.push_back(std::to_string(e.type));
-		v.push_back(std::to_string(e.sub_type));
+		v.push_back("'" + Strings::Escape(e.sub_type) + "'");
 		v.push_back(std::to_string(e.required_amount));

 		auto results = db.QueryDatabase(
@@ -428,7 +428,7 @@ public:
 			v.push_back(std::to_string(e.item_evolve_level));
 			v.push_back(std::to_string(e.item_id));
 			v.push_back(std::to_string(e.type));
-			v.push_back(std::to_string(e.sub_type));
+			v.push_back("'" + Strings::Escape(e.sub_type) + "'");
 			v.push_back(std::to_string(e.required_amount));

 			insert_chunks.push_back("(" + Strings::Implode(",", v) + ")");
@@ -0,0 +1,703 @@
+/**
+ * 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_ZONE_STATE_SPAWNS_REPOSITORY_H
+#define EQEMU_BASE_ZONE_STATE_SPAWNS_REPOSITORY_H
+
+#include "../../database.h"
+#include "../../strings.h"
+#include <ctime>
+
+class BaseZoneStateSpawnsRepository {
+public:
+	struct ZoneStateSpawns {
+		int64_t     id;
+		uint32_t    zone_id;
+		uint32_t    instance_id;
+		int8_t      is_corpse;
+		int32_t     decay_in_seconds;
+		uint32_t    npc_id;
+		uint32_t    spawn2_id;
+		uint32_t    spawngroup_id;
+		float       x;
+		float       y;
+		float       z;
+		float       heading;
+		uint32_t    respawn_time;
+		uint32_t    variance;
+		uint32_t    grid;
+		int32_t     current_waypoint;
+		int16_t     path_when_zone_idle;
+		uint16_t    condition_id;
+		int16_t     condition_min_value;
+		int16_t     enabled;
+		uint16_t    anim;
+		std::string loot_data;
+		std::string entity_variables;
+		std::string buffs;
+		int64_t     hp;
+		int64_t     mana;
+		int64_t     endurance;
+		time_t      created_at;
+	};
+
+	static std::string PrimaryKey()
+	{
+		return std::string("id");
+	}
+
+	static std::vector<std::string> Columns()
+	{
+		return {
+			"id",
+			"zone_id",
+			"instance_id",
+			"is_corpse",
+			"decay_in_seconds",
+			"npc_id",
+			"spawn2_id",
+			"spawngroup_id",
+			"x",
+			"y",
+			"z",
+			"heading",
+			"respawn_time",
+			"variance",
+			"grid",
+			"current_waypoint",
+			"path_when_zone_idle",
+			"condition_id",
+			"condition_min_value",
+			"enabled",
+			"anim",
+			"loot_data",
+			"entity_variables",
+			"buffs",
+			"hp",
+			"mana",
+			"endurance",
+			"created_at",
+		};
+	}
+
+	static std::vector<std::string> SelectColumns()
+	{
+		return {
+			"id",
+			"zone_id",
+			"instance_id",
+			"is_corpse",
+			"decay_in_seconds",
+			"npc_id",
+			"spawn2_id",
+			"spawngroup_id",
+			"x",
+			"y",
+			"z",
+			"heading",
+			"respawn_time",
+			"variance",
+			"grid",
+			"current_waypoint",
+			"path_when_zone_idle",
+			"condition_id",
+			"condition_min_value",
+			"enabled",
+			"anim",
+			"loot_data",
+			"entity_variables",
+			"buffs",
+			"hp",
+			"mana",
+			"endurance",
+			"UNIX_TIMESTAMP(created_at)",
+		};
+	}
+
+	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("zone_state_spawns");
+	}
+
+	static std::string BaseSelect()
+	{
+		return fmt::format(
+			"SELECT {} FROM {}",
+			SelectColumnsRaw(),
+			TableName()
+		);
+	}
+
+	static std::string BaseInsert()
+	{
+		return fmt::format(
+			"INSERT INTO {} ({}) ",
+			TableName(),
+			ColumnsRaw()
+		);
+	}
+
+	static ZoneStateSpawns NewEntity()
+	{
+		ZoneStateSpawns e{};
+
+		e.id                  = 0;
+		e.zone_id             = 0;
+		e.instance_id         = 0;
+		e.is_corpse           = 0;
+		e.decay_in_seconds    = 0;
+		e.npc_id              = 0;
+		e.spawn2_id           = 0;
+		e.spawngroup_id       = 0;
+		e.x                   = 0;
+		e.y                   = 0;
+		e.z                   = 0;
+		e.heading             = 0;
+		e.respawn_time        = 0;
+		e.variance            = 0;
+		e.grid                = 0;
+		e.current_waypoint    = 0;
+		e.path_when_zone_idle = 0;
+		e.condition_id        = 0;
+		e.condition_min_value = 0;
+		e.enabled             = 1;
+		e.anim                = 0;
+		e.loot_data           = "";
+		e.entity_variables    = "";
+		e.buffs               = "";
+		e.hp                  = 0;
+		e.mana                = 0;
+		e.endurance           = 0;
+		e.created_at          = 0;
+
+		return e;
+	}
+
+	static ZoneStateSpawns GetZoneStateSpawns(
+		const std::vector<ZoneStateSpawns> &zone_state_spawnss,
+		int zone_state_spawns_id
+	)
+	{
+		for (auto &zone_state_spawns : zone_state_spawnss) {
+			if (zone_state_spawns.id == zone_state_spawns_id) {
+				return zone_state_spawns;
+			}
+		}
+
+		return NewEntity();
+	}
+
+	static ZoneStateSpawns FindOne(
+		Database& db,
+		int zone_state_spawns_id
+	)
+	{
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"{} WHERE {} = {} LIMIT 1",
+				BaseSelect(),
+				PrimaryKey(),
+				zone_state_spawns_id
+			)
+		);
+
+		auto row = results.begin();
+		if (results.RowCount() == 1) {
+			ZoneStateSpawns e{};
+
+			e.id                  = row[0] ? strtoll(row[0], nullptr, 10) : 0;
+			e.zone_id             = row[1] ? static_cast<uint32_t>(strtoul(row[1], nullptr, 10)) : 0;
+			e.instance_id         = row[2] ? static_cast<uint32_t>(strtoul(row[2], nullptr, 10)) : 0;
+			e.is_corpse           = row[3] ? static_cast<int8_t>(atoi(row[3])) : 0;
+			e.decay_in_seconds    = row[4] ? static_cast<int32_t>(atoi(row[4])) : 0;
+			e.npc_id              = row[5] ? static_cast<uint32_t>(strtoul(row[5], nullptr, 10)) : 0;
+			e.spawn2_id           = row[6] ? static_cast<uint32_t>(strtoul(row[6], nullptr, 10)) : 0;
+			e.spawngroup_id       = row[7] ? static_cast<uint32_t>(strtoul(row[7], nullptr, 10)) : 0;
+			e.x                   = row[8] ? strtof(row[8], nullptr) : 0;
+			e.y                   = row[9] ? strtof(row[9], nullptr) : 0;
+			e.z                   = row[10] ? strtof(row[10], nullptr) : 0;
+			e.heading             = row[11] ? strtof(row[11], nullptr) : 0;
+			e.respawn_time        = row[12] ? static_cast<uint32_t>(strtoul(row[12], nullptr, 10)) : 0;
+			e.variance            = row[13] ? static_cast<uint32_t>(strtoul(row[13], nullptr, 10)) : 0;
+			e.grid                = row[14] ? static_cast<uint32_t>(strtoul(row[14], nullptr, 10)) : 0;
+			e.current_waypoint    = row[15] ? static_cast<int32_t>(atoi(row[15])) : 0;
+			e.path_when_zone_idle = row[16] ? static_cast<int16_t>(atoi(row[16])) : 0;
+			e.condition_id        = row[17] ? static_cast<uint16_t>(strtoul(row[17], nullptr, 10)) : 0;
+			e.condition_min_value = row[18] ? static_cast<int16_t>(atoi(row[18])) : 0;
+			e.enabled             = row[19] ? static_cast<int16_t>(atoi(row[19])) : 1;
+			e.anim                = row[20] ? static_cast<uint16_t>(strtoul(row[20], nullptr, 10)) : 0;
+			e.loot_data           = row[21] ? row[21] : "";
+			e.entity_variables    = row[22] ? row[22] : "";
+			e.buffs               = row[23] ? row[23] : "";
+			e.hp                  = row[24] ? strtoll(row[24], nullptr, 10) : 0;
+			e.mana                = row[25] ? strtoll(row[25], nullptr, 10) : 0;
+			e.endurance           = row[26] ? strtoll(row[26], nullptr, 10) : 0;
+			e.created_at          = strtoll(row[27] ? row[27] : "-1", nullptr, 10);
+
+			return e;
+		}
+
+		return NewEntity();
+	}
+
+	static int DeleteOne(
+		Database& db,
+		int zone_state_spawns_id
+	)
+	{
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"DELETE FROM {} WHERE {} = {}",
+				TableName(),
+				PrimaryKey(),
+				zone_state_spawns_id
+			)
+		);
+
+		return (results.Success() ? results.RowsAffected() : 0);
+	}
+
+	static int UpdateOne(
+		Database& db,
+		const ZoneStateSpawns &e
+	)
+	{
+		std::vector<std::string> v;
+
+		auto columns = Columns();
+
+		v.push_back(columns[1] + " = " + std::to_string(e.zone_id));
+		v.push_back(columns[2] + " = " + std::to_string(e.instance_id));
+		v.push_back(columns[3] + " = " + std::to_string(e.is_corpse));
+		v.push_back(columns[4] + " = " + std::to_string(e.decay_in_seconds));
+		v.push_back(columns[5] + " = " + std::to_string(e.npc_id));
+		v.push_back(columns[6] + " = " + std::to_string(e.spawn2_id));
+		v.push_back(columns[7] + " = " + std::to_string(e.spawngroup_id));
+		v.push_back(columns[8] + " = " + std::to_string(e.x));
+		v.push_back(columns[9] + " = " + std::to_string(e.y));
+		v.push_back(columns[10] + " = " + std::to_string(e.z));
+		v.push_back(columns[11] + " = " + std::to_string(e.heading));
+		v.push_back(columns[12] + " = " + std::to_string(e.respawn_time));
+		v.push_back(columns[13] + " = " + std::to_string(e.variance));
+		v.push_back(columns[14] + " = " + std::to_string(e.grid));
+		v.push_back(columns[15] + " = " + std::to_string(e.current_waypoint));
+		v.push_back(columns[16] + " = " + std::to_string(e.path_when_zone_idle));
+		v.push_back(columns[17] + " = " + std::to_string(e.condition_id));
+		v.push_back(columns[18] + " = " + std::to_string(e.condition_min_value));
+		v.push_back(columns[19] + " = " + std::to_string(e.enabled));
+		v.push_back(columns[20] + " = " + std::to_string(e.anim));
+		v.push_back(columns[21] + " = '" + Strings::Escape(e.loot_data) + "'");
+		v.push_back(columns[22] + " = '" + Strings::Escape(e.entity_variables) + "'");
+		v.push_back(columns[23] + " = '" + Strings::Escape(e.buffs) + "'");
+		v.push_back(columns[24] + " = " + std::to_string(e.hp));
+		v.push_back(columns[25] + " = " + std::to_string(e.mana));
+		v.push_back(columns[26] + " = " + std::to_string(e.endurance));
+		v.push_back(columns[27] + " = FROM_UNIXTIME(" + (e.created_at > 0 ? std::to_string(e.created_at) : "null") + ")");
+
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"UPDATE {} SET {} WHERE {} = {}",
+				TableName(),
+				Strings::Implode(", ", v),
+				PrimaryKey(),
+				e.id
+			)
+		);
+
+		return (results.Success() ? results.RowsAffected() : 0);
+	}
+
+	static ZoneStateSpawns InsertOne(
+		Database& db,
+		ZoneStateSpawns e
+	)
+	{
+		std::vector<std::string> v;
+
+		v.push_back(std::to_string(e.id));
+		v.push_back(std::to_string(e.zone_id));
+		v.push_back(std::to_string(e.instance_id));
+		v.push_back(std::to_string(e.is_corpse));
+		v.push_back(std::to_string(e.decay_in_seconds));
+		v.push_back(std::to_string(e.npc_id));
+		v.push_back(std::to_string(e.spawn2_id));
+		v.push_back(std::to_string(e.spawngroup_id));
+		v.push_back(std::to_string(e.x));
+		v.push_back(std::to_string(e.y));
+		v.push_back(std::to_string(e.z));
+		v.push_back(std::to_string(e.heading));
+		v.push_back(std::to_string(e.respawn_time));
+		v.push_back(std::to_string(e.variance));
+		v.push_back(std::to_string(e.grid));
+		v.push_back(std::to_string(e.current_waypoint));
+		v.push_back(std::to_string(e.path_when_zone_idle));
+		v.push_back(std::to_string(e.condition_id));
+		v.push_back(std::to_string(e.condition_min_value));
+		v.push_back(std::to_string(e.enabled));
+		v.push_back(std::to_string(e.anim));
+		v.push_back("'" + Strings::Escape(e.loot_data) + "'");
+		v.push_back("'" + Strings::Escape(e.entity_variables) + "'");
+		v.push_back("'" + Strings::Escape(e.buffs) + "'");
+		v.push_back(std::to_string(e.hp));
+		v.push_back(std::to_string(e.mana));
+		v.push_back(std::to_string(e.endurance));
+		v.push_back("FROM_UNIXTIME(" + (e.created_at > 0 ? std::to_string(e.created_at) : "null") + ")");
+
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"{} VALUES ({})",
+				BaseInsert(),
+				Strings::Implode(",", v)
+			)
+		);
+
+		if (results.Success()) {
+			e.id = results.LastInsertedID();
+			return e;
+		}
+
+		e = NewEntity();
+
+		return e;
+	}
+
+	static int InsertMany(
+		Database& db,
+		const std::vector<ZoneStateSpawns> &entries
+	)
+	{
+		std::vector<std::string> insert_chunks;
+
+		for (auto &e: entries) {
+			std::vector<std::string> v;
+
+			v.push_back(std::to_string(e.id));
+			v.push_back(std::to_string(e.zone_id));
+			v.push_back(std::to_string(e.instance_id));
+			v.push_back(std::to_string(e.is_corpse));
+			v.push_back(std::to_string(e.decay_in_seconds));
+			v.push_back(std::to_string(e.npc_id));
+			v.push_back(std::to_string(e.spawn2_id));
+			v.push_back(std::to_string(e.spawngroup_id));
+			v.push_back(std::to_string(e.x));
+			v.push_back(std::to_string(e.y));
+			v.push_back(std::to_string(e.z));
+			v.push_back(std::to_string(e.heading));
+			v.push_back(std::to_string(e.respawn_time));
+			v.push_back(std::to_string(e.variance));
+			v.push_back(std::to_string(e.grid));
+			v.push_back(std::to_string(e.current_waypoint));
+			v.push_back(std::to_string(e.path_when_zone_idle));
+			v.push_back(std::to_string(e.condition_id));
+			v.push_back(std::to_string(e.condition_min_value));
+			v.push_back(std::to_string(e.enabled));
+			v.push_back(std::to_string(e.anim));
+			v.push_back("'" + Strings::Escape(e.loot_data) + "'");
+			v.push_back("'" + Strings::Escape(e.entity_variables) + "'");
+			v.push_back("'" + Strings::Escape(e.buffs) + "'");
+			v.push_back(std::to_string(e.hp));
+			v.push_back(std::to_string(e.mana));
+			v.push_back(std::to_string(e.endurance));
+			v.push_back("FROM_UNIXTIME(" + (e.created_at > 0 ? std::to_string(e.created_at) : "null") + ")");
+
+			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<ZoneStateSpawns> All(Database& db)
+	{
+		std::vector<ZoneStateSpawns> all_entries;
+
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"{}",
+				BaseSelect()
+			)
+		);
+
+		all_entries.reserve(results.RowCount());
+
+		for (auto row = results.begin(); row != results.end(); ++row) {
+			ZoneStateSpawns e{};
+
+			e.id                  = row[0] ? strtoll(row[0], nullptr, 10) : 0;
+			e.zone_id             = row[1] ? static_cast<uint32_t>(strtoul(row[1], nullptr, 10)) : 0;
+			e.instance_id         = row[2] ? static_cast<uint32_t>(strtoul(row[2], nullptr, 10)) : 0;
+			e.is_corpse           = row[3] ? static_cast<int8_t>(atoi(row[3])) : 0;
+			e.decay_in_seconds    = row[4] ? static_cast<int32_t>(atoi(row[4])) : 0;
+			e.npc_id              = row[5] ? static_cast<uint32_t>(strtoul(row[5], nullptr, 10)) : 0;
+			e.spawn2_id           = row[6] ? static_cast<uint32_t>(strtoul(row[6], nullptr, 10)) : 0;
+			e.spawngroup_id       = row[7] ? static_cast<uint32_t>(strtoul(row[7], nullptr, 10)) : 0;
+			e.x                   = row[8] ? strtof(row[8], nullptr) : 0;
+			e.y                   = row[9] ? strtof(row[9], nullptr) : 0;
+			e.z                   = row[10] ? strtof(row[10], nullptr) : 0;
+			e.heading             = row[11] ? strtof(row[11], nullptr) : 0;
+			e.respawn_time        = row[12] ? static_cast<uint32_t>(strtoul(row[12], nullptr, 10)) : 0;
+			e.variance            = row[13] ? static_cast<uint32_t>(strtoul(row[13], nullptr, 10)) : 0;
+			e.grid                = row[14] ? static_cast<uint32_t>(strtoul(row[14], nullptr, 10)) : 0;
+			e.current_waypoint    = row[15] ? static_cast<int32_t>(atoi(row[15])) : 0;
+			e.path_when_zone_idle = row[16] ? static_cast<int16_t>(atoi(row[16])) : 0;
+			e.condition_id        = row[17] ? static_cast<uint16_t>(strtoul(row[17], nullptr, 10)) : 0;
+			e.condition_min_value = row[18] ? static_cast<int16_t>(atoi(row[18])) : 0;
+			e.enabled             = row[19] ? static_cast<int16_t>(atoi(row[19])) : 1;
+			e.anim                = row[20] ? static_cast<uint16_t>(strtoul(row[20], nullptr, 10)) : 0;
+			e.loot_data           = row[21] ? row[21] : "";
+			e.entity_variables    = row[22] ? row[22] : "";
+			e.buffs               = row[23] ? row[23] : "";
+			e.hp                  = row[24] ? strtoll(row[24], nullptr, 10) : 0;
+			e.mana                = row[25] ? strtoll(row[25], nullptr, 10) : 0;
+			e.endurance           = row[26] ? strtoll(row[26], nullptr, 10) : 0;
+			e.created_at          = strtoll(row[27] ? row[27] : "-1", nullptr, 10);
+
+			all_entries.push_back(e);
+		}
+
+		return all_entries;
+	}
+
+	static std::vector<ZoneStateSpawns> GetWhere(Database& db, const std::string &where_filter)
+	{
+		std::vector<ZoneStateSpawns> 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) {
+			ZoneStateSpawns e{};
+
+			e.id                  = row[0] ? strtoll(row[0], nullptr, 10) : 0;
+			e.zone_id             = row[1] ? static_cast<uint32_t>(strtoul(row[1], nullptr, 10)) : 0;
+			e.instance_id         = row[2] ? static_cast<uint32_t>(strtoul(row[2], nullptr, 10)) : 0;
+			e.is_corpse           = row[3] ? static_cast<int8_t>(atoi(row[3])) : 0;
+			e.decay_in_seconds    = row[4] ? static_cast<int32_t>(atoi(row[4])) : 0;
+			e.npc_id              = row[5] ? static_cast<uint32_t>(strtoul(row[5], nullptr, 10)) : 0;
+			e.spawn2_id           = row[6] ? static_cast<uint32_t>(strtoul(row[6], nullptr, 10)) : 0;
+			e.spawngroup_id       = row[7] ? static_cast<uint32_t>(strtoul(row[7], nullptr, 10)) : 0;
+			e.x                   = row[8] ? strtof(row[8], nullptr) : 0;
+			e.y                   = row[9] ? strtof(row[9], nullptr) : 0;
+			e.z                   = row[10] ? strtof(row[10], nullptr) : 0;
+			e.heading             = row[11] ? strtof(row[11], nullptr) : 0;
+			e.respawn_time        = row[12] ? static_cast<uint32_t>(strtoul(row[12], nullptr, 10)) : 0;
+			e.variance            = row[13] ? static_cast<uint32_t>(strtoul(row[13], nullptr, 10)) : 0;
+			e.grid                = row[14] ? static_cast<uint32_t>(strtoul(row[14], nullptr, 10)) : 0;
+			e.current_waypoint    = row[15] ? static_cast<int32_t>(atoi(row[15])) : 0;
+			e.path_when_zone_idle = row[16] ? static_cast<int16_t>(atoi(row[16])) : 0;
+			e.condition_id        = row[17] ? static_cast<uint16_t>(strtoul(row[17], nullptr, 10)) : 0;
+			e.condition_min_value = row[18] ? static_cast<int16_t>(atoi(row[18])) : 0;
+			e.enabled             = row[19] ? static_cast<int16_t>(atoi(row[19])) : 1;
+			e.anim                = row[20] ? static_cast<uint16_t>(strtoul(row[20], nullptr, 10)) : 0;
+			e.loot_data           = row[21] ? row[21] : "";
+			e.entity_variables    = row[22] ? row[22] : "";
+			e.buffs               = row[23] ? row[23] : "";
+			e.hp                  = row[24] ? strtoll(row[24], nullptr, 10) : 0;
+			e.mana                = row[25] ? strtoll(row[25], nullptr, 10) : 0;
+			e.endurance           = row[26] ? strtoll(row[26], nullptr, 10) : 0;
+			e.created_at          = strtoll(row[27] ? row[27] : "-1", nullptr, 10);
+
+			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 ZoneStateSpawns &e
+	)
+	{
+		std::vector<std::string> v;
+
+		v.push_back(std::to_string(e.id));
+		v.push_back(std::to_string(e.zone_id));
+		v.push_back(std::to_string(e.instance_id));
+		v.push_back(std::to_string(e.is_corpse));
+		v.push_back(std::to_string(e.decay_in_seconds));
+		v.push_back(std::to_string(e.npc_id));
+		v.push_back(std::to_string(e.spawn2_id));
+		v.push_back(std::to_string(e.spawngroup_id));
+		v.push_back(std::to_string(e.x));
+		v.push_back(std::to_string(e.y));
+		v.push_back(std::to_string(e.z));
+		v.push_back(std::to_string(e.heading));
+		v.push_back(std::to_string(e.respawn_time));
+		v.push_back(std::to_string(e.variance));
+		v.push_back(std::to_string(e.grid));
+		v.push_back(std::to_string(e.current_waypoint));
+		v.push_back(std::to_string(e.path_when_zone_idle));
+		v.push_back(std::to_string(e.condition_id));
+		v.push_back(std::to_string(e.condition_min_value));
+		v.push_back(std::to_string(e.enabled));
+		v.push_back(std::to_string(e.anim));
+		v.push_back("'" + Strings::Escape(e.loot_data) + "'");
+		v.push_back("'" + Strings::Escape(e.entity_variables) + "'");
+		v.push_back("'" + Strings::Escape(e.buffs) + "'");
+		v.push_back(std::to_string(e.hp));
+		v.push_back(std::to_string(e.mana));
+		v.push_back(std::to_string(e.endurance));
+		v.push_back("FROM_UNIXTIME(" + (e.created_at > 0 ? std::to_string(e.created_at) : "null") + ")");
+
+		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<ZoneStateSpawns> &entries
+	)
+	{
+		std::vector<std::string> insert_chunks;
+
+		for (auto &e: entries) {
+			std::vector<std::string> v;
+
+			v.push_back(std::to_string(e.id));
+			v.push_back(std::to_string(e.zone_id));
+			v.push_back(std::to_string(e.instance_id));
+			v.push_back(std::to_string(e.is_corpse));
+			v.push_back(std::to_string(e.decay_in_seconds));
+			v.push_back(std::to_string(e.npc_id));
+			v.push_back(std::to_string(e.spawn2_id));
+			v.push_back(std::to_string(e.spawngroup_id));
+			v.push_back(std::to_string(e.x));
+			v.push_back(std::to_string(e.y));
+			v.push_back(std::to_string(e.z));
+			v.push_back(std::to_string(e.heading));
+			v.push_back(std::to_string(e.respawn_time));
+			v.push_back(std::to_string(e.variance));
+			v.push_back(std::to_string(e.grid));
+			v.push_back(std::to_string(e.current_waypoint));
+			v.push_back(std::to_string(e.path_when_zone_idle));
+			v.push_back(std::to_string(e.condition_id));
+			v.push_back(std::to_string(e.condition_min_value));
+			v.push_back(std::to_string(e.enabled));
+			v.push_back(std::to_string(e.anim));
+			v.push_back("'" + Strings::Escape(e.loot_data) + "'");
+			v.push_back("'" + Strings::Escape(e.entity_variables) + "'");
+			v.push_back("'" + Strings::Escape(e.buffs) + "'");
+			v.push_back(std::to_string(e.hp));
+			v.push_back(std::to_string(e.mana));
+			v.push_back(std::to_string(e.endurance));
+			v.push_back("FROM_UNIXTIME(" + (e.created_at > 0 ? std::to_string(e.created_at) : "null") + ")");
+
+			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_ZONE_STATE_SPAWNS_REPOSITORY_H
@@ -2,7 +2,7 @@
 #define EQEMU_CHARACTER_EXPEDITION_LOCKOUTS_REPOSITORY_H

 #include "../database.h"
-#include "../expedition_lockout_timer.h"
+#include "../dynamic_zone_lockout.h"
 #include "../strings.h"
 #include "base/base_character_expedition_lockouts_repository.h"
 #include <unordered_map>
@@ -47,33 +47,8 @@ public:

 	// Custom extended repository methods here

-	struct CharacterExpeditionLockoutsTimeStamp {
-		int         id;
-		int         character_id;
-		std::string expedition_name;
-		std::string event_name;
-		time_t      expire_time;
-		int         duration;
-		std::string from_expedition_uuid;
-	};
-
-	static ExpeditionLockoutTimer GetExpeditionLockoutTimerFromEntry(
-		CharacterExpeditionLockoutsTimeStamp&& entry)
-	{
-		ExpeditionLockoutTimer lockout_timer{
-			std::move(entry.from_expedition_uuid),
-			std::move(entry.expedition_name),
-			std::move(entry.event_name),
-			static_cast<uint64_t>(entry.expire_time),
-			static_cast<uint32_t>(entry.duration)
-		};
-
-		return lockout_timer;
-	}
-
-	static std::unordered_map<uint32_t, std::vector<ExpeditionLockoutTimer>> GetManyCharacterLockoutTimers(
-		Database& db, const std::vector<uint32_t>& character_ids,
-		const std::string& expedition_name, const std::string& ordered_event_name)
+	static std::unordered_map<uint32_t, std::vector<DzLockout>> GetLockouts(
+		Database& db, const std::vector<uint32_t>& char_ids, const std::string& expedition)
 	{
 		auto results = db.QueryDatabase(fmt::format(SQL(
 			SELECT
@@ -84,39 +59,171 @@ public:
 				from_expedition_uuid
 			FROM character_expedition_lockouts
 			WHERE
-				character_id IN ({})
+				character_id IN ({0})
 				AND expire_time > NOW()
-				AND expedition_name = '{}'
+				AND expedition_name = '{1}'
 			ORDER BY
-				FIELD(character_id, {}),
-				FIELD(event_name, '{}') DESC
+				FIELD(character_id, {0}),
+				FIELD(event_name, '{2}') DESC
 		),
-			fmt::join(character_ids, ","),
-			Strings::Escape(expedition_name),
-			fmt::join(character_ids, ","),
-			Strings::Escape(ordered_event_name)
+			fmt::join(char_ids, ","),
+			Strings::Escape(expedition),
+			Strings::Escape(DzLockout::ReplayTimer)
 		));

-		std::unordered_map<uint32_t, std::vector<ExpeditionLockoutTimer>> lockouts;
+		std::unordered_map<uint32_t, std::vector<DzLockout>> lockouts;

 		for (auto row = results.begin(); row != results.end(); ++row)
 		{
-			CharacterExpeditionLockoutsTimeStamp entry{};
-
 			int col = 0;
-			entry.character_id         = std::strtoul(row[col++], nullptr, 10);
-			entry.expire_time          = std::strtoull(row[col++], nullptr, 10);
-			entry.duration             = std::strtoul(row[col++], nullptr, 10);
-			entry.event_name           = row[col++];
-			entry.expedition_name      = expedition_name;
-			entry.from_expedition_uuid = row[col++];
+			uint32_t    char_id     = std::strtoul(row[col++], nullptr, 10);
+			time_t      expire_time = std::strtoull(row[col++], nullptr, 10);
+			uint32_t    duration    = std::strtoul(row[col++], nullptr, 10);
+			std::string event       = row[col++];
+			std::string uuid        = row[col++];

-			auto lockout = GetExpeditionLockoutTimerFromEntry(std::move(entry));
-			lockouts[entry.character_id].emplace_back(std::move(lockout));
+			lockouts[char_id].emplace_back(std::move(uuid), expedition, std::move(event), expire_time, duration);
 		}

 		return lockouts;
 	}
+
+	static std::vector<DzLockout> GetLockouts(Database& db, uint32_t char_id)
+	{
+		std::vector<DzLockout> lockouts;
+
+		auto rows = GetWhere(db, fmt::format("character_id = {} AND expire_time > NOW()", char_id));
+		lockouts.reserve(rows.size());
+
+		for (auto& row : rows)
+		{
+			lockouts.emplace_back(
+				std::move(row.from_expedition_uuid),
+				std::move(row.expedition_name),
+				std::move(row.event_name),
+				row.expire_time,
+				row.duration
+			);
+		}
+
+		return lockouts;
+	}
+
+	static std::vector<CharacterExpeditionLockouts> GetLockouts(Database& db, const std::vector<std::string>& names, const std::string& expedition, const std::string& event)
+	{
+		if (names.empty())
+		{
+			return {};
+		}
+
+		return GetWhere(db, fmt::format(
+			"character_id IN (select id from character_data where name IN ('{}')) AND expire_time > NOW() AND expedition_name = '{}' AND event_name = '{}' LIMIT 1",
+			fmt::join(names, "','"), Strings::Escape(expedition), Strings::Escape(event)));
+	}
+
+	static void InsertLockouts(Database& db, uint32_t char_id, const std::vector<DzLockout>& lockouts)
+	{
+		std::string insert_values;
+		for (const auto& lockout : lockouts)
+		{
+			fmt::format_to(std::back_inserter(insert_values),
+				"({}, FROM_UNIXTIME({}), {}, '{}', '{}', '{}'),",
+				char_id,
+				lockout.GetExpireTime(),
+				lockout.GetDuration(),
+				Strings::Escape(lockout.UUID()),
+				Strings::Escape(lockout.DzName()),
+				Strings::Escape(lockout.Event())
+			);
+		}
+
+		if (!insert_values.empty())
+		{
+			insert_values.pop_back(); // trailing comma
+
+			auto query = fmt::format(SQL(
+				INSERT INTO character_expedition_lockouts
+					(character_id, expire_time, duration, from_expedition_uuid, expedition_name, event_name)
+				VALUES {}
+				ON DUPLICATE KEY UPDATE
+					from_expedition_uuid = VALUES(from_expedition_uuid),
+					expire_time = VALUES(expire_time),
+					duration = VALUES(duration);
+			), insert_values);
+
+			db.QueryDatabase(query);
+		}
+	}
+
+	static void InsertLockout(Database& db, const std::vector<uint32_t>& char_ids, const DzLockout& lockout)
+	{
+		std::string insert_values;
+		for (const auto& char_id : char_ids)
+		{
+			fmt::format_to(std::back_inserter(insert_values),
+				"({}, FROM_UNIXTIME({}), {}, '{}', '{}', '{}'),",
+				char_id,
+				lockout.GetExpireTime(),
+				lockout.GetDuration(),
+				Strings::Escape(lockout.UUID()),
+				Strings::Escape(lockout.DzName()),
+				Strings::Escape(lockout.Event())
+			);
+		}
+
+		if (!insert_values.empty())
+		{
+			insert_values.pop_back(); // trailing comma
+
+			auto query = fmt::format(SQL(
+				INSERT INTO character_expedition_lockouts
+					(character_id, expire_time, duration, from_expedition_uuid, expedition_name, event_name)
+				VALUES {}
+				ON DUPLICATE KEY UPDATE
+					from_expedition_uuid = VALUES(from_expedition_uuid),
+					expire_time = VALUES(expire_time),
+					duration = VALUES(duration);
+			), insert_values);
+
+			db.QueryDatabase(query);
+		}
+	}
+
+	// inserts a new lockout or updates existing lockout with seconds added to current time
+	static void AddLockoutDuration(Database& db, const std::vector<uint32_t>& char_ids, const DzLockout& lockout, int seconds)
+	{
+		std::string insert_values;
+		for (const auto& char_id : char_ids)
+		{
+			fmt::format_to(std::back_inserter(insert_values),
+				"({}, FROM_UNIXTIME({}), {}, '{}', '{}', '{}'),",
+				char_id,
+				lockout.GetExpireTime(),
+				lockout.GetDuration(),
+				Strings::Escape(lockout.UUID()),
+				Strings::Escape(lockout.DzName()),
+				Strings::Escape(lockout.Event())
+			);
+		}
+
+		if (!insert_values.empty())
+		{
+			insert_values.pop_back(); // trailing comma
+
+			auto query = fmt::format(SQL(
+				INSERT INTO character_expedition_lockouts
+					(character_id, expire_time, duration, from_expedition_uuid, expedition_name, event_name)
+				VALUES {0}
+				ON DUPLICATE KEY UPDATE
+					from_expedition_uuid = VALUES(from_expedition_uuid),
+					expire_time = DATE_ADD(expire_time, INTERVAL {1} SECOND),
+					duration = GREATEST(0, CAST(duration AS SIGNED) + {1});
+			), insert_values, seconds);
+
+			db.QueryDatabase(query);
+		}
+	}
+
 };

 #endif //EQEMU_CHARACTER_EXPEDITION_LOCKOUTS_REPOSITORY_H
@@ -0,0 +1,84 @@
+#ifndef EQEMU_DYNAMIC_ZONE_LOCKOUTS_REPOSITORY_H
+#define EQEMU_DYNAMIC_ZONE_LOCKOUTS_REPOSITORY_H
+
+#include "../database.h"
+#include "../strings.h"
+#include "../dynamic_zone_lockout.h"
+#include "base/base_dynamic_zone_lockouts_repository.h"
+
+class DynamicZoneLockoutsRepository: public BaseDynamicZoneLockoutsRepository {
+public:
+
+    /**
+     * This file was auto generated and can be modified and extended upon
+     *
+     * Base repository methods are automatically
+     * generated in the "base" version of this repository. The base repository
+     * is immutable and to be left untouched, while methods in this class
+     * are used as extension methods for more specific persistence-layer
+     * accessors or mutators.
+     *
+     * Base Methods (Subject to be expanded upon in time)
+     *
+     * Note: Not all tables are designed appropriately to fit functionality with all base methods
+     *
+     * InsertOne
+     * UpdateOne
+     * DeleteOne
+     * FindOne
+     * GetWhere(std::string where_filter)
+     * DeleteWhere(std::string where_filter)
+     * InsertMany
+     * All
+     *
+     * Example custom methods in a repository
+     *
+     * DynamicZoneLockoutsRepository::GetByZoneAndVersion(int zone_id, int zone_version)
+     * DynamicZoneLockoutsRepository::GetWhereNeverExpires()
+     * DynamicZoneLockoutsRepository::GetWhereXAndY()
+     * DynamicZoneLockoutsRepository::DeleteWhereXAndY()
+     *
+     * Most of the above could be covered by base methods, but if you as a developer
+     * find yourself re-using logic for other parts of the code, its best to just make a
+     * method that can be re-used easily elsewhere especially if it can use a base repository
+     * method and encapsulate filters there
+     */
+
+	// Custom extended repository methods here
+
+	static void InsertLockouts(Database& db, uint32_t dz_id, const std::vector<DzLockout>& lockouts)
+	{
+		std::string insert_values;
+		for (const auto& lockout : lockouts)
+		{
+			fmt::format_to(std::back_inserter(insert_values),
+				"({}, '{}', '{}', FROM_UNIXTIME({}), {}),",
+				dz_id,
+				Strings::Escape(lockout.UUID()),
+				Strings::Escape(lockout.Event()),
+				lockout.GetExpireTime(),
+				lockout.GetDuration()
+			);
+		}
+
+		if (!insert_values.empty())
+		{
+			insert_values.pop_back(); // trailing comma
+
+			auto query = fmt::format(SQL(
+				INSERT INTO dynamic_zone_lockouts
+					(dynamic_zone_id, from_expedition_uuid, event_name, expire_time, duration)
+				VALUES {}
+				ON DUPLICATE KEY UPDATE
+					from_expedition_uuid = VALUES(from_expedition_uuid),
+					expire_time = VALUES(expire_time),
+					duration = VALUES(duration);
+			), insert_values);
+
+			db.QueryDatabase(query);
+		}
+	}
+
+};
+
+#endif //EQEMU_DYNAMIC_ZONE_LOCKOUTS_REPOSITORY_H
@@ -65,7 +65,7 @@ public:
 		));
 	}

-	static std::vector<MemberWithName> GetAllWithNames(Database& db)
+	static std::vector<MemberWithName> AllWithNames(Database& db)
 	{
 		std::vector<MemberWithName> all_entries;

@@ -146,65 +146,34 @@ public:

 	static void RemoveMember(Database& db, uint32_t dynamic_zone_id, uint32_t character_id)
 	{
-		db.QueryDatabase(fmt::format(SQL(
-			DELETE FROM {}
-			WHERE dynamic_zone_id = {} AND character_id = {};
-		),
-			TableName(), dynamic_zone_id, character_id
-		));
+		DeleteWhere(db, fmt::format("dynamic_zone_id = {} AND character_id = {}", dynamic_zone_id, character_id));
 	}

 	static void RemoveAllMembers(Database& db, uint32_t dynamic_zone_id)
 	{
-		db.QueryDatabase(fmt::format(SQL(
-			DELETE FROM {}
-			WHERE dynamic_zone_id = {};
-		),
-			TableName(), dynamic_zone_id
-		));
+		DeleteWhere(db, fmt::format("dynamic_zone_id = {}", dynamic_zone_id));
 	}

-	static void RemoveAllMembers(Database& db, std::vector<uint32_t> dynamic_zone_ids)
+	static uint32_t InsertOrUpdateMany(Database& db, const std::vector<DynamicZoneMembers>& entries)
 	{
-		if (!dynamic_zone_ids.empty())
+		if (entries.empty())
 		{
-			db.QueryDatabase(fmt::format(SQL(
-				DELETE FROM {}
-				WHERE dynamic_zone_id IN ({});
-			),
-				TableName(), Strings::Join(dynamic_zone_ids, ",")
-			));
-		}
-	}
-
-	static int InsertOrUpdateMany(Database& db,
-		const std::vector<DynamicZoneMembers>& dynamic_zone_members_entries)
-	{
-		std::vector<std::string> insert_chunks;
-
-		for (auto &dynamic_zone_members_entry: dynamic_zone_members_entries)
-		{
-			std::vector<std::string> insert_values;
-
-			insert_values.push_back(std::to_string(dynamic_zone_members_entry.id));
-			insert_values.push_back(std::to_string(dynamic_zone_members_entry.dynamic_zone_id));
-			insert_values.push_back(std::to_string(dynamic_zone_members_entry.character_id));
-
-			insert_chunks.push_back("(" + Strings::Implode(",", insert_values) + ")");
+			return 0;
 		}

-		std::vector<std::string> insert_values;
+		std::vector<std::string> values;
+		values.reserve(entries.size());

-		auto results = db.QueryDatabase(
-			fmt::format(
-				"INSERT INTO {} ({}) VALUES {} ON DUPLICATE KEY UPDATE id = id;",
-				TableName(),
-				ColumnsRaw(),
-				Strings::Implode(",", insert_chunks)
-			)
-		);
+		for (const auto& entry : entries)
+		{
+			values.push_back(fmt::format("({},{},{})", entry.id, entry.dynamic_zone_id, entry.character_id));
+		}

-		return (results.Success() ? results.RowsAffected() : 0);
+		auto results = db.QueryDatabase(fmt::format(
+			"INSERT INTO {} ({}) VALUES {} ON DUPLICATE KEY UPDATE id = id;",
+			TableName(), ColumnsRaw(), fmt::join(values, ",")));
+
+		return results.Success() ? results.RowsAffected() : 0;
 	}
 };

@@ -70,6 +70,8 @@ public:
 		float    zone_in_z;
 		float    zone_in_heading;
 		int      has_zone_in;
+		int8_t   is_locked;
+		int8_t   add_replay;
 		int      zone;
 		int      version;
 		int      is_global;
@@ -105,6 +107,8 @@ public:
 				dynamic_zones.zone_in_z,
 				dynamic_zones.zone_in_heading,
 				dynamic_zones.has_zone_in,
+				dynamic_zones.is_locked,
+				dynamic_zones.add_replay,
 				instance_list.zone,
 				instance_list.version,
 				instance_list.is_global,
@@ -144,6 +148,8 @@ public:
 		entry.zone_in_z           = strtof(row[col++], nullptr);
 		entry.zone_in_heading     = strtof(row[col++], nullptr);
 		entry.has_zone_in         = strtol(row[col++], nullptr, 10) != 0;
+		entry.is_locked           = static_cast<int8_t>(strtol(row[col++], nullptr, 10));
+		entry.add_replay          = static_cast<int8_t>(strtol(row[col++], nullptr, 10));
 		// from instance_list
 		entry.zone                = strtol(row[col++], nullptr, 10);
 		entry.version             = strtol(row[col++], nullptr, 10);
@@ -244,6 +250,22 @@ public:
 		}
 	}

+	static void UpdateLocked(Database& db, uint32_t dz_id, bool lock)
+	{
+		if (dz_id != 0)
+		{
+			db.QueryDatabase(fmt::format("UPDATE dynamic_zones SET is_locked = {} WHERE id = {}", lock, dz_id));
+		}
+	}
+
+	static void UpdateReplayOnJoin(Database& db, uint32_t dz_id, bool enabled)
+	{
+		if (dz_id != 0)
+		{
+			db.QueryDatabase(fmt::format("UPDATE dynamic_zones SET add_replay = {} WHERE id = {}", enabled, dz_id));
+		}
+	}
+
 	static void UpdateSwitchID(Database& db, uint32_t dz_id, int dz_switch_id)
 	{
 		if (dz_id != 0)
@@ -351,6 +373,59 @@ public:

 		return all_entries;
 	}
+
+	struct CharacterDz
+	{
+		uint32_t    id;
+		std::string name;
+		uint32_t    dz_id;
+	};
+
+	// get character ids with possible active dz id by type
+	static std::vector<CharacterDz> GetCharactersWithDz(Database& db, const std::vector<std::string>& names, int type)
+	{
+		if (names.empty())
+		{
+			return {};
+		}
+
+		std::vector<CharacterDz> entries;
+		entries.reserve(names.size());
+
+		auto results = db.QueryDatabase(fmt::format(SQL(
+			SELECT
+				character_data.id,
+				character_data.name,
+				MAX(dynamic_zones.id)
+			FROM character_data
+				LEFT JOIN dynamic_zone_members
+					ON character_data.id = dynamic_zone_members.character_id
+				LEFT JOIN dynamic_zones
+					ON dynamic_zone_members.dynamic_zone_id = dynamic_zones.id
+					AND dynamic_zones.`type` = {0}
+			WHERE character_data.name IN ('{1}')
+			GROUP BY character_data.id
+			ORDER BY FIELD(character_data.name, '{1}')
+		),
+			type,
+			fmt::join(names, "','")
+		));
+
+		if (results.Success())
+		{
+			for (auto row = results.begin(); row != results.end(); ++row)
+			{
+				CharacterDz entry{};
+				entry.id    = std::strtoul(row[0], nullptr, 10);
+				entry.name  = row[1];
+				entry.dz_id = row[2] ? std::strtoul(row[2], nullptr, 10) : 0;
+
+				entries.push_back(std::move(entry));
+			}
+		}
+
+		return entries;
+	}
 };

 #endif //EQEMU_DYNAMIC_ZONES_REPOSITORY_H
@@ -1,102 +0,0 @@
-#ifndef EQEMU_EXPEDITION_LOCKOUTS_REPOSITORY_H
-#define EQEMU_EXPEDITION_LOCKOUTS_REPOSITORY_H
-
-#include "../database.h"
-#include "../strings.h"
-#include "base/base_expedition_lockouts_repository.h"
-
-class ExpeditionLockoutsRepository: public BaseExpeditionLockoutsRepository {
-public:
-
-    /**
-     * This file was auto generated and can be modified and extended upon
-     *
-     * Base repository methods are automatically
-     * generated in the "base" version of this repository. The base repository
-     * is immutable and to be left untouched, while methods in this class
-     * are used as extension methods for more specific persistence-layer
-     * accessors or mutators.
-     *
-     * Base Methods (Subject to be expanded upon in time)
-     *
-     * Note: Not all tables are designed appropriately to fit functionality with all base methods
-     *
-     * InsertOne
-     * UpdateOne
-     * DeleteOne
-     * FindOne
-     * GetWhere(std::string where_filter)
-     * DeleteWhere(std::string where_filter)
-     * InsertMany
-     * All
-     *
-     * Example custom methods in a repository
-     *
-     * ExpeditionLockoutsRepository::GetByZoneAndVersion(int zone_id, int zone_version)
-     * ExpeditionLockoutsRepository::GetWhereNeverExpires()
-     * ExpeditionLockoutsRepository::GetWhereXAndY()
-     * ExpeditionLockoutsRepository::DeleteWhereXAndY()
-     *
-     * Most of the above could be covered by base methods, but if you as a developer
-     * find yourself re-using logic for other parts of the code, its best to just make a
-     * method that can be re-used easily elsewhere especially if it can use a base repository
-     * method and encapsulate filters there
-     */
-
-	// Custom extended repository methods here
-
-	struct ExpeditionLockoutsWithTimestamp {
-		uint32_t    id;
-		uint32_t    expedition_id;
-		std::string event_name;
-		time_t      expire_time;
-		int         duration;
-		std::string from_expedition_uuid;
-	};
-
-	static std::vector<ExpeditionLockoutsWithTimestamp> GetWithTimestamp(
-		Database& db, const std::vector<uint32_t>& expedition_ids)
-	{
-		if (expedition_ids.empty())
-		{
-			return {};
-		}
-
-		std::vector<ExpeditionLockoutsWithTimestamp> all_entries;
-
-		auto results = db.QueryDatabase(fmt::format(SQL(
-			SELECT
-				id,
-				expedition_id,
-				event_name,
-				UNIX_TIMESTAMP(expire_time),
-				duration,
-				from_expedition_uuid
-			FROM expedition_lockouts
-			WHERE expedition_id IN ({})
-		),
-			Strings::Join(expedition_ids, ",")
-		));
-
-		all_entries.reserve(results.RowCount());
-
-		for (auto row = results.begin(); row != results.end(); ++row)
-		{
-			ExpeditionLockoutsWithTimestamp entry{};
-
-			int col = 0;
-			entry.id                   = strtoul(row[col++], nullptr, 10);
-			entry.expedition_id        = strtoul(row[col++], nullptr, 10);
-			entry.event_name           = row[col++];
-			entry.expire_time          = strtoull(row[col++], nullptr, 10);
-			entry.duration             = strtol(row[col++], nullptr, 10);
-			entry.from_expedition_uuid = row[col++];
-
-			all_entries.emplace_back(std::move(entry));
-		}
-
-		return all_entries;
-	}
-};
-
-#endif //EQEMU_EXPEDITION_LOCKOUTS_REPOSITORY_H
@@ -1,134 +0,0 @@
-#ifndef EQEMU_EXPEDITIONS_REPOSITORY_H
-#define EQEMU_EXPEDITIONS_REPOSITORY_H
-
-#include "../database.h"
-#include "../strings.h"
-#include "base/base_expeditions_repository.h"
-
-class ExpeditionsRepository: public BaseExpeditionsRepository {
-public:
-
-    /**
-     * This file was auto generated and can be modified and extended upon
-     *
-     * Base repository methods are automatically
-     * generated in the "base" version of this repository. The base repository
-     * is immutable and to be left untouched, while methods in this class
-     * are used as extension methods for more specific persistence-layer
-     * accessors or mutators.
-     *
-     * Base Methods (Subject to be expanded upon in time)
-     *
-     * Note: Not all tables are designed appropriately to fit functionality with all base methods
-     *
-     * InsertOne
-     * UpdateOne
-     * DeleteOne
-     * FindOne
-     * GetWhere(std::string where_filter)
-     * DeleteWhere(std::string where_filter)
-     * InsertMany
-     * All
-     *
-     * Example custom methods in a repository
-     *
-     * ExpeditionsRepository::GetByZoneAndVersion(int zone_id, int zone_version)
-     * ExpeditionsRepository::GetWhereNeverExpires()
-     * ExpeditionsRepository::GetWhereXAndY()
-     * ExpeditionsRepository::DeleteWhereXAndY()
-     *
-     * Most of the above could be covered by base methods, but if you as a developer
-     * find yourself re-using logic for other parts of the code, its best to just make a
-     * method that can be re-used easily elsewhere especially if it can use a base repository
-     * method and encapsulate filters there
-     */
-
-	// Custom extended repository methods here
-
-	struct CharacterExpedition
-	{
-		uint32_t    id;
-		std::string name;
-		uint32_t    expedition_id;
-	};
-
-	static std::vector<CharacterExpedition> GetCharactersWithExpedition(
-		Database& db, const std::vector<std::string>& character_names)
-	{
-		if (character_names.empty())
-		{
-			return {};
-		}
-
-		std::vector<CharacterExpedition> entries;
-
-		auto joined_character_names = fmt::format("'{}'", Strings::Join(character_names, "','"));
-
-		auto results = db.QueryDatabase(fmt::format(SQL(
-			SELECT
-				character_data.id,
-				character_data.name,
-				MAX(expeditions.id)
-			FROM character_data
-				LEFT JOIN dynamic_zone_members
-					ON character_data.id = dynamic_zone_members.character_id
-				LEFT JOIN expeditions
-					ON dynamic_zone_members.dynamic_zone_id = expeditions.dynamic_zone_id
-			WHERE character_data.name IN ({})
-			GROUP BY character_data.id
-			ORDER BY FIELD(character_data.name, {})
-		),
-			joined_character_names,
-			joined_character_names
-		));
-
-		if (results.Success())
-		{
-			entries.reserve(results.RowCount());
-
-			for (auto row = results.begin(); row != results.end(); ++row)
-			{
-				CharacterExpedition entry{};
-				entry.id            = std::strtoul(row[0], nullptr, 10);
-				entry.name          = row[1];
-				entry.expedition_id = row[2] ? std::strtoul(row[2], nullptr, 10) : 0;
-
-				entries.emplace_back(std::move(entry));
-			}
-		}
-
-		return entries;
-	}
-
-	static uint32_t GetIDByMemberID(Database& db, uint32_t character_id)
-	{
-		if (character_id == 0)
-		{
-			return 0;
-		}
-
-		uint32_t expedition_id = 0;
-
-		auto results = db.QueryDatabase(fmt::format(SQL(
-			SELECT
-				expeditions.id
-			FROM expeditions
-				INNER JOIN dynamic_zone_members
-					ON expeditions.dynamic_zone_id = dynamic_zone_members.dynamic_zone_id
-			WHERE
-				dynamic_zone_members.character_id = {}
-		),
-			character_id
-		));
-
-		if (results.Success() && results.RowCount() > 0)
-		{
-			auto row = results.begin();
-			expedition_id = std::strtoul(row[0], nullptr, 10);
-		}
-
-		return expedition_id;
-	}
-};
-
-#endif //EQEMU_EXPEDITIONS_REPOSITORY_H
@@ -45,33 +45,26 @@ public:

 	// Custom extended repository methods here

-	static int InsertOrUpdateMany(Database& db,
-		const std::vector<InstanceListPlayer>& instance_list_player_entries)
+	static uint32_t InsertOrUpdateMany(Database& db, const std::vector<InstanceListPlayer>& entries)
 	{
-		std::vector<std::string> insert_chunks;
-
-		for (auto &instance_list_player_entry: instance_list_player_entries)
+		if (entries.empty())
 		{
-			std::vector<std::string> insert_values;
-
-			insert_values.push_back(std::to_string(instance_list_player_entry.id));
-			insert_values.push_back(std::to_string(instance_list_player_entry.charid));
-
-			insert_chunks.push_back("(" + Strings::Implode(",", insert_values) + ")");
+			return 0;
 		}

-		std::vector<std::string> insert_values;
+		std::vector<std::string> values;
+		values.reserve(entries.size());

-		auto results = db.QueryDatabase(
-			fmt::format(
-				"INSERT INTO {} ({}) VALUES {} ON DUPLICATE KEY UPDATE id = VALUES(id)",
-				TableName(),
-				ColumnsRaw(),
-				Strings::Implode(",", insert_chunks)
-			)
-		);
+		for (const auto& entry : entries)
+		{
+			values.push_back(fmt::format("({},{})", entry.id, entry.charid));
+		}

-		return (results.Success() ? results.RowsAffected() : 0);
+		auto results = db.QueryDatabase(fmt::format(
+			"INSERT INTO {} ({}) VALUES {} ON DUPLICATE KEY UPDATE id = VALUES(id)",
+			TableName(), ColumnsRaw(), fmt::join(values, ",")));
+
+		return results.Success() ? results.RowsAffected() : 0;
 	}

 	static bool ReplaceOne(Database& db, InstanceListPlayer e)
@@ -0,0 +1,14 @@
+#ifndef EQEMU_ZONE_STATE_SPAWNS_REPOSITORY_H
+#define EQEMU_ZONE_STATE_SPAWNS_REPOSITORY_H
+
+#include "../database.h"
+#include "../strings.h"
+#include "base/base_zone_state_spawns_repository.h"
+
+class ZoneStateSpawnsRepository: public BaseZoneStateSpawnsRepository {
+public:
+	// Custom extended repository methods here
+
+};
+
+#endif //EQEMU_ZONE_STATE_SPAWNS_REPOSITORY_H
@@ -230,6 +230,7 @@ RULE_BOOL(Character, PlayerTradingLoreFeedback, true, "If enabled, during a play
 RULE_INT(Character, MendAlwaysSucceedValue, 199, "Value at which mend will always succeed its skill check. Default: 199")
 RULE_BOOL(Character, SneakAlwaysSucceedOver100, false, "When sneak skill is over 100, always succeed sneak/hide. Default: false")
 RULE_INT(Character, BandolierSwapDelay, 0, "Bandolier swap delay in milliseconds, default is 0")
+RULE_BOOL(Character, EnableHackedFastCampForGM, false, "Enables hacked fast camp for GM clients, if the GM doesn't have a hacked client they'll camp like normal")
 RULE_CATEGORY_END()

 RULE_CATEGORY(Mercs)
@@ -373,6 +374,7 @@ RULE_BOOL(Zone, AllowCrossZoneSpellsOnBots, false, "Set to true to allow cross z
 RULE_BOOL(Zone, AllowCrossZoneSpellsOnMercs, false, "Set to true to allow cross zone spells (cast/remove) to affect mercenaries")
 RULE_BOOL(Zone, AllowCrossZoneSpellsOnPets, false, "Set to true to allow cross zone spells (cast/remove) to affect pets")
 RULE_BOOL(Zone, ZoneShardQuestMenuOnly, false, "Set to true if you only want quests to show the zone shard menu")
+RULE_BOOL(Zone, StateSavingOnShutdown, true, "Set to true if you want zones to save state on shutdown (npcs, corpses, loot, entity variables, buffs etc.)")
 RULE_CATEGORY_END()

 RULE_CATEGORY(Map)
@@ -527,6 +529,7 @@ RULE_INT(Spells, TargetedAOEMaxTargets, 4, "Max number of targets a Targeted AOE
 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, 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_STRING(Spells, AlwaysStackSpells, "", "Comma-Seperated list of spell IDs to always stack with every other spell, except themselves.")
 RULE_CATEGORY_END()

 RULE_CATEGORY(Combat)
@@ -713,6 +716,7 @@ RULE_INT(Aggro, BardAggroCap, 40, "per song bard aggro cap.")
 RULE_INT(Aggro, InitialAggroBonus, 100, "Initial Aggro Bonus, Default: 100")
 RULE_INT(Aggro, InitialPetAggroBonus, 100, "Initial Pet Aggro Bonus, Default 100")
 RULE_STRING(Aggro, ExcludedFleeAllyFactionIDs, "0|5013|5014|5023|5032", "Common Faction IDs that are excluded from faction checks in EntityList::FleeAllyCount")
+RULE_BOOL(Aggro, AggroBotPets, false, "If enabled, NPCs will aggro bot pets")
 RULE_CATEGORY_END()

 RULE_CATEGORY(TaskSystem)
@@ -817,11 +821,11 @@ RULE_INT(Bots, MinDelayBetweenInCombatCastAttempts, 500, "The minimum delay in m
 RULE_INT(Bots, MaxDelayBetweenInCombatCastAttempts, 2000, "The maximum delay in milliseconds between cast attempts while in-combat. This is rolled between the min and max. Default 2500ms.")
 RULE_INT(Bots, MinDelayBetweenOutCombatCastAttempts, 1000, "The minimum delay in milliseconds between cast attempts while out-of-combat. This is rolled between the min and max. Default 1000ms.")
 RULE_INT(Bots, MaxDelayBetweenOutCombatCastAttempts, 2500, "The maximum delay in milliseconds between cast attempts while out-of-combat. This is rolled between the min and max. Default 2500ms.")
-RULE_INT(Bots, MezChance, 35, "35 Default. Chance for a bot to attempt to Mez a target after validating it is eligible.")
+RULE_INT(Bots, MezChance, 60, "60 Default. Chance for a bot to attempt to Mez a target after validating it is eligible.")
 RULE_INT(Bots, AEMezChance, 35, "35 Default. Chance for a bot to attempt to AE Mez targets after validating they are eligible.")
-RULE_INT(Bots, MezSuccessDelay, 3500, "3500 (3.5 sec) Default. Delay between successful Mez attempts.")
+RULE_INT(Bots, MezSuccessDelay, 2500, "2500 (2.5 sec) Default. Delay between successful Mez attempts.")
 RULE_INT(Bots, AEMezSuccessDelay, 5000, "5000 (5 sec) Default. Delay between successful AEMez attempts.")
-RULE_INT(Bots, MezFailDelay, 2000, "2000 (2 sec) Default. Delay between failed Mez attempts.")
+RULE_INT(Bots, MezFailDelay, 1250, "1250 (1.25 sec) Default. Delay between failed Mez attempts.")
 RULE_INT(Bots, MezAEFailDelay, 4000, "4000 (4 sec) Default. Delay between failed AEMez attempts.")
 RULE_INT(Bots, MinGroupHealTargets, 3, "Minimum number of targets in valid range that are required for a group heal to cast. Default 3.")
 RULE_INT(Bots, MinGroupCureTargets, 3, "Minimum number of targets in valid range that are required for a cure heal to cast. Default 3.")
@@ -1143,6 +1147,7 @@ RULE_BOOL(Items, DisableSpellFocusEffects, false, "Enable this to disable Spell
 RULE_BOOL(Items, SummonItemAllowInvisibleAugments, false, "Enable this to allow augments to be put in invisible augment slots of items in Client::SummonItem")
 RULE_BOOL(Items, AugmentItemAllowInvisibleAugments, false, "Enable this to allow augments to be put in invisible augment slots by players")
 RULE_BOOL(Items, AlwaysReturnHandins, true, "Enable this to always return handins to the player")
+RULE_BOOL(Items, NPCUseRecommendedLevels, false, "Enable to have NPCs scale item stats by recommended levels")
 RULE_CATEGORY_END()

 RULE_CATEGORY(Parcel)
@@ -0,0 +1,143 @@
+#ifndef EQEMU_SERVER_RELOAD_TYPES_H
+#define EQEMU_SERVER_RELOAD_TYPES_H
+
+#include <string>
+#include <vector>
+#include <cstdint>
+
+namespace ServerReload {
+	enum Type {
+		ReloadTypeNone = 0,
+		AAData,
+		AlternateCurrencies,
+		BaseData,
+		BlockedSpells,
+		Commands,
+		ContentFlags,
+		DataBucketsCache,
+		Doors,
+		DzTemplates,
+		Factions,
+		GroundSpawns,
+		LevelEXPMods,
+		Logs,
+		Loot,
+		Merchants,
+		NPCEmotes,
+		NPCSpells,
+		Objects,
+		Opcodes,
+		PerlExportSettings,
+		Quests,
+		QuestsTimerReset,
+		Rules,
+		SkillCaps,
+		StaticZoneData,
+		Tasks,
+		Titles,
+		Traps,
+		Variables,
+		VeteranRewards,
+		WorldRepop,
+		WorldWithRespawn,
+		ZoneData,
+		ZonePoints,
+		Max
+	};
+
+	static const char *Name[ServerReload::Max] = {
+		"None",
+		"AA Data",
+		"Alternate Currencies",
+		"Base Data",
+		"Blocked Spells",
+		"Commands",
+		"Content Flags",
+		"Data Buckets Cache",
+		"Doors",
+		"DZ Templates",
+		"Factions",
+		"Ground Spawns",
+		"Level EXP Mods",
+		"Logs",
+		"Loot",
+		"Merchants",
+		"NPC Emotes",
+		"NPC Spells",
+		"Objects",
+		"Opcodes",
+		"Perl Event Export Settings",
+		"Quest",
+		"Quests With Timer (Resets timer events)",
+		"Rules",
+		"Skill Caps",
+		"Static Zone Data",
+		"Tasks",
+		"Titles",
+		"Traps",
+		"Variables",
+		"Veteran Rewards",
+		"World Repop",
+		"World Repop Timers (Clear Respawn Timers)",
+		"Zone Data",
+		"Zone Points"
+	};
+
+	inline std::string GetName(int reload_type)
+	{
+		if (reload_type < 0 || reload_type >= ServerReload::Type::Max) {
+			return "Unknown";
+		}
+
+		return ServerReload::Name[reload_type];
+	}
+
+	// Get a clean name without spaces or special characters
+	inline std::string GetNameClean(int reload_type)
+	{
+		if (reload_type < 0 || reload_type >= ServerReload::Type::Max) {
+			return "Unknown";
+		}
+
+		// get the name before parentheses
+		std::string name = ServerReload::Name[reload_type];
+		size_t pos = name.find('(');
+		if (pos != std::string::npos) {
+			name = name.substr(0, pos);
+		}
+
+		// Trim leading spaces
+		size_t start = name.find_first_not_of(' ');
+		if (start == std::string::npos) {
+			return ""; // If all spaces, return empty string
+		}
+
+		// Trim trailing spaces
+		size_t end = name.find_last_not_of(' ');
+
+		// Extract trimmed substring
+		return name.substr(start, end - start + 1);
+
+		return name;
+	}
+
+	inline std::vector<ServerReload::Type> GetTypes()
+	{
+		std::vector<ServerReload::Type> types;
+		types.reserve(ServerReload::Type::Max);
+		for (int i = 1; i < ServerReload::Type::Max; i++) {
+			types.push_back(static_cast<ServerReload::Type>(i));
+		}
+		return types;
+	}
+
+	struct Request {
+		int      type                 = 0;
+		bool     requires_zone_booted = false;
+		int64    reload_at_unix       = 0;
+		int32    opt_param            = 0;
+		uint32_t zone_server_id       = 0;
+	};
+}
+
+#endif //EQEMU_SERVER_RELOAD_TYPES_H
@@ -170,18 +170,6 @@
 #define ServerOP_LFPMatches			0x0214
 #define ServerOP_ClientVersionSummary 0x0215

-// expedition
-#define ServerOP_ExpeditionCreate             0x0400
-#define ServerOP_ExpeditionLockout            0x0403
-#define ServerOP_ExpeditionDzAddPlayer        0x0408
-#define ServerOP_ExpeditionDzMakeLeader       0x0409
-#define ServerOP_ExpeditionCharacterLockout   0x040d
-#define ServerOP_ExpeditionSaveInvite         0x040e
-#define ServerOP_ExpeditionRequestInvite      0x040f
-#define ServerOP_ExpeditionReplayOnJoin       0x0410
-#define ServerOP_ExpeditionLockState          0x0411
-#define ServerOP_ExpeditionLockoutDuration    0x0414
-
 // dz
 #define ServerOP_DzAddRemoveMember            0x0450
 #define ServerOP_DzRemoveAllMembers           0x0451
@@ -199,6 +187,15 @@
 #define ServerOP_DzDeleted                    0x045d
 #define ServerOP_DzSetSwitchID                0x045e
 #define ServerOP_DzMovePC                     0x045f
+#define ServerOP_DzLock                       0x0460
+#define ServerOP_DzReplayOnJoin               0x0461
+#define ServerOP_DzLockout                    0x0462
+#define ServerOP_DzLockoutDuration            0x0463
+#define ServerOP_DzCharacterLockout           0x0464
+#define ServerOP_DzAddPlayer                  0x0465
+#define ServerOP_DzSaveInvite                 0x0466
+#define ServerOP_DzRequestInvite              0x0467
+#define ServerOP_DzMakeLeader                 0x0468

 #define ServerOP_LSInfo				0x1000
 #define ServerOP_LSStatus			0x1001
@@ -251,37 +248,7 @@
 #define ServerOP_UpdateSchedulerEvents 0x4007
 #define ServerOP_DiscordWebhookMessage 0x4008

-#define ServerOP_ReloadAAData 0x4100
-#define ServerOP_ReloadAlternateCurrencies 0x4101
-#define ServerOP_ReloadBlockedSpells 0x4102
-#define ServerOP_ReloadCommands 0x4103
-#define ServerOP_ReloadContentFlags 0x4104
-#define ServerOP_ReloadDoors 0x4105
-#define ServerOP_ReloadGroundSpawns 0x4106
-#define ServerOP_ReloadLevelEXPMods 0x4107
-#define ServerOP_ReloadLogs 0x4108
-#define ServerOP_ReloadMerchants 0x4109
-#define ServerOP_ReloadNPCEmotes 0x4110
-#define ServerOP_ReloadObjects 0x4111
-#define ServerOP_ReloadOpcodes 0x4112
-#define ServerOP_ReloadPerlExportSettings 0x4113
-#define ServerOP_ReloadRules 0x4114
-#define ServerOP_ReloadStaticZoneData 0x4115
-#define ServerOP_ReloadTasks 0x4116
-#define ServerOP_ReloadTitles 0x4117
-#define ServerOP_ReloadTraps 0x4118
-#define ServerOP_ReloadVariables 0x4119
-#define ServerOP_ReloadVeteranRewards 0x4120
-#define ServerOP_ReloadWorld 0x4121
-#define ServerOP_ReloadZonePoints 0x4122
-#define ServerOP_ReloadDzTemplates 0x4123
-#define ServerOP_ReloadZoneData 0x4124
-#define ServerOP_ReloadDataBucketsCache 0x4125
-#define ServerOP_ReloadFactions 0x4126
-#define ServerOP_ReloadLoot 0x4127
-#define ServerOP_ReloadBaseData 0x4128
-#define ServerOP_ReloadSkillCaps 0x4129
-#define ServerOP_ReloadNPCSpells 0x4130
+#define ServerOP_ServerReloadRequest 0x4100

 #define ServerOP_CZDialogueWindow 0x4500
 #define ServerOP_CZLDoNUpdate 0x4501
@@ -710,36 +677,53 @@ struct ServerLSPlayerZoneChange_Struct {
 	uint32 to; // 0 = world
 };

-struct ClientAuth_Struct {
+struct ClientAuth {
 	uint32 loginserver_account_id; // ID# in login server's db
-	char loginserver_name[64];
-	char account_name[30]; // username in login server's db
-	char key[30]; // the Key the client will present
-	uint8 lsadmin; // login server admin level
-	int16 is_world_admin; // login's suggested worldadmin level setting for this user, up to the world if they want to obey it
-	uint32 ip;
-	uint8 is_client_from_local_network; // 1 if the client is from the local network
+	char   loginserver_name[64];
+	char   account_name[30]; // username in login server's db
+	char   key[30]; // the key the client will present
+	uint8  lsadmin; // login server admin level
+	int16  is_world_admin; // login's suggested worldadmin level setting for this user, up to the world if they want to obey it
+	uint32 ip_address;
+	uint8  is_client_from_local_network; // 1 if the client is from the local network

-	template <class Archive>
+	template<class Archive>
 	void serialize(Archive &ar)
 	{
-		ar(loginserver_account_id, loginserver_name, account_name, key, lsadmin, is_world_admin, ip, is_client_from_local_network);
+		ar(
+			loginserver_account_id,
+			loginserver_name,
+			account_name,
+			key,
+			lsadmin,
+			is_world_admin,
+			ip_address,
+			is_client_from_local_network
+		);
 	}
 };

-struct ClientAuthLegacy_Struct {
+struct ClientAuthLegacy {
 	uint32 loginserver_account_id; // ID# in login server's db
-	char loginserver_account_name[30]; // username in login server's db
-	char key[30]; // the Key the client will present
-	uint8 loginserver_admin_level; // login server admin level
-	int16 is_world_admin; // login's suggested worldadmin level setting for this user, up to the world if they want to obey it
-	uint32 ip;
-	uint8 is_client_from_local_network; // 1 if the client is from the local network
+	char   loginserver_account_name[30]; // username in login server's db
+	char   key[30]; // the key the client will present
+	uint8  loginserver_admin_level; // login server admin level
+	int16  is_world_admin; // login's suggested worldadmin level setting for this user, up to the world if they want to obey it
+	uint32 ip_address;
+	uint8  is_client_from_local_network; // 1 if the client is from the local network

-	template <class Archive>
+	template<class Archive>
 	void serialize(Archive &ar)
 	{
-		ar(loginserver_account_id, loginserver_account_name, key, loginserver_admin_level, is_world_admin, ip, is_client_from_local_network);
+		ar(
+			loginserver_account_id,
+			loginserver_account_name,
+			key,
+			loginserver_admin_level,
+			is_world_admin,
+			ip_address,
+			is_client_from_local_network
+		);
 	}
 };

@@ -867,38 +851,38 @@ struct ServerSyncWorldList_Struct {
 	bool	placeholder;
 };

-struct UsertoWorldRequestLegacy_Struct {
-	uint32	lsaccountid;
-	uint32	worldid;
-	uint32	FromID;
-	uint32	ToID;
-	char	IPAddr[64];
-};
-
-struct UsertoWorldRequest_Struct {
-	uint32	lsaccountid;
-	uint32	worldid;
-	uint32	FromID;
-	uint32	ToID;
-	char	IPAddr[64];
-	char	login[64];
-};
-
-struct UsertoWorldResponseLegacy_Struct {
+struct UsertoWorldRequestLegacy {
 	uint32 lsaccountid;
 	uint32 worldid;
-	int8  response; // -3) World Full, -2) Banned, -1) Suspended, 0) Denied, 1) Allowed
+	uint32 FromID;
+	uint32 ToID;
+	char   IPAddr[64];
+};
+
+struct UsertoWorldRequest {
+	uint32 lsaccountid;
+	uint32 worldid;
+	uint32 FromID; // appears to be unused today
+	uint32 ToID; // appears to be unused today
+	char   IPAddr[64];
+	char   login[64];
+};
+
+struct UsertoWorldResponseLegacy {
+	uint32 lsaccountid;
+	uint32 worldid;
+	int8   response; // -3) World Full, -2) Banned, -1) Suspended, 0) Denied, 1) Allowed
 	uint32 FromID;
 	uint32 ToID;
 };

-struct UsertoWorldResponse_Struct {
+struct UsertoWorldResponse {
 	uint32 lsaccountid;
 	uint32 worldid;
-	int8  response; // -3) World Full, -2) Banned, -1) Suspended, 0) Denied, 1) Allowed
-	uint32 FromID;
-	uint32 ToID;
-	char  login[64];
+	int8   response; // -3) World Full, -2) Banned, -1) Suspended, 0) Denied, 1) Allowed
+	uint32 FromID; // appears to be unused today
+	uint32 ToID; // appears to be unused today
+	char   login[64];
 };

 // generic struct to be used for alot of simple zone->world questions
@@ -1543,10 +1527,8 @@ struct UCSServerStatus_Struct {
 	};
 };

-struct ServerExpeditionID_Struct {
-	uint32 expedition_id;
-	uint32 sender_zone_id;
-	uint32 sender_instance_id;
+struct ServerCharacterID_Struct {
+	uint32_t char_id;
 };

 struct ServerDzLeaderID_Struct {
@@ -1580,45 +1562,42 @@ struct ServerDzMovePC_Struct {
 	uint32 character_id;
 };

-struct ServerExpeditionLockout_Struct {
-	uint32 expedition_id;
+struct ServerDzLockout_Struct {
+	uint32 dz_id;
 	uint64 expire_time;
 	uint32 duration;
 	uint32 sender_zone_id;
 	uint16 sender_instance_id;
 	uint8  remove;
 	uint8  members_only;
-	int    seconds_adjust;
+	int    seconds;
 	char   event_name[256];
 };

-struct ServerExpeditionLockState_Struct {
-	uint32 expedition_id;
+struct ServerDzLock_Struct {
+	uint32 dz_id;
 	uint32 sender_zone_id;
 	uint16 sender_instance_id;
-	uint8  enabled;
+	bool   lock;
 	uint8  lock_msg; // 0: none, 1: closing 2: trial begin
+	uint32 color;
 };

-struct ServerExpeditionSetting_Struct {
-	uint32 expedition_id;
+struct ServerDzBool_Struct {
+	uint32 dz_id;
 	uint32 sender_zone_id;
 	uint16 sender_instance_id;
-	uint8  enabled;
+	bool   enabled;
 };

-struct ServerExpeditionCharacterLockout_Struct {
+struct ServerDzCharacterLockout_Struct {
 	uint8  remove;
-	uint32 character_id;
+	uint32 char_id;
 	uint64 expire_time;
 	uint32 duration;
 	char   uuid[37];
-	char   expedition_name[128];
-	char   event_name[256];
-};
-
-struct ServerExpeditionCharacterID_Struct {
-	uint32_t character_id;
+	char   expedition[128];
+	char   event[256];
 };

 struct ServerDzExpireWarning_Struct {
@@ -1627,7 +1606,7 @@ struct ServerDzExpireWarning_Struct {
 };

 struct ServerDzCommand_Struct {
-	uint32 expedition_id;
+	uint32 dz_id;
 	uint8  is_char_online;     // 0: target name is offline, 1: online
 	char   requester_name[64];
 	char   target_name[64];
@@ -1696,11 +1675,12 @@ struct ServerDzSetDuration_Struct {
 	uint32 seconds;
 };

-struct ServerDzCreateSerialized_Struct {
+struct ServerDzCreate_Struct {
 	uint16_t origin_zone_id;
 	uint16_t origin_instance_id;
+	uint32_t dz_id;
 	uint32_t cereal_size;
-	char     cereal_data[0];
+	char     cereal_data[1];
 };

 struct ServerSendPlayerEvent_Struct {
@@ -93,7 +93,14 @@ bool IsTargetableAESpell(uint16 spell_id)
 		return false;
 	}

-	return spells[spell_id].target_type == ST_AETarget;
+	return (
+		spells[spell_id].target_type == ST_AETarget ||
+		spells[spell_id].target_type == ST_TargetAETap ||
+		spells[spell_id].target_type == ST_AETargetHateList ||
+		spells[spell_id].target_type == ST_TargetAENoPlayersPets ||
+		spells[spell_id].target_type == ST_UndeadAE ||
+		spells[spell_id].target_type == ST_SummonedAE
+	);
 }

 bool IsSacrificeSpell(uint16 spell_id)
@@ -675,17 +682,19 @@ bool IsAnyNukeOrStunSpell(uint16 spell_id) {
 }

 bool IsAnyAESpell(uint16 spell_id) {
-    return (
-        IsValidSpell(spell_id) &&
-        (
-            IsAEDurationSpell(spell_id) ||
-            IsAESpell(spell_id) ||
-            IsAERainNukeSpell(spell_id) ||
-            IsAERainSpell(spell_id) ||
-            IsPBAESpell(spell_id) ||
-            IsPBAENukeSpell(spell_id)
-        )
-    );
+	if (!IsValidSpell(spell_id)) {
+		return false;
+	}
+
+	return (
+		IsTargetableAESpell(spell_id) ||
+		IsAESpell(spell_id) ||
+		IsPBAESpell(spell_id) ||
+		IsAEDurationSpell(spell_id) ||
+		IsAERainNukeSpell(spell_id) ||
+		IsAERainSpell(spell_id) ||
+		IsPBAENukeSpell(spell_id)
+	);
 }

 bool IsAESpell(uint16 spell_id)
@@ -740,8 +749,8 @@ bool IsPBAESpell(uint16 spell_id)

 	if (
 		spell.aoe_range > 0 &&
-		spell.target_type == ST_AECaster
-		) {
+		!IsTargetRequiredForSpell(spell_id)
+	) {
 		return true;
 	}

@@ -743,7 +743,7 @@ namespace BotSpellTypes
 	constexpr uint16	DISCIPLINE_END             = BotSpellTypes::DiscUtility;      // Do not remove this, increment as needed
 }

-static std::map<uint16, std::string> spellType_names = {
+static std::map<uint16, std::string> spell_type_names = {
 	{ BotSpellTypes::Nuke,                     "Nuke" },
 	{ BotSpellTypes::RegularHeal,              "Regular Heal" },
 	{ BotSpellTypes::Root,                     "Root" },
@@ -818,7 +818,7 @@ static std::map<uint16, std::string> spellType_names = {
 	{ BotSpellTypes::AELull,                   "AE Lull" }
 };

-static std::map<uint16, std::string> spellType_shortNames = {
+static std::map<uint16, std::string> spell_type_short_names = {
 	{ BotSpellTypes::Nuke,                     "nukes" },
 	{ BotSpellTypes::RegularHeal,              "regularheals" },
 	{ BotSpellTypes::Root,                     "roots" },
@@ -900,7 +900,7 @@ const uint32 SPELL_TYPES_INNATE = (SpellType_Nuke | SpellType_Lifetap | SpellTyp
 // Bot related functions
 bool IsBotSpellTypeDetrimental (uint16 spell_type);
 bool IsBotSpellTypeBeneficial (uint16 spell_type);
-bool IsBotSpellTypeOtherBeneficial(uint16 spell_type);
+bool BotSpellTypeUsesTargetSettings(uint16 spell_type);
 bool IsBotSpellTypeInnate (uint16 spell_type);
 bool IsAEBotSpellType(uint16 spell_type);
 bool IsGroupBotSpellType(uint16 spell_type);
@@ -90,7 +90,7 @@ bool IsBotSpellTypeBeneficial(uint16 spell_type) {
 	return false;
 }

-bool IsBotSpellTypeOtherBeneficial(uint16 spell_type) {
+bool BotSpellTypeUsesTargetSettings(uint16 spell_type) {
 	switch (spell_type) {
 		case BotSpellTypes::RegularHeal:
 		case BotSpellTypes::CompleteHeal:
@@ -912,3 +912,27 @@ std::string Strings::ZoneTime(const uint8 hours, const uint8 minutes)
 		hours >= 13 ? "PM" : "AM"
 	);
 }
+
+std::string Strings::Slugify(const std::string& input, const std::string& separator) {
+	std::string slug;
+	bool last_was_hyphen = false;
+
+	for (char c : input) {
+		if (std::isalnum(c)) {
+			slug += std::tolower(c);
+			last_was_hyphen = false;
+		} else if (c == ' ' || c == '_' || c == '-') {
+			if (!last_was_hyphen && !slug.empty()) {
+				slug += separator;
+				last_was_hyphen = true;
+			}
+		}
+	}
+
+	// Remove trailing hyphen if present
+	if (!slug.empty() && slug.back() == '-') {
+		slug.pop_back();
+	}
+
+	return slug;
+}
@@ -186,6 +186,8 @@ public:
 		value = strtod(tmp_str.data(), nullptr);
 		return res;
 	}
+
+	static std::string Slugify(const std::string &input, const std::string &separator = "-");
 };

 const std::string StringFormat(const char *format, ...);
@@ -25,7 +25,7 @@

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

-#define CURRENT_BINARY_DATABASE_VERSION 9302
+#define CURRENT_BINARY_DATABASE_VERSION 9309
 #define CURRENT_BINARY_BOTS_DATABASE_VERSION 9054

 #endif
@@ -143,7 +143,7 @@ void WorldServer::ProcessUserToWorldResponseLegacy(uint16_t opcode, const EQ::Ne
 		packet.ToString()
 	);

-	if (packet.Length() < sizeof(UsertoWorldResponseLegacy_Struct)) {
+	if (packet.Length() < sizeof(UsertoWorldResponseLegacy)) {
 		LogError(
 			"Received application packet from server that had opcode ServerOP_UsertoWorldResp, "
 			"but was too small. Discarded to avoid buffer overrun"
@@ -152,7 +152,7 @@ void WorldServer::ProcessUserToWorldResponseLegacy(uint16_t opcode, const EQ::Ne
 		return;
 	}

-	auto *res = (UsertoWorldResponseLegacy_Struct *) packet.Data();
+	auto *res = (UsertoWorldResponseLegacy *) packet.Data();

 	LogDebug("Trying to find client with user id of [{}]", res->lsaccountid);
 	Client *c = server.client_manager->GetClient(res->lsaccountid, "eqemu");
@@ -229,7 +229,7 @@ void WorldServer::ProcessUserToWorldResponse(uint16_t opcode, const EQ::Net::Pac
 		packet.ToString()
 	);

-	if (packet.Length() < sizeof(UsertoWorldResponse_Struct)) {
+	if (packet.Length() < sizeof(UsertoWorldResponse)) {
 		LogError(
 			"Received application packet from server that had opcode ServerOP_UsertoWorldResp, "
 			"but was too small. Discarded to avoid buffer overrun"
@@ -238,7 +238,7 @@ void WorldServer::ProcessUserToWorldResponse(uint16_t opcode, const EQ::Net::Pac
 		return;
 	}

-	auto res = (UsertoWorldResponse_Struct *) packet.Data();
+	auto res = (UsertoWorldResponse *) packet.Data();
 	LogDebug("Trying to find client with user id of [{}]", res->lsaccountid);

 	Client *c = server.client_manager->GetClient(
@@ -358,14 +358,12 @@ void WorldServer::ProcessLSAccountUpdate(uint16_t opcode, const EQ::Net::Packet
 void WorldServer::HandleNewWorldserver(LoginserverNewWorldRequest *req)
 {
 	if (m_is_server_logged_in) {
-		LogError(
-			"Login server was already marked as logged in, aborting"
-		);
+		LogInfo("Login server was already marked as logged in, returning");
 		return;
 	}

 	if (!HandleNewWorldserverValidation(req)) {
-		LogError("WorldServer::HandleNewWorldserver failed validation rules");
+		LogError("failed validation rules");
 		return;
 	}

@@ -494,7 +492,7 @@ void WorldServer::HandleWorldserverStatusUpdate(LoginserverWorldStatusUpdate *u)
 void WorldServer::SendClientAuthToWorld(Client *c)
 {
 	EQ::Net::DynamicPacket outapp;
-	ClientAuth_Struct      a{};
+	ClientAuth             a{};

 	a.loginserver_account_id = c->GetAccountID();

@@ -503,7 +501,7 @@ void WorldServer::SendClientAuthToWorld(Client *c)

 	a.lsadmin        = 0;
 	a.is_world_admin = 0;
-	a.ip             = inet_addr(c->GetConnection()->GetRemoteAddr().c_str());
+	a.ip_address     = inet_addr(c->GetConnection()->GetRemoteAddr().c_str());
 	strncpy(a.loginserver_name, &c->GetLoginServerName()[0], 64);

 	const std::string &client_address(c->GetConnection()->GetRemoteAddr());
@@ -521,7 +519,7 @@ void WorldServer::SendClientAuthToWorld(Client *c)
 	}

 	struct in_addr ip_addr{};
-	ip_addr.s_addr = a.ip;
+	ip_addr.s_addr = a.ip_address;

 	LogInfo(
 		"Client authentication response: world_address [{}] client_address [{}]",
@@ -80,7 +80,7 @@ private:
 	std::string  m_server_version;
 	bool         m_is_server_authorized_to_list;
 	bool         m_is_server_logged_in;
-	bool         m_is_server_trusted;
+	bool         m_is_server_trusted; // this is primarily for worldserver being able to push updates to the loginserver

 	static void FormatWorldServerName(char *name, int8 server_list_type);
 };
@@ -154,9 +154,9 @@ void WorldServerManager::SendUserLoginToWorldRequest(

 	if (iter != m_world_servers.end()) {
 		EQ::Net::DynamicPacket outapp;
-		outapp.Resize(sizeof(UsertoWorldRequest_Struct));
+		outapp.Resize(sizeof(UsertoWorldRequest));

-		auto *r = reinterpret_cast<UsertoWorldRequest_Struct *>(outapp.Data());
+		auto *r = reinterpret_cast<UsertoWorldRequest *>(outapp.Data());
 		r->worldid     = server_id;
 		r->lsaccountid = client_account_id;
 		strncpy(r->login, client_loginserver.c_str(), 64);
@@ -1,6 +1,6 @@
 {
  "name": "eqemu-server",
-  "version": "22.62.2",
+  "version": "23.1.0",
  "repository": {
    "type": "git",
    "url": "https://github.com/EQEmu/Server.git"
@@ -12,6 +12,7 @@
 #include "worldserver.h"
 #include "../common/events/player_events.h"
 #include "../common/events/player_event_logs.h"
+#include "../common/server_reload_types.h"
 #include <iomanip>
 #include <iostream>
 #include <stdarg.h>
@@ -72,9 +73,13 @@ void WorldServer::HandleMessage(uint16 opcode, const EQ::Net::Packet &p)
 		case 0: {
 			break;
 		}
-		case ServerOP_ReloadLogs: {
-			LogSys.LoadLogDatabaseSettings();
-			player_event_logs.ReloadSettings();
+		case ServerOP_ServerReloadRequest: {
+			auto o = (ServerReload::Request*) p.Data();
+			if (o->type == ServerReload::Type::Logs) {
+				LogSys.LoadLogDatabaseSettings();
+				player_event_logs.ReloadSettings();
+			}
+
 			break;
 		}
 		case ServerOP_QueryServGeneric: {
@@ -28,6 +28,7 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 #include "database.h"
 #include "../common/discord/discord_manager.h"
 #include "../common/events/player_event_logs.h"
+#include "../common/server_reload_types.h"

 #include <iostream>
 #include <string.h>
@@ -75,9 +76,13 @@ void WorldServer::ProcessMessage(uint16 opcode, EQ::Net::Packet &p)
 	{
 		break;
 	}
-	case ServerOP_ReloadLogs: {
-		LogSys.LoadLogDatabaseSettings();
-		player_event_logs.ReloadSettings();
+	case ServerOP_ServerReloadRequest: {
+		auto o = (ServerReload::Request*) pack->pBuffer;
+		if (o->type == ServerReload::Type::Logs) {
+			LogSys.LoadLogDatabaseSettings();
+			player_event_logs.ReloadSettings();
+		}
+
 		break;
 	}
 	case ServerOP_PlayerEvent: {
@@ -1,388 +0,0 @@
-## Ignore Visual Studio temporary files, build results, and
-## files generated by popular Visual Studio add-ons.
-##
-## Get latest from https://github.com/github/gitignore/blob/master/VisualStudio.gitignore
-
-# User-specific files
-*.rsuser
-*.suo
-*.user
-*.userosscache
-*.sln.docstates
-
-# User-specific files (MonoDevelop/Xamarin Studio)
-*.userprefs
-
-# Mono auto generated files
-mono_crash.*
-
-# Build results
-[Dd]ebug/
-[Dd]ebugPublic/
-[Rr]elease/
-[Rr]eleases/
-x64/
-x86/
-[Ww][Ii][Nn]32/
-[Aa][Rr][Mm]/
-[Aa][Rr][Mm]64/
-bld/
-[Bb]in/
-[Oo]bj/
-[Ll]og/
-[Ll]ogs/
-
-# Visual Studio 2015/2017 cache/options directory
-.vs/
-# Uncomment if you have tasks that create the project's static files in wwwroot
-#wwwroot/
-
-# Visual Studio 2017 auto generated files
-Generated\ Files/
-
-# MSTest test Results
-[Tt]est[Rr]esult*/
-[Bb]uild[Ll]og.*
-
-# NUnit
-*.VisualState.xml
-TestResult.xml
-nunit-*.xml
-
-# Build Results of an ATL Project
-[Dd]ebugPS/
-[Rr]eleasePS/
-dlldata.c
-
-# Benchmark Results
-BenchmarkDotNet.Artifacts/
-
-# .NET Core
-project.lock.json
-project.fragment.lock.json
-artifacts/
-
-# ASP.NET Scaffolding
-ScaffoldingReadMe.txt
-
-# StyleCop
-StyleCopReport.xml
-
-# Files built by Visual Studio
-*_i.c
-*_p.c
-*_h.h
-*.ilk
-*.meta
-*.obj
-*.iobj
-*.pch
-*.pdb
-*.ipdb
-*.pgc
-*.pgd
-*.rsp
-*.sbr
-*.tlb
-*.tli
-*.tlh
-*.tmp
-*.tmp_proj
-*_wpftmp.csproj
-*.log
-*.tlog
-*.vspscc
-*.vssscc
-.builds
-*.pidb
-*.svclog
-*.scc
-
-# Chutzpah Test files
-_Chutzpah*
-
-# Visual C++ cache files
-ipch/
-*.aps
-*.ncb
-*.opendb
-*.opensdf
-*.sdf
-*.cachefile
-*.VC.db
-*.VC.VC.opendb
-
-# Visual Studio profiler
-*.psess
-*.vsp
-*.vspx
-*.sap
-
-# Visual Studio Trace Files
-*.e2e
-
-# TFS 2012 Local Workspace
-$tf/
-
-# Guidance Automation Toolkit
-*.gpState
-
-# ReSharper is a .NET coding add-in
-_ReSharper*/
-*.[Rr]e[Ss]harper
-*.DotSettings.user
-
-# TeamCity is a build add-in
-_TeamCity*
-
-# DotCover is a Code Coverage Tool
-*.dotCover
-
-# AxoCover is a Code Coverage Tool
-.axoCover/*
-!.axoCover/settings.json
-
-# Coverlet is a free, cross platform Code Coverage Tool
-coverage*.json
-coverage*.xml
-coverage*.info
-
-# Visual Studio code coverage results
-*.coverage
-*.coveragexml
-
-# NCrunch
-_NCrunch_*
-.*crunch*.local.xml
-nCrunchTemp_*
-
-# MightyMoose
-*.mm.*
-AutoTest.Net/
-
-# Web workbench (sass)
-.sass-cache/
-
-# Installshield output folder
-[Ee]xpress/
-
-# DocProject is a documentation generator add-in
-DocProject/buildhelp/
-DocProject/Help/*.HxT
-DocProject/Help/*.HxC
-DocProject/Help/*.hhc
-DocProject/Help/*.hhk
-DocProject/Help/*.hhp
-DocProject/Help/Html2
-DocProject/Help/html
-
-# Click-Once directory
-publish/
-
-# Publish Web Output
-*.[Pp]ublish.xml
-*.azurePubxml
-# Note: Comment the next line if you want to checkin your web deploy settings,
-# but database connection strings (with potential passwords) will be unencrypted
-*.pubxml
-*.publishproj
-
-# Microsoft Azure Web App publish settings. Comment the next line if you want to
-# checkin your Azure Web App publish settings, but sensitive information contained
-# in these scripts will be unencrypted
-PublishScripts/
-
-# NuGet Packages
-*.nupkg
-# NuGet Symbol Packages
-*.snupkg
-# The packages folder can be ignored because of Package Restore
-**/[Pp]ackages/*
-# except build/, which is used as an MSBuild target.
-!**/[Pp]ackages/build/
-# Uncomment if necessary however generally it will be regenerated when needed
-#!**/[Pp]ackages/repositories.config
-# NuGet v3's project.json files produces more ignorable files
-*.nuget.props
-*.nuget.targets
-
-# Nuget personal access tokens and Credentials
-nuget.config
-
-# Microsoft Azure Build Output
-csx/
-*.build.csdef
-
-# Microsoft Azure Emulator
-ecf/
-rcf/
-
-# Windows Store app package directories and files
-AppPackages/
-BundleArtifacts/
-Package.StoreAssociation.xml
-_pkginfo.txt
-*.appx
-*.appxbundle
-*.appxupload
-
-# Visual Studio cache files
-# files ending in .cache can be ignored
-*.[Cc]ache
-# but keep track of directories ending in .cache
-!?*.[Cc]ache/
-
-# Others
-ClientBin/
-~$*
-*~
-*.dbmdl
-*.dbproj.schemaview
-*.jfm
-*.pfx
-*.publishsettings
-orleans.codegen.cs
-
-# Including strong name files can present a security risk
-# (https://github.com/github/gitignore/pull/2483#issue-259490424)
-#*.snk
-
-# Since there are multiple workflows, uncomment next line to ignore bower_components
-# (https://github.com/github/gitignore/pull/1529#issuecomment-104372622)
-#bower_components/
-
-# RIA/Silverlight projects
-Generated_Code/
-
-# Backup & report files from converting an old project file
-# to a newer Visual Studio version. Backup files are not needed,
-# because we have git ;-)
-_UpgradeReport_Files/
-Backup*/
-UpgradeLog*.XML
-UpgradeLog*.htm
-ServiceFabricBackup/
-*.rptproj.bak
-
-# SQL Server files
-*.mdf
-*.ldf
-*.ndf
-
-# Business Intelligence projects
-*.rdl.data
-*.bim.layout
-*.bim_*.settings
-*.rptproj.rsuser
-*- [Bb]ackup.rdl
-*- [Bb]ackup ([0-9]).rdl
-*- [Bb]ackup ([0-9][0-9]).rdl
-
-# Microsoft Fakes
-FakesAssemblies/
-
-# GhostDoc plugin setting file
-*.GhostDoc.xml
-
-# Node.js Tools for Visual Studio
-.ntvs_analysis.dat
-node_modules/
-
-# Visual Studio 6 build log
-*.plg
-
-# Visual Studio 6 workspace options file
-*.opt
-
-# Visual Studio 6 auto-generated workspace file (contains which files were open etc.)
-*.vbw
-
-# Visual Studio LightSwitch build output
-**/*.HTMLClient/GeneratedArtifacts
-**/*.DesktopClient/GeneratedArtifacts
-**/*.DesktopClient/ModelManifest.xml
-**/*.Server/GeneratedArtifacts
-**/*.Server/ModelManifest.xml
-_Pvt_Extensions
-
-# Paket dependency manager
-.paket/paket.exe
-paket-files/
-
-# FAKE - F# Make
-.fake/
-
-# CodeRush personal settings
-.cr/personal
-
-# Python Tools for Visual Studio (PTVS)
-__pycache__/
-*.pyc
-
-# Cake - Uncomment if you are using it
-# tools/**
-# !tools/packages.config
-
-# Tabs Studio
-*.tss
-
-# Telerik's JustMock configuration file
-*.jmconfig
-
-# BizTalk build output
-*.btp.cs
-*.btm.cs
-*.odx.cs
-*.xsd.cs
-
-# OpenCover UI analysis results
-OpenCover/
-
-# Azure Stream Analytics local run output
-ASALocalRun/
-
-# MSBuild Binary and Structured Log
-*.binlog
-
-# NVidia Nsight GPU debugger configuration file
-*.nvuser
-
-# MFractors (Xamarin productivity tool) working folder
-.mfractor/
-
-# Local History for Visual Studio
-.localhistory/
-
-# BeatPulse healthcheck temp database
-healthchecksdb
-
-# Backup folder for Package Reference Convert tool in Visual Studio 2017
-MigrationBackup/
-
-# Ionide (cross platform F# VS Code tools) working folder
-.ionide/
-
-# Fody - auto-generated XML schema
-FodyWeavers.xsd
-
-# VS Code files for those working on multiple tools
-.vscode/*
-!.vscode/settings.json
-!.vscode/tasks.json
-!.vscode/launch.json
-!.vscode/extensions.json
-*.code-workspace
-
-# Local History for Visual Studio Code
-.history/
-
-# Windows Installer files from build outputs
-*.cab
-*.msi
-*.msix
-*.msm
-*.msp
-
-# JetBrains Rider
-.idea/
-*.sln.iml
@@ -1,12 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace StreamParser.Common.Analyze
-{
-    public class PatchManager
-    {
-    }
-}
@@ -1,621 +0,0 @@
-using Ionic.Zlib;
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Net;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace StreamParser.Common.Daybreak
-{
-    public class Connection : IConnection
-    {
-        private class EncodeType
-        {
-            public const int None = 0;
-            public const int Compression = 1;
-            public const int XOR = 4;
-        }
-
-        private enum SequenceOrder
-        {
-            Past,
-            Current,
-            Future
-        }
-
-        private readonly IParser _owner;
-        private readonly IPAddress _srcAddr;
-        private readonly int _srcPort;
-        private readonly IPAddress _dstAddr;
-        private readonly int _dstPort;
-        private readonly Util.Crc32 _crc_generator = new Util.Crc32();
-        private readonly Guid _id = Guid.NewGuid();
-        private uint _connect_code = 0;
-        private int _encode_key = 0;
-        private int _crc_bytes = 0;
-        private int[] _encode_pass = new int[2] { 0, 0 };
-        private ConnectionStream[] _client_streams = new ConnectionStream[4] {
-            new ConnectionStream(),
-            new ConnectionStream(),
-            new ConnectionStream(),
-            new ConnectionStream()
-        };
-        private ConnectionStream[] _server_streams = new ConnectionStream[4] {
-            new ConnectionStream(),
-            new ConnectionStream(),
-            new ConnectionStream(),
-            new ConnectionStream()
-        };
-
-        public IConnection.OnPacketRecvHandler OnPacketRecv { get; set; }
-
-        public IPAddress ClientAddress => _srcAddr;
-        public int ClientPort => _srcPort;
-        public IPAddress ServerAddress => _dstAddr;
-        public int ServerPort => _dstPort;
-        public Guid Id => _id;
-
-        public ConnectionType ConnectionType {
-            get
-            {
-                //World servers used to be coded to always be 9000 but live started using dynamic ports
-                //I've seen from 9000 to 9008 on live
-                if (_dstPort >= 9000 && _dstPort <= 9010)
-                {
-                    return ConnectionType.World;
-                }
-                else if (_encode_pass[0] == EncodeType.None && _encode_pass[1] == EncodeType.None)
-                {
-                    return ConnectionType.Login;
-                }
-                else if (_encode_pass[0] == EncodeType.XOR && _encode_pass[1] == EncodeType.None)
-                {
-                    return ConnectionType.Chat;
-                }
-                else if (_encode_pass[0] == EncodeType.Compression && _encode_pass[1] == EncodeType.None)
-                {
-                    return ConnectionType.Zone;
-                }
-
-                return ConnectionType.Unknown;
-            }
-        }
-
-        public Connection(IParser owner, IPAddress srcAddr, int srcPort, IPAddress dstAddr, int dstPort)
-        {
-            _owner = owner;
-            _srcAddr = srcAddr;
-            _srcPort = srcPort;
-            _dstAddr = dstAddr;
-            _dstPort = dstPort;
-        }
-
-        public void ProcessPacket(IPAddress srcAddr, int srcPort, DateTime packetTime, ReadOnlySpan<byte> data)
-        {
-            if (data.Length < 1)
-            {
-                return;
-            }
-
-            var opcode = data[1];
-            if (data[0] == 0 && (opcode == Opcode.KeepAlive || opcode == Opcode.OutboundPing))
-            {
-                return;
-            }
-
-            if (PacketCanBeDecoded(data))
-            {
-                if (!ValidateCRC(data))
-                {
-                    return;
-                }
-
-                if (_encode_pass[0] == EncodeType.None && _encode_pass[1] == EncodeType.None)
-                {
-                    ProcessDecodedPacket(srcAddr, srcPort, packetTime, data.Slice(0, data.Length - _crc_bytes));
-                }
-                else
-                {
-                    //unfortunately we can't avoid a copy here
-                    var temp = data.Slice(0, data.Length - _crc_bytes).ToArray();
-                    for (int i = 1; i >= 0; --i)
-                    {
-                        switch(_encode_pass[i])
-                        {
-                            case EncodeType.Compression:
-                                if(temp[0] == 0)
-                                {
-                                    temp = Decompress(temp, 2, temp.Length - 2);
-                                }
-                                else
-                                {
-                                    temp = Decompress(temp, 1, temp.Length - 1);
-                                }
-                                break;
-                            case EncodeType.XOR:
-                                if (temp[0] == 0)
-                                {
-                                    temp = Decode(temp, 2, temp.Length - 2);
-                                }
-                                else
-                                {
-                                    temp = Decode(temp, 1, temp.Length - 1);
-                                }
-                                break;
-                        }
-                    }
-
-                    ProcessDecodedPacket(srcAddr, srcPort, packetTime, temp);
-                }
-            }
-            else
-            {
-                ProcessDecodedPacket(srcAddr, srcPort, packetTime, data);
-            }
-        }
-
-        private void ProcessDecodedPacket(IPAddress srcAddr, int srcPort, DateTime packetTime, ReadOnlySpan<byte> data)
-        {
-            if (data.Length < 1)
-            {
-                return;
-            }
-
-            if (data[0] == 0)
-            {
-                if (data.Length < 2)
-                {
-                    return;
-                }
-
-                var opcode = data[1];
-                switch (opcode)
-                {
-                    case Opcode.SessionResponse:
-                        if (_connect_code == 0)
-                        {
-                            //if(data.Length != 21)
-                            //{
-                            //    return;
-                            //}
-
-                            _connect_code = BitConverter.ToUInt32(data.Slice(2, 4));
-                            _encode_key = IPAddress.NetworkToHostOrder(BitConverter.ToInt32(data.Slice(6, 4)));
-                            _crc_bytes = data[10];
-                            _encode_pass[0] = data[11];
-                            _encode_pass[1] = data[12];
-                            _owner.OnNewConnection?.Invoke(this, packetTime);
-                        }
-                        break;
-                    case Opcode.SessionDisconnect:
-                        if(_connect_code != 0)
-                        {
-                            _connect_code = 0;
-                            _encode_key = 0;
-                            _crc_bytes = 0;
-                            _encode_pass[0] = 0;
-                            _encode_pass[1] = 0;
-                            _owner.OnLostConnection?.Invoke(this, packetTime);
-                        }
-                        break;
-                    case Opcode.Combined:
-                        {
-                            int current = 2;
-                            int end = data.Length;
-                            while (current < end)
-                            {
-                                byte subpacket_length = data[current];
-                                current += 1;
-
-                                if (end < current + subpacket_length)
-                                {
-                                    return;
-                                }
-
-                                var subpacket = data.Slice(current, subpacket_length);
-                                ProcessDecodedPacket(srcAddr, srcPort, packetTime, subpacket);
-                                current += subpacket_length;
-                            }
-                        }
-                        break;
-                    case Opcode.AppCombined:
-                        {
-                            int current = 2;
-                            int end = data.Length;
-                            while (current < end)
-                            {
-                                int subpacket_length = 0;
-                                if (data[current] == 0xff)
-                                {
-                                    if (end < current + 3)
-                                    {
-                                        return;
-                                    }
-
-                                    if (data[current + 1] == 0xff && data[current + 2] == 0xff)
-                                    {
-                                        if (end < current + 7)
-                                        {
-                                            return;
-                                        }
-
-                                        subpacket_length =
-                                            ((data[current + 3]) << 24) |
-                                            ((data[current + 4]) << 16) |
-                                            ((data[current + 5]) << 8) |
-                                            (data[current + 6]);
-
-                                        current += 7;
-                                    }
-                                    else
-                                    {
-                                        subpacket_length =
-                                            ((data[current + 1]) << 8) |
-                                            (data[current + 2]);
-
-                                        current += 3;
-                                    }
-                                }
-                                else
-                                {
-                                    subpacket_length = data[current];
-                                    current += 1;
-                                }
-
-                                var subpacket = data.Slice(current, subpacket_length);
-                                ProcessDecodedPacket(srcAddr, srcPort, packetTime, subpacket);
-                                current += subpacket_length;
-                            }
-                        }
-                        break;
-                    case Opcode.Packet:
-                    case Opcode.Packet2:
-                    case Opcode.Packet3:
-                    case Opcode.Packet4:
-                        {
-                            var stream_id = opcode - Opcode.Packet;
-                            var stream = FindStream(srcAddr, srcPort, stream_id);
-                            var sequence = (ushort)IPAddress.NetworkToHostOrder(BitConverter.ToInt16(data.Slice(2, 2)));
-                            var order = CompareSequence(stream.Sequence, sequence);
-                            if (order == SequenceOrder.Future)
-                            {
-                                if (!stream.PacketQueue.ContainsKey(sequence))
-                                {
-                                    stream.PacketQueue.Add(sequence, new ConnectionStream.QueuedPacket
-                                    {
-                                        Data = data.ToArray(),
-                                        PacketTime = packetTime
-                                    });
-                                }
-                            }
-                            else if (order == SequenceOrder.Current)
-                            {
-                                if (stream.PacketQueue.ContainsKey(sequence))
-                                {
-                                    stream.PacketQueue.Remove(sequence);
-                                }
-
-                                stream.Sequence++;
-                                ProcessDecodedPacket(srcAddr, srcPort, packetTime, data.Slice(4));
-                                ProcessQueue(srcAddr, srcPort, stream_id);
-                            }
-                        }
-                        break;
-                    case Opcode.Fragment:
-                    case Opcode.Fragment2:
-                    case Opcode.Fragment3:
-                    case Opcode.Fragment4:
-                        {
-                            var stream_id = opcode - Opcode.Fragment;
-                            var stream = FindStream(srcAddr, srcPort, stream_id);
-                            var sequence = (ushort)IPAddress.NetworkToHostOrder(BitConverter.ToInt16(data.Slice(2, 2)));
-                            var order = CompareSequence(stream.Sequence, sequence);
-                            if (order == SequenceOrder.Future)
-                            {
-                                if (!stream.PacketQueue.ContainsKey(sequence))
-                                {
-                                    stream.PacketQueue.Add(sequence, new ConnectionStream.QueuedPacket
-                                    {
-                                        Data = data.ToArray(),
-                                        PacketTime = packetTime
-                                    });
-                                }
-                            }
-                            else if (order == SequenceOrder.Current)
-                            {
-                                if (stream.PacketQueue.ContainsKey(sequence))
-                                {
-                                    stream.PacketQueue.Remove(sequence);
-                                }
-
-                                stream.Sequence++;
-
-                                if (stream.TotalFragmentedBytes == 0)
-                                {
-                                    stream.TotalFragmentedBytes = (uint)IPAddress.NetworkToHostOrder(BitConverter.ToInt32(data.Slice(4, 4)));
-                                    stream.CurrentFragmentedBytes = (uint)(data.Length - 8);
-
-                                    if(stream.FragmentBuffer == null || stream.FragmentBuffer.Length < (stream.TotalFragmentedBytes + 512))
-                                    {
-                                        stream.FragmentBuffer = new byte[stream.TotalFragmentedBytes + 512];
-                                    }
-
-                                    var target = stream.FragmentBuffer.AsSpan();
-                                    data.Slice(8).CopyTo(target);
-                                } else
-                                {
-                                    var target = stream.FragmentBuffer.AsSpan((int)stream.CurrentFragmentedBytes);
-                                    data.Slice(4).CopyTo(target);
-
-                                    stream.CurrentFragmentedBytes += (uint)(data.Length - 4);
-
-                                    if (stream.CurrentFragmentedBytes >= stream.TotalFragmentedBytes)
-                                    {
-                                        ProcessDecodedPacket(srcAddr, srcPort, packetTime,
-                                            stream.FragmentBuffer.AsSpan(0, (int)stream.TotalFragmentedBytes));
-                                        stream.CurrentFragmentedBytes = 0;
-                                        stream.TotalFragmentedBytes = 0;
-                                    }
-                                }
-
-                                ProcessQueue(srcAddr, srcPort, stream_id);
-                            }
-
-                        }
-                        break;
-                    case Opcode.Padding:
-                        OnPacketRecv?.Invoke(this, GetDirection(srcAddr, srcPort), packetTime, data.Slice(1));
-                        break;
-                    default:
-                        break;
-                }
-            } else
-            {
-                OnPacketRecv?.Invoke(this, GetDirection(srcAddr, srcPort), packetTime, data);
-            }
-        }
-
-        private void ProcessQueue(IPAddress srcAddr, int srcPort, int stream_id)
-        {
-            var stream = FindStream(srcAddr, srcPort, stream_id);
-            var sequence = stream.Sequence;
-
-            //try to get the current sequence in the queue, if it exists then process it
-            ConnectionStream.QueuedPacket value;
-            if(stream.PacketQueue.TryGetValue(sequence, out value))
-            {
-                ProcessDecodedPacket(srcAddr, srcPort, value.PacketTime, value.Data);
-            }
-        }
-
-        public bool Match(IPAddress srcAddr, int srcPort, IPAddress dstAddr, int dstPort)
-        {
-            var p1 = _srcAddr.Equals(srcAddr) && _srcPort == srcPort && _dstAddr.Equals(dstAddr) && _dstPort == dstPort;
-            var p2 = _srcAddr.Equals(dstAddr) && _srcPort == dstPort && _dstAddr.Equals(srcAddr) && _dstPort == srcPort;
-            return p1 || p2;
-        }
-
-        private SequenceOrder CompareSequence(ushort expected, ushort actual)
-        {
-            int diff = (int)actual - (int)expected;
-
-            if (diff == 0)
-            {
-                return SequenceOrder.Current;
-            }
-
-            if (diff > 0)
-            {
-                if (diff > 10000)
-                {
-                    return SequenceOrder.Past;
-                }
-
-                return SequenceOrder.Future;
-            }
-
-            if (diff < -10000)
-            {
-                return SequenceOrder.Future;
-            }
-
-            return SequenceOrder.Past;
-        }
-
-        private bool PacketCanBeDecoded(ReadOnlySpan<byte> p)
-        {
-            if (p.Length < 2)
-            {
-                return false;
-            }
-
-            if (p[0] != 0)
-            {
-                return true;
-            }
-
-            var opcode = p[1];
-
-            if (opcode == Opcode.SessionRequest || opcode == Opcode.SessionResponse || opcode == Opcode.OutOfSession)
-            {
-                return false;
-            }
-
-            return true;
-        }
-
-        private bool ValidateCRC(ReadOnlySpan<byte> p)
-        {
-            try
-            {
-                if (_crc_bytes == 0)
-                {
-                    return true;
-                }
-
-                int actual = 0;
-                int calculated = _crc_generator.Calculate(p.Slice(0, p.Length - _crc_bytes), _encode_key);
-                switch (_crc_bytes)
-                {
-                    case 2:
-                        actual = IPAddress.NetworkToHostOrder(BitConverter.ToInt16(p.Slice(p.Length - 2, 2))) & 0xFFFF;
-                        calculated = calculated & 0xFFFF;
-                        break;
-                    case 4:
-                        actual = IPAddress.NetworkToHostOrder(BitConverter.ToInt32(p.Slice(p.Length - 4, 4)));
-                        break;
-                    default:
-                        return false;
-                }
-
-                return actual == calculated;
-            } catch(Exception ex)
-            {
-                return false;
-            }
-        }
-
-        private byte[] Decompress(byte[] p, int offset, int length)
-        {
-            if (length < 2)
-            {
-                return p;
-            }
-
-            Span<byte> header = p.AsSpan(0, offset);
-            byte flag = p[offset];
-            Span<byte> payload = p.AsSpan(offset + 1, length - 1);
-
-            if (flag == 0x5a)
-            {
-                var pl = payload.ToArray();
-                var inflated = Inflate(payload.ToArray());
-                byte[] ret = new byte[offset + inflated.Length];
-                Array.Copy(p, 0, ret, 0, offset);
-                Array.Copy(inflated, 0, ret, offset, inflated.Length);
-                return ret;
-            }
-            else if (flag == 0xa5)
-            {
-                byte[] ret = new byte[offset + length - 1];
-                Array.Copy(p, 0, ret, 0, offset);
-                Array.Copy(p, offset + 1, ret, offset, length - 1);
-                return ret;
-            }
-            else
-            {
-                return p;
-            }
-        }
-
-        private byte[] Inflate(byte[] p)
-        {
-            try
-            {
-                using (var out_stream = new MemoryStream())
-                {
-                    using (var in_stream = new MemoryStream(p))
-                    {
-                        var buffer = new byte[512];
-                        using (var zs = new ZlibStream(in_stream, CompressionMode.Decompress))
-                        {
-                            int r = 0;
-                            do
-                            {
-                                r = zs.Read(buffer, 0, 512);
-                                out_stream.Write(buffer, 0, r);
-                            } while (r == 512);
-                        }
-                    }
-
-                    var ret = out_stream.ToArray();
-                    return ret;
-                }
-            }
-            catch (Exception)
-            {
-                return null;
-            }
-        }
-
-        private byte[] Decode(byte[] p, int offset, int length)
-        {
-            int key = _encode_key;
-            Span<byte> buffer = p.AsSpan(offset, length);
-            int i = 0;
-            for (i = 0; i + 4 <= length; i += 4)
-            {
-                int pt = BitConverter.ToInt32(buffer.Slice(i)) ^ key;
-                key = BitConverter.ToInt32(buffer.Slice(i));
-
-                if(BitConverter.TryWriteBytes(buffer.Slice(i), pt) == false)
-                {
-                    throw new Exception("Error writing bytes back in decode.");
-                }
-            }
-
-            byte kc = (byte)(key & 0xFF);
-            for (; i < length; i++)
-            {
-                buffer[i] = (byte)(buffer[i] ^ kc);
-            }
-
-            return p;
-        }
-
-        private Direction GetDirection(IPAddress srcAddr, int srcPort)
-        {
-            if(srcAddr.Equals(_srcAddr) && srcPort == _srcPort)
-            {
-                return Direction.ClientToServer;
-            } else
-            {
-                return Direction.ServerToClient;
-            }
-        }
-
-        private ConnectionStream FindStream(IPAddress srcAddr, int srcPort, int index)
-        {
-            if (index < 0 || index > 3)
-            {
-                return null;
-            }
-
-            var dir = GetDirection(srcAddr, srcPort);
-
-            if(dir == Direction.ClientToServer)
-            {
-                return _client_streams[index];
-            } else
-            {
-                return _server_streams[index];
-            }
-        }
-
-        private class ConnectionStream
-        {
-            public class QueuedPacket
-            {
-                public byte[] Data { get; set; }
-                public DateTime PacketTime { get; set; }
-            }
-
-            public ConnectionStream()
-            {
-                Sequence = 0;
-                CurrentFragmentedBytes = 0;
-                TotalFragmentedBytes = 0;
-                FragmentBuffer = null;
-                PacketQueue = new Dictionary<ushort, QueuedPacket>();
-            }
-
-            public ushort Sequence { get; set; }
-            public uint CurrentFragmentedBytes { get; set; }
-            public uint TotalFragmentedBytes { get; set; }
-            public byte[] FragmentBuffer { get; set; }
-            public Dictionary<ushort, QueuedPacket> PacketQueue { get; set; }
-        }
-    }
-}
@@ -1,114 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace StreamParser.Common.Daybreak
-{
-    public ref struct GamePacket
-    {
-        private readonly ReadOnlySpan<byte> _data;
-
-        public GamePacket(ReadOnlySpan<byte> data)
-        {
-            _data = data;
-        }
-
-        public readonly override string ToString()
-        {
-            return ToString(16);
-        }
-
-        public readonly string ToString(int columns)
-        {
-            int rows = _data.Length / columns;
-            if (_data.Length % columns != 0)
-            {
-                rows += 1;
-            }
-
-            int expected = (10 + columns * 4) * rows;
-            var sb = new StringBuilder(expected);
-
-            for(var i = 0; i < rows; ++i)
-            {
-                sb.AppendFormat("{0} |", (i * columns).ToString("X5"));
-
-                for(var j = 0; j < columns; ++j)
-                {
-                    var index = (i * 16) + j;
-                    if (index >= _data.Length)
-                    {
-                        sb.Append("   ");
-                    } else
-                    {
-                        var c = _data[index];
-                        sb.AppendFormat("{0,3}", c.ToString("X2"));
-                    }
-                }
-
-                sb.Append(" | ");
-
-                for (var j = 0; j < columns; ++j)
-                {
-                    var index = (i * 16) + j;
-                    if (index >= _data.Length)
-                    {
-                        sb.Append(" ");
-                    }
-                    else
-                    {
-                        var c = _data[index];
-                        var ch = (char)c;
-                        if (char.IsLetterOrDigit(ch) || char.IsPunctuation(ch) || char.IsSymbol(ch) || (ch == ' '))
-                        {
-                            sb.Append(ch);
-                        }
-                        else
-                        {
-                            sb.Append(".");
-                        }
-                    }
-                }
-
-                sb.AppendLine();
-            }
-
-            return sb.ToString();
-        }
-
-        public readonly string ToModelString(int max_taken, bool hex)
-        {
-            int expected = Math.Min(_data.Length, max_taken) * (hex ? 2 : 1);
-            if(expected <= 0)
-            {
-                return string.Empty;
-            }
-
-            var sb = new StringBuilder(expected);
-
-            for(var i = 0; i < Math.Min(_data.Length, max_taken); ++i)
-            {
-                var c = _data[i];
-                if(hex)
-                {
-                    sb.Append(c.ToString("X2"));
-                } else
-                {
-                    var ch = (char)c;
-                    if (char.IsLetterOrDigit(ch) || char.IsPunctuation(ch) || char.IsSymbol(ch) || (ch == ' '))
-                    {
-                        sb.Append(ch);
-                    }
-                    else
-                    {
-                        sb.Append(".");
-                    }
-                }
-            }
-
-            return sb.ToString();
-        }
-    }
-}
@@ -1,40 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Net;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace StreamParser.Common.Daybreak
-{
-    public enum Direction
-    {
-        ClientToServer,
-        ServerToClient
-    }
-
-    public enum ConnectionType
-    {
-        Unknown,
-        Login,
-        World,
-        Chat,
-        Zone
-    }
-
-    public interface IConnection
-    {
-        delegate void OnPacketRecvHandler(Connection connection, Direction direction, DateTime packetTime, ReadOnlySpan<byte> data);
-        OnPacketRecvHandler OnPacketRecv { get; set; }
-
-        void ProcessPacket(IPAddress srcAddr, int srcPort, DateTime packetTime, ReadOnlySpan<byte> data);
-        bool Match(IPAddress srcAddr, int srcPort, IPAddress dstAddr, int dstPort);
-
-        ConnectionType ConnectionType { get; }
-        IPAddress ClientAddress { get; }
-        int ClientPort { get; }
-        IPAddress ServerAddress { get; }
-        int ServerPort { get; }
-        Guid Id { get; }
-    }
-}
@@ -1,16 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace StreamParser.Common.Daybreak
-{
-    public interface IParser
-    {
-        delegate void ConnectionHandler(IConnection connection, DateTime connectionTime);
-        ConnectionHandler OnNewConnection { get; set; }
-        ConnectionHandler OnLostConnection { get; set; }
-        void Parse(string filename);
-    }
-}
@@ -1,39 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace StreamParser.Common.Daybreak
-{
-    public class Opcode
-    {
-        public const byte Padding = 0;
-        public const byte SessionRequest = 1;
-        public const byte SessionResponse = 2;
-        public const byte Combined = 3;
-        public const byte SessionDisconnect = 5;
-        public const byte KeepAlive = 6;
-        public const byte SessionStatRequest = 7;
-        public const byte SessionStatResponse = 8;
-        public const byte Packet = 9;
-        public const byte Packet2 = 10;
-        public const byte Packet3 = 11;
-        public const byte Packet4 = 12;
-        public const byte Fragment = 13;
-        public const byte Fragment2 = 14;
-        public const byte Fragment3 = 15;
-        public const byte Fragment4 = 16;
-        public const byte OutOfOrderAck = 17;
-        public const byte OutOfOrderAck2 = 18;
-        public const byte OutOfOrderAck3 = 19;
-        public const byte OutOfOrderAck4 = 20;
-        public const byte Ack = 21;
-        public const byte Ack2 = 22;
-        public const byte Ack3 = 23;
-        public const byte Ack4 = 22;
-        public const byte AppCombined = 25;
-        public const byte OutboundPing = 28;
-        public const byte OutOfSession = 29;
-    }
-}
@@ -1,115 +0,0 @@
-using Microsoft.Extensions.Logging;
-using SharpPcap;
-using SharpPcap.LibPcap;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Net;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace StreamParser.Common.Daybreak
-{
-    public class Parser : IParser
-    {
-        /**
-         * Dependencies
-         */ 
-        private readonly ILogger<Parser> _logger;
-        private readonly List<IConnection> _connections = new List<IConnection>();
-
-        public IParser.ConnectionHandler OnNewConnection { get; set; }
-        public IParser.ConnectionHandler OnLostConnection { get; set; }
-
-        public Parser(ILogger<Parser> logger)
-        {
-            _logger = logger;
-        }
-
-        public void Parse(string filename)
-        {
-            ICaptureDevice device = null;
-            try
-            {
-                device = new CaptureFileReaderDevice(filename);
-                device.Open();
-
-                device.OnPacketArrival += new PacketArrivalEventHandler(OnPacketCapture);
-
-                device.Capture();
-                device.Close();
-            } catch(Exception ex)
-            {
-                _logger.LogError(ex, "Error reading device capture.");
-            }
-        }
-
-        private void OnPacketCapture(object sender, PacketCapture capture)
-        {
-            var raw = capture.GetPacket();
-            if (raw.LinkLayerType == PacketDotNet.LinkLayers.Ethernet || raw.LinkLayerType == PacketDotNet.LinkLayers.Null)
-            {
-                var packet = PacketDotNet.Packet.ParsePacket(raw.LinkLayerType, raw.Data);
-                var ipPacket = packet.Extract<PacketDotNet.IPv4Packet>();
-                var udpPacket = packet.Extract<PacketDotNet.UdpPacket>();
-
-                if (ipPacket != null && udpPacket != null)
-                {
-                    try
-                    {
-                        ProcessPacket(ipPacket.SourceAddress,
-                            udpPacket.SourcePort,
-                            ipPacket.DestinationAddress,
-                            udpPacket.DestinationPort,
-                            raw.Timeval.Date,
-                            udpPacket.PayloadData);
-                    } catch(Exception ex)
-                    {
-                        _logger.LogError(ex, "Error processing packet");
-                    }
-                }
-            }
-        }
-
-        private void ProcessPacket(IPAddress srcAddr, int srcPort, IPAddress dstAddr, int dstPort, DateTime packetTime, ReadOnlySpan<byte> data)
-        {
-            if(data.Length < 2)
-            {
-                _logger.LogTrace("Tossing packet, {0} was less than minimum packet size", data.Length);
-                return;
-            }
-
-            var c = FindConnection(srcAddr, srcPort, dstAddr, dstPort);
-
-            if(c != null)
-            {
-                c.ProcessPacket(srcAddr, srcPort, packetTime, data);
-            }
-            else if (data[0] == 0 && data[1] == Opcode.SessionRequest)
-            {
-                if(data.Length != 24)
-                {
-                    _logger.LogTrace("Tossing packet, {0} was not the right size for a SessionRequest", data.Length);
-                    return;
-                }
-
-                c = new Connection(this, srcAddr, srcPort, dstAddr, dstPort);
-                _connections.Add(c);
-                c.ProcessPacket(srcAddr, srcPort, packetTime, data);
-            }
-        }
-
-        private IConnection FindConnection(IPAddress srcAddr, int srcPort, IPAddress dstAddr, int dstPort)
-        {
-            foreach (var c in _connections)
-            {
-                if (c.Match(srcAddr, srcPort, dstAddr, dstPort))
-                {
-                    return c;
-                }
-            }
-
-            return null;
-        }
-    }
-}
@@ -1,103 +0,0 @@
-using System;
-
-namespace StreamParser.Common.Util
-{
-    public class Crc32
-    {
-        private uint[] _encodeTable =
-        {
-            0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA,
-            0x076DC419, 0x706AF48F, 0xE963A535, 0x9E6495A3,
-            0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988,
-            0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91,
-            0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE,
-            0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7,
-            0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC,
-            0x14015C4F, 0x63066CD9, 0xFA0F3D63, 0x8D080DF5,
-            0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172,
-            0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B,
-            0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940,
-            0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59,
-            0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116,
-            0x21B4F4B5, 0x56B3C423, 0xCFBA9599, 0xB8BDA50F,
-            0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924,
-            0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D,
-            0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A,
-            0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433,
-            0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818,
-            0x7F6A0DBB, 0x086D3D2D, 0x91646C97, 0xE6635C01,
-            0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E,
-            0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457,
-            0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA, 0xFCB9887C,
-            0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65,
-            0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2,
-            0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB,
-            0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0,
-            0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9,
-            0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086,
-            0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F,
-            0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4,
-            0x59B33D17, 0x2EB40D81, 0xB7BD5C3B, 0xC0BA6CAD,
-            0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A,
-            0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683,
-            0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8,
-            0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1,
-            0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE,
-            0xF762575D, 0x806567CB, 0x196C3671, 0x6E6B06E7,
-            0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC,
-            0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5,
-            0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252,
-            0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B,
-            0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60,
-            0xDF60EFC3, 0xA867DF55, 0x316E8EEF, 0x4669BE79,
-            0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236,
-            0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F,
-            0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04,
-            0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D,
-            0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A,
-            0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713,
-            0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38,
-            0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21,
-            0x86D3D2D4, 0xF1D4E242, 0x68DDB3F8, 0x1FDA836E,
-            0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777,
-            0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C,
-            0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45,
-            0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2,
-            0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB,
-            0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0,
-            0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9,
-            0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6,
-            0xBAD03605, 0xCDD70693, 0x54DE5729, 0x23D967BF,
-            0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94,
-            0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D
-        };
-
-        public int Calculate(ReadOnlySpan<byte> data)
-        {
-            uint crc = 0xffffffff;
-
-            for (int i = 0; i < data.Length; ++i)
-            {
-                crc = ((crc >> 8) & 0x00FFFFFF) ^ _encodeTable[(crc ^ data[i]) & 0x000000FF];
-            }
-
-            return (int)~crc;
-        }
-
-        public int Calculate(ReadOnlySpan<byte> data, int key)
-        {
-            uint crc = 0xffffffff;
-            for (int i = 0; i < 4; ++i)
-            {
-                crc = ((crc >> 8) & 0x00FFFFFF) ^ _encodeTable[(crc ^ ((key >> (i * 8)) & 0xff)) & 0x000000FF];
-            }
-
-            for (int i = 0; i < data.Length; ++i)
-            {
-                crc = ((crc >> 8) & 0x00FFFFFF) ^ _encodeTable[(crc ^ data[i]) & 0x000000FF];
-            }
-
-            return (int)~crc;
-        }
-    }
-}
@@ -1,14 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <TargetFramework>net6.0</TargetFramework>
-    <RootNamespace>StreamParser.Common</RootNamespace>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <PackageReference Include="Iconic.Zlib.Netstandard" Version="1.0.0" />
-    <PackageReference Include="Microsoft.Extensions.Hosting" Version="8.0.1" />
-    <PackageReference Include="SharpPcap" Version="6.3.0" />
-  </ItemGroup>
-
-</Project>
@@ -1,337 +0,0 @@
-using Microsoft.Extensions.Hosting;
-using Microsoft.Extensions.Logging;
-using StreamParser.Common.Daybreak;
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Net;
-using System.Threading;
-using System.Threading.Tasks;
-using CommandLine;
-using System.Globalization;
-using Org.BouncyCastle.Crypto.Engines;
-using Org.BouncyCastle.Crypto.Modes;
-using Org.BouncyCastle.Crypto;
-using Org.BouncyCastle.Crypto.Parameters;
-using Ionic.Zlib;
-
-namespace StreamParser
-{
-    public class ConsoleHostedService : IHostedService
-    {
-        private class ParsedPacket {
-            public byte[] Data { get; set; }
-            public Direction Direction { get; set; }
-            public DateTime Time { get; set; }
-        }
-
-        private class ParsedConnection
-        {
-            public IPAddress ClientAddress { get; set; }
-            public int ClientPort { get; set; }
-            public IPAddress ServerAddress { get; set; }
-            public int ServerPort { get; set; }
-            public ConnectionType ConnectionType { get; set; }
-            public List<ParsedPacket> Packets { get; set; }
-            public DateTime ConnectedTime { get; set; }
-            public DateTime? DisconnectedTime { get; set; }
-        }
-
-        private readonly ILogger<ConsoleHostedService> _logger;
-        private readonly IHostApplicationLifetime _applicationLifetime;
-        private readonly IParser _parser;
-        private readonly Dictionary<Guid, ParsedConnection> _connections = new Dictionary<Guid, ParsedConnection>();
-
-        public ConsoleHostedService(ILogger<ConsoleHostedService> logger,
-            IHostApplicationLifetime applicationLifetime,
-            IParser parser)
-        {
-            _logger = logger;
-            _applicationLifetime = applicationLifetime;
-            _parser = parser;
-        }
-
-        public Task StartAsync(CancellationToken cancellationToken)
-        {
-            _applicationLifetime.ApplicationStarted.Register(() =>
-            {
-                var args = Environment.GetCommandLineArgs();
-
-                try
-                {
-                    CommandLine.Parser.Default.ParseArguments<ConsoleHostedServiceOptions>(args)
-                       .WithParsed<ConsoleHostedServiceOptions>(o =>
-                       {
-                           _parser.OnNewConnection += OnNewConnection;
-                           _parser.OnLostConnection += OnLostConnection;
-
-                           foreach (var f in o.Input)
-                           {
-                               _logger.LogInformation("Parsing {0}...", f);
-                               _parser.Parse(f);
-                           }
-
-                           foreach (var c in _connections)
-                           {
-                               if (c.Value.ConnectionType == ConnectionType.Unknown && !o.DumpUnknownStreams)
-                               {
-                                   continue;
-                               }
-
-                               if (o.Text)
-                               {
-                                   DumpConnectionToTextFile(c.Value, o.Output, o.Decrypt, o.DecompressOpcodes);
-                               }
-                           }
-
-                           _applicationLifetime.StopApplication();
-                       })
-                       .WithNotParsed<ConsoleHostedServiceOptions>(e =>
-                       {
-                           bool stops_processing = false;
-                           foreach (var err in e)
-                           {
-                               stops_processing = stops_processing || err.StopsProcessing || err is MissingRequiredOptionError;
-                           }
-
-                           if (stops_processing)
-                           {
-                               _applicationLifetime.StopApplication();
-                           }
-                       });
-                } 
-                catch(Exception ex)
-                {
-                    _logger.LogError(ex, "Error parsing command line arguments");
-                    _applicationLifetime.StopApplication();
-                }
-            });
-
-            return Task.CompletedTask;
-        }
-
-        public Task StopAsync(CancellationToken cancellationToken)
-        {
-            return Task.CompletedTask;
-        }
-
-        private void OnNewConnection(IConnection connection, DateTime connectionTime)
-        {
-            _logger.LogTrace("New connection {0}:{1} <-> {2}:{3} of type {4}", 
-                connection.ClientAddress, 
-                connection.ClientPort, 
-                connection.ServerAddress, 
-                connection.ServerPort,
-                connection.ConnectionType);
-            connection.OnPacketRecv += OnPacketRecv;
-
-            _connections.Add(connection.Id, new ParsedConnection
-            {
-                ClientAddress = connection.ClientAddress,
-                ClientPort = connection.ClientPort,
-                ServerAddress = connection.ServerAddress,
-                ServerPort = connection.ServerPort,
-                ConnectionType = connection.ConnectionType,
-                Packets = new List<ParsedPacket>(),
-                ConnectedTime = connectionTime,
-            });
-        }
-
-        private void OnLostConnection(IConnection connection, DateTime connectionTime)
-        {
-            _logger.LogTrace("Lost connection {0}:{1} <-> {2}:{3}",
-                connection.ClientAddress,
-                connection.ClientPort,
-                connection.ServerAddress,
-                connection.ServerPort);
-            connection.OnPacketRecv -= OnPacketRecv;
-
-            var parsedConnection = _connections.GetValueOrDefault(connection.Id);
-            parsedConnection.DisconnectedTime = connectionTime;
-        }
-
-        private void OnPacketRecv(IConnection connection, Direction direction, DateTime packetTime, ReadOnlySpan<byte> data)
-        {
-            var parsedConnection = _connections.GetValueOrDefault(connection.Id);
-            parsedConnection.Packets.Add(new ParsedPacket
-            {
-                Data = data.ToArray(),
-                Direction = direction,
-                Time = packetTime
-            });
-        }
-
-        private void DumpConnectionToTextFile(ParsedConnection c, string output, bool decrypt, IEnumerable<int> decompressOpcodes)
-        {
-            try
-            {
-                var path = output + string.Format("{0}-{1}.txt", c.ConnectionType.ToString().ToLower(), c.ConnectedTime.ToString("yyyyMMddHHmmssfff"));
-                if (File.Exists(path))
-                {
-                    File.Delete(path);
-                }
-
-                File.AppendAllText(path, string.Format("### type: {0}\n", c.ConnectionType));
-                File.AppendAllText(path, string.Format("### started: {0}\n", c.ConnectedTime.ToString("s")));
-                File.AppendAllText(path, string.Format("### ended: {0}\n", c.DisconnectedTime.HasValue ? c.DisconnectedTime.Value.ToString("s") : "unknown"));
-                File.AppendAllText(path, string.Format("### client: {0}:{1}\n", c.ClientAddress.ToString(), c.ClientPort));
-                File.AppendAllText(path, string.Format("### server: {0}:{1}\n\n", c.ServerAddress.ToString(), c.ServerPort));
-
-                foreach(var p in c.Packets)
-                {
-                    ReadOnlySpan<byte> data = p.Data;
-                    string dir = p.Direction == Direction.ClientToServer ? "Client -> Server" : "Server -> Client";
-
-                    switch (c.ConnectionType)
-                    {
-                        case ConnectionType.Login:
-                            {
-                                int opcode = BitConverter.ToUInt16(data.Slice(0, 2));
-                                {
-                                    File.AppendAllText(path,
-                                    string.Format("{0} [Opcode: 0x{1}, Size: {2}] ({3})\n", dir, opcode.ToString("X4"), data.Length - 2, p.Time.ToString("s")));
-
-                                    var gp = new GamePacket(data.Slice(2));
-                                    File.AppendAllText(path, string.Format("{0}\n", gp.ToString()));
-
-                                    if(decrypt && opcode == 2 || opcode == 24)
-                                    {
-                                        var encrypted_block = data.Slice(12, data.Length - 12);
-                                        var dec = EQDecrypt(encrypted_block);
-
-                                        if(dec != null)
-                                        {
-                                            File.AppendAllText(path, string.Format("[Decrypted Data, Offset: {0}, Size: {1}]\n", 10, dec.Length));
-                                            gp = new GamePacket(dec);
-                                            File.AppendAllText(path, string.Format("{0}\n", gp.ToString()));
-                                        }
-                                    }
-                                }
-                            }
-                            break;
-                        case ConnectionType.Chat:
-                            {
-                                int opcode = data[0];
-                                File.AppendAllText(path, 
-                                    string.Format("{0} [Opcode: 0x{1}, Size: {2}] ({3})\n", dir, opcode.ToString("X2"), data.Length - 1, p.Time.ToString("s")));
-
-                                var gp = new GamePacket(data.Slice(1));
-                                File.AppendAllText(path, string.Format("{0}\n", gp.ToString()));
-                            }
-                            break;
-                        default:
-                            {
-                                bool reported_decompressed = false;
-                                int opcode = BitConverter.ToUInt16(data.Slice(0, 2));
-                                foreach (var decompressOpcode in decompressOpcodes)
-                                {
-                                    if (opcode == decompressOpcode && data.Length > 12)
-                                    {
-                                        if (data[10] == 0x78 && data[11] == 0xDA)
-                                        {
-                                            var totalLen = BitConverter.ToInt32(data.Slice(6, 4));
-                                            if (totalLen > 0)
-                                            {
-                                                var decompressed = Inflate(data.Slice(10));
-                                                if(decompressed != null)
-                                                {
-                                                    var decompressed_gp = new GamePacket(decompressed);
-                                                    File.AppendAllText(path,
-                                                        string.Format("{0} [Opcode: 0x{1}, Size (decompressed): {2}] ({3})\n", dir, opcode.ToString("X4"), totalLen, p.Time.ToString("s")));
-
-                                                    File.AppendAllText(path, string.Format("{0}\n", decompressed_gp.ToString()));
-                                                    reported_decompressed = true;
-                                                    break;
-                                                }
-                                            }
-                                        } 
-                                        else if (data[6] == 0x78 && data[7] == 0xDA)
-                                        {
-                                            var totalLen = BitConverter.ToInt32(data.Slice(2, 4));
-                                            if (totalLen > 0)
-                                            {
-                                                var decompressed = Inflate(data.Slice(6));
-                                                if (decompressed != null)
-                                                {
-                                                    File.AppendAllText(path,
-                                                        string.Format("{0} [Opcode: 0x{1}, Size (decompressed): {2}] ({3})\n", dir, opcode.ToString("X4"), totalLen, p.Time.ToString("s")));
-
-                                                    var decompressed_gp = new GamePacket(decompressed);
-                                                    File.AppendAllText(path, string.Format("{0}\n", decompressed_gp.ToString()));
-                                                    reported_decompressed = true;
-                                                    break;
-                                                }
-                                            }
-                                        }
-                                    }
-                                }
-
-                                if (!reported_decompressed)
-                                {
-                                    File.AppendAllText(path,
-                                        string.Format("{0} [Opcode: 0x{1}, Size: {2}] ({3})\n", dir, opcode.ToString("X4"), data.Length - 2, p.Time.ToString("s")));
-                                    var gp = new GamePacket(data.Slice(2));
-                                    File.AppendAllText(path, string.Format("{0}\n", gp.ToString()));
-                                }
-                            }
-                            break;
-                    }
-                }
-            }
-            catch(Exception ex)
-            {
-                _logger.LogError(ex, "Error dumping connection {0} to txt file", c.ConnectedTime.ToString("s"));
-            }
-        }
-
-        private byte[] Inflate(ReadOnlySpan<byte> data)
-        {
-            try
-            {
-                using (var out_stream = new MemoryStream())
-                using (var in_stream = new MemoryStream(data.ToArray()))
-                {
-                    const int bufferLen = 4096;
-                    var buffer = new byte[bufferLen];
-                    using (var zs = new ZlibStream(in_stream, CompressionMode.Decompress))
-                    {
-                        int r = 0;
-                        do
-                        {
-                            r = zs.Read(buffer, 0, bufferLen);
-                            out_stream.Write(buffer, 0, r);
-                        } while (r == bufferLen);
-                    }
-
-                    var ret = out_stream.ToArray();
-                    return ret;
-                }
-            }
-            catch (Exception ex)
-            {
-                _logger.LogError(ex, "Error inflating data");
-                return null;
-            }
-        }
-
-        private byte[] EQDecrypt(ReadOnlySpan<byte> data)
-        {
-            try
-            {
-                var desEngine = new DesEngine();
-                var cbcBlockCipher = new CbcBlockCipher(desEngine);
-                var bufferedBlockCipher = new BufferedBlockCipher(cbcBlockCipher);
-                bufferedBlockCipher.Init(false, new ParametersWithIV(new KeyParameter(new byte[16]), new byte[8]));
-                var cipherData = new byte[bufferedBlockCipher.GetOutputSize(data.Length)];
-                var outputLength = bufferedBlockCipher.ProcessBytes(data.ToArray(), 0, data.Length, cipherData, 0);
-                bufferedBlockCipher.DoFinal(cipherData, outputLength);
-                return cipherData;
-            }
-            catch (Exception ex)
-            {
-                _logger.LogError(ex, "Error decrypting EQ Datablock");
-                return null;
-            }
-        }
-    }
-}
@@ -1,26 +0,0 @@
-using System.Collections.Generic;
-using CommandLine;
-
-namespace StreamParser
-{
-    public class ConsoleHostedServiceOptions
-    {
-        [Option("input", Required = true, HelpText = "Input pcap files to be processed.")]
-        public IEnumerable<string> Input { get; set; }
-
-        [Option("output", Default = "output/", HelpText = "Directory to put output files")]
-        public string Output { get; set; }
-
-        [Option("text", Default = true, HelpText = "Dump connections to text files.")]
-        public bool Text { get; set; }
-
-        [Option("decrypt", Default = false, HelpText = "Decrypt the \"Encrypted\" packets.")]
-        public bool Decrypt { get; set; }
-
-        [Option("decompress", Default = null, HelpText = "Which opcodes to attempt to decompress")]
-        public IEnumerable<int> DecompressOpcodes { get; set; }
-
-        [Option("enable-unknown-streams", Default = false, HelpText = "Enable dumping of unknown streams; they will be skipped otherwise.")]
-        public bool DumpUnknownStreams { get; set; }
-    }
-}
@@ -1,25 +0,0 @@
-using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Hosting;
-using StreamParser.Common.Daybreak;
-using System;
-
-namespace StreamParser
-{
-    class Program
-    {
-        static void Main(string[] args)
-        {
-            CreateHostBuilder(args).Build().Run();
-        }
-
-        public static IHostBuilder CreateHostBuilder(string[] args)
-        {
-            return Host.CreateDefaultBuilder(args)
-                .ConfigureServices((hostContext, services) =>
-                {
-                    services.AddScoped<IParser, Parser>();
-                    services.AddHostedService<ConsoleHostedService>();
-                });
-        }
-    }
-}
@@ -1,8 +0,0 @@
-{
-  "profiles": {
-    "stream_parser": {
-      "commandName": "Project",
-      "commandLineArgs": "--input input/test.pcap --output output/ --text --decrypt"
-    }
-  }
-}
@@ -1,24 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <OutputType>Exe</OutputType>
-    <TargetFramework>net8.0</TargetFramework>
-    <RootNamespace>StreamParser</RootNamespace>
-  </PropertyGroup>
-
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
-    <AllowUnsafeBlocks>false</AllowUnsafeBlocks>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <PackageReference Include="CommandLineParser" Version="2.9.1" />
-    <PackageReference Include="CsvHelper" Version="33.0.1" />
-    <PackageReference Include="Microsoft.Extensions.Hosting" Version="8.0.1" />
-    <PackageReference Include="Portable.BouncyCastle" Version="1.9.0" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <ProjectReference Include="..\common\common.csproj" />
-  </ItemGroup>
-
-</Project>
@@ -11,8 +11,6 @@ SET(world_sources
    dynamic_zone_manager.cpp
    eql_config.cpp
    eqemu_api_world_data_service.cpp
-    expedition_database.cpp
-    expedition_message.cpp
    launcher_link.cpp
    launcher_list.cpp
    lfplist.cpp
@@ -48,8 +46,6 @@ SET(world_headers
    dynamic_zone_manager.h
    eql_config.h
    eqemu_api_world_data_service.h
-    expedition_database.h
-    expedition_message.h
    launcher_link.h
    launcher_list.h
    lfplist.h
@@ -447,30 +447,30 @@ void Client::SendPostEnterWorld() {

 bool Client::HandleSendLoginInfoPacket(const EQApplicationPacket *app)
 {
-	if (app->size != sizeof(LoginInfo_Struct)) {
+	if (app->size != sizeof(LoginInfo)) {
 		return false;
 	}

-	auto *login_info = (LoginInfo_Struct *) app->pBuffer;
+	auto *r = (LoginInfo *) app->pBuffer;

 	// Quagmire - max len for name is 18, pass 15
 	char name[19]     = {0};
 	char password[16] = {0};
-	strn0cpy(name, (char *) login_info->login_info, 18);
-	strn0cpy(password, (char *) &(login_info->login_info[strlen(name) + 1]), 15);
+	strn0cpy(name, (char *) r->login_info, 18);
+	strn0cpy(password, (char *) &(r->login_info[strlen(name) + 1]), 15);

-	LogDebug("Receiving Login Info Packet from Client | name [{0}] password [{1}]", name, password);
+	LogDebug("Receiving login info packet from client | name [{}] password [{}]", name, password);

 	if (strlen(password) <= 1) {
 		LogInfo("Login without a password");
 		return false;
 	}

-	is_player_zoning = (login_info->zoning == 1);
+	is_player_zoning = (r->zoning == 1);

 	uint32 id = Strings::ToInt(name);
 	if (id == 0) {
-		LogWarning("Receiving Login Info Packet from Client | account_id is 0 - disconnecting");
+		LogWarning("Receiving login info packet from client | account_id is 0 - disconnecting");
 		return false;
 	}

@@ -480,15 +480,15 @@ bool Client::HandleSendLoginInfoPacket(const EQApplicationPacket *app)
 		LogClientLogin("Checking authentication id [{}] passed", id);
 		if (!is_player_zoning) {
 			// Track who is in and who is out of the game
-			char *inout= (char *) "";
+			std::string in_out;

-			if (cle->GetOnline() == CLE_Status::Never){
+			if (cle->GetOnline() == CLE_Status::Never) {
 				// Desktop -> Char Select
-				inout = (char *) "In";
+				in_out = "in";
 			}
 			else {
 				// Game -> Char Select
-				inout=(char *) "Out";
+				in_out = "out";
 			}

 			// Always at Char select at this point.
@@ -497,7 +497,7 @@ bool Client::HandleSendLoginInfoPacket(const EQApplicationPacket *app)
 			// Could use a Logging Out Completely message somewhere.
 			cle->SetOnline(CLE_Status::CharSelect);

-			LogInfo("Account ({}) Logging({}) to character select :: LSID [{}] ", cle->AccountName(), inout, cle->LSID());
+			LogInfo("Account ({}) Logging ({}) to character select :: LSID [{}] ", cle->AccountName(), in_out, cle->LSID());
 		}
 		else {
 			cle->SetOnline();
@@ -545,7 +545,7 @@ bool Client::HandleSendLoginInfoPacket(const EQApplicationPacket *app)
 			if (!skip_char_info && !custom_files_key.empty() && cle->Admin() < RuleI(World, CustomFilesAdminLevel)) {
 				// Modified clients can utilize this unused block in login_info to send custom payloads on login
 				// which indicates they are using custom client files with the correct version, based on key payload.
-				const auto client_key = std::string(reinterpret_cast<char*>(login_info->unknown064));
+				const auto client_key = std::string(reinterpret_cast<char*>(r->unknown064));
 				if (custom_files_key != client_key) {
 					std::string message = fmt::format("Missing Files [{}]", RuleS(World, CustomFilesUrl) );
 					SendUnsupportedClientPacket(message);
@@ -1434,7 +1434,7 @@ void Client::EnterWorld(bool TryBootup) {
 	}
 	else {
 		if (TryBootup) {
-			LogInfo("Attempting autobootup of [{}] ([{}]:[{}])", zone_name, zone_id, instance_id);
+			LogInfo("Attempting autobootup of [{}] [{}] [{}]", zone_name, zone_id, instance_id);
 			autobootup_timeout.Start();
 			zone_waiting_for_bootup = zoneserver_list.TriggerBootup(zone_id, instance_id);
 			if (zone_waiting_for_bootup == 0) {
@@ -1,20 +1,3 @@
-/*	EQEMu: Everquest Server Emulator
-	Copyright (C) 2001-2005 EQEMu Development Team (http://eqemulator.net)
-
-	This program is free software; you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation; version 2 of the License.
-
-	This program is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY except by those people which sell it, which
-	are required to give you total support for your newly bought product;
-	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
-	A PARTICULAR PURPOSE. See the GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with this program; if not, write to the Free Software
-	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-*/
 #include "../common/global_define.h"
 #include "cliententry.h"
 #include "clientlist.h"
@@ -24,93 +7,86 @@
 #include "worlddb.h"
 #include "zoneserver.h"
 #include "world_config.h"
-#include "../common/guilds.h"
-#include "../common/strings.h"

-extern uint32          numplayers;
-extern LoginServerList loginserverlist;
-extern ClientList      client_list;
-extern volatile bool   RunLoops;
+extern uint32            numplayers;
+extern LoginServerList   loginserverlist;
+extern ClientList        client_list;
+extern volatile bool     RunLoops;
 extern SharedTaskManager shared_task_manager;

-/**
- * @param in_id
- * @param in_loginserver_id
- * @param in_loginserver_name
- * @param in_login_name
- * @param in_login_key
- * @param in_is_world_admin
- * @param ip
- * @param local
- */
 ClientListEntry::ClientListEntry(
-	uint32 in_id,
-	uint32 in_loginserver_id,
-	const char *in_loginserver_name,
-	const char *in_login_name,
-	const char *in_login_key,
-	int16 in_is_world_admin,
-	uint32 ip,
+	uint32 id,
+	uint32 login_server_id,
+	const char *login_server_name,
+	const char *account_name,
+	const char *login_key,
+	int16 is_world_admin,
+	uint32 ip_address,
 	uint8 local
 )
-	: id(in_id)
+	: m_id(id)
 {
 	ClearVars(true);

 	LogDebug(
-		"in_id [{0}] in_loginserver_id [{1}] in_loginserver_name [{2}] in_login_name [{3}] in_login_key [{4}] "
-		" in_is_world_admin [{5}] ip [{6}] local [{7}]",
-		in_id,
-		in_loginserver_id,
-		in_loginserver_name,
-		in_login_name,
-		in_login_key,
-		in_is_world_admin,
-		ip,
+		"id [{}] loginserver_id [{}] loginserver_name [{}] login_name [{}] login_key [{}] is_world_admin [{}] ip [{}] local [{}]",
+		id,
+		login_server_id,
+		login_server_name,
+		account_name,
+		login_key,
+		is_world_admin,
+		ip_address,
 		local
 	);

-	pIP   = ip;
-	pLSID = in_loginserver_id;
-	if (in_loginserver_id > 0) {
-		paccountid = database.GetAccountIDFromLSID(in_loginserver_name, in_loginserver_id, paccountname, &padmin);
+	m_ip_address      = ip_address;
+	m_login_server_id = login_server_id;
+	if (login_server_id > 0) {
+		m_account_id = database.GetAccountIDFromLSID(
+			login_server_name,
+			login_server_id,
+			m_account_name,
+			&m_admin
+		);
 	}

-	strn0cpy(loginserver_account_name, in_login_name, sizeof(loginserver_account_name));
-	strn0cpy(plskey, in_login_key, sizeof(plskey));
-	strn0cpy(source_loginserver, in_loginserver_name, sizeof(source_loginserver));
-	pworldadmin = in_is_world_admin;
-	plocal      = (local == 1);
+	strn0cpy(m_login_account_name, account_name, sizeof(m_login_account_name));
+	strn0cpy(m_key, login_key, sizeof(m_key));
+	strn0cpy(m_source_loginserver, login_server_name, sizeof(m_source_loginserver));

-	memset(pLFGComments, 0, 64);
+	m_world_admin = is_world_admin;
+	m_is_local    = (local == 1);
+
+	memset(m_lfg_comments, 0, 64);
 }

-ClientListEntry::ClientListEntry(uint32 in_id, ZoneServer *iZS, ServerClientList_Struct *scl, CLE_Status iOnline)
-	: id(in_id)
+ClientListEntry::ClientListEntry(uint32 in_id, ZoneServer *z, ServerClientList_Struct *scl, CLE_Status online)
+	: m_id(in_id)
 {
 	ClearVars(true);

-	pIP   = 0;
-	pLSID = scl->LSAccountID;
-	strn0cpy(loginserver_account_name, scl->name, sizeof(loginserver_account_name));
-	strn0cpy(plskey, scl->lskey, sizeof(plskey));
-	pworldadmin = 0;
+	m_ip_address      = 0;
+	m_login_server_id = scl->LSAccountID;
+	strn0cpy(m_login_account_name, scl->name, sizeof(m_login_account_name));
+	strn0cpy(m_key, scl->lskey, sizeof(m_key));
+	m_world_admin = 0;

-	paccountid = scl->AccountID;
-	strn0cpy(paccountname, scl->AccountName, sizeof(paccountname));
-	padmin = scl->Admin;
+	m_account_id = scl->AccountID;
+	strn0cpy(m_account_name, scl->AccountName, sizeof(m_account_name));
+	m_admin = scl->Admin;

-	pinstance       = 0;
-	pLFGFromLevel   = 0;
-	pLFGToLevel     = 0;
-	pLFGMatchFilter = false;
-	memset(pLFGComments, 0, 64);
+	m_instance         = 0;
+	m_lfg_from_level   = 0;
+	m_lfg_to_level     = 0;
+	m_lfg_match_filter = false;
+	memset(m_lfg_comments, 0, 64);

-	if (iOnline >= CLE_Status::Zoning) {
-		Update(iZS, scl, iOnline);
+	if (online >= CLE_Status::Zoning) {
+		Update(z, scl, online);
 	}
 	else {
-		SetOnline(iOnline);
+		SetOnline(online);
 	}
 }

@@ -120,16 +96,16 @@ ClientListEntry::~ClientListEntry()
 		Camp(); // updates zoneserver's numplayers
 		client_list.RemoveCLEReferances(this);
 	}
-	for (auto& elem : tell_queue) {
+	for (auto &elem: m_tell_queue) {
 		safe_delete_array(elem);
 	}
-	tell_queue.clear();
+	m_tell_queue.clear();
 }

 void ClientListEntry::SetChar(uint32 iCharID, const char *iCharName)
 {
-	pcharid = iCharID;
-	strn0cpy(pname, iCharName, sizeof(pname));
+	m_char_id = iCharID;
+	strn0cpy(m_char_name, iCharName, sizeof(m_char_name));
 }

 void ClientListEntry::SetOnline(CLE_Status iOnline)
@@ -142,20 +118,20 @@ void ClientListEntry::SetOnline(CLE_Status iOnline)
 		static_cast<int>(iOnline)
 	);

-	if (iOnline >= CLE_Status::Online && pOnline < CLE_Status::Online) {
+	if (iOnline >= CLE_Status::Online && m_online < CLE_Status::Online) {
 		numplayers++;
 	}
-	else if (iOnline < CLE_Status::Online && pOnline >= CLE_Status::Online) {
+	else if (iOnline < CLE_Status::Online && m_online >= CLE_Status::Online) {
 		numplayers--;
 	}
-	if (iOnline != CLE_Status::Online || pOnline < CLE_Status::Online) {
-		pOnline = iOnline;
+	if (iOnline != CLE_Status::Online || m_online < CLE_Status::Online) {
+		m_online = iOnline;
 	}
 	if (iOnline < CLE_Status::Zoning) {
 		Camp();
 	}
-	if (pOnline >= CLE_Status::Online) {
-		stale = 0;
+	if (m_online >= CLE_Status::Online) {
+		m_stale = 0;
 	}
 }

@@ -193,49 +169,49 @@ void ClientListEntry::LSZoneChange(ZoneToZone_Struct *ztz)

 void ClientListEntry::Update(ZoneServer *iZS, ServerClientList_Struct *scl, CLE_Status iOnline)
 {
-	if (pzoneserver != iZS) {
-		if (pzoneserver) {
-			pzoneserver->RemovePlayer();
-			LSUpdate(pzoneserver);
+	if (m_zone_server != iZS) {
+		if (m_zone_server) {
+			m_zone_server->RemovePlayer();
+			LSUpdate(m_zone_server);
 		}
 		if (iZS) {
 			iZS->AddPlayer();
 			LSUpdate(iZS);
 		}
 	}
-	pzoneserver    = iZS;
-	pzone          = scl->zone;
-	pinstance      = scl->instance_id;
-	pcharid        = scl->charid;
+	m_zone_server          = iZS;
+	m_zone                 = scl->zone;
+	m_instance             = scl->instance_id;
+	m_char_id              = scl->charid;

-	strcpy(pname, scl->name);
-	if (paccountid == 0) {
-		paccountid = scl->AccountID;
-		strcpy(paccountname, scl->AccountName);
-		strcpy(loginserver_account_name, scl->AccountName);
-		pIP   = scl->IP;
-		pLSID = scl->LSAccountID;
-		strn0cpy(plskey, scl->lskey, sizeof(plskey));
+	strcpy(m_char_name, scl->name);
+	if (m_account_id == 0) {
+		m_account_id = scl->AccountID;
+		strcpy(m_account_name, scl->AccountName);
+		strcpy(m_login_account_name, scl->AccountName);
+		m_ip_address      = scl->IP;
+		m_login_server_id = scl->LSAccountID;
+		strn0cpy(m_key, scl->lskey, sizeof(m_key));
 	}
-	padmin         = scl->Admin;
-	plevel         = scl->level;
-	pclass_        = scl->class_;
-	prace          = scl->race;
-	panon          = scl->anon;
-	ptellsoff      = scl->tellsoff;
-	pguild_id      = scl->guild_id;
-	pguild_rank    = scl->guild_rank;
-	pguild_tribute_opt_in = scl->guild_tribute_opt_in;
-	pLFG           = scl->LFG;
-	gm             = scl->gm;
-	pClientVersion = scl->ClientVersion;
+	m_admin                = scl->Admin;
+	m_level                = scl->level;
+	m_class_               = scl->class_;
+	m_race                 = scl->race;
+	m_anon                 = scl->anon;
+	m_tells_off            = scl->tellsoff;
+	m_guild_id             = scl->guild_id;
+	m_guild_rank           = scl->guild_rank;
+	m_guild_tribute_opt_in = scl->guild_tribute_opt_in;
+	m_lfg                  = scl->LFG;
+	m_gm                   = scl->gm;
+	m_client_version       = scl->ClientVersion;

 	// Fields from the LFG Window
 	if ((scl->LFGFromLevel != 0) && (scl->LFGToLevel != 0)) {
-		pLFGFromLevel   = scl->LFGFromLevel;
-		pLFGToLevel     = scl->LFGToLevel;
-		pLFGMatchFilter = scl->LFGMatchFilter;
-		memcpy(pLFGComments, scl->LFGComments, sizeof(pLFGComments));
+		m_lfg_from_level   = scl->LFGFromLevel;
+		m_lfg_to_level     = scl->LFGToLevel;
+		m_lfg_match_filter = scl->LFGMatchFilter;
+		memcpy(m_lfg_comments, scl->LFGComments, sizeof(m_lfg_comments));
 	}

 	SetOnline(iOnline);
@@ -243,76 +219,76 @@ void ClientListEntry::Update(ZoneServer *iZS, ServerClientList_Struct *scl, CLE_

 void ClientListEntry::LeavingZone(ZoneServer *iZS, CLE_Status iOnline)
 {
-	if (iZS != 0 && iZS != pzoneserver) {
+	if (iZS != 0 && iZS != m_zone_server) {
 		return;
 	}
 	SetOnline(iOnline);

 	shared_task_manager.RemoveActiveInvitationByCharacterID(CharID());

-	if (pzoneserver) {
-		pzoneserver->RemovePlayer();
-		LSUpdate(pzoneserver);
+	if (m_zone_server) {
+		m_zone_server->RemovePlayer();
+		LSUpdate(m_zone_server);
 	}
-	pzoneserver = 0;
-	pzone       = 0;
+	m_zone_server = 0;
+	m_zone        = 0;
 }

 void ClientListEntry::ClearVars(bool iAll)
 {
 	if (iAll) {
-		pOnline = CLE_Status::Never;
-		stale   = 0;
+		m_online = CLE_Status::Never;
+		m_stale  = 0;

-		pLSID = 0;
-		memset(loginserver_account_name, 0, sizeof(loginserver_account_name));
-		memset(plskey, 0, sizeof(plskey));
-		pworldadmin = 0;
+		m_login_server_id = 0;
+		memset(m_login_account_name, 0, sizeof(m_login_account_name));
+		memset(m_key, 0, sizeof(m_key));
+		m_world_admin = 0;

-		paccountid = 0;
-		memset(paccountname, 0, sizeof(paccountname));
-		padmin = AccountStatus::Player;
+		m_account_id = 0;
+		memset(m_account_name, 0, sizeof(m_account_name));
+		m_admin = AccountStatus::Player;
 	}
-	pzoneserver = 0;
-	pzone       = 0;
-	pcharid     = 0;
-	memset(pname, 0, sizeof(pname));
-	plevel         = 0;
-	pclass_        = 0;
-	prace          = 0;
-	panon          = 0;
-	ptellsoff      = 0;
-	pguild_id      = GUILD_NONE;
-	pguild_rank    = 0;
-	pLFG           = 0;
-	gm             = 0;
-	pClientVersion = 0;
-	for (auto& elem : tell_queue) {
+	m_zone_server = 0;
+	m_zone        = 0;
+	m_char_id     = 0;
+	memset(m_char_name, 0, sizeof(m_char_name));
+	m_level          = 0;
+	m_class_         = 0;
+	m_race           = 0;
+	m_anon           = 0;
+	m_tells_off      = 0;
+	m_guild_id       = GUILD_NONE;
+	m_guild_rank     = 0;
+	m_lfg            = 0;
+	m_gm             = 0;
+	m_client_version = 0;
+	for (auto &elem: m_tell_queue) {
 		safe_delete_array(elem);
 	}
-	tell_queue.clear();
+	m_tell_queue.clear();
 }

 void ClientListEntry::Camp(ZoneServer *iZS)
 {
-	if (iZS != 0 && iZS != pzoneserver) {
+	if (iZS != 0 && iZS != m_zone_server) {
 		return;
 	}
-	if (pzoneserver) {
-		pzoneserver->RemovePlayer();
-		LSUpdate(pzoneserver);
+	if (m_zone_server) {
+		m_zone_server->RemovePlayer();
+		LSUpdate(m_zone_server);
 	}

 	ClearVars();

-	stale = 0;
+	m_stale = 0;
 }

 bool ClientListEntry::CheckStale()
 {
-	stale++;
-	if (stale > 20) {
-		if (pOnline > CLE_Status::Offline) {
+	m_stale++;
+	if (m_stale > 20) {
+		if (m_online > CLE_Status::Offline) {
 			SetOnline(CLE_Status::Offline);
 		}

@@ -324,48 +300,50 @@ bool ClientListEntry::CheckStale()
 bool ClientListEntry::CheckAuth(uint32 loginserver_account_id, const char *key_password)
 {
 	LogDebug(
-		"ls_account_id [{0}] key_password [{1}] plskey [{2}]",
+		"ls_account_id [{}] key_password [{}] key [{}]",
 		loginserver_account_id,
 		key_password,
-		plskey
+		m_key
 	);
-	if (pLSID == loginserver_account_id && strncmp(plskey, key_password, 10) == 0) {

+	if (m_login_server_id == loginserver_account_id && strncmp(m_key, key_password, 10) == 0) {
 		LogDebug(
-			"ls_account_id [{0}] key_password [{1}] plskey [{2}] lsid [{3}] paccountid [{4}]",
+			"ls_account_id [{}] key_password [{}] m_key [{}] lsid [{}] m_account_id [{}]",
 			loginserver_account_id,
 			key_password,
-			plskey,
+			m_key,
 			LSID(),
-			paccountid
+			m_account_id
 		);

-		if (paccountid == 0 && LSID() > 0) {
+		// create account if it doesn't exist
+		if (m_account_id == 0 && LSID() > 0) {
 			int16 default_account_status = WorldConfig::get()->DefaultStatus;

-			paccountid = database.CreateAccount(
-				loginserver_account_name,
+			m_account_id = database.CreateAccount(
+				m_login_account_name,
 				std::string(),
 				default_account_status,
-				source_loginserver,
+				m_source_loginserver,
 				LSID()
 			);

-			if (!paccountid) {
-				LogInfo(
-					"Error adding local account for LS login: [{0}:{1}], duplicate name",
-					source_loginserver,
-					loginserver_account_name
+			if (!m_account_id) {
+				LogError(
+					"Error adding local account for LS login [{}] [{}], duplicate name",
+					m_source_loginserver,
+					m_login_account_name
 				);
 				return false;
 			}
-			strn0cpy(paccountname, loginserver_account_name, sizeof(paccountname));
-			padmin = default_account_status;
+			strn0cpy(m_account_name, m_login_account_name, sizeof(m_account_name));
+			m_admin = default_account_status;
 		}
 		std::string lsworldadmin;
 		if (database.GetVariable("honorlsworldadmin", lsworldadmin)) {
-			if (Strings::ToInt(lsworldadmin) == 1 && pworldadmin != 0 && (padmin < pworldadmin || padmin == AccountStatus::Player)) {
-				padmin = pworldadmin;
+			if (Strings::ToInt(lsworldadmin) == 1 && m_world_admin != 0 &&
+				(m_admin < m_world_admin || m_admin == AccountStatus::Player)) {
+				m_admin = m_world_admin;
 			}
 		}
 		return true;
@@ -380,8 +358,8 @@ void ClientListEntry::ProcessTellQueue()
 	}

 	ServerPacket *pack;
-	auto         it = tell_queue.begin();
-	while (it != tell_queue.end()) {
+	auto         it = m_tell_queue.begin();
+	while (it != m_tell_queue.end()) {
 		pack = new ServerPacket(
 			ServerOP_ChannelMessage,
 			sizeof(ServerChannelMessage_Struct) + strlen((*it)->message) + 1
@@ -390,8 +368,7 @@ void ClientListEntry::ProcessTellQueue()
 		Server()->SendPacket(pack);
 		safe_delete(pack);
 		safe_delete_array(*it);
-		it = tell_queue.erase(it);
+		it = m_tell_queue.erase(it);
 	}
-	return;
 }

@@ -8,8 +8,7 @@
 #include "../common/rulesys.h"
 #include <vector>

-typedef enum
-{
+typedef enum {
 	Never,
 	Offline,
 	Online,
@@ -18,7 +17,7 @@ typedef enum
 	InZone
 } CLE_Status;

-static const char * CLEStatusString[] = {
+static const char *CLEStatusString[] = {
 	"Never",
 	"Offline",
 	"Online",
@@ -33,150 +32,133 @@ struct ServerClientList_Struct;
 class ClientListEntry {
 public:

-	/**
-	 * @param id
-	 * @param in_loginserver_id
-	 * @param in_loginserver_name
-	 * @param in_login_name
-	 * @param in_login_key
-	 * @param in_is_world_admin
-	 * @param ip
-	 * @param local
-	 */
 	ClientListEntry(
 		uint32 id,
-		uint32 in_loginserver_id,
-		const char *in_loginserver_name,
-		const char *in_login_name,
-		const char *in_login_key,
-		int16 in_is_world_admin = 0,
-		uint32 ip = 0,
+		uint32 login_server_id,
+		const char *login_server_name,
+		const char *account_name,
+		const char *login_key,
+		int16 is_world_admin = 0,
+		uint32 ip_address = 0,
 		uint8 local = 0
 	);

-	/**
-	 * @param id
-	 * @param iZS
-	 * @param scl
-	 * @param iOnline
-	 */
-	ClientListEntry(uint32 id, uint32 iAccID, const char* iAccName, MD5& iMD5Pass, int16 iAdmin = AccountStatus::Player);
-	ClientListEntry(uint32 id, ZoneServer* iZS, ServerClientList_Struct* scl, CLE_Status iOnline);
+	ClientListEntry(uint32 id, ZoneServer *z, ServerClientList_Struct *scl, CLE_Status online);
 	~ClientListEntry();
-	bool	CheckStale();
-	void	Update(ZoneServer* zoneserver, ServerClientList_Struct* scl, CLE_Status iOnline = CLE_Status::InZone);
-	void	LSUpdate(ZoneServer* zoneserver);
-	void	LSZoneChange(ZoneToZone_Struct* ztz);
-	bool	CheckAuth(uint32 loginserver_account_id, const char* key_password);
-	void	SetOnline(CLE_Status iOnline = CLE_Status::Online);
-	void	SetChar(uint32 iCharID, const char* iCharName);
-	inline CLE_Status Online()		{ return pOnline; }
-	inline const uint32	GetID() const	{ return id; }
-	inline const uint32	GetIP() const	{ return pIP; }
-	inline void			SetIP(const uint32& iIP) { pIP = iIP; }
-	inline void			KeepAlive()		{ stale = 0; }
-	inline uint8			GetStaleCounter() const { return stale; }
-	void	LeavingZone(ZoneServer* iZS = 0, CLE_Status iOnline = CLE_Status::Offline);
-	void	Camp(ZoneServer* iZS = 0);
+	bool CheckStale();
+	void Update(ZoneServer *zoneserver, ServerClientList_Struct *scl, CLE_Status iOnline = CLE_Status::InZone);
+	void LSUpdate(ZoneServer *zoneserver);
+	void LSZoneChange(ZoneToZone_Struct *ztz);
+	bool CheckAuth(uint32 loginserver_account_id, const char *key_password);
+	void SetOnline(CLE_Status iOnline = CLE_Status::Online);
+	void SetChar(uint32 iCharID, const char *iCharName);
+	inline CLE_Status Online() { return m_online; }
+	inline const uint32 GetID() const { return m_id; }
+	inline const uint32 GetIP() const { return m_ip_address; }
+	inline void SetIP(const uint32 &iIP) { m_ip_address = iIP; }
+	inline void KeepAlive() { m_stale = 0; }
+	inline uint8 GetStaleCounter() const { return m_stale; }
+	void LeavingZone(ZoneServer *iZS = 0, CLE_Status iOnline = CLE_Status::Offline);
+	void Camp(ZoneServer *iZS = 0);

 	// Login Server stuff
-	inline const char*  LoginServer() const   { return source_loginserver; }
-	inline uint32		LSID()	const		{ return pLSID; }
-	inline uint32		LSAccountID() const	{ return pLSID; }
-	inline const char*	LSName() const		{ return loginserver_account_name; }
-	inline int16		WorldAdmin() const	{ return pworldadmin; }
-	inline const char*	GetLSKey() const	{ return plskey; }
-	inline const CLE_Status	GetOnline() const	{ return pOnline; }
+	inline const char *LoginServer() const { return m_source_loginserver; }
+	inline uint32 LSID() const { return m_login_server_id; }
+	inline uint32 LSAccountID() const { return m_login_server_id; }
+	inline const char *LSName() const { return m_login_account_name; }
+	inline int16 WorldAdmin() const { return m_world_admin; }
+	inline const char *GetLSKey() const { return m_key; }
+	inline const CLE_Status GetOnline() const { return m_online; }

 	// Account stuff
-	inline uint32		AccountID() const		{ return paccountid; }
-	inline const char*	AccountName() const		{ return paccountname; }
-	inline int16		Admin() const			{ return padmin; }
-	inline void			SetAdmin(uint16 iAdmin)	{ padmin = iAdmin; }
+	inline uint32 AccountID() const { return m_account_id; }
+	inline const char *AccountName() const { return m_account_name; }
+	inline int16 Admin() const { return m_admin; }
+	inline void SetAdmin(uint16 iAdmin) { m_admin = iAdmin; }

 	// Character info
-	inline ZoneServer *Server() const { return pzoneserver; }
-	inline void ClearServer() { pzoneserver = 0; }
-	inline uint32 CharID() const { return pcharid; }
-	inline const char *name() const { return pname; }
-	inline uint32 zone() const { return pzone; }
-	inline uint16 instance() const { return pinstance; }
-	inline uint8 level() const { return plevel; }
-	inline uint8 class_() const { return pclass_; }
-	inline uint16 race() const { return prace; }
-	inline uint8 Anon() { return panon; }
-	inline uint8 TellsOff() const { return ptellsoff; }
-	inline uint32 GuildID() const { return pguild_id; }
-	inline uint32 GuildRank() const { return pguild_rank; }
-	inline bool GuildTributeOptIn() const { return pguild_tribute_opt_in; }
-	inline void SetGuild(uint32 guild_id) { pguild_id = guild_id; }
-	inline void SetGuildTributeOptIn(bool opt) { pguild_tribute_opt_in = opt; }
-	inline bool LFG() const { return pLFG; }
-	inline uint8 GetGM() const { return gm; }
-	inline void SetGM(uint8 igm) { gm = igm; }
-	inline void SetZone(uint32 zone) { pzone = zone; }
-	inline bool IsLocalClient() const { return plocal; }
-	inline uint8 GetLFGFromLevel() const { return pLFGFromLevel; }
-	inline uint8 GetLFGToLevel() const { return pLFGToLevel; }
-	inline bool GetLFGMatchFilter() const { return pLFGMatchFilter; }
-	inline const char *GetLFGComments() const { return pLFGComments; }
-	inline uint8 GetClientVersion() { return pClientVersion; }
+	inline ZoneServer *Server() const { return m_zone_server; }
+	inline void ClearServer() { m_zone_server = 0; }
+	inline uint32 CharID() const { return m_char_id; }
+	inline const char *name() const { return m_char_name; }
+	inline uint32 zone() const { return m_zone; }
+	inline uint16 instance() const { return m_instance; }
+	inline uint8 level() const { return m_level; }
+	inline uint8 class_() const { return m_class_; }
+	inline uint16 race() const { return m_race; }
+	inline uint8 Anon() { return m_anon; }
+	inline uint8 TellsOff() const { return m_tells_off; }
+	inline uint32 GuildID() const { return m_guild_id; }
+	inline uint32 GuildRank() const { return m_guild_rank; }
+	inline bool GuildTributeOptIn() const { return m_guild_tribute_opt_in; }
+	inline void SetGuild(uint32 guild_id) { m_guild_id = guild_id; }
+	inline void SetGuildTributeOptIn(bool opt) { m_guild_tribute_opt_in = opt; }
+	inline bool LFG() const { return m_lfg; }
+	inline uint8 GetGM() const { return m_gm; }
+	inline void SetGM(uint8 igm) { m_gm = igm; }
+	inline void SetZone(uint32 zone) { m_zone = zone; }
+	inline bool IsLocalClient() const { return m_is_local; }
+	inline uint8 GetLFGFromLevel() const { return m_lfg_from_level; }
+	inline uint8 GetLFGToLevel() const { return m_lfg_to_level; }
+	inline bool GetLFGMatchFilter() const { return m_lfg_match_filter; }
+	inline const char *GetLFGComments() const { return m_lfg_comments; }
+	inline uint8 GetClientVersion() { return m_client_version; }

-	inline bool TellQueueFull() const { return tell_queue.size() >= RuleI(World, TellQueueSize); }
-	inline bool TellQueueEmpty() const { return tell_queue.empty(); }
-	inline void PushToTellQueue(ServerChannelMessage_Struct *scm) { tell_queue.push_back(scm); }
+	inline bool TellQueueFull() const { return m_tell_queue.size() >= RuleI(World, TellQueueSize); }
+	inline bool TellQueueEmpty() const { return m_tell_queue.empty(); }
+	inline void PushToTellQueue(ServerChannelMessage_Struct *scm) { m_tell_queue.push_back(scm); }
 	void ProcessTellQueue();

-	void SetPendingExpeditionInvite(ServerPacket* pack) { p_pending_expedition_invite.reset(pack->Copy()); };
-	std::unique_ptr<ServerPacket> GetPendingExpeditionInvite() { return std::move(p_pending_expedition_invite); }
+	void SetPendingDzInvite(ServerPacket *pack) { m_dz_invite.reset(pack->Copy()); };
+	std::unique_ptr<ServerPacket> GetPendingDzInvite() { return std::move(m_dz_invite); }

 private:
-	void	ClearVars(bool iAll = false);
+	void ClearVars(bool iAll = false);

-	const uint32	id;
-	uint32	pIP;
-	CLE_Status pOnline;
-	uint8	stale;
+	const uint32 m_id;
+	uint32       m_ip_address;
+	CLE_Status   m_online;
+	uint8        m_stale;

 	// Login Server stuff
-	char	source_loginserver[64]{}; //Loginserver we came from.
-	uint32	pLSID;
-	char	loginserver_account_name[32]{};
-	char	plskey[16]{};
-	int16	pworldadmin;		// Login server's suggested admin status setting
-	bool	plocal;
+	char   m_source_loginserver[64]{}; //Loginserver we came from.
+	uint32 m_login_server_id;
+	char   m_login_account_name[32]{};
+	char   m_key[16]{};
+	int16  m_world_admin;        // Login server's suggested admin status setting
+	bool   m_is_local;

 	// Account stuff
-	uint32	paccountid;
-	char	paccountname[32]{};
-	int16	padmin{};
+	uint32 m_account_id;
+	char   m_account_name[32]{};
+	int16  m_admin{};

 	// Character info
-	ZoneServer* pzoneserver{};
-	uint32	pzone{};
-	uint16	pinstance{};
-	uint32	pcharid{};
-	char	pname[64]{};
-	uint8	plevel{};
-	uint8	pclass_{};
-	uint16	prace{};
-	uint8	panon{};
-	uint8	ptellsoff{};
-	uint32	pguild_id{};
-	uint32  pguild_rank;
-	bool	pguild_tribute_opt_in{};
-	bool	pLFG{};
-	uint8	gm{};
-	uint8	pClientVersion{};
-	uint8	pLFGFromLevel{};
-	uint8	pLFGToLevel{};
-	bool	pLFGMatchFilter{};
-	char	pLFGComments[64]{};
+	ZoneServer *m_zone_server{};
+	uint32 m_zone{};
+	uint16 m_instance{};
+	uint32 m_char_id{};
+	char   m_char_name[64]{};
+	uint8  m_level{};
+	uint8  m_class_{};
+	uint16 m_race{};
+	uint8  m_anon{};
+	uint8  m_tells_off{};
+	uint32 m_guild_id{};
+	uint32 m_guild_rank;
+	bool   m_guild_tribute_opt_in{};
+	bool   m_lfg{};
+	uint8  m_gm{};
+	uint8  m_client_version{};
+	uint8  m_lfg_from_level{};
+	uint8  m_lfg_to_level{};
+	bool   m_lfg_match_filter{};
+	char   m_lfg_comments[64]{};

 	// Tell Queue -- really a vector :D
-	std::vector<ServerChannelMessage_Struct *> tell_queue;
+	std::vector<ServerChannelMessage_Struct *> m_tell_queue;

-	std::unique_ptr<ServerPacket> p_pending_expedition_invite = nullptr;
+	std::unique_ptr<ServerPacket> m_dz_invite;
 };

 #endif /*CLIENTENTRY_H_*/
@@ -331,8 +331,26 @@ void ClientList::SendCLEList(const int16& admin, const char* to, WorldTCPConnect
 }


-void ClientList::CLEAdd(uint32 iLSID, const char *iLoginServerName, const char* iLoginName, const char* iLoginKey, int16 iWorldAdmin, uint32 ip, uint8 local) {
-	auto tmp = new ClientListEntry(GetNextCLEID(), iLSID, iLoginServerName, iLoginName, iLoginKey, iWorldAdmin, ip, local);
+void ClientList::CLEAdd(
+	uint32 login_server_id,
+	const char *login_server_name,
+	const char *login_name,
+	const char *login_key,
+	int16 world_admin,
+	uint32 ip_address,
+	uint8 is_local
+)
+{
+	auto tmp = new ClientListEntry(
+		GetNextCLEID(),
+		login_server_id,
+		login_server_name,
+		login_name,
+		login_key,
+		world_admin,
+		ip_address,
+		is_local
+	);

 	clientlist.Append(tmp);
 }
@@ -457,19 +475,19 @@ void ClientList::CLEKeepAlive(uint32 numupdates, uint32* wid) {
 	}
 }

-ClientListEntry *ClientList::CheckAuth(uint32 iLSID, const char *iKey)
+ClientListEntry *ClientList::CheckAuth(uint32 loginserver_account_id, const char *key)
 {
 	LinkedListIterator<ClientListEntry *> iterator(clientlist);

 	iterator.Reset();
 	while (iterator.MoreElements()) {
-		if (iterator.GetData()->CheckAuth(iLSID, iKey)) {
+		if (iterator.GetData()->CheckAuth(loginserver_account_id, key)) {
 			return iterator.GetData();
 		}
 		iterator.Advance();
 	}

-	return 0;
+	return nullptr;
 }

 void ClientList::SendOnlineGuildMembers(uint32 FromID, uint32 GuildID)
@@ -1717,13 +1735,13 @@ void ClientList::SendCharacterMessageID(ClientListEntry* character,
 		return;
 	}

-	SerializeBuffer serialized_args;
+	SerializeBuffer argbuf;
 	for (const auto& arg : args)
 	{
-		serialized_args.WriteString(arg);
+		argbuf.WriteString(arg);
 	}

-	uint32_t args_size = static_cast<uint32_t>(serialized_args.size());
+	uint32_t args_size = static_cast<uint32_t>(argbuf.size());
 	uint32_t pack_size = sizeof(CZClientMessageString_Struct) + args_size;
 	auto pack = std::make_unique<ServerPacket>(ServerOP_CZClientMessageString, pack_size);
 	auto buf = reinterpret_cast<CZClientMessageString_Struct*>(pack->pBuffer);
@@ -1731,7 +1749,10 @@ void ClientList::SendCharacterMessageID(ClientListEntry* character,
 	buf->chat_type = chat_type;
 	strn0cpy(buf->client_name, character->name(), sizeof(buf->client_name));
 	buf->args_size = args_size;
-	memcpy(buf->args, serialized_args.buffer(), serialized_args.size());
+	if (argbuf.size() > 0)
+	{
+		memcpy(buf->args, argbuf.buffer(), argbuf.size());
+	}

 	character->Server()->SendPacket(pack.get());
 }
@@ -51,7 +51,7 @@ public:

 	void	ClientUpdate(ZoneServer* zoneserver, ServerClientList_Struct* scl);
 	void	CLERemoveZSRef(ZoneServer* iZS);
-	ClientListEntry* CheckAuth(uint32 iLSID, const char* iKey);
+	ClientListEntry* CheckAuth(uint32 loginserver_account_id, const char* key);
 	ClientListEntry* FindCharacter(const char* name);
 	ClientListEntry* FindCLEByAccountID(uint32 iAccID);
 	ClientListEntry* FindCLEByCharacterID(uint32 iCharID);
@@ -59,7 +59,7 @@ public:
 	void	DisconnectByIP(uint32 in_ip);
 	void	CLCheckStale();
 	void	CLEKeepAlive(uint32 numupdates, uint32* wid);
-	void	CLEAdd(uint32 iLSID, const char* iLoginServerName, const char* iLoginName, const char* iLoginKey, int16 iWorldAdmin = AccountStatus::Player, uint32 ip = 0, uint8 local=0);
+	void	CLEAdd(uint32 login_server_id, const char* login_server_name, const char* login_name, const char* login_key, int16 world_admin = AccountStatus::Player, uint32 ip_address = 0, uint8 is_local=0);
 	void	UpdateClientGuild(uint32 char_id, uint32 guild_id);
 	bool    IsAccountInGame(uint32 iLSID);

@@ -911,11 +911,7 @@ void ConsoleReloadWorld(
 )
 {
 	connection->SendLine("Reloading World...");
-	auto               pack = new ServerPacket(ServerOP_ReloadWorld, sizeof(ReloadWorld_Struct));
-	ReloadWorld_Struct *RW  = (ReloadWorld_Struct *) pack->pBuffer;
-	RW->global_repop = ReloadWorld::Repop;
-	zoneserver_list.SendPacket(pack);
-	safe_delete(pack);
+	zoneserver_list.SendServerReload(ServerReload::Type::WorldRepop, nullptr);
 }

 auto debounce_reload = std::chrono::system_clock::now();
@@ -164,132 +164,6 @@ void DynamicZone::SendZonesLeaderChanged()
 	zoneserver_list.SendPacket(pack.get());
 }

-void DynamicZone::HandleZoneMessage(ServerPacket* pack)
-{
-	switch (pack->opcode)
-	{
-	case ServerOP_DzCreated:
-	{
-		dynamic_zone_manager.CacheNewDynamicZone(pack);
-		break;
-	}
-	case ServerOP_DzSetCompass:
-	case ServerOP_DzSetSafeReturn:
-	case ServerOP_DzSetZoneIn:
-	{
-		auto buf = reinterpret_cast<ServerDzLocation_Struct*>(pack->pBuffer);
-		auto dz = DynamicZone::FindDynamicZoneByID(buf->dz_id);
-		if (dz)
-		{
-			if (pack->opcode == ServerOP_DzSetCompass)
-			{
-				dz->SetCompass(buf->zone_id, buf->x, buf->y, buf->z, false);
-			}
-			else if (pack->opcode == ServerOP_DzSetSafeReturn)
-			{
-				dz->SetSafeReturn(buf->zone_id, buf->x, buf->y, buf->z, buf->heading, false);
-			}
-			else if (pack->opcode == ServerOP_DzSetZoneIn)
-			{
-				dz->SetZoneInLocation(buf->x, buf->y, buf->z, buf->heading, false);
-			}
-		}
-		zoneserver_list.SendPacket(pack);
-		break;
-	}
-	case ServerOP_DzSetSwitchID:
-	{
-		auto buf = reinterpret_cast<ServerDzSwitchID_Struct*>(pack->pBuffer);
-		auto dz = DynamicZone::FindDynamicZoneByID(buf->dz_id);
-		if (dz)
-		{
-			dz->ProcessSetSwitchID(buf->dz_switch_id);
-		}
-		zoneserver_list.SendPacket(pack);
-		break;
-	}
-	case ServerOP_DzAddRemoveMember:
-	{
-		auto buf = reinterpret_cast<ServerDzMember_Struct*>(pack->pBuffer);
-		auto dz = DynamicZone::FindDynamicZoneByID(buf->dz_id);
-		if (dz)
-		{
-			auto status = static_cast<DynamicZoneMemberStatus>(buf->character_status);
-			dz->ProcessMemberAddRemove({ buf->character_id, buf->character_name, status }, buf->removed);
-		}
-		zoneserver_list.SendPacket(pack);
-		break;
-	}
-	case ServerOP_DzSwapMembers:
-	{
-		auto buf = reinterpret_cast<ServerDzMemberSwap_Struct*>(pack->pBuffer);
-		auto dz = DynamicZone::FindDynamicZoneByID(buf->dz_id);
-		if (dz)
-		{
-			// we add first in world so new member can be chosen if leader is removed
-			auto status = static_cast<DynamicZoneMemberStatus>(buf->add_character_status);
-			dz->ProcessMemberAddRemove({ buf->add_character_id, buf->add_character_name, status }, false);
-			dz->ProcessMemberAddRemove({ buf->remove_character_id, buf->remove_character_name }, true);
-		}
-		zoneserver_list.SendPacket(pack);
-		break;
-	}
-	case ServerOP_DzRemoveAllMembers:
-	{
-		auto buf = reinterpret_cast<ServerDzID_Struct*>(pack->pBuffer);
-		auto dz = DynamicZone::FindDynamicZoneByID(buf->dz_id);
-		if (dz)
-		{
-			dz->ProcessRemoveAllMembers();
-		}
-		zoneserver_list.SendPacket(pack);
-		break;
-	}
-	case ServerOP_DzSetSecondsRemaining:
-	{
-		auto buf = reinterpret_cast<ServerDzSetDuration_Struct*>(pack->pBuffer);
-		auto dz = DynamicZone::FindDynamicZoneByID(buf->dz_id);
-		if (dz)
-		{
-			dz->SetSecondsRemaining(buf->seconds);
-		}
-		break;
-	}
-	case ServerOP_DzGetMemberStatuses:
-	{
-		auto buf = reinterpret_cast<ServerDzID_Struct*>(pack->pBuffer);
-		auto dz = DynamicZone::FindDynamicZoneByID(buf->dz_id);
-		if (dz)
-		{
-			dz->SendZoneMemberStatuses(buf->sender_zone_id, buf->sender_instance_id);
-		}
-		break;
-	}
-	case ServerOP_DzUpdateMemberStatus:
-	{
-		auto buf = reinterpret_cast<ServerDzMemberStatus_Struct*>(pack->pBuffer);
-		auto dz = DynamicZone::FindDynamicZoneByID(buf->dz_id);
-		if (dz)
-		{
-			auto status = static_cast<DynamicZoneMemberStatus>(buf->status);
-			dz->ProcessMemberStatusChange(buf->character_id, status);
-		}
-		zoneserver_list.SendPacket(pack);
-		break;
-	}
-	case ServerOP_DzMovePC:
-	{
-		auto buf = reinterpret_cast<ServerDzMovePC_Struct*>(pack->pBuffer);
-		auto dz = DynamicZone::FindDynamicZoneByID(buf->dz_id);
-		if (dz && dz->HasMember(buf->character_id))
-		{
-			zoneserver_list.SendPacket(buf->sender_zone_id, buf->sender_instance_id, pack);
-		}
-		break;
-	}
-	};
-}
-
 void DynamicZone::ProcessMemberAddRemove(const DynamicZoneMember& member, bool removed)
 {
 	DynamicZoneBase::ProcessMemberAddRemove(member, removed);
@@ -345,13 +219,13 @@ void DynamicZone::SendZoneMemberStatuses(uint16_t zone_id, uint16_t instance_id)

 void DynamicZone::CacheMemberStatuses()
 {
-	if (m_has_member_statuses)
+	if (m_has_member_statuses || m_members.empty())
 	{
 		return;
 	}

 	// called when a new dz is cached to fill member statuses
-	std::string zone_name{};
+	std::string zone_name;
 	std::vector<ClientListEntry*> all_clients;
 	all_clients.reserve(client_list.GetClientCount());
 	client_list.GetClients(zone_name.c_str(), all_clients);
@@ -22,7 +22,6 @@ public:
 	using DynamicZoneBase::DynamicZoneBase; // inherit base constructors

 	static DynamicZone* FindDynamicZoneByID(uint32_t dz_id);
-	static void HandleZoneMessage(ServerPacket* pack);

 	void SetSecondsRemaining(uint32_t seconds_remaining) override;

@@ -33,7 +32,7 @@ public:
 protected:
 	Database& GetDatabase() override;
 	void ProcessMemberAddRemove(const DynamicZoneMember& member, bool removed) override;
-	bool ProcessMemberStatusChange(uint32_t member_id, DynamicZoneMemberStatus status) override;
+	bool ProcessMemberStatusChange(uint32_t character_id, DynamicZoneMemberStatus status) override;
 	bool SendServerPacket(ServerPacket* packet) override;

 private:
@@ -1,12 +1,14 @@
 #include "dynamic_zone_manager.h"
 #include "dynamic_zone.h"
+#include "cliententry.h"
+#include "clientlist.h"
 #include "worlddb.h"
 #include "zonelist.h"
 #include "zoneserver.h"
 #include "../common/rulesys.h"
-#include "../common/repositories/expeditions_repository.h"
-#include "../common/repositories/expedition_lockouts_repository.h"
+#include "../common/repositories/dynamic_zone_lockouts_repository.h"

+extern ClientList client_list;
 extern ZSList zoneserver_list;

 DynamicZoneManager dynamic_zone_manager;
@@ -27,6 +29,8 @@ void DynamicZoneManager::PurgeExpiredDynamicZones()
 	{
 		LogDynamicZones("Purging [{}] dynamic zone(s)", dz_ids.size());

+		DynamicZoneLockoutsRepository::DeleteWhere(database,
+			fmt::format("dynamic_zone_id IN ({})", fmt::join(dz_ids, ",")));
 		DynamicZoneMembersRepository::DeleteWhere(database,
 			fmt::format("dynamic_zone_id IN ({})", Strings::Join(dz_ids, ",")));
 		DynamicZonesRepository::DeleteWhere(database,
@@ -34,8 +38,7 @@ void DynamicZoneManager::PurgeExpiredDynamicZones()
 	}
 }

-DynamicZone* DynamicZoneManager::CreateNew(
-	DynamicZone& dz_request, const std::vector<DynamicZoneMember>& members)
+DynamicZone* DynamicZoneManager::TryCreate(DynamicZone& dz_request, const std::vector<DynamicZoneMember>& members)
 {
 	// this creates a new dz instance and saves it to both db and cache
 	uint32_t dz_id = dz_request.Create();
@@ -46,15 +49,12 @@ DynamicZone* DynamicZoneManager::CreateNew(
 	}

 	auto dz = std::make_unique<DynamicZone>(dz_request);
-	if (!members.empty())
-	{
-		dz->SaveMembers(members);
-		dz->CacheMemberStatuses();
-	}
+	dz->SaveMembers(members);
+	dz->CacheMemberStatuses();

 	LogDynamicZones("Created new dz [{}] for zone [{}]", dz_id, dz_request.GetZoneID());

-	auto pack = dz->CreateServerDzCreatePacket(0, 0);
+	auto pack = dz->CreateServerPacket(0, 0);
 	zoneserver_list.SendPacket(pack.get());

 	auto inserted = dynamic_zone_cache.emplace(dz_id, std::move(dz));
@@ -63,18 +63,17 @@ DynamicZone* DynamicZoneManager::CreateNew(

 void DynamicZoneManager::CacheNewDynamicZone(ServerPacket* pack)
 {
-	auto buf = reinterpret_cast<ServerDzCreateSerialized_Struct*>(pack->pBuffer);
+	auto buf = reinterpret_cast<ServerDzCreate_Struct*>(pack->pBuffer);

 	auto new_dz = std::make_unique<DynamicZone>();
-	new_dz->LoadSerializedDzPacket(buf->cereal_data, buf->cereal_size);
+	new_dz->Unserialize({ buf->cereal_data, buf->cereal_size });
 	new_dz->CacheMemberStatuses();

 	// reserialize with member statuses cached before forwarding (restore origin zone)
-	auto repack = new_dz->CreateServerDzCreatePacket(buf->origin_zone_id, buf->origin_instance_id);
+	auto repack = new_dz->CreateServerPacket(buf->origin_zone_id, buf->origin_instance_id);

-	uint32_t dz_id = new_dz->GetID();
-	dynamic_zone_cache.emplace(dz_id, std::move(new_dz));
-	LogDynamicZones("Cached new dynamic zone [{}]", dz_id);
+	dynamic_zone_cache.emplace(buf->dz_id, std::move(new_dz));
+	LogDynamicZones("Cached new dynamic zone [{}]", buf->dz_id);

 	zoneserver_list.SendPacket(repack.get());
 }
@@ -83,18 +82,19 @@ void DynamicZoneManager::CacheAllFromDatabase()
 {
 	BenchTimer bench;

-	auto dynamic_zones = DynamicZonesRepository::AllWithInstanceNotExpired(database);
-	auto dynamic_zone_members = DynamicZoneMembersRepository::GetAllWithNames(database);
+	auto dzs = DynamicZonesRepository::AllWithInstanceNotExpired(database);
+	auto members = DynamicZoneMembersRepository::AllWithNames(database);
+	auto lockouts = DynamicZoneLockoutsRepository::All(database);

 	dynamic_zone_cache.clear();
-	dynamic_zone_cache.reserve(dynamic_zones.size());
+	dynamic_zone_cache.reserve(dzs.size());

-	for (auto& entry : dynamic_zones)
+	for (auto& entry : dzs)
 	{
 		uint32_t dz_id = entry.id;
 		auto dz = std::make_unique<DynamicZone>(std::move(entry));

-		for (auto& member : dynamic_zone_members)
+		for (auto& member : members)
 		{
 			if (member.dynamic_zone_id == dz_id)
 			{
@@ -102,6 +102,14 @@ void DynamicZoneManager::CacheAllFromDatabase()
 			}
 		}

+		for (auto& lockout : lockouts)
+		{
+			if (lockout.dynamic_zone_id == dz->GetID())
+			{
+				dz->m_lockouts.emplace_back(dz->GetName(), std::move(lockout));
+			}
+		}
+
 		// note leader status won't be updated here until leader is set by owning system (expeditions)
 		dz->CacheMemberStatuses();

@@ -142,24 +150,10 @@ void DynamicZoneManager::Process()
 			dynamic_zone_cache.erase(dz_id);
 		}

-		// need to look up expedition ids until lockouts are moved to dynamic zones
-		std::vector<uint32_t> expedition_ids;
-		auto expeditions = ExpeditionsRepository::GetWhere(database,
-			fmt::format("dynamic_zone_id IN ({})", Strings::Join(dynamic_zone_ids, ",")));
-
-		if (!expeditions.empty())
-		{
-			for (const auto& expedition : expeditions)
-			{
-				expedition_ids.emplace_back(expedition.id);
-			}
-			ExpeditionLockoutsRepository::DeleteWhere(database,
-				fmt::format("expedition_id IN ({})", Strings::Join(expedition_ids, ",")));
-		}
-
-		ExpeditionsRepository::DeleteWhere(database,
-			fmt::format("dynamic_zone_id IN ({})", Strings::Join(dynamic_zone_ids, ",")));
-		DynamicZoneMembersRepository::RemoveAllMembers(database, dynamic_zone_ids);
+		DynamicZoneLockoutsRepository::DeleteWhere(database,
+			fmt::format("dynamic_zone_id IN ({})", fmt::join(dynamic_zone_ids, ",")));
+		DynamicZoneMembersRepository::DeleteWhere(database,
+			fmt::format("dynamic_zone_id IN ({})", fmt::join(dynamic_zone_ids, ",")));
 		DynamicZonesRepository::DeleteWhere(database,
 			fmt::format("id IN ({})", Strings::Join(dynamic_zone_ids, ",")));
 	}
@@ -174,3 +168,250 @@ void DynamicZoneManager::LoadTemplates()
 		m_dz_templates[dz_template.id] = dz_template;
 	}
 }
+
+void DynamicZoneManager::HandleZoneMessage(ServerPacket* pack)
+{
+	switch (pack->opcode)
+	{
+	case ServerOP_DzCreated:
+	{
+		CacheNewDynamicZone(pack);
+		break;
+	}
+	case ServerOP_DzAddPlayer:
+	{
+		auto buf = reinterpret_cast<ServerDzCommand_Struct*>(pack->pBuffer);
+
+		ClientListEntry* cle = client_list.FindCharacter(buf->target_name);
+		if (cle && cle->Server())
+		{
+			// continue in the add target's zone
+			buf->is_char_online = true;
+			cle->Server()->SendPacket(pack);
+		}
+		else
+		{
+			// add target not online, return to inviter
+			ClientListEntry* inviter_cle = client_list.FindCharacter(buf->requester_name);
+			if (inviter_cle && inviter_cle->Server())
+			{
+				inviter_cle->Server()->SendPacket(pack);
+			}
+		}
+		break;
+	}
+	case ServerOP_DzSaveInvite:
+	{
+		auto buf = reinterpret_cast<ServerDzCommand_Struct*>(pack->pBuffer);
+		if (ClientListEntry* cle = client_list.FindCharacter(buf->target_name))
+		{
+			// store packet on cle and re-send it when client requests it
+			buf->is_char_online = true;
+			pack->opcode = ServerOP_DzAddPlayer;
+			cle->SetPendingDzInvite(pack);
+		}
+		break;
+	}
+	case ServerOP_DzRequestInvite:
+	{
+		auto buf = reinterpret_cast<ServerCharacterID_Struct*>(pack->pBuffer);
+		if (ClientListEntry* cle = client_list.FindCLEByCharacterID(buf->char_id))
+		{
+			auto invite_pack = cle->GetPendingDzInvite();
+			if (invite_pack && cle->Server())
+			{
+				cle->Server()->SendPacket(invite_pack.get());
+			}
+		}
+		break;
+	}
+	case ServerOP_DzMakeLeader:
+	{
+		auto buf = reinterpret_cast<ServerDzCommandMakeLeader_Struct*>(pack->pBuffer);
+
+		// notify requester (old leader) and new leader of the result
+		ZoneServer* new_leader_zs = nullptr;
+		ClientListEntry* leader_cle = client_list.FindCharacter(buf->new_leader_name);
+		if (leader_cle && leader_cle->Server())
+		{
+			auto dz = DynamicZone::FindDynamicZoneByID(buf->dz_id);
+			if (dz && dz->GetLeaderID() == buf->requester_id)
+			{
+				buf->is_success = dz->SetNewLeader(leader_cle->CharID());
+			}
+
+			buf->is_online = true;
+			new_leader_zs = leader_cle->Server();
+			new_leader_zs->SendPacket(pack);
+		}
+
+		// if old and new leader are in the same zone only send one message
+		ClientListEntry* requester_cle = client_list.FindCLEByCharacterID(buf->requester_id);
+		if (requester_cle && requester_cle->Server() && requester_cle->Server() != new_leader_zs)
+		{
+			requester_cle->Server()->SendPacket(pack);
+		}
+		break;
+	}
+	case ServerOP_DzSetCompass:
+	case ServerOP_DzSetSafeReturn:
+	case ServerOP_DzSetZoneIn:
+	{
+		auto buf = reinterpret_cast<ServerDzLocation_Struct*>(pack->pBuffer);
+		if (auto dz = DynamicZone::FindDynamicZoneByID(buf->dz_id))
+		{
+			if (pack->opcode == ServerOP_DzSetCompass)
+			{
+				dz->SetCompass(buf->zone_id, buf->x, buf->y, buf->z, false);
+			}
+			else if (pack->opcode == ServerOP_DzSetSafeReturn)
+			{
+				dz->SetSafeReturn(buf->zone_id, buf->x, buf->y, buf->z, buf->heading, false);
+			}
+			else if (pack->opcode == ServerOP_DzSetZoneIn)
+			{
+				dz->SetZoneInLocation(buf->x, buf->y, buf->z, buf->heading, false);
+			}
+		}
+		zoneserver_list.SendPacket(pack);
+		break;
+	}
+	case ServerOP_DzSetSwitchID:
+	{
+		auto buf = reinterpret_cast<ServerDzSwitchID_Struct*>(pack->pBuffer);
+		if (auto dz = DynamicZone::FindDynamicZoneByID(buf->dz_id))
+		{
+			dz->ProcessSetSwitchID(buf->dz_switch_id);
+		}
+		zoneserver_list.SendPacket(pack);
+		break;
+	}
+	case ServerOP_DzAddRemoveMember:
+	{
+		auto buf = reinterpret_cast<ServerDzMember_Struct*>(pack->pBuffer);
+		if (auto dz = DynamicZone::FindDynamicZoneByID(buf->dz_id))
+		{
+			auto status = static_cast<DynamicZoneMemberStatus>(buf->character_status);
+			dz->ProcessMemberAddRemove({ buf->character_id, buf->character_name, status }, buf->removed);
+		}
+		zoneserver_list.SendPacket(pack);
+		break;
+	}
+	case ServerOP_DzSwapMembers:
+	{
+		auto buf = reinterpret_cast<ServerDzMemberSwap_Struct*>(pack->pBuffer);
+		if (auto dz = DynamicZone::FindDynamicZoneByID(buf->dz_id))
+		{
+			// we add first in world so new member can be chosen if leader is removed
+			auto status = static_cast<DynamicZoneMemberStatus>(buf->add_character_status);
+			dz->ProcessMemberAddRemove({ buf->add_character_id, buf->add_character_name, status }, false);
+			dz->ProcessMemberAddRemove({ buf->remove_character_id, buf->remove_character_name }, true);
+		}
+		zoneserver_list.SendPacket(pack);
+		break;
+	}
+	case ServerOP_DzRemoveAllMembers:
+	{
+		auto buf = reinterpret_cast<ServerDzID_Struct*>(pack->pBuffer);
+		if (auto dz = DynamicZone::FindDynamicZoneByID(buf->dz_id))
+		{
+			dz->ProcessRemoveAllMembers();
+		}
+		zoneserver_list.SendPacket(pack);
+		break;
+	}
+	case ServerOP_DzSetSecondsRemaining:
+	{
+		auto buf = reinterpret_cast<ServerDzSetDuration_Struct*>(pack->pBuffer);
+		if (auto dz = DynamicZone::FindDynamicZoneByID(buf->dz_id))
+		{
+			dz->SetSecondsRemaining(buf->seconds);
+		}
+		break;
+	}
+	case ServerOP_DzGetMemberStatuses:
+	{
+		auto buf = reinterpret_cast<ServerDzID_Struct*>(pack->pBuffer);
+		if (auto dz = DynamicZone::FindDynamicZoneByID(buf->dz_id))
+		{
+			dz->SendZoneMemberStatuses(buf->sender_zone_id, buf->sender_instance_id);
+		}
+		break;
+	}
+	case ServerOP_DzUpdateMemberStatus:
+	{
+		auto buf = reinterpret_cast<ServerDzMemberStatus_Struct*>(pack->pBuffer);
+		if (auto dz = DynamicZone::FindDynamicZoneByID(buf->dz_id))
+		{
+			auto status = static_cast<DynamicZoneMemberStatus>(buf->status);
+			dz->ProcessMemberStatusChange(buf->character_id, status);
+		}
+		zoneserver_list.SendPacket(pack);
+		break;
+	}
+	case ServerOP_DzMovePC:
+	{
+		auto buf = reinterpret_cast<ServerDzMovePC_Struct*>(pack->pBuffer);
+		auto dz = DynamicZone::FindDynamicZoneByID(buf->dz_id);
+		if (dz && dz->HasMember(buf->character_id))
+		{
+			zoneserver_list.SendPacket(buf->sender_zone_id, buf->sender_instance_id, pack);
+		}
+		break;
+	}
+	case ServerOP_DzLock:
+	{
+		auto buf = reinterpret_cast<ServerDzLock_Struct*>(pack->pBuffer);
+		if (auto dz = DynamicZone::FindDynamicZoneByID(buf->dz_id))
+		{
+			dz->SetLocked(buf->lock);
+		}
+		zoneserver_list.SendPacket(pack);
+		break;
+	}
+	case ServerOP_DzReplayOnJoin:
+	{
+		auto buf = reinterpret_cast<ServerDzBool_Struct*>(pack->pBuffer);
+		if (auto dz = DynamicZone::FindDynamicZoneByID(buf->dz_id))
+		{
+			dz->SetReplayOnJoin(buf->enabled);
+		}
+		zoneserver_list.SendPacket(pack);
+		break;
+	}
+	case ServerOP_DzLockout:
+	{
+		auto buf = reinterpret_cast<ServerDzLockout_Struct*>(pack->pBuffer);
+		if (auto dz = DynamicZone::FindDynamicZoneByID(buf->dz_id))
+		{
+			DzLockout lockout{ dz->GetUUID(), dz->GetName(), buf->event_name, buf->expire_time, buf->duration };
+			dz->HandleLockoutUpdate(lockout, buf->remove, buf->members_only);
+		}
+		zoneserver_list.SendPacket(pack);
+		break;
+	}
+	case ServerOP_DzLockoutDuration:
+	{
+		auto buf = reinterpret_cast<ServerDzLockout_Struct*>(pack->pBuffer);
+		if (auto dz = DynamicZone::FindDynamicZoneByID(buf->dz_id))
+		{
+			DzLockout lockout{ dz->GetUUID(), dz->GetName(), buf->event_name, buf->expire_time, buf->duration };
+			dz->HandleLockoutDuration(lockout, buf->seconds, buf->members_only, false);
+		}
+		zoneserver_list.SendPacket(pack);
+		break;
+	}
+	case ServerOP_DzCharacterLockout:
+	{
+		auto buf = reinterpret_cast<ServerDzCharacterLockout_Struct*>(pack->pBuffer);
+		auto cle = client_list.FindCLEByCharacterID(buf->char_id);
+		if (cle && cle->Server())
+		{
+			cle->Server()->SendPacket(pack);
+		}
+		break;
+	}
+	default:
+		break;
+	};
+}
@@ -20,7 +20,8 @@ public:

 	void CacheAllFromDatabase();
 	void CacheNewDynamicZone(ServerPacket* pack);
-	DynamicZone* CreateNew(DynamicZone& dz_request, const std::vector<DynamicZoneMember>& members);
+	DynamicZone* TryCreate(DynamicZone& dz_request, const std::vector<DynamicZoneMember>& members);
+	void HandleZoneMessage(ServerPacket* pack);
 	void LoadTemplates();
 	void Process();
 	void PurgeExpiredDynamicZones();
@@ -5,6 +5,7 @@
 #include "zoneserver.h"
 #include "zonelist.h"
 #include "../common/database_schema.h"
+#include "../common/server_reload_types.h"
 #include "../common/zone_store.h"
 #include "worlddb.h"
 #include "wguild_mgr.h"
@@ -113,136 +114,47 @@ void callGetClientList(Json::Value &response)
 	client_list.GetClientList(response);
 }

-
-struct Reload {
-	std::string command{};
-	uint16      opcode;
-	std::string desc{};
-};
-
-std::vector<Reload> reload_types = {
-	Reload{.command = "aa", .opcode = ServerOP_ReloadAAData, .desc = "Alternate Advancement"},
-	Reload{.command = "alternate_currencies", .opcode = ServerOP_ReloadAlternateCurrencies, .desc = "Alternate Currencies"},
-	Reload{.command = "base_data", .opcode = ServerOP_ReloadBaseData, .desc = "Base Data"},
-	Reload{.command = "blocked_spells", .opcode = ServerOP_ReloadBlockedSpells, .desc = "Blocked Spells"},
-	Reload{.command = "commands", .opcode = ServerOP_ReloadCommands, .desc = "Commands"},
-	Reload{.command = "content_flags", .opcode = ServerOP_ReloadContentFlags, .desc = "Content Flags"},
-	Reload{.command = "data_buckets_cache", .opcode = ServerOP_ReloadDataBucketsCache, .desc = "Data Buckets Cache"},
-	Reload{.command = "doors", .opcode = ServerOP_ReloadDoors, .desc = "Doors"},
-	Reload{.command = "dztemplates", .opcode = ServerOP_ReloadDzTemplates, .desc = "Dynamic Zone Templates"},
-	Reload{.command = "ground_spawns", .opcode = ServerOP_ReloadGroundSpawns, .desc = "Ground Spawns"},
-	Reload{.command = "level_mods", .opcode = ServerOP_ReloadLevelEXPMods, .desc = "Level Mods"},
-	Reload{.command = "logs", .opcode = ServerOP_ReloadLogs, .desc = "Log Settings"},
-	Reload{.command = "loot", .opcode = ServerOP_ReloadLoot, .desc = "Loot"},
-	Reload{.command = "merchants", .opcode = ServerOP_ReloadMerchants, .desc = "Merchants"},
-	Reload{.command = "npc_emotes", .opcode = ServerOP_ReloadNPCEmotes, .desc = "NPC Emotes"},
-	Reload{.command = "npc_spells", .opcode = ServerOP_ReloadNPCSpells, .desc = "NPC Spells"},
-	Reload{.command = "objects", .opcode = ServerOP_ReloadObjects, .desc = "Objects"},
-	Reload{.command = "opcodes", .opcode = ServerOP_ReloadOpcodes, .desc = "Opcodes"},
-	Reload{.command = "perl_export", .opcode = ServerOP_ReloadPerlExportSettings, .desc = "Perl Event Export Settings"},
-	Reload{.command = "rules", .opcode = ServerOP_ReloadRules, .desc = "Rules"},
-	Reload{.command = "skill_caps", .opcode = ServerOP_ReloadSkillCaps, .desc = "Skill Caps"},
-	Reload{.command = "static", .opcode = ServerOP_ReloadStaticZoneData, .desc = "Static Zone Data"},
-	Reload{.command = "tasks", .opcode = ServerOP_ReloadTasks, .desc = "Tasks"},
-	Reload{.command = "titles", .opcode = ServerOP_ReloadTitles, .desc = "Titles"},
-	Reload{.command = "traps", .opcode = ServerOP_ReloadTraps, .desc = "Traps"},
-	Reload{.command = "variables", .opcode = ServerOP_ReloadVariables, .desc = "Variables"},
-	Reload{.command = "veteran_rewards", .opcode = ServerOP_ReloadVeteranRewards, .desc = "Veteran Rewards"},
-	Reload{.command = "world", .opcode = ServerOP_ReloadWorld, .desc = "World"},
-	Reload{.command = "zone_points", .opcode = ServerOP_ReloadZonePoints, .desc = "Zone Points"},
-};
-
 void getReloadTypes(Json::Value &response)
 {
-	for (auto &c: reload_types) {
+	for (auto &t: ServerReload::GetTypes()) {
 		Json::Value v;

-		v["command"]     = c.command;
-		v["opcode"]      = c.opcode;
-		v["description"] = c.desc;
+		v["command"]     = std::to_string(t);
+		v["description"] = ServerReload::GetName(t);
 		response.append(v);
 	}
 }

-
 void EQEmuApiWorldDataService::reload(Json::Value &r, const std::vector<std::string> &args)
 {
 	std::vector<std::string> commands{};
-	commands.reserve(reload_types.size());
-	for (auto &c: reload_types) {
-		commands.emplace_back(c.command);
+	commands.reserve(ServerReload::GetTypes().size());
+	for (auto &c: ServerReload::GetTypes()) {
+		commands.emplace_back(std::to_string(c));
 	}

 	std::string command = !args[1].empty() ? args[1] : "";
 	if (command.empty()) {
-		message(r, fmt::format("Need to provide a type to reload. Example(s) [{}]", Strings::Implode("|", commands)));
+		message(r, fmt::format("Need to provide a type ID to reload. Example(s) [{}]", Strings::Implode("|", commands)));
 		return;
 	}

 	ServerPacket *pack = nullptr;

-	bool      found_command = false;
-	for (auto &c: reload_types) {
-		if (command == c.command) {
-			if (c.command == "world") {
-				uint8 global_repop = ReloadWorld::NoRepop;
+	bool found_command = false;

-				if (Strings::IsNumber(args[2])) {
-					global_repop = static_cast<uint8>(Strings::ToUnsignedInt(args[2]));
-
-					if (global_repop > ReloadWorld::ForceRepop) {
-						global_repop = ReloadWorld::ForceRepop;
-					}
-				}
-
-				message(
-					r,
-					fmt::format(
-						"Attempting to reload Quests {}worldwide.",
-						(
-							global_repop ?
-								(
-									global_repop == ReloadWorld::Repop ?
-										"and repop NPCs " :
-										"and forcefully repop NPCs "
-								) :
-								""
-						)
-					)
-				);
-
-				pack = new ServerPacket(ServerOP_ReloadWorld, sizeof(ReloadWorld_Struct));
-				auto RW = (ReloadWorld_Struct *) pack->pBuffer;
-				RW->global_repop = global_repop;
-			}
-			else {
-				pack = new ServerPacket(c.opcode, 0);
-				message(r, fmt::format("Reloading [{}] globally", c.desc));
-
-				if (c.opcode == ServerOP_ReloadLogs) {
-					LogSys.LoadLogDatabaseSettings();
-					QSLink.SendPacket(pack);
-					UCSLink.SendPacket(pack);
-				}
-				else if (c.opcode == ServerOP_ReloadRules) {
-					RuleManager::Instance()->LoadRules(&database, RuleManager::Instance()->GetActiveRuleset(), true);
-				}
-			}
-
-			found_command = true;
+	for (auto &t: ServerReload::GetTypes()) {
+		if (std::to_string(t) == command || Strings::ToLower(ServerReload::GetName(t)) == command) {
+			message(r, fmt::format("Reloading [{}] globally", ServerReload::GetName(t)));
+			zoneserver_list.SendServerReload(t, nullptr);
 		}
+		found_command = true;
 	}

 	if (!found_command) {
 		message(r, fmt::format("Need to provide a type to reload. Example(s) [{}]", Strings::Implode("|", commands)));
 		return;
 	}
-
-	if (pack) {
-		zoneserver_list.SendPacket(pack);
-	}
-
-	safe_delete(pack);
 }

 void EQEmuApiWorldDataService::message(Json::Value &r, const std::string &message)
@@ -1,78 +0,0 @@
-/**
- * EQEmulator: Everquest Server Emulator
- * Copyright (C) 2001-2020 EQEmulator Development Team (https://github.com/EQEmu/Server)
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 2 of the License.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY except by those people which sell it, which
- * are required to give you total support for your newly bought product;
- * without even the implied warranty of MERCHANTABILITY or FITNESS FOR
- * A PARTICULAR PURPOSE. See the GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
- *
- */
-
-#include "expedition_database.h"
-#include "worlddb.h"
-#include "../common/repositories/expeditions_repository.h"
-#include "../common/repositories/expedition_lockouts_repository.h"
-#include "../common/repositories/dynamic_zone_members_repository.h"
-
-void ExpeditionDatabase::PurgeExpiredExpeditions()
-{
-	std::string query = SQL(
-		SELECT
-			expeditions.id,
-			expeditions.dynamic_zone_id
-		FROM expeditions
-			LEFT JOIN dynamic_zones ON expeditions.dynamic_zone_id = dynamic_zones.id
-			LEFT JOIN instance_list ON dynamic_zones.instance_id = instance_list.id
-			LEFT JOIN
-				(
-					SELECT dynamic_zone_id, COUNT(*) member_count
-					FROM dynamic_zone_members
-					GROUP BY dynamic_zone_id
-				) dynamic_zone_members
-				ON dynamic_zone_members.dynamic_zone_id = expeditions.dynamic_zone_id
-		WHERE
-			instance_list.id IS NULL
-			OR dynamic_zone_members.member_count IS NULL
-			OR dynamic_zone_members.member_count = 0
-			OR (instance_list.start_time + instance_list.duration) <= UNIX_TIMESTAMP();
-	);
-
-	auto results = database.QueryDatabase(query);
-	if (results.Success())
-	{
-		std::vector<std::string> expedition_ids;
-		std::vector<uint32_t> dynamic_zone_ids;
-		for (auto row = results.begin(); row != results.end(); ++row)
-		{
-			expedition_ids.emplace_back(row[0]);
-			dynamic_zone_ids.emplace_back(static_cast<uint32_t>(strtoul(row[1], nullptr, 10)));
-		}
-
-		if (!expedition_ids.empty())
-		{
-			ExpeditionsRepository::DeleteWhere(database, fmt::format("id IN ({})", fmt::join(expedition_ids, ",")));
-			ExpeditionLockoutsRepository::DeleteWhere(database, fmt::format("expedition_id IN ({})", fmt::join(expedition_ids, ",")));
-			DynamicZoneMembersRepository::RemoveAllMembers(database, dynamic_zone_ids);
-		}
-	}
-}
-
-void ExpeditionDatabase::PurgeExpiredCharacterLockouts()
-{
-	std::string query = SQL(
-		DELETE FROM character_expedition_lockouts
-		WHERE expire_time <= NOW();
-	);
-
-	database.QueryDatabase(query);
-}
@@ -1,35 +0,0 @@
-/**
- * EQEmulator: Everquest Server Emulator
- * Copyright (C) 2001-2020 EQEmulator Development Team (https://github.com/EQEmu/Server)
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 2 of the License.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY except by those people which sell it, which
- * are required to give you total support for your newly bought product;
- * without even the implied warranty of MERCHANTABILITY or FITNESS FOR
- * A PARTICULAR PURPOSE. See the GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
- *
- */
-
-#ifndef WORLD_EXPEDITION_DATABASE_H
-#define WORLD_EXPEDITION_DATABASE_H
-
-#include <cstdint>
-#include <vector>
-
-class Expedition;
-
-namespace ExpeditionDatabase
-{
-	void PurgeExpiredExpeditions();
-	void PurgeExpiredCharacterLockouts();
-};
-
-#endif
@@ -1,151 +0,0 @@
-/**
- * EQEmulator: Everquest Server Emulator
- * Copyright (C) 2001-2020 EQEmulator Development Team (https://github.com/EQEmu/Server)
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 2 of the License.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY except by those people which sell it, which
- * are required to give you total support for your newly bought product;
- * without even the implied warranty of MERCHANTABILITY or FITNESS FOR
- * A PARTICULAR PURPOSE. See the GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
- *
- */
-
-#include "dynamic_zone.h"
-#include "expedition_message.h"
-#include "cliententry.h"
-#include "clientlist.h"
-#include "zonelist.h"
-#include "zoneserver.h"
-#include "../common/servertalk.h"
-#include <algorithm>
-
-extern ClientList client_list;
-extern ZSList zoneserver_list;
-
-void ExpeditionMessage::HandleZoneMessage(ServerPacket* pack)
-{
-	switch (pack->opcode)
-	{
-	case ServerOP_ExpeditionCreate:
-	{
-		zoneserver_list.SendPacket(pack);
-		break;
-	}
-	case ServerOP_ExpeditionDzAddPlayer:
-	{
-		ExpeditionMessage::AddPlayer(pack);
-		break;
-	}
-	case ServerOP_ExpeditionDzMakeLeader:
-	{
-		ExpeditionMessage::MakeLeader(pack);
-		break;
-	}
-	case ServerOP_ExpeditionCharacterLockout:
-	{
-		auto buf = reinterpret_cast<ServerExpeditionCharacterLockout_Struct*>(pack->pBuffer);
-		auto cle = client_list.FindCLEByCharacterID(buf->character_id);
-		if (cle && cle->Server())
-		{
-			cle->Server()->SendPacket(pack);
-		}
-		break;
-	}
-	case ServerOP_ExpeditionSaveInvite:
-	{
-		ExpeditionMessage::SaveInvite(pack);
-		break;
-	}
-	case ServerOP_ExpeditionRequestInvite:
-	{
-		ExpeditionMessage::RequestInvite(pack);
-		break;
-	}
-	}
-}
-
-void ExpeditionMessage::AddPlayer(ServerPacket* pack)
-{
-	auto buf = reinterpret_cast<ServerDzCommand_Struct*>(pack->pBuffer);
-
-	ClientListEntry* invited_cle = client_list.FindCharacter(buf->target_name);
-	if (invited_cle && invited_cle->Server())
-	{
-		// continue in the add target's zone
-		buf->is_char_online = true;
-		invited_cle->Server()->SendPacket(pack);
-	}
-	else
-	{
-		// add target not online, return to inviter
-		ClientListEntry* inviter_cle = client_list.FindCharacter(buf->requester_name);
-		if (inviter_cle && inviter_cle->Server())
-		{
-			inviter_cle->Server()->SendPacket(pack);
-		}
-	}
-}
-
-void ExpeditionMessage::MakeLeader(ServerPacket* pack)
-{
-	auto buf = reinterpret_cast<ServerDzCommandMakeLeader_Struct*>(pack->pBuffer);
-
-	// notify requester (old leader) and new leader of the result
-	ZoneServer* new_leader_zs = nullptr;
-	ClientListEntry* new_leader_cle = client_list.FindCharacter(buf->new_leader_name);
-	if (new_leader_cle && new_leader_cle->Server())
-	{
-		auto dz = DynamicZone::FindDynamicZoneByID(buf->dz_id);
-		if (dz && dz->GetLeaderID() == buf->requester_id)
-		{
-			buf->is_success = dz->SetNewLeader(new_leader_cle->CharID());
-		}
-
-		buf->is_online = true;
-		new_leader_zs = new_leader_cle->Server();
-		new_leader_zs->SendPacket(pack);
-	}
-
-	// if old and new leader are in the same zone only send one message
-	ClientListEntry* requester_cle = client_list.FindCLEByCharacterID(buf->requester_id);
-	if (requester_cle && requester_cle->Server() && requester_cle->Server() != new_leader_zs)
-	{
-		requester_cle->Server()->SendPacket(pack);
-	}
-}
-
-void ExpeditionMessage::SaveInvite(ServerPacket* pack)
-{
-	auto buf = reinterpret_cast<ServerDzCommand_Struct*>(pack->pBuffer);
-
-	ClientListEntry* invited_cle = client_list.FindCharacter(buf->target_name);
-	if (invited_cle)
-	{
-		// store packet on cle and re-send it when client requests it
-		buf->is_char_online = true;
-		pack->opcode = ServerOP_ExpeditionDzAddPlayer;
-		invited_cle->SetPendingExpeditionInvite(pack);
-	}
-}
-
-void ExpeditionMessage::RequestInvite(ServerPacket* pack)
-{
-	auto buf = reinterpret_cast<ServerExpeditionCharacterID_Struct*>(pack->pBuffer);
-	ClientListEntry* cle = client_list.FindCLEByCharacterID(buf->character_id);
-	if (cle)
-	{
-		auto invite_pack = cle->GetPendingExpeditionInvite();
-		if (invite_pack && cle->Server())
-		{
-			cle->Server()->SendPacket(invite_pack.get());
-		}
-	}
-}
@@ -1,35 +0,0 @@
-/**
- * EQEmulator: Everquest Server Emulator
- * Copyright (C) 2001-2020 EQEmulator Development Team (https://github.com/EQEmu/Server)
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 2 of the License.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY except by those people which sell it, which
- * are required to give you total support for your newly bought product;
- * without even the implied warranty of MERCHANTABILITY or FITNESS FOR
- * A PARTICULAR PURPOSE. See the GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
- *
- */
-
-#ifndef WORLD_EXPEDITION_MESSAGE_H
-#define WORLD_EXPEDITION_MESSAGE_H
-
-class ServerPacket;
-
-namespace ExpeditionMessage
-{
-	void AddPlayer(ServerPacket* pack);
-	void HandleZoneMessage(ServerPacket* pack);
-	void MakeLeader(ServerPacket* pack);
-	void RequestInvite(ServerPacket* pack);
-	void SaveInvite(ServerPacket* pack);
-};
-
-#endif
@@ -46,8 +46,8 @@ void LoginServer::ProcessUsertoWorldReqLeg(uint16_t opcode, EQ::Net::Packet &p)
 	const WorldConfig *Config = WorldConfig::get();
 	LogNetcode("Received ServerPacket from LS OpCode {:#04x}", opcode);

-	UsertoWorldRequestLegacy_Struct *utwr  = (UsertoWorldRequestLegacy_Struct *) p.Data();
-	uint32                          id     = database.GetAccountIDFromLSID("eqemu", utwr->lsaccountid);
+	UsertoWorldRequestLegacy *utwr = (UsertoWorldRequestLegacy *) p.Data();
+	uint32                   id    = database.GetAccountIDFromLSID("eqemu", utwr->lsaccountid);
 	int16                           status = database.GetAccountStatus(id);

 	LogDebug(
@@ -63,11 +63,11 @@ void LoginServer::ProcessUsertoWorldReqLeg(uint16_t opcode, EQ::Net::Packet &p)

 	ServerPacket outpack;
 	outpack.opcode  = ServerOP_UsertoWorldRespLeg;
-	outpack.size    = sizeof(UsertoWorldResponseLegacy_Struct);
+	outpack.size    = sizeof(UsertoWorldResponseLegacy);
 	outpack.pBuffer = new uchar[outpack.size];
 	memset(outpack.pBuffer, 0, outpack.size);

-	UsertoWorldResponseLegacy_Struct *utwrs = (UsertoWorldResponseLegacy_Struct *) outpack.pBuffer;
+	UsertoWorldResponseLegacy *utwrs = (UsertoWorldResponseLegacy *) outpack.pBuffer;
 	utwrs->lsaccountid = utwr->lsaccountid;
 	utwrs->ToID        = utwr->FromID;
 	utwrs->worldid     = utwr->worldid;
@@ -126,8 +126,8 @@ void LoginServer::ProcessUsertoWorldReq(uint16_t opcode, EQ::Net::Packet &p)
 	const WorldConfig *Config = WorldConfig::get();
 	LogNetcode("Received ServerPacket from LS OpCode {:#04x}", opcode);

-	UsertoWorldRequest_Struct *utwr  = (UsertoWorldRequest_Struct *) p.Data();
-	uint32                    id     = database.GetAccountIDFromLSID(utwr->login, utwr->lsaccountid);
+	UsertoWorldRequest *utwr = (UsertoWorldRequest *) p.Data();
+	uint32             id    = database.GetAccountIDFromLSID(utwr->login, utwr->lsaccountid);
 	int16                     status = database.GetAccountStatus(id);

 	LogDebug(
@@ -143,11 +143,11 @@ void LoginServer::ProcessUsertoWorldReq(uint16_t opcode, EQ::Net::Packet &p)

 	ServerPacket outpack;
 	outpack.opcode  = ServerOP_UsertoWorldResp;
-	outpack.size    = sizeof(UsertoWorldResponse_Struct);
+	outpack.size    = sizeof(UsertoWorldResponse);
 	outpack.pBuffer = new uchar[outpack.size];
 	memset(outpack.pBuffer, 0, outpack.size);

-	UsertoWorldResponse_Struct *utwrs = (UsertoWorldResponse_Struct *) outpack.pBuffer;
+	UsertoWorldResponse *utwrs = (UsertoWorldResponse *) outpack.pBuffer;
 	utwrs->lsaccountid = utwr->lsaccountid;
 	utwrs->ToID        = utwr->FromID;
 	strn0cpy(utwrs->login, utwr->login, 64);
@@ -208,27 +208,27 @@ void LoginServer::ProcessLSClientAuthLegacy(uint16_t opcode, EQ::Net::Packet &p)
 	LogNetcode("Received ServerPacket from LS OpCode {:#04x}", opcode);

 	try {
-		auto client_authentication_request = p.GetSerialize<ClientAuthLegacy_Struct>(0);
+		auto r = p.GetSerialize<ClientAuthLegacy>(0);

 		LogDebug(
-			"Processing Loginserver Auth Legacy | account_id [{0}] account_name [{1}] key [{2}] admin [{3}] ip [{4}] "
-			"local_network [{5}]",
-			client_authentication_request.loginserver_account_id,
-			client_authentication_request.loginserver_account_name,
-			client_authentication_request.key,
-			client_authentication_request.is_world_admin,
-			client_authentication_request.ip,
-			client_authentication_request.is_client_from_local_network
+			"Processing Loginserver Auth Legacy | account_id [{}] account_name [{}] key [{}] admin [{}] ip [{}] "
+			"local_network [{}]",
+			r.loginserver_account_id,
+			r.loginserver_account_name,
+			r.key,
+			r.is_world_admin,
+			r.ip_address,
+			r.is_client_from_local_network
 		);

 		client_list.CLEAdd(
-			client_authentication_request.loginserver_account_id,
+			r.loginserver_account_id,
 			"eqemu",
-			client_authentication_request.loginserver_account_name,
-			client_authentication_request.key,
-			client_authentication_request.is_world_admin,
-			client_authentication_request.ip,
-			client_authentication_request.is_client_from_local_network
+			r.loginserver_account_name,
+			r.key,
+			r.is_world_admin,
+			r.ip_address,
+			r.is_client_from_local_network
 		);
 	}
 	catch (std::exception &ex) {
@@ -242,28 +242,28 @@ void LoginServer::ProcessLSClientAuth(uint16_t opcode, EQ::Net::Packet &p)
 	LogNetcode("Received ServerPacket from LS OpCode {:#04x}", opcode);

 	try {
-		auto client_authentication_request = p.GetSerialize<ClientAuth_Struct>(0);
+		auto r = p.GetSerialize<ClientAuth>(0);

 		LogDebug(
-			"Processing Loginserver Auth | account_id [{0}] account_name [{1}] loginserver_name [{2}] key [{3}] "
-			"admin [{4}] ip [{5}] local_network [{6}]",
-			client_authentication_request.loginserver_account_id,
-			client_authentication_request.account_name,
-			client_authentication_request.loginserver_name,
-			client_authentication_request.key,
-			client_authentication_request.is_world_admin,
-			client_authentication_request.ip,
-			client_authentication_request.is_client_from_local_network
+			"Processing Loginserver Auth | account_id [{}] account_name [{}] loginserver_name [{}] key [{}] "
+			"admin [{}] ip [{}] local_network [{}]",
+			r.loginserver_account_id,
+			r.account_name,
+			r.loginserver_name,
+			r.key,
+			r.is_world_admin,
+			r.ip_address,
+			r.is_client_from_local_network
 		);

 		client_list.CLEAdd(
-			client_authentication_request.loginserver_account_id,
-			client_authentication_request.loginserver_name,
-			client_authentication_request.account_name,
-			client_authentication_request.key,
-			client_authentication_request.is_world_admin,
-			client_authentication_request.ip,
-			client_authentication_request.is_client_from_local_network
+			r.loginserver_account_id,
+			r.loginserver_name,
+			r.account_name,
+			r.key,
+			r.is_world_admin,
+			r.ip_address,
+			r.is_client_from_local_network
 		);
 	}
 	catch (std::exception &ex) {
@@ -76,10 +76,10 @@
 #include "web_interface.h"
 #include "console.h"
 #include "dynamic_zone_manager.h"
-#include "expedition_database.h"

 #include "world_server_cli.h"
 #include "../common/content/world_content_service.h"
+#include "../common/repositories/character_expedition_lockouts_repository.h"
 #include "../common/repositories/character_task_timers_repository.h"
 #include "../common/zone_store.h"
 #include "world_event_scheduler.h"
@@ -449,7 +449,7 @@ int main(int argc, char **argv)
 		if (PurgeInstanceTimer.Check()) {
 			database.PurgeExpiredInstances();
 			database.PurgeAllDeletedDataBuckets();
-			ExpeditionDatabase::PurgeExpiredCharacterLockouts();
+			CharacterExpeditionLockoutsRepository::DeleteWhere(database, "expire_time <= NOW()");
 			CharacterTaskTimersRepository::DeleteWhere(database, "expire_time <= NOW()");
 		}

@@ -1172,7 +1172,7 @@ void SharedTaskManager::CreateDynamicZone(SharedTask *shared_task, DynamicZone &
 		}
 	}

-	auto new_dz = dynamic_zone_manager.CreateNew(dz_request, dz_members);
+	auto new_dz = dynamic_zone_manager.TryCreate(dz_request, dz_members);
 	if (new_dz) {
 		auto shared_task_dz = SharedTaskDynamicZonesRepository::NewEntity();
 		shared_task_dz.shared_task_id  = shared_task->GetDbSharedTask().id;
@@ -283,7 +283,7 @@ void SharedTaskWorldMessaging::HandleZoneMessage(ServerPacket *pack)
 			auto t = shared_task_manager.FindSharedTaskByTaskIdAndCharacterId(buf->task_id, buf->source_character_id);
 			if (t) {
 				DynamicZone dz;
-				dz.LoadSerializedDzPacket(buf->cereal_data, buf->cereal_size);
+				dz.Unserialize({ buf->cereal_data, buf->cereal_size });

 				shared_task_manager.CreateDynamicZone(t, dz);
 			}
@@ -5,12 +5,12 @@
 #include "../common/http/uri.h"
 #include "../common/net/console_server.h"
 #include "../common/net/servertalk_server.h"
+#include "../common/repositories/character_expedition_lockouts_repository.h"
 #include "../common/repositories/character_task_timers_repository.h"
 #include "../common/rulesys.h"
 #include "../common/strings.h"
 #include "adventure_manager.h"
 #include "dynamic_zone_manager.h"
-#include "expedition_database.h"
 #include "login_server_list.h"
 #include "shared_task_manager.h"
 #include "ucs.h"
@@ -101,6 +101,13 @@ bool WorldBoot::HandleCommandInput(int argc, char **argv)
 		}
 	}

+	// check if we ran a valid command, this whole CLI handler needs to be improved at a later time
+	std::string arg1 = argc >= 2 ? argv[1] : "";
+	if (argc >= 2 && !Strings::Contains(arg1, ":")) {
+		std::cout << "Invalid command, use --help to see available commands" << std::endl;
+		return true;
+	}
+
 	return false;
 }

@@ -367,9 +374,8 @@ bool WorldBoot::DatabaseLoadRoutines(int argc, char **argv)
 	LogInfo("Purging expired dynamic zones and members");
 	dynamic_zone_manager.PurgeExpiredDynamicZones();

-	LogInfo("Purging expired expeditions");
-	ExpeditionDatabase::PurgeExpiredExpeditions();
-	ExpeditionDatabase::PurgeExpiredCharacterLockouts();
+	LogInfo("Purging expired character expedition lockouts");
+	CharacterExpeditionLockoutsRepository::DeleteWhere(database, "expire_time <= NOW()");

 	LogInfo("Purging expired character task timers");
 	CharacterTaskTimersRepository::DeleteWhere(database, "expire_time <= NOW()");
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Chris Miles	2b79a36014	[Release] 23.1.0 (#4736 ) * [Release] 23.1.0 * Version * Pet table last minute add in	2025-03-01 19:23:50 -06:00
Akkadius	8cf52294e9	[Hotfix] Add character_pet_name to player tables schema	2025-03-01 18:56:38 -06:00
Chris Miles	0ef79903f8	[Crash] Validate item in SE_SummonItemIntoBag (#4734 )	2025-03-01 18:32:43 -06:00
Chris Miles	ab14458f9e	[Crash] Fix large file size crash in File::GetContents for windows (#4735 )	2025-03-01 18:32:35 -06:00
Chris Miles	5b94e736b3	[Crash] Fix reload concurrency crash when ran from Spire (#4733 )	2025-03-01 18:05:28 -06:00
Chris Miles	c3b8cc9744	[Crash] Check for directory existence before traversing in CheckForCompatibleQuestPlugins (#4730 )	2025-03-01 20:01:37 -04:00
Mitch Freeman	89e3b2c72e	[Fix] Add client packets to questmanager:setguild (#4732 )	2025-03-01 17:55:44 -06:00
Chris Miles	23c4aa241b	[Crash] World CLI validation (#4728 ) * [Crash] World CLI validation * Clean	2025-03-01 19:52:51 -04:00
Chris Miles	acb7584e26	[Loginserver] Minor cleanup (#4729 )	2025-03-01 19:52:21 -04:00
Chris Miles	a885bd9322	[Crash] Fix filesystem crash / exception in DatabaseDumpService::RemoveCredentialsFile() (#4731 )	2025-03-01 19:51:41 -04:00
Chris Miles	20fe1926e0	[Database] Remove force_interactive from big bag updates (#4727 )	2025-03-01 16:55:57 -06:00
Chris Miles	eb7118754b	[Zone State] Wrap all serialization/deserialization in try/catch (#4726 )	2025-03-01 16:46:08 -06:00
Mitch Freeman	3611b49f68	[Feature] Evolving items Additions (#4725 ) * Implement multi-value for evolving sub_types - Added ability for evolving sub_types to contain multiple values - Implemented EvolvingItems::Types::NUMBER_OF_KILLS with level for sub_type * Repair a timer issue preventing proper evolution of items * Simplify * Remove extra level of nesting * Update client_evolving_items.cpp --------- Co-authored-by: Akkadius <akkadius1@gmail.com>	2025-03-01 16:38:59 -06:00
catapultam-habeo	511d8a8bb3	[Bug Fix] Refactor ApplyItemBonuses to fix double-counting of ATK and recommended levels not correctly applying (#4713 ) * refactor AddItemBonuses * typo * simplify some syntax * fix indents * Revert "fix indents" This reverts commit `8e660707a9`. * fix indents without blowing up entire file * Revert "fix indents without blowing up entire file" This reverts commit `6b21d1bcc9`. * ok for real though * Undo spaces in formatting, source uses tabs * Spaces to tabs take 2 --------- Co-authored-by: Akkadius <akkadius1@gmail.com>	2025-02-28 21:04:42 -06:00
catapultam-habeo	1598d2e17b	[Feature] Add a rule for spells to bypass stacking rules (#4716 ) * define rule that allows for spells which always stack * Update spells.cpp --------- Co-authored-by: Akkadius <akkadius1@gmail.com>	2025-02-28 16:49:20 -06:00
nytmyr	805757ba87	[Bots] Fix unresponsive bots in groups upon group wipe (#4712 ) - Bots were failing to recall their group after dying due to the way it was grabbing the group from entity list.	2025-02-28 16:10:46 -06:00
Chris Miles	eb6ac25540	[Code Cleanup] More login <-> world code cleanup (#4724 ) * More cleanup * More cleanup	2025-02-28 16:08:06 -06:00
MortimerGreenwald	cb634cf57d	[Bug Fix] Fix Trading Items to Bot Pets (#4721 ) Small change using IsPetOwnerOfClientBot() instead of just IsPetOwnerClient Can bot pet take item? not before, but hopefully now?	2025-02-28 15:54:38 -06:00
Chris Miles	2f7ca2cdc8	[Zone] Implement Zone State Saving on Shutdown (#4715 ) * Save spawns * Update base_zone_state_spawns_repository.h * Zone state save work * Code cleanup * More cleanup * Database migration * Update database_update_manifest.cpp * Revert decay at storage model * Code cleanup * More cleanup * More cleanup * More cleanup * Entity variables * Add entity variables to the schema * Post rebase * Checkpoint * Serialize / deserialize buffs * Current hp / mana / end save / load * Save / load current_waypoint * Add zone spawn protection * Finishing touches * Cleanup * Update zone_save_state.cpp * Cleanup * Update zone_save_state.cpp * Update npc.cpp * Update npc.cpp * More * Update perl_npc.cpp * Update zone_loot.cpp	2025-02-28 15:31:06 -06:00
Chris Miles	425d24c1f4	[Quest API] Implement eq.handin() and quest::handin() (#4718 ) * [Quest API] Implement eq.handin() and quest::handin() * Fix MQ using new API style	2025-02-28 15:22:39 -06:00
Alex King	875df8e64a	[Quest API] Add Key Ring Methods to Perl and Lua (#4719 )	2025-02-28 15:08:57 -06:00
Alex King	7a2d2a0c51	[Bug Fix] Fix AA Reset Error Message (#4720 ) * [Bug Fix] Fix AA Reset Error Message * Update client.cpp * Update client.cpp	2025-02-28 15:06:49 -06:00
Alex King	5296202e56	[Bug Fix] Fix Issue with Suffixes/Prefixes (#4723 )	2025-02-28 15:05:57 -06:00
Akkadius	e2db8ffea8	[Hotfix] Clear m_completed_shared_tasks before reloading	2025-02-24 17:24:18 -06:00
Chris Miles	fa2ab11676	[Tasks] Extend IsTaskCompleted to also be aware of shared task completion (#4714 ) * [Tasks] Extend IsTaskCompleted to also be aware of shared task completion * Fix my stupidity * Update client.h	2025-02-24 16:31:35 -06:00
Chris Miles	80e8634a48	[Release] 23.0.2 (#4711 )	2025-02-21 23:18:29 -06:00
zimp-wow	98c2fa5127	[Bug Fix] Fix bad Mob reference in QuestManager::resumetimer() (#4710 )	2025-02-21 23:14:50 -06:00
nytmyr	8b8b41dab3	[Bots] Add checks to ensure bots and pets do not engage on ^pull (#4708 )	2025-02-21 23:13:54 -06:00
nytmyr	63b1e6b4b4	[Bots] Improve positioning (#4709 ) - Prevent bots not set to ^behindmob from finding positions behind their target. - Backs up a bot if they're too close and have target reflection, not just taunting bots. - Backs up bots if the target is rooting and they are not taunting to the appropriate position. - This will particularly help with casters running around.	2025-02-21 23:12:50 -06:00
nytmyr	21b7b6e7ab	[Bots] Prevent medding in combat if any mob has bot targeted (#4707 ) - Previously this only checked the bots target to med. It will now check the hatelist of the bot to ensure no mobs have the bot targeted before medding.	2025-02-21 23:12:29 -06:00
Alex King	878a5377ae	[Bug Fix] Fix Lua Zone ID Exports (#4700 )	2025-02-21 23:12:04 -06:00
Alex King	486c7c44be	[Quest API] Add GetSpawn() to Perl and Lua (#4702 ) * [Quest API] Add GetSpawn() to Perl and Lua * Push * Update npc.h	2025-02-21 22:57:41 -06:00
nytmyr	aa4869c6e9	[Hotfix] Fix cursor load on zone (#4704 ) * [Hotfix] Fix cursor load on zone - Corrects an issue where the item on your cursor would become invisible upon trying to place it anywhere in your inventory. * Remove general to prevent duplicate loads	2025-02-21 22:54:35 -06:00
zimp-wow	94e1b4edfa	[Bug Fix] Fix infinite loop in QuestManager::stoptimer() (#4703 )	2025-02-20 19:52:08 -05:00
Akkadius	4d73b7d641	[Release] 23.0.1	2025-02-20 02:48:01 -06:00
Chris Miles	ed4f9b0d30	[Fix] Player event ordering merge fix (#4699 )	2025-02-20 02:46:24 -06:00
Alex King	f8837d0926	[Quest API] Add DisableRespawnTimers to Perl and Lua (#4691 ) * [Quest API] Add DisableRespawnTimers to Perl and Lua * Update lua_zone.h * Update lua_zone.cpp * Change up how we're doing this --------- Co-authored-by: Akkadius <akkadius1@gmail.com>	2025-02-20 00:26:46 -06:00
Chris Miles	753d83c499	[Release] 23.0.0 (#4698 ) * [Release] 23.0.0 * Update CHANGELOG.md * Fix migration	2025-02-20 00:17:40 -06:00
Alex	f0108826d3	[Client Mod] Adds a hacked fast camp rule for GMs (#4697 ) Co-authored-by: KimLS <KimLS@peqtgc.com>	2025-02-19 23:20:22 -06:00
Chris Miles	6ac846c003	[Fix] Fix issue with getting an unset nested databucket (#4693 )	2025-02-19 13:28:02 -06:00
Chris Miles	44963f3f21	[Fix] #rq and #reload quest alias (#4694 )	2025-02-18 13:28:07 -06:00
Chris Miles	9fd935ef10	[Fix] Prevent zone from loading ETL ID's on bootup (#4696 )	2025-02-18 13:27:56 -06:00
Chris Miles	6f390c81f9	[Fix] Fix non-error in player_event_logs (#4695 )	2025-02-18 13:27:43 -06:00
Chris Miles	1bd281c8f2	[Performance] Server Reload Overhaul (#4689 ) * [Performance] Server Reload Overhaul * Client::SendReloadCommandMessages * Remove global buffs	2025-02-18 00:54:37 -06:00
Chris Miles	49cf97ae9c	[Databuckets] Add Zone Scoped Databuckets (#4690 ) * [Databuckets] Add Zone Scoped Databuckets * Add database indexes * Update database_update_manifest.cpp * Shutdown fix * Testing * Perf boost * Revert "Perf boost" This reverts commit `55d3e507d3`. * Update data_bucket.cpp	2025-02-18 00:14:49 -06:00
MortimerGreenwald	8315240b17	[Bug Fix] Find Zone - Expansion Settings (#4692 ) * Bug Fix Find Zone - Expansion Settings #fz expansion 30 Would crash your zone since the expansions don't go up that high. This Adds a check for range out of bounds and provides an exception to expansion 99 since those are test/dev zones. * Update zone.cpp * Update zone.cpp * Update zone.cpp --------- Co-authored-by: Kinglykrab <kinglykrab@gmail.com>	2025-02-17 23:37:35 -05:00
hg	55155ff800	[Expeditions] Move expedition code into DynamicZone (#4672 ) This removes the separate Expedition class and moves lockout code and /dz command handlers into DynamicZone classes. It also refactors some code to reduce bloat and some database usage. This completes the effort of moving everything to DynamicZone that started when implementing shared tasks. It also makes sense to do this since expeditions are just dynamic zones internally despite dzs being used for other types. Expedition specific things are just handled with dz type checks. Functionally nothing should change. This is mainly internal refactoring and moving code around along with some bug fixes and reduced database usage. Main changes: - The `expeditions` database table has been removed - Expeditions no longer use a separate id, the expedition id is just the dz id - Expedition lock state and replay timer option were moved to the `dynamic_zones` table - Expeditions no longer have a separate cache from dynamic zones - Expedition creation no longer has every zone query the database to cache it - Expedition internal lockouts are now stored on DynamicZone - The `expedition_lockouts` table has been renamed to `dynamic_zone_lockouts` - Fixed a small bug with the UpdateLockoutDuration api where the internal lockout would get the time added twice in memory in the initiating zone (this api is likely rarely used) - Fixed an issue where use of the group/raid DoesAnyMemberHaveExpeditionLockout api would query once for every out of zone character. - This api now checks all members in the current zone first and only performs a single bulk query for out of zone members if that check is exhausted - Deprecated the max_check_count param of DoesAnyMemberHaveExpeditionLockout, the quest api still exists to avoid api break but a passed arg has no effect	2025-02-15 18:40:35 -06:00
Mitch Freeman	ab4e1191ef	[Fix] Parcel Delivery Updates (#4688 ) * Fix two parcel bugs Fix two Parcel Bugs - If a player was at their parcel limit and perform a bazaar purchase via parcel delivery, their money would be lost - If a container with items was delivered via parcel, the parcel under certain inventory conditions could be delivered into an incorrect slot resulting in the container being lost. * Incorrect field used for BagSize vs ItemSize. Silly mistake. * Remove duplicate check and reorder stacking check * Fix edge case when Parcel Window remains open and Bazaar purchases are made. * Repair - bazaar purchase of items with charges reverting to 1 charge in error - bazaar visual error with selling price. Was caused by the parcel fee not being properly reflected in the client - corrected a type mismatch with parcel fee uint32 vs uin64 - corrected a few TraderPurchase and TraderSell event data points by splitting quantity and charges * Formatting * Use pre-existing AddMoney and TakeMoney and remove unnecessary routines * Updates after rebase	2025-02-15 18:27:09 -06:00
Mitch Freeman	c09fad5a75	[Feature] GuildBank Updates (#4674 ) * First pass of a re-write of Guild Bank to enable RoF2 features * Testing - Corrected a few bugs with merging, splitting and withdrawing * Testing - Corrected a few bugs with depositing of bags * Added player event logging for deposit, withdrawal and movement between deposit to main area. * Fix the guilddelete routine Fix the guilddelete routine as a result of the new guild_bank table structure * Fix an issue with items not being withdrawn correctly. * Final Testing Phase 1 - A few failures to be resolved yet. * Final Testing Phase 2 - Looks good * Final Testing Phase 3 - Repair a visual bug with withdrawal of items with charges * Cleanup * Formatting feedback updates * Rebase and fix version.h * Fix manifest issue after changes	2025-02-15 17:48:50 -06:00
Chris Miles	8201175c2c	[Fix] Item Handins to Pets (#4687 ) * [Fix] Item handins to pets * Update npc.cpp	2025-02-15 17:07:40 -06:00
Chris Miles	e88ea24966	[Fix] GMMove Update Edge Case With Clients (#4686 ) * [Fix] GMMove with clients * Exclude clients entirely for position update caching	2025-02-15 16:20:37 -06:00
nytmyr	02e2f6771c	[Bots] Fix AE range calculation (#4683 ) - Certain AE types weren't properly calculating their AE range and would base off the actual AE range for targeted types rather than the spells range itself	2025-02-15 15:41:08 -06:00
nytmyr	3b399dfac5	[Bots] Add missing stance options (#4681 ) - Moved stance check to function - Added check for Efficient and Assist stances. - Sets aggressive to ignore aggrochecks by default - Adds more types to default aggrocheck list - Sets Assist to hold CCs	2025-02-15 15:03:55 -06:00
nytmyr	9aa0f7c695	[Spells] Add all types to checks for max_targets_allowed rule for AEs (#4682 ) - Added all TargetedAE types to IsTargetableAESpell - Added IsTargetableAESpell to IsAnyAESpell and changed order for earlier escapes - IsPBAESpell now checks all PBAE types - The rule Spells, TargetedAOEMaxTargets will now check all Targeted AE types - The rule Spells, PointBlankAOEMaxTargets will now check all remaining types that can be a PBAE and not only Nuke PBAEs	2025-02-15 15:03:23 -06:00
nytmyr	3ba113a91d	[Bots] Fix pets causing aggro (#4677 ) - Adds the rule `Aggro, AggroBotPets`	2025-02-15 15:02:38 -06:00
nytmyr	b0c951bd6e	[Bots] Prevents casting on ineligible targets due to target type, stacking, etc. (#4680 ) - Prevents casting on ineligible targets due to target type, stacking, etc. - Adjust the rules Bots, MezChance, Bots, MezSuccessDelay and Bots, MezFailDelay	2025-02-15 15:01:39 -06:00
nytmyr	8a5f885558	[Bots] Add AEHateLine to HateLine ParentType (#4678 )	2025-02-15 15:00:54 -06:00
nytmyr	fd3f5cfd29	[Bots] Command Cleanup (#4676 ) - Fix ^discipline saying no bots were selected - Adds more information to certain commands to explain how they function. - Rewrote ^copysettings and ^defaultsettings to not be so bloated and accept arguments properly. - Added long names for setting categories - Add Spell ID output to ^spells	2025-02-15 15:00:14 -06:00
nytmyr	74b8cf8bd3	[Hotfix] Update pre big bag corpse slot_id's to support big bags (#4679 )	2025-02-15 14:58:39 -06:00
nytmyr	18685748f6	[Bots] Crash fixes related to GetNumberNeedingHealedInGroup (#4684 ) - Add pre-death checks and early returns - Cleanup pointers for GetUltimateSpellType checks - Rename IsBotSpellTypeOtherBeneficial to BotSpellTypeUsesTargetSettings - Rename GetUltimateSpellTypeDelayCheck to GetUltimateSpellTypeRecastCheck -Add entity validation to GetNumberNeedingHealedInGroup	2025-02-15 14:55:52 -06:00
nytmyr	da24bf467a	[Commands] Fix #goto not accepting proper heading (#4685 )	2025-02-15 11:12:23 -05:00
Alex King	e948a6815c	[Bug Fix] Fix Illusion Fade Texture Bug (#4673 ) * [Bug Fix] Fix Illusion Fade Texture Bug * Update spell_effects.cpp	2025-02-13 19:57:31 -06:00