Core.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using AeLa.EasyFeedback.FormFields;
using DG.Tweening;
using DG.Tweening.Core;
using DG.Tweening.Plugins.Options;
using ReflexCLI;
using Steamworks;
using UnityEngine;
 
// Token: 0x02000002 RID: 2
public class Core : BaseCore
{
    // Token: 0x17000001 RID: 1
    // (get) Token: 0x06000001 RID: 1 RVA: 0x00002050 File Offset: 0x00000250
    public bool IsGameStarted
    {
        get
        {
            return this.game != null && this.game.activeZone != null;
        }
    }
 
    // Token: 0x17000002 RID: 2
    // (get) Token: 0x06000002 RID: 2 RVA: 0x0000206A File Offset: 0x0000026A
    public override float uiScale
    {
        get
        {
            return this.ui.canvasScaler.scaleFactor;
        }
    }
 
    // Token: 0x06000003 RID: 3 RVA: 0x0000207C File Offset: 0x0000027C
    protected override void Awake()
    {
        base.Awake();
        Application.targetFrameRate = 60;
        IO.CreateDirectory(CorePath.Temp);
        Core.SetCurrent(null);
        Lang.langCode = "";
        if (Application.isEditor && this.debug.langCode != Lang.LangCode.None)
        {
            this.forceLangCode = this.debug.langCode.ToString();
        }
        foreach (string text in Application.isEditor ? this.debug.command.Split(',', StringSplitOptions.None) : Environment.GetCommandLineArgs())
        {
            text = text.Replace("-", "").ToUpper();
            Debug.Log("Commandline args:" + text);
            if (text.StartsWith("LANG_"))
            {
                this.forceLangCode = text.Replace("LANG_", "");
            }
            else if (text == "DEV")
            {
                this.releaseMode = ReleaseMode.Debug;
            }
        }
        NewsList.dict = null;
        InvOwner.Trader = (InvOwner.Main = null);
        SpriteSheet.dict.Clear();
        SpriteSheet.loadedPath.Clear();
        SpriteReplacerAnimation.dict.Clear();
        LayerDrama.haltPlaylist = false;
        LayerDrama.keepBGM = false;
        BaseModManager.isInitialized = false;
        Net.isUploading = false;
        MapPiece.initialized = false;
        ActPlan.warning = false;
        Game.isPaused = false;
        if (Application.isEditor && BaseCore.resetRuntime)
        {
            this.ResetRuntime();
        }
        Window.dictData.Clear();
        LayerInventory.listInv.Clear();
        this.debug = Resources.Load<CoreDebug>("_Debug " + this.releaseMode.ToString());
        this.debug.enable = (this.releaseMode > ReleaseMode.Public);
        if (this.useUImat)
        {
            Canvas.GetDefaultCanvasMaterial().CopyPropertiesFromMaterial(this.matUI);
            Canvas.GetDefaultCanvasMaterial().shader = this.matUI.shader;
        }
        if (!this.ui)
        {
            this.ui = Util.Instantiate<UI>("UI/UI", null);
        }
        if (!this.scene)
        {
            this.scene = Util.Instantiate<Scene>("Scene/Scene", null);
        }
        this.scene.screenNoMap.Activate();
        this.ui.ShowCover(0f, 1f, null, default(Color));
        this.canvas = this.ui.canvas;
        this.ui.OnCoreStart();
        BaseCore.BlockInput = (() => this.ui.IsDragging);
        CommandRegistry.assemblies.Add(typeof(Core).Assembly);
        SoundData.EditorPlaySpatial = delegate(SoundData a)
        {
            this.game.player.chara.PlaySound(a.name, 1f, true);
        };
        SoundManager.funcCanPlayBGM = (() => !LayerDrama.haltPlaylist && !LayerDrama.keepBGM);
        FileDragAndDrop.onDrop = new Action<List<string>>(this.textures.OnDropFile);
        MOD.langs.Clear();
        MOD.OnAddPcc = new Action<DirectoryInfo>(this.pccs.Add);
        MOD.listTalk = new TalkDataList();
        MOD.tones = new ToneDataList();
        MOD.listMaps.Clear();
        MOD.listPartialMaps.Clear();
        Portrait.modPortraitBGFs = new ModItemList<Sprite>(0);
        Portrait.modPortraitBGs = new ModItemList<Sprite>(0);
        Portrait.modPortraits = new ModItemList<Sprite>(0);
        Portrait.modOverlays = new ModItemList<Sprite>(0);
        Portrait.modFull = new ModItemList<Sprite>(0);
        Portrait.dictList = new Dictionary<string, List<ModItem<Sprite>>>();
        TileType.Init();
        this.screen.tileMap.rendererObjDummy.Init();
        Debug.Log("Core Awake");
        Debug.Log(this.steam.steamworks.settings.applicationId);
    }
 
