TaskWater.cs

using System;
using System.Collections.Generic;
 
// Token: 0x02000260 RID: 608
public class TaskWater : Task
{
    // Token: 0x1700049B RID: 1179
    // (get) Token: 0x06001120 RID: 4384 RVA: 0x000771C3 File Offset: 0x000753C3
    public TraitToolWaterCan waterCan
    {
        get
        {
            Chara chara = this.owner ?? Act.CC;
            object obj;
            if (chara == null)
            {
                obj = null;
            }
            else
            {
                Card held = chara.held;
                obj = ((held != null) ? held.trait : null);
            }
            return obj as TraitToolWaterCan;
        }
    }
 
    // Token: 0x06001121 RID: 4385 RVA: 0x000771F1 File Offset: 0x000753F1
    public override bool CanPerform()
    {
        return TaskWater.ShouldWater(Act.TP) && this.IsWaterCanValid(false);
    }
 
    // Token: 0x06001122 RID: 4386 RVA: 0x00077208 File Offset: 0x00075408
    public override bool CanManualCancel()
    {
        return true;
    }
 
    // Token: 0x06001123 RID: 4387 RVA: 0x0007720B File Offset: 0x0007540B
    public override IEnumerable<AIAct.Status> Run()
    {
        this.dest = new Point(this.dest);
        List<Point> list = this.ListPoints();
        for (;;)
        {
            TaskWater.<>c__DisplayClass5_0 CS$<>8__locals1 = new TaskWater.<>c__DisplayClass5_0();
            if (list.Count == 0)
            {
                break;
            }
            list.Sort((Point a, Point b) => a.Distance(this.dest) - b.Distance(this.dest));
            Point p = list[0];
            this.dest.Set(p);
            list.RemoveAt(0);
            if (TaskWater.ShouldWater(p))
            {
                if (!this.IsWaterCanValid(true))
                {
                    yield return this.Cancel();
                }
                CS$<>8__locals1.fail = false;
                yield return base.DoGoto(p, 1, false, delegate()
                {
                    CS$<>8__locals1.fail = true;
                    return AIAct.Status.Running;
                });
                if (!CS$<>8__locals1.fail)
                {
                    if (!this.IsWaterCanValid(true))
                    {
                        yield return this.Cancel();
                    }
                    if (TaskWater.ShouldWater(p))
                    {
                        if (this.owner.Dist(this.dest) > 1)
                        {
                            yield return this.Cancel();
                        }
                        p.cell.isWatered = true;
                        if (!p.cell.blocked && EClass.rnd(5) == 0)
                        {
                            EClass._map.SetLiquid(p.x, p.z, 1, 1);
                        }
                        this.owner.PlaySound("water_farm", 1f, true);
                        this.owner.Say("water_farm", this.owner, p.cell.GetFloorName(), null);
                        this.waterCan.owner.ModCharge(-1, false);
                        this.owner.ModExp(286, 15);
                        if (!this.IsWaterCanValid(true))
                        {
                            yield return this.Cancel();
                        }
                        yield return base.KeepRunning();
                        CS$<>8__locals1 = null;
                        p = null;
                    }
                }
            }
        }
        yield break;
    }
 
    // Token: 0x06001124 RID: 4388 RVA: 0x0007721C File Offset: 0x0007541C
    public static bool ShouldWater(Point p)
    {
        Cell cell = p.cell;
        if (cell.isWatered || cell.IsTopWater || cell.IsSnowTile || !p.IsFarmField)
        {
            return false;
        }
        if (p.cell.detail != null)
        {
            using (List<Thing>.Enumerator enumerator = p.Things.GetEnumerator())
            {
                while (enumerator.MoveNext())
                {
                    if (enumerator.Current.trait is TraitSeed)
                    {
                        return true;
                    }
                }
            }
        }
        return p.growth != null;
    }
 
    // Token: 0x06001125 RID: 4389 RVA: 0x000772B8 File Offset: 0x000754B8
    public bool IsWaterCanValid(bool msg = true)
    {
        bool flag = this.waterCan != null && this.waterCan.owner.c_charges > 0;
        if (!flag && msg)
        {
            Msg.Say("water_deplete");
        }
        return flag;
    }
 
    // Token: 0x06001126 RID: 4390 RVA: 0x000772EC File Offset: 0x000754EC
    public List<Point> ListPoints()
    {
        List<Point> list = new List<Point>();
        EClass._map.bounds.ForeachPoint(delegate(Point p)
        {
            if (TaskWater.ShouldWater(p))
            {
                list.Add(p.Copy());
            }
        });
        return list;
    }
 
    // Token: 0x04000DE1 RID: 3553
    public Point dest;
}