pa/eqemu-server
2
0
Fork 0
mirror of https://github.com/EQEmu/Server.git synced 2026-06-24 05:18:40 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Use Case 1, 2, 3,4,7 working.

Browse Source 
Need to fix 5, 6, 8
This commit is contained in:
neckkola
2022-01-08 00:03:05 -04:00
parent b8b5ca0e67
commit 947fb239a9
2 changed files with 240 additions and 256 deletions
Download Patch File Download Diff File Expand all files Collapse all files
zone/bot.cpp
+232 -248
View File
@@ -10097,297 +10097,281 @@ uint8 Bot::spell_casting_chances[SPELL_TYPE_COUNT][PLAYER_CLASS_COUNT][EQ::const
void Bot::ProcessRaidInvite(Bot* player_accepting_invite, Client* b_owner) { void Bot::ProcessRaidInvite(Bot* player_accepting_invite, Client* b_owner) {
//Client* player_accepting_invite = entity_list.GetClientByName(raid_command_packet->player_name); //Client* player_accepting_invite = entity_list.GetClientByName(raid_command_packet->player_name);
if (player_accepting_invite) { if (player_accepting_invite) {
if (player_accepting_invite->IsRaidGrouped()) { 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... 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.GetRaidByClient(b_owner);
if (raid) { // Does a raid already exist?
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, bot group invite would create a raid larger than the maximum number of members allowed.");
return; return;
} }
Raid* raid = entity_list.GetRaidByClient(b_owner); }
if (raid) { // Does a raid already exist? else {
raid->VerifyRaid(); if (1 + raid->RaidCount() > MAX_RAID_MEMBERS) {
Group* group = player_accepting_invite->GetGroup(); b_owner->Message(Chat::Red, "Invite failed, bot invite would create a raid larger than the maximum number of members allowed.");
if (group) { return;
if (group->GroupCount() + raid->RaidCount() > MAX_RAID_MEMBERS) { }
b_owner->Message(Chat::Red, "Invite failed, bot group invite would create a raid larger than the maximum number of members allowed."); }
return; //Usecase #3 - Raid already created, Bot is BotGroupLeader.
if (group) {//add us all // Is the player already in a group? If yes, add all players from the group
uint32 free_group_id = raid->GetFreeGroup();
Client* addClient = nullptr;
Bot* addBot = nullptr;
for (int x = 0; x < 6; x++) {
if (group->members[x]) {
Client* c = nullptr;
Bot* b = nullptr;
if (group->members[x]->IsBot()) {
b = group->members[x]->CastToBot();
if (x == 0) {
raid->AddBot(b, free_group_id, false, true, false);
raid->SetGroupLeader(b->GetName());
}
else {
raid->AddBot(b, free_group_id, false, false, false);
}
raid->SendBulkRaid(b->CastToClient());
} }
} else if (group->members[x]->IsClient()) {
else { c = group->members[x]->CastToClient();
if (1 + raid->RaidCount() > MAX_RAID_MEMBERS) { if (x == 0) {
b_owner->Message(Chat::Red, "Invite failed, bot invite would create a raid larger than the maximum number of members allowed."); raid->SendRaidCreate(c);
return; raid->SendMakeLeaderPacketTo(raid->leadername, c);
raid->AddMember(c, free_group_id, false, true, false);
raid->SetGroupLeader(c->GetName());
}
else {
raid->SendRaidCreate(c);
raid->SendMakeLeaderPacketTo(raid->leadername, c);
raid->AddMember(c, free_group_id, false, false, false);
}
raid->SendBulkRaid(c);
if (raid->IsLocked())
raid->SendRaidLockTo(c);
} }
}
//Usecase #3 - Raid already created, Bot is BotGroupLeader.
if (group) {//add us all // Is the player already in a group? If yes, add all players from the group
uint32 free_group_id = raid->GetFreeGroup();
Client* addClient = nullptr;
Bot* addBot = nullptr;
for (int x = 0; x < 6; x++) { //if (!addClient)
if (group->members[x]) { //{
Client* c = nullptr; // addClient = c;
Bot* b = nullptr; // raid->SetGroupLeader(addClient->GetName());
if (group->members[x]->IsBot()) { //}
b = group->members[x]->CastToBot();
if (x == 0) {
raid->AddBot(b, free_group_id, false, true, false);
raid->SetGroupLeader(b->GetName());
}
else {
raid->AddBot(b, free_group_id, false, false, false);
}
raid->SendBulkRaid(b->CastToClient());
}
else if (group->members[x]->IsClient()) {
c = group->members[x]->CastToClient();
if (x == 0) {
raid->SendRaidCreate(c);
raid->SendMakeLeaderPacketTo(raid->leadername, c);
raid->AddMember(c, free_group_id, false, true, false);
raid->SetGroupLeader(c->GetName());
}
else {
raid->SendRaidCreate(c);
raid->SendMakeLeaderPacketTo(raid->leadername, c);
raid->AddMember(c, free_group_id, false, false, false);
}
raid->SendBulkRaid(c);
if (raid->IsLocked())
raid->SendRaidLockTo(c);
}
//if (!addClient) //raid->SendRaidCreate(b_owner);
//{ //raid->SendMakeLeaderPacketTo(raid->leadername, b_owner);
// addClient = c; //if (group->IsLeader(group->members[x]))
// 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); // raid->AddMember(c, free_group_id, false, true);
// else // else
// raid->AddMember(c, free_group_id); // raid->AddMember(c, free_group_id);
//raid->SendRaidGroupAdd(b_owner->GetName(), free_group_id); //raid->SendRaidGroupAdd(b_owner->GetName(), free_group_id);
}
}
group->JoinRaidXTarget(raid);
group->DisbandGroup(true);
raid->GroupUpdate(free_group_id);
}
else { // Jan 6 this also now works. // If not in a group, invite the individual player
//raid->SendRaidCreate(b_owner);
//raid->SendMakeLeaderPacketTo(raid->leadername, b_owner);
raid->AddBot(player_accepting_invite);
// Set indicator that bot owner has already received this update. Mitch
//raid->SendBulkRaid(b_owner);
if (raid->IsLocked()) {
raid->SendRaidLockTo(b_owner);
}
} }
} }
else group->JoinRaidXTarget(raid);
{ // A raid does not already exist. One needs to be created before going forward group->DisbandGroup(true);
Group* player_invited_group = player_accepting_invite->GetGroup(); raid->GroupUpdate(free_group_id);
Group* group = entity_list.GetGroupByClient(b_owner); // player_accepting_invite->GetGroup(); }
if (group) //if our target has a group else { // Jan 6 this also now works. // If not in a group, invite the individual player
{ //raid->SendRaidCreate(b_owner);
// raid = new Raid(player_accepting_invite); //raid->SendMakeLeaderPacketTo(raid->leadername, b_owner);
raid = new Raid(b_owner); raid->AddBot(player_accepting_invite);
entity_list.AddRaid(raid); // Set indicator that bot owner has already received this update. Mitch
raid->SetRaidDetails();
uint32 raid_free_group_id = raid->GetFreeGroup(); //raid->SendBulkRaid(b_owner);
if (raid->IsLocked()) {
raid->SendRaidLockTo(b_owner);
}
}
}
//No raid exists.
else
{ // A raid does not already exist. One needs to be created before going forward
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();
/* If we already have a group then cycle through adding us... */ uint32 raid_free_group_id = raid->GetFreeGroup();
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()) /* If we already have a group then cycle through adding us... */
c = player_invited_group->members[x]->CastToClient(); if (player_invited_group) {
else Client* client_to_be_leader = nullptr;
continue; for (int x = 0; x < 6; x++) {
if (player_invited_group->members[x]) {
raid->SendRaidCreate(b_owner); if (!client_to_be_leader) {
raid->SendMakeLeaderPacketTo(raid->leadername, b_owner); if (player_invited_group->members[x]->IsClient()) {
raid->AddMember(c, raid_free_group_id, true, true, true); client_to_be_leader = player_invited_group->members[x]->CastToClient();
raid->SendBulkRaid(c); raid->SetGroupLeader(client_to_be_leader->GetName());
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); if (player_invited_group->IsLeader(player_invited_group->members[x])) {
player_invited_group->DisbandGroup(true); Client* c = nullptr;
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; if (player_invited_group->members[x]->IsClient() || player_invited_group->members[x]->IsBot())
/* Add client to an existing group */ c = player_invited_group->members[x]->CastToClient();
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 else
{ continue;
Client* c = nullptr;
if (group->members[x]->IsClient() || group->members[x]->IsBot()) raid->SendRaidCreate(b_owner);
c = group->members[x]->CastToClient(); raid->SendMakeLeaderPacketTo(raid->leadername, b_owner);
else raid->AddMember(c, raid_free_group_id, true, true, true);
continue; raid->SendBulkRaid(c);
raid->SendRaidCreate(b_owner); if (raid->IsLocked()) {
raid->SendMakeLeaderPacketTo(raid->leadername, b_owner); raid->SendRaidLockTo(b_owner);
raid->AddMember(c, raid_free_group_id); }
raid->SendBulkRaid(b_owner); }
else {
Client* c = nullptr;
if (raid->IsLocked()) { if (player_invited_group->members[x]->IsClient() || player_invited_group->members[x]->IsBot())
raid->SendRaidLockTo(b_owner); 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);
} }
} }
} }
group->JoinRaidXTarget(raid);
group->DisbandGroup(true);
raid->GroupUpdate(raid_free_group_id);
} }
/* Target does not have a group */ player_invited_group->JoinRaidXTarget(raid, true);
else { player_invited_group->DisbandGroup(true);
if (player_invited_group) { 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);
}
raid = new Raid(b_owner); Client* client_to_add = nullptr;
/* Add client to an existing group */
entity_list.AddRaid(raid); for (int x = 0; x < 6; x++) {
raid->SetRaidDetails(); if (group->members[x]) {
Client* addClientig = nullptr; if (!client_to_add) {
for (int x = 0; x < 6; x++) { if (group->members[x]->IsClient() || group->members[x]->IsBot()) {
if (player_invited_group->members[x]) { client_to_add = group->members[x]->CastToClient();
if (!addClientig) { raid->SetGroupLeader(client_to_add->GetName());
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);
}
}
}
} }
}
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->SendRaidCreate(b_owner);
raid->SendMakeLeaderPacketTo(raid->leadername, b_owner); raid->SendMakeLeaderPacketTo(raid->leadername, b_owner);
raid->AddMember(c, raid_free_group_id, false, true);
raid->SendBulkRaid(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()) { if (raid->IsLocked()) {
raid->SendRaidLockTo(b_owner); raid->SendRaidLockTo(b_owner);
} }
} }
//Usecase #2 - Neither the invitor and Bot has a group. else
else { // neither has a group - Jan 6 this appears to work now. One ungrouped player, one/many ungrouped bots {
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 */
//No raid and bot owner does not have group. Now check for bot having a group
else {
if (player_invited_group) {
// No raid, No bot owner group, bot has group
raid = new Raid(b_owner);
entity_list.AddRaid(raid);
raid->SetRaidDetails();
raid->SendRaidCreate(b_owner);
raid->SendMakeLeaderPacketTo(raid->leadername, b_owner);
raid->AddMember(b_owner, 0xFFFFFFFF, true, false, true);
for (int x = 0; x < 6; x++) {
if (player_invited_group->members[x]) {
Client* c = nullptr;
Bot* b = nullptr;
if (player_invited_group->members[x]->IsBot()) {
b = player_invited_group->members[x]->CastToBot();
if (x == 0) {
raid->AddBot(b, 0, false, true, false);
raid->SetGroupLeader(b->GetName());
}
else {
raid->AddBot(b, 0, false, false, false);
}
}
else if (group->members[x]->IsClient()) {
c = group->members[x]->CastToClient();
if (x == 0) {
raid->SendRaidCreate(c);
raid->SendMakeLeaderPacketTo(raid->leadername, c);
raid->AddMember(c, 0, false, true, false);
raid->SetGroupLeader(c->GetName());
}
else {
raid->SendRaidCreate(c);
raid->SendMakeLeaderPacketTo(raid->leadername, c);
raid->AddMember(c, 0, false, false, false);
}
}
}
}
player_invited_group->JoinRaidXTarget(raid, true);
player_invited_group->DisbandGroup(true);
raid->GroupUpdate(0);
if (raid->IsLocked()) {
raid->SendRaidLockTo(b_owner);
}
}
//Usecase #2 - No raid, no bot owner group, no bot group. Working
else {
raid = new Raid(b_owner); raid = new Raid(b_owner);
entity_list.AddRaid(raid); entity_list.AddRaid(raid);
raid->SetRaidDetails(); raid->SetRaidDetails();
// raid->SendRaidCreate(b_owner); // Not needed as one raid member is a bot
raid->SendRaidCreate(b_owner); raid->SendRaidCreate(b_owner);
raid->SendMakeLeaderPacketTo(raid->leadername, b_owner); raid->SendMakeLeaderPacketTo(raid->leadername, b_owner);
raid->AddMember(b_owner, 0xFFFFFFFF, true, false, true); raid->AddMember(b_owner, 0xFFFFFFFF, true, false, true);
raid->AddBot(player_accepting_invite); raid->AddBot(player_accepting_invite);
// raid->SendBulkRaid(b_owner); //Removed to correct usecase #2
if (raid->IsLocked()) { if (raid->IsLocked()) {
raid->SendRaidLockTo(b_owner); raid->SendRaidLockTo(b_owner);
} }
zone/raids.cpp
+5 -5
View File
@@ -190,11 +190,11 @@ void Raid::AddBot(Bot* b, uint32 group, bool rleader, bool groupleader, bool loo
database.SetRaidGroupLeaderInfo(group, GetID()); database.SetRaidGroupLeaderInfo(group, GetID());
//UpdateGroupAAs(group); //UpdateGroupAAs(group);
} }
if (group < 12) // if (group < 12)
GroupUpdate(group); // GroupUpdate(group);
else // get raid AAs, GroupUpdate will handles it otherwise // else // get raid AAs, GroupUpdate will handles it otherwise
//SendGroupLeadershipAA(c, RAID_GROUPLESS); Is this needed for bots? //SendGroupLeadershipAA(c, RAID_GROUPLESS); Is this needed for bots?
SendRaidAddAll(b->GetName()); SendRaidAddAll(b->GetName());
members[GetPlayerIndex(b->GetName())].SentToBotOwner = true; //Mitch indicates that the BotOwner has received this raid info already. members[GetPlayerIndex(b->GetName())].SentToBotOwner = true; //Mitch indicates that the BotOwner has received this raid info already.
b->SetRaidGrouped(true); b->SetRaidGrouped(true);
@@ -1076,7 +1076,7 @@ void Raid::SendRaidAdd(const char *who, Client *to)
for(int x = 0; x < MAX_RAID_MEMBERS; x++) for(int x = 0; x < MAX_RAID_MEMBERS; x++)
{ {
if(strcmp(members[x].membername, who) == 0 || !members[x].SentToBotOwner) //Mitch if(strcmp(members[x].membername, who) == 0)// || !members[x].SentToBotOwner) //Mitch
{ {
auto outapp = new EQApplicationPacket(OP_RaidUpdate, sizeof(RaidAddMember_Struct)); auto outapp = new EQApplicationPacket(OP_RaidUpdate, sizeof(RaidAddMember_Struct));
RaidAddMember_Struct *ram = (RaidAddMember_Struct*)outapp->pBuffer; RaidAddMember_Struct *ram = (RaidAddMember_Struct*)outapp->pBuffer;