AM_Adv.cs

using System;
using System.Collections.Generic;
using UnityEngine;
 
// Token: 0x0200015B RID: 347
public class AM_Adv : AM_BaseGameMode
{
    // Token: 0x17000291 RID: 657
    // (get) Token: 0x06000A2F RID: 2607 RVA: 0x0003C56D File Offset: 0x0003A76D
    public PointTarget mouseTarget
    {
        get
        {
            return EClass.scene.mouseTarget;
        }
    }
 
    // Token: 0x17000292 RID: 658
    // (get) Token: 0x06000A30 RID: 2608 RVA: 0x0003C579 File Offset: 0x0003A779
    public bool autorun
    {
        get
        {
            return EClass.core.config.input.autorun;
        }
    }
 
    // Token: 0x17000293 RID: 659
    // (get) Token: 0x06000A31 RID: 2609 RVA: 0x0003C590 File Offset: 0x0003A790
    public bool ShouldHideTile
    {
        get
        {
            return EClass.ui.layers.Count > 0 || (EClass.pc.renderer.IsMoving && !EInput.rightMouse.pressing) || EClass.pc.ai.Current is AI_Goto || this.cursorMove || EClass.ui.isPointerOverUI || EInput.axis != Vector2.zero;
        }
    }
 
    // Token: 0x17000294 RID: 660
    // (get) Token: 0x06000A32 RID: 2610 RVA: 0x0003C607 File Offset: 0x0003A807
    public override float gameSpeed
    {
        get
        {
            if (!this.ShouldPauseGame)
            {
                return ActionMode.GameSpeeds[EClass.game.gameSpeedIndex] * ((AM_Adv.turbo != 0f) ? AM_Adv.turbo : 1f);
            }
            return 1f;
        }
    }
 
    // Token: 0x17000295 RID: 661
    // (get) Token: 0x06000A33 RID: 2611 RVA: 0x0003C640 File Offset: 0x0003A840
    public override bool FixFocus
    {
        get
        {
            return !this.zoomOut && (EClass.core.config.test.alwaysFixCamera || EInput.leftMouse.pressing || !EInput.rightMouse.pressing || AM_Adv.actCount <= 0 || (EClass.pc.ai != Chara._NoGoalRepeat && (!(EClass.pc.ai is TaskDesignation) || !(EClass.pc.ai as TaskDesignation).isRepeated)));
        }
    }
 
    // Token: 0x17000296 RID: 662
    // (get) Token: 0x06000A34 RID: 2612 RVA: 0x0003C6CE File Offset: 0x0003A8CE
    public override bool ShouldPauseGame
    {
        get
        {
            return EClass.core.config.game.autopause && EClass.pc.HasNoGoal;
        }
    }
 
    // Token: 0x17000297 RID: 663
    // (get) Token: 0x06000A35 RID: 2613 RVA: 0x0003C6F2 File Offset: 0x0003A8F2
    public override bool AllowWheelZoom
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x17000298 RID: 664
    // (get) Token: 0x06000A36 RID: 2614 RVA: 0x0003C6F5 File Offset: 0x0003A8F5
    public override float TargetZoom
    {
        get
        {
            if (!this.zoomOut2)
            {
                return 0.01f * (float)EClass.game.config.defaultZoom;
            }
            return 0.01f * (float)EClass.game.config.zoomedZoom;
        }
    }
 
    // Token: 0x06000A37 RID: 2615 RVA: 0x0003C72C File Offset: 0x0003A92C
    public override bool HighlightWall(Point p)
    {
        return EClass.pc.held != null && TaskMine.CanMine(p, EClass.pc.held);
    }
 
    // Token: 0x06000A38 RID: 2616 RVA: 0x0003C74C File Offset: 0x0003A94C
    public unsafe override void OnActivate()
    {
        if (WidgetMouseover.Instance)
        {
            WidgetMouseover.Instance.Hide(false);
        }
        ActionMode.DefaultMode = this;
        this.pressedAction.Init(null);
        EClass.pc.ai.Cancel();
        EClass.screen.tileMap.RefreshHeight();
        (EClass.pc.renderer as CharaRenderer).first = true;
        EClass.pc.renderer.SetFirst(true, *EClass.pc.pos.PositionCenter());
        EClass.screen.FocusPC();
        EClass.screen.RefreshPosition();
    }
 
    // Token: 0x06000A39 RID: 2617 RVA: 0x0003C7EE File Offset: 0x0003A9EE
    public override void OnDeactivate()
    {
        this.EndTurbo();
    }
 
    // Token: 0x06000A3A RID: 2618 RVA: 0x0003C7F8 File Offset: 0x0003A9F8
    public unsafe override void OnRenderTile(Point point, HitResult result, int dir)
    {
        if (this.ShouldHideTile)
        {
            return;
        }
        EClass.player.currentHotItem.OnRenderTile(point, result, dir);
        base.OnRenderTile(point, result, dir);
        if (EClass.core.config.game.highlightEnemy)
        {
            using (List<Chara>.Enumerator enumerator = point.ListCharas().GetEnumerator())
            {
                while (enumerator.MoveNext())
                {
                    if (enumerator.Current.IsHostile(EClass.pc))
                    {
                        using (List<Chara>.Enumerator enumerator2 = EClass._map.charas.GetEnumerator())
                        {
                            while (enumerator2.MoveNext())
                            {
                                Chara chara = enumerator2.Current;
                                if (chara.isSynced && chara.IsHostile(EClass.pc) && !chara.IsMultisize)
                                {
                                    Vector3 vector = *chara.pos.Position();
                                    EClass.screen.guide.passGuideFloor.Add(vector.x, vector.y, vector.z - 0.01f, 23f, 0.3f);
                                }
                            }
                            break;
                        }
                    }
                }
            }
        }
    }
 
    // Token: 0x06000A3B RID: 2619 RVA: 0x0003C938 File Offset: 0x0003AB38
    public override int GetDefaultTile(Point p)
    {
        if (!p.IsSync)
        {
            return 30;
        }
        return 0;
    }
 
    // Token: 0x06000A3C RID: 2620 RVA: 0x0003C946 File Offset: 0x0003AB46
    public override void OnBeforeUpdate()
    {
        if (EClass.pc.renderer.IsMoving)
        {
            this.isMoving = true;
            return;
        }
        this.isMoving = false;
    }
 
