pg26wfsba
/
five-pieces
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

ADD file via upload

Browse Source
main
pg26wfsba 4 months ago
parent a2ae9f645c
commit 7deb4b23ce
1 changed files with 712 additions and 0 deletions
Show Stats Download Patch File Download Diff File

712
src/GomokuGame.java
Unescape View File

@ -0,0 +1,712 @@
package fivepieces;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import javax.sound.sampled.*;
import java.util.Stack;
public class GomokuGame extends JFrame{
private static final int BOARD_SIZE = 15;
private static final int CELL_SIZE = 40;
private static final int MARGIN = 30;
private static final int PIECE_SIZE = 36;
private int[][] board = new int[BOARD_SIZE][BOARD_SIZE]; // 0: empty, 1: black, 2: white
private boolean blackTurn = true;
private boolean gameOver = false;
private boolean aiMode = false;
private boolean playerIsBlack = true; // 玩家执黑先手
private Clip backgroundMusic;
private Stack<int[][]> history = new Stack<>();
private Stack<int[][]> redoStack = new Stack<>();
private static final int AI_SEARCH_DEPTH = 3; // 搜索深度
private static final int WIN_SCORE = 100000; // 获胜分数
private static final int BLOCK_WIN_SCORE = 50000; // 阻止获胜分数
public GomokuGame() {
setTitle("五子棋游戏");
setSize(BOARD_SIZE * CELL_SIZE + 2 * MARGIN, BOARD_SIZE * CELL_SIZE + 2 * MARGIN + 100);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setLocationRelativeTo(null);
// 加载背景音乐
loadBackgroundMusic();
// 添加游戏面板
add(new GamePanel(), BorderLayout.CENTER);
// 添加控制面板
JPanel controlPanel = new JPanel(new GridLayout(2, 3, 5, 5));
JButton restartButton = new JButton("重新开始");
restartButton.addActionListener(e -> restartGame());
JButton musicButton = new JButton("背景音乐 开/关");
musicButton.addActionListener(e -> toggleMusic());
JButton aiButton = new JButton("AI对战 开/关");
aiButton.addActionListener(e -> toggleAIMode());
JButton saveButton = new JButton("存档");
saveButton.addActionListener(e -> saveGame());
JButton loadButton = new JButton("读档");
loadButton.addActionListener(e -> loadGame());
JButton undoButton = new JButton("悔棋");
undoButton.addActionListener(e -> undoMove());
controlPanel.add(restartButton);
controlPanel.add(musicButton);
controlPanel.add(aiButton);
controlPanel.add(saveButton);
controlPanel.add(loadButton);
controlPanel.add(undoButton);
add(controlPanel, BorderLayout.SOUTH);
setVisible(true);
}
private void loadBackgroundMusic() {
try {
// 注意：你需要准备一个background.wav文件放在项目根目录下
// 或者修改为你的音乐文件路径
AudioInputStream audioInputStream = AudioSystem.getAudioInputStream(
new File("one.wav").getAbsoluteFile());
backgroundMusic = AudioSystem.getClip();
backgroundMusic.open(audioInputStream);
backgroundMusic.loop(Clip.LOOP_CONTINUOUSLY);
} catch (Exception e) {
JOptionPane.showMessageDialog(this, "无法加载背景音乐: " + e.getMessage());
}
}
private void toggleMusic() {
if (backgroundMusic != null) {
if (backgroundMusic.isRunning()) {
backgroundMusic.stop();
} else {
backgroundMusic.start();
}
}
}
private void toggleAIMode() {
aiMode = !aiMode;
if (aiMode) {
int option = JOptionPane.showOptionDialog(this,
"选择执子颜色", "AI对战",
JOptionPane.YES_NO_OPTION, JOptionPane.QUESTION_MESSAGE,
null, new String[]{"执黑先手", "执白后手"}, "执黑先手");
playerIsBlack = (option == 0);
// 如果AI先手，让它先走一步
if (!playerIsBlack && aiMode) {
makeAIMove();
}
}
restartGame();
}
private void saveGameState() {
// 深拷贝当前棋盘状态
int[][] currentState = new int[BOARD_SIZE][BOARD_SIZE];
for (int i = 0; i < BOARD_SIZE; i++) {
System.arraycopy(board[i], 0, currentState[i], 0, BOARD_SIZE);
}
history.push(currentState);
redoStack.clear(); // 新的操作后，重做栈清空
}
private void undoMove() {
if (history.size() > 1) { // 保留初始空棋盘状态
redoStack.push(history.pop());
board = history.peek();
blackTurn = !blackTurn;
gameOver = false;
repaint();
} else {
JOptionPane.showMessageDialog(this, "无法再悔棋了");
}
}
private void redoMove() {
if (!redoStack.isEmpty()) {
history.push(redoStack.pop());
board = history.peek();
blackTurn = !blackTurn;
repaint();
}
}
private void saveGame() {
try (ObjectOutputStream oos = new ObjectOutputStream(
new FileOutputStream("gomoku_save.dat"))) {
SaveData data = new SaveData(board, blackTurn, gameOver, aiMode, playerIsBlack);
oos.writeObject(data);
JOptionPane.showMessageDialog(this, "游戏已保存");
} catch (IOException e) {
JOptionPane.showMessageDialog(this, "保存游戏失败: " + e.getMessage());
}
}
private void loadGame() {
try (ObjectInputStream ois = new ObjectInputStream(
new FileInputStream("gomoku_save.dat"))) {
SaveData data = (SaveData) ois.readObject();
board = data.getBoard();
blackTurn = data.isBlackTurn();
gameOver = data.isGameOver();
aiMode = data.isAiMode();
playerIsBlack = data.isPlayerIsBlack();
// 重置历史栈
history.clear();
redoStack.clear();
saveGameState(); // 保存当前状态到历史
repaint();
JOptionPane.showMessageDialog(this, "游戏已加载");
} catch (IOException | ClassNotFoundException e) {
JOptionPane.showMessageDialog(this, "加载游戏失败: " + e.getMessage());
}
}
private void restartGame() {
board = new int[BOARD_SIZE][BOARD_SIZE];
blackTurn = true;
gameOver = false;
// 重置历史栈
history.clear();
redoStack.clear();
saveGameState(); // 保存初始状态
// 如果AI先手，让它先走一步
if (aiMode && !playerIsBlack) {
makeAIMove();
}
repaint();
}
private void makeMove(int x, int y) {
if (gameOver) return;
if (x >= 0 && x < BOARD_SIZE && y >= 0 && y < BOARD_SIZE && board[x][y] == 0) {
saveGameState();
board[x][y] = blackTurn ? 1 : 2;
if (checkWin(x, y)) {
gameOver = true;
JOptionPane.showMessageDialog(GomokuGame.this,
(blackTurn ? "黑方" : "白方") + "获胜！");
}
blackTurn = !blackTurn;
repaint();
// AI模式且轮到AI下棋
if (aiMode && !gameOver && ((playerIsBlack && !blackTurn) || (!playerIsBlack && blackTurn))) {
Timer timer = new Timer(500, e -> {
makeAIMove();
((Timer)e.getSource()).stop();
});
timer.setRepeats(false);
timer.start();
}
}
}
private void makeAIMove() {
// 使用MiniMax算法寻找最佳移动
int[] bestMove = findBestMoveWithMiniMax();
if (bestMove != null) {
makeMove(bestMove[0], bestMove[1]);
}
}
private int[] findBestMoveWithMiniMax() {
int player = playerIsBlack ? 2 : 1; // AI的棋子颜色
int opponent = playerIsBlack ? 1 : 2; // 玩家的棋子颜色
int bestScore = Integer.MIN_VALUE;
int[] bestMove = null;
// 获取所有可能的移动
java.util.List<int[]> possibleMoves = generatePossibleMoves();
for (int[] move : possibleMoves) {
int x = move[0], y = move[1];
// 尝试这个移动
board[x][y] = player;
// 计算这个移动的分数
int score = miniMax(AI_SEARCH_DEPTH - 1, false, player, opponent,
Integer.MIN_VALUE, Integer.MAX_VALUE);
// 撤销移动
board[x][y] = 0;
// 更新最佳移动
if (score > bestScore) {
bestScore = score;
bestMove = new int[]{x, y};
}
}
return bestMove;
}
private int miniMax(int depth, boolean isMaximizing, int player, int opponent,
int alpha, int beta) {
// 检查游戏是否结束或达到最大深度
if (depth == 0 || isGameOver()) {
return evaluateBoard(player, opponent);
}
// 生成可能的移动
java.util.List<int[]> possibleMoves = generatePossibleMoves();
if (isMaximizing) {
int bestScore = Integer.MIN_VALUE;
for (int[] move : possibleMoves) {
int x = move[0], y = move[1];
// 尝试这个移动
board[x][y] = player;
// 递归调用
int score = miniMax(depth - 1, false, player, opponent, alpha, beta);
// 撤销移动
board[x][y] = 0;
// 更新最佳分数
bestScore = Math.max(bestScore, score);
alpha = Math.max(alpha, bestScore);
// Alpha-Beta剪枝
if (beta <= alpha) {
break;
}
}
return bestScore;
} else {
int bestScore = Integer.MAX_VALUE;
for (int[] move : possibleMoves) {
int x = move[0], y = move[1];
// 尝试这个移动
board[x][y] = opponent;
// 递归调用
int score = miniMax(depth - 1, true, player, opponent, alpha, beta);
// 撤销移动
board[x][y] = 0;
// 更新最佳分数
bestScore = Math.min(bestScore, score);
beta = Math.min(beta, bestScore);
// Alpha-Beta剪枝
if (beta <= alpha) {
break;
}
}
return bestScore;
}
}
private java.util.List<int[]> generatePossibleMoves() {
java.util.List<int[]> moves = new java.util.ArrayList<>();
// 首先检查是否有紧急情况（立即获胜或阻止对手获胜）
int player = playerIsBlack ? 2 : 1;
int opponent = playerIsBlack ? 1 : 2;
// 1. 检查AI是否可以立即获胜
for (int i = 0; i < BOARD_SIZE; i++) {
for (int j = 0; j < BOARD_SIZE; j++) {
if (board[i][j] == 0) {
board[i][j] = player;
if (checkWin(i, j)) {
board[i][j] = 0;
moves.clear();
moves.add(new int[]{i, j});
return moves; // 直接返回获胜位置
}
board[i][j] = 0;
}
}
}
// 2. 检查是否需要阻止玩家获胜
for (int i = 0; i < BOARD_SIZE; i++) {
for (int j = 0; j < BOARD_SIZE; j++) {
if (board[i][j] == 0) {
board[i][j] = opponent;
if (checkWin(i, j)) {
board[i][j] = 0;
moves.clear();
moves.add(new int[]{i, j});
return moves; // 直接返回阻止位置
}
board[i][j] = 0;
}
}
}
// 3. 生成所有可能的移动，但优先考虑靠近已有棋子的位置
boolean[][] visited = new boolean[BOARD_SIZE][BOARD_SIZE];
for (int i = 0; i < BOARD_SIZE; i++) {
for (int j = 0; j < BOARD_SIZE; j++) {
if (board[i][j] != 0) {
// 检查周围的空位
for (int dx = -2; dx <= 2; dx++) {
for (int dy = -2; dy <= 2; dy++) {
int x = i + dx;
int y = j + dy;
if (x >= 0 && x < BOARD_SIZE && y >= 0 && y < BOARD_SIZE
&& board[x][y] == 0 && !visited[x][y]) {
moves.add(new int[]{x, y});
visited[x][y] = true;
}
}
}
}
}
}
// 如果没有找到附近的空位（游戏刚开始），返回中心区域的位置
if (moves.isEmpty()) {
int center = BOARD_SIZE / 2;
for (int i = center - 2; i <= center + 2; i++) {
for (int j = center - 2; j <= center + 2; j++) {
if (i >= 0 && i < BOARD_SIZE && j >= 0 && j < BOARD_SIZE
&& board[i][j] == 0) {
moves.add(new int[]{i, j});
}
}
}
}
return moves;
}
private int evaluateBoard(int player, int opponent) {
int score = 0;
// 评估所有可能的五元组
for (int i = 0; i < BOARD_SIZE; i++) {
for (int j = 0; j < BOARD_SIZE; j++) {
if (board[i][j] == player) {
score += evaluatePosition(i, j, player, opponent);
} else if (board[i][j] == opponent) {
score -= evaluatePosition(i, j, opponent, player);
}
}
}
return score;
}
private int evaluatePosition(int x, int y, int player, int opponent) {
int score = 0;
int[][] directions = {{1, 0}, {0, 1}, {1, 1}, {1, -1}};
for (int[] dir : directions) {
// 检查这个方向的棋型
int playerCount = 1; // 当前棋子
int openEnds = 0;
boolean blocked1 = false, blocked2 = false;
// 正向检查
for (int i = 1; i <= 4; i++) {
int nx = x + i * dir[0];
int ny = y + i * dir[1];
if (nx < 0 || nx >= BOARD_SIZE || ny < 0 || ny >= BOARD_SIZE) {
blocked1 = true;
break;
}
if (board[nx][ny] == player) {
playerCount++;
} else if (board[nx][ny] == opponent) {
blocked1 = true;
break;
} else {
openEnds++;
break;
}
}
// 反向检查
for (int i = 1; i <= 4; i++) {
int nx = x - i * dir[0];
int ny = y - i * dir[1];
if (nx < 0 || nx >= BOARD_SIZE || ny < 0 || ny >= BOARD_SIZE) {
blocked2 = true;
break;
}
if (board[nx][ny] == player) {
playerCount++;
} else if (board[nx][ny] == opponent) {
blocked2 = true;
break;
} else {
openEnds++;
break;
}
}
// 根据棋型评分
score += evaluatePattern(playerCount, openEnds);
}
return score;
}
private int evaluatePattern(int playerCount, int openEnds) {
if (playerCount >= 5) return WIN_SCORE; // 五连
if (openEnds == 0) return 0; // 被阻挡的两端
switch (playerCount) {
case 4:
return openEnds == 2 ? BLOCK_WIN_SCORE : 10000; // 活四或冲四
case 3:
return openEnds == 2 ? 5000 : 1000; // 活三或眠三
case 2:
return openEnds == 2 ? 200 : 50; // 活二或眠二
case 1:
return openEnds == 2 ? 10 : 1; // 活一或眠一
default:
return 0;
}
}
private boolean isGameOver() {
// 检查棋盘是否已满
boolean boardFull = true;
for (int i = 0; i < BOARD_SIZE; i++) {
for (int j = 0; j < BOARD_SIZE; j++) {
if (board[i][j] == 0) {
boardFull = false;
break;
}
}
if (!boardFull) break;
}
return boardFull;
}
private int[] findBestMove() {
int player = playerIsBlack ? 2 : 1; // AI的棋子颜色
// 1. 检查是否有可以立即获胜的位置
for (int i = 0; i < BOARD_SIZE; i++) {
for (int j = 0; j < BOARD_SIZE; j++) {
if (board[i][j] == 0) {
board[i][j] = player;
if (checkWin(i, j)) {
board[i][j] = 0;
return new int[]{i, j};
}
board[i][j] = 0;
}
}
}
// 2. 检查是否需要阻止玩家获胜
int opponent = playerIsBlack ? 1 : 2;
for (int i = 0; i < BOARD_SIZE; i++) {
for (int j = 0; j < BOARD_SIZE; j++) {
if (board[i][j] == 0) {
board[i][j] = opponent;
if (checkWin(i, j)) {
board[i][j] = 0;
return new int[]{i, j};
}
board[i][j] = 0;
}
}
}
// 3. 随机选择一个空位置
java.util.List<int[]> emptyCells = new java.util.ArrayList<>();
for (int i = 0; i < BOARD_SIZE; i++) {
for (int j = 0; j < BOARD_SIZE; j++) {
if (board[i][j] == 0) {
emptyCells.add(new int[]{i, j});
}
}
}
if (!emptyCells.isEmpty()) {
return emptyCells.get((int)(Math.random() * emptyCells.size()));
}
return null;
}
private boolean checkWin(int x, int y) {
int player = board[x][y];
int[][] directions = {{1, 0}, {0, 1}, {1, 1}, {1, -1}};
for (int[] dir : directions) {
int count = 1;
// 正向检查
for (int i = 1; i <= 4; i++) {
int nx = x + i * dir[0];
int ny = y + i * dir[1];
if (nx >= 0 && nx < BOARD_SIZE && ny >= 0 && ny < BOARD_SIZE && board[nx][ny] == player) {
count++;
} else {
break;
}
}
// 反向检查
for (int i = 1; i <= 4; i++) {
int nx = x - i * dir[0];
int ny = y - i * dir[1];
if (nx >= 0 && nx < BOARD_SIZE && ny >= 0 && ny < BOARD_SIZE && board[nx][ny] == player) {
count++;
} else {
break;
}
}
if (count >= 5) {
return true;
}
}
return false;
}
class GamePanel extends JPanel {
public GamePanel() {
setPreferredSize(new Dimension(
BOARD_SIZE * CELL_SIZE + 2 * MARGIN,
BOARD_SIZE * CELL_SIZE + 2 * MARGIN));
addMouseListener(new MouseAdapter() {
@Override
public void mouseClicked(MouseEvent e) {
if (gameOver) return;
if (aiMode && ((playerIsBlack && !blackTurn) || (!playerIsBlack && blackTurn))) {
return; // AI回合，忽略玩家点击
}
int x = (e.getX() - MARGIN + CELL_SIZE / 2) / CELL_SIZE;
int y = (e.getY() - MARGIN + CELL_SIZE / 2) / CELL_SIZE;
makeMove(x, y);
}
});
}
@Override
protected void paintComponent(Graphics g) {
super.paintComponent(g);
// 绘制棋盘背景
g.setColor(new Color(220, 179, 92));
g.fillRect(MARGIN, MARGIN, BOARD_SIZE * CELL_SIZE, BOARD_SIZE * CELL_SIZE);
// 绘制网格线
g.setColor(Color.BLACK);
for (int i = 0; i < BOARD_SIZE; i++) {
g.drawLine(MARGIN + i * CELL_SIZE, MARGIN,
MARGIN + i * CELL_SIZE, MARGIN + (BOARD_SIZE - 1) * CELL_SIZE);
g.drawLine(MARGIN, MARGIN + i * CELL_SIZE,
MARGIN + (BOARD_SIZE - 1) * CELL_SIZE, MARGIN + i * CELL_SIZE);
}
// 绘制棋子
for (int i = 0; i < BOARD_SIZE; i++) {
for (int j = 0; j < BOARD_SIZE; j++) {
if (board[i][j] == 1) {
g.setColor(Color.BLACK);
g.fillOval(MARGIN + i * CELL_SIZE - PIECE_SIZE / 2,
MARGIN + j * CELL_SIZE - PIECE_SIZE / 2,
PIECE_SIZE, PIECE_SIZE);
} else if (board[i][j] == 2) {
g.setColor(Color.WHITE);
g.fillOval(MARGIN + i * CELL_SIZE - PIECE_SIZE / 2,
MARGIN + j * CELL_SIZE - PIECE_SIZE / 2,
PIECE_SIZE, PIECE_SIZE);
}
}
}
// 显示当前回合和模式
g.setColor(Color.BLACK);
g.setFont(new Font("Arial", Font.BOLD, 16));
String modeText = aiMode ? (playerIsBlack ? "AI模式(玩家执黑)" : "AI模式(玩家执白)") : "双人对战模式";
g.drawString("模式: " + modeText, MARGIN, MARGIN + BOARD_SIZE * CELL_SIZE + 20);
g.drawString("当前回合: " + (blackTurn ? "黑方" : "白方"),
MARGIN, MARGIN + BOARD_SIZE * CELL_SIZE + 40);
}
}
// 用于游戏存档的序列化类
static class SaveData implements Serializable {
private static final long serialVersionUID = 1L;
private int[][] board;
private boolean blackTurn;
private boolean gameOver;
private boolean aiMode;
private boolean playerIsBlack;
public SaveData(int[][] board, boolean blackTurn, boolean gameOver, boolean aiMode, boolean playerIsBlack) {
this.board = new int[BOARD_SIZE][BOARD_SIZE];
for (int i = 0; i < BOARD_SIZE; i++) {
System.arraycopy(board[i], 0, this.board[i], 0, BOARD_SIZE);
}
this.blackTurn = blackTurn;
this.gameOver = gameOver;
this.aiMode = aiMode;
this.playerIsBlack = playerIsBlack;
}
public int[][] getBoard() {
return board;
}
public boolean isBlackTurn() {
return blackTurn;
}
public boolean isGameOver() {
return gameOver;
}
public boolean isAiMode() {
return aiMode;
}
public boolean isPlayerIsBlack() {
return playerIsBlack;
}
}
public static void main(String[] args) {
SwingUtilities.invokeLater(() -> new GomokuGame());
}
}
Write Preview
Loading…
Cancel
Save