private void drawUpgradeType(RSUpgrade upgradeType)
        {
            int currentLevel = roverScience.getUpgradeLevel(upgradeType);
            int nextLevel    = currentLevel + 1;
            //double upgradeValueNow = roverScience.getUpgradeValue(upgradeType, currentLevel);
            //double upgradeValueNext = roverScience.getUpgradeValue(upgradeType, (nextLevel));

            string upgradeValueNow  = roverScience.getUpgradeValueString(upgradeType, currentLevel);
            string upgradeValueNext = roverScience.getUpgradeValueString(upgradeType, (nextLevel));

            double upgradeCost = roverScience.getUpgradeCost(upgradeType, (nextLevel));



            GUILayout.BeginHorizontal();

            GUILayout.Label(roverScience.getUpgradeName(upgradeType));
            GUILayout.Space(5);
            GUILayout.Button("Current: " + upgradeValueNow + " [" + currentLevel + "]");
            GUILayout.Button("Next: " + (upgradeValueNext == "-1" ? "MAX" : upgradeValueNext.ToString()));
            GUILayout.Button("Cost: " + (upgradeCost == -1 ? "MAX" : upgradeCost.ToString()));

            if (GUILayout.Button("UP"))
            {
                Debug.Log("Upgrade button pressed - " + upgradeType);
                roverScience.upgradeTech(upgradeType);
            }

            GUILayout.EndHorizontal();
        }
        private void DrawUpgradeType(RSUpgrade upgradeType)
        {
            int currentLevel = roverScience.GetUpgradeLevel(upgradeType);
            int nextLevel    = currentLevel + 1;
            //double upgradeValueNow = roverScience.getUpgradeValue(upgradeType, currentLevel);
            //double upgradeValueNext = roverScience.getUpgradeValue(upgradeType, (nextLevel));

            string upgradeValueNow  = roverScience.GetUpgradeValueString(upgradeType, currentLevel);
            string upgradeValueNext = roverScience.GetUpgradeValueString(upgradeType, (nextLevel));

            double upgradeCost = roverScience.GetUpgradeCost(upgradeType, (nextLevel));



            GUILayout.BeginHorizontal();

            GUILayout.Label(roverScience.GetUpgradeName(upgradeType));
            GUILayout.Space(5);
            GUILayout.Button(Localizer.Format("#LOC_RoverScience_GUI_BtnUpgCurrent", upgradeValueNow, currentLevel));                                                                                 // Current: <<1>> [<<2>>]
            GUILayout.Button(Localizer.Format("#LOC_RoverScience_GUI_BtnUpgNext", (upgradeValueNext == "-1" ? Localizer.GetStringByTag("#LOC_RoverScience_GUI_Max") : upgradeValueNext.ToString()))); // Next <<1>>
            GUILayout.Button(Localizer.Format("#LOC_RoverScience_GUI_BtnUpgCost", (upgradeCost == -1 ? Localizer.GetStringByTag("#LOC_RoverScience_GUI_Max") : upgradeCost.ToString())));             // Cost <<1>>

            if (GUILayout.Button(Localizer.GetStringByTag("#LOC_RoverScience_GUI_BtnUpgrade")))                                                                                                       // UP
            {
                Utilities.LogVerbose("Upgrade button pressed - " + upgradeType);
                roverScience.UpgradeTech(upgradeType);
            }

            GUILayout.EndHorizontal();
        }
 public void SetUpgradeLevel(RSUpgrade upgradeType, int newValue)
 {
         if (upgradeType == RSUpgrade.maxDistance) {
             levelMaxDistance = newValue;
         } else
         if (upgradeType == RSUpgrade.predictionAccuracy) {
             levelPredictionAccuracy = newValue;
         } else
         if (upgradeType == RSUpgrade.analyzedDecay)
         {
             levelAnalyzedDecay = newValue;
         }
 }
 public int GetUpgradeMaxLevel(RSUpgrade upgradeType)
 {
     switch (upgradeType)
     {
         case (RSUpgrade.maxDistance):
             return maximum_levelMaxDistance;
         case (RSUpgrade.predictionAccuracy):
             return maximum_predictionAccuracy;
         case (RSUpgrade.analyzedDecay):
             return maximum_levelAnalyzedDecay;
         default:
             return -1;
     }
 }
        public string GetUpgradeName(RSUpgrade upgrade)
        {
            switch (upgrade)
            {
                case (RSUpgrade.maxDistance):
                    return Localizer.GetStringByTag("#LOC_RoverScience_GUI_MaxScanDistance"); //  "Max Scan Distance";
                case (RSUpgrade.predictionAccuracy):
                    return Localizer.GetStringByTag("#LOC_RoverScience_GUI_PrecisionAccuracy"); // "Prediction Accuracy";
                case (RSUpgrade.analyzedDecay):
                    return Localizer.GetStringByTag("#LOC_RoverScience_GUI_DecayLimit"); // "Analyzed Decay Limit";
                default:
                    return Localizer.GetStringByTag("#LOC_RoverScience_GUI_ErrorUpgradeName"); // "Failed to resolve getUpgradeName";
            }

        }
        public void upgradeTech(RSUpgrade upgradeType)
        {
            Debug.Log("upgradeTech called: " + upgradeType);
            int    nextLevel    = getUpgradeLevel(upgradeType) + 1;
            int    currentLevel = getUpgradeLevel(upgradeType);
            int    maxLevel     = getUpgradeMaxLevel(upgradeType);
            float  nextCost     = getUpgradeCost(upgradeType, nextLevel);
            string upgradeName  = getUpgradeName(upgradeType);

            // MAX LEVEL REACHED
            if (currentLevel >= maxLevel)
            {
                ScreenMessages.PostScreenMessage("Max Level reached for this upgrade",
                                                 3, ScreenMessageStyle.UPPER_CENTER);
                return;
            }

            // NOT ENOUGH SCIENCE
            if (nextCost > ResearchAndDevelopment.Instance.Science)
            {
                ScreenMessages.PostScreenMessage("Not enough science to upgrade",
                                                 3, ScreenMessageStyle.UPPER_CENTER);
                return;
            }

            // UPGRADE METHOD
            if (upgradeType == RSUpgrade.maxDistance)
            {
                levelMaxDistance++;
                Debug.Log("Upgraded levelMaxDistance. Now level: " + levelMaxDistance);
            }
            else if (upgradeType == RSUpgrade.predictionAccuracy)
            {
                levelPredictionAccuracy++;
                Debug.Log("Upgraded predictionAccuracy. Now level: " + levelPredictionAccuracy);
            }
            else if (upgradeType == RSUpgrade.analyzedDecay)
            {
                levelAnalyzedDecay++;
                Debug.Log("Upgraded levelAnalyzedDecay. Now level: " + levelAnalyzedDecay);
            }

            ResearchAndDevelopment.Instance.CheatAddScience(-nextCost);

            ScreenMessages.PostScreenMessage(("" + upgradeName + " has been upgraded"),
                                             3, ScreenMessageStyle.UPPER_CENTER);
        }
        public int getUpgradeLevel(RSUpgrade upgradeType)
        {
            switch (upgradeType)
            {
            case (RSUpgrade.maxDistance):
                return(levelMaxDistance);

            case (RSUpgrade.predictionAccuracy):
                return(levelPredictionAccuracy);

            case (RSUpgrade.analyzedDecay):
                return(levelAnalyzedDecay);

            default:
                return(-1);
            }
        }
        public string getUpgradeName(RSUpgrade upgrade)
        {
            switch (upgrade)
            {
            case (RSUpgrade.maxDistance):
                return("Max Scan Distance");

            case (RSUpgrade.predictionAccuracy):
                return("Prediction Accuracy");

            case (RSUpgrade.analyzedDecay):
                return("Analyzed Decay Limit");

            default:
                return("Failed to resolve getUpgradeName");
            }
        }
        public void UpgradeTech(RSUpgrade upgradeType)
        {
            Utilities.LogVerbose("upgradeTech called: " + upgradeType);
            int    nextLevel    = GetUpgradeLevel(upgradeType) + 1;
            int    currentLevel = GetUpgradeLevel(upgradeType);
            int    maxLevel     = GetUpgradeMaxLevel(upgradeType);
            float  nextCost     = GetUpgradeCost(upgradeType, nextLevel);
            string upgradeName  = GetUpgradeName(upgradeType);

            // MAX LEVEL REACHED
            if (currentLevel >= maxLevel)
            {
                ScreenMessages.PostScreenMessage(Localizer.GetStringByTag("#LOC_RoverScience_GUI_MaxUpgradeLevel"), 3, ScreenMessageStyle.UPPER_CENTER); // Max Level reached for this upgrade
                return;
            }

            // NOT ENOUGH SCIENCE
            if (nextCost > ResearchAndDevelopment.Instance.Science)
            {
                ScreenMessages.PostScreenMessage(Localizer.GetStringByTag("#LOC_RoverScience_GUI_NotEnoughScience"), 3, ScreenMessageStyle.UPPER_CENTER); // "Not enough science to upgrade"
                return;
            }

            // UPGRADE METHOD
            if (upgradeType == RSUpgrade.maxDistance)
            {
                levelMaxDistance++;
                Utilities.LogVerbose("Upgraded levelMaxDistance. Now level: " + levelMaxDistance);
            }
            else if (upgradeType == RSUpgrade.predictionAccuracy)
            {
                levelPredictionAccuracy++;
                Utilities.LogVerbose("Upgraded predictionAccuracy. Now level: " + levelPredictionAccuracy);
            }
            else if (upgradeType == RSUpgrade.analyzedDecay)
            {
                levelAnalyzedDecay++;
                Utilities.LogVerbose("Upgraded levelAnalyzedDecay. Now level: " + levelAnalyzedDecay);
            }

            ResearchAndDevelopment.Instance.CheatAddScience(-nextCost);

            ScreenMessages.PostScreenMessage(Localizer.Format("#LOC_RoverScience_GUI_UpgradeMessage", upgradeName), 3, ScreenMessageStyle.UPPER_CENTER); // <<1>> has been upgraded"
        }
        public string GetUpgradeValueString(RSUpgrade upgrade, int level)
        {
            // This will come with unit for display
            switch (upgrade)
            {
                case (RSUpgrade.maxDistance):
                    if (levelMaxDistance >= maximum_levelMaxDistance)
                    {
                        return Localizer.GetStringByTag("#LOC_RoverScience_GUI_Max"); // "MAX";
                    }
                    else
                    {
                        return Localizer.Format("#LOC_RoverScience_GUI_Metres", GetUpgradeValue(RSUpgrade.maxDistance, level)); // <<1>>m
                    }

                case (RSUpgrade.predictionAccuracy):
                    if (levelPredictionAccuracy >= maximum_predictionAccuracy)
                    {
                        return Localizer.GetStringByTag("#LOC_RoverScience_GUI_Max"); // "MAX";
                    }
                    else
                    {
                        return Localizer.Format("#LOC_RoverScience_GUI_Percentage", GetUpgradeValue(RSUpgrade.predictionAccuracy, level)); // <<1>>%
                    }

                case (RSUpgrade.analyzedDecay):
                    if (levelAnalyzedDecay >= maximum_levelAnalyzedDecay)
                    {
                        return Localizer.GetStringByTag("#LOC_RoverScience_GUI_Max"); // "MAX";
                    }
                    else
                    {
                        return Localizer.Format("#LOC_RoverScience_GUI_nvalue", GetUpgradeValue(RSUpgrade.analyzedDecay, level)); // <<1>>n
                    }

                default:
                    return "Unable to resolve getUpgradeValueString()";
            }
        }
        public string getUpgradeValueString(RSUpgrade upgrade, int level)
        {
            // This will come with unit for display
            switch (upgrade)
            {
            case (RSUpgrade.maxDistance):
                if (levelMaxDistance >= maximum_levelMaxDistance)
                {
                    return("MAX");
                }
                else
                {
                    return(getUpgradeValue(RSUpgrade.maxDistance, level) + "m");
                }

            case (RSUpgrade.predictionAccuracy):
                if (levelPredictionAccuracy >= maximum_predictionAccuracy)
                {
                    return("MAX");
                }
                else
                {
                    return(getUpgradeValue(RSUpgrade.predictionAccuracy, level) + "%");
                }

            case (RSUpgrade.analyzedDecay):
                if (levelAnalyzedDecay >= maximum_levelAnalyzedDecay)
                {
                    return("MAX");
                }
                else
                {
                    return(getUpgradeValue(RSUpgrade.analyzedDecay, level) + "n");
                }

            default:
                return("Unable to resolve getUpgradeValueString()");
            }
        }
        public double GetUpgradeValue(RSUpgrade upgrade, int level)
		{

			if (level == 0) level = 1;
            if (level > GetUpgradeMaxLevel(upgrade)) return -1;

			switch (upgrade)
			{
			case (RSUpgrade.maxDistance):
				if (level == 1) return 100;
				if (level == 2) return 500;
				if (level == 3) return 1000;
				if (level == 4) return 2000;
				if (level == 5) return 4000;

				return -1;

			case (RSUpgrade.predictionAccuracy):
				if (level == 1) return 10;
                if (level == 2) return 20;
				if (level == 3) return 50;
				if (level == 4) return 70;
				if (level == 5) return 80;

				return -1;

            case (RSUpgrade.analyzedDecay):
                if (level <= 2) return 2;
                if (level == 3) return 3;
                if (level == 4) return 4;
                if (level == 5) return 5;

                return -1;

            default:
			return -1;
			}
		}
        public float GetUpgradeCost(RSUpgrade upgrade, int level)
		{

            if (level == 0) level = 1;
            if (level > GetUpgradeMaxLevel(upgrade)) return -1;

			switch (upgrade)
			{
			case (RSUpgrade.maxDistance):
				if (level == 1) return 200;
				if (level == 2) return 250;
				if (level == 3) return 400;
				if (level == 4) return 550;
				if (level == 5) return 1000;

				return -1;
			case (RSUpgrade.predictionAccuracy):

				if (level == 1) return 200;
				if (level == 2) return 400;
				if (level == 3) return 500;
				if (level == 4) return 1000;
				if (level == 5) return 2100;

				return -1;
            case (RSUpgrade.analyzedDecay):

                if (level == 1) return 0;
                if (level == 2) return 0;
                if (level == 3) return 1000;
                if (level == 4) return 1000;
                if (level == 5) return 1000;

                return -1;
            default:
			return -1;
			}
		}
        public double getUpgradeValue(RSUpgrade upgrade, int level)
        {
            if (level == 0)
            {
                level = 1;
            }
            if (level > getUpgradeMaxLevel(upgrade))
            {
                return(-1);
            }

            switch (upgrade)
            {
            case (RSUpgrade.maxDistance):
                if (level == 1)
                {
                    return(100);
                }
                if (level == 2)
                {
                    return(500);
                }
                if (level == 3)
                {
                    return(1000);
                }
                if (level == 4)
                {
                    return(2000);
                }
                if (level == 5)
                {
                    return(4000);
                }

                return(-1);

            case (RSUpgrade.predictionAccuracy):
                if (level == 1)
                {
                    return(10);
                }
                if (level == 2)
                {
                    return(20);
                }
                if (level == 3)
                {
                    return(50);
                }
                if (level == 4)
                {
                    return(70);
                }
                if (level == 5)
                {
                    return(80);
                }

                return(-1);

            case (RSUpgrade.analyzedDecay):
                if (level <= 2)
                {
                    return(2);
                }
                if (level == 3)
                {
                    return(3);
                }
                if (level == 4)
                {
                    return(4);
                }
                if (level == 5)
                {
                    return(5);
                }

                return(-1);

            default:
                return(-1);
            }
        }
        public float getUpgradeCost(RSUpgrade upgrade, int level)
        {
            if (level == 0)
            {
                level = 1;
            }
            if (level > getUpgradeMaxLevel(upgrade))
            {
                return(-1);
            }

            switch (upgrade)
            {
            case (RSUpgrade.maxDistance):
                if (level == 1)
                {
                    return(200);
                }
                if (level == 2)
                {
                    return(250);
                }
                if (level == 3)
                {
                    return(400);
                }
                if (level == 4)
                {
                    return(550);
                }
                if (level == 5)
                {
                    return(1000);
                }

                return(-1);

            case (RSUpgrade.predictionAccuracy):

                if (level == 1)
                {
                    return(200);
                }
                if (level == 2)
                {
                    return(400);
                }
                if (level == 3)
                {
                    return(500);
                }
                if (level == 4)
                {
                    return(1000);
                }
                if (level == 5)
                {
                    return(2100);
                }

                return(-1);

            case (RSUpgrade.analyzedDecay):

                if (level == 1)
                {
                    return(0);
                }
                if (level == 2)
                {
                    return(0);
                }
                if (level == 3)
                {
                    return(1000);
                }
                if (level == 4)
                {
                    return(1000);
                }
                if (level == 5)
                {
                    return(1000);
                }

                return(-1);

            default:
                return(-1);
            }
        }