    // Token: 0x06000A3D RID: 2621 RVA: 0x0003C968 File Offset: 0x0003AB68
    public unsafe override void OnAfterUpdate()
    {
        Vector3 vector = this.mouseTarget.pos.IsValid ? (*this.mouseTarget.pos.PositionAuto()) : (*EClass.pc.pos.PositionAuto());
        vector = Camera.main.WorldToScreenPoint(vector);
        vector.z = 0f;
        vector += EClass.ui.hud.transRightPos * Mathf.Min(0f, EClass.screen.Zoom - 1f);
        EClass.ui.hud.transRight.position = vector;
        EClass.player.MarkMapHighlights();
    }
 
    // Token: 0x06000A3E RID: 2622 RVA: 0x0003CA20 File Offset: 0x0003AC20
    public override void OnUpdateCursor()
    {
        this.RefreshArrow();
        CursorInfo info = (EClass.ui.layers.Count == 0 && !EClass.ui.isPointerOverUI) ? CursorSystem.Instance.arrows[this.arrowIndex] : null;
        CursorSystem.leftIcon = null;
        bool flag = (EClass.pc.ai.IsRunning || AM_Adv.turbo != 0f || this.pressedAction.action != null) && !EClass.pc.HasNoGoal && !(EClass.pc.ai is GoalManualMove);
        if (flag && !EClass.ui.isPointerOverUI)
        {
            CursorSystem.leftIcon = CursorSystem.IconGear;
            CursorSystem.leftIconAngle = (float)((int)(this.gearAngle / 45f) * 45);
        }
        if (!this.cursorMove && (this.mouseTarget.hasTargetChanged || !this.mouseTarget.pos.Equals(this.planLeft.pos) || this.planLeft.performed || this.planRight.performed))
        {
            this.updatePlans = true;
        }
        if (!this.ShouldHideTile)
        {
            if (this.planLeft.HasAct)
            {
                info = this.planLeft.CursorIcon;
            }
            else if (this.planRight.HasAct)
            {
                info = this.planRight.CursorIcon;
            }
        }
        this.gearAngle += Core.gameDelta * 200f;
        CursorSystem.SetCursor(info, 0);
        if ((this.updatePlans && !flag) || EClass.pc.IsDisabled)
        {
            this.UpdatePlans();
        }
        if (CursorSystem.ignoreCount < 0)
        {
            this.UpdateLangWheel();
            EClass.ui.hud.transRight.SetActive(true);
            bool flag2 = !this.ShouldHideTile && !this.pressedAction.hideRightInfo && !EClass.ui.contextMenu.isActive;
            EClass.ui.hud.textLeft.SetActive(flag2 && this.planLeft.ShowAct);
            EClass.ui.hud.textRight.SetActive(flag2 && this.planRight.ShowAct);
            EClass.ui.hud.textMiddle.SetActive(flag2 && this.textMiddle != null);
            EClass.ui.hud.textWheel.SetActive(flag2 && this.textWheel != null);
            if (EClass.ui.hud.textLeft.gameObject.activeSelf)
            {
                EClass.ui.hud.textLeft.rectTransform.anchoredPosition = EClass.ui.hud.leftTextPos * Mathf.Max(1f, EClass.screen.Zoom) / EClass.core.uiScale;
            }
            if (EClass.ui.hud.textRight.gameObject.activeSelf)
            {
                EClass.ui.hud.textRight.rectTransform.anchoredPosition = EClass.ui.hud.rightTextPos * Mathf.Max(1f, EClass.screen.Zoom) / EClass.core.uiScale;
            }
            if (EClass.ui.hud.textMiddle.gameObject.activeSelf)
            {
                EClass.ui.hud.textMiddle.rectTransform.anchoredPosition = EClass.ui.hud.wheelTextPos * Mathf.Max(1f, EClass.screen.Zoom) / EClass.core.uiScale;
            }
            if (EClass.ui.hud.textWheel.gameObject.activeSelf)
            {
                EClass.ui.hud.textWheel.rectTransform.anchoredPosition = (EClass.ui.hud.textMiddle.gameObject.activeSelf ? EClass.ui.hud.wheelTextPos2 : EClass.ui.hud.wheelTextPos) * Mathf.Max(1f, EClass.screen.Zoom) / EClass.core.uiScale;
            }
            EClass.ui.hud.imageRight.SetActive(flag2 && this.planRight.HasAct);
        }
    }
 
    // Token: 0x06000A3F RID: 2623 RVA: 0x0003CE9F File Offset: 0x0003B09F
    public void UpdatePlans()
    {
        this.planLeft.Update(this.mouseTarget);
        this.planRight.Update(this.mouseTarget);
        this.updatePlans = false;
    }
 
    // Token: 0x06000A40 RID: 2624 RVA: 0x0003CECC File Offset: 0x0003B0CC
    public void UpdateLangWheel()
    {
        this.textWheel = null;
        this.textMiddle = null;
        if (this.planRight.HasAct)
        {
            if (EClass.scene.mouseTarget.pos.Distance(EClass.pc.pos) <= 1 && HotItemHeld.CanChangeHeightByWheel())
            {
                this.textWheel = "textWheel_changeHeight".lang();
            }
            else
            {
                if (ActionMode.Build.altitude != 0)
                {
                    ActionMode.Build.SetAltitude(0);
                    WidgetCurrentTool.Instance.placer.Refresh();
                }
                if (HotItemHeld.CanRotate())
                {
                    this.planAll.Update(this.mouseTarget);
                    if (!this.planAll.HasAct)
                    {
                        this.textMiddle = "textMiddle_rotate".lang(EInput.keys.mouseMiddle.key.ToString() ?? "", null, null, null, null);
                    }
                }
            }
            EClass.ui.hud.textWheel.SetText(this.textWheel.IsEmpty(""));
            EClass.ui.hud.textMiddle.SetText(this.textMiddle.IsEmpty(""));
        }
    }
 
    // Token: 0x06000A41 RID: 2625 RVA: 0x0003CFFE File Offset: 0x0003B1FE
    public void ClearPlans()
    {
        this.planLeft.Clear();
        this.planRight.Clear();
        this.updatePlans = true;
    }
 
