Inheritance diagram for GoalCombat:

Classes
class	ItemAbility

Public Member Functions
override bool	CanManualCancel ()

override IEnumerable< Status >	Run ()

bool	TryMove (int dist)

void	AddAbility (Act a, int mod=0, int chance=100, bool aiPt=false)

virtual bool	TryUseRanged (int dist)

virtual bool	TryThrow (int dist)

virtual bool	TryUseAbility (int dist, bool beforeMove=false)

virtual void	BuildAbilityList ()

virtual bool	TryAbortCombat ()

Public Member Functions inherited from Goal
Goal	Duplicate ()

Public Member Functions inherited from AIAct
override string	ToString ()

override MultiSprite	GetStateIcon ()

virtual bool	ShouldAllyAttack (Chara tg)

virtual Point	GetDestination ()

AIProgress	GetProgress ()

string	GetCurrentActionText ()

override bool	IsToolValid ()

virtual void	OnStart ()

void	SetOwner (Chara c)

virtual void	OnSetOwner ()

void	SetChild (AIAct seq, Func< Status > _onChildFail=null)

void	Start ()

override bool	Perform ()

Status	Restart ()

Status	Success (Action action=null)

virtual void	OnSuccess ()

bool	TryCancel (Card c)

virtual Status	Cancel ()

virtual void	OnCancel ()

virtual void	OnCancelOrSuccess ()

virtual bool	CanManualCancel ()

Status	KeepRunning ()

void	Reset ()

virtual void	OnReset ()

Status	Tick ()

virtual IEnumerable< Status >	Run ()

Status	TickChild ()

Status	Do (AIAct _seq, Func< Status > _onChildFail=null)

Status	DoGotoInteraction (Point pos, Func< Status > _onChildFail=null)

Status	DoGoto (Point pos, int dist=0, bool ignoreConnection=false, Func< Status > _onChildFail=null)

Status	DoGoto (Card card, Func< Status > _onChildFail=null)

Status	DoGoto (Card card, int dist, Func< Status > _onChildFail=null)

Status	DoGotoSpot (Card card, Func< Status > _onChildFail=null)

Status	DoGoto< T > (Func< Status > _onChildFail=null)

Status	DoGotoSpot< T > (Func< Status > _onChildFail=null, bool ignoreAccessType=false)

Status	DoGrab (Card card, int num=-1, bool pickHeld=false, Func< Status > _onChildFail=null)

Status	DoGrab< T > ()

Status	DoProgress ()

Status	DoIdle (int repeat=3)

Status	DoWait (int count=1)

virtual AIProgress	CreateProgress ()

virtual void	OnCreateProgress (Progress_Custom p)

virtual bool	CanProgress ()

virtual void	OnBeforeProgress ()

virtual void	OnProgress ()

virtual void	OnProgressComplete ()

void	SimulateZone (int days)

virtual void	OnSimulateZone (int days)

virtual void	OnSimulatePosition ()

Public Member Functions inherited from Act
virtual CursorInfo	GetCursorIcon (Card c)

virtual MultiSprite	GetStateIcon ()

override Sprite	GetSprite ()

virtual bool	ShowMouseHint (Card c)

virtual bool	IsValidTC (Card c)

virtual string	GetHintText (string str="")

virtual string	GetText (string str="")

virtual string	GetTextSmall (Card c)

bool	IsTargetHostileParty ()

virtual Color	GetActPlanColor ()

virtual bool	Perform ()

virtual bool	CanPerform ()

bool	Perform (Chara _cc, Card _tc=null, Point _tp=null)

bool	CanPerform (Chara _cc, Card _tc=null, Point _tp=null)

virtual bool	IsToolValid ()

new void	SetImage (Image image)

virtual void	OnMarkMapHighlights ()

virtual bool	ShouldMapHighlight (Point p)

Public Member Functions inherited from Element
virtual SourceElement.Row	GetSource ()

virtual int	GetSourcePotential (int v)

virtual Sprite	GetSprite ()

int	GetMaterialSourceValue (Thing t, int v)

virtual int	GetSourceValue (int v, int lv, SourceValueType type)

virtual Sprite	GetIcon (string suffix="")

bool	IsActive (Card c)

int	SortVal (bool charaSheet=false)

virtual bool	CanLink (ElementContainer owner)

bool	HasTag (string tag)

void	SetImage (Image i)

virtual string	GetDetail ()

bool	IsFactionElement (Chara c)

Element	GetParent (Card c)

void	WriteNote (UINote n, ElementContainer owner=null, Action< UINote > onWriteNote=null)

void	WriteNoteWithRef (UINote n, ElementContainer owner, Action< UINote > onWriteNote, Element refEle)

void	_WriteNote (UINote n, Chara c, Act act)

void	AddHeaderAbility (UINote n)

void	_WriteNote (UINote n, ElementContainer owner, Action< UINote > onWriteNote, bool isRef, bool addHeader=true)

virtual void	OnWriteNote (UINote n, ElementContainer owner)

virtual void	OnChangeValue ()

void	CheckLevelBonus (ElementContainer owner, UINote n=null)

int	GetSortVal (UIList.SortMode m)

virtual Act.Cost	GetCost (Chara c)

virtual int	GetPower (Card c)

virtual void	SetTextValue (UIText text)

virtual bool	IsPurchaseFeatReqMet (ElementContainer owner, int lv=-1)

virtual void	WritePurchaseReq (UINote n, int lv=1)

Public Attributes
Chara	destEnemy

Chara	tc

int	idleCount

int	moveFail

List< ItemAbility >	abilities

List< Chara >	charas = new List<Chara>()

Public Attributes inherited from AIAct
new Chara	owner

Status	status

IEnumerator< Status >	Enumerator

AIAct	child

AIAct	parent

byte	restartCount

Func< Status >	onChildFail

Func< bool >	isFail

Public Attributes inherited from Element
SourceElement.Row	_source

int	id

int	vBase

int	vExp

int	vPotential

int	vTempPotential

int	vLink

int	vSource

int	vSourcePotential

ElementContainer	owner

Properties
override CursorInfo	CursorIcon `[get]`

override bool	CancelWhenDamaged `[get]`

override bool	CancelOnAggro `[get]`

Tactics	tactics `[get]`

Properties inherited from Goal
override bool	InformCancel `[get]`

Properties inherited from AIAct
virtual bool	IsRunning `[get]`

bool	IsChildRunning `[get]`

bool	IsMoveAI `[get]`

