AI_Fish.cs

using System;
using System.Collections.Generic;
using UnityEngine;
 
// Token: 0x020001F0 RID: 496
public class AI_Fish : AIAct
{
    // Token: 0x170003A4 RID: 932
    // (get) Token: 0x06000E34 RID: 3636 RVA: 0x0006B85F File Offset: 0x00069A5F
    public override int MaxRestart
    {
        get
        {
            return 9999;
        }
    }
 
    // Token: 0x06000E35 RID: 3637 RVA: 0x0006B866 File Offset: 0x00069A66
    public override bool CanManualCancel()
    {
        return true;
    }
 
    // Token: 0x170003A5 RID: 933
    // (get) Token: 0x06000E36 RID: 3638 RVA: 0x0006B869 File Offset: 0x00069A69
    public override TargetType TargetType
    {
        get
        {
            return TargetType.Ground;
        }
    }
 
    // Token: 0x06000E37 RID: 3639 RVA: 0x0006B870 File Offset: 0x00069A70
    public override bool CanPerform()
    {
        return Act.TP.cell.IsTopWaterAndNoSnow;
    }
 
    // Token: 0x06000E38 RID: 3640 RVA: 0x0006B881 File Offset: 0x00069A81
    public override AIProgress CreateProgress()
    {
        return new AI_Fish.ProgressFish
        {
            posWater = this.pos
        };
    }
 
    // Token: 0x06000E39 RID: 3641 RVA: 0x0006B894 File Offset: 0x00069A94
    public override IEnumerable<AIAct.Status> Run()
    {
        if (!this.owner.IsPC)
        {
            this.owner.TryPickGroundItem();
        }
        if (this.pos != null)
        {
            if (!this.pos.cell.IsTopWaterAndNoSnow)
            {
                yield return this.Cancel();
            }
            yield return base.DoGoto(this.pos, 1, false, null);
            this.owner.LookAt(this.pos);
            if (this.owner.IsPC)
            {
                EClass.player.TryEquipBait();
                if (EClass.player.eqBait == null)
                {
                    Msg.Say("noBait");
                    yield return this.Cancel();
                }
            }
            if (!this.pos.cell.IsTopWaterAndNoSnow || this.owner.Dist(this.pos) > 1)
            {
                yield return this.Cancel();
            }
            AIAct.Status status = base.DoProgress();
            if (AI_Fish.shouldCancel)
            {
                AI_Fish.shouldCancel = false;
                yield return this.Cancel();
            }
            if (status == AIAct.Status.Running)
            {
                yield return AIAct.Status.Running;
            }
            if (this.owner == EClass.pc)
            {
                yield return base.Restart();
            }
            yield return base.DoWait(2);
            if (this.owner != null)
            {
                if (!this.owner.IsPC)
                {
                    this.owner.TryPickGroundItem();
                }
                if (this.owner.IsPCFaction && !this.owner.IsPCParty)
                {
                    this.owner.ClearInventory(ClearInventoryType.Silent);
                }
            }
            yield return base.Success(null);
        }
        if (this.owner.fov == null)
        {
            yield return this.Cancel();
        }
        List<Point> list = this.owner.fov.ListPoints();
        foreach (Point p in list)
        {
            if (!p.cell.IsTopWaterAndNoSnow)
            {
                int num;
                for (int _x = p.x - 1; _x <= p.x + 1; _x = num + 1)
                {
                    for (int _z = p.z - 1; _z <= p.z + 1; _z = num + 1)
                    {
                        Point.shared.Set(_x, _z);
                        if (Point.shared.IsValid && Point.shared.cell.IsTopWaterAndNoSnow)
                        {
                            Point dest = Point.shared.Copy();
                            yield return base.DoGoto(dest, 0, false, null);
                            this.owner.LookAt(dest);
                            yield return base.DoProgress();
                            yield return AIAct.Status.Success;
                            dest = null;
                        }
                        num = _z;
                    }
                    num = _x;
                }
                p = null;
            }
        }
        List<Point>.Enumerator enumerator = default(List<Point>.Enumerator);
        yield break;
        yield break;
    }
 
