ActionMode.cs

using System;
using System.Collections.Generic;
using System.Linq;
using UnityEngine;
 
// Token: 0x02000137 RID: 311
public class ActionMode : EClass
{
    // Token: 0x170001CB RID: 459
    // (get) Token: 0x06000844 RID: 2116 RVA: 0x000366C3 File Offset: 0x000348C3
    public static AM_Adv AdvOrRegion
    {
        get
        {
            if (!EClass._zone.IsRegion)
            {
                return ActionMode.Adv;
            }
            return ActionMode.Region;
        }
    }
 
    // Token: 0x170001CC RID: 460
    // (get) Token: 0x06000845 RID: 2117 RVA: 0x000366DC File Offset: 0x000348DC
    public static bool IsAdv
    {
        get
        {
            return ActionMode.DefaultMode is AM_Adv;
        }
    }
 
    // Token: 0x06000846 RID: 2118 RVA: 0x000366EC File Offset: 0x000348EC
    public static void OnGameInstantiated()
    {
        ActionMode.LastBuildMode = null;
        ActionMode.Sim = new AM_Sim();
        ActionMode.View = new AM_ViewZone();
        ActionMode.Adv = new AM_Adv();
        ActionMode.AdvTarget = new AM_ADV_Target();
        ActionMode.Region = new AM_Region();
        ActionMode.NoMap = new AM_NoMap();
        ActionMode.MiniGame = new AM_MiniGame();
        ActionMode.EloMap = new AM_EloMap();
        ActionMode.NewZone = new AM_NewZone();
        ActionMode.Select = new AM_Select();
        ActionMode.Inspect = new AM_Inspect();
        ActionMode.Bird = new AM_Bird();
        ActionMode.DefaultMode = ActionMode.Adv;
        ActionMode.Mine = new AM_Mine();
        ActionMode.Dig = new AM_Dig();
        ActionMode.Harvest = new AM_Harvest();
        ActionMode.Cut = new AM_Cut();
        ActionMode.Copy = new AM_Copy();
        ActionMode.Blueprint = new AM_Blueprint();
        ActionMode.Build = new AM_Build();
        ActionMode.Picker = new AM_Picker();
        ActionMode.StateEditor = new AM_StateEditor();
        ActionMode.CreateArea = new AM_CreateArea();
        ActionMode.EditArea = new AM_EditArea();
        ActionMode.ExpandArea = new AM_ExpandArea();
        ActionMode.RemoveDesignation = new AM_RemoveDesignation();
        ActionMode.Deconstruct = new AM_Deconstruct();
        ActionMode.ViewMap = new AM_ViewMap();
        ActionMode.Terrain = new AM_Terrain();
        ActionMode.Populate = new AM_Populate();
        ActionMode.EditMarker = new AM_EditMarker();
        ActionMode.Visibility = new AM_Visibility();
        ActionMode.Cinema = new AM_Cinema();
        ActionMode.FlagCell = new AM_FlagCell();
        ActionMode.Paint = new AM_Paint();
    }
 
    // Token: 0x170001CD RID: 461
    // (get) Token: 0x06000847 RID: 2119 RVA: 0x0003685D File Offset: 0x00034A5D
    public virtual float gameSpeed
    {
        get
        {
            return 1f;
        }
    }
 
    // Token: 0x170001CE RID: 462
    // (get) Token: 0x06000848 RID: 2120 RVA: 0x00036864 File Offset: 0x00034A64
    public bool IsActive
    {
        get
        {
            return EClass.scene.actionMode == this;
        }
    }
 
    // Token: 0x170001CF RID: 463
    // (get) Token: 0x06000849 RID: 2121 RVA: 0x00036873 File Offset: 0x00034A73
    public virtual BaseTileSelector.HitType hitType
    {
        get
        {
            return BaseTileSelector.HitType.Floor;
        }
    }
 
    // Token: 0x170001D0 RID: 464
    // (get) Token: 0x0600084A RID: 2122 RVA: 0x00036876 File Offset: 0x00034A76
    public virtual BaseTileSelector.SelectType selectType
    {
        get
        {
            return BaseTileSelector.SelectType.Multiple;
        }
    }
 
    // Token: 0x170001D1 RID: 465
    // (get) Token: 0x0600084B RID: 2123 RVA: 0x00036879 File Offset: 0x00034A79
    public virtual BaseTileSelector.BoxType boxType
    {
        get
        {
            return BaseTileSelector.BoxType.Box;
        }
    }
 
    // Token: 0x170001D2 RID: 466
    // (get) Token: 0x0600084C RID: 2124 RVA: 0x0003687C File Offset: 0x00034A7C
    public virtual bool ContinuousClick
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x170001D3 RID: 467
    // (get) Token: 0x0600084D RID: 2125 RVA: 0x0003687F File Offset: 0x00034A7F
    public virtual int hitW
    {
        get
        {
            return 1;
        }
    }
 
    // Token: 0x170001D4 RID: 468
    // (get) Token: 0x0600084E RID: 2126 RVA: 0x00036882 File Offset: 0x00034A82
    public virtual int hitH
    {
        get
        {
            return 1;
        }
    }
 
    // Token: 0x170001D5 RID: 469
    // (get) Token: 0x0600084F RID: 2127 RVA: 0x00036885 File Offset: 0x00034A85
    public HitSummary Summary
    {
        get
        {
            return this.tileSelector.summary;
        }
    }
 
    // Token: 0x170001D6 RID: 470
    // (get) Token: 0x06000850 RID: 2128 RVA: 0x00036892 File Offset: 0x00034A92
    public bool Multisize
    {
        get
        {
            return this.hitW != 1 || this.hitW != 1;
        }
    }
 
    // Token: 0x170001D7 RID: 471
    // (get) Token: 0x06000851 RID: 2129 RVA: 0x000368AB File Offset: 0x00034AAB
    public virtual string id
    {
        get
        {
            return base.GetType().Name.Split('_', StringSplitOptions.None)[1];
        }
    }
 
    // Token: 0x170001D8 RID: 472
    // (get) Token: 0x06000852 RID: 2130 RVA: 0x000368C2 File Offset: 0x00034AC2
    public virtual CursorInfo DefaultCursor
    {
        get
        {
            return null;
        }
    }
 
    // Token: 0x170001D9 RID: 473
    // (get) Token: 0x06000853 RID: 2131 RVA: 0x000368C5 File Offset: 0x00034AC5
    public virtual string idHelpTopic
    {
        get
        {
            return "4";
        }
    }
 
    // Token: 0x170001DA RID: 474
    // (get) Token: 0x06000854 RID: 2132 RVA: 0x000368CC File Offset: 0x00034ACC
    public virtual string idSound
    {
        get
        {
            return null;
        }
    }
 
    // Token: 0x170001DB RID: 475
    // (get) Token: 0x06000855 RID: 2133 RVA: 0x000368CF File Offset: 0x00034ACF
    public virtual bool enableMouseInfo
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x170001DC RID: 476
    // (get) Token: 0x06000856 RID: 2134 RVA: 0x000368D2 File Offset: 0x00034AD2
    public virtual bool hideBalloon
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x170001DD RID: 477
    // (get) Token: 0x06000857 RID: 2135 RVA: 0x000368D5 File Offset: 0x00034AD5
    public virtual string textHintTitle
    {
        get
        {
            return null;
        }
    }
 
    // Token: 0x170001DE RID: 478
    // (get) Token: 0x06000858 RID: 2136 RVA: 0x000368D8 File Offset: 0x00034AD8
    public virtual bool AllowAutoClick
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x170001DF RID: 479
    // (get) Token: 0x06000859 RID: 2137 RVA: 0x000368DB File Offset: 0x00034ADB
    public virtual bool ShowActionHint
    {
        get
        {
            return true;
        }
    }
 
