pygameControls 0.0.4__tar.gz

pygamecontrols-0.0.4/LICENSE

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2025 CodingPirates
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

pygamecontrols-0.0.4/PKG-INFO

@@ -0,0 +1,24 @@
+Metadata-Version: 2.4
+Name: pygameControls
+Version: 0.0.4
+Summary: A simple controller class for pygame.
+Home-page: 
+Author: Jan Lerking
+Author-email: 
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: license-file
+Dynamic: requires-python
+Dynamic: summary
+
+# PyGame-Controller
+
+Small module to make it easy to add controller support.

pygamecontrols-0.0.4/README.md

@@ -0,0 +1,3 @@
+# PyGame-Controller
+
+Small module to make it easy to add controller support.

pygamecontrols-0.0.4/pygameControls/__init__.py

@@ -0,0 +1 @@
+from . import controller

pygamecontrols-0.0.4/pygameControls/controller.py

@@ -0,0 +1,31 @@
+import pygame
+from .controlsbase import ControlsBase
+from .dualsense_controller import DualSenseController
+from .dualsense_edge_controller import DualSenseEdgeController
+from .logitech_f310_controller import LogitechF310Controller
+from .logitech_f510_controller import LogitechF510Controller
+from .logitech_f710_controller import LogitechF710Controller
+from .xbox_series_x_controller import XboxSeriesXController
+from .generic_controller import GenericController
+from .logitech_dual_action_controller import LogitechDualActionController
+
+__version__ = "0.0.4"
+
+CONTROLLERS = {
+    "DualSense Wireless Controller": DualSenseController,
+    "DualSense Edge Wireless Controller": DualSenseEdgeController,
+    "Logitech Gamepad F310": LogitechF310Controller,
+    "Logitech Gamepad F510": LogitechF510Controller,
+    "Logitech Gamepad F710": LogitechF710Controller,
+    "Logitech Dual Action": LogitechDualActionController,
+    "X box Series X Controller": XboxSeriesXController
+    }
+
+class Controllers:
+    def __init__(self, joy):
+        self.controllers = []
+        if not joy.get_name() in CONTROLLERS:
+            self.controllers.append(GenericController(joy))
+        else:
+            self.controllers.append(CONTROLLERS[joy.get_name()](joy))
+        

pygamecontrols-0.0.4/pygameControls/controlsbase.py

@@ -0,0 +1,33 @@
+"""
+This is an abstract baseclass for the controls of snake.
+"""
+from abc import ABC, abstractmethod
+
+class ControlsBase(ABC):
+    @abstractmethod
+    def handle_input(self, event):
+        pass
+    
+    @abstractmethod
+    def left(self):
+        pass
+    
+    @abstractmethod
+    def right(self):
+        pass
+    
+    @abstractmethod
+    def up(self):
+        pass
+    
+    @abstractmethod
+    def down(self):
+        pass
+    
+    @abstractmethod
+    def pause(self):
+        pass
+    
+    @abstractmethod
+    def rumble(self):
+        pass

pygamecontrols-0.0.4/pygameControls/dualsense_audio.py

