xdrm-brackets
/
lab.cpp
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Correction de tous le modele (refactor) + implementation de tous les deplacements (verif) + affichage des erreurs

This commit is contained in:
xdrm-brackets 2016-03-09 14:23:00 +01:00
parent 8c2f003941
commit 851d048e18
23 changed files with 228 additions and 99 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

166
Chess/dep/ChessContext.cpp
View File

@ -24,18 +24,176 @@ void ChessContext::init(){
/* [2] Renvoie le pion qui est en case (x, y)
=========================================================*/
Player* ChessContext::at(const int x, const int y){
Piece* ChessContext::at(const int x, const int y){
// On verifie que c'est pas le Player 1 qui l'a
Piece *p;
p = _p1->at(x, y);
if( p != NULL )
return _p1;
return p;
// On verifie que c'est pas le Player 2 qui l'a
p = _p2->at(x, y);
if( p != NULL )
return _p2;
return p;
return NULL;
}
}
/* [3] Verifie si un deplacement est possible
=========================================================*/
bool ChessContext::checkMove(Piece& p, int x, int y){
/* (1) On verifie que c'est une piece du joueur courant */
Player *current = (_turn=='1') ? _p1 : _p2; // Player courant
Player *enemy = (_turn=='1') ? _p2 : _p1; // Player enemi
// Si c'est pas un pion du courant, on retourne FAUX
if( !current->owns(p) )
return false;
/* (2) On verifie qu'on va pas sur une de nos pieces */
Piece *pieceAtDest = this->at(x, y);
// Si on se deplace sur une de nos pieces
if( pieceAtDest != NULL && current->owns(*pieceAtDest) )
return false;
/* (3) Gestion en fonction du type de piece */
switch( p.gett() ){
case PION: return this->checkPion(p, x, y); break;
case FOU: return this->checkFou(p, x, y); break;
case TOUR: return this->checkTour(p, x, y); break;
case CAVALIER: return this->checkCavalier(p, x, y); break;
case ROI: return this->checkRoi(p, x, y); break;
case REINE: return this->checkReine(p, x, y); break;
}
// On retourne FAUX par defaut
return false;
}
/* [4] Renvoie le joueur courant / enemi
=========================================================*/
Player* ChessContext::getCurrent(){
return (_turn=='1') ? _p1 : _p2;
}
Player* ChessContext::getEnemy(){
return (_turn=='1') ? _p2 : _p1;
}
/* [5] Verifie le deplacement d'un PION
=========================================================*/
bool ChessContext::checkPion(Piece& p, int x, int y){
int way = _turn=='1' ? -1 : 1; // sens de marche
int baseline = _turn=='1' ? 6 : 1; // position initiale
// CAS 1 : Deplacement 1 vers avant
bool move1Front = p.getx()==x && p.gety()+way==y;
// CAS 2 : Deplacement 2 vers avant (si sur ligne depart)
bool move2Front = p.getx()==x && p.gety()+2*way==y && p.gety()==baseline;
// CAS 3 : Mange un pion adjacent (diagonale && 1 case && enemi)
int xDiff = abs(p.getx()-x);
int yDiff = abs(p.gety()-y);
bool eatEnemy = xDiff == yDiff && xDiff==1 && this->at(x, y) != NULL && this->getEnemy()->owns(*this->at(x, y));
return move1Front || move2Front || eatEnemy;
}
/* [6] Verifie le deplacement d'un FOU
=========================================================*/
bool ChessContext::checkFou(Piece& p, int x, int y){
// Deplacement diagonal
bool inDiag = abs(p.getx()-x) == abs(p.gety()-y);
// Si deplacement pas en diagonale, on retourne faux
if( !inDiag ) return false;
// On verifie que la diagonale est degagee
int xstep = (x-p.getx()) / abs(x-p.getx());
int ystep = (y-p.gety()) / abs(y-p.gety());
for( int i = p.getx()+xstep, j = p.gety()+ystep ; i != x && j != y ; i+=xstep, j+=ystep )
if( this->at(i, j) != NULL ) return false;
// Si on a pas retourne faux, on retourne VRAI
return true;
}
/* [7] Verifie le deplacement d'une TOUR
=========================================================*/
bool ChessContext::checkTour(Piece& p, int x, int y){
// Deplacement horizontal ou vertical
bool inLine = ( x==p.getx() || y==p.gety() );
// On verifie que le chemin est degage
bool moveY = p.getx() == x;
int originMovingAxis = (moveY) ? p.gety() : p.getx();
int destMovingAxis = (moveY) ? y : x;
int way = (destMovingAxis-originMovingAxis) / abs(destMovingAxis-originMovingAxis);
for( int i = originMovingAxis+way ; i != destMovingAxis ; i+=way ){
if( moveY ) // si on se deplace sur y
if( this->at(x, i) != NULL ) return false;
else // si on se deplace sur x
if( this->at(i, y) != NULL ) return false;
}
return inLine;
}
/* [8] Verifie le deplacement d'un CAVALIER
=========================================================*/
bool ChessContext::checkCavalier(Piece& p, int x, int y){
bool horizontalL = abs(x-p.getx()) == 2 && abs(y-p.gety()) == 1;
bool verticalL = abs(x-p.getx()) == 1 && abs(y-p.gety()) == 2;
return horizontalL || verticalL;
}
/* [9] Verifie le deplacement d'un ROI
=========================================================*/
bool ChessContext::checkRoi(Piece& p, int x, int y){
bool fouMove = this->checkFou(p, x, y);
bool tourMove = this->checkTour(p, x, y);
bool oneCaseMove = abs(p.getx()-x) + abs(p.gety()-y) == 1;
bool twoCaseMove = abs(p.getx()-x) + abs(p.gety()-y) == 2;
return tourMove&&oneCaseMove || fouMove&&twoCaseMove;
}
/* [10] Verifie le deplacement d'une REINE
=========================================================*/
bool ChessContext::checkReine(Piece& p, int x, int y){
bool fouMove = this->checkFou(p, x, y);
bool tourMove = this->checkTour(p, x, y);
return fouMove || tourMove;
}

18
Chess/dep/ChessContext.h
View File

@ -8,6 +8,7 @@
#include <iostream>
#include <string>
#include <vector>
#include <stdlib.h>
/* (2) Externes */
#include "term.h"
@ -23,12 +24,27 @@
public:
ChessContext();
void init();
Player* at(const int x, const int y);
Piece* at(const int x, const int y);
bool checkMove(Piece& p, int x, int y);
// GETTERS
Player* getCurrent();
Player* getEnemy();
// ATTRIBUTS
char _turn;
Player *_p1;
Player *_p2;
private:
// FONCTIONS UTILITAIRES
bool checkPion(Piece& p, int x, int y);
bool checkFou(Piece& p, int x, int y);
bool checkTour(Piece& p, int x, int y);
bool checkCavalier(Piece& p, int x, int y);
bool checkRoi(Piece& p, int x, int y);
bool checkReine(Piece& p, int x, int y);
};
/* [n] Inclusion du corps

4
Chess/dep/Pieces/Cavalier.cpp
View File

@ -5,10 +5,6 @@ Cavalier::Cavalier(int x, int y) : Piece(CAVALIER, x, y) {
}
// ABSTRACT
bool Cavalier::can(int x, int y){
return true;
}
char Cavalier::getchar(){
return 'C';
}

1
Chess/dep/Pieces/Cavalier.h
View File

@ -19,7 +19,6 @@
Cavalier(int x, int y);
// ABSTRACT
bool can(int x, int y);
char getchar();
};

31
Chess/dep/Pieces/Fou.cpp
View File

@ -5,37 +5,6 @@ Fou::Fou(int x, int y) : Piece(FOU, x, y) {
}
// ABSTRACT
bool Fou::can(int x, int y){
bool inDiag = abs( _x-x ) == abs( _y-y );
// Si deplacement pas en diagonale, on retourne faux
if( !inDiag ) return false;
// On verifie que la diagonale est degagee
int xstep = ( x-_x ) / abs( x-_x );
int ystep = ( y-_y ) / abs( y-_y );
return true;
}
/*bool Fou::can(ChessContext *c, int x, int y){
bool inDiag = abs( _x-x ) == abs( _y-y );
// Si deplacement pas en diagonale, on retourne faux
if( !inDiag ) return false;
// On verifie que la diagonale est degagee
int xstep = ( x-_x ) / abs( x-_x );
int ystep = ( y-_y ) / abs( y-_y );
for( int i = _x+xstep, j = _y+ystep ; i != x && j != y ; i+=xstep, j+=ystep )
if( c->_p1->at(i, j) != NULL ) return false;
return true;
}*/
char Fou::getchar(){
return 'F';
}