    // Token: 0x06000004 RID: 4 RVA: 0x00002428 File Offset: 0x00000628
    private void Start()
    {
        TextField.onAddEmail = delegate()
        {
            string text = "";
            foreach (BaseModPackage baseModPackage in this.mods.packages)
            {
                if (!baseModPackage.builtin)
                {
                    text = string.Concat(new string[]
                    {
                        text,
                        baseModPackage.id,
                        "/",
                        baseModPackage.activated.ToString(),
                        Environment.NewLine
                    });
                }
            }
            if (!text.IsEmpty())
            {
                return Environment.NewLine + Environment.NewLine + text;
            }
            return "";
        };
        this.config = CoreConfig.TryLoadConfig();
        string str = "Loading Config:";
        string path = CoreConfig.path;
        string str2 = " - ";
        CoreConfig coreConfig = this.config;
        Debug.Log(str + path + str2 + ((coreConfig != null) ? coreConfig.ToString() : null));
        try
        {
            this.steam.Init();
        }
        catch
        {
        }
        this.StartCase();
    }
 
    // Token: 0x06000005 RID: 5 RVA: 0x000024A4 File Offset: 0x000006A4
    public void StartCase()
    {
        Debug.Log("StartCase:" + ModManager.IsInitialized.ToString());
        if (!ModManager.IsInitialized)
        {
            this.mods.Init(CorePath.rootMod, "_Elona");
            base.StartCoroutine(this.mods.RefreshMods(delegate
            {
                MOD.actorSources.Initialize();
                this.StartCase();
            }, !BaseCore.IsOffline && !this.debug.skipModSync && (this.config == null || this.config.other.syncMods)));
            return;
        }
        Debug.Log("Plugins:" + ModManager.ListPluginObject.Count.ToString());
        foreach (object obj in ModManager.ListPluginObject)
        {
            Component component = obj as Component;
            if (component)
            {
                GameObject gameObject = component.gameObject;
                gameObject.SendMessage("OnStartCore");
                foreach (Component component2 in gameObject.GetComponentsInChildren<Component>())
                {
                    Debug.Log(component2.GetType().Assembly.GetName().Name);
                    ClassCache.assemblies.Add(component2.GetType().Assembly.GetName().Name);
                }
                break;
            }
            Debug.Log("no go");
        }
        this.sources.Init();
        if (!this.forceLangCode.IsEmpty())
        {
            this.langCode = this.forceLangCode;
        }
        else if (this.config == null)
        {
            Debug.Log("Config doesn't exist.");
            if (this.debug.enable || !SteamAPI.IsSteamRunning())
            {
                BookList.dict = null;
                this.ui.ShowLang();
                return;
            }
            string currentGameLanguage = SteamApps.GetCurrentGameLanguage();
            if (!(currentGameLanguage == "chinese"))
            {
                if (!(currentGameLanguage == "japanese"))
                {
                    BookList.dict = null;
                    this.ui.ShowLang();
                    return;
                }
                this.langCode = "JP";
            }
            else
            {
                this.langCode = "CN";
            }
        }
        if (this.debug.showSceneSelector || (Input.GetKey(KeyCode.LeftShift) && this.debug.enable))
        {
            this.ui.ShowSceneSelector();
            return;
        }
        this.Init();
    }
 
