frontengine 1.0.2__tar.gz → 1.0.4__tar.gz

{frontengine-1.0.2 → frontengine-1.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: frontengine
-Version: 1.0.2
+Version: 1.0.4
 Summary: FrontEngine is use-define frontview or only use like screen saver
 Author-email: JE-Chen <jechenmailman@gmail.com>
 Project-URL: Homepage, https://github.com/Intergration-Automation-Testing/FrontEngine

frontengine-1.0.4/frontengine/show/pet/desktop_pet.py

@@ -0,0 +1,375 @@
+import random as _random_module
+from pathlib import Path
+from typing import Optional, Tuple
+
+from PySide6.QtCore import Qt, QRect, QTimer, Signal
+from PySide6.QtGui import QAction, QCursor, QMovie, QPainter, QPixmap, QTransform
+from PySide6.QtWidgets import QMenu, QMessageBox
+
+from frontengine.show.base_widget import BaseWidget
+from frontengine.show.window_helpers import apply_overlay_window_flags
+from frontengine.utils.logging.loggin_instance import front_engine_logger
+from frontengine.utils.multi_language.language_wrapper import language_wrapper
+
+# 行為模式 / Behaviour modes
+BEHAVIOUR_FLOOR = "floor"    # walk on the floor with gravity, throw & bounce
+BEHAVIOUR_WANDER = "wander"  # free 2D bounce, no gravity
+BEHAVIOUR_CHASE = "chase"    # chase the mouse cursor, sleep when caught
+
+# 攀爬時所在的表面 / Surface the pet is crawling on while climbing
+SURFACE_FLOOR = "floor"
+SURFACE_LEFT = "left"
+SURFACE_CEILING = "ceiling"
+SURFACE_RIGHT = "right"
+
+
+class PetMotion:
+    """
+    純邏輯的寵物移動模型（不依賴 Qt，完全可測試）。包含：
+      - 重力落下、落地、彈跳（受動量丟出後）
+      - 走路/發呆的隨機行為狀態機（rng 可注入以利測試）
+      - 追逐游標模式（追到後進入睡眠，游標移動即醒）
+    A pure, Qt-free motion model: gravity fall/land/bounce (after a throw),
+    a random walk/idle behaviour state machine (injectable rng), and a
+    cursor-chase mode that sleeps once it catches the target.
+    """
+
+    GRAVITY = 2.0
+    BOUNCE_DAMPING = 0.55
+    WALL_DAMPING = 0.6
+    BOUNCE_THRESHOLD = 8.0
+    CHASE_STOP_DISTANCE = 10.0
+    CHASE_SPEED_FACTOR = 2.0
+    CLIMB_CHANCE = 0.5      # chance to grab a wall (vs. turn around) at a floor corner
+    DROP_CHANCE = 0.008     # chance per step to let go while on a wall/ceiling
+
+    def __init__(
+        self,
+        x: int,
+        y: int,
+        width: int,
+        height: int,
+        bounds: Tuple[int, int, int, int],
+        speed: int = 3,
+        behaviour: str = BEHAVIOUR_FLOOR,
+        rng=None,
+        climb: bool = True,
+    ) -> None:
+        self.x = float(x)
+        self.y = float(y)
+        self.width = int(width)
+        self.height = int(height)
+        self.bounds = bounds  # (left, top, right, bottom)
+        self.speed = max(1, int(speed))
+        self.behaviour = behaviour
+        self._rng = rng if rng is not None else _random_module.SystemRandom()
+        self.vx = float(self.speed)
+        self.vy = 0.0 if behaviour != BEHAVIOUR_WANDER else float(self.speed)
+        self._airborne = False
+        self.state = "walk"  # walk | idle
+        self._state_ticks = 0
+        self.target: Optional[Tuple[float, float]] = None
+        self.asleep = False
+        self.climb = bool(climb)
+        self.surface = SURFACE_FLOOR
+
+    @property
+    def facing_left(self) -> bool:
+        return self.vx < 0
+
+    def set_bounds(self, bounds: Tuple[int, int, int, int]) -> None:
+        self.bounds = bounds
+
+    def set_target(self, x: float, y: float) -> None:
+        self.target = (float(x), float(y))
+
+    def throw(self, vx: float, vy: float) -> None:
+        """拖曳放開後以動量丟出（只在重力模式有意義）。"""
+        self.vx = float(vx)
+        self.vy = float(vy)
+        self._airborne = True
+        self.asleep = False
+        self.surface = SURFACE_FLOOR
+
+    def step(self) -> Tuple[int, int]:
+        left, top, right, bottom = self.bounds
+        floor_y = bottom - self.height
+        if self.behaviour == BEHAVIOUR_CHASE:
+            return self._step_chase(left, top, right, bottom)
+        if self.behaviour == BEHAVIOUR_WANDER:
+            return self._step_wander(left, top, right, bottom)
+        return self._step_floor(left, top, right, bottom, floor_y)
+
+    # --- floor / gravity / climbing ---
+    def _step_floor(self, left, top, right, bottom, floor_y) -> Tuple[int, int]:
+        airborne = self._airborne or (self.surface == SURFACE_FLOOR and self.y < floor_y - 0.5)
+        if airborne:
+            self.vy += self.GRAVITY
+            self.x += self.vx
+            self.y += self.vy
+            if self.x <= left:
+                self.x = float(left)
+                self.vx = abs(self.vx) * self.WALL_DAMPING
+            elif self.x + self.width >= right:
+                self.x = float(right - self.width)
+                self.vx = -abs(self.vx) * self.WALL_DAMPING
+            if self.y <= top:
+                self.y = float(top)
+                self.vy = abs(self.vy) * self.WALL_DAMPING
+            if self.y >= floor_y:
+                self.y = float(floor_y)
+                if abs(self.vy) > self.BOUNCE_THRESHOLD:
+                    self.vy = -self.vy * self.BOUNCE_DAMPING
+                else:
+                    self.vy = 0.0
+                    self._airborne = False
+                    self.surface = SURFACE_FLOOR
+                    self.vx = float(self.speed) if self.vx >= 0 else float(-self.speed)
+                    self._new_state(force_walk=True)
+            return int(self.x), int(self.y)
+
+        if self.surface != SURFACE_FLOOR:
+            return self._step_climb(left, top, right, bottom, floor_y)
+
+        # grounded on the floor: random walk / idle, with a chance to climb a wall
+        self.y = float(floor_y)
+        if self._state_ticks <= 0:
+            self._new_state()
+        self._state_ticks -= 1
+        if self.state != "walk":
+            return int(self.x), int(self.y)
+        self.x += self.vx
+        if self.x <= left:
+            self.x = float(left)
+            if self.climb and self._rng.random() < self.CLIMB_CHANCE:
+                self.surface = SURFACE_LEFT
+                self.vy = float(-self.speed)
+            else:
+                self.vx = abs(self.vx)
+        elif self.x + self.width >= right:
+            self.x = float(right - self.width)
+            if self.climb and self._rng.random() < self.CLIMB_CHANCE:
+                self.surface = SURFACE_RIGHT
+                self.vy = float(-self.speed)
+            else:
+                self.vx = -abs(self.vx)
+        return int(self.x), int(self.y)
+
+    def _step_climb(self, left, top, right, bottom, floor_y) -> Tuple[int, int]:
+        """沿螢幕邊緣爬行；隨機放手則掉落 / Crawl the screen perimeter; may let go and fall."""
+        if self._rng.random() < self.DROP_CHANCE:
+            self.surface = SURFACE_FLOOR
+            self._airborne = True
+            self.vy = 1.0
+            return int(self.x), int(self.y)
+
+        if self.surface == SURFACE_RIGHT:
+            self.x = float(right - self.width)
+            self.y += self.vy
+            if self.vy < 0 and self.y <= top:            # reached the ceiling, crawl left
+                self.y = float(top)
+                self.surface = SURFACE_CEILING
+                self.vx = float(-self.speed)
+            elif self.vy > 0 and self.y >= floor_y:      # climbed back down
+                self.y = float(floor_y)
+                self.surface = SURFACE_FLOOR
+                self.vx = float(-self.speed)
+                self._new_state(force_walk=True)
+        elif self.surface == SURFACE_LEFT:
+            self.x = float(left)
+            self.y += self.vy
+            if self.vy < 0 and self.y <= top:
+                self.y = float(top)
+                self.surface = SURFACE_CEILING
+                self.vx = float(self.speed)
+            elif self.vy > 0 and self.y >= floor_y:
+                self.y = float(floor_y)
+                self.surface = SURFACE_FLOOR
+                self.vx = float(self.speed)
+                self._new_state(force_walk=True)
+        elif self.surface == SURFACE_CEILING:
+            self.y = float(top)
+            self.x += self.vx
+            if self.vx < 0 and self.x <= left:           # corner -> climb down the left wall
+                self.x = float(left)
+                self.surface = SURFACE_LEFT
+                self.vy = float(self.speed)
+            elif self.vx > 0 and self.x + self.width >= right:
+                self.x = float(right - self.width)
+                self.surface = SURFACE_RIGHT
+                self.vy = float(self.speed)
+        return int(self.x), int(self.y)
+
+    def _new_state(self, force_walk: bool = False) -> None:
+        if force_walk or self._rng.random() < 0.65:
+            self.state = "walk"
+            if not force_walk:
+                self.vx = float(self.speed) if self._rng.random() < 0.5 else float(-self.speed)
+            self._state_ticks = self._rng.randint(30, 120)
+        else:
+            self.state = "idle"
+            self._state_ticks = self._rng.randint(20, 80)
+
+    # --- free wander ---
+    def _step_wander(self, left, top, right, bottom) -> Tuple[int, int]:
+        if abs(self.vy) < 1e-9:
+            self.vy = float(self.speed)
+        self.x += self.vx
+        self.y += self.vy
+        if self.x <= left:
+            self.x = float(left)
+            self.vx = abs(self.vx)
+        elif self.x + self.width >= right:
+            self.x = float(right - self.width)
+            self.vx = -abs(self.vx)
+        if self.y <= top:
+            self.y = float(top)
+            self.vy = abs(self.vy)
+        elif self.y + self.height >= bottom:
+            self.y = float(bottom - self.height)
+            self.vy = -abs(self.vy)
+        return int(self.x), int(self.y)
+
+    # --- chase cursor ---
+    def _step_chase(self, left, top, right, bottom) -> Tuple[int, int]:
+        if self.target is None:
+            return int(self.x), int(self.y)
+        target_x, target_y = self.target
+        dx = target_x - (self.x + self.width / 2)
+        dy = target_y - (self.y + self.height / 2)
+        distance = (dx * dx + dy * dy) ** 0.5
+        if distance <= self.CHASE_STOP_DISTANCE:
+            self.asleep = True
+            return int(self.x), int(self.y)
+        self.asleep = False
+        step = float(self.speed) * self.CHASE_SPEED_FACTOR
+        self.x += step * (dx / distance)
+        self.y += step * (dy / distance)
+        self.vx = abs(self.vx) if dx >= 0 else -abs(self.vx)
+        self.x = min(max(self.x, float(left)), float(right - self.width))
+        self.y = min(max(self.y, float(top)), float(bottom - self.height))
+        return int(self.x), int(self.y)
+
+
+class DesktopPetWidget(BaseWidget):
+    """
+    桌面寵物：可自主走動、可拖曳丟出、可追游標的動畫精靈。支援 GIF 與靜態圖。
+    A draggable, throwable, cursor-chasing animated sprite (GIF or image).
+    """
+
+    clone_requested = Signal()
+
+    def __init__(self, image_path: str, size: int = 128, speed: int = 3,
+                 behaviour: str = BEHAVIOUR_FLOOR, climb: bool = True):
+        front_engine_logger.info(
+            f"[DesktopPetWidget] Init | path={image_path}, size={size}, speed={speed}, "
+            f"behaviour={behaviour}, climb={climb}"
+        )
+        super().__init__()
+        self.opacity = 1.0
+        self.pet_size: int = max(16, int(size))
+        self.image_path: Path = Path(image_path)
+        self.movie: Optional[QMovie] = None
+        self.pixmap: Optional[QPixmap] = None
+        self._dragging: bool = False
+        self._drag_offset = None
+        self._last_move_delta: Tuple[int, int] = (0, 0)
+
+        if self.image_path.exists() and self.image_path.is_file():
+            if self.image_path.suffix.lower() in (".gif", ".webp"):
+                self.movie = QMovie(str(self.image_path))
+                self.movie.frameChanged.connect(self.update)
+                self.movie.start()
+            else:
+                self.pixmap = QPixmap(str(self.image_path))
+        else:
+            front_engine_logger.error(f"[DesktopPetWidget] File not found: {self.image_path}")
+            message_box = QMessageBox(self)
+            message_box.setText(language_wrapper.language_word_dict.get("pet_message_box_text", "Pet image not found"))
+            message_box.show()
+
+        self.resize(self.pet_size, self.pet_size)
+        self.motion = PetMotion(
+            0, 0, self.pet_size, self.pet_size, (0, 0, 1920, 1080), speed, behaviour, climb=climb
+        )
+
+        self._timer = QTimer(self)
+        self._timer.timeout.connect(self._on_tick)
+
+        self.menu = QMenu(self)
+        self.clone_action = QAction(language_wrapper.language_word_dict.get("pet_clone", "Clone"), self)
+        self.clone_action.triggered.connect(self.clone_requested.emit)
+        self.menu.addAction(self.clone_action)
+        self.close_action = QAction(language_wrapper.language_word_dict.get("control_center_close_all", "Close"), self)
+        self.close_action.triggered.connect(self.close)
+        self.menu.addAction(self.close_action)
+
+    def set_pet_window_flag(self) -> None:
+        """寵物需接收滑鼠以便拖曳，故 allow_input=True 並置頂。"""
+        apply_overlay_window_flags(self, show_on_bottom=False, allow_input=True)
+
+    def _current_pixmap(self) -> Optional[QPixmap]:
+        if self.movie is not None:
+            return self.movie.currentPixmap()
+        return self.pixmap
+
+    def draw_content(self, painter: QPainter) -> None:
+        pixmap = self._current_pixmap()
+        if pixmap is None or pixmap.isNull():
+            return
+        if self.motion.facing_left:
+            pixmap = pixmap.transformed(QTransform().scale(-1, 1))
+        painter.drawPixmap(QRect(0, 0, self.width(), self.height()), pixmap)
+
+    def start_moving(self, bounds: Tuple[int, int, int, int], interval_ms: int = 33) -> None:
+        front_engine_logger.info(f"[DesktopPetWidget] start_moving | bounds={bounds}")
+        left, top, right, bottom = bounds
+        self.motion.set_bounds(bounds)
+        self.motion.x = float(left)
+        self.motion.y = float(bottom - self.pet_size)
+        self.move(int(self.motion.x), int(self.motion.y))
+        self._timer.start(max(10, int(interval_ms)))
+
+    def _on_tick(self) -> None:
+        if self._dragging:
+            return
+        if self.motion.behaviour == BEHAVIOUR_CHASE:
+            cursor = QCursor.pos()
+            self.motion.set_target(cursor.x(), cursor.y())
+        x, y = self.motion.step()
+        self.move(x, y)
+
+    # --- dragging + throwing ---
+    def mousePressEvent(self, event) -> None:
+        if event.button() == Qt.MouseButton.LeftButton:
+            self._dragging = True
+            self._last_move_delta = (0, 0)
+            self._drag_offset = event.globalPosition().toPoint() - self.frameGeometry().topLeft()
+        super().mousePressEvent(event)
+
+    def mouseMoveEvent(self, event) -> None:
+        if self._dragging and self._drag_offset is not None:
+            new_top_left = event.globalPosition().toPoint() - self._drag_offset
+            self._last_move_delta = (new_top_left.x() - self.x(), new_top_left.y() - self.y())
+            self.move(new_top_left)
+        super().mouseMoveEvent(event)
+
+    def mouseReleaseEvent(self, event) -> None:
+        if self._dragging:
+            self._dragging = False
+            self.motion.x = float(self.x())
+            self.motion.y = float(self.y())
+            # Fling with the momentum of the last drag movement (floor mode).
+            if self.motion.behaviour == BEHAVIOUR_FLOOR:
+                self.motion.throw(self._last_move_delta[0], self._last_move_delta[1])
+        super().mouseReleaseEvent(event)
+
+    def contextMenuEvent(self, event) -> None:
+        self.menu.popup(event.globalPos())
+
+    def closeEvent(self, event) -> None:
+        if self._timer.isActive():
+            self._timer.stop()
+        if self.movie is not None:
+            self.movie.stop()
+        super().closeEvent(event)

{frontengine-1.0.2 → frontengine-1.0.4}/frontengine/ui/page/pet/pet_setting_ui.py

@@ -2,10 +2,12 @@ from typing import Optional
 
 from PySide6.QtGui import QGuiApplication
 from PySide6.QtWidgets import (
-    QWidget, QGridLayout, QLabel, QPushButton, QMessageBox, QCheckBox, QComboBox,
+    QWidget, QGridLayout, QLabel, QPushButton, QMessageBox, QComboBox, QCheckBox,
 )
 
-from frontengine.show.pet.desktop_pet import DesktopPetWidget
+from frontengine.show.pet.desktop_pet import (
+    DesktopPetWidget, BEHAVIOUR_FLOOR, BEHAVIOUR_WANDER, BEHAVIOUR_CHASE,
+)
 from frontengine.ui.dialog.choose_file_dialog import choose_pet
 from frontengine.ui.page.utils import (
     build_recent_combobox,
@@ -50,9 +52,19 @@ class PetSettingUI(QWidget):
         self.speed_combobox.addItems([str(n) for n in range(1, 11)])
         self.speed_combobox.setCurrentText("3")
 
-        # Gravity / walk on floor
-        self.gravity_checkbox = QCheckBox(language_wrapper.language_word_dict.get("pet_gravity_label", "Walk on floor"))
-        self.gravity_checkbox.setChecked(True)
+        # Behaviour
+        self.behaviour_label = QLabel(language_wrapper.language_word_dict.get("pet_behaviour_label", "Behaviour"))
+        self.behaviour_combobox = QComboBox()
+        self.behaviour_combobox.addItem(
+            language_wrapper.language_word_dict.get("pet_behaviour_floor", "Walk on floor"), BEHAVIOUR_FLOOR)
+        self.behaviour_combobox.addItem(
+            language_wrapper.language_word_dict.get("pet_behaviour_wander", "Free wander"), BEHAVIOUR_WANDER)
+        self.behaviour_combobox.addItem(
+            language_wrapper.language_word_dict.get("pet_behaviour_chase", "Chase cursor"), BEHAVIOUR_CHASE)
+
+        # Climb walls / ceiling (only meaningful in floor mode)
+        self.climb_checkbox = QCheckBox(language_wrapper.language_word_dict.get("pet_climb_label", "Climb walls"))
+        self.climb_checkbox.setChecked(True)
 
         # Start
         self.start_button = QPushButton(language_wrapper.language_word_dict.get("pet_start", "Spawn pet"))
@@ -73,21 +85,32 @@ class PetSettingUI(QWidget):
         self.grid_layout.addWidget(self.size_combobox, 1, 1)
         self.grid_layout.addWidget(self.speed_label, 2, 0)
         self.grid_layout.addWidget(self.speed_combobox, 2, 1)
-        self.grid_layout.addWidget(self.gravity_checkbox, 3, 0)
+        self.grid_layout.addWidget(self.behaviour_label, 3, 0)
+        self.grid_layout.addWidget(self.behaviour_combobox, 3, 1)
+        self.grid_layout.addWidget(self.climb_checkbox, 3, 2)
         self.grid_layout.addWidget(self.start_button, 4, 0)
         self.grid_layout.addWidget(self.recent_files_label, 5, 0)
         self.grid_layout.addWidget(self.recent_files_combobox, 5, 1)
 
-    def _create_pet_widget(self) -> DesktopPetWidget:
+    def _spawn_pet(self) -> None:
+        """建立、顯示並開始移動一隻寵物（供 Start 與右鍵複製共用）。"""
+        if not self.pet_image_path:
+            return
         pet = DesktopPetWidget(
             image_path=self.pet_image_path,
             size=int(self.size_combobox.currentText()),
             speed=int(self.speed_combobox.currentText()),
-            gravity=self.gravity_checkbox.isChecked(),
+            behaviour=self.behaviour_combobox.currentData(),
+            climb=self.climb_checkbox.isChecked(),
         )
+        pet.clone_requested.connect(self._spawn_pet)
         pet.set_pet_window_flag()
         self.pet_list.append(pet)
-        return pet
+        screen = QGuiApplication.primaryScreen()
+        geometry = screen.availableGeometry() if screen is not None else None
+        pet.show()
+        if geometry is not None:
+            pet.start_moving((geometry.left(), geometry.top(), geometry.right(), geometry.bottom()))
 
     def start_play_pet(self) -> None:
         front_engine_logger.info("[PetSettingUI] start_play_pet")
@@ -96,13 +119,7 @@ class PetSettingUI(QWidget):
             message_box.setText(language_wrapper.language_word_dict.get("not_prepare"))
             message_box.exec()
             return
-        pet = self._create_pet_widget()
-        screen = QGuiApplication.primaryScreen()
-        geometry = screen.availableGeometry() if screen is not None else None
-        pet.show()
-        if geometry is not None:
-            bounds = (geometry.left(), geometry.top(), geometry.right(), geometry.bottom())
-            pet.start_moving(bounds)
+        self._spawn_pet()
 
     def choose_and_play(self) -> None:
         front_engine_logger.info("[PetSettingUI] choose_and_play")
@@ -137,7 +154,8 @@ class PetSettingUI(QWidget):
             "pet_image_path": self.pet_image_path,
             "size": self.size_combobox.currentText(),
             "speed": self.speed_combobox.currentText(),
-            "gravity": self.gravity_checkbox.isChecked(),
+            "behaviour": self.behaviour_combobox.currentData(),
+            "climb": self.climb_checkbox.isChecked(),
         }
 
     def set_state(self, state: dict) -> None:
@@ -150,5 +168,12 @@ class PetSettingUI(QWidget):
                 index = combobox.findText(str(state[key]))
                 if index >= 0:
                     combobox.setCurrentIndex(index)
-        if "gravity" in state:
-            self.gravity_checkbox.setChecked(bool(state["gravity"]))
+        behaviour = state.get("behaviour")
+        if behaviour is None and "gravity" in state:  # back-compat with old presets
+            behaviour = BEHAVIOUR_FLOOR if state.get("gravity") else BEHAVIOUR_WANDER
+        if behaviour is not None:
+            index = self.behaviour_combobox.findData(behaviour)
+            if index >= 0:
+                self.behaviour_combobox.setCurrentIndex(index)
+        if "climb" in state:
+            self.climb_checkbox.setChecked(bool(state["climb"]))

{frontengine-1.0.2 → frontengine-1.0.4}/frontengine/utils/multi_language/english.py

@@ -219,7 +219,12 @@ english_word_dict = {
     "pet_choose_file": "Choose pet sprite",
     "pet_size_label": "Size",
     "pet_speed_label": "Speed",
-    "pet_gravity_label": "Walk on floor",
+    "pet_behaviour_label": "Behaviour",
+    "pet_behaviour_floor": "Walk on floor",
+    "pet_behaviour_wander": "Free wander",
+    "pet_behaviour_chase": "Chase cursor",
+    "pet_climb_label": "Climb walls",
+    "pet_clone": "Clone",
     "pet_start": "Spawn pet",
     "pet_message_box_text": "Pet image not found",
 }

{frontengine-1.0.2 → frontengine-1.0.4}/frontengine/utils/multi_language/traditional_chinese.py

@@ -220,7 +220,12 @@ traditional_chinese_word_dict = {
     "pet_choose_file": "選擇寵物圖片",
     "pet_size_label": "大小",
     "pet_speed_label": "速度",
-    "pet_gravity_label": "沿底部行走",
+    "pet_behaviour_label": "行為",
+    "pet_behaviour_floor": "沿底部行走",
+    "pet_behaviour_wander": "自由漫遊",
+    "pet_behaviour_chase": "追逐游標",
+    "pet_climb_label": "攀爬牆壁",
+    "pet_clone": "複製",
     "pet_start": "召喚寵物",
     "pet_message_box_text": "找不到寵物圖片",
 }

{frontengine-1.0.2 → frontengine-1.0.4}/frontengine.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: frontengine
-Version: 1.0.2
+Version: 1.0.4
 Summary: FrontEngine is use-define frontview or only use like screen saver
 Author-email: JE-Chen <jechenmailman@gmail.com>
 Project-URL: Homepage, https://github.com/Intergration-Automation-Testing/FrontEngine

{frontengine-1.0.2 → frontengine-1.0.4}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "frontengine"
-version = "1.0.2"
+version = "1.0.4"
 authors = [
     { name = "JE-Chen", email = "jechenmailman@gmail.com" },
 ]

frontengine-1.0.2/frontengine/show/pet/desktop_pet.py

@@ -1,178 +0,0 @@
-from pathlib import Path
-from typing import Optional, Tuple
-
-from PySide6.QtCore import Qt, QRect, QTimer
-from PySide6.QtGui import QAction, QMovie, QPainter, QPixmap, QTransform
-from PySide6.QtWidgets import QMenu, QMessageBox
-
-from frontengine.show.base_widget import BaseWidget
-from frontengine.show.window_helpers import apply_overlay_window_flags
-from frontengine.utils.logging.loggin_instance import front_engine_logger
-from frontengine.utils.multi_language.language_wrapper import language_wrapper
-
-
-class PetMotion:
-    """
-    純邏輯的移動模型（不依賴 Qt，便於測試）。gravity=True 時寵物沿著底部
-    行走並在左右邊緣轉向；否則在四邊之間自由彈跳。
-    Pure movement model (no Qt, easy to test). With gravity the pet walks
-    along the floor and turns at the left/right edges; otherwise it bounces
-    freely between all four edges.
-    """
-
-    def __init__(
-        self,
-        x: int,
-        y: int,
-        width: int,
-        height: int,
-        bounds: Tuple[int, int, int, int],
-        speed: int = 3,
-        gravity: bool = True,
-    ) -> None:
-        self.x = float(x)
-        self.y = float(y)
-        self.width = int(width)
-        self.height = int(height)
-        self.bounds = bounds  # (left, top, right, bottom)
-        self.speed = max(1, int(speed))
-        self.gravity = bool(gravity)
-        self.vx = float(self.speed)
-        self.vy = 0.0 if gravity else float(self.speed)
-
-    @property
-    def facing_left(self) -> bool:
-        return self.vx < 0
-
-    def set_bounds(self, bounds: Tuple[int, int, int, int]) -> None:
-        self.bounds = bounds
-
-    def step(self) -> Tuple[int, int]:
-        left, top, right, bottom = self.bounds
-        self.x += self.vx
-        if self.gravity:
-            self.y = float(bottom - self.height)
-        else:
-            self.y += self.vy
-            if self.y <= top:
-                self.y = float(top)
-                self.vy = abs(self.vy)
-            elif self.y + self.height >= bottom:
-                self.y = float(bottom - self.height)
-                self.vy = -abs(self.vy)
-        if self.x <= left:
-            self.x = float(left)
-            self.vx = abs(self.vx)
-        elif self.x + self.width >= right:
-            self.x = float(right - self.width)
-            self.vx = -abs(self.vx)
-        return int(self.x), int(self.y)
-
-
-class DesktopPetWidget(BaseWidget):
-    """
-    桌面寵物：可自主走動、可拖曳的動畫精靈。支援 GIF（QMovie）與靜態圖。
-    A draggable, self-walking animated sprite. Supports GIF (QMovie) and
-    static images.
-    """
-
-    def __init__(self, image_path: str, size: int = 128, speed: int = 3, gravity: bool = True):
-        front_engine_logger.info(
-            f"[DesktopPetWidget] Init | path={image_path}, size={size}, speed={speed}, gravity={gravity}"
-        )
-        super().__init__()
-        self.opacity = 1.0
-        self.pet_size: int = max(16, int(size))
-        self.image_path: Path = Path(image_path)
-        self.movie: Optional[QMovie] = None
-        self.pixmap: Optional[QPixmap] = None
-        self._dragging: bool = False
-        self._drag_offset = None
-
-        if self.image_path.exists() and self.image_path.is_file():
-            if self.image_path.suffix.lower() in (".gif", ".webp"):
-                self.movie = QMovie(str(self.image_path))
-                self.movie.frameChanged.connect(self.update)
-                self.movie.start()
-            else:
-                self.pixmap = QPixmap(str(self.image_path))
-        else:
-            front_engine_logger.error(f"[DesktopPetWidget] File not found: {self.image_path}")
-            message_box = QMessageBox(self)
-            message_box.setText(language_wrapper.language_word_dict.get("pet_message_box_text", "Pet image not found"))
-            message_box.show()
-
-        self.resize(self.pet_size, self.pet_size)
-        self.motion = PetMotion(0, 0, self.pet_size, self.pet_size, (0, 0, 1920, 1080), speed, gravity)
-
-        self._timer = QTimer(self)
-        self._timer.timeout.connect(self._on_tick)
-
-        # Right-click to close
-        self.close_action = QAction(language_wrapper.language_word_dict.get("control_center_close_all", "Close"), self)
-        self.close_action.triggered.connect(self.close)
-        self.menu = QMenu(self)
-        self.menu.addAction(self.close_action)
-
-    def set_pet_window_flag(self) -> None:
-        """寵物需接收滑鼠以便拖曳，故 allow_input=True 並置頂。"""
-        apply_overlay_window_flags(self, show_on_bottom=False, allow_input=True)
-
-    def _current_pixmap(self) -> Optional[QPixmap]:
-        if self.movie is not None:
-            return self.movie.currentPixmap()
-        return self.pixmap
-
-    def draw_content(self, painter: QPainter) -> None:
-        pixmap = self._current_pixmap()
-        if pixmap is None or pixmap.isNull():
-            return
-        if self.motion.facing_left:
-            # Mirror horizontally so the sprite faces its walking direction.
-            pixmap = pixmap.transformed(QTransform().scale(-1, 1))
-        painter.drawPixmap(QRect(0, 0, self.width(), self.height()), pixmap)
-
-    def start_moving(self, bounds: Tuple[int, int, int, int], interval_ms: int = 33) -> None:
-        """在指定範圍內開始走動 / Start walking within `bounds` (left, top, right, bottom)."""
-        front_engine_logger.info(f"[DesktopPetWidget] start_moving | bounds={bounds}")
-        left, top, right, bottom = bounds
-        self.motion.set_bounds(bounds)
-        self.motion.x = float(left)
-        self.motion.y = float(bottom - self.pet_size)
-        self.move(int(self.motion.x), int(self.motion.y))
-        self._timer.start(max(10, int(interval_ms)))
-
-    def _on_tick(self) -> None:
-        if self._dragging:
-            return
-        x, y = self.motion.step()
-        self.move(x, y)
-
-    # --- dragging ---
-    def mousePressEvent(self, event) -> None:
-        if event.button() == Qt.MouseButton.LeftButton:
-            self._dragging = True
-            self._drag_offset = event.globalPosition().toPoint() - self.frameGeometry().topLeft()
-        super().mousePressEvent(event)
-
-    def mouseMoveEvent(self, event) -> None:
-        if self._dragging and self._drag_offset is not None:
-            self.move(event.globalPosition().toPoint() - self._drag_offset)
-        super().mouseMoveEvent(event)
-
-    def mouseReleaseEvent(self, event) -> None:
-        if self._dragging:
-            self._dragging = False
-            self.motion.x = float(self.x())
-            self.motion.y = float(self.y())
-        super().mouseReleaseEvent(event)
-
-    def contextMenuEvent(self, event) -> None:
-        self.menu.popup(event.globalPos())
-
-    def closeEvent(self, event) -> None:
-        if self._timer.isActive():
-            self._timer.stop()
-        if self.movie is not None:
-            self.movie.stop()
-        super().closeEvent(event)