3
Chess/dep/Pieces/Fou.h
View File

@ -8,7 +8,6 @@
/* (2) Externes */
#include "Piece.h"
class ChessContext;
/* (3) Namespace */
using namespace std;
@ -20,8 +19,6 @@
Fou(int x, int y);
// ABSTRACT
bool can(int x, int y);
//bool can(ChessContext *c, int x, int y);
char getchar();
};

2
Chess/dep/Pieces/Piece.cpp
View File

@ -27,6 +27,4 @@ ostream& operator<<(ostream& o, const Piece& p){
}
// ABTRACT
bool Piece::can(int x, int y){ return false; }
bool Piece::can(ChessContext *c, int x, int y){ return false; }
char Piece::getchar(){ return '?'; }

2
Chess/dep/Pieces/Piece.h
View File

@ -59,8 +59,6 @@
friend ostream& operator<<(ostream& o, const Piece& p);
// ABSTRACT
virtual bool can(int x, int y);
virtual bool can(ChessContext *c, int x, int y);
virtual char getchar();

4
Chess/dep/Pieces/Pion.cpp
View File

@ -5,10 +5,6 @@ Pion::Pion(int x, int y) : Piece(PION, x, y) {
}
// ABSTRACT
bool Pion::can(int x, int y){
return true;
}
char Pion::getchar(){
return 'P';
}

