TraitementJoueur Class Reference

Implémentation d'un thread de traitement des clients du serveur de jeu. More...

#include <TraitementJoueur.h>

Inheritance diagram for TraitementJoueur:

Inheritance graph
[legend]
Collaboration diagram for TraitementJoueur:

Collaboration graph
[legend]
List of all members.

Public Member Functions

 TraitementJoueur (Socket *s, bool hotplug=false)
 Constructeur de la classe.
 ~TraitementJoueur ()
void * Traitement ()
 On attend l'initialisation du protocole, le login, le choix du rôle puis les autres joueurs.
void ModeZombie ()
 Méthode permettant de mettre le thread à l'état de Zombie, en cas de déconnexion du client que l'on traite:
Il stoppe alors tout traitement et attend simplement d'être tué par le serveur de jeu.
bool IsZombie ()
 Permet de savoir si le thread est passé en mode Zombie.

Private Member Functions

bool WaitForHello ()
 On attend l'initialisation du protocole.
string WaitForLogin ()
 On attend que le client nous donne son login.
bool WaitForRole ()
 On transmets les places disponibles et on attend que le client nous donne le role qu'il veut joueur.
bool WaitForPlayers ()
 On attend que tous les joueurs soient connecté.
bool TraitementDeplacement ()
 On traite les déplacements du client ou les demandes de la grille.
void DeplacementAuto ()
 On déplace automatique le joueur.

Private Attributes

Socket * mSocket
 Pointeur sur la socket NULL si un joueur humain.
Jeu * mJeu
 Pointeur sur le singleton gérant la partie.
Mutex mVerrou
 Sémaphore d'exclusion mutuelle.
unsigned int mIdJoueur
 Code du personnage géré par le thread.
string mLogin
 Login du joueur géré par le thread.
bool mZombie
 Vrai si le thread est à l'état de Zombie.
bool mHotPlug
 Vrai si le thread est créé pour remplacer un joueur déconnecté.

Detailed Description

Implémentation d'un thread de traitement des clients du serveur de jeu.

Definition at line 40 of file TraitementJoueur.h.

Constructor & Destructor Documentation

TraitementJoueur::TraitementJoueur ( Socket *  s,
bool  hotplug = false 
)

Constructeur de la classe.

Parameters:
s Pointeur sur une socket pour un joueur humain ou NULL pour un traitement automatique.
hotplug Vrai si le thread est créé afin de remplacer un joueur déconnecté.
Returns:

Definition at line 23 of file TraitementJoueur.cpp.

References Singleton< T >::GetInstance(), mHotPlug, mIdJoueur, mJeu, mLogin, mSocket, and mZombie.

00023                                                           : Thread(){
00024         mHotPlug=hotplug;
00025         if(s==NULL){
00026                 if(!mHotPlug){
00027                         cout<<"      SJ TraitementJoueur::Création d'un thread pour gérer un fantome automatique"<<endl;
00028                         mLogin="auto";
00029                 } else {
00030                         cout<<"      SJ TraitementJoueur::Création d'un thread pour remplacer un joueur déconnecté"<<endl;
00031                         mLogin="hotplug";
00032                 }
00033 
00034         } else {
00035                 cout<<"      SJ TraitementJoueur::Création d'un thread pour traiter le client"<<endl;
00036                 mLogin="";
00037         }
00038         mJeu=Jeu::GetInstance();
00039         mSocket=s;
00040         mZombie=false;
00041         mIdJoueur=-1;
00042 }

Here is the call graph for this function:

TraitementJoueur::~TraitementJoueur (  ) 

Definition at line 44 of file TraitementJoueur.cpp.

References mLogin, and mSocket.

00044                                    {
00045         cout<<"      SJ TraitementJoueur::Destruction du thread de traitement du joueur "<<mLogin<<endl;
00046         if(mSocket!=NULL) delete mSocket;
00047 }

Member Function Documentation

void * TraitementJoueur::Traitement (  )  [virtual]

On attend l'initialisation du protocole, le login, le choix du rôle puis les autres joueurs.


On traite alors les demandes de déplacement ou de grille si le joueur est humain.
Sinon on déplacement automatiquement le personnage toutes les secondes.

Returns:

Implements Thread.

Definition at line 49 of file TraitementJoueur.cpp.