    // Token: 0x06000A42 RID: 2626 RVA: 0x0003D020 File Offset: 0x0003B220
    public void OnBecomeNoGoal()
    {
        EClass.player.renderThing = null;
        if (EClass.player.hotItemToRestore != null)
        {
            if (EClass.player.currentHotItem != EClass.player.hotItemToRestore)
            {
                EClass.player.SetCurrentHotItem(null);
            }
            EClass.player.hotItemToRestore = null;
        }
        if (!EClass.core.config.game.alwaysUpdateRecipe)
        {
            EClass.game.updater.recipe.Build(EClass.pc.pos, RecipeUpdater.Mode.Passive);
        }
        if (EClass.rnd(30) == 0 && EClass.pc.HasElement(1559, 1))
        {
            List<Thing> list = EClass.pc.things.List((Thing a) => a.trait is TraitPotion, false);
            if (list.Count > 0)
            {
                EClass.pc.Drink(list.RandomItem<Thing>());
                EClass.player.EndTurn(true);
            }
        }
        if ((int)(Time.timeSinceLevelLoad / 60f / 60f) > Player.realHour)
        {
            EClass.player.OnAdvanceRealHour();
        }
        Tutorial.TryPlayReserve();
    }
 
    // Token: 0x06000A43 RID: 2627 RVA: 0x0003D13C File Offset: 0x0003B33C
    public override void _OnUpdateInput()
    {
        if (EClass.player.willAutoSave)
        {
            EClass.game.Save(true, null, false);
            EClass.player.willAutoSave = false;
        }
        if (RecipeUpdater.dirty)
        {
            RecipeUpdater.dirty = false;
            EClass.game.updater.recipe.Build(EClass.pc.pos, RecipeUpdater.Mode.Passive);
        }
        if (!EInput.rightMouse.pressing)
        {
            AM_Adv.actCount = 0;
        }
        if (EInput.rightMouse.pressing && EInput.rightMouse.pressedLong && !EInput.leftMouse.down && EClass.pc.ai is TaskDesignation && (EClass.pc.ai as TaskDesignation).isRepeated)
        {
            if (!EInput.rightMouse.pressing || !EInput.leftMouse.pressing)
            {
                this.rightMouseTimer = 2.5f;
            }
        }
        else
        {
            this.rightMouseTimer -= Core.delta;
        }
        EClass.player.waitingInput = false;
        if (EClass.pc.ai is GoalAutoCombat && EClass.pc.ai.IsRunning && !EClass.debug.godMode)
        {
            if (EClass.pc.IsCriticallyWounded(false) || (EClass.game.config.autoCombat.abortOnHalfHP && ((EClass.pc.Evalue(1421) > 0) ? (EClass.pc.hp + EClass.pc.mana.value) : EClass.pc.hp) < EClass.player.autoCombatStartHP / 2))
            {
                Msg.Say("abort_lowHP");
                EClass.pc.ai.Cancel();
            }
            else if (EClass.game.config.autoCombat.abortOnAllyDying && EClass.pc.party.IsCriticallyWounded(false) && EClass.player.TryAbortAutoCombat())
            {
                Msg.Say("abort_allyDying");
                EClass.pc.ai.Cancel();
            }
        }
        if (EClass.pc.HasNoGoal)
        {
            if (EClass.pc.WillConsumeTurn())
            {
                EClass.player.EndTurn(true);
                EClass.player.invlunerable = false;
                return;
            }
            if (EClass.player.lastTurn != EClass.pc.turn)
            {
                EClass.player.lastTurn = EClass.pc.turn;
                EClass.player.invlunerable = false;
                this.OnBecomeNoGoal();
                if (!EClass.pc.HasNoGoal)
                {
                    return;
                }
            }
            EClass.player.waitingInput = true;
            if (AI_PlayMusic.keepPlaying)
            {
                Thing playingTool = AI_PlayMusic.playingTool;
                if (EInput.IsAnyKeyDown(true) || (playingTool.GetRootCard() != EClass.pc && (!playingTool.ExistsOnMap || playingTool.Dist(EClass.pc) > 1)))
                {
                    AI_PlayMusic.CancelKeepPlaying();
                    return;
                }
                UISong instance = UISong.Instance;
                if (!instance || instance.ratio > 0.85f)
                {
                    EClass.pc.SetAIImmediate(new AI_PlayMusic
                    {
                        tool = playingTool
                    });
                    return;
                }
            }
        }
        if (EClass.player.returnInfo != null && EClass.player.returnInfo.askDest)
        {
            EClass.player.returnInfo.askDest = false;
            int uidDest = 0;
            List<Zone> list = EClass.game.spatials.ListReturnLocations();
            if (list == null || list.Count == 0)
            {
                EClass.player.returnInfo = null;
                Msg.Say("returnAbort");
                return;
            }
            EClass.ui.AddLayer<LayerList>().SetList2<Zone>(list, (Zone a) => a.Name, delegate(Zone a, ItemGeneral b)
            {
                uidDest = a.uid;
                if (a is Zone_Dungeon)
                {
                    uidDest = a.FindDeepestZone().uid;
                }
                EClass.player.returnInfo = new Player.ReturnInfo
                {
                    turns = EClass.rnd(10) + 10,
                    uidDest = uidDest
                };
                if (EClass.debug.instaReturn)
                {
                    EClass.player.returnInfo.turns = 1;
                    EClass.player.EndTurn(true);
                }
            }, delegate(Zone a, ItemGeneral b)
            {
                string lang = (a is Zone_Dungeon) ? a.TextDeepestLv : "surface".lang();
                b.SetSubText(lang, 200, FontColor.Default, TextAnchor.MiddleRight);
                b.Build();
                b.button1.mainText.rectTransform.sizeDelta = new Vector2(350f, 20f);
            }, true).SetSize(500f, -1f).SetOnKill(delegate
            {
                if (uidDest == 0)
                {
                    EClass.player.returnInfo = null;
                    Msg.Say("returnAbort");
                }
            }).SetTitles("wReturn", null);
            return;
        }
        else
        {
            if (EClass.player.haltMove)
            {
                EClass.player.haltMove = false;
                this.TryCancelInteraction(false);
                EInput.Consume(1);
                return;
            }
            if (this.keepWalking && (EInput.leftMouse.down || EInput.rightMouse.down))
            {
                this.keepWalking = false;
                EInput.Consume(1);
                return;
            }
            if (EClass.player.showShippingResult && !EClass.ui.IsActive)
            {
                EClass.player.showShippingResult = false;
                EClass.ui.AddLayer<LayerShippingResult>().Show();
            }
            if (this.pressedAction.IsPressing() || this.keepWalking)
            {
                this.pressedAction.timer += Core.delta;
                if (this.pressedAction.action != null)
                {
                    if (this.pressedAction.canTurbo && ((this.autorun && this.pressedAction.timer > 0.45f) || Input.GetKey(KeyCode.LeftShift)))
                    {
                        this.SetTurbo(-1);
                    }
                    if (!this.pressedAction.waitForTurn || this.CanAct())
                    {
                        if (this.pressedAction.count == 1 && !this.pressedAction.ignoreCount)
                        {
                            this.pressedAction.timerRepeat += Core.delta;
                            if (this.pressedAction.timerRepeat < 0.3f)
                            {
                                return;
                            }
                        }
                        this.pressedAction.count++;
                        if (this.pressedAction.action())
                        {
                            if (this.pressedAction.willEndTurn)
                            {
                                EClass.player.EndTurn(false);
                                if (!this.pressedAction.repeat)
                                {
                                    this.pressedAction.action = null;
                                    return;
                                }
                            }
                        }
                        else if (!this.pressedAction.repeat)
                        {
                            this.pressedAction.action = null;
                            return;
                        }
                    }
                }
                else if ((this.autorun && this.pressedAction.timer > 0.5f) || Input.GetKey(KeyCode.LeftShift))
                {
                    this.SetTurbo(-1);
                }
                return;
            }
            if (this.pressedAction.button != null || EInput.hasShiftChanged)
            {
                this.updatePlans = true;
            }
            this.cursorMove = false;
            EClass.player.nextMove = Vector2.zero;
            if (EClass.pc.HasNoGoal)
            {
                this.EndTurbo();
            }
            this.pressedAction.button = null;
            this.pressedAction.axis = Vector2.zero;
            this.pressedAction.count = 0;
            this.pressedAction.timerRepeat = 0f;
            if (EClass.player.willEndTurn)
            {
                EClass.player.willEndTurn = false;
                EClass.player.EndTurn(true);
                return;
            }
            if (EInput.axis != Vector2.zero)
            {
                this.AxisMove();
                return;
            }
            this.timerStartRunning = 0f;
            this.startedRun = false;
            if (this.movedByKey && EClass.pc.ai is GoalManualMove)
            {
                EClass.pc.ai.Cancel();
            }
            this.movedByKey = false;
            CoreConfig.InputSetting input = EClass.core.config.input;
            if (EInput.leftMouse.down)
            {
                if (this.TryCancelInteraction(true))
                {
                    return;
                }
                CursorSystem.ignoreCount = 5;
                this.SetPressedAction(EInput.leftMouse);
            }
            if (EInput.rightMouse.down)
            {
                if (this.TryCancelInteraction(true))
                {
                    return;
                }
                CursorSystem.ignoreCount = 5;
                this.SetPressedAction(EInput.rightMouse);
            }
            if (EInput.middleMouse.pressing || EInput.isShiftDown)
            {
                if (HotItemHeld.CanChangeHeightByWheel())
                {
                    if (EInput.wheel != 0)
                    {
                        ActionMode.Build.ModAltitude(EInput.wheel);
                        SE.Tab();
                        WidgetCurrentTool.Instance.placer.Refresh();
                        EInput.wheel = 0;
                    }
                    if (EInput.middleMouse.pressedTimer > EInput.middleMouse.clickDuration)
                    {
                        EInput.middleMouse.pressedTimer = 100f;
                    }
                }
                else if (EClass.scene.mouseTarget.CanCycle())
                {
                    if (EInput.wheel != 0)
                    {
                        EClass.scene.mouseTarget.CycleTarget(EInput.wheel);
                        EInput.wheel = 0;
                    }
                    if (EInput.middleMouse.pressedTimer > EInput.middleMouse.clickDuration)
                    {
                        EInput.middleMouse.pressedTimer = 100f;
                    }
                }
            }
            if ((EInput.middleMouse.down || EInput.middleMouse.clicked || EInput.middleMouse.pressedLong) && !EClass.ui.contextMenu.isActive)
            {
                this.planAll.Update(this.mouseTarget);
                bool flag = EClass.pc.held != null && HotItemHeld.taskBuild != null && (HotItemHeld.taskBuild.CanPerform() || !this.planAll.HasAct);
                if (EInput.middleMouse.clicked)
                {
                    if (flag)
                    {
                        HotItemHeld.taskBuild.recipe.Rotate();
                        SE.Rotate();
                    }
                    else
                    {
                        base.DoFunc(input.middleClick);
                    }
                }
                else if (EInput.middleMouse.pressedLong)
                {
                    base.DoFunc(input.middlePressLong);
                }
            }
            if (EInput.mouse3.clicked || (input.mouse3Click == CoreConfig.GameFunc.Fire && EInput.mouse3.pressing))
            {
                base.DoFunc(input.mouse3Click);
            }
            else if (EInput.mouse3.pressedLong)
            {
                base.DoFunc(input.mouse3PressLong);
            }
            if (EInput.mouse4.clicked || (input.mouse4Click == CoreConfig.GameFunc.Fire && EInput.mouse4.pressing))
            {
                if (this.zoomOut)
                {
                    this.ToggleZoom();
                }
                else
                {
                    base.DoFunc(input.mouse4Click);
                }
            }
            else if (EInput.mouse4.pressedLong)
            {
                base.DoFunc(input.mouse4PressLong);
            }
            if (EInput.wheel != 0)
            {
                if (EClass.scene.mouseTarget.pos.Distance(EClass.pc.pos) <= 1 && HotItemHeld.CanChangeHeightByWheel())
                {
                    if (EInput.wheel != 0)
                    {
                        ActionMode.Build.ModAltitude(EInput.wheel);
                        SE.Tab();
                        WidgetCurrentTool.Instance.placer.Refresh();
                        EInput.wheel = 0;
                    }
                }
                else
                {
                    WidgetCurrentTool.Instance.ModSelected(-EInput.wheel);
                    this.UpdatePlans();
                }
            }
            if (EClass.pc.HasNoGoal && EClass.player.currentHotItem.LookAtMouse)
            {
                EClass.pc.LookAt(this.planLeft.pos);
            }
            if (Input.GetKey(KeyCode.LeftControl))
            {
                if (Input.GetKeyDown(KeyCode.F))
                {
                    Widget widget = EClass.ui.widgets.Toggle("Search");
                    if (widget == null)
                    {
                        return;
                    }
                    widget.SoundActivate();
                }
                return;
            }
            EAction action = EInput.action;
            if (action != EAction.Wait)
            {
                if (action != EAction.Fire)
                {
                    switch (action)
                    {
                    case EAction.Report:
                        if (!EClass.debug.enable)
                        {
                            EClass.ui.ToggleFeedback();
                            return;
                        }
                        break;
                    case EAction.QuickSave:
                        if (EClass.debug.enable || EClass.game.Difficulty.allowManualSave)
                        {
                            if (!EClass.pc.HasNoGoal)
                            {
                                SE.Beep();
                                return;
                            }
                            EClass.game.Save(false, null, false);
                            return;
                        }
                        break;
                    case EAction.QuickLoad:
                        if (EClass.debug.enable || EClass.game.Difficulty.allowManualSave)
                        {
                            EClass.core.WaitForEndOfFrame(delegate
                            {
                                string id = Game.id;
                                EClass.scene.Init(Scene.Mode.None);
                                Game.Load(id);
                            });
                            return;
                        }
                        break;
                    case EAction.AutoCombat:
                        if (EClass.scene.mouseTarget.isValid && EClass.player.CanAcceptInput())
                        {
                            List<Chara> list2 = EClass.scene.mouseTarget.pos.ListCharas();
                            list2.Sort((Chara a, Chara b) => a.hostility - b.hostility);
                            foreach (Chara chara in list2)
                            {
                                if (chara.hostility < Hostility.Friend)
                                {
                                    EClass.pc.SetAIImmediate(new GoalAutoCombat(chara));
                                    return;
                                }
                            }
                            Msg.Say("noTargetFound");
                            return;
                        }
                        break;
                    case EAction.EmptyHand:
                        if (WidgetCurrentTool.Instance)
                        {
                            WidgetCurrentTool.Instance.Select(-1, false);
                            return;
                        }
                        break;
                    default:
                        return;
                    }
                }
                else
                {
                    if (!EClass.player.HasValidRangedTarget() || EInput.isShiftDown)
                    {
                        EClass.player.TargetRanged();
                        if (EClass.player.HasValidRangedTarget())
                        {
                            SE.Play("lock_on");
                        }
                        if (EInput.keyFire.IsRepeating)
                        {
                            EInput.keyFire.Consume();
                            return;
                        }
                    }
                    else if (EClass.pc.HasNoGoal)
                    {
                        Thing thing = EClass.player.currentHotItem.Thing;
                        bool reloading = EClass.pc.HasCondition<ConReload>();
                        if (thing == null || !thing.CanAutoFire(EClass.pc, EClass.player.target, reloading))
                        {
                            foreach (UIList.ButtonPair buttonPair in WidgetCurrentTool.Instance.list.buttons)
                            {
                                Thing thing2 = buttonPair.obj as Thing;
                                if (thing2 != null && thing2.CanAutoFire(EClass.pc, EClass.player.target, reloading))
                                {
                                    thing = thing2;
                                    break;
                                }
                            }
                        }
                        if (thing == null || !thing.CanAutoFire(EClass.pc, EClass.player.target, reloading))
                        {
                            thing = EClass.pc.things.Find((Thing _t) => _t.isEquipped && _t.CanAutoFire(EClass.pc, EClass.player.target, reloading), true);
                        }
                        if (thing != null && thing.CanAutoFire(EClass.pc, EClass.player.target, reloading))
                        {
                            if (thing.HasTag(CTAG.throwWeapon))
                            {
                                Point pos = EClass.player.target.pos;
                                if (ActThrow.CanThrow(EClass.pc, thing, EClass.player.target, null))
                                {
                                    ACT.Throw.target = thing;
                                    ACT.Throw.Perform(EClass.pc, EClass.player.target, EClass.player.target.pos);
                                    EClass.player.EndTurn(false);
                                    this.SetTurbo(-1);
                                    return;
                                }
                            }
                            else
                            {
                                TraitAbility traitAbility = thing.trait as TraitAbility;
                                if (traitAbility != null)
                                {
                                    if (traitAbility.act.CanPerform(EClass.pc, EClass.player.target, EClass.player.target.pos) && EClass.pc.UseAbility(traitAbility.act.source.alias, EClass.player.target, EClass.player.target.pos, false))
                                    {
                                        EClass.player.EndTurn(false);
                                        return;
                                    }
                                }
                                else if (thing.trait is TraitToolRange)
                                {
                                    EClass.pc.ranged = thing;
                                    if (ACT.Ranged.CanPerform(EClass.pc, EClass.player.target, null))
                                    {
                                        EClass.player.renderThing = thing;
                                        ACT.Ranged.Perform(EClass.pc, EClass.player.target, null);
                                        EClass.player.EndTurn(false);
                                        this.SetTurbo(-1);
                                    }
                                }
                            }
                        }
                    }
                }
            }
            else
            {
                if (EClass.debug.boradcast)
                {
                    EClass.debug.BroadcastNext();
                    return;
                }
                if (!EClass.pc.HasNoGoal)
                {
                    if (EClass.pc.ai.CanManualCancel())
                    {
                        EClass.pc.ai.Cancel();
                        return;
                    }
                }
                else
                {
                    if (EClass._zone.IsRegion)
                    {
                        EClass.player.EnterLocalZone(false);
                        return;
                    }
                    TraitNewZone traitNewZone = EClass.pc.pos.FindThing<TraitNewZone>();
                    if (traitNewZone != null && traitNewZone.CanAutoEnter())
                    {
                        traitNewZone.MoveZone(false);
                        return;
                    }
                    ACT.Wait.Perform(EClass.pc, null, null);
                    EClass.player.EndTurn(true);
                    return;
                }
            }
            return;
        }
    }
 
