araxiaonline/AscEmu
3
0
Fork 0
mirror of https://github.com/araxiaonline/AscEmu.git synced 2026-06-13 03:02:22 -04:00
Code Issues Packages Projects Releases Wiki Activity

Cleanup ObjectMgr misc functions

Browse Source
This commit is contained in:
Zyres
2023-07-22 00:17:31 +02:00
parent 95996c5885
commit e5e2942aa4
11 changed files with 256 additions and 272 deletions
Download Patch File Download Diff File Expand all files Collapse all files

397
src/world/Management/ObjectMgr.cpp
View File

@@ -90,14 +90,14 @@ void ObjectMgr::finalize()
delete i->second;
}
sLogger.info("ObjectMgr : Deleting Trainers...");
for (TrainerMap::iterator i = mTrainers.begin(); i != mTrainers.end(); ++i)
sLogger.info("ObjectMgr : Deleting Trainers UIMessages...");
for (auto trainerPair : m_trainers)
{
Trainer* t = i->second;
if (t->UIMessage && t->UIMessage != (char*)NormalTalkMessage)
delete[] t->UIMessage;
delete t;
auto trainer = trainerPair.second;
if (trainer->UIMessage && trainer->UIMessage != (char*)NormalTalkMessage)
delete[] trainer->UIMessage;
}
m_trainers.clear();
sLogger.info("ObjectMgr : Deleting Level Information...");
for (LevelInfoMap::iterator i = mLevelInfo.begin(); i != mLevelInfo.end(); ++i)
@@ -175,10 +175,8 @@ void ObjectMgr::finalize()
m_cachedCharacterInfo.clear();
sLogger.info("ObjectMgr : Deleting Boss Information...");
for (DungeonEncounterContainer::iterator itr = _dungeonEncounterStore.begin(); itr != _dungeonEncounterStore.end(); ++itr)
for (DungeonEncounterList::iterator encounterItr = itr->second.begin(); encounterItr != itr->second.end(); ++encounterItr)
delete *encounterItr;
sLogger.info("ObjectMgr : Clearing Boss Information...");
m_dungeonEncounterStore.clear();
sLogger.info("ObjectMgr : Clearing Arena Teams...");
m_arenaTeams.clear();
@@ -190,15 +188,15 @@ void ObjectMgr::finalize()
#endif
sLogger.info("ObjectMgr : Cleaning up worldstate templates...");
for (std::map< uint32, std::multimap< uint32, WorldState >* >::iterator itr = worldstate_templates.begin(); itr != worldstate_templates.end(); ++itr)
for (std::map< uint32, std::multimap< uint32, WorldState >* >::iterator itr = m_worldstateTemplates.begin(); itr != m_worldstateTemplates.end(); ++itr)
{
itr->second->clear();
delete itr->second;
}
worldstate_templates.clear();
m_worldstateTemplates.clear();
_creatureDisplayInfoData.clear();
m_creatureDisplayInfoData.clear();
sLogger.info("ObjectMgr : Clearing up event scripts...");
mEventScriptMaps.clear();
@@ -833,20 +831,20 @@ void ObjectMgr::loadCompletedAchievements()
delete result;
}
AchievementReward const* ObjectMgr::getAchievementReward(uint32_t entry, uint8_t gender)
AchievementReward const* ObjectMgr::getAchievementReward(uint32_t _entry, uint8_t _gender)
{
AchievementRewardsMapBounds bounds = m_achievementRewards.equal_range(entry);
AchievementRewardsMapBounds bounds = m_achievementRewards.equal_range(_entry);
for (AchievementRewardsMap::const_iterator iter = bounds.first; iter != bounds.second; ++iter)
{
if (iter->second.gender == 2 || iter->second.gender == gender)
if (iter->second.gender == 2 || iter->second.gender == _gender)
return &iter->second;
}
return nullptr;
}
AchievementCriteriaEntryList const& ObjectMgr::getAchievementCriteriaByType(AchievementCriteriaTypes type)
AchievementCriteriaEntryList const& ObjectMgr::getAchievementCriteriaByType(AchievementCriteriaTypes _type)
{
return m_AchievementCriteriasByType[type];
return m_AchievementCriteriasByType[_type];
}
void ObjectMgr::addCompletedAchievement(uint32_t _achievementId)
@@ -862,16 +860,16 @@ std::set<uint32_t> ObjectMgr::getAllCompleteAchievements()
//////////////////////////////////////////////////////////////////////////////////////////
// Misc
void ObjectMgr::generateDatabaseGossipMenu(Object* object, uint32_t gossipMenuId, Player* player, uint32_t forcedTextId /*= 0*/)
void ObjectMgr::generateDatabaseGossipMenu(Object* _object, uint32_t _gossipMenuId, Player* _player, uint32_t _forcedTextId /*= 0*/)
{
uint32_t textId = 2;
if (forcedTextId == 0)
if (_forcedTextId == 0)
{
auto gossipMenuTextStore = sMySQLStore.getGossipMenuInitTextId();
for (auto& initItr : *gossipMenuTextStore)
{
if (initItr.first == gossipMenuId)
if (initItr.first == _gossipMenuId)
{
textId = initItr.second.textId;
break;
@@ -880,15 +878,15 @@ void ObjectMgr::generateDatabaseGossipMenu(Object* object, uint32_t gossipMenuId
}
else
{
textId = forcedTextId;
textId = _forcedTextId;
}
GossipMenu menu(object->getGuid(), textId, player->getSession()->language, gossipMenuId);
GossipMenu menu(_object->getGuid(), textId, _player->getSession()->language, _gossipMenuId);
sQuestMgr.FillQuestMenu(dynamic_cast<Creature*>(object), player, menu);
sQuestMgr.FillQuestMenu(dynamic_cast<Creature*>(_object), _player, menu);
typedef MySQLDataStore::GossipMenuItemsContainer::iterator GossipMenuItemsIterator;
std::pair<GossipMenuItemsIterator, GossipMenuItemsIterator> gossipEqualRange = sMySQLStore._gossipMenuItemsStores.equal_range(gossipMenuId);
std::pair<GossipMenuItemsIterator, GossipMenuItemsIterator> gossipEqualRange = sMySQLStore._gossipMenuItemsStores.equal_range(_gossipMenuId);
for (GossipMenuItemsIterator itr = gossipEqualRange.first; itr != gossipEqualRange.second; ++itr)
{
// check requirements
@@ -898,24 +896,24 @@ void ObjectMgr::generateDatabaseGossipMenu(Object* object, uint32_t gossipMenuId
// 3 = canGainXP
// 4 = canNotGainXP
if (itr->first == gossipMenuId)
if (itr->first == _gossipMenuId)
{
auto& gossipMenuItem = itr->second;
if (gossipMenuItem.requirementType == 1 && !player->hasQuestInQuestLog(gossipMenuItem.requirementData))
if (gossipMenuItem.requirementType == 1 && !_player->hasQuestInQuestLog(gossipMenuItem.requirementData))
continue;
if (gossipMenuItem.requirementType == 3)
{
if (player->canGainXp())
menu.addItem(gossipMenuItem.icon, gossipMenuItem.menuOptionText, gossipMenuItem.itemOrder, "", gossipMenuItem.onChooseData, player->getSession()->LocalizedGossipOption(gossipMenuItem.onChooseData2));
if (_player->canGainXp())
menu.addItem(gossipMenuItem.icon, gossipMenuItem.menuOptionText, gossipMenuItem.itemOrder, "", gossipMenuItem.onChooseData, _player->getSession()->LocalizedGossipOption(gossipMenuItem.onChooseData2));
continue;
}
if (gossipMenuItem.requirementType == 4)
{
if (!player->canGainXp())
menu.addItem(gossipMenuItem.icon, gossipMenuItem.menuOptionText, gossipMenuItem.itemOrder, "", gossipMenuItem.onChooseData, player->getSession()->LocalizedGossipOption(gossipMenuItem.onChooseData2));
if (!_player->canGainXp())
menu.addItem(gossipMenuItem.icon, gossipMenuItem.menuOptionText, gossipMenuItem.itemOrder, "", gossipMenuItem.onChooseData, _player->getSession()->LocalizedGossipOption(gossipMenuItem.onChooseData2));
continue;
}
@@ -924,20 +922,20 @@ void ObjectMgr::generateDatabaseGossipMenu(Object* object, uint32_t gossipMenuId
}
}
menu.sendGossipPacket(player);
menu.sendGossipPacket(_player);
}
void ObjectMgr::generateDatabaseGossipOptionAndSubMenu(Object* object, Player* player, uint32_t gossipItemId, uint32_t gossipMenuId)
void ObjectMgr::generateDatabaseGossipOptionAndSubMenu(Object* _object, Player* _player, uint32_t _gossipItemId, uint32_t _gossipMenuId)
{
sLogger.debug("GossipId: %u gossipItemId: %u", gossipMenuId, gossipItemId);
sLogger.debug("GossipId: %u gossipItemId: %u", _gossipMenuId, _gossipItemId);
// bool openSubMenu = true;
typedef MySQLDataStore::GossipMenuItemsContainer::iterator GossipMenuItemsIterator;
std::pair<GossipMenuItemsIterator, GossipMenuItemsIterator> gossipEqualRange = sMySQLStore._gossipMenuItemsStores.equal_range(gossipMenuId);
std::pair<GossipMenuItemsIterator, GossipMenuItemsIterator> gossipEqualRange = sMySQLStore._gossipMenuItemsStores.equal_range(_gossipMenuId);
for (GossipMenuItemsIterator itr = gossipEqualRange.first; itr != gossipEqualRange.second; ++itr)
{
if (itr->second.itemOrder == gossipItemId)
if (itr->second.itemOrder == _gossipItemId)
{
// onChooseAction
// 0 = None
@@ -954,18 +952,18 @@ void ObjectMgr::generateDatabaseGossipOptionAndSubMenu(Object* object, Player* p
{
case 1:
{
generateDatabaseGossipMenu(object, itr->second.nextGossipMenu, player, itr->second.nextGossipMenuText);
generateDatabaseGossipMenu(_object, itr->second.nextGossipMenu, _player, itr->second.nextGossipMenuText);
if (itr->second.onChooseData != 0)
player->sendPoiById(itr->second.onChooseData);
_player->sendPoiById(itr->second.onChooseData);
} break;
case 2:
{
if (itr->second.onChooseData != 0)
{
player->castSpell(player, sSpellMgr.getSpellInfo(itr->second.onChooseData), true);
GossipMenu::senGossipComplete(player);
_player->castSpell(_player, sSpellMgr.getSpellInfo(itr->second.onChooseData), true);
GossipMenu::senGossipComplete(_player);
}
} break;
@@ -973,10 +971,10 @@ void ObjectMgr::generateDatabaseGossipOptionAndSubMenu(Object* object, Player* p
{
if (itr->second.onChooseData != 0)
{
if (object->isCreature())
player->getSession()->sendTaxiMenu(object->ToCreature());
if (_object->isCreature())
_player->getSession()->sendTaxiMenu(_object->ToCreature());
GossipMenu::senGossipComplete(player);
GossipMenu::senGossipComplete(_player);
}
} break;
@@ -984,32 +982,32 @@ void ObjectMgr::generateDatabaseGossipOptionAndSubMenu(Object* object, Player* p
{
if (itr->second.onChooseData != 0)
{
if (player->getFactionStanding(itr->second.onChooseData) >= static_cast<int32_t>(itr->second.onChooseData2))
player->castSpell(player, sSpellMgr.getSpellInfo(itr->second.onChooseData3), true);
if (_player->getFactionStanding(itr->second.onChooseData) >= static_cast<int32_t>(itr->second.onChooseData2))
_player->castSpell(_player, sSpellMgr.getSpellInfo(itr->second.onChooseData3), true);
else
player->broadcastMessage(player->getSession()->LocalizedWorldSrv(itr->second.onChooseData4));
_player->broadcastMessage(_player->getSession()->LocalizedWorldSrv(itr->second.onChooseData4));
GossipMenu::senGossipComplete(player);
GossipMenu::senGossipComplete(_player);
}
} break;
case 5:
{
GossipMenu::senGossipComplete(player);
GossipMenu::senGossipComplete(_player);
} break;
case 6:
{
if (player->hasEnoughCoinage(itr->second.onChooseData))
if (_player->hasEnoughCoinage(itr->second.onChooseData))
{
player->modCoinage(-static_cast<int32_t>(itr->second.onChooseData));
player->toggleXpGain();
GossipMenu::senGossipComplete(player);
_player->modCoinage(-static_cast<int32_t>(itr->second.onChooseData));
_player->toggleXpGain();
GossipMenu::senGossipComplete(_player);
}
} break;
default: // action 0
{
generateDatabaseGossipMenu(object, itr->second.nextGossipMenu, player, itr->second.nextGossipMenuText);
generateDatabaseGossipMenu(_object, itr->second.nextGossipMenu, _player, itr->second.nextGossipMenuText);
} break;
}
}
@@ -1119,13 +1117,13 @@ void ObjectMgr::loadTrainerSpellSets()
}
}
std::vector<TrainerSpell> ObjectMgr::getTrainserSpellSetById(uint32_t id)
std::vector<TrainerSpell> ObjectMgr::getTrainerSpellSetById(uint32_t _id)
{
auto itr = m_trainerSpellSet.find(id);
auto itr = m_trainerSpellSet.find(_id);
if (itr == m_trainerSpellSet.end())
return {};
else
return *itr->second;
return *itr->second;
}
void ObjectMgr::loadTrainers()
@@ -1137,7 +1135,7 @@ void ObjectMgr::loadTrainers()
auto* const fields = trainerResult->Fetch();
const auto entry = fields[0].GetUInt32();
Trainer* trainer = new Trainer;
std::shared_ptr<Trainer> trainer = std::make_shared<Trainer>();
trainer->RequiredSkill = fields[2].GetUInt16();
trainer->RequiredSkillLine = fields[3].GetUInt32();
trainer->RequiredClass = fields[4].GetUInt32();
@@ -1172,25 +1170,33 @@ void ObjectMgr::loadTrainers()
trainer->UIMessage[strlen(NormalTalkMessage)] = 0;
}
trainer->SpellCount = static_cast<uint32_t>(getTrainserSpellSetById(trainer->spellset_id).size());
trainer->SpellCount = static_cast<uint32_t>(getTrainerSpellSetById(trainer->spellset_id).size());
// and now we insert it to our lookup table
if (trainer->SpellCount == 0)
{
if (trainer->UIMessage != NormalTalkMessage)
delete[] trainer->UIMessage;
delete trainer;
continue;
}
mTrainers.insert(TrainerMap::value_type(entry, trainer));
m_trainers.insert(std::pair(entry, trainer));
} while (trainerResult->NextRow());
delete trainerResult;
sLogger.info("ObjectMgr : %u trainers loaded.", static_cast<uint32_t>(mTrainers.size()));
sLogger.info("ObjectMgr : %u trainers loaded.", static_cast<uint32_t>(m_trainers.size()));
}
}
std::shared_ptr<Trainer> ObjectMgr::getTrainer(uint32_t _entry)
{
const auto iter = m_trainers.find(_entry);
if (iter == m_trainers.end())
return nullptr;
return iter->second;
}
void ObjectMgr::loadCreatureDisplayInfo()
{
for (uint32_t i = 0; i < sCreatureDisplayInfoStore.GetNumRows(); ++i)
@@ -1211,14 +1217,14 @@ void ObjectMgr::loadCreatureDisplayInfo()
data.isModelInvisibleStalker = true;
}
_creatureDisplayInfoData.insert(std::make_pair(displayInfoEntry->ID, data));
m_creatureDisplayInfoData.insert(std::make_pair(displayInfoEntry->ID, data));
}
}
CreatureDisplayInfoData const* ObjectMgr::getCreatureDisplayInfoData(uint32_t displayId) const
{
const auto itr = _creatureDisplayInfoData.find(displayId);
if (itr == _creatureDisplayInfoData.cend())
const auto itr = m_creatureDisplayInfoData.find(displayId);
if (itr == m_creatureDisplayInfoData.cend())
return nullptr;
return &itr->second;
@@ -1354,6 +1360,136 @@ GameObject* ObjectMgr::createGameObjectByGuid(uint32_t id, uint32_t guid)
return gameObject;
}
DungeonEncounterList const* ObjectMgr::getDungeonEncounterList(uint32_t _mapId, uint8_t _difficulty)
{
#if VERSION_STRING >= WotLK
std::unordered_map<uint32_t, DungeonEncounterList>::const_iterator itr = m_dungeonEncounterStore.find(uint32_t(uint16_t(_mapId) | (uint32_t(_difficulty) << 16)));
#else
std::unordered_map<uint32_t, DungeonEncounterList>::const_iterator itr = _dungeonEncounterStore.find(_mapId);
#endif
if (itr != m_dungeonEncounterStore.end())
return &itr->second;
return nullptr;
}
void ObjectMgr::loadCreatureMovementOverrides()
{
const auto startTime = Util::TimeNow();
uint32_t count = 0;
m_creatureMovementOverrides.clear();
QueryResult* result = WorldDatabase.Query("SELECT SpawnId, Ground, Swim, Flight, Rooted, Chase, Random from creature_movement_override");
if (!result)
{
sLogger.info("loadCreatureMovementOverrides : Loaded 0 creature movement overrides. DB table `creature_movement_override` is empty!");
return;
}
do
{
Field* fields = result->Fetch();
uint32_t spawnId = fields[0].GetUInt32();
QueryResult* spawnResult = WorldDatabase.Query("SELECT * FROM creature_spawns WHERE id = %u", spawnId);
if (spawnResult == nullptr)
{
sLogger.failure("Creature (SpawnId: %u) does not exist but has a record in `creature_movement_override`", spawnId);
delete spawnResult;
continue;
}
CreatureMovementData& movement = m_creatureMovementOverrides[spawnId];
movement.Ground = static_cast<CreatureGroundMovementType>(fields[1].GetUInt8());
movement.Swim = fields[2].GetBool();
movement.Flight = static_cast<CreatureFlightMovementType>(fields[3].GetUInt8());
movement.Rooted = fields[4].GetBool();
movement.Chase = static_cast<CreatureChaseMovementType>(fields[5].GetUInt8());
movement.Random = static_cast<CreatureRandomMovementType>(fields[6].GetUInt8());
checkCreatureMovement(spawnId, movement);
++count;
} while (result->NextRow());
delete result;
sLogger.info("ObjectMgr : Loaded %u movement overrides in %u ms", count, static_cast<uint32_t>(Util::GetTimeDifferenceToNow(startTime)));
}
void ObjectMgr::checkCreatureMovement(uint32_t /*id*/, CreatureMovementData& _creatureMovement)
{
if (_creatureMovement.Ground >= CreatureGroundMovementType::Max)
_creatureMovement.Ground = CreatureGroundMovementType::Run;
if (_creatureMovement.Flight >= CreatureFlightMovementType::Max)
_creatureMovement.Flight = CreatureFlightMovementType::None;
if (_creatureMovement.Chase >= CreatureChaseMovementType::Max)
_creatureMovement.Chase = CreatureChaseMovementType::Run;
if (_creatureMovement.Random >= CreatureRandomMovementType::Max)
_creatureMovement.Random = CreatureRandomMovementType::Walk;
}
CreatureMovementData const* ObjectMgr::getCreatureMovementOverride(uint32_t _spawnId) const
{
const auto itr = m_creatureMovementOverrides.find(_spawnId);
if (itr != m_creatureMovementOverrides.end())
return &itr->second;
return nullptr;
}
void ObjectMgr::loadWorldStateTemplates()
{
QueryResult* result = WorldDatabase.QueryNA("SELECT DISTINCT map FROM worldstate_templates ORDER BY map;");
if (result == nullptr)
return;
do
{
Field* field = result->Fetch();
uint32_t mapId = field[0].GetUInt32();
m_worldstateTemplates.insert(std::make_pair(mapId, new std::multimap<uint32_t, WorldState>()));
} while (result->NextRow());
delete result;
result = WorldDatabase.QueryNA("SELECT map, zone, field, value FROM worldstate_templates;");
if (result == nullptr)
return;
do
{
Field* field = result->Fetch();
WorldState worldState;
uint32_t mapId = field[0].GetUInt32();
uint32_t zone = field[1].GetUInt32();
worldState.field = field[2].GetUInt32();
worldState.value = field[3].GetUInt32();
auto itr = m_worldstateTemplates.find(mapId);
if (itr == m_worldstateTemplates.end())
continue;
itr->second->insert(std::make_pair(zone, worldState));
} while (result->NextRow());
delete result;
}
std::multimap<uint32, WorldState>* ObjectMgr::getWorldStatesForMap(uint32 map) const
{
const auto itr = m_worldstateTemplates.find(map);
if (itr == m_worldstateTemplates.end())
return nullptr;
return itr->second;
}
//////////////////////////////////////////////////////////////////////////////////////////
// Groups
Group* ObjectMgr::GetGroupByLeader(Player* pPlayer)
@@ -1703,15 +1839,6 @@ Item* ObjectMgr::LoadItem(uint32 lowguid)
return pReturn;
}
Trainer* ObjectMgr::GetTrainer(uint32 Entry)
{
TrainerMap::iterator iter = mTrainers.find(Entry);
if (iter == mTrainers.end())
return nullptr;
return iter->second;
}
void ObjectMgr::GenerateLevelUpInfo()
{
struct MissingLevelData
@@ -2414,57 +2541,6 @@ VehicleAccessoryList const* ObjectMgr::getVehicleAccessories(Vehicle* vehicle)
return nullptr;
}
#endif
void ObjectMgr::LoadWorldStateTemplates()
{
QueryResult* result = WorldDatabase.QueryNA("SELECT DISTINCT map FROM worldstate_templates ORDER BY map;");
if (result == nullptr)
return;
do
{
Field* row = result->Fetch();
uint32 mapid = row[0].GetUInt32();
worldstate_templates.insert(std::make_pair(mapid, new std::multimap< uint32, WorldState >()));
} while (result->NextRow());
delete result;
result = WorldDatabase.QueryNA("SELECT map, zone, field, value FROM worldstate_templates;");
if (result == nullptr)
return;
do
{
Field* row = result->Fetch();
WorldState ws;
uint32 mapid = row[0].GetUInt32();
uint32 zone = row[1].GetUInt32();
ws.field = row[2].GetUInt32();
ws.value = row[3].GetUInt32();
std::map< uint32, std::multimap< uint32, WorldState >* >::iterator itr = worldstate_templates.find(mapid);
if (itr == worldstate_templates.end())
continue;
itr->second->insert(std::make_pair(zone, ws));
} while (result->NextRow());
delete result;
}
std::multimap< uint32, WorldState >* ObjectMgr::GetWorldStatesForMap(uint32 map) const
{
std::map< uint32, std::multimap< uint32, WorldState >* >::const_iterator itr = worldstate_templates.find(map);
if (itr == worldstate_templates.end())
return nullptr;
else
return itr->second;
}
void ObjectMgr::LoadEventScripts()
{
@@ -2754,10 +2830,10 @@ void ObjectMgr::LoadInstanceEncounters()
#if VERSION_STRING <= TBC
DungeonEncounterList& encounters = _dungeonEncounterStore[mapId];
encounters.push_back(new DungeonEncounter(EncounterCreditType(creditType), creditEntry));
encounters.push_back(std::make_shared<DungeonEncounter>(EncounterCreditType(creditType), creditEntry));
#else
DungeonEncounterList& encounters = _dungeonEncounterStore[static_cast<int32_t>(static_cast<uint16_t>(dungeonEncounter->mapId) | (static_cast<uint32_t>(dungeonEncounter->difficulty) << 16))];
encounters.push_back(new DungeonEncounter(dungeonEncounter, EncounterCreditType(creditType), creditEntry, lastEncounterDungeon));
DungeonEncounterList& encounters = m_dungeonEncounterStore[static_cast<int32_t>(static_cast<uint16_t>(dungeonEncounter->mapId) | (static_cast<uint32_t>(dungeonEncounter->difficulty) << 16))];
encounters.push_back(std::make_shared<DungeonEncounter>(dungeonEncounter, EncounterCreditType(creditType), creditEntry, lastEncounterDungeon));
#endif
++count;
} while (result->NextRow());
@@ -2765,71 +2841,6 @@ void ObjectMgr::LoadInstanceEncounters()
sLogger.info("ObjectMgr : Loaded %u instance encounters in %u ms", count, static_cast<uint32_t>(Util::GetTimeDifferenceToNow(startTime)));
}
void ObjectMgr::loadCreatureMovementOverrides()
{
const auto startTime = Util::TimeNow();
uint32_t count = 0;
_creatureMovementOverrides.clear();
QueryResult* result = WorldDatabase.Query("SELECT SpawnId, Ground, Swim, Flight, Rooted, Chase, Random from creature_movement_override");
if (!result)
{
sLogger.info("loadCreatureMovementOverrides : Loaded 0 creature movement overrides. DB table `creature_movement_override` is empty!");
return;
}
do
{
Field* fields = result->Fetch();
uint32_t spawnId = fields[0].GetUInt32();
QueryResult* spawnResult = WorldDatabase.Query("SELECT * FROM creature_spawns WHERE id = %u", spawnId);
if (spawnResult == nullptr)
{
sLogger.failure("Creature (SpawnId: %u) does not exist but has a record in `creature_movement_override`", spawnId);
continue;
}
CreatureMovementData& movement = _creatureMovementOverrides[spawnId];
movement.Ground = static_cast<CreatureGroundMovementType>(fields[1].GetUInt8());
movement.Swim = fields[2].GetBool();
movement.Flight = static_cast<CreatureFlightMovementType>(fields[3].GetUInt8());
movement.Rooted = fields[4].GetBool();
movement.Chase = static_cast<CreatureChaseMovementType>(fields[5].GetUInt8());
movement.Random = static_cast<CreatureRandomMovementType>(fields[6].GetUInt8());
checkCreatureMovement(spawnId, movement);
++count;
} while (result->NextRow());
sLogger.info("ObjectMgr : Loaded %u movement overrides in %u ms", count, static_cast<uint32_t>(Util::GetTimeDifferenceToNow(startTime)));
}
void ObjectMgr::checkCreatureMovement(uint32_t /*id*/, CreatureMovementData& creatureMovement)
{
if (creatureMovement.Ground >= CreatureGroundMovementType::Max)
{
creatureMovement.Ground = CreatureGroundMovementType::Run;
}
if (creatureMovement.Flight >= CreatureFlightMovementType::Max)
{
creatureMovement.Flight = CreatureFlightMovementType::None;
}
if (creatureMovement.Chase >= CreatureChaseMovementType::Max)
{
creatureMovement.Chase = CreatureChaseMovementType::Run;
}
if (creatureMovement.Random >= CreatureRandomMovementType::Max)
{
creatureMovement.Random = CreatureRandomMovementType::Walk;
}
}
#if VERSION_STRING > WotLK
uint64_t ObjectMgr::generateVoidStorageItemId()
{

93
src/world/Management/ObjectMgr.h
View File

@@ -86,8 +86,7 @@ struct DungeonEncounter
};
#endif
typedef std::list<DungeonEncounter const*> DungeonEncounterList;
typedef std::unordered_map<uint32_t, DungeonEncounterList> DungeonEncounterContainer;
typedef std::list<std::shared_ptr<DungeonEncounter>> DungeonEncounterList;
//it seems trainerspells should be part of trainer files ;)
struct TrainerSpell
@@ -287,9 +286,9 @@ public:
void loadAchievementRewards();
void loadCompletedAchievements();
AchievementReward const* getAchievementReward(uint32_t entry, uint8_t gender);
AchievementReward const* getAchievementReward(uint32_t _entry, uint8_t _gender);
AchievementCriteriaEntryList const& getAchievementCriteriaByType(AchievementCriteriaTypes type);
AchievementCriteriaEntryList const& getAchievementCriteriaByType(AchievementCriteriaTypes _type);
void addCompletedAchievement(uint32_t _achievementId);
std::set<uint32_t> getAllCompleteAchievements();
@@ -309,12 +308,14 @@ private:
//////////////////////////////////////////////////////////////////////////////////////////
// Misc
public:
void generateDatabaseGossipMenu(Object* object, uint32_t gossipMenuId, Player* player, uint32_t forcedTextId = 0);
void generateDatabaseGossipOptionAndSubMenu(Object* object, Player* player, uint32_t gossipItemId, uint32_t gossipMenuId);
void generateDatabaseGossipMenu(Object* _object, uint32_t _gossipMenuId, Player* _player, uint32_t _forcedTextId = 0);
void generateDatabaseGossipOptionAndSubMenu(Object* _object, Player* _player, uint32_t _gossipItemId, uint32_t _gossipMenuId);
void loadTrainerSpellSets();
std::vector<TrainerSpell> getTrainserSpellSetById(uint32_t id);
std::vector<TrainerSpell> getTrainerSpellSetById(uint32_t _id);
void loadTrainers();
std::shared_ptr<Trainer> getTrainer(uint32_t _entry);
// Preload CreatureDisplayInfoStore and CreatureModelDataStore to avoid DBC lookup calls
void loadCreatureDisplayInfo();
@@ -324,6 +325,31 @@ public:
GameObject* createGameObjectByGuid(uint32_t id, uint32_t guid);
DungeonEncounterList const* getDungeonEncounterList(uint32_t _mapId, uint8_t _difficulty);
void loadCreatureMovementOverrides();
void checkCreatureMovement(uint32_t _id, CreatureMovementData& _creatureMovement);
CreatureMovementData const* getCreatureMovementOverride(uint32_t _spawnId) const;
void loadWorldStateTemplates();
std::multimap<uint32_t, WorldState>* getWorldStatesForMap(uint32_t map) const;
private:
std::unordered_map<uint32_t, std::vector<TrainerSpell>*> m_trainerSpellSet;
std::unordered_map<uint32_t, std::shared_ptr<Trainer>> m_trainers;
std::unordered_map<uint32_t, CreatureDisplayInfoData> m_creatureDisplayInfoData;
std::unordered_map<uint32_t, DungeonEncounterList> m_dungeonEncounterStore;
std::unordered_map<uint32_t, CreatureMovementData> m_creatureMovementOverrides;
std::map<uint32_t, std::multimap<uint32_t, WorldState>*> m_worldstateTemplates;
public:
void LoadCreatureTimedEmotes();
TimedEmoteList* GetTimedEmoteList(uint32 spawnid);
@@ -331,23 +357,17 @@ public:
// Set typedef's
typedef std::unordered_map<uint32, Group*> GroupMap;
typedef std::unordered_map<uint32, std::vector<CreatureItem>*> VendorMap;
typedef std::unordered_map<uint32, Trainer*> TrainerMap;
typedef std::unordered_map<uint32, ReputationModifier*> ReputationModMap;
// Map typedef's
typedef std::map<uint32, LevelInfo*> LevelMap;
typedef std::map<std::pair<uint32, uint32>, LevelMap*> LevelInfoMap;
typedef std::map<uint32, uint32> PetSpellCooldownMap;
typedef std::multimap <uint32, uint32> BCEntryStorage;
typedef std::unordered_map<uint32_t, std::vector<TrainerSpell>*> TrainerSpellSetContainer;
Player* GetPlayer(const char* name, bool caseSensitive = true);
Player* GetPlayer(uint32 guid);
Mutex m_creatureSetMutex;
Item* CreateItem(uint32 entry, Player* owner);
@@ -397,8 +417,6 @@ public:
uint64_t generateVoidStorageItemId();
#endif
Trainer* GetTrainer(uint32 Entry);
LevelInfo* GetLevelInfo(uint32 Race, uint32 Class, uint32 Level);
void GenerateLevelUpInfo();
@@ -410,43 +428,10 @@ public:
uint32 GenerateCreatureSpawnID();
uint32 GenerateGameObjectSpawnID();
bool HandleInstanceReputationModifiers(Player* pPlayer, Unit* pVictim);
void LoadInstanceReputationModifiers();
void LoadInstanceEncounters();
void loadCreatureMovementOverrides();
void checkCreatureMovement(uint32_t id, CreatureMovementData& creatureMovement);
CreatureMovementData const* getCreatureMovementOverride(uint32_t spawnId) const
{
auto itr = _creatureMovementOverrides.find(spawnId);
if (itr != _creatureMovementOverrides.end())
return &itr->second;
return NULL;
}
#if VERSION_STRING >= WotLK
DungeonEncounterList const* GetDungeonEncounterList(uint32_t mapId, uint8_t difficulty)
{
std::unordered_map<uint32_t, DungeonEncounterList>::const_iterator itr = _dungeonEncounterStore.find(uint32(uint16(mapId) | (uint32(difficulty) << 16)));
if (itr != _dungeonEncounterStore.end())
return &itr->second;
return NULL;
}
#endif
#if VERSION_STRING <= TBC
DungeonEncounterList const* GetDungeonEncounterList(uint32_t mapId, uint8 difficulty = 0)
{
std::unordered_map<uint32_t, DungeonEncounterList>::const_iterator itr = _dungeonEncounterStore.find(mapId);
if (itr != _dungeonEncounterStore.end())
return &itr->second;
return NULL;
}
#endif
//////////////////////////////////////////////////////////////////////////////////////////
// Event Scripts
void LoadEventScripts();
@@ -457,7 +442,6 @@ public:
void EventScriptsUpdate(Player* plr, uint32 next_event);
//////////////////////////////////////////////////////////////////////////////////////////
#ifdef FT_VEHICLES
void LoadVehicleAccessories();
VehicleAccessoryList const* getVehicleAccessories(Vehicle* vehicle);
@@ -473,19 +457,11 @@ public:
}
#endif
void LoadWorldStateTemplates();
std::multimap< uint32, WorldState >* GetWorldStatesForMap(uint32 map) const;
private:
EventScriptMaps mEventScriptMaps;
SpellEffectMaps mSpellEffectMaps;
DungeonEncounterContainer _dungeonEncounterStore;
std::unordered_map<uint32_t, CreatureMovementData> _creatureMovementOverrides;
std::unordered_map<uint32_t, CreatureDisplayInfoData> _creatureDisplayInfoData;
protected:
// highest GUIDs, used for creating new objects
std::atomic<unsigned long> m_hiItemGuid;
std::atomic<unsigned long> m_hiGroupId;
@@ -519,8 +495,6 @@ public:
/// Map of all vendor goods
VendorMap mVendors;
TrainerSpellSetContainer m_trainerSpellSet;
TrainerMap mTrainers;
LevelInfoMap mLevelInfo;
PetSpellCooldownMap mPetSpellCooldowns;
@@ -528,7 +502,6 @@ public:
VehicleAccessoryContainer _vehicleAccessoryStore;
VehicleSeatAddonContainer _vehicleSeatAddonStore;
#endif
std::map< uint32, std::multimap<uint32, WorldState>* > worldstate_templates;
};
#define sObjectMgr ObjectMgr::getInstance()

