mangos-mirror/server
0
0
Fork 0
mirror of https://github.com/mangosfour/server.git synced 2025-12-14 07:37:01 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

[10371] More wide use ObjectGuid in group code.

Browse source 
Also drop some unused functions.
And fix some uint32 -> uint6 guid assigns.
This commit is contained in:
VladimirMangos 2010-08-18 05:23:50 +04:00
parent acdaac3587
commit dbe9c6f190
19 changed files with 354 additions and 346 deletions
Download patch file Download diff file Expand all files Collapse all files

21
src/game/BattleGround.cpp
View file

@ -1169,7 +1169,7 @@ void BattleGround::AddPlayer(Player *plr)
// score struct must be created in inherited class
uint64 guid = plr->GetGUID();
ObjectGuid guid = plr->GetObjectGuid();
uint32 team = plr->GetBGTeam();
BattleGroundPlayer bp;
@ -1177,7 +1177,7 @@ void BattleGround::AddPlayer(Player *plr)
bp.Team = team;
// Add to list/maps
m_Players[guid] = bp;
m_Players[guid.GetRawValue()] = bp;
UpdatePlayersCountByTeam(team, false); // +1 player
@ -1235,16 +1235,9 @@ void BattleGround::AddPlayer(Player *plr)
}
/* this method adds player to his team's bg group, or sets his correct group if player is already in bg group */
void BattleGround::AddOrSetPlayerToCorrectBgGroup(Player *plr, uint64 plr_guid, uint32 team)
void BattleGround::AddOrSetPlayerToCorrectBgGroup(Player *plr, ObjectGuid plr_guid, uint32 team)
{
Group* group = GetBgRaid(team);
if(!group) // first player joined
{
group = new Group;
SetBgRaid(team, group);
group->Create(plr_guid, plr->GetName());
}
else // raid already exist
if (Group* group = GetBgRaid(team)) // raid already exist
{
if (group->IsMember(plr_guid))
{
@ -1259,6 +1252,12 @@ void BattleGround::AddOrSetPlayerToCorrectBgGroup(Player *plr, uint64 plr_guid,
group->ChangeLeader(plr_guid);
}
}
else // first player joined
{
group = new Group;
SetBgRaid(team, group);
group->Create(plr_guid, plr->GetName());
}
}
// This method should be called when player logs into running battleground

3
src/game/BattleGround.h
View file

@ -23,6 +23,7 @@
#include "SharedDefines.h"
#include "Map.h"
#include "ByteBuffer.h"
#include "ObjectGuid.h"
// magic event-numbers
#define BG_EVENT_NONE 255
@ -481,7 +482,7 @@ class BattleGround
virtual void AddPlayer(Player *plr); // must be implemented in BG subclass
void AddOrSetPlayerToCorrectBgGroup(Player *plr, uint64 plr_guid, uint32 team);
void AddOrSetPlayerToCorrectBgGroup(Player *plr, ObjectGuid plr_guid, uint32 team);
virtual void RemovePlayerAtLeave(uint64 guid, bool Transport, bool SendPacket);
// can be extended in in BG subclass

4
src/game/BattleGroundHandler.cpp
View file

@ -147,7 +147,7 @@ void WorldSession::HandleBattlemasterJoinOpcode( WorldPacket & recv_data )
// no group found, error
if (!grp)
return;
if(grp->GetLeaderGUID() != _player->GetGUID())
if (grp->GetLeaderGuid() != _player->GetObjectGuid())
return;
err = grp->CanJoinBattleGroundQueue(bg, bgQueueTypeId, 0, bg->GetMaxPlayersPerTeam(), false, 0);
isPremade = (grp->GetMembersCount() >= bg->GetMinPlayersPerTeam());
@ -670,7 +670,7 @@ void WorldSession::HandleBattlemasterJoinArena( WorldPacket & recv_data )
// no group found, error
if (!grp)
return;
if(grp->GetLeaderGUID() != _player->GetGUID())
if (grp->GetLeaderGuid() != _player->GetObjectGuid())
return;
// may be Group::CanJoinBattleGroundQueue should be moved to player class...
err = grp->CanJoinBattleGroundQueue(bg, bgQueueTypeId, arenatype, arenatype, (bool)isRated, arenaslot);

13
src/game/ChatHandler.cpp
View file

@ -254,12 +254,12 @@ void WorldSession::HandleMessagechatOpcode( WorldPacket & recv_data )
return;
}
if((type == CHAT_MSG_PARTY_LEADER) && !group->IsLeader(_player->GetGUID()))
if ((type == CHAT_MSG_PARTY_LEADER) && !group->IsLeader(_player->GetObjectGuid()))
return;
WorldPacket data;
ChatHandler::FillMessageData(&data, this, type, lang, NULL, 0, msg.c_str(), NULL);
group->BroadcastPacket(&data, false, group->GetMemberGroup(GetPlayer()->GetGUID()));
group->BroadcastPacket(&data, false, group->GetMemberGroup(GetPlayer()->GetObjectGuid()));
} break;
case CHAT_MSG_GUILD:
@ -355,10 +355,10 @@ void WorldSession::HandleMessagechatOpcode( WorldPacket & recv_data )
// if player is in battleground, he cannot say to battleground members by /ra
Group *group = GetPlayer()->GetOriginalGroup();
if(!group)
if (!group)
{
group = GetPlayer()->GetGroup();
if(!group || group->isBGGroup() || !group->isRaidGroup() || !group->IsLeader(_player->GetGUID()))
if (!group || group->isBGGroup() || !group->isRaidGroup() || !group->IsLeader(_player->GetObjectGuid()))
return;
}
@ -379,7 +379,8 @@ void WorldSession::HandleMessagechatOpcode( WorldPacket & recv_data )
break;
Group *group = GetPlayer()->GetGroup();
if(!group || !group->isRaidGroup() || !(group->IsLeader(GetPlayer()->GetGUID()) || group->IsAssistant(GetPlayer()->GetGUID())))
if (!group || !group->isRaidGroup() ||
!(group->IsLeader(GetPlayer()->GetObjectGuid()) || group->IsAssistant(GetPlayer()->GetObjectGuid())))
return;
WorldPacket data;
@ -422,7 +423,7 @@ void WorldSession::HandleMessagechatOpcode( WorldPacket & recv_data )
// battleground raid is always in Player->GetGroup(), never in GetOriginalGroup()
Group *group = GetPlayer()->GetGroup();
if(!group || !group->isBGGroup() || !group->IsLeader(GetPlayer()->GetGUID()))
if (!group || !group->isBGGroup() || !group->IsLeader(GetPlayer()->GetObjectGuid()))
return;
WorldPacket data;

285
src/game/Group.cpp
View file

