diff --git a/Components/InventoryControllerDeployer.cs b/Components/InventoryControllerDeployer.cs
index b3d36d0..55d696f 100644
--- a/Components/InventoryControllerDeployer.cs
+++ b/Components/InventoryControllerDeployer.cs
@@ -4,6 +4,7 @@
 using System.Collections;
 using UnityEngine;
 using UnityEngine.UI;
+using System.Runtime.CompilerServices;
 
 namespace UltraFunGuns
 {
@@ -25,89 +26,121 @@ public class InventoryControllerDeployer : MonoBehaviour
 
         private void Awake()
         {
-            
             inventoryKey = UltraFunGuns.INVENTORY_KEY.Value;
-            om = MonoSingleton<OptionsManager>.Instance;
-            canvas = GetComponent<RectTransform>();
-            pauseMenu = transform.Find("PauseMenu").gameObject;
-            HydraLoader.prefabRegistry.TryGetValue("UFGInventoryUI", out GameObject controllerObject);
-            HydraLoader.prefabRegistry.TryGetValue("UFGInventoryButton", out GameObject pauseMenuInvButton);
-            invControllerButton = GameObject.Instantiate<GameObject>(pauseMenuInvButton, canvas).GetComponent<Button>();
-            invControllerButton.onClick.AddListener(OpenInventory);
-            invController = GameObject.Instantiate<GameObject>(controllerObject, canvas).GetComponent<InventoryController>();
-            invController.gameObject.SetActive(false);
-            invControllerButton.gameObject.SetActive(false);
+        }
 
-            configHelpMessage = invController.transform.Find("ConfigMessage");
+        private void Update()
+        {
+            CheckThings();
+            NewCheckStatus();
+        }
 
-            configHelpButton = invController.transform.Find("MenuBorder/SlotNames").GetComponent<Button>();
-            configHelpButton.onClick.AddListener(SendConfigHelpMessage);
+        private void CheckThings()
+        {
+            if(om == null)
+            {
+                om = MonoSingleton<OptionsManager>.Instance;
+            }
+
+            if(canvas == null)
+            {
+                canvas = GetComponent<RectTransform>();
+            }
+
+            if(pauseMenu == null)
+            {
+                pauseMenu = transform.Find("PauseMenu").gameObject;
+            }
+
+            if (invController == null)
+            {
+                HydraLoader.prefabRegistry.TryGetValue("UFGInventoryUI", out GameObject controllerObject);
+                invController = GameObject.Instantiate<GameObject>(controllerObject, canvas).GetComponent<InventoryController>();
+                invController.gameObject.SetActive(false);
+                configHelpMessage = invController.transform.Find("ConfigMessage");
+                configHelpButton = invController.transform.Find("MenuBorder/SlotNames").GetComponent<Button>();
+                configHelpButton.onClick.AddListener(SendConfigHelpMessage);
+            }
+
+            if (invControllerButton == null)
+            {
+                HydraLoader.prefabRegistry.TryGetValue("UFGInventoryButton", out GameObject pauseMenuInvButton);
+                invControllerButton = GameObject.Instantiate<GameObject>(pauseMenuInvButton, canvas).GetComponent<Button>();
+                invControllerButton.onClick.AddListener(OpenInventory);
+                invControllerButton.gameObject.SetActive(false);
+            }
         }
 
-        private void Update()
+
+        private void NewCheckStatus()
         {
-            if (UltraFunGuns.InLevel())
+            if (!UltraFunGuns.InLevel())
             {
-                
-                if (om.paused)
-                {
-                    if (inventoryManagerOpen)
-                    {
-                        invController.gameObject.SetActive(true);
-                    }
-                    else
-                    {
-                        invController.gameObject.SetActive(false);
-                        invControllerButton.gameObject.SetActive(true);
-                        configHelpMessage.gameObject.SetActive(false);
-                        sentBindingMessage = false;
-                    }
+                return;
+            }
 
-                }
-                else
-                {
-                    if(invController.data.firstTimeModLoaded)
-                    {
-                        MonoSingleton<HudMessageReceiver>.Instance.SendHudMessage(String.Format("UFG: Set a custom loadout for UFG weapons with [<color=orange>{0}</color>] or in the pause menu.",inventoryKey.ToString()), "", "", 2);
-                        invController.data.firstTimeModLoaded = false;
-                    }
-
-                    if (inventoryManagerOpen)
-                    {
-                        inventoryManagerOpen = false;
-                        invController.gameObject.SetActive(false);
-
-                    }
-                    invControllerButton.gameObject.SetActive(false);
-                }
-                
-                if(Input.GetKeyDown(inventoryKey) && !om.paused)
+            if (inventoryManagerOpen)
+            {
+
+                if (Input.GetKeyDown(KeyCode.Escape))
                 {
-                    OpenInventory();
+                    CloseInventory();
                 }
             }
 
+            invControllerButton.gameObject.SetActive(om.paused && !inventoryManagerOpen);
+
+            if (Input.GetKeyDown(UltraFunGuns.INVENTORY_KEY.Value) && !om.paused)
+            {
+                OpenInventory();
+            }
         }
 
         public void OpenInventory()
         {
-            if(!inventoryManagerOpen)
+            if (invController.gameObject.activeInHierarchy)
             {
-                if (!om.paused)
-                {
-                    om.Pause();
-                }
+                return;
+            }
 
-                if (invController.data.firstTimeUsingInventory)
-                {
-                    MonoSingleton<HudMessageReceiver>.Instance.SendHudMessage("WARNING: Having UFG weapons enabled at any point will enable the Major Assists for the duration of the level.", "", "", 4);
-                    invController.data.firstTimeUsingInventory = false;
-                }
-                pauseMenu.SetActive(false);
-                invControllerButton.gameObject.SetActive(false);
-                invController.gameObject.SetActive(true);
-                inventoryManagerOpen = true;
-            }         
+            if (om.paused)
+            {
+                om.UnPause();
+            }
+
+            om.paused = true;
+
+            invController.RefreshSlotKeyDisplays();
+
+            GameState ufgInvState = new GameState("ufg_inv", invController.gameObject);
+            ufgInvState.cursorLock = LockMode.Unlock;
+            ufgInvState.playerInputLock = LockMode.Lock;
+            ufgInvState.cameraInputLock = LockMode.Lock;
+            ufgInvState.priority = 2;
+            GameStateManager.Instance.RegisterState(ufgInvState);
+
+            invControllerButton.gameObject.SetActive(false);
+            invController.gameObject.SetActive(true);
+            inventoryManagerOpen = true;
+        }
+
+        public void CloseInventory()
+        {
+            inventoryManagerOpen = false;
+            om.paused = false;
+            configHelpMessage.gameObject.SetActive(false);
+            invController.gameObject.SetActive(false);
+            if (invController.data.firstTimeModLoaded)
+            {
+                MonoSingleton<HudMessageReceiver>.Instance.SendHudMessage(String.Format("UFG: Set a custom loadout for UFG weapons with [<color=orange>{0}</color>] or in the pause menu.", inventoryKey.ToString()), "", "", 2);
+                invController.data.firstTimeModLoaded = false;
+
+            }
+            else if (!invController.data.lecturedAboutVersion && !UltraFunGuns.UsingLatestVersion)
+            {
+                MonoSingleton<HudMessageReceiver>.Instance.SendHudMessage($"UFG: You are using an outdated version of UltraFunGuns. Consider updating to <color=orange>{UltraFunGuns.RELEASE_VERSION}</color>.", "", "", 2);
+                invController.data.lecturedAboutVersion = true;
+            }
         }
 
         public void SendConfigHelpMessage()
