pa/eqemu-server
2
0
Fork 0
mirror of https://github.com/EQEmu/Server.git synced 2025-12-11 21:01:29 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
eqemu-server/zone/bot_commands/bot.cpp
nytmyr 60ba76b39c
[Cleanup] Bot RaidGroupSay (#4653)
2025-02-07 14:06:31 -05:00

1998 lines
50 KiB
C++
Raw Blame History

#include "../bot_command.h"
void bot_command_bot(Client *c, const Seperator *sep)
{
std::vector<const char*> subcommand_list = {
"botappearance",
"botcamp",
"botclone",
"botcreate",
"botdelete",
"botfollowdistance",
"botinspectmessage",
"botlist",
"botoutofcombat",
"botreport",
"botspawn",
"botstance",
"botstopmeleelevel",
"botsummon",
"bottoggleranged",
"bottogglehelm",
"botupdate"
};
if (helper_command_alias_fail(c, "bot_command_bot", sep->arg[0], "bot"))
return;
helper_send_available_subcommands(c, "bot", subcommand_list);
}
void bot_command_camp(Client *c, const Seperator *sep)
{
if (helper_command_alias_fail(c, "bot_command_camp", sep->arg[0], "botcamp")) {
return;
}
if (helper_is_help_or_usage(sep->arg[1])) {
c->Message(Chat::White, "usage: %s ([actionable: target | byname | ownergroup | ownerraid | targetgroup | namesgroup | healrotationtargets | mmr | byclass | byrace | spawned] ([actionable_name]))", sep->arg[0]);
return;
}
if (!Bot::CheckCampSpawnConditions(c)) {
return;
}
const int ab_mask = ActionableBots::ABM_Type1;
std::string class_race_arg = sep->arg[1];
bool class_race_check = false;
if (!class_race_arg.compare("byclass") || !class_race_arg.compare("byrace")) {
class_race_check = true;
}
std::vector<Bot*> sbl;
if (ActionableBots::PopulateSBL(c, sep->arg[1], sbl, ab_mask, !class_race_check ? sep->arg[2] : nullptr, class_race_check ? atoi(sep->arg[2]) : 0) == ActionableBots::ABT_None) {
return;
}
for (auto bot_iter : sbl) {
bot_iter->Camp();
}
if (!sbl.empty()) {
c->Message(Chat::White, fmt::format("{} of your bots have been camped.", sbl.size()).c_str());
}
}
void bot_command_clone(Client *c, const Seperator *sep)
{
if (helper_command_alias_fail(c, "bot_command_clone", sep->arg[0], "botclone")) {
return;
}
if (helper_is_help_or_usage(sep->arg[1])) {
c->Message(
Chat::White,
fmt::format(
"Usage: <target_bot> {} [clone_name]",
sep->arg[0]
).c_str()
);
return;
}
auto my_bot = ActionableBots::AsTarget_ByBot(c);
if (!my_bot) {
c->Message(Chat::White, "You must target a bot that you own to use this command!");
return;
}
if (!my_bot->GetBotID()) {
c->Message(
Chat::White,
fmt::format(
"An unknown error has occured with {} (Bot ID {}).",
my_bot->GetCleanName(),
my_bot->GetBotID()
).c_str()
);
LogCommands(
"bot_command_clone(): - Error: Active bot reported invalid ID (BotName: [{}], BotID: [{}], OwnerName: [{}], OwnerID: [{}], AcctName: [{}], AcctID: [{}])",
my_bot->GetCleanName(),
my_bot->GetBotID(),
c->GetCleanName(),
c->CharacterID(),
c->AccountName(),
c->AccountID()
);
return;
}
if (sep->arg[1][0] == '\0' || sep->IsNumber(1)) {
c->Message(Chat::White, "You must name your bot clone.");
return;
}
std::string bot_name = sep->arg[1];
if (!Bot::IsValidName(bot_name)) {
c->Message(
Chat::Yellow,
fmt::format(
"'{}' is an invalid name. You may only use characters 'A-Z' or 'a-z' and it must be between 4 and 15 characters. Mixed case {} allowed.",
bot_name, RuleB(Bots, AllowCamelCaseNames) ? "is" : "is not"
).c_str()
);
return;
}
bool available_flag = false;
!database.botdb.QueryNameAvailablity(bot_name, available_flag);
if (!available_flag) {
c->Message(
Chat::Yellow,
fmt::format(
"The name '{}' is already being used or prohibited. Please choose a different name",
bot_name
).c_str()
);
return;
}
auto bot_creation_limit = c->GetBotCreationLimit();
auto bot_creation_limit_class = c->GetBotCreationLimit(my_bot->GetClass());
uint32 bot_count = 0;
uint32 bot_class_count = 0;
if (!database.botdb.QueryBotCount(c->CharacterID(), my_bot->GetClass(), bot_count, bot_class_count)) {
c->Message(Chat::White, "Failed to query bot count.");
return;
}
if (bot_creation_limit >= 0 && bot_count >= bot_creation_limit) {
std::string message;
if (bot_creation_limit) {
message = fmt::format(
"You have reached the maximum limit of {} bot{}.",
bot_creation_limit,
bot_creation_limit != 1 ? "s" : ""
);
} else {
message = "You cannot create any bots.";
}
c->Message(Chat::White, message.c_str());
return;
}
if (bot_creation_limit_class >= 0 && bot_class_count >= bot_creation_limit_class) {
std::string message;
if (bot_creation_limit_class) {
message = fmt::format(
"You cannot create anymore than {} {} bot{}.",
bot_creation_limit_class,
GetClassIDName(my_bot->GetClass()),
bot_creation_limit_class != 1 ? "s" : ""
);
} else {
message = fmt::format(
"You cannot create any {} bots.",
GetClassIDName(my_bot->GetClass())
);
}
c->Message(Chat::White, message.c_str());
return;
}
uint32 clone_id = 0;
if (!database.botdb.CreateCloneBot(my_bot->GetBotID(), bot_name, clone_id) || !clone_id) {
c->Message(
Chat::White,
fmt::format(
"Failed to create clone bot '{}'.",
bot_name
).c_str()
);
return;
}
int clone_stance = Stance::Passive;
if (!database.botdb.LoadStance(my_bot->GetBotID(), clone_stance)) {
c->Message(
Chat::White,
fmt::format(
"Failed to load stance from '{}'.",
my_bot->GetCleanName()
).c_str()
);
}
if (!database.botdb.SaveStance(clone_id, clone_stance)) {
c->Message(
Chat::White,
fmt::format(
"Failed to save stance for clone '{}'.",
bot_name
).c_str()
);
}
if (!database.botdb.CreateCloneBotInventory(my_bot->GetBotID(), clone_id)) {
c->Message(
Chat::White,
fmt::format(
"Failed to create clone bot inventory for clone '{}'.",
bot_name
).c_str()
);
}
c->Message(
Chat::White,
fmt::format(
"Bot Cloned | From: {} To: {}",
my_bot->GetCleanName(),
bot_name
).c_str()
);
}
void bot_command_create(Client *c, const Seperator *sep)
{
const std::string class_substrs[17] = {
"",
"WAR", "CLR", "PAL", "RNG",
"SHD", "DRU", "MNK", "BRD",
"ROG", "SHM", "NEC", "WIZ",
"MAG", "ENC", "BST", "BER"
};
const std::string race_substrs[17] = {
"",
"HUM", "BAR", "ERU", "ELF",
"HIE", "DEF", "HEF", "DWF",
"TRL", "OGR", "HFL", "GNM",
"IKS", "VAH", "FRG", "DRK"
};
const uint16 race_values[17] = {
Race::Doug,
Race::Human, Race::Barbarian, Race::Erudite, Race::WoodElf,
Race::HighElf, Race::DarkElf, Race::HalfElf, Race::Dwarf,
Race::Troll, Race::Ogre, Race::Halfling, Race::Gnome,
Race::Iksar, Race::VahShir, Race::Froglok2, Race::Drakkin
};
const std::string gender_substrs[2] = {
"Male", "Female",
};
if (helper_command_alias_fail(c, "bot_command_create", sep->arg[0], "botcreate")) {
return;
}
if (helper_is_help_or_usage(sep->arg[1])) {
c->Message(
Chat::White,
fmt::format(
"Usage: {} [Name] [Class] [Race] [Gender]",
sep->arg[0]
).c_str()
);
std::string window_text;
std::string message_separator;
int object_count = 0;
const int object_max = 4;
window_text.append(
fmt::format(
"Classes{}<c \"#FFFF\">",
DialogueWindow::Break()
)
);
message_separator = " ";
object_count = 0;
for (int i = 0; i <= 15; ++i) {
window_text.append(message_separator);
if (object_count >= object_max) {
window_text.append(DialogueWindow::Break());
object_count = 0;
}
window_text.append(
fmt::format("{} ({})",
class_substrs[i + 1],
(i + 1)
)
);
++object_count;
message_separator = ", ";
}
window_text.append(DialogueWindow::Break(2));
window_text.append(
fmt::format(
"<c \"#FFFFFF\">Races{}<c \"#FFFF\">",
DialogueWindow::Break()
)
);
message_separator = " ";
object_count = 0;
for (int i = 0; i <= 15; ++i) {
window_text.append(message_separator);
if (object_count >= object_max) {
window_text.append(DialogueWindow::Break());
object_count = 0;
}
window_text.append(
fmt::format("{} ({})",
race_substrs[i + 1],
race_values[i + 1]
)
);
++object_count;
message_separator = ", ";
}
window_text.append(DialogueWindow::Break(2));
window_text.append(
fmt::format(
"<c \"#FFFFFF\">Genders{}<c \"#FFFF\">",
DialogueWindow::Break()
)
);
message_separator = " ";
for (int i = 0; i <= 1; ++i) {
window_text.append(message_separator);
window_text.append(
fmt::format("{} ({})",
gender_substrs[i],
i
)
);
message_separator = ", ";
}
c->SendPopupToClient("Bot Creation Options", window_text.c_str());
return;
}
const auto arguments = sep->argnum;
if (!arguments || sep->IsNumber(1)) {
c->Message(Chat::White, "You must name your bot!");
return;
}
std::string bot_name = sep->arg[1];
bot_name = Strings::UcFirst(bot_name);
if (arguments < 2 || !sep->IsNumber(2)) {
c->Message(Chat::White, "Invalid class!");
return;
}
auto bot_class = static_cast<uint8>(Strings::ToUnsignedInt(sep->arg[2]));
if (arguments < 3 || !sep->IsNumber(3)) {
c->Message(Chat::White, "Invalid race!");
return;
}
auto bot_race = static_cast<uint16>(Strings::ToUnsignedInt(sep->arg[3]));
if (arguments < 4) {
c->Message(Chat::White, "Invalid gender!");
return;
}
auto bot_gender = Gender::Male;
if (sep->IsNumber(4)) {
bot_gender = static_cast<uint8>(Strings::ToUnsignedInt(sep->arg[4]));
if (bot_gender == Gender::Neuter) {
bot_gender = Gender::Male;
}
} else {
if (!strcasecmp(sep->arg[4], "m") || !strcasecmp(sep->arg[4], "male")) {
bot_gender = Gender::Male;
} else if (!strcasecmp(sep->arg[4], "f") || !strcasecmp(sep->arg[4], "female")) {
bot_gender = Gender::Female;
}
}
helper_bot_create(c, bot_name, bot_class, bot_race, bot_gender);
}
void bot_command_delete(Client *c, const Seperator *sep)
{
if (helper_command_alias_fail(c, "bot_command_delete", sep->arg[0], "botdelete"))
return;
if (helper_is_help_or_usage(sep->arg[1])) {
c->Message(Chat::White, "usage: <target_bot> %s", sep->arg[0]);
return;
}
if (!Bot::CheckCampSpawnConditions(c)) {
return;
}
auto my_bot = ActionableBots::AsTarget_ByBot(c);
if (!my_bot) {
c->Message(Chat::White, "You must <target> a bot that you own to use this command");
return;
}
std::string delete_confirm = sep->arg[1];
std::string deleted_check = "confirm";
if (!(delete_confirm.find(deleted_check) != std::string::npos)) {
c->Message(Chat::White, "You must type %s confirm to confirm the deletion of %s.", sep->arg[0], my_bot->GetCleanName());
return;
}
if (!my_bot->DeleteBot()) {
c->Message(Chat::White, "Failed to delete '%s' due to database error", my_bot->GetCleanName());
return;
}
auto bid = my_bot->GetBotID();
std::string bot_name = my_bot->GetCleanName();
my_bot->Camp(false);
c->Message(Chat::White, "Successfully deleted bot '%s' (id: %i)", bot_name.c_str(), bid);
}
void bot_command_follow_distance(Client *c, const Seperator *sep)
{
if (helper_command_alias_fail(c, "bot_command_follow_distance", sep->arg[0], "botfollowdistance")) {
c->Message(Chat::White, "note: Sets or resets the follow distance of the selected bots.");
return;
}
if (helper_is_help_or_usage(sep->arg[1])) {
BotCommandHelpParams p;
p.description = { "Sets or resets the follow distance of the selected bots." };
p.notes =
{
fmt::format("[Default]: {}", RuleI(Bots, MaxFollowDistance)),
fmt::format("- You must use a value between 1 and {}.", RuleI(Bots, MaxFollowDistance))
};
p.example_format = { fmt::format("{} [reset]/[set [value]] [actionable]", sep->arg[0]) };
p.examples_one = {
"To set all bots to follow at a distance of 25:",
fmt::format("{} set 25 spawned", sep->arg[0])
};
p.examples_two = {
"To check the curret following distance of all bots:",
fmt::format("{} current spawned", sep->arg[0])
};
p.examples_three =
{
"To reset the following distance of all Wizards:",
fmt::format(
"{} reset byclass {}",
sep->arg[0],
Class::Wizard
)
};
p.actionables = { "target, byname, ownergroup, ownerraid, targetgroup, namesgroup, healrotationtargets, mmr, byclass, byrace, spawned" };
std::string popup_text = c->SendBotCommandHelpWindow(p);
popup_text = DialogueWindow::Table(popup_text);
c->SendPopupToClient(sep->arg[0], popup_text.c_str());
return;
}
const int ab_mask = ActionableBots::ABM_Type2;
uint32 bfd = RuleI(Bots, DefaultFollowDistance);
bool set_flag = false;
bool current_check = false;
int ab_arg = 2;
std::string arg1 = sep->arg[1];
if (!arg1.compare("set")) {
if (!sep->IsNumber(2)) {
c->Message(Chat::Yellow, "You must enter a value between 1 and %i.", RuleI(Bots, MaxFollowDistance));
return;
}
bfd = Strings::ToInt(sep->arg[2]);
if (bfd < 1) {
c->Message(Chat::Yellow, "You must enter a value between 1 and %i.", RuleI(Bots, MaxFollowDistance));
return;
}
if (bfd > RuleI(Bots, MaxFollowDistance)) {
c->Message(Chat::Yellow, "You must enter a value between 1 and %i.", RuleI(Bots, MaxFollowDistance));
return;
}
set_flag = true;
++ab_arg;
}
else if (!arg1.compare("current")) {
current_check = true;
}
else if (arg1.compare("reset")) {
c->Message(
Chat::Yellow,
fmt::format(
"Incorrect argument, use {} for information regarding this command.",
Saylink::Silent(
fmt::format("{} help", sep->arg[0])
)
).c_str()
);
return;
}
std::string class_race_arg = sep->arg[ab_arg];
bool class_race_check = false;
if (!class_race_arg.compare("byclass") || !class_race_arg.compare("byrace")) {
class_race_check = true;
}
std::vector<Bot*> sbl;
if (ActionableBots::PopulateSBL(c, sep->arg[ab_arg], sbl, ab_mask, !class_race_check ? sep->arg[ab_arg + 1] : nullptr, class_race_check ? atoi(sep->arg[ab_arg + 1]) : 0) == ActionableBots::ABT_None) {
return;
}
sbl.erase(std::remove(sbl.begin(), sbl.end(), nullptr), sbl.end());
int bot_count = 0;
for (auto bot_iter : sbl) {
if (!bot_iter) {
continue;
}
if (current_check) {
Mob* follow_mob = entity_list.GetMob(bot_iter->GetFollowID());
c->Message(
Chat::Green,
fmt::format(
"{} says, 'I am currently following {} at a distance of {}.'",
bot_iter->GetCleanName(),
follow_mob ? follow_mob->GetCleanName() : "no one",
sqrt(bot_iter->GetFollowDistance())
).c_str()
);
}
else {
bot_iter->SetFollowDistance(bfd * bfd);
++bot_count;
}
}
if (current_check) {
return;
}
if (bot_count == 1) {
Mob* follow_mob = entity_list.GetMob(sbl.front()->GetFollowID());
c->Message(
Chat::Green,
fmt::format(
"{} says, 'Following {} at a distance of {}.'",
sbl.front()->GetCleanName(),
follow_mob ? follow_mob->GetCleanName() : "you",
bfd
).c_str()
);
}
else {
c->Message(
Chat::Green,
fmt::format(
"{} of your bots are now following at a distance of {}.",
bot_count,
bfd
).c_str()
);
}
}
void bot_command_inspect_message(Client *c, const Seperator *sep)
{
if (helper_command_alias_fail(c, "bot_command_inspect_message", sep->arg[0], "botinspectmessage"))
return;
if (helper_is_help_or_usage(sep->arg[1])) {
c->Message(Chat::White, "usage: %s [set | clear] ([actionable: target | byname | ownergroup | ownerraid | targetgroup | namesgroup | healrotationmembers | healrotationtargets | mmr | byclass | byrace | spawned] ([actionable_name]))", sep->arg[0]);
c->Message(Chat::White, "Notes:");
if (c->ClientVersion() >= EQ::versions::ClientVersion::SoF) {
c->Message(Chat::White, "- Self-inspect and type your bot's inspect message");
c->Message(Chat::White, "- Close the self-inspect window to update the server");
c->Message(Chat::White, "- Type '%s set' to set the bot's inspect message", sep->arg[0]);
}
else {
c->Message(Chat::White, "- Self-inspect and type your bot's inspect message");
c->Message(Chat::White, "- Close the self-inspect window");
c->Message(Chat::White, "- Self-inspect again to update the server");
c->Message(Chat::White, "- Type '%s set' to set the bot's inspect message", sep->arg[0]);
}
return;
}
const int ab_mask = ActionableBots::ABM_NoFilter;
bool set_flag = false;
if (!strcasecmp(sep->arg[1], "set")) {
set_flag = true;
}
else if (strcasecmp(sep->arg[1], "clear")) {
c->Message(Chat::White, "This command requires a [set | clear] argument");
return;
}
std::vector<Bot*> sbl;
auto ab_type = ActionableBots::PopulateSBL(c, sep->arg[2], sbl, ab_mask, sep->arg[3]);
if (ab_type == ActionableBots::ABT_None)
return;
const auto client_message_struct = &c->GetInspectMessage();
int bot_count = 0;
for (auto bot_iter : sbl) {
if (!bot_iter)
continue;
auto bot_message_struct = &bot_iter->GetInspectMessage();
memset(bot_message_struct, 0, sizeof(InspectMessage_Struct));
if (set_flag)
memcpy(bot_message_struct, client_message_struct, sizeof(InspectMessage_Struct));
if (ab_type != ActionableBots::ABT_All && !database.botdb.SaveInspectMessage(bot_iter->GetBotID(), *bot_message_struct)) {
return;
}
++bot_count;
}
if (ab_type == ActionableBots::ABT_All) {
InspectMessage_Struct bot_message_struct;
memset(&bot_message_struct, 0, sizeof(InspectMessage_Struct));
if (set_flag)
memcpy(&bot_message_struct, client_message_struct, sizeof(InspectMessage_Struct));
if (!database.botdb.SaveAllInspectMessages(c->CharacterID(), bot_message_struct)) {
return;
}
c->Message(Chat::White, "%s all of your bot inspect messages", set_flag ? "Set" : "Cleared");
}
else {
c->Message(Chat::White, "%s %i of your spawned bot inspect messages", set_flag ? "Set" : "Cleared", bot_count);
}
}
void bot_command_list_bots(Client *c, const Seperator *sep)
{
enum {
FilterClass,
FilterRace,
FilterName,
FilterCount,
MaskClass = (1 << FilterClass),
MaskRace = (1 << FilterRace),
MaskName = (1 << FilterName)
};
if (helper_command_alias_fail(c, "bot_command_list", sep->arg[0], "botlist")) {
return;
}
if (helper_is_help_or_usage(sep->arg[1])) {
c->Message(
Chat::White,
fmt::format(
"Usage: {} (account) ([class] [value]) ([race] [value]) ([name] [partial-full])",
sep->arg[0]
).c_str()
);
c->Message(Chat::White, "Note: Filter criteria is orderless and optional.");
return;
}
bool Account = false;
int seps = 1;
uint32 filter_value[FilterCount];
int name_criteria_arg = 0;
memset(&filter_value, 0, sizeof(uint32) * FilterCount);
int filter_mask = 0;
if (!strcasecmp(sep->arg[1], "account")) {
Account = true;
seps = 2;
}
for (int i = seps; i < (FilterCount * 2); i += 2) {
if (sep->arg[i][0] == '\0') {
break;
}
if (!strcasecmp(sep->arg[i], "class")) {
filter_mask |= MaskClass;
filter_value[FilterClass] = Strings::ToInt(sep->arg[i + 1]);
continue;
}
if (!strcasecmp(sep->arg[i], "race")) {
filter_mask |= MaskRace;
filter_value[FilterRace] = Strings::ToInt(sep->arg[i + 1]);
continue;
}
if (!strcasecmp(sep->arg[i], "name")) {
filter_mask |= MaskName;
name_criteria_arg = (i + 1);
continue;
}
c->Message(Chat::White, "A numeric value or name is required to use the filter property of this command (f: '%s', v: '%s')", sep->arg[i], sep->arg[i + 1]);
return;
}
std::list<BotsAvailableList> bots_list;
if (!database.botdb.LoadBotsList(c->CharacterID(), bots_list, Account)) {
return;
}
if (bots_list.empty()) {
c->Message(Chat::White, "You have no bots.");
return;
}
auto bot_count = 0;
auto bots_owned = 0;
auto bot_number = 1;
for (auto bots_iter : bots_list) {
if (filter_mask) {
if ((filter_mask & MaskClass) && filter_value[FilterClass] != bots_iter.class_) {
continue;
}
if ((filter_mask & MaskRace) && filter_value[FilterRace] != bots_iter.race) {
continue;
}
if (filter_mask & MaskName) {
std::string name_criteria = sep->arg[name_criteria_arg];
std::transform(name_criteria.begin(), name_criteria.end(), name_criteria.begin(), ::tolower);
std::string name_check = bots_iter.bot_name;
std::transform(name_check.begin(), name_check.end(), name_check.begin(), ::tolower);
if (name_check.find(name_criteria) == std::string::npos) {
continue;
}
}
}
auto* bot = entity_list.GetBotByBotName(bots_iter.bot_name);
c->Message(
Chat::White,
fmt::format(
"Bot {} | {} is a Level {} {} {} {} owned by {}.",
bot_number,
(
(c->CharacterID() == bots_iter.owner_id && !bot) ?
Saylink::Silent(
fmt::format("^spawn {}", bots_iter.bot_name),
bots_iter.bot_name
) :
bots_iter.bot_name
),
bots_iter.level,
GetGenderName(bots_iter.gender),
GetRaceIDName(bots_iter.race),
GetClassIDName(bots_iter.class_),
bots_iter.owner_name
).c_str()
);
if (c->CharacterID() == bots_iter.owner_id) {
bots_owned++;
}
bot_count++;
bot_number++;
}
if (!bot_count) {
c->Message(Chat::White, "You have no bots meeting this criteria.");
return;
} else {
c->Message(
Chat::White,
fmt::format(
"{} Of {} bot{} shown, {} {} owned by you.",
bot_count,
bots_list.size(),
bot_count != 1 ? "s" : "",
bots_owned,
bots_owned != 1 ? "are" : "is"
).c_str()
);
c->Message(Chat::White, "Note: You can spawn any owned bots by clicking their name if they are not already spawned.");
c->Message(Chat::White, "Your bot creation limits are as follows:");
const auto overall_bot_creation_limit = c->GetBotCreationLimit();
c->Message(
Chat::White,
fmt::format(
"Overall | {} Bot{}",
overall_bot_creation_limit,
overall_bot_creation_limit != 1 ? "s" : ""
).c_str()
);
for (uint8 class_id = Class::Warrior; class_id <= Class::Berserker; class_id++) {
auto class_creation_limit = c->GetBotCreationLimit(class_id);
if (class_creation_limit != overall_bot_creation_limit) {
c->Message(
Chat::White,
fmt::format(
"{} | {} Bot{}",
GetClassIDName(class_id),
class_creation_limit,
class_creation_limit != 1 ? "s" : ""
).c_str()
);
}
}
}
}
void bot_command_report(Client *c, const Seperator *sep)
{
if (helper_command_alias_fail(c, "bot_command_report", sep->arg[0], "botreport"))
return;
if (helper_is_help_or_usage(sep->arg[1])) {
c->Message(Chat::White, "usage: %s ([actionable: target | byname | ownergroup | ownerraid | targetgroup | namesgroup | healrotationmembers | healrotationtargets | mmr | byclass | byrace | spawned] ([actionable_name]))", sep->arg[0]);
return;
}
const int ab_mask = ActionableBots::ABM_Type1;
std::string arg1 = sep->arg[1];
int ab_arg = 1;
std::string class_race_arg = sep->arg[ab_arg];
bool class_race_check = false;
if (!class_race_arg.compare("byclass") || !class_race_arg.compare("byrace")) {
class_race_check = true;
}
std::vector<Bot*> sbl;
if (ActionableBots::PopulateSBL(c, sep->arg[ab_arg], sbl, ab_mask, !class_race_check ? sep->arg[ab_arg + 1] : nullptr, class_race_check ? atoi(sep->arg[ab_arg + 1]) : 0) == ActionableBots::ABT_None) {
return;
}
for (auto bot_iter : sbl) {
if (!bot_iter)
continue;
std::string report_msg = StringFormat("%s %s reports", GetClassIDName(bot_iter->GetClass()), bot_iter->GetCleanName());
report_msg.append(StringFormat(": %3.1f%% health", bot_iter->GetHPRatio()));
if (!IsNonSpellFighterClass(bot_iter->GetClass()))
report_msg.append(StringFormat(": %3.1f%% mana", bot_iter->GetManaRatio()));
c->Message(Chat::White, "%s", report_msg.c_str());
}
}
void bot_command_spawn(Client *c, const Seperator *sep)
{
if (helper_command_alias_fail(c, "bot_command_spawn", sep->arg[0], "botspawn")) {
return;
}
if (helper_is_help_or_usage(sep->arg[1])) {
c->Message(
Chat::White,
fmt::format(
"Usage: {} [bot_name] [optional: silent]",
sep->arg[0]
).c_str()
);
return;
}
auto bot_character_level = c->GetBotRequiredLevel();
if (
bot_character_level >= 0 &&
c->GetLevel() < bot_character_level &&
!c->GetGM()
) {
c->Message(
Chat::White,
fmt::format(
"You must be level {} to spawn bots.",
bot_character_level
).c_str()
);
return;
}
if (!Bot::CheckCampSpawnConditions(c)) {
return;
}
auto bot_spawn_limit = c->GetBotSpawnLimit();
auto spawned_bot_count = Bot::SpawnedBotCount(c->CharacterID());
if (
bot_spawn_limit >= 0 &&
spawned_bot_count >= bot_spawn_limit &&
!c->GetGM()
) {
std::string message;
if (bot_spawn_limit) {
message = fmt::format(
"You cannot have more than {} spawned bot{}.",
bot_spawn_limit,
bot_spawn_limit != 1 ? "s" : ""
);
} else {
message = "You are not currently allowed to spawn any bots.";
}
c->Message(Chat::White, message.c_str());
return;
}
if (sep->arg[1][0] == '\0' || sep->IsNumber(1)) {
c->Message(Chat::White, "You must specify a name to use this command.");
return;
}
std::string bot_name = sep->arg[1];
uint32 bot_id = 0;
uint8 bot_class = Class::None;
if (!database.botdb.LoadBotID(bot_name, bot_id, bot_class)) {
c->Message(
Chat::White,
fmt::format(
"Failed to load bot ID for '{}'.",
bot_name
).c_str()
);
return;
}
auto bot_spawn_limit_class = c->GetBotSpawnLimit(bot_class);
auto spawned_bot_count_class = Bot::SpawnedBotCount(c->CharacterID(), bot_class);
if (
bot_spawn_limit_class >= 0 &&
spawned_bot_count_class >= bot_spawn_limit_class &&
!c->GetGM()
) {
std::string message;
if (bot_spawn_limit_class) {
message = fmt::format(
"You cannot have more than {} spawned {} bot{}.",
bot_spawn_limit_class,
GetClassIDName(bot_class),
bot_spawn_limit_class != 1 ? "s" : ""
);
} else {
message = fmt::format(
"You are not currently allowed to spawn any {} bots.",
GetClassIDName(bot_class)
);
}
c->Message(Chat::White, message.c_str());
return;
}
auto bot_character_level_class = c->GetBotRequiredLevel(bot_class);
if (
bot_character_level_class >= 0 &&
c->GetLevel() < bot_character_level_class &&
!c->GetGM()
) {
c->Message(
Chat::White,
fmt::format(
"You must be level {} to spawn {} bots.",
bot_character_level_class,
GetClassIDName(bot_class)
).c_str()
);
return;
}
if (!bot_id) {
c->Message(
Chat::White,
fmt::format(
"You don't own a bot named '{}'.",
bot_name
).c_str()
);
return;
}
if (entity_list.GetMobByBotID(bot_id)) {
c->Message(
Chat::White,
fmt::format(
"'{}' is already spawned.",
bot_name
).c_str()
);
return;
}
auto my_bot = Bot::LoadBot(bot_id);
if (!my_bot) {
c->Message(
Chat::White,
fmt::format(
"Invalid bot '{}' (ID {})",
bot_name,
bot_id
).c_str()
);
return;
}
if (!my_bot->Spawn(c)) {
c->Message(
Chat::White,
fmt::format(
"Failed to spawn '{}' (ID {})",
bot_name,
bot_id
).c_str()
);
safe_delete(my_bot);
return;
}
static std::string bot_spawn_message[17] = {
"I am ready to fight!", // DEFAULT
"A solid weapon is my ally!", // Class::Warrior
"The pious shall never die!", // Class::Cleric
"I am the symbol of Light!", // Class::Paladin
"There are enemies near!", // Class::Ranger
"Out of the shadows, I step!", // Class::ShadowKnight
"Nature's fury shall be wrought!", // Class::Druid
"Your punishment will be my fist!", // Class::Monk
"Music is the overture of battle! ", // BARD
"Daggers into the backs of my enemies!", // Class::Rogue
"More bones to grind!", // Class::Shaman
"Death is only the beginning!", // Class::Necromancer
"I am the harbinger of demise!", // Class::Wizard
"The elements are at my command!", // Class::Magician
"No being can resist my charm!", // Class::Enchanter
"Battles are won by hand and paw!", // Class::Beastlord
"My bloodthirst shall not be quenched!" // Class::Berserker
};
uint8 message_index = 0;
if (c->GetBotOption(Client::booSpawnMessageClassSpecific)) {
message_index = VALIDATECLASSID(my_bot->GetClass());
}
std::string silent_confirm = sep->arg[2];
bool silent_tell = false;
if (!silent_confirm.compare("silent")) {
silent_tell = true;
}
if (!silent_tell && c->GetBotOption(Client::booSpawnMessageSay)) {
my_bot->RaidGroupSay(bot_spawn_message[message_index].c_str());
}
else if (!silent_tell && c->GetBotOption(Client::booSpawnMessageTell)) {
my_bot->OwnerMessage(bot_spawn_message[message_index]);
}
}
void bot_command_stance(Client *c, const Seperator *sep)
{
if (helper_command_alias_fail(c, "bot_command_stance", sep->arg[0], "botstance")) {
c->Message(Chat::White, "note: Change a bot's stance to control the way it behaves.");
return;
}
if (helper_is_help_or_usage(sep->arg[1])) {
BotCommandHelpParams p;
p.description = { "Change a bot's stance to control the way it behaves." };
p.notes =
{
"- <b>Changing a stance will reset all settings to match that stance type.</b>",
"- Any changes made will only save to that stance for future use.",
fmt::format(
"- {} (#{}) will tell Non-Warrior classes to taunt automatically.",
Stance::GetName(Stance::Aggressive),
Stance::Aggressive
),
"<br>",
"Available stances:",
fmt::format(
"{} (#{}), {} (#{}), {} (#{}), {} (#{}), {} (#{}), {} (#{}), {} (#{})",
Stance::GetName(Stance::Passive),
Stance::Passive,
Stance::GetName(Stance::Balanced),
Stance::Balanced,
Stance::GetName(Stance::Efficient),
Stance::Efficient,
Stance::GetName(Stance::Aggressive),
Stance::Aggressive,
Stance::GetName(Stance::Assist),
Stance::Assist,
Stance::GetName(Stance::Burn),
Stance::Burn,
Stance::GetName(Stance::AEBurn),
Stance::AEBurn
),
"<br>",
fmt::format(
"- {} (#{}) [Default] - Overall balance and casts most spell types by default.",
Stance::GetName(Stance::Balanced),
Stance::Balanced
),
fmt::format(
"- {} (#{}) - Idle. Does not cast or engage in combat.",
Stance::GetName(Stance::Passive),
Stance::Passive
),
fmt::format(
"- {} (#{}) - More mana and aggro efficient (SKs will still cast hate line). Longer delays between detrimental spells, thresholds adjusted to cast less often.",
Stance::GetName(Stance::Efficient),
Stance::Efficient
),
fmt::format(
"- {} (#{}) - Much more aggressive in their cast times and thresholds. More DPS, debuffs and slow but a higher risk of snagging aggro.",
Stance::GetName(Stance::Aggressive),
Stance::Aggressive
),
fmt::format(
"- {} (#{}) - Support role. Most offensive spell types are disabled. Focused on heals, cures, CC, debuffs and slows.",
Stance::GetName(Stance::Assist),
Stance::Assist
),
fmt::format(
"- {} (#{}) - Murder. Doesn't care about aggro, just wants to kill. DPS Machine.",
Stance::GetName(Stance::Burn),
Stance::Burn
),
fmt::format(
"- {} (#{}) - Murder EVERYTHING. Doesn't care about aggro, casts AEs. Everything must die ASAP.",
Stance::GetName(Stance::AEBurn),
Stance::AEBurn
)
};
p.example_format =
{ fmt::format( "{} [current | value]", sep->arg[0]) };
p.examples_one =
{
"To set all bots to BurnAE:",
fmt::format("{} {} spawned {}",
sep->arg[0],
Stance::Aggressive,
Class::ShadowKnight
)
};
p.examples_two =
{
"To set all Shadowknights to Aggressive:",
fmt::format("{} {} byclass {}",
sep->arg[0],
Stance::Aggressive,
Class::ShadowKnight
)
};
p.examples_three = {
"To check the current stances of all bots:",
fmt::format("{} current spawned", sep->arg[0])
};
p.actionables = { "target, byname, ownergroup, ownerraid, targetgroup, namesgroup, healrotationtargets, mmr, byclass, byrace, spawned" };
std::string popup_text = c->SendBotCommandHelpWindow(p);
popup_text = DialogueWindow::Table(popup_text);
c->SendPopupToClient(sep->arg[0], popup_text.c_str());
return;
}
const int ab_mask = ActionableBots::ABM_Type1;
bool current_check = false;
int ab_arg = 1;
uint32 value = 0;
std::string arg1 = sep->arg[1];
if (sep->IsNumber(1)) {
++ab_arg;
value = atoi(sep->arg[1]);
if (
value < Stance::Passive ||
value > Stance::AEBurn ||
value == Stance::Reactive ||
value == Stance::Assist
) {
c->Message(
Chat::Yellow,
fmt::format(
"You must choose a valid stance ID, use {} for information regarding this command.",
Saylink::Silent(
fmt::format("{} help", sep->arg[0])
)
).c_str()
);
return;
}
}
else if (!arg1.compare("current")) {
++ab_arg;
current_check = true;
}
else {
c->Message(
Chat::Yellow,
fmt::format(
"Incorrect argument, use {} for information regarding this command.",
Saylink::Silent(
fmt::format("{} help", sep->arg[0])
)
).c_str()
);
return;
}
std::string class_race_arg = sep->arg[ab_arg];
bool class_race_check = false;
if (!class_race_arg.compare("byclass") || !class_race_arg.compare("byrace")) {
class_race_check = true;
}
std::vector<Bot*> sbl;
if (ActionableBots::PopulateSBL(c, sep->arg[ab_arg], sbl, ab_mask, !class_race_check ? sep->arg[ab_arg + 1] : nullptr, class_race_check ? atoi(sep->arg[ab_arg + 1]) : 0) == ActionableBots::ABT_None) {
return;
}
Bot* first_found = nullptr;
int success_count = 0;
for (auto bot_iter : sbl) {
if (!first_found) {
first_found = bot_iter;
}
if (current_check) {
c->Message(
Chat::Green,
fmt::format(
"{} says, 'My current stance is {} ({}).'",
bot_iter->GetCleanName(),
Stance::GetName(bot_iter->GetBotStance()),
bot_iter->GetBotStance()
).c_str()
);
continue;
}
bot_iter->Save();
bot_iter->SetBotStance(value);
bot_iter->LoadDefaultBotSettings();
database.botdb.LoadBotSettings(bot_iter);
if (
(bot_iter->GetClass() == Class::Warrior || bot_iter->GetClass() == Class::Paladin || bot_iter->GetClass() == Class::ShadowKnight) &&
(bot_iter->GetBotStance() == Stance::Aggressive)
) {
bot_iter->SetTaunting(true);
if (bot_iter->HasPet() && bot_iter->GetPet()->GetSkill(EQ::skills::SkillTaunt)) {
bot_iter->GetPet()->CastToNPC()->SetTaunting(true);
}
}
else {
bot_iter->SetTaunting(false);
if (bot_iter->HasPet() && bot_iter->GetPet()->GetSkill(EQ::skills::SkillTaunt)) {
bot_iter->GetPet()->CastToNPC()->SetTaunting(false);
}
}
bot_iter->Save();
++success_count;
}
if (current_check) {
return;
}
if (success_count == 1 && first_found) {
c->Message(
Chat::Green,
fmt::format(
"{} says, 'I am now set to the stance [{}].'",
first_found->GetCleanName(),
Stance::GetName(value)
).c_str()
);
}
else {
c->Message(
Chat::Green,
fmt::format(
"{} of your bots are now set to the stance [{}].",
success_count,
Stance::GetName(value)
).c_str()
);
}
}
void bot_command_stop_melee_level(Client* c, const Seperator* sep)
{
if (helper_command_alias_fail(c, "bot_command_stop_melee_level", sep->arg[0], "botstopmeleelevel")) {
return;
}
if (helper_is_help_or_usage(sep->arg[1])) {
c->Message(Chat::White, "usage: %s [current | reset | sync | value: 0-255] ([actionable: target | byname | ownergroup | ownerraid | targetgroup | namesgroup | mmr | byclass | byrace | spawned] ([actionable_name]))", sep->arg[0]);
c->Message(Chat::White, "note: Use [reset] to set stop melee level to server rule");
c->Message(Chat::White, "note: Use [sync] to set stop melee level to current bot level");
return;
}
const int ab_mask = ActionableBots::ABM_Type1;
std::string arg1 = sep->arg[1];
int ab_arg = 1;
uint8 sml = RuleI(Bots, CasterStopMeleeLevel);
bool sync_sml = false;
bool reset_sml = false;
bool current_check = false;
if (sep->IsNumber(1)) {
ab_arg = 2;
sml = Strings::ToInt(sep->arg[1]);
if (sml <= 0 || sml > 255) {
c->Message(Chat::White, "You must provide a value between 0-255.");
return;
}
}
else if (!strcasecmp(sep->arg[1], "sync")) {
ab_arg = 2;
sync_sml = true;
}
else if (!arg1.compare("current")) {
ab_arg = 2;
current_check = true;
}
else if (!strcasecmp(sep->arg[1], "reset")) {
ab_arg = 2;
reset_sml = true;
}
else {
c->Message(
Chat::Yellow,
fmt::format(
"Incorrect argument, use {} for information regarding this command.",
Saylink::Silent(
fmt::format("{} help", sep->arg[0])
)
).c_str()
);
return;
}
std::string class_race_arg = sep->arg[ab_arg];
bool class_race_check = false;
if (!class_race_arg.compare("byclass") || !class_race_arg.compare("byrace")) {
class_race_check = true;
}
std::vector<Bot*> sbl;
if (ActionableBots::PopulateSBL(c, sep->arg[ab_arg], sbl, ab_mask, !class_race_check ? sep->arg[ab_arg + 1] : nullptr, class_race_check ? atoi(sep->arg[ab_arg + 1]) : 0) == ActionableBots::ABT_None) {
return;
}
sbl.erase(std::remove(sbl.begin(), sbl.end(), nullptr), sbl.end());
Bot* first_found = nullptr;
int success_count = 0;
for (auto my_bot : sbl) {
if (my_bot->BotPassiveCheck()) {
continue;
}
if (!first_found) {
first_found = my_bot;
}
if (sync_sml) {
sml = my_bot->GetLevel();
}
if (reset_sml) {
sml = my_bot->GetDefaultBotBaseSetting(BotBaseSettings::StopMeleeLevel);
}
if (current_check) {
c->Message(
Chat::White,
fmt::format(
"{} says, 'My current stop melee level is {}.'",
my_bot->GetCleanName(),
my_bot->GetStopMeleeLevel()
).c_str()
);
continue;
}
else {
my_bot->SetStopMeleeLevel(sml);
++success_count;
}
}
if (!current_check) {
if (success_count == 1 && first_found) {
c->Message(
Chat::White,
fmt::format(
"{} says, 'My stop melee level was {} to {}.'",
first_found->GetCleanName(),
reset_sml ? "reset" : "set",
sml
).c_str()
);
}
else {
c->Message(
Chat::White,
fmt::format(
"{} of your bots {} their stop melee{}'", // level to {}.
success_count,
reset_sml ? "reset" : "set",
fmt::format("{}", reset_sml ? "." : fmt::format(" level to {}.", sml).c_str()).c_str(),
sml
).c_str()
);
}
}
}
void bot_command_summon(Client *c, const Seperator *sep)
{
if (helper_command_alias_fail(c, "bot_command_summon", sep->arg[0], "botsummon")) {
return;
}
if (helper_is_help_or_usage(sep->arg[1])) {
c->Message(Chat::White, "usage: %s ([actionable: target | byname | ownergroup | ownerraid | targetgroup | namesgroup | healrotationtargets | mmr | byclass | byrace | spawned] ([actionable_name]))", sep->arg[0]);
return;
}
const int ab_mask = ActionableBots::ABM_Type1;
std::string arg1 = sep->arg[1];
int ab_arg = 1;
std::string class_race_arg = sep->arg[ab_arg];
bool class_race_check = false;
if (!class_race_arg.compare("byclass") || !class_race_arg.compare("byrace")) {
class_race_check = true;
}
std::vector<Bot*> sbl;
if (ActionableBots::PopulateSBL(c, sep->arg[ab_arg], sbl, ab_mask, !class_race_check ? sep->arg[ab_arg + 1] : nullptr, class_race_check ? atoi(sep->arg[ab_arg + 1]) : 0) == ActionableBots::ABT_None) {
return;
}
sbl.erase(std::remove(sbl.begin(), sbl.end(), nullptr), sbl.end());
for (auto bot_iter : sbl) {
if (!bot_iter) {
continue;
}
bot_iter->WipeHateList();
bot_iter->SetTarget(nullptr);
bot_iter->Teleport(c->GetPosition());
bot_iter->DoAnim(0);
if (!bot_iter->HasPet()) {
continue;
}
bot_iter->GetPet()->WipeHateList();
bot_iter->GetPet()->SetTarget(nullptr);
bot_iter->GetPet()->Teleport(c->GetPosition());
}
if (sbl.size() == 1) {
c->Message(
Chat::White,
fmt::format(
"Summoned {} to you.",
sbl.front() ? sbl.front()->GetCleanName() : "no one"
).c_str()
);
}
else {
c->Message(
Chat::White,
fmt::format(
"Summoned {} bots to you.",
sbl.size()
).c_str()
);
}
}
void bot_command_toggle_ranged(Client *c, const Seperator *sep)
{
if (helper_command_alias_fail(c, "bot_command_toggle_ranged", sep->arg[0], "bottoggleranged")) {
c->Message(Chat::White, "note: Toggles a ranged bot between melee and ranged weapon use.");
return;
}
if (helper_is_help_or_usage(sep->arg[1])) {
BotCommandHelpParams p;
p.description = { "Toggles a ranged bot between melee and ranged weapon use." };
p.example_format = { fmt::format("{} [value] [actionable]", sep->arg[0]) };
p.examples_one =
{
"To set BotA to use their ranged:",
fmt::format(
"{} 1 byname BotA",
sep->arg[0]
)
};
p.examples_two =
{
"To set all ranger bots to ranged:",
fmt::format(
"{} 1 byclass {}",
sep->arg[0],
Class::Ranger
)
};
p.examples_two =
{
"To check the ranged status of all bots:",
fmt::format(
"{} current spawned",
sep->arg[0],
Class::Ranger
)
};
p.actionables = { "target, byname, ownergroup, ownerraid, targetgroup, namesgroup, healrotationtargets, mmr, byclass, byrace, spawned" };
std::string popup_text = c->SendBotCommandHelpWindow(p);
popup_text = DialogueWindow::Table(popup_text);
c->SendPopupToClient(sep->arg[0], popup_text.c_str());
if (RuleB(Bots, SendClassRaceOnHelp)) {
c->Message(
Chat::Yellow,
fmt::format(
"Use {} for information about race/class IDs.",
Saylink::Silent("^classracelist")
).c_str()
);
}
return;
}
std::string arg1 = sep->arg[1];
int ab_arg = 1;
bool current_check = false;
uint32 type_value = 0;
if (sep->IsNumber(1)) {
type_value = atoi(sep->arg[1]);
++ab_arg;
if (type_value < 0 || type_value > 1) {
c->Message(Chat::Yellow, "You must enter either 0 for disabled or 1 for enabled.");
return;
}
}
else if (!arg1.compare("current")) {
++ab_arg;
current_check = true;
}
else {
c->Message(
Chat::Yellow,
fmt::format(
"Incorrect argument, use {} for information regarding this command.",
Saylink::Silent(
fmt::format("{} help", sep->arg[0])
)
).c_str()
);
return;
}
const int ab_mask = ActionableBots::ABM_Type1;
std::string class_race_arg = sep->arg[ab_arg];
bool class_race_check = false;
if (!class_race_arg.compare("byclass") || !class_race_arg.compare("byrace")) {
class_race_check = true;
}
std::vector<Bot*> sbl;
if (ActionableBots::PopulateSBL(c, sep->arg[ab_arg], sbl, ab_mask, !class_race_check ? sep->arg[ab_arg + 1] : nullptr, class_race_check ? atoi(sep->arg[ab_arg + 1]) : 0) == ActionableBots::ABT_None) {
return;
}
sbl.erase(std::remove(sbl.begin(), sbl.end(), nullptr), sbl.end());
Bot* first_found = nullptr;
int success_count = 0;
for (auto my_bot : sbl) {
if (my_bot->BotPassiveCheck()) {
continue;
}
if (current_check) {
c->Message(
Chat::Green,
fmt::format(
"{} says, 'I {} currently ranged.'",
my_bot->GetCleanName(),
my_bot->IsBotRanged() ? "am" : "am no longer"
).c_str()
);
}
else {
if (my_bot->GetBotRangedValue() < RuleI(Combat, MinRangedAttackDist)) {
c->Message(Chat::Yellow, "%s does not have proper weapons or ammo to be at range.", my_bot->GetCleanName());
continue;
}
if (!first_found) {
first_found = my_bot;
}
my_bot->SetBotRangedSetting(type_value);
my_bot->ChangeBotRangedWeapons(my_bot->IsBotRanged());
++success_count;
}
}
if (!current_check) {
if (success_count == 1 && first_found) {
c->Message(
Chat::Green,
fmt::format(
"{} says, 'I {} ranged.'",
first_found->GetCleanName(),
first_found->IsBotRanged() ? "am now" : "am no longer"
).c_str()
);
}
else {
c->Message(
Chat::Green,
fmt::format(
"{} of your bots {} ranged.",
success_count,
type_value ? "are now" : "are no longer"
).c_str()
);
}
}
}
void bot_command_toggle_helm(Client *c, const Seperator *sep)
{
if (helper_command_alias_fail(c, "bot_command_toggle_helm", sep->arg[0], "bottogglehelm")) {
c->Message(Chat::White, "note: Toggles whether or not bots will show their helm.");
return;
}
if (helper_is_help_or_usage(sep->arg[1])) {
BotCommandHelpParams p;
p.description = { "Toggles whether or not bots will show their helm." };
p.example_format = { fmt::format("{} [value] [actionable]", sep->arg[0]) };
p.examples_one =
{
"To set BotA to show their helm:",
fmt::format(
"{} 1 byname BotA",
sep->arg[0]
)
};
p.examples_two =
{
"To set all bots to show their helm:",
fmt::format(
"{} 1 spawned",
sep->arg[0]
)
};
p.examples_three =
{
"To check the toggle helm status of all bots:",
fmt::format(
"{} current spawned",
sep->arg[0]
)
};
p.actionables = { "target, byname, ownergroup, ownerraid, targetgroup, namesgroup, healrotationtargets, mmr, byclass, byrace, spawned" };
std::string popup_text = c->SendBotCommandHelpWindow(p);
popup_text = DialogueWindow::Table(popup_text);
c->SendPopupToClient(sep->arg[0], popup_text.c_str());
if (RuleB(Bots, SendClassRaceOnHelp)) {
c->Message(
Chat::Yellow,
fmt::format(
"Use {} for information about race/class IDs.",
Saylink::Silent("^classracelist")
).c_str()
);
}
return;
}
std::string arg1 = sep->arg[1];
int ab_arg = 1;
bool current_check = false;
uint32 type_value = 0;
if (sep->IsNumber(1)) {
type_value = atoi(sep->arg[1]);
++ab_arg;
if (type_value < 0 || type_value > 1) {
c->Message(Chat::Yellow, "You must enter either 0 for disabled or 1 for enabled.");
return;
}
}
else if (!arg1.compare("current")) {
++ab_arg;
current_check = true;
}
else {
c->Message(
Chat::Yellow,
fmt::format(
"Incorrect argument, use {} for information regarding this command.",
Saylink::Silent(
fmt::format("{} help", sep->arg[0])
)
).c_str()
);
return;
}
const int ab_mask = ActionableBots::ABM_Type1;
std::string class_race_arg = sep->arg[ab_arg];
bool class_race_check = false;
if (!class_race_arg.compare("byclass") || !class_race_arg.compare("byrace")) {
class_race_check = true;
}
std::vector<Bot*> sbl;
if (ActionableBots::PopulateSBL(c, sep->arg[ab_arg], sbl, ab_mask, !class_race_check ? sep->arg[ab_arg + 1] : nullptr, class_race_check ? atoi(sep->arg[ab_arg + 1]) : 0) == ActionableBots::ABT_None) {
return;
}
sbl.erase(std::remove(sbl.begin(), sbl.end(), nullptr), sbl.end());
Bot* first_found = nullptr;
int success_count = 0;
for (auto my_bot : sbl) {
if (my_bot->BotPassiveCheck()) {
continue;
}
if (!first_found) {
first_found = my_bot;
}
if (current_check) {
c->Message(
Chat::Green,
fmt::format(
"{} says, 'I {} show my helm.'",
my_bot->GetCleanName(),
my_bot->GetShowHelm() ? "will" : "will not"
).c_str()
);
}
else {
my_bot->SetShowHelm(type_value);
auto outapp = new EQApplicationPacket(OP_SpawnAppearance, sizeof(SpawnAppearance_Struct));
SpawnAppearance_Struct* saptr = (SpawnAppearance_Struct*) outapp->pBuffer;
saptr->spawn_id = my_bot->GetID();
saptr->type = AppearanceType::ShowHelm;
saptr->parameter = my_bot->GetShowHelm();
entity_list.QueueClients(my_bot, outapp, true);
safe_delete(outapp);
++success_count;
}
}
if (!current_check) {
if (success_count == 1 && first_found) {
c->Message(
Chat::Green,
fmt::format(
"{} says, 'I {} show my helm.'",
first_found->GetCleanName(),
first_found->GetShowHelm() ? "will now" : "will no longer"
).c_str()
);
}
else {
c->Message(
Chat::Green,
fmt::format(
"{} of your bots {} show their helm.",
success_count,
type_value ? "will now" : "will no longer"
).c_str()
);
}
}
// Notes:
/*
[CLIENT OPCODE TEST]
[10-16-2015 :: 14:57:56] [Packet :: Client -> Server (Dump)] [OP_SpawnAppearance - 0x01d1] [Size: 10]
0: A4 02 [2B 00] 01 00 00 00 - showhelm = true (client)
[10-16-2015 :: 14:57:56] [Packet :: Server -> Client (Dump)] [OP_SpawnAppearance - 0x01d1] [Size: 10]
0: A4 02 [2B 00] 01 00 00 00 - showhelm = true (client)
[10-16-2015 :: 14:58:02] [Packet :: Client -> Server (Dump)] [OP_SpawnAppearance - 0x01d1] [Size: 10]
0: A4 02 [2B 00] 00 00 00 00 - showhelm = false (client)
[10-16-2015 :: 14:58:02] [Packet :: Server -> Client (Dump)] [OP_SpawnAppearance - 0x01d1] [Size: 10]
0: A4 02 [2B 00] 00 00 00 00 - showhelm = false (client)
[BOT OPCODE TEST]
[10-16-2015 :: 22:15:34] [Packet :: Client -> Server (Dump)] [OP_ChannelMessage - 0x0045] [Size: 167]
0: 43 6C 65 72 69 63 62 6F - 74 00 00 00 00 00 00 00 | Clericbot.......
16: 00 00 00 00 00 00 00 00 - 00 00 00 00 00 00 00 00 | ................
32: 00 00 00 00 00 00 00 00 - 00 00 00 00 00 00 00 00 | ................
48: 00 00 00 00 00 00 00 00 - 00 00 00 00 00 00 00 00 | ................
64: 43 6C 65 72 69 63 62 6F - 74 00 00 00 00 00 00 00 | Clericbot.......
80: 00 00 00 00 00 00 00 00 - 00 00 00 00 00 00 00 00 | ................
96: 00 00 00 00 00 00 00 00 - 00 00 00 00 00 00 00 00 | ................
112: 00 00 00 00 00 00 00 00 - 00 00 00 00 00 00 00 00 | ................
128: 00 00 00 00 08 00 00 00 - CD CD CD CD CD CD CD CD | ................
144: 64 00 00 00 23 62 6F 74 - 20 73 68 6F 77 68 65 6C | d...#bot showhel
160: 6D 20 6F 6E 00 | m on.
[10-16-2015 :: 22:15:34] [Packet :: Server -> Client (Dump)] [OP_SpawnAppearance - 0x01d1] [Size: 10]
0: A2 02 2B 00 01 00 00 00 - showhelm = true
[10-16-2015 :: 22:15:40] [Packet :: Client -> Server (Dump)] [OP_ChannelMessage - 0x0045] [Size: 168]
0: 43 6C 65 72 69 63 62 6F - 74 00 00 00 00 00 00 00 | Clericbot.......
16: 00 00 00 00 00 00 00 00 - 00 00 00 00 00 00 00 00 | ................
32: 00 00 00 00 00 00 00 00 - 00 00 00 00 00 00 00 00 | ................
48: 00 00 00 00 00 00 00 00 - 00 00 00 00 00 00 00 00 | ................
64: 43 6C 65 72 69 63 62 6F - 74 00 00 00 00 00 00 00 | Clericbot.......
80: 00 00 00 00 00 00 00 00 - 00 00 00 00 00 00 00 00 | ................
96: 00 00 00 00 00 00 00 00 - 00 00 00 00 00 00 00 00 | ................
112: 00 00 00 00 00 00 00 00 - 00 00 00 00 00 00 00 00 | ................
128: 00 00 00 00 08 00 00 00 - CD CD CD CD CD CD CD CD | ................
144: 64 00 00 00 23 62 6F 74 - 20 73 68 6F 77 68 65 6C | d...#bot showhel
160: 6D 20 6F 66 66 00 | m off.
[10-16-2015 :: 22:15:40] [Packet :: Server -> Client (Dump)] [OP_SpawnAppearance - 0x01d1] [Size: 10]
0: A2 02 2B 00 00 00 00 00 - showhelm = false
*** Bot did not update using the OP_SpawnAppearance packet with AppearanceType::ShowHelm appearance type ***
*/
}
void bot_command_update(Client *c, const Seperator *sep)
{
if (helper_command_alias_fail(c, "bot_command_update", sep->arg[0], "botupdate"))
return;
if (helper_is_help_or_usage(sep->arg[1])) {
c->Message(Chat::White, "usage: %s", sep->arg[0]);
return;
}
std::vector<Bot*> sbl;
MyBots::PopulateSBL_BySpawnedBots(c, sbl);
if (sbl.empty()) {
c->Message(Chat::White, "You currently have no spawned bots");
return;
}
int bot_count = 0;
for (auto bot_iter : sbl) {
if (!bot_iter || bot_iter->IsEngaged() || bot_iter->GetLevel() == c->GetLevel())
continue;
bot_iter->CalcBotStats(c->GetBotOption(Client::booStatsUpdate));
bot_iter->SendAppearancePacket(AppearanceType::WhoLevel, bot_iter->GetLevel(), true, true);
++bot_count;
}
c->Message(Chat::White, "Updated %i of your %i spawned bots", bot_count, sbl.size());
}
Reference in New Issue View Git Blame Copy Permalink