Jeu.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 "Jeu.h"

bool Jeu::GameOver(){
        if(!mPacmanVivant) return true;
        if(mNBPomme==0) return true;
        return false;
}

Jeu::Jeu(){
        mNbFantomeAuto=-1;
        //Initialisations des variables relatives aux joueurs 
        mJoueurPacman=false;
        for(unsigned int i=0; i<3; i++) mJoueurF[i]=false;
        
        //Initialisation des attributs de pacman
        mScorePacman=0;
        mPacmanVivant=true;

        //Initialisation de la grille
        Point coord;
        for(unsigned int i=0; i<20; i++){
                for(unsigned int j=0; j<20; j++){
                        mGrille[i][j]='+';
                }
        }
        //Construction des bordures
        ConstruireMur(0,0,20,'H');
        ConstruireMur(0,0,20,'V');
        ConstruireMur(0,19,20,'H');
        ConstruireMur(19,0,20,'V');     
        //Construction aléatoire de murs internes 
        char sens;
        for(unsigned int i=0; i<20; i++){
                if(UintAleat(1,2)==1) sens='V'; //On détermine l'orientation à pile ou face
                else sens='H';
                ConstruireMur(UintAleat(0,19),UintAleat(0,19),UintAleat(0,5),sens);
        }
        unsigned int x,y;
        //On place 100 fruits
        mNBPomme=0;
        for(unsigned int i=0; i<100; i++){
                do{
                        x=UintAleat(0,19); y=UintAleat(0,19);
                } while(PointLibre(x,y)!=0); //Case non libre
                SetPoint(x,y,'x');
                mNBPomme++;
        }
        //On place 1 pacman 
        do{
                x=UintAleat(0,19); y=UintAleat(0,19);
        } while(PointLibre(x,y)!=0); //Case non libre
        SetPoint(x,y,'P');
        coord.x=x; coord.y=y;
        mCoordPacman=coord;
        //On place 3 fantomes 
        for(unsigned int i=0; i<3; i++){
                do{
                        x=UintAleat(0,19); y=UintAleat(0,19);
                } while(PointLibre(x,y)!=0); //Case non libre
                SetPoint(x,y,'F');
                coord.x=x; coord.y=y;
                mCoordF[i]=coord;
                mScoreF[i]=0;
        }
}

Jeu::~Jeu(){}

bool Jeu::DeplacerPersonnage(unsigned int codePerso, char sens){
        if(codePerso==3){
                return DeplacerPacman(sens);
        } else if((codePerso>=0)&&(codePerso<=2)){
                return DeplacerFantome(codePerso,sens);
        }
        return false;
}

bool Jeu::DeplacerPacman(char sens){
        unsigned int newX, newY;
        switch(sens){
                case 'G' : {
                        newX=mCoordPacman.x-1; newY=mCoordPacman.y;
                        break;
                }
                case 'D' : {
                        newX=mCoordPacman.x+1; newY=mCoordPacman.y;
                        break;
                }
                case 'H' : {
                        newX=mCoordPacman.x; newY=mCoordPacman.y-1;
                        break;
                }
                case 'B' : {
                        newX=mCoordPacman.x; newY=mCoordPacman.y+1;
                        break;
                }
        }
        switch(PointLibre(newX,newY)){
                case -1 : { //Mouvement hors plateau
                        //Pas de déplacement
                        return false;
                }
                case 0 : {  //Case vide
                        SetPoint(mCoordPacman.x,mCoordPacman.y,'+');
                        mCoordPacman.x=newX; mCoordPacman.y=newY;
                        SetPoint(mCoordPacman.x,mCoordPacman.y,'P');
                        return true;
                }
                case 1 : { //Occupée par un fruit
                        SetPoint(mCoordPacman.x,mCoordPacman.y,'+');
                        mCoordPacman.x=newX; mCoordPacman.y=newY;
                        SetPoint(mCoordPacman.x,mCoordPacman.y,'P');
                        mScorePacman++;
                        mNBPomme--;
                        return true;
                }
                //case 2 impossible (pacman n'a pas le don d'ubiquité :=)

                case 3 : { //Occupée par un fantôme
                        //On efface le pauvre pacman
                        SetPoint(mCoordPacman.x,mCoordPacman.y,'+');
                        mPacmanVivant=false;
                        return false;
                }
                case 4 : { //Occupée par un mur
                        //Pas de déplacement
                        return false;
                }
        }               
}

