MultiDimensional array doesnt work

[Dmitri Makovetskiy]

i want the array to run from one place in diagnol to another place in the array.

i set the arguments. here they are

     .
      int rowStart=3;
   
      int rowEnd=5;
  
      int columnStart=3;
 
      int columnEnd=5;

   

       
.
      int columnX=columnEnd-columnStart;

      int rowY=rowEnd-rowStart;

   			if (rowY>0 && columnX>0){
						

							
						
									while(pieces[rowStart+a][columnStart+a]==null && columnStart+a>columnEnd && rowStart+a>rowEnd){						
									
										a++;
									}
									
									System.out.println("BishopSouthEast   This is a "+a); 
									
							
				
						 if(a<rowY && a<columnX){
							 BishopNorthEast=false;
						       System.out.println("BishopSouthEast   This is a "+a+" and this is the square places disparity "+ rowY); 
						       System.out.println("BishopSouthEast    This is a "+a+" and this is the square places disparity "+ columnX);
						       System.out.println("BishopSouthEast   This is a This value is false");
					            }
					            else{
					       	BishopNorthEast=true;
					        System.out.println("BishopSouthEast       This is a "+a+" and this is the square places disparity "+ columnX); 
					        System.out.println("BishopSouthEast       This is a "+a+" and this is the square places disparity "+ rowY); 
					        System.out.println("BishopSouthEast        This is a This value is true");
					            }
				
	} 

why the a is returned always as 0 and not being counted even once?
(i tested, there are nulls only from point to point)
sorry for the messy code

[David Newton]

Instead of apologizing for the messy code, why not just format it in a reasonable way? Almost every IDE will do this for you at the push of a button. Here's what it looks like in a way that makes it intelligible.

        int rowStart = 3;
        int rowEnd = 5;
        int columnStart = 3;
        int columnEnd = 5;

        int columnX = columnEnd - columnStart;
        int rowY = rowEnd - rowStart;

        if (rowY > 0 && columnX > 0) {
            while ((pieces[rowStart + a][columnStart + a] == null) && ((columnStart + a) > columnEnd) && ((rowStart + a) > rowEnd)) {
                a++;
            }

            System.out.printf("BishopSouthEast: a=%d%n", a);

            boolean bishopNorthEast;
            if (a < rowY && a < columnX) {
                bishopNorthEast = false;
                System.out.printf("BishupSouthEast=%s, a=%d, disparity1=%d, disparity2=%d%n", bishopNorthEast, a, rowY, columnX);
            } else {
                bishopNorthEast = true;
                System.out.printf("BishupSouthEast=%s, a=%d, disparity1=%d, disparity2=%d%n", bishopNorthEast, a, columnX, rowY);
            }
        }

Unfortunately, without knowing what the code is trying to do, or with some idea of what should be in pieces, or knowing what the start value of a is, it's difficult to answer your question. I'm also a little confused by the usage of both bishopNorthEast and bishopSouthEast--I don't know if this is a cut-and-paste error, or if it's meaningful in some way.

[Dmitri Makovetskiy]

David Newton wrote:Instead of apologizing for the messy code, why not just format it in a reasonable way? Almost every IDE will do this for you at the push of a button. Here's what it looks like in a way that makes it intelligible.

        int rowStart = 3;
        int rowEnd = 5;
        int columnStart = 3;
        int columnEnd = 5;

        int columnX = columnEnd - columnStart;
        int rowY = rowEnd - rowStart;

        if (rowY > 0 && columnX > 0) {
            while ((pieces[rowStart + a][columnStart + a] == null) && ((columnStart + a) > columnEnd) && ((rowStart + a) > rowEnd)) {
                a++;
            }

            System.out.printf("BishopSouthEast: a=%d%n", a);

            boolean bishopNorthEast;
            if (a < rowY && a < columnX) {
                bishopNorthEast = false;
                System.out.printf("BishupSouthEast=%s, a=%d, disparity1=%d, disparity2=%d%n", bishopNorthEast, a, rowY, columnX);
            } else {
                bishopNorthEast = true;
                System.out.printf("BishupSouthEast=%s, a=%d, disparity1=%d, disparity2=%d%n", bishopNorthEast, a, columnX, rowY);
            }
        }

