AIAct.cs

using System;
using System.Collections.Generic;
using UnityEngine;
 
// Token: 0x020001DD RID: 477
public class AIAct : Act
{
    // Token: 0x1700036F RID: 879
    // (get) Token: 0x06000D7C RID: 3452 RVA: 0x000697D5 File Offset: 0x000679D5
    public virtual bool IsRunning
    {
        get
        {
            return this.status == AIAct.Status.Running && this.owner != null;
        }
    }
 
    // Token: 0x17000370 RID: 880
    // (get) Token: 0x06000D7D RID: 3453 RVA: 0x000697EA File Offset: 0x000679EA
    public bool IsChildRunning
    {
        get
        {
            return this.child != null && this.child.status == AIAct.Status.Running && this.child.owner != null;
        }
    }
 
    // Token: 0x17000371 RID: 881
    // (get) Token: 0x06000D7E RID: 3454 RVA: 0x00069811 File Offset: 0x00067A11
    public bool IsMoveAI
    {
        get
        {
            if (!this.IsChildRunning)
            {
                return this is AI_Goto;
            }
            return this.child.IsMoveAI;
        }
    }
 
    // Token: 0x17000372 RID: 882
    // (get) Token: 0x06000D7F RID: 3455 RVA: 0x00069830 File Offset: 0x00067A30
    public virtual int MaxRestart
    {
        get
        {
            return 5;
        }
    }
 
    // Token: 0x17000373 RID: 883
    // (get) Token: 0x06000D80 RID: 3456 RVA: 0x00069833 File Offset: 0x00067A33
    public new virtual string Name
    {
        get
        {
            return base.source.GetName();
        }
    }
 
    // Token: 0x06000D81 RID: 3457 RVA: 0x00069840 File Offset: 0x00067A40
    public override string ToString()
    {
        return base.GetType().Name;
    }
 
    // Token: 0x17000374 RID: 884
    // (get) Token: 0x06000D82 RID: 3458 RVA: 0x0006984D File Offset: 0x00067A4D
    protected virtual MultiSprite stateIcon
    {
        get
        {
            return null;
        }
    }
 
    // Token: 0x17000375 RID: 885
    // (get) Token: 0x06000D83 RID: 3459 RVA: 0x00069850 File Offset: 0x00067A50
    public virtual Sprite actionIcon
    {
        get
        {
            return EClass.core.refs.orbitIcons.Default;
        }
    }
 
    // Token: 0x17000376 RID: 886
    // (get) Token: 0x06000D84 RID: 3460 RVA: 0x00069866 File Offset: 0x00067A66
    public virtual bool IsNoGoal
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x17000377 RID: 887
    // (get) Token: 0x06000D85 RID: 3461 RVA: 0x00069869 File Offset: 0x00067A69
    public virtual bool IsAutoTurn
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x17000378 RID: 888
    // (get) Token: 0x06000D86 RID: 3462 RVA: 0x0006986C File Offset: 0x00067A6C
    public virtual bool IsIdle
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x17000379 RID: 889
    // (get) Token: 0x06000D87 RID: 3463 RVA: 0x0006986F File Offset: 0x00067A6F
    public virtual bool PushChara
    {
        get
        {
            return true;
        }
    }
 
    // Token: 0x1700037A RID: 890
    // (get) Token: 0x06000D88 RID: 3464 RVA: 0x00069872 File Offset: 0x00067A72
    public virtual int MaxProgress
    {
        get
        {
            return 20;
        }
    }
 
    // Token: 0x1700037B RID: 891
    // (get) Token: 0x06000D89 RID: 3465 RVA: 0x00069876 File Offset: 0x00067A76
    public virtual bool ShowProgress
    {
        get
        {
            return true;
        }
    }
 
    // Token: 0x1700037C RID: 892
    // (get) Token: 0x06000D8A RID: 3466 RVA: 0x00069879 File Offset: 0x00067A79
    public virtual bool UseTurbo
    {
        get
        {
            return true;
        }
    }
 
    // Token: 0x1700037D RID: 893
    // (get) Token: 0x06000D8B RID: 3467 RVA: 0x0006987C File Offset: 0x00067A7C
    public virtual int CurrentProgress
    {
        get
        {
            return 0;
        }
    }
 
