Updated for bypass all rule

[Bug Fix] Cleanup NPC Mana Tap Logic
Mana Tap rule logic was invalid - Cleaned up and simplified, either we care about npc mana or we dont.
2026-05-23 04:52:29 +00:00 · 2024-02-25 16:00:44 -05:00 · 2024-02-25 15:20:58 -05:00 · 2024-02-25 00:38:34 -05:00 · 2024-02-24 23:06:37 -06:00 · 2024-02-24 22:57:49 -06:00
329 changed files with 35465 additions and 26362 deletions
@@ -1,3 +1,350 @@
+## [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
@@ -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) {
@@ -222,6 +222,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
@@ -399,6 +402,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
@@ -491,7 +497,6 @@ SET(repositories
 SET(common_headers
    additive_lagged_fibonacci_engine.h
    base_packet.h
-    base_data.h
    bodytypes.h
    classes.h
    compression.h
@@ -561,7 +566,7 @@ SET(common_headers
    json_config.h
    light_source.h
    linked_list.h
-    loottable.h
+    loot.h
    mail_oplist.h
    md5.h
    memory_buffer.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
@@ -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
@@ -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;
 		}
@@ -201,6 +183,7 @@ void WorldContentService::ReloadContentFlags()
 	}

 	SetContentFlags(set_content_flags);
+	SetContentZones(ZoneRepository::All(*m_content_database));
 }

 Database *WorldContentService::GetDatabase() const
@@ -215,6 +198,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 +234,85 @@ void WorldContentService::SetContentFlag(const std::string &content_flag_name, b

 	ReloadContentFlags();
 }
+
+// SetZones 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::SetContentZones(const std::vector<BaseZoneRepository::Zone>& zones)
+{
+	m_zones = zones;
+
+	LogInfo("Loaded [{}] zones", m_zones.size());
+
+	return this;
+}
+
+// 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
+// example # 2
+void WorldContentService::HandleZoneRoutingMiddleware(ZoneChange_Struct *zc)
+{
+	// if we're already in an instance, we don't want to route the player to another instance
+	if (zc->instanceID > 0) {
+		return;
+	}
+
+	for (auto &z: m_zones) {
+		if (z.zoneidnumber == zc->zoneID) {
+			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
+				);
+
+				auto instances = InstanceListRepository::GetWhere(
+					*GetDatabase(),
+					fmt::format(
+						"zone = {} AND version = {} AND never_expires = 1 AND is_global = 1",
+						z.zoneidnumber,
+						z.version
+					)
+				);
+
+				if (!instances.empty()) {
+					auto instance = instances.front();
+					zc->instanceID = instance.id;
+
+					LogInfo(
+						"Routed player to instance [{}] of zone [{}] ({}) version [{}] long_name [{}] notes [{}]",
+						instance.id,
+						z.short_name,
+						z.zoneidnumber,
+						z.version,
+						z.long_name,
+						instance.notes
+					);
+
+					break;
+				}
+			}
+		}
+	}
+}
+
@@ -1,33 +1,20 @@
-/**
- * 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"

 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 +163,23 @@ 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);
+	WorldContentService * SetContentZones(const std::vector<ZoneRepository::Zone>& zones);
 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 = {};
 };

 extern WorldContentService content_service;
@@ -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
 	};

@@ -30,6 +30,11 @@
 #include <string.h>

 #include "../common/repositories/account_repository.h"
+#include "../common/repositories/character_bind_repository.h"
+#include "../common/repositories/character_data_repository.h"
+#include "../common/repositories/character_languages_repository.h"
+#include "../common/repositories/character_leadership_abilities_repository.h"
+#include "../common/repositories/character_skills_repository.h"

 // Disgrace: for windows compile
 #ifdef _WINDOWS
@@ -454,363 +459,185 @@ bool Database::DeleteCharacter(char *character_name)

 bool Database::SaveCharacterCreate(uint32 character_id, uint32 account_id, PlayerProfile_Struct *pp)
 {
-	std::string query = StringFormat(
-		"REPLACE INTO `character_data` ("
-		"id,"
-		"account_id,"
-		"`name`,"
-		"last_name,"
-		"gender,"
-		"race,"
-		"class,"
-		"`level`,"
-		"deity,"
-		"birthday,"
-		"last_login,"
-		"time_played,"
-		"pvp_status,"
-		"level2,"
-		"anon,"
-		"gm,"
-		"intoxication,"
-		"hair_color,"
-		"beard_color,"
-		"eye_color_1,"
-		"eye_color_2,"
-		"hair_style,"
-		"beard,"
-		"ability_time_seconds,"
-		"ability_number,"
-		"ability_time_minutes,"
-		"ability_time_hours,"
-		"title,"
-		"suffix,"
-		"exp,"
-		"points,"
-		"mana,"
-		"cur_hp,"
-		"str,"
-		"sta,"
-		"cha,"
-		"dex,"
-		"`int`,"
-		"agi,"
-		"wis,"
-		"face,"
-		"y,"
-		"x,"
-		"z,"
-		"heading,"
-		"pvp2,"
-		"pvp_type,"
-		"autosplit_enabled,"
-		"zone_change_count,"
-		"drakkin_heritage,"
-		"drakkin_tattoo,"
-		"drakkin_details,"
-		"toxicity,"
-		"hunger_level,"
-		"thirst_level,"
-		"ability_up,"
-		"zone_id,"
-		"zone_instance,"
-		"leadership_exp_on,"
-		"ldon_points_guk,"
-		"ldon_points_mir,"
-		"ldon_points_mmc,"
-		"ldon_points_ruj,"
-		"ldon_points_tak,"
-		"ldon_points_available,"
-		"tribute_time_remaining,"
-		"show_helm,"
-		"career_tribute_points,"
-		"tribute_points,"
-		"tribute_active,"
-		"endurance,"
-		"group_leadership_exp,"
-		"raid_leadership_exp,"
-		"group_leadership_points,"
-		"raid_leadership_points,"
-		"air_remaining,"
-		"pvp_kills,"
-		"pvp_deaths,"
-		"pvp_current_points,"
-		"pvp_career_points,"
-		"pvp_best_kill_streak,"
-		"pvp_worst_death_streak,"
-		"pvp_current_kill_streak,"
-		"aa_points_spent,"
-		"aa_exp,"
-		"aa_points,"
-		"group_auto_consent,"
-		"raid_auto_consent,"
-		"guild_auto_consent,"
-		"RestTimer) "
-		"VALUES ("
-		"%u,"  // id
-		"%u,"  // account_id
-		"'%s',"  // `name`
-		"'%s',"  // last_name
-		"%u,"  // gender
-		"%u,"  // race
-		"%u,"  // class
-		"%u,"  // `level`
-		"%u,"  // deity
-		"%u,"  // birthday
-		"%u,"  // last_login
-		"%u,"  // time_played
-		"%u,"  // pvp_status
-		"%u,"  // level2
-		"%u,"  // anon
-		"%u,"  // gm
-		"%u,"  // intoxication
-		"%u,"  // hair_color
-		"%u,"  // beard_color
-		"%u,"  // eye_color_1
-		"%u,"  // eye_color_2
-		"%u,"  // hair_style
-		"%u,"  // beard
-		"%u,"  // ability_time_seconds
-		"%u,"  // ability_number
-		"%u,"  // ability_time_minutes
-		"%u,"  // ability_time_hours
-		"'%s',"  // title
-		"'%s',"  // suffix
-		"%u,"  // exp
-		"%u,"  // points
-		"%u,"  // mana
-		"%u,"  // cur_hp
-		"%u,"  // str
-		"%u,"  // sta
-		"%u,"  // cha
-		"%u,"  // dex
-		"%u,"  // `int`
-		"%u,"  // agi
-		"%u,"  // wis
-		"%u,"  // face
-		"%f,"  // y
-		"%f,"  // x
-		"%f,"  // z
-		"%f,"  // heading
-		"%u,"  // pvp2
-		"%u,"  // pvp_type
-		"%u,"  // autosplit_enabled
-		"%u,"  // zone_change_count
-		"%u,"  // drakkin_heritage
-		"%u,"  // drakkin_tattoo
-		"%u,"  // drakkin_details
-		"%i,"  // toxicity
-		"%i,"  // hunger_level
-		"%i,"  // thirst_level
-		"%u,"  // ability_up
-		"%u,"  // zone_id
-		"%u,"  // zone_instance
-		"%u,"  // leadership_exp_on
-		"%u,"  // ldon_points_guk
-		"%u,"  // ldon_points_mir
-		"%u,"  // ldon_points_mmc
-		"%u,"  // ldon_points_ruj
-		"%u,"  // ldon_points_tak
-		"%u,"  // ldon_points_available
-		"%u,"  // tribute_time_remaining
-		"%u,"  // show_helm
-		"%u,"  // career_tribute_points
-		"%u,"  // tribute_points
-		"%u,"  // tribute_active
-		"%u,"  // endurance
-		"%u,"  // group_leadership_exp
-		"%u,"  // raid_leadership_exp
-		"%u,"  // group_leadership_point
-		"%u,"  // raid_leadership_points
-		"%u,"  // air_remaining
-		"%u,"  // pvp_kills
-		"%u,"  // pvp_deaths
-		"%u,"  // pvp_current_points
-		"%u,"  // pvp_career_points
-		"%u,"  // pvp_best_kill_streak
-		"%u,"  // pvp_worst_death_streak
-		"%u,"  // pvp_current_kill_strea
-		"%u,"  // aa_points_spent
-		"%u,"  // aa_exp
-		"%u,"  // aa_points
-		"%u,"  // group_auto_consent
-		"%u,"  // raid_auto_consent
-		"%u,"  // guild_auto_consent
-		"%u"  // RestTimer
-		")",
-		character_id,                      // " id,                        "
-		account_id,                          // " account_id,                "
-		Strings::Escape(pp->name).c_str(),      // " `name`,                    "
-		Strings::Escape(pp->last_name).c_str(), // " last_name,              "
-		pp->gender,                          // " gender,                    "
-		pp->race,                          // " race,                      "
-		pp->class_,                          // " class,                     "
-		pp->level,                          // " `level`,                   "
-		pp->deity,                          // " deity,                     "
-		pp->birthday,                      // " birthday,                  "
-		pp->lastlogin,                      // " last_login,                "
-		pp->timePlayedMin,                  // " time_played,               "
-		pp->pvp,                          // " pvp_status,                "
-		pp->level2,                          // " level2,                    "
-		pp->anon,                          // " anon,                      "
-		pp->gm,                              // " gm,                        "
-		pp->intoxication,                  // " intoxication,              "
-		pp->haircolor,                      // " hair_color,                "
-		pp->beardcolor,                      // " beard_color,               "
-		pp->eyecolor1,                      // " eye_color_1,               "
-		pp->eyecolor2,                      // " eye_color_2,               "
-		pp->hairstyle,                      // " hair_style,                "
-		pp->beard,                          // " beard,                     "
-		pp->ability_time_seconds,          // " ability_time_seconds,      "
-		pp->ability_number,                  // " ability_number,            "
-		pp->ability_time_minutes,          // " ability_time_minutes,      "
-		pp->ability_time_hours,              // " ability_time_hours,        "
-		Strings::Escape(pp->title).c_str(),  // " title,                     "
-		Strings::Escape(pp->suffix).c_str(), // " suffix,                    "
-		pp->exp,                          // " exp,                       "
-		pp->points,                          // " points,                    "
-		pp->mana,                          // " mana,                      "
-		pp->cur_hp,                          // " cur_hp,                    "
-		pp->STR,                          // " str,                       "
-		pp->STA,                          // " sta,                       "
-		pp->CHA,                          // " cha,                       "
-		pp->DEX,                          // " dex,                       "
-		pp->INT,                          // " `int`,                     "
-		pp->AGI,                          // " agi,                       "
-		pp->WIS,                          // " wis,                       "
-		pp->face,                          // " face,                      "
-		pp->y,                              // " y,                         "
-		pp->x,                              // " x,                         "
-		pp->z,                              // " z,                         "
-		pp->heading,                      // " heading,                   "
-		pp->pvp2,                          // " pvp2,                      "
-		pp->pvptype,                      // " pvp_type,                  "
-		pp->autosplit,                      // " autosplit_enabled,         "
-		pp->zone_change_count,              // " zone_change_count,         "
-		pp->drakkin_heritage,              // " drakkin_heritage,          "
-		pp->drakkin_tattoo,                  // " drakkin_tattoo,            "
-		pp->drakkin_details,              // " drakkin_details,           "
-		pp->toxicity,                      // " toxicity,                  "
-		pp->hunger_level,                  // " hunger_level,              "
-		pp->thirst_level,                  // " thirst_level,              "
-		pp->ability_up,                      // " ability_up,                "
-		pp->zone_id,                      // " zone_id,                   "
-		pp->zoneInstance,                  // " zone_instance,             "
-		pp->leadAAActive,                  // " leadership_exp_on,         "
-		pp->ldon_points_guk,              // " ldon_points_guk,           "
-		pp->ldon_points_mir,              // " ldon_points_mir,           "
-		pp->ldon_points_mmc,              // " ldon_points_mmc,           "
-		pp->ldon_points_ruj,              // " ldon_points_ruj,           "
-		pp->ldon_points_tak,              // " ldon_points_tak,           "
-		pp->ldon_points_available,          // " ldon_points_available,     "
-		pp->tribute_time_remaining,          // " tribute_time_remaining,    "
-		pp->showhelm,                      // " show_helm,                 "
-		pp->career_tribute_points,          // " career_tribute_points,     "
-		pp->tribute_points,                  // " tribute_points,            "
-		pp->tribute_active,                  // " tribute_active,            "
-		pp->endurance,                      // " endurance,                 "
-		pp->group_leadership_exp,          // " group_leadership_exp,      "
-		pp->raid_leadership_exp,          // " raid_leadership_exp,       "
-		pp->group_leadership_points,      // " group_leadership_points,   "
-		pp->raid_leadership_points,          // " raid_leadership_points,    "
-		pp->air_remaining,                  // " air_remaining,             "
-		pp->PVPKills,                      // " pvp_kills,                 "
-		pp->PVPDeaths,                      // " pvp_deaths,                "
-		pp->PVPCurrentPoints,              // " pvp_current_points,        "
-		pp->PVPCareerPoints,              // " pvp_career_points,         "
-		pp->PVPBestKillStreak,              // " pvp_best_kill_streak,      "
-		pp->PVPWorstDeathStreak,          // " pvp_worst_death_streak,    "
-		pp->PVPCurrentKillStreak,          // " pvp_current_kill_streak,   "
-		pp->aapoints_spent,                  // " aa_points_spent,           "
-		pp->expAA,                          // " aa_exp,                    "
-		pp->aapoints,                      // " aa_points,                 "
-		pp->groupAutoconsent,              // " group_auto_consent,        "
-		pp->raidAutoconsent,              // " raid_auto_consent,         "
-		pp->guildAutoconsent,              // " guild_auto_consent,        "
-		pp->RestTimer                      // " RestTimer)                 "
-	);
-	QueryDatabase(query);
+	auto c = CharacterDataRepository::NewEntity();

-	/* Save Bind Points */
-	query = StringFormat(
-		"REPLACE INTO `character_bind` (id, zone_id, instance_id, x, y, z, heading, slot)"
-		" VALUES (%u, %u, %u, %f, %f, %f, %f, %i), "
-		"(%u, %u, %u, %f, %f, %f, %f, %i), "
-		"(%u, %u, %u, %f, %f, %f, %f, %i), "
-		"(%u, %u, %u, %f, %f, %f, %f, %i), "
-		"(%u, %u, %u, %f, %f, %f, %f, %i)",
-		character_id, pp->binds[0].zone_id, 0, pp->binds[0].x, pp->binds[0].y, pp->binds[0].z, pp->binds[0].heading, 0,
-		character_id, pp->binds[1].zone_id, 0, pp->binds[1].x, pp->binds[1].y, pp->binds[1].z, pp->binds[1].heading, 1,
-		character_id, pp->binds[2].zone_id, 0, pp->binds[2].x, pp->binds[2].y, pp->binds[2].z, pp->binds[2].heading, 2,
-		character_id, pp->binds[3].zone_id, 0, pp->binds[3].x, pp->binds[3].y, pp->binds[3].z, pp->binds[3].heading, 3,
-		character_id, pp->binds[4].zone_id, 0, pp->binds[4].x, pp->binds[4].y, pp->binds[4].z, pp->binds[4].heading, 4
-	);
-	QueryDatabase(query);
+	c.id                      = character_id;
+	c.account_id              = account_id;
+	c.name                    = pp->name;
+	c.last_name               = pp->last_name;
+	c.gender                  = pp->gender;
+	c.race                    = pp->race;
+	c.class_                  = pp->class_;
+	c.level                   = pp->level;
+	c.deity                   = pp->deity;
+	c.birthday                = pp->birthday;
+	c.last_login              = pp->lastlogin;
+	c.time_played             = pp->timePlayedMin;
+	c.pvp_status              = pp->pvp;
+	c.level2                  = pp->level2;
+	c.anon                    = pp->anon;
+	c.gm                      = pp->gm;
+	c.intoxication            = pp->intoxication;
+	c.hair_color              = pp->haircolor;
+	c.beard_color             = pp->beardcolor;
+	c.eye_color_1             = pp->eyecolor1;
+	c.eye_color_2             = pp->eyecolor2;
+	c.hair_style              = pp->hairstyle;
+	c.beard                   = pp->beard;
+	c.ability_time_seconds    = pp->ability_time_seconds;
+	c.ability_number          = pp->ability_number;
+	c.ability_time_minutes    = pp->ability_time_minutes;
+	c.ability_time_hours      = pp->ability_time_hours;
+	c.title                   = pp->title;
+	c.suffix                  = pp->suffix;
+	c.exp                     = pp->exp;
+	c.points                  = pp->points;
+	c.mana                    = pp->mana;
+	c.cur_hp                  = pp->cur_hp;
+	c.str                     = pp->STR;
+	c.sta                     = pp->STA;
+	c.cha                     = pp->CHA;
+	c.dex                     = pp->DEX;
+	c.int_                    = pp->INT;
+	c.agi                     = pp->AGI;
+	c.wis                     = pp->WIS;
+	c.face                    = pp->face;
+	c.y                       = pp->y;
+	c.x                       = pp->x;
+	c.z                       = pp->z;
+	c.heading                 = pp->heading;
+	c.pvp2                    = pp->pvp2;
+	c.pvp_type                = pp->pvptype;
+	c.autosplit_enabled       = pp->autosplit;
+	c.zone_change_count       = pp->zone_change_count;
+	c.drakkin_heritage        = pp->drakkin_heritage;
+	c.drakkin_tattoo          = pp->drakkin_tattoo;
+	c.drakkin_details         = pp->drakkin_details;
+	c.toxicity                = pp->toxicity;
+	c.hunger_level            = pp->hunger_level;
+	c.thirst_level            = pp->thirst_level;
+	c.ability_up              = pp->ability_up;
+	c.zone_id                 = pp->zone_id;
+	c.zone_instance           = pp->zoneInstance;
+	c.leadership_exp_on       = pp->leadAAActive;
+	c.ldon_points_guk         = pp->ldon_points_guk;
+	c.ldon_points_mir         = pp->ldon_points_mir;
+	c.ldon_points_mmc         = pp->ldon_points_mmc;
+	c.ldon_points_ruj         = pp->ldon_points_ruj;
+	c.ldon_points_tak         = pp->ldon_points_tak;
+	c.ldon_points_available   = pp->ldon_points_available;
+	c.tribute_time_remaining  = pp->tribute_time_remaining;
+	c.show_helm               = pp->showhelm;
+	c.career_tribute_points   = pp->career_tribute_points;
+	c.tribute_points          = pp->tribute_points;
+	c.tribute_active          = pp->tribute_active;
+	c.endurance               = pp->endurance;
+	c.group_leadership_exp    = pp->group_leadership_exp;
+	c.raid_leadership_exp     = pp->raid_leadership_exp;
+	c.group_leadership_points = pp->group_leadership_points;
+	c.raid_leadership_points  = pp->raid_leadership_points;
+	c.air_remaining           = pp->air_remaining;
+	c.pvp_kills               = pp->PVPKills;
+	c.pvp_deaths              = pp->PVPDeaths;
+	c.pvp_current_points      = pp->PVPCurrentPoints;
+	c.pvp_career_points       = pp->PVPCareerPoints;
+	c.pvp_best_kill_streak    = pp->PVPBestKillStreak;
+	c.pvp_worst_death_streak  = pp->PVPWorstDeathStreak;
+	c.pvp_current_kill_streak = pp->PVPCurrentKillStreak;
+	c.aa_points_spent         = pp->aapoints_spent;
+	c.aa_exp                  = pp->expAA;
+	c.aa_points               = pp->aapoints;
+	c.group_auto_consent      = pp->groupAutoconsent;
+	c.raid_auto_consent       = pp->raidAutoconsent;
+	c.guild_auto_consent      = pp->guildAutoconsent;
+	c.RestTimer               = pp->RestTimer;
+
+	CharacterDataRepository::ReplaceOne(*this, c);
+
+	std::vector<CharacterBindRepository::CharacterBind> character_binds;
+
+	character_binds.reserve(5);
+
+	auto b = CharacterBindRepository::NewEntity();
+
+	b.id = character_id;
+
+	for (uint8 slot_id = 0; slot_id < 5; slot_id++) {
+		b.zone_id     = pp->binds[slot_id].zone_id;
+		b.x           = pp->binds[slot_id].x;
+		b.y           = pp->binds[slot_id].y;
+		b.z           = pp->binds[slot_id].z;
+		b.heading     = pp->binds[slot_id].heading;
+		b.slot        = slot_id;
+
+		character_binds.emplace_back(b);
+	}
+
+	CharacterBindRepository::ReplaceMany(*this, character_binds);

-	/* HoTT Ability */
 	if (RuleB(Character, GrantHoTTOnCreate)) {
-		query = StringFormat(
-			"INSERT INTO `character_leadership_abilities` (id, slot, `rank`) VALUES (%u, %i, %i)",
-			character_id,
-			14,
-			1
+		CharacterLeadershipAbilitiesRepository::InsertOne(
+			*this,
+			CharacterLeadershipAbilitiesRepository::CharacterLeadershipAbilities{
+				.id = character_id,
+				.slot = LeadershipAbilitySlot::HealthOfTargetsTarget,
+				.rank_ = 1
+			}
 		);
-		QueryDatabase(query);
 	}

-	/* Save Skills */
-	int      firstquery = 0;
-	for (int i          = 0; i < MAX_PP_SKILL; i++) {
-		if (pp->skills[i] > 0) {
-			if (firstquery != 1) {
-				firstquery = 1;
-				query      = StringFormat(
-					"REPLACE INTO `character_skills` (id, skill_id, value) VALUES (%u, %u, %u)",
-					character_id,
-					i,
-					pp->skills[i]
-				);
-			} else {
-				query = query + StringFormat(", (%u, %u, %u)", character_id, i, pp->skills[i]);
-			}
-		}
-	}
-	QueryDatabase(query);
+	std::vector<CharacterSkillsRepository::CharacterSkills> character_skills;

-	/* Save Language */
-	firstquery = 0;
-	for (int i = 0; i < MAX_PP_LANGUAGE; i++) {
-		if (pp->languages[i] > 0) {
-			if (firstquery != 1) {
-				firstquery = 1;
-				query      = StringFormat(
-					"REPLACE INTO `character_languages` (id, lang_id, value) VALUES (%u, %u, %u)",
-					character_id,
-					i,
-					pp->languages[i]
-				);
-			} else {
-				query = query + StringFormat(", (%u, %u, %u)", character_id, i, pp->languages[i]);
+	character_skills.reserve(MAX_PP_SKILL);
+
+	for (uint16 slot_id = 0; slot_id < MAX_PP_SKILL; slot_id++) {
+		character_skills.emplace_back(
+			CharacterSkillsRepository::CharacterSkills{
+				.id = character_id,
+				.skill_id = slot_id,
+				.value = static_cast<uint16_t>(pp->skills[slot_id])
 			}
-		}
+		);
 	}
-	QueryDatabase(query);
+
+	CharacterSkillsRepository::ReplaceMany(*this, character_skills);
+
+	std::vector<CharacterLanguagesRepository::CharacterLanguages> character_languages;
+
+	character_languages.reserve(MAX_PP_LANGUAGE);
+
+	for (uint16 slot_id = 0; slot_id < MAX_PP_LANGUAGE; slot_id++) {
+		character_languages.emplace_back(
+			CharacterLanguagesRepository::CharacterLanguages{
+				.id = character_id,
+				.lang_id = slot_id,
+				.value = static_cast<uint16_t>(pp->languages[slot_id])
+			}
+		);
+	}
+
+	CharacterLanguagesRepository::ReplaceMany(*this, character_languages);

 	return true;
 }

-uint32 Database::GetCharacterID(const char *name) {
-	const auto query = fmt::format(
-		"SELECT `id` FROM `character_data` WHERE `name` = '{}'",
-		Strings::Escape(name)
+uint32 Database::GetCharacterID(const std::string& name)
+{
+	const auto& l = CharacterDataRepository::GetWhere(
+		*this,
+		fmt::format(
+			"`name` = '{}'",
+			Strings::Escape(name)
+		)
 	);
-	auto results = QueryDatabase(query);
-	if (!results.Success() || !results.RowCount()) {
+
+	if (l.empty()) {
 		return 0;
 	}

-	auto row = results.begin();
-	return Strings::ToUnsignedInt(row[0]);
+	auto e = l.front();
+
+	return e.id;
 }

 /*
@@ -125,7 +125,7 @@ public:
 	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	GetCharacterID(const std::string& 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);
@@ -166,6 +166,7 @@ public:
 	void GetCharactersInInstance(uint16 instance_id, std::list<uint32> &character_ids);
 	void PurgeExpiredInstances();
 	void SetInstanceDuration(uint16 instance_id, uint32 new_duration);
+	void CleanupInstanceCorpses();

 	/* Adventure related. */

@@ -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",
@@ -5229,8 +5229,187 @@ ALTER TABLE `merchantlist_temp`
 		.condition = "not_empty",
 		.match = "",
 		.sql = R"(
-DROP TABLE item_tick
+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
 	}
 // -- template; copy/paste this when you need to create a new entry
 //	ManifestEntry{
@@ -104,6 +104,41 @@ 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
@@ -570,3 +570,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);
+}
@@ -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",
@@ -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();
@@ -639,3 +639,76 @@ std::string EQ::constants::GetAppearanceTypeName(uint32 appearance_type)

 	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" },
+	};
+
+	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();
+}
@@ -401,6 +401,9 @@ namespace EQ
 		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;
@@ -597,6 +600,65 @@ 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,
+	MAX_SPECIAL_ATTACK        = 56
+};
+

 namespace HeroicBonusBucket
 {
@@ -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
@@ -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),
@@ -1120,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*/
@@ -314,6 +314,7 @@ union
 	uint32 DestructibleUnk9;
 	bool targetable_with_hotkey;
 	bool show_name;
+	bool guild_show;
 };

 struct PlayerState_Struct {
@@ -631,6 +632,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
@@ -1671,6 +1678,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
@@ -1719,10 +1788,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;
@@ -1754,6 +1823,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];
@@ -1767,9 +1844,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*/
 };

@@ -3327,6 +3404,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.
@@ -3353,7 +3431,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
@@ -3372,7 +3485,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"
@@ -3394,6 +3507,7 @@ struct GuildStatus_Struct
 struct GuildDemoteStruct{
 	char	name[64];
 	char	target[64];
+	uint32	rank;
 };

 struct GuildRemoveStruct{
@@ -3403,9 +3517,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 {
@@ -3445,18 +3559,21 @@ struct Make_Pet_Struct { //Simple struct for getting pet info
 	uint32 min_dmg;
 	uint32 max_dmg;
 };
-struct GroundSpawn{
-	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 GroundSpawns {
 	struct GroundSpawn spawn[50]; //Assigned max number to allow
 };
@@ -3496,66 +3613,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;
 };


@@ -5544,28 +5788,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 {
@@ -5584,9 +5806,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
@@ -701,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;
 }
@@ -140,6 +140,7 @@ namespace Logs {
 		DataBuckets,
 		Zoning,
 		EqTime,
+		Corpses,
 		MaxCategoryID /* Don't Remove this */
 	};

@@ -239,6 +240,7 @@ namespace Logs {
 		"DataBuckets",
 		"Zoning",
 		"EqTime",
+		"Corpses",
 	};
 }

@@ -824,6 +824,16 @@
        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 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__);\
@@ -697,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;
@@ -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
@@ -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
@@ -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 {
@@ -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,63 @@ 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);
+		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);
 		uint32 _GetFreeGuildID();
+        GuildsRepository::Guilds CreateGuildRepoFromGuildInfo(uint32 guild_id, BaseGuildManager::GuildInfo& in);
 };
-
-
 #endif /*GUILD_BASE_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
@@ -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);
@@ -1419,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;
@@ -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
 //
@@ -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:
 		//////////////////////////
@@ -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
@@ -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
@@ -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;
@@ -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();
 	}
@@ -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;
+					}  //
 				}
 			}

@@ -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();
 	}
@@ -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);
@@ -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);
@@ -158,6 +158,7 @@ namespace RoF2
 				slotCursor
 			};

+			constexpr int16 format_as(InventorySlots slot) { return static_cast<int16>(slot); }
 		} // namespace enum_
 		using namespace enum_;

@@ -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)
@@ -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*/
 };

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


@@ -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*/
 };

@@ -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);
@@ -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)
@@ -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
@@ -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*/
@@ -36,6 +36,7 @@
 #include "../classes.h"
 #include "../races.h"
 #include "../raid.h"
+#include "../guilds.h"

 #include <iostream>
 #include <sstream>
@@ -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 != AppearanceType::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)
@@ -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_);
@@ -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);
@@ -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)
@@ -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_;
@@ -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;
 	}
@@ -151,16 +151,16 @@ public:
 		if (results.RowCount() == 1) {
 			BaseData e{};

-			e.level    = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
-			e.class_   = row[1] ? static_cast<uint32_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.unk1     = row[5] ? strtod(row[5], nullptr) : 0;
-			e.unk2     = 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;
+			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;
 		}
@@ -199,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));
@@ -230,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));
@@ -269,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));
@@ -307,16 +307,16 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			BaseData e{};

