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

Modify file structure

Browse Source
This commit is contained in:
Yunfan Li
2024-12-13 20:14:25 +08:00
parent a7496b3eb5
commit e7416db7dc
183 changed files with 0 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

87
src/strategy/shaman/CasterShamanStrategy.cpp
View File

@@ -1,87 +0,0 @@
/*
* 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 "CasterShamanStrategy.h"
#include "Playerbots.h"
class CasterShamanStrategyActionNodeFactory : public NamedObjectFactory<ActionNode>
{
public:
CasterShamanStrategyActionNodeFactory()
{
creators["magma totem"] = &magma_totem;
creators["totem of wrath"] = &totem_of_wrath;
}
private:
static ActionNode* magma_totem([[maybe_unused]] PlayerbotAI* botAI)
{
return new ActionNode("magma totem",
/*P*/ nullptr,
/*A*/ nullptr,
/*C*/ NextAction::array(0, new NextAction("fire nova"), nullptr));
}
static ActionNode* totem_of_wrath(PlayerbotAI* botAI)
{
return new ActionNode("totem of wrath",
/*P*/ NULL,
/*A*/ NextAction::array(0, new NextAction("flametongue totem"), NULL),
/*C*/ NULL);
}
};
CasterShamanStrategy::CasterShamanStrategy(PlayerbotAI* botAI) : GenericShamanStrategy(botAI)
{
actionNodeFactories.Add(new CasterShamanStrategyActionNodeFactory());
}
NextAction** CasterShamanStrategy::getDefaultActions()
{
return NextAction::array(0, new NextAction("lava burst", ACTION_DEFAULT + 0.2f),
new NextAction("lightning bolt", ACTION_DEFAULT), NULL);
}
void CasterShamanStrategy::InitTriggers(std::vector<TriggerNode*>& triggers)
{
GenericShamanStrategy::InitTriggers(triggers);
// triggers.push_back(new TriggerNode("enemy out of spell", NextAction::array(0, new NextAction("reach spell",
// ACTION_NORMAL + 9), nullptr))); triggers.push_back(new TriggerNode("shaman weapon", NextAction::array(0, new
// NextAction("flametongue weapon", 23.0f), nullptr)));
triggers.push_back(new TriggerNode(
"enough mana", NextAction::array(0, new NextAction("chain lightning", ACTION_DEFAULT + 0.1f), nullptr)));
triggers.push_back(new TriggerNode("main hand weapon no imbue",
NextAction::array(0, new NextAction("flametongue weapon", 22.0f), nullptr)));
// triggers.push_back(new TriggerNode("searing totem", NextAction::array(0, new NextAction("searing totem", 19.0f),
// nullptr)));
triggers.push_back(
new TriggerNode("flame shock", NextAction::array(0, new NextAction("flame shock", 20.0f), nullptr)));
triggers.push_back(new TriggerNode("elemental mastery",
NextAction::array(0, new NextAction("elemental mastery", 27.0f), nullptr)));
// triggers.push_back(new TriggerNode("frost shock snare", NextAction::array(0, new NextAction("frost
// shock", 21.0f), nullptr)));
triggers.push_back(
new TriggerNode("no fire totem", NextAction::array(0, new NextAction("totem of wrath", 15.0f), NULL)));
triggers.push_back(new TriggerNode("fire elemental totem",
NextAction::array(0, new NextAction("fire elemental totem", 32.0f), nullptr)));
triggers.push_back(
new TriggerNode("medium mana", NextAction::array(0, new NextAction("thunderstorm", ACTION_HIGH + 1), nullptr)));
triggers.push_back(new TriggerNode("enemy is close",
NextAction::array(0, new NextAction("thunderstorm", ACTION_HIGH + 1), nullptr)));
triggers.push_back(new TriggerNode("enemy too close for spell",
NextAction::array(0, new NextAction("flee", ACTION_MOVE + 9), nullptr)));
}
void CasterAoeShamanStrategy::InitTriggers(std::vector<TriggerNode*>& triggers)
{
triggers.push_back(
new TriggerNode("light aoe", NextAction::array(0, new NextAction("chain lightning", 25.0f), nullptr)));
}

33
src/strategy/shaman/CasterShamanStrategy.h
View File

@@ -1,33 +0,0 @@
/*
* 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_CASTSHAMANSTRATEGY_H
#define _PLAYERBOT_CASTSHAMANSTRATEGY_H
#include "GenericShamanStrategy.h"
class PlayerbotAI;
class CasterShamanStrategy : public GenericShamanStrategy
{
public:
CasterShamanStrategy(PlayerbotAI* botAI);
void InitTriggers(std::vector<TriggerNode*>& triggers) override;
NextAction** getDefaultActions() override;
std::string const getName() override { return "caster"; }
uint32 GetType() const override { return STRATEGY_TYPE_COMBAT | STRATEGY_TYPE_DPS | STRATEGY_TYPE_RANGED; }
};
class CasterAoeShamanStrategy : public CombatStrategy
{
public:
CasterAoeShamanStrategy(PlayerbotAI* botAI) : CombatStrategy(botAI) {}
void InitTriggers(std::vector<TriggerNode*>& triggers) override;
std::string const getName() override { return "caster aoe"; }
};
#endif

180
src/strategy/shaman/GenericShamanStrategy.cpp
View File

@@ -1,180 +0,0 @@
/*
* 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 "GenericShamanStrategy.h"
#include "HealShamanStrategy.h"
#include "Playerbots.h"
#include "Strategy.h"
class GenericShamanStrategyActionNodeFactory : public NamedObjectFactory<ActionNode>
{
public:
GenericShamanStrategyActionNodeFactory()
{
creators["flametongue weapon"] = &flametongue_weapon;
creators["frostbrand weapon"] = &frostbrand_weapon;
creators["windfury weapon"] = &windfury_weapon;
creators["lesser healing wave"] = &lesser_healing_wave;
creators["lesser healing wave on party"] = &lesser_healing_wave_on_party;
creators["chain heal on party"] = &chain_heal;
creators["riptide"] = &riptide;
creators["riptide on party"] = &riptide_on_party;
creators["earth shock"] = &earth_shock;
}
private:
static ActionNode* earth_shock([[maybe_unused]] PlayerbotAI* botAI)
{
return new ActionNode("earth shock",
/*P*/ nullptr,
/*A*/ NextAction::array(0, new NextAction("flame shock"), nullptr),
/*C*/ nullptr);
}
static ActionNode* flametongue_weapon([[maybe_unused]] PlayerbotAI* botAI)
{
return new ActionNode("flametongue weapon",
/*P*/ nullptr,
/*A*/ NextAction::array(0, new NextAction("rockbiter weapon"), nullptr),
/*C*/ nullptr);
}
static ActionNode* frostbrand_weapon([[maybe_unused]] PlayerbotAI* botAI)
{
return new ActionNode("frostbrand weapon",
/*P*/ nullptr,
/*A*/ NextAction::array(0, new NextAction("flametongue weapon"), nullptr),
/*C*/ nullptr);
}
static ActionNode* windfury_weapon([[maybe_unused]] PlayerbotAI* botAI)
{
return new ActionNode("windfury weapon",
/*P*/ nullptr,
/*A*/ NextAction::array(0, new NextAction("flametongue weapon"), nullptr),
/*C*/ nullptr);
}
static ActionNode* lesser_healing_wave([[maybe_unused]] PlayerbotAI* botAI)
{
return new ActionNode("lesser healing wave",
/*P*/ nullptr,
/*A*/ NextAction::array(0, new NextAction("healing wave"), nullptr),
/*C*/ nullptr);
}
static ActionNode* lesser_healing_wave_on_party([[maybe_unused]] PlayerbotAI* botAI)
{
return new ActionNode("lesser healing wave on party",
/*P*/ nullptr,
/*A*/ NextAction::array(0, new NextAction("healing wave on party"), nullptr),
/*C*/ nullptr);
}
static ActionNode* chain_heal([[maybe_unused]] PlayerbotAI* botAI)
{
return new ActionNode("chain heal on party",
/*P*/ nullptr,
/*A*/ NextAction::array(0, new NextAction("lesser healing wave on party"), nullptr),
/*C*/ nullptr);
}
static ActionNode* riptide([[maybe_unused]] PlayerbotAI* botAI)
{
return new ActionNode("riptide",
/*P*/ nullptr,
/*A*/ NextAction::array(0, new NextAction("healing wave"), nullptr),
/*C*/ nullptr);
}
static ActionNode* riptide_on_party([[maybe_unused]] PlayerbotAI* botAI)
{
return new ActionNode("riptide on party",
/*P*/ nullptr,
// /*A*/ NextAction::array(0, new NextAction("healing wave on party"), nullptr),
/*A*/ nullptr,
/*C*/ nullptr);
}
};
GenericShamanStrategy::GenericShamanStrategy(PlayerbotAI* botAI) : CombatStrategy(botAI)
{
actionNodeFactories.Add(new GenericShamanStrategyActionNodeFactory());
}
void GenericShamanStrategy::InitTriggers(std::vector<TriggerNode*>& triggers)
{
CombatStrategy::InitTriggers(triggers);
triggers.push_back(
new TriggerNode("wind shear", NextAction::array(0, new NextAction("wind shear", 23.0f), nullptr)));
triggers.push_back(
new TriggerNode("wind shear on enemy healer",
NextAction::array(0, new NextAction("wind shear on enemy healer", 23.0f), nullptr)));
triggers.push_back(new TriggerNode("purge", NextAction::array(0, new NextAction("purge", ACTION_DISPEL), nullptr)));
// triggers.push_back(new TriggerNode("party member medium health", NextAction::array(0, new NextAction("lesser
// healing wave on party", 25.0f), nullptr))); triggers.push_back(new TriggerNode("party member low health",
// NextAction::array(0, new NextAction("riptide on party", 25.0f), nullptr))); triggers.push_back(new
// TriggerNode("medium aoe heal", NextAction::array(0, new NextAction("chain heal on party", 27.0f), nullptr)));
// triggers.push_back(new TriggerNode("medium health", NextAction::array(0, new NextAction("lesser healing
// wave", 26.0f), nullptr))); triggers.push_back(new TriggerNode("low health", NextAction::array(0, new
// NextAction("riptide", 26.0f), nullptr)));
triggers.push_back(new TriggerNode("heroism", NextAction::array(0, new NextAction("heroism", 31.0f), nullptr)));
triggers.push_back(new TriggerNode("bloodlust", NextAction::array(0, new NextAction("bloodlust", 30.0f), nullptr)));
}
void ShamanBuffDpsStrategy::InitTriggers(std::vector<TriggerNode*>& triggers)
{
triggers.push_back(
new TriggerNode("lightning shield", NextAction::array(0, new NextAction("lightning shield", 22.0f), nullptr)));
}
void ShamanBuffManaStrategy::InitTriggers(std::vector<TriggerNode*>& triggers)
{
triggers.push_back(
new TriggerNode("water shield", NextAction::array(0, new NextAction("water shield", 22.0f), nullptr)));
}
void ShamanCureStrategy::InitTriggers(std::vector<TriggerNode*>& triggers)
{
triggers.push_back(
new TriggerNode("cure poison", NextAction::array(0, new NextAction("cure poison", 21.0f), nullptr)));
triggers.push_back(new TriggerNode("party member cure poison",
NextAction::array(0, new NextAction("cure poison on party", 21.0f), nullptr)));
triggers.push_back(new TriggerNode("cleanse spirit poison",
NextAction::array(0, new NextAction("cleanse spirit", 24.0f), nullptr)));
triggers.push_back(
new TriggerNode("party member cleanse spirit poison",
NextAction::array(0, new NextAction("cleanse spirit poison on party", 23.0f), nullptr)));
triggers.push_back(
new TriggerNode("cure disease", NextAction::array(0, new NextAction("cure disease", 31.0f), nullptr)));
triggers.push_back(new TriggerNode("party member cure disease",
NextAction::array(0, new NextAction("cure disease on party", 30.0f), nullptr)));
triggers.push_back(new TriggerNode("cleanse spirit disease",
NextAction::array(0, new NextAction("cleanse spirit", 24.0f), nullptr)));
triggers.push_back(
new TriggerNode("party member cleanse spirit disease",
NextAction::array(0, new NextAction("cleanse spirit disease on party", 23.0f), nullptr)));
triggers.push_back(new TriggerNode("cleanse spirit curse",
NextAction::array(0, new NextAction("cleanse spirit", 24.0f), nullptr)));
triggers.push_back(
new TriggerNode("party member cleanse spirit curse",
NextAction::array(0, new NextAction("cleanse spirit curse on party", 23.0f), nullptr)));
}
void ShamanHealerDpsStrategy::InitTriggers(std::vector<TriggerNode*>& triggers)
{
triggers.push_back(
new TriggerNode("healer should attack",
NextAction::array(0,
new NextAction("flame shock", ACTION_DEFAULT + 0.2f),
new NextAction("lava burst", ACTION_DEFAULT + 0.1f),
new NextAction("lightning bolt", ACTION_DEFAULT), nullptr)));
triggers.push_back(
new TriggerNode("medium aoe and healer should attack",
NextAction::array(0,
new NextAction("chain lightning", ACTION_DEFAULT + 0.3f), nullptr)));
}

