termflix 0.7.2

Terminal animation player with 60 procedurally generated animations, multiple render modes, and true color support
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

use super::Animation;
use crate::render::Canvas;
use rand::RngExt;

struct Petal {
    x: f64,
    y: f64,
    vx: f64,
    vy: f64,
    spin: f64,
    spin_speed: f64,
    size: f64,
    shade: f64,
}

/// Cherry blossom petals drifting and spinning in wind
pub struct Petals {
    width: usize,
    height: usize,
    petals: Vec<Petal>,
    wind: f64,
    wind_target: f64,
    wind_timer: f64,
    rng: rand::rngs::ThreadRng,
}

impl Petals {
    pub fn new(width: usize, height: usize, scale: f64) -> Self {
        let mut rng = rand::rng();
        let count = ((width * height) as f64 / 150.0 * scale) as usize;
        let petals = (0..count)
            .map(|_| Petal {
                x: rng.random_range(0.0..width as f64),
                y: rng.random_range(-(height as f64 * 2.0)..(height as f64)),
                vx: rng.random_range(-2.0..2.0),
                vy: rng.random_range(3.0..8.0),
                spin: rng.random_range(0.0..std::f64::consts::TAU),
                spin_speed: rng.random_range(-3.0..3.0),
                size: rng.random_range(0.4..1.0),
                shade: rng.random_range(0.0..1.0),
            })
            .collect();
        Petals {
            width,
            height,
            petals,
            wind: 2.0,
            wind_target: 2.0,
            wind_timer: 0.0,
            rng: rand::rng(),
        }
    }
}

impl Animation for Petals {
    fn name(&self) -> &str {
        "petals"
    }

    fn on_resize(&mut self, width: usize, height: usize) {
        self.width = width;
        self.height = height;
    }

    fn update(&mut self, canvas: &mut Canvas, dt: f64, time: f64) {
        let w = self.width as f64;
        let h = self.height as f64;

        // Vary wind
        self.wind_timer -= dt;
        if self.wind_timer <= 0.0 {
            self.wind_target = self.rng.random_range(-3.0..5.0);
            self.wind_timer = self.rng.random_range(2.0..5.0);
        }
        self.wind += (self.wind_target - self.wind) * dt * 0.5;

        canvas.clear();

        for petal in &mut self.petals {
            // Spin
            petal.spin += petal.spin_speed * dt;

            // Wind and gravity
            let wobble = (time * 1.5 + petal.x * 0.05).sin() * 2.0;
            petal.vx += (self.wind + wobble - petal.vx) * dt * 0.5;
            petal.vy += (5.0 - petal.vy) * dt * 0.3;

            // Flutter effect based on spin
            let flutter = petal.spin.sin() * 1.5;
            petal.vx += flutter * dt;

            petal.x += petal.vx * dt;
            petal.y += petal.vy * dt;

            // Reset when off screen
            if petal.y > h + 5.0 || petal.x > w + 10.0 || petal.x < -10.0 {
                petal.x = self.rng.random_range(0.0..w);
                petal.y = self.rng.random_range(-20.0..-2.0);
                petal.vy = self.rng.random_range(3.0..8.0);
                petal.vx = self.rng.random_range(-2.0..2.0);
                petal.spin_speed = self.rng.random_range(-3.0..3.0);
            }

            // Draw petal as a small cluster based on spin angle
            let apparent_width = petal.spin.cos().abs() * petal.size;
            let brightness = 0.6 + apparent_width * 0.4;

            let (r, g, b) = petal_color(petal.shade);

            let px = petal.x as usize;
            let py = petal.y as usize;
            if px < canvas.width && py < canvas.height {
                canvas.set_colored(px, py, brightness, r, g, b);
            }

            // Draw second pixel for wider petals
            if apparent_width > 0.5 {
                let px2 = (petal.x + petal.spin.cos()) as usize;
                let py2 = (petal.y + petal.spin.sin() * 0.5) as usize;
                if px2 < canvas.width && py2 < canvas.height {
                    canvas.set_colored(px2, py2, brightness * 0.7, r, g, b);
                }
            }
        }
    }
}

fn petal_color(shade: f64) -> (u8, u8, u8) {
    if shade < 0.3 {
        // White petal
        (255, 240, 245)
    } else if shade < 0.6 {
        // Light pink
        (255, 182, 193)
    } else if shade < 0.85 {
        // Medium pink
        (255, 150, 170)
    } else {
        // Deep pink
        (238, 130, 160)
    }
}