// return the total environent radiation at position specified
public static double Compute(Vessel v, Vector3d position, double gamma_transparency, double sunlight, out bool blackout,
out bool magnetosphere, out bool inner_belt, out bool outer_belt, out bool interstellar, out double shieldedRadiation)
{
// prepare out parameters
blackout = false;
magnetosphere = false;
inner_belt = false;
outer_belt = false;
interstellar = false;
shieldedRadiation = 0.0;
// no-op when Radiation is disabled
if (!Features.Radiation)
{
return(0.0);
}
// store stuff
Space gsm;
Vector3 p;
double D;
double r;
// accumulate radiation
double radiation = 0.0;
CelestialBody body = v.mainBody;
while (body != null)
{
// Compute radiation values from overlapping 3d fields (belts + magnetospheres)
RadiationBody rb = Info(body);
RadiationModel mf = rb.model;
// activity is [-0.15..1.05]
var activity = rb.SolarActivity(false);
if (mf.Has_field())
{
// transform to local space once
var scaled_position = ScaledSpace.LocalToScaledSpace(position);
// generate radii-normalized GSM space
gsm = Gsm_space(rb, true);
// move the point in GSM space
p = gsm.Transform_in(scaled_position);
// accumulate radiation and determine pause/belt flags
if (mf.has_inner)
{
D = mf.Inner_func(p);
inner_belt |= D < 0;
// allow for radiation field to grow/shrink with solar activity
D -= activity * 0.25 / mf.inner_radius;
r = RadiationInBelt(D, mf.inner_radius, rb.radiation_inner_gradient);
radiation += r * rb.radiation_inner * (1 + activity * 0.3);
}
if (mf.has_outer)
{
D = mf.Outer_func(p);
outer_belt |= D < 0;
// allow for radiation field to grow/shrink with solar activity
D -= activity * 0.25 / mf.outer_radius;
r = RadiationInBelt(D, mf.outer_radius, rb.radiation_outer_gradient);
radiation += r * rb.radiation_outer * (1 + activity * 0.3);
}
if (mf.has_pause)
{
gsm = Gsm_space(rb, false);
p = gsm.Transform_in(scaled_position);
D = mf.Pause_func(p);
radiation += Lib.Clamp(D / -0.1332f, 0.0f, 1.0f) * rb.RadiationPause();
magnetosphere |= D < 0.0f && !Lib.IsSun(rb.body); //< ignore heliopause
interstellar |= D > 0.0f && Lib.IsSun(rb.body); //< outside heliopause
}
}
if (rb.radiation_surface > 0 && body != v.mainBody)
{
Vector3d direction;
double distance;
if (Sim.IsBodyVisible(v, position, body, v.KerbalismData().EnvVisibleBodies, out direction, out distance))
{
var r0 = RadiationR0(rb);
var r1 = DistanceRadiation(r0, distance);
// clamp to max. surface radiation. when loading on a rescaled system, the vessel can appear to be within the sun for a few ticks
radiation += Math.Min(r1, rb.radiation_surface);
//if (v.loaded) Lib.Log("Radiation " + v + " from surface of " + body + ": " + Lib.HumanReadableRadiation(radiation) + " gamma: " + Lib.HumanReadableRadiation(r1));
}
}
// avoid loops in the chain
body = (body.referenceBody != null && body.referenceBody.referenceBody == body) ? null : body.referenceBody;
}
// add extern radiation
radiation += Settings.ExternRadiation / 3600.0;
//if (v.loaded) Lib.Log("Radiation " + v + " extern: " + Lib.HumanReadableRadiation(radiation) + " gamma: " + Lib.HumanReadableRadiation(PreferencesStorm.Instance.ExternRadiation));
// apply gamma transparency if inside atmosphere
radiation *= gamma_transparency;
//if (v.loaded) Lib.Log("Radiation " + v + " after gamma: " + Lib.HumanReadableRadiation(radiation) + " transparency: " + gamma_transparency);
// add surface radiation of the body itself
if (Lib.IsSun(v.mainBody) && v.altitude < v.mainBody.Radius)
{
if (v.altitude > v.mainBody.Radius)
{
radiation += DistanceRadiation(RadiationR0(Info(v.mainBody)), v.altitude);
}
}
//if (v.loaded) Lib.Log("Radiation " + v + " from current main body: " + Lib.HumanReadableRadiation(radiation) + " gamma: " + Lib.HumanReadableRadiation(DistanceRadiation(RadiationR0(Info(v.mainBody)), v.altitude)));
shieldedRadiation = radiation;
// if there is a storm in progress
if (Storm.InProgress(v))
{
// inside a magnetopause (except heliosphere), blackout the signal
// outside, add storm radiations modulated by sun visibility
if (magnetosphere)
{
blackout = true;
}
else
{
var vd = v.KerbalismData();
var activity = Info(vd.EnvMainSun.SunData.body).SolarActivity(false) / 2.0;
var strength = PreferencesRadiation.Instance.StormRadiation * sunlight * (activity + 0.5);
radiation += strength;
shieldedRadiation += vd.EnvHabitatInfo.AverageHabitatRadiation(strength);
}
}
// add emitter radiation after atmosphere transparency
var emitterRadiation = Emitter.Total(v);
radiation += emitterRadiation;
shieldedRadiation += emitterRadiation;
//if (v.loaded) Lib.Log("Radiation " + v + " after emitters: " + Lib.HumanReadableRadiation(radiation));
// for EVAs, add the effect of nearby emitters
if (v.isEVA)
{
var nearbyEmitters = Emitter.Nearby(v);
radiation += nearbyEmitters;
shieldedRadiation += nearbyEmitters;
}
var passiveShielding = PassiveShield.Total(v);
shieldedRadiation -= passiveShielding;
//if (v.loaded) Lib.Log("Radiation " + v + " before clamp: " + Lib.HumanReadableRadiation(radiation));
// clamp radiation to positive range
// note: we avoid radiation going to zero by using a small positive value
radiation = Math.Max(radiation, Nominal);
shieldedRadiation = Math.Max(shieldedRadiation, Nominal);
// if (v.loaded) Lib.Log("Radiation " + v + " after clamp: " + Lib.HumanReadableRadiation(radiation));
// return radiation
return(radiation);
}
// called at every simulation step
public void FixedUpdate()
{
// do nothing if paused
if (Lib.IsPaused()) return;
// do nothing if DB isn't ready
if (!DB.Ready()) return;
// for each vessel
foreach(Vessel vessel in FlightGlobals.Vessels)
{
// skip invalid vessels
if (!Lib.IsVessel(vessel)) continue;
// skip loaded vessels
if (vessel.loaded) continue;
// get vessel info from the cache
vessel_info info = Cache.VesselInfo(vessel);
// calculate atmospheric factor (proportion of flux not blocked by atmosphere)
double atmo_factor = Sim.AtmosphereFactor(vessel.mainBody, info.position, info.sun_dir);
// for each part
foreach(ProtoPartSnapshot part in vessel.protoVessel.protoPartSnapshots)
{
// get part prefab (required for module properties)
Part part_prefab = PartLoader.getPartInfoByName(part.partName).partPrefab;
// store index of ModuleResourceConverter to process
// rationale: a part can contain multiple resource converters
int converter_index = 0;
// for each module
foreach(ProtoPartModuleSnapshot module in part.modules)
{
// command module
if (module.moduleName == "ModuleCommand")
{
// get module from prefab
ModuleCommand command = part_prefab.Modules.GetModules<ModuleCommand>()[0];
// do not consume if this is a MCM with no crew
// rationale: for consistency, the game doesn't consume resources for MCM without crew in loaded vessels
// this make some sense: you left a vessel with some battery and nobody on board, you expect it to not consume EC
if (command.minimumCrew == 0 || part.protoModuleCrew.Count > 0)
{
// for each input resource
foreach(ModuleResource ir in command.inputResources)
{
// consume the resource
Lib.RequestResource(vessel, ir.name, ir.rate * TimeWarp.fixedDeltaTime);
}
}
}
// solar panel
else if (module.moduleName == "ModuleDeployableSolarPanel")
{
// determine if extended
bool extended = module.moduleValues.GetValue("stateString") == ModuleDeployableSolarPanel.panelStates.EXTENDED.ToString();
// if in sunlight and extended
if (info.sunlight && extended)
{
// get module from prefab
ModuleDeployableSolarPanel panel = part_prefab.Modules.GetModules<ModuleDeployableSolarPanel>()[0];
// produce electric charge
Lib.RequestResource(vessel, "ElectricCharge", -PanelOutput(vessel, part, panel, info.sun_dir, info.sun_dist, atmo_factor) * TimeWarp.fixedDeltaTime * Malfunction.Penalty(part));
}
}
// generator
// note: assume generators require all input
else if (module.moduleName == "ModuleGenerator")
{
// determine if active
bool activated = Convert.ToBoolean(module.moduleValues.GetValue("generatorIsActive"));
// if active
if (activated)
{
// get module from prefab
ModuleGenerator generator = part_prefab.Modules.GetModules<ModuleGenerator>()[0];
// determine if vessel is full of all output resources
bool full = true;
foreach(var or in generator.outputList)
{
double amount = Lib.GetResourceAmount(vessel, or.name);
double capacity = Lib.GetResourceCapacity(vessel, or.name);
double perc = capacity > 0.0 ? amount / capacity : 0.0;
full &= (perc >= 1.0 - double.Epsilon);
}
// if not full
if (!full)
{
// calculate worst required resource percentual
double worst_input = 1.0;
foreach(var ir in generator.inputList)
{
double required = ir.rate * TimeWarp.fixedDeltaTime;
double amount = Lib.GetResourceAmount(vessel, ir.name);
worst_input = Math.Min(worst_input, amount / required);
}
// for each input resource
foreach(var ir in generator.inputList)
{
// consume the resource
Lib.RequestResource(vessel, ir.name, ir.rate * worst_input * TimeWarp.fixedDeltaTime);
}
// for each output resource
foreach(var or in generator.outputList)
{
// produce the resource
Lib.RequestResource(vessel, or.name, -or.rate * worst_input * TimeWarp.fixedDeltaTime * Malfunction.Penalty(part));
}
}
}
}
// converter
// note: support multiple resource converters
// note: ignore stock temperature mechanic of converters
// note: ignore autoshutdown
// note: ignore crew experience bonus (seem that stock ignore it too)
// note: 'undo' stock behaviour by forcing lastUpdateTime to now (to minimize overlapping calculations from this and stock post-facto simulation)
else if (module.moduleName == "ModuleResourceConverter")
{
// determine if active
bool activated = Convert.ToBoolean(module.moduleValues.GetValue("IsActivated"));
// if active
if (activated)
{
// get module from prefab
ModuleResourceConverter converter = part_prefab.Modules.GetModules<ModuleResourceConverter>()[converter_index++];
// determine if vessel is full of all output resources
bool full = true;
foreach(var or in converter.outputList)
{
double amount = Lib.GetResourceAmount(vessel, or.ResourceName);
double capacity = Lib.GetResourceCapacity(vessel, or.ResourceName);
double perc = capacity > 0.0 ? amount / capacity : 0.0;
full &= (perc >= converter.FillAmount - double.Epsilon);
}
// if not full
if (!full)
{
// calculate worst required resource percentual
double worst_input = 1.0;
foreach(var ir in converter.inputList)
{
double required = ir.Ratio * TimeWarp.fixedDeltaTime;
double amount = Lib.GetResourceAmount(vessel, ir.ResourceName);
worst_input = Math.Min(worst_input, amount / required);
}
// for each input resource
foreach(var ir in converter.inputList)
{
// consume the resource
Lib.RequestResource(vessel, ir.ResourceName, ir.Ratio * worst_input * TimeWarp.fixedDeltaTime);
}
// for each output resource
foreach(var or in converter.outputList)
{
// produce the resource
Lib.RequestResource(vessel, or.ResourceName, -or.Ratio * worst_input * TimeWarp.fixedDeltaTime * Malfunction.Penalty(part));
}
}
// undo stock behaviour by forcing last_update_time to now
module.moduleValues.SetValue("lastUpdateTime", Planetarium.GetUniversalTime().ToString());
}
}
// drill
// note: ignore stock temperature mechanic of harvesters
// note: ignore autoshutdown
// note: ignore depletion (stock seem to do the same)
// note: 'undo' stock behaviour by forcing lastUpdateTime to now (to minimize overlapping calculations from this and stock post-facto simulation)
else if (module.moduleName == "ModuleResourceHarvester")
{
// determine if active
bool activated = Convert.ToBoolean(module.moduleValues.GetValue("IsActivated"));
// if active
if (activated)
{
// get module from prefab
ModuleResourceHarvester harvester = part_prefab.Modules.GetModules<ModuleResourceHarvester>()[0];
// deduce crew bonus
double experience_bonus = 0.0;
if (harvester.UseSpecialistBonus)
{
foreach(ProtoCrewMember c in vessel.protoVessel.GetVesselCrew())
{
experience_bonus = Math.Max(experience_bonus, (c.trait == harvester.Specialty) ? (double)c.experienceLevel : 0.0);
}
}
double crew_bonus = harvester.SpecialistBonusBase + (experience_bonus + 1.0) * harvester.SpecialistEfficiencyFactor;
// detect amount of ore in the ground
AbundanceRequest request = new AbundanceRequest
{
Altitude = vessel.altitude,
BodyId = vessel.mainBody.flightGlobalsIndex,
CheckForLock = false,
Latitude = vessel.latitude,
Longitude = vessel.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)
{
// calculate worst required resource percentual
double worst_input = 1.0;
foreach(var ir in harvester.inputList)
{
double required = ir.Ratio * TimeWarp.fixedDeltaTime;
double amount = Lib.GetResourceAmount(vessel, ir.ResourceName);
worst_input = Math.Min(worst_input, amount / required);
}
// for each input resource
foreach(var ir in harvester.inputList)
{
// consume the resource
Lib.RequestResource(vessel, ir.ResourceName, ir.Ratio * worst_input * TimeWarp.fixedDeltaTime);
}
// determine resource produced
double res = abundance * harvester.Efficiency * crew_bonus * worst_input * Malfunction.Penalty(part);
// accumulate ore
Lib.RequestResource(vessel, harvester.ResourceName, -res * TimeWarp.fixedDeltaTime);
}
// undo stock behaviour by forcing last_update_time to now
module.moduleValues.SetValue("lastUpdateTime", Planetarium.GetUniversalTime().ToString());
}
}
// asteroid drill
// note: untested
// note: ignore stock temperature mechanic of asteroid drills
// note: ignore autoshutdown
// note: 'undo' stock behaviour by forcing lastUpdateTime to now (to minimize overlapping calculations from this and stock post-facto simulation)
else if (module.moduleName == "ModuleAsteroidDrill")
{
// determine if active
bool activated = Convert.ToBoolean(module.moduleValues.GetValue("IsActivated"));
// if active
if (activated)
{
// get module from prefab
ModuleAsteroidDrill asteroid_drill = part_prefab.Modules.GetModules<ModuleAsteroidDrill>()[0];
// deduce crew bonus
double experience_bonus = 0.0;
if (asteroid_drill.UseSpecialistBonus)
{
foreach(ProtoCrewMember c in vessel.protoVessel.GetVesselCrew())
{
experience_bonus = Math.Max(experience_bonus, (c.trait == asteroid_drill.Specialty) ? (double)c.experienceLevel : 0.0);
}
}
double crew_bonus = asteroid_drill.SpecialistBonusBase + (experience_bonus + 1.0) * asteroid_drill.SpecialistEfficiencyFactor;
// get asteroid data
ProtoPartModuleSnapshot asteroid_info = null;
ProtoPartModuleSnapshot asteroid_resource = null;
foreach(ProtoPartSnapshot p in vessel.protoVessel.protoPartSnapshots)
{
if (asteroid_info == null) asteroid_info = p.modules.Find(k => k.moduleName == "ModuleAsteroidInfo");
if (asteroid_resource == null) asteroid_resource = p.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 = Convert.ToDouble(asteroid_info.moduleValues.GetValue("massThresholdVal"));
double mass = Convert.ToDouble(asteroid_info.moduleValues.GetValue("currentMassVal"));
double abundance = Convert.ToDouble(asteroid_resource.moduleValues.GetValue("abundance"));
string res_name = asteroid_resource.moduleValues.GetValue("resourceName");
double res_density = PartResourceLibrary.Instance.GetDefinition(res_name).density;
// if asteroid isn't depleted
if (mass > mass_threshold && abundance > double.Epsilon)
{
// consume EC
double ec_required = asteroid_drill.PowerConsumption * TimeWarp.fixedDeltaTime;
double ec_consumed = Lib.RequestResource(vessel, "ElectricCharge", ec_required);
double ec_ratio = ec_consumed / ec_required;
// determine resource extracted
double res_amount = abundance * asteroid_drill.Efficiency * crew_bonus * ec_ratio * TimeWarp.fixedDeltaTime;
// produce mined resource
Lib.RequestResource(vessel, res_name, -res_amount);
// consume asteroid mass
asteroid_info.moduleValues.SetValue("currentMassVal", (mass - res_density * res_amount).ToString());
}
}
// undo stock behaviour by forcing last_update_time to now
module.moduleValues.SetValue("lastUpdateTime", Planetarium.GetUniversalTime().ToString());
}
}
// SCANSAT support (new version)
// TODO: enable better SCANsat support
/*else if (module.moduleName == "SCANsat" || module.moduleName == "ModuleSCANresourceScanner")
{
// get ec consumption rate
PartModule scansat = part_prefab.Modules[module.moduleName];
double power = Lib.ReflectionValue<float>(scansat, "power");
double ec_required = power * TimeWarp.fixedDeltaTime;
// if it was scanning
if (SCANsat.wasScanning(module))
{
// if there is enough ec
double ec_amount = Lib.GetResourceAmount(vessel, "ElectricCharge");
double ec_capacity = Lib.GetResourceCapacity(vessel, "ElectricCharge");
if (ec_capacity > double.Epsilon && ec_amount / ec_capacity > 0.15) //< re-enable at 15% EC
{
// re-enable the scanner
SCANsat.resumeScanner(vessel, module, part_prefab);
// give the user some feedback
if (DB.VesselData(vessel.id).cfg_ec == 1)
Message.Post(Severity.relax, "SCANsat> sensor on <b>" + vessel.vesselName + "</b> resumed operations", "we got enough ElectricCharge");
}
}
// if it is scanning
if (SCANsat.isScanning(module))
{
// consume ec
double ec_consumed = Lib.RequestResource(vessel, "ElectricCharge", ec_required);
// if there isn't enough ec
if (ec_consumed < ec_required * 0.99 && ec_required > double.Epsilon)
{
// unregister scanner, and remember it
SCANsat.stopScanner(vessel, module, part_prefab);
// give the user some feedback
if (DB.VesselData(vessel.id).cfg_ec == 1)
Message.Post(Severity.warning, "SCANsat sensor was disabled on <b>" + vessel.vesselName + "</b>", "for lack of ElectricCharge");
}
}
}*/
// SCANSAT support (old version)
// note: this one doesn't support re-activation, is a bit slower and less clean
// waiting for DMagic to fix a little bug
else if (module.moduleName == "SCANsat" || module.moduleName == "ModuleSCANresourceScanner")
{
// determine if scanning
bool scanning = Convert.ToBoolean(module.moduleValues.GetValue("scanning"));
// consume ec
if (scanning)
{
// get ec consumption
PartModule scansat = part_prefab.Modules[module.moduleName];
double power = Lib.ReflectionValue<float>(scansat, "power");
// consume ec
double ec_required = power * TimeWarp.fixedDeltaTime;
double ec_consumed = Lib.RequestResource(vessel, "ElectricCharge", ec_required);
// if there isn't enough ec
if (ec_consumed < ec_required * 0.99 && ec_required > double.Epsilon)
{
// unregister scanner using reflection
foreach(var a in AssemblyLoader.loadedAssemblies)
{
if (a.name == "SCANsat")
{
Type controller_type = a.assembly.GetType("SCANsat.SCANcontroller");
System.Object controller = controller_type.GetProperty("controller", BindingFlags.Public | BindingFlags.Static).GetValue(null, null);
controller_type.InvokeMember("removeVessel", BindingFlags.InvokeMethod | BindingFlags.NonPublic | BindingFlags.Instance, null, controller, new System.Object[]{vessel});
}
}
// disable scanning
module.moduleValues.SetValue("scanning", false.ToString());
// give the user some feedback
if (DB.VesselData(vessel.id).cfg_ec == 1)
Message.Post(Severity.warning, "SCANsat sensor was disabled on <b>" + vessel.vesselName + "</b>", "for lack of ElectricCharge");
}
}
}
// NearFutureSolar support
// note: we assume deployed, this is a current limitation
else if (module.moduleName == "ModuleCurvedSolarPanel")
{
// [unused] determine if extended
//string state = module.moduleValues.GetValue("SavedState");
//bool extended = state == ModuleDeployableSolarPanel.panelStates.EXTENDED.ToString();
// if in sunlight
if (info.sunlight)
{
// produce electric charge
double output = CurvedPanelOutput(vessel, part, part_prefab, info.sun_dir, info.sun_dist, atmo_factor) * Malfunction.Penalty(part);
Lib.RequestResource(vessel, "ElectricCharge", -output * TimeWarp.fixedDeltaTime);
}
}
// KERBALISM modules
else if (module.moduleName == "Scrubber") { Scrubber.BackgroundUpdate(vessel, part.flightID); }
else if (module.moduleName == "Greenhouse") { Greenhouse.BackgroundUpdate(vessel, part.flightID); }
else if (module.moduleName == "Malfunction") { Malfunction.BackgroundUpdate(vessel, part.flightID); }
}
}
}
}
public override void OnLoad(ConfigNode node)
{
// everything in there will be called only one time : the first time a game is loaded from the main menu
if (!IsCoreGameInitDone)
{
try
{
// core game systems
Sim.Init(); // find suns (Kopernicus support)
Radiation.Init(); // create the radiation fields
ScienceDB.Init(); // build the science database (needs Sim.Init() and Radiation.Init() first)
Science.Init(); // register the science hijacker
// static graphic components
LineRenderer.Init();
ParticleRenderer.Init();
Highlighter.Init();
// UI
Textures.Init(); // set up the icon textures
UI.Init(); // message system, main gui, launcher
KsmGui.KsmGuiMasterController.Init(); // setup the new gui framework
// part prefabs hacks
Profile.SetupPods(); // add supply resources to pods
Misc.PartPrefabsTweaks(); // part prefabs tweaks, must be called after ScienceDB.Init()
// Create KsmGui windows
new ScienceArchiveWindow();
// GameEvents callbacks
Callbacks = new Callbacks();
}
catch (Exception e)
{
string fatalError = "FATAL ERROR : Kerbalism core init has failed :" + "\n" + e.ToString();
Lib.Log(fatalError, Lib.LogLevel.Error);
LoadFailedPopup(fatalError);
}
IsCoreGameInitDone = true;
}
// everything in there will be called every time a savegame (or a new game) is loaded from the main menu
if (!IsSaveGameInitDone)
{
try
{
Cache.Init();
ResourceCache.Init();
// prepare storm data
foreach (CelestialBody body in FlightGlobals.Bodies)
{
if (Storm.Skip_body(body))
{
continue;
}
Storm_data sd = new Storm_data {
body = body
};
storm_bodies.Add(sd);
}
}
catch (Exception e)
{
string fatalError = "FATAL ERROR : Kerbalism save game init has failed :" + "\n" + e.ToString();
Lib.Log(fatalError, Lib.LogLevel.Error);
LoadFailedPopup(fatalError);
}
IsSaveGameInitDone = true;
}
// eveything else will be called on every OnLoad() call :
// - save/load
// - every scene change
// - in various semi-random situations (thanks KSP)
// Fix for background IMGUI textures being dropped on scene changes since KSP 1.8
Styles.ReloadBackgroundStyles();
// always clear the caches
Cache.Clear();
ResourceCache.Clear();
// deserialize our database
try
{
UnityEngine.Profiling.Profiler.BeginSample("Kerbalism.DB.Load");
DB.Load(node);
UnityEngine.Profiling.Profiler.EndSample();
}
catch (Exception e)
{
string fatalError = "FATAL ERROR : Kerbalism save game load has failed :" + "\n" + e.ToString();
Lib.Log(fatalError, Lib.LogLevel.Error);
LoadFailedPopup(fatalError);
}
// I'm smelling the hacky mess in here.
Communications.NetworkInitialized = false;
Communications.NetworkInitializing = false;
// detect if this is a different savegame
if (DB.uid != savegame_uid)
{
// clear caches
Message.all_logs.Clear();
// sync main window pos from db
UI.Sync();
// remember savegame id
savegame_uid = DB.uid;
}
Kerbalism.gameLoadTime = Time.time;
}
// return solar panel EC output
// note: we ignore temperature curve, and make sure it is not relavant in the MM patch
static double PanelOutput(Vessel vessel, ProtoPartSnapshot part, ModuleDeployableSolarPanel panel, Vector3d sun_dir, double sun_dist, double atmo_factor)
{
// if, for whatever reason, sun_dist is zero (or negative), we do not return any output
if (sun_dist <= double.Epsilon) return 0.0;
// shortcuts
Quaternion rot = part.rotation;
Vector3d normal = panel.part.FindModelComponent<Transform>(panel.raycastTransformName).forward;
// calculate cosine factor
// note: for gameplay reasons, we ignore tracking panel pivots
double cosine_factor = panel.sunTracking ? 1.0 : Math.Max(Vector3d.Dot(sun_dir, (vessel.transform.rotation * rot * normal).normalized), 0.0);
// calculate solar flux
double solar_flux = Sim.SolarFlux(sun_dist);
// reduce solar flux inside atmosphere
solar_flux *= atmo_factor;
// finally, calculate output
return panel.chargeRate * cosine_factor * (panel.useCurve ? panel.powerCurve.Evaluate((float)sun_dist) : solar_flux / Sim.SolarFluxAtHome());
}
public vessel_info(Vessel v, uint vessel_id, UInt64 inc)
{
// NOTE: anything used here can't in turn use cache, unless you know what you are doing
// NOTE: you can't cache vessel position
// at any point in time all vessel/body positions are relative to a different frame of reference
// so comparing the current position of a vessel, with the cached one of another make no sense
// associate with an unique incremental id
this.inc = inc;
// determine if this is a valid vessel
is_vessel = Lib.IsVessel(v);
if (!is_vessel) return;
// determine if this is a rescue mission vessel
is_rescue = Misc.IsRescueMission(v);
if (is_rescue) return;
// dead EVA are not valid vessels
if (EVA.IsDead(v)) return;
// shortcut for common tests
is_valid = true;
// generate id once
id = vessel_id;
// calculate crew info for the vessel
crew_count = Lib.CrewCount(v);
crew_capacity = Lib.CrewCapacity(v);
// get vessel position
Vector3d position = Lib.VesselPosition(v);
// this should never happen again
if (Vector3d.Distance(position, v.mainBody.position) < 1.0)
{
throw new Exception("Shit hit the fan for vessel " + v.vesselName);
}
// determine if in sunlight, calculate sun direction and distance
sunlight = Sim.RaytraceBody(v, position, FlightGlobals.Bodies[0], out sun_dir, out sun_dist) ? 1.0 : 0.0;
// at the two highest timewarp speed, the number of sun visibility samples drop to the point that
// the quantization error first became noticeable, and then exceed 100%
// to solve this, we switch to an analytical estimation of the portion of orbit that was in sunlight
// - we check against timewarp rate, instead of index, to avoid issues during timewarp blending
if (v.mainBody.flightGlobalsIndex != 0 && TimeWarp.CurrentRate > 1000.0f)
{
sunlight = 1.0 - Sim.ShadowPeriod(v) / Sim.OrbitalPeriod(v);
}
// environment stuff
atmo_factor = Sim.AtmosphereFactor(v.mainBody, position, sun_dir);
gamma_transparency = Sim.GammaTransparency(v.mainBody, v.altitude);
underwater = Sim.Underwater(v);
breathable = Sim.Breathable(v, underwater);
landed = Lib.Landed(v);
// temperature at vessel position
temperature = Sim.Temperature(v, position, sunlight, atmo_factor, out solar_flux, out albedo_flux, out body_flux, out total_flux);
temp_diff = Sim.TempDiff(temperature, v.mainBody, landed);
// radiation
radiation = Radiation.Compute(v, position, gamma_transparency, sunlight, out blackout, out magnetosphere, out inner_belt, out outer_belt, out interstellar);
// extended atmosphere
thermosphere = Sim.InsideThermosphere(v);
exosphere = Sim.InsideExosphere(v);
// malfunction stuff
malfunction = Reliability.HasMalfunction(v);
critical = Reliability.HasCriticalFailure(v);
// signal info
antenna = new AntennaInfo(v);
avoid_inf_recursion.Add(v.id);
connection = Signal.connection(v, position, antenna, blackout, avoid_inf_recursion);
transmitting = Science.transmitting(v, connection.linked);
relaying = Signal.relaying(v, avoid_inf_recursion);
avoid_inf_recursion.Remove(v.id);
// habitat data
volume = Habitat.tot_volume(v);
surface = Habitat.tot_surface(v);
pressure = Habitat.pressure(v);
poisoning = Habitat.poisoning(v);
shielding = Habitat.shielding(v);
living_space = Habitat.living_space(v);
comforts = new Comforts(v, landed, crew_count > 1, connection.linked);
// data about greenhouses
greenhouses = Greenhouse.Greenhouses(v);
// other stuff
gravioli = Sim.Graviolis(v);
}
public static void body_info(this Panel p)
{
// only show in mapview
if (!MapView.MapIsEnabled) return;
// only show if there is a selected body and that body is not the sun
CelestialBody body = Lib.SelectedBody();
if (body == null || (body.flightGlobalsIndex == 0 && !Features.Radiation)) return;
// shortcut
CelestialBody sun = FlightGlobals.Bodies[0];
// for all bodies except the sun
if (body != sun)
{
// 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);
// surface panel
string temperature_str = body.atmosphere
? Lib.HumanReadableTemp(temperature)
: Lib.BuildString(Lib.HumanReadableTemp(temperature_min), " / ", Lib.HumanReadableTemp(temperature));
p.section("SURFACE");
p.content("temperature", temperature_str);
p.content("solar flux", Lib.HumanReadableFlux(solar_flux));
if (Features.Radiation) p.content("radiation", Lib.HumanReadableRadiation(radiation));
// atmosphere panel
if (body.atmosphere)
{
p.section("ATMOSPHERE");
p.content("breathable", Sim.Breathable(body) ? "yes" : "no");
p.content("light absorption", Lib.HumanReadablePerc(1.0 - Sim.AtmosphereFactor(body, 0.7071)));
if (Features.Radiation) p.content("gamma absorption", Lib.HumanReadablePerc(1.0 - Sim.GammaTransparency(body, 0.0)));
}
}
// rendering panel
if (Features.Radiation)
{
p.section("RENDERING");
p.content("inner belt", Radiation.show_inner ? "<color=green>show</color>" : "<color=red>hide</color>", string.Empty, () => p.toggle(ref Radiation.show_inner));
p.content("outer belt", Radiation.show_outer ? "<color=green>show</color>" : "<color=red>hide</color>", string.Empty, () => p.toggle(ref Radiation.show_outer));
p.content("magnetopause", Radiation.show_pause ? "<color=green>show</color>" : "<color=red>hide</color>", string.Empty, () => p.toggle(ref Radiation.show_pause));
}
// explain the user how to toggle the BodyInfo window
p.content(string.Empty);
p.content("<i>Press <b>B</b> to open this window again</i>");
// set metadata
p.title(Lib.BuildString(Lib.Ellipsis(body.bodyName, Styles.ScaleStringLength(24)), " <color=#cccccc>BODY INFO</color>"));
}
public void FixedUpdate()
{
// do nothing in editor
if (Lib.IsEditor())
{
return;
}
// do nothing if there isn't a solar panel
if (panel == null)
{
return;
}
// get resource handler
Resource_info ec = ResourceCache.Info(vessel, "ElectricCharge");
// get vessel data from cache
Vessel_info info = Cache.VesselInfo(vessel);
// do nothing if vessel is invalid
if (!info.is_valid)
{
return;
}
// detect if sunlight is evaluated analytically
bool analytical_sunlight = info.sunlight > 0.0 && info.sunlight < 1.0;
// detect occlusion from other vessel parts
// - we are only interested when the sunlight evaluation is discrete
var collider = panel.hit.collider;
bool locally_occluded = !analytical_sunlight && collider != null && info.sunlight > 0.0;
// if panel is enabled and extended, and if sun is not occluded, not even locally
if (panel.isEnabled && panel.deployState == ModuleDeployablePart.DeployState.EXTENDED && info.sunlight > 0.0 && !locally_occluded)
{
// calculate cosine factor
// - the stock module is already computing the tracking direction
double cosine_factor = Math.Max(Vector3d.Dot(info.sun_dir, panel.trackingDotTransform.forward), 0.0);
// calculate normalized solar flux
// - this include fractional sunlight if integrated over orbit
// - this include atmospheric absorption if inside an atmosphere
double norm_solar_flux = info.solar_flux / Sim.SolarFluxAtHome();
// calculate output
double output = rate // nominal panel charge rate at 1 AU
* norm_solar_flux // normalized flux at panel distance from sun
* cosine_factor; // cosine factor of panel orientation
// produce EC
ec.Produce(output * Kerbalism.elapsed_s);
// update ui
field_visibility = info.sunlight * 100.0;
field_atmosphere = info.atmo_factor * 100.0;
field_exposure = cosine_factor * 100.0;
field_output = output;
Fields["field_visibility"].guiActive = analytical_sunlight;
Fields["field_atmosphere"].guiActive = info.atmo_factor < 1.0;
Fields["field_exposure"].guiActive = true;
Fields["field_output"].guiActive = true;
}
// if panel is disabled, retracted, or in shadow
else
{
// hide ui
Fields["field_visibility"].guiActive = false;
Fields["field_atmosphere"].guiActive = false;
Fields["field_exposure"].guiActive = false;
Fields["field_output"].guiActive = false;
}
// update status ui
field_status = analytical_sunlight
? "<color=#ffff22>Integrated over the orbit</color>"
: locally_occluded
? "<color=#ff2222>Occluded by vessel</color>"
: info.sunlight < 1.0
? "<color=#ff2222>Occluded by celestial body</color>"
: string.Empty;
Fields["field_status"].guiActive = field_status.Length > 0;
}
public static ConnectionInfo Connection(Vessel v, Vector3d position, KAntennaInfo antenna, bool blackout, HashSet <Guid> avoid_inf_recursion)
{
// if signal mechanic is disabled, use RemoteTech/CommNet/S4
if (!Features.Signal)
{
return(OtherComms(v, antenna, avoid_inf_recursion));
}
// if it has no antenna
if (antenna.no_antenna)
{
return(new ConnectionInfo(LinkStatus.no_antenna));
}
// if there is a storm and the vessel is inside a magnetosphere
if (blackout)
{
return(new ConnectionInfo(LinkStatus.blackout));
}
// store raytracing data
bool visible;
// store other data
double rate;
List <ConnectionInfo> connections = new List <ConnectionInfo>();
// raytrace home body
visible = Sim.RaytraceBody(v, position, FlightGlobals.GetHomeBody(), out Vector3d dir, out double dist);
// get rate
rate = antenna.Direct_Rate(dist);
// if directly linked
if (visible && rate > 0.0)
{
ConnectionInfo conn = new ConnectionInfo(LinkStatus.direct_link, rate, antenna.direct_cost);
connections.Add(conn);
}
// for each other vessel
foreach (Vessel w in FlightGlobals.Vessels)
{
// do not test with itself
if (v == w)
{
continue;
}
// skip vessels already in this chain
if (avoid_inf_recursion.Contains(w.id))
{
continue;
}
// get vessel from the cache
// - when:
// . cache is empty (eg: new savegame loaded)
// - we avoid single-tick wrong paths arising from this situation:
// . vessel A is directly linked
// . vessel B is indirectly linked through A
// . cache is cleared (after loading a savegame)
// . cache of A is computed
// . in turn, cache of B is computed ignoring A (and stored)
// . until cache of B is re-computed, B will result incorrectly not linked
// - in this way:
// . cache of A is computed
// . in turn, cache of B is computed ignoring A (but not stored)
// . cache of B is then computed correctly
// . do not degenerate into O(N^3) by using non-optimal path
if (!Cache.HasVesselInfo(w, out Vessel_Info wi))
{
if (connections.Count > 0)
{
continue;
}
else
{
wi = new Vessel_Info(w, Lib.VesselID(w), 0);
}
}
// skip invalid vessels
if (!wi.is_valid)
{
continue;
}
// skip non-relays and non-linked relays
if (!wi.kAntenna.is_relay || !wi.connection.linked)
{
continue;
}
// raytrace the other vessel
visible = Sim.RaytraceVessel(v, w, position, Lib.VesselPosition(w), out dir, out dist);
// get rate
rate = antenna.Indirect_Rate(dist, wi.kAntenna);
// if indirectly linked
// - relays with no EC have zero relay_range
// - avoid relay loops
if (visible && rate > 0.0 && !wi.connection.path.Contains(v))
{
// create indirect link data
ConnectionInfo conn = new ConnectionInfo(wi.connection)
{
// update the link data and return it
status = LinkStatus.indirect_link,
cost = antenna.indirect_cost
};
conn.rate = Math.Min(conn.rate, rate);
conn.path.Add(w);
connections.Add(conn);
}
}
// if at least a connection has been found
if (connections.Count > 0)
{
// select the best connection
double best_rate = 0.0;
int best_index = 0;
for (int i = 0; i < connections.Count; ++i)
{
if (connections[i].rate > best_rate)
{
best_rate = connections[i].rate;
best_index = i;
}
}
// and return it
return(connections[best_index]);
}
// no link
return(new ConnectionInfo(LinkStatus.no_link));
}
