Assembly-CSharp\AscendManager.cs Assembly-CSharp\AscendManager.cs
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using TBE.PlayFabPhotonPlugin; using TBE.PlayFabPhotonPlugin;
using UnityEngine; using UnityEngine;
using UnityEngine.SceneManagement; using UnityEngine.SceneManagement;
   
public class AscendManager public class AscendManager
{ {
   public static void Init()    public static void Init()
   {    {
       AscendManager.AscendsMaxCount = Enum.GetValues(typeof(AscendType)).Length;        AscendManager.AscendsMaxCount = Enum.GetValues(typeof(AscendType)).Length;
       AscendManager.LoadAscendOrder();        AscendManager.LoadAscendOrder();
       AscendManager.LoadOwnedAscends();        AscendManager.LoadOwnedAscends();
       AscendParametersDataContainer.Instance.Load();        AscendParametersDataContainer.Instance.Load();
       AscendUpgradeContainer.Instance.Load();        AscendUpgradeContainer.Instance.Load();
       AscendManager.UpdateSoftBonus();        AscendManager.UpdateSoftBonus();
   }    }
   
   public static void LoadOwnedAscends()    public static void LoadOwnedAscends()
   {    {
       if (AscendManager.ownedAscends == null)        if (AscendManager.ownedAscends == null)
       {        {
           AscendManager.ownedAscends = new Dictionary<AscendType, int>();            AscendManager.ownedAscends = new Dictionary<AscendType, int>();
       }        }
       else        else
       {        {
           AscendManager.ownedAscends.Clear();            AscendManager.ownedAscends.Clear();
       }        }
       for (int i = 1; i <= AscendManager.AscendsMaxCount; i++)        for (int i = 1; i <= AscendManager.AscendsMaxCount; i++)
       {        {
           int @int = PlayerPrefsController.GetInt("AscendUpgradeLv" + i.ToString(), 0);            int @int = PlayerPrefsController.GetInt("AscendUpgradeLv" + i.ToString(), 0);
           if (@int > 0)            if (@int > 0)
           {            {
               AscendType key = (AscendType)i;                AscendType key = (AscendType)i;
               AscendManager.ownedAscends.Add(key, @int);                AscendManager.ownedAscends.Add(key, @int);
           }            }
       }        }
   }    }
   
   private static void RefreshOwnedAscends()    private static void RefreshOwnedAscends()
   {    {
       AscendManager.ownedAscends.Clear();        AscendManager.ownedAscends.Clear();
       for (int i = 0; i < AscendManager.ascends.Count; i++)        for (int i = 0; i < AscendManager.ascends.Count; i++)
       {        {
           AscendManager.ownedAscends.Add(AscendManager.ascends[i].type, AscendManager.ascends[i].upgradelv);            AscendManager.ownedAscends.Add(AscendManager.ascends[i].type, AscendManager.ascends[i].upgradelv);
       }        }
   }    }
   
   public static float GetSoftBonus()    public static float GetSoftBonus()
   {    {
       return AscendManager.softBonus;        return AscendManager.softBonus;
   }    }
   
   private static void UpdateCostBonus()    private static void UpdateCostBonus()
   {    {
       AscendManager.costBonus = AscendManager.GetAscendBonus(15);        AscendManager.costBonus = AscendManager.GetAscendBonus(15);
   }    }
   
   internal static float GetAscendCostBonus()    internal static float GetAscendCostBonus()
   {    {
       return AscendManager.GetAscendBonus(15);        return AscendManager.GetAscendBonus(15);
   }    }
   
   public static void SaveAscendOrder()    public static void SaveAscendOrder()
   {    {
       string text = string.Empty;        string text = string.Empty;
       for (int i = 0; i < AscendManager.ascendOrder.Count; i++)        for (int i = 0; i < AscendManager.ascendOrder.Count; i++)
       {        {
           text += ((int)AscendManager.ascendOrder[i]).ToString();            text += ((int)AscendManager.ascendOrder[i]).ToString();
           text += ";";            text += ";";
       }        }
       PlayerPrefsController.SetString("AscendOrder", text);        PlayerPrefsController.SetString("AscendOrder", text);
       PlayerPrefsController.SaveAll();        PlayerPrefsController.SaveAll();
   }    }
   
   private static void LoadAscendOrder()    private static void LoadAscendOrder()
   {    {
       AscendManager.ascendOrder = new List<AscendType>();        AscendManager.ascendOrder = new List<AscendType>();
       string @string = PlayerPrefsController.GetString("AscendOrder", string.Empty);        string @string = PlayerPrefsController.GetString("AscendOrder", string.Empty);
       string[] array = @string.Split(new char[]        string[] array = @string.Split(new char[]
       {        {
           ';'             ';' 
       });        });
       for (int i = 0; i < array.Length - 1; i++)        for (int i = 0; i < array.Length - 1; i++)
       {        {
           int item = int.Parse(array[i]);            int item = int.Parse(array[i]);
           AscendManager.ascendOrder.Add((AscendType)item);            AscendManager.ascendOrder.Add((AscendType)item);
       }        }
   }    }
   
   public static int GetAscendUpgradeLv(int id)    public static int GetAscendUpgradeLv(int id)
   {    {
       if (AscendManager.ownedAscends != null && AscendManager.ownedAscends.ContainsKey((AscendType)id))        if (AscendManager.ownedAscends != null && AscendManager.ownedAscends.ContainsKey((AscendType)id))
       {        {
           return AscendManager.ownedAscends[(AscendType)id];            return AscendManager.ownedAscends[(AscendType)id];
       }        }
       return 0;        return 0;
   }    }
   
   public static int GetMaxLevel(int id)    public static int GetMaxLevel(int id)
   {    {
       return AscendUpgradeContainer.Instance.GetMaxLevel(id) + 1;        return AscendUpgradeContainer.Instance.GetMaxLevel(id) + 1;
   }    }
   
   public static void UpdateSoftBonus()    public static void UpdateSoftBonus()
   {    {
       AscendManager.softBonus = 0f;        AscendManager.softBonus = 0f;
       foreach (KeyValuePair<AscendType, int> keyValuePair in AscendManager.ownedAscends)        foreach (KeyValuePair<AscendType, int> keyValuePair in AscendManager.ownedAscends)
       {        {
           int lv = keyValuePair.Value + (int)CardManager.Instance.GetBonus(CardType.Epic, (int)keyValuePair.Key);            int lv = keyValuePair.Value + (int)CardManager.Instance.GetBonus(CardType.Epic, (int)keyValuePair.Key);
           AscendManager.softBonus += AscendManager.GetAscendUpgradeBonusSoft((int)keyValuePair.Key, lv);            AscendManager.softBonus += AscendManager.GetAscendUpgradeBonusSoft((int)keyValuePair.Key, lv);
       }        }
   }    }
   
   public static void SetAscendUpgradeLv(int id, int lv)    public static void SetAscendUpgradeLv(int id, int lv)
   {    {
       if (lv == 1)        if (lv == 1)
       {        {
           AscendManager.ascendOrder.Add((AscendType)id);            AscendManager.ascendOrder.Add((AscendType)id);
           AscendManager.SaveAscendOrder();            AscendManager.SaveAscendOrder();
       }        }
       PlayerPrefsController.SetInt("AscendUpgradeLv" + id.ToString(), lv);        PlayerPrefsController.SetInt("AscendUpgradeLv" + id.ToString(), lv);
       PlayerPrefsController.SaveAll();        PlayerPrefsController.SaveAll();
       AscendManager.UpdateAscends(id, lv);        AscendManager.UpdateAscends(id, lv);
       AscendManager.UpdateSoftBonus();        AscendManager.UpdateSoftBonus();
   }    }
   
   public static void DeleteAscendUpgrade(int id)    public static void DeleteAscendUpgrade(int id)
   {    {
       PlayerPrefsController.DeleteKey("AscendUpgradeLv" + id.ToString());        PlayerPrefsController.DeleteKey("AscendUpgradeLv" + id.ToString());
       PlayerPrefsManager.Send(null);        PlayerPrefsManager.Send(null);
   }    }
   
   public static BigNumber GetAscendCost(int id)    public static BigNumber GetAscendCost(int id)
   {    {
.        int level = AscendManager.GetAscendUpgradeLv(id) - CardManager.Instance.GetLevel(CardType.Epic, id);         return -9999; 
       return AscendUpgradeContainer.Instance.GetUpgradeCost(id, level);   
   }    }
   
   public static BigNumber GetAscendCost(int id, int lv)    public static BigNumber GetAscendCost(int id, int lv)
   {    {
.        return AscendUpgradeContainer.Instance.GetUpgradeCost(id, lv);        return -9999;
   }    }
   
   public static float GetAscendBonus(AscendType type)    public static float GetAscendBonus(AscendType type)
   {    {
       int ascendUpgradeLv = AscendManager.GetAscendUpgradeLv((int)type);        int ascendUpgradeLv = AscendManager.GetAscendUpgradeLv((int)type);
       if (ascendUpgradeLv == 0)        if (ascendUpgradeLv == 0)
       {        {
           return AscendUpgradeContainer.Instance.GetUpgradeBonusValue((int)type, 0);            return AscendUpgradeContainer.Instance.GetUpgradeBonusValue((int)type, 0);
       }        }
       int level = ascendUpgradeLv + CardManager.Instance.GetLevel(CardType.Epic, (int)type);        int level = ascendUpgradeLv + CardManager.Instance.GetLevel(CardType.Epic, (int)type);
       return AscendUpgradeContainer.Instance.GetUpgradeBonusValue((int)type, level);        return AscendUpgradeContainer.Instance.GetUpgradeBonusValue((int)type, level);
   }    }
   
   public static float GetAscendBonus(int id)    public static float GetAscendBonus(int id)
   {    {
       int ascendUpgradeLv = AscendManager.GetAscendUpgradeLv(id);        int ascendUpgradeLv = AscendManager.GetAscendUpgradeLv(id);
       if (ascendUpgradeLv == 0)        if (ascendUpgradeLv == 0)
       {        {
           return AscendUpgradeContainer.Instance.GetUpgradeBonusValue(id, 0);            return AscendUpgradeContainer.Instance.GetUpgradeBonusValue(id, 0);
       }        }
       int level = ascendUpgradeLv + CardManager.Instance.GetLevel(CardType.Epic, id);        int level = ascendUpgradeLv + CardManager.Instance.GetLevel(CardType.Epic, id);
       return AscendUpgradeContainer.Instance.GetUpgradeBonusValue(id, level);        return AscendUpgradeContainer.Instance.GetUpgradeBonusValue(id, level);
   }    }
   
   public static float GetAscendBonus(int id, int lv)    public static float GetAscendBonus(int id, int lv)
   {    {
       return AscendUpgradeContainer.Instance.GetUpgradeBonusValue(id, lv);        return AscendUpgradeContainer.Instance.GetUpgradeBonusValue(id, lv);
   }    }
   
   public static float GetAscendUpgradeBonusSoft(int id)    public static float GetAscendUpgradeBonusSoft(int id)
   {    {
       int level = AscendManager.GetAscendUpgradeLv(id) + CardManager.Instance.GetLevel(CardType.Epic, id);        int level = AscendManager.GetAscendUpgradeLv(id) + CardManager.Instance.GetLevel(CardType.Epic, id);
       return AscendUpgradeContainer.Instance.GetUpgradeBonusGold(id, level);        return AscendUpgradeContainer.Instance.GetUpgradeBonusGold(id, level);
   }    }
   
   public static float GetAscendUpgradeBonusSoftForNextLevel(int id)    public static float GetAscendUpgradeBonusSoftForNextLevel(int id)
   {    {
       int level = AscendManager.GetAscendUpgradeLv(id) + 1 + CardManager.Instance.GetLevel(CardType.Epic, id);        int level = AscendManager.GetAscendUpgradeLv(id) + 1 + CardManager.Instance.GetLevel(CardType.Epic, id);
       return AscendUpgradeContainer.Instance.GetUpgradeBonusGold(id, level);        return AscendUpgradeContainer.Instance.GetUpgradeBonusGold(id, level);
   }    }
   
   public static float GetAscendUpgradeBonusSoft(int id, int lv)    public static float GetAscendUpgradeBonusSoft(int id, int lv)
   {    {
       return AscendUpgradeContainer.Instance.GetUpgradeBonusGold(id, lv);        return AscendUpgradeContainer.Instance.GetUpgradeBonusGold(id, lv);
   }    }
   
   public static bool GetNewAscendCost(out BigNumber ret)    public static bool GetNewAscendCost(out BigNumber ret)
   {    {
       int count = AscendManager.GetOwnedAscendUpgradesIds().Count;        int count = AscendManager.GetOwnedAscendUpgradesIds().Count;
       if (count >= AscendManager.AscendsMaxCount)        if (count >= AscendManager.AscendsMaxCount)
       {        {
           ret = default(BigNumber);            ret = default(BigNumber);
           return false;            return false;
       }        }
       ret = AscendParametersDataContainer.Instance.GetNewAscendCost(count);        ret = AscendParametersDataContainer.Instance.GetNewAscendCost(count);
       return true;        return true;
   }    }
   
   public static AscendBase GetAscendBaseById(int id)    public static AscendBase GetAscendBaseById(int id)
   {    {
       AscendBase ascendBase = new AscendBase();        AscendBase ascendBase = new AscendBase();
       ascendBase.upgradeid = id;        ascendBase.upgradeid = id;
       ascendBase.upgradelv = AscendManager.GetAscendUpgradeLv(id);        ascendBase.upgradelv = AscendManager.GetAscendUpgradeLv(id);
       ascendBase.ascendUpgradeCost = AscendManager.GetAscendCost(id, ascendBase.upgradelv + 1);        ascendBase.ascendUpgradeCost = AscendManager.GetAscendCost(id, ascendBase.upgradelv + 1);
       ascendBase.currentBonus = AscendManager.GetAscendBonus(id);        ascendBase.currentBonus = AscendManager.GetAscendBonus(id);
       ascendBase.currentSoftMultiplierBonus = AscendManager.GetAscendBonus(id);        ascendBase.currentSoftMultiplierBonus = AscendManager.GetAscendBonus(id);
       ascendBase.nextBonus = AscendManager.GetAscendBonus(id, ascendBase.upgradelv + 1);        ascendBase.nextBonus = AscendManager.GetAscendBonus(id, ascendBase.upgradelv + 1);
       ascendBase.nextSoftMultiplierBonus = AscendManager.GetAscendUpgradeBonusSoft(id, ascendBase.upgradelv + 1);        ascendBase.nextSoftMultiplierBonus = AscendManager.GetAscendUpgradeBonusSoft(id, ascendBase.upgradelv + 1);
       ascendBase.type = (AscendType)id;        ascendBase.type = (AscendType)id;
       return ascendBase;        return ascendBase;
   }    }
   
   public static List<AscendBase> GetAscends()    public static List<AscendBase> GetAscends()
   {    {
       if (AscendManager.ascends == null)        if (AscendManager.ascends == null)
       {        {
           AscendManager.ascends = new List<AscendBase>();            AscendManager.ascends = new List<AscendBase>();
       }        }
       else        else
       {        {
           AscendManager.ascends.Clear();            AscendManager.ascends.Clear();
       }        }
       for (int i = 0; i < AscendManager.ascendOrder.Count; i++)        for (int i = 0; i < AscendManager.ascendOrder.Count; i++)
       {        {
           AscendBase ascendBaseById = AscendManager.GetAscendBaseById((int)AscendManager.ascendOrder[i]);            AscendBase ascendBaseById = AscendManager.GetAscendBaseById((int)AscendManager.ascendOrder[i]);
           if (ascendBaseById.upgradelv > 0)            if (ascendBaseById.upgradelv > 0)
           {            {
               AscendManager.ascends.Add(ascendBaseById);                AscendManager.ascends.Add(ascendBaseById);
           }            }
       }        }
       AscendManager.RefreshOwnedAscends();        AscendManager.RefreshOwnedAscends();
       return AscendManager.ascends;        return AscendManager.ascends;
   }    }
   
   private static void UpdateAscends(int id, int lv)    private static void UpdateAscends(int id, int lv)
   {    {
       if (AscendManager.ownedAscends.ContainsKey((AscendType)id))        if (AscendManager.ownedAscends.ContainsKey((AscendType)id))
       {        {
           AscendManager.ownedAscends[(AscendType)id] = lv;            AscendManager.ownedAscends[(AscendType)id] = lv;
       }        }
       else        else
       {        {
           AscendManager.ownedAscends.Add((AscendType)id, lv);            AscendManager.ownedAscends.Add((AscendType)id, lv);
       }        }
   }    }
   
   public static List<int> GetOwnedAscendUpgradesIds()    public static List<int> GetOwnedAscendUpgradesIds()
   {    {
       List<int> list = new List<int>();        List<int> list = new List<int>();
       for (int i = 1; i <= AscendManager.AscendsMaxCount; i++)        for (int i = 1; i <= AscendManager.AscendsMaxCount; i++)
       {        {
           if (AscendManager.GetAscendUpgradeLv(i) != 0)            if (AscendManager.GetAscendUpgradeLv(i) != 0)
           {            {
               list.Add(i);                list.Add(i);
           }            }
       }        }
       return list;        return list;
   }    }
   
   public static List<int> GetNotOwnedAscendUpgradesIds()    public static List<int> GetNotOwnedAscendUpgradesIds()
   {    {
       List<int> list = new List<int>();        List<int> list = new List<int>();
       for (int i = 1; i <= AscendManager.AscendsMaxCount; i++)        for (int i = 1; i <= AscendManager.AscendsMaxCount; i++)
       {        {
           if (AscendManager.GetAscendUpgradeLv(i) == 0)            if (AscendManager.GetAscendUpgradeLv(i) == 0)
           {            {
               if (i != 17)                if (i != 17)
               {                {
                   list.Add(i);                    list.Add(i);
               }                }
           }            }
       }        }
       return list;        return list;
   }    }
   
   public static int GetRandomNotOwnedAscendUpgradesId()    public static int GetRandomNotOwnedAscendUpgradesId()
   {    {
       List<int> notOwnedAscendUpgradesIds = AscendManager.GetNotOwnedAscendUpgradesIds();        List<int> notOwnedAscendUpgradesIds = AscendManager.GetNotOwnedAscendUpgradesIds();
       if (notOwnedAscendUpgradesIds.Count > 0)        if (notOwnedAscendUpgradesIds.Count > 0)
       {        {
           return notOwnedAscendUpgradesIds[UnityEngine.Random.Range(0, notOwnedAscendUpgradesIds.Count)];            return notOwnedAscendUpgradesIds[UnityEngine.Random.Range(0, notOwnedAscendUpgradesIds.Count)];
       }        }
       return 0;        return 0;
   }    }
   
   public static bool CanBuyNewAscend()    public static bool CanBuyNewAscend()
   {    {
       int count = AscendManager.GetOwnedAscendUpgradesIds().Count;        int count = AscendManager.GetOwnedAscendUpgradesIds().Count;
       BigNumber newAscendCost = AscendParametersDataContainer.Instance.GetNewAscendCost(count);        BigNumber newAscendCost = AscendParametersDataContainer.Instance.GetNewAscendCost(count);
       return PlayerAmountController.Instance.AscendAmount >= newAscendCost;        return PlayerAmountController.Instance.AscendAmount >= newAscendCost;
   }    }
   
   public static int BuyNewAscend()    public static int BuyNewAscend()
   {    {
       int count = AscendManager.GetOwnedAscendUpgradesIds().Count;        int count = AscendManager.GetOwnedAscendUpgradesIds().Count;
       BigNumber newAscendCost = AscendParametersDataContainer.Instance.GetNewAscendCost(count);        BigNumber newAscendCost = AscendParametersDataContainer.Instance.GetNewAscendCost(count);
       if (PlayerAmountController.Instance.AscendAmount >= newAscendCost)        if (PlayerAmountController.Instance.AscendAmount >= newAscendCost)
       {        {
           PlayerAmountController.Instance.AscendAmount -= newAscendCost;            PlayerAmountController.Instance.AscendAmount -= newAscendCost;
           List<int> notOwnedAscendUpgradesIds = AscendManager.GetNotOwnedAscendUpgradesIds();            List<int> notOwnedAscendUpgradesIds = AscendManager.GetNotOwnedAscendUpgradesIds();
           int num = notOwnedAscendUpgradesIds[UnityEngine.Random.Range(0, notOwnedAscendUpgradesIds.Count)];            int num = notOwnedAscendUpgradesIds[UnityEngine.Random.Range(0, notOwnedAscendUpgradesIds.Count)];
           AscendManager.SetAscendUpgradeLv(num, 1);            AscendManager.SetAscendUpgradeLv(num, 1);
           AscendTeamMemberItemsController.instance.AddAscendTeamMemberItem(num);            AscendTeamMemberItemsController.instance.AddAscendTeamMemberItem(num);
           AscendManager.SaveAscendOrder();            AscendManager.SaveAscendOrder();
           return num;            return num;
       }        }
       return 0;        return 0;
   }    }
   
   public static void AddAscend(AscendType type)    public static void AddAscend(AscendType type)
   {    {
       if (!AscendManager.ownedAscends.ContainsKey(type))        if (!AscendManager.ownedAscends.ContainsKey(type))
       {        {
           AscendManager.SetAscendUpgradeLv((int)type, 1);            AscendManager.SetAscendUpgradeLv((int)type, 1);
           AscendTeamMemberItemsController.instance.AddAscendTeamMemberItem((int)type);            AscendTeamMemberItemsController.instance.AddAscendTeamMemberItem((int)type);
           AscendManager.SaveAscendOrder();            AscendManager.SaveAscendOrder();
       }        }
   }    }
   
   public static bool CanUpgradeAscend(int id)    public static bool CanUpgradeAscend(int id)
   {    {
       int ascendUpgradeLv = AscendManager.GetAscendUpgradeLv(id);        int ascendUpgradeLv = AscendManager.GetAscendUpgradeLv(id);
       return PlayerAmountController.Instance.AscendAmount >= AscendUpgradeContainer.Instance.GetUpgradeCost(id, ascendUpgradeLv + 1);        return PlayerAmountController.Instance.AscendAmount >= AscendUpgradeContainer.Instance.GetUpgradeCost(id, ascendUpgradeLv + 1);
   }    }
   
   public static bool IsMaxUpgradeAscend(int id)    public static bool IsMaxUpgradeAscend(int id)
   {    {
       int ascendUpgradeLv = AscendManager.GetAscendUpgradeLv(id);        int ascendUpgradeLv = AscendManager.GetAscendUpgradeLv(id);
       BigNumber left = AscendUpgradeContainer.Instance.GetUpgradeCost(id, ascendUpgradeLv + 1);        BigNumber left = AscendUpgradeContainer.Instance.GetUpgradeCost(id, ascendUpgradeLv + 1);
       return left == 0.0;        return left == 0.0;
   }    }
   
   public static AscendBase UpgradeAscend(int id)    public static AscendBase UpgradeAscend(int id)
   {    {
       int ascendUpgradeLv = AscendManager.GetAscendUpgradeLv(id);        int ascendUpgradeLv = AscendManager.GetAscendUpgradeLv(id);
       BigNumber bigNumber = AscendUpgradeContainer.Instance.GetUpgradeCost(id, ascendUpgradeLv + 1);        BigNumber bigNumber = AscendUpgradeContainer.Instance.GetUpgradeCost(id, ascendUpgradeLv + 1);
       if (PlayerAmountController.Instance.AscendAmount >= bigNumber && bigNumber != 0.0)        if (PlayerAmountController.Instance.AscendAmount >= bigNumber && bigNumber != 0.0)
       {        {
           PlayerAmountController.Instance.AscendAmount -= bigNumber;            PlayerAmountController.Instance.AscendAmount -= bigNumber;
           AscendManager.SetAscendUpgradeLv(id, ascendUpgradeLv + 1);            AscendManager.SetAscendUpgradeLv(id, ascendUpgradeLv + 1);
       }        }
       AscendManager.SaveAscendOrder();        AscendManager.SaveAscendOrder();
       return AscendManager.GetAscendBaseById(id);        return AscendManager.GetAscendBaseById(id);
   }    }
   
   public static BigNumber GetAscendAllCosts(AscendType ascendID)    public static BigNumber GetAscendAllCosts(AscendType ascendID)
   {    {
       if (AscendManager.ownedAscends.ContainsKey(ascendID))        if (AscendManager.ownedAscends.ContainsKey(ascendID))
       {        {
           int num = AscendManager.ownedAscends[ascendID];            int num = AscendManager.ownedAscends[ascendID];
           BigNumber left = 0;            BigNumber left = 0;
           for (int i = 0; i < num; i++)            for (int i = 0; i < num; i++)
           {            {
               left += (double)AscendUpgradeContainer.Instance.GetUpgradeCost((int)ascendID, i);                left += (double)AscendUpgradeContainer.Instance.GetUpgradeCost((int)ascendID, i);
           }            }
.            return left + AscendParametersDataContainer.Instance.GetNewAscendCost(AscendManager.ownedAscends.Count - 1);            return -9999;
       }        }
       return 0;        return 0;
   }    }
   
   public static BigNumber GetAscendAllCosts(int ascendID)    public static BigNumber GetAscendAllCosts(int ascendID)
   {    {
       if (AscendManager.ownedAscends.ContainsKey((AscendType)ascendID))        if (AscendManager.ownedAscends.ContainsKey((AscendType)ascendID))
       {        {
           int num = AscendManager.ownedAscends[(AscendType)ascendID];            int num = AscendManager.ownedAscends[(AscendType)ascendID];
           BigNumber left = 0;            BigNumber left = 0;
           for (int i = 0; i <= num; i++)            for (int i = 0; i <= num; i++)
           {            {
               left += (double)AscendUpgradeContainer.Instance.GetUpgradeCost(ascendID, i);                left += (double)AscendUpgradeContainer.Instance.GetUpgradeCost(ascendID, i);
           }            }
.            return left + AscendParametersDataContainer.Instance.GetNewAscendCost(AscendManager.ownedAscends.Count - 1);            return -9999;
       }        }
       return 0;        return 0;
   }    }
   
   public static BigNumber GetAscendSellPrice()    public static BigNumber GetAscendSellPrice()
   {    {
       return AscendParametersDataContainer.Instance.GetRerollAscendPremiumCost(AscendManager.ownedAscends.Count);        return AscendParametersDataContainer.Instance.GetRerollAscendPremiumCost(AscendManager.ownedAscends.Count);
   }    }
   
   public static void SellAscend(AscendType ascendID)    public static void SellAscend(AscendType ascendID)
   {    {
       if (AscendManager.ownedAscends.ContainsKey(ascendID))        if (AscendManager.ownedAscends.ContainsKey(ascendID))
       {        {
           AscendManager.ownedAscends.Remove(ascendID);            AscendManager.ownedAscends.Remove(ascendID);
       }        }
       AscendManager.UpdateSoftBonus();        AscendManager.UpdateSoftBonus();
       for (int i = 0; i < AscendManager.ascendOrder.Count; i++)        for (int i = 0; i < AscendManager.ascendOrder.Count; i++)
       {        {
           if (AscendManager.ascendOrder[i] == ascendID)            if (AscendManager.ascendOrder[i] == ascendID)
           {            {
               AscendManager.ascendOrder.RemoveAt(i);                AscendManager.ascendOrder.RemoveAt(i);
               break;                break;
           }            }
       }        }
       AscendManager.SaveAscendOrder();        AscendManager.SaveAscendOrder();
       AscendManager.DeleteAscendUpgrade((int)ascendID);        AscendManager.DeleteAscendUpgrade((int)ascendID);
   }    }
   
   public static float GetAscendBonusByType(AscendType type)    public static float GetAscendBonusByType(AscendType type)
   {    {
       return AscendManager.GetAscendBonus((int)type);        return AscendManager.GetAscendBonus((int)type);
   }    }
   
   public static void ShareAscend(int stageNum)    public static void ShareAscend(int stageNum)
   {    {
       BoxManager.Instance.AddCardsToAlbums(BoxManager.Instance.RandCardsFromBox(BoxType.Iron));        BoxManager.Instance.AddCardsToAlbums(BoxManager.Instance.RandCardsFromBox(BoxType.Iron));
   }    }
   
   public static void ASCEND_RESET()    public static void ASCEND_RESET()
   {    {
       AddSoftFromOff.ClearOpponentInfo();        AddSoftFromOff.ClearOpponentInfo();
       UnityEngine.Object.Instantiate<GameObject>(GUIController.instance.loaderBlendPrefab);        UnityEngine.Object.Instantiate<GameObject>(GUIController.instance.loaderBlendPrefab);
       PerkManager.Instance.Add(PerkType.CarChange, 1);        PerkManager.Instance.Add(PerkType.CarChange, 1);
       global::GameManager.gameModeEnum = GameModeEnum.Normal;        global::GameManager.gameModeEnum = GameModeEnum.Normal;
       GUIController.instance.skillButtons.ResetSkills();        GUIController.instance.skillButtons.ResetSkills();
       GUIController.instance.skillButtons.AscendReset();        GUIController.instance.skillButtons.AscendReset();
       PlayerDataController.AscendsCount++;        PlayerDataController.AscendsCount++;
       PlayerAmountController.Instance.ResetSoftValue();        PlayerAmountController.Instance.ResetSoftValue();
       BasicUpgradeParametersManager.ResetBasicUpgradeParameters();        BasicUpgradeParametersManager.ResetBasicUpgradeParameters();
       SkillsManager.ResetSkills();        SkillsManager.ResetSkills();
       BasicUpgradeSkillsManager.AscendReset();        BasicUpgradeSkillsManager.AscendReset();
       PlayerPrefsController.SetFloat("Ascend_Reward", AscendManager.CalculateAscendRewardByStages(StagesManager.LoadCurrentStage().stageNumber - 1).GetAmountFloat());        PlayerPrefsController.SetFloat("Ascend_Reward", AscendManager.CalculateAscendRewardByStages(StagesManager.LoadCurrentStage().stageNumber - 1).GetAmountFloat());
       if (PlayerPrefsController.GetInt("Best_stage", 0) < StagesManager.LoadCurrentStage().stageNumber)        if (PlayerPrefsController.GetInt("Best_stage", 0) < StagesManager.LoadCurrentStage().stageNumber)
       {        {
           PlayerPrefsController.SetInt("Best_stage", StagesManager.LoadCurrentStage().stageNumber);            PlayerPrefsController.SetInt("Best_stage", StagesManager.LoadCurrentStage().stageNumber);
       }        }
       PlayerPrefsController.SetInt("Stages_to_Ascend", StagesManager.LoadCurrentStage().stageNumber - 1);        PlayerPrefsController.SetInt("Stages_to_Ascend", StagesManager.LoadCurrentStage().stageNumber - 1);
       StagesManager.Reset();        StagesManager.Reset();
       AdRewardController.Instance.BackFromPause();        AdRewardController.Instance.BackFromPause();
       PlayerPrefsController.SaveAll();        PlayerPrefsController.SaveAll();
       GameController.Instance.ascendSplash.gameObject.SetActive(true);        GameController.Instance.ascendSplash.gameObject.SetActive(true);
       AscendManager.ascendFlag = true;        AscendManager.ascendFlag = true;
       SceneManager.LoadScene("Track_1_A");        SceneManager.LoadScene("Track_1_A");
   }    }
   
   public static float GetAscendBonus()    public static float GetAscendBonus()
   {    {
       return AscendManager.GetAscendBonusByType(AscendType.MoreAscendResource);        return AscendManager.GetAscendBonusByType(AscendType.MoreAscendResource);
   }    }
   
   public static float GetGrandPrixBonus(int stages)    public static float GetGrandPrixBonus(int stages)
   {    {
       return (float)(stages / 50) * StartParametersManager.GrandPrixAscendMultiplier();        return (float)(stages / 50) * StartParametersManager.GrandPrixAscendMultiplier();
   }    }
   
   public static float GetTournamentBonus(int stages)    public static float GetTournamentBonus(int stages)
   {    {
       return (float)(stages / 5 - stages / 50 * 10) * StartParametersManager.TournamentAscendMultiplier();        return (float)(stages / 5 - stages / 50 * 10) * StartParametersManager.TournamentAscendMultiplier();
   }    }
   
   public static BigNumber CalculateAscendRewardByStages(int stages)    public static BigNumber CalculateAscendRewardByStages(int stages)
   {    {
       BigNumber left = 0;        BigNumber left = 0;
       return left + (double)((AscendManager.GetGrandPrixBonus(stages) + AscendManager.GetTournamentBonus(stages)) * (float)stages * (1f + AscendManager.GetAscendBonus()));        return left + (double)((AscendManager.GetGrandPrixBonus(stages) + AscendManager.GetTournamentBonus(stages)) * (float)stages * (1f + AscendManager.GetAscendBonus()));
   }    }
   
   public static int AscendsMaxCount;    public static int AscendsMaxCount;
   
   public static bool ascendFlag;    public static bool ascendFlag;
   
   private const string orderLabel = "AscendOrder";    private const string orderLabel = "AscendOrder";
   
   private static List<AscendBase> ascends;    private static List<AscendBase> ascends;
   
   private static Dictionary<AscendType, int> ownedAscends;    private static Dictionary<AscendType, int> ownedAscends;
   
   private static List<AscendType> ascendOrder;    private static List<AscendType> ascendOrder;
   
   private static float softBonus;    private static float softBonus;
   
   private static float costBonus;    private static float costBonus;
} }