Merge pull request #18 from SemvdH/feature/test/gameCommands

Feature/test/game commands

Client/Client.cs

@@ -2,22 +2,55 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.IO;
 using System.Net.Sockets;
 using System.Text;
+using System.Windows.Media;
+using System.Windows;
+
+using static SharedClientServer.JSONConvert;
 
 namespace Client
 {
+    public delegate void LobbyJoinCallback(bool isHost);
+
+    public delegate void RandomWord(string word);
+    public delegate void HandleIncomingMsg(string username, string msg);
+    internal delegate void HandleIncomingPlayer(Lobby lobby);
+    public delegate void CanvasDataReceived(double[][] coordinates, Color color);
+    public delegate void CanvasReset();
+    public delegate void LobbyCallback(int id);
+
+
     class Client : ObservableObject
     {
+
+        private ClientData clientData = ClientData.Instance;
+
         private TcpClient tcpClient;
         private NetworkStream stream;
-        private byte[] buffer = new byte[1024];
-        private byte[] totalBuffer = new byte[1024];
+        private byte[] buffer = new byte[2048];
+        private byte[] totalBuffer = new byte[2048];
         private int totalBufferReceived = 0;
         public int Port = 5555;
         public bool Connected = false;
         private string username;
         public Callback OnSuccessfullConnect;
+        public Callback OnLobbiesListReceived;
+        public LobbyJoinCallback OnLobbyJoinSuccess;
+        public Callback OnLobbiesReceivedAndWaitingForHost;
+        public Callback OnServerDisconnect;
+        public Callback OnLobbyUpdate;
+        public LobbyCallback OnLobbyCreated;
+        public LobbyCallback OnLobbyLeave;
+        public RandomWord RandomWord;
+        public HandleIncomingMsg IncomingMsg;
+        public HandleIncomingPlayer IncomingPlayer;
+        private ClientData data = ClientData.Instance;
+        public CanvasDataReceived CanvasDataReceived;
+        public CanvasReset CReset;
+        public HandleIncomingPlayer UpdateUserScores;
+        public Lobby[] Lobbies { get; set; }
 
         public Client(string username)
         {
@@ -30,48 +63,73 @@ namespace Client
         private void OnConnect(IAsyncResult ar)
         {
             Debug.Write("finished connecting to server");
-            this.tcpClient.EndConnect(ar);
-            this.stream = tcpClient.GetStream();
-            OnSuccessfullConnect?.Invoke();
-            SendMessage(JSONConvert.ConstructUsernameMessage(username));
-            this.stream.BeginRead(buffer, 0, buffer.Length, new AsyncCallback(OnReadComplete),null);
+            try
+            {
+                this.tcpClient.EndConnect(ar);
+                this.stream = tcpClient.GetStream();
+                OnSuccessfullConnect?.Invoke();
+                OnLobbyUpdate = updateGameLobby;
+                SendMessage(JSONConvert.ConstructUsernameMessage(username));
+                this.stream.BeginRead(buffer, 0, buffer.Length, new AsyncCallback(OnReadComplete), null);
+
+            }
+            catch (Exception e)
+            {
+                Debug.WriteLine("Can't connect, retrying...");
+                tcpClient.BeginConnect("localhost", Port, new AsyncCallback(OnConnect), null);
+            }
         }
 
         private void OnReadComplete(IAsyncResult ar)
         {
-            int amountReceived = stream.EndRead(ar);
 
-            if (totalBufferReceived + amountReceived > 1024)
+            if (ar == null || (!ar.IsCompleted) || (!this.stream.CanRead) || !this.tcpClient.Client.Connected)
+                return;
+
+            try
             {
-                throw new OutOfMemoryException("buffer too small");
+                int amountReceived = stream.EndRead(ar);
+
+                if (totalBufferReceived + amountReceived > 2048)
+                {
+                    throw new OutOfMemoryException("buffer too small");
+                }
+
+                Array.Copy(buffer, 0, totalBuffer, totalBufferReceived, amountReceived);
+                totalBufferReceived += amountReceived;
+
+                int expectedMessageLength = BitConverter.ToInt32(totalBuffer, 0);
+
+                while (totalBufferReceived >= expectedMessageLength)
+                {
+                    // we have received the complete packet
+                    byte[] message = new byte[expectedMessageLength];
+                    // put the message received into the message array
+                    Array.Copy(totalBuffer, 0, message, 0, expectedMessageLength);
+                    handleData(message);
+
+                    totalBufferReceived -= expectedMessageLength;
+                    expectedMessageLength = BitConverter.ToInt32(totalBuffer, 0);
+                }
+
+                ar.AsyncWaitHandle.WaitOne();
+                stream.BeginRead(buffer, 0, buffer.Length, new AsyncCallback(OnReadComplete), null);
             }
-
-            Array.Copy(buffer, 0, totalBuffer, totalBufferReceived, amountReceived);
-            totalBufferReceived += amountReceived;
-
-            int expectedMessageLength = BitConverter.ToInt32(totalBuffer, 0);
-
-            while (totalBufferReceived >= expectedMessageLength)
+            catch (IOException e)
             {
-                // we have received the complete packet
-                byte[] message = new byte[expectedMessageLength];
-                // put the message received into the message array
-                Array.Copy(totalBuffer, 0, message, 0, expectedMessageLength);
-
-                handleData(message);
-
-                totalBufferReceived -= expectedMessageLength;
-                expectedMessageLength = BitConverter.ToInt32(totalBuffer, 0);
+                Debug.WriteLine("[CLIENT] server not responding! got error: " + e.Message);
+                OnServerDisconnect?.Invoke();
             }
-
-            stream.BeginRead(buffer, 0, buffer.Length, new AsyncCallback(OnReadComplete), null);
         }
 
         private void handleData(byte[] message)
         {
             byte id = message[4];
-            byte[] payload = new byte[message.Length - 1];
-            Array.Copy(message, 1, payload, 0, message.Length - 1);
+
+            byte[] payload = new byte[message.Length - 5];
+            Array.Copy(message, 5, payload, 0, message.Length - 5);
+
+            Debug.WriteLine("[CLIENT] GOT STRING" + Encoding.ASCII.GetString(payload));
             switch (id)
             {
                 case JSONConvert.LOGIN:
@@ -83,6 +141,16 @@ namespace Client
                     string textUsername = combo.Item1;
                     string textMsg = combo.Item2;
 
+                    if (textUsername != data.User.Username)
+                    {
+                        IncomingMsg?.Invoke(textUsername, textMsg);
+                    }
+
+                    if (textMsg == data.User.RandomWord && !string.IsNullOrEmpty(data.User.RandomWord))
+                    {
+                        Debug.WriteLine($"[CLIENT] word has been guessed! {data.User.Username} + Word: {data.User.RandomWord}");
+                    }
+
                     //TODO display username and message in chat window
                     Debug.WriteLine("[CLIENT] INCOMING MESSAGE!");
                     Debug.WriteLine("[CLIENT] User name: {0}\t User message: {1}", textUsername, textMsg);
@@ -90,20 +158,97 @@ namespace Client
 
                 case JSONConvert.LOBBY:
                     // lobby data
+                    LobbyIdentifier lobbyIdentifier = JSONConvert.GetLobbyIdentifier(payload);
+                    switch (lobbyIdentifier)
+                    {
+                        case LobbyIdentifier.LIST:
+                            Debug.WriteLine("got lobbies list");
+                            Lobbies = JSONConvert.GetLobbiesFromMessage(payload);
+                            OnLobbiesListReceived?.Invoke();
+                            OnLobbiesReceivedAndWaitingForHost?.Invoke();
+                            OnLobbyUpdate?.Invoke();
+                            break;
+                        case LobbyIdentifier.HOST:
+                            // we receive this when the server has made us a host of a new lobby
+                            // TODO get lobby id 
+                            Debug.WriteLine("[CLIENT] got lobby object");
+                            int lobbyCreatedID = JSONConvert.GetLobbyID(payload);
+                            OnLobbyCreated?.Invoke(lobbyCreatedID);
+                            break;
+                        case LobbyIdentifier.JOIN_SUCCESS:
+                            OnLobbyJoinSuccess?.Invoke(JSONConvert.GetLobbyJoinIsHost(payload));
+                            break;
+                        case LobbyIdentifier.LEAVE:
+                            int lobbyLeaveID = JSONConvert.GetLobbyID(payload);
+                            OnLobbyLeave?.Invoke(lobbyLeaveID);
+                            break;
+                    }
                     //TODO fill lobby with the data received
                     break;
 
                 case JSONConvert.CANVAS:
                     // canvas data
+                    //clientData.CanvasData = JSONConvert.getCoordinates(payload);         
+                    int type = JSONConvert.GetCanvasMessageType(payload);
+                    switch (type)
+                    {
+                        case JSONConvert.CANVAS_RESET:
+                            CReset?.Invoke();
+                            break;
+
+                        case JSONConvert.CANVAS_WRITING:
+                            CanvasDataReceived?.Invoke(JSONConvert.getCoordinates(payload), JSONConvert.getCanvasDrawingColor(payload));
+                            break;
+                    }
+                    break;
+
+                case JSONConvert.RANDOMWORD:
+                    //Flag byte for receiving the random word.
+                    int lobbyId = JSONConvert.GetLobbyID(payload);
+                    data.User.RandomWord = JSONConvert.GetRandomWord(payload);
+                    data.User.TurnToDraw = true; // Dit is test code, dit kan weg zodra alles lopende is.
+                    if (data.Lobby?.ID == lobbyId && data.User.TurnToDraw)
+                        RandomWord?.Invoke(data.User.RandomWord);
                     break;
 
                 default:
                     Debug.WriteLine("[CLIENT] Received weird identifier: " + id);
                     break;
+                case JSONConvert.GAME:
+                    switch (JSONConvert.GetGameCommand(payload))
+                    {
+                        case JSONConvert.GameCommand.TIMER_ELAPSED:
+                            int lobbyElapsedID = JSONConvert.GetLobbyID(payload);
+                            
+                            //todo set next round
+                            break;
+                        
+                    }
+                    break;
             }
+            SendMessage(JSONConvert.GetMessageToSend(JSONConvert.MESSAGE_RECEIVED, null));
 
         }
 
+        /*
+         * Updates the current lobby with the joining players, 
+         * their player score is also tracked and should always be zero.
+         */
+        private void updateGameLobby()
+        {
+            Debug.WriteLine("[CLIENT] updating game lobby");
+            foreach (var item in Lobbies)
+            {
+                Debug.WriteLine("[CLIENT] lobby data: {0}", item.Users.Count);
+                if (item.ID == data.Lobby?.ID)
+                {
+                    //IncomingPlayer?.Invoke(item);
+                    UpdateUserScores?.Invoke(item as Lobby);
+                }
+
+            }
+        }
+
         public void SendMessage(byte[] message)
         {
             Debug.WriteLine("[CLIENT] sending message " + Encoding.ASCII.GetString(message));
@@ -114,6 +259,7 @@ namespace Client
         {
             Debug.WriteLine("[CLIENT] finished writing");
             stream.EndWrite(ar);
+            stream.Flush();
         }
     }
 }

Client/ClientData.cs

@@ -31,6 +31,7 @@ namespace Client
         private Client _client;
         private Lobby _lobby;
         private string _message;
+        private double[] _canvasData = new double[4];
 
         private ClientData()
         {
@@ -68,5 +69,11 @@ namespace Client
             }
         }
 
+        public double[] CanvasData
+        {
+            get { return _canvasData; }
+            set { _canvasData = value; }
+        }
+
     }
 }

Client/ViewModels/LoginViewModel.cs

@@ -0,0 +1,37 @@
+using SharedClientServer;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Windows;
+
+namespace Client.ViewModels
+{
+
+    class LoginViewModel
+    {
+        ClientData data = ClientData.Instance;
+        private Window window;
+
+        public LoginViewModel(Window window)
+        {
+            this.window = window;
+        }
+        public void UsernameEntered(string name) {
+            User user = new User(name);
+
+            Client client = new Client(user.Username);
+            client.OnSuccessfullConnect = () =>
+            {
+                // because we need to start the main window on a UI thread, we need to let the dispatcher handle it, which will execute the code on the ui thread
+                Application.Current.Dispatcher.Invoke(delegate {
+                    data.User = user;
+                    data.Client = client;
+                    client.SendMessage(JSONConvert.ConstructLobbyRequestMessage());
+                    MainWindow startWindow = new MainWindow();
+                    startWindow.Show();
+                    window.Close();
+                });
+            };
+        }
+    }
+}

Client/ViewModels/ViewModel.cs

@@ -9,6 +9,11 @@ using System.Diagnostics;
 using System.Windows;
 using System.Collections.ObjectModel;
 using Client.Views;