57
src/strategy/shaman/GenericShamanStrategy.h
View File

@@ -1,57 +0,0 @@
/*
* 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_GENERICSHAMANSTRATEGY_H
#define _PLAYERBOT_GENERICSHAMANSTRATEGY_H
#include "CombatStrategy.h"
class PlayerbotAI;
class GenericShamanStrategy : public CombatStrategy
{
public:
GenericShamanStrategy(PlayerbotAI* botAI);
void InitTriggers(std::vector<TriggerNode*>& triggers) override;
};
class ShamanBuffDpsStrategy : public Strategy
{
public:
ShamanBuffDpsStrategy(PlayerbotAI* botAI) : Strategy(botAI) {}
void InitTriggers(std::vector<TriggerNode*>& triggers) override;
std::string const getName() override { return "bdps"; }
};
class ShamanBuffManaStrategy : public Strategy
{
public:
ShamanBuffManaStrategy(PlayerbotAI* botAI) : Strategy(botAI) {}
void InitTriggers(std::vector<TriggerNode*>& triggers) override;
std::string const getName() override { return "bmana"; }
};
class ShamanCureStrategy : public Strategy
{
public:
ShamanCureStrategy(PlayerbotAI* botAI) : Strategy(botAI) {}
void InitTriggers(std::vector<TriggerNode*>& triggers) override;
std::string const getName() override { return "cure"; }
};
class ShamanHealerDpsStrategy : public Strategy
{
public:
ShamanHealerDpsStrategy(PlayerbotAI* botAI) : Strategy(botAI) {}
void InitTriggers(std::vector<TriggerNode*>& triggers) override;
std::string const getName() override { return "healer dps"; }
};
#endif

115
src/strategy/shaman/HealShamanStrategy.cpp
View File

@@ -1,115 +0,0 @@
/*
* 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 "HealShamanStrategy.h"
#include "Playerbots.h"
class HealShamanStrategyActionNodeFactory : public NamedObjectFactory<ActionNode>
{
public:
HealShamanStrategyActionNodeFactory()
{
creators["earthliving weapon"] = &earthliving_weapon;
creators["mana tide totem"] = &mana_tide_totem;
}
private:
static ActionNode* earthliving_weapon([[maybe_unused]] PlayerbotAI* botAI)
{
return new ActionNode("earthliving weapon",
/*P*/ nullptr,
/*A*/ NextAction::array(0, new NextAction("flametongue weapon"), nullptr),
/*C*/ nullptr);
}
static ActionNode* mana_tide_totem([[maybe_unused]] PlayerbotAI* botAI)
{
return new ActionNode("mana tide totem",
/*P*/ nullptr,
/*A*/ NextAction::array(0, new NextAction("mana potion"), nullptr),
/*C*/ nullptr);
}
};
HealShamanStrategy::HealShamanStrategy(PlayerbotAI* botAI) : GenericShamanStrategy(botAI)
{
actionNodeFactories.Add(new HealShamanStrategyActionNodeFactory());
}
void HealShamanStrategy::InitTriggers(std::vector<TriggerNode*>& triggers)
{
GenericShamanStrategy::InitTriggers(triggers);
// triggers.push_back(new TriggerNode("enemy out of spell", NextAction::array(0, new NextAction("reach spell",
// ACTION_NORMAL + 9), nullptr))); triggers.push_back(new TriggerNode("shaman weapon", NextAction::array(0, new
// NextAction("earthliving weapon", 22.0f), nullptr)));
triggers.push_back(new TriggerNode("main hand weapon no imbue",
NextAction::array(0, new NextAction("earthliving weapon", 22.0f), nullptr)));
triggers.push_back(new TriggerNode(
"group heal setting",
NextAction::array(0, new NextAction("riptide on party", 27.0f), new NextAction("chain heal on party", 26.0f), NULL)));
triggers.push_back(new TriggerNode(
"party member critical health",
NextAction::array(0, new NextAction("riptide on party", 25.0f), new NextAction("healing wave on party", 24.0f),
new NextAction("lesser healing wave on party", 23.0f), nullptr)));
triggers.push_back(new TriggerNode(
"party member low health",
NextAction::array(0, new NextAction("riptide on party", 19.0f), new NextAction("healing wave on party", 18.0f),
new NextAction("lesser healing wave on party", 17.0f), nullptr)));
triggers.push_back(new TriggerNode(
"party member medium health",
NextAction::array(0, new NextAction("riptide on party", 16.0f), new NextAction("healing wave on party", 15.0f),
new NextAction("lesser healing wave on party", 14.0f), nullptr)));
triggers.push_back(
new TriggerNode("party member almost full health",
NextAction::array(0, new NextAction("riptide on party", 12.0f),
new NextAction("lesser healing wave on party", 11.0f), nullptr)));
triggers.push_back(
new TriggerNode("party member cleanse spirit poison",
NextAction::array(0, new NextAction("cleanse spirit poison on party", ACTION_DISPEL + 2),
new NextAction("cleansing totem", ACTION_DISPEL + 2), NULL)));
triggers.push_back(
new TriggerNode("party member cleanse spirit disease",
NextAction::array(0, new NextAction("cleanse spirit disease on party", ACTION_DISPEL + 2),
new NextAction("cleansing totem", ACTION_DISPEL + 1), NULL)));
triggers.push_back(new TriggerNode(
"party member cleanse spirit curse",
NextAction::array(0, new NextAction("cleanse spirit curse on party", ACTION_DISPEL + 2), NULL)));
// triggers.push_back(new TriggerNode(
// "no fire totem",
// NextAction::array(0, new NextAction("flametongue totem", 10.0f), NULL)));
// triggers.push_back(new TriggerNode(
// "no water totem",
// NextAction::array(0, new NextAction("healing stream totem", 13.0f), NULL)));
triggers.push_back(
new TriggerNode("earth shield on main tank",
NextAction::array(0, new NextAction("earth shield on main tank", ACTION_HIGH + 7), NULL)));
triggers.push_back(new TriggerNode("enemy too close for spell",
NextAction::array(0, new NextAction("flee", ACTION_MOVE + 9), nullptr)));
triggers.push_back(
new TriggerNode("medium mana", NextAction::array(0, new NextAction("mana tide totem", ACTION_HIGH + 5), NULL)));
triggers.push_back(
new TriggerNode("no fire totem", NextAction::array(0, new NextAction("flametongue totem", 7.0f),
new NextAction("searing totem", 6.0f), nullptr)));
triggers.push_back(new TriggerNode("fire elemental totem",
NextAction::array(0, new NextAction("fire elemental totem", 32.0f), nullptr)));
triggers.push_back(new TriggerNode(
"party member to heal out of spell range",
NextAction::array(0, new NextAction("reach party member to heal", ACTION_CRITICAL_HEAL + 1), nullptr)));
}

24
src/strategy/shaman/HealShamanStrategy.h
View File

