# AIBaseClient

# Description

The AIBaseClient class provides functionality related to AI units, including behavior control, status retrieval, and operations of AI units. This class inherits from the GameObject class and is used to control and retrieve various properties and behaviors of AI units in the game.

# How to Use

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient) {
    bool isMoving = aiClient->IsMoving();
    // Use the AI client for other operations
}

# ActionState

eGameObjectActionState ActionState()

Gets the current action state of the AI unit.

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient) {
    eGameObjectActionState state = aiClient->ActionState();
    // Use the action state for decision making
}

# AllShield

float AllShield()

Gets the total shield value of the AI unit.

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient) {
    float totalShield = aiClient->AllShield();
    // Process shield information
}

# Armor

float Armor()

Gets the armor value of the current AI unit.

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient) {
    float armor = aiClient->Armor();
    // Use armor value for calculations
}

# AttackCastDelay

float AttackCastDelay()

Gets the attack cast delay of the current AI unit.

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient) {
    float castDelay = aiClient->AttackCastDelay();
    // Use attack cast delay for calculations
}

# AttackDelay

float AttackDelay()

Gets the attack delay of the current AI unit.

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient) {
    float delay = aiClient->AttackDelay();
    // Use attack delay for calculations
}

# AttackRange

float AttackRange()

Gets the attack range of the current AI unit.

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient) {
    float atkRange = aiClient->AttackRange();
    // Use attack range for decision making
}

# AttackSpeedMod

float AttackSpeedMod()

Gets the attack speed modifier of the current AI unit.

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient) {
    float atkSpeedMod = aiClient->AttackSpeedMod();
    // Use attack speed modifier for calculations
}

# BaseAttackDamage

float BaseAttackDamage()

Gets the base attack damage of the current AI unit.

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient) {
    float baseAD = aiClient->BaseAttackDamage();
    // Use base attack damage for calculations
}

# BasicAttack

SpellData* BasicAttack()

Gets the basic attack data of the current AI unit.

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient) {
    SpellData* basicAttack = aiClient->BasicAttack();
    // Process basic attack data
}

# Buffs

std::vector<BuffInstance*>const& Buffs()

Gets all buffs of the current AI unit.

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient) {
    auto& buffs = aiClient->Buffs();
    for (auto buff : buffs) {
        // Process each buff
    }
}

# BuyItem

void BuyItem(int ItemID)

Purchases an item with the specified ID.

Parameter	Type	Description
ItemID	int	Item ID

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient) {
    // Buy a Long Sword
    aiClient->BuyItem(1036);
}

# CalcDamage

double CalcDamage(AIBaseClient* target, eDamageType damageType, double amount)

Calculates the damage that would be dealt to the target.

Parameter	Type	Description
target	AIBaseClient*	Target unit
damageType	eDamageType	Damage type
amount	double	Base damage amount

AIBaseClient* aiClient = GetAIBaseClient();
AIBaseClient* target = GetTargetUnit();
if (aiClient && target) {
    double damage = aiClient->CalcDamage(target, eDamageType::Physical, 100.0);
    // Use the calculated damage for decision making
}

# CanAttack

bool CanAttack()

Determines whether the current AI unit can attack.

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient && aiClient->CanAttack()) {
    // Unit can attack
}

# CanCast

bool CanCast()

Determines whether the current AI unit can cast spells.

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient && aiClient->CanCast()) {
    // Unit can cast spells
}

# CanMove

bool CanMove()

Determines whether the current AI unit can move.

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient && aiClient->CanMove()) {
    // Unit can move
}

# CanSelect

bool CanSelect()

Determines whether the current AI unit can be selected.

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient && aiClient->CanSelect()) {
    // Unit can be selected
}

# ChampionName

const char* ChampionName()

Gets the champion name of the AI unit.

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient) {
    const char* name = aiClient->ChampionName();
    // Process the champion name
}

# ChangeSkin

void ChangeSkin(const char* model, std::uint32_t skin)

Changes the skin of the AI unit.

Parameter	Type	Description
model	const char*	Model name
skin	std::uint32_t	Skin ID

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient) {
    // Change to skin ID 5
    aiClient->ChangeSkin(aiClient->ChampionName(), 5);
}

# Crit

float Crit()

Gets the critical strike chance of the current AI unit.

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient) {
    float critChance = aiClient->Crit();
    // Use critical strike chance for calculations
}

