void render_ec(ec_data ec)
{
bool shadow_different = Math.Abs(ec.generated_sunlight - ec.generated_shadow) > double.Epsilon;
string generated_str = Lib.HumanReadableRate(ec.generated_sunlight) + (shadow_different ? "</b> / <b>" + Lib.HumanReadableRate(ec.generated_shadow) : "");
string life_str = Lib.HumanReadableDuration(ec.life_expectancy_sunlight) + (shadow_different ? "</b> / <b>" + Lib.HumanReadableDuration(ec.life_expectancy_shadow) : "");
render_title("ELECTRIC CHARGE");
render_content("storage", Lib.ValueOrNone(ec.storage));
render_content("consumed", Lib.HumanReadableRate(ec.consumed));
render_content("generated", generated_str, "sunlight / shadow");
render_content("life expectancy", life_str, "sunlight / shadow");
render_space();
}
public static reliability_data analyze_reliability(List<Part> parts, ec_data ec, signal_data signal)
{
// store data
reliability_data reliability = new reliability_data();
// get manufacturing quality
reliability.quality = Malfunction.DeduceQuality();
// count parts that can fail
uint components = 0;
// scan the parts
foreach(Part p in parts)
{
// for each module
foreach(PartModule m in p.Modules)
{
// malfunctions
if (m.moduleName == "Malfunction")
{
Malfunction mm = (Malfunction)m;
++components;
double avg_lifetime = (mm.min_lifetime + mm.max_lifetime) * 0.5 * reliability.quality;
reliability.failure_year += (60.0 * 60.0 * Lib.HoursInDay() * Lib.DaysInYear()) / avg_lifetime;
}
}
}
// calculate reliability data
if (components > 0) reliability.failure_year /= (double)components;
double ec_redundancy = ec.best_ec_generator < ec.generated_sunlight ? (ec.generated_sunlight - ec.best_ec_generator) / ec.generated_sunlight : 0.0;
double antenna_redundancy = signal.second_best_range > 0.0 ? signal.second_best_range / signal.range : 0.0;
List<string> redundancies = new List<string>();
if (ec_redundancy >= 0.5) redundancies.Add("ec");
if (antenna_redundancy >= 0.99) redundancies.Add("antenna");
if (redundancies.Count == 0) redundancies.Add("none");
reliability.redundancy = String.Join(", ", redundancies.ToArray());
// return data
return reliability;
}
public void render()
{
// if there is something in the editor
if (EditorLogic.RootPart != null)
{
// store situations and altitude multipliers
string[] situations = {"Landed", "Low Orbit", "Orbit", "High Orbit"};
double[] altitude_mults = {0.0, 0.33, 1.0, 3.0};
// get body, situation and altitude multiplier
CelestialBody body = FlightGlobals.Bodies[body_index];
string situation = situations[situation_index];
double altitude_mult = altitude_mults[situation_index];
// get parts recursively
List<Part> parts = Lib.GetPartsRecursively(EditorLogic.RootPart);
// analyze
environment_data env = analyze_environment(body, altitude_mult);
crew_data crew = analyze_crew(parts);
food_data food = analyze_food(parts, env, crew);
oxygen_data oxygen = analyze_oxygen(parts, env, crew);
signal_data signal = analyze_signal(parts);
qol_data qol = analyze_qol(parts, env, crew, signal);
radiation_data radiation = analyze_radiation(parts, env, crew);
ec_data ec = analyze_ec(parts, env, crew, food, oxygen, signal);
reliability_data reliability = analyze_reliability(parts, ec, signal);
// render menu
GUILayout.BeginHorizontal(row_style);
if (GUILayout.Button(body.name, leftmenu_style)) { body_index = (body_index + 1) % FlightGlobals.Bodies.Count; if (body_index == 0) ++body_index; }
if (GUILayout.Button("["+ (page + 1) + "/2]", midmenu_style)) { page = (page + 1) % 2; }
if (GUILayout.Button(situation, rightmenu_style)) { situation_index = (situation_index + 1) % situations.Length; }
GUILayout.EndHorizontal();
// page 1/2
if (page == 0)
{
// render
render_ec(ec);
render_food(food);
render_oxygen(oxygen);
render_qol(qol);
}
// page 2/2
else
{
// render
render_radiation(radiation, env, crew);
render_reliability(reliability, crew);
render_signal(signal, env, crew);
render_environment(env);
}
}
// if there is nothing in the editor
else
{
// render quote
GUILayout.FlexibleSpace();
GUILayout.BeginHorizontal();
GUILayout.Label("<i>In preparing for space, I have always found that\nplans are useless but planning is indispensable.\nWernher von Kerman</i>", quote_style);
GUILayout.EndHorizontal();
GUILayout.Space(10.0f);
}
}
public static ec_data analyze_ec(List<Part> parts, environment_data env, crew_data crew, food_data food, oxygen_data oxygen, signal_data signal)
{
// store data
ec_data ec = new ec_data();
// calculate climate cost
ec.consumed = (double)crew.count * env.temp_diff * Settings.ElectricChargePerSecond;
// scan the parts
foreach(Part p in parts)
{
// accumulate EC storage
ec.storage += Lib.GetResourceAmount(p, "ElectricCharge");
// remember if we already considered a resource converter module
// rationale: we assume only the first module in a converter is active
bool first_converter = true;
// for each module
foreach(PartModule m in p.Modules)
{
// command
if (m.moduleName == "ModuleCommand")
{
ModuleCommand mm = (ModuleCommand)m;
foreach(ModuleResource res in mm.inputResources)
{
if (res.name == "ElectricCharge")
{
ec.consumed += res.rate;
}
}
}
// solar panel
else if (m.moduleName == "ModuleDeployableSolarPanel")
{
ModuleDeployableSolarPanel mm = (ModuleDeployableSolarPanel)m;
double solar_k = (mm.useCurve ? mm.powerCurve.Evaluate((float)env.sun_dist) : env.sun_flux / Sim.SolarFluxAtHome());
double generated = mm.chargeRate * solar_k * env.atmo_factor;
ec.generated_sunlight += generated;
ec.best_ec_generator = Math.Max(ec.best_ec_generator, generated);
}
// generator
else if (m.moduleName == "ModuleGenerator")
{
// skip launch clamps, that include a generator
if (p.partInfo.name == "launchClamp1") continue;
ModuleGenerator mm = (ModuleGenerator)m;
foreach(ModuleResource res in mm.inputList)
{
if (res.name == "ElectricCharge")
{
ec.consumed += res.rate;
}
}
foreach(ModuleResource res in mm.outputList)
{
if (res.name == "ElectricCharge")
{
ec.generated_shadow += res.rate;
ec.generated_sunlight += res.rate;
ec.best_ec_generator = Math.Max(ec.best_ec_generator, res.rate);
}
}
}
// converter
// note: only electric charge is considered for resource converters
// note: we only consider the first resource converter in a part, and ignore the rest
else if (m.moduleName == "ModuleResourceConverter" && first_converter)
{
ModuleResourceConverter mm = (ModuleResourceConverter)m;
foreach(ResourceRatio rr in mm.inputList)
{
if (rr.ResourceName == "ElectricCharge")
{
ec.consumed += rr.Ratio;
}
}
foreach(ResourceRatio rr in mm.outputList)
{
if (rr.ResourceName == "ElectricCharge")
{
ec.generated_shadow += rr.Ratio;
ec.generated_sunlight += rr.Ratio;
ec.best_ec_generator = Math.Max(ec.best_ec_generator, rr.Ratio);
}
}
first_converter = false;
}
// harvester
// note: only electric charge is considered for resource harvesters
else if (m.moduleName == "ModuleResourceHarvester")
{
ModuleResourceHarvester mm = (ModuleResourceHarvester)m;
foreach(ResourceRatio rr in mm.inputList)
{
if (rr.ResourceName == "ElectricCharge")
{
ec.consumed += rr.Ratio;
}
}
}
// active radiators
else if (m.moduleName == "ModuleActiveRadiator")
{
ModuleActiveRadiator mm = (ModuleActiveRadiator)m;
if (mm.IsCooling)
{
foreach(var rr in mm.inputResources)
{
if (rr.name == "ElectricCharge")
{
ec.consumed += rr.rate;
}
}
}
}
// wheels
else if (m.moduleName == "ModuleWheelMotor")
{
ModuleWheelMotor mm = (ModuleWheelMotor)m;
if (mm.motorEnabled && mm.inputResource.name == "ElectricCharge")
{
ec.consumed += mm.inputResource.rate;
}
}
else if (m.moduleName == "ModuleWheelMotorSteering")
{
ModuleWheelMotorSteering mm = (ModuleWheelMotorSteering)m;
if (mm.motorEnabled && mm.inputResource.name == "ElectricCharge")
{
ec.consumed += mm.inputResource.rate;
}
}
// SCANsat support
else if (m.moduleName == "SCANsat" || m.moduleName == "ModuleSCANresourceScanner")
{
// include it in ec consumption, if deployed
if (SCANsat.isDeployed(p, m)) ec.consumed += Lib.ReflectionValue<float>(m, "power");
}
// NearFutureSolar support
// note: assume half the components are in sunlight, and average inclination is half
else if (m.moduleName == "ModuleCurvedSolarPanel")
{
// get total rate
double tot_rate = Lib.ReflectionValue<float>(m, "TotalEnergyRate");
// get number of components
int components = p.FindModelTransforms(Lib.ReflectionValue<string>(m, "PanelTransformName")).Length;
// approximate output
// 0.7071: average clamped cosine
ec.generated_sunlight += 0.7071 * tot_rate;
}
}
}
// include cost from greenhouses artificial lighting
ec.consumed += food.greenhouse_cost;
// include cost from scrubbers
ec.consumed += oxygen.scrubber_cost;
// include relay cost for the best relay antenna
ec.consumed += signal.relay_cost;
// finally, calculate life expectancy of ec
ec.life_expectancy_sunlight = ec.storage / Math.Max(ec.consumed - ec.generated_sunlight, 0.0);
ec.life_expectancy_shadow = ec.storage / Math.Max(ec.consumed - ec.generated_shadow, 0.0);
// return data
return ec;
}