bool Jeu::DeplacerFantome(unsigned int noFantome, char sens){
        unsigned int newX, newY;
        switch(sens){
                case 'G' : {
                        newX=mCoordF[noFantome].x-1; newY=mCoordF[noFantome].y;
                        break;
                }
                case 'D' : {
                        newX=mCoordF[noFantome].x+1; newY=mCoordF[noFantome].y;
                        break;
                }
                case 'H' : {
                        newX=mCoordF[noFantome].x; newY=mCoordF[noFantome].y-1;
                        break;
                }
                case 'B' : {
                        newX=mCoordF[noFantome].x; newY=mCoordF[noFantome].y+1;
                        break;
                }
        }
        switch(PointLibre(newX,newY)){
                case -1 : { //Mouvement hors plateau
                        //Pas de déplacement
                        mVerrou.Unlock();
                        return false;
                }
                case 0 : {  //Case vide
                        //On efface la case sur laquelle était le fantome
                        SetPoint(mCoordF[noFantome].x,mCoordF[noFantome].y,'+');
                        //Si on a en mémoire les coordonées d'un fruit, on le replace sur la grille 
                        if((mCoordP[noFantome].x!=-1)&&(mCoordP[noFantome].y!=-1)) SetPoint(mCoordP[noFantome].x,mCoordP[noFantome].y,'x');
                        //On déplace le fantome
                        mCoordF[noFantome].x=newX; mCoordF[noFantome].y=newY;
                        SetPoint(mCoordF[noFantome].x,mCoordF[noFantome].y,'F');
                        //On indique que le fantome n'a pas écrasé de fruit 
                        mCoordP[noFantome].x=-1; mCoordP[noFantome].y=-1;
                        mVerrou.Unlock();
                        return true;
                }
                case 1 : { //Occupée par un fruit
                        //On efface la case sur laquelle était le fantome
                        SetPoint(mCoordF[noFantome].x,mCoordF[noFantome].y,'+');
                        //Si on a en mémoire les coordonées d'un fruit, on le replace sur la grille 
                        if((mCoordP[noFantome].x!=-1)&&(mCoordP[noFantome].y!=-1)) SetPoint(mCoordP[noFantome].x,mCoordP[noFantome].y,'x');
                        //On place le fantome à la nouvelle position ce faisant on efface un fruit
                        mCoordF[noFantome].x=newX; mCoordF[noFantome].y=newY;
                        SetPoint(mCoordF[noFantome].x,mCoordF[noFantome].y,'F');
                        //Mais on le garde en mémoire afin de le replacer ultérieurement
                        mCoordP[noFantome].x=newX; mCoordP[noFantome].y=newY;
                        mVerrou.Unlock();
                        return true;
                }
                case 2 : { //Occupée par pacman
                        //On efface la case sur laquelle était le fantome
                        SetPoint(mCoordF[noFantome].x,mCoordF[noFantome].y,'+');
                        //Si on a en mémoire les coordonées d'un fruit, on le replace sur la grille 
                        if((mCoordP[noFantome].x!=-1)&&(mCoordP[noFantome].y!=-1)) SetPoint(mCoordP[noFantome].x,mCoordP[noFantome].y,'x');
                        //On déplace le fantome
                        mCoordF[noFantome].x=newX; mCoordF[noFantome].y=newY;
                        SetPoint(mCoordF[noFantome].x,mCoordF[noFantome].y,'F');
                        //Pour pacman c'est la fin...
                        mScoreF[noFantome]+=10;
                        mPacmanVivant=false;
                        //On indique que le fantome n'a pas écrasé de fruit (par pure conscience professionelle hein)
                        mCoordP[noFantome].x=-1; mCoordP[noFantome].y=-1;
                        mVerrou.Unlock();
                        return true;
                }
                case 3 : { //Occupée par un fantôme
                        //Pas de déplacement
                        mVerrou.Unlock();
                        return false;
                }
                case 4 : { //Occupée par un mur
                        //Pas de déplacement
                        mVerrou.Unlock();
                        return false;
                }
        }
        
}

//Private
void Jeu::ConstruireMur(unsigned int x, unsigned int y, unsigned int l, char s){
        unsigned int i;
        if(s=='V'){
                //De x,y vers le bas (x reste fixe, on incrémente y)
                for(i=y; i<=y+l; i++) SetPoint(x,i,'I');
        } else {
                //De x,y vers la droite (on incrémente x, y reste fixe)
                for(i=x; i<=x+l; i++) SetPoint(i,y,'I');
        }
}

