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
eqemu-server/zone/bot_command.h
nytmyr bdf5f8b4a3
[Bots] [Quest API] Add ^clickitem, ^timer, fix GetBestBotSpellForCure (#3755) 
* [Bots][Quest API] Add ^clickitem, ^timer, revamp bot timers, fix GetBestBotSpellForCure

This adds the command **^clickitem** for bots.
Bots can click items they are wearing with the provided slot ID, players can use **^invlist** on their bots to see items and slot IDs.
This supports actionables.
**^itemclick 13 byclass 11** would command all Necromancer bots to attempt to click their Primary item.

This adds and supports charges for items to bots, when an item is used, it will lose a charge and cannot be clicked once no charges remain.

This adds the following rules:
**Bots, BotsClickItemsMinLvl** - Minimum level bots can use **^clickitem**.
**Bots, BotsCanClickItems** - Whether or not **^clickitem** is allowed for bots.
**Bots, CanClickMageEpicV1** - Whether or not players are allowed to command their bots to use the Magician Epic 1.0

This adds quest methods to Perl/Lua for:
ClearDisciplineReuseTimer, ClearItemReuseTimer, ClearSpellRecastTimer
GetDisciplineReuseTimer, GetItemReuseTimer, GetSpellRecastTimer
SetDisciplineReuseTimer, SetItemReuseTimer, SetSpellRecastTimer

Discipline and Spell methods use the spell_id to check, get and set. Item uses the item_id.
Clear and Get support wildcards (no spell/item id) to clear all timers of the type or get the first timer of the type.
Get will return the remaining time on the chosen timer, if any.
Set supports a wildcard (no recast/reuse provided) to use the default of the provided type, you can also specify a recast/reuse timer to set that timer to the chosen value.

**^timer** has been added as a bot command, defaulted for GM access.
This can be used to set, get and clear timers of different types. Use **^timer help** for info.

This revamps the way timers are set, stored, loaded for bots.

**GetBestBotSpellForCure** was previously checking only the first spell found and not properly iterating through the checks.

This requires modifications to the **bot_timers** table and is included in this commit.

* Rebase Conflicts

* Update queries to use repositories

* Minor adjustment

* Formatting

* Handle delete as well

* Cleanup.

* Adjust primary keys to prevent conflicts

---------

Co-authored-by: Akkadius <akkadius1@gmail.com>
Co-authored-by: Kinglykrab <kinglykrab@gmail.com>
2023-12-17 14:53:34 -05:00

686 lines
23 KiB
C++
Raw Blame History

/* EQEMu: Everquest Server Emulator
Copyright (C) 2001-2016 EQEMu Development Team (http://eqemulator.org)
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY except by those people which sell it, which
are required to give you total support for your newly bought product;
without even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef BOT_COMMAND_H
#define BOT_COMMAND_H
class Client;
class Seperator;
#include "../common/types.h"
#include "bot.h"
class BCEnum
{
public:
typedef enum SpellType {
SpT_None = 0,
SpT_BindAffinity,
SpT_Charm,
SpT_Cure,
SpT_Depart,
SpT_Escape,
SpT_Identify,
SpT_Invisibility,
SpT_Levitation,
SpT_Lull,
SpT_Mesmerize,
SpT_MovementSpeed,
SpT_Resistance,
SpT_Resurrect,
SpT_Rune,
SpT_SendHome,
SpT_Size,
SpT_Stance,
SpT_SummonCorpse,
SpT_WaterBreathing
} SpType;
static const int SpellTypeFirst = SpT_BindAffinity;
static const int SpellTypeLast = SpT_WaterBreathing;
typedef enum TargetType {
TT_None = 0,
TT_Corpse,
TT_Self,
TT_Animal,
TT_Undead,
TT_Summoned,
TT_Plant,
TT_Single,
TT_GroupV1,
TT_GroupV2,
TT_AECaster,
TT_AEBard,
TT_AETarget
} TType;
static const int TargetTypeFirst = TT_Corpse;
static const int TargetTypeLast = TT_AETarget;
static const int TargetTypeCount = 13;
typedef enum TargetMask {
TM_None = 0,
TM_Corpse = 1,
TM_Self = 2,
TM_Animal = 4,
TM_Undead = 8,
TM_Summoned = 16,
TM_Plant = 32,
TM_Single = 124, // currently, 2^6 + 2^{2..5}) -or- (64+32+16+8+4)
TM_GroupV1 = 128,
TM_GroupV2 = 256,
TM_AECaster = 512,
TM_AEBard = 1024,
TM_AETarget = 2048
} TMask;
typedef enum AppearanceFailType {
AFT_None = 0,
AFT_Value,
AFT_GenderRace,
AFT_Race
} AFType;
typedef enum AilmentType {
AT_None = 0,
AT_Blindness, // SE: 20
AT_Disease, // SE: 35
AT_Poison, // SE: 36
AT_Curse, // SE: 116
AT_Corruption // SE: 369
} AType;
static const int AilmentTypeCount = 5;
typedef enum InvisType {
IT_None = 0,
IT_Animal,
IT_Undead,
IT_Living,
IT_See
} IType;
typedef enum ResistanceType {
RT_None = 0,
RT_Fire, // SE: 46
RT_Cold, // SE: 47
RT_Poison, // SE: 48
RT_Disease, // SE: 49
RT_Magic, // SE: 50
RT_Corruption // SE: 370
} RType;
static const int ResistanceTypeCount = 6;
typedef enum SizeType {
SzT_None = 0,
SzT_Enlarge,
SzT_Reduce
} SzType;
typedef enum StanceType {
StT_None = 0,
StT_Aggressive,
StT_Defensive
} StType;
static std::string SpellTypeEnumToString(BCEnum::SpType spell_type) {
switch (spell_type) {
case SpT_BindAffinity:
return "SpT_BindAffinity";
case SpT_Charm:
return "SpT_Charm";
case SpT_Cure:
return "SpT_Cure";
case SpT_Depart:
return "SpT_Depart";
case SpT_Escape:
return "SpT_Escape";
case SpT_Identify:
return "SpT_Identify";
case SpT_Invisibility:
return "SpT_Invisibility";
case SpT_Levitation:
return "SpT_Levitation";
case SpT_Lull:
return "SpT_Lull";
case SpT_Mesmerize:
return "SpT_Mesmerize";
case SpT_MovementSpeed:
return "SpT_MovementSpeed";
case SpT_Resistance:
return "SpT_Resistance";
case SpT_Resurrect:
return "SpT_Resurrect";
case SpT_Rune:
return "SpT_Rune";
case SpT_SendHome:
return "SpT_SendHome";
case SpT_Size:
return "SpT_Size";
case SpT_Stance:
return "SpT_Stance";
case SpT_SummonCorpse:
return "SpT_SummonCorpse";
case SpT_WaterBreathing:
return "SpT_WaterBreathing";
default:
return "SpT_None";
}
}
static std::string TargetTypeEnumToString(BCEnum::TType target_type) {
switch (target_type) {
case TT_Self:
return "TT_Self";
case TT_Animal:
return "TT_Animal";
case TT_Undead:
return "TT_Undead";
case TT_Summoned:
return "TT_Summoned";
case TT_Plant:
return "TT_Plant";
case TT_Single:
return "TT_Single";
case TT_GroupV1:
return "TT_GroupV1";
case TT_GroupV2:
return "TT_GroupV2";
case TT_AECaster:
return "TT_AECaster";
case TT_AEBard:
return "TT_AEBard";
case TT_AETarget:
return "TT_AETarget";
case TT_Corpse:
return "TT_Corpse";
default:
return "TT_None";
}
}
};
class STBaseEntry;
class STCharmEntry;
class STCureEntry;
class STDepartEntry;
class STEscapeEntry;
class STInvisibilityEntry;
class STMovementSpeedEntry;
class STResistanceEntry;
class STResurrectEntry;
class STSendHomeEntry;
class STSizeEntry;
class STStanceEntry;
class STBaseEntry
{
protected:
BCEnum::SpType m_bcst;
public:
int spell_id;
uint8 spell_level;
uint8 caster_class;
BCEnum::TType target_type;
// A non-polymorphic constructor requires an appropriate, non-'ST_None' BCEnum::SType
STBaseEntry(BCEnum::SpType init_bcst = BCEnum::SpT_None) {
spell_id = 0;
spell_level = 255;
caster_class = 255;
target_type = BCEnum::TT_None;
m_bcst = init_bcst;
}
STBaseEntry(STBaseEntry* prototype) {
spell_id = prototype->spell_id;
spell_level = 255;
caster_class = 255;
target_type = prototype->target_type;
m_bcst = prototype->BCST();
}
virtual ~STBaseEntry() { return; };
BCEnum::SpType BCST() { return m_bcst; }
virtual bool IsDerived() { return false; }
bool IsCharm() const { return (m_bcst == BCEnum::SpT_Charm); }
bool IsCure() const { return (m_bcst == BCEnum::SpT_Cure); }
bool IsDepart() const { return (m_bcst == BCEnum::SpT_Depart); }
bool IsEscape() const { return (m_bcst == BCEnum::SpT_Escape); }
bool IsInvisibility() const { return (m_bcst == BCEnum::SpT_Invisibility); }
bool IsMovementSpeed() const { return (m_bcst == BCEnum::SpT_MovementSpeed); }
bool IsResistance() const { return (m_bcst == BCEnum::SpT_Resistance); }
bool IsResurrect() const { return (m_bcst == BCEnum::SpT_Resurrect); }
bool IsSendHome() const { return (m_bcst == BCEnum::SpT_SendHome); }
bool IsSize() const { return (m_bcst == BCEnum::SpT_Size); }
bool IsStance() const { return (m_bcst == BCEnum::SpT_Stance); }
virtual STCharmEntry* SafeCastToCharm() { return nullptr; }
virtual STCureEntry* SafeCastToCure() { return nullptr; }
virtual STDepartEntry* SafeCastToDepart() { return nullptr; }
virtual STEscapeEntry* SafeCastToEscape() { return nullptr; }
virtual STInvisibilityEntry* SafeCastToInvisibility() { return nullptr; }
virtual STMovementSpeedEntry* SafeCastToMovementSpeed() { return nullptr; }
virtual STResistanceEntry* SafeCastToResistance() { return nullptr; }
virtual STResurrectEntry* SafeCastToResurrect() { return nullptr; }
virtual STSendHomeEntry* SafeCastToSendHome() { return nullptr; }
virtual STSizeEntry* SafeCastToSize() { return nullptr; }
virtual STStanceEntry* SafeCastToStance() { return nullptr; }
};
class STCharmEntry : public STBaseEntry
{
public:
bool dire;
STCharmEntry() {
m_bcst = BCEnum::SpT_Charm;
dire = false;
}
STCharmEntry(STCharmEntry* prototype) : STBaseEntry(prototype) {
m_bcst = BCEnum::SpT_Charm;
dire = prototype->dire;
}
virtual ~STCharmEntry() { return; };
virtual bool IsDerived() { return true; }
virtual STCharmEntry* SafeCastToCharm() { return ((m_bcst == BCEnum::SpT_Charm) ? (static_cast<STCharmEntry*>(this)) : (nullptr)); }
};
class STCureEntry : public STBaseEntry
{
public:
int cure_value[BCEnum::AilmentTypeCount];
int cure_total;
STCureEntry() {
m_bcst = BCEnum::SpT_Cure;
memset(&cure_value, 0, (sizeof(int) * BCEnum::AilmentTypeCount));
cure_total = 0;
}
STCureEntry(STCureEntry* prototype) : STBaseEntry(prototype) {
m_bcst = BCEnum::SpT_Cure;
memcpy(&cure_value, prototype->cure_value, (sizeof(int) * BCEnum::AilmentTypeCount));
cure_total = prototype->cure_total;
}
virtual ~STCureEntry() { return; };
virtual bool IsDerived() { return true; }
virtual STCureEntry* SafeCastToCure() { return ((m_bcst == BCEnum::SpT_Cure) ? (static_cast<STCureEntry*>(this)) : (nullptr)); }
};
class STDepartEntry : public STBaseEntry
{
public:
bool single;
std::string long_name;
STDepartEntry() {
m_bcst = BCEnum::SpT_Depart;
single = false;
long_name.clear();
}
STDepartEntry(STDepartEntry* prototype) : STBaseEntry(prototype) {
m_bcst = BCEnum::SpT_Depart;
single = prototype->single;
long_name = prototype->long_name;
}
virtual ~STDepartEntry() { return; };
virtual bool IsDerived() { return true; }
virtual STDepartEntry* SafeCastToDepart() { return ((m_bcst == BCEnum::SpT_Depart) ? (static_cast<STDepartEntry*>(this)) : (nullptr)); }
};
class STEscapeEntry : public STBaseEntry
{
public:
bool lesser;
STEscapeEntry() {
m_bcst = BCEnum::SpT_Escape;
lesser = false;
}
STEscapeEntry(STEscapeEntry* prototype) : STBaseEntry(prototype) {
m_bcst = BCEnum::SpT_Escape;
lesser = prototype->lesser;
}
virtual ~STEscapeEntry() { return; };
virtual bool IsDerived() { return true; }
virtual STEscapeEntry* SafeCastToEscape() { return ((m_bcst == BCEnum::SpT_Escape) ? (static_cast<STEscapeEntry*>(this)) : (nullptr)); }
};
class STInvisibilityEntry : public STBaseEntry
{
public:
BCEnum::IType invis_type;
STInvisibilityEntry() {
m_bcst = BCEnum::SpT_Invisibility;
invis_type = BCEnum::IT_None;
}
STInvisibilityEntry(STInvisibilityEntry* prototype) : STBaseEntry(prototype) {
m_bcst = BCEnum::SpT_Invisibility;
invis_type = prototype->invis_type;
}
virtual ~STInvisibilityEntry() { return; };
virtual bool IsDerived() { return true; }
virtual STInvisibilityEntry* SafeCastToInvisibility() { return ((m_bcst == BCEnum::SpT_Invisibility) ? (static_cast<STInvisibilityEntry*>(this)) : (nullptr)); }
};
class STMovementSpeedEntry : public STBaseEntry
{
public:
bool group;
STMovementSpeedEntry() {
m_bcst = BCEnum::SpT_MovementSpeed;
group = false;
}
STMovementSpeedEntry(STMovementSpeedEntry* prototype) : STBaseEntry(prototype) {
m_bcst = BCEnum::SpT_MovementSpeed;
group = prototype->group;
}
virtual ~STMovementSpeedEntry() { return; };
virtual bool IsDerived() { return true; }
virtual STMovementSpeedEntry* SafeCastToMovementSpeed() { return ((m_bcst == BCEnum::SpT_MovementSpeed) ? (static_cast<STMovementSpeedEntry*>(this)) : (nullptr)); }
};
class STResistanceEntry : public STBaseEntry
{
public:
int resist_value[BCEnum::ResistanceTypeCount];
int resist_total;
STResistanceEntry() {
m_bcst = BCEnum::SpT_Resistance;
memset(&resist_value, 0, (sizeof(int) * BCEnum::ResistanceTypeCount));
resist_total = 0;
}
STResistanceEntry(STResistanceEntry* prototype) : STBaseEntry(prototype) {
m_bcst = BCEnum::SpT_Resistance;
memcpy(&resist_value, prototype->resist_value, (sizeof(int) * BCEnum::ResistanceTypeCount));
resist_total = prototype->resist_total;
}
virtual ~STResistanceEntry() { return; };
virtual bool IsDerived() { return true; }
virtual STResistanceEntry* SafeCastToResistance() { return ((m_bcst == BCEnum::SpT_Resistance) ? (static_cast<STResistanceEntry*>(this)) : (nullptr)); }
};
class STResurrectEntry : public STBaseEntry
{
public:
bool aoe;
STResurrectEntry() {
m_bcst = BCEnum::SpT_Resurrect;
aoe = false;
}
STResurrectEntry(STResurrectEntry* prototype) : STBaseEntry(prototype) {
m_bcst = BCEnum::SpT_Resurrect;
aoe = prototype->aoe;
}
virtual ~STResurrectEntry() { return; };
virtual bool IsDerived() { return true; }
virtual STResurrectEntry* SafeCastToResurrect() { return ((m_bcst == BCEnum::SpT_Resurrect) ? (static_cast<STResurrectEntry*>(this)) : (nullptr)); }
};
class STSendHomeEntry : public STBaseEntry
{
public:
bool group;
STSendHomeEntry() {
m_bcst = BCEnum::SpT_SendHome;
group = false;
}
STSendHomeEntry(STSendHomeEntry* prototype) : STBaseEntry(prototype) {
m_bcst = BCEnum::SpT_SendHome;
group = prototype->group;
}
virtual ~STSendHomeEntry() { return; };
virtual bool IsDerived() { return true; }
virtual STSendHomeEntry* SafeCastToSendHome() { return ((m_bcst == BCEnum::SpT_SendHome) ? (static_cast<STSendHomeEntry*>(this)) : (nullptr)); }
};
class STSizeEntry : public STBaseEntry
{
public:
BCEnum::SzType size_type;
STSizeEntry() {
m_bcst = BCEnum::SpT_Size;
size_type = BCEnum::SzT_None;
}
STSizeEntry(STSizeEntry* prototype) : STBaseEntry(prototype) {
m_bcst = BCEnum::SpT_Size;
size_type = prototype->size_type;
}
virtual ~STSizeEntry() { return; };
virtual bool IsDerived() { return true; }
virtual STSizeEntry* SafeCastToSize() { return ((m_bcst == BCEnum::SpT_Size) ? (static_cast<STSizeEntry*>(this)) : (nullptr)); }
};
class STStanceEntry : public STBaseEntry {
public:
BCEnum::StType stance_type;
STStanceEntry() {
m_bcst = BCEnum::SpT_Stance;
stance_type = BCEnum::StT_None;
}
STStanceEntry(STStanceEntry* prototype) : STBaseEntry(prototype) {
m_bcst = BCEnum::SpT_Stance;
stance_type = prototype->stance_type;
}
virtual ~STStanceEntry() { return; };
virtual bool IsDerived() { return true; }
virtual STStanceEntry* SafeCastToStance() { return ((m_bcst == BCEnum::SpT_Stance) ? (static_cast<STStanceEntry*>(this)) : (nullptr)); }
};
typedef std::list<STBaseEntry*> bcst_list;
typedef std::map<BCEnum::SpType, bcst_list> bcst_map;
typedef std::map<BCEnum::SpType, std::string> bcst_required_bot_classes_map;
typedef std::map<BCEnum::SpType, std::map<uint8, std::string>> bcst_required_bot_classes_map_by_class;
typedef std::map<uint8, uint8> bcst_levels;
typedef std::map<BCEnum::SpType, bcst_levels> bcst_levels_map;
#define BOT_COMMAND_CHAR '^'
typedef void (*BotCmdFuncPtr)(Client *,const Seperator *);
typedef struct {
int access;
const char *desc; // description of bot command
BotCmdFuncPtr function; // null means perl function
} BotCommandRecord;
extern int (*bot_command_dispatch)(Client *,char const*);
extern int bot_command_count; // number of bot commands loaded
// Bot Command System:
int bot_command_init(void);
void bot_command_deinit(void);
int bot_command_add(std::string bot_command_name, const char *desc, int access, BotCmdFuncPtr function);
int bot_command_not_avail(Client *c, const char *message);
int bot_command_real_dispatch(Client *c, char const *message);
// Bot Commands
void bot_command_actionable(Client *c, const Seperator *sep);
void bot_command_aggressive(Client *c, const Seperator *sep);
void bot_command_apply_poison(Client *c, const Seperator *sep);
void bot_command_apply_potion(Client* c, const Seperator* sep);
void bot_command_attack(Client *c, const Seperator *sep);
void bot_command_bind_affinity(Client *c, const Seperator *sep);
void bot_command_bot(Client *c, const Seperator *sep);
void bot_command_caster_range(Client* c, const Seperator* sep);
void bot_command_charm(Client *c, const Seperator *sep);
void bot_command_click_item(Client* c, const Seperator* sep);
void bot_command_cure(Client *c, const Seperator *sep);
void bot_command_defensive(Client *c, const Seperator *sep);
void bot_command_depart(Client *c, const Seperator *sep);
void bot_command_escape(Client *c, const Seperator *sep);
void bot_command_find_aliases(Client *c, const Seperator *sep);
void bot_command_follow(Client *c, const Seperator *sep);
void bot_command_guard(Client *c, const Seperator *sep);
void bot_command_heal_rotation(Client *c, const Seperator *sep);
void bot_command_help(Client *c, const Seperator *sep);
void bot_command_hold(Client *c, const Seperator *sep);
void bot_command_identify(Client *c, const Seperator *sep);
void bot_command_inventory(Client *c, const Seperator *sep);
void bot_command_invisibility(Client *c, const Seperator *sep);
void bot_command_item_use(Client *c, const Seperator *sep);
void bot_command_levitation(Client *c, const Seperator *sep);
void bot_command_lull(Client *c, const Seperator *sep);
void bot_command_mesmerize(Client *c, const Seperator *sep);
void bot_command_movement_speed(Client *c, const Seperator *sep);
void bot_command_owner_option(Client *c, const Seperator *sep);
void bot_command_pet(Client *c, const Seperator *sep);
void bot_command_pick_lock(Client *c, const Seperator *sep);
void bot_command_pickpocket(Client* c, const Seperator* sep);
void bot_command_precombat(Client* c, const Seperator* sep);
void bot_command_pull(Client *c, const Seperator *sep);
void bot_command_release(Client *c, const Seperator *sep);
void bot_command_resistance(Client *c, const Seperator *sep);
void bot_command_resurrect(Client *c, const Seperator *sep);
void bot_command_rune(Client *c, const Seperator *sep);
void bot_command_send_home(Client *c, const Seperator *sep);
void bot_command_size(Client *c, const Seperator *sep);
void bot_command_spell_list(Client* c, const Seperator *sep);
void bot_command_spell_settings_add(Client* c, const Seperator *sep);
void bot_command_spell_settings_delete(Client* c, const Seperator *sep);
void bot_command_spell_settings_list(Client* c, const Seperator *sep);
void bot_command_spell_settings_toggle(Client* c, const Seperator *sep);
void bot_command_spell_settings_update(Client* c, const Seperator *sep);
void bot_spell_info_dialogue_window(Client* c, const Seperator *sep);
void bot_command_enforce_spell_list(Client* c, const Seperator* sep);
void bot_command_summon_corpse(Client *c, const Seperator *sep);
void bot_command_suspend(Client *c, const Seperator *sep);
void bot_command_taunt(Client *c, const Seperator *sep);
void bot_command_timer(Client* c, const Seperator* sep);
void bot_command_track(Client *c, const Seperator *sep);
void bot_command_view_combos(Client *c, const Seperator *sep);
void bot_command_water_breathing(Client *c, const Seperator *sep);
// Bot Subcommands
void bot_subcommand_bot_appearance(Client *c, const Seperator *sep);
void bot_subcommand_bot_beard_color(Client *c, const Seperator *sep);
void bot_subcommand_bot_beard_style(Client *c, const Seperator *sep);
void bot_subcommand_bot_camp(Client *c, const Seperator *sep);
void bot_subcommand_bot_clone(Client *c, const Seperator *sep);
void bot_subcommand_bot_create(Client *c, const Seperator *sep);
void bot_subcommand_bot_delete(Client *c, const Seperator *sep);
void bot_subcommand_bot_details(Client *c, const Seperator *sep);
void bot_subcommand_bot_dye_armor(Client *c, const Seperator *sep);
void bot_subcommand_bot_eyes(Client *c, const Seperator *sep);
void bot_subcommand_bot_face(Client *c, const Seperator *sep);
void bot_subcommand_bot_follow_distance(Client *c, const Seperator *sep);
void bot_subcommand_bot_hair_color(Client *c, const Seperator *sep);
void bot_subcommand_bot_hairstyle(Client *c, const Seperator *sep);
void bot_subcommand_bot_heritage(Client *c, const Seperator *sep);
void bot_subcommand_bot_inspect_message(Client *c, const Seperator *sep);
void bot_subcommand_bot_list(Client *c, const Seperator *sep);
void bot_subcommand_bot_out_of_combat(Client *c, const Seperator *sep);
void bot_subcommand_bot_report(Client *c, const Seperator *sep);
void bot_subcommand_bot_spawn(Client *c, const Seperator *sep);
void bot_subcommand_bot_stance(Client *c, const Seperator *sep);
void bot_subcommand_bot_stop_melee_level(Client *c, const Seperator *sep);
void bot_subcommand_bot_suffix(Client *c, const Seperator *sep);
void bot_subcommand_bot_summon(Client *c, const Seperator *sep);
void bot_subcommand_bot_surname(Client *c, const Seperator *sep);
void bot_subcommand_bot_tattoo(Client *c, const Seperator *sep);
void bot_subcommand_bot_title(Client *c, const Seperator *sep);
void bot_subcommand_bot_toggle_archer(Client *c, const Seperator *sep);
void bot_subcommand_bot_toggle_helm(Client *c, const Seperator *sep);
void bot_subcommand_bot_update(Client *c, const Seperator *sep);
void bot_subcommand_bot_woad(Client *c, const Seperator *sep);
void bot_subcommand_circle(Client *c, const Seperator *sep);
void bot_subcommand_heal_rotation_adaptive_targeting(Client *c, const Seperator *sep);
void bot_subcommand_heal_rotation_add_member(Client *c, const Seperator *sep);
void bot_subcommand_heal_rotation_add_target(Client *c, const Seperator *sep);
void bot_subcommand_heal_rotation_adjust_critical(Client *c, const Seperator *sep);
void bot_subcommand_heal_rotation_adjust_safe(Client *c, const Seperator *sep);
void bot_subcommand_heal_rotation_casting_override(Client *c, const Seperator *sep);
void bot_subcommand_heal_rotation_change_interval(Client *c, const Seperator *sep);
void bot_subcommand_heal_rotation_clear_hot(Client *c, const Seperator *sep);
void bot_subcommand_heal_rotation_clear_targets(Client *c, const Seperator *sep);
void bot_subcommand_heal_rotation_create(Client *c, const Seperator *sep);
void bot_subcommand_heal_rotation_delete(Client *c, const Seperator *sep);
void bot_subcommand_heal_rotation_fast_heals(Client *c, const Seperator *sep);
void bot_subcommand_heal_rotation_list(Client *c, const Seperator *sep);
void bot_subcommand_heal_rotation_remove_member(Client *c, const Seperator *sep);
void bot_subcommand_heal_rotation_remove_target(Client *c, const Seperator *sep);
void bot_subcommand_heal_rotation_reset_limits(Client *c, const Seperator *sep);
void bot_subcommand_heal_rotation_save(Client *c, const Seperator *sep);
void bot_subcommand_heal_rotation_set_hot(Client *c, const Seperator *sep);
void bot_subcommand_heal_rotation_start(Client *c, const Seperator *sep);
void bot_subcommand_heal_rotation_stop(Client *c, const Seperator *sep);
void bot_subcommand_inventory_give(Client *c, const Seperator *sep);
void bot_subcommand_inventory_list(Client *c, const Seperator *sep);
void bot_subcommand_inventory_remove(Client *c, const Seperator *sep);
void bot_subcommand_inventory_window(Client *c, const Seperator *sep);
void bot_subcommand_pet_get_lost(Client *c, const Seperator *sep);
void bot_subcommand_pet_remove(Client *c, const Seperator *sep);
void bot_subcommand_pet_set_type(Client *c, const Seperator *sep);
void bot_subcommand_portal(Client *c, const Seperator *sep);
// bot command helpers
bool helper_bot_appearance_fail(Client *bot_owner, Bot *my_bot, BCEnum::AFType fail_type, const char* type_desc);
void helper_bot_appearance_form_final(Client *bot_owner, Bot *my_bot);
void helper_bot_appearance_form_update(Bot *my_bot);
uint32 helper_bot_create(Client *bot_owner, std::string bot_name, uint8 bot_class, uint16 bot_race, uint8 bot_gender);
void helper_bot_out_of_combat(Client *bot_owner, Bot *my_bot);
int helper_bot_follow_option_chain(Client *bot_owner);
bool helper_cast_standard_spell(Bot* casting_bot, Mob* target_mob, int spell_id, bool annouce_cast = true, uint32* dont_root_before = nullptr);
bool helper_command_disabled(Client *bot_owner, bool rule_value, const char *command);
bool helper_command_alias_fail(Client *bot_owner, const char* command_handler, const char *alias, const char *command);
void helper_command_depart_list(Client* bot_owner, Bot* druid_bot, Bot* wizard_bot, bcst_list* local_list, bool single_flag = false);
bool helper_is_help_or_usage(const char* arg);
bool helper_no_available_bots(Client *bot_owner, Bot *my_bot = nullptr);
void helper_send_available_subcommands(Client *bot_owner, const char* command_simile, const std::list<const char*>& subcommand_list);
void helper_send_usage_required_bots(Client *bot_owner, BCEnum::SpType spell_type, uint8 bot_class = Class::None);
bool helper_spell_check_fail(STBaseEntry* local_entry);
bool helper_spell_list_fail(Client *bot_owner, bcst_list* spell_list, BCEnum::SpType spell_type);
#endif
Reference in New Issue View Git Blame Copy Permalink