@ -74,13 +74,11 @@ RollVoteMask Roll::GetVoteMaskFor(Player* player) const
//============== Group ==============================
//===================================================
Group::Group() : m_Id(0), m_leaderGuid(0), m_mainTank(0), m_mainAssistant(0), m_groupType(GROUPTYPE_NORMAL),
Group::Group() : m_Id(0), m_groupType(GROUPTYPE_NORMAL),
m_dungeonDifficulty(REGULAR_DIFFICULTY), m_raidDifficulty(REGULAR_DIFFICULTY),
m_bgGroup(NULL), m_lootMethod(FREE_FOR_ALL), m_looterGuid(0), m_lootThreshold(ITEM_QUALITY_UNCOMMON),
m_bgGroup(NULL), m_lootMethod(FREE_FOR_ALL), m_lootThreshold(ITEM_QUALITY_UNCOMMON),
m_subGroupsCounts(NULL)
{
for (int i = 0; i < TARGET_ICON_COUNT; ++i)
m_targetIcons[i] = 0;
}
Group::~Group()
@ -116,7 +114,7 @@ Group::~Group()
delete[] m_subGroupsCounts;
}
bool Group::Create(const uint64 &guid, const char * name)
bool Group::Create(ObjectGuid guid, const char * name)
{
m_leaderGuid = guid;
m_leaderName = name;
@ -132,7 +130,7 @@ bool Group::Create(const uint64 &guid, const char * name)
m_dungeonDifficulty = DUNGEON_DIFFICULTY_NORMAL;
m_raidDifficulty = RAID_DIFFICULTY_10MAN_NORMAL;
if(!isBGGroup())
if (!isBGGroup())
{
m_Id = sObjectMgr.GenerateGroupId();
@ -151,14 +149,19 @@ bool Group::Create(const uint64 &guid, const char * name)
CharacterDatabase.PExecute("DELETE FROM group_member WHERE groupId ='%u'", m_Id);
CharacterDatabase.PExecute("INSERT INTO groups (groupId,leaderGuid,mainTank,mainAssistant,lootMethod,looterGuid,lootThreshold,icon1,icon2,icon3,icon4,icon5,icon6,icon7,icon8,groupType,difficulty,raiddifficulty) "
"VALUES ('%u','%u','%u','%u','%u','%u','%u','" UI64FMTD "','" UI64FMTD "','" UI64FMTD "','" UI64FMTD "','" UI64FMTD "','" UI64FMTD "','" UI64FMTD "','" UI64FMTD "','%u','%u','%u')",
m_Id, GUID_LOPART(m_leaderGuid), GUID_LOPART(m_mainTank), GUID_LOPART(m_mainAssistant), uint32(m_lootMethod),
GUID_LOPART(m_looterGuid), uint32(m_lootThreshold), m_targetIcons[0], m_targetIcons[1], m_targetIcons[2], m_targetIcons[3], m_targetIcons[4], m_targetIcons[5], m_targetIcons[6], m_targetIcons[7], uint8(m_groupType), uint32(m_dungeonDifficulty), uint32(m_raidDifficulty));
m_Id, m_leaderGuid.GetCounter(), m_mainTankGuid.GetCounter(), m_mainAssistantGuid.GetCounter(), uint32(m_lootMethod),
m_looterGuid.GetCounter(), uint32(m_lootThreshold),
m_targetIcons[0].GetRawValue(), m_targetIcons[1].GetRawValue(),
m_targetIcons[2].GetRawValue(), m_targetIcons[3].GetRawValue(),
m_targetIcons[4].GetRawValue(), m_targetIcons[5].GetRawValue(),
m_targetIcons[6].GetRawValue(), m_targetIcons[7].GetRawValue(),
uint8(m_groupType), uint32(m_dungeonDifficulty), uint32(m_raidDifficulty));
}
if(!AddMember(guid, name))
if (!AddMember(guid, name))
return false;
if(!isBGGroup())
if (!isBGGroup())
CharacterDatabase.CommitTransaction();
return true;
@ -170,10 +173,10 @@ bool Group::LoadGroupFromDB(Field* fields)
// result = CharacterDatabase.Query("SELECT mainTank, mainAssistant, lootMethod, looterGuid, lootThreshold, icon1, icon2, icon3, icon4, icon5, icon6, icon7, icon8, groupType, difficulty, raiddifficulty, leaderGuid, groupId FROM groups");
m_Id = fields[17].GetUInt32();
m_leaderGuid = MAKE_NEW_GUID(fields[16].GetUInt32(),0,HIGHGUID_PLAYER);
m_leaderGuid = ObjectGuid(HIGHGUID_PLAYER, fields[16].GetUInt32());
// group leader not exist
if(!sObjectMgr.GetPlayerNameByGUID(m_leaderGuid, m_leaderName))
if (!sObjectMgr.GetPlayerNameByGUID(m_leaderGuid, m_leaderName))
return false;
m_groupType = GroupType(fields[13].GetUInt8());
@ -191,14 +194,14 @@ bool Group::LoadGroupFromDB(Field* fields)
r_diff = RAID_DIFFICULTY_10MAN_NORMAL;
m_raidDifficulty = Difficulty(r_diff);
m_mainTank = fields[0].GetUInt64();
m_mainAssistant = fields[1].GetUInt64();
m_lootMethod = (LootMethod)fields[2].GetUInt8();
m_looterGuid = MAKE_NEW_GUID(fields[3].GetUInt32(), 0, HIGHGUID_PLAYER);
m_lootThreshold = (ItemQualities)fields[4].GetUInt16();
m_mainTankGuid = ObjectGuid(HIGHGUID_PLAYER, fields[0].GetUInt32());
m_mainAssistantGuid = ObjectGuid(HIGHGUID_PLAYER, fields[1].GetUInt32());
m_lootMethod = LootMethod(fields[2].GetUInt8());
m_looterGuid = ObjectGuid(HIGHGUID_PLAYER, fields[3].GetUInt32());
m_lootThreshold = ItemQualities(fields[4].GetUInt16());
for(int i = 0; i < TARGET_ICON_COUNT; ++i)
m_targetIcons[i] = fields[5+i].GetUInt64();
m_targetIcons[i] = ObjectGuid(fields[5+i].GetUInt64());
return true;
}
@ -206,10 +209,10 @@ bool Group::LoadGroupFromDB(Field* fields)
bool Group::LoadMemberFromDB(uint32 guidLow, uint8 subgroup, bool assistant)
{
MemberSlot member;
member.guid = MAKE_NEW_GUID(guidLow, 0, HIGHGUID_PLAYER);
member.guid = ObjectGuid(HIGHGUID_PLAYER, guidLow);
// skip nonexistent member
if(!sObjectMgr.GetPlayerNameByGUID(member.guid, member.name))
if (!sObjectMgr.GetPlayerNameByGUID(member.guid, member.name))
return false;
member.group = subgroup;
@ -261,7 +264,7 @@ bool Group::AddLeaderInvite(Player *player)
if(!AddInvite(player))
return false;
m_leaderGuid = player->GetGUID();
m_leaderGuid = player->GetObjectGuid();
m_leaderName = player->GetName();
return true;
}
@ -282,13 +285,12 @@ void Group::RemoveAllInvites()
m_invitees.clear();
}
Player* Group::GetInvited(const uint64& guid) const
Player* Group::GetInvited(ObjectGuid guid) const
{
for(InvitesList::const_iterator itr = m_invitees.begin(); itr != m_invitees.end(); ++itr)
{
if((*itr)->GetGUID() == guid)
if ((*itr)->GetObjectGuid() == guid)
return (*itr);
}
return NULL;
}
@ -302,17 +304,16 @@ Player* Group::GetInvited(const std::string& name) const
return NULL;
}
bool Group::AddMember(const uint64 &guid, const char* name)
bool Group::AddMember(ObjectGuid guid, const char* name)
{
if(!_addMember(guid, name))
if (!_addMember(guid, name))
return false;
SendUpdate();
Player *player = sObjectMgr.GetPlayer(guid);
if(player)
if (Player *player = sObjectMgr.GetPlayer(guid))
{
if(!IsLeader(player->GetGUID()) && !isBGGroup())
if (!IsLeader(player->GetObjectGuid()) && !isBGGroup())
{
// reset the new member's instances, unless he is currently in one of them
// including raid/heroic instances that they are not permanently bound to!
@ -344,29 +345,29 @@ bool Group::AddMember(const uint64 &guid, const char* name)
return true;
}
uint32 Group::RemoveMember(const uint64 &guid, const uint8 &method)
uint32 Group::RemoveMember(ObjectGuid guid, uint8 method)
{
// remove member and change leader (if need) only if strong more 2 members _before_ member remove
if(GetMembersCount() > uint32(isBGGroup() ? 1 : 2)) // in BG group case allow 1 members group
if (GetMembersCount() > uint32(isBGGroup() ? 1 : 2)) // in BG group case allow 1 members group
{
bool leaderChanged = _removeMember(guid);
if(Player *player = sObjectMgr.GetPlayer( guid ))
if (Player *player = sObjectMgr.GetPlayer( guid ))
{
// quest related GO state dependent from raid membership
if(isRaidGroup())
if (isRaidGroup())
player->UpdateForQuestWorldObjects();
WorldPacket data;
if(method == 1)
if (method == 1)
{
data.Initialize( SMSG_GROUP_UNINVITE, 0 );
player->GetSession()->SendPacket( &data );
}
//we already removed player from group and in player->GetGroup() is his original group!
if( Group* group = player->GetGroup() )
if (Group* group = player->GetGroup())
{
group->SendUpdate();
}
@ -381,7 +382,7 @@ uint32 Group::RemoveMember(const uint64 &guid, const uint8 &method)
_homebindIfInstance(player);
}
if(leaderChanged)
if (leaderChanged)
{
WorldPacket data(SMSG_GROUP_SET_LEADER, (m_memberSlots.front().name.size()+1));
data << m_memberSlots.front().name;
@ -397,11 +398,10 @@ uint32 Group::RemoveMember(const uint64 &guid, const uint8 &method)
return m_memberSlots.size();
}
void Group::ChangeLeader(const uint64 &guid)
void Group::ChangeLeader(ObjectGuid guid)
{
member_citerator slot = _getMemberCSlot(guid);
if(slot == m_memberSlots.end())
if (slot == m_memberSlots.end())
return;
_setLeader(guid);
@ -479,7 +479,7 @@ void Group::Disband(bool hideDestroy)
ResetInstances(INSTANCE_RESET_GROUP_DISBAND, true, NULL);
}
m_leaderGuid = 0;
m_leaderGuid.Clear();
m_leaderName = "";
}
@ -692,7 +692,7 @@ bool Group::CountRollVote(ObjectGuid const& playerGUID, Rolls::iterator& rollI,
{
Roll* roll = *rollI;
Roll::PlayerVote::iterator itr = roll->playerVote.find(playerGUID.GetRawValue());
Roll::PlayerVote::iterator itr = roll->playerVote.find(playerGUID);
// this condition means that player joins to the party after roll begins
if (itr == roll->playerVote.end())
return true; // result used for need iterator ++, so avoid for end of list
@ -766,7 +766,7 @@ void Group::StartLootRool(Creature* lootTarget, LootMethod method, Loot* loot, u
{
if (playerToRoll->IsWithinDist(lootTarget, sWorld.getConfig(CONFIG_FLOAT_GROUP_XP_DISTANCE), false))
{
r->playerVote[playerToRoll->GetGUID()] = ROLL_NOT_EMITED_YET;
r->playerVote[playerToRoll->GetObjectGuid()] = ROLL_NOT_EMITED_YET;
++r->totalPlayersRolling;
}
}
@ -824,7 +824,7 @@ void Group::CountTheRoll(Rolls::iterator& rollI)
ObjectGuid maxguid = (*roll->playerVote.begin()).first;
Player *player;
for( Roll::PlayerVote::const_iterator itr = roll->playerVote.begin(); itr != roll->playerVote.end(); ++itr)
for(Roll::PlayerVote::const_iterator itr = roll->playerVote.begin(); itr != roll->playerVote.end(); ++itr)
{
if (itr->second != ROLL_NEED)
continue;
@ -867,7 +867,7 @@ void Group::CountTheRoll(Rolls::iterator& rollI)
if(!roll->playerVote.empty())
{
uint8 maxresul = 0;
uint64 maxguid = (*roll->playerVote.begin()).first;
ObjectGuid maxguid = (*roll->playerVote.begin()).first;
Player *player;
RollVote rollvote = ROLL_PASS; //Fixed: Using uninitialized memory 'rollvote'
@ -934,24 +934,24 @@ void Group::CountTheRoll(Rolls::iterator& rollI)
delete roll;
}
void Group::SetTargetIcon(uint8 id, uint64 whoGuid, uint64 targetGuid)
void Group::SetTargetIcon(uint8 id, ObjectGuid whoGuid, ObjectGuid targetGuid)
{
if(id >= TARGET_ICON_COUNT)
if (id >= TARGET_ICON_COUNT)
return;
// clean other icons
if( targetGuid != 0 )
if (!targetGuid.IsEmpty())
for(int i = 0; i < TARGET_ICON_COUNT; ++i)
if( m_targetIcons[i] == targetGuid )
SetTargetIcon(i, 0, 0);
if (m_targetIcons[i] == targetGuid)
SetTargetIcon(i, ObjectGuid(), ObjectGuid());
m_targetIcons[id] = targetGuid;
WorldPacket data(MSG_RAID_TARGET_UPDATE, (1+8+1+8));
data << uint8(0); // set targets
data << uint64(whoGuid);
data << whoGuid;
data << uint8(id);
data << uint64(targetGuid);
data << targetGuid;
BroadcastPacket(&data, true);
}
@ -1006,11 +1006,11 @@ void Group::SendTargetIconList(WorldSession *session)
for(int i = 0; i < TARGET_ICON_COUNT; ++i)
{
if(m_targetIcons[i] == 0)
if (m_targetIcons[i].IsEmpty())
continue;
data << uint8(i);
data << uint64(m_targetIcons[i]);
data << m_targetIcons[i];
}
session->SendPacket(&data);
@ -1048,18 +1048,18 @@ void Group::SendUpdate()
onlineState = onlineState | ((isBGGroup()) ? MEMBER_STATUS_PVP : 0);
data << citr2->name;
data << uint64(citr2->guid);
data << citr2->guid;
data << uint8(onlineState); // online-state
data << uint8(citr2->group); // groupid
data << uint8(GetFlags(*citr2)); // group flags
data << uint8(0); // 3.3, role?
}
data << uint64(m_leaderGuid); // leader guid
data << m_leaderGuid; // leader guid
if(GetMembersCount()-1)
{
data << uint8(m_lootMethod); // loot method
data << uint64(m_looterGuid); // looter guid
data << m_looterGuid; // looter guid
data << uint8(m_lootThreshold); // loot threshold
data << uint8(m_dungeonDifficulty); // Dungeon Difficulty
data << uint8(m_raidDifficulty); // Raid Difficulty
@ -1086,12 +1086,12 @@ void Group::UpdatePlayerOutOfRange(Player* pPlayer)
player->GetSession()->SendPacket(&data);
}
void Group::BroadcastPacket(WorldPacket *packet, bool ignorePlayersInBGRaid, int group, uint64 ignore)
void Group::BroadcastPacket(WorldPacket *packet, bool ignorePlayersInBGRaid, int group, ObjectGuid ignore)
{
for(GroupReference *itr = GetFirstMember(); itr != NULL; itr = itr->next())
{
Player *pl = itr->getSource();
if(!pl || (ignore != 0 && pl->GetGUID() == ignore) || (ignorePlayersInBGRaid && pl->GetGroup() != this) )
if (!pl || (!ignore.IsEmpty() && pl->GetObjectGuid() == ignore) || (ignorePlayersInBGRaid && pl->GetGroup() != this) )
continue;
if (pl->GetSession() && (group == -1 || itr->getSubGroup() == group))
@ -1104,8 +1104,8 @@ void Group::BroadcastReadyCheck(WorldPacket *packet)
for(GroupReference *itr = GetFirstMember(); itr != NULL; itr = itr->next())
{
Player *pl = itr->getSource();
if(pl && pl->GetSession())
if(IsLeader(pl->GetGUID()) || IsAssistant(pl->GetGUID()))
if (pl && pl->GetSession())
if (IsLeader(pl->GetObjectGuid()) || IsAssistant(pl->GetObjectGuid()))
pl->GetSession()->SendPacket(packet);
}
}
@ -1118,14 +1118,14 @@ void Group::OfflineReadyCheck()
if (!pl || !pl->GetSession())
{
WorldPacket data(MSG_RAID_READY_CHECK_CONFIRM, 9);
data << uint64(citr->guid);
data << citr->guid;
data << uint8(0);
BroadcastReadyCheck(&data);
}
}
}
bool Group::_addMember(const uint64 &guid, const char* name, bool isAssistant)
bool Group::_addMember(ObjectGuid guid, const char* name, bool isAssistant)
{
// get first not-full group
uint8 groupid = 0;
@ -1148,12 +1148,12 @@ bool Group::_addMember(const uint64 &guid, const char* name, bool isAssistant)
return _addMember(guid, name, isAssistant, groupid);
}
bool Group::_addMember(const uint64 &guid, const char* name, bool isAssistant, uint8 group)
bool Group::_addMember(ObjectGuid guid, const char* name, bool isAssistant, uint8 group)
{
if(IsFull())
return false;
if(!guid)
if (guid.IsEmpty())
return false;
Player *player = sObjectMgr.GetPlayer(guid);
@ -1188,30 +1188,31 @@ bool Group::_addMember(const uint64 &guid, const char* name, bool isAssistant, u
if(!isRaidGroup()) // reset targetIcons for non-raid-groups
{
for(int i = 0; i < TARGET_ICON_COUNT; ++i)
m_targetIcons[i] = 0;
m_targetIcons[i].Clear();
}
if(!isBGGroup())
{
// insert into group table
CharacterDatabase.PExecute("INSERT INTO group_member(groupId,memberGuid,assistant,subgroup) VALUES('%u','%u','%u','%u')", m_Id, GUID_LOPART(member.guid), ((member.assistant==1)?1:0), member.group);
CharacterDatabase.PExecute("INSERT INTO group_member(groupId,memberGuid,assistant,subgroup) VALUES('%u','%u','%u','%u')",
m_Id, member.guid.GetCounter(), ((member.assistant==1)?1:0), member.group);
}
return true;
}
bool Group::_removeMember(const uint64 &guid)
bool Group::_removeMember(ObjectGuid guid)
{
Player *player = sObjectMgr.GetPlayer(guid);
if (player)
{
//if we are removing player from battleground raid
if( isBGGroup() )
if (isBGGroup())
player->RemoveFromBattleGroundRaid();
else
{
//we can remove player who is in battleground from his original group
if( player->GetOriginalGroup() == this )
if (player->GetOriginalGroup() == this)
player->SetOriginalGroup(NULL);
else
player->SetGroup(NULL);
@ -1228,12 +1229,12 @@ bool Group::_removeMember(const uint64 &guid)
m_memberSlots.erase(slot);
}
if(!isBGGroup())
CharacterDatabase.PExecute("DELETE FROM group_member WHERE memberGuid='%u'", GUID_LOPART(guid));
if (!isBGGroup())
CharacterDatabase.PExecute("DELETE FROM group_member WHERE memberGuid='%u'", guid.GetCounter());
if(m_leaderGuid == guid) // leader was removed
if (m_leaderGuid == guid) // leader was removed
{
if(GetMembersCount() > 0)
if (GetMembersCount() > 0)
_setLeader(m_memberSlots.front().guid);
return true;
}
@ -1241,14 +1242,18 @@ bool Group::_removeMember(const uint64 &guid)
return false;
}
void Group::_setLeader(const uint64 &guid)
void Group::_setLeader(ObjectGuid guid)
{
member_citerator slot = _getMemberCSlot(guid);
if(slot == m_memberSlots.end())
if (slot == m_memberSlots.end())
return;
if(!isBGGroup())
if (!isBGGroup())
{
uint32 slot_lowguid = slot->guid.GetCounter();
uint32 leader_lowguid = m_leaderGuid.GetCounter();
// TODO: set a time limit to have this function run rarely cause it can be slow
CharacterDatabase.BeginTransaction();
@ -1260,11 +1265,11 @@ void Group::_setLeader(const uint64 &guid)
CharacterDatabase.PExecute(
"DELETE FROM group_instance WHERE leaderguid='%u' AND (permanent = 1 OR "
"instance IN (SELECT instance FROM character_instance WHERE guid = '%u')"
")", GUID_LOPART(m_leaderGuid), GUID_LOPART(slot->guid)
);
")", leader_lowguid, slot_lowguid);
Player *player = sObjectMgr.GetPlayer(slot->guid);
if(player)
if (player)
{
for(uint8 i = 0; i < MAX_DIFFICULTY; ++i)
{
@ -1282,7 +1287,8 @@ void Group::_setLeader(const uint64 &guid)
}
// update the group's solo binds to the new leader
CharacterDatabase.PExecute("UPDATE group_instance SET leaderGuid='%u' WHERE leaderGuid = '%u'", GUID_LOPART(slot->guid), GUID_LOPART(m_leaderGuid));
CharacterDatabase.PExecute("UPDATE group_instance SET leaderGuid='%u' WHERE leaderGuid = '%u'",
slot_lowguid, leader_lowguid);
// copy the permanent binds from the new leader to the group
// overwriting the solo binds with permanent ones if necessary
@ -1290,7 +1296,7 @@ void Group::_setLeader(const uint64 &guid)
Player::ConvertInstancesToGroup(player, this, slot->guid);
// update the group leader
CharacterDatabase.PExecute("UPDATE groups SET leaderGuid='%u' WHERE groupId='%u'", GUID_LOPART(slot->guid), m_Id);
CharacterDatabase.PExecute("UPDATE groups SET leaderGuid='%u' WHERE groupId='%u'", slot_lowguid, m_Id);
CharacterDatabase.CommitTransaction();
}
@ -1298,7 +1304,7 @@ void Group::_setLeader(const uint64 &guid)
m_leaderName = slot->name;
}
void Group::_removeRolls(const uint64 &guid)
void Group::_removeRolls(ObjectGuid guid)
{
for (Rolls::iterator it = RollId.begin(); it != RollId.end(); )
{
@ -1326,76 +1332,77 @@ void Group::_removeRolls(const uint64 &guid)
}
}
bool Group::_setMembersGroup(const uint64 &guid, uint8 group)
bool Group::_setMembersGroup(ObjectGuid guid, uint8 group)
{
member_witerator slot = _getMemberWSlot(guid);
if(slot == m_memberSlots.end())
if (slot == m_memberSlots.end())
return false;
slot->group = group;
SubGroupCounterIncrease(group);
if(!isBGGroup())
CharacterDatabase.PExecute("UPDATE group_member SET subgroup='%u' WHERE memberGuid='%u'", group, GUID_LOPART(guid));
if (!isBGGroup())
CharacterDatabase.PExecute("UPDATE group_member SET subgroup='%u' WHERE memberGuid='%u'", group, guid.GetCounter());
return true;
}
bool Group::_setAssistantFlag(const uint64 &guid, const bool &state)
bool Group::_setAssistantFlag(ObjectGuid guid, const bool &state)
{
member_witerator slot = _getMemberWSlot(guid);
if(slot == m_memberSlots.end())
if (slot == m_memberSlots.end())
return false;
slot->assistant = state;
if(!isBGGroup())
CharacterDatabase.PExecute("UPDATE group_member SET assistant='%u' WHERE memberGuid='%u'", (state==true)?1:0, GUID_LOPART(guid));
if (!isBGGroup())
CharacterDatabase.PExecute("UPDATE group_member SET assistant='%u' WHERE memberGuid='%u'", (state==true)?1:0, guid.GetCounter());
return true;
}
bool Group::_setMainTank(const uint64 &guid)
bool Group::_setMainTank(ObjectGuid guid)
{
if (m_mainTank == guid)
if (m_mainTankGuid == guid)
return false;
if (guid)
if (!guid.IsEmpty())
{
member_citerator slot = _getMemberCSlot(guid);
if(slot == m_memberSlots.end())
if (slot == m_memberSlots.end())
return false;
if(m_mainAssistant == guid)
_setMainAssistant(0);
if (m_mainAssistantGuid == guid)
_setMainAssistant(ObjectGuid());
}
m_mainTank = guid;
m_mainTankGuid = guid;
if(!isBGGroup())
CharacterDatabase.PExecute("UPDATE groups SET mainTank='%u' WHERE groupId='%u'", GUID_LOPART(m_mainTank), m_Id);
if (!isBGGroup())
CharacterDatabase.PExecute("UPDATE groups SET mainTank='%u' WHERE groupId='%u'", m_mainTankGuid.GetCounter(), m_Id);
return true;
}
bool Group::_setMainAssistant(const uint64 &guid)
bool Group::_setMainAssistant(ObjectGuid guid)
{
if (m_mainAssistant == guid)
if (m_mainAssistantGuid == guid)
return false;
if (guid)
if (!guid.IsEmpty())
{
member_witerator slot = _getMemberWSlot(guid);
if(slot == m_memberSlots.end())
if (slot == m_memberSlots.end())
return false;
if(m_mainTank == guid)
_setMainTank(0);
if (m_mainTankGuid == guid)
_setMainTank(ObjectGuid());
}
m_mainAssistant = guid;
m_mainAssistantGuid = guid;
if(!isBGGroup())
CharacterDatabase.PExecute("UPDATE groups SET mainAssistant='%u' WHERE groupId='%u'", GUID_LOPART(m_mainAssistant), m_Id);
if (!isBGGroup())
CharacterDatabase.PExecute("UPDATE groups SET mainAssistant='%u' WHERE groupId='%u'",
m_mainAssistantGuid.GetCounter(), m_Id);
return true;
}
@ -1411,7 +1418,7 @@ bool Group::SameSubGroup(Player const* member1, Player const* member2) const
}
// allows setting subgroup for offline members
void Group::ChangeMembersGroup(const uint64 &guid, uint8 group)
void Group::ChangeMembersGroup(ObjectGuid guid, uint8 group)
{
if (!isRaidGroup())
return;
@ -1424,7 +1431,7 @@ void Group::ChangeMembersGroup(const uint64 &guid, uint8 group)
if (prevSubGroup == group)
return;
if(_setMembersGroup(guid, group))
if (_setMembersGroup(guid, group))
{
SubGroupCounterDecrease(prevSubGroup);
SendUpdate();
@ -1445,7 +1452,7 @@ void Group::ChangeMembersGroup(Player *player, uint8 group)
if (prevSubGroup == group)
return;
if (_setMembersGroup(player->GetGUID(), group))
if (_setMembersGroup(player->GetObjectGuid(), group))
{
if (player->GetGroup() == this)
player->GetGroupRef().setSubGroup(group);
@ -1493,24 +1500,24 @@ void Group::UpdateLooterGuid( Creature* creature, bool ifneed )
}
member_citerator guid_itr = _getMemberCSlot(GetLooterGuid());
if(guid_itr != m_memberSlots.end())
if (guid_itr != m_memberSlots.end())
{
if(ifneed)
if (ifneed)
{
// not update if only update if need and ok
Player* looter = ObjectAccessor::FindPlayer(guid_itr->guid);
if(looter && looter->IsWithinDist(creature, sWorld.getConfig(CONFIG_FLOAT_GROUP_XP_DISTANCE), false))
if (looter && looter->IsWithinDist(creature, sWorld.getConfig(CONFIG_FLOAT_GROUP_XP_DISTANCE), false))
return;
}
++guid_itr;
}
// search next after current
if(guid_itr != m_memberSlots.end())
if (guid_itr != m_memberSlots.end())
{
for(member_citerator itr = guid_itr; itr != m_memberSlots.end(); ++itr)
{
if(Player* pl = ObjectAccessor::FindPlayer(itr->guid))
if (Player* pl = ObjectAccessor::FindPlayer(itr->guid))
{
if (pl->IsWithinDist(creature, sWorld.getConfig(CONFIG_FLOAT_GROUP_XP_DISTANCE), false))
{
@ -1518,10 +1525,10 @@ void Group::UpdateLooterGuid( Creature* creature, bool ifneed )
//if(refresh) // update loot for new looter
// pl->GetSession()->DoLootRelease(pl->GetLootGUID());
SetLooterGuid(pl->GetGUID());
SetLooterGuid(pl->GetObjectGuid());
SendUpdate();
if(refresh) // update loot for new looter
pl->SendLoot(creature->GetGUID(), LOOT_CORPSE);
if (refresh) // update loot for new looter
pl->SendLoot(creature->GetObjectGuid(), LOOT_CORPSE);
return;
}
}
@ -1531,7 +1538,7 @@ void Group::UpdateLooterGuid( Creature* creature, bool ifneed )
// search from start
for(member_citerator itr = m_memberSlots.begin(); itr != guid_itr; ++itr)
{
if(Player* pl = ObjectAccessor::FindPlayer(itr->guid))
if (Player* pl = ObjectAccessor::FindPlayer(itr->guid))
{
if (pl->IsWithinDist(creature, sWorld.getConfig(CONFIG_FLOAT_GROUP_XP_DISTANCE), false))
{
@ -1539,16 +1546,16 @@ void Group::UpdateLooterGuid( Creature* creature, bool ifneed )
//if(refresh) // update loot for new looter
// pl->GetSession()->DoLootRelease(pl->GetLootGUID());
SetLooterGuid(pl->GetGUID());
SetLooterGuid(pl->GetObjectGuid());
SendUpdate();
if(refresh) // update loot for new looter
pl->SendLoot(creature->GetGUID(), LOOT_CORPSE);
if (refresh) // update loot for new looter
pl->SendLoot(creature->GetObjectGuid(), LOOT_CORPSE);
return;
}
}
}
SetLooterGuid(0);
SetLooterGuid(ObjectGuid());
SendUpdate();
}
@ -1753,18 +1760,20 @@ InstanceGroupBind* Group::GetBoundInstance(Map* aMap, Difficulty difficulty)
InstanceGroupBind* Group::BindToInstance(InstanceSave *save, bool permanent, bool load)
{
if(save && !isBGGroup())
if (save && !isBGGroup())
{
InstanceGroupBind& bind = m_boundInstances[save->GetDifficulty()][save->GetMapId()];
if(bind.save)
if (bind.save)
{
// when a boss is killed or when copying the players's binds to the group
if(permanent != bind.perm || save != bind.save)
if(!load)
CharacterDatabase.PExecute("UPDATE group_instance SET instance = '%u', permanent = '%u' WHERE leaderGuid = '%u' AND instance = '%u'", save->GetInstanceId(), permanent, GUID_LOPART(GetLeaderGUID()), bind.save->GetInstanceId());
if (permanent != bind.perm || save != bind.save)
if (!load)
CharacterDatabase.PExecute("UPDATE group_instance SET instance = '%u', permanent = '%u' WHERE leaderGuid = '%u' AND instance = '%u'",
save->GetInstanceId(), permanent, GetLeaderGuid().GetCounter(), bind.save->GetInstanceId());
}
else if(!load)
CharacterDatabase.PExecute("INSERT INTO group_instance (leaderGuid, instance, permanent) VALUES ('%u', '%u', '%u')", GUID_LOPART(GetLeaderGUID()), save->GetInstanceId(), permanent);
else if (!load)
CharacterDatabase.PExecute("INSERT INTO group_instance (leaderGuid, instance, permanent) VALUES ('%u', '%u', '%u')",
GetLeaderGuid().GetCounter(), save->GetInstanceId(), permanent);
if(bind.save != save)
{
@ -1775,8 +1784,9 @@ InstanceGroupBind* Group::BindToInstance(InstanceSave *save, bool permanent, boo
bind.save = save;
bind.perm = permanent;
if(!load)
DEBUG_LOG("Group::BindToInstance: %d is now bound to map %d, instance %d, difficulty %d", GUID_LOPART(GetLeaderGUID()), save->GetMapId(), save->GetInstanceId(), save->GetDifficulty());
if (!load)
DEBUG_LOG("Group::BindToInstance: Group (Id: %d) is now bound to map %d, instance %d, difficulty %d",
GetId(), save->GetMapId(), save->GetInstanceId(), save->GetDifficulty());
return &bind;
}
else
@ -1786,10 +1796,11 @@ InstanceGroupBind* Group::BindToInstance(InstanceSave *save, bool permanent, boo
void Group::UnbindInstance(uint32 mapid, uint8 difficulty, bool unload)
{
BoundInstancesMap::iterator itr = m_boundInstances[difficulty].find(mapid);
if(itr != m_boundInstances[difficulty].end())
if (itr != m_boundInstances[difficulty].end())
{
if(!unload)
CharacterDatabase.PExecute("DELETE FROM group_instance WHERE leaderGuid = '%u' AND instance = '%u'", GUID_LOPART(GetLeaderGUID()), itr->second.save->GetInstanceId());
if (!unload)
CharacterDatabase.PExecute("DELETE FROM group_instance WHERE leaderGuid = '%u' AND instance = '%u'",
GetLeaderGuid().GetCounter(), itr->second.save->GetInstanceId());
itr->second.save->RemoveGroup(this); // save can become invalid
m_boundInstances[difficulty].erase(itr);
}

136
src/game/Group.h
View file

@ -154,7 +154,7 @@ class Roll : public LootValidatorRef
int32 itemRandomPropId;
uint32 itemRandomSuffix;
uint8 itemCount;
typedef std::map<uint64, RollVote> PlayerVote;
typedef UNORDERED_MAP<ObjectGuid, RollVote> PlayerVote;
PlayerVote playerVote; //vote position correspond with player position (in group)
uint8 totalPlayersRolling;
uint8 totalNeed;
@ -183,7 +183,7 @@ class MANGOS_DLL_SPEC Group
public:
struct MemberSlot
{
uint64 guid;
ObjectGuid guid;
std::string name;
uint8 group;
bool assistant;
@ -203,19 +203,18 @@ class MANGOS_DLL_SPEC Group
~Group();
// group manipulation methods
bool Create(const uint64 &guid, const char * name);
bool Create(ObjectGuid guid, const char * name);
bool LoadGroupFromDB(Field *fields);
bool LoadMemberFromDB(uint32 guidLow, uint8 subgroup, bool assistant);
bool AddInvite(Player *player);
uint32 RemoveInvite(Player *player);
void RemoveAllInvites();
bool AddLeaderInvite(Player *player);
bool AddMember(const uint64 &guid, const char* name);
// method: 0=just remove, 1=kick
uint32 RemoveMember(const uint64 &guid, const uint8 &method);
void ChangeLeader(const uint64 &guid);
bool AddMember(ObjectGuid guid, const char* name);
uint32 RemoveMember(ObjectGuid guid, uint8 method); // method: 0=just remove, 1=kick
void ChangeLeader(ObjectGuid guid);
void SetLootMethod(LootMethod method) { m_lootMethod = method; }
void SetLooterGuid(const uint64 &guid) { m_looterGuid = guid; }
void SetLooterGuid(ObjectGuid guid) { m_looterGuid = guid; }
void UpdateLooterGuid( Creature* creature, bool ifneed = false );
void SetLootThreshold(ItemQualities threshold) { m_lootThreshold = threshold; }
void Disband(bool hideDestroy=false);
@ -226,55 +225,34 @@ class MANGOS_DLL_SPEC Group
bool isRaidGroup() const { return m_groupType & GROUPTYPE_RAID; }
bool isBGGroup() const { return m_bgGroup != NULL; }
bool IsCreated() const { return GetMembersCount() > 0; }
const uint64& GetLeaderGUID() const { return m_leaderGuid; }
ObjectGuid GetLeaderGuid() const { return m_leaderGuid; }
const char * GetLeaderName() const { return m_leaderName.c_str(); }
LootMethod GetLootMethod() const { return m_lootMethod; }
const uint64& GetLooterGuid() const { return m_looterGuid; }
ObjectGuid GetLooterGuid() const { return m_looterGuid; }
ItemQualities GetLootThreshold() const { return m_lootThreshold; }
// member manipulation methods
bool IsMember(const uint64& guid) const { return _getMemberCSlot(guid) != m_memberSlots.end(); }
bool IsLeader(const uint64& guid) const { return (GetLeaderGUID() == guid); }
uint64 GetMemberGUID(const std::string& name)
bool IsMember(ObjectGuid guid) const { return _getMemberCSlot(guid) != m_memberSlots.end(); }
bool IsLeader(ObjectGuid guid) const { return GetLeaderGuid() == guid; }
ObjectGuid GetMemberGUID(const std::string& name)
{
for(member_citerator itr = m_memberSlots.begin(); itr != m_memberSlots.end(); ++itr)
{
if(itr->name == name)
{
if (itr->name == name)
return itr->guid;
return ObjectGuid();
}
}
return 0;
}
bool IsAssistant(uint64 guid) const
bool IsAssistant(ObjectGuid guid) const
{
member_citerator mslot = _getMemberCSlot(guid);
if(mslot==m_memberSlots.end())
if (mslot==m_memberSlots.end())
return false;
return mslot->assistant;
}
Player* GetInvited(const uint64& guid) const;
Player* GetInvited(ObjectGuid guid) const;
Player* GetInvited(const std::string& name) const;
bool SameSubGroup(uint64 guid1,const uint64& guid2) const
{
member_citerator mslot2 = _getMemberCSlot(guid2);
if(mslot2==m_memberSlots.end())
return false;
return SameSubGroup(guid1,&*mslot2);
}
bool SameSubGroup(uint64 guid1, MemberSlot const* slot2) const
{
member_citerator mslot1 = _getMemberCSlot(guid1);
if(mslot1==m_memberSlots.end() || !slot2)
return false;
return (mslot1->group==slot2->group);
}
bool HasFreeSlotSubGroup(uint8 subgroup) const
{
return (m_subGroupsCounts && m_subGroupsCounts[subgroup] < MAX_GROUP_SIZE);
@ -286,10 +264,10 @@ class MANGOS_DLL_SPEC Group
GroupReference* GetFirstMember() { return m_memberMgr.getFirst(); }
uint32 GetMembersCount() const { return m_memberSlots.size(); }
void GetDataForXPAtKill(Unit const* victim, uint32& count,uint32& sum_level, Player* & member_with_max_level, Player* & not_gray_member_with_max_level, Player* additional = NULL);
uint8 GetMemberGroup(uint64 guid) const
uint8 GetMemberGroup(ObjectGuid guid) const
{
member_citerator mslot = _getMemberCSlot(guid);
if(mslot==m_memberSlots.end())
if (mslot == m_memberSlots.end())
return MAX_RAID_SUBGROUPS + 1;
return mslot->group;
@ -301,37 +279,37 @@ class MANGOS_DLL_SPEC Group
void SetBattlegroundGroup(BattleGround *bg) { m_bgGroup = bg; }
GroupJoinBattlegroundResult CanJoinBattleGroundQueue(BattleGround const* bgOrTemplate, BattleGroundQueueTypeId bgQueueTypeId, uint32 MinPlayerCount, uint32 MaxPlayerCount, bool isRated, uint32 arenaSlot);
void ChangeMembersGroup(const uint64 &guid, uint8 group);
void ChangeMembersGroup(ObjectGuid guid, uint8 group);
void ChangeMembersGroup(Player *player, uint8 group);
uint64 const& GetMainTank() const { return m_mainTank; }
uint64 const& GetMainAssistant() const { return m_mainAssistant; }
ObjectGuid GetMainTankGuid() const { return m_mainTankGuid; }
ObjectGuid GetMainAssistantGuid() const { return m_mainAssistantGuid; }
void SetAssistant(uint64 guid, bool state)
void SetAssistant(ObjectGuid guid, bool state)
{
if(!isRaidGroup())
if (!isRaidGroup())
return;
if(_setAssistantFlag(guid, state))
if (_setAssistantFlag(guid, state))
SendUpdate();
}
void SetMainTank(uint64 guid)
void SetMainTank(ObjectGuid guid)
{
if(!isRaidGroup())
if (!isRaidGroup())
return;
if(_setMainTank(guid))
if (_setMainTank(guid))
SendUpdate();
}
void SetMainAssistant(uint64 guid)
void SetMainAssistant(ObjectGuid guid)
{
if(!isRaidGroup())
if (!isRaidGroup())
return;
if(_setMainAssistant(guid))
if (_setMainAssistant(guid))
SendUpdate();
}
void SetTargetIcon(uint8 id, uint64 whoGuid, uint64 targetGuid);
void SetTargetIcon(uint8 id, ObjectGuid whoGuid, ObjectGuid targetGuid);
Difficulty GetDifficulty(bool isRaid) const { return isRaid ? m_raidDifficulty : m_dungeonDifficulty; }
Difficulty GetDungeonDifficulty() const { return m_dungeonDifficulty; }
@ -346,7 +324,7 @@ class MANGOS_DLL_SPEC Group
void SendUpdate();
void UpdatePlayerOutOfRange(Player* pPlayer);
// ignore: GUID of player that will be ignored
void BroadcastPacket(WorldPacket *packet, bool ignorePlayersInBGRaid, int group=-1, uint64 ignore=0);
void BroadcastPacket(WorldPacket *packet, bool ignorePlayersInBGRaid, int group=-1, ObjectGuid ignore = ObjectGuid());
void BroadcastReadyCheck(WorldPacket *packet);
void OfflineReadyCheck();
@ -377,17 +355,17 @@ class MANGOS_DLL_SPEC Group
BoundInstancesMap& GetBoundInstances(Difficulty difficulty) { return m_boundInstances[difficulty]; }
protected:
bool _addMember(const uint64 &guid, const char* name, bool isAssistant=false);
bool _addMember(const uint64 &guid, const char* name, bool isAssistant, uint8 group);
bool _removeMember(const uint64 &guid); // returns true if leader has changed
void _setLeader(const uint64 &guid);
bool _addMember(ObjectGuid guid, const char* name, bool isAssistant=false);
bool _addMember(ObjectGuid guid, const char* name, bool isAssistant, uint8 group);
bool _removeMember(ObjectGuid guid); // returns true if leader has changed
void _setLeader(ObjectGuid guid);
void _removeRolls(const uint64 &guid);
void _removeRolls(ObjectGuid guid);
bool _setMembersGroup(const uint64 &guid, uint8 group);
bool _setAssistantFlag(const uint64 &guid, const bool &state);
bool _setMainTank(const uint64 &guid);
bool _setMainAssistant(const uint64 &guid);
bool _setMembersGroup(ObjectGuid guid, uint8 group);
bool _setAssistantFlag(ObjectGuid guid, const bool &state);
bool _setMainTank(ObjectGuid guid);
bool _setMainAssistant(ObjectGuid guid);
void _homebindIfInstance(Player *player);
@ -403,23 +381,21 @@ class MANGOS_DLL_SPEC Group
++m_subGroupsCounts[itr->group];
}
member_citerator _getMemberCSlot(uint64 Guid) const
member_citerator _getMemberCSlot(ObjectGuid guid) const
{
for(member_citerator itr = m_memberSlots.begin(); itr != m_memberSlots.end(); ++itr)
{
if (itr->guid == Guid)
if (itr->guid == guid)
return itr;
}
return m_memberSlots.end();
}
member_witerator _getMemberWSlot(uint64 Guid)
member_witerator _getMemberWSlot(ObjectGuid guid)
{
for(member_witerator itr = m_memberSlots.begin(); itr != m_memberSlots.end(); ++itr)
{
if (itr->guid == Guid)
if (itr->guid == guid)
return itr;
}
return m_memberSlots.end();
}
@ -445,9 +421,9 @@ class MANGOS_DLL_SPEC Group
uint8 flags = 0;
if (slot.assistant)
flags |= GROUP_ASSISTANT;
if (slot.guid == m_mainAssistant)
if (slot.guid == m_mainAssistantGuid)
flags |= GROUP_MAIN_ASSISTANT;
if (slot.guid == m_mainTank)
if (slot.guid == m_mainTankGuid)
flags |= GROUP_MAIN_TANK;
return GroupFlagMask(flags);
}
@ -456,18 +432,18 @@ class MANGOS_DLL_SPEC Group
MemberSlotList m_memberSlots;
GroupRefManager m_memberMgr;
InvitesList m_invitees;
uint64 m_leaderGuid;
ObjectGuid m_leaderGuid;
std::string m_leaderName;
uint64 m_mainTank;
uint64 m_mainAssistant;
ObjectGuid m_mainTankGuid;
ObjectGuid m_mainAssistantGuid;
GroupType m_groupType;
Difficulty m_dungeonDifficulty;
Difficulty m_raidDifficulty;
BattleGround* m_bgGroup;
uint64 m_targetIcons[TARGET_ICON_COUNT];
ObjectGuid m_targetIcons[TARGET_ICON_COUNT];
LootMethod m_lootMethod;
ItemQualities m_lootThreshold;
uint64 m_looterGuid;
ObjectGuid m_looterGuid;
Rolls RollId;
BoundInstancesMap m_boundInstances[MAX_DIFFICULTY];
uint8* m_subGroupsCounts;

100
src/game/GroupHandler.cpp
View file

@ -110,7 +110,7 @@ void WorldSession::HandleGroupInviteOpcode( WorldPacket & recv_data )
if(group)
{
// not have permissions for invite
if(!group->IsLeader(GetPlayer()->GetGUID()) && !group->IsAssistant(GetPlayer()->GetGUID()))
if (!group->IsLeader(GetPlayer()->GetObjectGuid()) && !group->IsAssistant(GetPlayer()->GetObjectGuid()))
{
SendPartyResult(PARTY_OP_INVITE, "", ERR_NOT_LEADER);
return;
@ -172,9 +172,10 @@ void WorldSession::HandleGroupAcceptOpcode( WorldPacket & recv_data )
if (!group)
return;
if(group->GetLeaderGUID() == GetPlayer()->GetGUID())
if (group->GetLeaderGuid() == GetPlayer()->GetObjectGuid())
{
sLog.outError("HandleGroupAcceptOpcode: player %s(%d) tried to accept an invite to his own group", GetPlayer()->GetName(), GetPlayer()->GetGUIDLow());
sLog.outError("HandleGroupAcceptOpcode: %s tried to accept an invite to his own group",
GetPlayer()->GetObjectGuid().GetString().c_str());
return;
}
@ -191,21 +192,21 @@ void WorldSession::HandleGroupAcceptOpcode( WorldPacket & recv_data )
return;
}
Player* leader = sObjectMgr.GetPlayer(group->GetLeaderGUID());
Player* leader = sObjectMgr.GetPlayer(group->GetLeaderGuid());
// forming a new group, create it
if(!group->IsCreated())
if (!group->IsCreated())
{
if (leader)
group->RemoveInvite(leader);
if (group->Create(group->GetLeaderGUID(), group->GetLeaderName()))
if (group->Create(group->GetLeaderGuid(), group->GetLeaderName()))
sObjectMgr.AddGroup(group);
else
return;
}
// everything is fine, do it, PLAYER'S GROUP IS SET IN ADDMEMBER!!!
if(!group->AddMember(GetPlayer()->GetGUID(), GetPlayer()->GetName()))
if(!group->AddMember(GetPlayer()->GetObjectGuid(), GetPlayer()->GetName()))
return;
}
@ -216,12 +217,12 @@ void WorldSession::HandleGroupDeclineOpcode( WorldPacket & /*recv_data*/ )
return;
// remember leader if online
Player *leader = sObjectMgr.GetPlayer(group->GetLeaderGUID());
Player *leader = sObjectMgr.GetPlayer(group->GetLeaderGuid());
// uninvite, group can be deleted
GetPlayer()->UninviteFromGroup();
if(!leader || !leader->GetSession())
if (!leader || !leader->GetSession())
return;
// report
@ -232,19 +233,19 @@ void WorldSession::HandleGroupDeclineOpcode( WorldPacket & /*recv_data*/ )
void WorldSession::HandleGroupUninviteGuidOpcode(WorldPacket & recv_data)
{
uint64 guid;
ObjectGuid guid;
recv_data >> guid;
recv_data.read_skip<std::string>(); // reason
// can't uninvite yourself
if(guid == GetPlayer()->GetGUID())
if (guid == GetPlayer()->GetObjectGuid())
{
sLog.outError("WorldSession::HandleGroupUninviteGuidOpcode: leader %s(%d) tried to uninvite himself from the group.", GetPlayer()->GetName(), GetPlayer()->GetGUIDLow());
sLog.outError("WorldSession::HandleGroupUninviteGuidOpcode: leader %s tried to uninvite himself from the group.", GetPlayer()->GetName(), GetPlayer()->GetObjectGuid().GetString().c_str());
return;
}
PartyResult res = GetPlayer()->CanUninviteFromGroup();
if(res != ERR_PARTY_RESULT_OK)
if (res != ERR_PARTY_RESULT_OK)
{
SendPartyResult(PARTY_OP_LEAVE, "", res);
return;
@ -254,13 +255,13 @@ void WorldSession::HandleGroupUninviteGuidOpcode(WorldPacket & recv_data)
if(!grp)
return;
if(grp->IsMember(guid))
if (grp->IsMember(guid))
{
Player::RemoveFromGroup(grp, guid);
return;
}
if(Player* plr = grp->GetInvited(guid))
if (Player* plr = grp->GetInvited(guid))
{
plr->UninviteFromGroup();
return;
@ -275,34 +276,35 @@ void WorldSession::HandleGroupUninviteOpcode(WorldPacket & recv_data)
recv_data >> membername;
// player not found
if(!normalizePlayerName(membername))
if (!normalizePlayerName(membername))
return;
// can't uninvite yourself
if(GetPlayer()->GetName() == membername)
if (GetPlayer()->GetName() == membername)
{
sLog.outError("WorldSession::HandleGroupUninviteOpcode: leader %s(%d) tried to uninvite himself from the group.", GetPlayer()->GetName(), GetPlayer()->GetGUIDLow());
sLog.outError("WorldSession::HandleGroupUninviteOpcode: leader %s tried to uninvite himself from the group.", GetPlayer()->GetName(), GetPlayer()->GetObjectGuid().GetString().c_str());
return;
}
PartyResult res = GetPlayer()->CanUninviteFromGroup();
if(res != ERR_PARTY_RESULT_OK)
if (res != ERR_PARTY_RESULT_OK)
{
SendPartyResult(PARTY_OP_LEAVE, "", res);
return;
}
Group* grp = GetPlayer()->GetGroup();
if(!grp)
if (!grp)
return;
if(uint64 guid = grp->GetMemberGUID(membername))
ObjectGuid guid = grp->GetMemberGUID(membername);
if (!guid.IsEmpty())
{
Player::RemoveFromGroup(grp, guid);
return;
}
if(Player* plr = grp->GetInvited(membername))
if (Player* plr = grp->GetInvited(membername))
{
plr->UninviteFromGroup();
return;
@ -313,17 +315,17 @@ void WorldSession::HandleGroupUninviteOpcode(WorldPacket & recv_data)
void WorldSession::HandleGroupSetLeaderOpcode( WorldPacket & recv_data )
{
uint64 guid;
ObjectGuid guid;
recv_data >> guid;
Group *group = GetPlayer()->GetGroup();
if(!group)
if (!group)
return;
Player *player = sObjectMgr.GetPlayer(guid);
/** error handling **/
if (!player || !group->IsLeader(GetPlayer()->GetGUID()) || player->GetGroup() != group)
if (!player || !group->IsLeader(GetPlayer()->GetObjectGuid()) || player->GetGroup() != group)
return;
/********************/
@ -354,16 +356,16 @@ void WorldSession::HandleGroupDisbandOpcode( WorldPacket & /*recv_data*/ )
void WorldSession::HandleLootMethodOpcode( WorldPacket & recv_data )
{
uint32 lootMethod;
uint64 lootMaster;
ObjectGuid lootMaster;
uint32 lootThreshold;
recv_data >> lootMethod >> lootMaster >> lootThreshold;
Group *group = GetPlayer()->GetGroup();
if(!group)
if (!group)
return;
/** error handling **/
if(!group->IsLeader(GetPlayer()->GetGUID()))
if (!group->IsLeader(GetPlayer()->GetObjectGuid()))
return;
/********************/
@ -427,7 +429,7 @@ void WorldSession::HandleMinimapPingOpcode(WorldPacket& recv_data)
data << uint64(GetPlayer()->GetGUID());
data << float(x);
data << float(y);
GetPlayer()->GetGroup()->BroadcastPacket(&data, true, -1, GetPlayer()->GetGUID());
GetPlayer()->GetGroup()->BroadcastPacket(&data, true, -1, GetPlayer()->GetObjectGuid());
}
void WorldSession::HandleRandomRollOpcode(WorldPacket& recv_data)
@ -476,12 +478,14 @@ void WorldSession::HandleRaidTargetUpdateOpcode( WorldPacket & recv_data )
}
else // target icon update
{
if(group->isRaidGroup() && !group->IsLeader(GetPlayer()->GetGUID()) && !group->IsAssistant(GetPlayer()->GetGUID()))
if (group->isRaidGroup() &&
!group->IsLeader(GetPlayer()->GetObjectGuid()) &&
!group->IsAssistant(GetPlayer()->GetObjectGuid()))
return;
uint64 guid;
ObjectGuid guid;
recv_data >> guid;
group->SetTargetIcon(x, _player->GetGUID(), guid);
group->SetTargetIcon(x, _player->GetObjectGuid(), guid);
}
}
@ -495,7 +499,7 @@ void WorldSession::HandleGroupRaidConvertOpcode( WorldPacket & /*recv_data*/ )
return;
/** error handling **/
if(!group->IsLeader(GetPlayer()->GetGUID()) || group->GetMembersCount() < 2)
if (!group->IsLeader(GetPlayer()->GetObjectGuid()) || group->GetMembersCount() < 2)
return;
/********************/
@ -521,7 +525,8 @@ void WorldSession::HandleGroupChangeSubGroupOpcode( WorldPacket & recv_data )
return;
/** error handling **/
if(!group->IsLeader(GetPlayer()->GetGUID()) && !group->IsAssistant(GetPlayer()->GetGUID()))
if (!group->IsLeader(GetPlayer()->GetObjectGuid()) &&
!group->IsAssistant(GetPlayer()->GetObjectGuid()))
return;
if (!group->HasFreeSlotSubGroup(groupNr))
@ -531,23 +536,23 @@ void WorldSession::HandleGroupChangeSubGroupOpcode( WorldPacket & recv_data )
// everything is fine, do it
if (Player* player = sObjectMgr.GetPlayer(name.c_str()))
group->ChangeMembersGroup(player, groupNr);
else
group->ChangeMembersGroup(sObjectMgr.GetPlayerGUIDByName(name.c_str()), groupNr);
else if (uint64 guid = sObjectMgr.GetPlayerGUIDByName(name.c_str()))
group->ChangeMembersGroup(guid, groupNr);
}
void WorldSession::HandleGroupAssistantLeaderOpcode( WorldPacket & recv_data )
{
uint64 guid;
ObjectGuid guid;
uint8 flag;
recv_data >> guid;
recv_data >> flag;
Group *group = GetPlayer()->GetGroup();
if(!group)
if (!group)
return;
/** error handling **/
if(!group->IsLeader(GetPlayer()->GetGUID()))
if (!group->IsLeader(GetPlayer()->GetObjectGuid()))
return;
/********************/
@ -559,18 +564,18 @@ void WorldSession::HandlePartyAssignmentOpcode( WorldPacket & recv_data )
{
uint8 role;
uint8 apply;
uint64 guid;
ObjectGuid guid;
recv_data >> role >> apply; // role 0 = Main Tank, 1 = Main Assistant
recv_data >> guid;
DEBUG_LOG("MSG_PARTY_ASSIGNMENT");
Group *group = GetPlayer()->GetGroup();
if(!group)
if (!group)
return;
/** error handling **/
if(!group->IsLeader(GetPlayer()->GetGUID()))
if (!group->IsLeader(GetPlayer()->GetObjectGuid()))
return;
/********************/
@ -586,10 +591,10 @@ void WorldSession::HandlePartyAssignmentOpcode( WorldPacket & recv_data )
}
else
{
if (group->GetMainTank() == guid)
group->SetMainTank(0);
if (group->GetMainAssistant() == guid)
group->SetMainAssistant(0);
if (group->GetMainTankGuid() == guid)
group->SetMainTank(ObjectGuid());
if (group->GetMainAssistantGuid() == guid)
group->SetMainAssistant(ObjectGuid());
}
}
@ -602,7 +607,8 @@ void WorldSession::HandleRaidReadyCheckOpcode( WorldPacket & recv_data )
return;
/** error handling **/
if(!group->IsLeader(GetPlayer()->GetGUID()) && !group->IsAssistant(GetPlayer()->GetGUID()))
if (!group->IsLeader(GetPlayer()->GetObjectGuid()) &&
!group->IsAssistant(GetPlayer()->GetObjectGuid()))
return;
/********************/

24
src/game/LFGHandler.cpp
View file

@ -27,7 +27,7 @@
static void AttemptJoin(Player* _player)
{
// skip not can autojoin cases and player group case
if(!_player->m_lookingForGroup.canAutoJoin() || _player->GetGroup())
if (!_player->m_lookingForGroup.canAutoJoin() || _player->GetGroup())
return;
//TODO: Guard Player Map
@ -37,26 +37,26 @@ static void AttemptJoin(Player* _player)
Player *plr = iter->second;
// skip enemies and self
if(!plr || plr==_player || plr->GetTeam() != _player->GetTeam())
if (!plr || plr==_player || plr->GetTeam() != _player->GetTeam())
continue;
//skip players not in world
if(!plr->IsInWorld())
if (!plr->IsInWorld())
continue;
// skip not auto add, not group leader cases
if (!plr->GetSession()->LookingForGroup_auto_add || (plr->GetGroup() && plr->GetGroup()->GetLeaderGUID()!=plr->GetGUID()))
if (!plr->GetSession()->LookingForGroup_auto_add || (plr->GetGroup() && plr->GetGroup()->GetLeaderGuid() != plr->GetObjectGuid()))
continue;
// skip non auto-join or empty slots, or non compatible slots
if(!plr->m_lookingForGroup.more.canAutoJoin() || !_player->m_lookingForGroup.HaveInSlot(plr->m_lookingForGroup.more))
if (!plr->m_lookingForGroup.more.canAutoJoin() || !_player->m_lookingForGroup.HaveInSlot(plr->m_lookingForGroup.more))
continue;
// attempt create group, or skip
if(!plr->GetGroup())
if (!plr->GetGroup())
{
Group* group = new Group;
if(!group->Create(plr->GetGUID(), plr->GetName()))
if (!group->Create(plr->GetObjectGuid(), plr->GetName()))
{
delete group;
continue;
@ -66,7 +66,7 @@ static void AttemptJoin(Player* _player)
}
// stop at success join
if(plr->GetGroup()->AddMember(_player->GetGUID(), _player->GetName()))
if(plr->GetGroup()->AddMember(_player->GetObjectGuid(), _player->GetName()))
{
if( sWorld.getConfig(CONFIG_BOOL_RESTRICTED_LFG_CHANNEL) && _player->GetSession()->GetSecurity() == SEC_PLAYER )
_player->LeaveLFGChannel();
@ -84,7 +84,7 @@ static void AttemptJoin(Player* _player)
static void AttemptAddMore(Player* _player)
{
// skip not group leader case
if(_player->GetGroup() && _player->GetGroup()->GetLeaderGUID()!=_player->GetGUID())
if (_player->GetGroup() && _player->GetGroup()->GetLeaderGuid() != _player->GetObjectGuid())
return;
if(!_player->m_lookingForGroup.more.canAutoJoin())
@ -97,7 +97,7 @@ static void AttemptAddMore(Player* _player)
Player *plr = iter->second;
// skip enemies and self
if(!plr || plr==_player || plr->GetTeam() != _player->GetTeam())
if (!plr || plr==_player || plr->GetTeam() != _player->GetTeam())
continue;
if(!plr->IsInWorld())
@ -114,7 +114,7 @@ static void AttemptAddMore(Player* _player)
if(!_player->GetGroup())
{
Group* group = new Group;
if(!group->Create(_player->GetGUID(), _player->GetName()))
if(!group->Create(_player->GetObjectGuid(), _player->GetName()))
{
delete group;
return; // can't create group (??)
@ -124,7 +124,7 @@ static void AttemptAddMore(Player* _player)
}
// stop at join fail (full)
if(!_player->GetGroup()->AddMember(plr->GetGUID(), plr->GetName()) )
if(!_player->GetGroup()->AddMember(plr->GetObjectGuid(), plr->GetName()) )
{
if( sWorld.getConfig(CONFIG_BOOL_RESTRICTED_LFG_CHANNEL) && _player->GetSession()->GetSecurity() == SEC_PLAYER )
_player->LeaveLFGChannel();

8
src/game/Level1.cpp
View file

@ -415,8 +415,8 @@ bool ChatHandler::HandleNamegoCommand(char* args)
// we are in instance, and can summon only player in our group with us as lead
if (!m_session->GetPlayer()->GetGroup() || !target->GetGroup() ||
(target->GetGroup()->GetLeaderGUID() != m_session->GetPlayer()->GetGUID()) ||
(m_session->GetPlayer()->GetGroup()->GetLeaderGUID() != m_session->GetPlayer()->GetGUID()))
(target->GetGroup()->GetLeaderGuid() != m_session->GetPlayer()->GetObjectGuid()) ||
(m_session->GetPlayer()->GetGroup()->GetLeaderGuid() != m_session->GetPlayer()->GetObjectGuid()))
// the last check is a bit excessive, but let it be, just in case
{
PSendSysMessage(LANG_CANNOT_SUMMON_TO_INST,nameLink.c_str());
@ -1931,8 +1931,8 @@ bool ChatHandler::HandleGroupgoCommand(char* args)
// we are in instance, and can summon only player in our group with us as lead
if ( to_instance && (
!m_session->GetPlayer()->GetGroup() || (grp->GetLeaderGUID() != m_session->GetPlayer()->GetGUID()) ||
(m_session->GetPlayer()->GetGroup()->GetLeaderGUID() != m_session->GetPlayer()->GetGUID()) ) )
!m_session->GetPlayer()->GetGroup() || (grp->GetLeaderGuid() != m_session->GetPlayer()->GetObjectGuid()) ||
(m_session->GetPlayer()->GetGroup()->GetLeaderGuid() != m_session->GetPlayer()->GetObjectGuid()) ) )
// the last check is a bit excessive, but let it be, just in case
{
SendSysMessage(LANG_CANNOT_SUMMON_TO_INST);

8
src/game/LootHandler.cpp
View file

@ -437,7 +437,7 @@ void WorldSession::DoLootRelease(ObjectGuid lguid)
// update next looter
if(Group* group = pCreature->GetGroupLootRecipient())
if (group->GetLooterGuid() == player->GetGUID())
if (group->GetLooterGuid() == player->GetObjectGuid())
group->UpdateLooterGuid(pCreature);
if (loot->isLooted())
@ -469,19 +469,19 @@ void WorldSession::HandleLootMasterGiveOpcode( WorldPacket & recv_data )
recv_data >> lootguid >> slotid >> target_playerguid;
if(!_player->GetGroup() || _player->GetGroup()->GetLooterGuid() != _player->GetGUID())
if (!_player->GetGroup() || _player->GetGroup()->GetLooterGuid() != _player->GetObjectGuid())
{
_player->SendLootRelease(GetPlayer()->GetLootGUID());
return;
}
Player *target = ObjectAccessor::FindPlayer(target_playerguid);
if(!target)
if (!target)
return;
DEBUG_LOG("WorldSession::HandleLootMasterGiveOpcode (CMSG_LOOT_MASTER_GIVE, 0x02A3) Target = %s [%s].", target_playerguid.GetString().c_str(), target->GetName());
if(_player->GetLootGUID() != lootguid.GetRawValue())
if (_player->GetLootGUID() != lootguid.GetRawValue())
return;
Loot *pLoot = NULL;

21
src/game/Map.cpp
View file

@ -1724,15 +1724,16 @@ bool InstanceMap::Add(Player *player)
InstanceGroupBind *groupBind = pGroup->GetBoundInstance(this,GetDifficulty());
if (playerBind)
{
sLog.outError("InstanceMap::Add: player %s(%d) is being put in instance %d,%d,%d,%d,%d,%d but he is in group %d and is bound to instance %d,%d,%d,%d,%d,%d!",
player->GetName(), player->GetGUIDLow(), GetInstanceSave()->GetMapId(), GetInstanceSave()->GetInstanceId(),
sLog.outError("InstanceMap::Add: %s is being put in instance %d,%d,%d,%d,%d,%d but he is in group (Id: %d) and is bound to instance %d,%d,%d,%d,%d,%d!",
player->GetObjectGuid().GetString().c_str(), GetInstanceSave()->GetMapId(), GetInstanceSave()->GetInstanceId(),
GetInstanceSave()->GetDifficulty(), GetInstanceSave()->GetPlayerCount(), GetInstanceSave()->GetGroupCount(),
GetInstanceSave()->CanReset(), GUID_LOPART(pGroup->GetLeaderGUID()),
GetInstanceSave()->CanReset(), pGroup->GetId(),
playerBind->save->GetMapId(), playerBind->save->GetInstanceId(), playerBind->save->GetDifficulty(),
playerBind->save->GetPlayerCount(), playerBind->save->GetGroupCount(), playerBind->save->CanReset());
if (groupBind)
sLog.outError("InstanceMap::Add: the group is bound to instance %d,%d,%d,%d,%d,%d",
sLog.outError("InstanceMap::Add: the group (Id: %d) is bound to instance %d,%d,%d,%d,%d,%d",
pGroup->GetId(),
groupBind->save->GetMapId(), groupBind->save->GetInstanceId(), groupBind->save->GetDifficulty(),
groupBind->save->GetPlayerCount(), groupBind->save->GetGroupCount(), groupBind->save->CanReset());
ASSERT(false);
@ -1745,10 +1746,10 @@ bool InstanceMap::Add(Player *player)
// cannot jump to a different instance without resetting it
if (groupBind->save != GetInstanceSave())
{
sLog.outError("InstanceMap::Add: player %s(%d) is being put in instance %d,%d,%d but he is in group %d which is bound to instance %d,%d,%d!",
player->GetName(), player->GetGUIDLow(), GetInstanceSave()->GetMapId(),
sLog.outError("InstanceMap::Add: %s is being put in instance %d,%d,%d but he is in group (Id: %d) which is bound to instance %d,%d,%d!",
player->GetObjectGuid().GetString().c_str(), GetInstanceSave()->GetMapId(),
GetInstanceSave()->GetInstanceId(), GetInstanceSave()->GetDifficulty(),
GUID_LOPART(pGroup->GetLeaderGUID()), groupBind->save->GetMapId(),
pGroup->GetId(), groupBind->save->GetMapId(),
groupBind->save->GetInstanceId(), groupBind->save->GetDifficulty());
if (GetInstanceSave())
@ -1913,7 +1914,7 @@ bool InstanceMap::Reset(uint8 method)
void InstanceMap::PermBindAllPlayers(Player *player)
{
if(!IsDungeon())
if (!IsDungeon())
return;
Group *group = player->GetGroup();
@ -1924,7 +1925,7 @@ void InstanceMap::PermBindAllPlayers(Player *player)
// players inside an instance cannot be bound to other instances
// some players may already be permanently bound, in this case nothing happens
InstancePlayerBind *bind = plr->GetBoundInstance(GetId(), GetDifficulty());
if(!bind || !bind->perm)
if (!bind || !bind->perm)
{
plr->BindToInstance(GetInstanceSave(), true);
WorldPacket data(SMSG_INSTANCE_SAVE_CREATED, 4);
@ -1933,7 +1934,7 @@ void InstanceMap::PermBindAllPlayers(Player *player)
}
// if the leader is not in the instance the group will not get a perm bind
if(group && group->GetLeaderGUID() == plr->GetGUID())
if (group && group->GetLeaderGuid() == plr->GetObjectGuid())
group->BindToInstance(GetInstanceSave(), true);
}
}

16
src/game/MiscHandler.cpp
View file

@ -1347,9 +1347,9 @@ void WorldSession::HandleResetInstancesOpcode( WorldPacket & /*recv_data*/ )
{
DEBUG_LOG("WORLD: CMSG_RESET_INSTANCES");
if(Group *pGroup = _player->GetGroup())
if (Group *pGroup = _player->GetGroup())
{
if(pGroup->IsLeader(_player->GetGUID()))
if (pGroup->IsLeader(_player->GetObjectGuid()))
{
pGroup->ResetInstances(INSTANCE_RESET_ALL, false, _player);
pGroup->ResetInstances(INSTANCE_RESET_ALL, true,_player);
@ -1386,12 +1386,12 @@ void WorldSession::HandleSetDungeonDifficultyOpcode( WorldPacket & recv_data )
return;
}
if(_player->getLevel() < LEVELREQUIREMENT_HEROIC)
if (_player->getLevel() < LEVELREQUIREMENT_HEROIC)
return;
if(Group *pGroup = _player->GetGroup())
if (Group *pGroup = _player->GetGroup())
{
if(pGroup->IsLeader(_player->GetGUID()))
if (pGroup->IsLeader(_player->GetObjectGuid()))
{
// the difficulty is set even if the instances can't be reset
//_player->SendDungeonDifficulty(true);
@ -1430,12 +1430,12 @@ void WorldSession::HandleSetRaidDifficultyOpcode( WorldPacket & recv_data )
return;
}
if(_player->getLevel() < LEVELREQUIREMENT_HEROIC)
if (_player->getLevel() < LEVELREQUIREMENT_HEROIC)
return;
if(Group *pGroup = _player->GetGroup())
if (Group *pGroup = _player->GetGroup())
{
if(pGroup->IsLeader(_player->GetGUID()))
if (pGroup->IsLeader(_player->GetObjectGuid()))
{
// the difficulty is set even if the instances can't be reset
//_player->SendDungeonDifficulty(true);

2
src/game/NPCHandler.cpp
View file

@ -467,7 +467,7 @@ void WorldSession::HandleListStabledPetsOpcode( WorldPacket & recv_data )
recv_data >> npcGUID;
Creature *unit = GetPlayer()->GetNPCIfCanInteractWith(npcGUID.GetRawValue(), UNIT_NPC_FLAG_STABLEMASTER);
Creature *unit = GetPlayer()->GetNPCIfCanInteractWith(npcGUID, UNIT_NPC_FLAG_STABLEMASTER);
if (!unit)
{
DEBUG_LOG( "WORLD: HandleListStabledPetsOpcode - %s not found or you can't interact with him.", npcGUID.GetString().c_str());

7
src/game/ObjectMgr.cpp
View file

@ -3310,6 +3310,7 @@ void ObjectMgr::LoadGroups()
count++;
uint32 memberGuidlow = fields[0].GetUInt32();
ObjectGuid memberGuid = ObjectGuid(HIGHGUID_PLAYER, memberGuidlow);
bool assistent = fields[1].GetBool();
uint8 subgroup = fields[2].GetUInt8();
uint32 groupId = fields[3].GetUInt32();
@ -3318,7 +3319,8 @@ void ObjectMgr::LoadGroups()
group = GetGroupById(groupId);
if (!group)
{
sLog.outErrorDb("Incorrect entry in group_member table : no group with Id %d for member %d!", groupId, memberGuidlow);
sLog.outErrorDb("Incorrect entry in group_member table : no group with Id %d for member %s!",
groupId, memberGuid.GetString().c_str());
CharacterDatabase.PExecute("DELETE FROM group_member WHERE memberGuid = '%d'", memberGuidlow);
continue;
}
@ -3326,7 +3328,8 @@ void ObjectMgr::LoadGroups()
if (!group->LoadMemberFromDB(memberGuidlow, subgroup, assistent))
{
sLog.outErrorDb("Incorrect entry in group_member table : member %d cannot be added to player %d's group (Id: %u)!", memberGuidlow, GUID_LOPART(group->GetLeaderGUID()), groupId);
sLog.outErrorDb("Incorrect entry in group_member table : member %s cannot be added to group (Id: %u)!",
memberGuid.GetString().c_str(), groupId);
CharacterDatabase.PExecute("DELETE FROM group_member WHERE memberGuid = '%d'", memberGuidlow);
}
}while( result->NextRow() );

40
src/game/Player.cpp
View file

@ -2479,9 +2479,9 @@ void Player::UninviteFromGroup()
void Player::RemoveFromGroup(Group* group, ObjectGuid guid)
{
if(group)
if (group)
{
if (group->RemoveMember(guid.GetRawValue(), 0) <= 1)
if (group->RemoveMember(guid, 0) <= 1)
{
// group->Disband(); already disbanded in RemoveMember
sObjectMgr.RemoveGroup(group);
@ -8049,7 +8049,7 @@ void Player::SendLoot(ObjectGuid guid, LootType loot_type)
{
if (group->GetLootMethod() == FREE_FOR_ALL)
permission = ALL_PERMISSION;
else if (group->GetLooterGuid() == GetGUID())
else if (group->GetLooterGuid() == GetObjectGuid())
{
if (group->GetLootMethod() == MASTER_LOOT)
permission = MASTER_PERMISSION;
@ -15188,7 +15188,7 @@ bool Player::LoadFromDB( uint32 guid, SqlQueryHolder *holder )
//join player to battleground group
currentBg->EventPlayerLoggedIn(this, GetGUID());
currentBg->AddOrSetPlayerToCorrectBgGroup(this, GetGUID(), m_bgData.bgTeam);
currentBg->AddOrSetPlayerToCorrectBgGroup(this, GetObjectGuid(), m_bgData.bgTeam);
SetInviteForBattleGroundQueueType(bgQueueTypeId,currentBg->GetInstanceID());
}
@ -16376,7 +16376,7 @@ void Player::_LoadGroup(QueryResult *result)
if (Group* group = sObjectMgr.GetGroupById(groupId))
{
uint8 subgroup = group->GetMemberGroup(GetGUID());
uint8 subgroup = group->GetMemberGroup(GetObjectGuid());
SetGroup(group, subgroup);
if (getLevel() >= LEVELREQUIREMENT_HEROIC)
{
@ -16436,8 +16436,10 @@ void Player::_LoadBoundInstances(QueryResult *result)
if(!perm && group)
{
sLog.outError("_LoadBoundInstances: player %s(%d) is in group %d but has a non-permanent character bind to map %d,%d,%d", GetName(), GetGUIDLow(), GUID_LOPART(group->GetLeaderGUID()), mapId, instanceId, difficulty);
CharacterDatabase.PExecute("DELETE FROM character_instance WHERE guid = '%d' AND instance = '%d'", GetGUIDLow(), instanceId);
sLog.outError("_LoadBoundInstances: %s is in group (Id: %d) but has a non-permanent character bind to map %d,%d,%d",
GetObjectGuid().GetString().c_str(), group->GetId(), mapId, instanceId, difficulty);
CharacterDatabase.PExecute("DELETE FROM character_instance WHERE guid = '%d' AND instance = '%d'",
GetGUIDLow(), instanceId);
continue;
}
@ -16609,13 +16611,19 @@ void Player::SendSavedInstances()
}
/// convert the player's binds to the group
void Player::ConvertInstancesToGroup(Player *player, Group *group, uint64 player_guid)
void Player::ConvertInstancesToGroup(Player *player, Group *group, ObjectGuid player_guid)
{
bool has_binds = false;
bool has_solo = false;
if(player) { player_guid = player->GetGUID(); if(!group) group = player->GetGroup(); }
ASSERT(player_guid);
if (player)
{
player_guid = player->GetGUID();
if (!group)
group = player->GetGroup();
}
ASSERT(!player_guid.IsEmpty());
// copy all binds to the group, when changing leader it's assumed the character
// will not have any solo binds
@ -16641,13 +16649,15 @@ void Player::ConvertInstancesToGroup(Player *player, Group *group, uint64 player
}
}
uint32 player_lowguid = player_guid.GetCounter();
// if the player's not online we don't know what binds it has
if(!player || !group || has_binds)
CharacterDatabase.PExecute("INSERT INTO group_instance SELECT guid, instance, permanent FROM character_instance WHERE guid = '%u'", GUID_LOPART(player_guid));
CharacterDatabase.PExecute("INSERT INTO group_instance SELECT guid, instance, permanent FROM character_instance WHERE guid = '%u'", player_lowguid);
// the following should not get executed when changing leaders
if(!player || has_solo)
CharacterDatabase.PExecute("DELETE FROM character_instance WHERE guid = '%d' AND permanent = 0", GUID_LOPART(player_guid));
CharacterDatabase.PExecute("DELETE FROM character_instance WHERE guid = '%d' AND permanent = 0", player_lowguid);
}
bool Player::_LoadHomeBind(QueryResult *result)
@ -20588,13 +20598,13 @@ Player* Player::GetNextRandomRaidMember(float radius)
PartyResult Player::CanUninviteFromGroup() const
{
const Group* grp = GetGroup();
if(!grp)
if (!grp)
return ERR_NOT_IN_GROUP;
if(!grp->IsLeader(GetGUID()) && !grp->IsAssistant(GetGUID()))
if (!grp->IsLeader(GetObjectGuid()) && !grp->IsAssistant(GetObjectGuid()))
return ERR_NOT_LEADER;
if(InBattleGround())
if (InBattleGround())
return ERR_INVITE_RESTRICTED;
return ERR_PARTY_RESULT_OK;

2
src/game/Player.h
View file

@ -2333,7 +2333,7 @@ class MANGOS_DLL_SPEC Player : public Unit
InstancePlayerBind* BindToInstance(InstanceSave *save, bool permanent, bool load = false);
void SendRaidInfo();
void SendSavedInstances();
static void ConvertInstancesToGroup(Player *player, Group *group = NULL, uint64 player_guid = 0);
static void ConvertInstancesToGroup(Player *player, Group *group = NULL, ObjectGuid player_guid = ObjectGuid());
InstanceSave* GetBoundInstanceSaveForSelfOrGroup(uint32 mapid);
/*********************************************************/

4
src/game/Spell.cpp
View file

@ -2017,13 +2017,13 @@ void Spell::SetTargetMap(SpellEffectIndex effIndex, uint32 targetMode, UnitList&
if( targetOwner->GetTypeId() == TYPEID_PLAYER &&
target->GetTypeId() == TYPEID_UNIT && (((Creature*)target)->isPet()) &&
target->GetOwnerGUID() == targetOwner->GetGUID() &&
pGroup->IsMember(((Player*)targetOwner)->GetGUID()))
pGroup->IsMember(((Player*)targetOwner)->GetObjectGuid()))
{
targetUnitMap.push_back(target);
}
}
// 1Our target can be a player who is on our group
else if (target->GetTypeId() == TYPEID_PLAYER && pGroup->IsMember(((Player*)target)->GetGUID()))
else if (target->GetTypeId() == TYPEID_PLAYER && pGroup->IsMember(((Player*)target)->GetObjectGuid()))
{
targetUnitMap.push_back(target);
}

2
src/game/Unit.cpp
View file

@ -690,7 +690,7 @@ uint32 Unit::DealDamage(Unit *pVictim, uint32 damage, CleanDamage const* cleanDa
data << pVictim->GetObjectGuid(); //victim
if (group_tap)
group_tap->BroadcastPacket(&data, false, group_tap->GetMemberGroup(player_tap->GetGUID()),player_tap->GetGUID());
group_tap->BroadcastPacket(&data, false, group_tap->GetMemberGroup(player_tap->GetObjectGuid()),player_tap->GetObjectGuid());
player_tap->SendDirectMessage(&data);
}

2
src/shared/revision_nr.h
View file

@ -1,4 +1,4 @@
#ifndef __REVISION_NR_H__
#define __REVISION_NR_H__
#define REVISION_NR "10370"
#define REVISION_NR "10371"
#endif // __REVISION_NR_H__