Unfortunately, without knowing what the code is trying to do, or with some idea of what should be in pieces, or knowing what the start value of a is, it's difficult to answer your question. I'm also a little confused by the usage of both bishopNorthEast and bishopSouthEast--I don't know if this is a cut-and-paste error, or if it's meaningful in some way.

newton. i think i got it to work. the problem is shown in the code.

   	public boolean piecesCollision(ChessPiece[][]pieces,int rowStart,int columnStart ,int columnEnd,int rowEnd) { 
// chesspiece array doesnt respond to the algorithm well. (the algorithm works. i can move the bishop to wherever 
// i want. but the bishop piece doesnt notice that there are other pieces on the board.. it assumes everything is null. why is that?)
		
		int columnX=columnEnd-columnStart;
		
		int rowY=rowEnd-rowStart;  
		     
			      boolean BishopNorthEast=false;
				  boolean BishopNorthWest=false;
				  boolean BishopSouthWest=false;
				  boolean BishopSouthEast=false;
				  
				
		                         
					
				
		                      int a=0;
		           
////////////////////BishopNorthWest////////////////////////////////////	BishopNorthWest//////////////////////////////
					//1--
					if(columnX<0 && rowY<0){
							
					
								while(pieces[rowStart-1-a][columnStart-1-a]==null && (columnStart-1-a)!=columnEnd && (rowStart-1-a)!=rowEnd){						
									
										a++;
									}
									a=a+1;
				          
					   if(rowY<0 ){
			     rowY=rowY*(-1); 
			         }
					  if(columnX<0){
			    columnX=columnX*(-1); 
			         }
						 if(a<rowY && a><columnX){
							 BishopNorthWest=false;
						       System.out.println("BishopNorthWest     A is "+a+" and this is the square places disparity "+ rowY); 
						       System.out.println("BishopNorthWest      A is "+a+" and this is the square places disparity "+ columnX);
						       System.out.println("BishopNorthWest      value is flase");
					            }
					            else{
					       	BishopNorthWest=true;
					        System.out.println("BishopNorthWest      A is "+a+" and this is the square places disparity "+ columnX); 
					        System.out.println("BishopNorthWest     A is "+a+" and this is the square places disparity "+ rowY);
					        System.out.println("BishopNorthWest          value is true");
					            }		
                      			
			     rowY=rowY*(-1); 
			        
			    columnX=columnX*(-1); 
			       } 					
	///////////////////////////////	BishopSouthEast //////////////////////////////////////////////////BishopSo
					//2++
					if (rowY>0 && columnX>0){
						

							
						
									while(pieces[rowStart+1+a][columnStart+1+a]==null && (columnStart+1+a)!=columnEnd && (rowStart+1+a)!=rowEnd){						
									
										a++;
									}
									a=a+1;
									
									System.out.println("BishopSouthEast   This is a "+a); 
									
							
				
						 if(a<rowY && a><columnX){
							 BishopNorthEast=false;
						       System.out.println("BishopSouthEast   This is a "+a+" and this is the square places disparity "+ rowY); 
						       System.out.println("BishopSouthEast    This is a "+a+" and this is the square places disparity "+ columnX);
						       System.out.println("BishopSouthEast   This is a This value is false");
					            }
					            else{
					       	BishopNorthEast=true;
					        System.out.println("BishopSouthEast       This is a "+a+" and this is the square places disparity "+ columnX); 
					        System.out.println("BishopSouthEast       This is a "+a+" and this is the square places disparity "+ rowY); 
					        System.out.println("BishopSouthEast        This is a This value is true");
					            }
				
	}
///////////////////////	BishopSouthWest//////////////////////////////////////	BishopNorthEast///////////////////
			       if(rowY>0 && columnX<0){
			   		
									while(pieces[rowStart+1+a][columnStart-1-a]==null && (columnStart-1-a)!=columnEnd && (rowStart+1+a)!=rowEnd){						
									
										a++;
									}
									a=a+1;
								
								
									
					
			        if(rowY<0){
			     rowY=rowY*(-1); 
			         }
					  if(columnX<0){
			    columnX=columnX*(-1); 
			         }
					 if(a<rowY  && a><columnX){
						 BishopSouthWest=false;
					       System.out.println("BishopSouthWest           This is a "+a+" and this is the square places disparity "+ rowY); 
					       System.out.println("BishopSouthWest           This is a "+a+" and this is the square places disparity "+ columnX);
					       System.out.println("BishopSouthWest           This is a This value is false");
				            }
				            else{
				       	BishopSouthWest=true;
				        System.out.println("BishopSouthWest   This is a "+a+" and this is the square places disparity "+ columnX); 
				        System.out.println("BishopSouthWest    This is a "+a+" and this is the square places disparity "+ rowY); 
				        System.out.println("BishopSouthWest     This is a This value is true");
				            }
	}
				
///////////////////////////BishopNorthEast ////////////////////////////////////////BishopSouthWest/////////////////////
					//4+-
					if (rowY><0 && columnX>0){
						
						
									while(pieces[rowStart-1-a][columnStart+1+a]==null && (columnStart+1+a)!=columnEnd && (rowStart-1-a)!=rowEnd){						
									
										a++;
									}
									a=a+1;
									
								
                     if(rowY<0){
			     rowY=rowY*(-1); 
			         }
					  if(columnX<0){
			    columnX=columnX*(-1); 
			         }
						
						 if(a<rowY && a><columnX ){
							 BishopNorthEast=false;
						       System.out.println("BishopNorthEast         This is a "+a+" and this is the square places disparity "+ rowY); 
						       System.out.println("BishopNorthEast          This is a "+a+" and this is the square places disparity "+ columnX);
						       System.out.println("BishopNorthEast          This is a This value is false");
					            }
					            else{
					            	BishopNorthEast=true;
					        System.out.println("BishopNorthEast     This is a "+a+" and this is the square places disparity "+ columnX); 
					        System.out.println("BishopNorthEast     This is a "+a+" and this is the square places disparity "+ rowY); 
					        System.out.println("BishopNorthEast    This is a This value is true");
					 		
					            }
					}
					

	
		return BishopSouthWest ||BishopNorthEast || BishopSouthEast || BishopNorthWest;	
			
	}
} 

