python2025跨年代码

import pygame
from random import randint, uniform, choice
import math

vector = pygame.math.Vector2
# 定义重力
gravity = vector(0, 0.3)
# 定义显示的长和宽
DISPLAY_WIDTH = DISPLAY_HEIGHT = 800

# 定义烟花上升时的后面的轨迹颜色
trail_colours = [(150, 150, 150), (125, 125, 125), (75, 75, 75), (60, 60, 60), (45, 45, 45)]
# 对轨迹长度的控制，在运动的时候使用步长短的，在快要静止的时候使用大步长以得到更好的移动视觉效果
dynamic_offset = 1
static_offset = 3


class Firework:
    """
    烟花类
    """
    def __init__(self):
        # 该烟花上升时候的随机颜色
        self.colour = (randint(0, 255), randint(0, 255), randint(0, 255))
        # 该烟花爆炸的时候的随机颜色
        self.colours = (
            (randint(0, 255), randint(0, 255), randint(0, 255)),
            (randint(0, 255), randint(0, 255), randint(0, 255)),
            (randint(0, 255), randint(0, 255), randint(0, 255))
        )
        # 该烟花上升时候的轨迹
        self.firework = Particle(randint(0 + 100, DISPLAY_WIDTH - 100), DISPLAY_HEIGHT, True,
                                 self.colour)  # Creates the firework particle
        # 该烟花的爆炸状态
        self.exploded = False
        # 该烟花爆炸的时候的轨迹
        self.particles = []
        # 爆炸后分裂出的轨迹条数的范围
        self.min_max_particles = vector(100, 225)

    def update(self, win):  # called every frame
        # 如果不是爆炸状态
        if not self.exploded:
            # 施加重力影响
            self.firework.apply_force(gravity)
            # 让所有的粒子运动起来
            self.firework.move()
            # 将上升烟花的轨迹显示出来
            for tf in self.firework.trails:
                tf.show(win)
            # 将自己（也就是上升的烟花）显示出来
            self.show(win)

            # 垂直速度=0的时候烟花爆炸
            if self.firework.vel.y >= 0:
                self.exploded = True
                self.explode()

        # 如果是爆炸状态
        else:
            # 遍历所有爆炸后的烟花轨迹
            for particle in self.particles:
                # 对一条烟花施加重力，改变其x和y方向的加速度
                particle.apply_force(vector(gravity.x + uniform(-1, 1) / 20, gravity.y / 2 + (randint(1, 8) / 100)))
                # 让其根据此运动
                particle.move()
                # 显示其中一条轨迹粒子和其爆炸烟花
                for t in particle.trails:
                    t.show(win)
                particle.show(win)

    def explode(self):
        # amount 爆炸后分裂出的轨迹条数的随机数量
        amount = randint(int(self.min_max_particles.x), int(self.min_max_particles.y))
        # 创建相应数量的轨迹
        for i in range(amount):
            self.particles.append(Particle(self.firework.pos.x, self.firework.pos.y, False, self.colours))

    def show(self, win):
        # 根据坐标在窗口上画点
        pygame.draw.circle(win, self.colour, (int(self.firework.pos.x), int(self.firework.pos.y)), self.firework.size)

    def remove(self):
        # 执行在爆炸后的对烟花的清除
        if self.exploded:
            # 遍历所有爆炸后的烟花轨迹
            for p in self.particles:
                # 如果其中一条轨迹是要清除的状态，就清除它
                if p.remove is True:
                    self.particles.remove(p)

            # 如果当前爆炸后的烟花已经没有没被清除轨迹了，返回true
            if len(self.particles) == 0:
                return True
            # 如果还有轨迹没被清除，返回false
            else:
                return False