    // Token: 0x170001E0 RID: 480
    // (get) Token: 0x0600085A RID: 2138 RVA: 0x000368DE File Offset: 0x00034ADE
    public virtual bool ShowMouseoverTarget
    {
        get
        {
            return true;
        }
    }
 
    // Token: 0x170001E1 RID: 481
    // (get) Token: 0x0600085B RID: 2139 RVA: 0x000368E1 File Offset: 0x00034AE1
    public virtual AreaHighlightMode AreaHihlight
    {
        get
        {
            return AreaHighlightMode.None;
        }
    }
 
    // Token: 0x170001E2 RID: 482
    // (get) Token: 0x0600085C RID: 2140 RVA: 0x000368E4 File Offset: 0x00034AE4
    public virtual bool CanSelectTile
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x170001E3 RID: 483
    // (get) Token: 0x0600085D RID: 2141 RVA: 0x000368E7 File Offset: 0x00034AE7
    public virtual bool CanTargetOutsideBounds
    {
        get
        {
            return true;
        }
    }
 
    // Token: 0x170001E4 RID: 484
    // (get) Token: 0x0600085E RID: 2142 RVA: 0x000368EA File Offset: 0x00034AEA
    public virtual bool ShouldPauseGame
    {
        get
        {
            return true;
        }
    }
 
    // Token: 0x170001E5 RID: 485
    // (get) Token: 0x0600085F RID: 2143 RVA: 0x000368ED File Offset: 0x00034AED
    public virtual bool FixFocus
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x170001E6 RID: 486
    // (get) Token: 0x06000860 RID: 2144 RVA: 0x000368F0 File Offset: 0x00034AF0
    public virtual bool HideSubWidgets
    {
        get
        {
            return true;
        }
    }
 
    // Token: 0x170001E7 RID: 487
    // (get) Token: 0x06000861 RID: 2145 RVA: 0x000368F3 File Offset: 0x00034AF3
    public virtual bool IsBuildMode
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x170001E8 RID: 488
    // (get) Token: 0x06000862 RID: 2146 RVA: 0x000368F6 File Offset: 0x00034AF6
    public virtual bool ShowBuildWidgets
    {
        get
        {
            return this.IsBuildMode;
        }
    }
 
    // Token: 0x170001E9 RID: 489
    // (get) Token: 0x06000863 RID: 2147 RVA: 0x000368FE File Offset: 0x00034AFE
    public virtual BuildMenu.Mode buildMenuMode
    {
        get
        {
            if (!this.IsBuildMode)
            {
                return BuildMenu.Mode.None;
            }
            return BuildMenu.Mode.Hide;
        }
    }
 
    // Token: 0x170001EA RID: 490
    // (get) Token: 0x06000864 RID: 2148 RVA: 0x0003690B File Offset: 0x00034B0B
    public virtual bool ShouldHideBuildMenu
    {
        get
        {
            return this.IsBuildMode && this.tileSelector.start != null;
        }
    }
 
    // Token: 0x170001EB RID: 491
    // (get) Token: 0x06000865 RID: 2149 RVA: 0x00036925 File Offset: 0x00034B25
    public virtual bool CanTargetFog
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x170001EC RID: 492
    // (get) Token: 0x06000866 RID: 2150 RVA: 0x00036928 File Offset: 0x00034B28
    public virtual int CostMoney
    {
        get
        {
            return 0;
        }
    }
 
    // Token: 0x170001ED RID: 493
    // (get) Token: 0x06000867 RID: 2151 RVA: 0x0003692B File Offset: 0x00034B2B
    public virtual bool AllowBuildModeShortcuts
    {
        get
        {
            return this.IsBuildMode;
        }
    }
 
    // Token: 0x170001EE RID: 494
    // (get) Token: 0x06000868 RID: 2152 RVA: 0x00036933 File Offset: 0x00034B33
    public virtual bool AllowMiddleClickFunc
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x170001EF RID: 495
    // (get) Token: 0x06000869 RID: 2153 RVA: 0x00036936 File Offset: 0x00034B36
    public virtual bool AllowHotbar
    {
        get
        {
            return true;
        }
    }
 
    // Token: 0x170001F0 RID: 496
    // (get) Token: 0x0600086A RID: 2154 RVA: 0x00036939 File Offset: 0x00034B39
    public virtual bool AllowGeneralInput
    {
        get
        {
            return true;
        }
    }
 
    // Token: 0x170001F1 RID: 497
    // (get) Token: 0x0600086B RID: 2155 RVA: 0x0003693C File Offset: 0x00034B3C
    public virtual bool ShowMaskedThings
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x170001F2 RID: 498
    // (get) Token: 0x0600086C RID: 2156 RVA: 0x0003693F File Offset: 0x00034B3F
    public virtual int SelectorHeight
    {
        get
        {
            return -1;
        }
    }
 
    // Token: 0x170001F3 RID: 499
    // (get) Token: 0x0600086D RID: 2157 RVA: 0x00036942 File Offset: 0x00034B42
    public virtual bool AllowWheelZoom
    {
        get
        {
            return true;
        }
    }
 
    // Token: 0x0600086E RID: 2158 RVA: 0x00036945 File Offset: 0x00034B45
    public virtual int TopHeight(Point p)
    {
        return -1;
    }
 
    // Token: 0x170001F4 RID: 500
    // (get) Token: 0x0600086F RID: 2159 RVA: 0x00036948 File Offset: 0x00034B48
    public virtual float TargetZoom
    {
        get
        {
            return 1f;
        }
    }
 
    // Token: 0x170001F5 RID: 501
    // (get) Token: 0x06000870 RID: 2160 RVA: 0x0003694F File Offset: 0x00034B4F
    public virtual BaseTileMap.CardIconMode cardIconMode
    {
        get
        {
            return BaseTileMap.CardIconMode.None;
        }
    }
 
    // Token: 0x170001F6 RID: 502
    // (get) Token: 0x06000871 RID: 2161 RVA: 0x00036952 File Offset: 0x00034B52
    public virtual BaseGameScreen TargetGameScreen
    {
        get
        {
            return null;
        }
    }
 
    // Token: 0x170001F7 RID: 503
    // (get) Token: 0x06000872 RID: 2162 RVA: 0x00036955 File Offset: 0x00034B55
    public virtual bool IsNoMap
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x06000873 RID: 2163 RVA: 0x00036958 File Offset: 0x00034B58
    public virtual void SEExecuteSummary()
    {
        SE.Play("plan");
    }
 
    // Token: 0x170001F8 RID: 504
    // (get) Token: 0x06000874 RID: 2164 RVA: 0x00036964 File Offset: 0x00034B64
    public virtual bool UseSubMenu
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x170001F9 RID: 505
    // (get) Token: 0x06000875 RID: 2165 RVA: 0x00036967 File Offset: 0x00034B67
    public virtual bool UseSubMenuSlider
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x170001FA RID: 506
    // (get) Token: 0x06000876 RID: 2166 RVA: 0x0003696A File Offset: 0x00034B6A
    public virtual bool SubMenuAsGroup
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x06000877 RID: 2167 RVA: 0x0003696D File Offset: 0x00034B6D
    public virtual bool HighlightWall(Point p)
    {
        return false;
    }
 
    // Token: 0x170001FB RID: 507
    // (get) Token: 0x06000878 RID: 2168 RVA: 0x00036970 File Offset: 0x00034B70
    public virtual int SubMenuModeIndex
    {
        get
        {
            return 0;
        }
    }
 
    // Token: 0x06000879 RID: 2169 RVA: 0x00036973 File Offset: 0x00034B73
    public virtual void OnClickSubMenu(int a)
    {
    }
 
    // Token: 0x0600087A RID: 2170 RVA: 0x00036975 File Offset: 0x00034B75
    public virtual string OnSetSubMenuButton(int a, UIButton b)
    {
        return null;
    }
 