# CritDamageMultiplier

float CritDamageMultiplier()

Gets the critical damage multiplier of the current AI unit.

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient) {
    float critMult = aiClient->CritDamageMultiplier();
    // Use critical damage multiplier for calculations
}

# DashSpeed

float DashSpeed()

Gets the dash speed of the AI unit.

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient && aiClient->IsDashing()) {
    float speed = aiClient->DashSpeed();
    // Use dash speed information
}

# Direction

Vector const& Direction()

Gets the facing direction of the current AI unit.

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient) {
    Vector dir = aiClient->Direction();
    // Use direction for calculations
}

# Distance

float Distance(AIBaseClient* anotherUnit, bool squared = false)

Calculates the distance between the current AI unit and another unit.

Parameter	Type	Description
anotherUnit	AIBaseClient*	Another unit
squared	bool	Whether to return squared distance, default is false

AIBaseClient* aiClient = GetAIBaseClient();
AIBaseClient* target = GetTargetUnit();
if (aiClient && target) {
    float dist = aiClient->Distance(target);
    if (dist < 500.0f) {
        // Execute operation when distance is less than 500
    }
}

# Distance

float Distance(const Vector& point, bool squared = false)

Calculates the distance between the current AI unit and a specified position.

Parameter	Type	Description
point	Vector	Target position
squared	bool	Whether to return squared distance, default is false

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient) {
    Vector targetPos(100.0f, 0.0f, 200.0f);
    float dist = aiClient->Distance(targetPos);
    if (dist < 500.0f) {
        // Execute operation when distance is less than 500
    }
}

# FindItem

InventoryItem* FindItem(int itemId)

Finds an item based on the item ID.

Parameter	Type	Description
itemId	int	Item ID

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient) {
    // Find item with ID 3157 (Zhonya's Hourglass)
    InventoryItem* zhonya = aiClient->FindItem(3157);
    if (zhonya) {
        // Item exists, process it
    }
}

# FlatArmorMod

float FlatArmorMod()

Gets the additional armor value of the current AI unit.

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient) {
    float bonusArmor = aiClient->FlatArmorMod();
    // Use additional armor value for calculations
}

# FlatSpellBlockMod

float FlatSpellBlockMod()

Gets the additional magic resistance of the current AI unit.

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient) {
    float bonusMR = aiClient->FlatSpellBlockMod();
    // Use additional magic resistance for calculations
}

# GetAutoAttackDamage

double GetAutoAttackDamage(AIBaseClient* target, bool includePassive = false)

Calculates the damage of a normal attack to the target.

Parameter	Type	Description
target	AIBaseClient*	Target unit
includePassive	bool	Whether to include passive effects, default is false

AIBaseClient* aiClient = GetAIBaseClient();
AIBaseClient* target = GetTargetUnit();
if (aiClient && target) {
    double aaDamage = aiClient->GetAutoAttackDamage(target, true);
    // Use the calculated normal attack damage for decision making
}

# GetBuff

BuffInstance* GetBuff(std::uint32_t buffNameHash)

Gets a specific Buff instance based on the Buff name's hash value.

Parameter	Type	Description
buffNameHash	std::uint32_t	Buff name's hash value

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient) {
    BuffInstance* stun = aiClient->GetBuff(HashName_Buff("stunbuff"));
    if (stun) {
        // Process stun buff
    }
}

# GetBuffCaster

AIBaseClient* GetBuffCaster(std::uint32_t buffNameHash)

Gets the caster of a specified Buff.

Parameter	Type	Description
buffNameHash	std::uint32_t	Buff name's hash value

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient) {
    AIBaseClient* caster = aiClient->GetBuffCaster(HashName_Buff("ignite"));
    if (caster) {
        // Process ignite caster
    }
}

# GetBuffCount

int GetBuffCount(std::uint32_t buffNameHash)

Gets the stack count of a specified Buff.

Parameter	Type	Description
buffNameHash	std::uint32_t	Buff name's hash value

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient) {
    int stacks = aiClient->GetBuffCount(HashName_Buff("twitchdeadlyvenom"));
    // Use stack count for decision making
}

# GetBuffCountAlt

int GetBuffCountAlt(std::uint32_t buffNameHash)

Gets the alternative stack count of a specified Buff.

