Merge branch 'master' into stateful-canvas

merge Fix async stuff into master

Client/Client.cs

@@ -2,28 +2,43 @@
 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 OnLobbyCreated(int id);
+    public delegate void LobbyJoinCallback(bool isHost);
+    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 Callback OnLobbyJoinSuccess;
+        public LobbyJoinCallback OnLobbyJoinSuccess;
         public Callback OnLobbiesReceivedAndWaitingForHost;
-        public OnLobbyCreated OnLobbyCreated;
+        public Callback OnServerDisconnect;
+        public LobbyCallback OnLobbyCreated;
+        public LobbyCallback OnLobbyLeave;
+        private ClientData data = ClientData.Instance;
+        public CanvasDataReceived CanvasDataReceived;
+        public CanvasReset CReset;
         public Lobby[] Lobbies { get; set; }
 
         public Client(string username)
@@ -37,22 +52,36 @@ namespace Client
         private void OnConnect(IAsyncResult ar)
         {
             Debug.Write("finished connecting to server");
+            try
+            {
                 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);
+
+            } catch (Exception e)
+            {
+                Debug.WriteLine("Can't connect, retrying...");
+                tcpClient.BeginConnect("localhost", Port, new AsyncCallback(OnConnect), null);
+            }
         }
 
         private void OnReadComplete(IAsyncResult ar)
+        {
+
+            if (ar == null || (!ar.IsCompleted) || (!this.stream.CanRead) || !this.tcpClient.Client.Connected)
+                return;
+            try
             {
                 int amountReceived = stream.EndRead(ar);
 
-            if (totalBufferReceived + amountReceived > 1024)
+                if (totalBufferReceived + amountReceived > 2048)
                 {
                     throw new OutOfMemoryException("buffer too small");
                 }
 
+
                 Array.Copy(buffer, 0, totalBuffer, totalBufferReceived, amountReceived);
                 totalBufferReceived += amountReceived;
 
@@ -64,14 +93,19 @@ namespace Client
                     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);
+            } catch (IOException e)
+            {
+                Debug.WriteLine("[CLIENT] server not responding! got error: " + e.Message);
+                OnServerDisconnect?.Invoke();   
+            }
         }
 
         private void handleData(byte[] message)
@@ -81,6 +115,7 @@ namespace Client
             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:
@@ -92,6 +127,11 @@ namespace Client
                     string textUsername = combo.Item1;
                     string textMsg = combo.Item2;
 
+                    if(textUsername != data.User.Username)
+                    {
+                        ViewModels.ViewModelGame.HandleIncomingMsg(textUsername, textMsg);
+                    }
+
                     //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);
@@ -116,7 +156,12 @@ namespace Client
                             OnLobbyCreated?.Invoke(lobbyCreatedID);
                             break;
                         case LobbyIdentifier.JOIN_SUCCESS:
-                            OnLobbyJoinSuccess?.Invoke();
+
+                            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
@@ -124,12 +169,35 @@ namespace Client
 
                 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));
+                            // we hebben gedrawed, dus stuur dat we weer kunnen drawen
+                            
+                            break;
+                    }
+                break;
+
+
+                case JSONConvert.RANDOMWORD:
+                    //Flag byte for receiving the random word.
+                    int lobbyId = JSONConvert.GetLobbyID(payload);
+
+                    if(data.Lobby?.ID == lobbyId)
+                    ViewModels.ViewModelGame.HandleRandomWord(JSONConvert.GetRandomWord(payload));
+                    break;
                 default:
                     Debug.WriteLine("[CLIENT] Received weird identifier: " + id);
                     break;
             }
+            SendMessage(JSONConvert.GetMessageToSend(JSONConvert.MESSAGE_RECEIVED,null));
 
         }
 
