zero-trust-rps 0.0.4

Online Multiplayer Rock Paper Scissors
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

use ratatui::layout::Rect;
use tokio::sync::mpsc::UnboundedSender;
use tui_input::Input;
use uuid::Uuid;

use crate::common::{
    client::{
        channel::SendError,
        simple_move::SimpleUserMove,
        state::{ClientStateView, RpsState},
    },
    message::{HashWithData, RpsData, UserState},
};

use super::ClientOptions;

/// Application.
#[derive(Debug)]
pub struct App {
    /// Is the application running?
    pub running: bool,

    pub hide_inputs: bool,
    pub input: Input,
    pub user_tried_to_change_state_already: bool,
    pub submit_error: Option<String>,
    pub pop_up: Option<Rect>,

    pub client_state: ClientStateView,
    pub old_plays: Vec<Box<[(Uuid, HashWithData)]>>,

    pub confirm_button: Option<Rect>,

    umove_send: UnboundedSender<SimpleUserMove>,
}

impl App {
    /// Constructs a new instance of [`App`].
    pub fn new(umove_send: UnboundedSender<SimpleUserMove>, opts: &ClientOptions) -> Self {
        Self {
            running: true,
            user_tried_to_change_state_already: false,
            hide_inputs: opts.hide_inputs,
            confirm_button: None,
            submit_error: None,
            pop_up: None,
            input: Default::default(),
            client_state: Default::default(),
            old_plays: vec![],
            umove_send,
        }
    }

    /// Handles the tick event of the terminal.
    pub fn tick(&mut self) {}

    /// Set running to false to quit the application.
    pub fn quit(&mut self) {
        self.running = false;
    }

    pub fn do_move(&self, umove: SimpleUserMove) -> Result<(), SendError> {
        Ok(self.umove_send.send(umove)?)
    }

    pub fn text_input_allowed(&self) -> bool {
        match self.client_state.state {
            RpsState::BeforeRoom => true,
            RpsState::InRoom => true,
            RpsState::Played => false,
            RpsState::Confirmed => false,
        }
    }

    pub fn close_err_pop_up(&mut self) {
        self.pop_up = None;
        self.submit_error = None;
    }

    pub fn input_max_length(&self) -> u16 {
        const MAX_U64_LEN: u16 = u64::MAX.ilog10() as u16 + 1;
        const MAX_DATA_LEN: u16 = RpsData::LEN as u16;

        match self.client_state.state {
            RpsState::BeforeRoom => MAX_U64_LEN,
            RpsState::InRoom => MAX_DATA_LEN,
            RpsState::Played => 0,
            RpsState::Confirmed => 0,
        }
    }

    pub fn is_waiting_for_others(&self) -> bool {
        if let Some(room) = self.client_state.room.as_ref() {
            if let Some(round) = room.round.as_ref() {
                if !round.users.contains(&self.client_state.user) {
                    // user not in round
                    true
                } else {
                    let own_state = self.client_state.state;

                    for user in &round.users {
                        if *user == self.client_state.user {
                            continue;
                        }
                        if let Some(state) = self.client_state.cache.get(user) {
                            let rps_state = match state {
                                UserState::InRoom => RpsState::InRoom,
                                UserState::Played(_) => RpsState::Played,
                                UserState::Confirmed(_) => RpsState::Confirmed,
                            };
                            let is_waiting = match own_state {
                                RpsState::BeforeRoom => false,
                                RpsState::InRoom => rps_state == RpsState::Confirmed,
                                RpsState::Played => rps_state == RpsState::InRoom,
                                RpsState::Confirmed => rps_state == RpsState::Played,
                            };
                            if is_waiting {
                                return true;
                            }
                        }
                    }

                    false
                }
            } else {
                false
            }
        } else {
            false
        }
    }
}