2d collision between line and a point

Im trying to understanding collision detection in 2d world. I recently got this tutorials http://www.gotoandplay.it/_articles/2003/12/bezierCollision.php. I have question which puzzled me a lot - on the flash demo ball is dropping without responding if i try to swap the starting and 开发者_JAVA技巧end point. Can someone explain me , how the simulation works. I have modified this the sample code. It works perfect until the start and end point are swapped, Here is same code in objective c

Thanks in advance. .

-(void)render:(ccTime)dt {

 if(renderer)
 {
  CGPoint b = ball.position;


  float bvx = ball.vx;
  float bvy = ball.vy;

  bvx += .02;
  bvy -= .2;

  b.x += bvx;
  b.y += bvy;

  float br = ball.contentSize.width/2;
  for ( int p = 0 ; p < [map count]  ; p++ ) {

   line *l = [map objectAtIndex:p];
   CGPoint p0 = l.end;
   CGPoint p1 = l.start;

   float p0x = p0.x, p0y = p0.y, p1x = p1.x, p1y = p1.y;

   // get Angle //

   float dx = p0x - p1x;
   float dy = p0y - p1y;

   float angle = atan2( dy , dx );

   float _sin = sin ( angle );
   float _cos = cos ( angle );

   // rotate p1 ( need only 'x' ) //

   float p1rx = dy * _sin + dx * _cos + p0x;

   // rotate ball //

   float px = p0x - b.x;
   float py = p0y - b.y;

   float brx = py * _sin + px * _cos + p0x;
   float bry = py * _cos - px * _sin + p0y;

   float cp = ( b.x - p0x ) * ( p1y - p0y ) - ( b.y - p0y ) * ( p1x - p0x );

   if ( bry > p0y - br && brx > p0x && brx < p1rx && cp > 0 ) {

    // calc new Vector //

    float vx = bvy * _sin + bvx * _cos;
    float vy = bvy * _cos - bvx * _sin;

    vy *= -.8;
    vx *= .98;

    float __sin = sin ( -angle );
    float __cos = cos ( -angle );

    bvx = vy * __sin + vx * __cos;
    bvy = vy * __cos - vx * __sin;

    // calc new Position //

    bry = p0y - br;

    dx = p0x - brx;
    dy = p0y - bry;

    b.x = dy * __sin + dx * __cos + p0x;
    b.y = dy * __cos - dx * __sin + p0y;

   }

  }
  ball.position = b;
  ball.vx = bvx;
  ball.vy = bvy;

  if ( b.y < 42)
  {

   ball.position = ccp(50, size.height - 42);
   ball.vx = .0f;
   ball.vy = .0f;

  }
 }

}

The order of the points defines an orientation on the curve. If the start point is on the left and the end point on the right, then the curve is oriented so that "up" points above the curve. However, if you swap the start/end points the curve is oppositely oriented, so now "up" actually points below the curve.

When your code detects a collision and then corrects the velocity it is using the curve's orientation. That is why when the ball drops on the curve with the start/end points swapped it appears to jump through the curve.

To correct this your collision resolution code should check which side of the curve the ball is on (with respect to the curve's orientation), and adjust accordingly.

If you swap l.end and l.start it will serve for line without the segment (l.start, l.end). This is because all values are signed here. Algorithm turns the plane so that line is horizontal and one of the segment ends doesn't move. After that it is easy to understand whether the ball touches the line. And if it does, its speed should change: in rotated plane it just reverses y-coordinate and we should rotate it back to get line not horizontal again. In fact not a very good implementation. All this can be done without sin, cos, just vectors.