@@ -137,12 +205,14 @@ namespace Client
         {
             Debug.WriteLine("[CLIENT] sending message " + Encoding.ASCII.GetString(message));
             stream.BeginWrite(message, 0, message.Length, new AsyncCallback(OnWriteComplete), null);
+
         }
 
         private void OnWriteComplete(IAsyncResult ar)
         {
             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/ViewModel.cs

@@ -11,6 +11,9 @@ 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
 {
@@ -34,6 +37,11 @@ namespace Client
             _lobbies = new ObservableCollection<Lobby>();
             client = ClientData.Instance.Client;
             client.OnLobbiesListReceived = updateLobbies;
+            client.OnLobbyLeave = leaveLobby;
+            client.OnServerDisconnect = () =>
+            {
+                Environment.Exit(0);
+            };
             
 
             OnHostButtonClick = new RelayCommand(hostGame);
@@ -41,6 +49,13 @@ namespace Client
             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);
@@ -50,12 +65,10 @@ namespace Client
 
         private void becomeHostForLobby(int id)
         {
-            
             Debug.WriteLine($"got host succes with data {id} ");
             wantToBeHost = true;
             wantToBeHostId = id;
             client.OnLobbiesReceivedAndWaitingForHost = hostLobbiesReceived;
-
         }
 
         private void hostLobbiesReceived()
@@ -77,14 +90,21 @@ namespace Client
 
         private void joinLobby()
         {
-            // lobby die je wilt joinen verwijderen
-            // nieuwe binnengekregen lobby toevoegen
+            if (SelectedLobby != null)
+            {
+                if (SelectedLobby.PlayersIn == SelectedLobby.MaxPlayers || !SelectedLobby.LobbyJoinable)
+                {
+                    return;
+                }
                 client.OnLobbyJoinSuccess = OnLobbyJoinSuccess;
                 client.SendMessage(JSONConvert.ConstructLobbyJoinMessage(SelectedLobby.ID));
             }
             
-        private void OnLobbyJoinSuccess()
+        }
+
+        private void OnLobbyJoinSuccess(bool isHost)
         {
+            ClientData.Instance.User.Host = isHost;
             startGameInLobby();
         }
 
@@ -97,19 +117,6 @@ namespace Client
             Application.Current.Dispatcher.Invoke(delegate
             {
 
-                //for (int i = 0; i < lobbiesArr.Length; i++)
-                //{
-                //    Lobby lobby = lobbiesArr[i];
-                //    Debug.WriteLine(lobby.PlayersIn);
-                //    if (i < _lobbies.Count && _lobbies[i].ID == lobby.ID)
-                //    {
-                //        _lobbies[i].Set(lobby);
-                //    } else
-                //    {
-                //        _lobbies.Add(lobbiesArr[i]);
-                //    }
-                //}
-
                 _lobbies.Clear();
 
                 foreach (Lobby l in lobbiesArr)
@@ -168,5 +175,7 @@ namespace Client
             get { return _lobbies; }
             set { _lobbies = value; }
         }
+
+   
     }
 }

Client/ViewModels/ViewModelGame.cs

@@ -1,10 +1,15 @@
 
-using Client.Views;
+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.Timers;
 using System.Windows;
+using System.Windows.Controls;
 using System.Windows.Input;
 using System.Windows.Media;
 using System.Windows.Shapes;
@@ -13,20 +18,30 @@ namespace Client.ViewModels
 {
     class ViewModelGame : INotifyPropertyChanged
     {
-        private ClientData data = ClientData.Instance;
-
         public event PropertyChangedEventHandler PropertyChanged;
-
+        private ClientData data = ClientData.Instance;
+        private GameWindow window;
         private Point currentPoint = new Point();
-        private Color color;
+        public Color color;
+        public double[][] buffer;
+        public int pos = 0;
+        public int maxLines = 50;
+        public Queue<double[][]> linesQueue;
+        private Timer queueTimer;
 
-        public ObservableCollection<string> Messages { get; } = new ObservableCollection<string>();
+        public static ObservableCollection<string> Messages { get; } = new ObservableCollection<string>();
 
         private dynamic _payload;
 
-        private string _username;
+        public static string Word
+        {
+            get;
+            set;
+        }
 
-        private string _message;
+        public string _username;
+
+        public string _message;
         public string Message
         {
             get
@@ -38,7 +53,56 @@ namespace Client.ViewModels
                 _message = value;
             }
         }
+
+        public bool IsHost
+        {
+            get { return data.User.Host; }
+        }
+
+        public ViewModelGame(GameWindow window)
+        {
+            this.window = window;
+            if (_payload == null)
+            {
+                _message = "";
+
+            }
+            else
+            {
+                //_message = data.Message;
+                //_username = data.User.Username;
+                //Messages.Add($"{data.User.Username}: {Message}");
+            }
+
+            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;
+        }
+
         public ICommand OnKeyDown { get; set; }
+        public ICommand ButtonStartGame { get; set; }
+        public ICommand ButtonResetCanvas { get; set; }
+       
+        public void BeginGame()
+        {
+            
+            queueTimer = new Timer(50);
+            queueTimer.Start();
+            queueTimer.Elapsed += sendArrayFromQueue;
+            data.Client.SendMessage(JSONConvert.ConstructGameStartData(data.Lobby.ID));
+        }
+
+
+        private void CanvasResetLocal()
+        {
+            this.window.CanvasForPaint.Children.Clear();
+            data.Client.SendMessage(JSONConvert.GetMessageToSend(JSONConvert.CANVAS, JSONConvert.CANVAS_RESET));
+        }
+
 
         public void Canvas_MouseDown(MouseButtonEventArgs e, GameWindow window)
         {
@@ -66,9 +130,33 @@ namespace Client.ViewModels
                 coordinates[2] = line.X2;
                 coordinates[3] = line.Y2;
                 currentPoint = e.GetPosition(window.CanvasForPaint);
+                buffer[pos] = coordinates;
+                pos++;
 
                 window.CanvasForPaint.Children.Add(line);
-                data.Client.SendMessage(JSONConvert.GetMessageToSend(0x04, coordinates));
+                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;
+                }
+                
+            }
+        }
+
+        private void sendArrayFromQueue(object sender, ElapsedEventArgs e)
+        {
+            
+            if (linesQueue.Count != 0)
+            {
+                Debug.WriteLine("[GAME] sending canvas data...");
+                double[][] temp = linesQueue.Dequeue();
+                data.Client.SendMessage(JSONConvert.ConstructDrawingCanvasData(temp,color));
             }
         }
 
