em: add block, positions, and global score motor running

Author: jsm174

Editor/Descriptors/EMAddPointsUnitDescriptor.cs

@@ -44,6 +44,14 @@ protected override void DefinedPort(IUnitPort port, UnitPortDescription desc)
 					desc.summary = "The total amount of points to add.";
 					break;
 
+				case nameof(EMAddPointsUnit.blockPoints):
+					desc.summary = "Block single pulse points when score motor running.";
+					break;
+
+				case nameof(EMAddPointsUnit.positions):
+					desc.summary = "Score motor positions.";
+					break;
+
 				case nameof(EMAddPointsUnit.duration):
 					desc.summary = "The amount of time (in ms) the score motor runs.";
 					break;

Runtime/Nodes/EM/EMAddPointsUnit.cs

@@ -30,13 +30,23 @@ public class EMAddPointsUnit : GleUnit
 		[PortLabelHidden]
 		public ControlInput InputTrigger;
 
+		[DoNotSerialize]
+		public ValueInput blockPoints { get; private set; }
+
+		[DoNotSerialize]
+		public ValueInput positions { get; private set; }
+
 		[DoNotSerialize]
 		public ValueInput duration { get; private set; }
 
 		[DoNotSerialize]
 		[PortLabel("Unscaled")]
 		public ValueInput unscaledTime { get; private set; }
 
+		[DoNotSerialize]
+		[PortLabelHidden]
+		public ControlOutput OutputTrigger;
+
 		[DoNotSerialize]
 		public ControlOutput started;
 
@@ -53,17 +63,21 @@ public class EMAddPointsUnit : GleUnit
 		[PortLabel("Point Value")]
 		public ValueOutput OutputPointValue { get; private set; }
 
-		private Bool running = false;
+		private static string VARIABLE_EM_SCORE_MOTOR = "EM_SCORE_MOTOR";
 
 		protected override void Definition()
 		{
 			InputTrigger = ControlInputCoroutine(nameof(InputTrigger), Process);
 
 			pointValue = ValueInput(nameof(pointValue), 0);
 
-			duration = ValueInput(nameof(duration), .750f);
+			blockPoints = ValueInput(nameof(blockPoints), true);
+			positions = ValueInput(nameof(positions), 6);
+			duration = ValueInput(nameof(duration), 750);
 			unscaledTime = ValueInput(nameof(unscaledTime), false);
 
+			OutputTrigger = ControlOutput(nameof(OutputTrigger));
+
 			started = ControlOutput(nameof(started));
 			stopped = ControlOutput(nameof(stopped));
 
@@ -74,22 +88,17 @@ protected override void Definition()
 
 		private IEnumerator Process(Flow flow)
 		{
-			if (running) {
-				var points = flow.GetValue<int>(pointValue);
+			var running = false;
 
-				Debug.Log($"Score motor is already running. Ignoring {points} point(s).");
-
-				yield return null;
+			if (Variables.Application.IsDefined(VARIABLE_EM_SCORE_MOTOR)) {
+				running = Variables.Application.Get<bool>(VARIABLE_EM_SCORE_MOTOR);
 			}
-			else {
-				Debug.Log("Starting score motor");
-
-				yield return started;
 
-				running = true;
+			yield return OutputTrigger;
 
-				var points = flow.GetValue<int>(pointValue);
+			var points = flow.GetValue<int>(pointValue);
 
+			if (points > 0) {
 				var pulses =
 					(points % 100000 == 0) ? points / 100000 :
 					(points % 10000 == 0) ? points / 10000 :
@@ -98,34 +107,57 @@ private IEnumerator Process(Flow flow)
 					(points % 10 == 0) ? points / 10 :
 					points;
 
-				var pointsPerPulse = points / pulses;
+				if (pulses == 1) {
+					if (!running || (running && !flow.GetValue<bool>(blockPoints))) {
+						Debug.Log($"Single pulse triggering with {points} points");
 
-				var seconds = flow.GetValue<float>(duration) / 6;
-				var realtime = flow.GetValue<bool>(unscaledTime);
+						flow.SetValue(OutputPointValue, points);
 
-				for (int loop = 0; loop < 6; loop++) {
-					var outputPoints = loop < pulses ? pointsPerPulse : 0;
+						yield return pulse;
+					}
+				}
+				else if (running)
+				{
+					Debug.Log($"Score motor is already running.");
+				}
+				else {
+					Debug.Log("Starting score motor");
 
-					Debug.Log($"Pulse {loop + 1} of 6 - waiting {seconds} and triggering with {outputPoints} points");
+					Variables.Application.Set(VARIABLE_EM_SCORE_MOTOR, true);
+		
+					yield return started;
 
-					if (realtime) {
-						yield return new WaitForSecondsRealtime(seconds);
-					}
-					else {
-						yield return new WaitForSeconds(seconds);
-					}
+					var motorPositions = flow.GetValue<int>(positions);
+
+					var delay = (flow.GetValue<float>(duration) / 1000f) / motorPositions;
+					var realtime = flow.GetValue<bool>(unscaledTime);
+
+					var pointsPerPulse = points / pulses;
 
-					flow.SetValue(OutputPointValue, outputPoints);
+					for (int loop = 0; loop < motorPositions; loop++) {
+						var outputPoints = loop < pulses ? pointsPerPulse : 0;
 
-					yield return pulse;
-				}
+						Debug.Log($"Pulse {loop + 1} of {motorPositions} - waiting {delay}ms and triggering with {outputPoints} points");
+
+						if (realtime) {
+							yield return new WaitForSecondsRealtime(delay);
+						}
+						else {
+							yield return new WaitForSeconds(delay);
+						}
+
+						flow.SetValue(OutputPointValue, outputPoints);
+
+						yield return pulse;
+					}
 
-				Debug.Log("Stopping score motor");
+					Debug.Log("Stopping score motor");
 
-				running = false;
+					Variables.Application.Set(VARIABLE_EM_SCORE_MOTOR, false);
 
-				yield return stopped;
-			}
+					yield return stopped;
+				}
+			}
 		}
 	}
 }