+using System.Linq;
+using System.Windows.Data;
+using System.Data;
+using System.Windows.Controls.Primitives;
+using System.Windows.Controls;
 
 namespace Client
 {
@@ -21,21 +26,112 @@ namespace Client
 
         public Lobby SelectedLobby { get; set; }
 
+        private Client client;
+
+        private bool wantToBeHost = false;
+        private int wantToBeHostId = 0;
+
         public ViewModel()
         {
             _model = new Model();
             _lobbies = new ObservableCollection<Lobby>();
-
-            _lobbies.Add(new Lobby(50, 3, 8));
-            _lobbies.Add(new Lobby(69, 1, 9));
-            _lobbies.Add(new Lobby(420, 7, 7));
-
-            OnHostButtonClick = new RelayCommand(() => 
+            client = ClientData.Instance.Client;
+            client.OnLobbiesListReceived = updateLobbies;
+            client.OnLobbyLeave = leaveLobby;
+            client.OnServerDisconnect = () =>
             {
-                Debug.WriteLine("Host button clicked");
-            });
+                Environment.Exit(0);
+            };
+            
 
-            JoinSelectedLobby = new RelayCommand(startGameInLobby, true);
+            OnHostButtonClick = new RelayCommand(hostGame);
+
+            JoinSelectedLobby = new RelayCommand(joinLobby, true);
+        }
+
+        private void leaveLobby(int id)
+        {
+            _model.CanStartGame = true;
+            ClientData.Instance.Lobby = null;
+            SelectedLobby = null;
+        }
+
+        private void hostGame()
+        {
+            Debug.WriteLine("attempting to host game for " + ClientData.Instance.User.Username);
+            client.SendMessage(JSONConvert.ConstructLobbyHostMessage());
+            client.OnLobbyCreated = becomeHostForLobby;
+
+        }
+
+        private void becomeHostForLobby(int id)
+        {
+            Debug.WriteLine($"got host succes with data {id} ");
+            wantToBeHost = true;
+            wantToBeHostId = id;
+            ClientData.Instance.User.Host = true;
+            client.OnLobbiesReceivedAndWaitingForHost = hostLobbiesReceived;
+        }
+
+        private void hostLobbiesReceived()
+        {
+            if (wantToBeHost)
+                foreach (Lobby l in Lobbies)
+                {
+                    if (l.ID == wantToBeHostId)
+                    {
+                        Debug.WriteLine("found lobby that we want to be host of: " + l.ID + ", joining..");
+                        SelectedLobby = l;
+                        startGameInLobby();
+                        wantToBeHost = false;
+                        client.OnLobbiesReceivedAndWaitingForHost = null;
+                        break;
+                    }
+                }
+        }
+
+        private void joinLobby()
+        {
+            if (SelectedLobby != null)
+            {
+                if (SelectedLobby.PlayersIn == SelectedLobby.MaxPlayers || !SelectedLobby.LobbyJoinable)
+                {
+                    return;
+                }
+                client.OnLobbyJoinSuccess = OnLobbyJoinSuccess;
+                client.SendMessage(JSONConvert.ConstructLobbyJoinMessage(SelectedLobby.ID));
+            }
+            
+        }
+
+        private void OnLobbyJoinSuccess(bool isHost)
+        {
+            ClientData.Instance.User.Host = isHost;
+            startGameInLobby();
+        }
+
+
+
+        private void updateLobbies()
+        {
+            Debug.WriteLine("[VIEWMODEL] updating lobbies...");
+            Lobby[] lobbiesArr = client.Lobbies;
+            Application.Current.Dispatcher.Invoke(delegate
+            {
+
+                _lobbies.Clear();
+
+                foreach (Lobby l in lobbiesArr)
+                {
+                    _lobbies.Add(l);
+                    Lobby clientLobby = ClientData.Instance.Lobby;
+                    if (l.ID == clientLobby?.ID)
+                    {
+                        clientLobby = l;
+                    }
+                }
+
+            });
         }
 
         private void startGameInLobby()
@@ -43,11 +139,18 @@ namespace Client
             if (SelectedLobby != null)
             {
                 ClientData.Instance.Lobby = SelectedLobby;
-                
-                _model.CanStartGame = false;
+                startGameWindow();
+            }
+        }
+
+        private void startGameWindow()
+        {
+            _model.CanStartGame = false;
+            Application.Current.Dispatcher.Invoke(delegate
+            {
                 GameWindow window = new GameWindow();
                 window.Show();
-            }
+            });
         }
 
         private void ClickCheck()
@@ -79,5 +182,7 @@ namespace Client
             get { return _lobbies; }
             set { _lobbies = value; }
         }
+
+   
     }
 }

Client/ViewModels/ViewModelGame.cs

@@ -1,23 +1,41 @@
-using GalaSoft.MvvmLight.Command;
+using Client.Views;
+using GalaSoft.MvvmLight.Command;
 using SharedClientServer;
+using System;
+using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.ComponentModel;
 using System.Diagnostics;
-using System.Windows.Input;
+using System.Timers;
+using System.Windows;
+using System.Windows.Input;
+using System.Windows.Media;
+using System.Windows.Shapes;
 
 namespace Client.ViewModels
 {
     class ViewModelGame : INotifyPropertyChanged
     {
-        ClientData data = ClientData.Instance;
         public event PropertyChangedEventHandler PropertyChanged;
-        public ObservableCollection<string> Messages { get; } = new ObservableCollection<string>();
+        private ClientData data = ClientData.Instance;
+        private GameWindow window;
+        private Point currentPoint = new Point();
+        public Color color;
+        public double[][] buffer;
+        public int pos = 0;
+        public int maxLines = 50;
+        public Queue<double[][]> linesQueue;
+        private Timer queueTimer;
+
+        public static ObservableCollection<string> Messages { get; } = new ObservableCollection<string>();
+        public ObservableCollection<string> Players { get; } = new ObservableCollection<string>();
 
         private dynamic _payload;
 
-        private string _username;
-
-        private string _message;
+        public string _username;
+
+
+        public string _message;
         public string Message
         {
             get
@@ -29,22 +47,157 @@ namespace Client.ViewModels
                 _message = value;
             }
         }
-        public ICommand OnKeyDown { get; set; }
 
-        public ViewModelGame()
+        private string _randomWord;
+        public string RandomWord
         {
-            if (_payload == null)
-            {
-                _message = "";
-               
-            }
-            else
-            {
-                //_message = data.Message;
-                //_username = data.User.Username;
-                //Messages.Add($"{data.User.Username}: {Message}");
-            }
+            get { return _randomWord; }
+            set { _randomWord = value; }
+        }
+
+        public bool IsHost
+        {
+            get { return data.User.Host; }
+        }
+
+        public ViewModelGame(GameWindow window)
+        {
+            this.window = window;
+
+            buffer = new double[maxLines][];
+            linesQueue = new Queue<double[][]>();
             OnKeyDown = new RelayCommand(ChatBox_KeyDown);
+            ButtonStartGame = new RelayCommand(BeginGame);
+            ButtonResetCanvas = new RelayCommand(CanvasResetLocal);
+            data.Client.CanvasDataReceived = UpdateCanvasWithNewData;
+            data.Client.CReset = CanvasResetData;
+            data.Client.RandomWord = HandleRandomWord;
+            data.Client.IncomingMsg = HandleIncomingMsg;
+            data.Client.IncomingPlayer = HandleIncomingPlayer;
+            data.Client.UpdateUserScores = UpdateUserScores;
+
+            Application.Current.Dispatcher.Invoke(delegate
+            {
+                Messages.Clear();
+            });
+
+
+                queueTimer = new Timer(50);
+            queueTimer.Start();
+            queueTimer.Elapsed += sendArrayFromQueue;
+        }
+
+        public ICommand OnKeyDown { get; set; }
+        public ICommand ButtonStartGame { get; set; }
+        public ICommand ButtonResetCanvas { get; set; }
+       
+        public void BeginGame()
+        {
+    
+            data.Client.SendMessage(JSONConvert.ConstructGameStartData(data.Lobby.ID));
+        }
+
+
+        private void CanvasResetLocal()
+        {
+            this.window.CanvasForPaint.Children.Clear();
+            data.Client.SendMessage(JSONConvert.ConstructCanvasReset());
+        }
+
+
+        public void Canvas_MouseDown(MouseButtonEventArgs e, GameWindow window)
+        {
+            if (e.ButtonState == MouseButtonState.Pressed)
+            {
+                currentPoint = e.GetPosition(window.CanvasForPaint);
+            }
+        }
+
+        public void Canvas_MouseMove(MouseEventArgs e, GameWindow window)
+        {
+            if (e.LeftButton == MouseButtonState.Pressed)
+            {
+                double[] coordinates = new double[4];
+                Line line = new Line();
+
+                line.Stroke = new SolidColorBrush(color);
+                //line.Stroke = SystemColors.WindowFrameBrush;
+                line.X1 = currentPoint.X;
+                line.Y1 = currentPoint.Y;
+                line.X2 = e.GetPosition(window.CanvasForPaint).X;
+                line.Y2 = e.GetPosition(window.CanvasForPaint).Y;
+                coordinates[0] = line.X1;
+                coordinates[1] = line.Y1;
+                coordinates[2] = line.X2;
+                coordinates[3] = line.Y2;
+                currentPoint = e.GetPosition(window.CanvasForPaint);
+                buffer[pos] = coordinates;
+                pos++;
+
+                window.CanvasForPaint.Children.Add(line);
+                if (pos == maxLines)
+                {
+                    double[][] temp = new double[maxLines][];
+                    for (int i = 0; i < maxLines; i++)
+                    {
+                        temp[i] = buffer[i];
+                    }
+                    linesQueue.Enqueue(temp);
+                    Array.Clear(buffer, 0, buffer.Length);
+                    pos = 0;
+                }
+                
+            }
+        }
+
+        public void Canvas_MouseUp(object sender, MouseButtonEventArgs e)
+        {
+            sendArrayFromQueue(sender, null);
+        }
+
+        private void sendArrayFromQueue(object sender, ElapsedEventArgs e)
+        {
+            
+            if (linesQueue.Count != 0)
+            {
+                double[][] temp = linesQueue.Dequeue();
+                data.Client.SendMessage(JSONConvert.ConstructDrawingCanvasData(temp,color));
+            }
+        }
+
+        public void Color_Picker(RoutedPropertyChangedEventArgs<Color?> e, GameWindow window)
+        {
+            Color colorSelected = new Color();
+            colorSelected.A = 255;
+            colorSelected.R = window.ClrPcker_Background.SelectedColor.Value.R;
+            colorSelected.G = window.ClrPcker_Background.SelectedColor.Value.G;
+            colorSelected.B = window.ClrPcker_Background.SelectedColor.Value.B;
+            color = colorSelected;
+        }
+
+        private void UpdateCanvasWithNewData(double[][] buffer, Color color)
+        {
+            Application.Current.Dispatcher.Invoke(delegate
+            {
+                foreach (double[] arr in buffer)
+                {
+                    Line line = new Line();
+                    line.Stroke = new SolidColorBrush(color);
+                    line.X1 = arr[0];
+                    line.Y1 = arr[1];
+                    line.X2 = arr[2];
+                    line.Y2 = arr[3];
+                    this.window.CanvasForPaint.Children.Add(line);
+                }
+            });
+        }
+
+        private void CanvasResetData()
+        {
+            Application.Current.Dispatcher.Invoke(delegate
+            {
+                this.window.CanvasForPaint.Children.Clear();
+            });
         }
 
         private void ChatBox_KeyDown()
@@ -67,5 +220,63 @@ namespace Client.ViewModels
             //Broadcast the message after adding it to the list!
             data.Client.SendMessage(JSONConvert.GetMessageToSend(JSONConvert.MESSAGE, _payload));
         }
+
+        public void HandleIncomingMsg(string username, string message)
+        {
+            Application.Current.Dispatcher.Invoke(delegate
+            {
+                Messages.Add($"{username}: {message}");
+            });
+        }
+        public void LeaveGame(object sender, System.ComponentModel.CancelEventArgs e)
+        {
+            Debug.WriteLine("Leaving...");
+            data.Client.SendMessage(JSONConvert.ConstructLobbyLeaveMessage(data.Lobby.ID));
+        }
+
+        public void HandleRandomWord(string randomWord)
+        {
+            Debug.WriteLine("[CLIENT] Reached the handle random word method!");
+            Application.Current.Dispatcher.Invoke(delegate
+            {
+                RandomWord = randomWord;
+            });
+        }
+        public void HandleIncomingPlayer(Lobby lobby)
+        {
+            Application.Current.Dispatcher.Invoke(delegate
+            {
+                Players.Clear();
+                foreach (var item in lobby.Users)
+                {
+                    Players.Add(item.Username + "\n" + item.Score);
+                }
+            });
+        }
+
+        private void UpdateUserScores(Lobby newLobby) {
+            Debug.WriteLine("[GAME] updating user scores");
+            List<User> newUsers = newLobby.Users;
+            // go over all users in current lobby
+            foreach (User user in data.Lobby?.Users)
+            {
+                // check with all users in new lobby
+                foreach (User newUser in newUsers)
+                {
+                    // and update the score
+                    if (newUser.Username == user.Username)
+                    {
+                        Debug.WriteLine($"[GAME] setting score of {user.Username} to {newUser.Score}. it was {user.Score}");
+                        user.Score = newUser.Score;
+                        break;
+                    }
+                }
+            }
+
+            // update all the scores in the player list
+            HandleIncomingPlayer(newLobby);
+        }
+
+        
     }
 }

