GrowSystem.cs

using System;
using UnityEngine;
 
// Token: 0x02000674 RID: 1652
public class GrowSystem : EClass
{
    // Token: 0x06002E4A RID: 11850 RVA: 0x001054D7 File Offset: 0x001036D7
    public bool IsLastStage()
    {
        return this.stage.idx == this.StageLength - 1;
    }
 
    // Token: 0x17000D1C RID: 3356
    // (get) Token: 0x06002E4B RID: 11851 RVA: 0x001054EE File Offset: 0x001036EE
    public virtual RenderData RenderHarvest
    {
        get
        {
            return this.source.renderData;
        }
    }
 
    // Token: 0x17000D1D RID: 3357
    // (get) Token: 0x06002E4C RID: 11852 RVA: 0x001054FB File Offset: 0x001036FB
    public virtual int Step
    {
        get
        {
            return 5;
        }
    }
 
    // Token: 0x17000D1E RID: 3358
    // (get) Token: 0x06002E4D RID: 11853 RVA: 0x001054FE File Offset: 0x001036FE
    public virtual int StageLength
    {
        get
        {
            return 5;
        }
    }
 
    // Token: 0x17000D1F RID: 3359
    // (get) Token: 0x06002E4E RID: 11854 RVA: 0x00105501 File Offset: 0x00103701
    public virtual int DefaultStage
    {
        get
        {
            return Mathf.Clamp(this.StageLength - 2, 0, this.StageLength - 1);
        }
    }
 
    // Token: 0x17000D20 RID: 3360
    // (get) Token: 0x06002E4F RID: 11855 RVA: 0x00105519 File Offset: 0x00103719
    public virtual int HarvestStage
    {
        get
        {
            return -1;
        }
    }
 
    // Token: 0x17000D21 RID: 3361
    // (get) Token: 0x06002E50 RID: 11856 RVA: 0x0010551C File Offset: 0x0010371C
    public virtual int AutoMineStage
    {
        get
        {
            return this.HarvestStage;
        }
    }
 
    // Token: 0x17000D22 RID: 3362
    // (get) Token: 0x06002E51 RID: 11857 RVA: 0x00105524 File Offset: 0x00103724
    protected virtual int HaltStage
    {
        get
        {
            return this.HarvestStage;
        }
    }
 
    // Token: 0x06002E52 RID: 11858 RVA: 0x0010552C File Offset: 0x0010372C
    protected virtual bool IsHarvestStage(int idx)
    {
        return idx == this.HarvestStage;
    }
 
    // Token: 0x17000D23 RID: 3363
    // (get) Token: 0x06002E53 RID: 11859 RVA: 0x00105537 File Offset: 0x00103737
    protected virtual bool DrawHarvestOnTop
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x17000D24 RID: 3364
    // (get) Token: 0x06002E54 RID: 11860 RVA: 0x0010553A File Offset: 0x0010373A
    protected virtual bool UseGenericFirstStageTile
    {
        get
        {
            return true;
        }
    }
 
    // Token: 0x17000D25 RID: 3365
    // (get) Token: 0x06002E55 RID: 11861 RVA: 0x0010553D File Offset: 0x0010373D
    protected virtual bool WitherOnLastStage
    {
        get
        {
            return true;
        }
    }
 
    // Token: 0x17000D26 RID: 3366
    // (get) Token: 0x06002E56 RID: 11862 RVA: 0x00105540 File Offset: 0x00103740
    protected virtual bool CanRegrow
    {
        get
        {
            return true;
        }
    }
 
    // Token: 0x17000D27 RID: 3367
    // (get) Token: 0x06002E57 RID: 11863 RVA: 0x00105543 File Offset: 0x00103743
    public virtual int ShadowStage
    {
        get
        {
            return 1;
        }
    }
 
    // Token: 0x17000D28 RID: 3368
    // (get) Token: 0x06002E58 RID: 11864 RVA: 0x00105546 File Offset: 0x00103746
    public virtual bool IsTree
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x17000D29 RID: 3369
    // (get) Token: 0x06002E59 RID: 11865 RVA: 0x00105549 File Offset: 0x00103749
    public virtual bool IsCrimeToHarvest
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x17000D2A RID: 3370
    // (get) Token: 0x06002E5A RID: 11866 RVA: 0x0010554C File Offset: 0x0010374C
    public virtual float MtpProgress
    {
        get
        {
            return 1f;
        }
    }
 