    // Token: 0x0600087B RID: 2171 RVA: 0x00036978 File Offset: 0x00034B78
    public virtual bool IsRoofEditMode(Card c = null)
    {
        return false;
    }
 
    // Token: 0x0600087C RID: 2172 RVA: 0x0003697B File Offset: 0x00034B7B
    public virtual bool IsFillMode()
    {
        return false;
    }
 
    // Token: 0x0600087D RID: 2173 RVA: 0x0003697E File Offset: 0x00034B7E
    public virtual int GetDefaultTile(Point p)
    {
        return 0;
    }
 
    // Token: 0x170001FC RID: 508
    // (get) Token: 0x0600087E RID: 2174 RVA: 0x00036981 File Offset: 0x00034B81
    public virtual bool ShowExtraHint
    {
        get
        {
            return Lang.GetList("exhint_" + base.GetType().Name) != null;
        }
    }
 
    // Token: 0x0600087F RID: 2175 RVA: 0x000369A0 File Offset: 0x00034BA0
    public virtual void OnShowExtraHint(UINote n)
    {
        string[] list = Lang.GetList("exhint_" + base.GetType().Name);
        if (list == null)
        {
            return;
        }
        foreach (string text in list)
        {
            n.AddText("NoteText_extrahint", text, Color.white);
        }
    }
 
    // Token: 0x170001FD RID: 509
    // (get) Token: 0x06000880 RID: 2176 RVA: 0x000369F2 File Offset: 0x00034BF2
    public BaseTileSelector tileSelector
    {
        get
        {
            return EClass.screen.tileSelector;
        }
    }
 
    // Token: 0x06000881 RID: 2177 RVA: 0x00036A00 File Offset: 0x00034C00
    public void Activate(bool toggle = true, bool forceActivate = false)
    {
        if (this.TargetGameScreen != null)
        {
            this.TargetGameScreen.Activate();
        }
        if (EClass.scene.actionMode == this && !forceActivate)
        {
            if (toggle && EClass.scene.actionMode != ActionMode.DefaultMode)
            {
                ActionMode.DefaultMode.Activate(true, false);
            }
            return;
        }
        if (ActionMode.ignoreSound)
        {
            ActionMode.ignoreSound = false;
        }
        else
        {
            EClass.Sound.Play(this.idSound);
        }
        EInput.Consume(0);
        ActionMode actionMode = EClass.scene.actionMode;
        EClass.scene.actionMode = this;
        if (actionMode != null)
        {
            if (actionMode.IsBuildMode && !(actionMode is AM_ViewMap))
            {
                ActionMode.LastBuildMode = actionMode;
            }
            actionMode.ClearSimpleTexts();
            actionMode.OnDeactivate();
            if (EClass.core.IsGameStarted)
            {
                foreach (Card card in EClass._map.things.Concat(EClass._map.charas))
                {
                    card.renderer.DespawnSimpleText();
                }
            }
            AM_NoMap noMap = ActionMode.NoMap;
            EClass.ui.RemoveLayers(false);
        }
        if (this.IsBuildMode)
        {
            BuildMenu.Activate();
            BuildMenu.Instance.terrainMenu.Show(this);
        }
        else
        {
            BuildMenu.Deactivate();
        }
        if (!(this is AM_Adv))
        {
            EClass.ui.hud.transRight.SetActive(false);
        }
        EClass.ui.hud.frame.SetActive(this.IsBuildMode && EClass.game.altUI);
        if (this.hideBalloon)
        {
            EClass.ui.ShowBalloon(false);
        }
        else
        {
            EClass.ui.ShowBalloon(!EClass.scene.hideBalloon);
        }
        this.OnActivate();
        this.RefreshTexts();
        this.ShowLayer();
        EClass.ui.widgets.OnChangeActionMode();
        EClass.ui.extraHint.OnChangeActionMode();
        CursorSystem.leftIcon = null;
        EClass.scene.UpdateCursor();
    }
 
    // Token: 0x06000882 RID: 2178 RVA: 0x00036C08 File Offset: 0x00034E08
    public virtual void OnActivate()
    {
    }
 
    // Token: 0x06000883 RID: 2179 RVA: 0x00036C0C File Offset: 0x00034E0C
    public unsafe void RefreshTexts()
    {
        if (!EClass.core.IsGameStarted)
        {
            return;
        }
        this.ClearSimpleTexts();
        if (EClass._zone.IsRegion)
        {
            foreach (Spatial spatial in EClass._zone.children)
            {
                if (!spatial.destryoed)
                {
                    Sprite sprite = null;
                    if (spatial.isRandomSite && !spatial.isConquered && spatial.visitCount > 0)
                    {
                        sprite = EClass.core.refs.tcs.spriteVisited;
                    }
                    else if (spatial.isConquered)
                    {
                        sprite = EClass.core.refs.tcs.spriteConquer;
                    }
                    if (sprite)
                    {
                        TCSimpleText tcsimpleText = TCSimpleText.SpawnIcon(sprite);
                        ActionMode.simpleTexts.Add(tcsimpleText);
                        Cell cell = spatial.RegionPos.cell;
                        tcsimpleText.transform.position = *cell.GetPoint().PositionTopdown() + EClass.setting.render.tc.simpleTextPos;
                    }
                }
            }
        }
        if (!this.IsBuildMode || !this.ShowMaskedThings)
        {
            return;
        }
        foreach (Card card in EClass._map.things.Concat(EClass._map.charas))
        {
            string simpleText = this.GetSimpleText(card);
            if (!simpleText.IsEmpty())
            {
                TCSimpleText tcsimpleText2 = TCSimpleText.Spawn();
                Popper.SetText(tcsimpleText2.tm, simpleText);
                ActionMode.simpleTexts.Add(tcsimpleText2);
                tcsimpleText2.transform.position = *card.pos.Position() + EClass.setting.render.tc.simpleTextPos;
            }
        }
        if (Application.isEditor)
        {
            foreach (KeyValuePair<int, int> keyValuePair in EClass._map.backerObjs)
            {
                SourceBacker.Row row = EClass.sources.backers.map[keyValuePair.Value];
                string text = "Backer:" + row.id.ToString() + "/" + row.Name;
                if (row.isStatic != 0)
                {
                    text = "★" + text;
                }
                TCSimpleText tcsimpleText3 = TCSimpleText.Spawn();
                Popper.SetText(tcsimpleText3.tm, text);
                ActionMode.simpleTexts.Add(tcsimpleText3);
                Cell cell2 = EClass._map.GetCell(keyValuePair.Key);
                tcsimpleText3.transform.position = *cell2.GetPoint().Position() + EClass.setting.render.tc.simpleTextPos;
            }
            foreach (Card card2 in EClass._map.Cards)
            {
                if (card2.isBackerContent)
                {
                    SourceBacker.Row row2 = EClass.sources.backers.map.TryGetValue(card2.c_idBacker, null);
                    if (row2 != null)
                    {
                        string text2 = "Backer:" + row2.id.ToString() + "/" + row2.Name;
                        if (row2.isStatic != 0)
                        {
                            text2 = "★" + text2;
                        }
                        TCSimpleText tcsimpleText4 = TCSimpleText.Spawn();
                        Popper.SetText(tcsimpleText4.tm, text2);
                        ActionMode.simpleTexts.Add(tcsimpleText4);
                        tcsimpleText4.transform.position = card2.renderer.position + EClass.setting.render.tc.simpleTextPos;
                    }
                }
            }
        }
    }
 
    // Token: 0x06000884 RID: 2180 RVA: 0x0003701C File Offset: 0x0003521C
    public virtual string GetSimpleText(Card c)
    {
        if (c.trait is TraitRoomPlate && c.Cell.room != null)
        {
            return "#" + c.Cell.room.data.group.ToString();
        }
        return null;
    }
 
