UI.cs

using System;
using System.Collections.Generic;
using System.Reflection;
using DG.Tweening;
using DG.Tweening.Core;
using DG.Tweening.Plugins.Options;
using UnityEngine;
using UnityEngine.UI;
 
// Token: 0x020005CF RID: 1487
public class UI : ELayer
{
    // Token: 0x17000BD0 RID: 3024
    // (get) Token: 0x060028CE RID: 10446 RVA: 0x000E6BD9 File Offset: 0x000E4DD9
    public SkinManager skins
    {
        get
        {
            return ELayer.core.skins;
        }
    }
 
    // Token: 0x17000BD1 RID: 3025
    // (get) Token: 0x060028CF RID: 10447 RVA: 0x000E6BE5 File Offset: 0x000E4DE5
    public bool IsActive
    {
        get
        {
            return this.layers.Count > 0 || this.contextMenu.isActive;
        }
    }
 
    // Token: 0x17000BD2 RID: 3026
    // (get) Token: 0x060028D0 RID: 10448 RVA: 0x000E6C02 File Offset: 0x000E4E02
    public bool AllowInventoryInteractions
    {
        get
        {
            return !this.contextMenu.isActive && (this.layers.Count == 0 || base.TopLayer.option.allowInventoryInteraction);
        }
    }
 
    // Token: 0x17000BD3 RID: 3027
    // (get) Token: 0x060028D1 RID: 10449 RVA: 0x000E6C32 File Offset: 0x000E4E32
    public bool BlockActions
    {
        get
        {
            return (this.wasActive && (!base.TopLayer || !base.TopLayer.option.passive)) || EInput.isInputFieldActive;
        }
    }
 
    // Token: 0x17000BD4 RID: 3028
    // (get) Token: 0x060028D2 RID: 10450 RVA: 0x000E6C62 File Offset: 0x000E4E62
    public bool BlockMouseOverUpdate
    {
        get
        {
            return this.wasActive;
        }
    }
 
    // Token: 0x17000BD5 RID: 3029
    // (get) Token: 0x060028D3 RID: 10451 RVA: 0x000E6C6A File Offset: 0x000E4E6A
    public bool BlockInput
    {
        get
        {
            return this.IsDragging || base.IsBlockWidgetClick() || LayerAbility.hotElement != null || EInput.isInputFieldActive || this.contextMenu.isActive;
        }
    }
 
    // Token: 0x17000BD6 RID: 3030
    // (get) Token: 0x060028D4 RID: 10452 RVA: 0x000E6C9D File Offset: 0x000E4E9D
    public bool IsPauseGame
    {
        get
        {
            return this.layers.Count > 0 && base.TopLayer.option.pauseGame;
        }
    }
 
    // Token: 0x17000BD7 RID: 3031
    // (get) Token: 0x060028D5 RID: 10453 RVA: 0x000E6CBF File Offset: 0x000E4EBF
    public bool IsInventoryOpen
    {
        get
        {
            return this.layerFloat.GetLayer<LayerInventory>(false);
        }
    }
 
    // Token: 0x17000BD8 RID: 3032
    // (get) Token: 0x060028D6 RID: 10454 RVA: 0x000E6CD2 File Offset: 0x000E4ED2
    public bool IsAbilityOpen
    {
        get
        {
            return this.layerFloat.GetLayer<LayerAbility>(false);
        }
    }
 
    // Token: 0x17000BD9 RID: 3033
    // (get) Token: 0x060028D7 RID: 10455 RVA: 0x000E6CE5 File Offset: 0x000E4EE5
    public override bool blockWidgetClick
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x17000BDA RID: 3034
    // (get) Token: 0x060028D8 RID: 10456 RVA: 0x000E6CE8 File Offset: 0x000E4EE8
    public override RectTransform rectLayers
    {
        get
        {
            return this._rectLayers;
        }
    }
 
    // Token: 0x17000BDB RID: 3035
    // (get) Token: 0x060028D9 RID: 10457 RVA: 0x000E6CF0 File Offset: 0x000E4EF0
    public bool IsDragging
    {
        get
        {
            return this.currentDrag != null;
        }
    }
 
