pa/eqemu-server
2
0
Fork 0
mirror of https://github.com/EQEmu/Server.git synced 2025-12-12 09:31:30 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

[Readability] Clean up some of the raid command code to be more understandable

Browse Source
This commit is contained in:
Akkadius 2017-08-21 21:44:28 -05:00
parent ad7dfc31a9
commit 7a263c032d
1 changed files with 350 additions and 341 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

693
zone/client_packet.cpp
View File

@ -10948,289 +10948,307 @@ void Client::Handle_OP_RaidCommand(const EQApplicationPacket *app)
return; return;
} }
RaidGeneral_Struct *ri = (RaidGeneral_Struct*)app->pBuffer; RaidGeneral_Struct *raid_command_packet = (RaidGeneral_Struct*)app->pBuffer;
switch (ri->action) switch (raid_command_packet->action)
{ {
case RaidCommandInviteIntoExisting: case RaidCommandInviteIntoExisting:
case RaidCommandInvite: { case RaidCommandInvite: {
Client *i = entity_list.GetClientByName(ri->player_name);
if (!i) Client *player_to_invite = entity_list.GetClientByName(raid_command_packet->player_name);
if (!player_to_invite)
break; break;
Group *g = i->GetGroup();
// These two messages should be generated by the client I think, just do this for now Group *player_to_invite_group = player_to_invite->GetGroup();
if (i->HasRaid()) {
Message(13, "%s is already in a raid.", i->GetName()); if (player_to_invite->HasRaid()) {
Message(13, "%s is already in a raid.", player_to_invite->GetName());
break; break;
} }
if (g && !g->IsLeader(i)) {
if (player_to_invite_group && !player_to_invite_group->IsLeader(player_to_invite)) {
Message(13, "You can only invite an ungrouped player or group leader to join your raid."); Message(13, "You can only invite an ungrouped player or group leader to join your raid.");
break; break;
} }
//This sends an "invite" to the client in question.
auto outapp = new EQApplicationPacket(OP_RaidUpdate, sizeof(RaidGeneral_Struct));
RaidGeneral_Struct *rg = (RaidGeneral_Struct*)outapp->pBuffer;
strn0cpy(rg->leader_name, ri->leader_name, 64);
strn0cpy(rg->player_name, ri->player_name, 64);
rg->parameter = 0; /* Send out invite to the client */
rg->action = 20; auto outapp = new EQApplicationPacket(OP_RaidUpdate, sizeof(RaidGeneral_Struct));
i->QueuePacket(outapp); 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);
raid_command->parameter = 0;
raid_command->action = 20;
player_to_invite->QueuePacket(outapp);
safe_delete(outapp); safe_delete(outapp);
break; break;
} }
case RaidCommandAcceptInvite: { case RaidCommandAcceptInvite: {
Client *i = entity_list.GetClientByName(ri->player_name); Client *player_accepting_invite = entity_list.GetClientByName(raid_command_packet->player_name);
if (i) { if (player_accepting_invite) {
if (IsRaidGrouped()) { if (IsRaidGrouped()) {
i->Message_StringID(0, ALREADY_IN_RAID, GetName()); //group failed, must invite members not in raid... player_accepting_invite->Message_StringID(0, ALREADY_IN_RAID, GetName()); //group failed, must invite members not in raid...
return; return;
} }
Raid *r = entity_list.GetRaidByClient(i); Raid *raid = entity_list.GetRaidByClient(player_accepting_invite);
if (r) { if (raid) {
r->VerifyRaid(); raid->VerifyRaid();
Group *g = GetGroup(); Group *group = GetGroup();
if (g) { if (group) {
if (g->GroupCount() + r->RaidCount() > MAX_RAID_MEMBERS) if (group->GroupCount() + raid->RaidCount() > MAX_RAID_MEMBERS) {
{ player_accepting_invite->Message(13, "Invite failed, group invite would create a raid larger than the maximum number of members allowed.");
i->Message(13, "Invite failed, group invite would create a raid larger than the maximum number of members allowed.");
return; return;
} }
} }
else { else {
if (1 + r->RaidCount() > MAX_RAID_MEMBERS) if (1 + raid->RaidCount() > MAX_RAID_MEMBERS) {
{ player_accepting_invite->Message(13, "Invite failed, member invite would create a raid larger than the maximum number of members allowed.");
i->Message(13, "Invite failed, member invite would create a raid larger than the maximum number of members allowed.");
return; return;
} }
} }
if (g) {//add us all if (group) {//add us all
uint32 freeGroup = r->GetFreeGroup(); uint32 free_group_id = raid->GetFreeGroup();
Client *addClient = nullptr; Client *addClient = nullptr;
for (int x = 0; x < 6; x++) for (int x = 0; x < 6; x++) {
{ if (group->members[x]) {
if (g->members[x]) {
Client *c = nullptr; Client *c = nullptr;
if (g->members[x]->IsClient()) if (group->members[x]->IsClient())
c = g->members[x]->CastToClient(); c = group->members[x]->CastToClient();
else else
continue; continue;
if (!addClient) if (!addClient)
{ {
addClient = c; addClient = c;
r->SetGroupLeader(addClient->GetName()); raid->SetGroupLeader(addClient->GetName());
} }
r->SendRaidCreate(c); raid->SendRaidCreate(c);
r->SendMakeLeaderPacketTo(r->leadername, c); raid->SendMakeLeaderPacketTo(raid->leadername, c);
if (g->IsLeader(g->members[x])) if (group->IsLeader(group->members[x]))
r->AddMember(c, freeGroup, false, true); raid->AddMember(c, free_group_id, false, true);
else else
r->AddMember(c, freeGroup); raid->AddMember(c, free_group_id);
r->SendBulkRaid(c); raid->SendBulkRaid(c);
if (r->IsLocked()) { if (raid->IsLocked()) {
r->SendRaidLockTo(c); raid->SendRaidLockTo(c);
} }
} }
} }
g->JoinRaidXTarget(r); group->JoinRaidXTarget(raid);
g->DisbandGroup(true); group->DisbandGroup(true);
r->GroupUpdate(freeGroup); raid->GroupUpdate(free_group_id);
} }
else { else {
r->SendRaidCreate(this); raid->SendRaidCreate(this);
r->SendMakeLeaderPacketTo(r->leadername, this); raid->SendMakeLeaderPacketTo(raid->leadername, this);
r->AddMember(this); raid->AddMember(this);
r->SendBulkRaid(this); raid->SendBulkRaid(this);
if (r->IsLocked()) { if (raid->IsLocked()) {
r->SendRaidLockTo(this); raid->SendRaidLockTo(this);
} }
} }
} }
else else
{ {
Group *ig = i->GetGroup(); Group *player_invited_group = player_accepting_invite->GetGroup();
Group *g = GetGroup(); Group *group = GetGroup();
if (g) //if our target has a group if (group) //if our target has a group
{ {
r = new Raid(i); raid = new Raid(player_accepting_invite);
entity_list.AddRaid(r); entity_list.AddRaid(raid);
r->SetRaidDetails(); raid->SetRaidDetails();
uint32 groupFree = r->GetFreeGroup(); //get a free group uint32 raid_free_group_id = raid->GetFreeGroup();
if (ig) { //if we already have a group then cycle through adding us...
Client *addClientig = nullptr; /* If we already have a group then cycle through adding us... */
for (int x = 0; x < 6; x++) if (player_invited_group) {
{ Client *client_to_be_leader = nullptr;
if (ig->members[x]) { for (int x = 0; x < 6; x++) {
if (!addClientig) { if (player_invited_group->members[x]) {
if (ig->members[x]->IsClient()) { if (!client_to_be_leader) {
addClientig = ig->members[x]->CastToClient(); if (player_invited_group->members[x]->IsClient()) {
r->SetGroupLeader(addClientig->GetName()); client_to_be_leader = player_invited_group->members[x]->CastToClient();
raid->SetGroupLeader(client_to_be_leader->GetName());
} }
} }
if (ig->IsLeader(ig->members[x])) { if (player_invited_group->IsLeader(player_invited_group->members[x])) {
Client *c = nullptr; Client *c = nullptr;
if (ig->members[x]->IsClient())
c = ig->members[x]->CastToClient(); if (player_invited_group->members[x]->IsClient())
c = player_invited_group->members[x]->CastToClient();
else else
continue; continue;
r->SendRaidCreate(c);
r->SendMakeLeaderPacketTo(r->leadername, c); raid->SendRaidCreate(c);
r->AddMember(c, groupFree, true, true, true); raid->SendMakeLeaderPacketTo(raid->leadername, c);
r->SendBulkRaid(c); raid->AddMember(c, raid_free_group_id, true, true, true);
if (r->IsLocked()) { raid->SendBulkRaid(c);
r->SendRaidLockTo(c);
if (raid->IsLocked()) {
raid->SendRaidLockTo(c);
} }
} }
else { else {
Client *c = nullptr; Client *c = nullptr;
if (ig->members[x]->IsClient())
c = ig->members[x]->CastToClient(); if (player_invited_group->members[x]->IsClient())
c = player_invited_group->members[x]->CastToClient();
else else
continue; continue;
r->SendRaidCreate(c);
r->SendMakeLeaderPacketTo(r->leadername, c); raid->SendRaidCreate(c);
r->AddMember(c, groupFree); raid->SendMakeLeaderPacketTo(raid->leadername, c);
r->SendBulkRaid(c); raid->AddMember(c, raid_free_group_id);
if (r->IsLocked()) { raid->SendBulkRaid(c);
r->SendRaidLockTo(c);
if (raid->IsLocked()) {
raid->SendRaidLockTo(c);
} }
} }
} }
} }
ig->JoinRaidXTarget(r, true); player_invited_group->JoinRaidXTarget(raid, true);
ig->DisbandGroup(true); player_invited_group->DisbandGroup(true);
r->GroupUpdate(groupFree); raid->GroupUpdate(raid_free_group_id);
groupFree = r->GetFreeGroup(); raid_free_group_id = raid->GetFreeGroup();
} }
else { //else just add the inviter else {
r->SendRaidCreate(i); raid->SendRaidCreate(player_accepting_invite);
r->AddMember(i, 0xFFFFFFFF, true, false, true); raid->AddMember(player_accepting_invite, 0xFFFFFFFF, true, false, true);
} }
Client *addClient = nullptr; Client *client_to_add = nullptr;
//now add the existing group /* Add client to an existing group */
for (int x = 0; x < 6; x++) for (int x = 0; x < 6; x++) {
{ if (group->members[x]) {
if (g->members[x]) { if (!client_to_add) {
if (!addClient) if (group->members[x]->IsClient()) {
{ client_to_add = group->members[x]->CastToClient();
if (g->members[x]->IsClient()) { raid->SetGroupLeader(client_to_add->GetName());
addClient = g->members[x]->CastToClient();
r->SetGroupLeader(addClient->GetName());
} }
} }
if (g->IsLeader(g->members[x])) if (group->IsLeader(group->members[x])) {
{
Client *c = nullptr; Client *c = nullptr;
if (g->members[x]->IsClient())
c = g->members[x]->CastToClient(); if (group->members[x]->IsClient())
c = group->members[x]->CastToClient();
else else
continue; continue;
r->SendRaidCreate(c);
r->SendMakeLeaderPacketTo(r->leadername, c); raid->SendRaidCreate(c);
r->AddMember(c, groupFree, false, true); raid->SendMakeLeaderPacketTo(raid->leadername, c);
r->SendBulkRaid(c); raid->AddMember(c, raid_free_group_id, false, true);
if (r->IsLocked()) { raid->SendBulkRaid(c);
r->SendRaidLockTo(c);
if (raid->IsLocked()) {
raid->SendRaidLockTo(c);
} }
} }
else else
{ {
Client *c = nullptr; Client *c = nullptr;
if (g->members[x]->IsClient())
c = g->members[x]->CastToClient(); if (group->members[x]->IsClient())
c = group->members[x]->CastToClient();
else else
continue; continue;
r->SendRaidCreate(c);
r->SendMakeLeaderPacketTo(r->leadername, c); raid->SendRaidCreate(c);
r->AddMember(c, groupFree); raid->SendMakeLeaderPacketTo(raid->leadername, c);
r->SendBulkRaid(c); raid->AddMember(c, raid_free_group_id);
if (r->IsLocked()) { raid->SendBulkRaid(c);
r->SendRaidLockTo(c);
if (raid->IsLocked()) {
raid->SendRaidLockTo(c);
} }
} }
} }
} }
g->JoinRaidXTarget(r); group->JoinRaidXTarget(raid);
g->DisbandGroup(true); group->DisbandGroup(true);
r->GroupUpdate(groupFree);
raid->GroupUpdate(raid_free_group_id);
} }
else // target does not have a group /* Target does not have a group */
{ else {
if (ig) { if (player_invited_group) {
r = new Raid(i);
entity_list.AddRaid(r); raid = new Raid(player_accepting_invite);
r->SetRaidDetails();
entity_list.AddRaid(raid);
raid->SetRaidDetails();
Client *addClientig = nullptr; Client *addClientig = nullptr;
for (int x = 0; x < 6; x++) for (int x = 0; x < 6; x++) {
{ if (player_invited_group->members[x]) {
if (ig->members[x])
{
if (!addClientig) { if (!addClientig) {
if (ig->members[x]->IsClient()) { if (player_invited_group->members[x]->IsClient()) {
addClientig = ig->members[x]->CastToClient(); addClientig = player_invited_group->members[x]->CastToClient();
r->SetGroupLeader(addClientig->GetName()); raid->SetGroupLeader(addClientig->GetName());
} }
} }
if (ig->IsLeader(ig->members[x])) if (player_invited_group->IsLeader(player_invited_group->members[x])) {
{
Client *c = nullptr; Client *c = nullptr;
if (ig->members[x]->IsClient())
c = ig->members[x]->CastToClient(); if (player_invited_group->members[x]->IsClient())
c = player_invited_group->members[x]->CastToClient();
else else
continue; continue;
r->SendRaidCreate(c); raid->SendRaidCreate(c);
r->SendMakeLeaderPacketTo(r->leadername, c); raid->SendMakeLeaderPacketTo(raid->leadername, c);
r->AddMember(c, 0, true, true, true); raid->AddMember(c, 0, true, true, true);
r->SendBulkRaid(c); raid->SendBulkRaid(c);
if (r->IsLocked()) {
r->SendRaidLockTo(c); if (raid->IsLocked()) {
raid->SendRaidLockTo(c);
} }
} }
else else
{ {
Client *c = nullptr; Client *c = nullptr;
if (ig->members[x]->IsClient()) if (player_invited_group->members[x]->IsClient())
c = ig->members[x]->CastToClient(); c = player_invited_group->members[x]->CastToClient();
else else
continue; continue;
r->SendRaidCreate(c); raid->SendRaidCreate(c);
r->SendMakeLeaderPacketTo(r->leadername, c); raid->SendMakeLeaderPacketTo(raid->leadername, c);
r->AddMember(c, 0); raid->AddMember(c, 0);
r->SendBulkRaid(c); raid->SendBulkRaid(c);
if (r->IsLocked()) { if (raid->IsLocked()) {
r->SendRaidLockTo(c); raid->SendRaidLockTo(c);
} }
} }
} }
} }
r->SendRaidCreate(this); raid->SendRaidCreate(this);
r->SendMakeLeaderPacketTo(r->leadername, this); raid->SendMakeLeaderPacketTo(raid->leadername, this);
r->SendBulkRaid(this); raid->SendBulkRaid(this);
ig->JoinRaidXTarget(r, true); player_invited_group->JoinRaidXTarget(raid, true);
r->AddMember(this); raid->AddMember(this);
ig->DisbandGroup(true); player_invited_group->DisbandGroup(true);
r->GroupUpdate(0); raid->GroupUpdate(0);
if (r->IsLocked()) { if (raid->IsLocked()) {
r->SendRaidLockTo(this); raid->SendRaidLockTo(this);
} }
} }
else { // neither has a group else { // neither has a group
r = new Raid(i); raid = new Raid(player_accepting_invite);
entity_list.AddRaid(r); entity_list.AddRaid(raid);
r->SetRaidDetails(); raid->SetRaidDetails();
r->SendRaidCreate(i); raid->SendRaidCreate(player_accepting_invite);
r->SendRaidCreate(this); raid->SendRaidCreate(this);
r->SendMakeLeaderPacketTo(r->leadername, this); raid->SendMakeLeaderPacketTo(raid->leadername, this);
r->AddMember(i, 0xFFFFFFFF, true, false, true); raid->AddMember(player_accepting_invite, 0xFFFFFFFF, true, false, true);
r->SendBulkRaid(this); raid->SendBulkRaid(this);
r->AddMember(this); raid->AddMember(this);
if (r->IsLocked()) { if (raid->IsLocked()) {
r->SendRaidLockTo(this); raid->SendRaidLockTo(this);
} }
} }
} }
@ -11239,43 +11257,42 @@ void Client::Handle_OP_RaidCommand(const EQApplicationPacket *app)
break; break;
} }
case RaidCommandDisband: { case RaidCommandDisband: {
Raid *r = entity_list.GetRaidByClient(this); Raid *raid = entity_list.GetRaidByClient(this);
if (r) { if (raid) {
//if(this == r->GetLeader()){ uint32 group = raid->GetGroup(raid_command_packet->leader_name);
uint32 grp = r->GetGroup(ri->leader_name);
if (grp < 12) { if (group < 12) {
uint32 i = r->GetPlayerIndex(ri->leader_name); uint32 i = raid->GetPlayerIndex(raid_command_packet->leader_name);
if (r->members[i].IsGroupLeader) { //assign group leader to someone else if (raid->members[i].IsGroupLeader) { //assign group leader to someone else
for (int x = 0; x < MAX_RAID_MEMBERS; x++) { for (int x = 0; x < MAX_RAID_MEMBERS; x++) {
if (strlen(r->members[x].membername) > 0 && i != x) { if (strlen(raid->members[x].membername) > 0 && i != x) {
if (r->members[x].GroupNumber == grp) { if (raid->members[x].GroupNumber == group) {
r->SetGroupLeader(ri->leader_name, false); raid->SetGroupLeader(raid_command_packet->leader_name, false);
r->SetGroupLeader(r->members[x].membername); raid->SetGroupLeader(raid->members[x].membername);
r->UpdateGroupAAs(grp); raid->UpdateGroupAAs(group);
break; break;
} }
} }
} }
} }
if (r->members[i].IsRaidLeader) { if (raid->members[i].IsRaidLeader) {
for (int x = 0; x < MAX_RAID_MEMBERS; x++) { for (int x = 0; x < MAX_RAID_MEMBERS; x++) {
if (strlen(r->members[x].membername) > 0 && strcmp(r->members[x].membername, r->members[i].membername) != 0) if (strlen(raid->members[x].membername) > 0 && strcmp(raid->members[x].membername, raid->members[i].membername) != 0)
{ {
r->SetRaidLeader(r->members[i].membername, r->members[x].membername); raid->SetRaidLeader(raid->members[i].membername, raid->members[x].membername);
r->UpdateRaidAAs(); raid->UpdateRaidAAs();
r->SendAllRaidLeadershipAA(); raid->SendAllRaidLeadershipAA();
break; break;
} }
} }
} }
} }
r->RemoveMember(ri->leader_name); raid->RemoveMember(raid_command_packet->leader_name);
Client *c = entity_list.GetClientByName(ri->leader_name); Client *c = entity_list.GetClientByName(raid_command_packet->leader_name);
if (c) if (c)
r->SendGroupDisband(c); raid->SendGroupDisband(c);
else { else {
auto pack = auto pack =
new ServerPacket(ServerOP_RaidGroupDisband, sizeof(ServerRaidGeneralAction_Struct)); new ServerPacket(ServerOP_RaidGroupDisband, sizeof(ServerRaidGeneralAction_Struct));
@ -11283,66 +11300,64 @@ void Client::Handle_OP_RaidCommand(const EQApplicationPacket *app)
rga->rid = GetID(); rga->rid = GetID();
rga->zoneid = zone->GetZoneID(); rga->zoneid = zone->GetZoneID();
rga->instance_id = zone->GetInstanceID(); rga->instance_id = zone->GetInstanceID();
strn0cpy(rga->playername, ri->leader_name, 64); strn0cpy(rga->playername, raid_command_packet->leader_name, 64);
worldserver.SendPacket(pack); worldserver.SendPacket(pack);
safe_delete(pack); safe_delete(pack);
} }
//r->SendRaidGroupRemove(ri->leader_name, grp); //r->SendRaidGroupRemove(ri->leader_name, grp);
r->GroupUpdate(grp);// break raid->GroupUpdate(group);// break
//} //}
} }
break; break;
} }
case RaidCommandMoveGroup: case RaidCommandMoveGroup:
{ {
Raid *r = entity_list.GetRaidByClient(this); Raid *raid = entity_list.GetRaidByClient(this);
if (r) if (raid) {
{ /* Moving to group */
if (ri->parameter < 12) //moving to a group if (raid_command_packet->parameter < 12) {
{ uint8 group_count = raid->GroupCount(raid_command_packet->parameter);
uint8 grpcount = r->GroupCount(ri->parameter);
if (grpcount < 6) if (group_count < 6) {
{ Client *c = entity_list.GetClientByName(raid_command_packet->leader_name);
Client *c = entity_list.GetClientByName(ri->leader_name); uint32 old_group = raid->GetGroup(raid_command_packet->leader_name);
uint32 oldgrp = r->GetGroup(ri->leader_name); if (raid_command_packet->parameter == old_group) //don't rejoin grp if we order to join same group.
if (ri->parameter == oldgrp) //don't rejoin grp if we order to join same group.
break; break;
if (r->members[r->GetPlayerIndex(ri->leader_name)].IsGroupLeader) if (raid->members[raid->GetPlayerIndex(raid_command_packet->leader_name)].IsGroupLeader) {
{ raid->SetGroupLeader(raid_command_packet->leader_name, false);
r->SetGroupLeader(ri->leader_name, false);
if (oldgrp < 12) { //we were the leader of our old grp /* We were the leader of our old group */
for (int x = 0; x < MAX_RAID_MEMBERS; x++) //assign a new grp leader if we can if (old_group < 12) {
{ /* Assign new group leader if we can */
if (r->members[x].GroupNumber == oldgrp) for (int x = 0; x < MAX_RAID_MEMBERS; x++) {
{ if (raid->members[x].GroupNumber == old_group) {
if (strcmp(ri->leader_name, r->members[x].membername) != 0 && strlen(ri->leader_name) > 0) if (strcmp(raid_command_packet->leader_name, raid->members[x].membername) != 0 && strlen(raid_command_packet->leader_name) > 0) {
{ raid->SetGroupLeader(raid->members[x].membername);
r->SetGroupLeader(r->members[x].membername); raid->UpdateGroupAAs(old_group);
r->UpdateGroupAAs(oldgrp);
Client *cgl = entity_list.GetClientByName(r->members[x].membername); Client *client_to_update = entity_list.GetClientByName(raid->members[x].membername);
if (cgl) { if (client_to_update) {
r->SendRaidRemove(r->members[x].membername, cgl); raid->SendRaidRemove(raid->members[x].membername, client_to_update);
r->SendRaidCreate(cgl); raid->SendRaidCreate(client_to_update);
r->SendMakeLeaderPacketTo(r->leadername, cgl); raid->SendMakeLeaderPacketTo(raid->leadername, client_to_update);
r->SendRaidAdd(r->members[x].membername, cgl); raid->SendRaidAdd(raid->members[x].membername, client_to_update);
r->SendBulkRaid(cgl); raid->SendBulkRaid(client_to_update);
if (r->IsLocked()) { if (raid->IsLocked()) {
r->SendRaidLockTo(cgl); raid->SendRaidLockTo(client_to_update);
} }
} }
else { else {
auto pack = new ServerPacket( auto pack = new ServerPacket(ServerOP_RaidChangeGroup, sizeof(ServerRaidGeneralAction_Struct));
ServerOP_RaidChangeGroup, ServerRaidGeneralAction_Struct *raid_command_packet = (ServerRaidGeneralAction_Struct*)pack->pBuffer;
sizeof(
ServerRaidGeneralAction_Struct)); raid_command_packet->rid = raid->GetID();
ServerRaidGeneralAction_Struct *rga = (ServerRaidGeneralAction_Struct*)pack->pBuffer; raid_command_packet->zoneid = zone->GetZoneID();
rga->rid = r->GetID(); raid_command_packet->instance_id = zone->GetInstanceID();
strn0cpy(rga->playername, r->members[x].membername, 64); strn0cpy(raid_command_packet->playername, raid->members[x].membername, 64);
rga->zoneid = zone->GetZoneID();
rga->instance_id = zone->GetInstanceID();
worldserver.SendPacket(pack); worldserver.SendPacket(pack);
safe_delete(pack); safe_delete(pack);
} }
break; break;
@ -11351,69 +11366,67 @@ void Client::Handle_OP_RaidCommand(const EQApplicationPacket *app)
} }
} }
} }
if (grpcount == 0) { if (group_count == 0) {
r->SetGroupLeader(ri->leader_name); raid->SetGroupLeader(raid_command_packet->leader_name);
r->UpdateGroupAAs(ri->parameter); raid->UpdateGroupAAs(raid_command_packet->parameter);
} }
r->MoveMember(ri->leader_name, ri->parameter); raid->MoveMember(raid_command_packet->leader_name, raid_command_packet->parameter);
if (c) { if (c) {
r->SendGroupDisband(c); raid->SendGroupDisband(c);
} }
else { else {
auto pack = new ServerPacket(ServerOP_RaidGroupDisband, auto pack = new ServerPacket(ServerOP_RaidGroupDisband, sizeof(ServerRaidGeneralAction_Struct));
sizeof(ServerRaidGeneralAction_Struct)); ServerRaidGeneralAction_Struct* raid_command = (ServerRaidGeneralAction_Struct*)pack->pBuffer;
ServerRaidGeneralAction_Struct* rga = (ServerRaidGeneralAction_Struct*)pack->pBuffer; raid_command->rid = raid->GetID();
rga->rid = r->GetID(); raid_command->zoneid = zone->GetZoneID();
rga->zoneid = zone->GetZoneID(); raid_command->instance_id = zone->GetInstanceID();
rga->instance_id = zone->GetInstanceID(); strn0cpy(raid_command->playername, raid_command_packet->leader_name, 64);
strn0cpy(rga->playername, ri->leader_name, 64);
worldserver.SendPacket(pack); worldserver.SendPacket(pack);
safe_delete(pack); safe_delete(pack);
} }
//r->SendRaidGroupAdd(ri->leader_name, ri->parameter);
//r->SendRaidGroupRemove(ri->leader_name, oldgrp);
//r->SendGroupUpdate(c);
//break
r->GroupUpdate(ri->parameter); //send group update to our new group
if (oldgrp < 12) //if our old was a group send update there too
r->GroupUpdate(oldgrp);
//r->SendMakeGroupLeaderPacketAll(); /* Send group update to our new group */
raid->GroupUpdate(raid_command_packet->parameter);
/* If our old was a group send update there too */
if (old_group < 12)
raid->GroupUpdate(old_group);
} }
} }
else //moving to ungrouped /* Move player to ungrouped bank */
{ else {
Client *c = entity_list.GetClientByName(ri->leader_name); Client *c = entity_list.GetClientByName(raid_command_packet->leader_name);
uint32 oldgrp = r->GetGroup(ri->leader_name); uint32 oldgrp = raid->GetGroup(raid_command_packet->leader_name);
if (r->members[r->GetPlayerIndex(ri->leader_name)].IsGroupLeader) { if (raid->members[raid->GetPlayerIndex(raid_command_packet->leader_name)].IsGroupLeader) {
r->SetGroupLeader(ri->leader_name, false); raid->SetGroupLeader(raid_command_packet->leader_name, false);
for (int x = 0; x < MAX_RAID_MEMBERS; x++) for (int x = 0; x < MAX_RAID_MEMBERS; x++) {
{ if (raid->members[x].GroupNumber == oldgrp && strlen(raid->members[x].membername) > 0 && strcmp(raid->members[x].membername, raid_command_packet->leader_name) != 0){
if (r->members[x].GroupNumber == oldgrp && strlen(r->members[x].membername) > 0 && strcmp(r->members[x].membername, ri->leader_name) != 0)
{ raid->SetGroupLeader(raid->members[x].membername);
r->SetGroupLeader(r->members[x].membername); raid->UpdateGroupAAs(oldgrp);
r->UpdateGroupAAs(oldgrp);
Client *cgl = entity_list.GetClientByName(r->members[x].membername); Client *client_leaving_group = entity_list.GetClientByName(raid->members[x].membername);
if (cgl) { if (client_leaving_group) {
r->SendRaidRemove(r->members[x].membername, cgl); raid->SendRaidRemove(raid->members[x].membername, client_leaving_group);
r->SendRaidCreate(cgl); raid->SendRaidCreate(client_leaving_group);
r->SendMakeLeaderPacketTo(r->leadername, cgl); raid->SendMakeLeaderPacketTo(raid->leadername, client_leaving_group);
r->SendRaidAdd(r->members[x].membername, cgl); raid->SendRaidAdd(raid->members[x].membername, client_leaving_group);
r->SendBulkRaid(cgl); raid->SendBulkRaid(client_leaving_group);
if (r->IsLocked()) { if (raid->IsLocked()) {
r->SendRaidLockTo(cgl); raid->SendRaidLockTo(client_leaving_group);
} }
} }
else { else {
auto pack = new ServerPacket( auto pack = new ServerPacket( ServerOP_RaidChangeGroup, sizeof(ServerRaidGeneralAction_Struct));
ServerOP_RaidChangeGroup, ServerRaidGeneralAction_Struct *raid_command = (ServerRaidGeneralAction_Struct*)pack->pBuffer;
sizeof(ServerRaidGeneralAction_Struct));
ServerRaidGeneralAction_Struct *rga = (ServerRaidGeneralAction_Struct*)pack->pBuffer; raid_command->rid = raid->GetID();
rga->rid = r->GetID(); strn0cpy(raid_command->playername, raid->members[x].membername, 64);
strn0cpy(rga->playername, r->members[x].membername, 64); raid_command->zoneid = zone->GetZoneID();
rga->zoneid = zone->GetZoneID(); raid_command->instance_id = zone->GetInstanceID();
rga->instance_id = zone->GetInstanceID();
worldserver.SendPacket(pack); worldserver.SendPacket(pack);
safe_delete(pack); safe_delete(pack);
} }
@ -11421,28 +11434,29 @@ void Client::Handle_OP_RaidCommand(const EQApplicationPacket *app)
} }
} }
} }
r->MoveMember(ri->leader_name, 0xFFFFFFFF); raid->MoveMember(raid_command_packet->leader_name, 0xFFFFFFFF);
if (c) { if (c) {
r->SendGroupDisband(c); raid->SendGroupDisband(c);
} }
else { else {
auto pack = new ServerPacket(ServerOP_RaidGroupDisband, auto pack = new ServerPacket(ServerOP_RaidGroupDisband, sizeof(ServerRaidGeneralAction_Struct));
sizeof(ServerRaidGeneralAction_Struct)); ServerRaidGeneralAction_Struct* raid_command = (ServerRaidGeneralAction_Struct*)pack->pBuffer;
ServerRaidGeneralAction_Struct* rga = (ServerRaidGeneralAction_Struct*)pack->pBuffer;
rga->rid = r->GetID(); raid_command->rid = raid->GetID();
rga->zoneid = zone->GetZoneID(); raid_command->zoneid = zone->GetZoneID();
rga->instance_id = zone->GetInstanceID(); raid_command->instance_id = zone->GetInstanceID();
strn0cpy(rga->playername, ri->leader_name, 64); strn0cpy(raid_command->playername, raid_command_packet->leader_name, 64);
worldserver.SendPacket(pack); worldserver.SendPacket(pack);
safe_delete(pack); safe_delete(pack);
} }
//r->SendRaidGroupRemove(ri->leader_name, oldgrp);
r->GroupUpdate(oldgrp); raid->GroupUpdate(oldgrp);
//r->SendMakeGroupLeaderPacketAll();
} }
} }
Client *client_moved = entity_list.GetClientByName(ri->leader_name); Client *client_moved = entity_list.GetClientByName(raid_command_packet->leader_name);
if (client_moved) { if (client_moved) {
client_moved->GetRaid()->SendHPManaEndPacketsTo(client_moved); client_moved->GetRaid()->SendHPManaEndPacketsTo(client_moved);
@ -11458,36 +11472,34 @@ void Client::Handle_OP_RaidCommand(const EQApplicationPacket *app)
} }
case RaidCommandRaidLock: case RaidCommandRaidLock:
{ {
Raid *r = entity_list.GetRaidByClient(this); Raid *raid = entity_list.GetRaidByClient(this);
if (r) if (raid) {
{ if (!raid->IsLocked())
if (!r->IsLocked()) raid->LockRaid(true);
r->LockRaid(true);
else else
r->SendRaidLockTo(this); raid->SendRaidLockTo(this);
} }
break; break;
} }
case RaidCommandRaidUnlock: case RaidCommandRaidUnlock:
{ {
Raid *r = entity_list.GetRaidByClient(this); Raid *raid = entity_list.GetRaidByClient(this);
if (r) if (raid)
{ {
if (r->IsLocked()) if (raid->IsLocked())
r->LockRaid(false); raid->LockRaid(false);
else else
r->SendRaidUnlockTo(this); raid->SendRaidUnlockTo(this);
} }
break; break;
} }
case RaidCommandLootType2: case RaidCommandLootType2:
case RaidCommandLootType: case RaidCommandLootType:
{ {
Raid *r = entity_list.GetRaidByClient(this); Raid *raid = entity_list.GetRaidByClient(this);
if (r) if (raid) {
{ Message(15, "Loot type changed to: %d.", raid_command_packet->parameter);
Message(15, "Loot type changed to: %d.", ri->parameter); raid->ChangeLootType(raid_command_packet->parameter);
r->ChangeLootType(ri->parameter);
} }
break; break;
} }
@ -11495,11 +11507,10 @@ void Client::Handle_OP_RaidCommand(const EQApplicationPacket *app)
case RaidCommandAddLooter2: case RaidCommandAddLooter2:
case RaidCommandAddLooter: case RaidCommandAddLooter:
{ {
Raid *r = entity_list.GetRaidByClient(this); Raid *raid = entity_list.GetRaidByClient(this);
if (r) if (raid) {
{ Message(15, "Adding %s as a raid looter.", raid_command_packet->leader_name);
Message(15, "Adding %s as a raid looter.", ri->leader_name); raid->AddRaidLooter(raid_command_packet->leader_name);
r->AddRaidLooter(ri->leader_name);
} }
break; break;
} }
@ -11507,24 +11518,22 @@ void Client::Handle_OP_RaidCommand(const EQApplicationPacket *app)
case RaidCommandRemoveLooter2: case RaidCommandRemoveLooter2:
case RaidCommandRemoveLooter: case RaidCommandRemoveLooter:
{ {
Raid *r = entity_list.GetRaidByClient(this); Raid *raid = entity_list.GetRaidByClient(this);
if (r) if (raid) {
{ Message(15, "Removing %s as a raid looter.", raid_command_packet->leader_name);
Message(15, "Removing %s as a raid looter.", ri->leader_name); raid->RemoveRaidLooter(raid_command_packet->leader_name);
r->RemoveRaidLooter(ri->leader_name);
} }
break; break;
} }
case RaidCommandMakeLeader: case RaidCommandMakeLeader:
{ {
Raid *r = entity_list.GetRaidByClient(this); Raid *raid = entity_list.GetRaidByClient(this);
if (r) if (raid) {
{ if (strcmp(raid->leadername, GetName()) == 0) {
if (strcmp(r->leadername, GetName()) == 0) { raid->SetRaidLeader(GetName(), raid_command_packet->leader_name);
r->SetRaidLeader(GetName(), ri->leader_name); raid->UpdateRaidAAs();
r->UpdateRaidAAs(); raid->SendAllRaidLeadershipAA();
r->SendAllRaidLeadershipAA();
} }
} }
break; break;
@ -11532,19 +11541,19 @@ void Client::Handle_OP_RaidCommand(const EQApplicationPacket *app)
case RaidCommandSetMotd: case RaidCommandSetMotd:
{ {
Raid *r = entity_list.GetRaidByClient(this); Raid *raid = entity_list.GetRaidByClient(this);
if (!r) if (!raid)
break; break;
// we don't use the RaidGeneral here! // we don't use the RaidGeneral here!
RaidMOTD_Struct *motd = (RaidMOTD_Struct *)app->pBuffer; RaidMOTD_Struct *motd = (RaidMOTD_Struct *)app->pBuffer;
r->SetRaidMOTD(std::string(motd->motd)); raid->SetRaidMOTD(std::string(motd->motd));
r->SaveRaidMOTD(); raid->SaveRaidMOTD();
r->SendRaidMOTDToWorld(); raid->SendRaidMOTDToWorld();
break; break;
} }
default: { default: {
Message(13, "Raid command (%d) NYI", ri->action); Message(13, "Raid command (%d) NYI", raid_command_packet->action);
break; break;
} }
} }