    // Token: 0x1700037E RID: 894
    // (get) Token: 0x06000D8C RID: 3468 RVA: 0x0006987F File Offset: 0x00067A7F
    public virtual bool ShowCursor
    {
        get
        {
            return true;
        }
    }
 
    // Token: 0x1700037F RID: 895
    // (get) Token: 0x06000D8D RID: 3469 RVA: 0x00069882 File Offset: 0x00067A82
    public virtual bool CancelWhenDamaged
    {
        get
        {
            return true;
        }
    }
 
    // Token: 0x17000380 RID: 896
    // (get) Token: 0x06000D8E RID: 3470 RVA: 0x00069885 File Offset: 0x00067A85
    public virtual bool CancelWhenMoved
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x17000381 RID: 897
    // (get) Token: 0x06000D8F RID: 3471 RVA: 0x00069888 File Offset: 0x00067A88
    public virtual bool InformCancel
    {
        get
        {
            return true;
        }
    }
 
    // Token: 0x17000382 RID: 898
    // (get) Token: 0x06000D90 RID: 3472 RVA: 0x0006988B File Offset: 0x00067A8B
    public virtual Thing RenderThing
    {
        get
        {
            return null;
        }
    }
 
    // Token: 0x17000383 RID: 899
    // (get) Token: 0x06000D91 RID: 3473 RVA: 0x0006988E File Offset: 0x00067A8E
    public AIAct Current
    {
        get
        {
            if (!this.IsChildRunning)
            {
                return this;
            }
            return this.child.Current;
        }
    }
 
    // Token: 0x06000D92 RID: 3474 RVA: 0x000698A5 File Offset: 0x00067AA5
    public override MultiSprite GetStateIcon()
    {
        return (this.child ?? this).stateIcon;
    }
 
    // Token: 0x17000384 RID: 900
    // (get) Token: 0x06000D93 RID: 3475 RVA: 0x000698B7 File Offset: 0x00067AB7
    public override bool IsAct
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x17000385 RID: 901
    // (get) Token: 0x06000D94 RID: 3476 RVA: 0x000698BA File Offset: 0x00067ABA
    public override bool ShowPotential
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x17000386 RID: 902
    // (get) Token: 0x06000D95 RID: 3477 RVA: 0x000698BD File Offset: 0x00067ABD
    public override bool UsePotential
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x17000387 RID: 903
    // (get) Token: 0x06000D96 RID: 3478 RVA: 0x000698C0 File Offset: 0x00067AC0
    public override bool ShowRelativeAttribute
    {
        get
        {
            return true;
        }
    }
 
    // Token: 0x06000D97 RID: 3479 RVA: 0x000698C3 File Offset: 0x00067AC3
    public virtual Point GetDestination()
    {
        if (!this.IsChildRunning)
        {
            return this.owner.pos;
        }
        return this.child.GetDestination();
    }
 
    // Token: 0x06000D98 RID: 3480 RVA: 0x000698E4 File Offset: 0x00067AE4
    public AIProgress GetProgress()
    {
        if (this.IsChildRunning)
        {
            return this.child.GetProgress();
        }
        return this as AIProgress;
    }
 
    // Token: 0x06000D99 RID: 3481 RVA: 0x00069900 File Offset: 0x00067B00
    public string GetCurrentActionText()
    {
        if (this.IsChildRunning && this.child.source.id != 0 && !this.child.source.name_JP.IsEmpty())
        {
            return this.child.GetCurrentActionText();
        }
        return base.source.GetName().IsEmpty("idle".lang());
    }
 
    // Token: 0x06000D9A RID: 3482 RVA: 0x00069964 File Offset: 0x00067B64
    public override bool IsToolValid()
    {
        return this.owner == EClass.pc && Act.TOOL != null && Act.TOOL.parent == EClass.pc;
    }
 
    // Token: 0x06000D9B RID: 3483 RVA: 0x0006998D File Offset: 0x00067B8D
    public virtual void OnStart()
    {
    }
 
    // Token: 0x06000D9C RID: 3484 RVA: 0x0006998F File Offset: 0x00067B8F
    public void SetOwner(Chara c)
    {
        this.owner = c;
        this.status = AIAct.Status.Running;
        this.OnSetOwner();
    }
 