    // Token: 0x060028DA RID: 10458 RVA: 0x000E6CFB File Offset: 0x000E4EFB
    protected override void Awake()
    {
        base.Awake();
        base.InvokeRepeating("CheckWindowOrder", 1f, 0.5f);
    }
 
    // Token: 0x060028DB RID: 10459 RVA: 0x000E6D18 File Offset: 0x000E4F18
    public void OnCoreStart()
    {
        this.mouseInfo.SetActive(false);
    }
 
    // Token: 0x060028DC RID: 10460 RVA: 0x000E6D28 File Offset: 0x000E4F28
    public void OnActivateZone()
    {
        this.widgets.OnActivateZone();
        ELayer.player.queues.SetOwner(ELayer.pc);
        if (this.hud.hangCorner && this.hud.hangCorner.isActiveAndEnabled)
        {
            this.hud.hangCorner.Refresh();
        }
    }
 
    // Token: 0x060028DD RID: 10461 RVA: 0x000E6D88 File Offset: 0x000E4F88
    public void ShowFloats()
    {
        this.layerFloat.SetActive(true);
    }
 
    // Token: 0x060028DE RID: 10462 RVA: 0x000E6D96 File Offset: 0x000E4F96
    public void HideFloats()
    {
        this.layerFloat.SetActive(false);
    }
 
    // Token: 0x060028DF RID: 10463 RVA: 0x000E6DA4 File Offset: 0x000E4FA4
    public void OnKillGame()
    {
        this.widgets.OnKillGame();
        this.ShowBalloon(true);
        this.layerFloat.RemoveLayers(true);
        this.currentDrag = null;
    }
 
    // Token: 0x060028E0 RID: 10464 RVA: 0x000E6DCB File Offset: 0x000E4FCB
    public void OnClickAction(string _mode)
    {
        base.RemoveLayers(false);
        ((ActionMode)typeof(ActionMode).GetField(_mode, BindingFlags.Static | BindingFlags.Public).GetValue(null)).Activate(true, false);
    }
 
    // Token: 0x060028E1 RID: 10465 RVA: 0x000E6DF8 File Offset: 0x000E4FF8
    public void RefreshActiveState()
    {
        this.isPointerOverUI = false;
        foreach (GameObject gameObject in InputModuleEX.GetPointerEventData(-1).hovered)
        {
            if (gameObject && gameObject.layer == 5)
            {
                this.isPointerOverUI = true;
                break;
            }
        }
        this.wasActive = this.IsActive;
        if (this.wasActive)
        {
            CursorSystem.SetCursor(null, 0);
        }
    }
 
    // Token: 0x060028E2 RID: 10466 RVA: 0x000E6E88 File Offset: 0x000E5088
    public override void OnChangeLayer()
    {
        this.RefreshActiveState();
        CursorSystem.SetCursor(null, 0);
        this.hud.HideMouseInfo();
        if (ELayer.core.IsGameStarted)
        {
            ELayer.scene.actionMode.OnUpdateCursor();
        }
        CursorSystem.Instance.Draw();
        Layer topLayer = base.TopLayer;
        if (topLayer != null && topLayer.option.dontShowHint)
        {
            return;
        }
        if (this.layers.Count == 0)
        {
            this.hud.hint.Refresh();
            return;
        }
        if (base.TopLayer.option.hideFloatUI)
        {
            this.HideFloats();
        }
        if (base.TopLayer.option.hideWidgets)
        {
            this.widgets.Hide();
        }
        ELayer elayer = base.TopLayer as ELayer;
        if (elayer == null)
        {
            return;
        }
        elayer.TryShowHint(null);
    }
 
    // Token: 0x060028E3 RID: 10467 RVA: 0x000E6F58 File Offset: 0x000E5158
    public void FlashCover(float durationOut = 1f, float duration = 1f, float durationIn = 1f, Action onFadeOut = null, Action onComplete = null, Color color = default(Color))
    {
        this.ShowCover(durationOut, 1f, null, color);
        TweenUtil.Tween(durationOut + duration, null, delegate()
        {
            if (onFadeOut != null)
            {
                onFadeOut();
            }
            this.HideCover(durationIn, onComplete);
        });
    }
 