Parameter	Type	Description
buffNameHash	std::uint32_t	Buff name's hash value

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient) {
    int altStacks = aiClient->GetBuffCountAlt(HashName_Buff("brabumbuff"));
    // Use alternative stack count for decision making
}

# GetBuffEndTime

float GetBuffEndTime(std::uint32_t buffNameHash)

Gets the end time of a specified Buff.

Parameter	Type	Description
buffNameHash	std::uint32_t	Buff name's hash value

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient) {
    float endTime = aiClient->GetBuffEndTime(HashName_Buff("stunbuff"));
    // Use end time for decision making
}

# GetIgniteDamage

double GetIgniteDamage(AIBaseClient* target)

Calculates the damage of ignite to the target.

Parameter	Type	Description
target	AIBaseClient*	Target unit

AIBaseClient* aiClient = GetAIBaseClient();
AIBaseClient* target = GetTargetUnit();
if (aiClient && target) {
    double igniteDamage = aiClient->GetIgniteDamage(target);
    // Use the calculated ignite damage for decision making
}

# GetItem

InventoryItem* GetItem(eSpellSlot slot)

Gets an item based on the specified slot.

Parameter	Type	Description
slot	eSpellSlot	Item slot

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient) {
    InventoryItem* item = aiClient->GetItem(eSpellSlot::Item1);
    if (item) {
        // Process item data
    }
}

# GetPath

void GetPath(Vector const& Start, Vector const& End, std::vector<Vector>& Output)

Calculates the path from the start point to the end point.

Parameter	Type	Description
Start	Vector	Starting position
End	Vector	Target position
Output	std::vector<Vector>&	Output parameter, used to store calculated path

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient) {
    Vector start = aiClient->Position();
    Vector end(1000.0f, 0.0f, 1000.0f);
    std::vector&lt;Vector&gt; calculatedPath;
    aiClient->GetPath(start, end, calculatedPath);
    // Use the calculated path for processing
}

# GetSmiteDamage

double GetSmiteDamage(AIBaseClient* target)

Calculates the damage of smite to the target.

Parameter	Type	Description
target	AIBaseClient*	Target unit

AIBaseClient* aiClient = GetAIBaseClient();
AIBaseClient* jungle = GetJungleMonster();
if (aiClient && jungle) {
    double smiteDamage = aiClient->GetSmiteDamage(jungle);
    // Use the calculated smite damage for decision making
}

# GetSpell

SpellDataInst* GetSpell(eSpellSlot slot)

Gets a specific skill instance based on the specified slot.

Parameter	Type	Description
slot	eSpellSlot	Skill slot

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient) {
    SpellDataInst* qSpell = aiClient->GetSpell(eSpellSlot::Q);
    if (qSpell) {
        // Process Q skill data
    }
}

# GetSpellDamage

double GetSpellDamage(AIBaseClient* target, std::uint32_t spellNameHash)

Calculates the damage of a skill to the target.

Parameter	Type	Description
target	AIBaseClient*	Target unit
spellNameHash	std::uint32_t	Skill name's hash value

AIBaseClient* aiClient = GetAIBaseClient();
AIBaseClient* target = GetTargetUnit();
if (aiClient && target) {
    double qDamage = aiClient->GetSpellDamage(target, HashName_SpellData("AatroxQ"));
    // Use the calculated skill damage for decision making
}

# GetSpellDamage

double GetSpellDamage(AIBaseClient* target, eSpellSlot slot, int stage = 0)

Calculates the damage of a skill to the target based on the specified slot.

Parameter	Type	Description
target	AIBaseClient*	Target unit
slot	eSpellSlot	Skill slot
stage	int	Skill stage, default is 0

AIBaseClient* aiClient = GetAIBaseClient();
AIBaseClient* target = GetTargetUnit();
if (aiClient && target) {
    double rDamage = aiClient->GetSpellDamage(target, eSpellSlot::R);
    // Use the calculated R skill damage for decision making
}

# GetSpellSlot

eSpellSlot GetSpellSlot(std::uint32_t SDataName)

Gets the skill slot based on the skill data name.

Parameter	Type	Description
SDataName	std::uint32_t	Skill data name's hash value

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient) {
    eSpellSlot flashSlot = aiClient->GetSpellSlot(HashName_SpellData("SummonerFlash"));
    if (flashSlot != eSpellSlot::Unknown) {
        // Process flash skill
    }
}