virtual int	MaxRestart `[get]`

virtual new string	Name `[get]`

virtual MultiSprite	stateIcon `[get]`

virtual Sprite	actionIcon `[get]`

virtual bool	IsNoGoal `[get]`

virtual bool	IsAutoTurn `[get]`

virtual bool	IsIdle `[get]`

virtual bool	CancelOnAggro `[get]`

virtual bool	PushChara `[get]`

virtual int	MaxProgress `[get]`

virtual bool	ShowProgress `[get]`

virtual bool	UseTurbo `[get]`

virtual int	CurrentProgress `[get]`

virtual bool	ShowCursor `[get]`

virtual bool	CancelWhenDamaged `[get]`

virtual bool	CancelWhenMoved `[get]`

virtual bool	InformCancel `[get]`

virtual Thing	RenderThing `[get]`

AIAct	Current `[get]`

override bool	IsAct `[get]`

override bool	ShowPotential `[get]`

override bool	UsePotential `[get]`

override bool	ShowRelativeAttribute `[get]`

virtual bool	HasProgress `[get]`

Properties inherited from Act
override bool	ShowPotential `[get]`

override bool	UsePotential `[get]`

override bool	ShowRelativeAttribute `[get]`

virtual CursorInfo	CursorIcon `[get]`

virtual string	ID `[get]`

virtual bool	IsAct `[get]`

virtual bool	WillEndTurn `[get]`

virtual bool	CloseLayers `[get]`

virtual int	LeftHand `[get]`

virtual int	RightHand `[get]`

virtual int	ElementPowerMod `[get]`

virtual bool	ShowMapHighlight `[get]`

virtual bool	ShowMapHighlightBlock `[get]`

virtual bool	PickHeldOnStart `[get]`

virtual bool	DropHeldOnStart `[get]`

virtual bool	CanPressRepeat `[get]`

virtual bool	CanAutofire `[get]`

virtual bool	ResetAxis `[get]`

virtual bool	RequireTool `[get]`

virtual bool	IsHostileAct `[get]`

virtual bool	HideRightInfo `[get]`

virtual bool	HaveLongPressAction `[get]`

virtual float	Radius `[get]`

virtual int	PerformDistance `[get]`

virtual int	MaxRadius `[get]`

virtual TargetType	TargetType `[get]`

virtual bool	LocalAct `[get]`

virtual bool	CanRapidFire `[get]`

virtual float	RapidDelay `[get]`

virtual bool	ShowAuto `[get]`

virtual bool	IsCrime `[get]`

Properties inherited from Element
SourceElement.Row	source `[get]`

virtual int	DisplayValue `[get]`

virtual int	MinValue `[get]`

int	Value `[get]`

int	ValueWithoutLink `[get]`

virtual int	MinPotential `[get]`

int	Potential `[get]`

virtual bool	CanGainExp `[get]`

bool	IsFlag `[get]`

virtual string	Name `[get]`

virtual string	FullName `[get]`

virtual int	ExpToNext `[get]`

virtual bool	UseExpMod `[get]`

virtual int	CostTrain `[get]`

virtual int	CostLearn `[get]`

virtual bool	ShowXP `[get]`

virtual bool	ShowMsgOnValueChanged `[get]`

virtual bool	ShowValue `[get]`

virtual bool	ShowPotential `[get]`

virtual bool	UsePotential `[get]`

virtual bool	PotentialAsStock `[get]`

virtual bool	ShowRelativeAttribute `[get]`

virtual bool	ShowBonuses `[get]`

virtual string	ShortName `[get]`

bool	IsGlobalElement `[get]`

bool	IsFactionWideElement `[get]`

bool	IsPartyWideElement `[get]`

virtual bool	ShowEncNumber `[get]`

bool	IsTrait `[get]`

bool	IsFoodTrait `[get]`

bool	IsFoodTraitMain `[get]`

bool	IsMainAttribute `[get]`

Act	act `[get]`

Properties inherited from EClass
static Game	game `[get]`

static bool	AdvMode `[get]`

static Player	player `[get]`

static Chara	pc `[get]`

static UI	ui `[get]`

static Map	_map `[get]`

static Zone	_zone `[get]`

static FactionBranch	Branch `[get]`

static FactionBranch	BranchOrHomeBranch `[get]`

static Faction	Home `[get]`

static Faction	Wilds `[get]`

static Scene	scene `[get]`

static BaseGameScreen	screen `[get]`

static GameSetting	setting `[get]`

static GameData	gamedata `[get]`

static ColorProfile	Colors `[get]`

static World	world `[get]`

static SourceManager	sources `[get]`

static SourceManager	editorSources `[get]`

static SoundManager	Sound `[get]`

static CoreDebug	debug `[get]`

Additional Inherited Members
Public Types inherited from AIAct
enum	Status { Running , Fail , Success }

Public Types inherited from Act
enum	CostType { None , MP , SP }

Static Public Member Functions inherited from Act
static void	SetReference (Chara _cc, Card _tc=null, Point _tp=null)

static void	SetTool (Thing t)

Static Public Member Functions inherited from Element
static string	GetName (string alias)

static SourceElement.Row	Get (int id)

static Dictionary< int, int >	GetElementMap (int[] list)

static Dictionary< int, int >	GetElementMap (int[] list, Dictionary< int, int > map)

static SourceElement.Row	GetRandomElement (int lv=1)

static Element	Create (int id, int v=0)

static Element	Create (string id, int v=1)

static int	GetId (string alias)

static int	GetResistLv (int v)

static int	GetResistDamage (int dmg, int v, int power=0)

Static Public Member Functions inherited from EClass
static int	rnd (int a)

static int	curve (int a, int start, int step, int rate=75)

static int	rndHalf (int a)

static float	rndf (float a)

static int	rndSqrt (int a)

static void	Wait (float a, Card c)

static void	Wait (float a, Point p)

static int	Bigger (int a, int b)

static int	Smaller (int a, int b)

Static Public Attributes inherited from Act
static Chara	CC

static Card	TC

static Point	TP = new Point()

static Thing	TOOL

static int	powerMod = 100

static bool	forcePt

Static Public Attributes inherited from Element
const int	Div = 5

static Element	Void = new Element()

static int[]	List_MainAttributes = new int[9] { 70, 72, 71, 77, 74, 75, 76, 73, 79 }

static int[]	List_MainAttributesMajor = new int[8] { 70, 72, 71, 77, 74, 75, 76, 73 }

static int[]	List_Body = new int[4] { 70, 72, 71, 77 }