    // Token: 0x06000D9D RID: 3485 RVA: 0x000699A5 File Offset: 0x00067BA5
    public virtual void OnSetOwner()
    {
    }
 
    // Token: 0x06000D9E RID: 3486 RVA: 0x000699A8 File Offset: 0x00067BA8
    public void SetChild(AIAct seq, Func<AIAct.Status> _onChildFail = null)
    {
        if (this.child != null)
        {
            this.child.Reset();
        }
        this.child = seq;
        this.child.parent = this;
        this.child.SetOwner(this.owner);
        this.onChildFail = (_onChildFail ?? new Func<AIAct.Status>(this.Cancel));
    }
 
    // Token: 0x06000D9F RID: 3487 RVA: 0x00069A04 File Offset: 0x00067C04
    public void Start()
    {
        this.Enumerator = this.Run().GetEnumerator();
        this.OnStart();
        if (this.owner == null)
        {
            return;
        }
        if (this.owner.held != null)
        {
            if (this.DropHeldOnStart)
            {
                this.owner.DropHeld(null);
            }
            else if (this.PickHeldOnStart)
            {
                this.owner.PickHeld(false);
            }
        }
        if (this.RightHand != 0)
        {
            this.owner.SetTempHand(this.RightHand, this.LeftHand);
        }
        if (this.owner.IsPC && this.UseTurbo)
        {
            ActionMode.Adv.SetTurbo(-1);
        }
    }
 
    // Token: 0x06000DA0 RID: 3488 RVA: 0x00069AA8 File Offset: 0x00067CA8
    public override bool Perform()
    {
        Act.CC.SetAIImmediate(this);
        return false;
    }
 
    // Token: 0x06000DA1 RID: 3489 RVA: 0x00069AB8 File Offset: 0x00067CB8
    public AIAct.Status Restart()
    {
        this.restartCount += 1;
        if ((int)this.restartCount >= this.MaxRestart)
        {
            return this.Success(null);
        }
        byte b = this.restartCount;
        Chara chara = this.owner;
        this.Reset();
        this.SetOwner(chara);
        this.restartCount = b;
        return this.status = AIAct.Status.Running;
    }
 
    // Token: 0x06000DA2 RID: 3490 RVA: 0x00069B16 File Offset: 0x00067D16
    public AIAct.Status Success(Action action = null)
    {
        this.status = AIAct.Status.Success;
        this.OnSuccess();
        if (action != null)
        {
            action();
        }
        this.OnCancelOrSuccess();
        this.Reset();
        return this.status;
    }
 
    // Token: 0x06000DA3 RID: 3491 RVA: 0x00069B40 File Offset: 0x00067D40
    public virtual void OnSuccess()
    {
    }
 
    // Token: 0x06000DA4 RID: 3492 RVA: 0x00069B44 File Offset: 0x00067D44
    public bool TryCancel(Card c)
    {
        if (!this.IsRunning || this.Enumerator == null)
        {
            return false;
        }
        if (this.InformCancel)
        {
            if (this.owner.IsPC)
            {
                this.owner.Say("cancel_act_pc", this.owner, null, null);
            }
            else if (c != null)
            {
                this.owner.Say("cancel_act", this.owner, c, null, null);
            }
            else
            {
                this.owner.Say("cancel_act2", this.owner, null, null);
            }
        }
        this.Cancel();
        return true;
    }
 
    // Token: 0x06000DA5 RID: 3493 RVA: 0x00069BD0 File Offset: 0x00067DD0
    public virtual AIAct.Status Cancel()
    {
        this.status = AIAct.Status.Fail;
        if (this.owner != null && this.owner.held != null && !this.owner.IsPC)
        {
            this.owner.PickHeld(false);
        }
        this.OnCancel();
        this.OnCancelOrSuccess();
        this.Reset();
        return this.status;
    }
 
    // Token: 0x06000DA6 RID: 3494 RVA: 0x00069C2A File Offset: 0x00067E2A
    public virtual void OnCancel()
    {
    }
 
    // Token: 0x06000DA7 RID: 3495 RVA: 0x00069C2C File Offset: 0x00067E2C
    public virtual void OnCancelOrSuccess()
    {
    }
 
