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

int Partie::AjouterPartie(unsigned int id){
        struct PartieInfo p;
        p.id=id;
        p.loginP="";
        p.scoreP=-1;
        p.nbFantomeAuto=-1;
        for(unsigned int i=0; i<3; i++){
                p.scoreF[i]=-1; p.loginF[i]="";
        }
        mVerrou.Lock();
        mPartie.ConsQueue(p);
        mVerrou.Unlock();
}

int Partie::AjouterPartie(const PartieInfo &p){
        int pos=Rechercher(p.id);
        if(pos=-1) {
                mVerrou.Lock();
                mPartie.ConsQueue(p);
                mVerrou.Unlock();
                return 0;
        }
        return -1;
}

int  Partie::SupprimerPartie(unsigned int id){
        int pos=Rechercher(id);
        if(pos!=-1) {
                mVerrou.Lock();
                mPartie.Detruit(pos);
                mVerrou.Unlock();
                return 0;
        }
        return -1;
}

string Partie::ToString(){
        string res="";
        for(unsigned int i=0; i<mPartie.Card(); i++){
                ostringstream ossPort,ossScore, ossNBF;
                ossPort<<mPartie[i].id;
                string port=ossPort.str();
                res+=port; res+=" ";
                ossNBF<<mPartie[i].nbFantomeAuto;
                string nbf=ossNBF.str();
                res+=nbf; res+=" ";
                if(mPartie[i].loginP!="") {
                        res+=mPartie[i].loginP; res+=" ";
                } else res+="libre ";
                ossScore<<mPartie[i].scoreP;
                string score=ossScore.str();
                res+=score; res+=" ";
                for(unsigned int j=0; j<3; j++){
                        if(mPartie[i].loginF[j]!="") {
                                res+=mPartie[i].loginF[j]; res+=" ";
                        } else res+="libre ";
                        ostringstream ossScoreF;
                        ossScoreF<<mPartie[i].scoreF[j];
                        string scoreF=ossScoreF.str();
                        res+=scoreF; res+=" ";
                }
                if(i<mPartie.Card()-1) res+=": ";
        }
        return res;
}

void Partie::Afficher(){
        for(unsigned int i=0; i<mPartie.Card(); i++){
                Afficher(mPartie[i].id);
        }
}

void Partie::Afficher(unsigned int id){
        int pos=Rechercher(id);
        if(pos!=-1) {
                cout<<"Partie sur le port "<<mPartie[pos].id<<" avec "<<mPartie[pos].nbFantomeAuto<<" fantomes automatiques"<<endl;
                cout<<"\tPacman: "<<mPartie[pos].loginP<<" avec un score de "<<mPartie[pos].scoreP<<endl;
                for(unsigned int i=0; i<3; i++){
                        cout<<"\tFantome "<<i<<": "<<mPartie[pos].loginF[i]<<" avec un score de "<<mPartie[pos].scoreF[i]<<endl;
                }
        }
}

int  Partie::GetScorePacman(unsigned int id){
        int pos=Rechercher(id);
        if(pos!=-1) {
                return mPartie[pos].scoreP;
        }
        return -1;
}

int  Partie::SetScorePacman(unsigned int id, unsigned int score){
        int pos=Rechercher(id);
        if(pos!=-1) {
                struct PartieInfo p=mPartie[pos];
                p.scoreP=score;
                mVerrou.Lock();
                mPartie.Modifier(pos,p);
                mVerrou.Unlock();
                return 0;
        }
        return -1;
}

int Partie:: GetScoreF(unsigned int id, unsigned int idFantome){
        int pos=Rechercher(id);
        if(pos!=-1) {
                return mPartie[pos].scoreF[idFantome];
        }
        return -1;
}

int  Partie::SetScoreF(unsigned int id, unsigned int idFantome, unsigned int score){
        int pos=Rechercher(id);
        if(pos!=-1) {
                struct PartieInfo p=mPartie[pos];
                p.scoreF[idFantome]=score;
                mVerrou.Lock();
                mPartie.Modifier(pos,p);
                mVerrou.Unlock();
                return 0;
        }
        return -1;
}

int  Partie::SetLoginPacman(unsigned int id, string login){
        int pos=Rechercher(id);
        if(pos!=-1) {
                struct PartieInfo p=mPartie[pos];
                p.loginP=login;
                mVerrou.Lock();
                mPartie.Modifier(pos,p);
                mVerrou.Unlock();
                return 0;
        }
        return -1;
}

string Partie::GetLoginPacman(unsigned int id){
        int pos=Rechercher(id);
        if(pos!=-1) {
                return mPartie[pos].loginP;
        }
        return "";
}

int Partie::SetLoginF(unsigned int id, unsigned int idFantome, string login){
        int pos=Rechercher(id);
        if(pos!=-1) {
                struct PartieInfo p=mPartie[pos];
                p.loginF[idFantome]=login;
                mVerrou.Lock();
                mPartie.Modifier(pos,p);
                mVerrou.Unlock();
                return 0;
        }
        return -1;
}


string Partie::GetLoginF(unsigned int id, unsigned int idFantome){
        int pos=Rechercher(id);
        if(pos!=-1) {
                return mPartie[pos].loginF[idFantome];
        }
        return "";
}

int Partie::GetNbFantomeAuto(unsigned int id){
        int pos=Rechercher(id);
        if(pos!=-1) {
                return mPartie[pos].nbFantomeAuto;
        }
        return -1;
}

int  Partie::SetNbFantomeAuto(unsigned int id, unsigned int nbFantomeAuto){
        int pos=Rechercher(id);
        if(pos!=-1) {
                struct PartieInfo p=mPartie[pos];
                p.nbFantomeAuto=nbFantomeAuto;
                mVerrou.Lock();
                mPartie.Modifier(pos,p);
                mVerrou.Unlock();
                return 0;
        }
        return -1;
}


//Private
int Partie::Rechercher(unsigned int id){
        mVerrou.Lock();
        for(unsigned int i=0; i<mPartie.Card(); i++){
                if(mPartie[i].id==id) {
                        mVerrou.Unlock();
                        return i;
                }
        }
        mVerrou.Unlock();
        return -1;
}

---