public int ReturnBuildingCosts(SpaceCenterFacility facility)
{
switch (facility)
{
case SpaceCenterFacility.Administration:
return(administrationCost);
case SpaceCenterFacility.AstronautComplex:
return(astronautComplexCost);
case SpaceCenterFacility.MissionControl:
return(missionControlCost);
case SpaceCenterFacility.ResearchAndDevelopment:
return(rndCost);
case SpaceCenterFacility.SpaceplaneHangar:
return(sphCost);
case SpaceCenterFacility.TrackingStation:
return(trackingStationCost);
case SpaceCenterFacility.VehicleAssemblyBuilding:
return(vabCost);
default:
return(otherFacilityCost);
}
}
private void UpdateFacilityLevelStats(UpgradeableObject.UpgradeLevel lvl, int lvlIdx)
{
// levelText appears to be unused by KSP itself. We can use it to store original level stats.
// Restoring old values is necessary because those persist between scene changes but some of them are based on current KCT settings.
if (lvl.levelText == null)
{
lvl.levelText = ScriptableObject.CreateInstance <KSCUpgradeableLevelText>();
lvl.levelText.facility = lvl.levelStats.facility;
lvl.levelText.linePrefix = lvl.levelStats.linePrefix;
lvl.levelText.textBase = lvl.levelStats.textBase;
}
else
{
lvl.levelStats.textBase = lvl.levelText.textBase;
}
KCTDebug.Log($"Overriding level stats text for {lvl.levelStats.facility} lvl {lvlIdx}");
SpaceCenterFacility facilityType = lvl.levelStats.facility;
if (facilityType == SpaceCenterFacility.VehicleAssemblyBuilding ||
facilityType == SpaceCenterFacility.SpaceplaneHangar)
{
if (PresetManager.Instance.ActivePreset.GeneralSettings.CommonBuildLine &&
facilityType == SpaceCenterFacility.SpaceplaneHangar)
{
lvl.levelStats.linePrefix = string.Empty;
lvl.levelStats.textBase = "Upgrade the VAB instead";
}
else
{
lvl.levelStats.textBase += $"\n{lvlIdx + 1} build queue{(lvlIdx > 0 ? "s" : string.Empty)}";
if (lvlIdx > 0)
{
lvl.levelStats.textBase += $"\n+{lvlIdx * 25}% build rate";
}
}
}
else if (facilityType == SpaceCenterFacility.ResearchAndDevelopment &&
lvlIdx > 0)
{
lvl.levelStats.textBase += $"\n+{lvlIdx * 25}% research rate";
}
else if (facilityType == SpaceCenterFacility.Administration)
{
lvl.levelStats.linePrefix = string.Empty;
lvl.levelStats.textBase = "This facility is currently unused";
}
else if (facilityType == SpaceCenterFacility.AstronautComplex &&
lvlIdx > 0)
{
lvl.levelStats.textBase += $"\n{lvlIdx * 25}% shorter R&R times";
lvl.levelStats.textBase += $"\n{lvlIdx * 25}% shorter training times";
}
else if (facilityType == SpaceCenterFacility.LaunchPad)
{
lvl.levelStats.linePrefix = string.Empty;
lvl.levelStats.textBase = "<color=\"red\"><b>Launchpads cannot be upgraded. Build a new launchpad from the KCT Build List tab instead.</b></color>";
}
}
public static double CalculateBuildTime(double cost, SpaceCenterFacility facilityType, KCT_KSC KSC = null)
{
double bp = CalculateBP(cost, facilityType);
double rateTotal = KCT_Utilities.GetBothBuildRateSum(KSC ?? KCT_GameStates.ActiveKSC);
return(bp / rateTotal);
}
private int[] getFacilityLevelsVisual(SpaceCenterFacility f)
{
switch (f)
{
case SpaceCenterFacility.Administration:
return(customGameVariables.upgradesVisualAdministration);
case SpaceCenterFacility.AstronautComplex:
return(customGameVariables.upgradesVisualAstronauts);
case SpaceCenterFacility.LaunchPad:
return(customGameVariables.upgradesVisualLaunchPad);
case SpaceCenterFacility.MissionControl:
return(customGameVariables.upgradesVisualMission);
case SpaceCenterFacility.ResearchAndDevelopment:
return(customGameVariables.upgradesVisualRnD);
case SpaceCenterFacility.Runway:
return(customGameVariables.upgradesVisualRunway);
case SpaceCenterFacility.SpaceplaneHangar:
return(customGameVariables.upgradesVisualSPH);
case SpaceCenterFacility.TrackingStation:
return(customGameVariables.upgradesVisualTracking);
case SpaceCenterFacility.VehicleAssemblyBuilding:
return(customGameVariables.upgradesVisualVAB);
default:
return(customGameVariables.upgradesVisualTracking);
}
}
private float[] getFacilityUpgradePrices(SpaceCenterFacility f)
{
switch (f)
{
case SpaceCenterFacility.Administration:
return(customGameVariables.upgradesAdministration);
case SpaceCenterFacility.AstronautComplex:
return(customGameVariables.upgradesAstronauts);
case SpaceCenterFacility.LaunchPad:
return(customGameVariables.upgradesLaunchPad);
case SpaceCenterFacility.MissionControl:
return(customGameVariables.upgradesMission);
case SpaceCenterFacility.ResearchAndDevelopment:
return(customGameVariables.upgradesRnD);
case SpaceCenterFacility.Runway:
return(customGameVariables.upgradesRunway);
case SpaceCenterFacility.SpaceplaneHangar:
return(customGameVariables.upgradesSPH);
case SpaceCenterFacility.TrackingStation:
return(customGameVariables.upgradesTracking);
case SpaceCenterFacility.VehicleAssemblyBuilding:
return(customGameVariables.upgradesVAB);
default:
return(customGameVariables.upgradesTracking);
}
}
public FacilityConstructionEventDto(FacilityConstructionEvent fce)
{
date = CareerLog.UTToDate(fce.UT).ToString("o");
facility = fce.Facility;
newLevel = fce.NewLevel;
cost = fce.Cost;
state = fce.State;
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary> Calculates the level (1..3) of the facility specified.</summary>
///
/// <param name="facility"> The facility to fetch the level for.</param>
///
/// <returns> The level of the facility. This will be 1..3 where 1 is the initial level on a new
/// career game and 3 is fully upgraded.</returns>
private int FacilityLevel(SpaceCenterFacility facility)
{
var level = ScenarioUpgradeableFacilities.GetFacilityLevel(facility); // 0 .. 1
var count = ScenarioUpgradeableFacilities
.GetFacilityLevelCount(facility); // max upgrades allowed (usually 2)
return((int)(level * count) + 1);
}
public KCT_UpgradingBuilding(SpaceCenterFacility type, string facilityID, int newLevel, int oldLevel, string name)
{
facilityType = type;
id = facilityID;
upgradeLevel = newLevel;
currentLevel = oldLevel;
commonName = name;
KCTDebug.Log(string.Format("Upgrade of {0} requested from {1} to {2}", name, oldLevel, newLevel));
}
private int GetKCTUpgradeCounts(SpaceCenterFacility facility)
{
try
{
return(KerbalConstructionTime.Utilities.GetSpentUpgradesFor(facility));
}
catch (Exception ex)
{
Debug.LogException(ex);
return(0);
}
}
private int GetKCTUpgradeCounts(SpaceCenterFacility facility)
{
try
{
return(FnGetKCTUpgdCounts == null ? 0 : FnGetKCTUpgdCounts(facility));
}
catch (Exception ex)
{
Debug.LogException(ex);
return(0);
}
}
public static int BuildingUpgradeLevel(SpaceCenterFacility facility)
{
int lvl = 0;
if (HighLogic.CurrentGame.Mode == Game.Modes.CAREER && Settings1.Instance.UseUpgrades)
{
lvl = (int)Math.Round((ScenarioUpgradeableFacilities.GetFacilityLevelCount(facility) * ScenarioUpgradeableFacilities.GetFacilityLevel(facility)));
}
else
{
lvl = ScenarioUpgradeableFacilities.GetFacilityLevelCount(facility); //returns 2 for VAB in Sandbox
}
return(lvl);
}
public static int BuildingUpgradeLevel(SpaceCenterFacility facility)
{
int lvl = 0;
if (HighLogic.CurrentGame.Mode == Game.Modes.CAREER && Settings.Instance.UseUpgrades)
{
lvl = (int)(2 * ScenarioUpgradeableFacilities.GetFacilityLevel(facility));
}
else
{
//lvl = ScenarioUpgradeableFacilities.GetFacilityLevelCount(facility);
lvl = 2;
}
return lvl;
}
public string MaximumVesselMass()
{
SpaceCenterFacility rolloutFacility = (EditorDriver.editorFacility == EditorFacility.VAB) ? SpaceCenterFacility.LaunchPad : SpaceCenterFacility.Runway;
float maximumVesselMass = GameVariables.Instance.GetCraftMassLimit(ScenarioUpgradeableFacilities.GetFacilityLevel(rolloutFacility));
if (maximumVesselMass < float.MaxValue)
{
return(string.Format("{0} t", maximumVesselMass.ToString("F3")));
}
else
{
return("Unlimited");
}
}
/// <summary>
/// Gets the (integer) level of a particular facility
/// </summary>
/// <param name="facility">The facility to check</param>
/// <returns>The level of the facility</returns>
public static int GetFacilityLevel(SpaceCenterFacility facility)
{
int lvl = 0;
if (HighLogic.CurrentGame.Mode == Game.Modes.CAREER)
{
lvl = (int)(ScenarioUpgradeableFacilities.GetFacilityLevelCount(facility) * ScenarioUpgradeableFacilities.GetFacilityLevel(facility));
}
else
{
lvl = ScenarioUpgradeableFacilities.GetFacilityLevelCount(facility); //returns 2 for VAB in Sandbox
}
return(lvl);
}
public void AddFacilityConstructionEvent(SpaceCenterFacility facility, int newLevel, double cost, ConstructionState state)
{
if (CareerEventScope.ShouldIgnore || !IsEnabled)
{
return;
}
_facilityConstructions.Add(new FacilityConstructionEvent(KSPUtils.GetUT())
{
Facility = facility,
NewLevel = newLevel,
Cost = cost,
State = state
});
}
public static int BuildingUpgradeLevel(SpaceCenterFacility facility)
{
int lvl = 0;
if (HighLogic.CurrentGame.Mode == Game.Modes.CAREER && Settings.Instance.UseUpgrades)
{
lvl = (int)(2 * ScenarioUpgradeableFacilities.GetFacilityLevel(facility));
}
else
{
//lvl = ScenarioUpgradeableFacilities.GetFacilityLevelCount(facility);
lvl = 2;
}
return(lvl);
}
public void AddFacilityConstructionEvent(SpaceCenterFacility facility, int newLevel, double cost, ConstructionState state)
{
if (!IsEnabled)
{
return;
}
_facilityConstructions.Add(new FacilityConstructionEvent(Planetarium.GetUniversalTime())
{
Facility = facility,
NewLevel = newLevel,
Cost = cost,
State = state
});
}
public override bool LoadFromConfig(ConfigNode configNode)
{
// Load base class
bool valid = base.LoadFromConfig(configNode);
// Check on active contracts too
checkOnActiveContract = configNode.HasValue("checkOnActiveContract") ? checkOnActiveContract : true;
valid &= ConfigNodeUtil.ParseValue<SpaceCenterFacility>(configNode, "facility", x => facility = x, this);
valid &= ConfigNodeUtil.ParseValue<int>(configNode, "minLevel", x => minLevel = x, this, 1, x => Validation.Between(x, 1, 3));
valid &= ConfigNodeUtil.ParseValue<int>(configNode, "maxLevel", x => maxLevel = x, this, 3, x => Validation.Between(x, 1, 3));
valid &= ConfigNodeUtil.AtLeastOne(configNode, new string[] { "minLevel", "maxLevel" }, this);
return valid;
}
public int GetBuildingCosts()
{
int cost = 0;
for (int i = 0; i < facilities.Count(); i++)
{
SpaceCenterFacility facility = facilities.ElementAt(i);
if (facility == SpaceCenterFacility.LaunchPad || facility == SpaceCenterFacility.Runway)
{
continue;
}
int lvl = (int)Math.Round(ScenarioUpgradeableFacilities.GetFacilityLevel(facility) * ScenarioUpgradeableFacilities.GetFacilityLevelCount(facility)) + 1;
cost += lvl * BudgetSettings.instance.ReturnBuildingCosts(facility);
}
return(cost);
}
private int GetFacilityLevel(SpaceCenterFacility facility)
{
if (ScenarioUpgradeableFacilities.Instance == null || !ScenarioUpgradeableFacilities.Instance.enabled)
{
return(int.MaxValue);
}
double maxlevel = ScenarioUpgradeableFacilities.GetFacilityLevelCount(facility);
if (maxlevel <= 0)
{
maxlevel = 2; // not sure why, but GetFacilityLevelCount return -1 in career
}
return((int)Math.Round(ScenarioUpgradeableFacilities.GetFacilityLevel(facility) * maxlevel + 1)); // They start counting at 0
}
public FacilityManager()
{
InternalListeners.OnBudgetAboutToFire.Add(OnBudgetAboutToFire);
SpaceCenterFacility[] spaceCentreFacilities = (SpaceCenterFacility[])Enum.GetValues(typeof(SpaceCenterFacility));
for (int i = 0; i < spaceCentreFacilities.Length; i++)
{
SpaceCenterFacility spf = spaceCentreFacilities.ElementAt(i);
Facilities.Add(new BureaucracyFacility(spf));
}
//RB loads super late, well after we're done here, so we need to check if it's installed and set up a BureaucracyFacility for the Observatory.
ResearchBodiesWrapper rw = new ResearchBodiesWrapper();
if (rw.RBInstalled())
{
Facilities.Add(new BureaucracyFacility("Observatory"));
}
Name = "Construction";
ThisMonthsBudget = HighLogic.CurrentGame.Parameters.Career.StartingFunds * FundingAllocation;
Instance = this;
Debug.Log("[Bureaucracy]: Facility Manager Ready");
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary> Calculates the base maintenance cost for the facility specified.</summary>
///
/// <param name="facility"> The facility to fetch the maintenance cost for.</param>
///
/// <returns> The building costs.</returns>
private int BaseStructureCost(SpaceCenterFacility facility)
{
if (BudgetSettings.Instance == null)
{
return(0);
}
switch (facility)
{
case SpaceCenterFacility.Administration:
return(BudgetSettings.Instance.structureCostAdministration);
case SpaceCenterFacility.AstronautComplex:
return(BudgetSettings.Instance.structureCostAstronautComplex);
case SpaceCenterFacility.MissionControl:
return(BudgetSettings.Instance.structureCostMissionControl);
case SpaceCenterFacility.ResearchAndDevelopment:
return(BudgetSettings.Instance.structureCostRnD);
case SpaceCenterFacility.SpaceplaneHangar:
return(BudgetSettings.Instance.structureCostSph);
case SpaceCenterFacility.TrackingStation:
return(BudgetSettings.Instance.structureCostTrackingStation);
case SpaceCenterFacility.VehicleAssemblyBuilding:
return(BudgetSettings.Instance.structureCostVab);
case SpaceCenterFacility.LaunchPad:
case SpaceCenterFacility.Runway:
return(0);
default:
return(BudgetSettings.Instance.structureCostOtherFacility);
}
}
private string SetName(SpaceCenterFacility spf)
{
switch (spf)
{
case SpaceCenterFacility.Administration:
return("Administration");
case SpaceCenterFacility.AstronautComplex:
CanBeClosed = true;
return("AstronautComplex");
case SpaceCenterFacility.MissionControl:
return("MissionControl");
case SpaceCenterFacility.SpaceplaneHangar:
CanBeClosed = true;
return("SpaceplaneHangar");
case SpaceCenterFacility.TrackingStation:
return("TrackingStation");
case SpaceCenterFacility.ResearchAndDevelopment:
return("ResearchAndDevelopment");
case SpaceCenterFacility.VehicleAssemblyBuilding:
CanBeClosed = true;
return("VehicleAssemblyBuilding");
case SpaceCenterFacility.Runway:
return("Runway");
case SpaceCenterFacility.LaunchPad:
return("LaunchPad");
default:
return("Other Facility");
}
}
internal void ProcessUpgrade()
{
int oldLevel = getMember <int>("level");
KCTDebug.Log($"Upgrading from level {oldLevel}");
string facilityID = GetFacilityID();
SpaceCenterFacility facilityType = GetFacilityType();
string gate = GetTechGate(facilityID, oldLevel + 1);
KCTDebug.Log("[KCTT] Gate for " + facilityID + "? " + gate);
if (!string.IsNullOrEmpty(gate))
{
if (ResearchAndDevelopment.GetTechnologyState(gate) != RDTech.State.Available)
{
PopupDialog.SpawnPopupDialog(new MultiOptionDialog("kctUpgradePadConfirm",
"Can't upgrade this facility. Requires " + KerbalConstructionTimeData.techNameToTitle[gate] + ".",
"Lack Tech to Upgrade",
HighLogic.UISkin,
new DialogGUIButton("Ok", stub)),
false,
HighLogic.UISkin);
return;
}
}
KCT_UpgradingBuilding upgrading = new KCT_UpgradingBuilding(facilityType, facilityID, oldLevel + 1, oldLevel, facilityID.Split('/').Last());
upgrading.isLaunchpad = facilityID.ToLower().Contains("launchpad");
if (upgrading.isLaunchpad)
{
upgrading.launchpadID = KCT_GameStates.ActiveKSC.ActiveLaunchPadID;
if (upgrading.launchpadID > 0)
{
upgrading.commonName += KCT_GameStates.ActiveKSC.ActiveLPInstance.name;
}
}
if (!upgrading.AlreadyInProgress())
{
float cost = getMember <float>("upgradeCost");
if (Funding.CanAfford(cost))
{
KCT_Utilities.SpendFunds(cost, TransactionReasons.Structures);
KCT_GameStates.ActiveKSC.KSCTech.Add(upgrading);
upgrading.SetBP(cost);
upgrading.cost = cost;
try
{
KCT_Events.onFacilityUpgradeQueued?.Fire(upgrading);
}
catch (Exception ex)
{
Debug.LogException(ex);
}
ScreenMessages.PostScreenMessage("Facility upgrade requested!", 4.0f, ScreenMessageStyle.UPPER_CENTER);
KCTDebug.Log($"Facility {facilityID} upgrade requested to lvl {oldLevel + 1} for {cost} funds, resulting in a BP of {upgrading.BP}");
}
else
{
KCTDebug.Log("Couldn't afford to upgrade.");
ScreenMessages.PostScreenMessage("Not enough funds to upgrade facility!", 4.0f, ScreenMessageStyle.UPPER_CENTER);
}
}
else if (oldLevel + 1 != upgrading.currentLevel)
{
ScreenMessages.PostScreenMessage("Facility is already being upgraded!", 4.0f, ScreenMessageStyle.UPPER_CENTER);
KCTDebug.Log($"Facility {facilityID} tried to upgrade to lvl {oldLevel + 1} but already in list!");
}
}
protected override void OnLoadFromConfig(ConfigNode node)
{
facility = ConfigNodeUtil.ParseValue <SpaceCenterFacility>(node, "facility", SpaceCenterFacility.Administration);
level = ConfigNodeUtil.ParseValue <int>(node, "level");
}
public override void OnLoad(ConfigNode configNode)
{
facility = ConfigNodeUtil.ParseValue <SpaceCenterFacility>(configNode, "facility");
minLevel = ConfigNodeUtil.ParseValue <int>(configNode, "minLevel");
maxLevel = ConfigNodeUtil.ParseValue <int>(configNode, "maxLevel");
}
public override void OnLoad(ConfigNode configNode)
{
facility = ConfigNodeUtil.ParseValue<SpaceCenterFacility>(configNode, "facility");
minLevel = ConfigNodeUtil.ParseValue<int>(configNode, "minLevel");
maxLevel = ConfigNodeUtil.ParseValue<int>(configNode, "maxLevel");
}
public static List <UpgradeableFacility> GetFacilityReferencesByType(SpaceCenterFacility facilityType)
{
string internalId = ScenarioUpgradeableFacilities.SlashSanitize(facilityType.ToString());
return(GetFacilityReferencesById(internalId));
}
public override bool LoadFromConfig(ConfigNode configNode)
{
// Load base class
bool valid = base.LoadFromConfig(configNode);
// Check on active contracts too
checkOnActiveContract = configNode.HasValue("checkOnActiveContract") ? checkOnActiveContract : true;
valid &= ConfigNodeUtil.ParseValue <SpaceCenterFacility>(configNode, "facility", x => facility = x, this);
valid &= ConfigNodeUtil.ParseValue <int>(configNode, "minLevel", x => minLevel = x, this, 1, x => Validation.Between(x, 1, 3));
valid &= ConfigNodeUtil.ParseValue <int>(configNode, "maxLevel", x => maxLevel = x, this, 3, x => Validation.Between(x, 1, 3));
valid &= ConfigNodeUtil.AtLeastOne(configNode, new string[] { "minLevel", "maxLevel" }, this);
return(valid);
}
public static int GetKCTUpgradeCounts(SpaceCenterFacility facility)
{
return(KerbalConstructionTime.Utilities.GetSpentUpgradesFor(facility));
}
public static int GetKCTUpgradeCounts(SpaceCenterFacility facility)
{
return(KCT_Utilities.SpentUpgradesFor(facility));
}
protected override void OnLoadFromConfig(ConfigNode node)
{
facility = ConfigNodeUtil.ParseValue<SpaceCenterFacility>(node, "facility", SpaceCenterFacility.Administration);
level = ConfigNodeUtil.ParseValue<int>(node, "level");
}
public static double CalculateBP(double cost, SpaceCenterFacility facilityType)
{
int isAdm = 0, isAC = 0, isLP = 0, isMC = 0, isRD = 0, isRW = 0, isTS = 0, isSPH = 0, isVAB = 0;
switch (facilityType)
{
case SpaceCenterFacility.Administration:
isAdm = 1;
break;
case SpaceCenterFacility.AstronautComplex:
isAC = 1;
break;
case SpaceCenterFacility.LaunchPad:
isLP = 1;
break;
case SpaceCenterFacility.MissionControl:
isMC = 1;
break;
case SpaceCenterFacility.ResearchAndDevelopment:
isRD = 1;
break;
case SpaceCenterFacility.Runway:
isRW = 1;
break;
case SpaceCenterFacility.TrackingStation:
isTS = 1;
break;
case SpaceCenterFacility.SpaceplaneHangar:
isSPH = 1;
break;
case SpaceCenterFacility.VehicleAssemblyBuilding:
isVAB = 1;
break;
default:
break;
}
var variables = new Dictionary <string, string>()
{
{ "C", cost.ToString() },
{ "O", KCT_PresetManager.Instance.ActivePreset.timeSettings.OverallMultiplier.ToString() },
{ "Adm", isAdm.ToString() },
{ "AC", isAC.ToString() },
{ "LP", isLP.ToString() },
{ "MC", isMC.ToString() },
{ "RD", isRD.ToString() },
{ "RW", isRW.ToString() },
{ "TS", isTS.ToString() },
{ "SPH", isSPH.ToString() },
{ "VAB", isVAB.ToString() }
};
double bp = KCT_MathParsing.GetStandardFormulaValue("KSCUpgrade", variables);
if (bp <= 0)
{
bp = 1;
}
return(bp);
}
// With the help of NoMoreGrind code by nlight
private void LoadUpgradesPrices()
{
log("Loading new upgrades prices");
foreach (UpgradeableFacility facility in GameObject.FindObjectsOfType <UpgradeableFacility>())
{
SpaceCenterFacility facilityType = (SpaceCenterFacility)Enum.Parse(typeof(SpaceCenterFacility), facility.name);
float[] prices = getFacilityUpgradePrices(facilityType);
int levels = getFacilityLevels(facilityType);
int[] levelsVisual = getFacilityLevelsVisual(facilityType);
if (prices == null)
{
log("No upgrades prices set for " + facilityType + ". Skipping");
continue;
}
if (levels != prices.Length)
{
log("Wrong numbers of upgrade price for " + facility + " expecting " + levels + " and have " + prices.Length + ". Check your configs");
continue;
}
UpgradeableObject.UpgradeLevel[] upgradeLevels = facility.UpgradeLevels;
if (facility.UpgradeLevels[facility.FacilityLevel].Spawned)
{
facility.UpgradeLevels[facility.FacilityLevel].Despawn();
}
UpgradeableObject.UpgradeLevel[] newUpgradeLevels = new UpgradeableObject.UpgradeLevel[levels];
for (int i = 0; i < levels; i++)
{
int originalLevel = Math.Min(i, upgradeLevels.Length - 1);
UpgradeableObject.UpgradeLevel level = new UpgradeableObject.UpgradeLevel();
var sourceLvl = upgradeLevels[originalLevel];
level.levelCost = prices[i];
level.levelText = sourceLvl.levelText;
level.levelStats = sourceLvl.levelStats;
level.facilityPrefab = sourceLvl.facilityPrefab;
level.facilityInstance = null;
if (levelsVisual.Length == levels)
{
log(facility.name + " Copying level " + (levelsVisual[i] - 1) + " for level " + (i + 1));
//level.facilityPrefab = Instantiate(upgradeLevels[levelsVisual[i] - 1].facilityPrefab);
level.facilityPrefab = upgradeLevels[levelsVisual[i] - 1].facilityPrefab;
}
else
{
log("Wrong levelsVisual length " + levelsVisual.Length + " for " + facility.name + " expected " + levels);
}
newUpgradeLevels[i] = level;
}
facility.UpgradeLevels = newUpgradeLevels;
facility.SetupLevels();
facility.setLevel(facility.FacilityLevel);
}
log("New upgrades prices are Loaded");
}
