diff --git a/Chat/annuaireUdp/annuaireUdp/Program.cs b/Chat/annuaireUdp/annuaireUdp/Program.cs
index 3f1796c92b4b4175dfa87cdbac5247e4088c1d95..6cca657df51be05b2927402b4429bb82216d06ad 100644
--- a/Chat/annuaireUdp/annuaireUdp/Program.cs
+++ b/Chat/annuaireUdp/annuaireUdp/Program.cs
@@ -84,7 +84,7 @@ namespace ServeurUdp
Socket annuaire = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
// Liaison de la socket au point de communication
- annuaire.Bind(new IPEndPoint(IPAddress.Parse(ipAnnuaire), portAnnuaire));
+ annuaire.Bind(new IPEndPoint(IPAddress.Any, portAnnuaire));
Console.WriteLine("\nAnnuaire lancé");
while (true)
diff --git a/Tron/TronClient/TronClient/ChatMessage.cs b/Tron/TronClient/TronClient/ChatMessage.cs
new file mode 100644
index 0000000000000000000000000000000000000000..a831a30c37e12071c3c1097eb9cfdc0f6a946083
--- /dev/null
+++ b/Tron/TronClient/TronClient/ChatMessage.cs
@@ -0,0 +1,73 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace ClientUdp
+{
+ public enum Commande
+ {
+ POST, GET, HELP, QUIT, STOPSERVEUR, SUBSCRIBE, SUBSCRIBEv2, UNSUBSCRIBE, CREATEROOM, LISTROOMS, SIGNALER, LISTSERVEURS, LAUNCHGAME
+ };
+
+ public enum CommandeType { REQUETE, REPONSE };
+
+ class ChatMessage
+ {
+ public const int bufferSize = 1500;
+ public const int headerSize = 35;
+
+ public Commande commande; // commande
+ public CommandeType commandeType; // type (Requête/Réponse)
+ public int dataSize; // taille de la donnée
+ public String data; // données de la commande
+ public String pseudo; // pseudo de l'envoyeur
+
+ public ChatMessage(Commande commande, CommandeType type, String data, String pseudo)
+ {
+ this.commande = commande;
+ this.commandeType = type;
+ this.dataSize = data.Length;
+ this.data = data;
+ this.pseudo = pseudo;
+ }
+
+ public ChatMessage(byte[] buffer)
+ {
+ commande = (Commande)buffer[0];
+ commandeType = (CommandeType)buffer[1];
+ pseudo = Encoding.ASCII.GetString(buffer, 2, 30).TrimEnd(new char[] { '\0' });
+ dataSize = BitConverter.ToInt32(buffer, 32);
+ data = Encoding.ASCII.GetString(buffer, 36, dataSize);
+ }
+
+ public byte[] GetBytes()
+ {
+ byte[] buffer = new byte[bufferSize]; // Déclaration du buffer
+
+ buffer[0] = (byte)commande; // Commande
+ buffer[1] = (byte)commandeType; // Type de la commande
+ Encoding.ASCII.GetBytes(pseudo, 0, pseudo.Length, buffer, 2); // Pseudo à 30 bits
+ byte[] intBuf = BitConverter.GetBytes(dataSize); // Taille de la data
+ buffer[32] = intBuf[0]; // Int stocké sur 4bits
+ buffer[33] = intBuf[1];
+ buffer[34] = intBuf[2];
+ buffer[35] = intBuf[3];
+ Encoding.ASCII.GetBytes(data, 0, data.Length, buffer, 36); // Data
+
+ return buffer;
+ }
+
+ public static byte[] GetBytes(Commande commande, CommandeType type, String data, String pseudo)
+ {
+ ChatMessage chatCommande = new ChatMessage(commande, type, data, pseudo);
+ return chatCommande.GetBytes();
+ }
+
+ public override string ToString()
+ {
+ return "[" + commande + "," + commandeType + ",\"" + pseudo + "\"," + dataSize + ",\"" + data + "\"]";
+ }
+
+ }
+}
diff --git a/Tron/TronClient/TronClient/ClientUdp.cs b/Tron/TronClient/TronClient/ClientUdp.cs
new file mode 100644
index 0000000000000000000000000000000000000000..d3de6e5b6c014857b65e1dc4881c241f7291eff8
--- /dev/null
+++ b/Tron/TronClient/TronClient/ClientUdp.cs
@@ -0,0 +1,320 @@
+using System;
+using System.Net;
+using System.Net.Sockets;
+using System.IO;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading;
+namespace ClientUdp
+{
+ class ClientUdp
+ {
+ const int MsgsBufferSize = 100000000;
+ static string serverIP = "127.0.0.1"; // A changer
+ static int serverPort = 17021; // A changer
+ static string currentRoom = "Menu principal";
+ static string messages = "";
+ static volatile bool threadIsRunning;
+ static bool isSuscriber = false;
+ static bool createRoom = false;
+
+ // Création du EndPoint serveur
+ static EndPoint serverEP;
+
+ // Création de la socket d'écoute UDP
+ static Socket clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
+ static string getName(string HardName)
+ {
+ String name = String.Empty;
+ bool nameValide = true;
+ while (nameValide)
+ {
+ // Lecture pseudo au clavier
+ Console.Write(HardName + " : ");
+ name = Console.ReadLine();
+ if (name.Length > 30) //on vérifie que le pseudo/nom de la room ne fasse pas plus de 30 caractères, taille fixe définie dans la classe ChatMessage
+ {
+ Console.WriteLine("Le " + HardName + " est trop long");
+ }
+ else
+ {
+ nameValide = false;
+ }
+ }
+ return name;
+ }
+ static string getMessage()
+ {
+ String msg = String.Empty;
+ bool messageValide = true;
+ while (messageValide)
+ {
+ // Lecture du message au clavier
+ Console.Write("Message : ");
+ msg = Console.ReadLine();
+ if (msg.Length > ChatMessage.bufferSize - ChatMessage.headerSize) //on vérifie que le message ne dépassera pas la taille du buffer
+ {
+ Console.WriteLine("Le message est trop long");
+ }
+ else
+ {
+ messageValide = false;
+ }
+ }
+ return msg;
+ }
+ static void receiveMsgs()
+ {
+ do
+ {
+ Object o = receive(MsgsBufferSize);
+ if (o is ChatMessage)
+ {
+ TronClient.Program.LaunchTron();
+ }
+ else
+ {
+ messages = o.ToString();
+ displayMsgs();
+ displayMenu();
+ }
+ }
+ while (threadIsRunning);
+ }
+
+ static Object receive(int size)
+ {
+ // Création du buffer qui va réceptionner les infos
+ byte[] bufferGet = new byte[size];
+ // Réception des infos
+ int nBytes = clientSocket.ReceiveFrom(bufferGet, bufferGet.Length, SocketFlags.None, ref serverEP);
+ try
+ {
+ return Encoding.ASCII.GetString(bufferGet, 0, nBytes);
+ }
+ catch
+ {
+ return new ChatMessage(bufferGet);
+ }
+
+
+ }
+
+ static void displayMsgs()
+ {
+ string[] listMessages = messages.Split('/');
+ // Affichage des messages
+ Console.Clear();
+ Console.WriteLine("======== " + currentRoom + " ========");
+ Console.WriteLine("");
+ foreach (string mess in listMessages)
+ {
+ Console.WriteLine(mess);
+ }
+ }
+
+ static void displayMenu()
+ {
+ // Affichage du menu
+ if (createRoom)
+ {
+ Console.WriteLine("1. Envoyer un message");
+ Console.WriteLine("2. Demander messages");
+ Console.WriteLine("3. S'abonner");
+ Console.WriteLine("4. Se désabonner");
+ Console.WriteLine("5. Créer une room");
+ Console.WriteLine("6. Lister les rooms");
+ Console.WriteLine("7. Lister les serveurs");
+ Console.WriteLine("8. Lancer Tron");
+ Console.Write("Votre choix : ");
+ }
+ else//si pas de room créée
+ {
+ Console.WriteLine("1. Créer une room");
+ Console.Write("Votre choix : ");
+ }
+
+ }
+
+ static void Main(string[] args)
+ {
+ try
+ {
+ //************************************************************** Initialisation
+ bool continuer = true;
+ //connexion au serveur
+ serverEP = new IPEndPoint(IPAddress.Parse(serverIP), serverPort);
+ // Liaison de la socket au point de communication
+ clientSocket.Bind(new IPEndPoint(IPAddress.Any, 58600));
+ //************************************************************** Communications
+ while (continuer)
+ {
+ // Affichage des messages
+ Thread.Sleep(500);
+ displayMsgs();
+ displayMenu();
+
+ string choice = Console.ReadLine();//lecture du choix
+ if (!createRoom && choice == "1")
+ {
+ choice = "5";
+ }
+
+ // Traitement du choix du menu
+
+ switch (choice)
+ {
+ case "1": // Si envoi message
+ // Appel de la fonction qui renvoie le pseudo lu au clavier avec les vérifications nécessaires
+ string pseudo = getName("Pseudo");
+ // Appel de la fonction qui renvoie le message lu au clavier avec les vérifications nécessaires
+ string msg = getMessage();
+ // Création du message en POST de type REQUETE avec le message entré au clavier plus le pseudo entré également au clavier
+ ChatMessage chat_message = new ChatMessage(Commande.POST, CommandeType.REQUETE, msg, pseudo);
+
+ // Encodage string dans un buffer de bytes en ASCII
+ // Transformation des messages en Bytes et placer dans les différents buffer
+ byte[] buffer = chat_message.GetBytes();
+
+ // Envoi du message POST au serveur
+ clientSocket.SendTo(buffer, 0, buffer.Length, SocketFlags.None, serverEP);
+ Console.WriteLine("Message envoyé");
+ Thread.Sleep(500);
+ break;
+ case "2": // Si requête GET
+
+ if (!isSuscriber)
+ {
+ // Création requête GET
+ ChatMessage get_msg = new ChatMessage(Commande.GET, CommandeType.REQUETE, "", "");
+ byte[] bufferGet = get_msg.GetBytes();
+
+ // Envoi requête
+ clientSocket.SendTo(bufferGet, 0, bufferGet.Length, SocketFlags.None, serverEP);
+
+ // Réception messages
+ receiveMsgs();
+ }
+ break;
+
+ case "3": // Si abonnement
+ if (!isSuscriber)
+ {
+ // Création de la demande d'abonnement et du buffer associé
+ ChatMessage chat_subscribe = new ChatMessage(Commande.SUBSCRIBE, CommandeType.REQUETE, "", "");
+ byte[] bufferSubscr = chat_subscribe.GetBytes();
+
+ // Envoi de la demande d'abonnement
+ clientSocket.SendTo(bufferSubscr, 0, bufferSubscr.Length, SocketFlags.None, serverEP);
+
+ // Création du thread
+ Thread t = new Thread(new ThreadStart(receiveMsgs));
+ t.Start();
+ isSuscriber = true;
+ threadIsRunning = true;
+ Console.WriteLine("Vous êtes abonné");
+ Thread.Sleep(500);
+ }
+
+ break;
+
+
+ case "4": // Si désabonnement
+ // Arrêt du thread
+ threadIsRunning = false;
+
+ // Création de la demande de désabonnement et du buffer associé
+ ChatMessage chat_unsubscribe = new ChatMessage(Commande.UNSUBSCRIBE, CommandeType.REQUETE, "", "");
+ byte[] bufferUnsub = chat_unsubscribe.GetBytes();
+
+ // Envoi de la demande d'abonnement
+ clientSocket.SendTo(bufferUnsub, 0, bufferUnsub.Length, SocketFlags.None, serverEP);
+ isSuscriber = false;
+ Console.WriteLine("Désabonnement réussi");
+ Thread.Sleep(500);
+ break;
+
+ case "5": // Si création d'une room
+
+ createRoom = true;
+
+ // Appel de la fonction qui renvoie le nom de la room lu au clavier avec les vérifications nécessaires
+ string nameRoom = getName("Nom de la room");
+
+
+ // Envoi CREATEROOM au serveur
+ ChatMessage chat_nameRoom = new ChatMessage(Commande.CREATEROOM, CommandeType.REQUETE, nameRoom, "");
+ byte[] buffer_room = chat_nameRoom.GetBytes();
+ clientSocket.SendTo(buffer_room, 0, buffer_room.Length, SocketFlags.None, serverEP);
+
+ //connexion à la room
+ byte[] buf = new byte[MsgsBufferSize];
+ int nBytes = clientSocket.ReceiveFrom(buf, buf.Length, SocketFlags.None, ref serverEP);
+ int port = int.Parse(Encoding.ASCII.GetString(buf, 0, nBytes));
+
+ //on lie mnt le client sur la socket de la room qu'il vient de créer
+ serverEP = new IPEndPoint(IPAddress.Parse(serverIP), port);
+ Console.WriteLine("Connexion à la room...");
+ currentRoom = nameRoom;
+ Thread.Sleep(1000);
+
+ break;
+
+ case "6": // si demande de lister les rooms
+
+ ChatMessage get_rooms = new ChatMessage(Commande.LISTROOMS, CommandeType.REQUETE, "", "");
+ byte[] bufferGetRooms = get_rooms.GetBytes();
+
+ // Envoi LISTROOMS au serveur
+ clientSocket.SendTo(bufferGetRooms, 0, bufferGetRooms.Length, SocketFlags.None, serverEP);
+
+ if (!isSuscriber)
+ {
+ messages = receive(MsgsBufferSize).ToString();
+ }
+ break;
+
+ case "7": // si demande de lister les serveurs
+ ChatMessage get_servers = new ChatMessage(Commande.LISTSERVEURS, CommandeType.REQUETE, "", "");
+ byte[] bufferGetServers = get_servers.GetBytes();
+
+ serverEP = new IPEndPoint(IPAddress.Parse(serverIP), 17020);//appel à l'annuaire pour récupérer la liste
+
+ // Envoi LISTSERVEURS au serveur
+ clientSocket.SendTo(bufferGetServers, 0, bufferGetServers.Length, SocketFlags.None, serverEP);
+
+ // Réception des serveurs
+ receiveMsgs();
+ break;
+
+ case "8": // si on veut lancer Tron
+ ChatMessage msg_game = new ChatMessage(Commande.LAUNCHGAME, CommandeType.REQUETE, "", "");
+ byte[] bufferGame = msg_game.GetBytes();
+
+ serverEP = new IPEndPoint(IPAddress.Parse(serverIP), 17020);//appel à l'annuaire pour récupérer la liste
+
+ // Envoi LISTSERVEURS au serveur
+ clientSocket.SendTo(bufferGame, 0, bufferGame.Length, SocketFlags.None, serverEP);
+ break;
+
+ default: // Si mauvaise entrée
+ Console.WriteLine("Veuillez entrer un choix valide !");
+ Thread.Sleep(2000);
+ break;
+ }
+ }
+ //************************************************************** Conclusion
+ // Fermeture socket
+ Console.WriteLine("Fermeture Socket...");
+ clientSocket.Close();
+ }
+ catch (SocketException E)
+ {
+ Console.WriteLine(E.Message);
+ Console.ReadKey();
+ }
+ Console.ReadKey();
+ }
+ }
+}
\ No newline at end of file
diff --git a/Tron/TronClient/TronClient/Program.cs b/Tron/TronClient/TronClient/Program.cs
index 17b0769a8c8b44a3348100edf23beb6b42fbb52a..965197e2bc5fabd3f737f7139b77d65f28de8a08 100644
--- a/Tron/TronClient/TronClient/Program.cs
+++ b/Tron/TronClient/TronClient/Program.cs
@@ -12,7 +12,7 @@ namespace TronClient
/// </summary>
//[STAThread]
- static void Main()
+ public static void LaunchTron()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
diff --git a/Tron/TronServeur/TronServeur/ChatMessage.cs b/Tron/TronServeur/TronServeur/ChatMessage.cs
new file mode 100644
index 0000000000000000000000000000000000000000..a831a30c37e12071c3c1097eb9cfdc0f6a946083
--- /dev/null
+++ b/Tron/TronServeur/TronServeur/ChatMessage.cs
@@ -0,0 +1,73 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace ClientUdp
+{
+ public enum Commande
+ {
+ POST, GET, HELP, QUIT, STOPSERVEUR, SUBSCRIBE, SUBSCRIBEv2, UNSUBSCRIBE, CREATEROOM, LISTROOMS, SIGNALER, LISTSERVEURS, LAUNCHGAME
+ };
+
+ public enum CommandeType { REQUETE, REPONSE };
+
+ class ChatMessage
+ {
+ public const int bufferSize = 1500;
+ public const int headerSize = 35;
+
+ public Commande commande; // commande
+ public CommandeType commandeType; // type (Requête/Réponse)
+ public int dataSize; // taille de la donnée
+ public String data; // données de la commande
+ public String pseudo; // pseudo de l'envoyeur
+
+ public ChatMessage(Commande commande, CommandeType type, String data, String pseudo)
+ {
+ this.commande = commande;
+ this.commandeType = type;
+ this.dataSize = data.Length;
+ this.data = data;
+ this.pseudo = pseudo;
+ }
+
+ public ChatMessage(byte[] buffer)
+ {
+ commande = (Commande)buffer[0];
+ commandeType = (CommandeType)buffer[1];
+ pseudo = Encoding.ASCII.GetString(buffer, 2, 30).TrimEnd(new char[] { '\0' });
+ dataSize = BitConverter.ToInt32(buffer, 32);
+ data = Encoding.ASCII.GetString(buffer, 36, dataSize);
+ }
+
+ public byte[] GetBytes()
+ {
+ byte[] buffer = new byte[bufferSize]; // Déclaration du buffer
+
+ buffer[0] = (byte)commande; // Commande
+ buffer[1] = (byte)commandeType; // Type de la commande
+ Encoding.ASCII.GetBytes(pseudo, 0, pseudo.Length, buffer, 2); // Pseudo à 30 bits
+ byte[] intBuf = BitConverter.GetBytes(dataSize); // Taille de la data
+ buffer[32] = intBuf[0]; // Int stocké sur 4bits
+ buffer[33] = intBuf[1];
+ buffer[34] = intBuf[2];
+ buffer[35] = intBuf[3];
+ Encoding.ASCII.GetBytes(data, 0, data.Length, buffer, 36); // Data
+
+ return buffer;
+ }
+
+ public static byte[] GetBytes(Commande commande, CommandeType type, String data, String pseudo)
+ {
+ ChatMessage chatCommande = new ChatMessage(commande, type, data, pseudo);
+ return chatCommande.GetBytes();
+ }
+
+ public override string ToString()
+ {
+ return "[" + commande + "," + commandeType + ",\"" + pseudo + "\"," + dataSize + ",\"" + data + "\"]";
+ }
+
+ }
+}
diff --git a/Tron/TronServeur/TronServeur/Program.cs b/Tron/TronServeur/TronServeur/Program.cs
index e92b8e9312e6c502fd150442a821a71cc213b653..f7d8fedef2d2858f22e71377aca9ca5932b66b96 100644
--- a/Tron/TronServeur/TronServeur/Program.cs
+++ b/Tron/TronServeur/TronServeur/Program.cs
@@ -11,10 +11,10 @@ namespace TronServeur
{
class Program
{
- static void Main(string[] args)
+ public static void LaunchTron(byte n)
{
Tron.Tron myTron; // Moteur du jeu
- byte nJoueurs = 3; // Nombre de joueurs
+ byte nJoueurs = n; // Nombre de joueurs
byte frequence = 4; // Temps du tour de jeu (en dixieme de s)
byte taille = 60; // Taille du terrain
diff --git a/Tron/TronServeur/TronServeur/ServeurUdp.cs b/Tron/TronServeur/TronServeur/ServeurUdp.cs
new file mode 100644
index 0000000000000000000000000000000000000000..80b47a85bf216cb3290c9ae3bab6adf6044b31a2
--- /dev/null
+++ b/Tron/TronServeur/TronServeur/ServeurUdp.cs
@@ -0,0 +1,292 @@
+using System;
+using System.Net;
+using System.Net.Sockets;
+using System.IO;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using ClientUdp;
+using System.Threading;
+
+namespace ServeurUdp
+{
+ class ServeurUdp
+ {
+ const int MsgsBufferSize = 100000000;
+ string messages = String.Empty;
+ string server = String.Empty;
+ List<EndPoint> subscribers = new List<EndPoint>();
+ List<EndPoint> alreadyConnectedRoom = new List<EndPoint>();
+ string nameRoom = string.Empty;
+ static int numPort = 17021;
+ static bool display = false;
+ static bool insert = false;
+
+ EndPoint annuaire = new IPEndPoint(IPAddress.Parse(ipAnnuaire), portAnnuaire);
+
+ //éléments de base pour implémenter l'annuaire
+ static int portAnnuaire = 17020;
+ static string ipAnnuaire = "130.79.81.203";
+
+ void sendMsgs(Socket serverSocket, EndPoint clientEP)
+ {
+ // Pas de message sur le serveur on l'indique au client
+ if (messages == String.Empty)
+ {
+ byte[] buf = Encoding.ASCII.GetBytes("Il n'y a aucun message d'enregistré sur le serveur !");
+ serverSocket.SendTo(buf, 0, buf.Length, SocketFlags.None, clientEP);
+ }
+ // Envoi des messages au client
+ else
+ {
+ byte[] buf = System.Text.Encoding.ASCII.GetBytes(messages);
+ serverSocket.SendTo(buf, 0, buf.Length, SocketFlags.None, clientEP);
+ }
+ Console.WriteLine("Liste des messages envoyée !");
+ }
+
+ //pour chaque abonné on envoie les messages
+ void updateSubscribers(Socket serverSocket)
+ {
+ foreach (EndPoint ep in subscribers)
+ {
+ sendMsgs(serverSocket, ep);
+ }
+ }
+
+ //on regarde si un client est abonné
+ bool isSubscriber(EndPoint ep)
+ {
+ bool res = false;
+ for (int i = 0; i < subscribers.Count && !res; i++)
+ {
+ if (subscribers.ElementAt(i).ToString() == ep.ToString())
+ {
+ res = true;
+ }
+ }
+ return res;
+ }
+
+ //on regarde si le client est déjà connecté à une room
+ bool isConnectedToRoom(EndPoint ep)
+ {
+ bool res = false;
+ foreach (EndPoint client in alreadyConnectedRoom)
+ {
+ if (client.ToString() == ep.ToString())
+ {
+ res = true;
+ }
+ }
+ return res;
+ }
+
+ //création de la chat room
+ static void createChat(string nameRoom, Socket serverSocket)
+ {
+ ServeurUdp chatServer = new ServeurUdp();
+
+ //création de la nouvelle socket pour la chat room
+ numPort++;
+ string[] args = { numPort.ToString(), nameRoom };//envoi du numéro de port pour la chat room (sera à chaque fois incrémenté)
+
+ //création et lancement du Thread qui contiendra le MainServer
+ Thread chatServerThread = new System.Threading.Thread(() => chatServer.MainServer(args));
+ chatServerThread.Start();
+ }
+
+ public static void Main(string[] args)
+ {
+ //Serveur
+ ServeurUdp server = new ServeurUdp();
+
+ //on place le numéro du serveur de base en dur
+ string[] arg = { 17021.ToString() };
+ server.MainServer(arg);
+ }
+
+ public void MainServer(string[] args)
+ {
+ try
+ {
+ // ************************************************************** Initialisation
+
+ // Création de la socket d'écoute UDP / socket pour chaque chat room
+ Socket serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
+
+ // Liaison de la socket au point de communication
+ int num_port = int.Parse(args[0]);//on récupère le numéro de port qui a été incrémenté dans la fonction createChat
+
+ serverSocket.Bind(new IPEndPoint(IPAddress.Any, num_port));
+
+ if (!insert)//on enregistre pas le tout premier serveur lancé
+ {
+ insert = true;
+ }
+ else
+ {
+ //envoi de la requête signaler à l'annuaire dès qu'on crée un serveur de chat
+ string nameRoom = args[1];
+ ChatMessage get_signal = new ChatMessage(Commande.SIGNALER, CommandeType.REQUETE, nameRoom, num_port.ToString());
+ byte[] bufferGetSignal = get_signal.GetBytes();
+ serverSocket.SendTo(bufferGetSignal, 0, bufferGetSignal.Length, SocketFlags.None, annuaire);//on envoie à l'annuaire pour qu'il stocke le serveur et la room dans sa liste
+ }
+
+ bool continuer = true;
+
+ //************************************************************** Communications
+
+ while (continuer)
+ {
+ Console.WriteLine("\n************************ Attente d'un nouveau message ************************");
+ if (!display)
+ {
+ Console.WriteLine("numéro de port du serveur de base : " + serverSocket.LocalEndPoint);
+ display = true;
+ }
+ else
+ {
+ Console.WriteLine("numéro de port de la chat room : " + serverSocket.LocalEndPoint);
+ }
+
+ // Reception message client
+ EndPoint clientEP = new IPEndPoint(IPAddress.Any, 0);
+ byte[] buffer = new byte[ChatMessage.bufferSize];
+ serverSocket.ReceiveFrom(buffer, buffer.Length, SocketFlags.None, ref clientEP);
+
+ // Message instancié à partir du buffer
+ ChatMessage msg = new ChatMessage(buffer);
+
+ // Traitement par commande
+ switch (msg.commande)
+ {
+ // Si envoi de message
+ case Commande.POST:
+ messages += msg.pseudo + ':' + msg.data + '/';
+ Console.WriteLine(msg.ToString());
+ updateSubscribers(serverSocket);
+ break;
+
+ // Si demande des messages du serveur
+ case Commande.GET:
+ Console.WriteLine("Envoi des messages GET");
+ sendMsgs(serverSocket, clientEP);
+ break;
+
+ // Si demande d'abonnement aux messages
+ case Commande.SUBSCRIBE:
+ Console.WriteLine("Demande d'abonnement...");
+ if (!isSubscriber(clientEP))
+ {
+ Console.WriteLine("Un client s'est abonné");
+ subscribers.Add(clientEP);
+ }
+ else
+ {
+ Console.WriteLine("Le client est déjà abonné");
+ }
+ updateSubscribers(serverSocket);
+ break;
+
+ // Si demande de désabonnement
+ case Commande.UNSUBSCRIBE:
+ Console.WriteLine("Demande de désabonnement...");
+ if (isSubscriber(clientEP))
+ {
+ Console.WriteLine("Un client s'est désabonné");
+ sendMsgs(serverSocket, clientEP); // Pour débloquer le client afin qu'il termine son thread
+ subscribers.Remove(clientEP);
+ }
+ else
+ {
+ Console.WriteLine("Le client n'est pas abonné");
+ }
+ break;
+
+ case Commande.CREATEROOM://création d'une room
+
+ Console.WriteLine("Demande de création d'une room...");
+ Console.WriteLine("Un client a créé la room : " + msg.data + " et y a été automatiquement ajouté");
+ //création de la chat room
+ nameRoom = msg.data;
+ createChat(msg.data, serverSocket);
+
+ //on réenvoie le numéro de port de la chat room pour qu'on puisse connecter le client à celle-ci (permettra aussi les tests de créer une room dans une room)
+ byte[] buf = Encoding.ASCII.GetBytes(numPort.ToString());
+ serverSocket.SendTo(buf, 0, buf.Length, SocketFlags.None, clientEP);
+
+ break;
+
+ case Commande.LISTROOMS: // retourne toutes les rooms créées
+
+ Console.WriteLine("Demande de lister les rooms...");
+
+ //envoie demande à l'annuaire
+ ChatMessage get_rooms = new ChatMessage(Commande.LISTROOMS, CommandeType.REQUETE, "", "");
+ byte[] bufferGetRooms = get_rooms.GetBytes();
+ serverSocket.SendTo(bufferGetRooms, 0, bufferGetRooms.Length, SocketFlags.None, annuaire);
+
+ //réception des rooms
+ EndPoint annuairee = new IPEndPoint(IPAddress.Any, 0);
+ byte[] buff = new byte[MsgsBufferSize];
+ int nBytes = serverSocket.ReceiveFrom(buff, buff.Length, SocketFlags.None, ref annuairee);
+
+ string rooms = Encoding.ASCII.GetString(buff, 0, nBytes);
+
+ //envoie au client
+ byte[] buf_room = Encoding.ASCII.GetBytes(rooms);
+ serverSocket.SendTo(buf_room, 0, buf_room.Length, SocketFlags.None, clientEP);
+
+ break;
+
+ // on va rechercher dans l'annuaire
+ case Commande.LISTSERVEURS:
+ Console.WriteLine("Demande de lister les serveurs...");
+
+ //envoie demande à l'annuaire
+ ChatMessage get_servers = new ChatMessage(Commande.LISTSERVEURS, CommandeType.REQUETE, "", "");
+ byte[] bufferGetServers = get_servers.GetBytes();
+ serverSocket.SendTo(bufferGetServers, 0, bufferGetServers.Length, SocketFlags.None, annuaire);
+
+ //réception des rooms
+ EndPoint annu = new IPEndPoint(IPAddress.Any, 0);
+ byte[] buf_annuaire = new byte[ChatMessage.bufferSize];
+ int nbBytes = serverSocket.ReceiveFrom(buf_annuaire, buf_annuaire.Length, SocketFlags.None, ref annu);
+ string servers = Encoding.ASCII.GetString(buf_annuaire, 0, nbBytes);
+
+ //envoie au client
+ byte[] buf_ann = Encoding.ASCII.GetBytes(servers);
+ serverSocket.SendTo(buf_ann, 0, buf_ann.Length, SocketFlags.None, clientEP);
+
+ break;
+
+ // Lancement de Tron
+ case Commande.LAUNCHGAME:
+ Console.WriteLine("Lancement de Tron...");
+ TronServeur.Program.LaunchTron((byte) subscribers.Count);
+
+ foreach (EndPoint ep in subscribers)
+ {
+ ChatMessage msg_launch = new ChatMessage(Commande.LAUNCHGAME, CommandeType.REPONSE, "", "");
+ byte[] bufferLaunch = msg_launch.GetBytes();
+ serverSocket.SendTo(bufferLaunch, 0, bufferLaunch.Length, SocketFlags.None, ep);
+ }
+
+ break;
+ }
+ }
+ // Fermeture socket
+ Console.WriteLine("Fermeture Socket...");
+ serverSocket.Close();
+ //************************************************************** Conclusion
+ }
+ catch (SocketException E)
+ {
+ Console.WriteLine(E.Message);
+ Console.ReadKey();
+ }
+ Console.ReadKey();
+ }
+ }
+}
\ No newline at end of file