Add option for ROG Ally to remap ROG/QAM to L5/R5, with double/triple-tap for original function

Author: dpwhittaker

src/hhd/controller/base.py

@@ -544,6 +544,7 @@ def __init__(
                 "start_is_keyboard",
             ]
         ) = None,
+        guide_to_paddles: bool = False,
         trigger: None | Literal["analog_to_discrete", "discrete_to_analogue"] = None,
         dpad: (
             None
@@ -578,6 +579,7 @@ def __init__(
         startselect_chord: bool = False,
     ) -> None:
         self.swap_guide = swap_guide
+        self.guide_to_paddles = guide_to_paddles
         self.trigger = trigger
         self.dpad = dpad
         self.led = led
@@ -631,6 +633,8 @@ def __init__(
             self.emit and self.emit.simple_qam()
         )
         self.guide_pressed = False
+        self.guide_released = None
+        self.guide_times = 0
         self.steam_check = params.get("steam_check", None)
         self.steam_check_last = time.perf_counter()
         self.steam_check_fn = params.get("steam_check_fn", None)
@@ -1011,12 +1015,13 @@ def process(self, events: Sequence[Event]) -> Sequence[Event]:
                             )
                         ev["code"] = ""  # type: ignore
 
-                    if self.emit and ev["code"] == "mode":
-                        # Steam might do weirdness, emit an event to prepare
-                        # the overlay
-                        self.guide_pressed = ev["value"]
-                        if ev["value"]:
-                            self.emit({"type": "special", "event": "guide"})
+                    # overlay doesn't do anything with the "guide" event
+                    # if self.emit and ev["code"] == "mode":
+                    #     # Steam might do weirdness, emit an event to prepare
+                    #     # the overlay
+                    #     self.guide_pressed = ev["value"]
+                    #     if ev["value"]:
+                    #         self.emit({"type": "special", "event": "guide"})
 
                     if (
                         self.dpad == "discrete_to_analog" or self.dpad == "both"
@@ -1052,6 +1057,21 @@ def process(self, events: Sequence[Event]) -> Sequence[Event]:
                             }
                         )
 
+                    if ev["code"] == "mode" and self.guide_to_paddles:
+                        logger.info(f"guide_to_paddles mode button: {ev["value"]}, curr: {curr}")
+                        ev["code"] = ""
+                        if self.qam_simple:
+                            ev["code"] = "extra_l2"
+                        elif ev["value"]:
+                            self.guide_times += 1
+                            self.guide_pressed = curr
+                            self.guide_released = None
+                        elif self.guide_pressed:
+                            logger.info("releasing")
+                            self.guide_released = curr
+                            self.guide_pressed = None
+                        logger.info(f"guide_times: {self.guide_times}, guide_pressed: {self.guide_pressed}, guide_released: {self.guide_released}")
+
                     if (
                         self.qam_button is not None and ev["code"] == self.qam_button
                     ) or (self.keyboard_is == "qam" and ev["code"] == "keyboard"):
@@ -1077,11 +1097,11 @@ def process(self, events: Sequence[Event]) -> Sequence[Event]:
                                         self.qam_released = curr
                                     self.qam_pressed = None
                         else:
-                            if self.has_qam:
+                            if self.has_qam or self.guide_to_paddles:
                                 out.append(
                                     {
                                         "type": "button",
-                                        "code": "share",
+                                        "code": self.guide_to_paddles and "extra_r2" or "share",
                                         "value": ev["value"],
                                     },
                                 )
@@ -1369,6 +1389,23 @@ def process(self, events: Sequence[Event]) -> Sequence[Event]:
             if ev["type"] != "button" or ev["code"]:
                 out.append(ev)
 