# GetSpellState

eSpellState GetSpellState(eSpellSlot slot)

Gets the state of a specified skill.

Parameter	Type	Description
slot	eSpellSlot	Skill slot

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient) {
    eSpellState state = aiClient->GetSpellState(eSpellSlot::R);
    // Use R skill state for decision making
}

# Gold

float Gold()

Gets the gold amount owned by the current AI unit.

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient) {
    float gold = aiClient->Gold();
    // Use gold amount for decision making
}

# HPBarPosition

void HPBarPosition(Vector& Output)

Gets the screen position of the current AI unit's health bar.

Parameter	Type	Description
Output	Vector&	Output parameter, used to store health bar position

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient) {
    Vector hpBarPos;
    aiClient->HPBarPosition(hpBarPos);
    // Use health bar position for processing
}

# HPBarStacks

float HPBarStacks()

Gets the stack count of the current AI unit's health bar.

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient) {
    float hpStacks = aiClient->HPBarStacks();
    // Use health bar stack count for processing
}

# Hash

std::uint32_t Hash()

Gets the hash value of the AI unit.

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient) {
    std::uint32_t hash = aiClient->Hash();
    // Use hash value for identification or comparison
}

# HasBuff

bool HasBuff(std::uint32_t buffNameHash)

Determines whether the AI unit has a specified Buff.

Parameter	Type	Description
buffNameHash	std::uint32_t	Buff name's hash value

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient && aiClient->HasBuff(HashName_Buff("zhonyasringshield"))) {
    // Unit has Zhonya's Ring effect
}

# HasBuffOfType

bool HasBuffOfType(eBuffType Type)

Determines whether the AI unit has a specified type of Buff.

Parameter	Type	Description
Type	eBuffType	Buff type

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient && aiClient->HasBuffOfType(eBuffType::Stun)) {
    // Unit has stun type buff
}

# HasBuffOfType

bool HasBuffOfType(const std::vector<eBuffType>& Types)

Determines whether the AI unit has any Buff in the specified type list.

Parameter	Type	Description
Types	std::vector<eBuffType>&	Buff type list

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient) {
    std::vector&lt;eBuffType&gt; ccTypes = {eBuffType::Stun, eBuffType::Silence, eBuffType::Taunt};
    if (aiClient->HasBuffOfType(ccTypes)) {
        // Unit has control type buff
    }
}

# Health

float Health()

Gets the current health of the AI unit.

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient) {
    float health = aiClient->Health();
    // Check AI unit's health
}

# HealthPercent

float HealthPercent()

Gets the health percentage of the AI unit.

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient) {
    float healthPct = aiClient->HealthPercent();
    if (healthPct < 30.0f) {
        // Execute operation when health percentage is less than 30%
    }
}

# Icon

uintptr_t* Icon()

Gets the icon pointer of the current AI unit.

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient) {
    uintptr_t* icon = aiClient->Icon();
    // Use icon pointer for processing
}

# IsAsleep

bool IsAsleep()

Determines whether the current AI unit is in sleep state.

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient && aiClient->IsAsleep()) {
    // Unit is in sleep state
}

# IsChanneling

bool IsChanneling()

Determines whether the current AI unit is channeling a skill.

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient && aiClient->IsChanneling()) {
    // Unit is channeling a skill
}

# IsCharmed

bool IsCharmed()

Determines whether the current AI unit is in charmed state.

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient && aiClient->IsCharmed()) {
    // Unit is in charmed state
}

# IsControlled

bool IsControlled()

Determines whether the current AI unit is in controlled state.

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient && aiClient->IsControlled()) {
    // Unit is in controlled state
}

# IsCastingInterruptableSpell

int IsCastingInterruptableSpell()

Determines whether the current AI unit is casting an interruptable skill.

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient) {
    int priority = aiClient->IsCastingInterruptableSpell();
    if (priority > 0) {
        // Can interrupt target skill, priority is priority
    }
}

Returns:

2 = High priority
1 = Low priority
0 = No interruptable skill is being cast

# IsDashing

bool IsDashing()

Determines whether the AI unit is currently dashing.

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient && aiClient->IsDashing()) {
    // AI unit is dashing
}

# IsDisarmed

bool IsDisarmed()

Determines whether the current AI unit is in disarmed state.

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient && aiClient->IsDisarmed()) {
    // Unit is in disarmed state
}

