code煙火

1
import pygame
2
import random
3
import math
4

5
vector = pygame.math.Vector2
6

7
gravity = vector(0, 0.3)
8
DISPLAY_WIDTH = DISPLAY_HEIGHT = 800
9

10
trail_colours = [(45, 45, 45), (60, 60, 60), (75, 75, 75), (125, 125, 125), (150, 150, 150)]
11
dynamic_offset = 1
12
static_offset = 3
13

14
MAX_FIREWORKS = 200
15
MAX_PARTICLES = 5000
16

17
class Firework:
18
    def __init__(self):
19
        self.colour = (random.randint(0, 255), random.randint(0, 255), random.randint(0, 255))
20
        self.colours = (
21
            (random.randint(0, 255), random.randint(0, 255), random.randint(0, 255)),
22
            (random.randint(0, 255), random.randint(0, 255), random.randint(0, 255)),
23
            (random.randint(0, 255), random.randint(0, 255), random.randint(0, 255)))
24
        self.firework = Particle(random.randint(0, DISPLAY_WIDTH), DISPLAY_HEIGHT, True,
25
                                 self.colour)
26
        self.exploded = False
27
        self.particles = []
28
        self.min_max_particles = (100, 225)
29

30
    def uppubDate(self, win):
31
        if not self.exploded:
32
            self.firework.apply_force(gravity)
33
            self.firework.move()
34
            for tf in self.firework.trails:
35
                tf.show(win)
36

37
            self.show(win)
38

39
            if self.firework.vel.y >= 0:
40
                self.exploded = True
41
                self.explode()
42
        else:
43
            for particle in self.particles:
44
                particle.apply_force(vector(gravity.x + random.uniform(-1, 1) / 20, gravity.y / 2 + (random.randint(1, 8) / 100)))
45
                particle.move()
46
                for t in particle.trails:
47
                    t.show(win)
48
                particle.show(win)
49

50
    def explode(self):
51
        amount = random.randint(*self.min_max_particles)
52
        for i in range(amount):
53
            self.particles.append(Particle(self.firework.pos.x, self.firework.pos.y, False, self.colours))
54

55
    def show(self, win):
56
        pygame.draw.circle(win, self.colour, (int(self.firework.pos.x), int(self.firework.pos.y)), self.firework.size)
57

58
    def remove(self):
59
        if self.exploded:
60
            for p in self.particles:
61
                if p.remove is True:
62
                    self.particles.remove(p)
63

64
            if len(self.particles) == 0:
65
                return True
66
            else:
67
                return False
68

69
class Particle:
70
    def __init__(self, x, y, firework, colour):
71
        self.firework = firework
72
        self.pos = vector(x, y)
73
        self.origin = vector(x, y)
74
        self.radius = 20
75
        self.remove = False
76
        self.explosion_radius = random.randint(5, 18)
77
        self.life = 0
78
        self.acc = vector(0, 0)
79
        self.trails = []
80
        self.prev_posx = [-10] * 10
81
        self.prev_posy = [-10] * 10
82

83
        if self.firework:
84
            self.vel = vector(0, -random.randint(17, 20))
85
            self.size = 5
86
            self.colour = colour
87
            for i in range(5):
88
                self.trails.append(Trail(i, self.size, True))
89
        else:
90
            self.vel = vector(random.uniform(-1, 1), random.uniform(-1, 1))
91
            self.vel.x *= random.randint(3, self.explosion_radius)
92
            self.vel.y *= random.randint(3, self.explosion_radius)
93
            self.size = random.randint(2, 4)
94
            self.colour = random.choice(colour)
95
            for i in range(5):
96
                self.trails.append(Trail(i, self.size, False))
97

98
    def apply_force(self, force):
99
        self.acc += force
100

101
    def move(self):
102
        if not self.firework:
103
            self.vel.x *= 0.9
104
            self.vel.y *= 0.9
105
        self.vel += self.acc
106
        self.pos += self.vel
107
        self.acc *= 0
108

109
        if self.life == 0 and not self.firework:
110
            distance = math.sqrt((self.pos.x - self.origin.x) ** 2 + (self.pos.y - self.origin.y) ** 2)
111
            if distance > self.explosion_radius:
112
                self.remove = True
113

114
        if self.vel.length() < 0.5:
115
            self.remove = True
116

117
        self.decay()
118

119
        self.trail_uppubDate()
120

121
        self.life += 1
122

123
    def show(self, win):