    // Token: 0x06000DA8 RID: 3496 RVA: 0x00069C2E File Offset: 0x00067E2E
    public virtual bool CanManualCancel()
    {
        return this.IsChildRunning && this.child is AI_Goto;
    }
 
    // Token: 0x06000DA9 RID: 3497 RVA: 0x00069C48 File Offset: 0x00067E48
    public AIAct.Status KeepRunning()
    {
        return AIAct.Status.Running;
    }
 
    // Token: 0x06000DAA RID: 3498 RVA: 0x00069C4C File Offset: 0x00067E4C
    public void Reset()
    {
        if (this.owner == null)
        {
            return;
        }
        if (this.child != null)
        {
            this.child.Reset();
        }
        this.OnReset();
        if (this.Enumerator != null)
        {
            this.Enumerator.Dispose();
            this.Enumerator = null;
        }
        this.owner = null;
        this.child = null;
        this.restartCount = 0;
        this.onChildFail = null;
        this.isFail = null;
    }
 
    // Token: 0x06000DAB RID: 3499 RVA: 0x00069CB8 File Offset: 0x00067EB8
    public virtual void OnReset()
    {
    }
 
    // Token: 0x06000DAC RID: 3500 RVA: 0x00069CBC File Offset: 0x00067EBC
    public AIAct.Status Tick()
    {
        if (this.owner == null || (this.isFail != null && this.isFail()))
        {
            return this.Cancel();
        }
        if (this.IsChildRunning)
        {
            switch (this.child.Tick())
            {
            case AIAct.Status.Running:
                return AIAct.Status.Running;
            case AIAct.Status.Fail:
                if (this.onChildFail != null)
                {
                    return this.onChildFail();
                }
                return AIAct.Status.Fail;
            case AIAct.Status.Success:
                if (this.owner == null || (this.isFail != null && this.isFail()))
                {
                    return this.Cancel();
                }
                break;
            }
        }
        if (this.Enumerator == null)
        {
            this.Start();
            if (this.status != AIAct.Status.Running)
            {
                return this.status;
            }
        }
        if (!this.Enumerator.MoveNext())
        {
            return this.Success(null);
        }
        return this.status;
    }
 
    // Token: 0x06000DAD RID: 3501 RVA: 0x00069D89 File Offset: 0x00067F89
    public virtual IEnumerable<AIAct.Status> Run()
    {
        yield return this.Success(null);
        yield break;
    }
 
    // Token: 0x06000DAE RID: 3502 RVA: 0x00069D9C File Offset: 0x00067F9C
    public AIAct.Status TickChild()
    {
        if (this.child == null || this.onChildFail == null)
        {
            AIAct aiact = this.child;
            string str = (aiact != null) ? aiact.ToString() : null;
            string str2 = "/";
            Func<AIAct.Status> func = this.onChildFail;
            Debug.Log(str + str2 + ((func != null) ? func.ToString() : null));
            return AIAct.Status.Fail;
        }
        if (this.child.Tick() != AIAct.Status.Fail)
        {
            return AIAct.Status.Running;
        }
        if (this.onChildFail != null)
        {
            return this.onChildFail();
        }
        return AIAct.Status.Fail;
    }
 
    // Token: 0x06000DAF RID: 3503 RVA: 0x00069E13 File Offset: 0x00068013
    public AIAct.Status Do(AIAct _seq, Func<AIAct.Status> _onChildFail = null)
    {
        this.SetChild(_seq, _onChildFail);
        return this.TickChild();
    }
 
    // Token: 0x06000DB0 RID: 3504 RVA: 0x00069E23 File Offset: 0x00068023
    public AIAct.Status DoGotoInteraction(Point pos, Func<AIAct.Status> _onChildFail = null)
    {
        if (pos != null && pos.IsValid)
        {
            this.SetChild(new AI_Goto(pos, 0, false, true), _onChildFail);
            return this.TickChild();
        }
        if (_onChildFail == null)
        {
            return this.Cancel();
        }
        return _onChildFail();
    }
 
