From b65c999daa5c83b9e76c6dca9df088a40e440642 Mon Sep 17 00:00:00 2001
From: natrixaeria <janng@gmx.de>
Date: Sun, 19 May 2019 17:38:50 +0200
Subject: Change logger to fern

---
 game_server/src/main.rs | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

(limited to 'game_server/src/main.rs')

diff --git a/game_server/src/main.rs b/game_server/src/main.rs
index e129283..76e7a39 100644
--- a/game_server/src/main.rs
+++ b/game_server/src/main.rs
@@ -4,13 +4,14 @@ mod lobby;
 mod gameserver;
 mod backend_connection;
 
+mod game_logger;
+
 #[macro_use] extern crate log;
-use pretty_env_logger;
 
 use backend_connection::BackendConnection;
 
 fn main() {
-    pretty_env_logger::init();
+    game_logger::init_logger();
 
     let addr = ("127.0.0.1", 5001);
     info!("create game server on {:?}", addr);
-- 
cgit v1.2.3-54-g00ecf


From 14c163e415a8ad37d9111e6a5a4a34e3cbe0ad74 Mon Sep 17 00:00:00 2001
From: natrixaeria <janng@gmx.de>
Date: Sun, 19 May 2019 17:55:04 +0200
Subject: Rename gameserver module to server

---
 game_server/src/backend_connection.rs |   2 +-
 game_server/src/gameserver.rs         | 164 ----------------------------------
 game_server/src/main.rs               |   4 +-
 game_server/src/server.rs             | 164 ++++++++++++++++++++++++++++++++++
 4 files changed, 167 insertions(+), 167 deletions(-)
 delete mode 100644 game_server/src/gameserver.rs
 create mode 100644 game_server/src/server.rs

(limited to 'game_server/src/main.rs')

diff --git a/game_server/src/backend_connection.rs b/game_server/src/backend_connection.rs
index 11642f2..fa41791 100644
--- a/game_server/src/backend_connection.rs
+++ b/game_server/src/backend_connection.rs
@@ -1,7 +1,7 @@
 use reqwest::{Response, Client, Url, UrlError, Error as ReqError};
 use std::sync::mpsc::{Sender, Receiver};
 use std::sync::mpsc;
-use super::gameserver::Token;
+use super::server::Token;
 
 pub struct BackendConnection {
     host: String,
diff --git a/game_server/src/gameserver.rs b/game_server/src/gameserver.rs
deleted file mode 100644
index a4b1ed5..0000000
--- a/game_server/src/gameserver.rs
+++ /dev/null
@@ -1,164 +0,0 @@
-use websocket::{OwnedMessage,
-    sync::Server,
-    client::sync::Client,
-    server::{NoTlsAcceptor, InvalidConnection,
-        sync::AcceptResult}};
-use std::net::{SocketAddr, ToSocketAddrs, TcpStream};
-use std::sync::{mpsc,
-                mpsc::{Sender, Receiver},
-                Arc, Mutex};
-use std::collections::HashMap;
-use super::lobby::Lobby;
-use super::backend_connection::BackendConnection;
-
-const PROTOCOL: &str = "tuesday";
-
-pub type Token = u32;
-
-#[derive(Debug)]
-pub enum GameServerError {
-    BindError(std::io::Error),
-    HandshakeRequestError,
-    InvalidProtocolError,
-    AcceptError(std::io::Error)
-}
-
-pub struct GameServer {
-    addr: SocketAddr,
-    lobby: Lobby,
-    backend: Arc<Mutex<BackendConnection>>,
-    clients: Arc<Mutex<HashMap<Token, GameClient>>>,
-}
-
-pub struct GameClient {
-    addr: SocketAddr,
-    client: Client<TcpStream>,
-}
-
-impl GameClient {
-    fn from_raw(client: Client<TcpStream>) -> Result<Self, ()> {
-        let addr = client.peer_addr().map_err(|_| ())?;
-        info!("got a client connection from: {}", addr);
-        Ok(GameClient {
-            addr,
-            client,
-        })
-    }
-
-    fn require_token(&mut self) -> Option<Token> {
-        let message = self.client
-                 .recv_message()
-                 .ok()?;
-        if let OwnedMessage::Text(text) = message {
-            text.parse().ok()
-        } else {
-            None
-        }
-    }
-}
-
-type ClientConnection = Result<GameClient, GameServerError>;
-
-impl GameServer {
-    pub fn new<T: ToSocketAddrs>(addr: T) -> Self {
-        let addr = addr.to_socket_addrs().unwrap().next().unwrap();
-        debug!("ws address: {}", addr);
-        info!("create lobby");
-        let lobby = Lobby::new();
-        let backend = BackendConnection::new("https://kobert.dev");
-        info!("got a C# backend connection");
-        GameServer {
-            addr,
-            lobby,
-            backend: Arc::new(Mutex::new(backend)),
-            clients: Arc::new(Mutex::new(HashMap::new())),
-        }
-    }
-
-    pub fn run(&self) -> Result<(), GameServerError> {
-        let reader = self.read_clients();
-        loop {
-            let mut connection = reader.recv().unwrap()?;
-            self.add_client(connection);
-        }
-        Ok(())
-    }
-
-    fn add_client(&self, mut client: GameClient) {
-        let clients = Arc::clone(&self.clients);
-        let backend = Arc::clone(&self.backend);
-        std::thread::spawn(move || {
-            let token = client.require_token();
-            if let Some(token) = token {
-                println!("Token: {}", token);
-                let locked_backend = backend.lock().unwrap();
-                let result = locked_backend.validate_token(&token);
-                if let Err(err) = result {
-                    warn!("token {} is invalid: '{:?}'", token, err);
-                } else {
-                    clients.lock().unwrap().insert(token, client);
-                }
-            } else {
-                warn!("client sent invalid token");
-            }
-        });
-    }
-
-    fn read_clients(&self) -> Receiver<ClientConnection> {
-        let (s, r): (Sender<ClientConnection>, Receiver<ClientConnection>)
-                     = mpsc::channel();
-        let addr = self.addr;
-        std::thread::spawn(move || {
-            let result = Self::handle_requests(addr, &s).or_else(|e| s.send(Err(e)));
-        });
-        r
-    }
-
-    fn handle_requests(addr: SocketAddr, s: &Sender<ClientConnection>) -> Result<(), GameServerError> {
-        let server = match Server::<NoTlsAcceptor>::bind(addr) {
-            Ok(v) => v,
-            Err(e) => {
-                error!("websocket binding error");
-                Err(GameServerError::BindError(e))?
-            },
-        };
-        info!("webserver is being launched");
-        for req in server {
-            s.send(Ok(Self::handle_request(req)?)).unwrap();
-        }
-        info!("webserver is being shut down");
-        Ok(())
-    }
-
-    fn handle_request(req: AcceptResult<TcpStream>) -> ClientConnection {
-        match req {
-            Ok(req) => {
-                if !req.protocols().contains(&PROTOCOL.to_string()) {
-                    warn!("a client tried to connect without {} protocol", PROTOCOL);
-                    req.reject().unwrap();
-                    Err(GameServerError::InvalidProtocolError)
-                } else {
-                    match req.use_protocol(PROTOCOL).accept() {
-                        Ok(client) => {
-                            match GameClient::from_raw(client) {
-                                Ok(client) => Ok(client),
-                                Err(_) => {
-                                    error!("could not create a client");
-                                    Err(GameServerError::HandshakeRequestError)
-                                }
-                            }
-                        },
-                        Err((_, e)) => {
-                            warn!("client handshake failed");
-                            Err(GameServerError::AcceptError(e))
-                        }
-                    }
-                }
-            },
-            Err(e) => {
-                warn!("invalid client request");
-                Err(GameServerError::HandshakeRequestError)
-            }
-        }
-    }
-}
diff --git a/game_server/src/main.rs b/game_server/src/main.rs
index 76e7a39..4d05efe 100644
--- a/game_server/src/main.rs
+++ b/game_server/src/main.rs
@@ -1,7 +1,7 @@
 mod group;
 mod test_group;
 mod lobby;
-mod gameserver;
+mod server;
 mod backend_connection;
 
 mod game_logger;
@@ -15,7 +15,7 @@ fn main() {
 
     let addr = ("127.0.0.1", 5001);
     info!("create game server on {:?}", addr);
-    let gameserver = gameserver::GameServer::new(addr);
+    let gameserver = server::GameServer::new(addr);
     gameserver.run().unwrap();
 
 }
diff --git a/game_server/src/server.rs b/game_server/src/server.rs
new file mode 100644
index 0000000..a4b1ed5
--- /dev/null
+++ b/game_server/src/server.rs
@@ -0,0 +1,164 @@
+use websocket::{OwnedMessage,
+    sync::Server,
+    client::sync::Client,
+    server::{NoTlsAcceptor, InvalidConnection,
+        sync::AcceptResult}};
+use std::net::{SocketAddr, ToSocketAddrs, TcpStream};
+use std::sync::{mpsc,
+                mpsc::{Sender, Receiver},
+                Arc, Mutex};
+use std::collections::HashMap;
+use super::lobby::Lobby;
+use super::backend_connection::BackendConnection;
+
+const PROTOCOL: &str = "tuesday";
+
+pub type Token = u32;
+
+#[derive(Debug)]
+pub enum GameServerError {
+    BindError(std::io::Error),
+    HandshakeRequestError,
+    InvalidProtocolError,
+    AcceptError(std::io::Error)
+}
+
+pub struct GameServer {
+    addr: SocketAddr,
+    lobby: Lobby,
+    backend: Arc<Mutex<BackendConnection>>,
+    clients: Arc<Mutex<HashMap<Token, GameClient>>>,
+}
+
+pub struct GameClient {
+    addr: SocketAddr,
+    client: Client<TcpStream>,
+}
+
+impl GameClient {
+    fn from_raw(client: Client<TcpStream>) -> Result<Self, ()> {
+        let addr = client.peer_addr().map_err(|_| ())?;
+        info!("got a client connection from: {}", addr);
+        Ok(GameClient {
+            addr,
+            client,
+        })
+    }
+
+    fn require_token(&mut self) -> Option<Token> {
+        let message = self.client
+                 .recv_message()
+                 .ok()?;
+        if let OwnedMessage::Text(text) = message {
+            text.parse().ok()
+        } else {
+            None
+        }
+    }
+}
+
+type ClientConnection = Result<GameClient, GameServerError>;
+
+impl GameServer {
+    pub fn new<T: ToSocketAddrs>(addr: T) -> Self {
+        let addr = addr.to_socket_addrs().unwrap().next().unwrap();
+        debug!("ws address: {}", addr);
+        info!("create lobby");
+        let lobby = Lobby::new();
+        let backend = BackendConnection::new("https://kobert.dev");
+        info!("got a C# backend connection");
+        GameServer {
+            addr,
+            lobby,
+            backend: Arc::new(Mutex::new(backend)),
+            clients: Arc::new(Mutex::new(HashMap::new())),
+        }
+    }
+
+    pub fn run(&self) -> Result<(), GameServerError> {
+        let reader = self.read_clients();
+        loop {
+            let mut connection = reader.recv().unwrap()?;
+            self.add_client(connection);
+        }
+        Ok(())
+    }
+
+    fn add_client(&self, mut client: GameClient) {
+        let clients = Arc::clone(&self.clients);
+        let backend = Arc::clone(&self.backend);
+        std::thread::spawn(move || {
+            let token = client.require_token();
+            if let Some(token) = token {
+                println!("Token: {}", token);
+                let locked_backend = backend.lock().unwrap();
+                let result = locked_backend.validate_token(&token);
+                if let Err(err) = result {
+                    warn!("token {} is invalid: '{:?}'", token, err);
+                } else {
+                    clients.lock().unwrap().insert(token, client);
+                }
+            } else {
+                warn!("client sent invalid token");
+            }
+        });
+    }
+
+    fn read_clients(&self) -> Receiver<ClientConnection> {
+        let (s, r): (Sender<ClientConnection>, Receiver<ClientConnection>)
+                     = mpsc::channel();
+        let addr = self.addr;
+        std::thread::spawn(move || {
+            let result = Self::handle_requests(addr, &s).or_else(|e| s.send(Err(e)));
+        });
+        r
+    }
+
+    fn handle_requests(addr: SocketAddr, s: &Sender<ClientConnection>) -> Result<(), GameServerError> {
+        let server = match Server::<NoTlsAcceptor>::bind(addr) {
+            Ok(v) => v,
+            Err(e) => {
+                error!("websocket binding error");
+                Err(GameServerError::BindError(e))?
+            },
+        };
+        info!("webserver is being launched");
+        for req in server {
+            s.send(Ok(Self::handle_request(req)?)).unwrap();
+        }
+        info!("webserver is being shut down");
+        Ok(())
+    }
+
+    fn handle_request(req: AcceptResult<TcpStream>) -> ClientConnection {
+        match req {
+            Ok(req) => {
+                if !req.protocols().contains(&PROTOCOL.to_string()) {
+                    warn!("a client tried to connect without {} protocol", PROTOCOL);
+                    req.reject().unwrap();
+                    Err(GameServerError::InvalidProtocolError)
+                } else {
+                    match req.use_protocol(PROTOCOL).accept() {
+                        Ok(client) => {
+                            match GameClient::from_raw(client) {
+                                Ok(client) => Ok(client),
+                                Err(_) => {
+                                    error!("could not create a client");
+                                    Err(GameServerError::HandshakeRequestError)
+                                }
+                            }
+                        },
+                        Err((_, e)) => {
+                            warn!("client handshake failed");
+                            Err(GameServerError::AcceptError(e))
+                        }
+                    }
+                }
+            },
+            Err(e) => {
+                warn!("invalid client request");
+                Err(GameServerError::HandshakeRequestError)
+            }
+        }
+    }
+}
-- 
cgit v1.2.3-54-g00ecf


From 2d815af3f6d062d55da2f2598ce5d506ee74cb6e Mon Sep 17 00:00:00 2001
From: natrixaeria <janng@gmx.de>
Date: Sun, 19 May 2019 18:44:04 +0200
Subject: Refactor code

---
 game_server/src/backend_connection.rs | 10 +---------
 game_server/src/main.rs               |  2 --
 game_server/src/server.rs             |  7 +++----
 3 files changed, 4 insertions(+), 15 deletions(-)

(limited to 'game_server/src/main.rs')

diff --git a/game_server/src/backend_connection.rs b/game_server/src/backend_connection.rs
index 4a12439..ed112d9 100644
--- a/game_server/src/backend_connection.rs
+++ b/game_server/src/backend_connection.rs
@@ -18,10 +18,6 @@ pub enum BackendError {
     BadResponse(Response),
 }
 
-struct TokenResponseStruct {
-
-}
-
 pub type TokenValidity = Result<(), BackendError>;
 pub type RequestData = Url;
 pub type ResponseResult = Result<Response, ReqError>;
@@ -59,14 +55,10 @@ impl BackendConnection {
         self.res_rec.recv().unwrap()
     }
     
-    pub fn host_name<'a>(&'a self) -> &'a str {
-        &self.host
-    }
-
     pub fn validate_token(&self, token: &Token) -> TokenValidity {
         let location = format!("/api/lobby/tokens/{}", token);
         self.request(&location).map_err(|err| BackendError::UrlError(err))?;
-        let mut response = self.get_response().map_err(|err| BackendError::RequestError(err))?;
+        let response = self.get_response().map_err(|err| BackendError::RequestError(err))?;
         if response.status().is_success() {
             Ok(())
         } else if response.status() == reqwest::StatusCode::NOT_FOUND {
diff --git a/game_server/src/main.rs b/game_server/src/main.rs
index 4d05efe..628062e 100644
--- a/game_server/src/main.rs
+++ b/game_server/src/main.rs
@@ -8,8 +8,6 @@ mod game_logger;
 
 #[macro_use] extern crate log;
 
-use backend_connection::BackendConnection;
-
 fn main() {
     game_logger::init_logger();
 
diff --git a/game_server/src/server.rs b/game_server/src/server.rs
index 79cd322..7a9c5b0 100644
--- a/game_server/src/server.rs
+++ b/game_server/src/server.rs
@@ -1,7 +1,7 @@
 use websocket::{OwnedMessage,
     sync::Server,
     client::sync::Client,
-    server::{NoTlsAcceptor, InvalidConnection,
+    server::{NoTlsAcceptor,
         sync::AcceptResult}};
 use std::net::{SocketAddr, ToSocketAddrs, TcpStream};
 use std::sync::{mpsc,
@@ -82,10 +82,9 @@ impl GameServer {
     pub fn run(&self) -> Result<(), GameServerError> {
         let reader = self.read_clients();
         loop {
-            let mut connection = reader.recv().unwrap()?;
+            let connection = reader.recv().unwrap()?;
             self.add_client(connection);
         }
-        Ok(())
     }
 
     fn add_client(&self, mut client: GameClient) {
@@ -160,7 +159,7 @@ impl GameServer {
                     }
                 }
             },
-            Err(e) => {
+            Err(_) => {
                 warn!("invalid client request");
                 Err(GameServerError::HandshakeRequestError)
             }
-- 
cgit v1.2.3-54-g00ecf


From 054a2bfe069ed4118d2f9fd1f01428632049057b Mon Sep 17 00:00:00 2001
From: natrixaeria <janng@gmx.de>
Date: Sun, 19 May 2019 22:38:25 +0200
Subject: Add a client handling system

---
 game_server/src/backend_connection.rs | 21 +++++++++++++---
 game_server/src/group.rs              |  8 +++++-
 game_server/src/lobby.rs              | 30 ++++++++++++++++++++--
 game_server/src/main.rs               |  4 +--
 game_server/src/scribble_group.rs     | 42 +++++++++++++++++++++++++++++++
 game_server/src/server.rs             | 47 +++++++++++++++++++----------------
 game_server/src/test_group.rs         | 28 ---------------------
 7 files changed, 122 insertions(+), 58 deletions(-)
 create mode 100644 game_server/src/scribble_group.rs
 delete mode 100644 game_server/src/test_group.rs

(limited to 'game_server/src/main.rs')

diff --git a/game_server/src/backend_connection.rs b/game_server/src/backend_connection.rs
index ed112d9..e1844ee 100644
--- a/game_server/src/backend_connection.rs
+++ b/game_server/src/backend_connection.rs
@@ -1,7 +1,8 @@
 use reqwest::{Response, Client, Url, UrlError, Error as ReqError};
 use std::sync::mpsc::{Sender, Receiver};
 use std::sync::mpsc;
-use super::server::Token;
+use super::server::{UserId, Token};
+use super::group::GroupId;
 
 pub struct BackendConnection {
     host: String,
@@ -18,10 +19,17 @@ pub enum BackendError {
     BadResponse(Response),
 }
 
-pub type TokenValidity = Result<(), BackendError>;
+pub type TokenValidity = Result<TokenResponse, BackendError>;
 pub type RequestData = Url;
 pub type ResponseResult = Result<Response, ReqError>;
 
+pub struct TokenResponse {
+    pub group_id: GroupId,
+    pub group_type: String,
+    pub group_name: String,
+    pub user_id: UserId,
+}
+
 impl BackendConnection {
     fn run_background(req_rec: Receiver<RequestData>, res_sender: Sender<ResponseResult>) {
         let client = Client::new();
@@ -60,7 +68,14 @@ impl BackendConnection {
         self.request(&location).map_err(|err| BackendError::UrlError(err))?;
         let response = self.get_response().map_err(|err| BackendError::RequestError(err))?;
         if response.status().is_success() {
-            Ok(())
+            // zu Testzwecken werden noch keine JSON-Daten deserialisiert
+            // Dennis Server gibt ja noch nix zurück
+            Ok(TokenResponse {
+                group_id: 12,
+                group_type: "scribble".to_string(),
+                group_name: "Scribble".to_string(),
+                user_id: 420
+            })
         } else if response.status() == reqwest::StatusCode::NOT_FOUND {
             Err(BackendError::InvalidToken)
         } else if response.status().is_client_error() {
diff --git a/game_server/src/group.rs b/game_server/src/group.rs
index 55e4fbf..6356a14 100644
--- a/game_server/src/group.rs
+++ b/game_server/src/group.rs
@@ -1,8 +1,14 @@
+use super::server::{UserId, GameClient};
+
 pub type GroupId = u32;
 
 pub trait Group {
     fn id(&self) -> GroupId;
+    fn group_type(&self) -> String;
     fn name(&self) -> String;
 
-    fn run(&self);
+    fn run(&mut self);
+
+    fn add_client(&mut self, id: UserId, client: GameClient);
+    fn get_client(&self, client_id: UserId) -> Option<&GameClient>;
 }
diff --git a/game_server/src/lobby.rs b/game_server/src/lobby.rs
index fe3bdee..d03bd45 100644
--- a/game_server/src/lobby.rs
+++ b/game_server/src/lobby.rs
@@ -1,23 +1,49 @@
 use std::collections::HashMap;
 
 use super::group::{Group, GroupId};
+use super::scribble_group::ScribbleGroup;
+
+use super::server::{UserId, GameClient};
 
 pub struct Lobby {
     groups: HashMap<GroupId, Box<Group>>,
 }
 
 impl Lobby {
-    pub fn new() -> Lobby {
+    pub fn new() -> Self {
         Self {
             groups: HashMap::new(),
         }
     }
 
+    fn generate_group(group_type: &str, id: GroupId, name: &str) -> Option<Box<Group>> {
+        match group_type {
+            "scribble" => {
+                Some(Box::new(ScribbleGroup::new(id, name.to_string())))
+            },
+            other => None,
+        }
+    }
+
     pub fn add_group(&mut self, group: Box<Group>) {
         self.groups.insert(group.id(), group);
     }
 
-    pub fn iter<'a>(&'a self) -> GroupIterator<'a> {
+    pub fn add_client(&mut self, group_type: &str, group_id: GroupId, group_name: &str,
+                   user_id: UserId, client: GameClient) {
+        if !self.groups.contains_key(&group_id) {
+            let mut group = match Self::generate_group(group_type, group_id, group_name) {
+                    Some(x) => x,
+                    _ => return,
+            };
+            group.run();
+            self.groups.insert(group_id, group);
+        }
+        let group = self.groups.get_mut(&group_id).unwrap();
+        group.add_client(user_id, client);
+    }
+
+    pub fn iter<'b>(&'b self) -> GroupIterator<'b> {
         GroupIterator { groups: self.groups.values() }
     }
 }
diff --git a/game_server/src/main.rs b/game_server/src/main.rs
index 628062e..8ff8f97 100644
--- a/game_server/src/main.rs
+++ b/game_server/src/main.rs
@@ -1,5 +1,5 @@
 mod group;
-mod test_group;
+mod scribble_group;
 mod lobby;
 mod server;
 mod backend_connection;
@@ -13,7 +13,7 @@ fn main() {
 
     let addr = ("127.0.0.1", 5001);
     info!("create game server on {:?}", addr);
-    let gameserver = server::GameServer::new(addr);
+    let mut gameserver = server::GameServer::new(addr);
     gameserver.run().unwrap();
 
 }
diff --git a/game_server/src/scribble_group.rs b/game_server/src/scribble_group.rs
new file mode 100644
index 0000000..c240264
--- /dev/null
+++ b/game_server/src/scribble_group.rs
@@ -0,0 +1,42 @@
+use super::group::{Group, GroupId};
+use super::server::{UserId, GameClient};
+use std::collections::HashMap;
+
+pub struct ScribbleGroup {
+    id: GroupId,
+    name: String,
+    clients: HashMap<UserId, GameClient>
+}
+
+impl Group for ScribbleGroup {
+    fn id(&self) -> GroupId {
+        self.id
+    }
+
+    fn group_type(&self) -> String {
+        "scribble".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) {
+        debug!("user {} joined the group {}:'{}'", id, self.id, self.name);
+        self.clients.insert(id, client);
+    }
+
+    fn get_client(&self, client_id: UserId) -> Option<&GameClient> {
+        self.clients.get(&client_id)
+    }
+}
+
+impl ScribbleGroup {
+    pub fn new(id: GroupId, name: String) -> Self {
+        Self { id, name, clients: HashMap::new() }
+    }
+}
diff --git a/game_server/src/server.rs b/game_server/src/server.rs
index 7a9c5b0..c87594b 100644
--- a/game_server/src/server.rs
+++ b/game_server/src/server.rs
@@ -14,6 +14,7 @@ use super::backend_connection::BackendConnection;
 const PROTOCOL: &str = "tuesday";
 
 pub type Token = u32;
+pub type UserId = u32;
 
 #[derive(Debug)]
 pub enum GameServerError {
@@ -26,8 +27,7 @@ pub enum GameServerError {
 pub struct GameServer {
     addr: SocketAddr,
     lobby: Lobby,
-    backend: Arc<Mutex<BackendConnection>>,
-    clients: Arc<Mutex<HashMap<Token, GameClient>>>,
+    backend: BackendConnection,
 }
 
 pub struct GameClient {
@@ -73,13 +73,12 @@ impl GameServer {
         info!("got a C# backend connection");
         GameServer {
             addr,
-            lobby,
-            backend: Arc::new(Mutex::new(backend)),
-            clients: Arc::new(Mutex::new(HashMap::new())),
+            lobby: lobby,
+            backend: backend,
         }
     }
 
-    pub fn run(&self) -> Result<(), GameServerError> {
+    pub fn run(&mut self) -> Result<(), GameServerError> {
         let reader = self.read_clients();
         loop {
             let connection = reader.recv().unwrap()?;
@@ -87,25 +86,29 @@ impl GameServer {
         }
     }
 
-    fn add_client(&self, mut client: GameClient) {
-        let clients = Arc::clone(&self.clients);
-        let backend = Arc::clone(&self.backend);
-        std::thread::spawn(move || {
-            let token = client.require_token();
-            if let Some(token) = token {
-                let locked_backend = backend.lock().unwrap();
-                let result = locked_backend.validate_token(&token);
-                if let Err(err) = result {
-                    warn!("client's token {} is not valid: '{:?}'", token, err);
-                } else {
+    fn add_client(&mut self, mut client: GameClient) {
+        let token = client.require_token();
+        if let Some(token) = token {
+            let result = self.backend.validate_token(&token);
+            match result {
+                Err(err) => warn!("client's token {} is not valid: '{:?}'",
+                                  token, err),
+                Ok(result) => {
                     debug!("client validation was successfull");
-                    debug!("add client: ({}, {})", token, client.host_name());
-                    clients.lock().unwrap().insert(token, client);
+                    let user_id = result.user_id;
+                    let group_id = result.group_id;
+                    let group_type = result.group_type;
+                    let group_name = result.group_name;
+                    debug!("add client: (id:{}, token:{}, host:{}) to \"{}\"",
+                        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);
                 }
-            } else {
-                warn!("client sent invalid token");
             }
-        });
+        } else {
+            warn!("client sent invalid token");
+        }
     }
 
     fn read_clients(&self) -> Receiver<ClientConnection> {
diff --git a/game_server/src/test_group.rs b/game_server/src/test_group.rs
deleted file mode 100644
index bd570e3..0000000
--- a/game_server/src/test_group.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-use super::group::{Group, GroupId};
-
-pub struct TestGroup {
-    id: GroupId,
-    name: String,
-}
-
-impl Group for TestGroup {
-    fn id(&self) -> GroupId {
-        self.id
-    }
-
-    fn name(&self) -> String {
-        self.name.clone()
-    }
-
-    fn run(&self) {
-        let id = self.id;
-        let name = self.name.to_owned();
-        std::thread::spawn(move || /*loop { println!("> group nr.{} wishes you: '{}'", id, name) }*/());
-    }
-}
-
-impl TestGroup {
-    pub fn new(id: GroupId, name: String) -> Self {
-        TestGroup { id, name }
-    }
-}
-- 
cgit v1.2.3-54-g00ecf


From c7bc91ecd6c32afab52c5e45b569e3945bdd1056 Mon Sep 17 00:00:00 2001
From: natrixaeria <janng@gmx.de>
Date: Mon, 20 May 2019 18:27:26 +0200
Subject: Broadcast all text packets around clients

---
 game_server/src/backend_connection.rs |  7 +++++--
 game_server/src/group.rs              |  1 -
 game_server/src/main.rs               |  2 +-
 game_server/src/scribble_group.rs     | 29 +++++++++++++++++++++--------
 game_server/src/server.rs             | 15 ++++++++++++---
 game_server/src/ws_test.html          |  7 ++++++-
 6 files changed, 45 insertions(+), 16 deletions(-)

(limited to 'game_server/src/main.rs')

diff --git a/game_server/src/backend_connection.rs b/game_server/src/backend_connection.rs
index e1844ee..d32c58e 100644
--- a/game_server/src/backend_connection.rs
+++ b/game_server/src/backend_connection.rs
@@ -8,6 +8,7 @@ pub struct BackendConnection {
     host: String,
     req_sender: Sender<RequestData>,
     res_rec: Receiver<ResponseResult>,
+    max_uid: u32,
 }
 
 #[derive(Debug)]
@@ -52,6 +53,7 @@ impl BackendConnection {
             host: host.to_string(),
             req_sender,
             res_rec,
+            max_uid: 420,
         }
     }
 
@@ -63,18 +65,19 @@ impl BackendConnection {
         self.res_rec.recv().unwrap()
     }
     
-    pub fn validate_token(&self, token: &Token) -> TokenValidity {
+    pub fn validate_token(&mut self, token: &Token) -> TokenValidity {
         let location = format!("/api/lobby/tokens/{}", token);
         self.request(&location).map_err(|err| BackendError::UrlError(err))?;
         let response = self.get_response().map_err(|err| BackendError::RequestError(err))?;
         if response.status().is_success() {
             // zu Testzwecken werden noch keine JSON-Daten deserialisiert
             // Dennis Server gibt ja noch nix zurück
+            self.max_uid += 1;
             Ok(TokenResponse {
                 group_id: 12,
                 group_type: "scribble".to_string(),
                 group_name: "Scribble".to_string(),
-                user_id: 420
+                user_id: self.max_uid - 1,
             })
         } else if response.status() == reqwest::StatusCode::NOT_FOUND {
             Err(BackendError::InvalidToken)
diff --git a/game_server/src/group.rs b/game_server/src/group.rs
index 6356a14..fcda12a 100644
--- a/game_server/src/group.rs
+++ b/game_server/src/group.rs
@@ -10,5 +10,4 @@ pub trait Group {
     fn run(&mut self);
 
     fn add_client(&mut self, id: UserId, client: GameClient);
-    fn get_client(&self, client_id: UserId) -> Option<&GameClient>;
 }
diff --git a/game_server/src/main.rs b/game_server/src/main.rs
index 8ff8f97..ab73a97 100644
--- a/game_server/src/main.rs
+++ b/game_server/src/main.rs
@@ -11,7 +11,7 @@ mod game_logger;
 fn main() {
     game_logger::init_logger();
 
-    let addr = ("127.0.0.1", 5001);
+    let addr = ("0.0.0.0", 5001);
     info!("create game server on {:?}", addr);
     let mut gameserver = server::GameServer::new(addr);
     gameserver.run().unwrap();
diff --git a/game_server/src/scribble_group.rs b/game_server/src/scribble_group.rs
index c240264..e68c6df 100644
--- a/game_server/src/scribble_group.rs
+++ b/game_server/src/scribble_group.rs
@@ -1,11 +1,13 @@
 use super::group::{Group, GroupId};
-use super::server::{UserId, GameClient};
+use super::server::{UserId, GameClient,
+                    ClientSender, ClientReceiver};
 use std::collections::HashMap;
+use std::sync::{Arc, Mutex};
 
 pub struct ScribbleGroup {
     id: GroupId,
     name: String,
-    clients: HashMap<UserId, GameClient>
+    senders: Arc<Mutex<HashMap<UserId, ClientSender>>>
 }
 
 impl Group for ScribbleGroup {
@@ -27,16 +29,27 @@ impl Group for ScribbleGroup {
 
     fn add_client(&mut self, id: UserId, client: GameClient) {
         debug!("user {} joined the group {}:'{}'", id, self.id, self.name);
-        self.clients.insert(id, client);
-    }
-
-    fn get_client(&self, client_id: UserId) -> Option<&GameClient> {
-        self.clients.get(&client_id)
+        let (sen, mut rec) = client.split();
+        self.senders.lock().unwrap().insert(id, sen);
+        let senders_mutex = self.senders.clone();
+        let self_uid = id;
+        std::thread::spawn(move || {
+            loop {
+                let message = rec.recv_message().unwrap();
+                info!("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);
+                    }
+                }
+            }
+        });
     }
 }
 
 impl ScribbleGroup {
     pub fn new(id: GroupId, name: String) -> Self {
-        Self { id, name, clients: HashMap::new() }
+        Self { id, name, senders: Arc::new(Mutex::new(HashMap::new())) }
     }
 }
diff --git a/game_server/src/server.rs b/game_server/src/server.rs
index c87594b..6294e2c 100644
--- a/game_server/src/server.rs
+++ b/game_server/src/server.rs
@@ -1,16 +1,20 @@
 use websocket::{OwnedMessage,
+    stream::sync::Splittable,
     sync::Server,
     client::sync::Client,
     server::{NoTlsAcceptor,
-        sync::AcceptResult}};
+        sync::AcceptResult},
+    receiver, sender};
 use std::net::{SocketAddr, ToSocketAddrs, TcpStream};
 use std::sync::{mpsc,
-                mpsc::{Sender, Receiver},
-                Arc, Mutex};
+                mpsc::{Sender, Receiver}};
 use std::collections::HashMap;
 use super::lobby::Lobby;
 use super::backend_connection::BackendConnection;
 
+pub type ClientReceiver = receiver::Reader<<TcpStream as Splittable>::Reader>;
+pub type ClientSender = sender::Writer<<TcpStream as Splittable>::Writer>;
+
 const PROTOCOL: &str = "tuesday";
 
 pub type Token = u32;
@@ -59,6 +63,11 @@ impl GameClient {
     fn host_name(&self) -> SocketAddr {
         self.addr
     }
+
+    pub fn split(self) -> (ClientSender, ClientReceiver) {
+        let (mut rec, mut sen) = self.client.split().unwrap();
+        (sen, rec)
+    }
 }
 
 type ClientConnection = Result<GameClient, GameServerError>;
diff --git a/game_server/src/ws_test.html b/game_server/src/ws_test.html
index f802327..ee60b65 100644
--- a/game_server/src/ws_test.html
+++ b/game_server/src/ws_test.html
@@ -12,6 +12,7 @@
         <div id='cons'>connected</div><br>
         <button onclick='test_connection()'>Launch</button><br>
         <span>Server address: </span><input id='addr'></input>
+        <span>Message</span><input id='msg'></input><button onclick='send_text()'>Send</button>
         <div id='chat' style='background: rgb(20, 20, 20); padding-left: 20px; margin: 40px' />
     </body>
     <script>
@@ -22,7 +23,7 @@ function get_addr() {
 function test_connection() {
     let a = 'ws://' + get_addr();
     add_text('create a new connection at "' + a + '"');
-    const ws = new WebSocket(a, 'tuesday');
+    ws = new WebSocket(a, 'tuesday');
     ws.addEventListener('open', function (event) {
         add_text('connection established');
         toggle_connected(true);
@@ -42,6 +43,10 @@ function test_connection() {
     });
 }
 
+function send_text() {
+    ws.send(document.getElementById('msg').value);
+}
+
 function add_text(text, color='white') {
     let c = document.getElementById('chat');
     let n = document.createElement('span');
-- 
cgit v1.2.3-54-g00ecf


From 79db730d4e42ce592af753059422410979ff26b0 Mon Sep 17 00:00:00 2001
From: Dennis Kobert <d-kobert@web.de>
Date: Fri, 31 May 2019 14:53:37 +0200
Subject: tart implementing game logic

---
 game_server/src/collide.rs        |  36 +++++++++++
 game_server/src/main.rs           |   7 +++
 game_server/src/maths.rs          | 123 ++++++++++++++++++++++++++++++++++++++
 game_server/src/webhogg_game.rs   |  13 ++++
 game_server/src/webhogg_group.rs  |  71 ++++++++++++++++++++++
 game_server/src/webhogg_player.rs |   3 +
 6 files changed, 253 insertions(+)
 create mode 100644 game_server/src/collide.rs
 create mode 100644 game_server/src/maths.rs
 create mode 100644 game_server/src/webhogg_game.rs
 create mode 100644 game_server/src/webhogg_group.rs
 create mode 100644 game_server/src/webhogg_player.rs

(limited to 'game_server/src/main.rs')

diff --git a/game_server/src/collide.rs b/game_server/src/collide.rs
new file mode 100644
index 0000000..4169787
--- /dev/null
+++ b/game_server/src/collide.rs
@@ -0,0 +1,36 @@
+pub trait Collide<Rhs> {
+    fn collides(&self, other: &Rhs) -> bool;
+}
+
+impl Collide<Vec2> for Vec2 {
+    fn collides(self, other: Self) {
+        self == other
+    }
+}
+
+impl Collide<Vec2> for Box {
+    fn collides(self, other: Vec2) {
+        self.pos < other < self.pos + self.size 
+    }
+}
+
+impl Collide<Box> for Box {
+    fn collides(self, other: Self) {
+        self.collides(other.pos) 
+        || other.collides(self.pos) 
+    }
+}
+
+impl Collide<Vec2> for RBox {
+    fn collides(self, other: Vec2) {
+         
+        || other.pos < self.pos < other.pos + other.size 
+    }
+}
+
+impl Collide<Box> for Box {
+    fn collides(self, other: Self) {
+        self.pos < other.pos < self.pos + self.size 
+        || other.pos < self.pos < other.pos + other.size 
+    }
+}
diff --git a/game_server/src/main.rs b/game_server/src/main.rs
index ab73a97..e10fe3c 100644
--- a/game_server/src/main.rs
+++ b/game_server/src/main.rs
@@ -1,5 +1,12 @@
 mod group;
+mod maths;
 mod scribble_group;
+<<<<<<< Updated upstream
+=======
+mod webhogg_group;
+mod webhogg_game;
+mod collide;
+>>>>>>> Stashed changes
 mod lobby;
 mod server;
 mod backend_connection;
diff --git a/game_server/src/maths.rs b/game_server/src/maths.rs
new file mode 100644
index 0000000..8844c6e
--- /dev/null
+++ b/game_server/src/maths.rs
@@ -0,0 +1,123 @@
+#[derive(Clone, Copy)]
+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: self.x + other.x,
+            y: self.y + other.y
+        }
+    }
+}
+
+impl std::ops::Sub for Vec2 {
+    type Output = Self;
+    fn sub(self, other: Self) -> Self {
+        Self {
+            x: self.x - other.x,
+            y: self.y - other.y
+        }
+    }
+}
+
+impl std::ops::Neg for Vec2 {
+    type Output = Self;
+    fn neg(self) -> Self {
+        Self {
+            x: -self.x,
+            y: -self.y
+        }
+    }
+}
+
+impl std::cmp::PartialOrd for Vec2 {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        Some(if self.x < other.x && self.y < other.y {
+            std::cmp::Ordering::Less
+        } else if self.x > other.x && self.y > other.y {
+            std::cmp::Ordering::Greater
+        } else {
+            std::cmp::Ordering::Equal
+        })
+    }
+}
+
+impl std::cmp::PartialEq for Vec2 {
+    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
+    }
+}
+
+pub struct Box {
+    pub pos: Vec2,
+    /// the size may not be smaller than zero
+    pub size: Vec2, 
+}
+
+impl std::ops::Add<Vec2> for Box {
+    type Output = Self;
+    fn add(self, other: Vec2) -> Self {
+        Self {
+            p1: self.p1 + other,
+            p2: self.p2 + other,
+        }
+    }
+}
+
+impl std::ops::Sub<Vec2> for Box {
+    type Output = Self;
+    fn sub(self, other: Vec2) -> Self {
+        Self {
+            pos: self.pos + other,
+            size: self.size + other
+        }
+    }
+}
+
+pub struct RBox {
+    /// Point 1
+    pub p1: Vec2,
+    /// Point 2
+    pub p2: Vec2, 
+    /// Width
+    pub w: f32,
+}
+
+impl std::ops::Add<Vec2> for RBox {
+    type Output = Self;
+    fn add(self, other: Vec2) -> Self {
+        Self {
+            p1: self.p1 + other,
+            p2: self.p2 + other,
+            w: self.w,
+        }
+    }
+}
+
+impl std::ops::Sub<Vec2> for RBox {
+    type Output = Self;
+    fn sub(self, other: Vec2) -> Self {
+        Self {
+            p1: self.p1 + other,
+            p2: self.p2 + other,
+            w: self.w,
+        }
+    }
+}
diff --git a/game_server/src/webhogg_game.rs b/game_server/src/webhogg_game.rs
new file mode 100644
index 0000000..7b94fcb
--- /dev/null
+++ b/game_server/src/webhogg_game.rs
@@ -0,0 +1,13 @@
+use crate::maths::Vec2;
+
+pub struct WebhoggPlayer {
+    pos: Vec2,
+}
+
+pub struct WebhoggGame {
+    player1: WebhoggPlayer,
+    player2: WebhoggPlayer,
+}
+
+impl WebhoggGame {
+}
diff --git a/game_server/src/webhogg_group.rs b/game_server/src/webhogg_group.rs
new file mode 100644
index 0000000..5a326d8
--- /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<Mutex<HashMap<UserId, ClientSender>>>
+}
+
+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::launch_game(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 launch_game(self_uid: UserId, mut rec: ClientReceiver, senders_mutex: Arc<Mutex<HashMap<UserId, ClientSender>>>) {
+        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);
+    }
+}
diff --git a/game_server/src/webhogg_player.rs b/game_server/src/webhogg_player.rs
new file mode 100644
index 0000000..38b9596
--- /dev/null
+++ b/game_server/src/webhogg_player.rs
@@ -0,0 +1,3 @@
+pub struct WebhoggPlayer {
+
+}
-- 
cgit v1.2.3-54-g00ecf


From 4cdb0d88a065df2456b3e12389836eebc9b2fa4a Mon Sep 17 00:00:00 2001
From: Dennis Kobert <d-kobert@web.de>
Date: Fri, 31 May 2019 16:40:00 +0200
Subject: Fix issues in Collide

---
 game_server/src/collide.rs | 63 ++++++++++++++++++++++++++++++++++++----------
 game_server/src/main.rs    |  3 ---
 game_server/src/maths.rs   | 14 +++++------
 3 files changed, 57 insertions(+), 23 deletions(-)

(limited to 'game_server/src/main.rs')

diff --git a/game_server/src/collide.rs b/game_server/src/collide.rs
index 4169787..4217e7f 100644
--- a/game_server/src/collide.rs
+++ b/game_server/src/collide.rs
@@ -1,36 +1,73 @@
+use crate::maths::{Vec2, Box, RBox};
+
 pub trait Collide<Rhs> {
     fn collides(&self, other: &Rhs) -> bool;
 }
 
 impl Collide<Vec2> for Vec2 {
-    fn collides(self, other: Self) {
+    fn collides(&self, other: &Self) -> bool {
         self == other
     }
 }
 
 impl Collide<Vec2> for Box {
-    fn collides(self, other: Vec2) {
-        self.pos < other < self.pos + self.size 
+    fn collides(&self, other: &Vec2) -> bool {
+        self.pos < other && other < self.pos + self.size 
     }
 }
 
 impl Collide<Box> for Box {
-    fn collides(self, other: Self) {
-        self.collides(other.pos) 
-        || other.collides(self.pos) 
+    fn collides(&self, other: &Self) -> bool {
+        self.collides(other.pos)
+        || self.collides(other.pos + Vec2{x: other.x, y: 0})
+        || self.collides(other.pos + Vec2{x: 0, y: other.y})
+        || self.collides(other.pos + other.size)
+
+        || other.collides(self.pos)
+        || other.collides(self.pos + Vec2{x: self.x, y: 0})
+        || other.collides(self.pos + Vec2{x: 0, y: self.y})
+        || other.collides(self.pos + self.size)
     }
 }
 
 impl Collide<Vec2> for RBox {
-    fn collides(self, other: Vec2) {
-         
-        || other.pos < self.pos < other.pos + other.size 
+    fn collides(&self, other: &Vec2) -> bool {
+        let dx = self.size.x;
+        let dy = self.size.y;
+        let len = f32::sqrt(dx*dx+dy*dy);
+        dx /= len;
+        dy /= len;
+
+        let dax = other.x - self.p1.x;
+        let day = other.y - self.p1.y;
+        
+        let dot = dax * dx + day * dy;
+        let px = self.pos.x + dx * dot;
+        let py = self.pos.y + dy * dot;
+       
+        if !(self.pos < px && px < self.pos + self.size) {
+            return false; 
+        } 
+
+        let ddx = other.x-px; 
+        let ddy = other.y-py;
+        let manhattenDistance = ddx + ddy;
+
+        manhattenDistance < self.w 
     }
 }
 
-impl Collide<Box> for Box {
-    fn collides(self, other: Self) {
-        self.pos < other.pos < self.pos + self.size 
-        || other.pos < self.pos < other.pos + other.size 
+impl Collide<Box> for RBox {
+    fn collides(&self, other: &Box) -> bool {
+        self.collides(other.pos)
+        || self.collides(other.pos + Vec2{x: other.x, y: 0})
+        || self.collides(other.pos + Vec2{x: 0, y: other.y})
+        || self.collides(other.pos + other.size)
+        
+        || other.collides(self.pos)
+        || other.collides(self.pos + Vec2{x: self.x, y: 0})
+        || other.collides(self.pos + Vec2{x: 0, y: self.y})
+        || other.collides(self.pos + self.size)
+        
     }
 }
diff --git a/game_server/src/main.rs b/game_server/src/main.rs
index e10fe3c..cfd9787 100644
--- a/game_server/src/main.rs
+++ b/game_server/src/main.rs
@@ -1,12 +1,9 @@
 mod group;
 mod maths;
 mod scribble_group;
-<<<<<<< Updated upstream
-=======
 mod webhogg_group;
 mod webhogg_game;
 mod collide;
->>>>>>> Stashed changes
 mod lobby;
 mod server;
 mod backend_connection;
diff --git a/game_server/src/maths.rs b/game_server/src/maths.rs
index 8844c6e..a55c5ce 100644
--- a/game_server/src/maths.rs
+++ b/game_server/src/maths.rs
@@ -93,10 +93,10 @@ impl std::ops::Sub<Vec2> for Box {
 
 pub struct RBox {
     /// Point 1
-    pub p1: Vec2,
+    pub pos: Vec2,
     /// Point 2
-    pub p2: Vec2, 
-    /// Width
+    pub size: Vec2, 
+    /// Width Attention manhatten distance!!!
     pub w: f32,
 }
 
@@ -104,8 +104,8 @@ impl std::ops::Add<Vec2> for RBox {
     type Output = Self;
     fn add(self, other: Vec2) -> Self {
         Self {
-            p1: self.p1 + other,
-            p2: self.p2 + other,
+            pos: self.p1 + other,
+            size: self.p2 + other,
             w: self.w,
         }
     }
@@ -115,8 +115,8 @@ impl std::ops::Sub<Vec2> for RBox {
     type Output = Self;
     fn sub(self, other: Vec2) -> Self {
         Self {
-            p1: self.p1 + other,
-            p2: self.p2 + other,
+            pos: self.p1 + other,
+            size: self.p2 + other,
             w: self.w,
         }
     }
-- 
cgit v1.2.3-54-g00ecf