private void ExecuteRecipe(double k, Vessel_resources resources, double elapsed_s, Resource_recipe recipe)
{
// only execute processes if necessary
if (Math.Abs(k) < double.Epsilon)
{
return;
}
foreach (var p in inputs)
{
recipe.Input(p.Key, p.Value * k * elapsed_s);
}
foreach (var p in outputs)
{
recipe.Output(p.Key, p.Value * k * elapsed_s, dump.Check(p.Key));
}
foreach (var p in cures)
{
// TODO this assumes that the cure modifies always put the resource first
// works: modifier = _SickbayRDU,zerog works
// fails: modifier = zerog,_SickbayRDU
recipe.Cure(p.Key, p.Value * k * elapsed_s, modifiers[0]);
}
resources.Transform(recipe);
}
static void ProcessConverter(Vessel v, ProtoPartSnapshot p, ProtoPartModuleSnapshot m, ModuleResourceConverter converter, Vessel_resources resources, double elapsed_s)
{
// note: ignore stock temperature mechanic of converters
// note: ignore auto shutdown
// note: non-mandatory resources 'dynamically scale the ratios', that is exactly what mandatory resources do too (DERP ALERT)
// note: 'undo' stock behavior by forcing lastUpdateTime to now (to minimize overlapping calculations from this and stock post-facto simulation)
// if active
if (Lib.Proto.GetBool(m, "IsActivated"))
{
// determine if vessel is full of all output resources
// note: comparing against previous amount
bool full = true;
foreach (var or in converter.outputList)
{
Resource_info res = resources.Info(v, or.ResourceName);
full &= (res.level >= converter.FillAmount - double.Epsilon);
}
// if not full
if (!full)
{
// deduce crew bonus
int exp_level = -1;
if (converter.UseSpecialistBonus)
{
foreach (ProtoCrewMember c in Lib.CrewList(v))
{
if (c.experienceTrait.Effects.Find(k => k.Name == converter.ExperienceEffect) != null)
{
exp_level = Math.Max(exp_level, c.experienceLevel);
}
}
}
double exp_bonus = exp_level < 0
? converter.EfficiencyBonus * converter.SpecialistBonusBase
: converter.EfficiencyBonus * (converter.SpecialistBonusBase + (converter.SpecialistEfficiencyFactor * (exp_level + 1)));
// create and commit recipe
Resource_recipe recipe = new Resource_recipe(p);
foreach (var ir in converter.inputList)
{
recipe.Input(ir.ResourceName, ir.Ratio * exp_bonus * elapsed_s);
}
foreach (var or in converter.outputList)
{
recipe.Output(or.ResourceName, or.Ratio * exp_bonus * elapsed_s, or.DumpExcess);
}
resources.Transform(recipe);
}
// undo stock behavior by forcing last_update_time to now
Lib.Proto.Set(m, "lastUpdateTime", Planetarium.GetUniversalTime());
}
}
static void ProcessGenerator(Vessel v, ProtoPartSnapshot p, ProtoPartModuleSnapshot m, ModuleGenerator generator, Vessel_resources resources, double elapsed_s)
{
// if active
if (Lib.Proto.GetBool(m, "generatorIsActive"))
{
// create and commit recipe
Resource_recipe recipe = new Resource_recipe(p);
foreach (ModuleResource ir in generator.resHandler.inputResources)
{
recipe.Input(ir.name, ir.rate * elapsed_s);
}
foreach (ModuleResource or in generator.resHandler.outputResources)
{
recipe.Output(or.name, or.rate * elapsed_s, true);
}
resources.Transform(recipe);
}
}
public void Execute(Vessel v, Vessel_info vi, Vessel_resources resources, double elapsed_s)
{
// evaluate modifiers
double k = Modifiers.Evaluate(v, vi, resources, modifiers);
// only execute processes if necessary
if (k > double.Epsilon)
{
// prepare recipe
Resource_recipe recipe = new Resource_recipe();
foreach (var p in inputs)
{
recipe.Input(p.Key, p.Value * k * elapsed_s);
}
foreach (var p in outputs)
{
recipe.Output(p.Key, p.Value * k * elapsed_s, dump.Check(p.Key));
}
resources.Transform(recipe);
}
}
public static void BackgroundUpdate(Vessel v, ProtoPartModuleSnapshot m, Greenhouse g,
Vessel_info vi, Vessel_resources resources, double elapsed_s)
{
// get protomodule data
bool active = Lib.Proto.GetBool(m, "active");
double growth = Lib.Proto.GetDouble(m, "growth");
// if enabled and not ready for harvest
if (active && growth < 0.99)
{
// get resource handler
Resource_info ec = resources.Info(v, "ElectricCharge");
// calculate natural and artificial lighting
double natural = vi.solar_flux;
double artificial = Math.Max(g.light_tolerance - natural, 0.0);
// consume EC for the lamps, scaled by artificial light intensity
if (artificial > double.Epsilon)
{
ec.Consume(g.ec_rate * (artificial / g.light_tolerance) * elapsed_s, "greenhouse");
}
// reset artificial lighting if there is no ec left
// note: comparing against amount in previous simulation step
if (ec.amount <= double.Epsilon)
{
artificial = 0.0;
}
// execute recipe
Resource_recipe recipe = new Resource_recipe(g.part, "greenhouse");
foreach (ModuleResource input in g.resHandler.inputResources) //recipe.Input(input.name, input.rate * elapsed_s);
{
// WasteAtmosphere is primary combined input
if (g.WACO2 && input.name == "WasteAtmosphere")
{
recipe.Input(input.name, vi.breathable ? 0.0 : input.rate * elapsed_s, "CarbonDioxide");
}
// CarbonDioxide is secondary combined input
else if (g.WACO2 && input.name == "CarbonDioxide")
{
recipe.Input(input.name, vi.breathable ? 0.0 : input.rate * elapsed_s, "");
}
// if atmosphere is breathable disable WasteAtmosphere / CO2
else if (!g.WACO2 && (input.name == "CarbonDioxide" || input.name == "WasteAtmosphere"))
{
recipe.Input(input.name, vi.breathable ? 0.0 : input.rate, "");
}
else
{
recipe.Input(input.name, input.rate * elapsed_s);
}
}
foreach (ModuleResource output in g.resHandler.outputResources)
{
// if atmosphere is breathable disable Oxygen
if (output.name == "Oxygen")
{
recipe.Output(output.name, vi.breathable ? 0.0 : output.rate * elapsed_s, true);
}
else
{
recipe.Output(output.name, output.rate * elapsed_s, true);
}
}
resources.Transform(recipe);
// determine environment conditions
bool lighting = natural + artificial >= g.light_tolerance;
bool pressure = g.pressure_tolerance <= double.Epsilon || vi.pressure >= g.pressure_tolerance;
bool radiation = g.radiation_tolerance <= double.Epsilon || vi.radiation * (1.0 - vi.shielding) < g.radiation_tolerance;
// determine inputs conditions
// note: comparing against amounts in previous simulation step
bool inputs = true;
string missing_res = string.Empty;
bool dis_WACO2 = false;
foreach (ModuleResource input in g.resHandler.inputResources)
{
// combine WasteAtmosphere and CO2 if both exist
if (input.name == "WasteAtmosphere" || input.name == "CarbonDioxide")
{
if (dis_WACO2 || vi.breathable)
{
continue; // skip if already checked or atmosphere is breathable
}
if (g.WACO2)
{
if (resources.Info(v, "WasteAtmosphere").amount <= double.Epsilon && resources.Info(v, "CarbonDioxide").amount <= double.Epsilon)
{
inputs = false;
missing_res = "CarbonDioxide";
break;
}
dis_WACO2 = true;
continue;
}
}
if (resources.Info(v, input.name).amount <= double.Epsilon)
{
inputs = false;
missing_res = input.name;
break;
}
}
// if growing
if (lighting && pressure && radiation && inputs)
{
// increase growth
growth += g.crop_rate * elapsed_s;
growth = Math.Min(growth, 1.0);
// notify the user when crop can be harvested
if (growth >= 0.99)
{
Message.Post(Lib.BuildString("On <b>", v.vesselName, "</b> the crop is ready to be harvested"));
growth = 1.0;
}
}
// update time-to-harvest
double tta = (1.0 - growth) / g.crop_rate;
// update issues
string issue =
!inputs?Lib.BuildString("missing ", missing_res)
: !lighting ? "insufficient lighting"
: !pressure ? "insufficient pressure"
: !radiation ? "excessive radiation"
: string.Empty;
// update protomodule data
Lib.Proto.Set(m, "natural", natural);
Lib.Proto.Set(m, "artificial", artificial);
Lib.Proto.Set(m, "tta", tta);
Lib.Proto.Set(m, "issue", issue);
Lib.Proto.Set(m, "growth", growth);
}
}
public void FixedUpdate()
{
// do nothing in the editor
if (Lib.IsEditor())
{
return;
}
// if enabled and not ready for harvest
if (active && growth < 0.99)
{
// get vessel info from the cache
// - if the vessel is not valid (eg: flagged as debris) then solar flux will be 0 and landed false (but that's okay)
Vessel_info vi = Cache.VesselInfo(vessel);
// get resource cache
Vessel_resources resources = ResourceCache.Get(vessel);
Resource_info ec = resources.Info(vessel, "ElectricCharge");
// deal with corner cases when greenhouse is assembled using KIS
if (double.IsNaN(growth) || double.IsInfinity(growth))
{
growth = 0.0;
}
// calculate natural and artificial lighting
natural = vi.solar_flux;
artificial = Math.Max(light_tolerance - natural, 0.0);
// consume EC for the lamps, scaled by artificial light intensity
if (artificial > double.Epsilon)
{
ec.Consume(ec_rate * (artificial / light_tolerance) * Kerbalism.elapsed_s, "greenhouse");
}
// reset artificial lighting if there is no ec left
// - comparing against amount in previous simulation step
if (ec.amount <= double.Epsilon)
{
artificial = 0.0;
}
// execute recipe
Resource_recipe recipe = new Resource_recipe(part, "greenhouse");
foreach (ModuleResource input in resHandler.inputResources)
{
// WasteAtmosphere is primary combined input
if (WACO2 && input.name == "WasteAtmosphere")
{
recipe.Input(input.name, vi.breathable ? 0.0 : input.rate * Kerbalism.elapsed_s, "CarbonDioxide");
}
// CarbonDioxide is secondary combined input
else if (WACO2 && input.name == "CarbonDioxide")
{
recipe.Input(input.name, vi.breathable ? 0.0 : input.rate * Kerbalism.elapsed_s, "");
}
// if atmosphere is breathable disable WasteAtmosphere / CO2
else if (!WACO2 && (input.name == "CarbonDioxide" || input.name == "WasteAtmosphere"))
{
recipe.Input(input.name, vi.breathable ? 0.0 : input.rate, "");
}
else
{
recipe.Input(input.name, input.rate * Kerbalism.elapsed_s);
}
}
foreach (ModuleResource output in resHandler.outputResources)
{
// if atmosphere is breathable disable Oxygen
if (output.name == "Oxygen")
{
recipe.Output(output.name, vi.breathable ? 0.0 : output.rate * Kerbalism.elapsed_s, true);
}
else
{
recipe.Output(output.name, output.rate * Kerbalism.elapsed_s, true);
}
}
resources.Transform(recipe);
// determine environment conditions
bool lighting = natural + artificial >= light_tolerance;
bool pressure = pressure_tolerance <= double.Epsilon || vi.pressure >= pressure_tolerance;
bool radiation = radiation_tolerance <= double.Epsilon || vi.radiation * (1.0 - vi.shielding) < radiation_tolerance;
// determine input resources conditions
// - comparing against amounts in previous simulation step
bool inputs = true;
string missing_res = string.Empty;
bool dis_WACO2 = false;
foreach (ModuleResource input in resHandler.inputResources)
{
// combine WasteAtmosphere and CO2 if both exist
if (input.name == "WasteAtmosphere" || input.name == "CarbonDioxide")
{
if (dis_WACO2 || Cache.VesselInfo(vessel).breathable)
{
continue; // skip if already checked or atmosphere is breathable
}
if (WACO2)
{
if (resources.Info(vessel, "WasteAtmosphere").amount <= double.Epsilon && resources.Info(vessel, "CarbonDioxide").amount <= double.Epsilon)
{
inputs = false;
missing_res = "CarbonDioxide";
break;
}
dis_WACO2 = true;
continue;
}
}
if (resources.Info(vessel, input.name).amount <= double.Epsilon)
{
inputs = false;
missing_res = input.name;
break;
}
}
// if growing
if (lighting && pressure && radiation && inputs)
{
// increase growth
growth += crop_rate * Kerbalism.elapsed_s;
growth = Math.Min(growth, 1.0);
// notify the user when crop can be harvested
if (growth >= 0.99)
{
Message.Post(Lib.BuildString("On <b>", vessel.vesselName, "</b> the crop is ready to be harvested"));
growth = 1.0;
}
}
// update time-to-harvest
tta = (1.0 - growth) / crop_rate;
// update issues
issue =
!inputs?Lib.BuildString("missing ", missing_res)
: !lighting ? "insufficient lighting"
: !pressure ? "insufficient pressure"
: !radiation ? "excessive radiation"
: string.Empty;
}
}
static void ProcessAsteroidDrill(Vessel v, ProtoPartSnapshot p, ProtoPartModuleSnapshot m, ModuleAsteroidDrill asteroid_drill, Vessel_resources resources, double elapsed_s)
{
// note: untested
// note: ignore stock temperature mechanic of asteroid drills
// note: ignore auto shutdown
// note: 'undo' stock behavior by forcing lastUpdateTime to now (to minimize overlapping calculations from this and stock post-facto simulation)
// if active
if (Lib.Proto.GetBool(m, "IsActivated"))
{
// get asteroid data
ProtoPartModuleSnapshot asteroid_info = null;
ProtoPartModuleSnapshot asteroid_resource = null;
foreach (ProtoPartSnapshot pp in v.protoVessel.protoPartSnapshots)
{
if (asteroid_info == null)
{
asteroid_info = pp.modules.Find(k => k.moduleName == "ModuleAsteroidInfo");
}
if (asteroid_resource == null)
{
asteroid_resource = pp.modules.Find(k => k.moduleName == "ModuleAsteroidResource");
}
}
// if there is actually an asteroid attached to this active asteroid drill (it should)
if (asteroid_info != null && asteroid_resource != null)
{
// get some data
double mass_threshold = Lib.Proto.GetDouble(asteroid_info, "massThresholdVal");
double mass = Lib.Proto.GetDouble(asteroid_info, "currentMassVal");
double abundance = Lib.Proto.GetDouble(asteroid_resource, "abundance");
string res_name = Lib.Proto.GetString(asteroid_resource, "resourceName");
double res_density = PartResourceLibrary.Instance.GetDefinition(res_name).density;
// if asteroid isn't depleted
if (mass > mass_threshold && abundance > double.Epsilon)
{
// deduce crew bonus
int exp_level = -1;
if (asteroid_drill.UseSpecialistBonus)
{
foreach (ProtoCrewMember c in Lib.CrewList(v))
{
if (c.experienceTrait.Effects.Find(k => k.Name == asteroid_drill.ExperienceEffect) != null)
{
exp_level = Math.Max(exp_level, c.experienceLevel);
}
}
}
double exp_bonus = exp_level < 0
? asteroid_drill.EfficiencyBonus * asteroid_drill.SpecialistBonusBase
: asteroid_drill.EfficiencyBonus * (asteroid_drill.SpecialistBonusBase + (asteroid_drill.SpecialistEfficiencyFactor * (exp_level + 1)));
// determine resource extracted
double res_amount = abundance * asteroid_drill.Efficiency * exp_bonus * elapsed_s;
// transform EC into mined resource
Resource_recipe recipe = new Resource_recipe(p);
recipe.Input("ElectricCharge", asteroid_drill.PowerConsumption * elapsed_s);
recipe.Output(res_name, res_amount, true);
resources.Transform(recipe);
// if there was ec
// note: comparing against amount in previous simulation step
if (resources.Info(v, "ElectricCharge").amount > double.Epsilon)
{
// consume asteroid mass
Lib.Proto.Set(asteroid_info, "currentMassVal", (mass - res_density * res_amount));
}
}
}
// undo stock behavior by forcing last_update_time to now
Lib.Proto.Set(m, "lastUpdateTime", Planetarium.GetUniversalTime());
}
}
static void ProcessDrill(Vessel v, ProtoPartSnapshot p, ProtoPartModuleSnapshot m, ModuleResourceHarvester harvester, Vessel_resources resources, double elapsed_s)
{
// note: ignore stock temperature mechanic of harvesters
// note: ignore auto shutdown
// note: ignore depletion (stock seem to do the same)
// note: 'undo' stock behavior by forcing lastUpdateTime to now (to minimize overlapping calculations from this and stock post-facto simulation)
// if active
if (Lib.Proto.GetBool(m, "IsActivated"))
{
// do nothing if full
// note: comparing against previous amount
if (resources.Info(v, harvester.ResourceName).level < harvester.FillAmount - double.Epsilon)
{
// deduce crew bonus
int exp_level = -1;
if (harvester.UseSpecialistBonus)
{
foreach (ProtoCrewMember c in Lib.CrewList(v))
{
if (c.experienceTrait.Effects.Find(k => k.Name == harvester.ExperienceEffect) != null)
{
exp_level = Math.Max(exp_level, c.experienceLevel);
}
}
}
double exp_bonus = exp_level < 0
? harvester.EfficiencyBonus * harvester.SpecialistBonusBase
: harvester.EfficiencyBonus * (harvester.SpecialistBonusBase + (harvester.SpecialistEfficiencyFactor * (exp_level + 1)));
// detect amount of ore in the ground
AbundanceRequest request = new AbundanceRequest
{
Altitude = v.altitude,
BodyId = v.mainBody.flightGlobalsIndex,
CheckForLock = false,
Latitude = v.latitude,
Longitude = v.longitude,
ResourceType = (HarvestTypes)harvester.HarvesterType,
ResourceName = harvester.ResourceName
};
double abundance = ResourceMap.Instance.GetAbundance(request);
// if there is actually something (should be if active when unloaded)
if (abundance > harvester.HarvestThreshold)
{
// create and commit recipe
Resource_recipe recipe = new Resource_recipe(p);
foreach (var ir in harvester.inputList)
{
recipe.Input(ir.ResourceName, ir.Ratio * elapsed_s);
}
recipe.Output(harvester.ResourceName, abundance * harvester.Efficiency * exp_bonus * elapsed_s, true);
resources.Transform(recipe);
}
}
// undo stock behavior by forcing last_update_time to now
Lib.Proto.Set(m, "lastUpdateTime", Planetarium.GetUniversalTime());
}
}
public void Execute(Vessel v, Vessel_info vi, Vessel_resources resources, double elapsed_s)
{
// store list of crew to kill
List <ProtoCrewMember> deferred_kills = new List <ProtoCrewMember>();
// get input resource handler
Resource_info res = input.Length > 0 ? resources.Info(v, input) : null;
// determine message variant
uint variant = vi.temperature < PreferencesLifeSupport.Instance.survivalTemperature ? 0 : 1u;
// get product of all environment modifiers
double k = Modifiers.Evaluate(v, vi, resources, modifiers);
bool lifetime_enabled = PreferencesBasic.Instance.lifetime;
// for each crew
foreach (ProtoCrewMember c in Lib.CrewList(v))
{
// get kerbal data
KerbalData kd = DB.Kerbal(c.name);
// skip rescue kerbals
if (kd.rescue)
{
continue;
}
// skip disabled kerbals
if (kd.disabled)
{
continue;
}
// get kerbal property data from db
RuleData rd = kd.Rule(name);
rd.lifetime = lifetime_enabled && lifetime;
// if continuous
double step;
if (interval <= double.Epsilon)
{
// influence consumption by elapsed time
step = elapsed_s;
}
// if interval-based
else
{
// accumulate time
rd.time_since += elapsed_s;
// determine number of steps
step = Math.Floor(rd.time_since / interval);
// consume time
rd.time_since -= step * interval;
// remember if a meal is consumed/produced in this simulation step
if (step > 0.99)
{
res.SetMealHappened();
}
if (output.Length > 0 && step > 0.99)
{
ResourceCache.Info(v, output).SetMealHappened();
}
}
// if continuous, or if one or more intervals elapsed
if (step > double.Epsilon)
{
double r = rate * Variance(name, c, individuality); // kerbal-specific variance
// if there is a resource specified
if (res != null && r > double.Epsilon)
{
// determine amount of resource to consume
double required = r // consumption rate
* k // product of environment modifiers
* step; // seconds elapsed or number of steps
// if there is no output
if (output.Length == 0)
{
// simply consume (that is faster)
res.Consume(required);
}
// if there is an output and monitor is false
else if (!monitor)
{
// transform input into output resource
// - rules always dump excess overboard (because it is waste)
Resource_recipe recipe = new Resource_recipe((Part)null); // kerbals are not associated with a part
recipe.Input(input, required);
recipe.Output(output, required * ratio, true);
resources.Transform(recipe);
}
// if monitor then do not consume input resource and only produce output if resource percentage + monitor_offset is < 100%
else if ((res.amount / res.capacity) + monitor_offset < 1.0)
{
// simply produce (that is faster)
resources.Produce(v, output, required * ratio);
}
}
// degenerate:
// - if the environment modifier is not telling to reset (by being zero)
// - if the input threshold is reached if used
// - if this rule is resource-less, or if there was not enough resource in the vessel
if (input_threshold >= double.Epsilon)
{
if (res.amount >= double.Epsilon && res.capacity >= double.Epsilon)
{
trigger = (res.amount / res.capacity) + monitor_offset >= input_threshold;
}
else
{
trigger = false;
}
}
else
{
trigger = input.Length == 0 || res.amount <= double.Epsilon;
}
if (k > 0.0 && trigger)
{
rd.problem += degeneration // degeneration rate per-second or per-interval
* k // product of environment modifiers
* step // seconds elapsed or by number of steps
* Variance(name, c, variance); // kerbal-specific variance
}
// else slowly recover
else
{
rd.problem *= 1.0 / (1.0 + Math.Max(interval, 1.0) * step * 0.002);
}
}
bool do_breakdown = false;
if (breakdown && PreferencesBasic.Instance.stressBreakdowns)
{
// stress level
double breakdown_probability = rd.problem / warning_threshold;
breakdown_probability = Lib.Clamp(breakdown_probability, 0.0, 1.0);
// use the stupidity of a kerbal.
// however, nobody is perfect - not even a kerbal with a stupidity of 0.
breakdown_probability *= c.stupidity * 0.6 + 0.4;
// apply the weekly error rate
breakdown_probability *= PreferencesBasic.Instance.stressBreakdownRate;
// now we have the probability for one failure per week, based on the
// individual stupidity and stress level of the kerbal.
breakdown_probability = (breakdown_probability * elapsed_s) / (Lib.DaysInYear() * Lib.HoursInDay() * 3600);
if (breakdown_probability > Lib.RandomDouble())
{
do_breakdown = true;
// we're stressed out and just made a major mistake, this further increases the stress level...
rd.problem += warning_threshold * 0.05; // add 5% of the warning treshold to current stress level
}
}
// kill kerbal if necessary
if (rd.problem >= fatal_threshold)
{
if (fatal_message.Length > 0)
{
Message.Post(breakdown ? Severity.breakdown : Severity.fatality, Lib.ExpandMsg(fatal_message, v, c, variant));
}
if (breakdown)
{
do_breakdown = true;
// move back between warning and danger level
rd.problem = (warning_threshold + danger_threshold) * 0.5;
// make sure next danger message is shown
rd.message = 1;
}
else
{
deferred_kills.Add(c);
}
}
// show messages
else if (rd.problem >= danger_threshold && rd.message < 2)
{
if (danger_message.Length > 0)
{
Message.Post(Severity.danger, Lib.ExpandMsg(danger_message, v, c, variant));
}
rd.message = 2;
}
else if (rd.problem >= warning_threshold && rd.message < 1)
{
if (warning_message.Length > 0)
{
Message.Post(Severity.warning, Lib.ExpandMsg(warning_message, v, c, variant));
}
rd.message = 1;
}
else if (rd.problem < warning_threshold && rd.message > 0)
{
if (relax_message.Length > 0)
{
Message.Post(Severity.relax, Lib.ExpandMsg(relax_message, v, c, variant));
}
rd.message = 0;
}
if (do_breakdown)
{
// trigger breakdown event
Misc.Breakdown(v, c);
}
}
// execute the deferred kills
foreach (ProtoCrewMember c in deferred_kills)
{
Misc.Kill(v, c);
}
}
public void Execute(Vessel v, Vessel_info vi, Vessel_resources resources, double elapsed_s)
{
// store list of crew to kill
List <ProtoCrewMember> deferred_kills = new List <ProtoCrewMember>();
// get input resource handler
Resource_info res = input.Length > 0 ? resources.Info(v, input) : null;
// determine message variant
uint variant = vi.temperature < Settings.SurvivalTemperature ? 0 : 1u;
// get product of all environment modifiers
double k = Modifiers.Evaluate(v, vi, resources, modifiers);
// for each crew
foreach (ProtoCrewMember c in Lib.CrewList(v))
{
// get kerbal data
KerbalData kd = DB.Kerbal(c.name);
// skip rescue kerbals
if (kd.rescue)
{
continue;
}
// skip disabled kerbals
if (kd.disabled)
{
continue;
}
// get kerbal property data from db
RuleData rd = kd.Rule(name);
// if continuous
double step;
if (interval <= double.Epsilon)
{
// influence consumption by elapsed time
step = elapsed_s;
}
// if interval-based
else
{
// accumulate time
rd.time_since += elapsed_s;
// determine number of steps
step = Math.Floor(rd.time_since / interval);
// consume time
rd.time_since -= step * interval;
// remember if a meal is consumed/produced in this simulation step
res.meal_happened |= step > 0.99;
if (output.Length > 0)
{
ResourceCache.Info(v, output).meal_happened |= step > 0.99;
}
}
// if continuous, or if one or more intervals elapsed
if (step > double.Epsilon)
{
// if there is a resource specified
if (res != null && rate > double.Epsilon)
{
// determine amount of resource to consume
double required = rate // consumption rate
* k // product of environment modifiers
* step; // seconds elapsed or number of steps
// if there is no output
if (output.Length == 0)
{
// simply consume (that is faster)
res.Consume(required);
}
// if there is an output and monitor is false
else if (!monitor)
{
// transform input into output resource
// - rules always dump excess overboard (because it is waste)
Resource_recipe recipe = new Resource_recipe();
recipe.Input(input, required);
recipe.Output(output, required * ratio, true);
resources.Transform(recipe);
}
// if monitor then do not consume input resource and only produce output if resource percentage + monitor_offset is < 100%
else if ((res.amount / res.capacity) + monitor_offset < 1.0)
{
// simply produce (that is faster)
resources.Produce(v, output, required * ratio);
}
}
// degenerate:
// - if the environment modifier is not telling to reset (by being zero)
// - if the input threshold is reached if used
// - if this rule is resource-less, or if there was not enough resource in the vessel
if (input_threshold >= double.Epsilon)
{
if (res.amount >= double.Epsilon && res.capacity >= double.Epsilon)
{
trigger = (res.amount / res.capacity) + monitor_offset >= input_threshold;
}
else
{
trigger = false;
}
}
else
{
trigger = input.Length == 0 || res.amount <= double.Epsilon;
}
if (k > 0.0 && trigger)
{
rd.problem += degeneration // degeneration rate per-second or per-interval
* k // product of environment modifiers
* step // seconds elapsed or by number of steps
* Variance(c, variance); // kerbal-specific variance
}
// else slowly recover
else
{
rd.problem *= 1.0 / (1.0 + Math.Max(interval, 1.0) * step * 0.002);
rd.problem = Math.Max(rd.problem, 0.0);
}
}
// kill kerbal if necessary
if (rd.problem >= fatal_threshold)
{
if (fatal_message.Length > 0)
{
Message.Post(breakdown ? Severity.breakdown : Severity.fatality, Lib.ExpandMsg(fatal_message, v, c, variant));
}
if (breakdown)
{
// trigger breakdown event
Misc.Breakdown(v, c);
// move back between warning and danger level
rd.problem = (warning_threshold + danger_threshold) * 0.5;
// make sure next danger message is shown
rd.message = 1;
}
else
{
deferred_kills.Add(c);
}
}
// show messages
else if (rd.problem >= danger_threshold && rd.message < 2)
{
if (danger_message.Length > 0)
{
Message.Post(Severity.danger, Lib.ExpandMsg(danger_message, v, c, variant));
}
rd.message = 2;
}
else if (rd.problem >= warning_threshold && rd.message < 1)
{
if (warning_message.Length > 0)
{
Message.Post(Severity.warning, Lib.ExpandMsg(warning_message, v, c, variant));
}
rd.message = 1;
}
else if (rd.problem < warning_threshold && rd.message > 0)
{
if (relax_message.Length > 0)
{
Message.Post(Severity.relax, Lib.ExpandMsg(relax_message, v, c, variant));
}
rd.message = 0;
}
}
// execute the deferred kills
foreach (ProtoCrewMember c in deferred_kills)
{
Misc.Kill(v, c);
}
}