    // Token: 0x06000DB1 RID: 3505 RVA: 0x00069E57 File Offset: 0x00068057
    public AIAct.Status DoGoto(Point pos, int dist = 0, bool ignoreConnection = false, Func<AIAct.Status> _onChildFail = null)
    {
        if (pos != null && pos.IsValid)
        {
            this.SetChild(new AI_Goto(pos, dist, ignoreConnection, false), _onChildFail);
            return this.TickChild();
        }
        if (_onChildFail == null)
        {
            return this.Cancel();
        }
        return _onChildFail();
    }
 
    // Token: 0x06000DB2 RID: 3506 RVA: 0x00069E8E File Offset: 0x0006808E
    public AIAct.Status DoGoto(Card card, Func<AIAct.Status> _onChildFail = null)
    {
        return this.DoGoto(card, (card.isChara || card.pos.cell.blocked) ? 1 : 0, _onChildFail);
    }
 
    // Token: 0x06000DB3 RID: 3507 RVA: 0x00069EB8 File Offset: 0x000680B8
    public AIAct.Status DoGoto(Card card, int dist, Func<AIAct.Status> _onChildFail = null)
    {
        if (card != null && card == this.owner.held)
        {
            return AIAct.Status.Running;
        }
        if (card != null && card.ExistsOnMap)
        {
            this.SetChild(new AI_Goto(card, dist, false, false), _onChildFail);
            return this.TickChild();
        }
        if (_onChildFail == null)
        {
            return this.Cancel();
        }
        return _onChildFail();
    }
 
    // Token: 0x06000DB4 RID: 3508 RVA: 0x00069F0C File Offset: 0x0006810C
    public AIAct.Status DoGotoSpot(Card card, Func<AIAct.Status> _onChildFail = null)
    {
        if (card != null && card == this.owner.held)
        {
            return AIAct.Status.Running;
        }
        if (card != null && card.ExistsOnMap)
        {
            Point randomPoint = card.trait.GetRandomPoint(null);
            int dist = randomPoint.cell.blocked ? 1 : 0;
            this.SetChild(new AI_Goto(randomPoint, dist, false, false), _onChildFail);
            return this.TickChild();
        }
        if (_onChildFail == null)
        {
            return this.Cancel();
        }
        return _onChildFail();
    }
 
    // Token: 0x06000DB5 RID: 3509 RVA: 0x00069F7D File Offset: 0x0006817D
    public AIAct.Status DoGoto<T>(Func<AIAct.Status> _onChildFail = null) where T : Trait
    {
        Trait random = EClass._map.Installed.traits.GetTraitSet<T>().GetRandom();
        return this.DoGoto((random != null) ? random.owner : null, _onChildFail);
    }
 
    // Token: 0x06000DB6 RID: 3510 RVA: 0x00069FAC File Offset: 0x000681AC
    public AIAct.Status DoGotoSpot<T>(Func<AIAct.Status> _onChildFail = null) where T : Trait
    {
        Trait random = EClass._map.Installed.traits.GetTraitSet<T>().GetRandom();
        if (random != null)
        {
            this.DoGoto(random.GetRandomPoint(null), 0, false, _onChildFail);
        }
        if (_onChildFail == null)
        {
            return AIAct.Status.Fail;
        }
        return _onChildFail();
    }
 
    // Token: 0x06000DB7 RID: 3511 RVA: 0x00069FF4 File Offset: 0x000681F4
    public AIAct.Status DoGrab(Card card, int num = -1, bool pickHeld = false, Func<AIAct.Status> _onChildFail = null)
    {
        if (card != null && card == this.owner.held)
        {
            return AIAct.Status.Running;
        }
        if (card == null || !card.GetRootCard().ExistsOnMap)
        {
            return this.Cancel();
        }
        this.SetChild(new AI_Grab
        {
            target = card,
            num = num,
            pickHeld = pickHeld
        }, _onChildFail);
        return this.TickChild();
    }
 
    // Token: 0x06000DB8 RID: 3512 RVA: 0x0006A053 File Offset: 0x00068253
    public AIAct.Status DoGrab<T>() where T : Trait
    {
        this.SetChild(new AI_Grab<T>(), null);
        return this.TickChild();
    }
 
    // Token: 0x06000DB9 RID: 3513 RVA: 0x0006A067 File Offset: 0x00068267
    public AIAct.Status DoProgress()
    {
        this.SetChild(this.CreateProgress(), null);
        return this.TickChild();
    }
 