2
src/world/Map/Maps/InstanceMap.cpp
View File

@@ -270,7 +270,7 @@ void InstanceMap::createInstanceData(bool load)
if (getScript() == nullptr)
return;
auto const& encounters = sObjectMgr.GetDungeonEncounterList(getBaseMap()->getMapId(), getDifficulty());
auto const& encounters = sObjectMgr.getDungeonEncounterList(getBaseMap()->getMapId(), getDifficulty());
uint32_t bossNumber = static_cast<uint32_t>(encounters->size());

2
src/world/Map/Maps/WorldMap.cpp
View File

@@ -87,7 +87,7 @@ void WorldMap::initialize()
// load corpses
sObjectMgr.loadCorpsesForInstance(this);
worldstateshandler.InitWorldStates(sObjectMgr.GetWorldStatesForMap(getBaseMap()->getMapId()));
worldstateshandler.InitWorldStates(sObjectMgr.getWorldStatesForMap(getBaseMap()->getMapId()));
worldstateshandler.setObserver(this);
}

6
src/world/Objects/Units/Creatures/Creature.cpp
View File

@@ -1360,7 +1360,7 @@ void Creature::SetCreatureProperties(CreatureProperties const* cp)
creature_properties = cp;
}
Trainer* Creature::GetTrainer()
std::shared_ptr<Trainer> Creature::GetTrainer()
{
return mTrainer;
}
@@ -1610,7 +1610,7 @@ bool Creature::Load(MySQLStructure::CreatureSpawn* spawn, uint8 mode, MySQLStruc
_LoadQuests();
if (isTrainer() || isProfessionTrainer())
mTrainer = sObjectMgr.GetTrainer(getEntry());
mTrainer = sObjectMgr.getTrainer(getEntry());
if (isAuctioneer())
auctionHouse = sAuctionMgr.GetAuctionHouse(getEntry());
@@ -1845,7 +1845,7 @@ void Creature::Load(CreatureProperties const* properties_, float x, float y, flo
_LoadQuests();
if (isTrainer() || isProfessionTrainer())
mTrainer = sObjectMgr.GetTrainer(getEntry());
mTrainer = sObjectMgr.getTrainer(getEntry());
if (isAuctioneer())
auctionHouse = sAuctionMgr.GetAuctionHouse(getEntry());

4
src/world/Objects/Units/Creatures/Creature.h
View File

@@ -316,7 +316,7 @@ public:
CreatureProperties const* GetCreatureProperties();
void SetCreatureProperties(CreatureProperties const* creature_properties);
Trainer* GetTrainer();
std::shared_ptr<Trainer> GetTrainer();
DBC::Structures::CreatureFamilyEntry const* myFamily = nullptr;
@@ -376,7 +376,7 @@ public:
CreatureAIScript* _myScriptClass = nullptr;
bool m_limbostate = false;
Trainer* mTrainer = nullptr;
std::shared_ptr<Trainer> mTrainer = nullptr;
// Movement
MovementGeneratorType m_defaultMovementType = IDLE_MOTION_TYPE;

2
src/world/Objects/Units/Players/Player.cpp
View File

@@ -10201,7 +10201,7 @@ bool Player::canBuyAt(MySQLStructure::VendorRestrictions const* vendor)
return true;
}
bool Player::canTrainAt(Trainer* trainer)
bool Player::canTrainAt(std::shared_ptr<Trainer> trainer)
{
if (!trainer)
return false;

2
src/world/Objects/Units/Players/Player.hpp
View File

@@ -1795,7 +1795,7 @@ public:
void sendWorldStateUpdate(uint32_t worldState, uint32_t value);
bool canBuyAt(MySQLStructure::VendorRestrictions const* vendor);
bool canTrainAt(Trainer* trainer);
bool canTrainAt(std::shared_ptr<Trainer> trainer);
void sendCinematicCamera(uint32_t id);

8
src/world/Server/Packets/Handlers/NPCHandler.cpp
View File

@@ -140,7 +140,7 @@ void WorldSession::handleTrainerBuySpellOpcode(WorldPacket& recvPacket)
TrainerSpell const* trainerSpell = nullptr;
std::vector<TrainerSpell>::const_iterator itr;
std::vector<TrainerSpell> its = sObjectMgr.getTrainserSpellSetById(trainer->spellset_id);
std::vector<TrainerSpell> its = sObjectMgr.getTrainerSpellSetById(trainer->spellset_id);
for (itr = its.begin(); itr != its.end(); itr++)
{
@@ -409,7 +409,7 @@ void WorldSession::sendTrainerList(Creature* creature)
uiMessage = trainer->UIMessage;
const size_t size = 8 + 4 + 4 + 4 + uiMessage.size()
+ (sObjectMgr.getTrainserSpellSetById(trainer->spellset_id).size() * (4 + 1 + 4 + 4 + 4 + 1 + 4 + 4 + 4 + 4 + 4));
+ (sObjectMgr.getTrainerSpellSetById(trainer->spellset_id).size() * (4 + 1 + 4 + 4 + 4 + 1 + 4 + 4 + 4 + 4 + 4));
WorldPacket data(SMSG_TRAINER_LIST, size);
data << creature->getGuid();
@@ -420,10 +420,10 @@ void WorldSession::sendTrainerList(Creature* creature)
#endif
size_t count_p = data.wpos();
data << uint32_t(sObjectMgr.getTrainserSpellSetById(trainer->spellset_id).size());
data << uint32_t(sObjectMgr.getTrainerSpellSetById(trainer->spellset_id).size());
uint32_t count = 0;
for (const auto& spellItr : sObjectMgr.getTrainserSpellSetById(trainer->spellset_id))
for (const auto& spellItr : sObjectMgr.getTrainerSpellSetById(trainer->spellset_id))
{
auto* const trainerSpell = &spellItr;

10
src/world/Server/Script/ScriptMgr.cpp
View File

@@ -1045,12 +1045,12 @@ GameObject* InstanceScript::getGameObjectFromData(uint32_t type)
// encounters
void InstanceScript::generateBossDataState()
{
const auto* encounters = sObjectMgr.GetDungeonEncounterList(getWorldMap()->getBaseMap()->getMapId(), getWorldMap()->getDifficulty());
const auto* encounters = sObjectMgr.getDungeonEncounterList(getWorldMap()->getBaseMap()->getMapId(), getWorldMap()->getDifficulty());
uint32_t i = 0;
for (DungeonEncounterList::const_iterator itr = encounters->begin(); itr != encounters->end(); ++itr, ++i)
{
DungeonEncounter const* encounter = *itr;
const auto encounter = *itr;
BossInfo* bossInfo = &bosses[i];
bossInfo->entry = encounter->creditEntry;
@@ -1123,12 +1123,12 @@ void InstanceScript::loadSavedInstanceData(char const* data)
void InstanceScript::readSaveDataBossStates(std::istringstream& data)
{
const auto* encounters = sObjectMgr.GetDungeonEncounterList(getWorldMap()->getBaseMap()->getMapId(), getWorldMap()->getDifficulty());
const auto* encounters = sObjectMgr.getDungeonEncounterList(getWorldMap()->getBaseMap()->getMapId(), getWorldMap()->getDifficulty());
size_t i = 0;
for (DungeonEncounterList::const_iterator itr = encounters->begin(); itr != encounters->end(); ++itr, ++i)
{
DungeonEncounter const* encounter = *itr;
const auto encounter = *itr;
BossInfo* bossInfo = &bosses[i];
bossInfo->entry = encounter->creditEntry;
@@ -1168,7 +1168,7 @@ std::string InstanceScript::getSaveData()
#if VERSION_STRING >= WotLK
void InstanceScript::updateEncounterState(EncounterCreditType type, uint32_t creditEntry)
{
DungeonEncounterList const* encounters = sObjectMgr.GetDungeonEncounterList(mInstance->getBaseMap()->getMapId(), mInstance->getDifficulty());
DungeonEncounterList const* encounters = sObjectMgr.getDungeonEncounterList(mInstance->getBaseMap()->getMapId(), mInstance->getDifficulty());
if (!encounters)
return;

2
src/world/Server/World.cpp
View File

@@ -949,7 +949,7 @@ void World::loadMySQLTablesByTask()
sObjectMgr.LoadVehicleAccessories();
sObjectMgr.loadVehicleSeatAddon();
#endif
sObjectMgr.LoadWorldStateTemplates();
sObjectMgr.loadWorldStateTemplates();
#if VERSION_STRING > TBC
sObjectMgr.loadAchievementRewards();