@@ -82,21 +170,26 @@ namespace Client.ViewModels
             color = colorSelected;
         }
 
-
-        public ViewModelGame()
+        private void UpdateCanvasWithNewData(double[][] buffer, Color color)
         {
-            if (_payload == null)
+            Application.Current.Dispatcher.Invoke(delegate
             {
-                _message = "";
-
+                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);
                 }
-            else
-            {
-                //_message = data.Message;
-                //_username = data.User.Username;
-                //Messages.Add($"{data.User.Username}: {Message}");
+            });
         }
-            OnKeyDown = new RelayCommand(ChatBox_KeyDown);
+
+        private void CanvasResetData()
+        {
+            this.window.CanvasForPaint.Children.Clear();
         }
 
         private void ChatBox_KeyDown()
@@ -120,7 +213,32 @@ namespace Client.ViewModels
             data.Client.SendMessage(JSONConvert.GetMessageToSend(JSONConvert.MESSAGE, _payload));
         }
 
+        /*
+         * MISC make this a callback
+         * Handles the incoming chat message from another client.
+         */
+        public static void HandleIncomingMsg(string username, string message)
+        {
+            Application.Current.Dispatcher.Invoke(delegate
+            {
+                Messages.Add($"{username}: {message}");
+            });
+        }
+        public void LeaveGame(object sender, CancelEventArgs e)
+        {
+            Debug.WriteLine("Leaving...");
+            data.Client.SendMessage(JSONConvert.ConstructLobbyLeaveMessage(data.Lobby.ID));
+        }
 
+        /*
+         * MISC make this a callback
+         * Handles the random word that has been received from the server.
+         */
+        public static void HandleRandomWord(string randomWord)
+        {
+            Debug.WriteLine("[CLIENT] Reached the handle random word method!");
+            Word = "NegerPik";
+        }
     }
 }
 

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">
@@ -35,10 +34,27 @@
 
         </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 Grid.Row="0" Grid.Column="2" FontSize="20" Content="" VerticalAlignment="Center" HorizontalAlignment="Center"/>
+            
+            <Button Name="CanvasReset" Click="CanvasReset_Click" Grid.Row="0" Grid.Column="3" Content="RESET"/>
+        </Grid>
+
+        <Button Name="StartGame" Grid.Row="0" Grid.Column="2" Content="Start Game" FontSize="20" Command="{Binding ButtonStartGame}" IsEnabled="{Binding IsHost}"/>
+        <Label Name="GuessWord" Grid.Row="0" Grid.Column="1" Content="{Binding Path=Word, UpdateSourceTrigger=PropertyChanged}" Margin="140,0,109,0"/>
 
         <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.Background>

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
 {
@@ -22,8 +15,9 @@ namespace Client.Views
         private ViewModelGame viewModel;
         public GameWindow()
         {
-            this.viewModel = new ViewModelGame();
+            this.viewModel = new ViewModelGame(this);
             DataContext = this.viewModel;
+            Closing += this.viewModel.LeaveGame;
             InitializeComponent();
             
         }
@@ -58,5 +52,6 @@ namespace Client.Views
         {
             viewModel.Color_Picker(e, this);
         }
+
     }
 }

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>