static int[]	List_Mind = new int[4] { 74, 75, 76, 73 }

static List< SourceElement.Row >	ListElements = new List<SourceElement.Row>()

static List< SourceElement.Row >	ListAttackElements = new List<SourceElement.Row>()

Static Public Attributes inherited from EClass
static Core	core

Detailed Description

Definition at line 5 of file GoalCombat.cs.

Member Function Documentation

◆ AddAbility()

void GoalCombat.AddAbility	(	Act	a,
		int	mod = `0`,
		int	chance = `100`,
		bool	aiPt = `false`
	)

inline

Definition at line 408 of file GoalCombat.cs.

    {
        abilities.Add(new ItemAbility
        {
            act = a,
            priorityMod = mod,
            chance = chance,
            aiPt = aiPt
        });
    }

References abilities, and Element.act.

Referenced by BuildAbilityList().

◆ BuildAbilityList()

virtual void GoalCombat.BuildAbilityList ( )

inlinevirtual

Reimplemented in GoalAutoCombat.

Definition at line 1040 of file GoalCombat.cs.

    {
        foreach (ActList.Item item in owner.ability.list.items)
        {
            AddAbility(item.act, 0, item.chance, item.pt);
        }
        AddAbility(ACT.Ranged);
        AddAbility(ACT.Melee);
        AddAbility(ACT.Item);
    }

References Chara.ability, AddAbility(), ACT.Item, item, ActList.items, CharaAbility.list, ACT.Melee, AIAct.owner, and ACT.Ranged.

Referenced by Run().

◆ CanManualCancel()

override bool GoalCombat.CanManualCancel ( )

inlinevirtual

Reimplemented from AIAct.

Definition at line 44 of file GoalCombat.cs.

    {
        return true;
    }

◆ Run()

override IEnumerable< Status > GoalCombat.Run ( )

inlinevirtual

Reimplemented from AIAct.