Client/Views/GameWindow.xaml

@@ -3,7 +3,6 @@
         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
         xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
         xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
-        xmlns:local="clr-namespace:Client.Views"
         xmlns:xctk="http://schemas.xceed.com/wpf/xaml/toolkit"
         mc:Ignorable="d"
         Title="Scrubl.io" Height="600" Width="1200">
@@ -23,24 +22,32 @@
         <Grid Grid.Column="0" Grid.Row="1">
             <Grid.RowDefinitions>
                 <RowDefinition/>
-                <RowDefinition/>
-                <RowDefinition/>
-                <RowDefinition/>
-                <RowDefinition/>
-                <RowDefinition/>
-                <RowDefinition/>
-                <RowDefinition/>
             </Grid.RowDefinitions>
 
-
+            <ListBox Name="PlayerList" ItemsSource="{Binding Path=Players}" Margin="10,0,0,10" FontSize="20"/>
         </Grid>
 
-        <Button Name="CanvasReset" Click="CanvasReset_Click" Grid.Row="0" Grid.Column="2" Margin="84,10,10,10" Content="RESET"/>
+        <Grid Grid.Row="0" Grid.Column="1">
+            <Grid.ColumnDefinitions>
+                <ColumnDefinition Width="160"/>
+                <ColumnDefinition Width="160"/>
+                <ColumnDefinition Width="*"/>
+                <ColumnDefinition Width="100"/>
+            </Grid.ColumnDefinitions>
+            <Label Grid.Row="0" Grid.Column="0" VerticalAlignment="Center" FontSize="20" Content="Pick a color -->"/>
+            <xctk:ColorPicker Name="ClrPcker_Background" SelectedColorChanged="ClrPcker_Background_SelectedColorChanged_1" Grid.Column="1" HorizontalAlignment="Left" VerticalAlignment="Center" Height="22" Width="100"/>
+
+
+            <Label Name="GuessWord" Grid.Row="0" Grid.Column="2" Content="{Binding Path=RandomWord, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}" VerticalAlignment="Center" HorizontalAlignment="Center" FontSize="20"/>
+
+            <Button Name="CanvasReset" Command="{Binding ButtonResetCanvas}" Grid.Row="0" Grid.Column="3" Content="RESET"/>
+        </Grid>
+
+        
 
-        <xctk:ColorPicker Name="ClrPcker_Background" SelectedColorChanged="ClrPcker_Background_SelectedColorChanged_1" Grid.Column="1" HorizontalAlignment="Left" VerticalAlignment="Center" Height="22" Width="100"/>
 
         <Border Grid.Row="1" Grid.Column="1" Margin ="10,10,10,10" BorderBrush="Black" BorderThickness ="2.5">
-            <Canvas Name="CanvasForPaint" MouseDown="CanvasForPaint_MouseDown" MouseMove="CanvasForPaint_MouseMove">
+            <Canvas Name="CanvasForPaint" MouseDown="CanvasForPaint_MouseDown" MouseMove="CanvasForPaint_MouseMove" MouseUp="CanvasForPaint_MouseUp">
                 <Canvas.Background>
                     <SolidColorBrush Color="White" Opacity="0"/>
                 </Canvas.Background>
@@ -48,9 +55,9 @@
         </Border>
 
         <Grid Grid.Column="2" Grid.Row="1">
-            <ListBox Name ="TextBox" ItemsSource="{Binding Path=Messages}" Margin="0,0,0,69"/>
+            <ListBox Name ="TextBox" ItemsSource="{Binding Path=Messages}" Margin="0,0,10,69" />
 
-            <TextBox Name="ChatBox" Text="{Binding Message, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}" Margin="0,465,0,0">
+            <TextBox Name="ChatBox" Text="{Binding Message, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}" Margin="0,465,10,0">
                 <TextBox.InputBindings>
                     <KeyBinding Key="Return" Command="{Binding OnKeyDown}"/>
                 </TextBox.InputBindings>

Client/Views/GameWindow.xaml.cs

@@ -1,15 +1,8 @@
 using Client.ViewModels;
-using System;
-using System.Collections.Generic;
-using System.Text;
 using System.Windows;
-using System.Windows.Controls;
-using System.Windows.Data;
-using System.Windows.Documents;
 using System.Windows.Input;
 using System.Windows.Media;
-using System.Windows.Media.Imaging;
-using System.Windows.Shapes;
+
 
 namespace Client.Views
 {
@@ -18,90 +11,41 @@ namespace Client.Views
     /// </summary>
     public partial class GameWindow : Window
     {
-       
+        ClientData data = ClientData.Instance;
+        private ViewModelGame viewModel;
         public GameWindow()
         {
-            DataContext = new ViewModelGame();
+            this.viewModel = new ViewModelGame(this);
+            DataContext = this.viewModel;
+            Closing += this.viewModel.LeaveGame;
             InitializeComponent();
             
         }
-        Point currentPoint = new Point();
+        
 
         private void CanvasForPaint_MouseDown(object sender, MouseButtonEventArgs e)
         {
-            if (e.ButtonState == MouseButtonState.Pressed)
-            {
-                currentPoint = e.GetPosition(CanvasForPaint);
-            }
-
+            this.viewModel.Canvas_MouseDown(e, this);
         }
 
         private void CanvasForPaint_MouseMove(object sender, MouseEventArgs e)
         {
-            if (e.LeftButton == MouseButtonState.Pressed)
-            {
-                Line line = new Line();
-
-             
-                line.Stroke = new SolidColorBrush(color);
-                //line.Stroke = SystemColors.WindowFrameBrush;
-                line.X1 = currentPoint.X;
-                line.Y1 = currentPoint.Y;
-                line.X2 = e.GetPosition(CanvasForPaint).X;
-                line.Y2 = e.GetPosition(CanvasForPaint).Y;
-
-                currentPoint = e.GetPosition(CanvasForPaint);
-
-                CanvasForPaint.Children.Add(line);
-            }
-
-        }
-
-        private Color color;
-
-        private void ClrPcker_Background_SelectedColorChanged(object sender, RoutedPropertyChangedEventArgs<Color> e)
-        {
-            Color colorSelected = new Color();
-            colorSelected.A = 255;
-            colorSelected.R = ClrPcker_Background.SelectedColor.Value.R;
-            colorSelected.G = ClrPcker_Background.SelectedColor.Value.G;
-            colorSelected.B = ClrPcker_Background.SelectedColor.Value.B;
-            color = colorSelected;
+            viewModel.Canvas_MouseMove(e, this);
         }
 
         private void CanvasReset_Click(object sender, RoutedEventArgs e)
         {
             CanvasForPaint.Children.Clear();
-
-            //FOR FUTURE USE, IF NECCESSARY
-            //TEST.Children.Clear();
-
-            //foreach (UIElement child in CanvasForPaint.Children)
-            //{
-            //    var xaml = System.Windows.Markup.XamlWriter.Save(child);
-            //    var deepCopy = System.Windows.Markup.XamlReader.Parse(xaml) as UIElement;
-            //    TEST.Children.Add(deepCopy);
-            //}
         }
 
         private void ClrPcker_Background_SelectedColorChanged_1(object sender, RoutedPropertyChangedEventArgs<Color?> e)
         {
-            Color colorSelected = new Color();
-            colorSelected.A = 255;
-            colorSelected.R = ClrPcker_Background.SelectedColor.Value.R;
-            colorSelected.G = ClrPcker_Background.SelectedColor.Value.G;
-            colorSelected.B = ClrPcker_Background.SelectedColor.Value.B;
-            color = colorSelected;
+            viewModel.Color_Picker(e, this);
         }
 
-        ///*
-        // * Writes the current client's message to the chatbox.
-        // */
-        //private void WriteToChat(string message)
-        //{
-        //    string user = data.User.Username;
-        //    SentMessage.AppendText($"{user}: {message}\n");
-        //    data.User.Message = message;
-        //}
+        private void CanvasForPaint_MouseUp(object sender, MouseButtonEventArgs e)
+        {
+            viewModel.Canvas_MouseUp(sender, e);
+        }
     }
 }

Client/Views/LoginScreen.xaml

@@ -11,6 +11,7 @@
             <RowDefinition Height="60"/>
             <RowDefinition Height="50"/>
             <RowDefinition Height="30"/>
+            <RowDefinition Height="100"/>
         </Grid.RowDefinitions>
 
         <Grid.ColumnDefinitions>
@@ -22,8 +23,7 @@
         <Label Grid.Row="1" FontSize="30" Content="Enter a username:"/>
         <Label Grid.Row="2" FontSize="15" Content="(max amount of characters for the username is 10)"/>
 
-        <TextBox Name="usernameTextbox" Grid.Row="1" Grid.Column="1" MaxLength="10" FontSize="30" VerticalAlignment="Center" HorizontalAlignment="Left" Width="250"/>
-        <Button Content="ENTER" Grid.Column="1" Grid.Row="1" VerticalAlignment="Center" HorizontalAlignment="Right" Width="100" Height="40" Click="Button_EnterUsername"/>
-
+        <TextBox Name="usernameTextbox" Grid.Row="1" Grid.Column="1" MaxLength="69" FontSize="30" VerticalAlignment="Center" HorizontalAlignment="Left" Width="250"/>
+        <Button Name="LoginButton" Content="ENTER" Grid.Column="1" Grid.Row="1" VerticalAlignment="Center" HorizontalAlignment="Right" Width="100" Height="40" Click="Button_EnterUsername"/>
     </Grid>
 </Window>

Client/Views/LoginScreen.xaml.cs

@@ -1,4 +1,5 @@
-using SharedClientServer;
+using Client.ViewModels;
+using SharedClientServer;
 using System;
 using System.Collections.Generic;
 using System.Text;
@@ -26,20 +27,26 @@ namespace Client.Views
 
         private void Button_EnterUsername(object sender, RoutedEventArgs e)
         {
-            User user = new User(usernameTextbox.Text);
+            string name = usernameTextbox.Text;
+            if (name == string.Empty) return;
+            User user = new User(name);
+
             Client client = new Client(user.Username);
+            LoginButton.IsEnabled = false;
             client.OnSuccessfullConnect = () =>
             {
                 // because we need to start the main window on a UI thread, we need to let the dispatcher handle it, which will execute the code on the ui thread
                 Application.Current.Dispatcher.Invoke(delegate {
                     data.User = user;
                     data.Client = client;
+                    client.SendMessage(JSONConvert.ConstructLobbyRequestMessage());
                     MainWindow startWindow = new MainWindow();
                     startWindow.Show();
                     this.Close();
                 });
             };
 
+            
         }
     }
 }

Client/Views/MainWindow.xaml

@@ -57,7 +57,8 @@
                 <GridView x:Name="grdList">
                     <GridViewColumn Header="Lobby ID" DisplayMemberBinding="{Binding ID}" Width="70"/>
                     <GridViewColumn Header="Players in" DisplayMemberBinding="{Binding PlayersIn}" Width="70"/>
-                    <GridViewColumn Header="max players available" DisplayMemberBinding="{Binding MaxPlayers}"/>
+                    <GridViewColumn Header="max players available" DisplayMemberBinding="{Binding MaxPlayers}" Width="150"/>
+                    <GridViewColumn Header="joinable" DisplayMemberBinding="{Binding LobbyJoinable}"/>
                 </GridView>
             </ListView.View>
         </ListView>

Client/Views/MainWindow.xaml.cs

@@ -32,18 +32,6 @@ namespace Client
 
         private void Button_Click(object sender, RoutedEventArgs e)
         {
-            Lobby lobbySelected = LobbyList.SelectedItem as Lobby;
-            if(lobbySelected != null)
-            {
-                testLabel.Content = lobbySelected.ID;
-                colorSelection.IsEnabled = false;
-                joinButton.IsEnabled = false;
-                hostButton.IsEnabled = false;
-
-                GameWindow window = new GameWindow();
-                window.Show();
-                Close();
-            }
         }
     }
 }