    // Token: 0x17000D2B RID: 3371
    // (get) Token: 0x06002E5B RID: 11867 RVA: 0x00105553 File Offset: 0x00103753
    public virtual bool NeedSunlight
    {
        get
        {
            return true;
        }
    }
 
    // Token: 0x06002E5C RID: 11868 RVA: 0x00105556 File Offset: 0x00103756
    public virtual bool BlockSight(Cell cell)
    {
        return false;
    }
 
    // Token: 0x06002E5D RID: 11869 RVA: 0x00105559 File Offset: 0x00103759
    public virtual bool BlockPass(Cell cell)
    {
        return false;
    }
 
    // Token: 0x06002E5E RID: 11870 RVA: 0x0010555C File Offset: 0x0010375C
    public virtual string GetSoundProgress()
    {
        return "Material/grass";
    }
 
    // Token: 0x17000D2C RID: 3372
    // (get) Token: 0x06002E5F RID: 11871 RVA: 0x00105563 File Offset: 0x00103763
    public virtual AnimeID AnimeProgress
    {
        get
        {
            return AnimeID.HitObj;
        }
    }
 
    // Token: 0x17000D2D RID: 3373
    // (get) Token: 0x06002E60 RID: 11872 RVA: 0x00105566 File Offset: 0x00103766
    public GrowSystem.Stage stage
    {
        get
        {
            return this.stages[(int)(GrowSystem.cell.objVal / 30)];
        }
    }
 
    // Token: 0x06002E61 RID: 11873 RVA: 0x0010557C File Offset: 0x0010377C
    public virtual GrowSystem.Stage CreateStage()
    {
        return new GrowSystem.Stage();
    }
 
    // Token: 0x06002E62 RID: 11874 RVA: 0x00105584 File Offset: 0x00103784
    public void Init(SourceObj.Row _row)
    {
        this.source = _row;
        this.stages = new GrowSystem.Stage[this.StageLength];
        string[] growth = _row._growth;
        string[] array = growth[1].Split('/', StringSplitOptions.None);
        this.baseTiles = new int[array.Length];
        for (int i = 0; i < array.Length; i++)
        {
            this.baseTiles[i] = array[i].ToInt();
        }
        if (growth.Length > 2)
        {
            this.harvestTile = this.RenderHarvest.ConvertTile(growth[2].ToInt());
            this.idHarvestThing = growth[3];
        }
        for (int j = 0; j < this.StageLength; j++)
        {
            GrowSystem.Stage stage = this.CreateStage();
            this.stages[j] = stage;
            stage.idx = j;
            if (j == 0 && this.UseGenericFirstStageTile)
            {
                this.SetGenericFirstStageTile(stage);
            }
            else
            {
                this.SetStageTile(stage);
            }
            if (this.harvestTile != 0 && this.IsHarvestStage(j))
            {
                stage.harvest = true;
            }
        }
    }
 
    // Token: 0x06002E63 RID: 11875 RVA: 0x00105671 File Offset: 0x00103871
    public virtual void SetGenericFirstStageTile(GrowSystem.Stage s)
    {
        s.renderData = EClass.core.refs.renderers.objS_flat;
        s.SetTile(0, new int[]
        {
            100,
            101,
            102
        });
    }
 
    // Token: 0x06002E64 RID: 11876 RVA: 0x001056A5 File Offset: 0x001038A5
    public virtual void SetStageTile(GrowSystem.Stage s)
    {
        s.renderData = this.source.renderData;
        s.SetTile(s.idx + (this.UseGenericFirstStageTile ? -1 : 0), this.baseTiles);
    }
 
    // Token: 0x06002E65 RID: 11877 RVA: 0x001056D7 File Offset: 0x001038D7
    public virtual int GetStageTile()
    {
        return GrowSystem.currentStage.tiles[GrowSystem.cell.objDir % GrowSystem.currentStage.tiles.Length];
    }
 