    // Token: 0x06000E3A RID: 3642 RVA: 0x0006B8A4 File Offset: 0x00069AA4
    public static Point GetFishingPoint(Point p)
    {
        Point point = new Point();
        if (p.cell.IsTopWaterAndNoSnow)
        {
            return Point.Invalid;
        }
        for (int i = p.x - 1; i <= p.x + 1; i++)
        {
            for (int j = p.z - 1; j <= p.z + 1; j++)
            {
                point.Set(i, j);
                if (point.IsValid && point.cell.IsTopWaterAndNoSnow)
                {
                    return point;
                }
            }
        }
        return Point.Invalid;
    }
 
    // Token: 0x06000E3B RID: 3643 RVA: 0x0006B924 File Offset: 0x00069B24
    public static Thing Makefish(Chara c)
    {
        int num = c.Evalue(245);
        if (EClass.rnd(3 + num) == 0)
        {
            return null;
        }
        int[] source = new int[]
        {
            233,
            235,
            236,
            236,
            236,
            1170,
            1143,
            1144,
            727,
            728,
            237,
            869,
            1178,
            1179,
            1180
        };
        int num2 = 1;
        string text = "";
        if (c.IsPC || EClass.rnd(20) == 0)
        {
            if (EClass.rnd(30) == 0)
            {
                text = "book_ancient";
            }
            if (EClass.rnd(35) == 0 || EClass.debug.enable)
            {
                text = "plat";
                if (EClass.rnd(2) == 0)
                {
                    text = "scratchcard";
                }
                if (EClass.rnd(3) == 0)
                {
                    text = "casino_coin";
                }
                if (EClass.rnd(3) == 0)
                {
                    text = "gacha_coin";
                }
                if (EClass.rnd(50) == 0 || EClass.debug.enable)
                {
                    text = new string[]
                    {
                        "659",
                        "758",
                        "759",
                        "806",
                        "828",
                        "1190",
                        "1191"
                    }.RandomItem<string>();
                }
            }
            if (EClass.rnd(30) == 0 && EClass.rnd(100) > num + 10)
            {
                text = "medal";
            }
        }
        Thing thing;
        if (text != "")
        {
            thing = ThingGen.Create(text, -1, -1);
        }
        else if (EClass.rnd(5 + num / 3) == 0)
        {
            thing = ThingGen.Create(source.RandomItem<int>().ToString() ?? "", -1, -1);
        }
        else
        {
            int num3 = EClass.rnd(num * 2) + 1;
            thing = ThingGen.Create("fish", -1, num3);
            num2 = EClass.rnd(num / (num3 + 10)) + 1;
            int num4 = 5;
            if (EClass.Branch != null)
            {
                num4 += EClass.Branch.Evalue(3604) * 20 + EClass.Branch.Evalue(3706) * 25;
            }
            if (num4 >= EClass.rnd(100))
            {
                num2++;
            }
        }
        if (thing != null)
        {
            thing.SetNum(num2);
            thing.SetBlessedState(BlessedState.Normal);
        }
        return thing;
    }
 
    // Token: 0x04000D40 RID: 3392
    public Point pos;
 
    // Token: 0x04000D41 RID: 3393
    public static bool shouldCancel;
 
    // Token: 0x020008DE RID: 2270
    public class ProgressFish : AIProgress
    {
        // Token: 0x17001170 RID: 4464
        // (get) Token: 0x06003B88 RID: 15240 RVA: 0x0013BEAB File Offset: 0x0013A0AB
        public override bool ShowProgress
        {
            get
            {
                return false;
            }
        }
 
        // Token: 0x17001171 RID: 4465
        // (get) Token: 0x06003B89 RID: 15241 RVA: 0x0013BEAE File Offset: 0x0013A0AE
        public override int MaxProgress
        {
            get
            {
                return 100;
            }
        }
 
        // Token: 0x17001172 RID: 4466
        // (get) Token: 0x06003B8A RID: 15242 RVA: 0x0013BEB2 File Offset: 0x0013A0B2
        public override int LeftHand
        {
            get
            {
                return -1;
            }
        }
 
        // Token: 0x17001173 RID: 4467
        // (get) Token: 0x06003B8B RID: 15243 RVA: 0x0013BEB5 File Offset: 0x0013A0B5
        public override int RightHand
        {
            get
            {
                return 1107;
            }
        }
 
        // Token: 0x06003B8C RID: 15244 RVA: 0x0013BEBC File Offset: 0x0013A0BC
        public override void OnStart()
        {
            if (AI_Fish.shouldCancel)
            {
                return;
            }
            this.owner.PlaySound("fish_cast", 1f, true);
            if (this.owner.Tool != null)
            {
                this.owner.Say("fish_start", this.owner, this.owner.Tool, null, null);
                return;
            }
            this.owner.Say("fish_start2", this.owner, null, null);
        }
 
