AM_MoveInstalled.cs

using System;
using System.Collections.Generic;
using UnityEngine;
 
// Token: 0x0200014A RID: 330
public class AM_MoveInstalled : AM_Designation<TaskMoveInstalled>
{
    // Token: 0x06000981 RID: 2433 RVA: 0x0003A744 File Offset: 0x00038944
    public override bool IsRoofEditMode(Card c = null)
    {
        return ActionMode.Build._IsRoofEditMode(this.target);
    }
 
    // Token: 0x1700024A RID: 586
    // (get) Token: 0x06000982 RID: 2434 RVA: 0x0003A756 File Offset: 0x00038956
    public override int hitW
    {
        get
        {
            if (this.target != null)
            {
                return this.moldCard.W;
            }
            return 1;
        }
    }
 
    // Token: 0x1700024B RID: 587
    // (get) Token: 0x06000983 RID: 2435 RVA: 0x0003A76D File Offset: 0x0003896D
    public override int hitH
    {
        get
        {
            if (this.target != null)
            {
                return this.moldCard.H;
            }
            return 1;
        }
    }
 
    // Token: 0x1700024C RID: 588
    // (get) Token: 0x06000984 RID: 2436 RVA: 0x0003A784 File Offset: 0x00038984
    public override int CostMoney
    {
        get
        {
            if (this.target != null)
            {
                return 0;
            }
            return 0;
        }
    }
 
    // Token: 0x1700024D RID: 589
    // (get) Token: 0x06000985 RID: 2437 RVA: 0x0003A791 File Offset: 0x00038991
    public override BaseTileMap.CardIconMode cardIconMode
    {
        get
        {
            return BaseTileMap.CardIconMode.Inspect;
        }
    }
 
    // Token: 0x06000986 RID: 2438 RVA: 0x0003A794 File Offset: 0x00038994
    public override HitResult HitResultOnDesignation(Point p)
    {
        return HitResult.Invalid;
    }
 
    // Token: 0x1700024E RID: 590
    // (get) Token: 0x06000987 RID: 2439 RVA: 0x0003A797 File Offset: 0x00038997
    public override bool AllowMiddleClickFunc
    {
        get
        {
            return this.target == null;
        }
    }
 
    // Token: 0x1700024F RID: 591
    // (get) Token: 0x06000988 RID: 2440 RVA: 0x0003A7A2 File Offset: 0x000389A2
    public bool FreePos
    {
        get
        {
            return EClass.game.config.FreePos;
        }
    }
 
    // Token: 0x17000250 RID: 592
    // (get) Token: 0x06000989 RID: 2441 RVA: 0x0003A7B3 File Offset: 0x000389B3
    public override BaseTileSelector.SelectType selectType
    {
        get
        {
            return BaseTileSelector.SelectType.Single;
        }
    }
 
    // Token: 0x17000251 RID: 593
    // (get) Token: 0x0600098A RID: 2442 RVA: 0x0003A7B6 File Offset: 0x000389B6
    public override bool ShouldHideBuildMenu
    {
        get
        {
            return this.target != null;
        }
    }
 
    // Token: 0x0600098B RID: 2443 RVA: 0x0003A7C1 File Offset: 0x000389C1
    public override bool CanInstaComplete(TaskMoveInstalled t)
    {
        return EClass.player.instaComplete;
    }
 
    // Token: 0x0600098C RID: 2444 RVA: 0x0003A7CD File Offset: 0x000389CD
    public override MeshPass GetGuidePass(Point point)
    {
        return EClass.screen.guide.passGuideBlock;
    }
 
    // Token: 0x0600098D RID: 2445 RVA: 0x0003A7DE File Offset: 0x000389DE
    public void Activate(Thing t)
    {
        base.Activate(true, false);
        this.SetTarget(t);
        this.onetime = true;
        EClass.ui.hud.hint.UpdateText();
    }
 
    // Token: 0x0600098E RID: 2446 RVA: 0x0003A80C File Offset: 0x00038A0C
    public override void OnActivate()
    {
        this.onetime = false;
        this.list = base.Designations.moveInstalled;
        this.target = (this.moldCard = null);
        base.OnActivate();
    }
 
    // Token: 0x0600098F RID: 2447 RVA: 0x0003A848 File Offset: 0x00038A48
    public override void OnDeactivate()
    {
        this.target = (this.moldCard = (this.mold.target = null));
    }
 
    // Token: 0x06000990 RID: 2448 RVA: 0x0003A873 File Offset: 0x00038A73
    public override void OnCreateMold(bool processing)
    {
        this.mold.target = this.target;
    }
 
