Coinche Code

#include <QPixmap>
#include <QDebug>

#include "carte.h"


using namespace std;

//la carte par defaut est l'as de pique
Carte::Carte()
        :couleurCarte(Piques), valeurCarte(As)
{
    setPosition(0,0);
    isPixSet=false;
    joueur = -1;
    gagnant = -1;
}

Carte::~Carte()
{
    
}

Carte::Carte(Valeur val, Couleur type)
        :couleurCarte(type), valeurCarte(val)
{
    setPosition(0,0);
    isPixSet=false;
}

//Des cartes sont égales si elles ont même couleur et même valeur
bool Carte::operator== (Carte &c)
{
    if (couleurCarte != c.getCouleur())
        return false;
    if (valeurCarte != c.getValeur())
        return false;
    return true;
}

ostream& operator<< (ostream &out, Carte &carte)
{
    switch (carte.valeurCarte)
    {
    case Sept :
      out << "Sept";
      break;
    case Huit :
      out << "Huit";
      break;
    case Neuf :
      out << "Neuf";
      break;
    case Valet :
      out << "Valet";
      break;
    case Dame :
      out << "Dame";
      break;
    case Roi :
      out << "Roi";
      break;
    case Dix :
      out << "Dix";
      break;
    case As :
      out << "As";
      break;
    case Out :
      qDebug("Une carte ne peut pas avoir la valeur Out");
      break;
    }

    out << " de ";

    switch (carte.couleurCarte)
    {
    case Piques :
        out << "Pique";
        break;
    case Trefles :
        out << "Trefle";
        break;
    case Carreaux :
        out << "Carreau";
        break;
    case Coeurs :
        out << "Coeur";
        break;
    }
    return out;
}

// renvoie true si la carte en cours est meilleure que celle passee en parametre
bool Carte::estMeilleure(Carte* c, Couleur atout)
{

	if (couleurCarte == c->getCouleur())
	{
		return numOrdre(couleurCarte == atout) > c->numOrdre(couleurCarte == atout);
	}
	else
	{
		if (couleurCarte == atout)
			return true;
		else
			return false;
	}

/*
    int tot1,tot2;
    tot1 = this->numOrdre(this->getCouleur() == atout) +
        8*(this->getCouleur() == atout) ;

    tot2 = c->numOrdre(c->getCouleur() == atout) + 8*(c->getCouleur() == atout) ;
    return ((tot1 > tot2) && ((this->getCouleur() == atout)||
                (this->getCouleur() ==c->getCouleur())));
*/
}


int Carte::points(Couleur atout)
{
    switch(valeurCarte)
    {
        case As :
            return 11;
            break;
        case Dix :
            return 10;
            break;
        case Roi :
            return 4;
            break;
        case Dame :
            return 3;
            break;
        case Valet :
            if(couleurCarte==atout)
                {return 20;}
            else
                {return 2;}
            break;
        case Neuf :
            if(couleurCarte==atout)
                {return 14;}
            else
                {return 0;}
            break;
        default :
            return 0;
            break;
    }
}

int Carte::ordre()
{
    int result=0;
    switch (couleurCarte)
    {
    case Piques :
        result+=0;
        break;
    case Coeurs :
        result+=8;
        break;
    case Trefles :
        result+=16;
        break;
    case Carreaux :
        result+=24;
        break;
    }

    switch (valeurCarte)
    {
    case Sept :
      result+=0;
      break;
    case Huit :
      result+=1;
      break;
    case Neuf :
      result+=2;
      break;
    case Valet :
      result+=3;
      break;
    case Dame :
      result+=4;
      break;
    case Roi :
      result+=5;
      break;
    case Dix :
      result+=6;
      break;
    case As :
      result+=7;
      break;
    case Out:
      qDebug("Une carte ne peut pas avoir la valeur Out");
      break;      
    }
    return result;
}

