weathr 1.2.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
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163

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

#[derive(Default)]
pub struct Decorations;

pub struct DecorationRenderConfig {
    pub horizon_y: u16,
    pub house_x: u16,
    pub house_width: u16,
    pub width: u16,
    pub is_day: bool,
}

impl Decorations {
    pub fn new() -> Self {
        Self
    }

    pub fn render(
        &self,
        renderer: &mut TerminalRenderer,
        config: &DecorationRenderConfig,
    ) -> io::Result<()> {
        // Render Tree (Left of house)
        let (tree_lines, tree_color) = self.get_tree(config.is_day);
        let tree_height = tree_lines.len() as u16;
        let tree_y = config.horizon_y.saturating_sub(tree_height);
        let tree_x = config.house_x.saturating_sub(20);

        if tree_x > 0 {
            for (i, line) in tree_lines.iter().enumerate() {
                for (j, ch) in line.chars().enumerate() {
                    if ch != ' ' {
                        renderer.render_char(
                            tree_x + j as u16,
                            tree_y + i as u16,
                            ch,
                            tree_color,
                        )?;
                    }
                }
            }
        }

        // Render Fence (Right of house)
        let (fence_lines, fence_color) = self.get_fence(config.is_day);
        let fence_height = fence_lines.len() as u16;
        let fence_y = config.horizon_y.saturating_sub(fence_height); // Sitting on ground
        let fence_x = config.house_x + config.house_width + 2; // Slight gap

        if fence_x < config.width {
            for (i, line) in fence_lines.iter().enumerate() {
                for (j, ch) in line.chars().enumerate() {
                    if ch != ' ' {
                        renderer.render_char(
                            fence_x + j as u16,
                            fence_y + i as u16,
                            ch,
                            fence_color,
                        )?;
                    }
                }
            }
        }

        // Render Mailbox (On ground top level, left of tree)
        let (mailbox_lines, mailbox_color) = self.get_mailbox(config.is_day);
        let mailbox_height = mailbox_lines.len() as u16;
        let mailbox_x = tree_x.saturating_sub(10); // Left of tree
        let mailbox_y = config.horizon_y.saturating_sub(mailbox_height); // On ground top

        if mailbox_x < config.width {
            for (i, line) in mailbox_lines.iter().enumerate() {
                for (j, ch) in line.chars().enumerate() {
                    if ch != ' ' {
                        renderer.render_char(
                            mailbox_x + j as u16,
                            mailbox_y + i as u16,
                            ch,
                            mailbox_color,
                        )?;
                    }
                }
            }
        }

        // Render Second Tree (Right of house, only if terminal is wide enough)
        if config.width > 120 {
            let (pine_lines, pine_color) = self.get_pine_tree(config.is_day);
            let pine_height = pine_lines.len() as u16;
            let pine_x = config.house_x + config.house_width + 18; // 18 chars right of house
            let pine_y = config.horizon_y.saturating_sub(pine_height);

            if pine_x + 10 < config.width {
                // Check if full tree fits
                for (i, line) in pine_lines.iter().enumerate() {
                    for (j, ch) in line.chars().enumerate() {
                        if ch != ' ' {
                            renderer.render_char(
                                pine_x + j as u16,
                                pine_y + i as u16,
                                ch,
                                pine_color,
                            )?;
                        }
                    }
                }
            }
        }

        Ok(())
    }

    fn get_tree(&self, is_day: bool) -> (Vec<&'static str>, Color) {
        (
            vec![
                "      ####      ",
                "    ########    ",
                "   ##########   ",
                "    ########    ",
                "      _||_      ",
            ],
            if is_day {
                Color::DarkGreen
            } else {
                Color::Rgb { r: 0, g: 50, b: 0 }
            },
        )
    }

    fn get_fence(&self, is_day: bool) -> (Vec<&'static str>, Color) {
        (
            vec!["|--|--|--|--|", "|  |  |  |  |"],
            if is_day { Color::White } else { Color::Grey },
        )
    }

    fn get_mailbox(&self, is_day: bool) -> (Vec<&'static str>, Color) {
        (
            vec![" ___ ", "|___|", "  |  "],
            if is_day { Color::Blue } else { Color::DarkBlue },
        )
    }

    fn get_pine_tree(&self, is_day: bool) -> (Vec<&'static str>, Color) {
        (
            vec![
                "    *    ",
                "   ***   ",
                "  *****  ",
                " ******* ",
                "   |||   ",
            ],
            if is_day {
                Color::DarkGreen
            } else {
                Color::Rgb { r: 0, g: 50, b: 0 }
            },
        )
    }
}