# IsEpicMonster

bool IsEpicMonster()

Determines whether the current AI unit is an epic monster (such as dragon, dragon, etc.).

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient && aiClient->IsEpicMonster()) {
    // Unit is an epic monster
}

# IsFacing

bool IsFacing(AIBaseClient* target)

Determines whether the current AI unit is facing the target unit.

Parameter	Type	Description
target	AIBaseClient*	Target unit

AIBaseClient* aiClient = GetAIBaseClient();
AIBaseClient* target = GetTargetUnit();
if (aiClient && target && aiClient->IsFacing(target)) {
    // Current unit is facing target
}

# IsFeared

bool IsFeared()

Determines whether the current AI unit is in fear state.

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient && aiClient->IsFeared()) {
    // Unit is in fear state
}

# IsFleeing

bool IsFleeing()

Determines whether the current AI unit is in fleeing state.

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient && aiClient->IsFleeing()) {
    // Unit is in fleeing state
}

# IsGhosted

bool IsGhosted()

Determines whether the current AI unit is in ghost state.

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient && aiClient->IsGhosted()) {
    // Unit is in ghost state
}

# IsInvulnerable

bool IsInvulnerable()

Determines whether the current AI unit is in invulnerable state.

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient && aiClient->IsInvulnerable()) {
    // Unit is in invulnerable state
}

# IsLargeMonster

bool IsLargeMonster()

Determines whether the current AI unit is a large monster.

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient && aiClient->IsLargeMonster()) {
    // Unit is a large monster
}

# IsMagicImmune

bool IsMagicImmune()

Determines whether the current AI unit has magic immunity.

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient && aiClient->IsMagicImmune()) {
    // Unit has magic immunity
}

# IsMelee

bool IsMelee()

Determines whether the current AI unit is a melee unit.

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient && aiClient->IsMelee()) {
    // Unit is a melee unit
}

# IsMeleeMinion

bool IsMeleeMinion()

Determines whether the current AI unit is a melee minion.

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient && aiClient->IsMeleeMinion()) {
    // Unit is a melee minion
}

# IsMinion

bool IsMinion()

Determines whether the current AI unit is a minion.

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient && aiClient->IsMinion()) {
    // Unit is a minion
}

# IsMoving

bool IsMoving()

Determines whether the current AI unit is moving.

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient && aiClient->IsMoving()) {
    // AI unit is moving
}

# IsMovingInSameDirection

bool IsMovingInSameDirection(AIBaseClient* target)

Determines whether the current AI unit is moving in the same direction as the target unit.

Parameter	Type	Description
target	AIBaseClient*	Target unit

AIBaseClient* aiClient = GetAIBaseClient();
AIBaseClient* target = GetTargetUnit();
if (aiClient && target && aiClient->IsMovingInSameDirection(target)) {
    // Two units are moving in the same direction
}

# IsPet

bool IsPet(bool includeClones = true)

Determines whether the current AI unit is a pet (such as spider, grasshopper, Annie bear, etc.).

Parameter	Type	Description
includeClones	bool	Whether to include clones, default is true

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient && aiClient->IsPet()) {
    // Unit is a pet
}

# IsPhysicalImmune

bool IsPhysicalImmune()

Determines whether the current AI unit has physical immunity.

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient && aiClient->IsPhysicalImmune()) {
    // Unit has physical immunity
}

# IsPlant

bool IsPlant()

Determines whether the current AI unit is a plant (fruit).

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient && aiClient->IsPlant()) {
    // Unit is a plant (fruit)
}

# IsRanged

bool IsRanged()

Determines whether the current AI unit is a ranged unit.

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient && aiClient->IsRanged()) {
    // Unit is a ranged unit
}

# IsRangedMinion

bool IsRangedMinion()

Determines whether the current AI unit is a ranged minion.

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient && aiClient->IsRangedMinion()) {
    // Unit is a ranged minion
}

# IsReady

bool IsReady(eSpellSlot slot, int t = 0)

Determines whether a specified skill is ready.

Parameter	Type	Description
slot	eSpellSlot	Skill slot
t	int	Additional time (milliseconds), default is 0

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient && aiClient->IsReady(eSpellSlot::R)) {
    // R skill is ready
}

# IsRooted

bool IsRooted()

