weathr 1.0.0

A terminal-based ASCII weather application with animated scenes driven by real-time weather data
Documentation 
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

use crate::render::TerminalRenderer;
use crossterm::style::Color;
use std::io;

struct Star {
    x: u16,
    y: u16,
    brightness: f32,
    phase: f32,
}

struct ShootingStar {
    x: f32,
    y: f32,
    speed_x: f32,
    speed_y: f32,
    length: usize,
    active: bool,
}

pub struct StarSystem {
    stars: Vec<Star>,
    shooting_star: Option<ShootingStar>,
    terminal_width: u16,
    terminal_height: u16,
}

impl StarSystem {
    pub fn new(terminal_width: u16, terminal_height: u16) -> Self {
        let count = (terminal_width as usize * terminal_height as usize) / 80; // Density
        let mut stars = Vec::with_capacity(count);

        for _ in 0..count {
            stars.push(Star {
                x: rand::random::<u16>() % terminal_width,
                y: rand::random::<u16>() % (terminal_height / 2), // Upper half
                brightness: rand::random::<f32>(),
                phase: rand::random::<f32>() * std::f32::consts::TAU,
            });
        }

        Self {
            stars,
            shooting_star: None,
            terminal_width,
            terminal_height,
        }
    }

    pub fn update(&mut self, terminal_width: u16, terminal_height: u16) {
        self.terminal_width = terminal_width;
        self.terminal_height = terminal_height;

        // Twinkle
        for star in &mut self.stars {
            star.phase += 0.05;
            star.brightness = (star.phase.sin() + 1.0) / 2.0; // 0.0 to 1.0
        }

        // Shooting Star Logic
        if let Some(ref mut star) = self.shooting_star {
            star.x += star.speed_x;
            star.y += star.speed_y;

            if star.x < 0.0 || star.y as u16 >= terminal_height || star.length == 0 {
                self.shooting_star = None;
            }
        } else if rand::random::<f32>() < 0.005 {
            let start_x = (rand::random::<u16>() % (terminal_width / 2)) + (terminal_width / 4);
            let start_y = rand::random::<u16>() % (terminal_height / 4);

            self.shooting_star = Some(ShootingStar {
                x: start_x as f32,
                y: start_y as f32,
                speed_x: if rand::random::<bool>() { 1.5 } else { -1.5 },
                speed_y: 0.5 + (rand::random::<f32>() * 0.5),
                length: 5,
                active: true,
            });
        }
    }

    pub fn render(&self, renderer: &mut TerminalRenderer) -> io::Result<()> {
        for star in &self.stars {
            let ch = if star.brightness > 0.8 {
                '*'
            } else if star.brightness > 0.4 {
                '+'
            } else {
                '.'
            };
            let color = if star.brightness > 0.6 {
                Color::White
            } else {
                Color::DarkGrey
            };

            renderer.render_char(star.x, star.y, ch, color)?;
        }

        if let Some(ref star) = self.shooting_star {
            if star.active {
                let head_x = star.x as i16;
                let head_y = star.y as i16;

                if head_x >= 0
                    && head_x < self.terminal_width as i16
                    && head_y >= 0
                    && head_y < self.terminal_height as i16
                {
                    renderer.render_char(head_x as u16, head_y as u16, '*', Color::White)?;
                }

                // Trail
                for i in 1..star.length {
                    let trail_x = (star.x - (star.speed_x * i as f32)) as i16;
                    let trail_y = (star.y - (star.speed_y * i as f32)) as i16;

                    if trail_x >= 0
                        && trail_x < self.terminal_width as i16
                        && trail_y >= 0
                        && trail_y < self.terminal_height as i16
                    {
                        let ch = if i == 1 { '+' } else { '.' };
                        renderer.render_char(trail_x as u16, trail_y as u16, ch, Color::White)?;
                    }
                }
            }
        }

        Ok(())
    }
}