class Particle:
    """
    轨迹类
    """
    def __init__(self, x, y, firework, colour):
        # 这个是定义轨迹的类别的，如果是True就说明这里是烟花上升时候的轨迹，如果是False就说明是烟花爆炸后的轨迹
        self.firework = firework
        # 该轨迹当前位置
        self.pos = vector(x, y)
        # 该轨迹初始位置
        self.origin = vector(x, y)
        # 判定该轨迹是否是需要移除的状态
        self.remove = False
        # 随机取一个该轨迹的爆炸半径，是一个后面设置爆炸后轨迹初速度的参数
        self.explosion_radius = randint(5, 40)
        # 该轨迹已经存在的时间
        self.life = 0
        # 该轨迹的加速度
        self.acc = vector(0, 0)
        # trail variables 有关轨迹后面的点的参数
        self.trails = []  # stores the particles trail objects 存储当前轨迹中的一些点
        self.prev_posx = [-10] * 10  # stores the 10 last positions 存储该轨迹走过的最后的10个位置的x值
        self.prev_posy = [-10] * 10  # stores the 10 last positions 存储该轨迹走过的最后的10个位置的y值

        # 如果是上升的轨迹
        if self.firework:
            # 设置随机垂直初速度、水平初速度
            self.vel = vector(randint(-4, 4), -randint(17, 20))
            # 轨迹的粒子大小一定
            self.size = 5
            # 设置颜色为预先设定好的颜色
            self.colour = colour
            # 加入5个作为轨迹的点
            for i in range(5):
                self.trails.append(Trail(i, self.size, True))
        # 如果是爆炸后的轨迹
        else:
            # 设置向四周发射的初速度
            self.vel = vector(uniform(-1, 1), uniform(-1, 1))
            self.vel.x *= randint(7, self.explosion_radius + 2)
            self.vel.y *= randint(7, self.explosion_radius + 2)
            # 爆炸后的轨迹大小
            self.size = randint(2, 4)
            # 随机选择一个颜色作为该轨迹的颜色
            self.colour = choice(colour)
            # 加入5个作为轨迹的点
            for i in range(5):
                self.trails.append(Trail(i, self.size, False))

    def apply_force(self, force):
        # 粒子受力通过改变加速度体现
        self.acc += force

    def move(self):
        if not self.firework:  # 如果是爆炸后的轨迹，速度需要有一个百分比减小
            self.vel.x *= 0.8
            self.vel.y *= 0.8
        # 这里应该是默认了经过了单位时间，直接计算速度和位移坐标，之后重置加速度
        self.vel += self.acc
        self.pos += self.vel
        self.acc *= 0

        if self.life == 0 and not self.firework:  # check if particle is outside explosion radius 检查是否爆炸产生的粒子大于爆炸半径
            distance = math.sqrt((self.pos.x - self.origin.x) ** 2 + (self.pos.y - self.origin.y) ** 2)
            if distance > self.explosion_radius:
                self.remove = True

        # 引入随机衰变，具体看这个函数的实现
        self.decay()

        # 更新轨迹，具体看这个函数的实现
        self.trail_update()

        # 持续单位时间+1
        self.life += 1

    def show(self, win):
        # 显示该轨迹
        pygame.draw.circle(win, (self.colour[0], self.colour[1], self.colour[2], 0), (int(self.pos.x), int(self.pos.y)),
                           self.size)

    def decay(self):  # random decay of the particles 让粒子随机消失
        # 存在时间小于10的粒子不会再这里标记消失
        if 50 > self.life > 10:  # early stage there is a small chance of decay 在存在时间为10到50的早期粒子被标记消失的可能性小
            ran = randint(0, 30)  # 如果是真随机，1/30的机率
            if ran == 0:
                self.remove = True
        elif self.life > 50:  # 存在时间大于50的晚期粒子被标记消失的可能性更大
            ran = randint(0, 5)  # 如果是真随机，1/5的机率
            if ran == 0:
                self.remove = True

    def trail_update(self):
        # 将最老的位置数据删除，将当前的位置数据加入（模拟队列数据结构）
        self.prev_posx.pop()
        self.prev_posx.insert(0, int(self.pos.x))
        self.prev_posy.pop()
        self.prev_posy.insert(0, int(self.pos.y))

        # 遍历并更新当前轨迹下所有的轨迹点
        for n, t in enumerate(self.trails):
            if t.dynamic:  # 如果是上升时候的轨迹，轨迹点更密集
                t.get_pos(self.prev_posx[n + dynamic_offset], self.prev_posy[n + dynamic_offset])
            else:  # 如果是爆炸后的轨迹，轨迹点更稀疏
                t.get_pos(self.prev_posx[n + static_offset], self.prev_posy[n + static_offset])


class Trail:
    """
    轨迹中的一个轨迹点
    """
    def __init__(self, n, size, dynamic):
        # 轨迹点的位置，是该轨迹中的第几个轨迹点
        self.pos_in_line = n
        # 轨迹点的初始位置
        self.pos = vector(-10, -10)
        # 该参数将轨迹分为两类，True的话就是上升时候的轨迹点，False的话就是爆炸后的轨迹点
        self.dynamic = dynamic

        if self.dynamic:  # 如果是上升的轨迹点
            self.colour = trail_colours[n]
            self.size = int(size - n / 2)
        else:  # 如果是爆炸后的轨迹点
            self.colour = (255, 255, 200)
            self.size = size - 2
            if self.size < 0:
                self.size = 0

    def get_pos(self, x, y):
        self.pos = vector(x, y)

    def show(self, win):
        # 显示该轨迹点
        pygame.draw.circle(win, self.colour, (int(self.pos.x), int(self.pos.y)), self.size)


def update(win, fireworks):
    # 更新所有的烟花，如果有要删除的也就删除烟花
    for fw in fireworks:
        fw.update(win)
        if fw.remove():
            fireworks.remove(fw)

    pygame.display.update()


def main():
    pygame.init()
    pygame.font.init()
    pygame.display.set_caption("Fireworks in Pygame")  # 标题

    win = pygame.display.set_mode((DISPLAY_WIDTH, DISPLAY_HEIGHT))  # 显示的位置
    clock = pygame.time.Clock()

    fireworks = [Firework() for i in range(2)]  # create the first fireworks
    running = True

    while running:
        clock.tick(50)  # 可以理解为刷新频率，也就是1秒内刷新画面的次数，次数越大，烟花的速度就越快
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                running = False
            if event.type == pygame.KEYDOWN:  # Change game speed with number keys
                if event.key == pygame.K_1:  # 按下 1 立即加入1个烟花
                    fireworks.append(Firework())
                if event.key == pygame.K_2:  # 按下 2 立即加入10个烟花
                    for i in range(10):
                        fireworks.append(Firework())
        win.fill((20, 20, 30))  # draw background

        if randint(0, 20) == 1:  # create new firework
            fireworks.append(Firework())

        update(win, fireworks)
        # stats for fun
        # total_particles = 0
        # for f in fireworks:
        #    total_particles += len(f.particles)
        #
        # print(f"Fireworks: {len(fireworks)}\nParticles: {total_particles}\n\n")

    pygame.quit()
    quit()


if __name__ == "__main__":
    main()