@@ -0,0 +1,70 @@
+import os
+import time
+import numpy as np
+import sounddevice as sd
+import alsaaudio
+import pulsectl
+
+class DualSenseAudio:
+    def __init__(self):
+        self.alsa_devices = self._get_alsa_devices()
+        self.pulse_devices = self._get_pulseaudio_devices()
+        self.dualsense_device = self._detect_dualsense()
+
+    def _get_alsa_devices(self):
+        try:
+            cards = alsaaudio.cards()
+            return cards
+        except Exception as e:
+            print("ALSA detection failed:", e)
+            return []
+
+    def _get_pulseaudio_devices(self):
+        try:
+            pulse = pulsectl.Pulse("dualsense-audio")
+            sinks = pulse.sink_list()
+            return sinks
+        except Exception as e:
+            print("PulseAudio detection failed:", e)
+            return []
+
+    def _detect_dualsense(self):
+        # Check ALSA names
+        for card in self.alsa_devices:
+            if "DualSense" in card:
+                return {'type': 'alsa', 'name': card}
+
+        # Check PulseAudio sinks
+        for sink in self.pulse_devices:
+            if "dualsense" in sink.description.lower():
+                return {'type': 'pulse', 'name': sink.name}
+
+        return None
+
+    def play_tone(self, frequency=440.0, duration=2.0, volume=0.5):
+        if not self.dualsense_device:
+            print("DualSense speaker not found.")
+            return
+
+        print(f"Playing tone on DualSense ({self.dualsense_device['type']})...")
+
+        fs = 48000  # Sample rate
+        t = np.linspace(0, duration, int(fs * duration), False)
+        tone = np.sin(frequency * 2 * np.pi * t) * volume
+        audio = tone.astype(np.float32)
+
+        if self.dualsense_device['type'] == 'pulse':
+            sd.play(audio, samplerate=fs, device=self.dualsense_device['name'])
+        elif self.dualsense_device['type'] == 'alsa':
+            device_index = self.alsa_devices.index(self.dualsense_device['name'])
+            sd.play(audio, samplerate=fs, device=device_index)
+        sd.wait()
+
+    def list_devices(self):
+        print("ALSA Devices:")
+        for card in self.alsa_devices:
+            print(f" - {card}")
+        print("\nPulseAudio Devices:")
+        for sink in self.pulse_devices:
+            print(f" - {sink.name} ({sink.description})")
+

pygamecontrols-0.0.4/pygameControls/dualsense_controller.py

@@ -0,0 +1,74 @@
+from pygameControls.controlsbase import ControlsBase
+from pydualsense import *
+
+BATTERY_STATE = {
+    "0": "Discharging",
+    "1": "Charging",
+    "2": "Full",
+    "11": "Not charging",
+    "15": "Error",
+    "10": "Temp or voltage out of range"
+    }
+
+class DualSenseController(ControlsBase):
+    def __init__(self, joy):
+        self.device = pydualsense()
+        self.device.init()
+        self.name = self.device.device.get_product_string()
+        self.powerlevel = self.device.battery.Level
+        self.batterystate = BATTERY_STATE[str(self.device.battery.State)]
+        self.set_player_id(PlayerID.PLAYER_1)
+        print(f"{self.name} connected")
+        print(f"Power level: {self.powerlevel}")
+        print(f"Battery state: {self.batterystate}")
+    
+    def handle_input(self, event):
+        pass
+    
+    def set_led(self, red: int, green: int, blue: int):
+        self.device.light.setColorI(red, green, blue)
+
+    def set_player_id(self, playerid: PlayerID):
+        self.device.light.setPlayerID(playerid)
+        
+    def left(self):
+        pass
+    
+    def right(self):
+        pass
+    
+    def up(self):
+        pass
+    
+    def down(self):
+        pass
+    
+    def pause(self):
+        pass
+    
+    def rumble(self):
+        pass
+    
+    @property
+    def name(self) -> str:
+        return self._name
+    
+    @name.setter
+    def name(self, name: str) -> None:
+        self._name = name
+    
+    @property
+    def powerlevel(self) -> str:
+        return self._powerlevel
+    
+    @powerlevel.setter
+    def powerlevel(self, lvl: str) -> None:
+        self._powerlevel = lvl
+    
+    @property
+    def batterystate(self) -> int:
+        return self._batterystate
+    
+    @batterystate.setter
+    def batterystate(self, state) -> None:
+        self._batterystate = state

pygamecontrols-0.0.4/pygameControls/dualsense_edge_controller.py

