881 lines
31 KiB
Rust
881 lines
31 KiB
Rust
mod random_ai;
|
|
mod types;
|
|
|
|
use crate::random_ai::random_move;
|
|
use crate::types::{Color, Match, Tournament};
|
|
use futures_util::{SinkExt, StreamExt};
|
|
use rand::Rng;
|
|
use std::collections::HashMap;
|
|
use std::env;
|
|
use std::net::SocketAddr;
|
|
use std::num::ParseIntError;
|
|
use std::process::abort;
|
|
use std::sync::Arc;
|
|
use tokio::io::{AsyncReadExt, AsyncWriteExt};
|
|
use tokio::net::{TcpListener, TcpStream};
|
|
use tokio::sync::mpsc::error::SendError;
|
|
use tokio::sync::mpsc::UnboundedSender;
|
|
use tokio::sync::RwLock;
|
|
use tokio_tungstenite::tungstenite::Utf8Bytes;
|
|
use tokio_tungstenite::{accept_async, tungstenite::Message};
|
|
use tracing::{error, info, warn};
|
|
use types::Client;
|
|
|
|
type Clients = Arc<RwLock<HashMap<SocketAddr, Arc<RwLock<Client>>>>>;
|
|
type Usernames = Arc<RwLock<HashMap<String, SocketAddr>>>;
|
|
type Observers = Arc<RwLock<HashMap<SocketAddr, UnboundedSender<Message>>>>;
|
|
type Matches = Arc<RwLock<HashMap<u32, Arc<RwLock<Match>>>>>;
|
|
|
|
#[tokio::main]
|
|
async fn main() -> Result<(), anyhow::Error> {
|
|
// Initialize logging
|
|
tracing_subscriber::fmt::init();
|
|
|
|
let args: Vec<String> = env::args().collect();
|
|
let demo_mode = args.get(1).is_some() && args.get(1).unwrap() == "demo";
|
|
let admin_password = env::var("ADMIN_AUTH").unwrap_or_else(|_| String::from("admin"));
|
|
info!("Admin password: {}", admin_password);
|
|
let admin_password = Arc::new(admin_password);
|
|
|
|
let addr = "0.0.0.0:8080";
|
|
let listener = TcpListener::bind(&addr).await?;
|
|
info!("WebSocket server listening on: {}", addr);
|
|
|
|
let clients: Clients = Arc::new(RwLock::new(HashMap::new()));
|
|
let usernames: Usernames = Arc::new(RwLock::new(HashMap::new()));
|
|
let observers: Observers = Arc::new(RwLock::new(HashMap::new()));
|
|
let matches: Matches = Arc::new(RwLock::new(HashMap::new()));
|
|
let admin: Arc<RwLock<Option<SocketAddr>>> = Arc::new(RwLock::new(None));
|
|
let tournament: Arc<RwLock<Option<Tournament>>> = Arc::new(RwLock::new(None));
|
|
let waiting_timeout: Arc<RwLock<u64>> = Arc::new(RwLock::new(5));
|
|
|
|
while let Ok((stream, addr)) = listener.accept().await {
|
|
tokio::spawn(handle_connection(
|
|
stream,
|
|
addr,
|
|
clients.clone(),
|
|
usernames.clone(),
|
|
observers.clone(),
|
|
matches.clone(),
|
|
admin.clone(),
|
|
admin_password.clone(),
|
|
tournament.clone(),
|
|
waiting_timeout.clone(),
|
|
demo_mode,
|
|
));
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
async fn handle_connection(
|
|
stream: TcpStream,
|
|
addr: SocketAddr,
|
|
clients: Clients,
|
|
usernames: Usernames,
|
|
observers: Observers,
|
|
matches: Matches,
|
|
admin: Arc<RwLock<Option<SocketAddr>>>,
|
|
admin_password: Arc<String>,
|
|
tournament: Arc<RwLock<Option<Tournament>>>,
|
|
waiting_timeout: Arc<RwLock<u64>>,
|
|
demo_mode: bool,
|
|
) -> Result<(), anyhow::Error> {
|
|
info!("New WebSocket connection from: {}", addr);
|
|
|
|
let ws_stream = accept_async(stream).await?;
|
|
let (mut ws_sender, mut ws_receiver) = ws_stream.split();
|
|
let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
|
|
|
|
// Store the client
|
|
observers.write().await.insert(addr, tx.clone());
|
|
|
|
// Spawn task to handle outgoing messages
|
|
let send_task = tokio::spawn(async move {
|
|
while let Some(msg) = rx.recv().await {
|
|
if ws_sender.send(msg.clone()).await.is_err() {
|
|
break;
|
|
}
|
|
}
|
|
});
|
|
|
|
// Handle incoming messages
|
|
while let Some(msg) = ws_receiver.next().await {
|
|
match msg {
|
|
Ok(Message::Text(text)) => {
|
|
info!("Received text from {}: {}", addr, text);
|
|
|
|
if text.starts_with("CONNECT:") {
|
|
let requested_username = text.split(":").collect::<Vec<&str>>()[1].to_string();
|
|
|
|
if requested_username.is_empty() {
|
|
let _ = send(&tx, &format!("ERROR:INVALID:ID:{}", requested_username));
|
|
continue;
|
|
}
|
|
|
|
let mut is_taken = false;
|
|
for client in clients.read().await.values() {
|
|
if requested_username == client.read().await.username {
|
|
let _ = send(&tx, &format!("ERROR:INVALID:ID:{}", requested_username));
|
|
is_taken = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if is_taken {
|
|
continue;
|
|
}
|
|
|
|
// not taken
|
|
observers.write().await.remove(&addr);
|
|
usernames.write().await.insert(requested_username.clone(), addr);
|
|
clients.write().await.insert(
|
|
addr.to_string().parse()?,
|
|
Arc::new(RwLock::new(Client::new(
|
|
requested_username,
|
|
tx.clone(),
|
|
addr.to_string().parse()?,
|
|
))),
|
|
);
|
|
|
|
let _ = send(&tx, "CONNECT:ACK");
|
|
}
|
|
else if text == "READY" {
|
|
if clients.read().await.get(&addr).is_none() {
|
|
let _ = send(&tx, "ERROR:INVALID");
|
|
continue;
|
|
}
|
|
|
|
if clients.read().await.get(&addr).unwrap().read().await.ready {
|
|
let _ = send(&tx, "ERROR:INVALID");
|
|
continue;
|
|
}
|
|
|
|
clients.write().await.get_mut(&addr).unwrap().write().await.ready = true;
|
|
|
|
let _ = send(&tx, "READY:ACK");
|
|
|
|
if demo_mode {
|
|
let match_id: u32 = rand::rng().random_range(100000..=999999);
|
|
let new_match = Arc::new(RwLock::new(Match::new(
|
|
match_id,
|
|
addr.to_string().parse()?,
|
|
addr.to_string().parse()?,
|
|
)));
|
|
matches.write().await.insert(match_id, new_match.clone());
|
|
clients.write().await.get_mut(&addr).unwrap().write().await.ready = false;
|
|
clients.write().await.get_mut(&addr).unwrap().write().await.current_match =
|
|
Some(match_id);
|
|
clients.write().await.get_mut(&addr).unwrap().write().await.color =
|
|
Color::Red;
|
|
let _ = send(&tx, "GAME:START:1");
|
|
}
|
|
}
|
|
else if text.starts_with("PLAY:") {
|
|
let clients_guard = clients.read().await;
|
|
let client_option = clients_guard.get(&addr);
|
|
|
|
// Check if client is valid
|
|
if client_option.is_none() || client_option.unwrap().read().await.current_match.is_none()
|
|
{
|
|
let _ = send(&tx, "ERROR:INVALID:MOVE");
|
|
continue;
|
|
}
|
|
|
|
let client = client_option.unwrap().read().await;
|
|
|
|
let matches_guard = matches.read().await;
|
|
let current_match =
|
|
matches_guard.get(&client.current_match.unwrap()).unwrap().read().await;
|
|
|
|
let opponent = {
|
|
let result = if addr == current_match.player1 {
|
|
clients_guard.get(¤t_match.player2).unwrap().read().await
|
|
} else {
|
|
clients_guard.get(¤t_match.player1).unwrap().read().await
|
|
};
|
|
|
|
result
|
|
};
|
|
|
|
// Check if it's their move
|
|
if (current_match.ledger.is_empty() && current_match.player1 != addr) ||
|
|
(current_match.ledger.last().is_some() && current_match.ledger.last().unwrap().0 == client.color)
|
|
{
|
|
let _ = send(&tx, "ERROR:INVALID:MOVE");
|
|
continue;
|
|
}
|
|
|
|
let column_parse = text.split(":").collect::<Vec<&str>>()[1].parse::<usize>();
|
|
|
|
drop(current_match);
|
|
drop(matches_guard);
|
|
|
|
let mut matches_guard = matches.write().await;
|
|
let mut current_match = matches_guard
|
|
.get_mut(&client.current_match.unwrap())
|
|
.unwrap()
|
|
.write()
|
|
.await;
|
|
|
|
// Check if valid move
|
|
let mut invalid = false;
|
|
if let Ok(column) = column_parse {
|
|
if column >= 7 {
|
|
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;
|
|
}
|
|
|
|
|
|
} else {
|
|
let _ = send(&tx, "ERROR:INVALID:MOVE");
|
|
invalid = true;
|
|
}
|
|
|
|
// Terminate games if a player makes an invalid move
|
|
if invalid {
|
|
let opponent_addr = opponent.addr;
|
|
let current_match_id = current_match.id;
|
|
|
|
broadcast_message(¤t_match.viewers, &observers, "GAME:TERMINATED").await;
|
|
|
|
drop(client);
|
|
drop(opponent);
|
|
drop(current_match);
|
|
drop(clients_guard);
|
|
|
|
let mut clients_guard = clients.write().await;
|
|
let mut client = clients_guard.get_mut(&addr).unwrap().write().await;
|
|
client.current_match = None;
|
|
let _ = send(&tx, "GAME:TERMINATED");
|
|
drop(client);
|
|
|
|
let mut opponent =
|
|
clients_guard.get_mut(&opponent_addr).unwrap().write().await;
|
|
|
|
if !demo_mode {
|
|
opponent.current_match = None;
|
|
let _ = send(&opponent.connection, "GAME:TERMINATED");
|
|
}
|
|
matches_guard.remove(¤t_match_id).unwrap();
|
|
|
|
continue;
|
|
} else {
|
|
// Place it
|
|
current_match.place_token(client.color.clone(), column_parse.clone()?);
|
|
current_match.move_to_dispatch = (client.color.clone(), column_parse.clone()?);
|
|
}
|
|
|
|
// broadcast the move to viewers
|
|
broadcast_message(
|
|
¤t_match.viewers,
|
|
&observers,
|
|
&format!("GAME:MOVE:{}:{}", client.username, column_parse.clone()?),
|
|
)
|
|
.await;
|
|
|
|
// Check game end conditions
|
|
let (winner, filled) = {
|
|
let mut result = (Color::None, false);
|
|
|
|
let mut any_empty = true;
|
|
for x in 0..7 {
|
|
for y in 0..6 {
|
|
let color = current_match.board[x][y].clone();
|
|
let mut horizontal_end = true;
|
|
let mut vertical_end = true;
|
|
let mut diagonal_end = true;
|
|
|
|
if any_empty && color == Color::None {
|
|
any_empty = false;
|
|
}
|
|
|
|
for i in 0..4 {
|
|
if x + i >= 7
|
|
|| current_match.board[x + i][y] != color && horizontal_end
|
|
{
|
|
horizontal_end = false;
|
|
}
|
|
|
|
if y + i >= 6
|
|
|| current_match.board[x][y + i] != color && vertical_end
|
|
{
|
|
vertical_end = false;
|
|
}
|
|
|
|
if x + i >= 7
|
|
|| y + i >= 6
|
|
|| current_match.board[x + i][y + i] != color
|
|
&& diagonal_end
|
|
{
|
|
diagonal_end = false;
|
|
}
|
|
}
|
|
|
|
if horizontal_end || vertical_end || diagonal_end {
|
|
result = (color.clone(), false);
|
|
break;
|
|
}
|
|
}
|
|
if result.0 != Color::None {
|
|
break;
|
|
}
|
|
}
|
|
|
|
if any_empty && result.0 == Color::None {
|
|
result.1 = true;
|
|
}
|
|
|
|
result
|
|
};
|
|
|
|
if winner != Color::None {
|
|
if winner == client.color {
|
|
let _ = send(&tx, "GAME:WINS");
|
|
if !demo_mode {
|
|
let _ = send(&opponent.connection, "GAME:LOSS");
|
|
}
|
|
broadcast_message(
|
|
¤t_match.viewers,
|
|
&observers,
|
|
&format!("GAME:WIN:{}", client.username),
|
|
)
|
|
.await;
|
|
} else {
|
|
let _ = send(&tx, "GAME:LOSS");
|
|
if !demo_mode {
|
|
let _ = send(&opponent.connection, "GAME:WINS");
|
|
}
|
|
broadcast_message(
|
|
¤t_match.viewers,
|
|
&observers,
|
|
&format!("GAME:WIN:{}", opponent.username),
|
|
)
|
|
.await;
|
|
}
|
|
} else if filled {
|
|
let _ = send(&tx, "GAME:DRAW");
|
|
if !demo_mode {
|
|
let _ = send(&opponent.connection, "GAME:DRAW");
|
|
}
|
|
broadcast_message(¤t_match.viewers, &observers, "GAME:DRAW").await;
|
|
}
|
|
|
|
// remove match from matchmaker
|
|
if winner != Color::None || filled {
|
|
let opponent_addr = opponent.addr;
|
|
let current_match_id = current_match.id;
|
|
|
|
drop(client);
|
|
drop(opponent);
|
|
drop(current_match);
|
|
drop(clients_guard);
|
|
|
|
let mut clients_guard = clients.write().await;
|
|
let mut client = clients_guard.get_mut(&addr).unwrap().write().await;
|
|
if client.color == winner {
|
|
client.score += 1;
|
|
}
|
|
client.current_match = None;
|
|
client.color = Color::None;
|
|
drop(client);
|
|
|
|
let mut opponent =
|
|
clients_guard.get_mut(&opponent_addr).unwrap().write().await;
|
|
|
|
if !demo_mode {
|
|
opponent.current_match = None;
|
|
if opponent.color == winner {
|
|
opponent.score += 1;
|
|
}
|
|
opponent.color = Color::None;
|
|
}
|
|
matches_guard.remove(¤t_match_id).unwrap();
|
|
drop(opponent);
|
|
|
|
if !demo_mode && matches_guard.is_empty() {
|
|
let mut tournament_guard = tournament.write().await;
|
|
let tourney = tournament_guard.as_mut().unwrap();
|
|
tourney.next();
|
|
if tourney.is_completed {
|
|
// Send scores
|
|
let mut player_scores: Vec<(String, u32)> = Vec::new();
|
|
for (_, player_addr) in tourney.players.iter() {
|
|
let mut player = clients_guard.get_mut(player_addr).unwrap().write().await;
|
|
player_scores.push((player.username.clone(), player.score));
|
|
player.score = 0;
|
|
player.round_robin_id = 0;
|
|
}
|
|
|
|
player_scores.sort_by(|a, b| b.1.cmp(&a.1));
|
|
|
|
let mut message = "TOURNAMENT:END:".to_string();
|
|
for (player, score) in player_scores.iter() {
|
|
message.push_str(&format!("{},{}|", player, score))
|
|
}
|
|
message.pop();
|
|
|
|
broadcast_message_all_observers(&observers, &message).await;
|
|
} else {
|
|
// Create next matches
|
|
// TODO: Make this a function
|
|
for (i, id) in tourney.top_half.iter().enumerate() {
|
|
let player1_addr = tourney.players.get(id).unwrap();
|
|
let player2_addr = tourney.players.get(tourney.bottom_half.get(i).unwrap());
|
|
|
|
if player2_addr.is_none() { continue; }
|
|
let player2_addr = player2_addr.unwrap();
|
|
|
|
// TODO: gen without collisions
|
|
let match_id: u32 = rand::rng().random_range(100000..=999999);
|
|
let new_match = Arc::new(RwLock::new(Match::new(
|
|
match_id,
|
|
*player1_addr,
|
|
*player2_addr,
|
|
)));
|
|
|
|
let match_guard = new_match.read().await;
|
|
let mut player1 = clients_guard.get_mut(player1_addr).unwrap().write().await;
|
|
|
|
player1.current_match = Some(match_id);
|
|
player1.ready = false;
|
|
|
|
if match_guard.player1 == *player1_addr {
|
|
player1.color = Color::Red;
|
|
let _ = send(&player1.connection, "GAME:START:1");
|
|
} else {
|
|
player1.color = Color::Blue;
|
|
let _ = send(&player1.connection, "GAME:START:0");
|
|
}
|
|
|
|
drop(player1);
|
|
|
|
let mut player2 = clients_guard.get_mut(player2_addr).unwrap().write().await;
|
|
|
|
player2.current_match = Some(match_id);
|
|
player2.ready = false;
|
|
|
|
if match_guard.player1 == *player2_addr {
|
|
player2.color = Color::Red;
|
|
let _ = send(&player2.connection, "GAME:START:1");
|
|
} else {
|
|
player2.color = Color::Blue;
|
|
let _ = send(&player2.connection, "GAME:START:0");
|
|
}
|
|
|
|
drop(player2);
|
|
|
|
matches_guard.insert(match_id, new_match.clone());
|
|
}
|
|
}
|
|
}
|
|
|
|
continue;
|
|
}
|
|
|
|
if !demo_mode {
|
|
let connection = opponent.connection.clone();
|
|
let column = column_parse.clone()?;
|
|
let waiting = *waiting_timeout.read().await as i64 * 1000 + (rand::rng().random_range(0..=500) - 250);
|
|
let matches_move = matches.clone();
|
|
let match_id_move = current_match.id;
|
|
current_match.wait_thread = Some(tokio::spawn(async move {
|
|
tokio::time::sleep(tokio::time::Duration::from_millis(waiting as u64)).await;
|
|
|
|
let mut matches_guard = matches_move.write().await;
|
|
let mut current_match = matches_guard.get_mut(&match_id_move).unwrap().write().await;
|
|
let move_to_dispatch = current_match.move_to_dispatch.clone();
|
|
current_match.ledger.push(move_to_dispatch);
|
|
current_match.move_to_dispatch = (Color::None, 0);
|
|
|
|
drop(current_match);
|
|
drop(matches_guard);
|
|
|
|
let _ = send(
|
|
&connection,
|
|
&format!("OPPONENT:{}", column),
|
|
);
|
|
}));
|
|
} else {
|
|
let random_move = random_move(¤t_match.board);
|
|
current_match.place_token(Color::Blue, random_move);
|
|
let _ = send(&tx, &format!("OPPONENT:{}", random_move));
|
|
broadcast_message(
|
|
¤t_match.viewers,
|
|
&observers,
|
|
&format!("GAME:MOVE:{}:{}", "demo", random_move),
|
|
).await;
|
|
}
|
|
}
|
|
|
|
else if text == "PLAYER:LIST" {
|
|
let clients_guard = 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 += "|";
|
|
}
|
|
|
|
to_send.remove(to_send.len() - 1);
|
|
|
|
let _ = send(&tx, to_send.as_str());
|
|
}
|
|
else if text == "GAME:LIST" {
|
|
let matches_guard = matches.read().await;
|
|
let clients_guard = 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 = clients_guard.get(&a_match.player1).unwrap().read().await;
|
|
let player2 = clients_guard.get(&a_match.player2).unwrap().read().await;
|
|
to_send += a_match.id.to_string().as_str();
|
|
to_send += ","; to_send += player1.username.as_str(); to_send += ",";
|
|
to_send += (if player1.username == player2.username { "demo" } else { player2.username.as_str() });
|
|
to_send += "|";
|
|
}
|
|
|
|
to_send.remove(to_send.len() - 1);
|
|
|
|
let _ = send(&tx, to_send.as_str());
|
|
}
|
|
else if text.starts_with("GAME:WATCH:") {
|
|
let match_id_parse = text.split(":").collect::<Vec<&str>>()[2].parse::<u32>();
|
|
match match_id_parse {
|
|
Ok(match_id) => {
|
|
let result = watch(&matches, match_id, addr).await;
|
|
if result.is_err() { let _ = send(&tx, "ERROR:INVALID:WATCH"); continue; }
|
|
|
|
let clients_guard = clients.read().await;
|
|
let matches_guard = matches.read().await;
|
|
let the_match = matches_guard.get(&match_id).unwrap().read().await;
|
|
let player1 = clients_guard.get(&the_match.player1).unwrap().read().await.username.clone();
|
|
let player2 = clients_guard.get(&the_match.player2).unwrap().read().await.username.clone();
|
|
let ledger = the_match.ledger.clone();
|
|
|
|
drop(clients_guard);
|
|
drop(the_match);
|
|
drop(matches_guard);
|
|
|
|
let _ = send(&tx, &format!("GAME:WATCH:ACK:{},{},{}", match_id, player1, player2));
|
|
|
|
for a_move in ledger {
|
|
if a_move.0 == Color::Red {
|
|
let _ = send(&tx, &format!("GAME:MOVE:{}:{}", player1, a_move.1));
|
|
} else {
|
|
let _ = send(&tx, &format!("GAME:MOVE:{}:{}", player2, a_move.1));
|
|
}
|
|
}
|
|
}
|
|
Err(_) => { let _ = send(&tx, "ERROR:INVALID:WATCH"); continue; }
|
|
}
|
|
}
|
|
|
|
else if text.starts_with("ADMIN:AUTH:") {
|
|
if admin.read().await.is_some() {
|
|
let _ = send(&tx, "ERROR:INVALID:AUTH");
|
|
continue;
|
|
}
|
|
|
|
let password_parse = text.split(":").collect::<Vec<&str>>()[2];
|
|
if password_parse != *admin_password {
|
|
let _ = send(&tx, "ERROR:INVALID:AUTH");
|
|
continue;
|
|
}
|
|
|
|
let mut admin_guard = admin.write().await;
|
|
*admin_guard = Some(addr.to_string().parse()?);
|
|
let _ = send(&tx, "ADMIN:AUTH:ACK");
|
|
}
|
|
else if text.starts_with("ADMIN:KICK:") {
|
|
if admin.read().await.is_none() || admin.read().await.unwrap() != addr {
|
|
let _ = send(&tx, "ERROR:INVALID:AUTH");
|
|
continue;
|
|
}
|
|
|
|
let kick_username = text.split(":").collect::<Vec<&str>>()[2];
|
|
|
|
let usernames_guard = usernames.read().await;
|
|
let clients_guard = clients.read().await;
|
|
|
|
let kick_addr_result = usernames_guard.get(kick_username);
|
|
match kick_addr_result {
|
|
Some(kick_addr) => {
|
|
let kick_client = clients_guard.get(kick_addr).unwrap().read().await;
|
|
kick_client.connection.send(Message::Close(None))?;
|
|
},
|
|
None => {
|
|
let _ = send(&tx, "ERROR:INVALID:KICK");
|
|
continue
|
|
}
|
|
}
|
|
}
|
|
else if text == "GAME:TERMINATE" {
|
|
if admin.read().await.is_none() || admin.read().await.unwrap() != addr {
|
|
let _ = send(&tx, "ERROR:INVALID:AUTH");
|
|
continue;
|
|
}
|
|
|
|
let match_id_request = get_current_watching_match(&matches, addr).await;
|
|
|
|
match match_id_request {
|
|
Some(match_id) => {
|
|
let match_guard = matches.read().await;
|
|
let the_match = match_guard.get(&match_id).unwrap().read().await;
|
|
if let Some(wait_thread) = &the_match.wait_thread {
|
|
wait_thread.abort();
|
|
}
|
|
let player1_addr = the_match.player1;
|
|
let player2_addr = the_match.player2;
|
|
broadcast_message(&the_match.viewers, &observers, "GAME:TERMINATED").await;
|
|
drop(the_match);
|
|
drop(match_guard);
|
|
|
|
let clients_guard = clients.write().await;
|
|
|
|
let mut player1 = clients_guard.get(&player1_addr).unwrap().write().await;
|
|
player1.current_match = None;
|
|
player1.color = Color::None;
|
|
let _ = send(&player1.connection, "GAME:TERMINATED");
|
|
drop(player1);
|
|
|
|
let mut player2 = clients_guard.get(&player2_addr).unwrap().write().await;
|
|
player2.current_match = None;
|
|
player2.color = Color::None;
|
|
let _ = send(&player2.connection, "GAME:TERMINATED");
|
|
drop(player2);
|
|
|
|
drop(clients_guard);
|
|
|
|
matches.write().await.remove(&match_id);
|
|
},
|
|
None => {
|
|
let _ = send(&tx, "ERROR:INVALID:TERMINATE");
|
|
}
|
|
}
|
|
}
|
|
|
|
else if text == "TOURNAMENT:START" {
|
|
if admin.read().await.is_none() || admin.read().await.unwrap() != addr {
|
|
let _ = send(&tx, "ERROR:INVALID:AUTH");
|
|
continue;
|
|
}
|
|
|
|
if tournament.read().await.is_some() || demo_mode {
|
|
let _ = send(&tx, "ERROR:INVALID:TOURNAMENT");
|
|
continue;
|
|
}
|
|
|
|
let mut clients_guard = clients.write().await;
|
|
let mut ready_players = Vec::new();
|
|
for (client_addr, client_guard) in clients_guard.iter_mut() {
|
|
if client_guard.read().await.ready {
|
|
ready_players.push(*client_addr);
|
|
}
|
|
}
|
|
|
|
if ready_players.len() < 3 {
|
|
let _ = send(&tx, "ERROR:INVALID:TOURNAMENT");
|
|
continue;
|
|
}
|
|
|
|
let tourney = Tournament::new(&ready_players);
|
|
|
|
let mut tournament_guard = tournament.write().await;
|
|
*tournament_guard = Some(tourney.clone());
|
|
|
|
for (i, id) in tourney.top_half.iter().enumerate() {
|
|
let player1_addr = tourney.players.get(id).unwrap();
|
|
let player2_addr = tourney.players.get(tourney.bottom_half.get(i).unwrap()).unwrap();
|
|
let match_id: u32 = rand::rng().random_range(100000..=999999);
|
|
let new_match = Arc::new(RwLock::new(Match::new(
|
|
match_id,
|
|
*player1_addr,
|
|
*player2_addr,
|
|
)));
|
|
|
|
let match_guard = new_match.read().await;
|
|
let mut player1 = clients_guard.get_mut(player1_addr).unwrap().write().await;
|
|
|
|
player1.current_match = Some(match_id);
|
|
player1.ready = false;
|
|
|
|
if match_guard.player1 == *player1_addr {
|
|
player1.color = Color::Red;
|
|
let _ = send(&player1.connection, "GAME:START:1");
|
|
} else {
|
|
player1.color = Color::Blue;
|
|
let _ = send(&player1.connection, "GAME:START:0");
|
|
}
|
|
|
|
drop(player1);
|
|
|
|
let mut player2 = clients_guard.get_mut(player2_addr).unwrap().write().await;
|
|
|
|
player2.current_match = Some(match_id);
|
|
player2.ready = false;
|
|
|
|
if match_guard.player1 == *player2_addr {
|
|
player2.color = Color::Red;
|
|
let _ = send(&player2.connection, "GAME:START:1");
|
|
} else {
|
|
player2.color = Color::Blue;
|
|
let _ = send(&player2.connection, "GAME:START:0");
|
|
}
|
|
|
|
drop(player2);
|
|
|
|
matches.write().await.insert(match_id, new_match.clone());
|
|
}
|
|
|
|
let _ = send(&tx, "TOURNAMENT:START:ACK");
|
|
}
|
|
else if text.starts_with("TOURNAMENT:WAIT:") {
|
|
if admin.read().await.is_none() || admin.read().await.unwrap() != addr {
|
|
let _ = send(&tx, "ERROR:INVALID:AUTH");
|
|
continue;
|
|
}
|
|
|
|
let new_timeout = text.split(":").collect::<Vec<&str>>()[2].parse::<f64>()?;
|
|
*waiting_timeout.write().await = (new_timeout * 1000.0) as u64;
|
|
}
|
|
|
|
else {
|
|
let _ = send(&tx, "ERROR:UNKNOWN");
|
|
}
|
|
}
|
|
Ok(Message::Close(_)) => {
|
|
info!("Client {} disconnected", addr);
|
|
break;
|
|
}
|
|
Ok(Message::Ping(b)) => { let _ = tx.send(Message::Pong(b)); }
|
|
Ok(Message::Binary(_)) => { let _ = send(&tx, "ERROR:UNKNOWN"); }
|
|
Ok(_) => { info!("Received pong/frame? Something fishy is happening") },
|
|
Err(e) => {
|
|
error!("WebSocket error for {}: {}", addr, e);
|
|
break;
|
|
},
|
|
}
|
|
}
|
|
|
|
// Clean up
|
|
send_task.abort();
|
|
|
|
// Remove and terminate any matches
|
|
// TODO: Support reconnecting behaviors
|
|
if clients.read().await.get(&addr).is_some() { // We may not be a client disconnecting
|
|
if let Some(match_id) = clients.read().await.get(&addr).unwrap().read().await.current_match {
|
|
let matches_guard = matches.read().await;
|
|
let clients_guard = clients.read().await;
|
|
let the_match = matches_guard.get(&match_id).unwrap().read().await;
|
|
if let Some(wait_thread) = &the_match.wait_thread {
|
|
wait_thread.abort();
|
|
}
|
|
|
|
let player1 = clients_guard.get(&the_match.player1).unwrap().read().await;
|
|
let player2 = clients_guard.get(&the_match.player2).unwrap().read().await;
|
|
|
|
let _ = send(&player1.connection, "GAME:TERMINATED");
|
|
let _ = send(&player2.connection, "GAME:TERMINATED");
|
|
|
|
broadcast_message(&the_match.viewers, &observers, "GAME:TERMINATED").await;
|
|
|
|
drop(player1);
|
|
drop(player2);
|
|
drop(the_match);
|
|
drop(matches_guard);
|
|
drop(clients_guard);
|
|
|
|
matches.write().await.remove(&match_id);
|
|
}
|
|
let client = clients.write().await.remove(&addr).unwrap();
|
|
let username = client.read().await.username.clone();
|
|
usernames.write().await.remove(&username);
|
|
}
|
|
|
|
observers.write().await.remove(&addr);
|
|
|
|
let mut admin_guard = admin.write().await;
|
|
if let Some(admin_addr) = *admin_guard {
|
|
if admin_addr == addr {
|
|
*admin_guard = None;
|
|
}
|
|
}
|
|
drop(admin_guard);
|
|
|
|
info!("Client {} removed", addr);
|
|
|
|
Ok(())
|
|
}
|
|
|
|
async fn broadcast_message(addrs: &Vec<SocketAddr>, observers: &Observers, msg: &str) {
|
|
for addr in addrs {
|
|
let observers_guard = observers.read().await;
|
|
let tx = observers_guard.get(addr);
|
|
if tx.is_none() { continue; }
|
|
let _ = send(tx.unwrap(), msg);
|
|
}
|
|
}
|
|
|
|
async fn broadcast_message_all_observers(observers: &Observers, msg: &str) {
|
|
let observers_guard = observers.read().await;
|
|
for (_, tx) in observers_guard.iter() {
|
|
let _ = send(tx, msg);
|
|
}
|
|
}
|
|
|
|
async fn watch(matches: &Matches, new_match_id: u32, addr: SocketAddr) -> Result<(), String> {
|
|
let matches_guard = 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] == addr {
|
|
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(addr);
|
|
|
|
Ok(())
|
|
}
|
|
|
|
async fn get_current_watching_match(matches: &Matches, addr: SocketAddr) -> Option<u32> {
|
|
let matches_guard = matches.read().await;
|
|
let mut result = None;
|
|
for a_match in matches_guard.values() {
|
|
let a_match = a_match.read().await;
|
|
for viewer_addr in &a_match.viewers {
|
|
if *viewer_addr == addr {
|
|
result = Some(a_match.id);
|
|
break;
|
|
}
|
|
}
|
|
if result.is_some() { break; }
|
|
}
|
|
result
|
|
}
|
|
|
|
fn send(tx: &UnboundedSender<Message>, text: &str) -> Result<(), SendError<Message>> {
|
|
tx.send(Message::text(text))
|
|
}
|