m1.chocobarlite/src/chocobar/combi/ChocoBarArray.java

package chocobar.combi;

import java.util.Vector;

import conf.ChocoConfig;

class ChocoBarArray extends ChocoBar {
	char points[];

	/**
	 * Constructeur d'une barre de choco ayant x carres en largeur
	 * et y carres en hauteur, toute neuve.
	 **/
	private ChocoBarArray() 
	{
		points = new char[size];
		for (int i=0; (i<size); i++) {
			points[i] = (char) height;
		}
	}

	/** Constructeur par copie.
	 */
	private ChocoBarArray(ChocoBarArray old)
	{
		points = new char[size];
		for (int i=0; (i<size); i++) {
			points[i] = old.points[i];
		}
	}

	/** Constructeur par initialisation
	 */
	private ChocoBarArray(char p[])
	{
		points = new char[size];
		for (int i=0; (i<size); i++) {
			points[i] = p[i];
		}
	}

	/**
	 * Affichage de la barre de choco en ligne.
	 **/
	public String toLine()
	{
		String s = "";
		for (int i=0; (i<size); i++) {
			s += (int)points[i] + " ";
		}
		return s;
	}
	
	public String toString()
	{
		return toLine();
	}
	
	/**
	 * Vérifie si le carre (x, y) est déjà mangé.
	 **/
	protected boolean isBroken(int cX, int cY)
	{
		// We are inside what's defined
		return ((height - cY) <= points[cX]);
	}

	/**
	 * Comparaison de barres.
	 * La conversion entre type de ChocoBar n'est pas implémentée 
	 **/
	public boolean equals(ChocoBar comp) { return equals((ChocoBarArray) comp); }
	public boolean equals(ChocoBarArray comp)
	{
		// If the other bar is null we're not equal, since
		// we're obviously not null ;-)
		if (comp==null) {
			return false;
		} 

		// not the same size, isn't the same
		if (comp.size != size || comp.height != height) {
			return false;	
		}
		
		// We don't have a choice now... doing it the hard way	
		for (int i=0; (i<size); i++) {
			if (comp.points[i] != points[i]) {
				return false;
			}
		}

		// If we arrive here... it's the same !
		return true;
	}

	/** Recherche si l'on peut être un fils de la ChocoBar.
	 * La conversion entre type de ChocoBar n'est pas implémentée 
	 */
	public boolean isNextOf(ChocoBar parent) { return isNextOf((ChocoBarArray) parent); }
	public boolean isNextOf(ChocoBarArray parent)
	{
		int eaten = -1;
		for (int i=0; (i<size); i++) {
			// Si le parent est plus mangé que le fils, c'est toujours non !
			if (parent.points[i] > points[i]) {
				return false;
			}
			
			if (eaten == -1) {
				if (parent.points[i] != points[i]) {
					// On a mangé ce carré, les carrés suivants doivent donc être
					// identiquent à celui-ci ou à celui du père
					eaten = points[i];
					// On a traité ce carré, on passe au suivant
					continue;
				}
				// Le carré est identique, suivant !
				continue;
			}
			
			// On a mangé le carré précédent, ils doivent donc être 
			// identiques au point précédents, ou à celui que l'on vient de
			// manger  
			if (parent.points[i] != points[i] && points[i] != eaten) {
				return false;
			}
		}

		// Si on arrive ici, c'est que tout c'est bien passé, a-t-on un carré
		// mangé ?
		return (eaten != -1);
	}

	/** Usine pour construire une liste de ChocoBar.
	 * Cette usine contruit une liste exhaustive et ordonnée de ChocoBar.
	 */
	public static ChocoBar[] genChocoBars(int x, int y)
	{
		// On mets à jour les variables statiques de taille
		ChocoBarArray.size = x; 
		ChocoBarArray.height = y; 
		
		// Calcul du nombre de chocobars différentes existantes
		int nbChocobars = nbChocoBars(x, y);
		
		// Hop, on réserve le tableau de résultat...
		ChocoBar[] chocoBars = new ChocoBar[nbChocobars];
		
		// Il est temps de remplir le tableau !
		
		// Création du tableau pour stocker les valeurs
		char[] points = new char[x];

		boolean fin = false;
		int cbIdx = 0;	
		while (!fin) {
			// Affectation
			chocoBars[cbIdx] = new ChocoBarArray(points);
			cbIdx++;

			// Calcul du suivant :
			
			// On incrémente ... 
			int idx = x-1;
			points[idx] ++;

			// ... et on gère la retenue
			boolean overflow = (points[idx] > y);
			while (points[idx] > y) {
				if (idx == 0) {
					fin = true;
					break;
				}
				points[idx-1] ++;
				idx--;
			}
			// On répercute la modif vers la droite s'il y a eu overflow
			if (overflow) {
				for (int i=idx; (i<x); i++) {
					points[i] = points[idx];
				}
			}
		}
		
		return chocoBars;
	}

	public static ChocoBar[] genChocoBars(Integer x, Integer y)
	{
		return genChocoBars(x.intValue(), y.intValue());
	}
	

	// Implémentation de Vertice
  
	public void setLabel(String l) { }
	public String getLabel() { return "null"; }
	public void setColor(int c) { }
	public int getColor() { return 0; }
}