@@ -0,0 +1,199 @@
+import time
+import threading
+import numpy as np
+import sounddevice as sd
+import alsaaudio
+import pulsectl
+from pydualsense import *
+
+
+class DualSenseEdgeController:
+    def __init__(self):
+        # DualSense input/output interface
+        self.ds = pydualsense()
+        self.ds.init()
+        self._listening = False
+        self._bindings = {}
+
+        # Audio detection
+        self.alsa_devices = self._get_alsa_devices()
+        self.pulse_devices = self._get_pulseaudio_devices()
+        self.dualsense_audio_device = self._detect_dualsense_audio()
+
+        print("DualSense initialized.")
+
+    # ---------------------- Device Controls ----------------------
+
+    def set_rumble(self, small_motor: int, big_motor: int):
+        self.ds.setRumble(small_motor, big_motor)
+
+    def stop_rumble(self):
+        self.set_rumble(0, 0)
+
+    def set_led_color(self, r: int, g: int, b: int):
+        self.ds.setLightBarColor(r, g, b)
+
+    def set_trigger_effects(self, left_mode='Off', right_mode='Off', force=0):
+        left = getattr(TriggerModes, left_mode.upper(), TriggerModes.Off)
+        right = getattr(TriggerModes, right_mode.upper(), TriggerModes.Off)
+        self.ds.triggerL.setMode(left)
+        self.ds.triggerR.setMode(right)
+        if force > 0:
+            self.ds.triggerL.setForce(force)
+            self.ds.triggerR.setForce(force)
+
+    # ---------------------- Predefined Rumble Patterns ----------------------
+
+    def rumble_pattern(self, pattern: str, duration: float = 1.0):
+        patterns = {
+            "pulse": self._pulse_rumble,
+            "heartbeat": self._heartbeat_rumble,
+            "buzz": self._buzz_rumble,
+            "wave": self._wave_rumble,
+            "alarm": self._alarm_rumble,
+        }
+        if pattern in patterns:
+            threading.Thread(target=patterns[pattern], args=(duration,), daemon=True).start()
+        else:
+            print(f"Unknown rumble pattern: {pattern}")
+
+    def _pulse_rumble(self, duration):
+        end = time.time() + duration
+        while time.time() < end:
+            self.set_rumble(50, 150)
+            time.sleep(0.2)
+            self.stop_rumble()
+            time.sleep(0.2)
+
+    def _heartbeat_rumble(self, duration):
+        end = time.time() + duration
+        while time.time() < end:
+            self.set_rumble(200, 200)
+            time.sleep(0.1)
+            self.stop_rumble()
+            time.sleep(0.1)
+            self.set_rumble(100, 100)
+            time.sleep(0.1)
+            self.stop_rumble()
+            time.sleep(0.4)
+
+    def _buzz_rumble(self, duration):
+        self.set_rumble(80, 255)
+        time.sleep(duration)
+        self.stop_rumble()
+
+    def _wave_rumble(self, duration):
+        start = time.time()
+        while time.time() - start < duration:
+            for i in range(0, 256, 25):
+                self.set_rumble(i, 255 - i)
+                time.sleep(0.05)
+            for i in reversed(range(0, 256, 25)):
+                self.set_rumble(i, 255 - i)
+                time.sleep(0.05)
+        self.stop_rumble()
+
+    def _alarm_rumble(self, duration):
+        end = time.time() + duration
+        while time.time() < end:
+            self.set_rumble(255, 0)
+            time.sleep(0.1)
+            self.set_rumble(0, 255)
+            time.sleep(0.1)
+        self.stop_rumble()
+
+    # ---------------------- Input Listener + Bindings ----------------------
+
+    def bind(self, button: str, action: callable):
+        """Bind a button to a callable. Ex: controller.bind('cross', lambda: rumble_pattern('buzz'))"""
+        self._bindings[button] = action
+
+    def start_input_listener(self):
+        def listen():
+            while self._listening:
+                #self.ds.update()
+                for button, action in self._bindings.items():
+                    if getattr(self.ds, button, False):
+                        action()
+        self._listening = True
+        thread = threading.Thread(target=listen, daemon=True)
+        thread.start()
+
+    def stop_input_listener(self):
+        self._listening = False
+
+    # ---------------------- Audio Output ----------------------
+
+    def _get_alsa_devices(self):
+        try:
+            return alsaaudio.cards()
+        except Exception:
+            return []
+
+    def _get_pulseaudio_devices(self):
+        try:
+            pulse = pulsectl.Pulse("dualsense-audio")
+            return pulse.sink_list()
+        except Exception:
+            return []
+
+    def _detect_dualsense_audio(self):
+        # Check ALSA names
+        for card in self.alsa_devices:
+            if "DualSense" in card:
+                return {'type': 'alsa', 'name': card}
+
+        # Check PulseAudio sinks
+        for sink in self.pulse_devices:
+            if "dualsense" in sink.description.lower():
+                return {'type': 'pulse', 'name': sink.name}
+
+        return None
+
+    def play_tone(self, frequency=440.0, duration=2.0, volume=0.5):
+        if not self.dualsense_audio_device:
+            print("DualSense speaker not detected.")
+            return
+
+        print(f"Playing tone on DualSense ({self.dualsense_audio_device['type']})...")
+
+        fs = 48000  # Sample rate
+        t = np.linspace(0, duration, int(fs * duration), False)
+        tone = np.sin(frequency * 2 * np.pi * t) * volume
+        audio = tone.astype(np.float32)
+
+        try:
+            if self.dualsense_audio_device['type'] == 'pulse':
+                sd.play(audio, samplerate=fs, device=self.dualsense_audio_device['name'])
+            elif self.dualsense_audio_device['type'] == 'alsa':
+                device_index = self.alsa_devices.index(self.dualsense_audio_device['name'])
+                sd.play(audio, samplerate=fs, device=device_index)
+            sd.wait()
+        except Exception as e:
+            print("Failed to play tone:", e)
+
+    def list_audio_devices(self):
+        print("ALSA Devices:")
+        for card in self.alsa_devices:
+            print(f" - {card}")
+        print("\nPulseAudio Devices:")
+        for sink in self.pulse_devices:
+            print(f" - {sink.name} ({sink.description})")
+
+    # ---------------------- Cleanup ----------------------
+
+    def close(self):
+        self.ds.close()
+
+if __name__ == "__main__":
+    
+    controller = DualSenseController()
+
+    # Bind buttons to patterns
+    controller.bind("cross", lambda: controller.rumble_pattern("heartbeat", 1.5))
+    controller.bind("circle", lambda: controller.rumble_pattern("buzz", 0.5))
+    controller.bind("triangle", lambda: controller.rumble_pattern("pulse", 2))
+    controller.bind("square", lambda: controller.set_led_color(255, 0, 0))
+
+    # Start listening
+    controller.start_input_listener()

