AI_Goto.cs

using System;
using System.Collections.Generic;
using Algorithms;
 
// Token: 0x020001DE RID: 478
public class AI_Goto : AIAct
{
    // Token: 0x17000389 RID: 905
    // (get) Token: 0x06000DC8 RID: 3528 RVA: 0x0006A168 File Offset: 0x00068368
    public override bool UseTurbo
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x1700038A RID: 906
    // (get) Token: 0x06000DC9 RID: 3529 RVA: 0x0006A16B File Offset: 0x0006836B
    public override bool CancelWhenDamaged
    {
        get
        {
            return !EClass._zone.IsRegion;
        }
    }
 
    // Token: 0x1700038B RID: 907
    // (get) Token: 0x06000DCA RID: 3530 RVA: 0x0006A17A File Offset: 0x0006837A
    public override bool CancelWhenMoved
    {
        get
        {
            return true;
        }
    }
 
    // Token: 0x1700038C RID: 908
    // (get) Token: 0x06000DCB RID: 3531 RVA: 0x0006A17D File Offset: 0x0006837D
    public override bool InformCancel
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x06000DCC RID: 3532 RVA: 0x0006A180 File Offset: 0x00068380
    public override bool CanManualCancel()
    {
        return true;
    }
 
    // Token: 0x1700038D RID: 909
    // (get) Token: 0x06000DCD RID: 3533 RVA: 0x0006A183 File Offset: 0x00068383
    public override bool PushChara
    {
        get
        {
            AIAct parent = this.parent;
            return parent == null || parent.PushChara;
        }
    }
 
    // Token: 0x06000DCE RID: 3534 RVA: 0x0006A196 File Offset: 0x00068396
    public override Point GetDestination()
    {
        if (this.destCard != null)
        {
            return this.destCard.pos;
        }
        return this.dest;
    }
 
    // Token: 0x06000DCF RID: 3535 RVA: 0x0006A1B2 File Offset: 0x000683B2
    public AI_Goto(Point _dest, int dist, bool _ignoreConnection = false, bool _interaction = false)
    {
        this.dest.Set(_dest);
        this.destDist = dist;
        this.ignoreConnection = _ignoreConnection;
        this.interaction = _interaction;
    }
 
    // Token: 0x06000DD0 RID: 3536 RVA: 0x0006A1E8 File Offset: 0x000683E8
    public AI_Goto(Card _card, int dist, bool _ignoreConnection = false, bool _interaction = false)
    {
        this.destCard = _card;
        this.destDist = dist;
        this.ignoreConnection = _ignoreConnection;
        this.interaction = _interaction;
    }
 
    // Token: 0x06000DD1 RID: 3537 RVA: 0x0006A218 File Offset: 0x00068418
    public override void OnReset()
    {
        this.owner.path.state = PathProgress.State.Idle;
    }
 
