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

Feature/test/game commands

Client/Client.cs

@@ -20,7 +20,7 @@ namespace Client
     public delegate void CanvasDataReceived(double[][] coordinates, Color color);
     public delegate void CanvasReset();
     public delegate void LobbyCallback(int id);
-    
+
 
     class Client : ObservableObject
     {
@@ -70,9 +70,10 @@ namespace Client
                 OnSuccessfullConnect?.Invoke();
                 OnLobbyUpdate = updateGameLobby;
                 SendMessage(JSONConvert.ConstructUsernameMessage(username));
-                this.stream.BeginRead(buffer, 0, buffer.Length, new AsyncCallback(OnReadComplete),null);
+                this.stream.BeginRead(buffer, 0, buffer.Length, new AsyncCallback(OnReadComplete), null);
 
-            } catch (Exception e)
+            }
+            catch (Exception e)
             {
                 Debug.WriteLine("Can't connect, retrying...");
                 tcpClient.BeginConnect("localhost", Port, new AsyncCallback(OnConnect), null);
@@ -113,10 +114,11 @@ namespace Client
 
                 ar.AsyncWaitHandle.WaitOne();
                 stream.BeginRead(buffer, 0, buffer.Length, new AsyncCallback(OnReadComplete), null);
-            } catch (IOException e)
+            }
+            catch (IOException e)
             {
                 Debug.WriteLine("[CLIENT] server not responding! got error: " + e.Message);
-                OnServerDisconnect?.Invoke();   
+                OnServerDisconnect?.Invoke();
             }
         }
 
@@ -139,11 +141,16 @@ namespace Client
                     string textUsername = combo.Item1;
                     string textMsg = combo.Item2;
 
-                    if(textUsername != data.User.Username)
+                    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);
@@ -191,29 +198,42 @@ namespace Client
 
                         case JSONConvert.CANVAS_WRITING:
                             CanvasDataReceived?.Invoke(JSONConvert.getCoordinates(payload), JSONConvert.getCanvasDrawingColor(payload));
-                            
                             break;
                     }
-                break;
-
+                    break;
 
                 case JSONConvert.RANDOMWORD:
                     //Flag byte for receiving the random word.
                     int lobbyId = JSONConvert.GetLobbyID(payload);
-                    string randomWord = JSONConvert.GetRandomWord(payload);
-
-                    if (data.Lobby?.ID == lobbyId)
-                        RandomWord?.Invoke(randomWord);
-                    
+                    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));
+            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");
@@ -228,7 +248,7 @@ namespace Client
 
             }
         }
-        
+
         public void SendMessage(byte[] message)
         {
             Debug.WriteLine("[CLIENT] sending message " + Encoding.ASCII.GetString(message));

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/ViewModelGame.cs

@@ -8,8 +8,8 @@ using System.ComponentModel;
 using System.Diagnostics;
 using System.Timers;
 using System.Windows;
-using System.Windows.Input;
-using System.Windows.Media;
+using System.Windows.Input;
+using System.Windows.Media;
 using System.Windows.Shapes;
 
 namespace Client.ViewModels
@@ -32,8 +32,9 @@ namespace Client.ViewModels
 
         private dynamic _payload;
 
-        public string _username;
-
+        public string _username;
+
+
         public string _message;
         public string Message
         {
@@ -73,7 +74,17 @@ namespace Client.ViewModels
             data.Client.RandomWord = HandleRandomWord;
             data.Client.IncomingMsg = HandleIncomingMsg;
             data.Client.IncomingPlayer = HandleIncomingPlayer;
-            data.Client.UpdateUserScores = UpdateUserScores;
+            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; }
@@ -82,10 +93,7 @@ namespace Client.ViewModels
        
         public void BeginGame()
         {
-            
-            queueTimer = new Timer(50);
-            queueTimer.Start();
-            queueTimer.Elapsed += sendArrayFromQueue;
+    
             data.Client.SendMessage(JSONConvert.ConstructGameStartData(data.Lobby.ID));
         }
 
@@ -93,7 +101,7 @@ namespace Client.ViewModels
         private void CanvasResetLocal()
         {
             this.window.CanvasForPaint.Children.Clear();
-            data.Client.SendMessage(JSONConvert.GetMessageToSend(JSONConvert.CANVAS, JSONConvert.CANVAS_RESET));
+            data.Client.SendMessage(JSONConvert.ConstructCanvasReset());
         }
 
 
@@ -186,7 +194,10 @@ namespace Client.ViewModels
 
         private void CanvasResetData()
         {
-            this.window.CanvasForPaint.Children.Clear();
+            Application.Current.Dispatcher.Invoke(delegate
+            {
+                this.window.CanvasForPaint.Children.Clear();
+            });
         }
 
         private void ChatBox_KeyDown()

Client/Views/GameWindow.xaml

@@ -40,10 +40,10 @@
 
             <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" Click="CanvasReset_Click" Grid.Row="0" Grid.Column="3" Content="RESET"/>
+            <Button Name="CanvasReset" Command="{Binding ButtonResetCanvas}" 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}"/>
+        
 
 
         <Border Grid.Row="1" Grid.Column="1" Margin ="10,10,10,10" BorderBrush="Black" BorderThickness ="2.5">