Server/Models/ServerClient.cs

@@ -6,21 +6,26 @@ 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 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 int totalBufferReceived = 0;
         public User User { get; set; }
         private ServerCommunication serverCom = ServerCommunication.INSTANCE;
+        private Callback OnMessageReceivedOk;
 
 
         /// <summary>
@@ -45,10 +50,11 @@ namespace Server.Models
             if (ar == null || (!ar.IsCompleted) || (!this.stream.CanRead) || !this.tcpClient.Client.Connected)
                 return;
 
-
+            try
+            {
                 int bytesReceived = this.stream.EndRead(ar);
 
-            if (totalBufferReceived + bytesReceived > 1024)
+                if (totalBufferReceived + bytesReceived > 2048)
                 {
                     throw new OutOfMemoryException("buffer is too small!");
                 }
@@ -84,8 +90,16 @@ namespace Server.Models
 
 
                 }
+                ar.AsyncWaitHandle.WaitOne();
                 // 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);
+            }
 
 
         }
@@ -122,11 +136,15 @@ 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(ServerCommunication.INSTANCE.GetLobbyForUser(User),payload);
-                    Debug.WriteLine("Payload has been sent!");
+                    //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:
@@ -134,11 +152,57 @@ namespace Server.Models
                     LobbyIdentifier l = JSONConvert.GetLobbyIdentifier(payload);
                     handleLobbyMessage(payload, l);
                     break;
+
                 case JSONConvert.CANVAS:
-                    Debug.WriteLine("GOT A MESSAGE FROM THE CLIENT ABOUT THE 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));
+                            break;
+
+                        case JSONConvert.CANVAS_RESET:
+                            dynamic canvasDataForReset = new
+                            {
+                                type = 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");
+                    string command = JSONConvert.GetGameCommand(payload);
+                    switch (command)
+                    {
+                        case "startGame":
+                            int lobbyID = JSONConvert.GetStartGameLobbyID(payload);
+                            serverCom.CloseALobby(lobbyID);
+                            ServerCommunication.INSTANCE.sendToAll(JSONConvert.ConstructLobbyListMessage(ServerCommunication.INSTANCE.lobbies.ToArray()));
+                            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;
@@ -162,13 +226,44 @@ namespace Server.Models
                     break;
                 case LobbyIdentifier.JOIN:
                     int id = JSONConvert.GetLobbyID(payload);
-                    ServerCommunication.INSTANCE.JoinLobby(this.User,id);
-                    sendMessage(JSONConvert.ConstructLobbyJoinSuccessMessage());
+                    bool isHost;
+                    ServerCommunication.INSTANCE.JoinLobby(this.User,id, out isHost);
+                    sendMessage(JSONConvert.ConstructLobbyJoinSuccessMessage(isHost));
+                    ServerCommunication.INSTANCE.sendToAll(JSONConvert.ConstructLobbyListMessage(ServerCommunication.INSTANCE.lobbies.ToArray()));
+                    OnMessageReceivedOk = () =>
+                    {
+                        serverCom.sendToAll(JSONConvert.GetMessageToSend(JSONConvert.RANDOMWORD, new
+                        {
+                            id = serverCom.GetLobbyForUser(User).ID,
+                            word = JSONConvert.SendRandomWord("WordsForGame.json")
+                        }));
+                        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>
         /// sends a message to the tcp client
         /// </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;
         
 
@@ -89,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)
             {
@@ -97,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)
@@ -105,7 +126,31 @@ 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)
+            {
+                if (l == lobby)
+                {
+                    foreach (ServerClient sc in serverClientsInlobbies[l])
+                    {
+                        Debug.WriteLine("[SERVERCLIENT] Sending message");
+                        sc.sendMessage(message);
+                    }
+                    break;
+                }
+            }
+        }
+
+        public void SendCanvasDataToLobby(Lobby lobby, string username, byte[] message)
         {
             foreach (Lobby l in lobbies)
             {
@@ -161,6 +206,7 @@ namespace Server.Models
             }
         }
 
+
         public int HostForLobby(User user)
         {
             Lobby lobby = new Lobby( lobbies.Count + 1,0, 8);
@@ -171,17 +217,69 @@ namespace Server.Models
             return lobby.ID;
         }
 
-        public void JoinLobby(User user, int 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;
+                                }
+                            }
+                            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,4 +1,4 @@
-using Client;
+using Client;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 using System;
@@ -6,6 +6,7 @@ using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
 using System.Text;