void Jeu::SetPoint(unsigned int x, unsigned int y, char c){
        mVerrou.Lock();
        if((x>=0)&&(x<20)){
                if((y>=0)&&(y<20)){
                        mGrille[y][x]=c;
                }
        }
        mVerrou.Unlock();       
}

string Jeu::JoueurConnectes() const{
        string res="";
        for(unsigned int i=0; i<3; i++) {
                if(mJoueurF[i]) res+='1';
                else res+='0';
        }
        if(mJoueurPacman) res+='1';
        else res+='0';
        return res;
}

string Jeu::toString(){
        mVerrou.Lock();
        string res="";
        for(unsigned int i=0; i<20; i++){
                for(unsigned int j=0; j<20; j++){
                        res+=mGrille[i][j];
                }
        }       
        mVerrou.Unlock();
        return res;
}

string Jeu::EtatPartie(){
//mLoginPacman mScorePacman mLoginF mScoreF mNBPomme status
        string etat="";
        etat+=mLoginPacman; etat+=" ";
        ostringstream ossScoreP;
        ossScoreP<<mScorePacman;
        etat+=ossScoreP.str(); etat+=" ";
        for(unsigned int i=0; i<3; i++){
                etat+=mLoginF[i]; etat+=" ";
                ostringstream ossScore;
                ossScore<<mScoreF[i];
                etat+=ossScore.str(); etat+=" ";
        }
        ostringstream ossPomme;
        ossPomme<<mNBPomme;
        etat+=ossPomme.str(); etat+=" ";
        if(GameOver()) etat+="GAMEOVER";
        else etat+="GAMEOK";
        return etat;
        
}

bool Jeu::JeuPret() const{
        if((mJoueurPacman)&&(mJoueurF[0])&&(mJoueurF[1])&&(mJoueurF[2])) return true;
        return false;
}

unsigned int Jeu::UintAleat(unsigned int min, unsigned int max){
        static bool first=true;
        //On initialise le générateur en fonction de l'horloge
        if(first) {
                srand((unsigned)time(NULL));
                first=false;
        }
        unsigned int nb=(unsigned)rand();
        //on tire un nombre au hasard et on le place sur le bon intervalle.
        unsigned int final=(unsigned int)(min+((float)rand()/RAND_MAX*(max)));
        if(final==0) return 1;
        return final;
}

void Jeu::Afficher() const{
        for(unsigned int i=0; i<20; i++){
                for(unsigned int j=0; j<20; j++){
                        switch(mGrille[i][j]){
                                case '+' : {
                                        printf( "\e[30;47m%c \e[m",mGrille[i][j]);
                                        break;
                                }
                                case 'x' : {
                                        printf( "\e[30;47m\e[33m%c \e[m\e[m",mGrille[i][j]);
                                        break;
                                }
                                case 'P' : {
                                        printf( "\e[30;47m\e[34m%c \e[m\e[m",mGrille[i][j]);
                                        break;
                                }
                                case 'F' : {
                                        printf( "\e[30;47m\e[31m%c \e[m\e[m",mGrille[i][j]);
                                        break;
                                }
                                case 'I' : {
                                        printf( "\e[30;47m%c \e[m",mGrille[i][j]);
                                        break;
                                }
                        }               
                }
                if(i==0) printf( "  \e[30;47m Score Pacman \e[31m%d \e[m\e[m\n",mScorePacman);
                else cout<<endl;
        }       
}

int Jeu::PointLibre(unsigned int x, unsigned int y) {
        mVerrou.Lock();
        if((x>=0)&&(x<20)){
                if((y>=0)&&(y<20)){
                        switch(mGrille[y][x]){
                                case '+' : { mVerrou.Unlock(); return 0; } //Case vide
                                case 'x' : { mVerrou.Unlock(); return 1; } //Occupée par un fruit
                                case 'P' : { mVerrou.Unlock(); return 2; } //Occupée par Pacman
                                case 'F' : { mVerrou.Unlock(); return 3; } //Occupée par un fantôme
                                case 'I' : { mVerrou.Unlock(); return 4; } //Occupée par un mur
                                default : { mVerrou.Unlock(); return -1; }
                        }
                }
        }
        mVerrou.Unlock();
        return -1;
}

---