yolinlin/mod-playerbots
1
0
Fork 0
mirror of https://github.com/mod-playerbots/mod-playerbots synced 2025-11-29 15:58:20 +08:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #180 from liyunfan1223/perf

Browse Source 
Performance optimization
This commit is contained in:
Yunfan Li
2024-04-12 15:14:13 +08:00
committed by GitHub
parent 839257cd1e c8c33f01aa
commit 69ecee0efe
13 changed files with 238 additions and 97 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
conf/playerbots.conf.dist
View File

@@ -256,6 +256,10 @@ AiPlayerbot.GlobalCooldown = 500
# Max wait time when moving
AiPlayerbot.MaxWaitForMove = 5000
# Max search time for movement (higher for better movement on slopes)
# default: 3
AiPlayerbot.MaxMovementSearchTime = 3
# Action expiration time
AiPlayerbot.ExpireActionTime = 5000

2
src/PlayerbotAI.cpp
View File

@@ -1993,7 +1993,7 @@ bool PlayerbotAI::HasAura(std::string const name, Unit* unit, bool maxStack, boo
{
SpellInfo const* spellInfo = aurEff->GetSpellInfo();
std::string const auraName = spellInfo->SpellName[0];
std::string_view const auraName = spellInfo->SpellName[0];
if (auraName.empty() || auraName.length() != wnamepart.length() || !Utf8FitTo(auraName, wnamepart))
continue;

1
src/PlayerbotAIConfig.cpp
View File

@@ -53,6 +53,7 @@ bool PlayerbotAIConfig::Initialize()
globalCoolDown = sConfigMgr->GetOption<int32>("AiPlayerbot.GlobalCooldown", 1500);
maxWaitForMove = sConfigMgr->GetOption<int32>("AiPlayerbot.MaxWaitForMove", 5000);
maxMovementSearchTime = sConfigMgr->GetOption<int32>("AiPlayerbot.MaxMovementSearchTime", 3);
expireActionTime = sConfigMgr->GetOption<int32>("AiPlayerbot.ExpireActionTime", 5000);
dispelAuraDuration = sConfigMgr->GetOption<int32>("AiPlayerbot.DispelAuraDuration", 7000);
reactDelay = sConfigMgr->GetOption<int32>("AiPlayerbot.ReactDelay", 500);

3
src/PlayerbotAIConfig.h
View File

@@ -54,7 +54,8 @@ class PlayerbotAIConfig
bool enabled;
bool allowGuildBots, allowPlayerBots;
uint32 globalCoolDown, reactDelay, maxWaitForMove, expireActionTime, dispelAuraDuration, passiveDelay, repeatDelay,
uint32 globalCoolDown, reactDelay, maxWaitForMove, maxMovementSearchTime, expireActionTime,
dispelAuraDuration, passiveDelay, repeatDelay,
errorDelay, rpgDelay, sitDelay, returnDelay, lootDelay;
float sightDistance, spellDistance, reactDistance, grindDistance, lootDistance, shootDistance,
fleeDistance, tooCloseDistance, meleeDistance, followDistance, whisperDistance, contactDistance,

16
src/PlayerbotFactory.cpp
View File

@@ -605,7 +605,7 @@ void PlayerbotFactory::InitPetTalents()
return;
}
pet->resetTalents();
std::map<uint32, std::vector<TalentEntry const*> > spells;
std::unordered_map<uint32, std::vector<TalentEntry const*> > spells;
for (uint32 i = 0; i < sTalentStore.GetNumRows(); ++i)
{
TalentEntry const *talentInfo = sTalentStore.LookupEntry(i);
@@ -625,7 +625,7 @@ void PlayerbotFactory::InitPetTalents()
uint32 maxTalentPoints = pet->GetMaxTalentPointsForLevel(pet->GetLevel());
int row = 0;
// LOG_INFO("playerbots", "{} learning, max talent points: {}, cur: {}", bot->GetName().c_str(), maxTalentPoints, curTalentPoints);
for (std::map<uint32, std::vector<TalentEntry const*> >::iterator i = spells.begin(); i != spells.end(); ++i, ++row)
for (auto i = spells.begin(); i != spells.end(); ++i, ++row)
{
std::vector<TalentEntry const*> &spells_row = i->second;
if (spells_row.empty())
@@ -893,7 +893,7 @@ void PlayerbotFactory::InitTalentsBySpecNo(Player* bot, int specNo, bool reset)
uint32 cls = bot->getClass();
int startLevel = bot->GetLevel();
uint32 classMask = bot->getClassMask();
std::map<uint32, std::vector<TalentEntry const*> > spells_row;
std::unordered_map<uint32, std::vector<TalentEntry const*> > spells_row;
for (uint32 i = 0; i < sTalentStore.GetNumRows(); ++i)
{
TalentEntry const *talentInfo = sTalentStore.LookupEntry(i);
@@ -954,7 +954,7 @@ void PlayerbotFactory::InitTalentsByParsedSpecLink(Player* bot, std::vector<std:
bot->resetTalents(true);
}
uint32 classMask = bot->getClassMask();
std::map<uint32, std::vector<TalentEntry const*> > spells_row;
std::unordered_map<uint32, std::vector<TalentEntry const*> > spells_row;
for (uint32 i = 0; i < sTalentStore.GetNumRows(); ++i)
{
TalentEntry const *talentInfo = sTalentStore.LookupEntry(i);
@@ -2248,7 +2248,7 @@ void PlayerbotFactory::InitSpecialSpells()
void PlayerbotFactory::InitTalents(uint32 specNo)
{
uint32 classMask = bot->getClassMask();
std::map<uint32, std::vector<TalentEntry const*> > spells;
std::unordered_map<uint32, std::vector<TalentEntry const*> > spells;
for (uint32 i = 0; i < sTalentStore.GetNumRows(); ++i)
{
TalentEntry const *talentInfo = sTalentStore.LookupEntry(i);
@@ -2266,7 +2266,7 @@ void PlayerbotFactory::InitTalents(uint32 specNo)
}
uint32 freePoints = bot->GetFreeTalentPoints();
for (std::map<uint32, std::vector<TalentEntry const*> >::iterator i = spells.begin(); i != spells.end(); ++i)
for (auto i = spells.begin(); i != spells.end(); ++i)
{
std::vector<TalentEntry const*> &spells_row = i->second;
if (spells_row.empty())
@@ -2308,7 +2308,7 @@ void PlayerbotFactory::InitTalentsByTemplate(uint32 specTab)
int startLevel = bot->GetLevel();
uint32 specIndex = sPlayerbotAIConfig->randomClassSpecIndex[cls][specTab];
uint32 classMask = bot->getClassMask();
std::map<uint32, std::vector<TalentEntry const*> > spells_row;
std::unordered_map<uint32, std::vector<TalentEntry const*> > spells_row;
for (uint32 i = 0; i < sTalentStore.GetNumRows(); ++i)
{
TalentEntry const *talentInfo = sTalentStore.LookupEntry(i);
@@ -2648,7 +2648,7 @@ void PlayerbotFactory::InitFood()
if (sPlayerbotAIConfig->freeFood) {
return;
}
std::map<uint32, std::vector<uint32> > items;
std::unordered_map<uint32, std::vector<uint32> > items;
ItemTemplateContainer const* itemTemplateContainer = sObjectMgr->GetItemTemplateStore();
for (ItemTemplateContainer::const_iterator i = itemTemplateContainer->begin(); i != itemTemplateContainer->end(); ++i)
{

4
src/PlayerbotMgr.cpp
View File

@@ -900,7 +900,7 @@ std::vector<std::string> PlayerbotHolder::HandlePlayerbotCommand(char const* arg
std::string const cmdStr = cmd;
std::set<std::string> bots;
std::unordered_set<std::string> bots;
if (charnameStr == "*" && master)
{
Group* group = master->GetGroup();
@@ -958,7 +958,7 @@ std::vector<std::string> PlayerbotHolder::HandlePlayerbotCommand(char const* arg
}
}
for (std::set<std::string>::iterator i = bots.begin(); i != bots.end(); ++i)
for (auto i = bots.begin(); i != bots.end(); ++i)
{
std::string const bot = *i;

19
src/strategy/NamedObjectContext.h
View File

@@ -7,8 +7,9 @@
#include "Common.h"
#include <map>
#include <unordered_map>
#include <set>
#include <unordered_set>
#include <list>
#include <vector>
@@ -46,7 +47,7 @@ class NamedObjectFactory
{
protected:
typedef T*(*ActionCreator)(PlayerbotAI* botAI);
std::map<std::string, ActionCreator> creators;
std::unordered_map<std::string, ActionCreator> creators;
public:
T* create(std::string name, PlayerbotAI* botAI)
@@ -77,7 +78,7 @@ class NamedObjectFactory
std::set<std::string> supports()
{
std::set<std::string> keys;
for (typename std::map<std::string, ActionCreator>::iterator it = creators.begin(); it != creators.end(); it++)
for (typename std::unordered_map<std::string, ActionCreator>::iterator it = creators.begin(); it != creators.end(); it++)
keys.insert(it->first);
return keys;
@@ -106,7 +107,7 @@ class NamedObjectContext : public NamedObjectFactory<T>
void Clear()
{
for (typename std::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;
@@ -117,7 +118,7 @@ class NamedObjectContext : public NamedObjectFactory<T>
void Update()
{
for (typename std::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)
i->second->Update();
@@ -126,7 +127,7 @@ class NamedObjectContext : public NamedObjectFactory<T>
void Reset()
{
for (typename std::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)
i->second->Reset();
@@ -139,14 +140,14 @@ class NamedObjectContext : public NamedObjectFactory<T>
std::set<std::string> GetCreated()
{
std::set<std::string> keys;
for (typename std::map<std::string, T*>::iterator it = created.begin(); it != created.end(); it++)
for (typename std::unordered_map<std::string, T*>::iterator it = created.begin(); it != created.end(); it++)
keys.insert(it->first);
return keys;
}
protected:
std::map<std::string, T*> created;
std::unordered_map<std::string, T*> created;
bool shared;
bool supportsSiblings;
};
@@ -264,7 +265,7 @@ class NamedObjectFactoryList
factories.push_front(context);
}
T* GetContextObject(std::string const name, PlayerbotAI* botAI)
T* GetContextObject(std::string const &name, PlayerbotAI* botAI)
{
for (typename std::list<NamedObjectFactory<T>*>::iterator i = factories.begin(); i != factories.end(); i++)
{

195
src/strategy/actions/MovementActions.cpp
View File

@@ -3,7 +3,9 @@
*/
#include "MovementActions.h"
#include "Map.h"
#include "MotionMaster.h"
#include "MoveSplineInitArgs.h"
#include "MovementGenerator.h"
#include "ObjectDefines.h"
#include "ObjectGuid.h"
@@ -151,13 +153,8 @@ bool MovementAction::MoveTo(uint32 mapId, float x, float y, float z, bool idle,
// }
bool generatePath = !bot->HasAuraType(SPELL_AURA_MOD_INCREASE_MOUNTED_FLIGHT_SPEED) &&
!bot->IsFlying() && !bot->HasUnitMovementFlag(MOVEMENTFLAG_SWIMMING) && !bot->IsInWater();
float modifiedZ = SearchBestGroundZForPath(x, y, z, generatePath, 20.0f, normal_only, 8.0f);
if (modifiedZ == INVALID_HEIGHT) {
return false;
}
float distance = bot->GetExactDist(x, y, modifiedZ);
if (distance > sPlayerbotAIConfig->contactDistance)
{
if (!generatePath) {
float distance = bot->GetExactDist(x, y, z);
WaitForReach(distance);
if (bot->IsSitState())
@@ -171,9 +168,36 @@ bool MovementAction::MoveTo(uint32 mapId, float x, float y, float z, bool idle,
MotionMaster &mm = *bot->GetMotionMaster();
mm.Clear();
mm.MovePoint(mapId, x, y, modifiedZ, generatePath);
mm.MovePoint(mapId, x, y, z, generatePath);
AI_VALUE(LastMovement&, "last movement").Set(mapId, x, y, z, bot->GetOrientation());
return true;
} else {
float modifiedZ;
Movement::PointsArray path = SearchForBestPath(x, y, z, modifiedZ, sPlayerbotAIConfig->maxMovementSearchTime);
if (modifiedZ == INVALID_HEIGHT) {
return false;
}
float distance = bot->GetExactDist(x, y, modifiedZ);
if (distance > sPlayerbotAIConfig->contactDistance)
{
WaitForReach(distance);
if (bot->IsSitState())
bot->SetStandState(UNIT_STAND_STATE_STAND);
if (bot->IsNonMeleeSpellCast(true))
{
bot->CastStop();
botAI->InterruptSpell();
}
MotionMaster &mm = *bot->GetMotionMaster();
mm.Clear();
mm.MoveSplinePath(&path);
AI_VALUE(LastMovement&, "last movement").Set(mapId, x, y, z, bot->GetOrientation());
return true;
}
}
return false;
@@ -1324,60 +1348,109 @@ bool MovementAction::MoveInside(uint32 mapId, float x, float y, float z, float d
return MoveNear(mapId, x, y, z, distance);
}
float MovementAction::SearchBestGroundZForPath(float x, float y, float z, bool generatePath, float range, bool normal_only, float step)
{
if (!generatePath) {
return z;
}
float min_length = 100000.0f;
float current_z = INVALID_HEIGHT;
float modified_z;
float delta;
for (delta = 0.0f; delta <= range / 2; delta += step) {
modified_z = bot->GetMapWaterOrGroundLevel(x, y, z + delta);
PathGenerator gen(bot);
gen.CalculatePath(x, y, modified_z);
if (gen.GetPathType() == PATHFIND_NORMAL && gen.getPathLength() < min_length) {
min_length = gen.getPathLength();
current_z = modified_z;
if (abs(current_z - z) < 0.5f) {
return current_z;
}
}
}
for (delta = -step; delta >= -range / 2; delta -= step) {
modified_z = bot->GetMapWaterOrGroundLevel(x, y, z + delta);
PathGenerator gen(bot);
gen.CalculatePath(x, y, modified_z);
if (gen.GetPathType() == PATHFIND_NORMAL && gen.getPathLength() < min_length) {
min_length = gen.getPathLength();
current_z = modified_z;
if (abs(current_z - z) < 0.5f) {
return current_z;
}
}
}
for (delta = range / 2 + step; delta <= range; delta += 2) {
modified_z = bot->GetMapWaterOrGroundLevel(x, y, z + delta);
PathGenerator gen(bot);
gen.CalculatePath(x, y, modified_z);
if (gen.GetPathType() == PATHFIND_NORMAL && gen.getPathLength() < min_length) {
min_length = gen.getPathLength();
current_z = modified_z;
if (abs(current_z - z) < 0.5f) {
return current_z;
}
}
}
if (current_z == INVALID_HEIGHT && normal_only) {
return INVALID_HEIGHT;
}
if (current_z == INVALID_HEIGHT && !normal_only) {
return z;
}
return current_z;
}
// float MovementAction::SearchBestGroundZForPath(float x, float y, float z, bool generatePath, float range, bool normal_only, float step)
// {
// if (!generatePath) {
// return z;
// }
// float min_length = 100000.0f;
// float current_z = INVALID_HEIGHT;
// float modified_z;
// float delta;
// for (delta = 0.0f; delta <= range / 2; delta += step) {
// modified_z = bot->GetMapWaterOrGroundLevel(x, y, z + delta);
// PathGenerator gen(bot);
// gen.CalculatePath(x, y, modified_z);
// if (gen.GetPathType() == PATHFIND_NORMAL && gen.getPathLength() < min_length) {
// min_length = gen.getPathLength();
// current_z = modified_z;
// if (abs(current_z - z) < 0.5f) {
// return current_z;
// }
// }
// }
// for (delta = -step; delta >= -range / 2; delta -= step) {
// modified_z = bot->GetMapWaterOrGroundLevel(x, y, z + delta);
// PathGenerator gen(bot);
// gen.CalculatePath(x, y, modified_z);
// if (gen.GetPathType() == PATHFIND_NORMAL && gen.getPathLength() < min_length) {
// min_length = gen.getPathLength();
// current_z = modified_z;
// if (abs(current_z - z) < 0.5f) {
// return current_z;
// }
// }
// }
// for (delta = range / 2 + step; delta <= range; delta += 2) {
// modified_z = bot->GetMapWaterOrGroundLevel(x, y, z + delta);
// PathGenerator gen(bot);
// gen.CalculatePath(x, y, modified_z);
// if (gen.GetPathType() == PATHFIND_NORMAL && gen.getPathLength() < min_length) {
// min_length = gen.getPathLength();
// current_z = modified_z;
// if (abs(current_z - z) < 0.5f) {
// return current_z;
// }
// }
// }
// if (current_z == INVALID_HEIGHT && normal_only) {
// return INVALID_HEIGHT;
// }
// if (current_z == INVALID_HEIGHT && !normal_only) {
// return z;
// }
// return current_z;
// }
const Movement::PointsArray MovementAction::SearchForBestPath(float x, float y, float z, float &modified_z, int maxSearchCount, bool normal_only, float step)
{
bool found = false;
modified_z = INVALID_HEIGHT;
float tempZ = bot->GetMapWaterOrGroundLevel(x, y, z);
PathGenerator gen(bot);
gen.CalculatePath(x, y, tempZ);
Movement::PointsArray result = gen.GetPath();
float min_length = gen.getPathLength();
if (gen.GetPathType() == PATHFIND_NORMAL && abs(tempZ - z) < 0.5f) {
modified_z = tempZ;
return result;
}
// Start searching
if (gen.GetPathType() == PATHFIND_NORMAL) {
found = true;
modified_z = tempZ;
}
int count = 1;
for (float delta = step; count < maxSearchCount / 2 + 1; count++, delta += step) {
tempZ = bot->GetMapWaterOrGroundLevel(x, y, z + delta);
PathGenerator gen(bot);
gen.CalculatePath(x, y, tempZ);
if (gen.GetPathType() == PATHFIND_NORMAL && gen.getPathLength() < min_length) {
found = true;
min_length = gen.getPathLength();
result = gen.GetPath();
modified_z = tempZ;
}
}
for (float delta = -step; count < maxSearchCount; count++, delta -= step) {
tempZ = bot->GetMapWaterOrGroundLevel(x, y, z + delta);
PathGenerator gen(bot);
gen.CalculatePath(x, y, tempZ);
if (gen.GetPathType() == PATHFIND_NORMAL && gen.getPathLength() < min_length) {
found = true;
min_length = gen.getPathLength();
result = gen.GetPath();
modified_z = tempZ;
}
}
if (!found && normal_only) {
return Movement::PointsArray{};
}
if (!found && !normal_only) {
return result;
}
return result;
}
bool FleeAction::Execute(Event event)
{

3
src/strategy/actions/MovementActions.h
View File

@@ -42,7 +42,8 @@ class MovementAction : public Action
bool MoveInside(uint32 mapId, float x, float y, float z, float distance = sPlayerbotAIConfig->followDistance);
void CreateWp(Player* wpOwner, float x, float y, float z, float o, uint32 entry, bool important = false);
private:
float SearchBestGroundZForPath(float x, float y, float z, bool generatePath, float range = 20.0f, bool normal_only = false, float step = 8.0f);
// float SearchBestGroundZForPath(float x, float y, float z, bool generatePath, float range = 20.0f, bool normal_only = false, float step = 8.0f);
const Movement::PointsArray SearchForBestPath(float x, float y, float z, float &modified_z, int maxSearchCount = 5, bool normal_only = false, float step = 8.0f);
};
class FleeAction : public MovementAction

63
src/strategy/values/HasTotemValue.cpp
View File

@@ -9,24 +9,59 @@ char* strstri(char const* str1, char const* str2);
bool HasTotemValue::Calculate()
{
GuidVector units = *context->GetValue<GuidVector>("nearest npcs");
for (ObjectGuid const guid : units)
for (uint8 i = 0; i < MAX_SUMMON_SLOT; ++i)
{
Unit* unit = botAI->GetUnit(guid);
if (!unit)
continue;
Creature* creature = dynamic_cast<Creature*>(unit);
if (!creature || !creature->IsTotem())
continue;
if (creature->GetOwner() != bot) {
if (!bot->m_SummonSlot[i])
{
continue;
}
if (strstri(creature->GetName().c_str(), qualifier.c_str()) && bot->GetDistance(creature) <= botAI->GetRange("spell"))
return true;
if (Creature* OldTotem = bot->GetMap()->GetCreature(bot->m_SummonSlot[i]))
{
if (OldTotem->IsSummon() && OldTotem->GetDistance(bot) <= 30.0f)
{
if (strstri(OldTotem->GetName().c_str(), qualifier.c_str()))
return true;
}
}
}
return false;
}
// bool HasTotemValue::Calculate()
// {
// for (uint8 i = 0; i < MAX_SUMMON_SLOT; ++i)
// {
// if (!bot->m_SummonSlot[i])
// {
// continue;
// }
// if (Creature* OldTotem = bot->GetMap()->GetCreature(bot->m_SummonSlot[i]))
// {
// if (OldTotem->IsSummon())
// {
// if (strstri(creature->GetName().c_str(), qualifier.c_str()))
// return true;
// }
// }
// }
// GuidVector units = *context->GetValue<GuidVector>("nearest totems");
// for (ObjectGuid const guid : units)
// {
// Unit* unit = botAI->GetUnit(guid);
// if (!unit)
// continue;
// Creature* creature = dynamic_cast<Creature*>(unit);
// if (creature->GetOwner() != bot) {
// continue;
// }
// if (strstri(creature->GetName().c_str(), qualifier.c_str()))
// return true;
// }
// return false;
// }

12
src/strategy/values/NearestNpcsValue.cpp
View File

@@ -50,4 +50,16 @@ void NearestTriggersValue::FindUnits(std::list<Unit*>& targets)
bool NearestTriggersValue::AcceptUnit(Unit* unit)
{
return !unit->IsPlayer();
}
void NearestTotemsValue::FindUnits(std::list<Unit*>& targets)
{
Acore::AnyUnitInObjectRangeCheck u_check(bot, range);
Acore::UnitListSearcher<Acore::AnyUnitInObjectRangeCheck> searcher(bot, targets, u_check);
Cell::VisitAllObjects(bot, searcher, range);
}
bool NearestTotemsValue::AcceptUnit(Unit* unit)
{
return unit->IsTotem();
}

11
src/strategy/values/NearestNpcsValue.h
View File

@@ -39,4 +39,15 @@ class NearestTriggersValue : public NearestUnitsValue
void FindUnits(std::list<Unit*>& targets) override;
bool AcceptUnit(Unit* unit) override;
};
class NearestTotemsValue : public NearestUnitsValue
{
public:
NearestTotemsValue(PlayerbotAI* botAI, float range = 30.0f) : NearestUnitsValue(botAI, "nearest npcs", range, true) { }
protected:
void FindUnits(std::list<Unit*>& targets) override;
bool AcceptUnit(Unit* unit) override;
};
#endif

2
src/strategy/values/ValueContext.h
View File

@@ -103,6 +103,7 @@ class ValueContext : public NamedObjectContext<UntypedValue>
creators["nearest game objects no los"] = &ValueContext::nearest_game_objects_no_los;
creators["closest game objects"] = &ValueContext::closest_game_objects;
creators["nearest npcs"] = &ValueContext::nearest_npcs;
creators["nearest totems"] = &ValueContext::nearest_totems;
creators["nearest vehicles"] = &ValueContext::nearest_vehicles;
creators["nearest friendly players"] = &ValueContext::nearest_friendly_players;
creators["closest friendly players"] = &ValueContext::closest_friendly_players;
@@ -367,6 +368,7 @@ class ValueContext : public NamedObjectContext<UntypedValue>
static UntypedValue* closest_game_objects(PlayerbotAI* botAI) { return new NearestGameObjects(botAI, INTERACTION_DISTANCE); }
static UntypedValue* log_level(PlayerbotAI* botAI) { return new LogLevelValue(botAI); }
static UntypedValue* nearest_npcs(PlayerbotAI* botAI) { return new NearestNpcsValue(botAI); }
static UntypedValue* nearest_totems(PlayerbotAI* botAI) { return new NearestTotemsValue(botAI); }
static UntypedValue* nearest_vehicles(PlayerbotAI* botAI) { return new NearestVehiclesValue(botAI); }
static UntypedValue* nearest_friendly_players(PlayerbotAI* botAI) { return new NearestFriendlyPlayersValue(botAI); }
static UntypedValue* closest_friendly_players(PlayerbotAI* botAI) { return new NearestFriendlyPlayersValue(botAI, INTERACTION_DISTANCE); }