Client/Views/LoginScreen.xaml

@@ -25,7 +25,5 @@
 
         <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"/>
-
-        <Label Grid.Row="3" Grid.Column="0" Content="Tip of the century: base64 != UTF8!" FontSize="20" FontWeight="Bold"/>
     </Grid>
 </Window>

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

@@ -11,6 +11,7 @@ using System.Net.Sockets;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
+using System.Timers;
 using static SharedClientServer.JSONConvert;
 
 namespace Server.Models
@@ -22,7 +23,9 @@ namespace Server.Models
         private NetworkStream stream;
         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;
@@ -34,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();
@@ -145,6 +149,11 @@ namespace Server.Models
                         message = textMsg
                     };
 
+                    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;
@@ -167,13 +176,14 @@ namespace Server.Models
                                 coords = JSONConvert.getCoordinates(payload),
                                 color = JSONConvert.getCanvasDrawingColor(payload)
                             };
-                            serverCom.SendToLobby(serverCom.GetLobbyForUser(User),JSONConvert.GetMessageToSend(JSONConvert.CANVAS,canvasData));
+                            //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
                             {
-                                type = JSONConvert.GetCanvasMessageType(payload)
+                                canvasType = JSONConvert.GetCanvasMessageType(payload)
                             };
                             serverCom.SendToLobby(serverCom.GetLobbyForUser(User), JSONConvert.GetMessageToSend(CANVAS, canvasDataForReset));
                             break;
@@ -186,14 +196,35 @@ namespace Server.Models
 
                 case JSONConvert.GAME:
                     Debug.WriteLine("[SERVERCLIENT] Got a message about the game logic");
-                    string command = JSONConvert.GetGameCommand(payload);
+                    GameCommand command = JSONConvert.GetGameCommand(payload);
                     switch (command)
                     {
-                        case "startGame":
+                        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;
@@ -211,6 +242,17 @@ namespace Server.Models
             }
         }
 
+        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)
@@ -234,11 +276,11 @@ namespace Server.Models
                     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 = JSONConvert.SendRandomWord("WordsForGame.json")
+                            word = _randomWord
                         }));
                         OnMessageReceivedOk = null;
                     };

Server/Models/ServerCommunication.cs

@@ -142,7 +142,7 @@ namespace Server.Models
                 {
                     foreach (ServerClient sc in serverClientsInlobbies[l])
                     {
-                        Debug.WriteLine("[SERVERCLIENT] Sending message");
+                        Debug.WriteLine("[SERVERCLIENT] Sending message to lobby");
                         sc.sendMessage(message);
                     }
                     break;
@@ -150,6 +150,22 @@ 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)
@@ -158,7 +174,8 @@ namespace Server.Models
                 {
                     foreach (ServerClient sc in serverClientsInlobbies[l])
                     {
-                        sc.sendMessage(message);
+                        if (sc.User.Username != username)
+                            sc.sendMessage(message);
                     }
                     break;
                 }
@@ -261,6 +278,10 @@ namespace Server.Models
                                     break;
                                 }
                             }
+                            if (l.Users.Count != 0)
+                            {
+                                l.Users[0].Host = true;
+                            }
                             break;
                         }
                     }

SharedClientServer/JSONConvert.cs

@@ -1,17 +1,15 @@
 using Client;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
+using System;
+using System.Diagnostics;
 using System.IO;
