mirror of
https://github.com/EQEmu/Server.git
synced 2025-12-11 21:01:29 +00:00
306 lines
11 KiB
C++
306 lines
11 KiB
C++
/* EQEMu: Everquest Server Emulator
|
|
Copyright (C) 2001-2005 EQEMu Development Team (http://eqemulator.net)
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; version 2 of the License.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY except by those people which sell it, which
|
|
are required to give you total support for your newly bought product;
|
|
without even the implied warranty of MERCHANTABILITY or FITNESS FOR
|
|
A PARTICULAR PURPOSE. See the GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*/
|
|
#ifndef RAIDS_H
|
|
#define RAIDS_H
|
|
|
|
#include "../common/types.h"
|
|
#include "groups.h"
|
|
#include "xtargetautohaters.h"
|
|
#include "client.h"
|
|
|
|
class Client;
|
|
class EQApplicationPacket;
|
|
class Mob;
|
|
|
|
enum {
|
|
FindNextMarkerSlot = 1,
|
|
FindNextAssisterSlot = 2,
|
|
RaidDelegateMainAssist = 3,
|
|
RaidDelegateMainMarker = 4
|
|
};
|
|
|
|
typedef enum {
|
|
MAIN_ASSIST_1_SLOT = 0,
|
|
MAIN_ASSIST_2_SLOT = 1,
|
|
MAIN_ASSIST_3_SLOT = 2,
|
|
MAIN_ASSIST_1 = 1,
|
|
MAIN_ASSIST_2 = 2,
|
|
MAIN_ASSIST_3 = 3,
|
|
} MainAssistType;
|
|
|
|
typedef enum {
|
|
MAIN_MARKER_1_SLOT = 0,
|
|
MAIN_MARKER_2_SLOT = 1,
|
|
MAIN_MARKER_3_SLOT = 2,
|
|
MAIN_MARKER_1 = 1,
|
|
MAIN_MARKER_2 = 2,
|
|
MAIN_MARKER_3 = 3,
|
|
} MainMarkerType;
|
|
|
|
enum {
|
|
ClearDelegate = 1,
|
|
SetDelegate = 0,
|
|
FindNextRaidMainMarkerSlot = 1,
|
|
FindNextRaidMainAssisterSlot = 2,
|
|
DELEGATE_OFF = 0,
|
|
DELEGATE_ON = 1
|
|
};
|
|
|
|
struct Raid_Marked_NPC {
|
|
uint32 entity_id;
|
|
uint32 zone_id;
|
|
uint32 instance_id;
|
|
};
|
|
|
|
|
|
constexpr uint8_t MAX_RAID_GROUPS = 12;
|
|
constexpr uint8_t MAX_RAID_MEMBERS = 72;
|
|
const uint32 RAID_GROUPLESS = 0xFFFFFFFF;
|
|
#define MAX_NO_RAID_MAIN_ASSISTERS 3
|
|
#define MAX_NO_RAID_MAIN_MARKERS 3
|
|
|
|
struct RaidMember{
|
|
char member_name[64]{ 0 };
|
|
Client* member{ nullptr };
|
|
uint32 group_number{ RAID_GROUPLESS };
|
|
uint8 _class{ 0 };
|
|
uint8 level{ 0 };
|
|
std::string note{};
|
|
bool is_group_leader{ false };
|
|
bool is_raid_leader{ false };
|
|
bool is_looter{ false };
|
|
uint8 main_marker{ 0 };
|
|
uint8 main_assister{ 0 };
|
|
bool is_bot{ false };
|
|
bool is_raid_main_assist_one{false};
|
|
};
|
|
|
|
struct GroupMentor {
|
|
std::string name;
|
|
Client *mentoree;
|
|
int mentor_percent;
|
|
};
|
|
|
|
class Raid : public GroupIDConsumer {
|
|
public:
|
|
Raid(Client *nLeader);
|
|
Raid(uint32 raidID);
|
|
~Raid();
|
|
|
|
void SetLeader(Client* c) { leader = c; }
|
|
Client* GetLeader() { return leader; }
|
|
std::string GetLeaderName() { return leadername; }
|
|
bool IsLeader(Client* c) { return c == leader; }
|
|
bool IsLeader(const char* name) { return !strcmp(leadername, name); }
|
|
void SetRaidLeader(const char *wasLead, const char *name);
|
|
|
|
bool Process();
|
|
|
|
void AddMember(Client *c, uint32 group = 0xFFFFFFFF, bool rleader=false, bool groupleader=false, bool looter=false);
|
|
void AddBot(Bot* b, uint32 group = 0xFFFFFFFF, bool raid_leader=false, bool group_leader=false, bool looter=false);
|
|
void RaidGroupSay(const char* msg, const char* from, uint8 language, uint8 lang_skill);
|
|
void RaidSay(const char* msg, const char* from, uint8 language, uint8 lang_skill);
|
|
bool IsEngaged();
|
|
Mob* GetRaidMainAssistOne();
|
|
void RemoveMember(const char *character_name);
|
|
void DisbandRaid();
|
|
void MoveMember(const char *name, uint32 newGroup);
|
|
void SetGroupLeader(const char *who, bool glFlag = true);
|
|
Client *GetGroupLeader(uint32 group_id);
|
|
void RemoveGroupLeader(const char *who);
|
|
bool IsGroupLeader(const char* name);
|
|
bool IsGroupLeader(Client *c);
|
|
bool IsRaidMember(const char* name);
|
|
bool IsRaidMember(Client *c);
|
|
void UpdateLevel(const char *name, int newLevel);
|
|
void SetNewRaidLeader(uint32 i);
|
|
bool IsAssister(const char* who);
|
|
bool IsMarker(const char* who);
|
|
void EmptyRaidMembers();
|
|
|
|
uint32 GetFreeGroup();
|
|
uint8 GroupCount(uint32 gid);
|
|
uint8 RaidCount();
|
|
uint32 GetHighestLevel();
|
|
uint32 GetLowestLevel();
|
|
uint32 GetGroup(const char *name);
|
|
uint32 GetGroup(Client *c);
|
|
uint16 GetAvgLevel();
|
|
|
|
uint32 GetLootType() { return LootType; }
|
|
void ChangeLootType(uint32 type);
|
|
void AddRaidLooter(const char* looter);
|
|
void RemoveRaidLooter(const char* looter);
|
|
|
|
inline void SetRaidMOTD(const std::string& in_motd) { motd = in_motd; };
|
|
|
|
//util func
|
|
//keeps me from having to keep iterating through the list
|
|
//when I want lots of data from the same entry
|
|
uint32 GetPlayerIndex(const char *name);
|
|
uint32 GetPlayerIndex(Client *c);
|
|
//for perl interface
|
|
Client *GetClientByIndex(uint16 index);
|
|
const char *GetClientNameByIndex(uint8 index);
|
|
|
|
void LockRaid(bool lockFlag);
|
|
bool IsLocked() { return locked; }
|
|
|
|
//Actual Implementation Stuff
|
|
|
|
void RaidMessageString(Mob* sender, uint32 type, uint32 string_id, const char* message,const char* message2=0,const char* message3=0,const char* message4=0,const char* message5=0,const char* message6=0,const char* message7=0,const char* message8=0,const char* message9=0, uint32 distance = 0);
|
|
void CastGroupSpell(Mob* caster,uint16 spellid, uint32 gid);
|
|
void SplitExp(const uint64 exp, Mob* other);
|
|
uint32 GetTotalRaidDamage(Mob* other);
|
|
void BalanceHP(int32 penalty, uint32 gid, float range = 0, Mob* caster = nullptr, int32 limit = 0);
|
|
void BalanceMana(int32 penalty, uint32 gid, float range = 0, Mob* caster = nullptr, int32 limit = 0);
|
|
void HealGroup(uint32 heal_amt, Mob* caster, uint32 gid, float range = 0);
|
|
void SplitMoney(uint32 gid, uint32 copper, uint32 silver, uint32 gold, uint32 platinum, Client *splitter = nullptr);
|
|
|
|
void TeleportGroup(Mob* sender, uint32 zoneID, uint16 instance_id, float x, float y, float z, float heading, uint32 gid);
|
|
void TeleportRaid(Mob* sender, uint32 zoneID, uint16 instance_id, float x, float y, float z, float heading);
|
|
|
|
//updates the list of Client* objects based on who's in and not in the zone.
|
|
//also learns raid structure based on db.
|
|
void SetRaidDetails();
|
|
void GetRaidDetails();
|
|
void SaveRaidMOTD();
|
|
bool LearnMembers();
|
|
void VerifyRaid();
|
|
void MemberZoned(Client *c);
|
|
void SendHPManaEndPacketsTo(Client *c);
|
|
void SendHPManaEndPacketsFrom(Mob *mob);
|
|
void SendManaPacketFrom(Mob *mob);
|
|
void SendEndurancePacketFrom(Mob *mob);
|
|
void RaidSay(const char *msg, Client *c, uint8 language, uint8 lang_skill);
|
|
void RaidGroupSay(const char *msg, Client *c, uint8 language, uint8 lang_skill);
|
|
void SaveRaidNote(std::string who, std::string note);
|
|
std::vector<RaidMember> GetMembersWithNotes();
|
|
void DelegateAbilityAssist(Mob* mob, const char* who);
|
|
void DelegateAbilityMark(Mob* mob, const char* who);
|
|
void RaidMarkNPC(Mob* mob, uint32 parameter);
|
|
void UpdateXTargetType(XTargetType Type, Mob* m, const char* name = (const char*)nullptr);
|
|
int FindNextRaidDelegateSlot(int option);
|
|
void UpdateXtargetMarkedNPC();
|
|
void RaidClearNPCMarks(Client* c);
|
|
void RemoveRaidDelegates(const char* delegatee);
|
|
void UpdateRaidXTargets();
|
|
|
|
//Packet Functions
|
|
void SendRaidCreate(Client *to);
|
|
void SendRaidAdd(const char *who, Client *to);
|
|
void SendRaidAddAll(const char *who);
|
|
void SendRaidRemove(const char *who, Client *to);
|
|
void SendRaidRemoveAll(const char *who);
|
|
void SendRaidDisband(Client *to);
|
|
void SendRaidDisbandAll();
|
|
void SendRaidMove(const char* who, Client *to);
|
|
void SendRaidMoveAll(const char* who);
|
|
void SendBulkRaid(Client *to);
|
|
void SendRaidNotes();
|
|
void SendRaidNotesToWorld();
|
|
void SendRemoveRaidXTargets(XTargetType Type);
|
|
void SendRemoveAllRaidXTargets();
|
|
void SendRemoveAllRaidXTargets(const char* client_name);
|
|
void SendRaidAssistTarget();
|
|
void SendAssistTarget(Client* c);
|
|
void GroupUpdate(uint32 gid, bool initial = true);
|
|
void SendGroupUpdate(Client *to);
|
|
void SendGroupDisband(Client *to);
|
|
void SendRaidLock();
|
|
void SendRaidUnlock();
|
|
void SendRaidLockTo(Client *c);
|
|
void SendRaidUnlockTo(Client *c);
|
|
void SendRaidGroupAdd(const char *who, uint32 gid);
|
|
void SendRaidGroupRemove(const char *who, uint32 gid);
|
|
void SendMakeLeaderPacket(const char *who); //30
|
|
void SendMakeLeaderPacketTo(const char *who, Client *to);
|
|
void SendMakeGroupLeaderPacketAll();
|
|
void SendMakeGroupLeaderPacket(const char *who); //13
|
|
void SendMakeGroupLeaderPacketTo(const char *who, Client *to);
|
|
void SendRaidMOTD(Client *c);
|
|
void SendRaidMOTD();
|
|
void SendRaidMOTDToWorld();
|
|
void SendRaidAssisterTo(const char* assister, Client* to);
|
|
void SendRaidAssister(const char* assister);
|
|
void SendRaidMarkerTo(const char* marker, Client* to);
|
|
void SendRaidMarker(const char* marker);
|
|
void SendMarkTargets(Client* c);
|
|
|
|
void QueuePacket(const EQApplicationPacket *app, bool ack_req = true);
|
|
|
|
// Leadership
|
|
void UpdateGroupAAs(uint32 gid);
|
|
void SaveGroupLeaderAA(uint32 gid);
|
|
void UpdateRaidAAs();
|
|
void SaveRaidLeaderAA();
|
|
void SendGroupLeadershipAA(Client *c, uint32 gid);
|
|
void SendGroupLeadershipAA(uint32 gid);
|
|
void SendAllRaidLeadershipAA();
|
|
void LoadLeadership();
|
|
inline int GetLeadershipAA(int AAID, uint32 gid = 0)
|
|
{ if (AAID >= 16) return raid_aa.ranks[AAID - 16]; else return group_aa[gid].ranks[AAID]; }
|
|
inline void SetGroupAAs(uint32 gid, GroupLeadershipAA_Struct *glaa)
|
|
{ memcpy(&group_aa[gid], glaa, sizeof(GroupLeadershipAA_Struct)); }
|
|
inline void SetRaidAAs(RaidLeadershipAA_Struct *rlaa)
|
|
{ memcpy(&raid_aa, rlaa, sizeof(RaidLeadershipAA_Struct)); }
|
|
|
|
void SetGroupMentor(uint32 group_id, int percent, char *name);
|
|
void ClearGroupMentor(uint32 group_id);
|
|
void CheckGroupMentor(uint32 group_id, Client *c); // this just checks if we should be fixing the pointer in group mentor struct on zone
|
|
inline int GetMentorPercent(uint32 group_id) { return group_mentor[group_id].mentor_percent; }
|
|
inline Client *GetMentoree(uint32 group_id) { return group_mentor[group_id].mentoree; }
|
|
|
|
void SetDirtyAutoHaters();
|
|
inline XTargetAutoHaters *GetXTargetAutoMgr() { return &m_autohatermgr; }
|
|
|
|
void QueueClients(Mob *sender, const EQApplicationPacket *app, bool ack_required = true, bool ignore_sender = true, float distance = 0, bool group_only = true);
|
|
|
|
bool DoesAnyMemberHaveExpeditionLockout(const std::string& expedition_name, const std::string& event_name, int max_check_count = 0);
|
|
|
|
std::vector<RaidMember> GetMembers() const;
|
|
std::vector<RaidMember> GetRaidGroupMembers(uint32 gid);
|
|
std::vector<Bot*> GetRaidGroupBotMembers(uint32 gid);
|
|
std::vector<Bot*> GetRaidBotMembers(uint32 owner = 0);
|
|
void HandleBotGroupDisband(uint32 owner, uint32 gid = RAID_GROUPLESS);
|
|
void HandleOfflineBots(uint32 owner);
|
|
|
|
RaidMember members[MAX_RAID_MEMBERS];
|
|
char leadername[64];
|
|
char main_assister_pcs[MAX_NO_RAID_MAIN_ASSISTERS][64];
|
|
char main_marker_pcs[MAX_NO_RAID_MAIN_MARKERS][64];
|
|
Raid_Marked_NPC marked_npcs[MAX_MARKED_NPCS];
|
|
protected:
|
|
Client *leader;
|
|
bool locked;
|
|
uint32 LootType;
|
|
bool disbandCheck;
|
|
bool forceDisband;
|
|
std::string motd;
|
|
RaidLeadershipAA_Struct raid_aa{};
|
|
GroupLeadershipAA_Struct group_aa[MAX_RAID_GROUPS]{};
|
|
|
|
GroupMentor group_mentor[MAX_RAID_GROUPS];
|
|
|
|
XTargetAutoHaters m_autohatermgr;
|
|
};
|
|
|
|
|
|
#endif
|
|
|