a3b728ab0166 — cedricbonhomme tip 12 years ago
Removed tabulations.
M serveurPartie/game.cpp +589 -589
@@ 20,755 20,755 @@ pthread_mutex_t mutexSend = PTHREAD_MUTE
 
 
 Game::Game(u_short portEcoute, u_short portLecture, u_short portEcouteServeur,
-			u_short portEcouteDistant, u_short portEcouteServeurPrincipal, string adresseServeurPrincipal)
+            u_short portEcouteDistant, u_short portEcouteServeurPrincipal, string adresseServeurPrincipal)
 {
-	this->log("Creation serveur de partie.");
+    this->log("Creation serveur de partie.");
 
-	this->numberGhost = 0;
-	this->numberPacman = 0;
-	this->numberPlayer = 0;
+    this->numberGhost = 0;
+    this->numberPacman = 0;
+    this->numberPlayer = 0;
 
-	this->portEcoute = portEcoute;
-	this->portLecture = portLecture;
-	this->portEcouteDistant = portEcouteDistant;
-	this->portEcouteServeur = portEcouteServeur;
-	this->portEcouteServeurPrincipal = portEcouteServeurPrincipal;
+    this->portEcoute = portEcoute;
+    this->portLecture = portLecture;
+    this->portEcouteDistant = portEcouteDistant;
+    this->portEcouteServeur = portEcouteServeur;
+    this->portEcouteServeurPrincipal = portEcouteServeurPrincipal;
 
-	this->jeton = "jeton";
+    this->jeton = "jeton";
 
-	this->adresseServeurPrincipal = adresseServeurPrincipal;
+    this->adresseServeurPrincipal = adresseServeurPrincipal;
 
-	this->sockEcouteServeur = this->createTCPSock(this->portEcouteServeur);
-	this->sockLecture = this->createUDPSock(this->portLecture);
+    this->sockEcouteServeur = this->createTCPSock(this->portEcouteServeur);
+    this->sockLecture = this->createUDPSock(this->portLecture);
 
-	listen(this->sockEcouteServeur, 10);
+    listen(this->sockEcouteServeur, 10);
 }
 
 Game::~Game()
 {
-	this->gamerList.clear();
-	close(this->sockEcoute);
-	close(this->sockLecture);
-	this->numberPlayer = 0;
-	this->numberPacman = 0;
-	this->numberGhost = 0;
-	this->jeton = "jeton";
+    this->gamerList.clear();
+    close(this->sockEcoute);
+    close(this->sockLecture);
+    this->numberPlayer = 0;
+    this->numberPacman = 0;
+    this->numberGhost = 0;
+    this->jeton = "jeton";
 }
 
 char * md5_str(char *p)
 {
-	md5_state_t state;
-	md5_byte_t digest[16];
-	char *hex_output = (char *)malloc(33);
-	int di;
+    md5_state_t state;
+    md5_byte_t digest[16];
+    char *hex_output = (char *)malloc(33);
+    int di;
 
-	md5_init(&state);
-	md5_append(&state, (const md5_byte_t *)p, (int)strlen(p));
-	md5_finish(&state, digest);
+    md5_init(&state);
+    md5_append(&state, (const md5_byte_t *)p, (int)strlen(p));
+    md5_finish(&state, digest);
 
-	for (di = 0; di < 16; di++)
-	{
-		sprintf(hex_output + di * 2, "%02x", digest[di]);
-	}  
-	return hex_output;
+    for (di = 0; di < 16; di++)
+    {
+        sprintf(hex_output + di * 2, "%02x", digest[di]);
+    }
+    return hex_output;
 }
 
 int Game::serveurConnection()
 {
-	int sock;
-	string NomDistant = this->adresseServeurPrincipal;
-	struct sockaddr_in adresse;
-	struct hostent *recup;
+    int sock;
+    string NomDistant = this->adresseServeurPrincipal;
+    struct sockaddr_in adresse;
+    struct hostent *recup;
 
-	if ((sock = socket(AF_INET, SOCK_STREAM, 0)) == -1)
-	{
-		perror("Erreur ouverture");
-		return(-1);
-	}
+    if ((sock = socket(AF_INET, SOCK_STREAM, 0)) == -1)
+    {
+        perror("Erreur ouverture");
+        return(-1);
+    }
 
-	if ((recup = gethostbyname(NomDistant.c_str())) == NULL)
-	{
-		perror("Erreur obtention adresse");
-		return(-1);
-	}
-	memcpy((char *)&adresse.sin_addr, (char *)recup->h_addr, recup->h_length);
+    if ((recup = gethostbyname(NomDistant.c_str())) == NULL)
+    {
+        perror("Erreur obtention adresse");
+        return(-1);
+    }
+    memcpy((char *)&adresse.sin_addr, (char *)recup->h_addr, recup->h_length);
 
-	adresse.sin_family = AF_INET;
-	adresse.sin_port = htons((u_short)this->portEcouteServeurPrincipal);
+    adresse.sin_family = AF_INET;
+    adresse.sin_port = htons((u_short)this->portEcouteServeurPrincipal);
 
-	if (connect(sock, (struct sockaddr *)&adresse, sizeof(adresse)) == -1)
-	{
-		perror("Erreur connexion");
-		return(-1);
-	}
+    if (connect(sock, (struct sockaddr *)&adresse, sizeof(adresse)) == -1)
+    {
+        perror("Erreur connexion");
+        return(-1);
+    }
 
-	char * msg = (char *)malloc(11);
-	strcpy(msg, "gameServer");
-	char * mesgCrypte = (char *)malloc(33);
-	mesgCrypte = md5_str(msg);
+    char * msg = (char *)malloc(11);
+    strcpy(msg, "gameServer");
+    char * mesgCrypte = (char *)malloc(33);
+    mesgCrypte = md5_str(msg);
 
-	if (write(sock, mesgCrypte, 33) == -1)
-	{
-		perror("Erreur ecriture");
-		return(-1);
-	}
+    if (write(sock, mesgCrypte, 33) == -1)
+    {
+        perror("Erreur ecriture");
+        return(-1);
+    }
 
-	free(msg);
-	free(mesgCrypte);
+    free(msg);
+    free(mesgCrypte);
 
-	return 0;
+    return 0;
 }
 
 int * Game::connectionWaiting()
 {
-	this->sockEcoute = this->createTCPSock(this->portEcoute);
-	listen(this->sockEcoute, 10);
+    this->sockEcoute = this->createTCPSock(this->portEcoute);
+    listen(this->sockEcoute, 10);
 
-	while(1)
-	{ 
-		pthread_mutex_lock(&mutexConnectionClient);
-		this->msg_sock = accept(this->sockEcoute, NULL, NULL);
-		if (this->msg_sock == -1)
-		{
-			perror("Erreur accept");
-		}
-		else
-		{
-			this->log("Connexion nouveau client sur le port 2331");	
-		}
-		this->traiteNouveauClient();
-		pthread_mutex_unlock(&mutexConnectionClient);
-	}
-	return 0;
+    while(1)
+    {
+        pthread_mutex_lock(&mutexConnectionClient);
+        this->msg_sock = accept(this->sockEcoute, NULL, NULL);
+        if (this->msg_sock == -1)
+        {
+            perror("Erreur accept");
+        }
+        else
+        {
+            this->log("Connexion nouveau client sur le port 2331");
+        }
+        this->traiteNouveauClient();
+        pthread_mutex_unlock(&mutexConnectionClient);
+    }
+    return 0;
 }
 
 void  * Game::traiterClient() 
 {
-	pthread_mutex_lock(&mutex_msg_sockConnectionClient);
-	int socket = this->msg_sock;
-	pthread_mutex_unlock(&mutex_msg_sockConnectionClient);
+    pthread_mutex_lock(&mutex_msg_sockConnectionClient);
+    int socket = this->msg_sock;
+    pthread_mutex_unlock(&mutex_msg_sockConnectionClient);
 
-	char message[1024];
+    char message[1024];
 
-	struct sockaddr_in from;
-	unsigned int from_len= sizeof(from); 
-	getpeername(socket, (struct sockaddr*)&from, &from_len);
+    struct sockaddr_in from;
+    unsigned int from_len= sizeof(from);
+    getpeername(socket, (struct sockaddr*)&from, &from_len);
 
-	printf("Connexion avec %s : %d\n", inet_ntoa(from.sin_addr), ntohs(from.sin_port)); 
+    printf("Connexion avec %s : %d\n", inet_ntoa(from.sin_addr), ntohs(from.sin_port));
 
-	if (read(socket, message, 1023) == -1)
-	{
-		perror("Problemes");
-		exit(-1);
-	}
+    if (read(socket, message, 1023) == -1)
+    {
+        perror("Problemes");
+        exit(-1);
+    }
 
-	cout << endl;
-	cout << "serveur de partie recoi : " << message << endl;
+    cout << endl;
+    cout << "serveur de partie recoi : " << message << endl;
 
-	// decoupage	
-	istringstream iss( message );
-	string mot, tab[3];
-	int i=0;
-	while ( std::getline(iss, mot, ':' ) )
-	{	
-		tab[i] = mot;
-		i++;
-	}
+    // decoupage
+    istringstream iss( message );
+    string mot, tab[3];
+    int i=0;
+    while ( std::getline(iss, mot, ':' ) )
+    {
+        tab[i] = mot;
+        i++;
+    }
 
-	// test si le jeton est correct
-	if ((strcmp(tab[0].c_str(), this->jeton.c_str()) == 0) 
-			and (strcmp(tab[0].c_str(), "jeton") != 0))
-	{
-		// si correct, on ajoute le joueur a la liste des joueurs avec ces coordonnes initiale, son identifiant, etc.
-		int x = 1, y = 1;
-		if ( this->addPlayer(Joueur(tab[2], (this->numberPlayer + 1),
-						inet_ntoa(from.sin_addr), tab[1], 1, 1)
-						) == -1)
-		{
-			// echec de l'ajout
-			printf("Erreur lors de l'ajout du joueur %s\n", tab[2].c_str());
-			this->log("Erreur lors de l'ajout du joueur.");
-			return NULL;
-		}
+    // test si le jeton est correct
+    if ((strcmp(tab[0].c_str(), this->jeton.c_str()) == 0)
+            and (strcmp(tab[0].c_str(), "jeton") != 0))
+    {
+        // si correct, on ajoute le joueur a la liste des joueurs avec ces coordonnes initiale, son identifiant, etc.
+        int x = 1, y = 1;
+        if ( this->addPlayer(Joueur(tab[2], (this->numberPlayer + 1),
+                        inet_ntoa(from.sin_addr), tab[1], 1, 1)
+                        ) == -1)
+        {
+            // echec de l'ajout
+            printf("Erreur lors de l'ajout du joueur %s\n", tab[2].c_str());
+            this->log("Erreur lors de l'ajout du joueur.");
+            return NULL;
+        }
 
-		else
-		{
-			// le joueur est bien ajoute
-			printf("%s (identifiant : %d, adresse : %s) a rejoint la partie\n",
-							tab[2].c_str(), (this->numberPlayer), inet_ntoa(from.sin_addr));
-			this->log(tab[2]+" a rejoint la partie.");
+        else
+        {
+            // le joueur est bien ajoute
+            printf("%s (identifiant : %d, adresse : %s) a rejoint la partie\n",
+                            tab[2].c_str(), (this->numberPlayer), inet_ntoa(from.sin_addr));
+            this->log(tab[2]+" a rejoint la partie.");
 
-			// on averti les autres joueurs
-			// format du message :
-			//    NEW:id_j:type:l:c
-			//char identifiant[2];
-			//char coordX[2];
-			//char coordY[2];
-			char * identifiant = (char *)malloc(1024);
-			char * coordX = (char *)malloc(1024);
-			char * coordY = (char *)malloc(1024);
+            // on averti les autres joueurs
+            // format du message :
+            //    NEW:id_j:type:l:c
+            //char identifiant[2];
+            //char coordX[2];
+            //char coordY[2];
+            char * identifiant = (char *)malloc(1024);
+            char * coordX = (char *)malloc(1024);
+            char * coordY = (char *)malloc(1024);
 
-			sprintf(identifiant, "%d", (this->numberPlayer));
-			sprintf(coordX, "%d", x);
-			sprintf(coordY, "%d", y);
-			strcpy(message, "NEW");
-			strcat(message, ":");
-			strcat(message, identifiant);
-			strcat(message, ":");
-			strcat(message, tab[2].c_str());
-			strcat(message, ":");
-			strcat(message, tab[1].c_str());
-			strcat(message, ":");
-			strcat(message, coordX);
-			strcat(message, ":");
-			strcat(message, coordY);
-			strcat(message, ":");
-			this->sendOthers(from, message);
+            sprintf(identifiant, "%d", (this->numberPlayer));
+            sprintf(coordX, "%d", x);
+            sprintf(coordY, "%d", y);
+            strcpy(message, "NEW");
+            strcat(message, ":");
+            strcat(message, identifiant);
+            strcat(message, ":");
+            strcat(message, tab[2].c_str());
+            strcat(message, ":");
+            strcat(message, tab[1].c_str());
+            strcat(message, ":");
+            strcat(message, coordX);
+            strcat(message, ":");
+            strcat(message, coordY);
+            strcat(message, ":");
+            this->sendOthers(from, message);
 
 
 
 
-			// construction du message a renvoyer au nouveau client
-			// format du message :
-			//   id_j*@*l*,*c*@*id_j1*:*nom_j1*:*t_j1*:*l_j1*,*c_j1*;*id_j2*:*nom_j2*:*t_j2*:*l_j2*,*c_j2
-			memset (message, 0, sizeof (message));
-			strcpy(message, "|");
-			strcat(message, "ok");
-			strcat(message, "|");
-			strcat(message, identifiant);
-			strcat(message, "@");
-			strcat(message, coordX);
-			strcat(message, ",");
-			strcat(message, coordY);
-			strcat(message, "@");
+            // construction du message a renvoyer au nouveau client
+            // format du message :
+            //   id_j*@*l*,*c*@*id_j1*:*nom_j1*:*t_j1*:*l_j1*,*c_j1*;*id_j2*:*nom_j2*:*t_j2*:*l_j2*,*c_j2
+            memset (message, 0, sizeof (message));
+            strcpy(message, "|");
+            strcat(message, "ok");
+            strcat(message, "|");
+            strcat(message, identifiant);
+            strcat(message, "@");
+            strcat(message, coordX);
+            strcat(message, ",");
+            strcat(message, coordY);
+            strcat(message, "@");
 
-			list<Joueur>::iterator i;
-			for(i = gamerList.begin(); i != gamerList.end(); ++i)
-			{
-				if (i->getID() != (this->numberPlayer))
-				{
-					sprintf(identifiant, "%d", i->getID());
-					sprintf(coordX, "%d", i->getX());
-					sprintf(coordY, "%d", i->getY());
+            list<Joueur>::iterator i;
+            for(i = gamerList.begin(); i != gamerList.end(); ++i)
+            {
+                if (i->getID() != (this->numberPlayer))
+                {
+                    sprintf(identifiant, "%d", i->getID());
+                    sprintf(coordX, "%d", i->getX());
+                    sprintf(coordY, "%d", i->getY());
 
-					strcat(message, identifiant);
-					strcat(message, ":");
-					strcat(message, i->getNickname().c_str());
-					strcat(message, ":");
-					strcat(message, i->getType().c_str());
-					strcat(message, ":");
-					strcat(message, coordX);
-					strcat(message, ",");
-					strcat(message, coordY);
-					strcat(message, ";");
+                    strcat(message, identifiant);
+                    strcat(message, ":");
+                    strcat(message, i->getNickname().c_str());
+                    strcat(message, ":");
+                    strcat(message, i->getType().c_str());
+                    strcat(message, ":");
+                    strcat(message, coordX);
+                    strcat(message, ",");
+                    strcat(message, coordY);
+                    strcat(message, ";");
 
-					memset (identifiant, 0, sizeof (identifiant));
-					memset (coordX, 0, sizeof (coordX));
-					memset (coordY, 0, sizeof (coordY));
-				}
-			}
-			strcat(message, "|");
-			
-			free(identifiant);
-			free(coordX);
-			free(coordY);
-		}
+                    memset (identifiant, 0, sizeof (identifiant));
+                    memset (coordX, 0, sizeof (coordX));
+                    memset (coordY, 0, sizeof (coordY));
+                }
+            }
+            strcat(message, "|");
+    
+            free(identifiant);
+            free(coordX);
+            free(coordY);
+        }
 
-	}
-	else
-	{
-		printf("Authentification de (%s, %s) echouee. Jeton invalide\n",
-			tab[2].c_str(), inet_ntoa(from.sin_addr));
-		this->log("Authentification echouee. Jeton invalide.");
-		strcpy(message, "mauvaisJeton");
-	}
+    }
+    else
+    {
+        printf("Authentification de (%s, %s) echouee. Jeton invalide\n",
+            tab[2].c_str(), inet_ntoa(from.sin_addr));
+        this->log("Authentification echouee. Jeton invalide.");
+        strcpy(message, "mauvaisJeton");
+    }
 
-	cout << "serveur de partie renvoi : " << message << endl;
-	// envoie de la reponse au nouveau client 
-	if (write(socket, message, sizeof(message)) == -1 )
-	{
-		perror("Erreur write");
-	}
-	
-	close(socket);
-	return NULL;
+    cout << "serveur de partie renvoi : " << message << endl;
+    // envoie de la reponse au nouveau client
+    if (write(socket, message, sizeof(message)) == -1 )
+    {
+        perror("Erreur write");
+    }
+    
+    close(socket);
+    return NULL;
 }
 
 void * Game::receive()
 {
-	unsigned int tailleAdresse;
-	struct sockaddr_in adresseDistante;
+    unsigned int tailleAdresse;
+    struct sockaddr_in adresseDistante;
 
-	while(1)
-	{
-		//pthread_mutex_lock(&mutexReceive);
-		tailleAdresse = sizeof(struct sockaddr_in);
+    while(1)
+    {
+        //pthread_mutex_lock(&mutexReceive);
+        tailleAdresse = sizeof(struct sockaddr_in);
 
-		char * message = (char *)malloc(1024);
+        char * message = (char *)malloc(1024);
 
-		if(recvfrom(this->sockLecture, message, 1024, 0, (struct sockaddr*)&adresseDistante, &tailleAdresse) == -1)
-		{
-			perror("Erreur de lecture sur la socket");
-			exit(-1);
-		}
+        if(recvfrom(this->sockLecture, message, 1024, 0, (struct sockaddr*)&adresseDistante, &tailleAdresse) == -1)
+        {
+            perror("Erreur de lecture sur la socket");
+            exit(-1);
+        }
 
-		fprintf(stdout, "Message de (%s : %d) : %s\n", inet_ntoa(adresseDistante.sin_addr), ntohs(adresseDistante.sin_port), message);
+        fprintf(stdout, "Message de (%s : %d) : %s\n", inet_ntoa(adresseDistante.sin_addr), ntohs(adresseDistante.sin_port), message);
 
-		cout << endl;
-		cout << "Serveur de partie recoi : " << message << endl;
+        cout << endl;
+        cout << "Serveur de partie recoi : " << message << endl;
 
-		// decoupe
-		istringstream iss( message );
-		string mot, tab[5];
-		int j=0;
-		while ( std::getline(iss, mot, ':' ) )
-		{	
-			tab[j] = mot;
-			j++;
-		}
+        // decoupe
+        istringstream iss( message );
+        string mot, tab[5];
+        int j=0;
+        while ( std::getline(iss, mot, ':' ) )
+        {
+            tab[j] = mot;
+            j++;
+        }
 
-		// tests		
-		if (strcmp(tab[0].c_str(), "MVT") == 0)
-		{
-			// construction du message a renvoyer au client
-			// format du message :
-			//   MVT|identifiant|x,y
-			memset (message, 0, sizeof (message));
-			strcpy(message, "MVT");
+        // tests
+        if (strcmp(tab[0].c_str(), "MVT") == 0)
+        {
+            // construction du message a renvoyer au client
+            // format du message :
+            //   MVT|identifiant|x,y
+            memset (message, 0, sizeof (message));
+            strcpy(message, "MVT");
 
-			// parcours de la liste des joueurs
-			list<Joueur>::iterator i;
-			for(i = gamerList.begin(); i != gamerList.end(); ++i)
-			{
-				if (i->getIP() == inet_ntoa(adresseDistante.sin_addr))
-				{
-					i->setX(atoi(tab[2].c_str()));
-					i->setY(atoi(tab[3].c_str()));
+            // parcours de la liste des joueurs
+            list<Joueur>::iterator i;
+            for(i = gamerList.begin(); i != gamerList.end(); ++i)
+            {
+                if (i->getIP() == inet_ntoa(adresseDistante.sin_addr))
+                {
+                    i->setX(atoi(tab[2].c_str()));
+                    i->setY(atoi(tab[3].c_str()));
 
-					char identifiant[2];
-					sprintf(identifiant, "%d", i->getID());
-					strcat(message, ":");
-					strcat(message, identifiant);
-					strcat(message, ":");
-					strcat(message, tab[2].c_str());
-					strcat(message, ":");
-					strcat(message, tab[3].c_str());
-					strcat(message, ":");
-					break;
-				}
-			}
-		}
+                    char identifiant[2];
+                    sprintf(identifiant, "%d", i->getID());
+                    strcat(message, ":");
+                    strcat(message, identifiant);
+                    strcat(message, ":");
+                    strcat(message, tab[2].c_str());
+                    strcat(message, ":");
+                    strcat(message, tab[3].c_str());
+                    strcat(message, ":");
+                    break;
+                }
+            }
+        }
 
-		else if (strcmp(tab[0].c_str(), "DEC") == 0)
-		{
-			this->removePlayer(inet_ntoa(adresseDistante.sin_addr));
+        else if (strcmp(tab[0].c_str(), "DEC") == 0)
+        {
+            this->removePlayer(inet_ntoa(adresseDistante.sin_addr));
 
-			list<Joueur>::iterator i;
-			for(i = gamerList.begin(); i != gamerList.end(); ++i)
-			{				
-				if (i->getID() == atoi(tab[1].c_str()))
-				{
-					printf("\n%s a quitte la partie\n", i->getNickname().c_str());
-				}
-			}
-			memset (message, 0, sizeof (message));
-			strcpy(message, "DEC:");
-			strcat(message, tab[1].c_str());
-			strcat(message, ":");
-		}
-		
-		else if (strcmp(message, "AreYouAlive?") == 0)
-		{
-			this->sendALive();
-		}
+            list<Joueur>::iterator i;
+            for(i = gamerList.begin(); i != gamerList.end(); ++i)
+            {
+                if (i->getID() == atoi(tab[1].c_str()))
+                {
+                    printf("\n%s a quitte la partie\n", i->getNickname().c_str());
+                }
+            }
+            memset (message, 0, sizeof (message));
+            strcpy(message, "DEC:");
+            strcat(message, tab[1].c_str());
+            strcat(message, ":");
+        }
+    
+        else if (strcmp(message, "AreYouAlive?") == 0)
+        {
+            this->sendALive();
+        }
 
-		this->sendToAll(adresseDistante, message);
-		free(message);
-		//pthread_mutex_unlock(&mutexReceive);
-	}
-	close(this->sockEcoute);
-	exit(0);
+        this->sendToAll(adresseDistante, message);
+        free(message);
+        //pthread_mutex_unlock(&mutexReceive);
+    }
+    close(this->sockEcoute);
+    exit(0);
 }
 
 int Game::sendOthers(struct sockaddr_in adresseDistante, string reponse)
 {
-	pthread_mutex_lock(&mutexSend);
+    pthread_mutex_lock(&mutexSend);
 
-	struct sockaddr_in adresse;
-	struct hostent *recup;
-	string nomDistant, nickname, type;
+    struct sockaddr_in adresse;
+    struct hostent *recup;
+    string nomDistant, nickname, type;
 
-	// parcours de la liste des joueurs
-	list<Joueur>::iterator i;
-	for(i = gamerList.begin(); i != gamerList.end(); ++i)
-	{
-		// si différent de l'éméteur, envoie des données.
-		if (i->getIP() != inet_ntoa(adresseDistante.sin_addr))
-		{
-			// récupération des informations sur le destinataire actuel
-			nomDistant = i->getIP();
-			nickname = i->getNickname();
-			type = i->getType();
+    // parcours de la liste des joueurs
+    list<Joueur>::iterator i;
+    for(i = gamerList.begin(); i != gamerList.end(); ++i)
+    {
+        // si différent de l'éméteur, envoie des données.
+        if (i->getIP() != inet_ntoa(adresseDistante.sin_addr))
+        {
+            // récupération des informations sur le destinataire actuel
+            nomDistant = i->getIP();
+            nickname = i->getNickname();
+            type = i->getType();
 
-			if ((this->sockEcriture = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
-			{
-				perror("Erreur ouverture");
-				pthread_mutex_unlock(&mutexSend);
-				return(-1);
-			}
+            if ((this->sockEcriture = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
+            {
+                perror("Erreur ouverture");
+                pthread_mutex_unlock(&mutexSend);
+                return(-1);
+            }
 
-			if ((recup = gethostbyname(nomDistant.c_str())) == NULL)
-			{
-				perror("Erreur obtention adresse");
-				pthread_mutex_unlock(&mutexSend);
-				return(-1);
-			}
+            if ((recup = gethostbyname(nomDistant.c_str())) == NULL)
+            {
+                perror("Erreur obtention adresse");
+                pthread_mutex_unlock(&mutexSend);
+                return(-1);
+            }
 
-			memcpy((char *)&adresse.sin_addr, (char *)recup->h_addr, recup->h_length);
+            memcpy((char *)&adresse.sin_addr, (char *)recup->h_addr, recup->h_length);
 
-			adresse.sin_family = AF_INET;
-			adresse.sin_port = htons((u_short)this->portEcouteDistant);
+            adresse.sin_family = AF_INET;
+            adresse.sin_port = htons((u_short)this->portEcouteDistant);
 
-			if (connect(this->sockEcriture, (struct sockaddr *)&adresse, sizeof(adresse)) == -1)
-			{
-				perror("Erreur connect");
-				pthread_mutex_unlock(&mutexSend);
-				return(-1);
-			}
+            if (connect(this->sockEcriture, (struct sockaddr *)&adresse, sizeof(adresse)) == -1)
+            {
+                perror("Erreur connect");
+                pthread_mutex_unlock(&mutexSend);
+                return(-1);
+            }
 
-			if ((sendto(this->sockEcriture, reponse.c_str(), strlen(reponse.c_str()), 0, NULL, 0)) == -1)
-			{
-				perror("Erreur ecriture");
-				pthread_mutex_unlock(&mutexSend);
-				return(-1);
-			}
-			close(this->sockEcriture);
-		}
-	}
-	pthread_mutex_unlock(&mutexSend);
-	return 0;
+            if ((sendto(this->sockEcriture, reponse.c_str(), strlen(reponse.c_str()), 0, NULL, 0)) == -1)
+            {
+                perror("Erreur ecriture");
+                pthread_mutex_unlock(&mutexSend);
+                return(-1);
+            }
+            close(this->sockEcriture);
+        }
+    }
+    pthread_mutex_unlock(&mutexSend);
+    return 0;
 }
 
 int * Game::receiveServeur()
 {
-	while(1)
-	{ 
-		this->msg_sockServeur = accept(this->sockEcouteServeur, NULL, NULL);
-		if (this->msg_sockServeur == -1)
-		{
-			perror("Erreur accept");
-		}
-		this->initTraitementServeur();
-	}
-	close(this->msg_sockServeur);
-	return 0;
+    while(1)
+    {
+        this->msg_sockServeur = accept(this->sockEcouteServeur, NULL, NULL);
+        if (this->msg_sockServeur == -1)
+        {
+            perror("Erreur accept");
+        }
+        this->initTraitementServeur();
+    }
+    close(this->msg_sockServeur);
+    return 0;
 }
 
 void Game::traiteServeur()
 {
-	char message [1024];
-	int sock = this->msg_sockServeur;
+    char message [1024];
+    int sock = this->msg_sockServeur;
 
-	if (read(sock, message, 1023) == -1)
-	{
-		perror("Problemes");
-		exit(-1);
-	}
-	printf("Message recu du serveur principal : %s\n", message);
+    if (read(sock, message, 1023) == -1)
+    {
+        perror("Problemes");
+        exit(-1);
+    }
+    printf("Message recu du serveur principal : %s\n", message);
 
 
-	// decoupe
-	int i = 0;
-	string tab[2], mot;
-	istringstream iss( message );
-	while ( std::getline(iss, mot, ':' ) )
-	{
-		tab[i] = mot; 
-		i++;
-	}
+    // decoupe
+    int i = 0;
+    string tab[2], mot;
+    istringstream iss( message );
+    while ( std::getline(iss, mot, ':' ) )
+    {
+        tab[i] = mot;
+        i++;
+    }
 
-	if (strcmp(message, "succes") == 0)
-	{
-		printf("Connection accepte\n");
-		return;
-	}
+    if (strcmp(message, "succes") == 0)
+    {
+        printf("Connection accepte\n");
+        return;
+    }
 
-	else if (strcmp(message, "echec") == 0)
-	{
-		// connexion refusee, on quitte le programme
-		printf("Connection refuse\n");
-		exit(0);
-	}
+    else if (strcmp(message, "echec") == 0)
+    {
+        // connexion refusee, on quitte le programme
+        printf("Connection refuse\n");
+        exit(0);
+    }
 
-	else if (strcmp(message, "sendMeInfo") == 0)
-	{	// on prepare les donnees a envoyer au serveur principal
-		// format:
-		//  MyInfo:nbPlayer:nbPacman:nbFantome
-		char joueur [2];
-		sprintf (joueur, "%d", this->numberPlayer);
+    else if (strcmp(message, "sendMeInfo") == 0)
+    {    // on prepare les donnees a envoyer au serveur principal
+        // format:
+        //  MyInfo:nbPlayer:nbPacman:nbFantome
+        char joueur [2];
+        sprintf (joueur, "%d", this->numberPlayer);
 
-		char pacman [2];
-		sprintf (pacman, "%d", this->numberPacman);
+        char pacman [2];
+        sprintf (pacman, "%d", this->numberPacman);
 
-		char fantome [2];
-		sprintf (fantome, "%d", this->numberGhost);
+        char fantome [2];
+        sprintf (fantome, "%d", this->numberGhost);
 
-		strcpy(message, "MyInfo:");
-		strcat(message, joueur);
-		strcat(message, ":");
-		strcat(message, pacman);
-		strcat(message, ":");
-		strcat(message, fantome);
-	}
+        strcpy(message, "MyInfo:");
+        strcat(message, joueur);
+        strcat(message, ":");
+        strcat(message, pacman);
+        strcat(message, ":");
+        strcat(message, fantome);
+    }
 
-	else if (strcmp(tab[0].c_str(), "jeton") == 0)
-	{
-		// initialisation du nouveau jeton
-		this->jeton = tab[1];
-		printf("Nouveau jeton initialise\n");
-		return;
-	}
+    else if (strcmp(tab[0].c_str(), "jeton") == 0)
+    {
+        // initialisation du nouveau jeton
+        this->jeton = tab[1];
+        printf("Nouveau jeton initialise\n");
+        return;
+    }
 
-	else if (strcmp(message, "AreYouAlive?") == 0)
-	{
-		// test de présence
-		strcpy(message, "ImAlive");
-	}
-	else
-		// on envoie pas de message d'erreurs. on passe silencieusement...
-		return;
+    else if (strcmp(message, "AreYouAlive?") == 0)
+    {
+        // test de présence
+        strcpy(message, "ImAlive");
+    }
+    else
+        // on envoie pas de message d'erreurs. on passe silencieusement...
+        return;
 
-	// envoie de la réponse
-	int portServeur = 7772;
-	string NomDistant = this->adresseServeurPrincipal;
-	struct sockaddr_in adresse;
-	struct hostent *recup;
+    // envoie de la réponse
+    int portServeur = 7772;
+    string NomDistant = this->adresseServeurPrincipal;
+    struct sockaddr_in adresse;
+    struct hostent *recup;
 
-	if ((sock = socket(AF_INET, SOCK_STREAM, 0)) == -1)
-	{
-		perror("Erreur ouverture");
-	}
+    if ((sock = socket(AF_INET, SOCK_STREAM, 0)) == -1)
+    {
+        perror("Erreur ouverture");
+    }
 
-	if ((recup = gethostbyname(NomDistant.c_str())) == NULL)
-	{
-		perror("Erreur obtention adresse");
-	}
-	memcpy((char *)&adresse.sin_addr, (char *)recup->h_addr, recup->h_length);
+    if ((recup = gethostbyname(NomDistant.c_str())) == NULL)
+    {
+        perror("Erreur obtention adresse");
+    }
+    memcpy((char *)&adresse.sin_addr, (char *)recup->h_addr, recup->h_length);
 
-	adresse.sin_family = AF_INET;
-	adresse.sin_port = htons((u_short)portServeur);
-	if (connect(sock, (struct sockaddr *)&adresse, sizeof(adresse)) == -1)
-	{
-		perror("Erreur connexion");
-	}
+    adresse.sin_family = AF_INET;
+    adresse.sin_port = htons((u_short)portServeur);
+    if (connect(sock, (struct sockaddr *)&adresse, sizeof(adresse)) == -1)
+    {
+        perror("Erreur connexion");
+    }
 
-	if (write(sock, message, strlen(message)) == -1)
-	{
-		perror("Erreur ecriture");
-	}
-	close(sock);
+    if (write(sock, message, strlen(message)) == -1)
+    {
+        perror("Erreur ecriture");
+    }
+    close(sock);
 }
 
 int Game::sendToAll(struct sockaddr_in adresseDistante, string reponse)
 {
-	struct sockaddr_in adresse;
-	struct hostent *recup;
-	string nomDistant, nickname, type;
+    struct sockaddr_in adresse;
+    struct hostent *recup;
+    string nomDistant, nickname, type;
 
-	// parcours de la liste des joueurs
-	list<Joueur>::iterator i;
-	for(i = gamerList.begin(); i != gamerList.end(); ++i)
-	{
-			// récupération des informations sur le destinataire actuel
-			nomDistant = i->getIP();
-			nickname = i->getNickname();
-			type = i->getType();
+    // parcours de la liste des joueurs
+    list<Joueur>::iterator i;
+    for(i = gamerList.begin(); i != gamerList.end(); ++i)
+    {
+            // récupération des informations sur le destinataire actuel
+            nomDistant = i->getIP();
+            nickname = i->getNickname();
+            type = i->getType();
 
-			if ((this->sockEcriture = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
-			{
-				perror("Erreur ouverture");
-				return(-1);
-			}
+            if ((this->sockEcriture = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
+            {
+                perror("Erreur ouverture");
+                return(-1);
+            }
 
-			if ((recup = gethostbyname(nomDistant.c_str())) == NULL)
-			{
-				perror("Erreur obtention adresse");
-				return(-1);
-			}
+            if ((recup = gethostbyname(nomDistant.c_str())) == NULL)
+            {
+                perror("Erreur obtention adresse");
+                return(-1);
+            }
 
-			memcpy((char *)&adresse.sin_addr, (char *)recup->h_addr, recup->h_length);
+            memcpy((char *)&adresse.sin_addr, (char *)recup->h_addr, recup->h_length);
 
-			adresse.sin_family = AF_INET;
-			adresse.sin_port = htons((u_short)this->portEcouteDistant);
+            adresse.sin_family = AF_INET;
+            adresse.sin_port = htons((u_short)this->portEcouteDistant);
 
-			if (connect(this->sockEcriture, (struct sockaddr *)&adresse, sizeof(adresse)) == -1)
-			{
-				perror("Erreur connect");
-				return(-1);
-			}
+            if (connect(this->sockEcriture, (struct sockaddr *)&adresse, sizeof(adresse)) == -1)
+            {
+                perror("Erreur connect");
+                return(-1);
+            }
 
-			cout << "Serveur de partie renvoi :" << reponse << " a : " << i->getIP() << endl;
-			if ((sendto(this->sockEcriture, reponse.c_str(), strlen(reponse.c_str()), 0, NULL, 0)) == -1)
-			{
-				perror("Erreur ecriture");
-				return(-1);
-			}
-			close(this->sockEcriture);
+            cout << "Serveur de partie renvoi :" << reponse << " a : " << i->getIP() << endl;
+            if ((sendto(this->sockEcriture, reponse.c_str(), strlen(reponse.c_str()), 0, NULL, 0)) == -1)
+            {
+                perror("Erreur ecriture");
+                return(-1);
+            }
+            close(this->sockEcriture);
 
-	}
-	reponse.clear();
-	return 0;
+    }
+    reponse.clear();
+    return 0;
 }
 
 int Game::sendALive()
 {
-	// envoie de la réponse
-	int portServeur = 7772;
-	int sock;
-	string NomDistant = this->adresseServeurPrincipal;
-	struct sockaddr_in adresse;
-	struct hostent *recup;
+    // envoie de la réponse
+    int portServeur = 7772;
+    int sock;
+    string NomDistant = this->adresseServeurPrincipal;
+    struct sockaddr_in adresse;
+    struct hostent *recup;
 
-	if ((sock = socket(AF_INET, SOCK_STREAM, 0)) == -1)
-	{
-		perror("Erreur ouverture");
-	}
+    if ((sock = socket(AF_INET, SOCK_STREAM, 0)) == -1)
+    {
+        perror("Erreur ouverture");
+    }
 
-	if ((recup = gethostbyname(NomDistant.c_str())) == NULL)
-	{
-		perror("Erreur obtention adresse");
-	}
-	memcpy((char *)&adresse.sin_addr, (char *)recup->h_addr, recup->h_length);
+    if ((recup = gethostbyname(NomDistant.c_str())) == NULL)
+    {
+        perror("Erreur obtention adresse");
+    }
+    memcpy((char *)&adresse.sin_addr, (char *)recup->h_addr, recup->h_length);
 
-	adresse.sin_family = AF_INET;
-	adresse.sin_port = htons((u_short)portServeur);
-	if (connect(sock, (struct sockaddr *)&adresse, sizeof(adresse)) == -1)
-	{
-		perror("Erreur connexion");
-	}
+    adresse.sin_family = AF_INET;
+    adresse.sin_port = htons((u_short)portServeur);
+    if (connect(sock, (struct sockaddr *)&adresse, sizeof(adresse)) == -1)
+    {
+        perror("Erreur connexion");
+    }
 
-	if (write(sock, "ImAlive", strlen("ImAlive")) == -1)
-	{
-		perror("Erreur ecriture");
-	}
-	close(sock);
-	return 0;
+    if (write(sock, "ImAlive", strlen("ImAlive")) == -1)
+    {
+        perror("Erreur ecriture");
+    }
+    close(sock);
+    return 0;
 }
 
 int Game::createTCPSock(u_short port)
 {
-	int sock, retour;
-	struct sockaddr_in adresse;
+    int sock, retour;
+    struct sockaddr_in adresse;
 
-	sock = socket(AF_INET, SOCK_STREAM, 0);
-	if (sock<0)
-	{
-		perror ("Erreur ouverture");
-		return(-1);
-	}
+    sock = socket(AF_INET, SOCK_STREAM, 0);
+    if (sock<0)
+    {
+        perror ("Erreur ouverture");
+        return(-1);
+    }
 
-	adresse.sin_family = AF_INET;
-	adresse.sin_port = htons((u_short)port);
-	adresse.sin_addr.s_addr = INADDR_ANY;
+    adresse.sin_family = AF_INET;
+    adresse.sin_port = htons((u_short)port);
+    adresse.sin_addr.s_addr = INADDR_ANY;
 
-	retour = bind (sock, (struct sockaddr *)&adresse, sizeof(adresse));
+    retour = bind (sock, (struct sockaddr *)&adresse, sizeof(adresse));
 
-	if (retour<0)
-	{
-		perror ("Impossible de nommer le socket");
-		return(-1);
-	}
-	return (sock);
+    if (retour<0)
+    {
+        perror ("Impossible de nommer le socket");
+        return(-1);
+    }
+    return (sock);
 }
 
 int Game::createUDPSock(u_short port)
 {
-	int sock, retour;
-	struct sockaddr_in adresseDistante;
+    int sock, retour;
+    struct sockaddr_in adresseDistante;
 
-	sock = socket(AF_INET, SOCK_DGRAM, 0);
-	if (sock<0)
-	{
-		perror ("Erreur ouverture");
-		return(-1);
-	}
+    sock = socket(AF_INET, SOCK_DGRAM, 0);
+    if (sock<0)
+    {
+        perror ("Erreur ouverture");
+        return(-1);
+    }
 
-	adresseDistante.sin_family = AF_INET;
-	adresseDistante.sin_port = htons((u_short)port);
-	adresseDistante.sin_addr.s_addr = INADDR_ANY;
+    adresseDistante.sin_family = AF_INET;
+    adresseDistante.sin_port = htons((u_short)port);
+    adresseDistante.sin_addr.s_addr = INADDR_ANY;
 
-	retour = bind (sock, (struct sockaddr *)&adresseDistante, sizeof(adresseDistante));
+    retour = bind (sock, (struct sockaddr *)&adresseDistante, sizeof(adresseDistante));
 
-	if (retour<0)
-	{
-		perror ("Impossible de nommer le socket");
-		return(-1);
-	}
-	return (sock);
+    if (retour<0)
+    {
+        perror ("Impossible de nommer le socket");
+        return(-1);
+    }
+    return (sock);
 }
 
 int Game::addPlayer(Joueur joueur)
 {
-	pthread_mutex_lock(&mutexAjoutClient);
-	if (this->numberPlayer < 10)
-	{
-		this->gamerList.push_back(joueur);
-		(joueur.getType() == "p")? this->numberPacman++ : this->numberGhost++;
-		this->numberPlayer++;
-		pthread_mutex_unlock(&mutexAjoutClient);
-		return 0;
-		
-	}
-	pthread_mutex_unlock(&mutexAjoutClient);
-	return -1;
+    pthread_mutex_lock(&mutexAjoutClient);
+    if (this->numberPlayer < 10)
+    {
+        this->gamerList.push_back(joueur);
+        (joueur.getType() == "p")? this->numberPacman++ : this->numberGhost++;
+        this->numberPlayer++;
+        pthread_mutex_unlock(&mutexAjoutClient);
+        return 0;
+    
+    }
+    pthread_mutex_unlock(&mutexAjoutClient);
+    return -1;
 }
 
 int Game::removePlayer(string adresse)
 {
-	pthread_mutex_lock(&mutexSupprimeClient);
-	list<Joueur>::iterator i;
-	for(i = gamerList.begin(); i != gamerList.end(); ++i)
-	{
-		if (i->getIP() == adresse)
-		{
-			(i->getType() == "p")? this->numberPacman-- : this->numberGhost--;
-			this->gamerList.erase(i);
-			this->numberPlayer--;
-			pthread_mutex_unlock(&mutexSupprimeClient);
-			return 0;
-		}
-	}
-	pthread_mutex_unlock(&mutexSupprimeClient);
-	return 0;
+    pthread_mutex_lock(&mutexSupprimeClient);
+    list<Joueur>::iterator i;
+    for(i = gamerList.begin(); i != gamerList.end(); ++i)
+    {
+        if (i->getIP() == adresse)
+        {
+            (i->getType() == "p")? this->numberPacman-- : this->numberGhost--;
+            this->gamerList.erase(i);
+            this->numberPlayer--;
+            pthread_mutex_unlock(&mutexSupprimeClient);
+            return 0;
+        }
+    }
+    pthread_mutex_unlock(&mutexSupprimeClient);
+    return 0;
 }
 
 void Game::log(string message)
 {
-	// récupère l'heure système
-	time_t timer1;
-	time(&timer1);
-	int secondes, minutes, heures;
-	string fichier = "log";
-	struct tm *newTime1;
-	newTime1 = localtime(&timer1);
-	heures = newTime1->tm_hour;
-	minutes = newTime1->tm_min;
-	secondes = newTime1->tm_sec;
+    // récupère l'heure système
+    time_t timer1;
+    time(&timer1);
+    int secondes, minutes, heures;
+    string fichier = "log";
+    struct tm *newTime1;
+    newTime1 = localtime(&timer1);
+    heures = newTime1->tm_hour;
+    minutes = newTime1->tm_min;
+    secondes = newTime1->tm_sec;
 
-	ofstream file;
+    ofstream file;
 
-	file.open(fichier.c_str(), ios::out | ios::ate | ios::app);
+    file.open(fichier.c_str(), ios::out | ios::ate | ios::app);
 
-	if (file.bad())
-	{
-		cerr << "Fichier [" << fichier << "] invalide." << endl;
-		exit(-1);
-	}
-	if (file.is_open())
-	{
+    if (file.bad())
+    {
+        cerr << "Fichier [" << fichier << "] invalide." << endl;
+        exit(-1);
+    }
+    if (file.is_open())
+    {
         // Écrit les données :
-		file << "[" << heures << ":" << minutes << ":" << secondes << "] " << message << endl;
+        file << "[" << heures << ":" << minutes << ":" << secondes << "] " << message << endl;
 
-		file.close();
-	}
+        file.close();
+    }
 }

          
M serveurPartie/game.h +204 -204
@@ 34,177 34,177 @@ using namespace std;
  */
 class Game : public Threads
 {
-	//
-	// Membres publics
-	//
+    //
+    // Membres publics
+    //
 
-	public:
+    public:
 
-	/*!
-	 *
-	 * \brief Constructeur.
-	 * \param portEcoute Port d'écoute TCP de connection des clients.
-	 * \param portLecture Port de lecture UDP des mouvements des joueurs.
-	 * \param portEcouteServeur Port d'écoute TCP des messages du serveur.
-	 * \param portEcouteDistant Port d'écoute UDP du client distant.
-	 * \param portEcouteServeurPrincipal Port d'écoute TCP du serveur principal distant.
-	 * \param adresseServeurPrincipal Adresse du serveur principal distant.
-	 *
-	 */
-	Game(u_short portEcoute, u_short portLecture, u_short portEcouteServeur,
-			u_short portEcouteDistant, u_short portEcouteServeurPrincipal, string adresseServeurPrincipal);
+    /*!
+     *
+     * \brief Constructeur.
+     * \param portEcoute Port d'écoute TCP de connection des clients.
+     * \param portLecture Port de lecture UDP des mouvements des joueurs.
+     * \param portEcouteServeur Port d'écoute TCP des messages du serveur.
+     * \param portEcouteDistant Port d'écoute UDP du client distant.
+     * \param portEcouteServeurPrincipal Port d'écoute TCP du serveur principal distant.
+     * \param adresseServeurPrincipal Adresse du serveur principal distant.
+     *
+     */
+    Game(u_short portEcoute, u_short portLecture, u_short portEcouteServeur,
+            u_short portEcouteDistant, u_short portEcouteServeurPrincipal, string adresseServeurPrincipal);
 
-	/*!
-	 * \brief Destructeur
-	 */
-	~Game();
+    /*!
+     * \brief Destructeur
+     */
+    ~Game();
 
 
 
-	
-				//
-				// Méthodes relatives à la reception/envoie de données.
-				//
+    
+                //
+                // Méthodes relatives à la reception/envoie de données.
+                //
 
-	/*!
-	 *
-	 * \brief Crée un socket UDP.
-	 * \param port Le port du socket à créer.
-	 * \return Un entier indiquant si la création s'est bien passée.
-	 *
-	 */
-	int createUDPSock(u_short port);
+    /*!
+     *
+     * \brief Crée un socket UDP.
+     * \param port Le port du socket à créer.
+     * \return Un entier indiquant si la création s'est bien passée.
+     *
+     */
+    int createUDPSock(u_short port);
 
-	/*!
-	 * 
-	 * \brief Crée un socket TCP.
-	 * \param port Le port du socket à créer.
-	 * \return Un entier indiquant si la création s'est bien passée.
-	 *
-	 */	
-	int createTCPSock(u_short port);
-	
-	
-	/*!
-	 *
-	 * \brief Connexion au serveur principal. Envoie le code d'identification.
-	 * \return Un entier indiquant si la connexion a été accepté.
-	 *
-	 */
-	int serveurConnection();
-	
-	/*!
-	 * 
-	 * \brief Attend l'arrivée de nouveaux joueurs.
-	 * 
-	 */
-	int * connectionWaiting();
-	
-	/*!
-	 * 
-	 * \brief Traite les nouveaux joeurs.
-	 * 
-	 */
-	void * traiterClient();
-	
-	
-	/*!
-	 * 
-	 * \brief Intercepte les données émises en UDP par les joueurs ().
-	 * 
-	 */
-	void * receive();
-	
-	/*!
-	 * 
-	 * \brief Intercepte les données émises par le serveur.
-	 * 
-	 */
-	int * receiveServeur();
-	
-	/*!
-	 * 
-	 * Traite les messages du serveur principal et de partie.
-	 * 
-	 */
-	void traiteServeur();
-	
-	/*!
-	 * 
-	 * \brief Renvoie une réponse à l'émeteur.
-	 * 
-	 */	
-	int sendToAll(struct sockaddr_in adresseDistante, string data);
-	
-	/*!
-	 * 
-	 * \brief Renvoie à tous les joueurs (sauf l'émeteur) de la partie
-	 *  les nouvelles coordonnées et autres données à mettre à jour.
-	 * 
-	 */
-	int sendOthers(struct sockaddr_in adresseDistante, string data);
-	
-	/*!
-	 * 
-	 * \brief Informe le serveur principal si la serveur de partie n'a pas planté.
-	 * 
-	 */
-	int sendALive();
+    /*!
+     *
+     * \brief Crée un socket TCP.
+     * \param port Le port du socket à créer.
+     * \return Un entier indiquant si la création s'est bien passée.
+     *
+     */
+    int createTCPSock(u_short port);
+    
+    
+    /*!
+     *
+     * \brief Connexion au serveur principal. Envoie le code d'identification.
+     * \return Un entier indiquant si la connexion a été accepté.
+     *
+     */
+    int serveurConnection();
+    
+    /*!
+     *
+     * \brief Attend l'arrivée de nouveaux joueurs.
+     *
+     */
+    int * connectionWaiting();
+    
+    /*!
+     *
+     * \brief Traite les nouveaux joeurs.
+     *
+     */
+    void * traiterClient();
+    
+    
+    /*!
+     *
+     * \brief Intercepte les données émises en UDP par les joueurs ().
+     *
+     */
+    void * receive();
+    
+    /*!
+     *
+     * \brief Intercepte les données émises par le serveur.
+     *
+     */
+    int * receiveServeur();
+    
+    /*!
+     *
+     * Traite les messages du serveur principal et de partie.
+     *
+     */
+    void traiteServeur();
+    
+    /*!
+     *
+     * \brief Renvoie une réponse à l'émeteur.
+     *
+     */
+    int sendToAll(struct sockaddr_in adresseDistante, string data);
+    
+    /*!
+     *
+     * \brief Renvoie à tous les joueurs (sauf l'émeteur) de la partie
+     *  les nouvelles coordonnées et autres données à mettre à jour.
+     *
+     */
+    int sendOthers(struct sockaddr_in adresseDistante, string data);
+    
+    /*!
+     *
+     * \brief Informe le serveur principal si la serveur de partie n'a pas planté.
+     *
+     */
+    int sendALive();
 
 
 
 
-				//
-				// Méthodes relatives à la création de threads.
-				// Concrétise les virtuelles pures de la classe Threads.
-				//
+                //
+                // Méthodes relatives à la création de threads.
+                // Concrétise les virtuelles pures de la classe Threads.
+                //
 
-	/*!
-	 * 
-	 * \brief Lance la méthode connectionWaiting dans le thread d'ecoute.
-	 * 
-	 */
-	virtual void traitementEcoute() {
-		connectionWaiting();
-	}
-	/*!
-	 * 
-	 * \brief Lance la méthode traiterClient dans un nouveau thead temporaire.
-	 * 
-	 */
-	virtual void traitementNouveauClient() {
-		traiterClient();
-	}
+    /*!
+     *
+     * \brief Lance la méthode connectionWaiting dans le thread d'ecoute.
+     *
+     */
+    virtual void traitementEcoute() {
+        connectionWaiting();
+    }
+    /*!
+     *
+     * \brief Lance la méthode traiterClient dans un nouveau thead temporaire.
+     *
+     */
+    virtual void traitementNouveauClient() {
+        traiterClient();
+    }
 
 
 
-	/*!
-	 *
-	 * \brief Lance la méthode receive dans le thread de lecture.
-	 *
-	 */	
-	virtual void traitementLecture() {
-		receive();
-	}
+    /*!
+     *
+     * \brief Lance la méthode receive dans le thread de lecture.
+     *
+     */
+    virtual void traitementLecture() {
+        receive();
+    }
 
 
 
-	/*!
-	 *
-	 * \brief Lance la méthode receiveServeur dans le thread d'ecoute du serveur.
-	 *
-	 */
-	virtual void ecouteServeur() {
-		receiveServeur();
-	}
-	/*!
-	 *
-	 * \brief Lance la méthode de traitement des messages du serveur principal et de partie.
-	 *
-	 */
-	virtual void traitementServeur(){
-		traiteServeur();
-	}
+    /*!
+     *
+     * \brief Lance la méthode receiveServeur dans le thread d'ecoute du serveur.
+     *
+     */
+    virtual void ecouteServeur() {
+        receiveServeur();
+    }
+    /*!
+     *
+     * \brief Lance la méthode de traitement des messages du serveur principal et de partie.
+     *
+     */
+    virtual void traitementServeur(){
+        traiteServeur();
+    }
 
 
 

          
@@ 213,37 213,37 @@ class Game : public Threads
 
 
 
-				//
-				// Méthodes relatives à la gestion des joueurs, etc.
-				//
+                //
+                // Méthodes relatives à la gestion des joueurs, etc.
+                //
 
-	/*!
-	 *
-	 * \brief Ajoute un joueur Ă  une partie existante.
-	 * \param joueur Le joueur a ajouter Ă  la partie.
-	 * \return Un entier indiquant si l'ajout s'est bien passée.
-	 *
-	 */
-	int addPlayer(Joueur joueur);
+    /*!
+     *
+     * \brief Ajoute un joueur Ă  une partie existante.
+     * \param joueur Le joueur a ajouter Ă  la partie.
+     * \return Un entier indiquant si l'ajout s'est bien passée.
+     *
+     */
+    int addPlayer(Joueur joueur);
 
-	/*!
-	 *
-	 * \brief Déconnecte un joueur d'une partie.
-	 * \param adresse L'adresse du joueur Ă  supprimer de la partie.
-	 * \return Un entier indiquant si la suppression s'est bien passée.
-	 *
-	 */
-	int removePlayer(string adresse);
+    /*!
+     *
+     * \brief Déconnecte un joueur d'une partie.
+     * \param adresse L'adresse du joueur Ă  supprimer de la partie.
+     * \return Un entier indiquant si la suppression s'est bien passée.
+     *
+     */
+    int removePlayer(string adresse);
 
-	/*!
-	 *
-	 * \brief Ecrit dans un fichier de log les événements particuliers d'une partie.
-	 * \param message Le message Ă  logguer.
-	 *
-	 * Écrit à la fin du fichier sans écraser les données déjà présentes.
-	 * 
-	 */
-	void log(string message);
+    /*!
+     *
+     * \brief Ecrit dans un fichier de log les événements particuliers d'une partie.
+     * \param message Le message Ă  logguer.
+     *
+     * Écrit à la fin du fichier sans écraser les données déjà présentes.
+     *
+     */
+    void log(string message);
 
 
 

          
@@ 251,33 251,33 @@ class Game : public Threads
 
 
 
-	//
-	//	Membres privés.
-	//
+    //
+    //    Membres privés.
+    //
 
-	private:
+    private:
 
-	int numberPlayer; /*!< Nombre de joueurs sur la partie. */
-	int numberPacman; /*!< Nombre de pacman */
-	int numberGhost; /*!< Nombre de fantomes */
-	list<Joueur> gamerList; /*!< Liste de joueurs de la partie. */
-	
-	string jeton; /*!< Jeton permettant de vérifier que le joueur soit passé par le serveur principal */
+    int numberPlayer; /*!< Nombre de joueurs sur la partie. */
+    int numberPacman; /*!< Nombre de pacman */
+    int numberGhost; /*!< Nombre de fantomes */
+    list<Joueur> gamerList; /*!< Liste de joueurs de la partie. */
+    
+    string jeton; /*!< Jeton permettant de vérifier que le joueur soit passé par le serveur principal */
 
-	u_short portEcoute; /*!< Port d'écoute */
-	u_short portLecture; /*!< Port de lecture */
-	u_short portEcouteDistant; /*!< Port d'écoute distant */
-	u_short portEcouteServeur; /*!< Port de communication avec le serveur principal */
-	u_short portEcouteServeurPrincipal; /*!< Port d'écoute TCP du serveur principal */
-	string adresseServeurPrincipal; /*!< Adresse du serveur principal */
-	
-	int sockEcoute; /*!< Socket d'écoute des clients */
-	int sockLecture; /*!< Socket de lecture des mouvements des clients */
-	int sockEcriture; /*!< Socket d'écriture */
-	int sockEcouteServeur; /*!< Socket d'écoute du serveur */
-	int msg_sock , msg_sock0;
-	int sockServeur;
-	int msg_sockServeur;
+    u_short portEcoute; /*!< Port d'écoute */
+    u_short portLecture; /*!< Port de lecture */
+    u_short portEcouteDistant; /*!< Port d'écoute distant */
+    u_short portEcouteServeur; /*!< Port de communication avec le serveur principal */
+    u_short portEcouteServeurPrincipal; /*!< Port d'écoute TCP du serveur principal */
+    string adresseServeurPrincipal; /*!< Adresse du serveur principal */
+    
+    int sockEcoute; /*!< Socket d'écoute des clients */
+    int sockLecture; /*!< Socket de lecture des mouvements des clients */
+    int sockEcriture; /*!< Socket d'écriture */
+    int sockEcouteServeur; /*!< Socket d'écoute du serveur */
+    int msg_sock , msg_sock0;
+    int sockServeur;
+    int msg_sockServeur;
 };
 
 #endif /*GAME_H_*/

          
M serveurPartie/joueur.cpp +18 -18
@@ 2,12 2,12 @@ 
 
 Joueur::Joueur(string nickname, int id, string ip, string type, int x, int y)
 {
-	this->nickname = nickname;
-	this->id = id;
-	this->ip = ip;
-	this->x = x;
-	this->y = y;
-	this->type = type;
+    this->nickname = nickname;
+    this->id = id;
+    this->ip = ip;
+    this->x = x;
+    this->y = y;
+    this->type = type;
 }
 
 Joueur::~Joueur()

          
@@ 15,60 15,60 @@ Joueur::~Joueur()
 
 string Joueur::getIP()
 {
-	return this->ip;
+    return this->ip;
 }
 
 string Joueur::getNickname()
 {
-	return this->nickname;
+    return this->nickname;
 }
 
 int Joueur::getID()
 {
-	return this->id;
+    return this->id;
 }
 
 void Joueur::setID(int id)
 {
-	this->id = id;
+    this->id = id;
 }
 
 int Joueur::getX()
 {
-	return this->x;
+    return this->x;
 }
 
 void Joueur::setX(int x)
 {
-	this->x = x;
+    this->x = x;
 }
 
 int Joueur::getY()
 {
-	return this->y;
+    return this->y;
 }
 
 void Joueur::setY(int y)
 {
-	this->y = y;
+    this->y = y;
 }
 
 string Joueur::getType()
 {
-	return this->type;
+    return this->type;
 }
 
 void Joueur::setIP(string ip)
 {
-	this->ip = ip;
+    this->ip = ip;
 }
 
 void Joueur::setNickname(string nickname)
 {
-	this->nickname = nickname;	
+    this->nickname = nickname;
 }
 
 void Joueur::setType(string type)
 {
-	this->type = type;
+    this->type = type;
 }

          
M serveurPartie/joueur.h +126 -130
@@ 16,31 16,87 @@ using namespace std;
  */
 class Joueur
 {
-	private:
-	string nickname; /*!< Pseudo du joueur */
-	int id; /*!< Identifiant du joueur */
-	int x, y; /*!< Coordonnées du joueur */
-	string ip; /*!< Adresse IP du joueur */
-	string type; /*!< Type du joueur (pacman ou fantĂ´me) */
-	
-	public:
-	/*!
-	 * \brief Constructeur.
-	 * \param nickname Pseudo du joueur.
-	 * \param id L'identifiant du joueur.
-	 * \param ip L'adresse IP du joueur.
-	 * \param type Le type du joueur (pacman ou fantĂ´me).
-	 * \param x L'abscisse du joueur.
-	 * \param y L'ordonnée du joueur.
-	 */
-	Joueur(string nickname, int id, string ip, string type, int x, int y);
-	
-	/*!
-	 * 
-	 * \brief Destructeur
-	 * 
-	 */
-	~Joueur();
+    private:
+    string nickname; /*!< Pseudo du joueur */
+    int id; /*!< Identifiant du joueur */
+    int x, y; /*!< Coordonnées du joueur */
+    string ip; /*!< Adresse IP du joueur */
+    string type; /*!< Type du joueur (pacman ou fantĂ´me) */
+    
+    public:
+    /*!
+     * \brief Constructeur.
+     * \param nickname Pseudo du joueur.
+     * \param id L'identifiant du joueur.
+     * \param ip L'adresse IP du joueur.
+     * \param type Le type du joueur (pacman ou fantĂ´me).
+     * \param x L'abscisse du joueur.
+     * \param y L'ordonnée du joueur.
+     */
+    Joueur(string nickname, int id, string ip, string type, int x, int y);
+    
+    /*!
+     *
+     * \brief Destructeur
+     *
+     */
+    ~Joueur();
+
+
+
+
+                //
+                // Accesseurs.
+                //
+
+
+    /*!
+     *
+     * \brief Accesseur au pseudo du joueur.
+     * \return Le pseudo du joueur.
+     *
+     */
+    string getNickname();
+
+    /*!
+     *
+     * \brief Accesseur au pseudo du joueur.
+     * \return L'identifiant du joueur.
+     *
+     */
+    int getID();
+
+    /*!
+     *
+     * \brief Accesseur a l'abscisse.
+     * \return L'abscisse du joueur.
+     *
+     */
+    int getX();
+
+    /*!
+     *
+     * \brief Accesseur a l'ordonnée.
+     * \return L'ordonnée du joueur.
+     *
+     */
+    int getY();
+
+    /*!
+     *
+     * \brief Accesseur Ă  l'adresse IP du joueur.
+     * \return L'adresse IP du joueur.
+     *
+     */
+    string getIP();
+
+    /*!
+     *
+     * \brief Accesseur au type du joueur (pacamn ou fantĂ´me).
+     * \return Le type du joueur (pacman ou fantĂ´me).
+     *
+     */
+    string getType();
 
 
 

          
@@ 49,118 105,58 @@ class Joueur
 
 
 
-				//
-				// Accesseurs.
-				//
-
-
-	/*!
-	 *
-	 * \brief Accesseur au pseudo du joueur.
-	 * \return Le pseudo du joueur.
-	 *
-	 */
-	string getNickname();
-
-	/*!
-	 *
-	 * \brief Accesseur au pseudo du joueur.
-	 * \return L'identifiant du joueur.
-	 *
-	 */
-	int getID();
-
-	/*!
-	 *
-	 * \brief Accesseur a l'abscisse.
-	 * \return L'abscisse du joueur.
-	 *
-	 */
-	int getX();
-
-	/*!
-	 *
-	 * \brief Accesseur a l'ordonnée.
-	 * \return L'ordonnée du joueur.
-	 *
-	 */
-	int getY();
-
-	/*!
-	 *
-	 * \brief Accesseur Ă  l'adresse IP du joueur.
-	 * \return L'adresse IP du joueur.
-	 *
-	 */
-	string getIP();
-
-	/*!
-	 * 
-	 * \brief Accesseur au type du joueur (pacamn ou fantĂ´me).
-	 * \return Le type du joueur (pacman ou fantĂ´me).
-	 *
-	 */	
-	string getType();
-
-
+                //
+                // Setteurs.
+                //
 
 
-
-
-
-
-				//
-				// Setteurs.
-				//
-
+    /*!
+     *
+     * \brief Setteur au pseudo du joueur.
+     * \param id L'identifiant du joueur.
+     *
+     */
+    void setID(int id);
 
-	/*!
-	 *
-	 * \brief Setteur au pseudo du joueur.
-	 * \param id L'identifiant du joueur.
-	 *
-	 */
-	void setID(int id);
+    /*!
+     *
+     * \brief Setteur de l'abscisse.
+     * \param x L'abscisse du joueur.
+     *
+     */
+    void setX(int x);
 
-	/*!
-	 *
-	 * \brief Setteur de l'abscisse.
-	 * \param x L'abscisse du joueur.
-	 * 
-	 */
-	void setX(int x);
+    /*!
+     *
+     * \brief Setteur de l'ordonnée.
+     * \param y L'ordonnée du joueur.
+     *
+     */
+    void setY(int y);
 
-	/*!
-	 *
-	 * \brief Setteur de l'ordonnée.
-	 * \param y L'ordonnée du joueur. 
-	 *
-	 */
-	void setY(int y);
-
-	/*!
-	 *
-	 * \brief Setteur du pseudo du joueur.
-	 * \param nickname Le pseudo du joueur.
-	 *
-	 */
-	void setNickname(string nickname);
+    /*!
+     *
+     * \brief Setteur du pseudo du joueur.
+     * \param nickname Le pseudo du joueur.
+     *
+     */
+    void setNickname(string nickname);
 
-	/*!
-	 *
-	 * \brief Setteur de l'adresse IP du joueur.
-	 * \param ip L'adresse IP du joueur/ 
-	 * 
-	 */
-	void setIP(string ip);
+    /*!
+     *
+     * \brief Setteur de l'adresse IP du joueur.
+     * \param ip L'adresse IP du joueur/
+     *
+     */
+    void setIP(string ip);
 
-	/*!
-	 *
-	 * \brief Setteur du type du joueur.
-	 * \param type Le type du joueur (pacman ou fantĂ´me). 
-	 *
-	 */	
-	void setType(string type);
+    /*!
+     *
+     * \brief Setteur du type du joueur.
+     * \param type Le type du joueur (pacman ou fantĂ´me).
+     *
+     */
+    void setType(string type);
 };
 
 #endif /*JOUEUR_H_*/

          
M serveurPartie/main.cpp +31 -31
@@ 7,42 7,42 @@ using namespace std;
 
 int main(int argc, char **argv)
 {
-	// port d'ecoute TCP des messages du serveur
-	u_short portEcouteServeur = 2330;
-	// port d'ecoute TCP de connection des clients
-	u_short portEcoute = 2331;
-	// port d'ecoute UDP des mouvements des joueurs
-	u_short portLecture = 2332;
+    // port d'ecoute TCP des messages du serveur
+    u_short portEcouteServeur = 2330;
+    // port d'ecoute TCP de connection des clients
+    u_short portEcoute = 2331;
+    // port d'ecoute UDP des mouvements des joueurs
+    u_short portLecture = 2332;
 
-	// port d'ecoute UDP du client distant
-	u_short portEcouteDistant = 8880;
-	// port d'ecoute TCP du serveur principal
-	u_short portEcouteServeurPrincipal = 7770;
+    // port d'ecoute UDP du client distant
+    u_short portEcouteDistant = 8880;
+    // port d'ecoute TCP du serveur principal
+    u_short portEcouteServeurPrincipal = 7770;
 
-	string adresseServeurPrincipal;
-	cout << "Adresse du serveur principal :" << endl;
-	cin >> adresseServeurPrincipal;
-	cout << "Connexion au serveur...\n" << endl;
+    string adresseServeurPrincipal;
+    cout << "Adresse du serveur principal :" << endl;
+    cin >> adresseServeurPrincipal;
+    cout << "Connexion au serveur...\n" << endl;
 
-	Game * jeux = new Game(portEcoute, portLecture, portEcouteServeur, portEcouteDistant, portEcouteServeurPrincipal, adresseServeurPrincipal);
+    Game * jeux = new Game(portEcoute, portLecture, portEcouteServeur, portEcouteDistant, portEcouteServeurPrincipal, adresseServeurPrincipal);
 
-	// Lancement thread d'ecoute du serveur :
-	pthread_t * join_toEcouteServeur = jeux->initEcouteServeur();
+    // Lancement thread d'ecoute du serveur :
+    pthread_t * join_toEcouteServeur = jeux->initEcouteServeur();
 
-	// si connexion au serveur principal reussie
-	if (jeux->serveurConnection() == 0)
-	{
-		// Lancement thread d'ecoute des clients :
-		pthread_t * join_toEcoute = jeux->initEcoute();
-		// Lancement thread de lecture :
-		pthread_t * join_toLecture = jeux->initLecture();
+    // si connexion au serveur principal reussie
+    if (jeux->serveurConnection() == 0)
+    {
+        // Lancement thread d'ecoute des clients :
+        pthread_t * join_toEcoute = jeux->initEcoute();
+        // Lancement thread de lecture :
+        pthread_t * join_toLecture = jeux->initLecture();
 
-		(void) pthread_join(*join_toEcoute, NULL);
-		(void) pthread_join(*join_toLecture, NULL);
-		(void) pthread_join(*join_toEcouteServeur, NULL);
-	}
-	else
-		printf("Erreur de connexion au serveur principal.\n");
+        (void) pthread_join(*join_toEcoute, NULL);
+        (void) pthread_join(*join_toLecture, NULL);
+        (void) pthread_join(*join_toEcouteServeur, NULL);
+    }
+    else
+        printf("Erreur de connexion au serveur principal.\n");
 
-	return 0;
+    return 0;
 }

          
M serveurPartie/threads.h +150 -150
@@ 14,81 14,81 @@ using namespace std;
  */
 class Threads
 {
-	private:
-		pthread_t threadEcouteNouveauClient; /*!< Thread d'ecoute de connexion de nouveau client */
-		pthread_t threadTraitementNouveauClient; /*!< Thread temporaire de traitement des nouveaux clients */
+    private:
+        pthread_t threadEcouteNouveauClient; /*!< Thread d'ecoute de connexion de nouveau client */
+        pthread_t threadTraitementNouveauClient; /*!< Thread temporaire de traitement des nouveaux clients */
 
-		pthread_t threadLecture; /*!< Thread de lecture */
+        pthread_t threadLecture; /*!< Thread de lecture */
 
-		pthread_t threadEcouteServeur; /*!< Thread d'ecoute serveur principal et de partie */
-		pthread_t threadTraitementServeur; /*!< Thread d'ecoute serveur principal et de partie */
-		
+        pthread_t threadEcouteServeur; /*!< Thread d'ecoute serveur principal et de partie */
+        pthread_t threadTraitementServeur; /*!< Thread d'ecoute serveur principal et de partie */
+    
 
 
 
 
-	public:
-		Threads() {}
+    public:
+        Threads() {}
 
-		/*!
-		 * 
-		 * Thread d'Ecoute
-		 * 
-		 */
-		pthread_t * initEcoute()
-		{
-			/* Initialise les attributs du threads */
-			pthread_attr_t attr;
-			pthread_attr_init(&attr);
-			pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
+        /*!
+         *
+         * Thread d'Ecoute
+         *
+         */
+        pthread_t * initEcoute()
+        {
+            /* Initialise les attributs du threads */
+            pthread_attr_t attr;
+            pthread_attr_init(&attr);
+            pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
 
-			if( ! (pthread_create(&(this->threadEcouteNouveauClient), &attr, Threads::demarrerEcoute, static_cast<void *>(this))) )
-			{
-				printf("Creation du thread d'ecoute des joueurs\n");
-				return &(this->threadEcouteNouveauClient);
-			}
-			else
-			{
-				printf("Echec de la creation du thread d'ecoute des joueurs\n");
-				exit(0);
-			}
-		}
-		static void * demarrerEcoute(void * thread)
-		{
-			static_cast<Threads *>(thread)->traitementEcoute();
-			pthread_exit(NULL);
-		}
+            if( ! (pthread_create(&(this->threadEcouteNouveauClient), &attr, Threads::demarrerEcoute, static_cast<void *>(this))) )
+            {
+                printf("Creation du thread d'ecoute des joueurs\n");
+                return &(this->threadEcouteNouveauClient);
+            }
+            else
+            {
+                printf("Echec de la creation du thread d'ecoute des joueurs\n");
+                exit(0);
+            }
+        }
+        static void * demarrerEcoute(void * thread)
+        {
+            static_cast<Threads *>(thread)->traitementEcoute();
+            pthread_exit(NULL);
+        }
 
-		virtual void traitementEcoute() = 0;
-		/*!
-		 * 
-		 * Thread de traitement d'un nouveau client.
-		 * 
-		 */
-		pthread_t * traiteNouveauClient()
-		{
-			/* Initialise les attributs du threads */
-			pthread_attr_t attr;
-			pthread_attr_init(&attr);
-			pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
+        virtual void traitementEcoute() = 0;
+        /*!
+         *
+         * Thread de traitement d'un nouveau client.
+         *
+         */
+        pthread_t * traiteNouveauClient()
+        {
+            /* Initialise les attributs du threads */
+            pthread_attr_t attr;
+            pthread_attr_init(&attr);
+            pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
 
-			if( ! (pthread_create(&(this->threadTraitementNouveauClient), &attr, Threads::traiterNouveauClient, static_cast<void *>(this))) )
-			{
-				printf("Creation du thread temporaire de traitement des joueurs\n");
-				return &(this->threadTraitementNouveauClient);
-			}
-			else
-			{
-				printf("Echec de la creation du thread temporaire de traitement des joueurs\n");
-				exit(0);
-			}
-		}
-		static void * traiterNouveauClient(void * thread)
-		{
-			static_cast<Threads *>(thread)->traitementNouveauClient();
-			pthread_exit(NULL);
-		}
-		virtual void traitementNouveauClient() = 0;
+            if( ! (pthread_create(&(this->threadTraitementNouveauClient), &attr, Threads::traiterNouveauClient, static_cast<void *>(this))) )
+            {
+                printf("Creation du thread temporaire de traitement des joueurs\n");
+                return &(this->threadTraitementNouveauClient);
+            }
+            else
+            {
+                printf("Echec de la creation du thread temporaire de traitement des joueurs\n");
+                exit(0);
+            }
+        }
+        static void * traiterNouveauClient(void * thread)
+        {
+            static_cast<Threads *>(thread)->traitementNouveauClient();
+            pthread_exit(NULL);
+        }
+        virtual void traitementNouveauClient() = 0;
 
 
 

          
@@ 97,37 97,37 @@ class Threads
 
 
 
-		/*!
-		 * 
-		 * Thread de Lecture des déplacements
-		 * 
-		 */
-		pthread_t * initLecture()
-		{	
-			/* Initialise les attributs du threads */
-			pthread_attr_t attr;
-			pthread_attr_init(&attr);
-			pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
+        /*!
+         *
+         * Thread de Lecture des déplacements
+         *
+         */
+        pthread_t * initLecture()
+        {
+            /* Initialise les attributs du threads */
+            pthread_attr_t attr;
+            pthread_attr_init(&attr);
+            pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
 
-			if( ! (pthread_create(&(this->threadLecture), &attr, Threads::demarrerLecture, static_cast<void *>(this))) )
-			{
-				printf("Creation du thread Lecture des joueurs\n");
-				return &(this->threadLecture);
-			}
-			else
-			{
-				printf("Echec de la creation du thread Lecture des joueurs\n");
-				exit(0);
-			}
-		}
-		
-		static void * demarrerLecture(void * thread)
-		{
-			static_cast<Threads *>(thread)->traitementLecture();
-			pthread_exit(NULL);
-		}
+            if( ! (pthread_create(&(this->threadLecture), &attr, Threads::demarrerLecture, static_cast<void *>(this))) )
+            {
+                printf("Creation du thread Lecture des joueurs\n");
+                return &(this->threadLecture);
+            }
+            else
+            {
+                printf("Echec de la creation du thread Lecture des joueurs\n");
+                exit(0);
+            }
+        }
+    
+        static void * demarrerLecture(void * thread)
+        {
+            static_cast<Threads *>(thread)->traitementLecture();
+            pthread_exit(NULL);
+        }
 
-		virtual void traitementLecture() = 0;
+        virtual void traitementLecture() = 0;
 
 
 

          
@@ 136,63 136,63 @@ class Threads
 
 
 
-		/*!
-		 * 
-		 * Thread d'ecoute du serveur principal et de partie
-		 * 
-		 */		
-		pthread_t * initEcouteServeur()
-		{	
-			/* Initialise les attributs du threads */
-			pthread_attr_t attr;
-			pthread_attr_init(&attr);
-			pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
+        /*!
+         *
+         * Thread d'ecoute du serveur principal et de partie
+         *
+         */
+        pthread_t * initEcouteServeur()
+        {
+            /* Initialise les attributs du threads */
+            pthread_attr_t attr;
+            pthread_attr_init(&attr);
+            pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
 
-			if( ! (pthread_create(&(this->threadEcouteServeur), &attr, Threads::demarrerEcouteServeur, static_cast<void *>(this))) )
-			{
-				printf("Creation du thread d'ecoute du serveur principal\n");
-				return &(this->threadEcouteServeur);
-			}
-			else
-			{
-				printf("Echec de la creation du thread d'ecoute du serveur principal\n");
-				exit(0);
-			}
-		}
-		static void * demarrerEcouteServeur(void * thread)
-		{
-			static_cast<Threads *>(thread)->ecouteServeur();
-			pthread_exit(NULL);
-		}
-		virtual void ecouteServeur() = 0;
-		/*!
-		 * 
-		 * Thread de traitement des message du serveur principal
-		 * 
-		 */		
-		pthread_t * initTraitementServeur()
-		{	
-			/* Initialise les attributs du threads */
-			pthread_attr_t attr;
-			pthread_attr_init(&attr);
-			pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
+            if( ! (pthread_create(&(this->threadEcouteServeur), &attr, Threads::demarrerEcouteServeur, static_cast<void *>(this))) )
+            {
+                printf("Creation du thread d'ecoute du serveur principal\n");
+                return &(this->threadEcouteServeur);
+            }
+            else
+            {
+                printf("Echec de la creation du thread d'ecoute du serveur principal\n");
+                exit(0);
+            }
+        }
+        static void * demarrerEcouteServeur(void * thread)
+        {
+            static_cast<Threads *>(thread)->ecouteServeur();
+            pthread_exit(NULL);
+        }
+        virtual void ecouteServeur() = 0;
+        /*!
+         *
+         * Thread de traitement des message du serveur principal
+         *
+         */
+        pthread_t * initTraitementServeur()
+        {
+            /* Initialise les attributs du threads */
+            pthread_attr_t attr;
+            pthread_attr_init(&attr);
+            pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
 
-			if( ! (pthread_create(&(this->threadTraitementServeur), &attr, Threads::demarrerTraitementServeur, static_cast<void *>(this))) )
-			{
-				printf("Creation du thread de traitement du serveur principal\n");
-				return &(this->threadTraitementServeur);
-			}
-			else
-			{
-				printf("Echec de la creation du thread de traitement du serveur principal\n");
-				exit(0);
-			}
-		}
-		static void * demarrerTraitementServeur(void * thread)
-		{
-			static_cast<Threads *>(thread)->traitementServeur();
-			pthread_exit(NULL);
-		}
-		virtual void traitementServeur() = 0;
+            if( ! (pthread_create(&(this->threadTraitementServeur), &attr, Threads::demarrerTraitementServeur, static_cast<void *>(this))) )
+            {
+                printf("Creation du thread de traitement du serveur principal\n");
+                return &(this->threadTraitementServeur);
+            }
+            else
+            {
+                printf("Echec de la creation du thread de traitement du serveur principal\n");
+                exit(0);
+            }
+        }
+        static void * demarrerTraitementServeur(void * thread)
+        {
+            static_cast<Threads *>(thread)->traitementServeur();
+            pthread_exit(NULL);
+        }
+        virtual void traitementServeur() = 0;
 };
 #endif /*THREADS_H_*/

          
M serveurPrincipal/main.cpp +23 -23
@@ 7,36 7,36 @@ using namespace std;
 
 int main(int argc, char **argv)
 {
-	// port d'attente des serveurs de partie
-	u_short portServeurPartie = 7770;
-	// port d'attente des clients
-	u_short portLecture = 7771;
-	// port de lecture des messages des serveurs de partie
-	u_short portLectureServeurPartie = 7772;
+    // port d'attente des serveurs de partie
+    u_short portServeurPartie = 7770;
+    // port d'attente des clients
+    u_short portLecture = 7771;
+    // port de lecture des messages des serveurs de partie
+    u_short portLectureServeurPartie = 7772;
 
-	// port d'ecoute du serveur de partie distant
-	u_short portEcouteServeurPartie = 2330;
-	// port d'ecoute des serveurs de partie
-	u_short portEcouteClientServeurPartie = 2331;
+    // port d'ecoute du serveur de partie distant
+    u_short portEcouteServeurPartie = 2330;
+    // port d'ecoute des serveurs de partie
+    u_short portEcouteClientServeurPartie = 2331;
 
 
-	Serveur * serveur;
-	serveur = Serveur::getInstance(portServeurPartie, portLecture, portLectureServeurPartie,
-								portEcouteClientServeurPartie, portEcouteServeurPartie);
+    Serveur * serveur;
+    serveur = Serveur::getInstance(portServeurPartie, portLecture, portLectureServeurPartie,
+                                portEcouteClientServeurPartie, portEcouteServeurPartie);
 
-	pthread_t * join_toEcouteNouveauServeurPartie =  serveur->initAttendServeurPartie();
-	pthread_t * join_toEcouteNouveauClient = serveur->initAttendClient();
-	pthread_t * join_toLectureServeurPartie = serveur->initLectureServeurPartie();
+    pthread_t * join_toEcouteNouveauServeurPartie =  serveur->initAttendServeurPartie();
+    pthread_t * join_toEcouteNouveauClient = serveur->initAttendClient();
+    pthread_t * join_toLectureServeurPartie = serveur->initLectureServeurPartie();
 
-	//pthread_t * join_toTestServeurPartie = serveur->initTestServeurPartie();
+    //pthread_t * join_toTestServeurPartie = serveur->initTestServeurPartie();
 
 
 
-	(void) pthread_join(*join_toEcouteNouveauServeurPartie, NULL);
-	(void) pthread_join(*join_toEcouteNouveauClient, NULL);
-	(void) pthread_join(*join_toLectureServeurPartie, NULL);
-	
-	//(void) pthread_join(*join_toTestServeurPartie, NULL);
+    (void) pthread_join(*join_toEcouteNouveauServeurPartie, NULL);
+    (void) pthread_join(*join_toEcouteNouveauClient, NULL);
+    (void) pthread_join(*join_toLectureServeurPartie, NULL);
+    
+    //(void) pthread_join(*join_toTestServeurPartie, NULL);
 
-	return 0;
+    return 0;
 }

          
M serveurPrincipal/partie.cpp +20 -20
@@ 2,13 2,13 @@ 
 
 Partie::Partie(string ip, int portEcoute, int portLecture, int nbJoueur, int nbPacman,int nbFantome, bool alive)
 {
-	this->ip = ip;
-	this->portEcoute = 2331;
-	this->portLecture = 2332;
-	this->nbJoueur = nbJoueur;
-	this->nbPacman = nbPacman;
-	this->nbFantome = nbFantome;
-	this->alive = true;
+    this->ip = ip;
+    this->portEcoute = 2331;
+    this->portLecture = 2332;
+    this->nbJoueur = nbJoueur;
+    this->nbPacman = nbPacman;
+    this->nbFantome = nbFantome;
+    this->alive = true;
 }
 
 Partie::~Partie()

          
@@ 16,65 16,65 @@ Partie::~Partie()
 
 string Partie::getIP()
 {
-	return this->ip;
+    return this->ip;
 }
 
 int Partie::getPortEcoute()
 {
-	return this->portEcoute;
+    return this->portEcoute;
 }
 
 int Partie::getPortLecture()
 {
-	return this->portLecture;
+    return this->portLecture;
 }
 
 int Partie::getNbJoueur()
 {
-	return this->nbJoueur;
+    return this->nbJoueur;
 }
 
 void Partie::setNbJoueur(int nbJoueur)
 {
-	this->nbJoueur = nbJoueur;
+    this->nbJoueur = nbJoueur;
 }
 
 int Partie::getNbPacman()
 {
-	return this->nbPacman;
+    return this->nbPacman;
 }
 
 void Partie::setNbPacman(int nbPacman)
 {
-	this->nbPacman = nbPacman;
+    this->nbPacman = nbPacman;
 }
 
 int Partie::getNbFantome()
 {
-	return this->nbFantome;
+    return this->nbFantome;
 }
 
 void Partie::setNbFantome(int nbFantome)
 {
-	this->nbFantome = nbFantome;
+    this->nbFantome = nbFantome;
 }
 
 string Partie::getJeton()
 {
-	return this->jeton;
+    return this->jeton;
 }
 
 void Partie::setJeton(string jeton)
 {
-	this->jeton = jeton;
+    this->jeton = jeton;
 }
 
 bool Partie::getAlive()
 {
-	return this->alive;
+    return this->alive;
 }
 
 void Partie::setAlive(bool alive)
 {
-	this->alive = alive;
+    this->alive = alive;
 }

          
M serveurPrincipal/partie.h +129 -129
@@ 13,140 13,140 @@ using namespace std;
  */
 class Partie
 {
-	private:
-	string ip; /*!< Adresse IP du la partie */
-	int portEcoute; /*!< Port d'ecoute du serveur de partie */
-	int portLecture; /*!< Port de lecture du serveur de partie */
-	int nbJoueur; /*!< Nombre de joueurs */
-	int nbPacman; /*!< Nombre de pacman */
-	int nbFantome; /*!< Nombre de fantome */
-	string jeton; /*!< Jeton */
-	bool alive; /*!< Pour savoir si la partie n'a pas planté */
-	
-	public:
-	/*!
-	 * \brief Constructeur.
-	 * \param ip L'adresse IP de la partie.
-	 * \param portEcoute Le port d'écoute TCP des nouveaux arrivants.
-	 * \param portLecture Le port de lecture UDP des mouvements.
-	 * \param nbJoueur Le nombre de joueur de la partie.
-	 * \param nbPacman Le nombre de pacman de la partie.
-	 * \param nbFantome Le nombre de fantome de la partie.
-	 * \param alive Indique si la partie n'a pas planté.
-	 */
-	Partie(string ip, int portEcoute, int portLecture, int nbJoueur, int nbPacman,int nbFantome, bool alive);
-	
-	/*!
-	 *
-	 * \brief Destructeur.
-	 *
-	 */
-	~Partie();
-	
-	
-	/*!
-	 *
-	 * \brief Accesseur Ă  l'adresse IP de la partie.
-	 * \return L'adresse IP de la partie.
-	 *
-	 */
-	string getIP();
-	
-	/*!
-	 *
-	 * \brief Accesseur au port d'ecoute de la partie.
-	 * \return Le port d'écoute TCP des nouveaux arrivants de la partie.
-	 *
-	 */
-	int getPortEcoute();
+    private:
+    string ip; /*!< Adresse IP du la partie */
+    int portEcoute; /*!< Port d'ecoute du serveur de partie */
+    int portLecture; /*!< Port de lecture du serveur de partie */
+    int nbJoueur; /*!< Nombre de joueurs */
+    int nbPacman; /*!< Nombre de pacman */
+    int nbFantome; /*!< Nombre de fantome */
+    string jeton; /*!< Jeton */
+    bool alive; /*!< Pour savoir si la partie n'a pas planté */
+    
+    public:
+    /*!
+     * \brief Constructeur.
+     * \param ip L'adresse IP de la partie.
+     * \param portEcoute Le port d'écoute TCP des nouveaux arrivants.
+     * \param portLecture Le port de lecture UDP des mouvements.
+     * \param nbJoueur Le nombre de joueur de la partie.
+     * \param nbPacman Le nombre de pacman de la partie.
+     * \param nbFantome Le nombre de fantome de la partie.
+     * \param alive Indique si la partie n'a pas planté.
+     */
+    Partie(string ip, int portEcoute, int portLecture, int nbJoueur, int nbPacman,int nbFantome, bool alive);
+    
+    /*!
+     *
+     * \brief Destructeur.
+     *
+     */
+    ~Partie();
+    
+    
+    /*!
+     *
+     * \brief Accesseur Ă  l'adresse IP de la partie.
+     * \return L'adresse IP de la partie.
+     *
+     */
+    string getIP();
+    
+    /*!
+     *
+     * \brief Accesseur au port d'ecoute de la partie.
+     * \return Le port d'écoute TCP des nouveaux arrivants de la partie.
+     *
+     */
+    int getPortEcoute();
 
-	/*!
-	 *
-	 * \brief Accesseur au port de lecture de la partie.
-	 * \return Le port de lecture UDP des mouvements.
-	 *
-	 */
-	int getPortLecture();
+    /*!
+     *
+     * \brief Accesseur au port de lecture de la partie.
+     * \return Le port de lecture UDP des mouvements.
+     *
+     */
+    int getPortLecture();
 
-	/*!
-	 *
-	 * \brief Accesseur au nombre de joueur.
-	 * \param Le nombre de joueur de la partie.
-	 *
-	 */
-	int getNbJoueur();
+    /*!
+     *
+     * \brief Accesseur au nombre de joueur.
+     * \param Le nombre de joueur de la partie.
+     *
+     */
+    int getNbJoueur();
 
-	/*!
-	 *
-	 * \brief Setteur du nombre de joueur.
-	 * \param nbJoueur Le nombre de joueur de la partie.
-	 *
-	 */
-	void setNbJoueur(int nbJoueur);
+    /*!
+     *
+     * \brief Setteur du nombre de joueur.
+     * \param nbJoueur Le nombre de joueur de la partie.
+     *
+     */
+    void setNbJoueur(int nbJoueur);
 
-	/*!
-	 *
-	 * \brief Accesseur au nombre de pacman.
-	 * \return Le nombre de pacman de la partie.
-	 *
-	 */
-	int getNbPacman();
-	
-	/*!
-	 *
-	 * \brief Setteur du nombre de pacman.
-	 * \param nbPacman Le nombre pacman de la partie.
-	 *
-	 */
-	void setNbPacman(int nbPacman);
-	
-	/*!
-	 *
-	 * \brief Accesseur au nombre de fantome.
-	 * \return Le nombre de fantome de la partie.
-	 *
-	 */
-	int getNbFantome();
-	
-	/*!
-	 *
-	 * \brief Setter du nombre de fantome.
-	 * \param nbFantome Le nombre de fantome de la partie.
-	 *
-	 */
-	void setNbFantome(int nbFantome);
+    /*!
+     *
+     * \brief Accesseur au nombre de pacman.
+     * \return Le nombre de pacman de la partie.
+     *
+     */
+    int getNbPacman();
+    
+    /*!
+     *
+     * \brief Setteur du nombre de pacman.
+     * \param nbPacman Le nombre pacman de la partie.
+     *
+     */
+    void setNbPacman(int nbPacman);
+    
+    /*!
+     *
+     * \brief Accesseur au nombre de fantome.
+     * \return Le nombre de fantome de la partie.
+     *
+     */
+    int getNbFantome();
+    
+    /*!
+     *
+     * \brief Setter du nombre de fantome.
+     * \param nbFantome Le nombre de fantome de la partie.
+     *
+     */
+    void setNbFantome(int nbFantome);
 
-	/*!
-	 *
-	 * \brief Accesseur au jeton.
-	 * \return Le jeton de la partie.
-	 *
-	 */
-	string getJeton();
-	
-	/*!
-	 *
-	 * \brief Setter du jeton.
-	 * \param jeton Le jeton de la partie.
-	 *
-	 */
-	void setJeton(string jeton);
-	
-	/*!
-	 *
-	 * \brief Accesseur au booleen alive.
-	 * \return Un booleen indiquant si la partie n'a pas planté. 
-	 *
-	 */
-	bool getAlive();
-	
-	/*!
-	 *
-	 * \brief Setter du au booleen alive.
-	 * \param alive Le booleen indiquant si la partie n'a pas planté.
-	 *
-	 */
-	void setAlive(bool alive);
+    /*!
+     *
+     * \brief Accesseur au jeton.
+     * \return Le jeton de la partie.
+     *
+     */
+    string getJeton();
+    
+    /*!
+     *
+     * \brief Setter du jeton.
+     * \param jeton Le jeton de la partie.
+     *
+     */
+    void setJeton(string jeton);
+    
+    /*!
+     *
+     * \brief Accesseur au booleen alive.
+     * \return Un booleen indiquant si la partie n'a pas planté.
+     *
+     */
+    bool getAlive();
+    
+    /*!
+     *
+     * \brief Setter du au booleen alive.
+     * \param alive Le booleen indiquant si la partie n'a pas planté.
+     *
+     */
+    void setAlive(bool alive);
 
 };
 

          
M serveurPrincipal/serveur.cpp +697 -697
@@ 24,892 24,892 @@ pthread_mutex_t mutexLog = PTHREAD_MUTEX
 
 
 Serveur * Serveur::getInstance (u_short portServeurPartie, u_short portLecture, u_short portLectureServeurPartie,
-			u_short portEcouteClientServeurPartie, u_short portEcouteServeurPartie)
+            u_short portEcouteClientServeurPartie, u_short portEcouteServeurPartie)
 {
-	if (NULL ==  _singleton)
-	{
-		std::cout << "Creation du singleton." << std::endl;
-		_singleton =  new Serveur(portServeurPartie, portLecture, portLectureServeurPartie,
-								portEcouteClientServeurPartie, portEcouteServeurPartie);
-	}
-	else
-	{
-		std::cout << "Singleton deja cree !" << std::endl;
-	}
-	return _singleton;
+    if (NULL ==  _singleton)
+    {
+        std::cout << "Creation du singleton." << std::endl;
+        _singleton =  new Serveur(portServeurPartie, portLecture, portLectureServeurPartie,
+                                portEcouteClientServeurPartie, portEcouteServeurPartie);
+    }
+    else
+    {
+        std::cout << "Singleton deja cree !" << std::endl;
+    }
+    return _singleton;
 }
 
 void Serveur::kill()
 {
-	if (NULL != _singleton)
-	{
-		delete _singleton;
-		_singleton = NULL;
-	}
+    if (NULL != _singleton)
+    {
+        delete _singleton;
+        _singleton = NULL;
+    }
 }
 
 int hasard(int min, int max)
 {
-	srand(time(NULL));
-	return (rand() % (max - min + 1)) + min;
+    srand(time(NULL));
+    return (rand() % (max - min + 1)) + min;
 }
 
 char * md5_str(char *p)
 {
-	md5_state_t state;
-	md5_byte_t digest[16];
-	char *hex_output = (char *)malloc(33);
-	int di;
+    md5_state_t state;
+    md5_byte_t digest[16];
+    char *hex_output = (char *)malloc(33);
+    int di;
 
-	md5_init(&state);
-	md5_append(&state, (const md5_byte_t *)p, (int)strlen(p));
-	md5_finish(&state, digest);
+    md5_init(&state);
+    md5_append(&state, (const md5_byte_t *)p, (int)strlen(p));
+    md5_finish(&state, digest);
 
-	for (di = 0; di < 16; di++)
-	{
-		sprintf(hex_output + di * 2, "%02x", digest[di]);
-	}
-	return hex_output;
+    for (di = 0; di < 16; di++)
+    {
+        sprintf(hex_output + di * 2, "%02x", digest[di]);
+    }
+    return hex_output;
 }
 
 Serveur::Serveur(u_short portServeurPartie, u_short portLecture, u_short portLectureServeurPartie,
-			u_short portEcouteClientServeurPartie, u_short portEcouteServeurPartie)
+            u_short portEcouteClientServeurPartie, u_short portEcouteServeurPartie)
 {
-	// port d'écoute pour les nouveaux serveurs de partie
-	this->portServeurPartie = portServeurPartie;
-	// port d'écoute pour les nouveaux clients
-	this->portClient = portLecture;
-	// port de lecture des serveurs de partie
-	this->portLectureServeurPartie = portLectureServeurPartie;
+    // port d'écoute pour les nouveaux serveurs de partie
+    this->portServeurPartie = portServeurPartie;
+    // port d'écoute pour les nouveaux clients
+    this->portClient = portLecture;
+    // port de lecture des serveurs de partie
+    this->portLectureServeurPartie = portLectureServeurPartie;
 
-	// port d'écoute du serveur de partie distant
-	this->portEcouteServeurPartie = portEcouteServeurPartie;
-	// port d'écoute des clients de partie distant
-	this->portEcouteClientServeurPartie = portEcouteClientServeurPartie;
+    // port d'écoute du serveur de partie distant
+    this->portEcouteServeurPartie = portEcouteServeurPartie;
+    // port d'écoute des clients de partie distant
+    this->portEcouteClientServeurPartie = portEcouteClientServeurPartie;
 
 
-	this->sockServeurPartie = this->createSock(this->portServeurPartie);
-	this->sockClient = this->createSock(this->portClient);
-	this->sockLectureServeurPartie = this->createSock(this->portLectureServeurPartie);
+    this->sockServeurPartie = this->createSock(this->portServeurPartie);
+    this->sockClient = this->createSock(this->portClient);
+    this->sockLectureServeurPartie = this->createSock(this->portLectureServeurPartie);
 
 
-	listen(this->sockServeurPartie, 10);
-	listen(this->sockClient, 10);
-	listen(this->sockLectureServeurPartie, 10);
+    listen(this->sockServeurPartie, 10);
+    listen(this->sockClient, 10);
+    listen(this->sockLectureServeurPartie, 10);
 
 
-	this->numberOfGame = 0;
-	this->maxGame = 10;
+    this->numberOfGame = 0;
+    this->maxGame = 10;
 }
 
 Serveur::~Serveur()
 {
-	this->close_serveur(this->sockServeurPartie);
-	this->close_serveur(this->sockClient);
-	this->close_serveur(this->sockLectureServeurPartie);
-	this->numberOfGame = 0;
+    this->close_serveur(this->sockServeurPartie);
+    this->close_serveur(this->sockClient);
+    this->close_serveur(this->sockLectureServeurPartie);
+    this->numberOfGame = 0;
 }
 
 int * Serveur::connectionServeurPartie()
 {
-	while(1)
-	{
-		pthread_mutex_lock(&mutexConnectionNouveauServeurPartie);
-		this->msg_sockServeurPartie = accept(this->sockServeurPartie, NULL, NULL);
-		if (this->msg_sockServeurPartie == -1)
-		{
-			perror("Erreur accept");
-		}
-		this->initNouveauServeurPartie();
-		pthread_mutex_unlock(&mutexConnectionNouveauServeurPartie);
-	}
-	close(this->msg_sockServeurPartie);
-	return 0;
+    while(1)
+    {
+        pthread_mutex_lock(&mutexConnectionNouveauServeurPartie);
+        this->msg_sockServeurPartie = accept(this->sockServeurPartie, NULL, NULL);
+        if (this->msg_sockServeurPartie == -1)
+        {
+            perror("Erreur accept");
+        }
+        this->initNouveauServeurPartie();
+        pthread_mutex_unlock(&mutexConnectionNouveauServeurPartie);
+    }
+    close(this->msg_sockServeurPartie);
+    return 0;
 }
 
 void  * Serveur::traiterNouveauServeurPartie()
 {
-	// réception
-	pthread_mutex_lock(&mutex_msg_sockNouveauServeurPartie);
-	int socket1 = this->msg_sockServeurPartie;
-	pthread_mutex_unlock(&mutex_msg_sockNouveauServeurPartie);
+    // réception
+    pthread_mutex_lock(&mutex_msg_sockNouveauServeurPartie);
+    int socket1 = this->msg_sockServeurPartie;
+    pthread_mutex_unlock(&mutex_msg_sockNouveauServeurPartie);
 
-	char * message = (char *)malloc(33);
+    char * message = (char *)malloc(33);
 
-	struct sockaddr_in from;
-	from.sin_port = htons((u_short)this->portServeurPartie);
-	unsigned int from_len= sizeof(from);
-	if (getpeername(socket1, (struct sockaddr*)&from, &from_len) == -1)
-	{
-		perror("Erreur d'obtention du nom du correspondant connecte a la socket");
-	}
-	printf("Connexion avec %s : %d\n", inet_ntoa(from.sin_addr), ntohs(from.sin_port));
+    struct sockaddr_in from;
+    from.sin_port = htons((u_short)this->portServeurPartie);
+    unsigned int from_len= sizeof(from);
+    if (getpeername(socket1, (struct sockaddr*)&from, &from_len) == -1)
+    {
+        perror("Erreur d'obtention du nom du correspondant connecte a la socket");
+    }
+    printf("Connexion avec %s : %d\n", inet_ntoa(from.sin_addr), ntohs(from.sin_port));
 
-	if (read(socket1, message, 33) == -1)
-	{
-		perror("Probleme read");
-		exit(-1);
-	}
+    if (read(socket1, message, 33) == -1)
+    {
+        perror("Probleme read");
+        exit(-1);
+    }
 
-	// authentification md5
-	char * msg = (char *)malloc(10);
-	strcpy(msg, "gameServer");
-	char * mesgCrypte = (char *)malloc(33);
-	mesgCrypte = md5_str(msg);
+    // authentification md5
+    char * msg = (char *)malloc(10);
+    strcpy(msg, "gameServer");
+    char * mesgCrypte = (char *)malloc(33);
+    mesgCrypte = md5_str(msg);
 
-	if (strcmp(message, mesgCrypte) == 0)
-	{
-		// si réussie, ajout à la liste des serveurs de parties
-		if (this->addGame(Partie(inet_ntoa(from.sin_addr),
-				this->portEcouteClientServeurPartie, 2332, 0, 0, 0, false)) == -1)
-		{
-			strcpy(message, "echec");
-			this->log("\nAjout du nouveau serveur de partie impossible : nombre maximum de parties atteind");
-			printf("\nAjout du nouveau serveur de partie impossible :\n");
-			printf("Nombre maximum de parties atteind.\n");
-		}
-		else
-		{
-			strcpy(message, "succes");
-			this->log("Nouveau serveur de partie connecte sur le port 7770");
-			printf("\nNouveau serveur de partie connecte : %s.\n", inet_ntoa(from.sin_addr));
-			printf("Nombre de parties disponibles : %d\n", this->getNumberOfGame());
-		}
-	}
+    if (strcmp(message, mesgCrypte) == 0)
+    {
+        // si réussie, ajout à la liste des serveurs de parties
+        if (this->addGame(Partie(inet_ntoa(from.sin_addr),
+                this->portEcouteClientServeurPartie, 2332, 0, 0, 0, false)) == -1)
+        {
+            strcpy(message, "echec");
+            this->log("\nAjout du nouveau serveur de partie impossible : nombre maximum de parties atteind");
+            printf("\nAjout du nouveau serveur de partie impossible :\n");
+            printf("Nombre maximum de parties atteind.\n");
+        }
+        else
+        {
+            strcpy(message, "succes");
+            this->log("Nouveau serveur de partie connecte sur le port 7770");
+            printf("\nNouveau serveur de partie connecte : %s.\n", inet_ntoa(from.sin_addr));
+            printf("Nombre de parties disponibles : %d\n", this->getNumberOfGame());
+        }
+    }
 
-	else
-	{
-		strcpy(message, "echec");
-		this->log("Echec de connexion d'un serveur de partie sur le port 7770");
-		printf("\nEchec de connexion du serveur de partie : %s\n", inet_ntoa(from.sin_addr));
-		printf("Nombre de parties disponibles : %d\n", this->getNumberOfGame());
-	}
+    else
+    {
+        strcpy(message, "echec");
+        this->log("Echec de connexion d'un serveur de partie sur le port 7770");
+        printf("\nEchec de connexion du serveur de partie : %s\n", inet_ntoa(from.sin_addr));
+        printf("Nombre de parties disponibles : %d\n", this->getNumberOfGame());
+    }
 
-	free(msg);
-	free(mesgCrypte);
+    free(msg);
+    free(mesgCrypte);
 
-	close(socket1);
+    close(socket1);
 
-	// envoie de la réponse
-	int sock;
-	string NomDistant = inet_ntoa(from.sin_addr);
-	struct sockaddr_in adresse;
-	struct hostent *recup;
+    // envoie de la réponse
+    int sock;
+    string NomDistant = inet_ntoa(from.sin_addr);
+    struct sockaddr_in adresse;
+    struct hostent *recup;
 
-	if ((sock = socket(AF_INET, SOCK_STREAM, 0)) == -1)
-	{
-		perror("Erreur ouverture");
-	}
+    if ((sock = socket(AF_INET, SOCK_STREAM, 0)) == -1)
+    {
+        perror("Erreur ouverture");
+    }
 
-	if ((recup = gethostbyname(NomDistant.c_str())) == NULL)
-	{
-		perror("Erreur obtention adresse");
-	}
+    if ((recup = gethostbyname(NomDistant.c_str())) == NULL)
+    {
+        perror("Erreur obtention adresse");
+    }
 
-	memcpy((char *)&adresse.sin_addr, (char *)recup->h_addr, recup->h_length);
+    memcpy((char *)&adresse.sin_addr, (char *)recup->h_addr, recup->h_length);
 
-	adresse.sin_family = AF_INET;
-	adresse.sin_port = htons((u_short)this->portEcouteServeurPartie);
-	if (connect(sock, (struct sockaddr *)&adresse, sizeof(adresse)) == -1)
-	{
-		perror("Erreur connexion");
-	}
-	if (write(sock, message, strlen(message)) == -1)
-	{
-		perror("Erreur ecriture");
-	}
+    adresse.sin_family = AF_INET;
+    adresse.sin_port = htons((u_short)this->portEcouteServeurPartie);
+    if (connect(sock, (struct sockaddr *)&adresse, sizeof(adresse)) == -1)
+    {
+        perror("Erreur connexion");
+    }
+    if (write(sock, message, strlen(message)) == -1)
+    {
+        perror("Erreur ecriture");
+    }
 
-	free(message);
-	close(sock);
+    free(message);
+    close(sock);
 
-	return NULL;
+    return NULL;
 }
 
 int * Serveur::connectionClient()
 {
-	while(1)
-	{
-		pthread_mutex_lock(&mutexConnectionClient);
-		this->msg_sockClient = accept(this->sockClient, NULL, NULL);
-		if (this->msg_sockClient == -1)
-		{
-			perror("Erreur accept");
-		}
-		this->initNouveauClient();
-		pthread_mutex_unlock(&mutexConnectionClient);
-	}
-	close(this->msg_sockClient);
-	return 0;
+    while(1)
+    {
+        pthread_mutex_lock(&mutexConnectionClient);
+        this->msg_sockClient = accept(this->sockClient, NULL, NULL);
+        if (this->msg_sockClient == -1)
+        {
+            perror("Erreur accept");
+        }
+        this->initNouveauClient();
+        pthread_mutex_unlock(&mutexConnectionClient);
+    }
+    close(this->msg_sockClient);
+    return 0;
 }
 
 void * Serveur::traiterClient()
 {
-	// réception
-	pthread_mutex_lock(&mutex_msg_sockClient);	
-	int socket1 = this->msg_sockClient;
-	pthread_mutex_unlock(&mutex_msg_sockClient);
-	char  message[1024];
-	int longueurMessage;
-	struct sockaddr_in from;
-	from.sin_port = htons((u_short)this->portClient);
-	unsigned int from_len= sizeof(from);
-	if (getpeername(socket1, (struct sockaddr*)&from, &from_len) == -1)
-	{
-		perror("Erreur d'obtention du nom du correspondant connecte a la socket");
-	}
-	printf("Connexion avec %s : %d\n\n", inet_ntoa(from.sin_addr), ntohs(from.sin_port));
-	this->log("Nouvelle connexion");
+    // réception
+    pthread_mutex_lock(&mutex_msg_sockClient);
+    int socket1 = this->msg_sockClient;
+    pthread_mutex_unlock(&mutex_msg_sockClient);
+    char  message[1024];
+    int longueurMessage;
+    struct sockaddr_in from;
+    from.sin_port = htons((u_short)this->portClient);
+    unsigned int from_len= sizeof(from);
+    if (getpeername(socket1, (struct sockaddr*)&from, &from_len) == -1)
+    {
+        perror("Erreur d'obtention du nom du correspondant connecte a la socket");
+    }
+    printf("Connexion avec %s : %d\n\n", inet_ntoa(from.sin_addr), ntohs(from.sin_port));
+    this->log("Nouvelle connexion");
 
-	longueurMessage = read(socket1, message, 1023);
-	if (longueurMessage == -1)
-	{
-		perror("Probleme read");
-		exit(-1);
-	}
+    longueurMessage = read(socket1, message, 1023);
+    if (longueurMessage == -1)
+    {
+        perror("Probleme read");
+        exit(-1);
+    }
 
-	// decoupage	
-	istringstream iss( message );
-	string mot, tab[3];
-	int i=0;
-	while ( std::getline(iss, mot, ':' ) )
-	{	
-		tab[i] = mot;
-		i++;
-	}
-	memset(message, 0, strlen (message)+1);
+    // decoupage
+    istringstream iss( message );
+    string mot, tab[3];
+    int i=0;
+    while ( std::getline(iss, mot, ':' ) )
+    {
+        tab[i] = mot;
+        i++;
+    }
+    memset(message, 0, strlen (message)+1);
 
-	//test si authentification
-	if (strcmp(tab[0].c_str(), "connect") == 0)
-	{
-		this->log("Tentative d'authentification d'un nouveau client.");
-		
-		string code = this->seekUser(tab[1]);
-		if (strcmp(tab[2].c_str(), code.c_str()) == 0)
-		{
-			// demande d'information aux serveurs de partie
-			this->infoGame();
-			// mise a jour des jetons des serveurs de parties
-			this->initJeton();
-			// on attend la reponse des serveurs de partie
-			sleep(2);
+    //test si authentification
+    if (strcmp(tab[0].c_str(), "connect") == 0)
+    {
+        this->log("Tentative d'authentification d'un nouveau client.");
+    
+        string code = this->seekUser(tab[1]);
+        if (strcmp(tab[2].c_str(), code.c_str()) == 0)
+        {
+            // demande d'information aux serveurs de partie
+            this->infoGame();
+            // mise a jour des jetons des serveurs de parties
+            this->initJeton();
+            // on attend la reponse des serveurs de partie
+            sleep(2);
 
-			// construction du message a renvoyer au client
-			// format du message :
-			//   :info1:ip1:port1!jeton1;info2:ip2:port2:jeton2;...infoN:ipN:portN:jetonN:
-			char nbJoueur[2];
-			char nbPacman[2];
-			char nbFantome[2];
-			char portEcouteServeurPartie[5];
-			char portLectureServeurPartie[5];
+            // construction du message a renvoyer au client
+            // format du message :
+            //   :info1:ip1:port1!jeton1;info2:ip2:port2:jeton2;...infoN:ipN:portN:jetonN:
+            char nbJoueur[2];
+            char nbPacman[2];
+            char nbFantome[2];
+            char portEcouteServeurPartie[5];
+            char portLectureServeurPartie[5];
 
-			
-			strcat(message, "@");
-			strcat(message, "ok");
-			strcat(message, "@");
+    
+            strcat(message, "@");
+            strcat(message, "ok");
+            strcat(message, "@");
 
-			list<Partie>::iterator i;
-			for(i = gameList.begin(); i != gameList.end(); ++i)
-			{
-				sprintf(nbJoueur, "%d", i->getNbJoueur());
-				sprintf(nbPacman, "%d", i->getNbPacman());
-				sprintf(nbFantome, "%d", i->getNbFantome());
-				sprintf(portEcouteServeurPartie, "%d", i->getPortEcoute());
-				sprintf(portLectureServeurPartie, "%d", i->getPortLecture());
+            list<Partie>::iterator i;
+            for(i = gameList.begin(); i != gameList.end(); ++i)
+            {
+                sprintf(nbJoueur, "%d", i->getNbJoueur());
+                sprintf(nbPacman, "%d", i->getNbPacman());
+                sprintf(nbFantome, "%d", i->getNbFantome());
+                sprintf(portEcouteServeurPartie, "%d", i->getPortEcoute());
+                sprintf(portLectureServeurPartie, "%d", i->getPortLecture());
 
-				strcat(message, nbJoueur);
-				strcat(message, ":");
-				strcat(message, nbPacman);
-				strcat(message, ":");
-				strcat(message, nbFantome);
-				strcat(message, ":");
-				strcat(message, i->getIP().c_str());
-				strcat(message, ":");
-				strcat(message, portEcouteServeurPartie);
-				strcat(message, ":");
-				strcat(message, portLectureServeurPartie);
-				strcat(message, ":");
-				strcat(message, i->getJeton().c_str());
-				strcat(message, ";");
-			}
-				strcat(message, "@");
+                strcat(message, nbJoueur);
+                strcat(message, ":");
+                strcat(message, nbPacman);
+                strcat(message, ":");
+                strcat(message, nbFantome);
+                strcat(message, ":");
+                strcat(message, i->getIP().c_str());
+                strcat(message, ":");
+                strcat(message, portEcouteServeurPartie);
+                strcat(message, ":");
+                strcat(message, portLectureServeurPartie);
+                strcat(message, ":");
+                strcat(message, i->getJeton().c_str());
+                strcat(message, ";");
+            }
+                strcat(message, "@");
 
-				this->log(tab[1]+" vient de se connecter");
-		}
-		else
-		{
-			// login ou mot de passe mauvais
-			strcpy(message, "loginFailed");
-			this->log("Authentification du joueur "+tab[1]+" echouee");
-		}
-	}
+                this->log(tab[1]+" vient de se connecter");
+        }
+        else
+        {
+            // login ou mot de passe mauvais
+            strcpy(message, "loginFailed");
+            this->log("Authentification du joueur "+tab[1]+" echouee");
+        }
+    }
 
-	// test si inscription
-	else if (strcmp(tab[0].c_str(), "register") == 0)
-	{
-		this->log("Tentative d'inscription d'un nouveau joueur ("+tab[1]+").");
-		if (strcmp(this->seekUser(tab[1]).c_str(), "") == 0)
-		{
-			this->registerUser(tab[1], tab[2]);
-			this->log("Nouveau joueur "+tab[1]+" inscrit.");
-			strcpy(message, "ok");
-		}
-		else if (strcmp(this->seekUser(tab[1]).c_str(), "") != 0)
-		{
-			// login deja existant
-			this->log("Inscription du nouveau joueur "+tab[1]+" echoue.");
-			printf("Login deja existant\n");
-			strcpy(message, "registerFailed");
-		}
-	}
+    // test si inscription
+    else if (strcmp(tab[0].c_str(), "register") == 0)
+    {
+        this->log("Tentative d'inscription d'un nouveau joueur ("+tab[1]+").");
+        if (strcmp(this->seekUser(tab[1]).c_str(), "") == 0)
+        {
+            this->registerUser(tab[1], tab[2]);
+            this->log("Nouveau joueur "+tab[1]+" inscrit.");
+            strcpy(message, "ok");
+        }
+        else if (strcmp(this->seekUser(tab[1]).c_str(), "") != 0)
+        {
+            // login deja existant
+            this->log("Inscription du nouveau joueur "+tab[1]+" echoue.");
+            printf("Login deja existant\n");
+            strcpy(message, "registerFailed");
+        }
+    }
 
 
-	// test si desinscription
-	else if (strcmp(tab[0].c_str(), "unregister") == 0)
-	{
-		this->log("Tentative de desinscription du joueur ("+tab[1]+").");
+    // test si desinscription
+    else if (strcmp(tab[0].c_str(), "unregister") == 0)
+    {
+        this->log("Tentative de desinscription du joueur ("+tab[1]+").");
 
-		string code = this->seekUser(tab[1]);
-		if (strcmp(tab[2].c_str(), code.c_str()) == 0)
-		{
-			this->unRegisterUser(tab[1]);
-			this->log("Desinscription du joueur "+tab[1]+" reussie.");
-			strcpy(message, "ok");
-		}
-		else
-		{
-			// desinscription echouee
-			this->log("Desinscription du joueur "+tab[1]+" echoue.");
-			printf("Desinscription echouee");
-			strcpy(message, "unregisterFailed");
-		}
-	}
+        string code = this->seekUser(tab[1]);
+        if (strcmp(tab[2].c_str(), code.c_str()) == 0)
+        {
+            this->unRegisterUser(tab[1]);
+            this->log("Desinscription du joueur "+tab[1]+" reussie.");
+            strcpy(message, "ok");
+        }
+        else
+        {
+            // desinscription echouee
+            this->log("Desinscription du joueur "+tab[1]+" echoue.");
+            printf("Desinscription echouee");
+            strcpy(message, "unregisterFailed");
+        }
+    }
 
 
-	// message errone
-	else
-	{
-		// on envoie pas de message d'erreurs. on passe silencieusement...
-		this->log("Erreur de traitement d'une connexion.");
-		return NULL;
-	}
+    // message errone
+    else
+    {
+        // on envoie pas de message d'erreurs. on passe silencieusement...
+        this->log("Erreur de traitement d'une connexion.");
+        return NULL;
+    }
 
-	if (write(socket1, message, strlen(message)) == -1)
-	{
-		perror("Erreur ecriture");
-	}
+    if (write(socket1, message, strlen(message)) == -1)
+    {
+        perror("Erreur ecriture");
+    }
 
-	close(socket1);
+    close(socket1);
 
-	return NULL;
+    return NULL;
 }
 
 int * Serveur::lectureServeurPartie()
 {
-	while(1)
-	{
-		pthread_mutex_lock(&mutexLectureServeurPartie);
-		this->msg_sockLectureServeurPartie = accept(this->sockLectureServeurPartie, NULL, NULL);
-		if (this->msg_sockLectureServeurPartie == -1)
-		{
-			perror("Erreur accept");
-		}
-		this->initTraiteServeurPartie();
-		pthread_mutex_unlock(&mutexLectureServeurPartie);
-	}
-	close(this->msg_sockLectureServeurPartie);
-	return 0;	
+    while(1)
+    {
+        pthread_mutex_lock(&mutexLectureServeurPartie);
+        this->msg_sockLectureServeurPartie = accept(this->sockLectureServeurPartie, NULL, NULL);
+        if (this->msg_sockLectureServeurPartie == -1)
+        {
+            perror("Erreur accept");
+        }
+        this->initTraiteServeurPartie();
+        pthread_mutex_unlock(&mutexLectureServeurPartie);
+    }
+    close(this->msg_sockLectureServeurPartie);
+    return 0;
 }
 
 void * Serveur::traiterServeurPartie()
-{	
-	// réception
-	pthread_mutex_lock(&mutex_msg_sockLectureServeurPartie);
-	int socket1 = this->msg_sockLectureServeurPartie;
-	pthread_mutex_unlock(&mutex_msg_sockLectureServeurPartie);
-	char message[1024];
-	int msg_len;
-	struct sockaddr_in from;
-	from.sin_port = htons((u_short)this->portLectureServeurPartie);
-	unsigned int from_len= sizeof(from);
-	getpeername(socket1, (struct sockaddr*)&from, &from_len);
-	printf("Connexion avec %s : %d\n", inet_ntoa(from.sin_addr), ntohs(from.sin_port));
+{    
+    // réception
+    pthread_mutex_lock(&mutex_msg_sockLectureServeurPartie);
+    int socket1 = this->msg_sockLectureServeurPartie;
+    pthread_mutex_unlock(&mutex_msg_sockLectureServeurPartie);
+    char message[1024];
+    int msg_len;
+    struct sockaddr_in from;
+    from.sin_port = htons((u_short)this->portLectureServeurPartie);
+    unsigned int from_len= sizeof(from);
+    getpeername(socket1, (struct sockaddr*)&from, &from_len);
+    printf("Connexion avec %s : %d\n", inet_ntoa(from.sin_addr), ntohs(from.sin_port));
 
-	msg_len= read(socket1, message, 1023);
+    msg_len= read(socket1, message, 1023);
 
-	// decoupage
-	istringstream iss( message );
-	string mot, tab[4];
-	int i=0;
-	while ( std::getline(iss, mot, ':' ) )
-	{	
-		tab[i] = mot;
-		i++;
-	}
+    // decoupage
+    istringstream iss( message );
+    string mot, tab[4];
+    int i=0;
+    while ( std::getline(iss, mot, ':' ) )
+    {
+        tab[i] = mot;
+        i++;
+    }
 
-	// le serveur de partie vient d'envoyer les informations demandé par le serveur principal
-	if (strcmp(tab[0].c_str(), "MyInfo") == 0)
-	{
-		list<Partie>::iterator i;
-		for(i = gameList.begin(); i != gameList.end(); ++i)
-		{
-			if (i->getIP() == inet_ntoa(from.sin_addr))
-			{
-				i->setNbJoueur(atoi(tab[1].c_str()));
-				i->setNbPacman(atoi(tab[2].c_str()));
-				i->setNbFantome(atoi(tab[3].c_str()));
-			}
-		}
-		return NULL;
-	}
+    // le serveur de partie vient d'envoyer les informations demandé par le serveur principal
+    if (strcmp(tab[0].c_str(), "MyInfo") == 0)
+    {
+        list<Partie>::iterator i;
+        for(i = gameList.begin(); i != gameList.end(); ++i)
+        {
+            if (i->getIP() == inet_ntoa(from.sin_addr))
+            {
+                i->setNbJoueur(atoi(tab[1].c_str()));
+                i->setNbPacman(atoi(tab[2].c_str()));
+                i->setNbFantome(atoi(tab[3].c_str()));
+            }
+        }
+        return NULL;
+    }
 
-	// le serveur de partie envoie ce message  afin de montrer qu'il n'est pas planté
-	else if (strcmp(message, "ImAlive") == 0)
-	{
-		list<Partie>::iterator i;
-		for(i = gameList.begin(); i != gameList.end(); ++i)
-		{
-			if (i->getIP() == inet_ntoa(from.sin_addr))
-			{
-				i->setAlive(true);
-			}
-		}
-		return NULL;
-	}
-	else
-		// on envoie pas de message d'erreurs. on passe silencieusement...
-		return NULL;
+    // le serveur de partie envoie ce message  afin de montrer qu'il n'est pas planté
+    else if (strcmp(message, "ImAlive") == 0)
+    {
+        list<Partie>::iterator i;
+        for(i = gameList.begin(); i != gameList.end(); ++i)
+        {
+            if (i->getIP() == inet_ntoa(from.sin_addr))
+            {
+                i->setAlive(true);
+            }
+        }
+        return NULL;
+    }
+    else
+        // on envoie pas de message d'erreurs. on passe silencieusement...
+        return NULL;
 
-	//close(msgsock);
-	close(socket1);
+    //close(msgsock);
+    close(socket1);
 
-	// envoie de la réponse
-	int sock;
-	string NomDistant = inet_ntoa(from.sin_addr);
-	struct sockaddr_in adresse;
-	struct hostent *recup;
+    // envoie de la réponse
+    int sock;
+    string NomDistant = inet_ntoa(from.sin_addr);
+    struct sockaddr_in adresse;
+    struct hostent *recup;
 
-	if ((sock = socket(AF_INET, SOCK_STREAM, 0)) == -1)
-	{
-		perror("Erreur ouverture");
-	}
+    if ((sock = socket(AF_INET, SOCK_STREAM, 0)) == -1)
+    {
+        perror("Erreur ouverture");
+    }
 
-	if ((recup = gethostbyname(NomDistant.c_str())) == NULL)
-	{
-		perror("Erreur obtention adresse");
-	}
+    if ((recup = gethostbyname(NomDistant.c_str())) == NULL)
+    {
+        perror("Erreur obtention adresse");
+    }
 
-	memcpy((char *)&adresse.sin_addr, (char *)recup->h_addr, recup->h_length);
+    memcpy((char *)&adresse.sin_addr, (char *)recup->h_addr, recup->h_length);
 
-	adresse.sin_family = AF_INET;
-	adresse.sin_port = htons((u_short)this->portEcouteServeurPartie);
-	if (connect(sock, (struct sockaddr *)&adresse, sizeof(adresse)) == -1)
-	{
-		perror("Erreur connexion");
-	}
-	if (write(sock, message, strlen(message)) == -1)
-	{
-		perror("Erreur ecriture");
-	}
+    adresse.sin_family = AF_INET;
+    adresse.sin_port = htons((u_short)this->portEcouteServeurPartie);
+    if (connect(sock, (struct sockaddr *)&adresse, sizeof(adresse)) == -1)
+    {
+        perror("Erreur connexion");
+    }
+    if (write(sock, message, strlen(message)) == -1)
+    {
+        perror("Erreur ecriture");
+    }
 
-	close(sock);
+    close(sock);
 
-	return NULL;
+    return NULL;
 }
 
 void * Serveur::infoGame()
 {
-	string NomDistant;
-	struct sockaddr_in adresse;
-	struct hostent *recup;
-	int sock;
+    string NomDistant;
+    struct sockaddr_in adresse;
+    struct hostent *recup;
+    int sock;
 
-	string message = "sendMeInfo";
+    string message = "sendMeInfo";
 
-	list<Partie>::iterator i;
+    list<Partie>::iterator i;
 
-	for(i = gameList.begin(); i != gameList.end(); ++i)
-	{
-		NomDistant = i->getIP();
+    for(i = gameList.begin(); i != gameList.end(); ++i)
+    {
+        NomDistant = i->getIP();
 
-		if ((sock = socket(AF_INET, SOCK_STREAM, 0)) == -1)
-		{
-			perror("Erreur ouverture");
-			return NULL;
-		}
-		if ((recup = gethostbyname(NomDistant.c_str())) == NULL)
-		{
-			perror("Erreur obtention adresse");
-			return NULL;
-		}
-		memcpy((char *)&adresse.sin_addr, (char *)recup->h_addr, recup->h_length);
+        if ((sock = socket(AF_INET, SOCK_STREAM, 0)) == -1)
+        {
+            perror("Erreur ouverture");
+            return NULL;
+        }
+        if ((recup = gethostbyname(NomDistant.c_str())) == NULL)
+        {
+            perror("Erreur obtention adresse");
+            return NULL;
+        }
+        memcpy((char *)&adresse.sin_addr, (char *)recup->h_addr, recup->h_length);
 
-		adresse.sin_family = AF_INET;
-		adresse.sin_port = htons((u_short)this->portEcouteServeurPartie);
-		if (connect(sock, (struct sockaddr *)&adresse, sizeof(adresse)) == -1)
-		{
-			perror("Erreur connexion");
-			return NULL;
-		}
-		if (write(sock, message.c_str(), strlen(message.c_str())) == -1)
-		{
-			perror("Erreur ecriture");
-			return NULL;
-		}
-		close(sock);
-	}
-	return 0;
+        adresse.sin_family = AF_INET;
+        adresse.sin_port = htons((u_short)this->portEcouteServeurPartie);
+        if (connect(sock, (struct sockaddr *)&adresse, sizeof(adresse)) == -1)
+        {
+            perror("Erreur connexion");
+            return NULL;
+        }
+        if (write(sock, message.c_str(), strlen(message.c_str())) == -1)
+        {
+            perror("Erreur ecriture");
+            return NULL;
+        }
+        close(sock);
+    }
+    return 0;
 }
 
 void * Serveur::sendJeton()
 {
-	string NomDistant;
-	struct sockaddr_in adresse;
-	struct hostent *recup;
-	int sock;
+    string NomDistant;
+    struct sockaddr_in adresse;
+    struct hostent *recup;
+    int sock;
 
-	char message[12];
-	char nombreAleatoireString[3];
-	int nombreAleatoireInt;
+    char message[12];
+    char nombreAleatoireString[3];
+    int nombreAleatoireInt;
 
-	// generation aleatoire d'un jeton pour chaque partie
-	list<Partie>::iterator i;
-	for(i = gameList.begin(); i != gameList.end(); ++i)
-	{
-		nombreAleatoireInt = hasard(1, 99);
-		nombreAleatoireString[0] = '\0';
-		sprintf(nombreAleatoireString, "%d", nombreAleatoireInt);
-		i->setJeton(nombreAleatoireString);
-		memset (nombreAleatoireString, 0, strlen(nombreAleatoireString));
-	}
-	// on envoie le jeton aux parties
-	for(i = gameList.begin(); i != gameList.end(); ++i)
-	{
-		NomDistant = i->getIP();
+    // generation aleatoire d'un jeton pour chaque partie
+    list<Partie>::iterator i;
+    for(i = gameList.begin(); i != gameList.end(); ++i)
+    {
+        nombreAleatoireInt = hasard(1, 99);
+        nombreAleatoireString[0] = '\0';
+        sprintf(nombreAleatoireString, "%d", nombreAleatoireInt);
+        i->setJeton(nombreAleatoireString);
+        memset (nombreAleatoireString, 0, strlen(nombreAleatoireString));
+    }
+    // on envoie le jeton aux parties
+    for(i = gameList.begin(); i != gameList.end(); ++i)
+    {
+        NomDistant = i->getIP();
 
-		if ((sock = socket(AF_INET, SOCK_STREAM, 0)) == -1)
-		{
-			perror("Erreur ouverture");
-			return NULL;
-		}
-		if ((recup = gethostbyname(NomDistant.c_str())) == NULL)
-		{
-			perror("Erreur obtention adresse");
-			return NULL;
-		}
-		memcpy((char *)&adresse.sin_addr, (char *)recup->h_addr, recup->h_length);
+        if ((sock = socket(AF_INET, SOCK_STREAM, 0)) == -1)
+        {
+            perror("Erreur ouverture");
+            return NULL;
+        }
+        if ((recup = gethostbyname(NomDistant.c_str())) == NULL)
+        {
+            perror("Erreur obtention adresse");
+            return NULL;
+        }
+        memcpy((char *)&adresse.sin_addr, (char *)recup->h_addr, recup->h_length);
 
-		adresse.sin_family = AF_INET;
-		adresse.sin_port = htons((u_short)this->portEcouteServeurPartie);
-		if (connect(sock, (struct sockaddr *)&adresse, sizeof(adresse)) == -1)
-		{
-			perror("Erreur connexion");
-			return NULL;
-		}
+        adresse.sin_family = AF_INET;
+        adresse.sin_port = htons((u_short)this->portEcouteServeurPartie);
+        if (connect(sock, (struct sockaddr *)&adresse, sizeof(adresse)) == -1)
+        {
+            perror("Erreur connexion");
+            return NULL;
+        }
 
-		memset (message, 0, sizeof (message));
-		strcpy(message, "jeton:");
-		strcat(message, i->getJeton().c_str());
+        memset (message, 0, sizeof (message));
+        strcpy(message, "jeton:");
+        strcat(message, i->getJeton().c_str());
 
-		if (write(sock, message, strlen(message)) == -1)
-		{
-			perror("Erreur ecriture");
-			return NULL;
-		}
-		close(sock);
-	}
-	return 0;
+        if (write(sock, message, strlen(message)) == -1)
+        {
+            perror("Erreur ecriture");
+            return NULL;
+        }
+        close(sock);
+    }
+    return 0;
 }
 
 void * Serveur::testPresenceServeur()
 {
-	struct sockaddr_in adresse;
-	struct hostent *recup;
-	string nomDistant, nickname, type;
-	string message = "AreYouAlive?";
+    struct sockaddr_in adresse;
+    struct hostent *recup;
+    string nomDistant, nickname, type;
+    string message = "AreYouAlive?";
 
 
-	while (1)
-	{
-		sleep(5);
+    while (1)
+    {
+        sleep(5);
 
-		// parcours de la liste des joueurs
-		list<Partie>::iterator i;
-		for(i = gameList.begin(); i != gameList.end(); ++i)
-		{
-				nomDistant = i->getIP();
-				
-				// on initialise le booleen de presence a false pour tous les serveurs 
-				i->setAlive(false);
-	
-				if ((this->sockEcriture = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
-				{
-					perror("Erreur ouverture");
-				}
-	
-				if ((recup = gethostbyname(nomDistant.c_str())) == NULL)
-				{
-					perror("Erreur obtention adresse");
-				}
-	
-				memcpy((char *)&adresse.sin_addr, (char *)recup->h_addr, recup->h_length);
-	
-				adresse.sin_family = AF_INET;
-				adresse.sin_port = htons((u_short)2332);
-	
-				if (connect(this->sockEcriture, (struct sockaddr *)&adresse, sizeof(adresse)) == -1)
-				{
-					perror("Erreur connect");
-				}
-	
-				if ((sendto(this->sockEcriture, message.c_str(), strlen(message.c_str()), 0, NULL, 0)) == -1)
-				{
-					perror("Erreur ecriture");
-				}
+        // parcours de la liste des joueurs
+        list<Partie>::iterator i;
+        for(i = gameList.begin(); i != gameList.end(); ++i)
+        {
+                nomDistant = i->getIP();
+    
+                // on initialise le booleen de presence a false pour tous les serveurs
+                i->setAlive(false);
+    
+                if ((this->sockEcriture = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
+                {
+                    perror("Erreur ouverture");
+                }
+    
+                if ((recup = gethostbyname(nomDistant.c_str())) == NULL)
+                {
+                    perror("Erreur obtention adresse");
+                }
+    
+                memcpy((char *)&adresse.sin_addr, (char *)recup->h_addr, recup->h_length);
+    
+                adresse.sin_family = AF_INET;
+                adresse.sin_port = htons((u_short)2332);
+    
+                if (connect(this->sockEcriture, (struct sockaddr *)&adresse, sizeof(adresse)) == -1)
+                {
+                    perror("Erreur connect");
+                }
+    
+                if ((sendto(this->sockEcriture, message.c_str(), strlen(message.c_str()), 0, NULL, 0)) == -1)
+                {
+                    perror("Erreur ecriture");
+                }
 
-				close(this->sockEcriture);
-	
-		}
-		
-		// on laisse le temps aux serveurs de partie de répondre
-		sleep (3);
-		// on vérifie qui a répondu
-		for(i = gameList.begin(); i != gameList.end(); ++i)
-		{
-			if (i->getAlive() == false)
-			{
-				printf("Le serveur de partie %s ne répond pas.\nIl se peut qu'il ait planté.\n\n", i->getIP().c_str());
-				printf("Supprimé de la liste des serveurs de partie.");
-				this->delGame(i->getIP());
-				break;
-			}
-		}
-	}
-	message.clear();
-	return NULL;
+                close(this->sockEcriture);
+    
+        }
+    
+        // on laisse le temps aux serveurs de partie de répondre
+        sleep (3);
+        // on vérifie qui a répondu
+        for(i = gameList.begin(); i != gameList.end(); ++i)
+        {
+            if (i->getAlive() == false)
+            {
+                printf("Le serveur de partie %s ne répond pas.\nIl se peut qu'il ait planté.\n\n", i->getIP().c_str());
+                printf("Supprimé de la liste des serveurs de partie.");
+                this->delGame(i->getIP());
+                break;
+            }
+        }
+    }
+    message.clear();
+    return NULL;
 }
 
 
 int Serveur::createSock(u_short port)
 {
-	int sock, retour;
-	struct sockaddr_in adresse;
+    int sock, retour;
+    struct sockaddr_in adresse;
 
-	sock = socket(AF_INET, SOCK_STREAM, 0);
-	if (sock<0)
-	{
-		perror ("Erreur ouverture");
-		return(-1);
-	}
+    sock = socket(AF_INET, SOCK_STREAM, 0);
+    if (sock<0)
+    {
+        perror ("Erreur ouverture");
+        return(-1);
+    }
 
-	adresse.sin_family = AF_INET;
-	adresse.sin_port = htons((u_short)port);
-	adresse.sin_addr.s_addr = INADDR_ANY;
+    adresse.sin_family = AF_INET;
+    adresse.sin_port = htons((u_short)port);
+    adresse.sin_addr.s_addr = INADDR_ANY;
 
-	retour = bind (sock, (struct sockaddr *)&adresse, sizeof(adresse));
+    retour = bind (sock, (struct sockaddr *)&adresse, sizeof(adresse));
 
-	if (retour<0)
-	{
-		perror ("Impossible de nommer le socket");
-		return(-1);
-	}
-	return (sock);
+    if (retour<0)
+    {
+        perror ("Impossible de nommer le socket");
+        return(-1);
+    }
+    return (sock);
 }
 
 int Serveur::addGame(Partie partie)
 {
-	pthread_mutex_lock(&mutexAjoutPartie);
-	if (this->numberOfGame < this->maxGame)
-	{
-		this->gameList.push_back(partie);
-		this->numberOfGame++;
-		pthread_mutex_unlock(&mutexAjoutPartie);
-		return 0;
-	}
-	pthread_mutex_unlock(&mutexAjoutPartie);
-	return -1;
+    pthread_mutex_lock(&mutexAjoutPartie);
+    if (this->numberOfGame < this->maxGame)
+    {
+        this->gameList.push_back(partie);
+        this->numberOfGame++;
+        pthread_mutex_unlock(&mutexAjoutPartie);
+        return 0;
+    }
+    pthread_mutex_unlock(&mutexAjoutPartie);
+    return -1;
 }
 
 int Serveur::delGame(string adresse)
 {
-	pthread_mutex_lock(&mutexSupprimePartie);
-	list<Partie>::iterator i;
-	for(i = gameList.begin(); i != gameList.end(); ++i)
-	{
-		if (i->getIP() == adresse)
-		{
-			this->gameList.erase(i);
-			this->numberOfGame--;
-			pthread_mutex_unlock(&mutexSupprimePartie);
-			return 0;
-		}
-	}
-	pthread_mutex_unlock(&mutexSupprimePartie);
-	return 0;
+    pthread_mutex_lock(&mutexSupprimePartie);
+    list<Partie>::iterator i;
+    for(i = gameList.begin(); i != gameList.end(); ++i)
+    {
+        if (i->getIP() == adresse)
+        {
+            this->gameList.erase(i);
+            this->numberOfGame--;
+            pthread_mutex_unlock(&mutexSupprimePartie);
+            return 0;
+        }
+    }
+    pthread_mutex_unlock(&mutexSupprimePartie);
+    return 0;
 }
 
 int Serveur::getNumberOfGame()
 {
-	return this->gameList.size();
+    return this->gameList.size();
 }
 
 void Serveur::close_serveur(int sock)
 {
-	close(sock);
+    close(sock);
 }
 
 string Serveur::seekUser(string login)
-{	
-	ifstream file;
-	string fichier = "passwd";
-	file.open(fichier.c_str(), ios::in);
-	string ligne;
-	int nbLigne = 0;
-	string code = "";
+{    
+    ifstream file;
+    string fichier = "passwd";
+    file.open(fichier.c_str(), ios::in);
+    string ligne;
+    int nbLigne = 0;
+    string code = "";
 
-	if ( file ) // ce test echoue si le fichier n'est pas ouvert
-	{
-		std::string ligne; // variable contenant chaque ligne lue
+    if ( file ) // ce test echoue si le fichier n'est pas ouvert
+    {
+        std::string ligne; // variable contenant chaque ligne lue
 
-		// cette boucle s'arrĂªte dès qu'une erreur de lecture survient
-		while ( std::getline( file, ligne ) )
-		{
-			nbLigne++;
+        // cette boucle s'arrĂªte dès qu'une erreur de lecture survient
+        while ( std::getline( file, ligne ) )
+        {
+            nbLigne++;
 
-			istringstream iss( ligne );
-			string mot, utilisateur[2];
-			int i=0;
-			while ( std::getline( iss, mot, ':' ) )
-			{	
-				utilisateur[i] = mot;
-				i++;
-			}
+            istringstream iss( ligne );
+            string mot, utilisateur[2];
+            int i=0;
+            while ( std::getline( iss, mot, ':' ) )
+            {
+                utilisateur[i] = mot;
+                i++;
+            }
 
-			if (utilisateur[0] == login)
-			{
-				code = utilisateur[1];
-				file.close();
-				return code;
-			}
-		}
-		file.close();
-	}
-	return code;
+            if (utilisateur[0] == login)
+            {
+                code = utilisateur[1];
+                file.close();
+                return code;
+            }
+        }
+        file.close();
+    }
+    return code;
 }
 
 void Serveur::registerUser(string login, string code)
 {
-	ofstream file;
-	string fichier = "passwd";
+    ofstream file;
+    string fichier = "passwd";
 
-	//app (append) Set the stream's position indicator to the end of the stream before each output operation.
-	//ate (at end) Set the stream's position indicator to the end of the stream on opening.
+    //app (append) Set the stream's position indicator to the end of the stream before each output operation.
+    //ate (at end) Set the stream's position indicator to the end of the stream on opening.
 
-	file.open(fichier.c_str(), ios::out | ios::ate | ios::app);
+    file.open(fichier.c_str(), ios::out | ios::ate | ios::app);
 
-	if (file.bad())
-	{
-		cerr << "Fichier [" << fichier << "] invalide." << endl;
-		exit(-1);
-	}
-	if (file.is_open())
+    if (file.bad())
+    {
+        cerr << "Fichier [" << fichier << "] invalide." << endl;
+        exit(-1);
+    }
+    if (file.is_open())
     {
         // Écrit les données :
-		file << login << ":" << code << endl;
+        file << login << ":" << code << endl;
 
-		file.close();
+        file.close();
     }
 }
 
 void Serveur::unRegisterUser(string login)
 {
-	ifstream file;
-	ofstream fileTemp;
-	string fichier = "passwd";
-	string fichierTemp = "tmp";
-	file.open(fichier.c_str(), ios::in);
-	fileTemp.open(fichierTemp.c_str(), ios::out | ios::ate | ios::app);
-	string ligne;
-	string code = "";
+    ifstream file;
+    ofstream fileTemp;
+    string fichier = "passwd";
+    string fichierTemp = "tmp";
+    file.open(fichier.c_str(), ios::in);
+    fileTemp.open(fichierTemp.c_str(), ios::out | ios::ate | ios::app);
+    string ligne;
+    string code = "";
 
-	// on recopie les lignes des autres utilisateurs dans un fichier temporaire
-	if ( file and fileTemp)
-	{
-		std::string ligne;
+    // on recopie les lignes des autres utilisateurs dans un fichier temporaire
+    if ( file and fileTemp)
+    {
+        std::string ligne;
 
-		while ( std::getline( file, ligne ) )
-		{
+        while ( std::getline( file, ligne ) )
+        {
 
-			istringstream iss( ligne );
-			string mot, utilisateur[2];
-			int i=0;
-			while ( std::getline( iss, mot, ':' ) )
-			{	
-				utilisateur[i] = mot;
-				i++;
-			}
+            istringstream iss( ligne );
+            string mot, utilisateur[2];
+            int i=0;
+            while ( std::getline( iss, mot, ':' ) )
+            {
+                utilisateur[i] = mot;
+                i++;
+            }
 
-			if (utilisateur[0] != login)
-			{
-				fileTemp << ligne << endl;
-			}
-		}
-		file.close();
-		fileTemp.close();
-	}
+            if (utilisateur[0] != login)
+            {
+                fileTemp << ligne << endl;
+            }
+        }
+        file.close();
+        fileTemp.close();
+    }
 
 
-	// on écrase le contenu de passwd avec celui du fichier temporaire
-	file.open(fichierTemp.c_str(), ios::in);
-	fileTemp.open(fichier.c_str(), ios::out);
-	if (file.bad() or fileTemp.bad())
-	{
-		cerr << "Erreur d'ecriture ou lecture" << endl;
-		exit(-1);
-	}
-	if (file.is_open())
+    // on écrase le contenu de passwd avec celui du fichier temporaire
+    file.open(fichierTemp.c_str(), ios::in);
+    fileTemp.open(fichier.c_str(), ios::out);
+    if (file.bad() or fileTemp.bad())
+    {
+        cerr << "Erreur d'ecriture ou lecture" << endl;
+        exit(-1);
+    }
+    if (file.is_open())
     {
-		while ( std::getline(file, ligne) )
-		{
-			fileTemp << ligne << endl;
-		}
+        while ( std::getline(file, ligne) )
+        {
+            fileTemp << ligne << endl;
+        }
 
-		file.close();
-		fileTemp.close();
+        file.close();
+        fileTemp.close();
 
-		// suppression du fichier temporaire
-		if(remove( "tmp" ) != 0)
-			printf("Erreur lors de la suppression du fichier temporaire tmp\n");
-	}
+        // suppression du fichier temporaire
+        if(remove( "tmp" ) != 0)
+            printf("Erreur lors de la suppression du fichier temporaire tmp\n");
+    }
 }
 
 void Serveur::log(string message)
 {
-	pthread_mutex_lock(&mutexLog);
-	// récupère l'heure système
-	time_t timer1;
-	time(&timer1);
-	int secondes, minutes, heures;
-	string fichier = "log";
-	struct tm *newTime1;
-	newTime1 = localtime(&timer1);
-	heures = newTime1->tm_hour;
-	minutes = newTime1->tm_min;
-	secondes = newTime1->tm_sec;
+    pthread_mutex_lock(&mutexLog);
+    // récupère l'heure système
+    time_t timer1;
+    time(&timer1);
+    int secondes, minutes, heures;
+    string fichier = "log";
+    struct tm *newTime1;
+    newTime1 = localtime(&timer1);
+    heures = newTime1->tm_hour;
+    minutes = newTime1->tm_min;
+    secondes = newTime1->tm_sec;
 
-	ofstream file;
+    ofstream file;
 
-	file.open(fichier.c_str(), ios::out | ios::ate | ios::app);
+    file.open(fichier.c_str(), ios::out | ios::ate | ios::app);
 
-	if (file.bad())
-	{
-		cerr << "Fichier [" << fichier << "] invalide." << endl;
-		pthread_mutex_unlock(&mutexLog);
-		exit(-1);
-	}
-	if (file.is_open())
+    if (file.bad())
+    {
+        cerr << "Fichier [" << fichier << "] invalide." << endl;
+        pthread_mutex_unlock(&mutexLog);
+        exit(-1);
+    }
+    if (file.is_open())
     {
         // Écrit les données :
-		file << "[" << heures << ":" << minutes << ":" << secondes << "] " << message << endl;
+        file << "[" << heures << ":" << minutes << ":" << secondes << "] " << message << endl;
         
         file.close();
     }

          
M serveurPrincipal/serveur.h +305 -305
@@ 33,28 33,28 @@ using namespace std;
  * 
  */
 class Serveur : public Threads {
-	public:
+    public:
 
-	/*!
-	 * \brief Fonction permettant de récupérer l'instance unique de la classe Serveur.
-	 * \param portServeurPartie Port d'attente des serveurs de partie.
-	 * \param portLecture Port d'attente des clients.
-	 * \param portEcouteClientServeurPartie Port d'ecoute des clients des serveurs de partie.
-	 * \param portLectureServeurPartie Port de lecture des messages des serveurs de partie.
-	 * \param portEcouteServeurPartie Port d'ecoute du serveur de partie distant.
-	 * \return Le singleton serveur de partie.
-	 *
-	 */ 
-	static Serveur * getInstance (u_short portServeurPartie, u_short portLecture,
-			u_short portEcouteClientServeurPartie, u_short portLectureServeurPartie, u_short portEcouteServeurPartie);
+    /*!
+     * \brief Fonction permettant de récupérer l'instance unique de la classe Serveur.
+     * \param portServeurPartie Port d'attente des serveurs de partie.
+     * \param portLecture Port d'attente des clients.
+     * \param portEcouteClientServeurPartie Port d'ecoute des clients des serveurs de partie.
+     * \param portLectureServeurPartie Port de lecture des messages des serveurs de partie.
+     * \param portEcouteServeurPartie Port d'ecoute du serveur de partie distant.
+     * \return Le singleton serveur de partie.
+     *
+     */
+    static Serveur * getInstance (u_short portServeurPartie, u_short portLecture,
+            u_short portEcouteClientServeurPartie, u_short portLectureServeurPartie, u_short portEcouteServeurPartie);
 
-	/*!
-	 * \brief Fait pointer le singleton sur NULL.
-	 *
-	 *  Pour une future utilisation possible de la classe.
-	 *
-	 */
-	static void kill ();
+    /*!
+     * \brief Fait pointer le singleton sur NULL.
+     *
+     *  Pour une future utilisation possible de la classe.
+     *
+     */
+    static void kill ();
 
 
 

          
@@ 63,84 63,84 @@ class Serveur : public Threads {
 
 
 
-				//
-				// Méthodes relatives à la création de threads.
-				// Concrétise les virtuelles pures de la classe Threads.
-				//
+                //
+                // Méthodes relatives à la création de threads.
+                // Concrétise les virtuelles pures de la classe Threads.
+                //
 
 
-	/*!
-	 *
-	 * \brief Lance le thread d'écoute de nouveaux serveurs de partie.
-	 *
-	 */
-	virtual void traitementEcouteServeurPartie() {
-		this->connectionServeurPartie();
-	}
-	/*!
-	 *
-	 * \brief Lance le thread d'écoute de traitements des serveurs de partie.
-	 *
-	 */
-	virtual void traitementNouveauServeurPartie() {
-		this->traiterNouveauServeurPartie();
-	}
+    /*!
+     *
+     * \brief Lance le thread d'écoute de nouveaux serveurs de partie.
+     *
+     */
+    virtual void traitementEcouteServeurPartie() {
+        this->connectionServeurPartie();
+    }
+    /*!
+     *
+     * \brief Lance le thread d'écoute de traitements des serveurs de partie.
+     *
+     */
+    virtual void traitementNouveauServeurPartie() {
+        this->traiterNouveauServeurPartie();
+    }
 
 
-	/*!
-	 *
-	 * \brief Lance le thread d'écoute de nouveaux clients.
-	 *
-	 */
-	virtual void traitementEcouteClient() {
-		this->connectionClient();
-	}
-	/*!
-	 *
-	 * \brief Lance le thread d'écoute de traitements des clients.
-	 *
-	 */
-	virtual void traitementClient() {
-		this->traiterClient();
-	}
+    /*!
+     *
+     * \brief Lance le thread d'écoute de nouveaux clients.
+     *
+     */
+    virtual void traitementEcouteClient() {
+        this->connectionClient();
+    }
+    /*!
+     *
+     * \brief Lance le thread d'écoute de traitements des clients.
+     *
+     */
+    virtual void traitementClient() {
+        this->traiterClient();
+    }
 
 
-	/*!
-	 *
-	 * \brief Lance le thread de lecture des serveurs de partie.
-	 *
-	 */
-	virtual void traitementLectureServeurPartie() {
-		this->lectureServeurPartie();
-	}
-	/*!
-	 *
-	 * \brief Lance le thread de traitement des serveurs de partie.
-	 *
-	 */
-	virtual void traitementServeurPartie() {
-		this->traiterServeurPartie();
-	}
+    /*!
+     *
+     * \brief Lance le thread de lecture des serveurs de partie.
+     *
+     */
+    virtual void traitementLectureServeurPartie() {
+        this->lectureServeurPartie();
+    }
+    /*!
+     *
+     * \brief Lance le thread de traitement des serveurs de partie.
+     *
+     */
+    virtual void traitementServeurPartie() {
+        this->traiterServeurPartie();
+    }
 
 
-	/*!
-	 *
-	 * \brief Lance le thread de test de présence des serveurs de partiee.
-	 *
-	 */
-	virtual void traitementTestServeurPartie() {
-		this->testPresenceServeur();
-	}
+    /*!
+     *
+     * \brief Lance le thread de test de présence des serveurs de partiee.
+     *
+     */
+    virtual void traitementTestServeurPartie() {
+        this->testPresenceServeur();
+    }
 
 
-	/*!
-	 *
-	 * \brief Lance le thread de renouvellement du jeton.
-	 *
-	 */
-	virtual void traitementJeton() {
-		this->sendJeton();
-	}
+    /*!
+     *
+     * \brief Lance le thread de renouvellement du jeton.
+     *
+     */
+    virtual void traitementJeton() {
+        this->sendJeton();
+    }
 
 
 

          
@@ 149,85 149,85 @@ class Serveur : public Threads {
 
 
 
-				//
-				// Méthodes lancées dans des threads.
-				//
+                //
+                // Méthodes lancées dans des threads.
+                //
 
 
 
-	/*!
-	 *
-	 * \brief Attend la connection d'un serveur de partie.
-	 * 
-	 * Cette méthode est lancée dans un thread.
-	 * 
-	 */
-	int * connectionServeurPartie();
-	
-	/*!
-	 * 
-	 * \brief Attend la connexion d'un client.
-	 * 
-	 * Cette méthode est lancée dans un thread.
-	 * 
-	 */
-	int * connectionClient();
+    /*!
+     *
+     * \brief Attend la connection d'un serveur de partie.
+     *
+     * Cette méthode est lancée dans un thread.
+     *
+     */
+    int * connectionServeurPartie();
+    
+    /*!
+     *
+     * \brief Attend la connexion d'un client.
+     *
+     * Cette méthode est lancée dans un thread.
+     *
+     */
+    int * connectionClient();
 
 
-	/*!
-	 *
-	 * \brief Traite la connection d'un serveur de partie.
-	 *
-	 * Cette méthode est lancée dans un thread.
-	 *
-	 */
-	void * traiterNouveauServeurPartie();
+    /*!
+     *
+     * \brief Traite la connection d'un serveur de partie.
+     *
+     * Cette méthode est lancée dans un thread.
+     *
+     */
+    void * traiterNouveauServeurPartie();
 
-	/*!
-	 *
-	 * \brief Traite les messages des serveurs de partie.
-	 *
-	 * Cette méthode est lancée dans un thread.
-	 *
-	 */
-	void * traiterServeurPartie();
+    /*!
+     *
+     * \brief Traite les messages des serveurs de partie.
+     *
+     * Cette méthode est lancée dans un thread.
+     *
+     */
+    void * traiterServeurPartie();
 
-	/*!
-	 * 
-	 * Traite la connection d'un client.
-	 *
-	 * Cette méthode est lancée dans un thread.
-	 *
-	 */	
-	void * traiterClient();
+    /*!
+     *
+     * Traite la connection d'un client.
+     *
+     * Cette méthode est lancée dans un thread.
+     *
+     */
+    void * traiterClient();
 
-	/*!
-	 *
-	 * \brief Attend les messages des serveurs de partie.
-	 *
-	 * Cette méthode est lancée dans un thread.
-	 *
-	 */
-	int * lectureServeurPartie();
-	
+    /*!
+     *
+     * \brief Attend les messages des serveurs de partie.
+     *
+     * Cette méthode est lancée dans un thread.
+     *
+     */
+    int * lectureServeurPartie();
+    
 
-	/*!
-	 * 
-	 * \brief Test si un serveur de partie n'a pas planté.
-	 *
-	 * Cette méthode est lancée dans un thread.
-	 *
-	 */
-	void * testPresenceServeur();
+    /*!
+     *
+     * \brief Test si un serveur de partie n'a pas planté.
+     *
+     * Cette méthode est lancée dans un thread.
+     *
+     */
+    void * testPresenceServeur();
 
-	/*!
-	 * 
-	 * \brief Envoie le nouveau jeton aux serveurs de partie.
-	 *
-	 * Cette méthode est lancée dans un thread.
-	 *
-	 */
-	void * sendJeton();
+    /*!
+     *
+     * \brief Envoie le nouveau jeton aux serveurs de partie.
+     *
+     * Cette méthode est lancée dans un thread.
+     *
+     */
+    void * sendJeton();
 
 
 

          
@@ 236,80 236,80 @@ class Serveur : public Threads {
 
 
 
-				//
-				// Méthodes relatives à la gestion des utilisateurs
-				// Identification, ajout/suppression de joueurs, etc.
-				//
+                //
+                // Méthodes relatives à la gestion des utilisateurs
+                // Identification, ajout/suppression de joueurs, etc.
+                //
 
 
-	/*!
-	 *
-	 * \brief Recherche un utilisateur.
-	 * \param login Le login de l'utilisateur rechercher.
-	 * \return Le code de l'utilisateur s'il existe, la chaîne vide sinon.
-	 *
-	 */
-	string seekUser(string login);
+    /*!
+     *
+     * \brief Recherche un utilisateur.
+     * \param login Le login de l'utilisateur rechercher.
+     * \return Le code de l'utilisateur s'il existe, la chaîne vide sinon.
+     *
+     */
+    string seekUser(string login);
 
-	/*!
-	 *
-	 * \brief Enregistre un utilisateur dans le ficher.
-	 * \param login Le login de l'utilisateur à créer.
-	 * \param code Le code de l'utilisateur à créer.
-	 *
-	 */
-	void registerUser(string login, string code);
-	
-	/*!
-	 *
-	 * \brief Supprime l'utilisateur de la liste des joueurs.
-	 * \param login Le login de l'utilisateur à désinscrire.
-	 *
-	 */
-	void unRegisterUser(string login);
-	
-	/*!
-	 *
-	 * \brief Demande aux serveurs de partie des renseignements sur leur états (nombre de joueurs, ports, etc.).
-	 *
-	 */
-	void * infoGame();
-	
-	/*!
-	 *
-	 * \brief Ajoute un serveur de partie Ă  la liste des jeux.
-	 * \param partie Un objet Partie représentant la nouvelle partie.
-	 * \return Un entier indiquant si l'ajout s'est bien passé.
-	 *
-	 */
-	int addGame(Partie partie);
+    /*!
+     *
+     * \brief Enregistre un utilisateur dans le ficher.
+     * \param login Le login de l'utilisateur à créer.
+     * \param code Le code de l'utilisateur à créer.
+     *
+     */
+    void registerUser(string login, string code);
+    
+    /*!
+     *
+     * \brief Supprime l'utilisateur de la liste des joueurs.
+     * \param login Le login de l'utilisateur à désinscrire.
+     *
+     */
+    void unRegisterUser(string login);
+    
+    /*!
+     *
+     * \brief Demande aux serveurs de partie des renseignements sur leur états (nombre de joueurs, ports, etc.).
+     *
+     */
+    void * infoGame();
+    
+    /*!
+     *
+     * \brief Ajoute un serveur de partie Ă  la liste des jeux.
+     * \param partie Un objet Partie représentant la nouvelle partie.
+     * \return Un entier indiquant si l'ajout s'est bien passé.
+     *
+     */
+    int addGame(Partie partie);
 
-	/*!
-	 *
-	 * \brief Supprime un serveur de partie Ă  la liste des jeux.
-	 * \param adresse L'adresse du joueur Ă  supprimer de la partie.
-	 * \return Un entier indiquant si la suppression s'est bien passée.
-	 *
-	 */	
-	int delGame(string adresse);
-	
-	/*!
-	 *
-	 * \brief Renvoie le nombre de partie en cours.
-	 * \return Le nombre de partie.
-	 *
-	 */
-	int getNumberOfGame();
-	
-	/*!
-	 *
-	 * \brief Écrit dans un fichier de log les événements particuliers d'une partie.
-	 * \param message Le message a logguer.
-	 *
-	 * Écrit à la fin du fichier sans écraser les données déjà présentes.
-	 *
-	 */
-	void log(string message);
+    /*!
+     *
+     * \brief Supprime un serveur de partie Ă  la liste des jeux.
+     * \param adresse L'adresse du joueur Ă  supprimer de la partie.
+     * \return Un entier indiquant si la suppression s'est bien passée.
+     *
+     */
+    int delGame(string adresse);
+    
+    /*!
+     *
+     * \brief Renvoie le nombre de partie en cours.
+     * \return Le nombre de partie.
+     *
+     */
+    int getNumberOfGame();
+    
+    /*!
+     *
+     * \brief Écrit dans un fichier de log les événements particuliers d'une partie.
+     * \param message Le message a logguer.
+     *
+     * Écrit à la fin du fichier sans écraser les données déjà présentes.
+     *
+     */
+    void log(string message);
 
 
 

          
@@ 318,27 318,27 @@ class Serveur : public Threads {
 
 
 
-				//
-				// Socket.
-				//
+                //
+                // Socket.
+                //
 
 
-	/*!
-	 *
-	 * \brief Crée simplement un socket.
-	 * \param port Le port du socket.
-	 * \return Un entier indiquand si la création s'est bien passée.
-	 *
-	 */
-	int createSock(u_short port);
-	
-	/*!
-	 *
-	 * \brief Ferme un socket.
-	 * \param sock Le socket Ă  fermer.
-	 *
-	 */
-	void close_serveur(int sock);
+    /*!
+     *
+     * \brief Crée simplement un socket.
+     * \param port Le port du socket.
+     * \return Un entier indiquand si la création s'est bien passée.
+     *
+     */
+    int createSock(u_short port);
+    
+    /*!
+     *
+     * \brief Ferme un socket.
+     * \param sock Le socket Ă  fermer.
+     *
+     */
+    void close_serveur(int sock);
 
 
 

          
@@ 347,78 347,78 @@ class Serveur : public Threads {
 
 
 
-	private:
-	/*!
-	 *
-	 * \brief Constructeur du serveur principal.
-	 * \param portServeurPartie Port d'attente des serveurs de partie.
-	 * \param portLecture Port d'attente des clients.
-	 * \param portEcouteClientServeurPartie Port d'ecoute des clients des serveurs de partie.
-	 * \param portLectureServeurPartie Port de lecture des messages des serveurs de partie.
-	 * \param portEcouteServeurPartie Port d'ecoute du serveur de partie distant.
-	 *
-	 * On empĂªche la crĂ©ation directe d'objets Singleton en mettant son constructeur par dĂ©faut privĂ©.
-	 * Ainsi on oblige l'utilisateur Ă  passer par GetInstance.
-	 *
-	 */
-	Serveur(u_short portServeurPartie, u_short portLecture, u_short portLectureServeurPartie,
-			u_short portEcouteClientServeurPartie, u_short portEcouteServeurPartie);
+    private:
+    /*!
+     *
+     * \brief Constructeur du serveur principal.
+     * \param portServeurPartie Port d'attente des serveurs de partie.
+     * \param portLecture Port d'attente des clients.
+     * \param portEcouteClientServeurPartie Port d'ecoute des clients des serveurs de partie.
+     * \param portLectureServeurPartie Port de lecture des messages des serveurs de partie.
+     * \param portEcouteServeurPartie Port d'ecoute du serveur de partie distant.
+     *
+     * On empĂªche la crĂ©ation directe d'objets Singleton en mettant son constructeur par dĂ©faut privĂ©.
+     * Ainsi on oblige l'utilisateur Ă  passer par GetInstance.
+     *
+     */
+    Serveur(u_short portServeurPartie, u_short portLecture, u_short portLectureServeurPartie,
+            u_short portEcouteClientServeurPartie, u_short portEcouteServeurPartie);
 
-	/*!
-	 *
-	 * \brief Destructeur.
-	 *
-	 * On empĂªche la destruction directe d'objets Singleton en mettant son destructeur par dĂ©faut privĂ©.
-	 *
-	 */
-	~Serveur();
+    /*!
+     *
+     * \brief Destructeur.
+     *
+     * On empĂªche la destruction directe d'objets Singleton en mettant son destructeur par dĂ©faut privĂ©.
+     *
+     */
+    ~Serveur();
 
-	/*!
-	 *
-	 * \brief On empĂªche la recopie d'objets Singleton en mettant le constructeur par copie en privĂ©.
-	 *
-	 * On peut mĂªme ne pas l'implĂ©menter, c'est encore mieux.
-	 *
-	 */
-	Serveur(const Serveur&);
-	
-	/*!
-	 *
-	 * \brief On empĂªche l'affectation d'objets Singleton en mettant l'opĂ©rateur d'affectation en privĂ©.
-	 *
-	 * On peut mĂªme ne pas l'implĂ©menter, c'est encore mieux.
-	 *
-	 */
-  	const Serveur& operator=(const Serveur&);
+    /*!
+     *
+     * \brief On empĂªche la recopie d'objets Singleton en mettant le constructeur par copie en privĂ©.
+     *
+     * On peut mĂªme ne pas l'implĂ©menter, c'est encore mieux.
+     *
+     */
+    Serveur(const Serveur&);
+    
+    /*!
+     *
+     * \brief On empĂªche l'affectation d'objets Singleton en mettant l'opĂ©rateur d'affectation en privĂ©.
+     *
+     * On peut mĂªme ne pas l'implĂ©menter, c'est encore mieux.
+     *
+     */
+      const Serveur& operator=(const Serveur&);
 
 
-	static Serveur * _singleton; /*!< Objet singleton Serveur. */
+    static Serveur * _singleton; /*!< Objet singleton Serveur. */
 
 
 
 
-	list<Partie> gameList; /*!< Liste des parties. */
+    list<Partie> gameList; /*!< Liste des parties. */
 
-	int numberOfGame; /*!< Nombre de partie. */
-	int maxGame; /*!< Nombre de partie maximales. */
+    int numberOfGame; /*!< Nombre de partie. */
+    int maxGame; /*!< Nombre de partie maximales. */
 
-	u_short portServeurPartie; /*!< Port d'écoute de nouveaux serveurs de parties. */
-	u_short portClient; /*!< Port d'écoute de nouveaux clients. */
+    u_short portServeurPartie; /*!< Port d'écoute de nouveaux serveurs de parties. */
+    u_short portClient; /*!< Port d'écoute de nouveaux clients. */
 
-	u_short portEcouteServeurPartie; /*!< Port d'écoute du serveur de partie distant */
-	u_short portEcouteClientServeurPartie; /*!< Port d'écoute des nouveaux clients du serveur de partie distant */
+    u_short portEcouteServeurPartie; /*!< Port d'écoute du serveur de partie distant */
+    u_short portEcouteClientServeurPartie; /*!< Port d'écoute des nouveaux clients du serveur de partie distant */
 
-	u_short portLectureServeurPartie; /*!< Port d'écoute du serveur. */
-	u_short portEcriture; /*!< Port d'écriture du serveur. */
+    u_short portLectureServeurPartie; /*!< Port d'écoute du serveur. */
+    u_short portEcriture; /*!< Port d'écriture du serveur. */
 
-	int sockServeurPartie;
-	int sockClient;
-	int sockLectureServeurPartie; 
-	int sockEcriture;
-	int msgsock;
-	int msg_sockServeurPartie;
-	int msg_sockClient;
-	int msg_sockLectureServeurPartie;
+    int sockServeurPartie;
+    int sockClient;
+    int sockLectureServeurPartie;
+    int sockEcriture;
+    int msgsock;
+    int msg_sockServeurPartie;
+    int msg_sockClient;
+    int msg_sockLectureServeurPartie;
 };
 
 #endif /*SERVEUR_H_*/

          
M serveurPrincipal/threads.h +246 -246
@@ 15,85 15,85 @@ using namespace std;
  */
 class Threads
 {
-	private:
-		pthread_t threadEcouteNouveauServeurPartie; /*!< Thread d'ecoute de nouveaux serveur de partie */
-		pthread_t threadTraiteNouveauServeurPartie; /*!< Thread traitant les nouveaux serveurs de partie */
+    private:
+        pthread_t threadEcouteNouveauServeurPartie; /*!< Thread d'ecoute de nouveaux serveur de partie */
+        pthread_t threadTraiteNouveauServeurPartie; /*!< Thread traitant les nouveaux serveurs de partie */
 
-		pthread_t threadEcouteNouveauClient; /*!< Thread d'ecoute de nouveaux clients */
-		pthread_t threadTraiteNouveauClient; /*!< Thread traitant les nouveaux clients */
+        pthread_t threadEcouteNouveauClient; /*!< Thread d'ecoute de nouveaux clients */
+        pthread_t threadTraiteNouveauClient; /*!< Thread traitant les nouveaux clients */
 
-		pthread_t threadLectureServeurPartie; /*!< Thread de lecture des serveurs de partie */
-		pthread_t threadTraiteServeurPartie; /*!< Thread de traitement des messages des serveurs de partie */
+        pthread_t threadLectureServeurPartie; /*!< Thread de lecture des serveurs de partie */
+        pthread_t threadTraiteServeurPartie; /*!< Thread de traitement des messages des serveurs de partie */
 
-		pthread_t threadTestServeurPartie; /*!< Thread testant la présence des serveurs de partie */
+        pthread_t threadTestServeurPartie; /*!< Thread testant la présence des serveurs de partie */
 
-		pthread_t threadJeton; /*!< Thread envoyant le nouveau jeton aux serveurs de partie */
+        pthread_t threadJeton; /*!< Thread envoyant le nouveau jeton aux serveurs de partie */
 
 
 
 
-	public:
-		Threads() {}
+    public:
+        Threads() {}
 
-		/*!
-		 *
-		 * Initialisation du Thread d'Ecoute de nouveau serveur de partie
-		 *
-		 */
-		pthread_t * initAttendServeurPartie()
-		{	
-			/* Initialise les attributs du threads */
-			pthread_attr_t attr;
-			pthread_attr_init(&attr);
-			pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
+        /*!
+         *
+         * Initialisation du Thread d'Ecoute de nouveau serveur de partie
+         *
+         */
+        pthread_t * initAttendServeurPartie()
+        {
+            /* Initialise les attributs du threads */
+            pthread_attr_t attr;
+            pthread_attr_init(&attr);
+            pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
 
-			if( ! (pthread_create(&(this->threadEcouteNouveauServeurPartie), &attr, Threads::demarrerEcouteServeurPartie, static_cast<void *>(this))) )
-			{
-				printf("Creation du thread d'ecoute des serveurs de parties arrivants\n");
-				return &(this->threadEcouteNouveauServeurPartie);
-			}
-			else
-			{
-				printf("Echec de la creation du thread d'ecoute des serveurs de parties arrivants\n");
-				exit(0);
-			}
-		}
-		static void * demarrerEcouteServeurPartie(void * thread)
-		{
-			static_cast<Threads *>(thread)->traitementEcouteServeurPartie();
-			pthread_exit(NULL);
-		}
+            if( ! (pthread_create(&(this->threadEcouteNouveauServeurPartie), &attr, Threads::demarrerEcouteServeurPartie, static_cast<void *>(this))) )
+            {
+                printf("Creation du thread d'ecoute des serveurs de parties arrivants\n");
+                return &(this->threadEcouteNouveauServeurPartie);
+            }
+            else
+            {
+                printf("Echec de la creation du thread d'ecoute des serveurs de parties arrivants\n");
+                exit(0);
+            }
+        }
+        static void * demarrerEcouteServeurPartie(void * thread)
+        {
+            static_cast<Threads *>(thread)->traitementEcouteServeurPartie();
+            pthread_exit(NULL);
+        }
 
-		virtual void traitementEcouteServeurPartie() = 0;		
-		/*!
-		 *
-		 * Initialisation du Thread de traitement des nouveaux serveurs de partie.
-		 *
-		 */
-		pthread_t * initNouveauServeurPartie()
-		{
-			/* Initialise les attributs du threads */
-			pthread_attr_t attr;
-			pthread_attr_init(&attr);
-			pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
+        virtual void traitementEcouteServeurPartie() = 0;
+        /*!
+         *
+         * Initialisation du Thread de traitement des nouveaux serveurs de partie.
+         *
+         */
+        pthread_t * initNouveauServeurPartie()
+        {
+            /* Initialise les attributs du threads */
+            pthread_attr_t attr;
+            pthread_attr_init(&attr);
+            pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
 
-			if( ! (pthread_create(&(this->threadTraiteNouveauServeurPartie), &attr, Threads::demarrerServeurPartie, static_cast<void *>(this))) )
-			{
-				printf("Creation du thread temporaire de traitement des nouveaux serveurs de partie\n");
-				return &(this->threadTraiteNouveauServeurPartie);
-			}
-			else
-			{
-				printf("Echec de la creation du thread temporaire de traitement des nouveaux serveurs de partie\n");
-				exit(0);
-			}
-		}
-		static void * demarrerServeurPartie(void * thread)
-		{
-			static_cast<Threads *>(thread)->traitementNouveauServeurPartie();
-			pthread_exit(NULL);
-		}
-		virtual void traitementNouveauServeurPartie() = 0;
+            if( ! (pthread_create(&(this->threadTraiteNouveauServeurPartie), &attr, Threads::demarrerServeurPartie, static_cast<void *>(this))) )
+            {
+                printf("Creation du thread temporaire de traitement des nouveaux serveurs de partie\n");
+                return &(this->threadTraiteNouveauServeurPartie);
+            }
+            else
+            {
+                printf("Echec de la creation du thread temporaire de traitement des nouveaux serveurs de partie\n");
+                exit(0);
+            }
+        }
+        static void * demarrerServeurPartie(void * thread)
+        {
+            static_cast<Threads *>(thread)->traitementNouveauServeurPartie();
+            pthread_exit(NULL);
+        }
+        virtual void traitementNouveauServeurPartie() = 0;
 
 
 

          
@@ 101,168 101,168 @@ class Threads
 
 
 
-	
-		/*!
-		 *
-		 * Initialisation du Thread d'écoute de nouveaux clients.
-		 *
-		 */
-		pthread_t * initAttendClient()
-		{	
-			/* Initialise les attributs du threads */
-			pthread_attr_t attr;
-			pthread_attr_init(&attr);
-			pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
+    
+        /*!
+         *
+         * Initialisation du Thread d'écoute de nouveaux clients.
+         *
+         */
+        pthread_t * initAttendClient()
+        {
+            /* Initialise les attributs du threads */
+            pthread_attr_t attr;
+            pthread_attr_init(&attr);
+            pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
 
-			if( ! (pthread_create(&(this->threadEcouteNouveauClient), &attr, Threads::demarrerEcouteClient, static_cast<void *>(this))) )
-			{
-				printf("Creation du thread d'ecoute de nouveaux clients\n");
-				return &(this->threadEcouteNouveauClient);
-			}
-			else
-			{
-				printf("Echec de la creation du thread d'ecoute de nouveaux clients\n");
-				exit(0);
-			}
-		}
-		static void * demarrerEcouteClient(void * thread)
-		{
-			static_cast<Threads *>(thread)->traitementEcouteClient();
-			pthread_exit(NULL);
-		}
+            if( ! (pthread_create(&(this->threadEcouteNouveauClient), &attr, Threads::demarrerEcouteClient, static_cast<void *>(this))) )
+            {
+                printf("Creation du thread d'ecoute de nouveaux clients\n");
+                return &(this->threadEcouteNouveauClient);
+            }
+            else
+            {
+                printf("Echec de la creation du thread d'ecoute de nouveaux clients\n");
+                exit(0);
+            }
+        }
+        static void * demarrerEcouteClient(void * thread)
+        {
+            static_cast<Threads *>(thread)->traitementEcouteClient();
+            pthread_exit(NULL);
+        }
 
-		virtual void traitementEcouteClient() = 0;
-		/*!
-		 *
-		 * Initialisation du Thread de traitement de nouveaux clients.
-		 *
-		 */		
-		pthread_t * initNouveauClient()
-		{	
-			/* Initialise les attributs du threads */
-			pthread_attr_t attr;
-			pthread_attr_init(&attr);
-			pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
+        virtual void traitementEcouteClient() = 0;
+        /*!
+         *
+         * Initialisation du Thread de traitement de nouveaux clients.
+         *
+         */
+        pthread_t * initNouveauClient()
+        {
+            /* Initialise les attributs du threads */
+            pthread_attr_t attr;
+            pthread_attr_init(&attr);
+            pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
 
-			if( ! (pthread_create(&(this->threadTraiteNouveauClient), &attr, Threads::demarrerClient, static_cast<void *>(this))) )
-			{
-				printf("Creation du thread temporaire de traitement de nouveaux clients\n");
-				return &(this->threadTraiteNouveauClient);
-			}
-			else
-			{
-				printf("Echec de la creation temporaire de traitement de nouveaux clients\n");
-				exit(0);
-			}
-		}
-		static void * demarrerClient(void * thread)
-		{
-			static_cast<Threads *>(thread)->traitementClient();
-			pthread_exit(NULL);
-		}
-		virtual void traitementClient() = 0;
+            if( ! (pthread_create(&(this->threadTraiteNouveauClient), &attr, Threads::demarrerClient, static_cast<void *>(this))) )
+            {
+                printf("Creation du thread temporaire de traitement de nouveaux clients\n");
+                return &(this->threadTraiteNouveauClient);
+            }
+            else
+            {
+                printf("Echec de la creation temporaire de traitement de nouveaux clients\n");
+                exit(0);
+            }
+        }
+        static void * demarrerClient(void * thread)
+        {
+            static_cast<Threads *>(thread)->traitementClient();
+            pthread_exit(NULL);
+        }
+        virtual void traitementClient() = 0;
 
-		
-		
+    
+    
 
 
 
 
-		
-		/*!
-		 *
-		 * Initialisation du Thread  de lecture des serveurs de partie.
-		 *
-		 */
-		pthread_t * initLectureServeurPartie()
-		{	
-			/* Initialise les attributs du threads */
-			pthread_attr_t attr;
-			pthread_attr_init(&attr);
-			pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
+    
+        /*!
+         *
+         * Initialisation du Thread  de lecture des serveurs de partie.
+         *
+         */
+        pthread_t * initLectureServeurPartie()
+        {
+            /* Initialise les attributs du threads */
+            pthread_attr_t attr;
+            pthread_attr_init(&attr);
+            pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
 
-			if( ! (pthread_create(&(this->threadLectureServeurPartie), &attr, Threads::demarrerLectureServeurPartie, static_cast<void *>(this))) )
-			{
-				printf("Creation du thread de lecture des serveurs de partie\n");
-				return &(this->threadLectureServeurPartie);
-			}
-			else
-			{
-				printf("Echec de la creation du thread de lecture des serveurs de partie\n");
-				exit(0);
-			}
-		}
-		static void * demarrerLectureServeurPartie(void * thread)
-		{
-			static_cast<Threads *>(thread)->traitementLectureServeurPartie();
-			pthread_exit(NULL);
-		}
-		virtual void traitementLectureServeurPartie() = 0;
-		/*!
-		 *
-		 * Initialisation du Thread de traitement des mesages des serveurs de partie.
-		 *
-		 */		
-		pthread_t * initTraiteServeurPartie()
-		{	
-			/* Initialise les attributs du threads */
-			pthread_attr_t attr;
-			pthread_attr_init(&attr);
-			pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
+            if( ! (pthread_create(&(this->threadLectureServeurPartie), &attr, Threads::demarrerLectureServeurPartie, static_cast<void *>(this))) )
+            {
+                printf("Creation du thread de lecture des serveurs de partie\n");
+                return &(this->threadLectureServeurPartie);
+            }
+            else
+            {
+                printf("Echec de la creation du thread de lecture des serveurs de partie\n");
+                exit(0);
+            }
+        }
+        static void * demarrerLectureServeurPartie(void * thread)
+        {
+            static_cast<Threads *>(thread)->traitementLectureServeurPartie();
+            pthread_exit(NULL);
+        }
+        virtual void traitementLectureServeurPartie() = 0;
+        /*!
+         *
+         * Initialisation du Thread de traitement des mesages des serveurs de partie.
+         *
+         */
+        pthread_t * initTraiteServeurPartie()
+        {
+            /* Initialise les attributs du threads */
+            pthread_attr_t attr;
+            pthread_attr_init(&attr);
+            pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
 
-			if( ! (pthread_create(&(this->threadTraiteServeurPartie), &attr, Threads::demarrerTraiteServeurPartie, static_cast<void *>(this))) )
-			{
-				printf("Creation du thread de traitement des mesages des serveurs de partie\n");
-				return &(this->threadTraiteServeurPartie);
-			}
-			else
-			{
-				printf("Echec de la creation de traitement des mesages des serveurs de partie\n");
-				exit(0);
-			}
-		}
-		static void * demarrerTraiteServeurPartie(void * thread)
-		{
-			static_cast<Threads *>(thread)->traitementServeurPartie();
-			pthread_exit(NULL);
-		}
-		virtual void traitementServeurPartie() = 0;
-		
-		
-		
-		
-		
-		
-		
-		/*!
-		 *
-		 * Initialisation du Thread de test de présence des serveurs de partie.
-		 *
-		 */		
-		pthread_t * initTestServeurPartie()
-		{	
-			/* Initialise les attributs du threads */
-			pthread_attr_t attr;
-			pthread_attr_init(&attr);
-			pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
+            if( ! (pthread_create(&(this->threadTraiteServeurPartie), &attr, Threads::demarrerTraiteServeurPartie, static_cast<void *>(this))) )
+            {
+                printf("Creation du thread de traitement des mesages des serveurs de partie\n");
+                return &(this->threadTraiteServeurPartie);
+            }
+            else
+            {
+                printf("Echec de la creation de traitement des mesages des serveurs de partie\n");
+                exit(0);
+            }
+        }
+        static void * demarrerTraiteServeurPartie(void * thread)
+        {
+            static_cast<Threads *>(thread)->traitementServeurPartie();
+            pthread_exit(NULL);
+        }
+        virtual void traitementServeurPartie() = 0;
+    
+    
+    
+    
+    
+    
+    
+        /*!
+         *
+         * Initialisation du Thread de test de présence des serveurs de partie.
+         *
+         */
+        pthread_t * initTestServeurPartie()
+        {
+            /* Initialise les attributs du threads */
+            pthread_attr_t attr;
+            pthread_attr_init(&attr);
+            pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
 
-			if( ! (pthread_create(&(this->threadTestServeurPartie), &attr, Threads::demarrerTestServeurPartie, static_cast<void *>(this))) )
-			{
-				printf("Creation du thread de test de presence des serveurs de partie.\n");
-				return &(this->threadTestServeurPartie);
-			}
-			else
-			{
-				printf("Echec de la creation du thread de test de presence des serveurs de partie.\n");
-				exit(0);
-			}
-		}
-		static void * demarrerTestServeurPartie(void * thread)
-		{
-			static_cast<Threads *>(thread)->traitementTestServeurPartie();
-			pthread_exit(NULL);
-		}
-		virtual void traitementTestServeurPartie() = 0;
+            if( ! (pthread_create(&(this->threadTestServeurPartie), &attr, Threads::demarrerTestServeurPartie, static_cast<void *>(this))) )
+            {
+                printf("Creation du thread de test de presence des serveurs de partie.\n");
+                return &(this->threadTestServeurPartie);
+            }
+            else
+            {
+                printf("Echec de la creation du thread de test de presence des serveurs de partie.\n");
+                exit(0);
+            }
+        }
+        static void * demarrerTestServeurPartie(void * thread)
+        {
+            static_cast<Threads *>(thread)->traitementTestServeurPartie();
+            pthread_exit(NULL);
+        }
+        virtual void traitementTestServeurPartie() = 0;
 
 
 

          
@@ 271,34 271,34 @@ class Threads
 
 
 
-		/*!
-		 *
-		 * Initialisation du Thread d'envoie du jeton aux serveurs de partie.
-		 *
-		 */		
-		pthread_t * initJeton()
-		{	
-			/* Initialise les attributs du threads */
-			pthread_attr_t attr;
-			pthread_attr_init(&attr);
-			pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
+        /*!
+         *
+         * Initialisation du Thread d'envoie du jeton aux serveurs de partie.
+         *
+         */
+        pthread_t * initJeton()
+        {
+            /* Initialise les attributs du threads */
+            pthread_attr_t attr;
+            pthread_attr_init(&attr);
+            pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
 
-			if( ! (pthread_create(&(this->threadJeton), &attr, Threads::demarrerJeton, static_cast<void *>(this))) )
-			{
-				printf("Creation du thread d'envoie du jeton aux serveurs de partie.\n");
-				return &(this->threadJeton);
-			}
-			else
-			{
-				printf("Echec de la creation du thread d'envoie du jeton aux serveurs de partie.\n");
-				exit(0);
-			}
-		}
-		static void * demarrerJeton(void * thread)
-		{
-			static_cast<Threads *>(thread)->traitementJeton();
-			pthread_exit(NULL);
-		}
-		virtual void traitementJeton() = 0;
+            if( ! (pthread_create(&(this->threadJeton), &attr, Threads::demarrerJeton, static_cast<void *>(this))) )
+            {
+                printf("Creation du thread d'envoie du jeton aux serveurs de partie.\n");
+                return &(this->threadJeton);
+            }
+            else
+            {
+                printf("Echec de la creation du thread d'envoie du jeton aux serveurs de partie.\n");
+                exit(0);
+            }
+        }
+        static void * demarrerJeton(void * thread)
+        {
+            static_cast<Threads *>(thread)->traitementJeton();
+            pthread_exit(NULL);
+        }
+        virtual void traitementJeton() = 0;
 };
 #endif /*THREADS_H_*/