-			e.level    = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
-			e.class_   = row[1] ? static_cast<uint32_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.unk1     = row[5] ? strtod(row[5], nullptr) : 0;
-			e.unk2     = 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;
+			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);
 		}
@@ -341,16 +341,16 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			BaseData e{};

-			e.level    = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
-			e.class_   = row[1] ? static_cast<uint32_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.unk1     = row[5] ? strtod(row[5], nullptr) : 0;
-			e.unk2     = 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;
+			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);
 		}
@@ -430,8 +430,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));
@@ -462,8 +462,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));
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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_OWNER_OPTIONS_REPOSITORY_H
@@ -112,8 +112,9 @@ public:
 	{
 		auto results = db.QueryDatabase(
 			fmt::format(
-				"{} WHERE id = {} LIMIT 1",
+				"{} WHERE {} = {} LIMIT 1",
 				BaseSelect(),
+				PrimaryKey(),
 				bot_owner_options_id
 			)
 		);
@@ -122,9 +123,9 @@ public:
 		if (results.RowCount() == 1) {
 			BotOwnerOptions e{};

-			e.owner_id     = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.option_type  = static_cast<uint16_t>(strtoul(row[1], nullptr, 10));
-			e.option_value = static_cast<uint16_t>(strtoul(row[2], nullptr, 10));
+			e.owner_id     = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.option_type  = row[1] ? static_cast<uint16_t>(strtoul(row[1], nullptr, 10)) : 0;
+			e.option_value = row[2] ? static_cast<uint16_t>(strtoul(row[2], nullptr, 10)) : 0;

 			return e;
 		}
@@ -250,9 +251,9 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			BotOwnerOptions e{};

-			e.owner_id     = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.option_type  = static_cast<uint16_t>(strtoul(row[1], nullptr, 10));
-			e.option_value = static_cast<uint16_t>(strtoul(row[2], nullptr, 10));
+			e.owner_id     = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.option_type  = row[1] ? static_cast<uint16_t>(strtoul(row[1], nullptr, 10)) : 0;
+			e.option_value = row[2] ? static_cast<uint16_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) {
 			BotOwnerOptions e{};

-			e.owner_id     = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.option_type  = static_cast<uint16_t>(strtoul(row[1], nullptr, 10));
-			e.option_value = static_cast<uint16_t>(strtoul(row[2], nullptr, 10));
+			e.owner_id     = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.option_type  = row[1] ? static_cast<uint16_t>(strtoul(row[1], nullptr, 10)) : 0;
+			e.option_value = row[2] ? static_cast<uint16_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 BotOwnerOptions &e
+	)
+	{
+		std::vector<std::string> v;
+
+		v.push_back(std::to_string(e.owner_id));
+		v.push_back(std::to_string(e.option_type));
+		v.push_back(std::to_string(e.option_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<BotOwnerOptions> &entries
+	)
+	{
+		std::vector<std::string> insert_chunks;
+
+		for (auto &e: entries) {
+			std::vector<std::string> v;
+
+			v.push_back(std::to_string(e.owner_id));
+			v.push_back(std::to_string(e.option_type));
+			v.push_back(std::to_string(e.option_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_BOT_OWNER_OPTIONS_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_PET_BUFFS_REPOSITORY_H
@@ -120,8 +120,9 @@ public:
 	{
 		auto results = db.QueryDatabase(
 			fmt::format(
-				"{} WHERE id = {} LIMIT 1",
+				"{} WHERE {} = {} LIMIT 1",
 				BaseSelect(),
+				PrimaryKey(),
 				bot_pet_buffs_id
 			)
 		);
@@ -130,11 +131,11 @@ public:
 		if (results.RowCount() == 1) {
 			BotPetBuffs e{};

-			e.pet_buffs_index = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.pets_index      = 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<uint32_t>(strtoul(row[3], nullptr, 10));
-			e.duration        = static_cast<uint32_t>(strtoul(row[4], nullptr, 10));
+			e.pet_buffs_index = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.pets_index      = 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<uint32_t>(strtoul(row[3], nullptr, 10)) : 0;
+			e.duration        = row[4] ? static_cast<uint32_t>(strtoul(row[4], nullptr, 10)) : 0;

 			return e;
 		}
@@ -265,11 +266,11 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			BotPetBuffs e{};

-			e.pet_buffs_index = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.pets_index      = 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<uint32_t>(strtoul(row[3], nullptr, 10));
-			e.duration        = static_cast<uint32_t>(strtoul(row[4], nullptr, 10));
+			e.pet_buffs_index = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.pets_index      = 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<uint32_t>(strtoul(row[3], nullptr, 10)) : 0;
+			e.duration        = row[4] ? static_cast<uint32_t>(strtoul(row[4], nullptr, 10)) : 0;

 			all_entries.push_back(e);
 		}
@@ -294,11 +295,11 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			BotPetBuffs e{};

-			e.pet_buffs_index = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.pets_index      = 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<uint32_t>(strtoul(row[3], nullptr, 10));
-			e.duration        = static_cast<uint32_t>(strtoul(row[4], nullptr, 10));
+			e.pet_buffs_index = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.pets_index      = 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<uint32_t>(strtoul(row[3], nullptr, 10)) : 0;
+			e.duration        = row[4] ? static_cast<uint32_t>(strtoul(row[4], nullptr, 10)) : 0;

 			all_entries.push_back(e);
 		}
@@ -357,6 +358,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 BotPetBuffs &e
+	)
+	{
+		std::vector<std::string> v;
+
+		v.push_back(std::to_string(e.pet_buffs_index));
+		v.push_back(std::to_string(e.pets_index));
+		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));
+
+		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<BotPetBuffs> &entries
+	)
+	{
+		std::vector<std::string> insert_chunks;
+
+		for (auto &e: entries) {
+			std::vector<std::string> v;
+
+			v.push_back(std::to_string(e.pet_buffs_index));
+			v.push_back(std::to_string(e.pets_index));
+			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));
+
+			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_PET_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_PET_INVENTORIES_REPOSITORY_H
@@ -112,8 +112,9 @@ public:
 	{
 		auto results = db.QueryDatabase(
 			fmt::format(
-				"{} WHERE id = {} LIMIT 1",
+				"{} WHERE {} = {} LIMIT 1",
 				BaseSelect(),
+				PrimaryKey(),
 				bot_pet_inventories_id
 			)
 		);
@@ -122,9 +123,9 @@ public:
 		if (results.RowCount() == 1) {
 			BotPetInventories e{};

-			e.pet_inventories_index = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.pets_index            = static_cast<uint32_t>(strtoul(row[1], nullptr, 10));
-			e.item_id               = static_cast<uint32_t>(strtoul(row[2], nullptr, 10));
+			e.pet_inventories_index = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.pets_index            = row[1] ? static_cast<uint32_t>(strtoul(row[1], nullptr, 10)) : 0;
+			e.item_id               = row[2] ? static_cast<uint32_t>(strtoul(row[2], nullptr, 10)) : 0;

 			return e;
 		}
@@ -249,9 +250,9 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			BotPetInventories e{};

-			e.pet_inventories_index = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.pets_index            = static_cast<uint32_t>(strtoul(row[1], nullptr, 10));
-			e.item_id               = static_cast<uint32_t>(strtoul(row[2], nullptr, 10));
+			e.pet_inventories_index = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.pets_index            = row[1] ? static_cast<uint32_t>(strtoul(row[1], nullptr, 10)) : 0;
+			e.item_id               = row[2] ? static_cast<uint32_t>(strtoul(row[2], nullptr, 10)) : 0;

 			all_entries.push_back(e);
 		}
@@ -276,9 +277,9 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			BotPetInventories e{};

-			e.pet_inventories_index = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.pets_index            = static_cast<uint32_t>(strtoul(row[1], nullptr, 10));
-			e.item_id               = static_cast<uint32_t>(strtoul(row[2], nullptr, 10));
+			e.pet_inventories_index = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.pets_index            = row[1] ? static_cast<uint32_t>(strtoul(row[1], nullptr, 10)) : 0;
+			e.item_id               = row[2] ? static_cast<uint32_t>(strtoul(row[2], nullptr, 10)) : 0;

 			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 BotPetInventories &e
+	)
+	{
+		std::vector<std::string> v;
+
+		v.push_back(std::to_string(e.pet_inventories_index));
+		v.push_back(std::to_string(e.pets_index));
+		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<BotPetInventories> &entries
+	)
+	{
+		std::vector<std::string> insert_chunks;
+
+		for (auto &e: entries) {
+			std::vector<std::string> v;
+
+			v.push_back(std::to_string(e.pet_inventories_index));
+			v.push_back(std::to_string(e.pets_index));
+			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_BOT_PET_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_PETS_REPOSITORY_H
@@ -124,8 +124,9 @@ public:
 	{
 		auto results = db.QueryDatabase(
 			fmt::format(
-				"{} WHERE id = {} LIMIT 1",
+				"{} WHERE {} = {} LIMIT 1",
 				BaseSelect(),
+				PrimaryKey(),
 				bot_pets_id
 			)
 		);
@@ -134,12 +135,12 @@ public:
 		if (results.RowCount() == 1) {
 			BotPets e{};

-			e.pets_index = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.spell_id   = static_cast<uint32_t>(strtoul(row[1], nullptr, 10));
-			e.bot_id     = static_cast<uint32_t>(strtoul(row[2], nullptr, 10));
+			e.pets_index = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.spell_id   = 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;
 			e.name       = row[3] ? row[3] : "";
-			e.mana       = static_cast<int32_t>(atoi(row[4]));
-			e.hp         = static_cast<int32_t>(atoi(row[5]));
+			e.mana       = row[4] ? static_cast<int32_t>(atoi(row[4])) : 0;
+			e.hp         = row[5] ? static_cast<int32_t>(atoi(row[5])) : 0;

 			return e;
 		}
@@ -273,12 +274,12 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			BotPets e{};

-			e.pets_index = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.spell_id   = static_cast<uint32_t>(strtoul(row[1], nullptr, 10));
-			e.bot_id     = static_cast<uint32_t>(strtoul(row[2], nullptr, 10));
+			e.pets_index = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.spell_id   = 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;
 			e.name       = row[3] ? row[3] : "";
-			e.mana       = static_cast<int32_t>(atoi(row[4]));
-			e.hp         = static_cast<int32_t>(atoi(row[5]));
+			e.mana       = row[4] ? static_cast<int32_t>(atoi(row[4])) : 0;
+			e.hp         = row[5] ? static_cast<int32_t>(atoi(row[5])) : 0;

 			all_entries.push_back(e);
 		}
@@ -303,12 +304,12 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			BotPets e{};

-			e.pets_index = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.spell_id   = static_cast<uint32_t>(strtoul(row[1], nullptr, 10));
-			e.bot_id     = static_cast<uint32_t>(strtoul(row[2], nullptr, 10));
+			e.pets_index = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.spell_id   = 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;
 			e.name       = row[3] ? row[3] : "";
-			e.mana       = static_cast<int32_t>(atoi(row[4]));
-			e.hp         = static_cast<int32_t>(atoi(row[5]));
+			e.mana       = row[4] ? static_cast<int32_t>(atoi(row[4])) : 0;
+			e.hp         = row[5] ? static_cast<int32_t>(atoi(row[5])) : 0;

 			all_entries.push_back(e);
 		}
@@ -367,6 +368,72 @@ 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 BotPets &e
+	)
+	{
+		std::vector<std::string> v;
+
+		v.push_back(std::to_string(e.pets_index));
+		v.push_back(std::to_string(e.spell_id));
+		v.push_back(std::to_string(e.bot_id));
+		v.push_back("'" + Strings::Escape(e.name) + "'");
+		v.push_back(std::to_string(e.mana));
+		v.push_back(std::to_string(e.hp));
+
+		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<BotPets> &entries
+	)
+	{
+		std::vector<std::string> insert_chunks;
+
+		for (auto &e: entries) {
+			std::vector<std::string> v;
+
+			v.push_back(std::to_string(e.pets_index));
+			v.push_back(std::to_string(e.spell_id));
+			v.push_back(std::to_string(e.bot_id));
+			v.push_back("'" + Strings::Escape(e.name) + "'");
+			v.push_back(std::to_string(e.mana));
+			v.push_back(std::to_string(e.hp));
+
+			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_PETS_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_SPELL_CASTING_CHANCES_REPOSITORY_H
@@ -180,8 +180,9 @@ public:
 	{
 		auto results = db.QueryDatabase(
 			fmt::format(
-				"{} WHERE id = {} LIMIT 1",
+				"{} WHERE {} = {} LIMIT 1",
 				BaseSelect(),
+				PrimaryKey(),
 				bot_spell_casting_chances_id
 			)
 		);
@@ -190,26 +191,26 @@ public:
 		if (results.RowCount() == 1) {
 			BotSpellCastingChances e{};

-			e.id               = static_cast<int32_t>(atoi(row[0]));
-			e.spell_type_index = static_cast<uint8_t>(strtoul(row[1], nullptr, 10));
-			e.class_id         = static_cast<uint8_t>(strtoul(row[2], nullptr, 10));
-			e.stance_index     = static_cast<uint8_t>(strtoul(row[3], nullptr, 10));
-			e.nHSND_value      = static_cast<uint8_t>(strtoul(row[4], nullptr, 10));
-			e.pH_value         = static_cast<uint8_t>(strtoul(row[5], nullptr, 10));
-			e.pS_value         = static_cast<uint8_t>(strtoul(row[6], nullptr, 10));
-			e.pHS_value        = static_cast<uint8_t>(strtoul(row[7], nullptr, 10));
-			e.pN_value         = static_cast<uint8_t>(strtoul(row[8], nullptr, 10));
-			e.pHN_value        = static_cast<uint8_t>(strtoul(row[9], nullptr, 10));
-			e.pSN_value        = static_cast<uint8_t>(strtoul(row[10], nullptr, 10));
-			e.pHSN_value       = static_cast<uint8_t>(strtoul(row[11], nullptr, 10));
-			e.pD_value         = static_cast<uint8_t>(strtoul(row[12], nullptr, 10));
-			e.pHD_value        = static_cast<uint8_t>(strtoul(row[13], nullptr, 10));
-			e.pSD_value        = static_cast<uint8_t>(strtoul(row[14], nullptr, 10));
-			e.pHSD_value       = static_cast<uint8_t>(strtoul(row[15], nullptr, 10));
-			e.pND_value        = static_cast<uint8_t>(strtoul(row[16], nullptr, 10));
-			e.pHND_value       = static_cast<uint8_t>(strtoul(row[17], nullptr, 10));
-			e.pSND_value       = static_cast<uint8_t>(strtoul(row[18], nullptr, 10));
-			e.pHSND_value      = static_cast<uint8_t>(strtoul(row[19], nullptr, 10));
+			e.id               = row[0] ? static_cast<int32_t>(atoi(row[0])) : 0;
+			e.spell_type_index = row[1] ? static_cast<uint8_t>(strtoul(row[1], nullptr, 10)) : 0;
+			e.class_id         = row[2] ? static_cast<uint8_t>(strtoul(row[2], nullptr, 10)) : 0;
+			e.stance_index     = row[3] ? static_cast<uint8_t>(strtoul(row[3], nullptr, 10)) : 0;
+			e.nHSND_value      = row[4] ? static_cast<uint8_t>(strtoul(row[4], nullptr, 10)) : 0;
+			e.pH_value         = row[5] ? static_cast<uint8_t>(strtoul(row[5], nullptr, 10)) : 0;
+			e.pS_value         = row[6] ? static_cast<uint8_t>(strtoul(row[6], nullptr, 10)) : 0;
+			e.pHS_value        = row[7] ? static_cast<uint8_t>(strtoul(row[7], nullptr, 10)) : 0;
+			e.pN_value         = row[8] ? static_cast<uint8_t>(strtoul(row[8], nullptr, 10)) : 0;
+			e.pHN_value        = row[9] ? static_cast<uint8_t>(strtoul(row[9], nullptr, 10)) : 0;
+			e.pSN_value        = row[10] ? static_cast<uint8_t>(strtoul(row[10], nullptr, 10)) : 0;
+			e.pHSN_value       = row[11] ? static_cast<uint8_t>(strtoul(row[11], nullptr, 10)) : 0;
+			e.pD_value         = row[12] ? static_cast<uint8_t>(strtoul(row[12], nullptr, 10)) : 0;
+			e.pHD_value        = row[13] ? static_cast<uint8_t>(strtoul(row[13], nullptr, 10)) : 0;
+			e.pSD_value        = row[14] ? static_cast<uint8_t>(strtoul(row[14], nullptr, 10)) : 0;
+			e.pHSD_value       = row[15] ? static_cast<uint8_t>(strtoul(row[15], nullptr, 10)) : 0;
+			e.pND_value        = row[16] ? static_cast<uint8_t>(strtoul(row[16], nullptr, 10)) : 0;
+			e.pHND_value       = row[17] ? static_cast<uint8_t>(strtoul(row[17], nullptr, 10)) : 0;
+			e.pSND_value       = row[18] ? static_cast<uint8_t>(strtoul(row[18], nullptr, 10)) : 0;
+			e.pHSND_value      = row[19] ? static_cast<uint8_t>(strtoul(row[19], nullptr, 10)) : 0;

 			return e;
 		}
@@ -385,26 +386,26 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			BotSpellCastingChances e{};

-			e.id               = static_cast<int32_t>(atoi(row[0]));
-			e.spell_type_index = static_cast<uint8_t>(strtoul(row[1], nullptr, 10));
-			e.class_id         = static_cast<uint8_t>(strtoul(row[2], nullptr, 10));
-			e.stance_index     = static_cast<uint8_t>(strtoul(row[3], nullptr, 10));
-			e.nHSND_value      = static_cast<uint8_t>(strtoul(row[4], nullptr, 10));
-			e.pH_value         = static_cast<uint8_t>(strtoul(row[5], nullptr, 10));
-			e.pS_value         = static_cast<uint8_t>(strtoul(row[6], nullptr, 10));
-			e.pHS_value        = static_cast<uint8_t>(strtoul(row[7], nullptr, 10));
-			e.pN_value         = static_cast<uint8_t>(strtoul(row[8], nullptr, 10));
-			e.pHN_value        = static_cast<uint8_t>(strtoul(row[9], nullptr, 10));
-			e.pSN_value        = static_cast<uint8_t>(strtoul(row[10], nullptr, 10));
-			e.pHSN_value       = static_cast<uint8_t>(strtoul(row[11], nullptr, 10));
-			e.pD_value         = static_cast<uint8_t>(strtoul(row[12], nullptr, 10));
-			e.pHD_value        = static_cast<uint8_t>(strtoul(row[13], nullptr, 10));
-			e.pSD_value        = static_cast<uint8_t>(strtoul(row[14], nullptr, 10));
-			e.pHSD_value       = static_cast<uint8_t>(strtoul(row[15], nullptr, 10));
-			e.pND_value        = static_cast<uint8_t>(strtoul(row[16], nullptr, 10));
-			e.pHND_value       = static_cast<uint8_t>(strtoul(row[17], nullptr, 10));
-			e.pSND_value       = static_cast<uint8_t>(strtoul(row[18], nullptr, 10));
-			e.pHSND_value      = static_cast<uint8_t>(strtoul(row[19], nullptr, 10));
+			e.id               = row[0] ? static_cast<int32_t>(atoi(row[0])) : 0;
+			e.spell_type_index = row[1] ? static_cast<uint8_t>(strtoul(row[1], nullptr, 10)) : 0;
+			e.class_id         = row[2] ? static_cast<uint8_t>(strtoul(row[2], nullptr, 10)) : 0;
+			e.stance_index     = row[3] ? static_cast<uint8_t>(strtoul(row[3], nullptr, 10)) : 0;
+			e.nHSND_value      = row[4] ? static_cast<uint8_t>(strtoul(row[4], nullptr, 10)) : 0;
+			e.pH_value         = row[5] ? static_cast<uint8_t>(strtoul(row[5], nullptr, 10)) : 0;
+			e.pS_value         = row[6] ? static_cast<uint8_t>(strtoul(row[6], nullptr, 10)) : 0;
+			e.pHS_value        = row[7] ? static_cast<uint8_t>(strtoul(row[7], nullptr, 10)) : 0;
+			e.pN_value         = row[8] ? static_cast<uint8_t>(strtoul(row[8], nullptr, 10)) : 0;
+			e.pHN_value        = row[9] ? static_cast<uint8_t>(strtoul(row[9], nullptr, 10)) : 0;
+			e.pSN_value        = row[10] ? static_cast<uint8_t>(strtoul(row[10], nullptr, 10)) : 0;
+			e.pHSN_value       = row[11] ? static_cast<uint8_t>(strtoul(row[11], nullptr, 10)) : 0;
+			e.pD_value         = row[12] ? static_cast<uint8_t>(strtoul(row[12], nullptr, 10)) : 0;
+			e.pHD_value        = row[13] ? static_cast<uint8_t>(strtoul(row[13], nullptr, 10)) : 0;
+			e.pSD_value        = row[14] ? static_cast<uint8_t>(strtoul(row[14], nullptr, 10)) : 0;
+			e.pHSD_value       = row[15] ? static_cast<uint8_t>(strtoul(row[15], nullptr, 10)) : 0;
+			e.pND_value        = row[16] ? static_cast<uint8_t>(strtoul(row[16], nullptr, 10)) : 0;
+			e.pHND_value       = row[17] ? static_cast<uint8_t>(strtoul(row[17], nullptr, 10)) : 0;
+			e.pSND_value       = row[18] ? static_cast<uint8_t>(strtoul(row[18], nullptr, 10)) : 0;
+			e.pHSND_value      = row[19] ? static_cast<uint8_t>(strtoul(row[19], nullptr, 10)) : 0;

 			all_entries.push_back(e);
 		}
@@ -429,26 +430,26 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			BotSpellCastingChances e{};

-			e.id               = static_cast<int32_t>(atoi(row[0]));
-			e.spell_type_index = static_cast<uint8_t>(strtoul(row[1], nullptr, 10));
-			e.class_id         = static_cast<uint8_t>(strtoul(row[2], nullptr, 10));
-			e.stance_index     = static_cast<uint8_t>(strtoul(row[3], nullptr, 10));
-			e.nHSND_value      = static_cast<uint8_t>(strtoul(row[4], nullptr, 10));
-			e.pH_value         = static_cast<uint8_t>(strtoul(row[5], nullptr, 10));
-			e.pS_value         = static_cast<uint8_t>(strtoul(row[6], nullptr, 10));
-			e.pHS_value        = static_cast<uint8_t>(strtoul(row[7], nullptr, 10));
-			e.pN_value         = static_cast<uint8_t>(strtoul(row[8], nullptr, 10));
-			e.pHN_value        = static_cast<uint8_t>(strtoul(row[9], nullptr, 10));
-			e.pSN_value        = static_cast<uint8_t>(strtoul(row[10], nullptr, 10));
-			e.pHSN_value       = static_cast<uint8_t>(strtoul(row[11], nullptr, 10));
-			e.pD_value         = static_cast<uint8_t>(strtoul(row[12], nullptr, 10));
-			e.pHD_value        = static_cast<uint8_t>(strtoul(row[13], nullptr, 10));
-			e.pSD_value        = static_cast<uint8_t>(strtoul(row[14], nullptr, 10));
-			e.pHSD_value       = static_cast<uint8_t>(strtoul(row[15], nullptr, 10));
-			e.pND_value        = static_cast<uint8_t>(strtoul(row[16], nullptr, 10));
-			e.pHND_value       = static_cast<uint8_t>(strtoul(row[17], nullptr, 10));
-			e.pSND_value       = static_cast<uint8_t>(strtoul(row[18], nullptr, 10));
-			e.pHSND_value      = static_cast<uint8_t>(strtoul(row[19], nullptr, 10));
+			e.id               = row[0] ? static_cast<int32_t>(atoi(row[0])) : 0;
+			e.spell_type_index = row[1] ? static_cast<uint8_t>(strtoul(row[1], nullptr, 10)) : 0;
+			e.class_id         = row[2] ? static_cast<uint8_t>(strtoul(row[2], nullptr, 10)) : 0;
+			e.stance_index     = row[3] ? static_cast<uint8_t>(strtoul(row[3], nullptr, 10)) : 0;
+			e.nHSND_value      = row[4] ? static_cast<uint8_t>(strtoul(row[4], nullptr, 10)) : 0;
+			e.pH_value         = row[5] ? static_cast<uint8_t>(strtoul(row[5], nullptr, 10)) : 0;
+			e.pS_value         = row[6] ? static_cast<uint8_t>(strtoul(row[6], nullptr, 10)) : 0;
+			e.pHS_value        = row[7] ? static_cast<uint8_t>(strtoul(row[7], nullptr, 10)) : 0;
+			e.pN_value         = row[8] ? static_cast<uint8_t>(strtoul(row[8], nullptr, 10)) : 0;
+			e.pHN_value        = row[9] ? static_cast<uint8_t>(strtoul(row[9], nullptr, 10)) : 0;
+			e.pSN_value        = row[10] ? static_cast<uint8_t>(strtoul(row[10], nullptr, 10)) : 0;
+			e.pHSN_value       = row[11] ? static_cast<uint8_t>(strtoul(row[11], nullptr, 10)) : 0;
+			e.pD_value         = row[12] ? static_cast<uint8_t>(strtoul(row[12], nullptr, 10)) : 0;
+			e.pHD_value        = row[13] ? static_cast<uint8_t>(strtoul(row[13], nullptr, 10)) : 0;
+			e.pSD_value        = row[14] ? static_cast<uint8_t>(strtoul(row[14], nullptr, 10)) : 0;
+			e.pHSD_value       = row[15] ? static_cast<uint8_t>(strtoul(row[15], nullptr, 10)) : 0;
+			e.pND_value        = row[16] ? static_cast<uint8_t>(strtoul(row[16], nullptr, 10)) : 0;
+			e.pHND_value       = row[17] ? static_cast<uint8_t>(strtoul(row[17], nullptr, 10)) : 0;
+			e.pSND_value       = row[18] ? static_cast<uint8_t>(strtoul(row[18], nullptr, 10)) : 0;
+			e.pHSND_value      = row[19] ? static_cast<uint8_t>(strtoul(row[19], nullptr, 10)) : 0;

 			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 BotSpellCastingChances &e
+	)
+	{
+		std::vector<std::string> v;
+
+		v.push_back(std::to_string(e.id));
+		v.push_back(std::to_string(e.spell_type_index));
+		v.push_back(std::to_string(e.class_id));
+		v.push_back(std::to_string(e.stance_index));
+		v.push_back(std::to_string(e.nHSND_value));
+		v.push_back(std::to_string(e.pH_value));
+		v.push_back(std::to_string(e.pS_value));
+		v.push_back(std::to_string(e.pHS_value));
+		v.push_back(std::to_string(e.pN_value));
+		v.push_back(std::to_string(e.pHN_value));
+		v.push_back(std::to_string(e.pSN_value));
+		v.push_back(std::to_string(e.pHSN_value));
+		v.push_back(std::to_string(e.pD_value));
+		v.push_back(std::to_string(e.pHD_value));
+		v.push_back(std::to_string(e.pSD_value));
+		v.push_back(std::to_string(e.pHSD_value));
+		v.push_back(std::to_string(e.pND_value));
+		v.push_back(std::to_string(e.pHND_value));
+		v.push_back(std::to_string(e.pSND_value));
+		v.push_back(std::to_string(e.pHSND_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<BotSpellCastingChances> &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.spell_type_index));
+			v.push_back(std::to_string(e.class_id));
+			v.push_back(std::to_string(e.stance_index));
+			v.push_back(std::to_string(e.nHSND_value));
+			v.push_back(std::to_string(e.pH_value));
+			v.push_back(std::to_string(e.pS_value));
+			v.push_back(std::to_string(e.pHS_value));
+			v.push_back(std::to_string(e.pN_value));
+			v.push_back(std::to_string(e.pHN_value));
+			v.push_back(std::to_string(e.pSN_value));
+			v.push_back(std::to_string(e.pHSN_value));
+			v.push_back(std::to_string(e.pD_value));
+			v.push_back(std::to_string(e.pHD_value));
+			v.push_back(std::to_string(e.pSD_value));
+			v.push_back(std::to_string(e.pHSD_value));
+			v.push_back(std::to_string(e.pND_value));
+			v.push_back(std::to_string(e.pHND_value));
+			v.push_back(std::to_string(e.pSND_value));
+			v.push_back(std::to_string(e.pHSND_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_BOT_SPELL_CASTING_CHANCES_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_SPELL_SETTINGS_REPOSITORY_H
@@ -128,8 +128,9 @@ public:
 	{
 		auto results = db.QueryDatabase(
 			fmt::format(
-				"{} WHERE id = {} LIMIT 1",
+				"{} WHERE {} = {} LIMIT 1",
 				BaseSelect(),
+				PrimaryKey(),
 				bot_spell_settings_id
 			)
 		);
@@ -138,13 +139,13 @@ public:
 		if (results.RowCount() == 1) {
 			BotSpellSettings e{};

-			e.id         = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.bot_id     = static_cast<int32_t>(atoi(row[1]));
-			e.spell_id   = static_cast<int16_t>(atoi(row[2]));
-			e.priority   = static_cast<int16_t>(atoi(row[3]));
-			e.min_hp     = static_cast<int16_t>(atoi(row[4]));
-			e.max_hp     = static_cast<int16_t>(atoi(row[5]));
-			e.is_enabled = static_cast<uint8_t>(strtoul(row[6], nullptr, 10));
+			e.id         = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.bot_id     = row[1] ? static_cast<int32_t>(atoi(row[1])) : 0;
+			e.spell_id   = row[2] ? static_cast<int16_t>(atoi(row[2])) : 0;
+			e.priority   = row[3] ? static_cast<int16_t>(atoi(row[3])) : 0;
+			e.min_hp     = row[4] ? static_cast<int16_t>(atoi(row[4])) : 0;
+			e.max_hp     = row[5] ? static_cast<int16_t>(atoi(row[5])) : 0;
+			e.is_enabled = row[6] ? static_cast<uint8_t>(strtoul(row[6], nullptr, 10)) : 1;

 			return e;
 		}
@@ -281,13 +282,13 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			BotSpellSettings e{};

-			e.id         = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.bot_id     = static_cast<int32_t>(atoi(row[1]));
-			e.spell_id   = static_cast<int16_t>(atoi(row[2]));
-			e.priority   = static_cast<int16_t>(atoi(row[3]));
-			e.min_hp     = static_cast<int16_t>(atoi(row[4]));
-			e.max_hp     = static_cast<int16_t>(atoi(row[5]));
-			e.is_enabled = static_cast<uint8_t>(strtoul(row[6], nullptr, 10));
+			e.id         = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.bot_id     = row[1] ? static_cast<int32_t>(atoi(row[1])) : 0;
+			e.spell_id   = row[2] ? static_cast<int16_t>(atoi(row[2])) : 0;
+			e.priority   = row[3] ? static_cast<int16_t>(atoi(row[3])) : 0;
+			e.min_hp     = row[4] ? static_cast<int16_t>(atoi(row[4])) : 0;
+			e.max_hp     = row[5] ? static_cast<int16_t>(atoi(row[5])) : 0;
+			e.is_enabled = row[6] ? static_cast<uint8_t>(strtoul(row[6], nullptr, 10)) : 1;

 			all_entries.push_back(e);
 		}
@@ -312,13 +313,13 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			BotSpellSettings e{};

-			e.id         = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.bot_id     = static_cast<int32_t>(atoi(row[1]));
-			e.spell_id   = static_cast<int16_t>(atoi(row[2]));
-			e.priority   = static_cast<int16_t>(atoi(row[3]));
-			e.min_hp     = static_cast<int16_t>(atoi(row[4]));
-			e.max_hp     = static_cast<int16_t>(atoi(row[5]));
-			e.is_enabled = static_cast<uint8_t>(strtoul(row[6], nullptr, 10));
+			e.id         = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.bot_id     = row[1] ? static_cast<int32_t>(atoi(row[1])) : 0;
+			e.spell_id   = row[2] ? static_cast<int16_t>(atoi(row[2])) : 0;
+			e.priority   = row[3] ? static_cast<int16_t>(atoi(row[3])) : 0;
+			e.min_hp     = row[4] ? static_cast<int16_t>(atoi(row[4])) : 0;
+			e.max_hp     = row[5] ? static_cast<int16_t>(atoi(row[5])) : 0;
+			e.is_enabled = row[6] ? static_cast<uint8_t>(strtoul(row[6], nullptr, 10)) : 1;

 			all_entries.push_back(e);
 		}
@@ -377,6 +378,74 @@ 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 BotSpellSettings &e
+	)
+	{
+		std::vector<std::string> v;
+
+		v.push_back(std::to_string(e.id));
+		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.priority));
+		v.push_back(std::to_string(e.min_hp));
+		v.push_back(std::to_string(e.max_hp));
+		v.push_back(std::to_string(e.is_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<BotSpellSettings> &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.bot_id));
+			v.push_back(std::to_string(e.spell_id));
+			v.push_back(std::to_string(e.priority));
+			v.push_back(std::to_string(e.min_hp));
+			v.push_back(std::to_string(e.max_hp));
+			v.push_back(std::to_string(e.is_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_BOT_SPELL_SETTINGS_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_SPELLS_ENTRIES_REPOSITORY_H
@@ -160,8 +160,9 @@ public:
 	{
 		auto results = db.QueryDatabase(
 			fmt::format(
-				"{} WHERE id = {} LIMIT 1",
+				"{} WHERE {} = {} LIMIT 1",
 				BaseSelect(),
+				PrimaryKey(),
 				bot_spells_entries_id
 			)
 		);
@@ -170,21 +171,21 @@ public:
 		if (results.RowCount() == 1) {
 			BotSpellsEntries e{};

-			e.id                = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.npc_spells_id     = static_cast<int32_t>(atoi(row[1]));
-			e.spellid           = static_cast<int16_t>(atoi(row[2]));
-			e.type              = static_cast<uint32_t>(strtoul(row[3], nullptr, 10));
-			e.minlevel          = static_cast<uint8_t>(strtoul(row[4], nullptr, 10));
-			e.maxlevel          = static_cast<uint8_t>(strtoul(row[5], nullptr, 10));
-			e.manacost          = static_cast<int16_t>(atoi(row[6]));
-			e.recast_delay      = static_cast<int32_t>(atoi(row[7]));
-			e.priority          = static_cast<int16_t>(atoi(row[8]));
-			e.resist_adjust     = static_cast<int32_t>(atoi(row[9]));
-			e.min_hp            = static_cast<int16_t>(atoi(row[10]));
-			e.max_hp            = static_cast<int16_t>(atoi(row[11]));
+			e.id                = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.npc_spells_id     = row[1] ? static_cast<int32_t>(atoi(row[1])) : 0;
+			e.spellid           = row[2] ? static_cast<int16_t>(atoi(row[2])) : 0;
+			e.type              = row[3] ? static_cast<uint32_t>(strtoul(row[3], nullptr, 10)) : 0;
+			e.minlevel          = row[4] ? static_cast<uint8_t>(strtoul(row[4], nullptr, 10)) : 0;
+			e.maxlevel          = row[5] ? static_cast<uint8_t>(strtoul(row[5], nullptr, 10)) : 255;
+			e.manacost          = row[6] ? static_cast<int16_t>(atoi(row[6])) : -1;
+			e.recast_delay      = row[7] ? static_cast<int32_t>(atoi(row[7])) : -1;
+			e.priority          = row[8] ? static_cast<int16_t>(atoi(row[8])) : 0;
+			e.resist_adjust     = row[9] ? static_cast<int32_t>(atoi(row[9])) : 0;
+			e.min_hp            = row[10] ? static_cast<int16_t>(atoi(row[10])) : 0;
+			e.max_hp            = row[11] ? static_cast<int16_t>(atoi(row[11])) : 0;
 			e.bucket_name       = row[12] ? row[12] : "";
 			e.bucket_value      = row[13] ? row[13] : "";
-			e.bucket_comparison = static_cast<uint8_t>(strtoul(row[14], nullptr, 10));
+			e.bucket_comparison = row[14] ? static_cast<uint8_t>(strtoul(row[14], nullptr, 10)) : 0;

 			return e;
 		}
@@ -345,21 +346,21 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			BotSpellsEntries e{};

-			e.id                = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.npc_spells_id     = static_cast<int32_t>(atoi(row[1]));
-			e.spellid           = static_cast<int16_t>(atoi(row[2]));
-			e.type              = static_cast<uint32_t>(strtoul(row[3], nullptr, 10));
-			e.minlevel          = static_cast<uint8_t>(strtoul(row[4], nullptr, 10));
-			e.maxlevel          = static_cast<uint8_t>(strtoul(row[5], nullptr, 10));
-			e.manacost          = static_cast<int16_t>(atoi(row[6]));
-			e.recast_delay      = static_cast<int32_t>(atoi(row[7]));
-			e.priority          = static_cast<int16_t>(atoi(row[8]));
-			e.resist_adjust     = static_cast<int32_t>(atoi(row[9]));
-			e.min_hp            = static_cast<int16_t>(atoi(row[10]));
-			e.max_hp            = static_cast<int16_t>(atoi(row[11]));
+			e.id                = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.npc_spells_id     = row[1] ? static_cast<int32_t>(atoi(row[1])) : 0;
+			e.spellid           = row[2] ? static_cast<int16_t>(atoi(row[2])) : 0;
+			e.type              = row[3] ? static_cast<uint32_t>(strtoul(row[3], nullptr, 10)) : 0;
+			e.minlevel          = row[4] ? static_cast<uint8_t>(strtoul(row[4], nullptr, 10)) : 0;
+			e.maxlevel          = row[5] ? static_cast<uint8_t>(strtoul(row[5], nullptr, 10)) : 255;
+			e.manacost          = row[6] ? static_cast<int16_t>(atoi(row[6])) : -1;
+			e.recast_delay      = row[7] ? static_cast<int32_t>(atoi(row[7])) : -1;
+			e.priority          = row[8] ? static_cast<int16_t>(atoi(row[8])) : 0;
+			e.resist_adjust     = row[9] ? static_cast<int32_t>(atoi(row[9])) : 0;
+			e.min_hp            = row[10] ? static_cast<int16_t>(atoi(row[10])) : 0;
+			e.max_hp            = row[11] ? static_cast<int16_t>(atoi(row[11])) : 0;
 			e.bucket_name       = row[12] ? row[12] : "";
 			e.bucket_value      = row[13] ? row[13] : "";
-			e.bucket_comparison = static_cast<uint8_t>(strtoul(row[14], nullptr, 10));
+			e.bucket_comparison = row[14] ? static_cast<uint8_t>(strtoul(row[14], nullptr, 10)) : 0;

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

-			e.id                = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.npc_spells_id     = static_cast<int32_t>(atoi(row[1]));
-			e.spellid           = static_cast<int16_t>(atoi(row[2]));
-			e.type              = static_cast<uint32_t>(strtoul(row[3], nullptr, 10));
-			e.minlevel          = static_cast<uint8_t>(strtoul(row[4], nullptr, 10));
-			e.maxlevel          = static_cast<uint8_t>(strtoul(row[5], nullptr, 10));
-			e.manacost          = static_cast<int16_t>(atoi(row[6]));
-			e.recast_delay      = static_cast<int32_t>(atoi(row[7]));
-			e.priority          = static_cast<int16_t>(atoi(row[8]));
-			e.resist_adjust     = static_cast<int32_t>(atoi(row[9]));
-			e.min_hp            = static_cast<int16_t>(atoi(row[10]));
-			e.max_hp            = static_cast<int16_t>(atoi(row[11]));
+			e.id                = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.npc_spells_id     = row[1] ? static_cast<int32_t>(atoi(row[1])) : 0;
+			e.spellid           = row[2] ? static_cast<int16_t>(atoi(row[2])) : 0;
+			e.type              = row[3] ? static_cast<uint32_t>(strtoul(row[3], nullptr, 10)) : 0;
+			e.minlevel          = row[4] ? static_cast<uint8_t>(strtoul(row[4], nullptr, 10)) : 0;
+			e.maxlevel          = row[5] ? static_cast<uint8_t>(strtoul(row[5], nullptr, 10)) : 255;
+			e.manacost          = row[6] ? static_cast<int16_t>(atoi(row[6])) : -1;
+			e.recast_delay      = row[7] ? static_cast<int32_t>(atoi(row[7])) : -1;
+			e.priority          = row[8] ? static_cast<int16_t>(atoi(row[8])) : 0;
+			e.resist_adjust     = row[9] ? static_cast<int32_t>(atoi(row[9])) : 0;
+			e.min_hp            = row[10] ? static_cast<int16_t>(atoi(row[10])) : 0;
+			e.max_hp            = row[11] ? static_cast<int16_t>(atoi(row[11])) : 0;
 			e.bucket_name       = row[12] ? row[12] : "";
 			e.bucket_value      = row[13] ? row[13] : "";
-			e.bucket_comparison = static_cast<uint8_t>(strtoul(row[14], nullptr, 10));
+			e.bucket_comparison = row[14] ? static_cast<uint8_t>(strtoul(row[14], nullptr, 10)) : 0;

 			all_entries.push_back(e);
 		}
@@ -457,6 +458,90 @@ public:
 		return (results.Success() && results.begin()[0] ? strtoll(results.begin()[0], nullptr, 10) : 0);
 	}

+	static std::string BaseReplace()
+	{
+		return fmt::format(
+			"REPLACE INTO {} ({}) ",
+			TableName(),
+			ColumnsRaw()
+		);
+	}
+
+	static int ReplaceOne(
+		Database& db,
+		const BotSpellsEntries &e
+	)
+	{
+		std::vector<std::string> v;
+
+		v.push_back(std::to_string(e.id));
+		v.push_back(std::to_string(e.npc_spells_id));
+		v.push_back(std::to_string(e.spellid));
+		v.push_back(std::to_string(e.type));
+		v.push_back(std::to_string(e.minlevel));
+		v.push_back(std::to_string(e.maxlevel));
+		v.push_back(std::to_string(e.manacost));
+		v.push_back(std::to_string(e.recast_delay));
+		v.push_back(std::to_string(e.priority));
+		v.push_back(std::to_string(e.resist_adjust));
+		v.push_back(std::to_string(e.min_hp));
+		v.push_back(std::to_string(e.max_hp));
+		v.push_back("'" + Strings::Escape(e.bucket_name) + "'");
+		v.push_back("'" + Strings::Escape(e.bucket_value) + "'");
+		v.push_back(std::to_string(e.bucket_comparison));
+
+		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<BotSpellsEntries> &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.npc_spells_id));
+			v.push_back(std::to_string(e.spellid));
+			v.push_back(std::to_string(e.type));
+			v.push_back(std::to_string(e.minlevel));
+			v.push_back(std::to_string(e.maxlevel));
+			v.push_back(std::to_string(e.manacost));
+			v.push_back(std::to_string(e.recast_delay));
+			v.push_back(std::to_string(e.priority));
+			v.push_back(std::to_string(e.resist_adjust));
+			v.push_back(std::to_string(e.min_hp));
+			v.push_back(std::to_string(e.max_hp));
+			v.push_back("'" + Strings::Escape(e.bucket_name) + "'");
+			v.push_back("'" + Strings::Escape(e.bucket_value) + "'");
+			v.push_back(std::to_string(e.bucket_comparison));
+
+			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_SPELLS_ENTRIES_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_STANCES_REPOSITORY_H
@@ -108,8 +108,9 @@ public:
 	{
 		auto results = db.QueryDatabase(
 			fmt::format(
-				"{} WHERE id = {} LIMIT 1",
+				"{} WHERE {} = {} LIMIT 1",
 				BaseSelect(),
+				PrimaryKey(),
 				bot_stances_id
 			)
 		);
@@ -118,8 +119,8 @@ public:
 		if (results.RowCount() == 1) {
 			BotStances e{};

-			e.bot_id    = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.stance_id = static_cast<uint8_t>(strtoul(row[1], nullptr, 10));
+			e.bot_id    = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.stance_id = row[1] ? static_cast<uint8_t>(strtoul(row[1], nullptr, 10)) : 0;

 			return e;
 		}
@@ -242,8 +243,8 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			BotStances e{};

-			e.bot_id    = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.stance_id = static_cast<uint8_t>(strtoul(row[1], nullptr, 10));
+			e.bot_id    = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.stance_id = row[1] ? static_cast<uint8_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) {
 			BotStances e{};

-			e.bot_id    = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.stance_id = static_cast<uint8_t>(strtoul(row[1], nullptr, 10));
+			e.bot_id    = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.stance_id = row[1] ? static_cast<uint8_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 BotStances &e
+	)
+	{
+		std::vector<std::string> v;
+
+		v.push_back(std::to_string(e.bot_id));
+		v.push_back(std::to_string(e.stance_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<BotStances> &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.stance_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_STANCES_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_STARTING_ITEMS_REPOSITORY_H
@@ -16,7 +16,6 @@
 #include "../../strings.h"
 #include <ctime>

-
 class BaseBotStartingItemsRepository {
 public:
 	struct BotStartingItems {
@@ -25,6 +24,13 @@ public:
 		uint32_t    classes;
 		uint32_t    item_id;
 		uint8_t     item_charges;
+		uint32_t    augment_one;
+		uint32_t    augment_two;
+		uint32_t    augment_three;
+		uint32_t    augment_four;
+		uint32_t    augment_five;
+		uint32_t    augment_six;
+		uint8_t     min_status;
 		int32_t     slot_id;
 		int8_t      min_expansion;
 		int8_t      max_expansion;
@@ -45,6 +51,13 @@ public:
 			"classes",
 			"item_id",
 			"item_charges",
+			"augment_one",
+			"augment_two",
+			"augment_three",
+			"augment_four",
+			"augment_five",
+			"augment_six",
+			"min_status",
 			"slot_id",
 			"min_expansion",
 			"max_expansion",
@@ -61,6 +74,13 @@ public:
 			"classes",
 			"item_id",
 			"item_charges",
+			"augment_one",
+			"augment_two",
+			"augment_three",
+			"augment_four",
+			"augment_five",
+			"augment_six",
+			"min_status",
 			"slot_id",
 			"min_expansion",
 			"max_expansion",
@@ -111,6 +131,13 @@ public:
 		e.classes                = 0;
 		e.item_id                = 0;
 		e.item_charges           = 1;
+		e.augment_one            = 0;
+		e.augment_two            = 0;
+		e.augment_three          = 0;
+		e.augment_four           = 0;
+		e.augment_five           = 0;
+		e.augment_six            = 0;
+		e.min_status             = 0;
 		e.slot_id                = -1;
 		e.min_expansion          = -1;
 		e.max_expansion          = -1;
@@ -152,16 +179,23 @@ public:
 		if (results.RowCount() == 1) {
 			BotStartingItems e{};

-			e.id                     = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.races                  = static_cast<uint32_t>(strtoul(row[1], nullptr, 10));
-			e.classes                = static_cast<uint32_t>(strtoul(row[2], nullptr, 10));
-			e.item_id                = static_cast<uint32_t>(strtoul(row[3], nullptr, 10));
-			e.item_charges           = static_cast<uint8_t>(strtoul(row[4], nullptr, 10));
-			e.slot_id                = static_cast<int32_t>(atoi(row[5]));
-			e.min_expansion          = static_cast<int8_t>(atoi(row[6]));
-			e.max_expansion          = static_cast<int8_t>(atoi(row[7]));
-			e.content_flags          = row[8] ? row[8] : "";
-			e.content_flags_disabled = row[9] ? row[9] : "";
+			e.id                     = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.races                  = row[1] ? static_cast<uint32_t>(strtoul(row[1], nullptr, 10)) : 0;
+			e.classes                = 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.item_charges           = row[4] ? static_cast<uint8_t>(strtoul(row[4], nullptr, 10)) : 1;
+			e.augment_one            = row[5] ? static_cast<uint32_t>(strtoul(row[5], nullptr, 10)) : 0;
+			e.augment_two            = row[6] ? static_cast<uint32_t>(strtoul(row[6], nullptr, 10)) : 0;
+			e.augment_three          = row[7] ? static_cast<uint32_t>(strtoul(row[7], nullptr, 10)) : 0;
+			e.augment_four           = row[8] ? static_cast<uint32_t>(strtoul(row[8], nullptr, 10)) : 0;
+			e.augment_five           = row[9] ? static_cast<uint32_t>(strtoul(row[9], nullptr, 10)) : 0;
+			e.augment_six            = row[10] ? static_cast<uint32_t>(strtoul(row[10], nullptr, 10)) : 0;
+			e.min_status             = row[11] ? static_cast<uint8_t>(strtoul(row[11], nullptr, 10)) : 0;
+			e.slot_id                = row[12] ? static_cast<int32_t>(atoi(row[12])) : -1;
+			e.min_expansion          = row[13] ? static_cast<int8_t>(atoi(row[13])) : -1;
+			e.max_expansion          = row[14] ? static_cast<int8_t>(atoi(row[14])) : -1;
+			e.content_flags          = row[15] ? row[15] : "";
+			e.content_flags_disabled = row[16] ? row[16] : "";

 			return e;
 		}
@@ -199,11 +233,18 @@ public:
 		v.push_back(columns[2] + " = " + std::to_string(e.classes));
 		v.push_back(columns[3] + " = " + std::to_string(e.item_id));
 		v.push_back(columns[4] + " = " + std::to_string(e.item_charges));
-		v.push_back(columns[5] + " = " + std::to_string(e.slot_id));
-		v.push_back(columns[6] + " = " + std::to_string(e.min_expansion));
-		v.push_back(columns[7] + " = " + std::to_string(e.max_expansion));
-		v.push_back(columns[8] + " = '" + Strings::Escape(e.content_flags) + "'");
-		v.push_back(columns[9] + " = '" + Strings::Escape(e.content_flags_disabled) + "'");
+		v.push_back(columns[5] + " = " + std::to_string(e.augment_one));
+		v.push_back(columns[6] + " = " + std::to_string(e.augment_two));
+		v.push_back(columns[7] + " = " + std::to_string(e.augment_three));
+		v.push_back(columns[8] + " = " + std::to_string(e.augment_four));
+		v.push_back(columns[9] + " = " + std::to_string(e.augment_five));
+		v.push_back(columns[10] + " = " + std::to_string(e.augment_six));
+		v.push_back(columns[11] + " = " + std::to_string(e.min_status));
+		v.push_back(columns[12] + " = " + std::to_string(e.slot_id));
+		v.push_back(columns[13] + " = " + std::to_string(e.min_expansion));
+		v.push_back(columns[14] + " = " + std::to_string(e.max_expansion));
+		v.push_back(columns[15] + " = '" + Strings::Escape(e.content_flags) + "'");
+		v.push_back(columns[16] + " = '" + Strings::Escape(e.content_flags_disabled) + "'");

 		auto results = db.QueryDatabase(
 			fmt::format(
@@ -230,6 +271,13 @@ public:
 		v.push_back(std::to_string(e.classes));
 		v.push_back(std::to_string(e.item_id));
 		v.push_back(std::to_string(e.item_charges));
+		v.push_back(std::to_string(e.augment_one));
+		v.push_back(std::to_string(e.augment_two));
+		v.push_back(std::to_string(e.augment_three));
+		v.push_back(std::to_string(e.augment_four));
+		v.push_back(std::to_string(e.augment_five));
+		v.push_back(std::to_string(e.augment_six));
+		v.push_back(std::to_string(e.min_status));
 		v.push_back(std::to_string(e.slot_id));
 		v.push_back(std::to_string(e.min_expansion));
 		v.push_back(std::to_string(e.max_expansion));
@@ -269,6 +317,13 @@ public:
 			v.push_back(std::to_string(e.classes));
 			v.push_back(std::to_string(e.item_id));
 			v.push_back(std::to_string(e.item_charges));
+			v.push_back(std::to_string(e.augment_one));
+			v.push_back(std::to_string(e.augment_two));
+			v.push_back(std::to_string(e.augment_three));
+			v.push_back(std::to_string(e.augment_four));
+			v.push_back(std::to_string(e.augment_five));
+			v.push_back(std::to_string(e.augment_six));
+			v.push_back(std::to_string(e.min_status));
 			v.push_back(std::to_string(e.slot_id));
 			v.push_back(std::to_string(e.min_expansion));
 			v.push_back(std::to_string(e.max_expansion));
@@ -307,16 +362,23 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			BotStartingItems e{};

-			e.id                     = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.races                  = static_cast<uint32_t>(strtoul(row[1], nullptr, 10));
-			e.classes                = static_cast<uint32_t>(strtoul(row[2], nullptr, 10));
-			e.item_id                = static_cast<uint32_t>(strtoul(row[3], nullptr, 10));
-			e.item_charges           = static_cast<uint8_t>(strtoul(row[4], nullptr, 10));
-			e.slot_id                = static_cast<int32_t>(atoi(row[5]));
-			e.min_expansion          = static_cast<int8_t>(atoi(row[6]));
-			e.max_expansion          = static_cast<int8_t>(atoi(row[7]));
-			e.content_flags          = row[8] ? row[8] : "";
-			e.content_flags_disabled = row[9] ? row[9] : "";
+			e.id                     = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.races                  = row[1] ? static_cast<uint32_t>(strtoul(row[1], nullptr, 10)) : 0;
+			e.classes                = 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.item_charges           = row[4] ? static_cast<uint8_t>(strtoul(row[4], nullptr, 10)) : 1;
+			e.augment_one            = row[5] ? static_cast<uint32_t>(strtoul(row[5], nullptr, 10)) : 0;
+			e.augment_two            = row[6] ? static_cast<uint32_t>(strtoul(row[6], nullptr, 10)) : 0;
+			e.augment_three          = row[7] ? static_cast<uint32_t>(strtoul(row[7], nullptr, 10)) : 0;
+			e.augment_four           = row[8] ? static_cast<uint32_t>(strtoul(row[8], nullptr, 10)) : 0;
+			e.augment_five           = row[9] ? static_cast<uint32_t>(strtoul(row[9], nullptr, 10)) : 0;
+			e.augment_six            = row[10] ? static_cast<uint32_t>(strtoul(row[10], nullptr, 10)) : 0;
+			e.min_status             = row[11] ? static_cast<uint8_t>(strtoul(row[11], nullptr, 10)) : 0;
+			e.slot_id                = row[12] ? static_cast<int32_t>(atoi(row[12])) : -1;
+			e.min_expansion          = row[13] ? static_cast<int8_t>(atoi(row[13])) : -1;
+			e.max_expansion          = row[14] ? static_cast<int8_t>(atoi(row[14])) : -1;
+			e.content_flags          = row[15] ? row[15] : "";
+			e.content_flags_disabled = row[16] ? row[16] : "";

 			all_entries.push_back(e);
 		}
@@ -341,16 +403,23 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			BotStartingItems e{};

-			e.id                     = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.races                  = static_cast<uint32_t>(strtoul(row[1], nullptr, 10));
-			e.classes                = static_cast<uint32_t>(strtoul(row[2], nullptr, 10));
-			e.item_id                = static_cast<uint32_t>(strtoul(row[3], nullptr, 10));
-			e.item_charges           = static_cast<uint8_t>(strtoul(row[4], nullptr, 10));
-			e.slot_id                = static_cast<int32_t>(atoi(row[5]));
-			e.min_expansion          = static_cast<int8_t>(atoi(row[6]));
-			e.max_expansion          = static_cast<int8_t>(atoi(row[7]));
-			e.content_flags          = row[8] ? row[8] : "";
-			e.content_flags_disabled = row[9] ? row[9] : "";
+			e.id                     = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.races                  = row[1] ? static_cast<uint32_t>(strtoul(row[1], nullptr, 10)) : 0;
+			e.classes                = 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.item_charges           = row[4] ? static_cast<uint8_t>(strtoul(row[4], nullptr, 10)) : 1;
+			e.augment_one            = row[5] ? static_cast<uint32_t>(strtoul(row[5], nullptr, 10)) : 0;
+			e.augment_two            = row[6] ? static_cast<uint32_t>(strtoul(row[6], nullptr, 10)) : 0;
+			e.augment_three          = row[7] ? static_cast<uint32_t>(strtoul(row[7], nullptr, 10)) : 0;
+			e.augment_four           = row[8] ? static_cast<uint32_t>(strtoul(row[8], nullptr, 10)) : 0;
+			e.augment_five           = row[9] ? static_cast<uint32_t>(strtoul(row[9], nullptr, 10)) : 0;
+			e.augment_six            = row[10] ? static_cast<uint32_t>(strtoul(row[10], nullptr, 10)) : 0;
+			e.min_status             = row[11] ? static_cast<uint8_t>(strtoul(row[11], nullptr, 10)) : 0;
+			e.slot_id                = row[12] ? static_cast<int32_t>(atoi(row[12])) : -1;
+			e.min_expansion          = row[13] ? static_cast<int8_t>(atoi(row[13])) : -1;
+			e.max_expansion          = row[14] ? static_cast<int8_t>(atoi(row[14])) : -1;
+			e.content_flags          = row[15] ? row[15] : "";
+			e.content_flags_disabled = row[16] ? row[16] : "";

 			all_entries.push_back(e);
 		}
@@ -409,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 BotStartingItems &e
+	)
+	{
+		std::vector<std::string> v;
+
+		v.push_back(std::to_string(e.id));
+		v.push_back(std::to_string(e.races));
+		v.push_back(std::to_string(e.classes));
+		v.push_back(std::to_string(e.item_id));
+		v.push_back(std::to_string(e.item_charges));
+		v.push_back(std::to_string(e.augment_one));
+		v.push_back(std::to_string(e.augment_two));
+		v.push_back(std::to_string(e.augment_three));
+		v.push_back(std::to_string(e.augment_four));
+		v.push_back(std::to_string(e.augment_five));
+		v.push_back(std::to_string(e.augment_six));
+		v.push_back(std::to_string(e.min_status));
+		v.push_back(std::to_string(e.slot_id));
+		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<BotStartingItems> &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.races));
+			v.push_back(std::to_string(e.classes));
+			v.push_back(std::to_string(e.item_id));
+			v.push_back(std::to_string(e.item_charges));
+			v.push_back(std::to_string(e.augment_one));
+			v.push_back(std::to_string(e.augment_two));
+			v.push_back(std::to_string(e.augment_three));
+			v.push_back(std::to_string(e.augment_four));
+			v.push_back(std::to_string(e.augment_five));
+			v.push_back(std::to_string(e.augment_six));
+			v.push_back(std::to_string(e.min_status));
+			v.push_back(std::to_string(e.slot_id));
+			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_BOT_STARTING_ITEMS_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_TIMERS_REPOSITORY_H
@@ -16,7 +16,6 @@
 #include "../../strings.h"
 #include <ctime>

-
 class BaseBotTimersRepository {
 public:
 	struct BotTimers {
@@ -148,15 +147,15 @@ public:
 		if (results.RowCount() == 1) {
 			BotTimers e{};

-			e.bot_id      = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.timer_id    = static_cast<uint32_t>(strtoul(row[1], nullptr, 10));
-			e.timer_value = static_cast<uint32_t>(strtoul(row[2], nullptr, 10));
-			e.recast_time = static_cast<uint32_t>(strtoul(row[3], nullptr, 10));
-			e.is_spell    = static_cast<uint8_t>(strtoul(row[4], nullptr, 10));
-			e.is_disc     = static_cast<uint8_t>(strtoul(row[5], nullptr, 10));
-			e.spell_id    = static_cast<uint32_t>(strtoul(row[6], nullptr, 10));
-			e.is_item     = static_cast<uint8_t>(strtoul(row[7], nullptr, 10));
-			e.item_id     = static_cast<uint32_t>(strtoul(row[8], nullptr, 10));
+			e.bot_id      = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.timer_id    = row[1] ? static_cast<uint32_t>(strtoul(row[1], nullptr, 10)) : 0;
+			e.timer_value = row[2] ? static_cast<uint32_t>(strtoul(row[2], nullptr, 10)) : 0;
+			e.recast_time = row[3] ? static_cast<uint32_t>(strtoul(row[3], nullptr, 10)) : 0;
+			e.is_spell    = row[4] ? static_cast<uint8_t>(strtoul(row[4], nullptr, 10)) : 0;
+			e.is_disc     = row[5] ? static_cast<uint8_t>(strtoul(row[5], nullptr, 10)) : 0;
+			e.spell_id    = row[6] ? static_cast<uint32_t>(strtoul(row[6], nullptr, 10)) : 0;
+			e.is_item     = row[7] ? static_cast<uint8_t>(strtoul(row[7], nullptr, 10)) : 0;
+			e.item_id     = row[8] ? static_cast<uint32_t>(strtoul(row[8], nullptr, 10)) : 0;

 			return e;
 		}
@@ -300,15 +299,15 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			BotTimers e{};

-			e.bot_id      = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.timer_id    = static_cast<uint32_t>(strtoul(row[1], nullptr, 10));
-			e.timer_value = static_cast<uint32_t>(strtoul(row[2], nullptr, 10));
-			e.recast_time = static_cast<uint32_t>(strtoul(row[3], nullptr, 10));
-			e.is_spell    = static_cast<uint8_t>(strtoul(row[4], nullptr, 10));
-			e.is_disc     = static_cast<uint8_t>(strtoul(row[5], nullptr, 10));
-			e.spell_id    = static_cast<uint32_t>(strtoul(row[6], nullptr, 10));
-			e.is_item     = static_cast<uint8_t>(strtoul(row[7], nullptr, 10));
-			e.item_id     = static_cast<uint32_t>(strtoul(row[8], nullptr, 10));
+			e.bot_id      = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.timer_id    = row[1] ? static_cast<uint32_t>(strtoul(row[1], nullptr, 10)) : 0;
+			e.timer_value = row[2] ? static_cast<uint32_t>(strtoul(row[2], nullptr, 10)) : 0;
+			e.recast_time = row[3] ? static_cast<uint32_t>(strtoul(row[3], nullptr, 10)) : 0;
+			e.is_spell    = row[4] ? static_cast<uint8_t>(strtoul(row[4], nullptr, 10)) : 0;
+			e.is_disc     = row[5] ? static_cast<uint8_t>(strtoul(row[5], nullptr, 10)) : 0;
+			e.spell_id    = row[6] ? static_cast<uint32_t>(strtoul(row[6], nullptr, 10)) : 0;
+			e.is_item     = row[7] ? static_cast<uint8_t>(strtoul(row[7], nullptr, 10)) : 0;
+			e.item_id     = row[8] ? static_cast<uint32_t>(strtoul(row[8], nullptr, 10)) : 0;

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

-			e.bot_id      = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.timer_id    = static_cast<uint32_t>(strtoul(row[1], nullptr, 10));
-			e.timer_value = static_cast<uint32_t>(strtoul(row[2], nullptr, 10));
-			e.recast_time = static_cast<uint32_t>(strtoul(row[3], nullptr, 10));
-			e.is_spell    = static_cast<uint8_t>(strtoul(row[4], nullptr, 10));
-			e.is_disc     = static_cast<uint8_t>(strtoul(row[5], nullptr, 10));
-			e.spell_id    = static_cast<uint32_t>(strtoul(row[6], nullptr, 10));
-			e.is_item     = static_cast<uint8_t>(strtoul(row[7], nullptr, 10));
-			e.item_id     = static_cast<uint32_t>(strtoul(row[8], nullptr, 10));
+			e.bot_id      = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.timer_id    = row[1] ? static_cast<uint32_t>(strtoul(row[1], nullptr, 10)) : 0;
+			e.timer_value = row[2] ? static_cast<uint32_t>(strtoul(row[2], nullptr, 10)) : 0;
+			e.recast_time = row[3] ? static_cast<uint32_t>(strtoul(row[3], nullptr, 10)) : 0;
+			e.is_spell    = row[4] ? static_cast<uint8_t>(strtoul(row[4], nullptr, 10)) : 0;
+			e.is_disc     = row[5] ? static_cast<uint8_t>(strtoul(row[5], nullptr, 10)) : 0;
+			e.spell_id    = row[6] ? static_cast<uint32_t>(strtoul(row[6], nullptr, 10)) : 0;
+			e.is_item     = row[7] ? static_cast<uint8_t>(strtoul(row[7], nullptr, 10)) : 0;
+			e.item_id     = row[8] ? static_cast<uint32_t>(strtoul(row[8], nullptr, 10)) : 0;

 			all_entries.push_back(e);
 		}
@@ -400,6 +399,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 BotTimers &e
+	)
+	{
+		std::vector<std::string> v;
+
+		v.push_back(std::to_string(e.bot_id));
+		v.push_back(std::to_string(e.timer_id));
+		v.push_back(std::to_string(e.timer_value));
+		v.push_back(std::to_string(e.recast_time));
+		v.push_back(std::to_string(e.is_spell));
+		v.push_back(std::to_string(e.is_disc));
+		v.push_back(std::to_string(e.spell_id));
+		v.push_back(std::to_string(e.is_item));
+		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<BotTimers> &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.timer_id));
+			v.push_back(std::to_string(e.timer_value));
+			v.push_back(std::to_string(e.recast_time));
+			v.push_back(std::to_string(e.is_spell));
+			v.push_back(std::to_string(e.is_disc));
+			v.push_back(std::to_string(e.spell_id));
+			v.push_back(std::to_string(e.is_item));
+			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_BOT_TIMERS_REPOSITORY_H
@@ -66,6 +66,10 @@ public:
 		uint32_t    wc_7;
 		uint32_t    wc_8;
 		uint32_t    wc_9;
+		uint32_t    rez_time;
+		uint32_t    gm_exp;
+		uint32_t    killed_by;
+		uint8_t     rezzable;
 	};

 	static std::string PrimaryKey()
@@ -123,6 +127,10 @@ public:
 			"wc_7",
 			"wc_8",
 			"wc_9",
+			"rez_time",
+			"gm_exp",
+			"killed_by",
+			"rezzable",
 		};
 	}

@@ -176,6 +184,10 @@ public:
 			"wc_7",
 			"wc_8",
 			"wc_9",
+			"rez_time",
+			"gm_exp",
+			"killed_by",
+			"rezzable",
 		};
 	}