References DeplacementAuto(), Jeu::JoueurConnectes(), Mutex::Lock(), mHotPlug, mIdJoueur, mJeu, mLogin, mSocket, mVerrou, Jeu::SetJoueur(), TraitementDeplacement(), Mutex::Unlock(), WaitForHello(), WaitForLogin(), WaitForPlayers(), and WaitForRole().

00049                                   {
00050         if(mSocket!=NULL){
00051                 //On traite un joueur distant
00052                 if(!WaitForHello()) return NULL;
00053                 mLogin=WaitForLogin();
00054                 if(mLogin=="ERROR") return NULL;
00055                 if(!WaitForRole()) return NULL;
00056                 if(!WaitForPlayers()) return NULL;
00057                 if(!TraitementDeplacement()) return NULL;
00058                 cout<<"      SJ TraitementJoueur::Fin du traitement de "<<mLogin<<endl;
00059         } else {        
00060                 mVerrou.Lock();
00061                 string place=mJeu->JoueurConnectes();
00062                 if(!mHotPlug){
00063                         //On simule un fantome 
00064                         for(unsigned int i=0; i<3; i++){
00065                                 if(place[i]=='0'){
00066                                         mJeu->SetJoueur(i,"auto");
00067                                         mIdJoueur=i;
00068                                         break;
00069                                 }
00070                         }
00071                         mVerrou.Unlock();
00072                         WaitForPlayers();
00073                         DeplacementAuto();
00074                         cout<<"      SJ TraitementJoueur::Fin du traitement du fantome automatique "<<mIdJoueur<<endl;
00075                 } else {
00076                         //On remplace un joueur à chaud
00077                         for(unsigned int i=0; i<4; i++){
00078                                 if(place[i]=='0'){
00079                                         mJeu->SetJoueur(i,"hotplug");
00080                                         mIdJoueur=i;
00081                                         break;
00082                                 }
00083                         }
00084                         mVerrou.Unlock();
00085                         DeplacementAuto();
00086                         cout<<"      SJ TraitementJoueur::Fin du traitement du joueur automatique de remplacement "<<mIdJoueur<<endl;           
00087                 }
00088         }
00089         return NULL;
00090 }

Here is the call graph for this function:

void TraitementJoueur::ModeZombie (  ) 

Méthode permettant de mettre le thread à l'état de Zombie, en cas de déconnexion du client que l'on traite:
Il stoppe alors tout traitement et attend simplement d'être tué par le serveur de jeu.


Cela permet au serveur de jeu d'avoir le temps de détecter le problème et de le gérer.

Definition at line 92 of file TraitementJoueur.cpp.

References mIdJoueur, mJeu, mZombie, and Jeu::UnSetJoueur().

Referenced by TraitementDeplacement(), WaitForHello(), WaitForLogin(), WaitForPlayers(), and WaitForRole().

00092                                  {
00093         cout<<"      SJ TraitementJoueur::Passé en mode "; printf( "\e[31mZombie\e[m\n" );
00094         if(mIdJoueur!=-1) mJeu->UnSetJoueur(mIdJoueur);
00095         mZombie=true;
00096         while(1) sleep(1);
00097 }

Here is the call graph for this function:

bool TraitementJoueur::IsZombie (  )  [inline]

Permet de savoir si le thread est passé en mode Zombie.

Returns:
Vrai si le thread est en mode Zombie

Definition at line 70 of file TraitementJoueur.h.

References mZombie.

00070 { return mZombie; }

bool TraitementJoueur::WaitForHello (  )  [private]

On attend l'initialisation du protocole.

Returns:
Faux en cas de déconnexion du client.

Definition at line 98 of file TraitementJoueur.cpp.

References Socket::Ecouter(), Socket::Envoyer(), ModeZombie(), and mSocket.

Referenced by Traitement().