Determines whether the current AI unit is in rooted state.

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient && aiClient->IsRooted()) {
    // Unit is in rooted state
}

# IsSiegeMinion

bool IsSiegeMinion()

Determines whether the current AI unit is a siege minion.

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient && aiClient->IsSiegeMinion()) {
    // Unit is a siege minion
}

# IsSilenced

bool IsSilenced()

Determines whether the current AI unit is in silenced state.

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient && aiClient->IsSilenced()) {
    // Unit is in silenced state
}

# IsStealthed

bool IsStealthed()

Determines whether the current AI unit is in stealthed state.

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient && aiClient->IsStealthed()) {
    // Unit is in stealthed state
}

# IsStunned

bool IsStunned()

Determines whether the current AI unit is in stunned state.

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient && aiClient->IsStunned()) {
    // Unit is in stunned state
}

# IsSuperMinion

bool IsSuperMinion()

Determines whether the current AI unit is a super minion.

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient && aiClient->IsSuperMinion()) {
    // Unit is a super minion
}

# IsSupressed

bool IsSupressed()

Determines whether the current AI unit is in supressed state.

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient && aiClient->IsSupressed()) {
    // Unit is in supressed state
}

# IsTargetable

bool IsTargetable()

Determines whether the current AI unit can be selected as a target.

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient && aiClient->IsTargetable()) {
    // Unit can be selected as a target
}

# IsTaunted

bool IsTaunted()

Determines whether the current AI unit is in taunted state.

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient && aiClient->IsTaunted()) {
    // Unit is in taunted state
}

# IsValidTarget

bool IsValidTarget(float range = FLT_MAX, bool checkTeam = true, Vector const& from = Vector::Zero, bool ignoreInvulnerable = false)

Determines whether the AI unit is a valid target.

Parameter	Type	Description
range	float	Check range, default is maximum float
checkTeam	bool	Whether to check team, default is true
from	Vector	Check starting position, default is zero vector
ignoreInvulnerable	bool	Whether to ignore invulnerable state, default is false

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient && aiClient->IsValidTarget(800.0f)) {
    // Target is valid and within 800 range
}

# IsWard

bool IsWard()

Determines whether the current AI unit is a ward.

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient && aiClient->IsWard()) {
    // Unit is a ward
}

# IsZombie

bool IsZombie()

Determines whether the current AI unit is in zombie state.

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient && aiClient->IsZombie()) {
    // Unit is in zombie state
}

# IssueOrder

bool IssueOrder(eGameObjectOrder order, AIBaseClient* unit, bool triggerEvent = true)

Sends an order to the AI unit, specifying the target unit.

Parameter	Type	Description
order	eGameObjectOrder	Order type
unit	AIBaseClient*	Target unit
triggerEvent	bool	Whether to trigger event, default is true

AIBaseClient* aiClient = GetAIBaseClient();
AIBaseClient* target = GetTargetUnit();
if (aiClient && target) {
    bool success = aiClient->IssueOrder(eGameObjectOrder::AttackUnit, target);
}

# IssueOrder

bool IssueOrder(eGameObjectOrder order, Vector const& position, bool triggerEvent = true)

Sends an order to the AI unit, specifying the target position.

Parameter	Type	Description
order	eGameObjectOrder	Order type
position	Vector	Target position
triggerEvent	bool	Whether to trigger event, default is true

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient) {
    Vector targetPos(100.0f, 0.0f, 200.0f);
    bool success = aiClient->IssueOrder(eGameObjectOrder::MoveTo, targetPos);
}

# Level

int Level()

Gets the level of the current AI unit.

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient) {
    int level = aiClient->Level();
    // Use unit level for decision making
}

# Mana

float Mana()

Gets the current mana of the AI unit.

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient) {
    float mana = aiClient->Mana();
    // Use mana information
}

# ManaPercent

float ManaPercent()

Gets the mana percentage of the AI unit.

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient) {
    float manaPct = aiClient->ManaPercent();
    if (manaPct > 50.0f) {
        // Execute operation when mana percentage is greater than 50%
    }
}

# ManaCost

float ManaCost(eSpellSlot slot)

Gets the mana cost of a specified skill.

Parameter	Type	Description
slot	eSpellSlot	Skill slot

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient) {
    float cost = aiClient->ManaCost(eSpellSlot::Q);
    // Use Q skill mana cost for decision making
}