@@ -225,7 +237,7 @@ public:
 		e.y                = 0;
 		e.z                = 0;
 		e.heading          = 0;
-		e.time_of_death    = 0;
+		e.time_of_death    = std::time(nullptr);
 		e.guild_consent_id = 0;
 		e.is_rezzed        = 0;
 		e.is_buried        = 0;
@@ -263,6 +275,10 @@ public:
 		e.wc_7             = 0;
 		e.wc_8             = 0;
 		e.wc_9             = 0;
+		e.rez_time         = 0;
+		e.gm_exp           = 0;
+		e.killed_by        = 0;
+		e.rezzable         = 0;

 		return e;
 	}
@@ -346,6 +362,10 @@ public:
 			e.wc_7             = row[44] ? static_cast<uint32_t>(strtoul(row[44], nullptr, 10)) : 0;
 			e.wc_8             = row[45] ? static_cast<uint32_t>(strtoul(row[45], nullptr, 10)) : 0;
 			e.wc_9             = row[46] ? static_cast<uint32_t>(strtoul(row[46], nullptr, 10)) : 0;
+			e.rez_time         = row[47] ? static_cast<uint32_t>(strtoul(row[47], nullptr, 10)) : 0;
+			e.gm_exp           = row[48] ? static_cast<uint32_t>(strtoul(row[48], nullptr, 10)) : 0;
+			e.killed_by        = row[49] ? static_cast<uint32_t>(strtoul(row[49], nullptr, 10)) : 0;
+			e.rezzable         = row[50] ? static_cast<uint8_t>(strtoul(row[50], nullptr, 10)) : 0;

 			return e;
 		}
