mlbt 0.4.0

A terminal user interface for the MLB stats API. Watch a baseball game in your terminal! ⚾
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

use crate::components::game::live_game::GameState;
use mlbt_api::schedule::AbstractGameState;

#[derive(Default)]
pub struct GamedayState {
    pub panels: GamedayPanels,
    pub game: GameState,
    selected_at_bat: Option<usize>,
}

impl GamedayState {
    pub fn selected_at_bat(&self) -> Option<u8> {
        self.selected_at_bat.map(|i| i as u8)
    }

    pub fn current_game_id(&self) -> u64 {
        self.game.game_id
    }

    pub fn is_final(&self) -> bool {
        matches!(
            self.game.abstract_game_state,
            Some(AbstractGameState::Final)
        )
    }

    pub fn reset(&mut self, game_id: Option<u64>) {
        let new_id = game_id.unwrap_or(0);

        if self.game.game_id != new_id {
            self.selected_at_bat = None;
            self.game.reset();
            self.game.game_id = new_id;
        }
    }

    pub fn next_at_bat(&mut self) {
        let count = self.game.count_events();
        if count == 0 {
            return;
        }
        let i = match self.selected_at_bat {
            Some(i) if i >= count - 1 => 0,
            Some(i) => i + 1,
            None => 0,
        };

        self.selected_at_bat = Some(i);
    }

    pub fn previous_at_bat(&mut self) {
        let count = self.game.count_events();
        if count == 0 {
            return;
        }
        let i = match self.selected_at_bat {
            None => count - 1,
            Some(0) => count - 1,
            Some(i) => i - 1,
        };
        self.selected_at_bat = Some(i);
    }

    /// Go to "live" at bat by deselecting the current at bat.
    pub fn live(&mut self) {
        self.selected_at_bat = None;
    }

    /// Go to the start of the game.
    pub fn start(&mut self) {
        self.selected_at_bat = Some(0);
    }

    pub fn toggle_info(&mut self) {
        self.panels.info = !self.panels.info;
    }

    pub fn toggle_at_bat(&mut self) {
        self.panels.at_bat = !self.panels.at_bat;
    }

    pub fn toggle_boxscore(&mut self) {
        self.panels.boxscore = !self.panels.boxscore;
    }

    pub fn toggle_win_probability(&mut self) {
        self.panels.win_probability = !self.panels.win_probability;
    }
}

/// Store which panels should be rendered in the Gameday tab.
#[derive(Debug, Copy, Clone)]
pub struct GamedayPanels {
    pub info: bool,
    pub at_bat: bool,
    pub boxscore: bool,
    pub win_probability: bool,
}

impl GamedayPanels {
    /// Return the number of panels that are active.
    pub fn count(&self) -> usize {
        self.info as usize + self.at_bat as usize + self.boxscore as usize
    }
}

impl Default for GamedayPanels {
    fn default() -> Self {
        GamedayPanels {
            info: true,
            at_bat: true,
            boxscore: false,
            win_probability: true,
        }
    }
}