pygameP 0.0.1__py3-none-any.whl

pygameP/__init__.py

@@ -0,0 +1,36 @@
+"""pygameP - Pygame Plus 高级游戏开发框架"""
+
+__version__ = "0.0.1"
+__author__ = "pygameP contributors"
+
+from .shaders import Shader, ShaderEffect, BuiltInEffects
+from .performance import ObjectPool, SpatialHash, FPSMonitor, BatchRenderer
+from .scene import Scene, SceneManager, SceneEntity
+from .physics import RigidBody, PhysicsWorld, Collider, BoxCollider, CircleCollider
+from .input import InputManager, GamepadHandler, TouchHandler
+
+__all__ = [
+    # Shaders
+    "Shader",
+    "ShaderEffect", 
+    "BuiltInEffects",
+    # Performance
+    "ObjectPool",
+    "SpatialHash",
+    "FPSMonitor",
+    "BatchRenderer",
+    # Scene
+    "Scene",
+    "SceneManager",
+    "SceneEntity",
+    # Physics
+    "RigidBody",
+    "PhysicsWorld",
+    "Collider",
+    "BoxCollider",
+    "CircleCollider",
+    # Input
+    "InputManager",
+    "GamepadHandler",
+    "TouchHandler",
+]

pygameP/input.py

@@ -0,0 +1,548 @@
+"""扩展输入设备支持模块"""
+
+from typing import Dict, List, Optional, Tuple, Callable, Any
+import pygame
+
+
+class InputManager:
+    """输入管理器 - 统一管理所有输入设备
+    
+    支持键盘、鼠标、手柄、触摸等多种输入方式。
+    """
+    
+    def __init__(self):
+        """初始化输入管理器"""
+        self.keyboard = KeyboardHandler()
+        self.mouse = MouseHandler()
+        self.gamepads: Dict[int, GamepadHandler] = {}
+        self.touch = TouchHandler()
+        
+        # 输入映射
+        self.action_mappings: Dict[str, List[Tuple[str, Any]]] = {}
+        
+        # 初始化手柄
+        self._init_gamepads()
+    
+    def _init_gamepads(self):
+        """初始化手柄设备"""
+        pygame.joystick.init()
+        for i in range(pygame.joystick.get_count()):
+            joystick = pygame.joystick.Joystick(i)
+            joystick.init()
+            self.gamepads[i] = GamepadHandler(joystick)
+    
+    def update(self, events: List[pygame.event.Event]):
+        """更新所有输入设备状态
+        
+        Args:
+            events: pygame 事件列表
+        """
+        self.keyboard.update(events)
+        self.mouse.update(events)
+        self.touch.update(events)
+        
+        for gamepad in self.gamepads.values():
+            gamepad.update(events)
+    
+    def is_action_pressed(self, action: str) -> bool:
+        """检查动作是否被按下
+        
+        Args:
+            action: 动作名称
+        
+        Returns:
+            是否按下
+        """
+        if action not in self.action_mappings:
+            return False
+        
+        for device, binding in self.action_mappings[action]:
+            if device == 'keyboard' and self.keyboard.is_key_pressed(binding):
+                return True
+            elif device == 'mouse' and self.mouse.is_button_pressed(binding):
+                return True
+            elif device == 'gamepad':
+                pad_id, button = binding
+                if pad_id in self.gamepads:
+                    return self.gamepads[pad_id].is_button_pressed(button)
+        
+        return False
+    
+    def is_action_just_pressed(self, action: str) -> bool:
+        """检查动作是否刚刚被按下
+        
+        Args:
+            action: 动作名称
+        
+        Returns:
+            是否刚刚按下
+        """
+        if action not in self.action_mappings:
+            return False
+        
+        for device, binding in self.action_mappings[action]:
+            if device == 'keyboard' and self.keyboard.is_key_just_pressed(binding):
+                return True
+            elif device == 'mouse' and self.mouse.is_button_just_pressed(binding):
+                return True
+            elif device == 'gamepad':
+                pad_id, button = binding
+                if pad_id in self.gamepads:
+                    return self.gamepads[pad_id].is_button_just_pressed(button)
+        
+        return False
+    
+    def is_action_just_released(self, action: str) -> bool:
+        """检查动作是否刚刚被释放
+        
+        Args:
+            action: 动作名称
+        
+        Returns:
+            是否刚刚释放
+        """
+        if action not in self.action_mappings:
+            return False
+        
+        for device, binding in self.action_mappings[action]:
+            if device == 'keyboard' and self.keyboard.is_key_just_released(binding):
+                return True
+            elif device == 'mouse' and self.mouse.is_button_just_released(binding):
+                return True
+            elif device == 'gamepad':
+                pad_id, button = binding
+                if pad_id in self.gamepads:
+                    return self.gamepads[pad_id].is_button_just_released(button)
+        
+        return False
+    
+    def get_action_value(self, action: str) -> float:
+        """获取动作的模拟值（用于手柄摇杆等）
+        
+        Args:
+            action: 动作名称
+        
+        Returns:
+            动作值 (-1.0 到 1.0)
+        """
+        if action not in self.action_mappings:
+            return 0.0
+        
+        for device, binding in self.action_mappings[action]:
+            if device == 'gamepad':
+                pad_id, axis = binding
+                if pad_id in self.gamepads:
+                    return self.gamepads[pad_id].get_axis(axis)
+        
+        # 数字输入返回 0 或 1
+        return 1.0 if self.is_action_pressed(action) else 0.0
+    
+    def map_action(self, action: str, device: str, binding: Any):
+        """映射动作到输入
+        
+        Args:
+            action: 动作名称
+            device: 设备类型 ('keyboard', 'mouse', 'gamepad')
+            binding: 绑定值（键码、按钮索引等）
+        """
+        if action not in self.action_mappings:
+            self.action_mappings[action] = []
+        
+        self.action_mappings[action].append((device, binding))
+    
+    def unmap_action(self, action: str):
+        """移除动作映射
+        
+        Args:
+            action: 动作名称
+        """
+        if action in self.action_mappings:
+            del self.action_mappings[action]
+    
+    def get_gamepad_count(self) -> int:
+        """获取连接的手柄数量"""
+        return len(self.gamepads)
+    
+    def get_gamepad(self, index: int) -> Optional['GamepadHandler']:
+        """获取指定索引的手柄
+        
+        Args:
+            index: 手柄索引
+        
+        Returns:
+            手柄处理器或 None
+        """
+        return self.gamepads.get(index)
+
+
+class KeyboardHandler:
+    """键盘输入处理器"""
+    
+    def __init__(self):
+        """初始化键盘处理器"""
+        self.keys_pressed = set()
+        self.keys_just_pressed = set()
+        self.keys_just_released = set()
+    
+    def update(self, events: List[pygame.event.Event]):
+        """更新键盘状态
+        
+        Args:
+            events: pygame 事件列表
+        """
+        self.keys_just_pressed.clear()
+        self.keys_just_released.clear()
+        
+        for event in events:
+            if event.type == pygame.KEYDOWN:
+                self.keys_pressed.add(event.key)
+                self.keys_just_pressed.add(event.key)
+            elif event.type == pygame.KEYUP:
+                self.keys_pressed.discard(event.key)
+                self.keys_just_released.add(event.key)
+    
+    def is_key_pressed(self, key: int) -> bool:
+        """检查键是否被按下
+        
+        Args:
+            key: pygame 键码
+        
+        Returns:
+            是否按下
+        """
+        return key in self.keys_pressed
+    
+    def is_key_just_pressed(self, key: int) -> bool:
+        """检查键是否刚刚被按下
+        
+        Args:
+            key: pygame 键码
+        
+        Returns:
+            是否刚刚按下
+        """
+        return key in self.keys_just_pressed
+    
+    def is_key_just_released(self, key: int) -> bool:
+        """检查键是否刚刚被释放
+        
+        Args:
+            key: pygame 键码
+        
+        Returns:
+            是否刚刚释放
+        """
+        return key in self.keys_just_released
+    
+    def get_pressed_keys(self) -> set:
+        """获取所有按下的键"""
+        return self.keys_pressed.copy()
+
+
+class MouseHandler:
+    """鼠标输入处理器"""
+    
+    def __init__(self):
+        """初始化鼠标处理器"""
+        self.position = (0, 0)
+        self.rel_motion = (0, 0)
+        self.buttons_pressed = set()
+        self.buttons_just_pressed = set()
+        self.buttons_just_released = set()
+        self.scroll_amount = 0
+    
+    def update(self, events: List[pygame.event.Event]):
+        """更新鼠标状态
+        
+        Args:
+            events: pygame 事件列表
+        """
+        self.buttons_just_pressed.clear()
+        self.buttons_just_released.clear()
+        self.rel_motion = (0, 0)
+        self.scroll_amount = 0
+        
+        for event in events:
+            if event.type == pygame.MOUSEMOTION:
+                self.position = event.pos
+                self.rel_motion = event.rel
+            elif event.type == pygame.MOUSEBUTTONDOWN:
+                self.buttons_pressed.add(event.button)
+                self.buttons_just_pressed.add(event.button)
+                self.position = event.pos
+            elif event.type == pygame.MOUSEBUTTONUP:
+                self.buttons_pressed.discard(event.button)
+                self.buttons_just_released.add(event.button)
+                self.position = event.pos
+            elif event.type == pygame.MOUSEWHEEL:
+                self.scroll_amount = event.y
+    
+    def is_button_pressed(self, button: int) -> bool:
+        """检查鼠标按钮是否被按下
+        
+        Args:
+            button: 按钮索引 (1=左, 2=中, 3=右)
+        
+        Returns:
+            是否按下
+        """
+        return button in self.buttons_pressed
+    
+    def is_button_just_pressed(self, button: int) -> bool:
+        """检查鼠标按钮是否刚刚被按下
+        
+        Args:
+            button: 按钮索引
+        
+        Returns:
+            是否刚刚按下
+        """
+        return button in self.buttons_just_pressed
+    
+    def is_button_just_released(self, button: int) -> bool:
+        """检查鼠标按钮是否刚刚被释放
+        
+        Args:
+            button: 按钮索引
+        
+        Returns:
+            是否刚刚释放
+        """
+        return button in self.buttons_just_released
+    
+    def get_position(self) -> Tuple[int, int]:
+        """获取鼠标位置"""
+        return self.position
+    
+    def get_relative_motion(self) -> Tuple[int, int]:
+        """获取相对运动"""
+        return self.rel_motion
+    
+    def get_scroll(self) -> int:
+        """获取滚轮滚动量"""
+        return self.scroll_amount
+
+
+class GamepadHandler:
+    """手柄输入处理器"""
+    
+    def __init__(self, joystick: pygame.joystick.Joystick):
+        """初始化手柄处理器
+        
+        Args:
+            joystick: pygame Joystick 对象
+        """
+        self.joystick = joystick
+        self.buttons_pressed = set()
+        self.buttons_just_pressed = set()
+        self.buttons_just_released = set()
+        self.axes = {}
+        self.hats = {}
+        
+        # 初始化轴和帽子状态
+        for i in range(joystick.get_numaxes()):
+            self.axes[i] = 0.0
+        for i in range(joystick.get_numhats()):
+            self.hats[i] = (0, 0)
+    
+    def update(self, events: List[pygame.event.Event]):
+        """更新手柄状态
+        
+        Args:
+            events: pygame 事件列表
+        """
+        self.buttons_just_pressed.clear()
+        self.buttons_just_released.clear()
+        
+        for event in events:
+            if event.type == pygame.JOYBUTTONDOWN:
+                if event.joy == self.joystick.get_id():
+                    self.buttons_pressed.add(event.button)
+                    self.buttons_just_pressed.add(event.button)
+            elif event.type == pygame.JOYBUTTONUP:
+                if event.joy == self.joystick.get_id():
+                    self.buttons_pressed.discard(event.button)
+                    self.buttons_just_released.add(event.button)
+            elif event.type == pygame.JOYAXISMOTION:
+                if event.joy == self.joystick.get_id():
+                    self.axes[event.axis] = event.value
+            elif event.type == pygame.JOYHATMOTION:
+                if event.joy == self.joystick.get_id():
+                    self.hats[event.hat] = event.value
+    
+    def is_button_pressed(self, button: int) -> bool:
+        """检查按钮是否被按下
+        
+        Args:
+            button: 按钮索引
+        
+        Returns:
+            是否按下
+        """
+        return button in self.buttons_pressed
+    
+    def is_button_just_pressed(self, button: int) -> bool:
+        """检查按钮是否刚刚被按下
+        
+        Args:
+            button: 按钮索引
+        
+        Returns:
+            是否刚刚按下
+        """
+        return button in self.buttons_just_pressed
+    
+    def is_button_just_released(self, button: int) -> bool:
+        """检查按钮是否刚刚被释放
+        
+        Args:
+            button: 按钮索引
+        
+        Returns:
+            是否刚刚释放
+        """
+        return button in self.buttons_just_released
+    
+    def get_axis(self, axis: int) -> float:
+        """获取摇杆轴的值
+        
+        Args:
+            axis: 轴索引
+        
+        Returns:
+            轴值 (-1.0 到 1.0)
+        """
+        return self.axes.get(axis, 0.0)
+    
+    def get_left_stick(self) -> Tuple[float, float]:
+        """获取左摇杆值
+        
+        Returns:
+            (x, y) 摇杆值
+        """
+        return (self.axes.get(0, 0.0), self.axes.get(1, 0.0))
+    
+    def get_right_stick(self) -> Tuple[float, float]:
+        """获取右摇杆值
+        
+        Returns:
+            (x, y) 摇杆值
+        """
+        return (self.axes.get(2, 0.0), self.axes.get(3, 0.0))
+    
+    def get_hat(self, hat: int = 0) -> Tuple[int, int]:
+        """获取方向帽值
+        
+        Args:
+            hat: 帽子索引
+        
+        Returns:
+            (x, y) 方向值 (-1, 0, 1)
+        """
+        return self.hats.get(hat, (0, 0))
+    
+    def get_name(self) -> str:
+        """获取手柄名称"""
+        return self.joystick.get_name()
+    
+    def rumble(self, low_freq: float, high_freq: float, duration: int):
+        """手柄震动（如果支持）
+        
+        Args:
+            low_freq: 低频震动强度 (0.0-1.0)
+            high_freq: 高频震动强度 (0.0-1.0)
+            duration: 持续时间（毫秒）
+        """
+        try:
+            self.joystick.rumble(low_freq, high_freq, duration)
+        except:
+            # 某些手柄不支持震动
+            pass
+
+
+class TouchHandler:
+    """触摸输入处理器"""
+    
+    def __init__(self):
+        """初始化触摸处理器"""
+        self.touches: Dict[int, Tuple[int, int]] = {}
+        self.touches_just_started: Dict[int, Tuple[int, int]] = {}
+        self.touches_just_ended: List[int] = []
+    
+    def update(self, events: List[pygame.event.Event]):
+        """更新触摸状态
+        
+        Args:
+            events: pygame 事件列表
+        """
+        self.touches_just_started.clear()
+        self.touches_just_ended.clear()
+        
+        for event in events:
+            if event.type == pygame.FINGERDOWN:
+                touch_id = event.finger_id
+                pos = (int(event.x * pygame.display.get_surface().get_width()),
+                       int(event.y * pygame.display.get_surface().get_height()))
+                self.touches[touch_id] = pos
+                self.touches_just_started[touch_id] = pos
+            elif event.type == pygame.FINGERUP:
+                touch_id = event.finger_id
+                if touch_id in self.touches:
+                    del self.touches[touch_id]
+                self.touches_just_ended.append(touch_id)
+            elif event.type == pygame.FINGERMOTION:
+                touch_id = event.finger_id
+                if touch_id in self.touches:
+                    pos = (int(event.x * pygame.display.get_surface().get_width()),
+                           int(event.y * pygame.display.get_surface().get_height()))
+                    self.touches[touch_id] = pos
+    
+    def is_touching(self) -> bool:
+        """检查是否有触摸"""
+        return len(self.touches) > 0
+    
+    def get_touch_count(self) -> int:
+        """获取当前触摸点数量"""
+        return len(self.touches)
+    
+    def get_touch_position(self, finger_id: int = 0) -> Optional[Tuple[int, int]]:
+        """获取触摸位置
+        
+        Args:
+            finger_id: 手指 ID（默认为第一个触摸点）
+        
+        Returns:
+            触摸位置或 None
+        """
+        if finger_id in self.touches:
+            return self.touches[finger_id]
+        
+        # 返回第一个触摸点
+        if self.touches:
+            return list(self.touches.values())[0]
+        
+        return None
+    
+    def get_all_touches(self) -> Dict[int, Tuple[int, int]]:
+        """获取所有触摸点
+        
+        Returns:
+            {finger_id: position} 字典
+        """
+        return self.touches.copy()
+    
+    def is_touch_just_started(self) -> bool:
+        """检查是否有新的触摸开始"""
+        return len(self.touches_just_started) > 0
+    
+    def is_touch_just_ended(self) -> bool:
+        """检查是否有触摸结束"""
+        return len(self.touches_just_ended) > 0
+    
+    def get_new_touches(self) -> Dict[int, Tuple[int, int]]:
+        """获取新开始的触摸
+        
+        Returns:
+            {finger_id: position} 字典
+        """
+        return self.touches_just_started.copy()