View difference between Paste ID: hJBauYFA and C2efQiUu

-#define IsValidWallObject(%1)		(wallplanes[%1][PLANE_POS][0] == 0.0 && wallplanes[%1][PLANE_POS][1] == 0.0)
+#define IsValidWallObject(%1)		!(wallplanes[%1][PLANE_POS][0] == 0.0 && wallplanes[%1][PLANE_POS][1] == 0.0)
 
 enum PlaneEnum {
 	Float:	PLANE_POS[3],		// Position of the plane / of the wall object
 	Float:	PLANE_COORD[4],		// Representation of the plane in coordinate form
 	Float:	PLANE_BUFFER[4]		// Buffers minimum/maximum x and min/max z values for later use
 }
 
 new wallplanes[400][PlaneEnum];
 
-CreateWallObject(modelid, Float:x, Float:y, Float:z, Float:rX, Float:rY, Float:rZ)
+stock CreateWallObject(modelid, Float:x, Float:y, Float:z, Float:rX, Float:rY, Float:rZ)
 {
 	// Creating the real object
 	new obid = CreateObject(modelid, x, y, z, rX, rY, rZ);
 	if (obid == INVALID_OBJECT_ID) {
 		return INVALID_OBJECT_ID;
 	}
 
 	// Converting the wall to a plane
 	// E: x1*a + x2*b + x3*c = d
 	// Store position
 	wallplanes[obid][PLANE_POS][0] = x;
 	wallplanes[obid][PLANE_POS][1] = y;
 	wallplanes[obid][PLANE_POS][2] = z;
 
 	// Get params for coordinate representation, a b c d
 	wallplanes[obid][PLANE_COORD][0] = floatsin(rZ, degrees);
 	wallplanes[obid][PLANE_COORD][1] = floatcos(rZ, degrees);
 	wallplanes[obid][PLANE_COORD][2] = 0; // Easy case where walls always are vertical with no x rotation
 	wallplanes[obid][PLANE_COORD][3] = x * wallplanes[obid][PLANE_COORD][0] + y * wallplanes[obid][PLANE_COORD][1];
 
 	// Somehow retrieve the size
 	new Float:size[4];
 	GetWallObjectSize(modelid, size);
 
 	// Buffer some values for boost in checks
 	wallplanes[obid][PLANE_BUFFER][0] = x + wallplanes[obid][PLANE_COORD][0] * size[0];
-	wallplanes[obid][PLANE_BUFFER][1] = x + wallplanes[obid][PLANE_COORD][0] * size[2];
+	wallplanes[obid][PLANE_BUFFER][1] = x + wallplanes[obid][PLANE_COORD][0] * size[1];
 	// if xmin is greater than xmax (rotation > 180°) swap them
 	if (wallplanes[obid][PLANE_BUFFER][0] > wallplanes[obid][PLANE_BUFFER][1]) {
 		new Float:temp = wallplanes[obid][PLANE_BUFFER][0];
 		wallplanes[obid][PLANE_BUFFER][0] = wallplanes[obid][PLANE_BUFFER][1];
 		wallplanes[obid][PLANE_BUFFER][1] = temp;
 	}
-	wallplanes[obid][PLANE_BUFFER][2] = z + size[1];
+	wallplanes[obid][PLANE_BUFFER][2] = z + size[2];
 	wallplanes[obid][PLANE_BUFFER][3] = z + size[3];
 
 	// Done!
 	return obid;
 }
 
 stock GetWallObjectSize(modelid, Float:size[])
 {
 	// Somehow retrive and store the size
 	// e.g. with a constant array containing the size for all wall objects
 	#pragma unused modelid
 	// And NOT this way:
 	size[0] = -0.5;
-	size[1] = -0.5;
+	size[1] = 0.5;
-	size[2] = 0.5;
+	size[2] = -0.5;
 	size[3] = 0.5;
 
 	// Data should look like this:
-	// [0],[1]: X/Z-offset from the position pointing to the bottom left corner of the wall
+	// [0],[1]: X-offset minimum and maximum
-	// [2],[3]: X/Z-offset from the position pointing to the top right corner of the wall
+	// [2],[3]: Z-offset minimum and maximum
 }
 
 
 stock IsLOSFree(Float:x1, Float:y1, Float:z1, Float:x2, Float:y2, Float:z2)
 {
 	// Calculate the vector between the two points
 	new Float:u, Float:v, Float:w;
 	u = x2 - x1;
 	v = y2 - y1;
 	w = z2 - z1;
 
 	// Preload some used variables
 	new Float:lambda;
 	new Float:x, /*Float:y,*/ Float:z; // y not needed in this example, just x/z are used for checks
 	// Loop through ALL valid wallobjects
 	// This could be optimized e.g. by only checking objects in an area around the points etc
 	// or at least using foreach instead of IsValidWallObject
 	for (new i = 0; i < 400; i++) {
 		if (!IsValidWallObject(i)) continue;
 
 		// This actually calculates where the vector cuts the plane
 		// lambda = (a*x1 + b*y1 + c*z1 - d) / (u*a + v*b + w*c)
-		lambda = (wallplanes[i][PLANE_COORD][0] * x1 + wallplanes[i][PLANE_COORD][1] * y1 + wallplanes[i][PLANE_COORD][2] * z1)
+		lambda = (wallplanes[i][PLANE_COORD][0] * x1 + wallplanes[i][PLANE_COORD][1] * y1 + wallplanes[i][PLANE_COORD][2] * z1 - wallplanes[i][PLANE_COORD][3])
 			/ (u * wallplanes[i][PLANE_COORD][0] + v * wallplanes[i][PLANE_COORD][1] + w * wallplanes[i][PLANE_COORD][2]);
 
 		// lambda < -1 -> Point of intersection is behind point 2 and so not interesting
-		// lambda > 1 -> Point of intersection is behind point 2 and so not interesting
+		if (lambda > 0.0 || lambda < -1.0) continue;
-		if (lambda > 1.0 || lambda < 0.0) continue;
+
 		// Calculate the actual coordinates of the intersection
 		x = x1 + u * lambda;
 		//y = y1 + v * lambda; // Not needed as this example just uses x for checking
 		z = z1 + w * lambda;
 
 		// Now check if it lies on the wall, or next to it
 		// Check x and z areas
 		if (x < wallplanes[i][PLANE_BUFFER][0] || x > wallplanes[i][PLANE_BUFFER][1]		// < xmin or > xmax
 			|| z < wallplanes[i][PLANE_BUFFER][2] || z > wallplanes[i][PLANE_BUFFER][3]) {	// < zmin or > zmax
-			|| z < wallplanes[i][PLANE_BUFFER][2] || z > wallplanes[i][PLANE_BUFFER][3])	// < zmin or > zmax
+
 		}
 
 		// Else the point is on the wall, and so the LOS is blocked
 		return false;
 	}
 	// Passed all checks for all walls, so the LOS is free
 	return true;
 }