        // Token: 0x06003B8D RID: 15245 RVA: 0x0013BF34 File Offset: 0x0013A134
        public override void OnProgress()
        {
            if (this.owner.IsPC && (this.owner.Tool == null || !this.owner.Tool.HasElement(245, 1)))
            {
                this.Cancel();
                return;
            }
            if (this.hit >= 0)
            {
                this.owner.renderer.PlayAnime(AnimeID.Fishing, default(Vector3), false);
                this.owner.PlaySound("fish_fight", 1f, true);
                this.Ripple();
                int a = Mathf.Clamp(10 - EClass.rnd(this.owner.Evalue(245) + 1) / 10, 5, 10);
                if (this.hit > EClass.rnd(a))
                {
                    this.hit = 100;
                    this.progress = this.MaxProgress;
                }
                this.hit++;
                return;
            }
            if (EClass.rnd(Mathf.Clamp(10 - EClass.rnd(this.owner.Evalue(245) + 1) / 5, 2, 10)) == 0 && this.progress >= 10)
            {
                this.hit = 0;
            }
            if (this.progress == 2 || (this.progress >= 8 && this.progress % 6 == 0 && EClass.rnd(3) == 0))
            {
                this.owner.renderer.PlayAnime(AnimeID.Shiver, default(Vector3), false);
                this.Ripple();
            }
        }
 
        // Token: 0x06003B8E RID: 15246 RVA: 0x0013C098 File Offset: 0x0013A298
        public void Ripple()
        {
            if (this.posWater != null)
            {
                Effect.Get("ripple").Play(this.posWater, -0.04f, null, null);
                this.posWater.PlaySound("fish_splash", true, 1f, true);
            }
        }
 
        // Token: 0x06003B8F RID: 15247 RVA: 0x0013C0D8 File Offset: 0x0013A2D8
        public override void OnProgressComplete()
        {
            this.owner.renderer.PlayAnime(AnimeID.Fishing, default(Vector3), false);
            if (this.hit < 100)
            {
                this.Fail();
                return;
            }
            if (this.owner.IsPC && !EClass.debug.enable)
            {
                if (EClass.player.eqBait == null || EClass.player.eqBait.isDestroyed)
                {
                    Msg.Say("noBait");
                    return;
                }
                EClass.player.eqBait.ModNum(-1, true);
            }
            Thing thing = AI_Fish.Makefish(this.owner);
            if (thing == null)
            {
                this.Fail();
                return;
            }
            int num = thing.Num;
            EClass._zone.AddCard(thing, this.owner.pos);
            thing.renderer.PlayAnime(AnimeID.Jump, default(Vector3), false);
            this.owner.Say("fish_get", this.owner, thing, null, null);
            this.owner.PlaySound("fish_get", 1f, true);
            this.owner.elements.ModExp(245, 100, false);
            if (thing.id == "medal")
            {
                thing.isHidden = false;
            }
            if (this.owner.IsPC)
            {
                if (EClass.game.config.preference.pickFish)
                {
                    if (StatsBurden.GetPhase((EClass.pc.ChildrenWeight + thing.ChildrenAndSelfWeight) * 100 / EClass.pc.WeightLimit) >= 3)
                    {
                        EClass.pc.Say("tooHeavy", thing, null, null);
                        AI_Fish.shouldCancel = true;
                    }
                    else
                    {
                        this.owner.Pick(thing, true, true);
                    }
                }
            }
            else
            {
                foreach (Thing thing2 in this.owner.things.List((Thing t) => t.source._origin == "fish", false))
                {
                    thing2.Destroy();
                }
            }
            if (EClass.rnd(2) == 0 || num > 1)
            {
                this.owner.stamina.Mod(-1 * num);
            }
        }
 
        // Token: 0x06003B90 RID: 15248 RVA: 0x0013C314 File Offset: 0x0013A514
        public void Fail()
        {
            if (this.owner.IsPC)
            {
                this.owner.Say("fish_miss", this.owner, null, null);
            }
            this.owner.stamina.Mod(-1);
        }
 
        // Token: 0x040025A1 RID: 9633
        public int hit = -1;
 
        // Token: 0x040025A2 RID: 9634
        public Point posWater;
    }
}