def generate_heart_point(self, t: float, scale: float = 1.0) -> Dict[str, float]:
    """生成心形參數(shù)方程的點(diǎn)"""
    # 心形參數(shù)方程: x=16sin3t, y=13cost-5cos2t-2cos3t-cos4t
    x = 16 * math.sin(t)**3
    y = 13 * math.cos(t) - 5 * math.cos(2*t) - 2 * math.cos(3*t) - math.cos(4*t)
    # 映射到畫(huà)布中心并縮放
    center_x, center_y = WIDTH // 2, HEIGHT // 2
    heart_scale = min(WIDTH, HEIGHT) * 0.35 * scale
    return {
        "x": center_x + x * heart_scale / 16,
        "y": center_y - y * heart_scale / 16  # 反轉(zhuǎn)y軸
    }

class Particle:
    def __init__(self, x: float, y: float, particle_type: str = "heart"):
        self.x = x
        self.y = y
        self.type = particle_type
        # 初始化屬性
        self.current_size = 0
        self.current_alpha = 0
        # 根據(jù)粒子類型設(shè)置屬性
        if particle_type == "heart":
            self.setup_heart_particle()
        elif particle_type == "mouse":
            self.setup_mouse_particle()
        elif particle_type == "firework":
            self.setup_firework_particle()
        else:  # falling
            self.setup_falling_particle()
        # 煙花粒子延遲效果
        if particle_type == "firework":
            self.delay = random.random() * 15
            self.is_active = False
    def update(self) -> None:
        """更新粒子狀態(tài)"""
        # 根據(jù)粒子類型執(zhí)行不同的物理模擬
        # ... (省略具體實(shí)現(xiàn))
    def draw(self) -> None:
        """繪制粒子"""
        if self.type == "firework" and not self.is_active:
            return
        # 確保透明度在有效范圍內(nèi)
        r, g, b = self.color
        alpha = max(0, min(255, int(255 * self.current_alpha)))
        if alpha > 0:  # 只繪制可見(jiàn)粒子
            # 創(chuàng)建帶透明度的表面
            size = max(0.5, self.current_size)
            surf = pygame.Surface((int(size * 2), int(size * 2)), pygame.SRCALPHA)
            pygame.draw.circle(surf, (r, g, b, alpha), (int(size), int(size)), int(size))
            screen.blit(surf, (self.x - size, self.y - size))

def setup_firework_particle(self) -> None:
    """初始化煙花粒子屬性"""
    self.color = random.choice(particle_colors)
    self.size = 1.5 + random.random() * 4
    self.base_speed = 2 + random.random() * 3  # 較高初始速度
    self.angle = random.random() * math.pi * 2
    self.life = 100 + random.random() * 80
    self.max_life = self.life
    self.gravity = 0.05  # 重力
    self.friction = 0.97 + random.random() * 0.01  # 摩擦力
    # 笛卡爾坐標(biāo)速度
    self.vx = math.cos(self.angle) * self.base_speed
    self.vy = math.sin(self.angle) * self.base_speed
def update(self) -> None:
    # 煙花粒子物理模擬
    if self.type == "firework" and self.is_active:
        self.vx *= self.friction  # 摩擦力
        self.vy += self.gravity  # 重力
        self.x += self.vx
        self.y += self.vy
        # 轉(zhuǎn)換為墜落粒子
        if abs(self.vy) > 0.3 and random.random() < 0.08 and self.life > 40:
            self.type = "falling"
            self.setup_falling_particle()

def handle_mouse_move(self, x: int, y: int) -> None:
    """處理鼠標(biāo)移動(dòng)"""
    self.mouse["x"] = x
    self.mouse["y"] = y
    # 生成鼠標(biāo)軌跡粒子
    for _ in range(6):
        offset_x = (random.random() - 0.5) * 20
        offset_y = (random.random() - 0.5) * 20
        self.particles.append(Particle(
            self.mouse["x"] + offset_x, 
            self.mouse["y"] + offset_y, 
            "mouse"
        ))
def handle_mouse_down(self) -> None:
    """處理鼠標(biāo)按下 - 創(chuàng)建煙花"""
    self.mouse["is_down"] = True
    self.create_firework(self.mouse["x"], self.mouse["y"])