+        # Handle Guide button multitap (only needed when guide_to_paddles == True)
+        if self.guide_to_paddles:
+            if self.guide_pressed and self.guide_times == 2:
+                send_steam_expand = True
+                self.guide_pressed = None
+                self.guide_times = 0
+            if self.guide_released and (
+                curr - self.guide_released > self.QAM_MULTI_PRESS_DELAY
+            ):
+                out.append({"type": "button", "code": "extra_l2", "value": True})
+                self.queue.append((
+                    {"type": "button", "code": "extra_l2", "value": False},
+                    curr + self.QAM_TAP_TIME
+                ))
+                self.guide_released = None
+                self.guide_times = 0
+
         # Handle QAM button
         # Below is the multitap implementation
         # If it was disabled, the code is a NO-OP
@@ -1398,12 +1435,14 @@ def process(self, events: Sequence[Event]) -> Sequence[Event]:
             self.qam_pre_sent = True
 
         send_steam_qam = send_steam_qam or (
-            qam_apply and not qam_hhd and self.qam_released and self.qam_times == 1
+            qam_apply and not qam_hhd and self.qam_released and
+            self.qam_times == (self.guide_to_paddles and 2 or 1)
         )
-        send_steam_expand = (
+        send_steam_expand = send_steam_expand or (
             qam_apply and self.qam_pressed and was_held and self.qam_hold == "mode"
         )
         if qam_apply and self.emit:
+            logger.info(f"apply and emit, guide_to_paddles = {self.guide_to_paddles}, qam_hhd: {qam_hhd}")
             if qam_hhd:
                 match self.qam_times:
                     case 0:
@@ -1412,6 +1451,20 @@ def process(self, events: Sequence[Event]) -> Sequence[Event]:
                         self.emit({"type": "special", "event": "qam_double"})
                     case _:
                         self.emit({"type": "special", "event": "qam_triple"})
+            elif self.guide_to_paddles:
+                match self.qam_times:
+                    case 0:
+                        pass
+                    case 1:
+                        out.append({"type": "button", "code": "extra_r2", "value": True})
+                        self.queue.append((
+                            {"type": "button", "code": "extra_r2", "value": False},
+                            curr + self.QAM_TAP_TIME
+                        ))
+                    case 2:
+                        self.emit({"type": "special", "event": "qam_single"})
+                    case 3:
+                        self.emit({"type": "special", "event": "qam_double"})
             else:
                 # FIXME: hiding the event based on qam_hold should not happen
                 # instead the handler should not open hhd

src/hhd/device/rog_ally/base.py

@@ -50,7 +50,7 @@
     "vibration": 50 if allyx else 100,
 }
 
-MODE_DELAY = 0.15
+MODE_DELAY = 0.04
 VIBRATION_DELAY = 0.1
 VIBRATION_ON: Event = {
     "type": "rumble",
@@ -393,6 +393,7 @@ def controller_loop(
         nintendo_mode=conf["nintendo_mode"].to(bool),
         emit=emit,
         swap_guide="select_is_guide" if conf["swap_armory"].to(bool) else None,
+        guide_to_paddles=conf.get("armory_as_paddles", False),
         qam_no_release=not conf["swap_armory"].to(bool),
         params=d_params,
     )

src/hhd/device/rog_ally/controllers.yml

@@ -23,6 +23,14 @@ children:
     hint: >-
       Swaps the Armory Crate and Command center buttons with start and select.
     default: False
+  
+  armory_as_paddles:
+    type: bool
+    title: Use ROG/QAM as L5/R5
+    tags: [non-essential]
+    hint: >-
+      Replaces Armory Crate and Command Center with L5 and R5. Double-tap for original function, triple-tap view for HHD.
+    default: False
 
   imu:
     type: bool

src/hhd/plugins/overlay/controllers.py

@@ -133,6 +133,7 @@ def __call__(self, expanded=False) -> Any:
             return False
 
         try:
+            logger.info(f"QamHandlerKeyboard: opening {expanded}")
             btn = B("KEY_1") if expanded else B("KEY_2")
             self.uinput.write(B("EV_KEY"), B("KEY_LEFTCTRL"), 1)
             self.uinput.write(B("EV_KEY"), btn, 1)