simplevgpad 0.1.0__tar.gz

simplevgpad-0.1.0/PKG-INFO

@@ -0,0 +1,44 @@
+Metadata-Version: 2.4
+Name: simplevgpad
+Version: 0.1.0
+Summary: Simple wrapper around vgamepad for easier controller inputs
+Author: Jakanon Clenkk
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: vgamepad
+
+# simplevgpad
+
+A Python helper library for simplified Xbox controller input using vgamepad.
+
+Defines 2 classes which inherit the vgamepad.VX360Gamepad class, and adds methods to
+slightly simplify controller input simulation for simple projects.
+
+## Installation
+
+```bash
+pip install simplevgpad
+```
+
+## Examples
+
+### controller
+```py
+from simplevgpad import controller
+
+game = controller()
+game.press_a()
+game.hold_left_trigger(2)
+```
+
+### controller_async
+```py
+from simplevgpad import controller_async
+import asyncio
+
+async def main():
+    game = controller_async()
+    await game.press_a()
+
+asyncio.run(main())
+```

simplevgpad-0.1.0/README.md

@@ -0,0 +1,35 @@
+# simplevgpad
+
+A Python helper library for simplified Xbox controller input using vgamepad.
+
+Defines 2 classes which inherit the vgamepad.VX360Gamepad class, and adds methods to
+slightly simplify controller input simulation for simple projects.
+
+## Installation
+
+```bash
+pip install simplevgpad
+```
+
+## Examples
+
+### controller
+```py
+from simplevgpad import controller
+
+game = controller()
+game.press_a()
+game.hold_left_trigger(2)
+```
+
+### controller_async
+```py
+from simplevgpad import controller_async
+import asyncio
+
+async def main():
+    game = controller_async()
+    await game.press_a()
+
+asyncio.run(main())
+```

simplevgpad-0.1.0/pyproject.toml

@@ -0,0 +1,18 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "simplevgpad"
+version = "0.1.0"
+description = "Simple wrapper around vgamepad for easier controller inputs"
+readme = "README.md"
+requires-python = ">=3.8"
+
+authors = [
+  { name="Jakanon Clenkk" }
+]
+
+dependencies = [
+  "vgamepad"
+]

simplevgpad-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

simplevgpad-0.1.0/src/simplevgpad/__init__.py

@@ -0,0 +1,3 @@
+from .simplevgpad import controller, controller_async
+
+__all__ = ["controller", "controller_async"]

simplevgpad-0.1.0/src/simplevgpad/simplevgpad.py

