minor bug fixes to SPA382

Fixing a few missing breaks and other minor bug fixes for SPA382

.drone.yml

@@ -15,7 +15,7 @@ volumes:
 
 steps:
   - name: Build Linux X64
-    image: akkadius/eqemu-server:v13
+    image: akkadius/eqemu-server:v14
     environment:
       GITHUB_TOKEN:
         from_secret: GH_RELEASE_GITHUB_API_TOKEN

CHANGELOG.md

@@ -1,3 +1,956 @@
+## [22.48.0] 3/23/2024
+
+### Bots
+
+* IsValidTarget Crash Fix ([#4187](https://github.com/EQEmu/Server/pull/4187)) @nytmyr 2024-03-12
+* Move BotGroupSay to Pet Response ([#4171](https://github.com/EQEmu/Server/pull/4171)) @nytmyr 2024-03-08
+
+### Code
+
+* Cleanup Zone Get Methods ([#4169](https://github.com/EQEmu/Server/pull/4169)) @Kinglykrab 2024-03-09
+
+### Fixes
+
+* An Update to Xtarget to exclude Bot owned Temp/Swarm Pets ([#4172](https://github.com/EQEmu/Server/pull/4172)) @MortimerGreenwald 2024-03-08
+* Fix #serverrules Command ([#4193](https://github.com/EQEmu/Server/pull/4193)) @Kinglykrab 2024-03-20
+* Fix Bot Cloning ([#4186](https://github.com/EQEmu/Server/pull/4186)) @Kinglykrab 2024-03-17
+* Fix Crash in ClientList::GetCLEIP ([#4173](https://github.com/EQEmu/Server/pull/4173)) @Kinglykrab 2024-03-10
+* Fix Default Value in `rule_values` table ([#4166](https://github.com/EQEmu/Server/pull/4166)) @Kinglykrab 2024-03-07
+* Fix EVENT_KILLED_MERIT firing before NPC removal ([#4185](https://github.com/EQEmu/Server/pull/4185)) @Kinglykrab 2024-03-17
+* Fix Empty Groups When Removing Bots ([#4178](https://github.com/EQEmu/Server/pull/4178)) @Kinglykrab 2024-03-14
+* Fix GetLeaderName() for Groups ([#4184](https://github.com/EQEmu/Server/pull/4184)) @Kinglykrab 2024-03-14
+* Fix Mob::CalculateDistance(mob) Typo ([#4183](https://github.com/EQEmu/Server/pull/4183)) @Kinglykrab 2024-03-10
+* Fix Proximity Say ([#4189](https://github.com/EQEmu/Server/pull/4189)) @Kinglykrab 2024-03-15
+* Fix ScaleNPC() in Perl ([#4196](https://github.com/EQEmu/Server/pull/4196)) @Kinglykrab 2024-03-23
+* Fix range_percent ([#4197](https://github.com/EQEmu/Server/pull/4197)) @Kinglykrab 2024-03-22
+* Fix reusing timers ([#4199](https://github.com/EQEmu/Server/pull/4199)) @joligario 2024-03-23
+
+### Hot Fix
+
+* Add bool return to fix Client::RemoveAAPoints ([#4176](https://github.com/EQEmu/Server/pull/4176)) @Kinglykrab 2024-03-09
+
+### Loot
+
+* Fix issue with nested data being loaded multiple times ([#4192](https://github.com/EQEmu/Server/pull/4192)) @Akkadius 2024-03-23
+
+### Misc
+
+* Windows preprocessor define in crash.cpp ([#4191](https://github.com/EQEmu/Server/pull/4191)) @joligario 2024-03-23
+
+### Quest API
+
+* Add Buff Support to Perl/Lua ([#4182](https://github.com/EQEmu/Server/pull/4182)) @Kinglykrab 2024-03-14
+* Add DeleteBot() to Perl/Lua ([#4167](https://github.com/EQEmu/Server/pull/4167)) @nytmyr 2024-03-07
+* Add GetDeityName() to Perl/Lua ([#4180](https://github.com/EQEmu/Server/pull/4180)) @Kinglykrab 2024-03-14
+* Add RemoveAAPoints() and AA Loss Event to Perl/Lua ([#4174](https://github.com/EQEmu/Server/pull/4174)) @Kinglykrab 2024-03-09
+* Add RemoveAlternateCurrencyValue() to Perl/Lua ([#4190](https://github.com/EQEmu/Server/pull/4190)) @Kinglykrab 2024-03-17
+* Add Restore Methods for Health, Mana, and Endurance to Perl/Lua ([#4179](https://github.com/EQEmu/Server/pull/4179)) @Kinglykrab 2024-03-23
+* Add Silent Saylink Methods to Perl/Lua ([#4177](https://github.com/EQEmu/Server/pull/4177)) @Kinglykrab 2024-03-14
+
+### Rules
+
+* Add World:Rules Rule ([#4194](https://github.com/EQEmu/Server/pull/4194)) @Kinglykrab 2024-03-23
+
+### Tradeskills
+
+* Implement learning recipes from books ([#4170](https://github.com/EQEmu/Server/pull/4170)) @hgtw 2024-03-23
+
+## [22.47.0] 3/5/2024
+
+### Crash Fix
+
+* Added a guild_mgr check ([#4163](https://github.com/EQEmu/Server/pull/4163)) @neckkola 2024-03-06
+* Goto Command could crash using Developer Tools ([#4158](https://github.com/EQEmu/Server/pull/4158)) @neckkola 2024-03-04
+* Groundspawn Memory Corruption ([#4157](https://github.com/EQEmu/Server/pull/4157)) @neckkola 2024-03-04
+* Update to location of qGlobals initialization ([#4144](https://github.com/EQEmu/Server/pull/4144)) @neckkola 2024-03-02
+
+### Feature
+
+* Adds rules to control level requirements for Double Backstab, Assassinate, and Double Bowshot  (#4159) ([#29](https://github.com/EQEmu/Server/pull/29)) @catapultam-habeo 2024-03-04
+* Adjust String-based Rules Length ([#4138](https://github.com/EQEmu/Server/pull/4138)) @Kinglykrab 2024-03-06
+* Exempt a zone from IP-limit checks. ([#4137](https://github.com/EQEmu/Server/pull/4137)) @catapultam-habeo 2024-03-02
+
+### Fixes
+
+* Add id to the guild_bank table ([#4155](https://github.com/EQEmu/Server/pull/4155)) @neckkola 2024-03-05
+* Fix Bots/Bot Pets ending up on XTargets ([#4132](https://github.com/EQEmu/Server/pull/4132)) @Kinglykrab 2024-03-02
+* Fix Character EXP Modifiers default ([#4161](https://github.com/EQEmu/Server/pull/4161)) @Kinglykrab 2024-03-06
+* Fix Spawns Not Parsing Quest on Zone Bootup ([#4149](https://github.com/EQEmu/Server/pull/4149)) @Kinglykrab 2024-03-05
+* Fix typo when updating spawn events in spawn condition manager ([#4160](https://github.com/EQEmu/Server/pull/4160)) @joligario 2024-03-05
+* GetBotNameByID Temporary Reference Warning ([#4145](https://github.com/EQEmu/Server/pull/4145)) @Kinglykrab 2024-03-02
+* Prevent NPE when creating DZ using ad-hoc version IDs ([#4141](https://github.com/EQEmu/Server/pull/4141)) @catapultam-habeo 2024-03-05
+* Update FreeGuildID Routine ([#4143](https://github.com/EQEmu/Server/pull/4143)) @neckkola 2024-03-02
+
+### Quest API
+
+* Add Bot Special Attacks for Immune Aggro/Damage ([#4108](https://github.com/EQEmu/Server/pull/4108)) @Kinglykrab 2024-03-02
+* Add GetHeroicStrikethrough() to Perl/Lua ([#4150](https://github.com/EQEmu/Server/pull/4150)) @Kinglykrab 2024-03-03
+* Add IsAlwaysAggro() to Perl/Lua ([#4152](https://github.com/EQEmu/Server/pull/4152)) @Kinglykrab 2024-03-04
+* Add IsBoat()/IsControllableBoat() to Perl/Lua ([#4151](https://github.com/EQEmu/Server/pull/4151)) @Kinglykrab 2024-03-03
+* Add IsDestructibleObject() to Perl/Lua ([#4153](https://github.com/EQEmu/Server/pull/4153)) @Kinglykrab 2024-03-03
+
+### Zone
+
+* Zone Routing Improvements ([#4142](https://github.com/EQEmu/Server/pull/4142)) @Akkadius 2024-03-02
+
+### Zoning
+
+* Zone routing adjustment ([#4162](https://github.com/EQEmu/Server/pull/4162)) @Akkadius 2024-03-06
+
+## [22.46.1] 3/2/2024
+
+### Fixes
+
+* Change `UnburyCorpse` to use repository methods ([#4147](https://github.com/EQEmu/Server/pull/4147)) @joligario 2024-03-03
+
+## [22.46.0] 3/2/2024
+
+### Commands
+
+* Add #fish Command ([#4136](https://github.com/EQEmu/Server/pull/4136)) @Kinglykrab 2024-03-01
+
+### Crash Fix
+
+* Raid::UpdateGroupAAs ([#4139](https://github.com/EQEmu/Server/pull/4139)) @neckkola 2024-03-02
+* Update to location of qGlobals initialization ([#4144](https://github.com/EQEmu/Server/pull/4144)) @neckkola 2024-03-02
+
+### Feature
+
+* Exempt a zone from IP-limit checks. ([#4137](https://github.com/EQEmu/Server/pull/4137)) @catapultam-habeo 2024-03-02
+
+### Fixes
+
+* Cleanup NPC Mana Tap Logic ([#4134](https://github.com/EQEmu/Server/pull/4134)) @noudess 2024-03-02
+* Fix Bots/Bot Pets ending up on XTargets ([#4132](https://github.com/EQEmu/Server/pull/4132)) @Kinglykrab 2024-03-02
+* Fix issue with NPC Secondary Textures ([#4129](https://github.com/EQEmu/Server/pull/4129)) @Kinglykrab 2024-03-01
+* GetBotNameByID Temporary Reference Warning ([#4145](https://github.com/EQEmu/Server/pull/4145)) @Kinglykrab 2024-03-02
+* Update FreeGuildID Routine ([#4143](https://github.com/EQEmu/Server/pull/4143)) @neckkola 2024-03-02
+* Use std::clamp for Mob::ChangeSize ([#4140](https://github.com/EQEmu/Server/pull/4140)) @joligario 2024-03-02
+
+### Quest API
+
+* Add Bot Special Attacks for Immune Aggro/Damage ([#4108](https://github.com/EQEmu/Server/pull/4108)) @Kinglykrab 2024-03-02
+
+### Zone
+
+* Zone Routing Improvements ([#4142](https://github.com/EQEmu/Server/pull/4142)) @Akkadius 2024-03-02
+
+## [22.45.1] 2/29/2024
+
+### Character Creation
+
+* Improved Random Name Generator ([#4081](https://github.com/EQEmu/Server/pull/4081)) @catapultam-habeo 2024-02-27
+
+### Code
+
+* Fix Server Rules Documentation Generation ([#4125](https://github.com/EQEmu/Server/pull/4125)) @Kinglykrab 2024-02-26
+* Remove unnecessary stoptimer logs ([#4128](https://github.com/EQEmu/Server/pull/4128)) @Kinglykrab 2024-02-28
+
+### Commands
+
+* Add `#forage` command ([#4133](https://github.com/EQEmu/Server/pull/4133)) @joligario 2024-02-29
+
+### Crash
+
+* Fix crash issue during database dump ([#4127](https://github.com/EQEmu/Server/pull/4127)) @Akkadius 2024-02-29
+
+### Crash Fix
+
+* D20 crash if mitigation average resulted in 0 ([#4131](https://github.com/EQEmu/Server/pull/4131)) @nytmyr 2024-02-29
+
+### Fixes
+
+* Fix forage returning first result from table ([#4130](https://github.com/EQEmu/Server/pull/4130)) @nytmyr 2024-02-29
+* Who /all displays incorrect guild name ([#4123](https://github.com/EQEmu/Server/pull/4123)) @neckkola 2024-02-25
+
+### Quest API
+
+* Add Pet Owner Methods to Perl/Lua ([#4115](https://github.com/EQEmu/Server/pull/4115)) @Kinglykrab 2024-02-25
+
+## [22.45.0] 2/24/2024
+
+### Beacon
+
+* Revert a few lines of PR #4024 that broke beacons ([#4118](https://github.com/EQEmu/Server/pull/4118)) @noudess 2024-02-24
+
+### Bots
+
+* Cleanup empty `bot_commands` files ([#4095](https://github.com/EQEmu/Server/pull/4095)) @Kinglykrab 2024-02-19
+* Remove Alt Combat Functionality ([#4067](https://github.com/EQEmu/Server/pull/4067)) @Kinglykrab 2024-02-12
+
+### Code
+
+* Update fmt to 10.2.1 ([#4071](https://github.com/EQEmu/Server/pull/4071)) @hgtw 2024-02-16
+* Use explicit conversions for enum formatting ([#4064](https://github.com/EQEmu/Server/pull/4064)) @hgtw 2024-02-12
+
+### Database
+
+* Add content_database flag for zone changes ([#4104](https://github.com/EQEmu/Server/pull/4104)) @joligario 2024-02-20
+* Remove "item_tick" from database schema per https://github.com/EQEmu/Server/pull/3985 ([#4083](https://github.com/EQEmu/Server/pull/4083)) @Akkadius 2024-02-16
+
+### Expansions
+
+* Zone Expansion Version Routing ([#4084](https://github.com/EQEmu/Server/pull/4084)) @Akkadius 2024-02-20
+
+### Factions
+
+* Fix issue with npcedit and cached factions ([#4103](https://github.com/EQEmu/Server/pull/4103)) @noudess 2024-02-20
+
+### Feature
+
+* Add Augments to Starting Items for Bots/Players ([#4100](https://github.com/EQEmu/Server/pull/4100)) @Kinglykrab 2024-02-21
+* Hot Zone Bonus XP Notice ([#4091](https://github.com/EQEmu/Server/pull/4091)) @fryguy503 2024-02-18
+
+### Fixes
+
+* Add safety check to SummonAllCharacterCorpses. ([#4107](https://github.com/EQEmu/Server/pull/4107)) @fryguy503 2024-02-21
+* Added additional Guild-related crash checks ([#4105](https://github.com/EQEmu/Server/pull/4105)) @neckkola 2024-02-22
+* Aura effect spell id from #3964 ([#4094](https://github.com/EQEmu/Server/pull/4094)) @joligario 2024-02-18
+* Crash on Ubuntu 22.04 ([#4119](https://github.com/EQEmu/Server/pull/4119)) @neckkola 2024-02-25
+* Fix #wpadd Query ([#4078](https://github.com/EQEmu/Server/pull/4078)) @Kinglykrab 2024-02-14
+* Fix Bot Weapons with No Races ([#4110](https://github.com/EQEmu/Server/pull/4110)) @Kinglykrab 2024-02-25
+* Fix ClearSpawnTimers() ([#4073](https://github.com/EQEmu/Server/pull/4073)) @Kinglykrab 2024-02-13
+* Fix Issue with ClearSpawnTimers() ([#4070](https://github.com/EQEmu/Server/pull/4070)) @Kinglykrab 2024-02-13
+* Fix ObjectContentsRepository using content_db ([#4076](https://github.com/EQEmu/Server/pull/4076)) @Kinglykrab 2024-02-14
+* Fix Sympathetic Procs for Bots/Mercenariess ([#4086](https://github.com/EQEmu/Server/pull/4086)) @Kinglykrab 2024-02-19
+* Fix fix_z Query ([#4080](https://github.com/EQEmu/Server/pull/4080)) @Kinglykrab 2024-02-15
+* Fix hotzone string error ([#4109](https://github.com/EQEmu/Server/pull/4109)) @fryguy503 2024-02-22
+* Fix issue with IsEntOnHateList ([#4097](https://github.com/EQEmu/Server/pull/4097)) @Kinglykrab 2024-02-19
+* Fix manifest check on `base_data` change ([#4082](https://github.com/EQEmu/Server/pull/4082)) @joligario 2024-02-16
+* Revert 2df7d19 ([#4101](https://github.com/EQEmu/Server/pull/4101)) @joligario 2024-02-20
+* Update database_schema to add guild_permissions ([#4085](https://github.com/EQEmu/Server/pull/4085)) @neckkola 2024-02-16
+
+### Guilds
+
+* Fixes for Guild Bank ([#4120](https://github.com/EQEmu/Server/pull/4120)) @neckkola 2024-02-25
+
+### Logs
+
+* Fix log in BaseGuildManager::IsGuildLeader() ([#4102](https://github.com/EQEmu/Server/pull/4102)) @joligario 2024-02-20
+
+### Opcodes
+
+* Fix opcode reloading ([#4075](https://github.com/EQEmu/Server/pull/4075)) @Akkadius 2024-02-14
+
+### Quest API
+
+* Add Bot Methods to Perl/Lua ([#4113](https://github.com/EQEmu/Server/pull/4113)) @Kinglykrab 2024-02-25
+* Add Entity Variable Events to Perl/Lua ([#4092](https://github.com/EQEmu/Server/pull/4092)) @Kinglykrab 2024-02-20
+* Add GetAugmentIDs() to Perl/Lua ([#4114](https://github.com/EQEmu/Server/pull/4114)) @Kinglykrab 2024-02-25
+* Add GetNPCSpellsEffectsID() to Perl/Lua ([#4117](https://github.com/EQEmu/Server/pull/4117)) @Kinglykrab 2024-02-25
+* Add Hatelist Count Methods to Perl/Lua ([#4106](https://github.com/EQEmu/Server/pull/4106)) @Kinglykrab 2024-02-21
+* Add IsInAGuild() to Perl/Lua ([#4066](https://github.com/EQEmu/Server/pull/4066)) @Kinglykrab 2024-02-14
+* Add Pet Methods to Perl/Lua ([#4116](https://github.com/EQEmu/Server/pull/4116)) @Kinglykrab 2024-02-25
+* Add Timer Events to Perl/Lua ([#4099](https://github.com/EQEmu/Server/pull/4099)) @Kinglykrab 2024-02-19
+* Add spell cast methods to Lua ([#4096](https://github.com/EQEmu/Server/pull/4096)) @Kinglykrab 2024-02-19
+* Add tracebacks to Lua error messages ([#4079](https://github.com/EQEmu/Server/pull/4079)) @hgtw 2024-02-16
+* Export Combat Record to Death Events ([#4112](https://github.com/EQEmu/Server/pull/4112)) @Kinglykrab 2024-02-25
+
+### Repositories
+
+* Cleanup and Convert Character Creation to Repositories ([#4053](https://github.com/EQEmu/Server/pull/4053)) @Kinglykrab 2024-02-20
+* Convert Zone Flags to Repositories ([#4077](https://github.com/EQEmu/Server/pull/4077)) @Kinglykrab 2024-02-16
+* Update `zone` base repository from #4084 ([#4111](https://github.com/EQEmu/Server/pull/4111)) @joligario 2024-02-23
+
+## [22.44.5] - 2/12/2024
+
+### Fixes
+
+* [Hotfix] Fix issues where we're using the wrong database pointers @Akkadius
+
+## [22.44.4] - 2/12/2024
+
+### Fixes
+
+* Fix ClearSpawnTimers() ([#4073](https://github.com/EQEmu/Server/pull/4073)) @Kinglykrab 2024-02-13
+
+## [22.44.3] - 2/12/2024
+
+### Fixes
+
+* Fix Issue with ClearSpawnTimers() ([#4070](https://github.com/EQEmu/Server/pull/4070)) @Kinglykrab 2024-02-13
+
+## [22.44.2] - 2/12/2024
+
+### Bots
+
+* Remove Alt Combat Functionality ([#4067](https://github.com/EQEmu/Server/pull/4067)) @Kinglykrab 2024-02-12
+
+### Code
+
+* Use explicit conversions for enum formatting ([#4064](https://github.com/EQEmu/Server/pull/4064)) @hgtw 2024-02-12
+
+### Database
+
+* Fix default value for `time_of_death` in `character_corpses` ([#4060](https://github.com/EQEmu/Server/pull/4060)) @joligario 2024-02-11
+* Fix table name in manifest ([#4063](https://github.com/EQEmu/Server/pull/4063)) @joligario 2024-02-11
+* Proper default for `droptime` from `object_contents` ([#4061](https://github.com/EQEmu/Server/pull/4061)) @joligario 2024-02-11
+
+### Fixes
+
+* Guard against crash condition ([#4062](https://github.com/EQEmu/Server/pull/4062)) @neckkola 2024-02-11
+
+### Guilds
+
+* Clean up `GUILD_RANK_NONE` references ([#4059](https://github.com/EQEmu/Server/pull/4059)) @joligario 2024-02-11
+
+## [22.44.1] - 2/11/2024
+
+### Fixes
+
+* Fix File::Exists(file_name) to be resilient to Chinese characters ([#4058](https://github.com/EQEmu/Server/pull/4058)) @Akkadius 2024-02-11
+
+## [22.44.0] - 2/10/2024
+
+### Base Data
+
+* Remove from shared memory and simplify ([#4045](https://github.com/EQEmu/Server/pull/4045)) @Kinglykrab 2024-02-05
+
+### Bot Commands
+
+* Separate Bot Commands into Individual Files ([#4035](https://github.com/EQEmu/Server/pull/4035)) @Kinglykrab 2024-02-01
+
+### Code
+
+* Convert Quest Ornament Methods to Repositories ([#4048](https://github.com/EQEmu/Server/pull/4048)) @Kinglykrab 2024-02-10
+* Remove redundant check in Object::HandleCombine ([#4041](https://github.com/EQEmu/Server/pull/4041)) @joligario 2024-02-03
+
+### Commands
+
+* Add #show special_abilities ([#4043](https://github.com/EQEmu/Server/pull/4043)) @Kinglykrab 2024-02-05
+
+### Crash Reporting
+
+* Update Spire to use SSL ([#4055](https://github.com/EQEmu/Server/pull/4055)) @Akkadius 2024-02-10
+
+### Database
+
+* Correct manifest migration entries that should be content ([#4047](https://github.com/EQEmu/Server/pull/4047)) @Akkadius 2024-02-05
+
+### Deprecation
+
+* Remove eqemu_server.pl script and ties to server ([#4049](https://github.com/EQEmu/Server/pull/4049)) @Akkadius 2024-02-10
+
+### Feature
+
+* Add RoF2 Guild features ([#3699](https://github.com/EQEmu/Server/pull/3699)) @neckkola 2024-02-10
+* Add optional `is_forced` parameter to Zone::Repop ([#4046](https://github.com/EQEmu/Server/pull/4046)) @Kinglykrab 2024-02-05
+* Add support to crosszone/worldwide spells to affect bot pets ([#4036](https://github.com/EQEmu/Server/pull/4036)) @Kinglykrab 2024-02-01
+* Classic Taunt (Pre 2006) style of taunt ([#3942](https://github.com/EQEmu/Server/pull/3942)) @fryguy503 2024-02-10
+* Corpse Overhaul ([#3938](https://github.com/EQEmu/Server/pull/3938)) @fryguy503 2024-02-08
+
+### Fixes
+
+* Fix Bot Non-Melee Damage Messages ([#4038](https://github.com/EQEmu/Server/pull/4038)) @Kinglykrab 2024-02-01
+* Fix Froglok Starting Languages ([#4050](https://github.com/EQEmu/Server/pull/4050)) @Kinglykrab 2024-02-09
+* Fix Issue with Bot Dual wield ([#4037](https://github.com/EQEmu/Server/pull/4037)) @Kinglykrab 2024-02-01
+* Fix for potential crash of DS damage on death ([#4040](https://github.com/EQEmu/Server/pull/4040)) @nytmyr 2024-02-03
+
+### GM Commands
+
+* Fix typo in #rules help. ([#4042](https://github.com/EQEmu/Server/pull/4042)) @noudess 2024-02-04
+
+### Loot
+
+* Remove from shared memory, simplification ([#3988](https://github.com/EQEmu/Server/pull/3988)) @Akkadius 2024-02-05
+
+### Objects
+
+* Add `fix_z` column to ground spawns ([#3992](https://github.com/EQEmu/Server/pull/3992)) @Kinglykrab 2024-02-01
+
+### Quest API
+
+* Add GetAAEXPPercentage() and GetEXPPercentage() to Perl/Lua ([#4044](https://github.com/EQEmu/Server/pull/4044)) @Kinglykrab 2024-02-04
+
+### Quests
+
+* Cleanup Quest Parser Logic ([#4025](https://github.com/EQEmu/Server/pull/4025)) @Kinglykrab 2024-02-06
+
+### Tasks
+
+* Avoid removing client tasks from memory on load ([#4052](https://github.com/EQEmu/Server/pull/4052)) @hgtw 2024-02-10
+* Send active elements in task select packet ([#4051](https://github.com/EQEmu/Server/pull/4051)) @hgtw 2024-02-10
+
+## [22.43.3] - 1/30/2024
+
+### API
+
+* Add lock_status method to world API ([#4028](https://github.com/EQEmu/Server/pull/4028)) @Akkadius 2024-01-29
+
+### Alternate Currency
+
+* Convert Load of Alternate Currencies to Repositories ([#3993](https://github.com/EQEmu/Server/pull/3993)) @Kinglykrab 2024-01-29
+
+### Beacon
+
+* Cleanup Beacons Code ([#4024](https://github.com/EQEmu/Server/pull/4024)) @Kinglykrab 2024-01-29
+
+### Bots
+
+* Convert Bot Database Methods to Repositories ([#4023](https://github.com/EQEmu/Server/pull/4023)) @Kinglykrab 2024-01-29
+* Missing boolean returns on DeletePetStats and SaveInspectMessage ([#4031](https://github.com/EQEmu/Server/pull/4031)) @joligario 2024-01-30
+
+### Code
+
+* Add Raid Loot Type Constants ([#4022](https://github.com/EQEmu/Server/pull/4022)) @Kinglykrab 2024-01-29
+* Cleanup cross-zone/world-wide OPCode handling ([#4003](https://github.com/EQEmu/Server/pull/4003)) @Kinglykrab 2024-01-29
+
+### Commands
+
+* Cleanup #petitems Command ([#4005](https://github.com/EQEmu/Server/pull/4005)) @Kinglykrab 2024-01-29
+
+### Crash Fix
+
+* Fix Possible Crash in HateList::Find ([#4027](https://github.com/EQEmu/Server/pull/4027)) @Kinglykrab 2024-01-28
+
+### Fixes
+
+* Fix NPC After Death Emotes ([#4021](https://github.com/EQEmu/Server/pull/4021)) @Kinglykrab 2024-01-29
+* Fix database loading routines ([#4030](https://github.com/EQEmu/Server/pull/4030)) @Akkadius 2024-01-29
+* Fix issue in character_corpses Repository Query ([#4029](https://github.com/EQEmu/Server/pull/4029)) @Kinglykrab 2024-01-29
+* Limit Pet Taunt Distance ([#4018](https://github.com/EQEmu/Server/pull/4018)) @fryguy503 2024-01-26
+* Limit Player Taunt Distance ([#4019](https://github.com/EQEmu/Server/pull/4019)) @fryguy503 2024-01-26
+* Patch for recent change to DEATH ([#4032](https://github.com/EQEmu/Server/pull/4032)) @noudess 2024-01-30
+* spawn_conditions map was being emptied by mistake ([#4033](https://github.com/EQEmu/Server/pull/4033)) @noudess 2024-01-30
+
+### Grids
+
+* Convert Grid/Grid Entries to Repositories ([#4011](https://github.com/EQEmu/Server/pull/4011)) @Kinglykrab 2024-01-29
+
+### Mercenaries
+
+* Add expansion settings update to Mercs:Enable ([#4001](https://github.com/EQEmu/Server/pull/4001)) @Kinglykrab 2024-01-29
+
+### Merchants
+
+* Convert Merchant Load to Repositories ([#4007](https://github.com/EQEmu/Server/pull/4007)) @Kinglykrab 2024-01-29
+
+### Pets
+
+* Convert Load of Pets Beastlord Data to Repositories ([#3995](https://github.com/EQEmu/Server/pull/3995)) @Kinglykrab 2024-01-29
+
+### Quests
+
+* Use separate variable for quest idle override. ([#4026](https://github.com/EQEmu/Server/pull/4026)) @noudess 2024-01-27
+
+### Rules
+
+* Add rules for cross-zone/world-wide casts to affect Bots/Mercenaries/Pets ([#4002](https://github.com/EQEmu/Server/pull/4002)) @Kinglykrab 2024-01-29
+
+### Spawn2
+
+* Convert Spawn2 Methods to Repositories ([#4014](https://github.com/EQEmu/Server/pull/4014)) @Kinglykrab 2024-01-29
+
+### Traps
+
+* Convert Load/Set of Traps to Repositories ([#3994](https://github.com/EQEmu/Server/pull/3994)) @Kinglykrab 2024-01-29
+
+### Zone
+
+* Convert Fishing/Foraging to Repositories ([#4008](https://github.com/EQEmu/Server/pull/4008)) @Kinglykrab 2024-01-30
+
+## [22.43.2] - 1/25/2024
+
+### Bots
+
+* ^mez command spell list fix ([#3998](https://github.com/EQEmu/Server/pull/3998)) @dariusuknuis 2024-01-19
+
+### Code
+
+* Cleanup position methods ([#4015](https://github.com/EQEmu/Server/pull/4015)) @Kinglykrab 2024-01-25
+
+### Commands
+
+* Add `#npcedit set_grid [Grid ID]` to `#npcedit` ([#4004](https://github.com/EQEmu/Server/pull/4004)) @Kinglykrab 2024-01-22
+
+### Crash Fix
+
+* Fix crash when creating Frogloks/Drakkin ([#4016](https://github.com/EQEmu/Server/pull/4016)) @Kinglykrab 2024-01-25
+* Reverting PR #3877 ([#3997](https://github.com/EQEmu/Server/pull/3997)) @fryguy503 2024-01-17
+
+### Database
+
+* Drop deprecated item_tick table ([#3977](https://github.com/EQEmu/Server/pull/3977)) @Akkadius 2024-01-14
+* Drop item_tick if exists tweak in manifest ([#3985](https://github.com/EQEmu/Server/pull/3985)) @Akkadius 2024-01-15
+* Increase max spawngroup name from 50 to 200 ([#3991](https://github.com/EQEmu/Server/pull/3991)) @Akkadius 2024-01-22
+
+### Fixes
+
+* Fix Mercenaries Buffs/Zoning Issues ([#4000](https://github.com/EQEmu/Server/pull/4000)) @Kinglykrab 2024-01-22
+* Fix zone database update manifest ([#3972](https://github.com/EQEmu/Server/pull/3972)) @Kinglykrab 2024-01-13
+* Fixes to zone idle while empty changes. ([#4006](https://github.com/EQEmu/Server/pull/4006)) @noudess 2024-01-23
+* Reversed logic on InLiquid ([#3979](https://github.com/EQEmu/Server/pull/3979)) @fryguy503 2024-01-14
+
+### Instances
+
+* Convert Instance Quest Methods to Repositories ([#4012](https://github.com/EQEmu/Server/pull/4012)) @Kinglykrab 2024-01-25
+
+### Logging
+
+* Force Info category to be always on in file/console logs ([#3990](https://github.com/EQEmu/Server/pull/3990)) @Akkadius 2024-01-22
+
+### Merchants
+
+* Change database structure for merchant slots ([#3974](https://github.com/EQEmu/Server/pull/3974)) @joligario 2024-01-14
+
+### Messages
+
+* Fix disciple message added by previous patch. ([#3986](https://github.com/EQEmu/Server/pull/3986)) @noudess 2024-01-15
+
+### Quest API
+
+* QuestReward should now summon item to the inventory instead of the cursor. ([#3996](https://github.com/EQEmu/Server/pull/3996)) @regneq 2024-01-22
+
+### Repositories
+
+* Add `rank` to reserved words ([#3982](https://github.com/EQEmu/Server/pull/3982)) @Akkadius 2024-01-15
+* Fix datetime zero-value save behavior ([#3976](https://github.com/EQEmu/Server/pull/3976)) @Akkadius 2024-01-14
+
+### Spawn2
+
+* Spawn condition value should default spawn_conditions value ([#3980](https://github.com/EQEmu/Server/pull/3980)) @noudess 2024-01-14
+
+### Zoning
+
+* Additional logs for zoning under instance checks ([#3989](https://github.com/EQEmu/Server/pull/3989)) @Akkadius 2024-01-22
+
+## [22.43.1] - 1/14/2024
+
+### Repositories
+
+*  Revert #3976 - fix character corpses @Akkadius 2024-01-14
+
+## [22.43.0] - 1/14/2024
+
+### Database
+
+* Drop deprecated item_tick table ([#3977](https://github.com/EQEmu/Server/pull/3977)) @Akkadius 2024-01-14
+
+### Merchants
+
+* Change database structure for merchant slots ([#3974](https://github.com/EQEmu/Server/pull/3974)) @joligario 2024-01-14
+
+### Repositories
+
+* Fix datetime zero-value save behavior ([#3976](https://github.com/EQEmu/Server/pull/3976)) @Akkadius 2024-01-14
+
+### Zones
+
+* Convert IDLE_WHEN_EMPTY to a Zone Column ([#3891](https://github.com/EQEmu/Server/pull/3891)) @Kinglykrab 2024-01-13
+
+## [22.42.1] - 1/13/2024
+
+### Fixes
+
+* Fix zone database update manifest ([#3972](https://github.com/EQEmu/Server/pull/3972)) @Kinglykrab 2024-01-13
+* quest::processmobswhilezoneempty() fix. ([#3971](https://github.com/EQEmu/Server/pull/3971)) @noudess 2024-01-13
+
+## [22.42.0] - 1/13/2024
+
+### AAs
+
+* Convert Loading of AAs to Repositories ([#3963](https://github.com/EQEmu/Server/pull/3963)) @Kinglykrab 2024-01-13
+
+### Auras
+
+* Convert Get of Auras to Repositories ([#3964](https://github.com/EQEmu/Server/pull/3964)) @Kinglykrab 2024-01-13
+
+### Character
+
+* Character EXP Modifiers in Memory ([#3934](https://github.com/EQEmu/Server/pull/3934)) @Kinglykrab 2024-01-13
+* Convert Character Corpses to Repositories ([#3941](https://github.com/EQEmu/Server/pull/3941)) @Kinglykrab 2024-01-13
+* Convert Save of Character Languages to Repositories ([#3948](https://github.com/EQEmu/Server/pull/3948)) @Kinglykrab 2024-01-12
+
+### Code
+
+* Cleanup AddCash() and RemoveCash() NPC Methods ([#3957](https://github.com/EQEmu/Server/pull/3957)) @Kinglykrab 2024-01-12
+* Cleanup ChangeSize() ([#3959](https://github.com/EQEmu/Server/pull/3959)) @Kinglykrab 2024-01-12
+* Cleanup Owner Related Mob Methods ([#3960](https://github.com/EQEmu/Server/pull/3960)) @Kinglykrab 2024-01-13
+* Cleanup RandomizeFeatures() ([#3958](https://github.com/EQEmu/Server/pull/3958)) @Kinglykrab 2024-01-12
+* Remove GroupCount() and RaidGroupCount() ([#3943](https://github.com/EQEmu/Server/pull/3943)) @Kinglykrab 2024-01-13
+* Remove unused Grid methods ([#3944](https://github.com/EQEmu/Server/pull/3944)) @Kinglykrab 2024-01-13
+
+### Commands
+
+* Convert NPC Spawn Methods to Repositories ([#3956](https://github.com/EQEmu/Server/pull/3956)) @Kinglykrab 2024-01-13
+
+### Crash Fix
+
+* Character Creation Class/Race out of Range. ([#3920](https://github.com/EQEmu/Server/pull/3920)) @fryguy503 2024-01-09
+
+### Feat
+
+* Alt Sinister Strike Formula ([#3921](https://github.com/EQEmu/Server/pull/3921)) @fryguy503 2024-01-09
+
+### Feature
+
+* Add Lore Item Trade Error ([#3932](https://github.com/EQEmu/Server/pull/3932)) @fryguy503 2024-01-13
+* Rule: UseLiveBlockedMessage Bard Spam ([#3933](https://github.com/EQEmu/Server/pull/3933)) @fryguy503 2024-01-09
+
+### Fixes
+
+* Attack Corpse Skill Up Fix ([#3924](https://github.com/EQEmu/Server/pull/3924)) @fryguy503 2024-01-09
+* Fix Issue with SetFlyMode() ([#3961](https://github.com/EQEmu/Server/pull/3961)) @Kinglykrab 2024-01-12
+* Harm Touch Critical Ratio ([#3915](https://github.com/EQEmu/Server/pull/3915)) @fryguy503 2024-01-09
+* Increase Precision in CheckDoubleAttack ([#3928](https://github.com/EQEmu/Server/pull/3928)) @fryguy503 2024-01-09
+* IsOfClientBotMerc() for Discipline Messages ([#3940](https://github.com/EQEmu/Server/pull/3940)) @fryguy503 2024-01-09
+* Limit MeleeMitigationEffect to defender if only client. ([#3918](https://github.com/EQEmu/Server/pull/3918)) @fryguy503 2024-01-09
+* Rampage Number of Hits Limit ([#3929](https://github.com/EQEmu/Server/pull/3929)) @fryguy503 2024-01-09
+* Remove duplicate character_data repository in zonedb.cpp ([#3935](https://github.com/EQEmu/Server/pull/3935)) @Kinglykrab 2024-01-09
+* Undead Should Never Flee ([#3926](https://github.com/EQEmu/Server/pull/3926)) @fryguy503 2024-01-09
+
+### Global Loot
+
+* Convert Global Loot to Repositories ([#3962](https://github.com/EQEmu/Server/pull/3962)) @Kinglykrab 2024-01-13
+
+### Ground Spawns
+
+* Convert Ground Spawns to Repositories ([#3967](https://github.com/EQEmu/Server/pull/3967)) @Kinglykrab 2024-01-13
+
+### Horses
+
+* Convert Horses to Repositories ([#3965](https://github.com/EQEmu/Server/pull/3965)) @Kinglykrab 2024-01-13
+
+### Item Ticks
+
+* Remove Item Ticks Code ([#3955](https://github.com/EQEmu/Server/pull/3955)) @Kinglykrab 2024-01-13
+
+### Mercenaries
+
+* Convert Mercenaries to Repositories ([#3947](https://github.com/EQEmu/Server/pull/3947)) @Kinglykrab 2024-01-13
+
+### Merchants
+
+* Convert Clear/Delete/Save of Temporary Merchant Lists to Repositories ([#3945](https://github.com/EQEmu/Server/pull/3945)) @Kinglykrab 2024-01-13
+
+### NPCs
+
+* Convert Load of NPC Emotes to Repositories ([#3954](https://github.com/EQEmu/Server/pull/3954)) @Kinglykrab 2024-01-13
+
+### Objects
+
+* Convert Add/Delete/Update of Objects to Repositories ([#3966](https://github.com/EQEmu/Server/pull/3966)) @Kinglykrab 2024-01-13
+* Convert World Containers to Repositories ([#3951](https://github.com/EQEmu/Server/pull/3951)) @Kinglykrab 2024-01-13
+
+### Pets
+
+* Convert Pets to Repositories ([#3968](https://github.com/EQEmu/Server/pull/3968)) @Kinglykrab 2024-01-13
+
+### Repositories
+
+* Add null integer column support, instance_list notes migration, regenerate repositories ([#3969](https://github.com/EQEmu/Server/pull/3969)) @Akkadius 2024-01-13
+
+### Respawns
+
+* Convert Respawn Times to Repositories ([#3949](https://github.com/EQEmu/Server/pull/3949)) @Kinglykrab 2024-01-13
+
+### Rules
+
+* Add rule for bard aggro cap ([#3909](https://github.com/EQEmu/Server/pull/3909)) @fryguy503 2024-01-09
+* Allow GMs to silently summon ([#3910](https://github.com/EQEmu/Server/pull/3910)) @fryguy503 2024-01-09
+* Bash Two Hander use Shoulders ([#3925](https://github.com/EQEmu/Server/pull/3925)) @fryguy503 2024-01-09
+* Classic Spell Data SPA Calc variability ([#3931](https://github.com/EQEmu/Server/pull/3931)) @fryguy503 2024-01-09
+* Classic Tracking Skillups ([#3923](https://github.com/EQEmu/Server/pull/3923)) @fryguy503 2024-01-09
+* Separate Tradeskill Max Train from Research. ([#3916](https://github.com/EQEmu/Server/pull/3916)) @fryguy503 2024-01-09
+
+### Tasks
+
+* Add Support for Task Window Element Groups ([#3902](https://github.com/EQEmu/Server/pull/3902)) @hgtw 2024-01-09
+
+### Traps
+
+* Convert Load of LDoN Traps/Trap Entries to Repositories ([#3953](https://github.com/EQEmu/Server/pull/3953)) @Kinglykrab 2024-01-13
+
+### Zones
+
+* Convert Get/Set of Zone Timezone to Repositories ([#3946](https://github.com/EQEmu/Server/pull/3946)) @Kinglykrab 2024-01-13
+* Convert IDLE_WHEN_EMPTY to a Zone Column ([#3891](https://github.com/EQEmu/Server/pull/3891)) @Kinglykrab 2024-01-13
+* Convert SaveZoneCFG to Repositories ([#3950](https://github.com/EQEmu/Server/pull/3950)) @Kinglykrab 2024-01-13
+
+## [22.41.0] - 1/8/2024
+
+### Bug
+
+* DI Buff Fade ([#3919](https://github.com/EQEmu/Server/pull/3919)) @fryguy503 2024-01-08
+* NPCs will now only proc on hit ([#3913](https://github.com/EQEmu/Server/pull/3913)) @fryguy503 2024-01-08
+* Pets should not ignore Z axis ([#3912](https://github.com/EQEmu/Server/pull/3912)) @fryguy503 2024-01-08
+
+### Fixes
+
+* Disciplines should show when someone casts them. ([#3901](https://github.com/EQEmu/Server/pull/3901)) @fryguy503 2024-01-08
+* Fix Typo in Character Skills loading ([#3937](https://github.com/EQEmu/Server/pull/3937)) @Kinglykrab 2024-01-09
+* Fix for HasLockoutByCharacterID ([#3927](https://github.com/EQEmu/Server/pull/3927)) @fryguy503 2024-01-08
+* Harm Touch, Improved Harm Touch, and Unholy Touch ([#3904](https://github.com/EQEmu/Server/pull/3904)) @fryguy503 2024-01-08
+* Legacy Manaburn should have hard cap. ([#3905](https://github.com/EQEmu/Server/pull/3905)) @fryguy503 2024-01-08
+* TGB - Added logic to stop bard errors on group songs. ([#3906](https://github.com/EQEmu/Server/pull/3906)) @fryguy503 2024-01-08
+* World Shutdown Filter ([#3930](https://github.com/EQEmu/Server/pull/3930)) @fryguy503 2024-01-08
+
+### Info
+
+* Adding textual feedback when trying to sell alt items back to … ([#3917](https://github.com/EQEmu/Server/pull/3917)) @fryguy503 2024-01-08
+
+### Rules
+
+* Backstab Damage Modifier ([#3908](https://github.com/EQEmu/Server/pull/3908)) @fryguy503 2024-01-08
+* Classic Tradeskill Skill Clamp ([#3914](https://github.com/EQEmu/Server/pull/3914)) @fryguy503 2024-01-08
+* Classic Triple Attack ([#3903](https://github.com/EQEmu/Server/pull/3903)) @fryguy503 2024-01-08
+* Ensure mana taps only effect NPC's that have mana. ([#3907](https://github.com/EQEmu/Server/pull/3907)) @fryguy503 2024-01-08
+* Over Taunt Hate ([#3900](https://github.com/EQEmu/Server/pull/3900)) @fryguy503 2024-01-08
+* Stun Chance Percent Rule ([#3922](https://github.com/EQEmu/Server/pull/3922)) @fryguy503 2024-01-08
+
+## [22.40.0] - 1/7/2024
+
+### Account
+
+* Convert Get/Update Account Karma to Repositories ([#3858](https://github.com/EQEmu/Server/pull/3858)) @Kinglykrab 2024-01-07
+* Convert UpdateGMStatus to Repositories ([#3859](https://github.com/EQEmu/Server/pull/3859)) @Kinglykrab 2024-01-07
+
+### Bots
+
+* Resist Spell Fix ([#3840](https://github.com/EQEmu/Server/pull/3840)) @dariusuknuis 2024-01-07
+
+### Bugfix
+
+* Negative Aggro Fix ([#3866](https://github.com/EQEmu/Server/pull/3866)) @fryguy503 2024-01-07
+
+### Character
+
+* Convert Clear/Delete/Get/Update of Character Item Recast to Repositories ([#3857](https://github.com/EQEmu/Server/pull/3857)) @Kinglykrab 2024-01-07
+* Convert Delete/Load/Remove/Save of Character AA to Repositories ([#3849](https://github.com/EQEmu/Server/pull/3849)) @Kinglykrab 2024-01-07
+* Convert Delete/Load/Save of Character Bandolier to Repositories ([#3845](https://github.com/EQEmu/Server/pull/3845)) @Kinglykrab 2024-01-07
+* Convert Delete/Load/Save of Character Disciplines to Repositories ([#3850](https://github.com/EQEmu/Server/pull/3850)) @Kinglykrab 2024-01-07
+* Convert Delete/Load/Save of Character Leadership Abilities to Repositories ([#3847](https://github.com/EQEmu/Server/pull/3847)) @Kinglykrab 2024-01-07
+* Convert Delete/Load/Save of Character Material to Repositories ([#3846](https://github.com/EQEmu/Server/pull/3846)) @Kinglykrab 2024-01-07
+* Convert Delete/Load/Save of Character Spells to Repositories ([#3842](https://github.com/EQEmu/Server/pull/3842)) @Kinglykrab 2024-01-07
+* Convert Delete/Save of Character Memmed Spells to Repositories ([#3841](https://github.com/EQEmu/Server/pull/3841)) @Kinglykrab 2024-01-07
+* Convert Load/Save of Character Bind to Repositories ([#3851](https://github.com/EQEmu/Server/pull/3851)) @Kinglykrab 2024-01-07
+* Convert Load/Save of Character Buffs to Repositories ([#3855](https://github.com/EQEmu/Server/pull/3855)) @Kinglykrab 2024-01-07
+* Convert Load/Save of Character Currency to Repositories ([#3848](https://github.com/EQEmu/Server/pull/3848)) @Kinglykrab 2024-01-07
+* Convert Load/Save of Character Data to Repositories ([#3839](https://github.com/EQEmu/Server/pull/3839)) @Kinglykrab 2024-01-07
+* Convert Load/Save of Character Potion Belt to Repositories ([#3844](https://github.com/EQEmu/Server/pull/3844)) @Kinglykrab 2024-01-07
+* Convert Load/Save of Character Skills to Repositories ([#3843](https://github.com/EQEmu/Server/pull/3843)) @Kinglykrab 2024-01-07
+* Convert Load/Update of Character Alternate Currencies to Repositories ([#3856](https://github.com/EQEmu/Server/pull/3856)) @Kinglykrab 2024-01-07
+* Convert NoRentExpired to Repositories ([#3860](https://github.com/EQEmu/Server/pull/3860)) @Kinglykrab 2024-01-07
+
+### Characters
+
+* Convert Load/Save of Character Auras to Repositories ([#3854](https://github.com/EQEmu/Server/pull/3854)) @Kinglykrab 2024-01-07
+
+### Code
+
+* Remove bot-based saylink method ([#3852](https://github.com/EQEmu/Server/pull/3852)) @Kinglykrab 2024-01-07
+
+### Commands
+
+* Add #clearxtargets Command ([#3833](https://github.com/EQEmu/Server/pull/3833)) @Kinglykrab 2024-01-07
+* Add scoped buckets and editing to #databuckets ([#3826](https://github.com/EQEmu/Server/pull/3826)) @Kinglykrab 2024-01-07
+* Cleanup #appearance Command ([#3827](https://github.com/EQEmu/Server/pull/3827)) @Kinglykrab 2024-01-07
+* Cleanup #fixmob  Command ([#3828](https://github.com/EQEmu/Server/pull/3828)) @Kinglykrab 2024-01-07
+* Cleanup #petname Command ([#3829](https://github.com/EQEmu/Server/pull/3829)) @Kinglykrab 2024-01-07
+* Cleanup #shutdown Command ([#3830](https://github.com/EQEmu/Server/pull/3830)) @Kinglykrab 2024-01-07
+* Remove #zopp Command ([#3831](https://github.com/EQEmu/Server/pull/3831)) @Kinglykrab 2024-01-07
+
+### Crash
+
+* Fix crash where Raid invite could be accepted after forming group with the Raid invitor. ([#3837](https://github.com/EQEmu/Server/pull/3837)) @Aeadoin 2024-01-06
+
+### Feature
+
+* Break Trader if moved ([#3862](https://github.com/EQEmu/Server/pull/3862)) @fryguy503 2024-01-07
+* Formula Addition (40+ Harm Touch) ([#3870](https://github.com/EQEmu/Server/pull/3870)) @fryguy503 2024-01-07
+* Legacy Fizzle Code ([#3868](https://github.com/EQEmu/Server/pull/3868)) @fryguy503 2024-01-07
+* Legacy Manaburn Rule ([#3872](https://github.com/EQEmu/Server/pull/3872)) @fryguy503 2024-01-07
+
+### Fixes
+
+* Add locations where melee can be bound outside of a city. ([#3887](https://github.com/EQEmu/Server/pull/3887)) @fryguy503 2024-01-07
+* Amplification should not benefit from instrument mods ([#3898](https://github.com/EQEmu/Server/pull/3898)) @fryguy503 2024-01-07
+* Bard Caster Level Fixes ([#3883](https://github.com/EQEmu/Server/pull/3883)) @fryguy503 2024-01-07
+* Buff Sync ([#3896](https://github.com/EQEmu/Server/pull/3896)) @fryguy503 2024-01-07
+* Cancel Magic SE fix ([#3890](https://github.com/EQEmu/Server/pull/3890)) @fryguy503 2024-01-07
+* Class Trainers dont steal your money! ([#3864](https://github.com/EQEmu/Server/pull/3864)) @fryguy503 2024-01-07
+* Clear Ramp when Clearing hate ([#3892](https://github.com/EQEmu/Server/pull/3892)) @fryguy503 2024-01-07
+* DI/Death Pact Fix ([#3867](https://github.com/EQEmu/Server/pull/3867)) @fryguy503 2024-01-07
+* Depop Charm Pet and Detach Debuffs on Evacuate ([#3888](https://github.com/EQEmu/Server/pull/3888)) @fryguy503 2024-01-07
+* Dire Charm Reset ([#3875](https://github.com/EQEmu/Server/pull/3875)) @fryguy503 2024-01-07
+* Disciplines Getting Focuses Fix ([#3884](https://github.com/EQEmu/Server/pull/3884)) @fryguy503 2024-01-07
+* Fix issue with 9th/10th inventory slot ([#3835](https://github.com/EQEmu/Server/pull/3835)) @Kinglykrab 2024-01-03
+* Fix typo on ZoneDatabase::LoadPetInfo ([#3871](https://github.com/EQEmu/Server/pull/3871)) @Kinglykrab 2024-01-07
+* Harm Touch Unholy Disc Type ([#3874](https://github.com/EQEmu/Server/pull/3874)) @fryguy503 2024-01-07
+* Prevent QS Crashes ([#3877](https://github.com/EQEmu/Server/pull/3877)) @fryguy503 2024-01-07
+* Rez Effects Stacking ([#3882](https://github.com/EQEmu/Server/pull/3882)) @fryguy503 2024-01-07
+* Rez in zone clear aggro ([#3895](https://github.com/EQEmu/Server/pull/3895)) @fryguy503 2024-01-07
+* Rune Invis Break ([#3893](https://github.com/EQEmu/Server/pull/3893)) @fryguy503 2024-01-07
+* Snare and DOT Stacking ([#3897](https://github.com/EQEmu/Server/pull/3897)) @fryguy503 2024-01-07
+* Swim Skillup and Underwater Fall Damage Fix ([#3885](https://github.com/EQEmu/Server/pull/3885)) @fryguy503 2024-01-07
+* Swimming Rules Adjustment and Racial ([#3889](https://github.com/EQEmu/Server/pull/3889)) @fryguy503 2024-01-07
+* Target Locked Pet Taunt ([#3894](https://github.com/EQEmu/Server/pull/3894)) @fryguy503 2024-01-07
+* Vampiric Embrace Fixes ([#3873](https://github.com/EQEmu/Server/pull/3873)) @fryguy503 2024-01-07
+
+### Languages
+
+* Cleanup language constants, use repositories ([#3838](https://github.com/EQEmu/Server/pull/3838)) @Kinglykrab 2024-01-07
+
+### Pets
+
+* Convert Load/Save of Pet Info to Repositories ([#3853](https://github.com/EQEmu/Server/pull/3853)) @Kinglykrab 2024-01-07
+
+### Rules
+
+* Casting Charm on over level = Aggro ([#3886](https://github.com/EQEmu/Server/pull/3886)) @fryguy503 2024-01-07
+* Classic Invite Requires Target ([#3878](https://github.com/EQEmu/Server/pull/3878)) @fryguy503 2024-01-07
+* Evac Aggro Wipe ([#3880](https://github.com/EQEmu/Server/pull/3880)) @fryguy503 2024-01-07
+* Mounts will wear off on zone ([#3865](https://github.com/EQEmu/Server/pull/3865)) @fryguy503 2024-01-07
+* PC Push and NPCtoNPC Push ([#3879](https://github.com/EQEmu/Server/pull/3879)) @fryguy503 2024-01-07
+* RequireMnemonicRetention for Spells 9-12 Rule ([#3876](https://github.com/EQEmu/Server/pull/3876)) @fryguy503 2024-01-07
+* Resist Softcap rules ([#3863](https://github.com/EQEmu/Server/pull/3863)) @fryguy503 2024-01-07
+* Restrict Finishing Blow to only Fleeing NPC's. ([#3869](https://github.com/EQEmu/Server/pull/3869)) @fryguy503 2024-01-07
+* Undead Aggro ([#3881](https://github.com/EQEmu/Server/pull/3881)) @fryguy503 2024-01-07
+
+### Tuning
+
+* FD and Sneak break when cast on adjustments. ([#3861](https://github.com/EQEmu/Server/pull/3861)) @fryguy503 2024-01-07
+
+### UCS
+
+* Consolidate configuration block ([#3768](https://github.com/EQEmu/Server/pull/3768)) @Akkadius 2024-01-07
+
+## [22.39.1] - 12/31/2023
+
+### Code
+
+* Appearance not appearence ([#3819](https://github.com/EQEmu/Server/pull/3819)) @Kinglykrab 2023-12-30
+* Delete errmsg.h in common and zone ([#3821](https://github.com/EQEmu/Server/pull/3821)) @Kinglykrab 2023-12-30
+* Gender constants cleanup ([#3817](https://github.com/EQEmu/Server/pull/3817)) @Kinglykrab 2023-12-30
+* Remove MakeSpawnUpdateNoDelta from mob.cpp/mob.h ([#3816](https://github.com/EQEmu/Server/pull/3816)) @Kinglykrab 2023-12-31
+* Remove SendStunAppearance from mob.cpp/mob.h ([#3818](https://github.com/EQEmu/Server/pull/3818)) @Kinglykrab 2023-12-31
+* Remove unused PlotPosition methods from mob.cpp/mob.h ([#3820](https://github.com/EQEmu/Server/pull/3820)) @Kinglykrab 2023-12-31
+
+### Database
+
+* Database update improvements, content db and terminal checks ([#3814](https://github.com/EQEmu/Server/pull/3814)) @Akkadius 2023-12-31
+
+### Fixes
+
+* Client:SetBucket Overload Incorrectly Named ([#3825](https://github.com/EQEmu/Server/pull/3825)) @fryguy503 2023-12-30
+* Fix crash in Client::Handle_OP_GMGoto ([#3832](https://github.com/EQEmu/Server/pull/3832)) @Kinglykrab 2023-12-31
+
+### Quest API
+
+* Add HasItemOnCorpse() to Perl/Lua ([#3824](https://github.com/EQEmu/Server/pull/3824)) @Kinglykrab 2023-12-31
+* Fix issue with death events. ([#3823](https://github.com/EQEmu/Server/pull/3823)) @Kinglykrab 2023-12-31
+
+### Repositories
+
+* Protected extended repositories from being overwritten if exists ([#3815](https://github.com/EQEmu/Server/pull/3815)) @Akkadius 2023-12-31
+
+## [22.39.0] - 12/27/2023
+
+### Character
+
+* Fix character copier due to schema change ([#3805](https://github.com/EQEmu/Server/pull/3805)) @Akkadius 2023-12-28
+
+### Combat
+
+* Disarm was not dropping item to ground due to bug ([#3811](https://github.com/EQEmu/Server/pull/3811)) @noudess 2023-12-27
+
+### Logs
+
+* Bulk insert new log settings ([#3810](https://github.com/EQEmu/Server/pull/3810)) @Akkadius 2023-12-28
+* Reclassify unhelpful Info message ([#3809](https://github.com/EQEmu/Server/pull/3809)) @Akkadius 2023-12-28
+
+### MySQL
+
+* Fix MySQL Query error formatting ([#3808](https://github.com/EQEmu/Server/pull/3808)) @Akkadius 2023-12-28
+
+### Objects
+
+* Remove "No objects to load for zone" error message ([#3807](https://github.com/EQEmu/Server/pull/3807)) @Akkadius 2023-12-28
+
+### Player Events
+
+* Bulk replace settings on boot ([#3806](https://github.com/EQEmu/Server/pull/3806)) @Akkadius 2023-12-28
+
+### Tasks
+
+* Add enabled column ([#3804](https://github.com/EQEmu/Server/pull/3804)) @Akkadius 2023-12-28
+
+## [22.38.0] - 12/26/2023
+
+### Bots
+
+* Remove unnecessary error on SetItemReuse ([#3795](https://github.com/EQEmu/Server/pull/3795)) @nytmyr 2023-12-20
+
+### Code
+
+* Consolidate GetHateRandom(), GetHateRandomBot(), GetHateRandomClient(), and GetHateRandomNPC() ([#3794](https://github.com/EQEmu/Server/pull/3794)) @Kinglykrab 2023-12-25
+* Race constants refactor ([#3782](https://github.com/EQEmu/Server/pull/3782)) @Akkadius 2023-12-23
+
+### Database
+
+* Fix issue with saylinks query in MySQL 8.0+ ([#3800](https://github.com/EQEmu/Server/pull/3800)) @Akkadius 2023-12-24
+* Update faction mods with Live data ([#3799](https://github.com/EQEmu/Server/pull/3799)) @joligario 2023-12-23
+
+### Fixes
+
+* Disable Hide/Improved Hide on Trap damage ([#3791](https://github.com/EQEmu/Server/pull/3791)) @Kinglykrab 2023-12-19
+* Fix Bard Invisibility Songs breaking every 4 ticks ([#3783](https://github.com/EQEmu/Server/pull/3783)) @Kinglykrab 2023-12-19
+* Fix can_riposte parameter in DoMeleeSkillAttackDmg ([#3792](https://github.com/EQEmu/Server/pull/3792)) @Kinglykrab 2023-12-19
+
+### Forage
+
+* Add a rule to disabled using common_food_ids from the list in forage.cpp.  currently set to enabled. ([#3796](https://github.com/EQEmu/Server/pull/3796)) @regneq 2023-12-22
+
+### NPC
+
+* Support for multiple emotes per type, emote variables ([#3801](https://github.com/EQEmu/Server/pull/3801)) @regneq 2023-12-25
+
+### Quest API
+
+* Add GetHateTopBot(), GetHateTopClient(), and GetHateTopNPC() to Perl/Lua ([#3793](https://github.com/EQEmu/Server/pull/3793)) @Kinglykrab 2023-12-22
+* Add SummonItemIntoInventory() to Perl/Lua ([#3797](https://github.com/EQEmu/Server/pull/3797)) @Kinglykrab 2023-12-22
+
+### Repositories
+
+* Add ReplaceOne and ReplaceMany ([#3802](https://github.com/EQEmu/Server/pull/3802)) @Akkadius 2023-12-26
+
+## [22.37.0] - 12/18/2023
+
+### Bots
+
+* Add ScanCloseMobs support to fix AEs ([#3786](https://github.com/EQEmu/Server/pull/3786)) @nytmyr 2023-12-18
+* Expand ^itemuse options ([#3756](https://github.com/EQEmu/Server/pull/3756)) @nytmyr 2023-12-17
+* Fix ^defensive from checking aggressive disciplines. ([#3787](https://github.com/EQEmu/Server/pull/3787)) @nytmyr 2023-12-18
+* Fix ^oo autodefend from sending bots/pets to invalid haters ([#3772](https://github.com/EQEmu/Server/pull/3772)) @nytmyr 2023-12-16
+* Fix unnecessary failed to save timer error ([#3788](https://github.com/EQEmu/Server/pull/3788)) @nytmyr 2023-12-18
+* [Quest API] Add ^clickitem, ^timer, fix GetBestBotSpellForCure ([#3755](https://github.com/EQEmu/Server/pull/3755)) @nytmyr 2023-12-17
+
+### CI
+
+* Switch to use clang for Linux builds (speed) ([#3777](https://github.com/EQEmu/Server/pull/3777)) @Akkadius 2023-12-17
+
+### Compilation
+
+* Use pre-compiled headers for Windows (speed) ([#3778](https://github.com/EQEmu/Server/pull/3778)) @Akkadius 2023-12-18
+
+### Fixes
+
+* Drop Invisibility when hit by traps ([#3785](https://github.com/EQEmu/Server/pull/3785)) @Kinglykrab 2023-12-18
+* Fix NPCs routing to 0.0, 0.0 on #summon ([#3780](https://github.com/EQEmu/Server/pull/3780)) @Kinglykrab 2023-12-18
+* Fix bad merge  @Akkadius 2023-12-17
+* Fix issue with HOTBonusHealingSplitOverDuration Rule ([#3776](https://github.com/EQEmu/Server/pull/3776)) @Kinglykrab 2023-12-17
+* Fixed the discrepacy with time using command #time and in quests. ([#3767](https://github.com/EQEmu/Server/pull/3767)) @regneq 2023-12-17
+* Send Entity ID in Death Events to resolve #3721 ([#3779](https://github.com/EQEmu/Server/pull/3779)) @Kinglykrab 2023-12-18
+
+### Quest API
+
+* Add EVENT_ALT_CURRENCY_GAIN and EVENT_ALT_CURRENCY_LOSS to Perl/Lua ([#3734](https://github.com/EQEmu/Server/pull/3734)) @Kinglykrab 2023-12-17
+* Add EVENT_CRYSTAL_GAIN and EVENT_CRYSTAL_LOSS to Perl/Lua ([#3735](https://github.com/EQEmu/Server/pull/3735)) @Kinglykrab 2023-12-17
+* Add EVENT_LDON_POINTS_GAIN and EVENT_LDON_POINTS_LOSS to Perl/Lua ([#3742](https://github.com/EQEmu/Server/pull/3742)) @Kinglykrab 2023-12-17
+* Add EVENT_LEVEL_UP and EVENT_LEVEL_DOWN to Bots ([#3750](https://github.com/EQEmu/Server/pull/3750)) @Kinglykrab 2023-12-17
+* Add EVENT_LOOT_ADDED to Perl/Lua ([#3739](https://github.com/EQEmu/Server/pull/3739)) @Kinglykrab 2023-12-17
+* Add GetNPCAggro() and SetNPCAggro() to Perl/Lua ([#3781](https://github.com/EQEmu/Server/pull/3781)) @Kinglykrab 2023-12-18
+
 ## [22.36.0] - 12/16/2023
 
 ### Bots

CMakeLists.txt

@@ -17,6 +17,7 @@ SET(CMAKE_CXX_STANDARD_REQUIRED ON)
 SET(CMAKE_CXX_EXTENSIONS OFF)
 
 OPTION(EQEMU_BUILD_STATIC "Build with static linking" OFF)
+OPTION(EQEMU_BUILD_PCH "Build with precompiled headers (Windows)" ON)
 
 IF (EQEMU_BUILD_STATIC)
 	SET(BUILD_SHARED_LIBS OFF)

client_files/export/main.cpp

@@ -29,6 +29,8 @@
 #include "../../common/content/world_content_service.h"
 #include "../../common/zone_store.h"
 #include "../../common/path_manager.h"
+#include "../../common/repositories/skill_caps_repository.h"
+#include "../../common/file.h"
 
 EQEmuLogSys LogSys;
 WorldContentService content_service;
@@ -164,81 +166,76 @@ void ExportSpells(SharedDatabase *db)
 	fclose(f);
 }
 
-bool SkillUsable(SharedDatabase *db, int skill_id, int class_id)
+bool SkillUsable(SharedDatabase* db, int skill_id, int class_id)
 {
-
-	bool res = false;
-
-	std::string query   = StringFormat(
-		"SELECT max(cap) FROM skill_caps WHERE class=%d AND skillID=%d",
-		class_id, skill_id
+	const auto& l = SkillCapsRepository::GetWhere(
+		*db,
+		fmt::format(
+			"`class_id` = {} AND `skill_id` = {} ORDER BY `cap` DESC LIMIT 1",
+			class_id,
+			skill_id
+		)
 	);
-	auto        results = db->QueryDatabase(query);
-	if (!results.Success()) {
-		return false;
-	}
 
-	if (results.RowCount() == 0) {
-		return false;
-	}
-
-	auto row = results.begin();
-	if (row[0] && Strings::ToInt(row[0]) > 0) {
-		return true;
-	}
-
-	return false;
+	return !l.empty();
 }
 
-int GetSkill(SharedDatabase *db, int skill_id, int class_id, int level)
+uint32 GetSkill(SharedDatabase* db, int skill_id, int class_id, int level)
 {
-
-	std::string query   = StringFormat(
-		"SELECT cap FROM skill_caps WHERE class=%d AND skillID=%d AND level=%d",
-		class_id, skill_id, level
+	const auto& l = SkillCapsRepository::GetWhere(
+		*db,
+		fmt::format(
+			"`class_id` = {} AND `skill_id` = {} AND `level` = {}",
+			class_id,
+			skill_id,
+			level
+		)
 	);
-	auto        results = db->QueryDatabase(query);
-	if (!results.Success()) {
+
+	if (l.empty()) {
 		return 0;
 	}
 
-	if (results.RowCount() == 0) {
-		return 0;
-	}
+	auto e = l.front();
 
-	auto row = results.begin();
-	return Strings::ToInt(row[0]);
+	return e.cap;
 }
 
-void ExportSkillCaps(SharedDatabase *db)
+void ExportSkillCaps(SharedDatabase* db)
 {
 	LogInfo("Exporting Skill Caps");
 
-	std::string file = fmt::format("{}/export/SkillCaps.txt", path.GetServerPath());
-	FILE *f = fopen(file.c_str(), "w");
-	if (!f) {
+	std::ofstream file(fmt::format("{}/export/SkillCaps.txt", path.GetServerPath()));
+	if (!file || !file.is_open()) {
 		LogError("Unable to open export/SkillCaps.txt to write, skipping.");
 		return;
 	}
 
-	for (int cl = 1; cl <= 16; ++cl) {
-		for (int skill = 0; skill <= 77; ++skill) {
-			if (SkillUsable(db, skill, cl)) {
-				int      previous_cap = 0;
-				for (int level        = 1; level <= 100; ++level) {
-					int cap = GetSkill(db, skill, cl, level);
+	const uint8 skill_cap_max_level = (
+		RuleI(Character, SkillCapMaxLevel) > 0 ?
+		RuleI(Character, SkillCapMaxLevel) :
+		RuleI(Character, MaxLevel)
+	);
+
+	for (uint8 class_id = Class::Warrior; class_id <= Class::Berserker; class_id++) {
+		for (uint8 skill_id = EQ::skills::Skill1HBlunt; skill_id <= EQ::skills::Skill2HPiercing; skill_id++) {
+			if (SkillUsable(db, skill_id, class_id)) {
+				uint32 previous_cap = 0;
+				for (uint8 level = 1; level <= skill_cap_max_level; level++) {
+					uint32 cap = GetSkill(db, skill_id, class_id, level);
 					if (cap < previous_cap) {
 						cap = previous_cap;
 					}
 
-					fprintf(f, "%d^%d^%d^%d^0\n", cl, skill, level, cap);
+					file << fmt::format("{}^{}^{}^{}^0", class_id, skill_id, level, cap) << std::endl;
+
 					previous_cap = cap;
 				}
 			}
 		}
 	}
 
-	fclose(f);
+	file.close();
 }
 
 void ExportBaseData(SharedDatabase *db)

client_files/import/main.cpp

@@ -27,6 +27,8 @@
 #include "../../common/content/world_content_service.h"
 #include "../../common/zone_store.h"
 #include "../../common/path_manager.h"
+#include "../../common/repositories/base_data_repository.h"
+#include "../../common/file.h"
 
 EQEmuLogSys LogSys;
 WorldContentService content_service;
@@ -255,50 +257,45 @@ void ImportSkillCaps(SharedDatabase *db) {
 	fclose(f);
 }
 
-void ImportBaseData(SharedDatabase *db) {
+void ImportBaseData(SharedDatabase *db)
+{
 	LogInfo("Importing Base Data");
 
-	std::string file = fmt::format("{}/import/BaseData.txt", path.GetServerPath());
-	FILE *f = fopen(file.c_str(), "r");
-	if(!f) {
-		LogError("Unable to open {} to read, skipping.", file);
-		return;
+	const std::string& file_name = fmt::format("{}/import/BaseData.txt", path.GetServerPath());
+
+	const auto& file_contents = File::GetContents(file_name);
+	if (!file_contents.error.empty()) {
+		LogError("{}", file_contents.error);
 	}
 
-	std::string delete_sql = "DELETE FROM base_data";
-	db->QueryDatabase(delete_sql);
+	db->QueryDatabase("DELETE FROM base_data");
 
-	char buffer[2048];
-	while(fgets(buffer, 2048, f)) {
-		auto split = Strings::Split(buffer, '^');
+	std::vector<BaseDataRepository::BaseData> v;
 
-		if(split.size() < 10) {
+	auto e = BaseDataRepository::NewEntity();
+
+	for (const auto& line: Strings::Split(file_contents.contents, "\n")) {
+		const auto& line_data = Strings::Split(line, '^');
+
+		if (line_data.size() < 10) {
 			continue;
 		}
 
-		std::string sql;
-		int level, class_id;
-		double hp, mana, end, unk1, unk2, hp_fac, mana_fac, end_fac;
+		e.level     = static_cast<uint8_t>(Strings::ToUnsignedInt(line_data[0]));
+		e.class_    = static_cast<uint8_t>(Strings::ToUnsignedInt(line_data[1]));
+		e.hp        = Strings::ToFloat(line_data[2]);
+		e.mana      = Strings::ToFloat(line_data[3]);
+		e.end       = Strings::ToFloat(line_data[4]);
+		e.hp_regen  = Strings::ToFloat(line_data[5]);
+		e.end_regen = Strings::ToFloat(line_data[6]);
+		e.hp_fac    = Strings::ToFloat(line_data[7]);
+		e.mana_fac  = Strings::ToFloat(line_data[8]);
+		e.end_fac   = Strings::ToFloat(line_data[9]);
 
-		level = Strings::ToInt(split[0].c_str());
-		class_id = Strings::ToInt(split[1].c_str());
-		hp = Strings::ToFloat(split[2].c_str());
-		mana = Strings::ToFloat(split[3].c_str());
-		end = Strings::ToFloat(split[4].c_str());
-		unk1 = Strings::ToFloat(split[5].c_str());
-		unk2 = Strings::ToFloat(split[6].c_str());
-		hp_fac = Strings::ToFloat(split[7].c_str());
-		mana_fac = Strings::ToFloat(split[8].c_str());
-		end_fac = Strings::ToFloat(split[9].c_str());
-
-		sql = StringFormat("INSERT INTO base_data(level, class, hp, mana, end, unk1, unk2, hp_fac, "
-			"mana_fac, end_fac) VALUES(%d, %d, %f, %f, %f, %f, %f, %f, %f, %f)",
-			level, class_id, hp, mana, end, unk1, unk2, hp_fac, mana_fac, end_fac);
-
-		db->QueryDatabase(sql);
+		v.emplace_back(e);
 	}
 
-	fclose(f);
+	BaseDataRepository::InsertMany(*db, v);
 }
 
 void ImportDBStrings(SharedDatabase *db) {

common/CMakeLists.txt

@@ -13,7 +13,6 @@ SET(common_sources
     crc32.cpp
     database/database_dump_service.cpp
     database.cpp
-    database_conversions.cpp
     database_instances.cpp
     database/database_update_manifest.cpp
     database/database_update_manifest_bots.cpp
@@ -84,6 +83,7 @@ SET(common_sources
     shared_tasks.cpp
     shareddb.cpp
     skills.cpp
+    skill_caps.cpp
     spdat.cpp
     strings.cpp
     struct_strategy.cpp
@@ -223,6 +223,9 @@ SET(repositories
     repositories/base/base_group_leaders_repository.h
     repositories/base/base_guilds_repository.h
     repositories/base/base_guild_ranks_repository.h
+    repositories/base/base_guild_permissions_repository.h
+    repositories/base/base_guild_members_repository.h
+    repositories/base/base_guild_bank_repository.h
     repositories/base/base_guild_relations_repository.h
     repositories/base/base_horses_repository.h
     repositories/base/base_instance_list_repository.h
@@ -231,7 +234,6 @@ SET(repositories
     repositories/base/base_inventory_snapshots_repository.h
     repositories/base/base_ip_exemptions_repository.h
     repositories/base/base_items_repository.h
-    repositories/base/base_item_tick_repository.h
     repositories/base/base_ldon_trap_entries_repository.h
     repositories/base/base_ldon_trap_templates_repository.h
     repositories/base/base_level_exp_mods_repository.h
@@ -401,6 +403,9 @@ SET(repositories
     repositories/group_leaders_repository.h
     repositories/guilds_repository.h
     repositories/guild_ranks_repository.h
+    repositories/guild_permissions_repository.h
+    repositories/guild_members_repository.h
+    repositories/guild_bank_repository.h
     repositories/guild_relations_repository.h
     repositories/horses_repository.h
     repositories/instance_list_repository.h
@@ -409,7 +414,6 @@ SET(repositories
     repositories/inventory_snapshots_repository.h
     repositories/ip_exemptions_repository.h
     repositories/items_repository.h
-    repositories/item_tick_repository.h
     repositories/ldon_trap_entries_repository.h
     repositories/ldon_trap_templates_repository.h
     repositories/level_exp_mods_repository.h
@@ -489,12 +493,11 @@ SET(repositories
     repositories/zone_repository.h
     repositories/zone_points_repository.h
 
-    )
+)
 
 SET(common_headers
     additive_lagged_fibonacci_engine.h
     base_packet.h
-    base_data.h
     bodytypes.h
     classes.h
     compression.h
@@ -541,7 +544,6 @@ SET(common_headers
     events/player_event_logs.h
     events/player_event_discord_formatter.h
     events/player_events.h
-    errmsg.h
     event_sub.h
     expedition_lockout_timer.h
     extprofile.h
@@ -563,10 +565,9 @@ SET(common_headers
     item_fieldlist.h
     item_instance.h
     json_config.h
-    languages.h
     light_source.h
     linked_list.h
-    loottable.h
+    loot.h
     mail_oplist.h
     md5.h
     memory_buffer.h
@@ -592,7 +593,7 @@ SET(common_headers
     ptimer.h
     queue.h
     races.h
-	raid.h
+    raid.h
     random.h
     rdtsc.h
     rulesys.h
@@ -606,6 +607,7 @@ SET(common_headers
     shared_tasks.h
     shareddb.h
     skills.h
+    skill_caps.h
     spdat.h
     strings.h
     struct_strategy.h
@@ -681,13 +683,13 @@ SOURCE_GROUP(Event FILES
     event/event_loop.h
     event/timer.h
     event/task.h
-    )
+)
 
 SOURCE_GROUP(Json FILES
     json/json.h
     json/jsoncpp.cpp
     json/json-forwards.h
-    )
+)
 
 SOURCE_GROUP(Net FILES
     net/console_server.cpp
@@ -724,7 +726,7 @@ SOURCE_GROUP(Net FILES
     net/websocket_server.h
     net/websocket_server_connection.cpp
     net/websocket_server_connection.h
-    )
+)
 
 SOURCE_GROUP(Patches FILES
     patches/patches.h
@@ -768,12 +770,12 @@ SOURCE_GROUP(Patches FILES
     patches/titanium_limits.cpp
     patches/uf.cpp
     patches/uf_limits.cpp
-    )
+)
 
 SOURCE_GROUP(StackWalker FILES
     StackWalker/StackWalker.h
     StackWalker/StackWalker.cpp
-    )
+)
 
 SOURCE_GROUP(Util FILES
     util/memory_stream.h
@@ -781,7 +783,7 @@ SOURCE_GROUP(Util FILES
     util/directory.h
     util/uuid.cpp
     util/uuid.h
-    )
+)
 
 INCLUDE_DIRECTORIES(Patches SocketLib StackWalker)
 
@@ -792,5 +794,8 @@ IF (UNIX)
     SET_SOURCE_FILES_PROPERTIES("patches/sod.cpp" "patches/sof.cpp" "patches/rof.cpp" "patches/rof2.cpp" "patches/uf.cpp" PROPERTIES COMPILE_FLAGS -O0)
 ENDIF (UNIX)
 
+IF (WIN32 AND EQEMU_BUILD_PCH)
+    TARGET_PRECOMPILE_HEADERS(common PRIVATE pch/pch.h)
+ENDIF ()
 
 SET(LIBRARY_OUTPUT_PATH ${PROJECT_BINARY_DIR}/bin)

common/base_data.h

@@ -1,34 +0,0 @@
-/*	EQEMu: Everquest Server Emulator
-	Copyright (C) 2001-2013 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
-*/
-
-#ifndef __EQEMU_COMMON_BASE_DATA_H
-#define __EQEMU_COMMON_BASE_DATA_H
-
-struct BaseDataStruct
-{
-	double base_hp;
-	double base_mana;
-	double base_end;
-	double hp_regen;
-	double end_regen;
-	double hp_factor;
-	double mana_factor;
-	double endurance_factor;
-};
-
-#endif

common/bodytypes.h

@@ -64,4 +64,6 @@ typedef enum {
 } bodyType;
 /* bodytypes above 64 make the mob not show up */
 
+constexpr int format_as(bodyType type) { return static_cast<int>(type); }
+
 #endif

common/content/world_content_service.cpp

@@ -1,29 +1,11 @@
-/**
- * EQEmulator: Everquest Server Emulator
- * Copyright (C) 2001-2019 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 "world_content_service.h"
+
+#include <utility>
+#include <glm/vec3.hpp>
 #include "../database.h"
 #include "../rulesys.h"
 #include "../eqemu_logsys.h"
-#include "../loottable.h"
-#include "../repositories/content_flags_repository.h"
+#include "../repositories/instance_list_repository.h"
 
 
 WorldContentService::WorldContentService()
@@ -120,7 +102,7 @@ std::vector<std::string> WorldContentService::GetContentFlagsDisabled()
 /**
  * @param content_flags
  */
-void WorldContentService::SetContentFlags(const std::vector<ContentFlagsRepository::ContentFlags>& content_flags)
+void WorldContentService::SetContentFlags(const std::vector<ContentFlagsRepository::ContentFlags> &content_flags)
 {
 	WorldContentService::content_flags = content_flags;
 }
@@ -168,14 +150,14 @@ bool WorldContentService::DoesPassContentFiltering(const ContentFlags &f)
 	}
 
 	// if we don't have any enabled flag in enabled flags, we fail
-	for (const auto& flag: Strings::Split(f.content_flags)) {
+	for (const auto &flag: Strings::Split(f.content_flags)) {
 		if (!Strings::Contains(GetContentFlagsEnabled(), flag)) {
 			return false;
 		}
 	}
 
 	// if we don't have any disabled flag in disabled flags, we fail
-	for (const auto& flag: Strings::Split(f.content_flags_disabled)) {
+	for (const auto &flag: Strings::Split(f.content_flags_disabled)) {
 		if (!Strings::Contains(GetContentFlagsDisabled(), flag)) {
 			return false;
 		}
@@ -196,11 +178,13 @@ void WorldContentService::ReloadContentFlags()
 		LogInfo(
 			"Loaded content flag [{}] [{}]",
 			f.flag_name,
-			(f.enabled ? "Enabled" : "Disabled")
+			(f.enabled ? "enabled" : "disabled")
 		);
 	}
 
 	SetContentFlags(set_content_flags);
+	LoadZones();
+	LoadStaticGlobalZoneInstances();
 }
 
 Database *WorldContentService::GetDatabase() const
@@ -215,6 +199,18 @@ WorldContentService *WorldContentService::SetDatabase(Database *database)
 	return this;
 }
 
+Database *WorldContentService::GetContentDatabase() const
+{
+	return m_content_database;
+}
+
+WorldContentService *WorldContentService::SetContentDatabase(Database *database)
+{
+	WorldContentService::m_content_database = database;
+
+	return this;
+}
+
 void WorldContentService::SetContentFlag(const std::string &content_flag_name, bool enabled)
 {
 	auto flags = ContentFlagsRepository::GetWhere(
@@ -239,3 +235,125 @@ void WorldContentService::SetContentFlag(const std::string &content_flag_name, b
 
 	ReloadContentFlags();
 }
+
+// HandleZoneRoutingMiddleware is meant to handle content and context aware zone routing
+//
+// example # 1
+// lavastorm (pre-don) version 0 (classic)
+// lavastorm (don) version 1
+// we want to route players to the correct version of lavastorm based on the current server side expansion
+// in order to do that the simplest and cleanest way we intercept the zoning process and route players to an "instance" of the zone
+// the reason why we're doing this is because all of the zoning logic already is handled by two keys "zone_id" and "instance_id"
+// we can leverage static, never expires instances to handle this but to the client they don't see it any other way than a public normal zone
+// scripts handle all the same way, you don't have to think about instances, the middleware will handle the magic
+// the versions of zones are represented by two zone entries that have potentially different min/max expansion and/or different content flags
+// we decide to route the client to the correct version of the zone based on the current server side expansion
+void WorldContentService::HandleZoneRoutingMiddleware(ZoneChange_Struct *zc)
+{
+	auto r = FindZone(zc->zoneID, zc->instanceID);
+	if (r.zone_id == 0) {
+		return;
+	}
+
+	zc->instanceID = r.instance.id;
+}
+
+// LoadStaticGlobalZoneInstances loads all static global zone instances
+// these are zones that are never set to expire and are global
+// these are used commonly in v1/v2/v3 versions of the same zone for expansion routing
+WorldContentService * WorldContentService::LoadStaticGlobalZoneInstances()
+{
+	m_zone_instances = InstanceListRepository::GetWhere(*GetDatabase(), fmt::format("never_expires = 1 AND is_global = 1"));
+
+	LogInfo("Loaded [{}] zone_instances", m_zone_instances.size());
+
+	return this;
+}
+
+// LoadZones sets the zones for the world content service
+// this is used for zone routing middleware
+// we pull the zone list from the zone repository and feed from the zone store for now
+// we're holding a copy in the content service - but we're talking 250kb of data in memory to handle routing of zoning
+WorldContentService * WorldContentService::LoadZones()
+{
+	m_zones = ZoneRepository::All(*GetContentDatabase());
+
+	LogInfo("Loaded [{}] zones", m_zones.size());
+
+	return this;
+}
+
+// FindZone is critical to the zone routing middleware and any logic that needs to route players to the correct zone
+// era contextual routing, multiple version of zones, etc
+WorldContentService::FindZoneResult WorldContentService::FindZone(uint32 zone_id, uint32 instance_id)
+{
+	// if there's an active dynamic instance, we don't need to route
+	if (instance_id > 0) {
+		auto inst = InstanceListRepository::FindOne(*GetDatabase(), instance_id);
+		if (inst.id != 0 && !inst.is_global && !inst.never_expires) {
+			return WorldContentService::FindZoneResult{
+				.zone_id = 0,
+			};
+		}
+	}
+
+	for (auto &z: m_zones) {
+		if (z.zoneidnumber == zone_id) {
+			auto f = ContentFlags{
+				.min_expansion = z.min_expansion,
+				.max_expansion = z.max_expansion,
+				.content_flags = z.content_flags,
+				.content_flags_disabled = z.content_flags_disabled
+			};
+
+			if (DoesPassContentFiltering(f)) {
+				LogInfo(
+					"Attempting to route player to zone [{}] ({}) version [{}] long_name [{}]",
+					z.short_name,
+					z.zoneidnumber,
+					z.version,
+					z.long_name
+				);
+
+				// first pass, explicit match on public static global zone instances
+				for (auto &i: m_zone_instances) {
+					if (i.zone == zone_id && i.version == z.version) {
+						LogInfo(
+							"Routed player to instance [{}] of zone [{}] ({}) version [{}] long_name [{}] notes [{}]",
+							i.id,
+							z.short_name,
+							z.zoneidnumber,
+							z.version,
+							z.long_name,
+							i.notes
+						);
+
+						return WorldContentService::FindZoneResult{
+							.zone_id = static_cast<uint32>(z.zoneidnumber),
+							.instance = i,
+							.zone = z
+						};
+					}
+				}
+
+				LogInfo(
+					"Routed player to non-instance zone [{}] ({}) version [{}] long_name [{}] notes [{}]",
+					z.short_name,
+					z.zoneidnumber,
+					z.version,
+					z.long_name,
+					z.note
+				);
+
+				return WorldContentService::FindZoneResult{
+					.zone_id = static_cast<uint32>(z.zoneidnumber),
+					.instance = InstanceListRepository::NewEntity(),
+					.zone = z
+				};
+			}
+		}
+	}
+
+	return WorldContentService::FindZoneResult{.zone_id = 0};
+}
+

common/content/world_content_service.h

@@ -1,33 +1,21 @@
-/**
- * EQEmulator: Everquest Server Emulator
- * Copyright (C) 2001-2019 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 EQEMU_WORLD_CONTENT_SERVICE_H
 #define EQEMU_WORLD_CONTENT_SERVICE_H
 
 #include <string>
 #include <vector>
-#include "../loottable.h"
 #include "../repositories/content_flags_repository.h"
+#include "../repositories/zone_repository.h"
+#include "../repositories/instance_list_repository.h"
 
 class Database;
 
+struct ContentFlags {
+	int16       min_expansion;
+	int16       max_expansion;
+	std::string content_flags;
+	std::string content_flags_disabled;
+};
+
 namespace Expansion {
 	static const int EXPANSION_ALL        = -1;
 	static const int EXPANSION_FILTER_MAX = 99;
@@ -176,14 +164,33 @@ public:
 	WorldContentService * SetDatabase(Database *database);
 	Database *GetDatabase() const;
 
+	WorldContentService * SetContentDatabase(Database *database);
+	Database *GetContentDatabase() const;
+
 	void SetContentFlag(const std::string &content_flag_name, bool enabled);
 
+	void HandleZoneRoutingMiddleware(ZoneChange_Struct *zc);
+
+	struct FindZoneResult {
+		uint32                               zone_id = 0;
+		InstanceListRepository::InstanceList instance;
+		ZoneRepository::Zone                 zone;
+	};
+
+	FindZoneResult FindZone(uint32 zone_id, uint32 instance_id);
 private:
 	int current_expansion{};
 	std::vector<ContentFlagsRepository::ContentFlags> content_flags;
 
 	// reference to database
 	Database *m_database;
+	Database *m_content_database;
+
+	// holds a record of the zone table from the database
+	std::vector<ZoneRepository::Zone> m_zones = {};
+	WorldContentService *LoadStaticGlobalZoneInstances();
+	std::vector<InstanceListRepository::InstanceList> m_zone_instances;
+	WorldContentService * LoadZones();
 };
 
 extern WorldContentService content_service;

common/crash.cpp

@@ -15,7 +15,7 @@
 #include <cstdio>
 #include <vector>
 
-#if WINDOWS
+#ifdef _WINDOWS
 #define popen _popen
 #endif
 
@@ -23,7 +23,7 @@ void SendCrashReport(const std::string &crash_report)
 {
 	// can configure multiple endpoints if need be
 	std::vector<std::string> endpoints = {
-		"http://spire.akkadius.com/api/v1/analytics/server-crash-report",
+		"https://spire.akkadius.com/api/v1/analytics/server-crash-report",
 //		"http://localhost:3010/api/v1/analytics/server-crash-report", // development
 	};
 

common/database.h

@@ -18,8 +18,8 @@
 #ifndef EQEMU_DATABASE_H
 #define EQEMU_DATABASE_H
 
-#define AUTHENTICATION_TIMEOUT	60
-#define INVALID_ID				0xFFFFFFFF
+#define AUTHENTICATION_TIMEOUT    60
+#define INVALID_ID                0xFFFFFFFF
 
 #include "global_define.h"
 #include "eqemu_logsys.h"
@@ -38,8 +38,7 @@
 class MySQLRequestResult;
 class Client;
 
-namespace EQ
-{
+namespace EQ {
 	class InventoryProfile;
 }
 
@@ -52,10 +51,11 @@ struct npcDecayTimes_Struct {
 
 struct VarCache_Struct {
 	std::map<std::string, std::string> m_cache;
-	uint32 last_update;
+	uint32                             last_update;
 	VarCache_Struct() : last_update(0) { }
-	void Add(const std::string &key, const std::string &value) { m_cache[key] = value; }
-	const std::string *Get(const std::string &key) {
+	void Add(const std::string& key, const std::string& value) { m_cache[key] = value; }
+	const std::string* Get(const std::string& key)
+	{
 		auto it = m_cache.find(key);
 		return (it != m_cache.end() ? &it->second : nullptr);
 	}
@@ -76,37 +76,33 @@ class PTimerList;
 
 #define SQL(...) #__VA_ARGS__
 
-class LogSettings;
 class Database : public DBcore {
 public:
 	Database();
-	Database(const char* host, const char* user, const char* passwd, const char* database,uint32 port);
-	bool Connect(const char* host, const char* user, const char* passwd, const char* database, uint32 port, std::string connection_label = "default");
+	Database(
+		const std::string& host,
+		const std::string& user,
+		const std::string& password,
+		const std::string& database,
+		uint32 port
+	);
+	bool Connect(
+		const std::string& host,
+		const std::string& user,
+		const std::string& password,
+		const std::string& database,
+		uint32 port,
+		std::string connection_label = "default"
+	);
 	~Database();
 
 	/* Character Creation */
-
-	bool CreateCharacter(
-		uint32 account_id,
-		char *name,
-		uint16 gender,
-		uint16 race,
-		uint16 class_,
-		uint8 str,
-		uint8 sta,
-		uint8 cha,
-		uint8 dex,
-		uint8 int_,
-		uint8 agi,
-		uint8 wis,
-		uint8 face
-	);
-	bool DeleteCharacter(char *character_name);
-	bool MoveCharacterToZone(const char *charname, uint32 zone_id);
+	bool DeleteCharacter(const std::string& name);
+	bool MoveCharacterToZone(const std::string& name, uint32 zone_id);
 	bool MoveCharacterToZone(uint32 character_id, uint32 zone_id);
-	bool ReserveName(uint32 account_id, char *name);
-	bool SaveCharacterCreate(uint32 character_id, uint32 account_id, PlayerProfile_Struct *pp);
-	bool UpdateName(const char *oldname, const char *newname);
+	bool ReserveName(uint32 account_id, const std::string& name);
+	bool SaveCharacterCreate(uint32 character_id, uint32 account_id, PlayerProfile_Struct* pp);
+	bool UpdateName(const std::string& old_name, const std::string& new_name);
 	bool CopyCharacter(
 		const std::string& source_character_name,
 		const std::string& destination_character_name,
@@ -114,165 +110,171 @@ public:
 	);
 
 	/* General Information Queries */
+	bool AddBannedIP(const std::string& banned_ip, const std::string& notes); //Add IP address to the banned_ips table.
+	bool AddToNameFilter(const std::string& name);
+	bool CheckBannedIPs(const std::string& login_ip); //Check incoming connection against banned IP table.
+	bool CheckGMIPs(const std::string& login_ip, uint32 account_id);
+	bool CheckNameFilter(const std::string& name, bool surname = false);
+	bool IsNameUsed(const std::string& name);
 
-	bool	AddBannedIP(std::string banned_ip, std::string notes); //Add IP address to the banned_ips table.
-	bool	AddToNameFilter(std::string name);
-	bool	CheckBannedIPs(std::string login_ip); //Check incoming connection against banned IP table.
-	bool	CheckGMIPs(std::string login_ip, uint32 account_id);
-	bool	CheckNameFilter(std::string name, bool surname = false);
-	bool	CheckUsedName(std::string name);
+	uint32 GetAccountIDByChar(const std::string& name, uint32* character_id = 0);
+	uint32 GetAccountIDByChar(uint32 character_id);
+	uint32 GetAccountIDByName(const std::string& account_name, const std::string& loginserver, int16* status = 0, uint32* lsid = 0);
+	uint32 GetCharacterID(const std::string& name);
+	uint32 GetGuildIDByCharID(uint32 character_id);
+	uint32 GetGroupIDByCharID(uint32 character_id);
+	uint32 GetRaidIDByCharID(uint32 character_id);
 
-	uint32	GetAccountIDByChar(const char* charname, uint32* oCharID = 0);
-	uint32	GetAccountIDByChar(uint32 char_id);
-	uint32	GetAccountIDByName(std::string account_name, std::string loginserver, int16* status = 0, uint32* lsid = 0);
-	uint32	GetCharacterID(const char *name);
-	uint32	GetCharacterInfo(std::string character_name, uint32 *account_id, uint32 *zone_id, uint32 *instance_id);
-	uint32	GetGuildIDByCharID(uint32 char_id);
-	uint32  GetGroupIDByCharID(uint32 char_id);
-	uint32  GetRaidIDByCharID(uint32 char_id);
-
-	void	GetAccountName(uint32 accountid, char* name, uint32* oLSAccountID = 0);
-	void	GetCharName(uint32 char_id, char* name);
-	std::string GetCharNameByID(uint32 char_id);
-	std::string GetNPCNameByID(uint32 npc_id);
-	std::string GetCleanNPCNameByID(uint32 npc_id);
-	void	LoginIP(uint32 account_id, std::string login_ip);
+	const std::string GetAccountName(uint32 account_id, uint32* lsaccount_id = 0);
+	const std::string GetCharName(uint32 character_id);
+	const std::string GetCharNameByID(uint32 character_id);
+	const std::string GetNPCNameByID(uint32 npc_id);
+	const std::string GetCleanNPCNameByID(uint32 npc_id);
+	void LoginIP(uint32 account_id, const std::string& login_ip);
 
 	/* Instancing */
-
 	bool AddClientToInstance(uint16 instance_id, uint32 character_id);
 	bool CheckInstanceByCharID(uint16 instance_id, uint32 character_id);
 	bool CheckInstanceExists(uint16 instance_id);
 	bool CheckInstanceExpired(uint16 instance_id);
 	bool CreateInstance(uint16 instance_id, uint32 zone_id, uint32 version, uint32 duration);
-	bool GetUnusedInstanceID(uint16 &instance_id);
+	bool GetUnusedInstanceID(uint16& instance_id);
 	bool IsGlobalInstance(uint16 instance_id);
 	bool RemoveClientFromInstance(uint16 instance_id, uint32 char_id);
 	bool RemoveClientsFromInstance(uint16 instance_id);
 	bool VerifyInstanceAlive(uint16 instance_id, uint32 character_id);
 	bool VerifyZoneInstance(uint32 zone_id, uint16 instance_id);
 
-	uint16 GetInstanceID(uint32 zone, uint32 charid, int16 version);
+	uint16 GetInstanceID(uint32 zone, uint32 character_id, int16 version);
 	std::vector<uint16> GetInstanceIDs(uint32 zone_id, uint32 character_id);
 	uint8_t GetInstanceVersion(uint16 instance_id);
-	uint32 GetTimeRemainingInstance(uint16 instance_id, bool &is_perma);
+	uint32 GetTimeRemainingInstance(uint16 instance_id, bool& is_perma);
 	uint32 GetInstanceZoneID(uint16 instance_id);
 
-	void AssignGroupToInstance(uint32 gid, uint32 instance_id);
-	void AssignRaidToInstance(uint32 rid, uint32 instance_id);
+	void AssignGroupToInstance(uint32 group_id, uint32 instance_id);
+	void AssignRaidToInstance(uint32 raid_id, uint32 instance_id);
 	void DeleteInstance(uint16 instance_id);
-	void FlagInstanceByGroupLeader(uint32 zone_id, int16 version, uint32 charid, uint32 group_id);
-	void FlagInstanceByRaidLeader(uint32 zone_id, int16 version, uint32 charid, uint32 raid_id);
-	void GetCharactersInInstance(uint16 instance_id, std::list<uint32> &character_ids);
+	void FlagInstanceByGroupLeader(uint32 zone_id, int16 version, uint32 character_id, uint32 group_id);
+	void FlagInstanceByRaidLeader(uint32 zone_id, int16 version, uint32 character_id, uint32 raid_id);
+	void GetCharactersInInstance(uint16 instance_id, std::list<uint32>& character_ids);
 	void PurgeExpiredInstances();
 	void SetInstanceDuration(uint16 instance_id, uint32 new_duration);
+	void CleanupInstanceCorpses();
 
 	/* Adventure related. */
-
-	void UpdateAdventureStatsEntry(uint32 char_id, uint8 theme, bool win = false, bool remove = false);
-	bool GetAdventureStats(uint32 char_id, AdventureStats_Struct *as);
+	void UpdateAdventureStatsEntry(uint32 character_id, uint8 theme_id, bool is_win = false, bool is_remove = false);
+	bool GetAdventureStats(uint32 character_id, AdventureStats_Struct* as);
 
 	/* Account Related */
+	const std::string GetLiveChar(uint32 account_id);
+	bool SetAccountStatus(const std::string& account_name, int16 status);
+	bool SetLocalPassword(uint32 account_id, const std::string& password);
+	bool UpdateLiveChar(const std::string& name, uint32 account_id);
+	int16 CheckStatus(uint32 account_id);
+	void SetAccountCRCField(uint32 account_id, const std::string& field_name, uint64 checksum);
+	uint32 CheckLogin(const std::string& name, const std::string& password, const std::string& loginserver, int16* status = 0);
+	uint32 CreateAccount(
+		const std::string& name,
+		const std::string& password,
+		int16 status,
+		const std::string& loginserver,
+		uint32 lsaccount_id
+	);
+	uint32 GetAccountIDFromLSID(
+		const std::string& in_loginserver_id,
+		uint32 in_loginserver_account_id,
+		char* in_account_name = 0,
+		int16* in_status = 0
+	);
 
-	bool	DeleteAccount(const char *name, const char* loginserver);
-	bool	GetLiveChar(uint32 account_id, char* cname);
-	bool	SetAccountStatus(const char* name, int16 status);
-	bool	SetAccountStatus(const std::string& account_name, int16 status);
-	bool	SetLocalPassword(uint32 accid, const char* password);
-	bool	UpdateLiveChar(char* charname, uint32 account_id);
+	uint8 GetAgreementFlag(uint32 account_id);
+	void SetAgreementFlag(uint32 account_id);
 
-	int16	CheckStatus(uint32 account_id);
+	int GetIPExemption(const std::string& account_ip);
+	void SetIPExemption(const std::string& account_ip, int exemption_amount);
 
-	void	SetAccountCRCField(uint32 account_id, std::string field_name, uint64 checksum);
-
-	uint32	CheckLogin(const char* name, const char* password, const char *loginserver, int16* oStatus = 0);
-	uint32	CreateAccount(const char* name, const char* password, int16 status, const char* loginserver, uint32 lsaccount_id);
-	uint32	GetAccountIDFromLSID(const std::string& in_loginserver_id, uint32 in_loginserver_account_id, char* in_account_name = 0, int16* in_status = 0);
-	uint8	GetAgreementFlag(uint32 account_id);
-
-	void	GetAccountFromID(uint32 id, char* oAccountName, int16* oStatus);
-	void	SetAgreementFlag(uint32 account_id);
-
-	int  GetIPExemption(std::string account_ip);
-	void SetIPExemption(std::string account_ip, int exemption_amount);
-
-	int		GetInstanceID(uint32 char_id, uint32 zone_id);
+	int GetInstanceID(uint32 character_id, uint32 zone_id);
 
 
 	/* Groups */
-
-	std::string GetGroupLeaderForLogin(std::string character_name);
-	char* GetGroupLeadershipInfo(uint32 gid, char* leaderbuf, char* maintank = nullptr, char* assist = nullptr, char* puller = nullptr, char *marknpc = nullptr, char *mentoree = nullptr, int *mentor_percent = nullptr, GroupLeadershipAA_Struct* GLAA = nullptr);
-
-	uint32	GetGroupID(const char* name);
-
-	void	ClearGroup(uint32 gid = 0);
-	void	ClearGroupLeader(uint32 gid = 0);
-	void	SetGroupID(const char* name, uint32 id, uint32 charid, uint32 ismerc = false);
-	void	SetGroupLeaderName(uint32 gid, const char* name);
+	std::string GetGroupLeaderForLogin(const std::string& character_name);
+	char* GetGroupLeadershipInfo(
+		uint32 group_id,
+		char* leaderbuf,
+		char* maintank = nullptr,
+		char* assist = nullptr,
+		char* puller = nullptr,
+		char* marknpc = nullptr,
+		char* mentoree = nullptr,
+		int* mentor_percent = nullptr,
+		GroupLeadershipAA_Struct* GLAA = nullptr
+	);
+	std::string GetGroupLeaderName(uint32 group_id);
+	uint32 GetGroupID(const std::string& name);
+	void ClearGroup(uint32 group_id = 0);
+	void ClearGroupLeader(uint32 group_id = 0);
+	void SetGroupLeaderName(uint32 group_id, const std::string& name);
 
 	/* Raids */
+	const std::string GetRaidLeaderName(uint32 raid_id);
+	uint32 GetRaidID(const std::string& name);
+	void ClearRaid(uint32 raid_id = 0);
+	void ClearRaidDetails(uint32 raid_id = 0);
+	void ClearRaidLeader(uint32 group_id = std::numeric_limits<uint32>::max(), uint32 raid_id = 0);
+	void GetGroupLeadershipInfo(
+		uint32 group_id,
+		uint32 raid_id,
+		char* maintank = nullptr,
+		char* assist = nullptr,
+		char* puller = nullptr,
+		char* marknpc = nullptr,
+		char* mentoree = nullptr,
+		int* mentor_percent = nullptr,
+		GroupLeadershipAA_Struct* GLAA = nullptr
+	);
+	void GetRaidLeadershipInfo(
+		uint32 raid_id,
+		char* maintank = nullptr,
+		char* assist = nullptr,
+		char* puller = nullptr,
+		char* marknpc = nullptr,
+		RaidLeadershipAA_Struct* RLAA = nullptr
+	);
+	void SetRaidGroupLeaderInfo(uint32 group_id, uint32 raid_id);
 
-	const char *GetRaidLeaderName(uint32 rid);
+	void PurgeAllDeletedDataBuckets();
 
-	uint32	GetRaidID(const char* name);
-
-	void	ClearRaid(uint32 rid = 0);
-	void	ClearRaidDetails(uint32 rid = 0);
-	void	ClearRaidLeader(uint32 gid = 0xFFFFFFFF, uint32 rid = 0);
-	void	GetGroupLeadershipInfo(uint32 gid, uint32 rid, char* maintank = nullptr, char* assist = nullptr, char* puller = nullptr, char *marknpc = nullptr, char *mentoree = nullptr, int *mentor_percent = nullptr, GroupLeadershipAA_Struct* GLAA = nullptr);
-	void	GetRaidLeadershipInfo(uint32 rid, char* maintank = nullptr, char* assist = nullptr, char* puller = nullptr, char *marknpc = nullptr, RaidLeadershipAA_Struct* RLAA = nullptr);
-	void	SetRaidGroupLeaderInfo(uint32 gid, uint32 rid);
-
-	void    PurgeAllDeletedDataBuckets();
-
-	/* Database Conversions 'database_conversions.cpp' */
-
-	bool	CheckDatabaseConversions();
-	bool	CheckDatabaseConvertCorpseDeblob();
-	bool	CheckDatabaseConvertPPDeblob();
 
 	/* Database Variables */
+	bool GetVariable(const std::string& name, std::string& value);
+	bool SetVariable(const std::string& name, const std::string& value);
+	bool LoadVariables();
 
-	bool	GetVariable(std::string varname, std::string &varvalue);
-	bool	SetVariable(const std::string& varname, const std::string &varvalue);
-	bool	LoadVariables();
+	uint8 GetPEQZone(uint32 zone_id, uint32 version);
+	uint32 GetServerType();
+	void AddReport(const std::string& who, const std::string& against, const std::string& lines);
+	struct TimeOfDay_Struct LoadTime(time_t& realtime);
+	bool SaveTime(int8 minute, int8 hour, int8 day, int8 month, int16 year);
+	void ClearMerchantTemp();
+	void ClearPTimers(uint32 character_id);
+	void SetFirstLogon(uint32 character_id, uint8 first_logon);
+	void SetLFG(uint32 character_id, bool is_lfg);
+	void SetLFP(uint32 character_id, bool is_lfp);
+	void SetLoginFlags(uint32 character_id, bool is_lfp, bool is_lfg, uint8 first_logon);
 
-	/* General Queries */
+	int64 CountInvSnapshots();
+	void ClearInvSnapshots(bool from_now = false);
 
-	bool	GetZoneGraveyard(const uint32 graveyard_id, uint32* graveyard_zoneid = 0, float* graveyard_x = 0, float* graveyard_y = 0, float* graveyard_z = 0, float* graveyard_heading = 0);
-	bool	LoadPTimers(uint32 charid, PTimerList &into);
-
-	uint8	GetPEQZone(uint32 zone_id, uint32 version);
-	uint8	GetMinStatus(uint32 zone_id, uint32 instance_version);
-	uint8	GetRaceSkill(uint8 skillid, uint8 in_race);
-	uint8	GetServerType();
-	uint8	GetSkillCap(uint8 skillid, uint8 in_race, uint8 in_class, uint16 in_level);
-
-	void	AddReport(std::string who, std::string against, std::string lines);
-	struct TimeOfDay_Struct		LoadTime(time_t &realtime);
-	bool	SaveTime(int8 minute, int8 hour, int8 day, int8 month, int16 year);
-	void	ClearMerchantTemp();
-	void	ClearPTimers(uint32 charid);
-	void	SetFirstLogon(uint32 CharID, uint8 firstlogon);
-	void	SetLFG(uint32 CharID, bool LFG);
-	void	SetLFP(uint32 CharID, bool LFP);
-	void	SetLoginFlags(uint32 CharID, bool LFP, bool LFG, uint8 firstlogon);
-
-	int		CountInvSnapshots();
-	void	ClearInvSnapshots(bool from_now = false);
-
-	void SourceDatabaseTableFromUrl(std::string table_name, std::string url);
-	void SourceSqlFromUrl(std::string url);
+	void SourceDatabaseTableFromUrl(const std::string& table_name, const std::string& url);
+	void SourceSqlFromUrl(const std::string& url);
 
 private:
-
-	Mutex Mvarcache;
+	Mutex           Mvarcache;
 	VarCache_Struct varcache;
 
 	/* Groups, utility methods. */
-	void    ClearAllGroupLeaders();
-	void    ClearAllGroups();
+	void ClearAllGroupLeaders();
+	void ClearAllGroups();
 
 	/* Raid, utility methods. */
 	void ClearAllRaids();

common/database/database_dump_service.cpp

@@ -575,7 +575,12 @@ void DatabaseDumpService::RemoveSqlBackup()
 {
 	std::string file = fmt::format("{}.sql", GetDumpFileNameWithPath());
 	if (File::Exists(file)) {
-		std::filesystem::remove(file);
+		try {
+			std::filesystem::remove(file);
+		}
+		catch (std::exception &e) {
+			LogError("std::filesystem::remove err [{}]", e.what());
+		}
 	}
 
 	RemoveCredentialsFile();

common/database/database_update.cpp

@@ -76,9 +76,9 @@ void DatabaseUpdate::CheckDbUpdates()
 	}
 }
 
-std::string DatabaseUpdate::GetQueryResult(std::string query)
+std::string DatabaseUpdate::GetQueryResult(const ManifestEntry& e)
 {
-	auto results = m_database->QueryDatabase(query);
+	auto results = (e.content_schema_update ? m_content_database : m_database)->QueryDatabase(e.check);
 
 	std::vector<std::string> result_lines = {};
 
@@ -121,6 +121,16 @@ bool DatabaseUpdate::ShouldRunMigration(ManifestEntry &e, std::string query_resu
 	return false;
 }
 
+// check if we are running in a terminal
+bool is_atty()
+{
+#ifdef _WINDOWS
+	return ::_isatty(_fileno(stdin));
+#else
+	return isatty(fileno(stdin));
+#endif
+}
+
 // return true if we ran updates
 bool DatabaseUpdate::UpdateManifest(
 	std::vector<ManifestEntry> entries,
@@ -136,7 +146,7 @@ bool DatabaseUpdate::UpdateManifest(
 			for (auto &e: entries) {
 				if (e.version == version) {
 					bool        has_migration = true;
-					std::string r             = GetQueryResult(e.check);
+					std::string r             = GetQueryResult(e);
 					if (ShouldRunMigration(e, r)) {
 						has_migration = false;
 						missing_migrations.emplace_back(e.version);
@@ -179,7 +189,7 @@ bool DatabaseUpdate::UpdateManifest(
 				if (e.version == m) {
 					bool errored_migration = false;
 
-					auto r = m_database->QueryDatabaseMulti(e.sql);
+					auto r = (e.content_schema_update ? m_content_database : m_database)->QueryDatabaseMulti(e.sql);
 
 					// ignore empty query result "errors"
 					if (r.ErrorNumber() != 1065 && !r.ErrorMessage().empty()) {
@@ -187,31 +197,38 @@ bool DatabaseUpdate::UpdateManifest(
 						errored_migration = true;
 
 						LogInfo("Required database update failed. This could be a problem");
-						LogInfo("Would you like to skip this update? [y/n] (Timeout 60s)");
 
-						// user input
-						std::string input;
-						bool        gave_input        = false;
-						time_t      start_time        = time(nullptr);
-						time_t      wait_time_seconds = 60;
+						// if terminal attached then prompt for skip
+						if (is_atty()) {
+							LogInfo("Would you like to skip this update? [y/n] (Timeout 60s)");
 
-						// spawn a concurrent thread that waits for input from std::cin
-						std::thread t1(
-							[&]() {
-								std::cin >> input;
-								gave_input = true;
+							// user input
+							std::string input;
+							bool        gave_input        = false;
+							time_t      start_time        = time(nullptr);
+							time_t      wait_time_seconds = 60;
+
+							// spawn a concurrent thread that waits for input from std::cin
+							std::thread t1(
+								[&]() {
+									std::cin >> input;
+									gave_input = true;
+								}
+							);
+							t1.detach();
+
+							// check the inputReceived flag once every 50ms for 10 seconds
+							while (time(nullptr) < start_time + wait_time_seconds && !gave_input) {
+								std::this_thread::sleep_for(std::chrono::milliseconds(50));
 							}
-						);
-						t1.detach();
 
-						// check the inputReceived flag once every 50ms for 10 seconds
-						while (time(nullptr) < start_time + wait_time_seconds && !gave_input) {
-							std::this_thread::sleep_for(std::chrono::milliseconds(50));
-						}
-
-						// prompt for user skip
-						if (Strings::Trim(input) == "y") {
-							errored_migration = false;
+							// prompt for user skip
+							if (Strings::Trim(input) == "y") {
+								errored_migration = false;
+								LogInfo("Skipping update [{}] [{}]", e.version, e.description);
+							}
+						} else {
+							errored_migration = true;
 							LogInfo("Skipping update [{}] [{}]", e.version, e.description);
 						}
 					}
@@ -247,6 +264,13 @@ DatabaseUpdate *DatabaseUpdate::SetDatabase(Database *db)
 	return this;
 }
 
+DatabaseUpdate *DatabaseUpdate::SetContentDatabase(Database *db)
+{
+	m_content_database = db;
+
+	return this;
+}
+
 bool DatabaseUpdate::CheckVersionsUpToDate(DatabaseVersion v, DatabaseVersion b)
 {
 	LogInfo("{}", Strings::Repeat("-", BREAK_LENGTH));

common/database/database_update.h

@@ -10,6 +10,7 @@ struct ManifestEntry {
 	std::string condition{};   // condition or "match_type" - Possible values [contains|match|missing|empty|not_empty]
 	std::string match{};       // match field that is not always used, but works in conjunction with "condition" values [missing|match|contains]
 	std::string sql{};         // the SQL DDL that gets ran when the condition is true
+	bool        content_schema_update{}; // if true, this migration is a content schema update and should be ran against the content database
 };
 
 struct DatabaseVersion {
@@ -22,14 +23,16 @@ public:
 	DatabaseVersion GetDatabaseVersions();
 	DatabaseVersion GetBinaryDatabaseVersions();
 	void CheckDbUpdates();
-	std::string GetQueryResult(std::string query);
+	std::string GetQueryResult(const ManifestEntry& e);
 	static bool ShouldRunMigration(ManifestEntry &e, std::string query_result);
 	bool UpdateManifest(std::vector<ManifestEntry> entries, int version_low, int version_high);
 
 	DatabaseUpdate *SetDatabase(Database *db);
+	DatabaseUpdate *SetContentDatabase(Database *db);
 	bool HasPendingUpdates();
 private:
 	Database *m_database;
+	Database *m_content_database;
 	static bool CheckVersionsUpToDate(DatabaseVersion v, DatabaseVersion b);
 	void InjectBotsVersionColumn();
 };

common/database/database_update_manifest.cpp

@@ -4844,7 +4844,7 @@ UPDATE data_buckets SET bot_id = SUBSTRING_INDEX(SUBSTRING_INDEX( `key`, '-', 2
 			ADD COLUMN `marked_npc_3_zone_id` INT UNSIGNED NOT NULL DEFAULT '0' AFTER `marked_npc_3_entity_id`,
 			ADD COLUMN `marked_npc_3_instance_id` INT UNSIGNED NOT NULL DEFAULT '0' AFTER `marked_npc_3_zone_id`;
 		)"
-    },
+	},
 	ManifestEntry{
 		.version = 9235,
 		.description = "2023_07_31_character_stats_record.sql",
@@ -5016,7 +5016,7 @@ CREATE TABLE `spawn2_disabled` (
 ) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8mb4;
 INSERT INTO spawn2_disabled (spawn2_id, disabled) SELECT id, 1 FROM spawn2 WHERE enabled = 0;
 ALTER TABLE `spawn2` DROP COLUMN `enabled`;
-)"
+)",
 	},
 	ManifestEntry{
 		.version = 9242,
@@ -5028,7 +5028,8 @@ ALTER TABLE `spawn2` DROP COLUMN `enabled`;
 ALTER TABLE `spawnentry`
 ADD COLUMN `min_time` smallint(4) NOT NULL DEFAULT 0 AFTER `condition_value_filter`,
 ADD COLUMN `max_time` smallint(4) NOT NULL DEFAULT 0 AFTER `min_time`;
-)"
+)",
+		.content_schema_update = true
 	},
 	ManifestEntry{
 		.version = 9243,
@@ -5082,7 +5083,8 @@ INSERT INTO
 
 DROP TABLE `starting_items`;
 RENAME TABLE `starting_items_new` TO `starting_items`;
-)"
+)",
+		.content_schema_update = true
 	},
 	ManifestEntry{
 		.version = 9244,
@@ -5092,7 +5094,8 @@ RENAME TABLE `starting_items_new` TO `starting_items`;
 		.match = "0000-00-00 00:00:00",
 		.sql = R"(
 ALTER TABLE `items` MODIFY COLUMN `updated` datetime NULL DEFAULT NULL;
-		)"
+		)",
+		.content_schema_update = true
 	},
 	ManifestEntry{
 		.version = 9245,
@@ -5104,7 +5107,8 @@ ALTER TABLE `items` MODIFY COLUMN `updated` datetime NULL DEFAULT NULL;
 ALTER TABLE `object` CHANGE COLUMN `unknown08` `size_percentage` float NOT NULL DEFAULT 0 AFTER `icon`;
 ALTER TABLE `object` CHANGE COLUMN `unknown10` `solid_type` mediumint(5) NOT NULL DEFAULT 0 AFTER `size`;
 ALTER TABLE `object` CHANGE COLUMN `unknown20` `incline` int(11) NOT NULL DEFAULT 0 AFTER `solid_type`;
-)"
+)",
+		.content_schema_update = true
 	},
 	ManifestEntry{
 		.version = 9246,
@@ -5133,9 +5137,339 @@ CHANGE COLUMN `slot` `inventory_slot` mediumint(9) NOT NULL DEFAULT -1 AFTER `st
 
 ALTER TABLE `starting_items`
 CHANGE COLUMN `temporary` `class_list` text CHARACTER SET latin1 COLLATE latin1_swedish_ci NULL DEFAULT NULL AFTER `id`;
+)",
+		.content_schema_update = true
+	},
+	ManifestEntry{
+		.version = 9248,
+		.description = "2023_12_22_drop_npc_emotes_index.sql",
+		.check = "show index from npc_emotes where key_name = 'emoteid'",
+		.condition = "not_empty",
+		.match = "",
+		.sql = R"(
+ALTER TABLE `npc_emotes` DROP INDEX `emoteid`;
+)",
+		.content_schema_update = true
+	},
+	ManifestEntry{
+		.version = 9249,
+		.description = "2023_12_26_add_tasks_enabled_column.sql",
+		.check = "SHOW COLUMNS FROM `tasks` LIKE 'enabled'",
+		.condition = "empty",
+		.match = "",
+		.sql = R"(
+ALTER TABLE `tasks`
+ADD COLUMN `enabled` smallint NULL DEFAULT 1 AFTER `faction_amount`
+)",
+		.content_schema_update = true
+	},
+	ManifestEntry{
+		.version = 9250,
+		.description = "2023_01_06_task_activities_list_group.sql",
+		.check = "SHOW COLUMNS FROM `task_activities` LIKE 'list_group'",
+		.condition = "empty",
+		.match = "",
+		.sql = R"(
+ALTER TABLE `task_activities`
+	ADD COLUMN `list_group` TINYINT UNSIGNED NOT NULL DEFAULT '0' AFTER `optional`;
+)",
+		.content_schema_update = true
+	},
+	ManifestEntry{
+		.version = 9251,
+		.description = "2023_01_12_instance_list_notes.sql",
+		.check = "SHOW COLUMNS FROM `instance_list` LIKE 'notes'",
+		.condition = "empty",
+		.match = "",
+		.sql = R"(
+ALTER TABLE `instance_list`
+	ADD COLUMN `notes` varchar(50) NOT NULL DEFAULT '' AFTER `never_expires`;
+)",
+	},
+	ManifestEntry{
+		.version = 9252,
+		.description = "2024_01_07_zone_idle_when_empty.sql",
+		.check = "SHOW COLUMNS FROM `zone` LIKE 'idle_when_empty'",
+		.condition = "empty",
+		.match = "",
+		.sql = R"(
+ALTER TABLE `zone`
+ADD COLUMN `idle_when_empty` tinyint(1) UNSIGNED NOT NULL DEFAULT 1 AFTER `min_lava_damage`,
+ADD COLUMN `seconds_before_idle` int(11) UNSIGNED NOT NULL DEFAULT 60 AFTER `idle_when_empty`;
+)",
+		.content_schema_update = true
+	},
+	ManifestEntry{
+		.version = 9253,
+		.description = "2024_01_13_merchantlist_slot.sql",
+		.check = "SHOW COLUMNS FROM `merchantlist` LIKE 'slot'",
+		.condition = "missing",
+		.match = "unsigned",
+		.sql = R"(
+ALTER TABLE `merchantlist`
+	MODIFY COLUMN `slot` int(11) UNSIGNED NOT NULL DEFAULT 0
+)",
+		.content_schema_update = true
+	},
+	ManifestEntry{
+		.version = 9254,
+		.description = "2024_01_13_merchantlist_temp_slot.sql",
+		.check = "SHOW COLUMNS FROM `merchantlist_temp` LIKE 'slot'",
+		.condition = "contains",
+		.match = "tinyint",
+		.sql = R"(
+ALTER TABLE `merchantlist_temp`
+	MODIFY COLUMN `slot` int(11) UNSIGNED NOT NULL DEFAULT 0
 )"
-	}
+	},
+	ManifestEntry{
+		.version = 9255,
+		.description = "2024_01_13_drop_item_tick_deprecated.sql",
+		.check = "show tables like 'item_tick'",
+		.condition = "not_empty",
+		.match = "",
+		.sql = R"(
+DROP TABLE IF EXISTS item_tick
+)"
+	},
+	ManifestEntry{
+		.version = 9256,
+		.description = "2024_01_16_increase_spawngroup_size.sql",
+		.check = "SHOW COLUMNS FROM `spawngroup` LIKE 'name'",
+		.condition = "contains",
+		.match = "varchar(50)",
+		.sql = R"(
+ALTER TABLE `spawngroup`
+MODIFY COLUMN `name` varchar(200) CHARACTER SET latin1 COLLATE latin1_swedish_ci NOT NULL DEFAULT '' AFTER `id`;
+)",
+		.content_schema_update = true
+	},
+	ManifestEntry{
+		.version = 9257,
+		.description = "2024_01_16_ground_spawns_fix_z.sql",
+		.check = "SHOW COLUMNS FROM `ground_spawns` LIKE 'fix_z'",
+		.condition = "empty",
+		.match = "",
+		.sql = R"(
+ALTER TABLE `ground_spawns`
+ADD COLUMN `fix_z` tinyint(1) UNSIGNED NOT NULL DEFAULT 1 AFTER `respawn_timer`;
+)",
+		.content_schema_update = true
+	},
+	ManifestEntry{
+		.version = 9258,
+		.description = "2024_02_04_base_data.sql",
+		.check = "SHOW COLUMNS FROM `base_data` LIKE 'hp_regen'",
+		.condition = "empty",
+		.match = "",
+		.sql = R"(
+ALTER TABLE `base_data`
+CHANGE COLUMN `unk1` `hp_regen` double NOT NULL AFTER `end`,
+CHANGE COLUMN `unk2` `end_regen` double NOT NULL AFTER `hp_regen`,
+MODIFY COLUMN `level` tinyint(3) UNSIGNED NOT NULL FIRST,
+MODIFY COLUMN `class` tinyint(2) UNSIGNED NOT NULL AFTER `level`;
+)",
+		.content_schema_update = true
+	},
+	ManifestEntry{
+		.version = 9259,
+		.description = "2024_01_13_corpse_rez_overhaul.sql",
+		.check = "SHOW COLUMNS FROM `character_corpses` LIKE 'rez_time'",
+		.condition = "empty",
+		.match = "",
+		.sql = R"(
+ALTER TABLE `character_corpses`
+ADD COLUMN `rez_time` int(11) UNSIGNED NOT NULL DEFAULT 0 AFTER `wc_9`,
+ADD COLUMN `gm_exp` int(11) UNSIGNED NOT NULL DEFAULT 0 AFTER `rez_time`,
+ADD COLUMN `killed_by` int(11) UNSIGNED NOT NULL DEFAULT 0 AFTER `gm_exp`,
+ADD COLUMN `rezzable` tinyint(1) UNSIGNED NOT NULL DEFAULT 0 AFTER `killed_by`;
+)"
+	},
+	ManifestEntry{
+		.version = 9260,
+		.description = "2023_11_11_guild_features.sql",
+		.check = "SHOW TABLES LIKE 'guild_permissions'",
+		.condition = "empty",
+		.match = "",
+		.sql = R"(
+CREATE TABLE `guild_permissions` (
+	`id` INT(11) NOT NULL AUTO_INCREMENT,
+	`perm_id` INT(11) NOT NULL DEFAULT '0',
+	`guild_id` INT(11) NOT NULL DEFAULT '0',
+	`permission` INT(11) NOT NULL DEFAULT '0',
+	PRIMARY KEY (`id`) USING BTREE,
+	UNIQUE INDEX `perm_id_guild_id` (`perm_id`, `guild_id`) USING BTREE
+)
+ENGINE=InnoDB
+AUTO_INCREMENT=1;
 
+UPDATE guild_ranks SET title = 'Leader' WHERE `rank` = '1';
+UPDATE guild_ranks SET title = 'Senior Officer' WHERE `rank` = '2';
+UPDATE guild_ranks SET title = 'Officer' WHERE `rank` = '3';
+UPDATE guild_ranks SET title = 'Senior Member' WHERE `rank` = '4';
+UPDATE guild_ranks SET title = 'Member' WHERE `rank` = '5';
+UPDATE guild_ranks SET title = 'Junior Member' WHERE `rank` = '6';
+UPDATE guild_ranks SET title = 'Initiate' WHERE `rank` = '7';
+UPDATE guild_ranks SET title = 'Recruit' WHERE `rank` = '8';
+
+DELETE FROM guild_ranks WHERE `rank` = 0;
+
+ALTER TABLE `guild_ranks`
+	DROP COLUMN `can_hear`,
+	DROP COLUMN `can_speak`,
+	DROP COLUMN `can_invite`,
+	DROP COLUMN `can_remove`,
+	DROP COLUMN `can_promote`,
+	DROP COLUMN `can_demote`,
+	DROP COLUMN `can_motd`,
+	DROP COLUMN `can_warpeace`;
+
+UPDATE guild_members SET `rank` = '5' WHERE `rank` = '0';
+UPDATE guild_members SET `rank` = '3' WHERE `rank` = '1';
+UPDATE guild_members SET `rank` = '1' WHERE `rank` = '2';
+
+ALTER TABLE `guild_members`
+	ADD COLUMN `online` TINYINT(3) UNSIGNED NOT NULL DEFAULT '0' AFTER `alt`;
+
+ALTER TABLE `guilds`
+	ADD COLUMN `favor` INT(10) UNSIGNED NOT NULL DEFAULT '0' AFTER `url`;
+
+CREATE TABLE guild_tributes (
+  guild_id int(11) unsigned NOT NULL DEFAULT 0,
+  tribute_id_1 int(11) unsigned NOT NULL DEFAULT 0,
+  tribute_id_1_tier int(11) unsigned NOT NULL DEFAULT 0,
+  tribute_id_2 int(11) unsigned NOT NULL DEFAULT 0,
+  tribute_id_2_tier int(11) unsigned NOT NULL DEFAULT 0,
+  time_remaining int(11) unsigned NOT NULL DEFAULT 0,
+  enabled int(11) unsigned NOT NULL DEFAULT 0,
+  PRIMARY KEY (guild_id) USING BTREE
+) ENGINE=InnoDB;
+)"
+	},
+	ManifestEntry{
+		.version = 9261,
+		.description = "2024_02_11_character_corpses.sql",
+		.check = "SHOW COLUMNS FROM `character_corpses` LIKE 'time_of_death'",
+		.condition = "contains",
+		.match = "0000-00-00 00:00:00",
+		.sql = R"(
+ALTER TABLE `character_corpses` MODIFY COLUMN `time_of_death` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP;
+		)"
+	},
+	ManifestEntry{
+		.version = 9262,
+		.description = "2024_02_11_object_contents.sql",
+		.check = "SHOW COLUMNS FROM `object_contents` LIKE 'droptime'",
+		.condition = "contains",
+		.match = "0000-00-00 00:00:00",
+		.sql = R"(
+ALTER TABLE `object_contents` MODIFY COLUMN `droptime` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP;
+		)"
+	},
+	ManifestEntry{
+		.version = 9263,
+		.description = "2024_02_16_rearrange_zone_columns.sql",
+		.check = "show columns from zone like 'note'",
+		.condition = "missing",
+		.match = "varchar(200)",
+		.sql = R"(
+ALTER TABLE `zone`
+MODIFY COLUMN `id` int(10) NOT NULL AUTO_INCREMENT FIRST,
+MODIFY COLUMN `zoneidnumber` int(4) NOT NULL DEFAULT 0 AFTER `id`,
+MODIFY COLUMN `version` tinyint(3) UNSIGNED NOT NULL DEFAULT 0 AFTER `zoneidnumber`,
+MODIFY COLUMN `short_name` varchar(32) CHARACTER SET latin1 COLLATE latin1_swedish_ci NULL DEFAULT NULL AFTER `version`,
+MODIFY COLUMN `long_name` text CHARACTER SET latin1 COLLATE latin1_swedish_ci NOT NULL AFTER `short_name`,
+MODIFY COLUMN `min_status` tinyint(3) UNSIGNED NOT NULL DEFAULT 0 AFTER `long_name`,
+MODIFY COLUMN `note` varchar(200) CHARACTER SET latin1 COLLATE latin1_swedish_ci NULL DEFAULT NULL AFTER `map_file_name`,
+MODIFY COLUMN `min_expansion` tinyint(4) NOT NULL DEFAULT -1 AFTER `note`,
+MODIFY COLUMN `max_expansion` tinyint(4) NOT NULL DEFAULT -1 AFTER `min_expansion`,
+MODIFY COLUMN `content_flags` varchar(100) CHARACTER SET latin1 COLLATE latin1_swedish_ci NULL DEFAULT NULL AFTER `max_expansion`,
+MODIFY COLUMN `content_flags_disabled` varchar(100) CHARACTER SET latin1 COLLATE latin1_swedish_ci NULL DEFAULT NULL AFTER `content_flags`,
+MODIFY COLUMN `expansion` tinyint(3) NOT NULL DEFAULT 0 AFTER `content_flags_disabled`,
+MODIFY COLUMN `file_name` varchar(16) CHARACTER SET latin1 COLLATE latin1_swedish_ci NULL DEFAULT NULL AFTER `expansion`,
+MODIFY COLUMN `safe_x` float NOT NULL DEFAULT 0 AFTER `file_name`,
+MODIFY COLUMN `safe_y` float NOT NULL DEFAULT 0 AFTER `safe_x`,
+MODIFY COLUMN `safe_z` float NOT NULL DEFAULT 0 AFTER `safe_y`,
+MODIFY COLUMN `safe_heading` float NOT NULL DEFAULT 0 AFTER `safe_z`;
+		)",
+		.content_schema_update = true
+	},
+	ManifestEntry{
+		.version = 9264,
+		.description = "2024_02_18_starting_items_augments.sql",
+		.check = "SHOW COLUMNS FROM `starting_items` LIKE 'augment_one'",
+		.condition = "empty",
+		.match = "",
+		.sql = R"(
+ALTER TABLE `starting_items`
+ADD COLUMN `augment_one` int(11) UNSIGNED NOT NULL DEFAULT 0 AFTER `item_charges`,
+ADD COLUMN `augment_two` int(11) UNSIGNED NOT NULL DEFAULT 0 AFTER `augment_one`,
+ADD COLUMN `augment_three` int(11) UNSIGNED NOT NULL DEFAULT 0 AFTER `augment_two`,
+ADD COLUMN `augment_four` int(11) UNSIGNED NOT NULL DEFAULT 0 AFTER `augment_three`,
+ADD COLUMN `augment_five` int(11) UNSIGNED NOT NULL DEFAULT 0 AFTER `augment_four`,
+ADD COLUMN `augment_six` int(11) UNSIGNED NOT NULL DEFAULT 0 AFTER `augment_five`;
+		)",
+		.content_schema_update = true
+	},
+	ManifestEntry{
+		.version = 9265,
+		.description = "2024_03_03_add_id_to_guild_bank.sql",
+		.check = "SHOW COLUMNS FROM `guild_bank` LIKE 'id'",
+		.condition = "empty",
+		.match = "",
+		.sql = R"(
+ALTER TABLE `guild_bank`
+ADD COLUMN `id` INT UNSIGNED NOT NULL AUTO_INCREMENT FIRST,
+ADD PRIMARY KEY (`id`);
+		)",
+	},
+	ManifestEntry{
+		.version = 9266,
+		.description = "2024_03_02_rule_values_rule_value_length.sql",
+		.check = "SHOW COLUMNS FROM `rule_values` LIKE 'rule_value'",
+		.condition = "contains",
+		.match = "varchar(30)",
+		.sql = R"(
+ALTER TABLE `rule_values`
+MODIFY COLUMN `rule_value` text CHARACTER SET latin1 COLLATE latin1_swedish_ci NULL DEFAULT NULL AFTER `rule_name`;
+		)"
+	},
+	ManifestEntry{
+		.version = 9267,
+		.description = "2024_02_18_group_id_bot_id.sql",
+		.check = "SHOW COLUMNS FROM `group_id` LIKE 'bot_id'",
+		.condition = "empty",
+		.match = "",
+		.sql = R"(
+ALTER TABLE `group_id`
+CHANGE COLUMN `groupid` `group_id` int(11) UNSIGNED NOT NULL DEFAULT 0 FIRST,
+CHANGE COLUMN `charid` `character_id` int(11) UNSIGNED NOT NULL DEFAULT 0 AFTER `group_id`,
+CHANGE COLUMN `ismerc` `merc_id` int(11) UNSIGNED NOT NULL DEFAULT 0 AFTER `name`,
+ADD COLUMN `bot_id` int(11) UNSIGNED NOT NULL DEFAULT 0 AFTER `character_id`,
+MODIFY COLUMN `name` varchar(64) NOT NULL DEFAULT '' AFTER `character_id`,
+DROP PRIMARY KEY,
+ADD PRIMARY KEY (`group_id`, `character_id`, `bot_id`, `merc_id`) USING BTREE;
+ALTER TABLE `group_id`
+MODIFY COLUMN `character_id` int(11) UNSIGNED NOT NULL DEFAULT 0 AFTER `name`;
+)"
+	},
+	ManifestEntry{
+		.version = 9268,
+		.description = "2024_03_23_skill_caps.sql",
+		.check = "SHOW COLUMNS FROM `skill_caps` LIKE 'skill_id'",
+		.condition = "empty",
+		.match = "",
+		.sql = R"(
+ALTER TABLE `skill_caps`
+CHANGE COLUMN `skillID` `skill_id` tinyint(3) UNSIGNED NOT NULL DEFAULT 0 FIRST,
+CHANGE COLUMN `class` `class_id` tinyint(3) UNSIGNED NOT NULL DEFAULT 0 AFTER `skill_id`,
+ADD COLUMN `id` int(3) UNSIGNED NOT NULL AUTO_INCREMENT FIRST,
+DROP PRIMARY KEY,
+ADD PRIMARY KEY (`id`) USING BTREE,
+ADD INDEX `level_skill_cap`(`skill_id`, `class_id`, `level`, `cap`);
+)",
+		.content_schema_update = true,
+	}
 // -- template; copy/paste this when you need to create a new entry
 //	ManifestEntry{
 //		.version = 9228,

common/database/database_update_manifest_bots.cpp

@@ -82,6 +82,63 @@ CREATE TABLE `bot_starting_items`  (
 `content_flags_disabled` varchar(100) CHARACTER SET latin1 COLLATE latin1_swedish_ci NULL DEFAULT NULL,
 PRIMARY KEY (`id`)
 ) ENGINE = InnoDB CHARACTER SET = latin1 COLLATE = latin1_swedish_ci;
+)",
+	},
+	ManifestEntry{
+		.version = 9041,
+		.description = "2023_12_04_bot_timers.sql",
+		.check = "SHOW COLUMNS FROM `bot_timers` LIKE 'recast_time'",
+		.condition = "empty",
+		.match = "",
+		.sql = R"(
+ALTER TABLE `bot_timers`
+	ADD COLUMN `recast_time` INT(11) UNSIGNED NOT NULL DEFAULT '0' AFTER `timer_value`,
+	ADD COLUMN `is_spell` TINYINT(2) UNSIGNED NOT NULL DEFAULT 0 AFTER `recast_time`,
+	ADD COLUMN `is_disc` TINYINT(2) UNSIGNED NOT NULL DEFAULT 0 AFTER `is_spell`,
+	ADD COLUMN `spell_id` INT(11) UNSIGNED NOT NULL DEFAULT '0' AFTER `is_disc`,
+	ADD COLUMN `is_item` TINYINT(2) UNSIGNED NOT NULL DEFAULT 0 AFTER `spell_id`,
+	ADD COLUMN `item_id` INT(11) UNSIGNED NOT NULL DEFAULT '0' AFTER `is_item`;
+ALTER TABLE `bot_timers`
+	DROP FOREIGN KEY `FK_bot_timers_1`;
+ALTER TABLE `bot_timers`
+	DROP PRIMARY KEY;
+ALTER TABLE `bot_timers`
+	ADD PRIMARY KEY (`bot_id`, `timer_id`, `spell_id`, `item_id`);
+)"
+	},
+	ManifestEntry{
+		.version = 9042,
+		.description = "2024_01_27_delete_bot_foreign_keys.sql",
+		.check = "SHOW CREATE TABLE `bot_stances`",
+		.condition = "contains",
+		.match = "FOREIGN",
+		.sql = R"(
+ALTER TABLE `bot_buffs` DROP FOREIGN KEY `FK_bot_buffs_1`;
+ALTER TABLE `bot_heal_rotations` DROP FOREIGN KEY `FK_bot_heal_rotations`;
+ALTER TABLE `bot_heal_rotation_members` DROP FOREIGN KEY `FK_bot_heal_rotation_members_1`;
+ALTER TABLE `bot_heal_rotation_members` DROP FOREIGN KEY `FK_bot_heal_rotation_members_2`;
+ALTER TABLE `bot_heal_rotation_targets` DROP FOREIGN KEY `FK_bot_heal_rotation_targets`;
+ALTER TABLE `bot_inventories` DROP FOREIGN KEY `FK_bot_inventories_1`;
+ALTER TABLE `bot_pets` DROP FOREIGN KEY `FK_bot_pets_1`;
+ALTER TABLE `bot_pet_buffs` DROP FOREIGN KEY `FK_bot_pet_buffs_1`;
+ALTER TABLE `bot_pet_inventories` DROP FOREIGN KEY `FK_bot_pet_inventories_1`;
+ALTER TABLE `bot_stances` DROP FOREIGN KEY `FK_bot_stances_1`;
+)"
+	},
+	ManifestEntry{
+		.version = 9043,
+		.description = "2024_02_18_bot_starting_items_augments.sql",
+		.check = "SHOW COLUMNS FROM `bot_starting_items` LIKE 'augment_one'",
+		.condition = "empty",
+		.match = "",
+		.sql = R"(
+ALTER TABLE `bot_starting_items`
+ADD COLUMN `augment_one` int(11) UNSIGNED NOT NULL DEFAULT 0 AFTER `item_charges`,
+ADD COLUMN `augment_two` int(11) UNSIGNED NOT NULL DEFAULT 0 AFTER `augment_one`,
+ADD COLUMN `augment_three` int(11) UNSIGNED NOT NULL DEFAULT 0 AFTER `augment_two`,
+ADD COLUMN `augment_four` int(11) UNSIGNED NOT NULL DEFAULT 0 AFTER `augment_three`,
+ADD COLUMN `augment_five` int(11) UNSIGNED NOT NULL DEFAULT 0 AFTER `augment_four`,
+ADD COLUMN `augment_six` int(11) UNSIGNED NOT NULL DEFAULT 0 AFTER `augment_five`;
 )"
 	}
 // -- template; copy/paste this when you need to create a new entry

common/database_conversions.cpp

@@ -1,39 +0,0 @@
-#include "../common/global_define.h"
-#include "../common/rulesys.h"
-#include "../common/strings.h"
-
-#include "database.h"
-#include "database/database_update.h"
-
-
-// Disgrace: for windows compile
-#ifdef _WINDOWS
-#include <windows.h>
-#define snprintf	_snprintf
-#define strncasecmp	_strnicmp
-#define strcasecmp	_stricmp
-#else
-
-#include "unix.h"
-#include <netinet/in.h>
-#include <sys/time.h>
-
-#endif
-
-#pragma pack(1)
-
-DatabaseUpdate database_update;
-
-bool Database::CheckDatabaseConversions()
-{
-	auto *r = RuleManager::Instance();
-	r->LoadRules(this, "default", false);
-	if (!RuleB(Bots, Enabled) && DoesTableExist("bot_data")) {
-		LogInfo("Bot tables found but rule not enabled, enabling");
-		r->SetRule("Bots:Enabled", "true", this, true, true);
-	}
-
-	database_update.SetDatabase(this)->CheckDbUpdates();
-
-	return true;
-}

common/database_instances.cpp

@@ -421,20 +421,25 @@ void Database::AssignGroupToInstance(uint32 group_id, uint32 instance_id)
 	auto zone_id = GetInstanceZoneID(instance_id);
 	auto version = GetInstanceVersion(instance_id);
 
-	auto l = GroupIdRepository::GetWhere(
+	const auto& l = GroupIdRepository::GetWhere(
 		*this,
 		fmt::format(
-			"groupid = {}",
+			"`group_id` = {}",
 			group_id
 		)
 	);
+
 	if (l.empty()) {
 		return;
 	}
 
 	for (const auto& e : l) {
-		if (!GetInstanceID(zone_id, e.charid, version)) {
-			AddClientToInstance(instance_id, e.charid);
+		if (!e.character_id) {
+			continue;
+		}
+
+		if (!GetInstanceID(zone_id, e.character_id, version)) {
+			AddClientToInstance(instance_id, e.character_id);
 		}
 	}
 }
@@ -504,7 +509,7 @@ void Database::FlagInstanceByRaidLeader(uint32 zone_id, int16 version, uint32 ch
 		return;
 	}
 
-	auto raid_leader_id = GetCharacterID(GetRaidLeaderName(raid_id));
+	auto raid_leader_id = GetCharacterID(GetRaidLeaderName(raid_id).c_str());
 	auto raid_leader_instance_id = GetInstanceID(zone_id, raid_leader_id, version);
 
 	if (!raid_leader_instance_id) {
@@ -570,3 +575,23 @@ void Database::SetInstanceDuration(uint16 instance_id, uint32 new_duration)
 
 	InstanceListRepository::UpdateOne(*this, i);
 }
+
+void Database::CleanupInstanceCorpses() {
+	auto l = InstanceListRepository::GetWhere(
+		*this,
+		"never_expires = 0"
+	);
+
+	if (l.empty()) {
+		return;
+	}
+
+	std::vector<std::string> instance_ids;
+	for (const auto& e : l) {
+		instance_ids.emplace_back(std::to_string(e.id));
+	}
+
+	const auto imploded_instance_ids = Strings::Implode(",", instance_ids);
+
+	CharacterCorpsesRepository::BuryInstances(*this, imploded_instance_ids);
+}

common/database_schema.h

@@ -71,7 +71,7 @@ namespace DatabaseSchema {
 			{"character_tasks",                "charid"},
 			{"character_tribute",              "character_id"},
 			{"completed_tasks",                "charid"},
-			{"data_buckets",                   "id"},
+			{"data_buckets",                   "character_id"},
 			{"faction_values",                 "char_id"},
 			{"friends",                        "charid"},
 			{"guild_members",                  "char_id"},
@@ -146,8 +146,10 @@ namespace DatabaseSchema {
 			"friends",
 			"guild_bank",
 			"guild_members",
+			"guild_permissions",
 			"guild_ranks",
 			"guild_relations",
+			"guild_tributes",
 			"guilds",
 			"instance_list_player",
 			"inventory",
@@ -332,7 +334,6 @@ namespace DatabaseSchema {
 			"group_leaders",
 			"instance_list",
 			"ip_exemptions",
-			"item_tick",
 			"lfguild",
 			"merc_buffs",
 			"merchantlist_temp",

common/dbcore.cpp

@@ -8,7 +8,6 @@
 
 #include "dbcore.h"
 
-#include <errmsg.h>
 #include <fstream>
 #include <iostream>
 #include <mysqld_error.h>
@@ -138,7 +137,7 @@ MySQLRequestResult DBcore::QueryDatabase(const char *query, uint32 querylen, boo
 		 * Error logging
 		 */
 		if (mysql_errno(mysql) > 0 && query[0] != '\0') {
-			LogMySQLError("[{}] [{}]\n[{}]", mysql_errno(mysql), mysql_error(mysql), query);
+			LogMySQLError("MySQL Error ({}) [{}] Query [{}]", mysql_errno(mysql), mysql_error(mysql), query);
 		}
 
 		return MySQLRequestResult(nullptr, 0, 0, 0, 0, mysql_errno(mysql), errorBuffer);

common/dbcore.h

@@ -14,6 +14,9 @@
 #include <string.h>
 #include <mutex>
 
+#define CR_SERVER_GONE_ERROR    2006
+#define CR_SERVER_LOST          2013
+
 class DBcore {
 public:
 	enum eStatus {

common/deity.h

@@ -71,6 +71,8 @@ namespace EQ
 			bit_DeityAll           = UINT32_MAX
 		};
 
+		constexpr int format_as(DeityType type) { return static_cast<int>(type); }
+
 		extern DeityTypeBit GetDeityBitmask(DeityType deity_type);
 		extern std::string GetDeityName(DeityType deity_type);
 		extern const std::map<DeityType, std::string>& GetDeityMap();

common/emu_constants.cpp

@@ -22,7 +22,6 @@
 #include "data_verification.h"
 #include "eqemu_logsys.h"
 #include "eqemu_logsys_log_aliases.h"
-#include "languages.h"
 #include "rulesys.h"
 
 int16 EQ::invtype::GetInvTypeSize(int16 inv_type) {
@@ -159,45 +158,45 @@ int EQ::constants::ConvertStanceTypeToIndex(StanceType stance_type) {
 	return 0;
 }
 
-const std::map<int, std::string>& EQ::constants::GetLanguageMap()
+const std::map<uint8, std::string>& EQ::constants::GetLanguageMap()
 {
-	static const std::map<int, std::string> language_map = {
-		{ LANG_COMMON_TONGUE, "Common Tongue" },
-		{ LANG_BARBARIAN, "Barbarian" },
-		{ LANG_ERUDIAN, "Erudian" },
-		{ LANG_ELVISH, "Elvish" },
-		{ LANG_DARK_ELVISH, "Dark Elvish" },
-		{ LANG_DWARVISH, "Dwarvish" },
-		{ LANG_TROLL, "Troll" },
-		{ LANG_OGRE, "Ogre" },
-		{ LANG_GNOMISH, "Gnomish" },
-		{ LANG_HALFLING, "Halfling" },
-		{ LANG_THIEVES_CANT, "Thieves Cant" },
-		{ LANG_OLD_ERUDIAN, "Old Erudian" },
-		{ LANG_ELDER_ELVISH, "Elder Elvish" },
-		{ LANG_FROGLOK, "Froglok" },
-		{ LANG_GOBLIN, "Goblin" },
-		{ LANG_GNOLL, "Gnoll" },
-		{ LANG_COMBINE_TONGUE, "Combine Tongue" },
-		{ LANG_ELDER_TEIRDAL, "Elder Teirdal" },
-		{ LANG_LIZARDMAN, "Lizardman" },
-		{ LANG_ORCISH, "Orcish" },
-		{ LANG_FAERIE, "Faerie" },
-		{ LANG_DRAGON, "Dragon" },
-		{ LANG_ELDER_DRAGON, "Elder Dragon" },
-		{ LANG_DARK_SPEECH, "Dark Speech" },
-		{ LANG_VAH_SHIR, "Vah Shir" },
-		{ LANG_ALARAN, "Alaran" },
-		{ LANG_HADAL, "Hadal" },
-		{ LANG_UNKNOWN, "Unknown" }
+	static const std::map<uint8, std::string> language_map = {
+		{ Language::CommonTongue,  "Common Tongue" },
+		{ Language::Barbarian,     "Barbarian" },
+		{ Language::Erudian,       "Erudian" },
+		{ Language::Elvish,        "Elvish" },
+		{ Language::DarkElvish,    "Dark Elvish" },
+		{ Language::Dwarvish,      "Dwarvish" },
+		{ Language::Troll,         "Troll" },
+		{ Language::Ogre,          "Ogre" },
+		{ Language::Gnomish,       "Gnomish" },
+		{ Language::Halfling,      "Halfling" },
+		{ Language::ThievesCant,   "Thieves Cant" },
+		{ Language::OldErudian,    "Old Erudian" },
+		{ Language::ElderElvish,   "Elder Elvish" },
+		{ Language::Froglok,       "Froglok" },
+		{ Language::Goblin,        "Goblin" },
+		{ Language::Gnoll,         "Gnoll" },
+		{ Language::CombineTongue, "Combine Tongue" },
+		{ Language::ElderTeirDal,  "Elder Teir'Dal" },
+		{ Language::Lizardman,     "Lizardman" },
+		{ Language::Orcish,        "Orcish" },
+		{ Language::Faerie,        "Faerie" },
+		{ Language::Dragon,        "Dragon" },
+		{ Language::ElderDragon,   "Elder Dragon" },
+		{ Language::DarkSpeech,    "Dark Speech" },
+		{ Language::VahShir,       "Vah Shir" },
+		{ Language::Alaran,        "Alaran" },
+		{ Language::Hadal,         "Hadal" },
+		{ Language::Unknown27,     "Unknown" }
 	};
 
 	return language_map;
 }
 
-std::string EQ::constants::GetLanguageName(int language_id)
+std::string EQ::constants::GetLanguageName(uint8 language_id)
 {
-	if (!EQ::ValueWithin(language_id, LANG_COMMON_TONGUE, LANG_UNKNOWN)) {
+	if (!EQ::ValueWithin(language_id, Language::CommonTongue, Language::Unknown27)) {
 		return std::string();
 	}
 
@@ -509,7 +508,6 @@ std::string EQ::constants::GetObjectTypeName(int object_type)
 {
 	if (!EQ::ValueWithin(object_type, ObjectTypes::SmallBag, ObjectTypes::NoDeposit)) {
 		return std::string();
-
 	}
 
 	return EQ::constants::GetObjectTypeMap().find(object_type)->second;
@@ -564,6 +562,7 @@ std::string EQ::constants::GetEmoteEventTypeName(uint8 emote_event_type)
 const std::map<uint8, std::string> &EQ::constants::GetEmoteTypeMap()
 {
 	static const std::map<uint8, std::string> emote_type_map = {
+		{ EmoteTypes::Say, "Say" },
 		{ EmoteTypes::Emote, "Emote" },
 		{ EmoteTypes::Shout, "Shout" },
 		{ EmoteTypes::Proximity, "Proximity" }
@@ -574,9 +573,144 @@ const std::map<uint8, std::string> &EQ::constants::GetEmoteTypeMap()
 
 std::string EQ::constants::GetEmoteTypeName(uint8 emote_type)
 {
-	if (!EQ::ValueWithin(emote_type, EmoteTypes::Emote, EmoteTypes::Proximity)) {
+	if (!EQ::ValueWithin(emote_type, EmoteTypes::Say, EmoteTypes::Proximity)) {
 		return std::string();
 	}
 
 	return EQ::constants::GetEmoteTypeMap().find(emote_type)->second;
 }
+
+const std::map<uint32, std::string>& EQ::constants::GetAppearanceTypeMap()
+{
+	static const std::map<uint32, std::string> appearance_type_map = {
+		{ AppearanceType::Die, "Die" },
+		{ AppearanceType::WhoLevel, "Who Level" },
+		{ AppearanceType::MaxHealth, "Max Health" },
+		{ AppearanceType::Invisibility, "Invisibility" },
+		{ AppearanceType::PVP, "PVP" },
+		{ AppearanceType::Light, "Light" },
+		{ AppearanceType::Animation, "Animation" },
+		{ AppearanceType::Sneak, "Sneak" },
+		{ AppearanceType::SpawnID, "Spawn ID" },
+		{ AppearanceType::Health, "Health" },
+		{ AppearanceType::Linkdead, "Linkdead" },
+		{ AppearanceType::FlyMode, "Fly Mode" },
+		{ AppearanceType::GM, "GM" },
+		{ AppearanceType::Anonymous, "Anonymous" },
+		{ AppearanceType::GuildID, "Guild ID" },
+		{ AppearanceType::GuildRank, "Guild Rank" },
+		{ AppearanceType::AFK, "AFK" },
+		{ AppearanceType::Pet, "Pet" },
+		{ AppearanceType::Summoned, "Summoned" },
+		{ AppearanceType::Split, "Split" },
+		{ AppearanceType::Size, "Size" },
+		{ AppearanceType::SetType, "Set Type" },
+		{ AppearanceType::NPCName, "NPCName" },
+		{ AppearanceType::AARank, "AARank" },
+		{ AppearanceType::CancelSneakHide, "Cancel Sneak Hide" },
+		{ AppearanceType::AreaHealthRegen, "Area Health Regeneration" },
+		{ AppearanceType::AreaManaRegen, "Area Mana Regeneration" },
+		{ AppearanceType::AreaEnduranceRegen, "Area Endurance Regeneration" },
+		{ AppearanceType::FreezeBeneficialBuffs, "Freeze Beneficial Buffs" },
+		{ AppearanceType::NPCTintIndex, "NPC Tint Index" },
+		{ AppearanceType::GroupAutoConsent, "Group Auto Consent" },
+		{ AppearanceType::RaidAutoConsent, "Raid Auto Consent" },
+		{ AppearanceType::GuildAutoConsent, "Guild Auto Consent" },
+		{ AppearanceType::ShowHelm, "Show Helm" },
+		{ AppearanceType::DamageState, "Damage State" },
+		{ AppearanceType::EQPlayers, "EQ Players" },
+		{ AppearanceType::FindBits, "Find Bits" },
+		{ AppearanceType::TextureType, "Texture Type" },
+		{ AppearanceType::FacePick, "Face Pick" },
+		{ AppearanceType::AntiCheat, "Anti Cheat" },
+		{ AppearanceType::GuildShow, "Guild Show" },
+		{ AppearanceType::OfflineMode, "Offline Mode" }
+	};
+
+	return appearance_type_map;
+}
+
+std::string EQ::constants::GetAppearanceTypeName(uint32 appearance_type)
+{
+	const auto& a = EQ::constants::GetAppearanceTypeMap().find(appearance_type);
+	if (a != EQ::constants::GetAppearanceTypeMap().end()) {
+		return a->second;
+	}
+
+	return std::string();
+}
+
+const std::map<uint32, std::string>& EQ::constants::GetSpecialAbilityMap()
+{
+	static const std::map<uint32, std::string> special_ability_map = {
+		{ SPECATK_SUMMON,            "Summon" },
+		{ SPECATK_ENRAGE,            "Enrage" },
+		{ SPECATK_RAMPAGE,           "Rampage" },
+		{ SPECATK_AREA_RAMPAGE,      "Area Rampage" },
+		{ SPECATK_FLURRY,            "Flurry" },
+		{ SPECATK_TRIPLE,            "Triple Attack" },
+		{ SPECATK_QUAD,              "Quadruple Attack" },
+		{ SPECATK_INNATE_DW,         "Dual Wield" },
+		{ SPECATK_BANE,              "Bane Attack" },
+		{ SPECATK_MAGICAL,           "Magical Attack" },
+		{ SPECATK_RANGED_ATK,        "Ranged Attack" },
+		{ UNSLOWABLE,                "Immune to Slow" },
+		{ UNMEZABLE,                 "Immune to Mesmerize" },
+		{ UNCHARMABLE,               "Immune to Charm" },
+		{ UNSTUNABLE,                "Immune to Stun" },
+		{ UNSNAREABLE,               "Immune to Snare" },
+		{ UNFEARABLE,                "Immune to Fear" },
+		{ UNDISPELLABLE,             "Immune to Dispell" },
+		{ IMMUNE_MELEE,              "Immune to Melee" },
+		{ IMMUNE_MAGIC,              "Immune to Magic" },
+		{ IMMUNE_FLEEING,            "Immune to Fleeing" },
+		{ IMMUNE_MELEE_EXCEPT_BANE,  "Immune to Melee except Bane" },
+		{ IMMUNE_MELEE_NONMAGICAL,   "Immune to Non-Magical Melee" },
+		{ IMMUNE_AGGRO,              "Immune to Aggro" },
+		{ IMMUNE_AGGRO_ON,           "Immune to Being Aggro" },
+		{ IMMUNE_CASTING_FROM_RANGE, "Immune to Ranged Spells" },
+		{ IMMUNE_FEIGN_DEATH,        "Immune to Feign Death" },
+		{ IMMUNE_TAUNT,              "Immune to Taunt" },
+		{ NPC_TUNNELVISION,          "Tunnel Vision" },
+		{ NPC_NO_BUFFHEAL_FRIENDS,   "Does Not Heal of Buff Allies" },
+		{ IMMUNE_PACIFY,             "Immune to Pacify" },
+		{ LEASH,                     "Leashed" },
+		{ TETHER,                    "Tethered" },
+		{ DESTRUCTIBLE_OBJECT,       "Destructible Object" },
+		{ NO_HARM_FROM_CLIENT,       "Immune to Harm from Client" },
+		{ ALWAYS_FLEE,               "Always Flees" },
+		{ FLEE_PERCENT,              "Flee Percentage" },
+		{ ALLOW_BENEFICIAL,          "Allows Beneficial Spells" },
+		{ DISABLE_MELEE,             "Melee is Disabled" },
+		{ NPC_CHASE_DISTANCE,        "Chase Distance" },
+		{ ALLOW_TO_TANK,             "Allowed to Tank" },
+		{ IGNORE_ROOT_AGGRO_RULES,   "Ignores Root Aggro" },
+		{ CASTING_RESIST_DIFF,       "Casting Resist Difficulty" },
+		{ COUNTER_AVOID_DAMAGE,      "Counter Damage Avoidance" },
+		{ PROX_AGGRO,                "Proximity Aggro" },
+		{ IMMUNE_RANGED_ATTACKS,     "Immune to Ranged Attacks" },
+		{ IMMUNE_DAMAGE_CLIENT,      "Immune to Client Damage" },
+		{ IMMUNE_DAMAGE_NPC,         "Immune to NPC Damage" },
+		{ IMMUNE_AGGRO_CLIENT,       "Immune to Client Aggro" },
+		{ IMMUNE_AGGRO_NPC,          "Immune to NPC Aggro" },
+		{ MODIFY_AVOID_DAMAGE,       "Modify Damage Avoidance" },
+		{ IMMUNE_FADING_MEMORIES,    "Immune to Memory Fades" },
+		{ IMMUNE_OPEN,               "Immune to Open" },
+		{ IMMUNE_ASSASSINATE,        "Immune to Assassinate" },
+		{ IMMUNE_HEADSHOT,           "Immune to Headshot" },
+		{ IMMUNE_AGGRO_BOT,          "Immune to Bot Aggro" },
+		{ IMMUNE_DAMAGE_BOT,         "Immune to Bot Damage" },
+	};
+
+	return special_ability_map;
+}
+
+std::string EQ::constants::GetSpecialAbilityName(uint32 ability_id)
+{
+	const auto& a = EQ::constants::GetSpecialAbilityMap().find(ability_id);
+	if (a != EQ::constants::GetSpecialAbilityMap().end()) {
+		return a->second;
+	}
+
+	return std::string();
+}

common/emu_constants.h

@@ -350,6 +350,7 @@ namespace EQ
 		};
 
 		enum EmoteTypes : uint8 {
+			Say,
 			Emote,
 			Shout,
 			Proximity
@@ -358,8 +359,8 @@ namespace EQ
 		const char *GetStanceName(StanceType stance_type);
 		int ConvertStanceTypeToIndex(StanceType stance_type);
 
-		extern const std::map<int, std::string>& GetLanguageMap();
-		std::string GetLanguageName(int language_id);
+		extern const std::map<uint8, std::string>& GetLanguageMap();
+		std::string GetLanguageName(uint8 language_id);
 
 		extern const std::map<uint32, std::string>& GetLDoNThemeMap();
 		std::string GetLDoNThemeName(uint32 theme_id);
@@ -397,6 +398,12 @@ namespace EQ
 		extern const std::map<uint8, std::string>& GetEmoteTypeMap();
 		std::string GetEmoteTypeName(uint8 emote_type);
 
+		extern const std::map<uint32, std::string>& GetAppearanceTypeMap();
+		std::string GetAppearanceTypeName(uint32 animation_type);
+
+		extern const std::map<uint32, std::string>& GetSpecialAbilityMap();
+		std::string GetSpecialAbilityName(uint32 ability_id);
+
 		const int STANCE_TYPE_FIRST = stancePassive;
 		const int STANCE_TYPE_LAST = stanceBurnAE;
 		const int STANCE_TYPE_COUNT = stanceBurnAE;
@@ -593,6 +600,67 @@ enum class ApplySpellType {
 	Raid
 };
 
+enum {
+	SPECATK_SUMMON            = 1,
+	SPECATK_ENRAGE            = 2,
+	SPECATK_RAMPAGE           = 3,
+	SPECATK_AREA_RAMPAGE      = 4,
+	SPECATK_FLURRY            = 5,
+	SPECATK_TRIPLE            = 6,
+	SPECATK_QUAD              = 7,
+	SPECATK_INNATE_DW         = 8,
+	SPECATK_BANE              = 9,
+	SPECATK_MAGICAL           = 10,
+	SPECATK_RANGED_ATK        = 11,
+	UNSLOWABLE                = 12,
+	UNMEZABLE                 = 13,
+	UNCHARMABLE               = 14,
+	UNSTUNABLE                = 15,
+	UNSNAREABLE               = 16,
+	UNFEARABLE                = 17,
+	UNDISPELLABLE             = 18,
+	IMMUNE_MELEE              = 19,
+	IMMUNE_MAGIC              = 20,
+	IMMUNE_FLEEING            = 21,
+	IMMUNE_MELEE_EXCEPT_BANE  = 22,
+	IMMUNE_MELEE_NONMAGICAL   = 23,
+	IMMUNE_AGGRO              = 24,
+	IMMUNE_AGGRO_ON           = 25,
+	IMMUNE_CASTING_FROM_RANGE = 26,
+	IMMUNE_FEIGN_DEATH        = 27,
+	IMMUNE_TAUNT              = 28,
+	NPC_TUNNELVISION          = 29,
+	NPC_NO_BUFFHEAL_FRIENDS   = 30,
+	IMMUNE_PACIFY             = 31,
+	LEASH                     = 32,
+	TETHER                    = 33,
+	DESTRUCTIBLE_OBJECT       = 34,
+	NO_HARM_FROM_CLIENT       = 35,
+	ALWAYS_FLEE               = 36,
+	FLEE_PERCENT              = 37,
+	ALLOW_BENEFICIAL          = 38,
+	DISABLE_MELEE             = 39,
+	NPC_CHASE_DISTANCE        = 40,
+	ALLOW_TO_TANK             = 41,
+	IGNORE_ROOT_AGGRO_RULES   = 42,
+	CASTING_RESIST_DIFF       = 43,
+	COUNTER_AVOID_DAMAGE      = 44, // Modify by percent NPC's opponents chance to riposte, block, parry or dodge individually, or for all skills
+	PROX_AGGRO                = 45,
+	IMMUNE_RANGED_ATTACKS     = 46,
+	IMMUNE_DAMAGE_CLIENT      = 47,
+	IMMUNE_DAMAGE_NPC         = 48,
+	IMMUNE_AGGRO_CLIENT       = 49,
+	IMMUNE_AGGRO_NPC          = 50,
+	MODIFY_AVOID_DAMAGE       = 51, // Modify by percent the NPCs chance to riposte, block, parry or dodge individually, or for all skills
+	IMMUNE_FADING_MEMORIES    = 52,
+	IMMUNE_OPEN               = 53,
+	IMMUNE_ASSASSINATE        = 54,
+	IMMUNE_HEADSHOT           = 55,
+	IMMUNE_AGGRO_BOT          = 56,
+	IMMUNE_DAMAGE_BOT         = 57,
+	MAX_SPECIAL_ATTACK        = 58
+};
+
 
 namespace HeroicBonusBucket
 {

common/emu_opcodes.h

@@ -45,6 +45,7 @@ typedef enum { //EQEmu internal opcodes list
 	_maxEmuOpcode
 } EmuOpcode;
 
+constexpr int format_as(EmuOpcode opcode) { return static_cast<int>(opcode); }
 extern const char *OpcodeNames[_maxEmuOpcode+1];
 
 #endif

common/emu_oplist.h

@@ -228,6 +228,7 @@ N(OP_GuildBank),
 N(OP_GuildBankItemList),
 N(OP_GuildCreate),
 N(OP_GuildDelete),
+N(OP_GuildDeleteGuild),
 N(OP_GuildDemote),
 N(OP_GuildInvite),
 N(OP_GuildInviteAccept),
@@ -239,15 +240,33 @@ N(OP_GuildManageStatus),
 N(OP_GuildMemberLevelUpdate),
 N(OP_GuildMemberList),
 N(OP_GuildMemberUpdate),
+N(OP_GuildMemberLevel),
+N(OP_GuildMemberRankAltBanker),
+N(OP_GuildMemberPublicNote),
+N(OP_GuildMemberAdd),
+N(OP_GuildMemberRename),
+N(OP_GuildMemberDelete),
+N(OP_GuildMemberDetails),
+N(OP_GuildRenameGuild),
 N(OP_GuildMOTD),
 N(OP_GuildPeace),
 N(OP_GuildPromote),
 N(OP_GuildPublicNote),
 N(OP_GuildRemove),
+N(OP_GuildSelectTribute),
+N(OP_GuildModifyBenefits),
+N(OP_GuildTributeToggleReq),
+N(OP_GuildTributeToggleReply),
+N(OP_GuildOptInOut),
+N(OP_GuildSaveActiveTributes),
+N(OP_GuildSendActiveTributes),
+N(OP_GuildTributeFavorAndTimer),
 N(OP_GuildsList),
 N(OP_GuildStatus),
 N(OP_GuildTributeInfo),
-N(OP_GuildUpdateURLAndChannel),
+N(OP_GuildUpdate),
+N(OP_GuildTributeDonateItem),
+N(OP_GuildTributeDonatePlat),
 N(OP_GuildWar),
 N(OP_Heartbeat),
 N(OP_Hide),
@@ -425,6 +444,7 @@ N(OP_ReqClientSpawn),
 N(OP_ReqNewZone),
 N(OP_RequestClientZoneChange),
 N(OP_RequestDuel),
+N(OP_RequestGuildTributes),
 N(OP_RequestKnowledgeBase),
 N(OP_RequestTitles),
 N(OP_RespawnWindow),

common/eq_constants.h

@@ -23,61 +23,59 @@
 #include "skills.h"
 #include "types.h"
 
+namespace AppearanceType {
+	constexpr uint32 Die                   = 0; // Causes the client to keel over and zone to bind point (default action)
+	constexpr uint32 WhoLevel              = 1; // Level that shows up on /who
+	constexpr uint32 MaxHealth             = 2;
+	constexpr uint32 Invisibility          = 3; // 0 = Visible, 1 = Invisible
+	constexpr uint32 PVP                   = 4; // 0 = Non-PVP, 1 = PVP
+	constexpr uint32 Light                 = 5; // Light type emitted by player (lightstone, shiny shield)
+	constexpr uint32 Animation             = 14; // 100 = Standing, 102 = Freeze, 105 = Looting, 110 = Sitting, 111 = Crouching, 115 = Lying
+	constexpr uint32 Sneak                 = 15; // 0 = Normal, 1 = Sneaking
+	constexpr uint32 SpawnID               = 16; // Server -> Client, sets player spawn ID
+	constexpr uint32 Health                = 17; // Client->Server, my HP has changed (like regen tic)
+	constexpr uint32 Linkdead              = 18; // 0 = Normal, 1 = Linkdead
+	constexpr uint32 FlyMode               = 19; // 0 = Off, 1 = Flying, 2 = Levitating, 3 = Water, 4 = Floating, 5 = Levitating while Running
+	constexpr uint32 GM                    = 20; // 0 = Non-GM, 1 = GM
+	constexpr uint32 Anonymous             = 21; // 0 = Non-Anonymous, 1 = Anonymous, 2 = Roleplaying
+	constexpr uint32 GuildID               = 22;
+	constexpr uint32 GuildRank             = 23;
+	constexpr uint32 AFK                   = 24; // 0 = Non-AFK, 1 = AFK
+	constexpr uint32 Pet                   = 25; // Parameter is Entity ID of owner, or 0 for when charm breaks
+	constexpr uint32 Summoned              = 27;
+	constexpr uint32 Split                 = 28; // 0 = No Split, 1 = Auto Split
+	constexpr uint32 Size                  = 29; // Spawn's Size
+	constexpr uint32 SetType               = 30; // 0 = PC, 1 = NPC, 2 = Corpse
+	constexpr uint32 NPCName               = 31; // Change PC name color to NPC name color
+	constexpr uint32 AARank                = 32; // AA Rank Title ID, title in /who?
+	constexpr uint32 CancelSneakHide       = 33; // Turns off Hide and Sneak
+	constexpr uint32 AreaHealthRegen       = 35; // Guild Hall Regeneration Pool sets to value * 0.001
+	constexpr uint32 AreaManaRegen         = 36; // Guild Hall Regeneration Pool sets to value * 0.001
+	constexpr uint32 AreaEnduranceRegen    = 37; // Guild Hall Regeneration Pool sets to value * 0.001
+	constexpr uint32 FreezeBeneficialBuffs = 38; // Freezes beneficial buff timers for PCs
+	constexpr uint32 NPCTintIndex          = 39;
+	constexpr uint32 GroupAutoConsent      = 40; // Auto Consent Group
+	constexpr uint32 RaidAutoConsent       = 41; // Auto Consent Raid
+	constexpr uint32 GuildAutoConsent      = 42; // Auto Consent Guild
+	constexpr uint32 ShowHelm              = 43; // 0 = Hide, 1 = Show
+	constexpr uint32 DamageState           = 44; // The damage state of a destructible object (0 through 10) plays sound IDs, most only have 2 or 4 states though
+	constexpr uint32 EQPlayers             = 45; // EQ Players Update
+	constexpr uint32 FindBits              = 46; // Set Find Bits?
+	constexpr uint32 TextureType           = 48; // Texture Type?
+	constexpr uint32 FacePick              = 49; // Turns off face pick window?
+	constexpr uint32 AntiCheat             = 51; // Sent by the client randomly telling the server how long since last action has occurred
+	constexpr uint32 GuildShow             = 52;
+	constexpr uint32 OfflineMode           = 53; // Offline Mode
+}
 
-//SpawnAppearance types: (compared two clients for server-originating types: SoF & RoF2)
-#define AT_Die 0			// this causes the client to keel over and zone to bind point (default action)
-#define AT_WhoLevel 1		// the level that shows up on /who
-#define AT_HPMax 2			// idk
-#define AT_Invis 3			// 0 = visible, 1 = invisible
-#define AT_PVP 4			// 0 = blue, 1 = pvp (red)
-#define AT_Light 5			// light type emitted by player (lightstone, shiny shield)
-#define AT_Anim 14			// 100=standing, 110=sitting, 111=ducking, 115=feigned, 105=looting
-#define AT_Sneak 15			// 0 = normal, 1 = sneaking
-#define AT_SpawnID 16		// server to client, sets player spawn id
-#define AT_HP 17			// Client->Server, my HP has changed (like regen tic)
-#define AT_Linkdead 18		// 0 = normal, 1 = linkdead
-#define AT_Levitate 19		// 0=off, 1=flymode, 2=levitate max 5, see GravityBehavior enum
-#define AT_GM 20			// 0 = normal, 1 = GM - all odd numbers seem to make it GM
-#define AT_Anon 21			// 0 = normal, 1 = anon, 2 = roleplay
-#define AT_GuildID 22
-#define AT_GuildRank 23		// 0=member, 1=officer, 2=leader
-#define AT_AFK 24			// 0 = normal, 1 = afk
-#define AT_Pet 25			// Param is EntityID of owner, or 0 for when charm breaks
-#define AT_Summoned 27		// Unsure
-#define AT_Split 28			// 0 = normal, 1 = autosplit on (not showing in SoF+) (client-to-server only)
-#define AT_Size 29			// spawn's size (present: SoF, absent: RoF2)
-#define AT_SetType 30		// 0 = PC, 1 = NPC, 2 <= = corpse
-#define AT_NPCName 31		// change PC's name's color to NPC color 0 = normal, 1 = npc name, Trader on RoF2?
-#define AT_AARank 32		// AA Rank Title ID thingy, does is this the title in /who?
-#define AT_CancelSneakHide 33	// Turns off Hide and Sneak
-//#define AT_34 34			// unknown (present: SoF, absent: RoF2)
-#define AT_AreaHPRegen 35	// guild hall regen pool sets to value * 0.001
-#define AT_AreaManaRegen 36	// guild hall regen pool sets to value * 0.001
-#define AT_AreaEndRegen 37	// guild hall regen pool sets to value * 0.001
-#define AT_FreezeBuffs 38	// Freezes beneficial buff timers
-#define AT_NpcTintIndex 39	// not 100% sure
-#define AT_GroupConsent 40	// auto consent group
-#define AT_RaidConsent 41	// auto consent raid
-#define AT_GuildConsent 42	// auto consent guild
-#define AT_ShowHelm 43		// 0 = hide graphic, 1 = show graphic
-#define AT_DamageState 44	// The damage state of a destructible object (0 through 10) plays soundids most only have 2 or 4 states though
-#define AT_EQPlayers 45		// /eqplayersupdate
-#define AT_FindBits 46		// set FindBits, whatever those are!
-#define AT_TextureType 48	// TextureType
-#define AT_FacePick 49		// Turns off face pick window? maybe ...
-#define AT_AntiCheat 51		// sent by the client randomly telling the server how long since last action has occured
-#define AT_GuildShow 52		// this is what MQ2 call sit, not sure
-#define AT_Offline 53		// Offline mode
-
-//#define AT_Trader 300		// Bazaar Trader Mode (not present in SoF or RoF2)
-
-// animations for AT_Anim
-#define ANIM_FREEZE	    102
-#define	ANIM_STAND		0x64
-#define	ANIM_SIT		0x6e
-#define	ANIM_CROUCH		0x6f
-#define	ANIM_DEATH		0x73
-#define ANIM_LOOT		0x69
+namespace Animation {
+	constexpr uint32 Standing  = 100;
+	constexpr uint32 Freeze    = 102;
+	constexpr uint32 Looting   = 105;
+	constexpr uint32 Sitting   = 110;
+	constexpr uint32 Crouching = 111;
+	constexpr uint32 Lying     = 115;
+}
 
 constexpr int16 RECAST_TYPE_UNLINKED_ITEM = -1;
 
@@ -686,6 +684,53 @@ namespace Zones {
 	constexpr uint16 APPRENTICE = 999; // Designer Apprentice
 }
 
+namespace Language {
+	constexpr uint8 CommonTongue  = 0;
+	constexpr uint8 Barbarian     = 1;
+	constexpr uint8 Erudian       = 2;
+	constexpr uint8 Elvish        = 3;
+	constexpr uint8 DarkElvish    = 4;
+	constexpr uint8 Dwarvish      = 5;
+	constexpr uint8 Troll         = 6;
+	constexpr uint8 Ogre          = 7;
+	constexpr uint8 Gnomish       = 8;
+	constexpr uint8 Halfling      = 9;
+	constexpr uint8 ThievesCant   = 10;
+	constexpr uint8 OldErudian    = 11;
+	constexpr uint8 ElderElvish   = 12;
+	constexpr uint8 Froglok       = 13;
+	constexpr uint8 Goblin        = 14;
+	constexpr uint8 Gnoll         = 15;
+	constexpr uint8 CombineTongue = 16;
+	constexpr uint8 ElderTeirDal  = 17;
+	constexpr uint8 Lizardman     = 18;
+	constexpr uint8 Orcish        = 19;
+	constexpr uint8 Faerie        = 20;
+	constexpr uint8 Dragon        = 21;
+	constexpr uint8 ElderDragon   = 22;
+	constexpr uint8 DarkSpeech    = 23;
+	constexpr uint8 VahShir       = 24;
+	constexpr uint8 Alaran        = 25;
+	constexpr uint8 Hadal         = 26;
+	constexpr uint8 Unknown27     = 27;
+
+	constexpr uint8 MaxValue = 100;
+}
+namespace PetInfoType {
+	constexpr int Current   = 0;
+	constexpr int Suspended = 1;
+}
+
+namespace BuffEffectType {
+	constexpr uint8 None        = 0;
+	constexpr uint8 Buff        = 2;
+	constexpr uint8 InverseBuff = 4;
+}
+
+namespace AlternateCurrencyMode {
+	constexpr uint32 Update   = 7;
+	constexpr uint32 Populate = 8;
+}
 
 typedef enum {
 	FilterNone = 0,
@@ -1075,4 +1120,15 @@ enum MoneySubtypes
 	SharedBank // Platinum Only
 };
 
+namespace RaidLootType {
+	constexpr uint32 LeaderOnly                = 1;
+	constexpr uint32 LeaderAndGroupLeadersOnly = 2;
+	constexpr uint32 LeaderSelected            = 3;
+	constexpr uint32 EntireRaid                = 4;
+}
+
+namespace LeadershipAbilitySlot {
+	constexpr uint16 HealthOfTargetsTarget = 14;
+}
+
 #endif /*COMMON_EQ_CONSTANTS_H*/

common/eq_packet_structs.h

@@ -124,6 +124,17 @@ struct LDoNTrapTemplate
 	uint8 locked;
 };
 
+enum CrystalReclaimTypes
+{
+	Ebon = 5,
+	Radiant = 4,
+};
+
+namespace ItemStackSizeConstraint {
+	constexpr int16 Minimum = 1;
+	constexpr int16 Maximum = 1000;
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 
 
@@ -308,6 +319,7 @@ union
 	uint32 DestructibleUnk9;
 	bool targetable_with_hotkey;
 	bool show_name;
+	bool guild_show;
 };
 
 struct PlayerState_Struct {
@@ -386,7 +398,7 @@ struct NewZone_Struct {
 /*0724*/	uint32 underworld_teleport_index; // > 0 teleports w/ zone point index, invalid succors, if this value is 0, it prevents you from running off edges that would end up underworld
 /*0728*/	uint32 lava_damage; // Seen 50
 /*0732*/	uint32 min_lava_damage; // Seen 10
-/*0736*/
+/*0736*/	float safe_heading;
 };
 
 /*
@@ -625,6 +637,12 @@ struct ConsentResponse_Struct {
 	char zonename[32];
 };
 
+struct NameApproval_Struct {
+	char name[64];
+	uint32 race_id;
+	uint32 class_id;
+};
+
 /*
 ** Name Generator Struct
 ** Length: 72 bytes
@@ -1665,6 +1683,68 @@ struct GuildUpdate_Struct {
 	GuildsListEntry_Struct entry;
 };
 
+struct GuildMemberAdd_Struct {
+	/*000*/ uint32 guild_id;
+	/*004*/ uint32 unknown04;
+	/*008*/ uint32 unknown08;
+	/*012*/ uint32 unknown12;
+	/*016*/ uint32 level;
+	/*020*/ uint32 class_;
+	/*024*/ uint32 rank_;
+	/*028*/ uint32 guild_show;
+	/*032*/ uint32 zone_id;
+	/*036*/ uint32 last_on;
+	/*040*/ char   player_name[64];
+};
+
+struct GuildMemberLevel_Struct {
+	/*000*/ uint32 guild_id;
+	/*004*/ char   player_name[64];
+	/*068*/ uint32 level;
+};
+
+struct GuildMemberRank_Struct {
+	/*000*/ uint32 guild_id;
+	/*004*/ uint32 rank_;
+	/*008*/ char   player_name[64];
+	/*072*/ uint32 alt_banker; //Banker/Alt bit 00 - none 10 - Alt 11 - Alt and Banker 01 - Banker.  Banker not functional for RoF2+
+	/*076*/ uint32 offline;
+};
+
+struct GuildMemberPublicNote_Struct {
+	/*000*/ uint32 guild_id;
+	/*004*/ char   player_name[64];
+	/*068*/ char   public_note[256]; //RoF2 256
+};
+
+struct GuildDelete_Struct {
+	/*000*/ uint32 guild_id;
+};
+
+struct GuildRenameGuild_Struct {
+	/*000*/ uint32 guild_id;
+	/*004*/ char   new_guild_name[64];
+};
+
+struct GuildRenameMember_Struct {
+	/*000*/ uint32 guild_id;
+	/*004*/ char   player_name[64];
+	/*068*/ char   new_player_name[64];
+};
+
+struct GuildMemberDetails_Struct {
+	/*000*/ uint32 guild_id;
+	/*004*/ char   player_name[64];
+	/*068*/ uint32 zone_id;
+	/*072*/ uint32 last_on;
+	/*076*/ uint32 offline_mode; //1 Offline
+};
+
+struct GuildMemberDelete_Struct {
+	/*000*/ uint32 guild_id;
+	/*004*/ char   player_name[64];
+};
+
 /*
 ** Money Loot
 ** Length: 22 Bytes
@@ -1713,10 +1793,10 @@ struct GuildJoin_Struct{
 /*092*/
 };
 struct GuildInviteAccept_Struct {
-	char inviter[64];
-	char newmember[64];
+	char   inviter[64];
+	char   new_member[64];
 	uint32 response;
-	uint32 guildeqid;
+	uint32 guild_id;
 };
 struct GuildManageRemove_Struct {
 	uint32 guildeqid;
@@ -1748,6 +1828,14 @@ struct PopupResponse_Struct {
 /*0004*/	uint32	popupid;
 };
 
+enum GuildInformationActions
+{
+    GuildUpdateURL          = 0,
+    GuildUpdateChannel      = 1,
+    GuildUpdateRanks        = 4,
+    GuildUpdatePermissions  = 5
+};
+
 struct GuildManageBanker_Struct {
 	uint32 unknown0;
 	char myname[64];
@@ -1761,9 +1849,9 @@ struct GuildSetRank_Struct
 {
 /*00*/	uint32	Unknown00;
 /*04*/	uint32	Unknown04;
-/*08*/	uint32	Rank;
-/*12*/	char	MemberName[64];
-/*76*/	uint32	Banker;
+/*08*/	uint32	rank;
+/*12*/	char	member_name[64];
+/*76*/	uint32	banker;
 /*80*/
 };
 
@@ -3321,6 +3409,7 @@ struct Internal_GuildMemberEntry_Struct {
 //	char	public_note[1];				//variable length.
 	uint16	zoneinstance;				//network byte order
 	uint16	zone_id;					//network byte order
+	uint32  online;
 };
 
 struct Internal_GuildMembers_Struct {	//just for display purposes, this is not actually used in the message encoding.
@@ -3347,7 +3436,42 @@ struct GuildUpdate_PublicNote{
 	uint32	unknown0;
 	char	name[64];
 	char	target[64];
-	char	note[1]; //variable length.
+	char	note[256];
+};
+
+struct GuildUpdateURLAndChannelStruct {
+	char text[512];
+};
+
+struct GuildUpdatePermissionsStruct {
+	uint32	rank;				// the rank that is being changed
+	uint32	function_id;		// the id of the guild function
+	uint32	value;				// 1 is on, 0 is off
+
+};
+
+struct GuildUpdateRankNamesStruct {
+	uint32	rank;				// the rank that is being updated
+	char	rank_name[76];		// the rank name
+};
+
+struct GuildUpdateUCPStruct {
+	uint32	action;				// 0 and 1 use url and channel payload.  5 uses permissions payload
+	char	unknown[76];
+	union {
+		GuildUpdateURLAndChannelStruct  url_channel;
+		GuildUpdatePermissionsStruct    permissions;
+		GuildUpdateRankNamesStruct      rank_name;
+	}payload;
+};
+
+struct GuildPermission_Struct
+{
+	uint32	Action;				// 5 = Update function permission
+	char	Unknown0004[76];	// not used
+	uint32	rank;				// the rank that is being changed
+	uint32	function_id;		// the id of the guild function
+	uint32	value;				// 1 is on, 0 is off
 };
 
 struct GuildUpdateURLAndChannel_Struct
@@ -3366,7 +3490,7 @@ struct GuildUpdateURLAndChannel_Struct
 //The client sends this struct on changing a guild rank. The server sends each rank in 32 or less packets upon zonein if you are in a guild.
 struct GuildUpdateRanks_Struct
 {
-/*0000*/	uint32	Action;	// 0 = Update URL, 1 = Update Channel, 5 = RoF Ranks
+/*0000*/	uint32	Action;	// 0 = Update URL, 1 = Update Channel, 4 = Ranks 5 = Permissions
 /*0004*/	uint32	Unknown0004; //Seen 00 00 00 00
 /*0008*/	uint32	Unknown0008; //Seen 96 29 00 00
 /*0008*/	char	Unknown0012[64]; //Seen "CharacterName"
@@ -3388,6 +3512,7 @@ struct GuildStatus_Struct
 struct GuildDemoteStruct{
 	char	name[64];
 	char	target[64];
+	uint32	rank;
 };
 
 struct GuildRemoveStruct{
@@ -3397,9 +3522,9 @@ struct GuildRemoveStruct{
 	uint32	leaderstatus; //?
 };
 
-struct GuildMakeLeader{
-	char	name[64];
-	char	target[64];
+struct GuildMakeLeader_Struct{
+	char	requestor[64];
+	char	new_leader[64];
 };
 
 struct BugReport_Struct {
@@ -3439,20 +3564,23 @@ struct Make_Pet_Struct { //Simple struct for getting pet info
 	uint32 min_dmg;
 	uint32 max_dmg;
 };
-struct Ground_Spawn{
-	float max_x;
-	float max_y;
-	float min_x;
-	float min_y;
-	float max_z;
-	float heading;
-	char name[20];
-	uint32 item;
-	uint32 max_allowed;
-	uint32 respawntimer;
+
+struct GroundSpawn {
+	float       max_x         = 0.0f;
+	float       max_y         = 0.0f;
+	float       min_x         = 0.0f;
+	float       min_y         = 0.0f;
+	float       max_z         = 0.0f;
+	float       heading       = 0.0f;
+	std::string name          = std::string();
+	uint32      item_id       = 0;
+	uint32      max_allowed   = 1;
+	uint32      respawn_timer = 1;
+	bool        fix_z         = true;
 };
-struct Ground_Spawns {
-	struct Ground_Spawn spawn[50]; //Assigned max number to allow
+
+struct GroundSpawns {
+	struct GroundSpawn spawn[50]; //Assigned max number to allow
 };
 
 //struct PetitionBug_Struct{
@@ -3490,66 +3618,193 @@ struct ZoneInSendName_Struct2 {
 static const uint32 MAX_TRIBUTE_TIERS = 10;
 
 struct StartTribute_Struct {
-	uint32	client_id;
-	uint32	tribute_master_id;
-	uint32	response;
+	uint32 client_id;
+	uint32 tribute_master_id;
+	uint32 response;
 };
 
 struct TributeLevel_Struct {
-	uint32	level;	//backwards byte order!
-	uint32	tribute_item_id;	//backwards byte order!
-	uint32	cost;	//backwards byte order!
+	uint32 level;              //backwards byte order!
+	uint32 tribute_item_id;    //backwards byte order!
+	uint32 cost;               //backwards byte order!
 };
 
 struct TributeAbility_Struct {
-	uint32	tribute_id;	//backwards byte order!
-	uint32	tier_count;	//backwards byte order!
+	uint32              tribute_id;    //backwards byte order!
+	uint32              tier_count;    //backwards byte order!
 	TributeLevel_Struct tiers[MAX_TRIBUTE_TIERS];
-	char	name[0];
-};
-
-struct GuildTributeAbility_Struct {
-	uint32	guild_id;
-	TributeAbility_Struct ability;
+	char                name[0];
 };
 
 struct SelectTributeReq_Struct {
-	uint32	client_id;	//? maybe action ID?
-	uint32	tribute_id;
-	uint32	unknown8;	//seen E3 00 00 00
+	uint32 client_id;    //? maybe action ID?
+	uint32 tribute_id;
+	uint32 unknown8;    //seen E3 00 00 00
+};
+
+struct GuildTributeAbilityDetail_Struct {
+	uint32              tribute_id;    //backwards byte order!
+	uint32              tier_count;    //backwards byte order!
+	TributeLevel_Struct tiers[MAX_TRIBUTE_TIERS];
+	uint32              unknown132;
+	char                name[0];
+};
+
+struct GuildTributeAbility_Struct {
+	uint32                           guild_id;
+	GuildTributeAbilityDetail_Struct ability;
+};
+
+struct GuildTributeSelectReq_Struct {
+	uint32 tribute_id;
+	uint32 tier;
+	uint32 tribute_id2;
+	uint32 unknown12;    //seen A7 01 00 00
+};
+
+struct GuildTributeSelectReply_Struct {
+	uint32 tribute_id;
+	uint32 tier;
+	uint32 tribute_id2;
+	char   description;
+};
+
+struct GuildTributeModifyBenefits_Struct {
+/*000*/uint32 command;
+/*004*/uint32 data;
+/*008*/char   unknown8[12];
+/*020*/uint32 tribute_master_id;
+/*024*/uint32 tribute_id_1;
+/*028*/uint32 tribute_id_2;
+/*032*/uint32 tribute_id_1_tier;
+/*036*/uint32 tribute_id_2_tier;
+/*040*/char   unknown[40];
+};
+
+struct GuildTributeOptInOutReq_Struct {
+/*000*/uint32 guild_id;
+/*004*/uint32 tribute_toggle;
+/*008*/char   player[64];
+/*072*/uint32 command;
+/*076*/uint32 tribute_master_id;
+};
+
+struct GuildTributeOptInOutReply_Struct {
+/*000*/uint32 guild_id;
+/*004*/char   player_name[64];
+/*068*/uint32 tribute_toggle;//			0 off 1 on
+/*072*/uint32 tribute_trophy_toggle;// 	0 off 1 on		not yet implemented
+/*076*/uint32 no_donations;
+/*080*/uint32 time;
+/*084*/uint32 command;
+};
+
+struct GuildTributeSaveActive_Struct {
+/*000*/ uint32    command;
+/*004*/ char      unknown04[16];
+/*020*/ uint32    master_tribute_id;
+/*024*/ uint32    tribute_id_1;
+/*028*/ uint32    tribute_id_2;
+/*032*/ uint32    tribute_1_tier;
+/*036*/ uint32    tribute_2_tier;
+/*040*/ char      unknown40[8];
+};
+
+struct GuildTributeFavorTimer_Struct {
+/*000*/ uint32 guild_id;
+/*004*/ uint32 guild_favor;
+/*008*/ uint32 tribute_timer;
+/*012*/ uint32 trophy_timer;
+};
+
+struct GuildTributeSendActive_Struct {
+/*000*/ uint32 not_used;
+/*004*/ uint32 guild_favor;
+/*008*/ uint32 tribute_timer;
+/*012*/ uint32 tribute_enabled;
+/*016*/ char   unknown16[8];
+/*024*/ uint32 tribute_id_1;
+/*028*/ uint32 tribute_id_2;
+/*032*/ uint32 tribute_id_1_tier;
+/*036*/ uint32 tribute_id_2_tier;
+};
+
+struct GuildTributeToggleReq_Struct {
+/*000*/ uint32 command;
+/*004*/ uint32 unknown4;
+/*008*/ uint32 unknown8;
+};
+
+struct GuildTributeDonateItemRequest_Struct {
+/*000*/ uint32    type;
+/*004*/ uint16    slot;
+/*006*/ uint16    sub_index;
+/*008*/ uint16    aug_index;
+/*010*/ uint16    unknown10;
+/*012*/ uint32    quantity;
+/*016*/ uint32    tribute_master_id;
+/*020*/ uint32    unknown20;
+/*024*/ uint32    guild_id;
+/*028*/ uint32    unknown28;
+/*032*/ uint32    unknown32;
+};
+
+struct GuildTributeDonateItemReply_Struct {
+/*000*/ uint32 type;
+/*004*/ uint16 slot;
+/*006*/ uint16 sub_index;
+/*008*/ uint16 aug_index;
+/*010*/ uint16 unknown10;
+/*012*/ uint32 quantity;
+/*016*/ uint32 unknown20;
+/*020*/ uint32 favor;
+};
+
+struct GuildTributeDonatePlatRequest_Struct {
+/*000*/ uint32 quantity;
+/*004*/ uint32 tribute_master_id;
+/*008*/ uint32 unknown08;
+/*012*/ uint32 guild_id;
+/*016*/ uint32 unknown16;
+};
+
+struct GuildTributeDonatePlatReply_Struct {
+	/*000*/ uint32 quantity;
+	/*004*/ uint32 unknown4;
+	/*008*/ uint32 favor;
 };
 
 struct SelectTributeReply_Struct {
-	uint32	client_id;	//echoed from request.
-	uint32	tribute_id;
-	char		desc[0];
+	uint32 client_id;    //echoed from request.
+	uint32 tribute_id;
+	char   description[0];
 };
 
 struct TributeInfo_Struct {
-	uint32	active;		//0 == inactive, 1 == active
-	uint32	tributes[EQ::invtype::TRIBUTE_SIZE];	//-1 == NONE
-	uint32	tiers[EQ::invtype::TRIBUTE_SIZE];		//all 00's
-	uint32	tribute_master_id;
+	uint32 active;        //0 == inactive, 1 == active
+	uint32 tributes[EQ::invtype::TRIBUTE_SIZE];    //-1 == NONE
+	uint32 tiers[EQ::invtype::TRIBUTE_SIZE];        //all 00's
+	uint32 tribute_master_id;
 };
 
 struct TributeItem_Struct {
-	uint32	slot;
-	uint32	quantity;
-	uint32	tribute_master_id;
-	int32	tribute_points;
+	uint32 slot;
+	uint32 quantity;
+	uint32 tribute_master_id;
+	int32  tribute_points;
 };
 
 struct TributePoint_Struct {
-	int32	tribute_points;
-	uint32	unknown04;
-	int32	career_tribute_points;
-	uint32	unknown12;
+	int32  tribute_points;
+	uint32 unknown04;
+	int32  career_tribute_points;
+	uint32 unknown12;
 };
 
 struct TributeMoney_Struct {
-	uint32	platinum;
-	uint32	tribute_master_id;
-	int32	tribute_points;
+	uint32 platinum;
+	uint32 tribute_master_id;
+	int32  tribute_points;
 };
 
 
@@ -5128,8 +5383,6 @@ struct GroupMakeLeader_Struct
 //ex for a blank crowns window you would send:
 //999999|1|999999|0
 //any items come after in much the same way adventure merchant items do except there is no theme included
-#define ALT_CURRENCY_OP_POPULATE 8
-#define ALT_CURRENCY_OP_UPDATE 7
 
 //Server -> Client
 //Populates the initial Alternate Currency Window
@@ -5540,28 +5793,6 @@ struct MercenaryMerchantResponse_Struct {
 /*0004*/
 };
 
-struct ServerLootItem_Struct {
-	uint32	item_id;	  // uint32	item_id;
-	int16  equip_slot;	  // int16	equip_slot;
-	uint16 charges;	  // uint8	charges;
-	uint16 lootslot;	  // uint16	lootslot;
-	uint32 aug_1;		  // uint32	aug_1;
-	uint32 aug_2;		  // uint32	aug_2;
-	uint32 aug_3;		  // uint32	aug_3;
-	uint32 aug_4;		  // uint32	aug_4;
-	uint32 aug_5;		  // uint32	aug_5;
-	uint32 aug_6;		  // uint32	aug_5;
-	bool attuned;
-	std::string custom_data;
-	uint32 ornamenticon {};
-	uint32 ornamentidfile {};
-	uint32 ornament_hero_model {};
-	uint16 trivial_min_level;
-	uint16 trivial_max_level;
-	uint16 npc_min_level;
-	uint16 npc_max_level;
-};
-
 //Found in client near a ref to the string:
 //"Got a broadcast message for ... %s ...\n"
 struct ClientMarqueeMessage_Struct {
@@ -5580,9 +5811,6 @@ struct ClientMarqueeMessage_Struct {
 
 };
 
-typedef std::list<ServerLootItem_Struct*> ItemList;
-
-
 struct fling_struct {
 /* 00 */ uint32 collision; // 0 collision is off, anything else it's on
 /* 04 */ int32 travel_time; // ms -- UF we need to calc this, RoF+ -1 auto calcs

common/eqemu_config.cpp

@@ -20,9 +20,12 @@
 #include "eqemu_config.h"
 #include "misc_functions.h"
 #include "strings.h"
+#include "eqemu_logsys.h"
+#include "json/json.hpp"
 
 #include <iostream>
 #include <sstream>
+#include <filesystem>
 
 std::string EQEmuConfig::ConfigFile = "eqemu_config.json";
 EQEmuConfig *EQEmuConfig::_config = nullptr;
@@ -111,13 +114,12 @@ void EQEmuConfig::parse_config()
 		DisableConfigChecks = true;
 	}
 
-	/**
-	 * UCS
-	 */
-	ChatHost = _root["server"]["chatserver"].get("host", "eqchat.eqemulator.net").asString();
-	ChatPort = Strings::ToUnsignedInt(_root["server"]["chatserver"].get("port", "7778").asString());
-	MailHost = _root["server"]["mailserver"].get("host", "eqmail.eqemulator.net").asString();
-	MailPort = Strings::ToUnsignedInt(_root["server"]["mailserver"].get("port", "7778").asString());
+
+
+	CheckUcsConfigConversion();
+
+	m_ucs_host = _root["server"]["ucs"].get("host", "eqchat.eqemulator.net").asString();
+	m_ucs_port = Strings::ToUnsignedInt(_root["server"]["ucs"].get("port", "7778").asString());
 
 	/**
 	 * Database
@@ -246,16 +248,16 @@ std::string EQEmuConfig::GetByName(const std::string &var_name) const
 		return (WorldHTTPEnabled ? "true" : "false");
 	}
 	if (var_name == "ChatHost") {
-		return (ChatHost);
+		return (m_ucs_host);
 	}
 	if (var_name == "ChatPort") {
-		return (itoa(ChatPort));
+		return (itoa(m_ucs_port));
 	}
 	if (var_name == "MailHost") {
-		return (MailHost);
+		return (m_ucs_host);
 	}
 	if (var_name == "MailPort") {
-		return (itoa(MailPort));
+		return (itoa(m_ucs_port));
 	}
 	if (var_name == "DatabaseHost") {
 		return (DatabaseHost);
@@ -362,10 +364,8 @@ void EQEmuConfig::Dump() const
 	std::cout << "WorldHTTPPort = " << WorldHTTPPort << std::endl;
 	std::cout << "WorldHTTPMimeFile = " << WorldHTTPMimeFile << std::endl;
 	std::cout << "WorldHTTPEnabled = " << WorldHTTPEnabled << std::endl;
-	std::cout << "ChatHost = " << ChatHost << std::endl;
-	std::cout << "ChatPort = " << ChatPort << std::endl;
-	std::cout << "MailHost = " << MailHost << std::endl;
-	std::cout << "MailPort = " << MailPort << std::endl;
+	std::cout << "UCSHost = " << m_ucs_host << std::endl;
+	std::cout << "UCSPort = " << m_ucs_port << std::endl;
 	std::cout << "DatabaseHost = " << DatabaseHost << std::endl;
 	std::cout << "DatabaseUsername = " << DatabaseUsername << std::endl;
 	std::cout << "DatabasePassword = " << DatabasePassword << std::endl;
@@ -392,3 +392,98 @@ void EQEmuConfig::Dump() const
 	std::cout << "DefaultStatus = " << (int) DefaultStatus << std::endl;
 //	std::cout << "DynamicCount = " << DynamicCount << std::endl;
 }
+
+const std::string &EQEmuConfig::GetUCSHost() const
+{
+	return m_ucs_host;
+}
+
+uint16 EQEmuConfig::GetUCSPort() const
+{
+	return m_ucs_port;
+}
+
+void EQEmuConfig::CheckUcsConfigConversion()
+{
+	std::string chat_host = _root["server"]["chatserver"].get("host", "").asString();
+	uint32      chat_port = Strings::ToUnsignedInt(_root["server"]["chatserver"].get("port", "0").asString());
+	std::string mail_host = _root["server"]["mailserver"].get("host", "").asString();
+	uint32      mail_port = Strings::ToUnsignedInt(_root["server"]["mailserver"].get("port", "0").asString());
+	std::string ucs_host  = _root["server"]["ucs"].get("host", "").asString();
+
+	// automatic ucs legacy configuration migration
+	// if old configuration values are set, let's backup the existing configuration
+	// and migrate to to use the new fields and write the new config
+	if ((!chat_host.empty() || !mail_host.empty()) && ucs_host.empty()) {
+		LogInfo("Migrating old [eqemu_config] UCS configuration to new configuration");
+
+		std::string config_file_path = std::filesystem::path{
+			path.GetServerPath() + "/eqemu_config.json"
+		}.string();
+
+		std::string config_file_bak_path = std::filesystem::path{
+			path.GetServerPath() + "/eqemu_config.ucs-migrate-json.bak"
+		}.string();
+
+		// copy eqemu_config.json to eqemu_config.json.bak
+		std::ifstream src(config_file_path, std::ios::binary);
+		std::ofstream dst(config_file_bak_path, std::ios::binary);
+		dst << src.rdbuf();
+		src.close();
+
+		LogInfo("Old configuration backed up to [{}]", config_file_bak_path);
+
+		// read eqemu_config.json, transplant new fields and write to eqemu_config.json
+		Json::Value   root;
+		Json::Reader  reader;
+		std::ifstream file(config_file_path);
+		if (!reader.parse(file, root)) {
+			LogError("Failed to parse configuration file");
+			return;
+		}
+		file.close();
+
+		// get old fields
+		std::string host = !chat_host.empty() ? chat_host : mail_host;
+		if (host.empty()) {
+			host = "eqchat.eqemulator.net";
+		}
+		std::string port = chat_port > 0 ? std::to_string(chat_port) : std::to_string(mail_port);
+		if (port.empty()) {
+			port = "7778";
+		}
+
+		// set new fields
+		root["server"]["ucs"]["host"] = host;
+		root["server"]["ucs"]["port"] = port;
+
+		// unset old fields
+		root["server"].removeMember("chatserver");
+		root["server"].removeMember("mailserver");
+
+		// get Json::Value raw string
+		std::string config = root.toStyledString();
+
+		// format using more modern json library
+		nlohmann::json data = nlohmann::json::parse(config);
+
+		// write to file
+		std::ofstream o(config_file_path);
+		o << std::setw(1) << data << std::endl;
+		o.close();
+
+		// write new config
+		LogInfo("New configuration written to [{}]", config_file_path);
+		LogInfo("Migration complete, please review the new configuration file");
+
+		// reload config internally
+		try {
+			std::ifstream fconfig(config_file_path, std::ifstream::binary);
+			fconfig >> _config->_root;
+			_config->parse_config();
+		}
+		catch (std::exception &) {
+			return;
+		}
+	}
+}

common/eqemu_config.h

@@ -62,14 +62,6 @@ class EQEmuConfig
 		std::string SharedKey;
 		bool DisableConfigChecks;
 
-		// From <chatserver/>
-		std::string ChatHost;
-		uint16 ChatPort;
-
-		// From <mailserver/>
-		std::string MailHost;
-		uint16 MailPort;
-
 		// From <database/>
 		std::string DatabaseHost;
 		std::string DatabaseUsername;
@@ -122,12 +114,18 @@ class EQEmuConfig
 
 		bool auto_database_updates;
 
+		const std::string &GetUCSHost() const;
+		uint16 GetUCSPort() const;
+
 //	uint16 DynamicCount;
 
 //	map<string,uint16> StaticZones;
 
 	protected:
 
+		std::string m_ucs_host;
+		uint16      m_ucs_port;
+
 		static EQEmuConfig *_config;
 		Json::Value _root;
 		static std::string ConfigFile;
@@ -186,6 +184,7 @@ class EQEmuConfig
 		}
 
 		void Dump() const;
+		void CheckUcsConfigConversion();
 };
 
 #endif

common/eqemu_logsys.cpp

@@ -651,6 +651,9 @@ EQEmuLogSys *EQEmuLogSys::LoadLogDatabaseSettings()
 	}
 
 	// Auto inject categories that don't exist in the database...
+
+	std::vector<LogsysCategoriesRepository::LogsysCategories> db_categories_to_add{};
+
 	for (int i = Logs::AA; i != Logs::MaxCategoryID; i++) {
 
 		bool is_missing_in_database = std::find(db_categories.begin(), db_categories.end(), i) == db_categories.end();
@@ -665,11 +668,7 @@ EQEmuLogSys *EQEmuLogSys::LoadLogDatabaseSettings()
 		}
 
 		if (is_missing_in_database && !is_deprecated_category) {
-			LogInfo(
-				"Automatically adding new log category [{}] ({})",
-				Logs::LogCategoryName[i],
-				i
-			);
+			LogInfo("Automatically adding new log category [{}] ({})", Logs::LogCategoryName[i], i);
 
 			auto new_category = LogsysCategoriesRepository::NewEntity();
 			new_category.log_category_id          = i;
@@ -678,11 +677,16 @@ EQEmuLogSys *EQEmuLogSys::LoadLogDatabaseSettings()
 			new_category.log_to_gmsay             = log_settings[i].log_to_gmsay;
 			new_category.log_to_file              = log_settings[i].log_to_file;
 			new_category.log_to_discord           = log_settings[i].log_to_discord;
-
-			LogsysCategoriesRepository::InsertOne(*m_database, new_category);
+			db_categories_to_add.emplace_back(new_category);
 		}
 	}
 
+	if (!db_categories_to_add.empty()) {
+		LogsysCategoriesRepository::ReplaceMany(*m_database, db_categories_to_add);
+		LoadLogDatabaseSettings();
+		return this;
+	}
+
 	LogInfo("Loaded [{}] log categories", categories.size());
 
 	auto webhooks = DiscordWebhooksRepository::GetWhere(*m_database, fmt::format("id < {}", MAX_DISCORD_WEBHOOK_ID));
@@ -697,6 +701,8 @@ EQEmuLogSys *EQEmuLogSys::LoadLogDatabaseSettings()
 	log_settings[Logs::Crash].log_to_console = static_cast<uint8>(Logs::General);
 	log_settings[Logs::Crash].log_to_gmsay   = static_cast<uint8>(Logs::General);
 	log_settings[Logs::Crash].log_to_file    = static_cast<uint8>(Logs::General);
+	log_settings[Logs::Info].log_to_file     = static_cast<uint8>(Logs::General);
+	log_settings[Logs::Info].log_to_console  = static_cast<uint8>(Logs::General);
 
 	return this;
 }

common/eqemu_logsys.h

@@ -140,6 +140,8 @@ namespace Logs {
 		DataBuckets,
 		Zoning,
 		EqTime,
+		Corpses,
+		XTargets,
 		MaxCategoryID /* Don't Remove this */
 	};
 
@@ -239,6 +241,8 @@ namespace Logs {
 		"DataBuckets",
 		"Zoning",
 		"EqTime",
+		"Corpses",
+		"XTargets"
 	};
 }
 

common/eqemu_logsys_log_aliases.h

@@ -824,6 +824,26 @@
         OutF(LogSys, Logs::Detail, Logs::EqTime, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
+#define LogCorpses(message, ...) do {\
+    if (LogSys.IsLogEnabled(Logs::General, Logs::Corpses))\
+        OutF(LogSys, Logs::General, Logs::Corpses, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogCorpsesDetail(message, ...) do {\
+    if (LogSys.IsLogEnabled(Logs::Detail, Logs::Corpses))\
+        OutF(LogSys, Logs::Detail, Logs::Corpses, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogXTargets(message, ...) do {\
+    if (LogSys.IsLogEnabled(Logs::General, Logs::XTargets))\
+        OutF(LogSys, Logs::General, Logs::XTargets, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogXTargetsDetail(message, ...) do {\
+    if (LogSys.IsLogEnabled(Logs::Detail, Logs::XTargets))\
+        OutF(LogSys, Logs::Detail, Logs::XTargets, __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__);\

common/errmsg.h

@@ -1,59 +0,0 @@
-/*	Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
-
-	This library is free software; you can redistribute it and/or
-	modify it under the terms of the GNU Library General Public
-	License as published by the Free Software Foundation; either
-	version 2 of the License, or (at your option) any later version.
-
-	This library is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-	Library General Public License for more details.
-
-	You should have received a copy of the GNU Library General Public
-	License along with this library; if not, write to the Free
-	Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
-	MA 02111-1307, USA */
-
-/*	Error messages for mysql clients */
-/*	error messages for the demon is in share/language/errmsg.sys */
-
-#ifdef	__cplusplus
-extern "C" {
-#endif
-void	init_client_errs(void);
-extern const char *client_errors[];	/* Error messages */
-#ifdef	__cplusplus
-}
-#endif
-
-#define CR_MIN_ERROR		2000	/* For easier client code */
-#define CR_MAX_ERROR		2999
-#if defined(OS2) && defined( MYSQL_SERVER)
-#define CER(X) client_errors[(X)-CR_MIN_ERROR]
-#else
-#define ER(X) client_errors[(X)-CR_MIN_ERROR]
-#endif
-#define CLIENT_ERRMAP		2	/* Errormap used by my_error() */
-
-#define CR_UNKNOWN_ERROR	2000
-#define CR_SOCKET_CREATE_ERROR	2001
-#define CR_CONNECTION_ERROR	2002
-#define CR_CONN_HOST_ERROR	2003
-#define CR_IPSOCK_ERROR		2004
-#define CR_UNKNOWN_HOST		2005
-#define CR_SERVER_GONE_ERROR	2006
-#define CR_VERSION_ERROR	2007
-#define CR_OUT_OF_MEMORY	2008
-#define CR_WRONG_HOST_INFO	2009
-#define CR_LOCALHOST_CONNECTION 2010
-#define CR_TCP_CONNECTION	2011
-#define CR_SERVER_HANDSHAKE_ERR 2012
-#define CR_SERVER_LOST		2013
-#define CR_COMMANDS_OUT_OF_SYNC 2014
-#define CR_NAMEDPIPE_CONNECTION 2015
-#define CR_NAMEDPIPEWAIT_ERROR 2016
-#define CR_NAMEDPIPEOPEN_ERROR 2017
-#define CR_NAMEDPIPESETSTATE_ERROR 2018
-#define CR_CANT_READ_CHARSET	2019
-#define CR_NET_PACKET_TOO_LARGE 2020

common/events/player_event_logs.cpp

@@ -37,6 +37,8 @@ void PlayerEventLogs::Init()
 		db.emplace_back(e.id);
 	}
 
+	std::vector<PlayerEventLogSettingsRepository::PlayerEventLogSettings> settings_to_insert{};
+
 	// insert entries that don't exist in database
 	for (int i = PlayerEvent::GM_COMMAND; i != PlayerEvent::MAX; i++) {
 		bool is_in_database = std::find(db.begin(), db.end(), i) != db.end();
@@ -56,21 +58,21 @@ void PlayerEventLogs::Init()
 
 		bool is_missing_in_database = std::find(db.begin(), db.end(), i) == db.end();
 		if (is_missing_in_database && is_implemented && !is_deprecated) {
-			LogInfo(
-				"[New] PlayerEvent [{}] ({})",
-				PlayerEvent::EventName[i],
-				i
-			);
+			LogInfo("[New] PlayerEvent [{}] ({})", PlayerEvent::EventName[i], i);
 
 			auto c = PlayerEventLogSettingsRepository::NewEntity();
 			c.id             = i;
 			c.event_name     = PlayerEvent::EventName[i];
 			c.event_enabled  = m_settings[i].event_enabled;
 			c.retention_days = m_settings[i].retention_days;
-			PlayerEventLogSettingsRepository::InsertOne(*m_database, c);
+			settings_to_insert.emplace_back(c);
 		}
 	}
 
+	if (!settings_to_insert.empty()) {
+		PlayerEventLogSettingsRepository::ReplaceMany(*m_database, settings_to_insert);
+	}
+
 	bool processing_in_world = !RuleB(Logging, PlayerEventsQSProcess) && IsWorld();
 	bool processing_in_qs    = RuleB(Logging, PlayerEventsQSProcess) && IsQueryServ();
 
@@ -611,7 +613,7 @@ void PlayerEventLogs::Process()
 
 void PlayerEventLogs::ProcessRetentionTruncation()
 {
-	LogInfo("Running truncation");
+	LogPlayerEvents("Running truncation");
 
 	for (int i = PlayerEvent::GM_COMMAND; i != PlayerEvent::MAX; i++) {
 		if (m_settings[i].retention_days > 0) {
@@ -695,6 +697,8 @@ void PlayerEventLogs::SetSettingsDefaults()
 	m_settings[PlayerEvent::KILLED_NAMED_NPC].event_enabled   = 1;
 	m_settings[PlayerEvent::KILLED_RAID_NPC].event_enabled    = 1;
 	m_settings[PlayerEvent::ITEM_CREATION].event_enabled      = 1;
+	m_settings[PlayerEvent::GUILD_TRIBUTE_DONATE_ITEM].event_enabled      = 1;
+	m_settings[PlayerEvent::GUILD_TRIBUTE_DONATE_PLAT].event_enabled      = 1;
 
 	for (int i = PlayerEvent::GM_COMMAND; i != PlayerEvent::MAX; i++) {
 		m_settings[i].retention_days = RETENTION_DAYS_DEFAULT;

common/events/player_events.h

@@ -56,6 +56,8 @@ namespace PlayerEvent {
 		KILLED_NAMED_NPC,
 		KILLED_RAID_NPC,
 		ITEM_CREATION,
+		GUILD_TRIBUTE_DONATE_ITEM,
+		GUILD_TRIBUTE_DONATE_PLAT,
 		MAX // dont remove
 	};
 
@@ -112,7 +114,9 @@ namespace PlayerEvent {
 		"Killed NPC",
 		"Killed Named NPC",
 		"Killed Raid NPC",
-		"Item Creation"
+		"Item Creation",
+		"Guild Tribute Donate Item",
+		"Guild Tribute Donate Platinum"
 	};
 
 	// Generic struct used by all events
@@ -942,6 +946,36 @@ namespace PlayerEvent {
 			);
 		}
 	};
+
+	struct GuildTributeDonateItem {
+		uint32      item_id;
+		uint32 		guild_favor;
+
+		// cereal
+		template<class Archive>
+		void serialize(Archive &ar)
+		{
+			ar(
+				CEREAL_NVP(item_id),
+				CEREAL_NVP(guild_favor)
+			);
+		}
+	};
+
+	struct GuildTributeDonatePlat {
+		uint32      plat;
+		uint32 		guild_favor;
+
+		// cereal
+		template<class Archive>
+		void serialize(Archive &ar)
+		{
+			ar(
+				CEREAL_NVP(plat),
+				CEREAL_NVP(guild_favor)
+			);
+		}
+	};
 }
 
 #endif //EQEMU_PLAYER_EVENTS_H

common/faction.cpp

@@ -96,12 +96,12 @@ bool IsOfEqualRace(int r1, int r2)
 	// TODO: add more values
 	switch (r1) {
 		case DARK_ELF:
-			if (r2 == RACE_NERIAK_CITIZEN_77) {
+			if (r2 == Race::NeriakCitizen) {
 				return true;
 			}
 			break;
 		case BARBARIAN:
-			if (r2 == RACE_HALAS_CITIZEN_90) {
+			if (r2 == Race::HalasCitizen) {
 				return true;
 			}
 	}

common/faction.h

@@ -24,17 +24,15 @@
 #include <string>
 
 enum FACTION_VALUE {
-	FACTION_ALLY = 1,
-	FACTION_WARMLY = 2,
-	FACTION_KINDLY = 3,
-	FACTION_AMIABLY = 4,
-
-	FACTION_INDIFFERENTLY = 5,
-
+	FACTION_ALLY           = 1,
+	FACTION_WARMLY         = 2,
+	FACTION_KINDLY         = 3,
+	FACTION_AMIABLY        = 4,
+	FACTION_INDIFFERENTLY  = 5,
 	FACTION_APPREHENSIVELY = 6,
-	FACTION_DUBIOUSLY = 7,
-	FACTION_THREATENINGLY = 8,
-	FACTION_SCOWLS = 9
+	FACTION_DUBIOUSLY      = 7,
+	FACTION_THREATENINGLY  = 8,
+	FACTION_SCOWLS         = 9
 };
 
 struct NPCFactionList {
@@ -75,23 +73,6 @@ struct NPCFaction
 	uint8 temp;
 };
 
-// Faction Associations give a much more live like faction system
-// Basically the primary faction and magnitude of a faction hit will generate the rest of them
-
-// Largest faction I could find quickly was Lord Inquisitor Seru with 9 total hits (8 associations) so 8 + 2 for max for now
-#define MAX_FACTION_ASSOC 10
-
-// this is the ID of a faction association and it's multiplier
-struct FactionAssociationHit {
-	int id;
-	float multiplier;
-};
-
-struct FactionAssociations {
-	// maybe there should be more data here, fine for now
-	FactionAssociationHit hits[MAX_FACTION_ASSOC];
-};
-
 const char *FactionValueToString(FACTION_VALUE faction_value);
 FACTION_VALUE CalculateFaction(FactionMods* fm, int32 tmpCharacter_value);
 #endif

common/features.h

@@ -35,11 +35,6 @@ Core Zone features
 
 */
 
-
-//Uncomment this to cause a zone to basically idle
-//when there are no players in it, mobs stop wandering, etc..
-#define IDLE_WHEN_EMPTY
-
 #ifdef EMBPERL
 //Enable the new XS based perl parser
 #define EMBPERL_XS

common/file.cpp

@@ -38,21 +38,21 @@
 #include <fmt/format.h>
 #include <filesystem>
 #include <iostream>
+#include <sys/stat.h>
 
 namespace fs = std::filesystem;
 
-/**
- * @param name
- * @return
- */
+
 bool File::Exists(const std::string &name)
 {
-	return fs::exists(fs::path{name});
+	struct stat sb{};
+	if (stat(name.c_str(), &sb) == 0) {
+		return true;
+	}
+
+	return false;
 }
 
-/**
- * @param directory_name
- */
 void File::Makedir(const std::string &directory_name)
 {
 	try {

common/guild_base.h

@@ -5,6 +5,42 @@
 #include <map>
 #include <string>
 #include <vector>
+#include "timer.h"
+#include "../common/repositories/guild_members_repository.h"
+#include "../common/repositories/guilds_repository.h"
+
+struct DefaultPermissionStruct {
+	GuildAction id;
+	uint32      value;
+};
+
+struct DefaultRankNamesStruct {
+	uint32      id;
+	std::string name;
+};
+
+struct GuildTributeStruct {
+	Timer    timer;
+	uint32   id_1;
+	uint32   id_2;
+	uint32   id_1_tier;
+	uint32   id_2_tier;
+	uint32   favor;
+	uint32   time_remaining;
+	uint32   enabled;
+	bool     send_timer;
+};
+
+class TributeData {
+public:
+	//this level data stored in regular byte order and must be flipped before sending
+	TributeLevel_Struct tiers[MAX_TRIBUTE_TIERS];
+	uint8       tier_count;
+	uint32      unknown;
+	std::string name;
+	std::string description;
+	bool        is_guild;	//is a guild tribute item
+};
 
 class Database;
 
@@ -12,22 +48,23 @@ class CharGuildInfo
 {
 	public:
 		//fields from `characer_`
-		uint32	char_id;
+		uint32	    char_id;
 		std::string	char_name;
-		uint8	class_;
-		uint16	level;
-		uint32	time_last_on;
-		uint32	zone_id;
+		uint8	    class_;
+		uint16	    level;
+		uint32	    time_last_on;
+		uint32	    zone_id;
 
 		//fields from `guild_members`
-		uint32	guild_id;
-		uint8	rank;
-		bool	tribute_enable;
-		uint32	total_tribute;
-		uint32	last_tribute;		//timestamp
-		bool	banker;
-		bool	alt;
+		uint32	    guild_id;
+		uint8	    rank;
+		bool	    tribute_enable;
+		uint32	    total_tribute;
+		uint32	    last_tribute;		//timestamp
+		bool	    banker;
+		bool	    alt;
 		std::string	public_note;
+		bool	    online;
 };
 
 //this object holds guild functionality shared between world and zone.
@@ -38,21 +75,31 @@ class BaseGuildManager
 		virtual ~BaseGuildManager();
 
 		//this must be called before doing anything else with this object
-		void SetDatabase(Database *db)
+		BaseGuildManager * SetDatabase(Database *db)
 		{
 			m_db = db;
+
+			return this;
+		}
+
+		BaseGuildManager * SetContentDatabase(Database *db)
+		{
+			m_content_db = db;
+
+			return this;
 		}
 
 		bool LoadGuilds();
-		bool RefreshGuild(uint32 guild_id);
+		virtual bool RefreshGuild(uint32 guild_id);
 
 		//guild edit actions.
-		uint32	CreateGuild(const char* name, uint32 leader_char_id);
+		uint32	CreateGuild(std::string name, uint32 leader_char_id);
+		bool    StoreGuildDB(uint32 guild_id);
 		bool	DeleteGuild(uint32 guild_id);
-		bool	RenameGuild(uint32 guild_id, const char* name);
-		bool	SetGuildMOTD(uint32 guild_id, const char* motd, const char *setter);
-		bool	SetGuildURL(uint32 GuildID, const char* URL);
-		bool	SetGuildChannel(uint32 GuildID, const char* Channel);
+		bool	RenameGuild(uint32 guild_id, std::string name);
+		bool	SetGuildMOTD(uint32 guild_id, std::string motd, std::string setter);
+		bool	SetGuildURL(uint32 guild_id, std::string URL);
+		bool	SetGuildChannel(uint32 guild_id, std::string Channel);
 
 		//character edit actions
 		bool	SetGuildLeader(uint32 guild_id, uint32 leader_char_id);
@@ -62,9 +109,16 @@ class BaseGuildManager
 		bool	ForceRankUpdate(uint32 charid);
 		bool	GetAltFlag(uint32 CharID);
 		bool	SetAltFlag(uint32 charid, bool is_alt);
-		bool	GetBankerFlag(uint32 CharID);
+		bool	GetBankerFlag(uint32 CharID, bool compat_mode = false);
+		bool    GetGuildBankerStatus(uint32 guild_id, uint32 guild_rank);
 		bool	SetTributeFlag(uint32 charid, bool enabled);
-		bool	SetPublicNote(uint32 charid, const char *note);
+		bool	SetPublicNote(uint32 charid, std::string public_note);
+		uint32  UpdateDbGuildFavor(uint32 guild_id, uint32 enabled);
+		bool    UpdateDbGuildTributeEnabled(uint32 guild_id, uint32 enabled);
+		bool    UpdateDbMemberTributeEnabled(uint32 guild_id, uint32 char_id, uint32 enabled);
+		bool    UpdateDbTributeTimeRemaining(uint32 guild_id, uint32 enabled);
+		uint32	UpdateDbMemberFavor(uint32 guild_id, uint32 char_id, uint32 favor);
+		bool    UpdateDbMemberOnline(uint32 char_id, bool status);
 
 		//queries
 		bool	GetCharInfo(const char *char_name, CharGuildInfo &into);
@@ -74,29 +128,24 @@ class BaseGuildManager
 		bool	GetGuildMOTD(uint32 guild_id, char *motd_buffer, char *setter_buffer) const;
 		bool	GetGuildURL(uint32 GuildID, char *URLBuffer) const;
 		bool	GetGuildChannel(uint32 GuildID, char *ChannelBuffer) const;
-		const char *GetRankName(uint32 guild_id, uint8 rank) const;
-		const char *GetGuildName(uint32 guild_id) const;
-		std::string GetGuildNameByID(uint32 guild_id) const;
-		std::string GetGuildRankName(uint32 guild_id, uint8 rank) const;
-		bool IsCharacterInGuild(uint32 character_id, uint32 guild_id = 0);
-		bool	GetGuildNameByID(uint32 guild_id, std::string &into) const;
-		uint32	GetGuildIDByName(const char *GuildName);
-		uint32 GetGuildIDByCharacterID(uint32 character_id);
-		bool	IsGuildLeader(uint32 guild_id, uint32 char_id) const;
-		uint8	GetDisplayedRank(uint32 guild_id, uint8 rank, uint32 char_id) const;
-		bool	CheckGMStatus(uint32 guild_id, uint8 status) const;
-		bool	CheckPermission(uint32 guild_id, uint8 rank, GuildAction act) const;
-//	uint32	Getguild_id(uint32 eqid);
-		uint32	FindGuildByLeader(uint32 leader) const;
-//	void	GetGuildMembers(uint32 guild_id,GuildMember_Struct* gms);
-		uint32	NumberInGuild(uint32 guild_id);
-//	bool	GetGuildRanks(uint32 guildeqid, GuildRanks_Struct* gr);
-//	bool	EditGuild(uint32 guild_id, uint8 ranknum, GuildRankLevel_Struct* grl);
-
-		uint8 *MakeGuildList(const char *head_name, uint32 &length) const;	//make a guild list packet, returns ownership of the buffer.
-
-		static const char *const GuildActionNames[_MaxGuildAction];
-		uint32	DoesAccountContainAGuildLeader(uint32 AccountID);
+        bool    IsCharacterInGuild(uint32 character_id, uint32 guild_id = 0);
+        bool	GetGuildNameByID(uint32 guild_id, std::string& into) const;
+        bool	IsGuildLeader(uint32 guild_id, uint32 char_id) const;
+        bool	CheckGMStatus(uint32 guild_id, uint8 status) const;
+        bool	CheckPermission(uint32 guild_id, uint8 rank, GuildAction act) const;
+        bool	UpdateDbBankerFlag(uint32 charid, bool is_banker);
+        uint8*  MakeGuildList(const char* head_name, uint32& length) const;	//make a guild list packet, returns ownership of the buffer.
+        uint8	GetDisplayedRank(uint32 guild_id, uint8 rank, uint32 char_id) const;
+        uint32	GetGuildIDByName(const char *GuildName);
+		uint32  GetGuildIDByCharacterID(uint32 character_id);
+        uint32	FindGuildByLeader(uint32 leader) const;
+        uint32	NumberInGuild(uint32 guild_id);
+        uint32	DoesAccountContainAGuildLeader(uint32 AccountID);
+        const char* GetRankName(uint32 guild_id, uint8 rank) const;
+        const char* GetGuildName(uint32 guild_id) const;
+        std::string GetGuildNameByID(uint32 guild_id) const;
+        std::string GetGuildRankName(uint32 guild_id, uint8 rank) const;
+        std::vector<GuildMembersRepository::GuildMembers> GetGuildMembers(uint32 guild_id);
 
 	protected:
 		//the methods which must be defined by base classes.
@@ -105,58 +154,62 @@ class BaseGuildManager
 		virtual void SendRankUpdate(uint32 CharID) = 0;
 		virtual void SendGuildDelete(uint32 guild_id) = 0;
 
-		uint32	DBCreateGuild(const char* name, uint32 leader_char_id);
-		bool	DBDeleteGuild(uint32 guild_id);
-		bool	DBRenameGuild(uint32 guild_id, const char* name);
-		bool	DBSetGuildLeader(uint32 guild_id, uint32 leader_char_id);
-		bool	DBSetGuildMOTD(uint32 guild_id, const char* motd, const char *setter);
-		bool	DBSetGuildURL(uint32 GuildID, const char* URL);
-		bool	DBSetGuildChannel(uint32 GuildID, const char* Channel);
-		bool	DBSetGuild(uint32 charid, uint32 guild_id, uint8 rank);
-		bool	DBSetGuildRank(uint32 charid, uint8 rank);
-		bool	DBSetBankerFlag(uint32 charid, bool is_banker);
-		bool	DBSetAltFlag(uint32 charid, bool is_alt);
-		bool	DBSetTributeFlag(uint32 charid, bool enabled);
-		bool	DBSetPublicNote(uint32 charid, const char *note);
+		uint32	UpdateDbCreateGuild(std::string name, uint32 leader_char_id);
+		bool    UpdateDbDeleteGuild(uint32 guild_id, bool local_delete = true, bool db_delete = true);
+		bool	UpdateDbRenameGuild(uint32 guild_id, std::string name);
+		bool	UpdateDbGuildLeader(uint32 guild_id, uint32 leader_char_id);
+		bool	UpdateDbGuildMOTD(uint32 guild_id, std::string motd, std::string setter);
+		bool	UpdateDbGuildURL(uint32 GuildID, std::string URL);
+		bool	UpdateDbGuildChannel(uint32 GuildID, std::string Channel);
+		bool	UpdateDbGuild(uint32 charid, uint32 guild_id, uint8 rank);
+		bool	UpdateDbGuildRank(uint32 charid, uint8 rank);
+		bool	UpdateDbAltFlag(uint32 charid, bool is_alt);
+		bool	UpdateDbTributeFlag(uint32 charid, bool enabled);
+		bool	UpdateDbPublicNote(uint32 charid, std::string public_note);
 		bool	QueryWithLogging(std::string query, const char *errmsg);
-//	void	DBSetPublicNote(uint32 guild_id,char* charname, char* note);
-
 		bool	LocalDeleteGuild(uint32 guild_id);
 
-		class RankInfo
+		struct RankInfo
 		{
-			public:
-				RankInfo();
-				std::string name;
-				bool permissions[_MaxGuildAction];
+			RankInfo();
+			std::string rank_name;
 		};
-		class GuildInfo
+		struct Functions
 		{
-			public:
-				GuildInfo();
-				std::string name;
-				std::string motd;
-				std::string motd_setter;
-				std::string url;
-				std::string channel;
-
-				uint32 leader_char_id;
-				uint8 minstatus;
-				//tribute is not in here on purpose, since it is only valid in world!
-				RankInfo ranks[GUILD_MAX_RANK + 1];
+			uint32 id;
+			uint32 perm_id;
+			uint32 guild_id;
+			uint32 perm_value;
 		};
+	public:
+		class GuildInfo {
+		public:
+			GuildInfo();
+			std::string   name;
+			std::string   motd;
+			std::string   motd_setter;
+			std::string   url;
+			std::string   channel;
+			uint32        leader;
+			uint8         minstatus;
+			std::string   rank_names[GUILD_MAX_RANK + 1];
+			Functions     functions[GUILD_MAX_FUNCTIONS + 1];
+			GuildTributeStruct tribute;
+		};
+	virtual BaseGuildManager::GuildInfo* GetGuildByGuildID(uint32 guild_id);
+	uint32 GetGuildTributeTimeRemaining(uint32 guild_id);
 
+	protected:
 		std::map<uint32, GuildInfo *> m_guilds;	//we own the pointers in this map
 		void ClearGuilds();	//clears internal structure
 
-		Database *m_db;	//we do not own this
+		Database *m_db;
+		Database *m_content_db;
 
 		bool _StoreGuildDB(uint32 guild_id);
-		GuildInfo *_CreateGuild(uint32 guild_id, const char *guild_name, uint32 account_id, uint8 minstatus, const char *guild_motd, const char *motd_setter, const char *Channel, const char *URL);
-		uint32 _GetFreeGuildID();
+		GuildInfo* _CreateGuild(uint32 guild_id, std::string guild_name, uint32 leader_char_id, uint8 minstatus, std::string guild_motd, std::string motd_setter, std::string Channel, std::string URL, uint32 favour);
+        GuildsRepository::Guilds CreateGuildRepoFromGuildInfo(uint32 guild_id, BaseGuildManager::GuildInfo& in);
 };
-
-
 #endif /*GUILD_BASE_H_*/
 
 

common/guilds.h

@@ -16,31 +16,71 @@
 	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */
 
-#ifndef GUILD_H
-#define GUILD_H
+#ifndef GUILDS_H
+#define GUILDS_H
 
 #include "types.h"
 
 #define GUILD_NONE		0xFFFFFFFF // user has no guild
 
-#define GUILD_MAX_RANK 8 // 0-2 - some places in the code assume a single digit, dont go above 9
+#define GUILD_MAX_RANK                     8 // 0-2 - some places in the code assume a single digit, dont go above 9
+#define GUILD_MAX_FUNCTIONS                30
+#define GUILD_TRIBUTES_MODIFY              1
+#define GUILD_TRIBUTES_SAVE                0
+#define GUILD_TRIBUTES_OFF                 0
+#define GUILD_TRIBUTES_ON                  1
+#define GUILD_INVITE_DECLINE               9
 
 //defines for standard ranks
-#define GUILD_MEMBER	0
-#define GUILD_OFFICER	1
-#define GUILD_LEADER	2
-#define GUILD_RANK_NONE (GUILD_MAX_RANK+1)
+#define GUILD_MEMBER_TI	    0
+#define GUILD_OFFICER_TI    1
+#define GUILD_LEADER_TI     2
+#define GUILD_RANK_NONE_TI (GUILD_MAX_RANK + 1)
+
+//defines for standard ranks base on RoF2 definitions
+#define GUILD_RANK_NONE      0
+#define GUILD_LEADER         1
+#define GUILD_SENIOR_OFFICER 2
+#define GUILD_OFFICER        3
+#define GUILD_SENIOR_MEMBER  4
+#define GUILD_MEMBER         5
+#define GUILD_JUNIOR_MEMBER  6
+#define GUILD_INITIATE       7
+#define GUILD_RECRUIT        8
 
 typedef enum {
-	GUILD_HEAR		= 0,
-	GUILD_SPEAK		= 1,
-	GUILD_INVITE	= 2,
-	GUILD_REMOVE	= 3,
-	GUILD_PROMOTE	= 4,
-	GUILD_DEMOTE	= 5,
-	GUILD_MOTD		= 6,
-	GUILD_WARPEACE	= 7,
-	_MaxGuildAction
+	GUILD_ACTION_BANNER_CHANGE                        = 1,
+	GUILD_ACTION_BANNER_PLANT                         = 2,
+	GUILD_ACTION_BANNER_REMOVE                        = 3,
+	GUILD_ACTION_DISPLAY_GUILD_NAME                   = 4,
+	GUILD_ACTION_RANKS_CHANGE_PERMISSIONS             = 5,
+	GUILD_ACTION_RANKS_CHANGE_RANK_NAMES              = 6,
+	GUILD_ACTION_MEMBERS_INVITE                       = 7,
+	GUILD_ACTION_MEMBERS_PROMOTE                      = 8,
+	GUILD_ACTION_MEMBERS_DEMOTE                       = 9,
+	GUILD_ACTION_MEMBERS_REMOVE                       = 10,
+	GUILD_ACTION_EDIT_RECRUITING_SETTINGS             = 11,
+	GUILD_ACTION_EDIT_PUBLIC_NOTES                    = 12,
+	GUILD_ACTION_BANK_DEPOSIT_ITEMS                   = 13,
+	GUILD_ACTION_BANK_WITHDRAW_ITEMS                  = 14,
+	GUILD_ACTION_BANK_VIEW_ITEMS                      = 15,
+	GUILD_ACTION_BANK_PROMOTE_ITEMS                   = 16,
+	GUILD_ACTION_BANK_CHANGE_ITEM_PERMISSIONS         = 17,
+	GUILD_ACTION_CHANGE_THE_MOTD                      = 18,
+	GUILD_ACTION_GUILD_CHAT_SEE                       = 19,
+	GUILD_ACTION_GUILD_CHAT_SPEAK_IN                  = 20,
+	GUILD_ACTION_SEND_THE_WHOLE_GUILD_E_MAIL          = 21,
+	GUILD_ACTION_TRIBUTE_CHANGE_FOR_OTHERS            = 22,
+	GUILD_ACTION_TRIBUTE_CHANGE_ACTIVE_BENEFIT        = 23,
+	GUILD_ACTION_TROPHY_TRIBUTE_CHANGE_FOR_OTHERS     = 24,
+	GUILD_ACTION_TROPHY_TRIBUTE_CHANGE_ACTIVE_BENEFIT = 25,
+	GUILD_ACTION_MEMBERS_CHANGE_ALT_FLAG_FOR_OTHER    = 26,
+	GUILD_ACTION_REAL_ESTATE_GUILD_PLOT_BUY           = 27,
+	GUILD_ACTION_REAL_ESTATE_GUILD_PLOT_SELL          = 28,
+	GUILD_ACTION_REAL_ESTATE_MODIFY_TROPHIES          = 29,
+	GUILD_ACTION_MEMBERS_DEMOTE_SELF                  = 30,
 } GuildAction;
 
+constexpr int format_as(GuildAction action) { return static_cast<int>(action); }
+
 #endif

common/inventory_profile.cpp

@@ -173,7 +173,8 @@ EQ::ItemInstance* EQ::InventoryProfile::GetItem(int16 slot_id) const
 		result = _GetItem(m_inv, slot_id);
 	}
 	else if ((slot_id >= invslot::EQUIPMENT_BEGIN && slot_id <= invslot::EQUIPMENT_END) ||
-		(slot_id >= invslot::TRIBUTE_BEGIN && slot_id <= invslot::TRIBUTE_END)) {
+		(slot_id >= invslot::TRIBUTE_BEGIN && slot_id <= invslot::TRIBUTE_END) ||
+		(slot_id >= invslot::GUILD_TRIBUTE_BEGIN && slot_id <= invslot::GUILD_TRIBUTE_END)) {
 		// Equippable slots (on body)
 		result = _GetItem(m_worn, slot_id);
 	}
@@ -465,6 +466,10 @@ EQ::ItemInstance* EQ::InventoryProfile::PopItem(int16 slot_id)
 		p = m_worn[slot_id];
 		m_worn.erase(slot_id);
 	}
+	else if (slot_id >= invslot::GUILD_TRIBUTE_BEGIN && slot_id <= invslot::GUILD_TRIBUTE_END) {
+		p = m_worn[slot_id];
+		m_worn.erase(slot_id);
+	}
 	else if (slot_id >= invslot::BANK_BEGIN && slot_id <= invslot::BANK_END) {
 		p = m_bank[slot_id];
 		m_bank.erase(slot_id);
@@ -801,34 +806,35 @@ int16 EQ::InventoryProfile::HasItemByLoreGroup(uint32 loregroup, uint8 where)
 // Returns slot_id when there's one available, else SLOT_INVALID
 int16 EQ::InventoryProfile::FindFreeSlot(bool for_bag, bool try_cursor, uint8 min_size, bool is_arrow)
 {
-	// Check basic inventory
-	for (int16 i = invslot::GENERAL_BEGIN; i <= invslot::GENERAL_END; i++) {
-		if ((((uint64)1 << i) & m_lookup->PossessionsBitmask) == 0)
-			continue;
+	const int16 last_bag_slot = (RuleI(World, ExpansionSettings) == -1 || RuleI(World, ExpansionSettings) & EQ::expansions::bitHoT) ? EQ::invslot::slotGeneral10 : EQ::invslot::slotGeneral8;
 
-		if (!GetItem(i))
-			// Found available slot in personal inventory
-			return i;
+	for (int16 i = invslot::GENERAL_BEGIN; i <= last_bag_slot; i++) { // Check basic inventory
+		if ((((uint64) 1 << i) & m_lookup->PossessionsBitmask) == 0) {
+			continue;
+		}
+
+		if (!GetItem(i)) {
+			return i; // Found available slot in personal inventory
+		}
 	}
 
 	if (!for_bag) {
-		for (int16 i = invslot::GENERAL_BEGIN; i <= invslot::GENERAL_END; i++) {
-			if ((((uint64)1 << i) & m_lookup->PossessionsBitmask) == 0)
+		for (int16 i = invslot::GENERAL_BEGIN; i <= last_bag_slot; i++) {
+			if ((((uint64) 1 << i) & m_lookup->PossessionsBitmask) == 0) {
 				continue;
+			}
 
-			const ItemInstance* inst = GetItem(i);
-			if (inst && inst->IsClassBag() && inst->GetItem()->BagSize >= min_size)
-			{
-				if (inst->GetItem()->BagType == item::BagTypeQuiver && inst->GetItem()->ItemType != item::ItemTypeArrow)
-				{
+			const auto *inst = GetItem(i);
+			if (inst && inst->IsClassBag() && inst->GetItem()->BagSize >= min_size) {
+				if (inst->GetItem()->BagType == item::BagTypeQuiver &&
+					inst->GetItem()->ItemType != item::ItemTypeArrow) {
 					continue;
 				}
 
-				int16 base_slot_id = InventoryProfile::CalcSlotId(i, invbag::SLOT_BEGIN);
+				const int16 base_slot_id = InventoryProfile::CalcSlotId(i, invbag::SLOT_BEGIN);
 
-				uint8 slots = inst->GetItem()->BagSlots;
-				uint8 j;
-				for (j = invbag::SLOT_BEGIN; j<slots; j++) {
+				const uint8 slots = inst->GetItem()->BagSlots;
+				for (uint8 j = invbag::SLOT_BEGIN; j < slots; j++) {
 					if (!GetItem(base_slot_id + j)) {
 						// Found available slot within bag
 						return (base_slot_id + j);
@@ -1418,6 +1424,10 @@ int16 EQ::InventoryProfile::_PutItem(int16 slot_id, ItemInstance* inst)
 		m_worn[slot_id] = inst;
 		result = slot_id;
 	}
+	else if (slot_id >= invslot::GUILD_TRIBUTE_BEGIN && slot_id <= invslot::GUILD_TRIBUTE_END) {
+		m_worn[slot_id] = inst;
+		result = slot_id;
+	}
 	else if (slot_id >= invslot::BANK_BEGIN && slot_id <= invslot::BANK_END) {
 		if (slot_id - EQ::invslot::BANK_BEGIN < m_lookup->InventoryTypeSize.Bank) {
 			m_bank[slot_id] = inst;

common/inventory_profile.h

@@ -132,7 +132,7 @@ namespace EQ
 
 		// Swap items in inventory
 		enum SwapItemFailState : int8 { swapInvalid = -1, swapPass = 0, swapNotAllowed, swapNullData, swapRaceClass, swapDeity, swapLevel };
-		bool SwapItem(int16 source_slot, int16 destination_slot, SwapItemFailState& fail_state, uint16 race_id = RACE_DOUG_0, uint8 class_id = Class::None, uint16 deity_id = deity::DeityType::DeityUnknown, uint8 level = 0);
+		bool SwapItem(int16 source_slot, int16 destination_slot, SwapItemFailState& fail_state, uint16 race_id = Race::Doug, uint8 class_id = Class::None, uint16 deity_id = deity::DeityType::DeityUnknown, uint8 level = 0);
 
 		// Remove item from inventory
 		bool DeleteItem(int16 slot_id, int16 quantity = 0);

common/item_instance.cpp

@@ -1273,7 +1273,7 @@ int EQ::ItemInstance::GetItemBaneDamageBody(bool augments) const
 
 int EQ::ItemInstance::GetItemBaneDamageRace(bool augments) const
 {
-	int race = RACE_DOUG_0;
+	int race = Race::Doug;
 	const auto item = GetItem();
 	if (item) {
 		race = item->BaneDmgRace;
@@ -1791,6 +1791,27 @@ int EQ::ItemInstance::RemoveTaskDeliveredItems()
 	return count;
 }
 
+uint32 EQ::ItemInstance::GetItemGuildFavor() const
+{
+	uint32 total = 0;
+	const auto item = GetItem();
+	if (item) {
+		return total = item->GuildFavor;
+	}
+	return 0;
+}
+
+std::vector<uint32> EQ::ItemInstance::GetAugmentIDs() const
+{
+	std::vector<uint32> augments;
+
+	for (uint8 slot_id = invaug::SOCKET_BEGIN; slot_id <= invaug::SOCKET_END; slot_id++) {
+		augments.push_back(GetAugment(slot_id) ? GetAugmentItemID(slot_id) : 0);
+	}
+
+	return augments;
+}
+
 //
 // class EvolveInfo
 //

common/item_instance.h

@@ -299,6 +299,8 @@ namespace EQ
 		int GetItemHeroicDR(bool augments = false) const;
 		int GetItemHeroicCorrup(bool augments = false) const;
 		int GetItemHaste(bool augments = false) const;
+		uint32 GetItemGuildFavor() const;
+		std::vector<uint32> GetAugmentIDs() const;
 
 	protected:
 		//////////////////////////

common/languages.h

@@ -1,54 +0,0 @@
-/*	EQEMu: Everquest Server Emulator
-	Copyright (C) 2001-2002 EQEMu Development Team (http://eqemulator.org)
-
-	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 LANGUAGES_H
-#define LANGUAGES_H
-#include "../common/types.h"
-
-#define LANG_COMMON_TONGUE	0
-#define LANG_BARBARIAN		1
-#define LANG_ERUDIAN		2
-#define LANG_ELVISH			3
-#define LANG_DARK_ELVISH	4
-#define LANG_DWARVISH		5
-#define LANG_TROLL			6
-#define LANG_OGRE			7
-#define LANG_GNOMISH		8
-#define LANG_HALFLING		9
-#define LANG_THIEVES_CANT	10
-#define LANG_OLD_ERUDIAN	11
-#define LANG_ELDER_ELVISH	12
-#define LANG_FROGLOK		13
-#define LANG_GOBLIN			14
-#define LANG_GNOLL			15
-#define LANG_COMBINE_TONGUE	16
-#define LANG_ELDER_TEIRDAL	17
-#define LANG_LIZARDMAN		18
-#define LANG_ORCISH			19
-#define LANG_FAERIE			20
-#define LANG_DRAGON			21
-#define LANG_ELDER_DRAGON	22
-#define LANG_DARK_SPEECH	23
-#define LANG_VAH_SHIR		24
-#define LANG_ALARAN			25
-#define LANG_HADAL			26
-#define LANG_UNKNOWN	27
-
-#define MAX_LANGUAGE_SKILL 100
-
-#endif
-

common/loot.h

@@ -0,0 +1,33 @@
+#ifndef CODE_LOOT_H
+#define CODE_LOOT_H
+
+#include <list>
+#include <string>
+#include "../common/types.h"
+
+struct LootItem {
+	uint32      item_id;
+	int16       equip_slot;
+	uint16      charges;
+	uint16      lootslot;
+	uint32      aug_1;
+	uint32      aug_2;
+	uint32      aug_3;
+	uint32      aug_4;
+	uint32      aug_5;
+	uint32      aug_6;
+	bool        attuned;
+	std::string custom_data;
+	uint32      ornamenticon{};
+	uint32      ornamentidfile{};
+	uint32      ornament_hero_model{};
+	uint16      trivial_min_level;
+	uint16      trivial_max_level;
+	uint16      npc_min_level;
+	uint16      npc_max_level;
+};
+
+typedef std::list<LootItem*> LootItems;
+
+
+#endif //CODE_LOOT_H

common/loottable.h

@@ -1,68 +0,0 @@
-/*	EQEMu: Everquest Server Emulator
-	Copyright (C) 2001-2013 EQEMu Development Team (http://eqemu.org)
-
-	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 _EQEMU_LOOTTABLE_H
-#define _EQEMU_LOOTTABLE_H
-
-#include "types.h"
-
-#pragma pack(1)
-struct LootTableEntries_Struct {
-	uint32	lootdrop_id;
-	uint8	droplimit;
-	uint8	mindrop;
-	uint8	multiplier;
-	float	probability;
-};
-
-struct ContentFlags {
-	int16 min_expansion;
-	int16 max_expansion;
-	char  content_flags[100];
-	char  content_flags_disabled[100];
-};
-
-struct LootTable_Struct {
-	uint32                  mincash;
-	uint32                  maxcash;
-	uint32                  avgcoin;
-	uint32                  NumEntries;
-	ContentFlags            content_flags;
-	LootTableEntries_Struct Entries[0];
-};
-
-struct LootDropEntries_Struct {
-	uint32 item_id;
-	int8   item_charges;
-	uint8  equip_item;
-	float  chance;
-	uint16 trivial_min_level;
-	uint16 trivial_max_level;
-	uint16 npc_min_level;
-	uint16 npc_max_level;
-	uint8  multiplier;
-};
-
-struct LootDrop_Struct {
-	uint32                 NumEntries;
-	ContentFlags           content_flags;
-	LootDropEntries_Struct Entries[0];
-};
-#pragma pack()
-
-#endif

common/patches/rof.cpp

@@ -202,7 +202,7 @@ namespace RoF
 		unsigned char *emu_buffer = in->pBuffer;
 		uint32 opcode = *((uint32*)emu_buffer);
 
-		if (opcode == 8) {
+		if (opcode == AlternateCurrencyMode::Populate) {
 			AltCurrencyPopulate_Struct *populate = (AltCurrencyPopulate_Struct*)emu_buffer;
 
 			auto outapp = new EQApplicationPacket(
@@ -1308,13 +1308,13 @@ namespace RoF
 				PutFieldN(class_);
 
 				/* Translate older ranks to new values */
-				switch (emu_e->rank) {
-				case 0: { e->rank = htonl(5); break; }  // GUILD_MEMBER	0
-				case 1: { e->rank = htonl(3); break; }  // GUILD_OFFICER 1
-				case 2: { e->rank = htonl(1); break; }  // GUILD_LEADER	2
-				default: { e->rank = htonl(emu_e->rank); break; } // GUILD_NONE
-				}
-
+				//switch (emu_e->rank) {
+				//case 0: { e->rank = htonl(5); break; }  // GUILD_MEMBER	0
+				//case 1: { e->rank = htonl(3); break; }  // GUILD_OFFICER 1
+				//case 2: { e->rank = htonl(1); break; }  // GUILD_LEADER	2
+				//default: { e->rank = htonl(emu_e->rank); break; } // GUILD_NONE
+				//}
+				PutFieldN(rank);
 				PutFieldN(time_last_on);
 				PutFieldN(tribute_enable);
 				e->unknown01 = 0;
@@ -2621,7 +2621,7 @@ namespace RoF
 		general->parameter = RaidCommandAcceptInvite;
 		strn0cpy(general->leader_name, emu->leader_name, sizeof(emu->leader_name));
 		strn0cpy(general->player_name, emu->leader_name, sizeof(emu->leader_name));
-		
+
 		dest->FastQueuePacket(&outapp);
 
 		safe_delete(inapp);
@@ -3051,19 +3051,12 @@ namespace RoF
 		ENCODE_LENGTH_EXACT(GuildSetRank_Struct);
 		SETUP_DIRECT_ENCODE(GuildSetRank_Struct, structs::GuildSetRank_Struct);
 
-		eq->GuildID = emu->Unknown00;
+		eq->guild_id = emu->Unknown00;
+		eq->rank = emu->rank;
 
-		/* Translate older ranks to new values */
-		switch (emu->Rank) {
-		case 0: { eq->Rank = 5; break; }  // GUILD_MEMBER	0
-		case 1: { eq->Rank = 3; break; }  // GUILD_OFFICER	1
-		case 2: { eq->Rank = 1; break; }  // GUILD_LEADER	2
-		default: { eq->Rank = emu->Rank; break; }
-		}
-
-		memcpy(eq->MemberName, emu->MemberName, sizeof(eq->MemberName));
-		OUT(Banker);
-		eq->Unknown76 = 1;
+		memcpy(eq->member_name, emu->member_name, sizeof(eq->member_name));
+		OUT(banker);
+		eq->unknown76 = 1;
 
 		FINISH_ENCODE();
 	}
@@ -3165,7 +3158,7 @@ namespace RoF
 
 		SpawnAppearance_Struct *sas = (SpawnAppearance_Struct *)emu_buffer;
 
-		if (sas->type != AT_Size)
+		if (sas->type != AppearanceType::Size)
 		{
 			dest->FastQueuePacket(&in, ack_req);
 			return;
@@ -3868,8 +3861,8 @@ namespace RoF
 			}
 
 			float SpawnSize = emu->size;
-			if (!((emu->NPC == 0) || (emu->race <= RACE_GNOME_12) || (emu->race == RACE_IKSAR_128) ||
-					(emu->race == RACE_VAH_SHIR_130) || (emu->race == RACE_FROGLOK_330) || (emu->race == RACE_DRAKKIN_522))
+			if (!((emu->NPC == 0) || (emu->race <= Race::Gnome) || (emu->race == Race::Iksar) ||
+					(emu->race == Race::VahShir) || (emu->race == Race::Froglok2) || (emu->race == Race::Drakkin))
 				)
 			{
 				PacketSize += 60;
@@ -3973,10 +3966,22 @@ namespace RoF
 
 				/* Translate older ranks to new values */
 				switch (emu->guildrank) {
-				case 0: { VARSTRUCT_ENCODE_TYPE(uint32, Buffer, 5);  break; }  // GUILD_MEMBER	0
-				case 1: { VARSTRUCT_ENCODE_TYPE(uint32, Buffer, 3);  break; }  // GUILD_OFFICER	1
-				case 2: { VARSTRUCT_ENCODE_TYPE(uint32, Buffer, 1);  break; }  // GUILD_LEADER	2
-				default: { VARSTRUCT_ENCODE_TYPE(uint32, Buffer, emu->guildrank); break; }  //
+					case 0: {
+						VARSTRUCT_ENCODE_TYPE(uint32, Buffer, 5);
+						break;
+					}  // GUILD_MEMBER	0
+					case 1: {
+						VARSTRUCT_ENCODE_TYPE(uint32, Buffer, 3);
+						break;
+					}  // GUILD_OFFICER	1
+					case 2: {
+						VARSTRUCT_ENCODE_TYPE(uint32, Buffer, 1);
+						break;
+					}  // GUILD_LEADER	2
+					default: {
+						VARSTRUCT_ENCODE_TYPE(uint32, Buffer, emu->guildrank);
+						break;
+					}  //
 				}
 			}
 
@@ -4002,8 +4007,8 @@ namespace RoF
 			VARSTRUCT_ENCODE_TYPE(uint32, Buffer, 0xffffffff); // unknown18
 			VARSTRUCT_ENCODE_TYPE(uint32, Buffer, 0xffffffff); // unknown19
 
-			if ((emu->NPC == 0) || (emu->race <= RACE_GNOME_12) || (emu->race == RACE_IKSAR_128) ||
-					(emu->race == RACE_VAH_SHIR_130) || (emu->race == RACE_FROGLOK_330) || (emu->race == RACE_DRAKKIN_522)
+			if ((emu->NPC == 0) || (emu->race <= Race::Gnome) || (emu->race == Race::Iksar) ||
+					(emu->race == Race::VahShir) || (emu->race == Race::Froglok2) || (emu->race == Race::Drakkin)
 				)
 			{
 				for (k = EQ::textures::textureBegin; k < EQ::textures::materialCount; ++k)

common/patches/rof2.cpp

@@ -274,7 +274,7 @@ namespace RoF2
 		unsigned char *emu_buffer = in->pBuffer;
 		uint32 opcode = *((uint32*)emu_buffer);
 
-		if (opcode == 8) {
+		if (opcode == AlternateCurrencyMode::Populate) {
 			AltCurrencyPopulate_Struct *populate = (AltCurrencyPopulate_Struct*)emu_buffer;
 
 			auto outapp = new EQApplicationPacket(
@@ -1319,6 +1319,7 @@ namespace RoF2
 		buffer++;
 
 		// Guild ID
+		//*((uint32*)buffer) = htonl(2);
 		buffer += sizeof(uint32);
 
 		//add member count.
@@ -1357,15 +1358,7 @@ namespace RoF2
 				PutFieldN(level);
 				PutFieldN(banker);
 				PutFieldN(class_);
-
-				/* Translate older ranks to new values */
-				switch (emu_e->rank) {
-				case 0: { e->rank = htonl(5); break; }  // GUILD_MEMBER	0
-				case 1: { e->rank = htonl(3); break; }  // GUILD_OFFICER 1
-				case 2: { e->rank = htonl(1); break; }  // GUILD_LEADER	2
-				default: { e->rank = htonl(emu_e->rank); break; } // GUILD_NONE
-				}
-
+				PutFieldN(rank);
 				PutFieldN(time_last_on);
 				PutFieldN(tribute_enable);
 				e->unknown01 = 0;
@@ -1395,8 +1388,10 @@ namespace RoF2
 
 		OUT(GuildID);
 		memcpy(eq->MemberName, emu->MemberName, sizeof(eq->MemberName));
-		OUT(ZoneID);
-		OUT(InstanceID);
+		//OUT(ZoneID);
+		//OUT(InstanceID);
+		eq->InstanceID = emu->InstanceID;
+		eq->ZoneID = emu->ZoneID;
 		OUT(LastSeen);
 		eq->Unknown76 = 0;
 
@@ -1422,7 +1417,7 @@ namespace RoF2
 			if (InBuffer[0])
 			{
 				PacketSize += (5 + strlen(InBuffer));
-				HighestGuildID = i - 1;
+				HighestGuildID += 1;
 			}
 			InBuffer += 64;
 		}
@@ -1460,6 +1455,30 @@ namespace RoF2
 		dest->FastQueuePacket(&in, ack_req);
 	}
 
+	ENCODE(OP_GuildTributeDonateItem)
+	{
+		SETUP_DIRECT_ENCODE(GuildTributeDonateItemReply_Struct, structs::GuildTributeDonateItemReply_Struct);
+
+		Log(Logs::Detail, Logs::Netcode, "RoF2::ENCODE(OP_GuildTributeDonateItem)");
+
+		OUT(type);
+		OUT(sub_index);
+		OUT(aug_index);
+		OUT(quantity);
+		OUT(unknown10);
+		OUT(unknown20);
+		OUT(favor);
+
+		structs::InventorySlot_Struct iss;
+		iss = ServerToRoF2Slot(emu->slot);
+
+		eq->slot = iss.Slot;
+		eq->sub_index = iss.SubIndex;
+
+		FINISH_ENCODE();
+	}
+
+
 	ENCODE(OP_HPUpdate)
 	{
 		SETUP_DIRECT_ENCODE(SpawnHPUpdate_Struct, structs::SpawnHPUpdate_Struct);
@@ -2466,6 +2485,8 @@ namespace RoF2
 		{
 			outapp->WriteUInt32(0xffffffff);
 			outapp->WriteUInt32(0);
+//			outapp->WriteUInt32(60);
+//			outapp->WriteUInt32(1);
 		}
 
 		outapp->WriteUInt32(0);				// Unknown
@@ -3104,19 +3125,12 @@ namespace RoF2
 		ENCODE_LENGTH_EXACT(GuildSetRank_Struct);
 		SETUP_DIRECT_ENCODE(GuildSetRank_Struct, structs::GuildSetRank_Struct);
 
-		eq->GuildID = emu->Unknown00;
+		eq->guild_id= emu->Unknown00;
+		eq->rank = emu->rank;
 
-		/* Translate older ranks to new values */
-		switch (emu->Rank) {
-		case 0: { eq->Rank = 5; break; }  // GUILD_MEMBER	0
-		case 1: { eq->Rank = 3; break; }  // GUILD_OFFICER	1
-		case 2: { eq->Rank = 1; break; }  // GUILD_LEADER	2
-		default: { eq->Rank = emu->Rank; break; }
-		}
-
-		memcpy(eq->MemberName, emu->MemberName, sizeof(eq->MemberName));
-		OUT(Banker);
-		eq->Unknown76 = 1;
+		memcpy(eq->member_name, emu->member_name, sizeof(eq->member_name));
+		OUT(banker);
+		eq->unknown76 = 1;
 
 		FINISH_ENCODE();
 	}
@@ -3218,7 +3232,7 @@ namespace RoF2
 
 		SpawnAppearance_Struct *sas = (SpawnAppearance_Struct *)emu_buffer;
 
-		if (sas->type != AT_Size)
+		if (sas->type != AppearanceType::Size)
 		{
 			dest->FastQueuePacket(&in, ack_req);
 			return;
@@ -4007,8 +4021,8 @@ namespace RoF2
 			}
 
 			float SpawnSize = emu->size;
-			if (!((emu->NPC == 0) || (emu->race <= RACE_GNOME_12) || (emu->race == RACE_IKSAR_128) ||
-					(emu->race == RACE_VAH_SHIR_130) || (emu->race == RACE_FROGLOK_330) || (emu->race == RACE_DRAKKIN_522))
+			if (!((emu->NPC == 0) || (emu->race <= Race::Gnome) || (emu->race == Race::Iksar) ||
+					(emu->race == Race::VahShir) || (emu->race == Race::Froglok2) || (emu->race == Race::Drakkin))
 				)
 			{
 				PacketSize += 60;
@@ -4178,12 +4192,13 @@ namespace RoF2
 				VARSTRUCT_ENCODE_TYPE(uint32, Buffer, emu->guildID);
 
 				/* Translate older ranks to new values */
-				switch (emu->guildrank) {
-				case 0: { VARSTRUCT_ENCODE_TYPE(uint32, Buffer, 5);  break; }  // GUILD_MEMBER	0
-				case 1: { VARSTRUCT_ENCODE_TYPE(uint32, Buffer, 3);  break; }  // GUILD_OFFICER	1
-				case 2: { VARSTRUCT_ENCODE_TYPE(uint32, Buffer, 1);  break; }  // GUILD_LEADER	2
-				default: { VARSTRUCT_ENCODE_TYPE(uint32, Buffer, emu->guildrank); break; }  //
-				}
+				//switch (emu->guildrank) {
+				//case 0: { VARSTRUCT_ENCODE_TYPE(uint32, Buffer, 5);  break; }  // GUILD_MEMBER	0
+				//case 1: { VARSTRUCT_ENCODE_TYPE(uint32, Buffer, 3);  break; }  // GUILD_OFFICER	1
+				//case 2: { VARSTRUCT_ENCODE_TYPE(uint32, Buffer, 1);  break; }  // GUILD_LEADER	2
+				//default: { VARSTRUCT_ENCODE_TYPE(uint32, Buffer, emu->guildrank); break; }  //
+				//}
+				VARSTRUCT_ENCODE_TYPE(uint32, Buffer, emu->guildrank);
 			}
 
 			VARSTRUCT_ENCODE_TYPE(uint8, Buffer, emu->class_);
@@ -4199,7 +4214,7 @@ namespace RoF2
 			VARSTRUCT_ENCODE_STRING(Buffer, emu->lastName);
 
 			VARSTRUCT_ENCODE_TYPE(uint32, Buffer, 0);	// aatitle
-			VARSTRUCT_ENCODE_TYPE(uint8, Buffer, emu->NPC ? 0 : 1); // unknown - Must be 1 for guild name to be shown abover players head.
+			VARSTRUCT_ENCODE_TYPE(uint8, Buffer, emu->guild_show); 
 			VARSTRUCT_ENCODE_TYPE(uint8, Buffer, 0); // TempPet
 
 			VARSTRUCT_ENCODE_TYPE(uint32, Buffer, emu->petOwnerId);
@@ -4212,8 +4227,8 @@ namespace RoF2
 			VARSTRUCT_ENCODE_TYPE(uint32, Buffer, 0xffffffff); // These do something with OP_WeaponEquip1
 			VARSTRUCT_ENCODE_TYPE(uint32, Buffer, 0xffffffff); // ^
 
-			if ((emu->NPC == 0) || (emu->race <= RACE_GNOME_12) || (emu->race == RACE_IKSAR_128) ||
-					(emu->race == RACE_VAH_SHIR_130) || (emu->race == RACE_FROGLOK_330) || (emu->race == RACE_DRAKKIN_522)
+			if ((emu->NPC == 0) || (emu->race <= Race::Gnome) || (emu->race == Race::Iksar) ||
+					(emu->race == Race::VahShir) || (emu->race == Race::Froglok2) || (emu->race == Race::Drakkin)
 				)
 			{
 				for (k = EQ::textures::textureBegin; k < EQ::textures::materialCount; ++k)
@@ -4955,7 +4970,7 @@ namespace RoF2
 
 		strn0cpy(emu->target, eq->target, sizeof(emu->target));
 		strn0cpy(emu->name, eq->name, sizeof(emu->name));
-		// IN(rank);
+		IN(rank);
 
 		FINISH_DIRECT_DECODE();
 	}
@@ -4983,6 +4998,38 @@ namespace RoF2
 		FINISH_DIRECT_DECODE();
 	}
 
+	DECODE(OP_GuildTributeDonateItem)
+	{
+		DECODE_LENGTH_EXACT(structs::GuildTributeDonateItemRequest_Struct);
+		SETUP_DIRECT_DECODE(GuildTributeDonateItemRequest_Struct, structs::GuildTributeDonateItemRequest_Struct);
+
+		Log(Logs::Detail, Logs::Netcode, "RoF2::DECODE(OP_GuildTributeDonateItem)");
+
+		IN(type);
+		IN(slot);
+		IN(sub_index);
+		IN(aug_index);
+		IN(unknown10);
+		IN(quantity);
+		IN(tribute_master_id);
+		IN(unknown20);
+		IN(guild_id);
+		IN(unknown28);
+		IN(unknown32);
+
+		structs::InventorySlot_Struct iss;
+		iss.Slot = eq->slot;
+		iss.SubIndex = eq->sub_index;
+		iss.AugIndex = eq->aug_index;
+		iss.Type = eq->type;
+		iss.Unknown01 = 0;
+		iss.Unknown02 = 0;
+
+		emu->slot = RoF2ToServerSlot(iss);
+
+		FINISH_DIRECT_DECODE();
+	}
+
 	/*DECODE(OP_InspectAnswer)
 	{
 	DECODE_LENGTH_EXACT(structs::InspectResponse_Struct);

common/patches/rof2_limits.h

@@ -158,6 +158,7 @@ namespace RoF2
 				slotCursor
 			};
 
+			constexpr int16 format_as(InventorySlots slot) { return static_cast<int16>(slot); }
 		} // namespace enum_
 		using namespace enum_;
 

common/patches/rof2_ops.h

@@ -82,6 +82,7 @@ E(OP_GuildBank)
 E(OP_GuildMemberList)
 E(OP_GuildMemberUpdate)
 E(OP_GuildsList)
+E(OP_GuildTributeDonateItem)
 E(OP_HPUpdate)
 E(OP_Illusion)
 E(OP_InspectBuffs)
@@ -182,6 +183,7 @@ D(OP_GuildBank)
 D(OP_GuildDemote)
 D(OP_GuildRemove)
 D(OP_GuildStatus)
+D(OP_GuildTributeDonateItem)
 D(OP_InspectRequest)
 D(OP_ItemLinkClick)
 D(OP_ItemVerifyRequest)

common/patches/rof2_structs.h

@@ -2011,6 +2011,31 @@ struct GuildBankClear_Struct
 /*16*/	uint32	MainAreaCount;
 };
 
+struct GuildTributeDonateItemRequest_Struct {
+	/*000*/	uint32	type;
+	/*004*/ uint16 	slot;
+	/*006*/ uint16 	sub_index;
+	/*008*/ uint16 	aug_index;
+	/*010*/ uint16 	unknown10;
+	/*012*/ uint32 	quantity;
+	/*016*/ uint32	tribute_master_id;
+	/*020*/ uint32 	unknown20;
+	/*024*/ uint32	guild_id;
+	/*028*/ uint32	unknown28;
+	/*032*/ uint32 	unknown32;
+};
+
+struct GuildTributeDonateItemReply_Struct {
+	/*000*/ uint32	type;
+	/*004*/ uint16	slot;
+	/*006*/ uint16 	sub_index;
+	/*008*/	uint16	aug_index;
+	/*010*/	uint16	unknown10;
+	/*012*/ uint32	quantity;
+	/*016*/ uint32	unknown20;
+	/*020*/	uint32	favor;
+};
+
 /*
 ** Money Loot
 ** Length: 22 Bytes
@@ -3600,11 +3625,11 @@ struct GuildMakeLeader {
 // Update a guild members rank and banker status
 struct GuildSetRank_Struct
 {
-/*00*/	uint32	GuildID;	// Was Unknown00
-/*04*/	uint32	Rank;
-/*08*/	char	MemberName[64];
-/*72*/	uint32	Banker;
-/*76*/	uint32	Unknown76;	// Seen 1 - Maybe Banker?
+/*00*/	uint32	guild_id;	// Was Unknown00
+/*04*/	uint32	rank;
+/*08*/	char	member_name[64];
+/*72*/	uint32	banker;
+/*76*/	uint32	unknown76;	// Seen 1 - Maybe Banker?
 /*80*/
 };
 
@@ -3619,7 +3644,7 @@ struct Make_Pet_Struct { //Simple struct for getting pet info
 	uint32 min_dmg;
 	uint32 max_dmg;
 };
-struct Ground_Spawn{
+struct GroundSpawn{
 	float max_x;
 	float max_y;
 	float min_x;
@@ -3631,8 +3656,8 @@ struct Ground_Spawn{
 	uint32 max_allowed;
 	uint32 respawntimer;
 };
-struct Ground_Spawns {
-	struct Ground_Spawn spawn[50]; //Assigned max number to allow
+struct GroundSpawns {
+	struct GroundSpawn spawn[50]; //Assigned max number to allow
 };
 
 //struct PetitionBug_Struct{
@@ -3722,15 +3747,15 @@ struct TributeItem_Struct
 
 struct TributePoint_Struct {
 	int32   tribute_points;
-	uint32   unknown04;
+	uint32  unknown04;
 	int32   career_tribute_points;
-	uint32   unknown12;
+	uint32  unknown12;
 };
 
 struct TributeMoney_Struct {
 	uint32   platinum;
 	uint32   tribute_master_id;
-	int32   tribute_points;
+	int32    tribute_points;
 };
 
 

common/patches/rof_structs.h

@@ -3537,11 +3537,11 @@ struct GuildMakeLeader {
 // Update a guild members rank and banker status
 struct GuildSetRank_Struct
 {
-/*00*/	uint32	GuildID;	// Was Unknown00
-/*04*/	uint32	Rank;
-/*08*/	char	MemberName[64];
-/*72*/	uint32	Banker;
-/*76*/	uint32	Unknown76;	// Seen 1 - Maybe Banker?
+/*00*/	uint32	guild_id;	// Was Unknown00
+/*04*/	uint32	rank;
+/*08*/	char	member_name[64];
+/*72*/	uint32	banker;
+/*76*/	uint32	unknown76;	// Seen 1 - Maybe Banker?
 /*80*/
 };
 
@@ -3556,7 +3556,7 @@ struct Make_Pet_Struct { //Simple struct for getting pet info
 	uint32 min_dmg;
 	uint32 max_dmg;
 };
-struct Ground_Spawn{
+struct GroundSpawn{
 	float max_x;
 	float max_y;
 	float min_x;
@@ -3568,8 +3568,8 @@ struct Ground_Spawn{
 	uint32 max_allowed;
 	uint32 respawntimer;
 };
-struct Ground_Spawns {
-	struct Ground_Spawn spawn[50]; //Assigned max number to allow
+struct GroundSpawns {
+	struct GroundSpawn spawn[50]; //Assigned max number to allow
 };
 
 //struct PetitionBug_Struct{

common/patches/sod.cpp

@@ -2507,8 +2507,8 @@ namespace SoD
 			}
 
 			float SpawnSize = emu->size;
-			if (!((emu->NPC == 0) || (emu->race <= RACE_GNOME_12) || (emu->race == RACE_IKSAR_128) ||
-					(emu->race == RACE_VAH_SHIR_130) || (emu->race == RACE_FROGLOK_330) || (emu->race == RACE_DRAKKIN_522))
+			if (!((emu->NPC == 0) || (emu->race <= Race::Gnome) || (emu->race == Race::Iksar) ||
+					(emu->race == Race::VahShir) || (emu->race == Race::Froglok2) || (emu->race == Race::Drakkin))
 				)
 			{
 				PacketSize -= (sizeof(structs::Texture_Struct) * EQ::textures::materialCount);
@@ -2706,8 +2706,8 @@ namespace SoD
 
 			Buffer += sizeof(structs::Spawn_Struct_Position);
 
-			if ((emu->NPC == 0) || (emu->race <= RACE_GNOME_12) || (emu->race == RACE_IKSAR_128) ||
-					(emu->race == RACE_VAH_SHIR_130) || (emu->race == RACE_FROGLOK_330) || (emu->race == RACE_DRAKKIN_522)
+			if ((emu->NPC == 0) || (emu->race <= Race::Gnome) || (emu->race == Race::Iksar) ||
+					(emu->race == Race::VahShir) || (emu->race == Race::Froglok2) || (emu->race == Race::Drakkin)
 				)
 			{
 				for (k = EQ::textures::textureBegin; k < EQ::textures::materialCount; ++k)
@@ -2733,8 +2733,8 @@ namespace SoD
 			}
 
 
-			if ((emu->NPC == 0) || (emu->race <= RACE_GNOME_12) || (emu->race == RACE_IKSAR_128) ||
-					(emu->race == RACE_VAH_SHIR_130) || (emu->race == RACE_FROGLOK_330) || (emu->race == RACE_DRAKKIN_522)
+			if ((emu->NPC == 0) || (emu->race <= Race::Gnome) || (emu->race == Race::Iksar) ||
+					(emu->race == Race::VahShir) || (emu->race == Race::Froglok2) || (emu->race == Race::Drakkin)
 				)
 			{
 				structs::Texture_Struct *Equipment = (structs::Texture_Struct *)Buffer;

common/patches/sod_structs.h

@@ -3026,7 +3026,7 @@ struct Make_Pet_Struct { //Simple struct for getting pet info
 	uint32 min_dmg;
 	uint32 max_dmg;
 };
-struct Ground_Spawn{
+struct GroundSpawn{
 	float max_x;
 	float max_y;
 	float min_x;
@@ -3038,8 +3038,8 @@ struct Ground_Spawn{
 	uint32 max_allowed;
 	uint32 respawntimer;
 };
-struct Ground_Spawns {
-	struct Ground_Spawn spawn[50]; //Assigned max number to allow
+struct GroundSpawns {
+	struct GroundSpawn spawn[50]; //Assigned max number to allow
 };
 
 //struct PetitionBug_Struct{

common/patches/sof_structs.h

@@ -2951,7 +2951,7 @@ struct Make_Pet_Struct { //Simple struct for getting pet info
 	uint32 min_dmg;
 	uint32 max_dmg;
 };
-struct Ground_Spawn{
+struct GroundSpawn{
 	float max_x;
 	float max_y;
 	float min_x;
@@ -2963,8 +2963,8 @@ struct Ground_Spawn{
 	uint32 max_allowed;
 	uint32 respawntimer;
 };
-struct Ground_Spawns {
-	struct Ground_Spawn spawn[50]; //Assigned max number to allow
+struct GroundSpawns {
+	struct GroundSpawn spawn[50]; //Assigned max number to allow
 };
 
 //struct PetitionBug_Struct{

common/patches/titanium.cpp

@@ -34,6 +34,7 @@
 #include "titanium_structs.h"
 #include "../path_manager.h"
 #include "../raid.h"
+#include "../guilds.h"
 
 #include <sstream>
 
@@ -664,6 +665,155 @@ namespace Titanium
 		dest->FastQueuePacket(&in, ack_req);
 	}
 
+	ENCODE(OP_SetGuildRank)
+	{
+		ENCODE_LENGTH_EXACT(GuildSetRank_Struct);
+		SETUP_DIRECT_ENCODE(GuildSetRank_Struct, structs::GuildSetRank_Struct);
+
+		eq->unknown00 = 0;
+		eq->unknown04 = 0;
+
+		//Translate older ranks to new values* /
+		switch (emu->rank) {
+			case GUILD_SENIOR_MEMBER:
+			case GUILD_MEMBER:
+			case GUILD_JUNIOR_MEMBER:
+			case GUILD_INITIATE:
+			case GUILD_RECRUIT: {
+				eq->rank = GUILD_MEMBER_TI;
+				break;
+			}
+			case GUILD_OFFICER:
+			case GUILD_SENIOR_OFFICER: {
+				eq->rank = GUILD_OFFICER_TI;
+				break;
+			}
+			case GUILD_LEADER: {
+				eq->rank = GUILD_LEADER_TI;
+				break;
+			}
+			default: {
+				eq->rank = GUILD_RANK_NONE_TI;
+				break;
+			}
+		}
+
+		memcpy(eq->member_name, emu->member_name, sizeof(eq->member_name));
+		OUT(banker);
+
+		FINISH_ENCODE();
+	}
+
+	ENCODE(OP_SpawnAppearance)
+	{
+		ENCODE_LENGTH_EXACT(SpawnAppearance_Struct);
+		SETUP_DIRECT_ENCODE(SpawnAppearance_Struct, structs::SpawnAppearance_Struct);
+
+		OUT(spawn_id);
+		OUT(type);
+		OUT(parameter);
+		switch (emu->type) {
+			case AppearanceType::GuildRank: {
+				//Translate new ranks to old values* /
+				switch (emu->parameter) {
+					case GUILD_SENIOR_MEMBER:
+					case GUILD_MEMBER:
+					case GUILD_JUNIOR_MEMBER:
+					case GUILD_INITIATE:
+					case GUILD_RECRUIT: {
+						eq->parameter = GUILD_MEMBER_TI;
+						break;
+					}
+					case GUILD_OFFICER:
+					case GUILD_SENIOR_OFFICER: {
+						eq->parameter = GUILD_OFFICER_TI;
+						break;
+					}
+					case GUILD_LEADER: {
+						eq->parameter = GUILD_LEADER_TI;
+						break;
+					}
+				}
+				break; 
+			}
+			case AppearanceType::GuildShow: {
+				FAIL_ENCODE();
+				return;
+			}
+			default: {
+				break;
+			}
+		}
+
+		FINISH_ENCODE();
+	}
+
+	ENCODE(OP_GuildMemberAdd)
+	{
+		ENCODE_LENGTH_EXACT(GuildMemberAdd_Struct)
+		SETUP_DIRECT_ENCODE(GuildMemberAdd_Struct, structs::GuildMemberAdd_Struct)
+
+		OUT(guild_id)
+		OUT(level)
+		OUT(class_)
+		switch (emu->rank_) {
+			case GUILD_SENIOR_MEMBER:
+			case GUILD_MEMBER:
+			case GUILD_JUNIOR_MEMBER:
+			case GUILD_INITIATE:
+			case GUILD_RECRUIT: {
+				eq->rank_ = GUILD_MEMBER_TI;
+				break;
+			}
+			case GUILD_OFFICER:
+			case GUILD_SENIOR_OFFICER: {
+				eq->rank_ = GUILD_OFFICER_TI;
+				break;
+			}
+			case GUILD_LEADER: {
+				eq->rank_ = GUILD_LEADER_TI;
+				break;
+			}
+		}
+		OUT(zone_id)
+		OUT(last_on)
+		OUT_str(player_name)
+
+		FINISH_ENCODE()
+	}
+
+	ENCODE(OP_GuildMemberRankAltBanker)
+	{
+		ENCODE_LENGTH_EXACT(GuildMemberRank_Struct)
+		SETUP_DIRECT_ENCODE(GuildMemberRank_Struct, structs::GuildMemberRank_Struct)
+
+		OUT(guild_id)
+		OUT(alt_banker)
+		OUT_str(player_name)
+
+		switch (emu->rank_) {
+			case GUILD_SENIOR_MEMBER:
+			case GUILD_MEMBER:
+			case GUILD_JUNIOR_MEMBER:
+			case GUILD_INITIATE:
+			case GUILD_RECRUIT: {
+				eq->rank_ = GUILD_MEMBER_TI;
+				break;
+			}
+			case GUILD_OFFICER:
+			case GUILD_SENIOR_OFFICER: {
+				eq->rank_ = GUILD_OFFICER_TI;
+				break;
+			}
+			case GUILD_LEADER: {
+				eq->rank_ = GUILD_LEADER_TI;
+				break;
+			}
+		}
+
+		FINISH_ENCODE()
+	}
+
 	ENCODE(OP_GuildMemberList)
 	{
 		//consume the packet
@@ -727,12 +877,34 @@ namespace Titanium
 				str += sl + 1; \
 			}
 #define PutFieldN(field) e->field = htonl(emu_e->field)
-
+				/* Translate new ranks to older values */
 				SlideStructString(name, emu_name);
 				PutFieldN(level);
 				PutFieldN(banker);
 				PutFieldN(class_);
-				PutFieldN(rank);
+				switch (emu_e->rank) {
+					case GUILD_SENIOR_MEMBER:
+					case GUILD_MEMBER:
+					case GUILD_JUNIOR_MEMBER:
+					case GUILD_INITIATE:
+					case GUILD_RECRUIT: {
+						e->rank = htonl(GUILD_MEMBER_TI);
+						break;
+					}
+					case GUILD_OFFICER:
+					case GUILD_SENIOR_OFFICER: {
+						e->rank = htonl(GUILD_OFFICER_TI);
+						break;
+					}
+					case GUILD_LEADER: {
+						e->rank = htonl(GUILD_LEADER_TI);
+						break;
+					}
+					default: {
+						e->rank = htonl(GUILD_MEMBER_TI);
+						break;
+					}
+				}
 				PutFieldN(time_last_on);
 				PutFieldN(tribute_enable);
 				PutFieldN(total_tribute);
@@ -753,6 +925,38 @@ namespace Titanium
 		dest->FastQueuePacket(&in, ack_req);
 	}
 
+	ENCODE(OP_SendGuildTributes)
+	{
+		ENCODE_LENGTH_ATLEAST(structs::GuildTributeAbility_Struct);
+		SETUP_VAR_ENCODE(GuildTributeAbility_Struct);
+		ALLOC_VAR_ENCODE(structs::GuildTributeAbility_Struct, sizeof(GuildTributeAbility_Struct) + strlen(emu->ability.name));
+
+		eq->guild_id = emu->guild_id;;
+		strncpy(eq->ability.name, emu->ability.name, strlen(emu->ability.name));
+		eq->ability.tribute_id = emu->ability.tribute_id;
+		eq->ability.tier_count = emu->ability.tier_count;
+		for (int i = 0; i < ntohl(emu->ability.tier_count); i++) {
+			eq->ability.tiers[i].cost = emu->ability.tiers[i].cost;
+			eq->ability.tiers[i].level = emu->ability.tiers[i].level;
+			eq->ability.tiers[i].tribute_item_id = emu->ability.tiers[i].tribute_item_id;
+		}
+		FINISH_ENCODE();
+	}
+
+	ENCODE(OP_GuildTributeDonateItem)
+	{
+		SETUP_DIRECT_ENCODE(GuildTributeDonateItemReply_Struct, structs::GuildTributeDonateItemReply_Struct);
+
+		Log(Logs::Detail, Logs::Netcode, "UF::ENCODE(OP_GuildTributeDonateItem)");
+
+		OUT(quantity);
+		OUT(favor);
+		eq->unknown8 = 0;
+		eq->slot = ServerToTitaniumSlot(emu->slot);
+
+		FINISH_ENCODE();
+	}
+
 	ENCODE(OP_Illusion)
 	{
 		ENCODE_LENGTH_EXACT(Illusion_Struct);
@@ -867,11 +1071,60 @@ namespace Titanium
 
 	ENCODE(OP_LFGuild)
 	{
+		struct bit_mask_conversion {
+			uint32	titanium_mask;
+			uint32	rof2_mask;
+		};
+
+		std::vector<bit_mask_conversion> bit_mask = {
+			{.titanium_mask = 2, .rof2_mask = 256},
+			{.titanium_mask = 4, .rof2_mask = 32768},
+			{.titanium_mask = 8, .rof2_mask = 65536},
+			{.titanium_mask = 16, .rof2_mask = 4},
+			{.titanium_mask = 32, .rof2_mask = 64},
+			{.titanium_mask = 64, .rof2_mask = 16384},
+			{.titanium_mask = 128, .rof2_mask = 8192},
+			{.titanium_mask = 256, .rof2_mask = 128},
+			{.titanium_mask = 512, .rof2_mask = 2048},
+			{.titanium_mask = 1024, .rof2_mask = 8},
+			{.titanium_mask = 2048, .rof2_mask = 16},
+			{.titanium_mask = 4096, .rof2_mask = 512},
+			{.titanium_mask = 8192, .rof2_mask = 32},
+			{.titanium_mask = 16384, .rof2_mask = 1024},
+			{.titanium_mask = 32768, .rof2_mask = 2},
+			{.titanium_mask = 65536, .rof2_mask = 4096},
+		};
+
 		EQApplicationPacket *in = *p;
-		*p = nullptr;
 
 		uint32 Command = in->ReadUInt32();
 
+		if (Command == 1) {
+			ENCODE_LENGTH_EXACT(LFGuild_GuildToggle_Struct);
+			SETUP_DIRECT_ENCODE(LFGuild_GuildToggle_Struct, structs::LFGuild_GuildToggle_Struct);
+
+			OUT(Command);
+			OUT_str(Comment);
+			OUT(FromLevel);
+			OUT(ToLevel);
+			OUT(AACount);
+			OUT(TimeZone);
+			OUT(Toggle);
+			OUT(TimePosted);
+			OUT_str(Name);
+
+			uint32 emu_bitmask = emu->Classes;
+			uint32 ti_bitmask = 0;
+			for (auto const& b : bit_mask) {
+				(emu_bitmask & b.rof2_mask) != 0 ? ti_bitmask |= b.titanium_mask : ti_bitmask &= ~b.titanium_mask;
+			}
+			eq->Classes = ti_bitmask;
+
+			FINISH_ENCODE();
+			return;
+		}
+
+		*p = nullptr;
 		if (Command != 0)
 		{
 			dest->FastQueuePacket(&in, ack_req);
@@ -1149,7 +1402,29 @@ namespace Titanium
 		OUT(pvp);
 		OUT(anon);
 		OUT(gm);
-		OUT(guildrank);
+		switch (emu->guildrank) {
+			case GUILD_SENIOR_MEMBER:
+			case GUILD_MEMBER:
+			case GUILD_JUNIOR_MEMBER:
+			case GUILD_INITIATE:
+			case GUILD_RECRUIT: {
+				eq->guildrank = GUILD_MEMBER_TI;
+				break;
+			}
+			case GUILD_OFFICER:
+			case GUILD_SENIOR_OFFICER: {
+				eq->guildrank = GUILD_OFFICER_TI;
+				break;
+			}
+			case GUILD_LEADER: {
+				eq->guildrank = GUILD_LEADER_TI;
+				break;
+			}
+			default: {
+				eq->guildrank = GUILD_RANK_NONE_TI;
+				break;
+			}
+		}
 		OUT(guildbanker);
 		//	OUT(unknown13054[8]);
 		OUT(exp);
@@ -1250,7 +1525,7 @@ namespace Titanium
 	{
 		ENCODE_LENGTH_EXACT(MarkNPC_Struct);
 		SETUP_DIRECT_ENCODE(MarkNPC_Struct, MarkNPC_Struct);
-	
+
 		EQApplicationPacket* outapp = new EQApplicationPacket(OP_MarkNPC, sizeof(MarkNPC_Struct));
 		MarkNPC_Struct* mnpcs = (MarkNPC_Struct*)outapp->pBuffer;
 		mnpcs->TargetID = emu->TargetID;
@@ -1267,10 +1542,10 @@ namespace Titanium
 		*p = nullptr;
 		unsigned char* __emu_buffer = inapp->pBuffer;
 		RaidGeneral_Struct* raid_gen = (RaidGeneral_Struct*)__emu_buffer;
-		
+
 		switch (raid_gen->action)
 		{
-		case raidAdd: 
+		case raidAdd:
 		{
 			RaidAddMember_Struct* emu = (RaidAddMember_Struct*)__emu_buffer;
 
@@ -1340,7 +1615,7 @@ namespace Titanium
 			dest->QueuePacket(inapp);
 			break;
 		}
-		default: 
+		default:
 		{
 			RaidGeneral_Struct* emu = (RaidGeneral_Struct*)__emu_buffer;
 
@@ -1864,7 +2139,28 @@ namespace Titanium
 			eq->beard = emu->beard;
 			strcpy(eq->suffix, emu->suffix);
 			eq->petOwnerId = emu->petOwnerId;
-			eq->guildrank = emu->guildrank;
+			switch (emu->guildrank) {
+				case GUILD_SENIOR_MEMBER:
+				case GUILD_MEMBER:
+				case GUILD_JUNIOR_MEMBER:
+				case GUILD_INITIATE:
+				case GUILD_RECRUIT: {
+					eq->guildrank = GUILD_MEMBER_TI;
+					break;
+				}
+				case GUILD_OFFICER:
+				case GUILD_SENIOR_OFFICER: {
+					eq->guildrank = GUILD_OFFICER_TI;
+					break;
+				}
+				case GUILD_LEADER: {
+					eq->guildrank = GUILD_LEADER_TI;
+					break;
+				}
+				default: {
+					break;
+				}
+			}
 			//		eq->unknown0194[3] = emu->unknown0194[3];
 			for (k = EQ::textures::textureBegin; k < EQ::textures::materialCount; k++) {
 				eq->equipment.Slot[k].Material = emu->equipment.Slot[k].Material;
@@ -2205,6 +2501,34 @@ namespace Titanium
 		FINISH_DIRECT_DECODE();
 	}
 
+	DECODE(OP_GuildDemote)
+	{
+		DECODE_LENGTH_EXACT(structs::GuildDemoteStruct);
+		SETUP_DIRECT_DECODE(GuildDemoteStruct, structs::GuildDemoteStruct);
+
+		memcpy(emu->name, eq->name, sizeof(emu->name));
+		memcpy(emu->target, eq->target, sizeof(emu->target));
+		emu->rank = GUILD_MEMBER;
+
+		FINISH_DIRECT_DECODE();
+	}
+
+	DECODE(OP_GuildTributeDonateItem)
+	{
+		DECODE_LENGTH_EXACT(structs::GuildTributeDonateItemRequest_Struct);
+		SETUP_DIRECT_DECODE(GuildTributeDonateItemRequest_Struct, structs::GuildTributeDonateItemRequest_Struct);
+
+		Log(Logs::Detail, Logs::Netcode, "UF::DECODE(OP_GuildTributeDonateItem)");
+
+		IN(quantity);
+		IN(tribute_master_id);
+		IN(guild_id);
+
+		emu->slot = TitaniumToServerSlot(eq->slot);
+
+		FINISH_DIRECT_DECODE();
+	}
+
 	DECODE(OP_InspectAnswer)
 	{
 		DECODE_LENGTH_EXACT(structs::InspectResponse_Struct);
@@ -2260,8 +2584,77 @@ namespace Titanium
 
 	DECODE(OP_LFGuild)
 	{
+		struct bit_mask_conversion {
+			uint32	titanium_mask;
+			uint32	rof2_mask;
+		};
+
+		std::vector<bit_mask_conversion> bit_mask = {
+			{.titanium_mask = 2, .rof2_mask = 256},
+			{.titanium_mask = 4, .rof2_mask = 32768},
+			{.titanium_mask = 8, .rof2_mask = 65536},
+			{.titanium_mask = 16, .rof2_mask = 4},
+			{.titanium_mask = 32, .rof2_mask = 64},
+			{.titanium_mask = 64, .rof2_mask = 16384},
+			{.titanium_mask = 128, .rof2_mask = 8192},
+			{.titanium_mask = 256, .rof2_mask = 128},
+			{.titanium_mask = 512, .rof2_mask = 2048},
+			{.titanium_mask = 1024, .rof2_mask = 8},
+			{.titanium_mask = 2048, .rof2_mask = 16},
+			{.titanium_mask = 4096, .rof2_mask = 512},
+			{.titanium_mask = 8192, .rof2_mask = 32},
+			{.titanium_mask = 16384, .rof2_mask = 1024},
+			{.titanium_mask = 32768, .rof2_mask = 2},
+			{.titanium_mask = 65536, .rof2_mask = 4096},
+		};
+
 		uint32 Command = __packet->ReadUInt32();
 
+		if (Command == 3) {
+			DECODE_LENGTH_EXACT(structs::LFGuild_SearchPlayer_Struct);
+			SETUP_DIRECT_DECODE(LFGuild_SearchPlayer_Struct, structs::LFGuild_SearchPlayer_Struct);
+
+			IN(Command);
+			IN(Unknown04);
+			IN(FromLevel);
+			IN(ToLevel);
+			IN(MinAA);
+			IN(TimeZone);
+
+			uint32 new_bitmask = 0;
+			uint32 ti_bitmask = eq->Classes;
+			for (auto const& b : bit_mask) {
+				(ti_bitmask & b.titanium_mask) != 0 ? new_bitmask |= b.rof2_mask : new_bitmask &= ~b.rof2_mask;
+			}
+			emu->Classes = new_bitmask;
+			FINISH_DIRECT_DECODE();
+			return;
+		}
+
+		if (Command == 1) {
+			DECODE_LENGTH_EXACT(structs::LFGuild_GuildToggle_Struct);
+			SETUP_DIRECT_DECODE(LFGuild_GuildToggle_Struct, structs::LFGuild_GuildToggle_Struct);
+
+			IN(Command);
+			IN_str(Comment);
+			IN(FromLevel);
+			IN(ToLevel);
+			IN(AACount);
+			IN(TimeZone);
+			IN(Toggle);
+			IN(TimePosted);
+			IN_str(Name);
+
+			uint32 new_bitmask = 0;
+			uint32 ti_bitmask = eq->Classes;
+			for (auto const& b : bit_mask) {
+				(ti_bitmask & b.titanium_mask) != 0 ? new_bitmask |= b.rof2_mask : new_bitmask &= ~b.rof2_mask;
+			}
+			emu->Classes = new_bitmask;
+			FINISH_DIRECT_DECODE();
+			return;
+		}
+
 		if (Command != 0)
 			return;
 
@@ -2401,7 +2794,7 @@ namespace Titanium
 			IN(general.parameter);
 			IN_str(general.leader_name);
 			IN_str(general.player_name);
-			
+
 			auto len = 0;
 			if (__packet->size < sizeof(structs::RaidMOTD_Struct)) {
 				len = __packet->size - sizeof(structs::RaidGeneral_Struct);
@@ -2409,8 +2802,8 @@ namespace Titanium
 			else {
 				len = sizeof(eq->motd);
 			}
-			
-			strn0cpy(emu->motd, eq->motd, len > 1024 ? 1024 : len); 
+
+			strn0cpy(emu->motd, eq->motd, len > 1024 ? 1024 : len);
 			emu->motd[len - 1] = '\0';
 
 			FINISH_VAR_DECODE();
@@ -2428,7 +2821,7 @@ namespace Titanium
 
 			FINISH_VAR_DECODE();
 			break;
-		}		
+		}
 		default:
 		{
 			SETUP_DIRECT_DECODE(RaidGeneral_Struct, structs::RaidGeneral_Struct);

common/patches/titanium_ops.h

@@ -44,8 +44,13 @@ E(OP_DzSetLeaderName)
 E(OP_Emote)
 E(OP_FormattedMessage)
 E(OP_GroundSpawn)
+E(OP_SetGuildRank)
 E(OP_GuildMemberLevelUpdate)
 E(OP_GuildMemberList)
+E(OP_GuildMemberAdd)
+E(OP_GuildMemberRankAltBanker)
+E(OP_SendGuildTributes)
+E(OP_GuildTributeDonateItem)
 E(OP_Illusion)
 E(OP_InspectAnswer)
 E(OP_InspectRequest)
@@ -69,6 +74,7 @@ E(OP_SendCharInfo)
 E(OP_SendAATable)
 E(OP_SetFace)
 E(OP_ShopPlayerSell)
+E(OP_SpawnAppearance)
 E(OP_SpecialMesg)
 E(OP_TaskDescription)
 E(OP_Track)
@@ -100,9 +106,11 @@ D(OP_DzRemovePlayer)
 D(OP_DzSwapPlayer)
 D(OP_Emote)
 D(OP_FaceChange)
+D(OP_GuildDemote)
 D(OP_InspectAnswer)
 D(OP_InspectRequest)
 D(OP_ItemLinkClick)
+D(OP_GuildTributeDonateItem)
 D(OP_LFGuild)
 D(OP_LoadSpellSet)
 D(OP_LootItem)

common/patches/titanium_structs.h

@@ -1,5 +1,5 @@
 /*	EQEMu: Everquest Server Emulator
-	
+
 	Copyright (C) 2001-2016 EQEMu Development Team (http://eqemulator.net)
 
 	This program is free software; you can redistribute it and/or modify
@@ -1423,6 +1423,23 @@ struct GuildUpdate_Struct {
 	GuildsListEntry_Struct entry;
 };
 
+struct GuildTributeDonateItemRequest_Struct {
+	/*000*/ uint32 	slot;
+	/*004*/ uint32 	quantity;
+	/*008*/ uint32	tribute_master_id;
+	/*012*/ uint32 	unknown12;
+	/*016*/ uint32	guild_id;
+	/*020*/ uint32 	unknown20;
+	/*024*/ uint32	unknown24;
+};
+
+struct GuildTributeDonateItemReply_Struct {
+	/*000*/ uint32	slot;
+	/*004*/ uint32	quantity;
+	/*008*/ uint32	unknown8;
+	/*012*/	uint32	favor;
+};
+
 /*
 ** Money Loot
 ** Length: 22 Bytes
@@ -2604,7 +2621,7 @@ struct Make_Pet_Struct { //Simple struct for getting pet info
 	uint32 min_dmg;
 	uint32 max_dmg;
 };
-struct Ground_Spawn{
+struct GroundSpawn{
 	float max_x;
 	float max_y;
 	float min_x;
@@ -2616,8 +2633,8 @@ struct Ground_Spawn{
 	uint32 max_allowed;
 	uint32 respawntimer;
 };
-struct Ground_Spawns {
-	struct Ground_Spawn spawn[50]; //Assigned max number to allow
+struct GroundSpawns {
+	struct GroundSpawn spawn[50]; //Assigned max number to allow
 };
 
 //struct PetitionBug_Struct{
@@ -3508,7 +3525,7 @@ struct LFGuild_GuildToggle_Struct
 /*540*/ uint32	TimeZone;
 /*544*/ uint8	Toggle;
 /*545*/ uint8	Unknown545[3];
-/*548*/ uint32	Expires;
+/*548*/ uint32	TimePosted;
 /*552*/ char	Name[64];
 /*616*/
 };
@@ -3699,6 +3716,34 @@ struct SayLinkBodyFrame_Struct {
 /*045*/
 };
 
+struct GuildSetRank_Struct
+{
+	/*00*/	uint32	unknown00;
+	/*04*/	uint32	unknown04;
+	/*08*/	uint32	rank;
+	/*72*/	char	member_name[64];
+	/*76*/	uint32	banker;
+};
+
+struct GuildMemberAdd_Struct {
+	/*000*/ uint32 guild_id;
+	/*004*/ uint32 unknown04;
+	/*008*/ uint32 level;
+	/*012*/ uint32 class_;
+	/*016*/ uint32 rank_;
+	/*020*/ uint32 zone_id;
+	/*024*/ uint32 last_on;
+	/*028*/ char   player_name[64];
+};
+
+struct GuildMemberRank_Struct {
+	/*000*/ uint32 guild_id;
+	/*004*/ uint32 unknown_004;
+	/*008*/ uint32 rank_;
+	/*012*/ char   player_name[64];
+	/*076*/ uint32 alt_banker; //Banker/Alt bit 00 - none 10 - Alt 11 - Alt and Banker 01 - Banker.  Banker not functional for RoF2+
+};
+
 	}; /*structs*/
 
 }; /*Titanium*/

common/patches/uf.cpp

@@ -36,6 +36,7 @@
 #include "../classes.h"
 #include "../races.h"
 #include "../raid.h"
+#include "../guilds.h"
 
 #include <iostream>
 #include <sstream>
@@ -195,7 +196,7 @@ namespace UF
 		unsigned char *emu_buffer = in->pBuffer;
 		uint32 opcode = *((uint32*)emu_buffer);
 
-		if (opcode == 8) {
+		if (opcode == AlternateCurrencyMode::Populate) {
 			AltCurrencyPopulate_Struct *populate = (AltCurrencyPopulate_Struct*)emu_buffer;
 
 			auto outapp = new EQApplicationPacket(
@@ -1134,6 +1135,30 @@ namespace UF
 				PutFieldN(level);
 				PutFieldN(banker);
 				PutFieldN(class_);
+				//Translate older ranks to new values* /
+				switch (emu_e->rank) {
+					case GUILD_SENIOR_MEMBER:
+					case GUILD_MEMBER:
+					case GUILD_JUNIOR_MEMBER:
+					case GUILD_INITIATE:
+					case GUILD_RECRUIT: {
+						emu_e->rank = GUILD_MEMBER_TI;
+						break;
+					}
+					case GUILD_OFFICER:
+					case GUILD_SENIOR_OFFICER: {
+						emu_e->rank = GUILD_OFFICER_TI;
+						break;
+					}
+					case GUILD_LEADER: {
+						emu_e->rank = GUILD_LEADER_TI;
+						break;
+					}
+					default: {
+						emu_e->rank = GUILD_RANK_NONE_TI;
+						break;
+					}
+				}
 				PutFieldN(rank);
 				PutFieldN(time_last_on);
 				PutFieldN(tribute_enable);
@@ -1165,14 +1190,14 @@ namespace UF
 
 		unsigned char *__emu_buffer = in->pBuffer;
 		char *InBuffer = (char *)__emu_buffer;
-		uint32 HighestGuildID = 0;
+		uint32 actual_no_guilds = 0;
 
 		for (unsigned int i = 0; i < NumberOfGuilds; ++i)
 		{
 			if (InBuffer[0])
 			{
 				PacketSize += (5 + strlen(InBuffer));
-				HighestGuildID = i - 1;
+                actual_no_guilds++;
 			}
 			InBuffer += 64;
 		}
@@ -1188,7 +1213,7 @@ namespace UF
 		memset(OutBuffer, 0, 64);
 		OutBuffer += 64;
 
-		VARSTRUCT_ENCODE_TYPE(uint32, OutBuffer, HighestGuildID);
+		VARSTRUCT_ENCODE_TYPE(uint32, OutBuffer, actual_no_guilds);
 
 		for (unsigned int i = 0; i < NumberOfGuilds; ++i)
 		{
@@ -1206,6 +1231,111 @@ namespace UF
 		dest->FastQueuePacket(&in, ack_req);
 	}
 
+	ENCODE(OP_GuildMemberAdd)
+	{
+		ENCODE_LENGTH_EXACT(GuildMemberAdd_Struct)
+		SETUP_DIRECT_ENCODE(GuildMemberAdd_Struct, structs::GuildMemberAdd_Struct)
+
+		OUT(guild_id)
+		OUT(level)
+		OUT(class_)
+		switch (emu->rank_) {
+			case GUILD_SENIOR_MEMBER:
+			case GUILD_MEMBER:
+			case GUILD_JUNIOR_MEMBER:
+			case GUILD_INITIATE:
+			case GUILD_RECRUIT: {
+				eq->rank_ = GUILD_MEMBER_TI;
+				break;
+			}
+			case GUILD_OFFICER:
+			case GUILD_SENIOR_OFFICER: {
+				eq->rank_ = GUILD_OFFICER_TI;
+				break;
+			}
+			case GUILD_LEADER: {
+				eq->rank_ = GUILD_LEADER_TI;
+				break;
+			}
+			default: {
+				eq->rank_ = GUILD_RANK_NONE_TI;
+				break;
+			}
+		}
+		OUT(zone_id)
+		OUT(last_on)
+		OUT_str(player_name)
+
+		FINISH_ENCODE()
+	}
+
+	ENCODE(OP_GuildMemberRankAltBanker)
+	{
+		ENCODE_LENGTH_EXACT(GuildMemberRank_Struct)
+		SETUP_DIRECT_ENCODE(GuildMemberRank_Struct, structs::GuildMemberRank_Struct)
+
+		OUT(guild_id)
+		OUT(alt_banker)
+		OUT_str(player_name)
+
+		switch (emu->rank_) {
+			case GUILD_SENIOR_MEMBER:
+			case GUILD_MEMBER:
+			case GUILD_JUNIOR_MEMBER:
+			case GUILD_INITIATE:
+			case GUILD_RECRUIT: {
+				eq->rank_ = GUILD_MEMBER_TI;
+				break;
+			}
+			case GUILD_OFFICER:
+			case GUILD_SENIOR_OFFICER: {
+				eq->rank_ = GUILD_OFFICER_TI;
+				break;
+			}
+			case GUILD_LEADER: {
+				eq->rank_ = GUILD_LEADER_TI;
+				break;
+			}
+			default: {
+				eq->rank_ = GUILD_RANK_NONE_TI;
+				break;
+			}
+		}
+		FINISH_ENCODE()
+	}
+
+	ENCODE(OP_SendGuildTributes)
+	{
+		ENCODE_LENGTH_ATLEAST(structs::GuildTributeAbility_Struct)
+		SETUP_VAR_ENCODE(GuildTributeAbility_Struct)
+		ALLOC_VAR_ENCODE(structs::GuildTributeAbility_Struct, sizeof(GuildTributeAbility_Struct) + strlen(emu->ability.name))
+
+		eq->guild_id           = emu->guild_id;
+		eq->ability.tribute_id = emu->ability.tribute_id;
+		eq->ability.tier_count = emu->ability.tier_count;
+		strncpy(eq->ability.name, emu->ability.name, strlen(emu->ability.name));
+		for (int i = 0; i < ntohl(emu->ability.tier_count); i++) {
+			eq->ability.tiers[i].cost            = emu->ability.tiers[i].cost;
+			eq->ability.tiers[i].level           = emu->ability.tiers[i].level;
+			eq->ability.tiers[i].tribute_item_id = emu->ability.tiers[i].tribute_item_id;
+		}
+		FINISH_ENCODE()
+	}
+
+	ENCODE(OP_GuildTributeDonateItem)
+	{
+		SETUP_DIRECT_ENCODE(GuildTributeDonateItemReply_Struct, structs::GuildTributeDonateItemReply_Struct);
+
+		Log(Logs::Detail, Logs::Netcode, "UF::ENCODE(OP_GuildTributeDonateItem)");
+
+		OUT(quantity)
+		OUT(favor)
+		eq->unknown8 = 0;
+		eq->slot     = ServerToUFSlot(emu->slot);
+
+		FINISH_ENCODE()
+	}
+
 	ENCODE(OP_Illusion)
 	{
 		ENCODE_LENGTH_EXACT(Illusion_Struct);
@@ -1829,6 +1959,30 @@ namespace UF
 		OUT(pvp);
 		OUT(anon);
 		OUT(gm);
+		//Translate older ranks to new values* /
+		switch (emu->guildrank) {
+			case GUILD_SENIOR_MEMBER:
+			case GUILD_MEMBER:
+			case GUILD_JUNIOR_MEMBER:
+			case GUILD_INITIATE:
+			case GUILD_RECRUIT: {
+				emu->guildrank = GUILD_MEMBER_TI;
+				break;
+			}
+			case GUILD_OFFICER:
+			case GUILD_SENIOR_OFFICER: {
+				emu->guildrank = GUILD_OFFICER_TI;
+				break;
+			}
+			case GUILD_LEADER: {
+				emu->guildrank = GUILD_LEADER_TI;
+				break;
+			}
+			default: {
+				emu->guildrank = GUILD_RANK_NONE_TI;
+				break;
+			}
+		}
 		OUT(guildrank);
 		OUT(guildbanker);
 		//	OUT(unknown13054[12]);
@@ -2332,29 +2486,88 @@ namespace UF
 
 	ENCODE(OP_SpawnAppearance)
 	{
-		EQApplicationPacket *in = *p;
-		*p = nullptr;
+		ENCODE_LENGTH_EXACT(SpawnAppearance_Struct);
+		SETUP_DIRECT_ENCODE(SpawnAppearance_Struct, structs::SpawnAppearance_Struct);
 
-		unsigned char *emu_buffer = in->pBuffer;
-
-		SpawnAppearance_Struct *sas = (SpawnAppearance_Struct *)emu_buffer;
-
-		if (sas->type != AT_Size)
-		{
-			dest->FastQueuePacket(&in, ack_req);
-			return;
+		OUT(spawn_id);
+		OUT(type);
+		OUT(parameter);
+		switch (emu->type) {
+			case AppearanceType::GuildRank: {
+				//Translate new ranks to old values* /
+				switch (emu->parameter) {
+					case GUILD_SENIOR_MEMBER:
+					case GUILD_MEMBER:
+					case GUILD_JUNIOR_MEMBER:
+					case GUILD_INITIATE:
+					case GUILD_RECRUIT: {
+						eq->parameter = GUILD_MEMBER_TI;
+						break;
+					}
+					case GUILD_OFFICER:
+					case GUILD_SENIOR_OFFICER: {
+						eq->parameter = GUILD_OFFICER_TI;
+						break;
+					}
+					case GUILD_LEADER: {
+						eq->parameter = GUILD_LEADER_TI;
+						break;
+					}
+					default: {
+						eq->parameter = GUILD_RANK_NONE_TI;
+						break;
+					}
+				}
+				break;
+			}
+			case AppearanceType::GuildShow: {
+				FAIL_ENCODE();
+				return;
+			}
+			default: {
+				break;
+			}
 		}
 
-		auto outapp = new EQApplicationPacket(OP_ChangeSize, sizeof(ChangeSize_Struct));
-		ChangeSize_Struct *css = (ChangeSize_Struct *)outapp->pBuffer;
+		FINISH_ENCODE();
+	}
 
-		css->EntityID = sas->spawn_id;
-		css->Size = (float)sas->parameter;
-		css->Unknown08 = 0;
-		css->Unknown12 = 1.0f;
+	ENCODE(OP_SetGuildRank)
+	{
+		ENCODE_LENGTH_EXACT(GuildSetRank_Struct);
+		SETUP_DIRECT_ENCODE(GuildSetRank_Struct, structs::GuildSetRank_Struct);
 
-		dest->FastQueuePacket(&outapp, ack_req);
-		delete in;
+		eq->unknown00 = 0;
+		eq->unknown04 = 0;
+
+		switch (emu->rank) {
+			case GUILD_SENIOR_MEMBER:
+			case GUILD_MEMBER:
+			case GUILD_JUNIOR_MEMBER:
+			case GUILD_INITIATE:
+			case GUILD_RECRUIT: {
+				emu->rank = GUILD_MEMBER_TI;
+				break;
+			}
+			case GUILD_OFFICER:
+			case GUILD_SENIOR_OFFICER: {
+				emu->rank = GUILD_OFFICER_TI;
+				break;
+			}
+			case GUILD_LEADER: {
+				emu->rank = GUILD_LEADER_TI;
+				break;
+			}
+			default: {
+				emu->rank = GUILD_RANK_NONE_TI;
+				break;
+			}
+		}
+
+		memcpy(eq->member_name, emu->member_name, sizeof(eq->member_name));
+		OUT(banker);
+
+		FINISH_ENCODE();
 	}
 
 	ENCODE(OP_SpawnDoor)
@@ -2779,8 +2992,8 @@ namespace UF
 			}
 
 			float SpawnSize = emu->size;
-			if (!((emu->NPC == 0) || (emu->race <= RACE_GNOME_12) || (emu->race == RACE_IKSAR_128) ||
-					(emu->race == RACE_VAH_SHIR_130) || (emu->race == RACE_FROGLOK_330) || (emu->race == RACE_DRAKKIN_522))
+			if (!((emu->NPC == 0) || (emu->race <= Race::Gnome) || (emu->race == Race::Iksar) ||
+					(emu->race == Race::VahShir) || (emu->race == Race::Froglok2) || (emu->race == Race::Drakkin))
 				)
 			{
 				PacketSize -= (sizeof(structs::Texture_Struct) * EQ::textures::materialCount);
@@ -2945,6 +3158,30 @@ namespace UF
 			else
 			{
 				VARSTRUCT_ENCODE_TYPE(uint32, Buffer, emu->guildID);
+				//Translate older ranks to new values* /
+				switch (emu->guildrank) {
+					case GUILD_SENIOR_MEMBER:
+					case GUILD_MEMBER:
+					case GUILD_JUNIOR_MEMBER:
+					case GUILD_INITIATE:
+					case GUILD_RECRUIT: {
+						emu->guildrank = GUILD_MEMBER_TI;
+						break;
+					}
+					case GUILD_OFFICER:
+					case GUILD_SENIOR_OFFICER: {
+						emu->guildrank = GUILD_OFFICER_TI;
+						break;
+					}
+					case GUILD_LEADER: {
+						emu->guildrank = GUILD_LEADER_TI;
+						break;
+					}
+					default: {
+						emu->guildrank = GUILD_RANK_NONE_TI;
+						break;
+					}
+				}
 				VARSTRUCT_ENCODE_TYPE(uint32, Buffer, emu->guildrank);
 			}
 			VARSTRUCT_ENCODE_TYPE(uint8, Buffer, emu->class_);
@@ -2982,8 +3219,8 @@ namespace UF
 
 			Buffer += sizeof(structs::Spawn_Struct_Position);
 
-			if ((emu->NPC == 0) || (emu->race <= RACE_GNOME_12) || (emu->race == RACE_IKSAR_128) ||
-					(emu->race == RACE_VAH_SHIR_130) || (emu->race == RACE_FROGLOK_330) || (emu->race == RACE_DRAKKIN_522)
+			if ((emu->NPC == 0) || (emu->race <= Race::Gnome) || (emu->race == Race::Iksar) ||
+					(emu->race == Race::VahShir) || (emu->race == Race::Froglok2) || (emu->race == Race::Drakkin)
 				)
 			{
 				for (k = EQ::textures::textureBegin; k < EQ::textures::materialCount; ++k)
@@ -3018,8 +3255,8 @@ namespace UF
 				VARSTRUCT_ENCODE_TYPE(uint32, Buffer, 0);
 			}
 
-			if ((emu->NPC == 0) || (emu->race <= RACE_GNOME_12) || (emu->race == RACE_IKSAR_128) ||
-					(emu->race == RACE_VAH_SHIR_130) || (emu->race == RACE_FROGLOK_330) || (emu->race == RACE_DRAKKIN_522)
+			if ((emu->NPC == 0) || (emu->race <= Race::Gnome) || (emu->race == Race::Iksar) ||
+					(emu->race == Race::VahShir) || (emu->race == Race::Froglok2) || (emu->race == Race::Drakkin)
 				)
 			{
 				structs::Texture_Struct *Equipment = (structs::Texture_Struct *)Buffer;
@@ -3577,6 +3814,34 @@ namespace UF
 		DECODE_FORWARD(OP_GroupInvite);
 	}
 
+	DECODE(OP_GuildDemote)
+	{
+		DECODE_LENGTH_EXACT(structs::GuildDemoteStruct);
+		SETUP_DIRECT_DECODE(GuildDemoteStruct, structs::GuildDemoteStruct);
+
+		memcpy(emu->name, eq->name, sizeof(emu->name));
+		memcpy(emu->target, eq->target, sizeof(emu->target));
+		emu->rank = GUILD_MEMBER;
+
+		FINISH_DIRECT_DECODE();
+	}
+
+	DECODE(OP_GuildTributeDonateItem)
+	{
+		DECODE_LENGTH_EXACT(structs::GuildTributeDonateItemRequest_Struct);
+		SETUP_DIRECT_DECODE(GuildTributeDonateItemRequest_Struct, structs::GuildTributeDonateItemRequest_Struct);
+
+		Log(Logs::Detail, Logs::Netcode, "UF::DECODE(OP_GuildTributeDonateItem)");
+
+		IN(quantity);
+		IN(tribute_master_id);
+		IN(guild_id);
+
+		emu->slot = UFToServerSlot(eq->slot);
+
+		FINISH_DIRECT_DECODE();
+	}
+
 	DECODE(OP_InspectRequest)
 	{
 		DECODE_LENGTH_EXACT(structs::Inspect_Struct);

common/patches/uf_ops.h

@@ -58,6 +58,10 @@ E(OP_GroupInvite)
 E(OP_GroupUpdate)
 E(OP_GuildMemberList)
 E(OP_GuildsList)
+E(OP_GuildMemberAdd)
+E(OP_SendGuildTributes)
+E(OP_GuildMemberRankAltBanker)
+E(OP_GuildTributeDonateItem)
 E(OP_Illusion)
 E(OP_InspectBuffs)
 E(OP_InspectRequest)
@@ -82,6 +86,7 @@ E(OP_RespondAA)
 E(OP_SendAATable)
 E(OP_SendCharInfo)
 E(OP_SendZonepoints)
+E(OP_SetGuildRank)
 E(OP_ShopPlayerBuy)
 E(OP_ShopPlayerSell)
 E(OP_SomeItemPacketMaybe)
@@ -138,6 +143,8 @@ D(OP_GroupFollow)
 D(OP_GroupFollow2)
 D(OP_GroupInvite)
 D(OP_GroupInvite2)
+D(OP_GuildDemote)
+D(OP_GuildTributeDonateItem)
 D(OP_InspectRequest)
 D(OP_ItemLinkClick)
 D(OP_ItemVerifyRequest)

common/patches/uf_structs.h

@@ -1670,6 +1670,15 @@ struct Surname_Struct
 /*0100*/
 };
 
+struct GuildSetRank_Struct
+{
+	/*00*/	uint32	unknown00;
+	/*04*/	uint32	unknown04;
+	/*08*/	uint32	rank;
+	/*72*/	char	member_name[64];
+	/*76*/	uint32	banker;
+};
+
 struct GuildsListEntry_Struct {
 	char name[64];
 };
@@ -1685,6 +1694,27 @@ struct GuildUpdate_Struct {
 	GuildsListEntry_Struct entry;
 };
 
+struct GuildMemberAdd_Struct {
+	/*000*/ uint32 guild_id;
+	/*004*/ uint32 unknown04;
+	/*008*/ uint32 unknown08;
+	/*012*/ uint32 unknown12;
+	/*016*/ uint32 level;
+	/*020*/ uint32 class_;
+	/*024*/ uint32 rank_;
+	/*028*/ uint32 zone_id;
+	/*032*/ uint32 last_on;
+	/*036*/ char   player_name[64];
+};
+
+struct GuildMemberRank_Struct {
+	/*000*/ uint32 guild_id;
+	/*004*/ uint32 unknown_004;
+	/*008*/ uint32 rank_;
+	/*012*/ char   player_name[64];
+	/*076*/ uint32 alt_banker; //Banker/Alt bit 00 - none 10 - Alt 11 - Alt and Banker 01 - Banker.  Banker not functional for RoF2+
+};
+
 /*
 ** Money Loot
 ** Length: 22 Bytes
@@ -3067,6 +3097,23 @@ struct GuildMakeLeader{
 	char	target[64];
 };
 
+struct GuildTributeDonateItemRequest_Struct {
+/*000*/ uint32 	slot;
+/*004*/ uint32 	quantity;
+/*008*/ uint32	tribute_master_id;
+/*012*/ uint32 	unknown12;
+/*016*/ uint32	guild_id;
+/*020*/ uint32 	unknown20;
+/*024*/ uint32	unknown24;
+};
+
+struct GuildTributeDonateItemReply_Struct {
+/*000*/ uint32	slot;
+/*004*/ uint32	quantity;
+/*008*/ uint32	unknown8;
+/*012*/	uint32	favor;
+};
+
 struct Make_Pet_Struct { //Simple struct for getting pet info
 	uint8 level;
 	uint8 class_;
@@ -3078,7 +3125,7 @@ struct Make_Pet_Struct { //Simple struct for getting pet info
 	uint32 min_dmg;
 	uint32 max_dmg;
 };
-struct Ground_Spawn{
+struct GroundSpawn{
 	float max_x;
 	float max_y;
 	float min_x;
@@ -3090,8 +3137,8 @@ struct Ground_Spawn{
 	uint32 max_allowed;
 	uint32 respawntimer;
 };
-struct Ground_Spawns {
-	struct Ground_Spawn spawn[50]; //Assigned max number to allow
+struct GroundSpawns {
+	struct GroundSpawn spawn[50]; //Assigned max number to allow
 };
 
 //struct PetitionBug_Struct{

common/pch/pch.h

@@ -0,0 +1,34 @@
+// types
+#include <limits>
+#include <string>
+#include <cctype>
+#include <sstream>
+
+// containers
+#include <iterator>
+#include <set>
+#include <unordered_set>
+#include <map>
+#include <unordered_map>
+#include <list>
+#include <vector>
+
+// utilities
+#include <iostream>
+#include <cassert>
+#include <cmath>
+#include <memory>
+#include <functional>
+#include <algorithm>
+#include <utility>
+#include <tuple>
+#include <fstream>
+#include <cstdio>
+
+// fmt
+#include <fmt/format.h>
+
+// lua
+#include "lua.hpp"
+#include <luabind/luabind.hpp>
+#include <luabind/object.hpp>

common/ptimer.h

@@ -44,9 +44,10 @@ enum : int {	//values for pTimerType
 	pTimerBeggingPickPocket = 27,
 	pTimerLinkedSpellReuseStart = 28,
 	pTimerLinkedSpellReuseEnd = 48,
+	pTimerClearXTarget = 50,
+
+	pTimerShieldAbility = 86,
 
-	pTimerShieldAbility = 86,	
-	
 	pTimerLayHands = 87,		//these IDs are used by client too
 	pTimerHarmTouch = 89,		//so dont change them
 

common/repositories/account_repository.h

@@ -44,7 +44,51 @@ public:
      */
 
 	// Custom extended repository methods here
+	static int16 GetAccountStatus(Database& db, const uint32 account_id)
+	{
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"SELECT `status`, TIMESTAMPDIFF(SECOND, NOW(), `suspendeduntil`) FROM `{}` WHERE `{}` = {}",
+				TableName(),
+				PrimaryKey(),
+				account_id
+			)
+		);
 
+		if (!results.Success() || !results.RowCount()) {
+			return 0;
+		}
+
+		auto row = results.begin();
+
+		int16 status    = static_cast<int16>(Strings::ToInt(row[0]));
+		int   date_diff = 0;
+
+		if (row[1]) {
+			date_diff = Strings::ToInt(row[1]);
+		}
+
+		if (date_diff > 0) {
+			status = -1;
+		}
+
+		return status;
+	}
+
+	static bool UpdatePassword(Database& db, const uint32 account_id, const std::string& password)
+	{
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"UPDATE `{}` SET `password` = MD5('{}') WHERE `{}` = {}",
+				TableName(),
+				password,
+				PrimaryKey(),
+				account_id
+			)
+		);
+
+		return results.Success();
+	}
 };
 
 #endif //EQEMU_ACCOUNT_REPOSITORY_H

common/repositories/adventure_stats_repository.h

@@ -44,7 +44,65 @@ public:
      */
 
 	// Custom extended repository methods here
+	static void UpdateAdventureStatsEntry(Database& db, uint32 character_id, uint8 theme_id, bool is_win, bool is_remove)
+	{
+		std::string field;
 
+		switch (theme_id) {
+			case LDoNThemes::GUK: {
+				field = "guk_";
+				break;
+			}
+			case LDoNThemes::MIR: {
+				field = "mir_";
+				break;
+			}
+			case LDoNThemes::MMC: {
+				field = "mmc_";
+				break;
+			}
+			case LDoNThemes::RUJ: {
+				field = "ruj_";
+				break;
+			}
+			case LDoNThemes::TAK: {
+				field = "tak_";
+				break;
+			}
+		}
+
+		field += is_win ? "wins" : "losses";
+
+		auto e = FindOne(db, character_id);
+
+		if (!e.player_id && !is_remove) {
+			const std::string& query = fmt::format(
+				"INSERT INTO `{}` SET `{}` = 1, `{}` = {}",
+				TableName(),
+				field,
+				PrimaryKey(),
+				character_id
+			);
+
+			db.QueryDatabase(query);
+
+			return;
+		}
+
+		const std::string& field_operation = is_remove ? "-" : "+";
+
+		const std::string& query = fmt::format(
+			"UPDATE `{}` SET `{}` = {} {} 1 WHERE `{}` = {}",
+			TableName(),
+			field,
+			field,
+			field_operation,
+			PrimaryKey(),
+			character_id
+		);
+
+		db.QueryDatabase(query);
+	}
 };
 
 #endif //EQEMU_ADVENTURE_STATS_REPOSITORY_H

common/repositories/base/base_aa_ability_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_AA_ABILITY_REPOSITORY_H
@@ -33,6 +33,7 @@ public:
 		int32_t     first_rank_id;
 		uint8_t     enabled;
 		int8_t      reset_on_death;
+		int8_t      auto_grant_enabled;
 	};
 
 	static std::string PrimaryKey()
@@ -57,6 +58,7 @@ public:
 			"first_rank_id",
 			"enabled",
 			"reset_on_death",
+			"auto_grant_enabled",
 		};
 	}
 
@@ -77,6 +79,7 @@ public:
 			"first_rank_id",
 			"enabled",
 			"reset_on_death",
+			"auto_grant_enabled",
 		};
 	}
 
@@ -117,20 +120,21 @@ public:
 	{
 		AaAbility e{};
 
-		e.id               = 0;
-		e.name             = "";
-		e.category         = -1;
-		e.classes          = 131070;
-		e.races            = 65535;
-		e.drakkin_heritage = 127;
-		e.deities          = 131071;
-		e.status           = 0;
-		e.type             = 0;
-		e.charges          = 0;
-		e.grant_only       = 0;
-		e.first_rank_id    = -1;
-		e.enabled          = 1;
-		e.reset_on_death   = 0;
+		e.id                 = 0;
+		e.name               = "";
+		e.category           = -1;
+		e.classes            = 131070;
+		e.races              = 65535;
+		e.drakkin_heritage   = 127;
+		e.deities            = 131071;
+		e.status             = 0;
+		e.type               = 0;
+		e.charges            = 0;
+		e.grant_only         = 0;
+		e.first_rank_id      = -1;
+		e.enabled            = 1;
+		e.reset_on_death     = 0;
+		e.auto_grant_enabled = 0;
 
 		return e;
 	}
@@ -156,8 +160,9 @@ public:
 	{
 		auto results = db.QueryDatabase(
 			fmt::format(
-				"{} WHERE id = {} LIMIT 1",
+				"{} WHERE {} = {} LIMIT 1",
 				BaseSelect(),
+				PrimaryKey(),
 				aa_ability_id
 			)
 		);
@@ -166,20 +171,21 @@ public:
 		if (results.RowCount() == 1) {
 			AaAbility e{};
 
-			e.id               = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.name             = row[1] ? row[1] : "";
-			e.category         = static_cast<int32_t>(atoi(row[2]));
-			e.classes          = static_cast<int32_t>(atoi(row[3]));
-			e.races            = static_cast<int32_t>(atoi(row[4]));
-			e.drakkin_heritage = static_cast<int32_t>(atoi(row[5]));
-			e.deities          = static_cast<int32_t>(atoi(row[6]));
-			e.status           = static_cast<int32_t>(atoi(row[7]));
-			e.type             = static_cast<int32_t>(atoi(row[8]));
-			e.charges          = static_cast<int32_t>(atoi(row[9]));
-			e.grant_only       = static_cast<int8_t>(atoi(row[10]));
-			e.first_rank_id    = static_cast<int32_t>(atoi(row[11]));
-			e.enabled          = static_cast<uint8_t>(strtoul(row[12], nullptr, 10));
-			e.reset_on_death   = static_cast<int8_t>(atoi(row[13]));
+			e.id                 = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.name               = row[1] ? row[1] : "";
+			e.category           = row[2] ? static_cast<int32_t>(atoi(row[2])) : -1;
+			e.classes            = row[3] ? static_cast<int32_t>(atoi(row[3])) : 131070;
+			e.races              = row[4] ? static_cast<int32_t>(atoi(row[4])) : 65535;
+			e.drakkin_heritage   = row[5] ? static_cast<int32_t>(atoi(row[5])) : 127;
+			e.deities            = row[6] ? static_cast<int32_t>(atoi(row[6])) : 131071;
+			e.status             = row[7] ? static_cast<int32_t>(atoi(row[7])) : 0;
+			e.type               = row[8] ? static_cast<int32_t>(atoi(row[8])) : 0;
+			e.charges            = row[9] ? static_cast<int32_t>(atoi(row[9])) : 0;
+			e.grant_only         = row[10] ? static_cast<int8_t>(atoi(row[10])) : 0;
+			e.first_rank_id      = row[11] ? static_cast<int32_t>(atoi(row[11])) : -1;
+			e.enabled            = row[12] ? static_cast<uint8_t>(strtoul(row[12], nullptr, 10)) : 1;
+			e.reset_on_death     = row[13] ? static_cast<int8_t>(atoi(row[13])) : 0;
+			e.auto_grant_enabled = row[14] ? static_cast<int8_t>(atoi(row[14])) : 0;
 
 			return e;
 		}
@@ -227,6 +233,7 @@ public:
 		v.push_back(columns[11] + " = " + std::to_string(e.first_rank_id));
 		v.push_back(columns[12] + " = " + std::to_string(e.enabled));
 		v.push_back(columns[13] + " = " + std::to_string(e.reset_on_death));
+		v.push_back(columns[14] + " = " + std::to_string(e.auto_grant_enabled));
 
 		auto results = db.QueryDatabase(
 			fmt::format(
@@ -262,6 +269,7 @@ public:
 		v.push_back(std::to_string(e.first_rank_id));
 		v.push_back(std::to_string(e.enabled));
 		v.push_back(std::to_string(e.reset_on_death));
+		v.push_back(std::to_string(e.auto_grant_enabled));
 
 		auto results = db.QueryDatabase(
 			fmt::format(
@@ -305,6 +313,7 @@ public:
 			v.push_back(std::to_string(e.first_rank_id));
 			v.push_back(std::to_string(e.enabled));
 			v.push_back(std::to_string(e.reset_on_death));
+			v.push_back(std::to_string(e.auto_grant_enabled));
 
 			insert_chunks.push_back("(" + Strings::Implode(",", v) + ")");
 		}
@@ -338,20 +347,21 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			AaAbility e{};
 
-			e.id               = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.name             = row[1] ? row[1] : "";
-			e.category         = static_cast<int32_t>(atoi(row[2]));
-			e.classes          = static_cast<int32_t>(atoi(row[3]));
-			e.races            = static_cast<int32_t>(atoi(row[4]));
-			e.drakkin_heritage = static_cast<int32_t>(atoi(row[5]));
-			e.deities          = static_cast<int32_t>(atoi(row[6]));
-			e.status           = static_cast<int32_t>(atoi(row[7]));
-			e.type             = static_cast<int32_t>(atoi(row[8]));
-			e.charges          = static_cast<int32_t>(atoi(row[9]));
-			e.grant_only       = static_cast<int8_t>(atoi(row[10]));
-			e.first_rank_id    = static_cast<int32_t>(atoi(row[11]));
-			e.enabled          = static_cast<uint8_t>(strtoul(row[12], nullptr, 10));
-			e.reset_on_death   = static_cast<int8_t>(atoi(row[13]));
+			e.id                 = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.name               = row[1] ? row[1] : "";
+			e.category           = row[2] ? static_cast<int32_t>(atoi(row[2])) : -1;
+			e.classes            = row[3] ? static_cast<int32_t>(atoi(row[3])) : 131070;
+			e.races              = row[4] ? static_cast<int32_t>(atoi(row[4])) : 65535;
+			e.drakkin_heritage   = row[5] ? static_cast<int32_t>(atoi(row[5])) : 127;
+			e.deities            = row[6] ? static_cast<int32_t>(atoi(row[6])) : 131071;
+			e.status             = row[7] ? static_cast<int32_t>(atoi(row[7])) : 0;
+			e.type               = row[8] ? static_cast<int32_t>(atoi(row[8])) : 0;
+			e.charges            = row[9] ? static_cast<int32_t>(atoi(row[9])) : 0;
+			e.grant_only         = row[10] ? static_cast<int8_t>(atoi(row[10])) : 0;
+			e.first_rank_id      = row[11] ? static_cast<int32_t>(atoi(row[11])) : -1;
+			e.enabled            = row[12] ? static_cast<uint8_t>(strtoul(row[12], nullptr, 10)) : 1;
+			e.reset_on_death     = row[13] ? static_cast<int8_t>(atoi(row[13])) : 0;
+			e.auto_grant_enabled = row[14] ? static_cast<int8_t>(atoi(row[14])) : 0;
 
 			all_entries.push_back(e);
 		}
@@ -376,20 +386,21 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			AaAbility e{};
 
-			e.id               = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.name             = row[1] ? row[1] : "";
-			e.category         = static_cast<int32_t>(atoi(row[2]));
-			e.classes          = static_cast<int32_t>(atoi(row[3]));
-			e.races            = static_cast<int32_t>(atoi(row[4]));
-			e.drakkin_heritage = static_cast<int32_t>(atoi(row[5]));
-			e.deities          = static_cast<int32_t>(atoi(row[6]));
-			e.status           = static_cast<int32_t>(atoi(row[7]));
-			e.type             = static_cast<int32_t>(atoi(row[8]));
-			e.charges          = static_cast<int32_t>(atoi(row[9]));
-			e.grant_only       = static_cast<int8_t>(atoi(row[10]));
-			e.first_rank_id    = static_cast<int32_t>(atoi(row[11]));
-			e.enabled          = static_cast<uint8_t>(strtoul(row[12], nullptr, 10));
-			e.reset_on_death   = static_cast<int8_t>(atoi(row[13]));
+			e.id                 = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.name               = row[1] ? row[1] : "";
+			e.category           = row[2] ? static_cast<int32_t>(atoi(row[2])) : -1;
+			e.classes            = row[3] ? static_cast<int32_t>(atoi(row[3])) : 131070;
+			e.races              = row[4] ? static_cast<int32_t>(atoi(row[4])) : 65535;
+			e.drakkin_heritage   = row[5] ? static_cast<int32_t>(atoi(row[5])) : 127;
+			e.deities            = row[6] ? static_cast<int32_t>(atoi(row[6])) : 131071;
+			e.status             = row[7] ? static_cast<int32_t>(atoi(row[7])) : 0;
+			e.type               = row[8] ? static_cast<int32_t>(atoi(row[8])) : 0;
+			e.charges            = row[9] ? static_cast<int32_t>(atoi(row[9])) : 0;
+			e.grant_only         = row[10] ? static_cast<int8_t>(atoi(row[10])) : 0;
+			e.first_rank_id      = row[11] ? static_cast<int32_t>(atoi(row[11])) : -1;
+			e.enabled            = row[12] ? static_cast<uint8_t>(strtoul(row[12], nullptr, 10)) : 1;
+			e.reset_on_death     = row[13] ? static_cast<int8_t>(atoi(row[13])) : 0;
+			e.auto_grant_enabled = row[14] ? static_cast<int8_t>(atoi(row[14])) : 0;
 
 			all_entries.push_back(e);
 		}
@@ -448,6 +459,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 AaAbility &e
+	)
+	{
+		std::vector<std::string> v;
+
+		v.push_back(std::to_string(e.id));
+		v.push_back("'" + Strings::Escape(e.name) + "'");
+		v.push_back(std::to_string(e.category));
+		v.push_back(std::to_string(e.classes));
+		v.push_back(std::to_string(e.races));
+		v.push_back(std::to_string(e.drakkin_heritage));
+		v.push_back(std::to_string(e.deities));
+		v.push_back(std::to_string(e.status));
+		v.push_back(std::to_string(e.type));
+		v.push_back(std::to_string(e.charges));
+		v.push_back(std::to_string(e.grant_only));
+		v.push_back(std::to_string(e.first_rank_id));
+		v.push_back(std::to_string(e.enabled));
+		v.push_back(std::to_string(e.reset_on_death));
+		v.push_back(std::to_string(e.auto_grant_enabled));
+
+		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<AaAbility> &entries
+	)
+	{
+		std::vector<std::string> insert_chunks;
+
+		for (auto &e: entries) {
+			std::vector<std::string> v;
+
+			v.push_back(std::to_string(e.id));
+			v.push_back("'" + Strings::Escape(e.name) + "'");
+			v.push_back(std::to_string(e.category));
+			v.push_back(std::to_string(e.classes));
+			v.push_back(std::to_string(e.races));
+			v.push_back(std::to_string(e.drakkin_heritage));
+			v.push_back(std::to_string(e.deities));
+			v.push_back(std::to_string(e.status));
+			v.push_back(std::to_string(e.type));
+			v.push_back(std::to_string(e.charges));
+			v.push_back(std::to_string(e.grant_only));
+			v.push_back(std::to_string(e.first_rank_id));
+			v.push_back(std::to_string(e.enabled));
+			v.push_back(std::to_string(e.reset_on_death));
+			v.push_back(std::to_string(e.auto_grant_enabled));
+
+			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_AA_ABILITY_REPOSITORY_H

common/repositories/base/base_aa_rank_effects_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_AA_RANK_EFFECTS_REPOSITORY_H
@@ -120,8 +120,9 @@ public:
 	{
 		auto results = db.QueryDatabase(
 			fmt::format(
-				"{} WHERE id = {} LIMIT 1",
+				"{} WHERE {} = {} LIMIT 1",
 				BaseSelect(),
+				PrimaryKey(),
 				aa_rank_effects_id
 			)
 		);
@@ -130,11 +131,11 @@ public:
 		if (results.RowCount() == 1) {
 			AaRankEffects e{};
 
-			e.rank_id   = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.slot      = static_cast<uint32_t>(strtoul(row[1], nullptr, 10));
-			e.effect_id = static_cast<int32_t>(atoi(row[2]));
-			e.base1     = static_cast<int32_t>(atoi(row[3]));
-			e.base2     = static_cast<int32_t>(atoi(row[4]));
+			e.rank_id   = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.slot      = row[1] ? static_cast<uint32_t>(strtoul(row[1], nullptr, 10)) : 1;
+			e.effect_id = row[2] ? static_cast<int32_t>(atoi(row[2])) : 0;
+			e.base1     = row[3] ? static_cast<int32_t>(atoi(row[3])) : 0;
+			e.base2     = row[4] ? static_cast<int32_t>(atoi(row[4])) : 0;
 
 			return e;
 		}
@@ -266,11 +267,11 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			AaRankEffects e{};
 
-			e.rank_id   = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.slot      = static_cast<uint32_t>(strtoul(row[1], nullptr, 10));
-			e.effect_id = static_cast<int32_t>(atoi(row[2]));
-			e.base1     = static_cast<int32_t>(atoi(row[3]));
-			e.base2     = static_cast<int32_t>(atoi(row[4]));
+			e.rank_id   = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.slot      = row[1] ? static_cast<uint32_t>(strtoul(row[1], nullptr, 10)) : 1;
+			e.effect_id = row[2] ? static_cast<int32_t>(atoi(row[2])) : 0;
+			e.base1     = row[3] ? static_cast<int32_t>(atoi(row[3])) : 0;
+			e.base2     = row[4] ? static_cast<int32_t>(atoi(row[4])) : 0;
 
 			all_entries.push_back(e);
 		}
@@ -295,11 +296,11 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			AaRankEffects e{};
 
-			e.rank_id   = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.slot      = static_cast<uint32_t>(strtoul(row[1], nullptr, 10));
-			e.effect_id = static_cast<int32_t>(atoi(row[2]));
-			e.base1     = static_cast<int32_t>(atoi(row[3]));
-			e.base2     = static_cast<int32_t>(atoi(row[4]));
+			e.rank_id   = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.slot      = row[1] ? static_cast<uint32_t>(strtoul(row[1], nullptr, 10)) : 1;
+			e.effect_id = row[2] ? static_cast<int32_t>(atoi(row[2])) : 0;
+			e.base1     = row[3] ? static_cast<int32_t>(atoi(row[3])) : 0;
+			e.base2     = row[4] ? static_cast<int32_t>(atoi(row[4])) : 0;
 
 			all_entries.push_back(e);
 		}
@@ -358,6 +359,70 @@ 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 AaRankEffects &e
+	)
+	{
+		std::vector<std::string> v;
+
+		v.push_back(std::to_string(e.rank_id));
+		v.push_back(std::to_string(e.slot));
+		v.push_back(std::to_string(e.effect_id));
+		v.push_back(std::to_string(e.base1));
+		v.push_back(std::to_string(e.base2));
+
+		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<AaRankEffects> &entries
+	)
+	{
+		std::vector<std::string> insert_chunks;
+
+		for (auto &e: entries) {
+			std::vector<std::string> v;
+
+			v.push_back(std::to_string(e.rank_id));
+			v.push_back(std::to_string(e.slot));
+			v.push_back(std::to_string(e.effect_id));
+			v.push_back(std::to_string(e.base1));
+			v.push_back(std::to_string(e.base2));
+
+			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_AA_RANK_EFFECTS_REPOSITORY_H

common/repositories/base/base_aa_rank_prereqs_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_AA_RANK_PREREQS_REPOSITORY_H
@@ -112,8 +112,9 @@ public:
 	{
 		auto results = db.QueryDatabase(
 			fmt::format(
-				"{} WHERE id = {} LIMIT 1",
+				"{} WHERE {} = {} LIMIT 1",
 				BaseSelect(),
+				PrimaryKey(),
 				aa_rank_prereqs_id
 			)
 		);
@@ -122,9 +123,9 @@ public:
 		if (results.RowCount() == 1) {
 			AaRankPrereqs e{};
 
-			e.rank_id = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.aa_id   = static_cast<int32_t>(atoi(row[1]));
-			e.points  = static_cast<int32_t>(atoi(row[2]));
+			e.rank_id = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.aa_id   = row[1] ? static_cast<int32_t>(atoi(row[1])) : 0;
+			e.points  = row[2] ? static_cast<int32_t>(atoi(row[2])) : 0;
 
 			return e;
 		}
@@ -250,9 +251,9 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			AaRankPrereqs e{};
 
-			e.rank_id = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.aa_id   = static_cast<int32_t>(atoi(row[1]));
-			e.points  = static_cast<int32_t>(atoi(row[2]));
+			e.rank_id = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.aa_id   = row[1] ? static_cast<int32_t>(atoi(row[1])) : 0;
+			e.points  = row[2] ? static_cast<int32_t>(atoi(row[2])) : 0;
 
 			all_entries.push_back(e);
 		}
@@ -277,9 +278,9 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			AaRankPrereqs e{};
 
-			e.rank_id = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.aa_id   = static_cast<int32_t>(atoi(row[1]));
-			e.points  = static_cast<int32_t>(atoi(row[2]));
+			e.rank_id = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.aa_id   = row[1] ? static_cast<int32_t>(atoi(row[1])) : 0;
+			e.points  = row[2] ? static_cast<int32_t>(atoi(row[2])) : 0;
 
 			all_entries.push_back(e);
 		}
@@ -338,6 +339,66 @@ 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 AaRankPrereqs &e
+	)
+	{
+		std::vector<std::string> v;
+
+		v.push_back(std::to_string(e.rank_id));
+		v.push_back(std::to_string(e.aa_id));
+		v.push_back(std::to_string(e.points));
+
+		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<AaRankPrereqs> &entries
+	)
+	{
+		std::vector<std::string> insert_chunks;
+
+		for (auto &e: entries) {
+			std::vector<std::string> v;
+
+			v.push_back(std::to_string(e.rank_id));
+			v.push_back(std::to_string(e.aa_id));
+			v.push_back(std::to_string(e.points));
+
+			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_AA_RANK_PREREQS_REPOSITORY_H

common/repositories/base/base_aa_ranks_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_AA_RANKS_REPOSITORY_H
@@ -152,8 +152,9 @@ public:
 	{
 		auto results = db.QueryDatabase(
 			fmt::format(
-				"{} WHERE id = {} LIMIT 1",
+				"{} WHERE {} = {} LIMIT 1",
 				BaseSelect(),
+				PrimaryKey(),
 				aa_ranks_id
 			)
 		);
@@ -162,19 +163,19 @@ public:
 		if (results.RowCount() == 1) {
 			AaRanks e{};
 
-			e.id               = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.upper_hotkey_sid = static_cast<int32_t>(atoi(row[1]));
-			e.lower_hotkey_sid = static_cast<int32_t>(atoi(row[2]));
-			e.title_sid        = static_cast<int32_t>(atoi(row[3]));
-			e.desc_sid         = static_cast<int32_t>(atoi(row[4]));
-			e.cost             = static_cast<int32_t>(atoi(row[5]));
-			e.level_req        = static_cast<int32_t>(atoi(row[6]));
-			e.spell            = static_cast<int32_t>(atoi(row[7]));
-			e.spell_type       = static_cast<int32_t>(atoi(row[8]));
-			e.recast_time      = static_cast<int32_t>(atoi(row[9]));
-			e.expansion        = static_cast<int32_t>(atoi(row[10]));
-			e.prev_id          = static_cast<int32_t>(atoi(row[11]));
-			e.next_id          = static_cast<int32_t>(atoi(row[12]));
+			e.id               = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.upper_hotkey_sid = row[1] ? static_cast<int32_t>(atoi(row[1])) : -1;
+			e.lower_hotkey_sid = row[2] ? static_cast<int32_t>(atoi(row[2])) : -1;
+			e.title_sid        = row[3] ? static_cast<int32_t>(atoi(row[3])) : -1;
+			e.desc_sid         = row[4] ? static_cast<int32_t>(atoi(row[4])) : -1;
+			e.cost             = row[5] ? static_cast<int32_t>(atoi(row[5])) : 1;
+			e.level_req        = row[6] ? static_cast<int32_t>(atoi(row[6])) : 51;
+			e.spell            = row[7] ? static_cast<int32_t>(atoi(row[7])) : -1;
+			e.spell_type       = row[8] ? static_cast<int32_t>(atoi(row[8])) : 0;
+			e.recast_time      = row[9] ? static_cast<int32_t>(atoi(row[9])) : 0;
+			e.expansion        = row[10] ? static_cast<int32_t>(atoi(row[10])) : 0;
+			e.prev_id          = row[11] ? static_cast<int32_t>(atoi(row[11])) : -1;
+			e.next_id          = row[12] ? static_cast<int32_t>(atoi(row[12])) : -1;
 
 			return e;
 		}
@@ -330,19 +331,19 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			AaRanks e{};
 
-			e.id               = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.upper_hotkey_sid = static_cast<int32_t>(atoi(row[1]));
-			e.lower_hotkey_sid = static_cast<int32_t>(atoi(row[2]));
-			e.title_sid        = static_cast<int32_t>(atoi(row[3]));
-			e.desc_sid         = static_cast<int32_t>(atoi(row[4]));
-			e.cost             = static_cast<int32_t>(atoi(row[5]));
-			e.level_req        = static_cast<int32_t>(atoi(row[6]));
-			e.spell            = static_cast<int32_t>(atoi(row[7]));
-			e.spell_type       = static_cast<int32_t>(atoi(row[8]));
-			e.recast_time      = static_cast<int32_t>(atoi(row[9]));
-			e.expansion        = static_cast<int32_t>(atoi(row[10]));
-			e.prev_id          = static_cast<int32_t>(atoi(row[11]));
-			e.next_id          = static_cast<int32_t>(atoi(row[12]));
+			e.id               = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.upper_hotkey_sid = row[1] ? static_cast<int32_t>(atoi(row[1])) : -1;
+			e.lower_hotkey_sid = row[2] ? static_cast<int32_t>(atoi(row[2])) : -1;
+			e.title_sid        = row[3] ? static_cast<int32_t>(atoi(row[3])) : -1;
+			e.desc_sid         = row[4] ? static_cast<int32_t>(atoi(row[4])) : -1;
+			e.cost             = row[5] ? static_cast<int32_t>(atoi(row[5])) : 1;
+			e.level_req        = row[6] ? static_cast<int32_t>(atoi(row[6])) : 51;
+			e.spell            = row[7] ? static_cast<int32_t>(atoi(row[7])) : -1;
+			e.spell_type       = row[8] ? static_cast<int32_t>(atoi(row[8])) : 0;
+			e.recast_time      = row[9] ? static_cast<int32_t>(atoi(row[9])) : 0;
+			e.expansion        = row[10] ? static_cast<int32_t>(atoi(row[10])) : 0;
+			e.prev_id          = row[11] ? static_cast<int32_t>(atoi(row[11])) : -1;
+			e.next_id          = row[12] ? static_cast<int32_t>(atoi(row[12])) : -1;
 
 			all_entries.push_back(e);
 		}
@@ -367,19 +368,19 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			AaRanks e{};
 
-			e.id               = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.upper_hotkey_sid = static_cast<int32_t>(atoi(row[1]));
-			e.lower_hotkey_sid = static_cast<int32_t>(atoi(row[2]));
-			e.title_sid        = static_cast<int32_t>(atoi(row[3]));
-			e.desc_sid         = static_cast<int32_t>(atoi(row[4]));
-			e.cost             = static_cast<int32_t>(atoi(row[5]));
-			e.level_req        = static_cast<int32_t>(atoi(row[6]));
-			e.spell            = static_cast<int32_t>(atoi(row[7]));
-			e.spell_type       = static_cast<int32_t>(atoi(row[8]));
-			e.recast_time      = static_cast<int32_t>(atoi(row[9]));
-			e.expansion        = static_cast<int32_t>(atoi(row[10]));
-			e.prev_id          = static_cast<int32_t>(atoi(row[11]));
-			e.next_id          = static_cast<int32_t>(atoi(row[12]));
+			e.id               = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.upper_hotkey_sid = row[1] ? static_cast<int32_t>(atoi(row[1])) : -1;
+			e.lower_hotkey_sid = row[2] ? static_cast<int32_t>(atoi(row[2])) : -1;
+			e.title_sid        = row[3] ? static_cast<int32_t>(atoi(row[3])) : -1;
+			e.desc_sid         = row[4] ? static_cast<int32_t>(atoi(row[4])) : -1;
+			e.cost             = row[5] ? static_cast<int32_t>(atoi(row[5])) : 1;
+			e.level_req        = row[6] ? static_cast<int32_t>(atoi(row[6])) : 51;
+			e.spell            = row[7] ? static_cast<int32_t>(atoi(row[7])) : -1;
+			e.spell_type       = row[8] ? static_cast<int32_t>(atoi(row[8])) : 0;
+			e.recast_time      = row[9] ? static_cast<int32_t>(atoi(row[9])) : 0;
+			e.expansion        = row[10] ? static_cast<int32_t>(atoi(row[10])) : 0;
+			e.prev_id          = row[11] ? static_cast<int32_t>(atoi(row[11])) : -1;
+			e.next_id          = row[12] ? static_cast<int32_t>(atoi(row[12])) : -1;
 
 			all_entries.push_back(e);
 		}
@@ -438,6 +439,86 @@ 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 AaRanks &e
+	)
+	{
+		std::vector<std::string> v;
+
+		v.push_back(std::to_string(e.id));
+		v.push_back(std::to_string(e.upper_hotkey_sid));
+		v.push_back(std::to_string(e.lower_hotkey_sid));
+		v.push_back(std::to_string(e.title_sid));
+		v.push_back(std::to_string(e.desc_sid));
+		v.push_back(std::to_string(e.cost));
+		v.push_back(std::to_string(e.level_req));
+		v.push_back(std::to_string(e.spell));
+		v.push_back(std::to_string(e.spell_type));
+		v.push_back(std::to_string(e.recast_time));
+		v.push_back(std::to_string(e.expansion));
+		v.push_back(std::to_string(e.prev_id));
+		v.push_back(std::to_string(e.next_id));
+
+		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<AaRanks> &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.upper_hotkey_sid));
+			v.push_back(std::to_string(e.lower_hotkey_sid));
+			v.push_back(std::to_string(e.title_sid));
+			v.push_back(std::to_string(e.desc_sid));
+			v.push_back(std::to_string(e.cost));
+			v.push_back(std::to_string(e.level_req));
+			v.push_back(std::to_string(e.spell));
+			v.push_back(std::to_string(e.spell_type));
+			v.push_back(std::to_string(e.recast_time));
+			v.push_back(std::to_string(e.expansion));
+			v.push_back(std::to_string(e.prev_id));
+			v.push_back(std::to_string(e.next_id));
+
+			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_AA_RANKS_REPOSITORY_H

common/repositories/base/base_account_flags_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_ACCOUNT_FLAGS_REPOSITORY_H
@@ -112,8 +112,9 @@ public:
 	{
 		auto results = db.QueryDatabase(
 			fmt::format(
-				"{} WHERE id = {} LIMIT 1",
+				"{} WHERE {} = {} LIMIT 1",
 				BaseSelect(),
+				PrimaryKey(),
 				account_flags_id
 			)
 		);
@@ -122,7 +123,7 @@ public:
 		if (results.RowCount() == 1) {
 			AccountFlags e{};
 
-			e.p_accid = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
+			e.p_accid = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
 			e.p_flag  = row[1] ? row[1] : "";
 			e.p_value = row[2] ? row[2] : "";
 
@@ -250,7 +251,7 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			AccountFlags e{};
 
-			e.p_accid = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
+			e.p_accid = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
 			e.p_flag  = row[1] ? row[1] : "";
 			e.p_value = row[2] ? row[2] : "";
 
@@ -277,7 +278,7 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			AccountFlags e{};
 
-			e.p_accid = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
+			e.p_accid = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
 			e.p_flag  = row[1] ? row[1] : "";
 			e.p_value = row[2] ? row[2] : "";
 
@@ -338,6 +339,66 @@ 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 AccountFlags &e
+	)
+	{
+		std::vector<std::string> v;
+
+		v.push_back(std::to_string(e.p_accid));
+		v.push_back("'" + Strings::Escape(e.p_flag) + "'");
+		v.push_back("'" + Strings::Escape(e.p_value) + "'");
+
+		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<AccountFlags> &entries
+	)
+	{
+		std::vector<std::string> insert_chunks;
+
+		for (auto &e: entries) {
+			std::vector<std::string> v;
+
+			v.push_back(std::to_string(e.p_accid));
+			v.push_back("'" + Strings::Escape(e.p_flag) + "'");
+			v.push_back("'" + Strings::Escape(e.p_value) + "'");
+
+			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_ACCOUNT_FLAGS_REPOSITORY_H

common/repositories/base/base_account_ip_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_ACCOUNT_IP_REPOSITORY_H
@@ -22,7 +22,7 @@ public:
 		int32_t     accid;
 		std::string ip;
 		int32_t     count;
-		std::string lastused;
+		time_t      lastused;
 	};
 
 	static std::string PrimaryKey()
@@ -46,7 +46,7 @@ public:
 			"accid",
 			"ip",
 			"count",
-			"lastused",
+			"UNIX_TIMESTAMP(lastused)",
 		};
 	}
 
@@ -116,8 +116,9 @@ public:
 	{
 		auto results = db.QueryDatabase(
 			fmt::format(
-				"{} WHERE id = {} LIMIT 1",
+				"{} WHERE {} = {} LIMIT 1",
 				BaseSelect(),
+				PrimaryKey(),
 				account_ip_id
 			)
 		);
@@ -126,10 +127,10 @@ public:
 		if (results.RowCount() == 1) {
 			AccountIp e{};
 
-			e.accid    = static_cast<int32_t>(atoi(row[0]));
+			e.accid    = row[0] ? static_cast<int32_t>(atoi(row[0])) : 0;
 			e.ip       = row[1] ? row[1] : "";
-			e.count    = static_cast<int32_t>(atoi(row[2]));
-			e.lastused = row[3] ? row[3] : "";
+			e.count    = row[2] ? static_cast<int32_t>(atoi(row[2])) : 1;
+			e.lastused = strtoll(row[3] ? row[3] : "-1", nullptr, 10);
 
 			return e;
 		}
@@ -166,7 +167,7 @@ public:
 		v.push_back(columns[0] + " = " + std::to_string(e.accid));
 		v.push_back(columns[1] + " = '" + Strings::Escape(e.ip) + "'");
 		v.push_back(columns[2] + " = " + std::to_string(e.count));
-		v.push_back(columns[3] + " = '" + Strings::Escape(e.lastused) + "'");
+		v.push_back(columns[3] + " = FROM_UNIXTIME(" + (e.lastused > 0 ? std::to_string(e.lastused) : "null") + ")");
 
 		auto results = db.QueryDatabase(
 			fmt::format(
@@ -191,7 +192,7 @@ public:
 		v.push_back(std::to_string(e.accid));
 		v.push_back("'" + Strings::Escape(e.ip) + "'");
 		v.push_back(std::to_string(e.count));
-		v.push_back("'" + Strings::Escape(e.lastused) + "'");
+		v.push_back("FROM_UNIXTIME(" + (e.lastused > 0 ? std::to_string(e.lastused) : "null") + ")");
 
 		auto results = db.QueryDatabase(
 			fmt::format(
@@ -224,7 +225,7 @@ public:
 			v.push_back(std::to_string(e.accid));
 			v.push_back("'" + Strings::Escape(e.ip) + "'");
 			v.push_back(std::to_string(e.count));
-			v.push_back("'" + Strings::Escape(e.lastused) + "'");
+			v.push_back("FROM_UNIXTIME(" + (e.lastused > 0 ? std::to_string(e.lastused) : "null") + ")");
 
 			insert_chunks.push_back("(" + Strings::Implode(",", v) + ")");
 		}
@@ -258,10 +259,10 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			AccountIp e{};
 
-			e.accid    = static_cast<int32_t>(atoi(row[0]));
+			e.accid    = row[0] ? static_cast<int32_t>(atoi(row[0])) : 0;
 			e.ip       = row[1] ? row[1] : "";
-			e.count    = static_cast<int32_t>(atoi(row[2]));
-			e.lastused = row[3] ? row[3] : "";
+			e.count    = row[2] ? static_cast<int32_t>(atoi(row[2])) : 1;
+			e.lastused = strtoll(row[3] ? row[3] : "-1", nullptr, 10);
 
 			all_entries.push_back(e);
 		}
@@ -286,10 +287,10 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			AccountIp e{};
 
-			e.accid    = static_cast<int32_t>(atoi(row[0]));
+			e.accid    = row[0] ? static_cast<int32_t>(atoi(row[0])) : 0;
 			e.ip       = row[1] ? row[1] : "";
-			e.count    = static_cast<int32_t>(atoi(row[2]));
-			e.lastused = row[3] ? row[3] : "";
+			e.count    = row[2] ? static_cast<int32_t>(atoi(row[2])) : 1;
+			e.lastused = strtoll(row[3] ? row[3] : "-1", nullptr, 10);
 
 			all_entries.push_back(e);
 		}
@@ -348,6 +349,68 @@ 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 AccountIp &e
+	)
+	{
+		std::vector<std::string> v;
+
+		v.push_back(std::to_string(e.accid));
+		v.push_back("'" + Strings::Escape(e.ip) + "'");
+		v.push_back(std::to_string(e.count));
+		v.push_back("FROM_UNIXTIME(" + (e.lastused > 0 ? std::to_string(e.lastused) : "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<AccountIp> &entries
+	)
+	{
+		std::vector<std::string> insert_chunks;
+
+		for (auto &e: entries) {
+			std::vector<std::string> v;
+
+			v.push_back(std::to_string(e.accid));
+			v.push_back("'" + Strings::Escape(e.ip) + "'");
+			v.push_back(std::to_string(e.count));
+			v.push_back("FROM_UNIXTIME(" + (e.lastused > 0 ? std::to_string(e.lastused) : "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_ACCOUNT_IP_REPOSITORY_H

common/repositories/base/base_account_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_ACCOUNT_REPOSITORY_H
@@ -196,8 +196,9 @@ public:
 	{
 		auto results = db.QueryDatabase(
 			fmt::format(
-				"{} WHERE id = {} LIMIT 1",
+				"{} WHERE {} = {} LIMIT 1",
 				BaseSelect(),
+				PrimaryKey(),
 				account_id
 			)
 		);
@@ -206,25 +207,25 @@ public:
 		if (results.RowCount() == 1) {
 			Account e{};
 
-			e.id             = static_cast<int32_t>(atoi(row[0]));
+			e.id             = row[0] ? static_cast<int32_t>(atoi(row[0])) : 0;
 			e.name           = row[1] ? row[1] : "";
 			e.charname       = row[2] ? row[2] : "";
-			e.sharedplat     = static_cast<uint32_t>(strtoul(row[3], nullptr, 10));
+			e.sharedplat     = row[3] ? static_cast<uint32_t>(strtoul(row[3], nullptr, 10)) : 0;
 			e.password       = row[4] ? row[4] : "";
-			e.status         = static_cast<int32_t>(atoi(row[5]));
-			e.ls_id          = row[6] ? row[6] : "";
-			e.lsaccount_id   = static_cast<uint32_t>(strtoul(row[7], nullptr, 10));
-			e.gmspeed        = static_cast<uint8_t>(strtoul(row[8], nullptr, 10));
-			e.invulnerable   = static_cast<int8_t>(atoi(row[9]));
-			e.flymode        = static_cast<int8_t>(atoi(row[10]));
-			e.ignore_tells   = static_cast<int8_t>(atoi(row[11]));
-			e.revoked        = static_cast<uint8_t>(strtoul(row[12], nullptr, 10));
-			e.karma          = static_cast<uint32_t>(strtoul(row[13], nullptr, 10));
+			e.status         = row[5] ? static_cast<int32_t>(atoi(row[5])) : 0;
+			e.ls_id          = row[6] ? row[6] : "eqemu";
+			e.lsaccount_id   = row[7] ? static_cast<uint32_t>(strtoul(row[7], nullptr, 10)) : 0;
+			e.gmspeed        = row[8] ? static_cast<uint8_t>(strtoul(row[8], nullptr, 10)) : 0;
+			e.invulnerable   = row[9] ? static_cast<int8_t>(atoi(row[9])) : 0;
+			e.flymode        = row[10] ? static_cast<int8_t>(atoi(row[10])) : 0;
+			e.ignore_tells   = row[11] ? static_cast<int8_t>(atoi(row[11])) : 0;
+			e.revoked        = row[12] ? static_cast<uint8_t>(strtoul(row[12], nullptr, 10)) : 0;
+			e.karma          = row[13] ? static_cast<uint32_t>(strtoul(row[13], nullptr, 10)) : 0;
 			e.minilogin_ip   = row[14] ? row[14] : "";
-			e.hideme         = static_cast<int8_t>(atoi(row[15]));
-			e.rulesflag      = static_cast<uint8_t>(strtoul(row[16], nullptr, 10));
+			e.hideme         = row[15] ? static_cast<int8_t>(atoi(row[15])) : 0;
+			e.rulesflag      = row[16] ? static_cast<uint8_t>(strtoul(row[16], nullptr, 10)) : 0;
 			e.suspendeduntil = strtoll(row[17] ? row[17] : "-1", nullptr, 10);
-			e.time_creation  = static_cast<uint32_t>(strtoul(row[18], nullptr, 10));
+			e.time_creation  = row[18] ? static_cast<uint32_t>(strtoul(row[18], nullptr, 10)) : 0;
 			e.ban_reason     = row[19] ? row[19] : "";
 			e.suspend_reason = row[20] ? row[20] : "";
 			e.crc_eqgame     = row[21] ? row[21] : "";
@@ -417,25 +418,25 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			Account e{};
 
-			e.id             = static_cast<int32_t>(atoi(row[0]));
+			e.id             = row[0] ? static_cast<int32_t>(atoi(row[0])) : 0;
 			e.name           = row[1] ? row[1] : "";
 			e.charname       = row[2] ? row[2] : "";
-			e.sharedplat     = static_cast<uint32_t>(strtoul(row[3], nullptr, 10));
+			e.sharedplat     = row[3] ? static_cast<uint32_t>(strtoul(row[3], nullptr, 10)) : 0;
 			e.password       = row[4] ? row[4] : "";
-			e.status         = static_cast<int32_t>(atoi(row[5]));
-			e.ls_id          = row[6] ? row[6] : "";
-			e.lsaccount_id   = static_cast<uint32_t>(strtoul(row[7], nullptr, 10));
-			e.gmspeed        = static_cast<uint8_t>(strtoul(row[8], nullptr, 10));
-			e.invulnerable   = static_cast<int8_t>(atoi(row[9]));
-			e.flymode        = static_cast<int8_t>(atoi(row[10]));
-			e.ignore_tells   = static_cast<int8_t>(atoi(row[11]));
-			e.revoked        = static_cast<uint8_t>(strtoul(row[12], nullptr, 10));
-			e.karma          = static_cast<uint32_t>(strtoul(row[13], nullptr, 10));
+			e.status         = row[5] ? static_cast<int32_t>(atoi(row[5])) : 0;
+			e.ls_id          = row[6] ? row[6] : "eqemu";
+			e.lsaccount_id   = row[7] ? static_cast<uint32_t>(strtoul(row[7], nullptr, 10)) : 0;
+			e.gmspeed        = row[8] ? static_cast<uint8_t>(strtoul(row[8], nullptr, 10)) : 0;
+			e.invulnerable   = row[9] ? static_cast<int8_t>(atoi(row[9])) : 0;
+			e.flymode        = row[10] ? static_cast<int8_t>(atoi(row[10])) : 0;
+			e.ignore_tells   = row[11] ? static_cast<int8_t>(atoi(row[11])) : 0;
+			e.revoked        = row[12] ? static_cast<uint8_t>(strtoul(row[12], nullptr, 10)) : 0;
+			e.karma          = row[13] ? static_cast<uint32_t>(strtoul(row[13], nullptr, 10)) : 0;
 			e.minilogin_ip   = row[14] ? row[14] : "";
-			e.hideme         = static_cast<int8_t>(atoi(row[15]));
-			e.rulesflag      = static_cast<uint8_t>(strtoul(row[16], nullptr, 10));
+			e.hideme         = row[15] ? static_cast<int8_t>(atoi(row[15])) : 0;
+			e.rulesflag      = row[16] ? static_cast<uint8_t>(strtoul(row[16], nullptr, 10)) : 0;
 			e.suspendeduntil = strtoll(row[17] ? row[17] : "-1", nullptr, 10);
-			e.time_creation  = static_cast<uint32_t>(strtoul(row[18], nullptr, 10));
+			e.time_creation  = row[18] ? static_cast<uint32_t>(strtoul(row[18], nullptr, 10)) : 0;
 			e.ban_reason     = row[19] ? row[19] : "";
 			e.suspend_reason = row[20] ? row[20] : "";
 			e.crc_eqgame     = row[21] ? row[21] : "";
@@ -465,25 +466,25 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			Account e{};
 
-			e.id             = static_cast<int32_t>(atoi(row[0]));
+			e.id             = row[0] ? static_cast<int32_t>(atoi(row[0])) : 0;
 			e.name           = row[1] ? row[1] : "";
 			e.charname       = row[2] ? row[2] : "";
-			e.sharedplat     = static_cast<uint32_t>(strtoul(row[3], nullptr, 10));
+			e.sharedplat     = row[3] ? static_cast<uint32_t>(strtoul(row[3], nullptr, 10)) : 0;
 			e.password       = row[4] ? row[4] : "";
-			e.status         = static_cast<int32_t>(atoi(row[5]));
-			e.ls_id          = row[6] ? row[6] : "";
-			e.lsaccount_id   = static_cast<uint32_t>(strtoul(row[7], nullptr, 10));
-			e.gmspeed        = static_cast<uint8_t>(strtoul(row[8], nullptr, 10));
-			e.invulnerable   = static_cast<int8_t>(atoi(row[9]));
-			e.flymode        = static_cast<int8_t>(atoi(row[10]));
-			e.ignore_tells   = static_cast<int8_t>(atoi(row[11]));
-			e.revoked        = static_cast<uint8_t>(strtoul(row[12], nullptr, 10));
-			e.karma          = static_cast<uint32_t>(strtoul(row[13], nullptr, 10));
+			e.status         = row[5] ? static_cast<int32_t>(atoi(row[5])) : 0;
+			e.ls_id          = row[6] ? row[6] : "eqemu";
+			e.lsaccount_id   = row[7] ? static_cast<uint32_t>(strtoul(row[7], nullptr, 10)) : 0;
+			e.gmspeed        = row[8] ? static_cast<uint8_t>(strtoul(row[8], nullptr, 10)) : 0;
+			e.invulnerable   = row[9] ? static_cast<int8_t>(atoi(row[9])) : 0;
+			e.flymode        = row[10] ? static_cast<int8_t>(atoi(row[10])) : 0;
+			e.ignore_tells   = row[11] ? static_cast<int8_t>(atoi(row[11])) : 0;
+			e.revoked        = row[12] ? static_cast<uint8_t>(strtoul(row[12], nullptr, 10)) : 0;
+			e.karma          = row[13] ? static_cast<uint32_t>(strtoul(row[13], nullptr, 10)) : 0;
 			e.minilogin_ip   = row[14] ? row[14] : "";
-			e.hideme         = static_cast<int8_t>(atoi(row[15]));
-			e.rulesflag      = static_cast<uint8_t>(strtoul(row[16], nullptr, 10));
+			e.hideme         = row[15] ? static_cast<int8_t>(atoi(row[15])) : 0;
+			e.rulesflag      = row[16] ? static_cast<uint8_t>(strtoul(row[16], nullptr, 10)) : 0;
 			e.suspendeduntil = strtoll(row[17] ? row[17] : "-1", nullptr, 10);
-			e.time_creation  = static_cast<uint32_t>(strtoul(row[18], nullptr, 10));
+			e.time_creation  = row[18] ? static_cast<uint32_t>(strtoul(row[18], nullptr, 10)) : 0;
 			e.ban_reason     = row[19] ? row[19] : "";
 			e.suspend_reason = row[20] ? row[20] : "";
 			e.crc_eqgame     = row[21] ? row[21] : "";
@@ -547,6 +548,108 @@ 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 Account &e
+	)
+	{
+		std::vector<std::string> v;
+
+		v.push_back(std::to_string(e.id));
+		v.push_back("'" + Strings::Escape(e.name) + "'");
+		v.push_back("'" + Strings::Escape(e.charname) + "'");
+		v.push_back(std::to_string(e.sharedplat));
+		v.push_back("'" + Strings::Escape(e.password) + "'");
+		v.push_back(std::to_string(e.status));
+		v.push_back("'" + Strings::Escape(e.ls_id) + "'");
+		v.push_back(std::to_string(e.lsaccount_id));
+		v.push_back(std::to_string(e.gmspeed));
+		v.push_back(std::to_string(e.invulnerable));
+		v.push_back(std::to_string(e.flymode));
+		v.push_back(std::to_string(e.ignore_tells));
+		v.push_back(std::to_string(e.revoked));
+		v.push_back(std::to_string(e.karma));
+		v.push_back("'" + Strings::Escape(e.minilogin_ip) + "'");
+		v.push_back(std::to_string(e.hideme));
+		v.push_back(std::to_string(e.rulesflag));
+		v.push_back("FROM_UNIXTIME(" + (e.suspendeduntil > 0 ? std::to_string(e.suspendeduntil) : "null") + ")");
+		v.push_back(std::to_string(e.time_creation));
+		v.push_back("'" + Strings::Escape(e.ban_reason) + "'");
+		v.push_back("'" + Strings::Escape(e.suspend_reason) + "'");
+		v.push_back("'" + Strings::Escape(e.crc_eqgame) + "'");
+		v.push_back("'" + Strings::Escape(e.crc_skillcaps) + "'");
+		v.push_back("'" + Strings::Escape(e.crc_basedata) + "'");
+
+		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<Account> &entries
+	)
+	{
+		std::vector<std::string> insert_chunks;
+
+		for (auto &e: entries) {
+			std::vector<std::string> v;
+
+			v.push_back(std::to_string(e.id));
+			v.push_back("'" + Strings::Escape(e.name) + "'");
+			v.push_back("'" + Strings::Escape(e.charname) + "'");
+			v.push_back(std::to_string(e.sharedplat));
+			v.push_back("'" + Strings::Escape(e.password) + "'");
+			v.push_back(std::to_string(e.status));
+			v.push_back("'" + Strings::Escape(e.ls_id) + "'");
+			v.push_back(std::to_string(e.lsaccount_id));
+			v.push_back(std::to_string(e.gmspeed));
+			v.push_back(std::to_string(e.invulnerable));
+			v.push_back(std::to_string(e.flymode));
+			v.push_back(std::to_string(e.ignore_tells));
+			v.push_back(std::to_string(e.revoked));
+			v.push_back(std::to_string(e.karma));
+			v.push_back("'" + Strings::Escape(e.minilogin_ip) + "'");
+			v.push_back(std::to_string(e.hideme));
+			v.push_back(std::to_string(e.rulesflag));
+			v.push_back("FROM_UNIXTIME(" + (e.suspendeduntil > 0 ? std::to_string(e.suspendeduntil) : "null") + ")");
+			v.push_back(std::to_string(e.time_creation));
+			v.push_back("'" + Strings::Escape(e.ban_reason) + "'");
+			v.push_back("'" + Strings::Escape(e.suspend_reason) + "'");
+			v.push_back("'" + Strings::Escape(e.crc_eqgame) + "'");
+			v.push_back("'" + Strings::Escape(e.crc_skillcaps) + "'");
+			v.push_back("'" + Strings::Escape(e.crc_basedata) + "'");
+
+			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_ACCOUNT_REPOSITORY_H

common/repositories/base/base_account_rewards_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_ACCOUNT_REWARDS_REPOSITORY_H
@@ -112,8 +112,9 @@ public:
 	{
 		auto results = db.QueryDatabase(
 			fmt::format(
-				"{} WHERE id = {} LIMIT 1",
+				"{} WHERE {} = {} LIMIT 1",
 				BaseSelect(),
+				PrimaryKey(),
 				account_rewards_id
 			)
 		);
@@ -122,9 +123,9 @@ public:
 		if (results.RowCount() == 1) {
 			AccountRewards e{};
 
-			e.account_id = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.reward_id  = static_cast<uint32_t>(strtoul(row[1], nullptr, 10));
-			e.amount     = static_cast<uint32_t>(strtoul(row[2], nullptr, 10));
+			e.account_id = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.reward_id  = row[1] ? static_cast<uint32_t>(strtoul(row[1], nullptr, 10)) : 0;
+			e.amount     = row[2] ? static_cast<uint32_t>(strtoul(row[2], nullptr, 10)) : 0;
 
 			return e;
 		}
@@ -250,9 +251,9 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			AccountRewards e{};
 
-			e.account_id = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.reward_id  = static_cast<uint32_t>(strtoul(row[1], nullptr, 10));
-			e.amount     = static_cast<uint32_t>(strtoul(row[2], nullptr, 10));
+			e.account_id = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.reward_id  = row[1] ? static_cast<uint32_t>(strtoul(row[1], nullptr, 10)) : 0;
+			e.amount     = row[2] ? static_cast<uint32_t>(strtoul(row[2], nullptr, 10)) : 0;
 
 			all_entries.push_back(e);
 		}
@@ -277,9 +278,9 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			AccountRewards e{};
 
-			e.account_id = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.reward_id  = static_cast<uint32_t>(strtoul(row[1], nullptr, 10));
-			e.amount     = static_cast<uint32_t>(strtoul(row[2], nullptr, 10));
+			e.account_id = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.reward_id  = row[1] ? static_cast<uint32_t>(strtoul(row[1], nullptr, 10)) : 0;
+			e.amount     = row[2] ? static_cast<uint32_t>(strtoul(row[2], nullptr, 10)) : 0;
 
 			all_entries.push_back(e);
 		}
@@ -338,6 +339,66 @@ 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 AccountRewards &e
+	)
+	{
+		std::vector<std::string> v;
+
+		v.push_back(std::to_string(e.account_id));
+		v.push_back(std::to_string(e.reward_id));
+		v.push_back(std::to_string(e.amount));
+
+		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<AccountRewards> &entries
+	)
+	{
+		std::vector<std::string> insert_chunks;
+
+		for (auto &e: entries) {
+			std::vector<std::string> v;
+
+			v.push_back(std::to_string(e.account_id));
+			v.push_back(std::to_string(e.reward_id));
+			v.push_back(std::to_string(e.amount));
+
+			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_ACCOUNT_REWARDS_REPOSITORY_H

common/repositories/base/base_adventure_details_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_ADVENTURE_DETAILS_REPOSITORY_H
@@ -136,8 +136,9 @@ public:
 	{
 		auto results = db.QueryDatabase(
 			fmt::format(
-				"{} WHERE id = {} LIMIT 1",
+				"{} WHERE {} = {} LIMIT 1",
 				BaseSelect(),
+				PrimaryKey(),
 				adventure_details_id
 			)
 		);
@@ -146,15 +147,15 @@ public:
 		if (results.RowCount() == 1) {
 			AdventureDetails e{};
 
-			e.id                = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.adventure_id      = static_cast<uint16_t>(strtoul(row[1], nullptr, 10));
-			e.instance_id       = static_cast<int32_t>(atoi(row[2]));
-			e.count             = static_cast<uint16_t>(strtoul(row[3], nullptr, 10));
-			e.assassinate_count = static_cast<uint16_t>(strtoul(row[4], nullptr, 10));
-			e.status            = static_cast<uint8_t>(strtoul(row[5], nullptr, 10));
-			e.time_created      = static_cast<uint32_t>(strtoul(row[6], nullptr, 10));
-			e.time_zoned        = static_cast<uint32_t>(strtoul(row[7], nullptr, 10));
-			e.time_completed    = static_cast<uint32_t>(strtoul(row[8], nullptr, 10));
+			e.id                = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.adventure_id      = row[1] ? static_cast<uint16_t>(strtoul(row[1], nullptr, 10)) : 0;
+			e.instance_id       = row[2] ? static_cast<int32_t>(atoi(row[2])) : -1;
+			e.count             = row[3] ? static_cast<uint16_t>(strtoul(row[3], nullptr, 10)) : 0;
+			e.assassinate_count = row[4] ? static_cast<uint16_t>(strtoul(row[4], nullptr, 10)) : 0;
+			e.status            = row[5] ? static_cast<uint8_t>(strtoul(row[5], nullptr, 10)) : 0;
+			e.time_created      = row[6] ? static_cast<uint32_t>(strtoul(row[6], nullptr, 10)) : 0;
+			e.time_zoned        = row[7] ? static_cast<uint32_t>(strtoul(row[7], nullptr, 10)) : 0;
+			e.time_completed    = row[8] ? static_cast<uint32_t>(strtoul(row[8], nullptr, 10)) : 0;
 
 			return e;
 		}
@@ -297,15 +298,15 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			AdventureDetails e{};
 
-			e.id                = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.adventure_id      = static_cast<uint16_t>(strtoul(row[1], nullptr, 10));
-			e.instance_id       = static_cast<int32_t>(atoi(row[2]));
-			e.count             = static_cast<uint16_t>(strtoul(row[3], nullptr, 10));
-			e.assassinate_count = static_cast<uint16_t>(strtoul(row[4], nullptr, 10));
-			e.status            = static_cast<uint8_t>(strtoul(row[5], nullptr, 10));
-			e.time_created      = static_cast<uint32_t>(strtoul(row[6], nullptr, 10));
-			e.time_zoned        = static_cast<uint32_t>(strtoul(row[7], nullptr, 10));
-			e.time_completed    = static_cast<uint32_t>(strtoul(row[8], nullptr, 10));
+			e.id                = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.adventure_id      = row[1] ? static_cast<uint16_t>(strtoul(row[1], nullptr, 10)) : 0;
+			e.instance_id       = row[2] ? static_cast<int32_t>(atoi(row[2])) : -1;
+			e.count             = row[3] ? static_cast<uint16_t>(strtoul(row[3], nullptr, 10)) : 0;
+			e.assassinate_count = row[4] ? static_cast<uint16_t>(strtoul(row[4], nullptr, 10)) : 0;
+			e.status            = row[5] ? static_cast<uint8_t>(strtoul(row[5], nullptr, 10)) : 0;
+			e.time_created      = row[6] ? static_cast<uint32_t>(strtoul(row[6], nullptr, 10)) : 0;
+			e.time_zoned        = row[7] ? static_cast<uint32_t>(strtoul(row[7], nullptr, 10)) : 0;
+			e.time_completed    = row[8] ? static_cast<uint32_t>(strtoul(row[8], nullptr, 10)) : 0;
 
 			all_entries.push_back(e);
 		}
@@ -330,15 +331,15 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			AdventureDetails e{};
 
-			e.id                = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.adventure_id      = static_cast<uint16_t>(strtoul(row[1], nullptr, 10));
-			e.instance_id       = static_cast<int32_t>(atoi(row[2]));
-			e.count             = static_cast<uint16_t>(strtoul(row[3], nullptr, 10));
-			e.assassinate_count = static_cast<uint16_t>(strtoul(row[4], nullptr, 10));
-			e.status            = static_cast<uint8_t>(strtoul(row[5], nullptr, 10));
-			e.time_created      = static_cast<uint32_t>(strtoul(row[6], nullptr, 10));
-			e.time_zoned        = static_cast<uint32_t>(strtoul(row[7], nullptr, 10));
-			e.time_completed    = static_cast<uint32_t>(strtoul(row[8], nullptr, 10));
+			e.id                = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.adventure_id      = row[1] ? static_cast<uint16_t>(strtoul(row[1], nullptr, 10)) : 0;
+			e.instance_id       = row[2] ? static_cast<int32_t>(atoi(row[2])) : -1;
+			e.count             = row[3] ? static_cast<uint16_t>(strtoul(row[3], nullptr, 10)) : 0;
+			e.assassinate_count = row[4] ? static_cast<uint16_t>(strtoul(row[4], nullptr, 10)) : 0;
+			e.status            = row[5] ? static_cast<uint8_t>(strtoul(row[5], nullptr, 10)) : 0;
+			e.time_created      = row[6] ? static_cast<uint32_t>(strtoul(row[6], nullptr, 10)) : 0;
+			e.time_zoned        = row[7] ? static_cast<uint32_t>(strtoul(row[7], nullptr, 10)) : 0;
+			e.time_completed    = row[8] ? static_cast<uint32_t>(strtoul(row[8], nullptr, 10)) : 0;
 
 			all_entries.push_back(e);
 		}
@@ -397,6 +398,78 @@ 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 AdventureDetails &e
+	)
+	{
+		std::vector<std::string> v;
+
+		v.push_back(std::to_string(e.id));
+		v.push_back(std::to_string(e.adventure_id));
+		v.push_back(std::to_string(e.instance_id));
+		v.push_back(std::to_string(e.count));
+		v.push_back(std::to_string(e.assassinate_count));
+		v.push_back(std::to_string(e.status));
+		v.push_back(std::to_string(e.time_created));
+		v.push_back(std::to_string(e.time_zoned));
+		v.push_back(std::to_string(e.time_completed));
+
+		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<AdventureDetails> &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.adventure_id));
+			v.push_back(std::to_string(e.instance_id));
+			v.push_back(std::to_string(e.count));
+			v.push_back(std::to_string(e.assassinate_count));
+			v.push_back(std::to_string(e.status));
+			v.push_back(std::to_string(e.time_created));
+			v.push_back(std::to_string(e.time_zoned));
+			v.push_back(std::to_string(e.time_completed));
+
+			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_ADVENTURE_DETAILS_REPOSITORY_H

common/repositories/base/base_adventure_members_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_ADVENTURE_MEMBERS_REPOSITORY_H
@@ -108,8 +108,9 @@ public:
 	{
 		auto results = db.QueryDatabase(
 			fmt::format(
-				"{} WHERE id = {} LIMIT 1",
+				"{} WHERE {} = {} LIMIT 1",
 				BaseSelect(),
+				PrimaryKey(),
 				adventure_members_id
 			)
 		);
@@ -118,8 +119,8 @@ public:
 		if (results.RowCount() == 1) {
 			AdventureMembers e{};
 
-			e.id     = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.charid = static_cast<uint32_t>(strtoul(row[1], nullptr, 10));
+			e.id     = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.charid = row[1] ? static_cast<uint32_t>(strtoul(row[1], nullptr, 10)) : 0;
 
 			return e;
 		}
@@ -242,8 +243,8 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			AdventureMembers e{};
 
-			e.id     = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.charid = static_cast<uint32_t>(strtoul(row[1], nullptr, 10));
+			e.id     = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.charid = row[1] ? static_cast<uint32_t>(strtoul(row[1], nullptr, 10)) : 0;
 
 			all_entries.push_back(e);
 		}
@@ -268,8 +269,8 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			AdventureMembers e{};
 
-			e.id     = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.charid = static_cast<uint32_t>(strtoul(row[1], nullptr, 10));
+			e.id     = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.charid = row[1] ? static_cast<uint32_t>(strtoul(row[1], nullptr, 10)) : 0;
 
 			all_entries.push_back(e);
 		}
@@ -328,6 +329,64 @@ 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 AdventureMembers &e
+	)
+	{
+		std::vector<std::string> v;
+
+		v.push_back(std::to_string(e.id));
+		v.push_back(std::to_string(e.charid));
+
+		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<AdventureMembers> &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.charid));
+
+			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_ADVENTURE_MEMBERS_REPOSITORY_H

common/repositories/base/base_adventure_stats_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_ADVENTURE_STATS_REPOSITORY_H
@@ -144,8 +144,9 @@ public:
 	{
 		auto results = db.QueryDatabase(
 			fmt::format(
-				"{} WHERE id = {} LIMIT 1",
+				"{} WHERE {} = {} LIMIT 1",
 				BaseSelect(),
+				PrimaryKey(),
 				adventure_stats_id
 			)
 		);
@@ -154,17 +155,17 @@ public:
 		if (results.RowCount() == 1) {
 			AdventureStats e{};
 
-			e.player_id  = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.guk_wins   = static_cast<uint32_t>(strtoul(row[1], nullptr, 10));
-			e.mir_wins   = static_cast<uint32_t>(strtoul(row[2], nullptr, 10));
-			e.mmc_wins   = static_cast<uint32_t>(strtoul(row[3], nullptr, 10));
-			e.ruj_wins   = static_cast<uint32_t>(strtoul(row[4], nullptr, 10));
-			e.tak_wins   = static_cast<uint32_t>(strtoul(row[5], nullptr, 10));
-			e.guk_losses = static_cast<uint32_t>(strtoul(row[6], nullptr, 10));
-			e.mir_losses = static_cast<uint32_t>(strtoul(row[7], nullptr, 10));
-			e.mmc_losses = static_cast<uint32_t>(strtoul(row[8], nullptr, 10));
-			e.ruj_losses = static_cast<uint32_t>(strtoul(row[9], nullptr, 10));
-			e.tak_losses = static_cast<uint32_t>(strtoul(row[10], nullptr, 10));
+			e.player_id  = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.guk_wins   = row[1] ? static_cast<uint32_t>(strtoul(row[1], nullptr, 10)) : 0;
+			e.mir_wins   = row[2] ? static_cast<uint32_t>(strtoul(row[2], nullptr, 10)) : 0;
+			e.mmc_wins   = row[3] ? static_cast<uint32_t>(strtoul(row[3], nullptr, 10)) : 0;
+			e.ruj_wins   = row[4] ? static_cast<uint32_t>(strtoul(row[4], nullptr, 10)) : 0;
+			e.tak_wins   = row[5] ? static_cast<uint32_t>(strtoul(row[5], nullptr, 10)) : 0;
+			e.guk_losses = row[6] ? static_cast<uint32_t>(strtoul(row[6], nullptr, 10)) : 0;
+			e.mir_losses = row[7] ? static_cast<uint32_t>(strtoul(row[7], nullptr, 10)) : 0;
+			e.mmc_losses = row[8] ? static_cast<uint32_t>(strtoul(row[8], nullptr, 10)) : 0;
+			e.ruj_losses = row[9] ? static_cast<uint32_t>(strtoul(row[9], nullptr, 10)) : 0;
+			e.tak_losses = row[10] ? static_cast<uint32_t>(strtoul(row[10], nullptr, 10)) : 0;
 
 			return e;
 		}
@@ -314,17 +315,17 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			AdventureStats e{};
 
-			e.player_id  = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.guk_wins   = static_cast<uint32_t>(strtoul(row[1], nullptr, 10));
-			e.mir_wins   = static_cast<uint32_t>(strtoul(row[2], nullptr, 10));
-			e.mmc_wins   = static_cast<uint32_t>(strtoul(row[3], nullptr, 10));
-			e.ruj_wins   = static_cast<uint32_t>(strtoul(row[4], nullptr, 10));
-			e.tak_wins   = static_cast<uint32_t>(strtoul(row[5], nullptr, 10));
-			e.guk_losses = static_cast<uint32_t>(strtoul(row[6], nullptr, 10));
-			e.mir_losses = static_cast<uint32_t>(strtoul(row[7], nullptr, 10));
-			e.mmc_losses = static_cast<uint32_t>(strtoul(row[8], nullptr, 10));
-			e.ruj_losses = static_cast<uint32_t>(strtoul(row[9], nullptr, 10));
-			e.tak_losses = static_cast<uint32_t>(strtoul(row[10], nullptr, 10));
+			e.player_id  = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.guk_wins   = row[1] ? static_cast<uint32_t>(strtoul(row[1], nullptr, 10)) : 0;
+			e.mir_wins   = row[2] ? static_cast<uint32_t>(strtoul(row[2], nullptr, 10)) : 0;
+			e.mmc_wins   = row[3] ? static_cast<uint32_t>(strtoul(row[3], nullptr, 10)) : 0;
+			e.ruj_wins   = row[4] ? static_cast<uint32_t>(strtoul(row[4], nullptr, 10)) : 0;
+			e.tak_wins   = row[5] ? static_cast<uint32_t>(strtoul(row[5], nullptr, 10)) : 0;
+			e.guk_losses = row[6] ? static_cast<uint32_t>(strtoul(row[6], nullptr, 10)) : 0;
+			e.mir_losses = row[7] ? static_cast<uint32_t>(strtoul(row[7], nullptr, 10)) : 0;
+			e.mmc_losses = row[8] ? static_cast<uint32_t>(strtoul(row[8], nullptr, 10)) : 0;
+			e.ruj_losses = row[9] ? static_cast<uint32_t>(strtoul(row[9], nullptr, 10)) : 0;
+			e.tak_losses = row[10] ? static_cast<uint32_t>(strtoul(row[10], nullptr, 10)) : 0;
 
 			all_entries.push_back(e);
 		}
@@ -349,17 +350,17 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			AdventureStats e{};
 
-			e.player_id  = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.guk_wins   = static_cast<uint32_t>(strtoul(row[1], nullptr, 10));
-			e.mir_wins   = static_cast<uint32_t>(strtoul(row[2], nullptr, 10));
-			e.mmc_wins   = static_cast<uint32_t>(strtoul(row[3], nullptr, 10));
-			e.ruj_wins   = static_cast<uint32_t>(strtoul(row[4], nullptr, 10));
-			e.tak_wins   = static_cast<uint32_t>(strtoul(row[5], nullptr, 10));
-			e.guk_losses = static_cast<uint32_t>(strtoul(row[6], nullptr, 10));
-			e.mir_losses = static_cast<uint32_t>(strtoul(row[7], nullptr, 10));
-			e.mmc_losses = static_cast<uint32_t>(strtoul(row[8], nullptr, 10));
-			e.ruj_losses = static_cast<uint32_t>(strtoul(row[9], nullptr, 10));
-			e.tak_losses = static_cast<uint32_t>(strtoul(row[10], nullptr, 10));
+			e.player_id  = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.guk_wins   = row[1] ? static_cast<uint32_t>(strtoul(row[1], nullptr, 10)) : 0;
+			e.mir_wins   = row[2] ? static_cast<uint32_t>(strtoul(row[2], nullptr, 10)) : 0;
+			e.mmc_wins   = row[3] ? static_cast<uint32_t>(strtoul(row[3], nullptr, 10)) : 0;
+			e.ruj_wins   = row[4] ? static_cast<uint32_t>(strtoul(row[4], nullptr, 10)) : 0;
+			e.tak_wins   = row[5] ? static_cast<uint32_t>(strtoul(row[5], nullptr, 10)) : 0;
+			e.guk_losses = row[6] ? static_cast<uint32_t>(strtoul(row[6], nullptr, 10)) : 0;
+			e.mir_losses = row[7] ? static_cast<uint32_t>(strtoul(row[7], nullptr, 10)) : 0;
+			e.mmc_losses = row[8] ? static_cast<uint32_t>(strtoul(row[8], nullptr, 10)) : 0;
+			e.ruj_losses = row[9] ? static_cast<uint32_t>(strtoul(row[9], nullptr, 10)) : 0;
+			e.tak_losses = row[10] ? static_cast<uint32_t>(strtoul(row[10], nullptr, 10)) : 0;
 
 			all_entries.push_back(e);
 		}
@@ -418,6 +419,82 @@ 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 AdventureStats &e
+	)
+	{
+		std::vector<std::string> v;
+
+		v.push_back(std::to_string(e.player_id));
+		v.push_back(std::to_string(e.guk_wins));
+		v.push_back(std::to_string(e.mir_wins));
+		v.push_back(std::to_string(e.mmc_wins));
+		v.push_back(std::to_string(e.ruj_wins));
+		v.push_back(std::to_string(e.tak_wins));
+		v.push_back(std::to_string(e.guk_losses));
+		v.push_back(std::to_string(e.mir_losses));
+		v.push_back(std::to_string(e.mmc_losses));
+		v.push_back(std::to_string(e.ruj_losses));
+		v.push_back(std::to_string(e.tak_losses));
+
+		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<AdventureStats> &entries
+	)
+	{
+		std::vector<std::string> insert_chunks;
+
+		for (auto &e: entries) {
+			std::vector<std::string> v;
+
+			v.push_back(std::to_string(e.player_id));
+			v.push_back(std::to_string(e.guk_wins));
+			v.push_back(std::to_string(e.mir_wins));
+			v.push_back(std::to_string(e.mmc_wins));
+			v.push_back(std::to_string(e.ruj_wins));
+			v.push_back(std::to_string(e.tak_wins));
+			v.push_back(std::to_string(e.guk_losses));
+			v.push_back(std::to_string(e.mir_losses));
+			v.push_back(std::to_string(e.mmc_losses));
+			v.push_back(std::to_string(e.ruj_losses));
+			v.push_back(std::to_string(e.tak_losses));
+
+			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_ADVENTURE_STATS_REPOSITORY_H

common/repositories/base/base_adventure_template_entry_flavor_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_ADVENTURE_TEMPLATE_ENTRY_FLAVOR_REPOSITORY_H
@@ -108,8 +108,9 @@ public:
 	{
 		auto results = db.QueryDatabase(
 			fmt::format(
-				"{} WHERE id = {} LIMIT 1",
+				"{} WHERE {} = {} LIMIT 1",
 				BaseSelect(),
+				PrimaryKey(),
 				adventure_template_entry_flavor_id
 			)
 		);
@@ -118,7 +119,7 @@ public:
 		if (results.RowCount() == 1) {
 			AdventureTemplateEntryFlavor e{};
 
-			e.id   = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
+			e.id   = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
 			e.text = row[1] ? row[1] : "";
 
 			return e;
@@ -242,7 +243,7 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			AdventureTemplateEntryFlavor e{};
 
-			e.id   = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
+			e.id   = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
 			e.text = row[1] ? row[1] : "";
 
 			all_entries.push_back(e);
@@ -268,7 +269,7 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			AdventureTemplateEntryFlavor e{};
 
-			e.id   = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
+			e.id   = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
 			e.text = row[1] ? row[1] : "";
 
 			all_entries.push_back(e);
@@ -328,6 +329,64 @@ 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 AdventureTemplateEntryFlavor &e
+	)
+	{
+		std::vector<std::string> v;
+
+		v.push_back(std::to_string(e.id));
+		v.push_back("'" + Strings::Escape(e.text) + "'");
+
+		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<AdventureTemplateEntryFlavor> &entries
+	)
+	{
+		std::vector<std::string> insert_chunks;
+
+		for (auto &e: entries) {
+			std::vector<std::string> v;
+
+			v.push_back(std::to_string(e.id));
+			v.push_back("'" + Strings::Escape(e.text) + "'");
+
+			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_ADVENTURE_TEMPLATE_ENTRY_FLAVOR_REPOSITORY_H

common/repositories/base/base_adventure_template_entry_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_ADVENTURE_TEMPLATE_ENTRY_REPOSITORY_H
@@ -108,8 +108,9 @@ public:
 	{
 		auto results = db.QueryDatabase(
 			fmt::format(
-				"{} WHERE id = {} LIMIT 1",
+				"{} WHERE {} = {} LIMIT 1",
 				BaseSelect(),
+				PrimaryKey(),
 				adventure_template_entry_id
 			)
 		);
@@ -118,8 +119,8 @@ public:
 		if (results.RowCount() == 1) {
 			AdventureTemplateEntry e{};
 
-			e.id          = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.template_id = static_cast<uint32_t>(strtoul(row[1], nullptr, 10));
+			e.id          = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.template_id = row[1] ? static_cast<uint32_t>(strtoul(row[1], nullptr, 10)) : 0;
 
 			return e;
 		}
@@ -242,8 +243,8 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			AdventureTemplateEntry e{};
 
-			e.id          = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.template_id = static_cast<uint32_t>(strtoul(row[1], nullptr, 10));
+			e.id          = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.template_id = row[1] ? static_cast<uint32_t>(strtoul(row[1], nullptr, 10)) : 0;
 
 			all_entries.push_back(e);
 		}
@@ -268,8 +269,8 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			AdventureTemplateEntry e{};
 
-			e.id          = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.template_id = static_cast<uint32_t>(strtoul(row[1], nullptr, 10));
+			e.id          = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.template_id = row[1] ? static_cast<uint32_t>(strtoul(row[1], nullptr, 10)) : 0;
 
 			all_entries.push_back(e);
 		}
@@ -328,6 +329,64 @@ 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 AdventureTemplateEntry &e
+	)
+	{
+		std::vector<std::string> v;
+
+		v.push_back(std::to_string(e.id));
+		v.push_back(std::to_string(e.template_id));
+
+		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<AdventureTemplateEntry> &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.template_id));
+
+			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_ADVENTURE_TEMPLATE_ENTRY_REPOSITORY_H

common/repositories/base/base_adventure_template_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_ADVENTURE_TEMPLATE_REPOSITORY_H
@@ -232,8 +232,9 @@ public:
 	{
 		auto results = db.QueryDatabase(
 			fmt::format(
-				"{} WHERE id = {} LIMIT 1",
+				"{} WHERE {} = {} LIMIT 1",
 				BaseSelect(),
+				PrimaryKey(),
 				adventure_template_id
 			)
 		);
@@ -242,38 +243,38 @@ public:
 		if (results.RowCount() == 1) {
 			AdventureTemplate e{};
 
-			e.id                = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
+			e.id                = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
 			e.zone              = row[1] ? row[1] : "";
-			e.zone_version      = static_cast<uint8_t>(strtoul(row[2], nullptr, 10));
-			e.is_hard           = static_cast<uint8_t>(strtoul(row[3], nullptr, 10));
-			e.is_raid           = static_cast<uint8_t>(strtoul(row[4], nullptr, 10));
-			e.min_level         = static_cast<uint8_t>(strtoul(row[5], nullptr, 10));
-			e.max_level         = static_cast<uint8_t>(strtoul(row[6], nullptr, 10));
-			e.type              = static_cast<uint8_t>(strtoul(row[7], nullptr, 10));
-			e.type_data         = static_cast<uint32_t>(strtoul(row[8], nullptr, 10));
-			e.type_count        = static_cast<uint16_t>(strtoul(row[9], nullptr, 10));
-			e.assa_x            = strtof(row[10], nullptr);
-			e.assa_y            = strtof(row[11], nullptr);
-			e.assa_z            = strtof(row[12], nullptr);
-			e.assa_h            = strtof(row[13], nullptr);
+			e.zone_version      = row[2] ? static_cast<uint8_t>(strtoul(row[2], nullptr, 10)) : 0;
+			e.is_hard           = row[3] ? static_cast<uint8_t>(strtoul(row[3], nullptr, 10)) : 0;
+			e.is_raid           = row[4] ? static_cast<uint8_t>(strtoul(row[4], nullptr, 10)) : 0;
+			e.min_level         = row[5] ? static_cast<uint8_t>(strtoul(row[5], nullptr, 10)) : 1;
+			e.max_level         = row[6] ? static_cast<uint8_t>(strtoul(row[6], nullptr, 10)) : 65;
+			e.type              = row[7] ? static_cast<uint8_t>(strtoul(row[7], nullptr, 10)) : 0;
+			e.type_data         = row[8] ? static_cast<uint32_t>(strtoul(row[8], nullptr, 10)) : 0;
+			e.type_count        = row[9] ? static_cast<uint16_t>(strtoul(row[9], nullptr, 10)) : 0;
+			e.assa_x            = row[10] ? strtof(row[10], nullptr) : 0;
+			e.assa_y            = row[11] ? strtof(row[11], nullptr) : 0;
+			e.assa_z            = row[12] ? strtof(row[12], nullptr) : 0;
+			e.assa_h            = row[13] ? strtof(row[13], nullptr) : 0;
 			e.text              = row[14] ? row[14] : "";
-			e.duration          = static_cast<uint32_t>(strtoul(row[15], nullptr, 10));
-			e.zone_in_time      = static_cast<uint32_t>(strtoul(row[16], nullptr, 10));
-			e.win_points        = static_cast<uint16_t>(strtoul(row[17], nullptr, 10));
-			e.lose_points       = static_cast<uint16_t>(strtoul(row[18], nullptr, 10));
-			e.theme             = static_cast<uint8_t>(strtoul(row[19], nullptr, 10));
-			e.zone_in_zone_id   = static_cast<uint16_t>(strtoul(row[20], nullptr, 10));
-			e.zone_in_x         = strtof(row[21], nullptr);
-			e.zone_in_y         = strtof(row[22], nullptr);
-			e.zone_in_object_id = static_cast<int16_t>(atoi(row[23]));
-			e.dest_x            = strtof(row[24], nullptr);
-			e.dest_y            = strtof(row[25], nullptr);
-			e.dest_z            = strtof(row[26], nullptr);
-			e.dest_h            = strtof(row[27], nullptr);
-			e.graveyard_zone_id = static_cast<uint32_t>(strtoul(row[28], nullptr, 10));
-			e.graveyard_x       = strtof(row[29], nullptr);
-			e.graveyard_y       = strtof(row[30], nullptr);
-			e.graveyard_z       = strtof(row[31], nullptr);
+			e.duration          = row[15] ? static_cast<uint32_t>(strtoul(row[15], nullptr, 10)) : 7200;
+			e.zone_in_time      = row[16] ? static_cast<uint32_t>(strtoul(row[16], nullptr, 10)) : 1800;
+			e.win_points        = row[17] ? static_cast<uint16_t>(strtoul(row[17], nullptr, 10)) : 0;
+			e.lose_points       = row[18] ? static_cast<uint16_t>(strtoul(row[18], nullptr, 10)) : 0;
+			e.theme             = row[19] ? static_cast<uint8_t>(strtoul(row[19], nullptr, 10)) : 1;
+			e.zone_in_zone_id   = row[20] ? static_cast<uint16_t>(strtoul(row[20], nullptr, 10)) : 0;
+			e.zone_in_x         = row[21] ? strtof(row[21], nullptr) : 0;
+			e.zone_in_y         = row[22] ? strtof(row[22], nullptr) : 0;
+			e.zone_in_object_id = row[23] ? static_cast<int16_t>(atoi(row[23])) : 0;
+			e.dest_x            = row[24] ? strtof(row[24], nullptr) : 0;
+			e.dest_y            = row[25] ? strtof(row[25], nullptr) : 0;
+			e.dest_z            = row[26] ? strtof(row[26], nullptr) : 0;
+			e.dest_h            = row[27] ? strtof(row[27], nullptr) : 0;
+			e.graveyard_zone_id = row[28] ? static_cast<uint32_t>(strtoul(row[28], nullptr, 10)) : 0;
+			e.graveyard_x       = row[29] ? strtof(row[29], nullptr) : 0;
+			e.graveyard_y       = row[30] ? strtof(row[30], nullptr) : 0;
+			e.graveyard_z       = row[31] ? strtof(row[31], nullptr) : 0;
 
 			return e;
 		}
@@ -489,38 +490,38 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			AdventureTemplate e{};
 
-			e.id                = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
+			e.id                = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
 			e.zone              = row[1] ? row[1] : "";
-			e.zone_version      = static_cast<uint8_t>(strtoul(row[2], nullptr, 10));
-			e.is_hard           = static_cast<uint8_t>(strtoul(row[3], nullptr, 10));
-			e.is_raid           = static_cast<uint8_t>(strtoul(row[4], nullptr, 10));
-			e.min_level         = static_cast<uint8_t>(strtoul(row[5], nullptr, 10));
-			e.max_level         = static_cast<uint8_t>(strtoul(row[6], nullptr, 10));
-			e.type              = static_cast<uint8_t>(strtoul(row[7], nullptr, 10));
-			e.type_data         = static_cast<uint32_t>(strtoul(row[8], nullptr, 10));
-			e.type_count        = static_cast<uint16_t>(strtoul(row[9], nullptr, 10));
-			e.assa_x            = strtof(row[10], nullptr);
-			e.assa_y            = strtof(row[11], nullptr);
-			e.assa_z            = strtof(row[12], nullptr);
-			e.assa_h            = strtof(row[13], nullptr);
+			e.zone_version      = row[2] ? static_cast<uint8_t>(strtoul(row[2], nullptr, 10)) : 0;
+			e.is_hard           = row[3] ? static_cast<uint8_t>(strtoul(row[3], nullptr, 10)) : 0;
+			e.is_raid           = row[4] ? static_cast<uint8_t>(strtoul(row[4], nullptr, 10)) : 0;
+			e.min_level         = row[5] ? static_cast<uint8_t>(strtoul(row[5], nullptr, 10)) : 1;
+			e.max_level         = row[6] ? static_cast<uint8_t>(strtoul(row[6], nullptr, 10)) : 65;
+			e.type              = row[7] ? static_cast<uint8_t>(strtoul(row[7], nullptr, 10)) : 0;
+			e.type_data         = row[8] ? static_cast<uint32_t>(strtoul(row[8], nullptr, 10)) : 0;
+			e.type_count        = row[9] ? static_cast<uint16_t>(strtoul(row[9], nullptr, 10)) : 0;
+			e.assa_x            = row[10] ? strtof(row[10], nullptr) : 0;
+			e.assa_y            = row[11] ? strtof(row[11], nullptr) : 0;
+			e.assa_z            = row[12] ? strtof(row[12], nullptr) : 0;
+			e.assa_h            = row[13] ? strtof(row[13], nullptr) : 0;
 			e.text              = row[14] ? row[14] : "";
-			e.duration          = static_cast<uint32_t>(strtoul(row[15], nullptr, 10));
-			e.zone_in_time      = static_cast<uint32_t>(strtoul(row[16], nullptr, 10));
-			e.win_points        = static_cast<uint16_t>(strtoul(row[17], nullptr, 10));
-			e.lose_points       = static_cast<uint16_t>(strtoul(row[18], nullptr, 10));
-			e.theme             = static_cast<uint8_t>(strtoul(row[19], nullptr, 10));
-			e.zone_in_zone_id   = static_cast<uint16_t>(strtoul(row[20], nullptr, 10));
-			e.zone_in_x         = strtof(row[21], nullptr);
-			e.zone_in_y         = strtof(row[22], nullptr);
-			e.zone_in_object_id = static_cast<int16_t>(atoi(row[23]));
-			e.dest_x            = strtof(row[24], nullptr);
-			e.dest_y            = strtof(row[25], nullptr);
-			e.dest_z            = strtof(row[26], nullptr);
-			e.dest_h            = strtof(row[27], nullptr);
-			e.graveyard_zone_id = static_cast<uint32_t>(strtoul(row[28], nullptr, 10));
-			e.graveyard_x       = strtof(row[29], nullptr);
-			e.graveyard_y       = strtof(row[30], nullptr);
-			e.graveyard_z       = strtof(row[31], nullptr);
+			e.duration          = row[15] ? static_cast<uint32_t>(strtoul(row[15], nullptr, 10)) : 7200;
+			e.zone_in_time      = row[16] ? static_cast<uint32_t>(strtoul(row[16], nullptr, 10)) : 1800;
+			e.win_points        = row[17] ? static_cast<uint16_t>(strtoul(row[17], nullptr, 10)) : 0;
+			e.lose_points       = row[18] ? static_cast<uint16_t>(strtoul(row[18], nullptr, 10)) : 0;
+			e.theme             = row[19] ? static_cast<uint8_t>(strtoul(row[19], nullptr, 10)) : 1;
+			e.zone_in_zone_id   = row[20] ? static_cast<uint16_t>(strtoul(row[20], nullptr, 10)) : 0;
+			e.zone_in_x         = row[21] ? strtof(row[21], nullptr) : 0;
+			e.zone_in_y         = row[22] ? strtof(row[22], nullptr) : 0;
+			e.zone_in_object_id = row[23] ? static_cast<int16_t>(atoi(row[23])) : 0;
+			e.dest_x            = row[24] ? strtof(row[24], nullptr) : 0;
+			e.dest_y            = row[25] ? strtof(row[25], nullptr) : 0;
+			e.dest_z            = row[26] ? strtof(row[26], nullptr) : 0;
+			e.dest_h            = row[27] ? strtof(row[27], nullptr) : 0;
+			e.graveyard_zone_id = row[28] ? static_cast<uint32_t>(strtoul(row[28], nullptr, 10)) : 0;
+			e.graveyard_x       = row[29] ? strtof(row[29], nullptr) : 0;
+			e.graveyard_y       = row[30] ? strtof(row[30], nullptr) : 0;
+			e.graveyard_z       = row[31] ? strtof(row[31], nullptr) : 0;
 
 			all_entries.push_back(e);
 		}
@@ -545,38 +546,38 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			AdventureTemplate e{};
 
-			e.id                = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
+			e.id                = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
 			e.zone              = row[1] ? row[1] : "";
-			e.zone_version      = static_cast<uint8_t>(strtoul(row[2], nullptr, 10));
-			e.is_hard           = static_cast<uint8_t>(strtoul(row[3], nullptr, 10));
-			e.is_raid           = static_cast<uint8_t>(strtoul(row[4], nullptr, 10));
-			e.min_level         = static_cast<uint8_t>(strtoul(row[5], nullptr, 10));
-			e.max_level         = static_cast<uint8_t>(strtoul(row[6], nullptr, 10));
-			e.type              = static_cast<uint8_t>(strtoul(row[7], nullptr, 10));
-			e.type_data         = static_cast<uint32_t>(strtoul(row[8], nullptr, 10));
-			e.type_count        = static_cast<uint16_t>(strtoul(row[9], nullptr, 10));
-			e.assa_x            = strtof(row[10], nullptr);
-			e.assa_y            = strtof(row[11], nullptr);
-			e.assa_z            = strtof(row[12], nullptr);
-			e.assa_h            = strtof(row[13], nullptr);
+			e.zone_version      = row[2] ? static_cast<uint8_t>(strtoul(row[2], nullptr, 10)) : 0;
+			e.is_hard           = row[3] ? static_cast<uint8_t>(strtoul(row[3], nullptr, 10)) : 0;
+			e.is_raid           = row[4] ? static_cast<uint8_t>(strtoul(row[4], nullptr, 10)) : 0;
+			e.min_level         = row[5] ? static_cast<uint8_t>(strtoul(row[5], nullptr, 10)) : 1;
+			e.max_level         = row[6] ? static_cast<uint8_t>(strtoul(row[6], nullptr, 10)) : 65;
+			e.type              = row[7] ? static_cast<uint8_t>(strtoul(row[7], nullptr, 10)) : 0;
+			e.type_data         = row[8] ? static_cast<uint32_t>(strtoul(row[8], nullptr, 10)) : 0;
+			e.type_count        = row[9] ? static_cast<uint16_t>(strtoul(row[9], nullptr, 10)) : 0;
+			e.assa_x            = row[10] ? strtof(row[10], nullptr) : 0;
+			e.assa_y            = row[11] ? strtof(row[11], nullptr) : 0;
+			e.assa_z            = row[12] ? strtof(row[12], nullptr) : 0;
+			e.assa_h            = row[13] ? strtof(row[13], nullptr) : 0;
 			e.text              = row[14] ? row[14] : "";
-			e.duration          = static_cast<uint32_t>(strtoul(row[15], nullptr, 10));
-			e.zone_in_time      = static_cast<uint32_t>(strtoul(row[16], nullptr, 10));
-			e.win_points        = static_cast<uint16_t>(strtoul(row[17], nullptr, 10));
-			e.lose_points       = static_cast<uint16_t>(strtoul(row[18], nullptr, 10));
-			e.theme             = static_cast<uint8_t>(strtoul(row[19], nullptr, 10));
-			e.zone_in_zone_id   = static_cast<uint16_t>(strtoul(row[20], nullptr, 10));
-			e.zone_in_x         = strtof(row[21], nullptr);
-			e.zone_in_y         = strtof(row[22], nullptr);
-			e.zone_in_object_id = static_cast<int16_t>(atoi(row[23]));
-			e.dest_x            = strtof(row[24], nullptr);
-			e.dest_y            = strtof(row[25], nullptr);
-			e.dest_z            = strtof(row[26], nullptr);
-			e.dest_h            = strtof(row[27], nullptr);
-			e.graveyard_zone_id = static_cast<uint32_t>(strtoul(row[28], nullptr, 10));
-			e.graveyard_x       = strtof(row[29], nullptr);
-			e.graveyard_y       = strtof(row[30], nullptr);
-			e.graveyard_z       = strtof(row[31], nullptr);
+			e.duration          = row[15] ? static_cast<uint32_t>(strtoul(row[15], nullptr, 10)) : 7200;
+			e.zone_in_time      = row[16] ? static_cast<uint32_t>(strtoul(row[16], nullptr, 10)) : 1800;
+			e.win_points        = row[17] ? static_cast<uint16_t>(strtoul(row[17], nullptr, 10)) : 0;
+			e.lose_points       = row[18] ? static_cast<uint16_t>(strtoul(row[18], nullptr, 10)) : 0;
+			e.theme             = row[19] ? static_cast<uint8_t>(strtoul(row[19], nullptr, 10)) : 1;
+			e.zone_in_zone_id   = row[20] ? static_cast<uint16_t>(strtoul(row[20], nullptr, 10)) : 0;
+			e.zone_in_x         = row[21] ? strtof(row[21], nullptr) : 0;
+			e.zone_in_y         = row[22] ? strtof(row[22], nullptr) : 0;
+			e.zone_in_object_id = row[23] ? static_cast<int16_t>(atoi(row[23])) : 0;
+			e.dest_x            = row[24] ? strtof(row[24], nullptr) : 0;
+			e.dest_y            = row[25] ? strtof(row[25], nullptr) : 0;
+			e.dest_z            = row[26] ? strtof(row[26], nullptr) : 0;
+			e.dest_h            = row[27] ? strtof(row[27], nullptr) : 0;
+			e.graveyard_zone_id = row[28] ? static_cast<uint32_t>(strtoul(row[28], nullptr, 10)) : 0;
+			e.graveyard_x       = row[29] ? strtof(row[29], nullptr) : 0;
+			e.graveyard_y       = row[30] ? strtof(row[30], nullptr) : 0;
+			e.graveyard_z       = row[31] ? strtof(row[31], nullptr) : 0;
 
 			all_entries.push_back(e);
 		}
@@ -635,6 +636,126 @@ 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 AdventureTemplate &e
+	)
+	{
+		std::vector<std::string> v;
+
+		v.push_back(std::to_string(e.id));
+		v.push_back("'" + Strings::Escape(e.zone) + "'");
+		v.push_back(std::to_string(e.zone_version));
+		v.push_back(std::to_string(e.is_hard));
+		v.push_back(std::to_string(e.is_raid));
+		v.push_back(std::to_string(e.min_level));
+		v.push_back(std::to_string(e.max_level));
+		v.push_back(std::to_string(e.type));
+		v.push_back(std::to_string(e.type_data));
+		v.push_back(std::to_string(e.type_count));
+		v.push_back(std::to_string(e.assa_x));
+		v.push_back(std::to_string(e.assa_y));
+		v.push_back(std::to_string(e.assa_z));
+		v.push_back(std::to_string(e.assa_h));
+		v.push_back("'" + Strings::Escape(e.text) + "'");
+		v.push_back(std::to_string(e.duration));
+		v.push_back(std::to_string(e.zone_in_time));
+		v.push_back(std::to_string(e.win_points));
+		v.push_back(std::to_string(e.lose_points));
+		v.push_back(std::to_string(e.theme));
+		v.push_back(std::to_string(e.zone_in_zone_id));
+		v.push_back(std::to_string(e.zone_in_x));
+		v.push_back(std::to_string(e.zone_in_y));
+		v.push_back(std::to_string(e.zone_in_object_id));
+		v.push_back(std::to_string(e.dest_x));
+		v.push_back(std::to_string(e.dest_y));
+		v.push_back(std::to_string(e.dest_z));
+		v.push_back(std::to_string(e.dest_h));
+		v.push_back(std::to_string(e.graveyard_zone_id));
+		v.push_back(std::to_string(e.graveyard_x));
+		v.push_back(std::to_string(e.graveyard_y));
+		v.push_back(std::to_string(e.graveyard_z));
+		v.push_back(std::to_string(e.graveyard_radius));
+
+		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<AdventureTemplate> &entries
+	)
+	{
+		std::vector<std::string> insert_chunks;
+
+		for (auto &e: entries) {
+			std::vector<std::string> v;
+
+			v.push_back(std::to_string(e.id));
+			v.push_back("'" + Strings::Escape(e.zone) + "'");
+			v.push_back(std::to_string(e.zone_version));
+			v.push_back(std::to_string(e.is_hard));
+			v.push_back(std::to_string(e.is_raid));
+			v.push_back(std::to_string(e.min_level));
+			v.push_back(std::to_string(e.max_level));
+			v.push_back(std::to_string(e.type));
+			v.push_back(std::to_string(e.type_data));
+			v.push_back(std::to_string(e.type_count));
+			v.push_back(std::to_string(e.assa_x));
+			v.push_back(std::to_string(e.assa_y));
+			v.push_back(std::to_string(e.assa_z));
+			v.push_back(std::to_string(e.assa_h));
+			v.push_back("'" + Strings::Escape(e.text) + "'");
+			v.push_back(std::to_string(e.duration));
+			v.push_back(std::to_string(e.zone_in_time));
+			v.push_back(std::to_string(e.win_points));
+			v.push_back(std::to_string(e.lose_points));
+			v.push_back(std::to_string(e.theme));
+			v.push_back(std::to_string(e.zone_in_zone_id));
+			v.push_back(std::to_string(e.zone_in_x));
+			v.push_back(std::to_string(e.zone_in_y));
+			v.push_back(std::to_string(e.zone_in_object_id));
+			v.push_back(std::to_string(e.dest_x));
+			v.push_back(std::to_string(e.dest_y));
+			v.push_back(std::to_string(e.dest_z));
+			v.push_back(std::to_string(e.dest_h));
+			v.push_back(std::to_string(e.graveyard_zone_id));
+			v.push_back(std::to_string(e.graveyard_x));
+			v.push_back(std::to_string(e.graveyard_y));
+			v.push_back(std::to_string(e.graveyard_z));
+			v.push_back(std::to_string(e.graveyard_radius));
+
+			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_ADVENTURE_TEMPLATE_REPOSITORY_H

common/repositories/base/base_alternate_currency_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_ALTERNATE_CURRENCY_REPOSITORY_H
@@ -108,8 +108,9 @@ public:
 	{
 		auto results = db.QueryDatabase(
 			fmt::format(
-				"{} WHERE id = {} LIMIT 1",
+				"{} WHERE {} = {} LIMIT 1",
 				BaseSelect(),
+				PrimaryKey(),
 				alternate_currency_id
 			)
 		);
@@ -118,8 +119,8 @@ public:
 		if (results.RowCount() == 1) {
 			AlternateCurrency e{};
 
-			e.id      = static_cast<int32_t>(atoi(row[0]));
-			e.item_id = static_cast<int32_t>(atoi(row[1]));
+			e.id      = row[0] ? static_cast<int32_t>(atoi(row[0])) : 0;
+			e.item_id = row[1] ? static_cast<int32_t>(atoi(row[1])) : 0;
 
 			return e;
 		}
@@ -242,8 +243,8 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			AlternateCurrency e{};
 
-			e.id      = static_cast<int32_t>(atoi(row[0]));
-			e.item_id = static_cast<int32_t>(atoi(row[1]));
+			e.id      = row[0] ? static_cast<int32_t>(atoi(row[0])) : 0;
+			e.item_id = row[1] ? static_cast<int32_t>(atoi(row[1])) : 0;
 
 			all_entries.push_back(e);
 		}
@@ -268,8 +269,8 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			AlternateCurrency e{};
 
-			e.id      = static_cast<int32_t>(atoi(row[0]));
-			e.item_id = static_cast<int32_t>(atoi(row[1]));
+			e.id      = row[0] ? static_cast<int32_t>(atoi(row[0])) : 0;
+			e.item_id = row[1] ? static_cast<int32_t>(atoi(row[1])) : 0;
 
 			all_entries.push_back(e);
 		}
@@ -328,6 +329,64 @@ 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 AlternateCurrency &e
+	)
+	{
+		std::vector<std::string> v;
+
+		v.push_back(std::to_string(e.id));
+		v.push_back(std::to_string(e.item_id));
+
+		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<AlternateCurrency> &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.item_id));
+
+			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_ALTERNATE_CURRENCY_REPOSITORY_H

common/repositories/base/base_auras_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_AURAS_REPOSITORY_H
@@ -144,8 +144,9 @@ public:
 	{
 		auto results = db.QueryDatabase(
 			fmt::format(
-				"{} WHERE id = {} LIMIT 1",
+				"{} WHERE {} = {} LIMIT 1",
 				BaseSelect(),
+				PrimaryKey(),
 				auras_id
 			)
 		);
@@ -154,17 +155,17 @@ public:
 		if (results.RowCount() == 1) {
 			Auras e{};
 
-			e.type       = static_cast<int32_t>(atoi(row[0]));
-			e.npc_type   = static_cast<int32_t>(atoi(row[1]));
+			e.type       = row[0] ? static_cast<int32_t>(atoi(row[0])) : 0;
+			e.npc_type   = row[1] ? static_cast<int32_t>(atoi(row[1])) : 0;
 			e.name       = row[2] ? row[2] : "";
-			e.spell_id   = static_cast<int32_t>(atoi(row[3]));
-			e.distance   = static_cast<int32_t>(atoi(row[4]));
-			e.aura_type  = static_cast<int32_t>(atoi(row[5]));
-			e.spawn_type = static_cast<int32_t>(atoi(row[6]));
-			e.movement   = static_cast<int32_t>(atoi(row[7]));
-			e.duration   = static_cast<int32_t>(atoi(row[8]));
-			e.icon       = static_cast<int32_t>(atoi(row[9]));
-			e.cast_time  = static_cast<int32_t>(atoi(row[10]));
+			e.spell_id   = row[3] ? static_cast<int32_t>(atoi(row[3])) : 0;
+			e.distance   = row[4] ? static_cast<int32_t>(atoi(row[4])) : 60;
+			e.aura_type  = row[5] ? static_cast<int32_t>(atoi(row[5])) : 1;
+			e.spawn_type = row[6] ? static_cast<int32_t>(atoi(row[6])) : 0;
+			e.movement   = row[7] ? static_cast<int32_t>(atoi(row[7])) : 0;
+			e.duration   = row[8] ? static_cast<int32_t>(atoi(row[8])) : 5400;
+			e.icon       = row[9] ? static_cast<int32_t>(atoi(row[9])) : -1;
+			e.cast_time  = row[10] ? static_cast<int32_t>(atoi(row[10])) : 0;
 
 			return e;
 		}
@@ -314,17 +315,17 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			Auras e{};
 
-			e.type       = static_cast<int32_t>(atoi(row[0]));
-			e.npc_type   = static_cast<int32_t>(atoi(row[1]));
+			e.type       = row[0] ? static_cast<int32_t>(atoi(row[0])) : 0;
+			e.npc_type   = row[1] ? static_cast<int32_t>(atoi(row[1])) : 0;
 			e.name       = row[2] ? row[2] : "";
-			e.spell_id   = static_cast<int32_t>(atoi(row[3]));
-			e.distance   = static_cast<int32_t>(atoi(row[4]));
-			e.aura_type  = static_cast<int32_t>(atoi(row[5]));
-			e.spawn_type = static_cast<int32_t>(atoi(row[6]));
-			e.movement   = static_cast<int32_t>(atoi(row[7]));
-			e.duration   = static_cast<int32_t>(atoi(row[8]));
-			e.icon       = static_cast<int32_t>(atoi(row[9]));
-			e.cast_time  = static_cast<int32_t>(atoi(row[10]));
+			e.spell_id   = row[3] ? static_cast<int32_t>(atoi(row[3])) : 0;
+			e.distance   = row[4] ? static_cast<int32_t>(atoi(row[4])) : 60;
+			e.aura_type  = row[5] ? static_cast<int32_t>(atoi(row[5])) : 1;
+			e.spawn_type = row[6] ? static_cast<int32_t>(atoi(row[6])) : 0;
+			e.movement   = row[7] ? static_cast<int32_t>(atoi(row[7])) : 0;
+			e.duration   = row[8] ? static_cast<int32_t>(atoi(row[8])) : 5400;
+			e.icon       = row[9] ? static_cast<int32_t>(atoi(row[9])) : -1;
+			e.cast_time  = row[10] ? static_cast<int32_t>(atoi(row[10])) : 0;
 
 			all_entries.push_back(e);
 		}
@@ -349,17 +350,17 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			Auras e{};
 
-			e.type       = static_cast<int32_t>(atoi(row[0]));
-			e.npc_type   = static_cast<int32_t>(atoi(row[1]));
+			e.type       = row[0] ? static_cast<int32_t>(atoi(row[0])) : 0;
+			e.npc_type   = row[1] ? static_cast<int32_t>(atoi(row[1])) : 0;
 			e.name       = row[2] ? row[2] : "";
-			e.spell_id   = static_cast<int32_t>(atoi(row[3]));
-			e.distance   = static_cast<int32_t>(atoi(row[4]));
-			e.aura_type  = static_cast<int32_t>(atoi(row[5]));
-			e.spawn_type = static_cast<int32_t>(atoi(row[6]));
-			e.movement   = static_cast<int32_t>(atoi(row[7]));
-			e.duration   = static_cast<int32_t>(atoi(row[8]));
-			e.icon       = static_cast<int32_t>(atoi(row[9]));
-			e.cast_time  = static_cast<int32_t>(atoi(row[10]));
+			e.spell_id   = row[3] ? static_cast<int32_t>(atoi(row[3])) : 0;
+			e.distance   = row[4] ? static_cast<int32_t>(atoi(row[4])) : 60;
+			e.aura_type  = row[5] ? static_cast<int32_t>(atoi(row[5])) : 1;
+			e.spawn_type = row[6] ? static_cast<int32_t>(atoi(row[6])) : 0;
+			e.movement   = row[7] ? static_cast<int32_t>(atoi(row[7])) : 0;
+			e.duration   = row[8] ? static_cast<int32_t>(atoi(row[8])) : 5400;
+			e.icon       = row[9] ? static_cast<int32_t>(atoi(row[9])) : -1;
+			e.cast_time  = row[10] ? static_cast<int32_t>(atoi(row[10])) : 0;
 
 			all_entries.push_back(e);
 		}
@@ -418,6 +419,82 @@ 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 Auras &e
+	)
+	{
+		std::vector<std::string> v;
+
+		v.push_back(std::to_string(e.type));
+		v.push_back(std::to_string(e.npc_type));
+		v.push_back("'" + Strings::Escape(e.name) + "'");
+		v.push_back(std::to_string(e.spell_id));
+		v.push_back(std::to_string(e.distance));
+		v.push_back(std::to_string(e.aura_type));
+		v.push_back(std::to_string(e.spawn_type));
+		v.push_back(std::to_string(e.movement));
+		v.push_back(std::to_string(e.duration));
+		v.push_back(std::to_string(e.icon));
+		v.push_back(std::to_string(e.cast_time));
+
+		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<Auras> &entries
+	)
+	{
+		std::vector<std::string> insert_chunks;
+
+		for (auto &e: entries) {
+			std::vector<std::string> v;
+
+			v.push_back(std::to_string(e.type));
+			v.push_back(std::to_string(e.npc_type));
+			v.push_back("'" + Strings::Escape(e.name) + "'");
+			v.push_back(std::to_string(e.spell_id));
+			v.push_back(std::to_string(e.distance));
+			v.push_back(std::to_string(e.aura_type));
+			v.push_back(std::to_string(e.spawn_type));
+			v.push_back(std::to_string(e.movement));
+			v.push_back(std::to_string(e.duration));
+			v.push_back(std::to_string(e.icon));
+			v.push_back(std::to_string(e.cast_time));
+
+			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_AURAS_REPOSITORY_H

common/repositories/base/base_base_data_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_BASE_DATA_REPOSITORY_H
@@ -19,16 +19,16 @@
 class BaseBaseDataRepository {
 public:
 	struct BaseData {
-		uint32_t level;
-		uint32_t class_;
-		double   hp;
-		double   mana;
-		double   end;
-		double   unk1;
-		double   unk2;
-		double   hp_fac;
-		double   mana_fac;
-		double   end_fac;
+		uint8_t level;
+		uint8_t class_;
+		double  hp;
+		double  mana;
+		double  end;
+		double  hp_regen;
+		double  end_regen;
+		double  hp_fac;
+		double  mana_fac;
+		double  end_fac;
 	};
 
 	static std::string PrimaryKey()
@@ -44,8 +44,8 @@ public:
 			"hp",
 			"mana",
 			"end",
-			"unk1",
-			"unk2",
+			"hp_regen",
+			"end_regen",
 			"hp_fac",
 			"mana_fac",
 			"end_fac",
@@ -60,8 +60,8 @@ public:
 			"hp",
 			"mana",
 			"end",
-			"unk1",
-			"unk2",
+			"hp_regen",
+			"end_regen",
 			"hp_fac",
 			"mana_fac",
 			"end_fac",
@@ -105,16 +105,16 @@ public:
 	{
 		BaseData e{};
 
-		e.level    = 0;
-		e.class_   = 0;
-		e.hp       = 0;
-		e.mana     = 0;
-		e.end      = 0;
-		e.unk1     = 0;
-		e.unk2     = 0;
-		e.hp_fac   = 0;
-		e.mana_fac = 0;
-		e.end_fac  = 0;
+		e.level     = 0;
+		e.class_    = 0;
+		e.hp        = 0;
+		e.mana      = 0;
+		e.end       = 0;
+		e.hp_regen  = 0;
+		e.end_regen = 0;
+		e.hp_fac    = 0;
+		e.mana_fac  = 0;
+		e.end_fac   = 0;
 
 		return e;
 	}
@@ -140,8 +140,9 @@ public:
 	{
 		auto results = db.QueryDatabase(
 			fmt::format(
-				"{} WHERE id = {} LIMIT 1",
+				"{} WHERE {} = {} LIMIT 1",
 				BaseSelect(),
+				PrimaryKey(),
 				base_data_id
 			)
 		);
@@ -150,16 +151,16 @@ public:
 		if (results.RowCount() == 1) {
 			BaseData e{};
 
-			e.level    = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.class_   = static_cast<uint32_t>(strtoul(row[1], nullptr, 10));
-			e.hp       = strtod(row[2], nullptr);
-			e.mana     = strtod(row[3], nullptr);
-			e.end      = strtod(row[4], nullptr);
-			e.unk1     = strtod(row[5], nullptr);
-			e.unk2     = strtod(row[6], nullptr);
-			e.hp_fac   = strtod(row[7], nullptr);
-			e.mana_fac = strtod(row[8], nullptr);
-			e.end_fac  = strtod(row[9], nullptr);
+			e.level     = row[0] ? static_cast<uint8_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.class_    = row[1] ? static_cast<uint8_t>(strtoul(row[1], nullptr, 10)) : 0;
+			e.hp        = row[2] ? strtod(row[2], nullptr) : 0;
+			e.mana      = row[3] ? strtod(row[3], nullptr) : 0;
+			e.end       = row[4] ? strtod(row[4], nullptr) : 0;
+			e.hp_regen  = row[5] ? strtod(row[5], nullptr) : 0;
+			e.end_regen = row[6] ? strtod(row[6], nullptr) : 0;
+			e.hp_fac    = row[7] ? strtod(row[7], nullptr) : 0;
+			e.mana_fac  = row[8] ? strtod(row[8], nullptr) : 0;
+			e.end_fac   = row[9] ? strtod(row[9], nullptr) : 0;
 
 			return e;
 		}
@@ -198,8 +199,8 @@ public:
 		v.push_back(columns[2] + " = " + std::to_string(e.hp));
 		v.push_back(columns[3] + " = " + std::to_string(e.mana));
 		v.push_back(columns[4] + " = " + std::to_string(e.end));
-		v.push_back(columns[5] + " = " + std::to_string(e.unk1));
-		v.push_back(columns[6] + " = " + std::to_string(e.unk2));
+		v.push_back(columns[5] + " = " + std::to_string(e.hp_regen));
+		v.push_back(columns[6] + " = " + std::to_string(e.end_regen));
 		v.push_back(columns[7] + " = " + std::to_string(e.hp_fac));
 		v.push_back(columns[8] + " = " + std::to_string(e.mana_fac));
 		v.push_back(columns[9] + " = " + std::to_string(e.end_fac));
@@ -229,8 +230,8 @@ public:
 		v.push_back(std::to_string(e.hp));
 		v.push_back(std::to_string(e.mana));
 		v.push_back(std::to_string(e.end));
-		v.push_back(std::to_string(e.unk1));
-		v.push_back(std::to_string(e.unk2));
+		v.push_back(std::to_string(e.hp_regen));
+		v.push_back(std::to_string(e.end_regen));
 		v.push_back(std::to_string(e.hp_fac));
 		v.push_back(std::to_string(e.mana_fac));
 		v.push_back(std::to_string(e.end_fac));
@@ -268,8 +269,8 @@ public:
 			v.push_back(std::to_string(e.hp));
 			v.push_back(std::to_string(e.mana));
 			v.push_back(std::to_string(e.end));
-			v.push_back(std::to_string(e.unk1));
-			v.push_back(std::to_string(e.unk2));
+			v.push_back(std::to_string(e.hp_regen));
+			v.push_back(std::to_string(e.end_regen));
 			v.push_back(std::to_string(e.hp_fac));
 			v.push_back(std::to_string(e.mana_fac));
 			v.push_back(std::to_string(e.end_fac));
@@ -306,16 +307,16 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			BaseData e{};
 
-			e.level    = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.class_   = static_cast<uint32_t>(strtoul(row[1], nullptr, 10));
-			e.hp       = strtod(row[2], nullptr);
-			e.mana     = strtod(row[3], nullptr);
-			e.end      = strtod(row[4], nullptr);
-			e.unk1     = strtod(row[5], nullptr);
-			e.unk2     = strtod(row[6], nullptr);
-			e.hp_fac   = strtod(row[7], nullptr);
-			e.mana_fac = strtod(row[8], nullptr);
-			e.end_fac  = strtod(row[9], nullptr);
+			e.level     = row[0] ? static_cast<uint8_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.class_    = row[1] ? static_cast<uint8_t>(strtoul(row[1], nullptr, 10)) : 0;
+			e.hp        = row[2] ? strtod(row[2], nullptr) : 0;
+			e.mana      = row[3] ? strtod(row[3], nullptr) : 0;
+			e.end       = row[4] ? strtod(row[4], nullptr) : 0;
+			e.hp_regen  = row[5] ? strtod(row[5], nullptr) : 0;
+			e.end_regen = row[6] ? strtod(row[6], nullptr) : 0;
+			e.hp_fac    = row[7] ? strtod(row[7], nullptr) : 0;
+			e.mana_fac  = row[8] ? strtod(row[8], nullptr) : 0;
+			e.end_fac   = row[9] ? strtod(row[9], nullptr) : 0;
 
 			all_entries.push_back(e);
 		}
@@ -340,16 +341,16 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			BaseData e{};
 
-			e.level    = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.class_   = static_cast<uint32_t>(strtoul(row[1], nullptr, 10));
-			e.hp       = strtod(row[2], nullptr);
-			e.mana     = strtod(row[3], nullptr);
-			e.end      = strtod(row[4], nullptr);
-			e.unk1     = strtod(row[5], nullptr);
-			e.unk2     = strtod(row[6], nullptr);
-			e.hp_fac   = strtod(row[7], nullptr);
-			e.mana_fac = strtod(row[8], nullptr);
-			e.end_fac  = strtod(row[9], nullptr);
+			e.level     = row[0] ? static_cast<uint8_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.class_    = row[1] ? static_cast<uint8_t>(strtoul(row[1], nullptr, 10)) : 0;
+			e.hp        = row[2] ? strtod(row[2], nullptr) : 0;
+			e.mana      = row[3] ? strtod(row[3], nullptr) : 0;
+			e.end       = row[4] ? strtod(row[4], nullptr) : 0;
+			e.hp_regen  = row[5] ? strtod(row[5], nullptr) : 0;
+			e.end_regen = row[6] ? strtod(row[6], nullptr) : 0;
+			e.hp_fac    = row[7] ? strtod(row[7], nullptr) : 0;
+			e.mana_fac  = row[8] ? strtod(row[8], nullptr) : 0;
+			e.end_fac   = row[9] ? strtod(row[9], nullptr) : 0;
 
 			all_entries.push_back(e);
 		}
@@ -408,6 +409,80 @@ 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 BaseData &e
+	)
+	{
+		std::vector<std::string> v;
+
+		v.push_back(std::to_string(e.level));
+		v.push_back(std::to_string(e.class_));
+		v.push_back(std::to_string(e.hp));
+		v.push_back(std::to_string(e.mana));
+		v.push_back(std::to_string(e.end));
+		v.push_back(std::to_string(e.hp_regen));
+		v.push_back(std::to_string(e.end_regen));
+		v.push_back(std::to_string(e.hp_fac));
+		v.push_back(std::to_string(e.mana_fac));
+		v.push_back(std::to_string(e.end_fac));
+
+		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<BaseData> &entries
+	)
+	{
+		std::vector<std::string> insert_chunks;
+
+		for (auto &e: entries) {
+			std::vector<std::string> v;
+
+			v.push_back(std::to_string(e.level));
+			v.push_back(std::to_string(e.class_));
+			v.push_back(std::to_string(e.hp));
+			v.push_back(std::to_string(e.mana));
+			v.push_back(std::to_string(e.end));
+			v.push_back(std::to_string(e.hp_regen));
+			v.push_back(std::to_string(e.end_regen));
+			v.push_back(std::to_string(e.hp_fac));
+			v.push_back(std::to_string(e.mana_fac));
+			v.push_back(std::to_string(e.end_fac));
+
+			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_BASE_DATA_REPOSITORY_H

common/repositories/base/base_blocked_spells_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_BLOCKED_SPELLS_REPOSITORY_H
@@ -16,7 +16,6 @@
 #include "../../strings.h"
 #include <ctime>
 
-
 class BaseBlockedSpellsRepository {
 public:
 	struct BlockedSpells {
@@ -176,20 +175,20 @@ public:
 		if (results.RowCount() == 1) {
 			BlockedSpells e{};
 
-			e.id                     = static_cast<int32_t>(atoi(row[0]));
-			e.spellid                = static_cast<uint32_t>(strtoul(row[1], nullptr, 10));
-			e.type                   = static_cast<int8_t>(atoi(row[2]));
-			e.zoneid                 = static_cast<int32_t>(atoi(row[3]));
-			e.x                      = strtof(row[4], nullptr);
-			e.y                      = strtof(row[5], nullptr);
-			e.z                      = strtof(row[6], nullptr);
-			e.x_diff                 = strtof(row[7], nullptr);
-			e.y_diff                 = strtof(row[8], nullptr);
-			e.z_diff                 = strtof(row[9], nullptr);
+			e.id                     = row[0] ? static_cast<int32_t>(atoi(row[0])) : 0;
+			e.spellid                = row[1] ? static_cast<uint32_t>(strtoul(row[1], nullptr, 10)) : 0;
+			e.type                   = row[2] ? static_cast<int8_t>(atoi(row[2])) : 0;
+			e.zoneid                 = row[3] ? static_cast<int32_t>(atoi(row[3])) : 0;
+			e.x                      = row[4] ? strtof(row[4], nullptr) : 0;
+			e.y                      = row[5] ? strtof(row[5], nullptr) : 0;
+			e.z                      = row[6] ? strtof(row[6], nullptr) : 0;
+			e.x_diff                 = row[7] ? strtof(row[7], nullptr) : 0;
+			e.y_diff                 = row[8] ? strtof(row[8], nullptr) : 0;
+			e.z_diff                 = row[9] ? strtof(row[9], nullptr) : 0;
 			e.message                = row[10] ? row[10] : "";
 			e.description            = row[11] ? row[11] : "";
-			e.min_expansion          = static_cast<int8_t>(atoi(row[12]));
-			e.max_expansion          = static_cast<int8_t>(atoi(row[13]));
+			e.min_expansion          = row[12] ? static_cast<int8_t>(atoi(row[12])) : -1;
+			e.max_expansion          = row[13] ? static_cast<int8_t>(atoi(row[13])) : -1;
 			e.content_flags          = row[14] ? row[14] : "";
 			e.content_flags_disabled = row[15] ? row[15] : "";
 
@@ -355,20 +354,20 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			BlockedSpells e{};
 
-			e.id                     = static_cast<int32_t>(atoi(row[0]));
-			e.spellid                = static_cast<uint32_t>(strtoul(row[1], nullptr, 10));
-			e.type                   = static_cast<int8_t>(atoi(row[2]));
-			e.zoneid                 = static_cast<int32_t>(atoi(row[3]));
-			e.x                      = strtof(row[4], nullptr);
-			e.y                      = strtof(row[5], nullptr);
-			e.z                      = strtof(row[6], nullptr);
-			e.x_diff                 = strtof(row[7], nullptr);
-			e.y_diff                 = strtof(row[8], nullptr);
-			e.z_diff                 = strtof(row[9], nullptr);
+			e.id                     = row[0] ? static_cast<int32_t>(atoi(row[0])) : 0;
+			e.spellid                = row[1] ? static_cast<uint32_t>(strtoul(row[1], nullptr, 10)) : 0;
+			e.type                   = row[2] ? static_cast<int8_t>(atoi(row[2])) : 0;
+			e.zoneid                 = row[3] ? static_cast<int32_t>(atoi(row[3])) : 0;
+			e.x                      = row[4] ? strtof(row[4], nullptr) : 0;
+			e.y                      = row[5] ? strtof(row[5], nullptr) : 0;
+			e.z                      = row[6] ? strtof(row[6], nullptr) : 0;
+			e.x_diff                 = row[7] ? strtof(row[7], nullptr) : 0;
+			e.y_diff                 = row[8] ? strtof(row[8], nullptr) : 0;
+			e.z_diff                 = row[9] ? strtof(row[9], nullptr) : 0;
 			e.message                = row[10] ? row[10] : "";
 			e.description            = row[11] ? row[11] : "";
-			e.min_expansion          = static_cast<int8_t>(atoi(row[12]));
-			e.max_expansion          = static_cast<int8_t>(atoi(row[13]));
+			e.min_expansion          = row[12] ? static_cast<int8_t>(atoi(row[12])) : -1;
+			e.max_expansion          = row[13] ? static_cast<int8_t>(atoi(row[13])) : -1;
 			e.content_flags          = row[14] ? row[14] : "";
 			e.content_flags_disabled = row[15] ? row[15] : "";
 
@@ -395,20 +394,20 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			BlockedSpells e{};
 
-			e.id                     = static_cast<int32_t>(atoi(row[0]));
-			e.spellid                = static_cast<uint32_t>(strtoul(row[1], nullptr, 10));
-			e.type                   = static_cast<int8_t>(atoi(row[2]));
-			e.zoneid                 = static_cast<int32_t>(atoi(row[3]));
-			e.x                      = strtof(row[4], nullptr);
-			e.y                      = strtof(row[5], nullptr);
-			e.z                      = strtof(row[6], nullptr);
-			e.x_diff                 = strtof(row[7], nullptr);
-			e.y_diff                 = strtof(row[8], nullptr);
-			e.z_diff                 = strtof(row[9], nullptr);
+			e.id                     = row[0] ? static_cast<int32_t>(atoi(row[0])) : 0;
+			e.spellid                = row[1] ? static_cast<uint32_t>(strtoul(row[1], nullptr, 10)) : 0;
+			e.type                   = row[2] ? static_cast<int8_t>(atoi(row[2])) : 0;
+			e.zoneid                 = row[3] ? static_cast<int32_t>(atoi(row[3])) : 0;
+			e.x                      = row[4] ? strtof(row[4], nullptr) : 0;
+			e.y                      = row[5] ? strtof(row[5], nullptr) : 0;
+			e.z                      = row[6] ? strtof(row[6], nullptr) : 0;
+			e.x_diff                 = row[7] ? strtof(row[7], nullptr) : 0;
+			e.y_diff                 = row[8] ? strtof(row[8], nullptr) : 0;
+			e.z_diff                 = row[9] ? strtof(row[9], nullptr) : 0;
 			e.message                = row[10] ? row[10] : "";
 			e.description            = row[11] ? row[11] : "";
-			e.min_expansion          = static_cast<int8_t>(atoi(row[12]));
-			e.max_expansion          = static_cast<int8_t>(atoi(row[13]));
+			e.min_expansion          = row[12] ? static_cast<int8_t>(atoi(row[12])) : -1;
+			e.max_expansion          = row[13] ? static_cast<int8_t>(atoi(row[13])) : -1;
 			e.content_flags          = row[14] ? row[14] : "";
 			e.content_flags_disabled = row[15] ? row[15] : "";
 
@@ -469,6 +468,92 @@ 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 BlockedSpells &e
+	)
+	{
+		std::vector<std::string> v;
+
+		v.push_back(std::to_string(e.id));
+		v.push_back(std::to_string(e.spellid));
+		v.push_back(std::to_string(e.type));
+		v.push_back(std::to_string(e.zoneid));
+		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.x_diff));
+		v.push_back(std::to_string(e.y_diff));
+		v.push_back(std::to_string(e.z_diff));
+		v.push_back("'" + Strings::Escape(e.message) + "'");
+		v.push_back("'" + Strings::Escape(e.description) + "'");
+		v.push_back(std::to_string(e.min_expansion));
+		v.push_back(std::to_string(e.max_expansion));
+		v.push_back("'" + Strings::Escape(e.content_flags) + "'");
+		v.push_back("'" + Strings::Escape(e.content_flags_disabled) + "'");
+
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"{} VALUES ({})",
+				BaseReplace(),
+				Strings::Implode(",", v)
+			)
+		);
+
+		return (results.Success() ? results.RowsAffected() : 0);
+	}
+
+	static int ReplaceMany(
+		Database& db,
+		const std::vector<BlockedSpells> &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.spellid));
+			v.push_back(std::to_string(e.type));
+			v.push_back(std::to_string(e.zoneid));
+			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.x_diff));
+			v.push_back(std::to_string(e.y_diff));
+			v.push_back(std::to_string(e.z_diff));
+			v.push_back("'" + Strings::Escape(e.message) + "'");
+			v.push_back("'" + Strings::Escape(e.description) + "'");
+			v.push_back(std::to_string(e.min_expansion));
+			v.push_back(std::to_string(e.max_expansion));
+			v.push_back("'" + Strings::Escape(e.content_flags) + "'");
+			v.push_back("'" + Strings::Escape(e.content_flags_disabled) + "'");
+
+			insert_chunks.push_back("(" + Strings::Implode(",", v) + ")");
+		}
+
+		std::vector<std::string> v;
+
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"{} VALUES {}",
+				BaseReplace(),
+				Strings::Implode(",", insert_chunks)
+			)
+		);
+
+		return (results.Success() ? results.RowsAffected() : 0);
+	}
 };
 
 #endif //EQEMU_BASE_BLOCKED_SPELLS_REPOSITORY_H

common/repositories/base/base_books_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_BOOKS_REPOSITORY_H
@@ -116,8 +116,9 @@ public:
 	{
 		auto results = db.QueryDatabase(
 			fmt::format(
-				"{} WHERE id = {} LIMIT 1",
+				"{} WHERE {} = {} LIMIT 1",
 				BaseSelect(),
+				PrimaryKey(),
 				books_id
 			)
 		);
@@ -126,10 +127,10 @@ public:
 		if (results.RowCount() == 1) {
 			Books e{};
 
-			e.id       = static_cast<int32_t>(atoi(row[0]));
+			e.id       = row[0] ? static_cast<int32_t>(atoi(row[0])) : 0;
 			e.name     = row[1] ? row[1] : "";
 			e.txtfile  = row[2] ? row[2] : "";
-			e.language = static_cast<int32_t>(atoi(row[3]));
+			e.language = row[3] ? static_cast<int32_t>(atoi(row[3])) : 0;
 
 			return e;
 		}
@@ -257,10 +258,10 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			Books e{};
 
-			e.id       = static_cast<int32_t>(atoi(row[0]));
+			e.id       = row[0] ? static_cast<int32_t>(atoi(row[0])) : 0;
 			e.name     = row[1] ? row[1] : "";
 			e.txtfile  = row[2] ? row[2] : "";
-			e.language = static_cast<int32_t>(atoi(row[3]));
+			e.language = row[3] ? static_cast<int32_t>(atoi(row[3])) : 0;
 
 			all_entries.push_back(e);
 		}
@@ -285,10 +286,10 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			Books e{};
 
-			e.id       = static_cast<int32_t>(atoi(row[0]));
+			e.id       = row[0] ? static_cast<int32_t>(atoi(row[0])) : 0;
 			e.name     = row[1] ? row[1] : "";
 			e.txtfile  = row[2] ? row[2] : "";
-			e.language = static_cast<int32_t>(atoi(row[3]));
+			e.language = row[3] ? static_cast<int32_t>(atoi(row[3])) : 0;
 
 			all_entries.push_back(e);
 		}
@@ -347,6 +348,68 @@ 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 Books &e
+	)
+	{
+		std::vector<std::string> v;
+
+		v.push_back(std::to_string(e.id));
+		v.push_back("'" + Strings::Escape(e.name) + "'");
+		v.push_back("'" + Strings::Escape(e.txtfile) + "'");
+		v.push_back(std::to_string(e.language));
+
+		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<Books> &entries
+	)
+	{
+		std::vector<std::string> insert_chunks;
+
+		for (auto &e: entries) {
+			std::vector<std::string> v;
+
+			v.push_back(std::to_string(e.id));
+			v.push_back("'" + Strings::Escape(e.name) + "'");
+			v.push_back("'" + Strings::Escape(e.txtfile) + "'");
+			v.push_back(std::to_string(e.language));
+
+			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_BOOKS_REPOSITORY_H

common/repositories/base/base_bot_buffs_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_BOT_BUFFS_REPOSITORY_H
@@ -180,8 +180,9 @@ public:
 	{
 		auto results = db.QueryDatabase(
 			fmt::format(
-				"{} WHERE id = {} LIMIT 1",
+				"{} WHERE {} = {} LIMIT 1",
 				BaseSelect(),
+				PrimaryKey(),
 				bot_buffs_id
 			)
 		);
@@ -190,26 +191,26 @@ public:
 		if (results.RowCount() == 1) {
 			BotBuffs e{};
 
-			e.buffs_index         = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.bot_id              = static_cast<uint32_t>(strtoul(row[1], nullptr, 10));
-			e.spell_id            = static_cast<uint32_t>(strtoul(row[2], nullptr, 10));
-			e.caster_level        = static_cast<uint8_t>(strtoul(row[3], nullptr, 10));
-			e.duration_formula    = static_cast<uint32_t>(strtoul(row[4], nullptr, 10));
-			e.tics_remaining      = static_cast<uint32_t>(strtoul(row[5], nullptr, 10));
-			e.poison_counters     = static_cast<uint32_t>(strtoul(row[6], nullptr, 10));
-			e.disease_counters    = static_cast<uint32_t>(strtoul(row[7], nullptr, 10));
-			e.curse_counters      = static_cast<uint32_t>(strtoul(row[8], nullptr, 10));
-			e.corruption_counters = static_cast<uint32_t>(strtoul(row[9], nullptr, 10));
-			e.numhits             = static_cast<uint32_t>(strtoul(row[10], nullptr, 10));
-			e.melee_rune          = static_cast<uint32_t>(strtoul(row[11], nullptr, 10));
-			e.magic_rune          = static_cast<uint32_t>(strtoul(row[12], nullptr, 10));
-			e.dot_rune            = static_cast<uint32_t>(strtoul(row[13], nullptr, 10));
-			e.persistent          = static_cast<int8_t>(atoi(row[14]));
-			e.caston_x            = static_cast<int32_t>(atoi(row[15]));
-			e.caston_y            = static_cast<int32_t>(atoi(row[16]));
-			e.caston_z            = static_cast<int32_t>(atoi(row[17]));
-			e.extra_di_chance     = static_cast<uint32_t>(strtoul(row[18], nullptr, 10));
-			e.instrument_mod      = static_cast<int32_t>(atoi(row[19]));
+			e.buffs_index         = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.bot_id              = row[1] ? static_cast<uint32_t>(strtoul(row[1], nullptr, 10)) : 0;
+			e.spell_id            = row[2] ? static_cast<uint32_t>(strtoul(row[2], nullptr, 10)) : 0;
+			e.caster_level        = row[3] ? static_cast<uint8_t>(strtoul(row[3], nullptr, 10)) : 0;
+			e.duration_formula    = row[4] ? static_cast<uint32_t>(strtoul(row[4], nullptr, 10)) : 0;
+			e.tics_remaining      = row[5] ? static_cast<uint32_t>(strtoul(row[5], nullptr, 10)) : 0;
+			e.poison_counters     = row[6] ? static_cast<uint32_t>(strtoul(row[6], nullptr, 10)) : 0;
+			e.disease_counters    = row[7] ? static_cast<uint32_t>(strtoul(row[7], nullptr, 10)) : 0;
+			e.curse_counters      = row[8] ? static_cast<uint32_t>(strtoul(row[8], nullptr, 10)) : 0;
+			e.corruption_counters = row[9] ? static_cast<uint32_t>(strtoul(row[9], nullptr, 10)) : 0;
+			e.numhits             = row[10] ? static_cast<uint32_t>(strtoul(row[10], nullptr, 10)) : 0;
+			e.melee_rune          = row[11] ? static_cast<uint32_t>(strtoul(row[11], nullptr, 10)) : 0;
+			e.magic_rune          = row[12] ? static_cast<uint32_t>(strtoul(row[12], nullptr, 10)) : 0;
+			e.dot_rune            = row[13] ? static_cast<uint32_t>(strtoul(row[13], nullptr, 10)) : 0;
+			e.persistent          = row[14] ? static_cast<int8_t>(atoi(row[14])) : 0;
+			e.caston_x            = row[15] ? static_cast<int32_t>(atoi(row[15])) : 0;
+			e.caston_y            = row[16] ? static_cast<int32_t>(atoi(row[16])) : 0;
+			e.caston_z            = row[17] ? static_cast<int32_t>(atoi(row[17])) : 0;
+			e.extra_di_chance     = row[18] ? static_cast<uint32_t>(strtoul(row[18], nullptr, 10)) : 0;
+			e.instrument_mod      = row[19] ? static_cast<int32_t>(atoi(row[19])) : 10;
 
 			return e;
 		}
@@ -385,26 +386,26 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			BotBuffs e{};
 
-			e.buffs_index         = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.bot_id              = static_cast<uint32_t>(strtoul(row[1], nullptr, 10));
-			e.spell_id            = static_cast<uint32_t>(strtoul(row[2], nullptr, 10));
-			e.caster_level        = static_cast<uint8_t>(strtoul(row[3], nullptr, 10));
-			e.duration_formula    = static_cast<uint32_t>(strtoul(row[4], nullptr, 10));
-			e.tics_remaining      = static_cast<uint32_t>(strtoul(row[5], nullptr, 10));
-			e.poison_counters     = static_cast<uint32_t>(strtoul(row[6], nullptr, 10));
-			e.disease_counters    = static_cast<uint32_t>(strtoul(row[7], nullptr, 10));
-			e.curse_counters      = static_cast<uint32_t>(strtoul(row[8], nullptr, 10));
-			e.corruption_counters = static_cast<uint32_t>(strtoul(row[9], nullptr, 10));
-			e.numhits             = static_cast<uint32_t>(strtoul(row[10], nullptr, 10));
-			e.melee_rune          = static_cast<uint32_t>(strtoul(row[11], nullptr, 10));
-			e.magic_rune          = static_cast<uint32_t>(strtoul(row[12], nullptr, 10));
-			e.dot_rune            = static_cast<uint32_t>(strtoul(row[13], nullptr, 10));
-			e.persistent          = static_cast<int8_t>(atoi(row[14]));
-			e.caston_x            = static_cast<int32_t>(atoi(row[15]));
-			e.caston_y            = static_cast<int32_t>(atoi(row[16]));
-			e.caston_z            = static_cast<int32_t>(atoi(row[17]));
-			e.extra_di_chance     = static_cast<uint32_t>(strtoul(row[18], nullptr, 10));
-			e.instrument_mod      = static_cast<int32_t>(atoi(row[19]));
+			e.buffs_index         = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.bot_id              = row[1] ? static_cast<uint32_t>(strtoul(row[1], nullptr, 10)) : 0;
+			e.spell_id            = row[2] ? static_cast<uint32_t>(strtoul(row[2], nullptr, 10)) : 0;
+			e.caster_level        = row[3] ? static_cast<uint8_t>(strtoul(row[3], nullptr, 10)) : 0;
+			e.duration_formula    = row[4] ? static_cast<uint32_t>(strtoul(row[4], nullptr, 10)) : 0;
+			e.tics_remaining      = row[5] ? static_cast<uint32_t>(strtoul(row[5], nullptr, 10)) : 0;
+			e.poison_counters     = row[6] ? static_cast<uint32_t>(strtoul(row[6], nullptr, 10)) : 0;
+			e.disease_counters    = row[7] ? static_cast<uint32_t>(strtoul(row[7], nullptr, 10)) : 0;
+			e.curse_counters      = row[8] ? static_cast<uint32_t>(strtoul(row[8], nullptr, 10)) : 0;
+			e.corruption_counters = row[9] ? static_cast<uint32_t>(strtoul(row[9], nullptr, 10)) : 0;
+			e.numhits             = row[10] ? static_cast<uint32_t>(strtoul(row[10], nullptr, 10)) : 0;
+			e.melee_rune          = row[11] ? static_cast<uint32_t>(strtoul(row[11], nullptr, 10)) : 0;
+			e.magic_rune          = row[12] ? static_cast<uint32_t>(strtoul(row[12], nullptr, 10)) : 0;
+			e.dot_rune            = row[13] ? static_cast<uint32_t>(strtoul(row[13], nullptr, 10)) : 0;
+			e.persistent          = row[14] ? static_cast<int8_t>(atoi(row[14])) : 0;
+			e.caston_x            = row[15] ? static_cast<int32_t>(atoi(row[15])) : 0;
+			e.caston_y            = row[16] ? static_cast<int32_t>(atoi(row[16])) : 0;
+			e.caston_z            = row[17] ? static_cast<int32_t>(atoi(row[17])) : 0;
+			e.extra_di_chance     = row[18] ? static_cast<uint32_t>(strtoul(row[18], nullptr, 10)) : 0;
+			e.instrument_mod      = row[19] ? static_cast<int32_t>(atoi(row[19])) : 10;
 
 			all_entries.push_back(e);
 		}
@@ -429,26 +430,26 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			BotBuffs e{};
 
-			e.buffs_index         = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.bot_id              = static_cast<uint32_t>(strtoul(row[1], nullptr, 10));
-			e.spell_id            = static_cast<uint32_t>(strtoul(row[2], nullptr, 10));
-			e.caster_level        = static_cast<uint8_t>(strtoul(row[3], nullptr, 10));
-			e.duration_formula    = static_cast<uint32_t>(strtoul(row[4], nullptr, 10));
-			e.tics_remaining      = static_cast<uint32_t>(strtoul(row[5], nullptr, 10));
-			e.poison_counters     = static_cast<uint32_t>(strtoul(row[6], nullptr, 10));
-			e.disease_counters    = static_cast<uint32_t>(strtoul(row[7], nullptr, 10));
-			e.curse_counters      = static_cast<uint32_t>(strtoul(row[8], nullptr, 10));
-			e.corruption_counters = static_cast<uint32_t>(strtoul(row[9], nullptr, 10));
-			e.numhits             = static_cast<uint32_t>(strtoul(row[10], nullptr, 10));
-			e.melee_rune          = static_cast<uint32_t>(strtoul(row[11], nullptr, 10));
-			e.magic_rune          = static_cast<uint32_t>(strtoul(row[12], nullptr, 10));
-			e.dot_rune            = static_cast<uint32_t>(strtoul(row[13], nullptr, 10));
-			e.persistent          = static_cast<int8_t>(atoi(row[14]));
-			e.caston_x            = static_cast<int32_t>(atoi(row[15]));
-			e.caston_y            = static_cast<int32_t>(atoi(row[16]));
-			e.caston_z            = static_cast<int32_t>(atoi(row[17]));
-			e.extra_di_chance     = static_cast<uint32_t>(strtoul(row[18], nullptr, 10));
-			e.instrument_mod      = static_cast<int32_t>(atoi(row[19]));
+			e.buffs_index         = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.bot_id              = row[1] ? static_cast<uint32_t>(strtoul(row[1], nullptr, 10)) : 0;
+			e.spell_id            = row[2] ? static_cast<uint32_t>(strtoul(row[2], nullptr, 10)) : 0;
+			e.caster_level        = row[3] ? static_cast<uint8_t>(strtoul(row[3], nullptr, 10)) : 0;
+			e.duration_formula    = row[4] ? static_cast<uint32_t>(strtoul(row[4], nullptr, 10)) : 0;
+			e.tics_remaining      = row[5] ? static_cast<uint32_t>(strtoul(row[5], nullptr, 10)) : 0;
+			e.poison_counters     = row[6] ? static_cast<uint32_t>(strtoul(row[6], nullptr, 10)) : 0;
+			e.disease_counters    = row[7] ? static_cast<uint32_t>(strtoul(row[7], nullptr, 10)) : 0;
+			e.curse_counters      = row[8] ? static_cast<uint32_t>(strtoul(row[8], nullptr, 10)) : 0;
+			e.corruption_counters = row[9] ? static_cast<uint32_t>(strtoul(row[9], nullptr, 10)) : 0;
+			e.numhits             = row[10] ? static_cast<uint32_t>(strtoul(row[10], nullptr, 10)) : 0;
+			e.melee_rune          = row[11] ? static_cast<uint32_t>(strtoul(row[11], nullptr, 10)) : 0;
+			e.magic_rune          = row[12] ? static_cast<uint32_t>(strtoul(row[12], nullptr, 10)) : 0;
+			e.dot_rune            = row[13] ? static_cast<uint32_t>(strtoul(row[13], nullptr, 10)) : 0;
+			e.persistent          = row[14] ? static_cast<int8_t>(atoi(row[14])) : 0;
+			e.caston_x            = row[15] ? static_cast<int32_t>(atoi(row[15])) : 0;
+			e.caston_y            = row[16] ? static_cast<int32_t>(atoi(row[16])) : 0;
+			e.caston_z            = row[17] ? static_cast<int32_t>(atoi(row[17])) : 0;
+			e.extra_di_chance     = row[18] ? static_cast<uint32_t>(strtoul(row[18], nullptr, 10)) : 0;
+			e.instrument_mod      = row[19] ? static_cast<int32_t>(atoi(row[19])) : 10;
 
 			all_entries.push_back(e);
 		}
@@ -507,6 +508,100 @@ 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 BotBuffs &e
+	)
+	{
+		std::vector<std::string> v;
+
+		v.push_back(std::to_string(e.buffs_index));
+		v.push_back(std::to_string(e.bot_id));
+		v.push_back(std::to_string(e.spell_id));
+		v.push_back(std::to_string(e.caster_level));
+		v.push_back(std::to_string(e.duration_formula));
+		v.push_back(std::to_string(e.tics_remaining));
+		v.push_back(std::to_string(e.poison_counters));
+		v.push_back(std::to_string(e.disease_counters));
+		v.push_back(std::to_string(e.curse_counters));
+		v.push_back(std::to_string(e.corruption_counters));
+		v.push_back(std::to_string(e.numhits));
+		v.push_back(std::to_string(e.melee_rune));
+		v.push_back(std::to_string(e.magic_rune));
+		v.push_back(std::to_string(e.dot_rune));
+		v.push_back(std::to_string(e.persistent));
+		v.push_back(std::to_string(e.caston_x));
+		v.push_back(std::to_string(e.caston_y));
+		v.push_back(std::to_string(e.caston_z));
+		v.push_back(std::to_string(e.extra_di_chance));
+		v.push_back(std::to_string(e.instrument_mod));
+
+		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<BotBuffs> &entries
+	)
+	{
+		std::vector<std::string> insert_chunks;
+
+		for (auto &e: entries) {
+			std::vector<std::string> v;
+
+			v.push_back(std::to_string(e.buffs_index));
+			v.push_back(std::to_string(e.bot_id));
+			v.push_back(std::to_string(e.spell_id));
+			v.push_back(std::to_string(e.caster_level));
+			v.push_back(std::to_string(e.duration_formula));
+			v.push_back(std::to_string(e.tics_remaining));
+			v.push_back(std::to_string(e.poison_counters));
+			v.push_back(std::to_string(e.disease_counters));
+			v.push_back(std::to_string(e.curse_counters));
+			v.push_back(std::to_string(e.corruption_counters));
+			v.push_back(std::to_string(e.numhits));
+			v.push_back(std::to_string(e.melee_rune));
+			v.push_back(std::to_string(e.magic_rune));
+			v.push_back(std::to_string(e.dot_rune));
+			v.push_back(std::to_string(e.persistent));
+			v.push_back(std::to_string(e.caston_x));
+			v.push_back(std::to_string(e.caston_y));
+			v.push_back(std::to_string(e.caston_z));
+			v.push_back(std::to_string(e.extra_di_chance));
+			v.push_back(std::to_string(e.instrument_mod));
+
+			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_BOT_BUFFS_REPOSITORY_H

common/repositories/base/base_bot_create_combinations_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_BOT_CREATE_COMBINATIONS_REPOSITORY_H
@@ -108,8 +108,9 @@ public:
 	{
 		auto results = db.QueryDatabase(
 			fmt::format(
-				"{} WHERE id = {} LIMIT 1",
+				"{} WHERE {} = {} LIMIT 1",
 				BaseSelect(),
+				PrimaryKey(),
 				bot_create_combinations_id
 			)
 		);
@@ -118,8 +119,8 @@ public:
 		if (results.RowCount() == 1) {
 			BotCreateCombinations e{};
 
-			e.race    = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.classes = static_cast<uint32_t>(strtoul(row[1], nullptr, 10));
+			e.race    = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.classes = row[1] ? static_cast<uint32_t>(strtoul(row[1], nullptr, 10)) : 0;
 
 			return e;
 		}
@@ -242,8 +243,8 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			BotCreateCombinations e{};
 
-			e.race    = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.classes = static_cast<uint32_t>(strtoul(row[1], nullptr, 10));
+			e.race    = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.classes = row[1] ? static_cast<uint32_t>(strtoul(row[1], nullptr, 10)) : 0;
 
 			all_entries.push_back(e);
 		}
@@ -268,8 +269,8 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			BotCreateCombinations e{};
 
-			e.race    = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.classes = static_cast<uint32_t>(strtoul(row[1], nullptr, 10));
+			e.race    = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.classes = row[1] ? static_cast<uint32_t>(strtoul(row[1], nullptr, 10)) : 0;
 
 			all_entries.push_back(e);
 		}
@@ -328,6 +329,64 @@ 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 BotCreateCombinations &e
+	)
+	{
+		std::vector<std::string> v;
+
+		v.push_back(std::to_string(e.race));
+		v.push_back(std::to_string(e.classes));
+
+		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<BotCreateCombinations> &entries
+	)
+	{
+		std::vector<std::string> insert_chunks;
+
+		for (auto &e: entries) {
+			std::vector<std::string> v;
+
+			v.push_back(std::to_string(e.race));
+			v.push_back(std::to_string(e.classes));
+
+			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_BOT_CREATE_COMBINATIONS_REPOSITORY_H

common/repositories/base/base_bot_data_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_BOT_DATA_REPOSITORY_H
@@ -278,7 +278,7 @@ public:
 		e.expansion_bitmask      = -1;
 		e.enforce_spell_settings = 0;
 		e.archery_setting        = 0;
-		e.caster_range           = 0;
+		e.caster_range           = 300;
 
 		return e;
 	}
@@ -315,57 +315,57 @@ public:
 		if (results.RowCount() == 1) {
 			BotData e{};
 
-			e.bot_id                 = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.owner_id               = static_cast<uint32_t>(strtoul(row[1], nullptr, 10));
-			e.spells_id              = static_cast<uint32_t>(strtoul(row[2], nullptr, 10));
+			e.bot_id                 = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.owner_id               = row[1] ? static_cast<uint32_t>(strtoul(row[1], nullptr, 10)) : 0;
+			e.spells_id              = row[2] ? static_cast<uint32_t>(strtoul(row[2], nullptr, 10)) : 0;
 			e.name                   = row[3] ? row[3] : "";
 			e.last_name              = row[4] ? row[4] : "";
 			e.title                  = row[5] ? row[5] : "";
 			e.suffix                 = row[6] ? row[6] : "";
-			e.zone_id                = static_cast<int16_t>(atoi(row[7]));
-			e.gender                 = static_cast<int8_t>(atoi(row[8]));
-			e.race                   = static_cast<int16_t>(atoi(row[9]));
-			e.class_                 = static_cast<int8_t>(atoi(row[10]));
-			e.level                  = static_cast<uint8_t>(strtoul(row[11], nullptr, 10));
-			e.deity                  = static_cast<uint32_t>(strtoul(row[12], nullptr, 10));
-			e.creation_day           = static_cast<uint32_t>(strtoul(row[13], nullptr, 10));
-			e.last_spawn             = static_cast<uint32_t>(strtoul(row[14], nullptr, 10));
-			e.time_spawned           = static_cast<uint32_t>(strtoul(row[15], nullptr, 10));
-			e.size                   = strtof(row[16], nullptr);
-			e.face                   = static_cast<int32_t>(atoi(row[17]));
-			e.hair_color             = static_cast<int32_t>(atoi(row[18]));
-			e.hair_style             = static_cast<int32_t>(atoi(row[19]));
-			e.beard                  = static_cast<int32_t>(atoi(row[20]));
-			e.beard_color            = static_cast<int32_t>(atoi(row[21]));
-			e.eye_color_1            = static_cast<int32_t>(atoi(row[22]));
-			e.eye_color_2            = static_cast<int32_t>(atoi(row[23]));
-			e.drakkin_heritage       = static_cast<int32_t>(atoi(row[24]));
-			e.drakkin_tattoo         = static_cast<int32_t>(atoi(row[25]));
-			e.drakkin_details        = static_cast<int32_t>(atoi(row[26]));
-			e.ac                     = static_cast<int16_t>(atoi(row[27]));
-			e.atk                    = static_cast<int32_t>(atoi(row[28]));
-			e.hp                     = static_cast<int32_t>(atoi(row[29]));
-			e.mana                   = static_cast<int32_t>(atoi(row[30]));
-			e.str                    = static_cast<int32_t>(atoi(row[31]));
-			e.sta                    = static_cast<int32_t>(atoi(row[32]));
-			e.cha                    = static_cast<int32_t>(atoi(row[33]));
-			e.dex                    = static_cast<int32_t>(atoi(row[34]));
-			e.int_                   = static_cast<int32_t>(atoi(row[35]));
-			e.agi                    = static_cast<int32_t>(atoi(row[36]));
-			e.wis                    = static_cast<int32_t>(atoi(row[37]));
-			e.fire                   = static_cast<int16_t>(atoi(row[38]));
-			e.cold                   = static_cast<int16_t>(atoi(row[39]));
-			e.magic                  = static_cast<int16_t>(atoi(row[40]));
-			e.poison                 = static_cast<int16_t>(atoi(row[41]));
-			e.disease                = static_cast<int16_t>(atoi(row[42]));
-			e.corruption             = static_cast<int16_t>(atoi(row[43]));
-			e.show_helm              = static_cast<uint32_t>(strtoul(row[44], nullptr, 10));
-			e.follow_distance        = static_cast<uint32_t>(strtoul(row[45], nullptr, 10));
-			e.stop_melee_level       = static_cast<uint8_t>(strtoul(row[46], nullptr, 10));
-			e.expansion_bitmask      = static_cast<int32_t>(atoi(row[47]));
-			e.enforce_spell_settings = static_cast<uint8_t>(strtoul(row[48], nullptr, 10));
-			e.archery_setting        = static_cast<uint8_t>(strtoul(row[49], nullptr, 10));
-			e.caster_range           = static_cast<uint32_t>(strtoul(row[50], nullptr, 10));
+			e.zone_id                = row[7] ? static_cast<int16_t>(atoi(row[7])) : 0;
+			e.gender                 = row[8] ? static_cast<int8_t>(atoi(row[8])) : 0;
+			e.race                   = row[9] ? static_cast<int16_t>(atoi(row[9])) : 0;
+			e.class_                 = row[10] ? static_cast<int8_t>(atoi(row[10])) : 0;
+			e.level                  = row[11] ? static_cast<uint8_t>(strtoul(row[11], nullptr, 10)) : 0;
+			e.deity                  = row[12] ? static_cast<uint32_t>(strtoul(row[12], nullptr, 10)) : 0;
+			e.creation_day           = row[13] ? static_cast<uint32_t>(strtoul(row[13], nullptr, 10)) : 0;
+			e.last_spawn             = row[14] ? static_cast<uint32_t>(strtoul(row[14], nullptr, 10)) : 0;
+			e.time_spawned           = row[15] ? static_cast<uint32_t>(strtoul(row[15], nullptr, 10)) : 0;
+			e.size                   = row[16] ? strtof(row[16], nullptr) : 0;
+			e.face                   = row[17] ? static_cast<int32_t>(atoi(row[17])) : 1;
+			e.hair_color             = row[18] ? static_cast<int32_t>(atoi(row[18])) : 1;
+			e.hair_style             = row[19] ? static_cast<int32_t>(atoi(row[19])) : 1;
+			e.beard                  = row[20] ? static_cast<int32_t>(atoi(row[20])) : 0;
+			e.beard_color            = row[21] ? static_cast<int32_t>(atoi(row[21])) : 1;
+			e.eye_color_1            = row[22] ? static_cast<int32_t>(atoi(row[22])) : 1;
+			e.eye_color_2            = row[23] ? static_cast<int32_t>(atoi(row[23])) : 1;
+			e.drakkin_heritage       = row[24] ? static_cast<int32_t>(atoi(row[24])) : 0;
+			e.drakkin_tattoo         = row[25] ? static_cast<int32_t>(atoi(row[25])) : 0;
+			e.drakkin_details        = row[26] ? static_cast<int32_t>(atoi(row[26])) : 0;
+			e.ac                     = row[27] ? static_cast<int16_t>(atoi(row[27])) : 0;
+			e.atk                    = row[28] ? static_cast<int32_t>(atoi(row[28])) : 0;
+			e.hp                     = row[29] ? static_cast<int32_t>(atoi(row[29])) : 0;
+			e.mana                   = row[30] ? static_cast<int32_t>(atoi(row[30])) : 0;
+			e.str                    = row[31] ? static_cast<int32_t>(atoi(row[31])) : 75;
+			e.sta                    = row[32] ? static_cast<int32_t>(atoi(row[32])) : 75;
+			e.cha                    = row[33] ? static_cast<int32_t>(atoi(row[33])) : 75;
+			e.dex                    = row[34] ? static_cast<int32_t>(atoi(row[34])) : 75;
+			e.int_                   = row[35] ? static_cast<int32_t>(atoi(row[35])) : 75;
+			e.agi                    = row[36] ? static_cast<int32_t>(atoi(row[36])) : 75;
+			e.wis                    = row[37] ? static_cast<int32_t>(atoi(row[37])) : 75;
+			e.fire                   = row[38] ? static_cast<int16_t>(atoi(row[38])) : 0;
+			e.cold                   = row[39] ? static_cast<int16_t>(atoi(row[39])) : 0;
+			e.magic                  = row[40] ? static_cast<int16_t>(atoi(row[40])) : 0;
+			e.poison                 = row[41] ? static_cast<int16_t>(atoi(row[41])) : 0;
+			e.disease                = row[42] ? static_cast<int16_t>(atoi(row[42])) : 0;
+			e.corruption             = row[43] ? static_cast<int16_t>(atoi(row[43])) : 0;
+			e.show_helm              = row[44] ? static_cast<uint32_t>(strtoul(row[44], nullptr, 10)) : 0;
+			e.follow_distance        = row[45] ? static_cast<uint32_t>(strtoul(row[45], nullptr, 10)) : 200;
+			e.stop_melee_level       = row[46] ? static_cast<uint8_t>(strtoul(row[46], nullptr, 10)) : 255;
+			e.expansion_bitmask      = row[47] ? static_cast<int32_t>(atoi(row[47])) : -1;
+			e.enforce_spell_settings = row[48] ? static_cast<uint8_t>(strtoul(row[48], nullptr, 10)) : 0;
+			e.archery_setting        = row[49] ? static_cast<uint8_t>(strtoul(row[49], nullptr, 10)) : 0;
+			e.caster_range           = row[50] ? static_cast<uint32_t>(strtoul(row[50], nullptr, 10)) : 300;
 
 			return e;
 		}
@@ -634,57 +634,57 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			BotData e{};
 
-			e.bot_id                 = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.owner_id               = static_cast<uint32_t>(strtoul(row[1], nullptr, 10));
-			e.spells_id              = static_cast<uint32_t>(strtoul(row[2], nullptr, 10));
+			e.bot_id                 = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.owner_id               = row[1] ? static_cast<uint32_t>(strtoul(row[1], nullptr, 10)) : 0;
+			e.spells_id              = row[2] ? static_cast<uint32_t>(strtoul(row[2], nullptr, 10)) : 0;
 			e.name                   = row[3] ? row[3] : "";
 			e.last_name              = row[4] ? row[4] : "";
 			e.title                  = row[5] ? row[5] : "";
 			e.suffix                 = row[6] ? row[6] : "";
-			e.zone_id                = static_cast<int16_t>(atoi(row[7]));
-			e.gender                 = static_cast<int8_t>(atoi(row[8]));
-			e.race                   = static_cast<int16_t>(atoi(row[9]));
-			e.class_                 = static_cast<int8_t>(atoi(row[10]));
-			e.level                  = static_cast<uint8_t>(strtoul(row[11], nullptr, 10));
-			e.deity                  = static_cast<uint32_t>(strtoul(row[12], nullptr, 10));
-			e.creation_day           = static_cast<uint32_t>(strtoul(row[13], nullptr, 10));
-			e.last_spawn             = static_cast<uint32_t>(strtoul(row[14], nullptr, 10));
-			e.time_spawned           = static_cast<uint32_t>(strtoul(row[15], nullptr, 10));
-			e.size                   = strtof(row[16], nullptr);
-			e.face                   = static_cast<int32_t>(atoi(row[17]));
-			e.hair_color             = static_cast<int32_t>(atoi(row[18]));
-			e.hair_style             = static_cast<int32_t>(atoi(row[19]));
-			e.beard                  = static_cast<int32_t>(atoi(row[20]));
-			e.beard_color            = static_cast<int32_t>(atoi(row[21]));
-			e.eye_color_1            = static_cast<int32_t>(atoi(row[22]));
-			e.eye_color_2            = static_cast<int32_t>(atoi(row[23]));
-			e.drakkin_heritage       = static_cast<int32_t>(atoi(row[24]));
-			e.drakkin_tattoo         = static_cast<int32_t>(atoi(row[25]));
-			e.drakkin_details        = static_cast<int32_t>(atoi(row[26]));
-			e.ac                     = static_cast<int16_t>(atoi(row[27]));
-			e.atk                    = static_cast<int32_t>(atoi(row[28]));
-			e.hp                     = static_cast<int32_t>(atoi(row[29]));
-			e.mana                   = static_cast<int32_t>(atoi(row[30]));
-			e.str                    = static_cast<int32_t>(atoi(row[31]));
-			e.sta                    = static_cast<int32_t>(atoi(row[32]));
-			e.cha                    = static_cast<int32_t>(atoi(row[33]));
-			e.dex                    = static_cast<int32_t>(atoi(row[34]));
-			e.int_                   = static_cast<int32_t>(atoi(row[35]));
-			e.agi                    = static_cast<int32_t>(atoi(row[36]));
-			e.wis                    = static_cast<int32_t>(atoi(row[37]));
-			e.fire                   = static_cast<int16_t>(atoi(row[38]));
-			e.cold                   = static_cast<int16_t>(atoi(row[39]));
-			e.magic                  = static_cast<int16_t>(atoi(row[40]));
-			e.poison                 = static_cast<int16_t>(atoi(row[41]));
-			e.disease                = static_cast<int16_t>(atoi(row[42]));
-			e.corruption             = static_cast<int16_t>(atoi(row[43]));
-			e.show_helm              = static_cast<uint32_t>(strtoul(row[44], nullptr, 10));
-			e.follow_distance        = static_cast<uint32_t>(strtoul(row[45], nullptr, 10));
-			e.stop_melee_level       = static_cast<uint8_t>(strtoul(row[46], nullptr, 10));
-			e.expansion_bitmask      = static_cast<int32_t>(atoi(row[47]));
-			e.enforce_spell_settings = static_cast<uint8_t>(strtoul(row[48], nullptr, 10));
-			e.archery_setting        = static_cast<uint8_t>(strtoul(row[49], nullptr, 10));
-			e.caster_range           = static_cast<uint32_t>(strtoul(row[50], nullptr, 10));
+			e.zone_id                = row[7] ? static_cast<int16_t>(atoi(row[7])) : 0;
+			e.gender                 = row[8] ? static_cast<int8_t>(atoi(row[8])) : 0;
+			e.race                   = row[9] ? static_cast<int16_t>(atoi(row[9])) : 0;
+			e.class_                 = row[10] ? static_cast<int8_t>(atoi(row[10])) : 0;
+			e.level                  = row[11] ? static_cast<uint8_t>(strtoul(row[11], nullptr, 10)) : 0;
+			e.deity                  = row[12] ? static_cast<uint32_t>(strtoul(row[12], nullptr, 10)) : 0;
+			e.creation_day           = row[13] ? static_cast<uint32_t>(strtoul(row[13], nullptr, 10)) : 0;
+			e.last_spawn             = row[14] ? static_cast<uint32_t>(strtoul(row[14], nullptr, 10)) : 0;
+			e.time_spawned           = row[15] ? static_cast<uint32_t>(strtoul(row[15], nullptr, 10)) : 0;
+			e.size                   = row[16] ? strtof(row[16], nullptr) : 0;
+			e.face                   = row[17] ? static_cast<int32_t>(atoi(row[17])) : 1;
+			e.hair_color             = row[18] ? static_cast<int32_t>(atoi(row[18])) : 1;
+			e.hair_style             = row[19] ? static_cast<int32_t>(atoi(row[19])) : 1;
+			e.beard                  = row[20] ? static_cast<int32_t>(atoi(row[20])) : 0;
+			e.beard_color            = row[21] ? static_cast<int32_t>(atoi(row[21])) : 1;
+			e.eye_color_1            = row[22] ? static_cast<int32_t>(atoi(row[22])) : 1;
+			e.eye_color_2            = row[23] ? static_cast<int32_t>(atoi(row[23])) : 1;
+			e.drakkin_heritage       = row[24] ? static_cast<int32_t>(atoi(row[24])) : 0;
+			e.drakkin_tattoo         = row[25] ? static_cast<int32_t>(atoi(row[25])) : 0;
+			e.drakkin_details        = row[26] ? static_cast<int32_t>(atoi(row[26])) : 0;
+			e.ac                     = row[27] ? static_cast<int16_t>(atoi(row[27])) : 0;
+			e.atk                    = row[28] ? static_cast<int32_t>(atoi(row[28])) : 0;
+			e.hp                     = row[29] ? static_cast<int32_t>(atoi(row[29])) : 0;
+			e.mana                   = row[30] ? static_cast<int32_t>(atoi(row[30])) : 0;
+			e.str                    = row[31] ? static_cast<int32_t>(atoi(row[31])) : 75;
+			e.sta                    = row[32] ? static_cast<int32_t>(atoi(row[32])) : 75;
+			e.cha                    = row[33] ? static_cast<int32_t>(atoi(row[33])) : 75;
+			e.dex                    = row[34] ? static_cast<int32_t>(atoi(row[34])) : 75;
+			e.int_                   = row[35] ? static_cast<int32_t>(atoi(row[35])) : 75;
+			e.agi                    = row[36] ? static_cast<int32_t>(atoi(row[36])) : 75;
+			e.wis                    = row[37] ? static_cast<int32_t>(atoi(row[37])) : 75;
+			e.fire                   = row[38] ? static_cast<int16_t>(atoi(row[38])) : 0;
+			e.cold                   = row[39] ? static_cast<int16_t>(atoi(row[39])) : 0;
+			e.magic                  = row[40] ? static_cast<int16_t>(atoi(row[40])) : 0;
+			e.poison                 = row[41] ? static_cast<int16_t>(atoi(row[41])) : 0;
+			e.disease                = row[42] ? static_cast<int16_t>(atoi(row[42])) : 0;
+			e.corruption             = row[43] ? static_cast<int16_t>(atoi(row[43])) : 0;
+			e.show_helm              = row[44] ? static_cast<uint32_t>(strtoul(row[44], nullptr, 10)) : 0;
+			e.follow_distance        = row[45] ? static_cast<uint32_t>(strtoul(row[45], nullptr, 10)) : 200;
+			e.stop_melee_level       = row[46] ? static_cast<uint8_t>(strtoul(row[46], nullptr, 10)) : 255;
+			e.expansion_bitmask      = row[47] ? static_cast<int32_t>(atoi(row[47])) : -1;
+			e.enforce_spell_settings = row[48] ? static_cast<uint8_t>(strtoul(row[48], nullptr, 10)) : 0;
+			e.archery_setting        = row[49] ? static_cast<uint8_t>(strtoul(row[49], nullptr, 10)) : 0;
+			e.caster_range           = row[50] ? static_cast<uint32_t>(strtoul(row[50], nullptr, 10)) : 300;
 
 			all_entries.push_back(e);
 		}
@@ -709,57 +709,57 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			BotData e{};
 
-			e.bot_id                 = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.owner_id               = static_cast<uint32_t>(strtoul(row[1], nullptr, 10));
-			e.spells_id              = static_cast<uint32_t>(strtoul(row[2], nullptr, 10));
+			e.bot_id                 = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.owner_id               = row[1] ? static_cast<uint32_t>(strtoul(row[1], nullptr, 10)) : 0;
+			e.spells_id              = row[2] ? static_cast<uint32_t>(strtoul(row[2], nullptr, 10)) : 0;
 			e.name                   = row[3] ? row[3] : "";
 			e.last_name              = row[4] ? row[4] : "";
 			e.title                  = row[5] ? row[5] : "";
 			e.suffix                 = row[6] ? row[6] : "";
-			e.zone_id                = static_cast<int16_t>(atoi(row[7]));
-			e.gender                 = static_cast<int8_t>(atoi(row[8]));
-			e.race                   = static_cast<int16_t>(atoi(row[9]));
-			e.class_                 = static_cast<int8_t>(atoi(row[10]));
-			e.level                  = static_cast<uint8_t>(strtoul(row[11], nullptr, 10));
-			e.deity                  = static_cast<uint32_t>(strtoul(row[12], nullptr, 10));
-			e.creation_day           = static_cast<uint32_t>(strtoul(row[13], nullptr, 10));
-			e.last_spawn             = static_cast<uint32_t>(strtoul(row[14], nullptr, 10));
-			e.time_spawned           = static_cast<uint32_t>(strtoul(row[15], nullptr, 10));
-			e.size                   = strtof(row[16], nullptr);
-			e.face                   = static_cast<int32_t>(atoi(row[17]));
-			e.hair_color             = static_cast<int32_t>(atoi(row[18]));
-			e.hair_style             = static_cast<int32_t>(atoi(row[19]));
-			e.beard                  = static_cast<int32_t>(atoi(row[20]));
-			e.beard_color            = static_cast<int32_t>(atoi(row[21]));
-			e.eye_color_1            = static_cast<int32_t>(atoi(row[22]));
-			e.eye_color_2            = static_cast<int32_t>(atoi(row[23]));
-			e.drakkin_heritage       = static_cast<int32_t>(atoi(row[24]));
-			e.drakkin_tattoo         = static_cast<int32_t>(atoi(row[25]));
-			e.drakkin_details        = static_cast<int32_t>(atoi(row[26]));
-			e.ac                     = static_cast<int16_t>(atoi(row[27]));
-			e.atk                    = static_cast<int32_t>(atoi(row[28]));
-			e.hp                     = static_cast<int32_t>(atoi(row[29]));
-			e.mana                   = static_cast<int32_t>(atoi(row[30]));
-			e.str                    = static_cast<int32_t>(atoi(row[31]));
-			e.sta                    = static_cast<int32_t>(atoi(row[32]));
-			e.cha                    = static_cast<int32_t>(atoi(row[33]));
-			e.dex                    = static_cast<int32_t>(atoi(row[34]));
-			e.int_                   = static_cast<int32_t>(atoi(row[35]));
-			e.agi                    = static_cast<int32_t>(atoi(row[36]));
-			e.wis                    = static_cast<int32_t>(atoi(row[37]));
-			e.fire                   = static_cast<int16_t>(atoi(row[38]));
-			e.cold                   = static_cast<int16_t>(atoi(row[39]));
-			e.magic                  = static_cast<int16_t>(atoi(row[40]));
-			e.poison                 = static_cast<int16_t>(atoi(row[41]));
-			e.disease                = static_cast<int16_t>(atoi(row[42]));
-			e.corruption             = static_cast<int16_t>(atoi(row[43]));
-			e.show_helm              = static_cast<uint32_t>(strtoul(row[44], nullptr, 10));
-			e.follow_distance        = static_cast<uint32_t>(strtoul(row[45], nullptr, 10));
-			e.stop_melee_level       = static_cast<uint8_t>(strtoul(row[46], nullptr, 10));
-			e.expansion_bitmask      = static_cast<int32_t>(atoi(row[47]));
-			e.enforce_spell_settings = static_cast<uint8_t>(strtoul(row[48], nullptr, 10));
-			e.archery_setting        = static_cast<uint8_t>(strtoul(row[49], nullptr, 10));
-			e.caster_range           = static_cast<uint32_t>(strtoul(row[50], nullptr, 10));
+			e.zone_id                = row[7] ? static_cast<int16_t>(atoi(row[7])) : 0;
+			e.gender                 = row[8] ? static_cast<int8_t>(atoi(row[8])) : 0;
+			e.race                   = row[9] ? static_cast<int16_t>(atoi(row[9])) : 0;
+			e.class_                 = row[10] ? static_cast<int8_t>(atoi(row[10])) : 0;
+			e.level                  = row[11] ? static_cast<uint8_t>(strtoul(row[11], nullptr, 10)) : 0;
+			e.deity                  = row[12] ? static_cast<uint32_t>(strtoul(row[12], nullptr, 10)) : 0;
+			e.creation_day           = row[13] ? static_cast<uint32_t>(strtoul(row[13], nullptr, 10)) : 0;
+			e.last_spawn             = row[14] ? static_cast<uint32_t>(strtoul(row[14], nullptr, 10)) : 0;
+			e.time_spawned           = row[15] ? static_cast<uint32_t>(strtoul(row[15], nullptr, 10)) : 0;
+			e.size                   = row[16] ? strtof(row[16], nullptr) : 0;
+			e.face                   = row[17] ? static_cast<int32_t>(atoi(row[17])) : 1;
+			e.hair_color             = row[18] ? static_cast<int32_t>(atoi(row[18])) : 1;
+			e.hair_style             = row[19] ? static_cast<int32_t>(atoi(row[19])) : 1;
+			e.beard                  = row[20] ? static_cast<int32_t>(atoi(row[20])) : 0;
+			e.beard_color            = row[21] ? static_cast<int32_t>(atoi(row[21])) : 1;
+			e.eye_color_1            = row[22] ? static_cast<int32_t>(atoi(row[22])) : 1;
+			e.eye_color_2            = row[23] ? static_cast<int32_t>(atoi(row[23])) : 1;
+			e.drakkin_heritage       = row[24] ? static_cast<int32_t>(atoi(row[24])) : 0;
+			e.drakkin_tattoo         = row[25] ? static_cast<int32_t>(atoi(row[25])) : 0;
+			e.drakkin_details        = row[26] ? static_cast<int32_t>(atoi(row[26])) : 0;
+			e.ac                     = row[27] ? static_cast<int16_t>(atoi(row[27])) : 0;
+			e.atk                    = row[28] ? static_cast<int32_t>(atoi(row[28])) : 0;
+			e.hp                     = row[29] ? static_cast<int32_t>(atoi(row[29])) : 0;
+			e.mana                   = row[30] ? static_cast<int32_t>(atoi(row[30])) : 0;
+			e.str                    = row[31] ? static_cast<int32_t>(atoi(row[31])) : 75;
+			e.sta                    = row[32] ? static_cast<int32_t>(atoi(row[32])) : 75;
+			e.cha                    = row[33] ? static_cast<int32_t>(atoi(row[33])) : 75;
+			e.dex                    = row[34] ? static_cast<int32_t>(atoi(row[34])) : 75;
+			e.int_                   = row[35] ? static_cast<int32_t>(atoi(row[35])) : 75;
+			e.agi                    = row[36] ? static_cast<int32_t>(atoi(row[36])) : 75;
+			e.wis                    = row[37] ? static_cast<int32_t>(atoi(row[37])) : 75;
+			e.fire                   = row[38] ? static_cast<int16_t>(atoi(row[38])) : 0;
+			e.cold                   = row[39] ? static_cast<int16_t>(atoi(row[39])) : 0;
+			e.magic                  = row[40] ? static_cast<int16_t>(atoi(row[40])) : 0;
+			e.poison                 = row[41] ? static_cast<int16_t>(atoi(row[41])) : 0;
+			e.disease                = row[42] ? static_cast<int16_t>(atoi(row[42])) : 0;
+			e.corruption             = row[43] ? static_cast<int16_t>(atoi(row[43])) : 0;
+			e.show_helm              = row[44] ? static_cast<uint32_t>(strtoul(row[44], nullptr, 10)) : 0;
+			e.follow_distance        = row[45] ? static_cast<uint32_t>(strtoul(row[45], nullptr, 10)) : 200;
+			e.stop_melee_level       = row[46] ? static_cast<uint8_t>(strtoul(row[46], nullptr, 10)) : 255;
+			e.expansion_bitmask      = row[47] ? static_cast<int32_t>(atoi(row[47])) : -1;
+			e.enforce_spell_settings = row[48] ? static_cast<uint8_t>(strtoul(row[48], nullptr, 10)) : 0;
+			e.archery_setting        = row[49] ? static_cast<uint8_t>(strtoul(row[49], nullptr, 10)) : 0;
+			e.caster_range           = row[50] ? static_cast<uint32_t>(strtoul(row[50], nullptr, 10)) : 300;
 
 			all_entries.push_back(e);
 		}
@@ -818,6 +818,162 @@ 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 BotData &e
+	)
+	{
+		std::vector<std::string> v;
+
+		v.push_back(std::to_string(e.bot_id));
+		v.push_back(std::to_string(e.owner_id));
+		v.push_back(std::to_string(e.spells_id));
+		v.push_back("'" + Strings::Escape(e.name) + "'");
+		v.push_back("'" + Strings::Escape(e.last_name) + "'");
+		v.push_back("'" + Strings::Escape(e.title) + "'");
+		v.push_back("'" + Strings::Escape(e.suffix) + "'");
+		v.push_back(std::to_string(e.zone_id));
+		v.push_back(std::to_string(e.gender));
+		v.push_back(std::to_string(e.race));
+		v.push_back(std::to_string(e.class_));
+		v.push_back(std::to_string(e.level));
+		v.push_back(std::to_string(e.deity));
+		v.push_back(std::to_string(e.creation_day));
+		v.push_back(std::to_string(e.last_spawn));
+		v.push_back(std::to_string(e.time_spawned));
+		v.push_back(std::to_string(e.size));
+		v.push_back(std::to_string(e.face));
+		v.push_back(std::to_string(e.hair_color));
+		v.push_back(std::to_string(e.hair_style));
+		v.push_back(std::to_string(e.beard));
+		v.push_back(std::to_string(e.beard_color));
+		v.push_back(std::to_string(e.eye_color_1));
+		v.push_back(std::to_string(e.eye_color_2));
+		v.push_back(std::to_string(e.drakkin_heritage));
+		v.push_back(std::to_string(e.drakkin_tattoo));
+		v.push_back(std::to_string(e.drakkin_details));
+		v.push_back(std::to_string(e.ac));
+		v.push_back(std::to_string(e.atk));
+		v.push_back(std::to_string(e.hp));
+		v.push_back(std::to_string(e.mana));
+		v.push_back(std::to_string(e.str));
+		v.push_back(std::to_string(e.sta));
+		v.push_back(std::to_string(e.cha));
+		v.push_back(std::to_string(e.dex));
+		v.push_back(std::to_string(e.int_));
+		v.push_back(std::to_string(e.agi));
+		v.push_back(std::to_string(e.wis));
+		v.push_back(std::to_string(e.fire));
+		v.push_back(std::to_string(e.cold));
+		v.push_back(std::to_string(e.magic));
+		v.push_back(std::to_string(e.poison));
+		v.push_back(std::to_string(e.disease));
+		v.push_back(std::to_string(e.corruption));
+		v.push_back(std::to_string(e.show_helm));
+		v.push_back(std::to_string(e.follow_distance));
+		v.push_back(std::to_string(e.stop_melee_level));
+		v.push_back(std::to_string(e.expansion_bitmask));
+		v.push_back(std::to_string(e.enforce_spell_settings));
+		v.push_back(std::to_string(e.archery_setting));
+		v.push_back(std::to_string(e.caster_range));
+
+		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<BotData> &entries
+	)
+	{
+		std::vector<std::string> insert_chunks;
+
+		for (auto &e: entries) {
+			std::vector<std::string> v;
+
+			v.push_back(std::to_string(e.bot_id));
+			v.push_back(std::to_string(e.owner_id));
+			v.push_back(std::to_string(e.spells_id));
+			v.push_back("'" + Strings::Escape(e.name) + "'");
+			v.push_back("'" + Strings::Escape(e.last_name) + "'");
+			v.push_back("'" + Strings::Escape(e.title) + "'");
+			v.push_back("'" + Strings::Escape(e.suffix) + "'");
+			v.push_back(std::to_string(e.zone_id));
+			v.push_back(std::to_string(e.gender));
+			v.push_back(std::to_string(e.race));
+			v.push_back(std::to_string(e.class_));
+			v.push_back(std::to_string(e.level));
+			v.push_back(std::to_string(e.deity));
+			v.push_back(std::to_string(e.creation_day));
+			v.push_back(std::to_string(e.last_spawn));
+			v.push_back(std::to_string(e.time_spawned));
+			v.push_back(std::to_string(e.size));
+			v.push_back(std::to_string(e.face));
+			v.push_back(std::to_string(e.hair_color));
+			v.push_back(std::to_string(e.hair_style));
+			v.push_back(std::to_string(e.beard));
+			v.push_back(std::to_string(e.beard_color));
+			v.push_back(std::to_string(e.eye_color_1));
+			v.push_back(std::to_string(e.eye_color_2));
+			v.push_back(std::to_string(e.drakkin_heritage));
+			v.push_back(std::to_string(e.drakkin_tattoo));
+			v.push_back(std::to_string(e.drakkin_details));
+			v.push_back(std::to_string(e.ac));
+			v.push_back(std::to_string(e.atk));
+			v.push_back(std::to_string(e.hp));
+			v.push_back(std::to_string(e.mana));
+			v.push_back(std::to_string(e.str));
+			v.push_back(std::to_string(e.sta));
+			v.push_back(std::to_string(e.cha));
+			v.push_back(std::to_string(e.dex));
+			v.push_back(std::to_string(e.int_));
+			v.push_back(std::to_string(e.agi));
+			v.push_back(std::to_string(e.wis));
+			v.push_back(std::to_string(e.fire));
+			v.push_back(std::to_string(e.cold));
+			v.push_back(std::to_string(e.magic));
+			v.push_back(std::to_string(e.poison));
+			v.push_back(std::to_string(e.disease));
+			v.push_back(std::to_string(e.corruption));
+			v.push_back(std::to_string(e.show_helm));
+			v.push_back(std::to_string(e.follow_distance));
+			v.push_back(std::to_string(e.stop_melee_level));
+			v.push_back(std::to_string(e.expansion_bitmask));
+			v.push_back(std::to_string(e.enforce_spell_settings));
+			v.push_back(std::to_string(e.archery_setting));
+			v.push_back(std::to_string(e.caster_range));
+
+			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_BOT_DATA_REPOSITORY_H

common/repositories/base/base_bot_heal_rotation_members_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_BOT_HEAL_ROTATION_MEMBERS_REPOSITORY_H
@@ -112,8 +112,9 @@ public:
 	{
 		auto results = db.QueryDatabase(
 			fmt::format(
-				"{} WHERE id = {} LIMIT 1",
+				"{} WHERE {} = {} LIMIT 1",
 				BaseSelect(),
+				PrimaryKey(),
 				bot_heal_rotation_members_id
 			)
 		);
@@ -122,9 +123,9 @@ public:
 		if (results.RowCount() == 1) {
 			BotHealRotationMembers e{};
 
-			e.member_index        = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.heal_rotation_index = static_cast<uint32_t>(strtoul(row[1], nullptr, 10));
-			e.bot_id              = static_cast<uint32_t>(strtoul(row[2], nullptr, 10));
+			e.member_index        = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.heal_rotation_index = row[1] ? static_cast<uint32_t>(strtoul(row[1], nullptr, 10)) : 0;
+			e.bot_id              = row[2] ? static_cast<uint32_t>(strtoul(row[2], nullptr, 10)) : 0;
 
 			return e;
 		}
@@ -249,9 +250,9 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			BotHealRotationMembers e{};
 
-			e.member_index        = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.heal_rotation_index = static_cast<uint32_t>(strtoul(row[1], nullptr, 10));
-			e.bot_id              = static_cast<uint32_t>(strtoul(row[2], nullptr, 10));
+			e.member_index        = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.heal_rotation_index = row[1] ? static_cast<uint32_t>(strtoul(row[1], nullptr, 10)) : 0;
+			e.bot_id              = row[2] ? static_cast<uint32_t>(strtoul(row[2], nullptr, 10)) : 0;
 
 			all_entries.push_back(e);
 		}
@@ -276,9 +277,9 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			BotHealRotationMembers e{};
 
-			e.member_index        = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.heal_rotation_index = static_cast<uint32_t>(strtoul(row[1], nullptr, 10));
-			e.bot_id              = static_cast<uint32_t>(strtoul(row[2], nullptr, 10));
+			e.member_index        = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.heal_rotation_index = row[1] ? static_cast<uint32_t>(strtoul(row[1], nullptr, 10)) : 0;
+			e.bot_id              = row[2] ? static_cast<uint32_t>(strtoul(row[2], nullptr, 10)) : 0;
 
 			all_entries.push_back(e);
 		}
@@ -337,6 +338,66 @@ 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 BotHealRotationMembers &e
+	)
+	{
+		std::vector<std::string> v;
+
+		v.push_back(std::to_string(e.member_index));
+		v.push_back(std::to_string(e.heal_rotation_index));
+		v.push_back(std::to_string(e.bot_id));
+
+		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<BotHealRotationMembers> &entries
+	)
+	{
+		std::vector<std::string> insert_chunks;
+
+		for (auto &e: entries) {
+			std::vector<std::string> v;
+
+			v.push_back(std::to_string(e.member_index));
+			v.push_back(std::to_string(e.heal_rotation_index));
+			v.push_back(std::to_string(e.bot_id));
+
+			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_BOT_HEAL_ROTATION_MEMBERS_REPOSITORY_H

common/repositories/base/base_bot_heal_rotation_targets_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_BOT_HEAL_ROTATION_TARGETS_REPOSITORY_H
@@ -112,8 +112,9 @@ public:
 	{
 		auto results = db.QueryDatabase(
 			fmt::format(
-				"{} WHERE id = {} LIMIT 1",
+				"{} WHERE {} = {} LIMIT 1",
 				BaseSelect(),
+				PrimaryKey(),
 				bot_heal_rotation_targets_id
 			)
 		);
@@ -122,8 +123,8 @@ public:
 		if (results.RowCount() == 1) {
 			BotHealRotationTargets e{};
 
-			e.target_index        = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.heal_rotation_index = static_cast<uint32_t>(strtoul(row[1], nullptr, 10));
+			e.target_index        = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.heal_rotation_index = row[1] ? static_cast<uint32_t>(strtoul(row[1], nullptr, 10)) : 0;
 			e.target_name         = row[2] ? row[2] : "";
 
 			return e;
@@ -249,8 +250,8 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			BotHealRotationTargets e{};
 
-			e.target_index        = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.heal_rotation_index = static_cast<uint32_t>(strtoul(row[1], nullptr, 10));
+			e.target_index        = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.heal_rotation_index = row[1] ? static_cast<uint32_t>(strtoul(row[1], nullptr, 10)) : 0;
 			e.target_name         = row[2] ? row[2] : "";
 
 			all_entries.push_back(e);
@@ -276,8 +277,8 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			BotHealRotationTargets e{};
 
-			e.target_index        = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.heal_rotation_index = static_cast<uint32_t>(strtoul(row[1], nullptr, 10));
+			e.target_index        = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.heal_rotation_index = row[1] ? static_cast<uint32_t>(strtoul(row[1], nullptr, 10)) : 0;
 			e.target_name         = row[2] ? row[2] : "";
 
 			all_entries.push_back(e);
@@ -337,6 +338,66 @@ 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 BotHealRotationTargets &e
+	)
+	{
+		std::vector<std::string> v;
+
+		v.push_back(std::to_string(e.target_index));
+		v.push_back(std::to_string(e.heal_rotation_index));
+		v.push_back("'" + Strings::Escape(e.target_name) + "'");
+
+		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<BotHealRotationTargets> &entries
+	)
+	{
+		std::vector<std::string> insert_chunks;
+
+		for (auto &e: entries) {
+			std::vector<std::string> v;
+
+			v.push_back(std::to_string(e.target_index));
+			v.push_back(std::to_string(e.heal_rotation_index));
+			v.push_back("'" + Strings::Escape(e.target_name) + "'");
+
+			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_BOT_HEAL_ROTATION_TARGETS_REPOSITORY_H

common/repositories/base/base_bot_heal_rotations_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_BOT_HEAL_ROTATIONS_REPOSITORY_H
@@ -19,22 +19,22 @@
 class BaseBotHealRotationsRepository {
 public:
 	struct BotHealRotations {
-		uint32_t    heal_rotation_index;
-		uint32_t    bot_id;
-		uint32_t    interval;
-		uint32_t    fast_heals;
-		uint32_t    adaptive_targeting;
-		uint32_t    casting_override;
-		std::string safe_hp_base;
-		std::string safe_hp_cloth;
-		std::string safe_hp_leather;
-		std::string safe_hp_chain;
-		std::string safe_hp_plate;
-		std::string critical_hp_base;
-		std::string critical_hp_cloth;
-		std::string critical_hp_leather;
-		std::string critical_hp_chain;
-		std::string critical_hp_plate;
+		uint32_t heal_rotation_index;
+		uint32_t bot_id;
+		uint32_t interval_;
+		uint32_t fast_heals;
+		uint32_t adaptive_targeting;
+		uint32_t casting_override;
+		float    safe_hp_base;
+		float    safe_hp_cloth;
+		float    safe_hp_leather;
+		float    safe_hp_chain;
+		float    safe_hp_plate;
+		float    critical_hp_base;
+		float    critical_hp_cloth;
+		float    critical_hp_leather;
+		float    critical_hp_chain;
+		float    critical_hp_plate;
 	};
 
 	static std::string PrimaryKey()
@@ -47,7 +47,7 @@ public:
 		return {
 			"heal_rotation_index",
 			"bot_id",
-			"interval",
+			"`interval`",
 			"fast_heals",
 			"adaptive_targeting",
 			"casting_override",
@@ -69,7 +69,7 @@ public:
 		return {
 			"heal_rotation_index",
 			"bot_id",
-			"interval",
+			"`interval`",
 			"fast_heals",
 			"adaptive_targeting",
 			"casting_override",
@@ -125,7 +125,7 @@ public:
 
 		e.heal_rotation_index = 0;
 		e.bot_id              = 0;
-		e.interval            = 0;
+		e.interval_           = 0;
 		e.fast_heals          = 0;
 		e.adaptive_targeting  = 0;
 		e.casting_override    = 0;
@@ -164,8 +164,9 @@ public:
 	{
 		auto results = db.QueryDatabase(
 			fmt::format(
-				"{} WHERE id = {} LIMIT 1",
+				"{} WHERE {} = {} LIMIT 1",
 				BaseSelect(),
+				PrimaryKey(),
 				bot_heal_rotations_id
 			)
 		);
@@ -174,12 +175,12 @@ public:
 		if (results.RowCount() == 1) {
 			BotHealRotations e{};
 
-			e.heal_rotation_index = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.bot_id              = static_cast<uint32_t>(strtoul(row[1], nullptr, 10));
-			e.interval            = static_cast<uint32_t>(strtoul(row[2], nullptr, 10));
-			e.fast_heals          = static_cast<uint32_t>(strtoul(row[3], nullptr, 10));
-			e.adaptive_targeting  = static_cast<uint32_t>(strtoul(row[4], nullptr, 10));
-			e.casting_override    = static_cast<uint32_t>(strtoul(row[5], nullptr, 10));
+			e.heal_rotation_index = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.bot_id              = row[1] ? static_cast<uint32_t>(strtoul(row[1], nullptr, 10)) : 0;
+			e.interval_           = row[2] ? static_cast<uint32_t>(strtoul(row[2], nullptr, 10)) : 0;
+			e.fast_heals          = row[3] ? static_cast<uint32_t>(strtoul(row[3], nullptr, 10)) : 0;
+			e.adaptive_targeting  = row[4] ? static_cast<uint32_t>(strtoul(row[4], nullptr, 10)) : 0;
+			e.casting_override    = row[5] ? static_cast<uint32_t>(strtoul(row[5], nullptr, 10)) : 0;
 
 			return e;
 		}
@@ -214,7 +215,7 @@ public:
 		auto columns = Columns();
 
 		v.push_back(columns[1] + " = " + std::to_string(e.bot_id));
-		v.push_back(columns[2] + " = " + std::to_string(e.interval));
+		v.push_back(columns[2] + " = " + std::to_string(e.interval_));
 		v.push_back(columns[3] + " = " + std::to_string(e.fast_heals));
 		v.push_back(columns[4] + " = " + std::to_string(e.adaptive_targeting));
 		v.push_back(columns[5] + " = " + std::to_string(e.casting_override));
@@ -251,7 +252,7 @@ public:
 
 		v.push_back(std::to_string(e.heal_rotation_index));
 		v.push_back(std::to_string(e.bot_id));
-		v.push_back(std::to_string(e.interval));
+		v.push_back(std::to_string(e.interval_));
 		v.push_back(std::to_string(e.fast_heals));
 		v.push_back(std::to_string(e.adaptive_targeting));
 		v.push_back(std::to_string(e.casting_override));
@@ -296,7 +297,7 @@ public:
 
 			v.push_back(std::to_string(e.heal_rotation_index));
 			v.push_back(std::to_string(e.bot_id));
-			v.push_back(std::to_string(e.interval));
+			v.push_back(std::to_string(e.interval_));
 			v.push_back(std::to_string(e.fast_heals));
 			v.push_back(std::to_string(e.adaptive_targeting));
 			v.push_back(std::to_string(e.casting_override));
@@ -343,12 +344,12 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			BotHealRotations e{};
 
-			e.heal_rotation_index = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.bot_id              = static_cast<uint32_t>(strtoul(row[1], nullptr, 10));
-			e.interval            = static_cast<uint32_t>(strtoul(row[2], nullptr, 10));
-			e.fast_heals          = static_cast<uint32_t>(strtoul(row[3], nullptr, 10));
-			e.adaptive_targeting  = static_cast<uint32_t>(strtoul(row[4], nullptr, 10));
-			e.casting_override    = static_cast<uint32_t>(strtoul(row[5], nullptr, 10));
+			e.heal_rotation_index = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.bot_id              = row[1] ? static_cast<uint32_t>(strtoul(row[1], nullptr, 10)) : 0;
+			e.interval_           = row[2] ? static_cast<uint32_t>(strtoul(row[2], nullptr, 10)) : 0;
+			e.fast_heals          = row[3] ? static_cast<uint32_t>(strtoul(row[3], nullptr, 10)) : 0;
+			e.adaptive_targeting  = row[4] ? static_cast<uint32_t>(strtoul(row[4], nullptr, 10)) : 0;
+			e.casting_override    = row[5] ? static_cast<uint32_t>(strtoul(row[5], nullptr, 10)) : 0;
 
 			all_entries.push_back(e);
 		}
@@ -373,12 +374,12 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			BotHealRotations e{};
 
-			e.heal_rotation_index = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.bot_id              = static_cast<uint32_t>(strtoul(row[1], nullptr, 10));
-			e.interval            = static_cast<uint32_t>(strtoul(row[2], nullptr, 10));
-			e.fast_heals          = static_cast<uint32_t>(strtoul(row[3], nullptr, 10));
-			e.adaptive_targeting  = static_cast<uint32_t>(strtoul(row[4], nullptr, 10));
-			e.casting_override    = static_cast<uint32_t>(strtoul(row[5], nullptr, 10));
+			e.heal_rotation_index = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.bot_id              = row[1] ? static_cast<uint32_t>(strtoul(row[1], nullptr, 10)) : 0;
+			e.interval_           = row[2] ? static_cast<uint32_t>(strtoul(row[2], nullptr, 10)) : 0;
+			e.fast_heals          = row[3] ? static_cast<uint32_t>(strtoul(row[3], nullptr, 10)) : 0;
+			e.adaptive_targeting  = row[4] ? static_cast<uint32_t>(strtoul(row[4], nullptr, 10)) : 0;
+			e.casting_override    = row[5] ? static_cast<uint32_t>(strtoul(row[5], nullptr, 10)) : 0;
 
 			all_entries.push_back(e);
 		}
@@ -437,6 +438,92 @@ 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 BotHealRotations &e
+	)
+	{
+		std::vector<std::string> v;
+
+		v.push_back(std::to_string(e.heal_rotation_index));
+		v.push_back(std::to_string(e.bot_id));
+		v.push_back(std::to_string(e.interval_));
+		v.push_back(std::to_string(e.fast_heals));
+		v.push_back(std::to_string(e.adaptive_targeting));
+		v.push_back(std::to_string(e.casting_override));
+		v.push_back(std::to_string(e.safe_hp_base));
+		v.push_back(std::to_string(e.safe_hp_cloth));
+		v.push_back(std::to_string(e.safe_hp_leather));
+		v.push_back(std::to_string(e.safe_hp_chain));
+		v.push_back(std::to_string(e.safe_hp_plate));
+		v.push_back(std::to_string(e.critical_hp_base));
+		v.push_back(std::to_string(e.critical_hp_cloth));
+		v.push_back(std::to_string(e.critical_hp_leather));
+		v.push_back(std::to_string(e.critical_hp_chain));
+		v.push_back(std::to_string(e.critical_hp_plate));
+
+		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<BotHealRotations> &entries
+	)
+	{
+		std::vector<std::string> insert_chunks;
+
+		for (auto &e: entries) {
+			std::vector<std::string> v;
+
+			v.push_back(std::to_string(e.heal_rotation_index));
+			v.push_back(std::to_string(e.bot_id));
+			v.push_back(std::to_string(e.interval_));
+			v.push_back(std::to_string(e.fast_heals));
+			v.push_back(std::to_string(e.adaptive_targeting));
+			v.push_back(std::to_string(e.casting_override));
+			v.push_back(std::to_string(e.safe_hp_base));
+			v.push_back(std::to_string(e.safe_hp_cloth));
+			v.push_back(std::to_string(e.safe_hp_leather));
+			v.push_back(std::to_string(e.safe_hp_chain));
+			v.push_back(std::to_string(e.safe_hp_plate));
+			v.push_back(std::to_string(e.critical_hp_base));
+			v.push_back(std::to_string(e.critical_hp_cloth));
+			v.push_back(std::to_string(e.critical_hp_leather));
+			v.push_back(std::to_string(e.critical_hp_chain));
+			v.push_back(std::to_string(e.critical_hp_plate));
+
+			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_BOT_HEAL_ROTATIONS_REPOSITORY_H

common/repositories/base/base_bot_inspect_messages_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_BOT_INSPECT_MESSAGES_REPOSITORY_H
@@ -108,8 +108,9 @@ public:
 	{
 		auto results = db.QueryDatabase(
 			fmt::format(
-				"{} WHERE id = {} LIMIT 1",
+				"{} WHERE {} = {} LIMIT 1",
 				BaseSelect(),
+				PrimaryKey(),
 				bot_inspect_messages_id
 			)
 		);
@@ -118,7 +119,7 @@ public:
 		if (results.RowCount() == 1) {
 			BotInspectMessages e{};
 
-			e.bot_id          = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
+			e.bot_id          = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
 			e.inspect_message = row[1] ? row[1] : "";
 
 			return e;
@@ -242,7 +243,7 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			BotInspectMessages e{};
 
-			e.bot_id          = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
+			e.bot_id          = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
 			e.inspect_message = row[1] ? row[1] : "";
 
 			all_entries.push_back(e);
@@ -268,7 +269,7 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			BotInspectMessages e{};
 
-			e.bot_id          = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
+			e.bot_id          = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
 			e.inspect_message = row[1] ? row[1] : "";
 
 			all_entries.push_back(e);
@@ -328,6 +329,64 @@ 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 BotInspectMessages &e
+	)
+	{
+		std::vector<std::string> v;
+
+		v.push_back(std::to_string(e.bot_id));
+		v.push_back("'" + Strings::Escape(e.inspect_message) + "'");
+
+		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<BotInspectMessages> &entries
+	)
+	{
+		std::vector<std::string> insert_chunks;
+
+		for (auto &e: entries) {
+			std::vector<std::string> v;
+
+			v.push_back(std::to_string(e.bot_id));
+			v.push_back("'" + Strings::Escape(e.inspect_message) + "'");
+
+			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_BOT_INSPECT_MESSAGES_REPOSITORY_H

common/repositories/base/base_bot_inventories_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_BOT_INVENTORIES_REPOSITORY_H
@@ -168,8 +168,9 @@ public:
 	{
 		auto results = db.QueryDatabase(
 			fmt::format(
-				"{} WHERE id = {} LIMIT 1",
+				"{} WHERE {} = {} LIMIT 1",
 				BaseSelect(),
+				PrimaryKey(),
 				bot_inventories_id
 			)
 		);
@@ -178,23 +179,23 @@ public:
 		if (results.RowCount() == 1) {
 			BotInventories e{};
 
-			e.inventories_index   = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.bot_id              = static_cast<uint32_t>(strtoul(row[1], nullptr, 10));
-			e.slot_id             = static_cast<uint32_t>(strtoul(row[2], nullptr, 10));
-			e.item_id             = static_cast<uint32_t>(strtoul(row[3], nullptr, 10));
-			e.inst_charges        = static_cast<uint16_t>(strtoul(row[4], nullptr, 10));
-			e.inst_color          = static_cast<uint32_t>(strtoul(row[5], nullptr, 10));
-			e.inst_no_drop        = static_cast<uint8_t>(strtoul(row[6], nullptr, 10));
+			e.inventories_index   = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.bot_id              = row[1] ? static_cast<uint32_t>(strtoul(row[1], nullptr, 10)) : 0;
+			e.slot_id             = 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.inst_charges        = row[4] ? static_cast<uint16_t>(strtoul(row[4], nullptr, 10)) : 0;
+			e.inst_color          = row[5] ? static_cast<uint32_t>(strtoul(row[5], nullptr, 10)) : 0;
+			e.inst_no_drop        = row[6] ? static_cast<uint8_t>(strtoul(row[6], nullptr, 10)) : 0;
 			e.inst_custom_data    = row[7] ? row[7] : "";
-			e.ornament_icon       = static_cast<uint32_t>(strtoul(row[8], nullptr, 10));
-			e.ornament_id_file    = static_cast<uint32_t>(strtoul(row[9], nullptr, 10));
-			e.ornament_hero_model = static_cast<int32_t>(atoi(row[10]));
-			e.augment_1           = static_cast<uint32_t>(strtoul(row[11], nullptr, 10));
-			e.augment_2           = static_cast<uint32_t>(strtoul(row[12], nullptr, 10));
-			e.augment_3           = static_cast<uint32_t>(strtoul(row[13], nullptr, 10));
-			e.augment_4           = static_cast<uint32_t>(strtoul(row[14], nullptr, 10));
-			e.augment_5           = static_cast<uint32_t>(strtoul(row[15], nullptr, 10));
-			e.augment_6           = static_cast<uint32_t>(strtoul(row[16], nullptr, 10));
+			e.ornament_icon       = row[8] ? static_cast<uint32_t>(strtoul(row[8], nullptr, 10)) : 0;
+			e.ornament_id_file    = row[9] ? static_cast<uint32_t>(strtoul(row[9], nullptr, 10)) : 0;
+			e.ornament_hero_model = row[10] ? static_cast<int32_t>(atoi(row[10])) : 0;
+			e.augment_1           = row[11] ? static_cast<uint32_t>(strtoul(row[11], nullptr, 10)) : 0;
+			e.augment_2           = row[12] ? static_cast<uint32_t>(strtoul(row[12], nullptr, 10)) : 0;
+			e.augment_3           = row[13] ? static_cast<uint32_t>(strtoul(row[13], nullptr, 10)) : 0;
+			e.augment_4           = row[14] ? static_cast<uint32_t>(strtoul(row[14], nullptr, 10)) : 0;
+			e.augment_5           = row[15] ? static_cast<uint32_t>(strtoul(row[15], nullptr, 10)) : 0;
+			e.augment_6           = row[16] ? static_cast<uint32_t>(strtoul(row[16], nullptr, 10)) : 0;
 
 			return e;
 		}
@@ -361,23 +362,23 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			BotInventories e{};
 
-			e.inventories_index   = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.bot_id              = static_cast<uint32_t>(strtoul(row[1], nullptr, 10));
-			e.slot_id             = static_cast<uint32_t>(strtoul(row[2], nullptr, 10));
-			e.item_id             = static_cast<uint32_t>(strtoul(row[3], nullptr, 10));
-			e.inst_charges        = static_cast<uint16_t>(strtoul(row[4], nullptr, 10));
-			e.inst_color          = static_cast<uint32_t>(strtoul(row[5], nullptr, 10));
-			e.inst_no_drop        = static_cast<uint8_t>(strtoul(row[6], nullptr, 10));
+			e.inventories_index   = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.bot_id              = row[1] ? static_cast<uint32_t>(strtoul(row[1], nullptr, 10)) : 0;
+			e.slot_id             = 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.inst_charges        = row[4] ? static_cast<uint16_t>(strtoul(row[4], nullptr, 10)) : 0;
+			e.inst_color          = row[5] ? static_cast<uint32_t>(strtoul(row[5], nullptr, 10)) : 0;
+			e.inst_no_drop        = row[6] ? static_cast<uint8_t>(strtoul(row[6], nullptr, 10)) : 0;
 			e.inst_custom_data    = row[7] ? row[7] : "";
-			e.ornament_icon       = static_cast<uint32_t>(strtoul(row[8], nullptr, 10));
-			e.ornament_id_file    = static_cast<uint32_t>(strtoul(row[9], nullptr, 10));
-			e.ornament_hero_model = static_cast<int32_t>(atoi(row[10]));
-			e.augment_1           = static_cast<uint32_t>(strtoul(row[11], nullptr, 10));
-			e.augment_2           = static_cast<uint32_t>(strtoul(row[12], nullptr, 10));
-			e.augment_3           = static_cast<uint32_t>(strtoul(row[13], nullptr, 10));
-			e.augment_4           = static_cast<uint32_t>(strtoul(row[14], nullptr, 10));
-			e.augment_5           = static_cast<uint32_t>(strtoul(row[15], nullptr, 10));
-			e.augment_6           = static_cast<uint32_t>(strtoul(row[16], nullptr, 10));
+			e.ornament_icon       = row[8] ? static_cast<uint32_t>(strtoul(row[8], nullptr, 10)) : 0;
+			e.ornament_id_file    = row[9] ? static_cast<uint32_t>(strtoul(row[9], nullptr, 10)) : 0;
+			e.ornament_hero_model = row[10] ? static_cast<int32_t>(atoi(row[10])) : 0;
+			e.augment_1           = row[11] ? static_cast<uint32_t>(strtoul(row[11], nullptr, 10)) : 0;
+			e.augment_2           = row[12] ? static_cast<uint32_t>(strtoul(row[12], nullptr, 10)) : 0;
+			e.augment_3           = row[13] ? static_cast<uint32_t>(strtoul(row[13], nullptr, 10)) : 0;
+			e.augment_4           = row[14] ? static_cast<uint32_t>(strtoul(row[14], nullptr, 10)) : 0;
+			e.augment_5           = row[15] ? static_cast<uint32_t>(strtoul(row[15], nullptr, 10)) : 0;
+			e.augment_6           = row[16] ? static_cast<uint32_t>(strtoul(row[16], nullptr, 10)) : 0;
 
 			all_entries.push_back(e);
 		}
@@ -402,23 +403,23 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			BotInventories e{};
 
-			e.inventories_index   = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.bot_id              = static_cast<uint32_t>(strtoul(row[1], nullptr, 10));
-			e.slot_id             = static_cast<uint32_t>(strtoul(row[2], nullptr, 10));
-			e.item_id             = static_cast<uint32_t>(strtoul(row[3], nullptr, 10));
-			e.inst_charges        = static_cast<uint16_t>(strtoul(row[4], nullptr, 10));
-			e.inst_color          = static_cast<uint32_t>(strtoul(row[5], nullptr, 10));
-			e.inst_no_drop        = static_cast<uint8_t>(strtoul(row[6], nullptr, 10));
+			e.inventories_index   = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.bot_id              = row[1] ? static_cast<uint32_t>(strtoul(row[1], nullptr, 10)) : 0;
+			e.slot_id             = 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.inst_charges        = row[4] ? static_cast<uint16_t>(strtoul(row[4], nullptr, 10)) : 0;
+			e.inst_color          = row[5] ? static_cast<uint32_t>(strtoul(row[5], nullptr, 10)) : 0;
+			e.inst_no_drop        = row[6] ? static_cast<uint8_t>(strtoul(row[6], nullptr, 10)) : 0;
 			e.inst_custom_data    = row[7] ? row[7] : "";
-			e.ornament_icon       = static_cast<uint32_t>(strtoul(row[8], nullptr, 10));
-			e.ornament_id_file    = static_cast<uint32_t>(strtoul(row[9], nullptr, 10));
-			e.ornament_hero_model = static_cast<int32_t>(atoi(row[10]));
-			e.augment_1           = static_cast<uint32_t>(strtoul(row[11], nullptr, 10));
-			e.augment_2           = static_cast<uint32_t>(strtoul(row[12], nullptr, 10));
-			e.augment_3           = static_cast<uint32_t>(strtoul(row[13], nullptr, 10));
-			e.augment_4           = static_cast<uint32_t>(strtoul(row[14], nullptr, 10));
-			e.augment_5           = static_cast<uint32_t>(strtoul(row[15], nullptr, 10));
-			e.augment_6           = static_cast<uint32_t>(strtoul(row[16], nullptr, 10));
+			e.ornament_icon       = row[8] ? static_cast<uint32_t>(strtoul(row[8], nullptr, 10)) : 0;
+			e.ornament_id_file    = row[9] ? static_cast<uint32_t>(strtoul(row[9], nullptr, 10)) : 0;
+			e.ornament_hero_model = row[10] ? static_cast<int32_t>(atoi(row[10])) : 0;
+			e.augment_1           = row[11] ? static_cast<uint32_t>(strtoul(row[11], nullptr, 10)) : 0;
+			e.augment_2           = row[12] ? static_cast<uint32_t>(strtoul(row[12], nullptr, 10)) : 0;
+			e.augment_3           = row[13] ? static_cast<uint32_t>(strtoul(row[13], nullptr, 10)) : 0;
+			e.augment_4           = row[14] ? static_cast<uint32_t>(strtoul(row[14], nullptr, 10)) : 0;
+			e.augment_5           = row[15] ? static_cast<uint32_t>(strtoul(row[15], nullptr, 10)) : 0;
+			e.augment_6           = row[16] ? static_cast<uint32_t>(strtoul(row[16], nullptr, 10)) : 0;
 
 			all_entries.push_back(e);
 		}
@@ -477,6 +478,94 @@ 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 BotInventories &e
+	)
+	{
+		std::vector<std::string> v;
+
+		v.push_back(std::to_string(e.inventories_index));
+		v.push_back(std::to_string(e.bot_id));
+		v.push_back(std::to_string(e.slot_id));
+		v.push_back(std::to_string(e.item_id));
+		v.push_back(std::to_string(e.inst_charges));
+		v.push_back(std::to_string(e.inst_color));
+		v.push_back(std::to_string(e.inst_no_drop));
+		v.push_back("'" + Strings::Escape(e.inst_custom_data) + "'");
+		v.push_back(std::to_string(e.ornament_icon));
+		v.push_back(std::to_string(e.ornament_id_file));
+		v.push_back(std::to_string(e.ornament_hero_model));
+		v.push_back(std::to_string(e.augment_1));
+		v.push_back(std::to_string(e.augment_2));
+		v.push_back(std::to_string(e.augment_3));
+		v.push_back(std::to_string(e.augment_4));
+		v.push_back(std::to_string(e.augment_5));
+		v.push_back(std::to_string(e.augment_6));
+
+		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<BotInventories> &entries
+	)
+	{
+		std::vector<std::string> insert_chunks;
+
+		for (auto &e: entries) {
+			std::vector<std::string> v;
+
+			v.push_back(std::to_string(e.inventories_index));
+			v.push_back(std::to_string(e.bot_id));
+			v.push_back(std::to_string(e.slot_id));
+			v.push_back(std::to_string(e.item_id));
+			v.push_back(std::to_string(e.inst_charges));
+			v.push_back(std::to_string(e.inst_color));
+			v.push_back(std::to_string(e.inst_no_drop));
+			v.push_back("'" + Strings::Escape(e.inst_custom_data) + "'");
+			v.push_back(std::to_string(e.ornament_icon));
+			v.push_back(std::to_string(e.ornament_id_file));
+			v.push_back(std::to_string(e.ornament_hero_model));
+			v.push_back(std::to_string(e.augment_1));
+			v.push_back(std::to_string(e.augment_2));
+			v.push_back(std::to_string(e.augment_3));
+			v.push_back(std::to_string(e.augment_4));
+			v.push_back(std::to_string(e.augment_5));
+			v.push_back(std::to_string(e.augment_6));
+
+			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_BOT_INVENTORIES_REPOSITORY_H