diff --git a/Components/UFGWeaponManager.cs b/Components/UFGWeaponManager.cs
index 042fe96..1e24c96 100644
--- a/Components/UFGWeaponManager.cs
+++ b/Components/UFGWeaponManager.cs
@@ -3,6 +3,9 @@
 using UnityEngine;
 using HarmonyLib;
 using UnityEngine.SceneManagement;
+using System.Reflection;
+using System;
+using System.Linq;
 
 namespace UltraFunGuns
 {
@@ -11,6 +14,8 @@ public class UFGWeaponManager : MonoBehaviour
     {
         GunControl gc;
 
+        public static bool WeaponsInUse { get; private set; }
+
         private List<List<string>> weaponKeySlots = new List<List<string>>();
 
         //Empty slots for the weapons. Don't remove this.
@@ -57,6 +62,8 @@ private void Awake()
 
         public List<List<string>> CreateWeaponKeyset(InventoryControllerData invControllerData)
         {
+            int wepCount = 0;
+
             List<List<string>> newWeaponKeys = new List<List<string>>();
             for (int x = 0; x < invControllerData.slots.Length; x++)
             {
@@ -65,17 +72,28 @@ public List<List<string>> CreateWeaponKeyset(InventoryControllerData invControll
                 {
                     if(invControllerData.slots[x].slotNodes[y].weaponEnabled)
                     {
+                        ++wepCount;
                         newWeaponKeyList.Add(invControllerData.slots[x].slotNodes[y].weaponKey);
                     }
                 }
                 newWeaponKeys.Add(newWeaponKeyList);
             }
+
+            
+
             return newWeaponKeys;
         }
 
         //Gets weapon prefabs from the Data loader and instantiates them into the world and adds them to the gun controllers lists.
         public void DeployWeapons(bool firstTime = false)
         {
+
+            if(!LevelCheck.InLevel())
+            {
+                WeaponsInUse = false;
+                return;
+            }
+
             string sceneName = SceneManager.GetActiveScene().name;
             bool deploy = true;
 
@@ -136,6 +154,8 @@ public void DeployWeapons(bool firstTime = false)
         //adds weapons to the gun controller
         private void AddWeapons()
         {
+            bool weaponsUsed = false;
+
             for (int j = 0; j < customSlots.Count; j++)
             {
                 if (gc.slots.Contains(customSlots[j]))
@@ -152,13 +172,30 @@ private void AddWeapons()
                 {
                     if (!gc.allWeapons.Contains(wep))
                     {
+                        weaponsUsed = true;
                         gc.allWeapons.Add(wep);
+                        AddWeaponToFreshnessDict(wep);
                     }
                 }
 
             }
-            
 
+            if (LevelCheck.CurrentLevelType == LevelCheck.UKLevelType.Endless)
+            {   
+                if (WeaponsInUse)
+                {
+                    if (!EndlessGrid.Instance.GetComponent<Collider>().enabled)
+                    {
+                        HudMessageReceiver.Instance.SendHudMessage("You must restart the level after disabling UFG weapons for your score to count.");
+                        weaponsUsed = true;
+                    }      
+                }else if(weaponsUsed)
+                {
+                    HudMessageReceiver.Instance.SendHudMessage("Warning: having any UFG weapons enabled will prevent your CyberGrind score from being submitted.");
+                }
+            }
+
+            WeaponsInUse = weaponsUsed;
         }
 
         //TODO fix this, for some reason the input on switching to weapons doesn't work past slot 7. No its not because of the keycodes, that was an attempt to fix it. Inspect the GunControl class closer.
@@ -201,5 +238,66 @@ private void NewStyleItem(string name, string text)
                 MonoSingleton<StyleHUD>.Instance.RegisterStyleItem("hydraxous.ultrafunguns." + name, text);
             }
         }
+
+        //Credit to Agent of Nyarlathotep for this, thanks fren <3
+        private static Dictionary<GameObject, float> FreshnessList
+        {
+            get
+            {
+                var field = typeof(StyleHUD).GetField("weaponFreshness", BindingFlags.NonPublic | BindingFlags.Instance);
+                Dictionary<GameObject, float> freshnessList = field.GetValue(MonoSingleton<StyleHUD>.Instance) as Dictionary<GameObject, float>;
+                return freshnessList;
+            }
+
+            set
+            {
+                if (value != null)
+                {
+                    var field = typeof(StyleHUD).GetField("weaponFreshness", BindingFlags.NonPublic | BindingFlags.Instance);
+                    field.SetValue(MonoSingleton<StyleHUD>.Instance, value);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Adds weapon to style hud freshness
+        /// </summary>
+        /// <param name="go">gameObject to add</param>
+        /// <returns></returns>
+        public static bool AddWeaponToFreshnessDict(GameObject go)
+        {
+
+            if (go == null)
+            {
+                //HydraLogger.Log($"WeaponManager: Attempted to register null gameobject into freshness dict.", DebugChannel.Error);
+                return false;
+            }
+
+            try
+            {
+                Dictionary<GameObject, float> freshnessDict = FreshnessList;
+                if (!freshnessDict.ContainsKey(go))
+                {
+                    freshnessDict.Add(go, 10f);
+                    FreshnessList = freshnessDict;
+                    return true;
+                }
+
+                //HydraLogger.Log($"WeaponManager: Attempted to register existing weapon to freshness dict.", DebugChannel.Error);
+                return false;
+
+            }
+            catch (Exception ex)
+            {
+                //HydraLogger.Log($"WeaponManager: Could not register {go.name} to freshness dict.\n{ex.Message}\n{ex.StackTrace}", DebugChannel.Fatal);
+            }
+
+            return false;
+        }
+
+        private void OnDestroy()
+        {
+            WeaponsInUse = false;
+        }
     }
 }
diff --git a/Components/UI/InventoryController.cs b/Components/UI/InventoryController.cs
index 66a2e46..84026c1 100644
--- a/Components/UI/InventoryController.cs
+++ b/Components/UI/InventoryController.cs
@@ -44,20 +44,32 @@ private void CreateNewSlots()
             }
         }
 
+        private List<Text> slotKeyNames = new List<Text>();
+
         private void SetSlotKeyDisplays()
         {
-            List<Text> slotNameTexts = new List<Text>();
             for(int i = 0; i < slots.Count; i++)
             {
-                slotNameTexts.Add(transform.Find(String.Format("MenuBorder/SlotNames/Slot{0}Name", i)).GetComponent<Text>());
-                
+                slotKeyNames.Add(transform.Find(String.Format("MenuBorder/SlotNames/Slot{0}Name", i)).GetComponent<Text>());         
             }
-            slotNameTexts[0].text = slotNameTexts[0].text.Replace("KEY", UltraFunGuns.SLOT_7_KEY.Value.ToString());
-            slotNameTexts[1].text = slotNameTexts[1].text.Replace("KEY", UltraFunGuns.SLOT_8_KEY.Value.ToString());
-            slotNameTexts[2].text = slotNameTexts[2].text.Replace("KEY", UltraFunGuns.SLOT_9_KEY.Value.ToString());
-            slotNameTexts[3].text = slotNameTexts[3].text.Replace("KEY", UltraFunGuns.SLOT_10_KEY.Value.ToString());
+
+            RefreshSlotKeyDisplays();
         }
 
+
+        //Refreshes the keybind displays for each slot.
+        public void RefreshSlotKeyDisplays()
+        {
+            if (slotKeyNames.Count > 0)
+            {
+                slotKeyNames[0].text = string.Format("Slot {0} [<color=orange>{1}</color>]", 7, UltraFunGuns.SLOT_7_KEY.Value.ToString());
+                slotKeyNames[1].text = string.Format("Slot {0} [<color=orange>{1}</color>]", 8, UltraFunGuns.SLOT_8_KEY.Value.ToString());
+                slotKeyNames[2].text = string.Format("Slot {0} [<color=orange>{1}</color>]", 9, UltraFunGuns.SLOT_9_KEY.Value.ToString());
+                slotKeyNames[3].text = string.Format("Slot {0} [<color=orange>{1}</color>]", 10, UltraFunGuns.SLOT_10_KEY.Value.ToString());
+            }
+        }
+
+
         public void ButtonPressed(InventoryNode node, InventorySlot slot, string buttonPressed)
         {
             switch(buttonPressed)
@@ -133,7 +145,7 @@ public InventoryControllerData GetCurrentInventoryData()
             {
                 newNodeArray.Add(slots[i].GetSlotData());
             }
-            return new InventoryControllerData(newNodeArray.ToArray(), data.modVersion, data.firstTimeUsingInventory, data.firstTimeModLoaded);
+            return new InventoryControllerData(newNodeArray.ToArray(), data.modVersion, data.firstTimeUsingInventory, data.firstTimeModLoaded, data.lecturedAboutVersion);
         }
     }
 
