這一篇我們將解決人機對戰的問題。解決方案是“權值法”。
我的代碼裏默認的是人先下，也可以加個條件更換次序。其實所謂的AI的下棋不是真的自己在思考，而是從人所下的位置算出周圍8個頂點的權值，挑出最大的位置來下棋。
所以顯然，我們需要做的就是1.爲不同的情況定義權值，2.計算權值，3.挑出最大權值，4.AI下棋 。OK，讓我們開始吧
一、 考慮棋子相連的情況和對應的權值
活連 眠連 （至於什麼叫活連，眠連自行百度吧）
1連 40 1連20
2連 400 2連 200
3連 3000 3連 500
4連 10000 4連 3000
關於權值的設置可以自己在合理的範圍內設置，所謂合理就是：不能讓AI已經到達四連或者的情況下還去堵人的二連甚至一連。
活連 眠連 （至於什麼叫活連，眠連自行百度吧）
1連 40 1連20
2連 400 2連 200
3連 3000 3連 500
4連 10000 4連 3000
關於權值的設置可以自己在合理的範圍內設置，所謂合理就是：不能讓AI已經到達四連或者的情況下還去堵人的二連甚至一連。
AI棋子的權值偏高，人棋子的權值偏低。AI偏攻擊型
人棋子的權值偏高，AI棋子的權值偏低。AI偏防禦型
人棋子的權值偏高，AI棋子的權值偏低。AI偏防禦型
因爲希望能夠從連的情況得到其權值，恰好符合哈希表的特點，所以我們採用哈希表HashMap來儲存各種情況的權值。設置爲static，讓其能方便被ChessAI類調用。此代碼和ChessAI類的其他數據成員代碼如下：
package GoBang;
import java.awt.Color;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.util.ArrayList;
import java.util.HashMap;
import javax.swing.JComboBox;
import javax.swing.JOptionPane;
public class ChessAI extends MouseAdapter implements GoBangconfig {
public GoBang gb;
int maxrc[] = new int[2]; //定義數組儲存最大權值的行和列，具體見三
public ChessAI(GoBang gb) {
this.gb = gb;
}
static HashMap<String, Integer> map = new HashMap<String, Integer>();
static {
// 活連
map.put("010", 40); //黑棋爲1
map.put("0110", 400);
map.put("01110", 3000);
map.put("011110", 10000);
map.put("020", 20); //白棋爲2
map.put("0220", 200);
map.put("02220", 500);
map.put("022220", 3000);
// 眠連
map.put("012", 40);
map.put("0112", 400);
map.put("01112", 3000);
map.put("011112", 10000);
map.put("021", 40);
map.put("0221", 400);
map.put("02221", 3000);
map.put("022221", 10000);
}
private int[][] weightArray = new int[row][column]; //權值數組
二、weightcount（）
然後接下來我們定義一個權值數組用來儲存8個位置的權值。某個棋子對應的權值等於把上下左右，左上，右上，左下，右下八個方向的權值全部算出來後求和。
不過先別急着計算權值，因爲可能人下一步棋就已經贏了。所以應當先判斷輸贏，如果人還沒贏，就再算權值。AI算法要做的事情就是統計存儲棋子的數組，根據棋子數組中棋子相連的情況來計算權值存入到數組中。
以水平向左的情況爲例子：
// 根據棋子數組中棋子相連的情況來計算權值存入到數組中
public void WeightCount() {
//System.out.println("sssssssssss" + gb.isArrive.length);
for (int r = 0; r < gb.isArrive.length; r++) {
for (int c = 0; c < gb.isArrive[r].length; c++) {
// 判斷此位置有無棋子，如果已經有棋子了就沒必要下了
if (gb.isArrive[r][c] == 0) {
// 水平方向
String code = "0";// 用來記錄棋子相連情況
int chess = 0;// 記錄第一次出現的棋子
int number = 0;// 記錄空位出現的次數
// 水平方向
// 水平向左
for (int c1 = c - 1; c1 >= 0; c1--) {
if (gb.isArrive[r][c1] == 0) {
if (c == c1 + 1) { // 在c1+1處就空了，說明是連續兩個空位，就不用再討論啦
break;
}
// 不是連續兩個空位的情況
else if (number == 0) {// 表示第一次出現空位
code = code + gb.isArrive[r][c1];// 記錄棋子相連的情況
number++;// 空位的次數加1
} else if (number == 1) {// 表示第二次出現空位
if (gb.isArrive[r][c1] == gb.isArrive[r][c1 + 1]) {
break; // 檢測是否連續兩個位置是否都爲空位
}
code = code + gb.isArrive[r][c1];// 記錄棋子相連的情況
number++;
} else if (number == 2) {// 表示第三次出現空位
if (gb.isArrive[r][c1] == gb.isArrive[r][c]) // 檢測兩個位置是否都爲空位
break;
}
} else {
if (chess == 0) { // 表示第一次出現棋子
chess = gb.isArrive[r][c1];// 存儲第一次出現棋子
code = code + gb.isArrive[r][c1]; // 記錄棋子的相連情況
} else if (chess == gb.isArrive[r][c1]) {// 判斷是否和第一次出現的棋子同色
code = code + gb.isArrive[r][c1]; // 記錄棋子的相連情況
} else {// 表示此位置的棋子的顏色與第一次出現的顏色不同，所以記錄
code = code + gb.isArrive[r][c1]; // 記錄棋子的相連情況
break;
}
}
}
Integer value = map.get(code);
if (value != null)// 判斷value是否不爲null
weightArray[r][c] += value;// 在對應空位累加權值 } 爲了清晰一點，其他方向的代碼將放在文末，思路都是差不多的。
想提醒的是：1.之所以判斷是否是連續空位，是因爲如果空位有連續地兩個，那麼可以當做沒連的情況了，所以break遍歷的循環；
2.用Integer而不用int是因爲下面的if條件用到了null，Java裏int不能和null直接比較，而Integer恰好可以兼容
三、findmax（）
現在我們得到了想要的權值數組，接下來就從中取到權值最大的數據的行和列，再將這個行和列傳給監聽器，就能在該位置讓AI下棋了
![]()
public int[] findmax() { // 得到最大權值的行列，用數組來儲存
int max = 0, i = 0, j = 0;
for (i = 0; i < weightArray.length; i++) {
for (j = 0; j < weightArray[i].length; j++) {
//System.out.print(weightArray[i][j] + "\t");
if (weightArray[i][j] > max) {
max = weightArray[i][j];
maxrc[0] = i;
maxrc[1] = j;
}
}
//System.out.println();
}
//System.out.println(maxrc[0] + "<>" + maxrc[1]);
return maxrc; //因爲不能同時返回兩個值，所以用數組來存儲後返回數組即可
} 我們把AI的算法封裝爲AIPLAY，到時候直接調用就行。代碼：
public void AIPLAY(int x, int y) {
// 一開始人下
// 計算棋子要落的交叉點
int countx = (y - 20 + size / 2) / size;
int county = (x - 20 + size / 2) / size;
g = (Graphics2D) gf.getGraphics();
g.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
RenderingHints.VALUE_ANTIALIAS_ON); // 抗鋸齒
int arrivex, arrivey;
// 棋盤上的具體位置
arrivex = 20 + county * size;
arrivey = 20 + countx * size;
if (countx >= 0 && countx <= 15 && county >= 0 && county <= 15
&& gf.isArrive[countx][county] != 0) // 有棋子
{
JOptionPane.showMessageDialog(gf, "此處已有棋子，請換一個地方");
} else {
// 人下了黑棋
g.setColor(Color.black);
g.fillOval(arrivex - size / 2, arrivey - size / 2, size, size);
gf.isArrive[countx][county] = 1;
list.add(new chess(countx, county)); // 有序地存儲每個棋子的行列，爲悔棋做準備
// 判斷輸贏
if (Gobangwin.judge(gf.isArrive, countx, county)) {
JOptionPane.showMessageDialog(gf, "黑棋勝利");
gf.removeMouseListener(this); box.setEnabled(true); //解封box
return;
}
ChessAI c = new ChessAI(gf);
// System.out.println(">>>"+gf.isArrive[0].length+"<<<");
// 輪到AI下
c.WeightCount();
int maxrc[] = c.findmax();
arrivex = 20 + maxrc[1] * size;
arrivey = 20 + maxrc[0] * size;
g.setColor(Color.white);
g.fillOval(arrivex - size / 2, arrivey - size / 2, size, size);
gf.isArrive[maxrc[0]][maxrc[1]] = 2;
list.add(new chess(maxrc[0], maxrc[1]));// 有序地存儲每個棋子的行列，原因同上
// 判斷輸贏
if (Gobangwin.judge(gf.isArrive, maxrc[0], maxrc[1])) {
JOptionPane.showMessageDialog(gf, "白棋勝利");
gf.removeMouseListener(this); box.setEnabled(true); //解封box
}
}
} 同樣的，我們也可以把人下棋的方法封裝起來，便於調用。代碼如下：（註釋與AI相似，不再重複）
public void PERSONPLAY(int x, int y) {
// 人下的方法
// 計算棋子要落的交叉點
int countx = (y - 20 + size / 2) / size;
int county = (x - 20 + size / 2) / size;
g = (Graphics2D) gf.getGraphics();
g.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
RenderingHints.VALUE_ANTIALIAS_ON); // 抗鋸齒
int arrivex, arrivey; // 棋盤上
arrivex = 20 + county * size;
arrivey = 20 + countx * size;
if (gf.isArrive[countx][county] != 0) // 有棋子
{
JOptionPane.showMessageDialog(gf, "此處已有棋子，請換一個地方");
} else {// 當前位置可以下棋
if (turn == 1) {
// 設置顏色
g.setColor(Color.black);
// 下棋
g.fillOval(arrivex - size / 2, arrivey - size / 2, size, size);
gf.isArrive[countx][county] = 1;
turn++;
} else {
// 設置顏色
g.setColor(Color.white);
// 下棋
g.fillOval(arrivex - size / 2, arrivey - size / 2, size, size);
gf.isArrive[countx][county] = 2;
turn--;
}
//
list.add(new chess(countx, county));// 有序地存儲每個棋子的行列
// 判斷輸贏
if (Gobangwin.judge(gf.isArrive, countx, county)) {
if (turn == 2)
JOptionPane.showMessageDialog(gf, "黑棋勝利");
else
JOptionPane.showMessageDialog(gf, "白棋勝利");
gf.removeMouseListener(this); box.setEnabled(true); //解封box
}
}
} 好的，到此爲止呢整個五子棋程序就結束了。運行後的界面如圖：
PS：代碼中有很多被註釋掉的輸出語句。因爲代碼比較長，我們不知道是在哪裏出現了bug，所以在關鍵節點加上輸出語句能更有效的排查掉錯誤。這也是程序員的必備技能之一（血與淚的教訓++）
THE END
附：計算其他方向的代碼
public void WeightCount() {
//System.out.println("sssssssssss" + gb.isArrive.length);
for (int r = 0; r < gb.isArrive.length; r++) {
for (int c = 0; c < gb.isArrive[r].length; c++) {
// 判斷此位置有無棋子
if (gb.isArrive[r][c] == 0) {
// 水平方向
String code = "0";// 用來記錄棋子相連情況
int chess = 0;// 記錄第一次出現的棋子
int number = 0;// 記錄空位出現的次數
// 水平方向
// 水平向左
for (int c1 = c - 1; c1 >= 0; c1--) {
if (gb.isArrive[r][c1] == 0) {
if (c == c1 + 1) {// 在c1+1處就空了，說明是連續兩個空位，就不用再討論啦
break;
}
// 不是連續兩個空位的情況
else if (number == 0) {// 表示第一次出現空位
code = code + gb.isArrive[r][c1];// 記錄棋子相連的情況
number++;// 空位的次數加1
} else if (number == 1) {// 表示第二次出現空位
if (gb.isArrive[r][c1] == gb.isArrive[r][c1 + 1]) {
break; // 檢測兩個位置是否都爲空位
}
code = code + gb.isArrive[r][c1];// 記錄棋子相連的情況
number++;
} else if (number == 2) {// 表示第三次出現空位
if (gb.isArrive[r][c1] == gb.isArrive[r][c]) // 檢測兩個位置是否都爲空位
break;
}
} else {
if (chess == 0) {// 表示第一次出現棋子
chess = gb.isArrive[r][c1];// 存儲第一次出現棋子
code = code + gb.isArrive[r][c1]; // 記錄棋子的相連情況
} else if (chess == gb.isArrive[r][c1]) {// 判斷是否和第一次出現的棋子同色
code = code + gb.isArrive[r][c1]; // 記錄棋子的相連情況
} else {// 表示此位置的棋子的顏色與第一次出現的顏色不同，所以記錄
code = code + gb.isArrive[r][c1]; // 記錄棋子的相連情況
break;
}
}
}
Integer value = map.get(code);
if (value != null)// 判斷value是否不爲null
weightArray[r][c] += value;// 在對應空位累加權值
// 水平向右
for (int c1 = c + 1; c1 < gb.isArrive[r].length; c1++) {
if (gb.isArrive[r][c1] == 0) {
if (c == c1 - 1) {// 在c1+1處就空了，說明是連續兩個空位，就不用再討論啦
break;
}
// 不是連續兩個空位的情況
else if (number == 0) {// 表示第一次出現空位
code = code + gb.isArrive[r][c1];// 記錄棋子相連的情況
number++;// 空位的次數加1
} else if (number == 1) {// 表示第二次出現空位
if (c1 + 1 < gb.isArrive[r].length
&& gb.isArrive[r][c1] == gb.isArrive[r][c1 + 1]) {
break; // 檢測兩個位置是否都爲空位
}
code = code + gb.isArrive[r][c1];// 記錄棋子相連的情況
number++;
} else if (number == 2) {// 表示第三次出現空位
if (gb.isArrive[r][c1] == gb.isArrive[r][c]) // 檢測兩個位置是否都爲空位
break;
}
} else {
if (chess == 0) {// 表示第一次出現棋子
chess = gb.isArrive[r][c1];// 存儲第一次出現棋子
code = code + gb.isArrive[r][c1]; // 記錄棋子的相連情況
} else if (chess == gb.isArrive[r][c1]) {// 判斷是否和第一次出現的棋子同色
code = code + gb.isArrive[r][c1]; // 記錄棋子的相連情況
} else {// 表示此位置的棋子的顏色與第一次出現的顏色不同，所以記錄
code = code + gb.isArrive[r][c1]; // 記錄棋子的相連情況
break;
}
}
}
value = map.get(code);
if (value != null)// 判斷value是否不爲null
weightArray[r][c] += value;// 在對應空位累加權值
// 豎直方向
// 豎直向上檢查
for (int r1 = r - 1; r1 >= 0; r1--) {
if (gb.isArrive[r1][c] == 0) {
if (r == r1 + 1) {// 在c1+1處就空了，說明是連續兩個空位，就不用再討論啦
break;
}
// 不是連續兩個空位的情況
else if (number == 0) {// 表示第一次出現空位
code = code + gb.isArrive[r1][c];// 記錄棋子相連的情況
number++;// 空位的次數加1
} else if (number == 1) {// 表示第二次出現空位
if (gb.isArrive[r1][c] == gb.isArrive[r1 + 1][c]) {
break; // 檢測兩個位置是否都爲空位
}
code = code + gb.isArrive[r1][c];// 記錄棋子相連的情況
number++;
} else if (number == 2) {// 表示第三次出現空位
if (gb.isArrive[r1][c] == gb.isArrive[r][c]) // 檢測兩個位置是否都爲空位
break;
}
} else {
if (chess == 0) {// 表示第一次出現棋子
chess = gb.isArrive[r1][c];// 存儲第一次出現棋子
code = code + gb.isArrive[r1][c]; // 記錄棋子的相連情況
} else if (chess == gb.isArrive[r1][c]) {// 判斷是否和第一次出現的棋子同色
code = code + gb.isArrive[r1][c]; // 記錄棋子的相連情況
} else {// 表示此位置的棋子的顏色與第一次出現的顏色不同，所以記錄
code = code + gb.isArrive[r1][c]; // 記錄棋子的相連情況
break;
}
}
}
value = map.get(code);
if (value != null)// 判斷value是否不爲null
weightArray[r][c] += value;// 在對應空位累加權值
// 豎直向下檢查
for (int r1 = r + 1; r1 < gb.isArrive.length; r1++) {
if (gb.isArrive[r1][c] == 0) {
if (r == r1 - 1) {// 在c1+1處就空了，說明是連續兩個空位，就不用再討論啦
break;
}
// 不是連續兩個空位的情況
else if (number == 0) {// 表示第一次出現空位
code = code + gb.isArrive[r1][c];// 記錄棋子相連的情況
number++;// 空位的次數加1
} else if (number == 1) {// 表示第二次出現空位
if (r1 + 1 < gb.isArrive.length
&& gb.isArrive[r1][c] == gb.isArrive[r1 + 1][c]) {
break; // 檢測兩個位置是否都爲空位
}
code = code + gb.isArrive[r1][c];// 記錄棋子相連的情況
number++;
} else if (number == 2) {// 表示第三次出現空位
if (gb.isArrive[r1][c] == gb.isArrive[r][c]) // 檢測兩個位置是否都爲空位
break;
}
} else {
if (chess == 0) {// 表示第一次出現棋子
chess = gb.isArrive[r1][c];// 存儲第一次出現棋子
code = code + gb.isArrive[r1][c]; // 記錄棋子的相連情況
} else if (chess == gb.isArrive[r1][c]) {// 判斷是否和第一次出現的棋子同色
code = code + gb.isArrive[r1][c]; // 記錄棋子的相連情況
} else {// 表示此位置的棋子的顏色與第一次出現的顏色不同，所以記錄
code = code + gb.isArrive[r1][c]; // 記錄棋子的相連情況
break;
}
}
}
value = map.get(code);
if (value != null)// 判斷value是否不爲null
weightArray[r][c] += value;// 在對應空位累加權值
// 右斜方向
// 向左上
for (int r1 = r - 1, c1 = c - 1; r1 > 0 && c1 > 0; r1--, c1--) {
if (gb.isArrive[r1][c] == 0) {
if (r == r1 + 1 && c == c1 + 1) {// 在c1+1處就空了，說明是連續兩個空位，就不用再討論啦
break;
}
// 不是連續兩個空位的情況
else if (number == 0) {// 表示第一次出現空位
code = code + gb.isArrive[r1][c1];// 記錄棋子相連的情況
number++;// 空位的次數加1
} else if (number == 1) {// 表示第二次出現空位
if (r1 + 1 < gb.isArrive.length
&& c1 + 1 < gb.isArrive[r].length
&& gb.isArrive[r1][c1] == gb.isArrive[r1 + 1][c1 + 1]) {
break; // 檢測兩個位置是否都爲空位
}
code = code + gb.isArrive[r1][c1];// 記錄棋子相連的情況
number++;
} else if (number == 2) {// 表示第三次出現空位
if (gb.isArrive[r1][c1] == gb.isArrive[r][c]) // 檢測兩個位置是否都爲空位
break;
}
} else {
if (chess == 0) {// 表示第一次出現棋子
chess = gb.isArrive[r1][c1];// 存儲第一次出現棋子
code = code + gb.isArrive[r1][c1]; // 記錄棋子的相連情況
} else if (chess == gb.isArrive[r1][c1]) {// 判斷是否和第一次出現的棋子同色
code = code + gb.isArrive[r1][c1]; // 記錄棋子的相連情況
} else {// 表示此位置的棋子的顏色與第一次出現的顏色不同，所以記錄
code = code + gb.isArrive[r1][c1]; // 記錄棋子的相連情況
break;
}
}
}
value = map.get(code);
if (value != null)// 判斷value是否不爲null
weightArray[r][c] += value;// 在對應空位累加權值
// 向右下
for (int r1 = r + 1, c1 = c + 1; r1 < gb.isArrive.length
&& c1 < gb.isArrive[r].length; r1++, c1++) {
if (gb.isArrive[r1][c1] == 0) {
if (r == r1 - 1 && c == c1 - 1) {// 在c1+1處就空了，說明是連續兩個空位，就不用再討論啦
break;
}
// 不是連續兩個空位的情況
else if (number == 0) {// 表示第一次出現空位
code = code + gb.isArrive[r1][c1];// 記錄棋子相連的情況
number++;// 空位的次數加1
} else if (number == 1) {// 表示第二次出現空位
if (r1 + 1 < gb.isArrive.length
&& c1 + 1 < gb.isArrive[r1].length
&& (gb.isArrive[r1][c1] == gb.isArrive[r1 + 1][c1 + 1])) {
break; // 檢測兩個位置是否都爲空位
}
code = code + gb.isArrive[r1][c1];// 記錄棋子相連的情況
number++;
} else if (number == 2) {// 表示第三次出現空位
if (gb.isArrive[r1][c1] == gb.isArrive[r][c]) // 檢測兩個位置是否都爲空位
break;
}
} else {
if (chess == 0) {// 表示第一次出現棋子
chess = gb.isArrive[r1][c1];// 存儲第一次出現棋子
code = code + gb.isArrive[r1][c1]; // 記錄棋子的相連情況
} else if (chess == gb.isArrive[r1][c1]) {// 判斷是否和第一次出現的棋子同色
code = code + gb.isArrive[r1][c1]; // 記錄棋子的相連情況
} else {// 表示此位置的棋子的顏色與第一次出現的顏色不同，所以記錄
code = code + gb.isArrive[r1][c1]; // 記錄棋子的相連情況
break;
}
}
}
value = map.get(code);
if (value != null)// 判斷value是否不爲null
weightArray[r][c] += value;// 在對應空位累加權值
// 左斜方向
// 向右上
for (int r1 = r - 1, c1 = c + 1; r1 >= 0
&& c1 < gb.isArrive[r].length; r1--, c1++) {
if (gb.isArrive[r1][c1] == 0) {
if (r == r1 + 1 && c == c1 - 1) {// 在c1+1處就空了，說明是連續兩個空位，就不用再討論啦
break;
}
// 不是連續兩個空位的情況
else if (number == 0) {// 表示第一次出現空位
code = code + gb.isArrive[r1][c1];// 記錄棋子相連的情況
number++;// 空位的次數加1
} else if (number == 1) {// 表示第二次出現空位
if (c1 + 1 < gb.isArrive[r].length
&& r1 - 1 > 0
&& gb.isArrive[r1][c1] == gb.isArrive[r1 - 1][c1 + 1]) {
break; // 檢測兩個位置是否都爲空位
}
code = code + gb.isArrive[r1][c1];// 記錄棋子相連的情況
number++;
} else if (number == 2) {// 表示第三次出現空位
if (gb.isArrive[r1][c1] == gb.isArrive[r][c]) // 檢測兩個位置是否都爲空位
break;
}
} else {
if (chess == 0) {// 表示第一次出現棋子
chess = gb.isArrive[r1][c1];// 存儲第一次出現棋子
code = code + gb.isArrive[r1][c1]; // 記錄棋子的相連情況
} else if (chess == gb.isArrive[r1][c1]) {// 判斷是否和第一次出現的棋子同色
code = code + gb.isArrive[r1][c1]; // 記錄棋子的相連情況
} else {// 表示此位置的棋子的顏色與第一次出現的顏色不同，所以記錄
code = code + gb.isArrive[r1][c1]; // 記錄棋子的相連情況
break;
}
}
}
value = map.get(code);
if (value != null)// 判斷value是否不爲null
weightArray[r][c] += value;// 在對應空位累加權值
// 向左下
for (int r1 = r + 1, c1 = c - 1; r1 < gb.isArrive.length
&& c1 > 0; r1++, c1--) {
if (gb.isArrive[r1][c1] == 0) {
if (r == r1 - 1 && c == c1 + 1) {// 在c1+1處就空了，說明是連續兩個空位，就不用再討論啦
break;
}
// 不是連續兩個空位的情況
else if (number == 0) {// 表示第一次出現空位
code = code + gb.isArrive[r1][c1];// 記錄棋子相連的情況
number++;// 空位的次數加1
} else if (number == 1) {// 表示第二次出現空位
if (r1 + 1 < gb.isArrive.length
&& c1 - 1 > 0
&& gb.isArrive[r1][c1] == gb.isArrive[r1 + 1][c1 - 1]) {
break; // 檢測兩個位置是否都爲空位
}
code = code + gb.isArrive[r1][c1];// 記錄棋子相連的情況
number++;
} else if (number == 2) {// 表示第三次出現空位
if (gb.isArrive[r1][c1] == gb.isArrive[r][c]) // 檢測兩個位置是否都爲空位
break;
}
} else {
if (chess == 0) {// 表示第一次出現棋子
chess = gb.isArrive[r1][c1];// 存儲第一次出現棋子
code = code + gb.isArrive[r1][c1]; // 記錄棋子的相連情況
} else if (chess == gb.isArrive[r1][c1]) {// 判斷是否和第一次出現的棋子同色
code = code + gb.isArrive[r1][c1]; // 記錄棋子的相連情況
} else {// 表示此位置的棋子的顏色與第一次出現的顏色不同，所以記錄
code = code + gb.isArrive[r1][c1]; // 記錄棋子的相連情況
break;
}
}
}
value = map.get(code);
if (value != null)// 判斷value是否不爲null
weightArray[r][c] += value;// 在對應空位累加權值
}
}
}
}