**0**

###
#1
Members - Reputation: **594**

Posted 20 August 2012 - 05:13 AM

I am wanting to make a pong clone to test my new knowledge with Java and slick. i haven't started anything yet but im planning it out. I am just a it confused on how you get the direction the ball goes after you hit it with the paddle. I don't know anything about physics (im taking it in school though). do i just randomly generate a direction or is there some stupid long mathematical equation thanks for any help.

###
#2
Members - Reputation: **121**

Posted 20 August 2012 - 05:28 AM

That doesn't sound good regardless of how much I spin it around in my head."stupid long mathematical equation"

Anyway, you could just go with some simple conditional statements and inverse the direction of the ball. If you want something more complex you'd have to do some vector maths with at least the ball's direction vector, the paddle's forward vector and the position the ball hit the paddle.

[source lang="cpp"] // edge of playing field if (pong.ball.centre_y > 0.6f) { pong.ball_velocity_y = -ball_speed; } else if (pong.ball.centre_y < -0.6f) { pong.ball_velocity_y = ball_speed; } // ball hit a paddle on the right side if (pong.ball_velocity_x > 0 && collides(&pong.ball, &pong.bats[1]) ) { pong.ball_velocity_x = -pong.ball_velocity_x; } // ball hit a paddle on the left side if (pong.ball_velocity_x < 0 && collides(&pong.ball, &pong.bats[0]) ) { pong.ball_velocity_x = -pong.ball_velocity_x; }[/source]

**Edited by Tudor Nita, 20 August 2012 - 06:09 AM.**

###
#4
Crossbones+ - Reputation: **9068**

Posted 20 August 2012 - 06:07 AM

The slowsort algorithm is a perfect illustration of the multiply and surrender paradigm, which is perhaps the single most important paradigm in the development of reluctant algorithms. The basic multiply and surrender strategy consists in replacing the problem at hand by two or more subproblems, each slightly simpler than the original, and continue multiplying subproblems and subsubproblems recursively in this fashion as long as possible. At some point the subproblems will all become so simple that their solution can no longer be postponed, and we will have to surrender. Experience shows that, in most cases, by the time this point is reached the total work will be substantially higher than what could have been wasted by a more direct approach.

- *Pessimal Algorithms and Simplexity Analysis*