예제 #1
0
        public static void Initialize()
        {
            try
            {
                ModSettings.Version = ModAPI.Mods.LoadedMods["ChampionsOfForest"].Version;
                if (SteamDSConfig.isDedicated)
                {
                    ModAPI.Log.Write("isDedicated true");
                    ModSettings.IsDedicated = true;
                }

                if (ModSettings.IsDedicated)
                {
                    DedicatedServer.COTFDS.ReadDediServerConfig();
                    new GameObject("NetworkManagerObj").AddComponent <Network.NetworkManager>();
                    GameObject go = new GameObject("Playerobj");
                    go.AddComponent <ModReferences>();
                    ItemDataBase.Initialize();
                    EnemyManager.Initialize();
                    Network.NetworkManager.instance.onGetMessage += Network.CommandReader.OnCommand;
                    ExpEvents.Initialize();
                    return;
                }

                ModSettings.DifficultyChosen = false;
                if (SceneManager.GetActiveScene().name == "TitleScene")
                {
                    new GameObject("Resource Manager").AddComponent <ResourceLoader>();
                    ResourceLoader.InMainMenu = true;
                    MainMenuVisual.Create();
                }
                else
                {
                    ResourceLoader.InMainMenu = false;
                    NetworkPlayerStats.Reset();
                    COTFEvents.ClearEvents();

                    new GameObject("NetworkManagerObj").AddComponent <Network.NetworkManager>();
                    GameObject go           = new GameObject("__COTFPlayerobj__");
                    var        moddedPlayer = go.AddComponent <ModdedPlayer>();
                    moddedPlayer.SetStats();
                    go.AddComponent <Inventory>();
                    go.AddComponent <ModReferences>();
                    go.AddComponent <SpellCaster>();
                    go.AddComponent <ClientItemPicker>();
                    go.AddComponent <MeteorSpawner>();
                    go.AddComponent <BlackFlame>();
                    go.AddComponent <AsyncHit>();
                    go.AddComponent <GlobalSFX>();
                    go.AddComponent <TheFartCreator>();
                    go.AddComponent <RCoroutines>();
                    go.AddComponent <ActiveSpellManager>();
                    new GameObject("MainMenuObj").AddComponent <MainMenu>();


                    // go.AddComponent<Crafting>();
                    Network.CommandInitializer.Init();
                    CustomCrafting.Init();
                    BuffDB.FillBuffList();
                    ItemDataBase.Initialize();
                    SpellDataBase.Initialize();
                    EnemyManager.Initialize();
                    Network.NetworkManager.instance.onGetMessage += Network.CommandReader.OnCommand;
                    Buildings.InitBuildings();
                    PerkDatabase.FillPerkList();
                    ExpEvents.Initialize();
                    Portal.InitializePortals();
                    CoopCustomWeapons.Init();
                    BallLightning.InitPrefab();
                    ResourceInitializer.SetupMeshesFromOtherAssets();
                    Cataclysm.AssignPrefabs();
                    MarkEnemy.AssignTextures();
                }
            }
            catch (Exception ex)
            {
                ModAPI.Log.Write(ex.ToString());
            }
        }