00098                                    {
00099         //1 On attent que le client nous dise bonjour 
00100         cout<<"      SJ TraitementJoueur::Attente de l'initiation du protocole de la part du client";
00101         try{
00102                 while(mSocket->Ecouter()!="HELLO"){
00103                         mSocket->Envoyer("ERROR HELLO");
00104                 }
00105                 mSocket->Envoyer("HELLO");
00106                 //cout<<"  SJ Protocole initialisé"<<endl;
00107                 printf("\e[32m [OK]\e[m\n");
00108         } catch(SocketException s){
00109                 cout<<"      SJ TraitementJoueur::"; printf( "\e[31m[Erreur] \e[m"); cout<<"Déconnexion du client: le thread passe en mode "; printf( "\e[31mZombie\e[m\n" );
00110                 ModeZombie();
00111                 return false;
00112         }
00113         return true;
00114 }

Here is the call graph for this function:

string TraitementJoueur::WaitForLogin (  )  [private]

On attend que le client nous donne son login.

Returns:
Le login du client ou "erreur" en cas de déconnexion du client.

Definition at line 117 of file TraitementJoueur.cpp.

References Socket::Ecouter(), Socket::Envoyer(), ModeZombie(), and mSocket.

Referenced by Traitement().

00117                                      {
00118         //2 Le client doit se logger 
00119         string line,cmd;
00120         do{
00121                 try{
00122                         line=mSocket->Ecouter();
00123                         string login;
00124                         istringstream iss(line);
00125                         getline(iss,cmd,' '); 
00126                         if(cmd=="LOGIN"){
00127                                 getline(iss,login,' ');
00128                                 cout<<"      SJ TraitementJoueur::Connexion de "<<login<<endl;
00129                                 mSocket->Envoyer("LOGIN OK");
00130                                 return login;
00131                         } else mSocket->Envoyer("ERROR LOGIN");
00132                 } catch(SocketException s){
00133                         cout<<"      SJ TraitementJoueur::"; printf( "\e[31m[Erreur] \e[m"); cout<<"Déconnexion du client: le thread passe en mode "; printf( "\e[31mZombie\e[m\n" );
00134                         ModeZombie();
00135                         return false;
00136                 }
00137         } while(1);
00138 }

Here is the call graph for this function:

bool TraitementJoueur::WaitForRole (  )  [private]

On transmets les places disponibles et on attend que le client nous donne le role qu'il veut joueur.

Returns:
Faux en cas de déconnexion du client.

Definition at line 140 of file TraitementJoueur.cpp.

References Socket::Ecouter(), Socket::Envoyer(), Jeu::JoueurConnectes(), Mutex::Lock(), mIdJoueur, mJeu, mLogin, ModeZombie(), mSocket, mVerrou, Jeu::SetJoueur(), and Mutex::Unlock().

Referenced by Traitement().

00140                                   {
00141         mVerrou.Lock();
00142         cout<<"      SJ TraitementJoueur::Envoi des places restantes"<<endl;
00143         //3 On recherche les places encore libres et on les envoie au client
00144         string place=mJeu->JoueurConnectes();
00145         string reponse="BUSY ";
00146         reponse+=place;
00147         try{
00148                 mSocket->Envoyer(reponse);
00149                 cout<<"      SJ TraitementJoueur::Attente du rôle"<<endl;
00150                 bool stop=false;
00151                 //4 On attend que le client nous envoie le rôle qu'il veut jouer
00152                 do{
00153                         string line=mSocket->Ecouter();
00154                         string cmd,role;
00155                         istringstream iss(line);
00156                         getline(iss,cmd,' '); 
00157                         if(cmd=="GET"){
00158                                 getline(iss,role,' ');
00159                                 reponse="SET "; reponse+=mLogin; reponse+=" "; reponse+=role;
00160                                 if(role=="PACMAN"){
00161                                         if(place[3]=='0'){
00162                                                 stop=true;
00163                                                 mIdJoueur=3;
00164                                                 mJeu->SetJoueur(mIdJoueur,mLogin);
00165                                                 mSocket->Envoyer(reponse);
00166                                                 cout<<"      SJ TraitementJoueur::Attente du rôle"; printf("\e[32m [OK]\e[m\n");
00167                                         } else  mSocket->Envoyer("ERROR GET ROLE");
00168                                 } else if(role=="F1"){
00169                                         if(place[0]=='0'){
00170                                                 stop=true;
00171                                                 mIdJoueur=0;
00172                                                 mJeu->SetJoueur(mIdJoueur,mLogin);
00173                                                 mSocket->Envoyer(reponse);
00174                                                 cout<<"      SJ TraitementJoueur::Attente du rôle"; printf("\e[32m [OK]\e[m\n");
00175                                         } else  mSocket->Envoyer("ERROR GET ROLE");
00176                                 } else if(role=="F2"){
00177                                         if(place[1]=='0'){
00178                                                 stop=true;
00179                                                 mIdJoueur=1;
00180                                                 mJeu->SetJoueur(mIdJoueur,mLogin);
00181                                                 mSocket->Envoyer(reponse);
00182                                                 cout<<"      SJ TraitementJoueur::Attente du rôle"; printf("\e[32m [OK]\e[m\n");
00183                                         } else  mSocket->Envoyer("ERROR GET ROLE");
00184                                 } else if(role=="F3"){
00185                                         if(place[2]=='0'){
00186                                                 stop=true;
00187                                                 mIdJoueur=2;
00188                                                 mJeu->SetJoueur(mIdJoueur,mLogin);
00189                                                 mSocket->Envoyer(reponse);
00190                                                 cout<<"      SJ TraitementJoueur::Attente du rôle"; printf("\e[32m [OK]\e[m\n");
00191                                         } else  mSocket->Envoyer("ERROR GET ROLE");
00192                                 } else mSocket->Envoyer("ERROR GET ROLE");
00193                         } else mSocket->Envoyer("ERROR GET ROLE");
00194                 } while(!stop);
00195                 mVerrou.Unlock();
00196         } catch(SocketException s){
00197                 cout<<"      SJ TraitementJoueur::"; printf( "\e[31m[Erreur] \e[m"); cout<<"Déconnexion du client: le thread passe en mode "; printf( "\e[31mZombie\e[m\n" );
00198                 ModeZombie();
00199                 return false;
00200         }
00201         return true;
00202 }

