本文目錄一覽：
求一個簡單又有趣的JAVA小遊戲代碼
具體如下：
連連看的小源碼
package Lianliankan;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
public class lianliankan implements ActionListener
{
JFrame mainFrame; //主面板
Container thisContainer;
JPanel centerPanel,southPanel,northPanel; //子面板
JButton diamondsButton[][] = new JButton[6][5];//遊戲按鈕數組
JButton exitButton,resetButton,newlyButton; //退出，重列，重新開始按鈕
JLabel fractionLable=new JLabel(“0”); //分數標籤
JButton firstButton,secondButton; //
分別記錄兩次62616964757a686964616fe59b9ee7ad9431333335326239被選中的按鈕
int grid[][] = new int[8][7];//儲存遊戲按鈕位置
static boolean pressInformation=false; //判斷是否有按鈕被選中
int x0=0,y0=0,x=0,y=0,fristMsg=0,secondMsg=0,validateLV; //遊戲按鈕的位置坐標
int i,j,k,n;//消除方法控制
代碼（code）是程序員用開發工具所支持的語言寫出來的源文件，是一組由字符、符號或信號碼元以離散形式表示信息的明確的規則體系。
對於字符和Unicode數據的位模式的定義，此模式代表特定字母、數字或符號（例如 0x20 代表一個空格，而 0x74 代表字符「t」）。一些數據類型每個字符使用一個位元組；每個位元組可以具有 256 個不同的位模式中的一個模式。
在計算機中，字符由不同的位模式（ON 或 OFF）表示。每個位元組有 8 位，這 8 位可以有 256 種不同的 ON 和 OFF 組合模式。對於使用 1 個位元組存儲每個字符的程序，通過給每個位模式指派字符可表示最多 256 個不同的字符。2 個位元組有 16 位，這 16 位可以有 65,536 種唯一的 ON 和 OFF 組合模式。使用 2 個位元組表示每個字符的程序可表示最多 65,536 個字符。
單位元組代碼頁是字符定義，這些字符映射到每個位元組可能有的 256 種位模式中的每一種。代碼頁定義大小寫字符、數字、符號以及 !、@、#、% 等特殊字符的位模式。每種歐洲語言（如德語和西班牙語）都有各自的單位元組代碼頁。
雖然用於表示 A 到 Z 拉丁字母表字符的位模式在所有的代碼頁中都相同，但用於表示重音字符（如”é”和”á”）的位模式在不同的代碼頁中卻不同。如果在運行不同代碼頁的計算機間交換數據，必須將所有字符數據由發送計算機的代碼頁轉換為接收計算機的代碼頁。如果源數據中的擴展字符在接收計算機的代碼頁中未定義，那麼數據將丟失。
如果某個數據庫為來自許多不同國家的客戶端提供服務，則很難為該數據庫選擇這樣一種代碼頁，使其包括所有客戶端計算機所需的全部擴展字符。而且，在代碼頁間不停地轉換需要花費大量的處理時間。
用java編寫一個猜拳遊戲
import java.util.Scanner;
public class Game {
private Scanner scan = new Scanner(System.in);
private String rule[] = {“”,”剪刀”,”石頭”,”布”};
private String role[] = {“”,”劉備”,”孫權”,”曹操”};
private Computer computer;
private User user;
private int roundCount;
private Game(){
roundCount = 0;
}
public static void main(String[] args) {
Game game = new Game();
game.start();
}
public void start(){
computer = new Computer();
System.out.println(“- – 歡迎進入遊戲世界 – -“);
System.out.println(“** ******************”);
System.out.println(“** 猜拳，開始 **”);
System.out.println(“** ******************”);
System.out.println();
System.out.println(“出拳規則：1.剪刀 2.石頭 3.布”);
System.out.print(“請選擇角色（1：劉備 2.孫權 3.曹操）”);
int userRole = scan.nextInt();
if(userRole =1 userRole =3){
user = new User(role[userRole]);
System.out.println();
System.out.print(“要開始嗎？（y/n） “);
String start = scan.next();
if(start.equals(“y”)){
round();
}
else if(start.equals(“n”)){
}
}
}
private void round(){
roundCount ++;
System.out.println();
System.out.print(“請出拳:1.剪刀 2.石頭 3.布 (輸入相應數字): “);
int userRule = user.round();
if(userRule = 1 userRule = 3){
int computerRule = computer.round();
judge(userRule,computerRule);
System.out.println();
System.out.print(“是否開始下一輪（y/n）: “);
String next = scan.next();
if(next.equals(“y”)){
round();
}
else if(next.equals(“n”)){
end();
}
}
}
private void judge(int ur,int cr){
System.out.println(“你出拳：”+ rule[ur]);
System.out.println(“電腦出拳：”+ rule[cr]);
if(ur == cr){
System.out.println(“結果：和局，真衰！嘿嘿，等着瞧吧！”);
}
else if((ur == 1 cr== 3)||
(ur == 2 cr == 1)||
(ur == 3 cr == 2)){
System.out.println(“結果：你贏了！”);
user.win();
}
else{
System.out.println(“結果：你輸了！”);
computer.win();
}
}
private void end(){
System.out.println(“- ————————————-“);
System.out.println(user.getName() + “VS” + computer.getName());
System.out.println(“對戰次數:” + roundCount);
if(computer.getWin() == user.getWin()){
System.out.println(“結果:打成平手,下次再和你一分高下！”);
}
else if(computer.getWin() user.getWin()){
System.out.println(“結果：你輸了！電腦贏了” + computer.getWin()+”次！”);
}
else{
System.out.println(“結果：你贏了！你贏了” + user.getWin()+”次！”);
}
System.out.println(“- ————————————-“);
}
class Computer{
private int win;
private String name;
public Computer(){
win = 0;
name = “匿名”;
}
public int round(){
return (int)(System.currentTimeMillis() % 3) + 1;//隨機返回1、2、3
}
public String getName(){
return name;
}
public void win(){
win ++;
}
public int getWin(){
return win;
}
}
class User{
private int win;
private String name = “”;
public User(String name){
this.name = name;
win = 0;
}
public int round(){
return scan.nextInt();
}
public String getName(){
return name;
}
public void win(){
win ++;
}
public int getWin(){
return win;
}
}
}
剛剛寫好的，應該滿足你的題目要求。贏了和輸了的提示信息題目里沒有是我自己隨便寫的。
求java小遊戲源代碼
表1. CheckerDrag.java
// CheckerDrag.javaimport java.awt.*;import java.awt.event.*;public class CheckerDrag extends java.applet.Applet{ // Dimension of checkerboard square. // 棋盤上每個小方格的尺寸 final static int SQUAREDIM = 40; // Dimension of checkerboard — includes black outline. // 棋盤的尺寸 – 包括黑色的輪廓線 final static int BOARDDIM = 8 * SQUAREDIM + 2; // Dimension of checker — 3/4 the dimension of a square. // 棋子的尺寸 – 方格尺寸的3/4 final static int CHECKERDIM = 3 * SQUAREDIM / 4; // Square colors are dark green or white. // 方格的顏色為深綠色或者白色 final static Color darkGreen = new Color (0, 128, 0); // Dragging flag — set to true when user presses mouse button over checker // and cleared to false when user releases mouse button. // 拖動標記 –當用戶在棋子上按下鼠標按鍵時設為true， // 釋放鼠標按鍵時設為false boolean inDrag = false; // Left coordinate of checkerboard’s upper-left corner. // 棋盤左上角的左方向坐標 int boardx; // Top coordinate of checkerboard’s upper-left corner. //棋盤左上角的上方向坐標 int boardy; // Left coordinate of checker rectangle origin (upper-left corner). // 棋子矩形原點(左上角)的左方向坐標 int ox; // Top coordinate of checker rectangle origin (upper-left corner). // 棋子矩形原點(左上角)的上方向坐標 int oy; // Left displacement between mouse coordinates at time of press and checker // rectangle origin. // 在按鍵時的鼠標坐標與棋子矩形原點之間的左方向位移 int relx; // Top displacement between mouse coordinates at time of press and checker // rectangle origin. // 在按鍵時的鼠標坐標與棋子矩形原點之間的上方向位移 int rely; // Width of applet drawing area. // applet繪圖區域的寬度 int width; // Height of applet drawing area. // applet繪圖區域的高度 int height; // Image buffer. // 圖像緩衝 Image imBuffer; // Graphics context associated with image buffer. // 圖像緩衝相關聯的圖形背景 Graphics imG; public void init () { // Obtain the size of the applet’s drawing area. // 獲取applet繪圖區域的尺寸 width = getSize ().width; height = getSize ().height; // Create image buffer. // 創建圖像緩衝 imBuffer = createImage (width, height); // Retrieve graphics context associated with image buffer. // 取出圖像緩衝相關聯的圖形背景 imG = imBuffer.getGraphics (); // Initialize checkerboard’s origin, so that board is centered. // 初始化棋盤的原點，使棋盤在屏幕上居中 boardx = (width – BOARDDIM) / 2 + 1; boardy = (height – BOARDDIM) / 2 + 1; // Initialize checker’s rectangle’s starting origin so that checker is // centered in the square located in the top row and second column from // the left. // 初始化棋子矩形的起始原點，使得棋子在第一行左數第二列的方格里居中 ox = boardx + SQUAREDIM + (SQUAREDIM – CHECKERDIM) / 2 + 1; oy = boardy + (SQUAREDIM – CHECKERDIM) / 2 + 1; // Attach a mouse listener to the applet. That listener listens for // mouse-button press and mouse-button release events. // 向applet添加一個用來監聽鼠標按鍵的按下和釋放事件的鼠標監聽器 addMouseListener (new MouseAdapter () { public void mousePressed (MouseEvent e) { // Obtain mouse coordinates at time of press. // 獲取按鍵時的鼠標坐標 int x = e.getX (); int y = e.getY (); // If mouse is over draggable checker at time // of press (i.e., contains (x, y) returns // true), save distance between current mouse // coordinates and draggable checker origin // (which will always be positive) and set drag // flag to true (to indicate drag in progress). // 在按鍵時如果鼠標位於可拖動的棋子上方 // （也就是contains (x, y)返回true），則保存當前 // 鼠標坐標與棋子的原點之間的距離（始終為正值）並且 // 將拖動標誌設為true（用來表明正處在拖動過程中） if (contains (x, y)) { relx = x – ox; rely = y – oy; inDrag = true; } } boolean contains (int x, int y) { // Calculate center of draggable checker. // 計算棋子的中心位置 int cox = ox + CHECKERDIM / 2; int coy = oy + CHECKERDIM / 2; // Return true if (x, y) locates with bounds // of draggable checker. CHECKERDIM / 2 is the // radius. // 如果(x, y)仍處於棋子範圍內則返回true // CHECKERDIM / 2為半徑 return (cox – x) * (cox – x) + (coy – y) * (coy – y) CHECKERDIM / 2 * CHECKERDIM / 2; } public void mouseReleased (MouseEvent e) { // When mouse is released, clear inDrag (to // indicate no drag in progress) if inDrag is // already set. // 當鼠標按鍵被釋放時，如果inDrag已經為true， // 則將其置為false（用來表明不在拖動過程中） if (inDrag) inDrag = false; } }); // Attach a mouse motion listener to the applet. That listener listens // for mouse drag events. //向applet添加一個用來監聽鼠標拖動事件的鼠標運動監聽器 addMouseMotionListener (new MouseMotionAdapter () { public void mouseDragged (MouseEvent e) { if (inDrag) { // Calculate draggable checker’s new // origin (the upper-left corner of // the checker rectangle). // 計算棋子新的原點（棋子矩形的左上角） int tmpox = e.getX () – relx; int tmpoy = e.getY () – rely; // If the checker is not being moved // (at least partly) off board, // assign the previously calculated // origin (tmpox, tmpoy) as the // permanent origin (ox, oy), and // redraw the display area (with the // draggable checker at the new // coordinates). // 如果棋子（至少是棋子的一部分）沒有被 // 移出棋盤，則將之前計算的原點 // (tmpox, tmpoy)賦值給永久性的原點(ox, oy)， // 並且刷新顯示區域（此時的棋子已經位於新坐標上） if (tmpox boardx tmpoy boardy tmpox + CHECKERDIM boardx + BOARDDIM tmpoy + CHECKERDIM boardy + BOARDDIM) { ox = tmpox; oy = tmpoy; repaint (); } } } }); } public void paint (Graphics g) { // Paint the checkerboard over which the checker will be dragged. // 在棋子將要被拖動的位置上繪製棋盤 paintCheckerBoard (imG, boardx, boardy); // Paint the checker that will be dragged. // 繪製即將被拖動的棋子 paintChecker (imG, ox, oy); // Draw contents of image buffer. // 繪製圖像緩衝的內容 g.drawImage (imBuffer, 0, 0, this); } void paintChecker (Graphics g, int x, int y) { // Set checker shadow color. // 設置棋子陰影的顏色 g.setColor (Color.black); // Paint checker shadow. // 繪製棋子的陰影 g.fillOval (x, y, CHECKERDIM, CHECKERDIM); // Set checker color. // 設置棋子顏色 g.setColor (Color.red); // Paint checker. // 繪製棋子 g.fillOval (x, y, CHECKERDIM – CHECKERDIM / 13, CHECKERDIM – CHECKERDIM / 13); } void paintCheckerBoard (Graphics g, int x, int y) { // Paint checkerboard outline. // 繪製棋盤輪廓線 g.setColor (Color.black); g.drawRect (x, y, 8 * SQUAREDIM + 1, 8 * SQUAREDIM + 1); // Paint checkerboard. // 繪製棋盤 for (int row = 0; row 8; row++) { g.setColor (((row 1) != 0) ? darkGreen : Color.white); for (int col = 0; col 8; col++) { g.fillRect (x + 1 + col * SQUAREDIM, y + 1 + row * SQUAREDIM, SQUAREDIM, SQUAREDIM); g.setColor ((g.getColor () == darkGreen) ? Color.white : darkGreen); } } } // The AWT invokes the update() method in response to the repaint() method // calls that are made as a checker is dragged. The default implementation // of this method, which is inherited from the Container class, clears the // applet’s drawing area to the background color prior to calling paint(). // This clearing followed by drawing causes flicker. CheckerDrag overrides // update() to prevent the background from being cleared, which eliminates // the flicker. // AWT調用了update()方法來響應拖動棋子時所調用的repaint()方法。該方法從 // Container類繼承的默認實現會在調用paint()之前，將applet的繪圖區域清除 // 為背景色，這種繪製之後的清除就導致了閃爍。CheckerDrag重寫了update()來 // 防止背景被清除，從而消除了閃爍。 public void update (Graphics g) { paint (g); }}
系統框圖如下 java實現五子棋程序 可以實現人人對戰 人機對戰 簡單功能 悔棋 認輸
一、實驗題目
五子棋遊戲。
二、問題分析
五子棋是雙人博弈棋類益智遊戲，由圍棋演變而來，屬純策略型。棋盤通常15*15，即15行，15列，共225個交叉點，即棋子落點；棋子由黑白兩色組成，黑棋123顆，白棋122顆。遊戲規則為黑先白後，誰先五子連成一條直線誰贏，其中直線可以是橫的、縱的、45度、135度。
本次Java編程我的目的是現實人機對戰，即遊戲者一方是人，另一方計算機。這就要求程序不僅要具備五子棋的基本界面，還要編程指導計算機與人進行對弈。為了使程序儘可能智能，我採用了貪心策略、傳統搜索算法、極大極小博弈樹算法，對應遊戲玩家的3個等級：簡單、中等、困難。
三、功能設計
我的程序基本功能是實現人機對弈五子棋。人和電腦交替下棋，誰先五子連成一條直線誰就贏。下面是我程序的功能模塊：
1.等級設置
核心功能是實現不同策略與算法的對比運用，純貪心策略實現簡單等級對手，直接搜索算法實現中等等級對手，極大極小博弈樹算法實現困難等級對手。對應程序中的3選1單選按鈕。
2.悔棋功能
模擬棧機制實現人悔棋，不限步長的悔棋。對應程序中的悔棋按鈕。
3.棋面繪製
根據不同機計算機的屏幕分辨率，繪製逼真的棋盤。
4.圖片引入
兩張古典的人物圖片，生動模擬對弈雙方。人物圖片旁的黑白棋缽圖片顯示黑白棋歸屬。
5.背景設置
支持用戶選擇背景，包括棋盤、棋盤邊框、窗口邊框，彰顯個性。
6.音樂播放
下棋時有棋子落地的聲音，一方勝利時有五子連成一片的聲音。同時在設置背景時相應的改變整個對弈過程中的背景音樂。
7.時間顯示
在棋盤正上方有一模擬文本框顯示當前棋局用時。
8.其他小功能
支持和棋、認輸、開啟新遊戲、退出遊戲等操作。
四、數據結構與算法設計
數據結構部分
1.當前棋局的存儲結構
我的五子棋程序選擇通常用到的15行*15列棋盤，可以開二維數組PositionFlag = new int[15][15]，PositionFlag[i][j]為0表示(i,j)點尚無棋，為1表示(i,j)點是人的棋子，為2表示(i,j)點是機器的棋子。之所以選擇二維數組，主要原因有兩點：
1.本程序需要頻繁隨機訪問15*15的交叉點，對應查詢該點狀態以及改變該點狀態，隨機訪問是數組的特點。
2.15*15=225開二維數組的內存需求相對現在內存為2G及以上的計算機完全可以接受，且數組實現簡單、操作方便。
基於以上兩點，儘管創建動態的順序表—鏈表可能可以節省少量內存（可以只存當前有棋的點，原數組對應位置為0的點可以不存），但選擇數組的優勢完全在上述兩點體現了出來。
2.實現悔棋操作的數據結構
由於每次悔棋只需回退當前幾步，後進先出原則，這正是棧這種典型數據結構的設計思想，於是我選擇棧。我自己先寫了用自定義數組模擬的棧，但由於是學Java語言且由於悔棋的存儲空間需要隨當前步數增大而增大（由於每局最多下225步，即最多要悔225步，所以自己開個225的數組完全可以避免存儲空間自增長的問題且內存完全可以接受，之所以不用自定義數組而用ArrayList類主要是為了嘗試Java中STL的用法），所有我最終改為用Java類庫中的ArrayList類。
確定用ArrayList類實現棧機制後就必須考慮每個ArrayList單元具體存儲什麼。剛開始我存儲的是當前的棋局，即整個局面，而每個局面對應一個二維數組，這樣是很佔用內存的。試想一下，在最壞情況下，225個ArrayList單元，每個單元存放一個15*15的二維數組，儘管225*15*15在Java的內存管理機制下不會爆棧，但也是極不划算的。之所以說不划算，是因為有更好的解決方案。由於每次悔棋只是在回退倒數一步，多步悔棋只需循環回退，所以可以只存儲當前棋局最後一步的下法，對應一個二維點，完全可以自定義一個二維坐標類chessOneStep。
算法設計部分
Java語言是面向對象的語言。我在進行五子棋遊戲編程是總共傳創建了11個自定義的類。在編寫程序的過程中，我有一個明顯的體驗就是面向對象編程就是一項有關對象設計和對象接口技術，很多關鍵的技術就是如何設計自定義的對象。
下面我先概括給出我的所有類的作用：
1.mainFrame類：主框架類，我應用程序的入口；
2.chessPositon類：主控類，這個類是我程序的核心類，負責控制雙方的下棋，以及調用其他的類完成當前棋局的顯示繪製；
3.chessPanel類：面板類，調用其他底層類完成當前棋局的顯示繪製；
4.chessBoard類：棋盤繪製類，負責棋盤的繪製；
5.chessImage類：文件類，包含各種資源（背景圖片、背景音樂）以及靜態全局變量（public static Type）；
6.chessButton類：組件類，定義各種組件，包括按鈕、單選按鈕、文本框等；
7.chessMusic類：音樂類，負責調用Java庫類完成背景音樂、下棋音樂、取勝音樂等的播放；
8.chessPiece類：棋局類，定義棋局二維數組數據結構並完成相關操作；
9.chessList類：棧類，完成悔棋等操作；
10. chessOneStep類：棋子類，定義每步坐標以及下在該處獲得的估價值；
11.myCompare類：排序類，完成chessOneStep類的自定義排序
詳細設計
1.mainFrame類
作為我的五子棋程序的主類，mainFrame類主要實例化相關的對象，如chessbutton,chessborad等，從而完成框架的創建。更重要的是實例化chessposition，這是本程序的核心類，控制遊戲雙方行棋過程完成人機互動下棋，然後將MyChessPosition與鼠標響應addMouseListener（）關聯起來。
2.chessMusic類
一個好的遊戲必須給人一種身臨其境的感覺，而聲音是營造這種氛圍的重要因素。參照網上各遊戲運行商的音樂配置，我選擇相關逼真的聲音。包括背景音樂、下棋棋子落到棋盤發出的聲音以及一方勝出的配樂。所有這些功能的實現，依賴於自定義的chessMusic類，採用AudioInputStream配合Clip的方式完成音樂播放的軟硬件工作，然後定義兩個接口chessmusic(String Name)和Stop(),前者完成播放功能，後者完成關閉當前音樂功能。因為音頻文件相對較大，而我的程序提供在不同背景樂之間切換的功能，所以在打開另一個音頻文件之前必須關閉前一個正在播放的音頻文件，防止出現溢出。
3.chessImage類
適當的動畫或圖片能給遊戲玩家帶來美的體驗。所以我的五子棋程序界面在不失和諧的前提下引入了儘可能多的圖片，包括對弈雙方、棋缽等。圖片引入的具體工作通過語句import javax.imageio.ImageIO完成。同時，由於圖片要在用到它的類中被訪問，為了避免頻繁調用函數，我直接將圖片相關聯的對象定義為public static，表明是公用的、靜態的。進一步引申開去，我將程序中用到的靜態全局變量都定義在chessImage類中。具體如下：
public static Date begin;//每局開始時間
public static Date cur;//每局結束時間
public static chessOneStep LineLeft;//結束端點1
public static chessOneStep LineRight;//結束端點2
public static boolean IsGameOver;//是否只有一方獲勝
public static int ColorOfBackGround[][]= {{255, 227, 132},{0,255,127},{218,165,32}};//背景顏色
public static int ColorOfWindows[][]= {{ 60,179,113},{245,245,245},{122,122,122}};//背景顏色
public static int WitchMatch;//背景搭配
public static String MusicOfBackGround;//背景音樂
public static int CurrentStep;//記錄當前步數
public static int Rank;//設置難度等級
public static boolean IsSurrender;//判斷是否認輸
public static boolean IsTie;//判斷是否認輸
public static String Message;//輸出提示信息
public static Image IconImage;// 圖標
public static Image blackBoard;//白棋盤
public static Image whiteBoard;//黑棋盤
public static Image blackChess;// 白棋棋子圖片
public static Image whiteChess;// 白棋棋子圖片
public static Image RightPlayer;//白棋棋罐圖片
public static Image LeftPlayer;//白棋玩家頭像圖片
public static String path = “src/”;// 圖片的保存路徑
4.chessButton類
這個是程序的組件類。定義了各種功能鍵，完善程序功能，營造逼真的人機對戰遊戲效果。分為3類：效果。。
(1)、按鈕組件
本程序有5個按鈕，支持和棋、認輸、新遊戲、退出、悔棋等。認輸和和棋按鈕終止當前的棋局，給出相應的提示信息；退出按鈕調用系統System.exit(0)的函數正常返回；悔棋按鈕調用後面要介紹的chessList類實現悔棋；新遊戲按鈕則刷新當前棋局準備下一輪，要將記錄當前棋局的二維數組全部置0，刷新當前棋局開始時間等。
(2)、單選按鈕組件
遊戲界面支持設置個性化界面，包括背景顏色與背景音樂，跟重要的一點是設置難度（簡單、中等、困難）。單選按鈕只能多選一。背景顏色主要是存儲相關顏色搭配方案的RGB顏色，開2維數組，即對應RGB3原色數組的一維數組，然後通過改變WitchMatch全局變量的值來有用戶自己選擇顏色搭配，不同的顏色搭配對應不同的背景音樂表達一致的主題。難度設置主要是改變計算機的下棋算法，不同難度通過Rank判斷進入不同的程序分支，實現不同智能等級的計算機下棋水平。
(3)、文本框
在不同的單選按鈕前添加相應的文本框，提示用戶可以實現的功能。同時我用顏色模擬出顯示當前棋局耗用時間的文本框。
不論按鈕還是單選按鈕都要關聯相應的消息，把相應功能的實現放在消息響應處理函數理。這些主要是實現Java庫提供的消息響應接口裡的方法。
5.chessPiece類
主要完成當前棋面的存儲，存儲棋面的數據結構為二維數組int[][] PositionFlag；然後定義獲取、設置某點以及整個棋面的狀態的方法。
(1)、SetPositionFlag(int x, int y, int flag)//設置（x,y）處的狀態為flag
(2)、GetPositionFlag(int x, int y)//獲取（x,y）處的狀態
(3)、SetAllFlag(int [][]NewFlag)//設置當前整個棋面的狀態為NewFlag
(4)、GetAllFlag()//獲取當前整個棋面的狀態
(5)、DrawChessPiece(Graphics g)//繪製當前局面的棋子
由於本類比較重要，所以附上了代碼，見源代碼1。
6.chessBoard類
功能為繪製棋盤線。由於圍棋的棋盤比較複雜，橫線、豎線較多，且為了使棋盤美觀，還要自定義窗口邊框、棋盤邊框、對弈雙方邊框等，對線寬、線型也有一定要求。有時要單像素線條，有時要多像素線條。對於多像素線條，我主要用了2種方法。
方法一：
在需要繪製多像素線條處首先繪製一條單像素線，然後根據線寬要求上下平移適當像素達到繪製多像素的目的。這樣的方法適合繪製水平線或豎直線，繪製其他斜率的線條容易造成走樣。在沒有想到比較好的反走樣編程思想後我選擇了調用Java庫中已經封裝好的函數。
方法二：
為了克服方法一繪製非水平或豎直線時造成的走樣，同時也為了更進一步學習Java語言，我猜想肯定會有類似OpenGL中設置線寬的畫刷，於是上網百度找到了相應的畫刷Stroke類。通過Java庫實現繪製不同線寬的直線，達到了反走樣效果。
7.chessOneStep類
這個類是為了配合chessList類實現悔棋以及在計算機下棋算法實現返回有效狀態點而設計的。主要數據成員為
private int x,y,weight；//其中x,y表示點坐標，weight表示將棋下到該點獲得的估價值。
主要方法如下：
(1)、GetX()//獲得當前對象的x坐標
(2)、GetY()//獲得當前對象的y坐標
(3)、GetWeight()//獲得當前對象的(x,y)處的估價值
8.chessList類
程序支持悔棋功能，為了實現悔棋，自定義了chessList類。這個類主要通過引入java.util.ArrayList和java.util.List實現集合的數據類型。然後自定義一些方法，如下：
（1）、AddStep(chessOneStep OneStep)//添加一步棋到List中
（2）、GetSize()//獲得當前List的大小
（3）、ClearList()//清空List
（4）、RemoveLast()//刪去List中的最後元素
由於每次刪除當前List中的最後一個元素，實現後進先出，所以可以模擬棧的功能實現悔棋。
9.myCompare類
由於在計算機下棋的極大極小博弈樹算法中需要對自定義對象chessOneStep按weight進行排序，所以引入了myCompare類，通過實現Comparator接口中的compare方法完成自定義對象排序。
10.chessPanel類
程序的自定義面板類，主要負責完成當前框架內容的顯示。這是一個重要的與框架和圖形顯示密切相關的類。主要數據成員為
private chessboard MyChessBoard;//當前顯示棋盤
private chesspiece MyChessPiece;//當前顯示整個棋面的狀態
主要方法如下：
（1）、chesspanel(chessboard MyChessBoard1, chesspiece MyChessPiece1)//構造函數，分別用MyChessBoard1和MyChessPiece1初始化MyChessBoard和MyChessPiece
（2）display(chessboard MyChessBoard1, chesspiece MyChessPiece1)//自定義顯示回調函數，調用repaint()完成重新繪製遊戲界面
（3）、paintComponent(Graphics g)//核心方法，調用各種函數完成具體的繪製工作
11.chessPositon類
程序算法核心類，總的功能是控制人和計算機輪流下棋，以及調用chessPanel類中的display(chessboard , chesspiece )方法完成界面的實時刷新。關於chessPositon類，我在此將重點介紹。chessPosition類的主要數據成員如下：
private static chessboard MyChessBoard;//當前顯示棋盤
public static chesspiece MyChessPiece;//當前顯示整個棋面的狀態
private static chesspanel Mychesspanel;////當前顯示面板
public static chesslist MyChessList=new chesslist();//當前下棋集合，用於悔棋
final private static int INF = (1 30); // 表示正無窮大的常量，用於極大極小博弈數搜索算法
public static boolean CanGo;//控制當前下棋一方
類的設計集中體現在成員方法的設計上。實現人機對戰，只有語言是遠遠不夠的，還要加入算法，用算法引導計算機下棋。下面介紹該類的方法成員：
（1）、chessposition(chesspanel , chessboard ,chesspiece ) //帶有參數的構造函數
（2）、chessposition()
不帶參數的構造函數
（3）、mouseClicked(MouseEvent event)
鼠標響應函數，負責人的下棋，根據鼠標點擊的位置轉換得到所在棋盤的相對位置。如果該位置不合法，即超出棋盤有效範圍，點擊無響應；如果該位置上已有棋，彈出消息框給出提示。這二者都要求重新給出下棋位置，即當前鼠標響應無效…直到點擊到棋盤有效區域。
（4）、IsOver(int[][] Array,int x,int y)
判斷當前int[][]Array對應的棋局是否結束，即一方五子連成一條直線。此處有兩種思路，一種對當前棋面上的所有棋子都進行一次判斷，具體為水平方向、豎直方向、與水平線成45度方向、與水平線成135度方向，只要有一個方向五子連成一條直線就說明有一方獲勝，遊戲結束；另一種思路為只在當前下棋的4個方向進行判斷，我的程序採用的是第二種，所以IsOver方法除了int[][]Array參數外，還有x,y參數，（x,y）表示當前下棋的坐標點。
（5）display()
通過調用自定義面板類的顯示回調函數用於重新顯示遊戲界面，達到每下一步棋及時更新遊戲界面的目的。
（6）、GetValue(int flag, int num)
估值函數，根據經驗把棋局分成只有1顆棋相連，2顆棋相連且兩端被封死，2顆棋相連且一端封死另一端活的，2顆棋相連且兩端都是活的，同理3顆棋、4顆棋也各自可分3種情況。不同的情況對應不同的估價值。估價值的設定是決定計算機一方是否智能的一個關鍵因素。
（7）、GetPredictValue(int flag, int num)
對未連成一片但通過再下一顆子就能連成一片的局面進行估值，這在雙方下棋的有限步驟內是能產生重要影響的。如果每局棋僅考慮當前一步，是不可取的。
（8）、Evaluate(int[][] Array, int x, int y)
根據棋面具體情況以及預先設定的估值函數，對某個點對應的局面進行評估。由於每次雙方只能下一顆棋，所以可以每次取當前局面的所有點中對應估值最大值點的估值作為整個局面的估值。
（9）、GetGreedNext()
計算機下棋方法1，對應難度等級為簡單，採用貪心思想。每次下棋前在求得最有利點下棋，而是否最有利只是通過一步評估。算法偽碼描述為：
Max取負無窮大
for(行i從0到15)
{
For(列j從0到15)
{
If((i，j)對應的位置無棋)
{
a.假設放上一顆由人控制的棋，求估價值；
b.假設放上一顆由計算機控制的棋，求估價值；
c.取二者中較大值作為(i,j）處的估價值tmp；
d.取tmp與Max較大值賦值給Max.
}
}
}
最終Max對應的點就是當前整個局面中最大的估值點。至於上述為什麼要考慮雙方都在該點下棋的情況呢？主要原因為下五子棋是個攻防兼備的過程，不僅要考慮自己對自己最有利，還要考慮對對手最不利，通俗來講就是在自己贏的時候不能讓對手先贏。
（10）、GetSearchNext(int LookLength)
derectSearch(int [][]Array,boolean who,int deepth)
計算機下棋方法2：直接搜索法,對應難度等級為中等。
每步棋最多有225個不同下法，若採用直接搜索法則對應的孩子節點有225個（在下棋過程中會逐漸減少），即每層有最多225個節點待擴展，這就決定了直接搜索進行不超過2次—主要原因有兩點：
a.採用深度優先搜索需要遞歸，遞歸中狀態過多可能會爆棧，我們知道遞歸是用棧機制來實現的；採用寬度優先搜索又需要存儲為擴展的節點，這對內存容量要求很高。
b.不管深搜還是廣搜，在時間複雜度為O(N^m)的情況下都是不能接受的。其中N為當前棋局的待擴展節點，最大225;m為搜索的深度。
綜上所述，在採用直接搜索法時搜索深度不能太深，嚴格來說是應該控制在2層以內，在計算機運算速度在10^7次每秒的情況下，理論和實驗都表明超過2層就會變得很慢且這種趨勢成指數級增長。
直接搜索算法偽代碼為
GetSearch(boolean flag，int deep)
{
如果deep等於0，返回當前棋局估值；
for(行i從0到15)
{
For(列j從0到15)
{
If((i，j)對應的位置無棋)
{
如果輪到計算機下棋，置標誌位為2
GetSearch(！flag，deep-1)；
如果輪到人下棋，置標誌位為1；
GetSearch(！flag，deep-1)；
}
}
}
}
（11）、GetMinMaxsearchNext(int LookLength)
MinMaxsearch(int [][]Array,boolean who, int deepth)
計算機下棋算法3：極大極小博弈樹法,對應難度等級為困難。五子棋是個博弈遊戲，當前在尋找對自己最有利的下棋點時要儘可能保證對對手最不利，這種思想可以用極大極小博弈樹
原創文章，作者：DN2XS，如若轉載，請註明出處：https://www.506064.com/zh-hk/n/129761.html
微信掃一掃 
支付寶掃一掃 