124
        pygame.draw.circle(win, (self.colour[0], self.colour[1], self.colour[2], 0), (int(self.pos.x), int(self.pos.y)),
125
                           self.size)
126

127
    def decay(self):
128
        if 50 > self.life > 10:
129
            ran = random.randint(0, 30)
130
            if ran == 0:
131
                self.remove = True
132
        elif self.life > 50:
133
            ran = random.randint(0, 5)
134
            if ran == 0:
135
                self.remove = True
136

137
    def trail_uppubDate(self):
138
        self.prev_posx.pop()
139
        self.prev_posx.insert(0, int(self.pos.x))
140
        self.prev_posy.pop()
141
        self.prev_posy.insert(0, int(self.pos.y))
142

143
        for n, t in enumerate(self.trails):
144
            if t.dynamic:
145
                t.get_pos(self.prev_posx[n + dynamic_offset], self.prev_posy[n + dynamic_offset])
146
            else:
147
                t.get_pos(self.prev_posx[n + static_offset], self.prev_posy[n + static_offset])
148

149
class Trail:
150
    def __init__(self, n, size, dynamic):
151
        self.pos_in_line = n
152
        self.pos = vector(-10, -10)
153
        self.dynamic = dynamic
154

155
        if self.dynamic:
156
            self.colour = trail_colours[n]
157
            self.size = int(size - n / 2)
158
        else:
159
            self.colour = (255, 255, 200)
160
            self.size = size - 2
161
            if self.size < 0:
162
                self.size = 0
163

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

167
    def show(self, win):
168
        pygame.draw.circle(win, self.colour, (int(self.pos.x), int(self.pos.y)), self.size)
169

170
def uppubDate(win, fireworks):
171
    to_remove = []
172
    for fw in fireworks:
173
        fw.uppubDate(win)
174
        if fw.remove():
175
            to_remove.append(fw)
176

177
    for fw in to_remove:
178
        fireworks.remove(fw)
179

180
    pygame.display.uppubDate()
181

182
def main():
183
    pygame.init()
184
    pygame.font.init()
185
    pygame.display.set_caption("HI")
186

187
    win = pygame.display.set_mode((DISPLAY_WIDTH, DISPLAY_HEIGHT))
188
    clock = pygame.time.Clock()
189

190
    fireworks = [Firework() for i in range(2)]
191
    running = True
192

193
    while running:
194
        clock.tick(60)
195
        for event in pygame.event.get():
196
            if event.type == pygame.QUIT:
197
                running = False
198
            if event.type == pygame.KEYDOWN:
199
                if event.key == pygame.K_1:
200
                    if len(fireworks) < MAX_FIREWORKS:
201
                        fireworks.append(Firework())
202
                if event.key == pygame.K_2:
203
                    for i in range(10):
204
                        if len(fireworks) < MAX_FIREWORKS:
205
                            fireworks.append(Firework())
206
                if event.key == pygame.K_3:
207
                    for i in range(100):
208
                        if len(fireworks) < MAX_FIREWORKS:
209
                            fireworks.append(Firework())
210
        win.fill((20, 20, 30))
211

212
        if random.randint(0, 20) == 1 and len(fireworks) < MAX_FIREWORKS:
213
            fireworks.append(Firework())
214

215
        total_particles = sum(len(fw.particles) for fw in fireworks)
216
        if total_particles > MAX_PARTICLES:
217
            for fw in fireworks:
