Elin Decompiled Documentation EA 23.104 Nightly
Loading...
Searching...
No Matches
GoalCombat Class Reference
Inheritance diagram for GoalCombat:
Goal AIAct Act Element EClass GoalAutoCombat

Classes

class  ItemAbility
 

Public Member Functions

override bool CanManualCancel ()
 
override IEnumerable< StatusRun ()
 
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< StatusRun ()
 
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< ItemAbilityabilities
 
List< Characharas = new List<Chara>()
 
- Public Attributes inherited from AIAct
new Chara owner
 
Status status
 
IEnumerator< StatusEnumerator
 
AIAct child
 
AIAct parent
 
byte restartCount
 
Func< StatusonChildFail
 
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.RowListElements = new List<SourceElement.Row>()
 
static List< SourceElement.RowListAttackElements = 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.

409 {
410 abilities.Add(new ItemAbility
411 {
412 act = a,
413 priorityMod = mod,
414 chance = chance,
415 aiPt = aiPt
416 });
417 }
Act act
Definition: ELEMENT.cs:388
List< ItemAbility > abilities
Definition: GoalCombat.cs:32

References abilities, and Element.act.

Referenced by BuildAbilityList().

◆ BuildAbilityList()

virtual void GoalCombat.BuildAbilityList ( )
inlinevirtual

Reimplemented in GoalAutoCombat.

Definition at line 1061 of file GoalCombat.cs.

1062 {
1063 foreach (ActList.Item item in owner.ability.list.items)
1064 {
1065 AddAbility(item.act, 0, item.chance, item.pt);
1066 }
1070 }
Definition: ACT.cs:6
static ActRanged Ranged
Definition: ACT.cs:17
static ActMelee Melee
Definition: ACT.cs:15
static ActItem Item
Definition: ACT.cs:21
new Chara owner
Definition: AIAct.cs:14
List< Item > items
Definition: ActList.cs:14
ActList list
Definition: CharaAbility.cs:12
CharaAbility ability
Definition: Chara.cs:409
void AddAbility(Act a, int mod=0, int chance=100, bool aiPt=false)
Definition: GoalCombat.cs:408

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.

45 {
46 return true;
47 }

◆ Run()

override IEnumerable< Status > GoalCombat.Run ( )
inlinevirtual

Reimplemented from AIAct.

Definition at line 49 of file GoalCombat.cs.

