joshuafhiggins/connect4-moderator-server
1
0
Fork 0
Code Issues Pull Requests Actions Packages Releases 2 Activity

misc: formatting and compile fix

Browse Source
This commit is contained in:
Joshua Higgins
2026-03-22 14:51:00 -04:00
Unverified
parent 677c70a763
commit c5738741f1
7 changed files with 1890 additions and 1903 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
.rustfmt.toml
View File

@@ -1,2 +1,3 @@
combine_control_expr = false combine_control_expr = false
chain_width = 100 chain_width = 100
tab_spaces = 2

46
src/lib.rs
View File

@@ -2,15 +2,15 @@ use std::{collections::HashMap, net::SocketAddr, sync::Arc};
use rand::RngExt; use rand::RngExt;
use tokio::sync::{ use tokio::sync::{
mpsc::{error::SendError, UnboundedSender}, mpsc::{error::SendError, UnboundedSender},
RwLock, RwLock,
}; };
use tokio_tungstenite::tungstenite::Message; use tokio_tungstenite::tungstenite::Message;
use tracing::error; use tracing::error;
use crate::{ use crate::{
tournaments::Tournament, tournaments::Tournament,
types::{Client, Color, Match}, types::{Client, Color, Match},
}; };
pub mod server; pub mod server;
@@ -28,34 +28,34 @@ pub const SERVER_PLAYER_USERNAME: &str = "The Server";
pub const SERVER_PLAYER_ADDR: &str = "127.0.0.1:6666"; pub const SERVER_PLAYER_ADDR: &str = "127.0.0.1:6666";
pub async fn broadcast_message(observers: &Observers, addrs: &Vec<SocketAddr>, msg: &str) { pub async fn broadcast_message(observers: &Observers, addrs: &Vec<SocketAddr>, msg: &str) {
for addr in addrs { for addr in addrs {
let observers_guard = observers.read().await; let observers_guard = observers.read().await;
let tx = observers_guard.get(addr); let tx = observers_guard.get(addr);
if tx.is_none() { if tx.is_none() {
continue; continue;
}
let _ = send(tx.unwrap(), msg);
} }
let _ = send(tx.unwrap(), msg);
}
} }
pub async fn gen_match_id(matches: &Matches) -> u32 { pub async fn gen_match_id(matches: &Matches) -> u32 {
let matches_guard = matches.read().await; let matches_guard = matches.read().await;
let mut result = rand::rng().random_range(100000..=999999); let mut result = rand::rng().random_range(100000..=999999);
while matches_guard.get(&result).is_some() { while matches_guard.get(&result).is_some() {
result = rand::rng().random_range(100000..=999999); result = rand::rng().random_range(100000..=999999);
} }
result result
} }
pub fn random_move(board: &[Vec<Color>]) -> usize { pub fn random_move(board: &[Vec<Color>]) -> usize {
let mut random = rand::rng().random_range(0..7); let mut random = rand::rng().random_range(0..7);
while board[random][5] != Color::None { while board[random][5] != Color::None {
random = rand::rng().random_range(0..7); random = rand::rng().random_range(0..7);
} }
random random
} }
pub fn send(tx: &UnboundedSender<Message>, text: &str) -> Result<(), SendError<Message>> { pub fn send(tx: &UnboundedSender<Message>, text: &str) -> Result<(), SendError<Message>> {
tx.send(Message::text(text)) tx.send(Message::text(text))
} }

608
src/main.rs
View File

