public HingeValue(ModuleRoboticServoHinge init, SharedObjects shared)
{
servo = init;
this.shared = shared;
part = GetPart();
InitializeSuffixes();
}
/// <summary>
/// Sets up the Servo property on demand.
/// </summary>
private ModuleRoboticServoHinge InitializeServo()
{
if (!initializedServo)
{
initializedServo = true;
Logging.Log("Initializing servo for " + ToString(part));
// Locate the servo for this part.
_servo = TryGetServoModule(part);
if (_servo == null)
{
// Somebody done goofed, and added config to put this PartModule where
// it doesn't belong, i.e. on something that's not a robotic part.
Logging.Error(
"No appropriate servo module found for ModuleRoboticSlave on "
+ ToString(part) + "; mod won't function for this part.");
Master = null;
slaveSelected = false;
return(null);
}
InitializeFieldPairs();
}
return(_servo);
}
/// <summary>
/// Sometimes a part's situation may change in a way that affects master-slave chains. Examples
/// of this include attaching a part (with its tree of children); detaching a part (with its
/// tree of children); user manually toggling slave mode on/off; altering ship in flight
/// (e.g. docking, undocking, part destruction). Whenever that happens, something that
/// affects *this* part's choice of master can affect its entire child tree, too, so we need
/// to propagate the change.
///
/// This function affects the part passed in, as well as all of its children. It will be called
/// on all parts, not just robotic parts are those equipped with ModuleRoboticSlave, since
/// the master-slave connection propagates through "neutral" parts such as structural elements.
/// </summary>
/// <param name="part">The part to which to propagate a master</param>
/// <param name="prospectiveMaster">The relevant actual or potential master. Null if no master candidate is available.</param>
private static void PropagateMaster(Part part, ModuleRoboticServoHinge prospectiveMaster)
{
// Figure out how we propagate
ModuleRoboticServoHinge localServo;
ModuleRoboticSlave slave;
PropagationType propagation = PropagationTypeOf(part, out localServo, out slave);
ModuleRoboticServoHinge toPropagate = null;
switch (propagation)
{
case PropagationType.Transparent:
toPropagate = prospectiveMaster;
break;
case PropagationType.Assertive:
toPropagate = localServo;
break;
}
// If this part is a slaveable one, set the master.
if (slave != null)
{
slave.Master = prospectiveMaster;
}
// Propagate to children.
if (part.children != null)
{
for (int i = 0; i < part.children.Count; ++i)
{
PropagateMaster(part.children[i], toPropagate);
}
}
}
/// <summary>
/// Given a servo module, get its target angle field.
/// </summary>
/// <param name="servo"></param>
/// <param name="fieldName"></param>
/// <returns></returns>
private static BaseField FieldOf(ModuleRoboticServoHinge servo, string fieldName)
{
if (servo == null)
{
return(null);
}
return(servo.Fields[fieldName]);
}
/// <summary>
/// Sets the master to the specified value. This is typically used when we need to actively
/// switch from one master to another due to dynamically changed state such as a user
/// toggling slave mode on and off.
/// </summary>
/// <param name="newMaster"></param>
private void SetMaster(ModuleRoboticServoHinge newMaster)
{
if (!initializedMaster)
{
initializedMaster = true;
}
SwitchMaster(newMaster);
}
internal RoboticHinge(Part part)
{
Part = part;
var internalPart = part.InternalPart;
servo = internalPart.Module <ModuleRoboticServoHinge>();
if (servo == null)
{
throw new ArgumentException("Part is not a robotic servo");
}
}
/// <summary>
/// Get a brief description of the part, if possible. Otherwise, get the full part title.
/// </summary>
/// <param name="part"></param>
/// <returns></returns>
private static string GetBriefDescription(ModuleRoboticServoHinge servo)
{
ModuleRoboticSlave slave = TryGetSlaveModule(servo.part);
if ((slave == null) || (string.IsNullOrEmpty(slave.partAbbreviation)))
{
return(servo.part.partInfo.title);
}
else
{
return(slave.partAbbreviation);
}
}
/// <summary>
/// Given a part, determine what effect it should have on propagation.
/// </summary>
/// <param name="part">The part to analyze.</param>
/// <param name="localServo">The servo module on the part, if present; null otherwise.</param>
/// <param name="slave">THe slave module on the part, if present; null otherwise.</param>
/// <returns></returns>
private static PropagationType PropagationTypeOf(
Part part,
out ModuleRoboticServoHinge localServo,
out ModuleRoboticSlave slave)
{
localServo = null;
slave = null;
// Is it even a robotic part at all?
BaseServo baseServo = TryGetModule <BaseServo>(part);
if (baseServo == null)
{
return(PropagationType.Transparent);
}
// Is it locked?
if (baseServo.servoIsLocked)
{
return(PropagationType.Transparent);
}
// Is it loose?
if (!baseServo.servoIsMotorized || !baseServo.servoMotorIsEngaged)
{
return(PropagationType.Dead);
}
// Is it a supported robotic type?
localServo = baseServo as ModuleRoboticServoHinge;
if (localServo == null)
{
return(PropagationType.Dead);
}
// Is it slaveable?
slave = TryGetSlaveModule(part);
if (slave == null)
{
return(PropagationType.Assertive);
}
// Is slave mode active?
return(slave.IsSlaveEnabled ? PropagationType.Transparent : PropagationType.Assertive);
}
public override void OnStart(StartState state)
{
base.OnStart(state);
servoType = (BGServoTypes)Enum.Parse(typeof(BGServoTypes), type);
switch (servoType)
{
case BGServoTypes.hinge:
hingeServo = this.part.FindModuleImplementing <ModuleRoboticServoHinge>();
if (hingeServo != null)
{
servo = hingeServo;
}
break;
case BGServoTypes.piston:
pistonServo = this.part.FindModuleImplementing <ModuleRoboticServoPiston>();
if (pistonServo != null)
{
servo = pistonServo;
}
break;
case BGServoTypes.rotor:
rotorServo = this.part.FindModuleImplementing <ModuleRoboticServoRotor>();
if (rotorServo != null)
{
servo = rotorServo;
}
break;
case BGServoTypes.servo:
rotationServo = this.part.FindModuleImplementing <ModuleRoboticRotationServo>();
if (rotationServo != null)
{
servo = rotationServo;
}
break;
}
}
public override void OnStart(StartState state)
{
base.OnStart(state);
//Grab the textures if needed.
if (powerOnIcon == null)
{
string baseIconURL = "WildBlueIndustries/ServoController/Icons/";
ConfigNode[] settingsNodes = GameDatabase.Instance.GetConfigNodes("ServoController");
if (settingsNodes != null && settingsNodes.Length > 0)
{
baseIconURL = settingsNodes[0].GetValue("iconsFolder");
}
powerOnIcon = GameDatabase.Instance.GetTexture(baseIconURL + "PowerOn", false);
powerOffIcon = GameDatabase.Instance.GetTexture(baseIconURL + "PowerOff", false);
}
servoType = (BGServoTypes)Enum.Parse(typeof(BGServoTypes), type);
switch (servoType)
{
case BGServoTypes.hinge:
hingeServo = this.part.FindModuleImplementing <ModuleRoboticServoHinge>();
break;
case BGServoTypes.piston:
pistonServo = this.part.FindModuleImplementing <ModuleRoboticServoPiston>();
break;
case BGServoTypes.rotor:
rotorServo = this.part.FindModuleImplementing <ModuleRoboticServoRotor>();
break;
case BGServoTypes.servo:
rotationServo = this.part.FindModuleImplementing <ModuleRoboticRotationServo>();
break;
}
}
/// <summary>
/// Given a part, determine what effect it should have on propagation.
/// </summary>
/// <param name="part">The part to analyze.</param>
/// <param name="localServo">The servo module on the part, if present; null otherwise.</param>
/// <returns></returns>
private static PropagationType PropagationTypeOf(Part part, out ModuleRoboticServoHinge localServo)
{
ModuleRoboticSlave dontCareSlave;
return(PropagationTypeOf(part, out localServo, out dontCareSlave));
}
/// <summary>
/// Useful for debug logging messages.
/// </summary>
/// <param name="part"></param>
/// <returns></returns>
private static String ToString(ModuleRoboticServoHinge servo)
{
return((servo == null) ? "NULL" : ToString(servo.part));
}
/// <summary>
/// Shared logic for whenever the part's master changes.
/// </summary>
/// <param name="newMaster"></param>
private void SwitchMaster(ModuleRoboticServoHinge newMaster)
{
_master = newMaster;
ConfigureGui();
ResetTrackers();
}
