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

Replace rawptr with shared_ptr for Class ArenaTeam

Browse Source 
* refactor ArenaTeam objmgr function
* declare private members
* general code cleanup
This commit is contained in:
Zyres
2023-07-20 23:06:05 +02:00
parent f6e9bbaa1b
commit 8ef6fbc122
17 changed files with 260 additions and 266 deletions
Download Patch File Download Diff File Expand all files Collapse all files

36
src/world/Chat/Commands/ArenaCommands.cpp
View File

@@ -33,18 +33,18 @@ uint8 ChatHandler::GetArenaTeamInternalType(uint32 type, WorldSession* m_session
bool ChatHandler::HandleArenaCreateTeam(const char* args, WorldSession* m_session)
{
uint32 team_type;
char team_name[1000];
uint32_t teamType;
char teamName[1000];
auto player = GetSelectedPlayer(m_session, true, true);
if (sscanf(args, "%u %[^\n]", &team_type, team_name) != 2)
if (sscanf(args, "%u %[^\n]", &teamType, teamName) != 2)
{
SystemMessage(m_session, "Invalid syntax. Usage: .arena createteam <type> <name>");
return true;
}
uint8 internal_type = GetArenaTeamInternalType(team_type, m_session);
if (internal_type == 10)
uint8_t internalType = GetArenaTeamInternalType(teamType, m_session);
if (internalType == 10)
return true;
if (player == nullptr)
@@ -53,25 +53,25 @@ bool ChatHandler::HandleArenaCreateTeam(const char* args, WorldSession* m_sessio
return true;
}
if (player->isInArenaTeam(internal_type))
if (player->isInArenaTeam(internalType))
{
RedSystemMessage(m_session, "Player: %s is already in an arena team of that type!", player->getName().c_str());
return true;
}
auto arena_team = new ArenaTeam(uint32(internal_type), sObjectMgr.GenerateArenaTeamId());
arena_team->m_emblem.emblemStyle = 22;
arena_team->m_emblem.emblemColour = 4292133532UL;
arena_team->m_emblem.borderColour = 4294931722UL;
arena_team->m_emblem.borderStyle = 1;
arena_team->m_emblem.backgroundColour = 4284906803UL;
arena_team->m_leader = player->getGuidLow();
arena_team->m_name = std::string(team_name);
arena_team->addMember(player->getPlayerInfo());
auto arenaTeam = std::make_shared<ArenaTeam>(internalType, sObjectMgr.GenerateArenaTeamId());
arenaTeam->m_emblem.emblemStyle = 22;
arenaTeam->m_emblem.emblemColour = 4292133532UL;
arenaTeam->m_emblem.borderColour = 4294931722UL;
arenaTeam->m_emblem.borderStyle = 1;
arenaTeam->m_emblem.backgroundColour = 4284906803UL;
arenaTeam->m_leader = player->getGuidLow();
arenaTeam->m_name = std::string(teamName);
arenaTeam->addMember(player->getPlayerInfo());
sObjectMgr.AddArenaTeam(arena_team);
sObjectMgr.addArenaTeam(arenaTeam);
GreenSystemMessage(m_session, "Arena team created for Player: %s Type: %u", player->getName().c_str(), team_type);
GreenSystemMessage(m_session, "Arena team created for Player: %s Type: %u", player->getName().c_str(), teamType);
return true;
}
@@ -113,7 +113,7 @@ bool ChatHandler::HandleArenaSetTeamLeader(const char* args, WorldSession* m_ses
bool ChatHandler::HandleArenaTeamResetAllRatings(const char* /*args*/, WorldSession* /*m_session*/)
{
sObjectMgr.ResetArenaTeamRatings();
sObjectMgr.resetArenaTeamRatings();
return true;
}

4
src/world/Management/ArenaTeam.cpp
View File

@@ -169,7 +169,7 @@ void ArenaTeam::destroy()
for (auto& itr : toDestroyMembers)
removeMember(itr);
sObjectMgr.RemoveArenaTeam(this);
sObjectMgr.removeArenaTeam(shared_from_this());
delete this;
}
@@ -224,7 +224,7 @@ bool ArenaTeam::addMember(CachedCharacterInfo* cachedCharInfo)
loggedInPlayer->setArenaTeamId(m_type, m_id);
loggedInPlayer->setArenaTeamMemberRank(m_type, 1);
loggedInPlayer->setArenaTeam(m_type, this);
loggedInPlayer->setArenaTeam(m_type, shared_from_this());
loggedInPlayer->getSession()->SystemMessage("You are now a member of the arena team, '%s'.", m_name.c_str());

3
src/world/Management/ArenaTeam.hpp
View File

@@ -7,6 +7,7 @@ This file is released under the MIT license. See README-MIT for more information
#include <string>
#include <vector>
#include <memory>
#include "CommonTypes.hpp"
@@ -59,7 +60,7 @@ struct ArenaTeamStats
uint32_t ranking;
};
class SERVER_DECL ArenaTeam
class SERVER_DECL ArenaTeam : public std::enable_shared_from_this<ArenaTeam>
{
public:
ArenaTeam(uint8_t type, uint32_t Id);

2
src/world/Management/Arenas.cpp
View File

@@ -163,7 +163,7 @@ bool Arena::HandleFinishBattlegroundRewardCalculation(PlayerTeam winningTeam)
}
}
sObjectMgr.UpdateArenaTeamRankings();
sObjectMgr.updateArenaTeamRankings();
m_nextPvPUpdateTime = 0;
updatePvPData();

