Return to Question

When I set the intersection point, if I for example use 0.1 instead of 0.001 the puck travels further before it gets stuck, but for all values I have tried (including 0 -> the real intersection point) it gets stuck somewhere (but I necessarily not get a stack overflow). Can something in this part be the cause if my problem?

When I set the intersection point, if I for example use 0.1 instead of 0.001 the puck travels further before it gets stuck, but for all values I have tried (including 0 -> the real intersection point) it gets stuck somewhere (but I necessarily not get a stack overflow). Can something in this part be the cause of my problem?

I can see why I get the stack overflow when using -1.0 when calculating the new velocity vector; but not how to solve it. I traced the time steps used in the recursion (initial time step is always 1/60 ~ 0.01666):

Recursion depth   Time step next recursive call
[Start recursion, time step ~ 0.016666]
0                 0,000985806527246773
[No collision, stop recursion]
[Start recursion, time step ~ 0.016666]
0                 0,0149596704364629
1                 0,0144883449376379
2                 0,0143155612984837
3                 0,014224925727213
4                 0,0141673917461608
5                 0,0141265435314026
6                 0,0140953966184117
7                 0,0140704653746625
...and so on.

As you can see the collision is detected early in every recursive call which means the next time step decreases very slowly thus the recursion depth gets very big -> stack overflow.

EDIT2:

This is the code I use for collision detection, maybe it has something to do with the fact that I can't make the puck slide (-1.0) but only reflect (-2.0):

/* Point is the current position (not the predicted one) and quadrant is 4 for the bottom-right corner for example. */
if (GeometryHelper.PointInCircleQuadrant(circleCenter, circleRadius, state.Position, quadrant))
{
    /* The line is: from = state.Position, to = futurePosition. So a collision is detected when from is inside the circle and to is outside. */
    if (GeometryHelper.LineCircleIntersection2d(state.Position, futurePosition, circleCenter, circleRadius, intersectionPoint, quadrant))
    {
        collisionFound = true;

        /* Set the intersection point to slightly before the real intersection point (I read somewhere this was good to do because of floting point precision, not sure exactly how much though). */
        intersectionPoint = intersectionPoint - Vector2.NormalizeRet(state.Velocity) * 0.001;

        /* Normal at the intersection point. */
        intersectionPointNormal = Vector2.NormalizeRet(circleCenter - intersectionPoint)
    }
}

When I set the intersection point, if I for example use 0.1 instead of 0.001 the puck travels further before it gets stuck, but for all values I have tried (including 0 -> the real intersection point) it gets stuck somewhere (but I necessarily not get a stack overflow). Can something in this part be the cause if my problem?

EDIT: A combination of Patrick Hughes' and teodron's answers solved the velocity problem (I think), thanks a lot! This is the new code:

I decided to use a separate recursion method now too since I don't want to recalculate the acceleration in each recursion.

public override void Update(double fixedTimeStep)
{
    Acceleration.Zero();// = CalculateAcceleration(fixedTimeStep);

    PreviousState = new MovingEntityState(CurrentState.Position, CurrentState.Velocity);

    CurrentState = SlidingCollision(CurrentState, fixedTimeStep);

    Heading = Vector2.NormalizeRet(CurrentState.Velocity);
}

private MovingEntityState SlidingCollision(MovingEntityState state, double timeStep)
{
    bool collisionFound = false;

    /* Calculate the next position given no detected collision. */
    Vector2 futurePosition = state.Position + state.Velocity * timeStep;

    Vector2 intersectionPoint = new Vector2();

    Vector2 intersectionPointNormal = new Vector2();

    /* I did not include the collision detection code, if a collision is detected the intersection point and normal in that point is returned. */

    /* If no collision was detected it is safe to move to the future position. */
    if (!collisionFound)
        return new MovingEntityState(futurePosition, state.Velocity);

    /* Set new position to the intersection point (slightly before). */
    Vector2 newPosition = intersectionPoint;

    /* Project the new velocity along the intersection normal. */
    Vector2 newVelocity = state.Velocity - 1.90 * intersectionPointNormal * state.Velocity.DotProduct(intersectionPointNormal);

    /* Calculate the time of collision. */
    double timeOfCollision = Math.Sqrt((newPosition - state.Position).LengthSq() / (futurePosition - state.Position).LengthSq());

    /* Calculate new time step, remaining time of full step after the collision * current time step. */
    double newTimeStep = timeStep * (1 - timeOfCollision);

    return SlidingCollision(new MovingEntityState(newPosition, newVelocity), newTimeStep);
}

Even though the code above seems to slide the puck correctly please have a look at it.

I have a few questions, if I don't multiply by 1.90 in the newVelocity calculation it doesn't work (I get a stack overflow when the puck enters the corner because the timeStep decreases very slowly -> a collision is found early in every recursion), why is that? what does 1.90 really do and why 1.90?

Also I have a new problem, the puck does not move parallell to the short side after exiting the curve; to be more exact it moves outside the rink (I am not checking for any collisions with the short side at the moment). When I perform the collision detection I first check that the puck is in the correct quadrant. For example bottom-right corner is quadrant four i.e. circleCenter.X < puck.X && circleCenter.Y > puck.Y is this a problem? or should the short side of the rink be the one to make the puck go parallell to it and not the last collision in the corner?