Eindproject/Client2/Client2.csproj

@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>netcoreapp3.1</TargetFramework>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\Client\Client.csproj" />
+  </ItemGroup>
+
+</Project>

Eindproject/Client2/Program.cs

@@ -0,0 +1,14 @@
+using System;
+
+namespace Client2
+{
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            Client.App app = new Client.App();
+            app.Run();
+           
+        }
+    }
+}

Eindproject/Eindproject.sln

@@ -9,6 +9,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Client", "..\Client\Client.
 EndProject
 Project("{D954291E-2A0B-460D-934E-DC6B0785DB48}") = "SharedClientServer", "..\SharedClientServer\SharedClientServer.shproj", "{6D26F969-9CB1-414F-AC3E-7253D449AC5A}"
 EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Tests", "Tests\Tests.csproj", "{4CB2CD76-07D9-44D0-A559-A7A301621D30}"
+EndProject
 Global
 	GlobalSection(SharedMSBuildProjectFiles) = preSolution
 		..\SharedClientServer\SharedClientServer.projitems*{67a9bf1a-d317-47ca-9f07-c3480d1360ff}*SharedItemsImports = 5
@@ -28,6 +30,10 @@ Global
 		{83768EDB-097E-4089-A5DE-208CB252D1A0}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{83768EDB-097E-4089-A5DE-208CB252D1A0}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{83768EDB-097E-4089-A5DE-208CB252D1A0}.Release|Any CPU.Build.0 = Release|Any CPU
+		{4CB2CD76-07D9-44D0-A559-A7A301621D30}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{4CB2CD76-07D9-44D0-A559-A7A301621D30}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{4CB2CD76-07D9-44D0-A559-A7A301621D30}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{4CB2CD76-07D9-44D0-A559-A7A301621D30}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

Eindproject/TestHelper/Helper.cs

@@ -0,0 +1,10 @@
+using SharedClientServer;
+using System;
+
+namespace TestHelper
+{
+    public class Helper
+    {
+        public static JSONConvert JSONConvert;
+    }
+}

Eindproject/TestHelper/TestHelper.csproj

@@ -0,0 +1,14 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>netcoreapp3.1</TargetFramework>
+  </PropertyGroup>
+
+  <Import Project="..\..\SharedClientServer\SharedClientServer.projitems" Label="Shared" />
+
+  <ItemGroup>
+    <PackageReference Include="Newtonsoft.Json" Version="12.0.3" />
+  </ItemGroup>
+
+</Project>

Eindproject/Tests/JSONConvertCanvasMessages.cs

@@ -0,0 +1,161 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using SharedClientServer;
+using System;
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+using System.Text;
+using System.Windows.Media;
+
+namespace Tests
+{
+    [TestClass]
+    public class JSONConvertCanvasMessages
+    {
+        //Helper method for the tests
+        public byte[] GetPayload(byte[] message)
+        {
+            byte[] payload = new byte[message.Length - 5];
+            Array.Copy(message, 5, payload, 0, message.Length - 5);
+            return payload;
+        }
+
+        public dynamic GetDynamic(byte[] payload)
+        {
+            dynamic json = JsonConvert.DeserializeObject(Encoding.UTF8.GetString(payload));
+            return json;
+        }
+
+        [TestMethod]
+        public void TestConstructCanvasDataSend()
+        {
+            int type = JSONConvert.CANVAS_WRITING;
+            double[][] coordinateInfo = new double[2][];
+            double[] coordinatesOne = { 10.0, 10.0, 3.0, 3.0 };
+            double[] coordinatesTwo = { 10.0, 10.0, 3.0, 3.0 };
+            coordinateInfo[0] = coordinatesOne;
+            coordinateInfo[1] = coordinatesTwo;
+            Color color = Color.FromRgb(0, 0, 0);
+
+            byte[] message = JSONConvert.ConstructCanvasDataSend(type, coordinateInfo, color);
+            byte[] payload = GetPayload(message);
+            dynamic json = GetDynamic(payload);
+            int ID = json.canvasType;
+            JArray coorArray = json.coords;
+            double[][] coordinates = coorArray.ToObject<double[][]>();
+            Color colorResult = json.color;
+
+            Assert.AreEqual(0x04, message[4]);
+            Assert.AreEqual(type, ID, "The canvas type message is not correct on the ConstructDrawingCanvasData");
+            for (int i = 0; i < coordinateInfo.Length; i++)
+            {
+                CollectionAssert.AreEqual(coordinateInfo[i], coordinates[i], "Coordinates are not correct on the ConstructDrawingCanvasData");
+            }
+            Assert.AreEqual(color, colorResult, "color is not correct on the ConstructDrawingCanvasData");
+        }
+
+        [TestMethod]
+        public void TestConstructDrawingCanvasData()
+        {
+            double[][] coordinateInfo = new double[2][];
+            double[] coordinatesOne = {10.0, 10.0, 3.0, 3.0 };
+            double[] coordinatesTwo = { 10.0, 10.0, 3.0, 3.0 };
+            coordinateInfo[0] = coordinatesOne;
+            coordinateInfo[1] = coordinatesTwo;
+            Color color = Color.FromRgb(0, 0, 0);
+
+            byte[] message = JSONConvert.ConstructDrawingCanvasData(coordinateInfo, color);
+            byte[] payload = GetPayload(message);
+            dynamic json = GetDynamic(payload);
+            int ID = json.canvasType;
+            JArray coorArray = json.coords;
+            double[][] coordinates = coorArray.ToObject<double[][]>();
+            Color colorResult = json.color;
+
+            Assert.AreEqual(0x04, message[4]);
+            Assert.AreEqual(JSONConvert.CANVAS_WRITING, ID, "The canvas type message is not correct on the ConstructDrawingCanvasData");
+            for (int i = 0; i < coordinateInfo.Length; i++)
+            {
+                CollectionAssert.AreEqual(coordinateInfo[i], coordinates[i], "Coordinates are not correct on the ConstructDrawingCanvasData");
+            }
+            Assert.AreEqual(color, colorResult, "color is not correct on the ConstructDrawingCanvasData");
+        }
+
+        [TestMethod]
+        public void TestConstructCanvasReset()
+        {
+            byte[] canvasReset = JSONConvert.ConstructCanvasReset();
+            dynamic json = GetDynamic(GetPayload(canvasReset));
+            int ID = json.canvasType;
+
+            Assert.AreEqual(JSONConvert.CANVAS_RESET, ID, $"Canvas type should be reset(1)! Not, {ID}");
+        }
+
+        [TestMethod]
+        public void TestGetCanvasMessageType()
+        {
+            int type = JSONConvert.CANVAS_WRITING;
+            byte IDsend = JSONConvert.CANVAS;
+           
+            dynamic payloadSend = new
+            {
+                canvasType = type
+            };
+            byte[] message = JSONConvert.GetMessageToSend(IDsend, payloadSend);
+            byte[] payload = GetPayload(message);
+            int resultID = JSONConvert.GetCanvasMessageType(payload);
+
+            Assert.AreEqual(type, resultID, $"Canvas type should be {IDsend}! Not, {resultID}");
+        }
+
+        [TestMethod]
+        public void TestgetCoordinates()
+        {
+
+            int type = JSONConvert.CANVAS_WRITING;
+            byte IDsend = JSONConvert.CANVAS;
+            double[][] coordinateInfo = new double[2][];
+            double[] coordinatesOne = { 10.0, 10.0, 3.0, 3.0 };
+            double[] coordinatesTwo = { 10.0, 10.0, 3.0, 3.0 };
+            coordinateInfo[0] = coordinatesOne;
+            coordinateInfo[1] = coordinatesTwo;
+            dynamic payloadSend = new
+            {
+                canvasType = type,
+                coords = coordinateInfo
+            };
+            byte[] message = JSONConvert.GetMessageToSend(IDsend, payloadSend);
+            byte[] payload = GetPayload(message);
+
+            double[][] coordinates = JSONConvert.getCoordinates(payload);
+
+            for (int i = 0; i < coordinateInfo.Length; i++)
+            {
+                CollectionAssert.AreEqual(coordinateInfo[i], coordinates[i], "Coordinates are not correct on the ConstructDrawingCanvasData");
+            }
+
+        }
+
+        [TestMethod]
+        public void TestGetCanvasDrawingColor()
+        {
+
+            int type = JSONConvert.CANVAS_WRITING;
+            byte IDsend = JSONConvert.CANVAS;
+            Color colorSend = Color.FromRgb(0, 0, 0);
+            dynamic payloadSend = new
+            {
+                canvasType = type,
+                color = colorSend
+            };
+            byte[] message = JSONConvert.GetMessageToSend(IDsend, payloadSend);
+            byte[] payload = GetPayload(message);
+
+            Color colorResult = JSONConvert.getCanvasDrawingColor(payload);
+
+            Assert.AreEqual(colorSend, colorResult, "Colors are not equal!");
+        }
+
+    }
+}

Eindproject/Tests/JSONConvertGameCommand.cs

@@ -0,0 +1,100 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Newtonsoft.Json;
+using SharedClientServer;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Tests
+{
+    [TestClass]
+    public class JSONConvertGameCommand
+    {
+        public byte[] GetPayload(byte[] message)
+        {
+            byte[] payload = new byte[message.Length - 5];
+            Array.Copy(message, 5, payload, 0, message.Length - 5);
+            return payload;
+        }
+
+        public dynamic GetDynamic(byte[] payload)
+        {
+            return JsonConvert.DeserializeObject(Encoding.UTF8.GetString(GetPayload(payload)));
+        }
+
+        public byte[] GameCommandMessage()
+        {
+            byte identifier = 0x05;
+            dynamic payload = new
+            {
+                command = JSONConvert.GameCommand.NEXT_ROUND
+            };
+
+            byte[] res = JSONConvert.GetMessageToSend(identifier, payload);
+
+            return res;
+        }
+        
+        public byte[] GameLobbyID()
+        {
+            byte identifier = 0x05;
+            dynamic payload = new
+            {
+                lobbyToStart = 1
+            };
+
+            byte[] res = JSONConvert.GetMessageToSend(identifier, payload);
+
+            return res;
+        }
+
+        [TestMethod]
+        public void TestConstructGameStartData()
+        {
+            byte[] lobbyData = JSONConvert.ConstructGameStartData(1);
+            dynamic payload = GetDynamic(lobbyData);
+
+            int lobbyid = 1;
+            JSONConvert.GameCommand gameCommand = payload.command;
+
+            Assert.AreEqual(0x05, lobbyData[4]);
+            Assert.AreEqual(JSONConvert.GameCommand.START_GAME, gameCommand);
+            Assert.AreEqual(lobbyid, (int)payload.lobbyToStart);
+        }
+
+        [TestMethod]
+        public void TestConstructGameTimerElapsedMessage()
+        {
+            byte[] lobbyData = JSONConvert.ConstructGameTimerElapsedMessage(1);
+            dynamic payload = GetDynamic(lobbyData);
+
+            int lobbyid = 1;
+            JSONConvert.GameCommand gameCommand = payload.command;
+
+            Assert.AreEqual(0x05, lobbyData[4]);
+            Assert.AreEqual(JSONConvert.GameCommand.TIMER_ELAPSED, gameCommand);
+            Assert.AreEqual(lobbyid, (int)payload.id);
+        }
+
+        [TestMethod]
+        public void TestGetGameCommand()
+        {
+            byte[] data = GetPayload(GameCommandMessage());
+            JSONConvert.GameCommand gameCommand = JSONConvert.GetGameCommand(data);
+
+            Assert.AreEqual(JSONConvert.GameCommand.NEXT_ROUND, gameCommand);
+
+        }
+
+        [TestMethod]
+        public void TestGetStartGameLobbyID()
+        {
+            byte[] data = GetPayload(GameLobbyID());
+            int lobbyID = JSONConvert.GetStartGameLobbyID(data);
+
+            int expected = 1;
+
+            Assert.AreEqual(expected, lobbyID);
+        }
+    }
+}

Eindproject/Tests/JSONConvertGetMessageToSendTest.cs

