PlayerGroups.h 7.6 KB

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