On fait maintenant en fonction du temps pour liberer le port, optimisatonnnn!!!

code/server/Server/PongServer.cs

@@ -38,9 +38,10 @@ public class PongServer
             byte[] receivedData = serverSocket.Receive(ref remoteEndPoint);
             string fileJson = Encoding.UTF8.GetString(receivedData);
             ObjectTransfert<Player> data = JsonSerializer.Deserialize<ObjectTransfert<Player>>(fileJson);
-            
+
             if (data.Informations.Action == Shared.DTO.Action.Host)
             {
+
                 Host(data, remoteEndPoint, serverSocket, false);
 
             }
@@ -105,26 +106,29 @@ public class PongServer
         rooms[data.Data.playerId] = room;
         room.PropertyChanged += room.OnReadyChanged;
 
+        Console.WriteLine("FIN HOST...............");
+
     }
 
     private void Join(ObjectTransfert<Player> data, IPEndPoint remoteEndPoint, UdpClient serverSocket, Room room)
     {
 
         room.playerJoin = new KeyValuePair<Player, UdpClient>(data.Data, room.playerHost.Value);
-
+        
 
         Console.WriteLine("New connection Client from " + remoteEndPoint.ToString());
 
-        Tuple<int, bool> dataToSend = new Tuple<int, bool>(room.Port, true);
+        Tuple<int, bool> dataToSend = new Tuple<int, bool>(room.Port, false);
         Console.WriteLine(JsonSerializer.Serialize(dataToSend));
 
         // Send port message to client
         byte[] connectionData = Encoding.ASCII.GetBytes(JsonSerializer.Serialize(dataToSend));
         serverSocket.Send(connectionData, connectionData.Length, remoteEndPoint);
-
+        
         room.PropertyChanged += room.OnReadyChanged;
         room.NbPlayer++;
 
+        Console.WriteLine("FIN JOIN...............");
     }
 
 }

code/server/Server/Room.cs

@@ -61,59 +61,74 @@ namespace Server
         {
             IPEndPoint remoteEndPoint = new IPEndPoint(IPAddress.Any, 0);
 
+            Thread secondsCount = new Thread(new ThreadStart(CountSeconds));
+            secondsCount.Start();
+
+            //while (secondsCount.ThreadState==ThreadState.Running )
             while (true)
             {
                 byte[] receivedData = clientSocket1.Receive(ref remoteEndPoint);
                 semaphore.WaitOne();
 
                 clientSocket2.Send(receivedData, receivedData.Length, endpoint2);
-
                 semaphore.Release();
+            }
+            Availaible = true;
+        }
 
-
+        static void CountSeconds()
+        {
+            int seconds = 0;
+            while (seconds<=121)
+            {
+                seconds++;
+                Thread.Sleep(1000);
             }
         }
 
         public void OnReadyChanged(object sender, PropertyChangedEventArgs e)
         {
+            /*Thread principal = new Thread(() =>
+            {*/
+                Room room = sender as Room;
+                int maxPlayer = room.nbPlayer;
 
-            Room room = sender as Room;
-            int maxPlayer = room.nbPlayer;
 
+                if (maxPlayer == 2)
+                {
+                    room.Availaible = false;
+                    IPEndPoint remoteEndPointHost = new IPEndPoint(IPAddress.Any, room.Port);
+                    IPEndPoint remoteEndPointJoin = new IPEndPoint(IPAddress.Any, room.Port);
 
 
-            if (maxPlayer == 2)
-            {
-                IPEndPoint remoteEndPointHost = new IPEndPoint(IPAddress.Any, room.Port);
-                IPEndPoint remoteEndPointJoin = new IPEndPoint(IPAddress.Any, room.Port);
-
-
-                byte[] receivedDataHost = playerHost.Value.Receive(ref remoteEndPointHost);
-                byte[] receivedDataJoin = playerJoin.Value.Receive(ref remoteEndPointJoin);
-                
-                playerJoin.Value.Send(receivedDataHost, receivedDataHost.Length, remoteEndPointHost);
-                playerHost.Value.Send(receivedDataJoin, receivedDataJoin.Length, remoteEndPointJoin);
+                    byte[] receivedDataHost = playerHost.Value.Receive(ref remoteEndPointHost);
+                    byte[] receivedDataJoin = playerJoin.Value.Receive(ref remoteEndPointJoin);
 
-                Semaphore semaphore = new Semaphore(2,2);
+                    playerJoin.Value.Send(receivedDataHost, receivedDataHost.Length, remoteEndPointHost);
+                    playerHost.Value.Send(receivedDataJoin, receivedDataJoin.Length, remoteEndPointJoin);
 
+                    Semaphore semaphore = new Semaphore(2, 2);
 
-                Thread receiveThread1 = new Thread(() => ReceiveMessages(playerHost.Value, playerJoin.Value, remoteEndPointJoin, semaphore));
 
+                    Thread receiveThread1 = new Thread(() => ReceiveMessages(playerHost.Value, playerJoin.Value, remoteEndPointJoin, semaphore));
 
-                Thread receiveThread2 = new Thread(() => {
-                    ReceiveMessages(playerJoin.Value, playerHost.Value, remoteEndPointHost, semaphore);
-                });
-                receiveThread1.Start();
-                receiveThread2.Start();
 
+                    Thread receiveThread2 = new Thread(() =>
+                    {
+                        ReceiveMessages(playerJoin.Value, playerHost.Value, remoteEndPointHost, semaphore);
+                    });
+                    receiveThread1.Start();
+                    receiveThread2.Start();
 
-                receiveThread1.Join();
-                receiveThread2.Join();
 
-                
-            }
+                    receiveThread1.Join();
+                    receiveThread2.Join();
+                }
 
+            /*});
+            principal.Start();*/
         }
+            
 
     }
 }