C++ Plateau类代码示例

Case AlgoRegle::deroulerAlgo (Case caseClic)
{
	// On récupère la case cliquée
	caseCliquee = caseClic;

	// On récupère le tableau de cases
	Plateau* plateau = ((CJeuDeDamesApp *)AfxGetApp( ))->getPlateau();
	int nbCases = ((CJeuDeDamesApp *)AfxGetApp( ))->getTaillePlateau();

	for(int i = 0; i < nbCases; i++) {
		for(int j = 0; j < nbCases; j++)
		{
			tableauDeCases[i][j] = plateau->getCaseDuTableau(i,j);
		} 
	}

	// On récupère le joueur en cours
	int joueurEnCours = ((CJeuDeDamesApp *)AfxGetApp( ))->getJoueurEnCours();

	// On applique l'algo spécifique au joueur
	if (joueurEnCours == 1) AlgoADeroulerJoueurBlanc(nbCases);
	if (joueurEnCours == 2) AlgoADeroulerJoueurRouge(nbCases);

	// On met à jour le plateau
	for(int i = 0; i < nbCases; i++) {
		for(int j = 0; j < nbCases; j++)
		{
			plateau->setCaseDuTableau(i, j, tableauDeCases[i][j].getEtat());
		}
	}

	return caseMemo;
}

void testMortJoueur()
{
    Partie partie("Partie 1", 2, 2);
    Joueur *j1 = NULL, *j2 = NULL;
    Plateau *pl = NULL;
    Action *action = new Action();
    Sort *sort = NULL;
    vector<string> listeSort;
    listeSort.push_back("Boule de Feu");
    listeSort.push_back("Sceau de Controle");
    partie.initialiser();
    j1 =  partie.ajouterJoueur("Tarte", "pika", listeSort);
    j2 =  partie.ajouterJoueur("Platon", "Sala", listeSort);
    partie.demarrerPartie();
    pl = partie.getPlateau();
    sort = UsineSort::fabriqueSort("Boule de Feu");
    sort->setProprietaire(j2);
    action->setOrigine(NULL);
    action->setSort(sort);
    action->ajouterCible(pl->getCase(0,0));
    j2->diminuerMana(j2->getManaActuel());
    assert(j2->getManaActuel() == 0);
    partie.effectuerAction(action, j2);
    assert(j2->estMort() == true);
    assert(j2->getManaMaximum() == 0);
    assert(pl->getCase(0,0)->getDefenseActuelle() == pl->getCase(0,0)->getDefenseInitiale());
    delete action;
    delete sort;
}

void Puissance4::newPartie (){
  Plateau *p = Partie::getPartie()->getPlateau();
  Joueur *j = Partie::getPartie()->getJoueurs();
  int choix_pos = 0;
    int i=0;
  j->next();
  do{
    j->next();
    cout << "Joueur "<< j->getCourrant()<< endl;
    affichage();
    do{
      i = 0;
      cout << "choisissez une position : " << endl;
      cin >> choix_pos;
      for(;i < nbLignes && not p->hasPion(i, choix_pos); i++){}
    }while(choix_pos < 0 || 
	   choix_pos > nbLignes || 
	   (i == 0 && p->hasPion(choix_pos, i)));
    i = (i==0)? 0 : i-1;
    if(j->getCourrant() == 0){
      p->mettrePionDansCase(pO, i, choix_pos);
    } else {
      p->mettrePionDansCase(pX, i, choix_pos);
    }
  }while(not hasP4(i, choix_pos));
  affichage();
  cout << "Le joueur " << j->getCourrant() << "a gagné "<<  endl; 
  
}

