I've been fiddling with handling a ball bouncing arround the screen (and off of flat surfaces that are sides of rectangles where the rectangles are always larger than the ball). I have come up with several solutions to calculating if the ball needs to bounce, and where it needs to bounce but all of them require a lot of hard coding for each possible case which makes debugging painful.

I'm basically looking for a simpler way to do it or some tricks I can use.

My first approach was to take the circles current position and then draw two lines from it's edges to where it will be in its new position. I tried to use an estimation by using one of two sets of lines:

     A
    __
   /  \
D |    | B
   \__/
    C

either I would make a line connecting the circles A points and another connecting their C points, or I would make a line connecting their two B points and two D points. A and C would be chosen if abs(dx) > abs(dy).

I then would then plug in the y and x values for the sides of the rectangle into those lines equations to see where they intersect, then test to make sure the intersections are within the bounds of the rectangle.

Testing those bounds depends on the side I chose, whether dx > 0, whether dy > 0 and whether abs(dx) > abs(dy), creating a decent sized headache for me.

A more accurate alternative would be to select the lines based upon the direction the circle is headed. If it were headed in the dy/dx direction then a point on the circle at dx/dy from it's center would be chosen instead of A,B,C, or D. That would have most of the same problems.

Another way is just to see if the closest part of the circles new position is inside the rectangle by making sure it's x coordinates are greater than the left side of the rectangle and less than the right side of the rectangle, then the same for the y. That creates the problem of telling which side to bounce off of and where on that side to bounce off of, which is doable, but also a headache.

I'll have to read through it again and go through the steps myself on paper, but it looks like that is exactly what I needed. It should even be simpler than what they present because I only have to worry about horizontal and vertical lines so the vectors should become simpler.

Well, I had the general idea then tried to pick apart his examples and understand the psuedo code calculations, but his descriptions of how to actually perform the calculations (and why they work) are vague at best.

double intersect(Point pOrigin, Vector pNormal, Point rOrigin, Vector rVector)
{
double d = -(planeNormal * planeOrigin);
double numer = planeNormal * rayOrigin + d;
double denom = planeNormal * rayVector;
return -(numer / denom);
}

I sketched out an example plane and ray, then checked the projections etc. but it is far from obvious that this should work. Do you have any other resources that explain those sorts of calculations using vectors? I can do the calculations using lines and such but that is the ugliness I am hoping to avoid (not ugly in this case, but gets semi-ugly when the circle is involved).

nx*x + ny*y + nz*z + d = 0

t = -(rOrigin-pOrigin).pNormal / rVector.pNormal
t = -(c-o).n / v.n

(c+vt-o).n = r*sqrt(n.n)
[(c+vt-o).n]^2 = r^2*n.n
[(c-o).n+t(v.n)]^2 = r^2*n.n
(v.n)^2t^2 + 2(v.n)[(c-o).n]t + [(c-o).n]^2-r^2*n.n = 0

var/vn = v.x*n.x + v.y*n.y + v.z*n.z
var/cn = (c.x-o.x)*n.x + (c.y-o.y)*n.y + (c.z-o.z)*n.z
var/nn = n.x*n.x + n.y*n.y + n.z*n.z
var/rnsq = r*r*nn
// quadratic equation constants ax^2+bx+c=0
// in this case we'll just find b/2 since it's easier
var/a = vn*vn
var/b2 = vn*cn
var/c = cn*cn - rnsq
var/disc = b2*b2 - a*c      // (b^2-4ac)/4
if(disc<0)
  ...  // no intersection
var/cons = -b2/a            // = -(b/2)/a = -b/2a
disc = sqrt(disc)/a         // = sqrt(b^2-4ac)/2a
var/t0 = cons - disc
var/t1 = cons + disc

P = (c+vt)-r*n/|n|
P = (c+vt)-r*n/sqrt(nn)

var/nlen = sqrt(nn)
P.x = (c.x + v.x*t) - r*n.x/nlen
P.y = (c.y + v.y*t) - r*n.y/nlen
P.z = (c.z + v.z*t) - r*n.z/nlen

|c+vt-o| = r
(c+vt-o).(c+vt-o) = r*r
(v.v)t^2 + 2[v.(c-o)]t + (c-o).(c-0) - r*r = 0