speelbordtoestand.java

puzzle game with java.very good !

/*
 * Created on 9-okt-2004
 *
 * To change the template for this generated file go to
 * Window>Preferences>Java>Code Generation>Code and Comments
 */
package logic;


import java.util.ArrayList;

import java.util.List;

/**
 * @author gebruiker
 *
 * To change the template for this generated type comment go to
 * Window>Preferences>Java>Code Generation>Code and Comments
 */

public class SpeelBordToestand implements Cloneable {

	/* (non-Javadoc)
	 * @see java.lang.Comparable#compareTo(java.lang.Object)
	 */
	 public static int nmbrOfRows = 3, nmbrOfColumns = 3; //de dimensies van het speelbord
	 
	 public final static int MOVE_EAST = 0, MOVE_WEST = 1, MOVE_SOUTH = 2, MOVE_NORTH = 3;
	 
	 
	 
	 private SpeelBordToestand parent = null;	 
	 private Object speelbordMatrix[][];
	 
	 private int emptyRow = -1, emptyColumn = -1;

	 
	 
	 public SpeelBordToestand()
	 {
	 	speelbordMatrix = new Object[nmbrOfRows][nmbrOfColumns];
	 }
	 
	 public int getNumberOfColumns()
	 {
	 	return nmbrOfColumns;
	 }
	 public SpeelBordToestand getParent()
	 {
	 	return this.parent;
	 }
	 
	 public int getNumberOfRows()
	 {
	 	return nmbrOfRows;
	 }
	 
	 private void setParent(SpeelBordToestand parent)
	 {
	 	this.parent = parent;	 	
	 }

	 
	 /**
	 * @param direction geef op in welke richten verplaatst moet worden... MOVE_EAST = 0, MOVE_WEST = 1, MOVE_SOUTH = 2, MOVE_NORTH = 3
	 * @return boolean geeft true als het om een geldige move gaat, anders return false.
	 */
	public boolean move(int direction)
	 {	
	 	int newEmptyRow = -1, newEmptyColumn = -1;
	 	switch(direction)
	 	{
	 	case MOVE_EAST:
 			newEmptyRow = emptyRow;
 			newEmptyColumn = emptyColumn - 1;
 
	 		break;	 		
		case MOVE_WEST:
			
			newEmptyRow = emptyRow;
			newEmptyColumn = emptyColumn + 1;

			break;
			
		case MOVE_NORTH:
			newEmptyRow = emptyRow + 1;
			newEmptyColumn = emptyColumn;

			break;
			
		case MOVE_SOUTH:
			newEmptyRow = emptyRow - 1;
			newEmptyColumn = emptyColumn;
		
			break;
			
		default:

			return false;
				 	
	 	}
	 	
	 	if(newEmptyRow >= 0 && newEmptyRow < SpeelBordToestand.nmbrOfRows && newEmptyColumn >= 0 && newEmptyColumn < SpeelBordToestand.nmbrOfColumns)
	 	{
	 		this.speelbordMatrix[emptyRow][emptyColumn] = this.speelbordMatrix[newEmptyRow][newEmptyColumn];
			this.speelbordMatrix[newEmptyRow][newEmptyColumn] = null;//het lege vakje naar null laten wijzen
			
			this.emptyRow = newEmptyRow;
			this.emptyColumn = newEmptyColumn;
			return true;
	 	}else
	 	{
	 		return false;
	 	}
	 }
	 
	 public void setTegel(Tegel tegel, int row, int column)
	 {
	 	speelbordMatrix[row][column] = tegel;
	 	
	 	if(tegel == null)
	 	{
	 		this.emptyRow = row;
	 		this.emptyColumn = column;
	 	}
	 }
	 