@@ -425,6 +445,10 @@ public:
 		v.push_back(columns[44] + " = " + std::to_string(e.wc_7));
 		v.push_back(columns[45] + " = " + std::to_string(e.wc_8));
 		v.push_back(columns[46] + " = " + std::to_string(e.wc_9));
+		v.push_back(columns[47] + " = " + std::to_string(e.rez_time));
+		v.push_back(columns[48] + " = " + std::to_string(e.gm_exp));
+		v.push_back(columns[49] + " = " + std::to_string(e.killed_by));
+		v.push_back(columns[50] + " = " + std::to_string(e.rezzable));

 		auto results = db.QueryDatabase(
 			fmt::format(
@@ -493,6 +517,10 @@ public:
 		v.push_back(std::to_string(e.wc_7));
 		v.push_back(std::to_string(e.wc_8));
 		v.push_back(std::to_string(e.wc_9));
+		v.push_back(std::to_string(e.rez_time));
+		v.push_back(std::to_string(e.gm_exp));
+		v.push_back(std::to_string(e.killed_by));
+		v.push_back(std::to_string(e.rezzable));

 		auto results = db.QueryDatabase(
 			fmt::format(
@@ -569,6 +597,10 @@ public:
 			v.push_back(std::to_string(e.wc_7));
 			v.push_back(std::to_string(e.wc_8));
 			v.push_back(std::to_string(e.wc_9));
+			v.push_back(std::to_string(e.rez_time));
+			v.push_back(std::to_string(e.gm_exp));
+			v.push_back(std::to_string(e.killed_by));
+			v.push_back(std::to_string(e.rezzable));

 			insert_chunks.push_back("(" + Strings::Implode(",", v) + ")");
 		}
@@ -649,6 +681,10 @@ public:
 			e.wc_7             = row[44] ? static_cast<uint32_t>(strtoul(row[44], nullptr, 10)) : 0;
 			e.wc_8             = row[45] ? static_cast<uint32_t>(strtoul(row[45], nullptr, 10)) : 0;
 			e.wc_9             = row[46] ? static_cast<uint32_t>(strtoul(row[46], nullptr, 10)) : 0;
+			e.rez_time         = row[47] ? static_cast<uint32_t>(strtoul(row[47], nullptr, 10)) : 0;
+			e.gm_exp           = row[48] ? static_cast<uint32_t>(strtoul(row[48], nullptr, 10)) : 0;
+			e.killed_by        = row[49] ? static_cast<uint32_t>(strtoul(row[49], nullptr, 10)) : 0;
+			e.rezzable         = row[50] ? static_cast<uint8_t>(strtoul(row[50], nullptr, 10)) : 0;

 			all_entries.push_back(e);
 		}
@@ -720,6 +756,10 @@ public:
 			e.wc_7             = row[44] ? static_cast<uint32_t>(strtoul(row[44], nullptr, 10)) : 0;
 			e.wc_8             = row[45] ? static_cast<uint32_t>(strtoul(row[45], nullptr, 10)) : 0;
 			e.wc_9             = row[46] ? static_cast<uint32_t>(strtoul(row[46], nullptr, 10)) : 0;
+			e.rez_time         = row[47] ? static_cast<uint32_t>(strtoul(row[47], nullptr, 10)) : 0;
+			e.gm_exp           = row[48] ? static_cast<uint32_t>(strtoul(row[48], nullptr, 10)) : 0;
+			e.killed_by        = row[49] ? static_cast<uint32_t>(strtoul(row[49], nullptr, 10)) : 0;
+			e.rezzable         = row[50] ? static_cast<uint8_t>(strtoul(row[50], nullptr, 10)) : 0;

 			all_entries.push_back(e);
 		}
@@ -841,6 +881,10 @@ public:
 		v.push_back(std::to_string(e.wc_7));
 		v.push_back(std::to_string(e.wc_8));
 		v.push_back(std::to_string(e.wc_9));
+		v.push_back(std::to_string(e.rez_time));
+		v.push_back(std::to_string(e.gm_exp));
+		v.push_back(std::to_string(e.killed_by));
+		v.push_back(std::to_string(e.rezzable));

 		auto results = db.QueryDatabase(
 			fmt::format(
@@ -910,6 +954,10 @@ public:
 			v.push_back(std::to_string(e.wc_7));
 			v.push_back(std::to_string(e.wc_8));
 			v.push_back(std::to_string(e.wc_9));
+			v.push_back(std::to_string(e.rez_time));
+			v.push_back(std::to_string(e.gm_exp));
+			v.push_back(std::to_string(e.killed_by));
+			v.push_back(std::to_string(e.rezzable));

 			insert_chunks.push_back("(" + Strings::Implode(",", v) + ")");
 		}
@@ -21,7 +21,7 @@ public:
 	struct CharacterLeadershipAbilities {
 		uint32_t id;
 		uint16_t slot;
-		uint16_t rank;
+		uint16_t rank_;
 	};

 	static std::string PrimaryKey()
@@ -34,7 +34,7 @@ public:
 		return {
 			"id",
 			"slot",
-			"rank",
+			"`rank`",
 		};
 	}

@@ -43,7 +43,7 @@ public:
 		return {
 			"id",
 			"slot",
-			"rank",
+			"`rank`",
 		};
 	}

@@ -84,9 +84,9 @@ public:
 	{
 		CharacterLeadershipAbilities e{};

-		e.id   = 0;
-		e.slot = 0;
-		e.rank = 0;
+		e.id    = 0;
+		e.slot  = 0;
+		e.rank_ = 0;

 		return e;
 	}
@@ -123,9 +123,9 @@ public:
 		if (results.RowCount() == 1) {
 			CharacterLeadershipAbilities e{};

-			e.id   = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
-			e.slot = row[1] ? static_cast<uint16_t>(strtoul(row[1], nullptr, 10)) : 0;
-			e.rank = row[2] ? static_cast<uint16_t>(strtoul(row[2], nullptr, 10)) : 0;
+			e.id    = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.slot  = row[1] ? static_cast<uint16_t>(strtoul(row[1], nullptr, 10)) : 0;
+			e.rank_ = row[2] ? static_cast<uint16_t>(strtoul(row[2], nullptr, 10)) : 0;

 			return e;
 		}
@@ -161,7 +161,7 @@ public:

 		v.push_back(columns[0] + " = " + std::to_string(e.id));
 		v.push_back(columns[1] + " = " + std::to_string(e.slot));