    // Token: 0x06000DBA RID: 3514 RVA: 0x0006A07C File Offset: 0x0006827C
    public AIAct.Status DoIdle(int repeat = 3)
    {
        this.SetChild(new AI_Idle
        {
            maxRepeat = repeat
        }, new Func<AIAct.Status>(this.KeepRunning));
        return this.TickChild();
    }
 
    // Token: 0x06000DBB RID: 3515 RVA: 0x0006A0A2 File Offset: 0x000682A2
    public AIAct.Status DoWait(int count = 1)
    {
        this.SetChild(new AI_Wait
        {
            count = count
        }, new Func<AIAct.Status>(this.KeepRunning));
        return this.TickChild();
    }
 
    // Token: 0x17000388 RID: 904
    // (get) Token: 0x06000DBC RID: 3516 RVA: 0x0006A0C8 File Offset: 0x000682C8
    public virtual bool HasProgress
    {
        get
        {
            return true;
        }
    }
 
    // Token: 0x06000DBD RID: 3517 RVA: 0x0006A0CC File Offset: 0x000682CC
    public virtual AIProgress CreateProgress()
    {
        Progress_Custom progress_Custom = new Progress_Custom
        {
            onProgress = delegate(Progress_Custom p)
            {
                this.OnProgress();
            },
            onProgressComplete = new Action(this.OnProgressComplete),
            canProgress = new Func<bool>(this.CanProgress),
            onBeforeProgress = new Action(this.OnBeforeProgress)
        };
        this.OnCreateProgress(progress_Custom);
        return progress_Custom;
    }
 
    // Token: 0x06000DBE RID: 3518 RVA: 0x0006A132 File Offset: 0x00068332
    public virtual void OnCreateProgress(Progress_Custom p)
    {
    }
 
    // Token: 0x06000DBF RID: 3519 RVA: 0x0006A134 File Offset: 0x00068334
    public virtual bool CanProgress()
    {
        return true;
    }
 
    // Token: 0x06000DC0 RID: 3520 RVA: 0x0006A137 File Offset: 0x00068337
    public virtual void OnBeforeProgress()
    {
    }
 
    // Token: 0x06000DC1 RID: 3521 RVA: 0x0006A139 File Offset: 0x00068339
    public virtual void OnProgress()
    {
    }
 
    // Token: 0x06000DC2 RID: 3522 RVA: 0x0006A13B File Offset: 0x0006833B
    public virtual void OnProgressComplete()
    {
    }
 
    // Token: 0x06000DC3 RID: 3523 RVA: 0x0006A13D File Offset: 0x0006833D
    public void SimulateZone(int days)
    {
        if (this.owner.conSuspend != null)
        {
            return;
        }
        this.OnSimulateZone(days);
    }
 
    // Token: 0x06000DC4 RID: 3524 RVA: 0x0006A154 File Offset: 0x00068354
    public virtual void OnSimulateZone(int days)
    {
    }
 
    // Token: 0x06000DC5 RID: 3525 RVA: 0x0006A156 File Offset: 0x00068356
    public virtual void OnSimulatePosition()
    {
    }
 
    // Token: 0x04000D17 RID: 3351
    public new Chara owner;
 
    // Token: 0x04000D18 RID: 3352
    public AIAct.Status status;
 
    // Token: 0x04000D19 RID: 3353
    public IEnumerator<AIAct.Status> Enumerator;
 
    // Token: 0x04000D1A RID: 3354
    public AIAct child;
 
    // Token: 0x04000D1B RID: 3355
    public AIAct parent;
 
    // Token: 0x04000D1C RID: 3356
    public byte restartCount;
 
    // Token: 0x04000D1D RID: 3357
    public Func<AIAct.Status> onChildFail;
 
    // Token: 0x04000D1E RID: 3358
    public Func<bool> isFail;
 
    // Token: 0x020008CB RID: 2251
    public enum Status
    {
        // Token: 0x04002551 RID: 9553
        Running,
        // Token: 0x04002552 RID: 9554
        Fail,
        // Token: 0x04002553 RID: 9555
        Success
    }
}