    // Token: 0x06000006 RID: 6 RVA: 0x00002710 File Offset: 0x00000910
    public void Update()
    {
        SoundManager.requestCount = 0;
        InputModuleEX.UpdateEventData();
        EInput.uiMousePosition = Input.mousePosition / this.ui.canvasScaler.scaleFactor;
        if (!this.initialized)
        {
            return;
        }
        this.ui.OnUpdate();
        this.debug.UpdateAlways();
        PoolManager.ignorePool = this.debug.ignorePool;
        if (this.screen.tileMap && !this.screen.tileMap.passBlock.mat.mainTexture)
        {
            this.textures.RefreshTextures();
        }
        if (this.useUImat)
        {
            Canvas.GetDefaultCanvasMaterial().CopyPropertiesFromMaterial(this.matUI);
        }
        Core.avgDelta += (Time.smoothDeltaTime - Core.delta) * 0.1f;
        Core.delta = Time.smoothDeltaTime;
        EInput.delta = (ButtonState.delta = Core.delta);
        bool? flag = this.lastFullScreen;
        bool fullScreen = Screen.fullScreen;
        if (!(flag.GetValueOrDefault() == fullScreen & flag != null))
        {
            int width = Display.main.systemWidth;
            int height = Display.main.systemHeight;
            if (this.config != null && this.config.graphic.fixedResolution)
            {
                width = this.config.graphic.w;
                height = this.config.graphic.h;
            }
            if (Screen.fullScreen)
            {
                Screen.SetResolution(width, height, true);
            }
            this.lastFullScreen = new bool?(Screen.fullScreen);
            this.nextResolutionUpdate = 0f;
        }
        if (this.nextResolutionUpdate <= 0f)
        {
            if (this.config != null && this.config.graphic.fixedResolution)
            {
                int w = this.config.graphic.w;
                int h = this.config.graphic.h;
                if (Screen.width != w || Screen.height != h)
                {
                    Screen.SetResolution(w, h, Screen.fullScreen);
                }
            }
            if (Screen.width != this.lastScreenWidth || Screen.height != this.lastScreenHeight)
            {
                this.OnChangeResolution();
            }
            this.nextResolutionUpdate = 0.1f;
        }
        else
        {
            this.nextResolutionUpdate -= Core.delta;
        }
        if (this.IsGameStarted)
        {
            this.game.OnUpdate();
            Core.gameDeltaNoPause = Core.delta * this.scene.actionMode.gameSpeed;
            Core.gameDelta = (FlockChild.delta = (this.ui.IsPauseGame ? 0f : Core.gameDeltaNoPause));
        }
        else
        {
            Core.gameDelta = 0f;
        }
        this.scene.OnUpdate();
        if (this.actionsNextFrame.Count > 0)
        {
            for (int i = this.actionsNextFrame.Count - 1; i >= 0; i--)
            {
                this.actionsNextFrame[i]();
                this.actionsNextFrame.RemoveAt(i);
            }
        }
    }
 
    // Token: 0x06000007 RID: 7 RVA: 0x00002A00 File Offset: 0x00000C00
    private void LateUpdate()
    {
        if (!this.initialized)
        {
            return;
        }
        if (this.actionsLateUpdate.Count > 0)
        {
            for (int i = this.actionsLateUpdate.Count - 1; i >= 0; i--)
            {
                this.actionsLateUpdate[i]();
                this.actionsLateUpdate.RemoveAt(i);
            }
        }
        this.scene.OnLateUpdate();
    }
 
    // Token: 0x06000008 RID: 8 RVA: 0x00002A64 File Offset: 0x00000C64
    public void OnApplicationFocus(bool focus)
    {
        if (focus && Core.Instance)
        {
            this.actionsNextFrame.Add(delegate
            {
                this.textures.RefreshTextures();
                this.actionsNextFrame.Add(delegate
                {
                    if (this.IsGameStarted)
                    {
                        if (Application.isEditor && WidgetMinimap.Instance)
                        {
                            WidgetMinimap.Instance.Reload();
                        }
                        foreach (CardRow cardRow in this.sources.cards.rows)
                        {
                            if (cardRow.replacer.hasChacked && cardRow.replacer.data != null)
                            {
                                cardRow.replacer.data.GetSprite(false);
                            }
                        }
                    }
                });
            });
            if (this.IsGameStarted && this.debug.enable)
            {
                foreach (PCC.Part part in this.pccs.allParts.Values)
                {
                    foreach (ModItem<Texture2D> modItem in part.modTextures.Values)
                    {
                        modItem.ClearCache();
                    }
                }
                CharaActorPCC[] array = UnityEngine.Object.FindObjectsOfType<CharaActorPCC>();
                for (int i = 0; i < array.Length; i++)
                {
                    array[i].provider.Rebuild(PCCState.Normal);
                }
            }
        }
        EInput.Consume(false, 1);
        EInput.dragHack = 0f;
    }
 
