How to calculate the blast area of a bomb? - math

Question

I'm developing a game, let's say player a put a bomb in location x=100,y=100 and the explosion radius is 100 units... It is pretty easy for me to find all the "items" in the game that were hit by the blast of the bomb (just need to check that their distance from the bomb is lower then 100).
But now i want to take in consideration the obstacles i have in the game, the obstacles are squares, always 64*64 pixels, always aligned to the axis (not rotated).. i want to know if an item was "hidden" behind an obstacle to know he wasn't hit ...
something like this :
The dude on the right wasn't hit, but the dude on the bottom was hit, i filled in gray the hit area, and in green the area which is hidden...
My idea is :
1. find all the items in the scene that their distance from the bomb is lower then 100.
2. find all the obstacles in the scene that their distance from the bomb is lower then 100.
3. calculate the lines from the items to the center of the bomb .. then check if the lines intersect any obstacle , if no .. you were hit.
Finaly, the questions
1. Does any one has a better idea ?
2. Are there free opensource c# compatible engines that can help me ? Box2d can help me here ?
Thanks

Answer 1

It is quite simple, and as Jongware mention in the comments, you should use two lines of visibility.
You should compute the lines of visibility from each "side" of the items in the picture. The origin of each visibility line can be approximated by computing the line from the center of the bomb and get the direction normal to that vector. Your two visibility points are then located one radius out from the center of the item in the normal and negative normal direction. This circle approximation might not represent all possible shapes very well, but is generally a good enough approximation for simple games (and your items look circular in the drawing).
Java-isch pseudocode using 2D-vectors:
// bombCenter and itemCenter are 2D-vectors
bombDirectionVector = bombCenter.minus(itemCenter);
normal = bombDirectionVector.getNormal() // normal vector of length 1
viewPoint1 = itemCenter.plus(normal.times(itemRadius));
viewPoint2 = itemCenter.minus(normal.times(itemRadius));
// Check obstacle intersection with the lines from viewPoint{1,2} to bombCenter
// ...
The visibility lines will then go from the points on the sides of each item to the bomb center. So, for each item, you check if the two visibility lines intersect either the same obstacle or two connected obstacles.
There is no free open source C#-compatible engines I know of that does this, but the only part that can be a bit tricky is the obstacle intersection check. So if you just find something to help you with the intersection check, then the rest should be very straight forward to implement.
I hope this helps, and let me know if anything is unclear and I'll clarify the answer accordingly.

Answer 2

Here is a nice demo/write-up on the subject:
http://www.redblobgames.com/articles/visibility/
If it is a tile-based game and you know the tile coordinates of all of the objects, you could use Bresenham's Line Algorithm: http://roguebasin.roguelikedevelopment.org/index.php?title=Bresenham%27s_Line_Algorithm. Here is an excerpt:
// Author: Jason Morley (Source: http://www.morleydev.co.uk/blog/2010/11/18/generic-bresenhams-line-algorithm-in-visual-basic-net/)
using System;
namespace Bresenhams
{
/// <summary>
/// The Bresenham algorithm collection
/// </summary>
public static class Algorithms
{
private static void Swap<T>(ref T lhs, ref T rhs) { T temp; temp = lhs; lhs = rhs; rhs = temp; }
/// <summary>
/// The plot function delegate
/// </summary>
/// <param name="x">The x co-ord being plotted</param>
/// <param name="y">The y co-ord being plotted</param>
/// <returns>True to continue, false to stop the algorithm</returns>
public delegate bool PlotFunction(int x, int y);
/// <summary>
/// Plot the line from (x0, y0) to (x1, y10
/// </summary>
/// <param name="x0">The start x</param>
/// <param name="y0">The start y</param>
/// <param name="x1">The end x</param>
/// <param name="y1">The end y</param>
/// <param name="plot">The plotting function (if this returns false, the algorithm stops early)</param>
public static void Line(int x0, int y0, int x1, int y1, PlotFunction plot)
{
bool steep = Math.Abs(y1 - y0) > Math.Abs(x1 - x0);
if (steep) { Swap<int>(ref x0, ref y0); Swap<int>(ref x1, ref y1); }
if (x0 > x1) { Swap<int>(ref x0, ref x1); Swap<int>(ref y0, ref y1); }
int dX = (x1 - x0), dY = Math.Abs(y1 - y0), err = (dX / 2), ystep = (y0 < y1 ? 1 : -1), y = y0;
for (int x = x0; x <= x1; ++x)
{
if (!(steep ? plot(y, x) : plot(x, y))) return;
err = err - dY;
if (err < 0) { y += ystep; err += dX; }
}
}
}
}