    // Token: 0x06002E66 RID: 11878 RVA: 0x001056FB File Offset: 0x001038FB
    public virtual int GetShadow(int index)
    {
        return -1;
    }
 
    // Token: 0x06002E67 RID: 11879 RVA: 0x00105700 File Offset: 0x00103900
    public virtual void OnRenderTileMap(RenderParam p)
    {
        int num = (int)(GrowSystem.cell.objVal / 30);
        GrowSystem.currentStage = this.stages[num];
        SourceObj.Row row = this.source;
        float y = p.y;
        float z = p.z;
        if (num != 0 || !this.UseGenericFirstStageTile)
        {
            p.y += row.pref.y;
            p.z += row.pref.z;
        }
        if (GrowSystem.currentStage.harvest)
        {
            if (GrowSystem.cell.isHarvested || this.harvestTile == 0)
            {
                p.tile = (float)((this.afterHarvestTile != 0) ? this.afterHarvestTile : this.GetStageTile());
                GrowSystem.currentStage.renderData.Draw(p);
            }
            else
            {
                if (this.DrawHarvestOnTop)
                {
                    p.tile = (float)this.GetStageTile();
                    GrowSystem.currentStage.renderData.Draw(p);
                    p.liquidLv = 0;
                }
                p.tile = (float)this.harvestTile;
                this.RenderHarvest.Draw(p);
            }
        }
        else
        {
            p.tile = (float)this.GetStageTile();
            GrowSystem.currentStage.renderData.Draw(p);
        }
        p.y = y;
        p.z = z;
        if (num < this.ShadowStage)
        {
            return;
        }
        int shadow = this.GetShadow(num);
        if (shadow == -1)
        {
            shadow = row.pref.shadow;
        }
        if (shadow > 1 && !GrowSystem.cell.ignoreObjShadow)
        {
            EClass.screen.tileMap.passShadow.AddShadow(p.x + row.renderData.offsetShadow.x, p.y + row.renderData.offsetShadow.y, p.z + row.renderData.offsetShadow.z, ShadowData.Instance.items[shadow], row.pref, 0, p.snow);
        }
    }
 
    // Token: 0x06002E68 RID: 11880 RVA: 0x001058EC File Offset: 0x00103AEC
    public void SetRandomStage()
    {
        int num = Rand.rnd(this.stages.Length);
        if (num == 0 && EClass.rnd(5) != 0 && this.stages.Length >= 2)
        {
            num++;
        }
        else if (num == this.stages.Length - 1 && EClass.rnd(5) != 0 && this.stages.Length >= 2)
        {
            num--;
        }
        GrowSystem.cell.objVal = (byte)(num * 30);
    }
 
    // Token: 0x06002E69 RID: 11881 RVA: 0x00105956 File Offset: 0x00103B56
    public void SetDefaultStage()
    {
        GrowSystem.cell.objVal = (byte)(this.DefaultStage * 30);
    }
 
    // Token: 0x06002E6A RID: 11882 RVA: 0x0010596C File Offset: 0x00103B6C
    public bool CanGrow(VirtualDate date)
    {
        if (this.source.id == 0)
        {
            return false;
        }
        if (GrowSystem.cell.HasBlock)
        {
            return false;
        }
        if (this.NeedSunlight)
        {
            if (date.sunMap == null)
            {
                date.BuildSunMap();
            }
            if ((GrowSystem.cell.HasRoof || date.IsWinter) && !date.sunMap.Contains(GrowSystem.cell.index))
            {
                return false;
            }
        }
        return true;
    }
 
    // Token: 0x06002E6B RID: 11883 RVA: 0x001059DA File Offset: 0x00103BDA
    public void TryGrow(VirtualDate date)
    {
        if (!this.CanGrow(date))
        {
            return;
        }
        this.Grow(1);
    }
 
