nchebrov/mod-playerbots
1
0
Fork 0
mirror of https://github.com/mod-playerbots/mod-playerbots.git synced 2026-01-13 17:09:08 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #405 from liyunfan1223/code-style-and-check

Browse Source 
Code style and check
This commit is contained in:
Yunfan Li
2024-08-04 13:37:02 +08:00
committed by GitHub
parent c85b8fd02a 53611c9040
commit 78cdc11ba5
838 changed files with 35145 additions and 31861 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
.clang-format Normal file
View File

@@ -0,0 +1,12 @@
BasedOnStyle: google
IndentWidth: 4
TabWidth: 4
ColumnLimit: 120
UseTab: Never
AllowShortFunctionsOnASingleLine: All
AllowShortIfStatementsOnASingleLine: false
AllowShortLoopsOnASingleLine: false
BreakBeforeBraces: Allman
AccessModifierOffset: -4
DerivePointerAlignment: false
PointerAlignment: Left

30
.github/workflows/code_style.yml vendored Normal file
View File

@@ -0,0 +1,30 @@
name: Codestyle
on:
push:
branches: [ "master" ]
pull_request:
branches: [ "master" ]
jobs:
lint:
name: "clang-format-always-success"
runs-on: ubuntu-latest
steps:
- name: Checkout Playerbot Module
uses: actions/checkout@v4
- name: Install clang-format
run: sudo apt-get install clang-format -y
- name: Run clang-format
run: |
# Find all C/C++ source files
FILES=$(find . -name "*.h" -o -name "*.cpp" -o -name "*.c" -o -name "*.hpp")
# Run clang-format in dry-run mode to check for formatting issues
clang-format -i $FILES
# Check if there are any formatting changes
git diff --exit-code
shell: bash
continue-on-error: true

18
code_format.sh Executable file
View File

@@ -0,0 +1,18 @@
#!/bin/bash
CLANG_FORMAT_PATH=$(which clang-format)
if [ -z "$CLANG_FORMAT_PATH" ]; then
echo "clang-format not found."
exit 1
fi
PROJECT_ROOT=$(dirname "$0")
cpp_files=$(find $PROJECT_ROOT -name '*.cpp' -or -name '*.h' )
for file in $cpp_files; do
echo "Formatting $file"
$CLANG_FORMAT_PATH -i $file
done
echo "All .cpp or .h files have been formatted."

156
src/AiFactory.cpp
View File

@@ -1,28 +1,30 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#include "AiFactory.h"
#include "BattlegroundMgr.h"
#include "DKAiObjectContext.h"
#include "DruidAiObjectContext.h"
#include "Engine.h"
#include "Group.h"
#include "HunterAiObjectContext.h"
#include "Item.h"
#include "MageAiObjectContext.h"
#include "PaladinAiObjectContext.h"
#include "PlayerbotAI.h"
#include "PlayerbotAIConfig.h"
#include "Playerbots.h"
#include "Engine.h"
#include "Group.h"
#include "DKAiObjectContext.h"
#include "PriestAiObjectContext.h"
#include "MageAiObjectContext.h"
#include "RogueAiObjectContext.h"
#include "ShamanAiObjectContext.h"
#include "SharedDefines.h"
#include "SpellInfo.h"
#include "SpellMgr.h"
#include "WarlockAiObjectContext.h"
#include "WarriorAiObjectContext.h"
#include "ShamanAiObjectContext.h"
#include "PaladinAiObjectContext.h"
#include "DruidAiObjectContext.h"
#include "HunterAiObjectContext.h"
#include "RogueAiObjectContext.h"
AiObjectContext* AiFactory::createAiObjectContext(Player* player, PlayerbotAI* botAI)
{
@@ -100,11 +102,12 @@ std::map<uint8, uint32> AiFactory::GetPlayerSpecTabs(Player* bot)
for (PlayerTalentMap::const_iterator i = talentMap.begin(); i != talentMap.end(); ++i)
{
uint32 spellId = i->first;
if ((bot->GetActiveSpecMask() & i->second->specMask) == 0) {
if ((bot->GetActiveSpecMask() & i->second->specMask) == 0)
{
continue;
}
TalentSpellPos const* talentPos = GetTalentSpellPos(spellId);
if(!talentPos)
if (!talentPos)
continue;
TalentEntry const* talentInfo = sTalentStore.LookupEntry(talentPos->talent_id);
if (!talentInfo)
@@ -186,7 +189,8 @@ std::string AiFactory::GetPlayerSpecName(Player* player)
specName = "holy";
else
specName = "disc";
; break;
;
break;
case CLASS_SHAMAN:
if (tab == 2)
specName = "resto";
@@ -274,7 +278,7 @@ void AiFactory::AddDefaultCombatStrategies(Player* player, PlayerbotAI* const fa
{
engine->addStrategies("racials", "chat", "default", "cast time", "duel", "boost", "emote", nullptr);
}
if (sPlayerbotAIConfig->autoSaveMana)
if (sPlayerbotAIConfig->autoSaveMana)
{
engine->addStrategy("auto save mana");
}
@@ -286,11 +290,16 @@ void AiFactory::AddDefaultCombatStrategies(Player* player, PlayerbotAI* const fa
switch (player->getClass())
{
case CLASS_PRIEST:
if (tab == 2) {
if (tab == 2)
{
engine->addStrategies("dps", "shadow debuff", "shadow aoe", nullptr);
} else if (tab == PRIEST_TAB_DISIPLINE) {
}
else if (tab == PRIEST_TAB_DISIPLINE)
{
engine->addStrategies("heal", nullptr);
} else {
}
else
{
engine->addStrategies("holy heal", nullptr);
}
@@ -310,13 +319,13 @@ void AiFactory::AddDefaultCombatStrategies(Player* player, PlayerbotAI* const fa
if (tab == 2)
engine->addStrategies("tank", "tank assist", "aoe", "mark rti", nullptr);
else if (player->GetLevel() < 36 || tab == 0)
engine->addStrategies("arms", "aoe", "dps assist",/*"behind",*/ nullptr);
engine->addStrategies("arms", "aoe", "dps assist", /*"behind",*/ nullptr);
else
engine->addStrategies("fury", "aoe", "dps assist",/*"behind",*/ nullptr);
engine->addStrategies("fury", "aoe", "dps assist", /*"behind",*/ nullptr);
break;
case CLASS_SHAMAN:
if (tab == 0)
engine->addStrategies("caster", "caster aoe", "bmana",nullptr);
engine->addStrategies("caster", "caster aoe", "bmana", nullptr);
else if (tab == 2)
engine->addStrategies("heal", "bmana", nullptr);
else
@@ -343,9 +352,12 @@ void AiFactory::AddDefaultCombatStrategies(Player* player, PlayerbotAI* const fa
engine->addStrategies("heal", "cure", "dps assist", nullptr);
else
{
if (player->GetLevel() >= 20 && !player->HasAura(16931)/*thick hide*/) {
if (player->GetLevel() >= 20 && !player->HasAura(16931) /*thick hide*/)
{
engine->addStrategies("cat", "dps assist", nullptr);
} else {
}
else
{
engine->addStrategies("bear", "tank assist", nullptr);
}
}
@@ -355,9 +367,12 @@ void AiFactory::AddDefaultCombatStrategies(Player* player, PlayerbotAI* const fa
engine->addStrategy("dps debuff");
break;
case CLASS_ROGUE:
if (tab == ROGUE_TAB_ASSASSINATION) {
if (tab == ROGUE_TAB_ASSASSINATION)
{
engine->addStrategies("melee", "dps assist", "aoe", /*"behind",*/ nullptr);
} else {
}
else
{
engine->addStrategies("dps", "dps assist", "aoe", /*"behind",*/ nullptr);
}
break;
@@ -384,28 +399,37 @@ void AiFactory::AddDefaultCombatStrategies(Player* player, PlayerbotAI* const fa
engine->addStrategy("dps assist");
engine->removeStrategy("threat");
// engine-
switch (player->getClass()) {
case CLASS_PRIEST: {
if (tab != PRIEST_TAB_SHADOW) {
switch (player->getClass())
{
case CLASS_PRIEST:
{
if (tab != PRIEST_TAB_SHADOW)
{
engine->addStrategies("holy dps", "shadow debuff", "shadow aoe", nullptr);
}
break;
}
case CLASS_DRUID: {
if (tab == DRUID_TAB_RESTORATION) {
case CLASS_DRUID:
{
if (tab == DRUID_TAB_RESTORATION)
{
engine->addStrategies("caster", "caster aoe", nullptr);
engine->addStrategy("caster debuff");
}
break;
}
case CLASS_SHAMAN: {
if (tab == SHAMAN_TAB_RESTORATION) {
case CLASS_SHAMAN:
{
if (tab == SHAMAN_TAB_RESTORATION)
{
engine->addStrategies("caster", "caster aoe", "bmana", nullptr);
}
break;
}
case CLASS_PALADIN: {
if (tab == PALADIN_TAB_HOLY) {
case CLASS_PALADIN:
{
if (tab == PALADIN_TAB_HOLY)
{
engine->addStrategies("dps", "dps assist", "baoe", nullptr);
}
break;
@@ -447,7 +471,8 @@ void AiFactory::AddDefaultCombatStrategies(Player* player, PlayerbotAI* const fa
engine->addStrategy("arena");
}
engine->addStrategies("boost", "racials", "chat", "default", "aoe", "potions", "cast time", "dps assist", nullptr);
engine->addStrategies("boost", "racials", "chat", "default", "aoe", "potions", "cast time", "dps assist",
nullptr);
engine->removeStrategy("custom::say");
engine->removeStrategy("flee");
engine->removeStrategy("threat");
@@ -466,7 +491,7 @@ void AiFactory::AddDefaultCombatStrategies(Player* player, PlayerbotAI* const fa
Engine* AiFactory::createCombatEngine(Player* player, PlayerbotAI* const facade, AiObjectContext* aiObjectContext)
{
Engine* engine = new Engine(facade, aiObjectContext);
Engine* engine = new Engine(facade, aiObjectContext);
AddDefaultCombatStrategies(player, facade, engine);
return engine;
}
@@ -481,18 +506,22 @@ void AiFactory::AddDefaultNonCombatStrategies(Player* player, PlayerbotAI* const
nonCombatEngine->addStrategies("dps assist", "cure", nullptr);
break;
case CLASS_PALADIN:
if (tab == 1) {
if (tab == 1)
{
nonCombatEngine->addStrategies("bthreat", "tank assist", "barmor", nullptr);
if (player->GetLevel() >= 20) {
if (player->GetLevel() >= 20)
{
nonCombatEngine->addStrategy("bstats");
} else {
}
else
{
nonCombatEngine->addStrategy("bdps");
}
}
else if (tab == 0)
nonCombatEngine->addStrategies("dps assist", "bmana", "bcast", nullptr);
else
nonCombatEngine->addStrategies("dps assist", "bdps", "baoe",nullptr);
nonCombatEngine->addStrategies("dps assist", "bdps", "baoe", nullptr);
nonCombatEngine->addStrategies("cure", nullptr);
break;
@@ -516,10 +545,14 @@ void AiFactory::AddDefaultNonCombatStrategies(Player* player, PlayerbotAI* const
nonCombatEngine->addStrategies("dps assist", "cure", nullptr);
break;
case CLASS_DRUID:
if (tab == 1) {
if (player->GetLevel() >= 20 && !player->HasAura(16931)/*thick hide*/) {
if (tab == 1)
{
if (player->GetLevel() >= 20 && !player->HasAura(16931) /*thick hide*/)
{
nonCombatEngine->addStrategy("dps assist");
} else {
}
else
{
nonCombatEngine->addStrategy("tank assist");
}
}
@@ -533,11 +566,16 @@ void AiFactory::AddDefaultNonCombatStrategies(Player* player, PlayerbotAI* const
nonCombatEngine->addStrategy("dps assist");
break;
case CLASS_WARLOCK:
if (tab == WARLOCK_TAB_AFFLICATION) {
if (tab == WARLOCK_TAB_AFFLICATION)
{
nonCombatEngine->addStrategies("bmana", nullptr);
} else if (tab == WARLOCK_TAB_DEMONOLOGY) {
}
else if (tab == WARLOCK_TAB_DEMONOLOGY)
{
nonCombatEngine->addStrategies("bdps", nullptr);
} else if (tab == WARLOCK_TAB_DESTRUCTION) {
}
else if (tab == WARLOCK_TAB_DESTRUCTION)
{
nonCombatEngine->addStrategies("bhealth", nullptr);
}
nonCombatEngine->addStrategies("dps assist", nullptr);
@@ -555,17 +593,18 @@ void AiFactory::AddDefaultNonCombatStrategies(Player* player, PlayerbotAI* const
if (!player->InBattleground())
{
nonCombatEngine->addStrategies("nc", "food", "chat", "follow",
"default", "quest", "loot", "gather", "duel", "buff", "mount", "emote", nullptr);
nonCombatEngine->addStrategies("nc", "food", "chat", "follow", "default", "quest", "loot", "gather", "duel",
"buff", "mount", "emote", nullptr);
}
if (sPlayerbotAIConfig->autoSaveMana) {
if (sPlayerbotAIConfig->autoSaveMana)
{
nonCombatEngine->addStrategy("auto save mana");
}
if ((sRandomPlayerbotMgr->IsRandomBot(player)) && !player->InBattleground())
{
Player* master = facade->GetMaster();
// let 25% of free bots start duels.
// let 25% of free bots start duels.
if (!urand(0, 3))
nonCombatEngine->addStrategy("start duel");
@@ -588,7 +627,9 @@ void AiFactory::AddDefaultNonCombatStrategies(Player* player, PlayerbotAI* const
{
// nonCombatEngine->addStrategy("travel");
nonCombatEngine->addStrategy("rpg");
} else {
}
else
{
nonCombatEngine->addStrategy("move random");
}
@@ -627,7 +668,8 @@ void AiFactory::AddDefaultNonCombatStrategies(Player* player, PlayerbotAI* const
nonCombatEngine->ChangeStrategy(sPlayerbotAIConfig->randomBotNonCombatStrategies);
}
else {
else
{
nonCombatEngine->addStrategy("pvp");
nonCombatEngine->ChangeStrategy(sPlayerbotAIConfig->nonCombatStrategies);
}
@@ -644,7 +686,8 @@ void AiFactory::AddDefaultNonCombatStrategies(Player* player, PlayerbotAI* const
// Battleground switch
if (player->InBattleground() && player->GetBattleground())
{
nonCombatEngine->addStrategies("nc", "chat", "default", "buff", "food", "mount", "pvp", "dps assist", "attack tagged", "emote", nullptr);
nonCombatEngine->addStrategies("nc", "chat", "default", "buff", "food", "mount", "pvp", "dps assist",
"attack tagged", "emote", nullptr);
nonCombatEngine->removeStrategy("custom::say");
nonCombatEngine->removeStrategy("travel");
nonCombatEngine->removeStrategy("rpg");
@@ -654,7 +697,8 @@ void AiFactory::AddDefaultNonCombatStrategies(Player* player, PlayerbotAI* const
if (bgType == BATTLEGROUND_RB)
bgType = player->GetBattleground()->GetBgTypeID(true);
if ((bgType <= BATTLEGROUND_EY || bgType == BATTLEGROUND_IC) && !player->InArena()) // do not add for not supported bg or arena
if ((bgType <= BATTLEGROUND_EY || bgType == BATTLEGROUND_IC) &&
!player->InArena()) // do not add for not supported bg or arena
nonCombatEngine->addStrategy("battleground");
if (bgType == BATTLEGROUND_WS)
@@ -682,15 +726,15 @@ void AiFactory::AddDefaultNonCombatStrategies(Player* player, PlayerbotAI* const
Engine* AiFactory::createNonCombatEngine(Player* player, PlayerbotAI* const facade, AiObjectContext* aiObjectContext)
{
Engine* nonCombatEngine = new Engine(facade, aiObjectContext);
Engine* nonCombatEngine = new Engine(facade, aiObjectContext);
AddDefaultNonCombatStrategies(player, facade, nonCombatEngine);
return nonCombatEngine;
return nonCombatEngine;
}
void AiFactory::AddDefaultDeadStrategies(Player* player, PlayerbotAI* const facade, Engine* deadEngine)
{
(void)facade; // unused and remove warning
(void)facade; // unused and remove warning
deadEngine->addStrategies("dead", "stay", "chat", "default", "follow", nullptr);
if (sRandomPlayerbotMgr->IsRandomBot(player) && !player->GetGroup())

31
src/AiFactory.h
View File

@@ -1,14 +1,15 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#ifndef _PLAYERBOT_AIFACTORY_H
#define _PLAYERBOT_AIFACTORY_H
#include "Common.h"
#include <map>
#include "Common.h"
class AiObjectContext;
class Engine;
class Player;
@@ -18,19 +19,19 @@ enum BotRoles : uint8;
class AiFactory
{
public:
static AiObjectContext* createAiObjectContext(Player* player, PlayerbotAI* botAI);
static Engine* createCombatEngine(Player* player, PlayerbotAI* const facade, AiObjectContext* aiObjectContext);
static Engine* createNonCombatEngine(Player* player, PlayerbotAI* const facade, AiObjectContext* aiObjectContext);
static Engine* createDeadEngine(Player* player, PlayerbotAI* const facade, AiObjectContext* aibjectContext);
static void AddDefaultNonCombatStrategies(Player* player, PlayerbotAI* const facade, Engine* nonCombatEngine);
static void AddDefaultDeadStrategies(Player* player, PlayerbotAI* const facade, Engine* deadEngine);
static void AddDefaultCombatStrategies(Player* player, PlayerbotAI* const facade, Engine* engine);
public:
static AiObjectContext* createAiObjectContext(Player* player, PlayerbotAI* botAI);
static Engine* createCombatEngine(Player* player, PlayerbotAI* const facade, AiObjectContext* aiObjectContext);
static Engine* createNonCombatEngine(Player* player, PlayerbotAI* const facade, AiObjectContext* aiObjectContext);
static Engine* createDeadEngine(Player* player, PlayerbotAI* const facade, AiObjectContext* aibjectContext);
static void AddDefaultNonCombatStrategies(Player* player, PlayerbotAI* const facade, Engine* nonCombatEngine);
static void AddDefaultDeadStrategies(Player* player, PlayerbotAI* const facade, Engine* deadEngine);
static void AddDefaultCombatStrategies(Player* player, PlayerbotAI* const facade, Engine* engine);
static uint8 GetPlayerSpecTab(Player* player);
static std::map<uint8, uint32> GetPlayerSpecTabs(Player* player);
static BotRoles GetPlayerRoles(Player* player);
static std::string GetPlayerSpecName(Player* player);
static uint8 GetPlayerSpecTab(Player* player);
static std::map<uint8, uint32> GetPlayerSpecTabs(Player* player);
static BotRoles GetPlayerRoles(Player* player);
static std::string GetPlayerSpecName(Player* player);
};
#endif

385
src/ChatFilter.cpp
View File

@@ -1,8 +1,10 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#include "ChatFilter.h"
#include "Group.h"
#include "Playerbots.h"
#include "RtiTargetValue.h"
@@ -17,252 +19,252 @@ std::string const ChatFilter::Filter(std::string& message)
class StrategyChatFilter : public ChatFilter
{
public:
StrategyChatFilter(PlayerbotAI* botAI) : ChatFilter(botAI) { }
public:
StrategyChatFilter(PlayerbotAI* botAI) : ChatFilter(botAI) {}
std::string const Filter(std::string& message) override
{
Player* bot = botAI->GetBot();
std::string const Filter(std::string& message) override
{
Player* bot = botAI->GetBot();
bool tank = message.find("@tank") == 0;
if (tank && !botAI->IsTank(bot))
return "";
bool tank = message.find("@tank") == 0;
if (tank && !botAI->IsTank(bot))
return "";
bool dps = message.find("@dps") == 0;
if (dps && (botAI->IsTank(bot) || botAI->IsHeal(bot)))
return "";
bool dps = message.find("@dps") == 0;
if (dps && (botAI->IsTank(bot) || botAI->IsHeal(bot)))
return "";
bool heal = message.find("@heal") == 0;
if (heal && !botAI->IsHeal(bot))
return "";
bool heal = message.find("@heal") == 0;
if (heal && !botAI->IsHeal(bot))
return "";
bool ranged = message.find("@ranged") == 0;
if (ranged && !botAI->IsRanged(bot))
return "";
bool ranged = message.find("@ranged") == 0;
if (ranged && !botAI->IsRanged(bot))
return "";
bool melee = message.find("@melee") == 0;
if (melee && botAI->IsRanged(bot))
return "";
bool melee = message.find("@melee") == 0;
if (melee && botAI->IsRanged(bot))
return "";
if (tank || dps || heal || ranged || melee)
return ChatFilter::Filter(message);
if (tank || dps || heal || ranged || melee)
return ChatFilter::Filter(message);
return message;
}
return message;
}
};
class LevelChatFilter : public ChatFilter
{
public:
LevelChatFilter(PlayerbotAI* botAI) : ChatFilter(botAI) { }
public:
LevelChatFilter(PlayerbotAI* botAI) : ChatFilter(botAI) {}
std::string const Filter(std::string& message) override
std::string const Filter(std::string& message) override
{
Player* bot = botAI->GetBot();
if (message[0] != '@')
return message;
if (message.find("-") != std::string::npos)
{
Player* bot = botAI->GetBot();
uint32 fromLevel = atoi(message.substr(message.find("@") + 1, message.find("-")).c_str());
uint32 toLevel = atoi(message.substr(message.find("-") + 1, message.find(" ")).c_str());
if (message[0] != '@')
return message;
if (message.find("-") != std::string::npos)
{
uint32 fromLevel = atoi(message.substr(message.find("@") + 1, message.find("-")).c_str());
uint32 toLevel = atoi(message.substr(message.find("-") + 1, message.find(" ")).c_str());
if (bot->GetLevel() >= fromLevel && bot->GetLevel() <= toLevel)
return ChatFilter::Filter(message);
return message;
}
uint32 level = atoi(message.substr(message.find("@") + 1, message.find(" ")).c_str());
if (bot->GetLevel() == level)
if (bot->GetLevel() >= fromLevel && bot->GetLevel() <= toLevel)
return ChatFilter::Filter(message);
return message;
}
uint32 level = atoi(message.substr(message.find("@") + 1, message.find(" ")).c_str());
if (bot->GetLevel() == level)
return ChatFilter::Filter(message);
return message;
}
};
class CombatTypeChatFilter : public ChatFilter
{
public:
CombatTypeChatFilter(PlayerbotAI* botAI) : ChatFilter(botAI) { }
public:
CombatTypeChatFilter(PlayerbotAI* botAI) : ChatFilter(botAI) {}
std::string const Filter(std::string& message) override
std::string const Filter(std::string& message) override
{
Player* bot = botAI->GetBot();
bool melee = message.find("@melee") == 0;
bool ranged = message.find("@ranged") == 0;
if (!melee && !ranged)
return message;
switch (bot->getClass())
{
Player* bot = botAI->GetBot();
bool melee = message.find("@melee") == 0;
bool ranged = message.find("@ranged") == 0;
if (!melee && !ranged)
return message;
switch (bot->getClass())
{
case CLASS_WARRIOR:
case CLASS_PALADIN:
case CLASS_ROGUE:
case CLASS_DEATH_KNIGHT:
if (ranged)
return "";
break;
case CLASS_HUNTER:
case CLASS_PRIEST:
case CLASS_MAGE:
case CLASS_WARLOCK:
if (melee)
return "";
break;
case CLASS_DRUID:
if (ranged && botAI->IsTank(bot))
return "";
if (melee && !botAI->IsTank(bot))
return "";
break;
case CLASS_SHAMAN:
if (melee && botAI->IsHeal(bot))
return "";
if (ranged && !botAI->IsHeal(bot))
return "";
break;
}
return ChatFilter::Filter(message);
case CLASS_WARRIOR:
case CLASS_PALADIN:
case CLASS_ROGUE:
case CLASS_DEATH_KNIGHT:
if (ranged)
return "";
break;
case CLASS_HUNTER:
case CLASS_PRIEST:
case CLASS_MAGE:
case CLASS_WARLOCK:
if (melee)
return "";
break;
case CLASS_DRUID:
if (ranged && botAI->IsTank(bot))
return "";
if (melee && !botAI->IsTank(bot))
return "";
break;
case CLASS_SHAMAN:
if (melee && botAI->IsHeal(bot))
return "";
if (ranged && !botAI->IsHeal(bot))
return "";
break;
}
return ChatFilter::Filter(message);
}
};
class RtiChatFilter : public ChatFilter
{
public:
RtiChatFilter(PlayerbotAI* botAI) : ChatFilter(botAI)
public:
RtiChatFilter(PlayerbotAI* botAI) : ChatFilter(botAI)
{
rtis.push_back("@star");
rtis.push_back("@circle");
rtis.push_back("@diamond");
rtis.push_back("@triangle");
rtis.push_back("@moon");
rtis.push_back("@square");
rtis.push_back("@cross");
rtis.push_back("@skull");
}
std::string const Filter(std::string& message) override
{
Player* bot = botAI->GetBot();
Group* group = bot->GetGroup();
if (!group)
return message;
bool found = false;
bool isRti = false;
for (std::vector<std::string>::iterator i = rtis.begin(); i != rtis.end(); i++)
{
rtis.push_back("@star");
rtis.push_back("@circle");
rtis.push_back("@diamond");
rtis.push_back("@triangle");
rtis.push_back("@moon");
rtis.push_back("@square");
rtis.push_back("@cross");
rtis.push_back("@skull");
}
std::string const rti = *i;
std::string const Filter(std::string& message) override
{
Player* bot = botAI->GetBot();
Group* group = bot->GetGroup();
if (!group)
return message;
bool isRti = message.find(rti) == 0;
if (!isRti)
continue;
bool found = false;
bool isRti = false;
for (std::vector<std::string>::iterator i = rtis.begin(); i != rtis.end(); i++)
{
std::string const rti = *i;
bool isRti = message.find(rti) == 0;
if (!isRti)
continue;
ObjectGuid rtiTarget = group->GetTargetIcon(RtiTargetValue::GetRtiIndex(rti.substr(1)));
if (bot->GetGUID() == rtiTarget)
return ChatFilter::Filter(message);
Unit* target = *botAI->GetAiObjectContext()->GetValue<Unit*>("current target");
if (!target)
return "";
if (target->GetGUID() != rtiTarget)
return "";
found |= isRti;
if (found)
break;
}
if (found)
ObjectGuid rtiTarget = group->GetTargetIcon(RtiTargetValue::GetRtiIndex(rti.substr(1)));
if (bot->GetGUID() == rtiTarget)
return ChatFilter::Filter(message);
return message;
Unit* target = *botAI->GetAiObjectContext()->GetValue<Unit*>("current target");
if (!target)
return "";
if (target->GetGUID() != rtiTarget)
return "";
found |= isRti;
if (found)
break;
}
private:
std::vector<std::string> rtis;
if (found)
return ChatFilter::Filter(message);
return message;
}
private:
std::vector<std::string> rtis;
};
class ClassChatFilter : public ChatFilter
{
public:
ClassChatFilter(PlayerbotAI* botAI) : ChatFilter(botAI)
public:
ClassChatFilter(PlayerbotAI* botAI) : ChatFilter(botAI)
{
classNames["@death_knight"] = CLASS_DEATH_KNIGHT;
classNames["@druid"] = CLASS_DRUID;
classNames["@hunter"] = CLASS_HUNTER;
classNames["@mage"] = CLASS_MAGE;
classNames["@paladin"] = CLASS_PALADIN;
classNames["@priest"] = CLASS_PRIEST;
classNames["@rogue"] = CLASS_ROGUE;
classNames["@shaman"] = CLASS_SHAMAN;
classNames["@warlock"] = CLASS_WARLOCK;
classNames["@warrior"] = CLASS_WARRIOR;
}
std::string const Filter(std::string& message) override
{
Player* bot = botAI->GetBot();
bool found = false;
bool isClass = false;
for (std::map<std::string, uint8>::iterator i = classNames.begin(); i != classNames.end(); i++)
{
classNames["@death_knight"] = CLASS_DEATH_KNIGHT;
classNames["@druid"] = CLASS_DRUID;
classNames["@hunter"] = CLASS_HUNTER;
classNames["@mage"] = CLASS_MAGE;
classNames["@paladin"] = CLASS_PALADIN;
classNames["@priest"] = CLASS_PRIEST;
classNames["@rogue"] = CLASS_ROGUE;
classNames["@shaman"] = CLASS_SHAMAN;
classNames["@warlock"] = CLASS_WARLOCK;
classNames["@warrior"] = CLASS_WARRIOR;
}
std::string const Filter(std::string& message) override
{
Player* bot = botAI->GetBot();
bool found = false;
bool isClass = false;
for (std::map<std::string, uint8>::iterator i = classNames.begin(); i != classNames.end(); i++)
{
bool isClass = message.find(i->first) == 0;
if (isClass && bot->getClass() != i->second)
return "";
found |= isClass;
if (found)
break;
}
bool isClass = message.find(i->first) == 0;
if (isClass && bot->getClass() != i->second)
return "";
found |= isClass;
if (found)
return ChatFilter::Filter(message);
return message;
break;
}
private:
std::map<std::string, uint8> classNames;
if (found)
return ChatFilter::Filter(message);
return message;
}
private:
std::map<std::string, uint8> classNames;
};
class SubGroupChatFilter : public ChatFilter
{
public:
SubGroupChatFilter(PlayerbotAI* botAI) : ChatFilter(botAI) { }
public:
SubGroupChatFilter(PlayerbotAI* botAI) : ChatFilter(botAI) {}
std::string const Filter(std::string& message) override
std::string const Filter(std::string& message) override
{
Player* bot = botAI->GetBot();
if (message.find("@group") == 0)
{
Player* bot = botAI->GetBot();
if (message.find("@group") == 0)
std::string const pnum = message.substr(6, message.find(" "));
uint32 from = atoi(pnum.c_str());
uint32 to = from;
if (pnum.find("-") != std::string::npos)
{
std::string const pnum = message.substr(6, message.find(" "));
uint32 from = atoi(pnum.c_str());
uint32 to = from;
if (pnum.find("-") != std::string::npos)
{
from = atoi(pnum.substr(pnum.find("@") + 1, pnum.find("-")).c_str());
to = atoi(pnum.substr(pnum.find("-") + 1, pnum.find(" ")).c_str());
}
if (!bot->GetGroup())
return message;
uint32 sg = bot->GetSubGroup() + 1;
if (sg >= from && sg <= to)
return ChatFilter::Filter(message);
from = atoi(pnum.substr(pnum.find("@") + 1, pnum.find("-")).c_str());
to = atoi(pnum.substr(pnum.find("-") + 1, pnum.find(" ")).c_str());
}
return message;
if (!bot->GetGroup())
return message;
uint32 sg = bot->GetSubGroup() + 1;
if (sg >= from && sg <= to)
return ChatFilter::Filter(message);
}
return message;
}
};
CompositeChatFilter::CompositeChatFilter(PlayerbotAI* botAI) : ChatFilter(botAI)
@@ -295,4 +297,3 @@ std::string const CompositeChatFilter::Filter(std::string& message)
return message;
}

27
src/ChatFilter.h
View File

@@ -1,36 +1,37 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#ifndef _PLAYERBOT_CHATFILTER_H
#define _PLAYERBOT_CHATFILTER_H
#include <vector>
#include "Common.h"
#include "PlayerbotAIAware.h"
#include <vector>
class PlayerbotAI;
class ChatFilter : public PlayerbotAIAware
{
public:
ChatFilter(PlayerbotAI* botAI) : PlayerbotAIAware(botAI) { }
virtual ~ChatFilter() { }
public:
ChatFilter(PlayerbotAI* botAI) : PlayerbotAIAware(botAI) {}
virtual ~ChatFilter() {}
virtual std::string const Filter(std::string& message);
virtual std::string const Filter(std::string& message);
};
class CompositeChatFilter : public ChatFilter
{
public:
CompositeChatFilter(PlayerbotAI* botAI);
public:
CompositeChatFilter(PlayerbotAI* botAI);
virtual ~CompositeChatFilter();
std::string const Filter(std::string& message) override;
virtual ~CompositeChatFilter();
std::string const Filter(std::string& message) override;
private:
std::vector<ChatFilter*> filters;
private:
std::vector<ChatFilter*> filters;
};
#endif

121
src/ChatHelper.cpp
View File

@@ -1,8 +1,10 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#include "ChatHelper.h"
#include "AiFactory.h"
#include "Playerbots.h"
#include "SpellInfo.h"
@@ -18,13 +20,13 @@ std::map<uint8, std::string> ChatHelper::classes;
std::map<uint8, std::string> ChatHelper::races;
std::map<uint8, std::map<uint8, std::string> > ChatHelper::specs;
template<class T>
template <class T>
static bool substrContainsInMap(std::string const searchTerm, std::map<std::string, T> searchIn)
{
for (typename std::map<std::string, T>::iterator i = searchIn.begin(); i != searchIn.end(); ++i)
{
std::string const term = i->first;
if (term.size() > 1 && searchTerm.find(term) != std::string::npos)
if (term.size() > 1 && searchTerm.find(term) != std::string::npos)
return true;
}
@@ -57,19 +59,19 @@ ChatHelper::ChatHelper(PlayerbotAI* botAI) : PlayerbotAIAware(botAI)
projectileSubClasses["arrows"] = ITEM_SUBCLASS_ARROW;
projectileSubClasses["bullets"] = ITEM_SUBCLASS_BULLET;
//tradeSubClasses["cloth"] = ITEM_SUBCLASS_CLOTH;
//tradeSubClasses["leather"] = ITEM_SUBCLASS_LEATHER;
//tradeSubClasses["metal"] = ITEM_SUBCLASS_METAL_STONE;
//tradeSubClasses["stone"] = ITEM_SUBCLASS_METAL_STONE;
//tradeSubClasses["ore"] = ITEM_SUBCLASS_METAL_STONE;
//tradeSubClasses["meat"] = ITEM_SUBCLASS_MEAT;
//tradeSubClasses["herb"] = ITEM_SUBCLASS_HERB;
//tradeSubClasses["elemental"] = ITEM_SUBCLASS_ELEMENTAL;
//tradeSubClasses["disenchants"] = ITEM_SUBCLASS_ENCHANTING;
//tradeSubClasses["enchanting"] = ITEM_SUBCLASS_ENCHANTING;
//tradeSubClasses["gems"] = ITEM_SUBCLASS_JEWELCRAFTING;
//tradeSubClasses["jewels"] = ITEM_SUBCLASS_JEWELCRAFTING;
//tradeSubClasses["jewelcrafting"] = ITEM_SUBCLASS_JEWELCRAFTING;
// tradeSubClasses["cloth"] = ITEM_SUBCLASS_CLOTH;
// tradeSubClasses["leather"] = ITEM_SUBCLASS_LEATHER;
// tradeSubClasses["metal"] = ITEM_SUBCLASS_METAL_STONE;
// tradeSubClasses["stone"] = ITEM_SUBCLASS_METAL_STONE;
// tradeSubClasses["ore"] = ITEM_SUBCLASS_METAL_STONE;
// tradeSubClasses["meat"] = ITEM_SUBCLASS_MEAT;
// tradeSubClasses["herb"] = ITEM_SUBCLASS_HERB;
// tradeSubClasses["elemental"] = ITEM_SUBCLASS_ELEMENTAL;
// tradeSubClasses["disenchants"] = ITEM_SUBCLASS_ENCHANTING;
// tradeSubClasses["enchanting"] = ITEM_SUBCLASS_ENCHANTING;
// tradeSubClasses["gems"] = ITEM_SUBCLASS_JEWELCRAFTING;
// tradeSubClasses["jewels"] = ITEM_SUBCLASS_JEWELCRAFTING;
// tradeSubClasses["jewelcrafting"] = ITEM_SUBCLASS_JEWELCRAFTING;
slots["head"] = EQUIPMENT_SLOT_HEAD;
slots["neck"] = EQUIPMENT_SLOT_NECK;
@@ -179,11 +181,11 @@ ChatHelper::ChatHelper(PlayerbotAI* botAI) : PlayerbotAIAware(botAI)
std::string const ChatHelper::formatMoney(uint32 copper)
{
std::ostringstream out;
if (!copper)
{
out << "0";
return out.str();
}
if (!copper)
{
out << "0";
return out.str();
}
uint32 gold = uint32(copper / 10000);
copper -= (gold * 10000);
@@ -193,7 +195,7 @@ std::string const ChatHelper::formatMoney(uint32 copper)
bool space = false;
if (gold > 0)
{
out << gold << "g";
out << gold << "g";
space = true;
}
@@ -202,17 +204,17 @@ std::string const ChatHelper::formatMoney(uint32 copper)
if (space)
out << " ";
out << silver << "s";
out << silver << "s";
space = true;
}
if (copper > 0 && gold < 10)
{
if (copper > 0 && gold < 10)
{
if (space)
out << " ";
out << copper << "c";
}
out << copper << "c";
}
return out.str();
}
@@ -281,22 +283,27 @@ ItemIds ChatHelper::parseItems(std::string const text)
std::string const ChatHelper::FormatQuest(Quest const* quest)
{
std::ostringstream out;
out << "|cFFFFFF00|Hquest:" << quest->GetQuestId() << ':' << quest->GetQuestLevel() << "|h[" << quest->GetTitle() << "]|h|r";
out << "|cFFFFFF00|Hquest:" << quest->GetQuestId() << ':' << quest->GetQuestLevel() << "|h[" << quest->GetTitle()
<< "]|h|r";
return out.str();
}
std::string const ChatHelper::FormatGameobject(GameObject* go)
{
std::ostringstream out;
out << "|cFFFFFF00|Hfound:" << go->GetGUID().GetRawValue() << ":" << go->GetEntry() << ":" << "|h[" << go->GetNameForLocaleIdx(LOCALE_enUS) << "]|h|r";
out << "|cFFFFFF00|Hfound:" << go->GetGUID().GetRawValue() << ":" << go->GetEntry() << ":"
<< "|h[" << go->GetNameForLocaleIdx(LOCALE_enUS) << "]|h|r";
return out.str();
}
std::string const ChatHelper::FormatWorldobject(WorldObject* wo)
{
std::ostringstream out;
out << "|cFFFFFF00|Hfound:" << wo->GetGUID().GetRawValue() << ":" << wo->GetEntry() << ":" << "|h[";
out << (wo->ToGameObject() ? ((GameObject*)wo)->GetNameForLocaleIdx(LOCALE_enUS) : wo->GetNameForLocaleIdx(LOCALE_enUS)) << "]|h|r";
out << "|cFFFFFF00|Hfound:" << wo->GetGUID().GetRawValue() << ":" << wo->GetEntry() << ":"
<< "|h[";
out << (wo->ToGameObject() ? ((GameObject*)wo)->GetNameForLocaleIdx(LOCALE_enUS)
: wo->GetNameForLocaleIdx(LOCALE_enUS))
<< "]|h|r";
return out.str();
}
@@ -311,7 +318,8 @@ std::string const ChatHelper::FormatWorldEntry(int32 entry)
gInfo = sObjectMgr->GetGameObjectTemplate(entry * -1);
std::ostringstream out;
out << "|cFFFFFF00|Hentry:" << abs(entry) << ":" << "|h[";
out << "|cFFFFFF00|Hentry:" << abs(entry) << ":"
<< "|h[";
if (entry < 0 && gInfo)
out << gInfo->name;
@@ -339,9 +347,8 @@ std::string const ChatHelper::FormatItem(ItemTemplate const* proto, uint32 count
// const std::string &name = sObjectMgr->GetItemLocale(proto->ItemId)->Name[LOCALE_enUS];
std::ostringstream out;
out << "|c" << color << "|Hitem:" << proto->ItemId
<< ":0:0:0:0:0:0:0" << "|h[" << proto->Name1
<< "]|h|r";
out << "|c" << color << "|Hitem:" << proto->ItemId << ":0:0:0:0:0:0:0"
<< "|h[" << proto->Name1 << "]|h|r";
if (count > 1)
out << "x" << count;
@@ -392,7 +399,6 @@ std::string const ChatHelper::FormatChat(ChatMsg chat)
return "unknown";
}
uint32 ChatHelper::parseSpell(std::string const text)
{
PlayerbotChatHandler handler(botAI->GetBot());
@@ -410,13 +416,13 @@ GuidVector ChatHelper::parseGameobjects(std::string const text)
while (true)
{
// extract GO guid
auto i = text.find("Hfound:", pos); // base H = 11
if (i == std::string::npos) // break if error
auto i = text.find("Hfound:", pos); // base H = 11
if (i == std::string::npos) // break if error
break;
pos = i + 7; //start of window in text 11 + 7 = 18
auto endPos = text.find(':', pos); // end of window in text 22
if (endPos == std::string::npos) //break if error
pos = i + 7; // start of window in text 11 + 7 = 18
auto endPos = text.find(':', pos); // end of window in text 22
if (endPos == std::string::npos) // break if error
break;
std::istringstream stream(text.substr(pos, endPos - pos));
@@ -426,11 +432,11 @@ GuidVector ChatHelper::parseGameobjects(std::string const text)
// extract GO entry
pos = endPos + 1;
endPos = text.find(':', pos); // end of window in text
if (endPos == std::string::npos) //break if error
if (endPos == std::string::npos) // break if error
break;
std::string const entryC = text.substr(pos, endPos - pos); // get std::string const within window i.e entry
uint32 entry = atol(entryC.c_str()); // convert ascii to float
std::string const entryC = text.substr(pos, endPos - pos); // get std::string const within window i.e entry
uint32 entry = atol(entryC.c_str()); // convert ascii to float
ObjectGuid lootCurrent = ObjectGuid(guid);
@@ -444,8 +450,8 @@ GuidVector ChatHelper::parseGameobjects(std::string const text)
std::string const ChatHelper::FormatQuestObjective(std::string const name, uint32 available, uint32 required)
{
std::ostringstream out;
out << "|cFFFFFFFF" << name << (available >= required ? "|c0000FF00: " : "|c00FF0000: ")
<< available << "/" << required << "|r";
out << "|cFFFFFFFF" << name << (available >= required ? "|c0000FF00: " : "|c00FF0000: ") << available << "/"
<< required << "|r";
return out.str();
}
@@ -501,9 +507,11 @@ uint32 ChatHelper::parseSlot(std::string const text)
bool ChatHelper::parseable(std::string const text)
{
return text.find("|H") != std::string::npos || text == "questitem" || text == "ammo" || substrContainsInMap<uint32>(text, consumableSubClasses) ||
substrContainsInMap<uint32>(text, tradeSubClasses) || substrContainsInMap<uint32>(text, itemQualities) || substrContainsInMap<uint32>(text, slots) ||
substrContainsInMap<ChatMsg>(text, chats) || substrContainsInMap<uint32>(text, skills) || parseMoney(text) > 0;
return text.find("|H") != std::string::npos || text == "questitem" || text == "ammo" ||
substrContainsInMap<uint32>(text, consumableSubClasses) ||
substrContainsInMap<uint32>(text, tradeSubClasses) || substrContainsInMap<uint32>(text, itemQualities) ||
substrContainsInMap<uint32>(text, slots) || substrContainsInMap<ChatMsg>(text, chats) ||
substrContainsInMap<uint32>(text, skills) || parseMoney(text) > 0;
}
std::string const ChatHelper::FormatClass(Player* player, int8 spec)
@@ -526,15 +534,9 @@ std::string const ChatHelper::FormatClass(Player* player, int8 spec)
return out.str();
}
std::string const ChatHelper::FormatClass(uint8 cls)
{
return classes[cls];
}
std::string const ChatHelper::FormatClass(uint8 cls) { return classes[cls]; }
std::string const ChatHelper::FormatRace(uint8 race)
{
return races[race];
}
std::string const ChatHelper::FormatRace(uint8 race) { return races[race]; }
uint32 ChatHelper::parseSkill(std::string const text)
{
@@ -555,10 +557,7 @@ std::string const ChatHelper::FormatSkill(uint32 skill)
return "";
}
std::string const ChatHelper::FormatBoolean(bool flag)
{
return flag ? "|cff00ff00ON|r" : "|cffffff00OFF|r";
}
std::string const ChatHelper::FormatBoolean(bool flag) { return flag ? "|cff00ff00ON|r" : "|cffffff00OFF|r"; }
void ChatHelper::eraseAllSubStr(std::string& mainStr, std::string const toErase)
{

85
src/ChatHelper.h
View File

@@ -1,17 +1,18 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#ifndef _PLAYERBOT_CHATHELPER_H
#define _PLAYERBOT_CHATHELPER_H
#include <map>
#include "Common.h"
#include "ObjectGuid.h"
#include "PlayerbotAIAware.h"
#include "SharedDefines.h"
#include <map>
class GameObject;
class Quest;
class Player;
@@ -26,52 +27,52 @@ typedef std::set<uint32> SpellIds;
class ChatHelper : public PlayerbotAIAware
{
public:
ChatHelper(PlayerbotAI* botAI);
public:
ChatHelper(PlayerbotAI* botAI);
static std::string const formatMoney(uint32 copper);
static uint32 parseMoney(std::string const text);
static ItemIds parseItems(std::string const text);
uint32 parseSpell(std::string const text);
static std::string const FormatQuest(Quest const* quest);
static std::string const FormatItem(ItemTemplate const* proto, uint32 count = 0, uint32 total = 0);
static std::string const FormatQItem(uint32 itemId);
static std::string const FormatSpell(SpellInfo const* spellInfo);
static std::string const FormatGameobject(GameObject* go);
static std::string const FormatWorldobject(WorldObject* wo);
static std::string const FormatWorldEntry(int32 entry);
static std::string const FormatQuestObjective(std::string const name, uint32 available, uint32 required);
static GuidVector parseGameobjects(std::string const text);
static std::string const formatMoney(uint32 copper);
static uint32 parseMoney(std::string const text);
static ItemIds parseItems(std::string const text);
uint32 parseSpell(std::string const text);
static std::string const FormatQuest(Quest const* quest);
static std::string const FormatItem(ItemTemplate const* proto, uint32 count = 0, uint32 total = 0);
static std::string const FormatQItem(uint32 itemId);
static std::string const FormatSpell(SpellInfo const* spellInfo);
static std::string const FormatGameobject(GameObject* go);
static std::string const FormatWorldobject(WorldObject* wo);
static std::string const FormatWorldEntry(int32 entry);
static std::string const FormatQuestObjective(std::string const name, uint32 available, uint32 required);
static GuidVector parseGameobjects(std::string const text);
static ChatMsg parseChat(std::string const text);
static std::string const FormatChat(ChatMsg chat);
static ChatMsg parseChat(std::string const text);
static std::string const FormatChat(ChatMsg chat);
static std::string const FormatClass(Player* player, int8 spec);
static std::string const FormatClass(uint8 cls);
static std::string const FormatRace(uint8 race);
static std::string const FormatSkill(uint32 skill);
static std::string const FormatBoolean(bool flag);
static std::string const FormatClass(Player* player, int8 spec);
static std::string const FormatClass(uint8 cls);
static std::string const FormatRace(uint8 race);
static std::string const FormatSkill(uint32 skill);
static std::string const FormatBoolean(bool flag);
static uint32 parseItemQuality(std::string const text);
static bool parseItemClass(std::string const text, uint32* itemClass, uint32* itemSubClass);
static uint32 parseSlot(std::string const text);
uint32 parseSkill(std::string const text);
static uint32 parseItemQuality(std::string const text);
static bool parseItemClass(std::string const text, uint32* itemClass, uint32* itemSubClass);
static uint32 parseSlot(std::string const text);
uint32 parseSkill(std::string const text);
static bool parseable(std::string const text);
static bool parseable(std::string const text);
void eraseAllSubStr(std::string& mainStr, std::string const toErase);
void eraseAllSubStr(std::string& mainStr, std::string const toErase);
private:
static std::map<std::string, uint32> consumableSubClasses;
static std::map<std::string, uint32> tradeSubClasses;
static std::map<std::string, uint32> itemQualities;
static std::map<std::string, uint32> projectileSubClasses;
static std::map<std::string, uint32> slots;
static std::map<std::string, uint32> skills;
static std::map<std::string, ChatMsg> chats;
static std::map<uint8, std::string> classes;
static std::map<uint8, std::string> races;
static std::map<uint8, std::map<uint8, std::string>> specs;
private:
static std::map<std::string, uint32> consumableSubClasses;
static std::map<std::string, uint32> tradeSubClasses;
static std::map<std::string, uint32> itemQualities;
static std::map<std::string, uint32> projectileSubClasses;
static std::map<std::string, uint32> slots;
static std::map<std::string, uint32> skills;
static std::map<std::string, ChatMsg> chats;
static std::map<uint8, std::string> classes;
static std::map<uint8, std::string> races;
static std::map<uint8, std::map<uint8, std::string>> specs;
};
#endif

105
src/FleeManager.cpp
View File

@@ -1,36 +1,44 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#include "FleeManager.h"
#include "Playerbots.h"
#include "ServerFacade.h"
FleeManager::FleeManager(Player* bot, float maxAllowedDistance, float followAngle, bool forceMaxDistance, WorldPosition startPosition) :
bot(bot), maxAllowedDistance(maxAllowedDistance), followAngle(followAngle), forceMaxDistance(forceMaxDistance), startPosition(startPosition ? startPosition : WorldPosition(bot))
FleeManager::FleeManager(Player* bot, float maxAllowedDistance, float followAngle, bool forceMaxDistance,
WorldPosition startPosition)
: bot(bot),
maxAllowedDistance(maxAllowedDistance),
followAngle(followAngle),
forceMaxDistance(forceMaxDistance),
startPosition(startPosition ? startPosition : WorldPosition(bot))
{
}
void FleeManager::calculateDistanceToCreatures(FleePoint *point)
void FleeManager::calculateDistanceToCreatures(FleePoint* point)
{
point->minDistance = -1.0f;
point->sumDistance = 0.0f;
PlayerbotAI* botAI = GET_PLAYERBOT_AI(bot);
if (!botAI) {
if (!botAI)
{
return;
}
GuidVector units = *botAI->GetAiObjectContext()->GetValue<GuidVector>("possible targets no los");
for (GuidVector::iterator i = units.begin(); i != units.end(); ++i)
GuidVector units = *botAI->GetAiObjectContext()->GetValue<GuidVector>("possible targets no los");
for (GuidVector::iterator i = units.begin(); i != units.end(); ++i)
{
Unit* unit = botAI->GetUnit(*i);
if (!unit)
continue;
Unit* unit = botAI->GetUnit(*i);
if (!unit)
continue;
float d = sServerFacade->GetDistance2d(unit, point->x, point->y);
point->sumDistance += d;
if (point->minDistance < 0 || point->minDistance > d)
float d = sServerFacade->GetDistance2d(unit, point->x, point->y);
point->sumDistance += d;
if (point->minDistance < 0 || point->minDistance > d)
point->minDistance = d;
}
}
}
bool intersectsOri(float angle, std::vector<float>& angles, float angleIncrement)
@@ -45,20 +53,21 @@ bool intersectsOri(float angle, std::vector<float>& angles, float angleIncrement
return false;
}
void FleeManager::calculatePossibleDestinations(std::vector<FleePoint*> &points)
void FleeManager::calculatePossibleDestinations(std::vector<FleePoint*>& points)
{
PlayerbotAI* botAI = GET_PLAYERBOT_AI(bot);
if (!botAI) {
if (!botAI)
{
return;
}
Unit* target = *botAI->GetAiObjectContext()->GetValue<Unit*>("current target");
float botPosX = startPosition.getX();
float botPosX = startPosition.getX();
float botPosY = startPosition.getY();
float botPosZ = startPosition.getZ();
FleePoint start(botAI, botPosX, botPosY, botPosZ);
calculateDistanceToCreatures(&start);
FleePoint start(botAI, botPosX, botPosY, botPosZ);
calculateDistanceToCreatures(&start);
std::vector<float> enemyOri;
GuidVector units = *botAI->GetAiObjectContext()->GetValue<GuidVector>("possible targets no los");
@@ -72,19 +81,24 @@ void FleeManager::calculatePossibleDestinations(std::vector<FleePoint*> &points)
enemyOri.push_back(ori);
}
float distIncrement = std::max(sPlayerbotAIConfig->followDistance, (maxAllowedDistance - sPlayerbotAIConfig->tooCloseDistance) / 10.0f);
for (float dist = maxAllowedDistance; dist >= sPlayerbotAIConfig->tooCloseDistance ; dist -= distIncrement)
float distIncrement = std::max(sPlayerbotAIConfig->followDistance,
(maxAllowedDistance - sPlayerbotAIConfig->tooCloseDistance) / 10.0f);
for (float dist = maxAllowedDistance; dist >= sPlayerbotAIConfig->tooCloseDistance; dist -= distIncrement)
{
float angleIncrement = std::max(M_PI / 20, M_PI / 4 / (1.0 + dist - sPlayerbotAIConfig->tooCloseDistance));
for (float add = 0.0f; add < M_PI / 4 + angleIncrement; add += angleIncrement)
{
for (float angle = add; angle < add + 2 * static_cast<float>(M_PI) + angleIncrement; angle += static_cast<float>(M_PI) / 4)
for (float angle = add; angle < add + 2 * static_cast<float>(M_PI) + angleIncrement;
angle += static_cast<float>(M_PI) / 4)
{
if (intersectsOri(angle, enemyOri, angleIncrement))
continue;
float x = botPosX + cos(angle) * maxAllowedDistance, y = botPosY + sin(angle) * maxAllowedDistance, z = botPosZ + CONTACT_DISTANCE;
if (forceMaxDistance && sServerFacade->IsDistanceLessThan(sServerFacade->GetDistance2d(bot, x, y), maxAllowedDistance - sPlayerbotAIConfig->tooCloseDistance))
float x = botPosX + cos(angle) * maxAllowedDistance, y = botPosY + sin(angle) * maxAllowedDistance,
z = botPosZ + CONTACT_DISTANCE;
if (forceMaxDistance &&
sServerFacade->IsDistanceLessThan(sServerFacade->GetDistance2d(bot, x, y),
maxAllowedDistance - sPlayerbotAIConfig->tooCloseDistance))
continue;
bot->UpdateAllowedPositionZ(x, y, z);
@@ -99,7 +113,8 @@ void FleeManager::calculatePossibleDestinations(std::vector<FleePoint*> &points)
FleePoint* point = new FleePoint(botAI, x, y, z);
calculateDistanceToCreatures(point);
if (sServerFacade->IsDistanceGreaterOrEqualThan(point->minDistance - start.minDistance, sPlayerbotAIConfig->followDistance))
if (sServerFacade->IsDistanceGreaterOrEqualThan(point->minDistance - start.minDistance,
sPlayerbotAIConfig->followDistance))
points.push_back(point);
else
delete point;
@@ -108,14 +123,14 @@ void FleeManager::calculatePossibleDestinations(std::vector<FleePoint*> &points)
}
}
void FleeManager::cleanup(std::vector<FleePoint*> &points)
void FleeManager::cleanup(std::vector<FleePoint*>& points)
{
for (std::vector<FleePoint*>::iterator i = points.begin(); i != points.end(); i++)
for (std::vector<FleePoint*>::iterator i = points.begin(); i != points.end(); i++)
{
delete *i;
}
delete *i;
}
points.clear();
points.clear();
}
bool FleeManager::isBetterThan(FleePoint* point, FleePoint* other)
@@ -123,23 +138,23 @@ bool FleeManager::isBetterThan(FleePoint* point, FleePoint* other)
return point->sumDistance - other->sumDistance > 0;
}
FleePoint* FleeManager::selectOptimalDestination(std::vector<FleePoint*> &points)
FleePoint* FleeManager::selectOptimalDestination(std::vector<FleePoint*>& points)
{
FleePoint* best = nullptr;
for (std::vector<FleePoint*>::iterator i = points.begin(); i != points.end(); i++)
FleePoint* best = nullptr;
for (std::vector<FleePoint*>::iterator i = points.begin(); i != points.end(); i++)
{
FleePoint* point = *i;
if (!best || isBetterThan(point, best))
FleePoint* point = *i;
if (!best || isBetterThan(point, best))
best = point;
}
}
return best;
return best;
}
bool FleeManager::CalculateDestination(float* rx, float* ry, float* rz)
{
std::vector<FleePoint*> points;
calculatePossibleDestinations(points);
calculatePossibleDestinations(points);
FleePoint* point = selectOptimalDestination(points);
if (!point)
@@ -148,18 +163,19 @@ bool FleeManager::CalculateDestination(float* rx, float* ry, float* rz)
return false;
}
*rx = point->x;
*ry = point->y;
*rz = point->z;
*rx = point->x;
*ry = point->y;
*rz = point->z;
cleanup(points);
return true;
return true;
}
bool FleeManager::isUseful()
{
PlayerbotAI* botAI = GET_PLAYERBOT_AI(bot);
if (!botAI) {
if (!botAI)
{
return false;
}
GuidVector units = *botAI->GetAiObjectContext()->GetValue<GuidVector>("possible targets no los");
@@ -169,7 +185,8 @@ bool FleeManager::isUseful()
if (!creature)
continue;
if (startPosition.sqDistance(WorldPosition(creature)) < creature->GetAttackDistance(bot) * creature->GetAttackDistance(bot))
if (startPosition.sqDistance(WorldPosition(creature)) <
creature->GetAttackDistance(bot) * creature->GetAttackDistance(bot))
return true;
// float d = sServerFacade->GetDistance2d(unit, bot);

59
src/FleeManager.h
View File

@@ -1,54 +1,59 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#ifndef _PLAYERBOT_FLEEMANAGER_H
#define _PLAYERBOT_FLEEMANAGER_H
#include <vector>
#include "Common.h"
#include "TravelMgr.h"
#include <vector>
class Player;
class PlayerbotAI;
class FleePoint
{
public:
FleePoint(PlayerbotAI* botAI, float x, float y, float z) : botAI(botAI), sumDistance(0.0f), minDistance(0.0f), x(x), y(y), z(z) { }
public:
FleePoint(PlayerbotAI* botAI, float x, float y, float z)
: botAI(botAI), sumDistance(0.0f), minDistance(0.0f), x(x), y(y), z(z)
{
}
float x;
float y;
float z;
float x;
float y;
float z;
float sumDistance;
float minDistance;
float sumDistance;
float minDistance;
private:
PlayerbotAI* botAI;
private:
PlayerbotAI* botAI;
};
class FleeManager
{
public:
FleeManager(Player* bot, float maxAllowedDistance, float followAngle, bool forceMaxDistance = false, WorldPosition startPosition = WorldPosition());
public:
FleeManager(Player* bot, float maxAllowedDistance, float followAngle, bool forceMaxDistance = false,
WorldPosition startPosition = WorldPosition());
bool CalculateDestination(float* rx, float* ry, float* rz);
bool isUseful();
bool CalculateDestination(float* rx, float* ry, float* rz);
bool isUseful();
private:
void calculatePossibleDestinations(std::vector<FleePoint*> &points);
void calculateDistanceToCreatures(FleePoint *point);
void cleanup(std::vector<FleePoint*> &points);
FleePoint* selectOptimalDestination(std::vector<FleePoint*> &points);
bool isBetterThan(FleePoint* point, FleePoint* other);
private:
void calculatePossibleDestinations(std::vector<FleePoint*>& points);
void calculateDistanceToCreatures(FleePoint* point);
void cleanup(std::vector<FleePoint*>& points);
FleePoint* selectOptimalDestination(std::vector<FleePoint*>& points);
bool isBetterThan(FleePoint* point, FleePoint* other);
Player* bot;
float maxAllowedDistance;
[[maybe_unused]] float followAngle; // unused - whipowill
bool forceMaxDistance;
WorldPosition startPosition;
Player* bot;
float maxAllowedDistance;
[[maybe_unused]] float followAngle; // unused - whipowill
bool forceMaxDistance;
WorldPosition startPosition;
};
#endif

181
src/GuildTaskMgr.cpp
View File

@@ -1,15 +1,17 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#include "GuildTaskMgr.h"
#include "ChatHelper.h"
#include "GuildMgr.h"
#include "Group.h"
#include "GuildMgr.h"
#include "Mail.h"
#include "MapMgr.h"
#include "Playerbots.h"
#include "PlayerbotFactory.h"
#include "Playerbots.h"
#include "RandomItemMgr.h"
#include "ServerFacade.h"
@@ -42,13 +44,15 @@ void GuildTaskMgr::Update(Player* player, Player* guildMaster)
if (!player->IsFriendlyTo(guildMaster))
return;
Guild* guild = sGuildMgr->GetGuildById(guildMaster->GetGuildId());
Guild* guild = sGuildMgr->GetGuildById(guildMaster->GetGuildId());
DenyReason reason = PLAYERBOT_DENY_NONE;
PlayerbotSecurityLevel secLevel = masterBotAI->GetSecurity()->LevelFor(player, &reason);
if (secLevel == PLAYERBOT_SECURITY_DENY_ALL || (secLevel == PLAYERBOT_SECURITY_TALK && reason != PLAYERBOT_DENY_FAR))
if (secLevel == PLAYERBOT_SECURITY_DENY_ALL ||
(secLevel == PLAYERBOT_SECURITY_TALK && reason != PLAYERBOT_DENY_FAR))
{
LOG_DEBUG("playerbots", "{} / {}: skipping guild task update - not enough security level, reason = {}", guild->GetName().c_str(), player->GetName().c_str(), reason);
LOG_DEBUG("playerbots", "{} / {}: skipping guild task update - not enough security level, reason = {}",
guild->GetName().c_str(), player->GetName().c_str(), reason);
return;
}
@@ -72,14 +76,18 @@ void GuildTaskMgr::Update(Player* player, Player* guildMaster)
if (task == GUILD_TASK_TYPE_NONE)
{
LOG_ERROR("playerbots", "{} / {}: error creating guild task", guild->GetName().c_str(), player->GetName().c_str());
LOG_ERROR("playerbots", "{} / {}: error creating guild task", guild->GetName().c_str(),
player->GetName().c_str());
}
uint32 time = urand(sPlayerbotAIConfig->minGuildTaskChangeTime, sPlayerbotAIConfig->maxGuildTaskChangeTime);
SetTaskValue(owner, guildId, "activeTask", task, time);
SetTaskValue(owner, guildId, "advertisement", 1, urand(sPlayerbotAIConfig->minGuildTaskAdvertisementTime, sPlayerbotAIConfig->maxGuildTaskAdvertisementTime));
SetTaskValue(owner, guildId, "advertisement", 1,
urand(sPlayerbotAIConfig->minGuildTaskAdvertisementTime,
sPlayerbotAIConfig->maxGuildTaskAdvertisementTime));
LOG_DEBUG("playerbots", "{} / {}: guild task {} is set for {} secs", guild->GetName().c_str(), player->GetName().c_str(), task, time);
LOG_DEBUG("playerbots", "{} / {}: guild task {} is set for {} secs", guild->GetName().c_str(),
player->GetName().c_str(), task, time);
return;
}
@@ -92,11 +100,14 @@ void GuildTaskMgr::Update(Player* player, Player* guildMaster)
if (SendAdvertisement(trans, owner, guildId))
{
SetTaskValue(owner, guildId, "advertisement", 1, urand(sPlayerbotAIConfig->minGuildTaskAdvertisementTime, sPlayerbotAIConfig->maxGuildTaskAdvertisementTime));
SetTaskValue(owner, guildId, "advertisement", 1,
urand(sPlayerbotAIConfig->minGuildTaskAdvertisementTime,
sPlayerbotAIConfig->maxGuildTaskAdvertisementTime));
}
else
{
LOG_DEBUG("playerbots", "{} / {}: error sending advertisement", guild->GetName().c_str(), player->GetName().c_str());
LOG_DEBUG("playerbots", "{} / {}: error sending advertisement", guild->GetName().c_str(),
player->GetName().c_str());
}
}
@@ -112,7 +123,8 @@ void GuildTaskMgr::Update(Player* player, Player* guildMaster)
}
else
{
LOG_DEBUG("playerbots", "{} / {}: error sending thanks", guild->GetName().c_str(), player->GetName().c_str());
LOG_DEBUG("playerbots", "{} / {}: error sending thanks", guild->GetName().c_str(),
player->GetName().c_str());
}
}
@@ -128,7 +140,8 @@ void GuildTaskMgr::Update(Player* player, Player* guildMaster)
}
else
{
LOG_DEBUG("playerbots", "{} / {}: error sending reward", guild->GetName().c_str(), player->GetName().c_str());
LOG_DEBUG("playerbots", "{} / {}: error sending reward", guild->GetName().c_str(),
player->GetName().c_str());
}
}
@@ -151,7 +164,7 @@ uint32 GuildTaskMgr::CreateTask(Player* owner, uint32 guildId)
class RandomItemBySkillGuildTaskPredicate : public RandomItemPredicate
{
public:
RandomItemBySkillGuildTaskPredicate(Player* player) : RandomItemPredicate(), player(player) { }
RandomItemBySkillGuildTaskPredicate(Player* player) : RandomItemPredicate(), player(player) {}
bool Apply(ItemTemplate const* proto) override
{
@@ -180,16 +193,20 @@ bool GuildTaskMgr::CreateItemTask(Player* player, uint32 guildId)
uint32 itemId = sRandomItemMgr->GetRandomItem(player->GetLevel() - 5, RANDOM_ITEM_GUILD_TASK, &predicate);
if (!itemId)
{
LOG_ERROR("playerbots", "{} / {}: no items avaible for item task", sGuildMgr->GetGuildById(guildId)->GetName().c_str(), player->GetName().c_str());
LOG_ERROR("playerbots", "{} / {}: no items avaible for item task",
sGuildMgr->GetGuildById(guildId)->GetName().c_str(), player->GetName().c_str());
return false;
}
uint32 count = GetMaxItemTaskCount(itemId);
LOG_DEBUG("playerbots", "{} / {}: item task {} (x{})", sGuildMgr->GetGuildById(guildId)->GetName().c_str(), player->GetName().c_str(), itemId, count);
LOG_DEBUG("playerbots", "{} / {}: item task {} (x{})", sGuildMgr->GetGuildById(guildId)->GetName().c_str(),
player->GetName().c_str(), itemId, count);
SetTaskValue(player->GetGUID().GetCounter(), guildId, "itemCount", count, sPlayerbotAIConfig->maxGuildTaskChangeTime);
SetTaskValue(player->GetGUID().GetCounter(), guildId, "itemTask", itemId, sPlayerbotAIConfig->maxGuildTaskChangeTime);
SetTaskValue(player->GetGUID().GetCounter(), guildId, "itemCount", count,
sPlayerbotAIConfig->maxGuildTaskChangeTime);
SetTaskValue(player->GetGUID().GetCounter(), guildId, "itemTask", itemId,
sPlayerbotAIConfig->maxGuildTaskChangeTime);
return true;
}
@@ -204,8 +221,10 @@ bool GuildTaskMgr::CreateKillTask(Player* player, uint32 guildId)
std::vector<uint32> ids;
uint32 level = player->GetLevel();
QueryResult results = WorldDatabase.Query("SELECT ct.Entry, c.map, c.position_x, c.position_y, ct.Name FROM creature_template ct "
"JOIN creature c ON ct.Entry = c.id1 WHERE ct.MaxLevel < {} AND ct.MinLevel > {} AND ct.Rank = {} ", level + 4, level - 3, rank);
QueryResult results = WorldDatabase.Query(
"SELECT ct.Entry, c.map, c.position_x, c.position_y, ct.Name FROM creature_template ct "
"JOIN creature c ON ct.Entry = c.id1 WHERE ct.MaxLevel < {} AND ct.MinLevel > {} AND ct.Rank = {} ",
level + 4, level - 3, rank);
if (results)
{
do
@@ -231,16 +250,19 @@ bool GuildTaskMgr::CreateKillTask(Player* player, uint32 guildId)
if (ids.empty())
{
LOG_ERROR("playerbots", "{} / {}: no rare creatures available for kill task", sGuildMgr->GetGuildById(guildId)->GetName().c_str(), player->GetName().c_str());
LOG_ERROR("playerbots", "{} / {}: no rare creatures available for kill task",
sGuildMgr->GetGuildById(guildId)->GetName().c_str(), player->GetName().c_str());
return false;
}
uint32 index = urand(0, ids.size() - 1);
uint32 creatureId = ids[index];
LOG_DEBUG("playerbots", "{} / {}: kill task {}", sGuildMgr->GetGuildById(guildId)->GetName().c_str(), player->GetName().c_str(), creatureId);
LOG_DEBUG("playerbots", "{} / {}: kill task {}", sGuildMgr->GetGuildById(guildId)->GetName().c_str(),
player->GetName().c_str(), creatureId);
SetTaskValue(player->GetGUID().GetCounter(), guildId, "killTask", creatureId, sPlayerbotAIConfig->maxGuildTaskChangeTime);
SetTaskValue(player->GetGUID().GetCounter(), guildId, "killTask", creatureId,
sPlayerbotAIConfig->maxGuildTaskChangeTime);
return true;
}
@@ -283,7 +305,8 @@ std::string const formatTime(uint32 secs)
else if (secs < 3600 * 24)
{
out << secs / 3600 << " hr";
} else
}
else
{
out << secs / 3600 / 24 << " days";
}
@@ -294,7 +317,7 @@ std::string const formatTime(uint32 secs)
std::string const formatDateTime(uint32 secs)
{
time_t rawtime = time(nullptr) + secs;
tm* timeinfo = localtime (&rawtime);
tm* timeinfo = localtime(&rawtime);
char buffer[256];
strftime(buffer, sizeof(buffer), "%b %d, %H:%M", timeinfo);
@@ -318,7 +341,8 @@ std::string const GetHelloText(uint32 owner)
return body.str();
}
bool GuildTaskMgr::SendItemAdvertisement(CharacterDatabaseTransaction& trans, uint32 itemId, uint32 owner, uint32 guildId, uint32 validIn)
bool GuildTaskMgr::SendItemAdvertisement(CharacterDatabaseTransaction& trans, uint32 itemId, uint32 owner,
uint32 guildId, uint32 validIn)
{
Guild* guild = sGuildMgr->GetGuildById(guildId);
Player* leader = ObjectAccessor::FindPlayer(guild->GetLeaderGUID());
@@ -352,7 +376,8 @@ bool GuildTaskMgr::SendItemAdvertisement(CharacterDatabaseTransaction& trans, ui
return true;
}
bool GuildTaskMgr::SendKillAdvertisement(CharacterDatabaseTransaction& trans, uint32 creatureId, uint32 owner, uint32 guildId, uint32 validIn)
bool GuildTaskMgr::SendKillAdvertisement(CharacterDatabaseTransaction& trans, uint32 creatureId, uint32 owner,
uint32 guildId, uint32 validIn)
{
Guild* guild = sGuildMgr->GetGuildById(guildId);
Player* leader = ObjectAccessor::FindPlayer(guild->GetLeaderGUID());
@@ -361,7 +386,8 @@ bool GuildTaskMgr::SendKillAdvertisement(CharacterDatabaseTransaction& trans, ui
if (!proto)
return false;
QueryResult result = WorldDatabase.Query("SELECT map, position_x, position_y, position_z FROM creature WHERE id1 = {}", creatureId);
QueryResult result =
WorldDatabase.Query("SELECT map, position_x, position_y, position_z FROM creature WHERE id1 = {}", creatureId);
if (!result)
return false;
@@ -387,7 +413,8 @@ bool GuildTaskMgr::SendKillAdvertisement(CharacterDatabaseTransaction& trans, ui
std::ostringstream body;
body << GetHelloText(owner);
body << "As you probably know " << proto->Name << " is wanted dead for the crimes it did against our guild. If you should kill it ";
body << "As you probably know " << proto->Name
<< " is wanted dead for the crimes it did against our guild. If you should kill it ";
body << "we'd really appreciate that.\n\n";
if (!location.empty())
body << proto->Name << "'s the last known location was " << location << ".\n";
@@ -399,7 +426,8 @@ bool GuildTaskMgr::SendKillAdvertisement(CharacterDatabaseTransaction& trans, ui
std::ostringstream subject;
subject << "Guild Task: ";
if (proto->rank == CREATURE_ELITE_ELITE || proto->rank == CREATURE_ELITE_RAREELITE || proto->rank == CREATURE_ELITE_WORLDBOSS)
if (proto->rank == CREATURE_ELITE_ELITE || proto->rank == CREATURE_ELITE_RAREELITE ||
proto->rank == CREATURE_ELITE_WORLDBOSS)
subject << "(Elite) ";
subject << proto->Name;
if (!location.empty())
@@ -441,9 +469,7 @@ bool GuildTaskMgr::SendThanks(CharacterDatabaseTransaction& trans, uint32 owner,
body << guild->GetName() << "\n";
body << leader->GetName() << "\n";
MailDraft("Thank You", body.str()).
AddMoney(payment).
SendMailTo(trans, MailReceiver(owner), MailSender(leader));
MailDraft("Thank You", body.str()).AddMoney(payment).SendMailTo(trans, MailReceiver(owner), MailSender(leader));
Player* player = ObjectAccessor::FindPlayer(ObjectGuid::Create<HighGuid::Player>(owner));
if (player)
@@ -501,7 +527,8 @@ bool GuildTaskMgr::IsGuildTaskItem(uint32 itemId, uint32 guildId)
{
uint32 value = 0;
PlayerbotsDatabasePreparedStatement* stmt = PlayerbotsDatabase.GetPreparedStatement(PLAYERBOTS_SEL_GUILD_TASKS_BY_VALUE);
PlayerbotsDatabasePreparedStatement* stmt =
PlayerbotsDatabase.GetPreparedStatement(PLAYERBOTS_SEL_GUILD_TASKS_BY_VALUE);
stmt->SetData(0, itemId);
stmt->SetData(1, guildId);
stmt->SetData(2, "itemTask");
@@ -518,11 +545,13 @@ bool GuildTaskMgr::IsGuildTaskItem(uint32 itemId, uint32 guildId)
return value;
}
std::map<uint32, uint32> GuildTaskMgr::GetTaskValues(uint32 owner, std::string const type, uint32* validIn /* = nullptr */)
std::map<uint32, uint32> GuildTaskMgr::GetTaskValues(uint32 owner, std::string const type,
uint32* validIn /* = nullptr */)
{
std::map<uint32, uint32> results;
PlayerbotsDatabasePreparedStatement* stmt = PlayerbotsDatabase.GetPreparedStatement(PLAYERBOTS_SEL_GUILD_TASKS_BY_OWNER);
PlayerbotsDatabasePreparedStatement* stmt =
PlayerbotsDatabase.GetPreparedStatement(PLAYERBOTS_SEL_GUILD_TASKS_BY_OWNER);
stmt->SetData(0, owner);
stmt->SetData(1, type);
if (PreparedQueryResult result = PlayerbotsDatabase.Query(stmt))
@@ -542,14 +571,15 @@ std::map<uint32, uint32> GuildTaskMgr::GetTaskValues(uint32 owner, std::string c
} while (result->NextRow());
}
return std::move(results);
return std::move(results);
}
uint32 GuildTaskMgr::GetTaskValue(uint32 owner, uint32 guildId, std::string const type, uint32* validIn /* = nullptr */)
{
uint32 value = 0;
PlayerbotsDatabasePreparedStatement* stmt = PlayerbotsDatabase.GetPreparedStatement(PLAYERBOTS_SEL_GUILD_TASKS_BY_OWNER_AND_TYPE);
PlayerbotsDatabasePreparedStatement* stmt =
PlayerbotsDatabase.GetPreparedStatement(PLAYERBOTS_SEL_GUILD_TASKS_BY_OWNER_AND_TYPE);
stmt->SetData(0, owner);
stmt->SetData(1, guildId);
stmt->SetData(2, type);
@@ -566,7 +596,7 @@ uint32 GuildTaskMgr::GetTaskValue(uint32 owner, uint32 guildId, std::string cons
*validIn = secs;
}
return value;
return value;
}
uint32 GuildTaskMgr::SetTaskValue(uint32 owner, uint32 guildId, std::string const type, uint32 value, uint32 validIn)
@@ -596,13 +626,13 @@ bool GuildTaskMgr::HandleConsoleCommand(ChatHandler* handler, char const* args)
{
if (!sPlayerbotAIConfig->guildTaskEnabled)
{
LOG_ERROR("playerbots", "Guild task system is currently disabled!");
LOG_ERROR("playerbots", "Guild task system is currently disabled!");
return false;
}
if (!args || !*args)
{
LOG_ERROR("playerbots", "Usage: gtask stats/reset");
LOG_ERROR("playerbots", "Usage: gtask stats/reset");
return false;
}
@@ -627,13 +657,14 @@ bool GuildTaskMgr::HandleConsoleCommand(ChatHandler* handler, char const* args)
ObjectGuid guid = sCharacterCache->GetCharacterGuidByName(charName);
if (!guid)
{
LOG_ERROR("playerbots", "Player {} not found", charName.c_str());
LOG_ERROR("playerbots", "Player {} not found", charName.c_str());
return false;
}
uint32 owner = guid.GetCounter();
PlayerbotsDatabasePreparedStatement* stmt = PlayerbotsDatabase.GetPreparedStatement(PLAYERBOTS_SEL_GUILD_TASKS_BY_OWNER_ORDERED);
PlayerbotsDatabasePreparedStatement* stmt =
PlayerbotsDatabase.GetPreparedStatement(PLAYERBOTS_SEL_GUILD_TASKS_BY_OWNER_ORDERED);
stmt->SetData(0, owner);
stmt->SetData(1, "activeTask");
if (PreparedQueryResult result = PlayerbotsDatabase.Query(stmt))
@@ -731,11 +762,10 @@ bool GuildTaskMgr::HandleConsoleCommand(ChatHandler* handler, char const* args)
if (payment && paymentValidIn < validIn)
name << " payment " << ChatHelper::formatMoney(payment) << " in " << formatTime(paymentValidIn);
LOG_INFO("playerbots", "{}: {} valid in {} [{}]",
charName.c_str(), name.str().c_str(), formatTime(validIn).c_str(), guild->GetName().c_str());
LOG_INFO("playerbots", "{}: {} valid in {} [{}]", charName.c_str(), name.str().c_str(),
formatTime(validIn).c_str(), guild->GetName().c_str());
}
while (result->NextRow());
} while (result->NextRow());
}
return true;
@@ -774,13 +804,14 @@ bool GuildTaskMgr::HandleConsoleCommand(ChatHandler* handler, char const* args)
ObjectGuid guid = sCharacterCache->GetCharacterGuidByName(charName);
if (!guid)
{
LOG_ERROR("playerbots", "Player {} not found", charName.c_str());
LOG_ERROR("playerbots", "Player {} not found", charName.c_str());
return false;
}
uint32 owner = guid.GetCounter();
PlayerbotsDatabasePreparedStatement* stmt = PlayerbotsDatabase.GetPreparedStatement(PLAYERBOTS_SEL_GUILD_TASKS_BY_OWNER_DISTINCT);
PlayerbotsDatabasePreparedStatement* stmt =
PlayerbotsDatabase.GetPreparedStatement(PLAYERBOTS_SEL_GUILD_TASKS_BY_OWNER_DISTINCT);
stmt->SetData(0, owner);
if (PreparedQueryResult result = PlayerbotsDatabase.Query(stmt))
{
@@ -818,19 +849,20 @@ bool GuildTaskMgr::CheckItemTask(uint32 itemId, uint32 obtained, Player* ownerPl
return false;
uint32 owner = ownerPlayer->GetGUID().GetCounter();
Guild* guild = sGuildMgr->GetGuildById(bot->GetGuildId());
if (!guild)
return false;
Guild* guild = sGuildMgr->GetGuildById(bot->GetGuildId());
if (!guild)
return false;
if (!sRandomPlayerbotMgr->IsRandomBot(bot))
return false;
if (!sRandomPlayerbotMgr->IsRandomBot(bot))
return false;
LOG_DEBUG("playerbots", "{} / {}: checking guild task", guild->GetName().c_str(), ownerPlayer->GetName().c_str());
uint32 itemTask = GetTaskValue(owner, guildId, "itemTask");
if (itemTask != itemId)
{
LOG_DEBUG("playerbots", "{} / {}: item {} is not guild task item ({})", guild->GetName().c_str(), ownerPlayer->GetName().c_str(), itemId, itemTask);
LOG_DEBUG("playerbots", "{} / {}: item {} is not guild task item ({})", guild->GetName().c_str(),
ownerPlayer->GetName().c_str(), itemId, itemTask);
if (byMail)
SendCompletionMessage(ownerPlayer, "made a mistake with");
@@ -857,7 +889,8 @@ bool GuildTaskMgr::CheckItemTask(uint32 itemId, uint32 obtained, Player* ownerPl
if (obtained >= count)
{
LOG_DEBUG("playerbots", "{} / {}: guild task complete", guild->GetName().c_str(), ownerPlayer->GetName().c_str());
LOG_DEBUG("playerbots", "{} / {}: guild task complete", guild->GetName().c_str(),
ownerPlayer->GetName().c_str());
SetTaskValue(owner, guildId, "reward", 1, rewardTime - 15);
SetTaskValue(owner, guildId, "itemCount", 0, 0);
SetTaskValue(owner, guildId, "thanks", 0, 0);
@@ -865,7 +898,8 @@ bool GuildTaskMgr::CheckItemTask(uint32 itemId, uint32 obtained, Player* ownerPl
}
else
{
LOG_DEBUG("playerbots", "{} / {}: guild task progress {}/{}", guild->GetName().c_str(), ownerPlayer->GetName().c_str(), obtained, count);
LOG_DEBUG("playerbots", "{} / {}: guild task progress {}/{}", guild->GetName().c_str(),
ownerPlayer->GetName().c_str(), obtained, count);
SetTaskValue(owner, guildId, "itemCount", count - obtained, sPlayerbotAIConfig->maxGuildTaskChangeTime);
SetTaskValue(owner, guildId, "thanks", 1, rewardTime - 30);
SendCompletionMessage(ownerPlayer, "made a progress with");
@@ -904,12 +938,14 @@ bool GuildTaskMgr::Reward(CharacterDatabaseTransaction& trans, uint32 owner, uin
if (!proto)
return false;
body << "We wish to thank you for the " << proto->Name1 << " you provided so kindly. We really appreciate this and may this small gift bring you our thanks!\n";
body << "We wish to thank you for the " << proto->Name1
<< " you provided so kindly. We really appreciate this and may this small gift bring you our thanks!\n";
body << "\n";
body << "Many thanks,\n";
body << guild->GetName() << "\n";
body << leader->GetName() << "\n";
rewardType = proto->Quality > ITEM_QUALITY_NORMAL ? RANDOM_ITEM_GUILD_TASK_REWARD_EQUIP_BLUE : RANDOM_ITEM_GUILD_TASK_REWARD_EQUIP_GREEN;
rewardType = proto->Quality > ITEM_QUALITY_NORMAL ? RANDOM_ITEM_GUILD_TASK_REWARD_EQUIP_BLUE
: RANDOM_ITEM_GUILD_TASK_REWARD_EQUIP_GREEN;
itemId = sRandomItemMgr->GetRandomItem(player->GetLevel() - 5, rewardType);
}
else if (killTask)
@@ -918,12 +954,14 @@ bool GuildTaskMgr::Reward(CharacterDatabaseTransaction& trans, uint32 owner, uin
if (!proto)
return false;
body << "We wish to thank you for the " << proto->Name << " you've killed recently. We really appreciate this and may this small gift bring you our thanks!\n";
body << "We wish to thank you for the " << proto->Name
<< " you've killed recently. We really appreciate this and may this small gift bring you our thanks!\n";
body << "\n";
body << "Many thanks,\n";
body << guild->GetName() << "\n";
body << leader->GetName() << "\n";
rewardType = proto->rank == CREATURE_ELITE_RARE ? RANDOM_ITEM_GUILD_TASK_REWARD_TRADE : RANDOM_ITEM_GUILD_TASK_REWARD_TRADE_RARE;
rewardType = proto->rank == CREATURE_ELITE_RARE ? RANDOM_ITEM_GUILD_TASK_REWARD_TRADE
: RANDOM_ITEM_GUILD_TASK_REWARD_TRADE_RARE;
itemId = sRandomItemMgr->GetRandomItem(player->GetLevel(), rewardType);
if (itemId)
{
@@ -1032,7 +1070,8 @@ void GuildTaskMgr::CheckKillTaskInternal(Player* player, Unit* victim)
continue;
LOG_DEBUG("playerbots", "{} / {}: guild task complete", guild->GetName().c_str(), player->GetName().c_str());
SetTaskValue(owner, guildId, "reward", 1, urand(sPlayerbotAIConfig->minGuildTaskRewardTime, sPlayerbotAIConfig->maxGuildTaskRewardTime));
SetTaskValue(owner, guildId, "reward", 1,
urand(sPlayerbotAIConfig->minGuildTaskRewardTime, sPlayerbotAIConfig->maxGuildTaskRewardTime));
SendCompletionMessage(player, "completed");
}
@@ -1041,7 +1080,8 @@ void GuildTaskMgr::CheckKillTaskInternal(Player* player, Unit* victim)
void GuildTaskMgr::CleanupAdverts()
{
uint32 deliverTime = time(nullptr) - sPlayerbotAIConfig->minGuildTaskChangeTime;
QueryResult result = CharacterDatabase.Query("SELECT id, receiver FROM mail WHERE subject LIKE 'Guild Task%%' AND deliver_time <= {}", deliverTime);
QueryResult result = CharacterDatabase.Query(
"SELECT id, receiver FROM mail WHERE subject LIKE 'Guild Task%%' AND deliver_time <= {}", deliverTime);
if (!result)
return;
@@ -1059,7 +1099,8 @@ void GuildTaskMgr::CleanupAdverts()
if (count > 0)
{
CharacterDatabase.Execute("DELETE FROM mail WHERE subject LIKE 'Guild Task%%' AND deliver_time <= {}", deliverTime);
CharacterDatabase.Execute("DELETE FROM mail WHERE subject LIKE 'Guild Task%%' AND deliver_time <= {}",
deliverTime);
LOG_INFO("playerbots", "{} old gtask adverts removed", count);
}
}
@@ -1067,8 +1108,12 @@ void GuildTaskMgr::CleanupAdverts()
void GuildTaskMgr::RemoveDuplicatedAdverts()
{
uint32 deliverTime = time(nullptr);
QueryResult result = CharacterDatabase.Query("SELECT m.id, m.receiver FROM (SELECT MAX(id) AS id, subject, receiver FROM mail WHERE subject LIKE 'Guild Task%%' "
"AND deliver_time <= {} GROUP BY subject, receiver) q JOIN mail m ON m.subject = q.subject WHERE m.id <> q.id AND m.deliver_time <= {}", deliverTime, deliverTime);
QueryResult result = CharacterDatabase.Query(
"SELECT m.id, m.receiver FROM (SELECT MAX(id) AS id, subject, receiver FROM mail WHERE subject LIKE 'Guild "
"Task%%' "
"AND deliver_time <= {} GROUP BY subject, receiver) q JOIN mail m ON m.subject = q.subject WHERE m.id <> q.id "
"AND m.deliver_time <= {}",
deliverTime, deliverTime);
if (!result)
return;
@@ -1103,7 +1148,6 @@ void GuildTaskMgr::RemoveDuplicatedAdverts()
DeleteMail(buffer);
LOG_INFO("playerbots", "{} duplicated gtask adverts removed", count);
}
}
void GuildTaskMgr::DeleteMail(std::vector<uint32> buffer)
@@ -1147,7 +1191,8 @@ bool GuildTaskMgr::CheckTaskTransfer(std::string const text, Player* ownerPlayer
if (text.empty())
return false;
LOG_DEBUG("playerbots", "{} / {}: checking guild task transfer", guild->GetName().c_str(), ownerPlayer->GetName().c_str());
LOG_DEBUG("playerbots", "{} / {}: checking guild task transfer", guild->GetName().c_str(),
ownerPlayer->GetName().c_str());
uint32 account = ownerPlayer->GetSession()->GetAccountId();

73
src/GuildTaskMgr.h
View File

@@ -1,57 +1,60 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#ifndef _PLAYERBOT_GUILDTASKMGR_H
#define _PLAYERBOT_GUILDTASKMGR_H
#include <map>
#include "Common.h"
#include "Transaction.h"
#include <map>
class ChatHandler;
class Player;
class Unit;
class GuildTaskMgr
{
public:
GuildTaskMgr() { };
virtual ~GuildTaskMgr() { };
public:
GuildTaskMgr(){};
virtual ~GuildTaskMgr(){};
static GuildTaskMgr* instance()
{
static GuildTaskMgr instance;
return &instance;
}
static GuildTaskMgr* instance()
{
static GuildTaskMgr instance;
return &instance;
}
void Update(Player* owner, Player* guildMaster);
void Update(Player* owner, Player* guildMaster);
static bool HandleConsoleCommand(ChatHandler* handler, char const* args);
bool IsGuildTaskItem(uint32 itemId, uint32 guildId);
bool CheckItemTask(uint32 itemId, uint32 obtained, Player* owner, Player* bot, bool byMail = false);
void CheckKillTask(Player* owner, Unit* victim);
void CheckKillTaskInternal(Player* owner, Unit* victim);
bool CheckTaskTransfer(std::string const text, Player* owner, Player* bot);
static bool HandleConsoleCommand(ChatHandler* handler, char const* args);
bool IsGuildTaskItem(uint32 itemId, uint32 guildId);
bool CheckItemTask(uint32 itemId, uint32 obtained, Player* owner, Player* bot, bool byMail = false);
void CheckKillTask(Player* owner, Unit* victim);
void CheckKillTaskInternal(Player* owner, Unit* victim);
bool CheckTaskTransfer(std::string const text, Player* owner, Player* bot);
private:
std::map<uint32, uint32> GetTaskValues(uint32 owner, std::string const type, uint32* validIn = nullptr);
uint32 GetTaskValue(uint32 owner, uint32 guildId, std::string const type, uint32* validIn = nullptr);
uint32 SetTaskValue(uint32 owner, uint32 guildId, std::string const type, uint32 value, uint32 validIn);
uint32 CreateTask(Player* owner, uint32 guildId);
bool SendAdvertisement(CharacterDatabaseTransaction& trans, uint32 owner, uint32 guildId);
bool SendItemAdvertisement(CharacterDatabaseTransaction& trans, uint32 itemId, uint32 owner, uint32 guildId, uint32 validIn);
bool SendKillAdvertisement(CharacterDatabaseTransaction& trans, uint32 creatureId, uint32 owner, uint32 guildId, uint32 validIn);
bool SendThanks(CharacterDatabaseTransaction& trans, uint32 owner, uint32 guildId, uint32 payment);
bool Reward(CharacterDatabaseTransaction& trans, uint32 owner, uint32 guildId);
bool CreateItemTask(Player* owner, uint32 guildId);
bool CreateKillTask(Player* owner, uint32 guildId);
uint32 GetMaxItemTaskCount(uint32 itemId);
void CleanupAdverts();
void RemoveDuplicatedAdverts();
void DeleteMail(std::vector<uint32> buffer);
void SendCompletionMessage(Player* player, std::string const verb);
private:
std::map<uint32, uint32> GetTaskValues(uint32 owner, std::string const type, uint32* validIn = nullptr);
uint32 GetTaskValue(uint32 owner, uint32 guildId, std::string const type, uint32* validIn = nullptr);
uint32 SetTaskValue(uint32 owner, uint32 guildId, std::string const type, uint32 value, uint32 validIn);
uint32 CreateTask(Player* owner, uint32 guildId);
bool SendAdvertisement(CharacterDatabaseTransaction& trans, uint32 owner, uint32 guildId);
bool SendItemAdvertisement(CharacterDatabaseTransaction& trans, uint32 itemId, uint32 owner, uint32 guildId,
uint32 validIn);
bool SendKillAdvertisement(CharacterDatabaseTransaction& trans, uint32 creatureId, uint32 owner, uint32 guildId,
uint32 validIn);
bool SendThanks(CharacterDatabaseTransaction& trans, uint32 owner, uint32 guildId, uint32 payment);
bool Reward(CharacterDatabaseTransaction& trans, uint32 owner, uint32 guildId);
bool CreateItemTask(Player* owner, uint32 guildId);
bool CreateKillTask(Player* owner, uint32 guildId);
uint32 GetMaxItemTaskCount(uint32 itemId);
void CleanupAdverts();
void RemoveDuplicatedAdverts();
void DeleteMail(std::vector<uint32> buffer);
void SendCompletionMessage(Player* player, std::string const verb);
};
#define sGuildTaskMgr GuildTaskMgr::instance()

14
src/Helpers.cpp
View File

@@ -1,5 +1,6 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#include "Helpers.h"
@@ -15,7 +16,7 @@ char* strstri(char const* haystack, char const* needle)
{
if (tolower(*haystack) == tolower(*needle))
{
char const* h = haystack, * n = needle;
char const *h = haystack, *n = needle;
for (; *h && *n; ++h, ++n)
{
if (tolower(*h) != tolower(*n))
@@ -36,17 +37,14 @@ char* strstri(char const* haystack, char const* needle)
std::string& ltrim(std::string& s)
{
s.erase(s.begin(), std::find_if(s.begin(), s.end(), [](int c) {return !std::isspace(c); }));
s.erase(s.begin(), std::find_if(s.begin(), s.end(), [](int c) { return !std::isspace(c); }));
return s;
}
std::string& rtrim(std::string& s)
{
s.erase(std::find_if(s.rbegin(), s.rend(), [](int c) {return !std::isspace(c); }).base(), s.end());
s.erase(std::find_if(s.rbegin(), s.rend(), [](int c) { return !std::isspace(c); }).base(), s.end());
return s;
}
std::string& trim(std::string& s)
{
return ltrim(rtrim(s));
}
std::string& trim(std::string& s) { return ltrim(rtrim(s)); }

20
src/Helpers.h
View File

@@ -1,21 +1,23 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#ifndef _PLAYERBOT_HELPERS_H
#define _PLAYERBOT_HELPERS_H
#include "Common.h"
#include <map>
#include <vector>
#include <functional>
#include <cctype>
#include <locale>
#include <sstream>
#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <cctype>
#include <functional>
#include <locale>
#include <map>
#include <sstream>
#include <vector>
#include "Common.h"
void split(std::vector<std::string>& dest, std::string const str, char const* delim)
{

47
src/LazyCalculatedValue.h
View File

@@ -1,5 +1,6 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#ifndef _PLAYERBOT_LAZYCALCULATEDVALUE_H
@@ -8,37 +9,31 @@
template <class TValue, class TOwner>
class LazyCalculatedValue
{
public:
typedef TValue (TOwner::*Calculator)();
public:
typedef TValue (TOwner::*Calculator)();
public:
LazyCalculatedValue(TOwner* owner, Calculator calculator) : calculator(calculator), owner(owner)
public:
LazyCalculatedValue(TOwner* owner, Calculator calculator) : calculator(calculator), owner(owner) { Reset(); }
public:
TValue GetValue()
{
if (!calculated)
{
Reset();
value = (owner->*calculator)();
calculated = true;
}
public:
TValue GetValue()
{
if (!calculated)
{
value = (owner->*calculator)();
calculated = true;
}
return value;
}
return value;
}
void Reset() { calculated = false; }
void Reset()
{
calculated = false;
}
protected:
Calculator calculator;
TOwner* owner;
bool calculated;
TValue value;
protected:
Calculator calculator;
TOwner* owner;
bool calculated;
TValue value;
};
#endif

53
src/LootObjectStack.cpp
View File

@@ -1,17 +1,17 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#include "LootObjectStack.h"
#include "LootMgr.h"
#include "Playerbots.h"
#include "Unit.h"
#define MAX_LOOT_OBJECT_COUNT 10
LootTarget::LootTarget(ObjectGuid guid) : guid(guid), asOfTime(time(nullptr))
{
}
LootTarget::LootTarget(ObjectGuid guid) : guid(guid), asOfTime(time(nullptr)) {}
LootTarget::LootTarget(LootTarget const& other)
{
@@ -30,19 +30,16 @@ LootTarget& LootTarget::operator=(LootTarget const& other)
return *this;
}
bool LootTarget::operator<(LootTarget const& other) const
{
return guid < other.guid;
}
bool LootTarget::operator<(LootTarget const& other) const { return guid < other.guid; }
void LootTargetList::shrink(time_t fromTime)
{
for (std::set<LootTarget>::iterator i = begin(); i != end(); )
for (std::set<LootTarget>::iterator i = begin(); i != end();)
{
if (i->asOfTime <= fromTime)
erase(i++);
else
++i;
else
++i;
}
}
@@ -59,7 +56,8 @@ void LootObject::Refresh(Player* bot, ObjectGuid lootGUID)
guid.Clear();
PlayerbotAI* botAI = GET_PLAYERBOT_AI(bot);
if (!botAI) {
if (!botAI)
{
return;
}
Creature* creature = botAI->GetCreature(lootGUID);
@@ -73,7 +71,7 @@ void LootObject::Refresh(Player* bot, ObjectGuid lootGUID)
skillId = creature->GetCreatureTemplate()->GetRequiredLootSkill();
uint32 targetLevel = creature->GetLevel();
reqSkillValue = targetLevel < 10 ? 1 : targetLevel < 20 ? (targetLevel - 10) * 10 : targetLevel * 5;
if (botAI->HasSkill((SkillType) skillId) && bot->GetSkillValue(skillId) >= reqSkillValue)
if (botAI->HasSkill((SkillType)skillId) && bot->GetSkillValue(skillId) >= reqSkillValue)
guid = lootGUID;
}
@@ -83,7 +81,6 @@ void LootObject::Refresh(Player* bot, ObjectGuid lootGUID)
GameObject* go = botAI->GetGameObject(lootGUID);
if (go && go->isSpawned() && go->GetGoState() == GO_STATE_READY)
{
bool isQuestItemOnly = false;
GameObjectQuestItemList const* items = sObjectMgr->GetGameObjectQuestItemList(go->GetEntry());
@@ -123,21 +120,21 @@ void LootObject::Refresh(Player* bot, ObjectGuid lootGUID)
}
break;
case LOCK_KEY_SKILL:
if (goId == 13891 || goId == 19535) // Serpentbloom
if (goId == 13891 || goId == 19535) // Serpentbloom
{
this->guid = lootGUID;
}
else if (SkillByLockType(LockType(lockInfo->Index[i])) > 0)
{
skillId = SkillByLockType(LockType(lockInfo->Index[i]));
reqSkillValue = std::max((uint32) 1, lockInfo->Skill[i]);
reqSkillValue = std::max((uint32)1, lockInfo->Skill[i]);
guid = lootGUID;
}
break;
case LOCK_KEY_NONE:
guid = lootGUID;
break;
}
}
}
}
}
@@ -178,7 +175,8 @@ WorldObject* LootObject::GetWorldObject(Player* bot)
Refresh(bot, guid);
PlayerbotAI* botAI = GET_PLAYERBOT_AI(bot);
if (!botAI) {
if (!botAI)
{
return nullptr;
}
Creature* creature = botAI->GetCreature(guid);
@@ -206,7 +204,8 @@ bool LootObject::IsLootPossible(Player* bot)
return false;
PlayerbotAI* botAI = GET_PLAYERBOT_AI(bot);
if (!botAI) {
if (!botAI)
{
return false;
}
if (reqItem && !bot->HasItemCount(reqItem, 1))
@@ -214,7 +213,7 @@ bool LootObject::IsLootPossible(Player* bot)
if (abs(GetWorldObject(bot)->GetPositionZ() - bot->GetPositionZ()) > INTERACTION_DISTANCE)
return false;
Creature* creature = botAI->GetCreature(guid);
if (creature && creature->getDeathState() == DeathState::Corpse)
{
@@ -249,11 +248,13 @@ bool LootObject::IsLootPossible(Player* bot)
bool LootObjectStack::Add(ObjectGuid guid)
{
if (availableLoot.size() >= MAX_LOOT_OBJECT_COUNT) {
if (availableLoot.size() >= MAX_LOOT_OBJECT_COUNT)
{
availableLoot.shrink(time(nullptr) - 30);
}
if (availableLoot.size() >= MAX_LOOT_OBJECT_COUNT) {
if (availableLoot.size() >= MAX_LOOT_OBJECT_COUNT)
{
availableLoot.clear();
}
@@ -270,10 +271,7 @@ void LootObjectStack::Remove(ObjectGuid guid)
availableLoot.erase(i);
}
void LootObjectStack::Clear()
{
availableLoot.clear();
}
void LootObjectStack::Clear() { availableLoot.clear(); }
bool LootObjectStack::CanLoot(float maxDistance)
{
@@ -299,7 +297,7 @@ std::vector<LootObject> LootObjectStack::OrderByDistance(float maxDistance)
LootObject lootObject(bot, guid);
if (!lootObject.IsLootPossible(bot))
continue;
float distance = bot->GetDistance(lootObject.GetWorldObject(bot));
if (!maxDistance || distance <= maxDistance)
sortedMap[distance] = lootObject;
@@ -311,4 +309,3 @@ std::vector<LootObject> LootObjectStack::OrderByDistance(float maxDistance)
return result;
}

81
src/LootObjectStack.h
View File

@@ -1,5 +1,6 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#ifndef _PLAYERBOT_LOOTOBJECTSTACK_H
@@ -15,29 +16,29 @@ struct ItemTemplate;
class LootStrategy
{
public:
LootStrategy() { }
virtual ~LootStrategy() { };
virtual bool CanLoot(ItemTemplate const* proto, AiObjectContext* context) = 0;
virtual std::string const GetName() = 0;
public:
LootStrategy() {}
virtual ~LootStrategy(){};
virtual bool CanLoot(ItemTemplate const* proto, AiObjectContext* context) = 0;
virtual std::string const GetName() = 0;
};
class LootObject
{
public:
LootObject() : skillId(0), reqSkillValue(0), reqItem(0) { }
LootObject(Player* bot, ObjectGuid guid);
LootObject(LootObject const& other);
public:
LootObject() : skillId(0), reqSkillValue(0), reqItem(0) {}
LootObject(Player* bot, ObjectGuid guid);
LootObject(LootObject const& other);
bool IsEmpty() { return !guid; }
bool IsLootPossible(Player* bot);
void Refresh(Player* bot, ObjectGuid guid);
WorldObject* GetWorldObject(Player* bot);
ObjectGuid guid;
bool IsEmpty() { return !guid; }
bool IsLootPossible(Player* bot);
void Refresh(Player* bot, ObjectGuid guid);
WorldObject* GetWorldObject(Player* bot);
ObjectGuid guid;
uint32 skillId;
uint32 reqSkillValue;
uint32 reqItem;
uint32 skillId;
uint32 reqSkillValue;
uint32 reqItem;
private:
static bool IsNeededForQuest(Player* bot, uint32 itemId);
@@ -45,41 +46,41 @@ private:
class LootTarget
{
public:
LootTarget(ObjectGuid guid);
LootTarget(LootTarget const& other);
public:
LootTarget(ObjectGuid guid);
LootTarget(LootTarget const& other);
public:
LootTarget& operator=(LootTarget const& other);
bool operator<(LootTarget const& other) const;
public:
LootTarget& operator=(LootTarget const& other);
bool operator<(LootTarget const& other) const;
public:
ObjectGuid guid;
time_t asOfTime;
public:
ObjectGuid guid;
time_t asOfTime;
};
class LootTargetList : public std::set<LootTarget>
{
public:
void shrink(time_t fromTime);
public:
void shrink(time_t fromTime);
};
class LootObjectStack
{
public:
LootObjectStack(Player* bot) : bot(bot) { }
public:
LootObjectStack(Player* bot) : bot(bot) {}
bool Add(ObjectGuid guid);
void Remove(ObjectGuid guid);
void Clear();
bool CanLoot(float maxDistance);
LootObject GetLoot(float maxDistance = 0);
bool Add(ObjectGuid guid);
void Remove(ObjectGuid guid);
void Clear();
bool CanLoot(float maxDistance);
LootObject GetLoot(float maxDistance = 0);
private:
std::vector<LootObject> OrderByDistance(float maxDistance = 0);
private:
std::vector<LootObject> OrderByDistance(float maxDistance = 0);
Player* bot;
LootTargetList availableLoot;
Player* bot;
LootTargetList availableLoot;
};
#endif

111
src/PerformanceMonitor.cpp
View File

@@ -1,11 +1,14 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#include "PerformanceMonitor.h"
#include "Playerbots.h"
PerformanceMonitorOperation* PerformanceMonitor::start(PerformanceMetric metric, std::string const name, PerformanceStack* stack)
PerformanceMonitorOperation* PerformanceMonitor::start(PerformanceMetric metric, std::string const name,
PerformanceStack* stack)
{
if (!sPlayerbotAIConfig->perfMonEnabled)
return nullptr;
@@ -50,7 +53,6 @@ void PerformanceMonitor::PrintStats(bool perTick, bool fullStack)
if (data.empty())
return;
if (!perTick)
{
float updateAITotalTime = 0;
@@ -58,11 +60,17 @@ void PerformanceMonitor::PrintStats(bool perTick, bool fullStack)
if (map.first.find("PlayerbotAI::UpdateAIInternal") != std::string::npos)
updateAITotalTime += map.second->totalTime;
LOG_INFO("playerbots", "--------------------------------------[TOTAL BOT]------------------------------------------------------");
LOG_INFO("playerbots", "percentage time | min .. max ( avg of count) - type : name");
LOG_INFO("playerbots", "-------------------------------------------------------------------------------------------------------");
LOG_INFO(
"playerbots",
"--------------------------------------[TOTAL BOT]------------------------------------------------------");
LOG_INFO("playerbots",
"percentage time | min .. max ( avg of count) - type : name");
LOG_INFO(
"playerbots",
"-------------------------------------------------------------------------------------------------------");
for (std::map<PerformanceMetric, std::map<std::string, PerformanceData*>>::iterator i = data.begin(); i != data.end(); ++i)
for (std::map<PerformanceMetric, std::map<std::string, PerformanceData*>>::iterator i = data.begin();
i != data.end(); ++i)
{
std::map<std::string, PerformanceData*> pdMap = i->second;
@@ -99,10 +107,9 @@ void PerformanceMonitor::PrintStats(bool perTick, bool fullStack)
names.push_back(j->first);
}
std::sort(names.begin(), names.end(), [pdMap](std::string const i, std::string const j)
{
return pdMap.at(i)->totalTime < pdMap.at(j)->totalTime;
});
std::sort(names.begin(), names.end(),
[pdMap](std::string const i, std::string const j)
{ return pdMap.at(i)->totalTime < pdMap.at(j)->totalTime; });
uint64 typeTotalTime = 0;
uint64 typeMinTime = 0xffffffffu;
@@ -128,15 +135,9 @@ void PerformanceMonitor::PrintStats(bool perTick, bool fullStack)
if (perc >= 0.1f || avg >= 0.25f || pd->maxTime > 1000)
{
LOG_INFO("playerbots", "{:7.3f}% {:10.3f}s | {:7.1f} .. {:7.1f} ({:10.3f} of {:10d}) - {:6} : {}"
, perc
, time
, minTime
, maxTime
, avg
, pd->count
, key.c_str()
, disName.c_str());
LOG_INFO("playerbots",
"{:7.3f}% {:10.3f}s | {:7.1f} .. {:7.1f} ({:10.3f} of {:10d}) - {:6} : {}", perc, time,
minTime, maxTime, avg, pd->count, key.c_str(), disName.c_str());
}
}
float tPerc = (float)typeTotalTime / (float)updateAITotalTime * 100.0f;
@@ -144,15 +145,8 @@ void PerformanceMonitor::PrintStats(bool perTick, bool fullStack)
float tMinTime = (float)typeMinTime / 1000.0f;
float tMaxTime = (float)typeMaxTime / 1000.0f;
float tAvg = (float)typeTotalTime / (float)typeCount / 1000.0f;
LOG_INFO("playerbots", "{:7.3f}% {:10.3f}s | {:7.1f} .. {:7.1f} ({:10.3f} of {:10d}) - {:6} : {}"
, tPerc
, tTime
, tMinTime
, tMaxTime
, tAvg
, typeCount
, key.c_str()
, "Total");
LOG_INFO("playerbots", "{:7.3f}% {:10.3f}s | {:7.1f} .. {:7.1f} ({:10.3f} of {:10d}) - {:6} : {}", tPerc,
tTime, tMinTime, tMaxTime, tAvg, typeCount, key.c_str(), "Total");
LOG_INFO("playerbots", " ");
}
}
@@ -161,11 +155,17 @@ void PerformanceMonitor::PrintStats(bool perTick, bool fullStack)
float fullTickCount = data[PERF_MON_TOTAL]["RandomPlayerbotMgr::FullTick"]->count;
float fullTickTotalTime = data[PERF_MON_TOTAL]["RandomPlayerbotMgr::FullTick"]->totalTime;
LOG_INFO("playerbots", "---------------------------------------[PER TICK]------------------------------------------------------");
LOG_INFO("playerbots", "percentage time | min .. max ( avg of count) - type : name");
LOG_INFO("playerbots", "-------------------------------------------------------------------------------------------------------");
LOG_INFO(
"playerbots",
"---------------------------------------[PER TICK]------------------------------------------------------");
LOG_INFO("playerbots",
"percentage time | min .. max ( avg of count) - type : name");
LOG_INFO(
"playerbots",
"-------------------------------------------------------------------------------------------------------");
for (std::map<PerformanceMetric, std::map<std::string, PerformanceData*>>::iterator i = data.begin(); i != data.end(); ++i)
for (std::map<PerformanceMetric, std::map<std::string, PerformanceData*>>::iterator i = data.begin();
i != data.end(); ++i)
{
std::map<std::string, PerformanceData*> pdMap = i->second;
@@ -198,10 +198,9 @@ void PerformanceMonitor::PrintStats(bool perTick, bool fullStack)
names.push_back(j->first);
}
std::sort(names.begin(), names.end(), [pdMap](std::string const i, std::string const j)
{
return pdMap.at(i)->totalTime < pdMap.at(j)->totalTime;
});
std::sort(names.begin(), names.end(),
[pdMap](std::string const i, std::string const j)
{ return pdMap.at(i)->totalTime < pdMap.at(j)->totalTime; });
uint64 typeTotalTime = 0;
uint64 typeMinTime = 0xffffffffu;
@@ -227,15 +226,9 @@ void PerformanceMonitor::PrintStats(bool perTick, bool fullStack)
disName = disName.substr(0, disName.find("|")) + "]";
if (perc >= 0.1f || avg >= 0.25f || pd->maxTime > 1000)
{
LOG_INFO("playerbots", "{:7.3f}% {:9.3f}ms | {:7.1f} .. {:7.1f} ({:10.3f} of {:10.2f}) - {:6} : {}"
, perc
, time
, minTime
, maxTime
, avg
, amount
, key.c_str()
, disName.c_str());
LOG_INFO("playerbots",
"{:7.3f}% {:9.3f}ms | {:7.1f} .. {:7.1f} ({:10.3f} of {:10.2f}) - {:6} : {}", perc,
time, minTime, maxTime, avg, amount, key.c_str(), disName.c_str());
}
}
if (PERF_MON_TOTAL != i->first)
@@ -246,15 +239,8 @@ void PerformanceMonitor::PrintStats(bool perTick, bool fullStack)
float tMaxTime = (float)typeMaxTime / 1000.0f;
float tAvg = (float)typeTotalTime / (float)typeCount / 1000.0f;
float tAmount = (float)typeCount / fullTickCount;
LOG_INFO("playerbots", "{:7.3f}% {:9.3f}ms | {:7.1f} .. {:7.1f} ({:10.3f} of {:10.2f}) - {:6} : {}"
, tPerc
, tTime
, tMinTime
, tMaxTime
, tAvg
, tAmount
, key.c_str()
, "Total");
LOG_INFO("playerbots", "{:7.3f}% {:9.3f}ms | {:7.1f} .. {:7.1f} ({:10.3f} of {:10.2f}) - {:6} : {}",
tPerc, tTime, tMinTime, tMaxTime, tAvg, tAmount, key.c_str(), "Total");
}
LOG_INFO("playerbots", " ");
}
@@ -263,7 +249,8 @@ void PerformanceMonitor::PrintStats(bool perTick, bool fullStack)
void PerformanceMonitor::Reset()
{
for (std::map<PerformanceMetric, std::map<std::string, PerformanceData*> >::iterator i = data.begin(); i != data.end(); ++i)
for (std::map<PerformanceMetric, std::map<std::string, PerformanceData*>>::iterator i = data.begin();
i != data.end(); ++i)
{
std::map<std::string, PerformanceData*> pdMap = i->second;
for (std::map<std::string, PerformanceData*>::iterator j = pdMap.begin(); j != pdMap.end(); ++j)
@@ -278,14 +265,19 @@ void PerformanceMonitor::Reset()
}
}
PerformanceMonitorOperation::PerformanceMonitorOperation(PerformanceData* data, std::string const name, PerformanceStack* stack) : data(data), name(name), stack(stack)
PerformanceMonitorOperation::PerformanceMonitorOperation(PerformanceData* data, std::string const name,
PerformanceStack* stack)
: data(data), name(name), stack(stack)
{
started = (std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::high_resolution_clock::now())).time_since_epoch();
started = (std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::high_resolution_clock::now()))
.time_since_epoch();
}
void PerformanceMonitorOperation::finish()
{
std::chrono::microseconds finished = (std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::high_resolution_clock::now())).time_since_epoch();
std::chrono::microseconds finished =
(std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::high_resolution_clock::now()))
.time_since_epoch();
uint64_t elapsed = (finished - started).count();
std::lock_guard<std::mutex> guard(data->lock);
@@ -309,4 +301,3 @@ void PerformanceMonitorOperation::finish()
delete this;
}

54
src/PerformanceMonitor.h
View File

@@ -1,18 +1,19 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#ifndef _PLAYERBOT_PERFORMANCEMONITOR_H
#define _PLAYERBOT_PERFORMANCEMONITOR_H
#include "Common.h"
#include <chrono>
#include <ctime>
#include <map>
#include <mutex>
#include <vector>
#include "Common.h"
typedef std::vector<std::string> PerformanceStack;
struct PerformanceData
@@ -35,36 +36,37 @@ enum PerformanceMetric
class PerformanceMonitorOperation
{
public:
PerformanceMonitorOperation(PerformanceData* data, std::string const name, PerformanceStack* stack);
void finish();
public:
PerformanceMonitorOperation(PerformanceData* data, std::string const name, PerformanceStack* stack);
void finish();
private:
PerformanceData* data;
std::string const name;
PerformanceStack* stack;
std::chrono::microseconds started;
private:
PerformanceData* data;
std::string const name;
PerformanceStack* stack;
std::chrono::microseconds started;
};
class PerformanceMonitor
{
public:
PerformanceMonitor() { };
virtual ~PerformanceMonitor() { };
static PerformanceMonitor* instance()
{
static PerformanceMonitor instance;
return &instance;
}
public:
PerformanceMonitor(){};
virtual ~PerformanceMonitor(){};
static PerformanceMonitor* instance()
{
static PerformanceMonitor instance;
return &instance;
}
public:
PerformanceMonitorOperation* start(PerformanceMetric metric, std::string const name, PerformanceStack* stack = nullptr);
void PrintStats(bool perTick = false, bool fullStack = false);
void Reset();
public:
PerformanceMonitorOperation* start(PerformanceMetric metric, std::string const name,
PerformanceStack* stack = nullptr);
void PrintStats(bool perTick = false, bool fullStack = false);
void Reset();
private:
std::map<PerformanceMetric, std::map<std::string, PerformanceData*> > data;
std::mutex lock;
private:
std::map<PerformanceMetric, std::map<std::string, PerformanceData*> > data;
std::mutex lock;
};
#define sPerformanceMonitor PerformanceMonitor::instance()

18
src/PlaceholderHelper.cpp
View File

@@ -1,18 +1,17 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#include "PlaceholderHelper.h"
#include "AiFactory.h"
#include "Playerbots.h"
#include "PlayerbotTextMgr.h"
#include "Playerbots.h"
#include "Util.h"
void PlaceholderHelper::MapDungeon(
PlaceholderMap& placeholders,
DungeonSuggestion const* dungeonSuggestion,
Player* bot
)
void PlaceholderHelper::MapDungeon(PlaceholderMap& placeholders, DungeonSuggestion const* dungeonSuggestion,
Player* bot)
{
std::ostringstream out;
Insertion insertion = {out, dungeonSuggestion};
@@ -23,7 +22,6 @@ void PlaceholderHelper::MapDungeon(
placeholders["%dungeon"] = out.str();
}
void PlaceholderHelper::MapRole(PlaceholderMap& placeholders, Player* bot)
{
BotRoles const role = AiFactory::GetPlayerRoles(bot);
@@ -82,8 +80,8 @@ void PlaceholderHelper::InsertDifficulty(Insertion& insertion, [[maybe_unused]]
{
bool const isRandomlyNormal = urand(0, 1);
bool const isRandomlyHeroic = urand(0, 1);
std::vector<std::string> normalAbbrevations = { "Normal", "N" };
std::vector<std::string> heroicAbbrevations = { "Heroic", "HC", "H"};
std::vector<std::string> normalAbbrevations = {"Normal", "N"};
std::vector<std::string> heroicAbbrevations = {"Heroic", "HC", "H"};
uint32 const randomAbbrevationIndex = urand(0, 1);
if (isRandomlyNormal)
{

35
src/PlaceholderHelper.h
View File

@@ -1,38 +1,35 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#ifndef _PLAYERBOT_PLACEHOLDERHELPER_H
#define _PLAYERBOT_PLACEHOLDERHELPER_H
#include <map>
#include "Common.h"
#include "Player.h"
#include "PlayerbotDungeonSuggestionMgr.h"
#include <map>
typedef std::map<std::string, std::string> PlaceholderMap;
class PlaceholderHelper
{
public:
static void MapRole(PlaceholderMap& placeholders, Player* bot);
static void MapDungeon(
PlaceholderMap& placeholders,
DungeonSuggestion const* dungeonSuggestion,
Player* bot
);
public:
static void MapRole(PlaceholderMap& placeholders, Player* bot);
static void MapDungeon(PlaceholderMap& placeholders, DungeonSuggestion const* dungeonSuggestion, Player* bot);
private:
struct Insertion
{
std::ostringstream& out;
DungeonSuggestion const* dungeonSuggestion;
};
private:
struct Insertion
{
std::ostringstream& out;
DungeonSuggestion const* dungeonSuggestion;
};
static void InsertDungeonName(Insertion& insertion);
static void InsertDungeonStrategy(Insertion& insertion);
static void InsertDifficulty(Insertion& insertion, Player* bot);
static void InsertDungeonName(Insertion& insertion);
static void InsertDungeonStrategy(Insertion& insertion);
static void InsertDifficulty(Insertion& insertion, Player* bot);
};
#endif

1451
src/PlayerbotAI.cpp
View File

File diff suppressed because it is too large Load Diff

627
src/PlayerbotAI.h
View File

@@ -1,25 +1,26 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#ifndef _PLAYERBOT_PLAYERbotAI_H
#define _PLAYERBOT_PLAYERbotAI_H
#include <queue>
#include <stack>
#include "Chat.h"
#include "ChatHelper.h"
#include "ChatFilter.h"
#include "ChatHelper.h"
#include "Common.h"
#include "Event.h"
#include "Item.h"
#include "PlayerbotAIBase.h"
#include "PlayerbotAIConfig.h"
#include "PlayerbotSecurity.h"
#include "PlayerbotTextMgr.h"
#include "SpellAuras.h"
#include "WorldPacket.h"
#include "PlayerbotTextMgr.h"
#include <stack>
#include <queue>
class AiObjectContext;
class Creature;
@@ -43,228 +44,239 @@ enum StrategyType : uint32;
enum HealingItemDisplayId
{
HEALTHSTONE_DISPLAYID = 8026,
MAJOR_HEALING_POTION = 24152,
WHIPPER_ROOT_TUBER = 21974,
NIGHT_DRAGON_BREATH = 21975,
LIMITED_INVULNERABILITY_POTION = 24213,
GREATER_DREAMLESS_SLEEP_POTION = 17403,
SUPERIOR_HEALING_POTION = 15714,
CRYSTAL_RESTORE = 2516,
DREAMLESS_SLEEP_POTION = 17403,
GREATER_HEALING_POTION = 15713,
HEALING_POTION = 15712,
LESSER_HEALING_POTION = 15711,
DISCOLORED_HEALING_POTION = 15736,
MINOR_HEALING_POTION = 15710,
VOLATILE_HEALING_POTION = 24212,
SUPER_HEALING_POTION = 37807,
CRYSTAL_HEALING_POTION = 47132,
FEL_REGENERATION_POTION = 37864,
MAJOR_DREAMLESS_SLEEP_POTION = 37845
HEALTHSTONE_DISPLAYID = 8026,
MAJOR_HEALING_POTION = 24152,
WHIPPER_ROOT_TUBER = 21974,
NIGHT_DRAGON_BREATH = 21975,
LIMITED_INVULNERABILITY_POTION = 24213,
GREATER_DREAMLESS_SLEEP_POTION = 17403,
SUPERIOR_HEALING_POTION = 15714,
CRYSTAL_RESTORE = 2516,
DREAMLESS_SLEEP_POTION = 17403,
GREATER_HEALING_POTION = 15713,
HEALING_POTION = 15712,
LESSER_HEALING_POTION = 15711,
DISCOLORED_HEALING_POTION = 15736,
MINOR_HEALING_POTION = 15710,
VOLATILE_HEALING_POTION = 24212,
SUPER_HEALING_POTION = 37807,
CRYSTAL_HEALING_POTION = 47132,
FEL_REGENERATION_POTION = 37864,
MAJOR_DREAMLESS_SLEEP_POTION = 37845
};
enum BotState
{
BOT_STATE_COMBAT = 0,
BOT_STATE_NON_COMBAT = 1,
BOT_STATE_DEAD = 2,
BOT_STATE_COMBAT = 0,
BOT_STATE_NON_COMBAT = 1,
BOT_STATE_DEAD = 2,
BOT_STATE_MAX
};
bool IsAlliance(uint8 race);
class PlayerbotChatHandler: protected ChatHandler
class PlayerbotChatHandler : protected ChatHandler
{
public:
explicit PlayerbotChatHandler(Player* pMasterPlayer);
void sysmessage(std::string const str) { SendSysMessage(str.c_str()); }
uint32 extractQuestId(std::string const str);
uint32 extractSpellId(std::string const str)
{
char* source = (char*)str.c_str();
return extractSpellIdFromLink(source);
}
public:
explicit PlayerbotChatHandler(Player* pMasterPlayer);
void sysmessage(std::string const str) { SendSysMessage(str.c_str()); }
uint32 extractQuestId(std::string const str);
uint32 extractSpellId(std::string const str)
{
char* source = (char*)str.c_str();
return extractSpellIdFromLink(source);
}
};
class MinValueCalculator
{
public:
MinValueCalculator(float def = 0.0f) : param(nullptr), minValue(def) { }
public:
MinValueCalculator(float def = 0.0f) : param(nullptr), minValue(def) {}
void probe(float value, void* p)
void probe(float value, void* p)
{
if (!param || minValue >= value)
{
if (!param || minValue >= value)
{
minValue = value;
param = p;
}
}
minValue = value;
param = p;
}
}
void* param;
float minValue;
void* param;
float minValue;
};
enum RoguePoisonDisplayId
{
DEADLY_POISON_DISPLAYID = 13707,
INSTANT_POISON_DISPLAYID = 13710,
WOUND_POISON_DISPLAYID = 37278
DEADLY_POISON_DISPLAYID = 13707,
INSTANT_POISON_DISPLAYID = 13710,
WOUND_POISON_DISPLAYID = 37278
};
enum SharpeningStoneDisplayId
{
ROUGH_SHARPENING_DISPLAYID = 24673,
COARSE_SHARPENING_DISPLAYID = 24674,
HEAVY_SHARPENING_DISPLAYID = 24675,
SOLID_SHARPENING_DISPLAYID = 24676,
DENSE_SHARPENING_DISPLAYID = 24677,
CONSECRATED_SHARPENING_DISPLAYID = 24674, // will not be used because bot can not know if it will face undead targets
ELEMENTAL_SHARPENING_DISPLAYID = 21072,
FEL_SHARPENING_DISPLAYID = 39192,
ADAMANTITE_SHARPENING_DISPLAYID = 39193
ROUGH_SHARPENING_DISPLAYID = 24673,
COARSE_SHARPENING_DISPLAYID = 24674,
HEAVY_SHARPENING_DISPLAYID = 24675,
SOLID_SHARPENING_DISPLAYID = 24676,
DENSE_SHARPENING_DISPLAYID = 24677,
CONSECRATED_SHARPENING_DISPLAYID =
24674, // will not be used because bot can not know if it will face undead targets
ELEMENTAL_SHARPENING_DISPLAYID = 21072,
FEL_SHARPENING_DISPLAYID = 39192,
ADAMANTITE_SHARPENING_DISPLAYID = 39193
};
enum WeightStoneDisplayId
{
ROUGH_WEIGHTSTONE_DISPLAYID = 24683,
COARSE_WEIGHTSTONE_DISPLAYID = 24684,
HEAVY_WEIGHTSTONE_DISPLAYID = 24685,
SOLID_WEIGHTSTONE_DISPLAYID = 24686,
DENSE_WEIGHTSTONE_DISPLAYID = 24687,
FEL_WEIGHTSTONE_DISPLAYID = 39548,
ROUGH_WEIGHTSTONE_DISPLAYID = 24683,
COARSE_WEIGHTSTONE_DISPLAYID = 24684,
HEAVY_WEIGHTSTONE_DISPLAYID = 24685,
SOLID_WEIGHTSTONE_DISPLAYID = 24686,
DENSE_WEIGHTSTONE_DISPLAYID = 24687,
FEL_WEIGHTSTONE_DISPLAYID = 39548,
ADAMANTITE_WEIGHTSTONE_DISPLAYID = 39549
};
enum WizardOilDisplayId
{
MINOR_WIZARD_OIL = 9731,
LESSER_WIZARD_OIL = 47903,
BRILLIANT_WIZARD_OIL = 47901,
WIZARD_OIL = 47905,
SUPERIOR_WIZARD_OIL = 47904,
/// Blessed Wizard Oil = 26865 //scourge inv
MINOR_WIZARD_OIL = 9731,
LESSER_WIZARD_OIL = 47903,
BRILLIANT_WIZARD_OIL = 47901,
WIZARD_OIL = 47905,
SUPERIOR_WIZARD_OIL = 47904,
/// Blessed Wizard Oil = 26865 //scourge inv
};
enum ManaOilDisplayId
{
MINOR_MANA_OIL = 34492,
LESSER_MANA_OIL = 47902,
BRILLIANT_MANA_OIL = 41488,
SUPERIOR_MANA_OIL = 36862
MINOR_MANA_OIL = 34492,
LESSER_MANA_OIL = 47902,
BRILLIANT_MANA_OIL = 41488,
SUPERIOR_MANA_OIL = 36862
};
enum ShieldWardDisplayId
{
LESSER_WARD_OFSHIELDING = 38759,
LESSER_WARD_OFSHIELDING = 38759,
GREATER_WARD_OFSHIELDING = 38760
};
enum class BotTypeNumber : uint8
{
ACTIVITY_TYPE_NUMBER = 1,
GROUPER_TYPE_NUMBER = 2,
GUILDER_TYPE_NUMBER = 3,
GROUPER_TYPE_NUMBER = 2,
GUILDER_TYPE_NUMBER = 3,
};
enum class GrouperType : uint8
{
SOLO = 0,
MEMBER = 1,
LEADER_2 = 2,
LEADER_3 = 3,
LEADER_4 = 4,
LEADER_5 = 5
SOLO = 0,
MEMBER = 1,
LEADER_2 = 2,
LEADER_3 = 3,
LEADER_4 = 4,
LEADER_5 = 5
};
enum class GuilderType : uint8
{
SOLO = 0,
TINY = 30,
SMALL = 50,
SOLO = 0,
TINY = 30,
SMALL = 50,
MEDIUM = 70,
LARGE = 120,
VERY_LARGE = 250
LARGE = 120,
VERY_LARGE = 250
};
enum ActivityType
{
GRIND_ACTIVITY = 1,
RPG_ACTIVITY = 2,
TRAVEL_ACTIVITY = 3,
OUT_OF_PARTY_ACTIVITY = 4,
PACKET_ACTIVITY = 5,
DETAILED_MOVE_ACTIVITY = 6,
PARTY_ACTIVITY = 7,
ALL_ACTIVITY = 8,
GRIND_ACTIVITY = 1,
RPG_ACTIVITY = 2,
TRAVEL_ACTIVITY = 3,
OUT_OF_PARTY_ACTIVITY = 4,
PACKET_ACTIVITY = 5,
DETAILED_MOVE_ACTIVITY = 6,
PARTY_ACTIVITY = 7,
ALL_ACTIVITY = 8,
MAX_ACTIVITY_TYPE
};
enum BotRoles : uint8
{
BOT_ROLE_NONE = 0x00,
BOT_ROLE_TANK = 0x01,
BOT_ROLE_NONE = 0x00,
BOT_ROLE_TANK = 0x01,
BOT_ROLE_HEALER = 0x02,
BOT_ROLE_DPS = 0x04
BOT_ROLE_DPS = 0x04
};
enum HUNTER_TABS {
enum HUNTER_TABS
{
HUNTER_TAB_BEASTMASTER,
HUNTER_TAB_MARKSMANSHIP,
HUNTER_TAB_SURVIVAL,
};
enum ROGUE_TABS {
enum ROGUE_TABS
{
ROGUE_TAB_ASSASSINATION,
ROGUE_TAB_COMBAT,
ROGUE_TAB_SUBTLETY
};
enum PRIEST_TABS {
enum PRIEST_TABS
{
PRIEST_TAB_DISIPLINE,
PRIEST_TAB_HOLY,
PRIEST_TAB_SHADOW,
};
enum DEATHKNIGT_TABS {
enum DEATHKNIGT_TABS
{
DEATHKNIGT_TAB_BLOOD,
DEATHKNIGT_TAB_FROST,
DEATHKNIGT_TAB_UNHOLY,
};
enum DRUID_TABS {
enum DRUID_TABS
{
DRUID_TAB_BALANCE,
DRUID_TAB_FERAL,
DRUID_TAB_RESTORATION,
};
enum MAGE_TABS {
enum MAGE_TABS
{
MAGE_TAB_ARCANE,
MAGE_TAB_FIRE,
MAGE_TAB_FROST,
};
enum SHAMAN_TABS {
enum SHAMAN_TABS
{
SHAMAN_TAB_ELEMENTAL,
SHAMAN_TAB_ENHANCEMENT,
SHAMAN_TAB_RESTORATION,
};
enum PALADIN_TABS {
enum PALADIN_TABS
{
PALADIN_TAB_HOLY,
PALADIN_TAB_PROTECTION,
PALADIN_TAB_RETRIBUTION,
};
enum WARLOCK_TABS {
enum WARLOCK_TABS
{
WARLOCK_TAB_AFFLICATION,
WARLOCK_TAB_DEMONOLOGY,
WARLOCK_TAB_DESTRUCTION,
};
enum WARRIOR_TABS {
enum WARRIOR_TABS
{
WARRIOR_TAB_ARMS,
WARRIOR_TAB_FURY,
WARRIOR_TAB_PROTECTION,
@@ -272,215 +284,238 @@ enum WARRIOR_TABS {
class PacketHandlingHelper
{
public:
void AddHandler(uint16 opcode, std::string const handler);
void Handle(ExternalEventHelper &helper);
void AddPacket(WorldPacket const& packet);
public:
void AddHandler(uint16 opcode, std::string const handler);
void Handle(ExternalEventHelper& helper);
void AddPacket(WorldPacket const& packet);
private:
std::map<uint16, std::string> handlers;
std::stack<WorldPacket> queue;
private:
std::map<uint16, std::string> handlers;
std::stack<WorldPacket> queue;
};
class ChatCommandHolder
{
public:
ChatCommandHolder(std::string const command, Player* owner = nullptr, uint32 type = CHAT_MSG_WHISPER, time_t time = 0) : command(command), owner(owner), type(type), time(time) { }
ChatCommandHolder(ChatCommandHolder const& other) : command(other.command), owner(other.owner), type(other.type), time(other.time) { }
public:
ChatCommandHolder(std::string const command, Player* owner = nullptr, uint32 type = CHAT_MSG_WHISPER,
time_t time = 0)
: command(command), owner(owner), type(type), time(time)
{
}
ChatCommandHolder(ChatCommandHolder const& other)
: command(other.command), owner(other.owner), type(other.type), time(other.time)
{
}
std::string const GetCommand() { return command; }
Player* GetOwner() { return owner; }
uint32 GetType() { return type; }
time_t GetTime() { return time; }
std::string const GetCommand() { return command; }
Player* GetOwner() { return owner; }
uint32 GetType() { return type; }
time_t GetTime() { return time; }
private:
std::string const command;
Player* owner;
uint32 type;
time_t time;
private:
std::string const command;
Player* owner;
uint32 type;
time_t time;
};
class PlayerbotAI : public PlayerbotAIBase
{
public:
PlayerbotAI();
PlayerbotAI(Player* bot);
virtual ~PlayerbotAI();
public:
PlayerbotAI();
PlayerbotAI(Player* bot);
virtual ~PlayerbotAI();
void UpdateAI(uint32 elapsed, bool minimal = false) override;
void UpdateAIInternal(uint32 elapsed, bool minimal = false) override;
void UpdateAI(uint32 elapsed, bool minimal = false) override;
void UpdateAIInternal(uint32 elapsed, bool minimal = false) override;
std::string const HandleRemoteCommand(std::string const command);
void HandleCommand(uint32 type, std::string const text, Player* fromPlayer);
void QueueChatResponse(uint8 msgtype, ObjectGuid guid1, ObjectGuid guid2, std::string message, std::string chanName, std::string name);
void HandleBotOutgoingPacket(WorldPacket const& packet);
void HandleMasterIncomingPacket(WorldPacket const& packet);
void HandleMasterOutgoingPacket(WorldPacket const& packet);
void HandleTeleportAck();
void ChangeEngine(BotState type);
void DoNextAction(bool minimal = false);
virtual bool DoSpecificAction(std::string const name, Event event = Event(), bool silent = false, std::string const qualifier = "");
void ChangeStrategy(std::string const name, BotState type);
void ClearStrategies(BotState type);
std::vector<std::string> GetStrategies(BotState type);
bool ContainsStrategy(StrategyType type);
bool HasStrategy(std::string const name, BotState type);
BotState GetState() { return currentState; };
void ResetStrategies(bool load = false);
void ReInitCurrentEngine();
void Reset(bool full = false);
static bool IsTank(Player* player);
static bool IsHeal(Player* player);
static bool IsDps(Player* player);
static bool IsRanged(Player* player);
static bool IsMelee(Player* player);
static bool IsCaster(Player* player);
static bool IsCombo(Player* player);
static bool IsRangedDps(Player* player);
static bool IsMainTank(Player* player);
bool IsAssistTank(Player* player);
bool IsAssistTankOfIndex(Player* player, int index);
bool IsHealAssistantOfIndex(Player* player, int index);
bool IsRangedDpsAssistantOfIndex(Player* player, int index);
bool HasAggro(Unit* unit);
int32 GetGroupSlotIndex(Player* player);
int32 GetRangedIndex(Player* player);
int32 GetClassIndex(Player* player, uint8_t cls);
int32 GetRangedDpsIndex(Player* player);
int32 GetMeleeIndex(Player* player);
std::string const HandleRemoteCommand(std::string const command);
void HandleCommand(uint32 type, std::string const text, Player* fromPlayer);
void QueueChatResponse(uint8 msgtype, ObjectGuid guid1, ObjectGuid guid2, std::string message, std::string chanName,
std::string name);
void HandleBotOutgoingPacket(WorldPacket const& packet);
void HandleMasterIncomingPacket(WorldPacket const& packet);
void HandleMasterOutgoingPacket(WorldPacket const& packet);
void HandleTeleportAck();
void ChangeEngine(BotState type);
void DoNextAction(bool minimal = false);
virtual bool DoSpecificAction(std::string const name, Event event = Event(), bool silent = false,
std::string const qualifier = "");
void ChangeStrategy(std::string const name, BotState type);
void ClearStrategies(BotState type);
std::vector<std::string> GetStrategies(BotState type);
bool ContainsStrategy(StrategyType type);
bool HasStrategy(std::string const name, BotState type);
BotState GetState() { return currentState; };
void ResetStrategies(bool load = false);
void ReInitCurrentEngine();
void Reset(bool full = false);
static bool IsTank(Player* player);
static bool IsHeal(Player* player);
static bool IsDps(Player* player);
static bool IsRanged(Player* player);
static bool IsMelee(Player* player);
static bool IsCaster(Player* player);
static bool IsCombo(Player* player);
static bool IsRangedDps(Player* player);
static bool IsMainTank(Player* player);
bool IsAssistTank(Player* player);
bool IsAssistTankOfIndex(Player* player, int index);
bool IsHealAssistantOfIndex(Player* player, int index);
bool IsRangedDpsAssistantOfIndex(Player* player, int index);
bool HasAggro(Unit* unit);
int32 GetGroupSlotIndex(Player* player);
int32 GetRangedIndex(Player* player);
int32 GetClassIndex(Player* player, uint8_t cls);
int32 GetRangedDpsIndex(Player* player);
int32 GetMeleeIndex(Player* player);
Creature* GetCreature(ObjectGuid guid);
Unit* GetUnit(ObjectGuid guid);
Player* GetPlayer(ObjectGuid guid);
static Unit* GetUnit(CreatureData const* creatureData);
GameObject* GetGameObject(ObjectGuid guid);
// static GameObject* GetGameObject(GameObjectData const* gameObjectData);
WorldObject* GetWorldObject(ObjectGuid guid);
bool TellMaster(std::ostringstream& stream, PlayerbotSecurityLevel securityLevel = PLAYERBOT_SECURITY_ALLOW_ALL);
bool TellMaster(std::string const text, PlayerbotSecurityLevel securityLevel = PLAYERBOT_SECURITY_ALLOW_ALL);
bool TellMasterNoFacing(std::ostringstream& stream, PlayerbotSecurityLevel securityLevel = PLAYERBOT_SECURITY_ALLOW_ALL);
bool TellMasterNoFacing(std::string const text, PlayerbotSecurityLevel securityLevel = PLAYERBOT_SECURITY_ALLOW_ALL);
bool TellError(std::string const text, PlayerbotSecurityLevel securityLevel = PLAYERBOT_SECURITY_ALLOW_ALL);
void SpellInterrupted(uint32 spellid);
int32 CalculateGlobalCooldown(uint32 spellid);
void InterruptSpell();
void RemoveAura(std::string const name);
void RemoveShapeshift();
void WaitForSpellCast(Spell* spell);
bool PlaySound(uint32 emote);
bool PlayEmote(uint32 emote);
void Ping(float x, float y);
Item* FindPoison() const;
Item* FindBandage() const;
Item* FindConsumable(uint32 displayId) const;
Item* FindStoneFor(Item* weapon) const;
Item* FindOilFor(Item* weapon) const;
void ImbueItem(Item* item, uint32 targetFlag, ObjectGuid targetGUID);
void ImbueItem(Item* item, uint8 targetInventorySlot);
void ImbueItem(Item* item, Unit* target);
void ImbueItem(Item* item);
void EnchantItemT(uint32 spellid, uint8 slot);
uint32 GetBuffedCount(Player* player, std::string const spellname);
Creature* GetCreature(ObjectGuid guid);
Unit* GetUnit(ObjectGuid guid);
Player* GetPlayer(ObjectGuid guid);
static Unit* GetUnit(CreatureData const* creatureData);
GameObject* GetGameObject(ObjectGuid guid);
// static GameObject* GetGameObject(GameObjectData const* gameObjectData);
WorldObject* GetWorldObject(ObjectGuid guid);
bool TellMaster(std::ostringstream& stream, PlayerbotSecurityLevel securityLevel = PLAYERBOT_SECURITY_ALLOW_ALL);
bool TellMaster(std::string const text, PlayerbotSecurityLevel securityLevel = PLAYERBOT_SECURITY_ALLOW_ALL);
bool TellMasterNoFacing(std::ostringstream& stream,
PlayerbotSecurityLevel securityLevel = PLAYERBOT_SECURITY_ALLOW_ALL);
bool TellMasterNoFacing(std::string const text,
PlayerbotSecurityLevel securityLevel = PLAYERBOT_SECURITY_ALLOW_ALL);
bool TellError(std::string const text, PlayerbotSecurityLevel securityLevel = PLAYERBOT_SECURITY_ALLOW_ALL);
void SpellInterrupted(uint32 spellid);
int32 CalculateGlobalCooldown(uint32 spellid);
void InterruptSpell();
void RemoveAura(std::string const name);
void RemoveShapeshift();
void WaitForSpellCast(Spell* spell);
bool PlaySound(uint32 emote);
bool PlayEmote(uint32 emote);
void Ping(float x, float y);
Item* FindPoison() const;
Item* FindBandage() const;
Item* FindConsumable(uint32 displayId) const;
Item* FindStoneFor(Item* weapon) const;
Item* FindOilFor(Item* weapon) const;
void ImbueItem(Item* item, uint32 targetFlag, ObjectGuid targetGUID);
void ImbueItem(Item* item, uint8 targetInventorySlot);
void ImbueItem(Item* item, Unit* target);
void ImbueItem(Item* item);
void EnchantItemT(uint32 spellid, uint8 slot);
uint32 GetBuffedCount(Player* player, std::string const spellname);
virtual bool CanCastSpell(std::string const name, Unit* target, Item* itemTarget = nullptr);
virtual bool CastSpell(std::string const name, Unit* target, Item* itemTarget = nullptr);
virtual bool HasAura(std::string const spellName, Unit* player, bool maxStack = false, bool checkIsOwner = false, int maxAmount = -1, bool checkDuration = false);
virtual bool HasAnyAuraOf(Unit* player, ...);
virtual bool CanCastSpell(std::string const name, Unit* target, Item* itemTarget = nullptr);
virtual bool CastSpell(std::string const name, Unit* target, Item* itemTarget = nullptr);
virtual bool HasAura(std::string const spellName, Unit* player, bool maxStack = false, bool checkIsOwner = false,
int maxAmount = -1, bool checkDuration = false);
virtual bool HasAnyAuraOf(Unit* player, ...);
virtual bool IsInterruptableSpellCasting(Unit* player, std::string const spell);
virtual bool HasAuraToDispel(Unit* player, uint32 dispelType);
bool CanCastSpell(uint32 spellid, Unit* target, bool checkHasSpell = true, Item* itemTarget = nullptr, Item* castItem = nullptr);
bool CanCastSpell(uint32 spellid, GameObject* goTarget, uint8 effectMask, bool checkHasSpell = true);
bool CanCastSpell(uint32 spellid, float x, float y, float z, uint8 effectMask, bool checkHasSpell = true, Item* itemTarget = nullptr);
virtual bool IsInterruptableSpellCasting(Unit* player, std::string const spell);
virtual bool HasAuraToDispel(Unit* player, uint32 dispelType);
bool CanCastSpell(uint32 spellid, Unit* target, bool checkHasSpell = true, Item* itemTarget = nullptr,
Item* castItem = nullptr);
bool CanCastSpell(uint32 spellid, GameObject* goTarget, uint8 effectMask, bool checkHasSpell = true);
bool CanCastSpell(uint32 spellid, float x, float y, float z, uint8 effectMask, bool checkHasSpell = true,
Item* itemTarget = nullptr);
bool HasAura(uint32 spellId, Unit const* player);
Aura* GetAura(std::string const spellName, Unit* unit, bool checkIsOwner = false, bool checkDuration = false, int checkStack = -1);
bool CastSpell(uint32 spellId, Unit* target, Item* itemTarget = nullptr);
bool CastSpell(uint32 spellId, float x, float y, float z, Item* itemTarget = nullptr);
bool canDispel(SpellInfo const* spellInfo, uint32 dispelType);
bool HasAura(uint32 spellId, Unit const* player);
Aura* GetAura(std::string const spellName, Unit* unit, bool checkIsOwner = false, bool checkDuration = false,
int checkStack = -1);
bool CastSpell(uint32 spellId, Unit* target, Item* itemTarget = nullptr);
bool CastSpell(uint32 spellId, float x, float y, float z, Item* itemTarget = nullptr);
bool canDispel(SpellInfo const* spellInfo, uint32 dispelType);
bool CanCastVehicleSpell(uint32 spellid, Unit* target);
bool CastVehicleSpell(uint32 spellId, Unit* target);
bool CastVehicleSpell(uint32 spellId, float x, float y, float z);
bool IsInVehicle(bool canControl = false, bool canCast = false, bool canAttack = false, bool canTurn = false, bool fixed = false);
bool CanCastVehicleSpell(uint32 spellid, Unit* target);
bool CastVehicleSpell(uint32 spellId, Unit* target);
bool CastVehicleSpell(uint32 spellId, float x, float y, float z);
bool IsInVehicle(bool canControl = false, bool canCast = false, bool canAttack = false, bool canTurn = false,
bool fixed = false);
uint32 GetEquipGearScore(Player* player, bool withBags, bool withBank);
static uint32 GetMixedGearScore(Player* player, bool withBags, bool withBank, uint32 topN = 0);
bool HasSkill(SkillType skill);
bool IsAllowedCommand(std::string const text);
float GetRange(std::string const type);
uint32 GetEquipGearScore(Player* player, bool withBags, bool withBank);
static uint32 GetMixedGearScore(Player* player, bool withBags, bool withBank, uint32 topN = 0);
bool HasSkill(SkillType skill);
bool IsAllowedCommand(std::string const text);
float GetRange(std::string const type);
Player* GetBot() { return bot; }
Player* GetMaster() { return master; }
Player* GetBot() { return bot; }
Player* GetMaster() { return master; }
//Checks if the bot is really a player. Players always have themselves as master.
bool IsRealPlayer() { return master ? (master == bot) : false; }
//Bot has a master that is a player.
bool HasRealPlayerMaster();
//Bot has a master that is activly playing.
bool HasActivePlayerMaster();
//Get the group leader or the master of the bot.
//Checks if the bot is summoned as alt of a player
bool IsAlt();
Player* GetGroupMaster();
//Returns a semi-random (cycling) number that is fixed for each bot.
uint32 GetFixedBotNumer(BotTypeNumber typeNumber, uint32 maxNum = 100, float cyclePerMin = 1);
GrouperType GetGrouperType();
GuilderType GetGuilderType();
bool HasPlayerNearby(WorldPosition* pos, float range = sPlayerbotAIConfig->reactDistance);
bool HasPlayerNearby(float range = sPlayerbotAIConfig->reactDistance);
bool HasManyPlayersNearby(uint32 trigerrValue = 20, float range = sPlayerbotAIConfig->sightDistance);
bool AllowActive(ActivityType activityType);
bool AllowActivity(ActivityType activityType = ALL_ACTIVITY, bool checkNow = false);
// Checks if the bot is really a player. Players always have themselves as master.
bool IsRealPlayer() { return master ? (master == bot) : false; }
// Bot has a master that is a player.
bool HasRealPlayerMaster();
// Bot has a master that is activly playing.
bool HasActivePlayerMaster();
// Get the group leader or the master of the bot.
// Checks if the bot is summoned as alt of a player
bool IsAlt();
Player* GetGroupMaster();
// Returns a semi-random (cycling) number that is fixed for each bot.
uint32 GetFixedBotNumer(BotTypeNumber typeNumber, uint32 maxNum = 100, float cyclePerMin = 1);
GrouperType GetGrouperType();
GuilderType GetGuilderType();
bool HasPlayerNearby(WorldPosition* pos, float range = sPlayerbotAIConfig->reactDistance);
bool HasPlayerNearby(float range = sPlayerbotAIConfig->reactDistance);
bool HasManyPlayersNearby(uint32 trigerrValue = 20, float range = sPlayerbotAIConfig->sightDistance);
bool AllowActive(ActivityType activityType);
bool AllowActivity(ActivityType activityType = ALL_ACTIVITY, bool checkNow = false);
bool HasCheat(BotCheatMask mask) { return ((uint32)mask & (uint32)cheatMask) != 0 || ((uint32)mask & (uint32)sPlayerbotAIConfig->botCheatMask) != 0; }
BotCheatMask GetCheat() { return cheatMask; }
void SetCheat(BotCheatMask mask) { cheatMask = mask; }
bool HasCheat(BotCheatMask mask)
{
return ((uint32)mask & (uint32)cheatMask) != 0 ||
((uint32)mask & (uint32)sPlayerbotAIConfig->botCheatMask) != 0;
}
BotCheatMask GetCheat() { return cheatMask; }
void SetCheat(BotCheatMask mask) { cheatMask = mask; }
void SetMaster(Player* newMaster) { master = newMaster; }
AiObjectContext* GetAiObjectContext() { return aiObjectContext; }
ChatHelper* GetChatHelper() { return &chatHelper; }
bool IsOpposing(Player* player);
static bool IsOpposing(uint8 race1, uint8 race2);
PlayerbotSecurity* GetSecurity() { return &security; }
void SetMaster(Player* newMaster) { master = newMaster; }
AiObjectContext* GetAiObjectContext() { return aiObjectContext; }
ChatHelper* GetChatHelper() { return &chatHelper; }
bool IsOpposing(Player* player);
static bool IsOpposing(uint8 race1, uint8 race2);
PlayerbotSecurity* GetSecurity() { return &security; }
Position GetJumpDestination() { return jumpDestination; }
void SetJumpDestination(Position pos) { jumpDestination = pos; }
void ResetJumpDestination() { jumpDestination = Position(); }
Position GetJumpDestination() { return jumpDestination; }
void SetJumpDestination(Position pos) { jumpDestination = pos; }
void ResetJumpDestination() { jumpDestination = Position(); }
bool CanMove();
bool IsInRealGuild();
static std::vector<std::string> dispel_whitelist;
bool EqualLowercaseName(std::string s1, std::string s2);
InventoryResult CanEquipItem(uint8 slot, uint16& dest, Item* pItem, bool swap, bool not_loading = true) const;
uint8 FindEquipSlot(ItemTemplate const* proto, uint32 slot, bool swap) const;
private:
static void _fillGearScoreData(Player* player, Item* item, std::vector<uint32>* gearScore, uint32& twoHandScore, bool mixed = false);
bool IsTellAllowed(PlayerbotSecurityLevel securityLevel = PLAYERBOT_SECURITY_ALLOW_ALL);
protected:
Player* bot;
Player* master;
uint32 accountId;
AiObjectContext* aiObjectContext;
Engine* currentEngine;
Engine* engines[BOT_STATE_MAX];
BotState currentState;
ChatHelper chatHelper;
std::queue<ChatCommandHolder> chatCommands;
std::queue<ChatQueuedReply> chatReplies;
PacketHandlingHelper botOutgoingPacketHandlers;
PacketHandlingHelper masterIncomingPacketHandlers;
PacketHandlingHelper masterOutgoingPacketHandlers;
CompositeChatFilter chatFilter;
PlayerbotSecurity security;
std::map<std::string, time_t> whispers;
std::pair<ChatMsg, time_t> currentChat;
static std::set<std::string> unsecuredCommands;
bool allowActive[MAX_ACTIVITY_TYPE];
time_t allowActiveCheckTimer[MAX_ACTIVITY_TYPE];
bool inCombat = false;
BotCheatMask cheatMask = BotCheatMask::none;
Position jumpDestination = Position();
bool CanMove();
bool IsInRealGuild();
static std::vector<std::string> dispel_whitelist;
bool EqualLowercaseName(std::string s1, std::string s2);
InventoryResult CanEquipItem(uint8 slot, uint16& dest, Item* pItem, bool swap, bool not_loading = true) const;
uint8 FindEquipSlot(ItemTemplate const* proto, uint32 slot, bool swap) const;
private:
static void _fillGearScoreData(Player* player, Item* item, std::vector<uint32>* gearScore, uint32& twoHandScore,
bool mixed = false);
bool IsTellAllowed(PlayerbotSecurityLevel securityLevel = PLAYERBOT_SECURITY_ALLOW_ALL);
protected:
Player* bot;
Player* master;
uint32 accountId;
AiObjectContext* aiObjectContext;
Engine* currentEngine;
Engine* engines[BOT_STATE_MAX];
BotState currentState;
ChatHelper chatHelper;
std::queue<ChatCommandHolder> chatCommands;
std::queue<ChatQueuedReply> chatReplies;
PacketHandlingHelper botOutgoingPacketHandlers;
PacketHandlingHelper masterIncomingPacketHandlers;
PacketHandlingHelper masterOutgoingPacketHandlers;
CompositeChatFilter chatFilter;
PlayerbotSecurity security;
std::map<std::string, time_t> whispers;
std::pair<ChatMsg, time_t> currentChat;
static std::set<std::string> unsecuredCommands;
bool allowActive[MAX_ACTIVITY_TYPE];
time_t allowActiveCheckTimer[MAX_ACTIVITY_TYPE];
bool inCombat = false;
BotCheatMask cheatMask = BotCheatMask::none;
Position jumpDestination = Position();
};
#endif

11
src/PlayerbotAIAware.h
View File

@@ -1,5 +1,6 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#ifndef _PLAYERBOT_PLAYERbotAIAWARE_H
@@ -9,11 +10,11 @@ class PlayerbotAI;
class PlayerbotAIAware
{
public:
PlayerbotAIAware(PlayerbotAI* botAI) : botAI(botAI) { }
public:
PlayerbotAIAware(PlayerbotAI* botAI) : botAI(botAI) {}
protected:
PlayerbotAI* botAI;
protected:
PlayerbotAI* botAI;
};
#endif

27
src/PlayerbotAIBase.cpp
View File

@@ -1,13 +1,13 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#include "PlayerbotAIBase.h"
#include "Playerbots.h"
PlayerbotAIBase::PlayerbotAIBase(bool isBotAI) : nextAICheckDelay(0), _isBotAI(isBotAI)
{
}
PlayerbotAIBase::PlayerbotAIBase(bool isBotAI) : nextAICheckDelay(0), _isBotAI(isBotAI) {}
void PlayerbotAIBase::UpdateAI(uint32 elapsed, bool minimal)
{
@@ -26,12 +26,12 @@ void PlayerbotAIBase::UpdateAI(uint32 elapsed, bool minimal)
void PlayerbotAIBase::SetNextCheckDelay(uint32 const delay)
{
// if (nextAICheckDelay < delay)
// LOG_DEBUG("playerbots", "Setting lesser delay {} -> {}", nextAICheckDelay, delay);
// LOG_DEBUG("playerbots", "Setting lesser delay {} -> {}", nextAICheckDelay, delay);
nextAICheckDelay = delay;
// if (nextAICheckDelay > sPlayerbotAIConfig->globalCoolDown)
// LOG_DEBUG("playerbots", "std::set next check delay: {}", nextAICheckDelay);
// LOG_DEBUG("playerbots", "std::set next check delay: {}", nextAICheckDelay);
}
void PlayerbotAIBase::IncreaseNextCheckDelay(uint32 delay)
@@ -42,10 +42,7 @@ void PlayerbotAIBase::IncreaseNextCheckDelay(uint32 delay)
// LOG_DEBUG("playerbots", "increase next check delay: {}", nextAICheckDelay);
}
bool PlayerbotAIBase::CanUpdateAI()
{
return nextAICheckDelay == 0;
}
bool PlayerbotAIBase::CanUpdateAI() { return nextAICheckDelay == 0; }
void PlayerbotAIBase::YieldThread(bool delay)
{
@@ -53,12 +50,6 @@ void PlayerbotAIBase::YieldThread(bool delay)
nextAICheckDelay = delay ? sPlayerbotAIConfig->reactDelay * 10 : sPlayerbotAIConfig->reactDelay;
}
bool PlayerbotAIBase::IsActive()
{
return nextAICheckDelay < sPlayerbotAIConfig->maxWaitForMove;
}
bool PlayerbotAIBase::IsActive() { return nextAICheckDelay < sPlayerbotAIConfig->maxWaitForMove; }
bool PlayerbotAIBase::IsBotAI() const
{
return _isBotAI;
}
bool PlayerbotAIBase::IsBotAI() const { return _isBotAI; }

31
src/PlayerbotAIBase.h
View File

@@ -1,5 +1,6 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#ifndef _PLAYERBOT_PLAYERBOTAIBASE_H
@@ -9,23 +10,23 @@
class PlayerbotAIBase
{
public:
PlayerbotAIBase(bool isBotAI);
public:
PlayerbotAIBase(bool isBotAI);
bool CanUpdateAI();
void SetNextCheckDelay(uint32 const delay);
void IncreaseNextCheckDelay(uint32 delay);
void YieldThread(bool delay = false);
virtual void UpdateAI(uint32 elapsed, bool minimal = false);
virtual void UpdateAIInternal(uint32 elapsed, bool minimal = false) = 0;
bool IsActive();
bool IsBotAI() const;
bool CanUpdateAI();
void SetNextCheckDelay(uint32 const delay);
void IncreaseNextCheckDelay(uint32 delay);
void YieldThread(bool delay = false);
virtual void UpdateAI(uint32 elapsed, bool minimal = false);
virtual void UpdateAIInternal(uint32 elapsed, bool minimal = false) = 0;
bool IsActive();
bool IsBotAI() const;
protected:
uint32 nextAICheckDelay;
protected:
uint32 nextAICheckDelay;
private:
bool _isBotAI;
private:
bool _isBotAI;
};
#endif

157
src/PlayerbotAIConfig.cpp
View File

@@ -1,17 +1,19 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#include "PlayerbotAIConfig.h"
#include <iostream>
#include "Config.h"
#include "Playerbots.h"
#include "PlayerbotDungeonSuggestionMgr.h"
#include "PlayerbotFactory.h"
#include "Playerbots.h"
#include "RandomItemMgr.h"
#include "RandomPlayerbotFactory.h"
#include "Talentspec.h"
#include "PlayerbotDungeonSuggestionMgr.h"
#include <iostream>
template <class T>
void LoadList(std::string const value, T& list)
@@ -110,49 +112,71 @@ bool PlayerbotAIConfig::Initialize()
randomBotMapsAsString = sConfigMgr->GetOption<std::string>("AiPlayerbot.RandomBotMaps", "0,1,530,571");
LoadList<std::vector<uint32>>(randomBotMapsAsString, randomBotMaps);
probTeleToBankers = sConfigMgr->GetOption<float>("AiPlayerbot.ProbTeleToBankers", 0.25f);
LoadList<std::vector<uint32>>(sConfigMgr->GetOption<std::string>("AiPlayerbot.RandomBotQuestItems", "6948,5175,5176,5177,5178,16309,12382,13704,11000"), randomBotQuestItems);
LoadList<std::vector<uint32>>(sConfigMgr->GetOption<std::string>("AiPlayerbot.RandomBotSpellIds", "54197"), randomBotSpellIds);
LoadList<std::vector<uint32>>(sConfigMgr->GetOption<std::string>("AiPlayerbot.PvpProhibitedZoneIds", "2255,656,2361,2362,2363,976,35,2268,3425,392,541,1446,3828,3712,3738,3565,3539,3623,4152,3988,4658,4284,4418,4436,4275,4323,4395"), pvpProhibitedZoneIds);
LoadList<std::vector<uint32>>(sConfigMgr->GetOption<std::string>("AiPlayerbot.PvpProhibitedAreaIds", "976,35"), pvpProhibitedAreaIds);
LoadList<std::vector<uint32>>(
sConfigMgr->GetOption<std::string>("AiPlayerbot.RandomBotQuestItems",
"6948,5175,5176,5177,5178,16309,12382,13704,11000"),
randomBotQuestItems);
LoadList<std::vector<uint32>>(sConfigMgr->GetOption<std::string>("AiPlayerbot.RandomBotSpellIds", "54197"),
randomBotSpellIds);
LoadList<std::vector<uint32>>(
sConfigMgr->GetOption<std::string>("AiPlayerbot.PvpProhibitedZoneIds",
"2255,656,2361,2362,2363,976,35,2268,3425,392,541,1446,3828,3712,3738,3565,"
"3539,3623,4152,3988,4658,4284,4418,4436,4275,4323,4395"),
pvpProhibitedZoneIds);
LoadList<std::vector<uint32>>(sConfigMgr->GetOption<std::string>("AiPlayerbot.PvpProhibitedAreaIds", "976,35"),
pvpProhibitedAreaIds);
LoadList<std::vector<uint32>>(sConfigMgr->GetOption<std::string>("AiPlayerbot.RandomBotQuestIds", "7848,3802,5505,6502,7761"), randomBotQuestIds);
LoadList<std::vector<uint32>>(
sConfigMgr->GetOption<std::string>("AiPlayerbot.RandomBotQuestIds", "7848,3802,5505,6502,7761"),
randomBotQuestIds);
botAutologin = sConfigMgr->GetOption<bool>("AiPlayerbot.BotAutologin", false);
randomBotAutologin = sConfigMgr->GetOption<bool>("AiPlayerbot.RandomBotAutologin", true);
minRandomBots = sConfigMgr->GetOption<int32>("AiPlayerbot.MinRandomBots", 50);
maxRandomBots = sConfigMgr->GetOption<int32>("AiPlayerbot.MaxRandomBots", 200);
randomBotUpdateInterval = sConfigMgr->GetOption<int32>("AiPlayerbot.RandomBotUpdateInterval", MINUTE);
randomBotCountChangeMinInterval = sConfigMgr->GetOption<int32>("AiPlayerbot.RandomBotCountChangeMinInterval", 30 * MINUTE);
randomBotCountChangeMaxInterval = sConfigMgr->GetOption<int32>("AiPlayerbot.RandomBotCountChangeMaxInterval", 2 * HOUR);
randomBotCountChangeMinInterval =
sConfigMgr->GetOption<int32>("AiPlayerbot.RandomBotCountChangeMinInterval", 30 * MINUTE);
randomBotCountChangeMaxInterval =
sConfigMgr->GetOption<int32>("AiPlayerbot.RandomBotCountChangeMaxInterval", 2 * HOUR);
minRandomBotInWorldTime = sConfigMgr->GetOption<int32>("AiPlayerbot.MinRandomBotInWorldTime", 2 * HOUR);
maxRandomBotInWorldTime = sConfigMgr->GetOption<int32>("AiPlayerbot.MaxRandomBotInWorldTime", 12 * HOUR);
minRandomBotRandomizeTime = sConfigMgr->GetOption<int32>("AiPlayerbot.MinRandomBotRandomizeTime", 2 * HOUR);
maxRandomBotRandomizeTime = sConfigMgr->GetOption<int32>("AiPlayerbot.MaxRandomBotRandomizeTime", 14 * 24 * HOUR);
minRandomBotChangeStrategyTime = sConfigMgr->GetOption<int32>("AiPlayerbot.MinRandomBotChangeStrategyTime", 30 * MINUTE);
maxRandomBotChangeStrategyTime = sConfigMgr->GetOption<int32>("AiPlayerbot.MaxRandomBotChangeStrategyTime", 2 * HOUR);
minRandomBotChangeStrategyTime =
sConfigMgr->GetOption<int32>("AiPlayerbot.MinRandomBotChangeStrategyTime", 30 * MINUTE);
maxRandomBotChangeStrategyTime =
sConfigMgr->GetOption<int32>("AiPlayerbot.MaxRandomBotChangeStrategyTime", 2 * HOUR);
minRandomBotReviveTime = sConfigMgr->GetOption<int32>("AiPlayerbot.MinRandomBotReviveTime", MINUTE);
maxRandomBotReviveTime = sConfigMgr->GetOption<int32>("AiPlayerbot.MaxRandomBotReviveTime", 5 * MINUTE);
minRandomBotTeleportInterval = sConfigMgr->GetOption<int32>("AiPlayerbot.MinRandomBotTeleportInterval", 1 * HOUR);
maxRandomBotTeleportInterval = sConfigMgr->GetOption<int32>("AiPlayerbot.MaxRandomBotTeleportInterval", 5 * HOUR);
randomBotInWorldWithRotationDisabled = sConfigMgr->GetOption<int32>("AiPlayerbot.RandomBotInWorldWithRotationDisabled", 1 * YEAR);
randomBotInWorldWithRotationDisabled =
sConfigMgr->GetOption<int32>("AiPlayerbot.RandomBotInWorldWithRotationDisabled", 1 * YEAR);
randomBotTeleportDistance = sConfigMgr->GetOption<int32>("AiPlayerbot.RandomBotTeleportDistance", 100);
randomBotsPerInterval = sConfigMgr->GetOption<int32>("AiPlayerbot.RandomBotsPerInterval", MINUTE);
minRandomBotsPriceChangeInterval = sConfigMgr->GetOption<int32>("AiPlayerbot.MinRandomBotsPriceChangeInterval", 2 * HOUR);
maxRandomBotsPriceChangeInterval = sConfigMgr->GetOption<int32>("AiPlayerbot.MaxRandomBotsPriceChangeInterval", 48 * HOUR);
minRandomBotsPriceChangeInterval =
sConfigMgr->GetOption<int32>("AiPlayerbot.MinRandomBotsPriceChangeInterval", 2 * HOUR);
maxRandomBotsPriceChangeInterval =
sConfigMgr->GetOption<int32>("AiPlayerbot.MaxRandomBotsPriceChangeInterval", 48 * HOUR);
randomBotJoinLfg = sConfigMgr->GetOption<bool>("AiPlayerbot.RandomBotJoinLfg", true);
randomBotTalk = sConfigMgr->GetOption<bool>("AiPlayerbot.RandomBotTalk", false);
randomBotEmote = sConfigMgr->GetOption<bool>("AiPlayerbot.RandomBotEmote", false);
randomBotSuggestDungeons = sConfigMgr->GetOption<bool>("AiPlayerbot.RandomBotSuggestDungeons", true);
randomBotGuildTalk = sConfigMgr->GetOption<bool>("AiPlayerbot.RandomBotGuildTalk", false);
suggestDungeonsInLowerCaseRandomly = sConfigMgr->GetOption<bool>("AiPlayerbot.SuggestDungeonsInLowerCaseRandomly", false);
suggestDungeonsInLowerCaseRandomly =
sConfigMgr->GetOption<bool>("AiPlayerbot.SuggestDungeonsInLowerCaseRandomly", false);
randomBotJoinBG = sConfigMgr->GetOption<bool>("AiPlayerbot.RandomBotJoinBG", true);
randomBotAutoJoinBG = sConfigMgr->GetOption<bool>("AiPlayerbot.RandomBotAutoJoinBG", false);
randomBotAutoJoinWarsongBracket = sConfigMgr->GetOption<int32>("AiPlayerbot.RandomBotAutoJoinWarsongBracket", 14);
randomBotAutoJoinArenaBracket = sConfigMgr->GetOption<int32>("AiPlayerbot.RandomBotAutoJoinArenaBracket", 7);
randomBotAutoJoinBGWarsongCount = sConfigMgr->GetOption<int32>("AiPlayerbot.RandomBotAutoJoinBGWarsongCount", 0);
randomBotAutoJoinBGRatedArena2v2Count = sConfigMgr->GetOption<int32>("AiPlayerbot.RandomBotAutoJoinBGRatedArena2v2Count", 0);
randomBotAutoJoinBGRatedArena3v3Count = sConfigMgr->GetOption<int32>("AiPlayerbot.RandomBotAutoJoinBGRatedArena3v3Count", 0);
randomBotAutoJoinBGRatedArena5v5Count = sConfigMgr->GetOption<int32>("AiPlayerbot.RandomBotAutoJoinBGRatedArena5v5Count", 0);
randomBotAutoJoinBGRatedArena2v2Count =
sConfigMgr->GetOption<int32>("AiPlayerbot.RandomBotAutoJoinBGRatedArena2v2Count", 0);
randomBotAutoJoinBGRatedArena3v3Count =
sConfigMgr->GetOption<int32>("AiPlayerbot.RandomBotAutoJoinBGRatedArena3v3Count", 0);
randomBotAutoJoinBGRatedArena5v5Count =
sConfigMgr->GetOption<int32>("AiPlayerbot.RandomBotAutoJoinBGRatedArena5v5Count", 0);
logInGroupOnly = sConfigMgr->GetOption<bool>("AiPlayerbot.LogInGroupOnly", true);
logValuesPerTick = sConfigMgr->GetOption<bool>("AiPlayerbot.LogValuesPerTick", false);
fleeingEnabled = sConfigMgr->GetOption<bool>("AiPlayerbot.FleeingEnabled", true);
@@ -183,7 +207,8 @@ bool PlayerbotAIConfig::Initialize()
for (uint32 cls = 1; cls < MAX_CLASSES; ++cls)
{
if (cls == 10) {
if (cls == 10)
{
continue;
}
for (uint32 spec = 0; spec < MAX_SPECNO; ++spec)
@@ -196,12 +221,15 @@ bool PlayerbotAIConfig::Initialize()
os << "AiPlayerbot.PremadeSpecGlyph." << cls << "." << spec;
premadeSpecGlyph[cls][spec] = sConfigMgr->GetOption<std::string>(os.str().c_str(), "", false);
std::vector<std::string> splitSpecGlyph = split(premadeSpecGlyph[cls][spec], ',');
for (std::string &split : splitSpecGlyph) {
if (split.size() != 0) {
for (std::string& split : splitSpecGlyph)
{
if (split.size() != 0)
{
parsedSpecGlyph[cls][spec].push_back(atoi(split.c_str()));
}
}
for (uint32 level = 0; level < MAX_LEVEL; ++level) {
for (uint32 level = 0; level < MAX_LEVEL; ++level)
{
std::ostringstream os;
os << "AiPlayerbot.PremadeSpecLink." << cls << "." << spec << "." << level;
premadeSpecLink[cls][spec][level] = sConfigMgr->GetOption<std::string>(os.str().c_str(), "", false);
@@ -221,7 +249,8 @@ bool PlayerbotAIConfig::Initialize()
}
botCheats.clear();
LoadListString<std::vector<std::string>>(sConfigMgr->GetOption<std::string>("AiPlayerbot.BotCheats", "taxi"), botCheats);
LoadListString<std::vector<std::string>>(sConfigMgr->GetOption<std::string>("AiPlayerbot.BotCheats", "taxi"),
botCheats);
botCheatMask = 0;
@@ -236,7 +265,8 @@ bool PlayerbotAIConfig::Initialize()
if (std::find(botCheats.begin(), botCheats.end(), "power") != botCheats.end())
botCheatMask |= (uint32)BotCheatMask::power;
LoadListString<std::vector<std::string>>(sConfigMgr->GetOption<std::string>("AiPlayerbot.AllowedLogFiles", ""), allowedLogFiles);
LoadListString<std::vector<std::string>>(sConfigMgr->GetOption<std::string>("AiPlayerbot.AllowedLogFiles", ""),
allowedLogFiles);
worldBuffs.clear();
@@ -264,7 +294,8 @@ bool PlayerbotAIConfig::Initialize()
minGuildTaskChangeTime = sConfigMgr->GetOption<int32>("AiPlayerbot.MinGuildTaskChangeTime", 3 * 24 * 3600);
maxGuildTaskChangeTime = sConfigMgr->GetOption<int32>("AiPlayerbot.MaxGuildTaskChangeTime", 4 * 24 * 3600);
minGuildTaskAdvertisementTime = sConfigMgr->GetOption<int32>("AiPlayerbot.MinGuildTaskAdvertisementTime", 300);
maxGuildTaskAdvertisementTime = sConfigMgr->GetOption<int32>("AiPlayerbot.MaxGuildTaskAdvertisementTime", 12 * 3600);
maxGuildTaskAdvertisementTime =
sConfigMgr->GetOption<int32>("AiPlayerbot.MaxGuildTaskAdvertisementTime", 12 * 3600);
minGuildTaskRewardTime = sConfigMgr->GetOption<int32>("AiPlayerbot.MinGuildTaskRewardTime", 300);
maxGuildTaskRewardTime = sConfigMgr->GetOption<int32>("AiPlayerbot.MaxGuildTaskRewardTime", 3600);
guildTaskAdvertCleanupTime = sConfigMgr->GetOption<int32>("AiPlayerbot.GuildTaskAdvertCleanupTime", 300);
@@ -292,7 +323,7 @@ bool PlayerbotAIConfig::Initialize()
botRepairWhenSummon = sConfigMgr->GetOption<bool>("AiPlayerbot.BotRepairWhenSummon", true);
autoInitOnly = sConfigMgr->GetOption<bool>("AiPlayerbot.AutoInitOnly", false);
autoInitEquipLevelLimitRatio = sConfigMgr->GetOption<float>("AiPlayerbot.AutoInitEquipLevelLimitRatio", 1.0);
maxAddedBots = sConfigMgr->GetOption<int32>("AiPlayerbot.MaxAddedBots", 40);
maxAddedBotsPerClass = sConfigMgr->GetOption<int32>("AiPlayerbot.MaxAddedBotsPerClass", 10);
addClassCommand = sConfigMgr->GetOption<int32>("AiPlayerbot.AddClassCommand", 1);
@@ -352,7 +383,8 @@ bool PlayerbotAIConfig::Initialize()
selfBotLevel = sConfigMgr->GetOption<int32>("AiPlayerbot.SelfBotLevel", 1);
RandomPlayerbotFactory::CreateRandomBots();
if (World::IsStopped()) {
if (World::IsStopped())
{
return true;
}
PlayerbotFactory::Init();
@@ -418,7 +450,8 @@ std::string const PlayerbotAIConfig::GetTimestampStr()
// MM minutes (2 digits 00-59)
// SS seconds (2 digits 00-59)
char buf[20];
snprintf(buf, 20, "%04d-%02d-%02d %02d-%02d-%02d", aTm->tm_year + 1900, aTm->tm_mon + 1, aTm->tm_mday, aTm->tm_hour, aTm->tm_min, aTm->tm_sec);
snprintf(buf, 20, "%04d-%02d-%02d %02d-%02d-%02d", aTm->tm_year + 1900, aTm->tm_mon + 1, aTm->tm_mday, aTm->tm_hour,
aTm->tm_min, aTm->tm_sec);
return std::string(buf);
}
@@ -437,7 +470,7 @@ bool PlayerbotAIConfig::openLog(std::string const fileName, char const* mode)
FILE* file = logFileIt->second.first;
bool fileOpen = logFileIt->second.second;
if (fileOpen) //close log file
if (fileOpen) // close log file
fclose(file);
std::string m_logsDir = sConfigMgr->GetOption<std::string>("LogsDir", "", false);
@@ -447,7 +480,6 @@ bool PlayerbotAIConfig::openLog(std::string const fileName, char const* mode)
m_logsDir.append("/");
}
file = fopen((m_logsDir + fileName).c_str(), mode);
fileOpen = true;
@@ -490,7 +522,7 @@ void PlayerbotAIConfig::loadWorldBuf(uint32 factionId1, uint32 classId1, uint32
for (auto buff : buffs)
{
worldBuff wb = { buff, factionId1, classId1, minLevel1, maxLevel1 };
worldBuff wb = {buff, factionId1, classId1, minLevel1, maxLevel1};
worldBuffs.push_back(wb);
}
@@ -503,7 +535,7 @@ void PlayerbotAIConfig::loadWorldBuf(uint32 factionId1, uint32 classId1, uint32
for (auto buff : buffs)
{
worldBuff wb = { buff, factionId1, classId1, minLevel1, maxLevel1 };
worldBuff wb = {buff, factionId1, classId1, minLevel1, maxLevel1};
worldBuffs.push_back(wb);
}
}
@@ -517,7 +549,7 @@ void PlayerbotAIConfig::loadWorldBuf(uint32 factionId1, uint32 classId1, uint32
for (auto buff : buffs)
{
worldBuff wb = { buff, factionId1, classId1, minLevel1, maxLevel1 };
worldBuff wb = {buff, factionId1, classId1, minLevel1, maxLevel1};
worldBuffs.push_back(wb);
}
}
@@ -531,7 +563,7 @@ void PlayerbotAIConfig::loadWorldBuf(uint32 factionId1, uint32 classId1, uint32
for (auto buff : buffs)
{
worldBuff wb = { buff, factionId1, classId1, minLevel1, maxLevel1 };
worldBuff wb = {buff, factionId1, classId1, minLevel1, maxLevel1};
worldBuffs.push_back(wb);
}
}
@@ -545,34 +577,35 @@ void PlayerbotAIConfig::loadWorldBuf(uint32 factionId1, uint32 classId1, uint32
for (auto buff : buffs)
{
worldBuff wb = { buff, factionId1, classId1, minLevel1, maxLevel1 };
worldBuff wb = {buff, factionId1, classId1, minLevel1, maxLevel1};
worldBuffs.push_back(wb);
}
}
}
static std::vector<std::string> split(const std::string &str, const std::string &pattern)
static std::vector<std::string> split(const std::string& str, const std::string& pattern)
{
std::vector<std::string> res;
if(str == "")
if (str == "")
return res;
// Also add separators to string connections to facilitate intercepting the last paragraph.
std::string strs = str + pattern;
size_t pos = strs.find(pattern);
while(pos != strs.npos)
while (pos != strs.npos)
{
std::string temp = strs.substr(0, pos);
res.push_back(temp);
// Remove the split string and split the remaining string
strs = strs.substr(pos+1, strs.size());
strs = strs.substr(pos + 1, strs.size());
pos = strs.find(pattern);
}
return res;
}
std::vector<std::vector<uint32>> PlayerbotAIConfig::ParseTempTalentsOrder(uint32 cls, std::string tab_link) {
std::vector<std::vector<uint32>> PlayerbotAIConfig::ParseTempTalentsOrder(uint32 cls, std::string tab_link)
{
// check bad link
uint32 classMask = 1 << (cls - 1);
std::vector<std::vector<uint32>> res;
@@ -581,40 +614,44 @@ std::vector<std::vector<uint32>> PlayerbotAIConfig::ParseTempTalentsOrder(uint32
std::vector<std::vector<std::vector<uint32>>> orders(3);
for (uint32 i = 0; i < sTalentStore.GetNumRows(); ++i)
{
TalentEntry const *talentInfo = sTalentStore.LookupEntry(i);
if(!talentInfo)
TalentEntry const* talentInfo = sTalentStore.LookupEntry(i);
if (!talentInfo)
continue;
TalentTabEntry const *talentTabInfo = sTalentTabStore.LookupEntry( talentInfo->TalentTab );
if(!talentTabInfo)
TalentTabEntry const* talentTabInfo = sTalentTabStore.LookupEntry(talentInfo->TalentTab);
if (!talentTabInfo)
continue;
if( (classMask & talentTabInfo->ClassMask) == 0 )
if ((classMask & talentTabInfo->ClassMask) == 0)
continue;
spells[talentTabInfo->tabpage].push_back(talentInfo);
}
for (int tab = 0; tab < 3; tab++) {
if (tab_links.size() <= tab) {
for (int tab = 0; tab < 3; tab++)
{
if (tab_links.size() <= tab)
{
break;
}
std::sort(spells[tab].begin(), spells[tab].end(), [&](TalentEntry const* lhs, TalentEntry const* rhs) {
return lhs->Row != rhs->Row ? lhs->Row < rhs->Row : lhs->Col < rhs->Col;
});
for (int i = 0; i < tab_links[tab].size(); i++) {
if (i >= spells[tab].size()) {
std::sort(spells[tab].begin(), spells[tab].end(),
[&](TalentEntry const* lhs, TalentEntry const* rhs)
{ return lhs->Row != rhs->Row ? lhs->Row < rhs->Row : lhs->Col < rhs->Col; });
for (int i = 0; i < tab_links[tab].size(); i++)
{
if (i >= spells[tab].size())
{
break;
}
int lvl = tab_links[tab][i] - '0';
if (lvl == 0) continue;
if (lvl == 0)
continue;
orders[tab].push_back({(uint32)tab, spells[tab][i]->Row, spells[tab][i]->Col, (uint32)lvl});
}
}
// sort by talent tab size
std::sort(orders.begin(), orders.end(), [&](auto &lhs, auto &rhs) {
return lhs.size() > rhs.size();
});
for (auto &order : orders) {
std::sort(orders.begin(), orders.end(), [&](auto& lhs, auto& rhs) { return lhs.size() > rhs.size(); });
for (auto& order : orders)
{
res.insert(res.end(), order.begin(), order.end());
}
return res;

422
src/PlayerbotAIConfig.h
View File

@@ -1,256 +1,262 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#ifndef _PLAYERBOT_PLAYERbotAICONFIG_H
#define _PLAYERBOT_PLAYERbotAICONFIG_H
#include <mutex>
#include "Common.h"
#include "DBCEnums.h"
#include "SharedDefines.h"
#include "Talentspec.h"
#include <mutex>
enum class BotCheatMask : uint32
{
none = 0,
taxi = 1,
gold = 2,
health = 4,
mana = 8,
power = 16,
none = 0,
taxi = 1,
gold = 2,
health = 4,
mana = 8,
power = 16,
maxMask = 32
};
enum class HealingManaEfficiency : uint8
{
VERY_LOW = 1,
LOW = 2,
MEDIUM = 4,
HIGH = 8,
VERY_HIGH = 16,
SUPERIOR = 32
VERY_LOW = 1,
LOW = 2,
MEDIUM = 4,
HIGH = 8,
VERY_HIGH = 16,
SUPERIOR = 32
};
#define MAX_SPECNO 20
class PlayerbotAIConfig
{
public:
PlayerbotAIConfig() { };
static PlayerbotAIConfig* instance()
{
static PlayerbotAIConfig instance;
return &instance;
}
public:
PlayerbotAIConfig(){};
static PlayerbotAIConfig* instance()
{
static PlayerbotAIConfig instance;
return &instance;
}
bool Initialize();
bool IsInRandomAccountList(uint32 id);
bool IsInRandomQuestItemList(uint32 id);
bool IsPvpProhibited(uint32 zoneId, uint32 areaId);
bool IsInPvpProhibitedZone(uint32 id);
bool IsInPvpProhibitedArea(uint32 id);
bool Initialize();
bool IsInRandomAccountList(uint32 id);
bool IsInRandomQuestItemList(uint32 id);
bool IsPvpProhibited(uint32 zoneId, uint32 areaId);
bool IsInPvpProhibitedZone(uint32 id);
bool IsInPvpProhibitedArea(uint32 id);
bool enabled;
bool allowGuildBots, allowPlayerBots;
uint32 globalCoolDown, reactDelay, maxWaitForMove, disableMoveSplinePath, maxMovementSearchTime,
expireActionTime, dispelAuraDuration, passiveDelay, repeatDelay,
errorDelay, rpgDelay, sitDelay, returnDelay, lootDelay;
float sightDistance, spellDistance, reactDistance, grindDistance, lootDistance, shootDistance,
fleeDistance, tooCloseDistance, meleeDistance, followDistance, whisperDistance, contactDistance,
aoeRadius, rpgDistance, targetPosRecalcDistance, farDistance, healDistance, aggroDistance;
uint32 criticalHealth, lowHealth, mediumHealth, almostFullHealth;
uint32 lowMana, mediumMana;
bool autoSaveMana;
uint32 saveManaThreshold;
bool autoAvoidAoe;
bool tellWhenAvoidAoe;
uint32 openGoSpell;
bool randomBotAutologin;
bool botAutologin;
std::string randomBotMapsAsString;
float probTeleToBankers;
std::vector<uint32> randomBotMaps;
std::vector<uint32> randomBotQuestItems;
std::vector<uint32> randomBotAccounts;
std::vector<uint32> randomBotSpellIds;
std::vector<uint32> randomBotQuestIds;
uint32 randomBotTeleportDistance;
float randomGearLoweringChance;
int32 randomGearQualityLimit;
int32 randomGearScoreLimit;
float randomBotMaxLevelChance;
float randomBotRpgChance;
uint32 minRandomBots, maxRandomBots;
uint32 randomBotUpdateInterval, randomBotCountChangeMinInterval, randomBotCountChangeMaxInterval;
uint32 minRandomBotInWorldTime, maxRandomBotInWorldTime;
uint32 minRandomBotRandomizeTime, maxRandomBotRandomizeTime;
uint32 minRandomBotChangeStrategyTime, maxRandomBotChangeStrategyTime;
uint32 minRandomBotReviveTime, maxRandomBotReviveTime;
uint32 minRandomBotTeleportInterval, maxRandomBotTeleportInterval;
uint32 randomBotInWorldWithRotationDisabled;
uint32 minRandomBotPvpTime, maxRandomBotPvpTime;
uint32 randomBotsPerInterval;
uint32 minRandomBotsPriceChangeInterval, maxRandomBotsPriceChangeInterval;
bool randomBotJoinLfg;
bool randomBotTalk;
bool randomBotEmote;
bool randomBotSuggestDungeons;
bool randomBotGuildTalk;
bool suggestDungeonsInLowerCaseRandomly;
bool randomBotJoinBG;
bool randomBotAutoJoinBG;
uint32 randomBotAutoJoinWarsongBracket;
uint32 randomBotAutoJoinArenaBracket;
uint32 randomBotAutoJoinBGWarsongCount;
uint32 randomBotAutoJoinBGRatedArena2v2Count;
uint32 randomBotAutoJoinBGRatedArena3v3Count;
uint32 randomBotAutoJoinBGRatedArena5v5Count;
bool randomBotLoginAtStartup;
uint32 randomBotTeleLowerLevel, randomBotTeleHigherLevel;
bool logInGroupOnly, logValuesPerTick;
bool fleeingEnabled;
bool summonAtInnkeepersEnabled;
std::string combatStrategies, nonCombatStrategies;
std::string randomBotCombatStrategies, randomBotNonCombatStrategies;
uint32 randomBotMinLevel, randomBotMaxLevel;
float randomChangeMultiplier;
bool enabled;
bool allowGuildBots, allowPlayerBots;
uint32 globalCoolDown, reactDelay, maxWaitForMove, disableMoveSplinePath, maxMovementSearchTime, expireActionTime,
dispelAuraDuration, passiveDelay, repeatDelay, errorDelay, rpgDelay, sitDelay, returnDelay, lootDelay;
float sightDistance, spellDistance, reactDistance, grindDistance, lootDistance, shootDistance, fleeDistance,
tooCloseDistance, meleeDistance, followDistance, whisperDistance, contactDistance, aoeRadius, rpgDistance,
targetPosRecalcDistance, farDistance, healDistance, aggroDistance;
uint32 criticalHealth, lowHealth, mediumHealth, almostFullHealth;
uint32 lowMana, mediumMana;
bool autoSaveMana;
uint32 saveManaThreshold;
bool autoAvoidAoe;
bool tellWhenAvoidAoe;
uint32 openGoSpell;
bool randomBotAutologin;
bool botAutologin;
std::string randomBotMapsAsString;
float probTeleToBankers;
std::vector<uint32> randomBotMaps;
std::vector<uint32> randomBotQuestItems;
std::vector<uint32> randomBotAccounts;
std::vector<uint32> randomBotSpellIds;
std::vector<uint32> randomBotQuestIds;
uint32 randomBotTeleportDistance;
float randomGearLoweringChance;
int32 randomGearQualityLimit;
int32 randomGearScoreLimit;
float randomBotMaxLevelChance;
float randomBotRpgChance;
uint32 minRandomBots, maxRandomBots;
uint32 randomBotUpdateInterval, randomBotCountChangeMinInterval, randomBotCountChangeMaxInterval;
uint32 minRandomBotInWorldTime, maxRandomBotInWorldTime;
uint32 minRandomBotRandomizeTime, maxRandomBotRandomizeTime;
uint32 minRandomBotChangeStrategyTime, maxRandomBotChangeStrategyTime;
uint32 minRandomBotReviveTime, maxRandomBotReviveTime;
uint32 minRandomBotTeleportInterval, maxRandomBotTeleportInterval;
uint32 randomBotInWorldWithRotationDisabled;
uint32 minRandomBotPvpTime, maxRandomBotPvpTime;
uint32 randomBotsPerInterval;
uint32 minRandomBotsPriceChangeInterval, maxRandomBotsPriceChangeInterval;
bool randomBotJoinLfg;
bool randomBotTalk;
bool randomBotEmote;
bool randomBotSuggestDungeons;
bool randomBotGuildTalk;
bool suggestDungeonsInLowerCaseRandomly;
bool randomBotJoinBG;
bool randomBotAutoJoinBG;
uint32 randomBotAutoJoinWarsongBracket;
uint32 randomBotAutoJoinArenaBracket;
uint32 randomBotAutoJoinBGWarsongCount;
uint32 randomBotAutoJoinBGRatedArena2v2Count;
uint32 randomBotAutoJoinBGRatedArena3v3Count;
uint32 randomBotAutoJoinBGRatedArena5v5Count;
bool randomBotLoginAtStartup;
uint32 randomBotTeleLowerLevel, randomBotTeleHigherLevel;
bool logInGroupOnly, logValuesPerTick;
bool fleeingEnabled;
bool summonAtInnkeepersEnabled;
std::string combatStrategies, nonCombatStrategies;
std::string randomBotCombatStrategies, randomBotNonCombatStrategies;
uint32 randomBotMinLevel, randomBotMaxLevel;
float randomChangeMultiplier;
// std::string premadeLevelSpec[MAX_CLASSES][10][91]; //lvl 10 - 100
// ClassSpecs classSpecs[MAX_CLASSES];
// std::string premadeLevelSpec[MAX_CLASSES][10][91]; //lvl 10 - 100
// ClassSpecs classSpecs[MAX_CLASSES];
std::string premadeSpecName[MAX_CLASSES][MAX_SPECNO];
std::string premadeSpecGlyph[MAX_CLASSES][MAX_SPECNO];
std::vector<uint32> parsedSpecGlyph[MAX_CLASSES][MAX_SPECNO];
std::string premadeSpecLink[MAX_CLASSES][MAX_SPECNO][MAX_LEVEL];
std::vector<std::vector<uint32>> parsedSpecLinkOrder[MAX_CLASSES][MAX_SPECNO][MAX_LEVEL];
uint32 randomClassSpecProb[MAX_CLASSES][MAX_SPECNO];
uint32 randomClassSpecIndex[MAX_CLASSES][MAX_SPECNO];
std::string premadeSpecName[MAX_CLASSES][MAX_SPECNO];
std::string premadeSpecGlyph[MAX_CLASSES][MAX_SPECNO];
std::vector<uint32> parsedSpecGlyph[MAX_CLASSES][MAX_SPECNO];
std::string premadeSpecLink[MAX_CLASSES][MAX_SPECNO][MAX_LEVEL];
std::vector<std::vector<uint32>> parsedSpecLinkOrder[MAX_CLASSES][MAX_SPECNO][MAX_LEVEL];
uint32 randomClassSpecProb[MAX_CLASSES][MAX_SPECNO];
uint32 randomClassSpecIndex[MAX_CLASSES][MAX_SPECNO];
std::string commandPrefix, commandSeparator;
std::string randomBotAccountPrefix;
uint32 randomBotAccountCount;
bool randomBotRandomPassword;
bool deleteRandomBotAccounts;
uint32 randomBotGuildCount;
bool deleteRandomBotGuilds;
std::vector<uint32> randomBotGuilds;
std::vector<uint32> pvpProhibitedZoneIds;
std::vector<uint32> pvpProhibitedAreaIds;
std::string commandPrefix, commandSeparator;
std::string randomBotAccountPrefix;
uint32 randomBotAccountCount;
bool randomBotRandomPassword;
bool deleteRandomBotAccounts;
uint32 randomBotGuildCount;
bool deleteRandomBotGuilds;
std::vector<uint32> randomBotGuilds;
std::vector<uint32> pvpProhibitedZoneIds;
std::vector<uint32> pvpProhibitedAreaIds;
bool randombotsWalkingRPG;
bool randombotsWalkingRPGInDoors;
uint32 minEnchantingBotLevel;
uint32 limitEnchantExpansion;
uint32 limitGearExpansion;
uint32 randombotStartingLevel;
bool enableRotation;
uint32 rotationPoolSize;
bool gearscorecheck;
bool randomBotPreQuests;
bool randombotsWalkingRPG;
bool randombotsWalkingRPGInDoors;
uint32 minEnchantingBotLevel;
uint32 limitEnchantExpansion;
uint32 limitGearExpansion;
uint32 randombotStartingLevel;
bool enableRotation;
uint32 rotationPoolSize;
bool gearscorecheck;
bool randomBotPreQuests;
bool guildTaskEnabled;
uint32 minGuildTaskChangeTime, maxGuildTaskChangeTime;
uint32 minGuildTaskAdvertisementTime, maxGuildTaskAdvertisementTime;
uint32 minGuildTaskRewardTime, maxGuildTaskRewardTime;
uint32 guildTaskAdvertCleanupTime;
uint32 guildTaskKillTaskDistance;
bool guildTaskEnabled;
uint32 minGuildTaskChangeTime, maxGuildTaskChangeTime;
uint32 minGuildTaskAdvertisementTime, maxGuildTaskAdvertisementTime;
uint32 minGuildTaskRewardTime, maxGuildTaskRewardTime;
uint32 guildTaskAdvertCleanupTime;
uint32 guildTaskKillTaskDistance;
uint32 iterationsPerTick;
uint32 iterationsPerTick;
std::mutex m_logMtx;
std::vector<std::string> allowedLogFiles;
std::unordered_map<std::string, std::pair<FILE*, bool>> logFiles;
std::mutex m_logMtx;
std::vector<std::string> allowedLogFiles;
std::unordered_map<std::string, std::pair<FILE*, bool>> logFiles;
std::vector<std::string> botCheats;
uint32 botCheatMask = 0;
std::vector<std::string> botCheats;
uint32 botCheatMask = 0;
struct worldBuff
{
uint32 spellId;
uint32 factionId = 0;
uint32 classId = 0;
uint32 minLevel = 0;
uint32 maxLevel = 0;
};
struct worldBuff
{
uint32 spellId;
uint32 factionId = 0;
uint32 classId = 0;
uint32 minLevel = 0;
uint32 maxLevel = 0;
};
std::vector<worldBuff> worldBuffs;
std::vector<worldBuff> worldBuffs;
uint32 commandServerPort;
bool perfMonEnabled;
uint32 commandServerPort;
bool perfMonEnabled;
bool enableGreet;
bool summonWhenGroup;
bool randomBotShowHelmet;
bool randomBotShowCloak;
bool randomBotFixedLevel;
bool disableRandomLevels;
uint32 playerbotsXPrate;
bool disableDeathKnightLogin;
uint32 botActiveAlone;
bool enableGreet;
bool summonWhenGroup;
bool randomBotShowHelmet;
bool randomBotShowCloak;
bool randomBotFixedLevel;
bool disableRandomLevels;
uint32 playerbotsXPrate;
bool disableDeathKnightLogin;
uint32 botActiveAlone;
uint32 enablePrototypePerformanceDiff;
uint32 diffWithPlayer;
uint32 diffEmpty;
uint32 enablePrototypePerformanceDiff;
uint32 diffWithPlayer;
uint32 diffEmpty;
bool freeMethodLoot;
int32 lootRollLevel;
std::string autoPickReward;
bool autoEquipUpgradeLoot;
float equipUpgradeThreshold;
bool syncQuestWithPlayer;
bool syncQuestForPlayer;
std::string autoTrainSpells;
bool autoPickTalents;
bool autoUpgradeEquip;
bool autoLearnTrainerSpells;
bool autoDoQuests;
bool syncLevelWithPlayers;
bool freeFood;
bool autoLearnQuestSpells;
bool autoTeleportForLevel;
bool randomBotSayWithoutMaster;
bool sayWhenCollectingItems;
bool randomBotGroupNearby;
uint32 tweakValue; //Debugging config
bool freeMethodLoot;
int32 lootRollLevel;
std::string autoPickReward;
bool autoEquipUpgradeLoot;
float equipUpgradeThreshold;
bool syncQuestWithPlayer;
bool syncQuestForPlayer;
std::string autoTrainSpells;
bool autoPickTalents;
bool autoUpgradeEquip;
bool autoLearnTrainerSpells;
bool autoDoQuests;
bool syncLevelWithPlayers;
bool freeFood;
bool autoLearnQuestSpells;
bool autoTeleportForLevel;
bool randomBotSayWithoutMaster;
bool sayWhenCollectingItems;
bool randomBotGroupNearby;
uint32 tweakValue; // Debugging config
uint32 randomBotArenaTeamCount;
uint32 randomBotArenaTeamMaxRating;
uint32 randomBotArenaTeamMinRating;
uint32 randomBotArenaTeam2v2Count;
uint32 randomBotArenaTeam3v3Count;
uint32 randomBotArenaTeam5v5Count;
bool deleteRandomBotArenaTeams;
std::vector<uint32> randomBotArenaTeams;
uint32 randomBotArenaTeamCount;
uint32 randomBotArenaTeamMaxRating;
uint32 randomBotArenaTeamMinRating;
uint32 randomBotArenaTeam2v2Count;
uint32 randomBotArenaTeam3v3Count;
uint32 randomBotArenaTeam5v5Count;
bool deleteRandomBotArenaTeams;
std::vector<uint32> randomBotArenaTeams;
uint32 selfBotLevel;
bool downgradeMaxLevelBot;
bool equipmentPersistence;
int32 equipmentPersistenceLevel;
int32 groupInvitationPermission;
bool allowSummonInCombat;
bool allowSummonWhenMasterIsDead;
bool allowSummonWhenBotIsDead;
int reviveBotWhenSummoned;
bool botRepairWhenSummon;
bool autoInitOnly;
float autoInitEquipLevelLimitRatio;
int32 maxAddedBots, maxAddedBotsPerClass;
int32 addClassCommand;
int32 maintenanceCommand;
int32 autoGearCommand, autoGearQualityLimit, autoGearScoreLimit;
uint32 selfBotLevel;
bool downgradeMaxLevelBot;
bool equipmentPersistence;
int32 equipmentPersistenceLevel;
int32 groupInvitationPermission;
bool allowSummonInCombat;
bool allowSummonWhenMasterIsDead;
bool allowSummonWhenBotIsDead;
int reviveBotWhenSummoned;
bool botRepairWhenSummon;
bool autoInitOnly;
float autoInitEquipLevelLimitRatio;
int32 maxAddedBots, maxAddedBotsPerClass;
int32 addClassCommand;
int32 maintenanceCommand;
int32 autoGearCommand, autoGearQualityLimit, autoGearScoreLimit;
std::string const GetTimestampStr();
bool hasLog(std::string const fileName) { return std::find(allowedLogFiles.begin(), allowedLogFiles.end(), fileName) != allowedLogFiles.end(); };
bool openLog(std::string const fileName, char const* mode = "a");
bool isLogOpen(std::string const fileName) { auto it = logFiles.find(fileName); return it != logFiles.end() && it->second.second; }
void log(std::string const fileName, const char* str, ...);
std::string const GetTimestampStr();
bool hasLog(std::string const fileName)
{
return std::find(allowedLogFiles.begin(), allowedLogFiles.end(), fileName) != allowedLogFiles.end();
};
bool openLog(std::string const fileName, char const* mode = "a");
bool isLogOpen(std::string const fileName)
{
auto it = logFiles.find(fileName);
return it != logFiles.end() && it->second.second;
}
void log(std::string const fileName, const char* str, ...);
void loadWorldBuf(uint32 factionId, uint32 classId, uint32 minLevel, uint32 maxLevel);
static std::vector<std::vector<uint32>> ParseTempTalentsOrder(uint32 cls, std::string temp_talents_order);
void loadWorldBuf(uint32 factionId, uint32 classId, uint32 minLevel, uint32 maxLevel);
static std::vector<std::vector<uint32>> ParseTempTalentsOrder(uint32 cls, std::string temp_talents_order);
};
#define sPlayerbotAIConfig PlayerbotAIConfig::instance()

17
src/PlayerbotCommandServer.cpp
View File

@@ -1,18 +1,19 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#include "PlayerbotCommandServer.h"
#include "IoContext.h"
#include "Playerbots.h"
#include <boost/asio.hpp>
#include <boost/bind.hpp>
#include <boost/smart_ptr.hpp>
#include <boost/thread/thread.hpp>
#include <cstdlib>
#include <iostream>
#include <boost/bind.hpp>
#include <boost/smart_ptr.hpp>
#include <boost/asio.hpp>
#include <boost/thread/thread.hpp>
#include "IoContext.h"
#include "Playerbots.h"
using boost::asio::ip::tcp;
typedef boost::shared_ptr<tcp::socket> socket_ptr;
@@ -29,7 +30,7 @@ bool ReadLine(socket_ptr sock, std::string* buffer, std::string* line)
if (n == -1 || error == boost::asio::error::eof)
return false;
else if (error)
throw boost::system::system_error(error); // Some other error.
throw boost::system::system_error(error); // Some other error.
buf[n] = 0;
*buffer += buf;

21
src/PlayerbotCommandServer.h
View File

@@ -1,5 +1,6 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#ifndef _PLAYERBOT_PLAYERBOTCOMMANDSERVER_H
@@ -7,16 +8,16 @@
class PlayerbotCommandServer
{
public:
PlayerbotCommandServer() { }
virtual ~PlayerbotCommandServer() { }
static PlayerbotCommandServer* instance()
{
static PlayerbotCommandServer instance;
return &instance;
}
public:
PlayerbotCommandServer() {}
virtual ~PlayerbotCommandServer() {}
static PlayerbotCommandServer* instance()
{
static PlayerbotCommandServer instance;
return &instance;
}
void Start();
void Start();
};
#define sPlayerbotCommandServer PlayerbotCommandServer::instance()

9
src/PlayerbotDbStore.cpp
View File

@@ -1,12 +1,14 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#include "PlayerbotDbStore.h"
#include "Playerbots.h"
#include <iostream>
#include "Playerbots.h"
void PlayerbotDbStore::Load(PlayerbotAI* botAI)
{
ObjectGuid::LowType guid = botAI->GetBot()->GetGUID().GetCounter();
@@ -35,8 +37,7 @@ void PlayerbotDbStore::Load(PlayerbotAI* botAI)
botAI->ChangeStrategy(value, BOT_STATE_NON_COMBAT);
else if (key == "dead")
botAI->ChangeStrategy(value, BOT_STATE_DEAD);
}
while (result->NextRow());
} while (result->NextRow());
botAI->GetAiObjectContext()->Load(values);
}

35
src/PlayerbotDbStore.h
View File

@@ -1,34 +1,35 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#ifndef _PLAYERBOT_PLAYERBOTDBSTORE_H
#define _PLAYERBOT_PLAYERBOTDBSTORE_H
#include "Common.h"
#include <vector>
#include "Common.h"
class PlayerbotAI;
class PlayerbotDbStore
{
public:
PlayerbotDbStore() { }
virtual ~PlayerbotDbStore() { }
static PlayerbotDbStore* instance()
{
static PlayerbotDbStore instance;
return &instance;
}
public:
PlayerbotDbStore() {}
virtual ~PlayerbotDbStore() {}
static PlayerbotDbStore* instance()
{
static PlayerbotDbStore instance;
return &instance;
}
void Save(PlayerbotAI* botAI);
void Load(PlayerbotAI* botAI);
void Reset(PlayerbotAI* botAI);
void Save(PlayerbotAI* botAI);
void Load(PlayerbotAI* botAI);
void Reset(PlayerbotAI* botAI);
private:
void SaveValue(uint32 guid, std::string const key, std::string const value);
std::string const FormatStrategies(std::string const type, std::vector<std::string> strategies);
private:
void SaveValue(uint32 guid, std::string const key, std::string const value);
std::string const FormatStrategies(std::string const type, std::vector<std::string> strategies);
};
#define sPlayerbotDbStore PlayerbotDbStore::instance()

22
src/PlayerbotDungeonSuggestionMgr.cpp
View File

@@ -1,8 +1,10 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#include "PlayerbotDungeonSuggestionMgr.h"
#include "Playerbots.h"
std::vector<DungeonSuggestion> const PlayerbotDungeonSuggestionMgr::GetDungeonSuggestions()
@@ -33,22 +35,14 @@ void PlayerbotDungeonSuggestionMgr::LoadDungeonSuggestions()
std::string const abbrevation = fields[4].Get<std::string>();
std::string const strategy = fields[5].Get<std::string>();
DungeonSuggestion const row =
{
name,
static_cast<Difficulty>(difficulty),
min_level,
max_level,
abbrevation,
strategy
};
DungeonSuggestion const row = {
name, static_cast<Difficulty>(difficulty), min_level, max_level, abbrevation, strategy};
m_dungeonSuggestions.push_back(row);
++count;
}
while (result->NextRow());
} while (result->NextRow());
}
LOG_INFO("server.loading", "{} playerbots dungeon suggestions loaded in {} ms",
count, GetMSTimeDiffToNow(oldMSTime));
LOG_INFO("server.loading", "{} playerbots dungeon suggestions loaded in {} ms", count,
GetMSTimeDiffToNow(oldMSTime));
}

33
src/PlayerbotDungeonSuggestionMgr.h
View File

@@ -1,16 +1,17 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#ifndef _PLAYERBOT_PLAYERBOTDUNGEONSUGGESTIONMGR_H
#define _PLAYERBOT_PLAYERBOTDUNGEONSUGGESTIONMGR_H
#include "Common.h"
#include "DBCEnums.h"
#include <map>
#include <vector>
#include "Common.h"
#include "DBCEnums.h"
struct DungeonSuggestion
{
std::string name;
@@ -23,20 +24,20 @@ struct DungeonSuggestion
class PlayerbotDungeonSuggestionMgr
{
public:
PlayerbotDungeonSuggestionMgr() { };
~PlayerbotDungeonSuggestionMgr() { };
static PlayerbotDungeonSuggestionMgr* instance()
{
static PlayerbotDungeonSuggestionMgr instance;
return &instance;
}
public:
PlayerbotDungeonSuggestionMgr(){};
~PlayerbotDungeonSuggestionMgr(){};
static PlayerbotDungeonSuggestionMgr* instance()
{
static PlayerbotDungeonSuggestionMgr instance;
return &instance;
}
void LoadDungeonSuggestions();
std::vector<DungeonSuggestion> const GetDungeonSuggestions();
void LoadDungeonSuggestions();
std::vector<DungeonSuggestion> const GetDungeonSuggestions();
private:
std::vector<DungeonSuggestion> m_dungeonSuggestions;
private:
std::vector<DungeonSuggestion> m_dungeonSuggestions;
};
#define sPlayerbotDungeonSuggestionMgr PlayerbotDungeonSuggestionMgr::instance()

1942
src/PlayerbotFactory.cpp
View File

File diff suppressed because it is too large Load Diff

303
src/PlayerbotFactory.h
View File

@@ -1,5 +1,6 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#ifndef _PLAYERBOT_PLAYERBOTFACTORY_H
@@ -15,15 +16,15 @@ struct ItemTemplate;
struct EnchantTemplate
{
uint8 ClassId;
uint8 SpecId;
uint32 SpellId;
uint8 SlotId;
uint8 ClassId;
uint8 SpecId;
uint32 SpellId;
uint8 SlotId;
};
typedef std::vector<EnchantTemplate> EnchantContainer;
//TODO: more spec/role
// TODO: more spec/role
/* classid+talenttree
enum spec : uint8
{
@@ -46,158 +47,160 @@ enum spec : uint8
enum PriorizedConsumables
{
CONSUM_ID_ROUGH_WEIGHTSTONE = 3239,
CONSUM_ID_COARSE_WEIGHTSTONE = 3239,
CONSUM_ID_HEAVY_WEIGHTSTONE = 3241,
CONSUM_ID_SOLID_WEIGHTSTONE = 7965,
CONSUM_ID_DENSE_WEIGHTSTONE = 12643,
CONSUM_ID_FEL_WEIGHTSTONE = 28420,
CONSUM_ID_ADAMANTITE_WEIGHTSTONE = 28421,
CONSUM_ID_ROUGH_SHARPENING_STONE = 2862,
CONSUM_ID_COARSE_SHARPENING_STONE = 2863,
CONSUM_ID_HEAVY_SHARPENING_STONE = 2871,
CONSUM_ID_SOL_SHARPENING_STONE = 7964,
CONSUM_ID_DENSE_SHARPENING_STONE = 12404,
CONSUM_ID_ELEMENTAL_SHARPENING_STONE = 18262,
CONSUM_ID_CONSECRATED_SHARPENING_STONE = 23122,
CONSUM_ID_FEL_SHARPENING_STONE = 23528,
CONSUM_ID_ADAMANTITE_SHARPENING_STONE = 23529,
CONSUM_ID_LINEN_BANDAGE = 1251,
CONSUM_ID_HEAVY_LINEN_BANDAGE = 2581,
CONSUM_ID_WOOL_BANDAGE = 3530,
CONSUM_ID_HEAVY_WOOL_BANDAGE = 3531,
CONSUM_ID_SILK_BANDAGE = 6450,
CONSUM_ID_HEAVY_SILK_BANDAGE = 6451,
CONSUM_ID_MAGEWEAVE_BANDAGE = 8544,
CONSUM_ID_HEAVY_MAGEWEAVE_BANDAGE = 8545,
CONSUM_ID_RUNECLOTH_BANDAGE = 14529,
CONSUM_ID_HEAVY_RUNECLOTH_BANDAGE = 14530,
CONSUM_ID_NETHERWEAVE_BANDAGE = 21990,
CONSUM_ID_HEAVY_NETHERWEAVE_BANDAGE = 21991,
CONSUM_ID_BRILLIANT_MANA_OIL = 20748,
CONSUM_ID_MINOR_MANA_OIL = 20745,
CONSUM_ID_SUPERIOR_MANA_OIL = 22521,
CONSUM_ID_LESSER_MANA_OIL = 20747,
CONSUM_ID_BRILLIANT_WIZARD_OIL = 20749,
CONSUM_ID_MINOR_WIZARD_OIL = 20744,
CONSUM_ID_SUPERIOR_WIZARD_OIL = 22522,
CONSUM_ID_WIZARD_OIL = 20750,
CONSUM_ID_LESSER_WIZARD_OIL = 20746,
CONSUM_ID_INSTANT_POISON = 6947,
CONSUM_ID_INSTANT_POISON_II = 6949,
CONSUM_ID_INSTANT_POISON_III = 6950,
CONSUM_ID_INSTANT_POISON_IV = 8926,
CONSUM_ID_INSTANT_POISON_V = 8927,
CONSUM_ID_INSTANT_POISON_VI = 8928,
CONSUM_ID_INSTANT_POISON_VII = 21927,
CONSUM_ID_DEADLY_POISON = 2892,
CONSUM_ID_DEADLY_POISON_II = 2893,
CONSUM_ID_DEADLY_POISON_III = 8984,
CONSUM_ID_DEADLY_POISON_IV = 8985,
CONSUM_ID_DEADLY_POISON_V = 20844,
CONSUM_ID_DEADLY_POISON_VI = 22053,
CONSUM_ID_DEADLY_POISON_VII = 22054
CONSUM_ID_ROUGH_WEIGHTSTONE = 3239,
CONSUM_ID_COARSE_WEIGHTSTONE = 3239,
CONSUM_ID_HEAVY_WEIGHTSTONE = 3241,
CONSUM_ID_SOLID_WEIGHTSTONE = 7965,
CONSUM_ID_DENSE_WEIGHTSTONE = 12643,
CONSUM_ID_FEL_WEIGHTSTONE = 28420,
CONSUM_ID_ADAMANTITE_WEIGHTSTONE = 28421,
CONSUM_ID_ROUGH_SHARPENING_STONE = 2862,
CONSUM_ID_COARSE_SHARPENING_STONE = 2863,
CONSUM_ID_HEAVY_SHARPENING_STONE = 2871,
CONSUM_ID_SOL_SHARPENING_STONE = 7964,
CONSUM_ID_DENSE_SHARPENING_STONE = 12404,
CONSUM_ID_ELEMENTAL_SHARPENING_STONE = 18262,
CONSUM_ID_CONSECRATED_SHARPENING_STONE = 23122,
CONSUM_ID_FEL_SHARPENING_STONE = 23528,
CONSUM_ID_ADAMANTITE_SHARPENING_STONE = 23529,
CONSUM_ID_LINEN_BANDAGE = 1251,
CONSUM_ID_HEAVY_LINEN_BANDAGE = 2581,
CONSUM_ID_WOOL_BANDAGE = 3530,
CONSUM_ID_HEAVY_WOOL_BANDAGE = 3531,
CONSUM_ID_SILK_BANDAGE = 6450,
CONSUM_ID_HEAVY_SILK_BANDAGE = 6451,
CONSUM_ID_MAGEWEAVE_BANDAGE = 8544,
CONSUM_ID_HEAVY_MAGEWEAVE_BANDAGE = 8545,
CONSUM_ID_RUNECLOTH_BANDAGE = 14529,
CONSUM_ID_HEAVY_RUNECLOTH_BANDAGE = 14530,
CONSUM_ID_NETHERWEAVE_BANDAGE = 21990,
CONSUM_ID_HEAVY_NETHERWEAVE_BANDAGE = 21991,
CONSUM_ID_BRILLIANT_MANA_OIL = 20748,
CONSUM_ID_MINOR_MANA_OIL = 20745,
CONSUM_ID_SUPERIOR_MANA_OIL = 22521,
CONSUM_ID_LESSER_MANA_OIL = 20747,
CONSUM_ID_BRILLIANT_WIZARD_OIL = 20749,
CONSUM_ID_MINOR_WIZARD_OIL = 20744,
CONSUM_ID_SUPERIOR_WIZARD_OIL = 22522,
CONSUM_ID_WIZARD_OIL = 20750,
CONSUM_ID_LESSER_WIZARD_OIL = 20746,
CONSUM_ID_INSTANT_POISON = 6947,
CONSUM_ID_INSTANT_POISON_II = 6949,
CONSUM_ID_INSTANT_POISON_III = 6950,
CONSUM_ID_INSTANT_POISON_IV = 8926,
CONSUM_ID_INSTANT_POISON_V = 8927,
CONSUM_ID_INSTANT_POISON_VI = 8928,
CONSUM_ID_INSTANT_POISON_VII = 21927,
CONSUM_ID_DEADLY_POISON = 2892,
CONSUM_ID_DEADLY_POISON_II = 2893,
CONSUM_ID_DEADLY_POISON_III = 8984,
CONSUM_ID_DEADLY_POISON_IV = 8985,
CONSUM_ID_DEADLY_POISON_V = 20844,
CONSUM_ID_DEADLY_POISON_VI = 22053,
CONSUM_ID_DEADLY_POISON_VII = 22054
};
#define MAX_CONSUM_ID 28
class PlayerbotFactory
{
public:
PlayerbotFactory(Player* bot, uint32 level, uint32 itemQuality = 0, uint32 gearScoreLimit = 0);
public:
PlayerbotFactory(Player* bot, uint32 level, uint32 itemQuality = 0, uint32 gearScoreLimit = 0);
static ObjectGuid GetRandomBot();
static void Init();
void Refresh();
void Randomize(bool incremental);
static std::list<uint32> classQuestIds;
void ClearEverything();
void InitSkills();
static ObjectGuid GetRandomBot();
static void Init();
void Refresh();
void Randomize(bool incremental);
static std::list<uint32> classQuestIds;
void ClearEverything();
void InitSkills();
static uint32 tradeSkills[];
static float CalculateItemScore(uint32 item_id, Player* bot);
static float CalculateEnchantScore(uint32 enchant_id, Player* bot);
static float CalculateSpellScore(uint32 spell_id, Player* bot, uint32 trigger = ITEM_SPELLTRIGGER_ON_EQUIP);
void InitTalentsTree(bool incremental = false, bool use_template = true, bool reset = false);
static void InitTalentsBySpecNo(Player* bot, int specNo, bool reset);
static void InitTalentsByParsedSpecLink(Player* bot, std::vector<std::vector<uint32>> parsedSpecLink, bool reset);
void InitAvailableSpells();
void InitClassSpells();
void InitEquipment(bool incremental);
void InitPet();
void InitAmmo();
static uint32 CalcMixedGearScore(uint32 gs, uint32 quality);
void InitPetTalents();
void InitReagents();
void InitGlyphs(bool increment = false);
void InitFood();
void InitMounts();
void InitBags(bool destroyOld = true);
void ApplyEnchantAndGemsNew(bool destoryOld = true);
void InitInstanceQuests();
void UnbindInstance();
private:
void Prepare();
// void InitSecondEquipmentSet();
// void InitEquipmentNew(bool incremental);
bool CanEquipItem(ItemTemplate const* proto, uint32 desiredQuality);
bool CanEquipUnseenItem(uint8 slot, uint16& dest, uint32 item);
void InitTradeSkills();
void UpdateTradeSkills();
void SetRandomSkill(uint16 id);
void InitSpells();
void ClearSpells();
void ClearSkills();
void InitSpecialSpells();
void InitTalents(uint32 specNo);
void InitTalentsByTemplate(uint32 specNo);
void InitQuests(std::list<uint32>& questMap);
void ClearInventory();
void ClearAllItems();
void ResetQuests();
void InitPotions();
bool CanEquipArmor(ItemTemplate const* proto);
bool CanEquipWeapon(ItemTemplate const* proto);
void EnchantItem(Item* item);
void AddItemStats(uint32 mod, uint8& sp, uint8& ap, uint8& tank);
bool CheckItemStats(uint8 sp, uint8 ap, uint8 tank);
void CancelAuras();
bool IsDesiredReplacement(Item* item);
void InitInventory();
void InitInventoryTrade();
void InitInventoryEquip();
void InitInventorySkill();
Item* StoreItem(uint32 itemId, uint32 count);
void InitGuild();
void InitArenaTeam();
void InitImmersive();
void AddConsumables();
static void AddPrevQuests(uint32 questId, std::list<uint32>& questIds);
void LoadEnchantContainer();
void ApplyEnchantTemplate();
void ApplyEnchantTemplate(uint8 spec);
std::vector<InventoryType> GetPossibleInventoryTypeListBySlot(EquipmentSlots slot);
static bool IsShieldTank(Player* bot);
static bool NotSameArmorType(uint32 item_subclass_armor, Player* bot);
void IterateItems(IterateItemsVisitor* visitor, IterateItemsMask mask = ITERATE_ITEMS_IN_BAGS);
void IterateItemsInBags(IterateItemsVisitor* visitor);
void IterateItemsInEquip(IterateItemsVisitor* visitor);
void IterateItemsInBank(IterateItemsVisitor* visitor);
EnchantContainer::const_iterator GetEnchantContainerBegin() { return m_EnchantContainer.begin(); }
EnchantContainer::const_iterator GetEnchantContainerEnd() { return m_EnchantContainer.end(); }
uint32 level;
uint32 itemQuality;
uint32 gearScoreLimit;
static std::list<uint32> specialQuestIds;
std::vector<uint32> trainerIdCache;
static std::vector<uint32> enchantSpellIdCache;
static std::vector<uint32> enchantGemIdCache;
protected:
EnchantContainer m_EnchantContainer;
Player* bot;
PlayerbotAI* botAI;
static uint32 tradeSkills[];
static float CalculateItemScore(uint32 item_id, Player* bot);
static float CalculateEnchantScore(uint32 enchant_id, Player* bot);
static float CalculateSpellScore(uint32 spell_id, Player* bot, uint32 trigger = ITEM_SPELLTRIGGER_ON_EQUIP);
void InitTalentsTree(bool incremental = false, bool use_template = true, bool reset = false);
static void InitTalentsBySpecNo(Player* bot, int specNo, bool reset);
static void InitTalentsByParsedSpecLink(Player* bot, std::vector<std::vector<uint32>> parsedSpecLink, bool reset);
void InitAvailableSpells();
void InitClassSpells();
void InitEquipment(bool incremental);
void InitPet();
void InitAmmo();
static uint32 CalcMixedGearScore(uint32 gs, uint32 quality);
void InitPetTalents();
void InitReagents();
void InitGlyphs(bool increment = false);
void InitFood();
void InitMounts();
void InitBags(bool destroyOld = true);
void ApplyEnchantAndGemsNew(bool destoryOld = true);
void InitInstanceQuests();
void UnbindInstance();
private:
void Prepare();
// void InitSecondEquipmentSet();
// void InitEquipmentNew(bool incremental);
bool CanEquipItem(ItemTemplate const* proto, uint32 desiredQuality);
bool CanEquipUnseenItem(uint8 slot, uint16& dest, uint32 item);
void InitTradeSkills();
void UpdateTradeSkills();
void SetRandomSkill(uint16 id);
void InitSpells();
void ClearSpells();
void ClearSkills();
void InitSpecialSpells();
void InitTalents(uint32 specNo);
void InitTalentsByTemplate(uint32 specNo);
void InitQuests(std::list<uint32>& questMap);
void ClearInventory();
void ClearAllItems();
void ResetQuests();
void InitPotions();
bool CanEquipArmor(ItemTemplate const* proto);
bool CanEquipWeapon(ItemTemplate const* proto);
void EnchantItem(Item* item);
void AddItemStats(uint32 mod, uint8& sp, uint8& ap, uint8& tank);
bool CheckItemStats(uint8 sp, uint8 ap, uint8 tank);
void CancelAuras();
bool IsDesiredReplacement(Item* item);
void InitInventory();
void InitInventoryTrade();
void InitInventoryEquip();
void InitInventorySkill();
Item* StoreItem(uint32 itemId, uint32 count);
void InitGuild();
void InitArenaTeam();
void InitImmersive();
void AddConsumables();
static void AddPrevQuests(uint32 questId, std::list<uint32>& questIds);
void LoadEnchantContainer();
void ApplyEnchantTemplate();
void ApplyEnchantTemplate(uint8 spec);
std::vector<InventoryType> GetPossibleInventoryTypeListBySlot(EquipmentSlots slot);
static bool IsShieldTank(Player* bot);
static bool NotSameArmorType(uint32 item_subclass_armor, Player* bot);
void IterateItems(IterateItemsVisitor* visitor, IterateItemsMask mask = ITERATE_ITEMS_IN_BAGS);
void IterateItemsInBags(IterateItemsVisitor* visitor);
void IterateItemsInEquip(IterateItemsVisitor* visitor);
void IterateItemsInBank(IterateItemsVisitor* visitor);
EnchantContainer::const_iterator GetEnchantContainerBegin() { return m_EnchantContainer.begin(); }
EnchantContainer::const_iterator GetEnchantContainerEnd() { return m_EnchantContainer.end(); }
uint32 level;
uint32 itemQuality;
uint32 gearScoreLimit;
static std::list<uint32> specialQuestIds;
std::vector<uint32> trainerIdCache;
static std::vector<uint32> enchantSpellIdCache;
static std::vector<uint32> enchantGemIdCache;
protected:
EnchantContainer m_EnchantContainer;
Player* bot;
PlayerbotAI* botAI;
};
#endif

350
src/PlayerbotMgr.cpp
View File

@@ -1,7 +1,16 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#include "PlayerbotMgr.h"
#include <cstdio>
#include <cstring>
#include <istream>
#include <string>
#include "ChannelMgr.h"
#include "CharacterCache.h"
#include "CharacterPackets.h"
#include "Common.h"
@@ -11,35 +20,29 @@
#include "ObjectAccessor.h"
#include "ObjectMgr.h"
#include "PlayerbotAIConfig.h"
#include "PlayerbotMgr.h"
#include "PlayerbotSecurity.h"
#include "Playerbots.h"
#include "PlayerbotDbStore.h"
#include "PlayerbotFactory.h"
#include "PlayerbotSecurity.h"
#include "Playerbots.h"
#include "SharedDefines.h"
#include "WorldSession.h"
#include "ChannelMgr.h"
#include <cstdio>
#include <cstring>
#include <istream>
#include <string>
PlayerbotHolder::PlayerbotHolder() : PlayerbotAIBase(false)
{
}
PlayerbotHolder::PlayerbotHolder() : PlayerbotAIBase(false) {}
class PlayerbotLoginQueryHolder : public LoginQueryHolder
{
private:
uint32 masterAccountId;
PlayerbotHolder* playerbotHolder;
private:
uint32 masterAccountId;
PlayerbotHolder* playerbotHolder;
public:
PlayerbotLoginQueryHolder(PlayerbotHolder* playerbotHolder, uint32 masterAccount, uint32 accountId, ObjectGuid guid)
: LoginQueryHolder(accountId, guid), masterAccountId(masterAccount), playerbotHolder(playerbotHolder) { }
public:
PlayerbotLoginQueryHolder(PlayerbotHolder* playerbotHolder, uint32 masterAccount, uint32 accountId, ObjectGuid guid)
: LoginQueryHolder(accountId, guid), masterAccountId(masterAccount), playerbotHolder(playerbotHolder)
{
}
uint32 GetMasterAccountId() const { return masterAccountId; }
PlayerbotHolder* GetPlayerbotHolder() { return playerbotHolder; }
uint32 GetMasterAccountId() const { return masterAccountId; }
PlayerbotHolder* GetPlayerbotHolder() { return playerbotHolder; }
};
void PlayerbotHolder::AddPlayerBot(ObjectGuid playerGuid, uint32 masterAccountId)
@@ -53,7 +56,8 @@ void PlayerbotHolder::AddPlayerBot(ObjectGuid playerGuid, uint32 masterAccountId
if (!accountId)
return;
std::shared_ptr<PlayerbotLoginQueryHolder> holder = std::make_shared<PlayerbotLoginQueryHolder>(this, masterAccountId, accountId, playerGuid);
std::shared_ptr<PlayerbotLoginQueryHolder> holder =
std::make_shared<PlayerbotLoginQueryHolder>(this, masterAccountId, accountId, playerGuid);
if (!holder->Initialize())
{
return;
@@ -61,17 +65,15 @@ void PlayerbotHolder::AddPlayerBot(ObjectGuid playerGuid, uint32 masterAccountId
if (WorldSession* masterSession = sWorld->FindSession(masterAccountId))
{
masterSession->AddQueryHolderCallback(CharacterDatabase.DelayQueryHolder(holder)).AfterComplete([this](SQLQueryHolderBase const& holder)
{
HandlePlayerBotLoginCallback(static_cast<PlayerbotLoginQueryHolder const&>(holder));
});
masterSession->AddQueryHolderCallback(CharacterDatabase.DelayQueryHolder(holder))
.AfterComplete([this](SQLQueryHolderBase const& holder)
{ HandlePlayerBotLoginCallback(static_cast<PlayerbotLoginQueryHolder const&>(holder)); });
}
else
{
sWorld->AddQueryHolderCallback(CharacterDatabase.DelayQueryHolder(holder)).AfterComplete([this](SQLQueryHolderBase const& holder)
{
HandlePlayerBotLoginCallback(static_cast<PlayerbotLoginQueryHolder const&>(holder));
});
sWorld->AddQueryHolderCallback(CharacterDatabase.DelayQueryHolder(holder))
.AfterComplete([this](SQLQueryHolderBase const& holder)
{ HandlePlayerBotLoginCallback(static_cast<PlayerbotLoginQueryHolder const&>(holder)); });
}
}
@@ -79,23 +81,27 @@ void PlayerbotHolder::HandlePlayerBotLoginCallback(PlayerbotLoginQueryHolder con
{
// has bot already been added?
Player* loginBot = ObjectAccessor::FindConnectedPlayer(holder.GetGuid());
if (loginBot && loginBot->IsInWorld()) {
if (loginBot && loginBot->IsInWorld())
{
return;
}
uint32 botAccountId = holder.GetAccountId();
// At login DBC locale should be what the server is set to use by default (as spells etc are hardcoded to ENUS this allows channels to work as intended)
WorldSession* botSession = new WorldSession(botAccountId, "", nullptr, SEC_PLAYER, EXPANSION_WRATH_OF_THE_LICH_KING, time_t(0), sWorld->GetDefaultDbcLocale(), 0, false, false, 0, true);
// At login DBC locale should be what the server is set to use by default (as spells etc are hardcoded to ENUS this
// allows channels to work as intended)
WorldSession* botSession = new WorldSession(botAccountId, "", nullptr, SEC_PLAYER, EXPANSION_WRATH_OF_THE_LICH_KING,
time_t(0), sWorld->GetDefaultDbcLocale(), 0, false, false, 0, true);
botSession->HandlePlayerLoginFromDB(holder); // will delete lqh
botSession->HandlePlayerLoginFromDB(holder); // will delete lqh
Player* bot = botSession->GetPlayer();
if (!bot)
{
botSession->LogoutPlayer(true);
delete botSession;
// LOG_ERROR("playerbots", "Error logging in bot {}, please try to reset all random bots", holder.GetGuid().ToString().c_str());
// LOG_ERROR("playerbots", "Error logging in bot {}, please try to reset all random bots",
// holder.GetGuid().ToString().c_str());
return;
}
@@ -103,25 +109,37 @@ void PlayerbotHolder::HandlePlayerBotLoginCallback(PlayerbotLoginQueryHolder con
WorldSession* masterSession = masterAccount ? sWorld->FindSession(masterAccount) : nullptr;
std::ostringstream out;
bool allowed = false;
if (botAccountId == masterAccount) {
if (botAccountId == masterAccount)
{
allowed = true;
} else if (masterSession && sPlayerbotAIConfig->allowGuildBots && bot->GetGuildId() != 0 && bot->GetGuildId() == masterSession->GetPlayer()->GetGuildId()) {
}
else if (masterSession && sPlayerbotAIConfig->allowGuildBots && bot->GetGuildId() != 0 &&
bot->GetGuildId() == masterSession->GetPlayer()->GetGuildId())
{
allowed = true;
} else if (sPlayerbotAIConfig->IsInRandomAccountList(botAccountId)) {
}
else if (sPlayerbotAIConfig->IsInRandomAccountList(botAccountId))
{
allowed = true;
} else {
}
else
{
allowed = false;
out << "Failure: You are not allowed to control bot " << bot->GetName().c_str();
}
if (allowed && masterSession) {
if (allowed && masterSession)
{
Player* player = masterSession->GetPlayer();
PlayerbotMgr *mgr = GET_PLAYERBOT_MGR(player);
PlayerbotMgr* mgr = GET_PLAYERBOT_MGR(player);
uint32 count = mgr->GetPlayerbotsCount();
uint32 cls_count = mgr->GetPlayerbotsCountByClass(bot->getClass());
if (count >= sPlayerbotAIConfig->maxAddedBots) {
if (count >= sPlayerbotAIConfig->maxAddedBots)
{
allowed = false;
out << "Failure: You have added too many bots";
} else if (cls_count >= sPlayerbotAIConfig->maxAddedBotsPerClass) {
}
else if (cls_count >= sPlayerbotAIConfig->maxAddedBotsPerClass)
{
allowed = false;
out << "Failure: You have added too many bots for this class";
}
@@ -143,7 +161,8 @@ void PlayerbotHolder::HandlePlayerBotLoginCallback(PlayerbotLoginQueryHolder con
// OnBotLogin(bot);
// LogoutPlayerBot(bot->GetGUID());
// LOG_ERROR("playerbots", "Attempt to add not allowed bot {}, please try to reset all random bots", bot->GetName());
// LOG_ERROR("playerbots", "Attempt to add not allowed bot {}, please try to reset all random bots",
// bot->GetName());
}
}
@@ -155,7 +174,8 @@ void PlayerbotHolder::UpdateSessions()
if (bot->IsBeingTeleported())
{
PlayerbotAI* botAI = GET_PLAYERBOT_AI(bot);
if (botAI) {
if (botAI)
{
botAI->HandleTeleportAck();
}
}
@@ -229,7 +249,8 @@ void PlayerbotMgr::CancelLogout()
}
}
for (PlayerBotMap::const_iterator it = sRandomPlayerbotMgr->GetPlayerBotsBegin(); it != sRandomPlayerbotMgr->GetPlayerBotsEnd(); ++it)
for (PlayerBotMap::const_iterator it = sRandomPlayerbotMgr->GetPlayerBotsBegin();
it != sRandomPlayerbotMgr->GetPlayerBotsEnd(); ++it)
{
Player* const bot = it->second;
PlayerbotAI* botAI = GET_PLAYERBOT_AI(bot);
@@ -289,14 +310,16 @@ void PlayerbotHolder::LogoutPlayerBot(ObjectGuid guid)
logout = true;
}
if (master && (master->HasFlag(PLAYER_FLAGS, PLAYER_FLAGS_RESTING) || master->HasUnitState(UNIT_STATE_IN_FLIGHT) ||
(masterWorldSessionPtr && masterWorldSessionPtr->GetSecurity() >= (AccountTypes)sWorld->getIntConfig(CONFIG_INSTANT_LOGOUT))))
if (master &&
(master->HasFlag(PLAYER_FLAGS, PLAYER_FLAGS_RESTING) || master->HasUnitState(UNIT_STATE_IN_FLIGHT) ||
(masterWorldSessionPtr &&
masterWorldSessionPtr->GetSecurity() >= (AccountTypes)sWorld->getIntConfig(CONFIG_INSTANT_LOGOUT))))
{
logout = true;
}
TravelTarget* target = nullptr;
if (botAI->GetAiObjectContext()) //Maybe some day re-write to delate all pointer values.
if (botAI->GetAiObjectContext()) // Maybe some day re-write to delate all pointer values.
{
target = botAI->GetAiObjectContext()->GetValue<TravelTarget*>("travel target")->Get();
}
@@ -325,19 +348,19 @@ void PlayerbotHolder::LogoutPlayerBot(ObjectGuid guid)
}
else
{
playerBots.erase(guid); // deletes bot player ptr inside this WorldSession PlayerBotMap
playerBots.erase(guid); // deletes bot player ptr inside this WorldSession PlayerBotMap
delete botWorldSessionPtr; // finally delete the bot's WorldSession
if (target)
delete target;
}
return;
} // if instant logout possible, do it
} // if instant logout possible, do it
else if (bot && (logout || !botWorldSessionPtr->isLogingOut()))
{
botAI->TellMaster("Goodbye!");
playerBots.erase(guid); // deletes bot player ptr inside this WorldSession PlayerBotMap
botWorldSessionPtr->LogoutPlayer(true); // this will delete the bot Player object and PlayerbotAI object
delete botWorldSessionPtr; // finally delete the bot's WorldSession
playerBots.erase(guid); // deletes bot player ptr inside this WorldSession PlayerBotMap
botWorldSessionPtr->LogoutPlayer(true); // this will delete the bot Player object and PlayerbotAI object
delete botWorldSessionPtr; // finally delete the bot's WorldSession
}
}
}
@@ -347,7 +370,8 @@ void PlayerbotHolder::DisablePlayerBot(ObjectGuid guid)
if (Player* bot = GetPlayerBot(guid))
{
PlayerbotAI* botAI = GET_PLAYERBOT_AI(bot);
if (!botAI) {
if (!botAI)
{
return;
}
botAI->TellMaster("Goodbye!");
@@ -364,14 +388,14 @@ void PlayerbotHolder::DisablePlayerBot(ObjectGuid guid)
bot->SaveToDB(false, false);
if (botAI->GetAiObjectContext()) //Maybe some day re-write to delate all pointer values.
if (botAI->GetAiObjectContext()) // Maybe some day re-write to delate all pointer values.
{
TravelTarget* target = botAI->GetAiObjectContext()->GetValue<TravelTarget*>("travel target")->Get();
if (target)
delete target;
}
playerBots.erase(guid); // deletes bot player ptr inside this WorldSession PlayerBotMap
playerBots.erase(guid); // deletes bot player ptr inside this WorldSession PlayerBotMap
delete botAI;
}
@@ -393,7 +417,8 @@ Player* PlayerbotHolder::GetPlayerBot(ObjectGuid::LowType lowGuid) const
void PlayerbotHolder::OnBotLogin(Player* const bot)
{
// Prevent duplicate login
if (playerBots.find(bot->GetGUID()) != playerBots.end()) {
if (playerBots.find(bot->GetGUID()) != playerBots.end())
{
return;
}
@@ -401,16 +426,16 @@ void PlayerbotHolder::OnBotLogin(Player* const bot)
playerBots[bot->GetGUID()] = bot;
OnBotLoginInternal(bot);
PlayerbotAI* botAI = GET_PLAYERBOT_AI(bot);
if (!botAI) {
if (!botAI)
{
return;
}
Player* master = botAI->GetMaster();
if (master)
{
ObjectGuid masterGuid = master->GetGUID();
if (master->GetGroup() && ! master->GetGroup()->IsLeader(masterGuid))
if (master->GetGroup() && !master->GetGroup()->IsLeader(masterGuid))
master->GetGroup()->ChangeLeader(masterGuid);
}
@@ -475,19 +500,27 @@ void PlayerbotHolder::OnBotLogin(Player* const bot)
botAI->TellMaster("Hello!", PLAYERBOT_SECURITY_TALK);
if (master && master->GetGroup() && !group) {
if (master && master->GetGroup() && !group)
{
Group* mgroup = master->GetGroup();
if (mgroup->GetMembersCount() >= 5) {
if (!mgroup->isRaidGroup() && !mgroup->isLFGGroup() && !mgroup->isBGGroup() && !mgroup->isBFGroup()) {
if (mgroup->GetMembersCount() >= 5)
{
if (!mgroup->isRaidGroup() && !mgroup->isLFGGroup() && !mgroup->isBGGroup() && !mgroup->isBFGroup())
{
mgroup->ConvertToRaid();
}
if (mgroup->isRaidGroup()) {
if (mgroup->isRaidGroup())
{
mgroup->AddMember(bot);
}
} else {
}
else
{
mgroup->AddMember(bot);
}
} else if (master && !group) {
}
else if (master && !group)
{
Group* newGroup = new Group();
newGroup->Create(master);
sGroupMgr->AddGroup(newGroup);
@@ -497,30 +530,36 @@ void PlayerbotHolder::OnBotLogin(Player* const bot)
uint32 accountId = bot->GetSession()->GetAccountId();
bool isRandomAccount = sPlayerbotAIConfig->IsInRandomAccountList(accountId);
if (isRandomAccount && sPlayerbotAIConfig->randomBotFixedLevel) {
if (isRandomAccount && sPlayerbotAIConfig->randomBotFixedLevel)
{
bot->SetPlayerFlag(PLAYER_FLAGS_NO_XP_GAIN);
} else if (isRandomAccount && !sPlayerbotAIConfig->randomBotFixedLevel) {
}
else if (isRandomAccount && !sPlayerbotAIConfig->randomBotFixedLevel)
{
bot->RemovePlayerFlag(PLAYER_FLAGS_NO_XP_GAIN);
}
bot->SaveToDB(false, false);
if (master && isRandomAccount && master->GetLevel() < bot->GetLevel()) {
if (master && isRandomAccount && master->GetLevel() < bot->GetLevel())
{
// PlayerbotFactory factory(bot, master->GetLevel());
// factory.Randomize(false);
uint32 mixedGearScore = PlayerbotAI::GetMixedGearScore(master, true, false, 12) * sPlayerbotAIConfig->autoInitEquipLevelLimitRatio;
uint32 mixedGearScore =
PlayerbotAI::GetMixedGearScore(master, true, false, 12) * sPlayerbotAIConfig->autoInitEquipLevelLimitRatio;
PlayerbotFactory factory(bot, master->GetLevel(), ITEM_QUALITY_LEGENDARY, mixedGearScore);
factory.Randomize(false);
}
// bots join World chat if not solo oriented
if (bot->GetLevel() >= 10 && sRandomPlayerbotMgr->IsRandomBot(bot) && GET_PLAYERBOT_AI(bot) && GET_PLAYERBOT_AI(bot)->GetGrouperType() != GrouperType::SOLO)
if (bot->GetLevel() >= 10 && sRandomPlayerbotMgr->IsRandomBot(bot) && GET_PLAYERBOT_AI(bot) &&
GET_PLAYERBOT_AI(bot)->GetGrouperType() != GrouperType::SOLO)
{
// TODO make action/config
// Make the bot join the world channel for chat
WorldPacket pkt(CMSG_JOIN_CHANNEL);
pkt << uint32(0) << uint8(0) << uint8(0);
pkt << std::string("World");
pkt << ""; // Pass
pkt << ""; // Pass
bot->GetSession()->HandleJoinChannel(pkt);
}
// join standard channels
@@ -533,7 +572,8 @@ void PlayerbotHolder::OnBotLogin(Player* const bot)
for (uint32 i = 0; i < sChatChannelsStore.GetNumRows(); ++i)
{
ChatChannelsEntry const* channel = sChatChannelsStore.LookupEntry(i);
if (!channel) continue;
if (!channel)
continue;
bool isLfg = (channel->flags & CHANNEL_DBC_FLAG_LFG) != 0;
@@ -551,7 +591,8 @@ void PlayerbotHolder::OnBotLogin(Player* const bot)
else
{
char new_channel_name_buf[100];
snprintf(new_channel_name_buf, 100, channel->pattern[sWorld->GetDefaultDbcLocale()], current_zone_name.c_str());
snprintf(new_channel_name_buf, 100, channel->pattern[sWorld->GetDefaultDbcLocale()],
current_zone_name.c_str());
new_channel = cMgr->GetJoinChannel(new_channel_name_buf, channel->ChannelID);
}
if (new_channel && new_channel->GetName().length() > 0)
@@ -560,7 +601,8 @@ void PlayerbotHolder::OnBotLogin(Player* const bot)
}
}
std::string const PlayerbotHolder::ProcessBotCommand(std::string const cmd, ObjectGuid guid, ObjectGuid masterguid, bool admin, uint32 masterAccountId, uint32 masterGuildId)
std::string const PlayerbotHolder::ProcessBotCommand(std::string const cmd, ObjectGuid guid, ObjectGuid masterguid,
bool admin, uint32 masterAccountId, uint32 masterGuildId)
{
if (!sPlayerbotAIConfig->enabled || guid.IsEmpty())
return "bot system is disabled";
@@ -573,7 +615,8 @@ std::string const PlayerbotHolder::ProcessBotCommand(std::string const cmd, Obje
if (!isRandomAccount && !isMasterAccount && !admin && masterguid)
{
Player* master = ObjectAccessor::FindConnectedPlayer(masterguid);
if (master && (!sPlayerbotAIConfig->allowGuildBots || !masterGuildId || (masterGuildId && sCharacterCache->GetCharacterGuildIdByGuid(guid) != masterGuildId)))
if (master && (!sPlayerbotAIConfig->allowGuildBots || !masterGuildId ||
(masterGuildId && sCharacterCache->GetCharacterGuildIdByGuid(guid) != masterGuildId)))
return "not in your guild or account";
}
@@ -609,21 +652,27 @@ std::string const PlayerbotHolder::ProcessBotCommand(std::string const cmd, Obje
if (!bot)
return "bot not found";
if (!isRandomAccount || isRandomBot) {
if (!isRandomAccount || isRandomBot)
{
return "ERROR: You can not use this command on non-summoned random bot.";
}
if (!admin) {
if (!admin)
{
Player* master = ObjectAccessor::FindConnectedPlayer(masterguid);
if (master && (master->IsInCombat() || bot->IsInCombat())) {
if (master && (master->IsInCombat() || bot->IsInCombat()))
{
return "ERROR: You can not use this command during combat.";
}
}
if (GET_PLAYERBOT_AI(bot)) {
if (GET_PLAYERBOT_AI(bot))
{
if (Player* master = GET_PLAYERBOT_AI(bot)->GetMaster())
{
if (master->GetSession()->GetSecurity() <= SEC_PLAYER && sPlayerbotAIConfig->autoInitOnly && cmd != "init=auto") {
if (master->GetSession()->GetSecurity() <= SEC_PLAYER && sPlayerbotAIConfig->autoInitOnly &&
cmd != "init=auto")
{
return "The command is not allowed, use init=auto instead.";
}
int gs;
@@ -659,10 +708,12 @@ std::string const PlayerbotHolder::ProcessBotCommand(std::string const cmd, Obje
}
else if (cmd == "init=auto")
{
uint32 mixedGearScore = PlayerbotAI::GetMixedGearScore(master, true, false, 12) * sPlayerbotAIConfig->autoInitEquipLevelLimitRatio;
uint32 mixedGearScore = PlayerbotAI::GetMixedGearScore(master, true, false, 12) *
sPlayerbotAIConfig->autoInitEquipLevelLimitRatio;
PlayerbotFactory factory(bot, master->GetLevel(), ITEM_QUALITY_LEGENDARY, mixedGearScore);
factory.Randomize(false);
return "ok, gear score limit: " + std::to_string(mixedGearScore / (ITEM_QUALITY_EPIC + 1)) + "(for epic)";
return "ok, gear score limit: " + std::to_string(mixedGearScore / (ITEM_QUALITY_EPIC + 1)) +
"(for epic)";
}
else if (cmd.starts_with("init=") && sscanf(cmd.c_str(), "init=%d", &gs) != -1)
{
@@ -673,7 +724,7 @@ std::string const PlayerbotHolder::ProcessBotCommand(std::string const cmd, Obje
}
if (cmd == "refresh=raid")
{ // TODO: This function is not perfect yet. If you are already in a raid,
{ // TODO: This function is not perfect yet. If you are already in a raid,
// after the command is executed, the AI ​​needs to go back online or exit the raid and re-enter.
PlayerbotFactory factory(bot, bot->GetLevel());
factory.UnbindInstance();
@@ -698,7 +749,8 @@ std::string const PlayerbotHolder::ProcessBotCommand(std::string const cmd, Obje
sRandomPlayerbotMgr->Randomize(bot);
return "ok";
}
else if (cmd == "quests"){
else if (cmd == "quests")
{
PlayerbotFactory factory(bot, bot->GetLevel());
factory.InitInstanceQuests();
return "Initialization quests";
@@ -754,61 +806,78 @@ std::vector<std::string> PlayerbotHolder::HandlePlayerbotCommand(char const* arg
return messages;
}
char* cmd = strtok ((char*)args, " ");
char* charname = strtok (nullptr, " ");
char* cmd = strtok((char*)args, " ");
char* charname = strtok(nullptr, " ");
if (!cmd)
{
messages.push_back("usage: list/reload/tweak/self or add/init/remove PLAYERNAME or addclass CLASSNAME");
return messages;
}
if (!strcmp(cmd, "initself")) {
if (master->GetSession()->GetSecurity() >= SEC_GAMEMASTER) {
if (!strcmp(cmd, "initself"))
{
if (master->GetSession()->GetSecurity() >= SEC_GAMEMASTER)
{
// OnBotLogin(master);
PlayerbotFactory factory(master, master->GetLevel(), ITEM_QUALITY_EPIC);
factory.Randomize(false);
messages.push_back("initself ok");
return messages;
} else {
}
else
{
messages.push_back("ERROR: Only GM can use this command.");
return messages;
}
}
if (!strncmp(cmd, "initself=", 9)) {
if (!strcmp(cmd, "initself=rare")) {
if (master->GetSession()->GetSecurity() >= SEC_GAMEMASTER) {
if (!strncmp(cmd, "initself=", 9))
{
if (!strcmp(cmd, "initself=rare"))
{
if (master->GetSession()->GetSecurity() >= SEC_GAMEMASTER)
{
// OnBotLogin(master);
PlayerbotFactory factory(master, master->GetLevel(), ITEM_QUALITY_RARE);
factory.Randomize(false);
messages.push_back("initself ok");
return messages;
} else {
}
else
{
messages.push_back("ERROR: Only GM can use this command.");
return messages;
}
}
if (!strcmp(cmd, "initself=epic")) {
if (master->GetSession()->GetSecurity() >= SEC_GAMEMASTER) {
if (!strcmp(cmd, "initself=epic"))
{
if (master->GetSession()->GetSecurity() >= SEC_GAMEMASTER)
{
// OnBotLogin(master);
PlayerbotFactory factory(master, master->GetLevel(), ITEM_QUALITY_EPIC);
factory.Randomize(false);
messages.push_back("initself ok");
return messages;
} else {
}
else
{
messages.push_back("ERROR: Only GM can use this command.");
return messages;
}
}
int32 gs;
if (sscanf(cmd, "initself=%d", &gs) != -1) {
if (master->GetSession()->GetSecurity() >= SEC_GAMEMASTER) {
if (sscanf(cmd, "initself=%d", &gs) != -1)
{
if (master->GetSession()->GetSecurity() >= SEC_GAMEMASTER)
{
// OnBotLogin(master);
PlayerbotFactory factory(master, master->GetLevel(), ITEM_QUALITY_LEGENDARY, gs);
factory.Randomize(false);
messages.push_back("initself ok, gs = " + std::to_string(gs));
return messages;
} else {
}
else
{
messages.push_back("ERROR: Only GM can use this command.");
return messages;
}
@@ -867,12 +936,15 @@ std::vector<std::string> PlayerbotHolder::HandlePlayerbotCommand(char const* arg
if (!strcmp(cmd, "addclass"))
{
if (sPlayerbotAIConfig->addClassCommand == 0 && master->GetSession()->GetSecurity() < SEC_GAMEMASTER) {
if (sPlayerbotAIConfig->addClassCommand == 0 && master->GetSession()->GetSecurity() < SEC_GAMEMASTER)
{
messages.push_back("You do not have permission to create bot by addclass command");
return messages;
}
if (!charname) {
messages.push_back("addclass: invalid CLASSNAME(warrior/paladin/hunter/rogue/priest/shaman/mage/warlock/druid/dk)");
if (!charname)
{
messages.push_back(
"addclass: invalid CLASSNAME(warrior/paladin/hunter/rogue/priest/shaman/mage/warlock/druid/dk)");
return messages;
}
uint8 claz;
@@ -942,10 +1014,13 @@ std::vector<std::string> PlayerbotHolder::HandlePlayerbotCommand(char const* arg
}
uint32 maxAccountId = sPlayerbotAIConfig->randomBotAccounts.back();
// find a bot fit conditions and not in any guild
QueryResult results = CharacterDatabase.Query("SELECT guid FROM characters "
"WHERE name IN (SELECT name FROM playerbots_names) AND class = '{}' AND online = 0 AND race IN ({}) AND guid NOT IN ( SELECT guid FROM guild_member ) "
QueryResult results = CharacterDatabase.Query(
"SELECT guid FROM characters "
"WHERE name IN (SELECT name FROM playerbots_names) AND class = '{}' AND online = 0 AND race IN ({}) AND "
"guid NOT IN ( SELECT guid FROM guild_member ) "
"AND account <= {} "
"ORDER BY account DESC LIMIT 1", claz, race_limit, maxAccountId);
"ORDER BY account DESC LIMIT 1",
claz, race_limit, maxAccountId);
if (results)
{
Field* fields = results->Fetch();
@@ -966,13 +1041,18 @@ std::vector<std::string> PlayerbotHolder::HandlePlayerbotCommand(char const* arg
std::string name;
bool isPlayer = sCharacterCache->GetCharacterNameByGuid(master->GetTarget(), name);
// Player* tPlayer = ObjectAccessor::FindConnectedPlayer(master->GetTarget());
if (isPlayer) {
if (isPlayer)
{
charnameStr = name;
} else {
}
else
{
messages.push_back("usage: list/reload/tweak/self or add/init/remove PLAYERNAME");
return messages;
}
} else {
}
else
{
charnameStr = charname;
}
@@ -1050,7 +1130,9 @@ std::vector<std::string> PlayerbotHolder::HandlePlayerbotCommand(char const* arg
}
else if (master && member != master->GetGUID())
{
out << ProcessBotCommand(cmdStr, member, master->GetGUID(), master->GetSession()->GetSecurity() >= SEC_GAMEMASTER, master->GetSession()->GetAccountId(), master->GetGuildId());
out << ProcessBotCommand(cmdStr, member, master->GetGUID(),
master->GetSession()->GetSecurity() >= SEC_GAMEMASTER,
master->GetSession()->GetAccountId(), master->GetGuildId());
}
else if (!master)
{
@@ -1063,10 +1145,7 @@ std::vector<std::string> PlayerbotHolder::HandlePlayerbotCommand(char const* arg
return messages;
}
uint32 PlayerbotHolder::GetAccountId(std::string const name)
{
return AccountMgr::GetId(name);
}
uint32 PlayerbotHolder::GetAccountId(std::string const name) { return AccountMgr::GetId(name); }
uint32 PlayerbotHolder::GetAccountId(ObjectGuid guid)
{
@@ -1122,7 +1201,8 @@ std::string const PlayerbotHolder::ListBots(Player* master)
if (master)
{
QueryResult results = CharacterDatabase.Query("SELECT class, name FROM characters WHERE account = {}", master->GetSession()->GetAccountId());
QueryResult results = CharacterDatabase.Query("SELECT class, name FROM characters WHERE account = {}",
master->GetSession()->GetAccountId());
if (results)
{
do
@@ -1147,7 +1227,7 @@ std::string const PlayerbotHolder::ListBots(Player* master)
Group::MemberSlotList const& groupSlot = group->GetMemberSlots();
for (Group::member_citerator itr = groupSlot.begin(); itr != groupSlot.end(); itr++)
{
Player *member = ObjectAccessor::FindPlayer(itr->guid);
Player* member = ObjectAccessor::FindPlayer(itr->guid);
if (member && sRandomPlayerbotMgr->IsRandomBot(member))
{
std::string const name = member->GetName();
@@ -1192,7 +1272,8 @@ std::string const PlayerbotHolder::LookupBots(Player* master)
messages.push_back("DK");
messages.push_back("(Usage: .bot lookup CLASS)");
std::string ret_msg;
for (std::string msg: messages) {
for (std::string msg : messages)
{
ret_msg += msg + "\n";
}
return ret_msg;
@@ -1204,16 +1285,15 @@ uint32 PlayerbotHolder::GetPlayerbotsCountByClass(uint32 cls)
for (PlayerBotMap::const_iterator it = GetPlayerBotsBegin(); it != GetPlayerBotsEnd(); ++it)
{
Player* const bot = it->second;
if (bot->getClass() == cls) {
if (bot->getClass() == cls)
{
count++;
}
}
return count;
}
PlayerbotMgr::PlayerbotMgr(Player* const master) : PlayerbotHolder(), master(master), lastErrorTell(0)
{
}
PlayerbotMgr::PlayerbotMgr(Player* const master) : PlayerbotHolder(), master(master), lastErrorTell(0) {}
PlayerbotMgr::~PlayerbotMgr()
{
@@ -1253,7 +1333,8 @@ void PlayerbotMgr::HandleCommand(uint32 type, std::string const text)
botAI->HandleCommand(type, text, master);
}
for (PlayerBotMap::const_iterator it = sRandomPlayerbotMgr->GetPlayerBotsBegin(); it != sRandomPlayerbotMgr->GetPlayerBotsEnd(); ++it)
for (PlayerBotMap::const_iterator it = sRandomPlayerbotMgr->GetPlayerBotsBegin();
it != sRandomPlayerbotMgr->GetPlayerBotsEnd(); ++it)
{
Player* const bot = it->second;
PlayerbotAI* botAI = GET_PLAYERBOT_AI(bot);
@@ -1274,7 +1355,8 @@ void PlayerbotMgr::HandleMasterIncomingPacket(WorldPacket const& packet)
botAI->HandleMasterIncomingPacket(packet);
}
for (PlayerBotMap::const_iterator it = sRandomPlayerbotMgr->GetPlayerBotsBegin(); it != sRandomPlayerbotMgr->GetPlayerBotsEnd(); ++it)
for (PlayerBotMap::const_iterator it = sRandomPlayerbotMgr->GetPlayerBotsBegin();
it != sRandomPlayerbotMgr->GetPlayerBotsEnd(); ++it)
{
Player* const bot = it->second;
PlayerbotAI* botAI = GET_PLAYERBOT_AI(bot);
@@ -1309,7 +1391,8 @@ void PlayerbotMgr::HandleMasterOutgoingPacket(WorldPacket const& packet)
botAI->HandleMasterOutgoingPacket(packet);
}
for (PlayerBotMap::const_iterator it = sRandomPlayerbotMgr->GetPlayerBotsBegin(); it != sRandomPlayerbotMgr->GetPlayerBotsEnd(); ++it)
for (PlayerBotMap::const_iterator it = sRandomPlayerbotMgr->GetPlayerBotsBegin();
it != sRandomPlayerbotMgr->GetPlayerBotsEnd(); ++it)
{
Player* const bot = it->second;
PlayerbotAI* botAI = GET_PLAYERBOT_AI(bot);
@@ -1326,7 +1409,8 @@ void PlayerbotMgr::SaveToDB()
bot->SaveToDB(false, false);
}
for (PlayerBotMap::const_iterator it = sRandomPlayerbotMgr->GetPlayerBotsBegin(); it != sRandomPlayerbotMgr->GetPlayerBotsEnd(); ++it)
for (PlayerBotMap::const_iterator it = sRandomPlayerbotMgr->GetPlayerBotsBegin();
it != sRandomPlayerbotMgr->GetPlayerBotsEnd(); ++it)
{
Player* const bot = it->second;
if (GET_PLAYERBOT_AI(bot) && GET_PLAYERBOT_AI(bot)->GetMaster() == GetMaster())
@@ -1334,10 +1418,11 @@ void PlayerbotMgr::SaveToDB()
}
}
void PlayerbotMgr::OnBotLoginInternal(Player * const bot)
void PlayerbotMgr::OnBotLoginInternal(Player* const bot)
{
PlayerbotAI* botAI = GET_PLAYERBOT_AI(bot);
if (!botAI) {
if (!botAI)
{
return;
}
botAI->SetMaster(master);
@@ -1431,7 +1516,7 @@ void PlayerbotsMgr::AddPlayerbotData(Player* player, bool isBotAI)
return;
}
// If the guid already exists in the map, remove it
if (!isBotAI)
{
std::unordered_map<ObjectGuid, PlayerbotAIBase*>::iterator itr = _playerbotsMgrMap.find(player->GetGUID());
@@ -1458,13 +1543,16 @@ void PlayerbotsMgr::AddPlayerbotData(Player* player, bool isBotAI)
void PlayerbotsMgr::RemovePlayerBotData(ObjectGuid const& guid, bool is_AI)
{
if (is_AI) {
if (is_AI)
{
std::unordered_map<ObjectGuid, PlayerbotAIBase*>::iterator itr = _playerbotsAIMap.find(guid);
if (itr != _playerbotsAIMap.end())
{
_playerbotsAIMap.erase(itr);
}
} else {
}
else
{
std::unordered_map<ObjectGuid, PlayerbotAIBase*>::iterator itr = _playerbotsMgrMap.find(guid);
if (itr != _playerbotsMgrMap.end())
{

133
src/PlayerbotMgr.h
View File

@@ -1,15 +1,16 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#ifndef _PLAYERBOT_PLAYERBOTMGR_H
#define _PLAYERBOT_PLAYERBOTMGR_H
#include "Common.h"
#include "QueryHolder.h"
#include "QueryResult.h"
#include "Player.h"
#include "PlayerbotAIBase.h"
#include "QueryHolder.h"
#include "QueryResult.h"
class ChatHandler;
class PlayerbotAI;
@@ -21,92 +22,94 @@ typedef std::map<std::string, std::set<std::string> > PlayerBotErrorMap;
class PlayerbotHolder : public PlayerbotAIBase
{
public:
PlayerbotHolder();
virtual ~PlayerbotHolder() { };
public:
PlayerbotHolder();
virtual ~PlayerbotHolder(){};
void AddPlayerBot(ObjectGuid guid, uint32 masterAccountId);
void HandlePlayerBotLoginCallback(PlayerbotLoginQueryHolder const& holder);
void AddPlayerBot(ObjectGuid guid, uint32 masterAccountId);
void HandlePlayerBotLoginCallback(PlayerbotLoginQueryHolder const& holder);
void LogoutPlayerBot(ObjectGuid guid);
void DisablePlayerBot(ObjectGuid guid);
Player* GetPlayerBot(ObjectGuid guid) const;
Player* GetPlayerBot(ObjectGuid::LowType lowGuid) const;
PlayerBotMap::const_iterator GetPlayerBotsBegin() const { return playerBots.begin(); }
PlayerBotMap::const_iterator GetPlayerBotsEnd() const { return playerBots.end(); }
void LogoutPlayerBot(ObjectGuid guid);
void DisablePlayerBot(ObjectGuid guid);
Player* GetPlayerBot(ObjectGuid guid) const;
Player* GetPlayerBot(ObjectGuid::LowType lowGuid) const;
PlayerBotMap::const_iterator GetPlayerBotsBegin() const { return playerBots.begin(); }
PlayerBotMap::const_iterator GetPlayerBotsEnd() const { return playerBots.end(); }
void UpdateAIInternal([[maybe_unused]] uint32 elapsed, [[maybe_unused]] bool minimal = false) override { };
void UpdateSessions();
void HandleBotPackets(WorldSession* session);
void UpdateAIInternal([[maybe_unused]] uint32 elapsed, [[maybe_unused]] bool minimal = false) override{};
void UpdateSessions();
void HandleBotPackets(WorldSession* session);
void LogoutAllBots();
void OnBotLogin(Player* const bot);
void LogoutAllBots();
void OnBotLogin(Player* const bot);
std::vector<std::string> HandlePlayerbotCommand(char const* args, Player* master = nullptr);
std::string const ProcessBotCommand(std::string const cmd, ObjectGuid guid, ObjectGuid masterguid, bool admin, uint32 masterAccountId, uint32 masterGuildId);
uint32 GetAccountId(std::string const name);
uint32 GetAccountId(ObjectGuid guid);
std::string const ListBots(Player* master);
std::string const LookupBots(Player* master);
uint32 GetPlayerbotsCount() { return playerBots.size(); }
uint32 GetPlayerbotsCountByClass(uint32 cls);
protected:
virtual void OnBotLoginInternal(Player* const bot) = 0;
std::vector<std::string> HandlePlayerbotCommand(char const* args, Player* master = nullptr);
std::string const ProcessBotCommand(std::string const cmd, ObjectGuid guid, ObjectGuid masterguid, bool admin,
uint32 masterAccountId, uint32 masterGuildId);
uint32 GetAccountId(std::string const name);
uint32 GetAccountId(ObjectGuid guid);
std::string const ListBots(Player* master);
std::string const LookupBots(Player* master);
uint32 GetPlayerbotsCount() { return playerBots.size(); }
uint32 GetPlayerbotsCountByClass(uint32 cls);
PlayerBotMap playerBots;
protected:
virtual void OnBotLoginInternal(Player* const bot) = 0;
PlayerBotMap playerBots;
};
class PlayerbotMgr : public PlayerbotHolder
{
public:
PlayerbotMgr(Player* const master);
virtual ~PlayerbotMgr();
public:
PlayerbotMgr(Player* const master);
virtual ~PlayerbotMgr();
static bool HandlePlayerbotMgrCommand(ChatHandler* handler, char const* args);
void HandleMasterIncomingPacket(WorldPacket const& packet);
void HandleMasterOutgoingPacket(WorldPacket const& packet);
void HandleCommand(uint32 type, std::string const text);
void OnPlayerLogin(Player* player);
void CancelLogout();
static bool HandlePlayerbotMgrCommand(ChatHandler* handler, char const* args);
void HandleMasterIncomingPacket(WorldPacket const& packet);
void HandleMasterOutgoingPacket(WorldPacket const& packet);
void HandleCommand(uint32 type, std::string const text);
void OnPlayerLogin(Player* player);
void CancelLogout();
void UpdateAIInternal(uint32 elapsed, bool minimal = false) override;
void TellError(std::string const botName, std::string const text);
void UpdateAIInternal(uint32 elapsed, bool minimal = false) override;
void TellError(std::string const botName, std::string const text);
Player* GetMaster() const { return master; };
Player* GetMaster() const { return master; };
void SaveToDB();
void SaveToDB();
protected:
void OnBotLoginInternal(Player* const bot) override;
void CheckTellErrors(uint32 elapsed);
protected:
void OnBotLoginInternal(Player* const bot) override;
void CheckTellErrors(uint32 elapsed);
private:
Player* const master;
PlayerBotErrorMap errors;
time_t lastErrorTell;
private:
Player* const master;
PlayerBotErrorMap errors;
time_t lastErrorTell;
};
class PlayerbotsMgr
{
public:
PlayerbotsMgr() { }
~PlayerbotsMgr() { }
public:
PlayerbotsMgr() {}
~PlayerbotsMgr() {}
static PlayerbotsMgr* instance()
{
static PlayerbotsMgr instance;
return &instance;
}
static PlayerbotsMgr* instance()
{
static PlayerbotsMgr instance;
return &instance;
}
void AddPlayerbotData(Player* player, bool isBotAI);
void RemovePlayerBotData(ObjectGuid const& guid, bool is_AI);
void AddPlayerbotData(Player* player, bool isBotAI);
void RemovePlayerBotData(ObjectGuid const& guid, bool is_AI);
PlayerbotAI* GetPlayerbotAI(Player* player);
PlayerbotMgr* GetPlayerbotMgr(Player* player);
PlayerbotAI* GetPlayerbotAI(Player* player);
PlayerbotMgr* GetPlayerbotMgr(Player* player);
private:
std::unordered_map<ObjectGuid, PlayerbotAIBase*> _playerbotsAIMap;
std::unordered_map<ObjectGuid, PlayerbotAIBase*> _playerbotsMgrMap;
private:
std::unordered_map<ObjectGuid, PlayerbotAIBase*> _playerbotsAIMap;
std::unordered_map<ObjectGuid, PlayerbotAIBase*> _playerbotsMgrMap;
};
#define sPlayerbotsMgr PlayerbotsMgr::instance()

117
src/PlayerbotSecurity.cpp
View File

@@ -1,8 +1,10 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#include "PlayerbotSecurity.h"
#include "LFGMgr.h"
#include "PlayerbotAIConfig.h"
#include "Playerbots.h"
@@ -19,7 +21,8 @@ PlayerbotSecurityLevel PlayerbotSecurity::LevelFor(Player* from, DenyReason* rea
return PLAYERBOT_SECURITY_ALLOW_ALL;
PlayerbotAI* botAI = GET_PLAYERBOT_AI(bot);
if (!botAI) {
if (!botAI)
{
return PLAYERBOT_SECURITY_DENY_ALL;
}
if (botAI->IsOpposing(from))
@@ -62,7 +65,8 @@ PlayerbotSecurityLevel PlayerbotSecurity::LevelFor(Player* from, DenyReason* rea
}
}
if (sPlayerbotAIConfig->groupInvitationPermission <= 0) {
if (sPlayerbotAIConfig->groupInvitationPermission <= 0)
{
if (reason)
*reason = PLAYERBOT_DENY_NONE;
@@ -85,9 +89,11 @@ PlayerbotSecurityLevel PlayerbotSecurity::LevelFor(Player* from, DenyReason* rea
if (sPlayerbotAIConfig->gearscorecheck)
{
if (botGS && bot->GetLevel() > 15 && botGS > fromGS &&
static_cast<float>(100 * (botGS - fromGS) / botGS) >= static_cast<float>(12 * sWorld->getIntConfig(CONFIG_MAX_PLAYER_LEVEL) / from->GetLevel()))
static_cast<float>(100 * (botGS - fromGS) / botGS) >=
static_cast<float>(12 * sWorld->getIntConfig(CONFIG_MAX_PLAYER_LEVEL) / from->GetLevel()))
{
if (reason) *reason = PLAYERBOT_DENY_GEARSCORE;
if (reason)
*reason = PLAYERBOT_DENY_GEARSCORE;
return PLAYERBOT_SECURITY_TALK;
}
}
@@ -195,37 +201,39 @@ bool PlayerbotSecurity::CheckLevelFor(PlayerbotSecurityLevel level, bool silent,
case PLAYERBOT_SECURITY_TALK:
switch (reason)
{
case PLAYERBOT_DENY_NONE:
out << "I'll do it later";
break;
case PLAYERBOT_DENY_LOW_LEVEL:
out << "You are too low level: |cffff0000" << (uint32)from->GetLevel() << "|cffffffff/|cff00ff00" << (uint32)bot->GetLevel();
break;
case PLAYERBOT_DENY_GEARSCORE:
case PLAYERBOT_DENY_NONE:
out << "I'll do it later";
break;
case PLAYERBOT_DENY_LOW_LEVEL:
out << "You are too low level: |cffff0000" << (uint32)from->GetLevel() << "|cffffffff/|cff00ff00"
<< (uint32)bot->GetLevel();
break;
case PLAYERBOT_DENY_GEARSCORE:
{
int botGS = (int)botAI->GetEquipGearScore(bot, false, false);
int fromGS = (int)botAI->GetEquipGearScore(from, false, false);
int diff = (100 * (botGS - fromGS) / botGS);
int req = 12 * sWorld->getIntConfig(CONFIG_MAX_PLAYER_LEVEL) / from->GetLevel();
out << "Your gearscore is too low: |cffff0000" << fromGS << "|cffffffff/|cff00ff00" << botGS << " |cffff0000" << diff << "%|cffffffff/|cff00ff00" << req << "%";
out << "Your gearscore is too low: |cffff0000" << fromGS << "|cffffffff/|cff00ff00" << botGS
<< " |cffff0000" << diff << "%|cffffffff/|cff00ff00" << req << "%";
}
break;
case PLAYERBOT_DENY_NOT_YOURS:
out << "I have a master already";
break;
case PLAYERBOT_DENY_IS_BOT:
out << "You are a bot";
break;
case PLAYERBOT_DENY_OPPOSING:
out << "You are the enemy";
break;
case PLAYERBOT_DENY_DEAD:
out << "I'm dead. Will do it later";
break;
case PLAYERBOT_DENY_INVITE:
out << "Invite me to your group first";
break;
case PLAYERBOT_DENY_FAR:
case PLAYERBOT_DENY_NOT_YOURS:
out << "I have a master already";
break;
case PLAYERBOT_DENY_IS_BOT:
out << "You are a bot";
break;
case PLAYERBOT_DENY_OPPOSING:
out << "You are the enemy";
break;
case PLAYERBOT_DENY_DEAD:
out << "I'm dead. Will do it later";
break;
case PLAYERBOT_DENY_INVITE:
out << "Invite me to your group first";
break;
case PLAYERBOT_DENY_FAR:
{
out << "You must be closer to invite me to your group. I am in ";
@@ -235,31 +243,32 @@ bool PlayerbotSecurity::CheckLevelFor(PlayerbotSecurityLevel level, bool silent,
}
}
break;
case PLAYERBOT_DENY_FULL_GROUP:
out << "I am in a full group. Will do it later";
break;
case PLAYERBOT_DENY_IS_LEADER:
out << "I am currently leading a group. I can invite you if you want.";
break;
case PLAYERBOT_DENY_NOT_LEADER:
if (botAI->GetGroupMaster())
{
out << "I am in a group with " << botAI->GetGroupMaster()->GetName() << ". You can ask him for invite.";
}
else
{
out << "I am in a group with someone else. You can ask him for invite.";
}
break;
case PLAYERBOT_DENY_BG:
out << "I am in a queue for BG. Will do it later";
break;
case PLAYERBOT_DENY_LFG:
out << "I am in a queue for dungeon. Will do it later";
break;
default:
out << "I can't do that";
break;
case PLAYERBOT_DENY_FULL_GROUP:
out << "I am in a full group. Will do it later";
break;
case PLAYERBOT_DENY_IS_LEADER:
out << "I am currently leading a group. I can invite you if you want.";
break;
case PLAYERBOT_DENY_NOT_LEADER:
if (botAI->GetGroupMaster())
{
out << "I am in a group with " << botAI->GetGroupMaster()->GetName()
<< ". You can ask him for invite.";
}
else
{
out << "I am in a group with someone else. You can ask him for invite.";
}
break;
case PLAYERBOT_DENY_BG:
out << "I am in a queue for BG. Will do it later";
break;
case PLAYERBOT_DENY_LFG:
out << "I am in a queue for dungeon. Will do it later";
break;
default:
out << "I can't do that";
break;
}
break;
case PLAYERBOT_SECURITY_INVITE:

31
src/PlayerbotSecurity.h
View File

@@ -1,23 +1,24 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#ifndef _PLAYERBOT_PLAYERBOTSECURITY_H
#define _PLAYERBOT_PLAYERBOTSECURITY_H
#include <map>
#include "Common.h"
#include "ObjectGuid.h"
#include <map>
class Player;
enum PlayerbotSecurityLevel : uint32
{
PLAYERBOT_SECURITY_DENY_ALL = 0,
PLAYERBOT_SECURITY_TALK = 1,
PLAYERBOT_SECURITY_INVITE = 2,
PLAYERBOT_SECURITY_ALLOW_ALL = 3
PLAYERBOT_SECURITY_DENY_ALL = 0,
PLAYERBOT_SECURITY_TALK = 1,
PLAYERBOT_SECURITY_INVITE = 2,
PLAYERBOT_SECURITY_ALLOW_ALL = 3
};
enum DenyReason
@@ -40,16 +41,16 @@ enum DenyReason
class PlayerbotSecurity
{
public:
PlayerbotSecurity(Player* const bot);
public:
PlayerbotSecurity(Player* const bot);
PlayerbotSecurityLevel LevelFor(Player* from, DenyReason* reason = nullptr, bool ignoreGroup = false);
bool CheckLevelFor(PlayerbotSecurityLevel level, bool silent, Player* from, bool ignoreGroup = false);
PlayerbotSecurityLevel LevelFor(Player* from, DenyReason* reason = nullptr, bool ignoreGroup = false);
bool CheckLevelFor(PlayerbotSecurityLevel level, bool silent, Player* from, bool ignoreGroup = false);
private:
Player* const bot;
uint32 account;
std::map<ObjectGuid, std::map<std::string, time_t> > whispers;
private:
Player* const bot;
uint32 account;
std::map<ObjectGuid, std::map<std::string, time_t> > whispers;
};
#endif

27
src/PlayerbotTextMgr.cpp
View File

@@ -1,17 +1,21 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#include "PlayerbotTextMgr.h"
#include "Playerbots.h"
void PlayerbotTextMgr::replaceAll(std::string & str, const std::string & from, const std::string & to) {
void PlayerbotTextMgr::replaceAll(std::string& str, const std::string& from, const std::string& to)
{
if (from.empty())
return;
size_t start_pos = 0;
while ((start_pos = str.find(from, start_pos)) != std::string::npos) {
while ((start_pos = str.find(from, start_pos)) != std::string::npos)
{
str.replace(start_pos, from.length(), to);
start_pos += to.length(); // In case 'to' contains 'from', like replacing 'x' with 'yx'
start_pos += to.length(); // In case 'to' contains 'from', like replacing 'x' with 'yx'
}
}
@@ -20,7 +24,8 @@ void PlayerbotTextMgr::LoadBotTexts()
LOG_INFO("playerbots", "Loading playerbots texts...");
uint32 count = 0;
if (PreparedQueryResult result = PlayerbotsDatabase.Query(PlayerbotsDatabase.GetPreparedStatement(PLAYERBOTS_SEL_TEXT)))
if (PreparedQueryResult result =
PlayerbotsDatabase.Query(PlayerbotsDatabase.GetPreparedStatement(PLAYERBOTS_SEL_TEXT)))
{
do
{
@@ -37,8 +42,7 @@ void PlayerbotTextMgr::LoadBotTexts()
botTexts[name].push_back(BotTextEntry(name, text, sayType, replyType));
++count;
}
while (result->NextRow());
} while (result->NextRow());
}
LOG_INFO("playerbots", "{} playerbots texts loaded", count);
@@ -123,14 +127,14 @@ std::string PlayerbotTextMgr::GetBotText(ChatReplyType replyType, std::map<std::
return "";
BotTextEntry textEntry = proper_list[urand(0, proper_list.size() - 1)];
std::string botText = !textEntry.m_text[GetLocalePriority()].empty() ? textEntry.m_text[GetLocalePriority()] : textEntry.m_text[0];
for (auto & placeholder : placeholders)
std::string botText =
!textEntry.m_text[GetLocalePriority()].empty() ? textEntry.m_text[GetLocalePriority()] : textEntry.m_text[0];
for (auto& placeholder : placeholders)
replaceAll(botText, placeholder.first, placeholder.second);
return botText;
}
std::string PlayerbotTextMgr::GetBotText(ChatReplyType replyType, std::string name)
{
std::map<std::string, std::string> placeholders;
@@ -149,7 +153,7 @@ bool PlayerbotTextMgr::rollTextChance(std::string name)
return urand(0, 100) < botTextChance[name];
}
bool PlayerbotTextMgr::GetBotText(std::string name, std::string &text)
bool PlayerbotTextMgr::GetBotText(std::string name, std::string& text)
{
if (!rollTextChance(name))
return false;
@@ -167,7 +171,6 @@ bool PlayerbotTextMgr::GetBotText(std::string name, std::string& text, std::map<
return !text.empty();
}
void PlayerbotTextMgr::AddLocalePriority(uint32 locale)
{
if (!locale)

75
src/PlayerbotTextMgr.h
View File

@@ -1,21 +1,25 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#ifndef _PLAYERBOT_PLAYERBOTTEXTMGR_H
#define _PLAYERBOT_PLAYERBOTTEXTMGR_H
#include "Common.h"
#include <map>
#include <vector>
#include "Common.h"
#define BOT_TEXT1(name) sPlayerbotTextMgr->GetBotText(name)
#define BOT_TEXT2(name, replace) sPlayerbotTextMgr->GetBotText(name, replace)
struct BotTextEntry
{
BotTextEntry(std::string name, std::map<uint32, std::string> text, uint32 say_type, uint32 reply_type) : m_name(name), m_text(text), m_sayType(say_type), m_replyType(reply_type) {}
BotTextEntry(std::string name, std::map<uint32, std::string> text, uint32 say_type, uint32 reply_type)
: m_name(name), m_text(text), m_sayType(say_type), m_replyType(reply_type)
{
}
std::string m_name;
std::map<uint32, std::string> m_text;
uint32 m_sayType;
@@ -31,7 +35,11 @@ struct ChatReplyData
struct ChatQueuedReply
{
ChatQueuedReply(uint32 type, uint32 guid1, uint32 guid2, std::string msg, std::string chanName, std::string name, time_t time) : m_type(type), m_guid1(guid1), m_guid2(guid2), m_msg(msg), m_chanName(chanName), m_name(name), m_time(time) {}
ChatQueuedReply(uint32 type, uint32 guid1, uint32 guid2, std::string msg, std::string chanName, std::string name,
time_t time)
: m_type(type), m_guid1(guid1), m_guid2(guid2), m_msg(msg), m_chanName(chanName), m_name(name), m_time(time)
{
}
uint32 m_type;
uint32 m_guid1;
uint32 m_guid2;
@@ -54,39 +62,40 @@ enum ChatReplyType
class PlayerbotTextMgr
{
public:
PlayerbotTextMgr() {
for (uint8 i = 0; i < MAX_LOCALES; ++i)
{
botTextLocalePriority[i] = 0;
}
};
virtual ~PlayerbotTextMgr() { };
static PlayerbotTextMgr* instance()
public:
PlayerbotTextMgr()
{
for (uint8 i = 0; i < MAX_LOCALES; ++i)
{
static PlayerbotTextMgr instance;
return &instance;
botTextLocalePriority[i] = 0;
}
};
virtual ~PlayerbotTextMgr(){};
static PlayerbotTextMgr* instance()
{
static PlayerbotTextMgr instance;
return &instance;
}
std::string GetBotText(std::string name, std::map<std::string, std::string> placeholders);
std::string GetBotText(std::string name);
std::string GetBotText(ChatReplyType replyType, std::map<std::string, std::string> placeholders);
std::string GetBotText(ChatReplyType replyType, std::string name);
bool GetBotText(std::string name, std::string& text);
bool GetBotText(std::string name, std::string& text, std::map<std::string, std::string> placeholders);
void LoadBotTexts();
void LoadBotTextChance();
static void replaceAll(std::string& str, const std::string& from, const std::string& to);
bool rollTextChance(std::string text);
std::string GetBotText(std::string name, std::map<std::string, std::string> placeholders);
std::string GetBotText(std::string name);
std::string GetBotText(ChatReplyType replyType, std::map<std::string, std::string> placeholders);
std::string GetBotText(ChatReplyType replyType, std::string name);
bool GetBotText(std::string name, std::string& text);
bool GetBotText(std::string name, std::string& text, std::map<std::string, std::string> placeholders);
void LoadBotTexts();
void LoadBotTextChance();
static void replaceAll(std::string& str, const std::string& from, const std::string& to);
bool rollTextChance(std::string text);
uint32 GetLocalePriority();
void AddLocalePriority(uint32 locale);
void ResetLocalePriority();
uint32 GetLocalePriority();
void AddLocalePriority(uint32 locale);
void ResetLocalePriority();
private:
std::map<std::string, std::vector<BotTextEntry>> botTexts;
std::map<std::string, uint32 > botTextChance;
uint32 botTextLocalePriority[MAX_LOCALES];
private:
std::map<std::string, std::vector<BotTextEntry>> botTexts;
std::map<std::string, uint32> botTextChance;
uint32 botTextLocalePriority[MAX_LOCALES];
};
#define sPlayerbotTextMgr PlayerbotTextMgr::instance()

427
src/Playerbots.cpp
View File

@@ -15,327 +15,320 @@
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "cs_playerbots.h"
#include "Playerbots.h"
#include "Channel.h"
#include "Config.h"
#include "DatabaseEnv.h"
#include "DatabaseLoader.h"
#include "GuildTaskMgr.h"
#include "Metric.h"
#include "Playerbots.h"
#include "RandomPlayerbotMgr.h"
#include "ScriptMgr.h"
#include "cs_playerbots.h"
class PlayerbotsDatabaseScript : public DatabaseScript
{
public:
PlayerbotsDatabaseScript() : DatabaseScript("PlayerbotsDatabaseScript") { }
public:
PlayerbotsDatabaseScript() : DatabaseScript("PlayerbotsDatabaseScript") {}
bool OnDatabasesLoading() override
bool OnDatabasesLoading() override
{
DatabaseLoader playerbotLoader("server.playerbots");
playerbotLoader.SetUpdateFlags(sConfigMgr->GetOption<bool>("Playerbots.Updates.EnableDatabases", true)
? DatabaseLoader::DATABASE_PLAYERBOTS
: 0);
playerbotLoader.AddDatabase(PlayerbotsDatabase, "Playerbots");
return playerbotLoader.Load();
}
void OnDatabasesKeepAlive() override { PlayerbotsDatabase.KeepAlive(); }
void OnDatabasesClosing() override { PlayerbotsDatabase.Close(); }
void OnDatabaseWarnAboutSyncQueries(bool apply) override { PlayerbotsDatabase.WarnAboutSyncQueries(apply); }
void OnDatabaseSelectIndexLogout(Player* player, uint32& statementIndex, uint32& statementParam) override
{
statementIndex = CHAR_UPD_CHAR_ONLINE;
statementParam = player->GetGUID().GetCounter();
}
void OnDatabaseGetDBRevision(std::string& revision) override
{
if (QueryResult resultPlayerbot =
PlayerbotsDatabase.Query("SELECT date FROM version_db_playerbots ORDER BY date DESC LIMIT 1"))
{
DatabaseLoader playerbotLoader("server.playerbots");
playerbotLoader.SetUpdateFlags(sConfigMgr->GetOption<bool>("Playerbots.Updates.EnableDatabases", true) ? DatabaseLoader::DATABASE_PLAYERBOTS : 0);
playerbotLoader.AddDatabase(PlayerbotsDatabase, "Playerbots");
return playerbotLoader.Load();
Field* fields = resultPlayerbot->Fetch();
revision = fields[0].Get<std::string>();
}
void OnDatabasesKeepAlive() override
if (revision.empty())
{
PlayerbotsDatabase.KeepAlive();
}
void OnDatabasesClosing() override
{
PlayerbotsDatabase.Close();
}
void OnDatabaseWarnAboutSyncQueries(bool apply) override
{
PlayerbotsDatabase.WarnAboutSyncQueries(apply);
}
void OnDatabaseSelectIndexLogout(Player* player, uint32& statementIndex, uint32& statementParam) override
{
statementIndex = CHAR_UPD_CHAR_ONLINE;
statementParam = player->GetGUID().GetCounter();
}
void OnDatabaseGetDBRevision(std::string& revision) override
{
if (QueryResult resultPlayerbot = PlayerbotsDatabase.Query("SELECT date FROM version_db_playerbots ORDER BY date DESC LIMIT 1"))
{
Field* fields = resultPlayerbot->Fetch();
revision = fields[0].Get<std::string>();
}
if (revision.empty())
{
revision = "Unknown Playerbots Database Revision";
}
revision = "Unknown Playerbots Database Revision";
}
}
};
class PlayerbotsMetricScript : public MetricScript
{
public:
PlayerbotsMetricScript() : MetricScript("PlayerbotsMetricScript") { }
public:
PlayerbotsMetricScript() : MetricScript("PlayerbotsMetricScript") {}
void OnMetricLogging() override
void OnMetricLogging() override
{
if (sMetric->IsEnabled())
{
if (sMetric->IsEnabled())
{
sMetric->LogValue("db_queue_playerbots", uint64(PlayerbotsDatabase.QueueSize()), {});
}
sMetric->LogValue("db_queue_playerbots", uint64(PlayerbotsDatabase.QueueSize()), {});
}
}
};
class PlayerbotsPlayerScript : public PlayerScript
{
public:
PlayerbotsPlayerScript() : PlayerScript("PlayerbotsPlayerScript") { }
public:
PlayerbotsPlayerScript() : PlayerScript("PlayerbotsPlayerScript") {}
void OnLogin(Player* player) override
void OnLogin(Player* player) override
{
if (!player->GetSession()->IsBot())
{
if (!player->GetSession()->IsBot())
sPlayerbotsMgr->AddPlayerbotData(player, false);
sRandomPlayerbotMgr->OnPlayerLogin(player);
}
}
void OnAfterUpdate(Player* player, uint32 diff) override
{
if (PlayerbotAI* botAI = GET_PLAYERBOT_AI(player))
{
botAI->UpdateAI(diff);
}
if (PlayerbotMgr* playerbotMgr = GET_PLAYERBOT_MGR(player))
{
playerbotMgr->UpdateAI(diff);
}
}
bool CanPlayerUseChat(Player* player, uint32 type, uint32 /*lang*/, std::string& msg, Player* receiver) override
{
if (type == CHAT_MSG_WHISPER)
{
if (PlayerbotAI* botAI = GET_PLAYERBOT_AI(receiver))
{
sPlayerbotsMgr->AddPlayerbotData(player, false);
sRandomPlayerbotMgr->OnPlayerLogin(player);
botAI->HandleCommand(type, msg, player);
return false;
}
}
void OnAfterUpdate(Player* player, uint32 diff) override
{
if (PlayerbotAI* botAI = GET_PLAYERBOT_AI(player))
{
botAI->UpdateAI(diff);
}
return true;
}
if (PlayerbotMgr* playerbotMgr = GET_PLAYERBOT_MGR(player))
{
playerbotMgr->UpdateAI(diff);
}
}
bool CanPlayerUseChat(Player* player, uint32 type, uint32 /*lang*/, std::string& msg, Player* receiver) override
void OnChat(Player* player, uint32 type, uint32 /*lang*/, std::string& msg, Group* group) override
{
for (GroupReference* itr = group->GetFirstMember(); itr != nullptr; itr = itr->next())
{
if (type == CHAT_MSG_WHISPER)
if (Player* member = itr->GetSource())
{
if (PlayerbotAI* botAI = GET_PLAYERBOT_AI(receiver))
if (PlayerbotAI* botAI = GET_PLAYERBOT_AI(member))
{
botAI->HandleCommand(type, msg, player);
return false;
}
}
return true;
}
void OnChat(Player* player, uint32 type, uint32 /*lang*/, std::string& msg, Group* group) override
{
for (GroupReference* itr = group->GetFirstMember(); itr != nullptr; itr = itr->next())
{
if (Player* member = itr->GetSource())
{
if (PlayerbotAI* botAI = GET_PLAYERBOT_AI(member))
{
botAI->HandleCommand(type, msg, player);
}
}
}
}
}
void OnChat(Player* player, uint32 type, uint32 /*lang*/, std::string& msg) override
void OnChat(Player* player, uint32 type, uint32 /*lang*/, std::string& msg) override
{
if (type == CHAT_MSG_GUILD)
{
if (type == CHAT_MSG_GUILD)
if (PlayerbotMgr* playerbotMgr = GET_PLAYERBOT_MGR(player))
{
if (PlayerbotMgr* playerbotMgr = GET_PLAYERBOT_MGR(player))
for (PlayerBotMap::const_iterator it = playerbotMgr->GetPlayerBotsBegin();
it != playerbotMgr->GetPlayerBotsEnd(); ++it)
{
for (PlayerBotMap::const_iterator it = playerbotMgr->GetPlayerBotsBegin(); it != playerbotMgr->GetPlayerBotsEnd(); ++it)
if (Player* const bot = it->second)
{
if (Player* const bot = it->second)
if (bot->GetGuildId() == player->GetGuildId())
{
if (bot->GetGuildId() == player->GetGuildId())
{
GET_PLAYERBOT_AI(bot)->HandleCommand(type, msg, player);
}
GET_PLAYERBOT_AI(bot)->HandleCommand(type, msg, player);
}
}
}
}
}
}
void OnChat(Player* player, uint32 type, uint32 /*lang*/, std::string& msg, Channel* channel) override
void OnChat(Player* player, uint32 type, uint32 /*lang*/, std::string& msg, Channel* channel) override
{
if (PlayerbotMgr* playerbotMgr = GET_PLAYERBOT_MGR(player))
{
if (PlayerbotMgr* playerbotMgr = GET_PLAYERBOT_MGR(player))
if (channel->GetFlags() & 0x18)
{
if (channel->GetFlags() & 0x18)
{
playerbotMgr->HandleCommand(type, msg);
}
playerbotMgr->HandleCommand(type, msg);
}
sRandomPlayerbotMgr->HandleCommand(type, msg, player);
}
bool OnBeforeCriteriaProgress(Player* player, AchievementCriteriaEntry const* /*criteria*/) override
{
if (sRandomPlayerbotMgr->IsRandomBot(player))
{
return false;
}
return true;
}
sRandomPlayerbotMgr->HandleCommand(type, msg, player);
}
bool OnBeforeAchiComplete(Player* player, AchievementEntry const* /*achievement*/) override
bool OnBeforeCriteriaProgress(Player* player, AchievementCriteriaEntry const* /*criteria*/) override
{
if (sRandomPlayerbotMgr->IsRandomBot(player))
{
if (sRandomPlayerbotMgr->IsRandomBot(player))
{
return false;
}
return true;
return false;
}
return true;
}
bool OnBeforeAchiComplete(Player* player, AchievementEntry const* /*achievement*/) override
{
if (sRandomPlayerbotMgr->IsRandomBot(player))
{
return false;
}
return true;
}
};
class PlayerbotsMiscScript : public MiscScript
{
public:
PlayerbotsMiscScript() : MiscScript("PlayerbotsMiscScript", {MISCHOOK_ON_DESTRUCT_PLAYER}) { }
public:
PlayerbotsMiscScript() : MiscScript("PlayerbotsMiscScript", {MISCHOOK_ON_DESTRUCT_PLAYER}) {}
void OnDestructPlayer(Player* player) override
void OnDestructPlayer(Player* player) override
{
if (PlayerbotAI* botAI = GET_PLAYERBOT_AI(player))
{
if (PlayerbotAI* botAI = GET_PLAYERBOT_AI(player))
{
delete botAI;
}
if (PlayerbotMgr* playerbotMgr = GET_PLAYERBOT_MGR(player))
{
delete playerbotMgr;
}
delete botAI;
}
if (PlayerbotMgr* playerbotMgr = GET_PLAYERBOT_MGR(player))
{
delete playerbotMgr;
}
}
};
class PlayerbotsServerScript : public ServerScript
{
public:
PlayerbotsServerScript() : ServerScript("PlayerbotsServerScript") { }
public:
PlayerbotsServerScript() : ServerScript("PlayerbotsServerScript") {}
void OnPacketReceived(WorldSession* session, WorldPacket const& packet) override
{
if (Player* player = session->GetPlayer())
if (PlayerbotMgr* playerbotMgr = GET_PLAYERBOT_MGR(player))
playerbotMgr->HandleMasterIncomingPacket(packet);
}
void OnPacketReceived(WorldSession* session, WorldPacket const& packet) override
{
if (Player* player = session->GetPlayer())
if (PlayerbotMgr* playerbotMgr = GET_PLAYERBOT_MGR(player))
playerbotMgr->HandleMasterIncomingPacket(packet);
}
};
class PlayerbotsWorldScript : public WorldScript
{
public:
PlayerbotsWorldScript() : WorldScript("PlayerbotsWorldScript") { }
public:
PlayerbotsWorldScript() : WorldScript("PlayerbotsWorldScript") {}
void OnBeforeWorldInitialized() override
{
uint32 oldMSTime = getMSTime();
void OnBeforeWorldInitialized() override
{
uint32 oldMSTime = getMSTime();
LOG_INFO("server.loading", " ");
LOG_INFO("server.loading", "Load Playerbots Config...");
LOG_INFO("server.loading", " ");
LOG_INFO("server.loading", "Load Playerbots Config...");
sPlayerbotAIConfig->Initialize();
sPlayerbotAIConfig->Initialize();
LOG_INFO("server.loading", ">> Loaded playerbots config in {} ms", GetMSTimeDiffToNow(oldMSTime));
LOG_INFO("server.loading", " ");
}
LOG_INFO("server.loading", ">> Loaded playerbots config in {} ms", GetMSTimeDiffToNow(oldMSTime));
LOG_INFO("server.loading", " ");
}
};
class PlayerbotsScript : public PlayerbotScript
{
public:
PlayerbotsScript() : PlayerbotScript("PlayerbotsScript") { }
public:
PlayerbotsScript() : PlayerbotScript("PlayerbotsScript") {}
bool OnPlayerbotCheckLFGQueue(lfg::Lfg5Guids const& guidsList) override
bool OnPlayerbotCheckLFGQueue(lfg::Lfg5Guids const& guidsList) override
{
bool nonBotFound = false;
for (ObjectGuid const& guid : guidsList.guids)
{
bool nonBotFound = false;
for (ObjectGuid const& guid : guidsList.guids)
Player* player = ObjectAccessor::FindPlayer(guid);
if (guid.IsGroup() || (player && !GET_PLAYERBOT_AI(player)))
{
Player* player = ObjectAccessor::FindPlayer(guid);
if (guid.IsGroup() || (player && !GET_PLAYERBOT_AI(player)))
{
nonBotFound = true;
break;
}
nonBotFound = true;
break;
}
return nonBotFound;
}
void OnPlayerbotCheckKillTask(Player* player, Unit* victim) override
return nonBotFound;
}
void OnPlayerbotCheckKillTask(Player* player, Unit* victim) override
{
if (player)
sGuildTaskMgr->CheckKillTask(player, victim);
}
void OnPlayerbotCheckPetitionAccount(Player* player, bool& found) override
{
if (found && GET_PLAYERBOT_AI(player))
found = false;
}
bool OnPlayerbotCheckUpdatesToSend(Player* player) override
{
if (PlayerbotAI* botAI = GET_PLAYERBOT_AI(player))
return botAI->IsRealPlayer();
return true;
}
void OnPlayerbotPacketSent(Player* player, WorldPacket const* packet) override
{
if (!player)
return;
if (PlayerbotAI* botAI = GET_PLAYERBOT_AI(player))
{
if (player)
sGuildTaskMgr->CheckKillTask(player, victim);
botAI->HandleBotOutgoingPacket(*packet);
}
void OnPlayerbotCheckPetitionAccount(Player* player, bool& found) override
if (PlayerbotMgr* playerbotMgr = GET_PLAYERBOT_MGR(player))
{
if (found && GET_PLAYERBOT_AI(player))
found = false;
playerbotMgr->HandleMasterOutgoingPacket(*packet);
}
}
bool OnPlayerbotCheckUpdatesToSend(Player* player) override
{
if (PlayerbotAI* botAI = GET_PLAYERBOT_AI(player))
return botAI->IsRealPlayer();
void OnPlayerbotUpdate(uint32 diff) override
{
sRandomPlayerbotMgr->UpdateAI(diff);
sRandomPlayerbotMgr->UpdateSessions();
}
return true;
}
void OnPlayerbotPacketSent(Player* player, WorldPacket const* packet) override
{
if (!player)
return;
if (PlayerbotAI* botAI = GET_PLAYERBOT_AI(player))
{
botAI->HandleBotOutgoingPacket(*packet);
}
void OnPlayerbotUpdateSessions(Player* player) override
{
if (player)
if (PlayerbotMgr* playerbotMgr = GET_PLAYERBOT_MGR(player))
playerbotMgr->UpdateSessions();
}
void OnPlayerbotLogout(Player* player) override
{
if (PlayerbotMgr* playerbotMgr = GET_PLAYERBOT_MGR(player))
{
PlayerbotAI* botAI = GET_PLAYERBOT_AI(player);
if (!botAI || botAI->IsRealPlayer())
{
playerbotMgr->HandleMasterOutgoingPacket(*packet);
playerbotMgr->LogoutAllBots();
}
}
void OnPlayerbotUpdate(uint32 diff) override
{
sRandomPlayerbotMgr->UpdateAI(diff);
sRandomPlayerbotMgr->UpdateSessions();
}
sRandomPlayerbotMgr->OnPlayerLogout(player);
}
void OnPlayerbotUpdateSessions(Player* player) override
{
if (player)
if (PlayerbotMgr* playerbotMgr = GET_PLAYERBOT_MGR(player))
playerbotMgr->UpdateSessions();
}
void OnPlayerbotLogout(Player* player) override
{
if (PlayerbotMgr* playerbotMgr = GET_PLAYERBOT_MGR(player))
{
PlayerbotAI* botAI = GET_PLAYERBOT_AI(player);
if (!botAI || botAI->IsRealPlayer())
{
playerbotMgr->LogoutAllBots();
}
}
sRandomPlayerbotMgr->OnPlayerLogout(player);
}
void OnPlayerbotLogoutBots() override
{
sRandomPlayerbotMgr->LogoutAllBots();
}
void OnPlayerbotLogoutBots() override { sRandomPlayerbotMgr->LogoutAllBots(); }
};
void AddPlayerbotsScripts()

6
src/Playerbots.h
View File

@@ -1,5 +1,6 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#ifndef _PLAYERBOT_H
@@ -43,7 +44,8 @@ int strcmpi(char const* s1, char const* s2);
#define RESET_AI_VALUE2(type, name, param) context->GetValue<type>(name, param)->Reset()
#define PAI_VALUE(type, name) sPlayerbotsMgr->GetPlayerbotAI(player)->GetAiObjectContext()->GetValue<type>(name)->Get()
#define PAI_VALUE2(type, name, param) sPlayerbotsMgr->GetPlayerbotAI(player)->GetAiObjectContext()->GetValue<type>(name, param)->Get()
#define PAI_VALUE2(type, name, param) \
sPlayerbotsMgr->GetPlayerbotAI(player)->GetAiObjectContext()->GetValue<type>(name, param)->Get()
#define GAI_VALUE(type, name) sSharedValueContext->getGlobalValue<type>(name)->Get()
#define GAI_VALUE2(type, name, param) sSharedValueContext->getGlobalValue<type>(name, param)->Get()

882
src/RandomItemMgr.cpp
View File

File diff suppressed because it is too large Load Diff

199
src/RandomItemMgr.h
View File

@@ -1,18 +1,19 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#ifndef _PLAYERBOT_RANDOMITEMMGR_H
#define _PLAYERBOT_RANDOMITEMMGR_H
#include "AiFactory.h"
#include "Common.h"
#include "ItemTemplate.h"
#include <map>
#include <set>
#include <vector>
#include "AiFactory.h"
#include "Common.h"
#include "ItemTemplate.h"
class ChatHandler;
struct ItemTemplate;
@@ -60,7 +61,8 @@ struct StatWeight
struct ItemInfoEntry
{
ItemInfoEntry() : minLevel(0), source(0), sourceId(0), team(0), repRank(0), repFaction(0), quality(0), slot(0), itemId(0)
ItemInfoEntry()
: minLevel(0), source(0), sourceId(0), team(0), repRank(0), repFaction(0), quality(0), slot(0), itemId(0)
{
for (uint8 i = 1; i <= MAX_STAT_SCALES; ++i)
{
@@ -81,7 +83,7 @@ struct ItemInfoEntry
};
typedef std::vector<WeightScaleStat> WeightScaleStats;
//typedef std::map<WeightScaleInfo, WeightScaleStats> WeightScaleList;
// typedef std::map<WeightScaleInfo, WeightScaleStats> WeightScaleList;
struct WeightScale
{
@@ -89,14 +91,14 @@ struct WeightScale
WeightScaleStats stats;
};
//typedef map<uint32, WeightScale> WeightScales;
// typedef map<uint32, WeightScale> WeightScales;
class RandomItemPredicate
{
public:
virtual ~RandomItemPredicate() { };
public:
virtual ~RandomItemPredicate(){};
virtual bool Apply(ItemTemplate const* proto) = 0;
virtual bool Apply(ItemTemplate const* proto) = 0;
};
typedef std::vector<uint32> RandomItemList;
@@ -104,102 +106,107 @@ typedef std::map<RandomItemType, RandomItemList> RandomItemCache;
class BotEquipKey
{
public:
BotEquipKey() : level(0), clazz(0), slot(0), quality(0), key(GetKey()) { }
BotEquipKey(uint32 level, uint8 clazz, uint8 slot, uint32 quality) : level(level), clazz(clazz), slot(slot), quality(quality), key(GetKey()) { }
BotEquipKey(BotEquipKey const& other) : level(other.level), clazz(other.clazz), slot(other.slot), quality(other.quality), key(GetKey()) { }
public:
BotEquipKey() : level(0), clazz(0), slot(0), quality(0), key(GetKey()) {}
BotEquipKey(uint32 level, uint8 clazz, uint8 slot, uint32 quality)
: level(level), clazz(clazz), slot(slot), quality(quality), key(GetKey())
{
}
BotEquipKey(BotEquipKey const& other)
: level(other.level), clazz(other.clazz), slot(other.slot), quality(other.quality), key(GetKey())
{
}
bool operator<(BotEquipKey const& other) const
{
return other.key < this->key;
}
bool operator<(BotEquipKey const& other) const { return other.key < this->key; }
uint32 level;
uint8 clazz;
uint8 slot;
uint32 quality;
uint64 key;
uint32 level;
uint8 clazz;
uint8 slot;
uint32 quality;
uint64 key;
private:
uint64 GetKey();
private:
uint64 GetKey();
};
typedef std::map<BotEquipKey, RandomItemList> BotEquipCache;
class RandomItemMgr
{
public:
RandomItemMgr();
virtual ~RandomItemMgr();
static RandomItemMgr* instance()
{
static RandomItemMgr instance;
return &instance;
}
public:
RandomItemMgr();
virtual ~RandomItemMgr();
static RandomItemMgr* instance()
{
static RandomItemMgr instance;
return &instance;
}
public:
void Init();
void InitAfterAhBot();
static bool HandleConsoleCommand(ChatHandler* handler, char const* args);
RandomItemList Query(uint32 level, RandomItemType type, RandomItemPredicate* predicate);
RandomItemList Query(uint32 level, uint8 clazz, uint8 slot, uint32 quality);
uint32 GetUpgrade(Player* player, std::string spec, uint8 slot, uint32 quality, uint32 itemId);
std::vector<uint32> GetUpgradeList(Player* player, std::string spec, uint8 slot, uint32 quality, uint32 itemId, uint32 amount = 1);
bool HasStatWeight(uint32 itemId);
uint32 GetMinLevelFromCache(uint32 itemId);
uint32 GetStatWeight(Player* player, uint32 itemId);
uint32 GetLiveStatWeight(Player* player, uint32 itemId);
uint32 GetRandomItem(uint32 level, RandomItemType type, RandomItemPredicate* predicate = nullptr);
uint32 GetAmmo(uint32 level, uint32 subClass);
uint32 GetRandomPotion(uint32 level, uint32 effect);
uint32 GetRandomFood(uint32 level, uint32 category);
uint32 GetFood(uint32 level, uint32 category);
uint32 GetRandomTrade(uint32 level);
uint32 CalculateStatWeight(uint8 playerclass, uint8 spec, ItemTemplate const* proto);
uint32 CalculateSingleStatWeight(uint8 playerclass, uint8 spec, std::string stat, uint32 value);
bool CanEquipArmor(uint8 clazz, uint32 level, ItemTemplate const* proto);
bool ShouldEquipArmorForSpec(uint8 playerclass, uint8 spec, ItemTemplate const* proto);
bool CanEquipWeapon(uint8 clazz, ItemTemplate const* proto);
bool ShouldEquipWeaponForSpec(uint8 playerclass, uint8 spec, ItemTemplate const* proto);
float GetItemRarity(uint32 itemId);
uint32 GetQuestIdForItem(uint32 itemId);
std::vector<uint32> GetQuestIdsForItem(uint32 itemId);
static bool IsUsedBySkill(ItemTemplate const* proto, uint32 skillId);
bool IsTestItem(uint32 itemId) { return itemForTest.find(itemId) != itemForTest.end(); }
std::vector<uint32> GetCachedEquipments(uint32 requiredLevel, uint32 inventoryType);
public:
void Init();
void InitAfterAhBot();
static bool HandleConsoleCommand(ChatHandler* handler, char const* args);
RandomItemList Query(uint32 level, RandomItemType type, RandomItemPredicate* predicate);
RandomItemList Query(uint32 level, uint8 clazz, uint8 slot, uint32 quality);
uint32 GetUpgrade(Player* player, std::string spec, uint8 slot, uint32 quality, uint32 itemId);
std::vector<uint32> GetUpgradeList(Player* player, std::string spec, uint8 slot, uint32 quality, uint32 itemId,
uint32 amount = 1);
bool HasStatWeight(uint32 itemId);
uint32 GetMinLevelFromCache(uint32 itemId);
uint32 GetStatWeight(Player* player, uint32 itemId);
uint32 GetLiveStatWeight(Player* player, uint32 itemId);
uint32 GetRandomItem(uint32 level, RandomItemType type, RandomItemPredicate* predicate = nullptr);
uint32 GetAmmo(uint32 level, uint32 subClass);
uint32 GetRandomPotion(uint32 level, uint32 effect);
uint32 GetRandomFood(uint32 level, uint32 category);
uint32 GetFood(uint32 level, uint32 category);
uint32 GetRandomTrade(uint32 level);
uint32 CalculateStatWeight(uint8 playerclass, uint8 spec, ItemTemplate const* proto);
uint32 CalculateSingleStatWeight(uint8 playerclass, uint8 spec, std::string stat, uint32 value);
bool CanEquipArmor(uint8 clazz, uint32 level, ItemTemplate const* proto);
bool ShouldEquipArmorForSpec(uint8 playerclass, uint8 spec, ItemTemplate const* proto);
bool CanEquipWeapon(uint8 clazz, ItemTemplate const* proto);
bool ShouldEquipWeaponForSpec(uint8 playerclass, uint8 spec, ItemTemplate const* proto);
float GetItemRarity(uint32 itemId);
uint32 GetQuestIdForItem(uint32 itemId);
std::vector<uint32> GetQuestIdsForItem(uint32 itemId);
static bool IsUsedBySkill(ItemTemplate const* proto, uint32 skillId);
bool IsTestItem(uint32 itemId) { return itemForTest.find(itemId) != itemForTest.end(); }
std::vector<uint32> GetCachedEquipments(uint32 requiredLevel, uint32 inventoryType);
private:
void BuildRandomItemCache();
void BuildEquipCache();
void BuildEquipCacheNew();
void BuildItemInfoCache();
void BuildAmmoCache();
void BuildFoodCache();
void BuildPotionCache();
void BuildTradeCache();
void BuildRarityCache();
bool CanEquipItem(BotEquipKey key, ItemTemplate const* proto);
bool CanEquipItemNew(ItemTemplate const* proto);
void AddItemStats(uint32 mod, uint8& sp, uint8& ap, uint8& tank);
bool CheckItemStats(uint8 clazz, uint8 sp, uint8 ap, uint8 tank);
private:
std::map<uint32, RandomItemCache> randomItemCache;
std::map<RandomItemType, RandomItemPredicate*> predicates;
BotEquipCache equipCache;
std::map<EquipmentSlots, std::set<InventoryType>> viableSlots;
std::map<uint32, std::map<uint32, uint32> > ammoCache;
std::map<uint32, std::map<uint32, std::vector<uint32> > > potionCache;
std::map<uint32, std::map<uint32, std::vector<uint32> > > foodCache;
std::map<uint32, std::vector<uint32> > tradeCache;
std::map<uint32, float> rarityCache;
std::map<uint8, WeightScale> m_weightScales[MAX_CLASSES];
std::map<std::string, uint32 > weightStatLink;
std::map<std::string, uint32 > weightRatingLink;
std::map<uint32, ItemInfoEntry> itemInfoCache;
std::set<uint32> itemForTest;
static std::set<uint32> itemCache;
// equipCacheNew[RequiredLevel][InventoryType]
std::map<uint32, std::map<uint32, std::vector<uint32>>> equipCacheNew;
private:
void BuildRandomItemCache();
void BuildEquipCache();
void BuildEquipCacheNew();
void BuildItemInfoCache();
void BuildAmmoCache();
void BuildFoodCache();
void BuildPotionCache();
void BuildTradeCache();
void BuildRarityCache();
bool CanEquipItem(BotEquipKey key, ItemTemplate const* proto);
bool CanEquipItemNew(ItemTemplate const* proto);
void AddItemStats(uint32 mod, uint8& sp, uint8& ap, uint8& tank);
bool CheckItemStats(uint8 clazz, uint8 sp, uint8 ap, uint8 tank);
private:
std::map<uint32, RandomItemCache> randomItemCache;
std::map<RandomItemType, RandomItemPredicate*> predicates;
BotEquipCache equipCache;
std::map<EquipmentSlots, std::set<InventoryType>> viableSlots;
std::map<uint32, std::map<uint32, uint32>> ammoCache;
std::map<uint32, std::map<uint32, std::vector<uint32>>> potionCache;
std::map<uint32, std::map<uint32, std::vector<uint32>>> foodCache;
std::map<uint32, std::vector<uint32>> tradeCache;
std::map<uint32, float> rarityCache;
std::map<uint8, WeightScale> m_weightScales[MAX_CLASSES];
std::map<std::string, uint32> weightStatLink;
std::map<std::string, uint32> weightRatingLink;
std::map<uint32, ItemInfoEntry> itemInfoCache;
std::set<uint32> itemForTest;
static std::set<uint32> itemCache;
// equipCacheNew[RequiredLevel][InventoryType]
std::map<uint32, std::map<uint32, std::vector<uint32>>> equipCacheNew;
};
#define sRandomItemMgr RandomItemMgr::instance()

251
src/RandomPlayerbotFactory.cpp
View File

@@ -1,14 +1,16 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#include "RandomPlayerbotFactory.h"
#include "ArenaTeamMgr.h"
#include "AccountMgr.h"
#include "ArenaTeamMgr.h"
#include "DatabaseEnv.h"
#include "GuildMgr.h"
#include "Playerbots.h"
#include "PlayerbotFactory.h"
#include "Playerbots.h"
#include "ScriptMgr.h"
#include "SocialMgr.h"
@@ -26,14 +28,14 @@ RandomPlayerbotFactory::RandomPlayerbotFactory(uint32 accountId) : accountId(acc
availableRaces[CLASS_WARRIOR].push_back(RACE_UNDEAD_PLAYER);
availableRaces[CLASS_WARRIOR].push_back(RACE_TAUREN);
availableRaces[CLASS_WARRIOR].push_back(RACE_TROLL);
if(expansion >= EXPANSION_THE_BURNING_CRUSADE)
if (expansion >= EXPANSION_THE_BURNING_CRUSADE)
{
availableRaces[CLASS_WARRIOR].push_back(RACE_DRAENEI);
}
availableRaces[CLASS_PALADIN].push_back(RACE_HUMAN);
availableRaces[CLASS_PALADIN].push_back(RACE_DWARF);
if(expansion >= EXPANSION_THE_BURNING_CRUSADE)
if (expansion >= EXPANSION_THE_BURNING_CRUSADE)
{
availableRaces[CLASS_PALADIN].push_back(RACE_DRAENEI);
availableRaces[CLASS_PALADIN].push_back(RACE_BLOODELF);
@@ -45,7 +47,7 @@ RandomPlayerbotFactory::RandomPlayerbotFactory(uint32 accountId) : accountId(acc
availableRaces[CLASS_ROGUE].push_back(RACE_GNOME);
availableRaces[CLASS_ROGUE].push_back(RACE_ORC);
availableRaces[CLASS_ROGUE].push_back(RACE_TROLL);
if(expansion >= EXPANSION_THE_BURNING_CRUSADE)
if (expansion >= EXPANSION_THE_BURNING_CRUSADE)
{
availableRaces[CLASS_ROGUE].push_back(RACE_BLOODELF);
}
@@ -55,7 +57,7 @@ RandomPlayerbotFactory::RandomPlayerbotFactory(uint32 accountId) : accountId(acc
availableRaces[CLASS_PRIEST].push_back(RACE_NIGHTELF);
availableRaces[CLASS_PRIEST].push_back(RACE_TROLL);
availableRaces[CLASS_PRIEST].push_back(RACE_UNDEAD_PLAYER);
if(expansion >= EXPANSION_THE_BURNING_CRUSADE)
if (expansion >= EXPANSION_THE_BURNING_CRUSADE)
{
availableRaces[CLASS_PRIEST].push_back(RACE_DRAENEI);
availableRaces[CLASS_PRIEST].push_back(RACE_BLOODELF);
@@ -65,7 +67,7 @@ RandomPlayerbotFactory::RandomPlayerbotFactory(uint32 accountId) : accountId(acc
availableRaces[CLASS_MAGE].push_back(RACE_GNOME);
availableRaces[CLASS_MAGE].push_back(RACE_UNDEAD_PLAYER);
availableRaces[CLASS_MAGE].push_back(RACE_TROLL);
if(expansion >= EXPANSION_THE_BURNING_CRUSADE)
if (expansion >= EXPANSION_THE_BURNING_CRUSADE)
{
availableRaces[CLASS_MAGE].push_back(RACE_DRAENEI);
availableRaces[CLASS_MAGE].push_back(RACE_BLOODELF);
@@ -75,7 +77,7 @@ RandomPlayerbotFactory::RandomPlayerbotFactory(uint32 accountId) : accountId(acc
availableRaces[CLASS_WARLOCK].push_back(RACE_GNOME);
availableRaces[CLASS_WARLOCK].push_back(RACE_UNDEAD_PLAYER);
availableRaces[CLASS_WARLOCK].push_back(RACE_ORC);
if(expansion >= EXPANSION_THE_BURNING_CRUSADE)
if (expansion >= EXPANSION_THE_BURNING_CRUSADE)
{
availableRaces[CLASS_WARLOCK].push_back(RACE_BLOODELF);
}
@@ -83,7 +85,7 @@ RandomPlayerbotFactory::RandomPlayerbotFactory(uint32 accountId) : accountId(acc
availableRaces[CLASS_SHAMAN].push_back(RACE_ORC);
availableRaces[CLASS_SHAMAN].push_back(RACE_TAUREN);
availableRaces[CLASS_SHAMAN].push_back(RACE_TROLL);
if(expansion >= EXPANSION_THE_BURNING_CRUSADE)
if (expansion >= EXPANSION_THE_BURNING_CRUSADE)
{
availableRaces[CLASS_SHAMAN].push_back(RACE_DRAENEI);
}
@@ -93,7 +95,7 @@ RandomPlayerbotFactory::RandomPlayerbotFactory(uint32 accountId) : accountId(acc
availableRaces[CLASS_HUNTER].push_back(RACE_ORC);
availableRaces[CLASS_HUNTER].push_back(RACE_TAUREN);
availableRaces[CLASS_HUNTER].push_back(RACE_TROLL);
if(expansion >= EXPANSION_THE_BURNING_CRUSADE)
if (expansion >= EXPANSION_THE_BURNING_CRUSADE)
{
availableRaces[CLASS_HUNTER].push_back(RACE_DRAENEI);
availableRaces[CLASS_HUNTER].push_back(RACE_BLOODELF);
@@ -119,27 +121,30 @@ RandomPlayerbotFactory::RandomPlayerbotFactory(uint32 accountId) : accountId(acc
Player* RandomPlayerbotFactory::CreateRandomBot(WorldSession* session, uint8 cls)
{
LOG_DEBUG("playerbots", "Creating new random bot for class {}", cls);
LOG_DEBUG("playerbots", "Creating new random bot for class {}", cls);
uint8 gender = rand() % 2 ? GENDER_MALE : GENDER_FEMALE;
uint8 alliance = rand() % 2;
uint8 race;
for (int attempt = 0; attempt < 15; attempt++) {
for (int attempt = 0; attempt < 15; attempt++)
{
race = availableRaces[cls][urand(0, availableRaces[cls].size() - 1)];
if ((alliance && IsAlliance(race)) || (!alliance && !IsAlliance(race))) {
if ((alliance && IsAlliance(race)) || (!alliance && !IsAlliance(race)))
{
break;
}
}
std::string name = CreateRandomBotName(gender);
if (name.empty()) {
if (name.empty())
{
LOG_ERROR("playerbots", "Unable to get random bot name!");
return nullptr;
}
CharacterDatabase.DirectExecute("UPDATE playerbots_names SET in_use=1 WHERE name='{}'", name);
std::vector<uint8> skinColors, facialHairTypes;
std::vector<std::pair<uint8,uint8>> faces, hairs;
std::vector<std::pair<uint8, uint8>> faces, hairs;
for (CharSectionsEntry const* charSection : sCharSectionsStore)
{
if (charSection->Race != race || charSection->Gender != gender)
@@ -166,19 +171,22 @@ Player* RandomPlayerbotFactory::CreateRandomBot(WorldSession* session, uint8 cls
std::pair<uint8, uint8> face = faces[urand(0, faces.size() - 1)];
std::pair<uint8, uint8> hair = hairs[urand(0, hairs.size() - 1)];
bool excludeCheck = (race == RACE_TAUREN) || (race == RACE_DRAENEI) || (gender == GENDER_FEMALE && race != RACE_NIGHTELF && race != RACE_UNDEAD_PLAYER);
uint8 facialHair = excludeCheck ? 0 : facialHairTypes[urand(0, facialHairTypes.size() - 1)];
bool excludeCheck = (race == RACE_TAUREN) || (race == RACE_DRAENEI) ||
(gender == GENDER_FEMALE && race != RACE_NIGHTELF && race != RACE_UNDEAD_PLAYER);
uint8 facialHair = excludeCheck ? 0 : facialHairTypes[urand(0, facialHairTypes.size() - 1)];
std::unique_ptr<CharacterCreateInfo> characterInfo = std::make_unique<CharacterCreateInfo>(name, race, cls, gender, face.second, face.first, hair.first, hair.second, facialHair);
std::unique_ptr<CharacterCreateInfo> characterInfo = std::make_unique<CharacterCreateInfo>(
name, race, cls, gender, face.second, face.first, hair.first, hair.second, facialHair);
Player* player = new Player(session);
player->GetMotionMaster()->Initialize();
if (!player->Create(sObjectMgr->GetGenerator<HighGuid::Player>().Generate(), characterInfo.get()))
if (!player->Create(sObjectMgr->GetGenerator<HighGuid::Player>().Generate(), characterInfo.get()))
{
player->CleanupsBeforeDelete();
delete player;
LOG_ERROR("playerbots", "Unable to create random bot for account {} - name: \"{}\"; race: {}; class: {}", accountId, name.c_str(), race, cls);
LOG_ERROR("playerbots", "Unable to create random bot for account {} - name: \"{}\"; race: {}; class: {}",
accountId, name.c_str(), race, cls);
return nullptr;
}
@@ -186,23 +194,27 @@ Player* RandomPlayerbotFactory::CreateRandomBot(WorldSession* session, uint8 cls
player->SetAtLoginFlag(AT_LOGIN_NONE);
if (player->getClass() == CLASS_DEATH_KNIGHT)
{
player->learnSpell(50977, false);
}
{
player->learnSpell(50977, false);
}
// player->SaveToDB(true, false);
// player->RewardQuest(const Quest *quest, uint32 reward, Object *questGiver)
LOG_DEBUG("playerbots", "Random bot created for account {} - name: \"{}\"; race: {}; class: {}", accountId, name.c_str(), race, cls);
LOG_DEBUG("playerbots", "Random bot created for account {} - name: \"{}\"; race: {}; class: {}", accountId,
name.c_str(), race, cls);
return player;
}
std::string const RandomPlayerbotFactory::CreateRandomBotName(uint8 gender)
{
std::string botName = "";
std::string botName = "";
int tries = 10;
while(--tries) {
QueryResult result = CharacterDatabase.Query("SELECT name FROM playerbots_names "
"WHERE in_use = 0 AND gender = {} ORDER BY RAND() LIMIT 1", gender);
while (--tries)
{
QueryResult result = CharacterDatabase.Query(
"SELECT name FROM playerbots_names "
"WHERE in_use = 0 AND gender = {} ORDER BY RAND() LIMIT 1",
gender);
if (!result)
{
break;
@@ -215,66 +227,57 @@ std::string const RandomPlayerbotFactory::CreateRandomBotName(uint8 gender)
}
}
//CONLANG NAME GENERATION
// CONLANG NAME GENERATION
LOG_ERROR("playerbots", "No more names left for random bots. Attempting conlang name generation.");
const std::string groupCategory = "SCVKRU";
const std::string groupFormStart[2][4] = {
{"SV","SV","VK","RV"},
{"V" ,"SU","VS","RV"}
};
const std::string groupFormMid[2][6] = {
{"CV","CVC","CVC","CVK","VC","VK"},
{"CV","CVC","CVK","KVC","VC","KV"}
};
const std::string groupFormEnd[2][4] = {
{"CV","VC","VK","CV"},
{"RU","UR","VR","V" }
};
const std::string groupFormStart[2][4] = {{"SV", "SV", "VK", "RV"}, {"V", "SU", "VS", "RV"}};
const std::string groupFormMid[2][6] = {{"CV", "CVC", "CVC", "CVK", "VC", "VK"},
{"CV", "CVC", "CVK", "KVC", "VC", "KV"}};
const std::string groupFormEnd[2][4] = {{"CV", "VC", "VK", "CV"}, {"RU", "UR", "VR", "V"}};
const std::string groupLetter[2][6] = {
//S C V K R U
{"dtspkThfS","bcCdfghjkmnNqqrrlsStTvwxyz","aaeeiouA" ,"ppttkkbdg","lmmnrr" ,"AEO" },
{"dtskThfS" ,"bcCdfghjkmmnNqrrlssStTvwyz","aaaeeiiuAAEIO","ppttkbbdg","lmmnrrr","AEOy"}
};
// S C V K R U
{"dtspkThfS", "bcCdfghjkmnNqqrrlsStTvwxyz", "aaeeiouA", "ppttkkbdg", "lmmnrr", "AEO"},
{"dtskThfS", "bcCdfghjkmmnNqrrlssStTvwyz", "aaaeeiiuAAEIO", "ppttkbbdg", "lmmnrrr", "AEOy"}};
const std::string replaceRule[2][17] = {
{"ST" ,"ka","ko","ku","kr","S" ,"T" ,"C" ,"N" ,"jj","AA","AI" ,"A" ,"E" ,"O" ,"I" ,"aa"},
{"sth","ca","co","cu","cr","sh","th","ch","ng","dg","A" ,"ayu","ai","ei","ou","iu","ae"}
};
{"ST", "ka", "ko", "ku", "kr", "S", "T", "C", "N", "jj", "AA", "AI", "A", "E", "O", "I", "aa"},
{"sth", "ca", "co", "cu", "cr", "sh", "th", "ch", "ng", "dg", "A", "ayu", "ai", "ei", "ou", "iu", "ae"}};
tries = 10;
while (--tries)
{
botName.clear();
//Build name from groupForms
//Pick random start group
botName = groupFormStart[gender][rand()%4];
//Pick up to 2 and then up to 1 additional middle group
for (int i = 0; i < rand()%3 + rand()%2; i++)
// Build name from groupForms
// Pick random start group
botName = groupFormStart[gender][rand() % 4];
// Pick up to 2 and then up to 1 additional middle group
for (int i = 0; i < rand() % 3 + rand() % 2; i++)
{
botName += groupFormMid[gender][rand()%6];
}
//Pick up to 1 end group
botName += rand()%2 ? groupFormEnd[gender][rand()%4] : "";
//If name is single letter add random end group
botName += (botName.size() < 2) ? groupFormEnd[gender][rand()%4] : "";
//Replace Catagory value with random Letter from that Catagory's Letter string for a given bot gender
for (int i=0; i < botName.size(); i++)
botName += groupFormMid[gender][rand() % 6];
}
// Pick up to 1 end group
botName += rand() % 2 ? groupFormEnd[gender][rand() % 4] : "";
// If name is single letter add random end group
botName += (botName.size() < 2) ? groupFormEnd[gender][rand() % 4] : "";
// Replace Catagory value with random Letter from that Catagory's Letter string for a given bot gender
for (int i = 0; i < botName.size(); i++)
{
botName[i] = groupLetter[gender][groupCategory.find(botName[i])][rand()%groupLetter[gender][groupCategory.find(botName[i])].size()];
}
//Itterate over replace rules
botName[i] = groupLetter[gender][groupCategory.find(botName[i])]
[rand() % groupLetter[gender][groupCategory.find(botName[i])].size()];
}
// Itterate over replace rules
for (int i = 0; i < 17; i++)
{
int j = botName.find(replaceRule[0][i]);
while ( j > -1)
while (j > -1)
{
botName.replace(j,replaceRule[0][i].size(),replaceRule[1][i]);
botName.replace(j, replaceRule[0][i].size(), replaceRule[1][i]);
j = botName.find(replaceRule[0][i]);
}
}
}
//Capitalize first letter
// Capitalize first letter
botName[0] -= 32;
if (ObjectMgr::CheckPlayerName(botName) != CHAR_NAME_SUCCESS ||
@@ -286,11 +289,13 @@ std::string const RandomPlayerbotFactory::CreateRandomBotName(uint8 gender)
return std::move(botName);
}
//TRUE RANDOM NAME GENERATION
// TRUE RANDOM NAME GENERATION
LOG_ERROR("playerbots", "Con​lang name generation failed. True random name fallback.");
tries = 10;
while(--tries) {
for (uint8 i = 0; i < 10; i++) {
while (--tries)
{
for (uint8 i = 0; i < 10; i++)
{
botName += (i == 0 ? 'A' : 'a') + rand() % 26;
}
if (ObjectMgr::CheckPlayerName(botName) != CHAR_NAME_SUCCESS ||
@@ -325,7 +330,8 @@ void RandomPlayerbotFactory::CreateRandomBots()
}
LOG_INFO("playerbots", "Deleting all random bot characters, {} accounts collected...", botAccounts.size());
QueryResult results = LoginDatabase.Query("SELECT id FROM account WHERE username LIKE '{}%%'", sPlayerbotAIConfig->randomBotAccountPrefix.c_str());
QueryResult results = LoginDatabase.Query("SELECT id FROM account WHERE username LIKE '{}%%'",
sPlayerbotAIConfig->randomBotAccountPrefix.c_str());
int32 deletion_count = 0;
if (results)
{
@@ -340,15 +346,15 @@ void RandomPlayerbotFactory::CreateRandomBots()
PlayerbotsDatabase.Execute(PlayerbotsDatabase.GetPreparedStatement(PLAYERBOTS_DEL_RANDOM_BOTS));
CharacterDatabase.DirectExecute("UPDATE playerbots_names SET in_use = 0 WHERE in_use = 1");
/* TODO(yunfan): we need to sleep here to wait for async account deleted, or the newly account won't be created correctly
the better way is turning the async db operation to sync db operation */
/* TODO(yunfan): we need to sleep here to wait for async account deleted, or the newly account won't be created
correctly the better way is turning the async db operation to sync db operation */
std::this_thread::sleep_for(10ms * sPlayerbotAIConfig->randomBotAccountCount);
LOG_INFO("playerbots", "Random bot characters deleted.");
LOG_INFO("playerbots", "Please reset the AiPlayerbot.DeleteRandomBotAccounts to 0 and restart the server...");
World::StopNow(SHUTDOWN_EXIT_CODE);
return;
}
uint32 totalAccCount = sPlayerbotAIConfig->randomBotAccountCount;
LOG_INFO("playerbots", "Creating random bot accounts...");
@@ -374,7 +380,7 @@ void RandomPlayerbotFactory::CreateRandomBots()
{
for (int i = 0; i < 10; i++)
{
password += (char) urand('!', 'z');
password += (char)urand('!', 'z');
}
}
else
@@ -385,7 +391,8 @@ void RandomPlayerbotFactory::CreateRandomBots()
LOG_DEBUG("playerbots", "Account {} created for random bots", accountName.c_str());
}
if (account_creation) {
if (account_creation)
{
/* wait for async accounts create to make character create correctly, same as account delete */
LOG_INFO("playerbots", "Waiting for {} accounts loading into database...", account_creation);
std::this_thread::sleep_for(10ms * sPlayerbotAIConfig->randomBotAccountCount);
@@ -420,10 +427,12 @@ void RandomPlayerbotFactory::CreateRandomBots()
{
continue;
}
LOG_INFO("playerbots", "Creating random bot characters for account: [{}/{}]", accountNumber + 1, sPlayerbotAIConfig->randomBotAccountCount);
LOG_INFO("playerbots", "Creating random bot characters for account: [{}/{}]", accountNumber + 1,
sPlayerbotAIConfig->randomBotAccountCount);
RandomPlayerbotFactory factory(accountId);
WorldSession* session = new WorldSession(accountId, "", nullptr, SEC_PLAYER, EXPANSION_WRATH_OF_THE_LICH_KING, time_t(0), LOCALE_enUS, 0, false, false, 0, true);
WorldSession* session = new WorldSession(accountId, "", nullptr, SEC_PLAYER, EXPANSION_WRATH_OF_THE_LICH_KING,
time_t(0), LOCALE_enUS, 0, false, false, 0, true);
sessionBots.push_back(session);
for (uint8 cls = CLASS_WARRIOR; cls < MAX_CLASSES - count; ++cls)
@@ -433,29 +442,33 @@ void RandomPlayerbotFactory::CreateRandomBots()
continue;
if (bool const isClassDeathKnight = cls == CLASS_DEATH_KNIGHT;
isClassDeathKnight &&
sWorld->getIntConfig(CONFIG_EXPANSION) !=
EXPANSION_WRATH_OF_THE_LICH_KING)
isClassDeathKnight && sWorld->getIntConfig(CONFIG_EXPANSION) != EXPANSION_WRATH_OF_THE_LICH_KING)
{
continue;
}
if (cls != 10) {
if (Player* playerBot = factory.CreateRandomBot(session, cls)) {
if (cls != 10)
{
if (Player* playerBot = factory.CreateRandomBot(session, cls))
{
playerBot->SaveToDB(true, false);
sCharacterCache->AddCharacterCacheEntry(playerBot->GetGUID(), accountId, playerBot->GetName(),
playerBot->getGender(), playerBot->getRace(), playerBot->getClass(), playerBot->GetLevel());
sCharacterCache->AddCharacterCacheEntry(playerBot->GetGUID(), accountId, playerBot->GetName(),
playerBot->getGender(), playerBot->getRace(),
playerBot->getClass(), playerBot->GetLevel());
playerBot->CleanupsBeforeDelete();
delete playerBot;
bot_creation++;
} else {
}
else
{
LOG_ERROR("playerbots", "Fail to create character for account {}", accountId);
}
}
}
}
if (bot_creation) {
if (bot_creation)
{
LOG_INFO("playerbots", "Waiting for {} characters loading into database...", bot_creation);
/* wait for characters load into database, or characters will fail to loggin */
std::this_thread::sleep_for(10s);
@@ -463,12 +476,14 @@ void RandomPlayerbotFactory::CreateRandomBots()
for (WorldSession* session : sessionBots)
delete session;
for (uint32 accountId : sPlayerbotAIConfig->randomBotAccounts) {
for (uint32 accountId : sPlayerbotAIConfig->randomBotAccounts)
{
totalRandomBotChars += AccountMgr::GetCharactersCount(accountId);
}
LOG_INFO("server.loading", "{} random bot accounts with {} characters available", sPlayerbotAIConfig->randomBotAccounts.size(), totalRandomBotChars);
LOG_INFO("server.loading", "{} random bot accounts with {} characters available",
sPlayerbotAIConfig->randomBotAccounts.size(), totalRandomBotChars);
}
void RandomPlayerbotFactory::CreateRandomGuilds()
@@ -484,8 +499,7 @@ void RandomPlayerbotFactory::CreateRandomGuilds()
Field* fields = result->Fetch();
uint32 bot = fields[0].Get<uint32>();
randomBots.push_back(bot);
}
while (result->NextRow());
} while (result->NextRow());
}
if (sPlayerbotAIConfig->deleteRandomBotGuilds)
@@ -538,7 +552,8 @@ void RandomPlayerbotFactory::CreateRandomGuilds()
Player* player = ObjectAccessor::FindPlayer(leader);
if (!player)
{
LOG_ERROR("playerbots", "ObjectAccessor Cannot find player to set leader for guild {} . Skipped...", guildName.c_str());
LOG_ERROR("playerbots", "ObjectAccessor Cannot find player to set leader for guild {} . Skipped...",
guildName.c_str());
continue;
}
@@ -548,7 +563,8 @@ void RandomPlayerbotFactory::CreateRandomGuilds()
Guild* guild = new Guild();
if (!guild->Create(player, guildName))
{
LOG_ERROR("playerbots", "Error creating guild [ {} ] with leader [ {} ]", guildName.c_str(), player->GetName().c_str());
LOG_ERROR("playerbots", "Error creating guild [ {} ] with leader [ {} ]", guildName.c_str(),
player->GetName().c_str());
delete guild;
continue;
}
@@ -586,8 +602,10 @@ std::string const RandomPlayerbotFactory::CreateRandomGuildName()
uint32 maxId = fields[0].Get<uint32>();
uint32 id = urand(0, maxId);
result = CharacterDatabase.Query("SELECT n.name FROM playerbots_guild_names n "
"LEFT OUTER JOIN guild e ON e.name = n.name WHERE e.guildid IS NULL AND n.name_id >= {} LIMIT 1", id);
result = CharacterDatabase.Query(
"SELECT n.name FROM playerbots_guild_names n "
"LEFT OUTER JOIN guild e ON e.name = n.name WHERE e.guildid IS NULL AND n.name_id >= {} LIMIT 1",
id);
if (!result)
{
LOG_ERROR("playerbots", "No more names left for random guilds");
@@ -613,8 +631,7 @@ void RandomPlayerbotFactory::CreateRandomArenaTeams(ArenaType type, uint32 count
Field* fields = result->Fetch();
uint32 bot = fields[0].Get<uint32>();
randomBots.push_back(bot);
}
while (result->NextRow());
} while (result->NextRow());
}
uint32 arenaTeamNumber = 0;
@@ -664,10 +681,10 @@ void RandomPlayerbotFactory::CreateRandomArenaTeams(ArenaType type, uint32 count
continue;
}
// Below query no longer required as now user has control over the number of each type of arena team they want to create.
// Keeping commented for potential future reference.
// QueryResult results = CharacterDatabase.Query("SELECT `type` FROM playerbots_arena_team_names WHERE name = '{}'", arenaTeamName.c_str());
// if (!results)
// Below query no longer required as now user has control over the number of each type of arena team they want
// to create. Keeping commented for potential future reference. QueryResult results =
// CharacterDatabase.Query("SELECT `type` FROM playerbots_arena_team_names WHERE name = '{}'",
// arenaTeamName.c_str()); if (!results)
// {
// LOG_ERROR("playerbots", "No valid types for arena teams");
// return;
@@ -686,7 +703,8 @@ void RandomPlayerbotFactory::CreateRandomArenaTeams(ArenaType type, uint32 count
arenateam->SetCaptain(player->GetGUID());
// set random rating
arenateam->SetRatingForAll(urand(sPlayerbotAIConfig->randomBotArenaTeamMinRating, sPlayerbotAIConfig->randomBotArenaTeamMaxRating));
arenateam->SetRatingForAll(
urand(sPlayerbotAIConfig->randomBotArenaTeamMinRating, sPlayerbotAIConfig->randomBotArenaTeamMaxRating));
// set random emblem
uint32 backgroundColor = urand(0xFF000000, 0xFFFFFFFF);
@@ -697,10 +715,11 @@ void RandomPlayerbotFactory::CreateRandomArenaTeams(ArenaType type, uint32 count
arenateam->SetEmblem(backgroundColor, emblemStyle, emblemColor, borderStyle, borderColor);
// set random kills (wip)
//arenateam->SetStats(STAT_TYPE_GAMES_WEEK, urand(0, 30));
//arenateam->SetStats(STAT_TYPE_WINS_WEEK, urand(0, arenateam->GetStats().games_week));
//arenateam->SetStats(STAT_TYPE_GAMES_SEASON, urand(arenateam->GetStats().games_week, arenateam->GetStats().games_week * 5));
//arenateam->SetStats(STAT_TYPE_WINS_SEASON, urand(arenateam->GetStats().wins_week, arenateam->GetStats().games
// arenateam->SetStats(STAT_TYPE_GAMES_WEEK, urand(0, 30));
// arenateam->SetStats(STAT_TYPE_WINS_WEEK, urand(0, arenateam->GetStats().games_week));
// arenateam->SetStats(STAT_TYPE_GAMES_SEASON, urand(arenateam->GetStats().games_week,
// arenateam->GetStats().games_week * 5)); arenateam->SetStats(STAT_TYPE_WINS_SEASON,
// urand(arenateam->GetStats().wins_week, arenateam->GetStats().games
arenateam->SaveToDB();
sArenaTeamMgr->AddArenaTeam(arenateam);
@@ -725,8 +744,10 @@ std::string const RandomPlayerbotFactory::CreateRandomArenaTeamName()
uint32 maxId = fields[0].Get<uint32>();
uint32 id = urand(0, maxId);
result = CharacterDatabase.Query("SELECT n.name FROM playerbots_arena_team_names n LEFT OUTER JOIN arena_team e ON e.name = n.name "
"WHERE e.arenateamid IS NULL AND n.name_id >= {} LIMIT 1", id);
result = CharacterDatabase.Query(
"SELECT n.name FROM playerbots_arena_team_names n LEFT OUTER JOIN arena_team e ON e.name = n.name "
"WHERE e.arenateamid IS NULL AND n.name_id >= {} LIMIT 1",
id);
if (!result)
{

33
src/RandomPlayerbotFactory.h
View File

@@ -1,15 +1,16 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#ifndef _PLAYERBOT_RANDOMPLAYERBOTFACTORY_H
#define _PLAYERBOT_RANDOMPLAYERBOTFACTORY_H
#include "Common.h"
#include <map>
#include <unordered_map>
#include <vector>
#include "Common.h"
#include "DBCEnums.h"
class Player;
@@ -19,22 +20,22 @@ enum ArenaType : uint8;
class RandomPlayerbotFactory
{
public:
RandomPlayerbotFactory(uint32 accountId);
virtual ~RandomPlayerbotFactory() { }
public:
RandomPlayerbotFactory(uint32 accountId);
virtual ~RandomPlayerbotFactory() {}
Player* CreateRandomBot(WorldSession* session, uint8 cls);
static void CreateRandomBots();
static void CreateRandomGuilds();
static void CreateRandomArenaTeams(ArenaType slot, uint32 count);
static std::string const CreateRandomGuildName();
Player* CreateRandomBot(WorldSession* session, uint8 cls);
static void CreateRandomBots();
static void CreateRandomGuilds();
static void CreateRandomArenaTeams(ArenaType slot, uint32 count);
static std::string const CreateRandomGuildName();
private:
std::string const CreateRandomBotName(uint8 gender);
static std::string const CreateRandomArenaTeamName();
private:
std::string const CreateRandomBotName(uint8 gender);
static std::string const CreateRandomArenaTeamName();
uint32 accountId;
static std::map<uint8, std::vector<uint8>> availableRaces;
uint32 accountId;
static std::map<uint8, std::vector<uint8>> availableRaces;
};
#endif

789
src/RandomPlayerbotMgr.cpp
View File

File diff suppressed because it is too large Load Diff

246
src/RandomPlayerbotMgr.h
View File

@@ -1,5 +1,6 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#ifndef _PLAYERBOT_RANDOMPLAYERBOTMGR_H
@@ -7,7 +8,8 @@
#include "PlayerbotMgr.h"
struct BattlegroundInfo {
struct BattlegroundInfo
{
std::vector<uint32> bgInstances;
std::vector<uint32> ratedArenaInstances;
std::vector<uint32> skirmishArenaInstances;
@@ -16,9 +18,9 @@ struct BattlegroundInfo {
uint32 skirmishArenaInstanceCount = 0;
uint32 minLevel = 0;
uint32 maxLevel = 0;
uint32 activeRatedArenaQueue = 0; // 0 = Inactive, 1 = Active
uint32 activeSkirmishArenaQueue = 0; // 0 = Inactive, 1 = Active
uint32 activeBgQueue = 0; // 0 = Inactive, 1 = Active
uint32 activeRatedArenaQueue = 0; // 0 = Inactive, 1 = Active
uint32 activeSkirmishArenaQueue = 0; // 0 = Inactive, 1 = Active
uint32 activeBgQueue = 0; // 0 = Inactive, 1 = Active
// Bots (Arena)
uint32 ratedArenaBotCount = 0;
@@ -43,21 +45,27 @@ class WorldLocation;
class CachedEvent
{
public:
CachedEvent() : value(0), lastChangeTime(0), validIn(0), data("") { }
CachedEvent(const CachedEvent& other) : value(other.value), lastChangeTime(other.lastChangeTime), validIn(other.validIn), data(other.data) { }
CachedEvent(uint32 value, uint32 lastChangeTime, uint32 validIn, std::string const data = "") : value(value), lastChangeTime(lastChangeTime), validIn(validIn), data(data) { }
public:
CachedEvent() : value(0), lastChangeTime(0), validIn(0), data("") {}
CachedEvent(const CachedEvent& other)
: value(other.value), lastChangeTime(other.lastChangeTime), validIn(other.validIn), data(other.data)
{
}
CachedEvent(uint32 value, uint32 lastChangeTime, uint32 validIn, std::string const data = "")
: value(value), lastChangeTime(lastChangeTime), validIn(validIn), data(data)
{
}
bool IsEmpty() { return !lastChangeTime; }
bool IsEmpty() { return !lastChangeTime; }
public:
uint32 value;
uint32 lastChangeTime;
uint32 validIn;
std::string data;
public:
uint32 value;
uint32 lastChangeTime;
uint32 validIn;
std::string data;
};
//https://gist.github.com/bradley219/5373998
// https://gist.github.com/bradley219/5373998
class botPIDImpl;
class botPID
@@ -82,117 +90,121 @@ private:
class RandomPlayerbotMgr : public PlayerbotHolder
{
public:
RandomPlayerbotMgr();
virtual ~RandomPlayerbotMgr();
static RandomPlayerbotMgr* instance()
{
static RandomPlayerbotMgr instance;
return &instance;
}
public:
RandomPlayerbotMgr();
virtual ~RandomPlayerbotMgr();
static RandomPlayerbotMgr* instance()
{
static RandomPlayerbotMgr instance;
return &instance;
}
void LogPlayerLocation();
void UpdateAIInternal(uint32 elapsed, bool minimal = false) override;
void LogPlayerLocation();
void UpdateAIInternal(uint32 elapsed, bool minimal = false) override;
private:
void ScaleBotActivity();
private:
void ScaleBotActivity();
public:
uint32 activeBots = 0;
static bool HandlePlayerbotConsoleCommand(ChatHandler* handler, char const* args);
bool IsRandomBot(Player* bot);
bool IsRandomBot(ObjectGuid::LowType bot);
void Randomize(Player* bot);
void Clear(Player* bot);
void RandomizeFirst(Player* bot);
void RandomizeMin(Player* bot);
void IncreaseLevel(Player* bot);
void ScheduleTeleport(uint32 bot, uint32 time = 0);
void ScheduleChangeStrategy(uint32 bot, uint32 time = 0);
void HandleCommand(uint32 type, std::string const text, Player* fromPlayer, std::string channelName = "");
std::string const HandleRemoteCommand(std::string const request);
void OnPlayerLogout(Player* player);
void OnPlayerLogin(Player* player);
void OnPlayerLoginError(uint32 bot);
Player* GetRandomPlayer();
std::vector<Player*> GetPlayers() { return players; };
PlayerBotMap GetAllBots() { return playerBots; };
void PrintStats();
double GetBuyMultiplier(Player* bot);
double GetSellMultiplier(Player* bot);
void AddTradeDiscount(Player* bot, Player* master, int32 value);
void SetTradeDiscount(Player* bot, Player* master, uint32 value);
uint32 GetTradeDiscount(Player* bot, Player* master);
void Refresh(Player* bot);
void RandomTeleportForLevel(Player* bot);
void RandomTeleportGrindForLevel(Player* bot);
void RandomTeleportForRpg(Player* bot);
uint32 GetMaxAllowedBotCount();
bool ProcessBot(Player* player);
void Revive(Player* player);
void ChangeStrategy(Player* player);
void ChangeStrategyOnce(Player* player);
public:
uint32 activeBots = 0;
static bool HandlePlayerbotConsoleCommand(ChatHandler* handler, char const* args);
bool IsRandomBot(Player* bot);
bool IsRandomBot(ObjectGuid::LowType bot);
void Randomize(Player* bot);
void Clear(Player* bot);
void RandomizeFirst(Player* bot);
void RandomizeMin(Player* bot);
void IncreaseLevel(Player* bot);
void ScheduleTeleport(uint32 bot, uint32 time = 0);
void ScheduleChangeStrategy(uint32 bot, uint32 time = 0);
void HandleCommand(uint32 type, std::string const text, Player* fromPlayer, std::string channelName = "");
std::string const HandleRemoteCommand(std::string const request);
void OnPlayerLogout(Player* player);
void OnPlayerLogin(Player* player);
void OnPlayerLoginError(uint32 bot);
Player* GetRandomPlayer();
std::vector<Player*> GetPlayers() { return players; };
PlayerBotMap GetAllBots() { return playerBots; };
void PrintStats();
double GetBuyMultiplier(Player* bot);
double GetSellMultiplier(Player* bot);
void AddTradeDiscount(Player* bot, Player* master, int32 value);
void SetTradeDiscount(Player* bot, Player* master, uint32 value);
uint32 GetTradeDiscount(Player* bot, Player* master);
void Refresh(Player* bot);
void RandomTeleportForLevel(Player* bot);
void RandomTeleportGrindForLevel(Player* bot);
void RandomTeleportForRpg(Player* bot);
uint32 GetMaxAllowedBotCount();
bool ProcessBot(Player* player);
void Revive(Player* player);
void ChangeStrategy(Player* player);
void ChangeStrategyOnce(Player* player);
uint32 GetValue(Player* bot, std::string const type);
uint32 GetValue(uint32 bot, std::string const type);
std::string const GetData(uint32 bot, std::string const type);
void SetValue(uint32 bot, std::string const type, uint32 value, std::string const data = "");
void SetValue(Player* bot, std::string const type, uint32 value, std::string const data = "");
void Remove(Player* bot);
ObjectGuid const GetBattleMasterGUID(Player* bot, BattlegroundTypeId bgTypeId);
CreatureData const* GetCreatureDataByEntry(uint32 entry);
void LoadBattleMastersCache();
std::map<uint32, std::map<uint32, BattlegroundInfo>> BattlegroundData;
std::map<uint32, std::map<uint32, std::map<TeamId, uint32>>> VisualBots;
std::map<uint32, std::map<uint32, std::map<uint32, uint32>>> Supporters;
std::map<TeamId, std::vector<uint32>> LfgDungeons;
void CheckBgQueue();
void CheckLfgQueue();
void CheckPlayers();
void LogBattlegroundInfo();
uint32 GetValue(uint32 bot, std::string const type);
std::string const GetData(uint32 bot, std::string const type);
void SetValue(uint32 bot, std::string const type, uint32 value, std::string const data = "");
void SetValue(Player* bot, std::string const type, uint32 value, std::string const data = "");
void Remove(Player* bot);
ObjectGuid const GetBattleMasterGUID(Player* bot, BattlegroundTypeId bgTypeId);
CreatureData const* GetCreatureDataByEntry(uint32 entry);
void LoadBattleMastersCache();
std::map<uint32, std::map<uint32, BattlegroundInfo>> BattlegroundData;
std::map<uint32, std::map<uint32, std::map<TeamId, uint32>>> VisualBots;
std::map<uint32, std::map<uint32, std::map<uint32, uint32>>> Supporters;
std::map<TeamId, std::vector<uint32>> LfgDungeons;
void CheckBgQueue();
void CheckLfgQueue();
void CheckPlayers();
void LogBattlegroundInfo();
std::map<TeamId, std::map<BattlegroundTypeId, std::vector<uint32>>> getBattleMastersCache() { return BattleMastersCache; }
std::map<TeamId, std::map<BattlegroundTypeId, std::vector<uint32>>> getBattleMastersCache()
{
return BattleMastersCache;
}
float getActivityMod() { return activityMod; }
float getActivityPercentage() { return activityMod * 100.0f; }
void setActivityPercentage(float percentage) { activityMod = percentage / 100.0f; }
float getActivityMod() { return activityMod; }
float getActivityPercentage() { return activityMod * 100.0f; }
void setActivityPercentage(float percentage) { activityMod = percentage / 100.0f; }
protected:
void OnBotLoginInternal(Player* const bot) override;
protected:
void OnBotLoginInternal(Player* const bot) override;
private:
//pid values are set in constructor
botPID pid = botPID(1, 50, -50, 0, 0, 0);
float activityMod = 0.25;
uint32 GetEventValue(uint32 bot, std::string const event);
std::string const GetEventData(uint32 bot, std::string const event);
uint32 SetEventValue(uint32 bot, std::string const event, uint32 value, uint32 validIn, std::string const data = "");
void GetBots();
std::vector<uint32> GetBgBots(uint32 bracket);
time_t BgCheckTimer;
time_t LfgCheckTimer;
time_t PlayersCheckTimer;
uint32 AddRandomBots();
bool ProcessBot(uint32 bot);
void ScheduleRandomize(uint32 bot, uint32 time);
void RandomTeleport(Player* bot);
void RandomTeleport(Player* bot, std::vector<WorldLocation>& locs, bool hearth = false);
uint32 GetZoneLevel(uint16 mapId, float teleX, float teleY, float teleZ);
void PrepareTeleportCache();
typedef void(RandomPlayerbotMgr::*ConsoleCommandHandler)(Player*);
private:
// pid values are set in constructor
botPID pid = botPID(1, 50, -50, 0, 0, 0);
float activityMod = 0.25;
uint32 GetEventValue(uint32 bot, std::string const event);
std::string const GetEventData(uint32 bot, std::string const event);
uint32 SetEventValue(uint32 bot, std::string const event, uint32 value, uint32 validIn,
std::string const data = "");
void GetBots();
std::vector<uint32> GetBgBots(uint32 bracket);
time_t BgCheckTimer;
time_t LfgCheckTimer;
time_t PlayersCheckTimer;
uint32 AddRandomBots();
bool ProcessBot(uint32 bot);
void ScheduleRandomize(uint32 bot, uint32 time);
void RandomTeleport(Player* bot);
void RandomTeleport(Player* bot, std::vector<WorldLocation>& locs, bool hearth = false);
uint32 GetZoneLevel(uint16 mapId, float teleX, float teleY, float teleZ);
void PrepareTeleportCache();
typedef void (RandomPlayerbotMgr::*ConsoleCommandHandler)(Player*);
std::vector<Player*> players;
uint32 processTicks;
std::map<uint8, std::vector<WorldLocation>> locsPerLevelCache;
std::map<uint8, std::vector<WorldLocation>> bankerLocsPerLevelCache;
std::vector<Player*> players;
uint32 processTicks;
std::map<uint8, std::vector<WorldLocation>> locsPerLevelCache;
std::map<uint8, std::vector<WorldLocation>> bankerLocsPerLevelCache;
// std::map<uint32, std::vector<WorldLocation>> rpgLocsCache;
std::map<uint32, std::map<uint32, std::vector<WorldLocation>>> rpgLocsCacheLevel;
std::map<TeamId, std::map<BattlegroundTypeId, std::vector<uint32>>> BattleMastersCache;
std::map<uint32, std::map<std::string, CachedEvent>> eventCache;
std::list<uint32> currentBots;
uint32 bgBotsCount;
uint32 playersLevel;
PerformanceMonitorOperation* totalPmo;
// std::map<uint32, std::vector<WorldLocation>> rpgLocsCache;
std::map<uint32, std::map<uint32, std::vector<WorldLocation>>> rpgLocsCacheLevel;
std::map<TeamId, std::map<BattlegroundTypeId, std::vector<uint32>>> BattleMastersCache;
std::map<uint32, std::map<std::string, CachedEvent>> eventCache;
std::list<uint32> currentBots;
uint32 bgBotsCount;
uint32 playersLevel;
PerformanceMonitorOperation* totalPmo;
};
#define sRandomPlayerbotMgr RandomPlayerbotMgr::instance()

24
src/ServerFacade.cpp
View File

@@ -1,8 +1,10 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#include "ServerFacade.h"
#include "Playerbots.h"
#include "TargetedMovementGenerator.h"
@@ -15,7 +17,7 @@ float ServerFacade::GetDistance2d(Unit* unit, WorldObject* wo)
return std::round(dist * 10.0f) / 10.0f;
}
float ServerFacade::GetDistance2d(Unit *unit, float x, float y)
float ServerFacade::GetDistance2d(Unit* unit, float x, float y)
{
float dist = unit->GetDistance2d(x, y);
return std::round(dist * 10.0f) / 10.0f;
@@ -23,25 +25,19 @@ float ServerFacade::GetDistance2d(Unit *unit, float x, float y)
bool ServerFacade::IsDistanceLessThan(float dist1, float dist2)
{
//return dist1 - dist2 < sPlayerbotAIConfig->targetPosRecalcDistance;
// return dist1 - dist2 < sPlayerbotAIConfig->targetPosRecalcDistance;
return dist1 < dist2;
}
bool ServerFacade::IsDistanceGreaterThan(float dist1, float dist2)
{
//return dist1 - dist2 > sPlayerbotAIConfig->targetPosRecalcDistance;
// return dist1 - dist2 > sPlayerbotAIConfig->targetPosRecalcDistance;
return dist1 > dist2;
}
bool ServerFacade::IsDistanceGreaterOrEqualThan(float dist1, float dist2)
{
return !IsDistanceLessThan(dist1, dist2);
}
bool ServerFacade::IsDistanceGreaterOrEqualThan(float dist1, float dist2) { return !IsDistanceLessThan(dist1, dist2); }
bool ServerFacade::IsDistanceLessOrEqualThan(float dist1, float dist2)
{
return !IsDistanceGreaterThan(dist1, dist2);
}
bool ServerFacade::IsDistanceLessOrEqualThan(float dist1, float dist2) { return !IsDistanceGreaterThan(dist1, dist2); }
void ServerFacade::SetFacingTo(Player* bot, WorldObject* wo, bool force)
{
@@ -50,8 +46,8 @@ void ServerFacade::SetFacingTo(Player* bot, WorldObject* wo, bool force)
// bot->SetFacingTo(bot->GetAngle(wo));
// else
// {
bot->SetOrientation(angle);
bot->SendMovementFlagUpdate();
bot->SetOrientation(angle);
bot->SendMovementFlagUpdate();
// }
}

37
src/ServerFacade.h
View File

@@ -1,5 +1,6 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#ifndef _PLAYERBOT_SERVERFACADE_H
@@ -13,26 +14,26 @@ class WorldObject;
class ServerFacade
{
public:
ServerFacade() { };
virtual ~ServerFacade() { };
static ServerFacade* instance()
{
static ServerFacade instance;
return &instance;
}
public:
ServerFacade(){};
virtual ~ServerFacade(){};
static ServerFacade* instance()
{
static ServerFacade instance;
return &instance;
}
public:
float GetDistance2d(Unit* unit, WorldObject* wo);
float GetDistance2d(Unit* unit, float x, float y);
bool IsDistanceLessThan(float dist1, float dist2);
bool IsDistanceGreaterThan(float dist1, float dist2);
bool IsDistanceGreaterOrEqualThan(float dist1, float dist2);
bool IsDistanceLessOrEqualThan(float dist1, float dist2);
public:
float GetDistance2d(Unit* unit, WorldObject* wo);
float GetDistance2d(Unit* unit, float x, float y);
bool IsDistanceLessThan(float dist1, float dist2);
bool IsDistanceGreaterThan(float dist1, float dist2);
bool IsDistanceGreaterOrEqualThan(float dist1, float dist2);
bool IsDistanceLessOrEqualThan(float dist1, float dist2);
void SetFacingTo(Player* bot, WorldObject* wo, bool force = false);
void SetFacingTo(Player* bot, WorldObject* wo, bool force = false);
Unit* GetChaseTarget(Unit* target);
Unit* GetChaseTarget(Unit* target);
};
#define sServerFacade ServerFacade::instance()

95
src/Talentspec.cpp
View File

@@ -1,8 +1,10 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#include "Talentspec.h"
#include "Event.h"
#include "Playerbots.h"
@@ -11,7 +13,7 @@ uint32 TalentSpec::TalentListEntry::tabPage() const
return talentTabInfo->TalentTabID == 41 ? 1 : talentTabInfo->tabpage;
}
//Checks a talent link on basic validity.
// Checks a talent link on basic validity.
bool TalentSpec::CheckTalentLink(std::string const link, std::ostringstream* out)
{
std::string const validChar = "-";
@@ -50,10 +52,7 @@ uint32 TalentSpec::PointstoLevel(uint32 points) const
return uint32(ceil(points / sWorld->getRate(RATE_TALENT))) + 9;
}
TalentSpec::TalentSpec(uint32 classMask)
{
GetTalents(classMask);
}
TalentSpec::TalentSpec(uint32 classMask) { GetTalents(classMask); }
TalentSpec::TalentSpec(TalentSpec* base, std::string const link)
{
@@ -73,7 +72,7 @@ TalentSpec::TalentSpec(Player* bot, std::string const link)
ReadTalents(link);
}
//Check the talentspec for errors.
// Check the talentspec for errors.
bool TalentSpec::CheckTalents(uint32 level, std::ostringstream* out)
{
for (auto& entry : talents)
@@ -81,7 +80,8 @@ bool TalentSpec::CheckTalents(uint32 level, std::ostringstream* out)
if (entry.rank > entry.maxRank)
{
SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry.talentInfo->RankID[0]);
*out << "spec is not for this class. " << spellInfo->SpellName[0] << " has " << (entry.rank - entry.maxRank) << " points above max rank.";
*out << "spec is not for this class. " << spellInfo->SpellName[0] << " has " << (entry.rank - entry.maxRank)
<< " points above max rank.";
return false;
}
@@ -103,7 +103,8 @@ bool TalentSpec::CheckTalents(uint32 level, std::ostringstream* out)
if (!found)
{
SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry.talentInfo->RankID[0]);
*out << "spec is invalid. Talent:" << spellInfo->SpellName[0] << " needs: " << spellInfodep->SpellName[0] << " at rank: " << entry.talentInfo->DependsOnRank;
*out << "spec is invalid. Talent:" << spellInfo->SpellName[0]
<< " needs: " << spellInfodep->SpellName[0] << " at rank: " << entry.talentInfo->DependsOnRank;
return false;
}
}
@@ -120,7 +121,8 @@ bool TalentSpec::CheckTalents(uint32 level, std::ostringstream* out)
if (entry.rank > 0 && entry.talentInfo->Row * 5 > points)
{
SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry.talentInfo->RankID[0]);
*out << "spec is is invalid. Talent " << spellInfo->SpellName[0] << " is selected with only " << points << " in row below it.";
*out << "spec is is invalid. Talent " << spellInfo->SpellName[0] << " is selected with only " << points
<< " in row below it.";
return false;
}
@@ -137,17 +139,18 @@ bool TalentSpec::CheckTalents(uint32 level, std::ostringstream* out)
return true;
}
//Set the talents for the bots to the current spec.
// Set the talents for the bots to the current spec.
void TalentSpec::ApplyTalents(Player* bot, std::ostringstream* out)
{
for (auto& entry : talents) {
for (auto& entry : talents)
{
if (entry.rank == 0)
continue;
bot->LearnTalent(entry.talentInfo->TalentID, entry.rank - 1);
}
}
//Returns a base talentlist for a class.
// Returns a base talentlist for a class.
void TalentSpec::GetTalents(uint32 classMask)
{
TalentListEntry entry;
@@ -185,7 +188,7 @@ void TalentSpec::GetTalents(uint32 classMask)
SortTalents(talents, SORT_BY_DEFAULT);
}
//Sorts a talent list by page, row, column.
// Sorts a talent list by page, row, column.
bool sortTalentMap(TalentSpec::TalentListEntry i, TalentSpec::TalentListEntry j, uint32* tabSort)
{
uint32 itab = i.tabPage();
@@ -208,38 +211,35 @@ bool sortTalentMap(TalentSpec::TalentListEntry i, TalentSpec::TalentListEntry j,
return false;
}
void TalentSpec::SortTalents(uint32 sortBy)
{
SortTalents(talents, sortBy);
}
void TalentSpec::SortTalents(uint32 sortBy) { SortTalents(talents, sortBy); }
//Sort the talents.
// Sort the talents.
void TalentSpec::SortTalents(std::vector<TalentListEntry>& talents, uint32 sortBy)
{
switch (sortBy)
{
case SORT_BY_DEFAULT:
{
uint32 tabSort[] = { 0, 1, 2 };
std::sort(talents.begin(), talents.end(), [&tabSort](TalentSpec::TalentListEntry i, TalentSpec::TalentListEntry j)
{
return sortTalentMap(i, j, tabSort);
});
uint32 tabSort[] = {0, 1, 2};
std::sort(talents.begin(), talents.end(),
[&tabSort](TalentSpec::TalentListEntry i, TalentSpec::TalentListEntry j)
{ return sortTalentMap(i, j, tabSort); });
break;
}
case SORT_BY_POINTS_TREE:
{
uint32 tabSort[] = { GetTalentPoints(talents, 0) * 100 - urand(0, 99), GetTalentPoints(talents, 1) * 100 - urand(0, 99), GetTalentPoints(talents, 2) * 100 - urand(0, 99) };
std::sort(talents.begin(), talents.end(), [&tabSort](TalentSpec::TalentListEntry i, TalentSpec::TalentListEntry j)
{
return sortTalentMap(i, j, tabSort);
});
uint32 tabSort[] = {GetTalentPoints(talents, 0) * 100 - urand(0, 99),
GetTalentPoints(talents, 1) * 100 - urand(0, 99),
GetTalentPoints(talents, 2) * 100 - urand(0, 99)};
std::sort(talents.begin(), talents.end(),
[&tabSort](TalentSpec::TalentListEntry i, TalentSpec::TalentListEntry j)
{ return sortTalentMap(i, j, tabSort); });
break;
}
}
}
//Set the talent ranks to the current rank of the player.
// Set the talent ranks to the current rank of the player.
void TalentSpec::ReadTalents(Player* bot)
{
for (auto& entry : talents)
@@ -257,7 +257,7 @@ void TalentSpec::ReadTalents(Player* bot)
}
}
//Set the talent ranks to the ranks of the link.
// Set the talent ranks to the ranks of the link.
void TalentSpec::ReadTalents(std::string const link)
{
uint32 rank = 0;
@@ -308,7 +308,7 @@ void TalentSpec::ReadTalents(std::string const link)
}
}
//Returns only a specific tree from a talent list.
// Returns only a specific tree from a talent list.
std::vector<TalentSpec::TalentListEntry> TalentSpec::GetTalentTree(uint32 tabpage)
{
std::vector<TalentListEntry> retList;
@@ -320,12 +320,9 @@ std::vector<TalentSpec::TalentListEntry> TalentSpec::GetTalentTree(uint32 tabpag
return std::move(retList);
}
uint32 TalentSpec::GetTalentPoints(int32 tabpage)
{
return GetTalentPoints(talents, tabpage);
};
uint32 TalentSpec::GetTalentPoints(int32 tabpage) { return GetTalentPoints(talents, tabpage); };
//Counts the point in a talent list.
// Counts the point in a talent list.
uint32 TalentSpec::GetTalentPoints(std::vector<TalentListEntry>& talents, int32 tabpage)
{
if (tabpage == -1)
@@ -339,7 +336,7 @@ uint32 TalentSpec::GetTalentPoints(std::vector<TalentListEntry>& talents, int32
return tPoints;
}
//Generates a wow-head link from a talent list.
// Generates a wow-head link from a talent list.
std::string const TalentSpec::GetTalentLink()
{
std::string link = "";
@@ -403,7 +400,7 @@ std::string const TalentSpec::FormatSpec(Player* bot)
uint8 cls = bot->getClass();
std::ostringstream out;
//out << chathelper:: specs[cls][highestTree()] << " (";
// out << chathelper:: specs[cls][highestTree()] << " (";
uint32 c0 = GetTalentPoints(0);
uint32 c1 = GetTalentPoints(1);
@@ -416,7 +413,7 @@ std::string const TalentSpec::FormatSpec(Player* bot)
return out.str();
}
//Removes talentpoints to match the level
// Removes talentpoints to match the level
void TalentSpec::CropTalents(uint32 level)
{
if (points <= LeveltoPoints(level))
@@ -436,8 +433,10 @@ void TalentSpec::CropTalents(uint32 level)
SortTalents(talents, SORT_BY_DEFAULT);
}
//Substracts ranks. Follows the sorting of the newList.
std::vector<TalentSpec::TalentListEntry> TalentSpec::SubTalentList(std::vector<TalentListEntry>& oldList, std::vector<TalentListEntry>& newList, uint32 reverse = SUBSTRACT_OLD_NEW)
// Substracts ranks. Follows the sorting of the newList.
std::vector<TalentSpec::TalentListEntry> TalentSpec::SubTalentList(std::vector<TalentListEntry>& oldList,
std::vector<TalentListEntry>& newList,
uint32 reverse = SUBSTRACT_OLD_NEW)
{
std::vector<TalentSpec::TalentListEntry> deltaList = newList;
@@ -466,35 +465,35 @@ bool TalentSpec::isEarlierVersionOf(TalentSpec& newSpec)
return true;
}
//Modifies current talents towards new talents up to a maxium of points.
// Modifies current talents towards new talents up to a maxium of points.
void TalentSpec::ShiftTalents(TalentSpec* currentSpec, uint32 level)
{
uint32 currentPoints = currentSpec->GetTalentPoints();
if (points >= LeveltoPoints(level)) //We have no more points to spend. Better reset and crop
if (points >= LeveltoPoints(level)) // We have no more points to spend. Better reset and crop
{
CropTalents(level);
return;
}
SortTalents(SORT_BY_POINTS_TREE); //Apply points first to the largest new tree.
SortTalents(SORT_BY_POINTS_TREE); // Apply points first to the largest new tree.
std::vector<TalentSpec::TalentListEntry> deltaList = SubTalentList(currentSpec->talents, talents);
for (auto& entry : deltaList)
{
if (entry.rank < 0) //We have to remove talents. Might as well reset and crop the new list.
if (entry.rank < 0) // We have to remove talents. Might as well reset and crop the new list.
{
CropTalents(level);
return;
}
}
//Start from the current spec.
// Start from the current spec.
talents = currentSpec->talents;
for (auto& entry : deltaList)
{
if (entry.rank + points > LeveltoPoints(level)) //Running out of points. Only apply what we have left.
if (entry.rank + points > LeveltoPoints(level)) // Running out of points. Only apply what we have left.
entry.rank = std::max(0, std::abs(int32(LeveltoPoints(level) - points)));
for (auto& subentry : talents)

124
src/Talentspec.h
View File

@@ -1,5 +1,6 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#ifndef _PLAYERBOT_TALENTSPEC_H
@@ -21,85 +22,86 @@ struct TalentTabEntry;
// unused currently
class TalentSpec
{
public:
struct TalentListEntry
{
uint32 entry;
uint32 rank;
uint32 maxRank;
TalentEntry const* talentInfo;
TalentTabEntry const* talentTabInfo;
uint32 tabPage() const;
};
public:
struct TalentListEntry
{
uint32 entry;
uint32 rank;
uint32 maxRank;
TalentEntry const* talentInfo;
TalentTabEntry const* talentTabInfo;
uint32 tabPage() const;
};
TalentSpec() { };
virtual ~TalentSpec() { }
TalentSpec(uint32 classMask);
TalentSpec(TalentSpec* base, std::string const link);
TalentSpec(Player* bot);
TalentSpec(Player* bot, std::string const link);
TalentSpec(){};
virtual ~TalentSpec() {}
TalentSpec(uint32 classMask);
TalentSpec(TalentSpec* base, std::string const link);
TalentSpec(Player* bot);
TalentSpec(Player* bot, std::string const link);
uint32 points = 0;
std::vector<TalentListEntry> talents;
uint32 points = 0;
std::vector<TalentListEntry> talents;
bool CheckTalentLink(std::string const link, std::ostringstream* out);
virtual bool CheckTalents(uint32 maxPoints, std::ostringstream* out);
void CropTalents(uint32 level);
void ShiftTalents(TalentSpec* oldTalents, uint32 level);
void ApplyTalents(Player* bot, std::ostringstream* out);
bool CheckTalentLink(std::string const link, std::ostringstream* out);
virtual bool CheckTalents(uint32 maxPoints, std::ostringstream* out);
void CropTalents(uint32 level);
void ShiftTalents(TalentSpec* oldTalents, uint32 level);
void ApplyTalents(Player* bot, std::ostringstream* out);
uint32 GetTalentPoints(std::vector<TalentListEntry>& talents, int32 tabpage = -1);
uint32 GetTalentPoints(int32 tabpage = -1);
bool isEarlierVersionOf(TalentSpec& newSpec);
uint32 GetTalentPoints(std::vector<TalentListEntry>& talents, int32 tabpage = -1);
uint32 GetTalentPoints(int32 tabpage = -1);
bool isEarlierVersionOf(TalentSpec& newSpec);
std::string const GetTalentLink();
uint32 highestTree();
std::string const FormatSpec(Player* bot);
std::string const GetTalentLink();
uint32 highestTree();
std::string const FormatSpec(Player* bot);
protected:
uint32 LeveltoPoints(uint32 level) const;
uint32 PointstoLevel(uint32 points) const;
void GetTalents(uint32 classMask);
void SortTalents(std::vector<TalentListEntry>& talents, uint32 sortBy);
void SortTalents(uint32 sortBy);
protected:
uint32 LeveltoPoints(uint32 level) const;
uint32 PointstoLevel(uint32 points) const;
void GetTalents(uint32 classMask);
void SortTalents(std::vector<TalentListEntry>& talents, uint32 sortBy);
void SortTalents(uint32 sortBy);
void ReadTalents(Player* bot);
void ReadTalents(std::string const link);
void ReadTalents(Player* bot);
void ReadTalents(std::string const link);
std::vector<TalentListEntry> GetTalentTree(uint32 tabpage);
std::vector<TalentListEntry> SubTalentList(std::vector<TalentListEntry>& oldList, std::vector<TalentListEntry>& newList, uint32 reverse);
std::vector<TalentListEntry> GetTalentTree(uint32 tabpage);
std::vector<TalentListEntry> SubTalentList(std::vector<TalentListEntry>& oldList,
std::vector<TalentListEntry>& newList, uint32 reverse);
};
class TalentPath
{
public:
TalentPath(uint32 pathId, std::string const pathName, uint32 pathProbability)
{
id = pathId;
name = pathName;
probability = pathProbability;
};
public:
TalentPath(uint32 pathId, std::string const pathName, uint32 pathProbability)
{
id = pathId;
name = pathName;
probability = pathProbability;
};
uint32 id = 0;
std::string name = "";
uint32 probability = 100;
std::vector<TalentSpec> talentSpec;
uint32 id = 0;
std::string name = "";
uint32 probability = 100;
std::vector<TalentSpec> talentSpec;
};
class ClassSpecs
{
public:
ClassSpecs() { };
ClassSpecs(uint32 specsClassMask)
{
classMask = specsClassMask;
baseSpec = TalentSpec(specsClassMask);
}
public:
ClassSpecs(){};
ClassSpecs(uint32 specsClassMask)
{
classMask = specsClassMask;
baseSpec = TalentSpec(specsClassMask);
}
uint32 classMask = 0;
TalentSpec baseSpec;
uint32 classMask = 0;
TalentSpec baseSpec;
std::vector<TalentPath> talentPath;
std::vector<TalentPath> talentPath;
};
#endif

1083
src/TravelMgr.cpp
View File

File diff suppressed because it is too large Load Diff

1380
src/TravelMgr.h
View File

File diff suppressed because it is too large Load Diff

537
src/TravelNode.cpp
View File

File diff suppressed because it is too large Load Diff

881
src/TravelNode.h
View File

File diff suppressed because it is too large Load Diff

32
src/cs_playerbots.cpp
View File

@@ -13,39 +13,36 @@
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "BattleGroundTactics.h"
#include "Chat.h"
#include "GuildTaskMgr.h"
#include "PerformanceMonitor.h"
#include "PlayerbotMgr.h"
#include "RandomPlayerbotMgr.h"
#include "ScriptMgr.h"
#include "BattleGroundTactics.h"
using namespace Acore::ChatCommands;
class playerbots_commandscript : public CommandScript
{
public:
playerbots_commandscript() : CommandScript("playerbots_commandscript") { }
playerbots_commandscript() : CommandScript("playerbots_commandscript") {}
ChatCommandTable GetCommands() const override
{
static ChatCommandTable playerbotsDebugCommandTable =
{
{ "bg", HandleDebugBGCommand, SEC_GAMEMASTER, Console::Yes },
static ChatCommandTable playerbotsDebugCommandTable = {
{"bg", HandleDebugBGCommand, SEC_GAMEMASTER, Console::Yes},
};
static ChatCommandTable playerbotsCommandTable =
{
{ "bot", HandlePlayerbotCommand, SEC_PLAYER, Console::No },
{ "gtask", HandleGuildTaskCommand, SEC_GAMEMASTER, Console::Yes },
{ "pmon", HandlePerfMonCommand, SEC_GAMEMASTER, Console::Yes },
{ "rndbot", HandleRandomPlayerbotCommand, SEC_GAMEMASTER, Console::Yes },
{ "debug", playerbotsDebugCommandTable },
static ChatCommandTable playerbotsCommandTable = {
{"bot", HandlePlayerbotCommand, SEC_PLAYER, Console::No},
{"gtask", HandleGuildTaskCommand, SEC_GAMEMASTER, Console::Yes},
{"pmon", HandlePerfMonCommand, SEC_GAMEMASTER, Console::Yes},
{"rndbot", HandleRandomPlayerbotCommand, SEC_GAMEMASTER, Console::Yes},
{"debug", playerbotsDebugCommandTable},
};
static ChatCommandTable commandTable =
{
{ "playerbots", playerbotsCommandTable },
static ChatCommandTable commandTable = {
{"playerbots", playerbotsCommandTable},
};
return commandTable;
@@ -96,7 +93,4 @@ public:
}
};
void AddSC_playerbots_commandscript()
{
new playerbots_commandscript();
}
void AddSC_playerbots_commandscript() { new playerbots_commandscript(); }

5
src/playerbots_loader.cpp
View File

@@ -19,7 +19,4 @@
void AddPlayerbotsScripts();
// Add all
void Addmod_playerbotsScripts()
{
AddPlayerbotsScripts();
}
void Addmod_playerbotsScripts() { AddPlayerbotsScripts(); }

28
src/strategy/Action.cpp
View File

@@ -1,8 +1,10 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#include "Action.h"
#include "Playerbots.h"
#include "Timer.h"
@@ -66,8 +68,7 @@ NextAction** NextAction::array(uint32 nil, ...)
{
cur = va_arg(vl, NextAction*);
++size;
}
while (cur);
} while (cur);
va_end(vl);
@@ -85,28 +86,19 @@ void NextAction::destroy(NextAction** actions)
if (!actions)
return;
for (uint32 i=0; actions[i]; i++)
for (uint32 i = 0; actions[i]; i++)
delete actions[i];
delete[] actions;
}
Value<Unit*>* Action::GetTargetValue()
{
return context->GetValue<Unit*>(GetTargetName());
}
Value<Unit*>* Action::GetTargetValue() { return context->GetValue<Unit*>(GetTargetName()); }
Unit* Action::GetTarget()
{
return GetTargetValue()->Get();
}
Unit* Action::GetTarget() { return GetTargetValue()->Get(); }
ActionBasket::ActionBasket(ActionNode* action, float relevance, bool skipPrerequisites, Event event) :
action(action), relevance(relevance), skipPrerequisites(skipPrerequisites), event(event), created(getMSTime())
ActionBasket::ActionBasket(ActionNode* action, float relevance, bool skipPrerequisites, Event event)
: action(action), relevance(relevance), skipPrerequisites(skipPrerequisites), event(event), created(getMSTime())
{
}
bool ActionBasket::isExpired(uint32 msecs)
{
return getMSTime() - created >= msecs;
}
bool ActionBasket::isExpired(uint32 msecs) { return getMSTime() - created >= msecs; }

168
src/strategy/Action.h
View File

@@ -1,5 +1,6 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#ifndef _PLAYERBOT_ACTION_H
@@ -15,108 +16,119 @@ class Unit;
class NextAction
{
public:
NextAction(std::string const name, float relevance = 0.0f) : relevance(relevance), name(name) { } // name after relevance - whipowill
NextAction(NextAction const& o) : relevance(o.relevance), name(o.name) { } // name after relevance - whipowill
public:
NextAction(std::string const name, float relevance = 0.0f)
: relevance(relevance), name(name) {} // name after relevance - whipowill
NextAction(NextAction const& o) : relevance(o.relevance), name(o.name) {} // name after relevance - whipowill
std::string const getName() { return name; }
float getRelevance() {return relevance;}
std::string const getName() { return name; }
float getRelevance() { return relevance; }
static uint32 size(NextAction** actions);
static NextAction** clone(NextAction** actions);
static NextAction** merge(NextAction** what, NextAction** with);
static NextAction** array(uint32 nil,...);
static void destroy(NextAction** actions);
static uint32 size(NextAction** actions);
static NextAction** clone(NextAction** actions);
static NextAction** merge(NextAction** what, NextAction** with);
static NextAction** array(uint32 nil, ...);
static void destroy(NextAction** actions);
private:
float relevance;
std::string const name;
private:
float relevance;
std::string const name;
};
class Action : public AiNamedObject
{
public:
enum class ActionThreatType
{
None = 0,
Single = 1,
Aoe = 2
};
public:
enum class ActionThreatType
{
None = 0,
Single = 1,
Aoe = 2
};
Action(PlayerbotAI* botAI, std::string const name = "action") : AiNamedObject(botAI, name), verbose(false) { } // verbose after ainamedobject - whipowill
virtual ~Action(void) { }
Action(PlayerbotAI* botAI, std::string const name = "action")
: AiNamedObject(botAI, name), verbose(false) {} // verbose after ainamedobject - whipowill
virtual ~Action(void) {}
virtual bool Execute([[maybe_unused]] Event event) { return true; }
virtual bool isPossible() { return true; }
virtual bool isUseful() { return true; }
virtual NextAction** getPrerequisites() { return nullptr; }
virtual NextAction** getAlternatives() { return nullptr; }
virtual NextAction** getContinuers() { return nullptr; }
virtual ActionThreatType getThreatType() { return ActionThreatType::None; }
void Update() { }
void Reset() { }
virtual Unit* GetTarget();
virtual Value<Unit*>* GetTargetValue();
virtual std::string const GetTargetName() { return "self target"; }
void MakeVerbose() { verbose = true; }
void setRelevance(uint32 relevance1) { relevance = relevance1; };
virtual float getRelevance() { return relevance; }
virtual bool Execute([[maybe_unused]] Event event) { return true; }
virtual bool isPossible() { return true; }
virtual bool isUseful() { return true; }
virtual NextAction** getPrerequisites() { return nullptr; }
virtual NextAction** getAlternatives() { return nullptr; }
virtual NextAction** getContinuers() { return nullptr; }
virtual ActionThreatType getThreatType() { return ActionThreatType::None; }
void Update() {}
void Reset() {}
virtual Unit* GetTarget();
virtual Value<Unit*>* GetTargetValue();
virtual std::string const GetTargetName() { return "self target"; }
void MakeVerbose() { verbose = true; }
void setRelevance(uint32 relevance1) { relevance = relevance1; };
virtual float getRelevance() { return relevance; }
protected:
bool verbose;
float relevance = 0;
protected:
bool verbose;
float relevance = 0;
};
class ActionNode
{
public:
ActionNode(std::string const name, NextAction** prerequisites = nullptr, NextAction** alternatives = nullptr, NextAction** continuers = nullptr) :
name(name), action(nullptr), continuers(continuers), alternatives(alternatives), prerequisites(prerequisites) { } // reorder arguments - whipowill
public:
ActionNode(std::string const name, NextAction** prerequisites = nullptr, NextAction** alternatives = nullptr,
NextAction** continuers = nullptr)
: name(name), action(nullptr), continuers(continuers), alternatives(alternatives), prerequisites(prerequisites)
{
} // reorder arguments - whipowill
virtual ~ActionNode()
{
NextAction::destroy(prerequisites);
NextAction::destroy(alternatives);
NextAction::destroy(continuers);
}
virtual ~ActionNode()
{
NextAction::destroy(prerequisites);
NextAction::destroy(alternatives);
NextAction::destroy(continuers);
}
Action* getAction() { return action; }
void setAction(Action* action) { this->action = action; }
std::string const getName() { return name; }
Action* getAction() { return action; }
void setAction(Action* action) { this->action = action; }
std::string const getName() { return name; }
NextAction** getContinuers() { return NextAction::merge(NextAction::clone(continuers), action->getContinuers()); }
NextAction** getAlternatives() { return NextAction::merge(NextAction::clone(alternatives), action->getAlternatives()); }
NextAction** getPrerequisites() { return NextAction::merge(NextAction::clone(prerequisites), action->getPrerequisites()); }
NextAction** getContinuers() { return NextAction::merge(NextAction::clone(continuers), action->getContinuers()); }
NextAction** getAlternatives()
{
return NextAction::merge(NextAction::clone(alternatives), action->getAlternatives());
}
NextAction** getPrerequisites()
{
return NextAction::merge(NextAction::clone(prerequisites), action->getPrerequisites());
}
private:
std::string const name;
Action* action;
NextAction** continuers;
NextAction** alternatives;
NextAction** prerequisites;
private:
std::string const name;
Action* action;
NextAction** continuers;
NextAction** alternatives;
NextAction** prerequisites;
};
class ActionBasket
{
public:
ActionBasket(ActionNode* action, float relevance, bool skipPrerequisites, Event event);
public:
ActionBasket(ActionNode* action, float relevance, bool skipPrerequisites, Event event);
virtual ~ActionBasket(void) { }
virtual ~ActionBasket(void) {}
float getRelevance() {return relevance;}
ActionNode* getAction() {return action;}
Event getEvent() { return event; }
bool isSkipPrerequisites() { return skipPrerequisites; }
void AmendRelevance(float k) { relevance *= k; }
void setRelevance(float relevance) { this->relevance = relevance; }
bool isExpired(uint32 msecs);
float getRelevance() { return relevance; }
ActionNode* getAction() { return action; }
Event getEvent() { return event; }
bool isSkipPrerequisites() { return skipPrerequisites; }
void AmendRelevance(float k) { relevance *= k; }
void setRelevance(float relevance) { this->relevance = relevance; }
bool isExpired(uint32 msecs);
private:
ActionNode* action;
float relevance;
bool skipPrerequisites;
Event event;
uint32 created;
private:
ActionNode* action;
float relevance;
bool skipPrerequisites;
Event event;
uint32 created;
};
#endif

12
src/strategy/AiObject.cpp
View File

@@ -1,15 +1,15 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#include "AiObject.h"
#include "Playerbots.h"
AiObject::AiObject(PlayerbotAI* botAI) : PlayerbotAIAware(botAI), bot(botAI->GetBot()), context(botAI->GetAiObjectContext()), chat(botAI->GetChatHelper())
AiObject::AiObject(PlayerbotAI* botAI)
: PlayerbotAIAware(botAI), bot(botAI->GetBot()), context(botAI->GetAiObjectContext()), chat(botAI->GetChatHelper())
{
}
Player* AiObject::GetMaster()
{
return botAI->GetMaster();
}
Player* AiObject::GetMaster() { return botAI->GetMaster(); }

797
src/strategy/AiObject.h
View File

@@ -1,5 +1,6 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#ifndef _PLAYERBOT_AIOBJECT_H
@@ -15,26 +16,26 @@ class PlayerbotAI;
class AiObject : public PlayerbotAIAware
{
public:
AiObject(PlayerbotAI* botAI);
public:
AiObject(PlayerbotAI* botAI);
protected:
Player* bot;
Player* GetMaster();
AiObjectContext* context;
ChatHelper* chat;
protected:
Player* bot;
Player* GetMaster();
AiObjectContext* context;
ChatHelper* chat;
};
class AiNamedObject : public AiObject
{
public:
AiNamedObject(PlayerbotAI* botAI, std::string const name) : AiObject(botAI), name(name) { }
public:
AiNamedObject(PlayerbotAI* botAI, std::string const name) : AiObject(botAI), name(name) {}
public:
virtual std::string const getName() { return name; }
public:
virtual std::string const getName() { return name; }
protected:
std::string const name;
protected:
std::string const name;
};
//
@@ -44,475 +45,469 @@ class AiNamedObject : public AiObject
#define NEXT_TRIGGERS(name, relevance) \
virtual NextAction* getNextAction() { return new NextAction(name, relevance); }
#define BEGIN_TRIGGER(clazz, super) \
class clazz : public super \
{ \
public: \
clazz(PlayerbotAI* botAI) : super(botAI) { } \
bool IsActive() override; \
#define BEGIN_TRIGGER(clazz, super) \
class clazz : public super \
{ \
public: \
clazz(PlayerbotAI* botAI) : super(botAI) {} \
bool IsActive() override;
#define END_TRIGGER() \
};
} \
;
#define BUFF_TRIGGER(clazz, spell) \
class clazz : public BuffTrigger \
{ \
public: \
clazz(PlayerbotAI* botAI) : BuffTrigger(botAI, spell) { } \
}
#define BUFF_TRIGGER(clazz, spell) \
class clazz : public BuffTrigger \
{ \
public: \
clazz(PlayerbotAI* botAI) : BuffTrigger(botAI, spell) {} \
}
#define BUFF_TRIGGER_A(clazz, spell) \
class clazz : public BuffTrigger \
{ \
public: \
clazz(PlayerbotAI* botAI) : BuffTrigger(botAI, spell) { } \
bool IsActive() override; \
}
#define BUFF_TRIGGER_A(clazz, spell) \
class clazz : public BuffTrigger \
{ \
public: \
clazz(PlayerbotAI* botAI) : BuffTrigger(botAI, spell) {} \
bool IsActive() override; \
}
#define BUFF_PARTY_TRIGGER(clazz, spell) \
class clazz : public BuffOnPartyTrigger \
{ \
public: \
clazz(PlayerbotAI* botAI) : BuffOnPartyTrigger(botAI, spell) { } \
}
#define BUFF_PARTY_TRIGGER(clazz, spell) \
class clazz : public BuffOnPartyTrigger \
{ \
public: \
clazz(PlayerbotAI* botAI) : BuffOnPartyTrigger(botAI, spell) {} \
}
#define BUFF_PARTY_TRIGGER_A(clazz, spell) \
class clazz : public BuffOnPartyTrigger \
{ \
public: \
clazz(PlayerbotAI* botAI) : BuffOnPartyTrigger(botAI, spell) { } \
bool IsActive() override; \
}
#define BUFF_PARTY_TRIGGER_A(clazz, spell) \
class clazz : public BuffOnPartyTrigger \
{ \
public: \
clazz(PlayerbotAI* botAI) : BuffOnPartyTrigger(botAI, spell) {} \
bool IsActive() override; \
}
#define DEBUFF_TRIGGER(clazz, spell) \
class clazz : public DebuffTrigger \
{ \
public: \
clazz(PlayerbotAI* botAI) : DebuffTrigger(botAI, spell) { } \
}
#define DEBUFF_TRIGGER(clazz, spell) \
class clazz : public DebuffTrigger \
{ \
public: \
clazz(PlayerbotAI* botAI) : DebuffTrigger(botAI, spell) {} \
}
#define DEBUFF_CHECKISOWNER_TRIGGER(clazz, spell) \
class clazz : public DebuffTrigger \
{ \
public: \
clazz(PlayerbotAI* botAI) : DebuffTrigger(botAI, spell, 1, true) { } \
}
#define DEBUFF_CHECKISOWNER_TRIGGER(clazz, spell) \
class clazz : public DebuffTrigger \
{ \
public: \
clazz(PlayerbotAI* botAI) : DebuffTrigger(botAI, spell, 1, true) {} \
}
#define DEBUFF_TRIGGER_A(clazz, spell) \
class clazz : public DebuffTrigger \
{ \
public: \
clazz(PlayerbotAI* botAI) : DebuffTrigger(botAI, spell) { } \
bool IsActive() override; \
}
#define DEBUFF_TRIGGER_A(clazz, spell) \
class clazz : public DebuffTrigger \
{ \
public: \
clazz(PlayerbotAI* botAI) : DebuffTrigger(botAI, spell) {} \
bool IsActive() override; \
}
#define DEBUFF_ENEMY_TRIGGER(clazz, spell) \
class clazz : public DebuffOnAttackerTrigger \
{ \
public: \
clazz(PlayerbotAI* botAI) : DebuffOnAttackerTrigger(botAI, spell) { } \
}
#define DEBUFF_ENEMY_TRIGGER(clazz, spell) \
class clazz : public DebuffOnAttackerTrigger \
{ \
public: \
clazz(PlayerbotAI* botAI) : DebuffOnAttackerTrigger(botAI, spell) {} \
}
#define DEBUFF_ENEMY_TRIGGER_A(clazz, spell) \
class clazz : public DebuffOnAttackerTrigger \
{ \
public: \
clazz(PlayerbotAI* botAI) : DebuffOnAttackerTrigger(botAI, spell) { } \
bool IsActive() override; \
}
#define DEBUFF_ENEMY_TRIGGER_A(clazz, spell) \
class clazz : public DebuffOnAttackerTrigger \
{ \
public: \
clazz(PlayerbotAI* botAI) : DebuffOnAttackerTrigger(botAI, spell) {} \
bool IsActive() override; \
}
#define CURE_TRIGGER(clazz, spell, dispel) \
class clazz : public NeedCureTrigger \
{ \
public: \
clazz(PlayerbotAI* botAI) : NeedCureTrigger(botAI, spell, dispel) { } \
}
#define CURE_TRIGGER(clazz, spell, dispel) \
class clazz : public NeedCureTrigger \
{ \
public: \
clazz(PlayerbotAI* botAI) : NeedCureTrigger(botAI, spell, dispel) {} \
}
#define CURE_PARTY_TRIGGER(clazz, spell, dispel) \
class clazz : public PartyMemberNeedCureTrigger \
{ \
public: \
clazz(PlayerbotAI* botAI) : PartyMemberNeedCureTrigger(botAI, spell, dispel) { } \
}
#define CURE_PARTY_TRIGGER(clazz, spell, dispel) \
class clazz : public PartyMemberNeedCureTrigger \
{ \
public: \
clazz(PlayerbotAI* botAI) : PartyMemberNeedCureTrigger(botAI, spell, dispel) {} \
}
#define CAN_CAST_TRIGGER(clazz, spell) \
class clazz : public SpellCanBeCastTrigger \
{ \
public: \
clazz(PlayerbotAI* botAI) : SpellCanBeCastTrigger(botAI, spell) { } \
}
#define CAN_CAST_TRIGGER(clazz, spell) \
class clazz : public SpellCanBeCastTrigger \
{ \
public: \
clazz(PlayerbotAI* botAI) : SpellCanBeCastTrigger(botAI, spell) {} \
}
#define CAN_CAST_TRIGGER_A(clazz, spell) \
class clazz : public SpellCanBeCastTrigger \
{ \
public: \
clazz(PlayerbotAI* botAI) : SpellCanBeCastTrigger(botAI, spell) { } \
bool IsActive() override; \
}
#define CAN_CAST_TRIGGER_A(clazz, spell) \
class clazz : public SpellCanBeCastTrigger \
{ \
public: \
clazz(PlayerbotAI* botAI) : SpellCanBeCastTrigger(botAI, spell) {} \
bool IsActive() override; \
}
#define CD_TRIGGER(clazz, spell) \
class clazz : public SpellNoCooldownTrigger \
{ \
public: \
#define CD_TRIGGER(clazz, spell) \
class clazz : public SpellNoCooldownTrigger \
{ \
public: \
clazz(PlayerbotAI* botAI) : SpellNoCooldownTrigger(botAI, spell) {} \
}
}
#define INTERRUPT_TRIGGER(clazz, spell) \
class clazz : public InterruptSpellTrigger \
{ \
public: \
clazz(PlayerbotAI* botAI) : InterruptSpellTrigger(botAI, spell) { } \
}
#define INTERRUPT_TRIGGER(clazz, spell) \
class clazz : public InterruptSpellTrigger \
{ \
public: \
clazz(PlayerbotAI* botAI) : InterruptSpellTrigger(botAI, spell) {} \
}
#define INTERRUPT_TRIGGER_A(clazz, spell) \
class clazz : public InterruptSpellTrigger \
{ \
public: \
clazz(PlayerbotAI* botAI) : InterruptSpellTrigger(botAI, spell) { } \
bool IsActive() override; \
}
#define INTERRUPT_TRIGGER_A(clazz, spell) \
class clazz : public InterruptSpellTrigger \
{ \
public: \
clazz(PlayerbotAI* botAI) : InterruptSpellTrigger(botAI, spell) {} \
bool IsActive() override; \
}
#define HAS_AURA_TRIGGER(clazz, spell) \
class clazz : public HasAuraTrigger \
{ \
public: \
clazz(PlayerbotAI* botAI) : HasAuraTrigger(botAI, spell) { } \
}
#define HAS_AURA_TRIGGER(clazz, spell) \
class clazz : public HasAuraTrigger \
{ \
public: \
clazz(PlayerbotAI* botAI) : HasAuraTrigger(botAI, spell) {} \
}
#define HAS_AURA_TRIGGER_A(clazz, spell) \
class clazz : public HasAuraTrigger \
{ \
public: \
clazz(PlayerbotAI* botAI) : HasAuraTrigger(botAI, spell) { } \
bool IsActive() override; \
}
#define HAS_AURA_TRIGGER_A(clazz, spell) \
class clazz : public HasAuraTrigger \
{ \
public: \
clazz(PlayerbotAI* botAI) : HasAuraTrigger(botAI, spell) {} \
bool IsActive() override; \
}
#define SNARE_TRIGGER(clazz, spell) \
class clazz : public SnareTargetTrigger \
{ \
public: \
clazz(PlayerbotAI* botAI) : SnareTargetTrigger(botAI, spell) { } \
}
#define SNARE_TRIGGER(clazz, spell) \
class clazz : public SnareTargetTrigger \
{ \
public: \
clazz(PlayerbotAI* botAI) : SnareTargetTrigger(botAI, spell) {} \
}
#define SNARE_TRIGGER_A(clazz, spell) \
class clazz : public SnareTargetTrigger \
{ \
public: \
clazz(PlayerbotAI* botAI) : SnareTargetTrigger(botAI, spell) { } \
bool IsActive() override; \
}
#define SNARE_TRIGGER_A(clazz, spell) \
class clazz : public SnareTargetTrigger \
{ \
public: \
clazz(PlayerbotAI* botAI) : SnareTargetTrigger(botAI, spell) {} \
bool IsActive() override; \
}
#define PROTECT_TRIGGER(clazz, spell) \
class clazz : public ProtectPartyMemberTrigger \
{ \
public: \
clazz(PlayerbotAI* botAI) : ProtectPartyMemberTrigger(botAI) { } \
}
#define PROTECT_TRIGGER(clazz, spell) \
class clazz : public ProtectPartyMemberTrigger \
{ \
public: \
clazz(PlayerbotAI* botAI) : ProtectPartyMemberTrigger(botAI) {} \
}
#define DEFLECT_TRIGGER(clazz, spell) \
class clazz : public DeflectSpellTrigger \
{ \
public: \
clazz(PlayerbotAI* botAI) : DeflectSpellTrigger(botAI, spell) { } \
}
#define DEFLECT_TRIGGER(clazz, spell) \
class clazz : public DeflectSpellTrigger \
{ \
public: \
clazz(PlayerbotAI* botAI) : DeflectSpellTrigger(botAI, spell) {} \
}
#define BOOST_TRIGGER(clazz, spell) \
class clazz : public BoostTrigger \
{ \
public: \
clazz(PlayerbotAI* botAI) : BoostTrigger(botAI, spell) { } \
}
#define BOOST_TRIGGER(clazz, spell) \
class clazz : public BoostTrigger \
{ \
public: \
clazz(PlayerbotAI* botAI) : BoostTrigger(botAI, spell) {} \
}
#define BOOST_TRIGGER_A(clazz, spell) \
class clazz : public BoostTrigger \
{ \
public: \
clazz(PlayerbotAI* botAI) : BoostTrigger(botAI, spell) { } \
bool IsActive() override; \
}
#define BOOST_TRIGGER_A(clazz, spell) \
class clazz : public BoostTrigger \
{ \
public: \
clazz(PlayerbotAI* botAI) : BoostTrigger(botAI, spell) {} \
bool IsActive() override; \
}
#define INTERRUPT_HEALER_TRIGGER(clazz, spell) \
class clazz : public InterruptEnemyHealerTrigger \
{ \
public: \
clazz(PlayerbotAI* botAI) : InterruptEnemyHealerTrigger(botAI, spell) { } \
}
#define INTERRUPT_HEALER_TRIGGER(clazz, spell) \
class clazz : public InterruptEnemyHealerTrigger \
{ \
public: \
clazz(PlayerbotAI* botAI) : InterruptEnemyHealerTrigger(botAI, spell) {} \
}
#define INTERRUPT_HEALER_TRIGGER_A(clazz, spell) \
class clazz : public InterruptEnemyHealerTrigger \
{ \
public: \
clazz(PlayerbotAI* botAI) : InterruptEnemyHealerTrigger(botAI, spell) { } \
bool IsActive() override; \
}
#define INTERRUPT_HEALER_TRIGGER_A(clazz, spell) \
class clazz : public InterruptEnemyHealerTrigger \
{ \
public: \
clazz(PlayerbotAI* botAI) : InterruptEnemyHealerTrigger(botAI, spell) {} \
bool IsActive() override; \
}
#define CC_TRIGGER(clazz, spell) \
class clazz : public HasCcTargetTrigger \
{ \
public: \
clazz(PlayerbotAI* botAI) : HasCcTargetTrigger(botAI, spell) { } \
}
#define CC_TRIGGER(clazz, spell) \
class clazz : public HasCcTargetTrigger \
{ \
public: \
clazz(PlayerbotAI* botAI) : HasCcTargetTrigger(botAI, spell) {} \
}
//
// ACTIONS
//
#define MELEE_ACTION(clazz, spell) \
class clazz : public CastMeleeSpellAction \
{ \
public: \
clazz(PlayerbotAI* botAI) : CastMeleeSpellAction(botAI, spell) { } \
}
#define MELEE_ACTION(clazz, spell) \
class clazz : public CastMeleeSpellAction \
{ \
public: \
clazz(PlayerbotAI* botAI) : CastMeleeSpellAction(botAI, spell) {} \
}
#define MELEE_ACTION_U(clazz, spell, useful) \
class clazz : public CastMeleeSpellAction \
{ \
public: \
clazz(PlayerbotAI* botAI) : CastMeleeSpellAction(botAI, spell) { } \
bool isUseful() override { return useful; } \
}
#define MELEE_ACTION_U(clazz, spell, useful) \
class clazz : public CastMeleeSpellAction \
{ \
public: \
clazz(PlayerbotAI* botAI) : CastMeleeSpellAction(botAI, spell) {} \
bool isUseful() override { return useful; } \
}
#define SPELL_ACTION(clazz, spell) \
class clazz : public CastSpellAction \
{ \
public: \
clazz(PlayerbotAI* botAI) : CastSpellAction(botAI, spell) { } \
}
#define SPELL_ACTION(clazz, spell) \
class clazz : public CastSpellAction \
{ \
public: \
clazz(PlayerbotAI* botAI) : CastSpellAction(botAI, spell) {} \
}
#define SPELL_ACTION_U(clazz, spell, useful) \
class clazz : public CastSpellAction \
{ \
public: \
clazz(PlayerbotAI* botAI) : CastSpellAction(botAI, spell) { } \
bool isUseful() override { return useful; } \
}
#define SPELL_ACTION_U(clazz, spell, useful) \
class clazz : public CastSpellAction \
{ \
public: \
clazz(PlayerbotAI* botAI) : CastSpellAction(botAI, spell) {} \
bool isUseful() override { return useful; } \
}
#define HEAL_ACTION(clazz, spell) \
class clazz : public CastHealingSpellAction \
{ \
public: \
clazz(PlayerbotAI* botAI) : CastHealingSpellAction(botAI, spell) { } \
}
#define HEAL_ACTION(clazz, spell) \
class clazz : public CastHealingSpellAction \
{ \
public: \
clazz(PlayerbotAI* botAI) : CastHealingSpellAction(botAI, spell) {} \
}
#define HEAL_ACTION_U(clazz, spell, useful) \
class clazz : public CastHealingSpellAction \
{ \
public: \
clazz(PlayerbotAI* botAI) : CastHealingSpellAction(botAI, spell) { } \
bool isUseful() override { return useful; } \
}
#define HEAL_ACTION_U(clazz, spell, useful) \
class clazz : public CastHealingSpellAction \
{ \
public: \
clazz(PlayerbotAI* botAI) : CastHealingSpellAction(botAI, spell) {} \
bool isUseful() override { return useful; } \
}
#define HEAL_PARTY_ACTION(clazz, spell, estAmount, manaEfficiency) \
class clazz : public HealPartyMemberAction \
{ \
public: \
clazz(PlayerbotAI* botAI) : HealPartyMemberAction(botAI, spell, estAmount, manaEfficiency) { } \
}
#define HEAL_PARTY_ACTION(clazz, spell, estAmount, manaEfficiency) \
class clazz : public HealPartyMemberAction \
{ \
public: \
clazz(PlayerbotAI* botAI) : HealPartyMemberAction(botAI, spell, estAmount, manaEfficiency) {} \
}
#define AOE_HEAL_ACTION(clazz, spell, estAmount, manaEfficiency) \
class clazz : public CastAoeHealSpellAction \
{ \
public: \
clazz(PlayerbotAI* botAI) : CastAoeHealSpellAction(botAI, spell) { } \
}
#define AOE_HEAL_ACTION(clazz, spell, estAmount, manaEfficiency) \
class clazz : public CastAoeHealSpellAction \
{ \
public: \
clazz(PlayerbotAI* botAI) : CastAoeHealSpellAction(botAI, spell) {} \
}
#define BUFF_ACTION(clazz, spell) \
class clazz : public CastBuffSpellAction \
{ \
public: \
clazz(PlayerbotAI* botAI) : CastBuffSpellAction(botAI, spell) { } \
}
#define BUFF_ACTION(clazz, spell) \
class clazz : public CastBuffSpellAction \
{ \
public: \
clazz(PlayerbotAI* botAI) : CastBuffSpellAction(botAI, spell) {} \
}
#define BUFF_ACTION_U(clazz, spell, useful) \
class clazz : public CastBuffSpellAction \
{ \
public: \
clazz(PlayerbotAI* botAI) : CastBuffSpellAction(botAI, spell) { } \
bool isUseful() override { return useful; } \
}
#define BUFF_ACTION_U(clazz, spell, useful) \
class clazz : public CastBuffSpellAction \
{ \
public: \
clazz(PlayerbotAI* botAI) : CastBuffSpellAction(botAI, spell) {} \
bool isUseful() override { return useful; } \
}
#define BUFF_PARTY_ACTION(clazz, spell) \
class clazz : public BuffOnPartyAction \
{ \
public: \
clazz(PlayerbotAI* botAI) : BuffOnPartyAction(botAI, spell) { } \
}
#define BUFF_PARTY_ACTION(clazz, spell) \
class clazz : public BuffOnPartyAction \
{ \
public: \
clazz(PlayerbotAI* botAI) : BuffOnPartyAction(botAI, spell) {} \
}
#define CURE_ACTION(clazz, spell) \
class clazz : public CastCureSpellAction \
{ \
public: \
clazz(PlayerbotAI* botAI) : CastCureSpellAction(botAI, spell) { } \
}
#define CURE_ACTION(clazz, spell) \
class clazz : public CastCureSpellAction \
{ \
public: \
clazz(PlayerbotAI* botAI) : CastCureSpellAction(botAI, spell) {} \
}
#define CURE_PARTY_ACTION(clazz, spell, dispel) \
class clazz : public CurePartyMemberAction \
{ \
public: \
clazz(PlayerbotAI* botAI) : CurePartyMemberAction(botAI, spell, dispel) { } \
}
#define CURE_PARTY_ACTION(clazz, spell, dispel) \
class clazz : public CurePartyMemberAction \
{ \
public: \
clazz(PlayerbotAI* botAI) : CurePartyMemberAction(botAI, spell, dispel) {} \
}
#define RESS_ACTION(clazz, spell) \
class clazz : public ResurrectPartyMemberAction \
{ \
public: \
clazz(PlayerbotAI* botAI) : ResurrectPartyMemberAction(botAI, spell) { } \
}
#define RESS_ACTION(clazz, spell) \
class clazz : public ResurrectPartyMemberAction \
{ \
public: \
clazz(PlayerbotAI* botAI) : ResurrectPartyMemberAction(botAI, spell) {} \
}
#define DEBUFF_ACTION(clazz, spell) \
class clazz : public CastDebuffSpellAction \
{ \
public: \
clazz(PlayerbotAI* botAI) : CastDebuffSpellAction(botAI, spell) { } \
}
#define DEBUFF_ACTION(clazz, spell) \
class clazz : public CastDebuffSpellAction \
{ \
public: \
clazz(PlayerbotAI* botAI) : CastDebuffSpellAction(botAI, spell) {} \
}
#define DEBUFF_CHECKISOWNER_ACTION(clazz, spell) \
class clazz : public CastDebuffSpellAction \
{ \
public: \
clazz(PlayerbotAI* botAI) : CastDebuffSpellAction(botAI, spell, true) { } \
}
#define DEBUFF_CHECKISOWNER_ACTION(clazz, spell) \
class clazz : public CastDebuffSpellAction \
{ \
public: \
clazz(PlayerbotAI* botAI) : CastDebuffSpellAction(botAI, spell, true) {} \
}
#define DEBUFF_ACTION_U(clazz, spell, useful) \
class clazz : public CastDebuffSpellAction \
{ \
public: \
clazz(PlayerbotAI* botAI) : CastDebuffSpellAction(botAI, spell) { } \
bool isUseful() override { return useful; } \
}
#define DEBUFF_ACTION_U(clazz, spell, useful) \
class clazz : public CastDebuffSpellAction \
{ \
public: \
clazz(PlayerbotAI* botAI) : CastDebuffSpellAction(botAI, spell) {} \
bool isUseful() override { return useful; } \
}
#define DEBUFF_ACTION_R(clazz, spell, distance) \
class clazz : public CastDebuffSpellAction \
{ \
public: \
clazz(PlayerbotAI* botAI) : CastDebuffSpellAction(botAI, spell) \
{ \
range = distance; \
} \
}
#define DEBUFF_ACTION_R(clazz, spell, distance) \
class clazz : public CastDebuffSpellAction \
{ \
public: \
clazz(PlayerbotAI* botAI) : CastDebuffSpellAction(botAI, spell) { range = distance; } \
}
#define DEBUFF_ENEMY_ACTION(clazz, spell) \
class clazz : public CastDebuffSpellOnAttackerAction \
{ \
public: \
clazz(PlayerbotAI* botAI) : CastDebuffSpellOnAttackerAction(botAI, spell) { } \
}
#define DEBUFF_ENEMY_ACTION(clazz, spell) \
class clazz : public CastDebuffSpellOnAttackerAction \
{ \
public: \
clazz(PlayerbotAI* botAI) : CastDebuffSpellOnAttackerAction(botAI, spell) {} \
}
#define REACH_ACTION(clazz, spell, range) \
class clazz : public CastReachTargetSpellAction \
{ \
public: \
clazz(PlayerbotAI* botAI) : CastReachTargetSpellAction(botAI, spell, range) { } \
}
#define REACH_ACTION(clazz, spell, range) \
class clazz : public CastReachTargetSpellAction \
{ \
public: \
clazz(PlayerbotAI* botAI) : CastReachTargetSpellAction(botAI, spell, range) {} \
}
#define REACH_ACTION_U(clazz, spell, range, useful) \
class clazz : public CastReachTargetSpellAction \
{ \
public: \
clazz(PlayerbotAI* botAI) : CastReachTargetSpellAction(botAI, spell, range) { } \
bool isUseful() override { return useful; } \
}
#define REACH_ACTION_U(clazz, spell, range, useful) \
class clazz : public CastReachTargetSpellAction \
{ \
public: \
clazz(PlayerbotAI* botAI) : CastReachTargetSpellAction(botAI, spell, range) {} \
bool isUseful() override { return useful; } \
}
#define ENEMY_HEALER_ACTION(clazz, spell) \
class clazz : public CastSpellOnEnemyHealerAction \
{ \
public: \
clazz(PlayerbotAI* botAI) : CastSpellOnEnemyHealerAction(botAI, spell) { } \
}
#define ENEMY_HEALER_ACTION(clazz, spell) \
class clazz : public CastSpellOnEnemyHealerAction \
{ \
public: \
clazz(PlayerbotAI* botAI) : CastSpellOnEnemyHealerAction(botAI, spell) {} \
}
#define SNARE_ACTION(clazz, spell) \
class clazz : public CastSnareSpellAction \
{ \
public: \
clazz(PlayerbotAI* botAI) : CastSnareSpellAction(botAI, spell) {} \
}
#define SNARE_ACTION(clazz, spell) \
class clazz : public CastSnareSpellAction \
{ \
public: \
clazz(PlayerbotAI* botAI) : CastSnareSpellAction(botAI, spell) { } \
}
#define CC_ACTION(clazz, spell) \
class clazz : public CastCrowdControlSpellAction \
{ \
public: \
clazz(PlayerbotAI* botAI) : CastCrowdControlSpellAction(botAI, spell) {} \
}
#define CC_ACTION(clazz, spell) \
class clazz : public CastCrowdControlSpellAction \
{ \
public: \
clazz(PlayerbotAI* botAI) : CastCrowdControlSpellAction(botAI, spell) { } \
}
#define PROTECT_ACTION(clazz, spell) \
class clazz : public CastProtectSpellAction \
{ \
public: \
clazz(PlayerbotAI* botAI) : CastProtectSpellAction(botAI, spell) { } \
}
#define PROTECT_ACTION(clazz, spell) \
class clazz : public CastProtectSpellAction \
{ \
public: \
clazz(PlayerbotAI* botAI) : CastProtectSpellAction(botAI, spell) {} \
}
#define END_RANGED_SPELL_ACTION() \
};
} \
;
#define BEGIN_SPELL_ACTION(clazz, name) \
class clazz : public CastSpellAction \
{ \
public: \
clazz(PlayerbotAI* botAI) : CastSpellAction(botAI, name) { } \
#define BEGIN_SPELL_ACTION(clazz, name) \
class clazz : public CastSpellAction \
{ \
public: \
clazz(PlayerbotAI* botAI) : CastSpellAction(botAI, name) {}
#define END_SPELL_ACTION() \
};
} \
;
#define BEGIN_DEBUFF_ACTION(clazz, name) \
class clazz : public CastDebuffSpellAction \
{ \
public: \
clazz(PlayerbotAI* botAI) : CastDebuffSpellAction(botAI, name) { } \
#define BEGIN_DEBUFF_ACTION(clazz, name) \
class clazz : public CastDebuffSpellAction \
{ \
public: \
clazz(PlayerbotAI* botAI) : CastDebuffSpellAction(botAI, name) {}
#define BEGIN_RANGED_SPELL_ACTION(clazz, name) \
class clazz : public CastSpellAction \
{ \
public: \
clazz(PlayerbotAI* botAI) : CastSpellAction(botAI, name) { } \
class clazz : public CastSpellAction \
{ \
public: \
clazz(PlayerbotAI* botAI) : CastSpellAction(botAI, name) {}
#define BEGIN_MELEE_SPELL_ACTION(clazz, name) \
class clazz : public CastMeleeSpellAction \
{ \
public: \
clazz(PlayerbotAI* botAI) : CastMeleeSpellAction(botAI, name) { } \
class clazz : public CastMeleeSpellAction \
{ \
public: \
clazz(PlayerbotAI* botAI) : CastMeleeSpellAction(botAI, name) {}
#define END_RANGED_SPELL_ACTION() \
};
} \
;
#define BEGIN_BUFF_ON_PARTY_ACTION(clazz, name) \
class clazz : public BuffOnPartyAction \
{ \
public: \
clazz(PlayerbotAI* botAI) : BuffOnPartyAction(botAI, name) { }
class clazz : public BuffOnPartyAction \
{ \
public: \
clazz(PlayerbotAI* botAI) : BuffOnPartyAction(botAI, name) {}
//
// Action node
//
// node_name , action, prerequisite
#define ACTION_NODE_P(name, spell, pre) \
static ActionNode* name(PlayerbotAI* botAI) \
{ \
return new ActionNode(spell, \
/*P*/ NextAction::array(0, new NextAction(pre), nullptr), \
/*A*/ nullptr, \
/*C*/ nullptr); \
}
#define ACTION_NODE_P(name, spell, pre) \
static ActionNode* name(PlayerbotAI* botAI) \
{ \
return new ActionNode(spell, /*P*/ NextAction::array(0, new NextAction(pre), nullptr), /*A*/ nullptr, \
/*C*/ nullptr); \
}
// node_name , action, alternative
#define ACTION_NODE_A(name, spell, alt) \
static ActionNode* name(PlayerbotAI* botAI) \
{ \
return new ActionNode(spell, \
/*P*/ nullptr, \
/*A*/ NextAction::array(0, new NextAction(alt), nullptr), \
/*C*/ nullptr); \
}
#define ACTION_NODE_A(name, spell, alt) \
static ActionNode* name(PlayerbotAI* botAI) \
{ \
return new ActionNode(spell, /*P*/ nullptr, /*A*/ NextAction::array(0, new NextAction(alt), nullptr), \
/*C*/ nullptr); \
}
// node_name , action, continuer
#define ACTION_NODE_C(name, spell, con) \
static ActionNode* name(PlayerbotAI* botAI) \
{ \
return new ActionNode(spell, \
/*P*/ nullptr, \
/*A*/ nullptr, \
/*C*/ NextAction::array(0, new NextAction(con), nullptr)); \
}
#define ACTION_NODE_C(name, spell, con) \
static ActionNode* name(PlayerbotAI* botAI) \
{ \
return new ActionNode(spell, /*P*/ nullptr, /*A*/ nullptr, \
/*C*/ NextAction::array(0, new NextAction(con), nullptr)); \
}
#endif

50
src/strategy/AiObjectContext.cpp
View File

@@ -1,21 +1,23 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#include "AiObjectContext.h"
#include "StrategyContext.h"
#include "ActionContext.h"
#include "ChatActionContext.h"
#include "WorldPacketActionContext.h"
#include "ChatTriggerContext.h"
#include "TriggerContext.h"
#include "SharedValueContext.h"
#include "WorldPacketTriggerContext.h"
#include "ValueContext.h"
#include "Playerbots.h"
#include "raids/RaidTriggerContext.h"
#include "SharedValueContext.h"
#include "StrategyContext.h"
#include "TriggerContext.h"
#include "ValueContext.h"
#include "WorldPacketActionContext.h"
#include "WorldPacketTriggerContext.h"
#include "raids/RaidActionContext.h"
#include "raids/RaidStrategyContext.h"
#include "raids/RaidTriggerContext.h"
#include "raids/naxxramas/RaidNaxxActionContext.h"
#include "raids/naxxramas/RaidNaxxTriggerContext.h"
@@ -26,7 +28,7 @@ AiObjectContext::AiObjectContext(PlayerbotAI* botAI) : PlayerbotAIAware(botAI)
strategyContexts.Add(new AssistStrategyContext());
strategyContexts.Add(new QuestStrategyContext());
strategyContexts.Add(new RaidStrategyContext());
actionContexts.Add(new ActionContext());
actionContexts.Add(new ChatActionContext());
actionContexts.Add(new WorldPacketActionContext());
@@ -116,35 +118,20 @@ std::set<std::string> AiObjectContext::GetSiblingStrategy(std::string const name
return strategyContexts.GetSiblings(name);
}
Trigger* AiObjectContext::GetTrigger(std::string const name)
{
return triggerContexts.GetContextObject(name, botAI);
}
Trigger* AiObjectContext::GetTrigger(std::string const name) { return triggerContexts.GetContextObject(name, botAI); }
Action* AiObjectContext::GetAction(std::string const name)
{
return actionContexts.GetContextObject(name, botAI);
}
Action* AiObjectContext::GetAction(std::string const name) { return actionContexts.GetContextObject(name, botAI); }
UntypedValue* AiObjectContext::GetUntypedValue(std::string const name)
{
return valueContexts.GetContextObject(name, botAI);
}
std::set<std::string> AiObjectContext::GetValues()
{
return valueContexts.GetCreated();
}
std::set<std::string> AiObjectContext::GetValues() { return valueContexts.GetCreated(); }
std::set<std::string> AiObjectContext::GetSupportedStrategies()
{
return strategyContexts.supports();
}
std::set<std::string> AiObjectContext::GetSupportedStrategies() { return strategyContexts.supports(); }
std::set<std::string> AiObjectContext::GetSupportedActions()
{
return actionContexts.supports();
}
std::set<std::string> AiObjectContext::GetSupportedActions() { return actionContexts.supports(); }
std::string const AiObjectContext::FormatValues()
{
@@ -166,7 +153,4 @@ std::string const AiObjectContext::FormatValues()
return out.str();
}
void AiObjectContext::AddShared(NamedObjectContext<UntypedValue>* sharedValues)
{
valueContexts.Add(sharedValues);
}
void AiObjectContext::AddShared(NamedObjectContext<UntypedValue>* sharedValues) { valueContexts.Add(sharedValues); }

89
src/strategy/AiObjectContext.h
View File

@@ -1,10 +1,14 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#ifndef _PLAYERBOT_AIOBJECTCONTEXT_H
#define _PLAYERBOT_AIOBJECTCONTEXT_H
#include <sstream>
#include <string>
#include "Common.h"
#include "NamedObjectContext.h"
#include "PlayerbotAIAware.h"
@@ -12,62 +16,59 @@
#include "Trigger.h"
#include "Value.h"
#include <sstream>
#include <string>
class PlayerbotAI;
class AiObjectContext : public PlayerbotAIAware
{
public:
AiObjectContext(PlayerbotAI* botAI);
virtual ~AiObjectContext() { }
public:
AiObjectContext(PlayerbotAI* botAI);
virtual ~AiObjectContext() {}
virtual Strategy* GetStrategy(std::string const name);
virtual std::set<std::string> GetSiblingStrategy(std::string const name);
virtual Trigger* GetTrigger(std::string const name);
virtual Action* GetAction(std::string const name);
virtual UntypedValue* GetUntypedValue(std::string const name);
virtual Strategy* GetStrategy(std::string const name);
virtual std::set<std::string> GetSiblingStrategy(std::string const name);
virtual Trigger* GetTrigger(std::string const name);
virtual Action* GetAction(std::string const name);
virtual UntypedValue* GetUntypedValue(std::string const name);
template<class T>
Value<T>* GetValue(std::string const name)
{
return dynamic_cast<Value<T>*>(GetUntypedValue(name));
}
template <class T>
Value<T>* GetValue(std::string const name)
{
return dynamic_cast<Value<T>*>(GetUntypedValue(name));
}
template<class T>
Value<T>* GetValue(std::string const name, std::string const param)
{
return GetValue<T>((std::string(name) + "::" + param));
}
template <class T>
Value<T>* GetValue(std::string const name, std::string const param)
{
return GetValue<T>((std::string(name) + "::" + param));
}
template<class T>
Value<T>* GetValue(std::string const name, int32 param)
{
std::ostringstream out;
out << param;
return GetValue<T>(name, out.str());
}
template <class T>
Value<T>* GetValue(std::string const name, int32 param)
{
std::ostringstream out;
out << param;
return GetValue<T>(name, out.str());
}
std::set<std::string> GetValues();
std::set<std::string> GetSupportedStrategies();
std::set<std::string> GetSupportedActions();
std::string const FormatValues();
std::set<std::string> GetValues();
std::set<std::string> GetSupportedStrategies();
std::set<std::string> GetSupportedActions();
std::string const FormatValues();
virtual void Update();
virtual void Reset();
virtual void AddShared(NamedObjectContext<UntypedValue>* sharedValues);
virtual void Update();
virtual void Reset();
virtual void AddShared(NamedObjectContext<UntypedValue>* sharedValues);
std::vector<std::string> Save();
void Load(std::vector<std::string> data);
std::vector<std::string> Save();
void Load(std::vector<std::string> data);
std::vector<std::string> performanceStack;
std::vector<std::string> performanceStack;
protected:
NamedObjectContextList<Strategy> strategyContexts;
NamedObjectContextList<Action> actionContexts;
NamedObjectContextList<Trigger> triggerContexts;
NamedObjectContextList<UntypedValue> valueContexts;
protected:
NamedObjectContextList<Strategy> strategyContexts;
NamedObjectContextList<Action> actionContexts;
NamedObjectContextList<Trigger> triggerContexts;
NamedObjectContextList<UntypedValue> valueContexts;
};
#endif

23
src/strategy/CustomStrategy.cpp
View File

@@ -1,12 +1,14 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#include "CustomStrategy.h"
#include "Playerbots.h"
#include <regex>
#include "Playerbots.h"
std::map<std::string, std::string> CustomStrategy::actionLinesCache;
NextAction* toNextAction(std::string const action)
@@ -33,7 +35,7 @@ NextAction** toNextActionArray(std::string const actions)
res[index++] = na;
}
res[index++] = nullptr;
res[index++] = nullptr;
return res;
}
@@ -47,11 +49,9 @@ TriggerNode* toTriggerNode(std::string const actionLine)
return nullptr;
}
CustomStrategy::CustomStrategy(PlayerbotAI* botAI) : Strategy(botAI), Qualified()
{
}
CustomStrategy::CustomStrategy(PlayerbotAI* botAI) : Strategy(botAI), Qualified() {}
void CustomStrategy::InitTriggers(std::vector<TriggerNode*> &triggers)
void CustomStrategy::InitTriggers(std::vector<TriggerNode*>& triggers)
{
if (actionLines.empty())
{
@@ -68,7 +68,8 @@ void CustomStrategy::InitTriggers(std::vector<TriggerNode*> &triggers)
for (std::vector<std::string>::iterator i = tokens.begin(); i != tokens.end(); ++i)
{
std::string const line = *i;
for (std::sregex_iterator j = std::sregex_iterator(line.begin(), line.end(), tpl); j != std::sregex_iterator(); ++j)
for (std::sregex_iterator j = std::sregex_iterator(line.begin(), line.end(), tpl);
j != std::sregex_iterator(); ++j)
{
std::smatch match = *j;
std::string const actionLine = match[1].str();
@@ -88,7 +89,8 @@ void CustomStrategy::InitTriggers(std::vector<TriggerNode*> &triggers)
void CustomStrategy::LoadActionLines(uint32 owner)
{
PlayerbotsDatabasePreparedStatement* stmt = PlayerbotsDatabase.GetPreparedStatement(PLAYERBOTS_SEL_CUSTOM_STRATEGY_BY_OWNER_AND_NAME);
PlayerbotsDatabasePreparedStatement* stmt =
PlayerbotsDatabase.GetPreparedStatement(PLAYERBOTS_SEL_CUSTOM_STRATEGY_BY_OWNER_AND_NAME);
stmt->SetData(0, owner);
stmt->SetData(1, qualifier);
PreparedQueryResult result = PlayerbotsDatabase.Query(stmt);
@@ -99,8 +101,7 @@ void CustomStrategy::LoadActionLines(uint32 owner)
Field* fields = result->Fetch();
std::string const action = fields[1].Get<std::string>();
actionLines.push_back(action);
}
while (result->NextRow());
} while (result->NextRow());
}
}

25
src/strategy/CustomStrategy.h
View File

@@ -1,30 +1,31 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#ifndef _PLAYERBOT_CUSTOMSTRATEGY_H
#define _PLAYERBOT_CUSTOMSTRATEGY_H
#include "Strategy.h"
#include <map>
#include "Strategy.h"
class PlayerbotAI;
class CustomStrategy : public Strategy, public Qualified
{
public:
CustomStrategy(PlayerbotAI* botAI);
public:
CustomStrategy(PlayerbotAI* botAI);
void InitTriggers(std::vector<TriggerNode*> &triggers) override;
std::string const getName() override { return std::string("custom::" + qualifier); }
void Reset();
void InitTriggers(std::vector<TriggerNode*>& triggers) override;
std::string const getName() override { return std::string("custom::" + qualifier); }
void Reset();
static std::map<std::string, std::string> actionLinesCache;
static std::map<std::string, std::string> actionLinesCache;
private:
std::vector<std::string> actionLines;
void LoadActionLines(uint32 owner);
private:
std::vector<std::string> actionLines;
void LoadActionLines(uint32 owner);
};
#endif

102
src/strategy/Engine.cpp
View File

@@ -1,13 +1,15 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#include "Engine.h"
#include "Action.h"
#include "Event.h"
#include "Queue.h"
#include "PerformanceMonitor.h"
#include "Playerbots.h"
#include "Queue.h"
#include "Strategy.h"
Engine::Engine(PlayerbotAI* botAI, AiObjectContext* factory) : PlayerbotAIAware(botAI), aiObjectContext(factory)
@@ -125,12 +127,12 @@ void Engine::Init()
MultiplyAndPush(strategy->getDefaultActions(), 0.0f, false, emptyEvent, "default");
}
if (testMode)
{
if (testMode)
{
FILE* file = fopen("test.log", "w");
fprintf(file, "\n");
fclose(file);
}
}
}
bool Engine::DoNextAction(Unit* unit, uint32 depth, bool minimal)
@@ -147,7 +149,7 @@ bool Engine::DoNextAction(Unit* unit, uint32 depth, bool minimal)
// aiObjectContext->Update();
ProcessTriggers(minimal);
PushDefaultActions();
uint32 iterations = 0;
uint32 iterationsPerTick = queue.Size() * (minimal ? 2 : sPlayerbotAIConfig->iterationsPerTick);
do
@@ -156,7 +158,7 @@ bool Engine::DoNextAction(Unit* unit, uint32 depth, bool minimal)
if (basket)
{
float relevance = basket->getRelevance(); // just for reference
float relevance = basket->getRelevance(); // just for reference
bool skipPrerequisites = basket->isSkipPrerequisites();
if (minimal && (relevance < 100))
@@ -172,12 +174,13 @@ bool Engine::DoNextAction(Unit* unit, uint32 depth, bool minimal)
if (!action)
{
//LOG_ERROR("playerbots", "Action: {} - is UNKNOWN - c:{} l:{}", actionNode->getName().c_str(), botAI->GetBot()->getClass(), botAI->GetBot()->GetLevel());
// LOG_ERROR("playerbots", "Action: {} - is UNKNOWN - c:{} l:{}", actionNode->getName().c_str(),
// botAI->GetBot()->getClass(), botAI->GetBot()->GetLevel());
LogAction("A:%s - UNKNOWN", actionNode->getName().c_str());
}
else if (action->isUseful())
{
for (std::vector<Multiplier*>::iterator i = multipliers.begin(); i!= multipliers.end(); i++)
for (std::vector<Multiplier*>::iterator i = multipliers.begin(); i != multipliers.end(); i++)
{
Multiplier* multiplier = *i;
relevance *= multiplier->GetValue(action);
@@ -185,7 +188,8 @@ bool Engine::DoNextAction(Unit* unit, uint32 depth, bool minimal)
if (!relevance)
{
LogAction("Multiplier %s made action %s useless", multiplier->getName().c_str(), action->getName().c_str());
LogAction("Multiplier %s made action %s useless", multiplier->getName().c_str(),
action->getName().c_str());
break;
}
}
@@ -203,7 +207,8 @@ bool Engine::DoNextAction(Unit* unit, uint32 depth, bool minimal)
}
}
PerformanceMonitorOperation* pmo = sPerformanceMonitor->start(PERF_MON_ACTION, action->getName(), &aiObjectContext->performanceStack);
PerformanceMonitorOperation* pmo = sPerformanceMonitor->start(PERF_MON_ACTION, action->getName(),
&aiObjectContext->performanceStack);
actionExecuted = ListenAndExecute(action, event);
if (pmo)
pmo->finish();
@@ -264,8 +269,7 @@ bool Engine::DoNextAction(Unit* unit, uint32 depth, bool minimal)
delete actionNode;
}
}
while (basket && ++iterations <= iterationsPerTick);
} while (basket && ++iterations <= iterationsPerTick);
// if (!basket)
// {
@@ -312,13 +316,14 @@ ActionNode* Engine::CreateActionNode(std::string const name)
return node;
}
return new ActionNode (name,
/*P*/ nullptr,
/*A*/ nullptr,
/*C*/ nullptr);
return new ActionNode(name,
/*P*/ nullptr,
/*A*/ nullptr,
/*C*/ nullptr);
}
bool Engine::MultiplyAndPush(NextAction** actions, float forceRelevance, bool skipPrerequisites, Event event, char const* pushType)
bool Engine::MultiplyAndPush(NextAction** actions, float forceRelevance, bool skipPrerequisites, Event event,
char const* pushType)
{
bool pushed = false;
if (actions)
@@ -361,7 +366,7 @@ bool Engine::MultiplyAndPush(NextAction** actions, float forceRelevance, bool sk
ActionResult Engine::ExecuteAction(std::string const name, Event event, std::string const qualifier)
{
bool result = false;
bool result = false;
ActionNode* actionNode = CreateActionNode(name);
if (!actionNode)
@@ -399,7 +404,7 @@ ActionResult Engine::ExecuteAction(std::string const name, Event event, std::str
delete actionNode;
return result ? ACTION_RESULT_OK : ACTION_RESULT_FAILED;
return result ? ACTION_RESULT_OK : ACTION_RESULT_FAILED;
}
void Engine::addStrategy(std::string const name)
@@ -421,21 +426,20 @@ void Engine::addStrategy(std::string const name)
void Engine::addStrategies(std::string first, ...)
{
addStrategy(first);
addStrategy(first);
va_list vl;
va_start(vl, first);
va_list vl;
va_start(vl, first);
const char* cur;
do
{
cur = va_arg(vl, const char*);
if (cur)
addStrategy(cur);
}
while (cur);
const char* cur;
do
{
cur = va_arg(vl, const char*);
if (cur)
addStrategy(cur);
} while (cur);
va_end(vl);
va_end(vl);
}
bool Engine::removeStrategy(std::string const name)
@@ -463,10 +467,7 @@ void Engine::toggleStrategy(std::string const name)
addStrategy(name);
}
bool Engine::HasStrategy(std::string const name)
{
return strategies.find(name) != strategies.end();
}
bool Engine::HasStrategy(std::string const name) { return strategies.find(name) != strategies.end(); }
void Engine::ProcessTriggers(bool minimal)
{
@@ -486,16 +487,17 @@ void Engine::ProcessTriggers(bool minimal)
if (!trigger)
continue;
if (fires.find(trigger) != fires.end())
continue;
if (testMode || trigger->needCheck())
{
if (minimal && node->getFirstRelevance() < 100)
continue;
PerformanceMonitorOperation* pmo = sPerformanceMonitor->start(PERF_MON_TRIGGER, trigger->getName(), &aiObjectContext->performanceStack);
PerformanceMonitorOperation* pmo =
sPerformanceMonitor->start(PERF_MON_TRIGGER, trigger->getName(), &aiObjectContext->performanceStack);
Event event = trigger->Check();
if (pmo)
pmo->finish();
@@ -574,12 +576,12 @@ void Engine::PushAgain(ActionNode* actionNode, float relevance, Event event)
bool Engine::ContainsStrategy(StrategyType type)
{
for (std::map<std::string, Strategy*>::iterator i = strategies.begin(); i != strategies.end(); i++)
{
if (i->second->GetType() & type)
return true;
}
return false;
for (std::map<std::string, Strategy*>::iterator i = strategies.begin(); i != strategies.end(); i++)
{
if (i->second->GetType() & type)
return true;
}
return false;
}
Action* Engine::InitializeAction(ActionNode* actionNode)
@@ -658,7 +660,7 @@ void Engine::LogAction(char const* format, ...)
}
else
{
LOG_DEBUG("playerbots", "{} {}", bot->GetName().c_str(), buf);
LOG_DEBUG("playerbots", "{} {}", bot->GetName().c_str(), buf);
}
}
@@ -671,13 +673,13 @@ void Engine::ChangeStrategy(std::string const names)
switch (name[0])
{
case '+':
addStrategy(name+1);
addStrategy(name + 1);
break;
case '-':
removeStrategy(name+1);
removeStrategy(name + 1);
break;
case '~':
toggleStrategy(name+1);
toggleStrategy(name + 1);
break;
case '?':
botAI->TellMaster(ListStrategies());
@@ -696,5 +698,5 @@ void Engine::LogValues()
return;
std::string const text = botAI->GetAiObjectContext()->FormatValues();
LOG_DEBUG("playerbots", "Values for {}: {}", bot->GetName().c_str(), text.c_str());
LOG_DEBUG("playerbots", "Values for {}: {}", bot->GetName().c_str(), text.c_str());
}

134
src/strategy/Engine.h
View File

@@ -1,18 +1,19 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#ifndef _PLAYERBOT_ENGINE_H
#define _PLAYERBOT_ENGINE_H
#include <map>
#include "Multiplier.h"
#include "Queue.h"
#include "PlayerbotAIAware.h"
#include "Queue.h"
#include "Strategy.h"
#include "Trigger.h"
#include <map>
class Action;
class ActionNode;
class AiObjectContext;
@@ -31,97 +32,86 @@ enum ActionResult
class ActionExecutionListener
{
public:
virtual ~ActionExecutionListener() { };
public:
virtual ~ActionExecutionListener(){};
virtual bool Before(Action* action, Event event) = 0;
virtual bool AllowExecution(Action* action, Event event) = 0;
virtual void After(Action* action, bool executed, Event event) = 0;
virtual bool OverrideResult(Action* action, bool executed, Event event) = 0;
virtual bool Before(Action* action, Event event) = 0;
virtual bool AllowExecution(Action* action, Event event) = 0;
virtual void After(Action* action, bool executed, Event event) = 0;
virtual bool OverrideResult(Action* action, bool executed, Event event) = 0;
};
class ActionExecutionListeners : public ActionExecutionListener
{
public:
virtual ~ActionExecutionListeners();
public:
virtual ~ActionExecutionListeners();
bool Before(Action* action, Event event) override;
bool AllowExecution(Action* action, Event event) override;
void After(Action* action, bool executed, Event event) override;
bool OverrideResult(Action* action, bool executed, Event event) override;
bool Before(Action* action, Event event) override;
bool AllowExecution(Action* action, Event event) override;
void After(Action* action, bool executed, Event event) override;
bool OverrideResult(Action* action, bool executed, Event event) override;
void Add(ActionExecutionListener* listener)
{
listeners.push_back(listener);
}
void Add(ActionExecutionListener* listener) { listeners.push_back(listener); }
void Remove(ActionExecutionListener* listener)
{
listeners.remove(listener);
}
void Remove(ActionExecutionListener* listener) { listeners.remove(listener); }
private:
std::list<ActionExecutionListener*> listeners;
private:
std::list<ActionExecutionListener*> listeners;
};
class Engine : public PlayerbotAIAware
{
public:
Engine(PlayerbotAI* botAI, AiObjectContext* factory);
public:
Engine(PlayerbotAI* botAI, AiObjectContext* factory);
void Init();
void addStrategy(std::string const name);
void addStrategies(std::string first, ...);
bool removeStrategy(std::string const name);
bool HasStrategy(std::string const name);
void removeAllStrategies();
void toggleStrategy(std::string const name);
std::string const ListStrategies();
std::vector<std::string> GetStrategies();
bool ContainsStrategy(StrategyType type);
void ChangeStrategy(std::string const names);
std::string const GetLastAction() { return lastAction; }
void Init();
void addStrategy(std::string const name);
void addStrategies(std::string first, ...);
bool removeStrategy(std::string const name);
bool HasStrategy(std::string const name);
void removeAllStrategies();
void toggleStrategy(std::string const name);
std::string const ListStrategies();
std::vector<std::string> GetStrategies();
bool ContainsStrategy(StrategyType type);
void ChangeStrategy(std::string const names);
std::string const GetLastAction() { return lastAction; }
virtual bool DoNextAction(Unit*, uint32 depth = 0, bool minimal = false);
ActionResult ExecuteAction(std::string const name, Event event = Event(), std::string const qualifier = "");
virtual bool DoNextAction(Unit*, uint32 depth = 0, bool minimal = false);
ActionResult ExecuteAction(std::string const name, Event event = Event(), std::string const qualifier = "");
void AddActionExecutionListener(ActionExecutionListener* listener)
{
actionExecutionListeners.Add(listener);
}
void AddActionExecutionListener(ActionExecutionListener* listener) { actionExecutionListeners.Add(listener); }
void removeActionExecutionListener(ActionExecutionListener* listener)
{
actionExecutionListeners.Remove(listener);
}
void removeActionExecutionListener(ActionExecutionListener* listener) { actionExecutionListeners.Remove(listener); }
virtual ~Engine(void);
virtual ~Engine(void);
bool testMode;
bool testMode;
private:
bool MultiplyAndPush(NextAction** actions, float forceRelevance, bool skipPrerequisites, Event event, const char* pushType);
void Reset();
void ProcessTriggers(bool minimal);
void PushDefaultActions();
void PushAgain(ActionNode* actionNode, float relevance, Event event);
ActionNode* CreateActionNode(std::string const name);
Action* InitializeAction(ActionNode* actionNode);
bool ListenAndExecute(Action* action, Event event);
private:
bool MultiplyAndPush(NextAction** actions, float forceRelevance, bool skipPrerequisites, Event event,
const char* pushType);
void Reset();
void ProcessTriggers(bool minimal);
void PushDefaultActions();
void PushAgain(ActionNode* actionNode, float relevance, Event event);
ActionNode* CreateActionNode(std::string const name);
Action* InitializeAction(ActionNode* actionNode);
bool ListenAndExecute(Action* action, Event event);
void LogAction(char const* format, ...);
void LogValues();
void LogAction(char const* format, ...);
void LogValues();
ActionExecutionListeners actionExecutionListeners;
ActionExecutionListeners actionExecutionListeners;
protected:
Queue queue;
std::vector<TriggerNode*> triggers;
std::vector<Multiplier*> multipliers;
AiObjectContext* aiObjectContext;
std::map<std::string, Strategy*> strategies;
float lastRelevance;
std::string lastAction;
protected:
Queue queue;
std::vector<TriggerNode*> triggers;
std::vector<Multiplier*> multipliers;
AiObjectContext* aiObjectContext;
std::map<std::string, Strategy*> strategies;
float lastRelevance;
std::string lastAction;
};
#endif

4
src/strategy/Event.cpp
View File

@@ -1,8 +1,10 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#include "Event.h"
#include "Playerbots.h"
Event::Event(std::string const source, ObjectGuid object, Player* owner) : source(source), owner(owner)

47
src/strategy/Event.h
View File

@@ -1,5 +1,6 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#ifndef _PLAYERBOT_EVENT_H
@@ -12,27 +13,33 @@ class Player;
class Event
{
public:
Event(Event const& other) : source(other.source), param(other.param), packet(other.packet), owner(other.owner) { }
Event() { }
Event(std::string const source) : source(source) { }
Event(std::string const source, std::string const param, Player* owner = nullptr) : source(source), param(param), owner(owner) { }
Event(std::string const source, WorldPacket& packet, Player* owner = nullptr) : source(source), packet(packet), owner(owner) { }
Event(std::string const source, ObjectGuid object, Player* owner = nullptr);
virtual ~Event() { }
public:
Event(Event const& other) : source(other.source), param(other.param), packet(other.packet), owner(other.owner) {}
Event() {}
Event(std::string const source) : source(source) {}
Event(std::string const source, std::string const param, Player* owner = nullptr)
: source(source), param(param), owner(owner)
{
}
Event(std::string const source, WorldPacket& packet, Player* owner = nullptr)
: source(source), packet(packet), owner(owner)
{
}
Event(std::string const source, ObjectGuid object, Player* owner = nullptr);
virtual ~Event() {}
std::string const GetSource() { return source; }
std::string const getParam() { return param; }
WorldPacket& getPacket() { return packet; }
ObjectGuid getObject();
Player* getOwner() { return owner; }
bool operator! () const { return source.empty(); }
std::string const GetSource() { return source; }
std::string const getParam() { return param; }
WorldPacket& getPacket() { return packet; }
ObjectGuid getObject();
Player* getOwner() { return owner; }
bool operator!() const { return source.empty(); }
protected:
std::string source;
std::string param;
WorldPacket packet;
Player* owner = nullptr;
protected:
std::string source;
std::string param;
WorldPacket packet;
Player* owner = nullptr;
};
#endif

9
src/strategy/ExternalEventHelper.cpp
View File

@@ -1,11 +1,13 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#include "ExternalEventHelper.h"
#include "Trigger.h"
#include "ChatHelper.h"
#include "Playerbots.h"
#include "Trigger.h"
bool ExternalEventHelper::ParseChatCommand(std::string const command, Player* owner)
{
@@ -37,7 +39,8 @@ bool ExternalEventHelper::ParseChatCommand(std::string const command, Player* ow
return true;
}
void ExternalEventHelper::HandlePacket(std::map<uint16, std::string>& handlers, WorldPacket const& packet, Player* owner)
void ExternalEventHelper::HandlePacket(std::map<uint16, std::string>& handlers, WorldPacket const& packet,
Player* owner)
{
uint16 opcode = packet.GetOpcode();
std::string const name = handlers[opcode];

21
src/strategy/ExternalEventHelper.h
View File

@@ -1,29 +1,30 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#ifndef _PLAYERBOT_EXTERNALEVENTHELPER_H
#define _PLAYERBOT_EXTERNALEVENTHELPER_H
#include "Common.h"
#include <map>
#include "Common.h"
class AiObjectContext;
class Player;
class WorldPacket;
class ExternalEventHelper
{
public:
ExternalEventHelper(AiObjectContext* aiObjectContext) : aiObjectContext(aiObjectContext) { }
public:
ExternalEventHelper(AiObjectContext* aiObjectContext) : aiObjectContext(aiObjectContext) {}
bool ParseChatCommand(std::string const command, Player* owner = nullptr);
void HandlePacket(std::map<uint16, std::string>& handlers, WorldPacket const& packet, Player* owner = nullptr);
bool HandleCommand(std::string const name, std::string const param, Player* owner = nullptr);
bool ParseChatCommand(std::string const command, Player* owner = nullptr);
void HandlePacket(std::map<uint16, std::string>& handlers, WorldPacket const& packet, Player* owner = nullptr);
bool HandleCommand(std::string const name, std::string const param, Player* owner = nullptr);
private:
AiObjectContext* aiObjectContext;
private:
AiObjectContext* aiObjectContext;
};
#endif

7
src/strategy/ItemVisitors.cpp
View File

@@ -1,8 +1,10 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#include "ItemVisitors.h"
#include "Playerbots.h"
bool FindUsableItemVisitor::Visit(Item* item)
@@ -15,7 +17,8 @@ bool FindUsableItemVisitor::Visit(Item* item)
bool FindPotionVisitor::Accept(ItemTemplate const* proto)
{
if (proto->Class == ITEM_CLASS_CONSUMABLE && (proto->SubClass == ITEM_SUBCLASS_POTION || proto->SubClass == ITEM_SUBCLASS_FLASK))
if (proto->Class == ITEM_CLASS_CONSUMABLE &&
(proto->SubClass == ITEM_SUBCLASS_POTION || proto->SubClass == ITEM_SUBCLASS_FLASK))
{
for (uint8 j = 0; j < MAX_ITEM_PROTO_SPELLS; j++)
{

499
src/strategy/ItemVisitors.h
View File

@@ -1,5 +1,6 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#ifndef _PLAYERBOT_ITEMVISITORS_H
@@ -17,407 +18,401 @@ char* strstri(char const* str1, char const* str2);
enum IterateItemsMask : uint32
{
ITERATE_ITEMS_IN_BAGS = 1,
ITERATE_ITEMS_IN_EQUIP = 2,
ITERATE_ITEMS_IN_BANK = 4,
ITERATE_ALL_ITEMS = 255
ITERATE_ITEMS_IN_BAGS = 1,
ITERATE_ITEMS_IN_EQUIP = 2,
ITERATE_ITEMS_IN_BANK = 4,
ITERATE_ALL_ITEMS = 255
};
class IterateItemsVisitor
{
public:
IterateItemsVisitor() { }
public:
IterateItemsVisitor() {}
virtual bool Visit(Item* item) = 0;
virtual bool Visit(Item* item) = 0;
};
class FindItemVisitor : public IterateItemsVisitor
{
public:
FindItemVisitor() : IterateItemsVisitor(), result() { }
public:
FindItemVisitor() : IterateItemsVisitor(), result() {}
bool Visit(Item* item) override
{
if (!Accept(item->GetTemplate()))
return true;
result.push_back(item);
bool Visit(Item* item) override
{
if (!Accept(item->GetTemplate()))
return true;
}
std::vector<Item*>& GetResult() { return result; }
result.push_back(item);
return true;
}
protected:
virtual bool Accept(ItemTemplate const* proto) = 0;
std::vector<Item*>& GetResult() { return result; }
private:
std::vector<Item*> result;
protected:
virtual bool Accept(ItemTemplate const* proto) = 0;
private:
std::vector<Item*> result;
};
class FindUsableItemVisitor : public FindItemVisitor
{
public:
FindUsableItemVisitor(Player* bot) : FindItemVisitor(), bot(bot) { }
public:
FindUsableItemVisitor(Player* bot) : FindItemVisitor(), bot(bot) {}
bool Visit(Item* item) override;
bool Visit(Item* item) override;
private:
Player* bot;
private:
Player* bot;
};
class FindItemsByQualityVisitor : public IterateItemsVisitor
{
public:
FindItemsByQualityVisitor(uint32 quality, uint32 count) : IterateItemsVisitor(), quality(quality), count(count) { }
public:
FindItemsByQualityVisitor(uint32 quality, uint32 count) : IterateItemsVisitor(), quality(quality), count(count) {}
bool Visit(Item* item) override
{
if (item->GetTemplate()->Quality != quality)
return true;
if (result.size() >= (size_t)count)
return false;
result.push_back(item);
bool Visit(Item* item) override
{
if (item->GetTemplate()->Quality != quality)
return true;
}
std::vector<Item*>& GetResult()
{
return result;
}
if (result.size() >= (size_t)count)
return false;
private:
uint32 quality;
uint32 count;
std::vector<Item*> result;
result.push_back(item);
return true;
}
std::vector<Item*>& GetResult() { return result; }
private:
uint32 quality;
uint32 count;
std::vector<Item*> result;
};
class FindItemsToTradeByQualityVisitor : public FindItemsByQualityVisitor
{
public:
FindItemsToTradeByQualityVisitor(uint32 quality, uint32 count) : FindItemsByQualityVisitor(quality, count) { }
public:
FindItemsToTradeByQualityVisitor(uint32 quality, uint32 count) : FindItemsByQualityVisitor(quality, count) {}
bool Visit(Item* item) override
{
if (item->IsSoulBound())
return true;
bool Visit(Item* item) override
{
if (item->IsSoulBound())
return true;
return FindItemsByQualityVisitor::Visit(item);
}
return FindItemsByQualityVisitor::Visit(item);
}
};
class FindItemsToTradeByClassVisitor : public IterateItemsVisitor
{
public:
FindItemsToTradeByClassVisitor(uint32 itemClass, uint32 itemSubClass, uint32 count)
: IterateItemsVisitor(), itemClass(itemClass), itemSubClass(itemSubClass), count(count) { } // reorder args - whipowill
public:
FindItemsToTradeByClassVisitor(uint32 itemClass, uint32 itemSubClass, uint32 count)
: IterateItemsVisitor(), itemClass(itemClass), itemSubClass(itemSubClass), count(count)
{
} // reorder args - whipowill
bool Visit(Item* item) override
{
if (item->IsSoulBound())
return true;
if (item->GetTemplate()->Class != itemClass || item->GetTemplate()->SubClass != itemSubClass)
return true;
if (result.size() >= (size_t)count)
return false;
result.push_back(item);
bool Visit(Item* item) override
{
if (item->IsSoulBound())
return true;
}
std::vector<Item*>& GetResult()
{
return result;
}
if (item->GetTemplate()->Class != itemClass || item->GetTemplate()->SubClass != itemSubClass)
return true;
private:
uint32 itemClass;
uint32 itemSubClass;
uint32 count;
std::vector<Item*> result;
if (result.size() >= (size_t)count)
return false;
result.push_back(item);
return true;
}
std::vector<Item*>& GetResult() { return result; }
private:
uint32 itemClass;
uint32 itemSubClass;
uint32 count;
std::vector<Item*> result;
};
class QueryItemCountVisitor : public IterateItemsVisitor
{
public:
QueryItemCountVisitor(uint32 itemId) : count(0), itemId(itemId) { }
public:
QueryItemCountVisitor(uint32 itemId) : count(0), itemId(itemId) {}
bool Visit(Item* item) override
{
if (item->GetTemplate()->ItemId == itemId)
count += item->GetCount();
bool Visit(Item* item) override
{
if (item->GetTemplate()->ItemId == itemId)
count += item->GetCount();
return true;
}
return true;
}
uint32 GetCount() { return count; }
uint32 GetCount() { return count; }
protected:
uint32 count;
uint32 itemId;
protected:
uint32 count;
uint32 itemId;
};
class QueryNamedItemCountVisitor : public QueryItemCountVisitor
{
public:
QueryNamedItemCountVisitor(std::string const name) : QueryItemCountVisitor(0), name(name) { }
public:
QueryNamedItemCountVisitor(std::string const name) : QueryItemCountVisitor(0), name(name) {}
bool Visit(Item* item) override
{
ItemTemplate const* proto = item->GetTemplate();
if (proto && proto->Name1.c_str() && strstri(proto->Name1.c_str(), name.c_str()))
count += item->GetCount();
bool Visit(Item* item) override
{
ItemTemplate const* proto = item->GetTemplate();
if (proto && proto->Name1.c_str() && strstri(proto->Name1.c_str(), name.c_str()))
count += item->GetCount();
return true;
}
return true;
}
private:
std::string const name;
private:
std::string const name;
};
class FindNamedItemVisitor : public FindItemVisitor
{
public:
FindNamedItemVisitor([[maybe_unused]] Player* bot, std::string const name) : FindItemVisitor(), name(name) { }
public:
FindNamedItemVisitor([[maybe_unused]] Player* bot, std::string const name) : FindItemVisitor(), name(name) {}
bool Accept(ItemTemplate const* proto) override
{
return proto && proto->Name1.c_str() && strstri(proto->Name1.c_str(), name.c_str());
}
bool Accept(ItemTemplate const* proto) override
{
return proto && proto->Name1.c_str() && strstri(proto->Name1.c_str(), name.c_str());
}
private:
std::string const name;
private:
std::string const name;
};
class FindItemByIdVisitor : public FindItemVisitor
{
public:
FindItemByIdVisitor(uint32 id) : FindItemVisitor(), id(id) { }
public:
FindItemByIdVisitor(uint32 id) : FindItemVisitor(), id(id) {}
bool Accept(ItemTemplate const* proto) override
{
return proto->ItemId == id;
}
bool Accept(ItemTemplate const* proto) override { return proto->ItemId == id; }
private:
uint32 id;
private:
uint32 id;
};
class FindItemByIdsVisitor : public FindItemVisitor
{
public:
FindItemByIdsVisitor(ItemIds ids) : FindItemVisitor(), ids(ids) { }
public:
FindItemByIdsVisitor(ItemIds ids) : FindItemVisitor(), ids(ids) {}
bool Accept(ItemTemplate const* proto) override
{
return ids.find(proto->ItemId) != ids.end();
}
bool Accept(ItemTemplate const* proto) override { return ids.find(proto->ItemId) != ids.end(); }
private:
ItemIds ids;
private:
ItemIds ids;
};
class ListItemsVisitor : public IterateItemsVisitor
{
public:
ListItemsVisitor() : IterateItemsVisitor() { }
public:
ListItemsVisitor() : IterateItemsVisitor() {}
std::map<uint32, uint32> items;
std::map<uint32, bool> soulbound;
std::map<uint32, uint32> items;
std::map<uint32, bool> soulbound;
bool Visit(Item* item) override
{
uint32 id = item->GetTemplate()->ItemId;
bool Visit(Item* item) override
{
uint32 id = item->GetTemplate()->ItemId;
if (items.find(id) == items.end())
items[id] = 0;
if (items.find(id) == items.end())
items[id] = 0;
items[id] += item->GetCount();
soulbound[id] = item->IsSoulBound();
return true;
}
items[id] += item->GetCount();
soulbound[id] = item->IsSoulBound();
return true;
}
};
class ItemCountByQuality : public IterateItemsVisitor
{
public:
ItemCountByQuality() : IterateItemsVisitor()
{
for (uint32 i = 0; i < MAX_ITEM_QUALITY; ++i)
count[i] = 0;
}
public:
ItemCountByQuality() : IterateItemsVisitor()
{
for (uint32 i = 0; i < MAX_ITEM_QUALITY; ++i)
count[i] = 0;
}
bool Visit(Item* item) override
{
++count[item->GetTemplate()->Quality];
return true;
}
bool Visit(Item* item) override
{
++count[item->GetTemplate()->Quality];
return true;
}
public:
std::map<uint32, uint32> count;
public:
std::map<uint32, uint32> count;
};
class FindPotionVisitor : public FindUsableItemVisitor
{
public:
FindPotionVisitor(Player* bot, uint32 effectId) : FindUsableItemVisitor(bot), effectId(effectId) { }
public:
FindPotionVisitor(Player* bot, uint32 effectId) : FindUsableItemVisitor(bot), effectId(effectId) {}
bool Accept(ItemTemplate const* proto) override;
bool Accept(ItemTemplate const* proto) override;
private:
uint32 effectId;
private:
uint32 effectId;
};
class FindFoodVisitor : public FindUsableItemVisitor
{
public:
FindFoodVisitor(Player* bot, uint32 spellCategory, bool conjured = false) : FindUsableItemVisitor(bot),
spellCategory(spellCategory), conjured(conjured) { }
public:
FindFoodVisitor(Player* bot, uint32 spellCategory, bool conjured = false)
: FindUsableItemVisitor(bot), spellCategory(spellCategory), conjured(conjured)
{
}
bool Accept(ItemTemplate const* proto) override
{
return proto->Class == ITEM_CLASS_CONSUMABLE && (proto->SubClass == ITEM_SUBCLASS_CONSUMABLE || proto->SubClass == ITEM_SUBCLASS_FOOD) &&
proto->Spells[0].SpellCategory == spellCategory && (!conjured || proto->IsConjuredConsumable());
}
bool Accept(ItemTemplate const* proto) override
{
return proto->Class == ITEM_CLASS_CONSUMABLE &&
(proto->SubClass == ITEM_SUBCLASS_CONSUMABLE || proto->SubClass == ITEM_SUBCLASS_FOOD) &&
proto->Spells[0].SpellCategory == spellCategory && (!conjured || proto->IsConjuredConsumable());
}
private:
uint32 spellCategory;
bool conjured;
private:
uint32 spellCategory;
bool conjured;
};
class FindMountVisitor : public FindUsableItemVisitor
{
public:
FindMountVisitor(Player* bot) : FindUsableItemVisitor(bot) { }
public:
FindMountVisitor(Player* bot) : FindUsableItemVisitor(bot) {}
bool Accept(ItemTemplate const* proto) override;
bool Accept(ItemTemplate const* proto) override;
private:
uint32 effectId;
private:
uint32 effectId;
};
class FindPetVisitor : public FindUsableItemVisitor
{
public:
FindPetVisitor(Player* bot) : FindUsableItemVisitor(bot) { }
public:
FindPetVisitor(Player* bot) : FindUsableItemVisitor(bot) {}
bool Accept(ItemTemplate const* proto) override;
bool Accept(ItemTemplate const* proto) override;
};
class FindAmmoVisitor : public FindUsableItemVisitor
{
public:
FindAmmoVisitor(Player* bot, uint32 weaponType) : FindUsableItemVisitor(bot), weaponType(weaponType) { }
public:
FindAmmoVisitor(Player* bot, uint32 weaponType) : FindUsableItemVisitor(bot), weaponType(weaponType) {}
bool Accept(ItemTemplate const* proto)override
bool Accept(ItemTemplate const* proto) override
{
if (proto->Class == ITEM_CLASS_PROJECTILE)
{
if (proto->Class == ITEM_CLASS_PROJECTILE)
uint32 subClass = 0;
switch (weaponType)
{
uint32 subClass = 0;
switch (weaponType)
{
case ITEM_SUBCLASS_WEAPON_GUN:
subClass = ITEM_SUBCLASS_BULLET;
break;
case ITEM_SUBCLASS_WEAPON_BOW:
case ITEM_SUBCLASS_WEAPON_CROSSBOW:
subClass = ITEM_SUBCLASS_ARROW;
break;
}
if (!subClass)
return false;
if (proto->SubClass == subClass)
return true;
case ITEM_SUBCLASS_WEAPON_GUN:
subClass = ITEM_SUBCLASS_BULLET;
break;
case ITEM_SUBCLASS_WEAPON_BOW:
case ITEM_SUBCLASS_WEAPON_CROSSBOW:
subClass = ITEM_SUBCLASS_ARROW;
break;
}
return false;
if (!subClass)
return false;
if (proto->SubClass == subClass)
return true;
}
private:
uint32 weaponType;
return false;
}
private:
uint32 weaponType;
};
class FindQuestItemVisitor : public FindUsableItemVisitor
{
public:
FindQuestItemVisitor(Player* bot) : FindUsableItemVisitor(bot) { }
public:
FindQuestItemVisitor(Player* bot) : FindUsableItemVisitor(bot) {}
bool Accept(ItemTemplate const* proto) override
bool Accept(ItemTemplate const* proto) override
{
if (proto->Class == ITEM_CLASS_QUEST)
{
if (proto->Class == ITEM_CLASS_QUEST)
{
return true;
}
return false;
return true;
}
return false;
}
};
class FindRecipeVisitor : public FindUsableItemVisitor
{
public:
FindRecipeVisitor(Player* bot, SkillType skill = SKILL_NONE) : FindUsableItemVisitor(bot), skill(skill) { };
public:
FindRecipeVisitor(Player* bot, SkillType skill = SKILL_NONE) : FindUsableItemVisitor(bot), skill(skill){};
bool Accept(ItemTemplate const* proto) override
bool Accept(ItemTemplate const* proto) override
{
if (proto->Class == ITEM_CLASS_RECIPE)
{
if (proto->Class == ITEM_CLASS_RECIPE)
if (skill == SKILL_NONE)
return true;
switch (proto->SubClass)
{
if (skill == SKILL_NONE)
return true;
switch (proto->SubClass)
{
case ITEM_SUBCLASS_LEATHERWORKING_PATTERN:
return skill == SKILL_LEATHERWORKING;
case ITEM_SUBCLASS_TAILORING_PATTERN:
return skill == SKILL_TAILORING;
case ITEM_SUBCLASS_ENGINEERING_SCHEMATIC:
return skill == SKILL_ENGINEERING;
case ITEM_SUBCLASS_BLACKSMITHING:
return skill == SKILL_BLACKSMITHING;
case ITEM_SUBCLASS_COOKING_RECIPE:
return skill == SKILL_COOKING;
case ITEM_SUBCLASS_ALCHEMY_RECIPE:
return skill == SKILL_ALCHEMY;
case ITEM_SUBCLASS_FIRST_AID_MANUAL:
return skill == SKILL_FIRST_AID;
case ITEM_SUBCLASS_ENCHANTING_FORMULA:
return skill == SKILL_ENCHANTING;
case ITEM_SUBCLASS_FISHING_MANUAL:
return skill == SKILL_FISHING;
}
case ITEM_SUBCLASS_LEATHERWORKING_PATTERN:
return skill == SKILL_LEATHERWORKING;
case ITEM_SUBCLASS_TAILORING_PATTERN:
return skill == SKILL_TAILORING;
case ITEM_SUBCLASS_ENGINEERING_SCHEMATIC:
return skill == SKILL_ENGINEERING;
case ITEM_SUBCLASS_BLACKSMITHING:
return skill == SKILL_BLACKSMITHING;
case ITEM_SUBCLASS_COOKING_RECIPE:
return skill == SKILL_COOKING;
case ITEM_SUBCLASS_ALCHEMY_RECIPE:
return skill == SKILL_ALCHEMY;
case ITEM_SUBCLASS_FIRST_AID_MANUAL:
return skill == SKILL_FIRST_AID;
case ITEM_SUBCLASS_ENCHANTING_FORMULA:
return skill == SKILL_ENCHANTING;
case ITEM_SUBCLASS_FISHING_MANUAL:
return skill == SKILL_FISHING;
}
return false;
}
private:
SkillType skill;
return false;
}
private:
SkillType skill;
};
class FindItemUsageVisitor : public FindUsableItemVisitor
{
public:
FindItemUsageVisitor(Player* bot, ItemUsage usage = ITEM_USAGE_NONE);
public:
FindItemUsageVisitor(Player* bot, ItemUsage usage = ITEM_USAGE_NONE);
bool Accept(ItemTemplate const* proto) override;
bool Accept(ItemTemplate const* proto) override;
private:
AiObjectContext* context;
ItemUsage usage;
private:
AiObjectContext* context;
ItemUsage usage;
};
class FindUsableNamedItemVisitor : public FindUsableItemVisitor
{
public:
FindUsableNamedItemVisitor(Player* bot, std::string name): FindUsableItemVisitor(bot), name(name) {}
public:
FindUsableNamedItemVisitor(Player* bot, std::string name) : FindUsableItemVisitor(bot), name(name) {}
bool Accept(ItemTemplate const* proto) override;
private:
std::string name;
bool Accept(ItemTemplate const* proto) override;
private:
std::string name;
};
#endif

11
src/strategy/Multiplier.h
View File

@@ -1,5 +1,6 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#ifndef _PLAYERBOT_MULTIPLIER_H
@@ -12,11 +13,11 @@ class PlayerbotAI;
class Multiplier : public AiNamedObject
{
public:
Multiplier(PlayerbotAI* botAI, std::string const name) : AiNamedObject(botAI, name) {}
virtual ~Multiplier() { }
public:
Multiplier(PlayerbotAI* botAI, std::string const name) : AiNamedObject(botAI, name) {}
virtual ~Multiplier() {}
virtual float GetValue([[maybe_unused]] Action* action) { return 1.0f; }
virtual float GetValue([[maybe_unused]] Action* action) { return 1.0f; }
};
#endif

6
src/strategy/NamedObjectContext.cpp
View File

@@ -1,8 +1,10 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#include "NamedObjectContext.h"
#include "Playerbots.h"
void Qualified::Qualify(int qual)
@@ -24,7 +26,7 @@ std::string const Qualified::MultiQualify(std::vector<std::string> qualifiers)
std::vector<std::string> Qualified::getMultiQualifiers(std::string const qualifier1)
{
std::istringstream iss(qualifier1);
return { std::istream_iterator<std::string>{iss}, std::istream_iterator<std::string>{} };
return {std::istream_iterator<std::string>{iss}, std::istream_iterator<std::string>{}};
}
int32 Qualified::getMultiQualifier(std::string const qualifier1, uint32 pos)

403
src/strategy/NamedObjectContext.h
View File

@@ -1,283 +1,272 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#ifndef _PLAYERBOT_NAMEDOBJECTCONEXT_H
#define _PLAYERBOT_NAMEDOBJECTCONEXT_H
#include "Common.h"
#include <unordered_map>
#include <set>
#include <unordered_set>
#include <list>
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#include "Common.h"
class PlayerbotAI;
class Qualified
{
public:
Qualified() { };
Qualified(std::string const qualifier) : qualifier(qualifier) { }
Qualified(int32 qualifier1)
{
Qualify(qualifier1);
}
public:
Qualified(){};
Qualified(std::string const qualifier) : qualifier(qualifier) {}
Qualified(int32 qualifier1) { Qualify(qualifier1); }
virtual void Qualify(int qual);
virtual void Qualify(int qual);
virtual void Qualify(std::string const qual)
{
qualifier = qual;
}
virtual void Qualify(std::string const qual) { qualifier = qual; }
std::string const getQualifier() { return qualifier; }
std::string const getQualifier() { return qualifier; }
static std::string const MultiQualify(std::vector<std::string> qualifiers);
static std::vector<std::string> getMultiQualifiers(std::string const qualifier1);
static int32 getMultiQualifier(std::string const qualifier1, uint32 pos);
static std::string const MultiQualify(std::vector<std::string> qualifiers);
static std::vector<std::string> getMultiQualifiers(std::string const qualifier1);
static int32 getMultiQualifier(std::string const qualifier1, uint32 pos);
protected:
std::string qualifier;
protected:
std::string qualifier;
};
template <class T>
class NamedObjectFactory
{
protected:
typedef T*(*ActionCreator)(PlayerbotAI* botAI);
std::unordered_map<std::string, ActionCreator> creators;
protected:
typedef T* (*ActionCreator)(PlayerbotAI* botAI);
std::unordered_map<std::string, ActionCreator> creators;
public:
T* create(std::string name, PlayerbotAI* botAI)
public:
T* create(std::string name, PlayerbotAI* botAI)
{
size_t found = name.find("::");
std::string qualifier;
if (found != std::string::npos)
{
size_t found = name.find("::");
std::string qualifier;
if (found != std::string::npos)
{
qualifier = name.substr(found + 2);
name = name.substr(0, found);
}
if (creators.find(name) == creators.end())
return nullptr;
ActionCreator creator = creators[name];
if (!creator)
return nullptr;
T* object = (*creator)(botAI);
Qualified* q = dynamic_cast<Qualified*>(object);
if (q && found != std::string::npos)
q->Qualify(qualifier);
return object;
qualifier = name.substr(found + 2);
name = name.substr(0, found);
}
std::set<std::string> supports()
{
std::set<std::string> keys;
for (typename std::unordered_map<std::string, ActionCreator>::iterator it = creators.begin(); it != creators.end(); it++)
keys.insert(it->first);
if (creators.find(name) == creators.end())
return nullptr;
return keys;
}
ActionCreator creator = creators[name];
if (!creator)
return nullptr;
T* object = (*creator)(botAI);
Qualified* q = dynamic_cast<Qualified*>(object);
if (q && found != std::string::npos)
q->Qualify(qualifier);
return object;
}
std::set<std::string> supports()
{
std::set<std::string> keys;
for (typename std::unordered_map<std::string, ActionCreator>::iterator it = creators.begin();
it != creators.end(); it++)
keys.insert(it->first);
return keys;
}
};
template <class T>
class NamedObjectContext : public NamedObjectFactory<T>
{
public:
NamedObjectContext(bool shared = false, bool supportsSiblings = false) :
NamedObjectFactory<T>(), shared(shared), supportsSiblings(supportsSiblings) { }
public:
NamedObjectContext(bool shared = false, bool supportsSiblings = false)
: NamedObjectFactory<T>(), shared(shared), supportsSiblings(supportsSiblings)
{
}
virtual ~NamedObjectContext()
virtual ~NamedObjectContext() { Clear(); }
T* create(std::string const name, PlayerbotAI* botAI)
{
if (created.find(name) == created.end())
return created[name] = NamedObjectFactory<T>::create(name, botAI);
return created[name];
}
void Clear()
{
for (typename std::unordered_map<std::string, T*>::iterator i = created.begin(); i != created.end(); i++)
{
Clear();
if (i->second)
delete i->second;
}
T* create(std::string const name, PlayerbotAI* botAI)
created.clear();
}
void Update()
{
for (typename std::unordered_map<std::string, T*>::iterator i = created.begin(); i != created.end(); i++)
{
if (created.find(name) == created.end())
return created[name] = NamedObjectFactory<T>::create(name, botAI);
return created[name];
if (i->second)
i->second->Update();
}
}
void Clear()
void Reset()
{
for (typename std::unordered_map<std::string, T*>::iterator i = created.begin(); i != created.end(); i++)
{
for (typename std::unordered_map<std::string, T*>::iterator i = created.begin(); i != created.end(); i++)
{
if (i->second)
delete i->second;
}
created.clear();
if (i->second)
i->second->Reset();
}
}
void Update()
{
for (typename std::unordered_map<std::string, T*>::iterator i = created.begin(); i != created.end(); i++)
{
if (i->second)
i->second->Update();
}
}
bool IsShared() { return shared; }
bool IsSupportsSiblings() { return supportsSiblings; }
void Reset()
{
for (typename std::unordered_map<std::string, T*>::iterator i = created.begin(); i != created.end(); i++)
{
if (i->second)
i->second->Reset();
}
}
std::set<std::string> GetCreated()
{
std::set<std::string> keys;
for (typename std::unordered_map<std::string, T*>::iterator it = created.begin(); it != created.end(); it++)
keys.insert(it->first);
bool IsShared() { return shared; }
bool IsSupportsSiblings() { return supportsSiblings; }
return keys;
}
std::set<std::string> GetCreated()
{
std::set<std::string> keys;
for (typename std::unordered_map<std::string, T*>::iterator it = created.begin(); it != created.end(); it++)
keys.insert(it->first);
return keys;
}
protected:
std::unordered_map<std::string, T*> created;
bool shared;
bool supportsSiblings;
protected:
std::unordered_map<std::string, T*> created;
bool shared;
bool supportsSiblings;
};
template <class T>
class NamedObjectContextList
{
public:
virtual ~NamedObjectContextList()
public:
virtual ~NamedObjectContextList()
{
for (typename std::vector<NamedObjectContext<T>*>::iterator i = contexts.begin(); i != contexts.end(); i++)
{
for (typename std::vector<NamedObjectContext<T>*>::iterator i = contexts.begin(); i != contexts.end(); i++)
{
NamedObjectContext<T>* context = *i;
if (!context->IsShared())
delete context;
}
NamedObjectContext<T>* context = *i;
if (!context->IsShared())
delete context;
}
}
void Add(NamedObjectContext<T>* context) { contexts.push_back(context); }
T* GetContextObject(std::string const name, PlayerbotAI* botAI)
{
for (typename std::vector<NamedObjectContext<T>*>::iterator i = contexts.begin(); i != contexts.end(); i++)
{
if (T* object = (*i)->create(name, botAI))
return object;
}
void Add(NamedObjectContext<T>* context)
return nullptr;
}
void Update()
{
for (typename std::vector<NamedObjectContext<T>*>::iterator i = contexts.begin(); i != contexts.end(); i++)
{
contexts.push_back(context);
if (!(*i)->IsShared())
(*i)->Update();
}
}
void Reset()
{
for (typename std::vector<NamedObjectContext<T>*>::iterator i = contexts.begin(); i != contexts.end(); i++)
{
(*i)->Reset();
}
}
std::set<std::string> GetSiblings(std::string const name)
{
for (typename std::vector<NamedObjectContext<T>*>::iterator i = contexts.begin(); i != contexts.end(); i++)
{
if (!(*i)->IsSupportsSiblings())
continue;
std::set<std::string> supported = (*i)->supports();
std::set<std::string>::iterator found = supported.find(name);
if (found == supported.end())
continue;
supported.erase(found);
return supported;
}
T* GetContextObject(std::string const name, PlayerbotAI* botAI)
{
for (typename std::vector<NamedObjectContext<T>*>::iterator i = contexts.begin(); i != contexts.end(); i++)
{
if (T* object = (*i)->create(name, botAI))
return object;
}
return std::set<std::string>();
}
return nullptr;
std::set<std::string> supports()
{
std::set<std::string> result;
for (typename std::vector<NamedObjectContext<T>*>::iterator i = contexts.begin(); i != contexts.end(); i++)
{
std::set<std::string> supported = (*i)->supports();
for (std::set<std::string>::iterator j = supported.begin(); j != supported.end(); j++)
result.insert(*j);
}
void Update()
return result;
}
std::set<std::string> GetCreated()
{
std::set<std::string> result;
for (typename std::vector<NamedObjectContext<T>*>::iterator i = contexts.begin(); i != contexts.end(); i++)
{
for (typename std::vector<NamedObjectContext<T>*>::iterator i = contexts.begin(); i != contexts.end(); i++)
{
if (!(*i)->IsShared())
(*i)->Update();
}
std::set<std::string> createdKeys = (*i)->GetCreated();
for (std::set<std::string>::iterator j = createdKeys.begin(); j != createdKeys.end(); j++)
result.insert(*j);
}
void Reset()
{
for (typename std::vector<NamedObjectContext<T>*>::iterator i = contexts.begin(); i != contexts.end(); i++)
{
(*i)->Reset();
}
}
return result;
}
std::set<std::string> GetSiblings(std::string const name)
{
for (typename std::vector<NamedObjectContext<T>*>::iterator i = contexts.begin(); i != contexts.end(); i++)
{
if (!(*i)->IsSupportsSiblings())
continue;
std::set<std::string> supported = (*i)->supports();
std::set<std::string>::iterator found = supported.find(name);
if (found == supported.end())
continue;
supported.erase(found);
return supported;
}
return std::set<std::string>();
}
std::set<std::string> supports()
{
std::set<std::string> result;
for (typename std::vector<NamedObjectContext<T>*>::iterator i = contexts.begin(); i != contexts.end(); i++)
{
std::set<std::string> supported = (*i)->supports();
for (std::set<std::string>::iterator j = supported.begin(); j != supported.end(); j++)
result.insert(*j);
}
return result;
}
std::set<std::string> GetCreated()
{
std::set<std::string> result;
for (typename std::vector<NamedObjectContext<T>*>::iterator i = contexts.begin(); i != contexts.end(); i++)
{
std::set<std::string> createdKeys = (*i)->GetCreated();
for (std::set<std::string>::iterator j = createdKeys.begin(); j != createdKeys.end(); j++)
result.insert(*j);
}
return result;
}
private:
std::vector<NamedObjectContext<T>*> contexts;
private:
std::vector<NamedObjectContext<T>*> contexts;
};
template <class T>
class NamedObjectFactoryList
{
public:
virtual ~NamedObjectFactoryList()
public:
virtual ~NamedObjectFactoryList()
{
for (typename std::list<NamedObjectFactory<T>*>::iterator i = factories.begin(); i != factories.end(); i++)
delete *i;
}
void Add(NamedObjectFactory<T>* context) { factories.push_front(context); }
T* GetContextObject(std::string const& name, PlayerbotAI* botAI)
{
for (typename std::list<NamedObjectFactory<T>*>::iterator i = factories.begin(); i != factories.end(); i++)
{
for (typename std::list<NamedObjectFactory<T>*>::iterator i = factories.begin(); i != factories.end(); i++)
delete *i;
if (T* object = (*i)->create(name, botAI))
return object;
}
void Add(NamedObjectFactory<T>* context)
{
factories.push_front(context);
}
return nullptr;
}
T* GetContextObject(std::string const &name, PlayerbotAI* botAI)
{
for (typename std::list<NamedObjectFactory<T>*>::iterator i = factories.begin(); i != factories.end(); i++)
{
if (T* object = (*i)->create(name, botAI))
return object;
}
return nullptr;
}
private:
std::list<NamedObjectFactory<T>*> factories;
private:
std::list<NamedObjectFactory<T>*> factories;
};
#endif

6
src/strategy/PassiveMultiplier.cpp
View File

@@ -1,8 +1,10 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#include "PassiveMultiplier.h"
#include "Action.h"
#include "AiObjectContext.h"
@@ -30,7 +32,7 @@ PassiveMultiplier::PassiveMultiplier(PlayerbotAI* botAI) : Multiplier(botAI, "pa
float PassiveMultiplier::GetValue(Action* action)
{
if (!action)
return 1.0f;
return 1.0f;
std::string const name = action->getName();

19
src/strategy/PassiveMultiplier.h
View File

@@ -1,27 +1,28 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#ifndef _PLAYERBOT_PASSIVEMULTIPLIER_H
#define _PLAYERBOT_PASSIVEMULTIPLIER_H
#include "Multiplier.h"
#include <vector>
#include "Multiplier.h"
class Action;
class PlayerbotAI;
class PassiveMultiplier : public Multiplier
{
public:
PassiveMultiplier(PlayerbotAI* botAI);
public:
PassiveMultiplier(PlayerbotAI* botAI);
float GetValue(Action* action) override;
float GetValue(Action* action) override;
private:
static std::vector<std::string> allowedActions;
static std::vector<std::string> allowedParts;
private:
static std::vector<std::string> allowedActions;
static std::vector<std::string> allowedParts;
};
#endif

61
src/strategy/Queue.cpp
View File

@@ -1,26 +1,28 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#include "Queue.h"
#include "AiObjectContext.h"
#include "Log.h"
#include "PlayerbotAIConfig.h"
void Queue::Push(ActionBasket *action)
void Queue::Push(ActionBasket* action)
{
if (action)
if (action)
{
for (std::list<ActionBasket*>::iterator iter = actions.begin(); iter != actions.end(); iter++)
{
ActionBasket* basket = *iter;
if (action->getAction()->getName() == basket->getAction()->getName())
{
if (basket->getRelevance() < action->getRelevance())
basket->setRelevance(action->getRelevance());
if (basket->getRelevance() < action->getRelevance())
basket->setRelevance(action->getRelevance());
if (ActionNode* actionNode = action->getAction())
delete actionNode;
if (ActionNode* actionNode = action->getAction())
delete actionNode;
delete action;
@@ -28,34 +30,34 @@ void Queue::Push(ActionBasket *action)
}
}
actions.push_back(action);
actions.push_back(action);
}
}
ActionNode* Queue::Pop()
{
float max = -1;
ActionBasket* selection = nullptr;
float max = -1;
ActionBasket* selection = nullptr;
for (std::list<ActionBasket*>::iterator iter = actions.begin(); iter != actions.end(); iter++)
{
ActionBasket* basket = *iter;
if (basket->getRelevance() > max)
{
max = basket->getRelevance();
selection = basket;
}
}
for (std::list<ActionBasket*>::iterator iter = actions.begin(); iter != actions.end(); iter++)
{
ActionBasket* basket = *iter;
if (basket->getRelevance() > max)
{
max = basket->getRelevance();
selection = basket;
}
}
if (selection != nullptr)
{
ActionNode* action = selection->getAction();
actions.remove(selection);
delete selection;
return action;
}
if (selection != nullptr)
{
ActionNode* action = selection->getAction();
actions.remove(selection);
delete selection;
return action;
}
return nullptr;
return nullptr;
}
ActionBasket* Queue::Peek()
@@ -75,10 +77,7 @@ ActionBasket* Queue::Peek()
return selection;
}
uint32 Queue::Size()
{
return actions.size();
}
uint32 Queue::Size() { return actions.size(); }
void Queue::RemoveExpired()
{

25
src/strategy/Queue.h
View File

@@ -1,27 +1,28 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#ifndef _PLAYERBOT_QUEUE_H
#define _PLAYERBOT_QUEUE_H
#include "Common.h"
#include "Action.h"
#include "Common.h"
class Queue
{
public:
Queue(void) { }
~Queue(void) { }
public:
Queue(void) {}
~Queue(void) {}
void Push(ActionBasket *action);
ActionNode* Pop();
ActionBasket* Peek();
uint32 Size();
void RemoveExpired();
void Push(ActionBasket* action);
ActionNode* Pop();
ActionBasket* Peek();
uint32 Size();
void RemoveExpired();
private:
std::list<ActionBasket*> actions;
private:
std::list<ActionBasket*> actions;
};
#endif

196
src/strategy/Strategy.cpp
View File

@@ -1,116 +1,118 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#include "Strategy.h"
#include "Playerbots.h"
class ActionNodeFactoryInternal : public NamedObjectFactory<ActionNode>
{
public:
ActionNodeFactoryInternal()
{
creators["melee"] = &melee;
creators["healthstone"] = &healthstone;
creators["be near"] = &follow_master_random;
creators["attack anything"] = &attack_anything;
creators["move random"] = &move_random;
creators["move to loot"] = &move_to_loot;
creators["food"] = &food;
creators["drink"] = &drink;
creators["mana potion"] = &mana_potion;
creators["healing potion"] = &healing_potion;
creators["flee"] = &flee;
}
public:
ActionNodeFactoryInternal()
{
creators["melee"] = &melee;
creators["healthstone"] = &healthstone;
creators["be near"] = &follow_master_random;
creators["attack anything"] = &attack_anything;
creators["move random"] = &move_random;
creators["move to loot"] = &move_to_loot;
creators["food"] = &food;
creators["drink"] = &drink;
creators["mana potion"] = &mana_potion;
creators["healing potion"] = &healing_potion;
creators["flee"] = &flee;
}
private:
static ActionNode* melee([[maybe_unused]] PlayerbotAI* botAI)
{
return new ActionNode ("melee",
/*P*/ nullptr,
/*A*/ nullptr,
/*C*/ nullptr);
}
private:
static ActionNode* melee([[maybe_unused]] PlayerbotAI* botAI)
{
return new ActionNode("melee",
/*P*/ nullptr,
/*A*/ nullptr,
/*C*/ nullptr);
}
static ActionNode* healthstone([[maybe_unused]] PlayerbotAI* botAI)
{
return new ActionNode ("healthstone",
/*P*/ nullptr,
/*A*/ NextAction::array(0, new NextAction("healing potion"), nullptr),
/*C*/ nullptr);
}
static ActionNode* healthstone([[maybe_unused]] PlayerbotAI* botAI)
{
return new ActionNode("healthstone",
/*P*/ nullptr,
/*A*/ NextAction::array(0, new NextAction("healing potion"), nullptr),
/*C*/ nullptr);
}
static ActionNode* follow_master_random([[maybe_unused]] PlayerbotAI* botAI)
{
return new ActionNode ("be near",
/*P*/ nullptr,
/*A*/ NextAction::array(0, new NextAction("follow"), nullptr),
/*C*/ nullptr);
}
static ActionNode* follow_master_random([[maybe_unused]] PlayerbotAI* botAI)
{
return new ActionNode("be near",
/*P*/ nullptr,
/*A*/ NextAction::array(0, new NextAction("follow"), nullptr),
/*C*/ nullptr);
}
static ActionNode* attack_anything([[maybe_unused]] PlayerbotAI* botAI)
{
return new ActionNode ("attack anything",
/*P*/ nullptr,
/*A*/ nullptr,
/*C*/ nullptr);
}
static ActionNode* attack_anything([[maybe_unused]] PlayerbotAI* botAI)
{
return new ActionNode("attack anything",
/*P*/ nullptr,
/*A*/ nullptr,
/*C*/ nullptr);
}
static ActionNode* move_random([[maybe_unused]] PlayerbotAI* botAI)
{
return new ActionNode ("move random",
/*P*/ nullptr,
/*A*/ NextAction::array(0, new NextAction("stay line"), nullptr),
/*C*/ nullptr);
}
static ActionNode* move_random([[maybe_unused]] PlayerbotAI* botAI)
{
return new ActionNode("move random",
/*P*/ nullptr,
/*A*/ NextAction::array(0, new NextAction("stay line"), nullptr),
/*C*/ nullptr);
}
static ActionNode* move_to_loot([[maybe_unused]] PlayerbotAI* botAI)
{
return new ActionNode ("move to loot",
/*P*/ nullptr,
/*A*/ nullptr,
/*C*/ nullptr);
}
static ActionNode* move_to_loot([[maybe_unused]] PlayerbotAI* botAI)
{
return new ActionNode("move to loot",
/*P*/ nullptr,
/*A*/ nullptr,
/*C*/ nullptr);
}
static ActionNode* food([[maybe_unused]] PlayerbotAI* botAI)
{
return new ActionNode ("food",
/*P*/ nullptr,
/*A*/ nullptr,
/*C*/ nullptr);
}
static ActionNode* food([[maybe_unused]] PlayerbotAI* botAI)
{
return new ActionNode("food",
/*P*/ nullptr,
/*A*/ nullptr,
/*C*/ nullptr);
}
static ActionNode* drink([[maybe_unused]] PlayerbotAI* botAI)
{
return new ActionNode ("drink",
/*P*/ nullptr,
/*A*/ nullptr,
/*C*/ nullptr);
}
static ActionNode* drink([[maybe_unused]] PlayerbotAI* botAI)
{
return new ActionNode("drink",
/*P*/ nullptr,
/*A*/ nullptr,
/*C*/ nullptr);
}
static ActionNode* mana_potion([[maybe_unused]] PlayerbotAI* botAI)
{
return new ActionNode ("mana potion",
/*P*/ nullptr,
/*A*/ NextAction::array(0, new NextAction("drink"), nullptr),
/*C*/ nullptr);
}
static ActionNode* mana_potion([[maybe_unused]] PlayerbotAI* botAI)
{
return new ActionNode("mana potion",
/*P*/ nullptr,
/*A*/ NextAction::array(0, new NextAction("drink"), nullptr),
/*C*/ nullptr);
}
static ActionNode* healing_potion([[maybe_unused]] PlayerbotAI* botAI)
{
return new ActionNode ("healing potion",
/*P*/ nullptr,
/*A*/ NextAction::array(0, new NextAction("food"), nullptr),
/*C*/ nullptr);
}
static ActionNode* healing_potion([[maybe_unused]] PlayerbotAI* botAI)
{
return new ActionNode("healing potion",
/*P*/ nullptr,
/*A*/ NextAction::array(0, new NextAction("food"), nullptr),
/*C*/ nullptr);
}
static ActionNode* flee([[maybe_unused]] PlayerbotAI* botAI)
{
return new ActionNode ("flee",
/*P*/ nullptr,
/*A*/ nullptr,
/*C*/ nullptr);
}
static ActionNode* flee([[maybe_unused]] PlayerbotAI* botAI)
{
return new ActionNode("flee",
/*P*/ nullptr,
/*A*/ nullptr,
/*C*/ nullptr);
}
};
Strategy::Strategy(PlayerbotAI* botAI) : PlayerbotAIAware(botAI)
@@ -118,8 +120,4 @@ Strategy::Strategy(PlayerbotAI* botAI) : PlayerbotAIAware(botAI)
actionNodeFactories.Add(new ActionNodeFactoryInternal());
}
ActionNode* Strategy::GetAction(std::string const name)
{
return actionNodeFactories.GetContextObject(name, botAI);
}
ActionNode* Strategy::GetAction(std::string const name) { return actionNodeFactories.GetContextObject(name, botAI); }

49
src/strategy/Strategy.h
View File

@@ -1,26 +1,27 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#ifndef _PLAYERBOT_STRATEGY_H
#define _PLAYERBOT_STRATEGY_H
#include "Action.h"
#include "NamedObjectContext.h"
#include "Multiplier.h"
#include "Trigger.h"
#include "NamedObjectContext.h"
#include "PlayerbotAIAware.h"
#include "Trigger.h"
enum StrategyType : uint32
{
STRATEGY_TYPE_GENERIC = 0,
STRATEGY_TYPE_COMBAT = 1,
STRATEGY_TYPE_NONCOMBAT = 2,
STRATEGY_TYPE_TANK = 4,
STRATEGY_TYPE_DPS = 8,
STRATEGY_TYPE_HEAL = 16,
STRATEGY_TYPE_RANGED = 32,
STRATEGY_TYPE_MELEE = 64
STRATEGY_TYPE_GENERIC = 0,
STRATEGY_TYPE_COMBAT = 1,
STRATEGY_TYPE_NONCOMBAT = 2,
STRATEGY_TYPE_TANK = 4,
STRATEGY_TYPE_DPS = 8,
STRATEGY_TYPE_HEAL = 16,
STRATEGY_TYPE_RANGED = 32,
STRATEGY_TYPE_MELEE = 64
};
// enum ActionPriority
@@ -54,21 +55,21 @@ static float ACTION_EMERGENCY = 90.0f;
class Strategy : public PlayerbotAIAware
{
public:
Strategy(PlayerbotAI* botAI);
virtual ~Strategy() { }
public:
Strategy(PlayerbotAI* botAI);
virtual ~Strategy() {}
virtual NextAction** getDefaultActions() { return nullptr; }
virtual void InitTriggers([[maybe_unused]] std::vector<TriggerNode*> &triggers) { }
virtual void InitMultipliers([[maybe_unused]] std::vector<Multiplier*> &multipliers) { }
virtual std::string const getName() = 0;
virtual uint32 GetType() const { return STRATEGY_TYPE_GENERIC; }
virtual ActionNode* GetAction(std::string const name);
void Update() { }
void Reset() { }
virtual NextAction** getDefaultActions() { return nullptr; }
virtual void InitTriggers([[maybe_unused]] std::vector<TriggerNode*>& triggers) {}
virtual void InitMultipliers([[maybe_unused]] std::vector<Multiplier*>& multipliers) {}
virtual std::string const getName() = 0;
virtual uint32 GetType() const { return STRATEGY_TYPE_GENERIC; }
virtual ActionNode* GetAction(std::string const name);
void Update() {}
void Reset() {}
protected:
NamedObjectFactoryList<ActionNode> actionNodeFactories;
protected:
NamedObjectFactoryList<ActionNode> actionNodeFactories;
};
#endif

341
src/strategy/StrategyContext.h
View File

@@ -1,17 +1,17 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#ifndef _PLAYERBOT_STRATEGYCONTEXT_H
#define _PLAYERBOT_STRATEGYCONTEXT_H
#include "CustomStrategy.h"
#include "NamedObjectContext.h"
#include "AttackEnemyPlayersStrategy.h"
#include "BattlegroundStrategy.h"
#include "CastTimeStrategy.h"
#include "ChatCommandHandlerStrategy.h"
#include "ConserveManaStrategy.h"
#include "CustomStrategy.h"
#include "DeadStrategy.h"
#include "DebugStrategy.h"
#include "DpsAssistStrategy.h"
@@ -29,15 +29,16 @@
#include "MaintenanceStrategy.h"
#include "MarkRtiStrategy.h"
#include "MeleeCombatStrategy.h"
#include "NamedObjectContext.h"
#include "NonCombatStrategy.h"
#include "QuestStrategies.h"
#include "PassiveStrategy.h"
#include "PullStrategy.h"
#include "QuestStrategies.h"
#include "RTSCStrategy.h"
#include "RacialsStrategy.h"
#include "RangedCombatStrategy.h"
#include "ReturnStrategy.h"
#include "RpgStrategy.h"
#include "RTSCStrategy.h"
#include "RunawayStrategy.h"
#include "StayStrategy.h"
#include "TankAssistStrategy.h"
@@ -50,184 +51,182 @@
class StrategyContext : public NamedObjectContext<Strategy>
{
public:
StrategyContext()
{
creators["racials"] = &StrategyContext::racials;
creators["loot"] = &StrategyContext::loot;
creators["gather"] = &StrategyContext::gather;
creators["emote"] = &StrategyContext::emote;
creators["passive"] = &StrategyContext::passive;
// creators["conserve mana"] = &StrategyContext::conserve_mana;
creators["auto save mana"] = &StrategyContext::auto_save_mana;
creators["food"] = &StrategyContext::food;
creators["chat"] = &StrategyContext::chat;
creators["default"] = &StrategyContext::world_packet;
creators["ready check"] = &StrategyContext::ready_check;
creators["dead"] = &StrategyContext::dead;
creators["flee"] = &StrategyContext::flee;
creators["duel"] = &StrategyContext::duel;
creators["start duel"] = &StrategyContext::start_duel;
creators["kite"] = &StrategyContext::kite;
creators["potions"] = &StrategyContext::potions;
creators["cast time"] = &StrategyContext::cast_time;
creators["threat"] = &StrategyContext::threat;
creators["focus"] = &StrategyContext::focus;
creators["tell target"] = &StrategyContext::tell_target;
creators["pvp"] = &StrategyContext::pvp;
creators["return"] = &StrategyContext::_return;
creators["lfg"] = &StrategyContext::lfg;
creators["custom"] = &StrategyContext::custom;
creators["reveal"] = &StrategyContext::reveal;
creators["collision"] = &StrategyContext::collision;
creators["rpg"] = &StrategyContext::rpg;
creators["travel"] = &StrategyContext::travel;
creators["explore"] = &StrategyContext::explore;
creators["map"] = &StrategyContext::map;
creators["map full"] = &StrategyContext::map_full;
creators["sit"] = &StrategyContext::sit;
creators["mark rti"] = &StrategyContext::mark_rti;
creators["adds"] = &StrategyContext::possible_adds;
creators["close"] = &StrategyContext::close;
creators["ranged"] = &StrategyContext::ranged;
creators["behind"] = &StrategyContext::behind;
creators["bg"] = &StrategyContext::bg;
creators["battleground"] = &StrategyContext::battleground;
creators["warsong"] = &StrategyContext::warsong;
creators["alterac"] = &StrategyContext::alterac;
creators["arathi"] = &StrategyContext::arathi;
creators["eye"] = &StrategyContext::eye;
creators["isle"] = &StrategyContext::isle;
creators["arena"] = &StrategyContext::arena;
creators["mount"] = &StrategyContext::mount;
creators["rtsc"] = &StrategyContext::rtsc;
creators["attack tagged"] = &StrategyContext::attack_tagged;
creators["debug"] = &StrategyContext::debug;
creators["debug move"] = &StrategyContext::debug_move;
creators["debug rpg"] = &StrategyContext::debug_rpg;
creators["debug spell"] = &StrategyContext::debug_spell;
creators["maintenance"] = &StrategyContext::maintenance;
creators["group"] = &StrategyContext::group;
creators["guild"] = &StrategyContext::guild;
creators["grind"] = &StrategyContext::grind;
creators["avoid aoe"] = &StrategyContext::avoid_aoe;
creators["move random"] = &StrategyContext::move_random;
creators["combat formation"] = &StrategyContext::combat_formation;
}
public:
StrategyContext()
{
creators["racials"] = &StrategyContext::racials;
creators["loot"] = &StrategyContext::loot;
creators["gather"] = &StrategyContext::gather;
creators["emote"] = &StrategyContext::emote;
creators["passive"] = &StrategyContext::passive;
// creators["conserve mana"] = &StrategyContext::conserve_mana;
creators["auto save mana"] = &StrategyContext::auto_save_mana;
creators["food"] = &StrategyContext::food;
creators["chat"] = &StrategyContext::chat;
creators["default"] = &StrategyContext::world_packet;
creators["ready check"] = &StrategyContext::ready_check;
creators["dead"] = &StrategyContext::dead;
creators["flee"] = &StrategyContext::flee;
creators["duel"] = &StrategyContext::duel;
creators["start duel"] = &StrategyContext::start_duel;
creators["kite"] = &StrategyContext::kite;
creators["potions"] = &StrategyContext::potions;
creators["cast time"] = &StrategyContext::cast_time;
creators["threat"] = &StrategyContext::threat;
creators["focus"] = &StrategyContext::focus;
creators["tell target"] = &StrategyContext::tell_target;
creators["pvp"] = &StrategyContext::pvp;
creators["return"] = &StrategyContext::_return;
creators["lfg"] = &StrategyContext::lfg;
creators["custom"] = &StrategyContext::custom;
creators["reveal"] = &StrategyContext::reveal;
creators["collision"] = &StrategyContext::collision;
creators["rpg"] = &StrategyContext::rpg;
creators["travel"] = &StrategyContext::travel;
creators["explore"] = &StrategyContext::explore;
creators["map"] = &StrategyContext::map;
creators["map full"] = &StrategyContext::map_full;
creators["sit"] = &StrategyContext::sit;
creators["mark rti"] = &StrategyContext::mark_rti;
creators["adds"] = &StrategyContext::possible_adds;
creators["close"] = &StrategyContext::close;
creators["ranged"] = &StrategyContext::ranged;
creators["behind"] = &StrategyContext::behind;
creators["bg"] = &StrategyContext::bg;
creators["battleground"] = &StrategyContext::battleground;
creators["warsong"] = &StrategyContext::warsong;
creators["alterac"] = &StrategyContext::alterac;
creators["arathi"] = &StrategyContext::arathi;
creators["eye"] = &StrategyContext::eye;
creators["isle"] = &StrategyContext::isle;
creators["arena"] = &StrategyContext::arena;
creators["mount"] = &StrategyContext::mount;
creators["rtsc"] = &StrategyContext::rtsc;
creators["attack tagged"] = &StrategyContext::attack_tagged;
creators["debug"] = &StrategyContext::debug;
creators["debug move"] = &StrategyContext::debug_move;
creators["debug rpg"] = &StrategyContext::debug_rpg;
creators["debug spell"] = &StrategyContext::debug_spell;
creators["maintenance"] = &StrategyContext::maintenance;
creators["group"] = &StrategyContext::group;
creators["guild"] = &StrategyContext::guild;
creators["grind"] = &StrategyContext::grind;
creators["avoid aoe"] = &StrategyContext::avoid_aoe;
creators["move random"] = &StrategyContext::move_random;
creators["combat formation"] = &StrategyContext::combat_formation;
}
private:
static Strategy* behind(PlayerbotAI* botAI) { return new SetBehindCombatStrategy(botAI); }
static Strategy* ranged(PlayerbotAI* botAI) { return new RangedCombatStrategy(botAI); }
static Strategy* close(PlayerbotAI* botAI) { return new MeleeCombatStrategy(botAI); }
static Strategy* mark_rti(PlayerbotAI* botAI) { return new MarkRtiStrategy(botAI); }
static Strategy* tell_target(PlayerbotAI* botAI) { return new TellTargetStrategy(botAI); }
static Strategy* threat(PlayerbotAI* botAI) { return new ThreatStrategy(botAI); }
static Strategy* focus(PlayerbotAI* botAI) { return new FocusStrategy(botAI); }
static Strategy* cast_time(PlayerbotAI* botAI) { return new CastTimeStrategy(botAI); }
static Strategy* potions(PlayerbotAI* botAI) { return new UsePotionsStrategy(botAI); }
static Strategy* kite(PlayerbotAI* botAI) { return new KiteStrategy(botAI); }
static Strategy* duel(PlayerbotAI* botAI) { return new DuelStrategy(botAI); }
static Strategy* start_duel(PlayerbotAI* botAI) { return new StartDuelStrategy(botAI); }
static Strategy* flee(PlayerbotAI* botAI) { return new FleeStrategy(botAI); }
static Strategy* dead(PlayerbotAI* botAI) { return new DeadStrategy(botAI); }
static Strategy* racials(PlayerbotAI* botAI) { return new RacialsStrategy(botAI); }
static Strategy* loot(PlayerbotAI* botAI) { return new LootNonCombatStrategy(botAI); }
static Strategy* gather(PlayerbotAI* botAI) { return new GatherStrategy(botAI); }
static Strategy* emote(PlayerbotAI* botAI) { return new EmoteStrategy(botAI); }
static Strategy* passive(PlayerbotAI* botAI) { return new PassiveStrategy(botAI); }
// static Strategy* conserve_mana(PlayerbotAI* botAI) { return new ConserveManaStrategy(botAI); }
static Strategy* auto_save_mana(PlayerbotAI* botAI) { return new HealerAutoSaveManaStrategy(botAI); }
static Strategy* food(PlayerbotAI* botAI) { return new UseFoodStrategy(botAI); }
static Strategy* chat(PlayerbotAI* botAI) { return new ChatCommandHandlerStrategy(botAI); }
static Strategy* world_packet(PlayerbotAI* botAI) { return new WorldPacketHandlerStrategy(botAI); }
static Strategy* ready_check(PlayerbotAI* botAI) { return new ReadyCheckStrategy(botAI); }
static Strategy* pvp(PlayerbotAI* botAI) { return new AttackEnemyPlayersStrategy(botAI); }
static Strategy* _return(PlayerbotAI* botAI) { return new ReturnStrategy(botAI); }
static Strategy* lfg(PlayerbotAI* botAI) { return new LfgStrategy(botAI); }
static Strategy* custom(PlayerbotAI* botAI) { return new CustomStrategy(botAI); }
static Strategy* reveal(PlayerbotAI* botAI) { return new RevealStrategy(botAI); }
static Strategy* collision(PlayerbotAI* botAI) { return new CollisionStrategy(botAI); }
static Strategy* rpg(PlayerbotAI* botAI) { return new RpgStrategy(botAI); }
static Strategy* travel(PlayerbotAI* botAI) { return new TravelStrategy(botAI); }
static Strategy* explore(PlayerbotAI* botAI) { return new ExploreStrategy(botAI); }
static Strategy* map(PlayerbotAI* botAI) { return new MapStrategy(botAI); }
static Strategy* map_full(PlayerbotAI* botAI) { return new MapFullStrategy(botAI); }
static Strategy* sit(PlayerbotAI* botAI) { return new SitStrategy(botAI); }
static Strategy* possible_adds(PlayerbotAI* botAI) { return new PossibleAddsStrategy(botAI); }
static Strategy* mount(PlayerbotAI* botAI) { return new MountStrategy(botAI); }
static Strategy* bg(PlayerbotAI* botAI) { return new BGStrategy(botAI); }
static Strategy* battleground(PlayerbotAI* botAI) { return new BattlegroundStrategy(botAI); }
static Strategy* warsong(PlayerbotAI* botAI) { return new WarsongStrategy(botAI); }
static Strategy* alterac(PlayerbotAI* botAI) { return new AlteracStrategy(botAI); }
static Strategy* arathi(PlayerbotAI* botAI) { return new ArathiStrategy(botAI); }
static Strategy* eye(PlayerbotAI* botAI) { return new EyeStrategy(botAI); }
static Strategy* isle(PlayerbotAI* botAI) { return new IsleStrategy(botAI); }
static Strategy* arena(PlayerbotAI* botAI) { return new ArenaStrategy(botAI); }
static Strategy* rtsc(PlayerbotAI* botAI) { return new RTSCStrategy(botAI); }
static Strategy* attack_tagged(PlayerbotAI* botAI) { return new AttackTaggedStrategy(botAI); }
static Strategy* debug(PlayerbotAI* botAI) { return new DebugStrategy(botAI); }
static Strategy* debug_move(PlayerbotAI* botAI) { return new DebugMoveStrategy(botAI); }
static Strategy* debug_rpg(PlayerbotAI* botAI) { return new DebugRpgStrategy(botAI); }
static Strategy* debug_spell(PlayerbotAI* botAI) { return new DebugSpellStrategy(botAI); }
static Strategy* maintenance(PlayerbotAI* botAI) { return new MaintenanceStrategy(botAI); }
static Strategy* group(PlayerbotAI* botAI) { return new GroupStrategy(botAI); }
static Strategy* guild (PlayerbotAI* botAI) { return new GuildStrategy(botAI); }
static Strategy* grind(PlayerbotAI* botAI) { return new GrindingStrategy(botAI); }
static Strategy* avoid_aoe(PlayerbotAI* botAI) { return new AvoidAoeStrategy(botAI); }
static Strategy* move_random(PlayerbotAI* ai) { return new MoveRandomStrategy(ai); }
static Strategy* combat_formation(PlayerbotAI* ai) { return new CombatFormationStrategy(ai); }
private:
static Strategy* behind(PlayerbotAI* botAI) { return new SetBehindCombatStrategy(botAI); }
static Strategy* ranged(PlayerbotAI* botAI) { return new RangedCombatStrategy(botAI); }
static Strategy* close(PlayerbotAI* botAI) { return new MeleeCombatStrategy(botAI); }
static Strategy* mark_rti(PlayerbotAI* botAI) { return new MarkRtiStrategy(botAI); }
static Strategy* tell_target(PlayerbotAI* botAI) { return new TellTargetStrategy(botAI); }
static Strategy* threat(PlayerbotAI* botAI) { return new ThreatStrategy(botAI); }
static Strategy* focus(PlayerbotAI* botAI) { return new FocusStrategy(botAI); }
static Strategy* cast_time(PlayerbotAI* botAI) { return new CastTimeStrategy(botAI); }
static Strategy* potions(PlayerbotAI* botAI) { return new UsePotionsStrategy(botAI); }
static Strategy* kite(PlayerbotAI* botAI) { return new KiteStrategy(botAI); }
static Strategy* duel(PlayerbotAI* botAI) { return new DuelStrategy(botAI); }
static Strategy* start_duel(PlayerbotAI* botAI) { return new StartDuelStrategy(botAI); }
static Strategy* flee(PlayerbotAI* botAI) { return new FleeStrategy(botAI); }
static Strategy* dead(PlayerbotAI* botAI) { return new DeadStrategy(botAI); }
static Strategy* racials(PlayerbotAI* botAI) { return new RacialsStrategy(botAI); }
static Strategy* loot(PlayerbotAI* botAI) { return new LootNonCombatStrategy(botAI); }
static Strategy* gather(PlayerbotAI* botAI) { return new GatherStrategy(botAI); }
static Strategy* emote(PlayerbotAI* botAI) { return new EmoteStrategy(botAI); }
static Strategy* passive(PlayerbotAI* botAI) { return new PassiveStrategy(botAI); }
// static Strategy* conserve_mana(PlayerbotAI* botAI) { return new ConserveManaStrategy(botAI); }
static Strategy* auto_save_mana(PlayerbotAI* botAI) { return new HealerAutoSaveManaStrategy(botAI); }
static Strategy* food(PlayerbotAI* botAI) { return new UseFoodStrategy(botAI); }
static Strategy* chat(PlayerbotAI* botAI) { return new ChatCommandHandlerStrategy(botAI); }
static Strategy* world_packet(PlayerbotAI* botAI) { return new WorldPacketHandlerStrategy(botAI); }
static Strategy* ready_check(PlayerbotAI* botAI) { return new ReadyCheckStrategy(botAI); }
static Strategy* pvp(PlayerbotAI* botAI) { return new AttackEnemyPlayersStrategy(botAI); }
static Strategy* _return(PlayerbotAI* botAI) { return new ReturnStrategy(botAI); }
static Strategy* lfg(PlayerbotAI* botAI) { return new LfgStrategy(botAI); }
static Strategy* custom(PlayerbotAI* botAI) { return new CustomStrategy(botAI); }
static Strategy* reveal(PlayerbotAI* botAI) { return new RevealStrategy(botAI); }
static Strategy* collision(PlayerbotAI* botAI) { return new CollisionStrategy(botAI); }
static Strategy* rpg(PlayerbotAI* botAI) { return new RpgStrategy(botAI); }
static Strategy* travel(PlayerbotAI* botAI) { return new TravelStrategy(botAI); }
static Strategy* explore(PlayerbotAI* botAI) { return new ExploreStrategy(botAI); }
static Strategy* map(PlayerbotAI* botAI) { return new MapStrategy(botAI); }
static Strategy* map_full(PlayerbotAI* botAI) { return new MapFullStrategy(botAI); }
static Strategy* sit(PlayerbotAI* botAI) { return new SitStrategy(botAI); }
static Strategy* possible_adds(PlayerbotAI* botAI) { return new PossibleAddsStrategy(botAI); }
static Strategy* mount(PlayerbotAI* botAI) { return new MountStrategy(botAI); }
static Strategy* bg(PlayerbotAI* botAI) { return new BGStrategy(botAI); }
static Strategy* battleground(PlayerbotAI* botAI) { return new BattlegroundStrategy(botAI); }
static Strategy* warsong(PlayerbotAI* botAI) { return new WarsongStrategy(botAI); }
static Strategy* alterac(PlayerbotAI* botAI) { return new AlteracStrategy(botAI); }
static Strategy* arathi(PlayerbotAI* botAI) { return new ArathiStrategy(botAI); }
static Strategy* eye(PlayerbotAI* botAI) { return new EyeStrategy(botAI); }
static Strategy* isle(PlayerbotAI* botAI) { return new IsleStrategy(botAI); }
static Strategy* arena(PlayerbotAI* botAI) { return new ArenaStrategy(botAI); }
static Strategy* rtsc(PlayerbotAI* botAI) { return new RTSCStrategy(botAI); }
static Strategy* attack_tagged(PlayerbotAI* botAI) { return new AttackTaggedStrategy(botAI); }
static Strategy* debug(PlayerbotAI* botAI) { return new DebugStrategy(botAI); }
static Strategy* debug_move(PlayerbotAI* botAI) { return new DebugMoveStrategy(botAI); }
static Strategy* debug_rpg(PlayerbotAI* botAI) { return new DebugRpgStrategy(botAI); }
static Strategy* debug_spell(PlayerbotAI* botAI) { return new DebugSpellStrategy(botAI); }
static Strategy* maintenance(PlayerbotAI* botAI) { return new MaintenanceStrategy(botAI); }
static Strategy* group(PlayerbotAI* botAI) { return new GroupStrategy(botAI); }
static Strategy* guild(PlayerbotAI* botAI) { return new GuildStrategy(botAI); }
static Strategy* grind(PlayerbotAI* botAI) { return new GrindingStrategy(botAI); }
static Strategy* avoid_aoe(PlayerbotAI* botAI) { return new AvoidAoeStrategy(botAI); }
static Strategy* move_random(PlayerbotAI* ai) { return new MoveRandomStrategy(ai); }
static Strategy* combat_formation(PlayerbotAI* ai) { return new CombatFormationStrategy(ai); }
};
class MovementStrategyContext : public NamedObjectContext<Strategy>
{
public:
MovementStrategyContext() : NamedObjectContext<Strategy>(false, true)
{
creators["follow"] = &MovementStrategyContext::follow_master;
creators["stay"] = &MovementStrategyContext::stay;
creators["runaway"] = &MovementStrategyContext::runaway;
creators["flee from adds"] = &MovementStrategyContext::flee_from_adds;
creators["guard"] = &MovementStrategyContext::guard;
}
private:
static Strategy* guard(PlayerbotAI* botAI) { return new GuardStrategy(botAI); }
static Strategy* follow_master(PlayerbotAI* botAI) { return new FollowMasterStrategy(botAI); }
static Strategy* stay(PlayerbotAI* botAI) { return new StayStrategy(botAI); }
static Strategy* runaway(PlayerbotAI* botAI) { return new RunawayStrategy(botAI); }
static Strategy* flee_from_adds(PlayerbotAI* botAI) { return new FleeFromAddsStrategy(botAI); }
};
class AssistStrategyContext : public NamedObjectContext<Strategy>
public:
MovementStrategyContext() : NamedObjectContext<Strategy>(false, true)
{
public:
AssistStrategyContext() : NamedObjectContext<Strategy>(false, true)
{
creators["dps assist"] = &AssistStrategyContext::dps_assist;
creators["dps aoe"] = &AssistStrategyContext::dps_aoe;
creators["tank assist"] = &AssistStrategyContext::tank_assist;
}
creators["follow"] = &MovementStrategyContext::follow_master;
creators["stay"] = &MovementStrategyContext::stay;
creators["runaway"] = &MovementStrategyContext::runaway;
creators["flee from adds"] = &MovementStrategyContext::flee_from_adds;
creators["guard"] = &MovementStrategyContext::guard;
}
private:
static Strategy* dps_assist(PlayerbotAI* botAI) { return new DpsAssistStrategy(botAI); }
static Strategy* dps_aoe(PlayerbotAI* botAI) { return new DpsAoeStrategy(botAI); }
static Strategy* tank_assist(PlayerbotAI* botAI) { return new TankAssistStrategy(botAI); }
private:
static Strategy* guard(PlayerbotAI* botAI) { return new GuardStrategy(botAI); }
static Strategy* follow_master(PlayerbotAI* botAI) { return new FollowMasterStrategy(botAI); }
static Strategy* stay(PlayerbotAI* botAI) { return new StayStrategy(botAI); }
static Strategy* runaway(PlayerbotAI* botAI) { return new RunawayStrategy(botAI); }
static Strategy* flee_from_adds(PlayerbotAI* botAI) { return new FleeFromAddsStrategy(botAI); }
};
class AssistStrategyContext : public NamedObjectContext<Strategy>
{
public:
AssistStrategyContext() : NamedObjectContext<Strategy>(false, true)
{
creators["dps assist"] = &AssistStrategyContext::dps_assist;
creators["dps aoe"] = &AssistStrategyContext::dps_aoe;
creators["tank assist"] = &AssistStrategyContext::tank_assist;
}
private:
static Strategy* dps_assist(PlayerbotAI* botAI) { return new DpsAssistStrategy(botAI); }
static Strategy* dps_aoe(PlayerbotAI* botAI) { return new DpsAoeStrategy(botAI); }
static Strategy* tank_assist(PlayerbotAI* botAI) { return new TankAssistStrategy(botAI); }
};
class QuestStrategyContext : public NamedObjectContext<Strategy>
{
public:
QuestStrategyContext() : NamedObjectContext<Strategy>(false, true)
{
creators["quest"] = &QuestStrategyContext::quest;
creators["accept all quests"] = &QuestStrategyContext::accept_all_quests;
}
public:
QuestStrategyContext() : NamedObjectContext<Strategy>(false, true)
{
creators["quest"] = &QuestStrategyContext::quest;
creators["accept all quests"] = &QuestStrategyContext::accept_all_quests;
}
private:
static Strategy* quest(PlayerbotAI* botAI) { return new DefaultQuestStrategy(botAI); }
static Strategy* accept_all_quests(PlayerbotAI* botAI) { return new AcceptAllQuestsStrategy(botAI); }
private:
static Strategy* quest(PlayerbotAI* botAI) { return new DefaultQuestStrategy(botAI); }
static Strategy* accept_all_quests(PlayerbotAI* botAI) { return new AcceptAllQuestsStrategy(botAI); }
};
#endif

34
src/strategy/Trigger.cpp
View File

@@ -1,38 +1,36 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#include "Trigger.h"
#include "Event.h"
#include "Playerbots.h"
#include "Timer.h"
Trigger::Trigger(PlayerbotAI* botAI, std::string const name, int32 checkInterval) :
AiNamedObject(botAI, name), checkInterval(checkInterval == 1 ? 1 : (checkInterval < 100 ? checkInterval * 1000 : checkInterval)), lastCheckTime(0)
Trigger::Trigger(PlayerbotAI* botAI, std::string const name, int32 checkInterval)
: AiNamedObject(botAI, name),
checkInterval(checkInterval == 1 ? 1 : (checkInterval < 100 ? checkInterval * 1000 : checkInterval)),
lastCheckTime(0)
{
}
Event Trigger::Check()
{
if (IsActive())
{
Event event(getName());
return event;
}
if (IsActive())
{
Event event(getName());
return event;
}
Event event;
return event;
Event event;
return event;
}
Value<Unit*>* Trigger::GetTargetValue()
{
return context->GetValue<Unit*>(GetTargetName());
}
Value<Unit*>* Trigger::GetTargetValue() { return context->GetValue<Unit*>(GetTargetName()); }
Unit* Trigger::GetTarget()
{
return GetTargetValue()->Get();
}
Unit* Trigger::GetTarget() { return GetTargetValue()->Get(); }
bool Trigger::needCheck()
{

75
src/strategy/Trigger.h
View File

@@ -1,69 +1,64 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#ifndef _PLAYERBOT_TRIGGER_H
#define _PLAYERBOT_TRIGGER_H
#include "Common.h"
#include "Action.h"
#include "Common.h"
class PlayerbotAI;
class Unit;
class Trigger : public AiNamedObject
{
public:
Trigger(PlayerbotAI* botAI, std::string const name = "trigger", int32 checkInterval = 1);
public:
Trigger(PlayerbotAI* botAI, std::string const name = "trigger", int32 checkInterval = 1);
virtual ~Trigger() { }
virtual ~Trigger() {}
virtual Event Check();
virtual void ExternalEvent([[maybe_unused]] std::string const param, [[maybe_unused]] Player* owner = nullptr) { }
virtual void ExternalEvent([[maybe_unused]] WorldPacket& packet, [[maybe_unused]] Player* owner = nullptr) { }
virtual bool IsActive() { return false; }
virtual NextAction** getHandlers() { return nullptr; }
void Update() { }
virtual void Reset() { }
virtual Unit* GetTarget();
virtual Value<Unit*>* GetTargetValue();
virtual std::string const GetTargetName() { return "self target"; }
virtual Event Check();
virtual void ExternalEvent([[maybe_unused]] std::string const param, [[maybe_unused]] Player* owner = nullptr) {}
virtual void ExternalEvent([[maybe_unused]] WorldPacket& packet, [[maybe_unused]] Player* owner = nullptr) {}
virtual bool IsActive() { return false; }
virtual NextAction** getHandlers() { return nullptr; }
void Update() {}
virtual void Reset() {}
virtual Unit* GetTarget();
virtual Value<Unit*>* GetTargetValue();
virtual std::string const GetTargetName() { return "self target"; }
bool needCheck();
bool needCheck();
protected:
int32 checkInterval;
uint32 lastCheckTime;
protected:
int32 checkInterval;
uint32 lastCheckTime;
};
class TriggerNode
{
public:
TriggerNode(std::string const name, NextAction** handlers = nullptr) : trigger(nullptr), handlers(handlers), name(name) { } // reorder args - whipowill
public:
TriggerNode(std::string const name, NextAction** handlers = nullptr)
: trigger(nullptr), handlers(handlers), name(name)
{
} // reorder args - whipowill
virtual ~TriggerNode()
{
NextAction::destroy(handlers);
}
virtual ~TriggerNode() { NextAction::destroy(handlers); }
Trigger* getTrigger() { return trigger; }
void setTrigger(Trigger* trigger) { this->trigger = trigger; }
std::string const getName() { return name; }
Trigger* getTrigger() { return trigger; }
void setTrigger(Trigger* trigger) { this->trigger = trigger; }
std::string const getName() { return name; }
NextAction** getHandlers()
{
return NextAction::merge(NextAction::clone(handlers), trigger->getHandlers());
}
NextAction** getHandlers() { return NextAction::merge(NextAction::clone(handlers), trigger->getHandlers()); }
float getFirstRelevance()
{
return handlers[0] ? handlers[0]->getRelevance() : -1;
}
float getFirstRelevance() { return handlers[0] ? handlers[0]->getRelevance() : -1; }
private:
Trigger* trigger;
NextAction** handlers;
std::string const name;
private:
Trigger* trigger;
NextAction** handlers;
std::string const name;
};
#endif

40
src/strategy/Value.cpp
View File

@@ -1,13 +1,16 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#include "Value.h"
#include "PerformanceMonitor.h"
#include "Playerbots.h"
#include "Timer.h"
UnitCalculatedValue::UnitCalculatedValue(PlayerbotAI* botAI, std::string const name, int32 checkInterval) : CalculatedValue<Unit*>(botAI, name, checkInterval)
UnitCalculatedValue::UnitCalculatedValue(PlayerbotAI* botAI, std::string const name, int32 checkInterval)
: CalculatedValue<Unit*>(botAI, name, checkInterval)
{
}
@@ -44,8 +47,8 @@ std::string const FloatCalculatedValue::Format()
return out.str();
}
CDPairCalculatedValue::CDPairCalculatedValue(PlayerbotAI* botAI, std::string const name, int32 checkInterval) :
CalculatedValue<CreatureData const*>(botAI, name, checkInterval)
CDPairCalculatedValue::CDPairCalculatedValue(PlayerbotAI* botAI, std::string const name, int32 checkInterval)
: CalculatedValue<CreatureData const*>(botAI, name, checkInterval)
{
// lastCheckTime = getMSTime() - checkInterval / 2;
}
@@ -62,15 +65,16 @@ std::string const CDPairCalculatedValue::Format()
return "<none>";
}
CDPairListCalculatedValue::CDPairListCalculatedValue(PlayerbotAI* botAI, std::string const name, int32 checkInterval) :
CalculatedValue<std::vector<CreatureData const*>>(botAI, name, checkInterval)
CDPairListCalculatedValue::CDPairListCalculatedValue(PlayerbotAI* botAI, std::string const name, int32 checkInterval)
: CalculatedValue<std::vector<CreatureData const*>>(botAI, name, checkInterval)
{
// lastCheckTime = time(nullptr) - checkInterval / 2;
}
std::string const CDPairListCalculatedValue::Format()
{
std::ostringstream out; out << "{";
std::ostringstream out;
out << "{";
std::vector<CreatureData const*> cdPairs = Calculate();
for (CreatureData const* cdPair : cdPairs)
{
@@ -81,8 +85,8 @@ std::string const CDPairListCalculatedValue::Format()
return out.str();
}
ObjectGuidCalculatedValue::ObjectGuidCalculatedValue(PlayerbotAI* botAI, std::string const name, int32 checkInterval) :
CalculatedValue<ObjectGuid>(botAI, name, checkInterval)
ObjectGuidCalculatedValue::ObjectGuidCalculatedValue(PlayerbotAI* botAI, std::string const name, int32 checkInterval)
: CalculatedValue<ObjectGuid>(botAI, name, checkInterval)
{
// lastCheckTime = time(nullptr) - checkInterval / 2;
}
@@ -93,8 +97,9 @@ std::string const ObjectGuidCalculatedValue::Format()
return guid ? std::to_string(guid.GetRawValue()) : "<none>";
}
ObjectGuidListCalculatedValue::ObjectGuidListCalculatedValue(PlayerbotAI* botAI, std::string const name, int32 checkInterval) :
CalculatedValue<GuidVector>(botAI, name, checkInterval)
ObjectGuidListCalculatedValue::ObjectGuidListCalculatedValue(PlayerbotAI* botAI, std::string const name,
int32 checkInterval)
: CalculatedValue<GuidVector>(botAI, name, checkInterval)
{
}
@@ -116,17 +121,22 @@ std::string const ObjectGuidListCalculatedValue::Format()
Unit* UnitCalculatedValue::Get()
{
if (checkInterval < 2) {
PerformanceMonitorOperation* pmo = sPerformanceMonitor->start(PERF_MON_VALUE, this->getName(), this->context ? &this->context->performanceStack : nullptr);
if (checkInterval < 2)
{
PerformanceMonitorOperation* pmo = sPerformanceMonitor->start(
PERF_MON_VALUE, this->getName(), this->context ? &this->context->performanceStack : nullptr);
value = Calculate();
if (pmo)
pmo->finish();
} else {
}
else
{
time_t now = getMSTime();
if (!lastCheckTime || now - lastCheckTime >= checkInterval)
{
lastCheckTime = now;
PerformanceMonitorOperation* pmo = sPerformanceMonitor->start(PERF_MON_VALUE, this->getName(), this->context ? &this->context->performanceStack : nullptr);
PerformanceMonitorOperation* pmo = sPerformanceMonitor->start(
PERF_MON_VALUE, this->getName(), this->context ? &this->context->performanceStack : nullptr);
value = Calculate();
if (pmo)
pmo->finish();

492
src/strategy/Value.h
View File

@@ -1,388 +1,418 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#ifndef _PLAYERBOT_VALUE_H
#define _PLAYERBOT_VALUE_H
#include <time.h>
#include "AiObject.h"
#include "ObjectGuid.h"
#include "PerformanceMonitor.h"
#include "Timer.h"
#include "Unit.h"
#include <time.h>
class PlayerbotAI;
class Unit;
class FleeInfo
{
public:
Position fromPos;
float radius;
float angle;
uint32 timestamp;
int GetAngleRangeIndex() { return (angle + 2 * M_PI) / (M_PI / 2); } // [0, 7)
public:
Position fromPos;
float radius;
float angle;
uint32 timestamp;
int GetAngleRangeIndex() { return (angle + 2 * M_PI) / (M_PI / 2); } // [0, 7)
};
struct CreatureData;
class UntypedValue : public AiNamedObject
{
public:
UntypedValue(PlayerbotAI* botAI, std::string const name) : AiNamedObject(botAI, name) { }
virtual ~UntypedValue() { }
virtual void Update() { }
virtual void Reset() { }
virtual std::string const Format() { return "?"; }
virtual std::string const Save() { return "?"; }
virtual bool Load([[maybe_unused]] std::string const value) { return false; }
public:
UntypedValue(PlayerbotAI* botAI, std::string const name) : AiNamedObject(botAI, name) {}
virtual ~UntypedValue() {}
virtual void Update() {}
virtual void Reset() {}
virtual std::string const Format() { return "?"; }
virtual std::string const Save() { return "?"; }
virtual bool Load([[maybe_unused]] std::string const value) { return false; }
};
template<class T>
template <class T>
class Value
{
public:
virtual ~Value() { }
virtual T Get() = 0;
virtual T LazyGet() = 0;
virtual T& RefGet() = 0;
virtual void Reset() { }
virtual void Set(T value) = 0;
operator T() { return Get(); }
public:
virtual ~Value() {}
virtual T Get() = 0;
virtual T LazyGet() = 0;
virtual T& RefGet() = 0;
virtual void Reset() {}
virtual void Set(T value) = 0;
operator T() { return Get(); }
};
template<class T>
template <class T>
class CalculatedValue : public UntypedValue, public Value<T>
{
public:
CalculatedValue(PlayerbotAI* botAI, std::string const name = "value", uint32 checkInterval = 1) : UntypedValue(botAI, name),
checkInterval(checkInterval == 1 ? 1 : (checkInterval < 100 ? checkInterval * 1000 : checkInterval)) /*turn s -> ms?*/, lastCheckTime(0) { }
public:
CalculatedValue(PlayerbotAI* botAI, std::string const name = "value", uint32 checkInterval = 1)
: UntypedValue(botAI, name),
checkInterval(
checkInterval == 1 ? 1 : (checkInterval < 100 ? checkInterval * 1000 : checkInterval)) /*turn s -> ms?*/,
lastCheckTime(0)
{
}
virtual ~CalculatedValue() { }
virtual ~CalculatedValue() {}
T Get() override
T Get() override
{
if (checkInterval < 2)
{
if (checkInterval < 2) {
// PerformanceMonitorOperation* pmo = sPerformanceMonitor->start(PERF_MON_VALUE, this->getName(), this->context ? &this->context->performanceStack : nullptr);
// PerformanceMonitorOperation* pmo = sPerformanceMonitor->start(PERF_MON_VALUE, this->getName(),
// this->context ? &this->context->performanceStack : nullptr);
value = Calculate();
// if (pmo)
// pmo->finish();
}
else
{
time_t now = getMSTime();
if (!lastCheckTime || now - lastCheckTime >= checkInterval)
{
lastCheckTime = now;
// PerformanceMonitorOperation* pmo = sPerformanceMonitor->start(PERF_MON_VALUE, this->getName(),
// this->context ? &this->context->performanceStack : nullptr);
value = Calculate();
// if (pmo)
// pmo->finish();
} else {
time_t now = getMSTime();
if (!lastCheckTime || now - lastCheckTime >= checkInterval)
{
lastCheckTime = now;
// PerformanceMonitorOperation* pmo = sPerformanceMonitor->start(PERF_MON_VALUE, this->getName(), this->context ? &this->context->performanceStack : nullptr);
value = Calculate();
// if (pmo)
// pmo->finish();
}
}
return value;
}
return value;
}
T LazyGet() override
T LazyGet() override
{
if (!lastCheckTime)
return Get();
return value;
}
T& RefGet() override
{
if (checkInterval < 2)
{
if (!lastCheckTime)
return Get();
return value;
// PerformanceMonitorOperation* pmo = sPerformanceMonitor->start(PERF_MON_VALUE, this->getName(),
// this->context ? &this->context->performanceStack : nullptr);
value = Calculate();
// if (pmo)
// pmo->finish();
}
T& RefGet() override
else
{
if (checkInterval < 2) {
// PerformanceMonitorOperation* pmo = sPerformanceMonitor->start(PERF_MON_VALUE, this->getName(), this->context ? &this->context->performanceStack : nullptr);
time_t now = getMSTime();
if (!lastCheckTime || now - lastCheckTime >= checkInterval)
{
lastCheckTime = now;
// PerformanceMonitorOperation* pmo = sPerformanceMonitor->start(PERF_MON_VALUE, this->getName(),
// this->context ? &this->context->performanceStack : nullptr);
value = Calculate();
// if (pmo)
// pmo->finish();
} else {
time_t now = getMSTime();
if (!lastCheckTime || now - lastCheckTime >= checkInterval)
{
lastCheckTime = now;
// PerformanceMonitorOperation* pmo = sPerformanceMonitor->start(PERF_MON_VALUE, this->getName(), this->context ? &this->context->performanceStack : nullptr);
value = Calculate();
// if (pmo)
// pmo->finish();
}
}
return value;
}
void Set(T val) override { value = val; }
void Update() override {}
void Reset() override { lastCheckTime = 0; }
return value;
}
void Set(T val) override { value = val; }
void Update() override {}
void Reset() override { lastCheckTime = 0; }
protected:
virtual T Calculate() = 0;
protected:
virtual T Calculate() = 0;
uint32 checkInterval;
uint32 lastCheckTime;
T value;
uint32 checkInterval;
uint32 lastCheckTime;
T value;
};
template <class T>
class SingleCalculatedValue : public CalculatedValue<T>
{
public:
SingleCalculatedValue(PlayerbotAI* botAI, std::string const name = "value") : CalculatedValue<T>(botAI, name)
public:
SingleCalculatedValue(PlayerbotAI* botAI, std::string const name = "value") : CalculatedValue<T>(botAI, name)
{
this->Reset();
}
T Get() override
{
time_t now = time(0);
if (!this->lastCheckTime)
{
this->Reset();
this->lastCheckTime = now;
PerformanceMonitorOperation* pmo = sPerformanceMonitor->start(
PERF_MON_VALUE, this->getName(), this->context ? &this->context->performanceStack : nullptr);
this->value = this->Calculate();
if (pmo)
pmo->finish();
}
T Get() override
{
time_t now = time(0);
if (!this->lastCheckTime)
{
this->lastCheckTime = now;
PerformanceMonitorOperation* pmo = sPerformanceMonitor->start(PERF_MON_VALUE, this->getName(), this->context ? &this->context->performanceStack : nullptr);
this->value = this->Calculate();
if (pmo)
pmo->finish();
}
return this->value;
}
return this->value;
}
};
template<class T>
template <class T>
class MemoryCalculatedValue : public CalculatedValue<T>
{
public:
MemoryCalculatedValue(PlayerbotAI* botAI, std::string const name = "value", int32 checkInterval = 1) : CalculatedValue<T>(botAI, name, checkInterval)
{
lastChangeTime = time(0);
}
public:
MemoryCalculatedValue(PlayerbotAI* botAI, std::string const name = "value", int32 checkInterval = 1)
: CalculatedValue<T>(botAI, name, checkInterval)
{
lastChangeTime = time(0);
}
virtual bool EqualToLast(T value) = 0;
virtual bool CanCheckChange()
{
return time(0) - lastChangeTime < minChangeInterval || EqualToLast(this->value);
}
virtual bool EqualToLast(T value) = 0;
virtual bool CanCheckChange() { return time(0) - lastChangeTime < minChangeInterval || EqualToLast(this->value); }
virtual bool UpdateChange()
{
if (CanCheckChange())
return false;
virtual bool UpdateChange()
{
if (CanCheckChange())
return false;
lastChangeTime = time(0);
lastValue = this->value;
return true;
}
lastChangeTime = time(0);
lastValue = this->value;
return true;
}
void Set([[maybe_unused]] T value) override
{
CalculatedValue<T>::Set(this->value);
UpdateChange();
}
void Set([[maybe_unused]] T value) override
{
CalculatedValue<T>::Set(this->value);
UpdateChange();
}
T Get() override
{
this->value = CalculatedValue<T>::Get();
UpdateChange();
return this->value;
}
T Get() override
{
this->value = CalculatedValue<T>::Get();
UpdateChange();
return this->value;
}
T LazyGet() override
{
return this->value;
}
T LazyGet() override { return this->value; }
time_t LastChangeOn()
{
Get();
UpdateChange();
return lastChangeTime;
}
time_t LastChangeOn()
{
Get();
UpdateChange();
return lastChangeTime;
}
uint32 LastChangeDelay() { return time(0) - LastChangeOn(); }
uint32 LastChangeDelay() { return time(0) - LastChangeOn(); }
void Reset() override
{
CalculatedValue<T>::Reset();
lastChangeTime = time(0);
}
void Reset() override
{
CalculatedValue<T>::Reset();
lastChangeTime = time(0);
}
protected:
T lastValue;
uint32 minChangeInterval = 0;
time_t lastChangeTime;
protected:
T lastValue;
uint32 minChangeInterval = 0;
time_t lastChangeTime;
};
template<class T>
template <class T>
class LogCalculatedValue : public MemoryCalculatedValue<T>
{
public:
LogCalculatedValue(PlayerbotAI* botAI, std::string const name = "value", int32 checkInterval = 1) : MemoryCalculatedValue<T>(botAI, name, checkInterval) { }
public:
LogCalculatedValue(PlayerbotAI* botAI, std::string const name = "value", int32 checkInterval = 1)
: MemoryCalculatedValue<T>(botAI, name, checkInterval)
{
}
bool UpdateChange() override
{
if (MemoryCalculatedValue<T>::UpdateChange())
return false;
bool UpdateChange() override
{
if (MemoryCalculatedValue<T>::UpdateChange())
return false;
valueLog.push_back(std::make_pair(this->value, time(0)));
valueLog.push_back(std::make_pair(this->value, time(0)));
if (valueLog.size() > logLength)
valueLog.pop_front();
return true;
}
if (valueLog.size() > logLength)
valueLog.pop_front();
return true;
}
std::list<std::pair<T, time_t>> ValueLog() { return valueLog; }
std::list<std::pair<T, time_t>> ValueLog() { return valueLog; }
void Reset() override
{
MemoryCalculatedValue<T>::Reset();
valueLog.clear();
}
void Reset() override
{
MemoryCalculatedValue<T>::Reset();
valueLog.clear();
}
protected:
std::list<std::pair<T, time_t>> valueLog;
uint8 logLength = 10;
};
protected:
std::list<std::pair<T, time_t>> valueLog;
uint8 logLength = 10;
};
class Uint8CalculatedValue : public CalculatedValue<uint8>
{
public:
Uint8CalculatedValue(PlayerbotAI* botAI, std::string const name = "value", uint32 checkInterval = 1) :
CalculatedValue<uint8>(botAI, name, checkInterval) { }
public:
Uint8CalculatedValue(PlayerbotAI* botAI, std::string const name = "value", uint32 checkInterval = 1)
: CalculatedValue<uint8>(botAI, name, checkInterval)
{
}
std::string const Format() override;
std::string const Format() override;
};
class Uint32CalculatedValue : public CalculatedValue<uint32>
{
public:
Uint32CalculatedValue(PlayerbotAI* botAI, std::string const name = "value", int checkInterval = 1) :
CalculatedValue<uint32>(botAI, name, checkInterval) { }
public:
Uint32CalculatedValue(PlayerbotAI* botAI, std::string const name = "value", int checkInterval = 1)
: CalculatedValue<uint32>(botAI, name, checkInterval)
{
}
std::string const Format() override;
std::string const Format() override;
};
class FloatCalculatedValue : public CalculatedValue<float>
{
public:
FloatCalculatedValue(PlayerbotAI* botAI, std::string const name = "value", int checkInterval = 1) :
CalculatedValue<float>(botAI, name, checkInterval) { }
public:
FloatCalculatedValue(PlayerbotAI* botAI, std::string const name = "value", int checkInterval = 1)
: CalculatedValue<float>(botAI, name, checkInterval)
{
}
std::string const Format() override;
std::string const Format() override;
};
class BoolCalculatedValue : public CalculatedValue<bool>
{
public:
BoolCalculatedValue(PlayerbotAI* botAI, std::string const name = "value", int checkInterval = 1) :
CalculatedValue<bool>(botAI, name, checkInterval) { }
public:
BoolCalculatedValue(PlayerbotAI* botAI, std::string const name = "value", int checkInterval = 1)
: CalculatedValue<bool>(botAI, name, checkInterval)
{
}
std::string const Format() override
{
return Calculate() ? "true" : "false";
}
std::string const Format() override { return Calculate() ? "true" : "false"; }
};
class UnitCalculatedValue : public CalculatedValue<Unit*>
{
public:
UnitCalculatedValue(PlayerbotAI* botAI, std::string const name = "value", int32 checkInterval = 1);
public:
UnitCalculatedValue(PlayerbotAI* botAI, std::string const name = "value", int32 checkInterval = 1);
std::string const Format() override;
Unit* Get() override;
std::string const Format() override;
Unit* Get() override;
};
class CDPairCalculatedValue : public CalculatedValue<CreatureData const*>
{
public:
CDPairCalculatedValue(PlayerbotAI* botAI, std::string const name = "value", int32 checkInterval = 1);
public:
CDPairCalculatedValue(PlayerbotAI* botAI, std::string const name = "value", int32 checkInterval = 1);
std::string const Format() override;
std::string const Format() override;
};
class CDPairListCalculatedValue : public CalculatedValue<std::vector<CreatureData const*>>
{
public:
CDPairListCalculatedValue(PlayerbotAI* botAI, std::string const name = "value", int32 checkInterval = 1);
public:
CDPairListCalculatedValue(PlayerbotAI* botAI, std::string const name = "value", int32 checkInterval = 1);
std::string const Format() override;
std::string const Format() override;
};
class ObjectGuidCalculatedValue : public CalculatedValue<ObjectGuid>
{
public:
ObjectGuidCalculatedValue(PlayerbotAI* botAI, std::string const name = "value", int32 checkInterval = 1);
public:
ObjectGuidCalculatedValue(PlayerbotAI* botAI, std::string const name = "value", int32 checkInterval = 1);
std::string const Format() override;
std::string const Format() override;
};
class ObjectGuidListCalculatedValue : public CalculatedValue<GuidVector>
{
public:
ObjectGuidListCalculatedValue(PlayerbotAI* botAI, std::string const name = "value", int32 checkInterval = 1);
public:
ObjectGuidListCalculatedValue(PlayerbotAI* botAI, std::string const name = "value", int32 checkInterval = 1);
std::string const Format() override;
std::string const Format() override;
};
template<class T>
template <class T>
class ManualSetValue : public UntypedValue, public Value<T>
{
public:
ManualSetValue(PlayerbotAI* botAI, T defaultValue, std::string const name = "value") :
UntypedValue(botAI, name), value(defaultValue), defaultValue(defaultValue) { }
public:
ManualSetValue(PlayerbotAI* botAI, T defaultValue, std::string const name = "value")
: UntypedValue(botAI, name), value(defaultValue), defaultValue(defaultValue)
{
}
virtual ~ManualSetValue() { }
virtual ~ManualSetValue() {}
T Get() override { return value; }
T LazyGet() override { return value; }
T& RefGet() override { return value; }
void Set(T val) override { value = val; }
void Update() override {}
void Reset() override
{
value = defaultValue;
}
T Get() override { return value; }
T LazyGet() override { return value; }
T& RefGet() override { return value; }
void Set(T val) override { value = val; }
void Update() override {}
void Reset() override { value = defaultValue; }
protected:
T value;
T defaultValue;
protected:
T value;
T defaultValue;
};
class UnitManualSetValue : public ManualSetValue<Unit*>
{
public:
UnitManualSetValue(PlayerbotAI* botAI, Unit* defaultValue, std::string const name = "value") :
ManualSetValue<Unit*>(botAI, defaultValue, name) { }
public:
UnitManualSetValue(PlayerbotAI* botAI, Unit* defaultValue, std::string const name = "value")
: ManualSetValue<Unit*>(botAI, defaultValue, name)
{
}
std::string const Format() override;
Unit* Get() override;
std::string const Format() override;
Unit* Get() override;
};
class DisperseDistanceValue : public ManualSetValue<float>
{
public:
DisperseDistanceValue(PlayerbotAI* botAI, float defaultValue = -1.0f, std::string const name = "disperse distance") :
ManualSetValue<float>(botAI, defaultValue, name) { }
public:
DisperseDistanceValue(PlayerbotAI* botAI, float defaultValue = -1.0f, std::string const name = "disperse distance")
: ManualSetValue<float>(botAI, defaultValue, name)
{
}
};
class LastFleeAngleValue : public ManualSetValue<float>
{
public:
LastFleeAngleValue(PlayerbotAI* botAI, float defaultValue = 0.0f, std::string const name = "last flee angle") :
ManualSetValue<float>(botAI, defaultValue, name) { }
public:
LastFleeAngleValue(PlayerbotAI* botAI, float defaultValue = 0.0f, std::string const name = "last flee angle")
: ManualSetValue<float>(botAI, defaultValue, name)
{
}
};
class LastFleeTimestampValue : public ManualSetValue<uint32>
{
public:
LastFleeTimestampValue(PlayerbotAI* botAI, uint32 defaultValue = 0, std::string const name = "last flee timestamp") :
ManualSetValue<uint32>(botAI, defaultValue, name) { }
public:
LastFleeTimestampValue(PlayerbotAI* botAI, uint32 defaultValue = 0, std::string const name = "last flee timestamp")
: ManualSetValue<uint32>(botAI, defaultValue, name)
{
}
};
class RecentlyFleeInfo : public ManualSetValue<std::list<FleeInfo>>
{
public:
RecentlyFleeInfo(PlayerbotAI* botAI, std::list<FleeInfo> defaultValue = {}, std::string const name = "recently flee info") :
ManualSetValue<std::list<FleeInfo>>(botAI, defaultValue, name) { }
public:
RecentlyFleeInfo(PlayerbotAI* botAI, std::list<FleeInfo> defaultValue = {},
std::string const name = "recently flee info")
: ManualSetValue<std::list<FleeInfo>>(botAI, defaultValue, name)
{
}
};
#endif

14
src/strategy/actions/AcceptBattlegroundInvitationAction.cpp
View File

@@ -1,22 +1,24 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#include "AcceptBattlegroundInvitationAction.h"
#include "Event.h"
#include "Playerbots.h"
bool AcceptBgInvitationAction::Execute(Event event)
{
uint8 type = 0; // arenatype if arena
uint8 unk2 = 0; // unk, can be 0x0 (may be if was invited?) and 0x1
uint32 bgTypeId_ = BATTLEGROUND_WS; // type id from dbc
uint16 unk = 0x1F90; // 0x1F90 constant?*/
uint8 type = 0; // arenatype if arena
uint8 unk2 = 0; // unk, can be 0x0 (may be if was invited?) and 0x1
uint32 bgTypeId_ = BATTLEGROUND_WS; // type id from dbc
uint16 unk = 0x1F90; // 0x1F90 constant?*/
uint8 action = 1;
WorldPacket packet(CMSG_BATTLEFIELD_PORT, 20);
packet << type << unk2 << (uint32)bgTypeId_ << unk << action;
//packet << bgTypeId_ << action;
// packet << bgTypeId_ << action;
bot->GetSession()->HandleBattleFieldPortOpcode(packet);
botAI->ResetStrategies();

9
src/strategy/actions/AcceptBattlegroundInvitationAction.h
View File

@@ -1,5 +1,6 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#ifndef _PLAYERBOT_ACCEPTBATTLEGROUNDINVITATIONACTION_H
@@ -11,10 +12,10 @@ class PlayerbotAI;
class AcceptBgInvitationAction : public Action
{
public:
AcceptBgInvitationAction(PlayerbotAI* botAI) : Action(botAI, "accept bg invitatio") { }
public:
AcceptBgInvitationAction(PlayerbotAI* botAI) : Action(botAI, "accept bg invitatio") {}
bool Execute(Event event) override;
bool Execute(Event event) override;
};
#endif

7
src/strategy/actions/AcceptDuelAction.cpp
View File

@@ -1,8 +1,10 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#include "AcceptDuelAction.h"
#include "Event.h"
#include "Playerbots.h"
@@ -16,7 +18,8 @@ bool AcceptDuelAction::Execute(Event event)
p >> playerGuid;
// do not auto duel with low hp
if ((!botAI->HasRealPlayerMaster() || (botAI->GetMaster() && botAI->GetMaster()->GetGUID() != playerGuid)) && AI_VALUE2(uint8, "health", "self target") < 90)
if ((!botAI->HasRealPlayerMaster() || (botAI->GetMaster() && botAI->GetMaster()->GetGUID() != playerGuid)) &&
AI_VALUE2(uint8, "health", "self target") < 90)
{
WorldPacket packet(CMSG_DUEL_CANCELLED, 8);
packet << flagGuid;

9
src/strategy/actions/AcceptDuelAction.h
View File

@@ -1,5 +1,6 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#ifndef _PLAYERBOT_ACCEPTDUELACTION_H
@@ -11,10 +12,10 @@ class PlayerbotAI;
class AcceptDuelAction : public Action
{
public:
AcceptDuelAction(PlayerbotAI* botAI) : Action(botAI, "accept duel") { }
public:
AcceptDuelAction(PlayerbotAI* botAI) : Action(botAI, "accept duel") {}
bool Execute(Event event) override;
bool Execute(Event event) override;
};
#endif

13
src/strategy/actions/AcceptInvitationAction.cpp
View File

@@ -1,13 +1,15 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#include "AcceptInvitationAction.h"
#include "Event.h"
#include "ObjectAccessor.h"
#include "PlayerbotAIConfig.h"
#include "Playerbots.h"
#include "PlayerbotSecurity.h"
#include "Playerbots.h"
#include "WorldPacket.h"
bool AcceptInvitationAction::Execute(Event event)
@@ -41,8 +43,8 @@ bool AcceptInvitationAction::Execute(Event event)
if (sRandomPlayerbotMgr->IsRandomBot(bot))
botAI->SetMaster(inviter);
//else
//sPlayerbotDbStore->Save(botAI);
// else
// sPlayerbotDbStore->Save(botAI);
botAI->ResetStrategies();
botAI->ChangeStrategy("+follow,-lfg,-bg", BOT_STATE_NON_COMBAT);
@@ -50,7 +52,8 @@ bool AcceptInvitationAction::Execute(Event event)
botAI->TellMaster("Hello");
if (sPlayerbotAIConfig->summonWhenGroup && bot->GetDistance(inviter) > sPlayerbotAIConfig->sightDistance) {
if (sPlayerbotAIConfig->summonWhenGroup && bot->GetDistance(inviter) > sPlayerbotAIConfig->sightDistance)
{
Teleport(inviter, bot);
}
return true;

9
src/strategy/actions/AcceptInvitationAction.h
View File

@@ -1,5 +1,6 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#ifndef _PLAYERBOT_ACCEPTINVITATIONACTION_H
@@ -12,10 +13,10 @@ class PlayerbotAI;
class AcceptInvitationAction : public SummonAction
{
public:
AcceptInvitationAction(PlayerbotAI* botAI) : SummonAction(botAI, "accept invitation") { }
public:
AcceptInvitationAction(PlayerbotAI* botAI) : SummonAction(botAI, "accept invitation") {}
bool Execute(Event event) override;
bool Execute(Event event) override;
};
#endif

8
src/strategy/actions/AcceptQuestAction.cpp
View File

@@ -1,8 +1,10 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#include "AcceptQuestAction.h"
#include "Event.h"
#include "Playerbots.h"
@@ -112,7 +114,7 @@ bool AcceptQuestShareAction::Execute(Event event)
bot->SetDivider(ObjectGuid::Empty);
}
if (bot->CanAddQuest( qInfo, false))
if (bot->CanAddQuest(qInfo, false))
{
bot->AddQuest(qInfo, master);
@@ -125,7 +127,7 @@ bool AcceptQuestShareAction::Execute(Event event)
if (qInfo->GetSrcSpell() > 0)
{
bot->CastSpell( bot, qInfo->GetSrcSpell(), true);
bot->CastSpell(bot, qInfo->GetSrcSpell(), true);
}
botAI->TellMaster("Quest accepted");

25
src/strategy/actions/AcceptQuestAction.h
View File

@@ -1,5 +1,6 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#ifndef _PLAYERBOT_ACCEPTQUESTACTION_H
@@ -13,25 +14,27 @@ class WorldObject;
class AcceptAllQuestsAction : public QuestAction
{
public:
AcceptAllQuestsAction(PlayerbotAI* botAI, std::string const name = "accept all quests") : QuestAction(botAI, name) { }
public:
AcceptAllQuestsAction(PlayerbotAI* botAI, std::string const name = "accept all quests") : QuestAction(botAI, name)
{
}
protected:
void ProcessQuest(Quest const* quest, Object* questGiver) override;
protected:
void ProcessQuest(Quest const* quest, Object* questGiver) override;
};
class AcceptQuestAction : public AcceptAllQuestsAction
{
public:
AcceptQuestAction(PlayerbotAI* botAI) : AcceptAllQuestsAction(botAI, "accept quest") { }
bool Execute(Event event) override;
public:
AcceptQuestAction(PlayerbotAI* botAI) : AcceptAllQuestsAction(botAI, "accept quest") {}
bool Execute(Event event) override;
};
class AcceptQuestShareAction : public Action
{
public:
AcceptQuestShareAction(PlayerbotAI* botAI) : Action(botAI, "accept quest share") { }
bool Execute(Event event) override;
public:
AcceptQuestShareAction(PlayerbotAI* botAI) : Action(botAI, "accept quest share") {}
bool Execute(Event event) override;
};
#endif

8
src/strategy/actions/AcceptResurrectAction.cpp
View File

@@ -1,8 +1,10 @@
/*
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
* and/or modify it under version 2 of the License, or (at your option), any later version.
*/
#include "AcceptResurrectAction.h"
#include "Event.h"
#include "Playerbots.h"
@@ -18,8 +20,8 @@ bool AcceptResurrectAction::Execute(Event event)
WorldPacket packet(CMSG_RESURRECT_RESPONSE, 8 + 1);
packet << guid;
packet << uint8(1); // accept
bot->GetSession()->HandleResurrectResponseOpcode(packet); // queue the packet to get around race condition
packet << uint8(1); // accept
bot->GetSession()->HandleResurrectResponseOpcode(packet); // queue the packet to get around race condition
botAI->ChangeEngine(BOT_STATE_NON_COMBAT);

Some files were not shown because too many files have changed in this diff Show More