public VariableLabelSet(ConfigNode node, Part part)
{
RasterPropMonitorComputer rpmComp = null;
if (node.HasValue("labelText"))
{
string labelText = node.GetValue("labelText").Trim().UnMangleConfigText();
hasText = true;
oneShot = !labelText.Contains("$&$");
rpmComp = RasterPropMonitorComputer.Instantiate(part, true);
label = new StringProcessorFormatter(labelText, rpmComp);
}
else
{
hasText = false;
oneShot = true;
}
if (node.HasValue("color"))
{
color = JUtil.ParseColor32(node.GetValue("color").Trim(), part, ref rpmComp);
hasColor = true;
}
else
{
hasColor = false;
}
}
public void Start()
{
if (HighLogic.LoadedSceneIsEditor)
{
return;
}
try
{
rpmComp = RasterPropMonitorComputer.Instantiate(internalProp, true);
Transform textObjTransform = internalProp.FindModelTransform(transformName);
textObj = InternalComponents.Instance.CreateText("Arial", fontSize * 15.5f, textObjTransform, "", Color.green, false, "TopLeft");
// Force oneshot if there's no variables:
oneshot |= !labelText.Contains("$&$");
string sourceString = labelText.UnMangleConfigText();
if (!string.IsNullOrEmpty(sourceString) && sourceString.Length > 1)
{
// Alow a " character to escape leading whitespace
if (sourceString[0] == '"')
{
sourceString = sourceString.Substring(1);
}
}
spf = new StringProcessorFormatter(sourceString, rpmComp);
if (!oneshot)
{
rpmComp.UpdateDataRefreshRate(refreshRate);
}
if (!(string.IsNullOrEmpty(variableName) || string.IsNullOrEmpty(positiveColor) || string.IsNullOrEmpty(negativeColor) || string.IsNullOrEmpty(zeroColor)))
{
positiveColorValue = JUtil.ParseColor32(positiveColor, part, ref rpmComp);
negativeColorValue = JUtil.ParseColor32(negativeColor, part, ref rpmComp);
zeroColorValue = JUtil.ParseColor32(zeroColor, part, ref rpmComp);
del = (Action <float>)Delegate.CreateDelegate(typeof(Action <float>), this, "OnCallback");
rpmComp.RegisterVariableCallback(variableName, del);
registeredVessel = vessel.id;
// Initialize the text color. Actually, callback registration took care of that
}
}
catch (Exception e)
{
JUtil.LogErrorMessage(this, "Start failed with exception {0}", e);
spf = new StringProcessorFormatter("x", rpmComp);
}
}
/// <summary>
/// Start everything up and get it configured.
/// </summary>
public void Start()
{
try
{
rpmComp = RasterPropMonitorComputer.Instantiate(internalProp, true);
Transform textObjTransform = internalProp.FindModelTransform(transformName);
Vector3 localScale = internalProp.transform.localScale;
Transform offsetTransform = new GameObject().transform;
offsetTransform.gameObject.name = "JSILabel-" + this.internalProp.propID + "-" + this.GetHashCode().ToString();
offsetTransform.gameObject.layer = textObjTransform.gameObject.layer;
offsetTransform.SetParent(textObjTransform, false);
offsetTransform.Translate(transformOffset.x * localScale.x, transformOffset.y * localScale.y, 0.0f);
textObj = offsetTransform.gameObject.AddComponent <JSITextMesh>();
font = JUtil.LoadFont(fontName, fontQuality);
textObj.font = font;
//textObj.fontSize = fontQuality; // This doesn't work with Unity-embedded fonts
textObj.fontSize = font.fontSize;
if (!string.IsNullOrEmpty(anchor))
{
if (anchor == TextAnchor.LowerCenter.ToString())
{
textObj.anchor = TextAnchor.LowerCenter;
}
else if (anchor == TextAnchor.LowerLeft.ToString())
{
textObj.anchor = TextAnchor.LowerLeft;
}
else if (anchor == TextAnchor.LowerRight.ToString())
{
textObj.anchor = TextAnchor.LowerRight;
}
else if (anchor == TextAnchor.MiddleCenter.ToString())
{
textObj.anchor = TextAnchor.MiddleCenter;
}
else if (anchor == TextAnchor.MiddleLeft.ToString())
{
textObj.anchor = TextAnchor.MiddleLeft;
}
else if (anchor == TextAnchor.MiddleRight.ToString())
{
textObj.anchor = TextAnchor.MiddleRight;
}
else if (anchor == TextAnchor.UpperCenter.ToString())
{
textObj.anchor = TextAnchor.UpperCenter;
}
else if (anchor == TextAnchor.UpperLeft.ToString())
{
textObj.anchor = TextAnchor.UpperLeft;
}
else if (anchor == TextAnchor.UpperRight.ToString())
{
textObj.anchor = TextAnchor.UpperRight;
}
else
{
JUtil.LogErrorMessage(this, "Unrecognized anchor '{0}' in config for {1} ({2})", anchor, internalProp.propID, internalProp.propName);
}
}
if (!string.IsNullOrEmpty(alignment))
{
if (alignment == TextAlignment.Center.ToString())
{
textObj.alignment = TextAlignment.Center;
}
else if (alignment == TextAlignment.Left.ToString())
{
textObj.alignment = TextAlignment.Left;
}
else if (alignment == TextAlignment.Right.ToString())
{
textObj.alignment = TextAlignment.Right;
}
else
{
JUtil.LogErrorMessage(this, "Unrecognized alignment '{0}' in config for {1} ({2})", alignment, internalProp.propID, internalProp.propName);
}
}
float sizeScalar = 32.0f / (float)font.fontSize;
textObj.characterSize = fontSize * 0.00005f * sizeScalar;
textObj.lineSpacing = textObj.lineSpacing * lineSpacing;
// "Normal" mode
if (string.IsNullOrEmpty(switchTransform))
{
// Force oneshot if there's no variables:
oneshot |= !labelText.Contains("$&$");
string sourceString = labelText.UnMangleConfigText();
if (!string.IsNullOrEmpty(sourceString) && sourceString.Length > 1)
{
// Alow a " character to escape leading whitespace
if (sourceString[0] == '"')
{
sourceString = sourceString.Substring(1);
}
}
labels.Add(new JSILabelSet(sourceString, rpmComp, oneshot));
if (!oneshot)
{
rpmComp.UpdateDataRefreshRate(refreshRate);
}
}
else // Switchable mode
{
SmarterButton.CreateButton(internalProp, switchTransform, Click);
audioOutput = JUtil.SetupIVASound(internalProp, switchSound, switchSoundVolume, false);
foreach (ConfigNode node in GameDatabase.Instance.GetConfigNodes("PROP"))
{
if (node.GetValue("name") == internalProp.propName)
{
ConfigNode moduleConfig = node.GetNodes("MODULE")[moduleID];
ConfigNode[] variableNodes = moduleConfig.GetNodes("VARIABLESET");
for (int i = 0; i < variableNodes.Length; i++)
{
try
{
bool lOneshot = false;
if (variableNodes[i].HasValue("oneshot"))
{
bool.TryParse(variableNodes[i].GetValue("oneshot"), out lOneshot);
}
if (variableNodes[i].HasValue("labelText"))
{
string lText = variableNodes[i].GetValue("labelText");
string sourceString = lText.UnMangleConfigText();
lOneshot |= !lText.Contains("$&$");
labels.Add(new JSILabelSet(sourceString, rpmComp, lOneshot));
if (!lOneshot)
{
rpmComp.UpdateDataRefreshRate(refreshRate);
}
}
}
catch (ArgumentException e)
{
JUtil.LogErrorMessage(this, "Error in building prop number {1} - {0}", e.Message, internalProp.propID);
}
}
break;
}
}
}
if (!string.IsNullOrEmpty(zeroColor))
{
zeroColorValue = JUtil.ParseColor32(zeroColor, part, ref rpmComp);
textObj.color = zeroColorValue;
}
bool usesMultiColor = false;
if (!(string.IsNullOrEmpty(variableName) || string.IsNullOrEmpty(positiveColor) || string.IsNullOrEmpty(negativeColor) || string.IsNullOrEmpty(zeroColor)))
{
usesMultiColor = true;
positiveColorValue = JUtil.ParseColor32(positiveColor, part, ref rpmComp);
negativeColorValue = JUtil.ParseColor32(negativeColor, part, ref rpmComp);
del = (Action <float>)Delegate.CreateDelegate(typeof(Action <float>), this, "OnCallback");
rpmComp.RegisterVariableCallback(variableName, del);
registeredVessel = vessel.id;
// Initialize the text color. Actually, callback registration takes care of that.
}
if (string.IsNullOrEmpty(emissive))
{
if (usesMultiColor)
{
emissiveMode = EmissiveMode.active;
}
else
{
emissiveMode = EmissiveMode.always;
}
}
else if (emissive.ToLower() == EmissiveMode.always.ToString())
{
emissiveMode = EmissiveMode.always;
}
else if (emissive.ToLower() == EmissiveMode.never.ToString())
{
emissiveMode = EmissiveMode.never;
}
else if (emissive.ToLower() == EmissiveMode.active.ToString())
{
emissiveMode = EmissiveMode.active;
}
else if (emissive.ToLower() == EmissiveMode.passive.ToString())
{
emissiveMode = EmissiveMode.passive;
}
else if (emissive.ToLower() == EmissiveMode.flash.ToString())
{
if (flashRate > 0.0f)
{
emissiveMode = EmissiveMode.flash;
fm = JUtil.InstallFlashModule(part, flashRate);
if (fm != null)
{
fm.flashSubscribers += FlashToggle;
}
}
else
{
emissiveMode = EmissiveMode.active;
}
}
else
{
JUtil.LogErrorMessage(this, "Unrecognized emissive mode '{0}' in config for {1} ({2})", emissive, internalProp.propID, internalProp.propName);
emissiveMode = EmissiveMode.always;
}
UpdateShader();
}
catch (Exception e)
{
JUtil.LogErrorMessage(this, "Start failed in prop {1} ({2}) with exception {0}", e, internalProp.propID, internalProp.propName);
labels.Add(new JSILabelSet("ERR", rpmComp, true));
}
}
public void Start()
{
if (HighLogic.LoadedSceneIsEditor)
{
return;
}
try
{
rpmComp = RasterPropMonitorComputer.Instantiate(internalProp, true);
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;
rpmComp.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>)rpmComp.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 = rpmComp.InstantiateVariableOrNumber("PLUGIN_" + state);
}
else if (pluginConfig.HasValue("stateVariable"))
{
stateVariable = rpmComp.InstantiateVariableOrNumber(pluginConfig.GetValue("stateVariable").Trim());
}
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;
rpmComp.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 = rpmComp.InstantiateVariableOrNumber("PLUGIN_" + state);
}
else if (pluginConfig.HasValue("stateVariable"))
{
stateVariable = rpmComp.InstantiateVariableOrNumber(pluginConfig.GetValue("stateVariable").Trim());
}
if (pluginConfig.HasValue("setMethod"))
{
string action = pluginConfig.GetValue("name").Trim() + ":" + pluginConfig.GetValue("setMethod").Trim();
transferSetter = (Action <double>)rpmComp.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 = rpmComp.InstantiateVariableOrNumber(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>)rpmComp.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 = rpmComp.InstantiateVariableOrNumber("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 = rpmComp.InstantiateVariableOrNumber(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 (transferGetter == null && transferSetter == null)
{
actionName = "dummy";
stateVariable = null;
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) ||
transferGetter != null || transferSetter != null)
{
rpmComp.UpdateDataRefreshRate(refreshRate);
if (!string.IsNullOrEmpty(masterVariableName))
{
string[] range = masterVariableRange.Split(',');
if (range.Length == 2)
{
masterVariable = new VariableOrNumberRange(rpmComp, masterVariableName, range[0], range[1]);
}
else
{
masterVariable = null;
}
}
}
if (needsElectricChargeValue)
{
del = (Action <bool>)Delegate.CreateDelegate(typeof(Action <bool>), this, "ResourceDepletedCallback");
rpmComp.RegisterResourceCallback(resourceName, del);
}
// 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 && stateVariable != null)
{
currentState = stateVariable.AsInt() > 0;
}
else
{
if (persistentVarValid)
{
if (switchGroupIdentifier >= 0)
{
int activeSwitch = rpmComp.GetPersistentVariable(persistentVarName, 0, perPodPersistenceIsGlobal).MassageToInt();
currentState = customGroupState = (switchGroupIdentifier == activeSwitch);
}
else
{
currentState = customGroupState = rpmComp.GetPersistentVariable(persistentVarName, initialState, perPodPersistenceIsGlobal);
}
if (customAction == CustomActions.IntLight)
{
// We have to restore lighting after reading the
// persistent variable.
SetInternalLights(customGroupState);
}
}
}
}
if (persistentVarValid && !rpmComp.HasPersistentVariable(persistentVarName, perPodPersistenceIsGlobal))
{
if (switchGroupIdentifier >= 0)
{
if (currentState)
{
rpmComp.SetPersistentVariable(persistentVarName, switchGroupIdentifier, perPodPersistenceIsGlobal);
}
}
else
{
rpmComp.SetPersistentVariable(persistentVarName, currentState, perPodPersistenceIsGlobal);
}
}
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 = JUtil.ParseColor32(disabledColor, part, ref rpmComp);
enabledColorValue = JUtil.ParseColor32(enabledColor, part, ref rpmComp);
colorShiftMaterial = colorShiftRenderer.material;
colorNameId = Shader.PropertyToID(colorName);
colorShiftMaterial.SetColor(colorNameId, (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 (Exception e)
{
JUtil.LogErrorMessage(this, "Exception configuring prop {0} ({1}): {2}", internalProp.propID, internalProp.propName, e);
JUtil.AnnoyUser(this);
enabled = false;
}
}
/// <summary>
/// Initialize and configure the callback handler.
/// </summary>
/// <param name="node"></param>
/// <param name="variableName"></param>
/// <param name="thisProp"></param>
public CallbackAnimationSet(ConfigNode node, string variableName, InternalProp thisProp)
{
currentState = false;
if (!node.HasData)
{
throw new ArgumentException("No data?!");
}
string[] tokens = { };
if (node.HasValue("scale"))
{
tokens = node.GetValue("scale").Split(',');
}
if (tokens.Length != 2)
{
throw new ArgumentException("Could not parse 'scale' parameter.");
}
RasterPropMonitorComputer rpmComp = RasterPropMonitorComputer.Instantiate(thisProp, true);
variable = new VariableOrNumberRange(rpmComp, variableName, tokens[0], tokens[1]);
// That takes care of the scale, now what to do about that scale:
if (node.HasValue("reverse"))
{
if (!bool.TryParse(node.GetValue("reverse"), out reverse))
{
throw new ArgumentException("So is 'reverse' true or false?");
}
}
if (node.HasValue("flash"))
{
if (!bool.TryParse(node.GetValue("flash"), out flash))
{
throw new ArgumentException("So is 'reverse' true or false?");
}
}
else
{
flash = false;
}
if (node.HasValue("alarmSound"))
{
alarmSoundVolume = 0.5f;
if (node.HasValue("alarmSoundVolume"))
{
alarmSoundVolume = float.Parse(node.GetValue("alarmSoundVolume"));
}
audioOutput = JUtil.SetupIVASound(thisProp, node.GetValue("alarmSound"), alarmSoundVolume, false);
if (node.HasValue("alarmMustPlayOnce"))
{
if (!bool.TryParse(node.GetValue("alarmMustPlayOnce"), out alarmMustPlayOnce))
{
throw new ArgumentException("So is 'alarmMustPlayOnce' true or false?");
}
}
if (node.HasValue("alarmShutdownButton"))
{
SmarterButton.CreateButton(thisProp, node.GetValue("alarmShutdownButton"), AlarmShutdown);
}
if (node.HasValue("alarmSoundLooping"))
{
if (!bool.TryParse(node.GetValue("alarmSoundLooping"), out alarmSoundLooping))
{
throw new ArgumentException("So is 'alarmSoundLooping' true or false?");
}
audioOutput.audio.loop = alarmSoundLooping;
}
inIVA = (CameraManager.Instance.currentCameraMode == CameraManager.CameraMode.IVA);
GameEvents.OnCameraChange.Add(CameraChangeCallback);
}
if (node.HasValue("animationName"))
{
animationName = node.GetValue("animationName");
if (node.HasValue("animationSpeed"))
{
animationSpeed = float.Parse(node.GetValue("animationSpeed"));
if (reverse)
{
animationSpeed = -animationSpeed;
}
}
else
{
animationSpeed = 0.0f;
}
Animation[] anims = node.HasValue("animateExterior") ? thisProp.part.FindModelAnimators(animationName) : thisProp.FindModelAnimators(animationName);
if (anims.Length > 0)
{
onAnim = anims[0];
onAnim.enabled = true;
onAnim[animationName].speed = 0;
onAnim[animationName].normalizedTime = reverse ? 1f : 0f;
looping = node.HasValue("loopingAnimation");
if (looping)
{
onAnim[animationName].wrapMode = WrapMode.Loop;
onAnim.wrapMode = WrapMode.Loop;
onAnim[animationName].speed = animationSpeed;
mode = Mode.LoopingAnimation;
}
else
{
onAnim[animationName].wrapMode = WrapMode.Once;
mode = Mode.Animation;
}
onAnim.Play();
//alwaysActive = node.HasValue("animateExterior");
}
else
{
throw new ArgumentException("Animation " + animationName + " could not be found.");
}
if (node.HasValue("stopAnimationName"))
{
stopAnimationName = node.GetValue("stopAnimationName");
anims = node.HasValue("animateExterior") ? thisProp.part.FindModelAnimators(stopAnimationName) : thisProp.FindModelAnimators(stopAnimationName);
if (anims.Length > 0)
{
offAnim = anims[0];
offAnim.enabled = true;
offAnim[stopAnimationName].speed = 0;
offAnim[stopAnimationName].normalizedTime = reverse ? 1f : 0f;
if (looping)
{
offAnim[stopAnimationName].wrapMode = WrapMode.Loop;
offAnim.wrapMode = WrapMode.Loop;
offAnim[stopAnimationName].speed = animationSpeed;
mode = Mode.LoopingAnimation;
}
else
{
offAnim[stopAnimationName].wrapMode = WrapMode.Once;
mode = Mode.Animation;
}
}
}
}
else if (node.HasValue("activeColor") && node.HasValue("passiveColor") && node.HasValue("coloredObject"))
{
string colorNameString = "_EmissiveColor";
if (node.HasValue("colorName"))
{
colorNameString = node.GetValue("colorName");
}
colorName = Shader.PropertyToID(colorNameString);
if (reverse)
{
activeColor = JUtil.ParseColor32(node.GetValue("passiveColor"), thisProp.part, ref rpmComp);
passiveColor = JUtil.ParseColor32(node.GetValue("activeColor"), thisProp.part, ref rpmComp);
}
else
{
passiveColor = JUtil.ParseColor32(node.GetValue("passiveColor"), thisProp.part, ref rpmComp);
activeColor = JUtil.ParseColor32(node.GetValue("activeColor"), thisProp.part, ref rpmComp);
}
Renderer colorShiftRenderer = thisProp.FindModelComponent <Renderer>(node.GetValue("coloredObject"));
affectedMaterial = colorShiftRenderer.material;
affectedMaterial.SetColor(colorName, passiveColor);
mode = Mode.Color;
}
else if (node.HasValue("controlledTransform") && node.HasValue("localRotationStart") && node.HasValue("localRotationEnd"))
{
controlledTransform = thisProp.FindModelTransform(node.GetValue("controlledTransform").Trim());
initialRotation = controlledTransform.localRotation;
if (node.HasValue("longPath"))
{
longPath = true;
if (reverse)
{
vectorEnd = ConfigNode.ParseVector3(node.GetValue("localRotationStart"));
vectorStart = ConfigNode.ParseVector3(node.GetValue("localRotationEnd"));
}
else
{
vectorStart = ConfigNode.ParseVector3(node.GetValue("localRotationStart"));
vectorEnd = ConfigNode.ParseVector3(node.GetValue("localRotationEnd"));
}
}
else
{
if (reverse)
{
rotationEnd = Quaternion.Euler(ConfigNode.ParseVector3(node.GetValue("localRotationStart")));
rotationStart = Quaternion.Euler(ConfigNode.ParseVector3(node.GetValue("localRotationEnd")));
}
else
{
rotationStart = Quaternion.Euler(ConfigNode.ParseVector3(node.GetValue("localRotationStart")));
rotationEnd = Quaternion.Euler(ConfigNode.ParseVector3(node.GetValue("localRotationEnd")));
}
}
mode = Mode.Rotation;
}
else if (node.HasValue("controlledTransform") && node.HasValue("localTranslationStart") && node.HasValue("localTranslationEnd"))
{
controlledTransform = thisProp.FindModelTransform(node.GetValue("controlledTransform").Trim());
initialPosition = controlledTransform.localPosition;
if (reverse)
{
vectorEnd = ConfigNode.ParseVector3(node.GetValue("localTranslationStart"));
vectorStart = ConfigNode.ParseVector3(node.GetValue("localTranslationEnd"));
}
else
{
vectorStart = ConfigNode.ParseVector3(node.GetValue("localTranslationStart"));
vectorEnd = ConfigNode.ParseVector3(node.GetValue("localTranslationEnd"));
}
mode = Mode.Translation;
}
else if (node.HasValue("controlledTransform") && node.HasValue("localScaleStart") && node.HasValue("localScaleEnd"))
{
controlledTransform = thisProp.FindModelTransform(node.GetValue("controlledTransform").Trim());
initialScale = controlledTransform.localScale;
if (reverse)
{
vectorEnd = ConfigNode.ParseVector3(node.GetValue("localScaleStart"));
vectorStart = ConfigNode.ParseVector3(node.GetValue("localScaleEnd"));
}
else
{
vectorStart = ConfigNode.ParseVector3(node.GetValue("localScaleStart"));
vectorEnd = ConfigNode.ParseVector3(node.GetValue("localScaleEnd"));
}
mode = Mode.Scale;
}
else if (node.HasValue("controlledTransform") && node.HasValue("textureLayers") && node.HasValue("textureShiftStart") && node.HasValue("textureShiftEnd"))
{
affectedMaterial = thisProp.FindModelTransform(node.GetValue("controlledTransform").Trim()).GetComponent <Renderer>().material;
var textureLayers = node.GetValue("textureLayers").Split(',');
for (int i = 0; i < textureLayers.Length; ++i)
{
textureLayer.Add(textureLayers[i].Trim());
}
if (reverse)
{
textureShiftEnd = ConfigNode.ParseVector2(node.GetValue("textureShiftStart"));
textureShiftStart = ConfigNode.ParseVector2(node.GetValue("textureShiftEnd"));
}
else
{
textureShiftStart = ConfigNode.ParseVector2(node.GetValue("textureShiftStart"));
textureShiftEnd = ConfigNode.ParseVector2(node.GetValue("textureShiftEnd"));
}
mode = Mode.TextureShift;
}
else if (node.HasValue("controlledTransform") && node.HasValue("textureLayers") && node.HasValue("textureScaleStart") && node.HasValue("textureScaleEnd"))
{
affectedMaterial = thisProp.FindModelTransform(node.GetValue("controlledTransform").Trim()).GetComponent <Renderer>().material;
var textureLayers = node.GetValue("textureLayers").Split(',');
for (int i = 0; i < textureLayers.Length; ++i)
{
textureLayer.Add(textureLayers[i].Trim());
}
if (reverse)
{
textureScaleEnd = ConfigNode.ParseVector2(node.GetValue("textureScaleStart"));
textureScaleStart = ConfigNode.ParseVector2(node.GetValue("textureScaleEnd"));
}
else
{
textureScaleStart = ConfigNode.ParseVector2(node.GetValue("textureScaleStart"));
textureScaleEnd = ConfigNode.ParseVector2(node.GetValue("textureScaleEnd"));
}
mode = Mode.TextureScale;
}
else
{
throw new ArgumentException("Cannot initiate any of the possible action modes.");
}
TurnOff();
}