Пример #1
0
        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);
        }
Пример #2
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);
        }
Пример #3
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);
        }
Пример #4
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);
        }
Пример #5
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);
        }
Пример #6
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);
        }
Пример #7
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);
        }
Пример #8
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);
        }
Пример #9
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);
        }
Пример #10
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);
        }
Пример #11
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);
        }
Пример #12
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);
        }
Пример #13
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);
        }
Пример #14
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);
        }
Пример #15
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);
        }
Пример #16
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);
 }
Пример #17
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);
        }