TraitementJoueur.cpp

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.             *
 ***************************************************************************/

#include "TraitementJoueur.h"

TraitementJoueur::TraitementJoueur(Socket *s, bool hotplug) : Thread(){
        mHotPlug=hotplug;
        if(s==NULL){
                if(!mHotPlug){
                        cout<<"      SJ TraitementJoueur::Création d'un thread pour gérer un fantome automatique"<<endl;
                        mLogin="auto";
                } else {
                        cout<<"      SJ TraitementJoueur::Création d'un thread pour remplacer un joueur déconnecté"<<endl;
                        mLogin="hotplug";
                }

        } else {
                cout<<"      SJ TraitementJoueur::Création d'un thread pour traiter le client"<<endl;
                mLogin="";
        }
        mJeu=Jeu::GetInstance();
        mSocket=s;
        mZombie=false;
        mIdJoueur=-1;
}

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

void *TraitementJoueur::Traitement(){
        if(mSocket!=NULL){
                //On traite un joueur distant
                if(!WaitForHello()) return NULL;
                mLogin=WaitForLogin();
                if(mLogin=="ERROR") return NULL;
                if(!WaitForRole()) return NULL;
                if(!WaitForPlayers()) return NULL;
                if(!TraitementDeplacement()) return NULL;
                cout<<"      SJ TraitementJoueur::Fin du traitement de "<<mLogin<<endl;
        } else {        
                mVerrou.Lock();
                string place=mJeu->JoueurConnectes();
                if(!mHotPlug){
                        //On simule un fantome 
                        for(unsigned int i=0; i<3; i++){
                                if(place[i]=='0'){
                                        mJeu->SetJoueur(i,"auto");
                                        mIdJoueur=i;
                                        break;
                                }
                        }
                        mVerrou.Unlock();
                        WaitForPlayers();
                        DeplacementAuto();
                        cout<<"      SJ TraitementJoueur::Fin du traitement du fantome automatique "<<mIdJoueur<<endl;
                } else {
                        //On remplace un joueur à chaud
                        for(unsigned int i=0; i<4; i++){
                                if(place[i]=='0'){
                                        mJeu->SetJoueur(i,"hotplug");
                                        mIdJoueur=i;
                                        break;
                                }
                        }
                        mVerrou.Unlock();
                        DeplacementAuto();
                        cout<<"      SJ TraitementJoueur::Fin du traitement du joueur automatique de remplacement "<<mIdJoueur<<endl;           
                }
        }
        return NULL;
}

void TraitementJoueur::ModeZombie(){
        cout<<"      SJ TraitementJoueur::Passé en mode "; printf( "\e[31mZombie\e[m\n" );
        if(mIdJoueur!=-1) mJeu->UnSetJoueur(mIdJoueur);
        mZombie=true;
        while(1) sleep(1);
}
bool TraitementJoueur::WaitForHello(){
        //1 On attent que le client nous dise bonjour 
        cout<<"      SJ TraitementJoueur::Attente de l'initiation du protocole de la part du client";
        try{
                while(mSocket->Ecouter()!="HELLO"){
                        mSocket->Envoyer("ERROR HELLO");
                }
                mSocket->Envoyer("HELLO");
                //cout<<"  SJ Protocole initialisé"<<endl;
                printf("\e[32m [OK]\e[m\n");
        } catch(SocketException s){
                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" );
                ModeZombie();
                return false;
        }
        return true;
}


string TraitementJoueur::WaitForLogin(){
        //2 Le client doit se logger 
        string line,cmd;
        do{
                try{
                        line=mSocket->Ecouter();
                        string login;
                        istringstream iss(line);
                        getline(iss,cmd,' '); 
                        if(cmd=="LOGIN"){
                                getline(iss,login,' ');
                                cout<<"      SJ TraitementJoueur::Connexion de "<<login<<endl;
                                mSocket->Envoyer("LOGIN OK");
                                return login;
                        } else mSocket->Envoyer("ERROR LOGIN");
                } catch(SocketException s){
                        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" );
                        ModeZombie();
                        return false;
                }
        } while(1);
}