-		v.push_back(columns[2] + " = " + std::to_string(e.rank));
+		v.push_back(columns[2] + " = " + std::to_string(e.rank_));

 		auto results = db.QueryDatabase(
 			fmt::format(
@@ -185,7 +185,7 @@ public:

 		v.push_back(std::to_string(e.id));
 		v.push_back(std::to_string(e.slot));
-		v.push_back(std::to_string(e.rank));
+		v.push_back(std::to_string(e.rank_));

 		auto results = db.QueryDatabase(
 			fmt::format(
@@ -217,7 +217,7 @@ public:

 			v.push_back(std::to_string(e.id));
 			v.push_back(std::to_string(e.slot));
-			v.push_back(std::to_string(e.rank));
+			v.push_back(std::to_string(e.rank_));

 			insert_chunks.push_back("(" + Strings::Implode(",", v) + ")");
 		}
@@ -251,9 +251,9 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			CharacterLeadershipAbilities e{};

-			e.id   = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
-			e.slot = row[1] ? static_cast<uint16_t>(strtoul(row[1], nullptr, 10)) : 0;
-			e.rank = row[2] ? static_cast<uint16_t>(strtoul(row[2], nullptr, 10)) : 0;
+			e.id    = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.slot  = row[1] ? static_cast<uint16_t>(strtoul(row[1], nullptr, 10)) : 0;
+			e.rank_ = row[2] ? static_cast<uint16_t>(strtoul(row[2], nullptr, 10)) : 0;

 			all_entries.push_back(e);
 		}
@@ -278,9 +278,9 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			CharacterLeadershipAbilities e{};

-			e.id   = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
-			e.slot = row[1] ? static_cast<uint16_t>(strtoul(row[1], nullptr, 10)) : 0;
-			e.rank = row[2] ? static_cast<uint16_t>(strtoul(row[2], nullptr, 10)) : 0;
+			e.id    = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.slot  = row[1] ? static_cast<uint16_t>(strtoul(row[1], nullptr, 10)) : 0;
+			e.rank_ = row[2] ? static_cast<uint16_t>(strtoul(row[2], nullptr, 10)) : 0;

 			all_entries.push_back(e);
 		}
@@ -357,7 +357,7 @@ public:

 		v.push_back(std::to_string(e.id));
 		v.push_back(std::to_string(e.slot));
-		v.push_back(std::to_string(e.rank));
+		v.push_back(std::to_string(e.rank_));

 		auto results = db.QueryDatabase(
 			fmt::format(
@@ -382,7 +382,7 @@ public:

 			v.push_back(std::to_string(e.id));
 			v.push_back(std::to_string(e.slot));
-			v.push_back(std::to_string(e.rank));
+			v.push_back(std::to_string(e.rank_));

 			insert_chunks.push_back("(" + Strings::Implode(",", v) + ")");
 		}
@@ -33,6 +33,7 @@ public:
 		uint32_t    max_allowed;
 		std::string comment;
 		uint32_t    respawn_timer;
+		uint8_t     fix_z;
 		int8_t      min_expansion;
 		int8_t      max_expansion;
 		std::string content_flags;
@@ -61,6 +62,7 @@ public:
 			"max_allowed",
 			"comment",
 			"respawn_timer",
+			"fix_z",
 			"min_expansion",
 			"max_expansion",
 			"content_flags",
@@ -85,6 +87,7 @@ public:
 			"max_allowed",
 			"comment",
 			"respawn_timer",
+			"fix_z",
 			"min_expansion",
 			"max_expansion",
 			"content_flags",
@@ -143,6 +146,7 @@ public:
 		e.max_allowed            = 1;
 		e.comment                = "";
 		e.respawn_timer          = 300;
+		e.fix_z                  = 1;
 		e.min_expansion          = -1;
 		e.max_expansion          = -1;
 		e.content_flags          = "";
@@ -197,10 +201,11 @@ public:
 			e.max_allowed            = row[11] ? static_cast<uint32_t>(strtoul(row[11], nullptr, 10)) : 1;
 			e.comment                = row[12] ? row[12] : "";
 			e.respawn_timer          = row[13] ? static_cast<uint32_t>(strtoul(row[13], nullptr, 10)) : 300;
-			e.min_expansion          = row[14] ? static_cast<int8_t>(atoi(row[14])) : -1;
-			e.max_expansion          = row[15] ? static_cast<int8_t>(atoi(row[15])) : -1;
-			e.content_flags          = row[16] ? row[16] : "";
-			e.content_flags_disabled = row[17] ? row[17] : "";
+			e.fix_z                  = row[14] ? static_cast<uint8_t>(strtoul(row[14], nullptr, 10)) : 1;
+			e.min_expansion          = row[15] ? static_cast<int8_t>(atoi(row[15])) : -1;
+			e.max_expansion          = row[16] ? static_cast<int8_t>(atoi(row[16])) : -1;
+			e.content_flags          = row[17] ? row[17] : "";
+			e.content_flags_disabled = row[18] ? row[18] : "";

 			return e;
 		}
@@ -247,10 +252,11 @@ public:
 		v.push_back(columns[11] + " = " + std::to_string(e.max_allowed));
 		v.push_back(columns[12] + " = '" + Strings::Escape(e.comment) + "'");
 		v.push_back(columns[13] + " = " + std::to_string(e.respawn_timer));
-		v.push_back(columns[14] + " = " + std::to_string(e.min_expansion));
-		v.push_back(columns[15] + " = " + std::to_string(e.max_expansion));
-		v.push_back(columns[16] + " = '" + Strings::Escape(e.content_flags) + "'");
-		v.push_back(columns[17] + " = '" + Strings::Escape(e.content_flags_disabled) + "'");
+		v.push_back(columns[14] + " = " + std::to_string(e.fix_z));
+		v.push_back(columns[15] + " = " + std::to_string(e.min_expansion));
+		v.push_back(columns[16] + " = " + std::to_string(e.max_expansion));
+		v.push_back(columns[17] + " = '" + Strings::Escape(e.content_flags) + "'");
+		v.push_back(columns[18] + " = '" + Strings::Escape(e.content_flags_disabled) + "'");

 		auto results = db.QueryDatabase(
 			fmt::format(
@@ -286,6 +292,7 @@ public:
 		v.push_back(std::to_string(e.max_allowed));
 		v.push_back("'" + Strings::Escape(e.comment) + "'");
 		v.push_back(std::to_string(e.respawn_timer));
+		v.push_back(std::to_string(e.fix_z));
 		v.push_back(std::to_string(e.min_expansion));
 		v.push_back(std::to_string(e.max_expansion));
 		v.push_back("'" + Strings::Escape(e.content_flags) + "'");
@@ -333,6 +340,7 @@ public:
 			v.push_back(std::to_string(e.max_allowed));
 			v.push_back("'" + Strings::Escape(e.comment) + "'");
 			v.push_back(std::to_string(e.respawn_timer));
+			v.push_back(std::to_string(e.fix_z));
 			v.push_back(std::to_string(e.min_expansion));
 			v.push_back(std::to_string(e.max_expansion));
 			v.push_back("'" + Strings::Escape(e.content_flags) + "'");
@@ -384,10 +392,11 @@ public:
 			e.max_allowed            = row[11] ? static_cast<uint32_t>(strtoul(row[11], nullptr, 10)) : 1;
 			e.comment                = row[12] ? row[12] : "";
 			e.respawn_timer          = row[13] ? static_cast<uint32_t>(strtoul(row[13], nullptr, 10)) : 300;
-			e.min_expansion          = row[14] ? static_cast<int8_t>(atoi(row[14])) : -1;
-			e.max_expansion          = row[15] ? static_cast<int8_t>(atoi(row[15])) : -1;
-			e.content_flags          = row[16] ? row[16] : "";
-			e.content_flags_disabled = row[17] ? row[17] : "";
+			e.fix_z                  = row[14] ? static_cast<uint8_t>(strtoul(row[14], nullptr, 10)) : 1;
+			e.min_expansion          = row[15] ? static_cast<int8_t>(atoi(row[15])) : -1;
+			e.max_expansion          = row[16] ? static_cast<int8_t>(atoi(row[16])) : -1;
+			e.content_flags          = row[17] ? row[17] : "";
+			e.content_flags_disabled = row[18] ? row[18] : "";

 			all_entries.push_back(e);
 		}
@@ -426,10 +435,11 @@ public:
 			e.max_allowed            = row[11] ? static_cast<uint32_t>(strtoul(row[11], nullptr, 10)) : 1;
 			e.comment                = row[12] ? row[12] : "";
 			e.respawn_timer          = row[13] ? static_cast<uint32_t>(strtoul(row[13], nullptr, 10)) : 300;
-			e.min_expansion          = row[14] ? static_cast<int8_t>(atoi(row[14])) : -1;
-			e.max_expansion          = row[15] ? static_cast<int8_t>(atoi(row[15])) : -1;
-			e.content_flags          = row[16] ? row[16] : "";
-			e.content_flags_disabled = row[17] ? row[17] : "";
+			e.fix_z                  = row[14] ? static_cast<uint8_t>(strtoul(row[14], nullptr, 10)) : 1;
+			e.min_expansion          = row[15] ? static_cast<int8_t>(atoi(row[15])) : -1;
+			e.max_expansion          = row[16] ? static_cast<int8_t>(atoi(row[16])) : -1;
+			e.content_flags          = row[17] ? row[17] : "";
+			e.content_flags_disabled = row[18] ? row[18] : "";

 			all_entries.push_back(e);
 		}
@@ -518,6 +528,7 @@ public:
 		v.push_back(std::to_string(e.max_allowed));
 		v.push_back("'" + Strings::Escape(e.comment) + "'");
 		v.push_back(std::to_string(e.respawn_timer));
+		v.push_back(std::to_string(e.fix_z));
 		v.push_back(std::to_string(e.min_expansion));
 		v.push_back(std::to_string(e.max_expansion));
 		v.push_back("'" + Strings::Escape(e.content_flags) + "'");
@@ -558,6 +569,7 @@ public:
 			v.push_back(std::to_string(e.max_allowed));
 			v.push_back("'" + Strings::Escape(e.comment) + "'");
 			v.push_back(std::to_string(e.respawn_timer));
+			v.push_back(std::to_string(e.fix_z));
 			v.push_back(std::to_string(e.min_expansion));
 			v.push_back(std::to_string(e.max_expansion));
 			v.push_back("'" + Strings::Escape(e.content_flags) + "'");
@@ -0,0 +1,404 @@
+/**
+ * DO NOT MODIFY THIS FILE
+ *
+ * This repository was automatically generated and is NOT to be modified directly.
+ * Any repository modifications are meant to be made to the repository extending the base.
+ * Any modifications to base repositories are to be made by the generator only
+ *
+ * @generator ./utils/scripts/generators/repository-generator.pl
+ * @docs https://eqemu.gitbook.io/server/in-development/developer-area/repositories
+ */
+
+#ifndef EQEMU_BASE_GUILD_BANK_REPOSITORY_H
+#define EQEMU_BASE_GUILD_BANK_REPOSITORY_H
+
+#include "../../database.h"
+#include "../../strings.h"
+#include <ctime>
+
+
+class BaseGuildBankRepository {
+public:
+	struct GuildBank {
+		uint32_t    id;
+		uint32_t    guildid;
+		uint8_t     area;
+		uint32_t    slot;
+		uint32_t    itemid;
+		uint32_t    qty;
+		std::string donator;
+		uint8_t     permissions;
+		std::string whofor;
+	};
+
+	static std::string PrimaryKey()
+	{
+		return std::string("id");
+	}
+
+	static std::vector<std::string> Columns()
+	{
+		return {
+			"id",
+			"guildid",
+			"area",
+			"slot",
+			"itemid",
+			"qty",
+			"donator",
+			"permissions",
+			"whofor",
+		};
+	}
+
+	static std::vector<std::string> SelectColumns()
+	{
+		return {
+			"id",
+			"guildid",
+			"area",
+			"slot",
+			"itemid",
+			"qty",
+			"donator",
+			"permissions",
+			"whofor",
+		};
+	}
+
+	static std::string ColumnsRaw()
+	{
+		return std::string(Strings::Implode(", ", Columns()));
+	}
+
+	static std::string SelectColumnsRaw()
+	{
+		return std::string(Strings::Implode(", ", SelectColumns()));
+	}
+
+	static std::string TableName()
+	{
+		return std::string("guild_bank");
+	}
+
+	static std::string BaseSelect()
+	{
+		return fmt::format(
+			"SELECT {} FROM {}",
+			SelectColumnsRaw(),
+			TableName()
+		);
+	}
+
+	static std::string BaseInsert()
+	{
+		return fmt::format(
+			"INSERT INTO {} ({}) ",
+			TableName(),
+			ColumnsRaw()
+		);
+	}
+
+	static GuildBank NewEntity()
+	{
+		GuildBank e{};
+
+		e.id          = 0;
+		e.guildid     = 0;
+		e.area        = 0;
+		e.slot        = 0;
+		e.itemid      = 0;
+		e.qty         = 0;
+		e.donator     = "";
+		e.permissions = 0;
+		e.whofor      = "";
+
+		return e;
+	}
+
+	static GuildBank GetGuildBank(
+		const std::vector<GuildBank> &guild_banks,
+		int guild_bank_id
+	)
+	{
+		for (auto &guild_bank : guild_banks) {
+			if (guild_bank.id == guild_bank_id) {
+				return guild_bank;
+			}
+		}
+
+		return NewEntity();
+	}
+
+	static GuildBank FindOne(
+		Database& db,
+		int guild_bank_id
+	)
+	{
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"{} WHERE {} = {} LIMIT 1",
+				BaseSelect(),
+				PrimaryKey(),
+				guild_bank_id
+			)
+		);
+
+		auto row = results.begin();
+		if (results.RowCount() == 1) {
+			GuildBank e{};
+
+			e.id          = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
+			e.guildid     = static_cast<uint32_t>(strtoul(row[1], nullptr, 10));
+			e.area        = static_cast<uint8_t>(strtoul(row[2], nullptr, 10));
+			e.slot        = static_cast<uint32_t>(strtoul(row[3], nullptr, 10));
+			e.itemid      = static_cast<uint32_t>(strtoul(row[4], nullptr, 10));
+			e.qty         = static_cast<uint32_t>(strtoul(row[5], nullptr, 10));
+			e.donator     = row[6] ? row[6] : "";
+			e.permissions = static_cast<uint8_t>(strtoul(row[7], nullptr, 10));
+			e.whofor      = row[8] ? row[8] : "";
+
+			return e;
+		}
+
+		return NewEntity();
+	}
+
+	static int DeleteOne(
+		Database& db,
+		int guild_bank_id
+	)
+	{
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"DELETE FROM {} WHERE {} = {}",
+				TableName(),
+				PrimaryKey(),
+				guild_bank_id
+			)
+		);
+
+		return (results.Success() ? results.RowsAffected() : 0);
+	}
+
+	static int UpdateOne(
+		Database& db,
+		const GuildBank &e
+	)
+	{
+		std::vector<std::string> v;
+
+		auto columns = Columns();
+
+		v.push_back(columns[1] + " = " + std::to_string(e.guildid));
+		v.push_back(columns[2] + " = " + std::to_string(e.area));
+		v.push_back(columns[3] + " = " + std::to_string(e.slot));
+		v.push_back(columns[4] + " = " + std::to_string(e.itemid));
+		v.push_back(columns[5] + " = " + std::to_string(e.qty));
+		v.push_back(columns[6] + " = '" + Strings::Escape(e.donator) + "'");
+		v.push_back(columns[7] + " = " + std::to_string(e.permissions));
+		v.push_back(columns[8] + " = '" + Strings::Escape(e.whofor) + "'");
+
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"UPDATE {} SET {} WHERE {} = {}",
+				TableName(),
+				Strings::Implode(", ", v),
+				PrimaryKey(),
+				e.id
+			)
+		);
+
+		return (results.Success() ? results.RowsAffected() : 0);
+	}
+
+	static GuildBank InsertOne(
+		Database& db,
+		GuildBank e
+	)
+	{
+		std::vector<std::string> v;
+
+		v.push_back(std::to_string(e.id));
+		v.push_back(std::to_string(e.guildid));
+		v.push_back(std::to_string(e.area));
+		v.push_back(std::to_string(e.slot));
+		v.push_back(std::to_string(e.itemid));
+		v.push_back(std::to_string(e.qty));
+		v.push_back("'" + Strings::Escape(e.donator) + "'");
+		v.push_back(std::to_string(e.permissions));
+		v.push_back("'" + Strings::Escape(e.whofor) + "'");
+
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"{} VALUES ({})",
+				BaseInsert(),
+				Strings::Implode(",", v)
+			)
+		);
+
+		if (results.Success()) {
+			e.id = results.LastInsertedID();
+			return e;
+		}
+
+		e = NewEntity();
+
+		return e;
+	}
+
+	static int InsertMany(
+		Database& db,
+		const std::vector<GuildBank> &entries
+	)
+	{
+		std::vector<std::string> insert_chunks;
+
+		for (auto &e: entries) {
+			std::vector<std::string> v;
+
+			v.push_back(std::to_string(e.id));
+			v.push_back(std::to_string(e.guildid));
+			v.push_back(std::to_string(e.area));
+			v.push_back(std::to_string(e.slot));
+			v.push_back(std::to_string(e.itemid));
+			v.push_back(std::to_string(e.qty));
+			v.push_back("'" + Strings::Escape(e.donator) + "'");
+			v.push_back(std::to_string(e.permissions));
+			v.push_back("'" + Strings::Escape(e.whofor) + "'");
+
+			insert_chunks.push_back("(" + Strings::Implode(",", v) + ")");
+		}
+
+		std::vector<std::string> v;
+
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"{} VALUES {}",
+				BaseInsert(),
+				Strings::Implode(",", insert_chunks)
+			)
+		);
+
+		return (results.Success() ? results.RowsAffected() : 0);
+	}
+
+	static std::vector<GuildBank> All(Database& db)
+	{
+		std::vector<GuildBank> all_entries;
+
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"{}",
+				BaseSelect()
+			)
+		);
+
+		all_entries.reserve(results.RowCount());
+
+		for (auto row = results.begin(); row != results.end(); ++row) {
+			GuildBank e{};
+
+			e.id          = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
+			e.guildid     = static_cast<uint32_t>(strtoul(row[1], nullptr, 10));
+			e.area        = static_cast<uint8_t>(strtoul(row[2], nullptr, 10));
+			e.slot        = static_cast<uint32_t>(strtoul(row[3], nullptr, 10));
+			e.itemid      = static_cast<uint32_t>(strtoul(row[4], nullptr, 10));
+			e.qty         = static_cast<uint32_t>(strtoul(row[5], nullptr, 10));
+			e.donator     = row[6] ? row[6] : "";
+			e.permissions = static_cast<uint8_t>(strtoul(row[7], nullptr, 10));
+			e.whofor      = row[8] ? row[8] : "";
+
+			all_entries.push_back(e);
+		}
+
+		return all_entries;
+	}
+
+	static std::vector<GuildBank> GetWhere(Database& db, const std::string &where_filter)
+	{
+		std::vector<GuildBank> all_entries;
+
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"{} WHERE {}",
+				BaseSelect(),
+				where_filter
+			)
+		);
+
+		all_entries.reserve(results.RowCount());
+
+		for (auto row = results.begin(); row != results.end(); ++row) {
+			GuildBank e{};
+
+			e.id          = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
+			e.guildid     = static_cast<uint32_t>(strtoul(row[1], nullptr, 10));
+			e.area        = static_cast<uint8_t>(strtoul(row[2], nullptr, 10));
+			e.slot        = static_cast<uint32_t>(strtoul(row[3], nullptr, 10));
+			e.itemid      = static_cast<uint32_t>(strtoul(row[4], nullptr, 10));
+			e.qty         = static_cast<uint32_t>(strtoul(row[5], nullptr, 10));
+			e.donator     = row[6] ? row[6] : "";
+			e.permissions = static_cast<uint8_t>(strtoul(row[7], nullptr, 10));
+			e.whofor      = row[8] ? row[8] : "";
+
+			all_entries.push_back(e);
+		}
+
+		return all_entries;
+	}
+
+	static int DeleteWhere(Database& db, const std::string &where_filter)
+	{
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"DELETE FROM {} WHERE {}",
+				TableName(),
+				where_filter
+			)
+		);
+
+		return (results.Success() ? results.RowsAffected() : 0);
+	}
+
+	static int Truncate(Database& db)
+	{
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"TRUNCATE TABLE {}",
+				TableName()
+			)
+		);
+
+		return (results.Success() ? results.RowsAffected() : 0);
+	}
+
+	static int64 GetMaxId(Database& db)
+	{
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"SELECT COALESCE(MAX({}), 0) FROM {}",
+				PrimaryKey(),
+				TableName()
+			)
+		);
+
+		return (results.Success() && results.begin()[0] ? strtoll(results.begin()[0], nullptr, 10) : 0);
+	}
+
+	static int64 Count(Database& db, const std::string &where_filter = "")
+	{
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"SELECT COUNT(*) FROM {} {}",
+				TableName(),
+				(where_filter.empty() ? "" : "WHERE " + where_filter)
+			)
+		);
+
+		return (results.Success() && results.begin()[0] ? strtoll(results.begin()[0], nullptr, 10) : 0);
+	}
+
+};
+
+#endif //EQEMU_BASE_GUILD_BANK_REPOSITORY_H
@@ -21,7 +21,7 @@ public:
 	struct GuildMembers {
 		int32_t     char_id;
 		uint32_t    guild_id;
-		uint8_t     rank;
+		uint8_t     rank_;
 		uint8_t     tribute_enable;
 		uint32_t    total_tribute;
 		uint32_t    last_tribute;
@@ -41,7 +41,7 @@ public:
 		return {
 			"char_id",
 			"guild_id",
-			"rank",
+			"`rank`",
 			"tribute_enable",
 			"total_tribute",
 			"last_tribute",
@@ -57,7 +57,7 @@ public:
 		return {
 			"char_id",
 			"guild_id",
-			"rank",
+			"`rank`",
 			"tribute_enable",
 			"total_tribute",
 			"last_tribute",
@@ -107,7 +107,7 @@ public:

 		e.char_id        = 0;
 		e.guild_id       = 0;
-		e.rank           = 0;
+		e.rank_          = 0;
 		e.tribute_enable = 0;
 		e.total_tribute  = 0;
 		e.last_tribute   = 0;
@@ -153,7 +153,7 @@ public:

 			e.char_id        = row[0] ? static_cast<int32_t>(atoi(row[0])) : 0;
 			e.guild_id       = row[1] ? static_cast<uint32_t>(strtoul(row[1], nullptr, 10)) : 0;
-			e.rank           = row[2] ? static_cast<uint8_t>(strtoul(row[2], nullptr, 10)) : 0;
+			e.rank_          = row[2] ? static_cast<uint8_t>(strtoul(row[2], nullptr, 10)) : 0;
 			e.tribute_enable = row[3] ? static_cast<uint8_t>(strtoul(row[3], nullptr, 10)) : 0;
 			e.total_tribute  = row[4] ? static_cast<uint32_t>(strtoul(row[4], nullptr, 10)) : 0;
 			e.last_tribute   = row[5] ? static_cast<uint32_t>(strtoul(row[5], nullptr, 10)) : 0;
@@ -196,7 +196,7 @@ public:

 		v.push_back(columns[0] + " = " + std::to_string(e.char_id));
 		v.push_back(columns[1] + " = " + std::to_string(e.guild_id));
-		v.push_back(columns[2] + " = " + std::to_string(e.rank));
+		v.push_back(columns[2] + " = " + std::to_string(e.rank_));
 		v.push_back(columns[3] + " = " + std::to_string(e.tribute_enable));
 		v.push_back(columns[4] + " = " + std::to_string(e.total_tribute));
 		v.push_back(columns[5] + " = " + std::to_string(e.last_tribute));
@@ -227,7 +227,7 @@ public:

 		v.push_back(std::to_string(e.char_id));
 		v.push_back(std::to_string(e.guild_id));
-		v.push_back(std::to_string(e.rank));
+		v.push_back(std::to_string(e.rank_));
 		v.push_back(std::to_string(e.tribute_enable));
 		v.push_back(std::to_string(e.total_tribute));
 		v.push_back(std::to_string(e.last_tribute));
@@ -266,7 +266,7 @@ public:

 			v.push_back(std::to_string(e.char_id));
 			v.push_back(std::to_string(e.guild_id));
-			v.push_back(std::to_string(e.rank));
+			v.push_back(std::to_string(e.rank_));
 			v.push_back(std::to_string(e.tribute_enable));
 			v.push_back(std::to_string(e.total_tribute));
 			v.push_back(std::to_string(e.last_tribute));
@@ -309,7 +309,7 @@ public:

 			e.char_id        = row[0] ? static_cast<int32_t>(atoi(row[0])) : 0;
 			e.guild_id       = row[1] ? static_cast<uint32_t>(strtoul(row[1], nullptr, 10)) : 0;
-			e.rank           = row[2] ? static_cast<uint8_t>(strtoul(row[2], nullptr, 10)) : 0;
+			e.rank_          = row[2] ? static_cast<uint8_t>(strtoul(row[2], nullptr, 10)) : 0;
 			e.tribute_enable = row[3] ? static_cast<uint8_t>(strtoul(row[3], nullptr, 10)) : 0;
 			e.total_tribute  = row[4] ? static_cast<uint32_t>(strtoul(row[4], nullptr, 10)) : 0;
 			e.last_tribute   = row[5] ? static_cast<uint32_t>(strtoul(row[5], nullptr, 10)) : 0;
@@ -343,7 +343,7 @@ public:

 			e.char_id        = row[0] ? static_cast<int32_t>(atoi(row[0])) : 0;
 			e.guild_id       = row[1] ? static_cast<uint32_t>(strtoul(row[1], nullptr, 10)) : 0;
-			e.rank           = row[2] ? static_cast<uint8_t>(strtoul(row[2], nullptr, 10)) : 0;
+			e.rank_          = row[2] ? static_cast<uint8_t>(strtoul(row[2], nullptr, 10)) : 0;
 			e.tribute_enable = row[3] ? static_cast<uint8_t>(strtoul(row[3], nullptr, 10)) : 0;
 			e.total_tribute  = row[4] ? static_cast<uint32_t>(strtoul(row[4], nullptr, 10)) : 0;
 			e.last_tribute   = row[5] ? static_cast<uint32_t>(strtoul(row[5], nullptr, 10)) : 0;
@@ -427,7 +427,7 @@ public:

 		v.push_back(std::to_string(e.char_id));
 		v.push_back(std::to_string(e.guild_id));
-		v.push_back(std::to_string(e.rank));
+		v.push_back(std::to_string(e.rank_));
 		v.push_back(std::to_string(e.tribute_enable));
 		v.push_back(std::to_string(e.total_tribute));
 		v.push_back(std::to_string(e.last_tribute));
@@ -459,7 +459,7 @@ public:

 			v.push_back(std::to_string(e.char_id));
 			v.push_back(std::to_string(e.guild_id));
-			v.push_back(std::to_string(e.rank));
+			v.push_back(std::to_string(e.rank_));
 			v.push_back(std::to_string(e.tribute_enable));
 			v.push_back(std::to_string(e.total_tribute));
 			v.push_back(std::to_string(e.last_tribute));
@@ -0,0 +1,416 @@
+/**
+ * DO NOT MODIFY THIS FILE
+ *
+ * This repository was automatically generated and is NOT to be modified directly.
+ * Any repository modifications are meant to be made to the repository extending the base.
+ * Any modifications to base repositories are to be made by the generator only
+ *
+ * @generator ./utils/scripts/generators/repository-generator.pl
+ * @docs https://docs.eqemu.io/developer/repositories
+ */
+
+#ifndef EQEMU_BASE_GUILD_PERMISSIONS_REPOSITORY_H
+#define EQEMU_BASE_GUILD_PERMISSIONS_REPOSITORY_H
+
+#include "../../database.h"
+#include "../../strings.h"
+#include <ctime>
+
+
+class BaseGuildPermissionsRepository {
+public:
+	struct GuildPermissions {
+		int32_t id;
+		int32_t perm_id;
+		int32_t guild_id;
+		int32_t permission;
+	};
+
+	static std::string PrimaryKey()
+	{
+		return std::string("id");
+	}
+
+	static std::vector<std::string> Columns()
+	{
+		return {
+			"id",
+			"perm_id",
+			"guild_id",
+			"permission",
+		};
+	}
+
+	static std::vector<std::string> SelectColumns()
+	{
+		return {
+			"id",
+			"perm_id",
+			"guild_id",
+			"permission",
+		};
+	}
+
+	static std::string ColumnsRaw()
+	{
+		return std::string(Strings::Implode(", ", Columns()));
+	}
+
+	static std::string SelectColumnsRaw()
+	{
+		return std::string(Strings::Implode(", ", SelectColumns()));
+	}
+
+	static std::string TableName()
+	{
+		return std::string("guild_permissions");
+	}
+
+	static std::string BaseSelect()
+	{
+		return fmt::format(
+			"SELECT {} FROM {}",
+			SelectColumnsRaw(),
+			TableName()
+		);
+	}
+
+	static std::string BaseInsert()
+	{
+		return fmt::format(
+			"INSERT INTO {} ({}) ",
+			TableName(),
+			ColumnsRaw()
+		);
+	}
+
+	static GuildPermissions NewEntity()
+	{
+		GuildPermissions e{};
+
+		e.id         = 0;
+		e.perm_id    = 0;
+		e.guild_id   = 0;
+		e.permission = 0;
+
+		return e;
+	}
+
+	static GuildPermissions GetGuildPermissions(
+		const std::vector<GuildPermissions> &guild_permissionss,
+		int guild_permissions_id
+	)
+	{
+		for (auto &guild_permissions : guild_permissionss) {
+			if (guild_permissions.id == guild_permissions_id) {
+				return guild_permissions;
+			}
+		}
+
+		return NewEntity();
+	}
+
+	static GuildPermissions FindOne(
+		Database& db,
+		int guild_permissions_id
+	)
+	{
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"{} WHERE {} = {} LIMIT 1",
+				BaseSelect(),
+				PrimaryKey(),
+				guild_permissions_id
+			)
+		);
+
+		auto row = results.begin();
+		if (results.RowCount() == 1) {
+			GuildPermissions e{};
+
+			e.id         = static_cast<int32_t>(atoi(row[0]));
+			e.perm_id    = static_cast<int32_t>(atoi(row[1]));
+			e.guild_id   = static_cast<int32_t>(atoi(row[2]));
+			e.permission = static_cast<int32_t>(atoi(row[3]));
+
+			return e;
+		}
+
+		return NewEntity();
+	}
+
+	static int DeleteOne(
+		Database& db,
+		int guild_permissions_id
+	)
+	{
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"DELETE FROM {} WHERE {} = {}",
+				TableName(),
+				PrimaryKey(),
+				guild_permissions_id
+			)
+		);
+
+		return (results.Success() ? results.RowsAffected() : 0);
+	}
+
+	static int UpdateOne(
+		Database& db,
+		const GuildPermissions &e
+	)
+	{
+		std::vector<std::string> v;
+
+		auto columns = Columns();
+
+		v.push_back(columns[1] + " = " + std::to_string(e.perm_id));
+		v.push_back(columns[2] + " = " + std::to_string(e.guild_id));
+		v.push_back(columns[3] + " = " + std::to_string(e.permission));
+
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"UPDATE {} SET {} WHERE {} = {}",
+				TableName(),
+				Strings::Implode(", ", v),
+				PrimaryKey(),
+				e.id
+			)
+		);
+
+		return (results.Success() ? results.RowsAffected() : 0);
+	}
+
+	static GuildPermissions InsertOne(
+		Database& db,
+		GuildPermissions e
+	)
+	{
+		std::vector<std::string> v;
+
+		v.push_back(std::to_string(e.id));
+		v.push_back(std::to_string(e.perm_id));
+		v.push_back(std::to_string(e.guild_id));
+		v.push_back(std::to_string(e.permission));
+
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"{} VALUES ({})",
+				BaseInsert(),
+				Strings::Implode(",", v)
+			)
+		);
+
+		if (results.Success()) {
+			e.id = results.LastInsertedID();
+			return e;
+		}
+
+		e = NewEntity();
+
+		return e;
+	}
+
+	static int InsertMany(
+		Database& db,
+		const std::vector<GuildPermissions> &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.perm_id));
+			v.push_back(std::to_string(e.guild_id));
+			v.push_back(std::to_string(e.permission));
+
+			insert_chunks.push_back("(" + Strings::Implode(",", v) + ")");
+		}
+
+		std::vector<std::string> v;
+
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"{} VALUES {}",
+				BaseInsert(),
+				Strings::Implode(",", insert_chunks)
+			)
+		);
+
+		return (results.Success() ? results.RowsAffected() : 0);
+	}
+
+	static std::vector<GuildPermissions> All(Database& db)
+	{
+		std::vector<GuildPermissions> all_entries;
+
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"{}",
+				BaseSelect()
+			)
+		);
+
+		all_entries.reserve(results.RowCount());
+
+		for (auto row = results.begin(); row != results.end(); ++row) {
+			GuildPermissions e{};
+
+			e.id         = static_cast<int32_t>(atoi(row[0]));
+			e.perm_id    = static_cast<int32_t>(atoi(row[1]));
+			e.guild_id   = static_cast<int32_t>(atoi(row[2]));
+			e.permission = static_cast<int32_t>(atoi(row[3]));
+
+			all_entries.push_back(e);
+		}
+
+		return all_entries;
+	}
+
+	static std::vector<GuildPermissions> GetWhere(Database& db, const std::string &where_filter)
+	{
+		std::vector<GuildPermissions> all_entries;
+
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"{} WHERE {}",
+				BaseSelect(),
+				where_filter
+			)
+		);
+
+		all_entries.reserve(results.RowCount());
+
+		for (auto row = results.begin(); row != results.end(); ++row) {
+			GuildPermissions e{};
+
+			e.id         = static_cast<int32_t>(atoi(row[0]));
+			e.perm_id    = static_cast<int32_t>(atoi(row[1]));
+			e.guild_id   = static_cast<int32_t>(atoi(row[2]));
+			e.permission = static_cast<int32_t>(atoi(row[3]));
+
+			all_entries.push_back(e);
+		}
+
+		return all_entries;
+	}
+
+	static int DeleteWhere(Database& db, const std::string &where_filter)
+	{
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"DELETE FROM {} WHERE {}",
+				TableName(),
+				where_filter
+			)
+		);
+
+		return (results.Success() ? results.RowsAffected() : 0);
+	}
+
+	static int Truncate(Database& db)
+	{
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"TRUNCATE TABLE {}",
+				TableName()
+			)
+		);
+
+		return (results.Success() ? results.RowsAffected() : 0);
+	}
+
+	static int64 GetMaxId(Database& db)
+	{
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"SELECT COALESCE(MAX({}), 0) FROM {}",
+				PrimaryKey(),
+				TableName()
+			)
+		);
+
+		return (results.Success() && results.begin()[0] ? strtoll(results.begin()[0], nullptr, 10) : 0);
+	}
+
+	static int64 Count(Database& db, const std::string &where_filter = "")
+	{
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"SELECT COUNT(*) FROM {} {}",
+				TableName(),
+				(where_filter.empty() ? "" : "WHERE " + where_filter)
+			)
+		);
+
+		return (results.Success() && results.begin()[0] ? strtoll(results.begin()[0], nullptr, 10) : 0);
+	}
+
+	static std::string BaseReplace()
+	{
+		return fmt::format(
+			"REPLACE INTO {} ({}) ",
+			TableName(),
+			ColumnsRaw()
+		);
+	}
+
+	static int ReplaceOne(
+		Database& db,
+		const GuildPermissions &e
+	)
+	{
+		std::vector<std::string> v;
+
+		v.push_back(std::to_string(e.id));
+		v.push_back(std::to_string(e.perm_id));
+		v.push_back(std::to_string(e.guild_id));
+		v.push_back(std::to_string(e.permission));
+
+		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<GuildPermissions> &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.perm_id));
+			v.push_back(std::to_string(e.guild_id));
+			v.push_back(std::to_string(e.permission));
+
+			insert_chunks.push_back("(" + Strings::Implode(",", v) + ")");
+		}
+
+		std::vector<std::string> v;
+
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"{} VALUES {}",
+				BaseReplace(),
+				Strings::Implode(",", insert_chunks)
+			)
+		);
+
+		return (results.Success() ? results.RowsAffected() : 0);
+	}
+};
+
+#endif //EQEMU_BASE_GUILD_PERMISSIONS_REPOSITORY_H
@@ -20,7 +20,7 @@ class BaseGuildRanksRepository {
 public:
 	struct GuildRanks {
 		uint32_t    guild_id;
-		uint8_t     rank;
+		uint8_t     rank_;
 		std::string title;
 	};

@@ -33,7 +33,7 @@ public:
 	{
 		return {
 			"guild_id",
-			"rank",
+			"`rank`",
 			"title",
 		};
 	}
@@ -42,7 +42,7 @@ public:
 	{
 		return {
 			"guild_id",
-			"rank",
+			"`rank`",
 			"title",
 		};
 	}
@@ -85,7 +85,7 @@ public:
 		GuildRanks e{};

 		e.guild_id = 0;
-		e.rank     = 0;
+		e.rank_    = 0;
 		e.title    = "";

 		return e;
@@ -124,7 +124,7 @@ public:
 			GuildRanks e{};

 			e.guild_id = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
-			e.rank     = row[1] ? static_cast<uint8_t>(strtoul(row[1], nullptr, 10)) : 0;
+			e.rank_    = row[1] ? static_cast<uint8_t>(strtoul(row[1], nullptr, 10)) : 0;
 			e.title    = row[2] ? row[2] : "";

 			return e;
@@ -160,7 +160,7 @@ public:
 		auto columns = Columns();

 		v.push_back(columns[0] + " = " + std::to_string(e.guild_id));
-		v.push_back(columns[1] + " = " + std::to_string(e.rank));
+		v.push_back(columns[1] + " = " + std::to_string(e.rank_));
 		v.push_back(columns[2] + " = '" + Strings::Escape(e.title) + "'");

 		auto results = db.QueryDatabase(
@@ -184,7 +184,7 @@ public:
 		std::vector<std::string> v;

 		v.push_back(std::to_string(e.guild_id));
-		v.push_back(std::to_string(e.rank));
+		v.push_back(std::to_string(e.rank_));
 		v.push_back("'" + Strings::Escape(e.title) + "'");

 		auto results = db.QueryDatabase(
@@ -216,7 +216,7 @@ public:
 			std::vector<std::string> v;

 			v.push_back(std::to_string(e.guild_id));
-			v.push_back(std::to_string(e.rank));
+			v.push_back(std::to_string(e.rank_));
 			v.push_back("'" + Strings::Escape(e.title) + "'");

 			insert_chunks.push_back("(" + Strings::Implode(",", v) + ")");
@@ -252,7 +252,7 @@ public:
 			GuildRanks e{};

 			e.guild_id = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
-			e.rank     = row[1] ? static_cast<uint8_t>(strtoul(row[1], nullptr, 10)) : 0;
+			e.rank_    = row[1] ? static_cast<uint8_t>(strtoul(row[1], nullptr, 10)) : 0;
 			e.title    = row[2] ? row[2] : "";

 			all_entries.push_back(e);
@@ -279,7 +279,7 @@ public:
 			GuildRanks e{};

 			e.guild_id = row[0] ? static_cast<uint32_t>(strtoul(row[0], nullptr, 10)) : 0;
-			e.rank     = row[1] ? static_cast<uint8_t>(strtoul(row[1], nullptr, 10)) : 0;
+			e.rank_    = row[1] ? static_cast<uint8_t>(strtoul(row[1], nullptr, 10)) : 0;
 			e.title    = row[2] ? row[2] : "";

 			all_entries.push_back(e);
@@ -356,7 +356,7 @@ public:
 		std::vector<std::string> v;

 		v.push_back(std::to_string(e.guild_id));
-		v.push_back(std::to_string(e.rank));
+		v.push_back(std::to_string(e.rank_));
 		v.push_back("'" + Strings::Escape(e.title) + "'");

 		auto results = db.QueryDatabase(
@@ -381,7 +381,7 @@ public:
 			std::vector<std::string> v;

 			v.push_back(std::to_string(e.guild_id));
-			v.push_back(std::to_string(e.rank));
+			v.push_back(std::to_string(e.rank_));
 			v.push_back("'" + Strings::Escape(e.title) + "'");

 			insert_chunks.push_back("(" + Strings::Implode(",", v) + ")");
@@ -0,0 +1,453 @@
+/**
+ * DO NOT MODIFY THIS FILE
+ *
+ * This repository was automatically generated and is NOT to be modified directly.
+ * Any repository modifications are meant to be made to the repository extending the base.
+ * Any modifications to base repositories are to be made by the generator only
+ *
+ * @generator ./utils/scripts/generators/repository-generator.pl
+ * @docs https://docs.eqemu.io/developer/repositories
+ */
+
+#ifndef EQEMU_BASE_GUILD_TRIBUTES_REPOSITORY_H
+#define EQEMU_BASE_GUILD_TRIBUTES_REPOSITORY_H
+
+#include "../../database.h"
+#include "../../strings.h"
+#include <ctime>
+
+
+class BaseGuildTributesRepository {
+public:
+	struct GuildTributes {
+		uint32_t guild_id;
+		uint32_t tribute_id_1;
+		uint32_t tribute_id_1_tier;
+		uint32_t tribute_id_2;
+		uint32_t tribute_id_2_tier;
+		uint32_t time_remaining;
+		uint32_t enabled;
+	};
+
+	static std::string PrimaryKey()
+	{
+		return std::string("guild_id");
+	}
+
+	static std::vector<std::string> Columns()
+	{
+		return {
+			"guild_id",
+			"tribute_id_1",
+			"tribute_id_1_tier",
+			"tribute_id_2",
+			"tribute_id_2_tier",
+			"time_remaining",
+			"enabled",
+		};
+	}
+
+	static std::vector<std::string> SelectColumns()
+	{
+		return {
+			"guild_id",
+			"tribute_id_1",
+			"tribute_id_1_tier",
+			"tribute_id_2",
+			"tribute_id_2_tier",
+			"time_remaining",
+			"enabled",
+		};
+	}
+
+	static std::string ColumnsRaw()
+	{
+		return std::string(Strings::Implode(", ", Columns()));
+	}
+
+	static std::string SelectColumnsRaw()
+	{
+		return std::string(Strings::Implode(", ", SelectColumns()));
+	}
+
+	static std::string TableName()
+	{
+		return std::string("guild_tributes");
+	}
+
+	static std::string BaseSelect()
+	{
+		return fmt::format(
+			"SELECT {} FROM {}",
+			SelectColumnsRaw(),
+			TableName()
+		);
+	}
+
+	static std::string BaseInsert()
+	{
+		return fmt::format(
+			"INSERT INTO {} ({}) ",
+			TableName(),
+			ColumnsRaw()
+		);
+	}
+
+	static GuildTributes NewEntity()
+	{
+		GuildTributes e{};
+
+		e.guild_id          = 0;
+		e.tribute_id_1      = 0;
+		e.tribute_id_1_tier = 0;
+		e.tribute_id_2      = 0;
+		e.tribute_id_2_tier = 0;
+		e.time_remaining    = 0;
+		e.enabled           = 0;
+
+		return e;
+	}
+
+	static GuildTributes GetGuildTributes(
+		const std::vector<GuildTributes> &guild_tributess,
+		int guild_tributes_id
+	)
+	{
+		for (auto &guild_tributes : guild_tributess) {
+			if (guild_tributes.guild_id == guild_tributes_id) {
+				return guild_tributes;
+			}
+		}
+
+		return NewEntity();
+	}
+
+	static GuildTributes FindOne(
+		Database& db,
+		int guild_tributes_id
+	)
+	{
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"{} WHERE {} = {} LIMIT 1",
+				BaseSelect(),
+				PrimaryKey(),
+				guild_tributes_id
+			)
+		);
+
+		auto row = results.begin();
+		if (results.RowCount() == 1) {
+			GuildTributes e{};
+
+			e.guild_id          = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
+			e.tribute_id_1      = static_cast<uint32_t>(strtoul(row[1], nullptr, 10));
+			e.tribute_id_1_tier = static_cast<uint32_t>(strtoul(row[2], nullptr, 10));
+			e.tribute_id_2      = static_cast<uint32_t>(strtoul(row[3], nullptr, 10));
+			e.tribute_id_2_tier = static_cast<uint32_t>(strtoul(row[4], nullptr, 10));
+			e.time_remaining    = static_cast<uint32_t>(strtoul(row[5], nullptr, 10));
+			e.enabled           = static_cast<uint32_t>(strtoul(row[6], nullptr, 10));
+
+			return e;
+		}
+
+		return NewEntity();
+	}
+
+	static int DeleteOne(
+		Database& db,
+		int guild_tributes_id
+	)
+	{
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"DELETE FROM {} WHERE {} = {}",
+				TableName(),
+				PrimaryKey(),
+				guild_tributes_id
+			)
+		);
+
+		return (results.Success() ? results.RowsAffected() : 0);
+	}
+
+	static int UpdateOne(
+		Database& db,
+		const GuildTributes &e
+	)
+	{
+		std::vector<std::string> v;
+
+		auto columns = Columns();
+
+		v.push_back(columns[0] + " = " + std::to_string(e.guild_id));
+		v.push_back(columns[1] + " = " + std::to_string(e.tribute_id_1));
+		v.push_back(columns[2] + " = " + std::to_string(e.tribute_id_1_tier));
+		v.push_back(columns[3] + " = " + std::to_string(e.tribute_id_2));
+		v.push_back(columns[4] + " = " + std::to_string(e.tribute_id_2_tier));
+		v.push_back(columns[5] + " = " + std::to_string(e.time_remaining));
+		v.push_back(columns[6] + " = " + std::to_string(e.enabled));
+
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"UPDATE {} SET {} WHERE {} = {}",
+				TableName(),
+				Strings::Implode(", ", v),
+				PrimaryKey(),
+				e.guild_id
+			)
+		);
+
+		return (results.Success() ? results.RowsAffected() : 0);
+	}
+
+	static GuildTributes InsertOne(
+		Database& db,
+		GuildTributes e
+	)
+	{
+		std::vector<std::string> v;
+
+		v.push_back(std::to_string(e.guild_id));
+		v.push_back(std::to_string(e.tribute_id_1));
+		v.push_back(std::to_string(e.tribute_id_1_tier));
+		v.push_back(std::to_string(e.tribute_id_2));
+		v.push_back(std::to_string(e.tribute_id_2_tier));
+		v.push_back(std::to_string(e.time_remaining));
+		v.push_back(std::to_string(e.enabled));
+
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"{} VALUES ({})",
+				BaseInsert(),
+				Strings::Implode(",", v)
+			)
+		);
+
+		if (results.Success()) {
+			e.guild_id = results.LastInsertedID();
+			return e;
+		}
+
+		e = NewEntity();
+
+		return e;
+	}
+
+	static int InsertMany(
+		Database& db,
+		const std::vector<GuildTributes> &entries
+	)
+	{
+		std::vector<std::string> insert_chunks;
+
+		for (auto &e: entries) {
+			std::vector<std::string> v;
+
+			v.push_back(std::to_string(e.guild_id));
+			v.push_back(std::to_string(e.tribute_id_1));
+			v.push_back(std::to_string(e.tribute_id_1_tier));
+			v.push_back(std::to_string(e.tribute_id_2));
+			v.push_back(std::to_string(e.tribute_id_2_tier));
+			v.push_back(std::to_string(e.time_remaining));
+			v.push_back(std::to_string(e.enabled));
+
+			insert_chunks.push_back("(" + Strings::Implode(",", v) + ")");
+		}
+
+		std::vector<std::string> v;
+
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"{} VALUES {}",
+				BaseInsert(),
+				Strings::Implode(",", insert_chunks)
+			)
+		);
+
+		return (results.Success() ? results.RowsAffected() : 0);
+	}
+
+	static std::vector<GuildTributes> All(Database& db)
+	{
+		std::vector<GuildTributes> all_entries;
+
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"{}",
+				BaseSelect()
+			)
+		);
+
+		all_entries.reserve(results.RowCount());
+
+		for (auto row = results.begin(); row != results.end(); ++row) {
+			GuildTributes e{};
+
+			e.guild_id          = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
+			e.tribute_id_1      = static_cast<uint32_t>(strtoul(row[1], nullptr, 10));
+			e.tribute_id_1_tier = static_cast<uint32_t>(strtoul(row[2], nullptr, 10));
+			e.tribute_id_2      = static_cast<uint32_t>(strtoul(row[3], nullptr, 10));
+			e.tribute_id_2_tier = static_cast<uint32_t>(strtoul(row[4], nullptr, 10));
+			e.time_remaining    = static_cast<uint32_t>(strtoul(row[5], nullptr, 10));
+			e.enabled           = static_cast<uint32_t>(strtoul(row[6], nullptr, 10));
+
+			all_entries.push_back(e);
+		}
+
+		return all_entries;
+	}
+
+	static std::vector<GuildTributes> GetWhere(Database& db, const std::string &where_filter)
+	{
+		std::vector<GuildTributes> all_entries;
+
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"{} WHERE {}",
+				BaseSelect(),
+				where_filter
+			)
+		);
+
+		all_entries.reserve(results.RowCount());
+
+		for (auto row = results.begin(); row != results.end(); ++row) {
+			GuildTributes e{};
+
+			e.guild_id          = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
+			e.tribute_id_1      = static_cast<uint32_t>(strtoul(row[1], nullptr, 10));
+			e.tribute_id_1_tier = static_cast<uint32_t>(strtoul(row[2], nullptr, 10));
+			e.tribute_id_2      = static_cast<uint32_t>(strtoul(row[3], nullptr, 10));
+			e.tribute_id_2_tier = static_cast<uint32_t>(strtoul(row[4], nullptr, 10));
+			e.time_remaining    = static_cast<uint32_t>(strtoul(row[5], nullptr, 10));
+			e.enabled           = static_cast<uint32_t>(strtoul(row[6], nullptr, 10));
+
+			all_entries.push_back(e);
+		}
+
+		return all_entries;
+	}
+
+	static int DeleteWhere(Database& db, const std::string &where_filter)
+	{
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"DELETE FROM {} WHERE {}",
+				TableName(),
+				where_filter
+			)
+		);
+
+		return (results.Success() ? results.RowsAffected() : 0);
+	}
+
+	static int Truncate(Database& db)
+	{
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"TRUNCATE TABLE {}",
+				TableName()
+			)
+		);
+
+		return (results.Success() ? results.RowsAffected() : 0);
+	}
+
+	static int64 GetMaxId(Database& db)
+	{
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"SELECT COALESCE(MAX({}), 0) FROM {}",
+				PrimaryKey(),
+				TableName()
+			)
+		);
+
+		return (results.Success() && results.begin()[0] ? strtoll(results.begin()[0], nullptr, 10) : 0);
+	}
+
+	static int64 Count(Database& db, const std::string &where_filter = "")
+	{
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"SELECT COUNT(*) FROM {} {}",
+				TableName(),
+				(where_filter.empty() ? "" : "WHERE " + where_filter)
+			)
+		);
+
+		return (results.Success() && results.begin()[0] ? strtoll(results.begin()[0], nullptr, 10) : 0);
+	}
+
+	static std::string BaseReplace()
+	{
+		return fmt::format(
+			"REPLACE INTO {} ({}) ",
+			TableName(),
+			ColumnsRaw()
+		);
+	}
+
+	static int ReplaceOne(
+		Database& db,
+		const GuildTributes &e
+	)
+	{
+		std::vector<std::string> v;
+
+		v.push_back(std::to_string(e.guild_id));
+		v.push_back(std::to_string(e.tribute_id_1));
+		v.push_back(std::to_string(e.tribute_id_1_tier));
+		v.push_back(std::to_string(e.tribute_id_2));
+		v.push_back(std::to_string(e.tribute_id_2_tier));
+		v.push_back(std::to_string(e.time_remaining));
+		v.push_back(std::to_string(e.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<GuildTributes> &entries
+	)
+	{
+		std::vector<std::string> insert_chunks;
+
+		for (auto &e: entries) {
+			std::vector<std::string> v;
+
+			v.push_back(std::to_string(e.guild_id));
+			v.push_back(std::to_string(e.tribute_id_1));
+			v.push_back(std::to_string(e.tribute_id_1_tier));
+			v.push_back(std::to_string(e.tribute_id_2));
+			v.push_back(std::to_string(e.tribute_id_2_tier));
+			v.push_back(std::to_string(e.time_remaining));
+			v.push_back(std::to_string(e.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_GUILD_TRIBUTES_REPOSITORY_H
@@ -16,6 +16,7 @@
 #include "../../strings.h"
 #include <ctime>

+
 class BaseGuildsRepository {
 public:
 	struct Guilds {
@@ -116,7 +116,7 @@ public:
 		e.bagidx   = 0;
 		e.itemid   = 0;
 		e.charges  = 0;
-		e.droptime = 0;
+		e.droptime = std::time(nullptr);
 		e.augslot1 = 0;
 		e.augslot2 = 0;
 		e.augslot3 = 0;
@@ -19,13 +19,13 @@
 class BasePetsBeastlordDataRepository {
 public:
 	struct PetsBeastlordData {
-		uint32_t    player_race;
-		uint32_t    pet_race;
-		uint8_t     texture;
-		uint8_t     helm_texture;
-		uint8_t     gender;
-		std::string size_modifier;
-		uint8_t     face;
+		uint32_t player_race;
+		uint32_t pet_race;
+		uint8_t  texture;
+		uint8_t  helm_texture;
+		uint8_t  gender;
+		float    size_modifier;
+		uint8_t  face;
 	};

 	static std::string PrimaryKey()
@@ -227,7 +227,7 @@ public:
 		int32_t     no_block;
 		int32_t     field206;
 		int32_t     spellgroup;
-		int32_t     rank;
+		int32_t     rank_;
 		int32_t     field209;
 		int32_t     field210;
 		int32_t     CastRestriction;
@@ -474,7 +474,7 @@ public:
 			"no_block",
 			"field206",
 			"spellgroup",
-			"rank",
+			"`rank`",
 			"field209",
 			"field210",
 			"CastRestriction",
@@ -717,7 +717,7 @@ public:
 			"no_block",
 			"field206",
 			"spellgroup",
-			"rank",
+			"`rank`",
 			"field209",
 			"field210",
 			"CastRestriction",
@@ -994,7 +994,7 @@ public:
 		e.no_block             = 0;
 		e.field206             = -1;
 		e.spellgroup           = 0;
-		e.rank                 = 0;
+		e.rank_                = 0;
 		e.field209             = 0;
 		e.field210             = 1;
 		e.CastRestriction      = 0;
@@ -1267,7 +1267,7 @@ public:
 			e.no_block             = row[205] ? static_cast<int32_t>(atoi(row[205])) : 0;
 			e.field206             = row[206] ? static_cast<int32_t>(atoi(row[206])) : -1;
 			e.spellgroup           = row[207] ? static_cast<int32_t>(atoi(row[207])) : 0;
-			e.rank                 = row[208] ? static_cast<int32_t>(atoi(row[208])) : 0;
+			e.rank_                = row[208] ? static_cast<int32_t>(atoi(row[208])) : 0;
 			e.field209             = row[209] ? static_cast<int32_t>(atoi(row[209])) : 0;
 			e.field210             = row[210] ? static_cast<int32_t>(atoi(row[210])) : 1;
 			e.CastRestriction      = row[211] ? static_cast<int32_t>(atoi(row[211])) : 0;
@@ -1537,7 +1537,7 @@ public:
 		v.push_back(columns[205] + " = " + std::to_string(e.no_block));
 		v.push_back(columns[206] + " = " + std::to_string(e.field206));
 		v.push_back(columns[207] + " = " + std::to_string(e.spellgroup));
-		v.push_back(columns[208] + " = " + std::to_string(e.rank));
+		v.push_back(columns[208] + " = " + std::to_string(e.rank_));
 		v.push_back(columns[209] + " = " + std::to_string(e.field209));
 		v.push_back(columns[210] + " = " + std::to_string(e.field210));
 		v.push_back(columns[211] + " = " + std::to_string(e.CastRestriction));
@@ -1795,7 +1795,7 @@ public:
 		v.push_back(std::to_string(e.no_block));
 		v.push_back(std::to_string(e.field206));
 		v.push_back(std::to_string(e.spellgroup));
-		v.push_back(std::to_string(e.rank));
+		v.push_back(std::to_string(e.rank_));
 		v.push_back(std::to_string(e.field209));
 		v.push_back(std::to_string(e.field210));
 		v.push_back(std::to_string(e.CastRestriction));
@@ -2061,7 +2061,7 @@ public:
 			v.push_back(std::to_string(e.no_block));
 			v.push_back(std::to_string(e.field206));
 			v.push_back(std::to_string(e.spellgroup));
-			v.push_back(std::to_string(e.rank));
+			v.push_back(std::to_string(e.rank_));
 			v.push_back(std::to_string(e.field209));
 			v.push_back(std::to_string(e.field210));
 			v.push_back(std::to_string(e.CastRestriction));
@@ -2331,7 +2331,7 @@ public:
 			e.no_block             = row[205] ? static_cast<int32_t>(atoi(row[205])) : 0;
 			e.field206             = row[206] ? static_cast<int32_t>(atoi(row[206])) : -1;
 			e.spellgroup           = row[207] ? static_cast<int32_t>(atoi(row[207])) : 0;
-			e.rank                 = row[208] ? static_cast<int32_t>(atoi(row[208])) : 0;
+			e.rank_                = row[208] ? static_cast<int32_t>(atoi(row[208])) : 0;
 			e.field209             = row[209] ? static_cast<int32_t>(atoi(row[209])) : 0;
 			e.field210             = row[210] ? static_cast<int32_t>(atoi(row[210])) : 1;
 			e.CastRestriction      = row[211] ? static_cast<int32_t>(atoi(row[211])) : 0;
@@ -2592,7 +2592,7 @@ public:
 			e.no_block             = row[205] ? static_cast<int32_t>(atoi(row[205])) : 0;
 			e.field206             = row[206] ? static_cast<int32_t>(atoi(row[206])) : -1;
 			e.spellgroup           = row[207] ? static_cast<int32_t>(atoi(row[207])) : 0;
-			e.rank                 = row[208] ? static_cast<int32_t>(atoi(row[208])) : 0;
+			e.rank_                = row[208] ? static_cast<int32_t>(atoi(row[208])) : 0;
 			e.field209             = row[209] ? static_cast<int32_t>(atoi(row[209])) : 0;
 			e.field210             = row[210] ? static_cast<int32_t>(atoi(row[210])) : 1;
 			e.CastRestriction      = row[211] ? static_cast<int32_t>(atoi(row[211])) : 0;
@@ -2903,7 +2903,7 @@ public:
 		v.push_back(std::to_string(e.no_block));
 		v.push_back(std::to_string(e.field206));
 		v.push_back(std::to_string(e.spellgroup));
-		v.push_back(std::to_string(e.rank));
+		v.push_back(std::to_string(e.rank_));
 		v.push_back(std::to_string(e.field209));
 		v.push_back(std::to_string(e.field210));
 		v.push_back(std::to_string(e.CastRestriction));
@@ -3162,7 +3162,7 @@ public:
 			v.push_back(std::to_string(e.no_block));
 			v.push_back(std::to_string(e.field206));
 			v.push_back(std::to_string(e.spellgroup));
-			v.push_back(std::to_string(e.rank));
+			v.push_back(std::to_string(e.rank_));
 			v.push_back(std::to_string(e.field209));
 			v.push_back(std::to_string(e.field210));
 			v.push_back(std::to_string(e.CastRestriction));
@@ -26,6 +26,12 @@ public:
 		std::string zone_id_list;
 		uint32_t    item_id;
 		uint8_t     item_charges;
+		uint32_t    augment_one;
+		uint32_t    augment_two;
+		uint32_t    augment_three;
+		uint32_t    augment_four;
+		uint32_t    augment_five;
+		uint32_t    augment_six;
 		int32_t     status;
 		int32_t     inventory_slot;
 		int8_t      min_expansion;
@@ -49,6 +55,12 @@ public:
 			"zone_id_list",
 			"item_id",
 			"item_charges",
+			"augment_one",
+			"augment_two",
+			"augment_three",
+			"augment_four",
+			"augment_five",
+			"augment_six",
 			"status",
 			"inventory_slot",
 			"min_expansion",
@@ -68,6 +80,12 @@ public:
 			"zone_id_list",
 			"item_id",
 			"item_charges",
+			"augment_one",
+			"augment_two",
+			"augment_three",
+			"augment_four",
+			"augment_five",
+			"augment_six",
 			"status",
 			"inventory_slot",
 			"min_expansion",
@@ -121,6 +139,12 @@ public:
 		e.zone_id_list           = "";
 		e.item_id                = 0;
 		e.item_charges           = 1;
+		e.augment_one            = 0;
+		e.augment_two            = 0;
+		e.augment_three          = 0;
+		e.augment_four           = 0;
+		e.augment_five           = 0;
+		e.augment_six            = 0;
 		e.status                 = 0;
 		e.inventory_slot         = -1;
 		e.min_expansion          = -1;
@@ -170,12 +194,18 @@ public:
 			e.zone_id_list           = row[4] ? row[4] : "";
 			e.item_id                = row[5] ? static_cast<uint32_t>(strtoul(row[5], nullptr, 10)) : 0;
 			e.item_charges           = row[6] ? static_cast<uint8_t>(strtoul(row[6], nullptr, 10)) : 1;
-			e.status                 = row[7] ? static_cast<int32_t>(atoi(row[7])) : 0;
-			e.inventory_slot         = row[8] ? static_cast<int32_t>(atoi(row[8])) : -1;
-			e.min_expansion          = row[9] ? static_cast<int8_t>(atoi(row[9])) : -1;
-			e.max_expansion          = row[10] ? static_cast<int8_t>(atoi(row[10])) : -1;
-			e.content_flags          = row[11] ? row[11] : "";
-			e.content_flags_disabled = row[12] ? row[12] : "";
+			e.augment_one            = row[7] ? static_cast<uint32_t>(strtoul(row[7], nullptr, 10)) : 0;
+			e.augment_two            = row[8] ? static_cast<uint32_t>(strtoul(row[8], nullptr, 10)) : 0;
+			e.augment_three          = row[9] ? static_cast<uint32_t>(strtoul(row[9], nullptr, 10)) : 0;
+			e.augment_four           = row[10] ? static_cast<uint32_t>(strtoul(row[10], nullptr, 10)) : 0;
+			e.augment_five           = row[11] ? static_cast<uint32_t>(strtoul(row[11], nullptr, 10)) : 0;
+			e.augment_six            = row[12] ? static_cast<uint32_t>(strtoul(row[12], nullptr, 10)) : 0;
+			e.status                 = row[13] ? static_cast<int32_t>(atoi(row[13])) : 0;
+			e.inventory_slot         = row[14] ? static_cast<int32_t>(atoi(row[14])) : -1;
+			e.min_expansion          = row[15] ? static_cast<int8_t>(atoi(row[15])) : -1;
+			e.max_expansion          = row[16] ? static_cast<int8_t>(atoi(row[16])) : -1;
+			e.content_flags          = row[17] ? row[17] : "";
+			e.content_flags_disabled = row[18] ? row[18] : "";

 			return e;
 		}
@@ -215,12 +245,18 @@ public:
 		v.push_back(columns[4] + " = '" + Strings::Escape(e.zone_id_list) + "'");
 		v.push_back(columns[5] + " = " + std::to_string(e.item_id));
 		v.push_back(columns[6] + " = " + std::to_string(e.item_charges));
-		v.push_back(columns[7] + " = " + std::to_string(e.status));
-		v.push_back(columns[8] + " = " + std::to_string(e.inventory_slot));
-		v.push_back(columns[9] + " = " + std::to_string(e.min_expansion));
-		v.push_back(columns[10] + " = " + std::to_string(e.max_expansion));
-		v.push_back(columns[11] + " = '" + Strings::Escape(e.content_flags) + "'");
-		v.push_back(columns[12] + " = '" + Strings::Escape(e.content_flags_disabled) + "'");
+		v.push_back(columns[7] + " = " + std::to_string(e.augment_one));
+		v.push_back(columns[8] + " = " + std::to_string(e.augment_two));
+		v.push_back(columns[9] + " = " + std::to_string(e.augment_three));
+		v.push_back(columns[10] + " = " + std::to_string(e.augment_four));
+		v.push_back(columns[11] + " = " + std::to_string(e.augment_five));
+		v.push_back(columns[12] + " = " + std::to_string(e.augment_six));
+		v.push_back(columns[13] + " = " + std::to_string(e.status));
+		v.push_back(columns[14] + " = " + std::to_string(e.inventory_slot));
+		v.push_back(columns[15] + " = " + std::to_string(e.min_expansion));
+		v.push_back(columns[16] + " = " + std::to_string(e.max_expansion));
+		v.push_back(columns[17] + " = '" + Strings::Escape(e.content_flags) + "'");
+		v.push_back(columns[18] + " = '" + Strings::Escape(e.content_flags_disabled) + "'");

 		auto results = db.QueryDatabase(
 			fmt::format(
@@ -249,6 +285,12 @@ public:
 		v.push_back("'" + Strings::Escape(e.zone_id_list) + "'");
 		v.push_back(std::to_string(e.item_id));
 		v.push_back(std::to_string(e.item_charges));
+		v.push_back(std::to_string(e.augment_one));
+		v.push_back(std::to_string(e.augment_two));
+		v.push_back(std::to_string(e.augment_three));
+		v.push_back(std::to_string(e.augment_four));
+		v.push_back(std::to_string(e.augment_five));
+		v.push_back(std::to_string(e.augment_six));
 		v.push_back(std::to_string(e.status));
 		v.push_back(std::to_string(e.inventory_slot));
 		v.push_back(std::to_string(e.min_expansion));
@@ -291,6 +333,12 @@ public:
 			v.push_back("'" + Strings::Escape(e.zone_id_list) + "'");
 			v.push_back(std::to_string(e.item_id));
 			v.push_back(std::to_string(e.item_charges));
+			v.push_back(std::to_string(e.augment_one));
+			v.push_back(std::to_string(e.augment_two));
+			v.push_back(std::to_string(e.augment_three));
+			v.push_back(std::to_string(e.augment_four));
+			v.push_back(std::to_string(e.augment_five));
+			v.push_back(std::to_string(e.augment_six));
 			v.push_back(std::to_string(e.status));
 			v.push_back(std::to_string(e.inventory_slot));
 			v.push_back(std::to_string(e.min_expansion));
@@ -337,12 +385,18 @@ public:
 			e.zone_id_list           = row[4] ? row[4] : "";
 			e.item_id                = row[5] ? static_cast<uint32_t>(strtoul(row[5], nullptr, 10)) : 0;
 			e.item_charges           = row[6] ? static_cast<uint8_t>(strtoul(row[6], nullptr, 10)) : 1;
-			e.status                 = row[7] ? static_cast<int32_t>(atoi(row[7])) : 0;
-			e.inventory_slot         = row[8] ? static_cast<int32_t>(atoi(row[8])) : -1;
-			e.min_expansion          = row[9] ? static_cast<int8_t>(atoi(row[9])) : -1;
-			e.max_expansion          = row[10] ? static_cast<int8_t>(atoi(row[10])) : -1;
-			e.content_flags          = row[11] ? row[11] : "";
-			e.content_flags_disabled = row[12] ? row[12] : "";
+			e.augment_one            = row[7] ? static_cast<uint32_t>(strtoul(row[7], nullptr, 10)) : 0;
+			e.augment_two            = row[8] ? static_cast<uint32_t>(strtoul(row[8], nullptr, 10)) : 0;
+			e.augment_three          = row[9] ? static_cast<uint32_t>(strtoul(row[9], nullptr, 10)) : 0;
+			e.augment_four           = row[10] ? static_cast<uint32_t>(strtoul(row[10], nullptr, 10)) : 0;
+			e.augment_five           = row[11] ? static_cast<uint32_t>(strtoul(row[11], nullptr, 10)) : 0;
+			e.augment_six            = row[12] ? static_cast<uint32_t>(strtoul(row[12], nullptr, 10)) : 0;
+			e.status                 = row[13] ? static_cast<int32_t>(atoi(row[13])) : 0;
+			e.inventory_slot         = row[14] ? static_cast<int32_t>(atoi(row[14])) : -1;
+			e.min_expansion          = row[15] ? static_cast<int8_t>(atoi(row[15])) : -1;
+			e.max_expansion          = row[16] ? static_cast<int8_t>(atoi(row[16])) : -1;
+			e.content_flags          = row[17] ? row[17] : "";
+			e.content_flags_disabled = row[18] ? row[18] : "";

 			all_entries.push_back(e);
 		}
@@ -374,12 +428,18 @@ public:
 			e.zone_id_list           = row[4] ? row[4] : "";
 			e.item_id                = row[5] ? static_cast<uint32_t>(strtoul(row[5], nullptr, 10)) : 0;
 			e.item_charges           = row[6] ? static_cast<uint8_t>(strtoul(row[6], nullptr, 10)) : 1;
-			e.status                 = row[7] ? static_cast<int32_t>(atoi(row[7])) : 0;
-			e.inventory_slot         = row[8] ? static_cast<int32_t>(atoi(row[8])) : -1;
-			e.min_expansion          = row[9] ? static_cast<int8_t>(atoi(row[9])) : -1;
-			e.max_expansion          = row[10] ? static_cast<int8_t>(atoi(row[10])) : -1;
-			e.content_flags          = row[11] ? row[11] : "";
-			e.content_flags_disabled = row[12] ? row[12] : "";
+			e.augment_one            = row[7] ? static_cast<uint32_t>(strtoul(row[7], nullptr, 10)) : 0;
+			e.augment_two            = row[8] ? static_cast<uint32_t>(strtoul(row[8], nullptr, 10)) : 0;
+			e.augment_three          = row[9] ? static_cast<uint32_t>(strtoul(row[9], nullptr, 10)) : 0;
+			e.augment_four           = row[10] ? static_cast<uint32_t>(strtoul(row[10], nullptr, 10)) : 0;
+			e.augment_five           = row[11] ? static_cast<uint32_t>(strtoul(row[11], nullptr, 10)) : 0;
+			e.augment_six            = row[12] ? static_cast<uint32_t>(strtoul(row[12], nullptr, 10)) : 0;
+			e.status                 = row[13] ? static_cast<int32_t>(atoi(row[13])) : 0;
+			e.inventory_slot         = row[14] ? static_cast<int32_t>(atoi(row[14])) : -1;
+			e.min_expansion          = row[15] ? static_cast<int8_t>(atoi(row[15])) : -1;
+			e.max_expansion          = row[16] ? static_cast<int8_t>(atoi(row[16])) : -1;
+			e.content_flags          = row[17] ? row[17] : "";
+			e.content_flags_disabled = row[18] ? row[18] : "";

 			all_entries.push_back(e);
 		}
@@ -461,6 +521,12 @@ public:
 		v.push_back("'" + Strings::Escape(e.zone_id_list) + "'");
 		v.push_back(std::to_string(e.item_id));
 		v.push_back(std::to_string(e.item_charges));
+		v.push_back(std::to_string(e.augment_one));
+		v.push_back(std::to_string(e.augment_two));
+		v.push_back(std::to_string(e.augment_three));
+		v.push_back(std::to_string(e.augment_four));
+		v.push_back(std::to_string(e.augment_five));
+		v.push_back(std::to_string(e.augment_six));
 		v.push_back(std::to_string(e.status));
 		v.push_back(std::to_string(e.inventory_slot));
 		v.push_back(std::to_string(e.min_expansion));
@@ -496,6 +562,12 @@ public:
 			v.push_back("'" + Strings::Escape(e.zone_id_list) + "'");
 			v.push_back(std::to_string(e.item_id));
 			v.push_back(std::to_string(e.item_charges));
+			v.push_back(std::to_string(e.augment_one));
+			v.push_back(std::to_string(e.augment_two));
+			v.push_back(std::to_string(e.augment_three));
+			v.push_back(std::to_string(e.augment_four));
+			v.push_back(std::to_string(e.augment_five));
+			v.push_back(std::to_string(e.augment_six));
 			v.push_back(std::to_string(e.status));
 			v.push_back(std::to_string(e.inventory_slot));
 			v.push_back(std::to_string(e.min_expansion));
@@ -37,7 +37,7 @@ public:
 		uint32_t    respawn_time;
 		uint32_t    respawn_var;
 		int8_t      triggered_number;
-		int8_t      group;
+		int8_t      group_;
 		int8_t      despawn_when_triggered;
 		int8_t      undetectable;
 		int8_t      min_expansion;
@@ -72,7 +72,7 @@ public:
 			"respawn_time",
 			"respawn_var",
 			"triggered_number",
-			"group",
+			"`group`",
 			"despawn_when_triggered",
 			"undetectable",
 			"min_expansion",
@@ -103,7 +103,7 @@ public:
 			"respawn_time",
 			"respawn_var",
 			"triggered_number",
-			"group",
+			"`group`",
 			"despawn_when_triggered",
 			"undetectable",
 			"min_expansion",
@@ -168,7 +168,7 @@ public:
 		e.respawn_time           = 60;
 		e.respawn_var            = 0;
 		e.triggered_number       = 0;
-		e.group                  = 0;
+		e.group_                 = 0;
 		e.despawn_when_triggered = 0;
 		e.undetectable           = 0;
 		e.min_expansion          = -1;
@@ -229,7 +229,7 @@ public:
 			e.respawn_time           = row[15] ? static_cast<uint32_t>(strtoul(row[15], nullptr, 10)) : 60;
 			e.respawn_var            = row[16] ? static_cast<uint32_t>(strtoul(row[16], nullptr, 10)) : 0;
 			e.triggered_number       = row[17] ? static_cast<int8_t>(atoi(row[17])) : 0;
-			e.group                  = row[18] ? static_cast<int8_t>(atoi(row[18])) : 0;
+			e.group_                 = row[18] ? static_cast<int8_t>(atoi(row[18])) : 0;
 			e.despawn_when_triggered = row[19] ? static_cast<int8_t>(atoi(row[19])) : 0;
 			e.undetectable           = row[20] ? static_cast<int8_t>(atoi(row[20])) : 0;
 			e.min_expansion          = row[21] ? static_cast<int8_t>(atoi(row[21])) : -1;
@@ -286,7 +286,7 @@ public:
 		v.push_back(columns[15] + " = " + std::to_string(e.respawn_time));
 		v.push_back(columns[16] + " = " + std::to_string(e.respawn_var));
 		v.push_back(columns[17] + " = " + std::to_string(e.triggered_number));
-		v.push_back(columns[18] + " = " + std::to_string(e.group));
+		v.push_back(columns[18] + " = " + std::to_string(e.group_));
 		v.push_back(columns[19] + " = " + std::to_string(e.despawn_when_triggered));
 		v.push_back(columns[20] + " = " + std::to_string(e.undetectable));
 		v.push_back(columns[21] + " = " + std::to_string(e.min_expansion));
@@ -332,7 +332,7 @@ public:
 		v.push_back(std::to_string(e.respawn_time));
 		v.push_back(std::to_string(e.respawn_var));
 		v.push_back(std::to_string(e.triggered_number));
-		v.push_back(std::to_string(e.group));
+		v.push_back(std::to_string(e.group_));
 		v.push_back(std::to_string(e.despawn_when_triggered));
 		v.push_back(std::to_string(e.undetectable));
 		v.push_back(std::to_string(e.min_expansion));
@@ -386,7 +386,7 @@ public:
 			v.push_back(std::to_string(e.respawn_time));
 			v.push_back(std::to_string(e.respawn_var));
 			v.push_back(std::to_string(e.triggered_number));
-			v.push_back(std::to_string(e.group));
+			v.push_back(std::to_string(e.group_));
 			v.push_back(std::to_string(e.despawn_when_triggered));
 			v.push_back(std::to_string(e.undetectable));
 			v.push_back(std::to_string(e.min_expansion));
@@ -444,7 +444,7 @@ public:
 			e.respawn_time           = row[15] ? static_cast<uint32_t>(strtoul(row[15], nullptr, 10)) : 60;
 			e.respawn_var            = row[16] ? static_cast<uint32_t>(strtoul(row[16], nullptr, 10)) : 0;
 			e.triggered_number       = row[17] ? static_cast<int8_t>(atoi(row[17])) : 0;
-			e.group                  = row[18] ? static_cast<int8_t>(atoi(row[18])) : 0;
+			e.group_                 = row[18] ? static_cast<int8_t>(atoi(row[18])) : 0;
 			e.despawn_when_triggered = row[19] ? static_cast<int8_t>(atoi(row[19])) : 0;
 			e.undetectable           = row[20] ? static_cast<int8_t>(atoi(row[20])) : 0;
 			e.min_expansion          = row[21] ? static_cast<int8_t>(atoi(row[21])) : -1;
@@ -493,7 +493,7 @@ public:
 			e.respawn_time           = row[15] ? static_cast<uint32_t>(strtoul(row[15], nullptr, 10)) : 60;
 			e.respawn_var            = row[16] ? static_cast<uint32_t>(strtoul(row[16], nullptr, 10)) : 0;
 			e.triggered_number       = row[17] ? static_cast<int8_t>(atoi(row[17])) : 0;
-			e.group                  = row[18] ? static_cast<int8_t>(atoi(row[18])) : 0;
+			e.group_                 = row[18] ? static_cast<int8_t>(atoi(row[18])) : 0;
 			e.despawn_when_triggered = row[19] ? static_cast<int8_t>(atoi(row[19])) : 0;
 			e.undetectable           = row[20] ? static_cast<int8_t>(atoi(row[20])) : 0;
 			e.min_expansion          = row[21] ? static_cast<int8_t>(atoi(row[21])) : -1;
@@ -592,7 +592,7 @@ public:
 		v.push_back(std::to_string(e.respawn_time));
 		v.push_back(std::to_string(e.respawn_var));
 		v.push_back(std::to_string(e.triggered_number));
-		v.push_back(std::to_string(e.group));
+		v.push_back(std::to_string(e.group_));
 		v.push_back(std::to_string(e.despawn_when_triggered));
 		v.push_back(std::to_string(e.undetectable));
 		v.push_back(std::to_string(e.min_expansion));
@@ -639,7 +639,7 @@ public:
 			v.push_back(std::to_string(e.respawn_time));
 			v.push_back(std::to_string(e.respawn_var));
 			v.push_back(std::to_string(e.triggered_number));
-			v.push_back(std::to_string(e.group));
+			v.push_back(std::to_string(e.group_));
 			v.push_back(std::to_string(e.despawn_when_triggered));
 			v.push_back(std::to_string(e.undetectable));
 			v.push_back(std::to_string(e.min_expansion));
@@ -0,0 +1,392 @@
+/**
+ * DO NOT MODIFY THIS FILE
+ *
+ * This repository was automatically generated and is NOT to be modified directly.
+ * Any repository modifications are meant to be made to the repository extending the base.
+ * Any modifications to base repositories are to be made by the generator only
+ *
+ * @generator ./utils/scripts/generators/repository-generator.pl
+ * @docs https://docs.eqemu.io/developer/repositories
+ */
+
+#ifndef EQEMU_BASE_ZONE_FLAGS_REPOSITORY_H
+#define EQEMU_BASE_ZONE_FLAGS_REPOSITORY_H
+
+#include "../../database.h"
+#include "../../strings.h"
+#include <ctime>
+
+class BaseZoneFlagsRepository {
+public:
+	struct ZoneFlags {
+		int32_t charID;
+		int32_t zoneID;
+	};
+
+	static std::string PrimaryKey()
+	{
+		return std::string("charID");
+	}
+
+	static std::vector<std::string> Columns()
+	{
+		return {
+			"charID",
+			"zoneID",
+		};
+	}
+
+	static std::vector<std::string> SelectColumns()
+	{
+		return {
+			"charID",
+			"zoneID",
+		};
+	}
+
+	static std::string ColumnsRaw()
+	{
+		return std::string(Strings::Implode(", ", Columns()));
+	}
+
+	static std::string SelectColumnsRaw()
+	{
+		return std::string(Strings::Implode(", ", SelectColumns()));
+	}
+
+	static std::string TableName()
+	{
+		return std::string("zone_flags");
+	}
+
+	static std::string BaseSelect()
+	{
+		return fmt::format(
+			"SELECT {} FROM {}",
+			SelectColumnsRaw(),
+			TableName()
+		);
+	}
+
+	static std::string BaseInsert()
+	{
+		return fmt::format(
+			"INSERT INTO {} ({}) ",
+			TableName(),
+			ColumnsRaw()
+		);
+	}
+
+	static ZoneFlags NewEntity()
+	{
+		ZoneFlags e{};
+
+		e.charID = 0;
+		e.zoneID = 0;
+
+		return e;
+	}
+
+	static ZoneFlags GetZoneFlags(
+		const std::vector<ZoneFlags> &zone_flagss,
+		int zone_flags_id
+	)
+	{
+		for (auto &zone_flags : zone_flagss) {
+			if (zone_flags.charID == zone_flags_id) {
+				return zone_flags;
+			}
+		}
+
+		return NewEntity();
+	}
+
+	static ZoneFlags FindOne(
+		Database& db,
+		int zone_flags_id
+	)
+	{
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"{} WHERE {} = {} LIMIT 1",
+				BaseSelect(),
+				PrimaryKey(),
+				zone_flags_id
+			)
+		);
+
+		auto row = results.begin();
+		if (results.RowCount() == 1) {
+			ZoneFlags e{};
+
+			e.charID = row[0] ? static_cast<int32_t>(atoi(row[0])) : 0;
+			e.zoneID = row[1] ? static_cast<int32_t>(atoi(row[1])) : 0;
+
+			return e;
+		}
+
+		return NewEntity();
+	}
+
+	static int DeleteOne(
+		Database& db,
+		int zone_flags_id
+	)
+	{
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"DELETE FROM {} WHERE {} = {}",
+				TableName(),
+				PrimaryKey(),
+				zone_flags_id
+			)
+		);
+
+		return (results.Success() ? results.RowsAffected() : 0);
+	}
+
+	static int UpdateOne(
+		Database& db,
+		const ZoneFlags &e
+	)
+	{
+		std::vector<std::string> v;
+
+		auto columns = Columns();
+
+		v.push_back(columns[0] + " = " + std::to_string(e.charID));
+		v.push_back(columns[1] + " = " + std::to_string(e.zoneID));
+
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"UPDATE {} SET {} WHERE {} = {}",
+				TableName(),
+				Strings::Implode(", ", v),
+				PrimaryKey(),
+				e.charID
+			)
+		);
+
+		return (results.Success() ? results.RowsAffected() : 0);
+	}
+
+	static ZoneFlags InsertOne(
+		Database& db,
+		ZoneFlags e
+	)
+	{
+		std::vector<std::string> v;
+
+		v.push_back(std::to_string(e.charID));
+		v.push_back(std::to_string(e.zoneID));
+
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"{} VALUES ({})",
+				BaseInsert(),
+				Strings::Implode(",", v)
+			)
+		);
+
+		if (results.Success()) {
+			e.charID = results.LastInsertedID();
+			return e;
+		}
+
+		e = NewEntity();
+
+		return e;
+	}
+
+	static int InsertMany(
+		Database& db,
+		const std::vector<ZoneFlags> &entries
+	)
+	{
+		std::vector<std::string> insert_chunks;
+
+		for (auto &e: entries) {
+			std::vector<std::string> v;
+
+			v.push_back(std::to_string(e.charID));
+			v.push_back(std::to_string(e.zoneID));
+
+			insert_chunks.push_back("(" + Strings::Implode(",", v) + ")");
+		}
+
+		std::vector<std::string> v;
+
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"{} VALUES {}",
+				BaseInsert(),
+				Strings::Implode(",", insert_chunks)
+			)
+		);
+
+		return (results.Success() ? results.RowsAffected() : 0);
+	}
+
+	static std::vector<ZoneFlags> All(Database& db)
+	{
+		std::vector<ZoneFlags> all_entries;
+
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"{}",
+				BaseSelect()
+			)
+		);
+
+		all_entries.reserve(results.RowCount());
+
+		for (auto row = results.begin(); row != results.end(); ++row) {
+			ZoneFlags e{};
+
+			e.charID = row[0] ? static_cast<int32_t>(atoi(row[0])) : 0;
+			e.zoneID = row[1] ? static_cast<int32_t>(atoi(row[1])) : 0;
+
+			all_entries.push_back(e);
+		}
+
+		return all_entries;
+	}
+
+	static std::vector<ZoneFlags> GetWhere(Database& db, const std::string &where_filter)
+	{
+		std::vector<ZoneFlags> all_entries;
+
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"{} WHERE {}",
+				BaseSelect(),
+				where_filter
+			)
+		);
+
+		all_entries.reserve(results.RowCount());
+
+		for (auto row = results.begin(); row != results.end(); ++row) {
+			ZoneFlags e{};
+
+			e.charID = row[0] ? static_cast<int32_t>(atoi(row[0])) : 0;
+			e.zoneID = row[1] ? static_cast<int32_t>(atoi(row[1])) : 0;
+
+			all_entries.push_back(e);
+		}
+
+		return all_entries;
+	}
+
+	static int DeleteWhere(Database& db, const std::string &where_filter)
+	{
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"DELETE FROM {} WHERE {}",
+				TableName(),
+				where_filter
+			)
+		);
+
+		return (results.Success() ? results.RowsAffected() : 0);
+	}
+
+	static int Truncate(Database& db)
+	{
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"TRUNCATE TABLE {}",
+				TableName()
+			)
+		);
+
+		return (results.Success() ? results.RowsAffected() : 0);
+	}
+
+	static int64 GetMaxId(Database& db)
+	{
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"SELECT COALESCE(MAX({}), 0) FROM {}",
+				PrimaryKey(),
+				TableName()
+			)
+		);
+
+		return (results.Success() && results.begin()[0] ? strtoll(results.begin()[0], nullptr, 10) : 0);
+	}
+
+	static int64 Count(Database& db, const std::string &where_filter = "")
+	{
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"SELECT COUNT(*) FROM {} {}",
+				TableName(),
+				(where_filter.empty() ? "" : "WHERE " + where_filter)
+			)
+		);
+
+		return (results.Success() && results.begin()[0] ? strtoll(results.begin()[0], nullptr, 10) : 0);
+	}
+
+	static std::string BaseReplace()
+	{
+		return fmt::format(
+			"REPLACE INTO {} ({}) ",
+			TableName(),
+			ColumnsRaw()
+		);
+	}
+
+	static int ReplaceOne(
+		Database& db,
+		const ZoneFlags &e
+	)
+	{
+		std::vector<std::string> v;
+
+		v.push_back(std::to_string(e.charID));
+		v.push_back(std::to_string(e.zoneID));
+
+		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<ZoneFlags> &entries
+	)
+	{
+		std::vector<std::string> insert_chunks;
+
+		for (auto &e: entries) {
+			std::vector<std::string> v;
+
+			v.push_back(std::to_string(e.charID));
+			v.push_back(std::to_string(e.zoneID));
+
+			insert_chunks.push_back("(" + Strings::Implode(",", v) + ")");
+		}
+
+		std::vector<std::string> v;
+
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"{} VALUES {}",
+				BaseReplace(),
+				Strings::Implode(",", insert_chunks)
+			)
+		);
+
+		return (results.Success() ? results.RowsAffected() : 0);
+	}
+};
+
+#endif //EQEMU_BASE_ZONE_FLAGS_REPOSITORY_H
@@ -44,7 +44,46 @@ public:
     */

 	// Custom extended repository methods here