int testParachutage(Pion& pion, int x_fin, int y_fin, int joueur_actif, Plateau plateau)
{
	if(joueur_actif==1)
	{
		if(y_fin==0)//pas de parachutage en derniere ligne
			return -1;
		if((pion.getNom()==Cavalier)&&(y_fin<=1))//pas de cavalier sur les deux dernières lignes
			return -1;
	}	
	if(joueur_actif==2) //idem pour joueur 2
	{
		if(y_fin==8)
			return -1;
		if((pion.getNom()==Cavalier)&&(y_fin>=7))
			return -1;
	}
	
	if(pion.getNom()==Soldat) //vérification qu'il n'y a pas deux soldats non promus dans la même colonne
	{
		for(int i = 0; i<9;i++)
		{
			if((plateau.getPion(x_fin,i).getNom()==Soldat)&&(plateau.getPion(x_fin,i).getProprietaire()==joueur_actif))
				return -1;
		}
	}
	else return 0;
	
}

int main()
{
	Plateau p;
	char choix;
	bool nouveau_jeu = false;

	while (nouveau_jeu == false)
	{
		p.plateau_centraliser();
		cout << "voulez vous continuer à jouer (O/N)" << endl;
		cin >> choix;
		if (choix == 'O' || choix == 'o')
		{
			
			nouveau_jeu = false;
		}
		else if (choix == 'N' || choix == 'n' )
		{
			cout << "le jeux va s'arrêté" << endl;
			nouveau_jeu = true;
		}
	}

	system("PAUSE");
	return 0;
}

void AngePuissant::modifierCase(int &ligne, int &colonne, Plateau &p) {

    p.gameboard()[_ligne][_colonne].setCase(false, true);

    p.gameboard()[ligne][colonne].setCase(false, false);
 
    _ligne = ligne, _colonne = colonne;  //Je sauvegarde mes coordonées afin de faire les test plsu tard dans incorrect.
}

// la methode qui va tester si l'ange est arrivé aux coins des cases
bool Ange::gagne(Plateau &plateau) {

    if (_ligne == 0 || _ligne == plateau.dim() - 1 || _colonne == 0 || _colonne == plateau.dim() - 1) {
        plateau.affiche();
        cout << "Bravo !! vous avez gagné \n" << endl;
        return true;
    }
    return false;
}

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    Plateau w;
    w.setWindowIcon(QIcon(":/img/img/icone.ico"));
    w.setWindowTitle("Bonne nuit !");
    w.show();

    return a.exec();
}

int main()
{
	cout << "\n Coucou ! \t" << endl;
    Plateau plateau = Plateau();
    plateau.afficher();

    cout << endl;
    plateau(4,4).afficher();
    plateau(4,4).modifPion(-1);
    plateau(4,4).afficher();
    plateau.afficher();
    cout << endl;
}

void Renderer::render(surface& surf, Plateau& plateau) {

	surf.fill(color::black());
	back.blit(surf,100,0);

	int blanc=0;
	int noir=0;
	for(size_t i=0;i<plateau.pions.size();i++) {
		for(size_t j=0;j<plateau.pions[i].size();j++) {
			if(plateau.pions[i][j]==Pion::black()) {
				black.blit(surf,100+((int)i*60),(int)j*60);
				noir++;
			} else if(plateau.pions[i][j]==Pion::white()) {
				white.blit(surf,100+((int)i*60),(int)j*60);
				blanc++;
			}
		}
	}
	if(plateau.gameFinished()) {
		string aff = "Joueur: "
				+lexical_cast<string>(blanc)+" Ordinateur: "
				+lexical_cast<string>(noir);
		surface text = thefont.render_shaded(aff,color::cyan(),color::grey());
			text.blit(surf,(surf.get_width()/2)-(text.get_width()/2)
				,(surf.get_height()/2)-(text.get_height()/2));
	}

	surf.flip();
}

int main()
{
	srand(time(NULL));
	initscr();
	noecho();
	curs_set(FALSE);

	keypad(stdscr, TRUE);
	nodelay(stdscr, TRUE);
	intrflush(stdscr, TRUE);
	Plateau p;

	p.init_plateau();
	p.game();

	endwin();

	return 0;
}

void Puissance4::affichage(){
  Plateau *p = Partie::getPartie()->getPlateau();
  for(int i = 0; i < nbLignes; i++){
    for(int j = 0; j< nbColonnes ; j++){
      if(p->hasPion(i, j)){
	switch(p->getCase(i, j)->getPion()->getJoueur()){
	  case 0: cout << "O "; break;
	  case 1: cout << "X "; break;
	}	
      }else {
	cout << ". ";
      }
    }
    cout << endl;
  }
  for(int j = 0; j< nbLignes; j++){
    cout << j << " " ;
  }
  cout << endl;
}