# MaxHealth

float MaxHealth()

Gets the maximum health of the AI unit.

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient) {
    float maxHealth = aiClient->MaxHealth();
    float currentHealth = aiClient->Health();
    float healthPercentage = (currentHealth / maxHealth) * 100.0f;
}

# MaxMana

float MaxMana()

Gets the maximum mana of the AI unit.

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient) {
    float maxMana = aiClient->MaxMana();
    float currentMana = aiClient->Mana();
    float manaPercentage = (currentMana / maxMana) * 100.0f;
}

# MoveTo

bool MoveTo(const Vector& position)

Controls the AI unit to move to a specified position.

Parameter	Type	Description
position	Vector	3D coordinates of target position

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient) {
    Vector targetPos(100.0f, 0.0f, 200.0f);
    bool success = aiClient->MoveTo(targetPos);
}

# MoveSpeed

float MoveSpeed()

Gets the move speed of the current AI unit.

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient) {
    float ms = aiClient->MoveSpeed();
    // Use move speed for calculations
}

# Owner

AIBaseClient* Owner()

Gets the owner of the current AI unit. If the calling object is Tibbers, it will return Annie (owner).

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient) {
    AIBaseClient* owner = aiClient->Owner();
    if (owner) {
        // Process owner
    }
}

# Path

std::vector<Vector>const& Path()

Gets the move path of the current AI unit.

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient) {
    auto& path = aiClient->Path();
    if (!path.empty()) {
        // Process move path
    }
}

# PhysicalShield

float PhysicalShield()

Gets the physical shield value of the AI unit.

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient) {
    float physShield = aiClient->PhysicalShield();
    // Process physical shield information
}

# Position

Vector const& Position()

Gets the current position of the AI unit.

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient) {
    Vector position = aiClient->Position();
    // Use position information
}

# ServerPosition

Vector const& ServerPosition()

Gets the position of the current AI unit on the server.

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient) {
    Vector serverPos = aiClient->ServerPosition();
    // Use server position for calculations
}

# SkinId

std::uint32_t SkinId()

Gets the skin ID of the current AI unit.

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient) {
    std::uint32_t skinId = aiClient->SkinId();
    // Use skin ID for decision making
}

# SkinName

const char* SkinName()

Gets the skin name of the current AI unit.

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient) {
    const char* skinName = aiClient->SkinName();
    // Process skin name
}

# SpellBlock

float SpellBlock()

Gets the magic resistance of the current AI unit.

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient) {
    float magicResist = aiClient->SpellBlock();
    // Use magic resistance for calculations
}

# SpellBook

Spellbook* SpellBook()

Gets the skill book of the current AI unit.

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient) {
    Spellbook* book = aiClient->SpellBook();
    if (book) {
        // Process skill book
    }
}

# StatusFlags

eGameObjectStatusFlags StatusFlags()

Gets the status flags of the current AI unit.

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient) {
    eGameObjectStatusFlags flags = aiClient->StatusFlags();
    // Use status flags for decision making
}

# Stop

void Stop()

Stops all behaviors of the current AI unit.

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient) {
    aiClient->Stop();
}

# TotalAttackDamage

float TotalAttackDamage()

Gets the total attack damage (base + additional) of the current AI unit.

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient) {
    float totalAD = aiClient->TotalAttackDamage();
    // Use total attack damage for calculations
}

# TotalMagicalDamage

float TotalMagicalDamage()

Gets the total magical strength of the current AI unit.

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient) {
    float totalAP = aiClient->TotalMagicalDamage();
    // Use total magical strength for calculations
}

# VisibleOnScreen

bool VisibleOnScreen()

Determines whether the current AI unit is visible on the screen.

AIBaseClient* aiClient = GetAIBaseClient();
if (aiClient && aiClient->VisibleOnScreen()) {
    // Unit is visible on the screen
}

# GetCollision

void GetCollision(std::vector<AIBaseClient*>& Output, const Vector& from, std::vector<Vector>const& to, float delayOverride = -1) const

Gets collision units along the skill path.

Parameter	Type	Description
Output	std::vector<AIBaseClient*>&	Output collision units
from	const Vector&	Start position
to	std::vector<Vector>const&	List of target positions
delayOverride	float	Override delay value (optional)

← eTargetingMode AnimationClient →