Here is the call graph for this function:

bool TraitementJoueur::WaitForPlayers (  )  [private]

On attend que tous les joueurs soient connecté.

Returns:
Faux en cas de déconnexion du client.

Definition at line 204 of file TraitementJoueur.cpp.

References Socket::Envoyer(), Jeu::JeuPret(), mIdJoueur, mJeu, mLogin, ModeZombie(), and mSocket.

Referenced by Traitement().

00204                                      {
00205         cout<<"      SJ TraitementJoueur::Attente des autres joueurs..."<<endl;
00206         while(!(mJeu->JeuPret())){
00207                 sleep(1);//pour le petit processeur...
00208         }
00209         cout<<"      SJ TraitementJoueur::"<<mLogin<<" "<<mIdJoueur<<" dit: Le jeu est prêt!!!"<<endl;
00210         try{
00211                 if(mSocket!=NULL) mSocket->Envoyer("READY");
00212         } catch(SocketException s){
00213                 cout<<"      SJ TraitementJoueur::"; printf( "\e[31m[Erreur] \e[m"); cout<<"Déconnexion du client: le thread passe en mode "; printf( "\e[31mZombie\e[m\n" );
00214                 ModeZombie();
00215         }
00216         return true;
00217 }

Here is the call graph for this function:

bool TraitementJoueur::TraitementDeplacement (  )  [private]

On traite les déplacements du client ou les demandes de la grille.

Returns:
Faux en cas de déconnexion du client.

Definition at line 219 of file TraitementJoueur.cpp.

References Jeu::DeplacerPersonnage(), Socket::Ecouter(), Socket::Envoyer(), Jeu::EtatPartie(), Jeu::GameOver(), mIdJoueur, mJeu, ModeZombie(), mSocket, and Jeu::toString().

Referenced by Traitement().

00219                                             {
00220         while(!mJeu->GameOver()){
00221                 try{
00222                         string line=mSocket->Ecouter();
00223                         //On envoie la grille 
00224                         if(line=="GRID") {
00225                                 string res=mJeu->EtatPartie(); res+=" ";
00226                                 res+=mJeu->toString(); res+=" ";
00227                                 mSocket->Envoyer(res);
00228                         }
00229                         //On attend le déplacement 
00230                         if((line=="HAUT")||(line=="BAS")||(line=="GAUCHE")||(line=="DROITE")){
00231                                 if(mJeu->DeplacerPersonnage(mIdJoueur,line[0])) mSocket->Envoyer("MOVE OK");
00232                                 else mSocket->Envoyer("MOVE BAD");
00233                         } else mSocket->Envoyer("MOVE BAD");
00234                 } catch(SocketException s){
00235                         cout<<"      SJ TraitementJoueur::"; printf( "\e[31m[Erreur] \e[m"); cout<<"Déconnexion du client: le thread passe en mode "; printf( "\e[31mZombie\e[m\n" );
00236                         ModeZombie();
00237                 }
00238         }
00239         return true;
00240 }