	 public List getSuccessors()
	 {
	 	List list = new ArrayList();
	 	
	 	SpeelBordToestand successor;
	 	
	 	for(int i= 0; i < 4; i++)//voor elke windstreek een move proberen
	 	{
			successor = (SpeelBordToestand)this.clone();
			
	 		if(successor.move(i))//als de windstreek waarin bewogen wordt goed is =>
	 		{
				successor.setParent(this);
	 			list.add(successor);
	 		}
	 	}	 	 	
	 	return list;
	 }
	 


	 
	 public Object clone()
	 {
	 	SpeelBordToestand clone = new SpeelBordToestand();
	 	clone.setParent(this.getParent());
	 	
	 	//clone.speelbordMatrix = new this.speelbordMatrix;
		clone.speelbordMatrix = new Object[nmbrOfRows][nmbrOfColumns];
		
		for(int i = 0; i < SpeelBordToestand.nmbrOfRows; i++)
		{
		   for(int j = 0; j < SpeelBordToestand.nmbrOfColumns; j++)
		   {
			   clone.speelbordMatrix[i][j] = this.speelbordMatrix[i][j];
		   }			 
		}		
	 	
	 	clone.emptyColumn = this.emptyColumn;
	 	clone.emptyRow = this.emptyRow;	 	
	 	return clone;
	 }
	 
	/* Laat toe om deze toestand van het speelbord te vergelijken met een andere toestand v/h speelbord
	 * (non-Javadoc)
	 * 
	 * @see java.lang.Comparable#compareTo(java.lang.Object)
	 */

	public boolean equals(Object o)
	{
		SpeelBordToestand teVergelijken = (SpeelBordToestand)o;
		
		/*
		 * deze if structuur zal met een simpele test de meeste oproepen naar de compareTo methode
		 * kunnen opvangen, en dus de performantie verbeteren bij veelvuldig gebruik v/d methode.
		 */	
		//stukje optimalisatie
		if(teVergelijken.emptyColumn != this.emptyColumn || teVergelijken.emptyRow != this.emptyRow)
			return false;
		
		
			/*
			 * Hier zullen we de arrays doorlopen en de inhoud ervan met elkaar vergelijken.
			 * 
			 */
			 
			 for(int i = 0; i < SpeelBordToestand.nmbrOfRows; i++)
			 {
				for(int j = 0; j < SpeelBordToestand.nmbrOfColumns; j++)
				{
					Tegel tegelUitDitSpeelbord = (Tegel)this.speelbordMatrix[i][j];
					Tegel tegelUitAnderSpeelbord = (Tegel)teVergelijken.speelbordMatrix[i][j];
					//if(tegelUitAnderSpeelbord == null && tegelUitDitSpeelbord == null)
					//	return true;
					
					if(tegelUitAnderSpeelbord != null && tegelUitDitSpeelbord != null)
					{
						if(tegelUitAnderSpeelbord.equals(tegelUitDitSpeelbord) == false)
							return false;				
					}
					

				}			 
			
		
		}
		return true;	
	
	}

	/**
	 * @param numberOfMoves bepaalt het aantal bewegingen moet gemaakt worden vanuit de originele toestand
	 * @return
	 */
	public SpeelBordToestand shuffle(int numberOfMoves)
	{
		//numberOfMoves--;
	   /*SpeelBordToestand bord = null;
	   List successors;
	   if(bord == null)*/
	   		List successors = this.getSuccessors();
	   	/*else	   
		   successors = bord.getSuccessors();*/
		   
		   
			int random = (int)((double)Math.random() * (double)(successors.size()));
		   
		   	SpeelBordToestand bord = (SpeelBordToestand)successors.get(random);
		   	//bord.setParent(null);
			numberOfMoves--;	
		   
		   
		   while(numberOfMoves > 0)
		   {
				bord = bord.shuffle(); 
				numberOfMoves--;
		   }

		  // if(numberOfMoves == 0)
		  bord.setParent(null); //node mag z'n afkomst niet kennen.
		   	return bord;

	}
	private SpeelBordToestand shuffle()
	{
		List successors = this.getSuccessors();		   
		int random = (int)((double)Math.random() * (double)(successors.size()));
	    return (SpeelBordToestand)successors.get(random);			
	}

