void render_environment(Vessel v, vessel_info vi)
{
// determine atmosphere
string atmo_desc = "none";
if (Sim.Underwater(v)) atmo_desc = "ocean";
else if (vi.atmo_factor < 1.0) //< inside an atmosphere
{
atmo_desc = vi.breathable ? "breathable" : "not breathable";
}
render_title("ENVIRONMENT");
render_content("temperature", Lib.HumanReadableTemp(vi.temperature));
render_content("radiation", Lib.HumanReadableRadiationRate(vi.radiation));
render_content("atmosphere", atmo_desc);
if (Settings.ShowFlux)
{
render_content("solar flux", Lib.HumanReadableFlux(vi.solar_flux));
render_content("albedo flux", Lib.HumanReadableFlux(vi.albedo_flux));
render_content("body flux", Lib.HumanReadableFlux(vi.body_flux));
}
if (Settings.RelativisticTime)
{
render_content("time dilation", Lib.HumanReadablePerc(1.0 / vi.time_dilation));
}
render_space();
}
// called every frame
public void Update()
{
if (HighLogic.LoadedSceneIsEditor) return;
// get info from cache
vessel_info vi = Cache.VesselInfo(this.vessel);
// do nothing if vessel is invalid
if (!vi.is_valid) return;
// set reading
switch(type)
{
case "temperature": Status = Lib.HumanReadableTemp(vi.temperature); break;
case "radiation": Status = vi.radiation > double.Epsilon ? Lib.HumanReadableRadiationRate(vi.radiation) : "nominal"; break;
case "solar_flux": Status = Lib.HumanReadableFlux(vi.solar_flux); break;
case "albedo_flux": Status = Lib.HumanReadableFlux(vi.albedo_flux); break;
case "body_flux": Status = Lib.HumanReadableFlux(vi.body_flux); break;
}
// manage pin animation on geiger counter
if (pinanim != null && type == "radiation")
{
pinanim["pinanim"].normalizedTime = Lib.Clamp(pinfc.Evaluate((float)(vi.radiation * 3600.0)), 0.0f, 1.0f);
pinanim.Play();
}
}
// called every frame
public void Update()
{
if (HighLogic.LoadedSceneIsEditor) return;
vessel_info vi = Cache.VesselInfo(this.vessel);
switch(type)
{
case "temperature": Status = Lib.HumanReadableTemp(vi.temperature); break;
case "radiation": Status = vi.env_radiation > double.Epsilon ? Lib.HumanReadableRadiationRate(vi.env_radiation) : "nominal"; break;
}
if (pinanim != null && type == "radiation")
{
pinanim["pinanim"].normalizedTime = pinfc.Evaluate((float)vi.env_radiation);
}
}
void render_internal_space(Vessel v, vessel_info vi, List<ProtoCrewMember> crew)
{
// do not render internal space info for eva vessels
if (v.isEVA) return;
// if there is no crew, no space will be found, so do nothing in that case
if (crew.Count == 0) return;
// collect set of spaces
// note: this is guaranteed to get at least a space (because there is at least one crew member)
List<space_details> spaces = new List<space_details>();
foreach(var c in crew)
{
kerbal_data kd = DB.KerbalData(c.name);
space_details sd = spaces.Find(k => k.name == kd.space_name);
if (sd == null)
{
sd = new space_details();
sd.name = kd.space_name;
sd.living_space = kd.living_space;
sd.entertainment = kd.entertainment;
sd.shielding = kd.shielding;
spaces.Add(sd);
}
++sd.crew_count;
}
// select a space
space_details space = spaces[space_index % spaces.Count];
// render it
string radiation_txt = vi.radiation > double.Epsilon
? Lib.BuildString(" <i>(", Lib.HumanReadableRadiationRate(vi.radiation * (1.0 - space.shielding)), ")</i>")
: "";
render_title(space.name.Length > 0 && spaces.Count > 1 ? Lib.Epsilon(space.name.ToUpper(), 20) : "VESSEL", ref space_index, spaces.Count);
render_content("living space", QualityOfLife.LivingSpaceToString(space.living_space));
render_content("entertainment", QualityOfLife.EntertainmentToString(space.entertainment));
render_content("shielding", Lib.BuildString(Radiation.ShieldingToString(space.shielding), radiation_txt));
render_space();
}
public void FixedUpdate()
{
// in any scene: update the RMB ui
Status = Lib.HumanReadableRadiationRate(Math.Abs(radiation) * intensity);
// do nothing else in the editor
if (HighLogic.LoadedSceneIsEditor) return;
// if there is ec consumption
if (ec_rate > double.Epsilon)
{
// get vessel info from the cache
vessel_info vi = Cache.VesselInfo(vessel);
// do nothing if vessel is invalid
if (!vi.is_valid) return;
// get resource cache
resource_info ec = ResourceCache.Info(vessel, "ElectricCharge");
// get elapsed time
double elapsed_s = Kerbalism.elapsed_s * vi.time_dilation;
// if there is enough EC
// note: comparing against amount in previous simulation step
if (ec.amount > double.Epsilon)
{
// consume EC
ec.Consume(ec_rate * intensity * elapsed_s);
}
// else disable it
else
{
intensity = 0.0f;
}
}
}
// draw the window
void render(int _)
{
// shortcut
CelestialBody sun = FlightGlobals.Bodies[0];
// get selected body
CelestialBody body = Lib.SelectedBody();
// calculate simulation values
double atmo_factor = Sim.AtmosphereFactor(body, 0.7071);
double gamma_factor = Sim.GammaTransparency(body, 0.0);
double sun_dist = Sim.Apoapsis(Lib.PlanetarySystem(body)) - sun.Radius - body.Radius;
Vector3d sun_dir = (sun.position - body.position).normalized;
double solar_flux = Sim.SolarFlux(sun_dist) * atmo_factor;
double albedo_flux = Sim.AlbedoFlux(body, body.position + sun_dir * body.Radius);
double body_flux = Sim.BodyFlux(body, 0.0);
double total_flux = solar_flux + albedo_flux + body_flux + Sim.BackgroundFlux();
double temperature = body.atmosphere ? body.GetTemperature(0.0) : Sim.BlackBodyTemperature(total_flux);
// calculate night-side temperature
double total_flux_min = Sim.AlbedoFlux(body, body.position - sun_dir * body.Radius) + body_flux + Sim.BackgroundFlux();
double temperature_min = Sim.BlackBodyTemperature(total_flux_min);
// calculate radiation at body surface
double radiation = Radiation.ComputeSurface(body, gamma_factor);
// draw pseudo-title
GUILayout.BeginHorizontal();
GUILayout.Label(body.bodyName.ToUpper(), top_style);
GUILayout.EndHorizontal();
// surface panel
string temperature_str = body.atmosphere
? Lib.HumanReadableTemp(temperature)
: Lib.BuildString(Lib.HumanReadableTemp(temperature_min), " / ", Lib.HumanReadableTemp(temperature));
render_title("SURFACE");
render_content("temperature", temperature_str);
render_content("radiation", Lib.HumanReadableRadiationRate(radiation));
render_content("solar flux", Lib.HumanReadableFlux(solar_flux));
render_space();
// atmosphere panel
if (body.atmosphere)
{
render_title("ATMOSPHERE");
render_content("breathable", body.atmosphereContainsOxygen ? "yes" : "no");
render_content("light absorption", Lib.HumanReadablePerc(1.0 - Sim.AtmosphereFactor(body, 0.7071)));
render_content("gamma absorption", Lib.HumanReadablePerc(1.0 - Sim.GammaTransparency(body, 0.0)));
render_space();
}
// rendering panel
render_title("RENDERING");
render_content("inner belt", ref Radiation.show_inner);
render_content("outer belt", ref Radiation.show_outer);
render_content("magnetopause", ref Radiation.show_pause);
render_space();
// draw footer
GUILayout.BeginHorizontal();
GUILayout.Label("(ALT+N to open and close)", bot_style);
if (Lib.IsClicked()) Close();
GUILayout.EndHorizontal();
// enable dragging
GUI.DragWindow(drag_rect);
}
void render_info()
{
// find vessel
Vessel v = FlightGlobals.Vessels.Find(k => k.id == vessel_id);
// forget vessel if it doesn't exist anymore, or if its a dead eva kerbal
if (v == null || EVA.IsDead(v)) { vessel_id = Guid.Empty; return; }
// get info from the cache
vessel_info vi = Cache.VesselInfo(v);
render_title("ENVIRONMENT");
render_content("Temperature:\t", Lib.HumanReadableTemp(vi.temperature));
render_content("Radiation:\t", Lib.HumanReadableRadiationRate(vi.env_radiation));
render_content("Atmosphere:\t", v.mainBody.atmosphere ? " yes" + (vi.breathable ? " <i>(breathable)</i>" : "") : "no");
render_space();
// render supplies
if (Kerbalism.supply_rules.Count > 0 || Kerbalism.ec_rule != null)
{
render_title("SUPPLIES");
if (Kerbalism.ec_rule != null)
{
var vmon = vi.vmon[Kerbalism.ec_rule.name];
render_content(fix_title("Battery:"), vmon.level > double.Epsilon ? Lib.HumanReadableDuration(vmon.depletion) : "none");
}
if (Lib.CrewCapacity(v) > 0)
{
foreach(Rule r in Kerbalism.supply_rules)
{
var vmon = vi.vmon[r.name];
render_content(fix_title(r.resource_name + ":"), vmon.level > double.Epsilon ? Lib.HumanReadableDuration(vmon.depletion) : "none");
}
}
render_space();
}
// get crew
var crew = v.loaded ? v.GetVesselCrew() : v.protoVessel.GetVesselCrew();
// do not render internal spaces info for eva vessels
if (!v.isEVA)
{
// collect set of spaces
Dictionary<string, space_details> spaces = new Dictionary<string, space_details>();
foreach(var c in crew)
{
kerbal_data kd = DB.KerbalData(c.name);
if (!spaces.ContainsKey(kd.space_name))
{
space_details sd = new space_details();
sd.living_space = kd.living_space;
sd.entertainment = kd.entertainment;
sd.shielding = kd.shielding;
spaces.Add(kd.space_name, sd);
}
++(spaces[kd.space_name].crew_count);
}
// for each space
foreach(var space in spaces)
{
string space_name = space.Key;
space_details det = space.Value;
string radiation_txt = vi.env_radiation > double.Epsilon
? " <i>(" + Lib.HumanReadableRadiationRate(vi.env_radiation * (1.0 - det.shielding)) + ")</i>"
: "";
render_title(space_name.Length > 0 ? space_name.ToUpper() : v.isEVA ? "EVA" : "VESSEL");
render_content("Living space:\t", QualityOfLife.LivingSpaceToString(det.living_space));
render_content("Entertainment:\t", QualityOfLife.EntertainmentToString(det.entertainment));
render_content("Shielding:\t", Radiation.ShieldingToString(det.shielding) + radiation_txt);
render_space();
}
}
// for each kerbal
if (Kerbalism.rules.Count > 0)
{
foreach(var c in crew)
{
kerbal_data kd = DB.KerbalData(c.name);
render_title(c.name.ToUpper());
foreach(var q in Kerbalism.rules)
{
Rule r = q.Value;
if (r.degeneration > double.Epsilon)
{
var kmon = DB.KmonData(c.name, r.name);
var bar = Lib.ProgressBar(23, kmon.problem, r.warning_threshold, r.danger_threshold, r.fatal_threshold, kd.disabled > 0 ? "cyan" : "");
render_content(fix_title(r.name + ":"), bar);
}
}
if (kd.space_name.Length > 0 && !v.isEVA) render_content("Inside:\t\t", kd.space_name);
if (kd.disabled > 0) render_content("Hibernated:\t", "yes");
render_space();
}
}
// for each greenhouse
var greenhouses = Greenhouse.GetGreenhouses(v);
foreach(var greenhouse in greenhouses)
{
render_title("GREENHOUSE");
render_content("Lighting:\t\t", (greenhouse.lighting * 100.0).ToString("F0") + "%");
render_content("Growth:\t\t", (greenhouse.growth * 100.0).ToString("F0") + "%");
render_content("Harvest:\t\t", Lib.HumanReadableDuration(greenhouse.growing > double.Epsilon ? 1.0 / greenhouse.growing : 0.0));
render_space();
}
}
// editor/r&d info
public override string GetInfo()
{
return Lib.BuildString
(
Lib.Specifics(tooltip),
Lib.Specifics(ec_rate > double.Epsilon, "ElectricCharge", Lib.HumanReadableRate(ec_rate)),
Lib.Specifics(true, radiation >= 0.0 ? "Ionizing radiation" : "Active shielding", Lib.HumanReadableRadiationRate(Math.Abs(radiation)))
);
}