    // Token: 0x06000A44 RID: 2628 RVA: 0x0003E100 File Offset: 0x0003C300
    public void ShowAllAction()
    {
        this.planAll.Update(this.mouseTarget);
        if (this.planAll.HasAct)
        {
            this.planAll.ShowContextMenu();
            return;
        }
        if (EClass._zone.IsRegion)
        {
            EClass.ui.ToggleLayer<LayerTravel>(null);
            return;
        }
        if (EClass.debug.godBuild)
        {
            Thing lastThing = this.planAll.pos.LastThing;
            if (lastThing != null && EClass.pc.pos.Distance(this.planAll.pos) > 1 && lastThing.W == lastThing.H)
            {
                lastThing.Rotate(false);
                SE.Rotate();
                return;
            }
        }
        SE.BeepSmall();
    }
 
    // Token: 0x06000A45 RID: 2629 RVA: 0x0003E1AD File Offset: 0x0003C3AD
    public void SetTurbo(int mtp = -1)
    {
        if (mtp == -1)
        {
            if (AM_Adv.turbo <= EClass.setting.defaultTurbo)
            {
                AM_Adv.turbo = EClass.setting.defaultTurbo;
                return;
            }
        }
        else
        {
            AM_Adv.turbo = (float)mtp;
        }
    }
 
