Java實(shí)現(xiàn)簡(jiǎn)單的五子棋游戲示例代碼
更新時(shí)間：2022年05月13日 10:44:59 作者：錯(cuò)過(guò)了時(shí)間
這篇文章主要為大家介紹了如何利用Java語(yǔ)言實(shí)現(xiàn)簡(jiǎn)單的五子棋游戲，文中的示例代碼講解詳細(xì)，對(duì)我們學(xué)習(xí)Java游戲開(kāi)發(fā)有一定幫助，需要的可以參考一下
項(xiàng)目結(jié)構(gòu)
這個(gè)是在網(wǎng)上找的資源，出處記不得了，記錄一下。程序的總體結(jié)構(gòu)，很簡(jiǎn)單的：
核心代碼
代碼如下：
ArrComparator.java類(lèi)
import java.util.Comparator;
/**
* 排序 Comparator
*/
class ArrComparator implements Comparator<Object> {
int column = 2;
int sortOrder = -1; // 遞減
public ArrComparator() {
}
public int compare(Object a, Object b) {
if (a instanceof int[]) {
return sortOrder * (((int[]) a)[column] - ((int[]) b)[column]);
}
throw new IllegalArgumentException("param a,b must int[].");
}
}
ChessMap.java類(lèi)
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.net.URL;
@SuppressWarnings("serial")
public class ChessMap extends JFrame {
private ImageIcon map; //棋盤(pán)背景位圖
private ImageIcon blackchess; //黑子位圖
private ImageIcon whitechess; //白子位圖
private ChessPanel cp; //棋盤(pán)
private JPanel east;
private JPanel west;
private static final int FINAL_WIDTH = 450;
private static final int FINAL_HEIGHT = 500;
//以下為下拉菜單
private JMenuBar menubar;
private JMenu[] menu={new JMenu("開(kāi)始"),new JMenu("設(shè)置"),new JMenu("幫助")};
private JMenuItem[] menuitem1={new JMenuItem("重新開(kāi)始"),new JMenuItem("悔棋"),new JMenuItem("退出")};
private JMenuItem[] menuitem2={new JMenuItem("禁手選擇"),new JMenuItem("人機(jī)博弈"),new JMenuItem("人人對(duì)弈")};
private JMenuItem[] menuitem3={new JMenuItem("規(guī)則"),new JMenuItem("關(guān)于")};
private boolean haveai=true; //人與人下還是人與電腦下，true與電腦下
Mouseclicked mouseclicked=new Mouseclicked();
MouseMoved mousemoved=new MouseMoved();
Menuitemclicked menuclicked=new Menuitemclicked();
//構(gòu)造函數(shù)
public ChessMap(){
//改變系統(tǒng)默認(rèn)字體
Font font = new Font("Dialog", Font.PLAIN, 12);
java.util.Enumeration keys = UIManager.getDefaults().keys();
while (keys.hasMoreElements()) {
Object key = keys.nextElement();
Object value = UIManager.get(key);
if (value instanceof javax.swing.plaf.FontUIResource) {
UIManager.put(key, font);
}
}
setTitle("五子棋 ");
setSize(FINAL_WIDTH,FINAL_HEIGHT);
setResizable(false);
init();
setLocation(Toolkit.getDefaultToolkit().getScreenSize().width / 2
- FINAL_WIDTH / 2, Toolkit.getDefaultToolkit()
.getScreenSize().height
/ 2 - FINAL_HEIGHT / 2);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
cp.reset();
setVisible(true);
}
//初始化與默認(rèn)值
public void init()
{
map=new ImageIcon(getClass().getResource("bg.jpg"));
blackchess=new ImageIcon(getClass().getResource("blackchess.gif"));
whitechess=new ImageIcon(getClass().getResource("whitechess.gif"));
cp=new ChessPanel(map,blackchess,whitechess);
menubar=new JMenuBar();
menuitem1[0].setActionCommand("Restart");
menuitem1[1].setActionCommand("Rollback");
menuitem1[2].setActionCommand("Exit");
menuitem2[0].setActionCommand("Forbid");
menuitem2[1].setActionCommand("Robot");
menuitem2[2].setActionCommand("Human");
menuitem3[0].setActionCommand("Rule");
menuitem3[1].setActionCommand("About");
for(int i=0;i<3;i++)
menu[0].add(menuitem1[i]);
for(int i=0;i<3;i++)
menu[1].add(menuitem2[i]);
for(int i=0;i<2;i++)
menu[2].add(menuitem3[i]);
for(int i=0;i<3;i++)
menubar.add(menu[i]);
Container p = getContentPane();
setJMenuBar(menubar);
east = new JPanel();
west = new JPanel();
p.add(east, "East");
p.add(west, "West");
p.add(cp, "Center");
cp.addMouseListener(mouseclicked);
cp.addMouseMotionListener(mousemoved);
menuitem1[0].addActionListener(menuclicked);
menuitem1[1].addActionListener(menuclicked);
menuitem1[2].addActionListener(menuclicked);
menuitem2[0].addActionListener(menuclicked);
menuitem2[1].addActionListener(menuclicked);
menuitem2[2].addActionListener(menuclicked);
menuitem3[0].addActionListener(menuclicked);
menuitem3[1].addActionListener(menuclicked);
}
class Mouseclicked extends MouseAdapter //判斷鼠標(biāo)左擊并通知棋盤(pán)和電腦
{
public void mouseClicked(MouseEvent e)
{
if(cp.win==false){
if(haveai){ //和電腦博弈
Point p1=new Point();
p1=cp.getPoint(e.getX(),e.getY());
int x=p1.x;
int y=p1.y;
// 如果該位置已經(jīng)放置棋子
System.out.println("x="+x+",y="+y);
if (cp.isChessOn[x][y] != 2)
return;
// 玩家為黑棋,考慮禁手
if( cp.able_flag && cp.bw == 0) {
int type = cp.getType(x,y,cp.bw);
String str = null;
switch(type){
case 20:
str = "黑長(zhǎng)連禁手!請(qǐng)選擇其它位置下棋!";
break;
case 21:
str = "黑四四禁手!請(qǐng)選擇其它位置下棋!";
break;
case 22:
str = "黑三三禁手!請(qǐng)選擇其它位置下棋!";
break;
default : break;
}
if(str != null) {
JOptionPane.showMessageDialog(null,str);
return;
}
}
boolean flag=cp.haveWin(x, y, cp.bw);
cp.update( x, y );
cp.putVoice(); //落子聲音
// 第一步棋,需初始化設(shè)置邊界值
if( cp.chess_num == 1){
if(x-1>=0)
cp.x_min = x-1;
if(x-1<=15)
cp.x_max = x+1;
if(y-1>=0)
cp.y_min = y-1;
if(y-1<=15)
cp.y_max = y+1;
}
else
cp.resetMaxMin(x,y);
if (flag) {
cp.wined(1 - cp.bw);
return;
}
cp.putOne(cp.bw);
}else{ //和人博弈
Point p1=new Point();
p1=cp.getPoint(e.getX(),e.getY());
int x=p1.x;
int y=p1.y;
// 如果該位置已經(jīng)放置棋子
System.out.println("x="+x+",y="+y);
if (cp.isChessOn[x][y] != 2)
return;
// 玩家為黑棋,考慮禁手
if( cp.able_flag && cp.bw == 0) {
int type = cp.getType(x,y,cp.bw);
String str = null;
switch(type){
case 20:
str = "黑長(zhǎng)連禁手!請(qǐng)選擇其它位置下棋!";
break;
case 21:
str = "黑四四禁手!請(qǐng)選擇其它位置下棋!";
break;
case 22:
str = "黑三三禁手!請(qǐng)選擇其它位置下棋!";
break;
default : break;
}
if(str != null) {
JOptionPane.showMessageDialog(null,str);
return;
}
}
boolean flag=cp.haveWin(x, y, cp.bw);
cp.update( x, y );
cp.putVoice(); //落子聲音
cp.repaint();
// 第一步棋,需初始化設(shè)置邊界值
if( cp.chess_num == 1){
if(x-1>=0)
cp.x_min = x-1;
if(x-1<=15)
cp.x_max = x+1;
if(y-1>=0)
cp.y_min = y-1;
if(y-1<=15)
cp.y_max = y+1;
}
else
cp.resetMaxMin(x,y);
if (flag) {
cp.wined(1 - cp.bw);
return;
}
}
}
}
}
class MouseMoved implements MouseMotionListener //調(diào)試用，獲得鼠標(biāo)位置
{
public void mouseMoved(MouseEvent e)
{
cp.showMousePos(e.getPoint());
}
public void mouseDragged(MouseEvent e)
{}
}
class Menuitemclicked implements ActionListener //菜單消息處理
{
public void actionPerformed(ActionEvent e)
{
JMenuItem target = (JMenuItem)e.getSource();
String actionCommand = target.getActionCommand();
if(actionCommand.equals("Restart")){ //重開(kāi)一局
cp.reset();
if(cp.sbw==cp.WHITE_ONE)
cp.update(7, 7);
//player=cp.BLACK_ONE;
}
if(actionCommand.equals("Rollback")){ //悔棋
if(cp.win) {
JOptionPane.showMessageDialog(null,"棋局已經(jīng)結(jié)束,不能悔棋!請(qǐng)重新開(kāi)始新的棋局!");
return;
}
// 當(dāng)前輪到玩家下棋,取消兩步 否則,取消一步
if(cp.chess_num >= 2 && cp.bw == cp.sbw){
cp.isChessOn[cp.pre[cp.chess_num-1][0]][cp.pre[cp.chess_num-1][1]] = 2;
cp.isChessOn[cp.pre[cp.chess_num-2][0]][cp.pre[cp.chess_num-2][1]] = 2;
cp.chess_num -= 2;
cp.repaint();
}
else if(cp.chess_num >= 1 && cp.bw == 1-cp.sbw){
cp.isChessOn[cp.pre[cp.chess_num-1][0]][cp.pre[cp.chess_num-1][1]] = 2;
cp.chess_num --;
cp.repaint();
}
}
else if(actionCommand.equals("Exit")){ //退出
System.exit(1);
}
else if(actionCommand.equals("Forbid")){ //禁手選擇
Object[] options = { "無(wú)禁手", "有禁手" };
int sel = JOptionPane.showOptionDialog(
null, "你的選擇：", "禁手選擇",
JOptionPane.DEFAULT_OPTION,
JOptionPane.QUESTION_MESSAGE, null,
options, options[0]);
if(sel==1){
cp.able_flag=true;
System.out.println("有禁手");
}else{
cp.able_flag=false;
System.out.println("無(wú)禁手");
}
}
else if(actionCommand.equals("Robot")){ //人機(jī)博弈
haveai=true;
Object[] options = { "人類(lèi)先手", "機(jī)器先手" };
int sel = JOptionPane.showOptionDialog(
null, "你的選擇：", "先手選擇",
JOptionPane.DEFAULT_OPTION,
JOptionPane.QUESTION_MESSAGE, null,
options, options[0]);
if(sel==1){ //機(jī)器先手
cp.sbw=cp.WHITE_ONE;
cp.update(7, 7);
System.out.println("機(jī)器先手");
}else{ //人先手
//player=cp.BLACK_ONE;
cp.sbw=cp.BLACK_ONE;
System.out.println("人先手");
}
}
else if(actionCommand.equals("Human")){ //人人博弈
haveai=false;
cp.setHumanhuman(true);
}else if(actionCommand.equals("Rule")){ //規(guī)則
JOptionPane.showConfirmDialog(null,
"1、無(wú)禁手：" +"\n"+
" 黑白雙方依次落子，任一方先在棋盤(pán)上形成連續(xù)的五個(gè)(含五個(gè)以上)棋子的一方為勝。" +"\n"+
"2、有禁手：（走禁手就輸，禁手不能落子）" +"\n"+
" 鑒于無(wú)禁手規(guī)則黑棋必勝，人們不斷采用一些方法限制黑棋先行的優(yōu)勢(shì)，以平衡黑白雙方的形式。" +"\n"+
" 于是針對(duì)黑棋的各種禁手逐漸形成。" +"\n"+
" 禁手主要分為以下幾類(lèi)：" +"\n"+
" (1)黑長(zhǎng)連禁手：連成六個(gè)以上連續(xù)相同的棋子。" +"\n"+
" (2)黑三三禁手：兩個(gè)以上的活三。" + "\n"+
" (3)黑四四禁手：兩個(gè)以上的四。" + "\n"+
" 禁手是針對(duì)黑棋而言的，白棋沒(méi)有任何禁手。" ,"規(guī)則",JOptionPane.CLOSED_OPTION,JOptionPane.INFORMATION_MESSAGE);
}
else if(actionCommand.equals("About")){ //版權(quán)與幫助
JOptionPane.showConfirmDialog(null,"團(tuán)隊(duì)成員：\n" +"自行添加","關(guān)于",JOptionPane.CLOSED_OPTION,JOptionPane.INFORMATION_MESSAGE);
}
}
}
public static void main(String[] args) {
new ChessMap();
}
} ChessPanel.java類(lèi)
import javax.sound.sampled.AudioInputStream;
import javax.swing.*;
import java.applet.AudioClip;
import java.awt.*;
import java.net.URL;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.Random;
@SuppressWarnings("serial")
public class ChessPanel extends JPanel{
private ImageIcon map; //棋盤(pán)背景位圖
private ImageIcon blackchess; //黑子位圖
private ImageIcon whitechess; //白子位圖
public int isChessOn [][]; //棋局
protected boolean win = false; // 是否已經(jīng)分出勝負(fù)
protected int win_bw; // 勝利棋色
protected int deep = 3, weight = 7; // 搜索的深度以及廣度
public int drawn_num = 110; // 和棋步數(shù)
int chess_num = 0; // 總落子數(shù)目
public int[][] pre = new int[drawn_num + 1][2]; // 記錄下棋點(diǎn)的x,y坐標(biāo) 最多 (drawn_num + 1) 個(gè)
public int sbw = 0; //玩家棋色黑色0，白色1
public int bw = 0; // 當(dāng)前應(yīng)該下的棋色 0：黑色(默認(rèn))， 1：白色
// 邊界值,用于速度優(yōu)化
protected int x_max = 15, x_min = 0;
protected int y_max = 15, y_min = 0;
protected boolean able_flag = true; // 是否選擇禁手標(biāo)志 0:無(wú)禁手 1:有禁手(默認(rèn)
private int h; //棋子長(zhǎng)
private int w; //棋子寬
private int insx; //插入棋子的位置
private int insy;
private Point mousePoint; //鼠標(biāo)當(dāng)前位置
private int winer; //獲勝方
private boolean humanhuman=false; //是否是人人對(duì)弈
private int plast=0; //走了幾步了，
public int BLACK_ONE; //0表黑子
public int WHITE_ONE; //1表白子
public int NONE_ONE; //2表無(wú)子
public int N; //棋盤(pán)邊長(zhǎng)
//-------聲音
String[] choics = { "put.wav", "win.wav","lost.wav" }; //聲音文件名數(shù)組
URL file1 = getClass().getResource(choics[0]); //落子聲音文件
URL file2 = getClass().getResource(choics[1]); //獲勝聲音文件
URL file3 = getClass().getResource(choics[2]); //失敗聲音文件
AudioClip soundPut = java.applet.Applet.newAudioClip(file1); //落子聲音剪輯對(duì)象
AudioClip soundWin = java.applet.Applet.newAudioClip(file2); //獲勝聲音剪輯對(duì)象
AudioClip soundLost = java.applet.Applet.newAudioClip(file3); //失敗聲音剪輯對(duì)象
public ChessPanel(){}
public ChessPanel(ImageIcon r_map,ImageIcon r_blackchess,ImageIcon r_whitechess) {
N=15;
map=new ImageIcon();
blackchess=new ImageIcon();
whitechess=new ImageIcon();
map=r_map;
blackchess=r_blackchess;
whitechess=r_whitechess;
NONE_ONE=2;
BLACK_ONE=0;
WHITE_ONE=1;
winer=NONE_ONE;
isChessOn=new int[N][N];
h=blackchess.getIconHeight()*(N-1);
w=blackchess.getIconWidth()*(N-1);
insx=0;
insy=0;
mousePoint=new Point();
}
public void reset(){ //重開(kāi)一局
winer=NONE_ONE;
for(int i=0;i<N;i++)
for(int j=0;j<N;j++){
isChessOn[i][j]=NONE_ONE;
}
chess_num = 0;
win = false;
win_bw=2;
bw = 0;
x_max = 15; x_min = 0;
y_max = 15;y_min = 0;
repaint();
}
public void showMousePos(Point p){ //調(diào)試用，顯示鼠標(biāo)位置
int cw;
cw=h/N;
mousePoint.x=p.x/cw;
mousePoint.y=p.y/cw;
repaint();
}
public Point getPoint(int x,int y){
int cw;
insx=x;
insy=y;
cw=h/N;
Point r=new Point(x/cw,y/cw);
return r;
}
public void gameOver(int r_winer){ //游戲勝負(fù)已分
winer=r_winer;
}
public void paint(Graphics g){ //整體布局
super.paint(g);
paintChessMap(g);
paintChess(g);
if(winer==BLACK_ONE){
g.drawString(new String("游戲結(jié)束！黑棋獲勝！"),500,200);
}
else if(winer==WHITE_ONE){
g.drawString(new String("游戲結(jié)束！白棋獲勝！"),500,200);
}
}
private void paintChessMap(Graphics g){ //畫(huà)棋盤(pán)
map.paintIcon(this,g,10,10);
int j;
g.setColor(Color.BLACK);
for(j=0;j<N;j++){ //畫(huà)線(xiàn)
g.drawLine(h/N/2,h/N*j+h/N/2,w-w/N+(N%2)*(h/N/2),h/N*j+h/N/2);
g.drawLine(w/N*j+h/N/2,h/N/2,w/N*j+h/N/2,h-h/N+(N%2)*(h/N/2));
}
g.fillRect(w/N*7+h/N/2-3,h/N*7+h/N/2-3,6,6);//畫(huà)5個(gè)黑方塊
g.fillRect(w/N*3+h/N/2-3,h/N*3+h/N/2-3,6,6);
g.fillRect(w/N*11+h/N/2-3,h/N*3+h/N/2-3,6,6);
g.fillRect(w/N*3+h/N/2-3,h/N*11+h/N/2-3,6,6);
g.fillRect(w/N*11+h/N/2-3,h/N*11+h/N/2-3,6,6);
}
private void paintChess(Graphics g){ //畫(huà)棋子
int i,j;
for(i=0;i<N;i++)
for(j=0;j<N;j++){
if(isChessOn[i][j]==BLACK_ONE){
blackchess.paintIcon(this,g,w/N*i,h/N*j);
}
else if(isChessOn[i][j]==WHITE_ONE){
whitechess.paintIcon(this,g,w/N*i,h/N*j);
}
}
}
//-------------------------------下棋聲音設(shè)置-------------------------------------------------
//落子聲音
public void putVoice(){
soundPut.play();
}
//獲勝聲音
public void winVoice(){
soundWin.play();
}
//失敗聲音
public void lostVoice(){
soundLost.play();
}
//----------------------電腦下棋-------------------------------//
public void putOne(int bwf ) { //bwf 棋色 0:黑色 1：白色
int x, y, mx = -100000000;
x = y = -1;
// 搜索最優(yōu)下棋點(diǎn)
int[][] bests = getBests( bwf );
for (int k = 0; k < bests.length; k++) {
int i = bests[k][0];
int j = bests[k][1];
// 有成5,則直接下子,并退出循環(huán)..沒(méi)有,則思考對(duì)方情況
if (getType(i, j, bwf) == 1) {
x = i;
y = j;
break;
}
if (getType(i, j,1 - bwf) == 1) {
x = i;
y = j;
break;
}
// 預(yù)存當(dāng)前邊界值
int temp1=x_min,temp2=x_max,temp3=y_min,temp4=y_max;
// 預(yù)設(shè)己方下棋,并更新邊界值
isChessOn[i][j] = bwf;
resetMaxMin(i,j);
// 預(yù)測(cè)未來(lái)
int t = findMin(-100000000, 100000000, deep);
// 還原預(yù)設(shè)下棋位置以及邊界值
isChessOn[i][j] = 2;
x_min=temp1;
x_max=temp2;
y_min=temp3;
y_max=temp4;
// 差距小于1000，50%概率隨機(jī)選取
//System.out.println("外 :" + i + "," + j + " mx:" + mx + " t:" + t);
if (t - mx > 1000 || Math.abs(t - mx)<1000 && randomTest(3)) {
x = i;
y = j;
mx = t;
//System.out.println(i + "," + j + " mx:" + mx + " t:" + t);
}
}
System.out.println("x="+x+",y="+y);
// addChess(x,y,(bwf+1)%2,true);
// repaint();
int step=0;
step++;
System.out.println("step "+step+":-----------------------------------------------");
for(int i=0;i<15;i++,System.out.print("\n"))
for(int j=0;j<15;j++)
{
if(isChessOn[j][i]!=2)System.out.print(isChessOn[j][i]);
else System.out.print(isChessOn[j][i]);
}
// 判斷是否已分勝負(fù)
boolean flag = haveWin(x, y, bwf);
//記錄
update( x, y );
repaint();
// 重設(shè)邊界值
resetMaxMin(x,y);
// 勝負(fù)已分
if (flag)
wined(bwf);
if (!flag && chess_num >= drawn_num) {
win = true;
String str = drawn_num + "步?jīng)]分勝負(fù),判和棋!";
JOptionPane.showMessageDialog(null,str);
return;
}
}
//---------搜索當(dāng)前搜索狀態(tài)極大值--------------------------------//
//alpha 祖先節(jié)點(diǎn)得到的當(dāng)前最小最大值，用于alpha 剪枝
//beta 祖先節(jié)點(diǎn)得到的當(dāng)前最大最小值，用于beta 剪枝。
//step 還要搜索的步數(shù)
//return 當(dāng)前搜索子樹(shù)極大值
protected int findMax(int alpha, int beta, int step) {
int max = alpha;
if (step == 0) {
return evaluate();
}
int[][] rt = getBests(1 - sbw);
for (int i = 0; i < rt.length; i++) {
int x = rt[i][0];
int y = rt[i][1];
if (getType(x, y, 1 - sbw) == 1) //電腦可取勝
return 100 * ( getMark(1) + step*1000 );
isChessOn[x][y] = 1 - sbw;
// 預(yù)存當(dāng)前邊界值
int temp1=x_min,temp2=x_max,temp3=y_min,temp4=y_max;
resetMaxMin(x,y);
int t = findMin(max, beta, step - 1);
isChessOn[x][y] = 2;
// 還原預(yù)設(shè)邊界值
x_min=temp1;
x_max=temp2;
y_min=temp3;
y_max=temp4;
if (t > max)
max = t;
//beta 剪枝
if (max >= beta)
return max;
}
return max;
}
//-----------------------搜索當(dāng)前搜索狀態(tài)極小值---------------------------------//
//alpha 祖先節(jié)點(diǎn)得到的當(dāng)前最小最大值，用于alpha 剪枝
//beta 祖先節(jié)點(diǎn)得到的當(dāng)前最大最小值，用于beta 剪枝
//step 還要搜索的步數(shù)
//return 當(dāng)前搜索子樹(shù)極小值。
protected int findMin(int alpha, int beta, int step) {
int min = beta;
if (step == 0) {
return evaluate();
}
int[][] rt = getBests(sbw);
for (int i = 0; i < rt.length; i++) {
int x = rt[i][0];
int y = rt[i][1];
int type = getType(x, y, sbw);
if (type == 1) //玩家成5
return -100 * ( getMark(1) + step*1000 );
// 預(yù)存當(dāng)前邊界值
int temp1=x_min,temp2=x_max,temp3=y_min,temp4=y_max;
isChessOn[x][y] = sbw;
resetMaxMin(x,y);
int t = findMax( alpha, min, step - 1 );
isChessOn[x][y] = 2;
// 還原預(yù)設(shè)邊界值
x_min=temp1;
x_max=temp2;
y_min=temp3;
y_max=temp4;
if (t < min)
min = t;
//alpha 剪枝
if (min <= alpha) {
return min;
}
}
return min;
}
//-----------------選取局部最優(yōu)的幾個(gè)落子點(diǎn)作為下一次擴(kuò)展的節(jié)點(diǎn)---------//
//bwf 棋色 0：黑棋 1：白棋
//return 選出來(lái)的節(jié)點(diǎn)坐標(biāo)
private int[][] getBests(int bwf) {
int i_min=(x_min==0 ? x_min:x_min-1);
int j_min=(y_min==0 ? y_min:y_min-1);
int i_max=(x_max==15 ? x_max:x_max+1);
int j_max=(y_max==15 ? y_max:y_max+1);
int n = 0;
int type_1,type_2;
int[][] rt = new int[(i_max-i_min) * (j_max-j_min)][3];
for ( int i = i_min; i < i_max; i++)
for (int j = j_min; j < j_max; j++)
if (isChessOn[i][j] == 2) {
type_1 = getType(i, j, bwf);
type_2 = getType(i, j, 1 - bwf);
if(able_flag && bwf==0 && (type_1 == 20 || type_1 == 21 || type_1 == 22)) // 禁手棋位置,不記錄
continue;
rt[n][0] = i;
rt[n][1] = j;
rt[n][2] = getMark(type_1) + getMark(type_2);
n++;
}
// 對(duì)二維數(shù)組排序
Arrays.sort(rt, new ArrComparator());
int size = weight > n? n:weight;
int[][] bests = new int[size][3];
System.arraycopy(rt, 0, bests, 0, size);
return bests;
}
//----------------------------計(jì)算指定方位上的棋型-------------------//
// x,y 方向線(xiàn)基準(zhǔn)一點(diǎn)。
//ex,ey 指定方向步進(jìn)向量。
// k 棋子顏色，0：黑色，1：白色
// 該方向上的棋子數(shù)目 以及 活度
private int[] count(int x, int y, int ex, int ey, int bwf) {
// 該方向沒(méi)意義,返回0
if( !makesense(x, y, ex, ey, bwf))
return new int[] {0, 1};
// 正方向 以及 反方向棋子個(gè)數(shù)
int rt_1 = 1,rt_2 = 1;
// 總棋子個(gè)數(shù)
int rt = 1;
// 正方向 以及 反方向連子的活度
int ok_1 = 0,ok_2 =0;
// 總活度
int ok = 0;
// 連子中間有無(wú)空格
boolean flag_mid1 =false,flag_mid2 = false;
// 連子中間空格的位置
int flag_i1 = 1,flag_i2 = 1;
if (isChessOn[x][y] != 2) {
throw new IllegalArgumentException("position x,y must be empty!..");
}
int i;
// 往正方向搜索
for (i = 1; x + i * ex < 15 && x + i * ex >= 0 && y + i * ey < 15 && y + i * ey >= 0; i++) {
if (isChessOn[x + i * ex][y + i * ey] == bwf)
rt_1++;
// 位置為空,若中空標(biāo)志為false,則記為中空并繼續(xù)搜索 否則,break
else if(isChessOn[x + i * ex][y + i * ey] == 2) {
if(!flag_mid1) {
flag_mid1 = true;
flag_i1 = i;
}
else
break;
}
// 位置為對(duì)方棋子
else
break;
}
// 計(jì)算正方向活度,,
// 最后一個(gè)位置不超過(guò)邊界
if (x + i * ex < 15 && x + i * ex >= 0 && y + i * ey < 15 && y + i * ey >= 0) {
// 最后一個(gè)位置為空位 +1活
if( isChessOn[x + i * ex][y + i * ey] == 2) {
ok_1++;
// 若是在尾部檢測(cè)到連續(xù)的空格而退出搜索,則不算有中空
if(rt_1 == flag_i1)
flag_mid1 = false;
// 若中空的位置在4以下 且 棋子數(shù)>=4,則這一邊的4非活
if(flag_mid1 && rt_1 > 3 && flag_i1 < 4) {
ok_1--;
}
}
// 最后一個(gè)位置不是空格,且搜索了2步以上,若前一個(gè)是空格, 則不算中空,且為活的邊
else if( isChessOn[x + i * ex][y + i * ey] != bwf && i >= 2)
if(isChessOn[x + (i-1) * ex][y + (i-1) * ey] == 2) {
ok_1++;
flag_mid1 = false;
}
}
// 最后一個(gè)位置是邊界 搜索了2步以上,且前一個(gè)是空格, 則不算中空,且為活的邊
else if(i >= 2 && isChessOn[x + (i-1) * ex][y + (i-1) * ey] == 2) {
ok_1++;
flag_mid1 = false;
}
// 往反方向搜索
for (i = 1; x - i * ex >= 0 && x - i * ex < 15 && y - i * ey >= 0 && y - i * ey < 15; i++) {
if (isChessOn[x - i * ex][y - i * ey] == bwf)
rt_2++;
else if(isChessOn[x - i * ex][y - i * ey] == 2) {
if(!flag_mid2) {
flag_mid2 = true;
flag_i2 = i;
}
else
break;
}
else
break;
}
// 計(jì)算反方向活度
if (x - i * ex < 15 && x - i * ex >= 0 && y - i * ey < 15 && y - i * ey >= 0) {
if( isChessOn[x - i * ex][y - i * ey] == 2) {
ok_2++;
if(rt_2 == flag_i2)
flag_mid2 = false;
if(flag_mid2 && rt_2 > 3 && flag_i2 < 4) {
ok_2--;
}
}
else if( isChessOn[x - i * ex][y - i * ey] != bwf && i >= 2 )
if(isChessOn[x - (i-1) * ex][y - (i-1) * ey] == 2) {
ok_2++;
flag_mid2 = false;
}
}
else if(i >= 2 && isChessOn[x - (i-1) * ex][y - (i-1) * ey] == 2) {
ok_2++;
flag_mid2 = false;
}
//------------------分析棋子類(lèi)型
// 兩邊都沒(méi)中空,直接合成
if( !flag_mid1 && !flag_mid2 ) {
rt = rt_1 + rt_2 - 1;
ok = ok_1 + ok_2;
return new int[] {rt, ok};
}
// 兩邊都有中空
else if( flag_mid1 && flag_mid2 ){
int temp = flag_i1 + flag_i2 - 1;
// 判斷中間的純連子數(shù),在5以上,直接返回; 為4,返回活4;
if(temp >= 5)
return new int[] {temp, 2};
if(temp == 4)
return new int[] {temp, 2};
// 先看有沒(méi)死4,再看有沒(méi)活3,剩下只能是死3
if(rt_1 + flag_i2 - 1 >= 4 || rt_2 + flag_i1 - 1 >= 4)
return new int[] {4, 1};
if(rt_1+flag_i2-1 == 3 && ok_1 > 0 || rt_2+flag_i1-1 == 3 && ok_2 > 0)
return new int[] {3, 2};
return new int[] {3, 1};
}
// 有一邊有中空
else {
// 總棋子數(shù)少于5,直接合成
if( rt_1 + rt_2 - 1 < 5 )
return new int[] {rt_1 + rt_2 - 1, ok_1 + ok_2};
// 多于5,先找成5,再找活4,剩下的只能是死4
else {
if(flag_mid1 && rt_2 + flag_i1 - 1 >= 5)
return new int[] {rt_2 + flag_i1 - 1, ok_2 + 1};
if(flag_mid2 && rt_1 + flag_i2 - 1 >= 5)
return new int[] {rt_1 + flag_i2 - 1, ok_1 + 1};
if(flag_mid1 && (rt_2 + flag_i1 - 1 == 4 && ok_2 == 1 || flag_i1 == 4) )
return new int[] {4, 2};
if(flag_mid2 && (rt_1 + flag_i2 - 1 == 4 && ok_1 == 1 || flag_i2 == 4) )
return new int[] {4, 2};
return new int[] {4, 1};
}
}
}
//----------------------------判斷指定方向下棋是否有意義,即最大可能的棋子數(shù)是否 >=5-------------------------------//
// x,y 評(píng)估的基準(zhǔn)點(diǎn)
// ex,ey 方向向量
// k 棋色
// true:有意義 false:沒(méi)意義
private Boolean makesense(int x, int y, int ex, int ey, int bwf) {
int rt = 1;
for (int i = 1; x + i * ex < 15 && x + i * ex >= 0 && y + i * ey < 15 && y + i * ey >= 0 && rt < 5; i++)
if (isChessOn[x + i * ex][y + i * ey] != 1 - bwf)
rt++;
else
break;
for (int i = 1; x - i * ex >= 0 && x - i * ex < 15 && y - i * ey >= 0 && y - i * ey < 15 && rt < 5; i++)
if (isChessOn[x - i * ex][y - i * ey] != 1 - bwf)
rt++;
else
break;
return (rt >= 5);
}
//------------------------------------ 棋型判別-------------------------------------//
// x,y 落子位置
// bwf 棋色 0：黑子，1：白子
// 對(duì)應(yīng)的棋型： 棋型代碼對(duì)應(yīng)如下：
// 1：成5
// 2：成活4或者是雙死4或者是死4活3
// 3：成雙活3
// 4：成死3活3
// 5：成死4
// 6：?jiǎn)位?
// 7：成雙活2
// 8：成死3
// 9：成死2活2
// 10：成活2
// 11：成死2
// 12: 其他
// 20: 長(zhǎng)連禁手
// 21: 雙四禁手
// 22: 雙活三禁手
protected int getType(int x, int y, int bwf) {
if (isChessOn[x][y] != 2)
return -1;
int[][] types = new int[4][2];
types[0] = count(x, y, 0, 1, bwf); // 豎直
types[1] = count(x, y, 1, 0, bwf); // 橫向
types[2] = count(x, y, -1, 1, bwf); // 斜上
types[3] = count(x, y, 1, 1, bwf); // 斜下
// 各種棋型的方向的數(shù)目
int longfive = 0;
int five_OR_more = 0;
int four_died = 0, four_live = 0;
int three_died = 0, three_live = 0;
int two_died = 0, two_live = 0;
// 各方向上棋型的判別
for (int k = 0; k < 4; k++) {
if (types[k][0] > 5) {
longfive++; // 長(zhǎng)連
five_OR_more++;
}
else if (types[k][0] == 5)
five_OR_more++; // 成5
else if (types[k][0] == 4 && types[k][1] == 2)
four_live++; // 活4
else if (types[k][0] == 4 && types[k][1] != 2)
four_died++; // 死4
else if (types[k][0] == 3 && types[k][1] == 2)
three_live ++; // 活3
else if (types[k][0] == 3 && types[k][1] != 2)
three_died++; // 死3
else if (types[k][0] == 2 && types[k][1] == 2)
two_live++; // 活2
else if (types[k][0] == 2 && types[k][1] != 2)
two_died++; // 死2
else
;
}
// 總棋型的判別
if(bwf == 0 && able_flag) { // 黑棋且選擇有禁手
if (longfive != 0) // 長(zhǎng)連禁手
return 20;
if (four_live + four_died >=2) // 雙4禁手
return 21;
if (three_live >=2) // 雙活三禁手
return 22;
}
if (five_OR_more != 0)
return 1; // 成5
if (four_live != 0 || four_died >= 2 || four_died != 0 && three_live != 0)
return 2; // 成活4或者是雙死4或者是死4活3
if (three_live >= 2)
return 3; // 成雙活3
if (three_died != 0 && three_live != 0)
return 4; // 成死3活3
if (four_died != 0)
return 5; // 成死4
if (three_live != 0)
return 6; // 單活3
if (two_live >= 2)
return 7; // 成雙活2
if (three_died != 0)
return 8; // 成死3
if (two_live != 0 && two_died != 0)
return 9; // 成死2活2
if (two_live != 0)
return 10; // 成活2
if (two_died != 0)
return 11; // 成死2
return 12;
}
//--------------------------對(duì)當(dāng)前棋面進(jìn)行打分------------------------------------------------------------//
protected int evaluate() {
int rt = 0, mt_c = 1, mt_m = 1;
if(bw == sbw)
mt_m = 2;
else
mt_c = 2;
int i_min=(x_min==0 ? x_min:x_min-1);
int j_min=(y_min==0 ? y_min:y_min-1);
int i_max=(x_max==15 ? x_max:x_max+1);
int j_max=(y_max==15 ? y_max:y_max+1);
for (int i = i_min; i < i_max; i++)
for (int j = j_min; j < j_max; j++)
if (isChessOn[i][j] == 2) {
// 電腦棋面分?jǐn)?shù)
int type = getType(i, j, 1 - sbw );
if(type == 1) // 棋型1,棋型2以及棋型3,加權(quán). 防止"4個(gè)雙活3"的局分大于"1個(gè)雙四"之類(lèi)的錯(cuò)誤出現(xiàn)
rt += 30 * mt_c * getMark(type);
else if(type == 2)
rt += 10 * mt_c * getMark(type);
else if(type == 3)
rt += 3 * mt_c * getMark(type);
else
rt += mt_c * getMark(type);
// 玩家棋面分?jǐn)?shù)
type = getType(i, j, sbw );
if(type == 1)
rt -= 30 * mt_m * getMark(type);
else if(type == 2)
rt -= 10 * mt_m * getMark(type);
else if(type == 3)
rt -= 3 * mt_m * getMark(type);
else
rt -= mt_m * getMark(type);
}
return rt;
}
//--------------------------------下棋后,更新信息-----------------------------//
void update(int x,int y) {
isChessOn[x][y] = bw;
bw = 1 - bw;
pre[chess_num][0] = x;
pre[chess_num][1] = y;
chess_num++;
}
//-------------------------------------- 下棋后,重設(shè)邊界值------------------------------//
// x 當(dāng)前下棋位置的x坐標(biāo)
// y 當(dāng)前下棋位置的y坐標(biāo)
public void resetMaxMin(int x,int y){
if(x-1>=0)
x_min = (x_min<x-1 ? x_min:x-1);
if(x+1<=15)
x_max = (x_max>x+1 ? x_max:x+1);
if(y-1>=0)
y_min = (y_min<y-1 ? y_min:y-1);
if(y+1<=15)
y_max = (y_max>y+1 ? y_max:y+1);
}
//------------------------------------------對(duì)分?jǐn)?shù)相同的落子點(diǎn)，隨機(jī)選取-------------------//
// kt 隨機(jī)因子 值越小，被選取的概率越大
// return 是否選擇該位置
private boolean randomTest(int kt) {
Random rm = new Random();
return rm.nextInt() % kt == 0;
}
//------------------------------------- 不同棋型對(duì)應(yīng)分?jǐn)?shù)---------------------------------
// k 棋型代號(hào)
//return 對(duì)應(yīng)分?jǐn)?shù)
private int getMark(int k) {
switch (k) {
case 1:
return 100000;
case 2:
return 30000;
case 3:
return 5000;
case 4:
return 1000;
case 5:
return 500;
case 6:
return 200;
case 7:
return 100;
case 8:
return 50;
case 9:
return 10;
case 10:
return 5;
case 11:
return 3;
case 12:
return 2;
default: //禁手棋型
return 0;
}
}
//--------------------------------------- 判斷是否已分出勝負(fù)---------------------------------------------
// x 落子點(diǎn)x坐標(biāo) y 落子點(diǎn)y坐標(biāo)
// bwf 棋色 0:黑色 1：白色
// return true:分出勝負(fù) false:未分出勝負(fù)
public boolean haveWin(int x, int y, int bwf) {
boolean flag = false;
if (count(x, y, 1, 0, bwf)[0] >= 5)
flag = true;
if (!flag && count(x, y, 0, 1, bwf)[0] >= 5)
flag = true;
if (!flag && count(x, y, 1, 0, bwf)[0] >= 5)
flag = true;
if (!flag && count(x, y, 1, -1, bwf)[0] >= 5)
flag = true;
if (!flag && count(x, y, 1, 1, bwf)[0] >= 5)
flag = true;
// 測(cè)試用,激活此行代碼,不會(huì)有輸贏(yíng).. flag = false;
return flag;
}
public void wined(int bw) {
boolean hh=getHumanhuman();
if(!hh){ //不是人人對(duì)弈
win = true;
win_bw = bw;
String str = (bw == sbw ? "恭喜！你贏(yíng)了！" : "電腦贏(yíng)了,你還要繼續(xù)努力啊！");
if(bw==sbw)
winVoice();
else
lostVoice();
JOptionPane.showMessageDialog(null,str);
}
else{ //人人對(duì)弈
win = true;
win_bw = bw;
String str = (bw == BLACK_ONE ? "恭喜！黑棋獲勝！" : "恭喜！白棋獲勝！");
winVoice();
JOptionPane.showMessageDialog(null,str);
}
}
public void setHumanhuman(boolean humanhuman) {
this.humanhuman = humanhuman;
}
public boolean getHumanhuman() {
return humanhuman;
}
}效果圖展示
運(yùn)行截圖：
看了這么多，是不是沒(méi)看懂，這里給出鏈接，剩下的就靠大家努力啦！
以上就是Java實(shí)現(xiàn)簡(jiǎn)單的五子棋游戲示例代碼的詳細(xì)內(nèi)容，更多關(guān)于Java五子棋的資料請(qǐng)關(guān)注腳本之家其它相關(guān)文章！
相關(guān)文章
SpringMVC加載控制與Postmand的使用和Rest風(fēng)格的引入及RestFul開(kāi)發(fā)全面詳解
SpringMVC是一種基于Java，實(shí)現(xiàn)了Web MVC設(shè)計(jì)模式，請(qǐng)求驅(qū)動(dòng)類(lèi)型的輕量級(jí)Web框架，即使用了MVC架構(gòu)模式的思想，將Web層進(jìn)行職責(zé)解耦。基于請(qǐng)求驅(qū)動(dòng)指的就是使用請(qǐng)求-響應(yīng)模型，框架的目的就是幫助我們簡(jiǎn)化開(kāi)發(fā)，SpringMVC也是要簡(jiǎn)化我們?nèi)粘eb開(kāi)發(fā)2022-10-10
這篇文章主要為大家詳細(xì)介紹了Java實(shí)現(xiàn)走迷宮回溯算法，文中示例代碼介紹的非常詳細(xì)，具有一定的參考價(jià)值，感興趣的小伙伴們可以參考一下2018-01-01
Stream流是數(shù)據(jù)渠道，用于操作數(shù)據(jù)源（集合、數(shù)組等）所生成的元素序列。這篇文章主要介紹了Java8新特性Stream流的相關(guān)資料，需要的朋友參考下吧2021-08-08
java如何實(shí)現(xiàn)post請(qǐng)求webservice服務(wù)端
這篇文章主要介紹了java如何實(shí)現(xiàn)post請(qǐng)求webservice服務(wù)端，具有很好的參考價(jià)值，希望對(duì)大家有所幫助。如有錯(cuò)誤或未考慮完全的地方，望不吝賜教2022-03-03
Java網(wǎng)絡(luò)編程實(shí)例——簡(jiǎn)單模擬在線(xiàn)聊天
學(xué)了java網(wǎng)絡(luò)，也是該做個(gè)小案例來(lái)鞏固一下了。本次案例將使用UDP和多線(xiàn)程模擬即時(shí)聊天，簡(jiǎn)單練練手。2021-05-05
SpringBoot使用Sa-Token實(shí)現(xiàn)權(quán)限認(rèn)證
本文主要介紹了SpringBoot使用Sa-Token實(shí)現(xiàn)權(quán)限認(rèn)證，文中通過(guò)示例代碼介紹的非常詳細(xì)，對(duì)大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價(jià)值，需要的朋友們下面隨著小編來(lái)一起學(xué)習(xí)學(xué)習(xí)吧2023-04-04
Java自定義數(shù)組列表的實(shí)現(xiàn)操作
這篇文章主要介紹了Java自定義數(shù)組列表的實(shí)現(xiàn)操作，具有很好的參考價(jià)值，希望對(duì)大家有所幫助。一起跟隨小編過(guò)來(lái)看看吧2020-09-09
這篇文章主要介紹了Spring IOC 容器啟動(dòng)流程分析,本文給大家介紹的非常詳細(xì)，具有一定的參考借鑒價(jià)值，需要的朋友可以參考下2019-08-08
Spring?注入靜態(tài)對(duì)象使用三種方式示例
這篇文章主要為大家介紹了Spring注入靜態(tài)對(duì)象使用的三種方式示例詳解，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進(jìn)步，早日升職加薪2023-07-07
這篇文章主要介紹了Maven deploy配置方法詳解，文中通過(guò)示例代碼介紹的非常詳細(xì)，對(duì)大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價(jià)值，需要的朋友們下面隨著小編來(lái)一起學(xué)習(xí)學(xué)習(xí)吧2020-07-07