当前位置：首页 > news >正文

和平精英java 游戏程序

news 2025/11/7 8:35:30

以下是一个简化版的和平精英游戏程序，使用Java Swing实现。

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.util.ArrayList;
import java.util.Random;

public class PeaceEliteGame extends JPanel implements ActionListener, KeyListener {
// 游戏常量
private static final int WIDTH = 800;
private static final int HEIGHT = 600;
private static final int PLAYER_SIZE = 30;
private static final int ENEMY_SIZE = 25;
private static final int BULLET_SIZE = 5;
private static final int ITEM_SIZE = 20;
private static final int PLAYER_SPEED = 5;
private static final int BULLET_SPEED = 10;

// 游戏状态
private enum GameState { MENU, PLAYING, GAME_OVER, WIN }
private GameState gameState = GameState.MENU;

// 游戏元素
private Player player;
private ArrayList<Enemy> enemies;
private ArrayList<Bullet> bullets;
private ArrayList<Item> items;
private Random random;
private Timer timer;

// 游戏数据
private int score;
private int playerHealth;
private int ammo;
private int enemiesRemaining;
private int level;

// 图像资源（简化版使用颜色代替）
private Color playerColor = Color.BLUE;
private Color enemyColor = Color.RED;
private Color bulletColor = Color.YELLOW;
private Color healthItemColor = Color.GREEN;
private Color ammoItemColor = Color.ORANGE;

public PeaceEliteGame() {
setPreferredSize(new Dimension(WIDTH, HEIGHT));
setBackground(Color.BLACK);
setFocusable(true);
addKeyListener(this);

random = new Random();
initGame();

timer = new Timer(30, this);
timer.start();
}

private void initGame() {
player = new Player(WIDTH / 2, HEIGHT / 2);
enemies = new ArrayList<>();
bullets = new ArrayList<>();
items = new ArrayList<>();

score = 0;
playerHealth = 100;
ammo = 30;
level = 1;
enemiesRemaining = 5;

spawnEnemies(5);
spawnItems(3);
}

private void spawnEnemies(int count) {
for (int i = 0; i < count; i++) {
int x, y;
boolean validPosition;

do {
validPosition = true;
x = random.nextInt(WIDTH - ENEMY_SIZE);
y = random.nextInt(HEIGHT - ENEMY_SIZE);

// 确保敌人不会生成在玩家附近
if (Math.abs(x - player.x) < 100 && Math.abs(y - player.y) < 100) {
validPosition = false;
}

// 确保敌人不会相互重叠
for (Enemy enemy : enemies) {
if (Math.abs(x - enemy.x) < 50 && Math.abs(y - enemy.y) < 50) {
validPosition = false;
break;
}
}
} while (!validPosition);

enemies.add(new Enemy(x, y));
}
}

private void spawnItems(int count) {
for (int i = 0; i < count; i++) {
int x = random.nextInt(WIDTH - ITEM_SIZE);
int y = random.nextInt(HEIGHT - ITEM_SIZE);
Item.Type type = random.nextBoolean() ? Item.Type.HEALTH : Item.Type.AMMO;
items.add(new Item(x, y, type));
}
}

@Override
protected void paintComponent(Graphics g) {
super.paintComponent(g);

switch (gameState) {
case MENU:
drawMenu(g);
break;
case PLAYING:
drawGame(g);
break;
case GAME_OVER:
drawGameOver(g);
break;
case WIN:
drawWinScreen(g);
break;
}
}

private void drawMenu(Graphics g) {
g.setColor(Color.WHITE);
g.setFont(new Font("Arial", Font.BOLD, 36));
g.drawString("和平精英", WIDTH / 2 - 100, HEIGHT / 2 - 50);

g.setFont(new Font("Arial", Font.PLAIN, 18));
g.drawString("按空格键开始游戏", WIDTH / 2 - 80, HEIGHT / 2);
g.drawString("WASD 移动, 鼠标点击射击", WIDTH / 2 - 120, HEIGHT / 2 + 30);
g.drawString("收集绿色(生命)和橙色(弹药)物品", WIDTH / 2 - 160, HEIGHT / 2 + 60);
}

private void drawGame(Graphics g) {
// 绘制玩家
g.setColor(playerColor);
g.fillRect(player.x, player.y, PLAYER_SIZE, PLAYER_SIZE);

// 绘制敌人
g.setColor(enemyColor);
for (Enemy enemy : enemies) {
g.fillRect(enemy.x, enemy.y, ENEMY_SIZE, ENEMY_SIZE);
}

// 绘制子弹
g.setColor(bulletColor);
for (Bullet bullet : bullets) {
g.fillRect(bullet.x, bullet.y, BULLET_SIZE, BULLET_SIZE);
}

// 绘制物品
for (Item item : items) {
if (item.type == Item.Type.HEALTH) {
g.setColor(healthItemColor);
} else {
g.setColor(ammoItemColor);
}
g.fillRect(item.x, item.y, ITEM_SIZE, ITEM_SIZE);
}

// 绘制UI
drawUI(g);
}

private void drawUI(Graphics g) {
g.setColor(Color.WHITE);
g.setFont(new Font("Arial", Font.PLAIN, 14));

// 生命值条
g.drawString("生命值: " + playerHealth, 10, 20);
g.setColor(Color.RED);
g.fillRect(80, 10, playerHealth, 10);
g.setColor(Color.WHITE);
g.drawRect(80, 10, 100, 10);

// 弹药
g.drawString("弹药: " + ammo, 10, 40);

// 分数和等级
g.drawString("分数: " + score, 10, 60);
g.drawString("等级: " + level, 10, 80);
g.drawString("剩余敌人: " + enemiesRemaining, 10, 100);
}

private void drawGameOver(Graphics g) {
g.setColor(Color.RED);
g.setFont(new Font("Arial", Font.BOLD, 36));
g.drawString("游戏结束", WIDTH / 2 - 100, HEIGHT / 2 - 50);

g.setColor(Color.WHITE);
g.setFont(new Font("Arial", Font.PLAIN, 18));
g.drawString("最终分数: " + score, WIDTH / 2 - 60, HEIGHT / 2);
g.drawString("按R键重新开始", WIDTH / 2 - 70, HEIGHT / 2 + 30);
}

private void drawWinScreen(Graphics g) {
g.setColor(Color.GREEN);
g.setFont(new Font("Arial", Font.BOLD, 36));
g.drawString("胜利!", WIDTH / 2 - 50, HEIGHT / 2 - 50);

g.setColor(Color.WHITE);
g.setFont(new Font("Arial", Font.PLAIN, 18));
g.drawString("最终分数: " + score, WIDTH / 2 - 60, HEIGHT / 2);
g.drawString("按R键重新开始", WIDTH / 2 - 70, HEIGHT / 2 + 30);
}

@Override
public void actionPerformed(ActionEvent e) {
if (gameState == GameState.PLAYING) {
updateGame();
}
repaint();
}

private void updateGame() {
// 更新子弹位置
for (int i = bullets.size() - 1; i >= 0; i--) {
Bullet bullet = bullets.get(i);
bullet.x += bullet.dx;
bullet.y += bullet.dy;

// 移除超出屏幕的子弹
if (bullet.x < 0 || bullet.x > WIDTH || bullet.y < 0 || bullet.y > HEIGHT) {
bullets.remove(i);
continue;
}

// 检测子弹与敌人的碰撞
for (int j = enemies.size() - 1; j >= 0; j--) {
Enemy enemy = enemies.get(j);
if (bullet.intersects(enemy)) {
bullets.remove(i);
enemies.remove(j);
score += 10;
enemiesRemaining--;

// 随机掉落物品
if (random.nextDouble() < 0.3) {
Item.Type type = random.nextBoolean() ? Item.Type.HEALTH : Item.Type.AMMO;
items.add(new Item(enemy.x, enemy.y, type));
}

// 检查是否所有敌人都被消灭
if (enemies.isEmpty()) {
if (level < 3) {
level++;
enemiesRemaining = 5 + level * 2;
spawnEnemies(5 + level * 2);
playerHealth = 100; // 恢复生命值
ammo += 20; // 补充弹药
} else {
gameState = GameState.WIN;
}
}
break;
}
}
}

// 更新敌人位置
for (Enemy enemy : enemies) {
enemy.move(player.x, player.y);

// 检测敌人与玩家的碰撞
if (enemy.intersects(player)) {
playerHealth -= 1;
if (playerHealth <= 0) {
gameState = GameState.GAME_OVER;
}
}

// 敌人随机射击
if (random.nextInt(200) < 1) {
int dx = player.x - enemy.x;
int dy = player.y - enemy.y;
double distance = Math.sqrt(dx * dx + dy * dy);
if (distance > 0) {
dx = (int) (BULLET_SPEED * dx / distance);
dy = (int) (BULLET_SPEED * dy / distance);
bullets.add(new Bullet(enemy.x + ENEMY_SIZE / 2, enemy.y + ENEMY_SIZE / 2, dx, dy));
}
}
}

// 检测子弹与玩家的碰撞
for (int i = bullets.size() - 1; i >= 0; i--) {
Bullet bullet = bullets.get(i);
if (bullet.intersects(player)) {
bullets.remove(i);
playerHealth -= 10;
if (playerHealth <= 0) {
gameState = GameState.GAME_OVER;
}
}
}

// 检测物品与玩家的碰撞
for (int i = items.size() - 1; i >= 0; i--) {
Item item = items.get(i);
if (item.intersects(player)) {
if (item.type == Item.Type.HEALTH) {
playerHealth = Math.min(100, playerHealth + 30);
} else {
ammo += 15;
}
items.remove(i);
}
}
}

@Override
public void keyPressed(KeyEvent e) {
if (gameState == GameState.MENU && e.getKeyCode() == KeyEvent.VK_SPACE) {
gameState = GameState.PLAYING;
} else if ((gameState == GameState.GAME_OVER || gameState == GameState.WIN) &&
e.getKeyCode() == KeyEvent.VK_R) {
initGame();
gameState = GameState.PLAYING;
} else if (gameState == GameState.PLAYING) {
switch (e.getKeyCode()) {
case KeyEvent.VK_W:
player.y = Math.max(0, player.y - PLAYER_SPEED);
break;
case KeyEvent.VK_S:
player.y = Math.min(HEIGHT - PLAYER_SIZE, player.y + PLAYER_SPEED);
break;
case KeyEvent.VK_A:
player.x = Math.max(0, player.x - PLAYER_SPEED);
break;
case KeyEvent.VK_D:
player.x = Math.min(WIDTH - PLAYER_SIZE, player.x + PLAYER_SPEED);
break;
}
}
}

@Override
public void keyReleased(KeyEvent e) {}

@Override
public void keyTyped(KeyEvent e) {}

public void mousePressed(MouseEvent e) {
if (gameState == GameState.PLAYING && ammo > 0) {
int dx = e.getX() - (player.x + PLAYER_SIZE / 2);
int dy = e.getY() - (player.y + PLAYER_SIZE / 2);
double distance = Math.sqrt(dx * dx + dy * dy);

if (distance > 0) {
dx = (int) (BULLET_SPEED * dx / distance);
dy = (int) (BULLET_SPEED * dy / distance);
bullets.add(new Bullet(player.x + PLAYER_SIZE / 2, player.y + PLAYER_SIZE / 2, dx, dy));
ammo--;
}
}
}

// 玩家类
class Player {
int x, y;

Player(int x, int y) {
this.x = x;
this.y = y;
}
}

// 敌人类
class Enemy {
int x, y;

Enemy(int x, int y) {
this.x = x;
this.y = y;
}

void move(int targetX, int targetY) {
// 简单的追逐AI
if (x < targetX) x += 1;
if (x > targetX) x -= 1;
if (y < targetY) y += 1;
if (y > targetY) y -= 1;

// 边界检查
x = Math.max(0, Math.min(WIDTH - ENEMY_SIZE, x));
y = Math.max(0, Math.min(HEIGHT - ENEMY_SIZE, y));
}

boolean intersects(Player player) {
return x < player.x + PLAYER_SIZE &&
x + ENEMY_SIZE > player.x &&
y < player.y + PLAYER_SIZE &&
y + ENEMY_SIZE > player.y;
}
}

// 子弹类
class Bullet {
int x, y;
int dx, dy;

Bullet(int x, int y, int dx, int dy) {
this.x = x;
this.y = y;
this.dx = dx;
this.dy = dy;
}

boolean intersects(Enemy enemy) {
return x < enemy.x + ENEMY_SIZE &&
x + BULLET_SIZE > enemy.x &&
y < enemy.y + ENEMY_SIZE &&
y + BULLET_SIZE > enemy.y;
}

boolean intersects(Player player) {
return x < player.x + PLAYER_SIZE &&
x + BULLET_SIZE > player.x &&
y < player.y + PLAYER_SIZE &&
y + BULLET_SIZE > player.y;
}
}

// 物品类
class Item {
enum Type { HEALTH, AMMO }

int x, y;
Type type;

Item(int x, int y, Type type) {
this.x = x;
this.y = y;
this.type = type;
}

boolean intersects(Player player) {
return x < player.x + PLAYER_SIZE &&
x + ITEM_SIZE > player.x &&
y < player.y + PLAYER_SIZE &&
y + ITEM_SIZE > player.y;
}
}

public static void main(String[] args) {
JFrame frame = new JFrame("和平精英");
PeaceEliteGame game = new PeaceEliteGame();

// 添加鼠标监听器
game.addMouseListener(new MouseAdapter() {
@Override
public void mousePressed(MouseEvent e) {
game.mousePressed(e);
}
});

frame.add(game);
frame.pack();
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setLocationRelativeTo(null);
frame.setVisible(true);
}
}