+	static bool SaveAllHelmAppearances(Database& db, const uint32 owner_id, const bool show_flag)
+	{
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"UPDATE `{}` SET `show_helm` = {} WHERE `owner_id` = {}",
+				TableName(),
+				show_flag ? 1 : 0,
+				owner_id
+			)
+		);

+		return results.Success();
+	}
+
+	static bool ToggleAllHelmAppearances(Database& db, const uint32 owner_id)
+	{
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"UPDATE `{}` SET `show_helm` = (`show_helm` XOR '1') WHERE `owner_id` = {}",
+				TableName(),
+				owner_id
+			)
+		);
+
+		return results.Success();
+	}
+
+	static bool SaveAllFollowDistances(Database& db, const uint32 owner_id, const uint32 follow_distance)
+	{
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"UPDATE `{}` SET `follow_distance` = {} WHERE `owner_id` = {}",
+				TableName(),
+				follow_distance,
+				owner_id
+			)
+		);
+
+		return results.Success();
+	}
 };

 #endif //EQEMU_BOT_DATA_REPOSITORY_H
@@ -44,7 +44,36 @@ public:
     */

 	// Custom extended repository methods here
+	static bool SaveAllInspectMessages(Database& db, const uint32 owner_id, const std::string& inspect_message)
+	{
+		auto results = db.QueryDatabase(
+			fmt::format(
+				SQL(
+					INSERT INTO `bot_inspect_messages` (`bot_id`, `inspect_message`) VALUES
+					(SELECT `bot_id`, '{}' inspect_message FROM `bot_data` WHERE `owner_id` = {})
+				),
+				inspect_message,
+				owner_id
+			)
+		);

+		return results.Success();
+	}
+
+	static bool DeleteAllInspectMessages(Database& db, const uint32 owner_id)
+	{
+		auto results = db.QueryDatabase(
+			fmt::format(
+				SQL(
+					DELETE FROM `bot_inspect_messages`
+					WHERE `bot_id` IN (SELECT `bot_id` FROM `bot_data` WHERE `owner_id` = {})
+				),
+				owner_id
+			)
+		);
+
+		return results.Success();
+	}
 };

 #endif //EQEMU_BOT_INSPECT_MESSAGES_REPOSITORY_H