pygamecontrols-0.0.4/pygameControls/generic_controller.py

@@ -0,0 +1,45 @@
+import pygame
+from pygameControls.controlsbase import ControlsBase
+        
+class GenericController(ControlsBase):
+    def __init__(self, joy):
+        self.device = joy
+        self.instance_id: int = self.device.get_instance_id()
+        self.name = self.device.get_name()
+        self.guid = self.device.get_guid()
+        self.numaxis: int = self.device.get_numaxes()
+        self.axis: list = [self.device.get_axis(a) for a in range(self.numaxis)]
+        self.numhats: int = self.device.get_numhats()
+        self.hats: list = [self.device.get_hat(h) for h in range(self.numhats)]
+        self.numbuttons: int = self.device.get_numbuttons()
+        self.buttons: list = [self.device.get_button(b) for b in range(self.numbuttons)]
+    
+    def handle_input(self, event):
+        pass
+    
+    def left(self):
+        pass
+    
+    def right(self):
+        pass
+    
+    def up(self):
+        pass
+    
+    def down(self):
+        pass
+    
+    def pause(self):
+        pass
+    
+    def rumble(self):
+        pass
+    
+    @property
+    def name(self) -> str:
+        return self._name
+    
+    @name.setter
+    def name(self, name: str) -> None:
+        self._name = name
+    

pygamecontrols-0.0.4/pygameControls/logitech_dual_action_controller.py

