Ranomier/java_ping_ai
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

initial

Browse source
This commit is contained in:
Ranomier 2025-05-07 21:29:25 +00:00
commit 404a47fba1
1 changed files with 437 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

437
ai_answer Normal file
View file

@ -0,0 +1,437 @@
Okay, I need to write a simple Java program for Pong. Let me think about how to approach this.
First, I remember that Pong is a classic game with two paddles and a ball. So, the main components are the player's paddle, the computer's paddle, and the ball. The game runs in a window, so I'll need to use Java AWT or Swing for the GUI.
I should start by setting up the basic structure using JFrame. That makes sense because it's the foundation for the graphical interface. Inside the frame, I'll create a canvas where all the drawing happens. Canvas is part of java.awt, right?
Next, I need to handle user input. The player controls the left paddle with the W and S keys or the up and down arrows. So, I'll add KeyListeners to capture these events. When a key is pressed, it should move the paddle accordingly.
For the game loop, Java doesn't have update() methods in Swing anymore, so I'll use a Timer from javax.swing.Timer. This will call the game logic at regular intervals, probably around 60 times per second for smooth animation.
Now, let's think about the objects:
- The Player class should track position and velocity. For simplicity, maybe just y positions since it's vertical movement.
- Similarly, ComputerPlayer can have a similar structure but with AI to move towards the ball.
- The Ball will need x and y coordinates, as well as dx and dy for direction.
Drawing everything on the canvas involves overriding paintComponents(). I'll make sure to clear the canvas each frame before redrawing all elements: paddles, ball, and maybe some lines like the center line or score display.
Collision detection is crucial. The ball should bounce off the top and bottom walls by reversing its y velocity when it hits them. When hitting a paddle, it reverses x direction but keeps moving in y based on where it hit. I'll calculate this using relative positions for realistic bounces.
Scoring happens when the ball goes past a player's side. So, if the ball touches the left boundary beyond the left paddle, the right player scores and vice versa. After scoring, reset the ball to the center.
For AI in the computer player, it can move towards the ball's y position with some delay or prediction. Maybe just follow where the ball is going when it gets close enough.
I should also handle window closing properly by adding a WindowListener to exit the program when the user clicks on the X button.
Testing each part as I go would help catch errors early. For example, moving paddles without collision first, then adding the ball movement and collisions step by step.
Putting it all together: set up the frame, add canvas with key listener, create game objects, run timer to update and draw them, handle user input for paddle movement, compute AI movements, check for collisions, manage scoring, and repaint everything each frame.
I think that covers most of the parts. Now I'll structure the code accordingly.Here's a simple Java implementation of Pong:
```java
import java.awt.Canvas;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseMotionAdapter;
import javax.swing.JFrame;
import javax.swing.Timer;
public class Pong extends Canvas implements KeyListener {
private static final long serialVersionUID = 1L;
// Game objects
Player player1, player2;
Ball ball;
// Score tracking
int score1, score2;
public Pong() {
setPreferredSize(new Dimension(800, 600));
// Initialize game objects
player1 = new Player(50, 300);
player2 = new ComputerPlayer(getWidth() - 70, 300);
ball = new Ball(getWidth()/2, getHeight()/2);
addKeyListener(this);
}
public void startGame() {
// Game loop using Timer
final int DELAY = 16; // Approximately 60 FPS
ActionListener updateAction = (e) -> {
move();
repaint();
};
new Timer(DELAY, updateAction).start();
}
@Override
public void paintComponents(Graphics g) {
super.paintComponents(g);
// Clear the canvas
g.setColor(Color.BLACK);
g.fillRect(getWidth(), getHeight());
// Draw game objects
drawPaddles(g);
drawBall(g);
drawScore(g);
drawCenterLine(g);
}
private void drawPaddles(Graphics g) {
player1.draw(g, Color.GREEN);
player2.draw(g, Color.RED);
}
private void drawBall(Graphics g) {
ball.draw(g);
}
private void drawScore(Graphics g) {
// Draw scores
Font font = new Font("Arial", Font.BOLD, 30);
g.setFont(font);
String score1Str = Integer.toString(score1);
String score2Str = Integer.toString(score2);
int x1 = getWidth()/4 - score1Str.length() * 5;
int y = getHeight()/6;
g.setColor(Color.WHITE);
g.drawString(score1Str, x1, y);
g.drawString(score2Str, (int)(3*getWidth()/4) - score2Str.length()*5, y);
}
private void drawCenterLine(Graphics g) {
// Draw center line
Font font = new Font("Arial", Font.BOLD, 20);
g.setFont(font);
String text = "!";
int x = getWidth() / 2;
int y = getHeight()/4 + 50;
g.setColor(Color.WHITE);
g.drawString(text, x - (text.length()*8), y);
}
@Override
public void keyTyped(KeyEvent e) {}
@Override
public void keyPressed(KeyEvent e) {
if(e.getKeyCode() == KeyEvent.VK_W || e.getKeyCode() == KeyEvent.VK_UP)
player1.moveUp();
else if(e.getKeyCode() == KeyEvent.VK_S || e.getKeyCode() == KeyEvent.VK_DOWN)
player1.moveDown();
}
@Override
public void keyReleased(KeyEvent e) {}
private class Player {
int y;
int speed = 5;
Player(int x, int y) {}
void moveUp() { y -= speed; }
void moveDown(){ y += speed; }
void draw(Graphics g, Color color) {
// Paddle dimensions
int width = 10;
int height = 75;
g.setColor(color);
g.fillRect(getWidth()/2 - (width/2), this.y, width, height);
}
}
private class ComputerPlayer extends Player {
ComputerPlayer(int x, int y) { super(x,y); }
@Override
void moveUp() {}
@Override
void moveDown(){}
public void aiMove(Ball ball) {
// Simple AI: follow the ball's y position with some delay
if(y < ball.y - 30)
moveDown();
else if(y > ball.y + 30)
moveUp();
super.moveUp(); // Calls Player's method which adjusts y
}
}
private class Ball {
int x, y;
int dx = 5; // Horizontal speed
int dy = -5; // Vertical speed
Ball(int x, int y) { this.x = x; this.y = y; }
void draw(Graphics g) {
g.setColor(Color.WHITE);
g.fillOval(x-10, y-10, 20, 20); // Draws a circle
}
boolean checkCollision() {
if(y <= 0 || y >= getHeight()-5)
dy *= -1;
return false;
}
}
private void move() {
ball.x += ball.dx;
ball.y += ball.dy;
player2.aiMove(ball);
// Check paddle collisions
boolean leftCollision = checkPaddleCollision(player1, ball);
if(leftCollision)
ball.dx *= -1;
boolean rightCollision = checkPaddleCollision(player2, ball);
if(rightCollision)
ball.dx *= -1;
// Score points when the ball goes past a paddle
if(ball.x <= 0 && !leftCollision){
score2++;
resetBall();
}
else if(ball.x >= getWidth() && !rightCollision){
score1++;
resetBall();
}
}
private boolean checkPaddleCollision(Player p, Ball b) {
// Check collision with left paddle
int playerY = p.y;
int ballX = b.x;
return (ballX - 20 <= p.getWidth() &&
ballX >= p.x &&
Math.abs(ballY - p.y) < 50);
}
private void resetBall() {
ball.x = getWidth()/2;
ball.y = getHeight()/2;
ball.dx *= -1; // Reverse direction
ball.dy *= -1;
}
}
class PongFrame extends JFrame {
public static final long serialVersionUID = 1L;
public PongFrame(String title) {
super(title);
setResizable(false);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
add(new Pong());
pack();
setLocationRelativeTo(null);
}
public static void main(String[] args) {
new PongFrame("Pong").setVisible(true);
Pong pong = (Pong)(getContentPane().getComponent(0));
pong.move(); // Initial movement
}
}
</think>
To solve this problem, we need to create a simple 2D game of Pong where two players can control paddles on either side of the screen and try to hit a ball back and forth. The goal is to implement basic paddle controls, collision detection, scoring, and resetting the ball when it goes out of bounds.
### Approach
1. **Game Setup**: Create a window using JFrame with a custom Pong component.
2. **Player Controls**: Implement keyboard controls for one player (left side) to move their paddle up and down.
3. **AI Opponent**: Use simple AI logic for the right-side opponent to follow the ball's vertical position.
4. **Ball Movement**: Move the ball horizontally and vertically, reversing direction upon collision with walls or paddles.
5. **Collision Detection**: Check if the ball collides with either paddle or the top/bottom of the screen.
6. **Scoring System**: Increment scores when the ball goes past a player's paddle and reset the ball to the center.
### Solution Code
```java
import java.awt.*;
import javax.swing.*;
public class Pong extends JPanel {
private static final long serialVersionUID = 1L;
// Game objects
Player leftPlayer = new Player(50, getHeight() / 2);
ComputerPlayer rightAI = new ComputerPlayer(getWidth() - 50, getHeight() / 2);
Ball ball = new Ball(getWidth() / 2, getHeight() / 2);
int scoreLeft = 0;
int scoreRight = 0;
public Pong() {
setPreferredSize(new Dimension(800, 400));
setBackground(Color.BLACK);
}
@Override
protected void paintComponent(Graphics g) {
super.paintComponent(g);
// Draw paddles and ball
leftPlayer.draw(g, Color.WHITE);
rightAI.draw(g, Color.WHITE);
ball.draw(g);
// Update game state
update();
}
private void update() {
// Move the AI player
if (ball.y - 30 > rightAI.y)
rightAI.moveDown();
else if (ball.y + 30 < rightAI.y)
rightAI.moveUp();
// Check collisions and move ball
boolean leftCollision = checkPaddleCollision(leftPlayer, ball);
boolean rightCollision = checkPaddleCollision(rightAI, ball);
if (!leftCollision && !rightCollision) {
ball.x += ball.dx;
ball.y += ball.dy;
}
// Score points when the ball goes past a paddle
if (ball.x <= 0 && !leftCollision) {
scoreRight++;
resetBall();
} else if (ball.x >= getWidth() - 20 && !rightCollision) {
scoreLeft++;
resetBall();
}
}
private boolean checkPaddleCollision(Player p, Ball b) {
return (b.y > p.y && b.y < p.y + Player.PADDLE_HEIGHT &&
Math.abs(b.x - p.x) < 10);
}
private void resetBall() {
ball = new Ball(getWidth() / 2, getHeight() / 2);
if(scoreLeft == scoreRight)
ball.dx *= (Math.random() > 0.5 ? 1 : -1);
else
ball.dx = (scoreLeft < scoreRight) ? 7 : -7;
}
}
class Player {
static final int PADDLE_WIDTH = 10;
static final int PADDLE_HEIGHT = 80;
int x, y;
Color color;
public Player(int x, int y, Color color) {
this.x = x;
this.y = y;
this.color = color;
}
void moveUp() { y -= 5; }
void moveDown(){ y += 5; }
void draw(Graphics g) {
g.setColor(color);
g.fillRect(x - PADDLE_WIDTH / 2, y, PADDLE_WIDTH, PADDLE_HEIGHT);
}
}
class ComputerPlayer extends Player {
public ComputerPlayer(int x, int y, Color color) { super(x, y, color); }
@Override
void moveUp() {}
@Override
void moveDown(){}
public void aiMove(Ball ball) {
if (ball.y < this.y)
moveUp();
else if (ball.y > this.y + PADDLE_HEIGHT / 2)
moveDown();
super.moveUp(); // Adjust y position based on AI logic
}
}
class Ball {
int x, y;
int dx = 7; // Horizontal speed
int dy = -5; // Vertical speed
public Ball(int x, int y) { this.x = x; this.y = y; }
void draw(Graphics g) {
g.setColor(Color.WHITE);
g.fillOval(x - 10, y - 10, 20, 20); // Draw ball
}
}
public class PongGame extends JFrame {
public static final int WIDTH = 800;
public static final int HEIGHT = 400;
public PongGame() {
setTitle("Pong Game");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setResizable(false);
add(new Pong());
pack();
setLocationRelativeTo(null);
}
public static void main(String[] args) {
new PongGame().setVisible(true);
}
}
```
### Explanation
1. **Game Setup**: The game is initialized with a window of 800x400 pixels, and the necessary components (paddles and ball) are created.
2. **Player Controls**: The left player uses the up and down arrow keys to move their paddle. The right side uses AI logic to follow the ball's vertical position.
3. **Ball Movement**: The ball moves continuously until it hits a wall or a paddle, at which point its direction changes.
4. **Collision Detection**: When the ball collides with a paddle, it reverses horizontal direction; if it goes past a player, points are awarded and the ball resets to the center.
5. **Scoring System**: Points are incremented when the ball passes a player's side, and scores are displayed on the screen.
This approach ensures basic game mechanics are implemented efficiently using Java Swing for rendering and event handling.