1
Chess/dep/Pieces/Pion.h
View File

@ -19,7 +19,6 @@
Pion(int x, int y);
// ABSTRACT
bool can(int x, int y);
char getchar();
};

4
Chess/dep/Pieces/Reine.cpp
View File

@ -5,10 +5,6 @@ Reine::Reine(int x, int y) : Piece(REINE, x, y) {
}
// ABSTRACT
bool Reine::can(int x, int y){
return true;
}
char Reine::getchar(){
return 'Q';
}

1
Chess/dep/Pieces/Reine.h
View File

@ -19,7 +19,6 @@
Reine(int x, int y);
// ABSTRACT
bool can(int x, int y);
char getchar();
};

4
Chess/dep/Pieces/Roi.cpp
View File

@ -5,10 +5,6 @@ Roi::Roi(int x, int y) : Piece(ROI, x, y) {
}
// ABSTRACT
bool Roi::can(int x, int y){
return true;
}
char Roi::getchar(){
return 'K';
}

1
Chess/dep/Pieces/Roi.h
View File

@ -19,7 +19,6 @@
Roi(int x, int y);
// ABSTRACT
bool can(int x, int y);
char getchar();
};

4
Chess/dep/Pieces/Tour.cpp
View File

@ -5,10 +5,6 @@ Tour::Tour(int x, int y) : Piece(TOUR, x, y) {
}
// ABSTRACT
bool Tour::can(int x, int y){
return true;
}
char Tour::getchar(){
return 'T';
}

1
Chess/dep/Pieces/Tour.h
View File

@ -19,7 +19,6 @@
Tour(int x, int y);
// ABSTRACT
bool can(int x, int y);
char getchar();
};

6
Chess/dep/Player.cpp
View File