Definition at line 49 of file GoalCombat.cs.

    {
        if (destEnemy != null)
        {
            owner.enemy = destEnemy;
            destEnemy = null;
        }
        int count = 0;
        int lostCount = 0;
        bool dontWander = owner.IsPCParty && !owner.IsPC && EClass.game.config.tactics.dontWander;
        while (true)
        {
            bool canSeeLos = false;
            if (EClass.debug.logCombat)
            {
                Debug.Log("■" + owner.Name + "/" + count + "/" + lostCount);
            }
            if (EClass._zone.isPeace && owner.IsPCFactionOrMinion && !owner.IsPC)
            {
                owner.enemy = null;
                owner.ShowEmo(Emo.happy);
                yield return Success();
            }
            count++;
            if (dontWander && owner.enemy != null && !EClass.pc.isBlind && !EClass.pc.CanSeeLos(owner.enemy) && (owner.Dist(EClass.pc) > 4 || owner.Dist(owner.enemy) > 1))
            {
                Point firstStep = owner.GetFirstStep(EClass.pc.pos, PathManager.MoveType.Combat);
                if (firstStep.IsValid && !firstStep.HasChara)
                {
                    owner.enemy = null;
                }
            }
            tc = owner.enemy;
            if (tc != null && owner.IsPCFaction)
            {
                if (EClass.pc.isHidden && owner.isHidden)
                {
                    owner.enemy = null;
                    yield return Success();
                }
                if (!EClass.pc.ai.ShouldAllyAttack(tc))
                {
                    tc = (owner.enemy = null);
                }
            }
            if (tc == null || tc.isDead || !tc.ExistsOnMap || !tc.pos.IsInBounds || lostCount >= (owner.IsPowerful ? 50 : 5) || !owner.CanSee(tc))
            {
                tc = (owner.enemy = null);
                if (owner.IsPC && EClass.game.config.autoCombat.abortOnKill)
                {
                    yield return Success();
                }
                owner.FindNewEnemy();
                lostCount = 0;
                if (owner.enemy == null)
                {
                    yield return Success();
                }
                tc = owner.enemy;
            }
            else
            {
                canSeeLos = owner.CanSeeLos(tc);
                lostCount = ((!canSeeLos) ? (lostCount + 1) : 0);
            }
            if (owner.IsPC && tc.HasEditorTag(EditorTag.Invulnerable))
            {
                Msg.Say("abort_idle");
                yield return Success();
            }
            if (tc.IsPCFaction && owner.id == "melilith_boss" && EClass._map.plDay.list.Count > 1 && EClass._map.plDay.list[0].data.id != 107)
            {
                EClass._zone.SetBGM(107);
            }
            if (abilities == null)
            {
                abilities = new List<ItemAbility>();
                BuildAbilityList();
            }
            if (owner.IsPCFaction && tc.IsPCFaction && EClass.rnd(5) == 0 && count > 2)
            {
                CalmDown();
                yield return Success();
            }
            if (owner.OriginalHostility >= Hostility.Neutral && tc.OriginalHostility >= Hostility.Neutral && !owner.IsPCParty && owner.c_bossType == BossType.none && (!(owner.trait is TraitGuard) || owner.IsPCFaction || !tc.IsPCParty || !EClass.player.IsCriminal))
            {
                if (owner.calmCheckTurn < 0 || (!owner.enemy.IsPCParty && EClass.rnd(10) == 0))
                {
                    CalmDown();
                    yield return Success();
                }
                owner.calmCheckTurn--;
            }
            if (owner.IsPC)
            {
                CursorSystem.ignoreCount = 1;
            }
            if (tc.host != null && (tc.hp == 0 || EClass.rnd(5) == 0))
            {
                tc = owner.SetEnemy(tc.host);
            }
            if (tc.parasite != null && !tc.isRestrained && tc.parasite.hp > 0 && EClass.rnd(5) == 0)
            {
                tc = owner.SetEnemy(tc.parasite);
            }
            if (tc.ride != null && !tc.isRestrained && tc.ride.hp > 0 && EClass.rnd(5) == 0)
            {
                tc = owner.SetEnemy(tc.ride);
            }
            if (tc.enemy != null)
            {
                tc.TrySetEnemy(owner);
            }
            if (!tc.IsMinion && EClass.rnd(10) == 0 && EClass.rnd(tc.DEX + 10) > owner.LV && tc.HasElement(1315) && !owner.HasElement(1315) && owner.race.IsMachine && owner.CanBeTempAlly(tc))
            {
                owner.Say("dominate_machine", tc, owner);
                owner.PlayEffect("boost");
                owner.PlaySound("boost");
                owner.ShowEmo(Emo.love);
                owner.lastEmo = Emo.angry;
                owner.MakeMinion(tc.IsPCParty ? EClass.pc : tc);
                yield return Success();
            }
            if (EClass.rnd(5) == 0 && tc.HasElement(1325) && owner.race.IsPlant && owner.CanBeTempAlly(tc))
            {
                owner.Say("dominate_plant", tc, owner);
                owner.ShowEmo(Emo.love);
                owner.lastEmo = Emo.angry;
                owner.MakeMinion((tc.IsPCParty || tc.IsPCFactionMinion) ? EClass.pc : tc, MinionType.Friend);
                yield return Success();
            }
            if (EClass.rnd(20) == 0 && owner.isRestrained)
            {
                owner.Talk("restrained");
            }
            if (this is GoalAutoCombat)
            {
                ActionMode.Adv.SetTurbo(EClass.game.config.autoCombat.turbo ? (-1) : 0);
                EClass.pc.ModExp(135, 20);
            }
            int dist = owner.Dist(tc);
            bool move = owner.host == null && (tactics.ChanceMove > EClass.rnd(100) || (owner.IsPC && tc.HasCondition<ConFear>() && dist >= EClass.pc.GetSightRadius() - 1));
            bool haltSecondMove = false;
            if (!owner.IsPC && owner.IsNeutralOrAbove() && !owner.isBlind && !owner.isSummon && !owner.IsMinion)
            {
                int num = -1;
                if (tc.HasElement(1221))
                {
                    num = 1;
                }
                if (tc.source.HasTag(CTAG.suicide) && !tc.HasCondition<ConWet>())
                {
                    num = 3;
                }
                if (num > 0)
                {
                    if (dist <= num)
                    {
                        if (EClass.rnd(15) == 0)
                        {
                            owner.Talk("run_suicide");
                        }
                        if (owner.host == null && owner.TryMoveFrom(tc.pos) != 0)
                        {
                            yield return Status.Running;
                            idleCount = 0;
                            continue;
                        }
                        if (EClass.debug.logCombat)
                        {
                            Debug.Log("Failed to Run: " + owner.Name);
                        }
                    }
                    if (dist == num + 1)
                    {
                        haltSecondMove = true;
                        move = false;
                        idleCount = 0;
                    }
                }
            }
            if (dontWander)
            {
                int num2 = owner.Dist(EClass.pc);
                if (num2 > 3)
                {
                    int x = tc.pos.x;
                    int z = tc.pos.z;
                    if (EClass.pc.pos.Distance(owner.pos.x + ((x > owner.pos.x) ? 1 : ((x < owner.pos.x) ? (-1) : 0)), owner.pos.z + ((z > owner.pos.z) ? 1 : ((z < owner.pos.z) ? (-1) : 0))) >= num2)
                    {
                        move = false;
                        haltSecondMove = true;
                    }
                }
            }
            if ((owner.IsPC && EClass.game.config.autoCombat.bDontChase) || (!canSeeLos && tc.isHidden))
            {
                move = false;
                haltSecondMove = true;
            }
            if (EClass.debug.logCombat)
            {
                Debug.Log(owner.Name + "/" + move + "/" + haltSecondMove + "/" + dist);
            }
            if (move)
            {
                if (owner.IsPC && dist <= owner.GetSightRadius() && TryUseAbility(dist, beforeMove: true))
                {
                    yield return Status.Running;
                    idleCount = 0;
                    continue;
                }
                if (TryMove(dist))
                {
                    if (EClass.debug.logCombat)
                    {
                        Debug.Log("moved:" + owner.Name);
                    }
                    yield return Status.Running;
                    idleCount = 0;
                    continue;
                }
            }
            if (owner == null)
            {
                yield return Cancel();
            }
            if (dist <= owner.GetSightRadius() && TryUseAbility(dist))
            {
                yield return Status.Running;
                idleCount = 0;
                continue;
            }
            if (EClass.debug.logCombat)
            {
                Debug.Log(owner.Name + "/" + move + "/" + haltSecondMove + "/" + tactics.ChanceSecondMove);
            }
            if (!move && !haltSecondMove && tactics.ChanceSecondMove > EClass.rnd(100) && TryMove(dist))
            {
                yield return Status.Running;
                idleCount = 0;
                continue;
            }
            if (owner == null)
            {
                yield return Cancel();
            }
            idleCount++;
            if (TryAbortCombat())
            {
                yield return Success();
            }
            if (idleCount > 2)
            {
                if (dontWander)
                {
                    yield return Success();
                }
                idleCount = 0;
                string aiIdle = owner.source.aiIdle;
                if (aiIdle == "stand" || aiIdle == "root")
                {
                    yield return Success();
                }
                yield return DoGoto(tc.pos);
            }
            else if (owner.FindNearestNewEnemy())
            {
                yield return Status.Running;
                continue;
            }
            yield return Status.Running;
        }
        void CalmDown()
        {
            owner.enemy = null;
            if (owner.ride != null)
            {
                owner.ride.enemy = null;
            }
            if (owner.parasite != null)
            {
                owner.parasite.enemy = null;
            }
            owner.hostility = owner.OriginalHostility;
            if (tc.enemy == owner)
            {
                tc.enemy = null;
                if (tc.ride != null)
                {
                    tc.ride.enemy = null;
                }
                if (tc.parasite != null)
                {
                    tc.parasite.enemy = null;
                }
                tc.hostility = tc.OriginalHostility;
            }
            owner.Say("calmDown", owner);
        }
    }