@@ -1,24 +0,0 @@
/*
* 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_HEALSHAMANSTRATEGY_H
#define _PLAYERBOT_HEALSHAMANSTRATEGY_H
#include "GenericShamanStrategy.h"
#include "Strategy.h"
class PlayerbotAI;
class HealShamanStrategy : public GenericShamanStrategy
{
public:
HealShamanStrategy(PlayerbotAI* botAI);
void InitTriggers(std::vector<TriggerNode*>& triggers) override;
std::string const getName() override { return "heal"; }
uint32 GetType() const override { return STRATEGY_TYPE_RANGED | STRATEGY_TYPE_HEAL; }
};
#endif

105
src/strategy/shaman/MeleeShamanStrategy.cpp
View File

@@ -1,105 +0,0 @@
/*
* 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 "MeleeShamanStrategy.h"
#include "Playerbots.h"
class MeleeShamanStrategyActionNodeFactory : public NamedObjectFactory<ActionNode>
{
public:
MeleeShamanStrategyActionNodeFactory()
{
creators["stormstrike"] = &stormstrike;
creators["lava lash"] = &lava_lash;
creators["magma totem"] = &magma_totem;
}
private:
static ActionNode* stormstrike([[maybe_unused]] PlayerbotAI* botAI)
{
return new ActionNode("stormstrike",
/*P*/ nullptr,
// /*A*/ NextAction::array(0, new NextAction("lava lash"), nullptr),
nullptr,
/*C*/ nullptr);
}
static ActionNode* lava_lash([[maybe_unused]] PlayerbotAI* botAI)
{
return new ActionNode("lava lash",
/*P*/ nullptr,
/*A*/ NextAction::array(0, new NextAction("melee"), nullptr),
/*C*/ nullptr);
}
static ActionNode* magma_totem([[maybe_unused]] PlayerbotAI* botAI)
{
return new ActionNode("magma totem",
/*P*/ NULL,
/*A*/ NextAction::array(0, new NextAction("searing totem"), NULL),
/*C*/ NULL);
}
};
MeleeShamanStrategy::MeleeShamanStrategy(PlayerbotAI* botAI) : GenericShamanStrategy(botAI)
{
actionNodeFactories.Add(new MeleeShamanStrategyActionNodeFactory());
}
NextAction** MeleeShamanStrategy::getDefaultActions()
{
return NextAction::array(
0, new NextAction("stormstrike", ACTION_DEFAULT + 0.5f), new NextAction("earth shock", ACTION_DEFAULT + 0.4f),
new NextAction("feral spirit", ACTION_DEFAULT + 0.3f), new NextAction("fire nova", ACTION_DEFAULT + 0.2f),
new NextAction("lava lash", ACTION_DEFAULT + 0.1f), new NextAction("melee", ACTION_DEFAULT), NULL);
}
void MeleeShamanStrategy::InitTriggers(std::vector<TriggerNode*>& triggers)
{
GenericShamanStrategy::InitTriggers(triggers);
// triggers.push_back(new TriggerNode("shaman weapon", NextAction::array(0, new NextAction("flametongue
// weapon", 22.0f), nullptr)));
triggers.push_back(new TriggerNode("main hand weapon no imbue",
NextAction::array(0, new NextAction("windfury weapon", 22.0f), nullptr)));
triggers.push_back(new TriggerNode("off hand weapon no imbue",
NextAction::array(0, new NextAction("flametongue weapon", 21.0f), nullptr)));
// triggers.push_back(new TriggerNode("searing totem", NextAction::array(0, new NextAction("reach melee", 22.0f),
// new NextAction("searing totem", 22.0f), nullptr)));
triggers.push_back(
new TriggerNode("flame shock", NextAction::array(0, new NextAction("flame shock", 20.0f), nullptr)));
triggers.push_back(
new TriggerNode("maelstrom weapon 4", NextAction::array(0, new NextAction("lightning bolt", 25.0f), nullptr)));
triggers.push_back(new TriggerNode(
"medium aoe", NextAction::array(0, new NextAction("strength of earth totem", ACTION_LIGHT_HEAL), nullptr)));
triggers.push_back(new TriggerNode(
"enemy out of melee", NextAction::array(0, new NextAction("reach melee", ACTION_NORMAL + 8), nullptr)));
triggers.push_back(new TriggerNode(
"no fire totem",
NextAction::array(0, new NextAction("reach melee", 23.0f), new NextAction("magma totem", 22.0f), nullptr)));
triggers.push_back(new TriggerNode(
"fire elemental totem", NextAction::array(0, new NextAction("fire elemental totem melee", 32.0f), nullptr)));
triggers.push_back(
new TriggerNode("no air totem", NextAction::array(0, new NextAction("windfury totem", 20.0f), nullptr)));
triggers.push_back(
new TriggerNode("medium mana", NextAction::array(0, new NextAction("shamanistic rage", 23.0f), nullptr)));
triggers.push_back(
new TriggerNode("low health", NextAction::array(0, new NextAction("shamanistic rage", 23.0f), nullptr)));
}
void MeleeAoeShamanStrategy::InitTriggers(std::vector<TriggerNode*>& triggers)
{
// triggers.push_back(new TriggerNode("magma totem", NextAction::array(0, new NextAction("magma totem", 26.0f),
// nullptr)));
triggers.push_back(
new TriggerNode("medium aoe", NextAction::array(0, new NextAction("fire nova", 25.0f), nullptr)));
}

33
src/strategy/shaman/MeleeShamanStrategy.h
View File

