messageflight 0.2.4__py3-none-any.whl

message_flight/plane_banner.py

@@ -0,0 +1,359 @@
+"""Custom QWidget that draws a plane with a notification banner."""
+from typing import Optional
+
+from PyQt6.QtCore import QRect, Qt, QTimer, pyqtProperty  # type: ignore[attr-defined]
+from PyQt6.QtGui import QColor, QFont, QFontMetrics, QPainter, QPainterPath, QPixmap
+from PyQt6.QtWidgets import QWidget
+
+from message_flight.plane_presets import get_preset
+
+
+class PlaneBanner(QWidget):
+    def __init__(
+        self,
+        parent=None,
+        *,
+        plane_color: str = "#FF69B4",
+        wing_color: str = "#FF1493",
+        accent_color: str = "#FFFFFF",
+        decor_color: str = "#FF69B4",
+        banner_color: str = "#FFB6C1",
+        text_color: str = "#FFFFFF",
+        thruster_outer_color: str = "#FFA500",
+        thruster_middle_color: str = "#FF4500",
+        thruster_inner_color: str = "#FFFF00",
+    ):
+        super().__init__(parent)
+        self._banner_width = 280
+        self._banner_height = 50
+        self._text = ""
+        self._text_color = QColor(text_color)
+        self._preset = get_preset("airplane")
+        self._params = self._preset.get_default_params()
+        # Apply any color overrides from constructor
+        for attr_name in (
+            "plane_color", "wing_color", "accent_color", "decor_color",
+            "banner_color", "thruster_outer_color", "thruster_middle_color",
+            "thruster_inner_color",
+        ):
+            val = locals()[attr_name]
+            if hasattr(self._params, attr_name):
+                setattr(self._params, attr_name, val)
+        self._plane_offset = 0.0
+        self._facing_direction = 1  # 1 = 朝右, -1 = 朝左
+        self.setFixedSize(self._banner_width + 80, 80)
+
+        # 交互状态
+        self._click_feedback_text = ""
+        self._click_feedback_timer = None
+        self._dragging = False
+        self._drag_start_pos = None
+        self._drag_start_global = None
+
+    def _ensure_feedback_timer(self):
+        if self._click_feedback_timer is None:
+            try:
+                self._click_feedback_timer = QTimer(self)
+                self._click_feedback_timer.setSingleShot(True)
+                self._click_feedback_timer.timeout.connect(self._hide_click_feedback)
+            except RuntimeError:
+                pass
+
+    def _hide_click_feedback(self):
+        self._click_feedback_text = ""
+        self.update()
+
+    def mousePressEvent(self, event):
+        if event.button() == Qt.MouseButton.LeftButton:
+            self._dragging = True
+            self._drag_start_pos = event.pos()
+            self._drag_start_global = event.globalPosition().toPoint()
+            # 显示点击反馈
+            self._click_feedback_text = "✈️ 收到!"
+            self._ensure_feedback_timer()
+            if self._click_feedback_timer is not None:
+                self._click_feedback_timer.start(1500)
+            self.update()
+            # 通知父窗口暂停飞行动画
+            parent = self.parent()
+            if parent and hasattr(parent, "set_paused"):
+                parent.set_paused(True)
+            event.accept()
+
+    def mouseMoveEvent(self, event):
+        if self._dragging and self.parent():
+            delta = event.globalPosition().toPoint() - self._drag_start_global
+            new_pos = self.pos() + delta
+            # 限制在屏幕范围内
+            new_pos.setX(max(-self.width() + 50, min(new_pos.x(), self.parent().width() - 50)))
+            new_pos.setY(max(-self.height() + 50, min(new_pos.y(), self.parent().height() - 50)))
+            self.move(new_pos)
+            self._drag_start_global = event.globalPosition().toPoint()
+            event.accept()
+
+    def mouseReleaseEvent(self, event):
+        if event.button() == Qt.MouseButton.LeftButton:
+            self._dragging = False
+            self._drag_start_pos = None
+            self._drag_start_global = None
+            # 通知父窗口恢复飞行动画
+            parent = self.parent()
+            if parent and hasattr(parent, "set_paused"):
+                parent.set_paused(False)
+            event.accept()
+
+    def is_dragging(self) -> bool:
+        return self._dragging
+
+    def _generate_plane_cache(self) -> None:
+        """Render the plane preset to an off-screen pixmap for fast blitting."""
+        size = 100
+        self._plane_cache = QPixmap(size, size)
+        self._plane_cache.fill(Qt.GlobalColor.transparent)
+        painter = QPainter(self._plane_cache)
+        painter.setRenderHint(QPainter.RenderHint.Antialiasing)
+        # Translate by (20,20) so negative coordinates (e.g. bird wings) don't get clipped
+        painter.translate(20, 20)
+        rotation = getattr(self._params, 'rotation', 0.0)
+        if rotation != 0.0:
+            painter.translate(35, 40)
+            painter.rotate(rotation)
+            painter.translate(-35, -40)
+        self._preset.draw(painter, self._params)
+        painter.end()
+
+    def _recalculate_size(self) -> None:
+        """Recalculate widget size based on banner width and mount point offset."""
+        attach_x = getattr(self._params, 'banner_attach_x', 0)
+        extra = max(0, -2 * attach_x, attach_x - 80)
+        self.setFixedSize(self._banner_width + 100 + extra, 100)
+
+    def set_text(self, text: str):
+        self._text = text
+        fm = QFontMetrics(QFont("Microsoft YaHei", 12, QFont.Weight.Bold))
+        tw = fm.horizontalAdvance(text) + 40
+        self._banner_width = max(200, tw)
+        self._recalculate_size()
+        self.update()
+
+    def _plane_rect(self) -> QRect:
+        """Return the bounding rect of the plane area (approximate)."""
+        float_y = int(self._plane_offset * 6)
+        attach_x = getattr(self._params, 'banner_attach_x', 0)
+        extra_left = max(0, -attach_x)
+        if self._facing_direction == 1:
+            plane_x = extra_left + self._banner_width + 10
+        else:
+            plane_x = extra_left
+        return QRect(plane_x, 35 + float_y, 100, 100)
+
+    def _banner_rect(self) -> QRect:
+        """Return the bounding rect of the banner area."""
+        float_y = int(self._plane_offset * 6)
+        attach_x = getattr(self._params, 'banner_attach_x', 0)
+        extra_left = max(0, -attach_x)
+        if self._facing_direction == 1:
+            plane_x = extra_left + self._banner_width + 10
+            mount_x = plane_x + attach_x
+            bx = mount_x - self._banner_width - 10
+        else:
+            plane_x = extra_left
+            mount_x = plane_x + 100 - attach_x
+            bx = mount_x + 10
+        by = 35 + float_y + getattr(self._params, 'banner_attach_y', 35) - self._banner_height // 2
+        return QRect(bx, by, self._banner_width + 20, self._banner_height + 20)
+
+    def set_facing_direction(self, direction: int) -> None:
+        """Set the facing direction (1 = right, -1 = left) and trigger repaint."""
+        self._facing_direction = direction
+        self.update()
+
+    def _get_color(self, name: str) -> QColor:
+        """Return a QColor for the given attribute name from _params."""
+        value = getattr(self._params, name, "#FFFFFF")
+        return QColor(value)
+
+    def get_plane_offset(self):
+        return self._plane_offset
+
+    def set_plane_offset(self, val: float):
+        old_rect = self._plane_rect()
+        self._plane_offset = val
+        new_rect = self._plane_rect()
+        self.update(old_rect.united(new_rect))
+
+    plane_offset = pyqtProperty(float, get_plane_offset, set_plane_offset)
+
+    def update_colors(
+        self,
+        *,
+        plane_color: Optional[str] = None,
+        wing_color: Optional[str] = None,
+        accent_color: Optional[str] = None,
+        decor_color: Optional[str] = None,
+        banner_color: Optional[str] = None,
+        text_color: Optional[str] = None,
+        thruster_outer_color: Optional[str] = None,
+        thruster_middle_color: Optional[str] = None,
+        thruster_inner_color: Optional[str] = None,
+    ) -> None:
+        """Replace any of the 9 color attributes and request a repaint.
+
+        All arguments are keyword-only to match the ``__init__`` style.
+        A ``None`` argument leaves the corresponding color unchanged, which
+        lets callers forward ``**cfg.colors`` without worrying about missing
+        keys. A single ``update()`` is issued at the end so the repaint is
+        coalesced.
+        """
+        params_mapping = {
+            "plane_color": plane_color,
+            "wing_color": wing_color,
+            "accent_color": accent_color,
+            "decor_color": decor_color,
+            "banner_color": banner_color,
+            "thruster_outer_color": thruster_outer_color,
+            "thruster_middle_color": thruster_middle_color,
+            "thruster_inner_color": thruster_inner_color,
+        }
+        for attr, value in params_mapping.items():
+            if value is not None and hasattr(self._params, attr):
+                setattr(self._params, attr, value)
+        if text_color is not None:
+            self._text_color = QColor(text_color)
+            if hasattr(self._params, "text_color"):
+                self._params.text_color = text_color
+        self.__dict__.pop("_plane_cache", None)
+        self.update()
+
+    def apply_preset(self, preset, params) -> None:
+        """Replace the active preset and its params, then request a repaint."""
+        self._preset = preset
+        self._params = params
+        # sync banner/text colors if the new params carry them
+        if hasattr(params, "text_color"):
+            self._text_color = QColor(params.text_color)
+        self._recalculate_size()
+        self.__dict__.pop("_plane_cache", None)
+        self.update()
+
+    def paintEvent(self, event):
+        painter = QPainter(self)
+        painter.setRenderHint(QPainter.RenderHint.Antialiasing)
+        float_y = int(self._plane_offset * 6)
+
+        attach_x = getattr(self._params, 'banner_attach_x', 0)
+        attach_y = getattr(self._params, 'banner_attach_y', 35)
+        extra_left = max(0, -attach_x)
+
+        if self._facing_direction == 1:
+            # 左→右：飞船在右，横幅在左
+            plane_x = extra_left + self._banner_width + 10
+            plane_y = 35 + float_y
+
+            mount_x = plane_x + attach_x
+            mount_y = plane_y + attach_y
+
+            bx = mount_x - self._banner_width - 10
+            by = mount_y - self._banner_height // 2
+
+            self._draw_banner(painter, bx, by, tail_on_right=True)
+            self._draw_plane(painter, plane_x, plane_y, facing=1)
+        else:
+            # 右→左：飞船在左，横幅在右
+            plane_x = extra_left
+            plane_y = 35 + float_y
+
+            # facing=-1 时 _draw_plane 内部进行了 scale(-1,1) + translate(-100,0)
+            # 局部坐标 (x,y) 在世界坐标中 = (plane_x + 100 - x, plane_y + y)
+            mount_x = plane_x + 100 - attach_x
+            mount_y = plane_y + attach_y
+
+            bx = mount_x + 10
+            by = mount_y - self._banner_height // 2
+
+            self._draw_banner(painter, bx, by, tail_on_right=False)
+            self._draw_plane(painter, plane_x, plane_y, facing=-1)
+
+        # 绘制点击反馈气泡
+        if self._click_feedback_text:
+            self._draw_click_feedback(painter)
+
+        painter.end()
+
+    def _draw_click_feedback(self, painter: QPainter):
+        """Draw a temporary click feedback bubble above the plane."""
+        fm = QFontMetrics(QFont("Microsoft YaHei", 10, QFont.Weight.Bold))
+        text_w = fm.horizontalAdvance(self._click_feedback_text) + 16
+        text_h = fm.height() + 8
+        bubble_x = (self.width() - text_w) // 2
+        bubble_y = 5
+
+        path = QPainterPath()
+        path.addRoundedRect(bubble_x, bubble_y, text_w, text_h, 8, 8)
+        painter.fillPath(path, QColor(0, 0, 0, 180))
+
+        painter.setPen(Qt.GlobalColor.white)
+        font = QFont("Microsoft YaHei", 10, QFont.Weight.Bold)
+        painter.setFont(font)
+        painter.drawText(bubble_x, bubble_y, text_w, text_h, Qt.AlignmentFlag.AlignCenter, self._click_feedback_text)
+
+    def _draw_banner(self, painter: QPainter, bx: int, by: int, tail_on_right: bool):
+        """Draw the notification banner at (bx, by).
+
+        Args:
+            tail_on_right: True = tail on right edge (plane on right);
+                           False = tail on left edge (plane on left).
+        """
+        path = QPainterPath()
+        rect_w = self._banner_width
+        rect_h = self._banner_height
+        radius = 12
+
+        path.moveTo(bx + radius, by)
+        path.lineTo(bx + rect_w - radius, by)
+        path.arcTo(bx + rect_w - radius * 2, by, radius * 2, radius * 2, 90, -90)
+        path.lineTo(bx + rect_w, by + rect_h - radius)
+        path.arcTo(bx + rect_w - radius * 2, by + rect_h - radius * 2, radius * 2, radius * 2, 0, -90)
+        path.lineTo(bx + radius, by + rect_h)
+        path.arcTo(bx, by + rect_h - radius * 2, radius * 2, radius * 2, -90, -90)
+        path.lineTo(bx, by + radius)
+        path.arcTo(bx, by, radius * 2, radius * 2, 180, -90)
+        path.closeSubpath()
+
+        tail_y = by + rect_h // 2
+        if tail_on_right:
+            tail_x = bx + rect_w
+            path.moveTo(tail_x, tail_y - 6)
+            path.lineTo(tail_x + 10, tail_y)
+            path.lineTo(tail_x, tail_y + 6)
+        else:
+            tail_x = bx
+            path.moveTo(tail_x, tail_y - 6)
+            path.lineTo(tail_x - 10, tail_y)
+            path.lineTo(tail_x, tail_y + 6)
+        path.closeSubpath()
+
+        painter.fillPath(path, self._get_color("banner_color"))
+
+        painter.setPen(self._text_color)
+        font = QFont("Microsoft YaHei", 12, QFont.Weight.Bold)
+        painter.setFont(font)
+        fm = QFontMetrics(font)
+        text_y = by + (rect_h + fm.ascent() - fm.descent()) // 2
+        painter.drawText(bx + 20, text_y, self._text)
+
+    def _draw_plane(self, painter: QPainter, px: int, py: int, facing: int):
+        """Draw the plane at (px, py) using cached pixmap.
+
+        Args:
+            facing: 1 = head points right; -1 = head points left.
+        """
+        if not hasattr(self, '_plane_cache') or self._plane_cache.isNull():
+            self._generate_plane_cache()
+        painter.save()
+        painter.translate(px, py)
+        if facing == -1:
+            painter.scale(-1, 1)
+            painter.translate(-100, 0)
+        painter.drawPixmap(0, 0, self._plane_cache)
+        painter.restore()

