ServeurJeu.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2007 by Pierre Schmitt, Ludovic Giacomello, Nhi Ly      *
 *                                                                         *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/


#ifndef SERVEURJEU_H
#define SERVEURJEU_H

#include<string>
#include<iostream>

#include "SocketTCP.h"
#include "SocketUDP.h"

#include "TraitementJoueur.h"
#include "TraitementComServeurPrincipal.h"

class ServeurJeu {
public:
        ServeurJeu(unsigned int port, unsigned int nbFantomeAuto=0){
                mJeu=Jeu::GetInstance();
                mPort=port; mNbFantomeAuto=nbFantomeAuto;
                mJeu->SetNbFantomeAuto(nbFantomeAuto);
                cout<<endl<<"    SJ ServeurJeu::Création d'un serveur de jeu sur le port "<<port<<" avec "<<mJeu->GetNbFantomeAuto()<<" fantomes automatiques"<<endl;
                Traitement();
        }

        ~ServeurJeu(){ 
                cout<<"    SJ ServeurJeu::Destruction du serveur de jeu"<<endl;
                cout<<"      SJ ServeurJeu::Destruction de la socket d'écoute"<<endl;
                if(mSocketEcoute!=NULL) delete mSocketEcoute; 
                cout<<"      SJ ServeurJeu::Destruction des threads de traitement des clients"<<endl;
                for(int i=0; i<4; i++){
                        if(mTJ[i]!=NULL) delete mTJ[i]; 
                }
                if(mServeurPrincipal!=NULL) delete mServeurPrincipal;
                Jeu::KillInstance(); 
        }


private:
        void Traitement(){
                if(!CreationSocketEcoute()){
                        cout<<"    SJ ServeurJeu::"; printf( "\e[31m[Erreur Fatale]\e[m\n" );
                        exit(-1);
                }
                DemarrerFantomeAuto();
                CreationThreadComServeurPrincipal();
                do{
                        if(!AttendreClient()){
                                cout<<"    SJ ServeurJeu::"; printf( "\e[31m[Erreur Fatale]\e[m\n" );
                                exit(-1);
                        }
                } while(!AttendreDebutPartie());
                AttendreFinPartie();
        }

        bool CreationSocketEcoute(){
                bool stop=true;
                cout<<endl<<"    SJ ServeurJeu::Création du serveur avec "<<mNbFantomeAuto<<" fantomes automatiques"<<endl;
                try{
                        mSocketEcoute=new SocketTCP((unsigned int)mPort); 
                } catch(SocketException s){
                        cout<<"    SJ ServeurJeu::"; printf( "\e[31m[Erreur] \e[m" ); cout<<"Impossible de créer la socket d'écoute"<<endl;
                        return false;
                }
                return true;
        }
        
        void DemarrerFantomeAuto(){
                unsigned int k=0;
                //On initialise les places pour les threads à NULL
                for(unsigned int i=0; i<4; i++){
                        mTJ[i]=NULL;
                }
                //Création des fantomes automatiques 
                if(mNbFantomeAuto<=3){
                        for(unsigned int i=0; i<mNbFantomeAuto; i++){
                                cout<<"    SJ ServeurJeu::Démarrage d'un thread fantome"<<endl;
                                TraitementJoueur *t=new TraitementJoueur(NULL);
                                t->Demarrer();
                                mTJ[k]=t; k++;
                        }
                } else cerr<<"    SJ ServeurJeu::Trop de fantomes automatiques!!!"<<endl;
        }

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

        bool AttendreClient(){
                cout<<"    SJ ServeurJeu::Attente des clients"<<endl;
                while(1){
                        //On attend la connexion des clients tant qu'il y a de la place
                        bool place=false; unsigned int pos;
                        for(unsigned int i=0; i<4; i++){
                                if(mTJ[i]==NULL) {
                                        place=true;
                                        pos=i;
                                        break;
                                }
                        }
                        if(place){
                                //On attend la connexion d'un client 
                                try{
                                        Socket *s=mSocketEcoute->Accept();
                                        cout<<endl<<"    SJ ServeurJeu::Connexion d'un client"<<endl;
                                        //Passer la nouvelle socket à un thread qui va gérer le traitement
                                        TraitementJoueur *t=new TraitementJoueur(s);
                                        t->Demarrer();
                                        //On stock le thread dans une case libre 
                                        mTJ[pos]=t;
                                } catch(SocketException s){
                                        cout<<"    SJ ServeurJeu::"; printf( "\e[31m[Erreur] \e[m" ); cout<<"Impossible d'accepter le nouveau client"<<endl;
                                        return false;
                                }
                        } else break;
                }
                cout<<"    SJ ServeurJeu::Tous les clients attendus sont connectés"<<endl;
                return true;
        }

        bool AttendreDebutPartie(){
                cout<<"    SJ ServeurJeu::Attente du début de la partie"<<endl;
                while(!mJeu->JeuPret()){
                        //On vérifie qu'un client ne s'est pas déconnecté avant que la partie ne commence 
                        for(unsigned int i=0; i<4; i++){
                                bool unZombi=false;
                                if(mTJ[i]!=NULL) if(mTJ[i]->IsZombie()) {
                                        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;
                                        cout<<"    SJ ServeurJeu::"; printf( "\e[32m[Récupération] \e[m" ); cout<<"On supprime le thread et on repasse en mode d'attente"<<endl;
                                        delete mTJ[i];
                                        mTJ[i]=NULL;
                                        unZombi=true;
                                }
                                if(unZombi) return false; //Afin que Traitement() boucle sur l'attente des clients
                        }
                        sleep(1);
                }
                cout<<"    SJ ServeurJeu::La partie commence"<<endl;
                return true;
        }

        void AttendreFinPartie(){
                cout<<"    SJ ServeurJeu::Attente de la fin de la partie"<<endl;        
                unsigned int nbJoueurVivant=4-mNbFantomeAuto;
                bool stop=false;
                while((!mJeu->GameOver())&&(stop==false)){
                        //On vérifie qu'un client ne s'est pas déconnecté pendant la partie
                        for(unsigned int i=0; i<4; i++){
                                if(mTJ[i]!=NULL) if(mTJ[i]->IsZombie()) {
                                        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;
                                        cout<<"    SJ ServeurJeu::"; printf( "\e[32m[Récupération] \e[m" ); cout<<"On supprime le thread"<<endl;
                                        delete mTJ[i];
                                        mTJ[i]=NULL;
                                        nbJoueurVivant--;
                                        if(nbJoueurVivant==0){
                                                cout<<"    SJ ServeurJeu::"; printf( "\e[31m[Erreur Récupération] \e[m" ); cout<<"Plus de joueur vivant, abandon de la partie"<<endl;
                                                mJeu->KillGame(); //De cette manière on indique en udp au serveur que le jeu a été aborté
                                                stop=true;
                                                break;
                                        } else {
                                                cout<<"    SJ ServeurJeu::"; printf( "\e[32m[Récupération] \e[m" ); cout<<"On remplace le joueur par un joueur automatique"<<endl;
                                                TraitementJoueur *t=new TraitementJoueur(NULL,true);
                                                t->Demarrer();
                                                mTJ[i]=t;       
                                                
                                        }
                                }
                        }
                        sleep(1); //On attend la fin de la partie...
                }
                cout<<"    SJ ServeurJeu::La partie est terminée"<<endl;
                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
        }

        unsigned int mPort;

        unsigned int mNbFantomeAuto;

        Socket *mSocketEcoute;

        TraitementJoueur *mTJ[4];

        TraitementComServeurPrincipal *mServeurPrincipal;

        Jeu *mJeu;
};

#endif

---