    // Token: 0x06000885 RID: 2181 RVA: 0x0003706C File Offset: 0x0003526C
    public void ClearSimpleTexts()
    {
        foreach (TCSimpleText tcsimpleText in ActionMode.simpleTexts)
        {
            if (tcsimpleText != null)
            {
                PoolManager.Despawn(tcsimpleText);
            }
        }
        ActionMode.simpleTexts.Clear();
    }
 
    // Token: 0x06000886 RID: 2182 RVA: 0x000370D0 File Offset: 0x000352D0
    public void Deactivate()
    {
        ActionMode.DefaultMode.Activate(true, false);
    }
 
    // Token: 0x06000887 RID: 2183 RVA: 0x000370DE File Offset: 0x000352DE
    public virtual void OnDeactivate()
    {
    }
 
    // Token: 0x06000888 RID: 2184 RVA: 0x000370E0 File Offset: 0x000352E0
    public virtual void OnCancel()
    {
        if (this.IsBuildMode && !EClass.core.config.input.rightClickExitBuildMode && !Input.GetKey(KeyCode.Escape))
        {
            return;
        }
        this.Deactivate();
    }
 
    // Token: 0x06000889 RID: 2185 RVA: 0x00037110 File Offset: 0x00035310
    public virtual void OnBeforeUpdate()
    {
    }
 
    // Token: 0x0600088A RID: 2186 RVA: 0x00037112 File Offset: 0x00035312
    public virtual void OnAfterUpdate()
    {
    }
 
    // Token: 0x0600088B RID: 2187 RVA: 0x00037114 File Offset: 0x00035314
    public virtual void OnUpdateCursor()
    {
        CursorSystem.leftIcon = null;
        CursorSystem.SetCursor(null, 0);
    }
 
    // Token: 0x0600088C RID: 2188 RVA: 0x00037123 File Offset: 0x00035323
    public void OnRotate()
    {
        this.RotateUnderMouse();
    }
 
    // Token: 0x0600088D RID: 2189 RVA: 0x0003712B File Offset: 0x0003532B
    public void SetCursorOnMap(CursorInfo cursor)
    {
        CursorSystem.SetCursor(EClass.ui.isPointerOverUI ? null : cursor, 0);
    }
 