-using System.Linq;
-using System.Text;
-using System.Windows.Media;
-
+using System.Text;
+using System.Windows.Media;
+
 namespace SharedClientServer
 {
-    class JSONConvert
+    public class JSONConvert
     {
         public const byte LOGIN = 0x01;
         public const byte MESSAGE = 0x02;
@@ -23,7 +21,6 @@ namespace SharedClientServer
 
         public const int CANVAS_WRITING = 0;
         public const int CANVAS_RESET = 1;
-        
 
         public enum LobbyIdentifier
         {
@@ -35,14 +32,29 @@ namespace SharedClientServer
             REQUEST
         }
 
-        public static (string,string) GetUsernameAndMessage(byte[] json)
+        public enum GameCommand
+        {
+            START_GAME,
+            TIMER_ELAPSED,
+            NEXT_ROUND
+        }
+
+        public static (string, string) GetUsernameAndMessage(byte[] json)
         {
             string msg = Encoding.UTF8.GetString(json);
-            dynamic payload = JsonConvert.DeserializeObject(msg);
-            
+            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.UTF8.GetString(json));
@@ -73,7 +85,7 @@ namespace SharedClientServer
             {
                 identifier = LobbyIdentifier.HOST,
                 id = lobbyID
-            }) ;
+            });
         }
 
         public static byte[] ConstructLobbyRequestMessage()
@@ -87,13 +99,12 @@ namespace SharedClientServer
         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
@@ -110,7 +121,8 @@ namespace SharedClientServer
                 identifier = LobbyIdentifier.LEAVE,
                 id = lobbyID
             });
-        }
+        }
+
         public static LobbyIdentifier GetLobbyIdentifier(byte[] json)
         {
             dynamic payload = JsonConvert.DeserializeObject(Encoding.UTF8.GetString(json));
@@ -146,8 +158,11 @@ namespace SharedClientServer
 
         public static byte[] ConstructLobbyJoinSuccessMessage(bool isHost)
         {
-            return GetMessageToSend(LOBBY, new { identifier = LobbyIdentifier.JOIN_SUCCESS,
-            host = isHost});
+            return GetMessageToSend(LOBBY, new
+            {
+                identifier = LobbyIdentifier.JOIN_SUCCESS,
+                host = isHost
+            });
         }
 
         public static bool GetLobbyJoinIsHost(byte[] json)
@@ -156,11 +171,10 @@ namespace SharedClientServer
             return payload.host;
         }
 
-        #endregion
+        #endregion lobby messages
 
         public static byte[] ConstructCanvasDataSend(int typeToSend, double[][] buffer, Color colorToSend)
         {
-            
             return GetMessageToSend(CANVAS, new
             {
                 canvasType = typeToSend,
@@ -177,6 +191,15 @@ namespace SharedClientServer
                 coords = buffer,
                 color = colorToSend
             });
+        }
+
+        public static byte[] ConstructCanvasReset()
+        {
+            dynamic payload = new
+            {
+                canvasType = CANVAS_RESET
+            };
+            return GetMessageToSend(CANVAS, payload);
         }
 
         public static int GetCanvasMessageType(byte[] json)
@@ -205,15 +228,23 @@ namespace SharedClientServer
 
         public static byte[] ConstructGameStartData(int lobbyID)
         {
-            string startGame = "startGame";
             return GetMessageToSend(GAME, new
             {
-                command = startGame,
+                command = GameCommand.START_GAME,
                 lobbyToStart = lobbyID
             }); ;
         }
 
-        public static string GetGameCommand(byte[] payload)
+        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;
@@ -243,13 +274,14 @@ 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.
-         */
+        }
+
+        /*
+    * 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;
@@ -258,29 +290,27 @@ namespace SharedClientServer
             string projDir = Directory.GetParent(workingDir).Parent.Parent.FullName;
             string filePath = projDir += $@"\resources\{filename}";
 
-            using(StreamReader reader = new StreamReader(filePath))
+            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];
-        }
-        
+            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
 {
-    internal class Lobby : INotifyPropertyChanged
+    public class Lobby : INotifyPropertyChanged
     {
         public event PropertyChangedEventHandler PropertyChanged;
 

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

@@ -6,13 +6,14 @@ using System.Text;
 
 namespace SharedClientServer
 {
-    class User : IEquatable<User>
+    public class User : IEquatable<User>
     {
         private string _username;
         private int _score;
         private bool _host;
         private bool _turnToDraw;
         private string _message;
+        private string _randomWord;
 
         [JsonConstructor]
         public User(string username, int score, bool host, bool turnToDraw)
@@ -90,5 +91,10 @@ namespace SharedClientServer
             get { return _turnToDraw; }
             set { _turnToDraw = value; }
         }
+        public string RandomWord
+        {
+            get { return _randomWord; }
+            set { _randomWord = value; }
+        }
     }
 }