4
src/world/Management/Arenas.h
View File

@@ -31,7 +31,7 @@ class SERVER_DECL Arena : public Battleground
std::set<GameObject*> m_gates;
GameObject* m_buffs[2];
ArenaTeam* m_teams[2];
std::shared_ptr<ArenaTeam> m_teams[2];
uint8_t m_arenateamtype;
uint32 m_playersCount[2];
std::set<uint32> m_players2[2];
@@ -90,7 +90,7 @@ class SERVER_DECL Arena : public Battleground
uint32 GetTeamFaction(uint32 team);
uint8 Rated() override { return rated_match; }
uint8_t GetArenaTeamType() const { return m_arenateamtype; }
ArenaTeam** GetTeams() { return m_teams; }
std::shared_ptr<ArenaTeam>* GetTeams() { return m_teams; }
uint32 CalcDeltaRating(uint32 oldRating, uint32 opponentRating, bool outcome);
};

2
src/world/Management/Battleground/Battleground.cpp
View File

@@ -143,7 +143,7 @@ void Battleground::buildPvPUpdateDataPacket(WorldPacket* data)
else
{
/* Grab some arena teams */
ArenaTeam** teams = dynamic_cast< Arena* >(this)->GetTeams();
std::shared_ptr<ArenaTeam>* teams = dynamic_cast< Arena* >(this)->GetTeams();
if (teams[0])
{

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

@@ -184,11 +184,9 @@ void ObjectMgr::finalize()
for (DungeonEncounterList::iterator encounterItr = itr->second.begin(); encounterItr != itr->second.end(); ++encounterItr)
delete *encounterItr;
sLogger.info("ObjectMgr : Deleting Arena Teams...");
for (std::unordered_map<uint32, ArenaTeam*>::iterator itr = m_arenaTeams.begin(); itr != m_arenaTeams.end(); ++itr)
{
delete(*itr).second;
}
sLogger.info("ObjectMgr : Clearing Arena Teams...");
m_arenaTeams.clear();
#ifdef FT_VEHICLES
sLogger.info("ObjectMgr : Cleaning up vehicle accessories...");
_vehicleAccessoryStore.clear();
@@ -210,7 +208,173 @@ void ObjectMgr::finalize()
mEventScriptMaps.clear();
mSpellEffectMaps.clear();
}
//////////////////////////////////////////////////////////////////////////////////////////
// Arena Team
void ObjectMgr::loadArenaTeams()
{
QueryResult* result = CharacterDatabase.Query("SELECT * FROM arenateams");
if (result != nullptr)
{
if (result->GetFieldCount() != 22)
{
sLogger.failure("arenateams table format is invalid. Please update your database.");
return;
}
do
{
const std::shared_ptr<ArenaTeam> team = std::make_shared<ArenaTeam>(result->Fetch());
addArenaTeam(team);
if (team->m_id > static_cast<uint32_t>(m_hiArenaTeamId.load()))
m_hiArenaTeamId = static_cast<uint32_t>(team->m_id);
} while (result->NextRow());
delete result;
}
updateArenaTeamRankings();
}
void ObjectMgr::addArenaTeam(std::shared_ptr<ArenaTeam> _arenaTeam)
{
std::lock_guard guard(m_arenaTeamLock);
m_arenaTeams[_arenaTeam->m_id] = _arenaTeam;
m_arenaTeamMap[_arenaTeam->m_type].insert(std::make_pair(_arenaTeam->m_id, _arenaTeam));
}
void ObjectMgr::removeArenaTeam(std::shared_ptr<ArenaTeam> _arenaTeam)
{
std::lock_guard guard(m_arenaTeamLock);
m_arenaTeams.erase(_arenaTeam->m_id);
m_arenaTeamMap[_arenaTeam->m_type].erase(_arenaTeam->m_id);
}
std::shared_ptr<ArenaTeam> ObjectMgr::getArenaTeamByName(std::string& _name, uint32_t /*type*/)
{
std::lock_guard guard(m_arenaTeamLock);
for (auto& arenaTeam : m_arenaTeams)
if (arenaTeam.second->m_name == _name)
return arenaTeam.second;
return nullptr;
}
std::shared_ptr<ArenaTeam> ObjectMgr::getArenaTeamById(uint32_t _id)
{
std::lock_guard guard(m_arenaTeamLock);
const auto arenaTeam = m_arenaTeams.find(_id);
return arenaTeam == m_arenaTeams.end() ? nullptr : arenaTeam->second;
}
std::shared_ptr<ArenaTeam> ObjectMgr::getArenaTeamByGuid(uint32_t _guid, uint32_t _type)
{
std::lock_guard guard(m_arenaTeamLock);
for (auto& arenaTeam : m_arenaTeamMap[_type])
{
if (arenaTeam.second->isMember(_guid))
return arenaTeam.second;
}
return nullptr;
}
class ArenaSorter
{
public:
bool operator()(std::shared_ptr<ArenaTeam> const& _arenaTeamA, std::shared_ptr<ArenaTeam> const& _arenaTeamB) const
{
return (_arenaTeamA->m_stats.rating > _arenaTeamB->m_stats.rating);
}
bool operator()(std::shared_ptr<ArenaTeam>& _arenaTeamA, std::shared_ptr<ArenaTeam>& _arenaTeamB) const
{
return (_arenaTeamA->m_stats.rating > _arenaTeamB->m_stats.rating);
}
};
void ObjectMgr::updateArenaTeamRankings()
{
std::lock_guard guard(m_arenaTeamLock);
for (auto& arenaTeams : m_arenaTeamMap)
{
std::vector<std::shared_ptr<ArenaTeam>> ranking;
ranking.reserve(arenaTeams.size());
for (auto& arenaTeamPair : arenaTeams)
ranking.push_back(arenaTeamPair.second);
std::ranges::sort(ranking, ArenaSorter());
uint32_t rank = 1;
for (const auto& arenaTeam : ranking)
{
if (arenaTeam->m_stats.ranking != rank)
{
arenaTeam->m_stats.ranking = rank;
arenaTeam->saveToDB();
}
++rank;
}
}
}
void ObjectMgr::updateArenaTeamWeekly()
{
std::lock_guard guard(m_arenaTeamLock);
for (auto& arenaTeams : m_arenaTeamMap)
{
for (const auto& arenaTeamPair : arenaTeams)
{
if (const std::shared_ptr<ArenaTeam> arenaTeam = arenaTeamPair.second)
{
arenaTeam->m_stats.played_week = 0;
arenaTeam->m_stats.won_week = 0;
for (uint32_t j = 0; j < arenaTeam->m_memberCount; ++j)
{
arenaTeam->m_members[j].Played_ThisWeek = 0;
arenaTeam->m_members[j].Won_ThisWeek = 0;
}
arenaTeam->saveToDB();
}
}
}
}
void ObjectMgr::resetArenaTeamRatings()
{
std::lock_guard guard(m_arenaTeamLock);
for (auto& arenaTeams : m_arenaTeamMap)
{
for (auto& arenaTeamPair : arenaTeams)
{
if (const std::shared_ptr<ArenaTeam> arenaTeam = arenaTeamPair.second)
{
arenaTeam->m_stats.played_season = 0;
arenaTeam->m_stats.played_week = 0;
arenaTeam->m_stats.won_season = 0;
arenaTeam->m_stats.won_week = 0;
arenaTeam->m_stats.rating = 1500;
for (uint32_t j = 0; j < arenaTeam->m_memberCount; ++j)
{
arenaTeam->m_members[j].Played_ThisSeason = 0;
arenaTeam->m_members[j].Played_ThisWeek = 0;
arenaTeam->m_members[j].Won_ThisSeason = 0;
arenaTeam->m_members[j].Won_ThisWeek = 0;
arenaTeam->m_members[j].PersonalRating = 1500;
}
arenaTeam->saveToDB();
}
}
}
updateArenaTeamRankings();
}
//////////////////////////////////////////////////////////////////////////////////////////
// Misc
void ObjectMgr::loadCreatureDisplayInfo()
{
for (uint32_t i = 0; i < sCreatureDisplayInfoStore.GetNumRows(); ++i)
@@ -2154,184 +2318,6 @@ void ObjectMgr::loadGroupInstances()
sLogger.info("Loaded %u group-instance saves", count);
}
void ObjectMgr::LoadArenaTeams()
{
QueryResult* result = CharacterDatabase.Query("SELECT * FROM arenateams");
if (result != nullptr)
{
if (result->GetFieldCount() != 22)
{
sLogger.failure("arenateams table format is invalid. Please update your database.");
return;
}
do
{
ArenaTeam* team = new ArenaTeam(result->Fetch());
AddArenaTeam(team);
if (team->m_id > uint32(m_hiArenaTeamId.load()))
m_hiArenaTeamId = uint32(team->m_id);
}
while (result->NextRow());
delete result;
}
/* update the ranking */
UpdateArenaTeamRankings();
}
ArenaTeam* ObjectMgr::GetArenaTeamByGuid(uint32 guid, uint32 Type)
{
m_arenaTeamLock.Acquire();
for (std::unordered_map<uint32, ArenaTeam*>::iterator itr = m_arenaTeamMap[Type].begin(); itr != m_arenaTeamMap[Type].end(); ++itr)
{
if (itr->second->isMember(guid))
{
m_arenaTeamLock.Release();
return itr->second;
}
}
m_arenaTeamLock.Release();
return nullptr;
}
ArenaTeam* ObjectMgr::GetArenaTeamById(uint32 id)
{
std::unordered_map<uint32, ArenaTeam*>::iterator itr;
m_arenaTeamLock.Acquire();
itr = m_arenaTeams.find(id);
m_arenaTeamLock.Release();
return (itr == m_arenaTeams.end()) ? nullptr : itr->second;
}
ArenaTeam* ObjectMgr::GetArenaTeamByName(std::string & name, uint32 /*Type*/)
{
m_arenaTeamLock.Acquire();
for (std::unordered_map<uint32, ArenaTeam*>::iterator itr = m_arenaTeams.begin(); itr != m_arenaTeams.end(); ++itr)
{
if (!strnicmp(itr->second->m_name.c_str(), name.c_str(), name.size()))
{
m_arenaTeamLock.Release();
return itr->second;
}
}
m_arenaTeamLock.Release();
return nullptr;
}
void ObjectMgr::RemoveArenaTeam(ArenaTeam* team)
{
m_arenaTeamLock.Acquire();
m_arenaTeams.erase(team->m_id);
m_arenaTeamMap[team->m_type].erase(team->m_id);
m_arenaTeamLock.Release();
}
void ObjectMgr::AddArenaTeam(ArenaTeam* team)
{
m_arenaTeamLock.Acquire();
m_arenaTeams[team->m_id] = team;
m_arenaTeamMap[team->m_type].insert(std::make_pair(team->m_id, team));
m_arenaTeamLock.Release();
}
class ArenaSorter
{
public:
bool operator()(ArenaTeam* const & a, ArenaTeam* const & b)
{
return (a->m_stats.rating > b->m_stats.rating);
}
bool operator()(ArenaTeam*& a, ArenaTeam*& b)
{
return (a->m_stats.rating > b->m_stats.rating);
}
};
void ObjectMgr::UpdateArenaTeamRankings()
{
m_arenaTeamLock.Acquire();
for (uint8 i = 0; i < NUM_ARENA_TEAM_TYPES; ++i)
{
std::vector<ArenaTeam*> ranking;
for (std::unordered_map<uint32, ArenaTeam*>::iterator itr = m_arenaTeamMap[i].begin(); itr != m_arenaTeamMap[i].end(); ++itr)
ranking.push_back(itr->second);
std::sort(ranking.begin(), ranking.end(), ArenaSorter());
uint32 rank = 1;
for (std::vector<ArenaTeam*>::iterator itr = ranking.begin(); itr != ranking.end(); ++itr)
{
if ((*itr)->m_stats.ranking != rank)
{
(*itr)->m_stats.ranking = rank;
(*itr)->saveToDB();
}
++rank;
}
}
m_arenaTeamLock.Release();
}
void ObjectMgr::ResetArenaTeamRatings()
{
m_arenaTeamLock.Acquire();
for (uint8 i = 0; i < NUM_ARENA_TEAM_TYPES; ++i)
{
for (std::unordered_map<uint32, ArenaTeam*>::iterator itr = m_arenaTeamMap[i].begin(); itr != m_arenaTeamMap[i].end(); ++itr)
{
ArenaTeam* team = itr->second;
if (team)
{
team->m_stats.played_season = 0;
team->m_stats.played_week = 0;
team->m_stats.won_season = 0;
team->m_stats.won_week = 0;
team->m_stats.rating = 1500;
for (uint32 j = 0; j < team->m_memberCount; ++j)
{
team->m_members[j].Played_ThisSeason = 0;
team->m_members[j].Played_ThisWeek = 0;
team->m_members[j].Won_ThisSeason = 0;
team->m_members[j].Won_ThisWeek = 0;
team->m_members[j].PersonalRating = 1500;
}
team->saveToDB();
}
}
}
m_arenaTeamLock.Release();
UpdateArenaTeamRankings();
}
void ObjectMgr::UpdateArenaTeamWeekly()
{
// reset weekly matches count for all teams and all members
m_arenaTeamLock.Acquire();
for (uint8 i = 0; i < NUM_ARENA_TEAM_TYPES; ++i)
{
for (std::unordered_map<uint32, ArenaTeam*>::iterator itr = m_arenaTeamMap[i].begin(); itr != m_arenaTeamMap[i].end(); ++itr)
{
ArenaTeam* team = itr->second;
if (team)
{
team->m_stats.played_week = 0;
team->m_stats.won_week = 0;
for (uint32 j = 0; j < team->m_memberCount; ++j)
{
team->m_members[j].Played_ThisWeek = 0;
team->m_members[j].Won_ThisWeek = 0;
}
team->saveToDB();
}
}
}
m_arenaTeamLock.Release();
}
void ObjectMgr::ResetDailies()
{
std::lock_guard<std::mutex> guard(_playerslock);

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

@@ -214,6 +214,29 @@ public:
ObjectMgr& operator=(ObjectMgr&&) = delete;
ObjectMgr& operator=(ObjectMgr const&) = delete;
//////////////////////////////////////////////////////////////////////////////////////////
// Arena Team
void loadArenaTeams();
void addArenaTeam(std::shared_ptr<ArenaTeam> _arenaTeam);
void removeArenaTeam(std::shared_ptr<ArenaTeam> _arenaTeam);
std::shared_ptr<ArenaTeam> getArenaTeamByName(std::string& _name, uint32_t _type);
std::shared_ptr<ArenaTeam> getArenaTeamById(uint32_t _id);
std::shared_ptr<ArenaTeam> getArenaTeamByGuid(uint32_t _guid, uint32_t _type);
void updateArenaTeamRankings();
void updateArenaTeamWeekly();
void resetArenaTeamRatings();
private:
std::unordered_map<uint32_t, std::shared_ptr<ArenaTeam>> m_arenaTeams;
std::unordered_map<uint32_t, std::shared_ptr<ArenaTeam>> m_arenaTeamMap[3];
std::mutex m_arenaTeamLock;
//////////////////////////////////////////////////////////////////////////////////////////
// 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);
@@ -364,21 +387,6 @@ public:
Charter* GetCharterByItemGuid(uint64 guid);
Charter* GetCharterByGuid(uint64 playerguid, CharterTypes type);
ArenaTeam* GetArenaTeamByName(std::string & name, uint32 Type);
ArenaTeam* GetArenaTeamById(uint32 id);
ArenaTeam* GetArenaTeamByGuid(uint32 guid, uint32 Type);
void UpdateArenaTeamRankings();
void UpdateArenaTeamWeekly();
void ResetArenaTeamRatings();
void LoadArenaTeams();
std::unordered_map<uint32, ArenaTeam*> m_arenaTeamMap[3];
std::unordered_map<uint32, ArenaTeam*> m_arenaTeams;
void RemoveArenaTeam(ArenaTeam* team);
void AddArenaTeam(ArenaTeam* team);
Mutex m_arenaTeamLock;
bool HandleInstanceReputationModifiers(Player* pPlayer, Unit* pVictim);
void LoadInstanceReputationModifiers();
void LoadInstanceEncounters();

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

@@ -8057,15 +8057,15 @@ void Player::removeAllChannels()
//////////////////////////////////////////////////////////////////////////////////////////
// ArenaTeam
void Player::setArenaTeam(uint8_t type, ArenaTeam* arenaTeam) { m_arenaTeams[type] = arenaTeam; }
ArenaTeam* Player::getArenaTeam(uint8_t type) { return m_arenaTeams[type]; }
void Player::setArenaTeam(uint8_t type, std::shared_ptr<ArenaTeam> arenaTeam) { m_arenaTeams[type] = arenaTeam; }
std::shared_ptr<ArenaTeam> Player::getArenaTeam(uint8_t type) { return m_arenaTeams[type]; }
bool Player::isInArenaTeam(uint8_t type) const { return m_arenaTeams[type] != nullptr; }
void Player::initialiseArenaTeam()
{
for (uint8_t i = 0; i < NUM_ARENA_TEAM_TYPES; ++i)
{
m_arenaTeams[i] = sObjectMgr.GetArenaTeamByGuid(getGuidLow(), i);
m_arenaTeams[i] = sObjectMgr.getArenaTeamByGuid(getGuidLow(), i);
if (m_arenaTeams[i] != nullptr)
{
#if VERSION_STRING != Classic

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

@@ -1263,8 +1263,8 @@ private:
//////////////////////////////////////////////////////////////////////////////////////////
// Arena
public:
void setArenaTeam(uint8_t type, ArenaTeam* arenaTeam);
ArenaTeam* getArenaTeam(uint8_t type);
void setArenaTeam(uint8_t type, std::shared_ptr<ArenaTeam> arenaTeam);
std::shared_ptr<ArenaTeam> getArenaTeam(uint8_t type);
bool isInArenaTeam(uint8_t type) const;
void initialiseArenaTeam();
@@ -1278,7 +1278,7 @@ public:
uint32_t getInviteArenaTeamId() const;
private:
ArenaTeam* m_arenaTeams[NUM_ARENA_TEAM_TYPES] = {nullptr};
std::shared_ptr<ArenaTeam> m_arenaTeams[NUM_ARENA_TEAM_TYPES] = {nullptr};
uint32_t m_arenaPoints = 0;
uint32_t m_inviteArenaTeamId = 0;

20
src/world/Server/Packets/Handlers/ArenaTeamHandler.cpp
View File

@@ -28,7 +28,7 @@ void WorldSession::handleArenaTeamQueryOpcode(WorldPacket& recvPacket)
if (!srlPacket.deserialise(recvPacket))
return;
if (auto arenaTeam = sObjectMgr.GetArenaTeamById(srlPacket.teamId))
if (auto arenaTeam = sObjectMgr.getArenaTeamById(srlPacket.teamId))
{
SendPacket(SmsgArenaTeamQueryResponse(arenaTeam->m_id, arenaTeam->m_name,
arenaTeam->getPlayersPerTeam(), arenaTeam->m_emblem).serialise().get());
@@ -43,7 +43,7 @@ void WorldSession::handleArenaTeamAddMemberOpcode(WorldPacket& recvPacket)
if (!srlPacket.deserialise(recvPacket))
return;
auto arenaTeam = sObjectMgr.GetArenaTeamById(srlPacket.teamId);
auto arenaTeam = sObjectMgr.getArenaTeamById(srlPacket.teamId);
if (arenaTeam == nullptr)
return;
@@ -101,7 +101,7 @@ void WorldSession::handleArenaTeamRemoveMemberOpcode(WorldPacket& recvPacket)
if (!srlPacket.deserialise(recvPacket))
return;
auto arenaTeam = sObjectMgr.GetArenaTeamById(srlPacket.teamId);
auto arenaTeam = sObjectMgr.getArenaTeamById(srlPacket.teamId);
if (arenaTeam == nullptr)
{
GetPlayer()->softDisconnect();
@@ -154,7 +154,7 @@ void WorldSession::handleArenaTeamInviteAcceptOpcode(WorldPacket& /*recvPacket*/
return;
}
auto arenaTeam = sObjectMgr.GetArenaTeamById(_player->getInviteArenaTeamId());
auto arenaTeam = sObjectMgr.getArenaTeamById(_player->getInviteArenaTeamId());
if (arenaTeam == nullptr)
{
SystemMessage("That arena team no longer exists.");
@@ -194,7 +194,7 @@ void WorldSession::handleArenaTeamInviteDenyOpcode(WorldPacket& /*recvPacket*/)
return;
}
ArenaTeam* team = sObjectMgr.GetArenaTeamById(_player->getInviteArenaTeamId());
std::shared_ptr<ArenaTeam> team = sObjectMgr.getArenaTeamById(_player->getInviteArenaTeamId());
if (team == nullptr)
return;
@@ -208,7 +208,7 @@ void WorldSession::handleArenaTeamLeaveOpcode(WorldPacket& recvPacket)
if (!srlPacket.deserialise(recvPacket))
return;
auto arenaTeam = sObjectMgr.GetArenaTeamById(srlPacket.teamId);
auto arenaTeam = sObjectMgr.getArenaTeamById(srlPacket.teamId);
if (arenaTeam == nullptr)
{
GetPlayer()->softDisconnect();
@@ -250,7 +250,7 @@ void WorldSession::handleArenaTeamDisbandOpcode(WorldPacket& recvPacket)
if (!srlPacket.deserialise(recvPacket))
return;
auto arenaTeam = sObjectMgr.GetArenaTeamById(srlPacket.teamId);
auto arenaTeam = sObjectMgr.getArenaTeamById(srlPacket.teamId);
if (arenaTeam == nullptr)
{
GetPlayer()->softDisconnect();
@@ -278,7 +278,7 @@ void WorldSession::handleArenaTeamPromoteOpcode(WorldPacket& recvPacket)
if (!srlPacket.deserialise(recvPacket))
return;
auto arenaTeam = sObjectMgr.GetArenaTeamById(srlPacket.teamId);
auto arenaTeam = sObjectMgr.getArenaTeamById(srlPacket.teamId);
if (arenaTeam == nullptr)
{
GetPlayer()->softDisconnect();
@@ -324,7 +324,7 @@ void WorldSession::handleArenaTeamRosterOpcode(WorldPacket& recvPacket)
if (!srlPacket.deserialise(recvPacket))
return;
if (auto arenaTeam = sObjectMgr.GetArenaTeamById(srlPacket.teamId))
if (auto arenaTeam = sObjectMgr.getArenaTeamById(srlPacket.teamId))
{
const auto memberList = arenaTeam->getRoosterMembers();
SendPacket(SmsgArenaTeamRooster(arenaTeam->m_id, static_cast<uint32_t>(memberList.size()), arenaTeam->getPlayersPerTeam(), memberList).serialise().get());
@@ -352,7 +352,7 @@ void WorldSession::handleInspectArenaStatsOpcode(WorldPacket& recvPacket)
const uint32_t teamId = player->getArenaTeamId(offset);
if (teamId > 0)
{
const auto arenaTeam = sObjectMgr.GetArenaTeamById(teamId);
const auto arenaTeam = sObjectMgr.getArenaTeamById(teamId);
if (arenaTeam != nullptr)
{
tempList.playerGuid = player->getGuid();

2
src/world/Server/Packets/Handlers/CharacterHandler.cpp
View File

@@ -320,7 +320,7 @@ uint8_t WorldSession::deleteCharacter(WoWGuid guid)
for (uint8_t i = 0; i < NUM_ARENA_TEAM_TYPES; ++i)
{
const auto arenaTeam = sObjectMgr.GetArenaTeamByGuid(guid.getGuidLow(), i);
const auto arenaTeam = sObjectMgr.getArenaTeamByGuid(guid.getGuidLow(), i);
if (arenaTeam != nullptr && arenaTeam->m_leader == guid.getGuidLow())
return E_CHAR_DELETE_FAILED_ARENA_CAPTAIN;

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

@@ -694,7 +694,7 @@ void WorldSession::handleCharterTurnInCharter(WorldPacket& recvPacket)
return;
}
const auto arenaTeam = new ArenaTeam(type, sObjectMgr.GenerateArenaTeamId());
auto arenaTeam = std::make_shared<ArenaTeam>(type, sObjectMgr.GenerateArenaTeamId());
arenaTeam->m_name = charter->GuildName;
arenaTeam->m_emblem.emblemColour = srlPacket.iconColor;
arenaTeam->m_emblem.emblemStyle = srlPacket.icon;
@@ -704,8 +704,8 @@ void WorldSession::handleCharterTurnInCharter(WorldPacket& recvPacket)
arenaTeam->m_leader = _player->getGuidLow();
arenaTeam->m_stats.rating = 1500;
sObjectMgr.AddArenaTeam(arenaTeam);
sObjectMgr.UpdateArenaTeamRankings();
sObjectMgr.addArenaTeam(arenaTeam);
sObjectMgr.updateArenaTeamRankings();
arenaTeam->addMember(_player->m_playerInfo);
for (uint32_t i = 0; i < charter->SignatureCount; ++i)
@@ -756,7 +756,7 @@ void WorldSession::handleCharterBuy(WorldPacket& recvPacket)
return;
}
ArenaTeam* arenaTeam = sObjectMgr.GetArenaTeamByName(srlPacket.name, arena_type);
std::shared_ptr<ArenaTeam> arenaTeam = sObjectMgr.getArenaTeamByName(srlPacket.name, arena_type);
if (arenaTeam != nullptr)
{
sChatHandler.SystemMessage(this, _player->getSession()->LocalizedWorldSrv(ServerString::SS_PETITION_NAME_ALREADY_USED));

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

@@ -1928,7 +1928,7 @@ void HookInterface::OnHonorableKill(Player* pPlayer, Player* pKilled)
((tOnHonorableKill)*itr)(pPlayer, pKilled);
}
void HookInterface::OnArenaFinish(Player* pPlayer, ArenaTeam* pTeam, bool victory, bool rated)
void HookInterface::OnArenaFinish(Player* pPlayer, std::shared_ptr<ArenaTeam> pTeam, bool victory, bool rated)
{
ServerHookList hookList = sScriptMgr._hooks[SERVER_HOOK_EVENT_ON_ARENA_FINISH];
for (ServerHookList::iterator itr = hookList.begin(); itr != hookList.end(); ++itr)

4
src/world/Server/Script/ScriptMgr.h
View File

@@ -111,7 +111,7 @@ typedef bool(*ItemScript)(Item* pItem, Player* pPlayer);
typedef void(*tOnQuestCancel)(Player* pPlayer, QuestProperties const* pQuest);
typedef void(*tOnQuestFinished)(Player* pPlayer, QuestProperties const* pQuest, Object* pQuestGiver);
typedef void(*tOnHonorableKill)(Player* pPlayer, Player* pKilled);
typedef void(*tOnArenaFinish)(Player* pPlayer, ArenaTeam* pTeam, bool victory, bool rated);
typedef void(*tOnArenaFinish)(Player* pPlayer, std::shared_ptr<ArenaTeam> pTeam, bool victory, bool rated);
typedef void(*tOnObjectLoot)(Player* pPlayer, Object* pTarget, uint32 Money, uint32 ItemId);
typedef void(*tOnAreaTrigger)(Player* pPlayer, uint32 areaTrigger);
typedef void(*tOnPostLevelUp)(Player* pPlayer);
@@ -874,7 +874,7 @@ class SERVER_DECL HookInterface
void OnQuestCancelled(Player* pPlayer, QuestProperties const* pQuest);
void OnQuestFinished(Player* pPlayer, QuestProperties const* pQuest, Object* pQuestGiver);
void OnHonorableKill(Player* pPlayer, Player* pKilled);
void OnArenaFinish(Player* pPlayer, ArenaTeam* pTeam, bool victory, bool rated);
void OnArenaFinish(Player* pPlayer, std::shared_ptr<ArenaTeam> pTeam, bool victory, bool rated);
void OnObjectLoot(Player* pPlayer, Object* pTarget, uint32 Money, uint32 ItemId);
void OnAreaTrigger(Player* pPlayer, uint32 areaTrigger);
void OnPostLevelUp(Player* pPlayer);

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

@@ -944,7 +944,7 @@ void World::loadMySQLTablesByTask()
sObjectMgr.LoadReputationModifiers();
sObjectMgr.LoadGroups();
sObjectMgr.loadGroupInstances();
sObjectMgr.LoadArenaTeams();
sObjectMgr.loadArenaTeams();
#ifdef FT_VEHICLES
sObjectMgr.LoadVehicleAccessories();
sObjectMgr.loadVehicleSeatAddon();

35
src/world/Storage/DayWatcherThread.cpp
View File

@@ -206,22 +206,21 @@ void DayWatcherThread::update_arena()
// are we in any arena teams?
for (uint8_t i = 0; i < 3; ++i)
{
ArenaTeam* team = sObjectMgr.GetArenaTeamByGuid(guid, i);
if (team != nullptr)
if (const auto arenaTeam = sObjectMgr.getArenaTeamByGuid(guid, i))
{
const auto arenaTeamMember = team->getMemberByGuid(guid);
if (arenaTeamMember == nullptr || team->m_stats.played_week < 10 || arenaTeamMember->Played_ThisWeek * 100 / team->m_stats.played_week < 30)
const auto arenaTeamMember = arenaTeam->getMemberByGuid(guid);
if (arenaTeamMember == nullptr || arenaTeam->m_stats.played_week < 10 || arenaTeamMember->Played_ThisWeek * 100 / arenaTeam->m_stats.played_week < 30)
continue;
const double arenaStatsRating = team->m_stats.rating;
double anrenaPoints;
const double arenaStatsRating = arenaTeam->m_stats.rating;
double arenaPoints;
if (arenaStatsRating <= 510.0)
continue;
if (arenaStatsRating > 510.0 && arenaStatsRating <= 1500.0) // 510 < X <= 1500"
{
anrenaPoints = 0.22 * arenaStatsRating + 14.0;
arenaPoints = 0.22 * arenaStatsRating + 14.0;
}
else
{
@@ -230,26 +229,26 @@ void DayWatcherThread::update_arena()
divisor *= 1639.28;
divisor += 1.0;
anrenaPoints = 1511.26 / divisor;
arenaPoints = 1511.26 / divisor;
}
if (team->m_type == ARENA_TEAM_TYPE_2V2)
if (arenaTeam->m_type == ARENA_TEAM_TYPE_2V2)
{
anrenaPoints *= 0.76;
anrenaPoints *= worldConfig.getFloatRate(RATE_ARENAPOINTMULTIPLIER2X);
arenaPoints *= 0.76;
arenaPoints *= worldConfig.getFloatRate(RATE_ARENAPOINTMULTIPLIER2X);
}
else if (team->m_type == ARENA_TEAM_TYPE_3V3)
else if (arenaTeam->m_type == ARENA_TEAM_TYPE_3V3)
{
anrenaPoints *= 0.88;
anrenaPoints *= worldConfig.getFloatRate(RATE_ARENAPOINTMULTIPLIER3X);
arenaPoints *= 0.88;
arenaPoints *= worldConfig.getFloatRate(RATE_ARENAPOINTMULTIPLIER3X);
}
else
{
anrenaPoints *= worldConfig.getFloatRate(RATE_ARENAPOINTMULTIPLIER5X);
arenaPoints *= worldConfig.getFloatRate(RATE_ARENAPOINTMULTIPLIER5X);
}
if (anrenaPoints > 1.0)
arenapointsPerTeam[i] += long2int32(double(ceil(anrenaPoints)));
if (arenaPoints > 1.0)
arenapointsPerTeam[i] += long2int32(double(ceil(arenaPoints)));
}
}
@@ -276,7 +275,7 @@ void DayWatcherThread::update_arena()
delete result;
}
sObjectMgr.UpdateArenaTeamWeekly();
sObjectMgr.updateArenaTeamWeekly();
m_lastArenaTime = UNIXTIME;
dupe_tm_pointer(localtime(&m_lastArenaTime), &m_localLastArenaTime);