public ProtoAntenna(Vessel v, ProtoPartSnapshot p, ProtoPartModuleSnapshot ppms) { ConfigNode n = new ConfigNode(); ppms.Save(n); Name = p.partInfo.title; try { mTarget = new Guid(n.GetValue("RTAntennaTarget")); DishRange = Single.Parse(n.GetValue("RTDishRange")); DishFactor = Double.Parse(n.GetValue("RTDishFactor")); OmniRange = Single.Parse(n.GetValue("RTOmniRange")); } catch (ArgumentException) { mTarget = Guid.Empty; DishRange = 0.0f; DishFactor = 1.0f; OmniRange = 0.0f; RTUtil.Log("ProtoAntenna parsing error. Default values assumed."); } mProtoPart = p; mProtoModule = ppms; Vessel = v; RTUtil.Log("ProtoAntenna: DishRange: {0}, OmniRange: {1}, Name: {2}, DishTarget: {3})", DishRange, OmniRange, Vessel.vesselName, DishTarget); }
public SatSettingNode(ProtoPartModuleSnapshot s, Vessel v, ProtoPartSnapshot sn) { this.protoPartModule = s; this.vessel = v; this.snapshot = sn; isLoaded = false; ConfigNode n = new ConfigNode(); protoPartModule.Save(n); if (n.HasValue("pointedAt")) this.pointedAt = new Target(n.GetValue("pointedAt")); else this.pointedAt = new Target(); if (n.HasValue("dishRange")) this.dishRange = float.Parse(n.GetValue("dishRange")); else this.dishRange = 0; if (n.HasValue("antennaName")) this.antennaName = n.GetValue("antennaName"); for (int i = 0; i < RTGlobals.targets.Count; i++) { if (pointedAt.Equals(RTGlobals.targets[i])) { selectedTarget = i; break; } } }
public ProtoSignalProcessor(ProtoPartModuleSnapshot ppms, Vessel v) { Vessel = v; Powered = ppms.GetBool("IsRTPowered"); // get the crew count from the vessel var crewcount = v.GetVesselCrew().Count; // when the crew count is equal to 0 then look into the protoVessel if (crewcount == 0 && v.protoVessel.GetVesselCrew() != null) crewcount = v.protoVessel.GetVesselCrew().Count; RTLog.Notify("ProtoSignalProcessor crew count of {0} is {1}", v.vesselName, crewcount); int ppmsMinCrew; //try to get the RTCommandMinCrew value in the ProtoPartModuleSnapshot if (ppms.GetInt("RTCommandMinCrew", out ppmsMinCrew)) { IsCommandStation = Powered && v.HasCommandStation() && crewcount >= ppmsMinCrew; RTLog.Notify("ProtoSignalProcessor(Powered: {0}, HasCommandStation: {1}, Crew: {2}/{3})", Powered, v.HasCommandStation(), crewcount, ppmsMinCrew); } else { // there was no RTCommandMinCrew member in the ProtoPartModuleSnapshot IsCommandStation = false; RTLog.Notify("ProtoSignalProcessor(Powered: {0}, HasCommandStation: {1}, Crew: {2})", Powered, v.HasCommandStation(), crewcount); } }
public ProtoSignalProcessor(ProtoPartModuleSnapshot ppms, Vessel v) { mVessel = v; Powered = ppms.GetBool("IsRTPowered"); IsCommandStation = Powered && v.HasCommandStation() && v.GetVesselCrew().Count >= 6; RTLog.Notify("ProtoSignalProcessor(Powered: {0}, HasCommandStation: {1}, Crew: {2})", Powered, v.HasCommandStation(), v.GetVesselCrew().Count); }
public ProtoAntenna(Vessel v, ProtoPartSnapshot p, ProtoPartModuleSnapshot ppms) { ConfigNode n = new ConfigNode(); ppms.Save(n); Name = p.partInfo.title; Consumption = 0; Guid = v.id; mProtoPart = p; mProtoModule = ppms; try { mDishTarget = new Guid(n.GetValue("RTAntennaTarget")); } catch (ArgumentException) { mDishTarget = Guid.Empty; } double temp_double; float temp_float; bool temp_bool; Dish = Single.TryParse(n.GetValue("RTDishRange"), out temp_float) ? temp_float : 0.0f; CosAngle = Double.TryParse(n.GetValue("RTDishCosAngle"), out temp_double) ? temp_double : 0.0; Omni = Single.TryParse(n.GetValue("RTOmniRange"), out temp_float) ? temp_float : 0.0f; Powered = Boolean.TryParse(n.GetValue("IsRTPowered"), out temp_bool) ? temp_bool : false; Activated = Boolean.TryParse(n.GetValue("IsRTActive"), out temp_bool) ? temp_bool : false; RTLog.Notify(ToString()); }
public ProtoSignalProcessor(ProtoPartModuleSnapshot ppms, Vessel v) { mVessel = v; Powered = ppms.GetBool("IsRTPowered"); // get the crew count from the vessel int crewcount = v.GetVesselCrew().Count; // when the crewcount is eq 0 than look into the protoVessel if (crewcount == 0 && v.protoVessel.GetVesselCrew() != null) crewcount = v.protoVessel.GetVesselCrew().Count; RTLog.Notify("ProtoSignalProcessor crew count of {0} is {1}", v.vesselName, crewcount); try { IsCommandStation = Powered && v.HasCommandStation() && crewcount >= ppms.GetInt("RTCommandMinCrew"); RTLog.Notify("ProtoSignalProcessor(Powered: {0}, HasCommandStation: {1}, Crew: {2}/{3})", Powered, v.HasCommandStation(), crewcount, ppms.GetInt("RTCommandMinCrew")); } catch (ArgumentException argexeception) { // I'm assuming this would get thrown by ppms.GetInt()... do the other functions have an exception spec? IsCommandStation = false; RTLog.Notify("ProtoSignalProcessor(Powered: {0}, HasCommandStation: {1}, Crew: {2})", Powered, v.HasCommandStation(), crewcount); RTLog.Notify("ProtoSignalProcessor ", argexeception); } }
public ProtoSignalProcessor(ProtoPartModuleSnapshot ppms, Vessel v) { Vessel = v; Powered = ppms.GetBool("IsRTPowered"); CommandStation = Powered && v.HasCommandStation() && v.GetVesselCrew().Count >= 6; RTUtil.Log("ProtoSignalProcessor: Powered: {0}, CommandStation: {1}, Crew: {2}", Powered, v.HasCommandStation(), v.GetVesselCrew().Count); }
private ConfigNode findExperimentModulInPC(ProtoPartModuleSnapshot kasModule, AvailablePart experiment) { ConfigNode partConf = kasModule.moduleValues; foreach (ConfigNode contentPart in partConf.GetNodes(CONTENT_PART)) { NE_Helper.log("ContentPart: " + contentPart.GetValue("name")); if (contentPart.GetValue("name") == experiment.name) { foreach (ConfigNode module in contentPart.GetNodes("MODULE")) { if (module.GetValue("name") == experimentModulname[experiment.name]) return module; } } } return null; }
public static bool HasResourceGenerationData( PartModule m, ProtoPartModuleSnapshot s, Dictionary<String, List<ResourceModuleHandler>> resourceData, HashSet<String> interestingResources ) { ModuleCommand c = (ModuleCommand)m; // TODO: Check for deactivated command modules foreach (ModuleResource mr in c.inputResources) { if (interestingResources.Contains(mr.name)) { return true; } } return false; }
public static bool HasResourceGenerationData( PartModule m, ProtoPartModuleSnapshot s, Dictionary<String, List<ResourceModuleHandler>> resourceData, HashSet<String> interestingResources ) { bool active = false; Boolean.TryParse(s.moduleValues.GetValue("generatorIsActive"), out active); if (active) { ModuleGenerator g = (ModuleGenerator)m; if (g.inputList.Count <= 0) { foreach (ModuleResource gr in g.outputList) { if (interestingResources.Contains(gr.name)) { return true; } } } } return false; }
public static void ProtoBreak(Vessel v, ProtoPartSnapshot p, ProtoPartModuleSnapshot m) { // get reliability module prefab string type = Lib.Proto.GetString(m, "type", string.Empty); Reliability reliability = p.partPrefab.FindModulesImplementing <Reliability>().Find(k => k.type == type); if (reliability == null) { return; } // if manned, or if safemode didn't trigger if (Cache.VesselInfo(v).crew_capacity > 0 || Lib.RandomDouble() > Settings.SafeModeChance) { // flag as broken Lib.Proto.Set(m, "broken", true); // determine if this is a critical failure bool critical = Lib.RandomDouble() < Settings.CriticalChance; Lib.Proto.Set(m, "critical", critical); // for each associated module foreach (var proto_module in p.modules.FindAll(k => k.moduleName == reliability.type)) { // disable the module Lib.Proto.Set(proto_module, "isEnabled", false); } // type-specific hacks switch (reliability.type) { case "ProcessController": foreach (ProcessController pc in p.partPrefab.FindModulesImplementing <ProcessController>()) { ProtoPartResourceSnapshot res = p.resources.Find(k => k.resourceName == pc.resource); if (res != null) { res.flowState = false; } } break; } // show message Broken_msg(v, reliability.title, critical); } // safe mode else { // reset age Lib.Proto.Set(m, "last", 0.0); Lib.Proto.Set(m, "next", 0.0); // notify user Safemode_msg(v, reliability.title); } // in any case, incentive redundancy if (Settings.IncentiveRedundancy) { Incentive_redundancy(v, reliability.redundancy); } }
public static bool IsCommandStation(this ProtoPartModuleSnapshot ppms) { return(ppms.GetBool("IsRTCommandStation")); }
static bool Prefix(ref ProtoVessel pv, ref bool quick) { if (pv == null) { return(true); } // get a hard drive. any hard drive will do, no need to find a specific one. ProtoPartModuleSnapshot protoHardDrive = null; foreach (var p in pv.protoPartSnapshots) { foreach (var pm in Lib.FindModules(p, "HardDrive")) { protoHardDrive = pm; break; } if (protoHardDrive != null) { break; } } if (protoHardDrive == null) { return(true); // no drive on the vessel - nothing to do. } double scienceToCredit = 0.0; List <DialogGUIBase> labels = new List <DialogGUIBase>(); foreach (Drive drive in Drive.GetDrives(pv, true)) { foreach (File file in drive.files.Values) { double subjectValue = file.subjectData.ScienceValue(file.size); file.subjectData.RemoveScienceCollectedInFlight(subjectValue); if (file.useStockCrediting) { file.ConvertToStockData().Save(protoHardDrive.moduleValues.AddNode("ScienceData")); if (!file.subjectData.ExistsInRnD) { file.subjectData.CreateSubjectInRnD(); } file.subjectData.SetAsPersistent(); file.subjectData.UpdateSubjectCompletion(subjectValue); } else { scienceToCredit += file.subjectData.RetrieveScience(subjectValue, false, pv); labels.Add(new DialogGUILabel(Lib.BuildString( Lib.Color("+ " + subjectValue.ToString("F1"), Lib.Kolor.Science), " (", Lib.Color(file.subjectData.ScienceRetrievedInKSC.ToString("F1"), Lib.Kolor.Science, true), " / ", Lib.Color(file.subjectData.ScienceMaxValue.ToString("F1"), Lib.Kolor.Science, true), ") : ", file.subjectData.FullTitle ))); } } foreach (Sample sample in drive.samples.Values) { double subjectValue = sample.subjectData.ScienceValue(sample.size); sample.subjectData.RemoveScienceCollectedInFlight(subjectValue); if (sample.useStockCrediting) { sample.ConvertToStockData().Save(protoHardDrive.moduleValues.AddNode("ScienceData")); if (!sample.subjectData.ExistsInRnD) { sample.subjectData.CreateSubjectInRnD(); } sample.subjectData.SetAsPersistent(); sample.subjectData.UpdateSubjectCompletion(subjectValue); } else { scienceToCredit += sample.subjectData.RetrieveScience(subjectValue, false, pv); labels.Add(new DialogGUILabel(Lib.BuildString( Lib.Color("+ " + subjectValue.ToString("F1"), Lib.Kolor.Science), " (", Lib.Color(sample.subjectData.ScienceRetrievedInKSC.ToString("F1"), Lib.Kolor.Science, true), " / ", Lib.Color(sample.subjectData.ScienceMaxValue.ToString("F1"), Lib.Kolor.Science, true), ") : ", sample.subjectData.FullTitle ))); } } } protoHardDrive.moduleName = "ModuleScienceContainer"; if (scienceToCredit > 0.0) { // ideally we should hack the stock dialog to add the little science widgets to it but I'm lazy // plus it looks like crap anyway PopupDialog.SpawnPopupDialog ( new MultiOptionDialog ( "scienceResults", "", pv.vesselName + " " + Local.VesselRecovery_title, HighLogic.UISkin, new Rect(0.3f, 0.5f, 350f, 100f), //" recovery" new DialogGUIVerticalLayout ( new DialogGUIBox(Local.VesselRecovery_info + " : " + Lib.Color(scienceToCredit.ToString("F1") + " " + Local.VesselRecovery_CREDITS, Lib.Kolor.Science, true), 340f, 30f), //"SCIENCE RECOVERED"" CREDITS" new DialogGUIScrollList ( new Vector2(340f, 250f), false, true, new DialogGUIVerticalLayout(labels.ToArray()) ), new DialogGUIButton(Local.VesselRecovery_OKbutton, null, 340f, 30f, true, HighLogic.UISkin.button) //"OK" ) ), false, HighLogic.UISkin ); } return(true); // continue to the original code }
public static void BackgroundUpdate(Vessel v, ProtoPartModuleSnapshot m, Experiment experiment, Resource_info ec, double elapsed_s) { var exp = ResearchAndDevelopment.GetExperiment(experiment.experiment_id); 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); string subject_id; string issue = TestForIssues(v, exp, ec, experiment, broken, remainingSampleMass, didPrepare, shrouded, last_subject_id, out subject_id); Lib.Proto.Set(m, "issue", issue); double dataSampled = Lib.Proto.GetDouble(m, "dataSampled"); if (last_subject_id != subject_id) { dataSampled = 0; } // if experiment is active if (!Lib.Proto.GetBool(m, "recording")) { return; } // if there are no issues if (issue.Length == 0 && dataSampled < exp.scienceCap * exp.dataScale) { Lib.Proto.Set(m, "last_subject_id", subject_id); // record in drive double chunkSize = experiment.data_rate * elapsed_s; var info = Science.Experiment(subject_id); double massDelta = experiment.sample_mass * chunkSize / info.max_amount; bool isSample = experiment.sample_mass < float.Epsilon; var drive = isSample ? DB.Vessel(v).BestDrive(chunkSize, 0) : DB.Vessel(v).BestDrive(0, Lib.SampleSizeToSlots(chunkSize)); // on high time warp this chunk size could be too big, but we could store a sizable amount if we processed less double maxCapacity = isSample ? drive.FileCapacityAvailable() : drive.SampleCapacityAvailable(subject_id); if (maxCapacity < chunkSize) { double factor = maxCapacity / chunkSize; chunkSize *= factor; massDelta *= factor; elapsed_s *= factor; } bool stored = false; if (experiment.sample_mass < float.Epsilon) { stored = drive.Record_file(subject_id, chunkSize, true, true); } else { stored = drive.Record_sample(subject_id, chunkSize, massDelta); } if (stored) { // consume ec ec.Consume(experiment.ec_rate * elapsed_s); dataSampled += chunkSize; dataSampled = Math.Min(dataSampled, exp.scienceCap * exp.dataScale); if (!experiment.sample_collecting) { remainingSampleMass -= massDelta; remainingSampleMass = Math.Max(remainingSampleMass, 0); Lib.Proto.Set(m, "remainingSampleMass", remainingSampleMass); } Lib.Proto.Set(m, "dataSampled", dataSampled); } else { issue = "insufficient storage"; Lib.Proto.Set(m, "issue", issue); } } }
private bool labWithCrew(Vessel v) { if (v == null || v.protoVessel == null) { return(false); } if (v.loaded) { List <ModuleScienceLab> labs = v.FindPartModulesImplementing <ModuleScienceLab>(); for (int i = labs.Count - 1; i >= 0; i--) { ModuleScienceLab lab = labs[i]; if (lab == null) { continue; } if (lab.part.protoModuleCrew.Count >= lab.crewsRequired) { return(true); } } } else { for (int i = v.protoVessel.protoPartSnapshots.Count - 1; i >= 0; i--) { ProtoPartSnapshot part = v.protoVessel.protoPartSnapshots[i]; if (part == null) { continue; } for (int j = part.modules.Count - 1; j >= 0; j--) { ProtoPartModuleSnapshot mod = part.modules[j]; if (mod == null) { continue; } if (mod.moduleName != "ModuleScienceLab") { continue; } int crew = (int)getCrewRequired(part); if (part.protoModuleCrew.Count >= crew) { return(true); } } } } return(false); }
public ProtoEmitterDevice(ProtoPartModuleSnapshot emitter, uint part_id) { this.emitter = emitter; this.part_id = part_id; }
public static double GetChuteArea(List <ProtoPartSnapshot> protoParts) { double RCParameter = 0; bool realChuteInUse = false; try { foreach (ProtoPartSnapshot p in protoParts) { if (p.modules.Exists(ppms => ppms.moduleName == "RealChuteModule")) { if (!realChuteInUse) { RCParameter = 0; } //First off, get the PPMS since we'll need that ProtoPartModuleSnapshot realChute = p.modules.First(mod => mod.moduleName == "RealChuteModule"); //Assuming that's not somehow null, then we continue if (realChute != null) //Some of this was adopted from DebRefund, as Vendan's method of handling multiple parachutes is better than what I had. { //We make a list of ConfigNodes containing the parachutes (usually 1, but now there can be any number of them) //We get that from the PPMS ConfigNode rcNode = new ConfigNode(); realChute.Save(rcNode); //It's existence means that RealChute is installed and in use on the craft (you could have it installed and use stock chutes, so we only check if it's on the craft) realChuteInUse = true; RCParameter += ProcessRealchute(rcNode); } } else if (p.modules.Exists(ppms => ppms.moduleName == "RealChuteFAR")) //RealChute Lite for FAR { if (!realChuteInUse) { RCParameter = 0; } ProtoPartModuleSnapshot realChute = p.modules.First(mod => mod.moduleName == "RealChuteFAR"); float diameter = 0.0F; //realChute.moduleValues.GetValue("deployedDiameter") if (realChute.moduleRef != null) { try { diameter = realChute.moduleRef.Fields.GetValue <float>("deployedDiameter"); Debug.Log($"[SR] Diameter is {diameter}."); } catch (Exception e) { Debug.LogError("[SR] Exception while finding deployedDiameter for RealChuteFAR module on moduleRef."); Debug.LogException(e); } } else { Debug.Log("[SR] moduleRef is null, attempting workaround to find diameter."); object dDefault = p.partInfo.partPrefab.Modules["RealChuteFAR"]?.Fields?.GetValue("deployedDiameter"); //requires C# 6 if (dDefault != null) { diameter = Convert.ToSingle(dDefault); Debug.Log($"[SR] Workaround gave a diameter of {diameter}."); } else { Debug.Log("[SR] Couldn't get default value, setting to 0 and calling it a day."); diameter = 0.0F; } } float dragC = 1.0f; //float.Parse(realChute.moduleValues.GetValue("staticCd")); RCParameter += (dragC * Mathf.Pow(diameter, 2) * Math.PI / 4.0); realChuteInUse = true; } else if (!realChuteInUse && p.modules.Exists(ppms => ppms.moduleName == "ModuleParachute")) { //Credit to m4v and RCSBuildAid: https://github.com/m4v/RCSBuildAid/blob/master/Plugin/CoDMarker.cs Part part = p.partRef ?? p.partPrefab; //the part reference, or the part prefab DragCubeList dragCubes = part.DragCubes; dragCubes.SetCubeWeight("DEPLOYED", 1); dragCubes.SetCubeWeight("SEMIDEPLOYED", 0); dragCubes.SetCubeWeight("PACKED", 0); dragCubes.SetOcclusionMultiplier(0); Quaternion rotation = Quaternion.LookRotation(Vector3d.up); try { rotation = Quaternion.LookRotation(part.partTransform?.InverseTransformDirection(Vector3d.up) ?? Vector3d.up); } catch (Exception) { //Debug.LogException(e); } dragCubes.SetDragVectorRotation(rotation); } if (!realChuteInUse) { Part part = p.partRef ?? p.partPrefab; //the part reference, or the part prefab DragCubeList dragCubes = part.DragCubes; dragCubes.ForceUpdate(false, true); dragCubes.SetDragWeights(); dragCubes.SetPartOcclusion(); Vector3 dir = Vector3d.up; dragCubes.SetDrag(dir, 0.03f); //mach 0.03, or about 10m/s double dragCoeff = dragCubes.AreaDrag * PhysicsGlobals.DragCubeMultiplier; RCParameter += (dragCoeff * PhysicsGlobals.DragMultiplier); } } } catch (Exception e) { Debug.LogError("[SR] Error occured while trying to determine total chute area."); Debug.LogException(e); } return(RCParameter); }
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 autoshutdown // note: 'undo' stock behaviour 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(); 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 behaviour by forcing last_update_time to now Lib.Proto.Set(m, "lastUpdateTime", Planetarium.GetUniversalTime()); } }
static void ProcessHarvester(Vessel v, ProtoPartSnapshot p, ProtoPartModuleSnapshot m, ModuleResourceHarvester harvester, vessel_resources resources, double elapsed_s) { // 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) // 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(); 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 behaviour by forcing last_update_time to now Lib.Proto.Set(m, "lastUpdateTime", Planetarium.GetUniversalTime()); } }
static void ProcessCryoTank(Vessel v, ProtoPartSnapshot p, ProtoPartModuleSnapshot m, PartModule cryotank, Vessel_resources resources, Resource_info ec, double elapsed_s) { // Note. Currently background simulation of Cryotanks has an irregularity in that boiloff of a fuel type in a tank removes resources from all tanks // but at least some simulation is better than none ;) // get list of fuels, do nothing if no fuels IList fuels = Lib.ReflectionValue <IList>(cryotank, "fuels"); if (fuels == null) { return; } // is cooling available, note: comparing against amount in previous simulation step bool available = (Lib.Proto.GetBool(m, "CoolingEnabled") && ec.amount > double.Epsilon); // get cooling cost double cooling_cost = Lib.ReflectionValue <float>(cryotank, "CoolingCost"); string fuel_name = ""; double amount = 0.0; double total_cost = 0.0; double boiloff_rate = 0.0; foreach (var item in fuels) { fuel_name = Lib.ReflectionValue <string>(item, "fuelName"); // if fuel_name is null, don't do anything if (fuel_name == null) { continue; } //get fuel resource Resource_info fuel = resources.Info(v, fuel_name); // if there is some fuel // note: comparing against amount in previous simulation step if (fuel.amount > double.Epsilon) { // Try to find resource "fuel_name" in PartResources ProtoPartResourceSnapshot proto_fuel = p.resources.Find(k => k.resourceName == fuel_name); // If part doesn't have the fuel, don't do anything. if (proto_fuel == null) { continue; } // get amount in the part amount = proto_fuel.amount; // if cooling is enabled and there is enough EC if (available) { // calculate ec consumption total_cost += cooling_cost * amount * 0.001; } // if cooling is disabled or there wasn't any EC else { // get boiloff rate per-second boiloff_rate = Lib.ReflectionValue <float>(item, "boiloffRate") / 360000.0f; // let it boil off fuel.Consume(amount * (1.0 - Math.Pow(1.0 - boiloff_rate, elapsed_s))); } } } // apply EC consumption ec.Consume(total_cost * elapsed_s); }
public AntennaInfoCommNet(Vessel v, bool powered, bool storm, bool transmitting) { int transmitterCount = 0; rate = 1; double ec_transmitter = 0; // if vessel is loaded if (v.loaded) { List <ModuleDataTransmitter> transmitters; if (!Cache.HasVesselObjectsCache(v, "commnet")) { // find transmitters transmitters = v.FindPartModulesImplementing <ModuleDataTransmitter>(); if (transmitters == null) { transmitters = new List <ModuleDataTransmitter>(); } Cache.SetVesselObjectsCache(v, "commnet", transmitters); } else { transmitters = Cache.VesselObjectsCache <List <ModuleDataTransmitter> >(v, "commnet"); } foreach (ModuleDataTransmitter t in transmitters) { // Disable all stock buttons t.Events["TransmitIncompleteToggle"].active = false; t.Events["StartTransmission"].active = false; t.Events["StopTransmission"].active = false; t.Actions["StartTransmissionAction"].active = false; if (t.antennaType == AntennaType.INTERNAL) // do not include internal data rate, ec cost only { ec += t.DataResourceCost * t.DataRate; } else { // do we have an animation ModuleDeployableAntenna animation = t.part.FindModuleImplementing <ModuleDeployableAntenna>(); ModuleAnimateGeneric animationGeneric = t.part.FindModuleImplementing <ModuleAnimateGeneric>(); if (animation != null) { // only include data rate and ec cost if transmitter is extended if (animation.deployState == ModuleDeployablePart.DeployState.EXTENDED) { rate *= t.DataRate; transmitterCount++; var e = t.DataResourceCost * t.DataRate; ec_transmitter += e; } } else if (animationGeneric != null) { // only include data rate and ec cost if transmitter is extended if (animationGeneric.animSpeed > 0) { rate *= t.DataRate; transmitterCount++; var e = t.DataResourceCost * t.DataRate; ec_transmitter += e; } } // no animation else { rate *= t.DataRate; transmitterCount++; var e = t.DataResourceCost * t.DataRate; ec_transmitter += e; } } } } // if vessel is not loaded else { List <KeyValuePair <ModuleDataTransmitter, ProtoPartSnapshot> > transmitters; if (!Cache.HasVesselObjectsCache(v, "commnet_bg")) { transmitters = new List <KeyValuePair <ModuleDataTransmitter, ProtoPartSnapshot> >(); // find proto transmitters foreach (ProtoPartSnapshot p in v.protoVessel.protoPartSnapshots) { // get part prefab (required for module properties) Part part_prefab = PartLoader.getPartInfoByName(p.partName).partPrefab; foreach (ModuleDataTransmitter t in part_prefab.FindModulesImplementing <ModuleDataTransmitter>()) { transmitters.Add(new KeyValuePair <ModuleDataTransmitter, ProtoPartSnapshot>(t, p)); } } Cache.SetVesselObjectsCache(v, "commnet_bg", transmitters); } else { // cache transmitters transmitters = Cache.VesselObjectsCache <List <KeyValuePair <ModuleDataTransmitter, ProtoPartSnapshot> > >(v, "commnet_bg"); } foreach (var pair in transmitters) { ModuleDataTransmitter t = pair.Key; ProtoPartSnapshot p = pair.Value; if (t.antennaType == AntennaType.INTERNAL) // do not include internal data rate, ec cost only { ec += t.DataResourceCost * t.DataRate; } else { // do we have an animation ProtoPartModuleSnapshot m = p.FindModule("ModuleDeployableAntenna") ?? p.FindModule("ModuleAnimateGeneric"); if (m != null) { // only include data rate and ec cost if transmitter is extended string deployState = Lib.Proto.GetString(m, "deployState"); float animSpeed = Lib.Proto.GetFloat(m, "animSpeed"); if (deployState == "EXTENDED" || animSpeed > 0) { rate *= t.DataRate; transmitterCount++; ec_transmitter += t.DataResourceCost * t.DataRate; } } // no animation else { rate *= t.DataRate; transmitterCount++; ec_transmitter += t.DataResourceCost * t.DataRate; } } } } if (transmitterCount > 1) { rate = Math.Pow(rate, 1.0 / transmitterCount); } else if (transmitterCount == 0) { rate = 0; } // when transmitting, transmitters need more EC for the signal amplifiers. // while not transmitting, transmitters only use 10-20% of that ec_transmitter *= transmitting ? Settings.TransmitterActiveEcFactor : Settings.TransmitterPassiveEcFactor; ec += ec_transmitter; Init(v, powered, storm); }
/*************************************************************************************************************************/ public bool search_for_new_vessels(string save_file_name) { bool new_vessel_found = false, controllable = false; Log.PushStackInfo("FMRS_Core.search_for_new_vessels(string)", "entering search_for_new_vessels(string save_file_name) {0}", save_file_name); foreach (Vessel temp_vessel in FlightGlobals.Vessels) { controllable = false; //Check if the stage was claimed by another mod or by this mod string controllingMod = RecoveryControllerWrapper.ControllingMod(temp_vessel); bool FMRSIsControllingMod = false; if (controllingMod != null) { Log.info("RecoveryControllerWrapper.ControllingMod for vessel: {0} : {1}", temp_vessel.name, controllingMod); FMRSIsControllingMod = string.Equals(controllingMod, "FMRS", StringComparison.OrdinalIgnoreCase); } if (controllingMod == null || string.Equals(controllingMod, "auto", StringComparison.OrdinalIgnoreCase) || FMRSIsControllingMod) { if (!Vessels.Contains(temp_vessel.id)) { if (FMRSIsControllingMod || ( ((temp_vessel.isCommandable && temp_vessel.IsControllable) || (_SETTING_Control_Uncontrollable && controllingMod == null)) && temp_vessel.vesselType != VesselType.EVA && temp_vessel.vesselType != VesselType.Flag && temp_vessel.vesselType != VesselType.SpaceObject && temp_vessel.vesselType != VesselType.Unknown ) ) { controllable = true; } else { foreach (ProtoPartSnapshot proto_part in temp_vessel.protoVessel.protoPartSnapshots) { List <ProtoPartModuleSnapshot> proto_modules = proto_part.modules; ProtoPartModuleSnapshot module = null; if (proto_modules != null && (_SETTING_Parachutes && ((controllingMod != null && string.Equals(controllingMod, "FMRS", StringComparison.OrdinalIgnoreCase)) || !_SETTING_Defer_Parachutes_to_StageRecovery || !stageRecoveryInstalled) ) ) { // module = proto_part.modules.Find(p => p.moduleName == "RealChuteModule" || p.moduleName == "ModuleParachute" || p.moduleName == "ModuleKrKerbalParachute" || p.moduleName == "RealChuteFAR"); if (module != null) { controllable = true; } } if (proto_part.protoCrewNames.Count > 0) { controllable = true; } } } foreach (Part p in temp_vessel.Parts) { foreach (PartModule pm in p.Modules) { if (pm.moduleName == "FMRS_PM") { if ((pm as FMRS_PM).parent_vessel != "00000000-0000-0000-0000-000000000000") { controllable = false; break; } } } break; } if (controllable) { Log.dbg("{0} Found and will be added to the dicts", temp_vessel.vesselName); Vessels_dropped.Add(temp_vessel.id, save_file_name); Vessels_dropped_names.Add(temp_vessel.id, temp_vessel.vesselName); Vessel_State.Add(temp_vessel.id, vesselstate.FLY); foreach (Part p in temp_vessel.Parts) { foreach (PartModule pm in p.Modules) { if (pm.moduleName == "FMRS_PM") { pm.StartCoroutine("setid"); } } } foreach (ProtoPartSnapshot part_snapshot in temp_vessel.protoVessel.protoPartSnapshots) { foreach (ProtoCrewMember member in part_snapshot.protoModuleCrew) { if (!Kerbal_dropped.ContainsKey(member.name)) { Kerbal_dropped.Add(member.name, temp_vessel.id); } } } new_vessel_found = true; } Vessels.Add(temp_vessel.id); } } } Log.PopStackInfo("leaving search_for_new_vessels(string save_file_name)"); return(new_vessel_found); }
// Simulate resources production/consumption for unloaded vessel public static string BackgroundUpdate(Vessel v, ProtoPartSnapshot part_snapshot, ProtoPartModuleSnapshot module_snapshot, PartModule proto_part_module, Part proto_part, Dictionary <string, double> availableResources, List <KeyValuePair <string, double> > resourceChangeRequest, double elapsed_s) { if (Lib.Proto.GetBool(module_snapshot, "IsCooling")) { foreach (ModuleResource res in ((proto_part_module as SystemHeatRadiatorKerbalism).resHandler.inputResources)) { resourceChangeRequest.Add(new KeyValuePair <string, double>(res.name, -res.rate)); } } return(radiatorTitle); }
private IEnumerator loadSensors() { while (!FlightGlobals.ready) { yield return(null); } for (int i = FlightGlobals.Vessels.Count - 1; i >= 0; i--) { Vessel v = FlightGlobals.Vessels[i]; if (v == null) { continue; } if (v.mainBody != FlightGlobals.ActiveVessel.mainBody) { continue; } if (v.loaded) { for (int j = 0; j < v.Parts.Count; j++) { Part p = v.Parts[j]; if (p == null) { continue; } IDMSeismometer sensor = p.FindModuleImplementing <IDMSeismometer>(); if (sensor != null) { addLoadedSeismometer(p.flightID, sensor); } } } else { ProtoVessel pv = v.protoVessel; for (int j = 0; j < v.protoVessel.protoPartSnapshots.Count; j++) { ProtoPartSnapshot p = v.protoVessel.protoPartSnapshots[j]; if (p == null) { continue; } for (int k = 0; k < p.modules.Count; k++) { ProtoPartModuleSnapshot m = p.modules[k]; if (m == null) { continue; } if (m.moduleName == "DMSeismicSensor" || m.moduleName == "DMSeismicHammer") { addProtoSeismometer(p.flightID, p, m); } } } } } }
/// <summary> /// For Kerbalism integration /// </summary> /// <returns></returns> public new static string BackgroundUpdate(Vessel v, ProtoPartSnapshot part_snapshot, ProtoPartModuleSnapshot module_snapshot, PartModule proto_part_module, Part proto_part, Dictionary <string, double> availableResources, List <KeyValuePair <string, double> > resourceChangeRequest, double elapsed_s) => ModuleAvionics.BackgroundUpdate(v, part_snapshot, module_snapshot, proto_part_module, proto_part, availableResources, resourceChangeRequest, elapsed_s);
static void ProcessScanner(Vessel v, ProtoPartSnapshot p, ProtoPartModuleSnapshot m, PartModule scanner, Part part_prefab, VesselData vd, resource_info ec, double elapsed_s) { // get ec consumption rate double power = SCANsat.EcConsumption(scanner); // if the scanner doesn't require power to operate, we aren't interested in simulating it if (power <= double.Epsilon) { return; } // get scanner state bool is_scanning = Lib.Proto.GetBool(m, "scanning"); // if its scanning if (is_scanning) { // consume ec ec.Consume(power * elapsed_s); // if there isn't ec // - comparing against amount in previous simulation step if (ec.amount <= double.Epsilon) { // unregister scanner SCANsat.stopScanner(v, m, part_prefab); is_scanning = false; // remember disabled scanner vd.scansat_id.Add(p.flightID); // give the user some feedback if (vd.cfg_ec) { Message.Post(Lib.BuildString("SCANsat sensor was disabled on <b>", v.vesselName, "</b>")); } } } // if it was disabled in background else if (vd.scansat_id.Contains(p.flightID)) { // if there is enough ec // note: comparing against amount in previous simulation step if (ec.level > 0.25) //< re-enable at 25% EC { // re-enable the scanner SCANsat.resumeScanner(v, m, part_prefab); is_scanning = true; // give the user some feedback if (vd.cfg_ec) { Message.Post(Lib.BuildString("SCANsat sensor resumed operations on <b>", v.vesselName, "</b>")); } } } // forget active scanners if (is_scanning) { vd.scansat_id.Remove(p.flightID); } }
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); } // 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(); foreach (ModuleResource input in g.resHandler.inputResources) { recipe.Input(input.name, input.rate * elapsed_s); } foreach (ModuleResource output in g.resHandler.outputResources) { 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; foreach (ModuleResource input in g.resHandler.inputResources) { 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 ProtoRingDevice(ProtoPartModuleSnapshot ring, uint part_id) { this.ring = ring; this.part_id = part_id; }
private bool finishTransfer(Vessel v, ScienceData d, float boost) { if (v == null) { return(false); } if (d == null) { return(false); } if (v.loaded) { List <ModuleScienceContainer> containers = v.FindPartModulesImplementing <ModuleScienceContainer>(); if (containers.Count <= 0) { return(false); } ModuleScienceContainer currentContainer = null; for (int j = containers.Count - 1; j >= 0; j--) { ModuleScienceContainer container = containers[j]; if (container.capacity != 0 && container.GetData().Length >= container.capacity) { continue; } if (container.allowRepeatedSubjects) { currentContainer = container; break; } if (container.HasData(d)) { continue; } currentContainer = container; } if (currentContainer != null) { d.triggered = false; d.dataAmount *= (d.baseTransmitValue * (1 + boost)); d.transmitBonus = 1; d.baseTransmitValue = 1; return(currentContainer.AddData(d)); } } else { List <ProtoPartSnapshot> containers = getProtoContainers(v.protoVessel); if (containers.Count <= 0) { return(false); } ProtoPartModuleSnapshot currentContainer = null; uint host = 0; for (int j = containers.Count - 1; j >= 0; j--) { ProtoPartSnapshot container = containers[j]; host = container.flightID; ProtoPartModuleSnapshot tempContainer = null; for (int k = container.modules.Count - 1; k >= 0; k--) { ProtoPartModuleSnapshot mod = container.modules[k]; if (mod.moduleName != "ModuleScienceContainer") { continue; } tempContainer = mod; break; } if (tempContainer == null) { continue; } List <ScienceData> protoData = new List <ScienceData>(); ConfigNode[] science = tempContainer.moduleValues.GetNodes("ScienceData"); for (int l = science.Length - 1; l >= 0; l--) { ConfigNode node = science[l]; protoData.Add(new ScienceData(node)); } Part prefab = container.partInfo.partPrefab; ModuleScienceContainer prefabContainer = prefab.FindModuleImplementing <ModuleScienceContainer>(); if (prefabContainer != null) { if (prefabContainer.capacity != 0 && protoData.Count >= prefabContainer.capacity) { continue; } if (prefabContainer.allowRepeatedSubjects) { currentContainer = tempContainer; break; } if (HasData(d.subjectID, protoData)) { continue; } currentContainer = tempContainer; } } if (currentContainer != null) { d.triggered = false; d.dataAmount = d.dataAmount * (d.baseTransmitValue * (boost + 1)); d.transmitBonus = 1; d.baseTransmitValue = 1; d.container = host; d.Save(currentContainer.moduleValues.AddNode("ScienceData")); return(true); } } return(false); }
public static ModuleConfigurationFlags BackgroundModuleConfiguration( ProtoPartModuleSnapshot protoPartModuleSnapshot) => ModuleConfigurationFlags.LocalResources | ModuleConfigurationFlags.First | ModuleConfigurationFlags.SupplierOnly;
public ProtoSignalProcessor(ProtoPartModuleSnapshot ppms, Vessel v) { Vessel = v; Powered = ppms.GetBool("IsPowered"); CommandStation = Powered && v.HasCommandStation() && Vessel.GetVesselCrew().Count >= 6; }
public Antenna_Info(Vessel v) { List <AntennaPartInfo> adaptorsInfoList = new List <AntennaPartInfo>(); int numParts = (!v.loaded) ? v.protoVessel.protoPartSnapshots.Count : v.Parts.Count; for (int partIndex = 0; partIndex < numParts; partIndex++) { Part part; ProtoPartSnapshot protoPart = null; if (v.loaded) { part = v.Parts[partIndex]; } else { protoPart = v.protoVessel.protoPartSnapshots[partIndex]; part = PartLoader.getPartInfoByName(protoPart.partName).partPrefab; } bool hasInfo = false; AntennaPartInfo antennaPartInfo = new AntennaPartInfo(); ProtoPartModuleSnapshot protoPartModule = null; // Inspect each module of the part for (int moduleIndex = 0; moduleIndex < part.Modules.Count; moduleIndex++) { NetworkAdaptor antennaMod = new NetworkAdaptor(); PartModule pModule = part.Modules[moduleIndex]; if (pModule is NetworkAdaptor) { if (v.loaded) { antennaMod = (NetworkAdaptor)pModule; antennaPartInfo.frequency = antennaMod.frequency; antennaPartInfo.ecCost = antennaMod.ecCost; antennaPartInfo.rate = antennaMod.rate; antennaPartInfo.name = part.partInfo.title; } else { ProtoPartModuleSnapshot netAdaptor = FlightGlobals.FindProtoPartByID(protoPart.flightID).FindModule("NetworkAdaptor"); antennaPartInfo.frequency = Lib.Proto.GetShort(netAdaptor, "frequency"); antennaPartInfo.ecCost = Lib.Proto.GetDouble(netAdaptor, "ecCost"); antennaPartInfo.rate = Lib.Proto.GetDouble(netAdaptor, "rate"); antennaPartInfo.name = protoPart.partInfo.title; } hasInfo = true; } else if (pModule is ICommAntenna) { ICommAntenna antenna = pModule as ICommAntenna; // This method only works when v.Loaded, otherwise this brings a wrong deployState ModuleDeployableAntenna anim = part.FindModuleImplementing <ModuleDeployableAntenna>(); // Assume extended if there is no animator if (anim != null) { if (!v.loaded) { // This method works to !v.Loaded ProtoPartModuleSnapshot deployState = FlightGlobals.FindProtoPartByID(protoPart.flightID).FindModule("ModuleDeployableAntenna"); antennaPartInfo.deployState = Lib.KCOMMNET.String_to_DeployState(Lib.Proto.GetString(deployState, "deployState")); } else { antennaPartInfo.deployState = anim.deployState; } } else { antennaPartInfo.deployState = ModuleDeployablePart.DeployState.EXTENDED; } if (!v.loaded) { protoPartModule = protoPart.FindModule(pModule, moduleIndex); } antennaPartInfo.antennaPower = (!v.loaded) ? antenna.CommPowerUnloaded(protoPartModule) : antenna.CommPower; antennaPartInfo.antennaCombinable = antenna.CommCombinable; antennaPartInfo.antennaCombinableExponent = antenna.CommCombinableExponent; antennaPartInfo.antennaType = antenna.CommType; //antennaPartInfo.partReference = part; //antennaPartInfo.partSnapshotReference = protoPart; antennaPartInfo.canComm = (!v.loaded) ? antenna.CanCommUnloaded(protoPartModule) : antenna.CanComm(); hasInfo = true; } } if (hasInfo) { adaptorsInfoList.Add(antennaPartInfo); } } freqSortedList = adaptorsInfoList.OrderBy(a => a.frequency).ToList(); // order by frequency adaptorsSortedList = adaptorsInfoList.OrderBy(a => a.name).ToList(); // order by device name AntennaCalc(freqSortedList); }
public static string KITPartName(ProtoPartSnapshot protoPartSnapshot, ProtoPartModuleSnapshot protoPartModuleSnapshot) => _kitPartName;
public ProtoDrillDevice(ProtoPartModuleSnapshot drill, ModuleResourceHarvester prefab, uint part_id) { this.drill = drill; this.prefab = prefab; this.part_id = part_id; }
public void onProtoSave(GameEvents.FromToAction <ProtoPartModuleSnapshot, ConfigNode> FTA) { if (FTA.from.moduleName != "ModuleSEPScienceExperiment") { return; } ConfigNode node = FTA.to; //This is the case of a loaded vessel moving out of physics range if (node == null) { protoHost = FTA.from; int id = 0; protoHost.moduleValues.TryGetValue("flightID", ref id); if (id != flightID) { return; } //SEP_Utilities.log("Saving Handler from loaded vessel", logLevels.error); protoHost.moduleValues.SetValue("experimentRunning", experimentRunning.ToString()); protoHost.moduleValues.SetValue("calibration", calibration.ToString()); protoHost.moduleValues.SetValue("completion", completion.ToString()); protoHost.moduleValues.SetValue("submittedData", submittedData.ToString()); protoHost.moduleValues.SetValue("lastBackgroundCheck", lastBackgroundCheck.ToString()); protoHost.moduleValues.SetValue("controllerAutoTransmit", controllerAutoTransmit.ToString()); OnSave(protoHost.moduleValues); } //This is the standard method used when saving else { if (currentGame != null && HighLogic.LoadedScene == GameScenes.SPACECENTER) { if (lastBackgroundCheck > currentGame.UniversalTime) { return; } } int id = 0; node.TryGetValue("flightID", ref id); if (id != flightID) { return; } //if (vessel.mainBody.bodyName == "Kerbin") //{ // SEP_Utilities.log("Save - Experiment: {0} - Completion: {1:P0} - Science Data: {2} - Check Time: {3:N2} - UT: {4:N2} - Game UT: {5:N2}" // , logLevels.log // , experimentTitle // , completion // , storedData.Count > 0 ? storedData[0].title : "None" // , lastBackgroundCheck // , Planetarium.GetUniversalTime() // , currentGame == null ? -1000 : currentGame.UniversalTime); //} //SEP_Utilities.log("Saving Handler from proto vessel", logLevels.error); node.SetValue("experimentRunning", experimentRunning.ToString()); node.SetValue("calibration", calibration.ToString()); node.SetValue("completion", completion.ToString()); node.SetValue("submittedData", submittedData.ToString()); node.SetValue("lastBackgroundCheck", lastBackgroundCheck.ToString()); node.SetValue("controllerAutoTransmit", controllerAutoTransmit.ToString()); OnSave(node); } }
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, 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, 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 static bool IsSignalProcessor(this ProtoPartModuleSnapshot ppms) { return(ppms.GetBool("IsRTSignalProcessor")); }
public SolarPanel(ConfigNode node, InterestedVessel vessel, ProtoPartModuleSnapshot modulesnapshot, ProtoPartSnapshot partsnapshot) { if (node == null) { Debug.Log("[UnloadedResources]: SolarPanel - Call to constructor failed. node is null."); return; } if (vessel == null) { Debug.Log("[UnloadedResources]: SolarPanel - Call to constructor failed. vessel is null."); return; } if (modulesnapshot == null) { Debug.Log("[UnloadedResources]: SolarPanel - Call to constructor failed. modulesnapshot is null."); return; } if (partsnapshot == null) { Debug.Log("[UnloadedResources]: SolarPanel - Call to constructor failed. partsnapshot is null."); return; } this.vessel = vessel; this.PartModule = modulesnapshot; if (node.HasValue("type")) { panelType = (ModuleDeployableSolarPanel.PanelType)System.Enum.Parse(typeof(ModuleDeployableSolarPanel.PanelType), node.GetValue("type")); } node.TryGetValue("chargeRate", ref chargeRate); node.TryGetValue("sunAOA", ref this.sunAOA); node.TryGetValue("flowRate", ref this.flowRate); node.TryGetValue("flowMult", ref this.flowMult); node.TryGetValue("efficiencyMult", ref this.efficiencyMult); if (node.HasValue("deployState")) { deployState = (ModuleDeployablePart.DeployState)System.Enum.Parse(typeof(ModuleDeployablePart.DeployState), node.GetValue("deployState")); } if (deployState != ModuleDeployablePart.DeployState.EXTENDED) { sunAOA = 0f; flowRate = 0f; } Part part = PartLoader.getPartInfoByName(partsnapshot.partName).partPrefab; if (part == null) { Debug.Log("[UnloadedResources]: SolarPanel - Unable to Find Part: " + partsnapshot.partName); return; } for (int i = 0; i < part.Modules.Count; ++i) { if (part.Modules[i].moduleName == "ModuleDeployableSolarPanel" || part.Modules[i].moduleName == "KopernicusSolarPanel") { ModuleDeployableSolarPanel panelModule = (ModuleDeployableSolarPanel)part.Modules[i]; solarNormal = panelModule.part.FindModelTransform(panelModule.secondaryTransformName).forward; pivotAxis = panelModule.part.FindModelTransform(panelModule.pivotName).up; sunTracking = panelModule.isTracking && panelModule.trackingMode == ModuleDeployablePart.TrackingMode.SUN; usesCurve = panelModule.useCurve; tempCurve = panelModule.temperatureEfficCurve; temperature = (float)partsnapshot.temperature; powerCurve = panelModule.powerCurve; position = partsnapshot.position; orientation = partsnapshot.rotation; break; } } }
public BackgroundModule(BackgroundFunctionInfo functionInfo, Vessel vessel, ProtoPartSnapshot protoPartSnapshot, ProtoPartModuleSnapshot protoPartModuleSnapshot, Part part, PartModule partModule) { FunctionInfo = functionInfo; Vessel = vessel; ProtoPartSnapshot = protoPartSnapshot; ProtoPartModuleSnapshot = protoPartModuleSnapshot; Part = part; PartModule = partModule; }
public ProtoRingDevice(ProtoPartModuleSnapshot ring) { this.ring = ring; }
public static bool ModuleInAlias(ProtoPartModuleSnapshot Module, string alias) { for (int i = 0; i < ModuleAliases.Length; i++) { ConfigNode ModuleAlias = ModuleAliases [i]; if (ModuleAlias.GetValue ("name") == alias) { ConfigNode[] Modules = ModuleAlias.GetNode("Modules").GetNodes (); for (int k = 0; k < Modules.Length; k++) { ConfigNode Mod = Modules [k]; if (Mod.GetValue ("name") == Module.moduleValues.GetValue("name")) { return true; } } } } return false; }
public BackgroundSuppliableModule(BackgroundFunctionInfo functionInfo, Vessel vessel, ProtoPartSnapshot protoPartSnapshot, ProtoPartModuleSnapshot protoPartModuleSnapshot, Part part, PartModule partModule) : base(functionInfo, vessel, protoPartSnapshot, protoPartModuleSnapshot, part, partModule) { }