+using System.Windows.Media;
 
 namespace SharedClientServer
 {
@@ -15,6 +16,13 @@ namespace SharedClientServer
         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;
+
+        public const int CANVAS_WRITING = 0;
+        public const int CANVAS_RESET = 1;
+        
 
         public enum LobbyIdentifier
         {
@@ -25,9 +33,10 @@ namespace SharedClientServer
             LIST,
             REQUEST
         }
+
         public static (string,string) GetUsernameAndMessage(byte[] json)
         {
-            string msg = Encoding.ASCII.GetString(json);
+            string msg = Encoding.UTF8.GetString(json);
             dynamic payload = JsonConvert.DeserializeObject(msg);
             
             return (payload.username, payload.message);
@@ -35,7 +44,7 @@ namespace SharedClientServer
 
         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;
         }
 
@@ -83,6 +92,7 @@ namespace SharedClientServer
             });
         }
 
+
         public static byte[] ConstructLobbyJoinMessage(int lobbyID)
         {
             return GetMessageToSend(LOBBY, new
@@ -102,13 +112,13 @@ namespace SharedClientServer
         }
         public static LobbyIdentifier GetLobbyIdentifier(byte[] json)
         {
-            dynamic payload = JsonConvert.DeserializeObject(Encoding.ASCII.GetString(json));
+            dynamic payload = JsonConvert.DeserializeObject(Encoding.UTF8.GetString(json));
             return payload.identifier;
         }
 
         public static Lobby[] GetLobbiesFromMessage(byte[] json)
         {
-            dynamic payload = JsonConvert.DeserializeObject(Encoding.ASCII.GetString(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[]>();
@@ -122,24 +132,98 @@ namespace SharedClientServer
 
         public static int GetLobbyID(byte[] json)
         {
-            dynamic payload = JsonConvert.DeserializeObject(Encoding.ASCII.GetString(json));
+            dynamic payload = JsonConvert.DeserializeObject(Encoding.UTF8.GetString(json));
             return payload.id;
         }
 
         public static Lobby GetLobby(byte[] json)
         {
-            dynamic payload = JsonConvert.DeserializeObject(Encoding.ASCII.GetString(json));
+            dynamic payload = JsonConvert.DeserializeObject(Encoding.UTF8.GetString(json));
             JObject dynamicAsObject = payload.lobby;
             return dynamicAsObject.ToObject<Lobby>();
         }
 
-        public static byte[] ConstructLobbyJoinSuccessMessage()
+        public static byte[] ConstructLobbyJoinSuccessMessage(bool isHost)
         {
-            return GetMessageToSend(LOBBY, new { identifier = LobbyIdentifier.JOIN_SUCCESS});
+            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
 
+        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 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)
+        {
+            string startGame = "startGame";
+            return GetMessageToSend(GAME, new
+            {
+                command = startGame,
+                lobbyToStart = lobbyID
+            }); ;
+        }
+
+        public static string 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
         /// </summary>
@@ -149,7 +233,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
@@ -161,6 +246,40 @@ namespace SharedClientServer
             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[index];
+        }
+        
+        /*
+         * 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

@@ -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;
             }
         }
@@ -87,6 +89,11 @@ namespace Client
             set { _users = value; }
         }
 
+        public bool LobbyJoinable
+        {
+            get { return _lobbyJoinable; }
+            set { _lobbyJoinable = value; }
+        }
 
     }
 }

SharedClientServer/User.cs

@@ -1,23 +1,26 @@
 using Newtonsoft.Json;
 using System;
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using System.Text;
 
 namespace SharedClientServer
 {
-    class User
+    class User : IEquatable<User>
     {
         private string _username;
         private int _score;
         private bool _host;
+        private bool _turnToDraw;
         private string _message;
 
         [JsonConstructor]
-        public User(string username, int score, bool host)
+        public User(string username, int score, bool host, bool turnToDraw)
         {
             _username = username;
             _score = score;
             _host = host;
+            _turnToDraw = turnToDraw;
         }
 
         public User(string username)
@@ -25,6 +28,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
@@ -44,5 +84,11 @@ namespace SharedClientServer
             get { return _host; }
             set { _host = value; }
         }
+
+        public bool TurnToDraw
+        {
+            get { return _turnToDraw; }
+            set { _turnToDraw = value; }
+        }
     }
 }