The title says it all. How do i get the number of solid tiles between two points (or two tiles)? Ive been trying to think as to how to implement this algorithm, but all attempts so far have failed.

Here is a image showing what I want to do...

www.xanather.com/lighting.png

(the red tiles and the line are drawn in through paint, not part of the rendering).

The reason I want to implement this is to allow for dynamic 2D lighting between all tiles. A wall of tiles will block some lighting (it similar to Terraria's lighting).

After I implement this I will be able to obtain how many solid tiles are between two points and reduce the lighting depending on the amount of solid tiles that are in between these two points.

Anyway, I hope someone can help me

All replies are appreciated. Thanks,
Xanather.

EDIT: Sorry, just realized my below algorithm is incorrect, ignore it for now.

Loop start from one point, move in dx=TileWidth-1, dy=TileHeight-1 toward to the end point, until reach or beyond the end point.
In each move, get the tile at that point, check if it's a solid tile.
This will be sure you loop all tiles covered by the line and won't miss any tile.

the number of tiles is max(abs(x2-x1), abs(y2-y1)).

How does that work? Wont that just get the number of tiles in one of the two directions? (only the change in X or only the change in Y)?

Xanather.

Looking into Bresenham's algorithm now, looks like its what I need. Thanks

Ok well, I managed to implement Bresenham's line algorithm. Its creating some nice effects too...

http://www.xanather.com/hmm.png

And here is the code:

[source lang="csharp"] static byte GetTileReduction(int x0, int y0, int x1, int y1)
{
int reduction = 0;
if (x0 > x1)
{
int temp1 = x1;
int temp2 = y1;
x1 = x0;
y1 = y0;
x0 = temp1;
y0 = temp2;
}
int deltax = x1 - x0;
if (deltax == 0)
{
deltax = 1;
}
int deltay = y1 - y0;
float error = 0;
float deltaerror = (deltay / deltax);
int y = y0;
for (int x = x0; x < x1; x++)
{
if (Engine.tiles[x, y].type != 0)
{
reduction += 20;
if (reduction > 255)
{
reduction = 255;
}
}
error += deltaerror;
if (error >= 0.5f)
{
y = y + 1;
error = error - 1f;
}
}
return (byte)reduction;
}[/source]

The problem is that this occurs when the light source is completely underground...

http://www.xanather.com/hmm2.png

I am lost, it seems as when the "imaginary" line in the algorithm gets steeper the solid tiles found reduce, resulting in the brighter-than-it-should-be colored tile (brighter) along the vertical parts of the lighting... It should be just a smaller sphere (circle).

I hope you understand what I mean, Ive been trying to tackle this for a while now.

I feel like the actual problem is right under my nose xD

Xanather.

EDIT:

The
[source lang="csharp"]if (deltax == 0)
{
deltax = 1;
}[/source]
is temporary obviously...