public void Run()
{
if (HasData)
{
throw new InvalidOperationException("Experiment already contains data");
}
if (Inoperable)
{
throw new InvalidOperationException("Experiment is inoperable");
}
// Stock experiments
// FIXME: Don't use private API!!!
var gatherData = experiment.GetType().GetMethod("gatherData", BindingFlags.NonPublic | BindingFlags.Instance);
if (gatherData != null)
{
var result = (IEnumerator)gatherData.Invoke(experiment, new object[] { false });
experiment.StartCoroutine(result);
return;
}
// DMagic experiments
gatherData = experiment.GetType().GetMethod("gatherScienceData", BindingFlags.Public | BindingFlags.Instance | BindingFlags.FlattenHierarchy);
if (gatherData != null)
{
gatherData.Invoke(experiment, new object[] { true });
return;
}
throw new InvalidOperationException("Failed to find a gather data method for this experiment");
}
public ScienceExperimentFields(ModuleScienceExperiment module, SharedObjects sharedObj) : base(module, sharedObj)
{
this.module = module;
gatherDataMethod = module.GetType().GetMethod("gatherData",
BindingFlags.NonPublic | BindingFlags.Instance);
resetExperimentMethod = module.GetType().GetMethod("resetExperiment",
BindingFlags.NonPublic | BindingFlags.Instance);
sendDataToCommsMethod = module.GetType().GetMethod("sendDataToComms",
BindingFlags.NonPublic | BindingFlags.Instance);
dumpDataMethod = module.GetType().GetMethod("dumpData",
BindingFlags.NonPublic | BindingFlags.Instance);
InitializeSuffixes();
}
public ScienceExperimentFields(ModuleScienceExperiment module, SharedObjects sharedObj) : base(module, sharedObj)
{
this.module = module;
gatherDataMethod = module.GetType().GetMethod("gatherData",
BindingFlags.NonPublic | BindingFlags.Instance);
resetExperimentMethod = module.GetType().GetMethod("resetExperiment",
BindingFlags.NonPublic | BindingFlags.Instance);
sendDataToCommsMethod = module.GetType().GetMethod("sendDataToComms",
BindingFlags.NonPublic | BindingFlags.Instance);
dumpDataMethod = module.GetType().GetMethod("dumpData",
BindingFlags.NonPublic | BindingFlags.Instance);
InitializeSuffixes();
}
/// <summary>
/// Get the ScienceSubject for an asteroid experiment.
/// </summary>
/// <param name="mse">The science experiment module must be cast as a ModuleScienceExperiment.</param>
/// <param name="sit">The current Experiment Situation value; see the getExperimentSituation method above.</param>
/// <returns>Returns the ScienceSubject for that specific asteroid, experiment, and ExperimentSituation; returns null if the module is not of the right type, the experiment is not suitable for astroids, if no asteroids are detected, or if the current asteroid situation is not suitable for the experiment.</returns>
public static ScienceSubject getAsteroidSubject(ModuleScienceExperiment mse, ExperimentSituations sit)
{
if (mse == null)
{
return(null);
}
Type t = mse.GetType();
if (t != typeof(DMModuleScienceAnimateGeneric_NM.DMModuleScienceAnimateGeneric))
{
return(null);
}
DMModuleScienceAnimateGeneric_NM.DMModuleScienceAnimateGeneric DMMod = (DMModuleScienceAnimateGeneric_NM.DMModuleScienceAnimateGeneric)mse;
if (!isAsteroidExperiment(DMMod))
{
return(null);
}
if (DMMod.scienceExp == null)
{
return(null);
}
if (sit == ExperimentSituations.InSpaceLow)
{
if (!isAsteroidNear())
{
return(null);
}
}
else if (sit == ExperimentSituations.SrfLanded)
{
if (!isAsteroidGrappled())
{
return(null);
}
}
else
{
return(null);
}
if ((DMMod.scienceExp.situationMask & (int)sit) == 0)
{
return(null);
}
string oldBodyName = FlightGlobals.Bodies[16].bodyName;
DMAsteroidScienceGen newAsteroid = new DMAsteroidScienceGen();
ScienceSubject sub = new ScienceSubject(DMMod.scienceExp, sit, newAsteroid.Body, newAsteroid.AClass);
sub.subjectValue = newAsteroid.SciMult;
sub.scienceCap = DMMod.scienceExp.scienceCap * sub.subjectValue;
newAsteroid.Body.bodyName = oldBodyName;
return(sub);
}
/// <summary>
/// Get the ScienceSubject for an asteroid experiment.
/// </summary>
/// <param name="mse">The science experiment module must be cast as a ModuleScienceExperiment.</param>
/// <returns>Returns the ScienceSubject for that specific asteroid and experiment; returns null if the module is not of the right type, the experiment is not suitable for astroids, if no asteroids are detected, or if the current asteroid situation is not suitable for the experiment.</returns>
public static ScienceSubject getAsteroidSubject(ModuleScienceExperiment mse)
{
if (mse == null)
{
return(null);
}
Type t = mse.GetType();
if (!(t.IsSubclassOf(typeof(DMModuleScienceAnimate)) || t == typeof(DMModuleScienceAnimate)))
{
return(null);
}
DMModuleScienceAnimate DMMod = (DMModuleScienceAnimate)mse;
if (!isAsteroidExperiment(DMMod))
{
return(null);
}
if (DMMod.scienceExp == null)
{
return(null);
}
if (DMAsteroidScience.AsteroidGrappled)
{
if ((DMMod.scienceExp.situationMask & (int)ExperimentSituations.SrfLanded) == 0)
{
return(null);
}
string oldBodyName = FlightGlobals.Bodies[16].bodyName;
DMAsteroidScience newAsteroid = new DMAsteroidScience();
ScienceSubject sub = new ScienceSubject(DMMod.scienceExp, ExperimentSituations.SrfLanded, newAsteroid.Body, newAsteroid.AType + newAsteroid.ASeed.ToString());
sub.subjectValue = newAsteroid.SciMult;
newAsteroid.Body.bodyName = oldBodyName;
return(sub);
}
else if (DMAsteroidScience.AsteroidNear)
{
if ((DMMod.scienceExp.situationMask & (int)ExperimentSituations.InSpaceLow) == 0)
{
return(null);
}
string oldBodyName = FlightGlobals.Bodies[16].bodyName;
DMAsteroidScience newAsteroid = new DMAsteroidScience();
ScienceSubject sub = new ScienceSubject(DMMod.scienceExp, ExperimentSituations.InSpaceLow, newAsteroid.Body, newAsteroid.AType + newAsteroid.ASeed.ToString());
sub.subjectValue = newAsteroid.SciMult;
newAsteroid.Body.bodyName = oldBodyName;
return(sub);
}
return(null);
}
/// <summary>
/// Attempts to call DeployExperiment() on subclasses. Falls back to default on failure.
/// </summary>
/// <param name="moduleScienceExperiment"></param>
public static void DeployExperimentUsingReflection(this ModuleScienceExperiment moduleScienceExperiment)
{
try {
moduleScienceExperiment.GetType().InvokeMember("DeployExperiment", System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.IgnoreReturn | System.Reflection.BindingFlags.InvokeMethod, null, moduleScienceExperiment, null);
} catch {
moduleScienceExperiment.DeployExperiment();
}
}
/// <summary>
/// Attempts to call DumpData() on subclasses. Falls back to default on failure.
/// </summary>
/// <param name="moduleScienceExperiment"></param>
/// <param name="scienceData"></param>
public static void DumpDataUsingReflection(this ModuleScienceExperiment moduleScienceExperiment, ScienceData scienceData)
{
try {
moduleScienceExperiment.GetType().InvokeMember("DumpData", System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.IgnoreReturn | System.Reflection.BindingFlags.InvokeMethod, null, moduleScienceExperiment, new object[] { scienceData });
} catch {
moduleScienceExperiment.DumpData(scienceData);
}
}
/// <summary>
/// Attempts to call GetData() on subclasses. Falls back to default on failure.
/// </summary>
/// <param name="moduleScienceExperiment"></param>
/// <returns></returns>
public static ScienceData[] GetDataUsingReflection(this ModuleScienceExperiment moduleScienceExperiment)
{
try {
return((ScienceData[])moduleScienceExperiment.GetType().InvokeMember("GetData", System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.InvokeMethod, null, moduleScienceExperiment, null));
} catch {
return(moduleScienceExperiment.GetData());
}
}
/** Checks type for an experiment and returns suitable IETExperiment */
private IETExperiment checkType(ModuleScienceExperiment exp)
{
foreach (IETExperiment act in activators)
{
try
{
if (exp.GetType() == act.getType() || exp.GetType().IsSubclassOf(act.getType()))
{
return(act);
}
}
catch (Exception)
{
continue;
}
}
return(null);
}
public void Deploy()
{
var gatherDataMethod = experiment.GetType()
.GetMethod("gatherData", BindingFlags.NonPublic | BindingFlags.Instance);
experiment.DeployExperiment();
object result = gatherDataMethod !.Invoke(experiment, new object[] { false });
experiment.StartCoroutine(result as IEnumerator);
}
/** Checks type for an experiment and returns suitable IETExperiment */
private IETExperiment checkType(ModuleScienceExperiment exp)
{
for (int i = activators.Count - 1; i >= 0; i--)
{
IETExperiment act = activators[i];
try
{
if (exp.GetType() == act.getType() || exp.GetType().IsSubclassOf(act.getType()))
{
return(act);
}
}
catch (Exception)
{
continue;
}
}
return(null);
}
protected virtual void Deploy()
{
ThrowIfNotCPUVessel();
var gatherDataMethod = module.GetType().GetMethod("gatherData",
BindingFlags.NonPublic | BindingFlags.Instance);
object result = gatherDataMethod.Invoke(module, new object[] { false });
IEnumerator e = result as IEnumerator;
module.StartCoroutine(e);
}
public void Run()
{
if (HasData)
{
throw new InvalidOperationException("Experiment already contains data");
}
if (Inoperable)
{
throw new InvalidOperationException("Experiment is inoperable");
}
// FIXME: Don't use private API!!!
var gatherData = experiment.GetType().GetMethod("gatherData", BindingFlags.NonPublic | BindingFlags.Instance);
var result = (IEnumerator)gatherData.Invoke(experiment, new object[] { false });
experiment.StartCoroutine(result);
}
/// <summary>
/// Calls the internal method for getting the biome for a certain experiment.
/// </summary>
/// <param name="mse">The science experiment module must be cast as a ModuleScienceExperiment.</param>
/// <param name="sit">The current Experiment Situation value; see getExperimentSituation.</param>
/// <returns>Returns the biome string for that experiment; returns an empty string if the experiment is not of the right type.</returns>
public static string getBiome(ModuleScienceExperiment mse, ExperimentSituations sit)
{
if (mse == null)
{
return("");
}
Type t = mse.GetType();
if (t == typeof(DMModuleScienceAnimateGeneric_NM.DMModuleScienceAnimateGeneric))
{
DMModuleScienceAnimateGeneric_NM.DMModuleScienceAnimateGeneric DMMod = (DMModuleScienceAnimateGeneric_NM.DMModuleScienceAnimateGeneric)mse;
return(DMMod.getBiome(sit));
}
return("");
}
/// <summary>
/// Calls the internal method for getting the Experiment Situation for a certain experiment.
/// </summary>
/// <param name="mse">The science experiment module must be cast as a ModuleScienceExperiment.</param>
/// <returns>Returns the Experiment Situation value for that experiment; returns InSpaceHigh if the experiment is not of the right type.</returns>
public static ExperimentSituations getExperimentSituation(ModuleScienceExperiment mse)
{
if (mse == null)
{
return(ExperimentSituations.InSpaceHigh);
}
Type t = mse.GetType();
if (t == typeof(DMModuleScienceAnimateGeneric_NM.DMModuleScienceAnimateGeneric))
{
DMModuleScienceAnimateGeneric_NM.DMModuleScienceAnimateGeneric DMMod = (DMModuleScienceAnimateGeneric_NM.DMModuleScienceAnimateGeneric)mse;
return(DMMod.getSituation());
}
return(ExperimentSituations.InSpaceHigh);
}
/// <summary>
/// Check if an experiment can be conducted on asteroids.
/// </summary>
/// <param name="mse">The science experiment module must be cast as a ModuleScienceExperiment.</param>
/// <returns>Returns false if the module is not of the right type or if the experiment cannot be conducted with asteroids.</returns>
public static bool isAsteroidExperiment(ModuleScienceExperiment mse)
{
if (mse == null)
{
return(false);
}
Type t = mse.GetType();
if (t == typeof(DMModuleScienceAnimateGeneric_NM.DMModuleScienceAnimateGeneric))
{
DMModuleScienceAnimateGeneric_NM.DMModuleScienceAnimateGeneric DMMod = (DMModuleScienceAnimateGeneric_NM.DMModuleScienceAnimateGeneric)mse;
return(DMMod.asteroidReports);
}
return(false);
}
/// <summary>
/// Calls the internal method for getting the biome for a certain experiment.
/// </summary>
/// <param name="mse">The science experiment module must be cast as a ModuleScienceExperiment.</param>
/// <param name="sit">The current Experiment Situation value; see getExperimentSituation.</param>
/// <returns>Returns the biome string for that experiment; returns an empty string if the experiment is not of the right type.</returns>
public static string getBiome(ModuleScienceExperiment mse, ExperimentSituations sit)
{
if (mse == null)
{
return("");
}
Type t = mse.GetType();
if (t == typeof(DMAnomalyScanner))
{
DMAnomalyScanner DMMod = (DMAnomalyScanner)mse;
DMMod.getAnomValues();
return(DMMod.getBiome(sit));
}
else if (t == typeof(DMBathymetry))
{
DMBathymetry DMMod = (DMBathymetry)mse;
return(DMMod.getBiome(sit));
}
else if (t == typeof(DMReconScope))
{
DMReconScope DMMod = (DMReconScope)mse;
return(DMMod.getBiome(sit));
}
else if (t == typeof(DMSIGINT))
{
DMSIGINT DMMod = (DMSIGINT)mse;
return(DMMod.getBiome(sit));
}
else if (t.IsSubclassOf(typeof(DMModuleScienceAnimate)))
{
DMModuleScienceAnimate DMMod = (DMModuleScienceAnimate)mse;
return(DMMod.getBiome(sit));
}
else if (t == typeof(DMModuleScienceAnimate))
{
DMModuleScienceAnimate DMMod = (DMModuleScienceAnimate)mse;
return(DMMod.getBiome(sit));
}
return("");
}
/// <summary>
/// Calls the internal method for getting the Experiment Situation for a certain experiment.
/// </summary>
/// <param name="mse">The science experiment module must be cast as a ModuleScienceExperiment.</param>
/// <returns>Returns the Experiment Situation value for that experiment; returns InSpaceHigh if the experiment is not of the right type.</returns>
public static ExperimentSituations getExperimentSituation(ModuleScienceExperiment mse)
{
if (mse == null)
{
return(ExperimentSituations.InSpaceHigh);
}
Type t = mse.GetType();
if (t == typeof(DMAnomalyScanner))
{
DMAnomalyScanner DMMod = (DMAnomalyScanner)mse;
return(DMMod.getSituation());
}
else if (t == typeof(DMBathymetry))
{
DMBathymetry DMMod = (DMBathymetry)mse;
return(DMMod.getSituation());
}
else if (t == typeof(DMReconScope))
{
DMReconScope DMMod = (DMReconScope)mse;
return(DMMod.getSituation());
}
else if (t == typeof(DMSIGINT))
{
DMSIGINT DMMod = (DMSIGINT)mse;
return(DMMod.getSituation());
}
else if (t.IsSubclassOf(typeof(DMModuleScienceAnimate)))
{
DMModuleScienceAnimate DMMod = (DMModuleScienceAnimate)mse;
return(DMMod.getSituation());
}
else if (t == typeof(DMModuleScienceAnimate))
{
DMModuleScienceAnimate DMMod = (DMModuleScienceAnimate)mse;
return(DMMod.getSituation());
}
return(ExperimentSituations.InSpaceHigh);
}
private static void PrepareExternalModules(Item moduleNode, ModuleScienceExperiment moduleScienceExperiment,
ScienceExperiment experiment)
{
if (moduleNode != null)
{
Type t = moduleScienceExperiment.GetType();
//var meth = t.GetMethod("");
//meth.Invoke(moduleScienceExperiment, new object[]{12, 2, 6});
var field = t.GetField(moduleNode.Biome);
if (field != null)
{
var value = field.GetValue(moduleScienceExperiment);
experiment.biomeMask = Convert.ToUInt32(value);
}
else
{
var property = t.GetProperty(moduleNode.Biome);
if (property != null)
{
var value = property.GetValue(moduleScienceExperiment, null);
experiment.biomeMask = Convert.ToUInt32(value);
}
}
field = t.GetField(moduleNode.Situation);
if (field != null)
{
var value = field.GetValue(moduleScienceExperiment);
experiment.situationMask = Convert.ToUInt32(value);
}
else
{
var property = t.GetProperty(moduleNode.Situation);
if (property != null)
{
var value = property.GetValue(moduleScienceExperiment, null);
experiment.situationMask = Convert.ToUInt32(value);
}
}
}
}
/// <summary>
/// Check if an experiment can be conducted on asteroids.
/// </summary>
/// <param name="mse">The science experiment module must be cast as a ModuleScienceExperiment.</param>
/// <returns>Returns false if the module is not of the right type or if the experiment cannot be conducted with asteroids.</returns>
public static bool isAsteroidExperiment(ModuleScienceExperiment mse)
{
if (mse == null)
{
return(false);
}
Type t = mse.GetType();
if (t.IsSubclassOf(typeof(DMModuleScienceAnimate)))
{
DMModuleScienceAnimate DMMod = (DMModuleScienceAnimate)mse;
return(DMMod.asteroidReports);
}
else if (t == typeof(DMModuleScienceAnimate))
{
DMModuleScienceAnimate DMMod = (DMModuleScienceAnimate)mse;
return(DMMod.asteroidReports);
}
return(false);
}
private void getBiomeDMagic(ModuleScienceExperiment currentExperiment, ref string biome)
{
//getBiome
try
{
MethodInfo getBiomeMethod = currentExperiment.GetType().GetMethod("getBiome", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy | BindingFlags.InvokeMethod);
if (getBiomeMethod != null)
{
biome = (string)getBiomeMethod.Invoke(currentExperiment, new object[] { currentSituation });
Utilities.debug(modName, Utilities.LogMode.Debug, "found getBiomeMethod:" + biome);
}
else
{
Utilities.debug(modName, Utilities.LogMode.Debug, "getBiomeMethod is null");
}
}
catch (Exception e)
{
Utilities.debug(modName, Utilities.LogMode.Exception, e.Message);
}
}
public void AddScienceExperiment()
{
// If the Node is null, abort
if (experimentNode == null)
return;
// Create the ScienceExperiment
Part kerbal = FlightGlobals.ActiveVessel.evaController.part;
experiment = kerbal.AddModule(typeof(ModuleScienceExperiment).Name) as ModuleScienceExperiment;
// I can't find a function that loads the module from the config node... :/ Doing it manually
Type type = experiment.GetType();
foreach (ConfigNode.Value value in experimentNode.values)
{
try
{
FieldInfo field = type.GetField(value.name);
if (field.FieldType == typeof(string))
field.SetValue(experiment, value.value);
else if (field.FieldType.GetMethod("Parse") != null)
field.SetValue(experiment, field.FieldType.GetMethod("Parse").Invoke(null, new object[] { value.value }));
}
catch { }
}
// Deactivate some things
experiment.resettable = false;
// Start the experiment
experiment.OnStart(PartModule.StartState.None);
vesselID.Add(kerbal.vessel.id);
}
/// <summary>
/// For external use to determine if a module can conduct science
/// </summary>
/// <param name="MSE">The base ModuleScienceExperiment instance</param>
/// <returns>True if the experiment can be conducted under current conditions</returns>
public static bool conduct(ModuleScienceExperiment MSE)
{
if (MSE.GetType() != typeof(DMModuleScienceAnimate))
return false;
DMModuleScienceAnimate DMMod = (DMModuleScienceAnimate)MSE;
try
{
return DMMod.canConduct();
}
catch (Exception e)
{
Debug.LogWarning("[DM] Error in casting ModuleScienceExperiment to DMModuleScienceAnimate; Invalid Part Module... : " + e);
return false;
}
}
private bool canConduct(ModuleScienceExperiment currentExperiment, ScienceExperiment experiment)
{
try
{
MethodInfo conductMethod = currentExperiment.GetType().BaseType.GetMethod("canConduct", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy | BindingFlags.InvokeMethod);
if (conductMethod == null)
{
conductMethod = currentExperiment.GetType().GetMethod("canConduct", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy | BindingFlags.InvokeMethod);
}
if (conductMethod != null)
{
var conductResult = (bool)conductMethod.Invoke(currentExperiment, null);
if (!conductResult)
{
Utilities.debug(modName, Utilities.LogMode.Debug, "Experiment {0} can't be conducted.", experiment.id);
return false;
}
return true;
}
else
{
Utilities.debug(modName, Utilities.LogMode.Error, experiment.id + ": conductMethod == null");
}
}
catch (Exception e)
{
Utilities.debug(modName, Utilities.LogMode.Exception, e.Message);
}
return false;
}
private void ResetExperiment(ModuleScienceExperiment currentExperiment)
{
//Same as DeployExperiment just switched out the name
try
{
currentExperiment.GetType().InvokeMember("ResetExperiment", System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.IgnoreReturn | System.Reflection.BindingFlags.InvokeMethod, null, currentExperiment, null);
}
catch (Exception e)
{
Utilities.debug(modName, Utilities.LogMode.Error, "Failed to invoke \"ResetExperiment\" using GetType(). " + e);
currentExperiment.ResetExperiment();
}
currentExperiment.Inoperable = false;
}
private bool isExperimentLimitReached(ModuleScienceExperiment currentExperiment, ScienceExperiment experiment, ScienceSubject currentScienceSubject, ref float currentScienceValue)
{
try
{
int experimentNumber, experimentLimit;
if (int.TryParse(currentExperiment.GetType().GetField("experimentNumber").GetValue(currentExperiment).ToString(), out experimentNumber) &&
int.TryParse(currentExperiment.GetType().GetField("experimentLimit").GetValue(currentExperiment).ToString(), out experimentLimit))
{
if ((experimentNumber >= experimentLimit) && experimentLimit >= 1)
{
Utilities.debug(modName, Utilities.LogMode.Log, "Experiment {0} can't be conducted cause the experimentLimit is reached!", experiment.id);
return true;
}
else if (experimentNumber > 0)
{
addToContainer(currentScienceSubject.id, experimentNumber);
currentScienceValue = Utilities.Science.getScienceValue(shipCotainsExperiments, experiment, currentScienceSubject);
Utilities.debug(modName, Utilities.LogMode.Log, "Experiment is a DMagic Orbital Science experiment. Science value changed to: " + currentScienceValue);
if (currentScienceValue < currentSettings.getFloat("scienceCutoff"))
{
Utilities.debug(modName, Utilities.LogMode.Log, "Experiment is a DMagic Orbital Science experiment. Science value droped below cutoff.");
return true;
}
}
}
}
catch (Exception)
{
}
return false;
}
private void createScienceDMagic(ModuleScienceExperiment currentExperiment, ScienceSubject currentScienceSubject, float currentScienceValue)
{
var scienceData = new ScienceData(currentScienceValue, currentExperiment.xmitDataScalar, 0, currentScienceSubject.id, currentScienceSubject.title);
try
{
currentExperiment.GetType().InvokeMember("deployEvent", System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.IgnoreReturn | System.Reflection.BindingFlags.InvokeMethod, null, currentExperiment, null);
}
catch (Exception)
{
}
if (!currentExperiment.rerunnable)
{
currentExperiment.SetInoperable();
GameEvents.OnExperimentDeployed.Fire(scienceData);
}
container.AddData(scienceData);
}
private void DeployExperiment(ModuleScienceExperiment currentExperiment)
{
try//taken from ScienceAlert since .DeployExperiment() didnt work and i didnt know about this
{
// Get the most-derived type and use its DeployExperiment so we don't
// skip any plugin-derived versions
currentExperiment.GetType().InvokeMember("DeployExperiment", System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.IgnoreReturn | System.Reflection.BindingFlags.InvokeMethod, null, currentExperiment, null);
}
catch (Exception e)
{
Utilities.debug(modName, Utilities.LogMode.Error, "Failed to invoke \"DeployExperiment\" using GetType(), falling back to base type after encountering exception " + e);
currentExperiment.DeployExperiment();
}
}