@@ -10,340 +10,330 @@ use tracing::{error, info};
#[tokio::main] #[tokio::main]
async fn main() -> Result<(), anyhow::Error> { async fn main() -> Result<(), anyhow::Error> {
// Initialize logging // Initialize logging
tracing_subscriber::fmt::init(); tracing_subscriber::fmt::init();
let args: Vec<String> = env::args().collect(); let args: Vec<String> = env::args().collect();
let demo_mode = args.get(1).is_some() && args.get(1).unwrap() == "demo"; let demo_mode = args.get(1).is_some() && args.get(1).unwrap() == "demo";
if demo_mode { if demo_mode {
info!("Starting server in DEMO MODE"); info!("Starting server in DEMO MODE");
} }
let admin_password = env::var("ADMIN_AUTH").unwrap_or_else(|_| String::from("admin")); let admin_password = env::var("ADMIN_AUTH").unwrap_or_else(|_| String::from("admin"));
info!("Admin password: {}", admin_password); info!("Admin password: {}", admin_password);
let admin_password = Arc::new(admin_password); let admin_password = Arc::new(admin_password);
let addr = "0.0.0.0:8080"; let addr = "0.0.0.0:8080";
let listener = TcpListener::bind(&addr).await?; let listener = TcpListener::bind(&addr).await?;
let hosted_addr = if local_ip().is_ok() { let hosted_addr = if local_ip().is_ok() {
local_ip()?.to_string() + ":8080" local_ip()?.to_string() + ":8080"
} else { } else {
addr.to_string() addr.to_string()
}; };
info!("WebSocket server listening on: {}", hosted_addr); info!("WebSocket server listening on: {}", hosted_addr);
let server_data = Arc::new(Server::new(admin_password.as_ref().clone(), demo_mode)); let server_data = Arc::new(Server::new(admin_password.as_ref().clone(), demo_mode));
while let Ok((stream, addr)) = listener.accept().await { while let Ok((stream, addr)) = listener.accept().await {
tokio::spawn(handle_connection(stream, addr, server_data.clone())); tokio::spawn(handle_connection(stream, addr, server_data.clone()));
} }
Ok(()) Ok(())
} }
async fn handle_connection( async fn handle_connection(
stream: TcpStream, stream: TcpStream,
addr: SocketAddr, addr: SocketAddr,
sd: Arc<Server>, sd: Arc<Server>,
) -> Result<(), anyhow::Error> { ) -> Result<(), anyhow::Error> {
info!("New WebSocket connection from: {}", addr); info!("New WebSocket connection from: {}", addr);
let ws_stream = accept_async(stream).await?; let ws_stream = accept_async(stream).await?;
let (mut ws_sender, mut ws_receiver) = ws_stream.split(); let (mut ws_sender, mut ws_receiver) = ws_stream.split();
let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel(); let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
// Store the client // Store the client
sd.observers.write().await.insert(addr, tx.clone()); sd.observers.write().await.insert(addr, tx.clone());
// Spawn task to handle outgoing messages // Spawn task to handle outgoing messages
let send_task = tokio::spawn(async move { let send_task = tokio::spawn(async move {
while let Some(msg) = rx.recv().await { while let Some(msg) = rx.recv().await {
if ws_sender.send(msg.clone()).await.is_err() { if ws_sender.send(msg.clone()).await.is_err() {
break; break;
}
}
});
// Handle incoming messages
while let Some(msg) = ws_receiver.next().await {
match msg {
Ok(Message::Text(text)) => {
info!("Received text from {}: {}", addr, text);
let parts: Vec<&str> = text.split(':').collect();
let cmd = parts[0];
match cmd {
"CONNECT" => {
if parts.len() > 1 {
let requested_username = parts[1].to_string();
if let Err(e) = sd.handle_connect_cmd(addr, tx.clone(), requested_username).await {
error!("handle_connect: {}", e);
let _ = send(&tx, e.to_string().as_str());
}
} else {
let _ = send(&tx, "ERROR:INVALID:ID:");
} }
} }
}); "RECONNECT" => {
if parts.len() > 1 {
// Handle incoming messages let requested_username = parts[1].to_string();
while let Some(msg) = ws_receiver.next().await { if let Err(e) = sd.handle_reconnect_cmd(addr, tx.clone(), requested_username).await {
match msg { error!("handle_reconnect: {}", e);
Ok(Message::Text(text)) => { let _ = send(&tx, e.to_string().as_str());
info!("Received text from {}: {}", addr, text); }
let parts: Vec<&str> = text.split(':').collect(); } else {
let cmd = parts[0]; let _ = send(&tx, "ERROR:INVALID:RECONNECT:");
match cmd { }
"CONNECT" => { }
if parts.len() > 1 { "DISCONNECT" => {
let requested_username = parts[1].to_string(); if let Err(e) = sd.handle_disconnect_cmd(addr, tx.clone()).await {
if let Err(e) = error!("handle_disconnect: {}", e);
sd.handle_connect_cmd(addr, tx.clone(), requested_username).await let _ = send(&tx, e.to_string().as_str());
{ }
error!("handle_connect: {}", e); }
let _ = send(&tx, e.to_string().as_str()); "READY" => {
} if let Err(e) = sd.handle_ready(addr, tx.clone()).await {
} else { error!("handle_ready: {}", e);
let _ = send(&tx, "ERROR:INVALID:ID:"); let _ = send(&tx, e.to_string().as_str());
} }
} }
"RECONNECT" => { "PLAY" => {
if parts.len() > 1 { if parts.len() > 1 {
let requested_username = parts[1].to_string(); match parts[1].parse::<usize>() {
if let Err(e) = Ok(column) => {
sd.handle_reconnect_cmd(addr, tx.clone(), requested_username).await if let Err(e) = sd.handle_play(addr, tx.clone(), column).await {
{ error!("handle_play: {}", e);
error!("handle_reconnect: {}", e); let _ = send(&tx, e.to_string().as_str());
let _ = send(&tx, e.to_string().as_str()); }
}
} else {
let _ = send(&tx, "ERROR:INVALID:RECONNECT:");
}
}
"DISCONNECT" => {
if let Err(e) = sd.handle_disconnect_cmd(addr, tx.clone()).await {
error!("handle_disconnect: {}", e);
let _ = send(&tx, e.to_string().as_str());
}
}
"READY" => {
if let Err(e) = sd.handle_ready(addr, tx.clone()).await {
error!("handle_ready: {}", e);
let _ = send(&tx, e.to_string().as_str());
}
}
"PLAY" => {
if parts.len() > 1 {
match parts[1].parse::<usize>() {
Ok(column) => {
if let Err(e) = sd.handle_play(addr, tx.clone(), column).await {
error!("handle_play: {}", e);
let _ = send(&tx, e.to_string().as_str());
}
}
Err(_) => {
let _ = send(&tx, "ERROR:INVALID:MOVE");
}
}
} else {
let _ = send(&tx, "ERROR:INVALID:MOVE");
}
}
"PLAYER" => {
if parts.get(1) == Some(&"LIST") {
if let Err(e) = sd.handle_player_list(tx.clone()).await {
error!("handle_player_list: {}", e);
let _ = send(&tx, e.to_string().as_str());
}
} else {
let _ = send(&tx, "ERROR:INVALID:PLAYER");
}
}
"GAME" => {
if parts.get(1) == Some(&"LIST") {
if let Err(e) = sd.handle_game_list(tx.clone()).await {
error!("handle_game_list: {}", e);
let _ = send(&tx, e.to_string().as_str());
}
} else if parts.get(1) == Some(&"WATCH") && parts.len() > 2 {
match parts[2].parse::<u32>() {
Ok(match_id) => {
if let Err(e) =
sd.handle_game_watch(tx.clone(), match_id, addr).await
{
error!("handle_game_watch: {}", e);
let _ = send(&tx, e.to_string().as_str());
}
}
Err(_) => {
let _ = send(&tx, "ERROR:INVALID:WATCH");
}
}
} else if parts.get(1) == Some(&"TERMINATE") && parts.len() > 2 {
match parts[2].parse::<u32>() {
Ok(match_id) => {
if let Err(e) = sd.handle_game_terminate(addr, match_id).await {
error!("handle_game_terminate: {}", e);
let _ = send(&tx, e.to_string().as_str());
}
}
Err(_) => {
let _ = send(&tx, "ERROR:INVALID:TERMINATE");
}
}
} else if parts.get(1) == Some(&"AWARD") && parts.len() > 3 {
match parts[2].parse::<u32>() {
Ok(match_id) => {
let winner = parts[3].to_string();
if let Err(e) =
sd.handle_game_award_winner(addr, match_id, winner).await
{
error!("handle_game_award_winner: {}", e);
let _ = send(&tx, e.to_string().as_str());
}
}
Err(_) => {
let _ = send(&tx, "ERROR:INVALID:AWARD");
}
}
} else {
let _ = send(&tx, "ERROR:INVALID:GAME");
}
}
"ADMIN" => {
if parts.get(1) == Some(&"AUTH") && parts.len() > 2 {
if let Err(e) =
sd.handle_admin_auth(tx.clone(), addr, parts[2].to_string()).await
{
error!("handle_admin_auth: {}", e);
let _ = send(&tx, e.to_string().as_str());
}
} else if parts.get(1) == Some(&"KICK") && parts.len() > 2 {
if let Err(e) = sd.handle_admin_kick(addr, parts[2].to_string()).await {
error!("handle_admin_kick: {}", e);
let _ = send(&tx, e.to_string().as_str());
}
} else {
let _ = send(&tx, "ERROR:INVALID:ADMIN");
}
}
"TOURNAMENT" => {
if parts.get(1) == Some(&"START") && parts.len() > 2 {
if let Err(e) =
sd.handle_tournament_start(addr, parts[2].to_string()).await
{
error!("handle_tournament_start: {}", e);
let _ = send(&tx, e.to_string().as_str());
}
} else if parts.get(1) == Some(&"CANCEL") {
if let Err(e) = sd.handle_tournament_cancel(addr).await {
error!("handle_tournament_cancel: {}", e);
let _ = send(&tx, e.to_string().as_str());
}
} else {
let _ = send(&tx, "ERROR:INVALID:TOURNAMENT");
}
}
"GET" => {
if let Some(data_id) = parts.get(1) {
if let Err(e) =
sd.handle_get_data(tx.clone(), data_id.to_string()).await
{
error!("handle_get_data: {}", e);
let _ = send(&tx, e.to_string().as_str());
}
} else {
let _ = send(&tx, "ERROR:INVALID:GET");
}
}
"SET" => {
if parts.len() > 2 {
let data_id = parts[1].to_string();
let data_value = parts[2].to_string();
if let Err(e) =
sd.handle_set_data(tx.clone(), addr, data_id, data_value).await
{
error!("handle_set_data: {}", e);
let _ = send(&tx, e.to_string().as_str());
}
} else {
let _ = send(&tx, "ERROR:INVALID:SET");
}
}
"RESERVATION" => {
if parts.get(1) == Some(&"ADD") && parts.len() == 3 {
let usernames = parts[2].split(",").collect::<Vec<&str>>();
if usernames.len() != 2 {
error!("handle_reservation_add: invalid number of usernames");
let _ = send(&tx, "ERROR:INVALID:RESERVATION");
continue;
}
let player1_username = usernames[0].to_string();
let player2_username = usernames[1].to_string();
if let Err(e) = sd.handle_reservation_add(tx.clone(), addr, player1_username, player2_username).await {
error!("handle_reservation_add: {}", e);
let _ = send(&tx, e.to_string().as_str());
}
} else if parts.get(1) == Some(&"DELETE") && parts.len() == 3 {
let usernames = parts[2].split(",").collect::<Vec<&str>>();
if usernames.len() != 2 {
error!("handle_reservation_delete: invalid number of usernames");
let _ = send(&tx, "ERROR:INVALID:RESERVATION");
continue;
}
let player1_username = usernames[0].to_string();
let player2_username = usernames[1].to_string();
if let Err(e) = sd.handle_reservation_delete(tx.clone(), addr, player1_username, player2_username).await {
error!("handle_reservation_delete: {}", e);
let _ = send(&tx, e.to_string().as_str());
}
} else if parts.get(1) == Some(&"GET") {
if let Err(e) = sd.handle_reservation_get(tx.clone(), addr).await {
error!("handle_reservation_get: {}", e);
let _ = send(&tx, e.to_string().as_str());
}
} else {
let _ = send(&tx, "ERROR:INVALID:RESERVATION");
}
}
_ => {
let _ = send(&tx, "ERROR:UNKNOWN");
}
} }
Err(_) => {
let _ = send(&tx, "ERROR:INVALID:MOVE");
}
}
} else {
let _ = send(&tx, "ERROR:INVALID:MOVE");
} }
Ok(Message::Close(_)) => { }
info!("Client {} disconnected", addr); "PLAYER" => {
break; if parts.get(1) == Some(&"LIST") {
if let Err(e) = sd.handle_player_list(tx.clone()).await {
error!("handle_player_list: {}", e);
let _ = send(&tx, e.to_string().as_str());
}
} else {
let _ = send(&tx, "ERROR:INVALID:PLAYER");
} }
Ok(Message::Binary(_)) => { }
let _ = send(&tx, "ERROR:UNKNOWN"); "GAME" => {
if parts.get(1) == Some(&"LIST") {
if let Err(e) = sd.handle_game_list(tx.clone()).await {
error!("handle_game_list: {}", e);
let _ = send(&tx, e.to_string().as_str());
}
} else if parts.get(1) == Some(&"WATCH") && parts.len() > 2 {
match parts[2].parse::<u32>() {
Ok(match_id) => {
if let Err(e) = sd.handle_game_watch(tx.clone(), match_id, addr).await {
error!("handle_game_watch: {}", e);
let _ = send(&tx, e.to_string().as_str());
}
}
Err(_) => {
let _ = send(&tx, "ERROR:INVALID:WATCH");
}
}
} else if parts.get(1) == Some(&"TERMINATE") && parts.len() > 2 {
match parts[2].parse::<u32>() {
Ok(match_id) => {
if let Err(e) = sd.handle_game_terminate(addr, match_id).await {
error!("handle_game_terminate: {}", e);
let _ = send(&tx, e.to_string().as_str());
}
}
Err(_) => {
let _ = send(&tx, "ERROR:INVALID:TERMINATE");
}
}
} else if parts.get(1) == Some(&"AWARD") && parts.len() > 3 {
match parts[2].parse::<u32>() {
Ok(match_id) => {
let winner = parts[3].to_string();
if let Err(e) = sd.handle_game_award_winner(addr, match_id, winner).await {
error!("handle_game_award_winner: {}", e);
let _ = send(&tx, e.to_string().as_str());
}
}
Err(_) => {
let _ = send(&tx, "ERROR:INVALID:AWARD");
}
}
} else {
let _ = send(&tx, "ERROR:INVALID:GAME");
} }
Ok(_) => {} // Ping packets, we can ignore, they get handled for us }
Err(e) => { "ADMIN" => {
error!("WebSocket error for {}: {}", addr, e); if parts.get(1) == Some(&"AUTH") && parts.len() > 2 {
break; if let Err(e) = sd.handle_admin_auth(tx.clone(), addr, parts[2].to_string()).await {
error!("handle_admin_auth: {}", e);
let _ = send(&tx, e.to_string().as_str());
}
} else if parts.get(1) == Some(&"KICK") && parts.len() > 2 {
if let Err(e) = sd.handle_admin_kick(addr, parts[2].to_string()).await {
error!("handle_admin_kick: {}", e);
let _ = send(&tx, e.to_string().as_str());
}
} else {
let _ = send(&tx, "ERROR:INVALID:ADMIN");
} }
}
"TOURNAMENT" => {
if parts.get(1) == Some(&"START") && parts.len() > 2 {
if let Err(e) = sd.handle_tournament_start(addr, parts[2].to_string()).await {
error!("handle_tournament_start: {}", e);
let _ = send(&tx, e.to_string().as_str());
}
} else if parts.get(1) == Some(&"CANCEL") {
if let Err(e) = sd.handle_tournament_cancel(addr).await {
error!("handle_tournament_cancel: {}", e);
let _ = send(&tx, e.to_string().as_str());
}
} else {
let _ = send(&tx, "ERROR:INVALID:TOURNAMENT");
}
}
"GET" => {
if let Some(data_id) = parts.get(1) {
if let Err(e) = sd.handle_get_data(tx.clone(), data_id.to_string()).await {
error!("handle_get_data: {}", e);
let _ = send(&tx, e.to_string().as_str());
}
} else {
let _ = send(&tx, "ERROR:INVALID:GET");
}
}
"SET" => {
if parts.len() > 2 {
let data_id = parts[1].to_string();
let data_value = parts[2].to_string();
if let Err(e) = sd.handle_set_data(tx.clone(), addr, data_id, data_value).await {
error!("handle_set_data: {}", e);
let _ = send(&tx, e.to_string().as_str());
}
} else {
let _ = send(&tx, "ERROR:INVALID:SET");
}
}
"RESERVATION" => {
if parts.get(1) == Some(&"ADD") && parts.len() == 3 {
let usernames = parts[2].split(",").collect::<Vec<&str>>();
if usernames.len() != 2 {
error!("handle_reservation_add: invalid number of usernames");
let _ = send(&tx, "ERROR:INVALID:RESERVATION");
continue;
}
let player1_username = usernames[0].to_string();
let player2_username = usernames[1].to_string();
if let Err(e) = sd
.handle_reservation_add(tx.clone(), addr, player1_username, player2_username)
.await
{
error!("handle_reservation_add: {}", e);
let _ = send(&tx, e.to_string().as_str());
}
} else if parts.get(1) == Some(&"DELETE") && parts.len() == 3 {
let usernames = parts[2].split(",").collect::<Vec<&str>>();
if usernames.len() != 2 {
error!("handle_reservation_delete: invalid number of usernames");
let _ = send(&tx, "ERROR:INVALID:RESERVATION");
continue;
}
let player1_username = usernames[0].to_string();
let player2_username = usernames[1].to_string();
if let Err(e) = sd
.handle_reservation_delete(tx.clone(), addr, player1_username, player2_username)
.await
{
error!("handle_reservation_delete: {}", e);
let _ = send(&tx, e.to_string().as_str());
}
} else if parts.get(1) == Some(&"GET") {
if let Err(e) = sd.handle_reservation_get(tx.clone(), addr).await {
error!("handle_reservation_get: {}", e);
let _ = send(&tx, e.to_string().as_str());
}
} else {
let _ = send(&tx, "ERROR:INVALID:RESERVATION");
}
}
_ => {
let _ = send(&tx, "ERROR:UNKNOWN");
}
} }
}
Ok(Message::Close(_)) => {
info!("Client {} disconnected", addr);
break;
}
Ok(Message::Binary(_)) => {
let _ = send(&tx, "ERROR:UNKNOWN");
}
Ok(_) => {} // Ping packets, we can ignore, they get handled for us
Err(e) => {
error!("WebSocket error for {}: {}", addr, e);
break;
}
}
}
// Clean up
send_task.abort();
// Remove and terminate any matches
// We may not be a client disconnecting, do this check
let clients_guard = sd.clients.read().await;
if clients_guard.get(&addr).is_some() {
let client = clients_guard.get(&addr).unwrap().read().await;
let username = client.username.clone();
let tournament_guard = sd.tournament.read().await;
if client.current_match.is_some() {
sd.disconnected_clients.write().await.push(username.clone());
} else if tournament_guard.is_some() {
let tourney = tournament_guard.clone().unwrap();
if tourney.read().await.contains_player(addr) {
sd.disconnected_clients.write().await.push(username.clone());
}
} }
// Clean up drop(client);
send_task.abort(); drop(clients_guard);
// Remove and terminate any matches sd.clients.write().await.remove(&addr);
// We may not be a client disconnecting, do this check sd.usernames.write().await.remove(&username);
let clients_guard = sd.clients.read().await; }
if clients_guard.get(&addr).is_some() {
let client = clients_guard.get(&addr).unwrap().read().await;
let username = client.username.clone();
let tournament_guard = sd.tournament.read().await;
if client.current_match.is_some() {
sd.disconnected_clients.write().await.push(username.clone());
} else if tournament_guard.is_some() {
let tourney = tournament_guard.clone().unwrap();
if tourney.read().await.contains_player(addr) {
sd.disconnected_clients.write().await.push(username.clone());
}
}
drop(client); sd.observers.write().await.remove(&addr);
drop(clients_guard);
sd.clients.write().await.remove(&addr); let mut admin_guard = sd.admin.write().await;
sd.usernames.write().await.remove(&username); if let Some(admin_addr) = *admin_guard {
if admin_addr == addr {
*admin_guard = None;
} }
}
drop(admin_guard);
sd.observers.write().await.remove(&addr); info!("Client {} removed", addr);
let mut admin_guard = sd.admin.write().await; Ok(())
if let Some(admin_addr) = *admin_guard {
if admin_addr == addr {
*admin_guard = None;
}
}
drop(admin_guard);
info!("Client {} removed", addr);
Ok(())
} }

2539
src/server.rs
View File

File diff suppressed because it is too large Load Diff

22
src/tournaments/mod.rs
View File

@@ -9,15 +9,15 @@ pub use round_robin::RoundRobin;
#[async_trait] #[async_trait]
pub trait Tournament { pub trait Tournament {
fn new(ready_players: &[SocketAddr]) -> Self fn new(ready_players: &[SocketAddr]) -> Self
where where
Self: Sized; Self: Sized;
async fn next(&mut self, server: &Server); async fn next(&mut self, server: &Server);
async fn start(&mut self, server: &Server); async fn start(&mut self, server: &Server);
async fn cancel(&mut self, server: &Server); async fn cancel(&mut self, server: &Server);
fn inform_winner(&mut self, winner: SocketAddr, is_tie: bool); fn inform_winner(&mut self, winner: SocketAddr, is_tie: bool);
fn inform_reconnect(&mut self, old_addr: SocketAddr, new_addr: SocketAddr); fn inform_reconnect(&mut self, old_addr: SocketAddr, new_addr: SocketAddr);
fn contains_player(&self, addr: SocketAddr) -> bool; fn contains_player(&self, addr: SocketAddr) -> bool;
fn is_completed(&self) -> bool; fn is_completed(&self) -> bool;
fn get_type(&self) -> String; fn get_type(&self) -> String;
} }

340
src/tournaments/round_robin.rs
View File

@@ -9,217 +9,217 @@ type ID = u32;
#[derive(Clone)] #[derive(Clone)]
pub struct RoundRobin { pub struct RoundRobin {
pub players: HashMap<ID, (SocketAddr, Score)>, pub players: HashMap<ID, (SocketAddr, Score)>,
pub top_half: Vec<ID>, pub top_half: Vec<ID>,
pub bottom_half: Vec<ID>, pub bottom_half: Vec<ID>,
pub is_completed: bool, pub is_completed: bool,
} }
impl RoundRobin { impl RoundRobin {
async fn create_matches(&self, clients: &Clients, matches: &Matches) { async fn create_matches(&self, clients: &Clients, matches: &Matches) {
let clients_guard = clients.read().await; let clients_guard = clients.read().await;
for (i, id) in self.top_half.iter().enumerate() { for (i, id) in self.top_half.iter().enumerate() {
let player1_addr = self.players.get(id).unwrap(); let player1_addr = self.players.get(id).unwrap();
let player2_addr = self.players.get(self.bottom_half.get(i).unwrap()); let player2_addr = self.players.get(self.bottom_half.get(i).unwrap());
if player2_addr.is_none() { if player2_addr.is_none() {
continue; continue;
} }
let player2_addr = player2_addr.unwrap(); let player2_addr = player2_addr.unwrap();
let match_id: u32 = gen_match_id(matches).await; let match_id: u32 = gen_match_id(matches).await;
let new_match = Arc::new(RwLock::new(Match::new( let new_match = Arc::new(RwLock::new(Match::new(
match_id, match_id,
player1_addr.0, player1_addr.0,
player2_addr.0, player2_addr.0,
false, false,
))); )));
let match_guard = new_match.read().await; let match_guard = new_match.read().await;
let mut player1 = clients_guard.get(&player1_addr.0).unwrap().write().await; let mut player1 = clients_guard.get(&player1_addr.0).unwrap().write().await;
player1.current_match = Some(match_id); player1.current_match = Some(match_id);
player1.ready = false; player1.ready = false;
if match_guard.player1 == player1_addr.0 { if match_guard.player1 == player1_addr.0 {
player1.color = Color::Red; player1.color = Color::Red;
let _ = send(&player1.connection, "GAME:START:1"); let _ = send(&player1.connection, "GAME:START:1");
} else { } else {
player1.color = Color::Yellow; player1.color = Color::Yellow;
let _ = send(&player1.connection, "GAME:START:0"); let _ = send(&player1.connection, "GAME:START:0");
} }
drop(player1); drop(player1);
let mut player2 = clients_guard.get(&player2_addr.0).unwrap().write().await; let mut player2 = clients_guard.get(&player2_addr.0).unwrap().write().await;
player2.current_match = Some(match_id); player2.current_match = Some(match_id);
player2.ready = false; player2.ready = false;
if match_guard.player1 == player2_addr.0 { if match_guard.player1 == player2_addr.0 {
player2.color = Color::Red; player2.color = Color::Red;
let _ = send(&player2.connection, "GAME:START:1"); let _ = send(&player2.connection, "GAME:START:1");
} else { } else {
player2.color = Color::Yellow; player2.color = Color::Yellow;
let _ = send(&player2.connection, "GAME:START:0"); let _ = send(&player2.connection, "GAME:START:0");
} }
drop(player2); drop(player2);
matches.write().await.insert(match_id, new_match.clone()); matches.write().await.insert(match_id, new_match.clone());
}
} }
}
} }
#[async_trait] #[async_trait]
impl Tournament for RoundRobin { impl Tournament for RoundRobin {
fn new(ready_players: &[SocketAddr]) -> RoundRobin { fn new(ready_players: &[SocketAddr]) -> RoundRobin {
let mut result = RoundRobin { let mut result = RoundRobin {
players: HashMap::new(), players: HashMap::new(),
top_half: Vec::new(), top_half: Vec::new(),
bottom_half: Vec::new(), bottom_half: Vec::new(),
is_completed: false, is_completed: false,
}; };
let size = ready_players.len(); let size = ready_players.len();
for (id, player) in ready_players.iter().enumerate() { for (id, player) in ready_players.iter().enumerate() {
result.players.insert(id as u32, (*player, 0)); result.players.insert(id as u32, (*player, 0));
}
for i in 0..size / 2 {
result.top_half.push(i as u32);
}
for i in size / 2..size {
result.bottom_half.push(i as u32);
}
result
} }
fn inform_winner(&mut self, winner: SocketAddr, is_tie: bool) { for i in 0..size / 2 {
if is_tie { result.top_half.push(i as u32);
return;
}
for (_, player_addr) in self.players.iter_mut() {
if player_addr.0 == winner {
player_addr.1 += 1;
break;
}
}
} }
fn inform_reconnect(&mut self, old_addr: SocketAddr, new_addr: SocketAddr) { for i in size / 2..size {
for (_, (player_addr, _)) in self.players.iter_mut() { result.bottom_half.push(i as u32);
if *player_addr == old_addr {
*player_addr = new_addr;
break;
}
}
} }
fn contains_player(&self, addr: SocketAddr) -> bool { result
for (_, (player_addr, _)) in self.players.iter() { }
if *player_addr == addr {
return true; fn inform_winner(&mut self, winner: SocketAddr, is_tie: bool) {
} if is_tie {
} return;
false
} }
async fn next(&mut self, server: &Server) { for (_, player_addr) in self.players.iter_mut() {
if self.is_completed { if player_addr.0 == winner {
return; player_addr.1 += 1;
} break;
}
}
}
if self.top_half.len() <= 1 || self.bottom_half.is_empty() { fn inform_reconnect(&mut self, old_addr: SocketAddr, new_addr: SocketAddr) {
self.is_completed = true; for (_, (player_addr, _)) in self.players.iter_mut() {
return; if *player_addr == old_addr {
} *player_addr = new_addr;
break;
}
}
}
let last_from_top = self.top_half.pop().unwrap(); fn contains_player(&self, addr: SocketAddr) -> bool {
let first_from_bottom = self.bottom_half.remove(0); for (_, (player_addr, _)) in self.players.iter() {
if *player_addr == addr {
return true;
}
}
false
}
self.top_half.insert(1, first_from_bottom); async fn next(&mut self, server: &Server) {
self.bottom_half.push(last_from_top); if self.is_completed {
return;
let expected_bottom_start = self.top_half.len() as u32;
if self.top_half[1] == 1 && self.bottom_half[0] == expected_bottom_start {
self.is_completed = true;
}
let clients_guard = server.clients.read().await;
let mut player_scores: Vec<(String, u32)> = Vec::new();
for (_, player_addr) in self.players.iter() {
let player = clients_guard.get(&player_addr.0).unwrap().read().await;
let _ = send(&player.connection.clone(), "TOURNAMENT:END");
player_scores.push((player.username.clone(), player_addr.1));
}
drop(clients_guard);
player_scores.sort_by(|a, b| b.1.cmp(&a.1));
let mut message = "TOURNAMENT:SCORES:".to_string();
for (player, score) in player_scores.iter() {
message.push_str(&format!("{},{}|", player, score))
}
message.pop();
server.broadcast_message_all_observers(&message).await;
if self.is_completed() {
// Send scores
let clients_guard = server.clients.read().await;
for (_, player_addr) in self.players.iter() {
let player = clients_guard.get(&player_addr.0).unwrap().read().await;
let _ = send(&player.connection.clone(), "TOURNAMENT:END");
}
} else {
// Create next matches
self.create_matches(&server.clients, &server.matches).await;
}
} }
async fn start(&mut self, server: &Server) { if self.top_half.len() <= 1 || self.bottom_half.is_empty() {
self.create_matches(&server.clients, &server.matches).await; self.is_completed = true;
return;
} }
async fn cancel(&mut self, server: &Server) { let last_from_top = self.top_half.pop().unwrap();
for (_, addr) in self.players.iter() { let first_from_bottom = self.bottom_half.remove(0);
let clients_guard = server.clients.read().await;
let client = clients_guard.get(&addr.0); self.top_half.insert(1, first_from_bottom);
if client.is_none() { self.bottom_half.push(last_from_top);
continue;
}
let client = client.unwrap().read().await;
let client_connection = client.connection.clone();
let client_ready = client.ready;
let match_id = client.current_match; let expected_bottom_start = self.top_half.len() as u32;
if match_id.is_none() { if self.top_half[1] == 1 && self.bottom_half[0] == expected_bottom_start {
continue; self.is_completed = true;
}
let match_id = match_id.unwrap();
drop(client);
drop(clients_guard);
server.terminate_match(match_id).await;
if !client_ready {
let _ = send(&client_connection, "TOURNAMENT:END");
}
}
} }
fn is_completed(&self) -> bool { let clients_guard = server.clients.read().await;
self.is_completed let mut player_scores: Vec<(String, u32)> = Vec::new();
for (_, player_addr) in self.players.iter() {
let player = clients_guard.get(&player_addr.0).unwrap().read().await;
let _ = send(&player.connection.clone(), "TOURNAMENT:END");
player_scores.push((player.username.clone(), player_addr.1));
} }
drop(clients_guard);
fn get_type(&self) -> String { player_scores.sort_by(|a, b| b.1.cmp(&a.1));
"RoundRobin".to_string()
let mut message = "TOURNAMENT:SCORES:".to_string();
for (player, score) in player_scores.iter() {
message.push_str(&format!("{},{}|", player, score))
} }
message.pop();
server.broadcast_message_all_observers(&message).await;
if self.is_completed() {
// Send scores
let clients_guard = server.clients.read().await;
for (_, player_addr) in self.players.iter() {
let player = clients_guard.get(&player_addr.0).unwrap().read().await;
let _ = send(&player.connection.clone(), "TOURNAMENT:END");
}
} else {
// Create next matches
self.create_matches(&server.clients, &server.matches).await;
}
}
async fn start(&mut self, server: &Server) {
self.create_matches(&server.clients, &server.matches).await;
}
async fn cancel(&mut self, server: &Server) {
for (_, addr) in self.players.iter() {
let clients_guard = server.clients.read().await;
let client = clients_guard.get(&addr.0);
if client.is_none() {
continue;
}
let client = client.unwrap().read().await;
let client_connection = client.connection.clone();
let client_ready = client.ready;
let match_id = client.current_match;
if match_id.is_none() {
continue;
}
let match_id = match_id.unwrap();
drop(client);
drop(clients_guard);
server.terminate_match(match_id).await;
if !client_ready {
let _ = send(&client_connection, "TOURNAMENT:END");
}
}
}
fn is_completed(&self) -> bool {
self.is_completed
}
fn get_type(&self) -> String {
"RoundRobin".to_string()
}
} }

235
src/types.rs
View File

@@ -7,152 +7,149 @@ use tokio_tungstenite::tungstenite::Message;
#[derive(PartialEq, Clone, Copy)] #[derive(PartialEq, Clone, Copy)]
pub enum Color { pub enum Color {
Red, Red,
Yellow, Yellow,
None, None,
} }
impl ops::Not for Color { impl ops::Not for Color {
type Output = Color; type Output = Color;
fn not(self) -> Color { fn not(self) -> Color {
match self { match self {
Color::Red => Color::Yellow, Color::Red => Color::Yellow,
Color::Yellow => Color::Red, Color::Yellow => Color::Red,
Color::None => Color::None, Color::None => Color::None,
}
} }
}
} }
impl From<Color> for bool { impl From<Color> for bool {
fn from(color: Color) -> bool { fn from(color: Color) -> bool {
match color { match color {
Color::Red => true, Color::Red => true,
Color::Yellow => false, Color::Yellow => false,
Color::None => panic!("Cannot convert Color::None to bool"), Color::None => panic!("Cannot convert Color::None to bool"),
}
} }
}
} }
#[derive(Clone)] #[derive(Clone)]
pub struct Client { pub struct Client {
pub username: String, pub username: String,
pub connection: UnboundedSender<Message>, pub connection: UnboundedSender<Message>,
pub ready: bool, pub ready: bool,
pub color: Color, pub color: Color,
pub current_match: Option<u32>, pub current_match: Option<u32>,
pub addr: SocketAddr, pub addr: SocketAddr,
} }
impl Client { impl Client {
pub fn new(username: String, connection: UnboundedSender<Message>, addr: SocketAddr) -> Client { pub fn new(username: String, connection: UnboundedSender<Message>, addr: SocketAddr) -> Client {
Client { Client {
username, username,
connection, connection,
ready: false, ready: false,
color: Color::None, color: Color::None,
current_match: None, current_match: None,
addr, addr,
}
} }
}
} }
pub struct Match { pub struct Match {
pub id: u32, pub id: u32,
pub demo_mode: bool, pub demo_mode: bool,
pub board: Vec<Vec<Color>>, pub board: Vec<Vec<Color>>,
pub viewers: Vec<SocketAddr>, pub viewers: Vec<SocketAddr>,
pub ledger: Vec<(Color, usize, Instant)>, pub ledger: Vec<(Color, usize, Instant)>,
pub wait_thread: Option<tokio::task::JoinHandle<()>>, pub wait_thread: Option<tokio::task::JoinHandle<()>>,
pub timeout_thread: Option<tokio::task::JoinHandle<()>>, pub timeout_thread: Option<tokio::task::JoinHandle<()>>,
pub player1: SocketAddr, pub player1: SocketAddr,
pub player2: SocketAddr, pub player2: SocketAddr,
} }
impl Match { impl Match {
pub fn new(id: u32, player1: SocketAddr, player2: SocketAddr, demo_mode: bool) -> Match { pub fn new(id: u32, player1: SocketAddr, player2: SocketAddr, demo_mode: bool) -> Match {
let first = if rand::rng().random_range(0..=1) == 0 { let first = if rand::rng().random_range(0..=1) == 0 {
player1.to_string().parse().unwrap() player1.to_string().parse().unwrap()
} else { } else {
player2.to_string().parse().unwrap() player2.to_string().parse().unwrap()
}; };
Match { Match {
id, id,
demo_mode, demo_mode,
board: vec![vec![Color::None; 6]; 7], board: vec![vec![Color::None; 6]; 7],
viewers: Vec::new(), viewers: Vec::new(),
ledger: Vec::new(), ledger: Vec::new(),
wait_thread: None, wait_thread: None,
timeout_thread: None, timeout_thread: None,
player1: if player1 == first { player1 } else { player2 }, player1: if player1 == first { player1 } else { player2 },
player2: if player1 == first { player2 } else { player1 }, player2: if player1 == first { player2 } else { player1 },
}
}
pub fn place_token(&mut self, color: Color, column: usize) {
for i in 0..6 {
if self.board[column][i] == Color::None {
self.board[column][i] = color;
break;
}
}
}
pub fn end_game_check(&self) -> (Color, bool) {
let mut result = (Color::None, false);
let mut any_empty = true;
for x in 0..7 {
for y in 0..6 {
let color = self.board[x][y].clone();
let mut horizontal_end = true;
let mut vertical_end = true;
let mut diagonal_end_up = true;
let mut diagonal_end_down = true;
if any_empty && color == Color::None {
any_empty = false;
} }
for i in 0..4 {
if x + i >= 7 || self.board[x + i][y] != color && horizontal_end {
horizontal_end = false;
}
if y + i >= 6 || self.board[x][y + i] != color && vertical_end {
vertical_end = false;
}
if x + i >= 7 || y + i >= 6 || self.board[x + i][y + i] != color && diagonal_end_up {
diagonal_end_up = false;
}
if x + i >= 7
|| (y as i32 - i as i32) < 0
|| self.board[x + i][y - i] != color && diagonal_end_down
{
diagonal_end_down = false;
}
}
if horizontal_end || vertical_end || diagonal_end_up || diagonal_end_down {
result = (color.clone(), false);
break;
}
}
if result.0 != Color::None {
break;
}
} }
pub fn place_token(&mut self, color: Color, column: usize) { if any_empty && result.0 == Color::None {
for i in 0..6 { result.1 = true;
if self.board[column][i] == Color::None {
self.board[column][i] = color;
break;
}
}
} }
pub fn end_game_check(&self) -> (Color, bool) { result
let mut result = (Color::None, false); }
let mut any_empty = true;
for x in 0..7 {
for y in 0..6 {
let color = self.board[x][y].clone();
let mut horizontal_end = true;
let mut vertical_end = true;
let mut diagonal_end_up = true;
let mut diagonal_end_down = true;
if any_empty && color == Color::None {
any_empty = false;
}
for i in 0..4 {
if x + i >= 7 || self.board[x + i][y] != color && horizontal_end {
horizontal_end = false;
}
if y + i >= 6 || self.board[x][y + i] != color && vertical_end {
vertical_end = false;
}
if x + i >= 7
|| y + i >= 6
|| self.board[x + i][y + i] != color && diagonal_end_up
{
diagonal_end_up = false;
}
if x + i >= 7
|| (y as i32 - i as i32) < 0
|| self.board[x + i][y - i] != color && diagonal_end_down
{
diagonal_end_down = false;
}
}
if horizontal_end || vertical_end || diagonal_end_up || diagonal_end_down {
result = (color.clone(), false);
break;
}
}
if result.0 != Color::None {
break;
}
}
if any_empty && result.0 == Color::None {
result.1 = true;
}
result
}
} }