message_flight/plane_presets/__init__.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from typing import Type
+
+from .airplane import AirplanePreset
+from .base import PlanePreset
+from .bird import BirdPreset
+from .rocket import RocketPreset
+from .ufo import UFOPreset
+
+PRESETS: dict[str, Type[PlanePreset]] = {
+    "airplane": AirplanePreset,
+    "rocket": RocketPreset,
+    "ufo": UFOPreset,
+    "bird": BirdPreset,
+}
+
+
+def get_preset(key: str) -> PlanePreset:
+    if key not in PRESETS:
+        key = "airplane"
+    return PRESETS[key]()
+
+
+def list_presets() -> list[tuple[str, str, str]]:
+    return [(k, p.name, p.icon) for k, p in PRESETS.items()]

message_flight/plane_presets/airplane.py

@@ -0,0 +1,103 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from PyQt6.QtCore import Qt
+from PyQt6.QtGui import QColor, QPainter, QPainterPath
+
+from .base import ParamDef, PlanePreset
+
+
+@dataclass
+class AirplaneParameters:
+    plane_color: str = "#FF69B4"
+    wing_color: str = "#FF1493"
+    accent_color: str = "#FFFFFF"
+    decor_color: str = "#FF69B4"
+    banner_color: str = "#FFB6C1"
+    thruster_outer_color: str = "#FFA500"
+    thruster_middle_color: str = "#FF4500"
+    thruster_inner_color: str = "#FFFF00"
+    body_scale: float = 1.0
+    text_color: str = "#FFFFFF"
+    rotation: float = 0.0
+    banner_attach_x: int = 0
+    banner_attach_y: int = 30
+
+
+class AirplanePreset(PlanePreset):
+    name = "飞机"
+    icon = "✈️"
+
+    def draw(self, painter: QPainter, params: AirplaneParameters) -> None:
+        s = params.body_scale
+        painter.save()
+        self._draw_thruster(painter, params, s)
+        self._draw_fuselage(painter, params, s)
+        self._draw_wings(painter, params, s)
+        painter.restore()
+
+    def get_parameters(self) -> list[ParamDef]:
+        return [
+            ParamDef("plane_color", "飞机主体", "color", "#FF69B4"),
+            ParamDef("wing_color", "机翼", "color", "#FF1493"),
+            ParamDef("accent_color", "眼睛/高光", "color", "#FFFFFF"),
+            ParamDef("decor_color", "小圆装饰", "color", "#FF69B4"),
+            ParamDef("banner_color", "横幅装饰", "color", "#FFB6C1"),
+            ParamDef("thruster_outer_color", "推进器外焰", "color", "#FFA500"),
+            ParamDef("thruster_middle_color", "推进器中焰", "color", "#FF4500"),
+            ParamDef("thruster_inner_color", "推进器内焰", "color", "#FFFF00"),
+            ParamDef("body_scale", "机身缩放", "float", 1.0, 0.5, 2.0, 0.1),
+            ParamDef("rotation", "旋转角度", "float", 0.0, -45.0, 45.0, 1.0),
+            ParamDef("banner_attach_x", "横幅挂载X", "int", 0, -50, 100),
+            ParamDef("banner_attach_y", "横幅挂载Y", "int", 30, -50, 100),
+        ]
+
+    def get_default_params(self) -> AirplaneParameters:
+        return AirplaneParameters()
+
+    @staticmethod
+    def _draw_fuselage(painter, params, s):
+        painter.setPen(Qt.PenStyle.NoPen)
+        painter.setBrush(QColor(params.plane_color))
+        painter.drawEllipse(int(10*s), int(18*s), int(45*s), int(22*s))
+        painter.drawEllipse(int(48*s), int(19*s), int(14*s), int(20*s))
+        painter.setBrush(QColor(params.accent_color))
+        painter.drawEllipse(int(52*s), int(24*s), int(6*s), int(6*s))
+        painter.drawEllipse(int(38*s), int(24*s), int(5*s), int(5*s))
+        painter.setBrush(QColor(params.decor_color))
+        painter.drawEllipse(int(60*s), int(26*s), int(4*s), int(6*s))
+        painter.setBrush(QColor(params.banner_color))
+        painter.drawEllipse(int(56*s), int(22*s), int(12*s), int(3*s))
+        painter.drawEllipse(int(56*s), int(33*s), int(12*s), int(3*s))
+
+    @staticmethod
+    def _draw_wings(painter, params, s):
+        painter.setPen(Qt.PenStyle.NoPen)
+        painter.setBrush(QColor(params.wing_color))
+        wing_path = QPainterPath()
+        wing_path.moveTo(int(25*s), int(25*s))
+        wing_path.lineTo(int(15*s), int(8*s))
+        wing_path.lineTo(int(35*s), int(8*s))
+        wing_path.lineTo(int(40*s), int(25*s))
+        wing_path.closeSubpath()
+        painter.drawPath(wing_path)
+        tail_path = QPainterPath()
+        tail_path.moveTo(int(12*s), int(28*s))
+        tail_path.lineTo(int(2*s), int(18*s))
+        tail_path.lineTo(int(12*s), int(22*s))
+        tail_path.closeSubpath()
+        painter.drawPath(tail_path)
+
+    @staticmethod
+    def _draw_thruster(painter, params, s, intensity=1.0):
+        painter.setPen(Qt.PenStyle.NoPen)
+        outer_w = int(14 * intensity * s)
+        painter.setBrush(QColor(params.thruster_outer_color))
+        painter.drawEllipse(int(5*s), int(25*s), outer_w, int(10*s))
+        mid_w = int(10 * intensity * s)
+        painter.setBrush(QColor(params.thruster_middle_color))
+        painter.drawEllipse(int(5*s), int(26*s), mid_w, int(7*s))
+        inner_w = int(5 * intensity * s)
+        painter.setBrush(QColor(params.thruster_inner_color))
+        painter.drawEllipse(int(5*s), int(27*s), inner_w, int(4*s))