    // Token: 0x06002E6C RID: 11884 RVA: 0x001059F0 File Offset: 0x00103BF0
    public void EqualizePlants(Point pos)
    {
        PlantData p1 = EClass._map.TryGetPlant(pos);
        if (p1 == null || p1.seed == null)
        {
            return;
        }
        pos.ForeachNeighbor(delegate(Point pos2)
        {
            PlantData plantData = EClass._map.TryGetPlant(pos2);
            Thing thing = (plantData != null) ? plantData.seed : null;
            if (thing == null)
            {
                Thing installed = pos2.Installed;
                if (installed != null && installed.id == p1.seed.id)
                {
                    thing = installed;
                }
            }
            if (thing == null)
            {
                return;
            }
            if (p1.seed.refVal != thing.refVal)
            {
                return;
            }
            if (thing.encLV >= p1.seed.encLV)
            {
                p1.seed = thing;
            }
        }, false);
    }
 
    // Token: 0x06002E6D RID: 11885 RVA: 0x00105A40 File Offset: 0x00103C40
    public void Grow(int mtp = 1)
    {
        bool flag = GrowSystem.cell.isWatered || (GrowSystem.cell.IsTopWater && this.source.tag.Contains("flood"));
        PlantData plantData = EClass._map.TryGetPlant(GrowSystem.cell);
        if (plantData != null && flag)
        {
            plantData.water++;
        }
        int num = this.Step * mtp * (flag ? 2 : 1);
        int num2 = (int)(GrowSystem.cell.objVal / 30);
        int num3 = ((int)GrowSystem.cell.objVal + num) / 30;
        if (num2 != num3)
        {
            if (EClass.player.isAutoFarming && num2 == this.HarvestStage && this.CanHarvest())
            {
                this.PopHarvest(null, null, -1);
            }
            if (EClass.player.isAutoFarming && num2 >= this.AutoMineStage)
            {
                Point point = GrowSystem.cell.GetPoint();
                this.EqualizePlants(point);
                Thing thing = this.TryPopSeed(null);
                this.PopMineObj(null);
                if (thing != null)
                {
                    point.SetObj(0, 1, 0);
                    EClass._zone.AddCard(thing, point).Install();
                }
            }
            else if (num2 == this.StageLength - 1)
            {
                if (EClass.player.isAutoFarming)
                {
                    Point point2 = GrowSystem.cell.GetPoint();
                    this.EqualizePlants(point2);
                    Thing thing2 = this.TryPopSeed(null);
                    if (thing2 != null)
                    {
                        point2.SetObj(0, 1, 0);
                        EClass._zone.AddCard(thing2, point2).Install();
                    }
                }
                else
                {
                    this.OnExceedLastStage();
                }
            }
            else
            {
                this.OnReachNextStage();
            }
        }
        else
        {
            Cell cell = GrowSystem.cell;
            cell.objVal += (byte)num;
        }
        GrowSystem.cell.Refresh();
        EClass._map.RefreshFOV((int)GrowSystem.cell.x, (int)GrowSystem.cell.z, 6, false);
    }
 
    // Token: 0x06002E6E RID: 11886 RVA: 0x00105C0B File Offset: 0x00103E0B
    public virtual void OnReachNextStage()
    {
        this.SetStage((int)(GrowSystem.cell.objVal / 30 + 1), false);
    }
 
    // Token: 0x06002E6F RID: 11887 RVA: 0x00105C24 File Offset: 0x00103E24
    public virtual void OnExceedLastStage()
    {
        GrowSystem.cell.objVal = (byte)(this.stages.Length * 30 - 1);
        if (!this.CanRegrow)
        {
            return;
        }
        if (Rand.rnd(2) == 0)
        {
            Point point = GrowSystem.cell.GetPoint();
            if (point.IsFarmField)
            {
                return;
            }
            if (Rand.rnd(2) == 0)
            {
                Point randomNeighbor = point.GetRandomNeighbor();
                if (randomNeighbor.cell.CanGrowWeed)
                {
                    randomNeighbor.SetObj((int)GrowSystem.cell.obj, 1, 0);
                    point.SetObj(0, 1, 0);
                    return;
                }
            }
            GrowSystem.cell.objVal = 0;
            GrowSystem.cell.isHarvested = false;
            GrowSystem.cell.isWatered = GrowSystem.cell.HasLiquid;
        }
    }
 
