TaskHarvest.cs

using System;
using System.Runtime.CompilerServices;
using UnityEngine;
 
// Token: 0x02000258 RID: 600
public class TaskHarvest : BaseTaskHarvest
{
    // Token: 0x1700047F RID: 1151
    // (get) Token: 0x060010C9 RID: 4297 RVA: 0x00074B32 File Offset: 0x00072D32
    public bool IsObj
    {
        get
        {
            return this.mode == BaseTaskHarvest.HarvestType.Obj;
        }
    }
 
    // Token: 0x17000480 RID: 1152
    // (get) Token: 0x060010CA RID: 4298 RVA: 0x00074B40 File Offset: 0x00072D40
    public bool IsReapSeed
    {
        get
        {
            return this.IsObj && this.CanReapSeed && this.owner.Tool != null && (this.owner.Tool.trait is TraitToolSickle || this.owner.Tool.category.IsChildOf("scythe"));
        }
    }
 
    // Token: 0x17000481 RID: 1153
    // (get) Token: 0x060010CB RID: 4299 RVA: 0x00074B9F File Offset: 0x00072D9F
    public override BaseTaskHarvest.HarvestType harvestType
    {
        get
        {
            return this.mode;
        }
    }
 
    // Token: 0x17000482 RID: 1154
    // (get) Token: 0x060010CC RID: 4300 RVA: 0x00074BA7 File Offset: 0x00072DA7
    public override int RightHand
    {
        get
        {
            return 1005;
        }
    }
 
    // Token: 0x17000483 RID: 1155
    // (get) Token: 0x060010CD RID: 4301 RVA: 0x00074BAE File Offset: 0x00072DAE
    public override int destDist
    {
        get
        {
            return 1;
        }
    }
 
    // Token: 0x17000484 RID: 1156
    // (get) Token: 0x060010CE RID: 4302 RVA: 0x00074BB1 File Offset: 0x00072DB1
    public override bool IsGrowth
    {
        get
        {
            return this.pos.growth != null;
        }
    }
 
    // Token: 0x17000485 RID: 1157
    // (get) Token: 0x060010CF RID: 4303 RVA: 0x00074BC4 File Offset: 0x00072DC4
    public override bool IsHostileAct
    {
        get
        {
            if (!this.wasCrime)
            {
                if (this.mode == BaseTaskHarvest.HarvestType.Disassemble)
                {
                    Thing target = this.target;
                    if (target != null && target.isNPCProperty)
                    {
                        return true;
                    }
                }
                return this.mode == BaseTaskHarvest.HarvestType.Obj && (this.pos.sourceObj.ContainsTag("crime") || (this.pos.growth != null && this.pos.growth.IsCrimeToHarvest && !(EClass._zone is Zone_Harvest)));
            }
            return true;
        }
    }
 
    // Token: 0x060010D0 RID: 4304 RVA: 0x00074C4D File Offset: 0x00072E4D
    public override bool CanManualCancel()
    {
        return true;
    }
 
    // Token: 0x060010D1 RID: 4305 RVA: 0x00074C50 File Offset: 0x00072E50
    public override string GetBaseText(string str)
    {
        if (this.IsReapSeed)
        {
            return "TaskHarvestSeed".lang();
        }
        if (this.mode == BaseTaskHarvest.HarvestType.Disassemble)
        {
            return (this.HaveHarvestThing() ? "TaskDisassemble" : "TaskDisassemble_destroy").lang();
        }
        if (!base.IsHarvest)
        {
            return base.GetBaseText(str);
        }
        return "actHarvest".lang();
    }
 
    // Token: 0x060010D2 RID: 4306 RVA: 0x00074CAD File Offset: 0x00072EAD
    public override string GetTextSmall(Card c)
    {
        if (this.IsObj)
        {
            return base.GetTextSmall(c);
        }
        if (this.target == null)
        {
            return "";
        }
        return this.target.Name;
    }
 