@@ -1,33 +0,0 @@
/*
* 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_MELEESHAMANSTRATEGY_H
#define _PLAYERBOT_MELEESHAMANSTRATEGY_H
#include "GenericShamanStrategy.h"
class PlayerbotAI;
class MeleeShamanStrategy : public GenericShamanStrategy
{
public:
MeleeShamanStrategy(PlayerbotAI* botAI);
void InitTriggers(std::vector<TriggerNode*>& triggers) override;
NextAction** getDefaultActions() override;
std::string const getName() override { return "melee"; }
uint32 GetType() const override { return STRATEGY_TYPE_COMBAT | STRATEGY_TYPE_DPS | STRATEGY_TYPE_MELEE; }
};
class MeleeAoeShamanStrategy : public CombatStrategy
{
public:
MeleeAoeShamanStrategy(PlayerbotAI* botAI) : CombatStrategy(botAI) {}
void InitTriggers(std::vector<TriggerNode*>& triggers) override;
std::string const getName() override { return "melee aoe"; }
};
#endif

70
src/strategy/shaman/ShamanActions.cpp
View File

@@ -1,70 +0,0 @@
/*
* 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 "ShamanActions.h"
#include "Playerbots.h"
#include "Totem.h"
bool CastTotemAction::isUseful()
{
if (needLifeTime > 0.1f)
{
Unit* target = AI_VALUE(Unit*, "current target");
if (!target)
{
return false;
}
float dps = AI_VALUE(float, "estimated group dps");
if (target->GetHealth() / dps < needLifeTime)
{
return false;
}
}
return CastBuffSpellAction::isUseful() && !AI_VALUE2(bool, "has totem", name) && !botAI->HasAura(buff, bot);
}
bool CastManaSpringTotemAction::isUseful()
{
return CastTotemAction::isUseful() && !AI_VALUE2(bool, "has totem", "healing stream totem");
}
bool CastFlametongueTotemAction::isUseful()
{
return CastTotemAction::isUseful() && !AI_VALUE2(bool, "has totem", "magma totem") &&
!botAI->HasAura("totem of wrath", bot);
}
bool CastSearingTotemAction::isUseful()
{
return CastTotemAction::isUseful() && !AI_VALUE2(bool, "has totem", "flametongue totem");
}
bool CastMagmaTotemAction::isUseful() {
Unit* target = AI_VALUE(Unit*, "current target");
if (!target || !bot->IsWithinMeleeRange(target))
return false;
return CastTotemAction::isUseful() && !AI_VALUE2(bool, "has totem", name);
}
bool CastFireNovaAction::isUseful() {
Unit* target = AI_VALUE(Unit*, "current target");
if (!target)
return false;
Creature* fireTotem = bot->GetMap()->GetCreature(bot->m_SummonSlot[1]);
if (!fireTotem)
return false;
if (target->GetDistance(fireTotem) > 8.0f)
return false;
return CastMeleeSpellAction::isUseful();
}
bool CastCleansingTotemAction::isUseful()
{
return CastTotemAction::isUseful() && !AI_VALUE2(bool, "has totem", "mana tide totem");
}

461
src/strategy/shaman/ShamanActions.h
View File

@@ -1,461 +0,0 @@
/*
* 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_SHAMANACTIONS_H
#define _PLAYERBOT_SHAMANACTIONS_H
#include "GenericSpellActions.h"
#include "Playerbots.h"
#include "SharedDefines.h"
class PlayerbotAI;
class CastLesserHealingWaveAction : public CastHealingSpellAction
{
public:
CastLesserHealingWaveAction(PlayerbotAI* botAI) : CastHealingSpellAction(botAI, "lesser healing wave") {}
};
class CastLesserHealingWaveOnPartyAction : public HealPartyMemberAction
{
public:
CastLesserHealingWaveOnPartyAction(PlayerbotAI* botAI)
: HealPartyMemberAction(botAI, "lesser healing wave", 25.0f, HealingManaEfficiency::LOW)
{
}
};
class CastHealingWaveAction : public CastHealingSpellAction
{
public:
CastHealingWaveAction(PlayerbotAI* botAI) : CastHealingSpellAction(botAI, "healing wave") {}
};
class CastHealingWaveOnPartyAction : public HealPartyMemberAction
{
public:
CastHealingWaveOnPartyAction(PlayerbotAI* botAI)
: HealPartyMemberAction(botAI, "healing wave", 50.0f, HealingManaEfficiency::MEDIUM)
{
}
};
class CastChainHealAction : public HealPartyMemberAction
{
public:
CastChainHealAction(PlayerbotAI* botAI)
: HealPartyMemberAction(botAI, "chain heal", 15.0f, HealingManaEfficiency::HIGH)
{
}
};
class CastRiptideAction : public CastHealingSpellAction
{
public:
CastRiptideAction(PlayerbotAI* botAI) : CastHealingSpellAction(botAI, "riptide") {}
};
class CastRiptideOnPartyAction : public HealPartyMemberAction
{
public:
CastRiptideOnPartyAction(PlayerbotAI* botAI)
: HealPartyMemberAction(botAI, "riptide", 15.0f, HealingManaEfficiency::VERY_HIGH)
{
}
};
class CastEarthShieldAction : public CastBuffSpellAction
{
public:
CastEarthShieldAction(PlayerbotAI* botAI) : CastBuffSpellAction(botAI, "earth shield") {}
};
class CastEarthShieldOnPartyAction : public BuffOnPartyAction
{
public:
CastEarthShieldOnPartyAction(PlayerbotAI* botAI) : BuffOnPartyAction(botAI, "earth shield") {}
};
class CastWaterShieldAction : public CastBuffSpellAction
{
public:
CastWaterShieldAction(PlayerbotAI* botAI) : CastBuffSpellAction(botAI, "water shield") {}
};
class CastLightningShieldAction : public CastBuffSpellAction
{
public:
CastLightningShieldAction(PlayerbotAI* botAI) : CastBuffSpellAction(botAI, "lightning shield") {}
};
class CastEarthlivingWeaponAction : public CastEnchantItemAction
{
public:
CastEarthlivingWeaponAction(PlayerbotAI* botAI) : CastEnchantItemAction(botAI, "earthliving weapon") {}
};
class CastRockbiterWeaponAction : public CastEnchantItemAction
{
public:
CastRockbiterWeaponAction(PlayerbotAI* botAI) : CastEnchantItemAction(botAI, "rockbiter weapon") {}
};
class CastFlametongueWeaponAction : public CastEnchantItemAction
{
public:
CastFlametongueWeaponAction(PlayerbotAI* botAI) : CastEnchantItemAction(botAI, "flametongue weapon") {}
};
class CastFrostbrandWeaponAction : public CastEnchantItemAction
{
public:
CastFrostbrandWeaponAction(PlayerbotAI* botAI) : CastEnchantItemAction(botAI, "frostbrand weapon") {}
};
class CastWindfuryWeaponAction : public CastEnchantItemAction
{
public:
CastWindfuryWeaponAction(PlayerbotAI* botAI) : CastEnchantItemAction(botAI, "windfury weapon") {}
};
class CastTotemAction : public CastBuffSpellAction
{
public:
CastTotemAction(PlayerbotAI* botAI, std::string const spell, std::string const buffName = "",
float needLifeTime = 8.0f)
: CastBuffSpellAction(botAI, spell), needLifeTime(needLifeTime)
{
if (buffName == "")
{
buff = spell;
}
else
{
buff = buffName;
}
}
bool isUseful() override;
protected:
float needLifeTime;
std::string buff;
};
class CastStoneskinTotemAction : public CastTotemAction
{
public:
CastStoneskinTotemAction(PlayerbotAI* botAI) : CastTotemAction(botAI, "stoneskin totem") {}
};
class CastEarthbindTotemAction : public CastTotemAction
{
public:
CastEarthbindTotemAction(PlayerbotAI* botAI) : CastTotemAction(botAI, "earthbind totem") {}
};
class CastStrengthOfEarthTotemAction : public CastTotemAction
{
public:
CastStrengthOfEarthTotemAction(PlayerbotAI* botAI)
: CastTotemAction(botAI, "strength of earth totem", "strength of earth", 20.0f)
{
}
};
class CastManaSpringTotemAction : public CastTotemAction
{
public:
CastManaSpringTotemAction(PlayerbotAI* botAI) : CastTotemAction(botAI, "mana spring totem", "mana spring", 0.0f) {}
bool isUseful() override;
};
class CastManaTideTotemAction : public CastTotemAction
{
public:
CastManaTideTotemAction(PlayerbotAI* botAI) : CastTotemAction(botAI, "mana tide totem") {}
std::string const GetTargetName() override { return "self target"; }
};
class CastHealingStreamTotemAction : public CastTotemAction
{
public:
CastHealingStreamTotemAction(PlayerbotAI* botAI) : CastTotemAction(botAI, "healing stream totem") {}
};
class CastCleansingTotemAction : public CastTotemAction
{
public:
CastCleansingTotemAction(PlayerbotAI* botAI) : CastTotemAction(botAI, "cleansing totem") {}
virtual bool isUseful();
};
class CastFlametongueTotemAction : public CastTotemAction
{
public:
CastFlametongueTotemAction(PlayerbotAI* botAI) : CastTotemAction(botAI, "flametongue totem", "", 20.0f) {}
bool isUseful() override;
};
class CastWindfuryTotemAction : public CastTotemAction
{
public:
CastWindfuryTotemAction(PlayerbotAI* botAI) : CastTotemAction(botAI, "windfury totem") {}
};
class CastGraceOfAirTotemAction : public CastTotemAction
{
public:
CastGraceOfAirTotemAction(PlayerbotAI* botAI) : CastTotemAction(botAI, "grace of air totem") {}
};
class CastSearingTotemAction : public CastTotemAction
{
public:
CastSearingTotemAction(PlayerbotAI* botAI) : CastTotemAction(botAI, "searing totem", "", 0.0f) {}
std::string const GetTargetName() override { return "self target"; }
bool isUseful() override;
};
class CastMagmaTotemAction : public CastTotemAction
{
public:
CastMagmaTotemAction(PlayerbotAI* botAI) : CastTotemAction(botAI, "magma totem", "", 0.0f) {}
std::string const GetTargetName() override { return "self target"; }
bool isUseful() override;
};
class CastFireNovaAction : public CastMeleeSpellAction
{
public:
CastFireNovaAction(PlayerbotAI* botAI) : CastMeleeSpellAction(botAI, "fire nova") {}
bool isUseful() override;
};
class CastWindShearAction : public CastSpellAction
{
public:
CastWindShearAction(PlayerbotAI* botAI) : CastSpellAction(botAI, "wind shear") {}
};
class CastAncestralSpiritAction : public ResurrectPartyMemberAction
{
public:
CastAncestralSpiritAction(PlayerbotAI* botAI) : ResurrectPartyMemberAction(botAI, "ancestral spirit") {}
};
class CastPurgeAction : public CastSpellAction
{
public:
CastPurgeAction(PlayerbotAI* botAI) : CastSpellAction(botAI, "purge") {}
};
class CastStormstrikeAction : public CastMeleeSpellAction
{
public:
CastStormstrikeAction(PlayerbotAI* botAI) : CastMeleeSpellAction(botAI, "stormstrike") {}
};
class CastLavaLashAction : public CastMeleeSpellAction
{
public:
CastLavaLashAction(PlayerbotAI* botAI) : CastMeleeSpellAction(botAI, "lava lash") {}
};
class CastWaterBreathingAction : public CastBuffSpellAction
{
public:
CastWaterBreathingAction(PlayerbotAI* botAI) : CastBuffSpellAction(botAI, "water breathing") {}
};
class CastWaterWalkingAction : public CastBuffSpellAction
{
public:
CastWaterWalkingAction(PlayerbotAI* botAI) : CastBuffSpellAction(botAI, "water walking") {}
};
class CastWaterBreathingOnPartyAction : public BuffOnPartyAction
{
public:
CastWaterBreathingOnPartyAction(PlayerbotAI* botAI) : BuffOnPartyAction(botAI, "water breathing") {}
};
class CastWaterWalkingOnPartyAction : public BuffOnPartyAction
{
public:
CastWaterWalkingOnPartyAction(PlayerbotAI* botAI) : BuffOnPartyAction(botAI, "water walking") {}
};
class CastCleanseSpiritAction : public CastCureSpellAction
{
public:
CastCleanseSpiritAction(PlayerbotAI* botAI) : CastCureSpellAction(botAI, "cleanse spirit") {}
};
class CastCleanseSpiritPoisonOnPartyAction : public CurePartyMemberAction
{
public:
CastCleanseSpiritPoisonOnPartyAction(PlayerbotAI* botAI)
: CurePartyMemberAction(botAI, "cleanse spirit", DISPEL_POISON)
{
}
std::string const getName() override { return "cleanse spirit poison on party"; }
};
class CastCleanseSpiritCurseOnPartyAction : public CurePartyMemberAction
{
public:
CastCleanseSpiritCurseOnPartyAction(PlayerbotAI* botAI)
: CurePartyMemberAction(botAI, "cleanse spirit", DISPEL_CURSE)
{
}
std::string const getName() override { return "cleanse spirit curse on party"; }
};
class CastCleanseSpiritDiseaseOnPartyAction : public CurePartyMemberAction
{
public:
CastCleanseSpiritDiseaseOnPartyAction(PlayerbotAI* botAI)
: CurePartyMemberAction(botAI, "cleanse spirit", DISPEL_DISEASE)
{
}
std::string const getName() override { return "cleanse spirit disease on party"; }
};
class CastFlameShockAction : public CastDebuffSpellAction
{
public:
CastFlameShockAction(PlayerbotAI* botAI) : CastDebuffSpellAction(botAI, "flame shock", true, 6.0f) {}
};
class CastEarthShockAction : public CastSpellAction
{
public:
CastEarthShockAction(PlayerbotAI* botAI) : CastSpellAction(botAI, "earth shock") {}
};
class CastFrostShockAction : public CastSnareSpellAction
{
public:
CastFrostShockAction(PlayerbotAI* botAI) : CastSnareSpellAction(botAI, "frost shock") {}
};
class CastChainLightningAction : public CastSpellAction
{
public:
CastChainLightningAction(PlayerbotAI* botAI) : CastSpellAction(botAI, "chain lightning") {}
ActionThreatType getThreatType() override { return ActionThreatType::Aoe; }
};
class CastLightningBoltAction : public CastSpellAction
{
public:
CastLightningBoltAction(PlayerbotAI* botAI) : CastSpellAction(botAI, "lightning bolt") {}
};
class CastThunderstormAction : public CastSpellAction
{
public:
CastThunderstormAction(PlayerbotAI* botAI) : CastSpellAction(botAI, "thunderstorm") {}
};
class CastHeroismAction : public CastBuffSpellAction
{
public:
CastHeroismAction(PlayerbotAI* botAI) : CastBuffSpellAction(botAI, "heroism") {}
};
class CastBloodlustAction : public CastBuffSpellAction
{
public:
CastBloodlustAction(PlayerbotAI* botAI) : CastBuffSpellAction(botAI, "bloodlust") {}
};
class CastElementalMasteryAction : public CastBuffSpellAction
{
public:
CastElementalMasteryAction(PlayerbotAI* botAI) : CastBuffSpellAction(botAI, "elemental mastery") {}
};
class CastWindShearOnEnemyHealerAction : public CastSpellOnEnemyHealerAction
{
public:
CastWindShearOnEnemyHealerAction(PlayerbotAI* botAI) : CastSpellOnEnemyHealerAction(botAI, "wind shear") {}
};
CURE_ACTION(CastCurePoisonActionSham, "cure disease");
CURE_PARTY_ACTION(CastCurePoisonOnPartyActionSham, "cure poison", DISPEL_POISON);
CURE_ACTION(CastCureDiseaseActionSham, "cure disease");
CURE_PARTY_ACTION(CastCureDiseaseOnPartyActionSham, "cure disease", DISPEL_DISEASE);
class CastLavaBurstAction : public CastSpellAction
{
public:
CastLavaBurstAction(PlayerbotAI* ai) : CastSpellAction(ai, "lava burst") {}
};
class CastEarthShieldOnMainTankAction : public BuffOnMainTankAction
{
public:
CastEarthShieldOnMainTankAction(PlayerbotAI* ai) : BuffOnMainTankAction(ai, "earth shield", false) {}
};
class CastTotemOfWrathAction : public CastTotemAction
{
public:
CastTotemOfWrathAction(PlayerbotAI* ai) : CastTotemAction(ai, "totem of wrath") {}
virtual std::string const GetTargetName() override { return "self target"; }
virtual bool isUseful() override { return CastTotemAction::isUseful(); }
};
class CastFireElementalTotemAction : public CastTotemAction
{
public:
CastFireElementalTotemAction(PlayerbotAI* ai) : CastTotemAction(ai, "fire elemental totem", "", 0.0f) {}
virtual std::string const GetTargetName() override { return "self target"; }
virtual bool isUseful() override { return CastTotemAction::isUseful(); }
};
class CastFireElementalTotemMeleeAction : public CastTotemAction
{
public:
CastFireElementalTotemMeleeAction(PlayerbotAI* ai) : CastTotemAction(ai, "fire elemental totem", "", 0.0f) {}
virtual std::string const GetTargetName() override { return "self target"; }
virtual bool isUseful() override
{
Unit* target = AI_VALUE(Unit*, "current target");
if (!target || !bot->IsWithinMeleeRange(target))
return false;
return CastTotemAction::isUseful();
}
};
class CastWrathOfAirTotemAction : public CastTotemAction
{
public:
CastWrathOfAirTotemAction(PlayerbotAI* ai) : CastTotemAction(ai, "wrath of air totem", "wrath of air totem") {}
};
class CastShamanisticRageAction : public CastBuffSpellAction
{
public:
CastShamanisticRageAction(PlayerbotAI* ai) : CastBuffSpellAction(ai, "shamanistic rage") {}
};
class CastFeralSpiritAction : public CastSpellAction
{
public:
CastFeralSpiritAction(PlayerbotAI* ai) : CastSpellAction(ai, "feral spirit") {}
};
#endif

338
src/strategy/shaman/ShamanAiObjectContext.cpp
View File

@@ -1,338 +0,0 @@
/*
* 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 "ShamanAiObjectContext.h"
#include "CasterShamanStrategy.h"
#include "GenericShamanStrategy.h"
#include "HealShamanStrategy.h"
#include "MeleeShamanStrategy.h"
#include "NamedObjectContext.h"
#include "Playerbots.h"
#include "ShamanActions.h"
#include "ShamanNonCombatStrategy.h"
#include "ShamanTriggers.h"
#include "TotemsShamanStrategy.h"
class ShamanStrategyFactoryInternal : public NamedObjectContext<Strategy>
{
public:
ShamanStrategyFactoryInternal()
{
creators["nc"] = &ShamanStrategyFactoryInternal::nc;
creators["totems"] = &ShamanStrategyFactoryInternal::totems;
creators["melee aoe"] = &ShamanStrategyFactoryInternal::melee_aoe;
creators["caster aoe"] = &ShamanStrategyFactoryInternal::caster_aoe;
creators["cure"] = &ShamanStrategyFactoryInternal::cure;
creators["healer dps"] = &ShamanStrategyFactoryInternal::healer_dps;
}
private:
static Strategy* nc(PlayerbotAI* botAI) { return new ShamanNonCombatStrategy(botAI); }
static Strategy* totems(PlayerbotAI* botAI) { return new TotemsShamanStrategy(botAI); }
static Strategy* melee_aoe(PlayerbotAI* botAI) { return new MeleeAoeShamanStrategy(botAI); }
static Strategy* caster_aoe(PlayerbotAI* botAI) { return new CasterAoeShamanStrategy(botAI); }
static Strategy* cure(PlayerbotAI* botAI) { return new ShamanCureStrategy(botAI); }
static Strategy* healer_dps(PlayerbotAI* botAI) { return new ShamanHealerDpsStrategy(botAI); }
};
class ShamanBuffStrategyFactoryInternal : public NamedObjectContext<Strategy>
{
public:
ShamanBuffStrategyFactoryInternal() : NamedObjectContext<Strategy>(false, true)
{
creators["bmana"] = &ShamanBuffStrategyFactoryInternal::bmana;
creators["bdps"] = &ShamanBuffStrategyFactoryInternal::bdps;
}
private:
static Strategy* bmana(PlayerbotAI* botAI) { return new ShamanBuffManaStrategy(botAI); }
static Strategy* bdps(PlayerbotAI* botAI) { return new ShamanBuffDpsStrategy(botAI); }
};
class ShamanCombatStrategyFactoryInternal : public NamedObjectContext<Strategy>
{
public:
ShamanCombatStrategyFactoryInternal() : NamedObjectContext<Strategy>(false, true)
{
creators["heal"] = &ShamanCombatStrategyFactoryInternal::heal;
creators["melee"] = &ShamanCombatStrategyFactoryInternal::dps;
creators["dps"] = &ShamanCombatStrategyFactoryInternal::dps;
creators["caster"] = &ShamanCombatStrategyFactoryInternal::caster;
}
private:
static Strategy* heal(PlayerbotAI* botAI) { return new HealShamanStrategy(botAI); }
static Strategy* dps(PlayerbotAI* botAI) { return new MeleeShamanStrategy(botAI); }
static Strategy* caster(PlayerbotAI* botAI) { return new CasterShamanStrategy(botAI); }
};
class ShamanATriggerFactoryInternal : public NamedObjectContext<Trigger>
{
public:
ShamanATriggerFactoryInternal()
{
creators["grace of air totem"] = &ShamanATriggerFactoryInternal::grace_of_air_totem;
creators["windfury totem"] = &ShamanATriggerFactoryInternal::windfury_totem;
creators["mana spring totem"] = &ShamanATriggerFactoryInternal::mana_spring_totem;
creators["flametongue totem"] = &ShamanATriggerFactoryInternal::flametongue_totem;
creators["strength of earth totem"] = &ShamanATriggerFactoryInternal::strength_of_earth_totem;
creators["fire elemental totem"] = &ShamanATriggerFactoryInternal::fire_elemental_totem;
creators["magma totem"] = &ShamanATriggerFactoryInternal::magma_totem;
creators["searing totem"] = &ShamanATriggerFactoryInternal::searing_totem;
creators["wind shear"] = &ShamanATriggerFactoryInternal::wind_shear;
creators["purge"] = &ShamanATriggerFactoryInternal::purge;
// creators["shaman weapon"] = &ShamanATriggerFactoryInternal::shaman_weapon;
creators["main hand weapon no imbue"] = &ShamanATriggerFactoryInternal::main_hand_weapon_no_imbue;
creators["off hand weapon no imbue"] = &ShamanATriggerFactoryInternal::off_hand_weapon_no_imbue;
creators["water shield"] = &ShamanATriggerFactoryInternal::water_shield;
creators["lightning shield"] = &ShamanATriggerFactoryInternal::lightning_shield;
creators["water breathing"] = &ShamanATriggerFactoryInternal::water_breathing;
creators["water walking"] = &ShamanATriggerFactoryInternal::water_walking;
creators["water breathing on party"] = &ShamanATriggerFactoryInternal::water_breathing_on_party;
creators["water walking on party"] = &ShamanATriggerFactoryInternal::water_walking_on_party;
creators["cleanse spirit poison"] = &ShamanATriggerFactoryInternal::cleanse_poison;
creators["cleanse spirit curse"] = &ShamanATriggerFactoryInternal::cleanse_curse;
creators["cleanse spirit disease"] = &ShamanATriggerFactoryInternal::cleanse_disease;
creators["party member cleanse spirit poison"] = &ShamanATriggerFactoryInternal::party_member_cleanse_poison;
creators["party member cleanse spirit curse"] = &ShamanATriggerFactoryInternal::party_member_cleanse_curse;
creators["party member cleanse spirit disease"] = &ShamanATriggerFactoryInternal::party_member_cleanse_disease;
creators["shock"] = &ShamanATriggerFactoryInternal::shock;
creators["frost shock snare"] = &ShamanATriggerFactoryInternal::frost_shock_snare;
creators["heroism"] = &ShamanATriggerFactoryInternal::heroism;
creators["bloodlust"] = &ShamanATriggerFactoryInternal::bloodlust;
creators["elemental mastery"] = &ShamanATriggerFactoryInternal::elemental_mastery;
creators["wind shear on enemy healer"] = &ShamanATriggerFactoryInternal::wind_shear_on_enemy_healer;
creators["cure poison"] = &ShamanATriggerFactoryInternal::cure_poison;
creators["party member cure poison"] = &ShamanATriggerFactoryInternal::party_member_cure_poison;
creators["cure disease"] = &ShamanATriggerFactoryInternal::cure_disease;
creators["party member cure disease"] = &ShamanATriggerFactoryInternal::party_member_cure_disease;
creators["no fire totem"] = &ShamanATriggerFactoryInternal::no_fire_totem;
creators["no water totem"] = &ShamanATriggerFactoryInternal::no_water_totem;
creators["no air totem"] = &ShamanATriggerFactoryInternal::no_air_totem;
creators["earth shield on main tank"] = &ShamanATriggerFactoryInternal::earth_shield_on_main_tank;
creators["maelstrom weapon 3"] = &ShamanATriggerFactoryInternal::maelstrom_weapon_3;
creators["maelstrom weapon 4"] = &ShamanATriggerFactoryInternal::maelstrom_weapon_4;
creators["maelstrom weapon 5"] = &ShamanATriggerFactoryInternal::maelstrom_weapon_5;
creators["flame shock"] = &ShamanATriggerFactoryInternal::flame_shock;
creators["wrath of air totem"] = &ShamanATriggerFactoryInternal::wrath_of_air_totem;
}
private:
static Trigger* maelstrom_weapon_3(PlayerbotAI* botAI) { return new MaelstromWeaponTrigger(botAI, 3); }
static Trigger* maelstrom_weapon_4(PlayerbotAI* botAI) { return new MaelstromWeaponTrigger(botAI, 4); }
static Trigger* maelstrom_weapon_5(PlayerbotAI* botAI) { return new MaelstromWeaponTrigger(botAI, 5); }
static Trigger* heroism(PlayerbotAI* botAI) { return new HeroismTrigger(botAI); }
static Trigger* bloodlust(PlayerbotAI* botAI) { return new BloodlustTrigger(botAI); }
static Trigger* elemental_mastery(PlayerbotAI* botAI) { return new ElementalMasteryTrigger(botAI); }
static Trigger* party_member_cleanse_disease(PlayerbotAI* botAI)
{
return new PartyMemberCleanseSpiritDiseaseTrigger(botAI);
}
static Trigger* party_member_cleanse_curse(PlayerbotAI* botAI)
{
return new PartyMemberCleanseSpiritCurseTrigger(botAI);
}
static Trigger* party_member_cleanse_poison(PlayerbotAI* botAI)
{
return new PartyMemberCleanseSpiritPoisonTrigger(botAI);
}
static Trigger* cleanse_disease(PlayerbotAI* botAI) { return new CleanseSpiritDiseaseTrigger(botAI); }
static Trigger* cleanse_curse(PlayerbotAI* botAI) { return new CleanseSpiritCurseTrigger(botAI); }
static Trigger* cleanse_poison(PlayerbotAI* botAI) { return new CleanseSpiritPoisonTrigger(botAI); }
static Trigger* water_breathing(PlayerbotAI* botAI) { return new WaterBreathingTrigger(botAI); }
static Trigger* water_walking(PlayerbotAI* botAI) { return new WaterWalkingTrigger(botAI); }
static Trigger* water_breathing_on_party(PlayerbotAI* botAI) { return new WaterBreathingOnPartyTrigger(botAI); }
static Trigger* water_walking_on_party(PlayerbotAI* botAI) { return new WaterWalkingOnPartyTrigger(botAI); }
static Trigger* windfury_totem(PlayerbotAI* botAI) { return new WindfuryTotemTrigger(botAI); }
static Trigger* grace_of_air_totem(PlayerbotAI* botAI) { return new GraceOfAirTotemTrigger(botAI); }
static Trigger* mana_spring_totem(PlayerbotAI* botAI) { return new ManaSpringTotemTrigger(botAI); }
static Trigger* flametongue_totem(PlayerbotAI* botAI) { return new FlametongueTotemTrigger(botAI); }
static Trigger* strength_of_earth_totem(PlayerbotAI* botAI) { return new StrengthOfEarthTotemTrigger(botAI); }
static Trigger* fire_elemental_totem(PlayerbotAI* botAI) { return new FireElementalTotemTrigger(botAI); }
static Trigger* magma_totem(PlayerbotAI* botAI) { return new MagmaTotemTrigger(botAI); }
static Trigger* searing_totem(PlayerbotAI* botAI) { return new SearingTotemTrigger(botAI); }
static Trigger* wind_shear(PlayerbotAI* botAI) { return new WindShearInterruptSpellTrigger(botAI); }
static Trigger* purge(PlayerbotAI* botAI) { return new PurgeTrigger(botAI); }
// static Trigger* shaman_weapon(PlayerbotAI* botAI) { return new ShamanWeaponTrigger(botAI); }
static Trigger* main_hand_weapon_no_imbue(PlayerbotAI* botAI) { return new MainHandWeaponNoImbueTrigger(botAI); }
static Trigger* off_hand_weapon_no_imbue(PlayerbotAI* botAI) { return new OffHandWeaponNoImbueTrigger(botAI); }
static Trigger* water_shield(PlayerbotAI* botAI) { return new WaterShieldTrigger(botAI); }
static Trigger* lightning_shield(PlayerbotAI* botAI) { return new LightningShieldTrigger(botAI); }
static Trigger* shock(PlayerbotAI* botAI) { return new ShockTrigger(botAI); }
static Trigger* frost_shock_snare(PlayerbotAI* botAI) { return new FrostShockSnareTrigger(botAI); }
static Trigger* wind_shear_on_enemy_healer(PlayerbotAI* botAI)
{
return new WindShearInterruptEnemyHealerSpellTrigger(botAI);
}
static Trigger* cure_poison(PlayerbotAI* botAI) { return new CurePoisonTrigger(botAI); }
static Trigger* party_member_cure_poison(PlayerbotAI* botAI) { return new PartyMemberCurePoisonTrigger(botAI); }
static Trigger* cure_disease(PlayerbotAI* botAI) { return new CureDiseaseTrigger(botAI); }
static Trigger* party_member_cure_disease(PlayerbotAI* botAI) { return new PartyMemberCureDiseaseTrigger(botAI); }
static Trigger* no_fire_totem(PlayerbotAI* ai) { return new NoFireTotemTrigger(ai); }
static Trigger* no_water_totem(PlayerbotAI* ai) { return new NoWaterTotemTrigger(ai); }
static Trigger* no_air_totem(PlayerbotAI* ai) { return new NoAirTotemTrigger(ai); }
static Trigger* earth_shield_on_main_tank(PlayerbotAI* ai) { return new EarthShieldOnMainTankTrigger(ai); }
static Trigger* flame_shock(PlayerbotAI* ai) { return new FlameShockTrigger(ai); }
static Trigger* wrath_of_air_totem(PlayerbotAI* ai) { return new WrathOfAirTotemTrigger(ai); }
};
class ShamanAiObjectContextInternal : public NamedObjectContext<Action>
{
public:
ShamanAiObjectContextInternal()
{
creators["water shield"] = &ShamanAiObjectContextInternal::water_shield;
creators["lightning shield"] = &ShamanAiObjectContextInternal::lightning_shield;
creators["strength of earth totem"] = &ShamanAiObjectContextInternal::strength_of_earth_totem;
creators["flametongue totem"] = &ShamanAiObjectContextInternal::flametongue_totem;
creators["searing totem"] = &ShamanAiObjectContextInternal::searing_totem;
creators["magma totem"] = &ShamanAiObjectContextInternal::magma_totem;
creators["windfury totem"] = &ShamanAiObjectContextInternal::windfury_totem;
creators["grace of air totem"] = &ShamanAiObjectContextInternal::grace_of_air_totem;
creators["mana spring totem"] = &ShamanAiObjectContextInternal::mana_spring_totem;
creators["mana tide totem"] = &ShamanAiObjectContextInternal::mana_tide_totem;
creators["earthbind totem"] = &ShamanAiObjectContextInternal::earthbind_totem;
creators["healing stream totem"] = &ShamanAiObjectContextInternal::healing_stream_totem;
creators["wind shear"] = &ShamanAiObjectContextInternal::wind_shear;
creators["wind shear on enemy healer"] = &ShamanAiObjectContextInternal::wind_shear_on_enemy_healer;
creators["rockbiter weapon"] = &ShamanAiObjectContextInternal::rockbiter_weapon;
creators["flametongue weapon"] = &ShamanAiObjectContextInternal::flametongue_weapon;
creators["frostbrand weapon"] = &ShamanAiObjectContextInternal::frostbrand_weapon;
creators["windfury weapon"] = &ShamanAiObjectContextInternal::windfury_weapon;
creators["earthliving weapon"] = &ShamanAiObjectContextInternal::earthliving_weapon;
creators["purge"] = &ShamanAiObjectContextInternal::purge;
creators["healing wave"] = &ShamanAiObjectContextInternal::healing_wave;
creators["lesser healing wave"] = &ShamanAiObjectContextInternal::lesser_healing_wave;
creators["healing wave on party"] = &ShamanAiObjectContextInternal::healing_wave_on_party;
creators["lesser healing wave on party"] = &ShamanAiObjectContextInternal::lesser_healing_wave_on_party;
creators["earth shield"] = &ShamanAiObjectContextInternal::earth_shield;
creators["earth shield on party"] = &ShamanAiObjectContextInternal::earth_shield_on_party;
creators["chain heal on party"] = &ShamanAiObjectContextInternal::chain_heal;
creators["riptide"] = &ShamanAiObjectContextInternal::riptide;
creators["riptide on party"] = &ShamanAiObjectContextInternal::riptide_on_party;
creators["stormstrike"] = &ShamanAiObjectContextInternal::stormstrike;
creators["lava lash"] = &ShamanAiObjectContextInternal::lava_lash;
creators["fire nova"] = &ShamanAiObjectContextInternal::fire_nova;
creators["ancestral spirit"] = &ShamanAiObjectContextInternal::ancestral_spirit;
creators["water walking"] = &ShamanAiObjectContextInternal::water_walking;
creators["water breathing"] = &ShamanAiObjectContextInternal::water_breathing;
creators["water walking on party"] = &ShamanAiObjectContextInternal::water_walking_on_party;
creators["water breathing on party"] = &ShamanAiObjectContextInternal::water_breathing_on_party;
creators["cleanse spirit"] = &ShamanAiObjectContextInternal::cleanse_spirit;
creators["cleanse spirit poison on party"] = &ShamanAiObjectContextInternal::cleanse_spirit_poison_on_party;
creators["cleanse spirit disease on party"] = &ShamanAiObjectContextInternal::cleanse_spirit_disease_on_party;
creators["cleanse spirit curse on party"] = &ShamanAiObjectContextInternal::cleanse_spirit_curse_on_party;
creators["flame shock"] = &ShamanAiObjectContextInternal::flame_shock;
creators["earth shock"] = &ShamanAiObjectContextInternal::earth_shock;
creators["frost shock"] = &ShamanAiObjectContextInternal::frost_shock;
creators["chain lightning"] = &ShamanAiObjectContextInternal::chain_lightning;
creators["lightning bolt"] = &ShamanAiObjectContextInternal::lightning_bolt;
creators["thunderstorm"] = &ShamanAiObjectContextInternal::thunderstorm;
creators["heroism"] = &ShamanAiObjectContextInternal::heroism;
creators["bloodlust"] = &ShamanAiObjectContextInternal::bloodlust;
creators["elemental mastery"] = &ShamanAiObjectContextInternal::elemental_mastery;
creators["cure disease"] = &ShamanAiObjectContextInternal::cure_disease;
creators["cure disease on party"] = &ShamanAiObjectContextInternal::cure_disease_on_party;
creators["cure poison"] = &ShamanAiObjectContextInternal::cure_poison;
creators["cure poison on party"] = &ShamanAiObjectContextInternal::cure_poison_on_party;
creators["lava burst"] = &ShamanAiObjectContextInternal::lava_burst;
creators["earth shield on main tank"] = &ShamanAiObjectContextInternal::earth_shield_on_main_tank;
creators["fire elemental totem"] = &ShamanAiObjectContextInternal::fire_elemental_totem;
creators["fire elemental totem melee"] = &ShamanAiObjectContextInternal::fire_elemental_totem_melee;
creators["totem of wrath"] = &ShamanAiObjectContextInternal::totem_of_wrath;
creators["wrath of air totem"] = &ShamanAiObjectContextInternal::wrath_of_air_totem;
creators["shamanistic rage"] = &ShamanAiObjectContextInternal::shamanistic_rage;
creators["feral spirit"] = &ShamanAiObjectContextInternal::feral_spirit;
}
private:
static Action* heroism(PlayerbotAI* botAI) { return new CastHeroismAction(botAI); }
static Action* bloodlust(PlayerbotAI* botAI) { return new CastBloodlustAction(botAI); }
static Action* elemental_mastery(PlayerbotAI* botAI) { return new CastElementalMasteryAction(botAI); }
static Action* thunderstorm(PlayerbotAI* botAI) { return new CastThunderstormAction(botAI); }
static Action* lightning_bolt(PlayerbotAI* botAI) { return new CastLightningBoltAction(botAI); }
static Action* chain_lightning(PlayerbotAI* botAI) { return new CastChainLightningAction(botAI); }
static Action* frost_shock(PlayerbotAI* botAI) { return new CastFrostShockAction(botAI); }
static Action* earth_shock(PlayerbotAI* botAI) { return new CastEarthShockAction(botAI); }
static Action* flame_shock(PlayerbotAI* botAI) { return new CastFlameShockAction(botAI); }
static Action* cleanse_spirit_poison_on_party(PlayerbotAI* botAI)
{
return new CastCleanseSpiritPoisonOnPartyAction(botAI);
}
static Action* cleanse_spirit_disease_on_party(PlayerbotAI* botAI)
{
return new CastCleanseSpiritDiseaseOnPartyAction(botAI);
}
static Action* cleanse_spirit_curse_on_party(PlayerbotAI* botAI)
{
return new CastCleanseSpiritCurseOnPartyAction(botAI);
}
static Action* cleanse_spirit(PlayerbotAI* botAI) { return new CastCleanseSpiritAction(botAI); }
static Action* water_walking(PlayerbotAI* botAI) { return new CastWaterWalkingAction(botAI); }
static Action* water_breathing(PlayerbotAI* botAI) { return new CastWaterBreathingAction(botAI); }
static Action* water_walking_on_party(PlayerbotAI* botAI) { return new CastWaterWalkingOnPartyAction(botAI); }
static Action* water_breathing_on_party(PlayerbotAI* botAI) { return new CastWaterBreathingOnPartyAction(botAI); }
static Action* water_shield(PlayerbotAI* botAI) { return new CastWaterShieldAction(botAI); }
static Action* lightning_shield(PlayerbotAI* botAI) { return new CastLightningShieldAction(botAI); }
static Action* strength_of_earth_totem(PlayerbotAI* botAI) { return new CastStrengthOfEarthTotemAction(botAI); }
static Action* flametongue_totem(PlayerbotAI* botAI) { return new CastFlametongueTotemAction(botAI); }
static Action* magma_totem(PlayerbotAI* botAI) { return new CastMagmaTotemAction(botAI); }
static Action* searing_totem(PlayerbotAI* botAI) { return new CastSearingTotemAction(botAI); }
static Action* fire_nova(PlayerbotAI* botAI) { return new CastFireNovaAction(botAI); }
static Action* windfury_totem(PlayerbotAI* botAI) { return new CastWindfuryTotemAction(botAI); }
static Action* grace_of_air_totem(PlayerbotAI* botAI) { return new CastGraceOfAirTotemAction(botAI); }
static Action* mana_spring_totem(PlayerbotAI* botAI) { return new CastManaSpringTotemAction(botAI); }
static Action* mana_tide_totem(PlayerbotAI* botAI) { return new CastManaTideTotemAction(botAI); }
static Action* earthbind_totem(PlayerbotAI* botAI) { return new CastEarthbindTotemAction(botAI); }
static Action* healing_stream_totem(PlayerbotAI* botAI) { return new CastHealingStreamTotemAction(botAI); }
static Action* wind_shear(PlayerbotAI* botAI) { return new CastWindShearAction(botAI); }
static Action* rockbiter_weapon(PlayerbotAI* botAI) { return new CastRockbiterWeaponAction(botAI); }
static Action* flametongue_weapon(PlayerbotAI* botAI) { return new CastFlametongueWeaponAction(botAI); }
static Action* frostbrand_weapon(PlayerbotAI* botAI) { return new CastFrostbrandWeaponAction(botAI); }
static Action* windfury_weapon(PlayerbotAI* botAI) { return new CastWindfuryWeaponAction(botAI); }
static Action* earthliving_weapon(PlayerbotAI* botAI) { return new CastEarthlivingWeaponAction(botAI); }
static Action* purge(PlayerbotAI* botAI) { return new CastPurgeAction(botAI); }
static Action* healing_wave(PlayerbotAI* botAI) { return new CastHealingWaveAction(botAI); }
static Action* lesser_healing_wave(PlayerbotAI* botAI) { return new CastLesserHealingWaveAction(botAI); }
static Action* healing_wave_on_party(PlayerbotAI* botAI) { return new CastHealingWaveOnPartyAction(botAI); }
static Action* lesser_healing_wave_on_party(PlayerbotAI* botAI)
{
return new CastLesserHealingWaveOnPartyAction(botAI);
}
static Action* earth_shield(PlayerbotAI* botAI) { return new CastEarthShieldAction(botAI); }
static Action* earth_shield_on_party(PlayerbotAI* botAI) { return new CastEarthShieldOnPartyAction(botAI); }
static Action* chain_heal(PlayerbotAI* botAI) { return new CastChainHealAction(botAI); }
static Action* riptide(PlayerbotAI* botAI) { return new CastRiptideAction(botAI); }
static Action* riptide_on_party(PlayerbotAI* botAI) { return new CastRiptideOnPartyAction(botAI); }
static Action* stormstrike(PlayerbotAI* botAI) { return new CastStormstrikeAction(botAI); }
static Action* lava_lash(PlayerbotAI* botAI) { return new CastLavaLashAction(botAI); }
static Action* ancestral_spirit(PlayerbotAI* botAI) { return new CastAncestralSpiritAction(botAI); }
static Action* wind_shear_on_enemy_healer(PlayerbotAI* botAI)
{
return new CastWindShearOnEnemyHealerAction(botAI);
}
static Action* cure_poison(PlayerbotAI* botAI) { return new CastCurePoisonActionSham(botAI); }
static Action* cure_poison_on_party(PlayerbotAI* botAI) { return new CastCurePoisonOnPartyActionSham(botAI); }
static Action* cure_disease(PlayerbotAI* botAI) { return new CastCureDiseaseActionSham(botAI); }
static Action* cure_disease_on_party(PlayerbotAI* botAI) { return new CastCureDiseaseOnPartyActionSham(botAI); }
static Action* lava_burst(PlayerbotAI* ai) { return new CastLavaBurstAction(ai); }
static Action* earth_shield_on_main_tank(PlayerbotAI* ai) { return new CastEarthShieldOnMainTankAction(ai); }
static Action* totem_of_wrath(PlayerbotAI* ai) { return new CastTotemOfWrathAction(ai); }
static Action* fire_elemental_totem(PlayerbotAI* ai) { return new CastFireElementalTotemAction(ai); }
static Action* fire_elemental_totem_melee(PlayerbotAI* ai) { return new CastFireElementalTotemMeleeAction(ai); }
static Action* wrath_of_air_totem(PlayerbotAI* ai) { return new CastWrathOfAirTotemAction(ai); }
static Action* shamanistic_rage(PlayerbotAI* ai) { return new CastShamanisticRageAction(ai); }
static Action* feral_spirit(PlayerbotAI* ai) { return new CastFeralSpiritAction(ai); }
};
ShamanAiObjectContext::ShamanAiObjectContext(PlayerbotAI* botAI) : AiObjectContext(botAI)
{
strategyContexts.Add(new ShamanStrategyFactoryInternal());
strategyContexts.Add(new ShamanCombatStrategyFactoryInternal());
strategyContexts.Add(new ShamanBuffStrategyFactoryInternal());
actionContexts.Add(new ShamanAiObjectContextInternal());
triggerContexts.Add(new ShamanATriggerFactoryInternal());
}

19
src/strategy/shaman/ShamanAiObjectContext.h
View File

@@ -1,19 +0,0 @@
/*
* 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_SHAMANAIOBJECTCONTEXT_H
#define _PLAYERBOT_SHAMANAIOBJECTCONTEXT_H
#include "AiObjectContext.h"
class PlayerbotAI;
class ShamanAiObjectContext : public AiObjectContext
{
public:
ShamanAiObjectContext(PlayerbotAI* botAI);
};
#endif

57
src/strategy/shaman/ShamanNonCombatStrategy.cpp
View File

@@ -1,57 +0,0 @@
/*
* 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 "ShamanNonCombatStrategy.h"
#include "Playerbots.h"
void ShamanNonCombatStrategy::InitTriggers(std::vector<TriggerNode*>& triggers)
{
NonCombatStrategy::InitTriggers(triggers);
triggers.push_back(
new TriggerNode("party member dead",
NextAction::array(0, new NextAction("ancestral spirit", ACTION_CRITICAL_HEAL + 10), nullptr)));
triggers.push_back(
new TriggerNode("water breathing", NextAction::array(0, new NextAction("water breathing", 12.0f), nullptr)));
triggers.push_back(
new TriggerNode("water walking", NextAction::array(0, new NextAction("water walking", 12.0f), nullptr)));
triggers.push_back(new TriggerNode(
"water breathing on party", NextAction::array(0, new NextAction("water breathing on party", 11.0f), nullptr)));
triggers.push_back(new TriggerNode("water walking on party",
NextAction::array(0, new NextAction("water walking on party", 11.0f), nullptr)));
triggers.push_back(new TriggerNode("party member critical health",
NextAction::array(0, new NextAction("riptide on party", 31.0f),
new NextAction("healing wave on party", 30.0f), NULL)));
triggers.push_back(new TriggerNode("party member low health",
NextAction::array(0, new NextAction("riptide on party", 29.0f),
new NextAction("healing wave on party", 28.0f), NULL)));
triggers.push_back(new TriggerNode("party member medium health",
NextAction::array(0, new NextAction("riptide on party", 27.0f),
new NextAction("healing wave on party", 26.0f), NULL)));
triggers.push_back(new TriggerNode("party member almost full health",
NextAction::array(0, new NextAction("riptide on party", 25.0f),
new NextAction("lesser healing wave on party", 24.0f), NULL)));
triggers.push_back(
new TriggerNode("group heal setting", NextAction::array(0, new NextAction("chain heal on party", 27.0f), NULL)));
triggers.push_back(
new TriggerNode("cure poison", NextAction::array(0, new NextAction("cure poison", 21.0f), nullptr)));
triggers.push_back(new TriggerNode("party member cure poison",
NextAction::array(0, new NextAction("cure poison on party", 21.0f), nullptr)));
triggers.push_back(
new TriggerNode("cure disease", NextAction::array(0, new NextAction("cure disease", 31.0f), nullptr)));
triggers.push_back(new TriggerNode("party member cure disease",
NextAction::array(0, new NextAction("cure disease on party", 30.0f), nullptr)));
}
void ShamanNonCombatStrategy::InitMultipliers(std::vector<Multiplier*>& multipliers)
{
NonCombatStrategy::InitMultipliers(multipliers);
}

23
src/strategy/shaman/ShamanNonCombatStrategy.h
View File

@@ -1,23 +0,0 @@
/*
* 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_SHAMANNONCOMBATSTRATEGY_H
#define _PLAYERBOT_SHAMANNONCOMBATSTRATEGY_H
#include "NonCombatStrategy.h"
class PlayerbotAI;
class ShamanNonCombatStrategy : public NonCombatStrategy
{
public:
ShamanNonCombatStrategy(PlayerbotAI* botAI) : NonCombatStrategy(botAI) {}
void InitTriggers(std::vector<TriggerNode*>& triggers) override;
void InitMultipliers(std::vector<Multiplier*>& multipliers) override;
std::string const getName() override { return "nc"; }
};
#endif

104
src/strategy/shaman/ShamanTriggers.cpp
View File

@@ -1,104 +0,0 @@
/*
* 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 "ShamanTriggers.h"
#include "Playerbots.h"
/*
std::vector<std::string> ShamanWeaponTrigger::spells;
bool ShamanWeaponTrigger::IsActive()
{
if (spells.empty())
{
spells.push_back("frostbrand weapon");
spells.push_back("rockbiter weapon");
spells.push_back("flametongue weapon");
spells.push_back("earthliving weapon");
spells.push_back("windfury weapon");
}
for (std::vector<std::string>::iterator i = spells.begin(); i != spells.end(); ++i)
{
uint32 spellId = AI_VALUE2(uint32, "spell id", spell);
if (!spellId)
continue;
if (AI_VALUE2(Item*, "item for spell", spellId))
return true;
}
return false;
}
*/
bool MainHandWeaponNoImbueTrigger::IsActive()
{
Item* const itemForSpell = bot->GetItemByPos(INVENTORY_SLOT_BAG_0, EQUIPMENT_SLOT_MAINHAND);
if (!itemForSpell || itemForSpell->GetEnchantmentId(TEMP_ENCHANTMENT_SLOT))
return false;
return true;
}
bool OffHandWeaponNoImbueTrigger::IsActive()
{
Item* const itemForSpell = bot->GetItemByPos(INVENTORY_SLOT_BAG_0, EQUIPMENT_SLOT_OFFHAND);
if (!itemForSpell || itemForSpell->GetEnchantmentId(TEMP_ENCHANTMENT_SLOT) ||
itemForSpell->GetTemplate()->InventoryType != INVTYPE_WEAPON)
return false;
return true;
}
bool ShockTrigger::IsActive()
{
return SpellTrigger::IsActive() && !botAI->HasAura("flame shock", GetTarget(), false, true) &&
!botAI->HasAura("frost shock", GetTarget(), false, true);
}
bool TotemTrigger::IsActive()
{
return AI_VALUE(uint8, "attacker count") >= attackerCount && !AI_VALUE2(bool, "has totem", name) &&
!botAI->HasAura(name, bot);
}
bool ManaSpringTotemTrigger::IsActive()
{
return AI_VALUE(uint8, "attacker count") >= attackerCount && !AI_VALUE2(bool, "has totem", "mana tide totem") &&
!AI_VALUE2(bool, "has totem", name);
}
bool WaterWalkingTrigger::IsActive() { return BuffTrigger::IsActive() && AI_VALUE2(bool, "swimming", "self target"); }
bool WaterBreathingTrigger::IsActive() { return BuffTrigger::IsActive() && AI_VALUE2(bool, "swimming", "self target"); }
bool WaterWalkingOnPartyTrigger::IsActive()
{
return BuffOnPartyTrigger::IsActive() && AI_VALUE2(bool, "swimming", "self target");
}
bool WaterBreathingOnPartyTrigger::IsActive()
{
return BuffOnPartyTrigger::IsActive() && AI_VALUE2(bool, "swimming", "self target");
}
bool NoFireTotemTrigger::IsActive()
{
return !AI_VALUE2(bool, "has totem", "magma totem") && !AI_VALUE2(bool, "has totem", "flametongue totem") &&
!AI_VALUE2(bool, "has totem", "searing totem") && !AI_VALUE2(bool, "has totem", "fire elemental totem") &&
!AI_VALUE2(bool, "has totem", "frost resistance totem") && !AI_VALUE2(bool, "has totem", "totem of wrath");
}
bool NoWaterTotemTrigger::IsActive()
{
return !AI_VALUE2(bool, "has totem", "fire resistance totem") && !AI_VALUE2(bool, "has totem", "mana tide totem") &&
!AI_VALUE2(bool, "has totem", "cleansing totem") && !AI_VALUE2(bool, "has totem", "mana spring totem") &&
!AI_VALUE2(bool, "has totem", "healing stream totem");
}
bool NoAirTotemTrigger::IsActive()
{
return !AI_VALUE2(bool, "has totem", "wrath of air totem") && !AI_VALUE2(bool, "has totem", "windfury totem");
}

