misc: formatting and compile fix
This commit is contained in:
46
src/lib.rs
46
src/lib.rs
@@ -2,15 +2,15 @@ use std::{collections::HashMap, net::SocketAddr, sync::Arc};
|
||||
|
||||
use rand::RngExt;
|
||||
use tokio::sync::{
|
||||
mpsc::{error::SendError, UnboundedSender},
|
||||
RwLock,
|
||||
mpsc::{error::SendError, UnboundedSender},
|
||||
RwLock,
|
||||
};
|
||||
use tokio_tungstenite::tungstenite::Message;
|
||||
use tracing::error;
|
||||
|
||||
use crate::{
|
||||
tournaments::Tournament,
|
||||
types::{Client, Color, Match},
|
||||
tournaments::Tournament,
|
||||
types::{Client, Color, Match},
|
||||
};
|
||||
|
||||
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 async fn broadcast_message(observers: &Observers, addrs: &Vec<SocketAddr>, 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);
|
||||
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);
|
||||
}
|
||||
}
|
||||
|
||||
pub async fn gen_match_id(matches: &Matches) -> u32 {
|
||||
let matches_guard = matches.read().await;
|
||||
let mut result = rand::rng().random_range(100000..=999999);
|
||||
while matches_guard.get(&result).is_some() {
|
||||
result = rand::rng().random_range(100000..=999999);
|
||||
}
|
||||
result
|
||||
let matches_guard = matches.read().await;
|
||||
let mut result = rand::rng().random_range(100000..=999999);
|
||||
while matches_guard.get(&result).is_some() {
|
||||
result = rand::rng().random_range(100000..=999999);
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
pub fn random_move(board: &[Vec<Color>]) -> usize {
|
||||
let mut random = rand::rng().random_range(0..7);
|
||||
while board[random][5] != Color::None {
|
||||
random = rand::rng().random_range(0..7);
|
||||
}
|
||||
let mut random = rand::rng().random_range(0..7);
|
||||
while board[random][5] != Color::None {
|
||||
random = rand::rng().random_range(0..7);
|
||||
}
|
||||
|
||||
random
|
||||
random
|
||||
}
|
||||
|
||||
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
608
src/main.rs
@@ -10,340 +10,330 @@ use tracing::{error, info};
|
||||
|
||||
#[tokio::main]
|
||||
async fn main() -> Result<(), anyhow::Error> {
|
||||
// Initialize logging
|
||||
tracing_subscriber::fmt::init();
|
||||
// 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";
|
||||
if demo_mode {
|
||||
info!("Starting server in DEMO MODE");
|
||||
}
|
||||
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 args: Vec<String> = env::args().collect();
|
||||
let demo_mode = args.get(1).is_some() && args.get(1).unwrap() == "demo";
|
||||
if demo_mode {
|
||||
info!("Starting server in DEMO MODE");
|
||||
}
|
||||
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?;
|
||||
let hosted_addr = if local_ip().is_ok() {
|
||||
local_ip()?.to_string() + ":8080"
|
||||
} else {
|
||||
addr.to_string()
|
||||
};
|
||||
info!("WebSocket server listening on: {}", hosted_addr);
|
||||
let addr = "0.0.0.0:8080";
|
||||
let listener = TcpListener::bind(&addr).await?;
|
||||
let hosted_addr = if local_ip().is_ok() {
|
||||
local_ip()?.to_string() + ":8080"
|
||||
} else {
|
||||
addr.to_string()
|
||||
};
|
||||
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 {
|
||||
tokio::spawn(handle_connection(stream, addr, server_data.clone()));
|
||||
}
|
||||
while let Ok((stream, addr)) = listener.accept().await {
|
||||
tokio::spawn(handle_connection(stream, addr, server_data.clone()));
|
||||
}
|
||||
|
||||
Ok(())
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn handle_connection(
|
||||
stream: TcpStream,
|
||||
addr: SocketAddr,
|
||||
sd: Arc<Server>,
|
||||
stream: TcpStream,
|
||||
addr: SocketAddr,
|
||||
sd: Arc<Server>,
|
||||
) -> Result<(), anyhow::Error> {
|
||||
info!("New WebSocket connection from: {}", addr);
|
||||
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();
|
||||
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
|
||||
sd.observers.write().await.insert(addr, tx.clone());
|
||||
// Store the client
|
||||
sd.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;
|
||||
// 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);
|
||||
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:");
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
// 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 {
|
||||
let requested_username = parts[1].to_string();
|
||||
if let Err(e) =
|
||||
sd.handle_reconnect_cmd(addr, tx.clone(), requested_username).await
|
||||
{
|
||||
error!("handle_reconnect: {}", e);
|
||||
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");
|
||||
}
|
||||
}
|
||||
"RECONNECT" => {
|
||||
if parts.len() > 1 {
|
||||
let requested_username = parts[1].to_string();
|
||||
if let Err(e) = sd.handle_reconnect_cmd(addr, tx.clone(), requested_username).await {
|
||||
error!("handle_reconnect: {}", e);
|
||||
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");
|
||||
}
|
||||
Ok(Message::Close(_)) => {
|
||||
info!("Client {} disconnected", addr);
|
||||
break;
|
||||
}
|
||||
"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");
|
||||
}
|
||||
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) => {
|
||||
error!("WebSocket error for {}: {}", addr, e);
|
||||
break;
|
||||
}
|
||||
"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");
|
||||
}
|
||||
}
|
||||
}
|
||||
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
|
||||
send_task.abort();
|
||||
drop(client);
|
||||
drop(clients_guard);
|
||||
|
||||
// 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());
|
||||
}
|
||||
}
|
||||
sd.clients.write().await.remove(&addr);
|
||||
sd.usernames.write().await.remove(&username);
|
||||
}
|
||||
|
||||
drop(client);
|
||||
drop(clients_guard);
|
||||
sd.observers.write().await.remove(&addr);
|
||||
|
||||
sd.clients.write().await.remove(&addr);
|
||||
sd.usernames.write().await.remove(&username);
|
||||
let mut admin_guard = sd.admin.write().await;
|
||||
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;
|
||||
if let Some(admin_addr) = *admin_guard {
|
||||
if admin_addr == addr {
|
||||
*admin_guard = None;
|
||||
}
|
||||
}
|
||||
drop(admin_guard);
|
||||
|
||||
info!("Client {} removed", addr);
|
||||
|
||||
Ok(())
|
||||
Ok(())
|
||||
}
|
||||
|
||||
2539
src/server.rs
2539
src/server.rs
File diff suppressed because it is too large
Load Diff
@@ -9,15 +9,15 @@ pub use round_robin::RoundRobin;
|
||||
|
||||
#[async_trait]
|
||||
pub trait Tournament {
|
||||
fn new(ready_players: &[SocketAddr]) -> Self
|
||||
where
|
||||
Self: Sized;
|
||||
async fn next(&mut self, server: &Server);
|
||||
async fn start(&mut self, server: &Server);
|
||||
async fn cancel(&mut self, server: &Server);
|
||||
fn inform_winner(&mut self, winner: SocketAddr, is_tie: bool);
|
||||
fn inform_reconnect(&mut self, old_addr: SocketAddr, new_addr: SocketAddr);
|
||||
fn contains_player(&self, addr: SocketAddr) -> bool;
|
||||
fn is_completed(&self) -> bool;
|
||||
fn get_type(&self) -> String;
|
||||
fn new(ready_players: &[SocketAddr]) -> Self
|
||||
where
|
||||
Self: Sized;
|
||||
async fn next(&mut self, server: &Server);
|
||||
async fn start(&mut self, server: &Server);
|
||||
async fn cancel(&mut self, server: &Server);
|
||||
fn inform_winner(&mut self, winner: SocketAddr, is_tie: bool);
|
||||
fn inform_reconnect(&mut self, old_addr: SocketAddr, new_addr: SocketAddr);
|
||||
fn contains_player(&self, addr: SocketAddr) -> bool;
|
||||
fn is_completed(&self) -> bool;
|
||||
fn get_type(&self) -> String;
|
||||
}
|
||||
|
||||
@@ -9,217 +9,217 @@ type ID = u32;
|
||||
|
||||
#[derive(Clone)]
|
||||
pub struct RoundRobin {
|
||||
pub players: HashMap<ID, (SocketAddr, Score)>,
|
||||
pub top_half: Vec<ID>,
|
||||
pub bottom_half: Vec<ID>,
|
||||
pub is_completed: bool,
|
||||
pub players: HashMap<ID, (SocketAddr, Score)>,
|
||||
pub top_half: Vec<ID>,
|
||||
pub bottom_half: Vec<ID>,
|
||||
pub is_completed: bool,
|
||||
}
|
||||
|
||||
impl RoundRobin {
|
||||
async fn create_matches(&self, clients: &Clients, matches: &Matches) {
|
||||
let clients_guard = clients.read().await;
|
||||
for (i, id) in self.top_half.iter().enumerate() {
|
||||
let player1_addr = self.players.get(id).unwrap();
|
||||
let player2_addr = self.players.get(self.bottom_half.get(i).unwrap());
|
||||
async fn create_matches(&self, clients: &Clients, matches: &Matches) {
|
||||
let clients_guard = clients.read().await;
|
||||
for (i, id) in self.top_half.iter().enumerate() {
|
||||
let player1_addr = self.players.get(id).unwrap();
|
||||
let player2_addr = self.players.get(self.bottom_half.get(i).unwrap());
|
||||
|
||||
if player2_addr.is_none() {
|
||||
continue;
|
||||
}
|
||||
let player2_addr = player2_addr.unwrap();
|
||||
if player2_addr.is_none() {
|
||||
continue;
|
||||
}
|
||||
let player2_addr = player2_addr.unwrap();
|
||||
|
||||
let match_id: u32 = gen_match_id(matches).await;
|
||||
let new_match = Arc::new(RwLock::new(Match::new(
|
||||
match_id,
|
||||
player1_addr.0,
|
||||
player2_addr.0,
|
||||
false,
|
||||
)));
|
||||
let match_id: u32 = gen_match_id(matches).await;
|
||||
let new_match = Arc::new(RwLock::new(Match::new(
|
||||
match_id,
|
||||
player1_addr.0,
|
||||
player2_addr.0,
|
||||
false,
|
||||
)));
|
||||
|
||||
let match_guard = new_match.read().await;
|
||||
let mut player1 = clients_guard.get(&player1_addr.0).unwrap().write().await;
|
||||
let match_guard = new_match.read().await;
|
||||
let mut player1 = clients_guard.get(&player1_addr.0).unwrap().write().await;
|
||||
|
||||
player1.current_match = Some(match_id);
|
||||
player1.ready = false;
|
||||
player1.current_match = Some(match_id);
|
||||
player1.ready = false;
|
||||
|
||||
if match_guard.player1 == player1_addr.0 {
|
||||
player1.color = Color::Red;
|
||||
let _ = send(&player1.connection, "GAME:START:1");
|
||||
} else {
|
||||
player1.color = Color::Yellow;
|
||||
let _ = send(&player1.connection, "GAME:START:0");
|
||||
}
|
||||
if match_guard.player1 == player1_addr.0 {
|
||||
player1.color = Color::Red;
|
||||
let _ = send(&player1.connection, "GAME:START:1");
|
||||
} else {
|
||||
player1.color = Color::Yellow;
|
||||
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.ready = false;
|
||||
player2.current_match = Some(match_id);
|
||||
player2.ready = false;
|
||||
|
||||
if match_guard.player1 == player2_addr.0 {
|
||||
player2.color = Color::Red;
|
||||
let _ = send(&player2.connection, "GAME:START:1");
|
||||
} else {
|
||||
player2.color = Color::Yellow;
|
||||
let _ = send(&player2.connection, "GAME:START:0");
|
||||
}
|
||||
if match_guard.player1 == player2_addr.0 {
|
||||
player2.color = Color::Red;
|
||||
let _ = send(&player2.connection, "GAME:START:1");
|
||||
} else {
|
||||
player2.color = Color::Yellow;
|
||||
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]
|
||||
impl Tournament for RoundRobin {
|
||||
fn new(ready_players: &[SocketAddr]) -> RoundRobin {
|
||||
let mut result = RoundRobin {
|
||||
players: HashMap::new(),
|
||||
top_half: Vec::new(),
|
||||
bottom_half: Vec::new(),
|
||||
is_completed: false,
|
||||
};
|
||||
fn new(ready_players: &[SocketAddr]) -> RoundRobin {
|
||||
let mut result = RoundRobin {
|
||||
players: HashMap::new(),
|
||||
top_half: Vec::new(),
|
||||
bottom_half: Vec::new(),
|
||||
is_completed: false,
|
||||
};
|
||||
|
||||
let size = ready_players.len();
|
||||
let size = ready_players.len();
|
||||
|
||||
for (id, player) in ready_players.iter().enumerate() {
|
||||
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
|
||||
for (id, player) in ready_players.iter().enumerate() {
|
||||
result.players.insert(id as u32, (*player, 0));
|
||||
}
|
||||
|
||||
fn inform_winner(&mut self, winner: SocketAddr, is_tie: bool) {
|
||||
if is_tie {
|
||||
return;
|
||||
}
|
||||
|
||||
for (_, player_addr) in self.players.iter_mut() {
|
||||
if player_addr.0 == winner {
|
||||
player_addr.1 += 1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
for i in 0..size / 2 {
|
||||
result.top_half.push(i as u32);
|
||||
}
|
||||
|
||||
fn inform_reconnect(&mut self, old_addr: SocketAddr, new_addr: SocketAddr) {
|
||||
for (_, (player_addr, _)) in self.players.iter_mut() {
|
||||
if *player_addr == old_addr {
|
||||
*player_addr = new_addr;
|
||||
break;
|
||||
}
|
||||
}
|
||||
for i in size / 2..size {
|
||||
result.bottom_half.push(i as u32);
|
||||
}
|
||||
|
||||
fn contains_player(&self, addr: SocketAddr) -> bool {
|
||||
for (_, (player_addr, _)) in self.players.iter() {
|
||||
if *player_addr == addr {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
false
|
||||
result
|
||||
}
|
||||
|
||||
fn inform_winner(&mut self, winner: SocketAddr, is_tie: bool) {
|
||||
if is_tie {
|
||||
return;
|
||||
}
|
||||
|
||||
async fn next(&mut self, server: &Server) {
|
||||
if self.is_completed {
|
||||
return;
|
||||
}
|
||||
for (_, player_addr) in self.players.iter_mut() {
|
||||
if player_addr.0 == winner {
|
||||
player_addr.1 += 1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if self.top_half.len() <= 1 || self.bottom_half.is_empty() {
|
||||
self.is_completed = true;
|
||||
return;
|
||||
}
|
||||
fn inform_reconnect(&mut self, old_addr: SocketAddr, new_addr: SocketAddr) {
|
||||
for (_, (player_addr, _)) in self.players.iter_mut() {
|
||||
if *player_addr == old_addr {
|
||||
*player_addr = new_addr;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
let last_from_top = self.top_half.pop().unwrap();
|
||||
let first_from_bottom = self.bottom_half.remove(0);
|
||||
fn contains_player(&self, addr: SocketAddr) -> bool {
|
||||
for (_, (player_addr, _)) in self.players.iter() {
|
||||
if *player_addr == addr {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
false
|
||||
}
|
||||
|
||||
self.top_half.insert(1, first_from_bottom);
|
||||
self.bottom_half.push(last_from_top);
|
||||
|
||||
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 next(&mut self, server: &Server) {
|
||||
if self.is_completed {
|
||||
return;
|
||||
}
|
||||
|
||||
async fn start(&mut self, server: &Server) {
|
||||
self.create_matches(&server.clients, &server.matches).await;
|
||||
if self.top_half.len() <= 1 || self.bottom_half.is_empty() {
|
||||
self.is_completed = true;
|
||||
return;
|
||||
}
|
||||
|
||||
async fn cancel(&mut self, server: &Server) {
|
||||
for (_, addr) in self.players.iter() {
|
||||
let clients_guard = server.clients.read().await;
|
||||
let last_from_top = self.top_half.pop().unwrap();
|
||||
let first_from_bottom = self.bottom_half.remove(0);
|
||||
|
||||
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;
|
||||
self.top_half.insert(1, first_from_bottom);
|
||||
self.bottom_half.push(last_from_top);
|
||||
|
||||
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");
|
||||
}
|
||||
}
|
||||
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;
|
||||
}
|
||||
|
||||
fn is_completed(&self) -> bool {
|
||||
self.is_completed
|
||||
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);
|
||||
|
||||
fn get_type(&self) -> String {
|
||||
"RoundRobin".to_string()
|
||||
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) {
|
||||
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
235
src/types.rs
@@ -7,152 +7,149 @@ use tokio_tungstenite::tungstenite::Message;
|
||||
|
||||
#[derive(PartialEq, Clone, Copy)]
|
||||
pub enum Color {
|
||||
Red,
|
||||
Yellow,
|
||||
None,
|
||||
Red,
|
||||
Yellow,
|
||||
None,
|
||||
}
|
||||
|
||||
impl ops::Not for Color {
|
||||
type Output = Color;
|
||||
type Output = Color;
|
||||
|
||||
fn not(self) -> Color {
|
||||
match self {
|
||||
Color::Red => Color::Yellow,
|
||||
Color::Yellow => Color::Red,
|
||||
Color::None => Color::None,
|
||||
}
|
||||
fn not(self) -> Color {
|
||||
match self {
|
||||
Color::Red => Color::Yellow,
|
||||
Color::Yellow => Color::Red,
|
||||
Color::None => Color::None,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl From<Color> for bool {
|
||||
fn from(color: Color) -> bool {
|
||||
match color {
|
||||
Color::Red => true,
|
||||
Color::Yellow => false,
|
||||
Color::None => panic!("Cannot convert Color::None to bool"),
|
||||
}
|
||||
fn from(color: Color) -> bool {
|
||||
match color {
|
||||
Color::Red => true,
|
||||
Color::Yellow => false,
|
||||
Color::None => panic!("Cannot convert Color::None to bool"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone)]
|
||||
pub struct Client {
|
||||
pub username: String,
|
||||
pub connection: UnboundedSender<Message>,
|
||||
pub ready: bool,
|
||||
pub color: Color,
|
||||
pub current_match: Option<u32>,
|
||||
pub addr: SocketAddr,
|
||||
pub username: String,
|
||||
pub connection: UnboundedSender<Message>,
|
||||
pub ready: bool,
|
||||
pub color: Color,
|
||||
pub current_match: Option<u32>,
|
||||
pub addr: SocketAddr,
|
||||
}
|
||||
|
||||
impl Client {
|
||||
pub fn new(username: String, connection: UnboundedSender<Message>, addr: SocketAddr) -> Client {
|
||||
Client {
|
||||
username,
|
||||
connection,
|
||||
ready: false,
|
||||
color: Color::None,
|
||||
current_match: None,
|
||||
addr,
|
||||
}
|
||||
pub fn new(username: String, connection: UnboundedSender<Message>, addr: SocketAddr) -> Client {
|
||||
Client {
|
||||
username,
|
||||
connection,
|
||||
ready: false,
|
||||
color: Color::None,
|
||||
current_match: None,
|
||||
addr,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub struct Match {
|
||||
pub id: u32,
|
||||
pub demo_mode: bool,
|
||||
pub board: Vec<Vec<Color>>,
|
||||
pub viewers: Vec<SocketAddr>,
|
||||
pub ledger: Vec<(Color, usize, Instant)>,
|
||||
pub wait_thread: Option<tokio::task::JoinHandle<()>>,
|
||||
pub timeout_thread: Option<tokio::task::JoinHandle<()>>,
|
||||
pub player1: SocketAddr,
|
||||
pub player2: SocketAddr,
|
||||
pub id: u32,
|
||||
pub demo_mode: bool,
|
||||
pub board: Vec<Vec<Color>>,
|
||||
pub viewers: Vec<SocketAddr>,
|
||||
pub ledger: Vec<(Color, usize, Instant)>,
|
||||
pub wait_thread: Option<tokio::task::JoinHandle<()>>,
|
||||
pub timeout_thread: Option<tokio::task::JoinHandle<()>>,
|
||||
pub player1: SocketAddr,
|
||||
pub player2: SocketAddr,
|
||||
}
|
||||
|
||||
impl Match {
|
||||
pub fn new(id: u32, player1: SocketAddr, player2: SocketAddr, demo_mode: bool) -> Match {
|
||||
let first = if rand::rng().random_range(0..=1) == 0 {
|
||||
player1.to_string().parse().unwrap()
|
||||
} else {
|
||||
player2.to_string().parse().unwrap()
|
||||
};
|
||||
pub fn new(id: u32, player1: SocketAddr, player2: SocketAddr, demo_mode: bool) -> Match {
|
||||
let first = if rand::rng().random_range(0..=1) == 0 {
|
||||
player1.to_string().parse().unwrap()
|
||||
} else {
|
||||
player2.to_string().parse().unwrap()
|
||||
};
|
||||
|
||||
Match {
|
||||
id,
|
||||
demo_mode,
|
||||
board: vec![vec![Color::None; 6]; 7],
|
||||
viewers: Vec::new(),
|
||||
ledger: Vec::new(),
|
||||
wait_thread: None,
|
||||
timeout_thread: None,
|
||||
player1: if player1 == first { player1 } else { player2 },
|
||||
player2: if player1 == first { player2 } else { player1 },
|
||||
Match {
|
||||
id,
|
||||
demo_mode,
|
||||
board: vec![vec![Color::None; 6]; 7],
|
||||
viewers: Vec::new(),
|
||||
ledger: Vec::new(),
|
||||
wait_thread: None,
|
||||
timeout_thread: None,
|
||||
player1: if player1 == first { player1 } else { player2 },
|
||||
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) {
|
||||
for i in 0..6 {
|
||||
if self.board[column][i] == Color::None {
|
||||
self.board[column][i] = color;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if any_empty && result.0 == Color::None {
|
||||
result.1 = true;
|
||||
}
|
||||
|
||||
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;
|
||||
}
|
||||
}
|
||||
|
||||
if any_empty && result.0 == Color::None {
|
||||
result.1 = true;
|
||||
}
|
||||
|
||||
result
|
||||
}
|
||||
result
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user