@@ -0,0 +1,77 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Newtonsoft.Json;
+using SharedClientServer;
+using System;
+using System.Diagnostics;
+using System.Text;
+using Xunit.Sdk;
+
+namespace Tests
+{
+    
+    [TestClass]
+    public class JSONConvertGetMessageToSendTest
+    {
+
+        private byte[] testArray1()
+        {
+            byte identifier = 0x01;
+            dynamic payload = new
+            {
+                value = "test"
+            };
+
+            byte[] result = JSONConvert.GetMessageToSend(identifier, payload);
+            return result;
+        }
+        
+        [TestMethod]
+        public void TestGetMessageToSendLength()
+        {
+            
+            byte identifier = 0x01;
+            dynamic payload = new
+            {
+                value = "test"
+            };
+            string payloadToJson = JsonConvert.SerializeObject(payload);
+            byte[] payloadToBytes = Encoding.UTF8.GetBytes(payloadToJson);
+
+            byte[] result = JSONConvert.GetMessageToSend(identifier, payload);
+            Assert.AreEqual(payloadToBytes.Length + 5, result.Length);
+        }
+
+        [TestMethod]
+        public void TestGetMessageToSendIdentifier()
+        {
+            byte[] result = testArray1();
+            Assert.AreEqual(0x01, result[4]);
+        }
+
+        [TestMethod]
+        public void TestGetMessageToSendMessageLength()
+        {
+
+            byte identifier = 0x01;
+            dynamic payload = new
+            {
+                value = "test"
+            };
+
+            string json = JsonConvert.SerializeObject(payload);
+            byte[] payloadBytes = Encoding.UTF8.GetBytes(json);
+            byte[] res = new byte[payloadBytes.Length + 5];
+            Array.Copy(payloadBytes, 0, res, 5, payloadBytes.Length);
+            res[4] = identifier;
+            Array.Copy(BitConverter.GetBytes(payloadBytes.Length + 5), 0, res, 0, 4);
+            int lengthTest = BitConverter.ToInt32(res, 0);
+            byte[] result = testArray1();
+            int lengthResult = BitConverter.ToInt32(result, 0);
+
+            Assert.AreEqual(lengthTest, lengthResult);
+
+        }
+
+
+    }
+}

Eindproject/Tests/JSONConvertLobbyMessagesTests.cs

@@ -0,0 +1,203 @@
+using Client;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using SharedClientServer;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Tests
+{
+    [TestClass]
+    public class JSONConvertLobbyMessagesTests
+    {
+        public byte[] GetPayload(byte[] message)
+        {
+            byte[] payload = new byte[message.Length - 5];
+            Array.Copy(message, 5, payload, 0, message.Length - 5);
+            return payload;
+        }
+
+        public dynamic GetDynamic(byte[] res)
+        {
+            return JsonConvert.DeserializeObject(Encoding.UTF8.GetString(GetPayload(res)));
+        }
+
+        [TestMethod]
+        public void TestLobbyHostMessage()
+        {
+            byte[] res = JSONConvert.ConstructLobbyHostMessage();
+
+            dynamic payload = GetDynamic(res);
+            JSONConvert.LobbyIdentifier identifier = payload.identifier;
+
+            Assert.AreEqual(0x03, res[4]);
+            Assert.AreEqual(JSONConvert.LobbyIdentifier.HOST, identifier);
+        }
+
+        [TestMethod]
+        public void TestLobbyHostCreatedMessage()
+        {
+            byte[] res = JSONConvert.ConstructLobbyHostCreatedMessage(3);
+
+            dynamic payload = GetDynamic(res);
+            JSONConvert.LobbyIdentifier identifier = payload.identifier;
+            int id = payload.id;
+
+            Assert.AreEqual(0x03, res[4]);
+            Assert.AreEqual(JSONConvert.LobbyIdentifier.HOST, identifier);
+            Assert.AreEqual(3, id);
+        }
+        [TestMethod]
+        public void TestLobbyRequestMessage()
+        {
+            byte[] res = JSONConvert.ConstructLobbyRequestMessage();
+            dynamic payload = GetDynamic(res);
+
+            JSONConvert.LobbyIdentifier identifier = payload.identifier;
+
+            Assert.AreEqual(0x03, res[4]);
+            Assert.AreEqual(JSONConvert.LobbyIdentifier.REQUEST, identifier);
+
+        }
+
+        [TestMethod]
+        public void TestLobbyListMessage()
+        {
+
+            Lobby[] lobbies = new Lobby[] { new Lobby(3, 0, 9), new Lobby(1, 0, 3), new Lobby(1, 0, 1) };
+            byte[] res = JSONConvert.ConstructLobbyListMessage(lobbies);
+
+            dynamic payload = GetDynamic(res);
+            JSONConvert.LobbyIdentifier identifier = payload.identifier;
+            JArray lobbiesJArray = payload.lobbies;
+            Lobby[] lobbiesFromDynamic = lobbiesJArray.ToObject<Lobby[]>();
+
+            Assert.AreEqual(0x03, res[4]);
+            Assert.AreEqual(JSONConvert.LobbyIdentifier.LIST, identifier);
+            for (int i = 0; i < lobbies.Length; i++)
+            {
+                Lobby l1 = lobbies[i];
+                Lobby l2 = lobbiesFromDynamic[i];
+                Assert.AreEqual(l1.ID, l2.ID);
+                Assert.AreEqual(l1.PlayersIn, l2.PlayersIn);
+                Assert.AreEqual(l1.MaxPlayers, l2.MaxPlayers);
+            }
+
+        }
+
+        [TestMethod]
+        public void TestLobbyJoinMessage() 
+        {
+            byte[] res = JSONConvert.ConstructLobbyJoinMessage(8);
+
+            dynamic payload = GetDynamic(res);
+            JSONConvert.LobbyIdentifier identifier = payload.identifier;
+            int id = payload.id;
+
+            Assert.AreEqual(0x03, res[4]);
+            Assert.AreEqual(JSONConvert.LobbyIdentifier.JOIN, identifier);
+            Assert.AreEqual(8, id);
+        }
+
+        [TestMethod] 
+        public void TestLobbyLeaveMessage()
+        {
+            byte[] res = JSONConvert.ConstructLobbyLeaveMessage(4);
+
+            dynamic payload = GetDynamic(res);
+            JSONConvert.LobbyIdentifier identifier = payload.identifier;
+            int id = payload.id;
+
+            Assert.AreEqual(0x03, res[4]);
+            Assert.AreEqual(JSONConvert.LobbyIdentifier.LEAVE, identifier);
+            Assert.AreEqual(4, id);
+        }
+
+        [TestMethod]
+        public void TestGetLobbyIdentifier()
+        {
+            dynamic res = new
+            {
+                identifier = JSONConvert.LobbyIdentifier.REQUEST
+            };
+            byte[] arr = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(res));
+
+            JSONConvert.LobbyIdentifier lobbyIdentifier = JSONConvert.GetLobbyIdentifier(arr);
+
+            Assert.AreEqual(JSONConvert.LobbyIdentifier.REQUEST, lobbyIdentifier);
+        }
+
+        [TestMethod]
+        public void TestLobbyJoinSuccessMessage()
+        {
+            byte[] res = JSONConvert.ConstructLobbyJoinSuccessMessage(true);
+
+            dynamic payload = GetDynamic(res);
+            JSONConvert.LobbyIdentifier identifier = payload.identifier;
+            bool host = payload.host;
+
+            Assert.AreEqual(0x03, res[4]);
+            Assert.AreEqual(JSONConvert.LobbyIdentifier.JOIN_SUCCESS, identifier);
+            Assert.IsTrue(host);
+        }
+
+        [TestMethod]
+        public void TestGetLobbiesFromMessage()
+        {
+            Lobby[] lobbiesArray = new Lobby[] { new Lobby(7, 0, 8), new Lobby(3, 0, 5), new Lobby(5, 0, 10) };
+            dynamic res = new
+            {
+                lobbies = lobbiesArray
+            };
+            byte[] arr = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(res));
+            Lobby[] testLobbies = JSONConvert.GetLobbiesFromMessage(arr);
+
+            for (int i = 0; i < lobbiesArray.Length; i++)
+            {
+                Lobby l1 = lobbiesArray[i];
+                Lobby l2 = testLobbies[i];
+                Assert.AreEqual(l1.ID, l2.ID);
+                Assert.AreEqual(l1.PlayersIn, l2.PlayersIn);
+                Assert.AreEqual(l1.MaxPlayers, l2.MaxPlayers);
+            }
+        }
+
+        [TestMethod]
+        public void TestGetLobbyID()
+        {
+            dynamic res = new
+            {
+                id = 5
+            };
+
+            byte[] arr = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(res));
+            int testID = JSONConvert.GetLobbyID(arr);
+
+            Assert.AreEqual(5, testID);
+        }
+
+        [TestMethod]
+        public void TestGetLobby()
+        {
+            Lobby l = new Lobby(6, 0, 9);
+            dynamic res = new
+            {
+                lobby = l
+            };
+            byte[] arr = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(res));
+
+            Lobby testLobby = JSONConvert.GetLobby(arr);
+
+            Assert.AreEqual(l.ID, testLobby.ID);
+            Assert.AreEqual(l.MaxPlayers, testLobby.MaxPlayers);
+            Assert.AreEqual(l.PlayersIn, testLobby.PlayersIn);
+        }
+
+       
+
+
+    }
+}

Eindproject/Tests/JSONConvertRandomWord.cs

@@ -0,0 +1,59 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Newtonsoft.Json;
+using SharedClientServer;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Tests
+{
+    [TestClass]
+    public class JSONConvertRandomWord
+    {
+        public byte[] GetPayload(byte[] message)
+        {
+            byte[] payload = new byte[message.Length - 5];
+            Array.Copy(message, 5, payload, 0, message.Length - 5);
+            return payload;
+        }
+
+        public byte[] RandomWord()
+        {
+            byte identifier = 0x07;
+            dynamic payload = new
+            {
+                word = "teacher"
+            };
+
+            byte[] res = JSONConvert.GetMessageToSend(identifier, payload);
+
+            return res;
+        }
+
+        public dynamic GetDynamic(byte[] payload)
+        {
+            return JsonConvert.DeserializeObject(Encoding.UTF8.GetString(GetPayload(payload)));
+        }
+
+        [TestMethod]
+        public void TestSendRandomWord()
+        {
+            string randomWord = JSONConvert.SendRandomWord("WordsForGame.json");
+
+            string result = "teacher";
+            
+            Assert.AreEqual(result, randomWord);
+        }
+
+        [TestMethod]
+        public void TestGetRandomWord()
+        {
+            byte[] data = GetPayload(RandomWord());
+            string result = JSONConvert.GetRandomWord(data);
+
+            string word = "teacher";
+
+            Assert.AreEqual(word, result);
+        }
+    }
+}

Eindproject/Tests/JSONConvertUserMessages.cs

@@ -0,0 +1,89 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Newtonsoft.Json;
+using SharedClientServer;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Tests
+{
+    [TestClass]
+    public class JSONConvertUserMessages
+    {
+
+        public byte[] GetPayload(byte[] message)
+        {
+            byte[] payload = new byte[message.Length - 5];
+            Array.Copy(message, 5, payload, 0, message.Length - 5);
+            return payload;
+        }
+
+        public dynamic GetDynamic(byte[] payload)
+        {
+            return JsonConvert.DeserializeObject(Encoding.UTF8.GetString(GetPayload(payload)));
+        }
+
+        private byte[] ComboArray()
+        {
+            byte identifier = 0x02;
+            dynamic payload = new
+            {
+                username = "testName",
+                message = "message"
+            };
+
+            byte[] result = JSONConvert.GetMessageToSend(identifier, payload);
+
+            return result;
+        }
+
+        private byte[] LoginArray()
+        {
+            byte identifier = 0x01;
+            dynamic payload = new
+            {
+                username = "testname"
+            };
+
+            byte[] result = JSONConvert.GetMessageToSend(identifier, payload);
+
+            return result;
+        }
+
+        [TestMethod]
+        public void TestGetUsernameAndMessage()
+        {
+            byte[] data = GetPayload(ComboArray());
+            (string,string) result = JSONConvert.GetUsernameAndMessage(data);
+
+            (string, string) testCombo = ("testName", "message");
+
+            Assert.AreEqual(testCombo, result);
+        }
+
+        [TestMethod]
+        public void TestGetUsernameLogin()
+        {
+            byte[] data = GetPayload(LoginArray());
+            string result = JSONConvert.GetUsernameLogin(data);
+            string username = "testname";
+
+            Assert.AreEqual(username, result);
+        }
+
+        [TestMethod]
+        public void TestConstructUsernameMessage()
+        {
+            byte[] res = JSONConvert.ConstructUsernameMessage("testname");
+            dynamic payload = GetDynamic(res);
+
+            string username = "testname";
+
+            Assert.AreEqual(0x01, res[4]);
+            Assert.AreEqual(username, (string)payload.username);
+        }
+
+
+
+    }
+}

Eindproject/Tests/Tests.csproj

