Pacman: ServeurJeu Class Reference

ServeurJeu::ServeurJeu	(	unsigned int	port,
		unsigned int	nbFantomeAuto = `0`
	)			`[inline]`

Classe permettant de démarrer un serveur de jeu.

Parameters:

	port	Le port TCP à utiliser pour les clients, et UDP pour le serveur.
	nbFantomeAuto	Le nombre de fantomes automatiques pour la partie.

Returns:

Definition at line 45 of file ServeurJeu.h.

References Singleton< T >::GetInstance(), Jeu::GetNbFantomeAuto(), mJeu, mNbFantomeAuto, mPort, Jeu::SetNbFantomeAuto(), and Traitement().

00045                                                                    {
00046                 mJeu=Jeu::GetInstance();
00047                 mPort=port; mNbFantomeAuto=nbFantomeAuto;
00048                 mJeu->SetNbFantomeAuto(nbFantomeAuto);
00049                 cout<<endl<<"    SJ ServeurJeu::Création d'un serveur de jeu sur le port "<<port<<" avec "<<mJeu->GetNbFantomeAuto()<<" fantomes automatiques"<<endl;
00050                 Traitement();
00051         }

Here is the call graph for this function:

ServeurJeu::~ServeurJeu ( ) [inline]

Definition at line 53 of file ServeurJeu.h.

References Singleton< T >::KillInstance(), mServeurPrincipal, mSocketEcoute, and mTJ.

00053                      { 
00054                 cout<<"    SJ ServeurJeu::Destruction du serveur de jeu"<<endl;
00055                 cout<<"      SJ ServeurJeu::Destruction de la socket d'écoute"<<endl;
00056                 if(mSocketEcoute!=NULL) delete mSocketEcoute; 
00057                 cout<<"      SJ ServeurJeu::Destruction des threads de traitement des clients"<<endl;
00058                 for(int i=0; i<4; i++){
00059                         if(mTJ[i]!=NULL) delete mTJ[i]; 
00060                 }
00061                 if(mServeurPrincipal!=NULL) delete mServeurPrincipal;
00062                 Jeu::KillInstance(); 
00063         }

Here is the call graph for this function:

void ServeurJeu::Traitement ( ) [inline, private]

On créé la socket d'écoute TCP, on démarre les thread traitant les fantomes automatiques, on créé une socket de communication UDP avec le serveur puis on traite les clients qui se connecte.

Definition at line 70 of file ServeurJeu.h.

References AttendreClient(), AttendreDebutPartie(), AttendreFinPartie(), CreationSocketEcoute(), CreationThreadComServeurPrincipal(), and DemarrerFantomeAuto().

Referenced by ServeurJeu().

00070                          {
00071                 if(!CreationSocketEcoute()){
00072                         cout<<"    SJ ServeurJeu::"; printf( "\e[31m[Erreur Fatale]\e[m\n" );
00073                         exit(-1);
00074                 }
00075                 DemarrerFantomeAuto();
00076                 CreationThreadComServeurPrincipal();
00077                 do{
00078                         if(!AttendreClient()){
00079                                 cout<<"    SJ ServeurJeu::"; printf( "\e[31m[Erreur Fatale]\e[m\n" );
00080                                 exit(-1);
00081                         }
00082                 } while(!AttendreDebutPartie());
00083                 AttendreFinPartie();
00084         }

Here is the call graph for this function:

bool ServeurJeu::CreationSocketEcoute ( ) [inline, private]

Création d'une socket d'écoute TCP.

Returns:: Faux en cas d'exception.

Definition at line 90 of file ServeurJeu.h.

References mNbFantomeAuto, mPort, and mSocketEcoute.

Referenced by Traitement().

00090                                    {
00091                 bool stop=true;
00092                 cout<<endl<<"    SJ ServeurJeu::Création du serveur avec "<<mNbFantomeAuto<<" fantomes automatiques"<<endl;
00093                 try{
00094                         mSocketEcoute=new SocketTCP((unsigned int)mPort); 
00095                 } catch(SocketException s){
00096                         cout<<"    SJ ServeurJeu::"; printf( "\e[31m[Erreur] \e[m" ); cout<<"Impossible de créer la socket d'écoute"<<endl;
00097                         return false;
00098                 }
00099                 return true;
00100         }