References EClass._map, EClass._zone, abilities, ConfigAutoCombat.abortOnKill, ActionMode.Adv, Chara.ai, Game.Config.autoCombat, ConfigAutoCombat.bDontChase, BuildAbilityList(), Card.c_bossType, Chara.calmCheckTurn, Chara.CanBeTempAlly(), AIAct.Cancel(), Chara.CanSee(), Chara.CanSeeLos(), Tactics.ChanceSecondMove, Game.config, EClass.debug, Debug, destEnemy, Card.DEX, Card.Dist(), Point.Distance(), AIAct.DoGoto(), ConfigTactics.dontWander, Chara.enemy, Card.ExistsOnMap, Chara.FindNearestNewEnemy(), Chara.FindNewEnemy(), EClass.game, Chara.GetFirstStep(), Card.GetSightRadius(), Point.HasChara, Chara.HasCondition(), Card.HasEditorTag(), Card.HasElement(), Chara.host, Card.hp, Card.id, idleCount, Chara.isBlind, Player.IsCriminal, Chara.isDead, Card.isHidden, Point.IsInBounds, Chara.IsMinion, Chara.IsNeutralOrAbove(), Chara.IsPC, Chara.IsPCFaction, Chara.IsPCFactionMinion, Card.IsPCFactionOrMinion, Chara.IsPCParty, Spatial.isPeace, Card.IsPowerful, Card.isRestrained, Point.IsValid, CoreDebug.logCombat, Card.LV, Chara.MakeMinion(), Card.ModExp(), Card.Name, Chara.OriginalHostility, AIAct.owner, Chara.parasite, EClass.pc, Card.PlayEffect(), EClass.player, Card.PlaySound(), Map.plDay, Card.pos, Chara.race, Chara.ride, EClass.rnd(), Msg.Say(), Card.Say(), Zone.SetBGM(), Chara.SetEnemy(), AM_Adv.SetTurbo(), AIAct.ShouldAllyAttack(), Card.ShowEmo(), Chara.source, AIAct.Success, Game.Config.tactics, tactics, Card.Talk(), tc, Chara.trait, TryAbortCombat(), TryMove(), Chara.TryMoveFrom(), Chara.TrySetEnemy(), TryUseAbility(), ConfigAutoCombat.turbo, Point.x, and Point.z.

◆ TryAbortCombat()

virtual bool GoalCombat.TryAbortCombat ( )

inlinevirtual

Reimplemented in GoalAutoCombat.

Definition at line 1051 of file GoalCombat.cs.

    {
        return false;
    }

Referenced by Run().

◆ TryMove()

bool GoalCombat.TryMove ( int dist )

inline

Definition at line 351 of file GoalCombat.cs.

    {
        if (EClass.debug.logCombat)
        {
            Debug.Log("TryMove: " + owner.Name + "/" + dist);
        }
        if (owner.host != null)
        {
            return false;
        }
        if (owner.isBlind)
        {
            return owner.MoveRandom();
        }
        int num = (tc.HasCondition<ConFear>() ? 1 : tactics.DestDist);
        if (!owner.IsPC && (tactics.source.id == "archer" || tactics.source.id == "gunner") && !owner.TryEquipRanged())
        {
            num = 1;
        }
        if (!owner.IsPC && num > 1)
        {
            if (tactics.DestDist == 2)
            {
                if (EClass.rnd(5) == 0)
                {
                    num = 1;
                }
            }
            else if (owner.turn / 3 % 5 > 2)
            {
                num--;
            }
        }
        bool flag = false;
        if (dist > num)
        {
            flag = owner.TryMoveTowards(tc.pos) != Card.MoveResult.Fail;
            if (!flag)
            {
                moveFail++;
            }
        }
        else if (dist < num)
        {
            flag = owner.TryMoveFrom(tc.pos) != Card.MoveResult.Fail;
        }
        if (flag)
        {
            moveFail = 0;
        }
        if (EClass.debug.logCombat)
        {
            Debug.Log("TryMove:" + owner.Name + "/" + flag + "/" + dist + "/" + num);
        }
        return flag;
    }

References EClass.debug, Debug, Tactics.DestDist, Chara.HasCondition(), Chara.host, Chara.isBlind, Chara.IsPC, CoreDebug.logCombat, moveFail, Chara.MoveRandom(), Card.Name, AIAct.owner, Card.pos, EClass.rnd(), Tactics.source, tactics, tc, Chara.TryEquipRanged(), Chara.TryMoveFrom(), Chara.TryMoveTowards(), and Card.turn.

Referenced by Run().

◆ TryThrow()

virtual bool GoalCombat.TryThrow ( int dist )

inlinevirtual

Definition at line 428 of file GoalCombat.cs.

    {
        if (dist > owner.GetSightRadius())
        {
            return false;
        }
        Thing thing = owner.TryGetThrowable();
        if (thing == null)
        {
            return false;
        }
        if (!ACT.Throw.CanPerform(owner, tc, tc.pos))
        {
            return false;
        }
        ActThrow.Throw(owner, tc.pos, tc, thing.HasElement(410) ? thing : thing.Split(1));
        return true;
    }

References ActThrow.CanPerform(), Card.GetSightRadius(), Card.HasElement(), AIAct.owner, Card.pos, Card.Split(), tc, ACT.Throw, ActThrow.Throw(), and Chara.TryGetThrowable().

Referenced by TryUseAbility().

◆ TryUseAbility()

virtual bool GoalCombat.TryUseAbility	(	int	dist,
		bool	beforeMove = `false`
	)

inlinevirtual