@@ -0,0 +1,806 @@
+import vgamepad as vg
+import time
+import asyncio
+
+
+class controller(vg.VX360Gamepad):
+    def __init__(self):
+        super().__init__()
+    
+    def press_a(self):
+        """ Simulates a tap of the 'A' button on the controller """
+        self.press_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_A)
+        self.update()
+        time.sleep(0.05)
+        self.release_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_A)
+        self.update()
+        time.sleep(0.05)
+
+    def hold_a(self, duration: int):
+        """ Simulates holding of the 'A' button on the controller.
+        duration: time (in secconds) for how long to hold the input."""
+        self.press_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_A)
+        self.update()
+        time.sleep(duration)
+        self.release_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_A)
+        self.update()
+        time.sleep(0.05)
+
+    def press_b(self):
+        """ Simulates a tap of the 'B' button on the controller """
+        self.press_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_B)
+        self.update()
+        time.sleep(0.05)
+        self.release_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_B)
+        self.update()
+        time.sleep(0.05)
+
+    def hold_b(self, duration: int):
+        """ Simulates holding of the 'B' button on the controller.
+        duration: time (in secconds) for how long to hold the input."""
+        self.press_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_B)
+        self.update()
+        time.sleep(duration)
+        self.release_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_B)
+        self.update()
+        time.sleep(0.05)
+
+    def press_x(self):
+        """ Simulates a tap of the 'X' button on the controller """
+        self.press_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_X)
+        self.update()
+        time.sleep(0.05)
+        self.release_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_X)
+        self.update()
+        time.sleep(0.05)
+
+    def hold_x(self, duration: int):
+        """ Simulates holding of the 'X' button on the controller.
+        duration: time (in secconds) for how long to hold the input."""
+        self.press_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_X)
+        self.update()
+        time.sleep(duration)
+        self.release_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_X)
+        self.update()
+        time.sleep(0.05)
+
+    def press_y(self):
+        """ Simulates a tap of the 'Y' button on the controller """
+        self.press_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_X)
+        self.update()
+        time.sleep(0.05)
+        self.release_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_X)
+        self.update()
+        time.sleep(0.05)
+
+    def hold_y(self, duration: int):
+        """ Simulates holding of the 'Y' button on the controller.
+        duration: time (in secconds) for how long to hold the input."""
+        self.press_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_Y)
+        self.update()
+        time.sleep(duration)
+        self.release_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_Y)
+        self.update()
+        time.sleep(0.05)
+
+    def dpad_up(self):
+        """ Simulates a tap of the 'dpad up' button on the controller."""
+        self.press_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_DPAD_UP)
+        self.update()
+        time.sleep(0.05)
+        self.release_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_DPAD_UP)
+        self.update()
+        time.sleep(0.05)
+
+    def dpad_down(self):
+        """ Simulates a tap of the 'dpad down' button on the controller."""
+        self.press_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_DPAD_DOWN)
+        self.update()
+        time.sleep(0.05)
+        self.release_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_DPAD_DOWN)
+        self.update()
+        time.sleep(0.05)
+    
+    def dpad_left(self):
+        """ Simulates a tap of the 'dpad left' button on the controller."""
+        self.press_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_DPAD_LEFT)
+        self.update()
+        time.sleep(0.05)
+        self.release_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_DPAD_LEFT)
+        self.update()
+        time.sleep(0.05)
+    
+    def dpad_right(self):
+        """ Simulates a tap of the 'dpad right' button on the controller."""
+        self.press_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_DPAD_RIGHT)
+        self.update()
+        time.sleep(0.05)
+        self.release_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_DPAD_RIGHT)
+        self.update()
+        time.sleep(0.05)
+
+    def hold_dpad_up(self, duration):
+        """ Simulates holding of the 'dpad up' button on the controller.
+        duration: time (in secconds) for how long to hold the input."""
+        self.press_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_DPAD_UP)
+        self.update()
+        time.sleep(duration)
+        self.release_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_DPAD_UP)
+        self.update()
+        time.sleep(0.05)
+
+    def hold_dpad_down(self, duration):
+        """ Simulates holding of the 'dpad down' button on the controller.
+        duration: time (in secconds) for how long to hold the input."""
+        self.press_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_DPAD_DOWN)
+        self.update()
+        time.sleep(duration)
+        self.release_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_DPAD_DOWN)
+        self.update()
+        time.sleep(0.05)
+    
+    def hold_dpad_left(self, duration):
+        """ Simulates holding of the 'dpad left' button on the controller.
+        duration: time (in secconds) for how long to hold the input."""
+        self.press_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_DPAD_LEFT)
+        self.update()
+        time.sleep(duration)
+        self.release_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_DPAD_LEFT)
+        self.update()
+        time.sleep(0.05)
+    
+    def hold_dpad_right(self, duration):
+        """ Simulates holding of the 'dpad right' button on the controller.
+        duration: time (in secconds) for how long to hold the input."""
+        self.press_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_DPAD_RIGHT)
+        self.update()
+        time.sleep(duration)
+        self.release_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_DPAD_RIGHT)
+        self.update()
+        time.sleep(0.05)
+
+    def press_options(self):
+        """ Simulates a tap of the 'options' button on the controller."""
+        self.press_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_BACK)
+        self.update()
+        time.sleep(0.05)
+        self.release_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_BACK)
+        self.update()
+        time.sleep(0.05)
+    
+    def press_left_bumper(self):
+        """ Simulates a tap of the 'left bumper' button on the controller."""
+        self.press_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_LEFT_SHOULDER)
+        self.update()
+        time.sleep(0.05)
+        self.release_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_LEFT_SHOULDER)
+        self.update()
+        time.sleep(0.05)
+
+    def hold_left_bumper(self, duration: int):
+        """ Simulates holding of the 'left bumper' button on the controller.
+        duration: time (in secconds) for how long to hold the input."""
+        self.press_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_LEFT_SHOULDER)
+        self.update()
+        time.sleep(duration)
+        self.release_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_LEFT_SHOULDER)
+        self.update()
+        time.sleep(0.05)
+
+    def press_right_bumper(self):
+        """ Simulates a tap of the 'right bumper' button on the controller."""
+        self.press_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_LEFT_SHOULDER)
+        self.update()
+        time.sleep(0.05)
+        self.release_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_LEFT_SHOULDER)
+        self.update()
+        time.sleep(0.05)
+
+    def hold_right_bumper(self, duration: int):
+        """ Simulates holding of the 'right bumper' button on the controller.
+        duration: time (in secconds) for how long to hold the input."""
+        self.press_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_LEFT_SHOULDER)
+        self.update()
+        time.sleep(duration)
+        self.release_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_LEFT_SHOULDER)
+        self.update()
+        time.sleep(0.05)
+    
+    def press_left_trigger(self):
+        """ Simulates a tap of the 'left trigger' button on the controller."""
+        self.left_trigger(255)
+        self.update()
+        time.sleep(0.05)
+        self.left_trigger(0)
+        self.update()
+        time.sleep(0.05)
+        
+    def hold_left_trigger(self, duration: int):
+        """ Simulates holding of the 'left trigger' button on the controller.
+        duration: time (in secconds) for how long to hold the input."""
+        self.left_trigger(255)
+        self.update()
+        time.sleep(duration)
+        self.left_trigger(0)
+        self.update()
+        time.sleep(0.05)
+    
+    def press_right_trigger(self):
+        """ Simulates a tap of the 'right trigger' button on the controller."""
+        self.right_trigger(255)
+        self.update()
+        time.sleep(0.05)
+        self.right_trigger(0)
+        self.update()
+        time.sleep(0.05)
+        
+    def hold_right_trigger(self, duration: int):
+        """ Simulates holding of the 'right trigger' button on the controller.
+        duration: time (in secconds) for how long to hold the input."""
+        self.right_trigger(255)
+        self.update()
+        time.sleep(duration)
+        self.right_trigger(0)
+        self.update()
+        time.sleep(0.05)
+    
+    def left_joystick_up(self, duration: int):
+        """ Simulates holding of the 'left joystick' on the controller upwards.
+        duration: time (in secconds) for how long to hold the input."""
+        self.left_joystick_float(0.0, 1.0)
+        self.update()
+        time.sleep(duration)
+        self.left_joystick_float(0.0, 0.0)
+        self.update()
+        time.sleep(0.05)
+
+    def left_joystick_down(self, duration: int):
+        """ Simulates holding of the 'left joystick' on the controller downwards.
+        duration: time (in secconds) for how long to hold the input."""
+        self.left_joystick_float(0.0, -1.0)
+        self.update()
+        time.sleep(duration)
+        self.left_joystick_float(0.0, 0.0)
+        self.update()
+        time.sleep(0.05)
+    
+    def left_joystick_right(self, duration: int):
+        """ Simulates holding of the 'left joystick' on the controller to the right.
+        duration: time (in secconds) for how long to hold the input."""
+        self.left_joystick_float(1.0, 0.0)
+        self.update()
+        time.sleep(duration)
+        self.left_joystick_float(0.0, 0.0)
+        self.update()
+        time.sleep(0.05)
+    
+    def left_joystick_left(self, duration: int):
+        """ Simulates holding of the 'left joystick' on the controller to the left.
+        duration: time (in secconds) for how long to hold the input."""
+        self.left_joystick_float(-1.0, 0.0)
+        self.update()
+        time.sleep(duration)
+        self.left_joystick_float(0.0, 0.0)
+        self.update()
+        time.sleep(0.05)
+    
+    def left_joystick_custom(self, x_axis: float, y_axis: float, duration: int):
+        """ Simulates moving of the 'left joystick' on the controller.\n
+        duration: time (in secconds) for how long to hold the input.\n
+        x_axis: float value range -1.0 to 1.0 to set x axis, 0 is resting position.\n
+        y_axis: float value range -1.0 to 1.0 to set y axis, 0 is resting position."""
+        if x_axis < -1.0 or x_axis > 1.0 or y_axis < -1.0 or y_axis > 1.0: 
+            print(f"Custom joystick value error:\nValue of x_axis and y_axis must be between -1.0 and 1.0\nGot: x_axis: {x_axis} | y_axis: {y_axis}")
+            return
+        self.left_joystick_float(-1.0, 0.0)
+        self.update()
+        time.sleep(duration)
+        self.left_joystick_float(0.0, 0.0)
+        self.update()
+        time.sleep(0.05)
+    
+    def right_joystick_up(self, duration: int):
+        """ Simulates holding of the 'right joystick' on the controller upwards.
+        duration: time (in secconds) for how long to hold the input."""
+        self.right_joystick_float(0.0, 1.0)
+        self.update()
+        time.sleep(duration)
+        self.right_joystick_float(0.0, 0.0)
+        self.update()
+        time.sleep(0.05)
+
+    def right_joystick_down(self, duration: int):
+        """ Simulates holding of the 'right joystick' on the controller downwards.
+        duration: time (in secconds) for how long to hold the input."""
+        self.right_joystick_float(0.0, -1.0)
+        self.update()
+        time.sleep(duration)
+        self.right_joystick_float(0.0, 0.0)
+        self.update()
+        time.sleep(0.05)
+    
+    def right_joystick_right(self, duration: int):
+        """ Simulates holding of the 'right joystick' on the controller to the right.
+        duration: time (in secconds) for how long to hold the input."""
+        self.right_joystick_float(1.0, 0.0)
+        self.update()
+        time.sleep(duration)
+        self.right_joystick_float(0.0, 0.0)
+        self.update()
+        time.sleep(0.05)
+    
+    def right_joystick_left(self, duration: int):
+        """ Simulates holding of the 'right joystick' on the controller to the right.
+        duration: time (in secconds) for how long to hold the input."""
+        self.right_joystick_float(-1.0, 0.0)
+        self.update()
+        time.sleep(duration)
+        self.right_joystick_float(0.0, 0.0)
+        self.update()
+        time.sleep(0.05)
+    
+    def right_joystick_custom(self, x_axis: float, y_axis: float, duration: int):
+        """ Simulates moving of the 'right joystick' on the controller.\n
+        duration: time (in secconds) for how long to hold the input.\n
+        x_axis: float value range -1.0 to 1.0 to set x axis, 0 is resting position.\n
+        y_axis: float value range -1.0 to 1.0 to set y axis, 0 is resting position."""
+        if x_axis < -1.0 or x_axis > 1.0 or y_axis < -1.0 or y_axis > 1.0: 
+            print(f"Custom joystick value error:\nValue of x_axis and y_axis must be between -1.0 and 1.0\nGot: x_axis: {x_axis} | y_axis: {y_axis}")
+            return
+        self.right_joystick_float(-1.0, 0.0)
+        self.update()
+        time.sleep(duration)
+        self.right_joystick_float(0.0, 0.0)
+        self.update()
+        time.sleep(0.05)
+    
+    def press_left_thumb(self):
+        """ Simulates a tap of the 'left joystick' button on the controller."""
+        self.press_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_LEFT_THUMB)
+        time.sleep(0.05)
+        self.release_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_LEFT_THUMB)
+        time.sleep(0.05)
+
+    def hold_left_thumb(self, duration):
+        """ Simulates a holding of the 'left joystick' button on the controller.
+        duration: time (in secconds) for how long to hold the input."""
+        self.press_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_LEFT_THUMB)
+        self.update()
+        time.sleep(duration)
+        self.release_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_LEFT_THUMB)
+        self.update()
+        time.sleep(0.05)
+    
+    def press_right_thumb(self):
+        """ Simulates a tap of the 'right joystick' button on the controller."""
+        self.press_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_RIGHT_THUMB)
+        time.sleep(0.05)
+        self.release_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_RIGHT_THUMB)
+        time.sleep(0.05)
+
+    def hold_right_thumb(self, duration):
+        """ Simulates holding of the 'right joystick' button on the controller.
+        duration: time (in secconds) for how long to hold the input."""
+        self.press_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_RIGHT_THUMB)
+        self.update()
+        time.sleep(duration)
+        self.release_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_RIGHT_THUMB)
+        self.update()
+        time.sleep(0.05)
+
+
+class controller_async(vg.VX360Gamepad):
+    def __init__(self):
+        super().__init__()
+        self.movement_count = 0
+
+    async def press_a(self):
+        """ Simulates a tap of the 'A' button on the controller """
+        self.press_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_A)
+        self.update()
+        await asyncio.sleep(0.05)
+        self.release_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_A)
+        self.update()
+
+    async def hold_a(self, duration: int):
+        """ Simulates holding of the 'A' button on the controller.
+        duration: time (in secconds) for how long to hold the input."""
+        self.press_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_A)
+        self.update()
+        await asyncio.sleep(duration)
+        self.release_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_A)
+        self.update()
+
+    async def press_b(self):
+        """ Simulates a tap of the 'B' button on the controller """
+        self.press_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_B)
+        self.update()
+        await asyncio.sleep(0.05)
+        self.release_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_B)
+        self.update()
+
+    async def hold_b(self, duration: int):
+        """ Simulates holding of the 'B' button on the controller.
+        duration: time (in secconds) for how long to hold the input."""
+        self.press_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_B)
+        self.update()
+        await asyncio.sleep(duration)
+        self.release_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_B)
+        self.update()
+
+    async def press_x(self):
+        """ Simulates a tap of the 'X' button on the controller """
+        self.press_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_X)
+        self.update()
+        await asyncio.sleep(0.05)
+        self.release_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_X)
+        self.update()
+
+    async def hold_x(self, duration: int):
+        """ Simulates holding of the 'X' button on the controller.
+        duration: time (in secconds) for how long to hold the input."""
+        self.press_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_X)
+        self.update()
+        await asyncio.sleep(duration)
+        self.release_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_X)
+        self.update()
+
+    async def press_y(self):
+        """ Simulates a tap of the 'Y' button on the controller """
+        self.press_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_Y)
+        self.update()
+        await asyncio.sleep(0.05)
+        self.release_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_Y)
+        self.update()
+
+    async def hold_y(self, duration: int):
+        """ Simulates holding of the 'Y' button on the controller.
+        duration: time (in secconds) for how long to hold the input."""
+        self.press_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_Y)
+        self.update()
+        await asyncio.sleep(duration)
+        self.release_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_Y)
+        self.update()
+
+    async def dpad_up(self):
+        """ Simulates a tap of the 'dpad up' button on the controller."""
+        self.press_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_DPAD_UP)
+        self.update()
+        await asyncio.sleep(0.05)
+        self.release_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_DPAD_UP)
+        self.update()
+
+    async def dpad_down(self):
+        """ Simulates a tap of the 'dpad down' button on the controller."""
+        self.press_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_DPAD_DOWN)
+        self.update()
+        await asyncio.sleep(0.05)
+        self.release_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_DPAD_DOWN)
+        self.update()
+
+    async def dpad_left(self):
+        """ Simulates a tap of the 'dpad left' button on the controller."""
+        self.press_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_DPAD_LEFT)
+        self.update()
+        await asyncio.sleep(0.05)
+        self.release_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_DPAD_LEFT)
+        self.update()
+
+    async def dpad_right(self):
+        """ Simulates a tap of the 'dpad right' button on the controller."""
+        self.press_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_DPAD_RIGHT)
+        self.update()
+        await asyncio.sleep(0.05)
+        self.release_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_DPAD_RIGHT)
+        self.update()
+
+    async def hold_dpad_up(self, duration):
+        """ Simulates holding of the 'dpad up' button on the controller.
+        duration: time (in secconds) for how long to hold the input."""
+        self.press_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_DPAD_UP)
+        self.update()
+        await asyncio.sleep(duration)
+        self.release_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_DPAD_UP)
+        self.update()
+
+    async def hold_dpad_down(self, duration):
+        """ Simulates holding of the 'dpad down' button on the controller.
+        duration: time (in secconds) for how long to hold the input."""
+        self.press_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_DPAD_DOWN)
+        self.update()
+        await asyncio.sleep(duration)
+        self.release_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_DPAD_DOWN)
+        self.update()
+
+    async def hold_dpad_left(self, duration):
+        """ Simulates holding of the 'dpad left' button on the controller.
+        duration: time (in secconds) for how long to hold the input."""
+        self.press_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_DPAD_LEFT)
+        self.update()
+        await asyncio.sleep(duration)
+        self.release_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_DPAD_LEFT)
+        self.update()
+
+    async def hold_dpad_right(self, duration):
+        """ Simulates holding of the 'dpad right' button on the controller.
+        duration: time (in secconds) for how long to hold the input."""
+        self.press_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_DPAD_RIGHT)
+        self.update()
+        await asyncio.sleep(duration)
+        self.release_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_DPAD_RIGHT)
+        self.update()
+
+    async def press_options(self):
+        """ Simulates a tap of the 'options' button on the controller."""
+        self.press_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_BACK)
+        self.update()
+        await asyncio.sleep(0.05)
+        self.release_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_BACK)
+        self.update()
+
+    async def press_left_bumper(self):
+        """ Simulates a tap of the 'left bumper' button on the controller."""
+        self.press_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_LEFT_SHOULDER)
+        self.update()
+        await asyncio.sleep(0.05)
+        self.release_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_LEFT_SHOULDER)
+        self.update()
+
+    async def hold_left_bumper(self, duration: int):
+        """ Simulates holding of the 'left bumper' button on the controller.
+        duration: time (in secconds) for how long to hold the input."""
+        self.press_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_LEFT_SHOULDER)
+        self.update()
+        await asyncio.sleep(duration)
+        self.release_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_LEFT_SHOULDER)
+        self.update()
+
+    async def press_right_bumper(self):
+        """ Simulates a tap of the 'right bumper' button on the controller."""
+        self.press_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_RIGHT_SHOULDER)
+        self.update()
+        await asyncio.sleep(0.05)
+        self.release_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_RIGHT_SHOULDER)
+        self.update()
+
+    async def hold_right_bumper(self, duration: int):
+        """ Simulates holding of the 'right bumper' button on the controller.
+        duration: time (in secconds) for how long to hold the input."""
+        self.press_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_RIGHT_SHOULDER)
+        self.update()
+        await asyncio.sleep(duration)
+        self.release_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_RIGHT_SHOULDER)
+        self.update()
+
+    async def press_left_trigger(self):
+        """ Simulates a tap of the 'left trigger' button on the controller."""
+        self.left_trigger(255)
+        self.update()
+        await asyncio.sleep(0.05)
+        self.left_trigger(0)
+        self.update()
+
+    async def hold_left_trigger(self, duration: int):
+        """ Simulates holding of the 'left trigger' button on the controller.
+        duration: time (in secconds) for how long to hold the input."""
+        self.left_trigger(255)
+        self.update()
+        await asyncio.sleep(duration)
+        self.left_trigger(0)
+        self.update()
+
+    async def press_right_trigger(self):
+        """ Simulates a tap of the 'right trigger' button on the controller."""
+        self.right_trigger(255)
+        self.update()
+        await asyncio.sleep(0.05)
+        self.right_trigger(0)
+        self.update()
+
+    async def hold_right_trigger(self, duration: int):
+        """ Simulates holding of the 'right trigger' button on the controller.
+        duration: time (in secconds) for how long to hold the input."""
+        self.right_trigger(255)
+        self.update()
+        await asyncio.sleep(duration)
+        self.right_trigger(0)
+        self.update()
+
+    async def left_joystick_up(self, duration: int):
+        """ Simulates holding of the 'left joystick' on the controller upwards.
+        duration: time (in secconds) for how long to hold the input."""
+        self.movement_count += 1
+        current_movement = self.movement_count
+        self.left_joystick_float(0.0, 1.0)
+        self.update()
+        await asyncio.sleep(duration)
+        if self.movement_count == current_movement:
+            self.left_joystick_float(0.0, 0.0)
+            self.update()
+
+    async def left_joystick_down(self, duration: int):
+        """ Simulates holding of the 'left joystick' on the controller downwards.
+        duration: time (in secconds) for how long to hold the input."""
+        self.movement_count += 1
+        current_movement = self.movement_count
+        self.left_joystick_float(0.0, -1.0)
+        self.update()
+        await asyncio.sleep(duration)
+        if self.movement_count == current_movement:
+            self.left_joystick_float(0.0, 0.0)
+            self.update()
+
+    async def left_joystick_right(self, duration: int):
+        """ Simulates holding of the 'left joystick' on the controller to the right.
+        duration: time (in secconds) for how long to hold the input."""
+        self.movement_count += 1
+        current_movement = self.movement_count
+        self.left_joystick_float(1.0, 0.0)
+        self.update()
+        await asyncio.sleep(duration)
+        if self.movement_count == current_movement:
+            self.left_joystick_float(0.0, 0.0)
+            self.update()
+
+    async def left_joystick_left(self, duration: int):
+        """ Simulates holding of the 'left joystick' on the controller to the left.
+        duration: time (in secconds) for how long to hold the input."""
+        self.movement_count += 1
+        current_movement = self.movement_count
+        self.left_joystick_float(-1.0, 0.0)
+        self.update()
+        await asyncio.sleep(duration)
+        if self.movement_count == current_movement:
+            self.left_joystick_float(0.0, 0.0)
+            self.update()
+
+    async def left_joystick_custom(self, x_axis: float, y_axis: float, duration: int):
+        """ Simulates moving of the 'left joystick' on the controller.\n
+        duration: time (in secconds) for how long to hold the input.\n
+        x_axis: float value range -1.0 to 1.0 to set x axis, 0 is resting position.\n
+        y_axis: float value range -1.0 to 1.0 to set y axis, 0 is resting position."""
+        self.movement_count += 1
+        current_movement = self.movement_count
+        if not (-1.0 <= x_axis <= 1.0 and -1.0 <= y_axis <= 1.0):
+            print(f"Custom joystick value error:\nGot x_axis={x_axis}, y_axis={y_axis}")
+            return
+        self.left_joystick_float(x_axis, y_axis)
+        self.update()
+        await asyncio.sleep(duration)
+        if self.movement_count == current_movement:
+            self.left_joystick_float(0.0, 0.0)
+            self.update()
+
+    async def right_joystick_up(self, duration: int):
+        """ Simulates holding of the 'right joystick' on the controller upwards.
+        duration: time (in secconds) for how long to hold the input."""
+        self.movement_count += 1
+        current_movement = self.movement_count
+        self.right_joystick_float(0.0, 1.0)
+        self.update()
+        await asyncio.sleep(duration)
+        if self.movement_count == current_movement:
+            self.right_joystick_float(0.0, 0.0)
+            self.update()
+
+    async def right_joystick_down(self, duration: int):
+        """ Simulates holding of the 'right joystick' on the controller downwards.
+        duration: time (in secconds) for how long to hold the input."""
+        self.movement_count += 1
+        current_movement = self.movement_count
+        self.right_joystick_float(0.0, -1.0)
+        self.update()
+        await asyncio.sleep(duration)
+        if self.movement_count == current_movement:
+            self.right_joystick_float(0.0, 0.0)
+            self.update()
+
+    async def right_joystick_right(self, duration: int):
+        """ Simulates holding of the 'right joystick' on the controller to the right.
+        duration: time (in secconds) for how long to hold the input."""
+        self.movement_count += 1
+        current_movement = self.movement_count
+        self.right_joystick_float(1.0, 0.0)
+        self.update()
+        await asyncio.sleep(duration)
+        if self.movement_count == current_movement:
+            self.right_joystick_float(0.0, 0.0)
+            self.update()
+
+    async def right_joystick_left(self, duration: int):
+        """ Simulates holding of the 'right joystick' on the controller to the right.
+        duration: time (in secconds) for how long to hold the input."""
+        self.movement_count += 1
+        current_movement = self.movement_count
+        self.right_joystick_float(-1.0, 0.0)
+        self.update()
+        await asyncio.sleep(duration)
+        if self.movement_count == current_movement:
+            self.right_joystick_float(0.0, 0.0)
+            self.update()
+
+    async def right_joystick_custom(self, x_axis: float, y_axis: float, duration: int):
+        """ Simulates moving of the 'right joystick' on the controller.\n
+        duration: time (in secconds) for how long to hold the input.\n
+        x_axis: float value range -1.0 to 1.0 to set x axis, 0 is resting position.\n
+        y_axis: float value range -1.0 to 1.0 to set y axis, 0 is resting position."""
+        self.movement_count += 1
+        current_movement = self.movement_count
+        if not (-1.0 <= x_axis <= 1.0 and -1.0 <= y_axis <= 1.0):
+            print(f"Custom joystick value error:\nGot x_axis={x_axis}, y_axis={y_axis}")
+            return
+        self.right_joystick_float(x_axis, y_axis)
+        self.update()
+        await asyncio.sleep(duration)
+        if self.movement_count == current_movement:
+            self.right_joystick_float(0.0, 0.0)
+            self.update()
+
+    async def press_left_thumb(self):
+        """ Simulates a tap of the 'left joystick' button on the controller."""
+        self.press_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_LEFT_THUMB)
+        self.update()
+        await asyncio.sleep(0.05)
+        self.release_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_LEFT_THUMB)
+        self.update()
+    
+    async def press_right_thumb(self):
+        """ Simulates a tap of the 'right joystick' button on the controller."""
+        self.press_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_RIGHT_THUMB)
+        self.update()
+        await asyncio.sleep(0.05)
+        self.release_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_RIGHT_THUMB)
+        self.update()
+
+    async def hold_left_thumb(self, duration):
+        """ Simulates a holding of the 'left joystick' button on the controller.
+        duration: time (in secconds) for how long to hold the input."""
+        self.press_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_LEFT_THUMB)
+        self.update()
+        await asyncio.sleep(duration)
+        self.release_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_LEFT_THUMB)
+        self.update()
+    
+    async def hold_right_thumb(self, duration):
+        """ Simulates holding of the 'right joystick' button on the controller.
+        duration: time (in secconds) for how long to hold the input."""
+        self.press_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_RIGHT_THUMB)
+        self.update()
+        await asyncio.sleep(duration)
+        self.release_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_RIGHT_THUMB)
+        self.update()
+    
+    async def press_menu(self):
+        """ Simulates a tap of the 'options' button on the controller."""
+        self.press_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_START)
+        self.update()
+        await asyncio.sleep(0.05)
+        self.release_button(vg.XUSB_BUTTON.XUSB_GAMEPAD_START)
+        self.update()
+
+
+if __name__ == "__main__":
+
+    # Minimal working asynchronous example
+
+    def execute_async(command): #this is non-blocking
+        asyncio.create_task(command) 
+
+    async def main():
+        execute_async(game.left_joystick_up(20))
+        execute_async(game.hold_dpad_up(3))
+        await asyncio.sleep(3)
+        execute_async(game.hold_dpad_down(3))
+        await asyncio.sleep(3)
+        execute_async(game.hold_dpad_left(3))
+        await asyncio.sleep(3)
+        execute_async(game.hold_dpad_right(3))
+        await asyncio.sleep(3)
+        execute_async(game.hold_left_thumb(3))
+        await asyncio.sleep(3)
+        execute_async(game.hold_right_thumb(3))
+        await asyncio.sleep(3)
+
+    time.sleep(5)
+    game = controller_async()
+    asyncio.run(main())