    // Token: 0x06000A46 RID: 2630 RVA: 0x0003E1DB File Offset: 0x0003C3DB
    public void EndTurbo()
    {
        AM_Adv.turbo = 0f;
    }
 
    // Token: 0x06000A47 RID: 2631 RVA: 0x0003E1E8 File Offset: 0x0003C3E8
    public void ToggleZoom()
    {
        EClass.screen.focusPos = null;
        this.zoomOut2 = !this.zoomOut2;
        SE.Play(this.zoomOut2 ? "zoomOut" : "zoomIn");
        EClass.ui.widgets.OnChangeActionMode();
        this.ClearPlans();
    }
 
    // Token: 0x06000A48 RID: 2632 RVA: 0x0003E244 File Offset: 0x0003C444
    public bool TryCancelInteraction(bool sound = true)
    {
        if (!EClass.pc.HasNoGoal && EClass.pc.ai.IsRunning)
        {
            if (EClass.pc.ai.CanManualCancel())
            {
                EClass.pc.ai.Cancel();
                if (sound)
                {
                    SE.CancelAction();
                }
            }
            EInput.Consume(true, 1);
            return true;
        }
        return false;
    }
 
    // Token: 0x06000A49 RID: 2633 RVA: 0x0003E2A1 File Offset: 0x0003C4A1
    public bool CanAct()
    {
        return EClass.pc.HasNoGoal;
    }
 