    // Token: 0x060010D3 RID: 4307 RVA: 0x00074CD8 File Offset: 0x00072ED8
    public static TaskHarvest TryGetAct(Chara c, Point p)
    {
        TaskHarvest.<>c__DisplayClass20_0 CS$<>8__locals1;
        CS$<>8__locals1.p = p;
        CS$<>8__locals1.t = c.Tool;
        CS$<>8__locals1.hasTool = (CS$<>8__locals1.t != null && (CS$<>8__locals1.t.HasElement(225, 1) || CS$<>8__locals1.t.HasElement(220, 1)));
        CS$<>8__locals1.hasDiggingTool = (CS$<>8__locals1.t != null && CS$<>8__locals1.t.HasElement(230, 1));
        if (CS$<>8__locals1.t != null)
        {
            if (CS$<>8__locals1.t.trait is TraitToolWaterCan)
            {
                return null;
            }
            if (CS$<>8__locals1.t.trait is TraitToolMusic)
            {
                return null;
            }
            if (CS$<>8__locals1.t.trait is TraitToolSickle && !CS$<>8__locals1.p.cell.CanReapSeed())
            {
                return null;
            }
        }
        if (CS$<>8__locals1.p.HasObj && TaskHarvest.<TryGetAct>g__IsValidTarget|20_0(CS$<>8__locals1.p.sourceObj.reqHarvest, ref CS$<>8__locals1))
        {
            return new TaskHarvest
            {
                pos = CS$<>8__locals1.p.Copy()
            };
        }
        if (CS$<>8__locals1.p.HasThing)
        {
            for (int i = CS$<>8__locals1.p.Things.Count - 1; i >= 0; i--)
            {
                CS$<>8__locals1.t = CS$<>8__locals1.p.Things[i];
                if (CS$<>8__locals1.t.trait.ReqHarvest != null && TaskHarvest.<TryGetAct>g__IsValidTarget|20_0(CS$<>8__locals1.t.trait.ReqHarvest.Split(',', StringSplitOptions.None), ref CS$<>8__locals1))
                {
                    return new TaskHarvest
                    {
                        pos = CS$<>8__locals1.p.Copy(),
                        mode = BaseTaskHarvest.HarvestType.Thing,
                        target = CS$<>8__locals1.t
                    };
                }
            }
            for (int j = CS$<>8__locals1.p.Things.Count - 1; j >= 0; j--)
            {
                CS$<>8__locals1.t = CS$<>8__locals1.p.Things[j];
                if (!CS$<>8__locals1.t.isHidden && !CS$<>8__locals1.t.isMasked && CS$<>8__locals1.t.trait.CanBeDisassembled)
                {
                    Thing tool = c.Tool;
                    if (((tool != null) ? tool.trait : null) is TraitToolHammer)
                    {
                        return new TaskHarvest
                        {
                            pos = CS$<>8__locals1.p.Copy(),
                            mode = BaseTaskHarvest.HarvestType.Disassemble,
                            target = CS$<>8__locals1.t
                        };
                    }
                }
            }
        }
        return null;
    }
 
    // Token: 0x060010D4 RID: 4308 RVA: 0x00074F38 File Offset: 0x00073138
    public override bool CanProgress()
    {
        if (this.IsObj)
        {
            base.SetTarget(this.owner ?? EClass.pc, null);
            return base.CanProgress() && this.pos.HasObj;
        }
        return this.target != null && this.target.ExistsOnMap && base.CanProgress();
    }
 
    // Token: 0x060010D5 RID: 4309 RVA: 0x00074F98 File Offset: 0x00073198
    public override HitResult GetHitResult()
    {
        if (this.IsObj)
        {
            if (base.IsHarvest)
            {
                return HitResult.Valid;
            }
            if (this.pos.HasObj)
            {
                return HitResult.Valid;
            }
            if (this.pos.HasDecal && EClass.debug.godBuild && BuildMenu.Instance)
            {
                return HitResult.Valid;
            }
            return HitResult.Default;
        }
        else
        {
            if (this.target == null || !this.target.ExistsOnMap)
            {
                return HitResult.Default;
            }
            return HitResult.Valid;
        }
    }
 