@@ -0,0 +1,74 @@
+"""
+Logitech F310 Controller class.
+This controller is a usb controller, with the following features.
+(XInput mode)
+6 axis
+11 buttons
+1 hat
+
+(DirectInput mode)
+4 axis
+12 buttons
+1 hat
+"""
+
+import pygame
+from pygameControls.controlsbase import ControlsBase
+from enum import Enum
+
+class InputMode(Enum):
+    DirectInput = 1
+    XInput = 2
+    
+class LogitechDualActionController(ControlsBase):
+    def __init__(self, joy):
+        self.device = joy
+        self.instance_id: int = self.device.get_instance_id()
+        self.name = self.device.get_name()
+        self.guid = self.device.get_guid()
+        self.powerlevel = self.device.get_power_level()
+        self.numaxis: int = self.device.get_numaxes()
+        self.axis: list = [self.device.get_axis(a) for a in range(self.numaxis)]
+        self.numhats: int = self.device.get_numhats()
+        self.hats: list = [self.device.get_hat(h) for h in range(self.numhats)]
+        self.numbuttons: int = self.device.get_numbuttons()
+        self.buttons: list = [self.device.get_button(b) for b in range(self.numbuttons)]
+        self.input_mode = InputMode.DirectInput
+    
+    def handle_input(self, event):
+        pass
+    
+    def left(self):
+        pass
+    
+    def right(self):
+        pass
+    
+    def up(self):
+        pass
+    
+    def down(self):
+        pass
+    
+    def pause(self):
+        pass
+    
+    def rumble(self):
+        pass
+    
+    @property
+    def name(self) -> str:
+        return self._name
+    
+    @name.setter
+    def name(self, name: str) -> None:
+        self._name = name
+    
+    @property
+    def input_mode(self) -> int:
+        return self._inputmode
+    
+    @input_mode.setter
+    def input_mode(self, mode: int) -> None:
+        self._inputmode = mode
+    

pygamecontrols-0.0.4/pygameControls/logitech_f310_controller.py

@@ -0,0 +1,74 @@
+"""
+Logitech F310 Controller class.
+This controller is a usb controller, with the following features.
+(XInput mode)
+6 axis
+11 buttons
+1 hat
+
+(DirectInput mode)
+4 axis
+12 buttons
+1 hat
+"""
+
+import pygame
+from pygameControls.controlsbase import ControlsBase
+from enum import Enum
+
+class InputMode(Enum):
+    DirectInput = 1
+    XInput = 2
+    
+class LogitechF310Controller(ControlsBase):
+    def __init__(self, joy):
+        self.device = joy
+        self.instance_id: int = self.device.get_instance_id()
+        self.name = self.device.get_name()
+        self.guid = self.device.get_guid()
+        self.powerlevel = self.device.get_power_level()
+        self.numaxis: int = self.device.get_numaxes()
+        self.axis: list = [self.device.get_axis(a) for a in range(self.numaxis)]
+        self.numhats: int = self.device.get_numhats()
+        self.hats: list = [self.device.get_hat(h) for h in range(self.numhats)]
+        self.numbuttons: int = self.device.get_numbuttons()
+        self.buttons: list = [self.device.get_button(b) for b in range(self.numbuttons)]
+        self.input_mode = InputMode.XInput
+    
+    def handle_input(self, event):
+        pass
+    
+    def left(self):
+        pass
+    
+    def right(self):
+        pass
+    
+    def up(self):
+        pass
+    
+    def down(self):
+        pass
+    
+    def pause(self):
+        pass
+    
+    def rumble(self):
+        pass
+    
+    @property
+    def name(self) -> str:
+        return self._name
+    
+    @name.setter
+    def name(self, name: str) -> None:
+        self._name = name
+    
+    @property
+    def input_mode(self) -> int:
+        return self._inputmode
+    
+    @input_mode.setter
+    def input_mode(self, mode: int) -> None:
+        self._inputmode = mode
+    

pygamecontrols-0.0.4/pygameControls/logitech_f510_controller.py

