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)
{
}