@@ -44,7 +44,57 @@ public:
     */

 	// Custom extended repository methods here
+	static bool UpdateItemColors(Database& db, const uint32 bot_id, const uint32 color, const std::string& where_clause)
+	{
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"UPDATE `{}` SET `inst_color` = {} WHERE `bot_id` = {} AND `slot_id` {}",
+				TableName(),
+				color,
+				bot_id,
+				where_clause
+			)
+		);

+		return results.Success();
+	}
+
+	static bool SaveAllArmorColors(Database& db, const uint32 owner_id, const uint32 color)
+	{
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"UPDATE `{}` SET `inst_color` = {} WHERE `slot_id` IN ({}, {}, {}, {}, {}, {}, {}) AND `bot_id` IN (SELECT `bot_id` FROM `bot_data` WHERE `owner_id` = {})",
+				TableName(),
+				color,
+				EQ::invslot::slotHead,
+				EQ::invslot::slotChest,
+				EQ::invslot::slotArms,
+				EQ::invslot::slotWrist1,
+				EQ::invslot::slotWrist2,
+				EQ::invslot::slotHands,
+				EQ::invslot::slotLegs,
+				EQ::invslot::slotFeet,
+				owner_id
+			)
+		);
+
+		return results.Success();
+	}
+
+	static bool SaveAllArmorColorsBySlot(Database& db, const uint32 owner_id, const int16 slot_id, const uint32 color)
+	{
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"UPDATE `{}` SET `inst_color` = {} WHERE `slot_id` = {} AND `bot_id` IN (SELECT `bot_id` FROM `bot_data` WHERE `owner_id` = {})",
+				TableName(),
+				color,
+				slot_id,
+				owner_id
+			)
+		);
+
+		return results.Success();
+	}
 };

 #endif //EQEMU_BOT_INVENTORIES_REPOSITORY_H
@@ -65,7 +65,7 @@ public:
 			fmt::format(
 				"UPDATE `{}` SET `is_buried` = 1 WHERE `is_buried` = 0 AND (UNIX_TIMESTAMP() - UNIX_TIMESTAMP(time_of_death)) > {} AND time_of_death != 0",
 				TableName(),
-				RuleI(Character, CorpseDecayTimeMS) / 1000
+				RuleI(Character, CorpseDecayTime) / 1000
 			)
 		);

@@ -141,7 +141,7 @@ public:
 	{
 		db.QueryDatabase(
 			fmt::format(
-				"UPDATE `{}` SET `zone_id` = {}, `instance_id` = 0, `x` = {:.2f}, `y` = {:.2f}, `z` = {:.2f}`, `heading` = {:.2f}, `was_at_graveyard` = 1 WHERE `instance_id` = {}",
+				"UPDATE `{}` SET `zone_id` = {}, `instance_id` = 0, `x` = {:.2f}, `y` = {:.2f}, `z` = {:.2f}, `heading` = {:.2f}, `was_at_graveyard` = 1 WHERE `instance_id` = {}",
 				TableName(),
 				graveyard_zone_id,
 				position.x,
@@ -163,7 +163,7 @@ public:
 	{
 		db.QueryDatabase(
 			fmt::format(
-				"UPDATE `{}` SET `zone_id` = {}, `instance_id` = {}, `x` = {:.2f}, `y` = {:.2f}, `z` = {:.2f}`, `heading` = {:.2f}, `was_at_graveyard` = 1 WHERE `{}` = {}",
+				"UPDATE `{}` SET `zone_id` = {}, `instance_id` = {}, `x` = {:.2f}, `y` = {:.2f}, `z` = {:.2f}, `heading` = {:.2f}, `was_at_graveyard` = 1 WHERE `{}` = {}",
 				TableName(),
 				zone_id,
 				instance_id,
@@ -76,6 +76,48 @@ public:
 		return grid_entries;
 	}

+	static int GetHighestWaypoint(Database& db, uint32 zone_id, uint32 grid_id)
+	{
+		auto results = db.QueryDatabase(
+			fmt::format(
+				SQL(
+					SELECT COALESCE(MAX(`number`), 0) FROM `{}`
+					WHERE `zoneid` = {} AND `gridid` = {}
+				),
+				TableName(),
+				zone_id,
+				grid_id
+			)
+		);
+
+		if (!results.Success() || !results.RowCount()) {
+			return 0;
+		}
+
+		auto row = results.begin();
+
+		return Strings::ToInt(row[0]);
+	}
+
+	static int GetNextWaypoint(Database& db, uint32 zone_id, uint32 grid_id)
+	{
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"SELECT COALESCE(MAX(`number`), 0) FROM `{}` WHERE `zoneid` = {} AND `gridid` = {}",
+				TableName(),
+				zone_id,
+				grid_id
+			)
+		);
+
+		if (!results.Success() || !results.RowCount()) {
+			return 1;
+		}
+
+		auto row = results.begin();
+
+		return Strings::ToInt(row[0]) + 1;
+	}
 };

 #endif //EQEMU_GRID_ENTRIES_REPOSITORY_H
@@ -71,6 +71,27 @@ public:
 		return grids;
 	}

+	static int GetHighestGrid(Database& db, uint32 zone_id)
+	{
+		auto results = db.QueryDatabase(
+			fmt::format(
+				SQL(
+					SELECT COALESCE(MAX(`id`), 0) FROM `{}`
+					WHERE `zoneid` = {}
+				),
+				TableName(),
+				zone_id
+			)
+		);
+
+		if (!results.Success() || !results.RowCount()) {
+			return 0;
+		}
+
+		auto row = results.begin();
+
+		return Strings::ToInt(row[0]);
+	}
 };

 #endif //EQEMU_GRID_REPOSITORY_H
@@ -3,286 +3,47 @@

 #include "../database.h"
 #include "../strings.h"
+#include "base/base_guild_bank_repository.h"

-class GuildBankRepository {
+class GuildBankRepository: public BaseGuildBankRepository {
 public:
-	struct GuildBank {
-		int         guildid;
-		int8        area;
-		int         slot;
-		int         itemid;
-		int         qty;
-		std::string donator;
-		int8        permissions;
-		std::string whofor;
-	};

-	static std::string PrimaryKey()
-	{
-		return std::string("");
-	}
+    /**
+     * This file was auto generated and can be modified and extended upon
+     *
+     * Base repository methods are automatically
+     * generated in the "base" version of this repository. The base repository
+     * is immutable and to be left untouched, while methods in this class
+     * are used as extension methods for more specific persistence-layer
+     * accessors or mutators.
+     *
+     * Base Methods (Subject to be expanded upon in time)
+     *
+     * Note: Not all tables are designed appropriately to fit functionality with all base methods
+     *
+     * InsertOne
+     * UpdateOne
+     * DeleteOne
+     * FindOne
+     * GetWhere(std::string where_filter)
+     * DeleteWhere(std::string where_filter)
+     * InsertMany
+     * All
+     *
+     * Example custom methods in a repository
+     *
+     * GuildBankRepository::GetByZoneAndVersion(int zone_id, int zone_version)
+     * GuildBankRepository::GetWhereNeverExpires()
+     * GuildBankRepository::GetWhereXAndY()
+     * GuildBankRepository::DeleteWhereXAndY()
+     *
+     * Most of the above could be covered by base methods, but if you as a developer
+     * find yourself re-using logic for other parts of the code, its best to just make a
+     * method that can be re-used easily elsewhere especially if it can use a base repository
+     * method and encapsulate filters there
+     */

-	static std::vector<std::string> Columns()
-	{
-		return {
-			"guildid",
-			"area",
-			"slot",
-			"itemid",
-			"qty",
-			"donator",
-			"permissions",
-			"whofor",
-		};
-	}
-
-	static std::string ColumnsRaw()
-	{
-		return std::string(Strings::Implode(", ", Columns()));
-	}
-
-	static std::string InsertColumnsRaw()
-	{
-		std::vector<std::string> insert_columns;
-
-		for (auto &column : Columns()) {
-			if (column == PrimaryKey()) {
-				continue;
-			}
-
-			insert_columns.push_back(column);
-		}
-
-		return std::string(Strings::Implode(", ", insert_columns));
-	}
-
-	static std::string TableName()
-	{
-		return std::string("guild_bank");
-	}
-
-	static std::string BaseSelect()
-	{
-		return fmt::format(
-			"SELECT {} FROM {}",
-			ColumnsRaw(),
-			TableName()
-		);
-	}
-
-	static std::string BaseInsert()
-	{
-		return fmt::format(
-			"INSERT INTO {} ({}) ",
-			TableName(),
-			InsertColumnsRaw()
-		);
-	}
-
-	static GuildBank NewEntity()
-	{
-		GuildBank entry{};
-
-		entry.guildid     = 0;
-		entry.area        = 0;
-		entry.slot        = 0;
-		entry.itemid      = 0;
-		entry.qty         = 0;
-		entry.donator     = 0;
-		entry.permissions = 0;
-		entry.whofor      = 0;
-
-		return entry;
-	}
-
-	static GuildBank GetGuildBankEntry(
-		const std::vector<GuildBank> &guild_banks,
-		int guild_bank_id
-	)
-	{
-		for (auto &guild_bank : guild_banks) {
-			if (guild_bank. == guild_bank_id) {
-				return guild_bank;
-			}
-		}
-
-		return NewEntity();
-	}
-
-	static GuildBank FindOne(
-		int guild_bank_id
-	)
-	{
-		auto results = database.QueryDatabase(
-			fmt::format(
-				"{} WHERE id = {} LIMIT 1",
-				BaseSelect(),
-				guild_bank_id
-			)
-		);
-
-		auto row = results.begin();
-		if (results.RowCount() == 1) {
-			GuildBank entry{};
-
-			entry.guildid     = atoi(row[0]);
-			entry.area        = atoi(row[1]);
-			entry.slot        = atoi(row[2]);
-			entry.itemid      = atoi(row[3]);
-			entry.qty         = atoi(row[4]);
-			entry.donator     = row[5];
-			entry.permissions = atoi(row[6]);
-			entry.whofor      = row[7];
-
-			return entry;
-		}
-
-		return NewEntity();
-	}
-
-	static int DeleteOne(
-		int guild_bank_id
-	)
-	{
-		auto results = database.QueryDatabase(
-			fmt::format(
-				"DELETE FROM {} WHERE {} = {}",
-				TableName(),
-				PrimaryKey(),
-				guild_bank_id
-			)
-		);
-
-		return (results.Success() ? results.RowsAffected() : 0);
-	}
-
-	static int UpdateOne(
-		GuildBank guild_bank_entry
-	)
-	{
-		std::vector<std::string> update_values;
-
-		auto columns = Columns();
-
-		update_values.push_back(columns[0] + " = " + std::to_string(guild_bank_entry.guildid));
-		update_values.push_back(columns[1] + " = " + std::to_string(guild_bank_entry.area));
-		update_values.push_back(columns[2] + " = " + std::to_string(guild_bank_entry.slot));
-		update_values.push_back(columns[3] + " = " + std::to_string(guild_bank_entry.itemid));
-		update_values.push_back(columns[4] + " = " + std::to_string(guild_bank_entry.qty));
-		update_values.push_back(columns[5] + " = '" + Strings::Escape(guild_bank_entry.donator) + "'");
-		update_values.push_back(columns[6] + " = " + std::to_string(guild_bank_entry.permissions));
-		update_values.push_back(columns[7] + " = '" + Strings::Escape(guild_bank_entry.whofor) + "'");
-
-		auto results = database.QueryDatabase(
-			fmt::format(
-				"UPDATE {} SET {} WHERE {} = {}",
-				TableName(),
-				Strings::Implode(", ", update_values),
-				PrimaryKey(),
-				guild_bank_entry.
-			)
-		);
-
-		return (results.Success() ? results.RowsAffected() : 0);
-	}
-
-	static GuildBank InsertOne(
-		GuildBank guild_bank_entry
-	)
-	{
-		std::vector<std::string> insert_values;
-
-		insert_values.push_back(std::to_string(guild_bank_entry.guildid));
-		insert_values.push_back(std::to_string(guild_bank_entry.area));
-		insert_values.push_back(std::to_string(guild_bank_entry.slot));
-		insert_values.push_back(std::to_string(guild_bank_entry.itemid));
-		insert_values.push_back(std::to_string(guild_bank_entry.qty));
-		insert_values.push_back("'" + Strings::Escape(guild_bank_entry.donator) + "'");
-		insert_values.push_back(std::to_string(guild_bank_entry.permissions));
-		insert_values.push_back("'" + Strings::Escape(guild_bank_entry.whofor) + "'");
-
-		auto results = database.QueryDatabase(
-			fmt::format(
-				"{} VALUES ({})",
-				BaseInsert(),
-				Strings::Implode(",", insert_values)
-			)
-		);
-
-		if (results.Success()) {
-			guild_bank_entry.id = results.LastInsertedID();
-			return guild_bank_entry;
-		}
-
-		guild_bank_entry = InstanceListRepository::NewEntity();
-
-		return guild_bank_entry;
-	}
-
-	static int InsertMany(
-		std::vector<GuildBank> guild_bank_entries
-	)
-	{
-		std::vector<std::string> insert_chunks;
-
-		for (auto &guild_bank_entry: guild_bank_entries) {
-			std::vector<std::string> insert_values;
-
-			insert_values.push_back(std::to_string(guild_bank_entry.guildid));
-			insert_values.push_back(std::to_string(guild_bank_entry.area));
-			insert_values.push_back(std::to_string(guild_bank_entry.slot));
-			insert_values.push_back(std::to_string(guild_bank_entry.itemid));
-			insert_values.push_back(std::to_string(guild_bank_entry.qty));
-			insert_values.push_back("'" + Strings::Escape(guild_bank_entry.donator) + "'");
-			insert_values.push_back(std::to_string(guild_bank_entry.permissions));
-			insert_values.push_back("'" + Strings::Escape(guild_bank_entry.whofor) + "'");
-
-			insert_chunks.push_back("(" + Strings::Implode(",", insert_values) + ")");
-		}
-
-		std::vector<std::string> insert_values;
-
-		auto results = database.QueryDatabase(
-			fmt::format(
-				"{} VALUES {}",
-				BaseInsert(),
-				Strings::Implode(",", insert_chunks)
-			)
-		);
-
-		return (results.Success() ? results.RowsAffected() : 0);
-	}
-
-	static std::vector<GuildBank> All()
-	{
-		std::vector<GuildBank> all_entries;
-
-		auto results = database.QueryDatabase(
-			fmt::format(
-				"{}",
-				BaseSelect()
-			)
-		);
-
-		all_entries.reserve(results.RowCount());
-
-		for (auto row = results.begin(); row != results.end(); ++row) {
-			GuildBank entry{};
-
-			entry.guildid     = atoi(row[0]);
-			entry.area        = atoi(row[1]);
-			entry.slot        = atoi(row[2]);
-			entry.itemid      = atoi(row[3]);
-			entry.qty         = atoi(row[4]);
-			entry.donator     = row[5];
-			entry.permissions = atoi(row[6]);
-			entry.whofor      = row[7];
-
-			all_entries.push_back(entry);
-		}
-
-		return all_entries;
-	}
+	// Custom extended repository methods here

 };

@@ -0,0 +1,194 @@
+#ifndef EQEMU_GUILD_MEMBERS_REPOSITORY_H
+#define EQEMU_GUILD_MEMBERS_REPOSITORY_H
+
+#include "../database.h"
+#include "../strings.h"
+#include "base/base_guild_members_repository.h"
+
+class GuildMembersRepository : public BaseGuildMembersRepository {
+public:
+
+	struct GuildMembersWithTributeOnStruct {
+		int32_t     char_id;
+		uint32_t    guild_id;
+		uint8_t     tribute_enable;
+		std::string char_name;
+		uint32_t    char_level;
+	};
+
+	struct GuildMembershipStatsStruct {
+		uint32 leaders;
+		uint32 senior_officers;
+		uint32 officers;
+		uint32 senior_members;
+		uint32 members;
+		uint32 junior_members;
+		uint32 initates;
+		uint32 recruits;
+		uint32 tribute_enabled;
+	};
+
+	static int UpdateMemberRank(Database &db, uint32 char_id, uint32 rank_id)
+	{
+		const auto guild_members = GetWhere(db, fmt::format("char_id = '{}'", char_id));
+		if (guild_members.empty()) {
+			return 0;
+		}
+
+		auto m = guild_members[0];
+		m.rank_ = rank_id;
+
+		return UpdateOne(db, m);
+	}
+
+	static int UpdateEnabled(Database &db, uint32 guild_id, uint32 char_id, uint32 enabled)
+	{
+		const auto guild_members = GetWhere(db, fmt::format("char_id = '{}' AND guild_id = '{}'", char_id, guild_id));
+		if (guild_members.empty()) {
+			return 0;
+		}
+
+		auto m = guild_members[0];
+		m.tribute_enable = enabled ? 1 : 0;
+
+		return UpdateOne(db, m);
+	}
+
+	static std::vector<GuildMembersWithTributeOnStruct> GetMembersWithTributeOn(Database &db, uint32 guild_id)
+	{
+		std::vector<GuildMembersWithTributeOnStruct> all_entries;
+
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"SELECT gm.char_id, gm.guild_id, gm.tribute_enable, cd.`name`, cd.`level`, cd.deleted_at "
+				"FROM guild_members gm JOIN character_data cd ON cd.id = gm.char_id "
+				"WHERE ISNULL(cd.deleted_at) AND gm.tribute_enable = 1 AND gm.guild_id = '{}';",
+				guild_id
+			)
+		);
+
+		all_entries.reserve(results.RowCount());
+
+		for (auto row = results.begin(); row != results.end(); ++row) {
+			GuildMembersWithTributeOnStruct e{};
+
+			e.char_id        = static_cast<int32_t>(atoi(row[0]));
+			e.guild_id       = static_cast<uint32_t>(strtoul(row[1], nullptr, 10));
+			e.tribute_enable = static_cast<uint8_t>(strtoul(row[2], nullptr, 10));
+			e.char_name      = row[3] ? row[3] : "";
+			e.char_level     = static_cast<uint32_t>(strtoul(row[4], nullptr, 10));
+
+			all_entries.push_back(e);
+		}
+
+		return all_entries;
+	}
+
+	static int UpdateFavor(Database &db, uint32 guild_id, uint32 char_id, uint32 favor)
+	{
+		const auto guild_members = GetWhere(db, fmt::format("char_id = '{}' AND guild_id = '{}'", char_id, guild_id));
+		if (guild_members.empty()) {
+			return 0;
+		}
+
+		auto m = guild_members[0];
+		m.total_tribute = favor;
+		m.last_tribute  = time(nullptr);
+
+		return UpdateOne(db, m);
+	}
+
+	static int UpdateOnline(Database &db, uint32 char_id, bool status)
+	{
+		const auto guild_members = GetWhere(db, fmt::format("char_id = '{}'", char_id));
+		if (guild_members.empty()) {
+			return 0;
+		}
+
+		auto m = guild_members[0];
+		m.online = status ? 1 : 0;
+
+		return UpdateOne(db, m);
+	}
+
+	static int UpdateNote(Database &db, uint32 char_id, std::string &public_note)
+	{
+		const auto guild_members = GetWhere(db, fmt::format("char_id = '{}'", char_id));
+		if (guild_members.empty()) {
+			return 0;
+		}
+
+		auto m = guild_members[0];
+		m.public_note = public_note;
+
+		return UpdateOne(db, m);
+	}
+
+	static GuildMembershipStatsStruct GetGuildMembershipStats(Database &db, uint32 guild_id)
+	{
+		std::string query = fmt::format(
+			"SELECT "
+			"SUM(CASE WHEN gm.`rank` = 1 THEN 1 ELSE 0 END) AS RANK1, "
+			"SUM(CASE WHEN gm.`rank` = 2 THEN 1 ELSE 0 END) AS RANK2, "
+			"SUM(CASE WHEN gm.`rank` = 3 THEN 1 ELSE 0 END) AS RANK3, "
+			"SUM(CASE WHEN gm.`rank` = 4 THEN 1 ELSE 0 END) AS RANK4, "
+			"SUM(CASE WHEN gm.`rank` = 5 THEN 1 ELSE 0 END) AS RANK5, "
+			"SUM(CASE WHEN gm.`rank` = 6 THEN 1 ELSE 0 END) AS RANK6, "
+			"SUM(CASE WHEN gm.`rank` = 7 THEN 1 ELSE 0 END) AS RANK7, "
+			"SUM(CASE WHEN gm.`rank` = 8 THEN 1 ELSE 0 END) AS RANK8, "
+			"SUM(CASE WHEN gm.tribute_enable = 1 THEN 1 ELSE 0 END) AS TRIBUTE "
+			"FROM guild_members gm "
+			"WHERE gm.guild_id = '{}';",
+			guild_id
+		);
+
+		GuildMembershipStatsStruct gmss{};
+
+		auto results = db.QueryDatabase(query);
+		if (!results.Success()) {
+			return gmss;
+		}
+
+		for (auto row = results.begin(); row != results.end(); ++row) {
+
+			gmss.leaders         = static_cast<uint32_t>(Strings::ToUnsignedInt(row[0]));
+			gmss.senior_officers = static_cast<uint32_t>(Strings::ToUnsignedInt(row[1]));
+			gmss.officers        = static_cast<uint32_t>(Strings::ToUnsignedInt(row[2]));
+			gmss.senior_members  = static_cast<uint32_t>(Strings::ToUnsignedInt(row[3]));
+			gmss.members         = static_cast<uint32_t>(Strings::ToUnsignedInt(row[4]));
+			gmss.junior_members  = static_cast<uint32_t>(Strings::ToUnsignedInt(row[5]));
+			gmss.initates        = static_cast<uint32_t>(Strings::ToUnsignedInt(row[6]));
+			gmss.recruits        = static_cast<uint32_t>(Strings::ToUnsignedInt(row[7]));
+			gmss.tribute_enabled = static_cast<uint32_t>(Strings::ToUnsignedInt(row[8]));
+		}
+
+		return gmss;
+	}
+
+	static int UpdateBankerFlag(Database &db, uint32 char_id, bool status)
+	{
+		const auto guild_members = GetWhere(db, fmt::format("char_id = {}", char_id));
+		if (guild_members.empty()) {
+			return 0;
+		}
+
+		auto m = guild_members[0];
+		m.banker = status ? 1 : 0;
+
+		return UpdateOne(db, m);
+	}
+
+	static int UpdateAltFlag(Database &db, uint32 char_id, bool status)
+	{
+		const auto guild_members = GetWhere(db, fmt::format("char_id = {}", char_id));
+		if (guild_members.empty()) {
+			return 0;
+		}
+
+		auto m = guild_members[0];
+		m.alt = status ? 1 : 0;
+
+		return UpdateOne(db, m);
+	}
+};
+#endif //EQEMU_GUILD_MEMBERS_REPOSITORY_H
@@ -0,0 +1,50 @@
+#ifndef EQEMU_GUILD_PERMISSIONS_REPOSITORY_H
+#define EQEMU_GUILD_PERMISSIONS_REPOSITORY_H
+
+#include "../database.h"
+#include "../strings.h"
+#include "base/base_guild_permissions_repository.h"
+
+class GuildPermissionsRepository: public BaseGuildPermissionsRepository {
+public:
+
+    /**
+     * This file was auto generated and can be modified and extended upon
+     *
+     * Base repository methods are automatically
+     * generated in the "base" version of this repository. The base repository
+     * is immutable and to be left untouched, while methods in this class
+     * are used as extension methods for more specific persistence-layer
+     * accessors or mutators.
+     *
+     * Base Methods (Subject to be expanded upon in time)
+     *
+     * Note: Not all tables are designed appropriately to fit functionality with all base methods
+     *
+     * InsertOne
+     * UpdateOne
+     * DeleteOne
+     * FindOne
+     * GetWhere(std::string where_filter)
+     * DeleteWhere(std::string where_filter)
+     * InsertMany
+     * All
+     *
+     * Example custom methods in a repository
+     *
+     * GuildPermissionsRepository::GetByZoneAndVersion(int zone_id, int zone_version)
+     * GuildPermissionsRepository::GetWhereNeverExpires()
+     * GuildPermissionsRepository::GetWhereXAndY()
+     * GuildPermissionsRepository::DeleteWhereXAndY()
+     *
+     * Most of the above could be covered by base methods, but if you as a developer
+     * find yourself re-using logic for other parts of the code, its best to just make a
+     * method that can be re-used easily elsewhere especially if it can use a base repository
+     * method and encapsulate filters there
+     */
+
+	// Custom extended repository methods here
+
+};
+
+#endif //EQEMU_GUILD_PERMISSIONS_REPOSITORY_H
@@ -45,6 +45,21 @@ public:

 	// Custom extended repository methods here

