Thread: Changing the attribute of an instance object of a class that's declared in another package and whose variable is constructed by its parent class

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 30
at Board.legalDownSpec(Board.java:74)
at Board.legalDown(Board.java:122)
at Piece.fall(Piece.java:92)
at Tetris.dropPiece(Tetris.java:88)
at Tetris.main(Tetris.java:80)


It seemed to have improved slightly, but I don't understand why 30 is outofbound... like what the hell?

console program with recent modifications

public class collisiontest
{
 
	public static boolean legalDownSpec(int currentX, int currentY, int[][] board, int[][] shape, int index)
	{
	   int x = currentX+1;
	   int y = currentY;
 
	   //int row = array.length-1; row >= 0; row--
 
	   for (int row = index; row > 0; row--)
	   {
	   	for (int col = index; col > 0; col--)
	   	{
 
 
 
	   		if (shape[row][col] == 1 && board[x+row][y+col] == 0)
	   		{
 
 
	   		}
	   		else
	   		{
	   			if (shape[row][col] == 0 && board[x+row][y+col] == 1)
	   			{
 
	   			}
	   			else
	   			{
 
	   			    if(shape[row][col] ==0 && board[x+row][y+row] == 0)
	   			    {
 
	   			    }
 
	   			    else
	   			    {
 
	   				return false;
	   			    }
	   			}
	   		}
	   	}
	   }
 
 
    return true;
	}
 
 
 
 
	public static boolean legalDown(int currentX, int currentY, int[][] board, int[][] shape)
	{
	   int x = currentX+1;
	   int y = currentY;
 
 
	   if (x >= 3)
	   {
	   	int index = x;
	   	index = 6-index;
 
	   for (int row = 1; row < 4; row++)
	   {
	   	for(int col = 0; col < 4; col++)
	   	{
 
	   	    if(shape[row][col] == 1 && x+row >= 6)
	   		{
	   			return false;
	   		}
	   	}
	   }
 
	   	return legalDownSpec(currentX, currentY, board, shape, index);
 
	   	//call special code here
	   }
 
	   for (int row = 0; row < 4; row++)
	   {
	   	for(int col = 0; col < 4; col++)
	   	{
 
	   		if (shape[row][col] == 1 && board[x+row][y+col] == 0)
	   		{
 
 
	   		}
	   		else
	   		{
	   			if (shape[row][col] == 0 && board[x+row][y+col] == 1)
	   			{
 
	   			}
	   			else
	   			{
 
	   			    if(shape[row][col] ==0 && board[x+row][y+row] == 0)
	   			    {
 
	   			    }
 
	   			    else
	   			    {
 
	   				return false;
	   			    }
	   			}
	   		}
	   	}
	   }
 
 
    return true;
	}
 
 
public static void main(String[] args)
{
  		int [][] m1 =
		{{1,0,0,0},
		 {1,0,0,0},
		 {1,0,0,0},
		 {1,0,0,0},
		};
 
 
		int[][] board =
		{{0,0,0,0},
		 {0,0,1,1},
		 {0,0,1,1},
		 {0,0,1,1},
		 {0,0,1,1},
		 {0,0,1,1},
		 {1,0,1,1},
		};
 
			int[][] board3 =
		{{0,0,0,0},
		 {0,0,1,1},
		 {0,0,1,1},
		 {0,0,1,1},
		 {0,0,1,1},
		 {0,0,1,1},
		 {1,1,1,1},
		};
 
		int[][] board2 =
		{{0,0,0,0},
		 {0,0,0,0},
		 {0,0,0,0},
		 {0,0,0,0},
		 {0,0,0,0},
		 {0,0,0,0},
		 {0,0,0,0},
		};
 
int currentX = 6; //3 causes exception
int currentY = 0;
 
		System.out.println(legalDown(currentX, currentY, board, m1));
 
		System.out.println(legalDown(currentX, currentY, board3, m1));
 
		System.out.println(legalDown(currentX, currentY, board2, m1));
 
 
 
 
 
 
 
 
 
 
}
}

--- Update ---

oK... this line in legalDownSpec causes the exception... so... I can't think of a way to solve it

if (shape[row][col] == 0 && board[x+row][y+col] == 1)

I did the following, because I thought it would solve it, but it didn't