@@ -0,0 +1,108 @@
+"""
+Logitech F310 Controller class.
+This controller is a usb controller, with the following features.
+(XInput mode)
+6 axis
+11 buttons
+1 hat
+
+(DirectInput mode)
+4 axis
+12 buttons
+1 hat
+"""
+
+import pygame
+from pygameControls.controlsbase import ControlsBase
+from enum import Enum
+
+class InputMode(Enum):
+    DirectInput = 1
+    XInput = 2
+
+class ConnectionType(Enum):
+    WIRED = 1
+    WIRELESS = 2
+    
+class LogitechF510Controller(ControlsBase):
+    def __init__(self, joy):
+        self.device = joy
+        self.instance_id: int = self.device.get_instance_id()
+        self.name = self.device.get_name()
+        self.numaxis: int = self.device.get_numaxis()
+        self.axis: list = []
+        self.numhats: int = self.device.get_numhats()
+        self.hats: list = []
+        self.numbuttons: int = self.device.get_numbuttons()
+        self.buttons: list = []
+        self.input_mode: InputMode.DirectInput
+        self.input_connection: ConnectionType.WIRED
+    
+    def handle_input(self, event):
+        pass
+    
+    def left(self):
+        pass
+    
+    def right(self):
+        pass
+    
+    def up(self):
+        pass
+    
+    def down(self):
+        pass
+    
+    def pause(self):
+        pass
+    
+    def rumble(self):
+        pass
+    
+    @property
+    def name(self) -> str:
+        return self._name
+    
+    @name.setter
+    def name(self, name: str) -> None:
+        self._name = name
+    
+    @property
+    def axis(self) -> list:
+        return self._axis
+    
+    @axis.setter
+    def axis(self) -> None:
+        self._axis = [self.device.get_axis(a) for a in range(self.numaxis)]
+    
+    @property
+    def hats(self) -> list:
+        return self._hats
+    
+    @hats.setter
+    def hats(self) -> None:
+        self.hats = [self.device.get_hats(h) for h in range(self.numhats)]
+    
+    @property
+    def buttons(self) -> list:
+        return self._buttons
+    
+    @buttons.setter
+    def buttons(self) -> None:
+        self._buttons = [self.device.get_buttons(b) for b in range(self.numbuttons)]
+    
+    @property
+    def input_mode(self) -> int:
+        return self._inputmode
+    
+    @input_mode.setter
+    def input_mode(self, mode: int) -> None:
+        self._inputmode = mode
+    
+    @property
+    def input_connection(self) -> int:
+        return self._input_connection
+    
+    @input_connection.setter
+    def input_connection(self, conn: int) -> None:
+        self._input_connection = conn

pygamecontrols-0.0.4/pygameControls/logitech_f710_controller.py

@@ -0,0 +1,108 @@
+"""
+Logitech F310 Controller class.
+This controller is a usb controller, with the following features.
+(XInput mode)
+6 axis
+11 buttons
+1 hat
+
+(DirectInput mode)
+4 axis
+12 buttons
+1 hat
+"""
+
+import pygame
+from pygameControls.controlsbase import ControlsBase
+from enum import Enum
+
+class InputMode(Enum):
+    DirectInput = 1
+    XInput = 2
+
+class ConnectionType(Enum):
+    WIRED = 1
+    WIRELESS = 2
+    
+class LogitechF710Controller(ControlsBase):
+    def __init__(self, joy):
+        self.device = joy
+        self.instance_id: int = self.device.get_instance_id()
+        self.name = self.device.get_name()
+        self.numaxis: int = self.device.get_numaxis()
+        self.axis: list = []
+        self.numhats: int = self.device.get_numhats()
+        self.hats: list = []
+        self.numbuttons: int = self.device.get_numbuttons()
+        self.buttons: list = []
+        self.input_mode: InputMode.DirectInput
+        self.input_connection: ConnectionType.WIRED
+    
+    def handle_input(self, event):
+        pass
+    
+    def left(self):
+        pass
+    
+    def right(self):
+        pass
+    
+    def up(self):
+        pass
+    
+    def down(self):
+        pass
+    
+    def pause(self):
+        pass
+    
+    def rumble(self):
+        pass
+    
+    @property
+    def name(self) -> str:
+        return self._name
+    
+    @name.setter
+    def name(self, name: str) -> None:
+        self._name = name
+    
+    @property
+    def axis(self) -> list:
+        return self._axis
+    
+    @axis.setter
+    def axis(self) -> None:
+        self._axis = [self.device.get_axis(a) for a in range(self.numaxis)]
+    
+    @property
+    def hats(self) -> list:
+        return self._hats
+    
+    @hats.setter
+    def hats(self) -> None:
+        self.hats = [self.device.get_hats(h) for h in range(self.numhats)]
+    
+    @property
+    def buttons(self) -> list:
+        return self._buttons
+    
+    @buttons.setter
+    def buttons(self) -> None:
+        self._buttons = [self.device.get_buttons(b) for b in range(self.numbuttons)]
+    
+    @property
+    def input_mode(self) -> int:
+        return self._inputmode
+    
+    @input_mode.setter
+    def input_mode(self, mode: int) -> None:
+        self._inputmode = mode
+    
+    @property
+    def input_connection(self) -> int:
+        return self._input_connection
+    
+    @input_connection.setter
+    def input_connection(self, conn: int) -> None:
+        self._input_connection = conn

