From 6802681abe7be19260c1f77419d857883da5d3a4 Mon Sep 17 00:00:00 2001 From: neckkola <65987027+neckkola@users.noreply.github.com> Date: Tue, 4 Jan 2022 23:40:00 -0400 Subject: [PATCH] Jan 4 Basic structure in place for Raid::AddBot though not working --- zone/bot.cpp | 272 +++++++++++++++++++++++++++++++++++++++++ zone/bot.h | 1 + zone/client_packet.cpp | 57 +++++++-- zone/raids.cpp | 76 ++++++++++++ zone/raids.h | 1 + 5 files changed, 396 insertions(+), 11 deletions(-) diff --git a/zone/bot.cpp b/zone/bot.cpp index a9545c7e8..c52725585 100644 --- a/zone/bot.cpp +++ b/zone/bot.cpp @@ -20,6 +20,7 @@ #include "bot.h" #include "object.h" +#include "raids.h" #include "doors.h" #include "quest_parser_collection.h" #include "lua_parser.h" @@ -10093,4 +10094,275 @@ void Bot::StopMoving(float new_heading) uint8 Bot::spell_casting_chances[SPELL_TYPE_COUNT][PLAYER_CLASS_COUNT][EQ::constants::STANCE_TYPE_COUNT][cntHSND] = { 0 }; +void Bot::ProcessRaidInvite(Bot* player_accepting_invite, Client* b_owner) { + //Client* player_accepting_invite = entity_list.GetClientByName(raid_command_packet->player_name); + + if (player_accepting_invite) { + if (player_accepting_invite->IsRaidGrouped()) { + b_owner->MessageString(Chat::White, ALREADY_IN_RAID, player_accepting_invite->GetName()); //group failed, must invite members not in raid... + return; + } + Raid* raid = entity_list.GetRaidByMob(player_accepting_invite); + if (raid) { + raid->VerifyRaid(); + Group* group = player_accepting_invite->GetGroup(); + if (group) { + if (group->GroupCount() + raid->RaidCount() > MAX_RAID_MEMBERS) { + b_owner->Message(Chat::Red, "Invite failed, group invite would create a raid larger than the maximum number of members allowed."); + return; + } + } + else { + if (1 + raid->RaidCount() > MAX_RAID_MEMBERS) { + b_owner->Message(Chat::Red, "Invite failed, member invite would create a raid larger than the maximum number of members allowed."); + return; + } + } + if (group) {//add us all + uint32 free_group_id = raid->GetFreeGroup(); + Client* addClient = nullptr; + for (int x = 0; x < 6; x++) { + if (group->members[x]) { + Client* c = nullptr; + if (group->members[x]->IsBot()) + c = group->members[x]->CastToClient(); + + if (!addClient) + { + addClient = c; + raid->SetGroupLeader(addClient->GetName()); + } + + raid->SendRaidCreate(b_owner); + raid->SendMakeLeaderPacketTo(raid->leadername, b_owner); + if (group->IsLeader(group->members[x])) + raid->AddMember(c, free_group_id, false, true); + else + raid->AddMember(c, free_group_id); + raid->SendBulkRaid(b_owner); + if (raid->IsLocked()) { + raid->SendRaidLockTo(b_owner); + } + } + } + group->JoinRaidXTarget(raid); + group->DisbandGroup(true); + raid->GroupUpdate(free_group_id); + } + else { + raid->SendRaidCreate(b_owner); + raid->SendMakeLeaderPacketTo(raid->leadername, b_owner); + raid->AddMember(b_owner); + raid->SendBulkRaid(b_owner); + if (raid->IsLocked()) { + raid->SendRaidLockTo(b_owner); + } + } + } + else + { + Group* player_invited_group = player_accepting_invite->GetGroup(); + Group* group = entity_list.GetGroupByClient(b_owner); // player_accepting_invite->GetGroup(); + if (group) //if our target has a group + { +// raid = new Raid(player_accepting_invite); + raid = new Raid(b_owner); + entity_list.AddRaid(raid); + raid->SetRaidDetails(); + + uint32 raid_free_group_id = raid->GetFreeGroup(); + + /* If we already have a group then cycle through adding us... */ + if (player_invited_group) { + Client* client_to_be_leader = nullptr; + for (int x = 0; x < 6; x++) { + if (player_invited_group->members[x]) { + if (!client_to_be_leader) { + if (player_invited_group->members[x]->IsClient()) { + client_to_be_leader = player_invited_group->members[x]->CastToClient(); + raid->SetGroupLeader(client_to_be_leader->GetName()); + } + } + if (player_invited_group->IsLeader(player_invited_group->members[x])) { + Client* c = nullptr; + + if (player_invited_group->members[x]->IsClient() || player_invited_group->members[x]->IsBot()) + c = player_invited_group->members[x]->CastToClient(); + else + continue; + + raid->SendRaidCreate(b_owner); + raid->SendMakeLeaderPacketTo(raid->leadername, b_owner); + raid->AddMember(c, raid_free_group_id, true, true, true); + raid->SendBulkRaid(c); + + if (raid->IsLocked()) { + raid->SendRaidLockTo(b_owner); + } + } + else { + Client* c = nullptr; + + if (player_invited_group->members[x]->IsClient() || player_invited_group->members[x]->IsBot()) + c = player_invited_group->members[x]->CastToClient(); + else + continue; + + raid->SendRaidCreate(b_owner); + raid->SendMakeLeaderPacketTo(raid->leadername, b_owner); + raid->AddMember(c, raid_free_group_id); + raid->SendBulkRaid(b_owner); + + if (raid->IsLocked()) { + raid->SendRaidLockTo(b_owner); + } + } + } + } + player_invited_group->JoinRaidXTarget(raid, true); + player_invited_group->DisbandGroup(true); + raid->GroupUpdate(raid_free_group_id); + raid_free_group_id = raid->GetFreeGroup(); + } + else { +// raid->SendRaidCreate(player_accepting_invite); +// raid->AddMember(player_accepting_invite, 0xFFFFFFFF, true, false, true); + raid->SendRaidCreate(b_owner); + raid->AddMember(b_owner, 0xFFFFFFFF, true, false, true); + } + + Client* client_to_add = nullptr; + /* Add client to an existing group */ + for (int x = 0; x < 6; x++) { + if (group->members[x]) { + if (!client_to_add) { + if (group->members[x]->IsClient() || group->members[x]->IsBot()) { + client_to_add = group->members[x]->CastToClient(); + raid->SetGroupLeader(client_to_add->GetName()); + } + } + if (group->IsLeader(group->members[x])) { + Client* c = nullptr; + + if (group->members[x]->IsClient() || group->members[x]->IsClient()) + c = group->members[x]->CastToClient(); + else + continue; + + raid->SendRaidCreate(b_owner); + raid->SendMakeLeaderPacketTo(raid->leadername, b_owner); + raid->AddMember(c, raid_free_group_id, false, true); + raid->SendBulkRaid(b_owner); + + if (raid->IsLocked()) { + raid->SendRaidLockTo(b_owner); + } + } + else + { + Client* c = nullptr; + + if (group->members[x]->IsClient() || group->members[x]->IsBot()) + c = group->members[x]->CastToClient(); + else + continue; + + raid->SendRaidCreate(b_owner); + raid->SendMakeLeaderPacketTo(raid->leadername, b_owner); + raid->AddMember(c, raid_free_group_id); + raid->SendBulkRaid(b_owner); + + if (raid->IsLocked()) { + raid->SendRaidLockTo(b_owner); + } + } + } + } + group->JoinRaidXTarget(raid); + group->DisbandGroup(true); + + raid->GroupUpdate(raid_free_group_id); + } + /* Target does not have a group */ + else { + if (player_invited_group) { + + raid = new Raid(b_owner); + + entity_list.AddRaid(raid); + raid->SetRaidDetails(); + Client* addClientig = nullptr; + for (int x = 0; x < 6; x++) { + if (player_invited_group->members[x]) { + if (!addClientig) { + if (player_invited_group->members[x]->IsClient() || player_invited_group->members[x]->IsBot()) { + addClientig = player_invited_group->members[x]->CastToClient(); + raid->SetGroupLeader(addClientig->GetName()); + } + } + if (player_invited_group->IsLeader(player_invited_group->members[x])) { + Client* c = nullptr; + + if (player_invited_group->members[x]->IsClient() || player_invited_group->members[x]->IsBot()) + c = player_invited_group->members[x]->CastToClient(); + else + continue; + + raid->SendRaidCreate(b_owner); + raid->SendMakeLeaderPacketTo(raid->leadername, b_owner); + raid->AddMember(c, 0, true, true, true); + raid->SendBulkRaid(b_owner); + + if (raid->IsLocked()) { + raid->SendRaidLockTo(b_owner); + } + } + else + { + Client* c = nullptr; + if (player_invited_group->members[x]->IsClient() || player_invited_group->members[x]->IsBot()) + c = player_invited_group->members[x]->CastToClient(); + else + continue; + + raid->SendRaidCreate(b_owner); + raid->SendMakeLeaderPacketTo(raid->leadername, b_owner); + raid->AddMember(c, 0); + raid->SendBulkRaid(b_owner); + if (raid->IsLocked()) { + raid->SendRaidLockTo(b_owner); + } + } + } + } + raid->SendRaidCreate(b_owner); + raid->SendMakeLeaderPacketTo(raid->leadername, b_owner); + raid->SendBulkRaid(b_owner); + player_invited_group->JoinRaidXTarget(raid, true); + raid->AddMember(b_owner); + player_invited_group->DisbandGroup(true); + raid->GroupUpdate(0); + if (raid->IsLocked()) { + raid->SendRaidLockTo(b_owner); + } + } + else { // neither has a group + raid = new Raid(b_owner); + entity_list.AddRaid(raid); + raid->SetRaidDetails(); +// raid->SendRaidCreate(b_owner); // Not needed as one raid member is a bot + raid->SendRaidCreate(b_owner); + raid->SendMakeLeaderPacketTo(raid->leadername, b_owner); + raid->AddMember(b_owner, 0xFFFFFFFF, true, false, true); + raid->SendBulkRaid(b_owner); + raid->AddBot(player_accepting_invite); + if (raid->IsLocked()) { + raid->SendRaidLockTo(b_owner); + } + } + } + } + } + } + #endif diff --git a/zone/bot.h b/zone/bot.h index caa556cf9..eb82a253e 100644 --- a/zone/bot.h +++ b/zone/bot.h @@ -362,6 +362,7 @@ public: static std::string RaceIdToString(uint16 raceId); static bool IsBotAttackAllowed(Mob* attacker, Mob* target, bool& hasRuleDefined); static Bot* GetBotByBotClientOwnerAndBotName(Client* c, std::string botName); + static void ProcessRaidInvite(Bot* player_accepting_invite, Client* b_owner); //Mitch static void ProcessBotGroupInvite(Client* c, std::string botName); static void ProcessBotGroupDisband(Client* c, std::string botName); static void BotOrderCampAll(Client* c); diff --git a/zone/client_packet.cpp b/zone/client_packet.cpp index d6ef48140..7eae849c4 100644 --- a/zone/client_packet.cpp +++ b/zone/client_packet.cpp @@ -25,6 +25,7 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA #include #include #include +#include "bot.h" #ifdef _WINDOWS #define snprintf _snprintf @@ -11321,7 +11322,38 @@ void Client::Handle_OP_RaidCommand(const EQApplicationPacket *app) { case RaidCommandInviteIntoExisting: case RaidCommandInvite: { +//Mitch +#ifdef BOTS + Bot* player_to_invite = nullptr; + Client* player_to_invite_owner = nullptr; + if (entity_list.GetBotByBotName(raid_command_packet->player_name)) { + Bot* player_to_invite = entity_list.GetBotByBotName(raid_command_packet->player_name); + Client* player_to_invite_owner = player_to_invite->GetOwner()->CastToClient(); + if (!player_to_invite) { + break; + } + + Group* player_to_invite_group = player_to_invite->GetGroup(); + + if (player_to_invite->HasRaid()) { + Message(Chat::Red, "%s is already in a raid.", player_to_invite->GetName()); + break; + } + + if (player_to_invite_group && player_to_invite_group->IsGroupMember(this)) { + MessageString(Chat::Red, ALREADY_IN_PARTY); + break; + } + + if (player_to_invite_group && !player_to_invite_group->IsLeader(player_to_invite)) { + Message(Chat::Red, "You can only invite an ungrouped player or group leader to join your raid."); + break; + } + + Bot::ProcessRaidInvite(player_to_invite, player_to_invite_owner); + } +#else Client *player_to_invite = entity_list.GetClientByName(raid_command_packet->player_name); if (!player_to_invite) @@ -11344,22 +11376,25 @@ void Client::Handle_OP_RaidCommand(const EQApplicationPacket *app) break; } - /* Send out invite to the client */ - auto outapp = new EQApplicationPacket(OP_RaidUpdate, sizeof(RaidGeneral_Struct)); - RaidGeneral_Struct *raid_command = (RaidGeneral_Struct*)outapp->pBuffer; + /* Send out invite to the client */ + auto outapp = new EQApplicationPacket(OP_RaidUpdate, sizeof(RaidGeneral_Struct)); + RaidGeneral_Struct* raid_command = (RaidGeneral_Struct*)outapp->pBuffer; - strn0cpy(raid_command->leader_name, raid_command_packet->leader_name, 64); - strn0cpy(raid_command->player_name, raid_command_packet->player_name, 64); + strn0cpy(raid_command->leader_name, raid_command_packet->leader_name, 64); + strn0cpy(raid_command->player_name, raid_command_packet->player_name, 64); - raid_command->parameter = 0; - raid_command->action = 20; + raid_command->parameter = 0; + raid_command->action = 20; - player_to_invite->QueuePacket(outapp); + player_to_invite->QueuePacket(outapp); - safe_delete(outapp); + safe_delete(outapp); +#endif - break; - } + break; + } + + case RaidCommandAcceptInvite: { Client *player_accepting_invite = entity_list.GetClientByName(raid_command_packet->player_name); if (player_accepting_invite) { diff --git a/zone/raids.cpp b/zone/raids.cpp index 55e6d9e55..fb5e9a03a 100644 --- a/zone/raids.cpp +++ b/zone/raids.cpp @@ -24,6 +24,7 @@ #include "groups.h" #include "mob.h" #include "raids.h" +#include "bot.h" //Mitch #include "worldserver.h" @@ -162,6 +163,81 @@ void Raid::AddMember(Client *c, uint32 group, bool rleader, bool groupleader, bo worldserver.SendPacket(pack); safe_delete(pack); } +//Mitch +void Raid::AddBot(Bot* b, uint32 group, bool rleader, bool groupleader, bool looter) { + if (!b) + return; + + std::string query = StringFormat("INSERT INTO raid_members SET raidid = %lu, charid = %lu, " + "groupid = %lu, _class = %d, level = %d, name = '%s', " + "isgroupleader = %d, israidleader = %d, islooter = %d", + (unsigned long)GetID(), (unsigned long)b->GetBotID(), + (unsigned long)group, b->GetClass(), b->GetLevel(), + b->GetName(), groupleader, rleader, looter); + auto results = database.QueryDatabase(query); + + if (!results.Success()) { + LogError("Error inserting into raid members: [{}]", results.ErrorMessage().c_str()); + } + + LearnMembers(); + VerifyRaid(); + if (rleader) { + database.SetRaidGroupLeaderInfo(RAID_GROUPLESS, GetID()); + UpdateRaidAAs(); + } + if (group != RAID_GROUPLESS && groupleader) { + database.SetRaidGroupLeaderInfo(group, GetID()); + UpdateGroupAAs(group); + } + if (group < 12) + GroupUpdate(group); + else // get raid AAs, GroupUpdate will handles it otherwise + //SendGroupLeadershipAA(c, RAID_GROUPLESS); Is this needed for bots? + SendRaidAddAll(b->GetOwner()->GetName()); + + b->SetRaidGrouped(true); + SendRaidMOTD(b->GetOwner()->CastToClient()); + + // Mitch What to do here? + // xtarget shit .......... + //if (group == RAID_GROUPLESS) { + // if (rleader) { + // GetXTargetAutoMgr()->merge(*c->GetXTargetAutoMgr()); + // c->GetXTargetAutoMgr()->clear(); + // c->SetXTargetAutoMgr(GetXTargetAutoMgr()); + // } + // else { + // if (!c->GetXTargetAutoMgr()->empty()) { + // GetXTargetAutoMgr()->merge(*c->GetXTargetAutoMgr()); + // c->GetXTargetAutoMgr()->clear(); + // c->RemoveAutoXTargets(); + // } + + // c->SetXTargetAutoMgr(GetXTargetAutoMgr()); + + // if (!c->GetXTargetAutoMgr()->empty()) + // c->SetDirtyAutoHaters(); + // } + //} + + Raid* raid_update = nullptr; + raid_update = b->GetOwner()->GetRaid(); + if (raid_update) { + raid_update->SendHPManaEndPacketsTo(b->GetOwner()->CastToClient()); + raid_update->SendHPManaEndPacketsFrom(b->GetOwner()->CastToClient()); + } + + auto pack = new ServerPacket(ServerOP_RaidAdd, sizeof(ServerRaidGeneralAction_Struct)); + ServerRaidGeneralAction_Struct* rga = (ServerRaidGeneralAction_Struct*)pack->pBuffer; + rga->rid = GetID(); + strn0cpy(rga->playername, b->GetOwner()->GetName(), 64); + rga->zoneid = zone->GetZoneID(); + rga->instance_id = zone->GetInstanceID(); + worldserver.SendPacket(pack); + safe_delete(pack); +} + void Raid::RemoveMember(const char *characterName) { diff --git a/zone/raids.h b/zone/raids.h index a04d1eb54..1662bb6ad 100644 --- a/zone/raids.h +++ b/zone/raids.h @@ -112,6 +112,7 @@ public: bool IsRaid() { return true; } void AddMember(Client *c, uint32 group = 0xFFFFFFFF, bool rleader=false, bool groupleader=false, bool looter=false); + void AddBot(Bot* b, uint32 group = 0xFFFFFFFF, bool rleader=false, bool groupleader=false, bool looter=false); void RemoveMember(const char *c); void DisbandRaid(); void MoveMember(const char *name, uint32 newGroup);