예제 #2
0
        private void DrawInventory()
        {
            Rect SlotsRect = new Rect(0, 0, Inventory.Width * slotDim.x, Screen.height);

            GUI.Box(SlotsRect, "Inventory", new GUIStyle(GUI.skin.box)
            {
                font = secondaryFont, fontSize = Mathf.RoundToInt(65 * screenScale)
            });
            SelectedItem = -1;

            try
            {
                for (int y = 0; y < Inventory.Height; y++)
                {
                    for (int x = 0; x < Inventory.Width; x++)
                    {
                        int index = y * Inventory.Width + x;

                        DrawInvSlot(new Rect(SlotsRect.x + slotDim.x * x, SlotsRect.y + slotDim.y * y + 160 * screenScale + InventoryScrollAmount, slotDim.x, slotDim.y), index);
                    }
                }

                //PlayerSlots
                Rect eq = new Rect(SlotsRect.xMax + 30 * screenScale, 0, 420 * screenScale, Screen.height);
                GUI.Box(eq, "Equipment", new GUIStyle(GUI.skin.box)
                {
                    font = secondaryFont, fontSize = Mathf.RoundToInt(65 * screenScale)
                });
                Rect head = new Rect(Vector2.zero, slotDim * 2)
                {
                    center = eq.center
                };
                head.y -= 3.5f * head.height;

                Rect chest = new Rect(head);
                chest.y += chest.height + 50 * screenScale;

                Rect pants = new Rect(chest);
                pants.y += pants.height + 50 * screenScale;

                Rect boots = new Rect(pants);
                boots.y += boots.height + 50 * screenScale;

                Rect shoulders = new Rect(chest);
                shoulders.position += new Vector2(-chest.width, -chest.height / 2);

                Rect tallisman = new Rect(chest);
                tallisman.position += new Vector2(chest.width, -chest.height / 2);

                Rect gloves = new Rect(shoulders);
                gloves.y += gloves.height + 50 * screenScale;

                Rect bracer = new Rect(tallisman);
                bracer.y += bracer.height + 50 * screenScale;

                Rect ringR = new Rect(bracer);
                ringR.position += new Vector2(chest.width / 2, chest.height + 50 * screenScale);

                Rect ringL = new Rect(gloves);
                ringL.position += new Vector2(-chest.width / 2, chest.height + 50 * screenScale);

                Rect weapon = new Rect(ringL);
                weapon.y += weapon.height * 1.5f + 50 * screenScale;

                Rect offhand = new Rect(ringR);
                offhand.y += offhand.height * 1.5f + 50 * screenScale;

                DrawInvSlot(head, -2, "Head");
                DrawInvSlot(chest, -3, "Torso");
                DrawInvSlot(pants, -4, "Legs");
                DrawInvSlot(boots, -5, "Feet");
                DrawInvSlot(shoulders, -6, "Shoulders");
                DrawInvSlot(gloves, -7, "Hands");
                DrawInvSlot(tallisman, -8, "Neck");
                DrawInvSlot(bracer, -9, "Wrists");
                DrawInvSlot(ringR, -10, "Finger");
                DrawInvSlot(ringL, -11, "Finger");
                DrawInvSlot(weapon, -12, "Main hand");
                DrawInvSlot(offhand, -13, "Offhand");

                if (ModdedPlayer.Stats.perk_craftingReroll)
                {
                    DrawCrafting(eq.xMax + 30 * screenScale);
                }
            }
            catch (Exception exception)
            {
                ModAPI.Log.Write(exception.ToString());
                DraggedItem      = null;
                DraggedItemIndex = -1;
                isDragging       = false;
            }

            if (SelectedItem != -1)
            {
                if (UnityEngine.Input.GetKey(KeyCode.LeftShift))
                {
                    var targetSlotID = Inventory.Instance.ItemSlots[SelectedItem].destinationSlotID;
                    if (SelectedItem > -1 && targetSlotID != -1 && Inventory.Instance.ItemSlots[targetSlotID] != null)
                    {
                        DrawItemInfo(itemPos, Inventory.Instance.ItemSlots[SelectedItem], true, Inventory.Instance.ItemSlots[targetSlotID]);
                    }
                    else
                    {
                        DrawItemInfo(itemPos, Inventory.Instance.ItemSlots[SelectedItem]);
                    }
                }
                else
                {
                    DrawItemInfo(itemPos, Inventory.Instance.ItemSlots[SelectedItem]);
                }
            }

            if (isDragging)
            {
                Rect r = new Rect(mousePos, slotDim);
                GUI.color = new Color(1, 1, 1, 0.5f);
                GUI.DrawTexture(r, DraggedItem.icon);
                GUI.color = new Color(1, 1, 1, 1);

                if (UnityEngine.Input.GetMouseButtonUp(0))
                {
                    if (DraggedItem.Equipped)
                    {
                        DraggedItem.OnUnequip();
                        Inventory.Instance.ItemSlots[DraggedItemIndex].Equipped = false;
                    }
                    Inventory.Instance.DropItem(DraggedItemIndex);
                    CustomCrafting.ClearIndex(DraggedItemIndex);

                    DraggedItem      = null;
                    DraggedItemIndex = -1;
                    isDragging       = false;
                }
            }
        }