@@ -143,13 +155,15 @@ public class InventoryControllerData
         public string modVersion;
         public bool firstTimeModLoaded;
         public bool firstTimeUsingInventory;
+        public bool lecturedAboutVersion;
         public InventorySlotData[] slots;
-        public InventoryControllerData(InventorySlotData[] slots, string modVersion, bool firstTimeUse = false, bool firstTimeModLoaded = false)
+        public InventoryControllerData(InventorySlotData[] slots, string modVersion, bool firstTimeUse = false, bool firstTimeModLoaded = false, bool lecturedAboutVersion = false)
         {
             this.firstTimeModLoaded = firstTimeModLoaded;
             this.firstTimeUsingInventory = firstTimeUse;
             this.slots = slots;
             this.modVersion = modVersion;
+            this.lecturedAboutVersion = lecturedAboutVersion;
         }
 
         public InventoryControllerData()
diff --git a/Components/UI/InventoryDataManager.cs b/Components/UI/InventoryDataManager.cs
index 03a92f6..2e8c812 100644
--- a/Components/UI/InventoryDataManager.cs
+++ b/Components/UI/InventoryDataManager.cs
@@ -66,12 +66,11 @@ public static bool LoadInventoryData()
                     loadoutData = reader.ReadToEnd();
                 }
                 inventory = JsonConvert.DeserializeObject<InventoryControllerData>(loadoutData);