void ServeurJeu::DemarrerFantomeAuto ( ) [inline, private]

Méthode démarrant les fantomes automatiques
Tous les thread gérant les fantome sont du type TraitementJoueur, simplement que dans ce cas la socket passée en paramètre vaut NULL.

Definition at line 106 of file ServeurJeu.h.

References Thread::Demarrer(), mNbFantomeAuto, and mTJ.

Referenced by Traitement().

00106                                   {
00107                 unsigned int k=0;
00108                 //On initialise les places pour les threads à NULL
00109                 for(unsigned int i=0; i<4; i++){
00110                         mTJ[i]=NULL;
00111                 }
00112                 //Création des fantomes automatiques 
00113                 if(mNbFantomeAuto<=3){
00114                         for(unsigned int i=0; i<mNbFantomeAuto; i++){
00115                                 cout<<"    SJ ServeurJeu::Démarrage d'un thread fantome"<<endl;
00116                                 TraitementJoueur *t=new TraitementJoueur(NULL);
00117                                 t->Demarrer();
00118                                 mTJ[k]=t; k++;
00119                         }
00120                 } else cerr<<"    SJ ServeurJeu::Trop de fantomes automatiques!!!"<<endl;
00121         }

Here is the call graph for this function:

void ServeurJeu::CreationThreadComServeurPrincipal ( ) [inline, private]

Méthode démarrant un thread de type TraitementComServeurPrincipal.

Definition at line 126 of file ServeurJeu.h.

References Thread::Demarrer(), mPort, and mServeurPrincipal.

Referenced by Traitement().

00126                                                 {
00127                 cout<<"    SJ ServeurJeu::Création d'un thread de communication avec le serveur principal"<<endl;
00128                 //On créé un thread afin de communiquer l'état de la partie au serveur principal
00129                 mServeurPrincipal=new TraitementComServeurPrincipal(mPort);
00130                 mServeurPrincipal->Demarrer();
00131         }

Here is the call graph for this function:

bool ServeurJeu::AttendreClient ( ) [inline, private]

Méthode attendant les clients.

Returns:: Faux en cas d'exception

Definition at line 137 of file ServeurJeu.h.

References Socket::Accept(), Thread::Demarrer(), mSocketEcoute, and mTJ.

Referenced by Traitement().

00137                              {
00138                 cout<<"    SJ ServeurJeu::Attente des clients"<<endl;
00139                 while(1){
00140                         //On attend la connexion des clients tant qu'il y a de la place
00141                         bool place=false; unsigned int pos;
00142                         for(unsigned int i=0; i<4; i++){
00143                                 if(mTJ[i]==NULL) {
00144                                         place=true;
00145                                         pos=i;
00146                                         break;
00147                                 }
00148                         }
00149                         if(place){
00150                                 //On attend la connexion d'un client 
00151                                 try{
00152                                         Socket *s=mSocketEcoute->Accept();
00153                                         cout<<endl<<"    SJ ServeurJeu::Connexion d'un client"<<endl;
00154                                         //Passer la nouvelle socket à un thread qui va gérer le traitement
00155                                         TraitementJoueur *t=new TraitementJoueur(s);
00156                                         t->Demarrer();
00157                                         //On stock le thread dans une case libre 
00158                                         mTJ[pos]=t;
00159                                 } catch(SocketException s){
00160                                         cout<<"    SJ ServeurJeu::"; printf( "\e[31m[Erreur] \e[m" ); cout<<"Impossible d'accepter le nouveau client"<<endl;
00161                                         return false;
00162                                 }
00163                         } else break;
00164                 }
00165                 cout<<"    SJ ServeurJeu::Tous les clients attendus sont connectés"<<endl;
00166                 return true;
00167         }

Here is the call graph for this function:

bool ServeurJeu::AttendreDebutPartie ( ) [inline, private]