    // Token: 0x06000009 RID: 9 RVA: 0x00002B78 File Offset: 0x00000D78
    public void OnApplicationQuit()
    {
        try
        {
            foreach (Widget widget in this.ui.widgets.GetComponentsInChildren<Widget>(true))
            {
                if (widget.gameObject != null)
                {
                    UnityEngine.Object.Destroy(widget.gameObject);
                }
            }
            IO.PrintLog();
        }
        catch (Exception ex)
        {
            string str = "Exception:";
            Exception ex2 = ex;
            Debug.Log(str + ((ex2 != null) ? ex2.ToString() : null));
        }
        try
        {
            if (SteamAPI.IsSteamRunning())
            {
                SteamAPI.Shutdown();
            }
        }
        catch (Exception ex3)
        {
            string str2 = "Exception:";
            Exception ex4 = ex3;
            Debug.Log(str2 + ((ex4 != null) ? ex4.ToString() : null));
        }
        try
        {
            IO.DeleteDirectory(CorePath.Temp);
            GameIO.DeleteEmptyGameFolders();
        }
        catch (Exception ex5)
        {
            string str3 = "Exception:";
            Exception ex6 = ex5;
            Debug.Log(str3 + ((ex6 != null) ? ex6.ToString() : null));
        }
    }
 
    // Token: 0x0600000A RID: 10 RVA: 0x00002C74 File Offset: 0x00000E74
    public void ResetRuntime()
    {
        BaseCore.resetRuntime = false;
        BiomeProfile.forceInitialize = true;
        WidgetHotbar.registering = false;
        WidgetHotbar.registeringItem = null;
        WordGen.initialized = false;
        RecipeManager.rebuild = true;
        BookList.dict = null;
        SpawnList.allList.Clear();
    }
 
    // Token: 0x0600000B RID: 11 RVA: 0x00002CAC File Offset: 0x00000EAC
    public void Init()
    {
        Debug.Log("Initializing:" + this.langCode + "/" + this.forceLangCode);
        base.StartCoroutine("OnEndOfFrame");
        base.InvokeRepeating("Update100ms", 0.1f, 0.1f);
        UnityEngine.Object.DestroyImmediate(this.ui.layoutLang.gameObject);
        CoreConfig.Init();
        this.SetLang(this.config.lang, false);
        this.refs.Init();
        this.debug.Init();
        SpriteSheet.Add("Media/Graphics/Icon/icons_48");
        Cal.Init();
        this.Colors.Init();
        this.gameSetting.Init();
        this.mods.InitLang();
        if (!Lang.isBuiltin)
        {
            this.sources.ImportSourceTexts();
        }
        PCCManager.current.Init();
        SpriteVariationManager.current.Init();
        this.scene.InitPass();
        this.textures.Init();
        this.textures.RefreshTextures();
        SoundManager.current.Reset();
        if (this.debug.validatePref)
        {
            SourcePrefInspector.Instance.ValidatePrefs();
        }
        if (this.debug.startScene == CoreDebug.StartScene.Title)
        {
            this.scene.Init(Scene.Mode.Title);
        }
        else
        {
            this.debug.QuickStart();
        }
        this.ui.HideCover(2f, null);
        this.initialized = true;
    }
 
    // Token: 0x0600000C RID: 12 RVA: 0x00002E12 File Offset: 0x00001012
    public void Quit()
    {
        Application.Quit();
        Debug.Log("Quit");
    }
 
    // Token: 0x0600000D RID: 13 RVA: 0x00002E23 File Offset: 0x00001023
    public override void ConsumeInput()
    {
        EInput.Consume(false, 1);
    }
 
    // Token: 0x0600000E RID: 14 RVA: 0x00002E2C File Offset: 0x0000102C
    public static Core SetCurrent(Core _current = null)
    {
        if (Core.Instance)
        {
            return Core.Instance;
        }
        Core.Instance = (_current ?? UnityEngine.Object.FindObjectOfType<Core>());
        BaseCore.Instance = Core.Instance;
        if (Core.Instance)
        {
            Core.Instance.SetReferences();
        }
        return Core.Instance;
    }
 
    // Token: 0x0600000F RID: 15 RVA: 0x00002E7F File Offset: 0x0000107F
    public static Core GetCurrent()
    {
        return Core.Instance ?? Core.SetCurrent(null);
    }
 