Definition at line 447 of file GoalCombat.cs.

    {
        if (abilities.Count == 0)
        {
            Debug.Log("no ability:" + owner);
            return false;
        }
        int numEnemy = -1;
        int numFriend = -1;
        int numNeutral = -1;
        bool charaBuilt = false;
        bool flag = owner.CanSeeLos(tc, dist);
        bool isPCFaction = owner.IsPCFaction;
        bool flag2 = owner.HasCondition<ConSilence>();
        bool isBlind = owner.isBlind;
        bool flag3 = owner.HasCondition<ConFear>();
        bool isConfused = owner.isConfused;
        bool flag4 = owner.HasCondition<ConDim>();
        bool flag5 = owner.HasCondition<ConSupress>();
        foreach (ItemAbility ability in abilities)
        {
            Act act = ability.act;
            ability.priority = 0;
            ability.tg = null;
            ability.pt = false;
            if (EClass.rnd(100) >= ability.chance || (isBlind && ability.act.HasTag("reqSight")))
            {
                continue;
            }
            int num = 0;
            SourceElement.Row s = act.source;
            if (s.abilityType.Length == 0 || (owner.IsPC && flag2 && act is Spell) || (beforeMove && !act.HasTag("before_move")))
            {
                continue;
            }
            string text = s.abilityType[0];
            if (flag5 && !(text == "melee") && !(text == "range") && EClass.rnd(2) == 0)
            {
                continue;
            }
            switch (act.id)
            {
            case 6602:
                if (dist <= 1 || tc.HasCondition<ConEntangle>())
                {
                    continue;
                }
                break;
            case 6450:
                if (isPCFaction && (tc.HasElement(1221) || tc.HasElement(1223) || tc.id == "hedgehog_ether"))
                {
                    continue;
                }
                break;
            case 8200:
            case 8201:
                if (owner.HasElement(400))
                {
                    continue;
                }
                break;
            case 6400:
                if (isPCFaction)
                {
                    continue;
                }
                break;
            }
            bool isHOT;
            switch (text)
            {
            case "item":
                num = (ability.act as ActItem).BuildAct(owner);
                break;
            case "wait":
                if (owner.IsPCParty)
                {
                    continue;
                }
                num = 50;
                break;
            case "taunt":
            {
                bool flag6 = owner.HasCondition<StanceTaunt>();
                bool flag7 = tactics.source.taunt != -1 && 100 * owner.hp / owner.MaxHP >= tactics.source.taunt;
                num = ((flag6 && !flag7) ? 100 : ((!flag6 && flag7) ? 100 : 0));
                break;
            }
            case "melee":
                if (dist > owner.body.GetMeleeDistance())
                {
                    continue;
                }
                num = ((!flag3) ? tactics.P_Melee : ((!owner.IsPC) ? (tactics.P_Melee / 2) : 0));
                if (isConfused)
                {
                    num -= (owner.IsPC ? 30 : 10);
                }
                if (isBlind)
                {
                    num -= (owner.IsPC ? 50 : 10);
                }
                if (dist <= 1)
                {
                    if (tc.HasElement(1221))
                    {
                        num -= 40;
                    }
                    if (tc.HasElement(1223))
                    {
                        num -= 40;
                    }
                    if (!owner.IsPC && owner.IsPCFaction && tc.id == "hedgehog_ether")
                    {
                        continue;
                    }
                    if (!owner.IsPCFaction && num < 10)
                    {
                        num = 10;
                    }
                }
                break;
            case "range":
                if (!flag || EClass.rnd(100) > tactics.RangedChance)
                {
                    continue;
                }
                num = ((!flag3) ? tactics.P_Range : ((!owner.IsPC) ? (tactics.P_Range / 2) : 0));
                if (isConfused)
                {
                    num -= (owner.IsPC ? 30 : 10);
                }
                if (isBlind)
                {
                    num -= (owner.IsPC ? 50 : 10);
                }
                if (owner.ranged != null && owner.ranged.trait is TraitToolRangeCane && owner.mana.value <= 0)
                {
                    continue;
                }
                break;
            case "teleport":
                num = 40;
                break;
            case "any":
                num = 50;
                break;
            case "hot":
            case "heal":
                isHOT = text == "hot";
                num = ForeachChara(ability, (Chara c) => HealFactor(c), isFriendlyAbility: true);
                if (ability.aiPt || (owner.IsPC && tactics.CastPartyBuff))
                {
                    ability.pt = true;
                }
                break;
            case "dot":
            case "attack":
            case "attackMelee":
            {
                if (!flag)
                {
                    continue;
                }
                bool flag8 = text == "dot";
                if (flag8 && (owner.isRestrained || (tc != null && tc.IsRestrainedResident)))
                {
                    continue;
                }
                num = ((text == "attackMelee") ? tactics.P_Melee : tactics.P_Spell) + GetAttackMod(act);
                if (num > 0 && flag8)
                {
                    num += 10;
                }
                if (ability.aiPt)
                {
                    ability.pt = true;
                }
                break;
            }
            case "attackArea":
            {
                if (owner.isRestrained || (tc != null && tc.IsRestrainedResident))
                {
                    continue;
                }
                bool flag9 = ability.act is ActBolt;
                if (!flag || (owner.IsPCParty && (EClass._zone.IsTown || EClass._zone.IsPCFaction)) || (act.id == 9150 && EClass._zone.IsPCFaction && owner.IsNeutralOrAbove()))
                {
                    continue;
                }
                GetNumEnemy(flag9 ? 6 : 5);
                if (numEnemy == 0 || (owner.IsPCFactionOrMinion && GetNumNeutral(flag9 ? 6 : 5) > 0))
                {
                    continue;
                }
                num = tactics.P_Spell - 20 + numEnemy * 10 + GetAttackMod(act);
                break;
            }
            case "buff":
                num = ForeachChara(ability, (Chara c) => (!c.HasCondition(s.proc[1])) ? tactics.P_Buff : 0, isFriendlyAbility: true);
                if (ability.aiPt || (owner.IsPC && tactics.CastPartyBuff))
                {
                    ability.pt = true;
                }
                break;
            case "buffStats":
                num = ForeachChara(ability, delegate(Chara c)
                {
                    Element buffStats2 = c.GetBuffStats(s.proc[1]);
                    return (buffStats2 == null || buffStats2.Value < 0) ? tactics.P_Buff : 0;
                }, isFriendlyAbility: true);
                if (ability.aiPt || (owner.IsPC && tactics.CastPartyBuff))
                {
                    ability.pt = true;
                }
                break;
            case "debuff":
                if (!flag)
                {
                    continue;
                }
                num = tactics.P_Debuff;
                if (ability.aiPt)
                {
                    ability.pt = true;
                }
                break;
            case "debuffStats":
                if (!flag)
                {
                    continue;
                }
                num = ForeachChara(ability, delegate(Chara c)
                {
                    Element buffStats = c.GetBuffStats(s.proc[1]);
                    return (buffStats == null || buffStats.Value > 0) ? tactics.P_Debuff : 0;
                }, isFriendlyAbility: false);
                if (ability.aiPt)
                {
                    ability.pt = true;
                }
                break;
            case "ground":
                if (!flag || owner.isRestrained || (tc != null && tc.IsRestrainedResident))
                {
                    continue;
                }
                num = 50;
                if (isPCFaction)
                {
                    num -= 10;
                }
                break;
            case "summon":
            {
                if (owner.isRestrained || (tc != null && tc.IsRestrainedResident))
                {
                    continue;
                }
                int num2 = EClass._zone.CountMinions(owner);
                if (num2 >= owner.MaxSummon)
                {
                    continue;
                }
                num = tactics.P_Summon - 20 * num2 / owner.MaxSummon;
                break;
            }
            case "summonAlly":
                if (owner.isRestrained || (tc != null && tc.IsRestrainedResident))
                {
                    continue;
                }
                if (owner.IsPC)
                {
                    if (EClass.player.lastEmptyAlly <= 0)
                    {
                        continue;
                    }
                }
                else if (EClass._zone.CountMinions(owner) > 0)
                {
                    continue;
                }
                num = tactics.P_Summon;
                break;
            case "suicide":
                if (owner.IsPC || owner.HasCondition<ConWet>())
                {
                    continue;
                }
                if (owner.HasTag(CTAG.kamikaze))
                {
                    num = ((dist <= 1) ? 1000 : 0);
                    break;
                }
                num = 100 - 125 * owner.hp / owner.MaxHP;
                if (EClass.rnd(200) <= num)
                {
                    break;
                }
                continue;
            default:
                num = 0;
                break;
            }
            if (s.target == "Neighbor")
            {
                if (dist > 1)
                {
                    continue;
                }
                num += 10;
            }
            if (s.proc.Length != 0 && s.proc[0] == "Debuff" && tc.HasCondition(s.proc[1]))
            {
                continue;
            }
            if (s.abilityType.Length > 1)
            {
                num += (owner.IsPC ? s.abilityType[2] : s.abilityType[1]).ToInt();
            }
            if (act is Spell)
            {
                if (owner.IsPC)
                {
                    if (act.vPotential <= 0)
                    {
                        continue;
                    }
                    if (flag2 || isConfused || flag4)
                    {
                        num -= 50;
                    }
                }
                else
                {
                    if (flag2)
                    {
                        num -= 30;
                    }
                    if (isConfused || flag4)
                    {
                        num -= 10;
                    }
                }
            }
            if (num > 0)
            {
                num += ability.priorityMod + EClass.rnd(tactics.RandomFacotr + ability.priorityMod);
            }
            ability.priority = num;
            int HealFactor(Chara c)
            {
                if (isHOT && c.HasCondition(s.proc[1]))
                {
                    return 0;
                }
                float num3 = (float)c.hp / (float)c.MaxHP;
                if (num3 > (isHOT ? 0.85f : 0.75f))
                {
                    return 0;
                }
                int num4 = tactics.P_Heal - (int)((float)tactics.P_Heal * num3) + (isHOT ? 50 : 25);
                foreach (Condition condition in c.conditions)
                {
                    if (condition is ConFear)
                    {
                        num4 += 10;
                    }
                    else if (condition is ConPoison)
                    {
                        num4 += 2;
                    }
                    else if (condition is ConConfuse)
                    {
                        num4 += 4;
                    }
                    else if (condition is ConDim)
                    {
                        num4 += 6;
                    }
                    else if (condition is ConBleed)
                    {
                        num4 += 8;
                    }
                }
                return num4;
            }
        }
        abilities.Sort((ItemAbility a, ItemAbility b) => b.priority - a.priority);
        foreach (ItemAbility ability2 in abilities)
        {
            if (ability2.priority <= 0)
            {
                continue;
            }
            if (EClass.debug.logCombat && owner.IsPC)
            {
                Debug.Log(ability2.act.Name + "/" + ability2.priority);
            }
            if (ability2.act.source.alias == "ActRanged")
            {
                if (TryThrow(dist))
                {
                    return true;
                }
                if (TryUseRanged(dist))
                {
                    return true;
                }
                continue;
            }
            Cost cost = ability2.act.GetCost(owner);
            if (owner.IsPCParty && ability2.pt && !ability2.act.IsTargetHostileParty() && !ability2.act.TargetType.ForceParty && cost.cost * EClass.pc.party.members.Count > owner.mana.value)
            {
                continue;
            }
            if (isPCFaction && cost.cost > 0)
            {
                switch (cost.type)
                {
                case CostType.MP:
                    if (cost.cost > owner.mana.value)
                    {
                        continue;
                    }
                    break;
                case CostType.SP:
                    if (cost.cost > owner.stamina.value)
                    {
                        continue;
                    }
                    break;
                }
            }
            if (cost.cost > 0 && EClass.rnd(100) > tactics.AbilityChance)
            {
                continue;
            }
            Chara chara = owner;
            if (ability2.act.CanPerform(owner, ability2.tg ?? tc) && owner.UseAbility(ability2.act, ability2.tg ?? tc, null, (ability2.act.HaveLongPressAction && ability2.pt) || ability2.aiPt))
            {
                if (EClass.debug.logCombat)
                {
                    Debug.Log("Used Ability: " + chara?.ToString() + "/" + ability2.act?.ToString() + "/" + ability2.tg?.ToString() + "/" + tc);
                    Debug.Log(ability2.act.CanPerform(chara, ability2.tg ?? tc));
                }
                return true;
            }
        }
        if (EClass.debug.logCombat)
        {
            Debug.Log(owner.Name + "/" + abilities.Count);
            foreach (ItemAbility ability3 in abilities)
            {
                Debug.Log(ability3.act.Name + "/" + ability3.priority);
            }
        }
        return false;
        void BuildCharaList()
        {
            if (charaBuilt)
            {
                return;
            }
            charas.Clear();
            charaBuilt = true;
            int sightRadius = owner.GetSightRadius();
            foreach (Chara chara2 in EClass._map.charas)
            {
                if (chara2 != owner)
                {
                    int num7 = owner.Dist(chara2);
                    if (num7 > sightRadius || !owner.CanSeeLos(chara2, num7))
                    {
                        continue;
                    }
                }
                charas.Add(chara2);
            }
        }
        int ForeachChara(ItemAbility a, Func<Chara, int> func, bool isFriendlyAbility)
        {
            if (a.act.TargetType.Range == TargetRange.Self)
            {
                a.tg = owner;
                return func(owner);
            }
            BuildCharaList();
            int num8 = 0;
            foreach (Chara chara3 in charas)
            {
                int num9 = func(chara3);
                if (num9 > 0)
                {
                    if (isFriendlyAbility)
                    {
                        if (owner.IsPCParty)
                        {
                            if (!chara3.IsPCParty)
                            {
                                continue;
                            }
                        }
                        else if (!owner.IsFriendOrAbove(chara3))
                        {
                            continue;
                        }
                        if (chara3 != owner)
                        {
                            num9 += tactics.P_Party;
                        }
                    }
                    else if (!owner.IsHostile(chara3))
                    {
                        continue;
                    }
                    if (num9 >= num8)
                    {
                        a.tg = chara3;
                        num8 = num9;
                    }
                }
            }
            return num8;
        }
        int GetAttackMod(Act a)
        {
            if (!owner.IsPCParty || a.source.aliasRef.IsEmpty())
            {
                return 0;
            }
            int num5 = ((a.source.aliasRef == "mold") ? owner.MainElement.id : EClass.sources.elements.alias[a.source.aliasRef].id);
            int num6 = -15 * tc.ResistLvFrom(num5);
            switch (num5)
            {
            case 910:
                if (tc.isWet)
                {
                    num6 -= 30;
                }
                break;
            case 911:
                if (tc.HasCondition<ConBurning>())
                {
                    num6 -= 30;
                }
                break;
            case 912:
                if (tc.isWet)
                {
                    num6 += 30;
                }
                break;
            }
            return num6;
        }
        void GetNumEnemy(int radius)
        {
            if (numEnemy != -1)
            {
                return;
            }
            BuildCharaList();
            numEnemy = 0;
            foreach (Chara chara4 in charas)
            {
                if (chara4.host == null && owner.IsHostile(chara4) && owner.Dist(chara4) < radius && owner.CanSeeLos(chara4))
                {
                    numEnemy++;
                }
            }
        }
        int GetNumNeutral(int radius)
        {
            if (numNeutral != -1)
            {
                return numNeutral;
            }
            BuildCharaList();
            numNeutral = 0;
            foreach (Chara chara5 in charas)
            {
                if (!chara5.IsPCFactionOrMinion && chara5.IsNeutralOrAbove() && owner.Dist(chara5) <= radius && owner.CanSeeLos(chara5))
                {
                    numNeutral++;
                }
            }
            return numNeutral;
        }
    }

