feat: Input UserAction now provides API for double key/button presses

AlmasB · AlmasB · commit 907f26ba3d09 · 2022-07-15T18:54:41.000+01:00
diff --git a/fxgl-core/src/main/kotlin/com/almasb/fxgl/input/Input.kt b/fxgl-core/src/main/kotlin/com/almasb/fxgl/input/Input.kt
@@ -120,11 +120,27 @@ class Input {
      */
     private val currentActions = FXCollections.observableArrayList<UserAction>()
 
+    /**
+     * K - user action.
+     * V - time in seconds when last triggered.
+     */
+    private val actionTimes = hashMapOf<UserAction, Double>()
+
     private val activeTriggers = arrayListOf<Trigger>()
     private val listeners = arrayListOf<TriggerListener>()
 
     private val inputQueue = ArrayDeque<KeyCode>()
 
+    /**
+     * Time accumulated by this input in seconds.
+     */
+    private var time = 0.0
+
+    /**
+     * Time in seconds within which a double press can occur.
+     */
+    var doublePressTimeThreshold = 0.25
+
     /**
      * If action events should be processed.
      */
@@ -259,6 +275,8 @@ class Input {
     }
 
     fun update(tpf: Double) {
+        time += tpf
+
         if (isCapturing) {
             currentCapture!!.update(tpf)
         }
@@ -353,8 +371,19 @@ class Input {
                 .forEach { (act, _) ->
                     currentActions.add(act)
 
-                    if (processInput)
+                    if (processInput) {
                         act.begin()
+
+                        val lastTime = actionTimes[act] ?: -Int.MAX_VALUE.toDouble()
+
+                        actionTimes[act] = time
+
+                        if (time - lastTime <= doublePressTimeThreshold) {
+                            // this resets action time, so that 3rd action will not trigger double action
+                            actionTimes.remove(act)
+                            act.beginDoubleAction()
+                        }
+                    }
                 }
 
         if (event.eventType == KeyEvent.KEY_PRESSED) {
@@ -444,7 +473,10 @@ class Input {
             currentActions.forEach { it.end() }
         }
 
+        time = 0.0
+
         currentActions.clear()
+        actionTimes.clear()
         activeTriggers.clear()
 
         stopCapture()
diff --git a/fxgl-core/src/main/kotlin/com/almasb/fxgl/input/UserAction.kt b/fxgl-core/src/main/kotlin/com/almasb/fxgl/input/UserAction.kt
@@ -37,6 +37,7 @@ abstract class UserAction(
     internal fun begin() = onActionBegin()
     internal fun action() = onAction()
     internal fun end() = onActionEnd()
+    internal fun beginDoubleAction() = onDoubleActionBegin()
 
     /**
      * Called once in the same tick when triggered.
@@ -53,4 +54,10 @@ abstract class UserAction(
      * Called once in the same tick when trigger was released.
      */
     protected open fun onActionEnd() {}
+
+    /**
+     * Called once in the same tick when triggered for the second time
+     * within a specified period of time.
+     */
+    protected open fun onDoubleActionBegin() {}
 }
diff --git a/fxgl-core/src/test/kotlin/com/almasb/fxgl/input/InputTest.kt b/fxgl-core/src/test/kotlin/com/almasb/fxgl/input/InputTest.kt
@@ -1012,6 +1012,51 @@ class InputTest {
         assertThat(capture1, `is`(not(capture3)))
     }
 
+    @Test
+    fun `Double press action`() {
+        var calls = 0
+
+        val action = object : UserAction("Action1") {
+            override fun onDoubleActionBegin() {
+                calls++
+            }
+        }
+
+        input.addAction(action, KeyCode.A)
+
+        input.mockKeyPress(KeyCode.A)
+        input.mockKeyRelease(KeyCode.A)
+        assertThat(calls, `is`(0))
+
+        // within threshold, so 2nd press triggers it
+        input.mockKeyPress(KeyCode.A)
+        input.mockKeyRelease(KeyCode.A)
+        assertThat(calls, `is`(1))
+
+        // 3rd press should not trigger since action should be reset
+        input.mockKeyPress(KeyCode.A)
+        input.mockKeyRelease(KeyCode.A)
+        assertThat(calls, `is`(1))
+
+        // 4th press should trigger as normal
+        input.mockKeyPress(KeyCode.A)
+        input.mockKeyRelease(KeyCode.A)
+        assertThat(calls, `is`(2))
+
+        input.doublePressTimeThreshold = 0.1
+
+        input.mockKeyPress(KeyCode.A)
+        input.mockKeyRelease(KeyCode.A)
+        assertThat(calls, `is`(2))
+
+        input.update(0.2)
+
+        // does not trigger it since more time has passed than threshold
+        input.mockKeyPress(KeyCode.A)
+        input.mockKeyRelease(KeyCode.A)
+        assertThat(calls, `is`(2))
+    }
+
 //    @Test
 //    fun `Serialization`() {
 //        val action = object : UserAction("Action") {}
