Пример #1
0
        public override void OnStart(StartState state)
        {
            HeatShieldPreset.LoadPresets();
            if (!HeatShieldPreset.Initialized)
            {
                return;
            }

            if (availablePresetNames.Length > 0 && HighLogic.LoadedSceneIsEditor)
            {
                // RP-1 allows selecting all configs but will run validation when trying to add the vessel to build queue
                string[] unlockedPresetsName = RP1Found ? availablePresetNames : GetUnlockedPresets(availablePresetNames);
                UpdatePresetsList(unlockedPresetsName);
                Fields[nameof(heatShieldType)].uiControlEditor.onFieldChanged             =
                    Fields[nameof(heatShieldType)].uiControlEditor.onSymmetryFieldChanged =
                        (bf, ob) => ApplyPreset(ActivePreset);

                if (!onLoadFiredInEditor)
                {
                    EnsureBestAvailableConfigSelected();
                }
            }

            if (ActivePreset is null)
            {
                Debug.Log("[ROHeatshields] ActivePreset is null");
                heatShieldType = "default";
            }
        }
Пример #2
0
        public static void LoadPresets()
        {
            if (Initialized && Presets.Count > 0)
            {
                return;
            }

            var    nodes = GameDatabase.Instance.GetConfigNodes("ROHS_PRESET");
            string s     = string.Empty;

            foreach (var node in nodes)
            {
                HeatShieldPreset preset = null;

                if (node.TryGetValue("name", ref s) && !string.IsNullOrEmpty(s))
                {
                    preset = new HeatShieldPreset(node);
                }

                if (preset != null)
                {
                    Presets[preset.name] = preset;
                }

                UnityEngine.Debug.Log($"[ROHeatShields] Found and loaded preset {preset.name} ");
            }

            // initialize default fallback preset
            if (!Presets.ContainsKey("default"))
            {
                Presets["default"] = new HeatShieldPreset("default");
            }

            Initialized = true;
        }
Пример #3
0
        public void ApplyPreset(HeatShieldPreset p)
        {
            if (p is null)
            {
                Debug.Log("[ROHeatshields] invalid preset");
                return;
            }

            ResetPartToOriginal();

            if (p.maxTempOverride > 0)
            {
                part.maxTemp = p.maxTempOverride;
            }
            if (p.skinMaxTempOverride > 0)
            {
                part.skinMaxTemp = p.skinMaxTempOverride;
            }
            if (p.thermalMassModifierOverride > 0)
            {
                part.thermalMassModifier = p.thermalMassModifierOverride;
            }
            if (p.skinThermalMassModifierOverride > 0)
            {
                part.skinThermalMassModifier = p.skinThermalMassModifierOverride;
            }
            if (p.skinMassPerAreaOverride > 0)
            {
                part.skinMassPerArea = p.skinMassPerAreaOverride;
            }
            if (p.skinInternalConductionMultOverride > 0)
            {
                part.skinInternalConductionMult = p.skinInternalConductionMultOverride;
            }
            if (p.skinSkinConductionMultOverride > 0)
            {
                part.skinSkinConductionMult = p.skinSkinConductionMultOverride;
            }
            if (p.emissiveConstantOverride > 0)
            {
                part.emissiveConstant = p.emissiveConstantOverride;
            }
            if (p.heatConductivityOverride > 0)
            {
                part.heatConductivity = p.heatConductivityOverride;
            }

            // update ModuleAblator parameters, if present and used
            if (modAblator != null && !p.disableModAblator)
            {
                if (!string.IsNullOrWhiteSpace(p.AblativeResource))
                {
                    modAblator.ablativeResource = p.AblativeResource;
                }
                if (!string.IsNullOrWhiteSpace(p.OutputResource))
                {
                    modAblator.outputResource = p.OutputResource;
                }

                if (!string.IsNullOrWhiteSpace(p.NodeName))
                {
                    modAblator.nodeName = p.NodeName;
                }
                if (!string.IsNullOrWhiteSpace(p.CharModuleName))
                {
                    modAblator.charModuleName = p.CharModuleName;
                }
                if (!string.IsNullOrWhiteSpace(p.UnitsName))
                {
                    modAblator.unitsName = p.UnitsName;
                }

                if (p.LossExp.HasValue)
                {
                    modAblator.lossExp = p.LossExp.Value;
                }
                if (p.LossConst.HasValue)
                {
                    modAblator.lossConst = p.LossConst.Value;
                }
                if (p.PyrolysisLossFactor.HasValue)
                {
                    modAblator.pyrolysisLossFactor = p.PyrolysisLossFactor.Value;
                }
                if (p.AblationTempThresh.HasValue)
                {
                    modAblator.ablationTempThresh = p.AblationTempThresh.Value;
                }
                if (p.ReentryConductivity.HasValue)
                {
                    modAblator.reentryConductivity = p.ReentryConductivity.Value;
                }
                if (p.UseNode.HasValue)
                {
                    modAblator.useNode = p.UseNode.Value;
                }
                if (p.CharAlpha.HasValue)
                {
                    modAblator.charAlpha = p.CharAlpha.Value;
                }
                if (p.CharMax.HasValue)
                {
                    modAblator.charMax = p.CharMax.Value;
                }
                if (p.CharMin.HasValue)
                {
                    modAblator.charMin = p.CharMin.Value;
                }
                if (p.UseChar.HasValue)
                {
                    modAblator.useChar = p.UseChar.Value;
                }
                if (p.OutputMult.HasValue)
                {
                    modAblator.outputMult = p.OutputMult.Value;
                }
                if (p.InfoTemp.HasValue)
                {
                    modAblator.infoTemp = p.InfoTemp.Value;
                }
                if (p.Usekg.HasValue)
                {
                    modAblator.usekg = p.Usekg.Value;
                }
                if (p.NominalAmountRecip.HasValue)
                {
                    modAblator.nominalAmountRecip = p.NominalAmountRecip.Value;
                }
            }

            if (modAblator != null)
            {
                if (p.AblativeResource == null || ablatorResourceName != p.AblativeResource ||
                    p.OutputResource == null || outputResourceName != p.OutputResource ||
                    p.disableModAblator)
                {
                    RemoveAblatorResources();
                }

                ablatorResourceName = p.AblativeResource;
                outputResourceName  = p.OutputResource;

                modAblator.isEnabled = modAblator.enabled = !p.disableModAblator;
            }

            maxTemp     = part.maxTemp;
            skinMaxTemp = part.skinMaxTemp;

            //prevent DRE from ruining everything
            if (DREHandler.Found && HighLogic.LoadedSceneIsFlight)
            {
                DREHandler.SetOperationalTemps(part, maxTemp, skinMaxTemp);
            }

            if (!string.IsNullOrEmpty(p.description))
            {
                Fields[nameof(description)].guiActiveEditor = true;
                description = p.description;
            }
            else
            {
                Fields[nameof(description)].guiActiveEditor = false;
            }

            Debug.Log($"[ROHeatshields] loaded preset {p.name} for part {part.name}");
            UpdateHeatshieldValues();
        }