// renvoie le "nombre de points" de la carte dans sa couleur
int Carte::numOrdre(bool estAtout)
{
    switch (valeurCarte)
    {
    case Sept :
      return 0;
      break;
    case Huit :
      return 1;
      break;
    case Neuf :
      if (estAtout) return 6;
      else         return 2;
      break;
    case Valet :
      if (estAtout) return 7;
      else         return 3;
      break;
    case Dame :
      if (estAtout) return 2;
      else         return 4;
      break;
    case Roi :
      if (estAtout) return 3;
      else         return 5;
      break;
    case Dix :
      if (estAtout) return 4;
      else         return 6;
      break;
    case As :
      if (estAtout) return 5;
      else         return 7;
      break;
    case Out : 
       qDebug("Une carte ne peut pas avoir la valeur Out");
       break;

    }
    return 0;
}

// Ordre de classement des cartes
bool Carte::operator > (Carte &c)
{
    return (ordre()>c.ordre());
}

// Ordre de classement des cartes
bool Carte::operator < (Carte &c)
{
    return (ordre()<c.ordre());
}

QPixmap Carte::afficheCarte()
{
    if (!isPixSet)
    {
        setPixmap();
        isPixSet=true;
    }
    return pix;
}


void Carte::setPixmap()
{
    QPixmap cardmap("./images/cartes.png");
    int x = 0;
    int y = 0;
    const int LARGEUR = 100;
    const int HAUTEUR = 145;

    y = couleurCarte * HAUTEUR;
    x = valeurCarte * LARGEUR;
    /*
    for (Couleur i = Piques; i < couleurCarte; i = Couleur(i+1))
    {
        y++; //Dans quelle ligne se trouve la carte ?
    }

    for (Valeur i = Sept; i < valeurCarte; i = Valeur(i+1))
    {
        x++; //Colone ?
    }

    x *= LARGEUR;
    y *= HAUTEUR;
*/
    //affiche le rectangle correspondant à la carte
    pix = cardmap.copy(x, y, LARGEUR, HAUTEUR);

}

void Carte::setPosition(QPoint pos)
{
    rect = QRect(pos.x(),pos.y(),100,145);
}

void Carte::setPosition(int x, int y)
{
    rect = QRect(x,y,100,145);
}

void Carte::laquelle()
{
    switch (valeurCarte)
    {
    case Sept :
      cout<<"Sept ";
      break;
    case Huit :
      cout<<"Huit ";
      break;
    case Neuf :
      cout<<"Neuf ";
      break;
    case Valet :
      cout<<"Valet ";
      break;
    case Dame :
      cout<<"Dame ";
      break;
    case Roi :
      cout<<"Roi ";
      break;
    case Dix :
      cout<<"Dix ";
      break;
    case As :
      cout<<"As ";
      break;
    case Out :
      qDebug("Une carte ne peut pas avoir la valeur Out");
      break;
    }

    switch (couleurCarte)
    {
    case Piques :
        cout<<"Pique "<<endl;
        break;
    case Trefles :
        cout<<"Trefle "<<endl;
        break;
    case Carreaux :
        cout<<"Carreau "<<endl;
        break;
    case Coeurs :
        cout<<"Coeur "<<endl;
        break;
    }

}


// retourne la valeur de la carte juste plus forte, si c'est la carte la plus 
// forte, retourne -1
Valeur Carte::valeurSup(bool estAtout)
{
  Valeur val = valeurCarte;
  switch(val)
  {
    case Sept :
      return Huit;
      break;
    case Huit :
      return estAtout?Valet:Neuf;
      break;
    case Neuf : 
      return Valet;
      break;
    case Dix :
      return As;
      break;
    case Valet : 
      return estAtout?Out:Dame;
      break;
    case Dame :
      return Roi;
      break;
    case Roi :
      return Dix;
      break;
    case As :
      return estAtout?Neuf:Out;
      break;
    default :
      qWarning()<<"Erreur dans la fonction ValeurSup : valeur indeterminée\n";
      return Out;
  }
}