    // Token: 0x06000010 RID: 16 RVA: 0x00002E90 File Offset: 0x00001090
    public void SetReferences()
    {
        CorePath.Init();
        SourceData.dataPath = CorePath.packageCore + "/Data/Source/";
        EMono.core = this;
        EClass.core = this;
        Core.Instance = this;
        SkinManager._Instance = this.skins;
        PathManager.Instance = this.pathManager;
        EffectManager.Instance = this.effects;
        this.sources.InitLang();
    }
 
    // Token: 0x06000011 RID: 17 RVA: 0x00002EF4 File Offset: 0x000010F4
    public void SetReleaseMode(ReleaseMode m)
    {
        if (this.releaseMode == m)
        {
            return;
        }
        this.releaseMode = m;
        this.debug = Resources.Load<CoreDebug>("_Debug " + this.releaseMode.ToString());
    }
 
    // Token: 0x06000012 RID: 18 RVA: 0x00002F2D File Offset: 0x0000112D
    private IEnumerator OnEndOfFrame()
    {
        for (;;)
        {
            yield return new WaitForEndOfFrame();
            if (this.screen.guide)
            {
                this.screen.guide.OnEndOfFrame();
            }
        }
        yield break;
    }
 
    // Token: 0x06000013 RID: 19 RVA: 0x00002F3C File Offset: 0x0000113C
    private void Update100ms()
    {
        if (!this.IsGameStarted)
        {
            return;
        }
        this.game.updater.Update100ms();
    }
 
    // Token: 0x06000014 RID: 20 RVA: 0x00002F58 File Offset: 0x00001158
    public void OnChangeResolution()
    {
        if (this.config != null)
        {
            this.config.OnChangeResolution();
        }
        this.screen.RefreshScreenSize();
        this.lastScreenWidth = Screen.width;
        this.lastScreenHeight = Screen.height;
        IChangeResolution[] componentsInChildren = this.ui.GetComponentsInChildren<IChangeResolution>();
        for (int i = 0; i < componentsInChildren.Length; i++)
        {
            componentsInChildren[i].OnChangeResolution();
        }
        this.scene.camSupport.OnChangeResolution();
    }
 
    // Token: 0x06000015 RID: 21 RVA: 0x00002FCB File Offset: 0x000011CB
    public void Halt()
    {
    }
 
    // Token: 0x06000016 RID: 22 RVA: 0x00002FCD File Offset: 0x000011CD
    public override void FreezeScreen(float duration)
    {
        this.ui.FreezeScreen(duration);
    }
 
    // Token: 0x06000017 RID: 23 RVA: 0x00002FDB File Offset: 0x000011DB
    public override void UnfreezeScreen()
    {
        this.ui.UnfreezeScreen();
    }
 
    // Token: 0x06000018 RID: 24 RVA: 0x00002FE8 File Offset: 0x000011E8
    public override void RebuildBGMList()
    {
        this.refs.RebuildBGMList();
    }
 
    // Token: 0x06000019 RID: 25 RVA: 0x00002FF8 File Offset: 0x000011F8
    public override void StopEventSystem(Component c, Action action, float duration = 0.12f)
    {
        this.eventSystem.enabled = false;
        c.transform.DOScale(new Vector3(1f, 0f, 1f), duration).OnKill(delegate
        {
            this.eventSystem.enabled = true;
        }).OnComplete(delegate
        {
            action();
        }).SetEase(Ease.Linear);
    }
 
    // Token: 0x0600001A RID: 26 RVA: 0x0000306E File Offset: 0x0000126E
    public override void StopEventSystem(float duration = 0.2f)
    {
        this.eventSystem.enabled = false;
        TweenUtil.Tween(duration, null, delegate()
        {
            this.eventSystem.enabled = true;
        });
    }
 
    // Token: 0x0600001B RID: 27 RVA: 0x00003090 File Offset: 0x00001290
    public void SetLang(string langCode, bool force = false)
    {
        if (Lang.langCode == langCode && this.sources && this.sources.langGeneral)
        {
            return;
        }
        Lang.Init(langCode);
        AliasGen.list = null;
        NameGen.list = null;
        WordGen.initialized = false;
        this.sources.OnChangeLang();
        if (this.game != null && !this.IsGameStarted)
        {
            this.game.Kill();
        }
        this.config.OnSetLang();
    }
 