@@ -0,0 +1,35 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp3.1</TargetFramework>
+
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <None Remove="resources\WordsForGame.json" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Content Include="resources\WordsForGame.json">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </Content>
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Extended.Wpf.Toolkit" Version="4.0.1" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.7.1" />
+    <PackageReference Include="MSTest.TestAdapter" Version="2.1.2" />
+    <PackageReference Include="MSTest.TestFramework" Version="2.1.2" />
+    <PackageReference Include="coverlet.collector" Version="1.3.0">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="xunit.extensibility.execution" Version="2.4.1" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\Client\Client.csproj" />
+  </ItemGroup>
+
+</Project>

Eindproject/Tests/resources/WordsForGame.json

@@ -0,0 +1,31 @@
+{
+  "filename": "wordsForGame",
+  "words": [
+    "teacher",
+    "love",
+    "engineer",
+    "supermarket",
+    "disaster",
+    "studio",
+    "restaurant",
+    "music",
+    "chocolate",
+    "dirt",
+    "thought",
+    "virus",
+    "lieutenant",
+    "painter",
+    "kiwi",
+    "power ranger",
+    "computer",
+    "people",
+    "candidate",
+    "security guard",
+    "Canada",
+    "teeth",
+    "army",
+    "airport",
+    "president",
+    "bedroom"
+  ]
+}

Server/Models/ServerClient.cs

@@ -1,24 +1,35 @@
 
+
+using Client;
 using Newtonsoft.Json.Linq;
 using SharedClientServer;
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.IO;
 using System.Net.Sockets;
 using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Timers;
+using static SharedClientServer.JSONConvert;
 
 namespace Server.Models
 {
+    public delegate void Callback();
     class ServerClient : ObservableObject
     {
         private TcpClient tcpClient;
         private NetworkStream stream;
-        private byte[] buffer = new byte[1024];
-        private byte[] totalBuffer = new byte[1024];
+        private byte[] buffer = new byte[2048];
+        private byte[] totalBuffer = new byte[2048];
+        private string _randomWord = "";
         private int totalBufferReceived = 0;
+        private Dictionary<System.Timers.Timer, int> lobbyTimers;
         public User User { get; set; }
         private ServerCommunication serverCom = ServerCommunication.INSTANCE;
-        
+        private Callback OnMessageReceivedOk;
+
 
         /// <summary>
         /// Constructor that creates a new serverclient object with the given tcp client.
@@ -26,6 +37,7 @@ namespace Server.Models
         /// <param name="client">the TcpClient object to use</param>
         public ServerClient(TcpClient client)
         {
+            lobbyTimers = new Dictionary<System.Timers.Timer, int>();
             Debug.WriteLine("[SERVERCLIENT] making new instance and starting");
             tcpClient = client;
             stream = tcpClient.GetStream();
@@ -42,47 +54,59 @@ namespace Server.Models
             if (ar == null || (!ar.IsCompleted) || (!this.stream.CanRead) || !this.tcpClient.Client.Connected)
                 return;
 
-
-            int bytesReceived = this.stream.EndRead(ar);
-
-            if (totalBufferReceived + bytesReceived > 1024)
+            try
             {
-                throw new OutOfMemoryException("buffer is too small!");
-            }
+                int bytesReceived = this.stream.EndRead(ar);
 
-            // copy the received bytes into the buffer
-            Array.Copy(buffer, 0, totalBuffer, totalBufferReceived, bytesReceived);
-            // add the bytes we received to the total amount
-            totalBufferReceived += bytesReceived;
-
-            // calculate the expected length of the message
-            int expectedMessageLength = BitConverter.ToInt32(totalBuffer, 0);
-
-            while (totalBufferReceived >= expectedMessageLength)
-            {
-                // we have received the full packet
-                byte[] message = new byte[expectedMessageLength];
-                // copy the total buffer contents into the message array so we can pass it to the handleIncomingMessage method
-                Array.Copy(totalBuffer, 0, message, 0, expectedMessageLength);
-                HandleIncomingMessage(message);
-
-                // move the contents of the totalbuffer to the start of the array
-                Array.Copy(totalBuffer, expectedMessageLength, totalBuffer, 0, (totalBufferReceived - expectedMessageLength));
-
-                // remove the length of the expected message from the total buffer
-                totalBufferReceived -= expectedMessageLength;
-                // and set the new expected length to the rest that is still in the buffer
-                expectedMessageLength = BitConverter.ToInt32(totalBuffer, 0);
-
-                if (expectedMessageLength == 0)
+                if (totalBufferReceived + bytesReceived > 2048)
                 {
-                    break;
-                } 
+                    throw new OutOfMemoryException("buffer is too small!");
+                }
 
 
+                // copy the received bytes into the buffer
+                Array.Copy(buffer, 0, totalBuffer, totalBufferReceived, bytesReceived);
+                // add the bytes we received to the total amount
+                totalBufferReceived += bytesReceived;
+
+                // calculate the expected length of the message
+                int expectedMessageLength = BitConverter.ToInt32(totalBuffer, 0);
+
+                while (totalBufferReceived >= expectedMessageLength)
+                {
+                    // we have received the full packet
+                    byte[] message = new byte[expectedMessageLength];
+                    // copy the total buffer contents into the message array so we can pass it to the handleIncomingMessage method
+                    Array.Copy(totalBuffer, 0, message, 0, expectedMessageLength);
+                    HandleIncomingMessage(message);
+
+                    // move the contents of the totalbuffer to the start of the array
+                    Array.Copy(totalBuffer, expectedMessageLength, totalBuffer, 0, (totalBufferReceived - expectedMessageLength));
+
+                    // remove the length of the expected message from the total buffer
+                    totalBufferReceived -= expectedMessageLength;
+                    // and set the new expected length to the rest that is still in the buffer
+                    expectedMessageLength = BitConverter.ToInt32(totalBuffer, 0);
+
+                    if (expectedMessageLength == 0)
+                    {
+                        break;
+                    }
+
+
+                }
+
+                ar.AsyncWaitHandle.WaitOne();
+                // start reading for a new message
+                stream.BeginRead(buffer, 0, buffer.Length, new AsyncCallback(OnRead), null);
             }
-            // start reading for a new message
-            stream.BeginRead(buffer, 0, buffer.Length, new AsyncCallback(OnRead), null);
+            catch (IOException e)
+            {
+                Debug.WriteLine("[SERVERCLIENT] Client disconnected! exception was " + e.Message);
+                tcpClient.Close();
+                ServerCommunication.INSTANCE.ServerClientDisconnect(this);
+            }
+
 
         }
 
@@ -95,21 +119,21 @@ namespace Server.Models
             Debug.WriteLine($"Got message : {Encoding.ASCII.GetString(message)}");
             byte id = message[4];
             byte[] payload = new byte[message.Length - 5];
-            Array.Copy(message,5,payload,0,message.Length-5);
+            Array.Copy(message, 5, payload, 0, message.Length - 5);
             Debug.WriteLine("[SERVERCLIENT] GOT STRING" + Encoding.ASCII.GetString(payload));
-            switch(id)
+            switch (id)
             {
-                
+
                 case JSONConvert.LOGIN:
                     // json log in username data
                     string uName = JSONConvert.GetUsernameLogin(payload);
-                    
+
                     if (uName != null)
                     {
                         User = new User(uName);
                         User.Username = uName;
                         Debug.WriteLine("[SERVERCLIENT] set username to " + uName);
-                        
+
                     }
                     break;
                 case JSONConvert.MESSAGE:
@@ -118,25 +142,171 @@ namespace Server.Models
                     string textUsername = combo.Item1;
                     string textMsg = combo.Item2;
 
-                    Debug.WriteLine("[SERVERCLIENT] User name: {0}\t User message: {1}", textUsername, textMsg);
+                    //Takes the data sent from the client, and then sets it in a data packet to be sent.
+                    dynamic packet = new
+                    {
+                        username = textUsername,
+                        message = textMsg
+                    };
 
-                    // todo handle sending to all except this user the username and message to display in chat
-                    serverCom.SendToLobby(User.Lobby,payload);
-                    Debug.WriteLine("Payload has been sent!");
+                    if (textMsg == _randomWord && !string.IsNullOrEmpty(_randomWord))
+                    {
+                        Debug.WriteLine($"[SERVERCLIENT] word has been guessed! {User.Username} + Word: {_randomWord}");
+                    }
+
+                    //Sends the incomming message to be broadcast to all of the clients inside the current lobby.
+                    serverCom.SendToLobby(serverCom.GetLobbyForUser(User), JSONConvert.GetMessageToSend(JSONConvert.MESSAGE, packet));
                     break;
 
                 case JSONConvert.LOBBY:
                     // lobby data
+                    LobbyIdentifier l = JSONConvert.GetLobbyIdentifier(payload);
+                    handleLobbyMessage(payload, l);
                     break;
+
                 case JSONConvert.CANVAS:
+                    
+                    int typeToCheck = JSONConvert.GetCanvasMessageType(payload);
+                    switch (typeToCheck)
+                    {
+                        case JSONConvert.CANVAS_WRITING:
+                            dynamic canvasData = new
+                            {
+                                canvasType = typeToCheck,
+                                coords = JSONConvert.getCoordinates(payload),
+                                color = JSONConvert.getCanvasDrawingColor(payload)
+                            };
+                            //serverCom.SendToLobby(serverCom.GetLobbyForUser(User),JSONConvert.GetMessageToSend(JSONConvert.CANVAS,canvasData));
+                            serverCom.SendCanvasDataToLobby(serverCom.GetLobbyForUser(User), User.Username, JSONConvert.GetMessageToSend(JSONConvert.CANVAS, canvasData));
+                            break;
+
+                        case JSONConvert.CANVAS_RESET:
+                            dynamic canvasDataForReset = new
+                            {
+                                canvasType = JSONConvert.GetCanvasMessageType(payload)
+                            };
+                            serverCom.SendToLobby(serverCom.GetLobbyForUser(User), JSONConvert.GetMessageToSend(CANVAS, canvasDataForReset));
+                            break;
+                    }
+                    
+
                     // canvas data
                     // todo send canvas data to all other serverclients in lobby
                     break;
+
+                case JSONConvert.GAME:
+                    Debug.WriteLine("[SERVERCLIENT] Got a message about the game logic");
+                    GameCommand command = JSONConvert.GetGameCommand(payload);
+                    switch (command)
+                    {
+                        case GameCommand.START_GAME:
+                            int lobbyID = JSONConvert.GetStartGameLobbyID(payload);
+                            serverCom.CloseALobby(lobbyID);
+                            //todo start a timer for this lobby
+                            Debug.WriteLine("[SERVERCLIENT] making timer for lobby " + lobbyID);
+                            System.Timers.Timer lobbyTimer = new System.Timers.Timer(60 * 1000);
+                            this.lobbyTimers.Add(lobbyTimer, lobbyID);
+                            lobbyTimer.Elapsed += LobbyTimer_Elapsed;
+                            lobbyTimer.Start();
+                            ServerCommunication.INSTANCE.sendToAll(JSONConvert.ConstructLobbyListMessage(ServerCommunication.INSTANCE.lobbies.ToArray()));
+                            break;
+                        case GameCommand.TIMER_ELAPSED:
+                            
+                            break;
+                        case GameCommand.NEXT_ROUND:
+                            // The next round has been started, so we can start the timer again
+                            lobbyID = JSONConvert.GetLobbyID(payload);
+                            foreach (System.Timers.Timer timer in lobbyTimers.Keys)
+                            {
+                                if (lobbyTimers[timer] == lobbyID)
+                                {
+                                    timer.Start();
+                                    break;
+                                }
+                            }
+                            break;
+                    }
+
+                    break;
+                case JSONConvert.RANDOMWORD:
+                    //Flag byte for receiving the random word.
+                    break;
+                case JSONConvert.MESSAGE_RECEIVED:
+                    // we now can send a new message
+                    OnMessageReceivedOk?.Invoke();
+                    break;
+
                 default:
                     Debug.WriteLine("[SERVER] Received weird identifier: " + id);
                     break;
             }
-            //TODO implement ways to handle the message
+        }
+
+        private void LobbyTimer_Elapsed(object sender, ElapsedEventArgs e)
+        {
+            System.Timers.Timer timer = sender as System.Timers.Timer;
+            int lobbyID = lobbyTimers[timer];
+            Debug.WriteLine("[SERVERCLIENT] timer elapsed for lobby " + lobbyID);
+            serverCom.SendToLobby(lobbyID, JSONConvert.ConstructGameTimerElapsedMessage(lobbyID));
+            timer.Stop();
+            
+
+        }
+
+        private void handleLobbyMessage(byte[] payload, LobbyIdentifier l)
+        {
+            switch (l)
+            {
+                case LobbyIdentifier.REQUEST:
+                    Debug.WriteLine("[SERVERCLIENT] got lobby request message, sending lobbies...");
+                    sendMessage(JSONConvert.ConstructLobbyListMessage(ServerCommunication.INSTANCE.lobbies.ToArray()));
+                    break;
+                case LobbyIdentifier.HOST:
+                    // add new lobby and add this serverclient to it
+                    int createdLobbyID = ServerCommunication.INSTANCE.HostForLobby(this.User);
+                    Debug.WriteLine("[SERVERCLIENT] created lobby");
+                    sendMessage(JSONConvert.ConstructLobbyHostCreatedMessage(createdLobbyID));
+                    ServerCommunication.INSTANCE.sendToAll(JSONConvert.ConstructLobbyListMessage(ServerCommunication.INSTANCE.lobbies.ToArray()));
+                    break;
+                case LobbyIdentifier.JOIN:
+                    int id = JSONConvert.GetLobbyID(payload);
+                    bool isHost;
+                    ServerCommunication.INSTANCE.JoinLobby(this.User,id, out isHost);
+                    sendMessage(JSONConvert.ConstructLobbyJoinSuccessMessage(isHost));
+                    ServerCommunication.INSTANCE.sendToAll(JSONConvert.ConstructLobbyListMessage(ServerCommunication.INSTANCE.lobbies.ToArray()));
+                    OnMessageReceivedOk = () =>
+                    {
+                        _randomWord = JSONConvert.SendRandomWord("WordsForGame.json");
+                        serverCom.sendToAll(JSONConvert.GetMessageToSend(JSONConvert.RANDOMWORD, new
+                        {
+                            id = serverCom.GetLobbyForUser(User).ID,
+                            word = _randomWord
+                        }));
+                        OnMessageReceivedOk = null;
+                    };
+                    break;
+                case LobbyIdentifier.LEAVE:
+                    id = JSONConvert.GetLobbyID(payload);
+                    ServerCommunication.INSTANCE.LeaveLobby(User, id);
+                    sendMessage(JSONConvert.ConstructLobbyLeaveMessage(id));
+                    ServerCommunication.INSTANCE.sendToAll(JSONConvert.ConstructLobbyListMessage(ServerCommunication.INSTANCE.lobbies.ToArray()));
+                    break;
+            }
+        }
+
+        private async void SendLobbyData()
+        {
+            string result = await WaitForData();
+            if(result == "bruh momento")
+            {
+              
+            }
+        }
+
+        private async Task<string> WaitForData()
+        {
+            await Task.Delay(1000);
+            return "bruh momento";
         }
 
         /// <summary>