-                if(inventory.modVersion != UltraFunGuns.version)
+                if(inventory.modVersion != UltraFunGuns.RELEASE_VERSION)
                 {
                     Console.WriteLine("UFG: Inventory data found is for a different version of UFG, rebuilding.");
                     FirstTimeLoad();
-                }
-                UpdateWeaponUsage(inventory);
+                };
                 Console.WriteLine("UFG: Inventory data loaded.");
                 return true;
             }catch (System.Exception e)
@@ -81,38 +80,11 @@ public static bool LoadInventoryData()
             }
         }
 
-        private static void UpdateWeaponUsage(InventoryControllerData data)
-        {
-            bool weaponsInUse = false;
-            for (int x = 0; x < data.slots.Length; x++)
-            {
-                for (int y = 0; y < data.slots[x].slotNodes.Length; y++)
-                {
-                    if (weaponsInUse)
-                    {
-                        break;
-                    }
-
-                    if (data.slots[x].slotNodes[y].weaponEnabled)
-                    {
-                        weaponsInUse = true;
-                        break;
-                    }
-                }
-            }
-
-            if (weaponsInUse)
-            {
-                UltraFunGuns.usedWeapons = true;
-            }
-        }
-
         public static void SaveInventoryData(InventoryControllerData data)
         {   
             inventory = data;
             string loadoutData = JsonConvert.SerializeObject(inventory);
             File.WriteAllText(loadoutDataPath, loadoutData);
-            UpdateWeaponUsage(data);
             Console.WriteLine("UFG: Inventory data saved.");
         }
 