    // Token: 0x060028E4 RID: 10468 RVA: 0x000E6FB0 File Offset: 0x000E51B0
    public void ShowCover(float duration = 0f, float dest = 1f, Action onComplete = null, Color color = default(Color))
    {
        TweenUtil.KillTween(ref this.tweenCover, false);
        float a = this.hud.imageCover.color.a;
        this.hud.imageCover.color = ((color == default(Color)) ? Color.black : color).SetAlpha(a);
        this.hud.imageCover.SetActive(true);
        this.hidingCover = false;
        this.tweenCover = this.hud.imageCover.DOFade(dest, duration).OnComplete(delegate
        {
            Action onComplete2 = onComplete;
            if (onComplete2 == null)
            {
                return;
            }
            onComplete2();
        });
    }
 
    // Token: 0x060028E5 RID: 10469 RVA: 0x000E7060 File Offset: 0x000E5260
    public void HideCover(float duration = 0f, Action onComplete = null)
    {
        if (this.hidingCover)
        {
            return;
        }
        this.hidingCover = true;
        TweenUtil.KillTween(ref this.tweenCover, false);
        this.tweenCover = this.hud.imageCover.DOFade(0f, duration).OnComplete(delegate
        {
            this.hud.imageCover.SetActive(false);
            Action onComplete2 = onComplete;
            if (onComplete2 != null)
            {
                onComplete2();
            }
            this.hidingCover = false;
        });
    }
 
    // Token: 0x060028E6 RID: 10470 RVA: 0x000E70CB File Offset: 0x000E52CB
    public bool IsCovered()
    {
        return !this.hidingCover;
    }
 
    // Token: 0x060028E7 RID: 10471 RVA: 0x000E70D6 File Offset: 0x000E52D6
    public void ShowBalloon(bool enable)
    {
        ELayer.ui.rectDynamic.SetActive(enable);
        WidgetSystemIndicator.Refresh();
    }
 
    // Token: 0x060028E8 RID: 10472 RVA: 0x000E70F0 File Offset: 0x000E52F0
    public void Show(float duration = 1f)
    {
        ELayer.scene.elomapActor.selector.srHighlight.SetActive(true);
        this.cg.DOKill(false);
        if (duration == 0f)
        {
            this.cg.alpha = 1f;
            return;
        }
        this.cg.DOFade(1f, duration);
    }
 
    // Token: 0x060028E9 RID: 10473 RVA: 0x000E7150 File Offset: 0x000E5350
    public void Hide(float duration = 1f)
    {
        ELayer.scene.elomapActor.selector.srHighlight.SetActive(false);
        if (duration == 0f)
        {
            this.cg.alpha = 0f;
            return;
        }
        this.cg.DOFade(0f, duration);
    }
 
    // Token: 0x060028EA RID: 10474 RVA: 0x000E71A4 File Offset: 0x000E53A4
    public void OnUpdate()
    {
        if (this.hud.imageDrag.gameObject.activeSelf)
        {
            this.hud.imageDrag.transform.position = EInput.mpos + (ELayer.game.UseGrid ? this.hud.imageDragFix2 : this.hud.imageDragFix2);
            Util.ClampToScreen(this.hud.imageDrag.Rect(), this.hud.marginImageDrag);
        }
        if (ELayer.config.ui.blur && this.layers.Count > 0 && base.IsUseBlur())
        {
            UI.blurSize += Time.unscaledDeltaTime * this.blurSpeed;
            if (UI.blurSize > ELayer.config.ui.blurSize)
            {
                UI.blurSize = ELayer.config.ui.blurSize;
            }
            if (!this.blur.activeSelf)
            {
                this.blur.SetActive(true);
            }
            int siblingIndex = this.blur.transform.GetSiblingIndex();
            int num = 0;
            for (int i = this.layers.Count - 1; i >= 0; i--)
            {
                if (this.layers[i].IsUseBlur())
                {
                    num = this.layers[i].transform.GetSiblingIndex() - 1;
                    break;
                }
            }
            if (siblingIndex != num)
            {
                this.blur.transform.SetSiblingIndex(num);
            }
        }
        else
        {
            UI.blurSize -= Time.unscaledDeltaTime * this.blurSpeed;
            if (UI.blurSize < 0f)
            {
                UI.blurSize = 0f;
            }
            if (this.blur.activeSelf && UI.blurSize == 0f)
            {
                this.blur.SetActive(false);
            }
        }
        this.matBlur.SetFloat("_Size", UI.blurSize);
        if (!EInput.isShiftDown)
        {
            LayerInventory.highlightInv = null;
        }
        this.ShowMouseHint();
    }
 