Cette méthode attend le début de la partie, elle permet en fait de détecter les déconnexions brutales des clients avant que le jeu ne commence.

En effet elle parcours le tableau des threads à la recherche de thread passés en mode zombie, si tel est le cas, elle supprime le thread et renvoi Faux afin d'attendre à nouveau la connexion des joueurs.

Returns:: Faux si un client s'est déconnecté avant qua la partie commence.

Definition at line 174 of file ServeurJeu.h.

References Jeu::JeuPret(), mJeu, and mTJ.

Referenced by Traitement().

00174                                   {
00175                 cout<<"    SJ ServeurJeu::Attente du début de la partie"<<endl;
00176                 while(!mJeu->JeuPret()){
00177                         //On vérifie qu'un client ne s'est pas déconnecté avant que la partie ne commence 
00178                         for(unsigned int i=0; i<4; i++){
00179                                 bool unZombi=false;
00180                                 if(mTJ[i]!=NULL) if(mTJ[i]->IsZombie()) {
00181                                         cout<<"    SJ ServeurJeu::"; printf( "\e[31m[Avertissement] \e[m" ); cout<<"Un thread en mode "; printf( "\e[31mZombie \e[m" ); cout<<"a été détecté"<<endl;
00182                                         cout<<"    SJ ServeurJeu::"; printf( "\e[32m[Récupération] \e[m" ); cout<<"On supprime le thread et on repasse en mode d'attente"<<endl;
00183                                         delete mTJ[i];
00184                                         mTJ[i]=NULL;
00185                                         unZombi=true;
00186                                 }
00187                                 if(unZombi) return false; //Afin que Traitement() boucle sur l'attente des clients
00188                         }
00189                         sleep(1);
00190                 }
00191                 cout<<"    SJ ServeurJeu::La partie commence"<<endl;
00192                 return true;
00193         }

Here is the call graph for this function:

void ServeurJeu::AttendreFinPartie ( ) [inline, private]

Cette méthode permet d'attendre la fin de la partie.

En outre on recherche la présence de thread passé en mode zombi pendant tout ce temps.
Si tel est le cas en essaye de maintenir le jeu tant qu'il reste des joueurs humains en remplaçant les joueurs déconnectés par des joueurs automatiques.
Si c'est impossible on aborte le jeu.

Definition at line 201 of file ServeurJeu.h.

References Thread::Demarrer(), Jeu::GameOver(), Jeu::KillGame(), mJeu, mNbFantomeAuto, and mTJ.

Referenced by Traitement().

00201                                 {
00202                 cout<<"    SJ ServeurJeu::Attente de la fin de la partie"<<endl;        
00203                 unsigned int nbJoueurVivant=4-mNbFantomeAuto;
00204                 bool stop=false;
00205                 while((!mJeu->GameOver())&&(stop==false)){
00206                         //On vérifie qu'un client ne s'est pas déconnecté pendant la partie
00207                         for(unsigned int i=0; i<4; i++){
00208                                 if(mTJ[i]!=NULL) if(mTJ[i]->IsZombie()) {
00209                                         cout<<"    SJ ServeurJeu::"; printf( "\e[31m[Avertissement] \e[m" ); cout<<"Un thread en mode "; printf( "\e[31mZombie \e[m" ); cout<<"a été détecté"<<endl;
00210                                         cout<<"    SJ ServeurJeu::"; printf( "\e[32m[Récupération] \e[m" ); cout<<"On supprime le thread"<<endl;
00211                                         delete mTJ[i];
00212                                         mTJ[i]=NULL;
00213                                         nbJoueurVivant--;
00214                                         if(nbJoueurVivant==0){
00215                                                 cout<<"    SJ ServeurJeu::"; printf( "\e[31m[Erreur Récupération] \e[m" ); cout<<"Plus de joueur vivant, abandon de la partie"<<endl;
00216                                                 mJeu->KillGame(); //De cette manière on indique en udp au serveur que le jeu a été aborté
00217                                                 stop=true;
00218                                                 break;
00219                                         } else {
00220                                                 cout<<"    SJ ServeurJeu::"; printf( "\e[32m[Récupération] \e[m" ); cout<<"On remplace le joueur par un joueur automatique"<<endl;
00221                                                 TraitementJoueur *t=new TraitementJoueur(NULL,true);
00222                                                 t->Demarrer();
00223                                                 mTJ[i]=t;       
00224                                                 
00225                                         }
00226                                 }
00227                         }
00228                         sleep(1); //On attend la fin de la partie...
00229                 }
00230                 cout<<"    SJ ServeurJeu::La partie est terminée"<<endl;
00231                 sleep(3);//On attend avant de fermer pour laisser le temps au thread de communication avec le SP d'indiquer que la partie est terminée
00232         }

