mirror of
https://github.com/EQEmu/Server.git
synced 2025-12-11 21:01:29 +00:00
6297c56db2
# Notes - Separate all bot commands into individual files like regular commands. # Images
571 lines
12 KiB
C++
571 lines
12 KiB
C++
#include "../bot_command.h"
|
|
|
|
void bot_command_spell_list(Client* c, const Seperator *sep)
|
|
{
|
|
if (helper_command_alias_fail(c, "bot_command_spell_list", sep->arg[0], "spells")) {
|
|
return;
|
|
}
|
|
|
|
if (helper_is_help_or_usage(sep->arg[1])) {
|
|
c->Message(
|
|
Chat::White,
|
|
fmt::format(
|
|
"Usage: {} [Min Level] (Level is optional)",
|
|
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;
|
|
}
|
|
|
|
uint8 min_level = 0;
|
|
|
|
if (sep->IsNumber(1)) {
|
|
min_level = static_cast<uint8>(Strings::ToUnsignedInt(sep->arg[1]));
|
|
}
|
|
|
|
my_bot->ListBotSpells(min_level);
|
|
}
|
|
|
|
void bot_command_spell_settings_add(Client *c, const Seperator *sep)
|
|
{
|
|
if (helper_command_alias_fail(c, "bot_command_spell_settings_add", sep->arg[0], "spellsettingsadd")) {
|
|
return;
|
|
}
|
|
|
|
if (helper_is_help_or_usage(sep->arg[1])) {
|
|
c->Message(
|
|
Chat::White,
|
|
fmt::format(
|
|
"Usage: {} [Spell ID] [Priority] [Min HP] [Max HP]",
|
|
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;
|
|
}
|
|
|
|
auto arguments = sep->argnum;
|
|
if (
|
|
arguments < 4 ||
|
|
!sep->IsNumber(1) ||
|
|
!sep->IsNumber(2) ||
|
|
!sep->IsNumber(3) ||
|
|
!sep->IsNumber(4)
|
|
) {
|
|
c->Message(
|
|
Chat::White,
|
|
fmt::format(
|
|
"Usage: {} [Spell ID] [Priority] [Min HP] [Max HP]",
|
|
sep->arg[0]
|
|
).c_str()
|
|
);
|
|
return;
|
|
}
|
|
|
|
auto spell_id = static_cast<uint16>(Strings::ToUnsignedInt(sep->arg[1]));
|
|
|
|
if (!IsValidSpell(spell_id)) {
|
|
c->Message(
|
|
Chat::White,
|
|
fmt::format(
|
|
"Spell ID {} is invalid or could not be found.",
|
|
spell_id
|
|
).c_str()
|
|
);
|
|
return;
|
|
}
|
|
|
|
if (my_bot->GetBotSpellSetting(spell_id)) {
|
|
c->Message(
|
|
Chat::White,
|
|
fmt::format(
|
|
"{} already has a spell setting for {} ({}), trying using {} instead.",
|
|
my_bot->GetCleanName(),
|
|
spells[spell_id].name,
|
|
spell_id,
|
|
Saylink::Silent("^spellsettingsupdate")
|
|
).c_str()
|
|
);
|
|
return;
|
|
}
|
|
|
|
auto priority = static_cast<int16>(Strings::ToInt(sep->arg[2]));
|
|
auto min_hp = static_cast<int8>(EQ::Clamp(Strings::ToInt(sep->arg[3]), -1, 99));
|
|
auto max_hp = static_cast<int8>(EQ::Clamp(Strings::ToInt(sep->arg[4]), -1, 100));
|
|
|
|
BotSpellSetting bs;
|
|
|
|
bs.priority = priority;
|
|
bs.min_hp = min_hp;
|
|
bs.max_hp = max_hp;
|
|
|
|
if (!my_bot->AddBotSpellSetting(spell_id, &bs)) {
|
|
c->Message(
|
|
Chat::White,
|
|
fmt::format(
|
|
"Failed to add spell setting for {}.",
|
|
my_bot->GetCleanName()
|
|
).c_str()
|
|
);
|
|
return;
|
|
}
|
|
|
|
my_bot->AI_AddBotSpells(my_bot->GetBotSpellID());
|
|
|
|
c->Message(
|
|
Chat::White,
|
|
fmt::format(
|
|
"Successfully added spell setting for {}.",
|
|
my_bot->GetCleanName()
|
|
).c_str()
|
|
);
|
|
|
|
c->Message(
|
|
Chat::White,
|
|
fmt::format(
|
|
"Spell Setting Added | Spell: {} ({}) ",
|
|
spells[spell_id].name,
|
|
spell_id
|
|
).c_str()
|
|
);
|
|
|
|
c->Message(
|
|
Chat::White,
|
|
fmt::format(
|
|
"Spell Setting Added | Priority: {} Health: {}",
|
|
priority,
|
|
my_bot->GetHPString(min_hp, max_hp)
|
|
).c_str()
|
|
);
|
|
}
|
|
|
|
void bot_command_spell_settings_delete(Client *c, const Seperator *sep)
|
|
{
|
|
if (helper_command_alias_fail(c, "bot_command_spell_settings_delete", sep->arg[0], "spellsettingsdelete")) {
|
|
return;
|
|
}
|
|
|
|
if (helper_is_help_or_usage(sep->arg[1])) {
|
|
c->Message(
|
|
Chat::White,
|
|
fmt::format(
|
|
"Usage: {} [Spell ID]",
|
|
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;
|
|
}
|
|
|
|
auto arguments = sep->argnum;
|
|
if (
|
|
arguments < 1 ||
|
|
!sep->IsNumber(1)
|
|
) {
|
|
c->Message(
|
|
Chat::White,
|
|
fmt::format(
|
|
"Usage: {} [Spell ID]",
|
|
sep->arg[0]
|
|
).c_str()
|
|
);
|
|
return;
|
|
}
|
|
|
|
auto spell_id = static_cast<uint16>(Strings::ToUnsignedInt(sep->arg[1]));
|
|
|
|
if (!IsValidSpell(spell_id)) {
|
|
c->Message(
|
|
Chat::White,
|
|
fmt::format(
|
|
"Spell ID {} is invalid or could not be found.",
|
|
spell_id
|
|
).c_str()
|
|
);
|
|
return;
|
|
}
|
|
|
|
if (!my_bot->DeleteBotSpellSetting(spell_id)) {
|
|
c->Message(
|
|
Chat::White,
|
|
fmt::format(
|
|
"Failed to delete spell setting for {}.",
|
|
my_bot->GetCleanName()
|
|
).c_str()
|
|
);
|
|
return;
|
|
}
|
|
|
|
my_bot->AI_AddBotSpells(my_bot->GetBotSpellID());
|
|
|
|
c->Message(
|
|
Chat::White,
|
|
fmt::format(
|
|
"Successfully deleted spell setting for {}.",
|
|
my_bot->GetCleanName()
|
|
).c_str()
|
|
);
|
|
|
|
c->Message(
|
|
Chat::White,
|
|
fmt::format(
|
|
"Spell Setting Deleted | Spell: {} ({})",
|
|
spells[spell_id].name,
|
|
spell_id
|
|
).c_str()
|
|
);
|
|
}
|
|
|
|
void bot_command_spell_settings_list(Client *c, const Seperator *sep)
|
|
{
|
|
if (helper_command_alias_fail(c, "bot_command_spell_settings_list", sep->arg[0], "spellsettings")) {
|
|
return;
|
|
}
|
|
|
|
if (helper_is_help_or_usage(sep->arg[1])) {
|
|
c->Message(
|
|
Chat::White,
|
|
fmt::format(
|
|
"Usage: {}",
|
|
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;
|
|
}
|
|
|
|
my_bot->ListBotSpellSettings();
|
|
}
|
|
|
|
void bot_command_spell_settings_toggle(Client *c, const Seperator *sep)
|
|
{
|
|
if (helper_command_alias_fail(c, "bot_command_spell_settings_toggle", sep->arg[0], "spellsettingstoggle")) {
|
|
return;
|
|
}
|
|
|
|
if (helper_is_help_or_usage(sep->arg[1])) {
|
|
c->Message(
|
|
Chat::White,
|
|
fmt::format(
|
|
"Usage: {} [Spell ID] [Toggle]",
|
|
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;
|
|
}
|
|
|
|
auto arguments = sep->argnum;
|
|
if (
|
|
arguments < 2 ||
|
|
!sep->IsNumber(1)
|
|
) {
|
|
c->Message(
|
|
Chat::White,
|
|
fmt::format(
|
|
"Usage: {} [Spell ID] [Toggle]",
|
|
sep->arg[0]
|
|
).c_str()
|
|
);
|
|
return;
|
|
}
|
|
|
|
auto spell_id = static_cast<uint16>(Strings::ToUnsignedInt(sep->arg[1]));
|
|
if (!IsValidSpell(spell_id)) {
|
|
c->Message(
|
|
Chat::White,
|
|
fmt::format(
|
|
"Spell ID {} is invalid or could not be found.",
|
|
spell_id
|
|
).c_str()
|
|
);
|
|
return;
|
|
}
|
|
|
|
bool toggle = (
|
|
sep->IsNumber(2) ?
|
|
Strings::ToInt(sep->arg[2]) != 0 :
|
|
atobool(sep->arg[2])
|
|
);
|
|
|
|
auto obs = my_bot->GetBotSpellSetting(spell_id);
|
|
if (!obs) {
|
|
return;
|
|
}
|
|
|
|
BotSpellSetting bs;
|
|
|
|
bs.priority = obs->priority;
|
|
bs.min_hp = obs->min_hp;
|
|
bs.max_hp = obs->max_hp;
|
|
bs.is_enabled = toggle;
|
|
|
|
if (!my_bot->UpdateBotSpellSetting(spell_id, &bs)) {
|
|
c->Message(
|
|
Chat::White,
|
|
fmt::format(
|
|
"Failed to {}able spell for {}.",
|
|
toggle ? "en" : "dis",
|
|
my_bot->GetCleanName()
|
|
).c_str()
|
|
);
|
|
return;
|
|
}
|
|
|
|
my_bot->AI_AddBotSpells(my_bot->GetBotSpellID());
|
|
|
|
c->Message(
|
|
Chat::White,
|
|
fmt::format(
|
|
"Successfully {}abled spell for {}.",
|
|
toggle ? "en" : "dis",
|
|
my_bot->GetCleanName()
|
|
).c_str()
|
|
);
|
|
|
|
c->Message(
|
|
Chat::White,
|
|
fmt::format(
|
|
"Spell {}abled | Spell: {} ({})",
|
|
toggle ? "En" : "Dis",
|
|
spells[spell_id].name,
|
|
spell_id
|
|
).c_str()
|
|
);
|
|
}
|
|
|
|
void bot_command_spell_settings_update(Client *c, const Seperator *sep)
|
|
{
|
|
if (helper_command_alias_fail(c, "bot_command_spell_settings_update", sep->arg[0], "spellsettingsupdate")) {
|
|
return;
|
|
}
|
|
|
|
if (helper_is_help_or_usage(sep->arg[1])) {
|
|
c->Message(
|
|
Chat::White,
|
|
fmt::format(
|
|
"Usage: {} [Spell ID] [Priority] [Min HP] [Max HP]",
|
|
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;
|
|
}
|
|
|
|
auto arguments = sep->argnum;
|
|
if (
|
|
arguments < 4 ||
|
|
!sep->IsNumber(1) ||
|
|
!sep->IsNumber(2) ||
|
|
!sep->IsNumber(3) ||
|
|
!sep->IsNumber(4)
|
|
) {
|
|
c->Message(
|
|
Chat::White,
|
|
fmt::format(
|
|
"Usage: {} [Spell ID] [Priority] [Min HP] [Max HP]",
|
|
sep->arg[0]
|
|
).c_str()
|
|
);
|
|
return;
|
|
}
|
|
|
|
auto spell_id = static_cast<uint16>(Strings::ToUnsignedInt(sep->arg[1]));
|
|
|
|
if (!IsValidSpell(spell_id)) {
|
|
c->Message(
|
|
Chat::White,
|
|
fmt::format(
|
|
"Spell ID {} is invalid or could not be found.",
|
|
spell_id
|
|
).c_str()
|
|
);
|
|
return;
|
|
}
|
|
|
|
auto priority = static_cast<int16>(Strings::ToInt(sep->arg[2]));
|
|
auto min_hp = static_cast<int8>(EQ::Clamp(Strings::ToInt(sep->arg[3]), -1, 99));
|
|
auto max_hp = static_cast<int8>(EQ::Clamp(Strings::ToInt(sep->arg[4]), -1, 100));
|
|
|
|
BotSpellSetting bs;
|
|
|
|
bs.priority = priority;
|
|
bs.min_hp = min_hp;
|
|
bs.max_hp = max_hp;
|
|
|
|
if (!my_bot->UpdateBotSpellSetting(spell_id, &bs)) {
|
|
c->Message(
|
|
Chat::White,
|
|
fmt::format(
|
|
"Failed to update spell setting for {}.",
|
|
my_bot->GetCleanName()
|
|
).c_str()
|
|
);
|
|
return;
|
|
}
|
|
|
|
my_bot->AI_AddBotSpells(my_bot->GetBotSpellID());
|
|
|
|
c->Message(
|
|
Chat::White,
|
|
fmt::format(
|
|
"Successfully updated spell setting for {}.",
|
|
my_bot->GetCleanName()
|
|
).c_str()
|
|
);
|
|
|
|
c->Message(
|
|
Chat::White,
|
|
fmt::format(
|
|
"Spell Setting Updated | Spell: {} ({})",
|
|
spells[spell_id].name,
|
|
spell_id
|
|
).c_str()
|
|
);
|
|
|
|
c->Message(
|
|
Chat::White,
|
|
fmt::format(
|
|
"Spell Setting Updated | Priority: {} Health: {}",
|
|
priority,
|
|
my_bot->GetHPString(min_hp, max_hp)
|
|
).c_str()
|
|
);
|
|
}
|
|
|
|
void bot_spell_info_dialogue_window(Client* c, const Seperator *sep)
|
|
{
|
|
if (helper_command_alias_fail(c, "bot_spell_info_dialogue_window", sep->arg[0], "spellinfo")) {
|
|
return;
|
|
}
|
|
|
|
auto arguments = sep->argnum;
|
|
if (
|
|
arguments < 1 ||
|
|
!sep->IsNumber(1)
|
|
) {
|
|
c->Message(
|
|
Chat::White,
|
|
fmt::format(
|
|
"Usage: {} [Spell ID]",
|
|
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;
|
|
}
|
|
|
|
auto spell_id = static_cast<uint16>(Strings::ToUnsignedInt(sep->arg[1]));
|
|
auto min_level = spells[spell_id].classes;
|
|
auto class_level = min_level[my_bot->GetBotClass() - 1];
|
|
|
|
if (class_level > my_bot->GetLevel()) {
|
|
c->Message(Chat::White, "This is not a usable spell by your bot.");
|
|
return;
|
|
}
|
|
|
|
auto results = database.QueryDatabase(
|
|
fmt::format(
|
|
"SELECT value FROM db_str WHERE id = {} and type = 6 LIMIT 1",
|
|
spells[spell_id].effect_description_id
|
|
)
|
|
);
|
|
|
|
if (!results.Success() || !results.RowCount()) {
|
|
c->Message(Chat::White, "No Spell Information Available for this.");
|
|
return;
|
|
}
|
|
|
|
auto row = results.begin();
|
|
std::string spell_desc = row[0];
|
|
|
|
auto m = DialogueWindow::TableRow(
|
|
DialogueWindow::TableCell("Spell Effect: ") +
|
|
DialogueWindow::TableCell(spell_desc)
|
|
);
|
|
|
|
m += DialogueWindow::TableRow(
|
|
DialogueWindow::TableCell("Spell Level: ") +
|
|
DialogueWindow::TableCell(fmt::format("{}", class_level))
|
|
);
|
|
|
|
c->SendPopupToClient(
|
|
fmt::format(
|
|
"Spell: {}", spells[spell_id].name
|
|
).c_str(),
|
|
DialogueWindow::Table(m).c_str()
|
|
);
|
|
}
|
|
|
|
void bot_command_enforce_spell_list(Client* c, const Seperator *sep)
|
|
{
|
|
if (helper_command_alias_fail(c, "bot_command_enforce_spell_list", sep->arg[0], "enforcespellsettings")) {
|
|
return;
|
|
}
|
|
|
|
if (helper_is_help_or_usage(sep->arg[1])) {
|
|
c->Message(
|
|
Chat::White,
|
|
fmt::format(
|
|
"Usage: {} [True|False] (Blank to toggle]",
|
|
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;
|
|
}
|
|
|
|
bool enforce_state = (sep->argnum > 0) ? Strings::ToBool(sep->arg[1]) : !my_bot->GetBotEnforceSpellSetting();
|
|
my_bot->SetBotEnforceSpellSetting(enforce_state, true);
|
|
|
|
c->Message(
|
|
Chat::White,
|
|
fmt::format(
|
|
"{}'s Spell Settings List entries are now {}.",
|
|
my_bot->GetCleanName(),
|
|
my_bot->GetBotEnforceSpellSetting() ? "enforced" : "optional"
|
|
).c_str()
|
|
);
|
|
}
|