References EClass._map, EClass._zone, abilities, Tactics.AbilityChance, SourceElement.Row.abilityType, Element.act, GoalCombat.ItemAbility.act, GoalCombat.ItemAbility.aiPt, Chara.body, Act.CanPerform(), Chara.CanSeeLos(), Tactics.CastPartyBuff, charas, Map.charas, Chara.conditions, Act.Cost.cost, Zone.CountMinions(), EClass.debug, Debug, Card.Dist(), SourceManager.elements, TargetType.ForceParty, Chara.GetBuffStats(), Element.GetCost(), CharaBody.GetMeleeDistance(), Card.GetSightRadius(), Chara.HasCondition(), Card.HasElement(), Card.HasTag(), Element.HasTag(), Act.HaveLongPressAction, Chara.host, Card.hp, Card.id, Element.id, Chara.isBlind, Chara.isConfused, Chara.IsFriendOrAbove(), Chara.IsHostile(), Chara.IsNeutralOrAbove(), Chara.IsPC, Chara.IsPCFaction, Zone.IsPCFaction, Card.IsPCFactionOrMinion, Chara.IsPCParty, Card.isRestrained, Card.IsRestrainedResident, Act.IsTargetHostileParty(), Zone.IsTown, Chara.isWet, Player.lastEmptyAlly, CoreDebug.logCombat, Chara.MainElement, Chara.mana, Chara.MaxHP, Chara.MaxSummon, Party.members, Card.Name, Element.Name, AIAct.owner, Tactics.P_Buff, Tactics.P_Debuff, Tactics.P_Melee, Tactics.P_Party, Tactics.P_Range, Tactics.P_Spell, Tactics.P_Summon, Chara.party, EClass.pc, EClass.player, GoalCombat.ItemAbility.priority, GoalCombat.ItemAbility.priorityMod, SourceElement.Row.proc, GoalCombat.ItemAbility.pt, Tactics.RandomFacotr, TargetType.Range, Chara.ranged, Tactics.RangedChance, Card.ResistLvFrom(), EClass.rnd(), Element.source, Tactics.source, EClass.sources, Chara.stamina, tactics, SourceElement.Row.target, Act.TargetType, tc, GoalCombat.ItemAbility.tg, AIAct.ToString(), Chara.ToString(), Card.trait, TryThrow(), TryUseRanged(), Act.Cost.type, Chara.UseAbility(), Element.Value, Stats.value, and Element.vPotential.

