public static int UpdateFuelFlow(UpgradeConstants u_constants, Part part, PartStats original_stats, PartUpgrades upgrades_to_apply)
{
var upgrade_factor = u_constants.CalculateImprovementFactor(upgrades_to_apply.fuelFlow);
var engine_modules = PartStats.GetModuleEnginesList(part);
var rcs_module = PartStats.GetModuleRCS(part);
if (engine_modules == null && !rcs_module)
{
return(0);
}
for (var i = 0; i < original_stats.maxFuelFlows.Count; i++)
{
var max_fuel_flow = original_stats.maxFuelFlows[i] * upgrade_factor;
if (engine_modules != null)
{
engine_modules[i].maxFuelFlow = max_fuel_flow;
}
else if (rcs_module)
{
rcs_module.thrusterPower = max_fuel_flow; // There is only one rcs-module
}
}
return(0);
}
public static int UpdateGeneratorEfficiency(UpgradeConstants u_constants, Part part, PartStats original_stats, PartUpgrades upgrades_to_apply)
{
var generator = PartStats.GetModuleGenerator(part);
if (generator)
{
foreach (var output_resource in generator.resHandler.outputResources)
{
if (!original_stats.generatorEfficiency.TryGetValue(output_resource.name, out var original_rate))
{
continue;
}
output_resource.rate = u_constants.CalculateImprovementValue(original_rate, upgrades_to_apply.generatorEfficiency);
}
}
var fission_generator = PartStats.GetFissionGenerator(part);
if (fission_generator)
{
var power_generation = u_constants.CalculateImprovementValue(original_stats.fissionPowerGeneration, upgrades_to_apply.generatorEfficiency);
PartStats.SetGenericModuleValue(fission_generator, "PowerGeneration", power_generation);
}
return(0);
}
public static int UpdateElConverter(UpgradeConstants u_constants, Part part, PartStats original_stats, PartUpgrades upgrades_to_apply)
{
var converter_list = PartStats.GetModuleElConverterList(part);
if (converter_list == null)
{
return(0);
}
foreach (var converter in converter_list)
{
converter.Rate = u_constants.CalculateImprovementValue(original_stats.ELConverter, upgrades_to_apply.elConverter);
}
#if false
var el_converter = PartStats.GetModuleElConverter(part);
if (el_converter)
{
el_converter.Rate = u_constants.CalculateImprovementValue(original_stats.ELConverter, upgrades_to_apply.elConverter);
}
#endif
return(0);
}
public static int UpdateFuelCapacity(UpgradeConstants u_constants, Part part, PartStats original_stats, PartUpgrades upgrades_to_apply)
{
// Fuel Capacity:
var fuel_resources = PartStats.GetFuelResources(part);
if (fuel_resources == null || original_stats.fuelCapacities == null)
{
return(0);
}
double improvement_factor = u_constants.CalculateImprovementFactor(upgrades_to_apply.fuelCapacity);
foreach (var fuel_resource in fuel_resources)
{
if (!original_stats.fuelCapacities.ContainsKey(fuel_resource.resourceName))
{
continue;
}
var original_capacity = original_stats.fuelCapacities[fuel_resource.resourceName];
var new_capacity = Math.Round(original_capacity * improvement_factor);
var percentage_full = fuel_resource.amount / fuel_resource.maxAmount;
fuel_resource.maxAmount = new_capacity;
fuel_resource.amount = new_capacity * percentage_full;
}
return(0);
}
public static int UpdateConverterEfficiency(UpgradeConstants u_constants, Part part, PartStats original_stats, PartUpgrades upgrades_to_apply)
{
// Converter Efficiency:
var converter_list = PartStats.GetModuleResourceConverterList(part);
if (converter_list == null)
{
return(0);
}
foreach (var converter in converter_list)
{
if (!original_stats.converterEfficiency.TryGetValue(converter.ConverterName, out var original_output_resources))
{
continue;
}
// Since KSP 1.2 this can't be done in a foreach anymore, we have to read and write back the entire ResourceRatio-Object:
for (var i = 0; i < converter.outputList.Count; i++)
{
var resource_ratio = converter.outputList[i];
if (!original_output_resources.TryGetValue(resource_ratio.ResourceName, out var original_ratio))
{
continue;
}
resource_ratio.Ratio = u_constants.CalculateImprovementValue(original_ratio, upgrades_to_apply.converterEfficiency);
converter.outputList[i] = resource_ratio;
}
}
return(0);
}
public static int UpdateActiveRadiator(UpgradeConstants u_constants, Part part, PartStats original_stats, PartUpgrades upgrades_to_apply)
{
var radiator = PartStats.GetModuleActiveRadiator(part);
if (radiator)
{
radiator.maxEnergyTransfer = u_constants.CalculateImprovementValue(original_stats.maxEnergyTransfer, upgrades_to_apply.maxEnergyTransfer);
}
return(0);
}
public static int UpdatePacketSize(UpgradeConstants u_constants, Part part, PartStats original_stats, PartUpgrades upgrades_to_apply)
{
var antenna = PartStats.GetModuleDataTransmitter(part);
if (antenna)
{
antenna.packetSize = u_constants.CalculateImprovementValue(original_stats.packetSize, upgrades_to_apply.packetSize);
}
return(0);
}
public static int UpdateCrashTolerance(UpgradeConstants u_constants, Part part, PartStats original_stats, PartUpgrades upgrades_to_apply)
{
var landing_leg = PartStats.GetModuleWheelBase(part);
if (landing_leg)
{
part.crashTolerance = u_constants.CalculateImprovementValue(original_stats.crashTolerance, upgrades_to_apply.crashTolerance);
}
return(0);
}
public static int UpdateChargeRate(UpgradeConstants u_constants, Part part, PartStats original_stats, PartUpgrades upgrades_to_apply)
{
var solar_panel = PartStats.GetModuleDeployableSolarPanel(part);
if (solar_panel)
{
solar_panel.efficiencyMult = u_constants.CalculateImprovementValue(original_stats.efficiencyMult, upgrades_to_apply.efficiencyMult);
}
return(0);
}
public static int UpdateResourceHarvester(UpgradeConstants u_constants, Part part, PartStats original_stats, PartUpgrades upgrades_to_apply)
{
// Resource Harvester
var harvester = PartStats.GetModuleResourceHarvester(part);
if (harvester)
{
harvester.Efficiency = u_constants.CalculateImprovementValue(original_stats.resourceHarvester, upgrades_to_apply.resourceHarvester);
}
// TODO: Update surface harvester module too?
return(0);
}
public static int UpdateParachuteStrength(UpgradeConstants u_constants, Part part, PartStats original_stats, PartUpgrades upgrades_to_apply)
{
// Parachute Strength:
var parachute = PartStats.GetModuleParachute(part);
if (parachute)
{
// The safe deployment-speed is derived from the temperature
parachute.chuteMaxTemp = original_stats.chuteMaxTemp * u_constants.CalculateImprovementFactor(upgrades_to_apply.parachuteStrength);
}
return(0);
}
public static int UpdateDryMass(UpgradeConstants u_constants, Part part, PartStats original_stats, PartUpgrades upgrades_to_apply)
{
part.prefabMass = part.mass = u_constants.CalculateImprovementValue(original_stats.dryMass, upgrades_to_apply.dryMass);
// Dry Mass also improves fairing mass:
var fairing_module = PartStats.GetModuleProceduralFairing(part);
if (fairing_module)
{
fairing_module.UnitAreaMass = u_constants.CalculateImprovementValue(original_stats.fairingAreaMass, upgrades_to_apply.dryMass);
}
return(0);
}
public static int UpdateBatteryCharge(UpgradeConstants u_constants, Part part, PartStats original_stats, PartUpgrades upgrades_to_apply)
{
var electric_charge = PartStats.GetElectricCharge(part);
if (electric_charge == null)
{
return(0);
}
var max_charge = Math.Round(u_constants.CalculateImprovementValue(original_stats.batteryCharge, upgrades_to_apply.batteryCharge));
var percentage_full = electric_charge.amount / electric_charge.maxAmount;
electric_charge.maxAmount = max_charge;
electric_charge.amount = max_charge * percentage_full;
return(0);
}
public static int UpdateTorque(UpgradeConstants u_constants, Part part, PartStats original_stats, PartUpgrades upgrades_to_apply)
{
var reaction_wheel = PartStats.GetModuleReactionWheel(part);
if (!reaction_wheel)
{
return(0);
}
var torque = u_constants.CalculateImprovementValue(original_stats.torqueStrength, upgrades_to_apply.torqueStrength);
reaction_wheel.PitchTorque = torque;
reaction_wheel.YawTorque = torque;
reaction_wheel.RollTorque = torque;
return(0);
}
public static int UpdateDataStorage(UpgradeConstants u_constants, Part part, PartStats original_stats, PartUpgrades upgrades_to_apply)
{
var science_lab = PartStats.GetModuleScienceLab(part);
if (science_lab)
{
science_lab.dataStorage = u_constants.CalculateImprovementValue(original_stats.dataStorage, upgrades_to_apply.dataStorage);
}
var science_converter = PartStats.GetModuleScienceConverter(part);
if (science_converter)
{
science_converter.scienceCap = u_constants.CalculateImprovementValue(original_stats.scienceCap, upgrades_to_apply.dataStorage);
}
return(0);
}
public static int UpdateMaxTemperature(UpgradeConstants u_constants, Part part, PartStats original_stats, PartUpgrades upgrades_to_apply)
{
part.skinMaxTemp = u_constants.CalculateImprovementValue(original_stats.skinMaxTemp, upgrades_to_apply.maxTemperature);
part.maxTemp = u_constants.CalculateImprovementValue(original_stats.intMaxTemp, upgrades_to_apply.maxTemperature);
return(0);
}
public static int UpdateISPVacAtm(UpgradeConstants data_vac, UpgradeConstants data_atm, Part part, PartStats original_stats, PartUpgrades isp)
{
List <ModuleEngines> engine_modules = PartStats.GetModuleEnginesList(part);
ModuleRCS rcs_module = PartStats.GetModuleRCS(part);
if (engine_modules == null && !rcs_module)
{
return(0);
}
var improvement_factor_vac = data_vac.CalculateImprovementFactor(isp.ispVac);
var improvement_factor_atm = data_atm.CalculateImprovementFactor(isp.ispAtm);
for (var i = 0; i < original_stats.atmosphereCurves.Count; i++)
{
var is_air_breather = false;
if (engine_modules != null)
{
is_air_breather = engine_modules[i].engineType == EngineType.Turbine ||
engine_modules[i].engineType == EngineType.Piston ||
engine_modules[i].engineType == EngineType.ScramJet;
}
var fc = new FloatCurve();
for (var v = 0; v < original_stats.atmosphereCurves[i].Curve.length; v++)
{
var frame = original_stats.atmosphereCurves[i].Curve[v];
var pressure = frame.time;
//var value = frame.value;
float factor_at_this_pressure = 1;
if (is_air_breather && original_stats.atmosphereCurves[i].Curve.length == 1)
{
factor_at_this_pressure = improvement_factor_atm; // Air-breathing engines have a pressure curve starting at 0, but they should use Atm. as improvement factor.
}
else if (Math.Abs(pressure) < Single.Epsilon)
{
factor_at_this_pressure = improvement_factor_vac; // In complete vacuum
}
else if (pressure >= 1)
{
factor_at_this_pressure = improvement_factor_atm; // At lowest kerbal atmosphere
}
else
{
factor_at_this_pressure = (1 - pressure) * improvement_factor_vac + pressure * improvement_factor_atm; // Mix both
}
var new_value = frame.value * factor_at_this_pressure;
fc.Add(pressure, new_value);
}
if (engine_modules != null)
{
engine_modules[i].atmosphereCurve = fc;
}
else if (rcs_module)
{
rcs_module.atmosphereCurve = fc; // There is only one rcs-module
}
}
return(0);
}
