internal JSIDummy(ConfigNode node, RPMVesselComputer comp)
: base(node)
{
if (!node.HasValue("perPodPersistenceName"))
{
throw new Exception("Trying to create Dummy JSIAction with no perPodPersistenceName");
}
perPodPersistenceName = node.GetValue("perPodPersistenceName");
if (string.IsNullOrEmpty(perPodPersistenceName))
{
throw new Exception("Invalid perPodPersistenceName supplied for Dummy JSIAction");
}
if (node.HasValue("initialState"))
{
if (!bool.TryParse(node.GetValue("initialState"), out currentState))
{
currentState = false;
}
}
else
{
currentState = false;
}
currentState = comp.GetPersistentVariable(perPodPersistenceName, currentState);
comp.SetPersistentVariable(perPodPersistenceName, currentState);
}
/// <summary>
/// Return the persistent variable, pre-treated as a boolean.
/// </summary>
/// <param name="name"></param>
/// <param name="defaultValue"></param>
/// <param name="broadcast">Broadcast the request to other parts of the same craft?</param>
/// <returns></returns>
internal bool GetPersistentVariable(string name, bool defaultValue, bool broadcast)
{
object val;
if (persistentVars.ContainsKey(name))
{
val = persistentVars[name];
}
else if (broadcast)
{
RPMVesselComputer comp = RPMVesselComputer.Instance(vessel);
val = comp.GetPersistentVariable(name, defaultValue);
if (val.GetType() == typeof(System.Boolean))
{
persistentVars[name] = val;
}
}
else
{
val = defaultValue;
persistentVars[name] = defaultValue;
}
return((val.GetType() == typeof(System.Boolean)) ? (bool)val : false);
}
override internal bool CurrentState(Vessel vessel, RPMVesselComputer comp)
{
currentState = comp.GetPersistentVariable(perPodPersistenceName, currentState);
if (enableVariable != null)
{
currentState = currentState & enableVariable.IsInRange(comp);
}
return(currentState);
}
/// <summary>
/// Returns the named persistent value, or the default provided if
/// it's not set. The persistent value is initialized to the default
/// if the default is used. If 'broadcast' is set, other RPMC on the
/// same vessel are queried, as well.
/// </summary>
/// <param name="name">Name of the persistent</param>
/// <param name="defaultValue">The default value</param>
/// <param name="broadcast">Broadcast the request to other parts of the same craft?</param>
/// <returns></returns>
internal object GetPersistentVariable(string name, object defaultValue, bool broadcast)
{
object val;
if (persistentVars.ContainsKey(name))
{
val = persistentVars[name];
}
else if (broadcast)
{
RPMVesselComputer comp = RPMVesselComputer.Instance(vessel);
val = comp.GetPersistentVariable(name, defaultValue);
persistentVars[name] = val;
}
else
{
val = defaultValue;
persistentVars[name] = defaultValue;
}
return(val);
}
override internal bool CurrentState(Vessel vessel, RPMVesselComputer comp)
{
currentState = comp.GetPersistentVariable(persistentVarName, currentState);
return(currentState);
}
internal JSIIntLight(ConfigNode node, RPMVesselComputer comp, InternalModel internalModel)
: base(node)
{
if (!node.HasValue("internalLightName"))
{
throw new Exception("Unable to configure IJSIAction intlight without 'internalLightName'");
}
string internalLightName = node.GetValue("internalLightName");
if (node.HasValue("persistentVarName"))
{
persistentVarName = node.GetValue("persistentVarName");
if (string.IsNullOrEmpty(persistentVarName))
{
throw new Exception("Invalid persistentVarName supplied for internal light " + internalLightName);
}
}
else
{
persistentVarName = internalLightName;
}
Light[] availableLights = internalModel.FindModelComponents <Light>();
if (availableLights != null && availableLights.Length > 0)
{
List <Light> lights = new List <Light>(availableLights);
for (int i = lights.Count - 1; i >= 0; --i)
{
if (lights[i].name != internalLightName)
{
lights.RemoveAt(i);
}
}
if (lights.Count > 0)
{
lightObjects = lights.ToArray();
}
}
if (lightObjects == null)
{
throw new Exception("No lights with name " + internalLightName + " were found for JSISwitch intlight");
}
if (node.HasValue("needsElectricCharge"))
{
bool.TryParse(node.GetValue("needsElectricCharge"), out needsElectricCharge);
}
bool initialState = false;
if (node.HasValue("initialState"))
{
bool.TryParse(node.GetValue("initialState"), out initialState);
}
comp.GetPersistentVariable(persistentVarName, initialState);
currentState = initialState;
comp.SetPersistentVariable(persistentVarName, currentState);
SetInternalLights(currentState);
}
private void UpdateOdometer()
{
double thisUpdate = Planetarium.GetUniversalTime();
float dT = (float)(thisUpdate - lastUpdate) * odometerRotationScalar;
RPMVesselComputer comp = RPMVesselComputer.Instance(vessel);
float value;
if (!string.IsNullOrEmpty(perPodPersistenceName))
{
bool state = comp.GetPersistentVariable(perPodPersistenceName, false);
value = comp.ProcessVariable((state) ? altVariable : variable).MassageToFloat();
}
else
{
value = comp.ProcessVariable(variable).MassageToFloat();
}
// Make sure the value isn't going to be a problem.
if (float.IsNaN(value))
{
value = 0.0f;
}
if (value < 0.0f)
{
signGoalCoord = 0.625f;
}
else if (value > 0.0f)
{
signGoalCoord = 0.875f;
}
else
{
signGoalCoord = 0.75f;
}
signCurrentCoord = JUtil.DualLerp(signCurrentCoord, signGoalCoord, 0.0f, 1.0f, dT);
value = Mathf.Abs(value);
if (oMode == OdometerMode.SI)
{
float leadingDigitExponent;
if (value < 0.001f)
{
leadingDigitExponent = -3.0f;
}
else
{
leadingDigitExponent = Mathf.Floor(Mathf.Log10(value));
}
// siExponent is the location relative to the original decimal of
// the SI prefix. Is is always the greatest multiple-of-3 less
// than the leadingDigitExponent.
int siIndex = (int)Mathf.Floor(leadingDigitExponent / 3.0f);
if (siIndex > 3)
{
siIndex = 3;
}
int siExponent = siIndex * 3;
prefixGoalCoord = (float)(siIndex + 1) * 0.125f;
prefixCurrentCoord = JUtil.DualLerp(prefixCurrentCoord, prefixGoalCoord, 0.0f, 1.0f, dT);
float scaledValue = value / Mathf.Pow(10.0f, (float)(siExponent - 3));
int intValue = (int)(scaledValue);
for (int i = 5; i >= 0; --i)
{
float thisCoord = (float)(intValue % 10) / 10.0f;
if (i == 5)
{
// So we can display fractional values:
// However, we also quantize it to make it easier to
// read during the transition from 9 to 0.
thisCoord = Mathf.Floor((scaledValue % 10.0f) * 2.0f) / 20.0f;
}
intValue = intValue / 10;
goalCoordinate[i] = thisCoord;
}
}
else if (oMode == OdometerMode.TIME_HHHMMSS)
{
// Clamp the value
value = Mathf.Min(value, 59.0f + 59.0f * 60.0f + 999.0f * 60.0f * 24.0f);
// seconds
float thisCoord = Mathf.Floor((value % 10.0f) * 2.0f) / 20.0f;
goalCoordinate[6] = thisCoord;
int intValue = (int)(value) / 10;
// tens of seconds
thisCoord = (float)(intValue % 6) / 10.0f;
goalCoordinate[5] = thisCoord;
intValue /= 6;
// minutes
thisCoord = (float)(intValue % 10) / 10.0f;
goalCoordinate[4] = thisCoord;
intValue /= 10;
// tens of minutes
thisCoord = (float)(intValue % 6) / 10.0f;
goalCoordinate[3] = thisCoord;
intValue /= 6;
for (int i = 2; i >= 0; --i)
{
thisCoord = (float)(intValue % 10) / 10.0f;
intValue = intValue / 10;
goalCoordinate[i] = thisCoord;
}
}
else
{
int intValue = (int)(value);
for (int i = 7; i >= 0; --i)
{
float thisCoord = (float)(intValue % 10) / 10.0f;
if (i == 7)
{
thisCoord = Mathf.Floor((value % 10.0f) * 2.0f) / 20.0f;
}
intValue = intValue / 10;
goalCoordinate[i] = thisCoord;
}
}
// Update interpolants
for (int i = 0; i < 8; ++i)
{
if (currentCoordinate[i] != goalCoordinate[i])
{
float startingPoint;
float endingPoint;
if (Mathf.Abs(currentCoordinate[i] - goalCoordinate[i]) <= 0.5f)
{
startingPoint = currentCoordinate[i];
endingPoint = goalCoordinate[i];
}
else if (goalCoordinate[i] < currentCoordinate[i])
{
startingPoint = currentCoordinate[i];
endingPoint = goalCoordinate[i] + 1.0f;
}
else
{
startingPoint = currentCoordinate[i] + 1.0f;
endingPoint = goalCoordinate[i];
}
// This lerp causes a rotation that starts quickly but
// slows down close to the goal. It actually looks
// pretty good for typical incrementing counts, while the
// rapid spinning of small values is chaotic enough that
// you can't really tell what's going on, anyway.
float goal = JUtil.DualLerp(startingPoint, endingPoint, 0.0f, 1.0f, dT);
if (goal > 1.0f)
{
goal -= 1.0f;
}
currentCoordinate[i] = goal;
}
}
lastUpdate = thisUpdate;
}
public override void OnUpdate()
{
if (HighLogic.LoadedSceneIsEditor)
{
return;
}
if (!startupComplete)
{
return;
}
if (!JUtil.IsActiveVessel(vessel))
{
if (loopingOutput != null && currentState == true)
{
loopingOutput.audio.volume = 0.0f;
}
return;
}
else if (loopingOutput != null && currentState == true && loopingOutput.Active)
{
loopingOutput.audio.volume = loopingSoundVolume * GameSettings.SHIP_VOLUME;
}
if (consumingWhileActive && currentState && !forcedShutdown)
{
float requesting = (consumeWhileActiveAmount * TimeWarp.deltaTime);
float extracted = part.RequestResource(consumeWhileActiveName, requesting);
if (Math.Abs(extracted - requesting) > Math.Abs(requesting / 2))
{
// We don't have enough of the resource or can't produce more negative resource, so we should shut down...
forcedShutdown = true;
JUtil.LogMessage(this, "Could not consume {0}, asked for {1}, got {2} shutting switch down.", consumeWhileActiveName, requesting, extracted);
}
}
// Bizarre, but looks like I need to animate things offscreen if I want them in the right condition when camera comes back.
// So there's no check for internal cameras.
bool newState;
RPMVesselComputer comp = RPMVesselComputer.Instance(vessel);
if (isPluginAction && stateVariableValid)
{
try
{
newState = (comp.ProcessVariable(stateVariable).MassageToInt()) > 0;
}
catch
{
newState = currentState;
}
}
else if (isCustomAction)
{
if (string.IsNullOrEmpty(switchTransform) && perPodPersistenceValid)
{
if (switchGroupIdentifier >= 0)
{
int activeGroupId = comp.GetPersistentVariable(persistentVarName, 0).MassageToInt();
newState = (switchGroupIdentifier == activeGroupId);
customGroupState = newState;
}
else
{
// If the switch transform is not given, and the global comp.Persistence value is, this means this is a slave module.
newState = comp.GetPersistentVariable(persistentVarName, false);
}
}
else
{
// Otherwise it's a master module. But it still might have to follow the clicks on other copies of the same prop...
if (perPodPersistenceValid)
{
if (switchGroupIdentifier >= 0)
{
int activeGroupId = comp.GetPersistentVariable(persistentVarName, 0).MassageToInt();
newState = (switchGroupIdentifier == activeGroupId);
customGroupState = newState;
}
else
{
newState = comp.GetPersistentVariable(persistentVarName, customGroupState);
}
}
else
{
newState = customGroupState;
}
}
}
else
{
newState = vessel.ActionGroups[kspAction];
}
// If needsElectricCharge is true and there is no charge, the state value is overridden to false and the click action is reexecuted.
if (needsElectricChargeValue)
{
lightCheckCountdown--;
if (lightCheckCountdown <= 0)
{
lightCheckCountdown = refreshRate;
forcedShutdown |= currentState && comp.ProcessVariable(resourceName).MassageToFloat() < 0.01f;
}
}
if (perPodMasterSwitchValid)
{
bool switchEnabled = comp.GetPersistentVariable(perPodMasterSwitchName, false);
if (!switchEnabled)
{
// If the master switch is 'off', this switch needs to turn off
newState = false;
forcedShutdown = true;
}
}
if (masterVariable != null)
{
if (!masterVariable.IsInRange(comp))
{
newState = false;
forcedShutdown = true;
}
}
if (forcedShutdown)
{
if (currentState)
{
Click();
}
newState = false;
forcedShutdown = false;
}
if (newState != currentState)
{
// If we're consuming resources on toggle, do that now.
if ((consumingOnToggleUp && newState) || (consumingOnToggleDown && !newState))
{
float extracted = part.RequestResource(consumeOnToggleName, consumeOnToggleAmount);
if (Math.Abs(extracted - consumeOnToggleAmount) > Math.Abs(consumeOnToggleAmount / 2))
{
// We don't have enough of the resource, so we force a shutdown on the next loop.
// This ensures the animations will play at least once.
forcedShutdown = true;
}
}
if (audioOutput != null && (CameraManager.Instance.currentCameraMode == CameraManager.CameraMode.IVA ||
CameraManager.Instance.currentCameraMode == CameraManager.CameraMode.Internal))
{
audioOutput.audio.Play();
}
if (loopingOutput != null && (CameraManager.Instance.currentCameraMode == CameraManager.CameraMode.IVA ||
CameraManager.Instance.currentCameraMode == CameraManager.CameraMode.Internal))
{
if (newState)
{
loopingOutput.audio.Play();
}
else
{
loopingOutput.audio.Stop();
}
}
if (anim != null)
{
if (newState ^ reverse)
{
anim[animationName].normalizedTime = 0;
anim[animationName].speed = 1f * customSpeed;
anim.Play(animationName);
}
else
{
anim[animationName].normalizedTime = 1;
anim[animationName].speed = -1f * customSpeed;
anim.Play(animationName);
}
}
else if (colorShiftMaterial != null)
{
colorShiftMaterial.SetColor(colorName, (newState ^ reverse ? enabledColorValue : disabledColorValue));
}
currentState = newState;
}
}
public void Click()
{
RPMVesselComputer comp = RPMVesselComputer.Instance(vessel);
bool switchEnabled = true;
if (!forcedShutdown)
{
if (perPodMasterSwitchValid)
{
switchEnabled = comp.GetPersistentVariable(perPodMasterSwitchName, false);
}
if (masterVariable != null)
{
switchEnabled = masterVariable.IsInRange(comp);
}
}
if (!switchEnabled)
{
// If the master switch is 'off' and we're not here because
// of a forced shutdown, don't allow this switch to work.
// early return
return;
}
if (isCustomAction)
{
if (switchGroupIdentifier >= 0)
{
if (!forcedShutdown && !customGroupState)
{
customGroupState = true;
if (persistentVarValid)
{
comp.SetPersistentVariable(persistentVarName, switchGroupIdentifier);
}
}
// else: can't turn off a radio group switch.
}
else if (customAction == CustomActions.Plugin && stateVariableValid)
{
int ivalue = comp.ProcessVariable(stateVariable).MassageToInt();
customGroupState = (ivalue < 1) && !forcedShutdown;
}
else
{
customGroupState = !customGroupState;
if (persistentVarValid)
{
comp.SetPersistentVariable(persistentVarName, customGroupState);
}
}
}
else
{
vessel.ActionGroups.ToggleGroup(kspAction);
}
// Now we do extra things that with regular actions can't happen.
switch (customAction)
{
case CustomActions.IntLight:
SetInternalLights(customGroupState);
break;
case CustomActions.Plugin:
actionHandler(customGroupState);
break;
case CustomActions.Stage:
if (InputLockManager.IsUnlocked(ControlTypes.STAGING))
{
StageManager.ActivateNextStage();
}
break;
case CustomActions.TransferToPersistent:
if (stateVariableValid)
{
// stateVariable can disable the button functionality.
int ivalue = comp.ProcessVariable(stateVariable).MassageToInt();
if (ivalue < 1)
{
return; // early - button disabled
}
}
float getValue = comp.ProcessVariable(transferGetter).MassageToFloat();
comp.SetPersistentVariable(transferPersistentName, getValue);
break;
case CustomActions.TransferFromPersistent:
if (stateVariableValid)
{
// stateVariable can disable the button functionality.
int ivalue = comp.ProcessVariable(stateVariable).MassageToInt();
if (ivalue < 1)
{
return; // early - button disabled
}
}
if (comp.HasPersistentVariable(transferPersistentName))
{
transferSetter(comp.GetPersistentVariable(transferPersistentName, 0.0).MassageToDouble());
}
break;
case CustomActions.TransferFromVariable:
if (stateVariableValid)
{
// stateVariable can disable the button functionality.
int ivalue = comp.ProcessVariable(stateVariable).MassageToInt();
if (ivalue < 1)
{
return; // early - button disabled
}
}
double xferValue = comp.ProcessVariable(transferGetter).MassageToDouble();
transferSetter(xferValue);
break;
case CustomActions.Transfer:
JUtil.LogInfo(this, "The deprecated CustomActions.Transfer path was executed");
/*if (stateVariableValid)
* {
* // stateVariable can disable the button functionality.
* int ivalue = comp.ProcessVariable(stateVariable).MassageToInt();
* if (ivalue < 1)
* {
* return; // early - button disabled
* }
* }
* if (!string.IsNullOrEmpty(transferGetter))
* {
* float value = comp.ProcessVariable(transferGetter).MassageToFloat();
* comp.SetPersistentVariable(transferPersistentName, value);
* }
* else if (comp.HasPersistentVariable(transferPersistentName))
* {
* transferSetter(comp.GetPersistentVariable(transferPersistentName, 0.0).MassageToDouble());
* }*/
break;
}
}
public void Start()
{
if (HighLogic.LoadedSceneIsEditor)
{
return;
}
try
{
RPMVesselComputer comp = RPMVesselComputer.Instance(vessel);
if (!groupList.ContainsKey(actionName) && !customGroupList.ContainsKey(actionName))
{
JUtil.LogErrorMessage(this, "Action \"{0}\" is not supported.", actionName);
return;
}
// Parse the needs-electric-charge here.
if (!string.IsNullOrEmpty(needsElectricCharge))
{
switch (needsElectricCharge.ToLowerInvariant().Trim())
{
case "true":
case "yes":
case "1":
needsElectricChargeValue = true;
break;
case "false":
case "no":
case "0":
needsElectricChargeValue = false;
break;
}
}
// Now parse consumeOnToggle and consumeWhileActive...
if (!string.IsNullOrEmpty(consumeOnToggle))
{
string[] tokens = consumeOnToggle.Split(',');
if (tokens.Length == 3)
{
consumeOnToggleName = tokens[0].Trim();
if (!(PartResourceLibrary.Instance.GetDefinition(consumeOnToggleName) != null &&
float.TryParse(tokens[1].Trim(), NumberStyles.Any, CultureInfo.InvariantCulture,
out consumeOnToggleAmount)))
{
JUtil.LogErrorMessage(this, "Could not parse \"{0}\"", consumeOnToggle);
}
switch (tokens[2].Trim().ToLower())
{
case "on":
consumingOnToggleUp = true;
break;
case "off":
consumingOnToggleDown = true;
break;
case "both":
consumingOnToggleUp = true;
consumingOnToggleDown = true;
break;
default:
JUtil.LogErrorMessage(this, "So should I consume resources when turning on, turning off, or both in \"{0}\"?", consumeOnToggle);
break;
}
}
}
if (!string.IsNullOrEmpty(consumeWhileActive))
{
string[] tokens = consumeWhileActive.Split(',');
if (tokens.Length == 2)
{
consumeWhileActiveName = tokens[0].Trim();
if (!(PartResourceLibrary.Instance.GetDefinition(consumeWhileActiveName) != null &&
float.TryParse(tokens[1].Trim(),
NumberStyles.Any, CultureInfo.InvariantCulture,
out consumeWhileActiveAmount)))
{
JUtil.LogErrorMessage(this, "Could not parse \"{0}\"", consumeWhileActive);
}
else
{
consumingWhileActive = true;
JUtil.LogMessage(this, "Switch in prop {0} prop id {1} will consume {2} while active at a rate of {3}", internalProp.propName,
internalProp.propID, consumeWhileActiveName, consumeWhileActiveAmount);
}
}
}
if (groupList.ContainsKey(actionName))
{
kspAction = groupList[actionName];
currentState = vessel.ActionGroups[kspAction];
// action group switches may not belong to a radio group
switchGroupIdentifier = -1;
}
else
{
isCustomAction = true;
switch (actionName)
{
case "intlight":
persistentVarName = internalLightName;
if (!string.IsNullOrEmpty(internalLightName))
{
Light[] availableLights = internalModel.FindModelComponents <Light>();
if (availableLights != null && availableLights.Length > 0)
{
List <Light> lights = new List <Light>(availableLights);
for (int i = lights.Count - 1; i >= 0; --i)
{
if (lights[i].name != internalLightName)
{
lights.RemoveAt(i);
}
}
if (lights.Count > 0)
{
lightObjects = lights.ToArray();
needsElectricChargeValue |= string.IsNullOrEmpty(needsElectricCharge) || needsElectricChargeValue;
}
else
{
actionName = "dummy";
}
}
}
else
{
actionName = "dummy";
}
break;
case "plugin":
persistentVarName = string.Empty;
comp.UpdateDataRefreshRate(refreshRate);
foreach (ConfigNode node in GameDatabase.Instance.GetConfigNodes("PROP"))
{
if (node.GetValue("name") == internalProp.propName)
{
foreach (ConfigNode pluginConfig in node.GetNodes("MODULE")[moduleID].GetNodes("PLUGINACTION"))
{
if (pluginConfig.HasValue("name") && pluginConfig.HasValue("actionMethod"))
{
string action = pluginConfig.GetValue("name").Trim() + ":" + pluginConfig.GetValue("actionMethod").Trim();
actionHandler = (Action <bool>)comp.GetMethod(action, internalProp, typeof(Action <bool>));
if (actionHandler == null)
{
JUtil.LogErrorMessage(this, "Failed to instantiate action handler {0}", action);
}
else
{
if (pluginConfig.HasValue("stateMethod"))
{
string state = pluginConfig.GetValue("name").Trim() + ":" + pluginConfig.GetValue("stateMethod").Trim();
stateVariable = "PLUGIN_" + state;
stateVariableValid = true;
}
else if (pluginConfig.HasValue("stateVariable"))
{
stateVariable = pluginConfig.GetValue("stateVariable").Trim();
stateVariableValid = true;
}
isPluginAction = true;
break;
}
}
}
}
}
if (actionHandler == null)
{
actionName = "dummy";
JUtil.LogMessage(this, "Plugin handlers did not start, reverting to dummy mode.");
}
break;
case "transfer":
persistentVarName = string.Empty;
comp.UpdateDataRefreshRate(refreshRate);
foreach (ConfigNode node in GameDatabase.Instance.GetConfigNodes("PROP"))
{
if (node.GetValue("name") == internalProp.propName)
{
foreach (ConfigNode pluginConfig in node.GetNodes("MODULE")[moduleID].GetNodes("TRANSFERACTION"))
{
if (pluginConfig.HasValue("name") || pluginConfig.HasValue("getVariable"))
{
if (pluginConfig.HasValue("stateMethod"))
{
string state = pluginConfig.GetValue("name").Trim() + ":" + pluginConfig.GetValue("stateMethod").Trim();
stateVariable = "PLUGIN_" + state;
stateVariableValid = true;
}
else if (pluginConfig.HasValue("stateVariable"))
{
stateVariable = pluginConfig.GetValue("stateVariable").Trim();
stateVariableValid = true;
}
if (pluginConfig.HasValue("setMethod"))
{
string action = pluginConfig.GetValue("name").Trim() + ":" + pluginConfig.GetValue("setMethod").Trim();
transferSetter = (Action <double>)comp.GetMethod(action, internalProp, typeof(Action <double>));
if (transferSetter == null)
{
JUtil.LogErrorMessage(this, "Failed to instantiate transfer handler {0}", pluginConfig.GetValue("name"));
}
else if (pluginConfig.HasValue("perPodPersistenceName"))
{
transferPersistentName = pluginConfig.GetValue("perPodPersistenceName").Trim();
actionName = "transferFromPersistent";
customAction = CustomActions.TransferFromPersistent;
}
else if (pluginConfig.HasValue("getVariable"))
{
transferGetter = pluginConfig.GetValue("getVariable").Trim();
actionName = "transferFromVariable";
customAction = CustomActions.TransferFromVariable;
}
else
{
JUtil.LogErrorMessage(this, "Unable to configure transfer setter method in {0} - no perPodPersistenceName or getVariable", internalProp.name);
transferSetter = null;
//JUtil.LogMessage(this, "Got setter {0}", action);
}
}
else if (pluginConfig.HasValue("getMethod"))
{
if (pluginConfig.HasValue("perPodPersistenceName"))
{
string action = pluginConfig.GetValue("name").Trim() + ":" + pluginConfig.GetValue("getMethod").Trim();
var getter = (Func <double>)comp.GetMethod(action, internalProp, typeof(Func <double>));
if (getter == null)
{
JUtil.LogErrorMessage(this, "Failed to instantiate transfer handler {0} in {1}", pluginConfig.GetValue("name"), internalProp.name);
}
else
{
transferGetter = "PLUGIN_" + action;
transferPersistentName = pluginConfig.GetValue("perPodPersistenceName").Trim();
actionName = "transferToPersistent";
customAction = CustomActions.TransferToPersistent;
//JUtil.LogMessage(this, "Got getter {0}", action);
break;
}
}
else
{
JUtil.LogErrorMessage(this, "Transfer handler in {0} configured with 'getVariable', but no 'perPodPeristenceName'", internalProp.name);
}
}
else if (pluginConfig.HasValue("getVariable"))
{
if (pluginConfig.HasValue("perPodPersistenceName"))
{
transferGetter = pluginConfig.GetValue("getVariable").Trim();
transferPersistentName = pluginConfig.GetValue("perPodPersistenceName").Trim();
actionName = "transferToPersistent";
customAction = CustomActions.TransferToPersistent;
}
else
{
JUtil.LogErrorMessage(this, "Transfer handler in {0} configured with 'getVariable', but no 'perPodPeristenceName'", internalProp.name);
}
}
}
}
}
}
if (string.IsNullOrEmpty(transferGetter) && transferSetter == null)
{
actionName = "dummy";
stateVariable = string.Empty;
stateVariableValid = false;
JUtil.LogMessage(this, "Transfer handlers did not start, reverting to dummy mode.");
}
break;
default:
persistentVarName = "switch" + internalProp.propID + "_" + moduleID;
break;
}
if (!string.IsNullOrEmpty(perPodPersistenceName))
{
persistentVarName = perPodPersistenceName;
}
else
{
// If there's no persistence name, there's no valid group id for this switch
switchGroupIdentifier = -1;
}
persistentVarValid = !string.IsNullOrEmpty(persistentVarName);
}
perPodPersistenceValid = !string.IsNullOrEmpty(perPodPersistenceName);
if (customGroupList.ContainsKey(actionName))
{
customAction = customGroupList[actionName];
}
if (needsElectricChargeValue || persistentVarValid || !string.IsNullOrEmpty(perPodMasterSwitchName) || !string.IsNullOrEmpty(masterVariableName) ||
!string.IsNullOrEmpty(transferGetter) || transferSetter != null)
{
comp.UpdateDataRefreshRate(refreshRate);
if (!string.IsNullOrEmpty(masterVariableName))
{
string[] range = masterVariableRange.Split(',');
if (range.Length == 2)
{
masterVariable = new VariableOrNumberRange(masterVariableName, range[0], range[1]);
}
else
{
masterVariable = null;
}
}
}
// set up the toggle switch
if (!string.IsNullOrEmpty(switchTransform))
{
if (momentarySwitch)
{
SmarterButton.CreateButton(internalProp, switchTransform, Click, Click);
}
else
{
SmarterButton.CreateButton(internalProp, switchTransform, Click);
}
}
if (isCustomAction)
{
if (isPluginAction && stateVariableValid)
{
try
{
currentState = (comp.ProcessVariable(stateVariable).MassageToInt()) > 0;
}
catch
{
// no-op
}
}
else
{
if (persistentVarValid)
{
if (switchGroupIdentifier >= 0)
{
int activeSwitch = comp.GetPersistentVariable(persistentVarName, 0).MassageToInt();
currentState = customGroupState = (switchGroupIdentifier == activeSwitch);
}
else
{
currentState = customGroupState = comp.GetPersistentVariable(persistentVarName, initialState);
}
if (customAction == CustomActions.IntLight)
{
// We have to restore lighting after reading the
// persistent variable.
SetInternalLights(customGroupState);
}
}
}
}
if (persistentVarValid && !comp.HasPersistentVariable(persistentVarName))
{
if (switchGroupIdentifier >= 0)
{
if (currentState)
{
comp.SetPersistentVariable(persistentVarName, switchGroupIdentifier);
}
}
else
{
comp.SetPersistentVariable(persistentVarName, currentState);
}
}
if (!string.IsNullOrEmpty(animationName))
{
// Set up the animation
Animation[] animators = animateExterior ? part.FindModelAnimators(animationName) : internalProp.FindModelAnimators(animationName);
if (animators.Length > 0)
{
anim = animators[0];
}
else
{
JUtil.LogErrorMessage(this, "Could not find animation \"{0}\" on {2} \"{1}\"",
animationName, animateExterior ? part.name : internalProp.name, animateExterior ? "part" : "prop");
return;
}
anim[animationName].wrapMode = WrapMode.Once;
if (currentState ^ reverse)
{
anim[animationName].speed = float.MaxValue;
anim[animationName].normalizedTime = 0;
}
else
{
anim[animationName].speed = float.MinValue;
anim[animationName].normalizedTime = 1;
}
anim.Play(animationName);
}
else if (!string.IsNullOrEmpty(coloredObject))
{
// Set up the color shift.
Renderer colorShiftRenderer = internalProp.FindModelComponent <Renderer>(coloredObject);
disabledColorValue = ConfigNode.ParseColor32(disabledColor);
enabledColorValue = ConfigNode.ParseColor32(enabledColor);
colorShiftMaterial = colorShiftRenderer.material;
colorShiftMaterial.SetColor(colorName, (currentState ^ reverse ? enabledColorValue : disabledColorValue));
}
else
{
JUtil.LogMessage(this, "Warning, neither color nor animation are defined in prop {0} #{1} (this may be okay).", internalProp.propName, internalProp.propID);
}
audioOutput = JUtil.SetupIVASound(internalProp, switchSound, switchSoundVolume, false);
if (!string.IsNullOrEmpty(loopingSound) && loopingSoundVolume > 0.0f)
{
loopingOutput = JUtil.SetupIVASound(internalProp, loopingSound, loopingSoundVolume, true);
}
perPodMasterSwitchValid = !string.IsNullOrEmpty(perPodMasterSwitchName);
JUtil.LogMessage(this, "Configuration complete in prop {0} ({1}).", internalProp.propID, internalProp.propName);
startupComplete = true;
}
catch
{
JUtil.AnnoyUser(this);
enabled = false;
throw;
}
}
public override void OnUpdate()
{
if (enabled && JUtil.VesselIsInIVA(vessel))
{
//JUtil.LogMessage(this, "OnUpdate()");
double time = Planetarium.GetUniversalTime();
float change = 0.0f;
for (int i = 0; i < numericInputs.Count; ++i)
{
change += numericInputs[i].Update(time);
}
if (change < 0.0f || change > 0.0f)
{
RPMVesselComputer comp = RPMVesselComputer.Instance(vessel);
float val = comp.GetPersistentVariable(perPodPersistenceName, 0.0f).MassageToFloat();
val += change + remainder;
if (minRange != null)
{
float v;
if (minRange.Get(out v, comp))
{
if (loopInput)
{
if (val < v)
{
if (maxRange.Get(out v, comp))
{
val = v;
}
}
}
else
{
val = Mathf.Max(val, v);
}
}
}
if (maxRange != null)
{
float v;
if (maxRange.Get(out v, comp))
{
if (loopInput)
{
if (val > v)
{
if (minRange.Get(out v, comp))
{
val = v;
}
}
}
else
{
val = Mathf.Min(val, v);
}
}
}
if (stepSize > 0.0f)
{
remainder = val % stepSize;
//JUtil.LogMessage(this, "Adjusting {0} to {1} due to stepSize {2}, (remainder {3})",
// val, val-remainder, stepSize, remainder);
val -= remainder;
}
comp.SetPersistentVariable(perPodPersistenceName, val);
}
else
{
remainder = 0.0f;
}
}
else
{
remainder = 0.0f;
}
}
public void Start()
{
// If we're not in the correct location, there's no point doing anything.
if (!InstallationPathWarning.Warn())
{
return;
}
if (HighLogic.LoadedSceneIsEditor)
{
return;
}
try
{
// Install the calculator module.
RPMVesselComputer comp = RPMVesselComputer.Instance(vessel);
comp.UpdateDataRefreshRate(refreshDataRate);
// Loading the font...
List <Texture2D> fontTexture = new List <Texture2D>();
fontTexture.Add(LoadFont(this, internalProp, fontTransform));
// Damn KSP's config parser!!!
if (!string.IsNullOrEmpty(emptyColor))
{
emptyColorValue = ConfigNode.ParseColor32(emptyColor);
}
if (!string.IsNullOrEmpty(defaultFontTint))
{
defaultFontTintValue = ConfigNode.ParseColor32(defaultFontTint);
}
if (!string.IsNullOrEmpty(fontDefinition))
{
JUtil.LogMessage(this, "Loading font definition from {0}", fontDefinition);
fontDefinitionString = File.ReadAllLines(KSPUtil.ApplicationRootPath + "GameData/" + fontDefinition.EnforceSlashes(), Encoding.UTF8)[0];
}
// Now that is done, proceed to setting up the screen.
screenTexture = new RenderTexture(screenPixelWidth, screenPixelHeight, 24, RenderTextureFormat.ARGB32);
screenMat = internalProp.FindModelTransform(screenTransform).GetComponent <Renderer>().material;
foreach (string layerID in textureLayerID.Split())
{
screenMat.SetTexture(layerID.Trim(), screenTexture);
}
if (GameDatabase.Instance.ExistsTexture(noSignalTextureURL.EnforceSlashes()))
{
noSignalTexture = GameDatabase.Instance.GetTexture(noSignalTextureURL.EnforceSlashes(), false);
}
// Create camera instance...
cameraStructure = new FlyingCamera(part, screenTexture, cameraAspect);
// The neat trick. IConfigNode doesn't work. No amount of kicking got it to work.
// Well, we don't need it. GameDatabase, gimme config nodes for all props!
foreach (ConfigNode node in GameDatabase.Instance.GetConfigNodes("PROP"))
{
// Now, we know our own prop name.
if (node.GetValue("name") == internalProp.propName)
{
// So this is the configuration of our prop in memory. Nice place.
// We know it contains at least one MODULE node, us.
// And we know our moduleID, which is the number in order of being listed in the prop.
// Therefore the module by that number is our module's own config node.
ConfigNode moduleConfig = node.GetNodes("MODULE")[moduleID];
ConfigNode[] pageNodes = moduleConfig.GetNodes("PAGE");
// Which we can now parse for page definitions.
for (int i = 0; i < pageNodes.Length; i++)
{
// Mwahahaha.
try
{
var newPage = new MonitorPage(i, pageNodes[i], this);
activePage = activePage ?? newPage;
if (newPage.isDefault)
{
activePage = newPage;
}
pages.Add(newPage);
}
catch (ArgumentException e)
{
JUtil.LogMessage(this, "Warning - {0}", e);
}
}
// Now that all pages are loaded, we can use the moment in the loop to suck in all the extra fonts.
foreach (string value in moduleConfig.GetValues("extraFont"))
{
fontTexture.Add(LoadFont(this, internalProp, value));
}
break;
}
}
JUtil.LogMessage(this, "Done setting up pages, {0} pages ready.", pages.Count);
textRenderer = new TextRenderer(fontTexture, new Vector2((float)fontLetterWidth, (float)fontLetterHeight), fontDefinitionString, 17, screenPixelWidth, screenPixelHeight);
// Load our state from storage...
persistentVarName = "activePage" + internalProp.propID;
int activePageID = comp.GetPersistentVariable(persistentVarName, pages.Count).MassageToInt();
if (activePageID < pages.Count)
{
activePage = pages[activePageID];
}
activePage.Active(true);
// If we have global buttons, set them up.
if (!string.IsNullOrEmpty(globalButtons))
{
string[] tokens = globalButtons.Split(',');
for (int i = 0; i < tokens.Length; i++)
{
string buttonName = tokens[i].Trim();
// Notice that holes in the global button list ARE legal.
if (!string.IsNullOrEmpty(buttonName))
{
SmarterButton.CreateButton(internalProp, buttonName, i, GlobalButtonClick, GlobalButtonRelease);
}
}
}
audioOutput = JUtil.SetupIVASound(internalProp, buttonClickSound, buttonClickVolume, false);
// One last thing to make sure of: If our pod is transparent, we're always active.
#if ENABLE_TP
ourPodIsTransparent = JUtil.IsPodTransparent(part);
#endif
// And if the try block never completed, startupComplete will never be true.
startupComplete = true;
}
catch
{
JUtil.AnnoyUser(this);
startupFailed = true;
// We can also disable ourselves, that should help.
enabled = false;
// And now that we notified the user that config is borked, we rethrow the exception so that
// it gets logged and we can debug.
throw;
}
}
public void Start()
{
if (!HighLogic.LoadedSceneIsFlight)
{
return;
}
// Grrrrrr.
if (!string.IsNullOrEmpty(nameColor))
{
nameColorValue = ConfigNode.ParseColor32(nameColor);
}
if (!string.IsNullOrEmpty(distanceColor))
{
distanceColorValue = ConfigNode.ParseColor32(distanceColor);
}
if (!string.IsNullOrEmpty(selectedColor))
{
selectedColorValue = ConfigNode.ParseColor32(selectedColor);
}
if (!string.IsNullOrEmpty(unavailableColor))
{
unavailableColorValue = ConfigNode.ParseColor32(unavailableColor);
}
persistentVarName = "targetfilter" + internalProp.propID;
RPMVesselComputer comp = RPMVesselComputer.Instance(vessel);
// 7 is the bitmask for ship-station-probe;
VesselFilterFromBitmask(comp.GetPersistentVariable(persistentVarName, defaultFilter).MassageToInt());
nameColorTag = JUtil.ColorToColorTag(nameColorValue);
distanceColorTag = JUtil.ColorToColorTag(distanceColorValue);
selectedColorTag = JUtil.ColorToColorTag(selectedColorValue);
unavailableColorTag = JUtil.ColorToColorTag(unavailableColorValue);
distanceFormatString = distanceFormatString.UnMangleConfigText();
menuTitleFormatString = menuTitleFormatString.UnMangleConfigText();
topMenu.labelColor = nameColorTag;
topMenu.selectedColor = selectedColorTag;
topMenu.disabledColor = unavailableColorTag;
if (!string.IsNullOrEmpty(pageTitle))
{
pageTitle = pageTitle.UnMangleConfigText();
}
foreach (CelestialBody body in FlightGlobals.Bodies)
{
celestialsList.Add(new Celestial(body, vessel.transform.position));
}
FindReferencePoints();
UpdateUndockablesList();
var menuActions = new List <Action <int, TextMenu.Item> >();
menuActions.Add(ShowCelestialMenu);
menuActions.Add(ShowVesselMenu);
menuActions.Add(ShowSpaceObjectMenu);
menuActions.Add(ShowReferenceMenu);
menuActions.Add(ShowUndockMenu);
menuActions.Add(ArmGrapple);
menuActions.Add(ShowFiltersMenu);
menuActions.Add(ClearTarget);
for (int i = 0; i < rootMenu.Count; ++i)
{
var menuitem = new TextMenu.Item();
menuitem.labelText = rootMenu[i];
menuitem.action = menuActions[i];
topMenu.Add(menuitem);
switch (menuitem.labelText)
{
case clearTargetItemText:
clearTarget = topMenu[i];
break;
case undockItemText:
undockMenuItem = topMenu[i];
break;
case armGrappleText:
grappleMenuItem = topMenu[i];
break;
}
}
activeMenu = topMenu;
}