Thread: [SOLVED] Raycasting troubles

Greetings.

I am writing a raycasting engine right now, based off the Permadi tutorial, and I seem to have encountered two problems concerning wall drawing.

The first is that when I turn 180°, I get the exact same thing, regardless of how far away the wall behind me might be (essentially, if you look at the minimap top right (which does display the level correctly), you'd get the same images if I were to look into the top-left corner).

The second is that the walls don't render properly, as can be seen on the images below. Only difference between these two images is that I move forward a little (it gets a lot worse if I move more).

Would anybody know offhand what is happening ? Being new to this forum, I can't post enough code to provide an understanding of the way I'm trying to do this.

raycasting.jpg

I'm writing all this in Java, and I'm not sure all my issues are purely of an algorithmic nature.

Here's a .jar so that people can better visualise my issue (I've cleared up the 180° problem, but I still have trouble with the wal drawing).

TestExport.rar

One can move with the arrow keys. The level is 10*10, with blocks at all edges, and one block near the middle.

All right, I've cleared up some more of the issues, but there still seems to be some problems with corners and such. a couple of walls come out of nowhere, and when one gets closer to the far walls, it gets a little strange. All these issues seem to be happening when the player angle is somewhere between 330 and 30 degrees (when the player looks straight right).

TestExport.zip

Ah, I can post some code. Essentially, the issues are with the raycast method.
(source code is unoptimised, and hopelly not too illegible).

This method is supposed to return the distance of a wall from player position at a certain angle.

public static double raycast(double x, double y, double angle, Level level){
 
// These will be intersection coordinates. Initialised at player coordinates. 
		int xtemp = (int)Math.floor(x);
		int ytemp = (int)Math.floor(y);
 
// These will be the distance one gets
		double distancefoundhor = 0;
		double distancefoundver = 0;
		double angle2 = Math.PI * angle /180;
		boolean iswall = false;
 
		//avoid division by zero
		if(angle2 %(Math.PI/2) == 0) return 0;
 
// Horizontal intersections
// Get first intersection coordinates, depends if ray is facing up or down
 
		if(angle2>Math.PI)
{ytemp = ((ytemp/128)*128 -1);}else{ytemp = ((ytemp/128)*128 +128);}
		xtemp -= ((y - ytemp)/(Math.tan(angle2)));
 
// if it's out of boundaries, return huge distance
		if(xtemp < 0 || ytemp < 0 || xtemp >= level.WIDTH*128  || ytemp >= level.HEIGHT*128){ iswall = true; distancefoundhor = 4000;}
 
// if the block corresponding to the intersection is a wall, return distance
 
		if(!iswall&&level.getBlockType(xtemp, ytemp)==-1){iswall = true;
			distancefoundhor = ((y-ytemp)/Math.sin(angle2));
		}
 
// otherwise get the next intersection	
		while(!iswall){
//not the same formula
			if(angle2 >Math.PI){ytemp-=128; xtemp -= Math.floor(128/Math.tan(angle2));}else{ytemp += 128; xtemp += Math.floor(128/(Math.tan(angle2)));}
 
//check boundaries
			if(xtemp < 0 || ytemp < 0 || xtemp >= level.WIDTH*128 || ytemp >= level.HEIGHT*128){ iswall = true; distancefoundhor = 4000;}
 
// Check wall block again
			if(!iswall && level.getBlockType(xtemp, ytemp)==-1){iswall = true;
				distancefoundhor = ((y-ytemp)/Math.sin(angle2));
			}
		}			
 
// Vertical intersections
// Reinitialise
		xtemp = (int)x; ytemp = (int)y;iswall = false;
 
// Get first intersection, depends if ray is facing left or right
 
		if(angle2>Math.PI/2 && angle2<3*Math.PI/2){	xtemp = ((xtemp/128) *128 -1);}else{xtemp = ((xtemp/128)*128+128);}
		ytemp -= ((x - xtemp)*(Math.tan(angle2)));
 
// Check boundaries		
		if(xtemp < 0 || ytemp < 0 || xtemp >= level.WIDTH*128 || ytemp >= level.HEIGHT*128){ iswall = true; distancefoundver = 4000;}
 
// Check if is wall block. Distance is calculated using cos as it avoids division by near-zero values
		if(!iswall&&level.getBlockType(xtemp, ytemp)== -1){iswall = true;
			distancefoundver =  ((x-xtemp)/Math.cos(angle2));
		}	
 
// Get next intersection(s)
		while(!iswall){
			if(angle2 >Math.PI/2&&angle2<3*Math.PI/2){xtemp-=128;ytemp -= Math.floor(128*(Math.tan(angle2)));}else{xtemp += 128;	ytemp += Math.floor(128*(Math.tan(angle2)));}
 
// Same as before
			if(xtemp < 0 || ytemp < 0 || xtemp >= level.WIDTH*128 || ytemp >= level.HEIGHT*128){ iswall = true; distancefoundver = 4000;}
			if(!iswall&&level.getBlockType(xtemp, ytemp)==-1){iswall = true;
				distancefoundver =  ((x-xtemp)/Math.cos(angle2));
			}
		}	
 
// Return lower value of distance
		if(Math.abs(distancefoundhor) < Math.abs(distancefoundver)){
 
			return Math.abs(distancefoundhor);
		}else{
			return Math.abs(distancefoundver);}
 
	}
}