50 {
51 if (destEnemy != null)
52 {
53 owner.enemy = destEnemy;
54 destEnemy = null;
55 }
56 int count = 0;
57 int lostCount = 0;
58 bool dontWander = owner.IsPCParty && !owner.IsPC && EClass.game.config.tactics.dontWander;
59 while (true)
60 {
61 bool canSeeLos = false;
63 {
64 Debug.Log("â– " + owner.Name + "/" + count + "/" + lostCount);
65 }
67 {
68 owner.enemy = null;
69 owner.ShowEmo(Emo.happy);
70 yield return Success();
71 }
72 count++;
73 if (dontWander && owner.enemy != null && !EClass.pc.isBlind && !EClass.pc.CanSeeLos(owner.enemy) && (owner.Dist(EClass.pc) > 4 || owner.Dist(owner.enemy) > 1))
74 {
76 if (firstStep.IsValid && !firstStep.HasChara)
77 {
78 owner.enemy = null;
79 }
80 }
81 tc = owner.enemy;
82 if (tc != null && owner.IsPCFaction)
83 {
85 {
86 owner.enemy = null;
87 yield return Success();
88 }
90 {
91 tc = (owner.enemy = null);
92 }
93 }
94 if (tc == null || tc.isDead || !tc.ExistsOnMap || !tc.pos.IsInBounds || lostCount >= (owner.IsPowerful ? 50 : 5) || !owner.CanSee(tc))
95 {
96 tc = (owner.enemy = null);
98 {
99 yield return Success();
100 }
102 lostCount = 0;
103 if (owner.enemy == null)
104 {
105 yield return Success();
106 }
107 tc = owner.enemy;
108 }
109 else
110 {
111 canSeeLos = owner.CanSeeLos(tc);
112 lostCount = ((!canSeeLos) ? (lostCount + 1) : 0);
113 }
114 if (owner.IsPC && tc.HasEditorTag(EditorTag.Invulnerable))
115 {
116 Msg.Say("abort_idle");
117 yield return Success();
118 }
119 if (tc.IsPCFaction && owner.id == "melilith_boss" && EClass._map.plDay.list.Count > 1 && EClass._map.plDay.list[0].data.id != 107)
120 {
121 EClass._zone.SetBGM(107);
122 }
123 if (abilities == null)
124 {
125 abilities = new List<ItemAbility>();
127 }
128 if (owner.IsPCFaction && tc.IsPCFaction && EClass.rnd(5) == 0 && count > 2)
129 {
130 CalmDown();
131 yield return Success();
132 }
134 {
135 if (owner.calmCheckTurn < 0 || (!owner.enemy.IsPCParty && EClass.rnd(10) == 0))
136 {
137 CalmDown();
138 yield return Success();
139 }
141 }
142 if (owner.IsPC)
143 {
144 CursorSystem.ignoreCount = 1;
145 }
146 if (tc.host != null && (tc.hp == 0 || EClass.rnd(5) == 0))
147 {
149 }
150 if (tc.parasite != null && !tc.isRestrained && tc.parasite.hp > 0 && EClass.rnd(5) == 0)
151 {
153 }
154 if (tc.ride != null && !tc.isRestrained && tc.ride.hp > 0 && EClass.rnd(5) == 0)
155 {
157 }
158 if (tc.enemy != null)
159 {
161 }
162 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))
163 {
164 owner.Say("dominate_machine", tc, owner);
165 owner.PlayEffect("boost");
166 owner.PlaySound("boost");
167 owner.ShowEmo(Emo.love);
168 owner.lastEmo = Emo.angry;
170 yield return Success();
171 }
172 if (EClass.rnd(5) == 0 && tc.HasElement(1325) && owner.race.IsPlant && owner.CanBeTempAlly(tc))
173 {
174 owner.Say("dominate_plant", tc, owner);
175 owner.ShowEmo(Emo.love);
176 owner.lastEmo = Emo.angry;
178 yield return Success();
179 }
180 if (EClass.rnd(20) == 0 && owner.isRestrained)
181 {
182 owner.Talk("restrained");
183 }
184 if (this is GoalAutoCombat)
185 {
187 EClass.pc.ModExp(135, 20);
188 }
189 int dist = owner.Dist(tc);
190 bool move = owner.host == null && (tactics.ChanceMove > EClass.rnd(100) || (owner.IsPC && tc.HasCondition<ConFear>() && dist >= EClass.pc.GetSightRadius() - 1));
191 bool haltSecondMove = false;
192 if (!owner.IsPC && owner.IsNeutralOrAbove() && !owner.isBlind && !owner.isSummon && !owner.IsMinion)
193 {
194 int num = -1;
195 if (tc.HasElement(1221))
196 {
197 num = 1;
198 }
199 if (tc.source.HasTag(CTAG.suicide) && !tc.HasCondition<ConWet>())
200 {
201 num = 3;
202 }
203 if (num > 0)
204 {
205 if (dist <= num)
206 {
207 if (EClass.rnd(15) == 0)
208 {
209 owner.Talk("run_suicide");
210 }
211 if (owner.host == null && owner.TryMoveFrom(tc.pos) != 0)
212 {
213 yield return Status.Running;
214 idleCount = 0;
215 continue;
216 }
218 {
219 Debug.Log("Failed to Run: " + owner.Name);
220 }
221 }
222 if (dist == num + 1)
223 {
224 haltSecondMove = true;
225 move = false;
226 idleCount = 0;
227 }
228 }
229 }
230 if (dontWander)
231 {
232 int num2 = owner.Dist(EClass.pc);
233 if (num2 > 3)
234 {
235 int x = tc.pos.x;
236 int z = tc.pos.z;
237 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)
238 {
239 move = false;
240 haltSecondMove = true;
241 }
242 }
243 }
244 if ((owner.IsPC && EClass.game.config.autoCombat.bDontChase) || (!canSeeLos && tc.isHidden))
245 {
246 move = false;
247 haltSecondMove = true;
248 }
250 {
251 Debug.Log(owner.Name + "/" + move + "/" + haltSecondMove + "/" + dist);
252 }
253 if (move)
254 {
255 if (owner.IsPC && dist <= owner.GetSightRadius() && TryUseAbility(dist, beforeMove: true))
256 {
257 yield return Status.Running;
258 idleCount = 0;
259 continue;
260 }
261 if (TryMove(dist))
262 {
264 {
265 Debug.Log("moved:" + owner.Name);
266 }
267 yield return Status.Running;
268 idleCount = 0;
269 continue;
270 }
271 }
272 if (owner == null)
273 {
274 yield return Cancel();
275 }
276 if (dist <= owner.GetSightRadius() && TryUseAbility(dist))
277 {
278 yield return Status.Running;
279 idleCount = 0;
280 continue;
281 }
283 {
284 Debug.Log(owner.Name + "/" + move + "/" + haltSecondMove + "/" + tactics.ChanceSecondMove);
285 }
286 if (!move && !haltSecondMove && tactics.ChanceSecondMove > EClass.rnd(100) && TryMove(dist))
287 {
288 yield return Status.Running;
289 idleCount = 0;
290 continue;
291 }
292 if (owner == null)
293 {
294 yield return Cancel();
295 }
296 idleCount++;
297 if (TryAbortCombat())
298 {
299 yield return Success();
300 }
301 if (idleCount > 2)
302 {
303 if (dontWander)
304 {
305 yield return Success();
306 }
307 idleCount = 0;
308 string aiIdle = owner.source.aiIdle;
309 if (aiIdle == "stand" || aiIdle == "root")
310 {
311 yield return Success();
312 }
313 yield return DoGoto(tc.pos);
314 }
315 else if (owner.FindNearestNewEnemy())
316 {
317 yield return Status.Running;
318 continue;
319 }
320 yield return Status.Running;
321 }
322 void CalmDown()
323 {
324 owner.enemy = null;
325 if (owner.ride != null)
326 {
327 owner.ride.enemy = null;
328 }
329 if (owner.parasite != null)
330 {
331 owner.parasite.enemy = null;
332 }
333 owner.hostility = owner.OriginalHostility;
334 if (tc.enemy == owner)
335 {
336 tc.enemy = null;
337 if (tc.ride != null)
338 {
339 tc.ride.enemy = null;
340 }
341 if (tc.parasite != null)
342 {
343 tc.parasite.enemy = null;
344 }
345 tc.hostility = tc.OriginalHostility;
346 }
347 owner.Say("calmDown", owner);
348 }
349 }
BossType
Definition: BossType.cs:2
CTAG
Definition: CTAG.cs:2
EditorTag
Definition: EditorTag.cs:2
Emo
Definition: Emo.cs:2
Hostility
Definition: Hostility.cs:2
MinionType
Definition: MinionType.cs:2
virtual Status Cancel()
Definition: AIAct.cs:291
virtual bool ShouldAllyAttack(Chara tg)
Definition: AIAct.cs:134
Status
Definition: AIAct.cs:8
Status DoGoto(Point pos, int dist=0, bool ignoreConnection=false, Func< Status > _onChildFail=null)
Definition: AIAct.cs:432
void SetTurbo(int mtp=-1)
Definition: AM_Adv.cs:1040
static AM_Adv Adv
Definition: ActionMode.cs:15
bool IsPCFactionOrMinion
Definition: Card.cs:2132
string id
Definition: Card.cs:31
int GetSightRadius()
Definition: Card.cs:5649
bool HasElement(int ele, int req=1)
Definition: Card.cs:5214
bool isRestrained
Definition: Card.cs:538
SoundSource PlaySound(string id, float v=1f, bool spatial=true)
Definition: Card.cs:5404
void Talk(string idTopic, string ref1=null, string ref2=null, bool forceSync=false)
Definition: Card.cs:5949
int hp
Definition: Card.cs:226
string Name
Definition: Card.cs:2013
bool ExistsOnMap
Definition: Card.cs:1961
Point pos
Definition: Card.cs:55
int DEX
Definition: Card.cs:2195
Effect PlayEffect(string id, bool useRenderPos=true, float range=0f, Vector3 fix=default(Vector3))
Definition: Card.cs:5438
void ShowEmo(Emo _emo=Emo.none, float duration=0f, bool skipSame=true)
Definition: Card.cs:5372
bool IsPowerful
Definition: Card.cs:1970
bool HasEditorTag(EditorTag tag)
Definition: Card.cs:2460
BossType c_bossType
Definition: Card.cs:1157
int Dist(Card c)
Definition: Card.cs:6781
bool isHidden
Definition: Card.cs:502
void ModExp(string alias, int a)
Definition: Card.cs:2508
int LV
Definition: Card.cs:370
void Say(string lang, string ref1=null, string ref2=null)
Definition: Card.cs:6046
new TraitChara trait
Definition: Chara.cs:488
Hostility OriginalHostility
Definition: Chara.cs:456
AIAct ai
Definition: Chara.cs:187
MoveResult TryMoveFrom(Point p)
Definition: Chara.cs:2382
override bool IsPC
Definition: Chara.cs:597
Chara host
Definition: Chara.cs:33
Point GetFirstStep(Point newPoint, PathManager.MoveType moveType=PathManager.MoveType.Default)
Definition: Chara.cs:2279
bool CanSeeLos(Card c, int dist=-1)
Definition: Chara.cs:1059
override bool IsPCParty
Definition: Chara.cs:600
bool HasCondition(string alias)
Definition: Chara.cs:8583
bool IsNeutralOrAbove()
Definition: Chara.cs:5928
override bool IsMinion
Definition: Chara.cs:612
override bool IsPCFaction
Definition: Chara.cs:656
int calmCheckTurn
Definition: Chara.cs:113
void MakeMinion(Chara _master, MinionType type=MinionType.Default)
Definition: Chara.cs:2058
bool CanSee(Card c)
Definition: Chara.cs:1027
override bool IsPCFactionMinion
Definition: Chara.cs:640
SourceChara.Row source
Definition: Chara.cs:143
bool FindNewEnemy()
Definition: Chara.cs:5800
Chara parasite
Definition: Chara.cs:30
Chara ride
Definition: Chara.cs:27
bool CanBeTempAlly(Chara c)
Definition: Chara.cs:2045
bool FindNearestNewEnemy()
Definition: Chara.cs:5869
Chara enemy
Definition: Chara.cs:83
Chara SetEnemy(Chara c=null)
Definition: Chara.cs:5658
bool isBlind
Definition: Chara.cs:125
bool isDead
Definition: Chara.cs:374
void TrySetEnemy(Chara c)
Definition: Chara.cs:5675
SourceRace.Row race
Definition: Chara.cs:449
Definition: ConWet.cs:2
bool logCombat
Definition: CoreDebug.cs:244
Definition: EClass.cs:5
static Game game
Definition: EClass.cs:8
static int rnd(int a)
Definition: EClass.cs:50
static Zone _zone
Definition: EClass.cs:20
static Map _map
Definition: EClass.cs:18
static Player player
Definition: EClass.cs:12
static Chara pc
Definition: EClass.cs:14
static CoreDebug debug
Definition: EClass.cs:48
ConfigTactics tactics
Definition: Game.cs:90
ConfigAutoCombat autoCombat
Definition: Game.cs:93
Config config
Definition: Game.cs:215
virtual void BuildAbilityList()
Definition: GoalCombat.cs:1061
Chara tc
Definition: GoalCombat.cs:26
Tactics tactics
Definition: GoalCombat.cs:42
int idleCount
Definition: GoalCombat.cs:28
virtual bool TryAbortCombat()
Definition: GoalCombat.cs:1072
bool TryMove(int dist)
Definition: GoalCombat.cs:351
Chara destEnemy
Definition: GoalCombat.cs:24
virtual bool TryUseAbility(int dist, bool beforeMove=false)
Definition: GoalCombat.cs:447
Playlist plDay
Definition: Map.cs:77
Definition: Msg.cs:5
static string Say(string idLang, string ref1, string ref2=null, string ref3=null, string ref4=null)
Definition: Msg.cs:58
bool IsCriminal
Definition: Player.cs:1138
Definition: Point.cs:9
int x
Definition: Point.cs:36
int z
Definition: Point.cs:39
bool IsValid
Definition: Point.cs:88
int Distance(Point p)
Definition: Point.cs:953
bool IsInBounds
Definition: Point.cs:104
bool HasChara
Definition: Point.cs:226
bool isPeace
Definition: Spatial.cs:406
int ChanceSecondMove
Definition: Tactics.cs:56
void SetBGM(List< int > ids, bool refresh=true)
Definition: Zone.cs:2706

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 1072 of file GoalCombat.cs.