218
                fw.particles = fw.particles[:MAX_PARTICLES // len(fireworks)]
219

220
        uppubDate(win, fireworks)
221

222
    pygame.quit()
223
    quit()
224

225
if __name__ == '__main__':
226
    main()

1
const canvas = document.createElement('canvas');
2
const ctx = canvas.getContext('2d');
3
document.body.appendChild(canvas);
4

5
const gravity = { x: 0, y: 0.3 };
6
const DISPLAY_WIDTH = 800;
7
const DISPLAY_HEIGHT = 800;
8

9
const trail_colours = [
10
    [45, 45, 45],
11
    [60, 60, 60],
12
    [75, 75, 75],
13
    [125, 125, 125],
14
    [150, 150, 150]
15
];
16
const dynamic_offset = 1;
17
const static_offset = 3;
18

19
const MAX_FIREWORKS = 200;
20
const MAX_PARTICLES = 5000;
21

22
class Firework {
23
    constructor() {
24
        this.colour = [
25
            Math.floor(Math.random() * 256),
26
            Math.floor(Math.random() * 256),
27
            Math.floor(Math.random() * 256)
28
        ];
29
        this.colours = [
30
            [
31
                Math.floor(Math.random() * 256),
32
                Math.floor(Math.random() * 256),
33
                Math.floor(Math.random() * 256)
34
            ],
35
            [
36
                Math.floor(Math.random() * 256),
37
                Math.floor(Math.random() * 256),
38
                Math.floor(Math.random() * 256)
39
            ],
40
            [
41
                Math.floor(Math.random() * 256),
42
                Math.floor(Math.random() * 256),
43
                Math.floor(Math.random() * 256)
44
            ]
45
        ];
46
        this.firework = new Particle(
47
            Math.floor(Math.random() * DISPLAY_WIDTH),
48
            DISPLAY_HEIGHT,
49
            true,
50
            this.colour
51
        );
52
        this.exploded = false;
53
        this.particles = [];
54
        this.min_max_particles = [100, 225];
55
    }
56

57
    uppubDate() {
58
        if (!this.exploded) {
59
            this.firework.apply_force(gravity);
60
            this.firework.move();
61
            this.firework.show();
62
            if (this.firework.vel.y >= 0) {
63
                this.exploded = true;
64
                this.explode();
65
            }
66
        } else {
67
            for (const particle of this.particles) {
68
                particle.apply_force({
69
                    x: gravity.x + (Math.random() - 0.5) / 20,
70
                    y: gravity.y / 2 + (Math.floor(Math.random() * 8) + 1) / 100
71
                });
72
                particle.move();
73
                particle.show();
74
            }
75
        }
76
    }
77

78
    explode() {
79
        const amount = Math.floor(
80
            Math.random() * (this.min_max_particles[1] - this.min_max_particles[0] + 1) +
81
            this.min_max_particles[0]
82
        );
83
        for (let i = 0; i < amount; i++) {
84
            this.particles.push(
85
                new Particle(this.firework.pos.x, this.firework.pos.y, false, this.colours)
86
            );
87
        }
88
    }
89

90
    remove() {
91
        if (this.exploded) {
92
            this.particles = this.particles.filter((p) => !p.remove);
93
            return this.particles.length === 0;
94
        }
95
        return false;
96
    }
97
}
98

99
class Particle {
100
    constructor(x, y, firework, colour) {
101
        this.firework = firework;
102
        this.pos = { x, y };
103
        this.origin = { x, y };
104
        this.radius = 20;
105
        this.remove = false;
106
        this.explosion_radius = Math.floor(Math.random() * 14) + 5;
107
        this.life = 0;
108
        this.acc = { x: 0, y: 0 };
109
        this.trails = [];
110
        this.prev_posx = Array(10).fill(-10);
111
        this.prev_posy = Array(10).fill(-10);
112

113
        if (this.firework) {
114
            this.vel = { x: 0, y: -Math.floor(Math.random() * 4) - 17 };
115
            this.size = 5;
116
            this.colour = colour;
117
            for (let i = 0; i < 5; i++) {
118
                this.trails.push(new Trail(i, this.size, true));
119
            }
120
        } else {
121
            this.vel = {
122
                x: (Math.random() - 0.5) * 2 * Math.floor(Math.random() * this.explosion_radius),
123
                y: (Math.random() - 0.5) * 2 * Math.floor(Math.random() * this.explosion_radius)
124
            };
125
            this.size = Math.floor(Math.random() * 3) + 2;
126
            this.colour = colour[Math.floor(Math.random() * colour.length)];
127
            for (let i = 0; i < 5; i++) {
128
                this.trails.push(new Trail(i, this.size, false));
129
            }
130
        }
131
    }
132

133
    apply_force(force) {
134
        this.acc.x += force.x;
135
        this.acc.y += force.y;
136
    }
137

138
    move() {
139
        if (!this.firework) {
140
            this.vel.x *= 0.9;
141
            this.vel.y *= 0.9;
142
        }
143
        this.vel.x += this.acc.x;
144
        this.vel.y += this.acc.y;
145
        this.pos.x += this.vel.x;
146
        this.pos.y += this.vel.y;
147
        this.acc.x = 0;
148
        this.acc.y = 0;
149

150
        if (this.life === 0 && !this.firework) {
151
            const distance = Math.sqrt(
152
                (this.pos.x - this.origin.x) ** 2 + (this.pos.y - this.origin.y) ** 2
153
            );
154
            if (distance > this.explosion_radius) {
155
                this.remove = true;
156
            }
157
        }
158

159
        if (Math.abs(this.vel.x) < 0.5 && Math.abs(this.vel.y) < 0.5) {
160
            this.remove = true;
161
        }
162

163
        this.decay();
164
        this.trail_uppubDate();
165
        this.life++;
166
    }
167

168
    show() {
169
        ctx.beginPath();
170
        ctx.arc(this.pos.x, this.pos.y, this.size, 0, Math.PI * 2);
171
        ctx.fillStyle = `rgba(${this.colour[0]}, ${this.colour[1]}, ${this.colour[2]}, 1)`;
172
        ctx.fill();
173
    }
174

175
    decay() {
176
        if (this.life > 10 && this.life < 50 && Math.random() < 0.03) {
177
            this.remove = true;
178
        } else if (this.life >= 50 && Math.random() < 0.2) {
179
            this.remove = true;
180
        }
181
    }
182

183
    trail_uppubDate() {
184
        this.prev_posx.pop();
185
        this.prev_posx.unshift(this.pos.x);
186
        this.prev_posy.pop();
187
        this.prev_posy.unshift(this.pos.y);
188

189
        for (let n = 0; n < this.trails.length; n++) {
190
            const t = this.trails[n];
191
            if (t.dynamic) {
192
                t.get_pos(this.prev_posx[n + dynamic_offset], this.prev_posy[n + dynamic_offset]);
193
            } else {
194
                t.get_pos(this.prev_posx[n + static_offset], this.prev_posy[n + static_offset]);
195
            }
196
        }
197
    }
198
}
199

200
class Trail {
201
    constructor(n, size, dynamic) {
202
        this.pos_in_line = n;
203
        this.pos = { x: -10, y: -10 };
204
        this.dynamic = dynamic;
205

206
        if (this.dynamic) {
207
            this.colour = `rgb(${trail_colours[n][0]}, ${trail_colours[n][1]}, ${trail_colours[n][2]})`;
208
            this.size = size - n / 2;
209
        } else {
210
            this.colour = 'rgb(255, 255, 200)';
211
            this.size = size - 2;
212
            if (this.size < 0) {
213
                this.size = 0;
214
            }
215
        }
216
    }
217

218
    get_pos(x, y) {
219
        this.pos = { x, y };
220
    }
221

222
    show() {
223
        ctx.beginPath();
224
        ctx.arc(this.pos.x, this.pos.y, this.size, 0, Math.PI * 2);
225
        ctx.fillStyle = this.colour;
226
        ctx.fill();
227
    }
228
}
229

230
function uppubDate(fireworks) {
231
    const to_remove = [];
232
    fireworks.forEach((fw) => {
233
        fw.uppubDate();
234
        if (fw.remove()) {
235
            to_remove.push(fw);
236
        }
237
    });
238

239
    to_remove.forEach((fw) => {
240
        const index = fireworks.indexOf(fw);
241
        fireworks.splice(index, 1);
242
    });
243
}
244

245
function main() {
246
    canvas.width = DISPLAY_WIDTH;
247
    canvas.height = DISPLAY_HEIGHT;
248

249
    const fireworks = Array.from({ length: 2 }, () => new Firework());
250

251
    setInterval(() => {
252
        if (fireworks.length < MAX_FIREWORKS && Math.random() < 0.05) {
253
            fireworks.push(new Firework());
254
        }
255
    }, 100);
256

257
    setInterval(() => {
258
        if (fireworks.length < MAX_FIREWORKS && Math.random() < 0.1) {
259
            for (let i = 0; i < 10; i++) {
260
                if (fireworks.length < MAX_FIREWORKS) {
261
                    fireworks.push(new Firework());
262
                }
263
            }
264
        }
265
    }, 500);
266

267
    setInterval(() => {
268
        if (fireworks.length < MAX_FIREWORKS && Math.random() < 0.2) {
269
            for (let i = 0; i < 100; i++) {
270
                if (fireworks.length < MAX_FIREWORKS) {
271
                    fireworks.push(new Firework());
272
                }
273
            }
274
        }
275
    }, 1000);
276

277
    function animate() {
278
        ctx.fillStyle = 'rgba(20, 20, 30, 0.2)';
279
        ctx.fillRect(0, 0, DISPLAY_WIDTH, DISPLAY_HEIGHT);
280
        uppubDate(fireworks);
281
        requestAnimationFrame(animate);
282
    }
283

284
    animate();
285
}
286

287
main();