예제 #3
0
        private void DrawInvSlot(Rect r, int index)
        {
            Color frameColor = Color.black;

            GUI.DrawTexture(r, Res.ResourceLoader.instance.LoadedTextures[12]);

            if (Inventory.Instance.ItemSlots[index] != null)
            {
                frameColor = RarityColors[Inventory.Instance.ItemSlots[index].Rarity];
                if (Inventory.Instance.ItemSlots[index].icon != null)
                {
                    Rect  itemRect = new Rect(r);
                    float f        = r.width * 0.15f;
                    itemRect.width  -= f;
                    itemRect.height -= f;
                    itemRect.x      += f / 2;
                    itemRect.y      += f / 2;

                    if (DraggedItemIndex != -1)
                    {
                        if (DraggedItemIndex == index)
                        {
                            GUI.color = new Color(1, 1, 1, 0.5f);
                        }
                    }
                    if (ModdedPlayer.instance.level < Inventory.Instance.ItemSlots[index].level && index < -1)
                    {
                        frameColor = Color.black;
                        GUI.color  = Color.black;
                    }
                    if (CustomCrafting.isIngredient(index))
                    {
                        GUI.color = new Color(0, 0, 0, 0.4f);
                    }
                    else
                    {
                        GUI.color = new Color(1, 1, 1, 1);
                    }

                    GUI.DrawTexture(itemRect, Inventory.Instance.ItemSlots[index].icon);
                    if (Inventory.Instance.ItemSlots[index].StackSize > 1)
                    {
                        GUI.color = Color.white;

                        GUI.Label(r, Inventory.Instance.ItemSlots[index].Amount.ToString("N0"), new GUIStyle(GUI.skin.label)
                        {
                            alignment = TextAnchor.LowerLeft, fontSize = Mathf.RoundToInt(15 * screenScale), font = mainFont, fontStyle = FontStyle.Bold
                        });
                    }

                    if (isDragging)
                    {
                        if (r.Contains(mousePos))
                        {
                            bool canPlace = DraggedItem.CanPlaceInSlot(in index);
                            if (index > -1)
                            {
                                canPlace = true;
                            }
                            if (DraggedItemIndex < 0)
                            {
                                if (DraggedItem.type != Inventory.Instance.ItemSlots[index].type)
                                {
                                    if (DraggedItemIndex == -13)
                                    {
                                        if (Inventory.Instance.ItemSlots[index].type != BaseItem.ItemType.Shield || Inventory.Instance.ItemSlots[index].type != BaseItem.ItemType.Quiver || Inventory.Instance.ItemSlots[index].type != BaseItem.ItemType.SpellScroll)
                                        {
                                            canPlace = false;
                                        }
                                    }
                                    else
                                    {
                                        canPlace = false;
                                    }
                                }
                            }

                            if (canPlace || index > -1)
                            {
                                if (hoveredOverID == index)
                                {
                                    DraggedItemAlpha = Mathf.Clamp(DraggedItemAlpha + Time.unscaledDeltaTime / 2.5f, 0, 0.3f);
                                    GUI.color        = new Color(1, 1, 1, DraggedItemAlpha);
                                    GUI.DrawTexture(itemRect, DraggedItem.icon);
                                    GUI.color = new Color(1, 1, 1, 1);
                                }
                                else
                                {
                                    DraggedItemAlpha = 0;
                                    hoveredOverID    = index;
                                }
                            }
                            if (UnityEngine.Input.GetMouseButtonUp(0))
                            {
                                SelectedItem = index;
                                Effects.Sound_Effects.GlobalSFX.Play(1);
                                if (Inventory.Instance.ItemSlots[index].CombineItems(DraggedItem))
                                {
                                    Inventory.Instance.ItemSlots[DraggedItemIndex].Amount--;
                                    if (Inventory.Instance.ItemSlots[DraggedItemIndex].Amount <= 0)
                                    {
                                        Inventory.Instance.ItemSlots[DraggedItemIndex] = null;
                                    }
                                    DraggedItem      = null;
                                    DraggedItemIndex = -1;
                                    return;
                                }
                                if (index < -1)
                                {
                                    if (canPlace)
                                    {
                                        Inventory.SwapItems(index, DraggedItemIndex);

                                        DraggedItem      = null;
                                        DraggedItemIndex = -1;
                                        isDragging       = false;
                                    }
                                    else
                                    {
                                        Inventory.Instance.ItemSlots[DraggedItemIndex] = DraggedItem;
                                        DraggedItem      = null;
                                        DraggedItemIndex = -1;
                                    }
                                }
                                else
                                {
                                    if (DraggedItem.ID != Inventory.Instance.ItemSlots[index].ID ||
                                        DraggedItem.Amount == DraggedItem.StackSize ||
                                        Inventory.Instance.ItemSlots[index].Amount == Inventory.Instance.ItemSlots[index].StackSize ||
                                        (Inventory.Instance.ItemSlots[index].StackSize <= 1 && DraggedItem.StackSize <= 1))
                                    {
                                        if (canPlace)
                                        {
                                            //replace items
                                            Inventory.SwapItems(index, DraggedItemIndex);
                                            DraggedItem      = null;
                                            DraggedItemIndex = -1;
                                            isDragging       = false;
                                        }
                                    }
                                    else if (DraggedItemIndex != index)
                                    {
                                        //stack items
                                        int i = DraggedItem.Amount + Inventory.Instance.ItemSlots[index].Amount - DraggedItem.StackSize;
                                        if (i > 0)                                          //too much to stack completely
                                        {
                                            Inventory.Instance.ItemSlots[index].Amount            = Inventory.Instance.ItemSlots[index].StackSize;
                                            Inventory.Instance.ItemSlots[DraggedItemIndex].Amount = i;
                                            DraggedItem      = null;
                                            DraggedItemIndex = -1;
                                            isDragging       = false;
                                        }
                                        else                                         //enough to stack completely
                                        {
                                            Inventory.Instance.ItemSlots[index].Amount    += DraggedItem.Amount;
                                            Inventory.Instance.ItemSlots[DraggedItemIndex] = null;

                                            CustomCrafting.ClearIndex(DraggedItemIndex);
                                            DraggedItem      = null;
                                            DraggedItemIndex = -1;
                                            isDragging       = false;
                                        }
                                    }
                                    else
                                    {
                                        DraggedItem      = null;
                                        DraggedItemIndex = -1;
                                        isDragging       = false;
                                    }
                                }
                            }
                        }
                    }
                    else
                    {
                        if (r.Contains(mousePos))
                        {
                            if (UnityEngine.Input.GetMouseButtonDown(0) && !UnityEngine.Input.GetKey(KeyCode.LeftShift) && !UnityEngine.Input.GetKey(KeyCode.LeftControl))
                            {
                                Effects.Sound_Effects.GlobalSFX.Play(0);

                                isDragging       = true;
                                DraggedItem      = Inventory.Instance.ItemSlots[index];
                                DraggedItemIndex = index;
                            }
                            else if (UnityEngine.Input.GetMouseButtonDown(1) && index > -1 && !UnityEngine.Input.GetKey(KeyCode.LeftShift) && !UnityEngine.Input.GetKey(KeyCode.LeftControl))
                            {
                                Effects.Sound_Effects.GlobalSFX.Play(0);

                                if (!consumedsomething)
                                {
                                    consumedsomething = true;
                                    if (Inventory.Instance.ItemSlots[index].OnConsume())
                                    {
                                        Inventory.Instance.ItemSlots[index].Amount--;
                                        if (Inventory.Instance.ItemSlots[index].Amount <= 0)
                                        {
                                            Inventory.Instance.ItemSlots[index] = null;
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
            else
            {
                if (isDragging)
                {
                    if (r.Contains(mousePos))
                    {
                        if (hoveredOverID == index)
                        {
                            Rect  itemRect = new Rect(r);
                            float f        = r.width * 0.15f;
                            itemRect.width  -= f;
                            itemRect.height -= f;
                            itemRect.x      += f / 2;
                            itemRect.y      += f / 2;

                            DraggedItemAlpha = Mathf.Clamp(DraggedItemAlpha + Time.unscaledDeltaTime / 2.5f, 0, 0.3f);
                            GUI.color        = new Color(1, 1, 1, DraggedItemAlpha);
                            GUI.DrawTexture(itemRect, DraggedItem.icon);
                        }
                        else
                        {
                            DraggedItemAlpha = 0;
                            hoveredOverID    = index;
                        }
                    }
                    GUI.color = new Color(1, 1, 1, 1);
                    if (r.Contains(mousePos) && UnityEngine.Input.GetMouseButtonUp(0))
                    {
                        isDragging = false;
                        if (index < -1)
                        {
                            bool canPlace = DraggedItem.CanPlaceInSlot(in index);
                            if (canPlace)
                            {
                                Inventory.Instance.ItemSlots[index]            = DraggedItem;
                                Inventory.Instance.ItemSlots[DraggedItemIndex] = null;
                                CustomCrafting.UpdateIndex(DraggedItemIndex, index);
                                DraggedItem      = null;
                                DraggedItemIndex = -1;
                                Effects.Sound_Effects.GlobalSFX.Play(1);
                            }
                            else
                            {
                                Inventory.Instance.ItemSlots[index]            = null;
                                Inventory.Instance.ItemSlots[DraggedItemIndex] = DraggedItem;
                                DraggedItem      = null;
                                DraggedItemIndex = -1;
                            }
                        }
                        else if (DraggedItemIndex != index)
                        {
                            Inventory.Instance.ItemSlots[index]            = DraggedItem;
                            Inventory.Instance.ItemSlots[DraggedItemIndex] = null;
                            CustomCrafting.UpdateIndex(DraggedItemIndex, index);
                            DraggedItem      = null;
                            DraggedItemIndex = -1;
                            Effects.Sound_Effects.GlobalSFX.Play(1);
                        }
                    }
                }
            }
            GUI.color = frameColor;
            GUI.DrawTexture(r, Res.ResourceLoader.instance.LoadedTextures[13]);
            GUI.color = Color.white;
            if (r.Contains(mousePos))
            {
                if (Inventory.Instance.ItemSlots[index] != null)
                {
                    itemPos      = r.position + r.width * Vector2.right;
                    SelectedItem = index;
                }
                else
                {
                    SelectedItem = -1;
                }
            }
        }
예제 #4
0
        private void Update()
        {
            if (difficultyCooldown > 0)
            {
                difficultyCooldown -= Time.deltaTime;
            }
            LevelUpDuration -= Time.deltaTime;

            if (_openedMenu == OpenedMenuMode.Stats)
            {
                BookScrollAmountGoal = Mathf.Clamp(BookScrollAmountGoal + 500 * screenScale * Input.GetAxis("Mouse ScrollWheel"), -Screen.height * 10 * screenScale, 0);
                if (Input.GetKeyDown(KeyCode.RightArrow))
                {
                    ChangePage(guidePage + 1);
                }
                if (Input.GetKeyDown(KeyCode.LeftArrow))
                {
                    ChangePage(guidePage - 1);
                }
                if (Input.GetKeyDown(KeyCode.DownArrow))
                {
                    BookScrollAmountGoal = Mathf.Clamp(BookScrollAmountGoal - 1000f * screenScale, -Screen.height * 10 * screenScale, 0);
                }
                if (Input.GetKeyDown(KeyCode.UpArrow))
                {
                    BookScrollAmountGoal = Mathf.Clamp(BookScrollAmountGoal + 1000f * screenScale, -Screen.height * 10 * screenScale, 0);
                }
                BookScrollAmount = Vector3.Slerp(new Vector3(BookScrollAmount, 0, 0), new Vector3(BookScrollAmountGoal, 0, 0), Time.deltaTime * 30f * screenScale).x;
            }
            else if (_openedMenu == OpenedMenuMode.Inventory)
            {
                if (Input.GetKeyDown(KeyCode.LeftAlt))
                {
                    drawTotal = !drawTotal;
                }
            }

            try
            {
                PingUpdate();
            }
            catch (Exception exc)
            {
                ModAPI.Console.Write("ERROR with ping update\n" + exc.ToString());
            }

            if (_openedMenu != OpenedMenuMode.Hud)
            {
                if (_openedMenu == OpenedMenuMode.Inventory)
                {
                    if (Input.GetMouseButtonUp(1))
                    {
                        if (consumedsomething)
                        {
                            consumedsomething = false;
                        }
                    }

                    if (SelectedItem != -1 && Inventory.Instance.ItemSlots[SelectedItem] != null)
                    {
                        var item = Inventory.Instance.ItemSlots[SelectedItem];
                        if (Input.GetMouseButtonDown(0))
                        {
                            if (Input.GetKey(KeyCode.LeftShift))
                            {
                                //unequip if equipped
                                if (SelectedItem < -1)
                                {
                                    for (int i = 0; i < Inventory.SlotCount; i++)
                                    {
                                        if (Inventory.Instance.ItemSlots[i] == null)
                                        {
                                            DraggedItem = null;
                                            isDragging  = false;
                                            CustomCrafting.ClearIndex(SelectedItem);
                                            CustomCrafting.ClearIndex(i);
                                            DraggedItemIndex = -1;
                                            Inventory.Instance.ItemSlots[i]            = item;
                                            Inventory.Instance.ItemSlots[SelectedItem] = null;
                                            SelectedItem = -1;
                                            break;
                                        }
                                    }
                                }
                                else                                //move to its correct slot or swap if slot is not empty
                                {
                                    int targetSlot = -1;

                                    switch (item.type)
                                    {
                                    case BaseItem.ItemType.Helmet:
                                        targetSlot = -2;
                                        break;

                                    case BaseItem.ItemType.ChestArmor:
                                        targetSlot = -3;
                                        break;

                                    case BaseItem.ItemType.Pants:
                                        targetSlot = -4;
                                        break;

                                    case BaseItem.ItemType.Boot:
                                        targetSlot = -5;
                                        break;

                                    case BaseItem.ItemType.ShoulderArmor:
                                        targetSlot = -6;
                                        break;

                                    case BaseItem.ItemType.Glove:
                                        targetSlot = -7;
                                        break;

                                    case BaseItem.ItemType.Amulet:
                                        targetSlot = -8;
                                        break;

                                    case BaseItem.ItemType.Bracer:
                                        targetSlot = -9;
                                        break;

                                    case BaseItem.ItemType.Ring:
                                        if (Inventory.Instance.ItemSlots[-10] == null)
                                        {
                                            targetSlot = -10;
                                        }
                                        else if (Inventory.Instance.ItemSlots[-11] == null)
                                        {
                                            targetSlot = -11;
                                        }
                                        else
                                        {
                                            targetSlot = -10;
                                        }
                                        break;

                                    case BaseItem.ItemType.Weapon:
                                        targetSlot = -12;
                                        break;

                                    case BaseItem.ItemType.Quiver:
                                    case BaseItem.ItemType.SpellScroll:
                                    case BaseItem.ItemType.Shield:
                                        targetSlot = -13;
                                        break;
                                    }
                                    if (targetSlot != -1)
                                    {
                                        if (Inventory.Instance.ItemSlots[targetSlot] == null)
                                        {
                                            DraggedItem      = null;
                                            isDragging       = false;
                                            DraggedItemIndex = -1;
                                            CustomCrafting.ClearIndex(SelectedItem);
                                            Inventory.Instance.ItemSlots[targetSlot]   = item;
                                            Inventory.Instance.ItemSlots[SelectedItem] = null;
                                            SelectedItem = -1;
                                        }
                                        else
                                        {
                                            DraggedItem      = null;
                                            isDragging       = false;
                                            DraggedItemIndex = -1;
                                            CustomCrafting.ClearIndex(SelectedItem);
                                            Inventory.Instance.ItemSlots[SelectedItem] = Inventory.Instance.ItemSlots[targetSlot];
                                            Inventory.Instance.ItemSlots[targetSlot]   = item;
                                            SelectedItem = -1;
                                        }
                                    }
                                }
                            }
                            else if (Input.GetKey(KeyCode.LeftControl))
                            {
                                if (SelectedItem > -1 && CustomCrafting.instance.craftMode != CustomCrafting.CraftMode.None)
                                {
                                    if (CustomCrafting.instance.changedItem.i == null)
                                    {
                                        CustomCrafting.instance.changedItem.Assign(SelectedItem, Inventory.Instance.ItemSlots[SelectedItem]);
                                    }
                                    else
                                    {
                                        int max = CustomCrafting.instance.CurrentCraftingMode.IngredientCount;
                                        for (int j = 0; j < max; j++)
                                        {
                                            if (CustomCrafting.Ingredients[j].i == null)
                                            {
                                                if (!(CustomCrafting.Ingredients.Any(x => x.i == item) || CustomCrafting.instance.changedItem.i == item))
                                                {
                                                    CustomCrafting.Ingredients[j].Assign(SelectedItem, item);
                                                    DraggedItem      = null;
                                                    DraggedItemIndex = -1;
                                                    isDragging       = false;
                                                    break;
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
                else if (consumedsomething)
                {
                    consumedsomething = false;
                }
                //LocalPlayer.FpCharacter.LockView(false);
                LevelsToGain = 0;
                if (Input.GetKeyDown(KeyCode.Escape))
                {
                    StartCoroutine(FadeMenuSwitch(OpenedMenuMode.Hud));
                }
            }
            else
            {
                if (LevelsToGain > 0)
                {
                    if (ProgressBarAmount < 1)
                    {
                        ProgressBarAmount = Mathf.MoveTowards(ProgressBarAmount, 1, Time.unscaledDeltaTime * 2);
                    }
                    else
                    {
                        LevelsToGain--;
                        ProgressBarAmount = 0;
                    }
                }
                else
                {
                    if (ProgressBarAmount < (float)ModdedPlayer.instance.ExpCurrent / ModdedPlayer.instance.ExpGoal)
                    {
                        ProgressBarAmount = Mathf.MoveTowards(ProgressBarAmount, Convert.ToSingle((float)ModdedPlayer.instance.ExpCurrent / ModdedPlayer.instance.ExpGoal), Time.unscaledDeltaTime / 2);
                    }
                    else
                    {
                        ProgressBarAmount = Convert.ToSingle((float)ModdedPlayer.instance.ExpCurrent / ModdedPlayer.instance.ExpGoal);
                    }
                }
                ProgressBarAmount = Mathf.Clamp01(ProgressBarAmount);
            }
            isCrouching = LocalPlayer.FpCharacter.crouching;
            if (ModAPI.Input.GetButtonDown("MenuToggle"))
            {
                MenuKeyPressAction();
            }
        }