Beispiel #1
0
    //calcul du best
int Joueur::getMeilleur(Carte **tas, Couleur atout, int premierJoueur){
    int best = premierJoueur;
    Carte *prems = tas[premierJoueur];
    bool isAtout = false;
    for(int i = 0; i < 4; i++){
        if(tas[i] != nullptr){
            //Si la carte actuelle est un atout
            if(tas[i]->isCouleur(atout)){

                //Si la meilleure carte est aussi un atout on doit comparer
                if(isAtout){
                    if(tas[best]->getValeur(atout) < tas[i]->getValeur(atout))
                        best = i;
                }else{ // Sinon ça devient automatiquement la meilleure carte
                    best = i;
                }
            }//sinon, si la carte actuelle est de la couleur demandée (et qu'on a pas déjà eu un atout
            else if(tas[i]->isCouleur(prems->getCouleur())){
                //On compare la puissance de l'âme des cartes, Yugi
                if(tas[best]->getValeur(atout) < tas[i]->getValeur(atout))
                        best = i;
            }
        }
    }
    return best;
}
Beispiel #2
0
void Solitaire::deplacerColonneAColonne(int p_colonneSource, int p_colonneDestination, int p_nbCartes)
{
	PRECONDITION(p_colonneSource >=0 && p_colonneSource <=6);
	PRECONDITION(p_colonneDestination >=0 && p_colonneDestination <=6);

	//variables temporaires permettant de faire les validations.
	int positionCarteSource = (m_colonnes[p_colonneSource].reqTailleColonne() + 1) - p_nbCartes;
	Carte derniereCarteDestination = m_colonnes[p_colonneDestination].derniereCarteColonne();
	Carte carteSource = m_colonnes[p_colonneSource].carteALaPosition(positionCarteSource);
	int valeurCarteSource = carteSource.reqValeur();
	int tailleColonneDestination = m_colonnes[p_colonneDestination].colonneEstVide();

	//Si la taille de la colonneDestination est vide et que la première carte à bouger est un Roi, le déplacement est possible.
	if((tailleColonneDestination == 0) && (valeurCarteSource == Carte::ROI))
		{
			m_colonnes[p_colonneSource].deplacePaquet(m_colonnes[p_colonneDestination], p_nbCartes);
		}
		//Si la colone n'est pas vide, verification de la dernière carte de la colonne. Deplacement si elle est suivante à la carteSource.
	else if(derniereCarteDestination.estSuivante(carteSource) &&
					!derniereCarteDestination.estMemeCouleur(carteSource))
		{
			m_colonnes[p_colonneSource].deplacePaquet(m_colonnes[p_colonneDestination], p_nbCartes);
		}
	else
	{
		cout << endl << "Ce deplacement est invalide!" << endl << endl;
	}
}
Beispiel #3
0
void CaseCarte::joueurArrive(Joueur* j)
{
    Case::joueurArrive(j);
    Carte *carte = m_paquet->tirer();
	j->setLastCarte(carte);
    if (!dynamic_cast<Payer_ou_tirer*>(carte))
		carte->tirer(j);
}
Beispiel #4
0
Carte* Joueur::pullCarte(unsigned int i){
    Carte *ret = getCarte(i);
    if(!ret->isDefault()){
        jeu[i]->setPlayed(true);
        jeu[i] = jeu[0];
        jeu.erase(jeu.begin());
    }
    return ret;
}
Beispiel #5
0
Carte* PaquetCarte::tirer()
{
	Carte* carte;
	do
	{
		carte = m_cartes.front();
		m_cartes.pop_front();
		m_cartes.push_back(carte);
	}while(carte->estEnPossession());
	return carte;
}
Beispiel #6
0
void Carte::afficherS () {

	Carte* ec = teteS;

	while (ec->_suc != queueS ) {

		ec->afficher();

		ec=ec->_suc;

	}

}
Beispiel #7
0
void Carte::afficherN () {

	Carte* ec = teteN;

	while (ec->_suc != queueN ) {

		ec->afficher();

		ec=ec->_suc;

	}

}
Beispiel #8
0
/**
*\fn afficherS()
*\brief display a card of the S player
*/
void Carte::afficherS() 
{
	if(firstS == nullptr)
	{
		printf("No card");
	}else{
		Carte * cardToDisplay = firstS;
		while(cardToDisplay != nullptr)
		{
			cardToDisplay->afficher();
			cardToDisplay = cardToDisplay->nextCard;
		}	
	}
}
Beispiel #9
0
Deck::Deck(string fichier)
{
  int pdv,pa,cm,fct,i,j,sz;
  i = 0;
  j = 0;  
  string ligne,nom,des;
  bool charge,provoc,sort;  
  vector<Carte> myvector;
  ifstream ifs(fichier.c_str());
  
  srand(time(0));
  
  if(ifs)
	{
		while(getline(ifs,ligne))
		{

			istringstream iss(ligne);
			iss >> pa;
			iss >> pdv;
			iss >> nom;
			iss >> cm;
			iss >> charge;
			iss >> provoc;
			iss >> sort;
			iss >> fct;
			iss >> des;
			//cout << pdv << " " << pa << " " << nom << " " << cm << endl;
			
			replace(nom.begin(),nom.end(),'_',' ');
			replace(des.begin(),des.end(),'_',' ');
			
			Carte * c = new Carte(pdv,pa,nom,cm,charge,provoc,sort,fct,des);
			
			myvector.push_back(*c);
			//d.push(*c);
			
			std::random_shuffle ( myvector.begin(), myvector.end() );

			// using myrandom:
  			std::random_shuffle ( myvector.begin(), myvector.end(), myrandom);
  			
			i++;
			
			cout << c->toString() << endl;
		}
	}
	else
	{
Beispiel #10
0
/*!
    @fn void AskDataBase::CreateFile(void)

    @brief Cree ou recupere une BDD puis lance la feetre principale.
    \note Dans les faits la recuperation ou la creation de la base de donnée se fait à l'appel de datacreate on récupére aussi les catagories qui ont été sauvergardé dans les QSettings.

*/
void AskDataBase::CreateFile(void)
{
    filename= ui->comboBox->currentText().remove(".db");
    database::dataCreate(filename)->initTable();
    int i = 0 ;
    QStringList Categories;
    QSettings settings("CartoTeam", "Cartographe");
    Categories.append(settings.value("Categories").toStringList());
    for(i=0;i<Categories.count();i++)
    {
        addCategorie(Categories.value(i));
    }
    Carte * WCarte = new Carte();
    WCarte->show();
    this->close();
}
Beispiel #11
0
vector<Carte*> Joueur::priorite(Carte** tas, Couleur atout){
    int premier = 0, moi = -1, part = -1;
    Carte *prems = tas[premier];

    // On trouve le premier joueur
    while(premier < 4 && (prems == nullptr || tas[(premier+3)%4] != nullptr)){
        prems = tas[++premier];
    }

    //On trouve ma position, et par conséquent celle de mon partenaire
    for(int i = 0; i < 4; i++){
        int ii = (i+premier)%4;
        if(tas[ii] == nullptr){
            moi = ii;
            part = (moi+2)%4;
        }
    }
    vector<Carte*> ret;
    if(premier == 4){//On est le premier
        ret = jeu;
    }else{ // Sinon
        if(prems->getCouleur() != atout){ // SI la couleur demandée n'est pas l'atout
            if(aCouleur(prems->getCouleur())){ //Si on a la couleur demandée, alors couleur
                for(Carte *c:jeu){
                        if(c->getCouleur() == prems->getCouleur()){
                            ret.push_back(c);
                        }
                }
            }else{
                int best = getMeilleur(tas, atout, premier); // Sinon on regarde qui est le meilleur
                if(part == best){ // Si le partenaire est le meilleur, ça implique qu'il ait déjà joué, on peut jouer n'imp
                    ret = jeu;
                }
            }
        }else{ // SI la couleur demandée est de l'atout
            int best = getMeilleur(tas, atout, premier);
            if(tas[best]->getCouleur() == atout){
                int bestVal = tas[best]->getValeur(atout);
                for(Carte *c:jeu){ // On regarde si on peut mettre un meilleur atout
                    if(c->getCouleur() == atout && c->getValeur(atout) > bestVal){
                        ret.push_back(c);
                    }
                }
            }
        }

        if(ret.empty()){// Si ret est toujours vide, on regarde si on a une carte de la couleur demandée
            if(aCouleur(prems->getCouleur())){ //Si on a la couleur demandée, alors couleur
                for(Carte *c:jeu){
                        if(c->getCouleur() == prems->getCouleur()){
                            ret.push_back(c);
                        }
                }
            }else{ // sinon n'importe quelle carte
                ret = jeu;
            }
        }
    }
    return ret;
}
Beispiel #12
0
bool operator<(const Carte& lhs, const Carte& rhs)
{
    if(lhs.getColor() < rhs.getColor())
		return true;
	else if (lhs.getColor() == rhs.getColor() && lhs.getValue() < rhs.getValue())
		return true;
	else 
		return false;
}
int main(){
	Carte* carteD = new Carte(0,{{'#','_','#'},{'#','_','#'},{'#','_','_'}});
	Carte* carteA = new Carte(1,{{'_','_','#'},{'#','_','#'},{'#','_','#'}});
	Coordonnees coordD(0,0);
	Coordonnees coordA(1,0);
	PersonnageJouable* pers = new PersonnageJouable("Jerôme",coordD,carteD);
	((CelluleAccessible*)carteD->getCel(coordD))->setPersonnage(pers);
	ActionChangementCarte act(carteD,carteA,coordD,coordA);
	cout << "Personnage présent dans la carte de départ?" << ((CelluleAccessible*)carteD->getCel(coordD))->getPersonnage() << endl;
	cout << "Personnage présent dans la carte d'arrivée?" << ((CelluleAccessible*)carteA->getCel(coordA))->getPersonnage() << endl << endl;
	act.lancerAction();
	cout << "Lancement de l'action déplacer" << endl << endl;
	cout << "Personnage présent dans la carte de départ?" << ((CelluleAccessible*)carteD->getCel(coordD))->getPersonnage() << endl;
	cout << "Personnage présent dans la carte d'arrivée?" << ((CelluleAccessible*)carteA->getCel(coordA))->getPersonnage() << endl << endl;
	cout << "Affichage texte interaction" << endl;
	cout << act.getTexteInteraction() << endl << endl;
	cout << "L'action est-elle toujours active?" << endl;
	cout << "est actif?" << act.isActive() <<endl << endl;
	cout << "On fait un toggle active" << endl << endl;
	act.toggleActive();
	cout << "L'action est-elle toujours active?" << endl;
	cout << "est actif?" << act.isActive() <<endl;
}
Beispiel #14
0
bool operator<(Carte const &a, Carte const& b)
{
    return (int)a.getValeur()<(int)b.getValeur();
}
Beispiel #15
0
bool Carte::supAbs(Carte c) { return _valeur>c.valeur();}
void Jeu::lireJoueurs(){//DONE
    ifstream file("donnees/Joueurs.d", ios::in);
    int idCartePerso, xPerso, yPerso;
    string nomPerso;
    file >> nomPerso
        >> idCartePerso
        >> xPerso
        >> yPerso;
    Carte* cartePerso = monde.getCarte(idCartePerso);
    personnageJouable = new JoueurHumain(nomPerso, Coordonnees(xPerso, yPerso), cartePerso);
    personnageJouable->setCarte(cartePerso);
    personnageJouable->setCoordonnees(Coordonnees(xPerso, yPerso));
    ((CelluleAccessible*)cartePerso->getCellules()[xPerso][yPerso])->setPersonnage(personnageJouable);

    int nbAdversaire;
    file >> nbAdversaire;
    for(int i=0; i<nbAdversaire; i++){
        int typePerso, xTailleGrille, yTailleGrille;
        char bossFinal;
        string aCasesCombat, armePerso;
        file >> typePerso
            >> nomPerso
            >> idCartePerso
            >> xPerso
            >> yPerso
            >> armePerso
            >> bossFinal
            >> xTailleGrille
            >> yTailleGrille;

        int nbBateauFlotte;
        vector<int> bateaux;
        file >> nbBateauFlotte;
        for(int i=0; i<nbBateauFlotte; i++){
            int tailleBateau;
            file >> tailleBateau;
            bateaux.push_back(tailleBateau);
        }


        Arme* arme;
        if(armePerso == "ArmeFatale")
            arme = new ArmeFatale();
        else if (armePerso == "ArmeChercheuse")
            arme = new ArmeChercheuse();
        else if (armePerso == "ArmeCroix")
            arme = new ArmeCroix();
        else
            arme = new ArmeClassique();

        PersonnageNonJouable* perso;
        switch(typePerso) {
            case 1: //JoueurIA
                perso = new JoueurIA(nomPerso, xTailleGrille, yTailleGrille, bateaux, arme);
                break;
            case 2: //JoueurIAAvance
                perso = new JoueurIAAvance(nomPerso, xTailleGrille, yTailleGrille, bateaux, arme);
                break;
            case 3: //JoueurIACheate
                perso = new JoueurIACheate(nomPerso, xTailleGrille, yTailleGrille, bateaux, arme);
                break;
        }

        if(bossFinal=='Y')
            perso->getInventaire()->ajoutObjet(new BadgeFinal());

        cartePerso = monde.getCarte(idCartePerso);
        perso->setCarte(cartePerso);
        perso->setCoordonnees(Coordonnees(xPerso, yPerso));
        ((CelluleAccessible*)cartePerso->getCellules()[xPerso][yPerso])->setPersonnage(perso);

        personnagesNonJouables.push_back(perso);


        file >> aCasesCombat;
        if(aCasesCombat == "Y"){
            int nbCasesCombat;
            file >> nbCasesCombat;
            Action* action = new ActionCombat(perso, "");
            for(int j=0; j<nbCasesCombat; j++){
                int xCase, yCase, idCarteCase;
                file >> idCarteCase >> xCase >> yCase;
                monde.getCarte(idCarteCase)->getCellules()[xCase][yCase]->setType("x");
                monde.getCarte(idCarteCase)->getCellules()[xCase][yCase]->setAction(action);
            }
        }
    }
Beispiel #17
0
bool operator==(const Carte& lhs, const Carte& rhs) 
{
    return lhs.getValue() == rhs.getValue() && lhs.getColor() == rhs.getColor();
}
Beispiel #18
0
/**
* Methode qui lance le jeu
*/
void Jeu::jouer()
{
	if (system("CLS")) system("clear");
	
	bool finJeu = false;

	if (this->joueurCourant->getPdm() == 0)
	{
		this->joueurCourant->ajouterMain(this->joueurCourant->getDeck()->tirerCarte());
		this->joueurCourant->ajouterMain(this->joueurCourant->getDeck()->tirerCarte());
	}
	
	if (this->joueurCourant->getPdm() < 10)
	{
		this->joueurCourant->setPDM(this->joueurCourant->getPdm()+1);			
	}
	
	this->joueurCourant->setPDMTour(this->joueurCourant->getPdm());
	
	Carte c = this->joueurCourant->getDeck()->tirerCarte();

 	if (c.getPdv() == -1 )
 	{
 		this->joueurCourant->setPDV(this->joueurCourant->getPdv()-1);
 		finJeu = notifierObs();
 	}
 	else
 	{
 		this->joueurCourant->ajouterMain(c);
 	}
  
	enleverMalinvoc();
	
	vue->afficherDebutTour(joueurCourant);
	vue->afficher2Board(joueurCourant,joueurAutre);
		
	int choix = -1;
	
	if (this->testNoMana() == true && this->testNoAttaque() == true )
	{
			this->setEtat(this->getEtatDoubleNo());
	} else {
	
		if (this->testNoMana() == true )
		{
			this->setEtat(this->getEtatNoMana());
		}
		 
		if (this->testNoAttaque() == true )
		{
			this->setEtat(this->getEtatNoAttaque());
		} 
	}  
	
	
	while (choix != 0 && finJeu == false)
	{	
		vue->afficherPersonnage(joueurCourant);
		vue->afficherPersonnageAutre(joueurAutre);
		choix = etatCourant->afficherChoixEtat();
		finJeu = notifierObs();
	}

	if (finJeu != true)
	{
		vue->afficherFinTour();
	
		usleep(1000000);
	
		this->finTour();
	}
}
    void FenetrePrincipale::AfficherCarte() const
    {
        int xZero, yZero;
        int l = carteGraphicsScene->getLargeurUnite(), h = carteGraphicsScene->getHauteurUnite();

        QPen styloNoir;
        styloNoir.setWidth(2);
        styloNoir.setColor(QColor("black"));
        QPen styloBleu;
        styloBleu.setWidth(10);
        styloBleu.setColor(QColor("blue"));

        Carte* carte = JoueurSingleton::getInstance()->getCarte();

        for(int i=0; i<16; i++)
        {
            for(int j=0; j<16; j++)
            {
                xZero = j*l;
                yZero = i*h;


                if(carte->getCase(j, i) == CHEMIN_NORD)
                {
                    QPixmap butPixmap(QString(":/images/chemin_N.jpg"));
                    butPixmap = butPixmap.scaled(l, h);
                    QGraphicsPixmapItem* tmp = carteGraphicsScene->addPixmap(butPixmap);
                    //tmp->setScale(ScalePourUnite(butPixmap, l, h));
                    tmp->setPos(xZero, yZero);
                    tmp->setData(0, "CHEMIN_NORD");
                }
                else if(carte->getCase(j, i) ==  CHEMIN_SUD)
                {
                    QPixmap butPixmap(QString(":/images/chemin_S.jpg"));
                    butPixmap = butPixmap.scaled(l, h);
                    QGraphicsPixmapItem* tmp = carteGraphicsScene->addPixmap(butPixmap);
                    tmp->setPos(xZero, yZero);
                    tmp->setData(0, "CHEMIN_SUD");
                }
                else if(carte->getCase(j, i) == CHEMIN_OUEST)
                {
                    QPixmap butPixmap(QString(":/images/chemin_W.jpg"));
                    butPixmap = butPixmap.scaled(l, h);
                    QGraphicsPixmapItem* tmp = carteGraphicsScene->addPixmap(butPixmap);
                    tmp->setPos(xZero, yZero);
                    tmp->setData(0, "CHEMIN_OUEST");
                }
                else if(carte->getCase(j, i) ==  CHEMIN_EST)
                {
                    QPixmap butPixmap(QString(":/images/chemin_E.jpg"));
                    butPixmap = butPixmap.scaled(l, h);
                    QGraphicsPixmapItem* tmp = carteGraphicsScene->addPixmap(butPixmap);
                    tmp->setPos(xZero, yZero);
                    tmp->setData(0, "CHEMIN_EST");
                }
                else if(carte->getCase(j, i) == CHEMIN_NO)
                {
                    if(carte->getCase(j, i-1) == CHEMIN_NORD || carte->getCase(j, i-1) == CHEMIN_SUD)
                    {
                        QPixmap butPixmap(QString(":/images/chemin_SE.jpg"));
                        butPixmap = butPixmap.scaled(l, h);
                        QGraphicsPixmapItem* tmp = carteGraphicsScene->addPixmap(butPixmap);
                        tmp->setPos(xZero, yZero);
                        tmp->setData(0, "CHEMIN_NO");
                    }
                    else
                    {
                        QPixmap butPixmap(QString(":/images/chemin_NW.jpg"));
                        butPixmap = butPixmap.scaled(l, h);
                        QGraphicsPixmapItem* tmp = carteGraphicsScene->addPixmap(butPixmap);
                        tmp->setPos(xZero, yZero);
                        tmp->setData(0, "CHEMIN_NO");
                    }
                }
                else if(carte->getCase(j, i) == CHEMIN_SE)
                {
                    if(carte->getCase(j, i-1) == CHEMIN_NORD || carte->getCase(j, i-1) == CHEMIN_SUD)
                    {
                        QPixmap butPixmap(QString(":/images/chemin_SE.jpg"));
                        butPixmap = butPixmap.scaled(l, h);
                        QGraphicsPixmapItem* tmp = carteGraphicsScene->addPixmap(butPixmap);
                        tmp->setPos(xZero, yZero);
                        tmp->setData(0, "CHEMIN_SE");
                    }
                    else
                    {
                        QPixmap butPixmap(QString(":/images/chemin_NW.jpg"));
                        butPixmap = butPixmap.scaled(l, h);
                        QGraphicsPixmapItem* tmp = carteGraphicsScene->addPixmap(butPixmap);
                        tmp->setPos(xZero, yZero);
                        tmp->setData(0, "CHEMIN_SE");
                    }
                }
                else if(carte->getCase(j, i) == CHEMIN_NE)
                {
                    if(carte->getCase(j, i-1) == CHEMIN_NORD || carte->getCase(j, i-1) == CHEMIN_SUD)
                    {
                        QPixmap butPixmap(QString(":/images/chemin_SW.jpg"));
                        butPixmap = butPixmap.scaled(l, h);
                        QGraphicsPixmapItem* tmp = carteGraphicsScene->addPixmap(butPixmap);
                        tmp->setPos(xZero, yZero);
                        tmp->setData(0, "CHEMIN_NE");
                    }
                    else
                    {
                        QPixmap butPixmap(QString(":/images/chemin_NE.jpg"));
                        butPixmap = butPixmap.scaled(l, h);
                        QGraphicsPixmapItem* tmp = carteGraphicsScene->addPixmap(butPixmap);
                        tmp->setPos(xZero, yZero);
                        tmp->setData(0, "CHEMIN_NE");
                    }
                }
                else if(carte->getCase(j, i) == CHEMIN_SO)
                {
                    if(carte->getCase(j, i-1) == CHEMIN_NORD || carte->getCase(j, i-1) == CHEMIN_SUD)
                    {
                        QPixmap butPixmap(QString(":/images/chemin_SW.jpg"));
                        butPixmap = butPixmap.scaled(l, h);
                        QGraphicsPixmapItem* tmp = carteGraphicsScene->addPixmap(butPixmap);
                        tmp->setPos(xZero, yZero);
                        tmp->setData(0, "CHEMIN_SO");
                    }
                    else
                    {
                        QPixmap butPixmap(QString(":/images/chemin_NE.jpg"));
                        butPixmap = butPixmap.scaled(l, h);
                        QGraphicsPixmapItem* tmp = carteGraphicsScene->addPixmap(butPixmap);
                        tmp->setPos(xZero, yZero);
                        tmp->setData(0, "CHEMIN_SO");
                    }

                 }
                else if(carte->getCase(j, i) == BUT_ENNEMIS)
                {
                    QPixmap butPixmap(QString(":/images/but.png"));
                    butPixmap = butPixmap.scaled(l, h);
                    QGraphicsPixmapItem* tmp = carteGraphicsScene->addPixmap(butPixmap);
                    tmp->setPos(xZero, yZero);
                    tmp->setData(0, "BUT_ENNEMIS");
                }
                else if(carte->getCase(j, i) == DEPART_NORD || carte->getCase(j, i) == DEPART_SUD || carte->getCase(j, i) == DEPART_OUEST || carte->getCase(j, i) == DEPART_EST)
                {
                    QGraphicsItem* item = carteGraphicsScene->addRect(xZero, yZero, l, h, styloBleu, Qt::blue);
                    item->setData(0, "DEPART");
                }
                else if(carte->getCase(j, i) == BOUE)
                {
                    QGraphicsItem* item = carteGraphicsScene->addRect(xZero, yZero, l, h, QPen(Qt::darkGreen), Qt::darkGreen);
                    item->setData(0, "BOUE");
                }
                else
                {
                    QGraphicsItem* item = carteGraphicsScene->addRect(xZero, yZero, l, h, QPen(Qt::transparent));
                    item->setData(0, "LIBRE");
                }
            }
        }
    }
/* Met à jour le joueur.*/
void Joueur::update(Carte const &carte)
{
	// Si les coins du personnages touchent une tile solide.
	bool coins[4];
	
	EnumDirections direction_deplacement = HAUT;
	
	// Les dimensions d'une tile de la carte.
	int hauteur_tile = carte.getHauteurTile();
	int largeur_tile = carte.getLargeurTile();
	
	// La position du joueur à l'image précédente.
	Coordonnees pos_precedente = m_position;
	
	//---------------------------------
	// Mise à jour des attributs du joueur.
	
	//---------------------------------
	// Déplacement du joueur.
	
	// Attribution de la direction en fonction du déplacement demandé.
	if(m_actions[DIR_HAUT] && !m_actions[DIR_DROITE] && !m_actions[DIR_BAS] && !m_actions[DIR_GAUCHE])
	{
		direction_deplacement = HAUT;
		m_direction_deplacement = 0;
	}
	else if(m_actions[DIR_HAUT] && m_actions[DIR_DROITE] && !m_actions[DIR_BAS] && !m_actions[DIR_GAUCHE])
	{
		direction_deplacement = HAUT_DROITE;
		m_direction_deplacement = M_PI_4;
	}
	else if(!m_actions[DIR_HAUT] && m_actions[DIR_DROITE] && !m_actions[DIR_BAS] && !m_actions[DIR_GAUCHE])
	{
		direction_deplacement = DROITE;
		m_direction_deplacement = M_PI_2;
	}
	else if(!m_actions[DIR_HAUT] && m_actions[DIR_DROITE] && m_actions[DIR_BAS] && !m_actions[DIR_GAUCHE])
	{
		direction_deplacement = BAS_DROITE;
		m_direction_deplacement = 3. * M_PI_4;
	}
	else if(!m_actions[DIR_HAUT] && !m_actions[DIR_DROITE] && m_actions[DIR_BAS] && !m_actions[DIR_GAUCHE])
	{
		direction_deplacement = BAS;
		m_direction_deplacement = M_PI;
	}
	else if(!m_actions[DIR_HAUT] && !m_actions[DIR_DROITE] && m_actions[DIR_BAS] && m_actions[DIR_GAUCHE])
	{
		direction_deplacement = BAS_GAUCHE;
		m_direction_deplacement = 5. * M_PI_4;
	}
	else if(!m_actions[DIR_HAUT] && !m_actions[DIR_DROITE] && !m_actions[DIR_BAS] && m_actions[DIR_GAUCHE])
	{
		direction_deplacement = GAUCHE;
		m_direction_deplacement = 3. * M_PI_2;
	}
	else if(m_actions[DIR_HAUT] && !m_actions[DIR_DROITE] && !m_actions[DIR_BAS] && m_actions[DIR_GAUCHE])
	{
		direction_deplacement = HAUT_GAUCHE;
		m_direction_deplacement = 7. * M_PI_4;
	}
	
	// Si le joueur se déplace
	if(m_actions[DIR_BAS] || m_actions[DIR_DROITE] || m_actions[DIR_GAUCHE] || m_actions[DIR_HAUT])
	{
		// Calcul de la vitesse.
		m_vitesse.x = sin(m_direction_deplacement) * m_vitesse_max;
		m_vitesse.y = (-1.) * cos(m_direction_deplacement) * m_vitesse_max;
		
		// Changement de la position.
		m_position.x += m_vitesse.x;
		m_position.y += m_vitesse.y;
	}
	
	// Test de collisions avec les tiles solides de la carte et modification du déplacement si il y a collision.
    coins[0] = carte.isTileSolide(m_position.x/largeur_tile, m_position.y/hauteur_tile);
    coins[1] = carte.isTileSolide((m_position.x+largeur_tile-1)/largeur_tile, m_position.y/hauteur_tile);
    coins[2] = carte.isTileSolide((m_position.x+largeur_tile-1)/largeur_tile, (m_position.y+hauteur_tile-1)/hauteur_tile);
    coins[3] = carte.isTileSolide(m_position.x/largeur_tile, (m_position.y+hauteur_tile-1)/hauteur_tile);
    if(coins[0] && coins[1]) {
        m_position.y = (m_position.y/hauteur_tile + 1) * hauteur_tile;
    }
    if(coins[1] && coins[2]) {
        m_position.x = (m_position.x/largeur_tile) * largeur_tile;
    }
    if(coins[2] && coins[3]) {
        m_position.y = (m_position.y/hauteur_tile) * hauteur_tile;
    }
    if(coins[3] && coins[0]) {
        m_position.x = (m_position.x/largeur_tile + 1) * largeur_tile;
    }
    if (coins[0] && !(coins[1] || coins[2] || coins[3])) {
        switch(direction_deplacement) {
        case GAUCHE: m_position.x = (m_position.x/largeur_tile + 1) * largeur_tile;
            break;
        case HAUT: m_position.y = (m_position.y/hauteur_tile + 1) * hauteur_tile;
            break;
        case HAUT_DROITE: m_position.y = (m_position.y/hauteur_tile + 1) * hauteur_tile;
            break;
        case BAS_GAUCHE: m_position.x = (m_position.x/largeur_tile + 1) * largeur_tile;
            break;
        case HAUT_GAUCHE:
            if (pos_precedente.x - (m_position.x / largeur_tile + 1)*largeur_tile > pos_precedente.y - (m_position.y / hauteur_tile + 1)*hauteur_tile) {
                m_position.x = (m_position.x/largeur_tile + 1) * largeur_tile;
            } else {
                m_position.y = (m_position.y/hauteur_tile + 1) * hauteur_tile;
            }
            break;
        default:
            break;
        }
    }
    if (coins[1] && !(coins[0] || coins[2] || coins[3])) {
        switch(direction_deplacement) {
        case DROITE: m_position.x = (m_position.x/largeur_tile) * largeur_tile;
            break;
        case HAUT: m_position.y = (m_position.y/hauteur_tile + 1) * hauteur_tile;
            break;
        case HAUT_GAUCHE: m_position.y = (m_position.y/hauteur_tile + 1) * hauteur_tile;
            break;
        case BAS_DROITE: m_position.x = (m_position.x/largeur_tile) * largeur_tile;
            break;
        case HAUT_DROITE:
            if((m_position.x/largeur_tile)*largeur_tile - pos_precedente.x > pos_precedente.y - (m_position.y/hauteur_tile + 1) * hauteur_tile) {
                m_position.x = (m_position.x/largeur_tile) * largeur_tile;
            } else {
                m_position.y = (m_position.y/hauteur_tile + 1) * hauteur_tile;
            }
            break;
        default:
            break;
        }
    }
    if (coins[2] && !(coins[0] || coins[1] || coins[3])) {
        switch(direction_deplacement) {
        case DROITE: m_position.x = (m_position.x/largeur_tile) * largeur_tile;
            break;
        case BAS: m_position.y = (m_position.y/hauteur_tile) * hauteur_tile;
            break;
        case BAS_GAUCHE: m_position.y = (m_position.y/hauteur_tile) * hauteur_tile;
            break;
        case HAUT_DROITE: m_position.x = (m_position.x/largeur_tile) * largeur_tile;
            break;
        case BAS_DROITE:
            if((m_position.x/largeur_tile)*largeur_tile - pos_precedente.x > (m_position.y/hauteur_tile)*hauteur_tile - pos_precedente.y) {
                m_position.x = (m_position.x/largeur_tile) * largeur_tile;
            } else {
                m_position.y = (m_position.y/hauteur_tile) * hauteur_tile;
            }
            break;
        default:
            break;
        }
    }
    if (coins[3] && !(coins[0] || coins[1] || coins[2])) {
        switch(direction_deplacement) {
        case GAUCHE: m_position.x = (m_position.x/largeur_tile + 1) * largeur_tile;
            break;
        case BAS: m_position.y = (m_position.y/hauteur_tile) * hauteur_tile;
            break;
        case BAS_DROITE: m_position.y = (m_position.y/hauteur_tile) * hauteur_tile;
            break;
        case HAUT_GAUCHE: m_position.x = (m_position.x/largeur_tile + 1) * largeur_tile;
            break;
        case BAS_GAUCHE:
            if(pos_precedente.x - (m_position.x/largeur_tile + 1)*largeur_tile > (m_position.y/hauteur_tile)*hauteur_tile - pos_precedente.y) {
                m_position.x = (m_position.x/largeur_tile + 1) * largeur_tile;
            } else {
                m_position.y = (m_position.y/hauteur_tile) * hauteur_tile;
            }
            break;
        default:
            break;
        }
    }
	
	// Changement de l'image du joueur en fonction de la direction.
	if(m_actions[CHANGE_DIRECTION])
	{
		if(m_direction_visee >= 15. * M_PI_8 || m_direction_visee < M_PI_8)
		{
			m_image = m_textures[HAUT];
		}
		else if(m_direction_visee >= M_PI_8 && m_direction_visee < 3. * M_PI_8)
		{
			m_image = m_textures[HAUT_DROITE];
		}
		else if(m_direction_visee >= 3. * M_PI_8 && m_direction_visee < 5. * M_PI_8)
		{
			m_image = m_textures[DROITE];
		}
		else if(m_direction_visee >= 5. * M_PI_8 && m_direction_visee < 7. * M_PI_8)
		{
			m_image = m_textures[BAS_DROITE];
		}
		else if(m_direction_visee >= 7. * M_PI_8 && m_direction_visee < 9. * M_PI_8)
		{
			m_image = m_textures[BAS];
		}
		else if(m_direction_visee >= 9. * M_PI_8 && m_direction_visee < 11. * M_PI_8)
		{
			m_image = m_textures[BAS_GAUCHE];
		}
		else if(m_direction_visee >= 11. * M_PI_8 && m_direction_visee < 13. * M_PI_8)
		{
			m_image = m_textures[GAUCHE];
		}
		else if(m_direction_visee >= 13. * M_PI_8 && m_direction_visee < 15. * M_PI_8)
		{
			m_image = m_textures[HAUT_GAUCHE];
		}
		
		m_actions[CHANGE_DIRECTION] = false;
	}
	
	//---------------------------------
	// Utilisation de l'arme.
	
	// Écoulement du compteur de recharge.
	if(m_compteur_recharge > 0)
	{
		m_compteur_recharge--;
		std::cout << "compteur recharge : " << m_compteur_recharge << std::endl;
	}
	
	if(m_actions[UTILISE_ARME] && m_compteur_recharge == 0)
	{
		m_compteur_recharge = m_arme_selectionnee->getTpsRecharge();
		m_arme_selectionnee->utiliser(*this);
		m_actions[UTILISE_ARME] = false;
	}
}
Beispiel #21
0
//////////////////////////////////////////////////////////////////////
/////////////////////////////Opérator/////////////////////////////////
/////////////////////////////////////////////////////////////////////
bool operator==(Carte const& a, Carte const& b)
{
    return (int)a.getValeur()==(int)b.getValeur() && (int)a.getCouleur()==(int)b.getCouleur();
}
Beispiel #22
0
bool Carte::egale(Carte c) { return _valeur==c.valeur();}
Beispiel #23
0
void Interface::update()
{
    int x, y;
    x=y=0;
    m_button_achat->SetVisible(false);
    m_button_hypothequer->SetVisible(false);
    m_button_deshypothequer->SetVisible(false);
    m_button_construire->SetVisible(false);
    m_button_detruire->SetVisible(false);
    m_button_liberer->SetVisible(false);
    m_button_caution->SetVisible(false);
    Joueur *joueur = m_plateau->getPlateau()->getJoueurTour();

	m_infoCase->SetText(joueur->nom()+" est sur : " + joueur->estSur()->nom()+"\n"+joueur->estSur()->description());

    if (dynamic_cast<CasePropriete*>(joueur->estSur()) && !((CasePropriete*)(joueur->estSur()))->estAchete()
        && joueur->argent() > ((CasePropriete*)(joueur->estSur()))->prixAchat())
        m_button_achat->SetVisible(true);

    if (joueur->estEnPrison() && joueur->cartesLiberte().size() != 0)
       m_button_liberer->SetVisible(true);

    if (joueur->estEnPrison() && joueur->getToursPrison() != 0)
        m_button_caution->SetVisible(true);

    for (CasePropriete *m_case : joueur->proprietes())
    {
        if (!m_case->estEnHypotheque())
            m_button_hypothequer->SetVisible(true);
        if (m_case->estEnHypotheque())
            m_button_deshypothequer->SetVisible(true);
        if (m_case->peutConstruire() && joueur->argent() > ((CasePropriete*)(joueur->estSur()))->prixAchat())
            m_button_construire->SetVisible(true);
        if (m_case->peutDetruire())
            m_button_detruire->SetVisible(true);
    }
	Carte* carte = joueur->lastCarte();
	joueur->setLastCarte(nullptr);

	if(carte && !dynamic_cast<Payer_ou_tirer*>(carte))
		m_lastInfos = joueur->nom()+":\nCarte " + carte->paquet()->nom() + "\n" + carte->description();

	if (dynamic_cast<Payer_ou_tirer*>(carte))
    {
        new MessageBox("Carte "+carte->paquet()->nom(), carte->description(), m_plateau->getPlateau(), dynamic_cast<Payer_ou_tirer*>(carte), m_button_des);
        m_button_des->SetVisible(false);
    }

    if (m_window_hypothequer && m_window_deshypothequer && m_window_construire && m_window_detruire)
    {
        if (m_window_hypothequer->IsVisible() || m_window_deshypothequer->IsVisible() || m_window_construire->IsVisible() || m_window_detruire->IsVisible())
            m_button_des->SetVisible(false);
    }
    else
        m_button_des->SetVisible(true);

    if (!m_window_hypothequer)
    {
        m_window_hypothequer = m_engine->GetGuiManager()->GetRootNode()->AddWindow();
        m_window_hypothequer->SetCharacterSizeTitle(22);
        m_window_hypothequer->SetWindowTitle("Hypotéquer");
        m_window_hypothequer->SetColorShape(sf::Color(255, 255, 255));
        m_window_hypothequer->SetColorOutlineShape(sf::Color(255, 0, 0));
        m_window_hypothequer->SetColorContener(sf::Color(255, 255, 255));
        m_window_hypothequer->SetColorOutlineContener(sf::Color(255, 0, 0));
        m_window_hypothequer->SetClosable(true);
        m_window_hypothequer->CloseItem()->SetData("this", this);
        m_window_hypothequer->CloseItem()->SetCallBack("onClosed", Interface::closeHypotheque);
        m_window_hypothequer->SetVisible(false);
    }

    if(!m_window_deshypothequer)
    {
        m_window_deshypothequer = m_engine->GetGuiManager()->GetRootNode()->AddWindow();
        m_window_deshypothequer->SetCharacterSizeTitle(22);
        m_window_deshypothequer->SetWindowTitle("Deshypothéquer");
        m_window_deshypothequer->SetColorShape(sf::Color(255, 255, 255));
        m_window_deshypothequer->SetColorOutlineShape(sf::Color(255, 0, 0));
        m_window_deshypothequer->SetColorContener(sf::Color(255, 255, 255));
        m_window_deshypothequer->SetColorOutlineContener(sf::Color(255, 0, 0));
        m_window_deshypothequer->SetClosable(true);
        m_window_deshypothequer->CloseItem()->SetData("this", this);
        m_window_deshypothequer->CloseItem()->SetCallBack("onClosed", Interface::closeDeshypotheque);
        m_window_deshypothequer->SetVisible(false);
    }

    if(!m_window_construire)
    {
        m_window_construire = m_engine->GetGuiManager()->GetRootNode()->AddWindow();
        m_window_construire->SetCharacterSizeTitle(22);
        m_window_construire->SetWindowTitle("Construire");
        m_window_construire->SetColorShape(sf::Color(255, 255, 255));
        m_window_construire->SetColorOutlineShape(sf::Color(255, 0, 0));
        m_window_construire->SetColorContener(sf::Color(255, 255, 255));
        m_window_construire->SetColorOutlineContener(sf::Color(255, 0, 0));
        m_window_construire->SetClosable(true);
        m_window_construire->CloseItem()->SetData("this", this);
        m_window_construire->CloseItem()->SetCallBack("onClosed", Interface::closeConstruire);
        m_window_construire->SetVisible(false);
    }

    if(!m_window_detruire)
    {
        m_window_detruire = m_engine->GetGuiManager()->GetRootNode()->AddWindow();
        m_window_detruire->SetCharacterSizeTitle(22);
        m_window_detruire->SetWindowTitle("Détruire");
        m_window_detruire->SetColorShape(sf::Color(255, 255, 255));
        m_window_detruire->SetColorOutlineShape(sf::Color(255, 0, 0));
        m_window_detruire->SetColorContener(sf::Color(255, 255, 255));
        m_window_detruire->SetColorOutlineContener(sf::Color(255, 0, 0));
        m_window_detruire->SetClosable(true);
        m_window_detruire->CloseItem()->SetData("this", this);
        m_window_detruire->CloseItem()->SetCallBack("onClosed", Interface::closeDetruire);
        m_window_detruire->SetVisible(false);
    }
	m_info->SetText(m_lastInfos);
}
Beispiel #24
0
int main(int argc, char** argv) {
    if (argc && argv); //pour éviter un warning.....
    
    std::srand(std::time(NULL));
    
    SDL_Rect src;
    SDL_Rect dst;
    src.w=640; src.h=480; src.y=0;src.x=0;dst.x=0; dst.y=0;
    
    SDL_Surface* gpScreen = NULL;
    
    int mode = 2; //mode=0;
    
    gpScreen = init();
    SDL_Surface* gpScreen2 = SDL_CreateRGBSurface(SDL_HWSURFACE, 320, 240, 32, 0, 0, 0, 0);
    SDL_Surface* gpScreen3 = NULL;
    
    Audio* gpAudio = new Audio();
    Jeu* gpJeu = new Jeu(gpAudio);
    Carte* gpCarte = new Carte(gpJeu);
    Encyclopedie* gpEncyclopedie = new Encyclopedie(gpJeu);
    Keyboard* gpKeyboard = new Keyboard(gpJeu, gpCarte, gpEncyclopedie, gpScreen, mode);
    gpJeu->setKeyboard(gpKeyboard);
    Generique* gpGenerique = new Generique(gpJeu);
    gpJeu->setGenerique(gpGenerique);
    gpGenerique->initLogo();
    
    //gpJeu->init(0);
    
    bool gLoop = true;
    
    Uint32 lastAnimTime = SDL_GetTicks();
    
    while (gLoop) {
        
        if (gpKeyboard->gererClavier() == -1) {gLoop = false;}
        
        switch (gpKeyboard->getMode()) {
            case 0 : //jeu normal
                gpJeu->draw(gpScreen2); break;
            case 1 : //disclamer
            case 2 : //logo
            case 3 : //titre
            case 14 : //générique score
            case 17 : //menu d'aide 1
            case 18 : //menu d'aide 2
                gpGenerique->draw(gpScreen2); break;
            case 4 : //selection
                gpGenerique->drawSelection(gpScreen2, gpKeyboard->getLigne(), 
                    gpKeyboard->getColonne()); break;
            case 6 : //options
                gpGenerique->drawOption(gpScreen2, gpKeyboard->getLigneOption(),
                gpKeyboard->getVolume()/8, gpKeyboard->getVolson()/8); break;
            case 7 : //charger partie
                gpGenerique->drawCharger(gpScreen2, gpKeyboard->getLigne(), 
                    gpKeyboard->getLigneVal()); break;
            case 8 : //générique intro
                gpGenerique->drawIntro(gpScreen2, gpKeyboard->getIntro()); break;
            case 9 : //effacer partie
                gpGenerique->drawEffacerSave(gpScreen2, gpKeyboard->getLigne(), 
                    gpKeyboard->getLigneVal()); break;
            case 10 : //générique début chez link
                gpGenerique->drawDebut(gpScreen2); break;
            case 11 : //générique fin
                gpGenerique->drawFin(gpScreen2); break;
            case 12 : //carte
            case 22 : //carte téléportation
                gpCarte->draw(gpScreen2); break;
            case 13 : //encyclopédie des monstres
                gpEncyclopedie->draw(gpScreen2); break;
            case 15 : //records
            case 19 : //rang 100%
            case 20 : //rang ultime
            case 21 : //rang de rapidité
                gpGenerique->drawRecord(gpScreen2, gpKeyboard->getLigneRecord(),
                    gpKeyboard->getColonneRecord()); break;
            case 16 : //effacer record
                gpGenerique->drawEffacer(gpScreen2, gpKeyboard->getLigneVal()); break;
            default : break;
        }
        
        SDL_FreeSurface(gpScreen3);
        gpScreen3 = zoomSurface (gpScreen2, 2, 2, 0);
        SDL_BlitSurface(gpScreen3, &src, gpScreen, &dst);
        
        SDL_Flip(gpScreen);
        
        if (SDL_GetTicks() < lastAnimTime + 20) SDL_Delay(lastAnimTime+20-SDL_GetTicks());
        lastAnimTime = SDL_GetTicks();
    
    }
    
    SDL_FreeSurface(gpScreen2);
    SDL_FreeSurface(gpScreen3);
    
    delete gpEncyclopedie;
    delete gpGenerique;
    delete gpKeyboard;
    delete gpCarte;
    delete gpJeu;
    delete gpAudio;
    
    SDL_ShowCursor(SDL_ENABLE);
    SDL_Quit();
    exit(0);
    
    return 0;
}