    // Token: 0x06000A4A RID: 2634 RVA: 0x0003E2B0 File Offset: 0x0003C4B0
    public void AxisMove()
    {
        Vector2 vector = (EClass.core.config.input.altKeyAxis && !EClass._zone.IsRegion) ? Util.ConvertAxis(EInput.axis) : EInput.axis;
        if (!this.startedRun)
        {
            if ((this.autorun && this.timerStartRunning >= 0.7f) || Input.GetKey(KeyCode.LeftShift))
            {
                this.SetTurbo(-1);
                this.startedRun = true;
            }
        }
        else if (Input.GetKeyDown(KeyCode.LeftShift))
        {
            this.SetTurbo((AM_Adv.turbo == 0f) ? -1 : 0);
        }
        if (EClass.core.config.test.alwaysRun)
        {
            this.SetTurbo(Input.GetKey(KeyCode.LeftShift) ? 0 : -1);
        }
        this.timerStartRunning += Core.delta;
        EClass.player.nextMove.x = 0f;
        EClass.player.nextMove.y = 0f;
        Point point = EClass.pc.pos.Copy();
        point.x += (int)vector.x;
        point.z += (int)vector.y;
        if (EClass.pc.HasNoGoal && !point.IsValid && EClass.player.CanExitBorder(point))
        {
            EClass.player.ExitBorder(null);
            return;
        }
        this.axisTarget.Update(point);
        this.pressedAction.Init(Vector3.zero);
        this.planKeyboard.Update(this.axisTarget);
        if (!this.planKeyboard.HasAct)
        {
            EClass.player.nextMove.x = vector.x;
            EClass.player.nextMove.y = vector.y;
            if (!(EClass.pc.ai is GoalManualMove) && EClass.pc.HasNoGoal && GoalManualMove.CanMove())
            {
                this.SetManualMove();
            }
            this.movedByKey = true;
            return;
        }
        if (this.planKeyboard.list[0].act.ResetAxis && EClass.pc.ai is GoalManualMove)
        {
            EInput.forbidAxis = EInput.axis;
            EClass.pc.ai.Cancel();
            return;
        }
        this.pressedAction.axis = EInput.axis;
        this.pressedAction.SetAction(this.planKeyboard.GetAction(), true, this.planKeyboard.WillEndTurn, true);
    }
 
    // Token: 0x06000A4B RID: 2635 RVA: 0x0003E529 File Offset: 0x0003C729
    public void SetManualMove()
    {
        if (EClass.player.TooHeavyToMove())
        {
            return;
        }
        this.SetTurbo(EInput.isShiftDown ? -1 : 0);
        EClass.pc.SetAIImmediate(new GoalManualMove());
        this.cursorMove = true;
    }
 
    // Token: 0x06000A4C RID: 2636 RVA: 0x0003E560 File Offset: 0x0003C760
    public void SetPressedAction(ButtonState button)
    {
        if (this.updatePlans)
        {
            this.UpdatePlans();
        }
        bool flag = button == EInput.leftMouse;
        this.pressedAction.Init(button);
        if (this.isMouseOnMap)
        {
            if (flag)
            {
                if (this.planLeft.HasAct)
                {
                    this.pressedAction.SetPlan(this.planLeft);
                    return;
                }
            }
            else
            {
                if (this.planRight.HasAct)
                {
                    this.pressedAction.SetPlan(this.planRight);
                    return;
                }
                SE.Play("noAction");
                return;
            }
        }
        if (flag)
        {
            Point pos = (!this.isMouseOnMap) ? null : base.hit.Copy();
            if (pos != null)
            {
                if (EClass.pc.pos.Equals(pos))
                {
                    return;
                }
                if (EClass.pc.pos.Distance(pos) == 1 && pos.cell.blocked)
                {
                    return;
                }
            }
            this.planLeft.Update(this.mouseTarget);
            if (this.planLeft.HasAct)
            {
                return;
            }
            this.clickPos = Input.mousePosition;
            this.pressedAction.SetAction(() => this.PressedActionMove(pos), false, false, false);
            this.pressedAction.repeat = this.zoomOut;
            this.pressedAction.ignoreCount = true;
        }
    }
 
