OregonCore  revision fb2a440-git
Your Favourite TBC server
Group.h
Go to the documentation of this file.
1 /*
2  * This file is part of the OregonCore Project. See AUTHORS file for Copyright information
3  *
4  * This program is free software; you can redistribute it and/or modify it
5  * under the terms of the GNU General Public License as published by the
6  * Free Software Foundation; either version 2 of the License, or (at your
7  * option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful, but WITHOUT
10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
12  * more details.
13  *
14  * You should have received a copy of the GNU General Public License along
15  * with this program. If not, see <http://www.gnu.org/licenses/>.
16  */
17 
18 #ifndef OREGONCORE_GROUP_H
19 #define OREGONCORE_GROUP_H
20 
21 #include "GroupReference.h"
22 #include "GroupRefManager.h"
23 #include "LootMgr.h"
24 
25 #include <map>
26 #include <vector>
27 
28 #define MAXGROUPSIZE 5
29 #define MAXRAIDSIZE 40
30 #define TARGETICONCOUNT 8
31 
33 {
34  ROLL_PASS = 0,
35  ROLL_NEED = 1,
37 
38  // other not send by client
39  ROLL_NOT_EMITED_YET = 3, // send to client
40  ROLL_NOT_VALID = 4 // not send to client
41 };
42 
44 {
48  MEMBER_STATUS_UNK0 = 0x0004, // dead? (health=0)
49  MEMBER_STATUS_UNK1 = 0x0008, // ghost? (health=1)
50  MEMBER_STATUS_UNK2 = 0x0010, // never seen
51  MEMBER_STATUS_UNK3 = 0x0020, // never seen
52  MEMBER_STATUS_UNK4 = 0x0040, // appears with dead and ghost flags
53  MEMBER_STATUS_UNK5 = 0x0080, // never seen
54  MEMBER_STATUS_RAF_BUDDY = 0x0100 // Refer-A-Friend Flag
55 };
56 
58 {
61 };
62 
64 {
68 };
69 
70 class Battleground;
71 
73 {
74  GROUP_UPDATE_FLAG_NONE = 0x00000000, // nothing
75  GROUP_UPDATE_FLAG_STATUS = 0x00000001, // uint16, flags
76  GROUP_UPDATE_FLAG_CUR_HP = 0x00000002, // uint16
77  GROUP_UPDATE_FLAG_MAX_HP = 0x00000004, // uint16
78  GROUP_UPDATE_FLAG_POWER_TYPE = 0x00000008, // uint8
79  GROUP_UPDATE_FLAG_CUR_POWER = 0x00000010, // uint16
80  GROUP_UPDATE_FLAG_MAX_POWER = 0x00000020, // uint16
81  GROUP_UPDATE_FLAG_LEVEL = 0x00000040, // uint16
82  GROUP_UPDATE_FLAG_ZONE = 0x00000080, // uint16
83  GROUP_UPDATE_FLAG_POSITION = 0x00000100, // uint16, uint16
84  GROUP_UPDATE_FLAG_AURAS = 0x00000200, // uint64 mask, for each bit set uint16 spellid + uint8 unk
85  GROUP_UPDATE_FLAG_PET_GUID = 0x00000400, // uint64 pet guid
86  GROUP_UPDATE_FLAG_PET_NAME = 0x00000800, // pet name, NULL terminated string
87  GROUP_UPDATE_FLAG_PET_MODEL_ID = 0x00001000, // uint16, model id
88  GROUP_UPDATE_FLAG_PET_CUR_HP = 0x00002000, // uint16 pet cur health
89  GROUP_UPDATE_FLAG_PET_MAX_HP = 0x00004000, // uint16 pet max health
90  GROUP_UPDATE_FLAG_PET_POWER_TYPE = 0x00008000, // uint8 pet power type
91  GROUP_UPDATE_FLAG_PET_CUR_POWER = 0x00010000, // uint16 pet cur power
92  GROUP_UPDATE_FLAG_PET_MAX_POWER = 0x00020000, // uint16 pet max power
93  GROUP_UPDATE_FLAG_PET_AURAS = 0x00040000, // uint64 mask, for each bit set uint16 spellid + uint8 unk, pet auras...
94  GROUP_UPDATE_PET = 0x0007FC00, // all pet flags
95  GROUP_UPDATE_FULL = 0x0007FFFF, // all known flags
96 };
97 
99 {
103 };
104 
105 
106 #define GROUP_UPDATE_FLAGS_COUNT 20
107 
108 // 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,11,12,13,14,15,16,17,18,19
109 static const uint8 GroupUpdateLength[GROUP_UPDATE_FLAGS_COUNT] = { 0, 2, 2, 2, 1, 2, 2, 2, 2, 4, 8, 8, 1, 2, 2, 2, 1, 2, 2, 8};
110 
111 class InstanceSave;
112 
113 class Roll : public LootValidatorRef
114 {
115  public:
116  Roll(uint64 _guid, LootItem const& li)
117  : itemGUID(_guid), itemid(li.itemid), itemRandomPropId(li.randomPropertyId), itemRandomSuffix(li.randomSuffix),
119  ~Roll() override { }
120  void setLoot(Loot* pLoot)
121  {
122  link(pLoot, this);
123  }
125  {
126  return getTarget();
127  }
128  void targetObjectBuildLink() override;
129 
134  typedef std::map<uint64, RollVote> PlayerVote;
135  PlayerVote playerVote; //vote position correspond with player position (in group)
141 };
142 
144 {
146  bool perm;
147  /* permanent InstanceGroupBinds exist iff the leader has a permanent
148  PlayerInstanceBind for the same instance. */
149  InstanceGroupBind() : save(NULL), perm(false) {}
150 };
151 
154 class Group
155 {
156  public:
157  struct MemberSlot
158  {
160  std::string name;
162  bool assistant;
163  };
164  typedef std::list<MemberSlot> MemberSlotList;
165  typedef MemberSlotList::const_iterator member_citerator;
166 
168  protected:
169  typedef MemberSlotList::iterator member_witerator;
170  typedef std::set<Player*> InvitesList;
171 
172  typedef std::vector<Roll*> Rolls;
173 
174  public:
175  Group();
176  ~Group();
177 
178  // group manipulation methods
179  bool Create(const uint64& guid, const char* name);
180  bool LoadGroupFromDB(const uint64& leaderGuid, QueryResult_AutoPtr result = QueryResult_AutoPtr(NULL), bool loadMembers = true);
181  bool LoadMemberFromDB(uint32 guidLow, uint8 subgroup, bool assistant);
182  bool AddInvite(Player* player, bool leader);
183  uint32 RemoveInvite(Player* player);
184  void RemoveAllInvites();
185  bool AddLeaderInvite(Player* player);
186  bool AddMember(const uint64& guid, const char* name);
187  uint32 RemoveMember(const uint64 &guid, const RemoveMethod &method = GROUP_REMOVEMETHOD_DEFAULT, uint64 kicker = 0, const char* reason = NULL);
188  void ChangeLeader(const uint64& guid);
190  {
191  m_lootMethod = method;
192  }
193  void SetLooterGuid(const uint64& guid)
194  {
195  m_looterGuid = guid;
196  }
197  void SetMasterLooterGuid(uint64 guid) { m_masterLooterGuid = guid; }
198  void UpdateLooterGuid(WorldObject* object, bool ifneed = false);
200  {
201  m_lootThreshold = threshold;
202  }
203  void Disband(bool hideDestroy = false);
204 
205  // properties accessories
206  bool IsFull() const
207  {
208  return (m_groupType == GROUPTYPE_NORMAL) ? (m_memberSlots.size() >= MAXGROUPSIZE) : (m_memberSlots.size() >= MAXRAIDSIZE);
209  }
210  bool isRaidGroup() const
211  {
212  return m_groupType == GROUPTYPE_RAID;
213  }
214  bool isBGGroup() const
215  {
216  return m_bgGroup != NULL;
217  }
218  bool IsCreated() const
219  {
220  return GetMembersCount() > 0;
221  }
222  const uint64& GetLeaderGUID() const
223  {
224  return m_leaderGuid;
225  }
226  const char* GetLeaderName() const
227  {
228  return m_leaderName.c_str();
229  }
231  {
232  return m_lootMethod;
233  }
234  const uint64 GetLooterGuid() const
235  {
236  if (GetLootMethod() == FREE_FOR_ALL)
237  return 0;
238  return m_looterGuid;
239  }
240  uint64 GetMasterLooterGuid() const { return m_masterLooterGuid; }
242  {
243  return m_lootThreshold;
244  }
245 
246  // member manipulation methods
247  bool IsMember(const uint64& guid) const
248  {
249  return _getMemberCSlot(guid) != m_memberSlots.end();
250  }
251  bool IsLeader(const uint64& guid) const
252  {
253  return (GetLeaderGUID() == guid);
254  }
255  uint64 GetMemberGUID(const std::string& name)
256  {
257  for (member_citerator itr = m_memberSlots.begin(); itr != m_memberSlots.end(); ++itr)
258  {
259  if (itr->name == name)
260  return itr->guid;
261  }
262  return 0;
263  }
264  bool IsAssistant(uint64 guid) const
265  {
266  member_citerator mslot = _getMemberCSlot(guid);
267  if (mslot == m_memberSlots.end())
268  return false;
269 
270  return mslot->assistant;
271  }
272  Player* GetInvited(const uint64& guid) const;
273  Player* GetInvited(const std::string& name) const;
274 
275  bool SameSubGroup(uint64 guid1, const uint64& guid2) const
276  {
277  member_citerator mslot2 = _getMemberCSlot(guid2);
278  if (mslot2 == m_memberSlots.end())
279  return false;
280 
281  return SameSubGroup(guid1, &*mslot2);
282  }
283 
284  bool SameSubGroup(uint64 guid1, MemberSlot const* slot2) const
285  {
286  member_citerator mslot1 = _getMemberCSlot(guid1);
287  if (mslot1 == m_memberSlots.end() || !slot2)
288  return false;
289 
290  return (mslot1->group == slot2->group);
291  }
292 
293  bool HasFreeSlotSubGroup(uint8 subgroup) const
294  {
295  return (m_subGroupsCounts && m_subGroupsCounts[subgroup] < MAXGROUPSIZE);
296  }
297 
298  bool SameSubGroup(Player const* member1, Player const* member2) const;
299 
300  MemberSlotList const& GetMemberSlots() const
301  {
302  return m_memberSlots;
303  }
305  {
306  return m_memberMgr.getFirst();
307  }
308  GroupReference const* GetFirstMember() const { return m_memberMgr.getFirst(); }
309  uint32 GetMembersCount() const
310  {
311  return m_memberSlots.size();
312  }
313  void GetDataForXPAtKill(Unit const* victim, uint32& count, uint32& sum_level, Player*& member_with_max_level, Player*& not_gray_member_with_max_level);
315  {
316  member_citerator mslot = _getMemberCSlot(guid);
317  if (mslot == m_memberSlots.end())
318  return (MAXRAIDSIZE / MAXGROUPSIZE + 1);
319 
320  return mslot->group;
321  }
322 
323  // some additional raid methods
324  void ConvertToRaid();
325 
327  {
328  m_bgGroup = bg;
329  }
330  uint32 CanJoinBattlegroundQueue(uint32 bgTypeId, uint32 bgQueueType, uint32 MinPlayerCount, uint32 MaxPlayerCount, bool isRated, uint32 arenaSlot);
331 
332  void ChangeMembersGroup(const uint64& guid, const uint8& group);
333  void ChangeMembersGroup(Player* player, const uint8& group);
334 
335  void SetAssistant(uint64 guid, const bool& state)
336  {
337  if (!isRaidGroup())
338  return;
339  if (_setAssistantFlag(guid, state))
340  SendUpdate();
341  }
342  void SetMainTank(uint64 guid)
343  {
344  if (!isRaidGroup())
345  return;
346 
347  if (_setMainTank(guid))
348  SendUpdate();
349  }
351  {
352  if (!isRaidGroup())
353  return;
354 
355  if (_setMainAssistant(guid))
356  SendUpdate();
357  }
358 
359  void SetTargetIcon(uint8 id, uint64 guid);
360  void SetDifficulty(DungeonDifficulty difficulty);
362  {
363  return m_difficulty;
364  }
365  uint16 InInstance();
366  bool InCombatToInstance(uint32 instanceId);
367  void ResetInstances(uint8 method, Player* SendMsgTo);
368 
369  // -no description-
370  //void SendInit(WorldSession *session);
371  void SendTargetIconList(WorldSession* session);
372  void SendUpdate();
373  void UpdatePlayerOutOfRange(Player* pPlayer);
374  // ignore: GUID of player that will be ignored
375 
376  template<class Worker>
377  void BroadcastWorker(Worker& worker)
378  {
379  for (GroupReference* itr = GetFirstMember(); itr != NULL; itr = itr->next())
380  worker(itr->GetSource());
381  }
382 
383  template<class Worker>
384  void BroadcastWorker(Worker const& worker) const
385  {
386  for (GroupReference const* itr = GetFirstMember(); itr != NULL; itr = itr->next())
387  worker(itr->GetSource());
388  }
389  void BroadcastPacket(WorldPacket* packet, bool ignorePlayersInBGRaid, int group = -1, uint64 ignore = 0);
390  void BroadcastReadyCheck(WorldPacket* packet);
391  void OfflineReadyCheck();
392 
393  /*********************************************************/
394  /*** LOOT SYSTEM ***/
395  /*********************************************************/
396 
397  void SendLootStartRoll(uint32 CountDown, const Roll& r);
398  void SendLootRoll(const uint64& SourceGuid, const uint64& TargetGuid, uint8 RollNumber, uint8 RollType, const Roll& r);
399  void SendLootRollWon(const uint64& SourceGuid, const uint64& TargetGuid, uint8 RollNumber, uint8 RollType, const Roll& r);
400  void SendLootAllPassed(uint32 NumberOfPlayers, const Roll& r);
401  void SendLooter(Creature* creature, Player* pLooter);
402  void GroupLoot(const uint64& playerGUID, Loot* loot, WorldObject* object);
403  void NeedBeforeGreed(const uint64& playerGUID, Loot* loot, WorldObject* object);
404  void MasterLoot(const uint64& playerGUID, Loot* loot, WorldObject* object);
405  Rolls::iterator GetRoll(uint64 Guid)
406  {
407  Rolls::iterator iter;
408  for (iter = RollId.begin(); iter != RollId.end(); ++iter)
409  {
410  if ((*iter)->itemGUID == Guid && (*iter)->isValid())
411  return iter;
412  }
413  return RollId.end();
414  }
415  void CountTheRoll(Rolls::iterator roll, uint32 NumberOfPlayers);
416  void CountRollVote(const uint64& playerGUID, const uint64& Guid, uint32 NumberOfPlayers, uint8 Choise);
417  void EndRoll();
418 
420  {
421  m_memberMgr.insertFirst(pRef);
422  }
423  void DelinkMember(GroupReference* /*pRef*/) { }
424 
425  InstanceGroupBind* BindToInstance(InstanceSave* save, bool permanent, bool load = false);
426  void UnbindInstance(uint32 mapid, uint8 difficulty, bool unload = false);
427  InstanceGroupBind* GetBoundInstance(Player* player);
428  InstanceGroupBind* GetBoundInstance(Map* aMap);
429  InstanceGroupBind* GetBoundInstance(MapEntry const* mapEntry);
430  InstanceGroupBind* GetBoundInstance(DungeonDifficulty difficulty, uint32 mapId);
431  BoundInstancesMap& GetBoundInstances(DungeonDifficulty difficulty);
432 
433  // FG: evil hacks
434  void BroadcastGroupUpdate(void);
435 
436  protected:
437  bool _addMember(const uint64& guid, const char* name, bool isAssistant = false);
438  bool _addMember(const uint64& guid, const char* name, bool isAssistant, uint8 group);
439  bool _removeMember(const uint64& guid); // returns true if leader has changed
440  void _setLeader(const uint64& guid);
441 
442  void _removeRolls(const uint64& guid);
443 
444  bool _setMembersGroup(const uint64& guid, const uint8& group);
445  bool _setAssistantFlag(const uint64& guid, const bool& state);
446  bool _setMainTank(const uint64& guid);
447  bool _setMainAssistant(const uint64& guid);
448 
449  void _homebindIfInstance(Player* player);
450 
452  {
453  // Sub group counters initialization
454  if (!m_subGroupsCounts)
455  m_subGroupsCounts = new uint8[MAXRAIDSIZE / MAXGROUPSIZE];
456 
457  memset((void*)m_subGroupsCounts, 0, (MAXRAIDSIZE / MAXGROUPSIZE)*sizeof(uint8));
458 
459  for (member_citerator itr = m_memberSlots.begin(); itr != m_memberSlots.end(); ++itr)
460  ++m_subGroupsCounts[itr->group];
461  }
462 
463  member_citerator _getMemberCSlot(uint64 Guid) const
464  {
465  for (member_citerator itr = m_memberSlots.begin(); itr != m_memberSlots.end(); ++itr)
466  {
467  if (itr->guid == Guid)
468  return itr;
469  }
470  return m_memberSlots.end();
471  }
472 
473  member_witerator _getMemberWSlot(uint64 Guid)
474  {
475  for (member_witerator itr = m_memberSlots.begin(); itr != m_memberSlots.end(); ++itr)
476  {
477  if (itr->guid == Guid)
478  return itr;
479  }
480  return m_memberSlots.end();
481  }
482 
484  {
485  if (m_subGroupsCounts)
486  ++m_subGroupsCounts[subgroup];
487  }
488 
490  {
491  if (m_subGroupsCounts)
492  --m_subGroupsCounts[subgroup];
493  }
494 
495  GroupFlagMask GetFlags(MemberSlot const& slot) const
496  {
497  uint8 flags = 0;
498  if (slot.assistant)
499  flags |= GROUP_ASSISTANT;
500  if (slot.guid == m_mainAssistant)
501  flags |= GROUP_MAIN_ASSISTANT;
502  if (slot.guid == m_mainTank)
503  flags |= GROUP_MAIN_TANK;
504  return GroupFlagMask(flags);
505  }
506  MemberSlotList m_memberSlots;
508  InvitesList m_invitees;
510  std::string m_leaderName;
516  uint64 m_targetIcons[TARGETICONCOUNT];
521  Rolls RollId;
522  BoundInstancesMap m_boundInstances[TOTAL_DIFFICULTIES];
524 };
525 
526 #define sScriptMgr Oregon::Singleton<ScriptMgr>::Instance()
527 #endif
528 
InstanceSave * save
Definition: Group.h:145
void SetLooterGuid(const uint64 &guid)
Definition: Group.h:193
~Roll() override
Definition: Group.h:119
void SetLootThreshold(ItemQualities threshold)
Definition: Group.h:199
uint64 itemGUID
Definition: Group.h:130
bool SameSubGroup(uint64 guid1, const uint64 &guid2) const
Definition: Group.h:275
void LinkMember(GroupReference *pRef)
Definition: Group.h:419
std::map< uint64, RollVote > PlayerVote
Definition: Group.h:134
MemberSlotList::iterator member_witerator
Definition: Group.h:169
std::set< Player * > InvitesList
Definition: Group.h:170
void _initRaidSubGroupsCounter()
Definition: Group.h:451
MemberSlotList::const_iterator member_citerator
Definition: Group.h:165
GroupMemberOnlineStatus
Definition: Group.h:43
member_witerator _getMemberWSlot(uint64 Guid)
Definition: Group.h:473
Rolls RollId
Definition: Group.h:521
uint8 totalPlayersRolling
Definition: Group.h:136
uint32 itemRandomSuffix
Definition: Group.h:133
InvitesList m_invitees
Definition: Group.h:508
bool isRaidGroup() const
Definition: Group.h:210
PlayerVote playerVote
Definition: Group.h:135
void DelinkMember(GroupReference *)
Definition: Group.h:423
uint8 * m_subGroupsCounts
Definition: Group.h:523
std::list< MemberSlot > MemberSlotList
Definition: Group.h:164
void SetLootMethod(LootMethod method)
Definition: Group.h:189
LootMethod m_lootMethod
Definition: Group.h:517
ACE_INT32 int32
Definition: Define.h:67
NULL Dbg ErrDB Arena Chat Char Map MMap false
Definition: Log.cpp:556
uint32 itemid
Definition: Group.h:131
bool IsAssistant(uint64 guid) const
Definition: Group.h:264
GroupFlagMask
Definition: Group.h:63
uint64 m_masterLooterGuid
Definition: Group.h:520
bool IsMember(const uint64 &guid) const
Definition: Group.h:247
#define TARGETICONCOUNT
Definition: Group.h:30
int32 itemRandomPropId
Definition: Group.h:132
const char * GetLeaderName() const
Definition: Group.h:226
uint64 m_looterGuid
Definition: Group.h:519
DungeonDifficulty
uint64 m_mainAssistant
Definition: Group.h:512
bool SameSubGroup(uint64 guid1, MemberSlot const *slot2) const
Definition: Group.h:284
uint64 m_mainTank
Definition: Group.h:511
Definition: Group.h:113
Battleground * m_bgGroup
Definition: Group.h:515
ItemQualities GetLootThreshold() const
Definition: Group.h:241
member_citerator _getMemberCSlot(uint64 Guid) const
Definition: Group.h:463
uint8 totalNeed
Definition: Group.h:137
GroupType
Definition: Group.h:57
bool IsFull() const
Definition: Group.h:206
MemberSlotList m_memberSlots
Definition: Group.h:506
bool IsCreated() const
Definition: Group.h:218
ACE_UINT8 uint8
Definition: Define.h:73
bool IsLeader(const uint64 &guid) const
Definition: Group.h:251
void targetObjectBuildLink() override
Definition: Group.cpp:1493
uint64 GetMasterLooterGuid() const
Definition: Group.h:240
void SetMainAssistant(uint64 guid)
Definition: Group.h:350
GroupFlagMask GetFlags(MemberSlot const &slot) const
Definition: Group.h:495
Definition: LootMgr.h:290
Rolls::iterator GetRoll(uint64 Guid)
Definition: Group.h:405
GroupRefManager m_memberMgr
Definition: Group.h:507
UNORDERED_MAP< uint32, InstanceGroupBind > BoundInstancesMap
Definition: Group.h:167
uint64 GetMemberGUID(const std::string &name)
Definition: Group.h:255
bool isBGGroup() const
Definition: Group.h:214
#define UNORDERED_MAP
Definition: UnorderedMap.h:47
bool assistant
Definition: Group.h:162
DungeonDifficulty GetDifficulty()
Definition: Group.h:361
void SubGroupCounterDecrease(uint8 subgroup)
Definition: Group.h:489
GroupReference * GetFirstMember()
Definition: Group.h:304
std::string name
Definition: Group.h:160
bool HasFreeSlotSubGroup(uint8 subgroup) const
Definition: Group.h:293
void SetAssistant(uint64 guid, const bool &state)
Definition: Group.h:335
Definition: Map.h:266
void setLoot(Loot *pLoot)
Definition: Group.h:120
GroupReference * next()
void link(Loot *toObj, LootValidatorRef *fromObj)
Definition: Reference.h:42
GroupType m_groupType
Definition: Group.h:513
MemberSlotList const & GetMemberSlots() const
Definition: Group.h:300
#define GROUP_UPDATE_FLAGS_COUNT
Definition: Group.h:106
uint64 guid
Definition: Group.h:159
ACE_UINT64 uint64
Definition: Define.h:70
Roll(uint64 _guid, LootItem const &li)
Definition: Group.h:116
ItemQualities
const uint64 & GetLeaderGUID() const
Definition: Group.h:222
#define MAXRAIDSIZE
Definition: Group.h:29
uint64 m_leaderGuid
Definition: Group.h:509
ACE_Refcounted_Auto_Ptr< QueryResult, ACE_Null_Mutex > QueryResult_AutoPtr
Definition: QueryResult.h:113
Loot * getLoot()
Definition: Group.h:124
GroupReference const * GetFirstMember() const
Definition: Group.h:308
DungeonDifficulty m_difficulty
Definition: Group.h:514
uint32 GetMembersCount() const
Definition: Group.h:309
void SetMainTank(uint64 guid)
Definition: Group.h:342
GroupUpdateFlags
Definition: Group.h:72
LootMethod
Definition: LootMgr.h:34
#define MAXGROUPSIZE
Definition: Group.h:28
ItemQualities m_lootThreshold
Definition: Group.h:518
void SetBattlegroundGroup(Battleground *bg)
Definition: Group.h:326
LootMethod GetLootMethod() const
Definition: Group.h:230
void SubGroupCounterIncrease(uint8 subgroup)
Definition: Group.h:483
uint8 GetMemberGroup(uint64 guid) const
Definition: Group.h:314
ACE_UINT16 uint16
Definition: Define.h:72
ACE_UINT32 uint32
Definition: Define.h:71
Definition: Unit.h:908
void BroadcastWorker(Worker &worker)
Definition: Group.h:377
std::string m_leaderName
Definition: Group.h:510
uint8 itemSlot
Definition: Group.h:140
Definition: Player.h:922
std::vector< Roll * > Rolls
Definition: Group.h:172
RemoveMethod
Definition: Group.h:98
const uint64 GetLooterGuid() const
Definition: Group.h:234
uint8 totalPass
Definition: Group.h:139
Definition: Group.h:154
RollVote
Definition: Group.h:32
void BroadcastWorker(Worker const &worker) const
Definition: Group.h:384
void SetMasterLooterGuid(uint64 guid)
Definition: Group.h:197
uint8 totalGreed
Definition: Group.h:138