StackOverflowError

import java.util.List;
import java.util.LinkedList;

enum Couleur {Noir,Blanc};

public class Case
{		
    private final int x;
    private final int y;
    private final Couleur c;
    
    /**
     * Représente une case par ses coordonnés (x,y).
     * La case est noire si x+y est paire, blanche sinon.
     * @param x la ligne entre 0 et 7 (normalement représentée par les lettres A...H)
     * @param y la colonne entre 0 et 7 (normalement représentée par les chiffres 1...8)
     * @throws Exception si x ou y n'est pas dans l'intervalle [0,7]
     */
    public Case(int x,int y) throws Exception
    {
        if (x<0 || x>7 || y<0 || y>7)
        	throw new Exception();
        
        this.x=x;
        this.y=y;
        
        c = ((x+y)%2==0) ? Couleur.Noir : Couleur.Blanc;
    }

    /**
     * @return l'indice de ligne entre 0 et 7
     */
    public int getX()
    {
        return x;
    }
    
    /**
     * @return l'indice de colonne entre 0 et 7
     */
    public int getY()
    {
        return y;
    }
    
    /**
     * @return la couleur de la case (a1=Noire, les autres par alternance)
     */
    public Couleur getCouleur()
    {
    	return c;
    }
        
    @Override
    public String toString()
    {
    	return (char) ('a'+x)+""+(char) ('1'+y);
    }
    
    @Override
    public boolean equals(Object o)
    {
    	if (o instanceof Case)
    	{
    		Case c = (Case) o;
    		return x==c.x && y==c.y;
    	}
    	else	return false;
    }
}

// ajout d'une case à la liste si elle existe et est à proximité du roi
private void ajoutSiAccessible(List<Case> liste, int dx, int dy)
{
	try 
	{			
		liste.add(new Case(position.getX()+dx,position.getY()+dy)); // la case est libre
	}
	catch (Exception e) // la case n'existe pas
	{
	}
}

List<Case> casesAccessiblesSaufRoi() 
{
	List<Case> liste = new LinkedList<Case>();

	ajoutSiAccessible(liste,-1,-1);
	ajoutSiAccessible(liste,-1, 0);
	ajoutSiAccessible(liste,-1, 1);
	ajoutSiAccessible(liste, 0,-1);
	ajoutSiAccessible(liste, 0, 1);
	ajoutSiAccessible(liste, 1,-1);
	ajoutSiAccessible(liste, 1, 0);
	ajoutSiAccessible(liste, 1, 1);
	
	return liste;
}

List<Case> casesAccessibles() 
{		
	return casesAccessiblesSaufRoi().removeAll(roiAdverse.accessiblesSaufRoi());
}

List<Case> casesDisponibles()
{
	List<Case> liste = new LinkedList<Case>();
	
	for (Case c : casesAccessibles()) // parmi les cases accessibles
		if (echiquier.getCase(c).estLibre() // si la case est libre 
		 || echiquier.getCase(c).getPiece().getCamp()!=this.getCamp()) // ou si la pièce est un adversaire
			liste.add(c); // alors on peut s'y mettre
			
	return liste;
}

public ArrayList<int[]> nouveauDéplacement(){       
     

  ArrayList<int[]> al = new ArrayList<int[]>();       
  int dl, dc;      
  boolean bool;     

  // Prend chacune des huits directions itérativement  
  for(int i = 0;i<8;i++) {       

   //Prend le déplacement selon les lignes (valeur comprise entre -1 et 1)  
     dl = directions[2*i];       

  // Prend le déplacement selon les colonnes (valeur comprise entre -1 et 1)  
     dc = directions[2*i+1];     
    
 // Vérifie que le déplacement laisse le roi dans l'échiquier, que la pièce à laquelle  
 // aboutit le déplacement est ennemie ou vide, et, dans ce cas-là, si elle n'est pas  
 // menacée par une pièce ennemie  
     bool = dedans(ln+dl,col+dc) && *la pièce en ln+dl et col+dc n'est pas de la même couleur* && pasEnPrise(ln+dl,col+dc);  

// Réinitialise testeEnPrise       
     testeEnPrise = false;    

// Ajoute le déplacement sous forme d'un tableau de deux entiers s'il est valable  
     if (bool) {       
        al.add(new int[] {dl,dc});       
     }       
  }       
  return al;       
 }       
        
 public boolean pasEnPrise(int l, int c) {       

// La méthode retourne vrai sans test si la récursivité croisée a déjà eu une  
// occurrence  
  if (testeEnPrise) {return true;}  

// Attribue vrai à testeEnPrise si c'est la première occurrence de la récursivité croisée       
  testeEnPrise = true;       

  boolean b = true;       
  ArrayList<Pièce> ennemis = *pièces ennemies*;       

// Prend chacune des pièces ennemies  
  for (int i = 0; i < ennemis.size() && b; i++) {       
     Pièce p = ennemis.get(i);    

     // Calcule les déplacements possibles de la pièce    
     ArrayList<int[]> al = p.nouveauDéplacement();    

     // Vérifie pour chaque déplacement s'il n'aboutit à la case (ligne l, colonne c)  
     for(int j = 0; j < al.size() && b;j++) {       
        b &= (p.ln+al.get(j)[0] != l || p.col+al.get(j)[1] != c);       
     }       
  }       
  return b;       
 }   
  

public class Échiquier {
	final static Case[][] cases = new Case[8][8];
	final static ArrayList<Pièce>[] camps = new ArrayList[2];
	Roi[] rois = {new Roi(1,5,0,this),new Roi(8,5,1,this)};
	
	Échiquier() throws Exception {
		
                //Je remplis mon "cases" de cases avec les bonnes positions
		for (int i = 0; i < 8; i++) {
			for(int j = 0; j < 8;j++) {
				cases[i][j] = new Case(i+1,j+1);
			}
		}

                 //Là, je fais une boucle où j'ajoute les pièces dans "camps"

                //Pour chaque pièce p comprise dans les camps, je dis à la pièce sur laquelle elle est posée que c'est p qui est sur elle
                for (int i = 0; i < 2; i++) {
			for(int j = 0; j < camps[i].size();j++) {
				Case c = getCase(camps[i].get(j).dép);
				c.setPosée(camps[i].get(j));
			}
		}

//Petite méthode pour raccourcir le code :
        public Case getCase(Case c) {
---->		return cases[c.getLn()-1][c.getCol()-1];
	}