    // Token: 0x06000A4D RID: 2637 RVA: 0x0003E6C0 File Offset: 0x0003C8C0
    public bool PressedActionMove(Point pos)
    {
        if (EClass.player.TooHeavyToMove())
        {
            return false;
        }
        if (pos != null)
        {
            if (EInput.leftMouse.clicked)
            {
                if (EClass.pc.pos.Equals(pos) || !pos.IsValid)
                {
                    EClass.player.nextMove = Vector2.zero;
                    EClass.pc.ai.Cancel();
                }
                else if (PathManager.Instance.RequestPathImmediate(EClass.pc.pos, pos, EClass.pc, PathManager.MoveType.Default, -1, 0).HasPath && (this.zoomOut || (!pos.Equals(GoalManualMove.lastPoint) && !pos.Equals(GoalManualMove.lastlastPoint))))
                {
                    if (!EClass.pc.IsEnemyOnPath(pos, true))
                    {
                        EClass.pc.SetAIImmediate(new AI_Goto(pos, 0, false, false));
                    }
                }
                else
                {
                    EClass.player.nextMove = Vector2.zero;
                    EClass.pc.ai.Cancel();
                }
                return false;
            }
            if (EInput.rightMouse.down && EClass.core.config.input.autowalk)
            {
                this.keepWalking = true;
            }
        }
        if (this.autorun)
        {
            if (Vector2.Distance(this.posOrigin, this.posArrow) > EClass.core.config.game.runDistance)
            {
                this.SetTurbo(-1);
            }
            else if (AM_Adv.turbo != 0f && !Input.GetKey(KeyCode.LeftShift) && !EClass.core.config.input.keepRunning && !this.zoomOut && Vector2.Distance(this.posOrigin, this.posArrow) < 1.2f)
            {
                this.EndTurbo();
            }
        }
        if (pos != null && !this.cursorMove)
        {
            Vector2Int v = new Vector2Int(pos.x - EClass.pc.pos.x, pos.z - EClass.pc.pos.z);
            if (Mathf.Abs(v.x) > 1 || Mathf.Abs(v.y) > 1)
            {
                int num = Mathf.Max(Mathf.Abs(v.x), Mathf.Abs(v.y));
                v.x /= num;
                v.y /= num;
            }
            EClass.player.nextMove = v;
            Point.shared.Set(EClass.pc.pos.x + v.x, EClass.pc.pos.z + v.y);
        }
        else
        {
            EClass.player.nextMove = this.vArrow;
            Point.shared.Set(EClass.pc.pos.x + (int)this.vArrow.x, EClass.pc.pos.z + (int)this.vArrow.y);
        }
        if (EClass.pc.IsEnemyOnPath(Point.shared, true))
        {
            if (EClass.pc.ai is GoalManualMove)
            {
                EClass.pc.ai.Cancel();
            }
            return true;
        }
        if (Point.shared.IsInBounds)
        {
            if (!(EClass.pc.ai is GoalManualMove))
            {
                if (EClass.pc.HasNoGoal)
                {
                    if (GoalManualMove.CanMove())
                    {
                        this.SetTurbo(EInput.isShiftDown ? -1 : 0);
                        EClass.pc.SetAIImmediate(new GoalManualMove());
                    }
                    this.cursorMove = true;
                }
            }
            else
            {
                this.cursorMove = true;
            }
            return true;
        }
        if (EClass.pc.HasNoGoal && EClass.player.CanExitBorder(Point.shared))
        {
            EClass.player.ExitBorder(null);
            return false;
        }
        if (EClass.pc.ai is GoalManualMove)
        {
            EClass.pc.ai.Cancel();
        }
        return true;
    }
 
    // Token: 0x06000A4E RID: 2638 RVA: 0x0003EAA8 File Offset: 0x0003CCA8
    public unsafe virtual void RefreshArrow()
    {
        bool flag = this.zoomOut || EInput.rightMouse.pressedLong;
        if (flag && this.mouseTarget.pos.Equals(EClass.pc.pos))
        {
            this.vArrow = Vector2.zero;
            EClass.player.nextMove = this.vArrow;
            return;
        }
        this.posOrigin = (flag ? (*EClass.pc.pos.PositionCenter()) : CursorSystem.posOrigin);
        this.posArrow = CursorSystem.position;
        float num;
        if (this.cursorMove || EClass.pc.pos.Distance(base.hit) > 1)
        {
            num = Util.GetAngle(this.posArrow.x - this.posOrigin.x, this.posArrow.y - this.posOrigin.y) + 90f + 22.5f;
        }
        else
        {
            num = Util.GetAngle((float)(EClass.pc.pos.x - base.hit.x), (float)(EClass.pc.pos.z - base.hit.z)) - 22.5f;
            if (num < 0f)
            {
                num = 360f + num;
            }
        }
        if (WidgetUnityChan.Instance)
        {
            WidgetUnityChan.Instance.Refresh(num);
        }
        if (this.clickPos != Vector3.zero)
        {
            if (Vector3.Distance(Input.mousePosition, this.clickPos) < EClass.core.config.game.angleMargin)
            {
                return;
            }
            this.clickPos = Vector3.zero;
        }
        this.vArrow = Vector2.zero;
        int _angle = 0;
        Action<int, int, int, int> action = delegate(int x, int y, int i, int a)
        {
            this.vArrow.x = (float)x;
            this.vArrow.y = (float)y;
            this.arrowIndex = i;
            _angle = -a;
        };
        if (num < 45f || num >= 360f)
        {
            action(-1, -1, 0, 0);
            return;
        }
        if (num < 90f)
        {
            action(-1, 0, 1, 35);
            return;
        }
        if (num < 135f)
        {
            action(-1, 1, 2, 90);
            return;
        }
        if (num < 180f)
        {
            action(0, 1, 3, 145);
            return;
        }
        if (num < 225f)
        {
            action(1, 1, 4, 180);
            return;
        }
        if (num < 270f)
        {
            action(1, 0, 5, 215);
            return;
        }
        if (num < 315f)
        {
            action(1, -1, 6, 270);
            return;
        }
        action(0, -1, 7, 325);
    }
 