    // Token: 0x06002E70 RID: 11888 RVA: 0x00105CD0 File Offset: 0x00103ED0
    public void SetStage(int idx, bool renewHarvest = false)
    {
        GrowSystem.cell.objVal = (byte)(idx * 30);
        GrowSystem.cell.gatherCount = 0;
        if (GrowSystem.cell.HasLiquid)
        {
            GrowSystem.cell.isWatered = true;
        }
        if (renewHarvest)
        {
            GrowSystem.cell.isHarvested = true;
        }
    }
 
    // Token: 0x06002E71 RID: 11889 RVA: 0x00105D1C File Offset: 0x00103F1C
    public bool HaltGrowth()
    {
        return this.stage.idx == this.HarvestStage;
    }
 
    // Token: 0x17000D2E RID: 3374
    // (get) Token: 0x06002E72 RID: 11890 RVA: 0x00105D31 File Offset: 0x00103F31
    public virtual bool IsMature
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x06002E73 RID: 11891 RVA: 0x00105D34 File Offset: 0x00103F34
    public void Perish()
    {
        if (EClass.player.isAutoFarming)
        {
            if (this.CanHarvest())
            {
                this.PopHarvest(null, null, -1);
            }
            Thing thing = this.TryPopSeed(null);
            if (thing != null)
            {
                EClass._zone.AddCard(thing, GrowSystem.cell.GetPoint()).Install();
            }
            EClass._map.SetObj((int)GrowSystem.cell.x, (int)GrowSystem.cell.z, 0, 1, 0);
            return;
        }
        if (this.WitherOnLastStage && this.stage.idx == this.StageLength - 2)
        {
            this.SetStage(this.StageLength - 1, false);
            return;
        }
        if (EClass.rnd(3) == 0)
        {
            Thing thing2 = this.TryPopSeed(null);
            if (thing2 != null)
            {
                EClass._zone.AddCard(thing2, GrowSystem.cell.GetPoint()).Install();
            }
        }
        EClass._map.SetObj((int)GrowSystem.cell.x, (int)GrowSystem.cell.z, 0, 1, 0);
    }
 
    // Token: 0x06002E74 RID: 11892 RVA: 0x00105E22 File Offset: 0x00104022
    public bool IsWithered()
    {
        return this.WitherOnLastStage && this.stage.idx == this.StageLength - 1;
    }
 
    // Token: 0x06002E75 RID: 11893 RVA: 0x00105E44 File Offset: 0x00104044
    public bool CanHarvest()
    {
        return this.stage.harvest && !GrowSystem.cell.isHarvested;
    }
 
    // Token: 0x06002E76 RID: 11894 RVA: 0x00105E62 File Offset: 0x00104062
    public virtual bool CanReapSeed()
    {
        return this.CanHarvest();
    }
 
    // Token: 0x06002E77 RID: 11895 RVA: 0x00105E6A File Offset: 0x0010406A
    public virtual void OnHit(Chara c)
    {
    }
 
    // Token: 0x06002E78 RID: 11896 RVA: 0x00105E6C File Offset: 0x0010406C
    public virtual void OnHitFail(Chara c)
    {
    }
 
    // Token: 0x06002E79 RID: 11897 RVA: 0x00105E6E File Offset: 0x0010406E
    public void OnProgressComplete(Chara c)
    {
        EClass._map.MineObj(GrowSystem.cell.GetPoint(), null, c);
    }
 
    // Token: 0x06002E7A RID: 11898 RVA: 0x00105E86 File Offset: 0x00104086
    public void PopMineObj(Chara c = null)
    {
        this.OnMineObj(c);
        this.TryPopSeed(c);
    }
 
    // Token: 0x06002E7B RID: 11899 RVA: 0x00105E98 File Offset: 0x00104098
    public virtual void OnMineObj(Chara c = null)
    {
        if (!this.IsWithered())
        {
            int num = GrowSystem.cell.sourceObj.components.Length - 1;
            Thing t = ThingGen.Create(GrowSystem.cell.sourceObj.components[num].Split('/', StringSplitOptions.None)[0], GrowSystem.cell.matObj_fixed.alias);
            this.TryPick(GrowSystem.cell, t, c, false);
        }
    }
 