+	static int UpdateTitle(Database &db, uint32 guild_id, uint32 rank, std::string title)
+	{
+		auto guild_rank = GetWhere(db, fmt::format("guild_id = '{}' AND rank = '{}'", guild_id, rank));
+		if (guild_rank.empty()) {
+			return 0;
+		}
+
+		auto r = guild_rank[0];
+		r.title = title;
+
+		DeleteWhere(db, fmt::format("guild_id = '{}' AND rank = '{}'", guild_id, rank));
+		InsertOne(db, r);
+
+		return 1;
+	}
 };

 #endif //EQEMU_GUILD_RANKS_REPOSITORY_H
@@ -0,0 +1,77 @@
+#ifndef EQEMU_GUILD_TRIBUTES_REPOSITORY_H
+#define EQEMU_GUILD_TRIBUTES_REPOSITORY_H
+
+#include "../database.h"
+#include "../strings.h"
+#include "base/base_guild_tributes_repository.h"
+
+class GuildTributesRepository: public BaseGuildTributesRepository {
+public:
+
+    /**
+     * This file was auto generated and can be modified and extended upon
+     *
+     * Base repository methods are automatically
+     * generated in the "base" version of this repository. The base repository
+     * is immutable and to be left untouched, while methods in this class
+     * are used as extension methods for more specific persistence-layer
+     * accessors or mutators.
+     *
+     * Base Methods (Subject to be expanded upon in time)
+     *
+     * Note: Not all tables are designed appropriately to fit functionality with all base methods
+     *
+     * InsertOne
+     * UpdateOne
+     * DeleteOne
+     * FindOne
+     * GetWhere(std::string where_filter)
+     * DeleteWhere(std::string where_filter)
+     * InsertMany
+     * All
+     *
+     * Example custom methods in a repository
+     *
+     * GuildTributesRepository::GetByZoneAndVersion(int zone_id, int zone_version)
+     * GuildTributesRepository::GetWhereNeverExpires()
+     * GuildTributesRepository::GetWhereXAndY()
+     * GuildTributesRepository::DeleteWhereXAndY()
+     *
+     * Most of the above could be covered by base methods, but if you as a developer
+     * find yourself re-using logic for other parts of the code, its best to just make a
+     * method that can be re-used easily elsewhere especially if it can use a base repository
+     * method and encapsulate filters there
+     */
+
+	// Custom extended repository methods here
+	static int UpdateEnabled(Database& db, uint32 guild_id, uint32 enabled)
+	{
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"UPDATE {} SET `enabled` = '{}' WHERE `guild_id` = {}",
+				TableName(),
+				enabled,
+				guild_id
+			)
+		);
+
+		return (results.Success() ? results.RowsAffected() : 0);
+	}
+
+	static int UpdateTimeRemaining(Database& db, uint32 guild_id, uint32 time_remaining)
+	{
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"UPDATE {} SET `time_remaining` = '{}' WHERE `guild_id` = {}",
+				TableName(),
+				time_remaining,
+				guild_id
+			)
+		);
+
+		return (results.Success() ? results.RowsAffected() : 0);
+	}
+
+};
+
+#endif //EQEMU_GUILD_TRIBUTES_REPOSITORY_H
@@ -5,46 +5,58 @@
 #include "../strings.h"
 #include "base/base_guilds_repository.h"

-class GuildsRepository: public BaseGuildsRepository {
+class GuildsRepository : public BaseGuildsRepository {
 public:

-    /**
-     * This file was auto generated and can be modified and extended upon
-     *
-     * Base repository methods are automatically
-     * generated in the "base" version of this repository. The base repository
-     * is immutable and to be left untouched, while methods in this class
-     * are used as extension methods for more specific persistence-layer
-     * accessors or mutators.
-     *
-     * Base Methods (Subject to be expanded upon in time)
-     *
-     * Note: Not all tables are designed appropriately to fit functionality with all base methods
-     *
-     * InsertOne
-     * UpdateOne
-     * DeleteOne
-     * FindOne
-     * GetWhere(std::string where_filter)
-     * DeleteWhere(std::string where_filter)
-     * InsertMany
-     * All
-     *
-     * Example custom methods in a repository
-     *
-     * GuildsRepository::GetByZoneAndVersion(int zone_id, int zone_version)
-     * GuildsRepository::GetWhereNeverExpires()
-     * GuildsRepository::GetWhereXAndY()
-     * GuildsRepository::DeleteWhereXAndY()
-     *
-     * Most of the above could be covered by base methods, but if you as a developer
-     * find yourself re-using logic for other parts of the code, its best to just make a
-     * method that can be re-used easily elsewhere especially if it can use a base repository
-     * method and encapsulate filters there
-     */
+	/**
+	 * This file was auto generated and can be modified and extended upon
+	 *
+	 * Base repository methods are automatically
+	 * generated in the "base" version of this repository. The base repository
+	 * is immutable and to be left untouched, while methods in this class
+	 * are used as extension methods for more specific persistence-layer
+	 * accessors or mutators.
+	 *
+	 * Base Methods (Subject to be expanded upon in time)
+	 *
+	 * Note: Not all tables are designed appropriately to fit functionality with all base methods
+	 *
+	 * InsertOne
+	 * UpdateOne
+	 * DeleteOne
+	 * FindOne
+	 * GetWhere(std::string where_filter)
+	 * DeleteWhere(std::string where_filter)
+	 * InsertMany
+	 * All
+	 *
+	 * Example custom methods in a repository
+	 *
+	 * GuildsRepository::GetByZoneAndVersion(int zone_id, int zone_version)
+	 * GuildsRepository::GetWhereNeverExpires()
+	 * GuildsRepository::GetWhereXAndY()
+	 * GuildsRepository::DeleteWhereXAndY()
+	 *
+	 * Most of the above could be covered by base methods, but if you as a developer
+	 * find yourself re-using logic for other parts of the code, its best to just make a
+	 * method that can be re-used easily elsewhere especially if it can use a base repository
+	 * method and encapsulate filters there
+	 */

-	// Custom extended repository methods here
+	 // Custom extended repository methods here

+	static int UpdateFavor(Database &db, uint32 guild_id, uint32 favor)
+	{
+		auto const guild = GetWhere(db, fmt::format("id = '{}'", guild_id));
+		if (guild.empty()) {
+			return 0;
+		}
+
+		auto g = guild[0];
+		g.favor = favor;
+
+		return UpdateOne(db, g);
+	}
 };

 #endif //EQEMU_GUILDS_REPOSITORY_H
@@ -45,14 +45,41 @@ public:

 	// Custom extended repository methods here

-	static int UpdateDuration(Database& db, int instance_id, uint32_t new_duration)
+	static int UpdateDuration(Database& db, uint16 instance_id, uint32_t new_duration)
 	{
-		auto results = db.QueryDatabase(fmt::format(
-			"UPDATE {} SET duration = {} WHERE {} = {};",
-			TableName(), new_duration, PrimaryKey(), instance_id
-		));
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"UPDATE `{}` SET `duration` = {} WHERE `{}` = {}",
+				TableName(),
+				new_duration,
+				PrimaryKey(),
+				instance_id
+			)
+		);

-		return (results.Success() ? results.RowsAffected() : 0);
+		return results.Success() ? results.RowsAffected() : 0;
+	}
+
+	static uint32 GetRemainingTimeByInstanceID(Database& db, uint16 instance_id)
+	{
+		auto results = db.QueryDatabase(
+			fmt::format(
+				SQL(
+					SELECT ((start_time + duration) - UNIX_TIMESTAMP()) AS `remaining` FROM `{}`
+					WHERE `id` = {}
+				),
+				TableName(),
+				instance_id
+			)
+		);
+
+		if (!results.Success() || !results.RowCount()) {
+			return 0;
+		}
+
+		auto row = results.begin();
+
+		return Strings::ToUnsignedInt(row[0]);
 	}
 };

@@ -8,42 +8,24 @@
 class LootdropEntriesRepository: public BaseLootdropEntriesRepository {
 public:

-    /**
-     * This file was auto generated and can be modified and extended upon
-     *
-     * Base repository methods are automatically
-     * generated in the "base" version of this repository. The base repository
-     * is immutable and to be left untouched, while methods in this class
-     * are used as extension methods for more specific persistence-layer
-     * accessors or mutators.
-     *
-     * Base Methods (Subject to be expanded upon in time)
-     *
-     * Note: Not all tables are designed appropriately to fit functionality with all base methods
-     *
-     * InsertOne
-     * UpdateOne
-     * DeleteOne
-     * FindOne
-     * GetWhere(std::string where_filter)
-     * DeleteWhere(std::string where_filter)
-     * InsertMany
-     * All
-     *
-     * Example custom methods in a repository
-     *
-     * LootdropEntriesRepository::GetByZoneAndVersion(int zone_id, int zone_version)
-     * LootdropEntriesRepository::GetWhereNeverExpires()
-     * LootdropEntriesRepository::GetWhereXAndY()
-     * LootdropEntriesRepository::DeleteWhereXAndY()
-     *
-     * Most of the above could be covered by base methods, but if you as a developer
-     * find yourself re-using logic for other parts of the code, its best to just make a
-     * method that can be re-used easily elsewhere especially if it can use a base repository
-     * method and encapsulate filters there
-     */
+	static LootdropEntries NewNpcEntity()
+	{
+		LootdropEntries e{};

-	// Custom extended repository methods here
+		e.lootdrop_id       = 0;
+		e.item_id           = 0;
+		e.item_charges      = 1;
+		e.equip_item        = 1;
+		e.chance            = 0;
+		e.disabled_chance   = 0;
+		e.trivial_min_level = 0;
+		e.trivial_max_level = 0;
+		e.multiplier        = 0;
+		e.npc_min_level     = 0;
+		e.npc_max_level     = 0;
+
+		return e;
+	}

 };

@@ -44,7 +44,35 @@ public:
     */

 	// Custom extended repository methods here
+	static uint32 GetPathGridBySpawn2ID(Database& db, uint32 spawn2_id)
+	{
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"SELECT `pathgrid` FROM `{}` WHERE `id` = {}",
+				TableName(),
+				spawn2_id
+			)
+		);

+		if (!results.Success() || !results.RowCount()) {
+			return 0;
+		}
+
+		auto row = results.begin();
+
+		return Strings::ToUnsignedInt(row[0]);
+	}
+
+	static void SetPathGridBySpawn2ID(Database& db, uint32 spawn2_id, uint32 grid_id)
+	{
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"UPDATE `spawn2` SET `pathgrid` = {} WHERE `id` = {}",
+				grid_id,
+				spawn2_id
+			)
+		);
+	}
 };

 #endif //EQEMU_SPAWN2_REPOSITORY_H
@@ -0,0 +1,50 @@
+#ifndef EQEMU_ZONE_FLAGS_REPOSITORY_H
+#define EQEMU_ZONE_FLAGS_REPOSITORY_H
+
+#include "../database.h"
+#include "../strings.h"
+#include "base/base_zone_flags_repository.h"
+
+class ZoneFlagsRepository: public BaseZoneFlagsRepository {
+public:
+
+    /**
+     * This file was auto generated and can be modified and extended upon
+     *
+     * Base repository methods are automatically
+     * generated in the "base" version of this repository. The base repository
+     * is immutable and to be left untouched, while methods in this class
+     * are used as extension methods for more specific persistence-layer
+     * accessors or mutators.
+     *
+     * Base Methods (Subject to be expanded upon in time)
+     *
+     * Note: Not all tables are designed appropriately to fit functionality with all base methods
+     *
+     * InsertOne
+     * UpdateOne
+     * DeleteOne
+     * FindOne
+     * GetWhere(std::string where_filter)
+     * DeleteWhere(std::string where_filter)
+     * InsertMany
+     * All
+     *
+     * Example custom methods in a repository
+     *
+     * ZoneFlagsRepository::GetByZoneAndVersion(int zone_id, int zone_version)
+     * ZoneFlagsRepository::GetWhereNeverExpires()
+     * ZoneFlagsRepository::GetWhereXAndY()
+     * ZoneFlagsRepository::DeleteWhereXAndY()
+     *
+     * Most of the above could be covered by base methods, but if you as a developer
+     * find yourself re-using logic for other parts of the code, its best to just make a
+     * method that can be re-used easily elsewhere especially if it can use a base repository
+     * method and encapsulate filters there
+     */
+
+	// Custom extended repository methods here
+
+};
+
+#endif //EQEMU_ZONE_FLAGS_REPOSITORY_H
@@ -47,8 +47,11 @@ RULE_INT(Character, DeathExpLossMultiplier, 3, "Adjust how much experience is lo
 RULE_BOOL(Character, DeathKeepLevel, false, "Players can not drop below 0% experience from death.")
 RULE_BOOL(Character, UseDeathExpLossMult, false, "Setting to control whether DeathExpLossMultiplier or the code default is used: (Level x Level / 18.0) x 12000")
 RULE_BOOL(Character, UseOldRaceRezEffects, false, "Older clients had ID 757 for races with high starting STR, but it doesn't seem used anymore")
-RULE_INT(Character, CorpseDecayTimeMS, 10800000, "Time after which the corpse decays (milliseconds)")
-RULE_INT(Character, CorpseResTimeMS, 10800000, "Time after which the corpse can no longer be resurrected (milliseconds)")
+RULE_INT(Character, CorpseDecayTime, 604800000, "Time after which the corpse decays (milliseconds) DEFAULT: 604800000 (7 Days)")
+RULE_INT( Character, EmptyCorpseDecayTime, 10800000, "Time after which an empty corpse decays (milliseconds) DEFAULT: 10800000 (3 Hours)")
+RULE_INT(Character, CorpseResTime, 10800000, "Time after which the corpse can no longer be resurrected (milliseconds) DEFAULT: 10800000 (3 Hours)")
+RULE_INT( Character, DuelCorpseResTime, 600000, "Time before cant res corpse after a duel (milliseconds) DEFAULT: 600000 (10 Minutes)")
+RULE_INT( Character, CorpseOwnerOnlineTime, 30000, "How often corpse will check if its owner is online DEFAULT: 30000 (30 Seconds)")
 RULE_BOOL(Character, LeaveCorpses, true, "Setting whether you leave a corpse behind")
 RULE_BOOL(Character, LeaveNakedCorpses, false, "Setting whether you leave a corpse without items")
 RULE_INT(Character, MaxDraggedCorpses, 2, "Maximum number of corpses you can drag at once")
@@ -242,6 +245,10 @@ RULE_INT(Guild, PlayerCreationLimit, 1, "Only allow use of the UF+ window if the
 RULE_INT(Guild, PlayerCreationRequiredStatus, 0, "Required status to create a guild")
 RULE_INT(Guild, PlayerCreationRequiredLevel, 0, "Required level of the player attempting to create the guild")
 RULE_INT(Guild, PlayerCreationRequiredTime, 0, "Time needed online on the account to create a guild (in minutes)")
+RULE_INT(Guild, TributeTime, 600000, "Time in ms for guild tributes.  Default is 10 mins.")
+RULE_INT(Guild, TributeTimeRefreshInterval, 180000, "Time in ms to send all guild members a Tribute Time refresh. Default is 3 mins.")
+RULE_INT(Guild, TributePlatConversionRate, 10, "The conversion rate of platinum donations.  Default is 10 guild favor to 1 platinum.")
+RULE_BOOL(Guild, UseCharacterMaxLevelForGuildTributes, true, "Guild Tributes will adhere to Character:MaxLevel.  Default is true.")
 RULE_CATEGORY_END()

 RULE_CATEGORY(Skills)
@@ -259,6 +266,7 @@ RULE_BOOL(Skills, RequireTomeHandin, false, "Disable click-to-learn and force ha
 RULE_INT(Skills, TradeSkillClamp, 0, "Legacy tradeskills would clamp at 252 regardless of item modifiers and skill combination. DEFAULT: 0 will bypass clamp. Legacy value 252")
 RULE_BOOL(Skills, UseAltSinisterStrikeFormula, false, "Enabling will utilize a formula derived from 2004 monkey business post which makes the AA actually worth something.")
 RULE_BOOL(Skills, TrackingAutoRefreshSkillUps, true, "Disable to prevent tracking auto-refresh from giving skill-ups. Classic Style")
+RULE_INT(Skills, MaximumTauntDistance, 150, "Maximum player taunt distance.")
 RULE_CATEGORY_END()

 RULE_CATEGORY(Pets)
@@ -269,6 +277,7 @@ RULE_BOOL(Pets, CanTakeNoDrop, false, "Setting whether anyone can give no-drop i
 RULE_BOOL(Pets, CanTakeQuestItems, true, "Setting whether anyone can give quest items to pets")
 RULE_BOOL(Pets, LivelikeBreakCharmOnInvis, true, "Default: true will break charm on any type of invis (hide/ivu/iva/etc) false will only break if the pet can not see you (ex. you have an undead pet and cast IVU")
 RULE_BOOL(Pets, ClientPetsUseOwnerNameInLastName, true, "Disable this to keep client pet's last names from being owner_name's pet")
+RULE_INT(Pets, PetTauntRange, 150, "Range at which a pet will taunt targets.")
 RULE_CATEGORY_END()

 RULE_CATEGORY(GM)
@@ -340,6 +349,9 @@ RULE_INT(Zone, GlobalLootMultiplier, 1, "Sets Global Loot drop multiplier for da
 RULE_BOOL(Zone, KillProcessOnDynamicShutdown, true, "When process has booted a zone and has hit its zone shut down timer, it will hard kill the process to free memory back to the OS")
 RULE_INT(Zone, SpawnEventMin, 3, "When strict is set in spawn_events, specifies the max EQ minutes into the trigger hour a spawn_event will fire. Going below 3 may cause the spawn_event to not fire.")
 RULE_INT(Zone, ForageChance, 25, "Chance of foraging from zone table vs global table")
+RULE_BOOL(Zone, AllowCrossZoneSpellsOnBots, false, "Set to true to allow cross zone spells (cast/remove) to affect bots")
+RULE_BOOL(Zone, AllowCrossZoneSpellsOnMercs, false, "Set to true to allow cross zone spells (cast/remove) to affect mercenaries")
+RULE_BOOL(Zone, AllowCrossZoneSpellsOnPets, false, "Set to true to allow cross zone spells (cast/remove) to affect pets")
 RULE_CATEGORY_END()

 RULE_CATEGORY(Map)
@@ -483,6 +495,7 @@ RULE_BOOL(Spells, EvacClearCharmPet, false, "Enable to have evac in zone clear c
 RULE_BOOL(Spells, ManaTapsRequireNPCMana, false, "Enabling will require target to have mana to tap. Default off as many npc's are caster class with 0 mana and need fixed.")
 RULE_INT(Spells, HarmTouchCritRatio, 200, "Harmtouch crit bonus, on top of BaseCritRatio")
 RULE_BOOL(Spells, UseClassicSpellFocus, false, "Enabling will tell the server to handle random focus damage as classic spell imports lack the limit values.")
+RULE_BOOL(Spells, ManaTapsOnAnyClass, false, "Enabling this will allow you to cast mana taps on any class, this will bypass ManaTapsRequireNPCMana rule.")
 RULE_CATEGORY_END()

 RULE_CATEGORY(Combat)
@@ -521,6 +534,8 @@ RULE_REAL(Combat, DefProcPerMinAgiContrib, 0.075, "How much agility contributes
 RULE_INT(Combat, NPCFlurryChance, 20, "Chance for NPC to flurry")
 RULE_BOOL(Combat, TauntOverLevel, 1, "Allows you to taunt NPC's over warriors level")
 RULE_INT(Combat, TauntOverAggro, 0, "+ amount over hate_top it will add before any bonus hate.")
+RULE_INT(Combat, TauntChanceBonus, 0, "Bonus to taunt chance")
+RULE_BOOL(Combat, ClassicTauntSystem, false, "Enable to use the pre 2006 taunt system.")
 RULE_REAL(Combat, TauntSkillFalloff, 0.33, "For every taunt skill point that's not maxed you lose this percentage chance to taunt")
 RULE_BOOL(Combat, EXPFromDmgShield, false, "Determine if damage from a damage shield counts for experience gain")
 RULE_INT(Combat, QuiverHasteCap, 1000, "Quiver haste cap 1000 on live for a while, currently 700 on live")
@@ -575,10 +590,10 @@ RULE_REAL(Combat, BashACBonusDivisor, 25.0, "this divides the AC value contribut
 RULE_CATEGORY_END()

 RULE_CATEGORY(NPC)
-RULE_INT(NPC, MinorNPCCorpseDecayTimeMS, 450000, "NPC corpse decay time, if NPC below level 55 (milliseconds)")
-RULE_INT(NPC, MajorNPCCorpseDecayTimeMS, 1500000, "NPC corpse decay time, if NPC equal or greater than level 55 (milliseconds)")
+RULE_INT(NPC, MinorNPCCorpseDecayTime, 450000, "NPC corpse decay time, if NPC below level 55 (milliseconds)")
+RULE_INT(NPC, MajorNPCCorpseDecayTime, 1500000, "NPC corpse decay time, if NPC equal or greater than level 55 (milliseconds)")
 RULE_INT(NPC, CorpseUnlockTimer, 150000, "Time after which corpses are unlocked for everyone to loot (milliseconds)")
-RULE_INT(NPC, EmptyNPCCorpseDecayTimeMS, 0, "NPC corpse decay time, if no items are left on the corpse (milliseconds)")
+RULE_INT(NPC, EmptyNPCCorpseDecayTime, 0, "NPC corpse decay time, if no items are left on the corpse (milliseconds)")
 RULE_BOOL(NPC, UseItemBonusesForNonPets, true, "Switch whether item bonuses should be used for NPCs who are not pets")
 RULE_BOOL(NPC, UseBaneDamage, false, "If NPCs can't inherently hit the target we don't add bane/magic dmg which isn't exactly the same as PCs")
 RULE_INT(NPC, SayPauseTimeInSec, 5, "Time span in which an NPC pauses his movement after a Say event without aggro (seconds)")
@@ -680,7 +695,6 @@ RULE_BOOL(Bots, BotGroupXP, false, "Determines whether client gets experience fo
 RULE_BOOL(Bots, BotLevelsWithOwner, false, "Auto-updates spawned bots as owner levels/de-levels (false is original behavior)")
 RULE_INT(Bots, BotCharacterLevel, 0, "If level is greater that value player can spawn bots if BotCharacterLevelEnabled is true")
 RULE_INT(Bots, CasterStopMeleeLevel, 13, "Level at which caster bots stop melee attacks")
-RULE_BOOL(Bots, AllowOwnerOptionAltCombat, true, "When option is enabled, bots will use an auto-/shared-aggro combat model")
 RULE_BOOL(Bots, AllowOwnerOptionAutoDefend, true, "When option is enabled, bots will defend their owner on enemy aggro")
 RULE_REAL(Bots, LeashDistance, 562500.0f, "Distance a bot is allowed to travel from leash owner before being pulled back (squared value)")
 RULE_BOOL(Bots, AllowApplyPoisonCommand, true, "Allows the use of the bot command 'applypoison'")
@@ -877,7 +891,7 @@ RULE_INT(Expansion, AutoGrantAAExpansion, -1, "Expansion to auto grant AAs up to
 RULE_CATEGORY_END()

 RULE_CATEGORY(Instances)
-RULE_INT(Instances, ReservedInstances, 30, "Number of instance IDs which are reserved for globals. This value should not be changed while a server is running")
+RULE_INT(Instances, ReservedInstances, 100, "Number of instance IDs which are reserved for globals. This value should not be changed while a server is running")
 RULE_BOOL(Instances, RecycleInstanceIds, true, "Setting whether free instance IDs should be recycled to prevent them from gradually running out at 32k")
 RULE_INT(Instances, GuildHallExpirationDays, 90, "Amount of days before a Guild Hall instance expires")
 RULE_CATEGORY_END()
--- a/Show More
+++ b/Show More