1073 {
1074 return false;
1075 }

Referenced by Run().

◆ TryMove()

bool GoalCombat.TryMove ( int  dist)
inline

Definition at line 351 of file GoalCombat.cs.

352 {
354 {
355 Debug.Log("TryMove: " + owner.Name + "/" + dist);
356 }
357 if (owner.host != null)
358 {
359 return false;
360 }
361 if (owner.isBlind)
362 {
363 return owner.MoveRandom();
364 }
365 int num = (tc.HasCondition<ConFear>() ? 1 : tactics.DestDist);
366 if (!owner.IsPC && (tactics.source.id == "archer" || tactics.source.id == "gunner") && !owner.TryEquipRanged())
367 {
368 num = 1;
369 }
370 if (!owner.IsPC && num > 1)
371 {
372 if (tactics.DestDist == 2)
373 {
374 if (EClass.rnd(5) == 0)
375 {
376 num = 1;
377 }
378 }
379 else if (owner.turn / 3 % 5 > 2)
380 {
381 num--;
382 }
383 }
384 bool flag = false;
385 if (dist > num)
386 {
387 flag = owner.TryMoveTowards(tc.pos) != Card.MoveResult.Fail;
388 if (!flag)
389 {
390 moveFail++;
391 }
392 }
393 else if (dist < num)
394 {
395 flag = owner.TryMoveFrom(tc.pos) != Card.MoveResult.Fail;
396 }
397 if (flag)
398 {
399 moveFail = 0;
400 }
402 {
403 Debug.Log("TryMove:" + owner.Name + "/" + flag + "/" + dist + "/" + num);
404 }
405 return flag;
406 }
Definition: Card.cs:11
MoveResult
Definition: Card.cs:13
int turn
Definition: Card.cs:61
bool MoveRandom()
Definition: Chara.cs:2284
MoveResult TryMoveTowards(Point p)
Definition: Chara.cs:2320
bool TryEquipRanged()
Definition: Chara.cs:7091
int moveFail
Definition: GoalCombat.cs:30
int DestDist
Definition: Tactics.cs:24
SourceTactics.Row source
Definition: Tactics.cs:3

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.