>

[David Newton]

Glad you got it worked out, although I don't see how that code would compile because of the "><" constructs.

It sure seems like the code would be a good candidate for refactoring since there are four "chunks" that do essentially the same thing: is the goal to see if there are any pieces along any of the directions the bishop can move?

It also seems like determining the possible moves would be a prime candidate for moving into the Bishop subclass, no?

[Dmitri Makovetskiy]

David Newton wrote:Glad you got it worked out, although I don't see how that code would compile because of the "><" constructs.

It sure seems like the code would be a good candidate for refactoring since there are four "chunks" that do essentially the same thing: is the goal to see if there are any pieces along any of the directions the bishop can move?

It also seems like determining the possible moves would be a prime candidate for moving into the Bishop subclass, no?

The bishop moves legally, i tested the code many times. but what the code fails to do is adhere to this law

if(pieces[rowStart+b][columnStart+b]==nulll......

it keeps on counting even if there are objects ..as if the whole array was one big null. that does frustrate it. and it is beyond my comperhension of java to see why it happens..henceforth i posted it here.so someone could tell me

[David Newton]

It'd be a lot easier to help if you posted a board configuration that exhibits the error/

[Dmitri Makovetskiy]

David Newton wrote:It'd be a lot easier to help if you posted a board configuration that exhibits the error/

it doesnt show any error. the bishop piece simple moves to any position i ask it too and the game continues.
so for example,

bishop from 1,1 to 8,8. it will be there. and it doesnt listen to the rule .. if(pieces[][]==null... it considers everything as null

[David Newton]

I think you misunderstood me: an "error" is anything that doesn't work the way you want it to. What I asked for was a board configuration that exhibits the error--rather than making us reverse engineer *everything*, provide an SSCCE for us to examine. It's difficult enough to read your code without having to also figure out how to create a scenario that causes the undesired behavior.

[Dmitri Makovetskiy]

David Newton wrote:I think you misunderstood me: an "error" is anything that doesn't work the way you want it to. What I asked for was a board configuration that exhibits the error--rather than making us reverse engineer *everything*, provide an SSCCE for us to examine. It's difficult enough to read your code without having to also figure out how to create a scenario that causes the undesired behavior.

newton, i can give you the code after i debugged it. it has a different array (of strings) and 4 variables to change to move the pieces (rowstart, columnstart.....), other than that everything else is the same. all the algorithm
is copied and pasted....

   

class rook{
    public static void main(String[] args){
		 String[][]pieces =new String[9][9];
	   pieces[2][1]="Twenty One";
		             // pieces[2][2]="Twenty Two";
		              pieces[2][3]="Twenty Three";
		              pieces[2][4]="Twenty Four";
		              pieces[2][5]="Twenty Five";
		              pieces[2][6]="Twenty Six";
		              pieces[2][7]="Twenty Seven";
		              pieces[2][8]="Twenty Seven";
		                                   
		                  pieces [1][1]="Twenty Eight";
		                  pieces [1][2]="Twenty Eight";
		                  pieces [1][3]="Twenty Eight";
		                  pieces [1][4]="Twenty Eight";
		                  pieces [1][5]="Twenty Eight";
		                  pieces [1][6]="Twenty Eight";
		                  pieces [1][7]="Twenty Eight";
		                  pieces [1][8]="Twenty Seven";         

		                  pieces[7][1]="Twenty Seven";
		                  pieces[7][2]="Twenty Eight";
		                  pieces[7][3]="Twenty Eight";
		                  pieces[7][4]="Twenty Eight";
		                //  pieces[7][5]="Twenty Eight";
		                  pieces[7][6]=null;
		                  pieces[7][7]="Twenty Seven";
		                  //pieces[7][8]="Twenty Seven";
		                             
		                      pieces [8][1]="Twenty Seven";
		                      pieces [8][2]="Twenty Eight";
		                      pieces [8][3]="Twenty Eight";
		                      pieces [8][4]="Twenty Eight";
		                      pieces [8][5]="Twenty Eight";
		                      pieces [8][6]=null;
		                      //pieces [8][7]="Twenty Eight";
		                      pieces [8][8]=null;
							  
	
	 
			   int rowStart = 8;
			   int rowEnd=7;
			   int columnStart = 8;
			   int columnEnd=8;	
			 
			 
			 
					  
					  
					
			 
		 

		
				
				boolean isRookMovingRight=false;
				boolean isRookMovingLeft=false;
				boolean isRookMovingDown=false;
				boolean isRookMovingUp=false;
		       
				
				int b=0;
				int rowX=rowEnd-rowStart;
				
				int columnY=columnEnd-columnStart;
				   
				    System.out.println("rowX "+rowX);
				    System.out.println("columnY "+columnY);
			 
					  
					  
					
			 
		 

			//while(pieces[rowStart-1-a][columnStart+1+a]==null && (columnStart+1+a)!=columnEnd && (rowStart-1-a)!=rowEnd){						
									
								
				

				
				////////////////////////////////////////////////////////////////////////////////////////////////////////////
				if(columnY>0 & rowX==0){ // RIGHT SIDE (CHECK FOR NULL)
						  	  
					 
							
				  b=1;	
				  while(pieces[rowStart][columnStart+b+1]==null && columnStart+1+b!=columnEnd && pieces[rowEnd][columnEnd]==null){
								     b++;
								   
						 
				             }
				  
				  System.out.println("B "+ b );
					
					   
					  
				    if(b!=columnY || columnY==0 || b==0 ){
					isRookMovingRight=false;
					System.out.println("RIGHT SIDE "+"This is false "+ b+ " This is space "+ columnY);
		         }
		         else{
					isRookMovingRight=true;
					System.out.println("RIGHT SIDE "+"This is true "+ b+ " This is space "+ columnY);
		         }	 // IF B SMALLER THAN THE DIFFERENCE BETWEEN COLUMNSTART & COLUMNEND (SPACESY) , GIVE FALSE. OTHERWISE GIVE TRUE.
				
				
				}

				
				//////////////////////////////////////////////////////////////////////////////////////////////////////
				
				
				
				
				if(columnY<0 & rowX==0){ // LEFT SIDE (CHECK FOR NULL)
								  	  
						
									  
				while(pieces[rowStart][columnStart-1-b]==null && columnStart-b-1!=columnEnd && pieces[rowEnd][columnEnd]==null){
								     b++;
								    
						  
									
					}
		      			b=b+1;
				  
			
				columnY=columnY*(-1); 
				if(b!=columnY || columnY==0 || b==0 ){
						isRookMovingLeft=false;
						System.out.println("LEFT SIDE "+"This is false "+ b+ " This is space "+ columnY);
				     }
				     else{
						isRookMovingLeft=true;
						System.out.println("LEFT SIDE "+"This is true "+ b+ " This is space "+ columnY);
				     }			  
								  
				}		
							  
					

				
				
				
				//////////////////////////////////////////////////////////////////////////////////////////////////////////
				
				   if(columnY==0 & rowX>0){ // DOWN SIDE (CHECK FOR NULL)
					  	  
						 
						b=1;
					   while(pieces[rowStart+b][columnStart]==null && rowStart+b!=rowEnd && pieces[rowEnd][columnEnd]==null){ // CHECKS THE down ROW.
											   b++;						   
								}	
				
					   
					    if(b!=rowX || rowX==0 || b==0 ){
						isRookMovingDown=false;
						System.out.println("DOWN SIDE "+"This is false "+ b+ " This is space "+ rowX);
			         }
			         else{
						isRookMovingDown=true;
						System.out.println("DOWN SIDE "+"This is true "+ b+ " This is space "+ rowX);
			         }			
										  
					}	  
									  
				/////////////////////////////////////////////////////////////////////////////////////						  
				  if(columnY==0 & rowX<0){ // UP SIDE (CHECK FOR NULL)			  
					 // (array[columnStart-b]!=0 && array[columnStart-b]!=array[columnEnd]&& array[columnEnd]!=0 )	
				
			     while(pieces[rowStart-1-b][columnStart]==null & rowStart-b!=rowEnd && pieces[rowEnd][columnEnd]==null){ // CHECKS THE UPPER ROW.
										   b++;	 
										  
										    }	
			    
						  
		       
				     rowX=rowX*(-1);   							
						
				 if(b!=rowX || rowX==0 || b==0){
					isRookMovingUp=false;
					  System.out.println("UP SIDE "+"This is  false"+" B is "+ b + " rowX is "+rowX);
		         }
		         else{
					isRookMovingUp=true;
					  System.out.println("UP SIDE "+"This is true "+" B is "+ b+ " row X is "+rowX  );
		         }	
		
		 }
					

				//return isRookMovingUp | isRookMovingDown | isRookMovingLeft | isRookMovingRight;
		 }
		 
	
	}		 	

 

i think conceptually something happens that prevents my if test to be executed. i dont know how to reach teh sscce code

[David Newton]

Are you trying to work on the rook, or the bishop? In other words, post the exact code you're trying to debug: when you're trying to get help from people, do as much as you possible can for them.

[David Newton]

(And, as I mentioned, the bishop code you posted will not compile: rather than force me to guess your intent, better to post working code.)

[David Newton]

(And I can't tell if you have a cut-and-paste error in your code, or if it's what you really mean: perhaps posting an explanation of your algorithm would also be useful to the dwindling number of people that are still trying to help.)

[Dmitri Makovetskiy]

David Newton wrote:(And I can't tell if you have a cut-and-paste error in your code, or if it's what you really mean: perhaps posting an explanation of your algorithm would also be useful to the dwindling number of people that are still trying to help.)

The bishop and the rook algorithm is based on the same principle they both dont work on the same principle


here is bishops debugged code. works..

just feed new numbers and see for yourself. you could also add or remove the nulls from an array.

  

class LinkedListEx2{
	public static void main(String[] args){
		  String[][]pieces =new String[9][9];
				  
				      pieces[2][1]="Twenty One";
		             // pieces[2][2]="Twenty Two";
		              pieces[2][3]="Twenty Three";
		              pieces[2][4]="Twenty Four";
		              pieces[2][5]="Twenty Five";
		              pieces[2][6]="Twenty Six";
		              pieces[2][7]="Twenty Seven";
		              pieces[2][8]="Twenty Seven";
		                                   
		                  pieces [1][1]="Twenty Eight";
		                  pieces [1][2]="Twenty Eight";
		                  pieces [1][3]="Twenty Eight";
		                  pieces [1][4]="Twenty Eight";
		                  pieces [1][5]="Twenty Eight";
		                  pieces [1][6]="Twenty Eight";
		                  pieces [1][7]="Twenty Eight";
		                  pieces [1][8]="Twenty Seven";         

		                  pieces[7][1]="Twenty Seven";
		                  pieces[7][2]="Twenty Eight";
		                  pieces[7][3]="Twenty Eight";
		                  pieces[7][4]="Twenty Eight";
		                //  pieces[7][5]="Twenty Eight";
		                  pieces[7][6]=null;
		                  pieces[7][7]=null;
		                  pieces[7][8]=null;
		                             
		                      pieces [8][1]="Twenty Seven";
		                      pieces [8][2]="Twenty Eight";
		                      pieces [8][3]="Twenty Eight";
		                      pieces [8][4]="Twenty Eight";
		                      pieces [8][5]="Twenty Eight";
		                      pieces [8][6]=null;
		                      pieces [8][7]=null;
		                      pieces [8][8]=null;
							  
							  
		int rowStart=1;
		int rowEnd=8;
		int columnStart=1;
		int columnEnd=8;
		
	int columnX=columnEnd-columnStart;// This is a very important part!!!!!!!!!!!!!!!!!!!!!!!!1
		
		int rowY=rowEnd-rowStart;  // This is a very important part!!!!!!!!!!!!!!!!!!!!!
		     
			      boolean BishopNorthEast=false;
				  boolean BishopNorthWest=false;
				  boolean BishopSouthWest=false;
				  boolean BishopSouthEast=false;
				  
				
		                         
					
				
		                      int a=0;
		           
////////////////////BishopNorthWest//////////////////////////////////
					//1--
					if(columnX<0 && rowY<0){ 
// based on the values from columnX, rowY, the if condition will be executed (if start is bigger than end, and vice versa)
							
					
								while(pieces[rowStart-1-a][columnStart-1-a]==null && (columnStart-1-a)!=columnEnd && (rowStart-1-a)!=rowEnd){
// this loop does 2 things. 
// 1) count the squares from start to finish.
// 2) count how many nulls there are.
// if both conditions are satisfied , then the value "a" will be counted once each time the loop is executed.						
									
										a++;
									}
									a=a+1;
				          
					   if(rowY<0 ){ // This is self explanatory
			     rowY=rowY*(-1); 
			         }
					  if(columnX<0){
			    columnX=columnX*(-1); 
			         }
						 if(a<rowY && a><columnX){
// this condition simply wants to see whether a==columnX or rowX (which should be equal as the bishop moves in diagonal). if a==rowY/columnX, then 
// it means that java counted all the squares from start to finish as nulls.. there were no objects
							 BishopNorthWest=false;
						       System.out.println("BishopNorthWest     A is "+a+" and this is the square places disparity "+ rowY); 
						       System.out.println("BishopNorthWest      A is "+a+" and this is the square places disparity "+ columnX);
						       System.out.println("BishopNorthWest      value is flase");
					            }
					            else{
					       	BishopNorthWest=true;
					        System.out.println("BishopNorthWest      A is "+a+" and this is the square places disparity "+ columnX); 
					        System.out.println("BishopNorthWest     A is "+a+" and this is the square places disparity "+ rowY);
					        System.out.println("BishopNorthWest          value is true");
					            }		
                      			
			     rowY=rowY*(-1);
// this simply returns the rowY columnX to the way they used to be (negative ) if i dont do that
// procedure... the code will do things i dont want it to do. it is marginal in importance..
// not critical, thought necessary
			        
			    columnX=columnX*(-1); 
			       } 					
	///////////////////////////////	BishopSouthEast /////////////////////////////////////
					//2++
					if (rowY>0 && columnX>0){ // the whole algorithm is same, but the first condition dictates how the <>-+ signs will be!!
						

							
						
									while(pieces[rowStart+1+a][columnStart+1+a]==null && (columnStart+1+a)!=columnEnd && (rowStart+1+a)!=rowEnd){						
									
										a++;
									}
									a=a+1;
									
									System.out.println("BishopSouthEast   This is a "+a); 
									
							
				
						 if(a<rowY && a><columnX){
							 BishopNorthEast=false;
						       System.out.println("BishopSouthEast   This is a "+a+" and this is the square places disparity "+ rowY); 
						       System.out.println("BishopSouthEast    This is a "+a+" and this is the square places disparity "+ columnX);
						       System.out.println("BishopSouthEast   This is a This value is false");
					            }
					            else{
					       	BishopNorthEast=true;
					        System.out.println("BishopSouthEast       This is a "+a+" and this is the square places disparity "+ columnX); 
					        System.out.println("BishopSouthEast       This is a "+a+" and this is the square places disparity "+ rowY); 
					        System.out.println("BishopSouthEast        This is a This value is true");
					            }
				
	}
///////////////////////	BishopSouthWest//////////////////////////////////////	BishopNorthEast////////////////////////////
			       if(rowY>0 && columnX<0){
			   		
									while(pieces[rowStart+1+a][columnStart-1-a]==null && (columnStart-1-a)!=columnEnd && (rowStart+1+a)!=rowEnd){						
									
										a++;
									}
									a=a+1;
								
								
									
					
			        if(rowY<0){
			     rowY=rowY*(-1); 
			         }
					  if(columnX<0){
			    columnX=columnX*(-1); 
			         }
					 if(a<rowY  && a><columnX){
						 BishopSouthWest=false;
					       System.out.println("BishopSouthWest           This is a "+a+" and this is the square places disparity "+ rowY); 
					       System.out.println("BishopSouthWest           This is a "+a+" and this is the square places disparity "+ columnX);
					       System.out.println("BishopSouthWest           This is a This value is false");
				            }
				            else{
				       	BishopSouthWest=true;
				        System.out.println("BishopSouthWest   This is a "+a+" and this is the square places disparity "+ columnX); 
				        System.out.println("BishopSouthWest    This is a "+a+" and this is the square places disparity "+ rowY); 
				        System.out.println("BishopSouthWest     This is a This value is true");
				            }
	}
				
///////////////////////////BishopNorthEast ////////////////////////////////////////BishopSouthWest//////////////////////////////
					//4+-
					if (rowY><0 && columnX>0){
						
						
									while(pieces[rowStart-1-a][columnStart+1+a]==null && (columnStart+1+a)!=columnEnd && (rowStart-1-a)!=rowEnd){						
									
										a++;
									}
									a=a+1;
									
								
                     if(rowY<0){
			     rowY=rowY*(-1); 
			         }
					  if(columnX<0){
			    columnX=columnX*(-1); 
			         }
						
						 if(a<rowY && a><columnX ){
							 BishopNorthEast=false;
						       System.out.println("BishopNorthEast         This is a "+a+" and this is the square places disparity "+ rowY); 
						       System.out.println("BishopNorthEast          This is a "+a+" and this is the square places disparity "+ columnX);
						       System.out.println("BishopNorthEast          This is a This value is false");
					            }
					            else{
					            	BishopNorthEast=true;
					        System.out.println("BishopNorthEast     This is a "+a+" and this is the square places disparity "+ columnX); 
					        System.out.println("BishopNorthEast     This is a "+a+" and this is the square places disparity "+ rowY); 
					        System.out.println("BishopNorthEast    This is a This value is true");
					 		
					            }
					}
					

	

			
	}
}

  

>

[David Newton]

If the debugged bishop code works, what's the issue? The rook code?

You're confusing on several levels... And please, *please* format your code.

[Dmitri Makovetskiy]

David Newton wrote:If the debugged bishop code works, what's the issue? The rook code?

You're confusing on several levels... And please, *please* format your code.

The debugg works. cause i put everything in a class. but in my original code i put the things in one method and call it from the main. that kind of order makes it fail..
it doesnt pay attention to the objects.. it counts every piece as a null

[David Newton]

The code above will not compile--do you understand that? You need to post the exact code that doesn't work the way you expect, you need to state how you want your code to work, and so on.

[Dmitri Makovetskiy]

David Newton wrote:The code above will not compile--do you understand that? You need to post the exact code that doesn't work the way you expect, you need to state how you want your code to work, and so on.

my code does compile. i used it for 3 days, i feed it with different values.


try to see whats the problem when you copy it and paste it. may be you are missing a bracket

[David Newton]

Maybe I'm missing a bracket? Really?

That aside:

if (a<rowY && a><columnX ){  

Tell me how that compiles. (Hint: it doesn't. It's on line 185 above, and in the other three blocks as well.)

Why won't you format your code nicely?

[Campbell Ritchie]

David Newton wrote:Maybe I'm missing a bracket? Really?

That aside:

if (a<rowY && a><columnX ){  

Tell me how that compiles. (Hint: it doesn't. It's on line 185 above, and in the other three blocks as well.)

Why won't you format your code nicely?

I think there is a bug on the Ranch which produces >< every now and again when you are supposed to have only one of those characters.

[Wouter Oet]

I noticed that bug earlier this year and made a bug-report about it. I believe that Ulf fixed it.

[David Newton]

Bug or not (and I can believe it is), the OP needs to at least tell us which character is the correct one.

[Campbell Ritchie]

Do you have Pawn objects and Bishop objects and Knight objects, etc?

[Campbell Ritchie]

I have probably made the code legibility even worse by getting rid of some of the long lines so as to avoid horizontal scroll-bars.

[Dmitri Makovetskiy]

Campbell Ritchie wrote:Do you have Pawn objects and Bishop objects and Knight objects, etc?

i do have all that!!!

here is my array of pieces in the main:

The class that is called ChessInterface

  ChessPiece[][]pieces =new ChessPiece[9][9];  

   

			   pieces[2][1]=new Pawn("Bpn1");
			   pieces[2][2]=new Pawn("Bpn2");
			   pieces[2][3]=new Pawn("Bpn3");
			   pieces[2][4]=new Pawn("Bpn4");
			   pieces[2][5]=new Pawn("Bpn5");
			   pieces[2][6]=new Pawn("Bpn6");
			   pieces[2][7]=new Pawn("Bpn7");
			   pieces[2][8]=new Pawn("Bpn8");
			   					  
			          pieces [1][1]=new Rook("BR1");
				  pieces [1][2]=new Knight("BN1");
				  pieces [1][3]=new Bishop("BB1");
				  pieces [1][4]=new King("BKing");
				  pieces [1][5]=new Queen("BQueen");
				  pieces [1][6]=new Bishop("BB2");
				  pieces [1][7]=new Knight("BN2");
				  pieces [1][8]=new Rook("BR2");		  
		  
				   pieces[7][1]=new Pawn("Wpn1");
				   pieces[7][2]=new Pawn("Wpn2");
				   pieces[7][3]=new Pawn("Wpn3");
				   pieces[7][4]=new Pawn("Wpn4");
				   pieces[7][5]=new Pawn("Wpn5");
				   pieces[7][6]=new Pawn("Wpn6");
				   pieces[7][7]=new Pawn("Wpn7");
				   pieces[7][8]=new Pawn("Wpn8");
				   	   	  
				      pieces [8][1]=new Rook("WR1");
				      pieces [8][2]=new Knight("WN1");
					  pieces [8][3]=new Bishop("WB1");
					  pieces [8][4]=new King("WKing");
					  pieces [8][5]=new Queen("WQueen");
					  pieces [8][6]=new Bishop("WB2");
					  pieces [8][7]=new Knight("WN2");
					  pieces [8][8]=new Rook("WR2");
					  
					  


 

ChessPiece is the name of my abstract class:

   



abstract class ChessPiece {
	  
	 abstract public  boolean isMoveValid(ChessPiece[][] pieces,int columnStart, int rowStart, int columnEnd, int rowEnd);
	
	  abstract public String print();

	 abstract public String FindPiece(String chessPiece); 
	 
	

	 abstract public boolean piecesCollision(ChessPiece[][]pieces,int rowStart,int columnStart ,int columnEnd,int rowEnd);
	 

   	}	  
	 




 

all the algorithm of hte chess piece collsion is inside the method in the rook (or bishop class, they are quite similar..but different enough)

  
class Rook extends ChessPiece{
public boolean piecesCollision(ChessPiece[][]pieces,int rowStart,int columnStart ,int columnEnd,int rowEnd) {
  

what intrigues me. how that pieces array behaves? may be it doesnt work cause of jumbing between classes and methods\| cause i have an if condition that counts or is aware of whether there is an object or condition