From 3f539662518609390964c60acf2f38d9a08aee6d Mon Sep 17 00:00:00 2001 From: Dennis Kobert Date: Fri, 31 May 2019 04:17:35 +0200 Subject: Extract connention loop to seperate funtion --- game_server/src/scribble_group.rs | 38 ++++++++++++++++++++------------------ 1 file changed, 20 insertions(+), 18 deletions(-) diff --git a/game_server/src/scribble_group.rs b/game_server/src/scribble_group.rs index 01090de..2eb16f2 100644 --- a/game_server/src/scribble_group.rs +++ b/game_server/src/scribble_group.rs @@ -33,24 +33,7 @@ impl Group for ScribbleGroup { self.senders.lock().unwrap().insert(id, sen); let senders_mutex = self.senders.clone(); let self_uid = id; - std::thread::spawn(move || { - loop { - let message = match rec.recv_message() { - Ok(x) => x, - _ => break - }; - //trace!("got message: '{:?}'", message); - let mut senders = senders_mutex.lock().unwrap(); - for (uid, sender) in senders.iter_mut() { - if self_uid != *uid { - sender.send_message(&message) - .unwrap_or_else(|_| debug!("tried to send message to {}, but failed", *uid)); - } - } - } - senders_mutex.lock().unwrap().remove(&self_uid); - info!("client {} has left", self_uid); - }); + std::thread::spawn(move || Self::broadcast_clients(self_uid, rec, senders_mutex)); } } @@ -58,4 +41,23 @@ impl ScribbleGroup { pub fn new(id: GroupId, name: String) -> Self { Self { id, name, senders: Arc::new(Mutex::new(HashMap::new())) } } + + fn broadcast_clients(self_uid: UserId, mut rec: ClientReceiver, senders_mutex: Arc>>) { + loop { + let message = match rec.recv_message() { + Ok(x) => x, + _ => break + }; + //trace!("got message: '{:?}'", message); + let mut senders = senders_mutex.lock().unwrap(); + for (uid, sender) in senders.iter_mut() { + if self_uid != *uid { + sender.send_message(&message) + .unwrap_or_else(|_| debug!("tried to send message to {}, but failed", *uid)); + } + } + } + senders_mutex.lock().unwrap().remove(&self_uid); + info!("client {} has left", self_uid); + } } -- cgit v1.2.3-54-g00ecf From 1b6b5acf63d5d78207dcd746d080cafcd1bfbd84 Mon Sep 17 00:00:00 2001 From: Dennis Kobert Date: Fri, 31 May 2019 04:20:08 +0200 Subject: Make reciver and sender of the Gameclient imutable --- game_server/src/server.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/game_server/src/server.rs b/game_server/src/server.rs index 6294e2c..ea33e2a 100644 --- a/game_server/src/server.rs +++ b/game_server/src/server.rs @@ -65,7 +65,7 @@ impl GameClient { } pub fn split(self) -> (ClientSender, ClientReceiver) { - let (mut rec, mut sen) = self.client.split().unwrap(); + let (rec, sen) = self.client.split().unwrap(); (sen, rec) } } -- cgit v1.2.3-54-g00ecf From cdb4799231837e1e1a07f484b0b8a944819e6e78 Mon Sep 17 00:00:00 2001 From: Dennis Kobert Date: Fri, 31 May 2019 04:57:08 +0200 Subject: Get rid of WarningGet rid of Warninss --- WebInterface/Web.config | 15 --------------- game_server/src/lobby.rs | 4 +++- game_server/src/scribble_group.rs | 2 +- game_server/src/server.rs | 14 ++++++++------ 4 files changed, 12 insertions(+), 23 deletions(-) delete mode 100644 WebInterface/Web.config diff --git a/WebInterface/Web.config b/WebInterface/Web.config deleted file mode 100644 index 741b7d8..0000000 --- a/WebInterface/Web.config +++ /dev/null @@ -1,15 +0,0 @@ - - - - - - - - \ No newline at end of file diff --git a/game_server/src/lobby.rs b/game_server/src/lobby.rs index d03bd45..ef164af 100644 --- a/game_server/src/lobby.rs +++ b/game_server/src/lobby.rs @@ -9,6 +9,7 @@ pub struct Lobby { groups: HashMap>, } +#[allow(dead_code)] impl Lobby { pub fn new() -> Self { Self { @@ -21,7 +22,7 @@ impl Lobby { "scribble" => { Some(Box::new(ScribbleGroup::new(id, name.to_string()))) }, - other => None, + _ => None, } } @@ -48,6 +49,7 @@ impl Lobby { } } +#[allow(dead_code)] pub struct GroupIterator<'a> { groups: std::collections::hash_map::Values<'a, GroupId, Box> } diff --git a/game_server/src/scribble_group.rs b/game_server/src/scribble_group.rs index 2eb16f2..0d2c0f1 100644 --- a/game_server/src/scribble_group.rs +++ b/game_server/src/scribble_group.rs @@ -29,7 +29,7 @@ impl Group for ScribbleGroup { fn add_client(&mut self, id: UserId, client: GameClient) { debug!("user {} joined the group {}:'{}'", id, self.id, self.name); - let (sen, mut rec) = client.split(); + let (sen, rec) = client.split(); self.senders.lock().unwrap().insert(id, sen); let senders_mutex = self.senders.clone(); let self_uid = id; diff --git a/game_server/src/server.rs b/game_server/src/server.rs index ea33e2a..0b76f15 100644 --- a/game_server/src/server.rs +++ b/game_server/src/server.rs @@ -8,7 +8,6 @@ use websocket::{OwnedMessage, use std::net::{SocketAddr, ToSocketAddrs, TcpStream}; use std::sync::{mpsc, mpsc::{Sender, Receiver}}; -use std::collections::HashMap; use super::lobby::Lobby; use super::backend_connection::BackendConnection; @@ -121,16 +120,19 @@ impl GameServer { } fn read_clients(&self) -> Receiver { - let (s, r): (Sender, Receiver) + let (sen, rec): (Sender, Receiver) = mpsc::channel(); let addr = self.addr; std::thread::spawn(move || { - let result = Self::handle_requests(addr, &s).or_else(|e| s.send(Err(e))); + match Self::handle_requests(addr, &sen) { + Err(e) => sen.send(Err(e)).unwrap(), + _ => (), + } }); - r + rec } - fn handle_requests(addr: SocketAddr, s: &Sender) -> Result<(), GameServerError> { + fn handle_requests(addr: SocketAddr, sen: &Sender) -> Result<(), GameServerError> { let server = match Server::::bind(addr) { Ok(v) => v, Err(e) => { @@ -140,7 +142,7 @@ impl GameServer { }; info!("webserver is being launched"); for req in server { - s.send(Ok(Self::handle_request(req)?)).unwrap(); + sen.send(Ok(Self::handle_request(req)?)).unwrap(); } info!("webserver is being shut down"); Ok(()) -- cgit v1.2.3-54-g00ecf From 031ba8a21d3899d4e24bd1423ec738ebf95ab947 Mon Sep 17 00:00:00 2001 From: Dennis Kobert Date: Fri, 31 May 2019 06:49:25 +0200 Subject: Improve Exception Handling Add WebhoggGroup --- game_server/src/backend_connection.rs | 4 +- game_server/src/group.rs | 4 +- game_server/src/lobby.rs | 12 +++--- game_server/src/main.rs | 1 + game_server/src/scribble_group.rs | 10 +++-- game_server/src/server.rs | 24 ++++++++++-- game_server/src/webhogg_group.rs | 71 +++++++++++++++++++++++++++++++++++ 7 files changed, 108 insertions(+), 18 deletions(-) create mode 100644 game_server/src/webhogg_group.rs diff --git a/game_server/src/backend_connection.rs b/game_server/src/backend_connection.rs index d32c58e..a751b30 100644 --- a/game_server/src/backend_connection.rs +++ b/game_server/src/backend_connection.rs @@ -1,8 +1,8 @@ use reqwest::{Response, Client, Url, UrlError, Error as ReqError}; use std::sync::mpsc::{Sender, Receiver}; use std::sync::mpsc; -use super::server::{UserId, Token}; -use super::group::GroupId; +use crate::server::{UserId, Token}; +use crate::group::GroupId; pub struct BackendConnection { host: String, diff --git a/game_server/src/group.rs b/game_server/src/group.rs index fcda12a..74a04f7 100644 --- a/game_server/src/group.rs +++ b/game_server/src/group.rs @@ -1,4 +1,4 @@ -use super::server::{UserId, GameClient}; +use crate::server::{UserId, GameClient, GameServerError}; pub type GroupId = u32; @@ -9,5 +9,5 @@ pub trait Group { fn run(&mut self); - fn add_client(&mut self, id: UserId, client: GameClient); + fn add_client(&mut self, id: UserId, client: GameClient) -> Result<(), GameServerError>; } diff --git a/game_server/src/lobby.rs b/game_server/src/lobby.rs index ef164af..6d11a5f 100644 --- a/game_server/src/lobby.rs +++ b/game_server/src/lobby.rs @@ -1,9 +1,9 @@ use std::collections::HashMap; -use super::group::{Group, GroupId}; -use super::scribble_group::ScribbleGroup; +use crate::group::{Group, GroupId}; +use crate::scribble_group::ScribbleGroup; -use super::server::{UserId, GameClient}; +use crate::server::{UserId, GameClient, GameServerError}; pub struct Lobby { groups: HashMap>, @@ -31,17 +31,17 @@ impl Lobby { } pub fn add_client(&mut self, group_type: &str, group_id: GroupId, group_name: &str, - user_id: UserId, client: GameClient) { + user_id: UserId, client: GameClient) -> Result<(), GameServerError> { if !self.groups.contains_key(&group_id) { let mut group = match Self::generate_group(group_type, group_id, group_name) { Some(x) => x, - _ => return, + _ => return Err(GameServerError::GroupCreationError(format!("failed to generate '{}' group", group_type))), }; group.run(); self.groups.insert(group_id, group); } let group = self.groups.get_mut(&group_id).unwrap(); - group.add_client(user_id, client); + group.add_client(user_id, client) } pub fn iter<'b>(&'b self) -> GroupIterator<'b> { diff --git a/game_server/src/main.rs b/game_server/src/main.rs index ab73a97..a6cc608 100644 --- a/game_server/src/main.rs +++ b/game_server/src/main.rs @@ -1,5 +1,6 @@ mod group; mod scribble_group; +mod webhogg_group; mod lobby; mod server; mod backend_connection; diff --git a/game_server/src/scribble_group.rs b/game_server/src/scribble_group.rs index 0d2c0f1..8980e7b 100644 --- a/game_server/src/scribble_group.rs +++ b/game_server/src/scribble_group.rs @@ -1,6 +1,7 @@ -use super::group::{Group, GroupId}; -use super::server::{UserId, GameClient, - ClientSender, ClientReceiver}; +use crate::group::{Group, GroupId}; +use crate::server::{UserId, GameClient, + ClientSender, ClientReceiver, + GameServerError}; use std::collections::HashMap; use std::sync::{Arc, Mutex}; @@ -27,13 +28,14 @@ impl Group for ScribbleGroup { info!("a new group {}:'{}' runs now", self.id, self.name); } - fn add_client(&mut self, id: UserId, client: GameClient) { + fn add_client(&mut self, id: UserId, client: GameClient) -> Result<(), GameServerError> { debug!("user {} joined the group {}:'{}'", id, self.id, self.name); let (sen, rec) = client.split(); self.senders.lock().unwrap().insert(id, sen); let senders_mutex = self.senders.clone(); let self_uid = id; std::thread::spawn(move || Self::broadcast_clients(self_uid, rec, senders_mutex)); + Ok(()) } } diff --git a/game_server/src/server.rs b/game_server/src/server.rs index 0b76f15..5b1a7a9 100644 --- a/game_server/src/server.rs +++ b/game_server/src/server.rs @@ -8,8 +8,8 @@ use websocket::{OwnedMessage, use std::net::{SocketAddr, ToSocketAddrs, TcpStream}; use std::sync::{mpsc, mpsc::{Sender, Receiver}}; -use super::lobby::Lobby; -use super::backend_connection::BackendConnection; +use crate::lobby::Lobby; +use crate::backend_connection::BackendConnection; pub type ClientReceiver = receiver::Reader<::Reader>; pub type ClientSender = sender::Writer<::Writer>; @@ -24,7 +24,22 @@ pub enum GameServerError { BindError(std::io::Error), HandshakeRequestError, InvalidProtocolError, - AcceptError(std::io::Error) + AcceptError(std::io::Error), + GroupError(String), + GroupCreationError(String), +} + +impl std::fmt::Display for GameServerError { + fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> { + match self { + GameServerError::BindError(e) => write!(f, "BindError: {}", e), + GameServerError::HandshakeRequestError => write!(f, "HandshakeRequestError"), + GameServerError::InvalidProtocolError => write!(f, "InvalidProtocolError"), + GameServerError::AcceptError(e) => write!(f, "AcceptError: {}", e), + GameServerError::GroupError(e) => write!(f, "GroupError: {}", e), + GameServerError::GroupCreationError(e) => write!(f, "GroupCreationError: {}", e), + } + } } pub struct GameServer { @@ -111,7 +126,8 @@ impl GameServer { user_id, token, client.host_name(), group_name); //clients.lock().unwrap().insert(token, client); self.lobby.add_client(&group_type, group_id, - &group_name, user_id, client); + &group_name, user_id, client) + .unwrap_or_else(|e| warn!("failed to add client: {}", e)); } } } else { diff --git a/game_server/src/webhogg_group.rs b/game_server/src/webhogg_group.rs new file mode 100644 index 0000000..091f7f8 --- /dev/null +++ b/game_server/src/webhogg_group.rs @@ -0,0 +1,71 @@ +use crate::group::{Group, GroupId}; +use crate::server::{UserId, GameClient, + ClientSender, ClientReceiver, + GameServerError}; +use std::collections::HashMap; +use std::sync::{Arc, Mutex}; + +pub struct WebhoggGroup { + id: GroupId, + name: String, + senders: Arc>> +} + +impl Group for WebhoggGroup { + fn id(&self) -> GroupId { + self.id + } + + fn group_type(&self) -> String { + "webhogg".to_string() + } + + fn name(&self) -> String { + self.name.clone() + } + + fn run(&mut self) { + info!("a new group {}:'{}' runs now", self.id, self.name); + } + + fn add_client(&mut self, id: UserId, client: GameClient) -> Result<(), GameServerError> { + if self.senders.lock().unwrap().len() > 1 { + return Err(GameServerError::GroupError( + format!("user {} was not able to join the {} group, {}", + "because the client limit has been exceeded", + id, self.name))); + } + debug!("user {} joined the group {}:'{}'", id, self.id, self.name); + let (sen, rec) = client.split(); + self.senders.lock().unwrap().insert(id, sen); + let senders_mutex = self.senders.clone(); + let self_uid = id; + std::thread::spawn(move || Self::broadcast_clients(self_uid, rec, senders_mutex)); + Ok(()) + } +} + +impl WebhoggGroup { + pub fn new(id: GroupId, name: String) -> Self { + Self { id, name, senders: Arc::new(Mutex::new(HashMap::new())) } + } + + fn broadcast_clients(self_uid: UserId, mut rec: ClientReceiver, senders_mutex: Arc>>) { + loop { + let message = match rec.recv_message() { + Ok(x) => x, + _ => break + }; + //trace!("got message: '{:?}'", message); + let mut senders = senders_mutex.lock().unwrap(); + for (uid, sender) in senders.iter_mut() { + if self_uid != *uid { + sender.send_message(&message) + .unwrap_or_else(|_| debug!("tried to send message to {}, but failed", *uid)); + } + } + } + senders_mutex.lock().unwrap().remove(&self_uid); + info!("client {} has left", self_uid); + } +} -- cgit v1.2.3-54-g00ecf From 3527f10f8767b3b62b876f8a3f3bc5bd3ba56b2d Mon Sep 17 00:00:00 2001 From: Dennis Kobert Date: Fri, 31 May 2019 07:35:55 +0200 Subject: Add Vec2 --- game_server/src/maths.rs | 54 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 54 insertions(+) create mode 100644 game_server/src/maths.rs diff --git a/game_server/src/maths.rs b/game_server/src/maths.rs new file mode 100644 index 0000000..635eed6 --- /dev/null +++ b/game_server/src/maths.rs @@ -0,0 +1,54 @@ +pub struct Vec2 { + pub x: f32, + pub y: f32, +} + +impl std::ops::Add for Vec2 { + type Output = Self; + fn add(self, other: Self) -> Self { + Self { + x: x + other.x, + y: y + other.y + } + } +} + +impl std::ops::Sub for Vec2 { + type Output = Self; + fn sub(self, other: Self) -> Self { + Self { + x: x - other.x, + y: y - other.y + } + } +} + +impl std::ops::Neg for Vec2 { + type Output = Self; + fn sub(self) -> Self { + Self { + x: -x, + y: -y + } + } +} + +impl std::cmp::PartialEq for Vec2 { + type Output = bool; + fn eq(&self, other: &Self) -> bool { + f32::abs(self.x - other.x) < 1e-8 + && f32::abs(self.y - other.y) < 1e-8 + } +} + +impl std::cmp::Eq for Vec2 {} + +impl Vec2 { + pub fn distance(&self) -> f32 { + f32::sqrt(self.distance2) + } + + pub fn distance2(&self) -> f32 { + self.x * self.x + self.y * self.y + } +} -- cgit v1.2.3-54-g00ecf