    // Token: 0x0600001C RID: 28 RVA: 0x00003114 File Offset: 0x00001314
    public static int[] ParseElements(string str)
    {
        if (string.IsNullOrEmpty(str))
        {
            return new int[0];
        }
        string[] array = str.Replace("\n", "").Split(',', StringSplitOptions.None);
        int[] array2 = new int[array.Length * 2];
        for (int i = 0; i < array.Length; i++)
        {
            string[] array3 = array[i].Split('/', StringSplitOptions.None);
            array2[i * 2] = Core.GetElement(array3[0]);
            array2[i * 2 + 1] = ((array3.Length == 1) ? 1 : int.Parse(array3[1]));
        }
        return array2;
    }
 
    // Token: 0x0600001D RID: 29 RVA: 0x00003194 File Offset: 0x00001394
    public static int GetElement(string id)
    {
        Core.SetCurrent(null);
        if (Core.sourceElement == null)
        {
            Core.sourceElement = UnityEngine.Object.FindObjectOfType<SourceManager>().GetComponent<SourceManager>().elements;
        }
        if (!Core.sourceElement.initialized)
        {
            Core.sourceElement.Init();
        }
        SourceElement.Row row;
        if (!Core.sourceElement.alias.TryGetValue(id ?? "_void", out row))
        {
            Debug.LogError("exception:" + id);
            row = Core.sourceElement.rows[0];
        }
        return row.id;
    }
 
    // Token: 0x0600001E RID: 30 RVA: 0x00003224 File Offset: 0x00001424
    public void ApplySkins()
    {
        IUISkin[] componentsInChildren = this.ui.GetComponentsInChildren<IUISkin>(true);
        for (int i = 0; i < componentsInChildren.Length; i++)
        {
            componentsInChildren[i].ApplySkin();
        }
    }
 
    // Token: 0x04000001 RID: 1
    public new static Core Instance;
 
    // Token: 0x04000002 RID: 2
    public static float delta;
 
    // Token: 0x04000003 RID: 3
    public static float avgDelta;
 
    // Token: 0x04000004 RID: 4
    public static float gameDelta;
 
    // Token: 0x04000005 RID: 5
    public static float gameDeltaNoPause;
 
    // Token: 0x04000006 RID: 6
    public static bool spiked;
 
    // Token: 0x04000007 RID: 7
    private static SourceElement sourceElement;
 
    // Token: 0x04000008 RID: 8
    public CoreDebug debug;
 
    // Token: 0x04000009 RID: 9
    public SourceManager sources;
 
    // Token: 0x0400000A RID: 10
    public PathManager pathManager;
 
    // Token: 0x0400000B RID: 11
    public EffectManager effects;
 
    // Token: 0x0400000C RID: 12
    public ModManager mods = new ModManager();
 
    // Token: 0x0400000D RID: 13
    public PCCManager pccs;
 
    // Token: 0x0400000E RID: 14
    public SkinManager skins;
 
    // Token: 0x0400000F RID: 15
    public TextureManager textures = new TextureManager();
 
    // Token: 0x04000010 RID: 16
    public GameSetting gameSetting;
 
    // Token: 0x04000011 RID: 17
    public GameData gamedata;
 
    // Token: 0x04000012 RID: 18
    public CoreRef refs;
 
    // Token: 0x04000013 RID: 19
    public ColorProfile Colors;
 
    // Token: 0x04000014 RID: 20
    public Material matUI;
 
    // Token: 0x04000015 RID: 21
    public Steam steam;
 
    // Token: 0x04000016 RID: 22
    public bool useUImat;
 
    // Token: 0x04000017 RID: 23
    public bool trial;
 
    // Token: 0x04000018 RID: 24
    public UI ui;
 
    // Token: 0x04000019 RID: 25
    public Scene scene;
 
    // Token: 0x0400001A RID: 26
    public BaseGameScreen screen;
 
    // Token: 0x0400001B RID: 27
    [NonSerialized]
    public CoreConfig config;
 
    // Token: 0x0400001C RID: 28
    public Game game;
 
    // Token: 0x0400001D RID: 29
    [NonSerialized]
    public bool initialized;
 
    // Token: 0x0400001E RID: 30
    private bool? lastFullScreen;
 
    // Token: 0x0400001F RID: 31
    private float nextResolutionUpdate;
 
    // Token: 0x04000020 RID: 32
    private float skinTimer;
}