Thread: Please help with code for a method, much appreciated!!

public boolean gameOver()
/*
Pre-condition: none
Post-condition: true is returned if the game is
over because the grid is empty
Informally: return whether or not the game is over
*/
{
int r,c;
Location l;

trace("gameOver: gameOver starts");

COMPLETE ME!!!

trace("gameOver: gameOver ends");
return true;
}

thanks for the reply but i am unsure how to implement the code to define the method

/*
Pre-condition: none
Post-condition: true is returned if the game is
over because the grid is empty
Informally: return whether or not the game is over
*/

{
int r,c;
Location l;
 
trace("gameOver: gameOver starts");
 
COMPLETE ME!!!
 
trace("gameOver: gameOver ends");
return true;
}

I have to fill in the areas where is marked "Complete me!!!" I cant do any of them!! any help would be much appreciated, thanks

import java.awt.*;
 
 
public class Grid implements GridInterface
{
	//finals
	private final int DIMENSION=21;						// number of squares in grid
	private final int MAXIMUM_ROW=6;					// number of rows in grid
	private final boolean TRACING=true;				// do we want to see trace output?
 
	// properties
	private int dimension;			// the number of rows in the grid
	private Square board[];			// all the Squares within the grid
 
 
	public Grid()
	/*
		Constructor method.
		Pre-condition: none
		Post-condition: a 21 element grid is created in
						which all squares are occupied		
		Informally: create a full 6 row triangular grid
	*/
	{
		int i,r,c;
		Location l;
 
		trace("Grid: constructor begins");
 
		dimension=MAXIMUM_ROW;		
		board=new Square[DIMENSION];
 
		trace("Grid: building squares");
		i=0;
		for (r=0; r<MAXIMUM_ROW; r++)
		{
			for (c=0; c<=r; c++)
			{
				l=new Location(r+1,c+1);
				board[i]=new Square(l);
				i++;
			}
		}
 
		trace("Grid: constructor ends");
	}
 
