| public static VesselInAtmosphere ( Vessel vessel ) : bool | ||
| vessel | Vessel | |
| return | bool | |
public override void OnFixedUpdate()
{
// convect
if (Utils.VesselInAtmosphere(this.vessel))
{
double pressure = FlightGlobals.getStaticPressure(vessel.transform.position);
availableHeatRejection = PressureCurve.Evaluate((float)pressure);
}
else
{
availableHeatRejection = 0f;
}
if (State != RadiatorState.Deployed && State != RadiatorState.Broken)
{
availableHeatRejection += HeatRadiatedClosed;
}
else if (State == RadiatorState.Broken)
{
availableHeatRejection = 0f;
}
else
{
availableHeatRejection += HeatRadiated;
}
foreach (AnimationState state in heatStates)
{
state.normalizedTime = Mathf.MoveTowards(state.normalizedTime, Mathf.Clamp01(requestedHeatRejection / availableHeatRejection), 0.1f * TimeWarp.fixedDeltaTime);
}
HeatRejectionGUI = String.Format("{0:F1} kW", availableHeatRejection);
}
public override void OnFixedUpdate()
{
float wattsRadiated = RadiatorEfficiency();
float wattsConvected = 0f;
float wattsGoal = 0f;
float wattsError = 0f;
float goalTemperature = 0f;
double fuelUsage = 0d;
// calculate atmoshperic dissipation
if (Utils.VesselInAtmosphere(vessel))
{
//Debug.Log("NFPP: Debugging Pressure Curves... " + PressureCurve.maxTime.ToString() + " and " + PressureCurve.minTime.ToString() );
float pressure = (float)FlightGlobals.getStaticPressure(vessel.transform.position);
wattsConvected = PressureCurve.Evaluate(pressure);
}
if (Enabled)
{
// Don't let thermal wattage go over radiation+convection
if (SafetyLimit)
{
wattsGoal = Mathf.Min(ThermalPower * CurrentPowerPercent, wattsRadiated + wattsConvected);
}
// Allow thermal power to go to maximum
else
{
wattsGoal = ThermalPower * CurrentPowerPercent;
}
}
else
{
wattsGoal = 0f;
}
currentThermalPower = Mathf.MoveTowards(currentThermalPower, wattsGoal, TimeWarp.fixedDeltaTime * ThermalPowerResponseRate);
thermalPowerRatio = (double)(currentThermalPower / ThermalPower);
// what the wattage difference between cooling and power is
wattsError = currentThermalPower - wattsRadiated - wattsConvected;
//Debug.Log("Watt error: " + wattsError.ToString());
if (wattsError > 0f)
{
// increase the overheat amount
overheatAmount += TimeWarp.fixedDeltaTime * (wattsError / (this.part.mass * 500f));
if (UseStagingIcon)
{
infoBox.SetValue(Mathf.Clamp01((CurrentCoreTemperature - MaxCoreTemperature) / (MeltdownCoreTemperature - MaxCoreTemperature)));
}
}
else
{
//overheatAmount += TimeWarp.fixedDeltaTime * (wattsError / (this.part.mass * 500f));
overheatAmount = Mathf.MoveTowards(overheatAmount, 0f, TimeWarp.fixedDeltaTime * Mathf.Max((wattsError / (this.part.mass * 500f)), 1f));
if (UseStagingIcon)
{
infoBox.SetValue(Mathf.Clamp01((CurrentCoreTemperature - MaxCoreTemperature) / (MeltdownCoreTemperature - MaxCoreTemperature)));
}
}
//Debug.Log("Overheat total: " + overheatAmount.ToString());
goalTemperature = (float)thermalPowerRatio * MaxCoreTemperature + Mathf.Clamp(overheatAmount, 0f, 5000f);
CurrentCoreTemperature = Mathf.MoveTowards(CurrentCoreTemperature, goalTemperature, TimeWarp.fixedDeltaTime * CoreTemperatureResponseRate);
coreTemperatureRatio = (double)(CurrentCoreTemperature / MaxCoreTemperature);
// Reactor meltdown!
if (CurrentCoreTemperature >= MeltdownCoreTemperature)
{
CoreDamagePercent = 1f;
CoreStatus = "Complete Meltdown!";
if (Enabled)
{
ShutdownReactor();
}
}
else if (CurrentCoreTemperature >= MaxCoreTemperature)
{
CoreDamagePercent = Mathf.Max(CoreDamagePercent, (CurrentCoreTemperature - MaxCoreTemperature * 1.15f) / (MeltdownCoreTemperature - MaxCoreTemperature * 1.15f));
if (CoreDamagePercent < 1f)
{
CoreStatus = String.Format("{0:F0} %", Mathf.Clamp01(1f - CoreDamagePercent) * 100f);
}
}
else
{
if (CoreDamagePercent < 1f)
{
CoreStatus = String.Format("{0:F0} %", Mathf.Clamp01(1f - CoreDamagePercent) * 100f);
}
}
// heat animation
if (CoreDamagePercent >= 1f)
{
generatorAnimation.SetHeatLevel(1f);
}
else
{
generatorAnimation.SetHeatLevel(Mathf.Clamp01((CurrentCoreTemperature - MaxCoreTemperature) / MeltdownCoreTemperature));
}
currentGeneration = thermalPowerRatio * PowerGenerationMaximum * (1f - CoreDamagePercent);
FuelStatus = FindTimeRemaining(BurnRate * coreTemperatureRatio);
// compute the fuel usage
fuelUsage = BurnRate * coreTemperatureRatio * TimeWarp.fixedDeltaTime;
double fuelAmt = this.part.RequestResource("EnrichedUranium", fuelUsage);
this.part.RequestResource("DepletedUranium", -fuelAmt);
if (fuelAmt <= 0d && fuelUsage > 0d)
{
FuelStatus = "No fuel remaining";
ShutdownReactor();
}
LastFuelUpdate = (float)vessel.missionTime;
this.part.RequestResource("ElectricCharge", -currentGeneration * TimeWarp.fixedDeltaTime);
}