message_flight/plane_presets/base.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from typing import Any, Optional
+
+from PyQt6.QtGui import QPainter
+
+
+@dataclass
+class ParamDef:
+    name: str
+    label: str
+    type: str
+    default: Any
+    min: Optional[Any] = None
+    max: Optional[Any] = None
+    step: Optional[Any] = None
+
+
+class PlanePreset(ABC):
+    name: str = ""
+    icon: str = ""
+
+    @abstractmethod
+    def draw(self, painter: QPainter, params: Any) -> None:
+        pass
+
+    @abstractmethod
+    def get_parameters(self) -> list[ParamDef]:
+        pass
+
+    @abstractmethod
+    def get_default_params(self) -> Any:
+        pass

message_flight/plane_presets/bird.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass
+
+from PyQt6.QtCore import Qt
+from PyQt6.QtGui import QColor, QPainter, QPainterPath
+
+from .base import ParamDef, PlanePreset
+
+
+@dataclass
+class BirdParameters:
+    body_size: int = 20
+    wing_span: int = 40
+    body_color: str = "#4169E1"
+    wing_color: str = "#1E90FF"
+    beak_color: str = "#FFA500"
+    eye_color: str = "#000000"
+    wing_flap_speed: float = 4.0
+    banner_color: str = "#87CEEB"
+    text_color: str = "#FFFFFF"
+    rotation: float = 0.0
+    banner_attach_x: int = -10
+    banner_attach_y: int = 0
+
+
+class BirdPreset(PlanePreset):
+    name = "小鸟"
+    icon = "🐦"
+
+    def __init__(self):
+        self._animation_time = 0.0
+
+    def draw(self, painter: QPainter, params: BirdParameters) -> None:
+        bs = params.body_size
+        ws = params.wing_span
+        self._animation_time += 0.016  # ~60fps assumption
+        phase = (math.sin(self._animation_time * params.wing_flap_speed) + 1.0) / 2.0
+        wing_offset = int(ws // 2 * phase)
+        painter.save()
+        painter.setPen(Qt.PenStyle.NoPen)
+        painter.setBrush(QColor(params.body_color))
+        painter.drawEllipse(-bs // 2, -bs // 4, bs, bs // 2)
+        painter.drawEllipse(bs // 4, -bs // 3, bs // 2, bs // 2)
+        painter.setBrush(QColor(params.beak_color))
+        beak = QPainterPath()
+        beak.moveTo(bs * 3 // 4, -bs // 8)
+        beak.lineTo(bs + 4, 0)
+        beak.lineTo(bs * 3 // 4, bs // 8)
+        beak.closeSubpath()
+        painter.drawPath(beak)
+        painter.setBrush(QColor(params.eye_color))
+        painter.drawEllipse(bs // 2, -bs // 6, 2, 2)
+        painter.setBrush(QColor(params.wing_color))
+        wing_top = QPainterPath()
+        wing_top.moveTo(-bs // 4, -bs // 4)
+        wing_top.lineTo(-bs // 4 - wing_offset, -wing_offset)
+        wing_top.lineTo(bs // 4, -bs // 4)
+        wing_top.closeSubpath()
+        painter.drawPath(wing_top)
+        wing_bot = QPainterPath()
+        wing_bot.moveTo(-bs // 4, bs // 4)
+        wing_bot.lineTo(-bs // 4 - wing_offset, wing_offset)
+        wing_bot.lineTo(bs // 4, bs // 4)
+        wing_bot.closeSubpath()
+        painter.drawPath(wing_bot)
+        painter.restore()
+
+    def get_parameters(self) -> list[ParamDef]:
+        return [
+            ParamDef("body_size", "身体大小", "int", 20, 10, 40),
+            ParamDef("wing_span", "翼展", "int", 40, 20, 80),
+            ParamDef("body_color", "身体颜色", "color", "#4169E1"),
+            ParamDef("wing_color", "翅膀颜色", "color", "#1E90FF"),
+            ParamDef("beak_color", "鸟喙颜色", "color", "#FFA500"),
+            ParamDef("eye_color", "眼睛颜色", "color", "#000000"),
+            ParamDef("wing_flap_speed", "扇翅速度", "float", 4.0, 0.0, 10.0, 0.5),
+            ParamDef("banner_color", "横幅颜色", "color", "#87CEEB"),
+            ParamDef("rotation", "旋转角度", "float", 0.0, -45.0, 45.0, 1.0),
+            ParamDef("text_color", "文字颜色", "color", "#FFFFFF"),
+            ParamDef("banner_attach_x", "横幅挂载X", "int", -10, -50, 100),
+            ParamDef("banner_attach_y", "横幅挂载Y", "int", 0, -50, 100),
+        ]
+
+    def get_default_params(self) -> BirdParameters:
+        return BirdParameters()