    // Token: 0x0600088E RID: 2190 RVA: 0x00037144 File Offset: 0x00035344
    public void UpdateInput()
    {
        ActionMode.mpos = Input.mousePosition;
        if (!this.IsNoMap)
        {
            EClass.scene.mouseTarget.Update(Scene.HitPoint);
            if (WidgetMouseover.Instance)
            {
                WidgetMouseover.Instance.Refresh();
            }
        }
        if (LayerAbility.hotElement != null)
        {
            ActionMode.hotElementTimer += Core.delta;
            ButtonAbility hotElement = LayerAbility.hotElement;
            if (EInput.leftMouse.down)
            {
                if (EClass.core.config.game.doubleClickToHold && ActionMode.hotElementTimer < 0.35f)
                {
                    EClass.player.SetCurrentHotItem(new HotItemAct(hotElement.source));
                    SE.SelectHotitem();
                }
                else
                {
                    ButtonGrid componentOf = InputModuleEX.GetComponentOf<ButtonGrid>();
                    if (componentOf && componentOf.invOwner != null && componentOf.invOwner.owner == EClass.pc && (componentOf.card == null || componentOf.card.trait is TraitAbility) && !(componentOf.invOwner is InvOwnerEquip))
                    {
                        if (componentOf.card != null)
                        {
                            componentOf.card.Destroy();
                        }
                        SE.Equip();
                        CardBlueprint.SetNormalRarity(false);
                        Thing thing = ThingGen.Create("ability", -1, -1);
                        int num = (componentOf.invOwner is InvOwnerHotbar) ? 1 : 0;
                        componentOf.invOwner.Container.AddThing(thing, false, componentOf.index, num);
                        thing.c_idAbility = hotElement.source.alias;
                        thing.invY = num;
                        thing.invX = componentOf.index;
                        WidgetCurrentTool.dirty = true;
                    }
                    else
                    {
                        SE.BeepSmall();
                    }
                }
                LayerAbility.ClearHotElement();
            }
            if (EInput.rightMouse.down)
            {
                LayerAbility.ClearHotElement();
            }
        }
        else
        {
            ActionMode.hotElementTimer = 0f;
        }
        ActionMode.focusTimer += Core.delta;
        if (EClass.ui.isPointerOverUI && (EInput.leftMouse.down || EInput.rightMouse.down || (EClass.core.config.ui.autoFocusWindow && !Input.GetMouseButton(0) && ActionMode.focusTimer > 0.2f)))
        {
            LayerInventory componentOf2 = InputModuleEX.GetComponentOf<LayerInventory>();
            if (componentOf2 != null && EClass.ui.layerFloat.layers.Contains(componentOf2))
            {
                if (EInput.rightMouse.down)
                {
                    if (!componentOf2.mainInv && !InputModuleEX.GetComponentOf<UIButton>() && !componentOf2.windows[0].saveData.noRightClickClose)
                    {
                        componentOf2.Close();
                    }
                }
                else
                {
                    componentOf2.transform.SetAsLastSibling();
                }
            }
            LayerAbility componentOf3 = InputModuleEX.GetComponentOf<LayerAbility>();
            if (componentOf3 != null && EClass.ui.layerFloat.layers.Contains(componentOf3))
            {
                componentOf3.transform.SetAsLastSibling();
            }
            ActionMode.focusTimer = 0f;
        }
        if ((EInput.isShiftDown && Input.GetMouseButton(0)) || (EInput.rightMouse.dragging2 && !Input.GetMouseButtonDown(1) && Input.GetMouseButton(1)))
        {
            bool rightMouse = !Input.GetMouseButtonDown(1) && Input.GetMouseButton(1);
            ButtonGrid componentOf4 = InputModuleEX.GetComponentOf<ButtonGrid>();
            if (componentOf4 != null && componentOf4.invOwner != null && componentOf4.card != null && componentOf4.invOwner.CanShiftClick(componentOf4, rightMouse) && EClass.ui.AllowInventoryInteractions)
            {
                componentOf4.invOwner.OnShiftClick(componentOf4, rightMouse);
            }
        }
        if (EInput.rightMouse.down)
        {
            if (EClass.ui.contextMenu.isActive)
            {
                EClass.ui.contextMenu.currentMenu.Hide();
                EInput.rightMouse.Consume();
                Layer.rightClicked = false;
            }
            if (DropdownGrid.IsActive && !EClass.ui.GetLayer<LayerInfo>(false))
            {
                DropdownGrid.Instance.Deactivate();
                EInput.rightMouse.Consume();
                Layer.rightClicked = false;
            }
        }
        if (EInput.middleMouse.down && this.TryShowWidgetMenu())
        {
            EInput.Consume(false, 1);
        }
        if (EInput.middleMouse.down || EInput.middleMouse.clicked || EInput.middleMouse.pressedLong)
        {
            UIButton componentOf5 = InputModuleEX.GetComponentOf<UIButton>();
            if (componentOf5 && componentOf5.CanMiddleClick() && (EInput.middleMouse.clicked || EInput.middleMouse.pressedLong))
            {
                componentOf5.OnMiddleClick();
            }
        }
        if (EClass.ui.contextMenu.currentMenu)
        {
            UIContextMenu.timeSinceClosed = 0f;
        }
        else
        {
            UIContextMenu.timeSinceClosed += Time.deltaTime;
        }
        if (EClass.ui.currentDrag != null)
        {
            EClass.ui.OnDrag();
            if (EInput.leftMouse.down || EInput.rightMouse.down)
            {
                EClass.ui.EndDrag(EInput.rightMouse.down);
            }
        }
        ButtonState middleMouse = EInput.middleMouse;
        if (middleMouse.pressedLongAction != null)
        {
            if (middleMouse.pressedLong)
            {
                middleMouse.pressedLongAction();
                middleMouse.pressedLongAction = null;
            }
            else if (!EInput.middleMouse.pressing)
            {
                middleMouse.pressedLongAction = null;
            }
        }
        EClass.ui.UpdateInput();
        if (this.AllowGeneralInput && !EClass.ui.IsDragging)
        {
            if (Input.GetKeyDown(KeyCode.Tab) && !EClass.debug.debugInput && !EClass.ui.BlockInput && !EInput.waitReleaseAnyKey)
            {
                if (!EClass.ui.IsInventoryOpen)
                {
                    SE.PopInventory();
                }
                EClass.ui.ToggleInventory(false);
            }
            if (!EClass.ui.BlockInput && !this.IsBuildMode && !EInput.waitReleaseAnyKey)
            {
                switch (EInput.action)
                {
                case EAction.MenuInventory:
                    EClass.ui.ToggleInventory(false);
                    break;
                case EAction.MenuChara:
                {
                    LayerChara layerChara = EClass.ui.ToggleLayer<LayerChara>(null);
                    if (layerChara != null)
                    {
                        layerChara.SetChara(EClass.pc);
                    }
                    break;
                }
                case EAction.MenuJournal:
                    EClass.ui.ToggleLayer<LayerJournal>(null);
                    break;
                case EAction.MenuAbility:
                    if (!EClass.debug.enable)
                    {
                        EClass.ui.ToggleAbility(false);
                    }
                    break;
                }
            }
            if (!this.FixFocus)
            {
                this.InputMovement();
            }
            if (!EClass.ui.canvas.enabled && EInput.IsAnyKeyDown(true))
            {
                EClass.ui.canvas.enabled = true;
                EInput.Consume(false, 1);
                return;
            }
        }
        if (EInput.action == EAction.Examine && !this.IsBuildMode)
        {
            ButtonGrid componentOf6 = InputModuleEX.GetComponentOf<ButtonGrid>();
            Card card = null;
            if (componentOf6 && componentOf6.card != null)
            {
                card = componentOf6.card;
            }
            if (card == null)
            {
                UIItem componentOf7 = InputModuleEX.GetComponentOf<UIItem>();
                if (componentOf7 && componentOf7.refObj is Thing)
                {
                    card = (Thing)componentOf7.refObj;
                }
            }
            if (card == null)
            {
                LayerCraft layerCraft = EClass.ui.GetLayer<LayerCraft>(false);
                if (layerCraft)
                {
                    card = layerCraft.product;
                }
            }
            if (card != null)
            {
                if (EClass.ui.GetLayer<LayerInfo>(false))
                {
                    EClass.ui.RemoveLayer<LayerInfo>();
                }
                EClass.ui.AddLayer<LayerInfo>().Set(card, true);
            }
        }
        if (EInput.buttonCtrl.clicked && !LayerDrama.Instance && EClass.scene.actionMode is AM_Adv && WidgetCurrentTool.Instance)
        {
            WidgetCurrentTool.Instance.SwitchPage();
        }
        if (EClass.ui.BlockActions)
        {
            return;
        }
        if (this.AllowBuildModeShortcuts && Input.GetKeyDown(KeyCode.Q) && ActionMode.Picker.CanActivate)
        {
            ActionMode.Picker.Activate(true, false);
        }
        if (EClass.debug.godBuild && EInput.isCtrlDown && EInput.wheel != 0 && Scene.HitPoint.IsValid && HotItemHeld.taskBuild == null)
        {
            Point hitPoint = Scene.HitPoint;
            bool flag = EInput.wheel > 0;
            if (EClass.scene.mouseTarget.card != null)
            {
                Card card2 = EClass.scene.mouseTarget.card;
                if (card2.isThing && card2.IsInstalled)
                {
                    SourceMaterial.Row currentMat = card2.isDyed ? card2.DyeMat : card2.material;
                    List<SourceMaterial.Row> source = (from m in EClass.sources.materials.rows
                    where m.thing == currentMat.thing
                    select m).ToList<SourceMaterial.Row>();
                    if (EInput.isShiftDown)
                    {
                        source = EClass.sources.materials.rows;
                    }
                    SourceMaterial.Row row = flag ? source.NextItem(currentMat) : source.PrevItem(currentMat);
                    if (EInput.isAltDown)
                    {
                        row = ActionMode.lastEditorMat;
                    }
                    if (card2.isDyed)
                    {
                        card2.Dye(row);
                    }
                    else
                    {
                        card2.ChangeMaterial(row);
                    }
                    ActionMode.lastEditorMat = row;
                    Msg.Say(row.GetName() + "(" + row.alias + ")");
                }
            }
            else if (hitPoint.HasObj)
            {
                SourceMaterial.Row matObj = hitPoint.cell.matObj;
                List<SourceMaterial.Row> rows = EClass.sources.materials.rows;
                SourceMaterial.Row row2 = flag ? rows.NextItem(matObj) : rows.PrevItem(matObj);
                if (EInput.isAltDown)
                {
                    row2 = ActionMode.lastEditorMat;
                }
                hitPoint.cell.objMat = (byte)row2.id;
                ActionMode.lastEditorMat = row2;
                Msg.Say(row2.GetName());
            }
            EInput.Consume(false, 1);
        }
        if (this.AllowHotbar && !this.IsBuildMode && EClass.debug.debugHotkeys == CoreDebug.DebugHotkey.None)
        {
            if (EInput.hotkey != -1)
            {
                WidgetCurrentTool.Instance.Select(EInput.hotkey, true);
                ActionMode.AdvOrRegion.UpdatePlans();
            }
            else if (!EClass.debug.enable && EInput.functionkey != -1)
            {
                WidgetHotbar hotbarExtra = WidgetHotbar.HotbarExtra;
                if (hotbarExtra)
                {
                    hotbarExtra.TryUse(EInput.functionkey);
                }
            }
        }
        this.OnUpdateInput();
        if (EClass.debug.enable)
        {
            EClass.core.debug.UpdateInput();
        }
        ActionMode.textTimer += Core.delta;
        if (ActionMode.textTimer > 0.1f)
        {
            ActionMode.textTimer = 0f;
            this.RefreshTexts();
        }
        if (this.IsBuildMode)
        {
            CoreConfig.InputSetting input = EClass.core.config.input;
            if (EInput.middleMouse.clicked)
            {
                this.DoFunc(input.b_middleClick);
            }
            else if (EInput.middleMouse.pressedLong)
            {
                this.DoFunc(input.b_middlePressLong);
                EInput.middleMouse.Consume();
            }
            if (EInput.mouse3.clicked)
            {
                this.DoFunc(input.b_mouse3Click);
            }
            else if (EInput.mouse3.pressedLong)
            {
                this.DoFunc(input.b_mouse3PressLong);
                EInput.mouse3.Consume();
            }
            if (EInput.mouse4.clicked)
            {
                this.DoFunc(input.b_mouse4Click);
                return;
            }
            if (EInput.mouse4.pressedLong)
            {
                this.DoFunc(input.b_mouse4PressLong);
                EInput.mouse4.Consume();
            }
        }
    }
 