pygamecontrols-0.0.4/pygameControls/xbox_series_x_controller.py

@@ -0,0 +1,45 @@
+import time
+import threading
+
+class XboxSeriesXController:
+    def __init__(self, joy):
+        self.device = joy
+        self.instance_id: int = self.device.get_instance_id()
+        self.name = self.device.get_name()
+        self.guid = self.device.get_guid()
+        self.numaxis: int = self.device.get_numaxes()
+        self.axis: list = [self.device.get_axis(a) for a in range(self.numaxis)]
+        self.numhats: int = self.device.get_numhats()
+        self.hats: list = [self.device.get_hat(h) for h in range(self.numhats)]
+        self.numbuttons: int = self.device.get_numbuttons()
+        self.buttons: list = [self.device.get_button(b) for b in range(self.numbuttons)]
+    
+    def handle_input(self, event):
+        pass
+    
+    def left(self):
+        pass
+    
+    def right(self):
+        pass
+    
+    def up(self):
+        pass
+    
+    def down(self):
+        pass
+    
+    def pause(self):
+        pass
+    
+    def rumble(self):
+        pass
+    
+    @property
+    def name(self) -> str:
+        return self._name
+    
+    @name.setter
+    def name(self, name: str) -> None:
+        self._name = name
+    

pygamecontrols-0.0.4/pygameControls.egg-info/PKG-INFO

@@ -0,0 +1,24 @@
+Metadata-Version: 2.4
+Name: pygameControls
+Version: 0.0.4
+Summary: A simple controller class for pygame.
+Home-page: 
+Author: Jan Lerking
+Author-email: 
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: license-file
+Dynamic: requires-python
+Dynamic: summary
+
+# PyGame-Controller
+
+Small module to make it easy to add controller support.

pygamecontrols-0.0.4/pygameControls.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+LICENSE
+README.md
+setup.py
+pygameControls/__init__.py
+pygameControls/controller.py
+pygameControls/controlsbase.py
+pygameControls/dualsense_audio.py
+pygameControls/dualsense_controller.py
+pygameControls/dualsense_edge_controller.py
+pygameControls/generic_controller.py
+pygameControls/logitech_dual_action_controller.py
+pygameControls/logitech_f310_controller.py
+pygameControls/logitech_f510_controller.py
+pygameControls/logitech_f710_controller.py
+pygameControls/xbox_series_x_controller.py
+pygameControls.egg-info/PKG-INFO
+pygameControls.egg-info/SOURCES.txt
+pygameControls.egg-info/dependency_links.txt
+pygameControls.egg-info/top_level.txt

pygamecontrols-0.0.4/pygameControls.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pygamecontrols-0.0.4/pygameControls.egg-info/top_level.txt

@@ -0,0 +1 @@
+pygameControls

pygamecontrols-0.0.4/setup.cfg

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

pygamecontrols-0.0.4/setup.py

@@ -0,0 +1,21 @@
+if __name__ == "__main__":
+    from setuptools import setup, find_packages
+
+    setup(
+        name='pygameControls',
+        version='0.0.4',
+        packages=find_packages(),
+        install_requires=[],
+        author='Jan Lerking',
+        author_email='',
+        description='A simple controller class for pygame.',
+        long_description=open('README.md').read(),
+        long_description_content_type='text/markdown',
+        url='',
+        classifiers=[
+                    'Programming Language :: Python :: 3',
+                    'License :: OSI Approved :: MIT License',
+                    'Operating System :: OS Independent',
+                    ],
+        python_requires='>=3.12',
+    )