bool AngePuissant::incorrect(int &ligne, int &colonne, Plateau &plateau) {

    if (ligne < 0 || ligne > plateau.dim() - 1 || colonne < 0 || colonne > plateau.dim() - 1) {
        cout << "Cette case n'existe pas " << endl;
        return false;

    }else if(!plateau.gameboard()[ligne][colonne].broken() && !plateau.gameboard()[ligne][colonne].free()) {
        cout << "Vous êtes deja dessus !!\n" << endl;
        return false;

    } else if (plateau.gameboard()[ligne][colonne].broken() && !plateau.gameboard()[ligne][colonne].free()) {
        cout << "Case deja detruite !!\n" << endl;
        return false;
        
    }else{
        
        if (_colonne - _puissance <= colonne && colonne <= _colonne + _puissance && _ligne - _puissance <= ligne && ligne <= _ligne + _puissance) {
            return true;

        }else{
            cout << "Vous pouvez bouger que de " << _puissance << " cases" << endl;
            return false;
        }
    }
}

int main(void) {
	//! Déclaration des variables utiles au main
	Plateau plateau; //! Creation d'un plateau
	list<Deplacement> regulier, nulls; //! Liste temporaires de déplacements
	int tour = BLANC; //! Le premier tour sera effectué par les blancs : 0x00
	Deplacement deplacement; //! Stoque le déplacement en cours
	bool deplacementBool;

	//! Initialisation des deux joueurs IA
	IAJoueur noir(NOIR, 3);
	IAJoueur blanc(BLANC, 1);

	//! Iniialisation du plateau par defaut en le remplissant
	plateau.initialisationPlateau();

	printf("###################################################\n");
	printf("Jeux d'echec, computer vs. computeur. - m1_76\n"
			"Basé sur un algorithme d'elagage alpha-beta.\n"
			"(optimisation de l'algorithme MinMax)\n"
			"Profondeur de recherche (modifiable en dur) :\n"
			"--- NOIR : 4\n"
			"--- BLANC : 1\n"
			"ATTENTION : Etre patient, certains déplacements peuvent etre longs !\n");
	printf("###################################################\n");
	printf("##### Appuyez sur une touche pour commencer ! #####\n");
	getchar();
	for(;;) {

		//! Affichage du plateau
		plateau.affichage();

		//! Tour par tour
		if(tour)
			deplacementBool = noir.getDeplacement(plateau, deplacement);
		else
			deplacementBool = blanc.getDeplacement(plateau, deplacement);

		if(!deplacementBool) //! Si aucun déplacement n'est possible:deplacementBool=0
			break;

		//! Si un déplacement est trouvé alors on le get
		regulier.clear();
		nulls.clear();
		plateau.getDeplacements(tour, regulier, regulier, nulls);

		//Execution des mouvements nulls di de maintenance
		for(list<Deplacement>::iterator i=nulls.begin(); i!=nulls.end(); ++i){ //! On parcours la liste de déplacement nulls
			plateau.deplacement(*i);
		}

		//! On vient executer le déplacement sur le plateau
		plateau.deplacement(deplacement);

		//! On affiche le déplacement au dessu du plateau
		deplacement.affichage();

		//! On vient passer le tour à l'adverssair : 0x10 ^ tour
		tour = CHANGE_COULEUR(tour);
	}

	//! Get le Status du tour pour voir si il y a echec ou pat
	JoueurEchec::Status status = plateau.getJoueurStatus(tour);

	switch(status) //! En fonction du status du joueur en cour
	{
		case JoueurEchec::EchecMat:
			printf("EchecMat -- Les Noirs ont gagné\n");
			break;
		case JoueurEchec::Pat:
			printf("Pat -- Aucun vainqueur\n");
			break;
	}
}

Plateau::Plateau(const Plateau &obj) {

    _dim = obj._dim;
    _gameboard = obj.gameboard();
}