	public String toString()
	{
		StringBuffer buffer = new StringBuffer("");
		
		for(int i = 0; i < SpeelBordToestand.nmbrOfRows; i++)
		{
		   for(int j = 0; j < SpeelBordToestand.nmbrOfColumns; j++)
		   {
		   		Tegel tegel = (Tegel)this.speelbordMatrix[i][j];
		   		if(tegel == null)
		   			buffer.append(" ### ");
		   		else
					buffer.append(tegel.toString());
		   }	
		   buffer.append("\n");		 
		}
		return buffer.toString();
	}
	

	
	public String getHtml()
	{
		StringBuffer buffer = new StringBuffer("<html><body><b><table border='1'>");
			
		for(int i = 0; i < SpeelBordToestand.nmbrOfRows; i++)
		{
			buffer.append("<tr>");
		   for(int j = 0; j < SpeelBordToestand.nmbrOfColumns; j++)
		   {
				Tegel tegel = (Tegel)this.speelbordMatrix[i][j];
				if(tegel == null)
					buffer.append("<td bgcolor='black'></td>");
				else
				{
					buffer.append("<td bgcolor='#FF3333'><b><font color='white'>");
					buffer.append(tegel.toString());
					buffer.append("</font></b></td>");
				}		
		   }
		   buffer.append("</tr>");
		}
		
		buffer.append("</table></b></body></html>");
		
		return buffer.toString();		
	}

	public int getManhattanAfstandTot(SpeelBordToestand eenAndereToestand, int maxRowToControl)
	{
		int intManhattanAfstand = 0;
	
		for(int i = 0; i < maxRowToControl; i++)
		{
		   for(int j = 0; j < SpeelBordToestand.nmbrOfColumns; j++)
		   {
				Tegel tegel = (Tegel)eenAndereToestand.speelbordMatrix[i][j]; //tegel uit het andere speelbord
				if(tegel != null)
				{
					intManhattanAfstand += getManhattanAfstandTot(tegel, i, j);
				}
		   }
		}
		/*if(intManhattanAfstand == 0)
		{
			System.out.println("maxRowToControl = " + maxRowToControl +"\neenAndereToestand = \n" + eenAndereToestand.toString()+"\nthis = \n"+ toString());
		}*/
		return intManhattanAfstand;		
	}
	
	
	/*
	 * Bereken per tegel het aantal kolommen + het aantal rijen 
	 * dat ze van hun doelpositie verwijderd zijn.
	 * 
	 * Maak van al deze waarden nogmaals de som = manhattanafstand.
	 */
	public int getManhattanAfstandTot(SpeelBordToestand eenAndereToestand)
	{
		return this.getManhattanAfstandTot(eenAndereToestand, SpeelBordToestand.nmbrOfRows);//standaard rekening houden met alle rijen!
	
	}
	
	/* helper klasse publieke getManhattenAfstand
	 * Ze krijgt een tegel door van het andere bord, met daarbij de kolom
	 * en de rij waarin deze tegel voorkomt in dat andere speelbord.
	 */
	private int getManhattanAfstandTot(Tegel tegelUitAnderBord, int row, int column)
	{
		for(int i = 0; i < SpeelBordToestand.nmbrOfRows; i++)
		{
		   for(int j = 0; j < SpeelBordToestand.nmbrOfColumns; j++)
		   {
				Tegel tegelUitDitBord = (Tegel)this.speelbordMatrix[i][j]; 
				if(tegelUitDitBord != null){ //&& tegelUitAnderBord != null){				
				
					if(tegelUitDitBord.equals(tegelUitAnderBord))
						return makePositive(row - i) + makePositive(column - j);
				}
				/*else if(tegelUitAnderBord == null && tegelUitDitBord == null)
				{
					return makePositive(row - i) + makePositive(column - j);
				}*/
					
		   }
		}
		return 0;
	}
	private int makePositive(int aNumber)
	{
		if(aNumber < 0)
			return aNumber * -1;
		else
			return aNumber;
	}



}