    // Token: 0x060010D6 RID: 4310 RVA: 0x00075008 File Offset: 0x00073208
    public override void OnCreateProgress(Progress_Custom p)
    {
        base.SetTarget(this.owner, null);
        string n = this.IsObj ? this.pos.cell.GetObjName() : this.target.Name;
        SourceMaterial.Row mat = this.IsObj ? this.pos.cell.matObj : this.target.material;
        GrowSystem growth = this.pos.growth;
        float num = base.IsHarvest ? 0.5f : ((!this.IsObj) ? 1f : ((growth != null) ? growth.MtpProgress : 1f));
        int exp = 50;
        this.wasReapSeed = this.IsReapSeed;
        this.wasCrime = this.IsHostileAct;
        p.textHint = n;
        p.maxProgress = (int)((float)(this.maxProgress * 150) * num / 100f);
        p.interval = 1;
        p.onProgressBegin = delegate()
        {
            if (this.IsTooHard)
            {
                this.owner.Say((this.mode == BaseTaskHarvest.HarvestType.Disassemble) ? "tooHardToDisassemble" : "tooHardToHarvest", this.owner, n, null);
                p.Cancel();
                return;
            }
            if (this.mode == BaseTaskHarvest.HarvestType.Disassemble)
            {
                this.owner.Say("disassemble_start", this.owner, this.owner.Tool, n, null);
                return;
            }
            if (this.owner.Tool == null)
            {
                this.owner.Say("harvestHand_start", this.owner, n, null);
                return;
            }
            this.owner.Say("harvest_start", this.owner, this.owner.Tool, n, null);
        };
        p.onProgress = delegate(Progress_Custom _p)
        {
            this.owner.LookAt(this.pos);
            this.owner.renderer.NextFrame();
            if (_p.progress % 2 == 0)
            {
                if (this.IsObj)
                {
                    if (this.IsHarvest && growth != null)
                    {
                        this.owner.PlaySound(growth.GetSoundProgress(), 1f, true);
                        if (growth.AnimeProgress != AnimeID.None)
                        {
                            this.pos.Animate(growth.AnimeProgress, false);
                        }
                        return;
                    }
                    this.pos.Animate(AnimeID.HitObj, false);
                }
                else
                {
                    this.target.PlayAnime(AnimeID.HitObj, false);
                }
                this.pos.PlaySound(mat.GetSoundImpact(null), true, 1f, true);
                mat.PlayHitEffect(this.pos);
                mat.AddBlood(this.pos, 1);
                this.effectFrame += this.maxProgress / 4 + 1;
                if (EClass._zone.IsCrime(this.owner, this))
                {
                    this.owner.pos.TryWitnessCrime(this.owner, null, 4, null);
                }
            }
        };
        p.onProgressComplete = delegate()
        {
            string idRecipe = this.IsObj ? this.pos.sourceObj.RecipeID : ((this.target != null) ? this.target.source.RecipeID : "");
            SourceBacker.Row backerObj = EClass._map.GetBackerObj(this.pos);
            int num2 = (EClass.rnd(3) == 0) ? 0 : 1;
            if (this.IsObj)
            {
                SourceObj.Row sourceObj = this.pos.sourceObj;
                bool flag = false;
                if (this.difficulty >= 0 && EClass.rnd(6) == 0)
                {
                    flag = true;
                }
                if (this.difficulty >= 2 && EClass.rnd(3) == 0)
                {
                    flag = true;
                }
                if (flag && growth != null)
                {
                    growth.OnHitFail(this.owner);
                }
                if (EClass._zone is Zone_Harvest && !this.IsHarvest && this.pos.IsFarmField)
                {
                    EClass._map.DestroyObj(this.pos);
                    this.pos.SetObj(0, 1, 0);
                }
                else
                {
                    if (this.IsHarvest && !this.IsReapSeed)
                    {
                        this.pos.growth.Harvest(this.owner);
                    }
                    else if (growth != null && !this.IsReapSeed)
                    {
                        growth.OnProgressComplete(this.owner);
                    }
                    else
                    {
                        EClass._map.MineObj(this.pos, this, null);
                    }
                    if (sourceObj.alias == "mound")
                    {
                        if (EClass.rnd(7) == 0)
                        {
                            EClass._zone.AddThing("plat", this.pos);
                        }
                        else if (EClass.rnd(3) == 0)
                        {
                            EClass._zone.AddCard(ThingGen.CreateFromCategory("junk", -1), this.pos);
                        }
                        else
                        {
                            EClass._zone.AddThing("bone", this.pos);
                        }
                    }
                }
            }
            else
            {
                exp = this.target.Num * 5;
                num2 = this.target.Num / 3 + EClass.rnd(this.target.Num / 3 + 2);
                this.HarvestThing();
            }
            if (EClass._zone.IsCrime(this.owner, this) && EClass.rnd(3) != 0)
            {
                EClass.player.ModKarma(-1);
            }
            if (backerObj != null)
            {
                if (backerObj != null && !backerObj.loot.IsEmpty() && !EClass.player.doneBackers.Contains(backerObj.id))
                {
                    if (EClass.sources.cards.map.ContainsKey(backerObj.loot))
                    {
                        Thing thing = ThingGen.Create(backerObj.loot, -1, -1);
                        int id = backerObj.id;
                        if (id <= 2531)
                        {
                            if (id <= 867)
                            {
                                if (id == 471)
                                {
                                    goto IL_4BC;
                                }
                                if (id != 490 && id != 867)
                                {
                                    goto IL_4F7;
                                }
                            }
                            else if (id <= 1828)
                            {
                                if (id == 1027)
                                {
                                    thing.ChangeMaterial(25);
                                    thing.SetBlessedState(BlessedState.Doomed);
                                    thing.ChangeRarity(Rarity.Legendary);
                                    goto IL_4F7;
                                }
                                if (id != 1828)
                                {
                                    goto IL_4F7;
                                }
                                goto IL_4BC;
                            }
                            else
                            {
                                if (id == 1854)
                                {
                                    thing.decay = 10000;
                                    goto IL_4F7;
                                }
                                if (id != 2531)
                                {
                                    goto IL_4F7;
                                }
                                thing.MakeFoodFrom("putty");
                                goto IL_4F7;
                            }
                        }
                        else if (id <= 4788)
                        {
                            if (id == 4565)
                            {
                                EClass._zone.AddThing("rod", this.pos);
                                EClass._zone.AddThing("money", this.pos).SetNum(121);
                                goto IL_4F7;
                            }
                            if (id == 4615)
                            {
                                thing.ChangeMaterial("meat");
                                goto IL_4F7;
                            }
                            if (id != 4788)
                            {
                                goto IL_4F7;
                            }
                            thing.SetEncLv(1);
                            goto IL_4F7;
                        }
                        else if (id <= 5367)
                        {
                            if (id != 5160)
                            {
                                if (id != 5367)
                                {
                                    goto IL_4F7;
                                }
                                thing.Dye("obsidian");
                                goto IL_4F7;
                            }
                        }
                        else
                        {
                            if (id == 5529)
                            {
                                thing.ChangeMaterial(25);
                                goto IL_4F7;
                            }
                            if (id != 5765)
                            {
                                goto IL_4F7;
                            }
                            goto IL_4BC;
                        }
                        thing.c_charges = 0;
                        thing.c_priceFix = -100;
                        goto IL_4F7;
                        IL_4BC:
                        thing.SetBlessedState(BlessedState.Cursed);
                        IL_4F7:
                        EClass._zone.AddCard(thing, this.pos);
                    }
                    else
                    {
                        Debug.LogError("exception: Backer Loot not valid:" + backerObj.id.ToString() + "/" + backerObj.loot);
                    }
                    Debug.Log(string.Concat(new string[]
                    {
                        backerObj.id.ToString(),
                        "/",
                        backerObj.Name,
                        "/",
                        backerObj.loot
                    }));
                }
                EClass.player.doneBackers.Add(backerObj.id);
                if (!backerObj.Text.IsEmpty() && EClass.core.config.backer.Show(backerObj))
                {
                    bool flag2 = backerObj.type == 1;
                    Msg.Say(flag2 ? "backerRemain_read" : "backerTree_read");
                    Msg.Say(flag2 ? "backerRemain" : "backerTree", backerObj.Text, null, null, null);
                }
            }
            if (this.owner.IsPC)
            {
                EClass.pc.CalculateFOV();
            }
            this.owner.elements.ModExp(this.idEle, exp, false);
            if (this.wasReapSeed)
            {
                this.owner.ModExp(286, 20);
            }
            this.owner.stamina.Mod(-num2);
            if (this.owner == null)
            {
                return;
            }
            if (this.owner.IsPC)
            {
                EClass.player.recipes.ComeUpWithRecipe(idRecipe, 30);
            }
        };
    }
 
    // Token: 0x060010D7 RID: 4311 RVA: 0x0007517C File Offset: 0x0007337C
    public bool HaveHarvestThing()
    {
        string text = this.target.source.components[0].Split('|', StringSplitOptions.None)[0].Split('/', StringSplitOptions.None)[0];
        if (this.target.IsEquipmentOrRanged || this.target.IsAmmo)
        {
            text = this.target.material.thing;
        }
        return !(this.target.trait is TraitGrave) && !text.Contains("$") && !text.Contains("#") && !text.Contains("@") && !text.Contains("-") && !(text == this.target.id) && EClass.sources.cards.map.ContainsKey(text) && !this.target.source.components.IsEmpty();
    }
 
    // Token: 0x060010D8 RID: 4312 RVA: 0x0007526C File Offset: 0x0007346C
    public void HarvestThing()
    {
        string text = this.target.source.components[0].Split('|', StringSplitOptions.None)[0].Split('/', StringSplitOptions.None)[0];
        if (this.target.IsEquipmentOrRanged || this.target.IsAmmo)
        {
            text = this.target.material.thing;
        }
        float num = (float)this.target.Num;
        float num2 = 1.1f;
        if (text == "log" || text == "rock")
        {
            num2 = 2.2f;
        }
        if (this.target.trait is TraitAmmo)
        {
            num2 = 50f;
        }
        float num3 = num % num2;
        num /= num2;
        if (num3 > 0f && EClass.rndf(num2 - num3 + 1f) < 1f)
        {
            num += 1f;
        }
        if (this.target.sockets != null)
        {
            this.target.EjectSockets();
        }
        int decay = this.target.decay;
        int lv = this.target.LV;
        this.target.Die(null, null, AttackSource.None);
        if (this.target.trait is TraitGrave)
        {
            return;
        }
        if (text.Contains("$") || text.Contains("#") || text.Contains("@") || text.Contains("-"))
        {
            return;
        }
        if (text == this.target.id || !EClass.sources.cards.map.ContainsKey(text))
        {
            return;
        }
        if ((int)num <= 0 || this.target.source.components.IsEmpty())
        {
            return;
        }
        if (this.target.isCopy)
        {
            text = "ash3";
        }
        CardBlueprint.Set(new CardBlueprint
        {
            fixedQuality = true
        });
        Thing thing = ThingGen.Create(text, 1, Mathf.Max(1, lv * 2 / 3));
        if (thing != null)
        {
            thing.SetNum((int)num);
            thing.ChangeMaterial(this.target.material);
            thing.decay = decay;
            if (thing.IsDecayed && thing.IsFood)
            {
                thing.elements.SetBase(73, -10, 0);
            }
            EClass._map.TrySmoothPick(this.pos.IsBlocked ? this.owner.pos : this.pos, thing, EClass.pc);
        }
    }
 
    // Token: 0x060010DA RID: 4314 RVA: 0x000754DC File Offset: 0x000736DC
    [CompilerGenerated]
    internal static bool <TryGetAct>g__IsValidTarget|20_0(string[] raw, ref TaskHarvest.<>c__DisplayClass20_0 A_1)
    {
        if (raw[0] == "digging")
        {
            return A_1.hasDiggingTool;
        }
        bool flag = A_1.p.cell.CanHarvest();
        int num = flag ? 250 : EClass.sources.elements.alias[raw[0]].id;
        bool flag2 = !flag && num != 250;
        return (flag2 || A_1.t == null || A_1.t.trait.CanHarvest) && (!flag2 | A_1.hasTool);
    }
 
    // Token: 0x04000DCD RID: 3533
    public bool wasReapSeed;
 
    // Token: 0x04000DCE RID: 3534
    public bool wasCrime;
 
    // Token: 0x04000DCF RID: 3535
    public BaseTaskHarvest.HarvestType mode = BaseTaskHarvest.HarvestType.Obj;
}