@ -56,7 +56,7 @@ void Player::remPiece(Piece& p){
/* DEBUG */
setfont(BLUE, ITALIC);
cout << "\t\t[-] " << p << " to cimetery of Player " << (_first?1:2);
cout << " [-] " << p << " to cimetery of Player " << (_first?1:2);
setfont();
cout << endl;
@ -64,8 +64,8 @@ void Player::remPiece(Piece& p){
// INITIALISATION DES PIECES DE BASE
void Player::initPieces(){
int y1 = _first ? 0 : 7; // ligne forte
int y2 = _first ? 1 : 6; // ligne de pions
int y1 = _first ? 7 : 0; // ligne forte
int y2 = _first ? 6 : 1; // ligne de pions
// Premier ligne

14
Chess/dep/term.cpp
View File

@ -8,4 +8,18 @@ void clear(){ // efface l'ecran
void setfont(const TERM_COLOR c, const TERM_STYLE s){
cout << "\033[" << s << ";" << c << "m";
}
void err(string msg){
// On affiche le WARNING
setfont(RED, BOLD);
cout << "/!\\ ";
// On affiche le message d'erreur
setfont(RED);
cout << msg << endl;
// On attends l'appui sur une touche
setfont();
sleep(1);
}

3
Chess/dep/term.h
View File

@ -39,7 +39,8 @@
=========================================================*/
void clear();
void setfont(const TERM_COLOR c=DEFAULT, const TERM_STYLE s=NORMAL);
void err(string msg);
/* [n] Inclusion du corps
=========================================================*/
#include "term.cpp"

BIN
Chess/exe
View File

Binary file not shown.

56
Chess/main.cpp
View File

@ -4,11 +4,12 @@
=========================================================*/
int main(){
ChessContext ctx;
// On initialise la partie
ctx.init();
// On continue d'attendre que les joueurs jouent
// tant que la partie n'est pas finie
do{
display_board(ctx);
game_routine(ctx);
@ -96,11 +97,11 @@ void display_board(ChessContext& ctx){
cout << endl << endl;
if( ctx._turn == '1' )
cout << "TOUR DU JOUEUR 1" << endl;
cout << "> TOUR DU JOUEUR 1 <" << endl << "--------------------" << endl;
else if( ctx._turn == '2' )
cout << "TOUR DU JOUEUR 2" << endl;
cout << "> TOUR DU JOUEUR 2 <" << endl << "--------------------" << endl;
else
cout << "PARTIE FINIE" << endl;
cout << "> PARTIE FINIE <" << endl << "-----------------" << endl;
}
@ -112,9 +113,9 @@ void game_routine(ChessContext& ctx){
int dest[2]; // contiendra la position souhaitee
// Contient le joueur courant
Player *curnt = (ctx._turn=='1') ? ctx._p1 : ctx._p2;
Player *curnt = ctx.getCurrent();
// Contient l'ennemi
Player *enemy = (ctx._turn=='1') ? ctx._p2 : ctx._p1;
Player *enemy = ctx.getEnemy();
@ -122,8 +123,6 @@ void game_routine(ChessContext& ctx){
=========================================================*/
chess_input(origin, dest);
cout << "(" << origin[0] << "," << origin[1] << ")" << endl;
/* [3] On verifie qu'un pion est a cette case
=========================================================*/
Piece *toMove = ctx._p1->at(origin[0], origin[1]);
@ -134,30 +133,33 @@ void game_routine(ChessContext& ctx){
if( toMove != NULL )
cout << *toMove << endl;
else{
cout << "Aucune piece sur cette case" << endl;
return;
}
else
err("Aucune piece sur cette case");
/* [4] On verifie qu'il peut atteindre la destination
=========================================================*/
cout << "Can move to dest : " << toMove->can(dest[0], dest[1]) << endl;
bool canMove = ctx.checkMove(*toMove, dest[0], dest[1]);
if( canMove ){
/* [5] On gere le deplacement
=========================================================*/
/* (1) Gestion de si on mange l'ennemi */
Piece *eaten = enemy->at(dest[0], dest[1]);
if( eaten != NULL ) // si piece mangee
enemy->remPiece( *eaten ); // on mange l'ennemi
toMove->move(dest[0], dest[1]); // on deplace la piece
/* [5] On gere le deplacement
=========================================================*/
/* (1) Gestion de si on mange l'ennemi */
Piece *eaten = enemy->at(dest[0], dest[1]);
if( eaten != NULL ) // si piece mangee
enemy->remPiece( *eaten ); // on mange l'ennemi
/* [n] Gestion du tour ou partie finie
=========================================================*/
ctx._turn = (ctx._turn=='1') ? '2' : '1';
toMove->move(dest[0], dest[1]); // on deplace la piece
/* [n] Gestion du tour ou partie finie
=========================================================*/
ctx._turn = (ctx._turn=='1') ? '2' : '1';
}else
err("Mouvement interdit");
}
/* [3] Gestion de la saisie du tour
@ -165,12 +167,12 @@ void game_routine(ChessContext& ctx){
void chess_input(int* origin, int* dest){
char coord[2] = {'\0'};
cout << "Piece to move (XN) : ";
cout << "Piece a deplacer (XN) : ";
cin >> coord;
Piece::decode(coord, origin);
cout << endl;
cout << "Move to (XN) : ";
cout << "Deplacer vers (XN) : ";
cin >> coord;
Piece::decode(coord, dest);
cout << endl;

1
Chess/main.h
View File

@ -9,6 +9,7 @@
#include <string>
#include <vector>
#include <stdlib.h>
#include <unistd.h>
/* (2) Externes */
#include "dep/term.h"

BIN
Chess/main.o
View File

Binary file not shown.