    // Token: 0x06002E7C RID: 11900 RVA: 0x00105F00 File Offset: 0x00104100
    public void TryPick(Cell cell, Thing t, Chara c, bool applySeed = false)
    {
        if (applySeed)
        {
            this.ApplySeed(t);
        }
        if (EClass.player.isAutoFarming)
        {
            if (EClass.rnd(4) == 0)
            {
                return;
            }
            if (t.Num > 1)
            {
                t.SetNum(t.Num / 2);
            }
            else if (EClass.rnd(2) == 0)
            {
                return;
            }
            if (!EClass._zone.TryAddThingInSharedContainer(t, null, true, false, null, true))
            {
                EClass.game.cards.container_shipping.AddCard(t);
                return;
            }
        }
        else
        {
            EClass._map.TrySmoothPick(cell, t, c);
        }
    }
 
    // Token: 0x06002E7D RID: 11901 RVA: 0x00105F86 File Offset: 0x00104186
    public void TryPick(Cell cell, string idThing, int idMat = -1, int num = 1, bool applySeed = false)
    {
        if (num <= 0)
        {
            return;
        }
        this.TryPick(cell, ThingGen.Create(idThing, idMat, -1).SetNum(num), EClass.pc, applySeed);
    }
 
    // Token: 0x06002E7E RID: 11902 RVA: 0x00105FAC File Offset: 0x001041AC
    public Thing TryPopSeed(Chara c)
    {
        if (this.source.HasTag(CTAG.seed))
        {
            int num = GrowSystem.cell.IsFarmField ? 400 : 1000;
            if (EClass._zone.IsPCFaction)
            {
                int soilCost = EClass._zone.GetSoilCost();
                int maxSoil = EClass.Branch.MaxSoil;
                if (soilCost > maxSoil)
                {
                    num += (soilCost - maxSoil) * 10;
                }
            }
            if (this.IsWithered())
            {
                num /= 5;
            }
            if (EClass.player.isAutoFarming || EClass.rnd(num) < EClass.rnd(this.source.chance))
            {
                Thing thing = TraitSeed.MakeSeed(this.source, EClass._map.TryGetPlant(GrowSystem.cell));
                if (EClass.player.isAutoFarming)
                {
                    return thing;
                }
                this.TryPick(GrowSystem.cell, thing, c, false);
                return thing;
            }
        }
        return null;
    }
 
    // Token: 0x06002E7F RID: 11903 RVA: 0x0010607D File Offset: 0x0010427D
    public void Harvest(Chara c)
    {
        GrowSystem.cell.isHarvested = true;
        GrowSystem.cell.gatherCount = 0;
        this.PopHarvest(c, null, -1);
    }
 
    // Token: 0x06002E80 RID: 11904 RVA: 0x0010609E File Offset: 0x0010429E
    public void PopHarvest(Chara c, string idThing, int num = -1)
    {
        this.PopHarvest(c, ThingGen.Create(idThing, -1, -1), num);
    }
 
    // Token: 0x06002E81 RID: 11905 RVA: 0x001060B0 File Offset: 0x001042B0
    public void PopHarvest(Chara c, Thing t = null, int num = -1)
    {
        if (t == null)
        {
            if (this.idHarvestThing.StartsWith('#'))
            {
                t = ThingGen.CreateFromCategory(this.idHarvestThing.Replace("#", ""), -1);
            }
            else
            {
                t = ThingGen.Create(this.idHarvestThing.IsEmpty("apple"), -1, -1);
            }
        }
        this.ApplySeed(t);
        PlantData plantData = EClass._map.TryGetPlant(GrowSystem.cell);
        if (plantData != null && plantData.size > 0)
        {
            t.c_weight = t.SelfWeight * (80 + plantData.size * plantData.size * 100) / 100;
            t.SetBool(115, true);
            t.isWeightChanged = true;
        }
        t.SetBlessedState(BlessedState.Normal);
        if (this.source._growth.Length > 4)
        {
            int num2 = EClass.rnd(this.source._growth[4].ToInt()) + 1;
            if (EClass._zone.IsPCFaction)
            {
                int soilCost = EClass._zone.GetSoilCost();
                int maxSoil = EClass.Branch.MaxSoil;
                if (soilCost > maxSoil && EClass.player.stats.days >= 5)
                {
                    num2 -= EClass.rnd(2 + (soilCost - maxSoil) / 20);
                }
            }
            if (num2 <= 0)
            {
                if (!EClass.player.isAutoFarming)
                {
                    c.Say("cropSpoiled", c, GrowSystem.cell.GetObjName(), null);
                }
                return;
            }
            t.SetNum(num2);
        }
        else
        {
            Debug.Log("harvest count not set:" + this.source.id.ToString() + "/" + this.source.alias);
        }
        if (num != -1)
        {
            t.SetNum(num);
        }
        if (c == null || EClass.player.isAutoFarming)
        {
            this.TryPick(GrowSystem.cell, t, c, false);
            return;
        }
        c.Pick(t, true, true);
    }
 