for (int row = index; row > 0; row--)
{
for (int col = index; col > 0; col--)
{

--- Update ---

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 32
at Board.addArray(Board.java:49)
at Piece.fall(Piece.java:103)
at Tetris.dropPiece(Tetris.java:88)
at Tetris.main(Tetris.java:80)

Process completed.

Well... it reached the bottom at the least

damnit ... OK it kinda works now, but when I rotate an object there are 2 shapes that are created...
lol

public class Piece extends Grid {
	int currentX;     // current X location on the board
	int currentY;  // current Y location on the board
 
 
	public Piece(int shape[][]) {
		super(shape);
		currentX = 7;
		currentY = 5;
		updateLocation();
	}
 
 
 
	void updateSize() {
		setSize(Tetris.SQUARE_SIZE*getColumns(),
				Tetris.SQUARE_SIZE*getRows());
	}
 
	void updateLocation() {
		setLocation(Tetris.SQUARE_SIZE*currentX,
					(int) (Tetris.SQUARE_SIZE*currentY));
	}
 
	synchronized void moveDown() {
 
	}
 
	synchronized void moveLeft() {
 
		currentX--;
		updateLocation();
 
	}
 
	synchronized void moveRight() {
 
		currentX++;
		updateLocation();
 
	}
 
    synchronized void rotateClockwise(Board board) {
 
    	int [][] a = getContents();
		int [][] b = board.getContents();
 
	    if(Board.legalDown(currentX, currentY, b, a) && Board.isNotOutOfBoundDown(currentX, currentY, b, a))
	    {
	    int [][] transpose = new int[4][4];
	    transpose = transpose(contents);
	    contents = multiplyMatrix(transpose);
 
	    updateLocation();
	    updateSize();
	    }
    }
 
 
 
 
	synchronized void rotateCounterclockwise(Board board) {
 
		int [][] a = getContents();
		int [][] b = board.getContents();
 
		if(Board.legalDown(currentX, currentY, b, a) && Board.isNotOutOfBoundDown(currentX, currentY, b, a))
		{
		int [][] transpose2 = new int[4][4];
		transpose2 = multiplyMatrix(contents);
		transpose2 = transpose(transpose2);
		contents = transpose2;
 
		updateLocation();
	    updateSize();
		}
	}
 
	void fall(Board board) {
 
		int [][] a = getContents();
		int [][] b = board.getContents();
 
 
		while(Board.legalDown(currentX, currentY, b, a) && Board.isNotOutOfBoundDown(currentX, currentY, b, a))
		{
			currentY++;
			updateLocation();
	    	updateSize();
	    	Tetris.sleep(2000);
 
 
 
 
		}
		Board.addArray(currentX, currentY, b, a);
		updateSize(); //necessary?
 
		//Tetris.sleep(2000);
	}
 
	synchronized void drop(Board board) {
		int [][] a = getContents();
		int [][] b = board.getContents();
 
		if(Board.legalDown(currentX, currentY, b, a) && Board.isNotOutOfBoundDown(currentX, currentY, b, a))
		{
		currentY++;
		updateLocation();
		}
		else
		{
		Board.addArray(currentX, currentY, b, a);
		updateLocation(); //necessary?
		}
 
	}
 
  public static int [][] transpose(int [][] m1)
  {
  	  int m = 4;
  	  int n = 4;
  	  int c = 0;
  	  int d = 0;
 
  	  int[][] transpose = new int [n][m];
 
 
  	  for ( c = 0 ; c < m ; c++ )
      {
	      for ( d = 0 ; d < n ; d++ )
	      {
	         transpose[d][c] = m1[c][d];
	      }
      }
 
      return transpose;
 
  }
 
  public static int [][] multiplyMatrix(int [][] m1)
  {
  		int [][] m2 =
		{{0,0,0,1},
		 {0,0,1,0},
		 {0,1,0,0},
		 {1,0,0,0},
		};
 
 
    int[][] result = new int[4][4];
 
    // multiply
    for (int i=0; i<4; i++)
      for (int j=0; j<4; j++)
        for (int k=0; k<4; k++)
        result[i][j] += m1[i][k] * m2[k][j];
 
 
    return result;
  }
 
    }

maybe it's because I called updateLocation 2 times sometimes.. I don't know or that rotate() and fall() both fills an array... I don't know..

Originally Posted by Norm

Time for more debugging to see what the code is doing.

synchronized void moveLeft() {
 
		currentX--;

That code says that x is a column. Not a row: board[x+row]

Any tip for debugging?

Uhmm, I had called addArray in two different places, now I only have it in fall();

and I remove updateLocation() in 2 places

Now, it kinda works, but there's an unusual behavior with the "I" block when I rotate it...

Do you have any idea what's causing this?

I think I need to update shape when I rotate. Do you have any idea how to do this? Because it fills up the array as if they weren't rotated at all... Do I have to write a new method?

Some information that might be helpful

In the Piece class, you'll want methods for moving the piece down, moving it left and right by one column, and for rotating the piece clockwise and counterclockwise 90 degrees. (You want these methods to be synchronized so that two modifications of the piece aren't attempted concurrently.) When a piece is rotated, the array changes shape (somewhat similar, but not exactly like, the transpose algorithm we did in class). Note: Each time you move a piece, call its updateLocation method so that it gets painted properly on the board. Similarly, each time you change the shape of a piece, call its updateSize method. You should only move or rotate a piece if it would be legal to do so. (The methods of the Board will be helpful for determining legality of a board position.)

 
	public static void addArray(int currentX, int currentY, int[][] board, int[][] shape)
	{
	   int x = currentY;
	   int y = currentX;
 
	   for (int row = 0; row < 4; row++)
	   {
	   	for(int col = 0; col < 4; col++)
	   	{
 
 
	   		if (shape[row][col] == 1 )
	   		{
 
				board[x+row][y+col] = 1;
	   		}
 
 
	   	}
	   }
	}

	void fall(Board board) {
 
		int [][] a = getContents();
		int [][] b = board.getContents();
 
 
		while(Board.legalDown(currentX, currentY, b, a) && Board.isNotOutOfBoundDown(currentX, currentY, b, a))
		{
			currentY++;
			updateLocation();
	    	updateSize();
	    	Tetris.sleep(2000);
 
 
 
 
		}
		Board.addArray(currentX, currentY, b, a);
 
 
		//Tetris.sleep(2000);
	}

    synchronized void rotateClockwise(Board board) {
 
    	int [][] a = getContents();
		int [][] b = board.getContents();
 
	    if(Board.legalDown(currentX, currentY, b, a) && Board.isNotOutOfBoundDown(currentX, currentY, b, a))
	    {
	    int [][] transpose = new int[4][4];
	    transpose = transpose(contents);
	    contents = multiplyMatrix(transpose);
 
	    updateLocation();
	    updateSize();
	    }
    }
 
 
 
 
	synchronized void rotateCounterclockwise(Board board) {
 
		int [][] a = getContents();
		int [][] b = board.getContents();
 
		if(Board.legalDown(currentX, currentY, b, a) && Board.isNotOutOfBoundDown(currentX, currentY, b, a))
		{
		int [][] transpose2 = new int[4][4];
		transpose2 = multiplyMatrix(contents);
		transpose2 = transpose(transpose2);
		contents = transpose2;
 
		updateLocation();
	    updateSize();
		}
	}

i don't see anything wrong with the rotate methods

how can i debug the rotate methods?

--- Update ---

it's because the method fall takes content before it rotates... so how do I fix this?

int [][] a = getContents();

--- Update ---

while(Board.legalDown(currentX, currentY, b, a) && Board.isNotOutOfBoundDown(currentX, currentY, b, a))
{
a = getContents();
b = board.getContents();

currentY++;
updateLocation();
updateSize();
Tetris.sleep(2000);




}

ok fixed

--- Update ---

now I need to fix the error when the pieces goes out of bound in the left or in the right side...

ummm... any suggestion??

--- Update ---

I should have writen a legal() method for both left and right and down... but i didn't and I can't think of a way to do that... now, i am kinda screwed up, because I can't think of a simple way to do this....

--- Update ---

ok the easiest way is to check for legalRight and legalLeft before checking for legalDown, right? I can't think of a better way? This way I won't get any exception right?

--- Update ---

I have a question... say we have

a shape

defined as

1 0 0 0 0
1 0 0 0 0
1 0 0 0 0
1 0 0 0 0

Does it matter if 0 goes out of bound? No, right? It just that when you check for the board[][] the index for col must be between 0 and 15, right?

Help!! When I print the array of board, I only get 0s. Do you know why?

The pieces aren't there...

ok nevermind. geeze. ummm when i rotate the objects the shape aren't updated for some reason and they land before they hit anything

--- Update ---

Originally Posted by Norm

Why do you think there should be non-0s in the array? Where are there non-0 values assigned to elements of the array?

umm i just commented out printarray for some reason

--- Update ---



yeah i think there is something wrong with my legal method, i think i need to update it inside by using the getter method...

--- Update ---

Hmm yeah, now the problem is that sometimes rotating it make it land before it should. sometimes it doesn't... do you hav any clue as to what is wrong? i think it has to do with the update methods

 
 
public class Piece extends Grid {
	int currentX;     // current X location on the board
	int currentY;  // current Y location on the board
 
 
	public Piece(int shape[][]) {
		super(shape);
		currentX = 7;
		currentY = 5;
		updateLocation();
	}
 
 
 
	void updateSize() {
		setSize(Tetris.SQUARE_SIZE*getColumns(),
				Tetris.SQUARE_SIZE*getRows());
	}
 
	void updateLocation() {
		setLocation(Tetris.SQUARE_SIZE*currentX,
					(int) (Tetris.SQUARE_SIZE*currentY));
	}
 
	synchronized void moveDown() {
 
	}
 
	synchronized void moveLeft() {
 
		currentX--;
		updateLocation();
 
	}
 
	synchronized void moveRight() {
 
		currentX++;
		updateLocation();
 
	}
 
    synchronized void rotateClockwise(Board board) {
 
    	int [][] a = getContents();
		int [][] b = board.getContents();
 
	    if(Board.legalDown(currentX, currentY, b, a) && Board.isNotOutOfBoundDown(currentX, currentY, b, a))
	    {
	    int [][] transpose = new int[4][4];
	    transpose = transpose(contents);
	    contents = multiplyMatrix(transpose);
 
	    updateLocation();
	    updateSize();
	    }
    }
 
 
 
 
	synchronized void rotateCounterclockwise(Board board) {
 
		int [][] a = getContents();
		int [][] b = board.getContents();
 
		if(Board.legalDown(currentX, currentY, b, a) && Board.isNotOutOfBoundDown(currentX, currentY, b, a))
		{
		int [][] transpose2 = new int[4][4];
		transpose2 = multiplyMatrix(contents);
		transpose2 = transpose(transpose2);
		contents = transpose2;
 
		updateLocation();
	    updateSize();
		}
	}
 
	void fall(Board board) {
		int stopLoop = 0;
 
		while(stopLoop == 0)
		{
 
 
		int [][] a = getContents();
		int [][] b = board.getContents();
 
 
		while(Board.legalDown(currentX, currentY, b, a) && Board.isNotOutOfBoundDown(currentX, currentY, b, a))
		{
			a = getContents();
		    b = board.getContents();
 
			currentY++;
			updateLocation();
	    	updateSize();
	    	Tetris.sleep(2000);
 
 
 
 
		}
		Board.addArray(currentX, currentY, b, a);
		stopLoop++;
		}
 
 
		//Tetris.sleep(2000);
	}
 
	synchronized void drop(Board board) {
 
		int [][] a = getContents();
		int [][] b = board.getContents();
 
		if(Board.legalDown(currentX, currentY, b, a) && Board.isNotOutOfBoundDown(currentX, currentY, b, a))
		{
 
		currentY++;
		updateLocation();
		}
 
 
 
	}
 
  public static int [][] transpose(int [][] m1)
  {
  	  int m = 4;
  	  int n = 4;
  	  int c = 0;
  	  int d = 0;
 
  	  int[][] transpose = new int [n][m];
 
 
  	  for ( c = 0 ; c < m ; c++ )
      {
	      for ( d = 0 ; d < n ; d++ )
	      {
	         transpose[d][c] = m1[c][d];
	      }
      }
 
      return transpose;
 
  }
 
  public static int [][] multiplyMatrix(int [][] m1)
  {
  		int [][] m2 =
		{{0,0,0,1},
		 {0,0,1,0},
		 {0,1,0,0},
		 {1,0,0,0},
		};
 
 
    int[][] result = new int[4][4];
 
    // multiply
    for (int i=0; i<4; i++)
      for (int j=0; j<4; j++)
        for (int k=0; k<4; k++)
        result[i][j] += m1[i][k] * m2[k][j];
 
 
    return result;
  }
 
    }

--- Update ---

Do you know why sometimes a block stops before it should? Is it because of simultaneous processes that conflict with each other or it's just my code? What are the possibilities.

--- Update ---



ok so the problem is in this:

public static boolean legalDown(int currentX, int currentY, int[][] board, int[][] shape)
	{
	   int x = currentY+1;
	   int y = currentX;
 
 
 
 
	   //printArray(board);
 
 
 
 
 
	   if (x > 28)
	   {
 
 
	   	return legalDownSpec(currentX, currentY, board, shape);
 
 
 
	   }
 
	   for (int row = 0; row < 4; row++)
	   {
	   	for(int col = 0; col < 4; col++)
	   	{
 
 
	   		if (shape[row][col] == 1 && board[x+row][y+col] == 0)
	   		{
 
 
	   		}
	   		else
	   		{
	   			if (shape[row][col] == 0 && board[x+row][y+col] == 1)
	   			{
 
	   			}
	   			else
	   			{
 
	   			    if (shape[row][col] ==0 && board[x+row][y+row] == 0)
	   			    {
 
	   			    }
 
	   			    else
	   			    {
	   			    System.out.println("NOT spec");
 
	   				return false;
	   			    }
	   			}
	   		}
	   	}
	   }
 
 
 
 
	    return true;
	}

I get: notspec like 6 times when it should have been only 1; furthermore, it stops a block before it should... What is the problem? I need an expert here...

Is it because of legalDown() and rotateCounterClockWise() running concurrently?

--- Update ---

the tetris block stops before it lands on another block or the floor...

legalDown is supposed to say if it will land or not.

0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000001000000000
0000011000000000
0000010000000000
0000000000000000
0000000111110000
0000000111000000

It landed before it should have because of legalDown()...

Originally Posted by Norm

Those terms are for a user viewing the game being played.
Try explaining the problem in programming terms using variable names and their contents, etc.

currentPiece.contents should not stop falling (fall()) until it touches the last row of board or another contents

--- Update ---

Ohhhh... I knoww!!

Can you tell me how I can do this:

a = getContents();
b = board.getContents();

Inside of:

 
	public static boolean legalDown(int currentX, int currentY, int[][] board, int[][] shape)
	{
	   int x = currentY+1;
	   int y = currentX;
 
 
 
 
	   printArray(board);
 
 
 
 
 
	   if (x > 28)
	   {
 
 
	   	return legalDownSpec(currentX, currentY, board, shape);
 
 
 
	   }
 
	   for (int row = 0; row < 4; row++)
	   {
	   	for(int col = 0; col < 4; col++)
	   	{
 
 
	   		if (shape[row][col] == 1 && board[x+row][y+col] == 0)
	   		{
 
 
	   		}
	   		else
	   		{
	   			if (shape[row][col] == 0 && board[x+row][y+col] == 1)
	   			{
 
	   			}
	   			else
	   			{
 
	   			    if (shape[row][col] ==0 && board[x+row][y+row] == 0)
	   			    {
 
	   			    }
 
	   			    else
	   			    {
	   			    System.out.println("NOT spec");
 
	   				return false;
	   			    }
	   			}
	   		}
	   	}
	   }
 
 
 
 
	    return true;
	}

I need to update the variables..., but I can't since the method is static, but doing so would fix the problem.

for some reason i can't remove static...


this doesn't work:

board = board.getContents();
shape = currentPiece.getContents();

--- Update ---

Ok, actually I could remove static, but these

board = board.getContents();
shape = currentPiece.getContents();

still give me

error: cannot find symbol
error: cannot find symbol

How do we refer to the currentPiece object inside drop()?

synchronized void drop(Board board) {

int [][] a = getContents();
int [][] b = board.getContents();


if(Board.legalDown(currentX, currentY, b, a) && Board.isNotOutOfBoundDown(currentX, currentY, b, a))
{

currentY++;
updateLocation();
}



}

I wrote the following:

Piece currentPiece = currentPiece; this inside


but it doesn't work, is there any way to do this?

--- Update ---

Originally Posted by Norm

The variables need to be defined and in scope at the statement where you try to access them.

I made a suggestion earlier about writing a test program with some classes for testing this problem.
You need to try that to see how to solve the problem.

I do know how to access variables from other classes, but in this case, it a different story, because I have to access an Object that wasn't parsed as an argument inside the method from which I want to make the method call.

--- Update ---

If I write:

drop(board, currentPiece) instead of

currentPiece.drop(board);

will the method still work as intended? I think the variables currentX and currentY won't be able to be accessed directly, right? So I would have to do:

currentPiece.currentX++

instead of

currentX++

right?

Originally Posted by Norm

It is very hard to follow your posts.
Can you write a smaller complete testing program with some classes, methods and variables that demonstrates the problem you are having?
This is getting to be a waste of time trying to make sense of the isolated pieces of code that have been posted.
Make a small complete program that shows the problem. Without that I'm outa here.

synchronized void drop(Board board) {

int [][] a = getArray();
int [][] b = board.getArray();


//I don't have currentObject here... what do I need to write?


if(Board.goDown(currentX, currentY, b, a, board, currentObject))
{

currentY++;
updateXY();
}



}

the method call is currentObject.drop(board) and we can't pass in currentObject as a variable.

Is there any easy way of doing this or I just have to rewrite the entire code?