Jan 4

Basic structure in place for Raid::AddBot though not working

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

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);

zone/client_packet.cpp

@@ -25,6 +25,7 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 #include <stdio.h>
 #include <string.h>
 #include <zlib.h>
+#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 */
+				/* Send out invite to the client */
-			auto outapp = new EQApplicationPacket(OP_RaidUpdate, sizeof(RaidGeneral_Struct));
+				auto outapp = new EQApplicationPacket(OP_RaidUpdate, sizeof(RaidGeneral_Struct));
-			RaidGeneral_Struct *raid_command = (RaidGeneral_Struct*)outapp->pBuffer;
+				RaidGeneral_Struct* raid_command = (RaidGeneral_Struct*)outapp->pBuffer;
 
-			strn0cpy(raid_command->leader_name, raid_command_packet->leader_name, 64);
+				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->player_name, raid_command_packet->player_name, 64);
 
-			raid_command->parameter = 0;
+				raid_command->parameter = 0;
-			raid_command->action = 20;
+				raid_command->action = 20;
 
-			player_to_invite->QueuePacket(outapp);
+				player_to_invite->QueuePacket(outapp);
+
+				safe_delete(outapp);
+#endif
+
+				break;
+			}
 
-			safe_delete(outapp);
 		
-			break;
-		}
 		case RaidCommandAcceptInvite: {
 			Client *player_accepting_invite = entity_list.GetClientByName(raid_command_packet->player_name);
 			if (player_accepting_invite) {

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)
 {

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);