    // Token: 0x06002E82 RID: 11906 RVA: 0x00106270 File Offset: 0x00104470
    public void ApplySeed(Thing t)
    {
        PlantData plantData = EClass._map.TryGetPlant(GrowSystem.cell);
        Thing thing = (plantData != null) ? plantData.seed : null;
        if (EClass._zone.IsUserZone)
        {
            thing = null;
        }
        if (thing != null)
        {
            int encLv = thing.encLV / 10 + ((thing.encLV > 0) ? 1 : 0);
            foreach (Element element in thing.elements.dict.Values)
            {
                if ((!element.IsFoodTrait || t.IsFood) && (element.IsFoodTrait || element.id == 2))
                {
                    t.elements.ModBase(element.id, element.Value / 10 * 10);
                }
            }
            t.SetEncLv(encLv);
            t.c_refText = thing.c_refText;
            t.isCrafted = true;
        }
    }
 
    // Token: 0x06002E83 RID: 11907 RVA: 0x00106368 File Offset: 0x00104568
    public virtual int GetHp()
    {
        return this.source.hp;
    }
 
    // Token: 0x04001A4D RID: 6733
    public static SourceObj.Row[] sourceSnowTree = new SourceObj.Row[]
    {
        EClass.sources.objs.map[54],
        EClass.sources.objs.map[55]
    };
 
    // Token: 0x04001A4E RID: 6734
    public const int DivStage = 30;
 
    // Token: 0x04001A4F RID: 6735
    public static Cell cell;
 
    // Token: 0x04001A50 RID: 6736
    public static GrowSystem.Stage currentStage;
 
    // Token: 0x04001A51 RID: 6737
    public SourceObj.Row source;
 
    // Token: 0x04001A52 RID: 6738
    public GrowSystem.Stage[] stages;
 
    // Token: 0x04001A53 RID: 6739
    public int[] baseTiles;
 
    // Token: 0x04001A54 RID: 6740
    public int harvestTile;
 
    // Token: 0x04001A55 RID: 6741
    public int afterHarvestTile;
 
    // Token: 0x04001A56 RID: 6742
    public string idHarvestThing;
 
    // Token: 0x02000BE3 RID: 3043
    public class Stage
    {
        // Token: 0x060045CA RID: 17866 RVA: 0x0015FA93 File Offset: 0x0015DC93
        public void SetTile(int _tile)
        {
            this.tiles = new int[this.Convert(_tile)];
        }
 
        // Token: 0x060045CB RID: 17867 RVA: 0x0015FAA8 File Offset: 0x0015DCA8
        public void SetTile(int tileIdx, params int[] _tiles)
        {
            this.tiles = new int[_tiles.Length];
            for (int i = 0; i < this.tiles.Length; i++)
            {
                this.tiles[i] = this.Convert(_tiles[i] + tileIdx);
            }
        }
 
        // Token: 0x060045CC RID: 17868 RVA: 0x0015FAE9 File Offset: 0x0015DCE9
        public int Convert(int tile)
        {
            return this.renderData.ConvertTile(tile);
        }
 
        // Token: 0x04002F7A RID: 12154
        public int[] tiles;
 
        // Token: 0x04002F7B RID: 12155
        public int idx;
 
        // Token: 0x04002F7C RID: 12156
        public int tileEx;
 
        // Token: 0x04002F7D RID: 12157
        public RenderData renderData;
 
        // Token: 0x04002F7E RID: 12158
        public bool harvest;
    }
    public class Stage {…};
}
public class GrowSystem : EClass {…};