Here is the call graph for this function:

void TraitementJoueur::DeplacementAuto (  )  [private]

On déplace automatique le joueur.

Definition at line 242 of file TraitementJoueur.cpp.

References Jeu::DeplacerPersonnage(), Jeu::GameOver(), mIdJoueur, mJeu, and Jeu::UintAleat().

Referenced by Traitement().

00242                                       {
00243         cout<<"      SJ TraitementJoueur::Démarrage du déplacement automatique du personnage "<<mIdJoueur<<endl;
00244         bool deplacementOk=false;
00245         char c;
00246         while(!mJeu->GameOver()){
00247                 if(deplacementOk){
00248                         //On continue dans la même direction 
00249                         deplacementOk=mJeu->DeplacerPersonnage(mIdJoueur,c);
00250                 } else {
00251                         switch(mJeu->UintAleat(1,4)){
00252                                 case 1 : {
00253                                         deplacementOk=mJeu->DeplacerPersonnage(mIdJoueur,'H'); c='H';
00254                                         break;
00255                                 }
00256                                 case 2 : {
00257                                         deplacementOk=mJeu->DeplacerPersonnage(mIdJoueur,'B'); c='B';
00258                                         break;
00259                                 }
00260                                 case 3 : {
00261                                         deplacementOk=mJeu->DeplacerPersonnage(mIdJoueur,'G'); c='G';
00262                                         break;
00263                                 }
00264                                 case 4 : {
00265                                         deplacementOk=mJeu->DeplacerPersonnage(mIdJoueur,'D'); c='D';
00266                                         break;
00267                                 }
00268                         }
00269                 }
00270                 sleep(1);
00271         }
00272 }

Here is the call graph for this function:

Member Data Documentation

Socket* TraitementJoueur::mSocket [private]

Pointeur sur la socket NULL si un joueur humain.

Definition at line 110 of file TraitementJoueur.h.

Referenced by Traitement(), TraitementDeplacement(), TraitementJoueur(), WaitForHello(), WaitForLogin(), WaitForPlayers(), WaitForRole(), and ~TraitementJoueur().

Jeu* TraitementJoueur::mJeu [private]

Pointeur sur le singleton gérant la partie.

Definition at line 115 of file TraitementJoueur.h.

Referenced by DeplacementAuto(), ModeZombie(), Traitement(), TraitementDeplacement(), TraitementJoueur(), WaitForPlayers(), and WaitForRole().

Mutex TraitementJoueur::mVerrou [private]

Sémaphore d'exclusion mutuelle.

Definition at line 120 of file TraitementJoueur.h.

Referenced by Traitement(), and WaitForRole().

unsigned int TraitementJoueur::mIdJoueur [private]

Code du personnage géré par le thread.

Definition at line 125 of file TraitementJoueur.h.

Referenced by DeplacementAuto(), ModeZombie(), Traitement(), TraitementDeplacement(), TraitementJoueur(), WaitForPlayers(), and WaitForRole().

string TraitementJoueur::mLogin [private]

Login du joueur géré par le thread.

Definition at line 130 of file TraitementJoueur.h.

Referenced by Traitement(), TraitementJoueur(), WaitForPlayers(), WaitForRole(), and ~TraitementJoueur().

bool TraitementJoueur::mZombie [private]

Vrai si le thread est à l'état de Zombie.

Definition at line 135 of file TraitementJoueur.h.

Referenced by IsZombie(), ModeZombie(), and TraitementJoueur().

bool TraitementJoueur::mHotPlug [private]

Vrai si le thread est créé pour remplacer un joueur déconnecté.

Definition at line 140 of file TraitementJoueur.h.

Referenced by Traitement(), and TraitementJoueur().

The documentation for this class was generated from the following files:
Generated on Wed Jan 2 14:02:25 2008 for Pacman by  doxygen 1.5.1