320
src/strategy/shaman/ShamanTriggers.h
View File

@@ -1,320 +0,0 @@
/*
* 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_SHAMANTRIGGERS_H
#define _PLAYERBOT_SHAMANTRIGGERS_H
#include "CureTriggers.h"
#include "GenericTriggers.h"
#include "SharedDefines.h"
class PlayerbotAI;
/*
class ShamanWeaponTrigger : public BuffTrigger
{
public:
ShamanWeaponTrigger(PlayerbotAI* botAI) : BuffTrigger(botAI, "rockbiter weapon", 2 * 2000) { }
bool IsActive() override;
private:
static std::vector<std::string> spells;
};
*/
class MainHandWeaponNoImbueTrigger : public BuffTrigger
{
public:
MainHandWeaponNoImbueTrigger(PlayerbotAI* ai) : BuffTrigger(ai, "main hand", 1) {}
virtual bool IsActive();
};
class OffHandWeaponNoImbueTrigger : public BuffTrigger
{
public:
OffHandWeaponNoImbueTrigger(PlayerbotAI* ai) : BuffTrigger(ai, "off hand", 1) {}
virtual bool IsActive();
};
class TotemTrigger : public Trigger
{
public:
TotemTrigger(PlayerbotAI* botAI, std::string const spell, uint32 attackerCount = 0)
: Trigger(botAI, spell), attackerCount(attackerCount)
{
}
bool IsActive() override;
protected:
uint32 attackerCount;
};
class WindfuryTotemTrigger : public TotemTrigger
{
public:
WindfuryTotemTrigger(PlayerbotAI* botAI) : TotemTrigger(botAI, "windfury totem") {}
};
class GraceOfAirTotemTrigger : public TotemTrigger
{
public:
GraceOfAirTotemTrigger(PlayerbotAI* botAI) : TotemTrigger(botAI, "grace of air totem") {}
};
class ManaSpringTotemTrigger : public TotemTrigger
{
public:
ManaSpringTotemTrigger(PlayerbotAI* botAI) : TotemTrigger(botAI, "mana spring totem") {}
bool IsActive() override;
};
class FlametongueTotemTrigger : public TotemTrigger
{
public:
FlametongueTotemTrigger(PlayerbotAI* botAI) : TotemTrigger(botAI, "flametongue totem") {}
};
class StrengthOfEarthTotemTrigger : public TotemTrigger
{
public:
StrengthOfEarthTotemTrigger(PlayerbotAI* botAI) : TotemTrigger(botAI, "strength of earth totem") {}
};
class FireElementalTotemTrigger : public BoostTrigger
{
public:
FireElementalTotemTrigger(PlayerbotAI* botAI) : BoostTrigger(botAI, "fire elemental totem") {}
};
class MagmaTotemTrigger : public TotemTrigger
{
public:
MagmaTotemTrigger(PlayerbotAI* botAI) : TotemTrigger(botAI, "magma totem", 3) {}
};
class SearingTotemTrigger : public TotemTrigger
{
public:
SearingTotemTrigger(PlayerbotAI* botAI) : TotemTrigger(botAI, "searing totem", 1) {}
};
class WindShearInterruptSpellTrigger : public InterruptSpellTrigger
{
public:
WindShearInterruptSpellTrigger(PlayerbotAI* botAI) : InterruptSpellTrigger(botAI, "wind shear") {}
};
class WaterShieldTrigger : public BuffTrigger
{
public:
WaterShieldTrigger(PlayerbotAI* botAI) : BuffTrigger(botAI, "water shield") {}
};
class LightningShieldTrigger : public BuffTrigger
{
public:
LightningShieldTrigger(PlayerbotAI* botAI) : BuffTrigger(botAI, "lightning shield") {}
};
class PurgeTrigger : public TargetAuraDispelTrigger
{
public:
PurgeTrigger(PlayerbotAI* botAI) : TargetAuraDispelTrigger(botAI, "purge", DISPEL_MAGIC) {}
};
class WaterWalkingTrigger : public BuffTrigger
{
public:
WaterWalkingTrigger(PlayerbotAI* botAI) : BuffTrigger(botAI, "water walking", 7) {}
bool IsActive() override;
};
class WaterBreathingTrigger : public BuffTrigger
{
public:
WaterBreathingTrigger(PlayerbotAI* botAI) : BuffTrigger(botAI, "water breathing", 5 * 2000) {}
bool IsActive() override;
};
class WaterWalkingOnPartyTrigger : public BuffOnPartyTrigger
{
public:
WaterWalkingOnPartyTrigger(PlayerbotAI* botAI) : BuffOnPartyTrigger(botAI, "water walking on party", 2 * 2000) {}
bool IsActive() override;
};
class WaterBreathingOnPartyTrigger : public BuffOnPartyTrigger
{
public:
WaterBreathingOnPartyTrigger(PlayerbotAI* botAI) : BuffOnPartyTrigger(botAI, "water breathing on party", 2 * 2000)
{
}
bool IsActive() override;
};
class CleanseSpiritPoisonTrigger : public NeedCureTrigger
{
public:
CleanseSpiritPoisonTrigger(PlayerbotAI* botAI) : NeedCureTrigger(botAI, "cleanse spirit", DISPEL_POISON) {}
};
class PartyMemberCleanseSpiritPoisonTrigger : public PartyMemberNeedCureTrigger
{
public:
PartyMemberCleanseSpiritPoisonTrigger(PlayerbotAI* botAI)
: PartyMemberNeedCureTrigger(botAI, "cleanse spirit", DISPEL_POISON)
{
}
};
class CleanseSpiritCurseTrigger : public NeedCureTrigger
{
public:
CleanseSpiritCurseTrigger(PlayerbotAI* botAI) : NeedCureTrigger(botAI, "cleanse spirit", DISPEL_CURSE) {}
};
class PartyMemberCleanseSpiritCurseTrigger : public PartyMemberNeedCureTrigger
{
public:
PartyMemberCleanseSpiritCurseTrigger(PlayerbotAI* botAI)
: PartyMemberNeedCureTrigger(botAI, "cleanse spirit", DISPEL_CURSE)
{
}
};
class CleanseSpiritDiseaseTrigger : public NeedCureTrigger
{
public:
CleanseSpiritDiseaseTrigger(PlayerbotAI* botAI) : NeedCureTrigger(botAI, "cleanse spirit", DISPEL_DISEASE) {}
};
class PartyMemberCleanseSpiritDiseaseTrigger : public PartyMemberNeedCureTrigger
{
public:
PartyMemberCleanseSpiritDiseaseTrigger(PlayerbotAI* botAI)
: PartyMemberNeedCureTrigger(botAI, "cleanse spirit", DISPEL_DISEASE)
{
}
};
class ShockTrigger : public DebuffTrigger
{
public:
ShockTrigger(PlayerbotAI* botAI) : DebuffTrigger(botAI, "earth shock", 1, true) {}
bool IsActive() override;
};
class FrostShockSnareTrigger : public SnareTargetTrigger
{
public:
FrostShockSnareTrigger(PlayerbotAI* botAI) : SnareTargetTrigger(botAI, "frost shock") {}
};
class HeroismTrigger : public BoostTrigger
{
public:
HeroismTrigger(PlayerbotAI* botAI) : BoostTrigger(botAI, "heroism") {}
};
class BloodlustTrigger : public BoostTrigger
{
public:
BloodlustTrigger(PlayerbotAI* botAI) : BoostTrigger(botAI, "bloodlust") {}
};
class ElementalMasteryTrigger : public BoostTrigger
{
public:
ElementalMasteryTrigger(PlayerbotAI* botAI) : BoostTrigger(botAI, "elemental mastery") {}
};
class MaelstromWeaponTrigger : public HasAuraStackTrigger
{
public:
MaelstromWeaponTrigger(PlayerbotAI* botAI, int stack = 5) : HasAuraStackTrigger(botAI, "maelstrom weapon", stack) {}
};
class WindShearInterruptEnemyHealerSpellTrigger : public InterruptEnemyHealerTrigger
{
public:
WindShearInterruptEnemyHealerSpellTrigger(PlayerbotAI* botAI) : InterruptEnemyHealerTrigger(botAI, "wind shear") {}
};
class CurePoisonTrigger : public NeedCureTrigger
{
public:
CurePoisonTrigger(PlayerbotAI* botAI) : NeedCureTrigger(botAI, "cure poison", DISPEL_POISON) {}
};
class PartyMemberCurePoisonTrigger : public PartyMemberNeedCureTrigger
{
public:
PartyMemberCurePoisonTrigger(PlayerbotAI* botAI) : PartyMemberNeedCureTrigger(botAI, "cure poison", DISPEL_POISON)
{
}
};
class CureDiseaseTrigger : public NeedCureTrigger
{
public:
CureDiseaseTrigger(PlayerbotAI* botAI) : NeedCureTrigger(botAI, "cure disease", DISPEL_DISEASE) {}
};
class PartyMemberCureDiseaseTrigger : public PartyMemberNeedCureTrigger
{
public:
PartyMemberCureDiseaseTrigger(PlayerbotAI* botAI)
: PartyMemberNeedCureTrigger(botAI, "cure disease", DISPEL_DISEASE)
{
}
};
class NoFireTotemTrigger : public Trigger
{
public:
NoFireTotemTrigger(PlayerbotAI* ai) : Trigger(ai, "no fire totem") {}
bool IsActive() override;
};
class NoWaterTotemTrigger : public Trigger
{
public:
NoWaterTotemTrigger(PlayerbotAI* ai) : Trigger(ai, "no water totem") {}
bool IsActive() override;
};
class EarthShieldOnMainTankTrigger : public BuffOnMainTankTrigger
{
public:
EarthShieldOnMainTankTrigger(PlayerbotAI* botAI) : BuffOnMainTankTrigger(botAI, "earth shield", false) {}
};
class FlameShockTrigger : public DebuffTrigger
{
public:
FlameShockTrigger(PlayerbotAI* ai) : DebuffTrigger(ai, "flame shock", 1, true) {}
};
class WrathOfAirTotemTrigger : public TotemTrigger
{
public:
WrathOfAirTotemTrigger(PlayerbotAI* ai) : TotemTrigger(ai, "wrath of air totem") {}
};
class NoAirTotemTrigger : public TotemTrigger
{
public:
NoAirTotemTrigger(PlayerbotAI* ai) : TotemTrigger(ai, "no air totem") {}
bool IsActive() override;
};
#endif