simplevgpad-0.1.0/src/simplevgpad.egg-info/PKG-INFO

@@ -0,0 +1,44 @@
+Metadata-Version: 2.4
+Name: simplevgpad
+Version: 0.1.0
+Summary: Simple wrapper around vgamepad for easier controller inputs
+Author: Jakanon Clenkk
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: vgamepad
+
+# simplevgpad
+
+A Python helper library for simplified Xbox controller input using vgamepad.
+
+Defines 2 classes which inherit the vgamepad.VX360Gamepad class, and adds methods to
+slightly simplify controller input simulation for simple projects.
+
+## Installation
+
+```bash
+pip install simplevgpad
+```
+
+## Examples
+
+### controller
+```py
+from simplevgpad import controller
+
+game = controller()
+game.press_a()
+game.hold_left_trigger(2)
+```
+
+### controller_async
+```py
+from simplevgpad import controller_async
+import asyncio
+
+async def main():
+    game = controller_async()
+    await game.press_a()
+
+asyncio.run(main())
+```

simplevgpad-0.1.0/src/simplevgpad.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+README.md
+pyproject.toml
+src/simplevgpad/__init__.py
+src/simplevgpad/simplevgpad.py
+src/simplevgpad.egg-info/PKG-INFO
+src/simplevgpad.egg-info/SOURCES.txt
+src/simplevgpad.egg-info/dependency_links.txt
+src/simplevgpad.egg-info/requires.txt
+src/simplevgpad.egg-info/top_level.txt

simplevgpad-0.1.0/src/simplevgpad.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

simplevgpad-0.1.0/src/simplevgpad.egg-info/requires.txt

@@ -0,0 +1 @@
+vgamepad

simplevgpad-0.1.0/src/simplevgpad.egg-info/top_level.txt

@@ -0,0 +1 @@
+simplevgpad