This is in my render method (I know it's badly written) :

for(double i = 0; i <640; i++){  
 
//spans from player angle -30 to player angle + 30 with pixel increment  
                double j = game.player.ROTATION + i*3/32 -30;            
                this.drawWall((int)i,Raycasting.raycast(game.player.X_COORD,game.player.Y_COORD,j , game.level), j, 0x10cc);  
        }

This draws the walls :

    public void drawWall(int x,double distance, double angle, int colour ){  
            //draws the corresponding wall section using distance       
            int wallheight = 0;  
            if(distance!= 0){  
             wallheight = (int) ((128*554/(distance*Math.cos((angle- Screen.display.game.player.ROTATION)*Math.PI/180))));      
     // cos is to avoid fisheye effect.  
            }  
 
    // Avoid drawing out of screen  
            if(wallheight > Display.HEIGHT){  
                wallheight = Display.HEIGHT;  
            }              
            drawVerticalLine(x, Raycasting.CENTER_Y - wallheight/2, wallheight, colour);  
    }

Using :

 public void drawVerticalLine(int x, int y, int length, int colour){  
            //This method draws a vertical line from (x, y-length/2) to (x,y+length/2) 
    		for(int i = 0; i < length;i++){
                pixels[x+Display.WIDTH*(y+i)] = colour;}  
        }

Levels are represented as an array, with width and depth specified. -1 for walls, 0 for ground.

The raycast method uses this method :

public int getBlockType(int x, int y){
 
	return floordata[(x/128 ) + WIDTH*(y/128)];
 
	}

Here's my test level in the .jars (width = depth = 10), I think (changed it since, the -1 isn't there anymore) :

{-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
-1,0,0,0,0,0,0,0,0,-1,
-1,0,0,0,0,0,0,0,0,-1,
-1,0,0,0,0,0,0,0,0,-1,
-1,0,0,0,0,-1,0,0,0,-1,
-1,0,0,0,0,0,0,0,0,-1,
-1,0,0,0,0,0,0,0,0,-1,
-1,0,0,0,0,0,0,0,0,-1,
-1,0,0,0,0,0,0,0,0,-1,
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1}

and here's the Permadi tutorial :
Ray Casting Programming Tutorial For Game Development

I don't use the same conventions concerning angles (mine are clockwise), and wall size (128, with a display screen of 640*400).

I hope that's enough information. Essentially, there's only the issues mentioned above left : weird behaviour when angle is between 330 and 30 degrees, and it seems wall corners aren't quite right.

I believe some of these could be attributed to rounding errors, although I'm not sure where. I've been debugging this for quite a while, I would really like to *finally* get this properly working.

Anyways, if you've actually read from start to end, thanks a lot !

Solved those weird wall drawing issues. Only a few rounding issues with corners left, but that's a minor niggle for now. Sorry for the sort of monologue.