    // Token: 0x06000DD2 RID: 3538 RVA: 0x0006A22C File Offset: 0x0006842C
    public AIAct.Status TryGoTo()
    {
        PathProgress path = this.owner.path;
        Point pos = this.owner.pos;
        if (this.owner.IsPC)
        {
            if (this.dest.x > EClass._map.bounds.maxX + 1)
            {
                this.dest.x = EClass._map.bounds.maxX + 1;
            }
            else if (this.dest.x < EClass._map.bounds.x - 1)
            {
                this.dest.x = EClass._map.bounds.x - 1;
            }
            if (this.dest.z > EClass._map.bounds.maxZ + 1)
            {
                this.dest.z = EClass._map.bounds.maxZ + 1;
            }
            else if (this.dest.z < EClass._map.bounds.z - 1)
            {
                this.dest.z = EClass._map.bounds.z - 1;
            }
        }
        if ((this.repath || (this.owner.IsPC && ActionMode.IsAdv)) && path.state == PathProgress.State.Idle)
        {
            path.RequestPathImmediate(pos, this.dest, this.destDist, this.ignoreConnection, -1);
            this.repath = false;
        }
        switch (path.state)
        {
        case PathProgress.State.Idle:
            path.RequestPath(pos, this.dest, this.destDist, this.ignoreConnection, -1);
            break;
        case PathProgress.State.PathReady:
        {
            if (path.nodeIndex < 0)
            {
                return this.Cancel();
            }
            PathFinderNode pathFinderNode = path.nodes[path.nodeIndex];
            if (this.owner.IsPC && ActionMode.IsAdv && path.nodeIndex > 2)
            {
                ActionMode.Adv.SetTurbo(-1);
            }
            Point shared = Point.GetShared(pathFinderNode.X, pathFinderNode.Z);
            if (shared.x == this.owner.pos.x && shared.z == this.owner.pos.z && path.nodeIndex > 0 && !shared.cell.HasLadder && !this.owner.Cell.HasLadder)
            {
                path.nodeIndex--;
                pathFinderNode = path.nodes[path.nodeIndex];
                shared.Set(pathFinderNode.X, pathFinderNode.Z);
            }
            if (shared.HasChara && !this.owner.IsPC)
            {
                this.waitCount++;
                if (this.waitCount < 3 || EClass.rnd(5) != 0)
                {
                    return AIAct.Status.Running;
                }
            }
            this.waitCount = 0;
            Card.MoveResult moveResult = this.owner.TryMove(shared, true);
            if (this.owner == null)
            {
                return AIAct.Status.Running;
            }
            if (moveResult == Card.MoveResult.Fail || moveResult == Card.MoveResult.Door)
            {
                if (this.owner.IsPC && ActionMode.IsAdv)
                {
                    return this.Cancel();
                }
                return base.Restart();
            }
            else
            {
                if (!this.owner.pos.Equals(shared))
                {
                    path.state = PathProgress.State.Idle;
                    this.repath = true;
                }
                path.nodeIndex--;
                if (this.IsDestinationReached())
                {
                    return base.Success(null);
                }
            }
            break;
        }
        case PathProgress.State.Fail:
            return this.Cancel();
        }
        return AIAct.Status.Running;
    }
 
    // Token: 0x06000DD3 RID: 3539 RVA: 0x0006A584 File Offset: 0x00068784
    public bool IsDestinationReached()
    {
        if (this.destCard != null)
        {
            int num = this.destCard.pos.Distance(this.owner.pos);
            return (this.interaction && num == 1 && this.owner.CanInteractTo(this.owner.pos)) || num <= this.destDist;
        }
        int num2 = Util.Distance(this.owner.pos.x, this.owner.pos.z, this.dest.x, this.dest.z);
        return (this.interaction && num2 == 1 && this.owner.CanInteractTo(this.dest)) || num2 <= this.destDist;
    }
 
    // Token: 0x06000DD4 RID: 3540 RVA: 0x0006A651 File Offset: 0x00068851
    public override IEnumerable<AIAct.Status> Run()
    {
        if (this.owner.host != null)
        {
            yield return this.Cancel();
        }
        for (;;)
        {
            if (this.destCard != null)
            {
                this.dest.Set(this.GetDestination());
            }
            while (this.owner.path.state == PathProgress.State.Searching)
            {
                yield return AIAct.Status.Running;
            }
            this.owner.path.state = PathProgress.State.Idle;
            if (this.IsDestinationReached())
            {
                yield return base.Success(null);
            }
            EClass.player.enemySpotted = false;
            for (;;)
            {
                if (this.owner.IsPC)
                {
                    if (EClass.player.TooHeavyToMove())
                    {
                        yield return this.Cancel();
                    }
                    if (EClass.player.enemySpotted)
                    {
                        EClass.player.enemySpotted = false;
                        Msg.Say("enemy_spotted");
                        yield return this.Cancel();
                    }
                }
                yield return this.TryGoTo();
                if (this.destCard != null)
                {
                    Point destination = this.GetDestination();
                    int num = this.dest.Distance(destination);
                    if (num > 3 && num < 20)
                    {
                        break;
                    }
                }
            }
            this.repath = true;
            this.owner.path.state = PathProgress.State.Idle;
        }
        yield break;
    }
 
    // Token: 0x04000D1F RID: 3359
    public Card destCard;
 
    // Token: 0x04000D20 RID: 3360
    public Point dest = new Point();
 
    // Token: 0x04000D21 RID: 3361
    public int destDist;
 
    // Token: 0x04000D22 RID: 3362
    public int waitCount;
 
    // Token: 0x04000D23 RID: 3363
    public bool ignoreConnection;
 
    // Token: 0x04000D24 RID: 3364
    public bool interaction;
 
    // Token: 0x04000D25 RID: 3365
    public bool repath;
}