Server/Models/ServerCommunication.cs

@@ -16,6 +16,7 @@ namespace Server.Models
         public bool Started = false;
         public List<Lobby> lobbies;
         private Dictionary<Lobby, List<ServerClient>> serverClientsInlobbies;
+        internal Action DisconnectClientAction;
         public Action newClientAction;
         
 
@@ -32,7 +33,10 @@ namespace Server.Models
             listener = new TcpListener(IPAddress.Any, port);
             serverClients = new List<ServerClient>();
             lobbies = new List<Lobby>();
+            Lobby temp = new Lobby(1, 7, 8);
+            lobbies.Add(temp);
             serverClientsInlobbies = new Dictionary<Lobby, List<ServerClient>>();
+            serverClientsInlobbies.Add(temp, new List<ServerClient>());
         }
 
         /// <summary>
@@ -86,7 +90,7 @@ namespace Server.Models
         /// send a message to all tcp clients in the list
         /// </summary>
         /// <param name="message">the message to send</param>
-        public void sendToAll(byte[] message)
+        public async void sendToAll(byte[] message)
         {
             foreach (ServerClient sc in serverClients)
             {
@@ -94,6 +98,26 @@ namespace Server.Models
             }
         }
 
+        public void ServerClientDisconnect(ServerClient serverClient)
+        {
+            Debug.WriteLine("[SERVERCOMM] handling disconnect");
+            DisconnectClientAction?.Invoke();
+            int id = -1;
+            foreach (Lobby l in serverClientsInlobbies.Keys)
+            {
+                if (serverClientsInlobbies[l].Contains(serverClient))
+                {
+                    id = l.ID;
+                }break;
+            }
+
+            if (id != -1)
+            {
+                LeaveLobby(serverClient.User, id);
+                SendToAllExcept(serverClient, JSONConvert.ConstructLobbyLeaveMessage(id));
+            }
+        }
+
         public void SendToAllExcept(string username, byte[] message)
         {
             foreach (ServerClient sc in serverClients)
@@ -102,6 +126,14 @@ namespace Server.Models
             }
         }
 
+        public void SendToAllExcept(ServerClient sc, byte[] message)
+        {
+            foreach (ServerClient s in serverClients)
+            {
+                if (s != sc) s.sendMessage(message);
+            }
+        }
+
         public void SendToLobby(Lobby lobby, byte[] message)
         {
             foreach (Lobby l in lobbies)
@@ -110,6 +142,7 @@ namespace Server.Models
                 {
                     foreach (ServerClient sc in serverClientsInlobbies[l])
                     {
+                        Debug.WriteLine("[SERVERCLIENT] Sending message to lobby");
                         sc.sendMessage(message);
                     }
                     break;
@@ -117,6 +150,50 @@ namespace Server.Models
             }
         }
 
+        public void SendToLobby(int lobbyID, byte[] message)
+        {
+            foreach (Lobby l in lobbies)
+            {
+                if (l.ID == lobbyID)
+                {
+                    foreach (ServerClient sc in serverClientsInlobbies[l])
+                    {
+                        Debug.WriteLine("[SERVERCLIENT] Sending message to lobby");
+                        sc.sendMessage(message);
+                    }
+                    break;
+                }
+            }
+        }
+
+        public void SendCanvasDataToLobby(Lobby lobby, string username, byte[] message)
+        {
+            foreach (Lobby l in lobbies)
+            {
+                if (l == lobby)
+                {
+                    foreach (ServerClient sc in serverClientsInlobbies[l])
+                    {
+                        if (sc.User.Username != username)
+                            sc.sendMessage(message);
+                    }
+                    break;
+                }
+            }
+        }
+
+        public Lobby GetLobbyForUser(User user)
+        {
+            foreach (Lobby l in lobbies)
+            {
+                if (l.Users.Contains(user))
+                {
+                    return l;
+                }
+            }
+            return null;
+        }
+
         public void AddToLobby(Lobby lobby, User user)
         {
             foreach (Lobby l in lobbies)
@@ -125,6 +202,7 @@ namespace Server.Models
                 {
                     bool succ;
                     l.AddUser(user, out succ);
+                    Debug.WriteLine("[SERVERCOMM] added user to lobby, now contains " + l.PlayersIn);
                     if (!succ)
                     {
                         // TODO send lobby full message
@@ -144,5 +222,85 @@ namespace Server.Models
                 }
             }
         }
+
+
+        public int HostForLobby(User user)
+        {
+            Lobby lobby = new Lobby( lobbies.Count + 1,0, 8);
+            lobbies.Add(lobby);
+            serverClientsInlobbies.Add(lobby, new List<ServerClient>());
+            user.Host = true;
+            AddToLobby(lobby, user);
+            return lobby.ID;
+        }
+
+        public void JoinLobby(User user, int id, out bool isHost)
+        {
+            isHost = false;
+            foreach (Lobby l in lobbies)
+            {
+                if (l.ID == id)
+                {
+                    if (l.Users.Count == 0)
+                    {
+                        user.Host = true;
+                        isHost = true;
+                    }
+                    AddToLobby(l, user);
+                    Debug.WriteLine($"{user.Username} joined lobby with id {id}");
+                    break;
+                }
+            }
+        }
+
+        public void LeaveLobby(User user, int id)
+        {
+            Debug.WriteLine("[SERVERCOMM] removing user from lobby");
+            foreach (Lobby l in lobbies)
+            {
+                if (l.ID == id)
+                {
+                    Debug.WriteLine($"[SERVERCOMM] checking for lobby with id {l.ID}");
+                    
+                    foreach (User u in l.Users)
+                    {
+                        Debug.WriteLine($"[SERVERCOMM] checking if {u.Username} is {user.Username} ");
+                        // contains doesn't work, so we'll do it like this...
+                        if (u.Username == user.Username)
+                        {
+                            Debug.WriteLine("[SERVERCOMM] removed user from lobby!");
+                            l.Users.Remove(user);
+                            foreach (ServerClient sc in serverClients)
+                            {
+                                if (sc.User.Username == user.Username)
+                                {
+                                    serverClientsInlobbies[l].Remove(sc);
+                                    break;
+                                }
+                            }
+                            if (l.Users.Count != 0)
+                            {
+                                l.Users[0].Host = true;
+                            }
+                            break;
+                        }
+                    }
+
+                    
+                   
+                }
+            }
+        }
+
+        public void CloseALobby(int lobbyID)
+        {
+            foreach (Lobby lobby in lobbies)
+            {
+                if (lobby.ID == lobbyID)
+                {
+                    lobby.LobbyJoinable = false;
+                }
+            }
+        }
     }
 }

Server/Server.csproj

@@ -6,6 +6,16 @@
     <UseWPF>true</UseWPF>
   </PropertyGroup>
 
+  <ItemGroup>
+    <None Remove="resources\WordsForGame.json" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Content Include="resources\WordsForGame.json">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </Content>
+  </ItemGroup>
+
   <ItemGroup>
     <PackageReference Include="AsyncAwaitBestPractices" Version="4.3.0" />
     <PackageReference Include="Extended.Wpf.Toolkit" Version="4.0.1" />

Server/ViewModels/MainViewModel.cs

@@ -33,6 +33,10 @@ namespace Server.ViewModels
             {
                 InformationModel.ClientsConnected++;
             };
+            serverCommunication.DisconnectClientAction = () =>
+            {
+                InformationModel.ClientsConnected--;
+            };
             //BitmapImage onlineImg = new BitmapImage(new Uri(@"/img/online.png",UriKind.Relative));
             //BitmapImage offlineImg = new BitmapImage(new Uri(@"/img/offline.png", UriKind.Relative));
             

Server/resources/WordsForGame.json

@@ -0,0 +1,31 @@
+{
+  "filename": "wordsForGame",
+  "words": [
+    "teacher",
+    "love",
+    "engineer",
+    "supermarket",
+    "disaster",
+    "studio",
+    "restaurant",
+    "music",
+    "chocolate",
+    "dirt",
+    "thought",
+    "virus",
+    "lieutenant",
+    "painter",
+    "kiwi",
+    "power ranger",
+    "computer",
+    "people",
+    "candidate",
+    "security guard",
+    "Canada",
+    "teeth",
+    "army",
+    "airport",
+    "president",
+    "bedroom"
+  ]
+}

SharedClientServer/ClientServerUtil.cs