    // Token: 0x06000991 RID: 2449 RVA: 0x0003A888 File Offset: 0x00038A88
    public override HitResult HitTest(Point point, Point start)
    {
        if (EClass.debug.enable)
        {
            int hotkey = EInput.hotkey;
            if (hotkey != 0)
            {
                if (hotkey == 1)
                {
                    EClass._map.AddDecal(point.x, point.z, 2, 1, true);
                }
            }
            else
            {
                EClass._map.SetDecal(point.x, point.z, 0, 1, true);
            }
        }
        if (this.target == null)
        {
            if (EClass.scene.mouseTarget.CanCycle())
            {
                return HitResult.Warning;
            }
            if (this.GetTarget(point) != null)
            {
                return HitResult.Valid;
            }
            return HitResult.Default;
        }
        else
        {
            if (this.target.isChara && this.CheckEnemyNearBy(this.target, point, false))
            {
                return HitResult.Invalid;
            }
            this.moldCard.ignoreStackHeight = Input.GetKey(KeyCode.LeftControl);
            if (!EClass.debug.ignoreBuildRule)
            {
                if (this.target.isChara && (point.IsBlocked || point.HasChara))
                {
                    return HitResult.Invalid;
                }
                if (!EClass._map.bounds.Contains(point))
                {
                    return HitResult.Invalid;
                }
            }
            return base.HitTest(point, start);
        }
    }
 
    // Token: 0x06000992 RID: 2450 RVA: 0x0003A988 File Offset: 0x00038B88
    public void SetTarget(Card _target)
    {
        foreach (TaskMoveInstalled taskMoveInstalled in EClass._map.tasks.designations.moveInstalled.items.ToArray())
        {
            if (taskMoveInstalled.target == _target)
            {
                taskMoveInstalled.Destroy();
            }
        }
        this.mold.target = _target;
        this.target = _target;
        if (this.target.isThing)
        {
            this.moldCard = this.target.Duplicate(1);
            this.moldCard.placeState = PlaceState.installed;
        }
        else
        {
            this.moldCard = CharaGen.Create(_target.id, -1);
            this.moldCard.idSkin = this.target.idSkin;
        }
        EClass.ui.hud.hint.UpdateText();
    }
 
    // Token: 0x06000993 RID: 2451 RVA: 0x0003AA54 File Offset: 0x00038C54
    public Card GetTarget(Point point)
    {
        return EClass.scene.mouseTarget.card;
    }
 
    // Token: 0x06000994 RID: 2452 RVA: 0x0003AA65 File Offset: 0x00038C65
    public bool CanPutAway()
    {
        return EClass.debug.ignoreBuildRule || (this.target != null && !this.target.isChara && !this.target.trait.CanOnlyCarry);
    }
 
    // Token: 0x06000995 RID: 2453 RVA: 0x0003AAA0 File Offset: 0x00038CA0
    public bool TryPutAway()
    {
        if (!this.CanPutAway())
        {
            return false;
        }
        if (!EClass._map.PutAway(this.target))
        {
            SE.Beep();
            return false;
        }
        SE.Click();
        this.target = null;
        EClass.ui.hud.hint.UpdateText();
        return true;
    }
 
    // Token: 0x06000996 RID: 2454 RVA: 0x0003AAF4 File Offset: 0x00038CF4
    public bool CheckEnemyNearBy(Card t, Point p, bool msg = true)
    {
        if (t.isChara && !EClass.debug.ignoreBuildRule)
        {
            bool flag = true;
            foreach (Chara chara in EClass._map.charas)
            {
                if (chara.hostility <= Hostility.Enemy && chara.Dist(p) <= 6)
                {
                    flag = false;
                }
            }
            if (!flag)
            {
                if (msg)
                {
                    SE.BeepSmall();
                    EClass.ui.Say("enemyInMap".langGame(), null);
                }
                return true;
            }
        }
        return false;
    }
 