Referenced by Run().

◆ TryUseRanged()

virtual bool GoalCombat.TryUseRanged ( int dist )

inlinevirtual

Reimplemented in GoalAutoCombat.

Definition at line 419 of file GoalCombat.cs.

    {
        if (owner.TryEquipRanged())
        {
            return ACT.Ranged.Perform(owner, tc);
        }
        return false;
    }

References AIAct.owner, ActRanged.Perform(), ACT.Ranged, tc, and Chara.TryEquipRanged().

Referenced by TryUseAbility().

Member Data Documentation

◆ abilities

List<ItemAbility> GoalCombat.abilities

Definition at line 32 of file GoalCombat.cs.

Referenced by AddAbility(), Run(), and TryUseAbility().

◆ charas

List<Chara> GoalCombat.charas = new List<Chara>()

Definition at line 34 of file GoalCombat.cs.

Referenced by TryUseAbility().

◆ destEnemy

Chara GoalCombat.destEnemy

Definition at line 24 of file GoalCombat.cs.

Referenced by GoalAutoCombat.GoalAutoCombat(), and Run().

◆ idleCount

int GoalCombat.idleCount

Definition at line 28 of file GoalCombat.cs.

Referenced by Run().

◆ moveFail

int GoalCombat.moveFail

Definition at line 30 of file GoalCombat.cs.

Referenced by TryMove().

◆ tc

Chara GoalCombat.tc

Definition at line 26 of file GoalCombat.cs.

Referenced by Run(), TryMove(), TryThrow(), TryUseAbility(), GoalAutoCombat.TryUseRanged(), and TryUseRanged().

Property Documentation

◆ CancelOnAggro

override bool GoalCombat.CancelOnAggro

get

Definition at line 40 of file GoalCombat.cs.

◆ CancelWhenDamaged

override bool GoalCombat.CancelWhenDamaged

get

Definition at line 38 of file GoalCombat.cs.

◆ CursorIcon

override CursorInfo GoalCombat.CursorIcon

get

Definition at line 36 of file GoalCombat.cs.

◆ tactics

Tactics GoalCombat.tactics

get

Definition at line 42 of file GoalCombat.cs.

Referenced by Run(), TryMove(), and TryUseAbility().

The documentation for this class was generated from the following file:

Elin/GoalCombat.cs

Classes

Public Member Functions

Public Attributes

Properties

Additional Inherited Members

Detailed Description

Member Function Documentation

◆ AddAbility()

◆ BuildAbilityList()

◆ CanManualCancel()

◆ Run()

◆ TryAbortCombat()

◆ TryMove()

◆ TryThrow()

◆ TryUseAbility()

◆ TryUseRanged()

Member Data Documentation

◆ abilities

◆ charas

◆ destEnemy

◆ idleCount

◆ moveFail

◆ tc

Property Documentation

◆ CancelOnAggro

◆ CancelWhenDamaged

◆ CursorIcon

◆ tactics