1346 lines
46 KiB
Rust
1346 lines
46 KiB
Rust
use anyhow::anyhow;
|
|
use std::time::Instant;
|
|
|
|
use crate::{tournaments::*, types::*, *};
|
|
|
|
pub struct Server {
|
|
pub clients: Clients,
|
|
pub disconnected_clients: Arc<RwLock<Vec<String>>>,
|
|
pub usernames: Usernames,
|
|
pub observers: Observers,
|
|
pub matches: Matches,
|
|
pub reservations: Reservations,
|
|
pub admin: Arc<RwLock<Option<String>>>,
|
|
pub admin_password: Arc<String>,
|
|
pub tournament: WrappedTournament,
|
|
pub waiting_timeout: Arc<RwLock<u64>>,
|
|
pub max_timeout: Arc<RwLock<u64>>,
|
|
pub demo_mode: Arc<RwLock<bool>>,
|
|
}
|
|
|
|
impl Server {
|
|
pub fn new(admin_password: String, demo_mode: bool) -> Server {
|
|
Server {
|
|
clients: Arc::new(RwLock::new(HashMap::new())),
|
|
disconnected_clients: Arc::new(RwLock::new(Vec::new())),
|
|
usernames: Arc::new(RwLock::new(HashMap::new())),
|
|
observers: Arc::new(RwLock::new(HashMap::new())),
|
|
matches: Arc::new(RwLock::new(HashMap::new())),
|
|
reservations: Arc::new(RwLock::new(Vec::new())),
|
|
admin: Arc::new(RwLock::new(None)),
|
|
admin_password: Arc::new(admin_password),
|
|
tournament: Arc::new(RwLock::new(None)),
|
|
waiting_timeout: Arc::new(RwLock::new(5000)),
|
|
max_timeout: Arc::new(RwLock::new(30000)),
|
|
demo_mode: Arc::new(RwLock::new(demo_mode)),
|
|
}
|
|
}
|
|
|
|
pub async fn handle_connect_cmd(
|
|
&self,
|
|
addr: SocketAddr,
|
|
tx: UnboundedSender<Message>,
|
|
requested_username: String,
|
|
) -> Result<(), anyhow::Error> {
|
|
if requested_username.is_empty() {
|
|
return Err(anyhow::anyhow!(format!(
|
|
"ERROR:INVALID:ID:{}",
|
|
requested_username
|
|
)));
|
|
}
|
|
|
|
if requested_username == SERVER_PLAYER_USERNAME {
|
|
return Err(anyhow::anyhow!(format!(
|
|
"ERROR:INVALID:ID:{}",
|
|
requested_username
|
|
)));
|
|
}
|
|
|
|
let mut reconnecting = false;
|
|
let disconnected_guard = self.disconnected_clients.read().await;
|
|
if disconnected_guard.contains(&requested_username) {
|
|
reconnecting = true;
|
|
}
|
|
|
|
let clients_guard = self.clients.read().await;
|
|
let reconnecting_client = clients_guard.get(&requested_username).cloned();
|
|
if reconnecting_client.is_some() && !reconnecting {
|
|
return Err(anyhow::anyhow!(format!(
|
|
"ERROR:INVALID:ID:{}",
|
|
requested_username
|
|
)));
|
|
}
|
|
|
|
drop(clients_guard);
|
|
|
|
self.remove_observer_from_all_matches(addr).await;
|
|
self.observers.write().await.remove(&addr);
|
|
self.usernames.write().await.insert(requested_username.clone(), addr);
|
|
let _ = send(&tx, "CONNECT:ACK");
|
|
|
|
if !reconnecting {
|
|
self.clients.write().await.insert(
|
|
requested_username.clone(),
|
|
Arc::new(RwLock::new(Client::new(
|
|
requested_username,
|
|
tx.clone(),
|
|
addr,
|
|
))),
|
|
);
|
|
|
|
return Ok(());
|
|
}
|
|
|
|
// reconnecting
|
|
self.disconnected_clients.write().await.retain(|name| name != &requested_username);
|
|
let client_guard = reconnecting_client.unwrap();
|
|
let mut client = client_guard.write().await;
|
|
client.addr = addr;
|
|
client.connection = tx.clone();
|
|
// I don't think this will fail
|
|
let match_id = client.current_match.unwrap();
|
|
let client_color = client.color;
|
|
|
|
drop(client);
|
|
|
|
let matches_guard = self.matches.read().await;
|
|
let mut the_match = matches_guard.get(&match_id).unwrap().write().await;
|
|
if the_match.demo_mode {
|
|
drop(the_match);
|
|
drop(matches_guard);
|
|
self.terminate_match(match_id).await;
|
|
return Ok(());
|
|
} else {
|
|
the_match.ledger.clear();
|
|
the_match.board = vec![vec![Color::None; 6]; 7];
|
|
let opponent_username = if the_match.player1 == requested_username {
|
|
the_match.player2.clone()
|
|
} else {
|
|
the_match.player1.clone()
|
|
};
|
|
|
|
if the_match.wait_thread.is_some() {
|
|
the_match.wait_thread.as_ref().unwrap().abort();
|
|
}
|
|
|
|
if the_match.timeout_thread.is_some() {
|
|
the_match.timeout_thread.as_ref().unwrap().abort();
|
|
}
|
|
|
|
let clients_guard = self.clients.read().await;
|
|
let opponent = clients_guard.get(&opponent_username).unwrap().read().await;
|
|
let _ = send(&opponent.connection, "GAME:TERMINATED");
|
|
let _ = send(
|
|
&tx,
|
|
&format!("GAME:START:{}", bool::from(client_color) as u8),
|
|
);
|
|
let _ = send(
|
|
&opponent.connection,
|
|
&format!("GAME:START:{}", bool::from(opponent.color) as u8),
|
|
);
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub async fn handle_reconnect_cmd(
|
|
&self,
|
|
addr: SocketAddr,
|
|
tx: UnboundedSender<Message>,
|
|
requested_username: String,
|
|
) -> Result<(), anyhow::Error> {
|
|
let clients_guard = self.clients.read().await;
|
|
let disconnected_guard = self.disconnected_clients.read().await;
|
|
let found_client = if disconnected_guard.contains(&requested_username) {
|
|
clients_guard.get(&requested_username).cloned()
|
|
} else {
|
|
None
|
|
};
|
|
|
|
drop(clients_guard);
|
|
drop(disconnected_guard);
|
|
|
|
if let Some(client_guard) = found_client {
|
|
self.disconnected_clients.write().await.retain(|name| name != &requested_username);
|
|
let mut client = client_guard.write().await;
|
|
client.addr = addr;
|
|
client.connection = tx.clone();
|
|
|
|
let _ = send(&tx, "RECONNECT:ACK");
|
|
|
|
let matches_guard = self.matches.read().await;
|
|
let the_match = matches_guard.get(&client.current_match.unwrap()).unwrap().read().await;
|
|
|
|
let last = the_match.ledger.last();
|
|
if last.is_some() && last.unwrap().0 != client.color {
|
|
let _ = send(
|
|
&tx,
|
|
&format!("OPPONENT:{}", the_match.ledger.last().unwrap().1),
|
|
);
|
|
}
|
|
} else {
|
|
return Err(anyhow::anyhow!(format!(
|
|
"ERROR:INVALID:RECONNECT:{}",
|
|
requested_username
|
|
)));
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub async fn handle_disconnect_cmd(
|
|
&self,
|
|
addr: SocketAddr,
|
|
tx: UnboundedSender<Message>,
|
|
) -> Result<(), anyhow::Error> {
|
|
let Some(username) = self
|
|
.usernames
|
|
.read()
|
|
.await
|
|
.iter()
|
|
.find_map(|(username, client_addr)| if *client_addr == addr { Some(username.clone()) } else { None })
|
|
else {
|
|
return Err(anyhow::anyhow!("ERROR:INVALID:DISCONNECT"));
|
|
};
|
|
let clients_guard = self.clients.read().await;
|
|
let client_opt = clients_guard.get(&username).cloned();
|
|
|
|
if client_opt.is_none() {
|
|
return Err(anyhow::anyhow!("ERROR:INVALID:DISCONNECT"));
|
|
}
|
|
|
|
drop(clients_guard);
|
|
|
|
let mut client = client_opt.as_ref().unwrap().write().await;
|
|
self.usernames.write().await.remove(&client.username);
|
|
client.ready = false;
|
|
client.color = Color::None;
|
|
|
|
if client.current_match.is_some() {
|
|
let match_id = client.current_match.unwrap();
|
|
drop(client);
|
|
|
|
self.terminate_match(match_id).await;
|
|
}
|
|
|
|
self.clients.write().await.remove(&username);
|
|
self.observers.write().await.insert(addr, tx.clone());
|
|
let _ = send(&tx, "DISCONNECT:ACK");
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub async fn handle_ready(
|
|
&self,
|
|
addr: SocketAddr,
|
|
tx: UnboundedSender<Message>,
|
|
) -> Result<(), anyhow::Error> {
|
|
let Some(username) = self
|
|
.usernames
|
|
.read()
|
|
.await
|
|
.iter()
|
|
.find_map(|(username, client_addr)| if *client_addr == addr { Some(username.clone()) } else { None })
|
|
else {
|
|
return Err(anyhow::anyhow!("ERROR:INVALID"));
|
|
};
|
|
let clients_guard = self.clients.read().await;
|
|
if clients_guard.get(&username).is_none() {
|
|
return Err(anyhow::anyhow!("ERROR:INVALID"));
|
|
}
|
|
|
|
if clients_guard.get(&username).unwrap().read().await.ready {
|
|
return Err(anyhow::anyhow!("ERROR:INVALID:READY"));
|
|
}
|
|
|
|
let mut client = clients_guard.get(&username).unwrap().write().await;
|
|
let client_username = client.username.clone();
|
|
client.ready = true;
|
|
let _ = send(&tx, "READY:ACK");
|
|
drop(client);
|
|
drop(clients_guard);
|
|
|
|
if let Some(opponent_username) = self.find_reservation_opponent(client_username).await {
|
|
let clients_guard = self.clients.read().await;
|
|
let mut client = clients_guard.get(&username).unwrap().write().await;
|
|
let mut opponent = clients_guard.get(&opponent_username).unwrap().write().await;
|
|
|
|
let match_id: u32 = gen_match_id(&self.matches).await;
|
|
let new_match = Arc::new(RwLock::new(Match::new(
|
|
match_id,
|
|
username.clone(),
|
|
opponent_username,
|
|
false,
|
|
)));
|
|
self.matches.write().await.insert(match_id, new_match.clone());
|
|
|
|
client.ready = false;
|
|
client.current_match = Some(match_id);
|
|
client.color = if new_match.read().await.player1 == username {
|
|
let _ = send(&tx, "GAME:START:1");
|
|
let _ = send(&opponent.connection, "GAME:START:0");
|
|
Color::Red
|
|
} else {
|
|
let _ = send(&tx, "GAME:START:0");
|
|
let _ = send(&opponent.connection, "GAME:START:1");
|
|
Color::Yellow
|
|
};
|
|
|
|
opponent.ready = false;
|
|
opponent.current_match = Some(match_id);
|
|
opponent.color = !client.color;
|
|
|
|
self.reservations
|
|
.write()
|
|
.await
|
|
.retain(|(p1, p2)| !(p1 == &client.username && p2 == &opponent.username));
|
|
|
|
return Ok(());
|
|
}
|
|
|
|
let clients_guard = self.clients.read().await;
|
|
let mut client = clients_guard.get(&username).unwrap().write().await;
|
|
let is_demo_mode = self.demo_mode.read().await.clone();
|
|
if is_demo_mode {
|
|
let match_id: u32 = gen_match_id(&self.matches).await;
|
|
let new_match = Arc::new(RwLock::new(Match::new(
|
|
match_id,
|
|
username.clone(),
|
|
SERVER_PLAYER_USERNAME.to_string(),
|
|
is_demo_mode,
|
|
)));
|
|
self.matches.write().await.insert(match_id, new_match.clone());
|
|
client.ready = false;
|
|
client.current_match = Some(match_id);
|
|
client.color = if new_match.read().await.player1 == username {
|
|
let _ = send(&tx, "GAME:START:1");
|
|
Color::Red
|
|
} else {
|
|
let _ = send(&tx, "GAME:START:0");
|
|
Color::Yellow
|
|
};
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub async fn handle_play(
|
|
&self,
|
|
addr: SocketAddr,
|
|
tx: UnboundedSender<Message>,
|
|
column: usize,
|
|
) -> Result<(), anyhow::Error> {
|
|
let Some(client_username) = self
|
|
.usernames
|
|
.read()
|
|
.await
|
|
.iter()
|
|
.find_map(|(username, client_addr)| if *client_addr == addr { Some(username.clone()) } else { None })
|
|
else {
|
|
return Err(anyhow::anyhow!("ERROR:INVALID:MOVE"));
|
|
};
|
|
let clients_guard = self.clients.read().await;
|
|
let client_opt = clients_guard.get(&client_username);
|
|
|
|
// Check if client is valid
|
|
if client_opt.is_none() || client_opt.unwrap().read().await.current_match.is_none() {
|
|
return Err(anyhow::anyhow!("ERROR:INVALID:MOVE"));
|
|
}
|
|
let client = client_opt.unwrap().read().await;
|
|
|
|
let matches_guard = self.matches.read().await;
|
|
let current_match = matches_guard.get(&client.current_match.unwrap()).unwrap().read().await;
|
|
|
|
let opponent = {
|
|
let mut result = None;
|
|
|
|
if !current_match.demo_mode {
|
|
let opponent_username = if client_username == current_match.player1 {
|
|
current_match.player2.clone()
|
|
} else {
|
|
current_match.player1.clone()
|
|
};
|
|
|
|
result = Some(clients_guard.get(&opponent_username).cloned().unwrap());
|
|
}
|
|
|
|
result
|
|
};
|
|
|
|
// Check if it's their move
|
|
let mut invalid = false;
|
|
if (current_match.ledger.is_empty() && current_match.player1 != client_username)
|
|
|| (current_match.ledger.last().is_some()
|
|
&& current_match.ledger.last().unwrap().0 == client.color)
|
|
{
|
|
let _ = send(&tx, "ERROR:INVALID:MOVE");
|
|
invalid = true;
|
|
}
|
|
|
|
drop(current_match);
|
|
drop(matches_guard);
|
|
|
|
let mut matches_guard = self.matches.write().await;
|
|
let mut current_match =
|
|
matches_guard.get_mut(&client.current_match.unwrap()).unwrap().write().await;
|
|
|
|
// Check if valid move
|
|
if column >= 7 && !invalid {
|
|
let _ = send(&tx, "ERROR:INVALID:MOVE");
|
|
invalid = true;
|
|
}
|
|
|
|
if current_match.board[column][5] != Color::None && !invalid {
|
|
let _ = send(&tx, "ERROR:INVALID:MOVE");
|
|
invalid = true;
|
|
}
|
|
|
|
// Terminate games if a player makes an invalid move
|
|
if invalid {
|
|
let current_match_id = current_match.id;
|
|
let is_demo_mode = current_match.demo_mode;
|
|
let viewers = current_match.viewers.clone();
|
|
|
|
drop(current_match);
|
|
drop(matches_guard);
|
|
drop(client);
|
|
drop(clients_guard);
|
|
|
|
if is_demo_mode {
|
|
self.terminate_match(current_match_id).await;
|
|
tx.send(Message::Close(None))?;
|
|
} else {
|
|
let opponent = opponent.unwrap();
|
|
let mut opponent = opponent.write().await;
|
|
|
|
let _ = send(&tx, "GAME:LOSS");
|
|
let _ = send(&opponent.connection, "GAME:WINS");
|
|
self.broadcast_message(&viewers, &format!("GAME:WIN:{}", opponent.username)).await;
|
|
|
|
opponent.current_match = None;
|
|
opponent.color = Color::None;
|
|
let opponent_username = opponent.username.clone();
|
|
drop(opponent);
|
|
|
|
let mut clients_guard = self.clients.write().await;
|
|
let mut client = clients_guard.get_mut(&client_username).unwrap().write().await;
|
|
client.current_match = None;
|
|
client.color = Color::None;
|
|
drop(client);
|
|
|
|
let mut tournament_guard = self.tournament.write().await;
|
|
let tourney = tournament_guard.as_mut().unwrap();
|
|
tourney.write().await.inform_winner(opponent_username, false);
|
|
drop(tournament_guard);
|
|
|
|
self.matches.write().await.remove(¤t_match_id).unwrap();
|
|
}
|
|
return Ok(());
|
|
}
|
|
|
|
current_match.place_token(client.color.clone(), column);
|
|
|
|
if let Some(timeout_thread) = ¤t_match.timeout_thread {
|
|
timeout_thread.abort();
|
|
}
|
|
|
|
let mut viewer_messages = Vec::new();
|
|
let viewers = current_match.viewers.clone();
|
|
|
|
viewer_messages.push(format!("GAME:MOVE:{}:{}", client.username, column));
|
|
|
|
// Check game end conditions
|
|
let (winner, filled) = current_match.end_game_check();
|
|
|
|
// Send match results
|
|
if winner == client.color {
|
|
let _ = send(&tx, "GAME:WINS");
|
|
if !current_match.demo_mode {
|
|
let opponent = opponent.clone().unwrap();
|
|
let opponent = opponent.read().await;
|
|
let _ = send(&opponent.connection, "GAME:LOSS");
|
|
}
|
|
viewer_messages.push(format!("GAME:WIN:{}", client.username));
|
|
} else if filled {
|
|
let _ = send(&tx, "GAME:DRAW");
|
|
if !current_match.demo_mode {
|
|
let opponent = opponent.clone().unwrap();
|
|
let opponent = opponent.read().await;
|
|
let _ = send(&opponent.connection, "GAME:DRAW");
|
|
}
|
|
viewer_messages.push("GAME:DRAW".to_string());
|
|
}
|
|
|
|
// remove match from matchmaker
|
|
if winner != Color::None || filled {
|
|
let current_match_id = current_match.id;
|
|
let is_demo_mode = current_match.demo_mode;
|
|
|
|
drop(client);
|
|
drop(current_match);
|
|
drop(clients_guard);
|
|
|
|
let clients_guard = self.clients.read().await;
|
|
let mut client = clients_guard.get(&client_username).unwrap().write().await;
|
|
client.current_match = None;
|
|
client.color = Color::None;
|
|
drop(client);
|
|
|
|
if !is_demo_mode {
|
|
let opponent = opponent.clone().unwrap();
|
|
let mut opponent = opponent.write().await;
|
|
opponent.current_match = None;
|
|
opponent.color = Color::None;
|
|
drop(opponent);
|
|
}
|
|
|
|
matches_guard.remove(¤t_match_id).unwrap();
|
|
|
|
if self.tournament.read().await.is_some() && matches_guard.is_empty() {
|
|
drop(matches_guard);
|
|
drop(clients_guard);
|
|
|
|
let mut tournament_guard = self.tournament.write().await;
|
|
let tourney = tournament_guard.as_mut().unwrap();
|
|
tourney.write().await.inform_winner(client_username.clone(), filled);
|
|
tourney.write().await.next(&self).await;
|
|
if tourney.read().await.is_completed() {
|
|
*tournament_guard = None;
|
|
}
|
|
} else if self.tournament.read().await.is_none() {
|
|
let _ = send(&tx, "TOURNAMENT:END");
|
|
if !is_demo_mode {
|
|
let opponent = opponent.clone().unwrap();
|
|
let opponent = opponent.read().await;
|
|
let _ = send(&opponent.connection, "TOURNAMENT:END");
|
|
}
|
|
}
|
|
|
|
return Ok(());
|
|
}
|
|
|
|
let default_waiting_time = *self.waiting_timeout.read().await;
|
|
let mut adjusted_waiting =
|
|
default_waiting_time as i64 + (rand::rng().random_range(0..=50) - 25);
|
|
let current_move_time = Instant::now();
|
|
|
|
if current_match.ledger.is_empty() {
|
|
adjusted_waiting = 0;
|
|
} else {
|
|
let last_move_time = current_match.ledger.last().unwrap().2;
|
|
let elapsed = current_move_time.duration_since(last_move_time).as_millis() as i64;
|
|
adjusted_waiting -= elapsed;
|
|
if adjusted_waiting < 0 {
|
|
adjusted_waiting = 0;
|
|
}
|
|
}
|
|
|
|
current_match.ledger.push((client.color.clone(), column, current_move_time));
|
|
|
|
let demo_mode = current_match.demo_mode;
|
|
let demo_move = random_move(¤t_match.board);
|
|
let no_winner = winner == Color::None && !filled;
|
|
let observers = self.observers.clone();
|
|
let clients_for_viewers = self.clients.clone();
|
|
let opponent_move = opponent.clone();
|
|
let client_tx = tx.clone();
|
|
if current_match.demo_mode {
|
|
current_match.ledger.push((!client.color, demo_move, Instant::now()));
|
|
current_match.place_token(!client.color, demo_move);
|
|
}
|
|
|
|
current_match.wait_thread = Some(tokio::spawn(async move {
|
|
tokio::time::sleep(tokio::time::Duration::from_millis(adjusted_waiting as u64)).await;
|
|
|
|
if !demo_mode && no_winner {
|
|
let opponent = opponent_move.unwrap();
|
|
let opponent = opponent.read().await;
|
|
let _ = send(
|
|
&opponent.connection.clone(),
|
|
&format!("OPPONENT:{}", column),
|
|
);
|
|
}
|
|
|
|
for msg in viewer_messages {
|
|
broadcast_message(&clients_for_viewers, &observers, &viewers, &msg).await;
|
|
}
|
|
|
|
if demo_mode && no_winner {
|
|
tokio::time::sleep(tokio::time::Duration::from_millis(default_waiting_time)).await;
|
|
let _ = send(&client_tx, &format!("OPPONENT:{}", demo_move));
|
|
broadcast_message(
|
|
&clients_for_viewers,
|
|
&observers,
|
|
&viewers,
|
|
&format!("GAME:MOVE:{}:{}", SERVER_PLAYER_USERNAME, demo_move),
|
|
)
|
|
.await;
|
|
}
|
|
}));
|
|
|
|
let max_timeout = *self.max_timeout.read().await;
|
|
let matches = self.matches.clone();
|
|
let tournament = self.tournament.clone();
|
|
let clients = self.clients.clone();
|
|
let match_id = current_match.id;
|
|
let ledger_size = current_match.ledger.len();
|
|
let client_username = client.username.clone();
|
|
let client_tx = tx.clone();
|
|
let client_username_timeout = client_username.clone();
|
|
let observers = self.observers.clone();
|
|
let viewers = current_match.viewers.clone();
|
|
let opponent_move = opponent.clone();
|
|
current_match.timeout_thread = Some(tokio::spawn(async move {
|
|
if demo_mode {
|
|
return;
|
|
}
|
|
tokio::time::sleep(tokio::time::Duration::from_millis(adjusted_waiting as u64)).await;
|
|
tokio::time::sleep(tokio::time::Duration::from_millis(max_timeout as u64)).await;
|
|
|
|
let matches_guard = matches.read().await;
|
|
let the_match = matches_guard.get(&match_id);
|
|
if let Some(the_match) = the_match {
|
|
let the_match = the_match.read().await;
|
|
if the_match.ledger.len() == ledger_size {
|
|
// forfeit the match
|
|
let _ = send(&client_tx, "GAME:WINS");
|
|
let opponent = opponent_move.clone().unwrap();
|
|
let opponent = opponent.read().await;
|
|
let _ = send(&opponent.connection, "GAME:LOSS");
|
|
drop(opponent);
|
|
broadcast_message(
|
|
&clients,
|
|
&observers,
|
|
&viewers,
|
|
&format!("GAME:WIN:{}", client_username),
|
|
)
|
|
.await;
|
|
|
|
let mut clients_guard = clients.write().await;
|
|
let mut client = clients_guard.get_mut(&client_username_timeout).unwrap().write().await;
|
|
client.current_match = None;
|
|
client.color = Color::None;
|
|
drop(client);
|
|
|
|
let opponent = opponent_move.unwrap();
|
|
let mut opponent = opponent.write().await;
|
|
opponent.current_match = None;
|
|
opponent.color = Color::None;
|
|
drop(opponent);
|
|
|
|
let mut tournament_guard = tournament.write().await;
|
|
let tourney = tournament_guard.as_mut().unwrap();
|
|
tourney.write().await.inform_winner(client_username_timeout.clone(), false);
|
|
drop(tournament_guard);
|
|
|
|
matches.write().await.remove(&match_id).unwrap();
|
|
}
|
|
}
|
|
}));
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub async fn handle_player_list(
|
|
&self,
|
|
tx: UnboundedSender<Message>,
|
|
) -> Result<(), anyhow::Error> {
|
|
let clients_guard = self.clients.read().await;
|
|
let mut to_send = "PLAYER:LIST:".to_string();
|
|
for client_guard in clients_guard.values() {
|
|
let player = client_guard.read().await;
|
|
to_send += player.username.as_str();
|
|
to_send += ",";
|
|
to_send += if player.ready { "true" } else { "false" };
|
|
to_send += ",";
|
|
to_send += if player.current_match.is_some() {
|
|
"true"
|
|
} else {
|
|
"false"
|
|
};
|
|
to_send += "|";
|
|
}
|
|
|
|
if !to_send.ends_with(":") {
|
|
to_send.remove(to_send.len() - 1);
|
|
}
|
|
|
|
let _ = send(&tx, to_send.as_str());
|
|
Ok(())
|
|
}
|
|
|
|
pub async fn handle_game_list(
|
|
&self,
|
|
tx: UnboundedSender<Message>,
|
|
) -> Result<(), anyhow::Error> {
|
|
let matches_guard = self.matches.read().await;
|
|
let clients_guard = self.clients.read().await;
|
|
let mut to_send = "GAME:LIST:".to_string();
|
|
for match_guard in matches_guard.values() {
|
|
let a_match = match_guard.read().await;
|
|
let player1 = if a_match.player1 == SERVER_PLAYER_USERNAME {
|
|
SERVER_PLAYER_USERNAME.to_string()
|
|
} else {
|
|
clients_guard.get(&a_match.player1).unwrap().read().await.username.clone()
|
|
};
|
|
let player2 = if a_match.player2 == SERVER_PLAYER_USERNAME {
|
|
SERVER_PLAYER_USERNAME.to_string()
|
|
} else {
|
|
clients_guard.get(&a_match.player2).unwrap().read().await.username.clone()
|
|
};
|
|
to_send += a_match.id.to_string().as_str();
|
|
to_send += ",";
|
|
to_send += player1.as_str();
|
|
to_send += ",";
|
|
to_send += player2.as_str();
|
|
to_send += "|";
|
|
}
|
|
|
|
if !to_send.ends_with(":") {
|
|
to_send.remove(to_send.len() - 1);
|
|
}
|
|
|
|
let _ = send(&tx, to_send.as_str());
|
|
Ok(())
|
|
}
|
|
|
|
pub async fn handle_game_watch(
|
|
&self,
|
|
tx: UnboundedSender<Message>,
|
|
match_id: u32,
|
|
addr: SocketAddr,
|
|
) -> Result<(), anyhow::Error> {
|
|
let result = self.watch(match_id, addr).await;
|
|
if result.is_err() {
|
|
return Err(anyhow::anyhow!("ERROR:INVALID:WATCH"));
|
|
}
|
|
|
|
let clients_guard = self.clients.read().await;
|
|
let matches_guard = self.matches.read().await;
|
|
let the_match = matches_guard.get(&match_id).unwrap().read().await;
|
|
|
|
let player1 = if the_match.player1 != SERVER_PLAYER_USERNAME {
|
|
clients_guard.get(&the_match.player1).unwrap().read().await.username.clone()
|
|
} else {
|
|
SERVER_PLAYER_USERNAME.to_string()
|
|
};
|
|
|
|
let player2 = if the_match.player2 != SERVER_PLAYER_USERNAME {
|
|
clients_guard.get(&the_match.player2).unwrap().read().await.username.clone()
|
|
} else {
|
|
SERVER_PLAYER_USERNAME.to_string()
|
|
};
|
|
|
|
let ledger = the_match.ledger.clone();
|
|
|
|
drop(clients_guard);
|
|
drop(the_match);
|
|
drop(matches_guard);
|
|
|
|
let mut message = format!("GAME:WATCH:ACK:{},{},{}|", match_id, player1, player2);
|
|
|
|
for a_move in ledger {
|
|
if a_move.0 == Color::Red {
|
|
message += &format!("{},{}|", player1, a_move.1);
|
|
} else {
|
|
message += &format!("{},{}|", player2, a_move.1);
|
|
}
|
|
}
|
|
|
|
message.pop();
|
|
|
|
let _ = send(&tx, &message);
|
|
Ok(())
|
|
}
|
|
|
|
pub async fn handle_admin_auth(
|
|
&self,
|
|
tx: UnboundedSender<Message>,
|
|
addr: SocketAddr,
|
|
password: String,
|
|
) -> Result<(), anyhow::Error> {
|
|
if self.admin.read().await.is_some() {
|
|
return Err(anyhow::anyhow!("ERROR:INVALID:AUTH"));
|
|
}
|
|
|
|
if password != *self.admin_password {
|
|
return Err(anyhow::anyhow!("ERROR:INVALID:AUTH"));
|
|
}
|
|
|
|
let Some(admin_username) = self
|
|
.usernames
|
|
.read()
|
|
.await
|
|
.iter()
|
|
.find_map(|(username, client_addr)| if *client_addr == addr { Some(username.clone()) } else { None })
|
|
else {
|
|
return Err(anyhow::anyhow!("ERROR:INVALID:AUTH"));
|
|
};
|
|
let mut admin_guard = self.admin.write().await;
|
|
*admin_guard = Some(admin_username);
|
|
let _ = send(&tx, "ADMIN:AUTH:ACK");
|
|
Ok(())
|
|
}
|
|
|
|
pub async fn handle_admin_kick(
|
|
&self,
|
|
addr: SocketAddr,
|
|
kick_username: String,
|
|
) -> Result<(), anyhow::Error> {
|
|
if !self.auth_check(addr).await {
|
|
return Err(anyhow::anyhow!("ERROR:INVALID:AUTH"));
|
|
}
|
|
|
|
let clients_guard = self.clients.read().await;
|
|
|
|
match clients_guard.get(&kick_username) {
|
|
Some(kick_client) => {
|
|
let kick_client = kick_client.read().await;
|
|
kick_client.connection.send(Message::Close(None))?;
|
|
}
|
|
None => return Err(anyhow::anyhow!("ERROR:INVALID:KICK")),
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
pub async fn handle_game_terminate(
|
|
&self,
|
|
addr: SocketAddr,
|
|
match_id: u32,
|
|
) -> Result<(), anyhow::Error> {
|
|
if !self.auth_check(addr).await {
|
|
return Err(anyhow::anyhow!("ERROR:INVALID:AUTH"));
|
|
}
|
|
|
|
self.terminate_match(match_id).await;
|
|
|
|
if self.tournament.read().await.is_some() && self.matches.read().await.is_empty() {
|
|
let mut tournament_guard = self.tournament.write().await;
|
|
let tourney = tournament_guard.as_mut().unwrap();
|
|
tourney.write().await.next(&self).await;
|
|
if tourney.read().await.is_completed() {
|
|
*tournament_guard = None;
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
pub async fn handle_game_award_winner(
|
|
&self,
|
|
addr: SocketAddr,
|
|
match_id: u32,
|
|
winner_username: String,
|
|
) -> Result<(), anyhow::Error> {
|
|
if !self.auth_check(addr).await {
|
|
return Err(anyhow!("ERROR:INVALID:AUTH"));
|
|
}
|
|
|
|
let matches_guard = self.matches.read().await;
|
|
let found_match =
|
|
matches_guard.get(&match_id).ok_or_else(|| anyhow!("ERROR:INVALID:AWARD"))?.clone();
|
|
drop(matches_guard);
|
|
|
|
let the_match = found_match.read().await;
|
|
|
|
// Validate that the declared winner is actually one of the players in this match
|
|
let clients_guard = self.clients.read().await;
|
|
let player1_client = clients_guard.get(&the_match.player1);
|
|
let player2_client = clients_guard.get(&the_match.player2);
|
|
|
|
// If we cannot resolve both players, or the winner username doesn't match either, reject
|
|
if let (Some(p1_arc), Some(p2_arc)) = (player1_client, player2_client) {
|
|
let p1 = p1_arc.read().await;
|
|
let p2 = p2_arc.read().await;
|
|
|
|
if winner_username != p1.username && winner_username != p2.username {
|
|
return Err(anyhow!("ERROR:INVALID:AWARD"));
|
|
}
|
|
} else {
|
|
return Err(anyhow!("ERROR:INVALID:AWARD"));
|
|
}
|
|
drop(clients_guard);
|
|
|
|
self.matches.write().await.remove(&match_id);
|
|
|
|
if let Some(wait_thread) = &the_match.wait_thread {
|
|
wait_thread.abort();
|
|
}
|
|
|
|
if let Some(timeout_thread) = &the_match.timeout_thread {
|
|
timeout_thread.abort();
|
|
}
|
|
|
|
self.broadcast_message(&the_match.viewers, &format!("GAME:WIN:{}", winner_username)).await;
|
|
|
|
let clients_guard = self.clients.read().await;
|
|
if the_match.demo_mode {
|
|
let player_win = if winner_username != SERVER_PLAYER_USERNAME {
|
|
"WINS"
|
|
} else {
|
|
"LOSS"
|
|
};
|
|
let mut the_player = if the_match.player1 != SERVER_PLAYER_USERNAME {
|
|
clients_guard.get(&the_match.player1).unwrap().write().await
|
|
} else {
|
|
clients_guard.get(&the_match.player2).unwrap().write().await
|
|
};
|
|
|
|
let _ = send(&the_player.connection, &format!("GAME:{}", player_win));
|
|
let _ = send(&the_player.connection, "TOURNAMENT:END");
|
|
|
|
the_player.color = Color::None;
|
|
the_player.current_match = None;
|
|
|
|
return Ok(());
|
|
}
|
|
|
|
let mut player1 = clients_guard.get(&the_match.player1).unwrap().write().await;
|
|
let mut player2 = clients_guard.get(&the_match.player2).unwrap().write().await;
|
|
|
|
player1.current_match = None;
|
|
player1.color = Color::None;
|
|
|
|
player2.current_match = None;
|
|
player2.color = Color::None;
|
|
|
|
let winner_tx = if player1.username == winner_username {
|
|
player1.connection.clone()
|
|
} else {
|
|
player2.connection.clone()
|
|
};
|
|
|
|
let loser_tx = if player1.username != winner_username {
|
|
player1.connection.clone()
|
|
} else {
|
|
player2.connection.clone()
|
|
};
|
|
|
|
drop(player1);
|
|
drop(player2);
|
|
drop(clients_guard);
|
|
|
|
let _ = send(&winner_tx, "GAME:WINS");
|
|
let _ = send(&loser_tx, "GAME:LOSS");
|
|
|
|
if self.tournament.read().await.is_some() {
|
|
let mut tournament_guard = self.tournament.write().await;
|
|
let tourney = tournament_guard.as_mut().unwrap();
|
|
tourney.write().await.inform_winner(winner_username, false);
|
|
if self.matches.read().await.is_empty() {
|
|
tourney.write().await.next(&self).await;
|
|
if tourney.read().await.is_completed() {
|
|
*tournament_guard = None;
|
|
}
|
|
}
|
|
} else {
|
|
let _ = send(&winner_tx, "TOURNAMENT:END");
|
|
let _ = send(&loser_tx, "TOURNAMENT:END");
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub async fn handle_tournament_start(
|
|
&self,
|
|
addr: SocketAddr,
|
|
tournament_type: String,
|
|
) -> Result<(), anyhow::Error> {
|
|
if !self.auth_check(addr).await {
|
|
return Err(anyhow::anyhow!("ERROR:INVALID:AUTH"));
|
|
}
|
|
|
|
if self.tournament.read().await.is_some() {
|
|
return Err(anyhow::anyhow!("ERROR:INVALID:TOURNAMENT"));
|
|
}
|
|
|
|
let mut clients_guard = self.clients.write().await;
|
|
let mut ready_players = Vec::new();
|
|
for (client_username, client_guard) in clients_guard.iter_mut() {
|
|
if client_guard.read().await.ready {
|
|
ready_players.push(client_username.clone());
|
|
}
|
|
}
|
|
|
|
if ready_players.len() < 3 {
|
|
return Err(anyhow::anyhow!("ERROR:INVALID:TOURNAMENT"));
|
|
}
|
|
|
|
drop(clients_guard);
|
|
|
|
let mut tourney = match tournament_type.as_str() {
|
|
"RoundRobin" => RoundRobin::new(&ready_players),
|
|
&_ => RoundRobin::new(&ready_players),
|
|
};
|
|
tourney.start(&self).await;
|
|
|
|
let mut tournament_guard = self.tournament.write().await;
|
|
*tournament_guard = Some(Arc::new(RwLock::new(tourney)));
|
|
|
|
// Clear any pending reservations when a tournament starts
|
|
self.reservations.write().await.clear();
|
|
|
|
self.broadcast_message_all_observers(&format!("TOURNAMENT:START:{}", tournament_type))
|
|
.await;
|
|
Ok(())
|
|
}
|
|
|
|
pub async fn handle_tournament_cancel(&self, addr: SocketAddr) -> Result<(), anyhow::Error> {
|
|
if !self.auth_check(addr).await {
|
|
return Err(anyhow::anyhow!("ERROR:INVALID:AUTH"));
|
|
}
|
|
|
|
if self.tournament.read().await.is_none() {
|
|
return Err(anyhow::anyhow!("ERROR:INVALID:TOURNAMENT"));
|
|
}
|
|
|
|
let mut tournament_guard = self.tournament.write().await;
|
|
let tourney = tournament_guard.as_mut().unwrap();
|
|
tourney.write().await.cancel(&self).await;
|
|
*tournament_guard = None;
|
|
|
|
self.broadcast_message_all_observers("TOURNAMENT:CANCEL").await;
|
|
Ok(())
|
|
}
|
|
|
|
pub async fn handle_get_data(
|
|
&self,
|
|
tx: UnboundedSender<Message>,
|
|
data_id: String,
|
|
) -> Result<(), anyhow::Error> {
|
|
let mut msg = format!("GET:{}:", data_id);
|
|
match data_id.as_str() {
|
|
"TOURNAMENT_STATUS" => {
|
|
let tournament = self.tournament.read().await.clone();
|
|
if tournament.is_some() {
|
|
msg += tournament.as_ref().unwrap().read().await.get_type().as_str();
|
|
} else {
|
|
msg += "false";
|
|
}
|
|
}
|
|
"MOVE_WAIT" => {
|
|
let wait_time = *self.waiting_timeout.read().await as f64 / 1000f64;
|
|
msg += wait_time.to_string().as_str();
|
|
}
|
|
"DEMO_MODE" => {
|
|
let demo_mode = *self.demo_mode.read().await;
|
|
msg += demo_mode.to_string().as_str();
|
|
}
|
|
"MAX_TIMEOUT" => {
|
|
let max_time = *self.max_timeout.read().await as f64 / 1000f64;
|
|
msg += max_time.to_string().as_str();
|
|
}
|
|
&_ => return Err(anyhow::anyhow!("ERROR:INVALID:GET")),
|
|
}
|
|
|
|
let _ = send(&tx, &msg);
|
|
Ok(())
|
|
}
|
|
|
|
pub async fn handle_set_data(
|
|
&self,
|
|
tx: UnboundedSender<Message>,
|
|
addr: SocketAddr,
|
|
data_id: String,
|
|
data_value: String,
|
|
) -> Result<(), anyhow::Error> {
|
|
if !self.auth_check(addr).await {
|
|
return Err(anyhow::anyhow!("ERROR:INVALID:AUTH"));
|
|
}
|
|
|
|
match data_id.as_str() {
|
|
"DEMO_MODE" => {
|
|
let demo_mode = data_value.parse::<bool>();
|
|
if demo_mode.is_err() {
|
|
return Err(anyhow::anyhow!("ERROR:INVALID:SET"));
|
|
}
|
|
*self.demo_mode.write().await = demo_mode.unwrap();
|
|
}
|
|
"MOVE_WAIT" => {
|
|
let wait_time = data_value.parse::<f64>();
|
|
if wait_time.is_err() {
|
|
return Err(anyhow::anyhow!("ERROR:INVALID:SET"));
|
|
}
|
|
*self.waiting_timeout.write().await = (wait_time.unwrap() * 1000.0) as u64;
|
|
}
|
|
"MAX_TIMEOUT" => {
|
|
let max_time = data_value.parse::<f64>();
|
|
if max_time.is_err() {
|
|
return Err(anyhow::anyhow!("ERROR:INVALID:SET"));
|
|
}
|
|
*self.max_timeout.write().await = (max_time.unwrap() * 1000.0) as u64;
|
|
}
|
|
&_ => return Err(anyhow::anyhow!("ERROR:INVALID:SET")),
|
|
}
|
|
|
|
let _ = send(&tx, &format!("SET:{}:ACK", data_id));
|
|
Ok(())
|
|
}
|
|
|
|
pub async fn handle_reservation_add(
|
|
&self,
|
|
tx: UnboundedSender<Message>,
|
|
addr: SocketAddr,
|
|
player1_username: String,
|
|
player2_username: String,
|
|
) -> Result<(), anyhow::Error> {
|
|
if !self.auth_check(addr).await {
|
|
return Err(anyhow::anyhow!("ERROR:INVALID:AUTH"));
|
|
}
|
|
|
|
self.reservations.write().await.push((player1_username.clone(), player2_username.clone()));
|
|
|
|
let _ = send(
|
|
&tx,
|
|
&format!("RESERVATION:ADD:{},{}", player1_username, player2_username),
|
|
);
|
|
|
|
let clients_guard = self.clients.read().await;
|
|
if clients_guard.get(&player1_username).is_some() && clients_guard.get(&player2_username).is_some() {
|
|
let mut player1 = clients_guard.get(&player1_username).unwrap().write().await;
|
|
let mut player2 = clients_guard.get(&player2_username).unwrap().write().await;
|
|
|
|
if player1.ready && player2.ready {
|
|
let match_id: u32 = gen_match_id(&self.matches).await;
|
|
let new_match = Arc::new(RwLock::new(Match::new(
|
|
match_id,
|
|
player1_username.clone(),
|
|
player2_username.clone(),
|
|
false,
|
|
)));
|
|
self.matches.write().await.insert(match_id, new_match.clone());
|
|
|
|
player1.ready = false;
|
|
player1.current_match = Some(match_id);
|
|
player1.color = if new_match.read().await.player1 == player1_username {
|
|
let _ = send(&tx, "GAME:START:1");
|
|
let _ = send(&player2.connection, "GAME:START:0");
|
|
Color::Red
|
|
} else {
|
|
let _ = send(&tx, "GAME:START:0");
|
|
let _ = send(&player2.connection, "GAME:START:1");
|
|
Color::Yellow
|
|
};
|
|
|
|
player2.ready = false;
|
|
player2.current_match = Some(match_id);
|
|
player2.color = !player1.color;
|
|
|
|
self.reservations
|
|
.write()
|
|
.await
|
|
.retain(|(p1, p2)| !(p1 == &player1_username && p2 == &player2_username));
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub async fn handle_reservation_delete(
|
|
&self,
|
|
tx: UnboundedSender<Message>,
|
|
addr: SocketAddr,
|
|
player1_username: String,
|
|
player2_username: String,
|
|
) -> Result<(), anyhow::Error> {
|
|
if !self.auth_check(addr).await {
|
|
return Err(anyhow::anyhow!("ERROR:INVALID:AUTH"));
|
|
}
|
|
|
|
self.reservations
|
|
.write()
|
|
.await
|
|
.retain(|(p1, p2)| !(p1 == &player1_username && p2 == &player2_username));
|
|
|
|
let _ = send(
|
|
&tx,
|
|
&format!(
|
|
"RESERVATION:DELETE:{},{}",
|
|
player1_username, player2_username
|
|
),
|
|
);
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub async fn handle_reservation_get(
|
|
&self,
|
|
tx: UnboundedSender<Message>,
|
|
addr: SocketAddr,
|
|
) -> Result<(), anyhow::Error> {
|
|
if !self.auth_check(addr).await {
|
|
return Err(anyhow::anyhow!("ERROR:INVALID:AUTH"));
|
|
}
|
|
|
|
let reservations_guard = self.reservations.read().await;
|
|
let mut msg = "RESERVATION:LIST:".to_string();
|
|
for (p1, p2) in reservations_guard.iter() {
|
|
msg += &format!("{},{}|", p1, p2);
|
|
}
|
|
if msg.ends_with("|") {
|
|
msg.pop();
|
|
}
|
|
|
|
let _ = send(&tx, &msg);
|
|
Ok(())
|
|
}
|
|
|
|
pub async fn watch(&self, new_match_id: u32, addr: SocketAddr) -> Result<(), String> {
|
|
let Some(username) = self
|
|
.usernames
|
|
.read()
|
|
.await
|
|
.iter()
|
|
.find_map(|(username, client_addr)| if *client_addr == addr { Some(username.clone()) } else { None })
|
|
else {
|
|
return Err("Client not found".to_string());
|
|
};
|
|
let matches_guard = self.matches.read().await;
|
|
|
|
for match_guard in matches_guard.values() {
|
|
let mut found = false;
|
|
let mut a_match = match_guard.write().await;
|
|
for i in 0..a_match.viewers.len() {
|
|
if a_match.viewers[i] == username.as_str() {
|
|
a_match.viewers.remove(i);
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if found {
|
|
break;
|
|
}
|
|
}
|
|
|
|
let result = matches_guard.get(&new_match_id);
|
|
if result.is_none() {
|
|
return Err("Match not found".to_string());
|
|
}
|
|
result.unwrap().write().await.viewers.push(username);
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub async fn remove_observer_from_all_matches(&self, addr: SocketAddr) {
|
|
let Some(username) = self
|
|
.usernames
|
|
.read()
|
|
.await
|
|
.iter()
|
|
.find_map(|(username, client_addr)| if *client_addr == addr { Some(username.clone()) } else { None })
|
|
else {
|
|
return;
|
|
};
|
|
let matches_guard = self.matches.read().await;
|
|
|
|
for match_guard in matches_guard.values() {
|
|
let mut found = false;
|
|
let mut a_match = match_guard.write().await;
|
|
for i in 0..a_match.viewers.len() {
|
|
if a_match.viewers[i] == username.as_str() {
|
|
a_match.viewers.remove(i);
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if found {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
pub async fn terminate_match(&self, match_id: u32) {
|
|
let matches_guard = self.matches.read().await;
|
|
let the_match = matches_guard.get(&match_id);
|
|
if the_match.is_none() {
|
|
error!(
|
|
"Tried to call terminate_match on invalid matchID: {}",
|
|
match_id
|
|
);
|
|
}
|
|
let the_match = the_match.unwrap().read().await;
|
|
|
|
if let Some(wait_thread) = &the_match.wait_thread {
|
|
wait_thread.abort();
|
|
}
|
|
|
|
if let Some(timeout_thread) = &the_match.timeout_thread {
|
|
timeout_thread.abort();
|
|
}
|
|
|
|
self.broadcast_message(&the_match.viewers, "GAME:TERMINATED").await;
|
|
|
|
let clients_guard = self.clients.read().await;
|
|
if the_match.player1 != SERVER_PLAYER_USERNAME {
|
|
let mut player1 = clients_guard.get(&the_match.player1).unwrap().write().await;
|
|
let _ = send(&player1.connection, "GAME:TERMINATED");
|
|
player1.current_match = None;
|
|
player1.color = Color::None;
|
|
}
|
|
|
|
if the_match.player2 != SERVER_PLAYER_USERNAME {
|
|
let mut player2 = clients_guard.get(&the_match.player2).unwrap().write().await;
|
|
let _ = send(&player2.connection, "GAME:TERMINATED");
|
|
player2.current_match = None;
|
|
player2.color = Color::None;
|
|
}
|
|
drop(clients_guard);
|
|
|
|
drop(the_match);
|
|
drop(matches_guard);
|
|
|
|
self.matches.write().await.remove(&match_id);
|
|
}
|
|
|
|
pub async fn broadcast_message(&self, usernames: &Vec<String>, msg: &str) {
|
|
broadcast_message(&self.clients, &self.observers, usernames, msg).await;
|
|
}
|
|
|
|
pub async fn broadcast_message_all_observers(&self, msg: &str) {
|
|
let observers_guard = self.observers.read().await;
|
|
for (_, tx) in observers_guard.iter() {
|
|
let _ = send(tx, msg);
|
|
}
|
|
}
|
|
|
|
pub async fn auth_check(&self, addr: SocketAddr) -> bool {
|
|
let Some(username) = self
|
|
.usernames
|
|
.read()
|
|
.await
|
|
.iter()
|
|
.find_map(|(username, client_addr)| if *client_addr == addr { Some(username.clone()) } else { None })
|
|
else {
|
|
return false;
|
|
};
|
|
if self.admin.read().await.is_none() || self.admin.read().await.as_ref().unwrap() != &username {
|
|
return false;
|
|
}
|
|
true
|
|
}
|
|
|
|
pub async fn find_reservation_opponent(&self, username: String) -> Option<String> {
|
|
let reservations_guard = self.reservations.read().await;
|
|
for (player1, player2) in reservations_guard.iter() {
|
|
if player1 == &username || player2 == &username {
|
|
let opponent_username = if player1 == &username {
|
|
player2
|
|
} else {
|
|
player1
|
|
};
|
|
|
|
let clients_guard = self.clients.read().await;
|
|
if let Some(opponent) = clients_guard.get(opponent_username) {
|
|
let opponent = opponent.read().await;
|
|
if opponent.ready {
|
|
return Some(opponent_username.clone());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
None
|
|
}
|
|
}
|