@@ -134,7 +106,7 @@ private static void FirstTimeLoad()
             slot4.Add(new InventoryNodeData("FingerGun", true, 1));
     
             List<InventorySlotData> newSlotDatas = new List<InventorySlotData> { new InventorySlotData(slot1.ToArray()), new InventorySlotData(slot2.ToArray()), new InventorySlotData(slot3.ToArray()), new InventorySlotData(slot4.ToArray()) };
-            InventoryControllerData defaultData = new InventoryControllerData(newSlotDatas.ToArray(), UltraFunGuns.version, true, true);
+            InventoryControllerData defaultData = new InventoryControllerData(newSlotDatas.ToArray(), UltraFunGuns.RELEASE_VERSION, true, true);
             SaveInventoryData(defaultData);
         }
     }
diff --git a/Components/UI/InventoryNode.cs b/Components/UI/InventoryNode.cs
index baf7162..1cbb9a3 100644
--- a/Components/UI/InventoryNode.cs
+++ b/Components/UI/InventoryNode.cs
@@ -28,7 +28,7 @@ public void Initialize(InventoryNodeData data, InventorySlot slot, int slotIndex
             weaponIcon_Disabled = new Color(73f, 73f, 73f, 255f);
             nodeBg_Enabled = new Color(185.0f, 185.0f, 185.0f, 110f);
             nodeBg_Disabled = new Color(49.0f, 49.0f, 49.0f, 110f);
-            Debug.Log(data.weaponKey + " NODE INIT!");
+            //Debug.Log(data.weaponKey + " NODE INIT!");
             this.slotIndexPosition = slotIndex;
             this.data = data;
             this.slot = slot;
diff --git a/Components/Weapons/EggToss/EggSplosion.cs b/Components/Weapons/EggToss/EggSplosion.cs
index 3934e8e..e125d91 100644
--- a/Components/Weapons/EggToss/EggSplosion.cs
+++ b/Components/Weapons/EggToss/EggSplosion.cs
@@ -26,7 +26,8 @@ private void Awake()
         //Eggsplosion casts a sphere to try and find enemies nearby. It then spawns an egg and shoots it at the found enemy.
         private void Start()
         {
-            Debug.Log("Eggsplosion!");
+            
+            
             RaycastHit[] hits = Physics.SphereCastAll(transform.position, explosionSize, transform.position, Mathf.Infinity);
             if (hits.Length > 0)
             {
diff --git a/Patches/CyberGrindPatch.cs b/Patches/CyberGrindPatch.cs
new file mode 100644
index 0000000..c051ed0
--- /dev/null
+++ b/Patches/CyberGrindPatch.cs
@@ -0,0 +1,27 @@
+using HarmonyLib;
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using System.Text;
+using UnityEngine;
+
+namespace UltraFunGuns.Patches
+{
+    public class CheatsPatch
+    {
+        [HarmonyPatch(typeof(SteamController), nameof(SteamController.SubmitCyberGrindScore))]
+        public static class CyberGrindPreventer
+        {
+            public static bool Prefix(SteamController __instance)
+            {
+                if(UFGWeaponManager.WeaponsInUse)
+                {
+                    Debug.Log("UFG: weapons used. Disqualifying cybergrind score.");
+                    return false;
+                }
+
+                return true;
+            }
+        }
+    }
+}
diff --git a/Plugin.cs b/Plugin.cs
index 56e250f..44b375e 100644
--- a/Plugin.cs
+++ b/Plugin.cs
@@ -8,22 +8,31 @@
 using UnityEngine.SceneManagement;
 using UltraFunGuns.Properties;
 using HarmonyLib;
+using Newtonsoft.Json.Linq;
+using System.Collections;
+using UnityEngine.Networking;
 
 namespace UltraFunGuns
 {
-    [BepInPlugin("Hydraxous.ULTRAKILL.UltraFunGuns", "UltraFunGuns", "1.1.7")]
+    [BepInPlugin("Hydraxous.ULTRAKILL.UltraFunGuns", "UltraFunGuns", "1.1.8")]
     public class UltraFunGuns : BaseUnityPlugin
     {
         
         public UFGWeaponManager gunPatch;
         public InventoryControllerDeployer invControllerDeployer;
 
-        public static bool usedWeapons = true;
-        public static string version = "1.1.7";
+        public const string RELEASE_VERSION = "1.1.8-Experimental";
+        const string GITHUB_URL = "https://api.github.com/repos/Hydraxous/ultrafunguns/tags";
+
+        public static bool UsingLatestVersion = true;
+        public static string LatestVersion = "UNKNOWN";
+
         private void Awake()
         {
             if (RegisterAssets() && InventoryDataManager.Initialize())
             {
+                LevelCheck.Init();
+                CheckVersion();
                 DoPatching();
                 Logger.LogInfo("UltraFunGuns Loaded.");
             }else
@@ -44,7 +53,6 @@ private void CheckWeapons()
                 CanvasController canvas = MonoSingleton<CanvasController>.Instance;
                 if(!canvas.TryGetComponent<InventoryControllerDeployer>(out invControllerDeployer))
                 {
-                    usedWeapons = false;
                     invControllerDeployer = canvas.gameObject.AddComponent<InventoryControllerDeployer>();
                 }
 
@@ -55,7 +63,6 @@ private void CheckWeapons()
                 GunControl gc = MonoSingleton<GunControl>.Instance;
                 if (!gc.TryGetComponent<UFGWeaponManager>(out UFGWeaponManager ultraFGPatch))
                 {
-                    usedWeapons = false;
                     gunPatch = gc.gameObject.AddComponent<UFGWeaponManager>();
                     gunPatch.Slot7Key = SLOT_7_KEY.Value;
                     gunPatch.Slot8Key = SLOT_8_KEY.Value;
@@ -68,12 +75,8 @@ private void CheckWeapons()
 
         public static bool InLevel()
         {
-            string sceneName = SceneManager.GetActiveScene().name;
-            if (sceneName == "Intro" || sceneName == "Main Menu")
-            {
-                return false;
-            }
-            return true;
+            //Yeah yeah cry about it.
+            return LevelCheck.InLevel();
         }
 
         private void DoPatching()
@@ -159,31 +162,16 @@ private bool RegisterAssets()
             new HydraLoader.CustomAssetPrefab("UFGInventoryButton", new Component[] { });
 
 
-            return HydraLoader.RegisterAll(UltraFunGunsResources.UltraFunGuns);
+            return HydraLoader.RegisterAll(Properties.Resources.UltraFunGuns);
             
         }
 
-        private static void UpdateMajorAssistUsage()
-        {
-            if (MonoSingleton<StatsManager>.Instance != null)
-            {
-                if (!MonoSingleton<StatsManager>.Instance.majorUsed)
-                {
-                    MonoSingleton<StatsManager>.Instance.majorUsed = usedWeapons;
-                }
-            }
-        }
 
         private void Update()
         {
             try
             {
-                if(!InLevel())
-                {
-                    usedWeapons = false;
-                }
                 CheckWeapons();
-                UpdateMajorAssistUsage();
             }
             catch(System.Exception e)
             {
@@ -214,6 +202,44 @@ public void SaveConfig()
         {
             Config.Save();
         }
+
+        private void CheckVersion()
+        {
+            StartCoroutine(CheckLatestVersion());
+        }
+
+        //matches current mod version with latest release on github
+        private IEnumerator CheckLatestVersion()
+        {
+            using (UnityWebRequest webRequest = UnityWebRequest.Get(GITHUB_URL))
+            {
+                yield return webRequest.SendWebRequest();
+
+                if (!webRequest.isNetworkError)
+                {
+                    string page = webRequest.downloadHandler.text;
+                    try
+                    {
+                        LatestVersion = JArray.Parse(page)[0].Value<string>("name");
+                        UsingLatestVersion = (LatestVersion == RELEASE_VERSION);
+                        if (UsingLatestVersion)
+                        {
+                            Debug.Log(string.Format("You are using the latest version of UFG: {0}", LatestVersion));
+                        }
+                        else
+                        {
+                            Debug.Log(string.Format("New version of UFG available: {0}. Please consider updating.", LatestVersion));
+                        }
+                    }
+                    catch (System.Exception e)
+                    {
+                        UsingLatestVersion = true;
+                        Logger.Log(LogLevel.Info, string.Format("Error getting version info. Current Version: {0}\n{1}\n{2}", RELEASE_VERSION, e.Message, e.StackTrace));
+                    }
+
+                }
+            }
+        }
     }
     
 }
\ No newline at end of file
diff --git a/Properties/Resources.Designer.cs b/Properties/Resources.Designer.cs
index ee0982b..cba24bd 100644
--- a/Properties/Resources.Designer.cs
+++ b/Properties/Resources.Designer.cs
@@ -19,17 +19,17 @@ namespace UltraFunGuns.Properties {
     // class via a tool like ResGen or Visual Studio.
     // To add or remove a member, edit your .ResX file then rerun ResGen
     // with the /str option, or rebuild your VS project.
-    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "15.0.0.0")]
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "17.0.0.0")]
     [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
     [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
-    internal class UltraFunGunsResources {
+    internal class Resources {
         
         private static global::System.Resources.ResourceManager resourceMan;
         
         private static global::System.Globalization.CultureInfo resourceCulture;
         
         [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
-        internal UltraFunGunsResources() {
+        internal Resources() {
         }
         
         /// <summary>
@@ -39,7 +39,7 @@ internal UltraFunGunsResources() {
         internal static global::System.Resources.ResourceManager ResourceManager {
             get {
                 if (object.ReferenceEquals(resourceMan, null)) {
-                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("UltraFunGuns.Properties.Resources", typeof(UltraFunGunsResources).Assembly);
+                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("UltraFunGuns.Properties.Resources", typeof(Resources).Assembly);
                     resourceMan = temp;
                 }
                 return resourceMan;
diff --git a/UltraFunGuns.csproj b/UltraFunGuns.csproj
index b82b72b..4e18dc5 100644
--- a/UltraFunGuns.csproj
+++ b/UltraFunGuns.csproj
@@ -38,9 +38,6 @@
     <Reference Include="Assembly-CSharp">
       <HintPath>$(ULTRAKILLPath)\ULTRAKILL_Data\Managed\Assembly-CSharp.dll</HintPath>
     </Reference>
-    <Reference Include="UMM">
-      <HintPath>$(ULTRAKILLPath)\BepInEx\plugins\UMM\UMM.dll</HintPath>
-    </Reference>
     <Reference Include="Unity.InputSystem">
       <HintPath>$(ULTRAKILLPath)\ULTRAKILL_Data\Managed\Unity.InputSystem.dll</HintPath>
     </Reference>
@@ -98,6 +95,9 @@
     <Reference Include="UnityEngine.UnityWebRequestModule">
       <HintPath>$(ULTRAKILLPath)\ULTRAKILL_Data\Managed\UnityEngine.UnityWebRequestModule.dll</HintPath>
     </Reference>
+	<Reference Include="BepInEx">
+		<HintPath>$(ULTRAKILLPath)\BepInEx\Core\BepInEx.dll</HintPath>
+	</Reference>
   </ItemGroup>
 
   <ItemGroup>
@@ -124,6 +124,6 @@
     <Error Condition="!Exists($(ULTRAKILLPath))" Text="ULTRAKILLPath not set, create a .csproj.user file that sets this property to compile" />
   </Target>
   <Target Name="CopyModDlls" AfterTargets="AfterBuild">
-    <Copy SourceFiles="$(OutDir)/$(AssemblyName).dll" DestinationFolder="$(ULTRAKILLPath)\BepInEx\UMM Mods\UFG\" />
+    <Copy SourceFiles="$(OutDir)/$(AssemblyName).dll" DestinationFolder="$(ULTRAKILLPath)\BepInEx\plugins\UFG\" />
   </Target>
 </Project>
diff --git a/Util/LevelCheck.cs b/Util/LevelCheck.cs
new file mode 100644
index 0000000..5bec410
--- /dev/null
+++ b/Util/LevelCheck.cs
@@ -0,0 +1,148 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using UnityEngine;
+using UnityEngine.SceneManagement;
+
+namespace UltraFunGuns
+{
+    public static class LevelCheck
+    {
+        private static bool initialized;
+        public static void Init()
+        {
+            if (!initialized)
+            {
+                initialized = true;
+                SceneManager.sceneLoaded += OnSceneLoad;
+            }
+        }
+
+        private static void PrintLoadedScenes()
+        {
+            int numScenes = SceneManager.sceneCountInBuildSettings;
+            for (int i = 0; i < numScenes; i++)
+            {
+                PrintSceneDetails(SceneManager.GetSceneByBuildIndex(i));
+            }
+        }
+
+        private static void PrintSceneDetails(Scene scene, bool force = false)
+        {
+            if ((scene == null || scene.buildIndex == -1) && !force)
+            {
+                //HydraLogger.Log($"SCENEHELPER: Scene is null!");
+                return;
+            }
+
+            /*
+            HydraLogger.Log($"=============================\n" +
+                $"SCENE FOUND: {scene.name}\n" +
+                $"VALID: {scene.IsValid()}\n" +
+                $"INDEX: {scene.buildIndex}\n" +
+                $"PATH: {scene.path}\n" +
+                $"OBJS: {scene.rootCount}\n" +
+                $"=============================");
+            */
+        }
+
+        /// <summary>
+        /// Enumerated version of the Ultrakill scene types
+        /// </summary>
+        public enum UKLevelType { Intro, MainMenu, Level, Endless, Sandbox, Credits, Custom, Intermission, Secret, PrimeSanctum, Unknown }
+
+        /// <summary>
+        /// Returns the current level type
+        /// </summary>
+        public static UKLevelType CurrentLevelType = UKLevelType.Intro;
+
+        /// <summary>
+        /// Returns the currently active ultrakill scene name.
+        /// </summary>
+        public static string CurrentSceneName = "";
+
+        public delegate void OnLevelChangedHandler(UKLevelType uKLevelType);
+
+        /// <summary>
+        /// Invoked whenever the current level type is changed.
+        /// </summary>
+        public static OnLevelChangedHandler OnLevelTypeChanged;
+
+        /// <summary>
+        /// Invoked whenever the scene is changed.
+        /// </summary>
+        public static OnLevelChangedHandler OnLevelChanged;
+
+        //Perhaps there is a better way to do this.
+        private static void OnSceneLoad(Scene scene, LoadSceneMode loadSceneMode)
+        {
+            string sceneName = scene.name;
+
+            if (scene != SceneManager.GetActiveScene())
+                return;
+
+            UKLevelType newScene = GetUKLevelType(sceneName);
+
+            if (newScene != CurrentLevelType)
+            {
+                CurrentLevelType = newScene;
+                CurrentSceneName = scene.name;
+                OnLevelTypeChanged?.Invoke(newScene);
+            }
+
+            OnLevelChanged?.Invoke(CurrentLevelType);
+        }
+
+        //Perhaps there is a better way to do this. Also this will most definitely cause problems in the future if PITR or Hakita rename any scenes.
+
+        /// <summary>
+        /// Gets enumerated level type from the name of a scene.
+        /// </summary>
+        /// <param name="sceneName">Name of the scene</param>
+        /// <returns></returns>
+        public static UKLevelType GetUKLevelType(string sceneName)
+        {
+            sceneName = (sceneName.Contains("P-")) ? "Sanctum" : sceneName;
+            sceneName = (sceneName.Contains("-S")) ? "Secret" : sceneName;
+            sceneName = (sceneName.Contains("Level")) ? "Level" : sceneName;
+            sceneName = (sceneName.Contains("Intermission")) ? "Intermission" : sceneName;
+
+            switch (sceneName)
+            {
+                case "Main Menu":
+                    return UKLevelType.MainMenu;
+                case "Custom Content":
+                    return UKLevelType.Custom;
+                case "Intro":
+                    return UKLevelType.Intro;
+                case "Endless":
+                    return UKLevelType.Endless;
+                case "uk_construct":
+                    return UKLevelType.Sandbox;
+                case "Intermission":
+                    return UKLevelType.Intermission;
+                case "Level":
+                    return UKLevelType.Level;
+                case "Secret":
+                    return UKLevelType.Secret;
+                case "Sanctum":
+                    return UKLevelType.PrimeSanctum;
+                case "Credits":
+                    return UKLevelType.Credits;
+                default:
+                    return UKLevelType.Unknown;
+            }
+        }
+
+        /// <summary>
+        /// Returns true if the current scene is playable.
+        /// This will return false for all secret levels.
+        /// </summary>
+        /// <returns></returns>
+        public static bool InLevel()
+        {
+            bool inNonPlayable = (CurrentLevelType == UKLevelType.MainMenu || CurrentLevelType == UKLevelType.Intro || CurrentLevelType == UKLevelType.Intermission || CurrentLevelType == UKLevelType.Secret || CurrentLevelType == UKLevelType.Unknown);
+            return !inNonPlayable;
+        }
+    }
+}
\ No newline at end of file