PlayerGroups.h 7.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195
  1. /*
  2. EQ2Emulator: Everquest II Server Emulator
  3. Copyright (C) 2007 EQ2EMulator Development Team (http://www.eq2emulator.net)
  4. This file is part of EQ2Emulator.
  5. EQ2Emulator is free software: you can redistribute it and/or modify
  6. it under the terms of the GNU General Public License as published by
  7. the Free Software Foundation, either version 3 of the License, or
  8. (at your option) any later version.
  9. EQ2Emulator is distributed in the hope that it will be useful,
  10. but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  12. GNU General Public License for more details.
  13. You should have received a copy of the GNU General Public License
  14. along with EQ2Emulator. If not, see <http://www.gnu.org/licenses/>.
  15. */
  16. #ifndef __PLAYERGROUPS_H__
  17. #define __PLAYERGROUPS_H__
  18. #include <deque>
  19. #include <map>
  20. #include "../common/types.h"
  21. #include "Entity.h"
  22. using namespace std;
  23. /// <summary>All the generic info for the group window, plus a client pointer for players</summary>
  24. struct GroupMemberInfo {
  25. int32 group_id;
  26. string name;
  27. string zone;
  28. sint32 hp_current;
  29. sint32 hp_max;
  30. sint32 power_current;
  31. sint32 power_max;
  32. int16 level_current;
  33. int16 level_max;
  34. int8 race_id;
  35. int8 class_id;
  36. bool leader;
  37. Client* client;
  38. Entity* member;
  39. };
  40. /// <summary>Represents a players group in game</summary>
  41. class PlayerGroup {
  42. public:
  43. PlayerGroup(int32 id);
  44. ~PlayerGroup();
  45. /// <summary>Adds a new member to the players group</summary>
  46. /// <param name='member'>Entity to add to the group, can be a Player or NPC</param>
  47. /// <returns>True if the member was added</returns>
  48. bool AddMember(Entity* member);
  49. /// <summary>Removes a member from the players group</summary>
  50. /// <param name='member'>Entity to remove from the player group</param>
  51. /// <returns>True if the member was removed</param>
  52. bool RemoveMember(Entity* member);
  53. /// <summary>Removes all members from the group and destroys the group</summary>
  54. void Disband();
  55. /// <summary>Sends updates to all the clients in the group</summary>
  56. /// <param name='exclude'>Client to exclude from the update</param>
  57. void SendGroupUpdate(Client* exclude = 0);
  58. /// <summary>Gets the total number of members in the group</summary>
  59. /// <returns>int32, number of members in the group</returns>
  60. int32 Size() { return m_members.size(); }
  61. /// <summary>Gets a pointer to the list of members</summary>
  62. /// <returns>deque pointer</returns>
  63. deque<GroupMemberInfo*>* GetMembers() { return &m_members; }
  64. void SimpleGroupMessage(const char* message);
  65. void GroupChatMessage(Spawn* from, const char* message);
  66. void MakeLeader(Entity* new_leader);
  67. Mutex MGroupMembers; // Mutex for the group members
  68. private:
  69. int32 m_id; // ID of this group
  70. deque<GroupMemberInfo*> m_members; // List of members in this group
  71. };
  72. /// <summary>Responsible for managing all the player groups in the world</summary>
  73. class PlayerGroupManager {
  74. public:
  75. PlayerGroupManager();
  76. ~PlayerGroupManager();
  77. /// <summary>Adds a member to a group</summary>
  78. /// <param name='group_id'>ID of the group to add a member to</param>
  79. /// <param name='member'>Entity* to add to the group</param>
  80. /// <returns>True if the member was added to the group</returns>
  81. bool AddGroupMember(int32 group_id, Entity* member);
  82. /// <summary>Removes a member from a group</summary>
  83. /// <param name='group_id'>ID of the group to remove a member from</param>
  84. /// <param name='member'>Entity* to remove from the group</param>
  85. /// <returns>True if the member was removed from the group</returns>
  86. bool RemoveGroupMember(int32 group_id, Entity* member);
  87. /// <summary>Creates a new group with the provided Entity* as the leader</summary>
  88. /// <param name='leader'>The Entity* that will be the leader of the group</param>
  89. void NewGroup(Entity* leader);
  90. /// <summary>Removes the group from the group manager</summary>
  91. /// <param name='group_id'>ID of the group to remove</param>
  92. void RemoveGroup(int32 group_id);
  93. /// <summary>Handles a player inviting another player or NPC to a group</summary>
  94. /// <param name='leader'>Player that sent the invite</param>
  95. /// <param name='member'>Player or NPC that is the target of the invite</param>
  96. /// <returns>Error code if invite was unsuccessful, 0 if successful</returns>
  97. int8 Invite(Player* leader, Entity* member);
  98. /// <summary>Handles accepting of a group invite</summary>
  99. /// <param name='member'>Entity* that is accepting the invite</param>
  100. /// <returns>Error code if accepting the invite failed, 0 if successful<returns>
  101. int8 AcceptInvite(Entity* member);
  102. /// <summary>Handles declining of a group invite</summary>
  103. /// <param name='member'>Entity* that is declining the invite</param>
  104. void DeclineInvite(Entity* member);
  105. /// <summary>Checks to see if there is a group with the given id in the group manager</summary>
  106. /// <param name='group_id'>ID to check for</param>
  107. /// <returns>True if a group with the given ID is found</returns>
  108. bool IsGroupIDValid(int32 group_id);
  109. /// <summary>Send updates to all the clients in the group</summary>
  110. /// <param name='group_id'>ID of the group to send updates to</param>
  111. /// <param name='exclude'>Client* to exclude from the update, usually the one that triggers the update</param>
  112. void SendGroupUpdate(int32 group_id, Client* exclude = 0);
  113. PlayerGroup* GetGroup(int32 group_id);
  114. /// <summary>
  115. /// Gets the group members for the given group, be sure to call GroupLock() before calling this and ReleaseGroupLock() after you
  116. /// are done with the list. This is for reading purposes only, the list should never be altered using this function
  117. /// </summary>
  118. /// <param name='group_id'>ID of the group who's members we want</param>
  119. /// <returns>deque pointer of the members in the group</returns>
  120. deque<GroupMemberInfo*>* GetGroupMembers(int32 group_id);
  121. /// <summary>Read locks the group list, no changes to the list should be made when using this</summary>
  122. /// <param name='function'>Name of the function called from, used for better debugging in the event of a deadlock</param>
  123. /// <param name='line'>Line number that this was called from, used for better debugging in the event of a deadlock</param>
  124. void GroupLock(const char* function = 0, int32 line = 0U) { MGroups.readlock(function, line); }
  125. /// <summary>Releases the readlock acquired from GroupLock()</summary>
  126. /// <param name='function'>Name of the function called from, used for better debugging in the event of a deadlock</param>
  127. /// <param name='line'>Line number that this was called from, used for better debugging in the event of a deadlock</param>
  128. void ReleaseGroupLock(const char* function = 0, int32 line = 0U) { MGroups.releasereadlock(function, line); }
  129. void ClearPendingInvite(Entity* member);
  130. void RemoveGroupBuffs(int32 group_id, Client* client);
  131. int32 GetGroupSize(int32 group_id);
  132. void SendGroupQuests(int32 group_id, Client* client);
  133. void SimpleGroupMessage(int32 group_id, const char* message);
  134. void GroupMessage(int32 group_id, const char* message, ...);
  135. void GroupChatMessage(int32 group_id, Spawn* from, const char* message);
  136. void MakeLeader(int32 group_id, Entity* new_leader);
  137. void UpdateGroupBuffs();
  138. bool IsInGroup(int32 group_id, Entity* member);
  139. // TODO: Any function below this comment
  140. bool IsSpawnInGroup(int32 group_id, string name); // used in follow
  141. Player* GetGroupLeader(int32 group_id);
  142. private:
  143. int32 m_nextGroupID; // Used to generate a new unique id for new groups
  144. map<int32, PlayerGroup*> m_groups; // int32 is the group id, PlayerGroup* is a pointer to the actual group
  145. map<string, string> m_pendingInvites; // First string is the person invited to the group, second string is the leader of the group
  146. Mutex MGroups; // Mutex for the group map (m_groups)
  147. Mutex MPendingInvites; // Mutex for the pending invites map (m_pendingInvites)
  148. };
  149. #endif