25
src/strategy/shaman/TotemsShamanStrategy.cpp
View File

@@ -1,25 +0,0 @@
/*
* 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 "TotemsShamanStrategy.h"
#include "Playerbots.h"
TotemsShamanStrategy::TotemsShamanStrategy(PlayerbotAI* botAI) : GenericShamanStrategy(botAI) {}
void TotemsShamanStrategy::InitTriggers(std::vector<TriggerNode*>& triggers)
{
GenericShamanStrategy::InitTriggers(triggers);
triggers.push_back(
new TriggerNode("no air totem", NextAction::array(0, new NextAction("wrath of air totem", 8.0f), nullptr)));
triggers.push_back(
new TriggerNode("no water totem", NextAction::array(0, new NextAction("mana spring totem", 7.0f),
new NextAction("healing stream totem", 6.0f), nullptr)));
triggers.push_back(new TriggerNode("strength of earth totem",
NextAction::array(0, new NextAction("strength of earth totem", 6.0f), nullptr)));
}

22
src/strategy/shaman/TotemsShamanStrategy.h
View File

@@ -1,22 +0,0 @@
/*
* 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_TOTEMSSHAMANSTRATEGY_H
#define _PLAYERBOT_TOTEMSSHAMANSTRATEGY_H
#include "GenericShamanStrategy.h"
class PlayerbotAI;
class TotemsShamanStrategy : public GenericShamanStrategy
{
public:
TotemsShamanStrategy(PlayerbotAI* botAI);
void InitTriggers(std::vector<TriggerNode*>& triggers) override;
std::string const getName() override { return "totems"; }
};
#endif