Pong: How does the paddle know where the ball will

Question

After implementing Pacman and Snake I'm implementing the next very very classic game: Pong.

The implementation is really simple, but I just have one little problem remaining. When one of the paddle (I'm not sure if it is called paddle) is controlled by the computer, I have trouble to position it at the correct position.

The ball has a current position, a speed (which for now is constant) and a direction angle. So I could calculate the position where it will hit the side of the computer controlled paddle. And so Icould position the paddle right there. But however in the real game, there is a probability that the computer's paddle will miss the ball. How can I implement this probability?

If I only use a probability of lets say 0.5 that the computer's paddle will hit the ball, the problem is solved, but I think it isn't that simple.

From the original game I think the probability depends on the distance between the current paddle position and the position the ball will hit the border.

Does anybody have any hints how exactly this is calculated?

Answer 1

after several iterations, if your paddle (that is yours or the AI's depending on your perspective) is too close to the top or bottom of the screen it is simply impossible to cover the distance required. The paddle can easily just follow the y-value of the ball. If you are too far you'll miss.

Alternatively, you can have the AI reset to center after each hit, or travel toward the center as long as the ball is moving away (i.e. toward the opponent)

Or more briefly:
- move toward the center while the ball is moving away - imitate y-coordinate of ball while it is approaching.

from here you can change the difficulty by making the y-coord imitation mechanism slower than the ball (more consistent, and probably what the original implementation was like; as difficulties are abstracted into simple speed coefficients), or adding random error to each movement or otherwise.

Answer 2

I'm not sure what the 'official' way to do this is, but I've always just used (pseudocode)

if (ball is above paddle) {
    move paddle up
}
if (ball is below paddle) {
    move paddle down
}

Then I gave the paddle a slightly varying speed that was slow enough that it couldn't always keep up with the ball. Kind of crude, but it works.

This thread also has some interesting ideas you might want to look at: http://www.gamedev.net/community/forums/topic.asp?topic_id=439576

Answer 3

Quoting from the very enjoyable book "Racing the Beam" (Google Books: http://books.google.co.uk/books?id=DqePfdz_x6gC&lpg=PP1&dq=racing%20the%20beam&pg=PA40#v=onepage&q&f=false) the original technique was:

To help simulate the human error inherent in precise paddle positioning, The AI paddle skips its adjustment every eight frames. The resulting behaviour is visibly unnoticeable, but it allows the computer player's aim to drift enough that it occasionally misses the ball. It is also technically trivial to implement, requiring only a single mask and the binary AND operation, for which there exists a corresponding 6502 instruction. The programmer can test if the result is zero with another single opcode, branching if needed to skip the instructions that move the paddle.

Even this behaviour must be modified slightly for the game to work at all. If the AI player simply stopped tracking the ball every eight frames, it would be hopelessly out of sync within a few seconds. To prevent this, the AI follows a secondary ball-tracking scheme near the top and bottom of the playfield. If the ball collides with one of these walls while the paddle is also aligned with it, the paddle readjusts, recovering from any drift that had accumulated since the ball last struck the wall. The result is a stochastic misalignment and realignment of computer paddle and ball.

Answer 4

It just so happens I wrote a pong clone the other day just for fun.

You can play it here and view the source code here.

The AI takes the ball's current speed and multiplies the x-distance away from the wall. It then moves towards that calculated position at a capped speed. It doesn't account for vertical bounces, but that's sort of intended (to make the AI beatable).

Here is the relevant snippet:

/* Update enemy based on simple AI */
enemy.update = function (delta) {
    var impactDistance, impactTime, targetY, speed;
    speed = .25; // a little slower than the human player

    if (ball.vx < 0) {
        // Ball is moving away, AI takes a nap ..
        return;
    }

    // Figure out linear trajectory ..
    impactDistance = width - ball.width - ball.x;
    impactTime = impactDistance / (ball.vx * .25 * 1000);
    targetY = ball.y + (ball.vy * .25 * 1000) * impactTime;

    if (Math.abs(targetY - (this.y + this.height/2)) < 10) {
        // AI doesn't need to move
        return;
    }

    if (targetY < this.y + (this.height / 2)) {
        // Move up if ball is going above paddle
        speed = -speed;
    }

    this.y += speed * delta;
    this.keepInBounds();
};

Answer 5

Other answers discuss how to decide the correct direction to move in in different circumstances. You can also add a lag time before the computer player "reacts" by starting to move in this direction -- that mirrors the typical response of human players.

Answer 6

I would think you should have the paddle always move from its current position to a specific point, which would be where the ball is expected to align vertically with the paddle. You could then have a 50% chance that the paddle will move to this exact point and deflect the ball, a 25% chance that it will overshoot, perhaps by some X pixels, and 25% chance that it will undershoot. An even better way to do it might be to have it move to that position on a bell curve so that it misses by different amounts each time.