public void LoadCreatureTexts()
{
uint oldMSTime = Time.GetMSTime();
mTextMap.Clear(); // for reload case
//all currently used temp texts are NOT reset
PreparedStatement stmt = DB.World.GetPreparedStatement(WorldStatements.SEL_CREATURE_TEXT);
SQLResult result = DB.World.Query(stmt);
if (result.IsEmpty())
{
Log.outInfo(LogFilter.ServerLoading, "Loaded 0 ceature texts. DB table `creature_texts` is empty.");
return;
}
uint textCount = 0;
uint creatureCount = 0;
do
{
CreatureTextEntry temp = new();
temp.creatureId = result.Read <uint>(0);
temp.groupId = result.Read <byte>(1);
temp.id = result.Read <byte>(2);
temp.text = result.Read <string>(3);
temp.type = (ChatMsg)result.Read <byte>(4);
temp.lang = (Language)result.Read <byte>(5);
temp.probability = result.Read <float>(6);
temp.emote = (Emote)result.Read <uint>(7);
temp.duration = result.Read <uint>(8);
temp.sound = result.Read <uint>(9);
temp.BroadcastTextId = result.Read <uint>(10);
temp.TextRange = (CreatureTextRange)result.Read <byte>(11);
if (temp.sound != 0)
{
if (!CliDB.SoundKitStorage.ContainsKey(temp.sound))
{
Log.outError(LogFilter.Sql, "GossipManager: Entry {0}, Group {1} in table `creature_texts` has Sound {2} but sound does not exist.", temp.creatureId, temp.groupId, temp.sound);
temp.sound = 0;
}
}
if (ObjectManager.GetLanguageDescByID(temp.lang) == null)
{
Log.outError(LogFilter.Sql, "GossipManager: Entry {0}, Group {1} in table `creature_texts` using Language {2} but Language does not exist.", temp.creatureId, temp.groupId, temp.lang);
temp.lang = Language.Universal;
}
if (temp.type >= ChatMsg.Max)
{
Log.outError(LogFilter.Sql, "GossipManager: Entry {0}, Group {1} in table `creature_texts` has Type {2} but this Chat Type does not exist.", temp.creatureId, temp.groupId, temp.type);
temp.type = ChatMsg.Say;
}
if (temp.emote != 0)
{
if (!CliDB.EmotesStorage.ContainsKey((uint)temp.emote))
{
Log.outError(LogFilter.Sql, "GossipManager: Entry {0}, Group {1} in table `creature_texts` has Emote {2} but emote does not exist.", temp.creatureId, temp.groupId, temp.emote);
temp.emote = Emote.OneshotNone;
}
}
if (temp.BroadcastTextId != 0)
{
if (!CliDB.BroadcastTextStorage.ContainsKey(temp.BroadcastTextId))
{
Log.outError(LogFilter.Sql, "CreatureTextMgr: Entry {0}, Group {1}, Id {2} in table `creature_texts` has non-existing or incompatible BroadcastTextId {3}.", temp.creatureId, temp.groupId, temp.id, temp.BroadcastTextId);
temp.BroadcastTextId = 0;
}
}
if (temp.TextRange > CreatureTextRange.World)
{
Log.outError(LogFilter.Sql, "CreatureTextMgr: Entry {0}, Group {1}, Id {2} in table `creature_text` has incorrect TextRange {3}.", temp.creatureId, temp.groupId, temp.id, temp.TextRange);
temp.TextRange = CreatureTextRange.Normal;
}
if (!mTextMap.ContainsKey(temp.creatureId))
{
mTextMap[temp.creatureId] = new MultiMap <byte, CreatureTextEntry>();
++creatureCount;
}
mTextMap[temp.creatureId].Add(temp.groupId, temp);
++textCount;
} while (result.NextRow());
Log.outInfo(LogFilter.ServerLoading, "Loaded {0} creature texts for {1} creatures in {2} ms", textCount, creatureCount, Time.GetMSTimeDiffToNow(oldMSTime));
}
public void LoadAuctions()
{
uint oldMSTime = Time.GetMSTime();
PreparedStatement stmt = DB.Characters.GetPreparedStatement(CharStatements.SEL_AUCTIONS);
SQLResult result = DB.Characters.Query(stmt);
if (result.IsEmpty())
{
Log.outInfo(LogFilter.ServerLoading, "Loaded 0 auctions. DB table `auctionhouse` is empty.");
return;
}
uint count = 0;
SQLTransaction trans = new SQLTransaction();
do
{
AuctionEntry aItem = new AuctionEntry();
if (!aItem.LoadFromDB(result.GetFields()))
{
aItem.DeleteFromDB(trans);
continue;
}
GetAuctionsMap(aItem.factionTemplateId).AddAuction(aItem);
++count;
} while (result.NextRow());
DB.Characters.CommitTransaction(trans);
Log.outInfo(LogFilter.ServerLoading, "Loaded {0} auctions in {1} ms", count, Time.GetMSTimeDiffToNow(oldMSTime));
}
public void LoadCreatureTextLocales()
{
uint oldMSTime = Time.GetMSTime();
mLocaleTextMap.Clear(); // for reload case
SQLResult result = DB.World.Query("SELECT CreatureId, GroupId, ID, Locale, Text FROM creature_text_locale");
if (result.IsEmpty())
{
return;
}
do
{
uint creatureId = result.Read <uint>(0);
uint groupId = result.Read <byte>(1);
uint id = result.Read <byte>(2);
string localeName = result.Read <string>(3);
Locale locale = localeName.ToEnum <Locale>();
if (!SharedConst.IsValidLocale(locale) || locale == Locale.enUS)
{
continue;
}
var key = new CreatureTextId(creatureId, groupId, id);
if (!mLocaleTextMap.ContainsKey(key))
{
mLocaleTextMap[key] = new CreatureTextLocale();
}
CreatureTextLocale data = mLocaleTextMap[key];
ObjectManager.AddLocaleString(result.Read <string>(4), locale, data.Text);
} while (result.NextRow());
Log.outInfo(LogFilter.ServerLoading, "Loaded {0} creature localized texts in {1} ms", mLocaleTextMap.Count, Time.GetMSTimeDiffToNow(oldMSTime));
}
public void LoadRBAC()
{
ClearRBAC();
Log.outDebug(LogFilter.Rbac, "AccountMgr:LoadRBAC");
uint oldMSTime = Time.GetMSTime();
uint count1 = 0;
uint count2 = 0;
uint count3 = 0;
Log.outDebug(LogFilter.Rbac, "AccountMgr:LoadRBAC: Loading permissions");
SQLResult result = DB.Login.Query("SELECT id, name FROM rbac_permissions");
if (result.IsEmpty())
{
Log.outInfo(LogFilter.ServerLoading, "Loaded 0 account permission definitions. DB table `rbac_permissions` is empty.");
return;
}
do
{
uint id = result.Read <uint>(0);
_permissions[id] = new RBACPermission(id, result.Read <string>(1));
++count1;
}while (result.NextRow());
Log.outDebug(LogFilter.Rbac, "AccountMgr:LoadRBAC: Loading linked permissions");
result = DB.Login.Query("SELECT id, linkedId FROM rbac_linked_permissions ORDER BY id ASC");
if (result.IsEmpty())
{
Log.outInfo(LogFilter.ServerLoading, "Loaded 0 linked permissions. DB table `rbac_linked_permissions` is empty.");
return;
}
uint permissionId = 0;
RBACPermission permission = null;
do
{
uint newId = result.Read <uint>(0);
if (permissionId != newId)
{
permissionId = newId;
permission = _permissions[newId];
}
uint linkedPermissionId = result.Read <uint>(1);
if (linkedPermissionId == permissionId)
{
Log.outError(LogFilter.Sql, "RBAC Permission {0} has itself as linked permission. Ignored", permissionId);
continue;
}
permission.AddLinkedPermission(linkedPermissionId);
++count2;
}while (result.NextRow());
Log.outDebug(LogFilter.Rbac, "AccountMgr:LoadRBAC: Loading default permissions");
result = DB.Login.Query("SELECT secId, permissionId FROM rbac_default_permissions ORDER BY secId ASC");
if (result.IsEmpty())
{
Log.outInfo(LogFilter.ServerLoading, "Loaded 0 default permission definitions. DB table `rbac_default_permissions` is empty.");
return;
}
uint secId = 255;
do
{
uint newId = result.Read <uint>(0);
if (secId != newId)
{
secId = newId;
}
_defaultPermissions.Add((byte)secId, result.Read <uint>(1));
++count3;
}while (result.NextRow());
Log.outInfo(LogFilter.ServerLoading, "Loaded {0} permission definitions, {1} linked permissions and {2} default permissions in {3} ms", count1, count2, count3, Time.GetMSTimeDiffToNow(oldMSTime));
}
public void LoadAuctionItems()
{
uint oldMSTime = Time.GetMSTime();
// need to clear in case we are reloading
mAitems.Clear();
// data needs to be at first place for Item.LoadFromDB
PreparedStatement stmt = DB.Characters.GetPreparedStatement(CharStatements.SEL_AUCTION_ITEMS);
SQLResult result = DB.Characters.Query(stmt);
if (result.IsEmpty())
{
Log.outInfo(LogFilter.ServerLoading, "Loaded 0 auction items. DB table `auctionhouse` or `item_instance` is empty!");
return;
}
uint count = 0;
do
{
ulong itemGuid = result.Read <ulong>(0);
uint itemEntry = result.Read <uint>(1);
ItemTemplate proto = Global.ObjectMgr.GetItemTemplate(itemEntry);
if (proto == null)
{
Log.outError(LogFilter.Server, "AuctionHouseMgr:LoadAuctionItems: Unknown item (GUID: {0} item entry: {1}) in auction, skipped.", itemGuid, itemEntry);
continue;
}
Item item = Bag.NewItemOrBag(proto);
if (!item.LoadFromDB(itemGuid, ObjectGuid.Empty, result.GetFields(), itemEntry))
{
continue;
}
AddAItem(item);
++count;
}while (result.NextRow());
Log.outInfo(LogFilter.ServerLoading, "Loaded {0} auction items in {1} ms", count, Time.GetMSTimeDiffToNow(oldMSTime));
}
public void LoadWeatherData()
{
uint oldMSTime = Time.GetMSTime();
uint count = 0;
SQLResult result = DB.World.Query("SELECT zone, spring_rain_chance, spring_snow_chance, spring_storm_chance," +
"summer_rain_chance, summer_snow_chance, summer_storm_chance, fall_rain_chance, fall_snow_chance, fall_storm_chance," +
"winter_rain_chance, winter_snow_chance, winter_storm_chance, ScriptName FROM game_weather");
if (result.IsEmpty())
{
Log.outError(LogFilter.ServerLoading, "Loaded 0 weather definitions. DB table `game_weather` is empty.");
return;
}
do
{
uint zone_id = result.Read <uint>(0);
WeatherData wzc = new WeatherData();
for (byte season = 0; season < 4; ++season)
{
wzc.data[season].rainChance = result.Read <byte>(season * (4 - 1) + 1);
wzc.data[season].snowChance = result.Read <byte>(season * (4 - 1) + 2);
wzc.data[season].stormChance = result.Read <byte>(season * (4 - 1) + 3);
if (wzc.data[season].rainChance > 100)
{
wzc.data[season].rainChance = 25;
Log.outError(LogFilter.Sql, "Weather for zone {0} season {1} has wrong rain chance > 100%", zone_id, season);
}
if (wzc.data[season].snowChance > 100)
{
wzc.data[season].snowChance = 25;
Log.outError(LogFilter.Sql, "Weather for zone {0} season {1} has wrong snow chance > 100%", zone_id, season);
}
if (wzc.data[season].stormChance > 100)
{
wzc.data[season].stormChance = 25;
Log.outError(LogFilter.Sql, "Weather for zone {0} season {1} has wrong storm chance > 100%", zone_id, season);
}
}
wzc.ScriptId = Global.ObjectMgr.GetScriptId(result.Read <string>(13));
_weatherData[zone_id] = wzc;
++count;
}while (result.NextRow());
Log.outInfo(LogFilter.ServerLoading, "Loaded {0} weather definitions in {1} ms", count, Time.GetMSTimeDiffToNow(oldMSTime));
}
public void LoadFromDB()
{
// Pool templates
{
uint oldMSTime = Time.GetMSTime();
SQLResult result = DB.World.Query("SELECT entry, max_limit FROM pool_template");
if (result.IsEmpty())
{
mPoolTemplate.Clear();
Log.outInfo(LogFilter.ServerLoading, "Loaded 0 object pools. DB table `pool_template` is empty.");
return;
}
uint count = 0;
do
{
uint pool_id = result.Read <uint>(0);
PoolTemplateData pPoolTemplate = new PoolTemplateData();
pPoolTemplate.MaxLimit = result.Read <uint>(1);
mPoolTemplate[pool_id] = pPoolTemplate;
++count;
}while (result.NextRow());
Log.outInfo(LogFilter.ServerLoading, "Loaded {0} objects pools in {1} ms", count, Time.GetMSTimeDiffToNow(oldMSTime));
}
// Creatures
Log.outInfo(LogFilter.ServerLoading, "Loading Creatures Pooling Data...");
{
uint oldMSTime = Time.GetMSTime();
// 1 2 3
SQLResult result = DB.World.Query("SELECT guid, pool_entry, chance FROM pool_creature");
if (result.IsEmpty())
{
Log.outInfo(LogFilter.ServerLoading, "Loaded 0 creatures in pools. DB table `pool_creature` is empty.");
}
else
{
uint count = 0;
do
{
ulong guid = result.Read <ulong>(0);
uint pool_id = result.Read <uint>(1);
float chance = result.Read <float>(2);
CreatureData data = Global.ObjectMgr.GetCreatureData(guid);
if (data == null)
{
Log.outError(LogFilter.Sql, "`pool_creature` has a non existing creature spawn (GUID: {0}) defined for pool id ({1}), skipped.", guid, pool_id);
continue;
}
if (!mPoolTemplate.ContainsKey(pool_id))
{
Log.outError(LogFilter.Sql, "`pool_creature` pool id ({0}) is not in `pool_template`, skipped.", pool_id);
continue;
}
if (chance < 0 || chance > 100)
{
Log.outError(LogFilter.Sql, "`pool_creature` has an invalid chance ({0}) for creature guid ({1}) in pool id ({2}), skipped.", chance, guid, pool_id);
continue;
}
PoolTemplateData pPoolTemplate = mPoolTemplate[pool_id];
PoolObject plObject = new PoolObject(guid, chance);
if (!mPoolCreatureGroups.ContainsKey(pool_id))
{
mPoolCreatureGroups[pool_id] = new PoolGroup <Creature>();
}
PoolGroup <Creature> cregroup = mPoolCreatureGroups[pool_id];
cregroup.SetPoolId(pool_id);
cregroup.AddEntry(plObject, pPoolTemplate.MaxLimit);
mCreatureSearchMap.Add(guid, pool_id);
++count;
}while (result.NextRow());
Log.outInfo(LogFilter.ServerLoading, "Loaded {0} creatures in pools in {1} ms", count, Time.GetMSTimeDiffToNow(oldMSTime));
}
}
// Gameobjects
Log.outInfo(LogFilter.ServerLoading, "Loading Gameobject Pooling Data...");
{
uint oldMSTime = Time.GetMSTime();
// 1 2 3
SQLResult result = DB.World.Query("SELECT guid, pool_entry, chance FROM pool_gameobject");
if (result.IsEmpty())
{
Log.outInfo(LogFilter.ServerLoading, "Loaded 0 gameobjects in pools. DB table `pool_gameobject` is empty.");
}
else
{
uint count = 0;
do
{
ulong guid = result.Read <ulong>(0);
uint pool_id = result.Read <uint>(1);
float chance = result.Read <float>(2);
GameObjectData data = Global.ObjectMgr.GetGameObjectData(guid);
if (data == null)
{
Log.outError(LogFilter.Sql, "`pool_gameobject` has a non existing gameobject spawn (GUID: {0}) defined for pool id ({1}), skipped.", guid, pool_id);
continue;
}
GameObjectTemplate goinfo = Global.ObjectMgr.GetGameObjectTemplate(data.Id);
if (goinfo.type != GameObjectTypes.Chest &&
goinfo.type != GameObjectTypes.FishingHole &&
goinfo.type != GameObjectTypes.GatheringNode &&
goinfo.type != GameObjectTypes.Goober)
{
Log.outError(LogFilter.Sql, "`pool_gameobject` has a not lootable gameobject spawn (GUID: {0}, type: {1}) defined for pool id ({2}), skipped.", guid, goinfo.type, pool_id);
continue;
}
if (!mPoolTemplate.ContainsKey(pool_id))
{
Log.outError(LogFilter.Sql, "`pool_gameobject` pool id ({0}) is not in `pool_template`, skipped.", pool_id);
continue;
}
if (chance < 0 || chance > 100)
{
Log.outError(LogFilter.Sql, "`pool_gameobject` has an invalid chance ({0}) for gameobject guid ({1}) in pool id ({2}), skipped.", chance, guid, pool_id);
continue;
}
PoolTemplateData pPoolTemplate = mPoolTemplate[pool_id];
PoolObject plObject = new PoolObject(guid, chance);
if (!mPoolGameobjectGroups.ContainsKey(pool_id))
{
mPoolGameobjectGroups[pool_id] = new PoolGroup <GameObject>();
}
PoolGroup <GameObject> gogroup = mPoolGameobjectGroups[pool_id];
gogroup.SetPoolId(pool_id);
gogroup.AddEntry(plObject, pPoolTemplate.MaxLimit);
mGameobjectSearchMap.Add(guid, pool_id);
++count;
}while (result.NextRow());
Log.outInfo(LogFilter.ServerLoading, "Loaded {0} gameobject in pools in {1} ms", count, Time.GetMSTimeDiffToNow(oldMSTime));
}
}
// Pool of pools
Log.outInfo(LogFilter.ServerLoading, "Loading Mother Pooling Data...");
{
uint oldMSTime = Time.GetMSTime();
// 1 2 3
SQLResult result = DB.World.Query("SELECT pool_id, mother_pool, chance FROM pool_pool");
if (result.IsEmpty())
{
Log.outInfo(LogFilter.ServerLoading, "Loaded 0 pools in pools");
}
else
{
uint count = 0;
do
{
uint child_pool_id = result.Read <uint>(0);
uint mother_pool_id = result.Read <uint>(1);
float chance = result.Read <float>(2);
if (!mPoolTemplate.ContainsKey(mother_pool_id))
{
Log.outError(LogFilter.Sql, "`pool_pool` mother_pool id ({0}) is not in `pool_template`, skipped.", mother_pool_id);
continue;
}
if (!mPoolTemplate.ContainsKey(child_pool_id))
{
Log.outError(LogFilter.Sql, "`pool_pool` included pool_id ({0}) is not in `pool_template`, skipped.", child_pool_id);
continue;
}
if (mother_pool_id == child_pool_id)
{
Log.outError(LogFilter.Sql, "`pool_pool` pool_id ({0}) includes itself, dead-lock detected, skipped.", child_pool_id);
continue;
}
if (chance < 0 || chance > 100)
{
Log.outError(LogFilter.Sql, "`pool_pool` has an invalid chance ({0}) for pool id ({1}) in mother pool id ({2}), skipped.", chance, child_pool_id, mother_pool_id);
continue;
}
PoolTemplateData pPoolTemplateMother = mPoolTemplate[mother_pool_id];
PoolObject plObject = new PoolObject(child_pool_id, chance);
if (!mPoolPoolGroups.ContainsKey(mother_pool_id))
{
mPoolPoolGroups[mother_pool_id] = new PoolGroup <Pool>();
}
PoolGroup <Pool> plgroup = mPoolPoolGroups[mother_pool_id];
plgroup.SetPoolId(mother_pool_id);
plgroup.AddEntry(plObject, pPoolTemplateMother.MaxLimit);
mPoolSearchMap.Add(child_pool_id, mother_pool_id);
++count;
}while (result.NextRow());
Log.outInfo(LogFilter.ServerLoading, "Loaded {0} pools in mother pools in {1} ms", count, Time.GetMSTimeDiffToNow(oldMSTime));
}
}
Log.outInfo(LogFilter.ServerLoading, "Loading Quest Pooling Data...");
{
uint oldMSTime = Time.GetMSTime();
PreparedStatement stmt = DB.World.GetPreparedStatement(WorldStatements.SEL_QUEST_POOLS);
SQLResult result = DB.World.Query(stmt);
if (result.IsEmpty())
{
Log.outInfo(LogFilter.ServerLoading, "Loaded 0 quests in pools");
}
else
{
List <uint> creBounds;
List <uint> goBounds;
Dictionary <uint, QuestTypes> poolTypeMap = new Dictionary <uint, QuestTypes>();
uint count = 0;
do
{
uint entry = result.Read <uint>(0);
uint pool_id = result.Read <uint>(1);
if (!poolTypeMap.ContainsKey(pool_id))
{
poolTypeMap[pool_id] = 0;
}
Quest quest = Global.ObjectMgr.GetQuestTemplate(entry);
if (quest == null)
{
Log.outError(LogFilter.Sql, "`pool_quest` has a non existing quest template (Entry: {0}) defined for pool id ({1}), skipped.", entry, pool_id);
continue;
}
if (!mPoolTemplate.ContainsKey(pool_id))
{
Log.outError(LogFilter.Sql, "`pool_quest` pool id ({0}) is not in `pool_template`, skipped.", pool_id);
continue;
}
if (!quest.IsDailyOrWeekly())
{
Log.outError(LogFilter.Sql, "`pool_quest` has an quest ({0}) which is not daily or weekly in pool id ({1}), use ExclusiveGroup instead, skipped.", entry, pool_id);
continue;
}
if (poolTypeMap[pool_id] == QuestTypes.None)
{
poolTypeMap[pool_id] = quest.IsDaily() ? QuestTypes.Daily : QuestTypes.Weekly;
}
QuestTypes currType = quest.IsDaily() ? QuestTypes.Daily : QuestTypes.Weekly;
if (poolTypeMap[pool_id] != currType)
{
Log.outError(LogFilter.Sql, "`pool_quest` quest {0} is {1} but pool ({2}) is specified for {3}, mixing not allowed, skipped.",
entry, currType, pool_id, poolTypeMap[pool_id]);
continue;
}
creBounds = mQuestCreatureRelation.LookupByKey(entry);
goBounds = mQuestGORelation.LookupByKey(entry);
if (creBounds.Empty() && goBounds.Empty())
{
Log.outError(LogFilter.Sql, "`pool_quest` lists entry ({0}) as member of pool ({1}) but is not started anywhere, skipped.", entry, pool_id);
continue;
}
PoolTemplateData pPoolTemplate = mPoolTemplate[pool_id];
PoolObject plObject = new PoolObject(entry, 0.0f);
if (!mPoolQuestGroups.ContainsKey(pool_id))
{
mPoolQuestGroups[pool_id] = new PoolGroup <Quest>();
}
PoolGroup <Quest> questgroup = mPoolQuestGroups[pool_id];
questgroup.SetPoolId(pool_id);
questgroup.AddEntry(plObject, pPoolTemplate.MaxLimit);
mQuestSearchMap.Add(entry, pool_id);
++count;
}while (result.NextRow());
Log.outInfo(LogFilter.ServerLoading, "Loaded {0} quests in pools in {1} ms", count, Time.GetMSTimeDiffToNow(oldMSTime));
}
}
// The initialize method will spawn all pools not in an event and not in another pool, this is why there is 2 left joins with 2 null checks
Log.outInfo(LogFilter.ServerLoading, "Starting objects pooling system...");
{
uint oldMSTime = Time.GetMSTime();
SQLResult result = DB.World.Query("SELECT DISTINCT pool_template.entry, pool_pool.pool_id, pool_pool.mother_pool FROM pool_template" +
" LEFT JOIN game_event_pool ON pool_template.entry=game_event_pool.pool_entry" +
" LEFT JOIN pool_pool ON pool_template.entry=pool_pool.pool_id WHERE game_event_pool.pool_entry IS NULL");
if (result.IsEmpty())
{
Log.outInfo(LogFilter.ServerLoading, "Pool handling system initialized, 0 pools spawned.");
}
else
{
uint count = 0;
do
{
uint pool_entry = result.Read <uint>(0);
uint pool_pool_id = result.Read <uint>(1);
if (!CheckPool(pool_entry))
{
if (pool_pool_id != 0)
{
// The pool is a child pool in pool_pool table. Ideally we should remove it from the pool handler to ensure it never gets spawned,
// however that could recursively invalidate entire chain of mother pools. It can be done in the future but for now we'll do nothing.
Log.outError(LogFilter.Sql, "Pool Id {0} has no equal chance pooled entites defined and explicit chance sum is not 100. This broken pool is a child pool of Id {1} and cannot be safely removed.", pool_entry, result.Read <uint>(2));
}
else
{
Log.outError(LogFilter.Sql, "Pool Id {0} has no equal chance pooled entites defined and explicit chance sum is not 100. The pool will not be spawned.", pool_entry);
}
continue;
}
// Don't spawn child pools, they are spawned recursively by their parent pools
if (pool_pool_id == 0)
{
SpawnPool(pool_entry);
count++;
}
}while (result.NextRow());
Log.outInfo(LogFilter.ServerLoading, "Pool handling system initialized, {0} pools spawned in {1} ms", count, Time.GetMSTimeDiffToNow(oldMSTime));
}
}
}
public void CheckQuestDisables()
{
if (!m_DisableMap.ContainsKey(DisableType.Quest) || m_DisableMap[DisableType.Quest].Count == 0)
{
Log.outInfo(LogFilter.ServerLoading, "Checked 0 quest disables.");
return;
}
uint oldMSTime = Time.GetMSTime();
// check only quests, rest already done at startup
foreach (var pair in m_DisableMap[DisableType.Quest])
{
uint entry = pair.Key;
if (Global.ObjectMgr.GetQuestTemplate(entry) == null)
{
Log.outError(LogFilter.Sql, "Quest entry {0} from `disables` doesn't exist, skipped.", entry);
m_DisableMap[DisableType.Quest].Remove(entry);
continue;
}
if (pair.Value.flags != 0)
{
Log.outError(LogFilter.Sql, "Disable flags specified for quest {0}, useless data.", entry);
}
}
Log.outInfo(LogFilter.ServerLoading, "Checked {0} quest disables in {1} ms", m_DisableMap[DisableType.Quest].Count, Time.GetMSTimeDiffToNow(oldMSTime));
}
public void LoadDisables()
{
uint oldMSTime = Time.GetMSTime();
// reload case
m_DisableMap.Clear();
SQLResult result = DB.World.Query("SELECT sourceType, entry, flags, params_0, params_1 FROM disables");
if (result.IsEmpty())
{
Log.outError(LogFilter.ServerLoading, "Loaded 0 disables. DB table `disables` is empty!");
return;
}
uint total_count = 0;
do
{
DisableType type = (DisableType)result.Read <uint>(0);
if (type >= DisableType.Max)
{
Log.outError(LogFilter.Sql, "Invalid type {0} specified in `disables` table, skipped.", type);
continue;
}
uint entry = result.Read <uint>(1);
byte flags = result.Read <byte>(2);
string params_0 = result.Read <string>(3);
string params_1 = result.Read <string>(4);
DisableData data = new DisableData();
data.flags = flags;
switch (type)
{
case DisableType.Spell:
if (!(Global.SpellMgr.HasSpellInfo(entry, Difficulty.None) || flags.HasAnyFlag <byte>(DisableFlags.SpellDeprecatedSpell)))
{
Log.outError(LogFilter.Sql, "Spell entry {0} from `disables` doesn't exist in dbc, skipped.", entry);
continue;
}
if (flags == 0 || flags > DisableFlags.MaxSpell)
{
Log.outError(LogFilter.Sql, "Disable flags for spell {0} are invalid, skipped.", entry);
continue;
}
if (flags.HasAnyFlag(DisableFlags.SpellMap))
{
var array = new StringArray(params_0, ',');
for (byte i = 0; i < array.Length;)
{
if (uint.TryParse(array[i++], out uint id))
{
data.param0.Add(id);
}
}
}
if (flags.HasAnyFlag(DisableFlags.SpellArea))
{
var array = new StringArray(params_1, ',');
for (byte i = 0; i < array.Length;)
{
if (uint.TryParse(array[i++], out uint id))
{
data.param1.Add(id);
}
}
}
break;
// checked later
case DisableType.Quest:
break;
case DisableType.Map:
case DisableType.LFGMap:
{
MapRecord mapEntry = CliDB.MapStorage.LookupByKey(entry);
if (mapEntry == null)
{
Log.outError(LogFilter.Sql, "Map entry {0} from `disables` doesn't exist in dbc, skipped.", entry);
continue;
}
bool isFlagInvalid = false;
switch (mapEntry.InstanceType)
{
case MapTypes.Common:
if (flags != 0)
{
isFlagInvalid = true;
}
break;
case MapTypes.Instance:
case MapTypes.Raid:
if (flags.HasAnyFlag(DisableFlags.DungeonStatusHeroic) && Global.DB2Mgr.GetMapDifficultyData(entry, Difficulty.Heroic) == null)
{
flags -= DisableFlags.DungeonStatusHeroic;
}
if (flags.HasAnyFlag(DisableFlags.DungeonStatusHeroic10Man) && Global.DB2Mgr.GetMapDifficultyData(entry, Difficulty.Raid10HC) == null)
{
flags -= DisableFlags.DungeonStatusHeroic10Man;
}
if (flags.HasAnyFlag(DisableFlags.DungeonStatusHeroic25Man) && Global.DB2Mgr.GetMapDifficultyData(entry, Difficulty.Raid25HC) == null)
{
flags -= DisableFlags.DungeonStatusHeroic25Man;
}
if (flags == 0)
{
isFlagInvalid = true;
}
break;
case MapTypes.Battleground:
case MapTypes.Arena:
Log.outError(LogFilter.Sql, "Battlegroundmap {0} specified to be disabled in map case, skipped.", entry);
continue;
}
if (isFlagInvalid)
{
Log.outError(LogFilter.Sql, "Disable flags for map {0} are invalid, skipped.", entry);
continue;
}
break;
}
case DisableType.Battleground:
if (!CliDB.BattlemasterListStorage.ContainsKey(entry))
{
Log.outError(LogFilter.Sql, "Battlegroundentry {0} from `disables` doesn't exist in dbc, skipped.", entry);
continue;
}
if (flags != 0)
{
Log.outError(LogFilter.Sql, "Disable flags specified for Battleground{0}, useless data.", entry);
}
break;
case DisableType.OutdoorPVP:
if (entry > (int)OutdoorPvPTypes.Max)
{
Log.outError(LogFilter.Sql, "OutdoorPvPTypes value {0} from `disables` is invalid, skipped.", entry);
continue;
}
if (flags != 0)
{
Log.outError(LogFilter.Sql, "Disable flags specified for outdoor PvP {0}, useless data.", entry);
}
break;
case DisableType.Criteria:
if (Global.CriteriaMgr.GetCriteria(entry) == null)
{
Log.outError(LogFilter.Sql, "Criteria entry {0} from `disables` doesn't exist in dbc, skipped.", entry);
continue;
}
if (flags != 0)
{
Log.outError(LogFilter.Sql, "Disable flags specified for Criteria {0}, useless data.", entry);
}
break;
case DisableType.VMAP:
{
MapRecord mapEntry = CliDB.MapStorage.LookupByKey(entry);
if (mapEntry == null)
{
Log.outError(LogFilter.Sql, "Map entry {0} from `disables` doesn't exist in dbc, skipped.", entry);
continue;
}
switch (mapEntry.InstanceType)
{
case MapTypes.Common:
if (flags.HasAnyFlag(DisableFlags.VmapAreaFlag))
{
Log.outInfo(LogFilter.Server, "Areaflag disabled for world map {0}.", entry);
}
if (flags.HasAnyFlag(DisableFlags.VmapLiquidStatus))
{
Log.outInfo(LogFilter.Server, "Liquid status disabled for world map {0}.", entry);
}
break;
case MapTypes.Instance:
case MapTypes.Raid:
if (flags.HasAnyFlag(DisableFlags.VmapHeight))
{
Log.outInfo(LogFilter.Server, "Height disabled for instance map {0}.", entry);
}
if (flags.HasAnyFlag(DisableFlags.VmapLOS))
{
Log.outInfo(LogFilter.Server, "LoS disabled for instance map {0}.", entry);
}
break;
case MapTypes.Battleground:
if (flags.HasAnyFlag(DisableFlags.VmapHeight))
{
Log.outInfo(LogFilter.Server, "Height disabled for Battlegroundmap {0}.", entry);
}
if (flags.HasAnyFlag(DisableFlags.VmapLOS))
{
Log.outInfo(LogFilter.Server, "LoS disabled for Battlegroundmap {0}.", entry);
}
break;
case MapTypes.Arena:
if (flags.HasAnyFlag(DisableFlags.VmapHeight))
{
Log.outInfo(LogFilter.Server, "Height disabled for arena map {0}.", entry);
}
if (flags.HasAnyFlag(DisableFlags.VmapLOS))
{
Log.outInfo(LogFilter.Server, "LoS disabled for arena map {0}.", entry);
}
break;
default:
break;
}
break;
}
case DisableType.MMAP:
{
MapRecord mapEntry = CliDB.MapStorage.LookupByKey(entry);
if (mapEntry == null)
{
Log.outError(LogFilter.Sql, "Map entry {0} from `disables` doesn't exist in dbc, skipped.", entry);
continue;
}
switch (mapEntry.InstanceType)
{
case MapTypes.Common:
Log.outInfo(LogFilter.Server, "Pathfinding disabled for world map {0}.", entry);
break;
case MapTypes.Instance:
case MapTypes.Raid:
Log.outInfo(LogFilter.Server, "Pathfinding disabled for instance map {0}.", entry);
break;
case MapTypes.Battleground:
Log.outInfo(LogFilter.Server, "Pathfinding disabled for Battlegroundmap {0}.", entry);
break;
case MapTypes.Arena:
Log.outInfo(LogFilter.Server, "Pathfinding disabled for arena map {0}.", entry);
break;
default:
break;
}
break;
}
default:
break;
}
if (!m_DisableMap.ContainsKey(type))
{
m_DisableMap[type] = new Dictionary <uint, DisableData>();
}
m_DisableMap[type].Add(entry, data);
++total_count;
}while (result.NextRow());
Log.outInfo(LogFilter.ServerLoading, "Loaded {0} disables in {1} ms", total_count, Time.GetMSTimeDiffToNow(oldMSTime));
}
public static void CleanDatabase()
{
// config to disable
if (!WorldConfig.GetBoolValue(WorldCfg.CleanCharacterDb))
{
return;
}
Log.outInfo(LogFilter.Server, "Cleaning character database...");
uint oldMSTime = Time.GetMSTime();
// check flags which clean ups are necessary
SQLResult result = DB.Characters.Query("SELECT value FROM worldstates WHERE entry = {0}", (uint)WorldStates.CleaningFlags);
if (result.IsEmpty())
{
return;
}
CleaningFlags flags = (CleaningFlags)result.Read <uint>(0);
// clean up
if (flags.HasAnyFlag(CleaningFlags.AchievementProgress))
{
CleanCharacterAchievementProgress();
}
if (flags.HasAnyFlag(CleaningFlags.Skills))
{
CleanCharacterSkills();
}
if (flags.HasAnyFlag(CleaningFlags.Spells))
{
CleanCharacterSpell();
}
if (flags.HasAnyFlag(CleaningFlags.Talents))
{
CleanCharacterTalent();
}
if (flags.HasAnyFlag(CleaningFlags.Queststatus))
{
CleanCharacterQuestStatus();
}
// NOTE: In order to have persistentFlags be set in worldstates for the next cleanup,
// you need to define them at least once in worldstates.
flags &= (CleaningFlags)WorldConfig.GetIntValue(WorldCfg.PersistentCharacterCleanFlags);
DB.Characters.DirectExecute("UPDATE worldstates SET value = {0} WHERE entry = {1}", flags, (uint)WorldStates.CleaningFlags);
Global.WorldMgr.SetCleaningFlags(flags);
Log.outInfo(LogFilter.ServerLoading, "Cleaned character database in {0} ms", Time.GetMSTimeDiffToNow(oldMSTime));
}
public void LoadFromDB()
{
uint oldMSTime = Time.GetMSTime();
uint count = 0;
_maxEventId = 0;
_maxInviteId = 0;
// 0 1 2 3 4 5 6 7 8
SQLResult result = DB.Characters.Query("SELECT EventID, Owner, Title, Description, EventType, TextureID, Date, Flags, LockDate FROM calendar_events");
if (!result.IsEmpty())
{
do
{
ulong eventID = result.Read <ulong>(0);
ObjectGuid ownerGUID = ObjectGuid.Create(HighGuid.Player, result.Read <ulong>(1));
string title = result.Read <string>(2);
string description = result.Read <string>(3);
CalendarEventType type = (CalendarEventType)result.Read <byte>(4);
int textureID = result.Read <int>(5);
long date = result.Read <long>(6);
CalendarFlags flags = (CalendarFlags)result.Read <uint>(7);
long lockDate = result.Read <long>(8);
ulong guildID = 0;
if (flags.HasAnyFlag(CalendarFlags.GuildEvent) || flags.HasAnyFlag(CalendarFlags.WithoutInvites))
{
guildID = Global.CharacterCacheStorage.GetCharacterGuildIdByGuid(ownerGUID);
}
CalendarEvent calendarEvent = new(eventID, ownerGUID, guildID, type, textureID, date, flags, title, description, lockDate);
_events.Add(calendarEvent);
_maxEventId = Math.Max(_maxEventId, eventID);
++count;
}while (result.NextRow());
}
Log.outInfo(LogFilter.ServerLoading, $"Loaded {count} calendar events in {Time.GetMSTimeDiffToNow(oldMSTime)} ms");
count = 0;
oldMSTime = Time.GetMSTime();
// 0 1 2 3 4 5 6 7
result = DB.Characters.Query("SELECT InviteID, EventID, Invitee, Sender, Status, ResponseTime, ModerationRank, Note FROM calendar_invites");
if (!result.IsEmpty())
{
do
{
ulong inviteId = result.Read <ulong>(0);
ulong eventId = result.Read <ulong>(1);
ObjectGuid invitee = ObjectGuid.Create(HighGuid.Player, result.Read <ulong>(2));
ObjectGuid senderGUID = ObjectGuid.Create(HighGuid.Player, result.Read <ulong>(3));
CalendarInviteStatus status = (CalendarInviteStatus)result.Read <byte>(4);
long responseTime = result.Read <long>(5);
CalendarModerationRank rank = (CalendarModerationRank)result.Read <byte>(6);
string note = result.Read <string>(7);
CalendarInvite invite = new(inviteId, eventId, invitee, senderGUID, responseTime, status, rank, note);
_invites.Add(eventId, invite);
_maxInviteId = Math.Max(_maxInviteId, inviteId);
++count;
}while (result.NextRow());
}
Log.outInfo(LogFilter.ServerLoading, $"Loaded {count} calendar invites in {Time.GetMSTimeDiffToNow(oldMSTime)} ms");
for (ulong i = 1; i < _maxEventId; ++i)
{
if (GetEvent(i) == null)
{
_freeEventIds.Add(i);
}
}
for (ulong i = 1; i < _maxInviteId; ++i)
{
if (GetInvite(i) == null)
{
_freeInviteIds.Add(i);
}
}
}
public void LoadGuildRewards()
{
uint oldMSTime = Time.GetMSTime();
// 0 1 2 3
SQLResult result = DB.World.Query("SELECT ItemID, MinGuildRep, RaceMask, Cost FROM guild_rewards");
if (result.IsEmpty())
{
Log.outInfo(LogFilter.ServerLoading, "Loaded 0 guild reward definitions. DB table `guild_rewards` is empty.");
return;
}
uint count = 0;
do
{
GuildReward reward = new();
reward.ItemID = result.Read <uint>(0);
reward.MinGuildRep = result.Read <byte>(1);
reward.RaceMask = result.Read <ulong>(2);
reward.Cost = result.Read <ulong>(3);
if (Global.ObjectMgr.GetItemTemplate(reward.ItemID) == null)
{
Log.outError(LogFilter.ServerLoading, "Guild rewards constains not existing item entry {0}", reward.ItemID);
continue;
}
if (reward.MinGuildRep >= (int)ReputationRank.Max)
{
Log.outError(LogFilter.ServerLoading, "Guild rewards contains wrong reputation standing {0}, max is {1}", reward.MinGuildRep, (int)ReputationRank.Max - 1);
continue;
}
PreparedStatement stmt = DB.World.GetPreparedStatement(WorldStatements.SEL_GUILD_REWARDS_REQ_ACHIEVEMENTS);
stmt.AddValue(0, reward.ItemID);
SQLResult reqAchievementResult = DB.World.Query(stmt);
if (!reqAchievementResult.IsEmpty())
{
do
{
uint requiredAchievementId = reqAchievementResult.Read <uint>(0);
if (!CliDB.AchievementStorage.ContainsKey(requiredAchievementId))
{
Log.outError(LogFilter.ServerLoading, "Guild rewards constains not existing achievement entry {0}", requiredAchievementId);
continue;
}
reward.AchievementsRequired.Add(requiredAchievementId);
} while (reqAchievementResult.NextRow());
}
guildRewards.Add(reward);
++count;
} while (result.NextRow());
Log.outInfo(LogFilter.ServerLoading, "Loaded {0} guild reward definitions in {1} ms", count, Time.GetMSTimeDiffToNow(oldMSTime));
}
public void LoadGuilds()
{
Log.outInfo(LogFilter.ServerLoading, "Loading Guilds Definitions...");
{
uint oldMSTime = Time.GetMSTime();
// 0 1 2 3 4 5 6
SQLResult result = DB.Characters.Query("SELECT g.guildid, g.name, g.leaderguid, g.EmblemStyle, g.EmblemColor, g.BorderStyle, g.BorderColor, " +
// 7 8 9 10 11 12
"g.BackgroundColor, g.info, g.motd, g.createdate, g.BankMoney, COUNT(gbt.guildid) " +
"FROM guild g LEFT JOIN guild_bank_tab gbt ON g.guildid = gbt.guildid GROUP BY g.guildid ORDER BY g.guildid ASC");
if (result.IsEmpty())
{
Log.outInfo(LogFilter.Guild, "Loaded 0 guild definitions. DB table `guild` is empty.");
return;
}
uint count = 0;
do
{
Guild guild = new();
if (!guild.LoadFromDB(result.GetFields()))
{
continue;
}
AddGuild(guild);
count++;
} while (result.NextRow());
Log.outInfo(LogFilter.ServerLoading, "Loaded {0} guild definitions in {1} ms", count, Time.GetMSTimeDiffToNow(oldMSTime));
}
Log.outInfo(LogFilter.ServerLoading, "Loading guild ranks...");
{
uint oldMSTime = Time.GetMSTime();
// Delete orphaned guild rank entries before loading the valid ones
DB.Characters.DirectExecute("DELETE gr FROM guild_rank gr LEFT JOIN guild g ON gr.guildId = g.guildId WHERE g.guildId IS NULL");
// 0 1 2 3 4
SQLResult result = DB.Characters.Query("SELECT guildid, rid, rname, rights, BankMoneyPerDay FROM guild_rank ORDER BY guildid ASC, rid ASC");
if (result.IsEmpty())
{
Log.outInfo(LogFilter.ServerLoading, "Loaded 0 guild ranks. DB table `guild_rank` is empty.");
}
else
{
uint count = 0;
do
{
uint guildId = result.Read <uint>(0);
Guild guild = GetGuildById(guildId);
if (guild)
{
guild.LoadRankFromDB(result.GetFields());
}
++count;
}while (result.NextRow());
Log.outInfo(LogFilter.ServerLoading, "Loaded {0} guild ranks in {1} ms", count, Time.GetMSTimeDiffToNow(oldMSTime));
}
}
// 3. Load all guild members
Log.outInfo(LogFilter.ServerLoading, "Loading guild members...");
{
uint oldMSTime = Time.GetMSTime();
// Delete orphaned guild member entries before loading the valid ones
DB.Characters.DirectExecute("DELETE gm FROM guild_member gm LEFT JOIN guild g ON gm.guildId = g.guildId WHERE g.guildId IS NULL");
DB.Characters.DirectExecute("DELETE gm FROM guild_member_withdraw gm LEFT JOIN guild_member g ON gm.guid = g.guid WHERE g.guid IS NULL");
// 0 1 2 3 4 5 6 7 8 9 10
SQLResult result = DB.Characters.Query("SELECT gm.guildid, gm.guid, rank, pnote, offnote, w.tab0, w.tab1, w.tab2, w.tab3, w.tab4, w.tab5, " +
// 11 12 13 14 15 16 17 18 19 20
"w.tab6, w.tab7, w.money, c.name, c.level, c.class, c.gender, c.zone, c.account, c.logout_time " +
"FROM guild_member gm LEFT JOIN guild_member_withdraw w ON gm.guid = w.guid " +
"LEFT JOIN characters c ON c.guid = gm.guid ORDER BY gm.guildid ASC");
if (result.IsEmpty())
{
Log.outInfo(LogFilter.ServerLoading, "Loaded 0 guild members. DB table `guild_member` is empty.");
}
else
{
uint count = 0;
do
{
uint guildId = result.Read <uint>(0);
Guild guild = GetGuildById(guildId);
if (guild)
{
guild.LoadMemberFromDB(result.GetFields());
}
++count;
}while (result.NextRow());
Log.outInfo(LogFilter.ServerLoading, "Loaded {0} guild members in {1} ms", count, Time.GetMSTimeDiffToNow(oldMSTime));
}
}
// 4. Load all guild bank tab rights
Log.outInfo(LogFilter.ServerLoading, "Loading bank tab rights...");
{
uint oldMSTime = Time.GetMSTime();
// Delete orphaned guild bank right entries before loading the valid ones
DB.Characters.DirectExecute("DELETE gbr FROM guild_bank_right gbr LEFT JOIN guild g ON gbr.guildId = g.guildId WHERE g.guildId IS NULL");
// 0 1 2 3 4
SQLResult result = DB.Characters.Query("SELECT guildid, TabId, rid, gbright, SlotPerDay FROM guild_bank_right ORDER BY guildid ASC, TabId ASC");
if (result.IsEmpty())
{
Log.outInfo(LogFilter.ServerLoading, "Loaded 0 guild bank tab rights. DB table `guild_bank_right` is empty.");
}
else
{
uint count = 0;
do
{
uint guildId = result.Read <uint>(0);
Guild guild = GetGuildById(guildId);
if (guild)
{
guild.LoadBankRightFromDB(result.GetFields());
}
++count;
}while (result.NextRow());
Log.outInfo(LogFilter.ServerLoading, "Loaded {0} bank tab rights in {1} ms", count, Time.GetMSTimeDiffToNow(oldMSTime));
}
}
// 5. Load all event logs
Log.outInfo(LogFilter.ServerLoading, "Loading guild event logs...");
{
uint oldMSTime = Time.GetMSTime();
DB.Characters.DirectExecute("DELETE FROM guild_eventlog WHERE LogGuid > {0}", GuildConst.EventLogMaxRecords);
// 0 1 2 3 4 5 6
SQLResult result = DB.Characters.Query("SELECT guildid, LogGuid, EventType, PlayerGuid1, PlayerGuid2, NewRank, TimeStamp FROM guild_eventlog ORDER BY TimeStamp DESC, LogGuid DESC");
if (result.IsEmpty())
{
Log.outInfo(LogFilter.ServerLoading, "Loaded 0 guild event logs. DB table `guild_eventlog` is empty.");
}
else
{
uint count = 0;
do
{
uint guildId = result.Read <uint>(0);
Guild guild = GetGuildById(guildId);
if (guild)
{
guild.LoadEventLogFromDB(result.GetFields());
}
++count;
}while (result.NextRow());
Log.outInfo(LogFilter.ServerLoading, "Loaded {0} guild event logs in {1} ms", count, Time.GetMSTimeDiffToNow(oldMSTime));
}
}
// 6. Load all bank event logs
Log.outInfo(LogFilter.ServerLoading, "Loading guild bank event logs...");
{
uint oldMSTime = Time.GetMSTime();
// Remove log entries that exceed the number of allowed entries per guild
DB.Characters.DirectExecute("DELETE FROM guild_bank_eventlog WHERE LogGuid > {0}", GuildConst.BankLogMaxRecords);
// 0 1 2 3 4 5 6 7 8
SQLResult result = DB.Characters.Query("SELECT guildid, TabId, LogGuid, EventType, PlayerGuid, ItemOrMoney, ItemStackCount, DestTabId, TimeStamp FROM guild_bank_eventlog ORDER BY TimeStamp DESC, LogGuid DESC");
if (result.IsEmpty())
{
Log.outInfo(LogFilter.ServerLoading, "Loaded 0 guild bank event logs. DB table `guild_bank_eventlog` is empty.");
}
else
{
uint count = 0;
do
{
uint guildId = result.Read <uint>(0);
Guild guild = GetGuildById(guildId);
if (guild)
{
guild.LoadBankEventLogFromDB(result.GetFields());
}
++count;
}while (result.NextRow());
Log.outInfo(LogFilter.ServerLoading, "Loaded {0} guild bank event logs in {1} ms", count, Time.GetMSTimeDiffToNow(oldMSTime));
}
}
// 7. Load all news event logs
Log.outInfo(LogFilter.ServerLoading, "Loading Guild News...");
{
uint oldMSTime = Time.GetMSTime();
DB.Characters.DirectExecute("DELETE FROM guild_newslog WHERE LogGuid > {0}", GuildConst.NewsLogMaxRecords);
// 0 1 2 3 4 5 6
SQLResult result = DB.Characters.Query("SELECT guildid, LogGuid, EventType, PlayerGuid, Flags, Value, Timestamp FROM guild_newslog ORDER BY TimeStamp DESC, LogGuid DESC");
if (result.IsEmpty())
{
Log.outInfo(LogFilter.ServerLoading, "Loaded 0 guild event logs. DB table `guild_newslog` is empty.");
}
else
{
uint count = 0;
do
{
uint guildId = result.Read <uint>(0);
Guild guild = GetGuildById(guildId);
if (guild)
{
guild.LoadGuildNewsLogFromDB(result.GetFields());
}
++count;
}while (result.NextRow());
Log.outInfo(LogFilter.ServerLoading, "Loaded {0} guild new logs in {1} ms", count, Time.GetMSTimeDiffToNow(oldMSTime));
}
}
// 8. Load all guild bank tabs
Log.outInfo(LogFilter.ServerLoading, "Loading guild bank tabs...");
{
uint oldMSTime = Time.GetMSTime();
// Delete orphaned guild bank tab entries before loading the valid ones
DB.Characters.DirectExecute("DELETE gbt FROM guild_bank_tab gbt LEFT JOIN guild g ON gbt.guildId = g.guildId WHERE g.guildId IS NULL");
// 0 1 2 3 4
SQLResult result = DB.Characters.Query("SELECT guildid, TabId, TabName, TabIcon, TabText FROM guild_bank_tab ORDER BY guildid ASC, TabId ASC");
if (result.IsEmpty())
{
Log.outInfo(LogFilter.ServerLoading, "Loaded 0 guild bank tabs. DB table `guild_bank_tab` is empty.");
}
else
{
uint count = 0;
do
{
uint guildId = result.Read <uint>(0);
Guild guild = GetGuildById(guildId);
if (guild)
{
guild.LoadBankTabFromDB(result.GetFields());
}
++count;
}while (result.NextRow());
Log.outInfo(LogFilter.ServerLoading, "Loaded {0} guild bank tabs in {1} ms", count, Time.GetMSTimeDiffToNow(oldMSTime));
}
}
// 9. Fill all guild bank tabs
Log.outInfo(LogFilter.ServerLoading, "Filling bank tabs with items...");
{
uint oldMSTime = Time.GetMSTime();
// Delete orphan guild bank items
DB.Characters.DirectExecute("DELETE gbi FROM guild_bank_item gbi LEFT JOIN guild g ON gbi.guildId = g.guildId WHERE g.guildId IS NULL");
SQLResult result = DB.Characters.Query(DB.Characters.GetPreparedStatement(CharStatements.SEL_GUILD_BANK_ITEMS));
if (result.IsEmpty())
{
Log.outInfo(LogFilter.ServerLoading, "Loaded 0 guild bank tab items. DB table `guild_bank_item` or `item_instance` is empty.");
}
else
{
uint count = 0;
do
{
ulong guildId = result.Read <ulong>(43);
Guild guild = GetGuildById(guildId);
if (guild)
{
guild.LoadBankItemFromDB(result.GetFields());
}
++count;
}while (result.NextRow());
Log.outInfo(LogFilter.ServerLoading, "Loaded {0} guild bank tab items in {1} ms", count, Time.GetMSTimeDiffToNow(oldMSTime));
}
}
// 10. Load guild achievements
Log.outInfo(LogFilter.ServerLoading, "Loading guild achievements...");
{
uint oldMSTime = Time.GetMSTime();
foreach (var pair in GuildStore)
{
PreparedStatement stmt = DB.Characters.GetPreparedStatement(CharStatements.SEL_GUILD_ACHIEVEMENT);
stmt.AddValue(0, pair.Key);
SQLResult achievementResult = DB.Characters.Query(stmt);
stmt = DB.Characters.GetPreparedStatement(CharStatements.SEL_GUILD_ACHIEVEMENT_CRITERIA);
stmt.AddValue(0, pair.Key);
SQLResult criteriaResult = DB.Characters.Query(stmt);
pair.Value.GetAchievementMgr().LoadFromDB(achievementResult, criteriaResult);
}
Log.outInfo(LogFilter.ServerLoading, "Loaded guild achievements and criterias in {0} ms", Time.GetMSTimeDiffToNow(oldMSTime));
}
// 11. Validate loaded guild data
Log.outInfo(LogFilter.Server, "Validating data of loaded guilds...");
{
uint oldMSTime = Time.GetMSTime();
foreach (var guild in GuildStore.ToList())
{
if (!guild.Value.Validate())
{
GuildStore.Remove(guild.Key);
}
}
Log.outInfo(LogFilter.ServerLoading, "Validated data of loaded guilds in {0} ms", Time.GetMSTimeDiffToNow(oldMSTime));
}
}
public void LoadFromDB()
{
// Pool templates
{
uint oldMSTime = Time.GetMSTime();
SQLResult result = DB.World.Query("SELECT entry, max_limit FROM pool_template");
if (result.IsEmpty())
{
mPoolTemplate.Clear();
Log.outInfo(LogFilter.ServerLoading, "Loaded 0 object pools. DB table `pool_template` is empty.");
return;
}
uint count = 0;
do
{
uint pool_id = result.Read <uint>(0);
PoolTemplateData pPoolTemplate = new();
pPoolTemplate.MaxLimit = result.Read <uint>(1);
mPoolTemplate[pool_id] = pPoolTemplate;
++count;
}while (result.NextRow());
Log.outInfo(LogFilter.ServerLoading, "Loaded {0} objects pools in {1} ms", count, Time.GetMSTimeDiffToNow(oldMSTime));
}
// Creatures
Log.outInfo(LogFilter.ServerLoading, "Loading Creatures Pooling Data...");
{
uint oldMSTime = Time.GetMSTime();
// 1 2 3
SQLResult result = DB.World.Query("SELECT spawnId, poolSpawnId, chance FROM pool_members WHERE type = 0");
if (result.IsEmpty())
{
Log.outInfo(LogFilter.ServerLoading, "Loaded 0 creatures in pools. DB table `pool_creature` is empty.");
}
else
{
uint count = 0;
do
{
ulong guid = result.Read <ulong>(0);
uint pool_id = result.Read <uint>(1);
float chance = result.Read <float>(2);
CreatureData data = Global.ObjectMgr.GetCreatureData(guid);
if (data == null)
{
Log.outError(LogFilter.Sql, "`pool_creature` has a non existing creature spawn (GUID: {0}) defined for pool id ({1}), skipped.", guid, pool_id);
continue;
}
if (!mPoolTemplate.ContainsKey(pool_id))
{
Log.outError(LogFilter.Sql, "`pool_creature` pool id ({0}) is not in `pool_template`, skipped.", pool_id);
continue;
}
if (chance < 0 || chance > 100)
{
Log.outError(LogFilter.Sql, "`pool_creature` has an invalid chance ({0}) for creature guid ({1}) in pool id ({2}), skipped.", chance, guid, pool_id);
continue;
}
PoolTemplateData pPoolTemplate = mPoolTemplate[pool_id];
PoolObject plObject = new(guid, chance);
if (!mPoolCreatureGroups.ContainsKey(pool_id))
{
mPoolCreatureGroups[pool_id] = new PoolGroup <Creature>();
}
PoolGroup <Creature> cregroup = mPoolCreatureGroups[pool_id];
cregroup.SetPoolId(pool_id);
cregroup.AddEntry(plObject, pPoolTemplate.MaxLimit);
mCreatureSearchMap.Add(guid, pool_id);
++count;
}while (result.NextRow());
Log.outInfo(LogFilter.ServerLoading, "Loaded {0} creatures in pools in {1} ms", count, Time.GetMSTimeDiffToNow(oldMSTime));
}
}
// Gameobjects
Log.outInfo(LogFilter.ServerLoading, "Loading Gameobject Pooling Data...");
{
uint oldMSTime = Time.GetMSTime();
// 1 2 3
SQLResult result = DB.World.Query("SELECT spawnId, poolSpawnId, chance FROM pool_members WHERE type = 1");
if (result.IsEmpty())
{
Log.outInfo(LogFilter.ServerLoading, "Loaded 0 gameobjects in pools. DB table `pool_gameobject` is empty.");
}
else
{
uint count = 0;
do
{
ulong guid = result.Read <ulong>(0);
uint pool_id = result.Read <uint>(1);
float chance = result.Read <float>(2);
GameObjectData data = Global.ObjectMgr.GetGameObjectData(guid);
if (data == null)
{
Log.outError(LogFilter.Sql, "`pool_gameobject` has a non existing gameobject spawn (GUID: {0}) defined for pool id ({1}), skipped.", guid, pool_id);
continue;
}
GameObjectTemplate goinfo = Global.ObjectMgr.GetGameObjectTemplate(data.Id);
if (goinfo.type != GameObjectTypes.Chest &&
goinfo.type != GameObjectTypes.FishingHole &&
goinfo.type != GameObjectTypes.GatheringNode &&
goinfo.type != GameObjectTypes.Goober)
{
Log.outError(LogFilter.Sql, "`pool_gameobject` has a not lootable gameobject spawn (GUID: {0}, type: {1}) defined for pool id ({2}), skipped.", guid, goinfo.type, pool_id);
continue;
}
if (!mPoolTemplate.ContainsKey(pool_id))
{
Log.outError(LogFilter.Sql, "`pool_gameobject` pool id ({0}) is not in `pool_template`, skipped.", pool_id);
continue;
}
if (chance < 0 || chance > 100)
{
Log.outError(LogFilter.Sql, "`pool_gameobject` has an invalid chance ({0}) for gameobject guid ({1}) in pool id ({2}), skipped.", chance, guid, pool_id);
continue;
}
PoolTemplateData pPoolTemplate = mPoolTemplate[pool_id];
PoolObject plObject = new(guid, chance);
if (!mPoolGameobjectGroups.ContainsKey(pool_id))
{
mPoolGameobjectGroups[pool_id] = new PoolGroup <GameObject>();
}
PoolGroup <GameObject> gogroup = mPoolGameobjectGroups[pool_id];
gogroup.SetPoolId(pool_id);
gogroup.AddEntry(plObject, pPoolTemplate.MaxLimit);
mGameobjectSearchMap.Add(guid, pool_id);
++count;
}while (result.NextRow());
Log.outInfo(LogFilter.ServerLoading, "Loaded {0} gameobject in pools in {1} ms", count, Time.GetMSTimeDiffToNow(oldMSTime));
}
}
// Pool of pools
Log.outInfo(LogFilter.ServerLoading, "Loading Mother Pooling Data...");
{
uint oldMSTime = Time.GetMSTime();
// 1 2 3
SQLResult result = DB.World.Query("SELECT spawnId, poolSpawnId, chance FROM pool_members WHERE type = 2");
if (result.IsEmpty())
{
Log.outInfo(LogFilter.ServerLoading, "Loaded 0 pools in pools");
}
else
{
uint count = 0;
do
{
uint child_pool_id = result.Read <uint>(0);
uint mother_pool_id = result.Read <uint>(1);
float chance = result.Read <float>(2);
if (!mPoolTemplate.ContainsKey(mother_pool_id))
{
Log.outError(LogFilter.Sql, "`pool_pool` mother_pool id ({0}) is not in `pool_template`, skipped.", mother_pool_id);
continue;
}
if (!mPoolTemplate.ContainsKey(child_pool_id))
{
Log.outError(LogFilter.Sql, "`pool_pool` included pool_id ({0}) is not in `pool_template`, skipped.", child_pool_id);
continue;
}
if (mother_pool_id == child_pool_id)
{
Log.outError(LogFilter.Sql, "`pool_pool` pool_id ({0}) includes itself, dead-lock detected, skipped.", child_pool_id);
continue;
}
if (chance < 0 || chance > 100)
{
Log.outError(LogFilter.Sql, "`pool_pool` has an invalid chance ({0}) for pool id ({1}) in mother pool id ({2}), skipped.", chance, child_pool_id, mother_pool_id);
continue;
}
PoolTemplateData pPoolTemplateMother = mPoolTemplate[mother_pool_id];
PoolObject plObject = new(child_pool_id, chance);
if (!mPoolPoolGroups.ContainsKey(mother_pool_id))
{
mPoolPoolGroups[mother_pool_id] = new PoolGroup <Pool>();
}
PoolGroup <Pool> plgroup = mPoolPoolGroups[mother_pool_id];
plgroup.SetPoolId(mother_pool_id);
plgroup.AddEntry(plObject, pPoolTemplateMother.MaxLimit);
mPoolSearchMap.Add(child_pool_id, mother_pool_id);
++count;
}while (result.NextRow());
Log.outInfo(LogFilter.ServerLoading, "Loaded {0} pools in mother pools in {1} ms", count, Time.GetMSTimeDiffToNow(oldMSTime));
}
}
// The initialize method will spawn all pools not in an event and not in another pool, this is why there is 2 left joins with 2 null checks
Log.outInfo(LogFilter.ServerLoading, "Starting objects pooling system...");
{
uint oldMSTime = Time.GetMSTime();
SQLResult result = DB.World.Query("SELECT DISTINCT pool_template.entry, pool_members.spawnId, pool_members.poolSpawnId FROM pool_template" +
" LEFT JOIN game_event_pool ON pool_template.entry=game_event_pool.pool_entry" +
" LEFT JOIN pool_members ON pool_members.type = 2 AND pool_template.entry = pool_members.spawnId WHERE game_event_pool.pool_entry IS NULL");
if (result.IsEmpty())
{
Log.outInfo(LogFilter.ServerLoading, "Pool handling system initialized, 0 pools spawned.");
}
else
{
uint count = 0;
do
{
uint pool_entry = result.Read <uint>(0);
uint pool_pool_id = result.Read <uint>(1);
if (!CheckPool(pool_entry))
{
if (pool_pool_id != 0)
{
// The pool is a child pool in pool_pool table. Ideally we should remove it from the pool handler to ensure it never gets spawned,
// however that could recursively invalidate entire chain of mother pools. It can be done in the future but for now we'll do nothing.
Log.outError(LogFilter.Sql, "Pool Id {0} has no equal chance pooled entites defined and explicit chance sum is not 100. This broken pool is a child pool of Id {1} and cannot be safely removed.", pool_entry, result.Read <uint>(2));
}
else
{
Log.outError(LogFilter.Sql, "Pool Id {0} has no equal chance pooled entites defined and explicit chance sum is not 100. The pool will not be spawned.", pool_entry);
}
continue;
}
// Don't spawn child pools, they are spawned recursively by their parent pools
if (pool_pool_id == 0)
{
SpawnPool(pool_entry);
count++;
}
}while (result.NextRow());
Log.outInfo(LogFilter.ServerLoading, "Pool handling system initialized, {0} pools spawned in {1} ms", count, Time.GetMSTimeDiffToNow(oldMSTime));
}
}
}
public void Load()
{
var oldMSTime = Time.GetMSTime();
// 0 1 2 3 4 5 6 7 8 9
SQLResult result = DB.World.Query("SELECT id, point, position_x, position_y, position_z, orientation, move_type, delay, action, action_chance FROM waypoint_data ORDER BY id, point");
if (result.IsEmpty())
{
Log.outError(LogFilter.ServerLoading, "Loaded 0 waypoints. DB table `waypoint_data` is empty!");
return;
}
uint count = 0;
do
{
uint pathId = result.Read <uint>(0);
float x = result.Read <float>(2);
float y = result.Read <float>(3);
float z = result.Read <float>(4);
float o = result.Read <float>(5);
GridDefines.NormalizeMapCoord(ref x);
GridDefines.NormalizeMapCoord(ref y);
WaypointNode wp = new WaypointNode();
wp.id = result.Read <uint>(1);
wp.x = x;
wp.y = y;
wp.z = z;
wp.orientation = o;
wp.moveType = (WaypointMoveType)result.Read <uint>(6);
if (wp.moveType >= WaypointMoveType.Max)
{
Log.outError(LogFilter.Sql, "Waypoint {0} in waypoint_data has invalid move_type, ignoring", wp.id);
continue;
}
wp.delay = result.Read <uint>(7);
wp.eventId = result.Read <uint>(8);
wp.eventChance = result.Read <byte>(9);
if (!_waypointStore.ContainsKey(pathId))
{
_waypointStore[pathId] = new WaypointPath();
}
_waypointStore[pathId].nodes.Add(wp);
++count;
} while (result.NextRow());
Log.outInfo(LogFilter.ServerLoading, "Loaded {0} waypoints in {1} ms", count, Time.GetMSTimeDiffToNow(oldMSTime));
}
public void LoadCreatureTextLocales()
{
uint oldMSTime = Time.GetMSTime();
mLocaleTextMap.Clear(); // for reload case
SQLResult result = DB.World.Query("SELECT entry, groupid, id, text_loc1, text_loc2, text_loc3, text_loc4, text_loc5, text_loc6, text_loc7, text_loc8 FROM locales_creature_text");
if (result.IsEmpty())
{
return;
}
uint textCount = 0;
do
{
CreatureTextLocale loc = new CreatureTextLocale();
for (byte locale = 1; locale < (int)LocaleConstant.OldTotal; ++locale)
{
ObjectManager.AddLocaleString(result.Read <string>(3 + locale - 1), (LocaleConstant)locale, loc.Text);
}
mLocaleTextMap[new CreatureTextId(result.Read <uint>(0), result.Read <byte>(1), result.Read <byte>(2))] = loc;
++textCount;
} while (result.NextRow());
Log.outInfo(LogFilter.ServerLoading, "Loaded {0} creature localized texts in {1} ms", textCount, Time.GetMSTimeDiffToNow(oldMSTime));
}
