public static void BackgroundUpdate(Vessel v, ProtoPartModuleSnapshot m, KerbalismProcess process, Resource_info ec, Vessel_resources resources, double elapsed_s)
{
if (!process.unloaded)
{
return;
}
List <KeyValuePair <string, double> > resourcesProduced;
List <KeyValuePair <string, double> > resourcesConsumed;
if (!Cache.HasVesselObjectsCache(v, "kerbalism_process_produced_" + process.part.flightID))
{
resourcesProduced = ParseResources(process.resources_produced, false);
Cache.SetVesselObjectsCache <List <KeyValuePair <string, double> > >(v, "kerbalism_process_produced_" + process.part.flightID, resourcesProduced);
}
else
{
resourcesProduced = Cache.VesselObjectsCache <List <KeyValuePair <string, double> > >(v, "kerbalism_process_produced_" + process.part.flightID);
}
if (!Cache.HasVesselObjectsCache(v, "kerbalism_process_consumed_" + process.part.flightID))
{
resourcesConsumed = ParseResources(process.resources_produced, false);
Cache.SetVesselObjectsCache <List <KeyValuePair <string, double> > >(v, "kerbalism_process_consumed_" + process.part.flightID, resourcesConsumed);
}
else
{
resourcesConsumed = Cache.VesselObjectsCache <List <KeyValuePair <string, double> > >(v, "kerbalism_process_consumed_" + process.part.flightID);
}
RunProcessTick(v, elapsed_s, process.ec_produced, resourcesProduced, process.ec_consumed, resourcesConsumed, ec, resources);
}
// specifics support
public Specifics Specs()
{
var specs = new Specifics();
var exp = Science.Experiment(experiment_id);
if (exp == null)
{
specs.Add(Localizer.Format("#KERBALISM_ExperimentInfo_Unknown"));
return(specs);
}
specs.Add(Lib.BuildString("<b>", exp.name, "</b>"));
if (!string.IsNullOrEmpty(experiment_desc))
{
specs.Add(Lib.BuildString("<i>", experiment_desc, "</i>"));
}
specs.Add(string.Empty);
double expSize = exp.max_amount;
if (sample_mass < float.Epsilon)
{
specs.Add("Data", Lib.HumanReadableDataSize(expSize));
specs.Add("Data rate", Lib.HumanReadableDataRate(data_rate));
specs.Add("Duration", Lib.HumanReadableDuration(expSize / data_rate));
}
else
{
specs.Add("Sample size", Lib.HumanReadableSampleSize(expSize));
specs.Add("Sample mass", Lib.HumanReadableMass(sample_mass));
if (!sample_collecting && Math.Abs(sample_reservoir - sample_mass) > double.Epsilon && sample_mass > double.Epsilon)
{
specs.Add("Experiments", "" + Math.Round(sample_reservoir / sample_mass, 0));
}
specs.Add("Duration", Lib.HumanReadableDuration(expSize / data_rate));
}
List <string> situations = exp.Situations();
if (situations.Count > 0)
{
specs.Add(string.Empty);
specs.Add("<color=#00ffff>Situations:</color>", string.Empty);
foreach (string s in situations)
{
specs.Add(Lib.BuildString("• <b>", s, "</b>"));
}
}
specs.Add(string.Empty);
specs.Add("<color=#00ffff>Needs:</color>");
specs.Add("EC", Lib.HumanReadableRate(ec_rate));
foreach (var p in KerbalismProcess.ParseResources(resources))
{
specs.Add(p.Key, Lib.HumanReadableRate(p.Value));
}
if (crew_prepare.Length > 0)
{
var cs = new CrewSpecs(crew_prepare);
specs.Add("Preparation", cs ? cs.Info() : "none");
}
if (crew_operate.Length > 0)
{
var cs = new CrewSpecs(crew_operate);
specs.Add("Operation", cs ? cs.Info() : "unmanned");
}
if (crew_reset.Length > 0)
{
var cs = new CrewSpecs(crew_reset);
specs.Add("Reset", cs ? cs.Info() : "none");
}
if (!string.IsNullOrEmpty(requires))
{
specs.Add(string.Empty);
specs.Add("<color=#00ffff>Requires:</color>", string.Empty);
var tokens = Lib.Tokenize(requires, ',');
foreach (string s in tokens)
{
specs.Add(Lib.BuildString("• <b>", Science.RequirementText(s), "</b>"));
}
}
return(specs);
}
public static void BackgroundUpdate(Vessel v, ProtoPartModuleSnapshot m, Experiment experiment, Resource_info ec, Vessel_resources resources, double elapsed_s)
{
bool didPrepare = Lib.Proto.GetBool(m, "didPrepare", false);
bool shrouded = Lib.Proto.GetBool(m, "shrouded", false);
string last_subject_id = Lib.Proto.GetString(m, "last_subject_id", "");
double remainingSampleMass = Lib.Proto.GetDouble(m, "remainingSampleMass", 0);
bool broken = Lib.Proto.GetBool(m, "broken", false);
bool forcedRun = Lib.Proto.GetBool(m, "forcedRun", false);
bool recording = Lib.Proto.GetBool(m, "recording", false);
uint privateHdId = Lib.Proto.GetUInt(m, "privateHdId", 0);
string issue = TestForIssues(v, ec, experiment, privateHdId, broken,
remainingSampleMass, didPrepare, shrouded, last_subject_id);
if (string.IsNullOrEmpty(issue))
{
issue = TestForResources(v, KerbalismProcess.ParseResources(experiment.resources), elapsed_s, resources);
}
Lib.Proto.Set(m, "issue", issue);
if (!string.IsNullOrEmpty(issue))
{
return;
}
var subject_id = Science.Generate_subject_id(experiment.experiment_id, v);
Lib.Proto.Set(m, "last_subject_id", subject_id);
double dataSampled = Lib.Proto.GetDouble(m, "dataSampled");
if (last_subject_id != subject_id)
{
dataSampled = 0;
Lib.Proto.Set(m, "forcedRun", false);
}
double scienceValue = Science.Value(last_subject_id);
Lib.Proto.Set(m, "scienceValue", scienceValue);
var state = GetState(scienceValue, issue, recording, forcedRun);
if (state != State.RUNNING)
{
return;
}
if (dataSampled >= Science.Experiment(subject_id).max_amount)
{
return;
}
var stored = DoRecord(experiment, subject_id, v, ec, privateHdId,
resources, KerbalismProcess.ParseResources(experiment.resources),
remainingSampleMass, dataSampled, out dataSampled, out remainingSampleMass);
if (!stored)
{
Lib.Proto.Set(m, "issue", insufficient_storage);
}
Lib.Proto.Set(m, "dataSampled", dataSampled);
Lib.Proto.Set(m, "remainingSampleMass", remainingSampleMass);
}
public override void OnStart(StartState state)
{
// don't break tutorial scenarios
if (Lib.DisableScenario(this))
{
return;
}
// initialize the remaining sample mass in case it was not configured in the cfg.
if (remainingSampleMass < float.Epsilon && string.IsNullOrEmpty(issue) && !sample_collecting)
{
remainingSampleMass = sample_mass;
if (sample_reservoir > float.Epsilon)
{
remainingSampleMass = sample_reservoir;
}
}
// create animators
deployAnimator = new Animator(part, anim_deploy);
deployAnimator.reversed = anim_deploy_reverse;
loopAnimator = new Animator(part, anim_loop);
loopAnimator.reversed = anim_loop_reverse;
// set initial animation states
deployAnimator.Still(recording ? 1.0 : 0.0);
loopAnimator.Still(recording ? 1.0 : 0.0);
if (recording)
{
loopAnimator.Play(false, true);
}
// parse crew specs
if (!string.IsNullOrEmpty(crew_operate))
{
operator_cs = new CrewSpecs(crew_operate);
}
if (!string.IsNullOrEmpty(crew_reset))
{
reset_cs = new CrewSpecs(crew_reset);
}
if (!string.IsNullOrEmpty(crew_prepare))
{
prepare_cs = new CrewSpecs(crew_prepare);
}
resourceDefs = KerbalismProcess.ParseResources(resources);
foreach (var hd in part.FindModulesImplementing <HardDrive>())
{
if (hd.experiment_id == experiment_id)
{
privateHdId = part.flightID;
}
}
Events["Toggle"].guiActiveUncommand = true;
Events["Toggle"].externalToEVAOnly = true;
Events["Toggle"].requireFullControl = false;
Events["Prepare"].guiActiveUncommand = true;
Events["Prepare"].externalToEVAOnly = true;
Events["Prepare"].requireFullControl = false;
Events["Reset"].guiActiveUncommand = true;
Events["Reset"].externalToEVAOnly = true;
Events["Reset"].requireFullControl = false;
}
public static void Update(Vessel v, Vessel_info vi, VesselData vd, Vessel_resources resources, double elapsed_s)
{
if (!Lib.IsVessel(v))
{
return;
}
// get most used resource handlers
Resource_info ec = resources.Info(v, "ElectricCharge");
// This is basically handled in cache. However, when accelerating time warp while
// the vessel is in shadow, the cache logic doesn't kick in soon enough. So we double-check here
if (TimeWarp.CurrentRate > 1000.0f || elapsed_s > 150) // we're time warping fast...
{
vi.highspeedWarp(v);
}
foreach (var e in Background_PMs(v))
{
switch (e.type)
{
case Module_type.Reliability: Reliability.BackgroundUpdate(v, e.p, e.m, e.module_prefab as Reliability); break;
case Module_type.Experiment: Experiment.BackgroundUpdate(v, e.m, e.module_prefab as Experiment, ec, resources, elapsed_s); break;
case Module_type.Greenhouse: Greenhouse.BackgroundUpdate(v, e.m, e.module_prefab as Greenhouse, vi, resources, elapsed_s); break;
case Module_type.GravityRing: GravityRing.BackgroundUpdate(v, e.p, e.m, e.module_prefab as GravityRing, ec, elapsed_s); break;
case Module_type.Emitter: Emitter.BackgroundUpdate(v, e.p, e.m, e.module_prefab as Emitter, ec, elapsed_s); break;
case Module_type.Harvester: Harvester.BackgroundUpdate(v, e.m, e.module_prefab as Harvester, elapsed_s); break; // Kerbalism ground and air harvester module
case Module_type.Laboratory: Laboratory.BackgroundUpdate(v, e.p, e.m, e.module_prefab as Laboratory, ec, elapsed_s); break;
case Module_type.Command: ProcessCommand(v, e.p, e.m, e.module_prefab as ModuleCommand, resources, elapsed_s); break;
case Module_type.Panel: ProcessPanel(v, e.p, e.m, e.module_prefab as ModuleDeployableSolarPanel, vi, ec, elapsed_s); break;
case Module_type.Generator: ProcessGenerator(v, e.p, e.m, e.module_prefab as ModuleGenerator, resources, elapsed_s); break;
case Module_type.Converter: ProcessConverter(v, e.p, e.m, e.module_prefab as ModuleResourceConverter, resources, elapsed_s); break;
case Module_type.Drill: ProcessDrill(v, e.p, e.m, e.module_prefab as ModuleResourceHarvester, resources, elapsed_s); break; // Stock ground harvester module
case Module_type.AsteroidDrill: ProcessAsteroidDrill(v, e.p, e.m, e.module_prefab as ModuleAsteroidDrill, resources, elapsed_s); break; // Stock asteroid harvester module
case Module_type.StockLab: ProcessStockLab(v, e.p, e.m, e.module_prefab as ModuleScienceConverter, ec, elapsed_s); break;
case Module_type.Light: ProcessLight(v, e.p, e.m, e.module_prefab as ModuleLight, ec, elapsed_s); break;
case Module_type.Scanner: KerbalismScansat.BackgroundUpdate(v, e.p, e.m, e.module_prefab as KerbalismScansat, e.part_prefab, vd, ec, elapsed_s); break;
case Module_type.CurvedPanel: ProcessCurvedPanel(v, e.p, e.m, e.module_prefab, e.part_prefab, vi, ec, elapsed_s); break;
case Module_type.FissionGenerator: ProcessFissionGenerator(v, e.p, e.m, e.module_prefab, ec, elapsed_s); break;
case Module_type.RadioisotopeGenerator: ProcessRadioisotopeGenerator(v, e.p, e.m, e.module_prefab, ec, elapsed_s); break;
case Module_type.CryoTank: ProcessCryoTank(v, e.p, e.m, e.module_prefab, resources, ec, elapsed_s); break;
case Module_type.FNGenerator: ProcessFNGenerator(v, e.p, e.m, e.module_prefab, ec, elapsed_s); break;
case Module_type.NonRechargeBattery: ProcessNonRechargeBattery(v, e.p, e.m, e.module_prefab, ec, elapsed_s); break;
case Module_type.KerbalismProcess: KerbalismProcess.BackgroundUpdate(v, e.m, e.module_prefab as KerbalismProcess, ec, resources, elapsed_s); break;
}
}
}