def draw_ui(self) -> None:
    """繪制用戶界面"""
    # 標(biāo)題
    title = font.render("心之律動(dòng)", True, (255, 255, 255))
    subtitle = font.render("鼠標(biāo)移動(dòng)生成軌跡，點(diǎn)擊釋放煙花", True, (230, 230, 230))
    screen.blit(title, (WIDTH//2 - title.get_width()//2, 20))
    screen.blit(subtitle, (WIDTH//2 - subtitle.get_width()//2, 55))
    # 粒子數(shù)量
    particle_count_text = font.render(f"粒子數(shù)量: {self.particle_count}", True, (255, 255, 255))
    screen.blit(particle_count_text, (20, 20))
    # 操作提示
    help_text1 = font.render("R: 重置 | P: 暫停 | +: 增加粒子 | -: 減少粒子", True, (200, 200, 200))
    screen.blit(help_text1, (WIDTH//2 - help_text1.get_width()//2, HEIGHT - 40))

import pygame
import math
import random
import sys
from typing import List, Dict, Tuple
# 初始化Pygame
pygame.init()
# 確保中文正常顯示
pygame.font.init()
font = pygame.font.SysFont(["SimHei", "WenQuanYi Micro Hei", "Heiti TC"], 24)
# 屏幕設(shè)置
WIDTH, HEIGHT = 1000, 700
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("心之律動(dòng) - Pygame粒子動(dòng)畫(huà)")
# 顏色定義
particle_colors = [
    (255, 94, 135),
    (255, 133, 162),
    (255, 179, 198),
    (255, 194, 209),
    (255, 215, 228),
    (255, 154, 162),
    (255, 183, 178),
    (255, 218, 193),
    (226, 240, 203),
    (181, 234, 215),
    (199, 206, 234),
    (167, 154, 255),
    (194, 167, 255),
    (216, 167, 255),
    (234, 167, 255),
    (245, 167, 255),
]
# 粒子類
class Particle:
    def __init__(self, x: float, y: float, particle_type: str = "heart"):
        self.x = x
        self.y = y
        self.type = particle_type  # heart, mouse, firework, falling
        # 初始化屬性
        self.current_size = 0
        self.current_alpha = 0
        # 根據(jù)粒子類型設(shè)置屬性
        if particle_type == "heart":
            self.setup_heart_particle()
        elif particle_type == "mouse":
            self.setup_mouse_particle()
        elif particle_type == "firework":
            self.setup_firework_particle()
        else:  # falling
            self.setup_falling_particle()
        # 煙花粒子延遲效果
        if particle_type == "firework":
            self.delay = random.random() * 15
            self.is_active = False
    def setup_heart_particle(self) -> None:
        """初始化心形粒子屬性"""
        self.layer = random.randint(0, 3)  # 粒子層次
        # 根據(jù)層次選擇顏色
        color_pools = [
            particle_colors[0:3],  # 外層
            particle_colors[3:6],  # 中層
            particle_colors[6:9],  # 內(nèi)層
            particle_colors[9:],  # 中心
        ]
        self.color = random.choice(color_pools[self.layer])
        # 根據(jù)層次設(shè)置大小和速度
        self.size = 2 + random.random() * (8 - self.layer * 2)
        self.speed = 0.1 + random.random() * 0.3 + self.layer * 0.05
        self.angle = random.random() * math.pi * 2  # 隨機(jī)方向
        # 生命周期
        self.life = 150 + random.random() * 100 - self.layer * 30
        self.max_life = self.life
    def setup_mouse_particle(self) -> None:
        """初始化鼠標(biāo)軌跡粒子屬性"""
        self.color = random.choice(particle_colors)
        self.size = 1 + random.random() * 3
        self.speed = 0.05 + random.random() * 0.1  # 較慢速度
        self.angle = random.random() * math.pi * 2
        self.life = 100 + random.random() * 80  # 較長(zhǎng)壽命
        self.max_life = self.life
    def setup_firework_particle(self) -> None:
        """初始化煙花粒子屬性"""
        self.color = random.choice(particle_colors)
        self.size = 1.5 + random.random() * 4
        self.base_speed = 2 + random.random() * 3  # 較高初始速度
        self.angle = random.random() * math.pi * 2
        self.life = 100 + random.random() * 80
        self.max_life = self.life
        self.gravity = 0.05  # 重力
        self.friction = 0.97 + random.random() * 0.01  # 摩擦力
        # 笛卡爾坐標(biāo)速度
        self.vx = math.cos(self.angle) * self.base_speed
        self.vy = math.sin(self.angle) * self.base_speed
    def setup_falling_particle(self) -> None:
        """初始化墜落粒子屬性"""
        self.color = random.choice(particle_colors)
        self.size = 0.5 + random.random() * 2
        self.speed = 0.5 + random.random() * 1.5
        # 主要向下的角度
        self.angle = math.pi + (random.random() - 0.5) * math.pi * 0.6
        self.life = 80 + random.random() * 120
        self.max_life = self.life
        self.gravity = 0.03  # 重力
        self.wind = (random.random() - 0.5) * 0.003  # 風(fēng)力
    def update(self) -> None:
        """更新粒子狀態(tài)"""
        # 煙花粒子延遲激活
        if self.type == "firework" and not self.is_active:
            self.delay -= 1
            if self.delay <= 0:
                self.is_active = True
            return
        # 煙花粒子物理模擬
        if self.type == "firework" and self.is_active:
            self.vx *= self.friction  # 摩擦力
            self.vy += self.gravity  # 重力
            self.x += self.vx
            self.y += self.vy
            # 轉(zhuǎn)換為墜落粒子
            if abs(self.vy) > 0.3 and random.random() < 0.08 and self.life > 40:
                self.type = "falling"
                self.setup_falling_particle()
        else:
            # 其他粒子使用極坐標(biāo)移動(dòng)
            self.x += math.cos(self.angle) * self.speed
            self.y += math.sin(self.angle) * self.speed
        # 墜落粒子額外處理
        if self.type == "falling":
            self.speed += self.gravity
            self.x += self.wind
        # 生命周期遞減
        self.life -= 1
        # 心跳效果 - 大小和透明度變化
        heartbeat_phase = (pygame.time.get_ticks() / 800) % (math.pi * 2)
        heartbeat_factor = 1.0 + 0.15 * math.sin(heartbeat_phase)
        if self.type == "heart":
            self.current_size = (
                self.size * heartbeat_factor * (self.life / self.max_life)
            )
            self.current_alpha = (self.life / self.max_life) * (
                0.8 + 0.2 * math.sin(heartbeat_phase + self.layer * 0.5)
            )
        else:
            self.current_size = self.size * (self.life / self.max_life)
            self.current_alpha = self.life / self.max_life
    def draw(self) -> None:
        """繪制粒子"""
        if self.type == "firework" and not self.is_active:
            return
        # 確保透明度在有效范圍內(nèi)
        r, g, b = self.color
        alpha = max(0, min(255, int(255 * self.current_alpha)))
        if alpha > 0:  # 只繪制可見(jiàn)粒子
            # 創(chuàng)建帶透明度的表面
            size = max(0.5, self.current_size)  # 確保大小至少為0.5
            surf = pygame.Surface((int(size * 2), int(size * 2)), pygame.SRCALPHA)
            pygame.draw.circle(
                surf, (r, g, b, alpha), (int(size), int(size)), int(size)
            )
            screen.blit(surf, (self.x - size, self.y - size))
    def is_alive(self) -> bool:
        """檢查粒子是否存活"""
        return self.life > 0
# 心形動(dòng)畫(huà)類
class HeartAnimation:
    def __init__(self):
        self.particles: List[Particle] = []
        self.is_paused = False
        self.mouse = {"x": WIDTH // 2, "y": HEIGHT // 2, "is_down": False}
        self.particle_count = 0
        self.heart_particle_count = 1000  # 心形粒子目標(biāo)數(shù)量
        self.heart_regen_rate = 5  # 每幀再生數(shù)量
        # 生成初始心形粒子
        self.generate_heart_particles(self.heart_particle_count)
    def is_inside_heart(self, x: float, y: float, scale: float = 1.0) -> bool:
        """判斷點(diǎn)是否在心形內(nèi)部"""
        center_x, center_y = WIDTH // 2, HEIGHT // 2
        nx = (x - center_x) / (WIDTH / 2)
        ny = (y - center_y) / (HEIGHT / 2)
        # 心形方程: (x2 + y2 - 1)3 - x2y3 ≤ 0
        heart_eq = (nx**2 + ny**2 - 1) ** 3 - nx**2 * ny**3
        return heart_eq <= 0
    def generate_heart_point(self, t: float, scale: float = 1.0) -> Dict[str, float]:
        """生成心形參數(shù)方程的點(diǎn)"""
        # 心形參數(shù)方程: x=16sin3t, y=13cost-5cos2t-2cos3t-cos4t
        x = 16 * math.sin(t) ** 3
        y = (
            13 * math.cos(t)
            - 5 * math.cos(2 * t)
            - 2 * math.cos(3 * t)
            - math.cos(4 * t)
        )
        # 映射到畫(huà)布中心并縮放
        center_x, center_y = WIDTH // 2, HEIGHT // 2
        heart_scale = min(WIDTH, HEIGHT) * 0.35 * scale
        return {
            "x": center_x + x * heart_scale / 16,
            "y": center_y - y * heart_scale / 16,  # 反轉(zhuǎn)y軸
        }
    def generate_heart_particles(self, count: int) -> None:
        """生成心形粒子"""
        for _ in range(count):
            layer = random.randint(0, 3)  # 隨機(jī)層次
            # 根據(jù)層次設(shè)置縮放
            if layer == 0:
                scale = 1.0  # 外層
            elif layer == 1:
                scale = 0.95  # 中層
            elif layer == 2:
                scale = 0.85  # 內(nèi)層
            else:
                scale = 0.7  # 中心層
            t = random.random() * math.pi * 2  # 隨機(jī)角度
            point = self.generate_heart_point(t, scale)
            # 中心層添加隨機(jī)偏移
            if layer == 3:
                offset = random.random() * 0.2 * (WIDTH / 2)
                point["x"] += (random.random() - 0.5) * offset
                point["y"] += (random.random() - 0.5) * offset
                # 確保點(diǎn)在心形內(nèi)
                if not self.is_inside_heart(point["x"], point["y"]):
                    continue
            # 創(chuàng)建粒子
            self.particles.append(Particle(point["x"], point["y"], "heart"))
        self.update_particle_count()
    def regenerate_heart_particles(self, count: int) -> None:
        """再生心形粒子"""
        for _ in range(count):
            layer = random.randint(0, 3)
            scale = (
                1.0
                if layer == 0
                else 0.95 if layer == 1 else 0.85 if layer == 2 else 0.7
            )
            t = random.random() * math.pi * 2
            point = self.generate_heart_point(t, scale)
            if layer == 3:
                offset = random.random() * 0.2 * (WIDTH / 2)
                point["x"] += (random.random() - 0.5) * offset
                point["y"] += (random.random() - 0.5) * offset
                if not self.is_inside_heart(point["x"], point["y"]):
                    continue
            self.particles.append(Particle(point["x"], point["y"], "heart"))
    def handle_mouse_move(self, x: int, y: int) -> None:
        """處理鼠標(biāo)移動(dòng)"""
        self.mouse["x"] = x
        self.mouse["y"] = y
        # 生成鼠標(biāo)軌跡粒子
        for _ in range(6):  # 生成多個(gè)粒子形成連續(xù)軌跡
            offset_x = (random.random() - 0.5) * 20
            offset_y = (random.random() - 0.5) * 20
            self.particles.append(
                Particle(
                    self.mouse["x"] + offset_x, self.mouse["y"] + offset_y, "mouse"
                )
            )
        self.update_particle_count()
    def handle_mouse_down(self) -> None:
        """處理鼠標(biāo)按下 - 創(chuàng)建煙花"""
        self.mouse["is_down"] = True
        self.create_firework(self.mouse["x"], self.mouse["y"])
    def handle_mouse_up(self) -> None:
        """處理鼠標(biāo)釋放"""
        self.mouse["is_down"] = False
    def create_firework(self, x: float, y: float) -> None:
        """創(chuàng)建煙花效果"""
        # 主爆炸
        self.create_firework_wave(x, y, 180, 0)
        # 延遲爆炸 - 外層
        pygame.time.set_timer(pygame.USEREVENT + 1, 150, True)
        # 精細(xì)粒子
        pygame.time.set_timer(pygame.USEREVENT + 2, 250, True)
        self.update_particle_count()
    def create_firework_wave(
        self,
        x: float,
        y: float,
        count: int,
        base_delay: int,
        fine_particles: bool = False,
        speed_multiplier: float = 1.0,
    ) -> None:
        """創(chuàng)建一波煙花粒子"""
        for _ in range(count):
            p = Particle(x, y, "firework")
            if fine_particles:
                p.size = 0.5 + random.random() * 1.5
                p.base_speed = 1.5 + random.random() * 2
                p.life = 80 + random.random() * 60
            else:
                p.size = 1 + random.random() * 3
                p.base_speed = (2 + random.random() * 3) * speed_multiplier
            p.delay = base_delay + random.random() * 10
            p.vx = math.cos(p.angle) * p.base_speed
            p.vy = math.sin(p.angle) * p.base_speed
            self.particles.append(p)
    def handle_reset(self) -> None:
        """重置動(dòng)畫(huà)"""
        self.particles = []
        self.generate_heart_particles(self.heart_particle_count)
    def handle_pause(self) -> None:
        """暫停/繼續(xù)動(dòng)畫(huà)"""
        self.is_paused = not self.is_paused
    def handle_increase(self) -> None:
        """增加粒子數(shù)量"""
        self.heart_particle_count += 200
        self.generate_heart_particles(200)
    def handle_decrease(self) -> None:
        """減少粒子數(shù)量"""
        if self.heart_particle_count > 200:
            self.heart_particle_count -= 200
            # 移除舊的心形粒子
            removed = 0
            for i in range(len(self.particles) - 1, -1, -1):
                if self.particles[i].type == "heart":
                    self.particles.pop(i)
                    removed += 1
                    if removed >= 200:
                        break
            self.update_particle_count()
    def update_particle_count(self) -> None:
        """更新粒子數(shù)量顯示"""
        self.particle_count = len(self.particles)
    def draw_ui(self) -> None:
        """繪制用戶界面"""
        # 標(biāo)題
        title = font.render("心之律動(dòng)", True, (255, 255, 255))
        subtitle = font.render("鼠標(biāo)移動(dòng)生成軌跡，點(diǎn)擊釋放煙花", True, (230, 230, 230))
        screen.blit(title, (WIDTH // 2 - title.get_width() // 2, 20))
        screen.blit(subtitle, (WIDTH // 2 - subtitle.get_width() // 2, 55))
        # 粒子數(shù)量
        particle_count_text = font.render(
            f"粒子數(shù)量: {self.particle_count}", True, (255, 255, 255)
        )
        screen.blit(particle_count_text, (20, 20))
        # 操作提示
        help_text1 = font.render(
            "R: 重置 | P: 暫停 | +: 增加粒子 | -: 減少粒子", True, (200, 200, 200)
        )
        screen.blit(help_text1, (WIDTH // 2 - help_text1.get_width() // 2, HEIGHT - 40))
# 主函數(shù)
def main():
    clock = pygame.time.Clock()
    heart_animation = HeartAnimation()
    # 主循環(huán)
    running = True
    while running:
        # 事件處理
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                running = False
            elif event.type == pygame.MOUSEMOTION:
                heart_animation.handle_mouse_move(event.pos[0], event.pos[1])
            elif event.type == pygame.MOUSEBUTTONDOWN:
                heart_animation.handle_mouse_down()
            elif event.type == pygame.MOUSEBUTTONUP:
                heart_animation.handle_mouse_up()
            elif event.type == pygame.KEYDOWN:
                if event.key == pygame.K_r:
                    heart_animation.handle_reset()
                elif event.key == pygame.K_p:
                    heart_animation.handle_pause()
                elif event.key == pygame.K_PLUS or event.key == pygame.K_KP_PLUS:
                    heart_animation.handle_increase()
                elif event.key == pygame.K_MINUS or event.key == pygame.K_KP_MINUS:
                    heart_animation.handle_decrease()
            elif event.type == pygame.USEREVENT + 1:  # 延遲煙花
                heart_animation.create_firework_wave(
                    heart_animation.mouse["x"],
                    heart_animation.mouse["y"],
                    120,
                    10,
                    False,
                    1.5,
                )
            elif event.type == pygame.USEREVENT + 2:  # 精細(xì)粒子
                heart_animation.create_firework_wave(
                    heart_animation.mouse["x"],
                    heart_animation.mouse["y"],
                    150,
                    15,
                    True,
                )
        # 填充背景
        screen.fill((26, 26, 46))  # 深色背景
        # 更新和繪制粒子
        if not heart_animation.is_paused:
            # 更新粒子
            for i in range(len(heart_animation.particles) - 1, -1, -1):
                heart_animation.particles[i].update()
                if not heart_animation.particles[i].is_alive():
                    heart_animation.particles.pop(i)
            # 補(bǔ)充心形粒子
            heart_count = sum(1 for p in heart_animation.particles if p.type == "heart")
            if heart_count < heart_animation.heart_particle_count:
                to_add = min(
                    heart_animation.heart_regen_rate,
                    heart_animation.heart_particle_count - heart_count,
                )
                heart_animation.regenerate_heart_particles(to_add)
        # 繪制所有粒子
        for particle in heart_animation.particles:
            particle.draw()
        # 繪制UI
        heart_animation.draw_ui()
        # 更新顯示
        pygame.display.flip()
        # 控制幀率
        clock.tick(60)
    pygame.quit()
    sys.exit()
if __name__ == "__main__":
    main()