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

misc: rustfmt

Browse Source
This commit is contained in:
Joshua Higgins
2025-11-18 14:33:42 -05:00
Unverified
parent 22ffb96271
commit be7aabbe5f
4 changed files with 358 additions and 311 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
.rustfmt.toml Normal file
View File

@@ -0,0 +1,2 @@
combine_control_expr = false
chain_width = 100

550
src/main.rs
View File

@@ -1,12 +1,13 @@
mod types;
mod random_ai; mod random_ai;
mod types;
use crate::random_ai::random_move;
use crate::types::{Color, Match}; use crate::types::{Color, Match};
use futures_util::{SinkExt, StreamExt}; use futures_util::{SinkExt, StreamExt};
use rand::Rng;
use std::collections::HashMap; use std::collections::HashMap;
use std::net::SocketAddr; use std::net::SocketAddr;
use std::sync::Arc; use std::sync::Arc;
use rand::Rng;
use tokio::net::{TcpListener, TcpStream}; use tokio::net::{TcpListener, TcpStream};
use tokio::sync::mpsc::error::SendError; use tokio::sync::mpsc::error::SendError;
use tokio::sync::mpsc::UnboundedSender; use tokio::sync::mpsc::UnboundedSender;
@@ -14,39 +15,37 @@ use tokio::sync::RwLock;
use tokio_tungstenite::{accept_async, tungstenite::Message}; use tokio_tungstenite::{accept_async, tungstenite::Message};
use tracing::{error, info, warn}; use tracing::{error, info, warn};
use types::Client; use types::Client;
use crate::random_ai::random_move;
type Clients = Arc<RwLock<HashMap<SocketAddr, Arc<RwLock<Client>>>>>; type Clients = Arc<RwLock<HashMap<SocketAddr, Arc<RwLock<Client>>>>>;
type Observers = Arc<RwLock<HashMap<SocketAddr, UnboundedSender<Message>>>>; type Observers = Arc<RwLock<HashMap<SocketAddr, UnboundedSender<Message>>>>;
type Matches = Arc<RwLock<HashMap<u32, Arc<RwLock<Match>>>>>; type Matches = Arc<RwLock<HashMap<u32, Arc<RwLock<Match>>>>>;
#[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> = std::env::args().collect(); let args: Vec<String> = std::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";
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?;
info!("WebSocket server listening on: {}", addr); info!("WebSocket server listening on: {}", addr);
let clients: Clients = Arc::new(RwLock::new(HashMap::new())); let clients: Clients = Arc::new(RwLock::new(HashMap::new()));
let observers: Observers = 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 matches: Matches = Arc::new(RwLock::new(HashMap::new()));
let admin: Arc<RwLock<Option<SocketAddr>>> = Arc::new(RwLock::new(None)); let admin: Arc<RwLock<Option<SocketAddr>>> = Arc::new(RwLock::new(None));
while let Ok((stream, addr)) = listener.accept().await { while let Ok((stream, addr)) = listener.accept().await {
tokio::spawn(handle_connection( tokio::spawn(handle_connection(
stream, stream,
addr, addr,
clients.clone(), clients.clone(),
observers.clone(), observers.clone(),
matches.clone(), matches.clone(),
admin.clone(), admin.clone(),
demo_mode demo_mode,
)); ));
} }
@@ -57,10 +56,10 @@ async fn handle_connection(
stream: TcpStream, stream: TcpStream,
addr: SocketAddr, addr: SocketAddr,
clients: Clients, clients: Clients,
observers: Observers, observers: Observers,
matches: Matches, matches: Matches,
admin: Arc<RwLock<Option<SocketAddr>>>, admin: Arc<RwLock<Option<SocketAddr>>>,
demo_mode: bool, demo_mode: bool,
) -> Result<(), anyhow::Error> { ) -> Result<(), anyhow::Error> {
info!("New WebSocket connection from: {}", addr); info!("New WebSocket connection from: {}", addr);
@@ -69,7 +68,7 @@ async fn handle_connection(
let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel(); let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
// Store the client // Store the client
observers.write().await.insert(addr, tx.clone()); 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 {
@@ -89,32 +88,36 @@ async fn handle_connection(
if text.starts_with("CONNECT:") { if text.starts_with("CONNECT:") {
let requested_username = text.split(":").collect::<Vec<&str>>()[1].to_string(); let requested_username = text.split(":").collect::<Vec<&str>>()[1].to_string();
if requested_username.is_empty() { if requested_username.is_empty() {
let _ = send(&tx, &format!("ERROR:INVALID:ID:{}", requested_username)); let _ = send(&tx, &format!("ERROR:INVALID:ID:{}", requested_username));
continue; continue;
} }
let mut is_taken = false; let mut is_taken = false;
for client in clients.read().await.values() { for client in clients.read().await.values() {
if requested_username == client.read().await.username { if requested_username == client.read().await.username {
let _ = send(&tx, &format!("ERROR:INVALID:ID:{}", requested_username)); let _ = send(&tx, &format!("ERROR:INVALID:ID:{}", requested_username));
is_taken = true; is_taken = true;
break; break;
} }
} }
if is_taken { continue; } if is_taken {
continue;
}
// not taken // not taken
observers.write().await.remove(&addr); observers.write().await.remove(&addr);
clients clients.write().await.insert(
.write().await addr.to_string().parse()?,
.insert( Arc::new(RwLock::new(Client::new(
addr.to_string().parse()?, requested_username,
Arc::new(RwLock::new(Client::new(requested_username, tx.clone(), addr.to_string().parse()?))) tx.clone(),
); addr.to_string().parse()?,
))),
);
let _ = send(&tx, "CONNECT:ACK"); let _ = send(&tx, "CONNECT:ACK");
} }
else if text == "READY" { else if text == "READY" {
if clients.read().await.get(&addr).is_none() { if clients.read().await.get(&addr).is_none() {
@@ -122,232 +125,263 @@ async fn handle_connection(
continue; continue;
} }
if clients.read().await.get(&addr).unwrap().read().await.ready { if clients.read().await.get(&addr).unwrap().read().await.ready {
let _ = send(&tx, "ERROR:INVALID"); let _ = send(&tx, "ERROR:INVALID");
continue; continue;
} }
clients.write().await.get_mut(&addr).unwrap().write().await.ready = true; clients.write().await.get_mut(&addr).unwrap().write().await.ready = true;
let _ = send(&tx,"READY:ACK"); let _ = send(&tx, "READY:ACK");
if demo_mode { if demo_mode {
let match_id: u32 = rand::rng().random_range(100000..=999999); 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()?))); let new_match = Arc::new(RwLock::new(Match::new(
matches.write().await.insert(match_id, new_match.clone()); match_id,
clients.write().await.get_mut(&addr).unwrap().write().await.ready = false; addr.to_string().parse()?,
clients addr.to_string().parse()?,
.write().await )));
.get_mut(&addr).unwrap() matches.write().await.insert(match_id, new_match.clone());
.write().await.current_match = Some(match_id); clients.write().await.get_mut(&addr).unwrap().write().await.ready = false;
clients clients.write().await.get_mut(&addr).unwrap().write().await.current_match =
.write().await Some(match_id);
.get_mut(&addr).unwrap() clients.write().await.get_mut(&addr).unwrap().write().await.color =
.write().await.color = Color::Red; Color::Red;
let _ = send(&tx, "GAME:START:1"); let _ = send(&tx, "GAME:START:1");
} }
} }
else if text.starts_with("PLAY:") { else if text.starts_with("PLAY:") {
let clients_guard = clients.read().await; let clients_guard = clients.read().await;
let client_option = clients_guard.get(&addr); let client_option = clients_guard.get(&addr);
// Check if client is valid // Check if client is valid
if client_option.is_none() || client_option.unwrap().read().await.current_match.is_none() { if client_option.is_none()
let _ = send(&tx, "ERROR:INVALID:MOVE"); || client_option.unwrap().read().await.current_match.is_none()
continue; {
} let _ = send(&tx, "ERROR:INVALID:MOVE");
continue;
}
let client = client_option.unwrap().read().await; let client = client_option.unwrap().read().await;
let matches_guard = matches.read().await; let matches_guard = matches.read().await;
let current_match = matches_guard.get(&client.current_match.unwrap()).unwrap().read().await; let current_match =
matches_guard.get(&client.current_match.unwrap()).unwrap().read().await;
let opponent = { let opponent = {
let result = let result = if addr == current_match.player1 {
if addr == current_match.player1 clients_guard.get(&current_match.player2).unwrap().read().await
{ clients_guard.get(&current_match.player2).unwrap().read().await } } else {
else clients_guard.get(&current_match.player1).unwrap().read().await
{ clients_guard.get(&current_match.player1).unwrap().read().await }; };
result result
}; };
// Check if it's their move // Check if it's their move
if (current_match.ledger.is_empty() && if (current_match.ledger.is_empty() && current_match.first != addr)
current_match.first != addr) || || (current_match.ledger.last().is_some()
(current_match.ledger.last().is_some() && current_match.ledger.last().unwrap().0 == client.color) && current_match.ledger.last().unwrap().0 == client.color)
{ {
let _ = send(&tx, "ERROR:INVALID:MOVE"); let _ = send(&tx, "ERROR:INVALID:MOVE");
continue; continue;
} }
let column_parse = text.split(":").collect::<Vec<&str>>()[1].parse::<usize>(); let column_parse = text.split(":").collect::<Vec<&str>>()[1].parse::<usize>();
drop(current_match); drop(current_match);
drop(matches_guard); drop(matches_guard);
let mut matches_guard = matches.write().await; let mut matches_guard = matches.write().await;
let mut current_match = matches_guard.get_mut(&client.current_match.unwrap()).unwrap().write().await; let mut current_match = matches_guard
.get_mut(&client.current_match.unwrap())
.unwrap()
.write()
.await;
// Check if valid move // Check if valid move
if let Ok(column) = column_parse { if let Ok(column) = column_parse {
if column >= 6 { if column >= 6 {
let _ = send(&tx, "ERROR:INVALID:MOVE"); let _ = send(&tx, "ERROR:INVALID:MOVE");
continue; continue;
} }
if current_match.board[column][4] != Color::None { if current_match.board[column][4] != Color::None {
let _ = send(&tx, "ERROR:INVALID:MOVE"); let _ = send(&tx, "ERROR:INVALID:MOVE");
continue; continue;
} }
// Place it // Place it
current_match.place_token(client.color.clone(), column) current_match.place_token(client.color.clone(), column)
} else { } else {
let _ = send(&tx, "ERROR:INVALID:MOVE"); let _ = send(&tx, "ERROR:INVALID:MOVE");
continue; continue;
} }
// broadcast the move to viewers // broadcast the move to viewers
broadcast_message( broadcast_message(
&current_match.viewers, &current_match.viewers,
&observers, &observers,
&format!("GAME:MOVE:{}:{}", client.username, column_parse.clone()?)) &format!("GAME:MOVE:{}:{}", client.username, column_parse.clone()?),
.await; )
.await;
// Check game end conditions // Check game end conditions
let (winner, filled) = { let (winner, filled) = {
let mut result = (Color::None, false); let mut result = (Color::None, false);
let mut any_empty = true; let mut any_empty = true;
for x in 0..6 { for x in 0..6 {
for y in 0..5 { for y in 0..5 {
let color = current_match.board[x][y].clone(); let color = current_match.board[x][y].clone();
let mut horizontal_end = true; let mut horizontal_end = true;
let mut vertical_end = true; let mut vertical_end = true;
let mut diagonal_end = true; let mut diagonal_end = true;
if any_empty && color == Color::None { if any_empty && color == Color::None {
any_empty = false; any_empty = false;
} }
for i in 0..4 { for i in 0..4 {
if x + i >= 6 || current_match.board[x + i][y] != color && horizontal_end { if x + i >= 6
horizontal_end = false; || current_match.board[x + i][y] != color && horizontal_end
} {
horizontal_end = false;
}
if y + i >= 5 || current_match.board[x][y + i] != color && vertical_end { if y + i >= 5
vertical_end = false; || current_match.board[x][y + i] != color && vertical_end
} {
vertical_end = false;
}
if x + i >= 6 || y + i >= 5 || current_match.board[x + i][y + i] != color && diagonal_end { if x + i >= 6
diagonal_end = false; || y + i >= 5
} || 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 horizontal_end || vertical_end || diagonal_end {
} result = (color.clone(), false);
if result.0 != Color::None { break; } break;
} }
}
if result.0 != Color::None {
break;
}
}
if any_empty && result.0 == Color::None { result.1 = true; } if any_empty && result.0 == Color::None {
result.1 = true;
}
result result
}; };
if winner != Color::None { if winner != Color::None {
if winner == client.color { if winner == client.color {
let _ = send(&tx, "GAME:WINS"); let _ = send(&tx, "GAME:WINS");
if !demo_mode { if !demo_mode {
let _ = send(&opponent.connection, "GAME:LOSS"); let _ = send(&opponent.connection, "GAME:LOSS");
} }
broadcast_message(&current_match.viewers, &observers, &format!("GAME:WIN:{}", client.username)).await; broadcast_message(
} else { &current_match.viewers,
let _ = send(&tx, "GAME:LOSS"); &observers,
if !demo_mode { &format!("GAME:WIN:{}", client.username),
let _ = send(&opponent.connection, "GAME:WINS"); )
} .await;
broadcast_message(&current_match.viewers, &observers, &format!("GAME:WIN:{}", opponent.username)).await; } else {
} let _ = send(&tx, "GAME:LOSS");
} if !demo_mode {
else if filled { let _ = send(&opponent.connection, "GAME:WINS");
let _ = send(&tx, "GAME:DRAW"); }
if !demo_mode { broadcast_message(
let _ = send(&opponent.connection, "GAME:DRAW"); &current_match.viewers,
} &observers,
broadcast_message(&current_match.viewers, &observers, "GAME:DRAW").await; &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(&current_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;
// remove match from matchmaker drop(client);
if winner != Color::None || filled { drop(opponent);
let opponent_addr = opponent.addr; drop(current_match);
let current_match_id = current_match.id; drop(clients_guard);
drop(client); let mut clients_guard = clients.write().await;
drop(opponent); let mut client = clients_guard.get_mut(&addr).unwrap().write().await;
drop(current_match); client.current_match = None;
drop(clients_guard); drop(client);
let mut clients_guard = clients.write().await; let mut opponent =
let mut client = clients_guard.get_mut(&addr).unwrap().write().await; clients_guard.get_mut(&opponent_addr).unwrap().write().await;
client.current_match = None;
drop(client);
let mut opponent = clients_guard.get_mut(&opponent_addr).unwrap().write().await; if !demo_mode {
opponent.current_match = None;
if !demo_mode { }
opponent.current_match = None; matches_guard.remove(&current_match_id).unwrap();
} continue;
matches_guard.remove(&current_match_id).unwrap(); }
continue;
}
if !demo_mode{
// TODO: delay/autoplay/continue behavior
let _ = send(&opponent.connection, &format!("OPPONENT:{}", column_parse.clone()?));
} else {
let random_move = random_move(&current_match.board);
current_match.place_token(Color::Blue, random_move);
let _ = send(&tx, &format!("OPPONENT:{}", random_move));
}
}
if !demo_mode {
// TODO: delay/autoplay/continue behavior
let _ = send(
&opponent.connection,
&format!("OPPONENT:{}", column_parse.clone()?),
);
} else {
let random_move = random_move(&current_match.board);
current_match.place_token(Color::Blue, random_move);
let _ = send(&tx, &format!("OPPONENT:{}", random_move));
}
}
else if text == "GAME:LIST" { else if text == "GAME:LIST" {
todo!() todo!()
} }
else if text.starts_with("GAME:WATCH:") { else if text.starts_with("GAME:WATCH:") {
todo!() todo!()
} }
else if text.starts_with("ADMIN:AUTH:") {
else if text.starts_with("ADMIN:AUTH:") { todo!()
todo!() }
} else if text.starts_with("ADMIN:KICK:") {
else if text.starts_with("ADMIN:KICK:") { todo!()
todo!() }
} else if text == "GAME:TERMINATE" {
else if text == "GAME:TERMINATE" { todo!()
todo!() }
} else if text.starts_with("GAME:AUTOPLAY:") {
else if text.starts_with("GAME:AUTOPLAY:") { todo!()
todo!() }
}
else if text == "GAME:CONTINUE" { else if text == "GAME:CONTINUE" {
todo!() todo!()
} }
else { else {
let _ = send(&tx, "ERROR:UNKNOWN"); let _ = send(&tx, "ERROR:UNKNOWN");
} }
} }
Ok(Message::Close(_)) => { Ok(Message::Close(_)) => {
info!("Client {} disconnected", addr); info!("Client {} disconnected", addr);
break; break;
} }
Ok(_) => { Ok(_) => {
let _ = send(&tx, "ERROR:UNKNOWN"); let _ = send(&tx, "ERROR:UNKNOWN");
} }
Err(e) => { Err(e) => {
error!("WebSocket error for {}: {}", addr, e); error!("WebSocket error for {}: {}", addr, e);
break; break;
@@ -359,71 +393,69 @@ async fn handle_connection(
send_task.abort(); send_task.abort();
// Remove and terminate any matches // Remove and terminate any matches
if let Some(match_id) = clients.read().await.get(&addr).unwrap().read().await.current_match { if let Some(match_id) = clients.read().await.get(&addr).unwrap().read().await.current_match {
let matches_guard = matches.read().await; let matches_guard = matches.read().await;
let clients_guard = clients.read().await; let clients_guard = clients.read().await;
let the_match = matches_guard.get(&match_id).unwrap().read().await; let the_match = matches_guard.get(&match_id).unwrap().read().await;
let player1 = clients_guard.get(&the_match.player1).unwrap().read().await; let player1 = clients_guard.get(&the_match.player1).unwrap().read().await;
let player2 = clients_guard.get(&the_match.player2).unwrap().read().await; let player2 = clients_guard.get(&the_match.player2).unwrap().read().await;
let _ = send(&player1.connection, "GAME:TERMINATED"); let _ = send(&player1.connection, "GAME:TERMINATED");
let _ = send(&player2.connection, "GAME:TERMINATED"); let _ = send(&player2.connection, "GAME:TERMINATED");
broadcast_message(&the_match.viewers, &observers, "GAME:TERMINATED").await; broadcast_message(&the_match.viewers, &observers, "GAME:TERMINATED").await;
drop(player1); drop(player1);
drop(player2); drop(player2);
drop(the_match); drop(the_match);
drop(matches_guard); drop(matches_guard);
drop(clients_guard); drop(clients_guard);
matches.write().await.remove(&match_id); matches.write().await.remove(&match_id);
} }
clients.write().await.remove(&addr); clients.write().await.remove(&addr);
observers.write().await.remove(&addr); observers.write().await.remove(&addr);
let mut admin_guard = admin.write().await; let mut admin_guard = admin.write().await;
if let Some(admin_addr) = *admin_guard { if let Some(admin_addr) = *admin_guard {
if admin_addr == addr { if admin_addr == addr {
*admin_guard = None; *admin_guard = None;
} }
} }
drop(admin_guard); drop(admin_guard);
info!("Client {} removed", addr); info!("Client {} removed", addr);
Ok(()) Ok(())
} }
async fn broadcast_message(addrs: &Vec<SocketAddr>, observers: &Observers, msg: &str) { async fn broadcast_message(addrs: &Vec<SocketAddr>, observers: &Observers, msg: &str) {
for addr in addrs { for addr in addrs {
let _ = send(observers.read().await.get(addr).unwrap(), msg); let _ = send(observers.read().await.get(addr).unwrap(), msg);
} }
} }
async fn watch(matches: &Matches, new_match_id: u32, addr: SocketAddr) { async fn watch(matches: &Matches, new_match_id: u32, addr: SocketAddr) {
for a_match in &mut matches.write().await.values_mut() { for a_match in &mut matches.write().await.values_mut() {
let mut found = false; let mut found = false;
for i in 0..a_match.write().await.viewers.len() { for i in 0..a_match.write().await.viewers.len() {
if a_match.write().await.viewers[i] == addr { if a_match.write().await.viewers[i] == addr {
a_match.write().await.viewers.remove(i); a_match.write().await.viewers.remove(i);
found = true; found = true;
break; break;
} }
} }
if found { break; } if found {
} break;
}
}
matches matches.write().await.get_mut(&new_match_id).unwrap().write().await.viewers.push(addr);
.write().await
.get_mut(&new_match_id).unwrap()
.write().await
.viewers.push(addr);
} }
fn send(tx: &UnboundedSender<Message>, text: &str) -> Result<(), SendError<Message>> { fn send(tx: &UnboundedSender<Message>, text: &str) -> Result<(), SendError<Message>> {
tx.send(Message::text(text)) tx.send(Message::text(text))
} }

12
src/random_ai.rs
View File

@@ -1,11 +1,11 @@
use crate::types::Color;
use rand::Rng; use rand::Rng;
use crate::types::{Client, Color};
pub fn random_move(board: &[Vec<Color>]) -> usize { pub fn random_move(board: &[Vec<Color>]) -> usize {
let mut random = rand::rng().random_range(0..6); let mut random = rand::rng().random_range(0..6);
while board[random][4] != Color::None { while board[random][4] != Color::None {
random = rand::rng().random_range(0..6); random = rand::rng().random_range(0..6);
} }
random random
} }

99
src/types.rs
View File

@@ -1,68 +1,81 @@
use rand::Rng;
use std::net::SocketAddr; use std::net::SocketAddr;
use std::vec; use std::vec;
use rand::Rng;
use tokio::sync::mpsc::error::SendError; use tokio::sync::mpsc::error::SendError;
use tokio::sync::mpsc::UnboundedSender; use tokio::sync::mpsc::UnboundedSender;
use tokio_tungstenite::tungstenite::Message; use tokio_tungstenite::tungstenite::Message;
#[derive(PartialEq, Clone)] #[derive(PartialEq, Clone)]
pub enum Color { pub enum Color {
Red, Red,
Blue, Blue,
None, None,
} }
#[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 demo: bool, pub demo: bool,
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,
demo: false, demo: false,
addr, addr,
} }
} }
pub fn send(&self, text: &str) -> Result<(), SendError<Message>> { pub fn send(&self, text: &str) -> Result<(), SendError<Message>> {
self.connection.send(Message::text(text)) self.connection.send(Message::text(text))
} }
} }
pub struct Match { pub struct Match {
pub id: u32, pub id: u32,
pub board: Vec<Vec<Color>>, pub board: Vec<Vec<Color>>,
pub viewers: Vec<SocketAddr>, pub viewers: Vec<SocketAddr>,
pub ledger: Vec<(Color, usize)>, pub ledger: Vec<(Color, usize)>,
pub first: SocketAddr, pub first: SocketAddr,
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) -> Match { pub fn new(id: u32, player1: SocketAddr, player2: SocketAddr) -> Match {
let first = if rand::rng().random_range(0..=1) == 0 { player1.clone() } else { player2.clone() }; let first = if rand::rng().random_range(0..=1) == 0 {
Match { id, board: vec![vec![Color::None; 5]; 6], viewers: Vec::new(), ledger: Vec::new(), first, player1, player2 } player1.to_string().parse().unwrap()
} } else {
player2.to_string().parse().unwrap()
};
// TODO: make player1 in Match always first
Match {
id,
board: vec![vec![Color::None; 5]; 6],
viewers: Vec::new(),
ledger: Vec::new(),
first,
player1,
player2,
}
}
pub fn place_token(&mut self, color: Color, column: usize) { pub fn place_token(&mut self, color: Color, column: usize) {
for i in 0..5 { for i in 0..5 {
if self.board[column][i] == Color::None { if self.board[column][i] == Color::None {
self.board[column][i] = color; self.board[column][i] = color;
break; break;
} }
} }
} }
} }