Here is the call graph for this function:

unsigned int ServeurJeu::mPort [private]

Port du serveur.

Definition at line 237 of file ServeurJeu.h.

Referenced by CreationSocketEcoute(), CreationThreadComServeurPrincipal(), and ServeurJeu().

unsigned int ServeurJeu::mNbFantomeAuto [private]

Nombre de fantome automatique.

Definition at line 242 of file ServeurJeu.h.

Referenced by AttendreFinPartie(), CreationSocketEcoute(), DemarrerFantomeAuto(), and ServeurJeu().

Socket* ServeurJeu::mSocketEcoute [private]

Socket d'écoute TCP.

Definition at line 247 of file ServeurJeu.h.

Referenced by AttendreClient(), CreationSocketEcoute(), and ~ServeurJeu().

TraitementJoueur* ServeurJeu::mTJ[4] [private]

Tableau de pointeurs sur les 4 thread traitant les joueurs.

Definition at line 252 of file ServeurJeu.h.

Referenced by AttendreClient(), AttendreDebutPartie(), AttendreFinPartie(), DemarrerFantomeAuto(), and ~ServeurJeu().

TraitementComServeurPrincipal* ServeurJeu::mServeurPrincipal [private]

Pointeur sur le thread traitant la communication avec le serveur principal.

Definition at line 257 of file ServeurJeu.h.

Referenced by CreationThreadComServeurPrincipal(), and ~ServeurJeu().

Jeu* ServeurJeu::mJeu [private]

Pointeur sur le singleton gérant le jeu.

Definition at line 262 of file ServeurJeu.h.

Referenced by AttendreDebutPartie(), AttendreFinPartie(), and ServeurJeu().

ServeurJeu Class Reference

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation


Public Member Functions
	ServeurJeu (unsigned int port, unsigned int nbFantomeAuto=0)
	Classe permettant de démarrer un serveur de jeu.
	~ServeurJeu ()
Private Member Functions
void	Traitement ()
	On créé la socket d'écoute TCP, on démarre les thread traitant les fantomes automatiques, on créé une socket de communication UDP avec le serveur puis on traite les clients qui se connecte.
bool	CreationSocketEcoute ()
	Création d'une socket d'écoute TCP.
void	DemarrerFantomeAuto ()
	Méthode démarrant les fantomes automatiques Tous les thread gérant les fantome sont du type TraitementJoueur, simplement que dans ce cas la socket passée en paramètre vaut NULL.
void	CreationThreadComServeurPrincipal ()
	Méthode démarrant un thread de type TraitementComServeurPrincipal.
bool	AttendreClient ()
	Méthode attendant les clients.
bool	AttendreDebutPartie ()
	Cette méthode attend le début de la partie, elle permet en fait de détecter les déconnexions brutales des clients avant que le jeu ne commence.
void	AttendreFinPartie ()
	Cette méthode permet d'attendre la fin de la partie.
Private Attributes
unsigned int	mPort
	Port du serveur.
unsigned int	mNbFantomeAuto
	Nombre de fantome automatique.
Socket *	mSocketEcoute
	Socket d'écoute TCP.
TraitementJoueur *	mTJ [4]
	Tableau de pointeurs sur les 4 thread traitant les joueurs.
TraitementComServeurPrincipal *	mServeurPrincipal
	Pointeur sur le thread traitant la communication avec le serveur principal.
Jeu *	mJeu
	Pointeur sur le singleton gérant le jeu.