From 3cffe5f7ef0f3a48a793792518d70a0a25f775d9 Mon Sep 17 00:00:00 2001 From: Uleat Date: Thu, 7 Feb 2019 22:09:31 -0500 Subject: [PATCH] Put merc and bot classes on the same stance standard (mercs) --- changelog.txt | 5 + common/emu_constants.cpp | 34 ++++++ common/emu_constants.h | 18 +++ common/version.h | 2 +- .../sql/git/bots/bots_db_update_manifest.txt | 1 + .../2019_02_07_bots_stance_type_update.sql | 11 ++ zone/bot.cpp | 46 +++---- zone/bot.h | 44 ++----- zone/bot_command.cpp | 38 +++--- zone/bot_database.cpp | 14 +-- zone/botspellsai.cpp | 115 +++++++++--------- zone/client_packet.cpp | 2 +- zone/merc.cpp | 28 ++--- zone/merc.h | 18 +-- 14 files changed, 210 insertions(+), 166 deletions(-) create mode 100644 utils/sql/git/bots/required/2019_02_07_bots_stance_type_update.sql diff --git a/changelog.txt b/changelog.txt index 8deecf26b..d6ddcbf75 100644 --- a/changelog.txt +++ b/changelog.txt @@ -1,6 +1,11 @@ EQEMu Changelog (Started on Sept 24, 2003 15:50) ------------------------------------------------------- +== 2/7/2019 == +Uleat: Put merc and bot classes on the same stance standard (mercs) + - Both classes will now use the same stance standard + - Pushed stance types up to EQEmu::constants + == 2/4/2019 == Uleat: Added command 'profanity' (aliased 'prof') - This is a server-based tool for redacting any language that an admin deems as profanity (socially unacceptable within their community) diff --git a/common/emu_constants.cpp b/common/emu_constants.cpp index e229b7d6d..950bc5ebb 100644 --- a/common/emu_constants.cpp +++ b/common/emu_constants.cpp @@ -118,3 +118,37 @@ EQEmu::bug::CategoryID EQEmu::bug::CategoryNameToCategoryID(const char* category return catOther; } + +const char *EQEmu::constants::GetStanceName(StanceType stance_type) { + switch (stance_type) { + case stanceUnknown: + return "Unknown"; + case stancePassive: + return "Passive"; + case stanceBalanced: + return "Balanced"; + case stanceEfficient: + return "Efficient"; + case stanceReactive: + return "Reactive"; + case stanceAggressive: + return "Aggressive"; + case stanceAssist: + return "Assist"; + case stanceBurn: + return "Burn"; + case stanceEfficient2: + return "Efficient2"; + case stanceBurnAE: + return "BurnAE"; + default: + return "Invalid"; + } +} + +int EQEmu::constants::ConvertStanceTypeToIndex(StanceType stance_type) { + if (stance_type >= EQEmu::constants::stancePassive && stance_type <= EQEmu::constants::stanceBurnAE) + return (stance_type - EQEmu::constants::stancePassive); + + return 0; +} diff --git a/common/emu_constants.h b/common/emu_constants.h index e3869570e..970b2861d 100644 --- a/common/emu_constants.h +++ b/common/emu_constants.h @@ -203,6 +203,24 @@ namespace EQEmu const size_t SAY_LINK_CLOSER_SIZE = 1; const size_t SAY_LINK_MAXIMUM_SIZE = (SAY_LINK_OPENER_SIZE + SAY_LINK_BODY_SIZE + SAY_LINK_TEXT_SIZE + SAY_LINK_CLOSER_SIZE); + enum StanceType : int { + stanceUnknown = 0, + stancePassive, + stanceBalanced, + stanceEfficient, + stanceReactive, + stanceAggressive, + stanceAssist, + stanceBurn, + stanceEfficient2, + stanceBurnAE + }; + + const char *GetStanceName(StanceType stance_type); + int ConvertStanceTypeToIndex(StanceType stance_type); + + const size_t STANCE_TYPE_MAX = stanceBurnAE; + } /*constants*/ namespace profile { diff --git a/common/version.h b/common/version.h index 5f78cdb3a..ff1c9ee46 100644 --- a/common/version.h +++ b/common/version.h @@ -32,7 +32,7 @@ #define CURRENT_BINARY_DATABASE_VERSION 9136 #ifdef BOTS - #define CURRENT_BINARY_BOTS_DATABASE_VERSION 9021 + #define CURRENT_BINARY_BOTS_DATABASE_VERSION 9022 #else #define CURRENT_BINARY_BOTS_DATABASE_VERSION 0 // must be 0 #endif diff --git a/utils/sql/git/bots/bots_db_update_manifest.txt b/utils/sql/git/bots/bots_db_update_manifest.txt index acdb20532..48e9fa026 100644 --- a/utils/sql/git/bots/bots_db_update_manifest.txt +++ b/utils/sql/git/bots/bots_db_update_manifest.txt @@ -20,6 +20,7 @@ 9019|2018_04_12_bots_stop_melee_level.sql|SHOW COLUMNS FROM `bot_data` LIKE 'stop_melee_level'|empty| 9020|2018_08_13_bots_inventory_update.sql|SELECT * FROM `inventory_versions` WHERE `version` = 2 and `bot_step` = 0|not_empty| 9021|2018_10_09_bots_owner_options.sql|SHOW TABLES LIKE 'bot_owner_options'|empty| +9022|2019_02_07_bots_stance_type_update.sql|SELECT * FROM `bot_spell_casting_chances` WHERE `spell_type_index` = '255' AND `class_id` = '255' AND `stance_index` = '0'|empty| # Upgrade conditions: # This won't be needed after this system is implemented, but it is used database that are not diff --git a/utils/sql/git/bots/required/2019_02_07_bots_stance_type_update.sql b/utils/sql/git/bots/required/2019_02_07_bots_stance_type_update.sql new file mode 100644 index 000000000..d2e3169fa --- /dev/null +++ b/utils/sql/git/bots/required/2019_02_07_bots_stance_type_update.sql @@ -0,0 +1,11 @@ +-- Update `bot_stances`.`stance_id` to new values +UPDATE `bot_stances` SET `stance_id` = '9' WHERE `stance_id` = '6'; +UPDATE `bot_stances` SET `stance_id` = '7' WHERE `stance_id` = '5'; +UPDATE `bot_stances` SET `stance_id` = (`stance_id` + 1) WHERE `stance_id` in (0,1,2,3,4); + +-- Update `bot_spell_casting_chances`.`stance_index` to new values +UPDATE `bot_spell_casting_chances` SET `stance_index` = '8' WHERE `stance_index` = '6'; +UPDATE `bot_spell_casting_chances` SET `stance_index` = '6' WHERE `stance_index` = '5'; + +-- Update `bot_spell_casting_chances` implicit versioning +UPDATE `bot_spell_casting_chances` SET `stance_index` = '1' WHERE `spell_type_index` = '255' AND `class_id` = '255'; diff --git a/zone/bot.cpp b/zone/bot.cpp index d7e330f6e..381701a51 100644 --- a/zone/bot.cpp +++ b/zone/bot.cpp @@ -163,7 +163,7 @@ Bot::Bot(uint32 botID, uint32 botOwnerCharacterID, uint32 botSpellsID, double to if (!stance_flag && bot_owner) bot_owner->Message(13, "Could not locate stance for '%s'", GetCleanName()); - SetTaunting((GetClass() == WARRIOR || GetClass() == PALADIN || GetClass() == SHADOWKNIGHT) && (GetBotStance() == BotStanceAggressive)); + SetTaunting((GetClass() == WARRIOR || GetClass() == PALADIN || GetClass() == SHADOWKNIGHT) && (GetBotStance() == EQEmu::constants::stanceAggressive)); SetPauseAI(false); rest_timer.Disable(); @@ -2766,7 +2766,7 @@ void Bot::AI_Process() { // we can't fight if we don't have a target, are stun/mezzed or dead.. // Stop attacking if the target is enraged TEST_TARGET(); - if (GetBotStance() == BotStancePassive || (tar->IsEnraged() && !BehindMob(tar, GetX(), GetY()))) + if (GetBotStance() == EQEmu::constants::stancePassive || (tar->IsEnraged() && !BehindMob(tar, GetX(), GetY()))) return; // First, special attack per class (kick, backstab etc..) @@ -2893,7 +2893,7 @@ void Bot::AI_Process() { FaceTarget(GetTarget()); // This is a mob that is fleeing either because it has been feared or is low on hitpoints - if (GetBotStance() != BotStancePassive) { + if (GetBotStance() != EQEmu::constants::stancePassive) { AI_PursueCastCheck(); // This appears to always return true..can't trust for success/fail return; } @@ -2901,7 +2901,7 @@ void Bot::AI_Process() { } // end not in combat range if (!IsMoving() && !spellend_timer.Enabled()) { // This may actually need work... - if (GetBotStance() == BotStancePassive) + if (GetBotStance() == EQEmu::constants::stancePassive) return; if (GetTarget() && AI_EngagedCastCheck()) @@ -2959,7 +2959,7 @@ void Bot::AI_Process() { // Ok to idle if (fm_dist <= GetFollowDistance()) { if (!IsMoving() && AI_think_timer->Check() && !spellend_timer.Enabled()) { - if (GetBotStance() != BotStancePassive) { + if (GetBotStance() != EQEmu::constants::stancePassive) { if (!AI_IdleCastCheck() && !IsCasting() && GetClass() != BARD) BotMeditate(true); } @@ -3004,7 +3004,7 @@ void Bot::AI_Process() { // Basically, bard bots get a chance to cast idle spells while moving if (IsMoving()) { - if (GetBotStance() != BotStancePassive) { + if (GetBotStance() != EQEmu::constants::stancePassive) { if (GetClass() == BARD && !spellend_timer.Enabled() && AI_think_timer->Check()) { AI_IdleCastCheck(); return; @@ -8268,19 +8268,19 @@ bool EntityList::Bot_AICheckCloseBeneficialSpells(Bot* caster, uint8 iChance, fl Group *g = caster->GetGroup(); float hpRatioToHeal = 25.0f; switch(caster->GetBotStance()) { - case BotStanceReactive: - case BotStanceBalanced: - hpRatioToHeal = 50.0f; - break; - case BotStanceBurn: - case BotStanceBurnAE: - hpRatioToHeal = 20.0f; - break; - case BotStanceAggressive: - case BotStanceEfficient: - default: - hpRatioToHeal = 25.0f; - break; + case EQEmu::constants::stanceReactive: + case EQEmu::constants::stanceBalanced: + hpRatioToHeal = 50.0f; + break; + case EQEmu::constants::stanceBurn: + case EQEmu::constants::stanceBurnAE: + hpRatioToHeal = 20.0f; + break; + case EQEmu::constants::stanceAggressive: + case EQEmu::constants::stanceEfficient: + default: + hpRatioToHeal = 25.0f; + break; } if(g) { @@ -8819,11 +8819,11 @@ bool Bot::HasOrMayGetAggro() { } void Bot::SetDefaultBotStance() { - BotStanceType defaultStance = BotStanceBalanced; + EQEmu::constants::StanceType defaultStance = EQEmu::constants::stanceBalanced; if (GetClass() == WARRIOR) - defaultStance = BotStanceAggressive; + defaultStance = EQEmu::constants::stanceAggressive; - _baseBotStance = BotStancePassive; + _baseBotStance = EQEmu::constants::stancePassive; _botStance = defaultStance; } @@ -9096,4 +9096,6 @@ std::string Bot::CreateSayLink(Client* c, const char* message, const char* name) return saylink; } +uint8 Bot::spell_casting_chances[MaxSpellTypes][PLAYER_CLASS_COUNT][EQEmu::constants::STANCE_TYPE_MAX][cntHSND] = { 0 }; + #endif diff --git a/zone/bot.h b/zone/bot.h index 55a8cba97..08b62b7b0 100644 --- a/zone/bot.h +++ b/zone/bot.h @@ -54,34 +54,6 @@ const int MaxDisciplineTimer = 10; const int DisciplineReuseStart = MaxSpellTimer + 1; const int MaxTimer = MaxSpellTimer + MaxDisciplineTimer; -enum BotStanceType { - BotStancePassive, - BotStanceBalanced, - BotStanceEfficient, - BotStanceReactive, - BotStanceAggressive, - BotStanceBurn, - BotStanceBurnAE, - BotStanceUnknown, - MaxStances = BotStanceUnknown -}; - -#define BOT_STANCE_COUNT 8 -#define VALIDBOTSTANCE(x) ((x >= (int)BotStancePassive && x <= (int)BotStanceBurnAE) ? ((BotStanceType)x) : (BotStanceUnknown)) - -static const std::string bot_stance_name[BOT_STANCE_COUNT] = { - "Passive", // 0 - "Balanced", // 1 - "Efficient", // 2 - "Reactive", // 3 - "Aggressive", // 4 - "Burn", // 5 - "BurnAE", // 6 - "Unknown" // 7 -}; - -static const char* GetBotStanceName(int stance_id) { return bot_stance_name[VALIDBOTSTANCE(stance_id)].c_str(); } - #define VALIDBOTEQUIPSLOT(x) ((x >= EQEmu::invslot::EQUIPMENT_BEGIN && x <= EQEmu::invslot::EQUIPMENT_END) ? (x) : (EQEmu::invslot::EQUIPMENT_COUNT)) static const std::string bot_equip_slot_name[EQEmu::invslot::EQUIPMENT_COUNT + 1] = @@ -519,7 +491,7 @@ public: virtual bool IsBot() const { return true; } bool GetRangerAutoWeaponSelect() { return _rangerAutoWeaponSelect; } BotRoleType GetBotRole() { return _botRole; } - BotStanceType GetBotStance() { return _botStance; } + EQEmu::constants::StanceType GetBotStance() { return _botStance; } uint8 GetChanceToCastBySpellType(uint32 spellType); bool IsGroupHealer() { return m_CastingRoles.GroupHealer; } @@ -633,7 +605,12 @@ public: // void SetBotOwnerCharacterID(uint32 botOwnerCharacterID) { _botOwnerCharacterID = botOwnerCharacterID; } void SetRangerAutoWeaponSelect(bool enable) { GetClass() == RANGER ? _rangerAutoWeaponSelect = enable : _rangerAutoWeaponSelect = false; } void SetBotRole(BotRoleType botRole) { _botRole = botRole; } - void SetBotStance(BotStanceType botStance) { _botStance = ((botStance != BotStanceUnknown) ? (botStance) : (BotStancePassive)); } + void SetBotStance(EQEmu::constants::StanceType botStance) { + if (botStance >= EQEmu::constants::stancePassive && botStance <= EQEmu::constants::stanceBurnAE) + _botStance = botStance; + else + _botStance = EQEmu::constants::stancePassive; + } void SetSpellRecastTimer(int timer_index, int32 recast_delay); void SetDisciplineRecastTimer(int timer_index, int32 recast_delay); void SetAltOutOfCombatBehavior(bool behavior_flag) { _altoutofcombatbehavior = behavior_flag;} @@ -727,8 +704,8 @@ private: uint32 _lastZoneId; bool _rangerAutoWeaponSelect; BotRoleType _botRole; - BotStanceType _botStance; - BotStanceType _baseBotStance; + EQEmu::constants::StanceType _botStance; + EQEmu::constants::StanceType _baseBotStance; unsigned int RestRegenHP; unsigned int RestRegenMana; unsigned int RestRegenEndurance; @@ -792,6 +769,9 @@ private: bool LoadPet(); // Load and spawn bot pet if there is one bool SavePet(); // Save and depop bot pet if there is one bool DeletePet(); + + public: + static uint8 spell_casting_chances[MaxSpellTypes][PLAYER_CLASS_COUNT][EQEmu::constants::STANCE_TYPE_MAX][cntHSND]; }; #endif // BOTS diff --git a/zone/bot_command.cpp b/zone/bot_command.cpp index 94b25b3ad..b12aa2d46 100644 --- a/zone/bot_command.cpp +++ b/zone/bot_command.cpp @@ -4249,7 +4249,7 @@ void bot_subcommand_bot_clone(Client *c, const Seperator *sep) return; } - int clone_stance = BotStancePassive; + int clone_stance = EQEmu::constants::stancePassive; if (!botdb.LoadStance(my_bot->GetBotID(), clone_stance)) c->Message(m_fail, "%s for bot '%s'", BotDatabase::fail::LoadStance(), my_bot->GetCleanName()); if (!botdb.SaveStance(clone_id, clone_stance)) @@ -5160,29 +5160,34 @@ void bot_subcommand_bot_stance(Client *c, const Seperator *sep) if (helper_command_alias_fail(c, "bot_subcommand_bot_stance", sep->arg[0], "botstance")) return; if (helper_is_help_or_usage(sep->arg[1])) { - c->Message(m_usage, "usage: %s [current | value: 0-6] ([actionable: target | byname] ([actionable_name]))", sep->arg[0]); + c->Message(m_usage, "usage: %s [current | value: 1-9] ([actionable: target | byname] ([actionable_name]))", sep->arg[0]); c->Message(m_note, "value: %u(%s), %u(%s), %u(%s), %u(%s), %u(%s), %u(%s), %u(%s)", - BotStancePassive, GetBotStanceName(BotStancePassive), - BotStanceBalanced, GetBotStanceName(BotStanceBalanced), - BotStanceEfficient, GetBotStanceName(BotStanceEfficient), - BotStanceReactive, GetBotStanceName(BotStanceReactive), - BotStanceAggressive, GetBotStanceName(BotStanceAggressive), - BotStanceBurn, GetBotStanceName(BotStanceBurn), - BotStanceBurnAE, GetBotStanceName(BotStanceBurnAE) + EQEmu::constants::stancePassive, EQEmu::constants::GetStanceName(EQEmu::constants::stancePassive), + EQEmu::constants::stanceBalanced, EQEmu::constants::GetStanceName(EQEmu::constants::stanceBalanced), + EQEmu::constants::stanceEfficient, EQEmu::constants::GetStanceName(EQEmu::constants::stanceEfficient), + EQEmu::constants::stanceReactive, EQEmu::constants::GetStanceName(EQEmu::constants::stanceReactive), + EQEmu::constants::stanceAggressive, EQEmu::constants::GetStanceName(EQEmu::constants::stanceAggressive), + EQEmu::constants::stanceAssist, EQEmu::constants::GetStanceName(EQEmu::constants::stanceAssist), + EQEmu::constants::stanceBurn, EQEmu::constants::GetStanceName(EQEmu::constants::stanceBurn), + EQEmu::constants::stanceEfficient2, EQEmu::constants::GetStanceName(EQEmu::constants::stanceEfficient2), + EQEmu::constants::stanceBurnAE, EQEmu::constants::GetStanceName(EQEmu::constants::stanceBurnAE) ); return; } int ab_mask = (ActionableBots::ABM_Target | ActionableBots::ABM_ByName); bool current_flag = false; - auto bst = BotStanceUnknown; + auto bst = EQEmu::constants::stanceUnknown; if (!strcasecmp(sep->arg[1], "current")) current_flag = true; - else if (sep->IsNumber(1)) - bst = VALIDBOTSTANCE(atoi(sep->arg[1])); + else if (sep->IsNumber(1)) { + bst = (EQEmu::constants::StanceType)atoi(sep->arg[1]); + if (bst < EQEmu::constants::stanceUnknown || bst > EQEmu::constants::stanceBurnAE) + bst = EQEmu::constants::stanceUnknown; + } - if (!current_flag && bst == BotStanceUnknown) { + if (!current_flag && bst == EQEmu::constants::stanceUnknown) { c->Message(m_fail, "A [current] argument or valid numeric [value] is required to use this command"); return; } @@ -5200,7 +5205,12 @@ void bot_subcommand_bot_stance(Client *c, const Seperator *sep) bot_iter->Save(); } - Bot::BotGroupSay(bot_iter, "My current stance is '%s' (%u)", GetBotStanceName(bot_iter->GetBotStance()), bot_iter->GetBotStance()); + Bot::BotGroupSay( + bot_iter, + "My current stance is '%s' (%i)", + EQEmu::constants::GetStanceName(bot_iter->GetBotStance()), + bot_iter->GetBotStance() + ); } } diff --git a/zone/bot_database.cpp b/zone/bot_database.cpp index f32ecafc4..651729223 100644 --- a/zone/bot_database.cpp +++ b/zone/bot_database.cpp @@ -83,12 +83,8 @@ bool BotDatabase::LoadBotCommandSettings(std::map= MaxStances) + if (stance_index >= EQEmu::constants::STANCE_TYPE_MAX) continue; for (uint8 conditional_index = nHSND; conditional_index < cntHSND; ++conditional_index) { @@ -136,7 +132,7 @@ bool BotDatabase::LoadBotSpellCastingChances() if (value > 100) value = 100; - spell_casting_chances[spell_type_index][class_index][stance_index][conditional_index] = value; + Bot::spell_casting_chances[spell_type_index][class_index][stance_index][conditional_index] = value; } } @@ -877,7 +873,7 @@ bool BotDatabase::LoadStance(Bot* bot_inst, bool& stance_flag) return true; auto row = results.begin(); - bot_inst->SetBotStance((BotStanceType)atoi(row[0])); + bot_inst->SetBotStance((EQEmu::constants::StanceType)atoi(row[0])); stance_flag = true; return true; @@ -2857,12 +2853,12 @@ uint8 BotDatabase::GetSpellCastingChance(uint8 spell_type_index, uint8 class_ind return 0; if (class_index >= PLAYER_CLASS_COUNT) return 0; - if (stance_index >= MaxStances) + if (stance_index >= EQEmu::constants::STANCE_TYPE_MAX) return 0; if (conditional_index >= cntHSND) return 0; - return spell_casting_chances[spell_type_index][class_index][stance_index][conditional_index]; + return Bot::spell_casting_chances[spell_type_index][class_index][stance_index][conditional_index]; } diff --git a/zone/botspellsai.cpp b/zone/botspellsai.cpp index 154574453..d660f2420 100644 --- a/zone/botspellsai.cpp +++ b/zone/botspellsai.cpp @@ -192,25 +192,24 @@ bool Bot::AICastSpell(Mob* tar, uint8 iChance, uint32 iSpellTypes) { else { float hpRatioToCast = 0.0f; - switch(this->GetBotStance()) - { - case BotStanceEfficient: - case BotStanceAggressive: - hpRatioToCast = isPrimaryHealer?90.0f:50.0f; - break; - case BotStanceBalanced: - hpRatioToCast = isPrimaryHealer?95.0f:75.0f; - break; - case BotStanceReactive: - hpRatioToCast = isPrimaryHealer?100.0f:90.0f; - break; - case BotStanceBurn: - case BotStanceBurnAE: - hpRatioToCast = isPrimaryHealer?75.0f:25.0f; - break; - default: - hpRatioToCast = isPrimaryHealer?100.0f:0.0f; - break; + switch(this->GetBotStance()) { + case EQEmu::constants::stanceEfficient: + case EQEmu::constants::stanceAggressive: + hpRatioToCast = isPrimaryHealer?90.0f:50.0f; + break; + case EQEmu::constants::stanceBalanced: + hpRatioToCast = isPrimaryHealer?95.0f:75.0f; + break; + case EQEmu::constants::stanceReactive: + hpRatioToCast = isPrimaryHealer?100.0f:90.0f; + break; + case EQEmu::constants::stanceBurn: + case EQEmu::constants::stanceBurnAE: + hpRatioToCast = isPrimaryHealer?75.0f:25.0f; + break; + default: + hpRatioToCast = isPrimaryHealer?100.0f:0.0f; + break; } //If we're at specified mana % or below, don't heal as hybrid @@ -381,23 +380,22 @@ bool Bot::AICastSpell(Mob* tar, uint8 iChance, uint32 iSpellTypes) { { float manaRatioToCast = 75.0f; - switch(this->GetBotStance()) - { - case BotStanceEfficient: - manaRatioToCast = 90.0f; - break; - case BotStanceBalanced: - case BotStanceAggressive: - manaRatioToCast = 75.0f; - break; - case BotStanceReactive: - case BotStanceBurn: - case BotStanceBurnAE: - manaRatioToCast = 50.0f; - break; - default: - manaRatioToCast = 75.0f; - break; + switch(this->GetBotStance()) { + case EQEmu::constants::stanceEfficient: + manaRatioToCast = 90.0f; + break; + case EQEmu::constants::stanceBalanced: + case EQEmu::constants::stanceAggressive: + manaRatioToCast = 75.0f; + break; + case EQEmu::constants::stanceReactive: + case EQEmu::constants::stanceBurn: + case EQEmu::constants::stanceBurnAE: + manaRatioToCast = 50.0f; + break; + default: + manaRatioToCast = 75.0f; + break; } //If we're at specified mana % or below, don't rune as enchanter @@ -461,25 +459,24 @@ bool Bot::AICastSpell(Mob* tar, uint8 iChance, uint32 iSpellTypes) { { float manaRatioToCast = 75.0f; - switch(this->GetBotStance()) - { - case BotStanceEfficient: - manaRatioToCast = 90.0f; - break; - case BotStanceBalanced: - manaRatioToCast = 75.0f; - break; - case BotStanceReactive: - case BotStanceAggressive: - manaRatioToCast = 50.0f; - break; - case BotStanceBurn: - case BotStanceBurnAE: - manaRatioToCast = 25.0f; - break; - default: - manaRatioToCast = 50.0f; - break; + switch(this->GetBotStance()) { + case EQEmu::constants::stanceEfficient: + manaRatioToCast = 90.0f; + break; + case EQEmu::constants::stanceBalanced: + manaRatioToCast = 75.0f; + break; + case EQEmu::constants::stanceReactive: + case EQEmu::constants::stanceAggressive: + manaRatioToCast = 50.0f; + break; + case EQEmu::constants::stanceBurn: + case EQEmu::constants::stanceBurnAE: + manaRatioToCast = 25.0f; + break; + default: + manaRatioToCast = 50.0f; + break; } //If we're at specified mana % or below, don't nuke as cleric or enchanter @@ -1310,7 +1307,7 @@ bool Bot::AI_EngagedCastCheck() { AIautocastspell_timer->Disable(); //prevent the timer from going off AGAIN while we are casting. uint8 botClass = GetClass(); - BotStanceType botStance = GetBotStance(); + EQEmu::constants::StanceType botStance = GetBotStance(); bool mayGetAggro = HasOrMayGetAggro(); Log(Logs::Detail, Logs::AI, "Engaged autocast check triggered (BOTS). Trying to cast healing spells then maybe offensive spells."); @@ -2653,11 +2650,13 @@ uint8 Bot::GetChanceToCastBySpellType(uint32 spellType) return 0; --class_index; - uint8 stance_index = (uint8)GetBotStance(); - if (stance_index >= MaxStances) + EQEmu::constants::StanceType stance_type = GetBotStance(); + if (stance_type < EQEmu::constants::stancePassive || stance_type > EQEmu::constants::stanceBurnAE) return 0; + uint8 stance_index = EQEmu::constants::ConvertStanceTypeToIndex(stance_type); uint8 type_index = nHSND; + if (HasGroup()) { if (IsGroupHealer()/* || IsRaidHealer()*/) type_index |= pH; diff --git a/zone/client_packet.cpp b/zone/client_packet.cpp index 9e03a6e4e..10cd81d89 100644 --- a/zone/client_packet.cpp +++ b/zone/client_packet.cpp @@ -9394,7 +9394,7 @@ void Client::Handle_OP_MercenaryCommand(const EQApplicationPacket *app) //check to see if selected option is a valid stance slot (option is the slot the stance is in, not the actual stance) if (option >= 0 && option < numStances) { - merc->SetStance(mercTemplate->Stances[option]); + merc->SetStance((EQEmu::constants::StanceType)mercTemplate->Stances[option]); GetMercInfo().Stance = mercTemplate->Stances[option]; Log(Logs::General, Logs::Mercenaries, "Set Stance: %u for %s (%s)", merc->GetStance(), merc->GetName(), GetName()); diff --git a/zone/merc.cpp b/zone/merc.cpp index 1825a23eb..e71667320 100644 --- a/zone/merc.cpp +++ b/zone/merc.cpp @@ -66,7 +66,7 @@ Merc::Merc(const NPCType* d, float x, float y, float z, float heading) memset(equipment, 0, sizeof(equipment)); SetMercID(0); - SetStance(MercStanceBalanced); + SetStance(EQEmu::constants::stanceBalanced); rest_timer.Disable(); if (GetClass() == ROGUE) @@ -3669,13 +3669,13 @@ MercSpell Merc::GetBestMercSpellForAENuke(Merc* caster, Mob* tar) { switch(caster->GetStance()) { - case MercStanceBurnAE: + case EQEmu::constants::stanceBurnAE: initialCastChance = 50; break; - case MercStanceBalanced: + case EQEmu::constants::stanceBalanced: initialCastChance = 25; break; - case MercStanceBurn: + case EQEmu::constants::stanceBurn: initialCastChance = 0; break; } @@ -3717,11 +3717,11 @@ MercSpell Merc::GetBestMercSpellForTargetedAENuke(Merc* caster, Mob* tar) { switch(caster->GetStance()) { - case MercStanceBurnAE: + case EQEmu::constants::stanceBurnAE: numTargetsCheck = 1; break; - case MercStanceBalanced: - case MercStanceBurn: + case EQEmu::constants::stanceBalanced: + case EQEmu::constants::stanceBurn: numTargetsCheck = 2; break; } @@ -3769,11 +3769,11 @@ MercSpell Merc::GetBestMercSpellForPBAENuke(Merc* caster, Mob* tar) { switch(caster->GetStance()) { - case MercStanceBurnAE: + case EQEmu::constants::stanceBurnAE: numTargetsCheck = 2; break; - case MercStanceBalanced: - case MercStanceBurn: + case EQEmu::constants::stanceBalanced: + case EQEmu::constants::stanceBurn: numTargetsCheck = 3; break; } @@ -3820,11 +3820,11 @@ MercSpell Merc::GetBestMercSpellForAERainNuke(Merc* caster, Mob* tar) { switch(caster->GetStance()) { - case MercStanceBurnAE: + case EQEmu::constants::stanceBurnAE: numTargetsCheck = 1; break; - case MercStanceBalanced: - case MercStanceBurn: + case EQEmu::constants::stanceBalanced: + case EQEmu::constants::stanceBurn: numTargetsCheck = 2; break; } @@ -5649,7 +5649,7 @@ void Client::SpawnMerc(Merc* merc, bool setMaxStats) { merc->SetSuspended(false); SetMerc(merc); merc->Unsuspend(setMaxStats); - merc->SetStance(GetMercInfo().Stance); + merc->SetStance((EQEmu::constants::StanceType)GetMercInfo().Stance); Log(Logs::General, Logs::Mercenaries, "SpawnMerc Success for %s.", GetName()); diff --git a/zone/merc.h b/zone/merc.h index cf6a14009..0fdc05f7a 100644 --- a/zone/merc.h +++ b/zone/merc.h @@ -30,18 +30,6 @@ namespace EQEmu const int MercAISpellRange = 100; // TODO: Write a method that calcs what the merc's spell range is based on spell, equipment, AA, whatever and replace this -enum MercStanceType { - MercStancePassive = 1, - MercStanceBalanced, - MercStanceEfficient, - MercStanceReactive, - MercStanceAggressive, - MercStanceAssist, - MercStanceBurn, - MercStanceEfficient2, - MercStanceBurnAE -}; - struct MercSpell { uint16 spellid; // <= 0 = no spell uint32 type; // 0 = never, must be one (and only one) of the defined values @@ -175,7 +163,7 @@ public: uint8 GetTierID() { return _TierID; } uint32 GetCostFormula() { return _CostFormula; } uint32 GetMercNameType() { return _NameType; } - uint32 GetStance() { return _currentStance; } + EQEmu::constants::StanceType GetStance() { return _currentStance; } int GetHatedCount() { return _hatedCount; } inline const uint8 GetClientVersion() const { return _OwnerClientVersion; } @@ -265,7 +253,7 @@ public: void SetMercNameType( uint8 nametype ) { _NameType = nametype; } void SetClientVersion(uint8 clientVersion) { _OwnerClientVersion = clientVersion; } void SetSuspended(bool suspended) { _suspended = suspended; } - void SetStance( uint32 stance ) { _currentStance = stance; } + void SetStance( EQEmu::constants::StanceType stance ) { _currentStance = stance; } void SetHatedCount( int count ) { _hatedCount = count; } void Sit(); @@ -385,7 +373,7 @@ private: uint8 _CostFormula; uint8 _NameType; uint8 _OwnerClientVersion; - uint32 _currentStance; + EQEmu::constants::StanceType _currentStance; EQEmu::InventoryProfile m_inv; int32 max_end;