PlayerGroups.h 7.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197
  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 <mutex>
  21. #include <shared_mutex>
  22. #include "../common/types.h"
  23. #include "Entity.h"
  24. using namespace std;
  25. /// <summary>All the generic info for the group window, plus a client pointer for players</summary>
  26. struct GroupMemberInfo {
  27. int32 group_id;
  28. string name;
  29. string zone;
  30. sint32 hp_current;
  31. sint32 hp_max;
  32. sint32 power_current;
  33. sint32 power_max;
  34. int16 level_current;
  35. int16 level_max;
  36. int8 race_id;
  37. int8 class_id;
  38. bool leader;
  39. Client* client;
  40. Entity* member;
  41. int32 mentor_target_char_id;
  42. };
  43. /// <summary>Represents a players group in game</summary>
  44. class PlayerGroup {
  45. public:
  46. PlayerGroup(int32 id);
  47. ~PlayerGroup();
  48. /// <summary>Adds a new member to the players group</summary>
  49. /// <param name='member'>Entity to add to the group, can be a Player or NPC</param>
  50. /// <returns>True if the member was added</returns>
  51. bool AddMember(Entity* member);
  52. /// <summary>Removes a member from the players group</summary>
  53. /// <param name='member'>Entity to remove from the player group</param>
  54. /// <returns>True if the member was removed</param>
  55. bool RemoveMember(Entity* member);
  56. /// <summary>Removes all members from the group and destroys the group</summary>
  57. void Disband();
  58. /// <summary>Sends updates to all the clients in the group</summary>
  59. /// <param name='exclude'>Client to exclude from the update</param>
  60. void SendGroupUpdate(Client* exclude = 0);
  61. /// <summary>Gets the total number of members in the group</summary>
  62. /// <returns>int32, number of members in the group</returns>
  63. int32 Size() { return m_members.size(); }
  64. /// <summary>Gets a pointer to the list of members</summary>
  65. /// <returns>deque pointer</returns>
  66. deque<GroupMemberInfo*>* GetMembers() { return &m_members; }
  67. void SimpleGroupMessage(const char* message);
  68. void GroupChatMessage(Spawn* from, int32 language, const char* message);
  69. void MakeLeader(Entity* new_leader);
  70. void RemoveClientReference(Client* remove);
  71. void UpdateGroupMemberInfo(Entity* ent, bool groupMembersLocked=false);
  72. Entity* GetGroupMemberByPosition(Entity* seeker, int32 mapped_position);
  73. Mutex MGroupMembers; // Mutex for the group members
  74. private:
  75. int32 m_id; // ID of this group
  76. deque<GroupMemberInfo*> m_members; // List of members in this group
  77. };
  78. /// <summary>Responsible for managing all the player groups in the world</summary>
  79. class PlayerGroupManager {
  80. public:
  81. PlayerGroupManager();
  82. ~PlayerGroupManager();
  83. /// <summary>Adds a member to a group</summary>
  84. /// <param name='group_id'>ID of the group to add a member to</param>
  85. /// <param name='member'>Entity* to add to the group</param>
  86. /// <returns>True if the member was added to the group</returns>
  87. bool AddGroupMember(int32 group_id, Entity* member);
  88. /// <summary>Removes a member from a group</summary>
  89. /// <param name='group_id'>ID of the group to remove a member from</param>
  90. /// <param name='member'>Entity* to remove from the group</param>
  91. /// <returns>True if the member was removed from the group</returns>
  92. bool RemoveGroupMember(int32 group_id, Entity* member);
  93. /// <summary>Creates a new group with the provided Entity* as the leader</summary>
  94. /// <param name='leader'>The Entity* that will be the leader of the group</param>
  95. void NewGroup(Entity* leader);
  96. /// <summary>Removes the group from the group manager</summary>
  97. /// <param name='group_id'>ID of the group to remove</param>
  98. void RemoveGroup(int32 group_id);
  99. /// <summary>Handles a player inviting another player or NPC to a group</summary>
  100. /// <param name='leader'>Player that sent the invite</param>
  101. /// <param name='member'>Player or NPC that is the target of the invite</param>
  102. /// <returns>Error code if invite was unsuccessful, 0 if successful</returns>
  103. int8 Invite(Player* leader, Entity* member);
  104. /// <summary>Handles accepting of a group invite</summary>
  105. /// <param name='member'>Entity* that is accepting the invite</param>
  106. /// <returns>Error code if accepting the invite failed, 0 if successful<returns>
  107. int8 AcceptInvite(Entity* member);
  108. /// <summary>Handles declining of a group invite</summary>
  109. /// <param name='member'>Entity* that is declining the invite</param>
  110. void DeclineInvite(Entity* member);
  111. /// <summary>Checks to see if there is a group with the given id in the group manager</summary>
  112. /// <param name='group_id'>ID to check for</param>
  113. /// <returns>True if a group with the given ID is found</returns>
  114. bool IsGroupIDValid(int32 group_id);
  115. /// <summary>Send updates to all the clients in the group</summary>
  116. /// <param name='group_id'>ID of the group to send updates to</param>
  117. /// <param name='exclude'>Client* to exclude from the update, usually the one that triggers the update</param>
  118. void SendGroupUpdate(int32 group_id, Client* exclude = 0);
  119. PlayerGroup* GetGroup(int32 group_id);
  120. /// <summary>Read locks the group list, no changes to the list should be made when using this</summary>
  121. /// <param name='function'>Name of the function called from, used for better debugging in the event of a deadlock</param>
  122. /// <param name='line'>Line number that this was called from, used for better debugging in the event of a deadlock</param>
  123. void GroupHardLock(const char* function = 0, int32 line = 0U) { MGroups.lock(); }
  124. void GroupLock(const char* function = 0, int32 line = 0U) { MGroups.lock_shared(); }
  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 ReleaseGroupHardLock(const char* function = 0, int32 line = 0U) { MGroups.unlock(); }
  129. void ReleaseGroupLock(const char* function = 0, int32 line = 0U) { MGroups.unlock_shared(); }
  130. void ClearPendingInvite(Entity* member);
  131. void RemoveGroupBuffs(int32 group_id, Client* client);
  132. int32 GetGroupSize(int32 group_id);
  133. void SendGroupQuests(int32 group_id, Client* client);
  134. bool HasGroupCompletedQuest(int32 group_id, int32 quest_id);
  135. void SimpleGroupMessage(int32 group_id, const char* message);
  136. void GroupMessage(int32 group_id, const char* message, ...);
  137. void GroupChatMessage(int32 group_id, Spawn* from, int32 language, const char* message);
  138. void MakeLeader(int32 group_id, Entity* new_leader);
  139. void UpdateGroupBuffs();
  140. bool IsInGroup(int32 group_id, Entity* member);
  141. Entity* IsPlayerInGroup(int32 group_id, int32 char_id);
  142. // TODO: Any function below this comment
  143. bool IsSpawnInGroup(int32 group_id, string name); // used in follow
  144. Player* GetGroupLeader(int32 group_id);
  145. private:
  146. int32 m_nextGroupID; // Used to generate a new unique id for new groups
  147. map<int32, PlayerGroup*> m_groups; // int32 is the group id, PlayerGroup* is a pointer to the actual group
  148. map<string, string> m_pendingInvites; // First string is the person invited to the group, second string is the leader of the group
  149. mutable std::shared_mutex MGroups; // Mutex for the group map (m_groups)
  150. Mutex MPendingInvites; // Mutex for the pending invites map (m_pendingInvites)
  151. };
  152. #endif