/**
* Methode utile pour la classe Pion. modifie le fetdeplacementPossible selon la presence d'une
* piece adverse en diagonale par rapport a la direction d'avancee du pion
*
* @param caseActuelle :case du pion
* @param res : le getdeplacement de la piece
*/
private void filtrerpresenceAdversaireDiagonale(Case caseActuelle, ArrayList<Case> casePossible) {
for (int i = 0; i < casePossible.size(); i++) {
Case c = casePossible.get(i);
Case caseEchiquier = chercherCase(c.getPosition());
if (caseEchiquier.getPosition().getLargeur() == caseActuelle.getPosition().getLargeur() + 1
|| caseEchiquier.getPosition().getLargeur()
== caseActuelle.getPosition().getLargeur() - 1) {
if (caseEchiquier.estVide()) {
casePossible.remove(c);
i--;
} else if (caseEchiquier.getPiece().getCamp().equals(caseActuelle.getPiece().getCamp())) {
casePossible.remove(c);
i--;
}
} else {
if (!caseEchiquier.estVide()) {
casePossible.remove(c);
i--;
}
}
}
}
/**
* regarde si la case e est menace par le camp c
*
* @param c
* @param e
* @return
*/
public boolean estMenace(String camp, Case e) {
boolean estmenace = false;
Vector<Case> listePieceAdverse = new Vector<Case>();
if (camp.equals("noir")) {
listePieceAdverse = listerPiecesNoires(this.listePieceEnJeu);
} else if (camp.equals("blanc")) {
listePieceAdverse = listerPiecesBlanches(this.listePieceEnJeu);
} else {
System.out.println("case noirblanc");
}
for (int i = 0; i < listePieceAdverse.size(); i++) // pour toutes les pieces adverses
{
ArrayList<Case> deplacementPieceAdverse = filtreGeneral(listePieceAdverse.get(i));
for (int j = 0;
j < deplacementPieceAdverse.size();
j++) { // pour tous les deplacements possibles de la piece courante
if (deplacementPieceAdverse
.get(j)
.getPosition()
.equals(e.getPosition())) { // Si les deux cases ont la même position
estmenace = true;
}
}
}
return estmenace;
}
private void filtrePourReine(Case caseActuelle, ArrayList<Case> casePossible) {
ArrayList<Case> diagonale = new ArrayList<Case>();
ArrayList<Case> droite = new ArrayList<Case>();
for (int i = 0; i < casePossible.size(); i++) {
Case c = casePossible.get(i);
if (c.getPosition().getHauteur() == caseActuelle.getPosition().getHauteur()
|| c.getPosition().getLargeur() == caseActuelle.getPosition().getLargeur()) droite.add(c);
else diagonale.add(c);
}
filtrePourTour(caseActuelle, droite);
filtrePourFou(caseActuelle, diagonale);
casePossible.clear();
casePossible.addAll(droite);
casePossible.addAll(diagonale);
}
/**
* regarde si la case e est menace par le camp c
*
* @param c
* @param e
* @return liste de piece qui menace la case
*/
public Vector<Case> estMenacePar(String camp, Case e) {
Vector<Case> listePieceAdverse = new Vector<Case>();
Vector<Case> listePieceMenacante = new Vector<Case>();
if (camp.equals("noir")) {
listePieceAdverse = listerPiecesNoires(this.listePieceEnJeu);
} else if (camp.equals("blanc")) {
listePieceAdverse = listerPiecesBlanches(this.listePieceEnJeu);
} else { // TODO: creer une exception
}
for (int i = 0; i < listePieceAdverse.size(); i++) { // pour toutes les pieces adverses
ArrayList<Case> deplacementPieceAdverse = filtreGeneral(listePieceAdverse.get(i));
for (int j = 0;
j < deplacementPieceAdverse.size();
j++) { // pour tous les deplacements de chaque piece
if (deplacementPieceAdverse
.get(j)
.getPosition()
.equals(e.getPosition())) { // la case e est égale a la case que l'on veut tester
listePieceMenacante.add(listePieceAdverse.get(i));
}
}
}
return listePieceMenacante;
}
public String getNotationAlgebrique(Case caseDepart, Case caseArrivee) {
String nota = new String();
nota =
nota.concat(
String.valueOf(caseDepart.getPosition().getHauteur())
+ String.valueOf(caseDepart.getPosition().getLargeur()));
if (caseArrivee.estVide()) nota = nota.concat("-");
else nota = nota.concat("x");
nota =
nota.concat(
String.valueOf(caseArrivee.getPosition().getHauteur())
+ String.valueOf(caseArrivee.getPosition().getLargeur()));
return nota;
}
public void validerDeplacement(Position depart, Case caseDepart, Case caseSauvegardeArrivee) {
if (!caseSauvegardeArrivee.estVide()) // si il y avait une piece a l'arrivee
{
this.listePiecePrises.add(
caseSauvegardeArrivee.getPiece()); // on ajoute la piece dans la liste des pieces prises
for (int j = 0; j < listePieceEnJeu.size(); j++) // pour toutes les pieces en jeu
if (this.listePieceEnJeu
.get(j)
.getPiece()
.equals(
caseSauvegardeArrivee.getPiece())) // si il y a une case egale a la case d'arrivee
this.listePieceEnJeu.remove(j); // on la supprime
}
/* if(!caseSauvegardeArrivee.estVide())//si il y a une piece a l'arrivee
{
this.listePiecePrises.add(caseSauvegardeArrivee.getPiece());//on ajoute la piece dans la liste des pieces prises
for(int j=0; j< listePieceEnJeu.size();j++)//pour toutes les pieces en jeu
if(this.listePieceEnJeu.get(j).getPiece().equals(caseSauvegardeArrivee.getPosition()))//si il y a une case egale a la case d'arrivee
this.listePieceEnJeu.remove(j);//on la supprime
}*/
if (caseDepart.getPiece().getClass().getSimpleName().equals("Roi")) {
if (caseDepart.getPiece().getCamp().equals("noir")) {
this.caseRoiNoir.setPosition(caseSauvegardeArrivee.getPosition());
} else {
this.caseRoiBlanc.setPosition(caseSauvegardeArrivee.getPosition());
}
}
if (!caseDepart.getPiece().isDejaBouge()) caseDepart.getPiece().setDejaBouge(true);
}
private void filtrePourTour(Case caseActuelle, ArrayList<Case> casePossible) {
ArrayList<Case> caseGauche = new ArrayList<Case>();
ArrayList<Case> caseDroite = new ArrayList<Case>();
ArrayList<Case> caseHaut = new ArrayList<Case>();
ArrayList<Case> caseBas = new ArrayList<Case>();
for (int i = 0; i < casePossible.size(); i++) {
Case c = casePossible.get(i);
if (caseActuelle.getPosition().getHauteur() == c.getPosition().getHauteur()
&& caseActuelle.getPosition().getLargeur() > c.getPosition().getLargeur()) {
caseGauche.add(c);
}
if (caseActuelle.getPosition().getHauteur() == c.getPosition().getHauteur()
&& caseActuelle.getPosition().getLargeur() < c.getPosition().getLargeur()) {
caseDroite.add(c);
}
if (caseActuelle.getPosition().getHauteur() < c.getPosition().getHauteur()
&& caseActuelle.getPosition().getLargeur() == c.getPosition().getLargeur()) {
caseHaut.add(c);
}
if (caseActuelle.getPosition().getHauteur() > c.getPosition().getHauteur()
&& caseActuelle.getPosition().getLargeur() == c.getPosition().getLargeur()) {
caseBas.add(c);
}
}
for (int i = 0; i < caseGauche.size(); i++) {
Case caseEchi = chercherCase(caseGauche.get(i).getPosition());
if (!caseEchi.estVide())
for (int j = 0; j < caseGauche.size(); j++) {
if (caseGauche.get(i).getPosition().getLargeur()
> caseGauche.get(j).getPosition().getLargeur()) {
caseGauche.remove(caseGauche.get(j));
j--;
}
/*if(!diagBasGauche.get(i).estVide()){
System.out.println("attention");
for(int j=0; j < diagBasGauche.size()-1;j++){
if(diagBasGauche.get(i).getPosition().getLargeur()>diagBasGauche.get(j).getPosition().getLargeur())
{
diagBasGauche.remove(diagBasGauche.get(j));
j--;
}
}}
diagBasGauche.remove(diagBasGauche.get(i));*/
}
}
for (int i = 0; i < caseDroite.size(); i++) {
Case caseEchi = chercherCase(caseDroite.get(i).getPosition());
if (!caseEchi.estVide())
for (int j = 0; j < caseDroite.size(); j++) {
if (caseDroite.get(i).getPosition().getLargeur()
< caseDroite.get(j).getPosition().getLargeur()) {
caseDroite.remove(caseDroite.get(j));
j--;
}
}
}
for (int i = 0; i < caseHaut.size(); i++) {
Case caseEchi = chercherCase(caseHaut.get(i).getPosition());
if (!caseEchi.estVide()) {
for (int j = 0; j < caseHaut.size(); j++) {
if (caseHaut.get(i).getPosition().getHauteur()
< caseHaut.get(j).getPosition().getHauteur()) {
caseHaut.remove(caseHaut.get(j));
j--;
}
}
}
}
for (int i = 0; i < caseBas.size(); i++) {
Case caseEchi = chercherCase(caseBas.get(i).getPosition());
if (!caseEchi.estVide())
for (int j = 0; j < caseBas.size(); j++) {
if (caseBas.get(i).getPosition().getHauteur()
> caseBas.get(j).getPosition().getHauteur()) {
caseBas.remove(caseBas.get(j));
j--;
}
}
}
casePossible.clear();
casePossible.addAll(caseGauche);
casePossible.addAll(caseDroite);
casePossible.addAll(caseHaut);
casePossible.addAll(caseBas);
}
/**
* fait un deplacement sans test d'echec
*
* @param caseDepart
* @param caseArrivee
*/
public boolean deplacerReussi(Case caseDepart, Case caseArrivee) {
ArrayList<Case> plop = new ArrayList<Case>();
boolean depEffectue = false;
plop = filtreGeneral(caseDepart);
for (int i = 0; i < plop.size(); i++) {
if (plop.get(i).getPosition().equals(caseArrivee.getPosition())) {
Case sauvegardeArrivee =
new Case(
new Position(
caseArrivee.getPosition().getHauteur(),
caseArrivee.getPosition().getLargeur()));
Piece p = changerCase(caseDepart, caseArrivee);
sauvegardeArrivee.setPiece(p);
for (int j = 0; j < listePieceEnJeu.size(); j++) // pour toutes les pieces en jeu
if (this.listePieceEnJeu.get(j).getPosition().equals(caseDepart.getPosition())) {
this.listePieceEnJeu
.get(j)
.setPosition(
new Position(
sauvegardeArrivee.getPosition().getHauteur(),
sauvegardeArrivee.getPosition().getLargeur())); // on met a jour la position
}
if (caseArrivee.getPiece().getClass().getSimpleName().equals("Roi")) {
if (caseArrivee.getPiece().getCamp().equals("noir")) {
this.caseRoiNoir.setPosition(sauvegardeArrivee.getPosition());
} else {
this.caseRoiBlanc.setPosition(sauvegardeArrivee.getPosition());
}
}
int res = echec();
if (res == 11 && campActif.equals("noir")) {
changerCase(caseArrivee, caseDepart);
for (int j = 0; j < listePieceEnJeu.size(); j++) // pour toutes les pieces en jeu
if (this.listePieceEnJeu
.get(j)
.getPosition()
.equals(
new Position(
sauvegardeArrivee.getPosition().getHauteur(),
sauvegardeArrivee.getPosition().getLargeur()))) {
this.listePieceEnJeu
.get(j)
.setPosition(caseDepart.getPosition()); // on met a jour la position
}
if (caseDepart.getPiece().getClass().getSimpleName().equals("Roi")) {
if (caseDepart.getPiece().getCamp().equals("noir")) {
this.caseRoiNoir.setPosition(caseDepart.getPosition());
} else {
this.caseRoiBlanc.setPosition(caseDepart.getPosition());
}
}
} else if (res == 12 && campActif.equals("blanc")) {
changerCase(caseArrivee, caseDepart);
for (int j = 0; j < listePieceEnJeu.size(); j++) // pour toutes les pieces en jeu
if (this.listePieceEnJeu
.get(j)
.getPosition()
.equals(
new Position(
sauvegardeArrivee.getPosition().getHauteur(),
sauvegardeArrivee.getPosition().getLargeur()))) {
this.listePieceEnJeu
.get(j)
.setPosition(caseDepart.getPosition()); // on met a jour la position
}
} else {
validerDeplacement(caseDepart.getPosition(), caseArrivee, sauvegardeArrivee);
depEffectue = true;
}
}
}
return depEffectue;
}