@@ -7,6 +7,8 @@ using System.Text;
 namespace SharedClientServer
 {
     public delegate void Callback();
+
+
     class ClientServerUtil
     {
         // creates a message array to send to the server or to clients

SharedClientServer/JSONConvert.cs

@@ -1,37 +1,63 @@
-using Client;
+using Client;
 using Newtonsoft.Json;
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Text;
-
+using Newtonsoft.Json.Linq;
+using System;
+using System.Diagnostics;
+using System.IO;
+using System.Text;
+using System.Windows.Media;
+
 namespace SharedClientServer
 {
-    class JSONConvert
+    public class JSONConvert
     {
         public const byte LOGIN = 0x01;
         public const byte MESSAGE = 0x02;
         public const byte LOBBY = 0x03;
         public const byte CANVAS = 0x04;
+        public const byte GAME = 0x05;
+        public const byte MESSAGE_RECEIVED = 0x06;
+        public const byte RANDOMWORD = 0x07;
 
-        enum LobbyIdentifier
+        public const int CANVAS_WRITING = 0;
+        public const int CANVAS_RESET = 1;
+
+        public enum LobbyIdentifier
         {
             HOST,
-            ADD,
+            JOIN,
+            JOIN_SUCCESS,
             LEAVE,
+            LIST,
             REQUEST
         }
-        public static (string,string) GetUsernameAndMessage(byte[] json)
+
+        public enum GameCommand
         {
-            string msg = Encoding.ASCII.GetString(json);
-            dynamic payload = JsonConvert.DeserializeObject(msg);
-            
+            START_GAME,
+            TIMER_ELAPSED,
+            NEXT_ROUND
+        }
+
+        public static (string, string) GetUsernameAndMessage(byte[] json)
+        {
+            string msg = Encoding.UTF8.GetString(json);
+            dynamic payload = JsonConvert.DeserializeObject(msg);
+
             return (payload.username, payload.message);
         }
 
+        internal static byte[] ConstructCanvasResetMessage()
+        {
+            return GetMessageToSend(CANVAS, new
+            {
+                canvasType = CANVAS_RESET
+            });
+        }
+
         public static string GetUsernameLogin(byte[] json)
         {
-            dynamic payload = JsonConvert.DeserializeObject(Encoding.ASCII.GetString(json));
+            dynamic payload = JsonConvert.DeserializeObject(Encoding.UTF8.GetString(json));
             return payload.username;
         }
 
@@ -43,11 +69,192 @@ namespace SharedClientServer
             });
         }
 
-        public static byte[] ConstructLobbyDataMessage(Lobby lobby)
+        #region lobby messages
+
+        public static byte[] ConstructLobbyHostMessage()
         {
-            return null;
+            return GetMessageToSend(LOBBY, new
+            {
+                identifier = LobbyIdentifier.HOST
+            });
         }
 
+        public static byte[] ConstructLobbyHostCreatedMessage(int lobbyID)
+        {
+            return GetMessageToSend(LOBBY, new
+            {
+                identifier = LobbyIdentifier.HOST,
+                id = lobbyID
+            });
+        }
+
+        public static byte[] ConstructLobbyRequestMessage()
+        {
+            return GetMessageToSend(LOBBY, new
+            {
+                identifier = LobbyIdentifier.REQUEST
+            });
+        }
+
+        public static byte[] ConstructLobbyListMessage(Lobby[] lobbiesList)
+        {
+            return GetMessageToSend(LOBBY, new
+            {
+                identifier = LobbyIdentifier.LIST,
+                lobbies = lobbiesList
+            });
+        }
+
+        public static byte[] ConstructLobbyJoinMessage(int lobbyID)
+        {
+            return GetMessageToSend(LOBBY, new
+            {
+                identifier = LobbyIdentifier.JOIN,
+                id = lobbyID
+            });
+        }
+
+        public static byte[] ConstructLobbyLeaveMessage(int lobbyID)
+        {
+            return GetMessageToSend(LOBBY, new
+            {
+                identifier = LobbyIdentifier.LEAVE,
+                id = lobbyID
+            });
+        }
+
+        public static LobbyIdentifier GetLobbyIdentifier(byte[] json)
+        {
+            dynamic payload = JsonConvert.DeserializeObject(Encoding.UTF8.GetString(json));
+            return payload.identifier;
+        }
+
+        public static Lobby[] GetLobbiesFromMessage(byte[] json)
+        {
+            dynamic payload = JsonConvert.DeserializeObject(Encoding.UTF8.GetString(json));
+            JArray lobbiesArray = payload.lobbies;
+            Debug.WriteLine("[JSONCONVERT] got lobbies from message" + lobbiesArray.ToString());
+            Lobby[] lobbiesTemp = lobbiesArray.ToObject<Lobby[]>();
+            Debug.WriteLine("lobbies in array: ");
+            foreach (Lobby l in lobbiesTemp)
+            {
+                Debug.WriteLine("players: " + l.PlayersIn);
+            }
+            return lobbiesTemp;
+        }
+
+        public static int GetLobbyID(byte[] json)
+        {
+            dynamic payload = JsonConvert.DeserializeObject(Encoding.UTF8.GetString(json));
+            return payload.id;
+        }
+
+        public static Lobby GetLobby(byte[] json)
+        {
+            dynamic payload = JsonConvert.DeserializeObject(Encoding.UTF8.GetString(json));
+            JObject dynamicAsObject = payload.lobby;
+            return dynamicAsObject.ToObject<Lobby>();
+        }
+
+        public static byte[] ConstructLobbyJoinSuccessMessage(bool isHost)
+        {
+            return GetMessageToSend(LOBBY, new
+            {
+                identifier = LobbyIdentifier.JOIN_SUCCESS,
+                host = isHost
+            });
+        }
+
+        public static bool GetLobbyJoinIsHost(byte[] json)
+        {
+            dynamic payload = JsonConvert.DeserializeObject(Encoding.UTF8.GetString(json));
+            return payload.host;
+        }
+
+        #endregion lobby messages
+
+        public static byte[] ConstructCanvasDataSend(int typeToSend, double[][] buffer, Color colorToSend)
+        {
+            return GetMessageToSend(CANVAS, new
+            {
+                canvasType = typeToSend,
+                coords = buffer,
+                color = colorToSend
+            }); ;
+        }
+
+        public static byte[] ConstructDrawingCanvasData(double[][] buffer, Color colorToSend)
+        {
+            return GetMessageToSend(CANVAS, new
+            {
+                canvasType = CANVAS_WRITING,
+                coords = buffer,
+                color = colorToSend
+            });
+        }
+
+        public static byte[] ConstructCanvasReset()
+        {
+            dynamic payload = new
+            {
+                canvasType = CANVAS_RESET
+            };
+            return GetMessageToSend(CANVAS, payload);
+        }
+
+        public static int GetCanvasMessageType(byte[] json)
+        {
+            dynamic d = JsonConvert.DeserializeObject(Encoding.UTF8.GetString(json));
+            return d.canvasType;
+        }
+
+        public static double[][] getCoordinates(byte[] payload)
+        {
+            Debug.WriteLine("got coords " + Encoding.UTF8.GetString(payload));
+            dynamic json = JsonConvert.DeserializeObject(Encoding.UTF8.GetString(payload));
+            JArray coordinatesArray = json.coords;
+
+            double[][] coordinates = coordinatesArray.ToObject<double[][]>();
+
+            return coordinates;
+        }
+
+        public static Color getCanvasDrawingColor(byte[] payload)
+        {
+            dynamic json = JsonConvert.DeserializeObject(Encoding.UTF8.GetString(payload));
+            Color color = json.color;
+            return color;
+        }
+
+        public static byte[] ConstructGameStartData(int lobbyID)
+        {
+            return GetMessageToSend(GAME, new
+            {
+                command = GameCommand.START_GAME,
+                lobbyToStart = lobbyID
+            }); ;
+        }
+
+        public static byte[] ConstructGameTimerElapsedMessage(int lobbyID)
+        {
+            return GetMessageToSend(GAME, new
+            {
+                command = GameCommand.TIMER_ELAPSED,
+                id = lobbyID
+            });
+        }
+
+        public static GameCommand GetGameCommand(byte[] payload)
+        {
+            dynamic json = JsonConvert.DeserializeObject(Encoding.UTF8.GetString(payload));
+            return json.command;
+        }
+
+        public static int GetStartGameLobbyID(byte[] payload)
+        {
+            dynamic json = JsonConvert.DeserializeObject(Encoding.UTF8.GetString(payload));
+            return json.lobbyToStart;
+        }
 
         /// <summary>
         /// constructs a message that can be sent to the clients or server
@@ -58,7 +265,8 @@ namespace SharedClientServer
         public static byte[] GetMessageToSend(byte identifier, dynamic payload)
         {
             // convert the dynamic to bytes
-            byte[] payloadBytes = Encoding.ASCII.GetBytes(JsonConvert.SerializeObject(payload));
+            string json = JsonConvert.SerializeObject(payload);
+            byte[] payloadBytes = Encoding.UTF8.GetBytes(json);
             // make the array that holds the message and copy the payload into it with the first spot containing the identifier
             byte[] res = new byte[payloadBytes.Length + 5];
             // put the payload in the res array
@@ -66,8 +274,43 @@ namespace SharedClientServer
             // put the identifier at the start of the payload part
             res[4] = identifier;
             // put the length of the payload at the start of the res array
-            Array.Copy(BitConverter.GetBytes(payloadBytes.Length+5),0,res,0,4);
+            Array.Copy(BitConverter.GetBytes(payloadBytes.Length + 5), 0, res, 0, 4);
             return res;
+        }
+
+        /*
+    * This method sends a random word from the json file, this happens when the client joins a lobby.
+    */
+
+        public static string SendRandomWord(string filename)
+        {
+            dynamic words;
+            Random random = new Random();
+            string workingDir = Path.GetFullPath(@"..\Server");
+            string projDir = Directory.GetParent(workingDir).Parent.Parent.FullName;
+            string filePath = projDir += $@"\resources\{filename}";
+
+            using (StreamReader reader = new StreamReader(filePath))
+            {
+                string json = reader.ReadToEnd();
+                words = JsonConvert.DeserializeObject(json);
+            }
+
+            int index = random.Next(0, 24);
+
+            Debug.WriteLine($"[SERVERCLIENT] Sending random words {words}");
+
+            return words.words[0];
+        }
+
+        /*
+         * Client gets the payload and retrieves the word from the payload
+         */
+
+        public static string GetRandomWord(byte[] json)
+        {
+            dynamic payload = JsonConvert.DeserializeObject(Encoding.ASCII.GetString(json));
+            return payload.word;
         }
     }
-}
+}

SharedClientServer/Lobby.cs

@@ -6,7 +6,7 @@ using System.Text;
 
 namespace Client
 {
-    class Lobby : INotifyPropertyChanged
+    public class Lobby : INotifyPropertyChanged
     {
         public event PropertyChangedEventHandler PropertyChanged;
 
@@ -14,6 +14,7 @@ namespace Client
         private int _id;
         private int _playersIn;
         private int _maxPlayers;
+        private bool _lobbyJoinable;
         //private List<string> _usernames;
         private List<User> _users;
 
@@ -34,6 +35,7 @@ namespace Client
             _maxPlayers = maxPlayers;
             //_usernames = new List<string>();
             _users = new List<User>();
+            _lobbyJoinable = true;
         }
 
         public void AddUser(string username, out bool succes)
@@ -41,7 +43,7 @@ namespace Client
             succes = false;
             if (_users.Count < _maxPlayers)
             {
-                _users.Add(new User(username, 0, false));
+                _users.Add(new User(username, 0, false, false));
                 succes = true;
             }
         }
@@ -64,16 +66,34 @@ namespace Client
 
         public int PlayersIn
         {
-            get { return _playersIn; }
+            get { return _users.Count; }
             set { _playersIn = value; }
         }
 
+        public void Set(Lobby lobby)
+        {
+            this._id = lobby._id;
+            this._users = lobby._users;
+            this._maxPlayers = lobby._maxPlayers;
+        }
+
         public int MaxPlayers
         {
             get { return _maxPlayers; }
             set { _maxPlayers = value; }
         }
 
+        public List<User> Users
+        {
+            get { return _users; }
+            set { _users = value; }
+        }
+
+        public bool LobbyJoinable
+        {
+            get { return _lobbyJoinable; }
+            set { _lobbyJoinable = value; }
+        }
 
     }
 }

SharedClientServer/SharedClientServer.shproj

@@ -10,4 +10,4 @@
   <PropertyGroup />
   <Import Project="SharedClientServer.projitems" Label="Shared" />
   <Import Project="$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)\CodeSharing\Microsoft.CodeSharing.CSharp.targets" />
-</Project>
+</Project>

SharedClientServer/User.cs

@@ -1,21 +1,27 @@
-using System;
+using Newtonsoft.Json;
+using System;
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using System.Text;
 
 namespace SharedClientServer
 {
-    class User
+    public class User : IEquatable<User>
     {
         private string _username;
         private int _score;
         private bool _host;
+        private bool _turnToDraw;
         private string _message;
+        private string _randomWord;
 
-        public User(string username, int score, bool host)
+        [JsonConstructor]
+        public User(string username, int score, bool host, bool turnToDraw)
         {
             _username = username;
             _score = score;
             _host = host;
+            _turnToDraw = turnToDraw;
         }
 
         public User(string username)
@@ -23,6 +29,43 @@ namespace SharedClientServer
             _username = username;
             _score = 0;
             _host = false;
+            _turnToDraw = false;
+        }
+
+        public static bool operator ==(User u1, User u2)
+        {
+            if (object.ReferenceEquals(u1, null))
+            {
+                return object.ReferenceEquals(u2, null);
+            }
+            return u1.Equals(u2 as object);
+        }
+
+        public static bool operator !=(User u1, User u2)
+        {
+            if (object.ReferenceEquals(u1, null))
+            {
+                return object.ReferenceEquals(u2, null);
+            }
+            return u1.Equals(u2 as object);
+        }
+
+        public override bool Equals(object obj)
+        {
+            if ((obj == null) || !this.GetType().Equals(obj.GetType()))
+            {
+                return false;
+            }
+            else
+            {
+                return this.Equals(obj as User);
+                
+            }
+        }
+
+        public bool Equals([AllowNull] User other)
+        {
+            return other.Username == this.Username;
         }
 
         public string Username
@@ -42,5 +85,16 @@ namespace SharedClientServer
             get { return _host; }
             set { _host = value; }
         }
+
+        public bool TurnToDraw
+        {
+            get { return _turnToDraw; }
+            set { _turnToDraw = value; }
+        }
+        public string RandomWord
+        {
+            get { return _randomWord; }
+            set { _randomWord = value; }
+        }
     }
 }