    // Token: 0x0600088F RID: 2191 RVA: 0x00037C48 File Offset: 0x00035E48
    public void InputMovement()
    {
        float num = 0f;
        float num2 = 0f;
        Vector2 vector = EInput.axis;
        bool flag = !EClass.core.IsGameStarted;
        if ((!this.FixFocus && !EInput.rightMouse.pressing) || EClass.scene.actionMode.IsBuildMode)
        {
            if (Input.GetKey(KeyCode.LeftShift))
            {
                vector *= 3f;
            }
            if (EClass.core.config.camera.edgeScroll)
            {
                Vector2 zero = Vector2.zero;
                if (ActionMode.mpos.x < 16f)
                {
                    zero.x -= 1f;
                }
                if (ActionMode.mpos.x > (float)(Screen.width - 16))
                {
                    zero.x += 1f;
                }
                if (ActionMode.mpos.y < 8f)
                {
                    zero.y -= 1f;
                }
                if (ActionMode.mpos.y > (float)(Screen.height - 8))
                {
                    zero.y += 1f;
                }
                if (zero != Vector2.zero)
                {
                    vector += zero * (EClass.core.config.camera.sensEdge * 2f);
                }
            }
            EInput.hasAxisMoved = (vector != Vector2.zero);
            ButtonState buttonScroll = EInput.buttonScroll;
            if (ActionMode.Adv.IsActive)
            {
                bool zoomOut = ActionMode.Adv.zoomOut;
            }
            if (EInput.buttonScroll != null && EInput.buttonScroll.pressing && (flag || !EClass.ui.BlockActions))
            {
                num = EInput.dragAmount.x * (0.1f + EClass.core.config.camera.sensDrag);
                num2 = EInput.dragAmount.y * (0.1f + EClass.core.config.camera.sensDrag);
                if (!EClass.core.config.camera.invertX)
                {
                    num *= -1f;
                }
                if (!EClass.core.config.camera.invertY)
                {
                    num2 *= -1f;
                }
                if (EInput.hasMouseMoved)
                {
                    EInput.hasAxisMoved = true;
                }
            }
            if (EInput.hasAxisMoved)
            {
                EClass.screen.zoomPos = Vector3.zero;
            }
            if (EInput.wheel != 0 && !InputModuleEX.GetComponentOf<UIScrollView>())
            {
                this.InputWheel(EInput.wheel);
            }
        }
        float momentum = EClass.core.config.camera.momentum;
        if (momentum > 0f && EInput.axis == Vector2.zero)
        {
            ActionMode.smoothX = Mathf.Lerp(ActionMode.smoothX, num, Time.smoothDeltaTime * momentum);
            ActionMode.smoothY = Mathf.Lerp(ActionMode.smoothY, num2, Time.smoothDeltaTime * momentum);
        }
        else
        {
            ActionMode.smoothX = num;
            ActionMode.smoothY = num2;
        }
        EClass.screen.ScrollMouse(ActionMode.smoothX * 0.1f, ActionMode.smoothY * 0.1f);
        if (EInput.hasAxisMoved)
        {
            this.OnScroll();
            EClass.screen.ScrollAxis(vector, false);
        }
    }
 
    // Token: 0x06000890 RID: 2192 RVA: 0x00037F63 File Offset: 0x00036163
    public virtual void InputWheel(int wheel)
    {
        if (this.AllowWheelZoom)
        {
            EClass.screen.ModTargetZoomIndex(-wheel);
        }
    }
 
    // Token: 0x06000891 RID: 2193 RVA: 0x00037F79 File Offset: 0x00036179
    public virtual void OnUpdateInput()
    {
    }
 
    // Token: 0x06000892 RID: 2194 RVA: 0x00037F7C File Offset: 0x0003617C
    public void DoFunc(CoreConfig.GameFuncBuild func)
    {
        switch (func)
        {
        case CoreConfig.GameFuncBuild.ExitBuildMode:
            ActionMode.DefaultMode.Activate(true, false);
            break;
        case CoreConfig.GameFuncBuild.Rotate:
            this.OnRotate();
            break;
        case CoreConfig.GameFuncBuild.ToggleFreepos:
            EClass.scene.ToggleFreePos();
            break;
        case CoreConfig.GameFuncBuild.SnapFreepos:
            EClass.scene.ToggleSnapFreePos();
            break;
        case CoreConfig.GameFuncBuild.ToggleRoof:
            EClass.scene.ToggleShowRoof();
            break;
        case CoreConfig.GameFuncBuild.ToggleSlope:
            EClass.scene.ToggleSlope();
            break;
        case CoreConfig.GameFuncBuild.ToggleWall:
            EClass.scene.ToggleShowWall();
            break;
        case CoreConfig.GameFuncBuild.TogglePicker:
            if (!ActionMode.Picker.CanActivate)
            {
                ActionMode.Picker.Activate(true, false);
            }
            break;
        case CoreConfig.GameFuncBuild.ToggleBuildLight:
            EClass.scene.ToggleLight();
            break;
        }
        WidgetHotbar.RefreshHighlights();
    }
 
    // Token: 0x06000893 RID: 2195 RVA: 0x00038034 File Offset: 0x00036234
    public void DoFunc(CoreConfig.GameFunc func)
    {
        Chara targetChara = EClass.scene.mouseTarget.TargetChara;
        switch (func)
        {
        case CoreConfig.GameFunc.ToggleZoom:
            ActionMode.Adv.ToggleZoom();
            break;
        case CoreConfig.GameFunc.ShowInv:
            EClass.ui.ToggleInventory(true);
            break;
        case CoreConfig.GameFunc.ShowChara:
        {
            LayerChara layerChara = EClass.ui.ToggleLayer<LayerChara>(null);
            if (layerChara)
            {
                layerChara.SetChara(EClass.pc);
                layerChara.windows[0].SetRect(EClass.core.refs.rects.center, false);
                layerChara.Delay(0.05f);
            }
            break;
        }
        case CoreConfig.GameFunc.ShowAbility:
            EClass.ui.ToggleAbility(true);
            break;
        case CoreConfig.GameFunc.ToggleBuild:
            if (!EClass._zone.CanEnterBuildModeAnywhere)
            {
                SE.Beep();
                Msg.Say("invalidAction");
                return;
            }
            ActionMode.Inspect.Activate(true, false);
            break;
        case CoreConfig.GameFunc.ShowJournal:
        {
            LayerJournal layerJournal = EClass.ui.ToggleLayer<LayerJournal>(null);
            if (layerJournal)
            {
                layerJournal.windows[0].SetRect(EClass.core.refs.rects.center, false);
                layerJournal.Delay(0.05f);
            }
            break;
        }
        case CoreConfig.GameFunc.EmuShift:
        case CoreConfig.GameFunc.EmuAlt:
            return;
        case CoreConfig.GameFunc.AllAction:
            if (!EClass.ui.isPointerOverUI)
            {
                ActionMode.Adv.ShowAllAction();
            }
            break;
        case CoreConfig.GameFunc.ToggleNoRoof:
            EClass.game.config.noRoof = !EClass.game.config.noRoof;
            break;
        case CoreConfig.GameFunc.OpenAllyInv:
            if (!EClass.pc.HasNoGoal || (targetChara != null && !targetChara.IsPCFaction))
            {
                return;
            }
            if (EClass.scene.mouseTarget.pos.Equals(EClass.pc.pos))
            {
                if (!EClass.ui.IsInventoryOpen)
                {
                    SE.PopInventory();
                }
                EClass.ui.ToggleInventory(false);
            }
            else if (targetChara != null && EClass.pc.Dist(targetChara) <= 1)
            {
                LayerInventory.CreateContainer(targetChara);
            }
            break;
        case CoreConfig.GameFunc.Talk:
            if (!EClass.pc.HasNoGoal || targetChara == null || targetChara.hostility <= Hostility.Enemy || targetChara.IsPC || EClass.pc.Dist(targetChara) > 2)
            {
                return;
            }
            ACT.Chat.Perform(EClass.pc, targetChara, null);
            break;
        case CoreConfig.GameFunc.EmptyHand:
            EInput.action = EAction.EmptyHand;
            return;
        case CoreConfig.GameFunc.Fire:
            if (EInput.keyFire.Update(true))
            {
                EInput.action = EAction.Fire;
                return;
            }
            break;
        default:
            return;
        }
        EInput.Consume(false, 1);
    }
 
    // Token: 0x06000894 RID: 2196 RVA: 0x000382B4 File Offset: 0x000364B4
    public virtual void OnScroll()
    {
    }
 