    // Token: 0x060028EB RID: 10475 RVA: 0x000E739C File Offset: 0x000E559C
    public void ShowMouseHint()
    {
        if (this.durationHideMouseHint > 0f)
        {
            this.durationHideMouseHint -= Core.delta;
            this.hud.textMouseHintLeft.SetActive(false);
            this.hud.textMouseHintRight.SetActive(false);
            return;
        }
        IMouseHint mouseHint = UIButton.currentHighlight as IMouseHint;
        bool flag = mouseHint != null && !this.IsDragging && this.isPointerOverUI && UIButton.currentHighlight && InputModuleEX.IsPointerOver(UIButton.currentHighlight) && LayerAbility.hotElement == null;
        bool flag2 = flag;
        if (flag2)
        {
            if (mouseHint.ShowMouseHintLeft())
            {
                this.hud.textMouseHintLeft.text = mouseHint.GetTextMouseHintLeft();
                if (this.hud.textMouseHintLeft.text == "")
                {
                    flag2 = false;
                }
            }
            else
            {
                flag2 = false;
            }
        }
        if (flag)
        {
            if (mouseHint.ShowMouseHintRight())
            {
                this.hud.textMouseHintRight.text = mouseHint.GetTextMouseHintRight();
                if (this.hud.textMouseHintRight.text == "")
                {
                    flag = false;
                }
            }
            else
            {
                flag = false;
            }
        }
        this.hud.textMouseHintLeft.SetActive(flag2);
        this.hud.textMouseHintRight.SetActive(flag);
        if (flag || flag2)
        {
            this.hud.textMouseHintLeft.transform.position = UIButton.currentHighlight.transform.position + this.hud.textMouseHintFixLeft;
            this.hud.textMouseHintRight.transform.position = UIButton.currentHighlight.transform.position + this.hud.textMouseHintFix;
            Util.ClampToScreen(this.hud.textMouseHintRight.Rect(), 10);
        }
    }
 
    // Token: 0x060028EC RID: 10476 RVA: 0x000E755E File Offset: 0x000E575E
    public void HideMouseHint(float duration = 0.2f)
    {
        this.durationHideMouseHint = duration;
        this.hud.textMouseHintLeft.SetActive(false);
        this.hud.textMouseHintRight.SetActive(false);
    }
 
    // Token: 0x060028ED RID: 10477 RVA: 0x000E758C File Offset: 0x000E578C
    public void CheckWindowOrder()
    {
        if (this.layers.Count > 0)
        {
            return;
        }
        foreach (GameObject gameObject in InputModuleEX.GetPointerEventData(-1).hovered)
        {
            if (gameObject)
            {
                Widget component = gameObject.GetComponent<Widget>();
                if (component && !component.AlwaysBottom && this.widgets.transform.GetChild(this.widgets.transform.childCount - 1) != gameObject.transform)
                {
                    gameObject.transform.SetAsLastSibling();
                    break;
                }
            }
        }
        if (WidgetFeed.Instance)
        {
            WidgetFeed.Instance.transform.SetAsLastSibling();
        }
    }
 
