protected void checkAutolockAfterPlaying()
{
if (!isPlayingSnapshot || !autoLock)
{
return;
}
switch (servoType)
{
case BGServoTypes.hinge:
if (Mathf.Abs(hingeServo.currentAngle) / Mathf.Abs(hingeServo.targetAngle) <= 0.1f)
{
SetServoLock(true);
}
isPlayingSnapshot = hingeServo.IsJointUnlocked();
break;
case BGServoTypes.piston:
if (Mathf.Abs(pistonServo.currentExtension) / Mathf.Abs(pistonServo.targetExtension) <= 0.1f)
{
SetServoLock(true);
}
isPlayingSnapshot = pistonServo.IsJointUnlocked();
break;
case BGServoTypes.rotor:
servo = rotorServo;
break;
case BGServoTypes.servo:
if (Mathf.Abs(rotationServo.currentAngle) / Mathf.Abs(rotationServo.targetAngle) <= 0.1f)
{
SetServoLock(true);
}
isPlayingSnapshot = rotationServo.IsJointUnlocked();
break;
}
if (isPlayingSnapshot)
{
this.part.Effect(servoEffectName, 1.0f);
}
else
{
this.part.Effect(servoEffectName, -1.0f);
}
}
protected void resetLockedTargetAngle()
{
if (IsJointUnlocked())
{
return;
}
switch (servoType)
{
case BGServoTypes.hinge:
if (Mathf.Abs(hingeServo.targetAngle) != 0)
{
float targetRatio = Mathf.Abs(hingeServo.currentAngle) / Mathf.Abs(hingeServo.targetAngle);
if (targetRatio < 0.9999f || targetRatio > 1.0001)
{
hingeServo.targetAngle = hingeServo.currentAngle;
}
}
break;
case BGServoTypes.piston:
if (Mathf.Abs(pistonServo.targetExtension) != 0)
{
float targetRatio = Mathf.Abs(pistonServo.currentExtension) / Mathf.Abs(pistonServo.targetExtension);
if (targetRatio < 0.9999f || targetRatio > 1.0001)
{
pistonServo.targetExtension = pistonServo.currentExtension;
}
}
break;
case BGServoTypes.rotor:
servo = rotorServo;
break;
case BGServoTypes.servo:
if (Mathf.Abs(rotationServo.targetAngle) != 0)
{
float targetRatio = Mathf.Abs(rotationServo.currentAngle) / Mathf.Abs(rotationServo.targetAngle);
if (targetRatio < 0.9999f || targetRatio > 1.0001)
{
rotationServo.targetAngle = rotationServo.currentAngle;
}
}
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>
/// <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;
}
}