    // Token: 0x06000895 RID: 2197 RVA: 0x000382B8 File Offset: 0x000364B8
    public void TryRightClickCloseWidget()
    {
        Widget componentOf = InputModuleEX.GetComponentOf<Widget>();
        if (componentOf && componentOf.RightClickToClose)
        {
            componentOf.Close();
        }
    }
 
    // Token: 0x06000896 RID: 2198 RVA: 0x000382E4 File Offset: 0x000364E4
    public bool TryShowWidgetMenu()
    {
        Widget componentOf = InputModuleEX.GetComponentOf<Widget>();
        if (!componentOf || !componentOf.CanShowContextMenu())
        {
            return false;
        }
        if (componentOf.RightClickToClose)
        {
            componentOf.Close();
            return true;
        }
        componentOf.ShowContextMenu();
        return true;
    }
 
    // Token: 0x06000897 RID: 2199 RVA: 0x00038320 File Offset: 0x00036520
    public HitResult _HitTest(Point point, Point start)
    {
        if (!EClass.debug.ignoreBuildRule && !this.CanTargetOutsideBounds && (!point.IsValid || !point.IsInBoundsPlus))
        {
            return HitResult.NoTarget;
        }
        if (!point.IsValid)
        {
            return HitResult.NoTarget;
        }
        if (!this.CanTargetFog && !point.cell.isSeen)
        {
            return HitResult.Default;
        }
        return this.HitTest(point, start);
    }
 
    // Token: 0x06000898 RID: 2200 RVA: 0x00038384 File Offset: 0x00036584
    public virtual HitResult HitTest(Point point, Point start)
    {
        return HitResult.Default;
    }
 
    // Token: 0x06000899 RID: 2201 RVA: 0x00038387 File Offset: 0x00036587
    public virtual void OnSelectStart(Point point)
    {
    }
 
    // Token: 0x0600089A RID: 2202 RVA: 0x00038389 File Offset: 0x00036589
    public virtual void OnSelectEnd(bool cancel)
    {
    }
 
    // Token: 0x0600089B RID: 2203 RVA: 0x0003838C File Offset: 0x0003658C
    public virtual MeshPass GetGuidePass(Point point)
    {
        if ((!point.HasNonWallBlock && !point.HasBlockRecipe && point.IsSeen) || (point.sourceBlock.tileType.Invisible && !this.IsBuildMode))
        {
            return EClass.screen.guide.passGuideFloor;
        }
        return EClass.screen.guide.passGuideBlock;
    }
 
    // Token: 0x0600089C RID: 2204 RVA: 0x000383EC File Offset: 0x000365EC
    public unsafe virtual void OnRenderTile(Point point, HitResult result, int dir)
    {
        if (result == HitResult.NoTarget || !point.IsValid || (!point.IsSeen && !this.CanTargetFog))
        {
            return;
        }
        MeshPass guidePass = this.GetGuidePass(point);
        int num = (int)result;
        if (this.tileSelector.start != null && result == HitResult.Default)
        {
            num = 2;
        }
        Vector3 vector = *point.Position();
        if (num == 0)
        {
            num = this.GetDefaultTile(point);
        }
        guidePass.Add(vector.x, vector.y, vector.z - 0.01f, (float)num, 0.3f);
        if (!this.IsRoofEditMode(null) && point.HasWallOrFence && !point.cell.hasDoor && this.HighlightWall(point))
        {
            EClass.screen.guide.DrawWall(point, EClass.Colors.blockColors.Passive, true, 0f);
        }
        if (this.IsBuildMode && EClass.screen.tileSelector.start == null && point.Installed != null && ActionMode.Inspect.IsActive)
        {
            point.Installed.trait.OnRenderTile(point, result, dir);
        }
    }
 
    // Token: 0x0600089D RID: 2205 RVA: 0x000384FC File Offset: 0x000366FC
    public unsafe void OnRenderTileFloor(Point point, HitResult result)
    {
        if (result == HitResult.NoTarget || !point.IsValid || (!point.IsSeen && !this.CanTargetFog))
        {
            return;
        }
        MeshPass guidePass = this.GetGuidePass(point);
        int num = (int)result;
        if (this.tileSelector.start != null && result == HitResult.Default)
        {
            num = 2;
        }
        Vector3 vector = *point.Position((int)point.cell.height);
        if (num == 0)
        {
            num = this.GetDefaultTile(point);
        }
        guidePass.Add(vector.x, vector.y, vector.z - 0.01f, (float)num, 0.3f);
    }
 
    // Token: 0x0600089E RID: 2206 RVA: 0x0003858B File Offset: 0x0003678B
    public virtual bool CanProcessTiles()
    {
        return !this.Multisize || this.Summary.countValid == this.hitW * this.hitH;
    }
 
    // Token: 0x0600089F RID: 2207 RVA: 0x000385B2 File Offset: 0x000367B2
    public virtual void OnBeforeProcessTiles()
    {
    }
 
    // Token: 0x060008A0 RID: 2208 RVA: 0x000385B4 File Offset: 0x000367B4
    public virtual void OnProcessTiles(Point point, int dir)
    {
    }
 
    // Token: 0x060008A1 RID: 2209 RVA: 0x000385B6 File Offset: 0x000367B6
    public virtual void OnAfterProcessTiles(Point start, Point end)
    {
    }
 
    // Token: 0x060008A2 RID: 2210 RVA: 0x000385B8 File Offset: 0x000367B8
    public virtual void OnFinishProcessTiles()
    {
    }
 
    // Token: 0x060008A3 RID: 2211 RVA: 0x000385BA File Offset: 0x000367BA
    public virtual void OnRefreshSummary(Point point, HitResult result, HitSummary summary)
    {
        if (result == HitResult.Valid || result == HitResult.Warning)
        {
            summary.money += this.CostMoney;
            summary.countValid++;
        }
    }
 
    // Token: 0x060008A4 RID: 2212 RVA: 0x000385E8 File Offset: 0x000367E8
    public void ShowLayer()
    {
        this.layer = this.OnShowLayer();
        if (this.layer != null)
        {
            CursorSystem.SetCursor(null, 0);
        }
        else
        {
            CursorSystem.SetCursor(this.DefaultCursor, 0);
        }
        if (EClass.core.screen.tileSelector)
        {
            EClass.core.screen.tileSelector.OnChangeActionMode();
        }
        EClass.ui.hud.hint.Refresh();
    }
 
    // Token: 0x060008A5 RID: 2213 RVA: 0x00038662 File Offset: 0x00036862
    public virtual Layer OnShowLayer()
    {
        return null;
    }
 
    // Token: 0x060008A6 RID: 2214 RVA: 0x00038665 File Offset: 0x00036865
    public void HideLayer()
    {
        EClass.ui.RemoveLayer(this.layer);
        CursorSystem.SetCursor(CursorSystem.Select, 0);
        EClass.ui.hud.hint.UpdateText();
        this.OnHideLayer();
    }
 
    // Token: 0x060008A7 RID: 2215 RVA: 0x0003869C File Offset: 0x0003689C
    public virtual void OnHideLayer()
    {
    }
 
    // Token: 0x060008A8 RID: 2216 RVA: 0x000386A0 File Offset: 0x000368A0
    public virtual string GetHintText()
    {
        string text = this.textHintTitle.IsEmpty(Lang.Get(this.id)) + "   - ";
        BaseTileSelector tileSelector = EClass.screen.tileSelector;
        ActionMode actionMode = EClass.scene.actionMode;
        if (this.layer)
        {
            if (actionMode == ActionMode.Build)
            {
                text += "hintBuild".lang();
            }
            if (actionMode == ActionMode.CreateArea)
            {
                text += "hintCreateArea".lang();
            }
        }
        else if (actionMode == ActionMode.Inspect && ActionMode.Inspect.target != null)
        {
            text = "hintMoveTarget".lang();
        }
        else if (this.selectType == BaseTileSelector.SelectType.Single)
        {
            text += "hintSelectSingle".lang();
        }
        else if (tileSelector.start == null)
        {
            text += "hintSelectStart".lang();
        }
        else
        {
            text += "hintSelectEnd".lang();
        }
        if (actionMode == ActionMode.Build && ActionMode.Build.recipe != null && tileSelector.start == null)
        {
            if (ActionMode.Build.recipe.CanRotate)
            {
                text = text + "  " + "hintRotate".lang();
            }
            if (ActionMode.Build.MaxAltitude > 0)
            {
                text = text + "  " + "hintAltitude2".lang();
            }
        }
        return text;
    }
 