    // Token: 0x060028EE RID: 10478 RVA: 0x000E7664 File Offset: 0x000E5864
    public void ShowSceneSelector()
    {
        this.canvasScaler.scaleFactor = 1f;
        Shader.SetGlobalFloat("_UIBrightness", 1f);
        Shader.SetGlobalFloat("_UIContrast", 1f);
        this.layoutLang.SetActive(true);
        List<CoreDebug.StartScene> list = Util.EnumToList<CoreDebug.StartScene>();
        Button t = this.layoutLang.CreateMold(null);
        foreach (CoreDebug.StartScene l in list)
        {
            Button button = Util.Instantiate<Button>(t, this.layoutLang);
            CoreDebug.StartScene _l = l;
            button.GetComponentInChildren<Text>().text = l.ToString();
            button.onClick.AddListener(delegate()
            {
                this.layoutLang.SetActive(false);
                ELayer.debug.startScene = _l;
                ELayer.core.Init();
            });
        }
        this.layoutLang.RebuildLayout(false);
    }
 
    // Token: 0x060028EF RID: 10479 RVA: 0x000E7750 File Offset: 0x000E5950
    public void ShowLang()
    {
        this.canvasScaler.scaleFactor = 1f;
        Shader.SetGlobalFloat("_UIBrightness", 1f);
        Shader.SetGlobalFloat("_UIContrast", 1f);
        this.layoutLang.SetActive(true);
        Button t = this.layoutLang.CreateMold(null);
        foreach (LangSetting langSetting in MOD.langs.Values)
        {
            Button button = Util.Instantiate<Button>(t, this.layoutLang);
            LangSetting _l = langSetting;
            button.GetComponentInChildren<Text>().text = langSetting.name + " (" + langSetting.name_en + ")";
            button.onClick.AddListener(delegate()
            {
                this.layoutLang.SetActive(false);
                ELayer.core.langCode = _l.id;
                if (ELayer.debug.showSceneSelector || (Input.GetKey(KeyCode.LeftShift) && ELayer.debug.enable))
                {
                    this.ShowSceneSelector();
                    return;
                }
                ELayer.core.Init();
            });
        }
        this.layoutLang.RebuildLayout(false);
    }
 
    // Token: 0x060028F0 RID: 10480 RVA: 0x000E7850 File Offset: 0x000E5A50
    public void SetLight(bool enable)
    {
    }
 
    // Token: 0x060028F1 RID: 10481 RVA: 0x000E7852 File Offset: 0x000E5A52
    public UIContextMenu CreateContextMenu(string cid = "ContextMenu")
    {
        return this.contextMenu.Create(cid, true);
    }
 
    // Token: 0x060028F2 RID: 10482 RVA: 0x000E7861 File Offset: 0x000E5A61
    public UIContextMenu CreateContextMenuInteraction()
    {
        return this.contextMenu.Create("ContextInteraction", true);
    }
 
    // Token: 0x060028F3 RID: 10483 RVA: 0x000E7874 File Offset: 0x000E5A74
    public void Say(string text, Sprite sprite = null)
    {
        this.popSystem.PopText(text.lang(), sprite, "PopAchievement", default(Color), default(Vector3), 0f);
        Debug.Log(text);
    }
 
    // Token: 0x060028F4 RID: 10484 RVA: 0x000E78B8 File Offset: 0x000E5AB8
    public void FreezeScreen(float duration)
    {
        if (this.texFreeze)
        {
            UnityEngine.Object.Destroy(this.texFreeze);
        }
        this.texFreeze = ScreenCapture.CaptureScreenshotAsTexture();
        this.imageFreeze.SetActive(true);
        this.imageFreeze.texture = this.texFreeze;
        if (duration != 0f)
        {
            TweenUtil.Tween(duration, null, delegate()
            {
                this.UnfreezeScreen();
            });
        }
    }
 
    // Token: 0x060028F5 RID: 10485 RVA: 0x000E7921 File Offset: 0x000E5B21
    public void UnfreezeScreen()
    {
        if (this.texFreeze)
        {
            UnityEngine.Object.DestroyImmediate(this.texFreeze);
        }
        this.imageFreeze.SetActive(false);
    }
 