bool TraitementJoueur::WaitForRole(){
        mVerrou.Lock();
        cout<<"      SJ TraitementJoueur::Envoi des places restantes"<<endl;
        //3 On recherche les places encore libres et on les envoie au client
        string place=mJeu->JoueurConnectes();
        string reponse="BUSY ";
        reponse+=place;
        try{
                mSocket->Envoyer(reponse);
                cout<<"      SJ TraitementJoueur::Attente du rôle"<<endl;
                bool stop=false;
                //4 On attend que le client nous envoie le rôle qu'il veut jouer
                do{
                        string line=mSocket->Ecouter();
                        string cmd,role;
                        istringstream iss(line);
                        getline(iss,cmd,' '); 
                        if(cmd=="GET"){
                                getline(iss,role,' ');
                                reponse="SET "; reponse+=mLogin; reponse+=" "; reponse+=role;
                                if(role=="PACMAN"){
                                        if(place[3]=='0'){
                                                stop=true;
                                                mIdJoueur=3;
                                                mJeu->SetJoueur(mIdJoueur,mLogin);
                                                mSocket->Envoyer(reponse);
                                                cout<<"      SJ TraitementJoueur::Attente du rôle"; printf("\e[32m [OK]\e[m\n");
                                        } else  mSocket->Envoyer("ERROR GET ROLE");
                                } else if(role=="F1"){
                                        if(place[0]=='0'){
                                                stop=true;
                                                mIdJoueur=0;
                                                mJeu->SetJoueur(mIdJoueur,mLogin);
                                                mSocket->Envoyer(reponse);
                                                cout<<"      SJ TraitementJoueur::Attente du rôle"; printf("\e[32m [OK]\e[m\n");
                                        } else  mSocket->Envoyer("ERROR GET ROLE");
                                } else if(role=="F2"){
                                        if(place[1]=='0'){
                                                stop=true;
                                                mIdJoueur=1;
                                                mJeu->SetJoueur(mIdJoueur,mLogin);
                                                mSocket->Envoyer(reponse);
                                                cout<<"      SJ TraitementJoueur::Attente du rôle"; printf("\e[32m [OK]\e[m\n");
                                        } else  mSocket->Envoyer("ERROR GET ROLE");
                                } else if(role=="F3"){
                                        if(place[2]=='0'){
                                                stop=true;
                                                mIdJoueur=2;
                                                mJeu->SetJoueur(mIdJoueur,mLogin);
                                                mSocket->Envoyer(reponse);
                                                cout<<"      SJ TraitementJoueur::Attente du rôle"; printf("\e[32m [OK]\e[m\n");
                                        } else  mSocket->Envoyer("ERROR GET ROLE");
                                } else mSocket->Envoyer("ERROR GET ROLE");
                        } else mSocket->Envoyer("ERROR GET ROLE");
                } while(!stop);
                mVerrou.Unlock();
        } catch(SocketException s){
                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" );
                ModeZombie();
                return false;
        }
        return true;
}

bool TraitementJoueur::WaitForPlayers(){
        cout<<"      SJ TraitementJoueur::Attente des autres joueurs..."<<endl;
        while(!(mJeu->JeuPret())){
                sleep(1);//pour le petit processeur...
        }
        cout<<"      SJ TraitementJoueur::"<<mLogin<<" "<<mIdJoueur<<" dit: Le jeu est prêt!!!"<<endl;
        try{
                if(mSocket!=NULL) mSocket->Envoyer("READY");
        } catch(SocketException s){
                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" );
                ModeZombie();
        }
        return true;
}

bool TraitementJoueur::TraitementDeplacement(){
        while(!mJeu->GameOver()){
                try{
                        string line=mSocket->Ecouter();
                        //On envoie la grille 
                        if(line=="GRID") {
                                string res=mJeu->EtatPartie(); res+=" ";
                                res+=mJeu->toString(); res+=" ";
                                mSocket->Envoyer(res);
                        }
                        //On attend le déplacement 
                        if((line=="HAUT")||(line=="BAS")||(line=="GAUCHE")||(line=="DROITE")){
                                if(mJeu->DeplacerPersonnage(mIdJoueur,line[0])) mSocket->Envoyer("MOVE OK");
                                else mSocket->Envoyer("MOVE BAD");
                        } else mSocket->Envoyer("MOVE BAD");
                } catch(SocketException s){
                        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" );
                        ModeZombie();
                }
        }
        return true;
}

void TraitementJoueur::DeplacementAuto(){
        cout<<"      SJ TraitementJoueur::Démarrage du déplacement automatique du personnage "<<mIdJoueur<<endl;
        bool deplacementOk=false;
        char c;
        while(!mJeu->GameOver()){
                if(deplacementOk){
                        //On continue dans la même direction 
                        deplacementOk=mJeu->DeplacerPersonnage(mIdJoueur,c);
                } else {
                        switch(mJeu->UintAleat(1,4)){
                                case 1 : {
                                        deplacementOk=mJeu->DeplacerPersonnage(mIdJoueur,'H'); c='H';
                                        break;
                                }
                                case 2 : {
                                        deplacementOk=mJeu->DeplacerPersonnage(mIdJoueur,'B'); c='B';
                                        break;
                                }
                                case 3 : {
                                        deplacementOk=mJeu->DeplacerPersonnage(mIdJoueur,'G'); c='G';
                                        break;
                                }
                                case 4 : {
                                        deplacementOk=mJeu->DeplacerPersonnage(mIdJoueur,'D'); c='D';
                                        break;
                                }
                        }
                }
                sleep(1);
        }
}

---