	private int findIndex(Location l)
	/*
		Locate index in grid which corresponds to square at
		given location
		Pre-condition: location is within the current grid
		Post-condition: the index of the element with the given
						location is returned
		Informally: identify which array element is at the given
					location
	*/
	{
		int i,r,c;
 
		trace("findIndex: findIndex starts");	
 
		i=0;
		for (r=1;r<l.getRow();r++)
		{
			for (c=1;c<=r;c++)
			{
				i++;
			}
		}
 
		i+=(l.getColumn()-1);
 
		trace("findIndex: findIndex ends");
		return i;
	}
 
 
	public void setSquare(Location l, Square s) throws IllegalGridException
	/*
		Set method for an element of the "board" instance variable.
		Pre-condition: the given Square object and the board array
					   are defined
		Post-condition: the given square is assigned to an element
						of the Grid object selected according to
						the given location within the grid
		Informally: insert the given square into the grid at the
					appropriate location, an exception is thrown if
					the location is not within the grid
	*/
	{
		int i;
 
      	trace("setSquare: setSquare starts");
 
	COMPLETE ME!!!
      	trace("setSquare: setSquare ends");
	}
 
 
	public Square getSquare(Location l) throws IllegalGridException
	/*
		Get method for an element of the "board" instance variable.
		Pre-condition: the board array is defined
		Post-condition: the Square object at the appropriate
						element of the "board" selected according
						to the given Location value is returned
		Informally: return the square of the grid at the given
					location, an exception is thrown if the
					location is not within the grid
	*/
	{
		int i;
 
      	trace("getSquare: getSquare starts");
 
COMPLETE ME!!!
	}
 
 
	public void setDimension(int d)
	/*
		Set method for the "dimension" instance variable.
		Pre-condition: the given Dimension value is defined and
					   valid
		Post-condition: the instance variable "dimension" is
						assigned the given Dimension value
		Informally: assign the given dimension to the Grid object
	*/
	{
      	trace("setDimension: setDimension starts");
 
COMPLETE ME!!!
 
      	trace("setDimension: setDimension ends");
	}
 
 
	public int getDimension()
	/*
		Get method for "dimension" instance variable.
		Pre-condition: none
		Post-condition: the value of the Grid object's dimension
						field is returned
		Informally: return the current grid's dimension
	*/
	{
      	trace("getDimension: getDimension starts and ends");
 
COMPLETE ME!!!
	}
 
 
	public void emptySquare(Location l)
	/*
		Pre-condition: the given Location value is within
					   the bounds of the current Grid
					   object
		Post-condition: the square at the position in the
						grid indicated by the given Location
						value is altered to be empty
		Informally: update the square at the nominated location
					of the grid with the empty symbol
	*/
	{
		Square q;
 
      	trace("emptySquare: emptySquare starts");
 
COMPLETE ME!!!
 
      	trace("emptySquare: emptySquare ends");
	}
 
 
	public boolean isEmpty(Location l)
	/*
		Pre-condition: the given Location value is within
					   the bounds of the current grid
		Post-condition: a Boolean value is returned which
						represents whether the symbol of
						the square of the current Grid
						object with the given Location
						value is empty
		Informally: return whether or not the square at
					the given location is empty
	*/
	{
      	trace("isEmpty: isEmpty starts and ends");
COMPLETE ME!!!
	}
 
 
	public boolean validMove(Location l)
	/*
		Pre-condition: none
		Post-condition: true is returned if the given
						Location is within the bounds of
						the current Grid object, false is
						returned if it is not
		Informally: return whether or not the given
					location lies within the current grid
	*/
	{
		int r;
		int c;
 
      	trace("validMove: validMove starts and ends");
 
COMPLETE ME!!!
	}
 
 
	public boolean gameOver()
	/*
		Pre-condition: none
		Post-condition: true is returned if the game is
						over because the grid is empty
		Informally: return whether or not the game is over
	*/
	{
		int r,c;
		Location l;
 
      	trace("gameOver: gameOver starts");
 
COMPLETE ME!!!
 
      	trace("gameOver: gameOver ends");
  		return true;
    }
 
 
	public String toString()
	/*
		Pre-condition: none
		Post-condition: a String representation of the grid
						is returned
		Informally: find a String representation of the grid
	*/
	{
		String s="[";
		int r,c;
		Location l;
 
 
      	trace("toString: toString starts");
 
		for (r=1;r<=dimension;r++)
		{
			for (c=1;c<=r;c++)
			{
				l=new Location(r,c);
				if (isEmpty(l))
				{
					s+=" ";
				}
				else
				{
					s+="X";
				}
			}
			if (r != dimension)
			{
				s+=",";
			}
		}
 
		s+="]";
 
      	trace("toString: toString ends");
		return s;
	}
 
 
	public void showGrid(Display s)
	/*
		Pre-condition: the Screen parameter is correctly defined
		Post-condition: the screen representation of the Grid
						object is displayed on the given Screen
		Informally: display the current grid
	*/
	{
		int i;
 
      	trace("showGrid: showGrid starts");
 
		for (i=0; i<DIMENSION; i++)
		{
			board[i].showSquare(s,getDimension());
		}
 
		trace("showGrid: grid is " + toString());
 
      	trace("showGrid: showGrid ends");
 	}
 
	public void trace(String s)
	/*
		Provide trace output.
		Pre-condition: none
		Post-condition: if trace output is desired then the given String
						parameter is shown on the console
		Informally: show the given message for tracing purposes
	*/
	{
		if (TRACING)
		{
			System.out.println("Grid: " + s);
		}
	}
}

the variables values have to be gotten from are: int r, c and location l. I assume the boolean returns true if there are null in all values of the grid at locations l from the r (row) and c (column) arrays? Sorry but am very new to java language

great. you legend

Originally Posted by mrjavajava

great. you legend

That's the best thing you've said so far.

I'm having a bit of trouble with this..

public void emptySquare(Location l)
	/*
		Pre-condition: the given Location value is within
					   the bounds of the current Grid
					   object
		Post-condition: the square at the position in the
						grid indicated by the given Location
						value is altered to be empty
		Informally: update the square at the nominated location
					of the grid with the empty symbol
	*/
	{
		Square q;
 
      	trace("emptySquare: emptySquare starts");
 
		//COMPLETE ME!!!
 
		assert(!validMove(l));
 
		i=findIndex(l);
		board[i]=q;
		q=null;
 
 
 
      	trace("emptySquare: emptySquare ends");
	}

I'm not sure how to implement square q. Does this seem right to you?

Thanks