    // Token: 0x060028F6 RID: 10486 RVA: 0x000E7948 File Offset: 0x000E5B48
    public void ToggleAbility(bool delay = false)
    {
        if (!ELayer.game.altAbility)
        {
            if (!ELayer.ui.RemoveLayer<LayerAbility>())
            {
                LayerAbility layerAbility = ELayer.ui.AddLayer<LayerAbility>();
                if (delay)
                {
                    layerAbility.windows[0].SetRect(ELayer.core.refs.rects.center, false);
                    layerAbility.Delay(0.05f);
                }
            }
            return;
        }
        if (ELayer.ui.layerFloat.GetLayer<LayerAbility>(false))
        {
            ELayer.ui.layerFloat.RemoveLayer<LayerAbility>();
            ELayer.player.pref.layerAbility = false;
            SE.Play("pop_ability_deactivate");
            return;
        }
        ELayer.ui.layerFloat.AddLayer<LayerAbility>("LayerAbility/LayerAbilityFloat");
        ELayer.player.pref.layerAbility = true;
    }
 
    // Token: 0x060028F7 RID: 10487 RVA: 0x000E7A14 File Offset: 0x000E5C14
    public void ToggleInventory(bool delay = false)
    {
        if (!this.IsInventoryOpen)
        {
            this.OpenFloatInv(false);
            return;
        }
        if (InvOwner.HasTrader)
        {
            SE.Beep();
            return;
        }
        List<Card> list = new List<Card>();
        foreach (LayerInventory layerInventory in LayerInventory.listInv)
        {
            if (layerInventory.IsPlayerContainer(false))
            {
                list.Add(layerInventory.invs[0].owner.Container);
            }
        }
        LayerInventory.listInv.ForeachReverse(delegate(LayerInventory l)
        {
            if (l.IsPlayerContainer(true))
            {
                ELayer.ui.layerFloat.RemoveLayer(l);
            }
        });
        ELayer.ui.widgets.DeactivateWidget("Equip");
        foreach (Card card in list)
        {
            card.c_windowSaveData.open = true;
        }
        SE.Play("pop_inventory_deactivate");
    }
 
    // Token: 0x060028F8 RID: 10488 RVA: 0x000E7B34 File Offset: 0x000E5D34
    public void OpenFloatInv(bool ignoreSound = false)
    {
        if (ignoreSound)
        {
            SoundManager.ignoreSounds = true;
        }
        ELayer.ui.layerFloat.AddLayer(LayerInventory.CreatePCBackpack(false));
        SoundManager.ignoreSounds = true;
        ELayer.ui.widgets.Activate("Equip");
        foreach (Thing thing in ELayer.pc.things.List((Thing a) => a.trait.IsContainer, false))
        {
            Window.SaveData c_windowSaveData = thing.c_windowSaveData;
            if (!(thing.trait is TraitToolBelt) && c_windowSaveData != null && c_windowSaveData.open)
            {
                LayerInventory.CreateContainer(thing);
            }
        }
        SoundManager.ignoreSounds = false;
    }
 
    // Token: 0x060028F9 RID: 10489 RVA: 0x000E7C10 File Offset: 0x000E5E10
    public void ToggleFeedback()
    {
        if (ELayer.core.IsGameStarted && !ELayer.ui.GetLayer<LayerFeedback>(false) && ELayer.pc.HasCondition<ConHallucination>())
        {
            SE.Play("wow");
            Msg.Say("bug_hal");
            return;
        }
        ELayer.ui.ToggleLayer<LayerFeedback>(null);
        SE.Tab();
    }
 
    // Token: 0x060028FA RID: 10490 RVA: 0x000E7C70 File Offset: 0x000E5E70
    public void StartDrag(DragItem item)
    {
        this.dragDuration = 0f;
        if (this.currentDrag != null)
        {
            this.EndDrag(true);
            if (this.currentDrag != null)
            {
                return;
            }
        }
        this.currentDrag = item;
        item.OnStartDrag();
        this.OnDrag();
        ELayer.core.actionsNextFrame.Add(delegate
        {
            TooltipManager.Instance.HideTooltips(true);
        });
    }
 
    // Token: 0x060028FB RID: 10491 RVA: 0x000E7CE1 File Offset: 0x000E5EE1
    public void OnDrag()
    {
        this.dragDuration += Core.delta;
        this.currentDrag.OnDrag(false, false);
    }
 