    // Token: 0x060008A9 RID: 2217 RVA: 0x000387F4 File Offset: 0x000369F4
    public virtual void RotateUnderMouse()
    {
        SE.Rotate();
        Point hitPoint = Scene.HitPoint;
        if (!hitPoint.IsValid)
        {
            return;
        }
        hitPoint.cell.RotateAll();
        if (EClass.debug.enable)
        {
            GrowSystem growth = hitPoint.growth;
            if (growth != null)
            {
                growth.Grow(100);
            }
            Thing installed = hitPoint.Installed;
            if (((installed != null) ? installed.trait : null) is TraitSeed)
            {
                (hitPoint.Installed.trait as TraitSeed).TrySprout(true, false, null);
                return;
            }
        }
    }
 
    // Token: 0x060008AA RID: 2218 RVA: 0x00038871 File Offset: 0x00036A71
    public virtual ref string SetMouseInfo(ref string s)
    {
        return ref s;
    }
 
    // Token: 0x060008AB RID: 2219 RVA: 0x00038874 File Offset: 0x00036A74
    public void TogglePause()
    {
        if (ActionMode.IsAdv)
        {
            EClass.core.config.game.autopause = !EClass.core.config.game.autopause;
            if (EClass.core.config.game.autopause)
            {
                SE.Play("tick0");
                return;
            }
            SE.Play("tick1");
            return;
        }
        else
        {
            if (EClass.game.gameSpeedIndex != 0)
            {
                this.Pause(true);
                return;
            }
            this.UnPause(true);
            return;
        }
    }
 
    // Token: 0x060008AC RID: 2220 RVA: 0x000388FA File Offset: 0x00036AFA
    public void Pause(bool sound = false)
    {
        this.ChangeGameSpeed(1, sound);
    }
 
    // Token: 0x060008AD RID: 2221 RVA: 0x00038904 File Offset: 0x00036B04
    public void UnPause(bool sound = false)
    {
        this.ChangeGameSpeed(EClass.game.lastGameSpeedIndex, sound);
    }
 
    // Token: 0x060008AE RID: 2222 RVA: 0x00038918 File Offset: 0x00036B18
    public void ChangeGameSpeed(int a, bool sound = false)
    {
        if (EClass.game.gameSpeedIndex == a)
        {
            return;
        }
        if (sound)
        {
            SE.Play("tick" + a.ToString());
        }
        EClass.game.gameSpeedIndex = a;
        if (a != 0)
        {
            EClass.game.lastGameSpeedIndex = a;
        }
        WidgetHotbar.RefreshHighlights();
    }
 
    // Token: 0x040008AA RID: 2218
    public static ActionMode DefaultMode;
 
    // Token: 0x040008AB RID: 2219
    public static AM_Title Title = new AM_Title();
 
    // Token: 0x040008AC RID: 2220
    public static AM_Sim Sim;
 
    // Token: 0x040008AD RID: 2221
    public static AM_ViewZone View;
 
    // Token: 0x040008AE RID: 2222
    public static AM_Adv Adv;
 
    // Token: 0x040008AF RID: 2223
    public static AM_Region Region;
 
    // Token: 0x040008B0 RID: 2224
    public static AM_ADV_Target AdvTarget;
 
    // Token: 0x040008B1 RID: 2225
    public static AM_EloMap EloMap;
 
    // Token: 0x040008B2 RID: 2226
    public static AM_Inspect Inspect;
 
    // Token: 0x040008B3 RID: 2227
    public static AM_NoMap NoMap;
 
    // Token: 0x040008B4 RID: 2228
    public static AM_MiniGame MiniGame;
 
    // Token: 0x040008B5 RID: 2229
    public static AM_NewZone NewZone;
 
    // Token: 0x040008B6 RID: 2230
    public static AM_Bird Bird;
 
    // Token: 0x040008B7 RID: 2231
    public static AM_Mine Mine;
 
    // Token: 0x040008B8 RID: 2232
    public static AM_Dig Dig;
 
    // Token: 0x040008B9 RID: 2233
    public static AM_Harvest Harvest;
 
    // Token: 0x040008BA RID: 2234
    public static AM_Cut Cut;
 
    // Token: 0x040008BB RID: 2235
    public static AM_StateEditor StateEditor;
 
    // Token: 0x040008BC RID: 2236
    public static AM_Picker Picker;
 
    // Token: 0x040008BD RID: 2237
    public static AM_Copy Copy;
 
    // Token: 0x040008BE RID: 2238
    public static AM_Blueprint Blueprint;
 
    // Token: 0x040008BF RID: 2239
    public static AM_Build Build;
 
    // Token: 0x040008C0 RID: 2240
    public static AM_CreateArea CreateArea;
 
    // Token: 0x040008C1 RID: 2241
    public static AM_EditArea EditArea;
 
    // Token: 0x040008C2 RID: 2242
    public static AM_ExpandArea ExpandArea;
 
    // Token: 0x040008C3 RID: 2243
    public static AM_Deconstruct Deconstruct;
 
    // Token: 0x040008C4 RID: 2244
    public static AM_Select Select;
 
    // Token: 0x040008C5 RID: 2245
    public static AM_RemoveDesignation RemoveDesignation;
 
    // Token: 0x040008C6 RID: 2246
    public static AM_ViewMap ViewMap;
 
    // Token: 0x040008C7 RID: 2247
    public static AM_Terrain Terrain;
 
    // Token: 0x040008C8 RID: 2248
    public static AM_Populate Populate;
 
    // Token: 0x040008C9 RID: 2249
    public static AM_EditMarker EditMarker;
 
    // Token: 0x040008CA RID: 2250
    public static AM_Visibility Visibility;
 
    // Token: 0x040008CB RID: 2251
    public static AM_Cinema Cinema;
 
    // Token: 0x040008CC RID: 2252
    public static AM_Paint Paint;
 
    // Token: 0x040008CD RID: 2253
    public static AM_FlagCell FlagCell;
 
    // Token: 0x040008CE RID: 2254
    public static ActionMode LastBuildMode;
 
    // Token: 0x040008CF RID: 2255
    public static SourceMaterial.Row lastEditorMat;
 
    // Token: 0x040008D0 RID: 2256
    public static bool ignoreSound;
 
    // Token: 0x040008D1 RID: 2257
    private static float smoothX = 0f;
 
    // Token: 0x040008D2 RID: 2258
    private static float smoothY = 0f;
 
    // Token: 0x040008D3 RID: 2259
    private static float textTimer = 0f;
 
    // Token: 0x040008D4 RID: 2260
    protected static Vector3 mpos;
 
    // Token: 0x040008D5 RID: 2261
    public static float[] GameSpeeds = new float[]
    {
        0f,
        1f,
        2f,
        5f
    };
 
    // Token: 0x040008D6 RID: 2262
    public static List<TCSimpleText> simpleTexts = new List<TCSimpleText>();
 
    // Token: 0x040008D7 RID: 2263
    public Layer layer;
 
    // Token: 0x040008D8 RID: 2264
    public int brushRadius = 4;
 
    // Token: 0x040008D9 RID: 2265
    private static float focusTimer;
 
    // Token: 0x040008DA RID: 2266
    private static float hotElementTimer;
}