    // Token: 0x06000997 RID: 2455 RVA: 0x0003AB94 File Offset: 0x00038D94
    public override void OnProcessTiles(Point point, int dir)
    {
        if (this.target == null)
        {
            Card t = this.GetTarget(point);
            if (this.CheckEnemyNearBy(t, t.pos, true))
            {
                return;
            }
            if (t.trait.ShowContextOnPick)
            {
                ActPlan actPlan = new ActPlan
                {
                    pos = point.Copy(),
                    ignoreAdddCondition = true,
                    input = ActInput.AllAction,
                    altAction = true
                };
                t.trait.TrySetAct(actPlan);
                if (actPlan.list.Count > 0)
                {
                    UIContextMenu uicontextMenu = EClass.ui.CreateContextMenuInteraction();
                    uicontextMenu.AddButton("move", delegate()
                    {
                        this.SetTarget(t);
                        SE.Click();
                    }, true);
                    using (List<ActPlan.Item>.Enumerator enumerator = actPlan.list.GetEnumerator())
                    {
                        while (enumerator.MoveNext())
                        {
                            ActPlan.Item i = enumerator.Current;
                            uicontextMenu.AddButton(i.GetTextContext(false), delegate()
                            {
                                i.act.Perform();
                            }, true);
                        }
                    }
                    uicontextMenu.Show();
                    return;
                }
            }
            this.SetTarget(t);
            SE.Click();
            return;
        }
        else
        {
            if (this.CheckEnemyNearBy(this.target, point, true))
            {
                return;
            }
            this.mold.dir = this.moldCard.dir;
            this.mold.altitude = this.moldCard.altitude;
            if (this.target.isChara)
            {
                Point orgPos = this.target.Chara.orgPos;
                if (orgPos != null)
                {
                    orgPos.Set(point);
                }
            }
            base.OnProcessTiles(point, dir);
            this.target.ignoreStackHeight = this.moldCard.ignoreStackHeight;
            this.target.freePos = this.moldCard.freePos;
            this.target.fx = (this.FreePos ? this.moldCard.fx : 0f);
            this.target.fy = (this.FreePos ? this.moldCard.fy : 0f);
            if (this.target.isChara && EClass.debug)
            {
                foreach (Thing thing in point.Things)
                {
                    TraitShackle traitShackle = thing.trait as TraitShackle;
                    if (traitShackle != null)
                    {
                        traitShackle.Restrain(this.target.Chara, false);
                    }
                }
            }
            if (this.target.isThing)
            {
                this.target.isRoofItem = this.IsRoofEditMode(null);
                if (this.target.isRoofItem)
                {
                    this.target.SetPlaceState(PlaceState.roaming, false);
                }
            }
            SE.Click();
            if (this.target.renderer.hasActor)
            {
                this.target.renderer.RefreshSprite();
            }
            this.target = null;
            return;
        }
    }
 
    // Token: 0x06000998 RID: 2456 RVA: 0x0003AEB0 File Offset: 0x000390B0
    public unsafe override void OnRenderTile(Point point, HitResult result, int dir)
    {
        if (this.target == null)
        {
            Card card = this.GetTarget(point);
            if (card != null && card.isThing)
            {
                card.Thing.RenderMarker(point, true, result, true, -1, true);
            }
            base.OnRenderTile(point, (result == HitResult.Valid) ? (EClass.scene.mouseTarget.CanCycle() ? HitResult.Warning : HitResult.Default) : result, dir);
            return;
        }
        if (this.moldCard == null)
        {
            base.OnRenderTile(point, result, dir);
            return;
        }
        this.moldCard.SetFreePos(point);
        if (result != HitResult.Valid && result != HitResult.Warning)
        {
            base.OnRenderTile(point, result, dir);
        }
        else
        {
            int desiredDir = this.target.TileType.GetDesiredDir(point, this.moldCard.dir);
            if (desiredDir != -1)
            {
                dir = (this.moldCard.dir = desiredDir);
            }
            bool flag = !base.tileSelector.multisize || (base.tileSelector.firstInMulti && base.Summary.count == base.Summary.countValid);
            this.moldCard.RenderMarker(point, false, result, flag, -1, false);
            if (flag)
            {
                this.target.trait.OnRenderTile(point, result, dir);
            }
        }
        EClass.screen.guide.DrawLine(*this.target.pos.PositionCenter(), *point.PositionCenter());
    }
 
    // Token: 0x06000999 RID: 2457 RVA: 0x0003B003 File Offset: 0x00039203
    public override void RotateUnderMouse()
    {
        if (this.target != null)
        {
            SE.Rotate();
            this.moldCard.Rotate(false);
            return;
        }
        base.RotateUnderMouse();
    }
 
    // Token: 0x0600099A RID: 2458 RVA: 0x0003B028 File Offset: 0x00039228
    public override void InputWheel(int wheel)
    {
        if (EInput.isAltDown || EInput.isCtrlDown)
        {
            return;
        }
        if (this.target != null && this.target.TileType.MaxAltitude > 0)
        {
            this.moldCard.ChangeAltitude(wheel);
            return;
        }
        if (EClass.scene.mouseTarget.CanCycle())
        {
            EClass.scene.mouseTarget.CycleTarget(wheel);
            return;
        }
        base.InputWheel(wheel);
    }
 
    // Token: 0x0600099B RID: 2459 RVA: 0x0003B095 File Offset: 0x00039295
    public override void OnCancel()
    {
        if (this.target != null)
        {
            this.target = null;
            if (this.onetime)
            {
                base.OnCancel();
            }
            return;
        }
        base.OnCancel();
    }
 
    // Token: 0x0600099C RID: 2460 RVA: 0x0003B0BB File Offset: 0x000392BB
    public override void OnFinishProcessTiles()
    {
        if (this.onetime)
        {
            base.Deactivate();
        }
    }
 
    // Token: 0x040008EF RID: 2287
    public Card target;
 
    // Token: 0x040008F0 RID: 2288
    public Card moldCard;
 
    // Token: 0x040008F1 RID: 2289
    public bool onetime;
}