public void Process(ScienceData data) { resetLabBonuses(); if (processDelegate != null) processDelegate(data); }
public void Reset(ScienceData data) { resetLabBonuses(); if (resetDelegate != null) resetDelegate(data); }
public void Keep(ScienceData data) { resetLabBonuses(); if (keepDelegate != null) keepDelegate(data); }
public ScienceDataValue(ScienceData scienceData, global::Part hostPart) { this.scienceData = scienceData; this.hostPart = hostPart; InitializeSuffixes(); }
public void Awake() { vessel = this.GetComponent<Vessel>(); Print("VesselSettings for " + vessel.vesselName + " started."); _expanded = new List<IScienceDataContainer>(); _selectedContainer = null; _selectedData = null; UpdateContainerLists(); GameEvents.onVesselWasModified.Add(OnVesselWasModified); }
public void DumpData(ScienceData science_data) { if (science_data == this.science_data) { this.science_data = null; merdp = null; result_string = null; result_title = null; transmit_value = 0; recovery_value = 0; Deployed = false; } }
public void onSendDataToLab(ScienceData data) { List<ModuleScienceLab> labList = vessel.FindPartModulesImplementing<ModuleScienceLab>(); if(labList.Count > 0) { ModuleScienceLab lab = labList.OrderBy(l => ScienceUtil.GetLabScore(l)).First(l => l.IsOperational()); if(lab != null) { lab.StartCoroutine(lab.ProcessData(data, new Callback<ScienceData>(onLabComplete))); } else { ScreenMessages.PostScreenMessage("<color=#ff9900ff>No opperational science lab on this vessel.</color>", 4f, ScreenMessageStyle.UPPER_CENTER); } } else { ScreenMessages.PostScreenMessage("<color=#ff9900ff>No science lab on this vessel.</color>", 4f, ScreenMessageStyle.UPPER_CENTER); } }
public static ScienceData CreateData(Part part, float amount) { ScienceExperiment experiment = ResearchAndDevelopment.GetExperiment(kBiomeAnalysisID); ScienceSubject subject = ResearchAndDevelopment.GetExperimentSubject(experiment, ScienceUtil.GetExperimentSituation(part.vessel), part.vessel.mainBody, Utils.GetCurrentBiome(part.vessel).name); //Kerbin low orbit has a science multiplier of 1. ScienceSubject subjectLEO = ResearchAndDevelopment.GetExperimentSubject(experiment, ExperimentSituations.InSpaceLow, FlightGlobals.GetHomeBody(), ""); //This ensures you can re-run the experiment. subjectLEO.science = 0f; subjectLEO.scientificValue = 1f; //Create science data ScienceData data = new ScienceData(amount, 1f, 0f, subjectLEO.id, subject.title); return data; }
private void onTransmitData(ScienceData data) { resultsDialog = null; IScienceDataTransmitter bestTransmitter = ScienceUtil.GetBestTransmitter(vessel); if (bestTransmitter != null) { bestTransmitter.TransmitData(new List <ScienceData> { data }); DumpData(data); } else if (CommNet.CommNetScenario.CommNetEnabled) { ScreenMessages.PostScreenMessage("No usable, in-range Comms Devices on this vessel. Cannot Transmit Data.", 3f, ScreenMessageStyle.UPPER_CENTER); } else { ScreenMessages.PostScreenMessage("No Comms Devices on this vessel. Cannot Transmit Data.", 3f, ScreenMessageStyle.UPPER_CENTER); } }
protected override bool generateScienceData() { ScienceExperiment experiment = ResearchAndDevelopment.GetExperiment("ExpInterstellarTelescope"); if (experiment == null) { return(false); } if (science_awaiting_addition > 0) { ScienceSubject subject = ResearchAndDevelopment.GetExperimentSubject(experiment, ExperimentSituations.InSpaceHigh, vessel.mainBody, ""); if (subject == null) { return(false); } subject.subjectValue = PluginHelper.getScienceMultiplier(vessel); subject.scienceCap = 167 * subject.subjectValue; //PluginHelper.getScienceMultiplier(vessel.mainBody.flightGlobalsIndex,false); subject.dataScale = 1.25f; float remaining_base_science = (subject.scienceCap - subject.science) / subject.subjectValue; science_awaiting_addition = Math.Min(science_awaiting_addition, remaining_base_science); // transmission of zero data breaks the experiment result dialog box data_size = Math.Max(float.Epsilon, science_awaiting_addition * subject.dataScale); science_data = new ScienceData((float)data_size, 1, 0, subject.id, "Infrared Telescope Data"); result_title = "Infrared Telescope Experiment"; result_string = "Infrared telescope observations were recovered from the vicinity of " + vessel.mainBody.name + "."; recovery_value = science_awaiting_addition; transmit_value = recovery_value; xmit_scalar = 1; ref_value = subject.scienceCap; return(true); } return(false); }
public void analyze(IScienceDataContainer cont, ScienceData sd) { //print(sd.title); if (GetScienceCount() > 0) { ScreenMessages.PostScreenMessage("Analyzer already full. Transmit the data!", 6, ScreenMessageStyle.UPPER_CENTER); return; } cont.DumpData(sd); this.AddData(sd); if (kuarqsRequired > 0) { setResourceMaxAmount("Kuarqs", kuarqsRequired); Events["ReviewDataEvent"].guiActive = false; } else { sd.transmitValue = txValue; this.ReviewData(); } this.updateList(); }
protected override bool generateScienceData() { ScienceExperiment experiment = ResearchAndDevelopment.GetExperiment(experimentID); if (experiment == null) { return(false); } if (science_to_add > 0) { ScienceSubject subject = ResearchAndDevelopment.GetExperimentSubject(experiment, ScienceUtil.GetExperimentSituation(vessel), vessel.mainBody, "", ""); if (subject == null) { return(false); } subject.subjectValue = PluginHelper.getScienceMultiplier(vessel); subject.scienceCap = 167 * subject.subjectValue; subject.dataScale = 1.25f; double remaining_base_science = (subject.scienceCap - subject.science) / subject.subjectValue; science_to_add = Math.Min(science_to_add, remaining_base_science); // transmission of zero data breaks the experiment result dialog box data_size = Math.Max(float.Epsilon, science_to_add * subject.dataScale); science_data = new ScienceData((float)data_size, 1, 0, subject.id, "Science Lab Data"); result_title = experiment.experimentTitle; result_string = this.nameStr + " " + getRandomExperimentResult(); recovery_value = science_to_add; transmit_value = recovery_value; xmit_scalar = 1; ref_value = subject.scienceCap; return(true); } return(false); }
public MetaData(ScienceData data, Part host) { // find the part containing the data part = host; // get the vessel vessel = part.vessel; // get the container module storing the data container = Science.container(part, Science.experiment(data.subjectID).id); // get the stock experiment module storing the data (if that's the case) experiment = container != null ? container as ModuleScienceExperiment : null; // determine if this is a sample (non-transmissible) // - if this is a third-party data container/experiment, we assume it is transmissible is_sample = experiment != null && experiment.xmitDataScalar < 1.0f; // determine if the container/experiment can collect the data multiple times // - if this is a third-party data container/experiment, we assume it can collect multiple times is_rerunnable = experiment == null || experiment.rerunnable; }
public void ReturnData(ScienceData data) { if (data == null) { return; } if (handler == null) { return; } handler.GetData().Add(data); Events["CollectData"].active = true; Events["ReviewDataEvent"].active = true; if (controller != null) { controller.setCollectEvent(); } }
private void onTransmitData(ScienceData data) { resultsDialog = null; IScienceDataTransmitter bestTransmitter = ScienceUtil.GetBestTransmitter(vessel); if (bestTransmitter != null) { bestTransmitter.TransmitData(new List <ScienceData> { data }); DumpData(data); } else if (CommNet.CommNetScenario.CommNetEnabled) { ScreenMessages.PostScreenMessage(Localizer.Format("#autoLOC_237738"), 3f, ScreenMessageStyle.UPPER_CENTER); } else { ScreenMessages.PostScreenMessage(Localizer.Format("#autoLOC_237740"), 3f, ScreenMessageStyle.UPPER_CENTER); } }
public void analyze(IScienceDataContainer cont, ScienceData sd) { //print(sd.title); if (GetScienceCount() > 0) { ScreenMessages.PostScreenMessage(Localizer.Format("#autoLOC_StatSci_screen_analyseFull"), 6, ScreenMessageStyle.UPPER_CENTER); return; } cont.DumpData(sd); this.AddData(sd); if (kuarqsRequired > 0) { setResourceMaxAmount("Kuarqs", kuarqsRequired); Events["ReviewDataEvent"].guiActive = false; } else { sd.baseTransmitValue = txValue; this.ReviewData(); } this.updateList(); }
public void TransmitData(ScienceData data) { print("[SCANsat] transmitting data"); expDialog = null; if (!storedData.Contains(data)) { return; } foreach (IScienceDataTransmitter t in vessel.FindPartModulesImplementing <IScienceDataTransmitter>()) { if (t.CanTransmit()) { if (!t.IsBusy()) { makeScienceData(false); // just to update values... t.TransmitData(storedData); storedData = new List <ScienceData>(); break; } } } }
protected override void onCriticalSuccess() { if (scienceContainer == null) { scienceContainer = this.part.FindModuleImplementing <ModuleScienceContainer>(); } //Time to pay the piper if (currentExperiment == GeologyLabExperiments.BiomeAnalysis) { if (ResearchAndDevelopment.Instance.Science >= kBiomeResearchCost) { ResearchAndDevelopment.Instance.AddScience(-kBiomeResearchCost, TransactionReasons.RnDTechResearch); } //Not enough science. Efforts wasted. else { ScreenMessages.PostScreenMessage(kNotEnoughScience, 5.0f, ScreenMessageStyle.UPPER_CENTER); StopConverter(); return; } //Generate biome analysis ScienceData data = WBIBiomeAnalysis.CreateData(this.part, kBiomeResearchCost * (1.0f + getBiomeAnalysisBonus() / 100f)); scienceContainer.AddData(data); } else { float efficiencyModifier = 0.1f + (totalCrewSkill / 100f); applyResults(efficiencyModifier, kBetterEfficiency); //Reduce core sample count dumpFirstCoreSample(); } }
private void getScienceData(bool sensorOnly, bool asteroid, bool silent) { ScienceData data = null; if (asteroid) { DMSeismicHammer hammer = vessel.FindPartModulesImplementing <DMSeismicHammer>().FirstOrDefault(); if (hammer == null) { data = DMSeismicHandler.makeData(values, values.Score, exp, experimentID, sensorOnly, asteroid); } else { hammer.DeployExperiment(); return; } } else { DMSeismometerValues v = values.getBestHammer(); data = DMSeismicHandler.makeData(v, v.Score, exp, experimentID, sensorOnly, asteroid); } if (data == null) { return; } GameEvents.OnExperimentDeployed.Fire(data); scienceReports.Add(data); Deployed = true; if (!silent) { ReviewData(); } }
internal static double RecordData(ScienceData data, MetaData meta) { double remaining = data.dataAmount; foreach (var drive in Drive.GetDrives(meta.vessel.KerbalismData(), false)) { var size = Math.Min(remaining, drive.FileCapacityAvailable()); if (size > 0) { drive.Record_file(meta.subjectData, size, true, true); remaining -= size; } } if (remaining > 0) { Message.Post( Lib.Color(Lib.BuildString(meta.subjectData.FullTitle, " stored partially"), Lib.Kolor.Orange), "Not enough space on hard drive" ); } return(remaining); }
private void OnTransmitData(ScienceData data) { _expDialog = null; IScienceDataTransmitter transmitter = ScienceUtil.GetBestTransmitter(FlightGlobals.ActiveVessel); if (transmitter != null) { transmitter.TransmitData(new List <ScienceData> { data }); DumpData(data); } else if (CommNet.CommNetScenario.CommNetEnabled) { Utils.DisplayScreenMsg(Localizer.Format("#autoLOC_237738")); } else { Utils.DisplayScreenMsg(Localizer.Format("#autoLOC_237740")); } //UpdateUI(); }
protected void perfomBiomeAnalysys() { //We need at least one crewmember in the lab. if (this.part.protoModuleCrew.Count == 0) { ScreenMessages.PostScreenMessage(kNoCrew, kMessageDuration, ScreenMessageStyle.UPPER_CENTER); return; } //We need at least one scientist in the lab, or one TERRAIN satellite in orbit. float scienceBonus = getBiomeAnalysisBonus(); //We can run the analysis, add the science bonus if (scienceBonus > 0.0f) { //Generate lab data ScienceData data = WBIBiomeAnalysis.CreateData(this.part, scienceBonus); scienceContainer.AddData(data); scienceContainer.ReviewDataItem(data); swizzler.SwizzleResultsDialog(); } //Ok, do we at least have a TERRAIN satellite in orbit? else if (planetHasTerrainSat()) { ScreenMessages.PostScreenMessage(kAnalysisUplink, kMessageDuration * 1.5f, ScreenMessageStyle.UPPER_CENTER); } else { ScreenMessages.PostScreenMessage(kNoScientistsOrTerrain, kMessageDuration * 1.5f, ScreenMessageStyle.UPPER_CENTER); return; } //Run the analysis biomeScanner.RunAnalysis(); }
public void Transmit(ScienceData data) { ExperimentsResultDialog dlg = ExperimentsResultDialog.Instance; ExperimentResultDialogPage page = dlg.currentPage; DialogCallbacks dialogCallbacks; if (page == null) { return; } //Get the callbacks if (callbacks.ContainsKey(page) == false) { return; } dialogCallbacks = callbacks[page]; //Original callback if (dialogCallbacks.originalTransmitCallback != null) { dialogCallbacks.originalTransmitCallback(data); } }
//A timer to prevent the experiment results from being displayed right away private IEnumerator waitForDeploy(ModuleAsteroid m) { float time = 2f; if (anim != null) { time = anim[animationName].length; } yield return(new WaitForSeconds(time)); ScienceData data = sampleData(m); if (data != null) { GameEvents.OnExperimentDeployed.Fire(data); dataList.Add(data); ReviewData(); Deployed = true; } else { Debug.LogWarning("[IRSurfaceSampler] Something went wrong with Science Data collection here..."); } }
public override void OnLoad(ConfigNode node) { if (node.HasNode("ScienceData")) { foreach (ConfigNode storedDataNode in node.GetNodes("ScienceData")) { ScienceData data = new ScienceData(storedDataNode); storedData.Add(data); } } if (node.HasNode("SCANsatRPM")) { ConfigNode RPMPersistence = node.GetNode("SCANsatRPM"); foreach (ConfigNode RPMNode in RPMPersistence.GetNodes("Prop")) { string id = RPMNode.GetValue("Prop ID"); int Mode = Convert.ToInt32(RPMNode.GetValue("Mode")); int Color = Convert.ToInt32(RPMNode.GetValue("Color")); int Zoom = Convert.ToInt32(RPMNode.GetValue("Zoom")); bool Lines = Convert.ToBoolean(RPMNode.GetValue("Lines")); RPMList.Add(new RPMPersistence(id, Mode, Color, Zoom, Lines)); } } }
public void update(double size, Vessel v) { if (queue.Count > 0) { // get first data in queue ScienceData data = queue[0]; // transmit some transmitted[0] += size; // if transmission is completed if (transmitted[0] >= data.dataAmount) { // if triggered, fire the triggered data callback if (data.triggered) { // we can't just integrate triggered data with Science data transmission, // because virtually all the listener callbacks assume the vessel is loaded GameEvents.OnTriggeredDataTransmission.Fire(data, v, false); } // if not triggered, we just submit the data else { ScienceSubject subject = ResearchAndDevelopment.GetSubjectByID(data.subjectID); if (subject != null) { ResearchAndDevelopment.Instance.SubmitScienceData(data.dataAmount, subject, 1.0f, v.protoVessel); } } // remove data from queue queue.RemoveAt(0); transmitted.RemoveAt(0); } } }
void TransmitData(ScienceData data, IScienceDataContainer container) { if (TransmittingScience.ContainsKey(data.subjectID)) { Debug.Log("[MoarScience!] transmitting queue already has: " + data.subjectID); return; } if (data.baseTransmitValue < 0.40) { // Debug.Log("[MoarScience!] transmit value is less than 40%: " + data.subjectID); return; } // we check for a transmitter late because of logspam from remotetech if (transmitter == null) { Debug.Log("[MoarScience!] have science to transfer but no transmitter/connection"); return; } AddSubjectIDToDict(TransmittingScience, data.subjectID); transmitter.TransmitData(new List <ScienceData> { data }); container.DumpData(data); }
void Hijack(ScienceData data, bool send) { // shortcut ExperimentResultDialogPage page = dialog.currentPage; // collect and deduce all data necessary just once MetaData meta = new MetaData(data, page.host); // hijack the dialog if (!meta.is_rerunnable) { popup = Lib.Popup ( "Warning!", "Recording the data will render this module inoperable.\n\nRestoring functionality will require a scientist.", new DialogGUIButton("Record data", () => Record(meta, data, send)), new DialogGUIButton("Discard data", () => Dismiss(data)) ); } else { Record(meta, data, send); } }
protected virtual void onComplete(ScienceData data) { ReviewData(); }
protected new void DumpData(ScienceData data) { if (storedScienceReports.Contains(data)) { experimentsReturned++; Inoperable = !IsRerunnable(); Deployed = Inoperable; storedScienceReports.Remove(data); } }
public new void ReturnData(ScienceData data) { if (data == null) return; storedScienceReports.Add(data); experimentsReturned--; if (experimentsReturned < 0) experimentsReturned = 0; Inoperable = false; if (experimentLimit <= 1) Deployed = true; else { if (experimentNumber >= experimentLimit - 1) Deployed = true; } }
public override void OnLoad(ConfigNode node) { if (node.HasNode("ScienceData")) { foreach (ConfigNode storedDataNode in node.GetNodes("ScienceData")) { ScienceData data = new ScienceData(storedDataNode); storedScienceReports.Add(data); } } }
void IScienceDataContainer.ReviewDataItem(ScienceData data) { ReviewData(); }
protected void OnExperimentDeployed(ScienceData scienceData) { Vessel vessel = FlightGlobals.ActiveVessel; if (vessel == null || scienceData == null || !ReadyToComplete()) { return; } LoggingUtil.LogVerbose(this, "OnExperimentDeployed: " + scienceData.subjectID + ", " + vessel.id); // Decide if this is a matching subject ScienceSubject subject = ResearchAndDevelopment.GetSubjectByID(scienceData.subjectID); foreach (string exp in experiment) { if (CheckSubject(exp, subject)) { matchingSubjects[exp] = subject; if (recoveryMethod == ScienceRecoveryMethod.None) { recoveryDone[exp] = true; } UpdateDelegates(); } } CheckVessel(vessel); }
private ScienceData makeScience(float boost, ExperimentSituations vesselSituation) { string biome = getBiome(vesselSituation); CelestialBody mainBody = vessel.mainBody; bool asteroids = false; DMAsteroidScience newAsteroid = null; //Check for asteroids and alter the biome and celestialbody values as necessary if (asteroidReports && (DMAsteroidScience.AsteroidGrappled || DMAsteroidScience.AsteroidNear)) { newAsteroid = new DMAsteroidScience(); asteroids = true; mainBody = newAsteroid.Body; biome = newAsteroid.AType + newAsteroid.ASeed.ToString(); } ScienceData data = null; ScienceSubject sub = null; if (scienceExp == null) { Debug.LogError("[DM] Something Went Wrong Here; Null Experiment Returned; Please Report This On The KSP Forum With Output.log Data"); return null; } sub = ResearchAndDevelopment.GetExperimentSubject(scienceExp, vesselSituation, mainBody, biome); if (sub == null) { Debug.LogError("[DM] Something Went Wrong Here; Null Subject Returned; Please Report This On The KSP Forum With Output.log Data"); return null; } if (asteroids) { DMUtils.OnAsteroidScience.Fire(newAsteroid.AClass, experimentID); sub.title = scienceExp.experimentTitle + astCleanup(vesselSituation, newAsteroid.AType); registerDMScience(newAsteroid, sub); mainBody.bodyName = bodyNameFixed; } else { DMUtils.OnAnomalyScience.Fire(mainBody, experimentID, biome); sub.title = scienceExp.experimentTitle + situationCleanup(vesselSituation, biome); sub.subjectValue = fixSubjectValue(vesselSituation, sub.subjectValue, boost, mainBody); sub.scienceCap = scienceExp.scienceCap * sub.subjectValue; } data = new ScienceData(scienceExp.baseValue * sub.dataScale, xmitDataScalar, 1f, sub.id, sub.title, false, part.flightID); return data; }
/* ************************************************************************************************ * Function Name: ReviewData * Input: The current science experiment and a pretty screenshot * Output: None * Purpose: This is called when a science report is generated, or when the player is revisting * stored science experiments. This simply calls a coroutine, so as to allow execution without * dropping the frame rate. * ************************************************************************************************/ public void ReviewData(ScienceData Data, Texture2D Screenshot) { StartCoroutine(ReviewDataCoroutine(Data, Screenshot)); }
/* ************************************************************************************************ * Function Name: _onPageDiscard * Input: The current science experiment * Output: None * Purpose: This is a coroutine that is called when the "discard data" button in a Science report * dialog box is clicked. This resets the current science experiment. * ************************************************************************************************/ private void _onPageDiscard(ScienceData Data) { StoredData.Remove(Data); ResetExperimentGUI(); return; }
public ScienceData getAvailableScience(Vessel v, SCANdata.SCANtype sensor, bool notZero) { SCANdata data = getData(v.mainBody); ScienceData sd = null; ScienceExperiment se = null; ScienceSubject su = null; bool found = false; string id = null; double coverage = 0f; if(v.mainBody.pqsController != null) { if(!found && (sensor & SCANdata.SCANtype.AltimetryLoRes) != SCANdata.SCANtype.Nothing) { found = true; id = "SCANsatAltimetryLoRes"; coverage = data.getCoveragePercentage(SCANdata.SCANtype.AltimetryLoRes); } if(!found && (sensor & SCANdata.SCANtype.AltimetryHiRes) != SCANdata.SCANtype.Nothing) { found = true; id = "SCANsatAltimetryHiRes"; coverage = data.getCoveragePercentage(SCANdata.SCANtype.AltimetryHiRes); } } if(v.mainBody.BiomeMap != null) { if(!found && (sensor & SCANdata.SCANtype.Biome) != SCANdata.SCANtype.Nothing) { found = true; id = "SCANsatBiomeAnomaly"; coverage = data.getCoveragePercentage(SCANdata.SCANtype.Biome | SCANdata.SCANtype.Anomaly); } } if(!found) return null; se = ResearchAndDevelopment.GetExperiment(id); if(se == null) return null; su = ResearchAndDevelopment.GetExperimentSubject(se, ExperimentSituations.InSpaceHigh, v.mainBody, "surface"); if(su == null) return null; print("[SCANsat] coverage " + coverage.ToString("F1") + ", science cap " + su.scienceCap.ToString("F1") + ", subject value " + su.subjectValue.ToString("F2") + ", science value " + su.scientificValue.ToString("F2") + ", science " + su.science.ToString("F2")); su.scientificValue = 1; float science = (float)coverage; if(science > 95) science = 100; if(science < 30) science = 0; science = science / 100f; science = Mathf.Max(0, (science * su.scienceCap) - su.science); print("[SCANsat] remaining science: " + science.ToString("F1") + ", base = " + (se.baseValue).ToString("F1")); science /= Mathf.Max(0.1f, su.scientificValue); science /= su.subjectValue; print("[SCANsat] result = " + science.ToString("F2")); if(notZero && science <= 0) science = 0.00001f; sd = new ScienceData(science, 1f, 0f, id, se.experimentTitle + " of " + v.mainBody.theName); sd.subjectID = su.id; return sd; }
private void onKeepInitialData(ScienceData data) { if (experimentNumber >= experimentLimit) { ScreenMessages.PostScreenMessage(storageFullMessage, 5f, ScreenMessageStyle.UPPER_CENTER); initialResultsPage(); } else if (scienceReports.Count > 0) { if (experimentLimit != 0) { if (!string.IsNullOrEmpty(sampleAnim)) secondaryAnimator(sampleAnim, animSpeed, experimentNumber * (1f / experimentLimit), anim2[sampleAnim].length / experimentLimit); if (!string.IsNullOrEmpty(indicatorAnim)) secondaryAnimator(indicatorAnim, animSpeed, experimentNumber * (1f / experimentLimit), anim2[indicatorAnim].length / experimentLimit); } storedScienceReports.Add(data); scienceReports.Remove(data); experimentNumber++; } }
public void DumpData(ScienceData data) { storedPath = ""; storedData.Remove(data); ResetExperimentGUI(); }
//[KSPEvent(active = true, externalToEVAOnly = true, guiActiveUnfocused = true, guiName = "Collect Data", unfocusedRange = 2)] //public void CollectScience() //{ // List<ModuleScienceContainer> containers = FlightGlobals.ActiveVessel.FindPartModulesImplementing<ModuleScienceContainer>(); // foreach (ModuleScienceContainer container in containers) // { // if (storedData.Count > 0) // { // if (container.StoreData(new List<IScienceDataContainer>() { this }, false)) // ScreenMessages.PostScreenMessage("Transferred Data to " + vessel.vesselName, 3f, ScreenMessageStyle.UPPER_CENTER); // } // } //} private void _onPageSendToLab(ScienceData data) { }
protected virtual void onInitialComplete(ScienceData data) { initialResultsPage(); }
private void DumpInitialData(ScienceData data) { if (scienceReports.Contains(data)) { experimentsReturned++; Inoperable = !IsRerunnable(); Deployed = Inoperable; scienceReports.Remove(data); } }
public bool TransmitToKSC(ScienceData data) { List<ModuleDataTransmitter> transmitters = this.part.vessel.FindPartModulesImplementing<ModuleDataTransmitter>(); List<ScienceData> dataQueue = new List<ScienceData>(); ModuleDataTransmitter bestTransmitter = null; //Package up the data and put it in the queue. TransmitItem item = new TransmitItem(); item.science = data.dataAmount; item.reputation = 0f; item.funds = 0f; item.title = data.title; transmitList.Add(item); //Find an available transmitter. if found, transmit the data. dataQueue.Add(data); foreach (ModuleDataTransmitter transmitter in transmitters) { if (transmitter.IsBusy() == false) { if (bestTransmitter == null) bestTransmitter = transmitter; else if (transmitter.packetSize > bestTransmitter.packetSize) bestTransmitter = transmitter; } } if (bestTransmitter != null) { bestTransmitter.TransmitData(dataQueue, OnTransmitComplete); return true; } else { //Inform user that there is no available transmitter. ScreenMessages.PostScreenMessage(kNoAvailableTransmitter, 5.0f, ScreenMessageStyle.UPPER_CENTER); return false; } }
private void onSendToLab(ScienceData data) { List<ModuleScienceLab> labList = vessel.FindPartModulesImplementing<ModuleScienceLab>(); if (checkLabOps() && storedScienceReports.Count > 0) labList.OrderBy(ScienceUtil.GetLabScore).First().StartCoroutine(labList.First().ProcessData(data, new Callback<ScienceData>(onComplete))); else ScreenMessages.PostScreenMessage("No operational lab modules on this vessel. Cannot analyze data.", 4f, ScreenMessageStyle.UPPER_CENTER); }
protected override bool generateScienceData() { ScienceExperiment experiment = ResearchAndDevelopment.GetExperiment(experimentID); if (experiment == null) return false; if (science_to_add > 0) { result_title = experiment.experimentTitle; result_string = "Science experiments were conducted in the vicinity of " + vessel.mainBody.name + "."; transmit_value = science_to_add; recovery_value = science_to_add; data_size = science_to_add * 1.25f; xmit_scalar = 1; ScienceSubject subject = ResearchAndDevelopment.GetExperimentSubject(experiment, ScienceUtil.GetExperimentSituation(vessel), vessel.mainBody, ""); subject.scienceCap = 167 * PluginHelper.getScienceMultiplier(vessel.mainBody.flightGlobalsIndex, false); ref_value = subject.scienceCap; science_data = new ScienceData(science_to_add, 1, 0, subject.id, "Science Lab Data"); return true; } return false; }
public ModableExperimentResultDialogPage(Part host, ScienceData experimentData, float xmitDataScalar, float labDataBoost, bool showTransmitWarning, string transmitWarningMessage, bool showResetOption, bool showLabOption, Callback<ScienceData> onDiscardData, Callback<ScienceData> onKeepData, Callback<ScienceData> onTransmitData, Callback<ScienceData> onSendToLab) : base(host,experimentData,xmitDataScalar,labDataBoost,showTransmitWarning,transmitWarningMessage,showResetOption,showLabOption,onDiscardData, onKeepData, onTransmitData, onSendToLab) { }
private void onTransmitData(ScienceData data) { List<IScienceDataTransmitter> tranList = vessel.FindPartModulesImplementing<IScienceDataTransmitter>(); if (tranList.Count > 0 && storedScienceReports.Count > 0) { tranList.OrderBy(ScienceUtil.GetTransmitterScore).First().TransmitData(new List<ScienceData> { data }); DumpData(data); } else ScreenMessages.PostScreenMessage("No transmitters available on this vessel.", 4f, ScreenMessageStyle.UPPER_LEFT); }
/* ************************************************************************************************ * Function Name: _onPageKeep * Input: The current science experiment * Output: None * Purpose: This is a coroutine that is called when the "keep data" button in a Science report * dialog box is clicked. This stores the current science experiment in the part. * ************************************************************************************************/ private void _onPageKeep(ScienceData Data) { StoredData.Add(Data); ResetExperimentGUI(); return; }
private void onTransmitInitialData(ScienceData data) { List<IScienceDataTransmitter> tranList = vessel.FindPartModulesImplementing<IScienceDataTransmitter>(); if (tranList.Count > 0 && scienceReports.Count > 0) { if (experimentLimit != 0) { if (!string.IsNullOrEmpty(sampleAnim)) secondaryAnimator(sampleAnim, animSpeed, experimentNumber * (1f / experimentLimit), anim2[sampleAnim].length / experimentLimit); if (!string.IsNullOrEmpty(indicatorAnim)) secondaryAnimator(indicatorAnim, animSpeed, experimentNumber * (1f / experimentLimit), anim2[indicatorAnim].length / experimentLimit); } tranList.OrderBy(ScienceUtil.GetTransmitterScore).First().TransmitData(new List<ScienceData> { data }); DumpInitialData(data); experimentNumber++; } else ScreenMessages.PostScreenMessage("No transmitters available on this vessel.", 4f, ScreenMessageStyle.UPPER_LEFT); }
public ScienceDataValue(ScienceData scienceData) { this.scienceData = scienceData; InitializeSuffixes(); }
void IScienceDataContainer.DumpData(ScienceData data) { DumpData(data); }
private bool transmitData(SEP_ExperimentHandler exp, int level, float submittedData, float newData) { ScienceData data = SEP_Utilities.getScienceData(exp, exp.getExperimentLevel(level), level); if (exp.vessel.loaded) { IScienceDataTransmitter bestTransmitter = ScienceUtil.GetBestTransmitter(exp.vessel); if (bestTransmitter != null) { ScienceExperiment e = exp.getExperimentLevel(level); float transmitterCost = getLoadedTransmitterCost(bestTransmitter); float ecCost = newData * e.dataScale * transmitterCost; if (ecCost > SEP_Utilities.getTotalVesselEC(exp.vessel)) { if (!dataOnboard(exp, level)) { SEP_Utilities.log("Not enough power for transmissionon this vessel: {1}; saving data: {0}", logLevels.log, data.title, exp.vessel.vesselName); exp.addData(data); if (exp.host != null) { exp.host.Events["ReviewDataEvent"].active = true; exp.host.Events["TransferDataEvent"].active = exp.host.hasContainer; exp.host.Events["CollectData"].active = true; if (exp.host.Controller != null) { exp.host.Controller.setCollectEvent(); } } } return(false); } SEP_Utilities.log("Sending data to vessel comms: {0}", logLevels.log, data.title); bestTransmitter.TransmitData(new List <ScienceData> { data }); return(true); } else { if (!dataOnboard(exp, level)) { SEP_Utilities.log("No Comms Devices on this vessel: {1}. Cannot Transmit Data; saving data: {0}", logLevels.log, data.title, exp.vessel.vesselName); exp.addData(data); if (exp.host != null) { exp.host.Events["ReviewDataEvent"].active = true; exp.host.Events["TransferDataEvent"].active = exp.host.hasContainer; exp.host.Events["CollectData"].active = true; if (exp.host.Controller != null) { exp.host.Controller.setCollectEvent(); } } } return(false); } } else { List <ProtoPartSnapshot> transmitters = getProtoTransmitters(exp.vessel.protoVessel); float?transmitterCost = getBestTransmitterCost(transmitters); if (transmitterCost == null) { if (!dataOnboard(exp, level)) { SEP_Utilities.log("No Comms Devices on this vessel: {1}. Cannot Transmit Data; saving data: {0}", logLevels.log, data.title, exp.vessel.protoVessel.vesselName); exp.addData(data); } return(false); } //SEP_Utilities.log("Transmission Score: {0:N4}EC", logLevels.warning, transmitterCost); ScienceExperiment e = exp.getExperimentLevel(level); float ecCost = newData * e.dataScale * (float)transmitterCost; //SEP_Utilities.log("Transmission Cost: {0:N4}EC", logLevels.warning, ecCost); if (ecCost > SEP_Utilities.getTotalVesselEC(exp.vessel.protoVessel)) { if (!dataOnboard(exp, level)) { SEP_Utilities.log("Not enough electricity on this vessel: {1}. Cannot Transmit Data; saving data: {0}", logLevels.log, data.title, exp.vessel.protoVessel.vesselName); exp.addData(data); } return(false); } ScienceSubject sub = SEP_Utilities.checkAndUpdateRelatedSubjects(exp, level, newData, submittedData); if (sub == null) { return(false); } ResearchAndDevelopment.Instance.SubmitScienceData(newData * sub.dataScale, sub, 1, exp.vessel.protoVessel); if (exp.vessel.HasValidContractObjectives(new List <string> { "Generator" })) { consumeResources(exp.vessel.protoVessel, ecCost); } exp.submittedData += (newData - submittedData); return(true); } }
void IScienceDataContainer.ReturnData(ScienceData data) { ReturnData(data); }
private void _onPageKeep(ScienceData data) { ResetExperimentGUI(); }
private void onDiscardData(ScienceData data) { if (storedScienceReports.Count > 0) { if (experimentLimit != 0) { if (!string.IsNullOrEmpty(sampleEmptyAnim)) secondaryAnimator(sampleEmptyAnim, animSpeed, 1f - (experimentNumber * (1f / experimentLimit)), anim2[sampleEmptyAnim].length / experimentLimit); else if (!string.IsNullOrEmpty(sampleAnim)) secondaryAnimator(sampleAnim, -1f * animSpeed, experimentNumber * (1f / experimentLimit), anim2[sampleAnim].length / experimentLimit); if (!string.IsNullOrEmpty(indicatorAnim)) secondaryAnimator(indicatorAnim, -1f * animSpeed, experimentNumber * (1f / experimentLimit), anim[indicatorAnim].length / experimentLimit); } storedScienceReports.Remove(data); if (keepDeployedMode == 0) retractEvent(); experimentNumber--; if (experimentNumber < 0) experimentNumber = 0; Deployed = false; } }
public void ReviewDataItem(ScienceData data) { StartCoroutine(ReviewDataCoroutine(data)); }
private void onDiscardInitialData(ScienceData data) { if (scienceReports.Count > 0) { scienceReports.Remove(data); if (keepDeployedMode == 0) retractEvent(); Deployed = false; } }
public new void DumpData(ScienceData data) { NE_Helper.log("DumbData"); base.DumpData(data); }
private void onKeepData(ScienceData data) { }