    // Token: 0x060028FC RID: 10492 RVA: 0x000E7D04 File Offset: 0x000E5F04
    public void EndDrag(bool canceled = false)
    {
        if (this.currentDrag == null)
        {
            return;
        }
        bool flag = this.currentDrag.OnDrag(true, canceled);
        EInput.Consume(false, 1);
        EInput.dragHack = 0f;
        if (flag)
        {
            ELayer.ui.RemoveLayer<LayerRegisterHotbar>();
            this.currentDrag.OnEndDrag();
            this.currentDrag = null;
            if (this.nextDrag != null)
            {
                this.StartDrag(this.nextDrag);
                this.nextDrag = null;
            }
            else
            {
                this.hud.SetDragImage(null, null, null);
            }
            UIButton.TryShowTip(null, true, true);
            return;
        }
        SE.BeepSmall();
    }
 
    // Token: 0x040016F1 RID: 5873
    private static float blurSize;
 
    // Token: 0x040016F2 RID: 5874
    public Canvas canvas;
 
    // Token: 0x040016F3 RID: 5875
    public HUD hud;
 
    // Token: 0x040016F4 RID: 5876
    public ExtraHint extraHint;
 
    // Token: 0x040016F5 RID: 5877
    public InputModuleEX inputModule;
 
    // Token: 0x040016F6 RID: 5878
    public UIContextMenuManager contextMenu;
 
    // Token: 0x040016F7 RID: 5879
    public WidgetManager widgets;
 
    // Token: 0x040016F8 RID: 5880
    public UIMouseInfo mouseInfo;
 
    // Token: 0x040016F9 RID: 5881
    public RectTransform rectDynamic;
 
    // Token: 0x040016FA RID: 5882
    public RectTransform rectDynamicEssential;
 
    // Token: 0x040016FB RID: 5883
    public RectTransform _rectLayers;
 
    // Token: 0x040016FC RID: 5884
    public ReflexConsole console;
 
    // Token: 0x040016FD RID: 5885
    public GameObject blur;
 
    // Token: 0x040016FE RID: 5886
    public Material matBlur;
 
    // Token: 0x040016FF RID: 5887
    public LayoutGroup layoutLang;
 
    // Token: 0x04001700 RID: 5888
    public CanvasScaler canvasScaler;
 
    // Token: 0x04001701 RID: 5889
    public Image light;
 
    // Token: 0x04001702 RID: 5890
    public CanvasGroup cg;
 
    // Token: 0x04001703 RID: 5891
    public int minWidth;
 
    // Token: 0x04001704 RID: 5892
    public Layer layerFloat;
 
    // Token: 0x04001705 RID: 5893
    public UIAutoTurn autoTurn;
 
    // Token: 0x04001706 RID: 5894
    public PopManager popGame;
 
    // Token: 0x04001707 RID: 5895
    public PopManager popSystem;
 
    // Token: 0x04001708 RID: 5896
    public float blurSpeed;
 
    // Token: 0x04001709 RID: 5897
    public Texture2D texFreeze;
 
    // Token: 0x0400170A RID: 5898
    public RawImage imageFreeze;
 
    // Token: 0x0400170B RID: 5899
    public DragItem currentDrag;
 
    // Token: 0x0400170C RID: 5900
    public DragItem nextDrag;
 
    // Token: 0x0400170D RID: 5901
    private bool hidingCover;
 
    // Token: 0x0400170E RID: 5902
    [NonSerialized]
    public float lightContrast;
 
    // Token: 0x0400170F RID: 5903
    [NonSerialized]
    public float dragDuration;
 
    // Token: 0x04001710 RID: 5904
    private Tween tweenCover;
 
    // Token: 0x04001711 RID: 5905
    [NonSerialized]
    public bool wasActive;
 
    // Token: 0x04001712 RID: 5906
    [NonSerialized]
    public bool isPointerOverUI;
 
    // Token: 0x04001713 RID: 5907
    private float durationHideMouseHint;
}
public class UI : ELayer {…};