    // Token: 0x04000905 RID: 2309
    public static float turbo;
 
    // Token: 0x04000906 RID: 2310
    public static int actCount;
 
    // Token: 0x04000907 RID: 2311
    public bool zoomOut;
 
    // Token: 0x04000908 RID: 2312
    public bool zoomOut2;
 
    // Token: 0x04000909 RID: 2313
    public bool movedByKey;
 
    // Token: 0x0400090A RID: 2314
    protected int arrowIndex;
 
    // Token: 0x0400090B RID: 2315
    protected float timerStartRunning;
 
    // Token: 0x0400090C RID: 2316
    protected bool cursorMove;
 
    // Token: 0x0400090D RID: 2317
    protected bool keepWalking;
 
    // Token: 0x0400090E RID: 2318
    protected Vector3 posOrigin;
 
    // Token: 0x0400090F RID: 2319
    protected Vector3 posArrow;
 
    // Token: 0x04000910 RID: 2320
    protected Vector2 vArrow;
 
    // Token: 0x04000911 RID: 2321
    public AM_Adv.PressedAction pressedAction = new AM_Adv.PressedAction();
 
    // Token: 0x04000912 RID: 2322
    public PointTarget axisTarget = new PointTarget
    {
        mouse = false
    };
 
    // Token: 0x04000913 RID: 2323
    public ActPlan planLeft = new ActPlan
    {
        input = ActInput.LeftMouse
    };
 
    // Token: 0x04000914 RID: 2324
    public ActPlan planRight = new ActPlan
    {
        input = ActInput.RightMouse
    };
 
    // Token: 0x04000915 RID: 2325
    public ActPlan planKeyboard = new ActPlan
    {
        input = ActInput.Key
    };
 
    // Token: 0x04000916 RID: 2326
    public ActPlan planAll = new ActPlan
    {
        input = ActInput.AllAction
    };
 
    // Token: 0x04000917 RID: 2327
    public string textWheel;
 
    // Token: 0x04000918 RID: 2328
    public string textMiddle;
 
    // Token: 0x04000919 RID: 2329
    private float gearAngle;
 
    // Token: 0x0400091A RID: 2330
    protected bool updatePlans;
 
    // Token: 0x0400091B RID: 2331
    protected bool isMoving;
 
    // Token: 0x0400091C RID: 2332
    private Vector3 lastCamPos;
 
    // Token: 0x0400091D RID: 2333
    public float rightMouseTimer;
 
    // Token: 0x0400091E RID: 2334
    private bool startedRun;
 
    // Token: 0x0400091F RID: 2335
    protected Vector3 clickPos;
 
    // Token: 0x02000872 RID: 2162
    public class PressedAction
    {
        // Token: 0x06003A31 RID: 14897 RVA: 0x00135598 File Offset: 0x00133798
        public void Init(Vector3 _axis)
        {
            this.button = null;
            this.action = null;
            this.plan = null;
            this.timer = 0f;
            this.axis = _axis;
        }
 
        // Token: 0x06003A32 RID: 14898 RVA: 0x001355C6 File Offset: 0x001337C6
        public void Init(ButtonState _button = null)
        {
            this.button = _button;
            this.action = null;
            this.plan = null;
            this.timer = 0f;
            this.axis = Vector2.zero;
        }
 
        // Token: 0x06003A33 RID: 14899 RVA: 0x001355F4 File Offset: 0x001337F4
        public void SetAction(Func<bool> _action = null, bool _canTurbo = true, bool _willEndTurn = true, bool _waitForTurn = true)
        {
            this.plan = null;
            this.action = _action;
            this.canTurbo = _canTurbo;
            this.willEndTurn = _willEndTurn;
            this.waitForTurn = _waitForTurn;
            this.hideRightInfo = false;
            this.repeat = false;
            this.ignoreCount = false;
            this.act = null;
        }
 
        // Token: 0x06003A34 RID: 14900 RVA: 0x00135644 File Offset: 0x00133844
        public void SetPlan(ActPlan _plan)
        {
            this.plan = _plan;
            this.action = this.plan.GetAction();
            this.canTurbo = true;
            this.willEndTurn = this.plan.WillEndTurn;
            this.waitForTurn = true;
            this.hideRightInfo = this.plan.HideRightInfo;
            this.repeat = this.plan.canRepeat;
            this.ignoreCount = false;
            this.act = ((this.plan.list.Count == 1) ? this.plan.list[0].act : null);
        }
 
        // Token: 0x06003A35 RID: 14901 RVA: 0x001356E4 File Offset: 0x001338E4
        public bool IsPressing()
        {
            if (this.button != null)
            {
                return this.button.down || this.button.pressing || this.button.clicked;
            }
            return this.axis != Vector2.zero && EInput.axis == this.axis;
        }
 
        // Token: 0x04002418 RID: 9240
        public ButtonState button;
 
        // Token: 0x04002419 RID: 9241
        public bool canTurbo;
 
        // Token: 0x0400241A RID: 9242
        public bool willEndTurn;
 
        // Token: 0x0400241B RID: 9243
        public bool waitForTurn;
 
        // Token: 0x0400241C RID: 9244
        public bool hideRightInfo;
 
        // Token: 0x0400241D RID: 9245
        public bool repeat;
 
        // Token: 0x0400241E RID: 9246
        public bool ignoreCount;
 
        // Token: 0x0400241F RID: 9247
        public Func<bool> action;
 
        // Token: 0x04002420 RID: 9248
        public Act act;
 
        // Token: 0x04002421 RID: 9249
        public ActPlan plan;
 
        // Token: 0x04002422 RID: 9250
        public float timer;
 
        // Token: 0x04002423 RID: 9251
        public float timerRepeat;
 
        // Token: 0x04002424 RID: 9252
        public Vector2 axis;
 
        // Token: 0x04002425 RID: 9253
        public int count;
    }
}