429 {
430 if (dist > owner.GetSightRadius())
431 {
432 return false;
433 }
434 Thing thing = owner.TryGetThrowable();
435 if (thing == null)
436 {
437 return false;
438 }
439 if (!ACT.Throw.CanPerform(owner, tc, tc.pos))
440 {
441 return false;
442 }
443 ActThrow.Throw(owner, tc.pos, tc, thing.HasElement(410) ? thing : thing.Split(1));
444 return true;
445 }
static ActThrow Throw
Definition: ACT.cs:19
static EffectIRenderer Throw(Card c, Point p, Thing t, ThrowMethod method=ThrowMethod.Default, float failChance=0f)
Definition: ActThrow.cs:93
override bool CanPerform()
Definition: ActThrow.cs:25
Thing Split(int a)
Definition: Card.cs:3231
Thing TryGetThrowable()
Definition: Chara.cs:7015
Definition: Thing.cs:8

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.

448 {
449 if (abilities.Count == 0)
450 {
451 Debug.Log("no ability:" + owner);
452 return false;
453 }
454 int numEnemy = -1;
455 int numFriend = -1;
456 int numNeutral = -1;
457 bool charaBuilt = false;
458 bool flag = owner.CanSeeLos(tc, dist);
459 bool isPCFaction = owner.IsPCFaction;
460 bool flag2 = owner.HasCondition<ConSilence>();
461 bool isBlind = owner.isBlind;
462 bool flag3 = owner.HasCondition<ConFear>();
463 bool isConfused = owner.isConfused;
464 bool flag4 = owner.HasCondition<ConDim>();
465 bool flag5 = owner.HasCondition<ConSupress>();
466 foreach (ItemAbility ability in abilities)
467 {
468 Act act = ability.act;
469 ability.priority = 0;
470 ability.tg = null;
471 ability.pt = false;
472 if (EClass.rnd(100) >= ability.chance || (isBlind && ability.act.HasTag("reqSight")))
473 {
474 continue;
475 }
476 int num = 0;
478 if (s.abilityType.Length == 0 || (owner.IsPC && flag2 && act is Spell) || (beforeMove && !act.HasTag("before_move")))
479 {
480 continue;
481 }
482 string text = s.abilityType[0];
483 if (flag5 && !(text == "melee") && !(text == "range") && EClass.rnd(2) == 0)
484 {
485 continue;
486 }
487 switch (act.id)
488 {
489 case 6603:
490 if (!tc.IsPCParty || tc.Evalue(418) < 0)
491 {
492 break;
493 }
494 foreach (Chara member in EClass.pc.party.members)
495 {
496 if (member.Evalue(418) < 0)
497 {
498 owner.enemy = (tc = member);
499 return false;
500 }
501 }
502 break;
503 case 6602:
504 if (dist <= 1 || tc.HasCondition<ConEntangle>())
505 {
506 continue;
507 }
508 break;
509 case 6450:
510 if (isPCFaction && (tc.HasElement(1221) || tc.HasElement(1223) || tc.id == "hedgehog_ether"))
511 {
512 continue;
513 }
514 break;
515 case 8200:
516 case 8201:
517 if (owner.HasElement(400))
518 {
519 continue;
520 }
521 break;
522 case 6400:
523 if (isPCFaction)
524 {
525 continue;
526 }
527 break;
528 case 8790:
529 case 8791:
530 if (tc.host != null)
531 {
532 continue;
533 }
534 break;
535 }
536 bool isHOT;
537 switch (text)
538 {
539 case "item":
540 num = (ability.act as ActItem).BuildAct(owner);
541 break;
542 case "wait":
543 if (owner.IsPCParty)
544 {
545 continue;
546 }
547 num = 50;
548 break;
549 case "taunt":
550 {
551 bool flag6 = owner.HasCondition<StanceTaunt>();
552 bool flag7 = tactics.source.taunt != -1 && 100 * owner.hp / owner.MaxHP >= tactics.source.taunt;
553 num = ((flag6 && !flag7) ? 100 : ((!flag6 && flag7) ? 100 : 0));
554 break;
555 }
556 case "melee":
557 if (dist > owner.body.GetMeleeDistance())
558 {
559 continue;
560 }
561 num = ((!flag3) ? tactics.P_Melee : ((!owner.IsPC) ? (tactics.P_Melee / 2) : 0));
562 if (isConfused)
563 {
564 num -= (owner.IsPC ? 30 : 10);
565 }
566 if (isBlind)
567 {
568 num -= (owner.IsPC ? 50 : 10);
569 }
570 if (dist <= 1)
571 {
572 if (tc.HasElement(1221))
573 {
574 num -= 40;
575 }
576 if (tc.HasElement(1223))
577 {
578 num -= 40;
579 }
580 if (!owner.IsPC && owner.IsPCFaction && tc.id == "hedgehog_ether")
581 {
582 continue;
583 }
584 if (!owner.IsPCFaction && num < 10)
585 {
586 num = 10;
587 }
588 }
589 break;
590 case "range":
591 if (!flag || EClass.rnd(100) > tactics.RangedChance)
592 {
593 continue;
594 }
595 num = ((!flag3) ? tactics.P_Range : ((!owner.IsPC) ? (tactics.P_Range / 2) : 0));
596 if (isConfused)
597 {
598 num -= (owner.IsPC ? 30 : 10);
599 }
600 if (isBlind)
601 {
602 num -= (owner.IsPC ? 50 : 10);
603 }
604 if (owner.ranged != null && owner.ranged.trait is TraitToolRangeCane && owner.mana.value <= 0)
605 {
606 continue;
607 }
608 break;
609 case "teleport":
610 num = 40;
611 break;
612 case "any":
613 num = 50;
614 break;
615 case "hot":
616 case "heal":
617 isHOT = text == "hot";
618 num = ForeachChara(ability, (Chara c) => HealFactor(c), isFriendlyAbility: true);
619 if (ability.aiPt || (owner.IsPC && tactics.CastPartyBuff))
620 {
621 ability.pt = true;
622 }
623 break;
624 case "dot":
625 case "attack":
626 case "attackMelee":
627 {
628 if (!flag)
629 {
630 continue;
631 }
632 bool flag8 = text == "dot";
633 if (flag8 && (owner.isRestrained || (tc != null && tc.IsRestrainedResident)))
634 {
635 continue;
636 }
637 num = ((text == "attackMelee") ? tactics.P_Melee : tactics.P_Spell) + GetAttackMod(act);
638 if (num > 0 && flag8)
639 {
640 num += 10;
641 }
642 if (ability.aiPt)
643 {
644 ability.pt = true;
645 }
646 break;
647 }
648 case "attackArea":
649 {
650 if (owner.isRestrained || (tc != null && tc.IsRestrainedResident))
651 {
652 continue;
653 }
654 bool flag9 = ability.act is ActBolt;
656 {
657 continue;
658 }
659 GetNumEnemy(flag9 ? 6 : 5);
660 if (numEnemy == 0 || (owner.IsPCFactionOrMinion && GetNumNeutral(flag9 ? 6 : 5) > 0))
661 {
662 continue;
663 }
664 num = tactics.P_Spell - 20 + numEnemy * 10 + GetAttackMod(act);
665 break;
666 }
667 case "buff":
668 num = ForeachChara(ability, (Chara c) => (!c.HasCondition(s.proc[1])) ? tactics.P_Buff : 0, isFriendlyAbility: true);
669 if (ability.aiPt || (owner.IsPC && tactics.CastPartyBuff))
670 {
671 ability.pt = true;
672 }
673 break;
674 case "buffStats":
675 num = ForeachChara(ability, delegate(Chara c)
676 {
677 Element buffStats2 = c.GetBuffStats(s.proc[1]);
678 return (buffStats2 == null || buffStats2.Value < 0) ? tactics.P_Buff : 0;
679 }, isFriendlyAbility: true);
680 if (ability.aiPt || (owner.IsPC && tactics.CastPartyBuff))
681 {
682 ability.pt = true;
683 }
684 break;
685 case "debuff":
686 if (!flag)
687 {
688 continue;
689 }
690 num = tactics.P_Debuff;
691 if (ability.aiPt)
692 {
693 ability.pt = true;
694 }
695 break;
696 case "debuffStats":
697 if (!flag)
698 {
699 continue;
700 }
701 num = ForeachChara(ability, delegate(Chara c)
702 {
703 Element buffStats = c.GetBuffStats(s.proc[1]);
704 return (buffStats == null || buffStats.Value > 0) ? tactics.P_Debuff : 0;
705 }, isFriendlyAbility: false);
706 if (ability.aiPt)
707 {
708 ability.pt = true;
709 }
710 break;
711 case "ground":
712 if (!flag || owner.isRestrained || (tc != null && tc.IsRestrainedResident))
713 {
714 continue;
715 }
716 num = 50;
717 if (isPCFaction)
718 {
719 num -= 10;
720 }
721 break;
722 case "summon":
723 {
724 if (owner.isRestrained || (tc != null && tc.IsRestrainedResident))
725 {
726 continue;
727 }
728 int num2 = EClass._zone.CountMinions(owner);
729 if (num2 >= owner.MaxSummon)
730 {
731 continue;
732 }
733 num = tactics.P_Summon - 20 * num2 / owner.MaxSummon;
734 break;
735 }
736 case "summonAlly":
737 if (owner.isRestrained || (tc != null && tc.IsRestrainedResident))
738 {
739 continue;
740 }
741 if (owner.IsPC)
742 {
743 if (EClass.player.lastEmptyAlly <= 0)
744 {
745 continue;
746 }
747 }
748 else if (EClass._zone.CountMinions(owner) > 0)
749 {
750 continue;
751 }
752 num = tactics.P_Summon;
753 break;
754 case "suicide":
756 {
757 continue;
758 }
759 if (owner.HasTag(CTAG.kamikaze))
760 {
761 num = ((dist <= 1) ? 1000 : 0);
762 break;
763 }
764 num = 100 - 125 * owner.hp / owner.MaxHP;
765 if (EClass.rnd(200) <= num)
766 {
767 break;
768 }
769 continue;
770 default:
771 num = 0;
772 break;
773 }
774 if (s.target == "Neighbor")
775 {
776 if (dist > 1)
777 {
778 continue;
779 }
780 num += 10;
781 }
782 if (s.proc.Length != 0 && s.proc[0] == "Debuff" && tc.HasCondition(s.proc[1]))
783 {
784 continue;
785 }
786 if (s.abilityType.Length > 1)
787 {
788 num += (owner.IsPC ? s.abilityType[2] : s.abilityType[1]).ToInt();
789 }
790 if (act is Spell)
791 {
792 if (owner.IsPC)
793 {
794 if (act.vPotential <= 0)
795 {
796 continue;
797 }
798 if (flag2 || isConfused || flag4)
799 {
800 num -= 50;
801 }
802 }
803 else
804 {
805 if (flag2)
806 {
807 num -= 30;
808 }
809 if (isConfused || flag4)
810 {
811 num -= 10;
812 }
813 }
814 }
815 if (num > 0)
816 {
817 num += ability.priorityMod + EClass.rnd(tactics.RandomFacotr + ability.priorityMod);
818 }
819 ability.priority = num;
820 int HealFactor(Chara c)
821 {
822 if (isHOT && c.HasCondition(s.proc[1]))
823 {
824 return 0;
825 }
826 float num3 = (float)c.hp / (float)c.MaxHP;
827 if (num3 > (isHOT ? 0.85f : 0.75f))
828 {
829 return 0;
830 }
831 int num4 = tactics.P_Heal - (int)((float)tactics.P_Heal * num3) + (isHOT ? 50 : 25);
832 foreach (Condition condition in c.conditions)
833 {
834 if (condition is ConFear)
835 {
836 num4 += 10;
837 }
838 else if (condition is ConPoison)
839 {
840 num4 += 2;
841 }
842 else if (condition is ConConfuse)
843 {
844 num4 += 4;
845 }
846 else if (condition is ConDim)
847 {
848 num4 += 6;
849 }
850 else if (condition is ConBleed)
851 {
852 num4 += 8;
853 }
854 }
855 return num4;
856 }
857 }
858 abilities.Sort((ItemAbility a, ItemAbility b) => b.priority - a.priority);
859 foreach (ItemAbility ability2 in abilities)
860 {
861 if (ability2.priority <= 0)
862 {
863 continue;
864 }
866 {
867 Debug.Log(ability2.act.Name + "/" + ability2.priority);
868 }
869 if (ability2.act.source.alias == "ActRanged")
870 {
871 if (TryThrow(dist))
872 {
873 return true;
874 }
875 if (TryUseRanged(dist))
876 {
877 return true;
878 }
879 continue;
880 }
881 Cost cost = ability2.act.GetCost(owner);
882 if (owner.IsPCParty && ability2.pt && !ability2.act.IsTargetHostileParty() && !ability2.act.TargetType.ForceParty && cost.cost * EClass.pc.party.members.Count > owner.mana.value)
883 {
884 continue;
885 }
886 if (isPCFaction && cost.cost > 0)
887 {
888 switch (cost.type)
889 {
890 case CostType.MP:
891 if (cost.cost > owner.mana.value)
892 {
893 continue;
894 }
895 break;
896 case CostType.SP:
897 if (cost.cost > owner.stamina.value)
898 {
899 continue;
900 }
901 break;
902 }
903 }
904 if (cost.cost > 0 && EClass.rnd(100) > tactics.AbilityChance)
905 {
906 continue;
907 }
908 Chara chara = owner;
909 if (ability2.act.CanPerform(owner, ability2.tg ?? tc) && owner.UseAbility(ability2.act, ability2.tg ?? tc, null, (ability2.act.HaveLongPressAction && ability2.pt) || ability2.aiPt))
910 {
912 {
913 Debug.Log("Used Ability: " + chara?.ToString() + "/" + ability2.act?.ToString() + "/" + ability2.tg?.ToString() + "/" + tc);
914 Debug.Log(ability2.act.CanPerform(chara, ability2.tg ?? tc));
915 }
916 return true;
917 }
918 }
920 {
921 Debug.Log(owner.Name + "/" + abilities.Count);
922 foreach (ItemAbility ability3 in abilities)
923 {
924 Debug.Log(ability3.act.Name + "/" + ability3.priority);
925 }
926 }
927 return false;
928 void BuildCharaList()
929 {
930 if (charaBuilt)
931 {
932 return;
933 }
934 charas.Clear();
935 charaBuilt = true;
936 int sightRadius = owner.GetSightRadius();
937 foreach (Chara chara2 in EClass._map.charas)
938 {
939 if (chara2 != owner)
940 {
941 int num7 = owner.Dist(chara2);
942 if (num7 > sightRadius || !owner.CanSeeLos(chara2, num7))
943 {
944 continue;
945 }
946 }
947 charas.Add(chara2);
948 }
949 }
950 int ForeachChara(ItemAbility a, Func<Chara, int> func, bool isFriendlyAbility)
951 {
952 if (a.act.TargetType.Range == TargetRange.Self)
953 {
954 a.tg = owner;
955 return func(owner);
956 }
957 BuildCharaList();
958 int num8 = 0;
959 foreach (Chara chara3 in charas)
960 {
961 int num9 = func(chara3);
962 if (num9 > 0)
963 {
964 if (isFriendlyAbility)
965 {
966 if (owner.IsPCParty)
967 {
968 if (!chara3.IsPCParty)
969 {
970 continue;
971 }
972 }
973 else if (!owner.IsFriendOrAbove(chara3))
974 {
975 continue;
976 }
977 if (chara3 != owner)
978 {
979 num9 += tactics.P_Party;
980 }
981 }
982 else if (!owner.IsHostile(chara3))
983 {
984 continue;
985 }
986 if (num9 >= num8)
987 {
988 a.tg = chara3;
989 num8 = num9;
990 }
991 }
992 }
993 return num8;
994 }
995 int GetAttackMod(Act a)
996 {
997 if (!owner.IsPCParty || a.source.aliasRef.IsEmpty())
998 {
999 return 0;
1000 }
1001 int num5 = ((a.source.aliasRef == "mold") ? owner.MainElement.id : EClass.sources.elements.alias[a.source.aliasRef].id);
1002 int num6 = -15 * tc.ResistLvFrom(num5);
1003 switch (num5)
1004 {
1005 case 910:
1006 if (tc.isWet)
1007 {
1008 num6 -= 30;
1009 }
1010 break;
1011 case 911:
1012 if (tc.HasCondition<ConBurning>())
1013 {
1014 num6 -= 30;
1015 }
1016 break;
1017 case 912:
1018 if (tc.isWet)
1019 {
1020 num6 += 30;
1021 }
1022 break;
1023 }
1024 return num6;
1025 }
1026 void GetNumEnemy(int radius)
1027 {
1028 if (numEnemy != -1)
1029 {
1030 return;
1031 }
1032 BuildCharaList();
1033 numEnemy = 0;
1034 foreach (Chara chara4 in charas)
1035 {
1036 if (chara4.host == null && owner.IsHostile(chara4) && owner.Dist(chara4) < radius && owner.CanSeeLos(chara4))
1037 {
1038 numEnemy++;
1039 }
1040 }
1041 }
1042 int GetNumNeutral(int radius)
1043 {
1044 if (numNeutral != -1)
1045 {
1046 return numNeutral;
1047 }
1048 BuildCharaList();
1049 numNeutral = 0;
1050 foreach (Chara chara5 in charas)
1051 {
1052 if (!chara5.IsPCFactionOrMinion && chara5.IsNeutralOrAbove() && owner.Dist(chara5) <= radius && owner.CanSeeLos(chara5))
1053 {
1054 numNeutral++;
1055 }
1056 }
1057 return numNeutral;
1058 }
1059 }
TargetRange
Definition: TargetRange.cs:2
override string ToString()
Definition: AIAct.cs:124
Definition: ACT.cs:62
CostType
Definition: ACT.cs:64
bool IsRestrainedResident
Definition: Card.cs:2118
bool HasTag(CTAG tag)
Definition: Card.cs:2455
Trait trait
Definition: Card.cs:49
int Evalue(int ele)
Definition: Card.cs:2431
int ResistLvFrom(int ele)
Definition: Card.cs:5204
int GetMeleeDistance()
Definition: CharaBody.cs:414
Definition: Chara.cs:10
bool UseAbility(string idAct, Card tc=null, Point pos=null, bool pt=false)
Definition: Chara.cs:5228
Element MainElement
Definition: Chara.cs:702
CharaBody body
Definition: Chara.cs:91
Element GetBuffStats(string alias)
Definition: Chara.cs:8595
bool isWet
Definition: Chara.cs:137
Party party
Definition: Chara.cs:43
List< Condition > conditions
Definition: Chara.cs:196
int MaxSummon
Definition: Chara.cs:699
bool IsFriendOrAbove()
Definition: Chara.cs:5972
override int MaxHP
Definition: Chara.cs:693
Thing ranged
Definition: Chara.cs:95
Stats mana
Definition: Chara.cs:963
Stats stamina
Definition: Chara.cs:955
bool IsHostile()
Definition: Chara.cs:5884
bool isConfused
Definition: Chara.cs:121
Definition: ConDim.cs:2
static SourceManager sources
Definition: EClass.cs:42
int id
Definition: ELEMENT.cs:244
SourceElement.Row source
Definition: ELEMENT.cs:267
int vPotential
Definition: ELEMENT.cs:250
bool HasTag(string tag)
Definition: ELEMENT.cs:467
int Value
Definition: ELEMENT.cs:286
virtual bool TryUseRanged(int dist)
Definition: GoalCombat.cs:419
virtual bool TryThrow(int dist)
Definition: GoalCombat.cs:428
List< Chara > charas
Definition: GoalCombat.cs:34
List< Chara > charas
Definition: Map.cs:81
List< Chara > members
Definition: Party.cs:18
int lastEmptyAlly
Definition: Player.cs:994
string[] abilityType
SourceElement elements
Definition: SPELL.cs:468
virtual int value
Definition: Stats.cs:56
int RandomFacotr
Definition: Tactics.cs:12
int P_Party
Definition: Tactics.cs:71
int P_Spell
Definition: Tactics.cs:100
bool CastPartyBuff
Definition: Tactics.cs:118
int P_Debuff
Definition: Tactics.cs:113
int P_Buff
Definition: Tactics.cs:111
int P_Melee
Definition: Tactics.cs:74
int RangedChance
Definition: Tactics.cs:146
int AbilityChance
Definition: Tactics.cs:130
int P_Range
Definition: Tactics.cs:86
int P_Summon
Definition: Tactics.cs:115
int CountMinions(Chara c)
Definition: Zone.cs:3420
virtual bool IsTown
Definition: Zone.cs:220
bool IsPCFaction
Definition: Zone.cs:464

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, Card.Evalue(), 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.

420 {
421 if (owner.TryEquipRanged())
422 {
423 return ACT.Ranged.Perform(owner, tc);
424 }
425 return false;
426 }
override bool Perform()
Definition: ActRanged.cs:65

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

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: