TaskBuild.cs

using System;
using System.Collections.Generic;
using Newtonsoft.Json;
using UnityEngine;
 
// Token: 0x0200025F RID: 607
public class TaskBuild : TaskBaseBuild
{
    // Token: 0x17000493 RID: 1171
    // (get) Token: 0x0600110E RID: 4366 RVA: 0x000765D3 File Offset: 0x000747D3
    public override int destDist
    {
        get
        {
            return 1;
        }
    }
 
    // Token: 0x0600110F RID: 4367 RVA: 0x000765D6 File Offset: 0x000747D6
    public override bool CanManualCancel()
    {
        return true;
    }
 
    // Token: 0x17000494 RID: 1172
    // (get) Token: 0x06001110 RID: 4368 RVA: 0x000765D9 File Offset: 0x000747D9
    public override bool CanPressRepeat
    {
        get
        {
            return this.useHeld && EClass.pc.held != null && EClass.pc.held.trait.CanExtendBuild;
        }
    }
 
    // Token: 0x17000495 RID: 1173
    // (get) Token: 0x06001111 RID: 4369 RVA: 0x00076607 File Offset: 0x00074807
    public override bool HasProgress
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x17000496 RID: 1174
    // (get) Token: 0x06001112 RID: 4370 RVA: 0x0007660A File Offset: 0x0007480A
    public override bool destIgnoreConnection
    {
        get
        {
            return this.recipe.IsFloorOrBridge;
        }
    }
 
    // Token: 0x17000497 RID: 1175
    // (get) Token: 0x06001113 RID: 4371 RVA: 0x00076617 File Offset: 0x00074817
    public bool useHeld
    {
        get
        {
            return this.held != null;
        }
    }
 
    // Token: 0x17000498 RID: 1176
    // (get) Token: 0x06001114 RID: 4372 RVA: 0x00076622 File Offset: 0x00074822
    public override int W
    {
        get
        {
            return this.recipe.W;
        }
    }
 
    // Token: 0x17000499 RID: 1177
    // (get) Token: 0x06001115 RID: 4373 RVA: 0x0007662F File Offset: 0x0007482F
    public override int H
    {
        get
        {
            return this.recipe.H;
        }
    }
 
    // Token: 0x1700049A RID: 1178
    // (get) Token: 0x06001116 RID: 4374 RVA: 0x0007663C File Offset: 0x0007483C
    public override bool isBlock
    {
        get
        {
            return this.recipe.IsBlock;
        }
    }
 
    // Token: 0x06001117 RID: 4375 RVA: 0x0007664C File Offset: 0x0007484C
    public override string GetText(string str = "")
    {
        if (this.useHeld && EClass.pc.held != null)
        {
            if (EClass.pc.held.category.id == "seed")
            {
                return "actInstallSeed".lang();
            }
            if (EClass.pc.held.id == "fertilizer")
            {
                return "actInstallFertilizer".lang();
            }
        }
        return base.GetText(str);
    }
 
    // Token: 0x06001118 RID: 4376 RVA: 0x000766C8 File Offset: 0x000748C8
    public override bool _CanPerformTask(Chara chara, int radius)
    {
        Recipe.Ingredient ingredient = this.recipe.ingredients[0];
        if (!ingredient.IsThingSpecified && ingredient.thing == null)
        {
            ingredient.thing = EClass._map.Stocked.Find(ingredient.id, ingredient.mat, ingredient.refVal, false);
            if (ingredient.thing == null)
            {
                base.TryLayer(30);
                return false;
            }
        }
        return true;
    }
 
    // Token: 0x06001119 RID: 4377 RVA: 0x00076734 File Offset: 0x00074934
    public override void OnAdd()
    {
        if (this.reqs == null)
        {
            this.reqs = new int[this.recipe.ingredients.Count];
            for (int i = 0; i < this.recipe.ingredients.Count; i++)
            {
                this.reqs[i] = this.recipe.ingredients[i].req;
            }
        }
    }
 
    // Token: 0x0600111A RID: 4378 RVA: 0x000767A0 File Offset: 0x000749A0
    public override HitResult GetHitResult()
    {
        if (!this.pos.IsValid || (!this.pos.IsInBoundsPlus && !EClass.debug.ignoreBuildRule))
        {
            return HitResult.Invalid;
        }
        if (this.recipe == null)
        {
            Debug.Log("recipe is null");
            return HitResult.Invalid;
        }
        if (this.useHeld)
        {
            if (EClass.pc.held == null || EClass.pc.held.GetRootCard() != EClass.pc || EClass.pc.held != this.held)
            {
                return HitResult.Invalid;
            }
            if (EClass.pc.held.TileType.IsBlockPass && this.pos.HasChara)
            {
                return HitResult.Invalid;
            }
            if (this.pos.HasBlock && EClass.pc.held.TileType.IsDoor && this.pos.HasWallOrFence && this.pos.cell.blockDir != 2)
            {
                this.recipe.SetDir((this.pos.cell.blockDir == 0) ? 0 : 1);
            }
            if (!EClass.debug.ignoreBuildRule && !EClass._zone.IsPCFaction)
            {
                if (!(EClass._zone is Zone_Tent) && !EClass._zone.IsPCFaction && EClass.pc.held.trait.CanBeOnlyBuiltInHome)
                {
                    return HitResult.Invalid;
                }
                if (EClass._zone.RestrictBuild && !EClass.pc.held.trait.CanBuildInTown)
                {
                    return HitResult.Invalid;
                }
            }
        }
        if (this.lastPos != null)
        {
            if (this.recipe.IsBlock && this.lastPos.x != this.pos.x && this.lastPos.z != this.pos.z)
            {
                return HitResult.Invalid;
            }
            if (this.recipe.IsWallOrFence && ((this.recipe._dir == 0 && this.pos.z != this.lastPos.z) || (this.recipe._dir == 1 && this.pos.x != this.lastPos.x)))
            {
                return HitResult.Invalid;
            }
        }
        if (!false && this.recipe.HasSameTile(this.pos, this.recipe._dir, this.altitude, this.bridgeHeight))
        {
            return HitResult.Default;
        }
        if (this.recipe.IsThing)
        {
            CardRow cardRow = this.recipe.renderRow as CardRow;
            if (cardRow != null && !base.CanPlaceCard(this.pos, cardRow.model))
            {
                return HitResult.Invalid;
            }
            if (this.recipe.MultiSize && this.useHeld)
            {
                Point point = new Point();
                for (int i = 0; i < this.H; i++)
                {
                    for (int j = 0; j < this.W; j++)
                    {
                        point.Set(this.pos.x - j, this.pos.z + i);
                        if (!point.IsValid)
                        {
                            return HitResult.Invalid;
                        }
                        HitResult hitResult = this._GetHitResult(point);
                        if (hitResult != HitResult.Valid && hitResult != HitResult.Warning)
                        {
                            return HitResult.Invalid;
                        }
                    }
                }
                return HitResult.Valid;
            }
        }
        if (this.recipe.IsWallOrFence && this.pos.HasWallOrFence && AM_Adv.actCount == 0 && this.recipe._dir != this.pos.cell.blockDir)
        {
            return HitResult.Valid;
        }
        if (!this.useHeld && EClass.debug.ignoreBuildRule)
        {
            return HitResult.Valid;
        }
        if (EClass.scene.actionMode.IsRoofEditMode(null))
        {
            return HitResult.Valid;
        }
        return this._GetHitResult(this.pos);
    }
 
    // Token: 0x0600111B RID: 4379 RVA: 0x00076B24 File Offset: 0x00074D24
    public HitResult _GetHitResult(Point p)
    {
        if (this.useHeld)
        {
            if (EClass.pc.held == null || EClass.pc.held.isDestroyed)
            {
                return HitResult.Invalid;
            }
            if (p.Installed != null)
            {
                if (p.Installed.trait is TraitSeed && !(EClass.pc.held.trait is TraitFertilizer))
                {
                    return HitResult.Invalid;
                }
                if (EClass.pc.held.trait is TraitFertilizer && p.Things.LastItem<Thing>().trait is TraitFertilizer)
                {
                    return HitResult.Invalid;
                }
                if (EClass.pc.held.trait is TraitSeed)
                {
                    using (List<Thing>.Enumerator enumerator = p.Things.GetEnumerator())
                    {
                        while (enumerator.MoveNext())
                        {
                            if (enumerator.Current.trait is TraitSeed)
                            {
                                return HitResult.Invalid;
                            }
                        }
                    }
                }
            }
        }
        return this.recipe.tileType._HitTest(p, this.recipe.Mold, true);
    }
 
    // Token: 0x0600111C RID: 4380 RVA: 0x00076C44 File Offset: 0x00074E44
    public override void OnProgressComplete()
    {
        if (this.useHeld)
        {
            if (EClass.pc.held == null || EClass.pc.held.GetRootCard() != EClass.pc || this.pos.Distance(EClass.pc.pos) > 1 || !this.pos.IsInBounds)
            {
                return;
            }
            ActionMode.Build.FixBridge(this.pos, this.recipe);
            this.bridgeHeight = ActionMode.Build.bridgeHeight;
            this.target = (EClass.pc.held.category.installOne ? EClass.pc.held.Split(1) : EClass.pc.held);
            if (this.target.trait is TraitTile)
            {
                this.target.ModNum(-1, true);
            }
            this.dir = this.recipe._dir;
            EClass.pc.LookAt(this.pos);
            EClass.pc.renderer.PlayAnime(AnimeID.Attack_Place, this.pos);
            if (this.target.id == "statue_weird")
            {
                EClass.pc.Say("statue_install", null, null);
            }
        }
        this.lastPos = this.pos.Copy();
        if (ActionMode.Build.IsActive && ActionMode.Build.IsFillMode())
        {
            if (this.recipe.IsBridge)
            {
                this.dir = this.pos.cell.floorDir;
                this.bridgeHeight = (int)this.pos.cell.bridgeHeight;
                this.altitude = 0;
            }
            else if (this.recipe.IsFloor)
            {
                this.dir = this.pos.cell.floorDir;
            }
            else if (this.recipe.IsBlock)
            {
                this.dir = this.pos.cell.blockDir;
            }
        }
        else
        {
            Effect.Get("smoke").Play(this.pos, 0f, null, null);
            Effect.Get("mine").Play(this.pos, 0f, null, null).SetParticleColor(this.recipe.GetColorMaterial().GetColor()).Emit(10 + EClass.rnd(10));
            if (this.recipe.IsWallOrFence)
            {
                if (this.pos.HasWallOrFence && this.pos.cell.blockDir != 2 && this.pos.cell.blockDir != this.recipe._dir)
                {
                    this.pos.cell.blockDir = 2;
                    EClass.pc.PlaySound(this.pos.matBlock.GetSoundImpact(null), 1f, true);
                    this.pos.RefreshTile();
                    return;
                }
                if (this.pos.sourceRoofBlock.tileType.IsWallOrFence && this.pos.cell._roofBlockDir % 4 != 2 && (int)(this.pos.cell._roofBlockDir % 4) != this.recipe._dir)
                {
                    this.pos.cell._roofBlockDir = this.pos.cell._roofBlockDir / 4 * 4 + 2;
                    EClass.pc.PlaySound(this.pos.matBlock.GetSoundImpact(null), 1f, true);
                    this.pos.RefreshTile();
                    return;
                }
            }
        }
        if (this.bridgeHeight > 150)
        {
            this.bridgeHeight = 150;
        }
        this.recipe.Build(this);
        this.resources.Clear();
        EClass.player.flags.OnBuild(this.recipe);
        EClass._map.RefreshShadow(this.pos.x, this.pos.z);
        EClass._map.RefreshShadow(this.pos.x, this.pos.z - 1);
        EClass._map.RefreshFOV(this.pos.x, this.pos.z, 6, false);
        EClass.pc.renderer.SetFirst(true);
        if (this.recipe.IsFloor)
        {
            foreach (Card card in this.pos.ListThings<TraitNewZone>(true))
            {
                bool isDownstairs = (card.trait as TraitNewZone).IsDownstairs;
            }
        }
    }
 
    // Token: 0x0600111D RID: 4381 RVA: 0x000770F0 File Offset: 0x000752F0
    public override void OnDestroy()
    {
        foreach (Thing t in this.resources)
        {
            EClass._zone.AddCard(t, this.pos);
        }
    }
 
    // Token: 0x0600111E RID: 4382 RVA: 0x00077150 File Offset: 0x00075350
    public override void DrawMarker(int x, int z, RenderParam p)
    {
        this.recipe.OnRenderMarker(Point.shared.Set(x, z), this.owner != null, HitResult.Default, x == this.pos.x && z == this.pos.z, this.dir, this.bridgeHeight + this.altitude);
    }
 
    // Token: 0x04000DD5 RID: 3541
    [JsonProperty]
    public Recipe recipe;
 
    // Token: 0x04000DD6 RID: 3542
    [JsonProperty]
    public int dir;
 
    // Token: 0x04000DD7 RID: 3543
    [JsonProperty]
    public int bridgeHeight;
 
    // Token: 0x04000DD8 RID: 3544
    [JsonProperty]
    public int altitude;
 
    // Token: 0x04000DD9 RID: 3545
    [JsonProperty]
    public List<Thing> resources = new List<Thing>();
 
    // Token: 0x04000DDA RID: 3546
    [JsonProperty]
    public int[] reqs;
 
    // Token: 0x04000DDB RID: 3547
    public Card held;
 
    // Token: 0x04000DDC RID: 3548
    public float fx;
 
    // Token: 0x04000DDD RID: 3549
    public float fy;
 
    // Token: 0x04000DDE RID: 3550
    public bool freePos;
 
    // Token: 0x04000DDF RID: 3551
    public Card target;
 
    // Token: 0x04000DE0 RID: 3552
    public Point lastPos;
}