java写的一个五子棋，求大佬们指点

fresh_python

棋盘类：

1. public class Board {
   
2.     protected static int rows;
   
3.     protected static int cols;
   
4.     protected static int size;
   
5.     protected static int margin;
   
6. 
   
7.     public static void main(String[] args){
   
8.         Board.init(6,6,30,20);
   
9.         CoordinateLogical c1 = new CoordinateLogical(2,3);
   
10.         CoordinatePhysical c2 = new CoordinatePhysical(10,20);
    
11. 
    
12.         CoordinateLogical c21 = Board.convert(c2);
    
13.         CoordinatePhysical c11 = Board.convert(c1);
    
14. 
    
15.         System.out.printf("(%d,%d)->(%d,%d)",c2.x,c2.y,c21.col,c21.row);
    
16.         System.out.printf("(%d,%d)->(%d,%d)",c1.col,c1.row,c11.x,c11.y);
    
17.     }
    
18. 
    
19.     public static void init(int n1,int n2,int n3,int n4){
    
20.         rows = n1;
    
21.         cols = n2;
    
22.         size = n3;
    
23.         margin = n4;
    
24.     }
    
25. 
    
26.     /**
    
27.      * 物理坐标转换为逻辑坐标
    
28.      * @param c
    
29.      * @return
    
30.      */
    
31.     public static CoordinateLogical convert(CoordinatePhysical c){
    
32.         CoordinateLogical c1 = new CoordinateLogical();
    
33.         c1.col = Math.round((c.x-margin)/(float)size);
    
34.         c1.row = Math.round((c.y - margin)/(float)size);
    
35. 
    
36.         return c1;
    
37.     }
    
38. 
    
39.     /**
    
40.      * 逻辑坐标转换为物理坐标
    
41.      * @param c
    
42.      * @return
    
43.      */
    
44.     public static CoordinatePhysical convert(CoordinateLogical c){
    
45.         CoordinatePhysical c1 = new CoordinatePhysical();
    
46.         c1.x = margin + size * c.col;
    
47.         c1.y = margin + size * c.row;
    
48.         return c1;
    
49.     }
    
50. 
    
51.     public static int getWidth() {
    
52.         return margin*2+size*(rows-1);
    
53.     }
    
54. 
    
55.     public static int getHeight() {
    
56.         return margin*2+size*(cols-1);
    
57.     }
    
58. }
    

复制代码

棋局类：

1. public class Chess {
   
2.     int flag = 0;
   
3.     public static int NONE = 0;//无子
   
4.     public static int WHITE = 1;//白子
   
5.     public static int BLACK = -1;//黑子
   
6. 
   
7.     private int [][]chesses;//左右落点的状态
   
8.     private int turn;//当前轮到白方（1）/黑方（-1）落子
   
9. 
   
10.     public Chess(int rows,int cols){
    
11. 
    
12.         //创建所有的落点
    
13.         chesses = new int[rows][cols];
    
14. 
    
15.         //初始化每个落点为无子
    
16.         for (int row = 0; row < rows; row++) {
    
17.             for (int col = 0; col < cols; col++) {
    
18.                 chesses[row][col] = NONE;
    
19.             }
    
20.         }
    
21. 
    
22.         //黑方落子
    
23.         turn = BLACK;
    
24.     }
    
25. 
    
26.     /**
    
27.      * 判断某个位置是否有棋子
    
28.      * @param c 逻辑位置
    
29.      * @return 是否由棋子
    
30.      */
    
31.     public boolean exist(CoordinateLogical c){
    
32. 
    
33.         return chesses[c.row][c.col] != NONE;
    
34.     }
    
35. 
    
36.     /**
    
37.      * 落子
    
38.      * @param c 落子位置
    
39.      * @return 落子颜色
    
40.      */
    
41.     public int add(CoordinateLogical c){
    
42.         int color = turn;
    
43.         chesses[c.row][c.col] = color;
    
44.         turn = - turn;
    
45.         return color;
    
46.     }
    
47. 
    
48.     public int isWin1(CoordinateLogical c){
    
49.         int color = chesses[c.row][c.col];
    
50.         //垂直方向
    
51.         if(extend(c,0)+extend(c,4)>=4){
    
52.             return color;
    
53.         }
    
54.         //负对角线方向
    
55.         if(extend(c,1)+extend(c,5)>=4){
    
56.             return color;
    
57.         }
    
58.         //水平方向
    
59.         if(extend(c,2)+extend(c,6)>=4){
    
60.             return color;
    
61.         }
    
62.         //主对角线方向
    
63.         if(extend(c,3)+extend(c,7)>=4){
    
64.             return color;
    
65.         }
    
66.         return 0;
    
67.     }
    
68. 
    
69.     /**
    
70.      * 从指定位置往某个方向扩展
    
71.      * @param c 位置
    
72.      * @param direction 方向 0：上 1：右上 2：右 3：右下 4：下 5：左下 6：左 7：左上
    
73.      * @return
    
74.      */
    
75.     private int extend(CoordinateLogical c,int direction){
    
76.         int count = 0;
    
77.         int row = c.row;
    
78.         int col = c.col;
    
79.         int color = chesses[row][col];
    
80. 
    
81.         //一个方向拓展的次数不可能超过4
    
82.         for (int i = 0; i < 4; i++) {
    
83.             switch (direction){
    
84.                 case 0:
    
85.                     row--;
    
86.                     break;
    
87.                 case 1:
    
88.                     row--;
    
89.                     col++;
    
90.                     break;
    
91.                 case 2:
    
92.                     col++;
    
93.                     break;
    
94.                 case 3:
    
95.                     row++;
    
96.                     col++;
    
97.                     break;
    
98.                 case 4:
    
99.                     row++;
    
100.                     break;
     
101.                 case 5:
     
102.                     row++;
     
103.                     col--;
     
104.                     break;
     
105.                 case 6:
     
106.                     col--;
     
107.                     break;
     
108.                 case 7:
     
109.                     col--;
     
110.                     row--;
     
111.                     break;
     
112.             }
     
113.             if(row<0||row>=Board.rows||col<0||col>=Board.cols){
     
114.                 break;
     
115.             }
     
116.             if(chesses[row][col]==color){
     
117.                 count++;
     
118.             }else{
     
119.                 break;
     
120.             }
     
121.         }
     
122.         return count;
     
123. 
     
124.     }
     
125. 
     
126.     /**
     
127.      * 判断在指定位置的周围是否形成了五个以上同色的棋子
     
128.      * @param p 位置
     
129.      * @return
     
130.      */
     
131.     public int isWin(CoordinateLogical p){
     
132. 
     
133.         if((count(p,0,-1,-turn)+count(p,0,1,-turn))-1>=5)
     
134.         {
     
135.             return -turn;
     
136.         }
     
137.         if((count(p,1,0,-turn)+count(p,-1,0,-turn))-1>=5)
     
138.         {
     
139.             return -turn;
     
140.         }
     
141.         if((count(p,1,-1,-turn)+count(p,-1,1,-turn))-1>=5){
     
142.             return -turn;
     
143.         }
     
144.         if((count(p,-1,-1,-turn)+count(p,1,1,-turn))-1>=5){
     
145.             return -turn;
     
146.         }
     
147. 
     
148.      return 0;
     
149.     }
     
150. 
     
151.     private int count(CoordinateLogical p,int movX,int movY,int turn){
     
152.         CoordinateLogical p1 = new CoordinateLogical(0,0);
     
153. 
     
154.             if (chesses[p.row][ p.col] == turn) {
     
155.                 if ((p.row < 0 || p.row >= Board.rows) || p.col < 0 || p.col >= Board.cols) {
     
156.                     return 0;
     
157.                 }
     
158.                 p1.col = p.col + movX;
     
159.                 p1.row = p.row + movY;
     
160.                 return 1+count(p1,movX,movY,turn);
     
161. 
     
162.             } else {
     
163.                 return 0;
     
164.             }
     
165. 
     
166. 
     
167.     }
     
168. }
     

复制代码

逻辑坐标类

1. //逻辑坐标
   
2. public class CoordinateLogical {
   
3.     public int col;
   
4.     public int row;
   
5. 
   
6.     public CoordinateLogical(int col,int row){
   
7.         this.col = col;
   
8.         this.row = row;
   
9.     }
   
10. 
    
11.     public CoordinateLogical(){
    
12.         this.col = 0;
    
13.         this.row = 0;
    
14.     }
    
15. }
    

复制代码

物理坐标类：

1. //物理坐标
   
2. public class CoordinatePhysical {
   
3.     public int x;
   
4.     public int y;
   
5. 
   
6.     public CoordinatePhysical(int x,int y){
   
7.         this.x = x;
   
8.         this.y = y;
   
9.     }
   
10.     public CoordinatePhysical(){
    
11.         this.x = 0;
    
12.         this.y = 0;
    
13.     }
    
14. }
    

复制代码

游戏控制类：

1. import javax.swing.*;
   
2. import java.awt.*;
   
3. import java.awt.event.MouseAdapter;
   
4. import java.awt.event.MouseEvent;
   
5. import java.awt.event.WindowAdapter;
   
6. import java.awt.event.WindowEvent;
   
7. 
   
8. public class Game {
   
9.     private static Frame frame;//窗体
   
10.     private static Canvas canvas;//画布
    
11.     private static Graphics graphics;//绘图对象
    
12.     private static Button button;//按钮
    
13. 
    
14. 
    
15.     private static Chess chess;
    
16. 
    
17.     /**
    
18.      * 构造函数
    
19.      *
    
20.      * @param rows
    
21.      * @param cols
    
22.      * @param size
    
23.      * @param margin
    
24.      */
    
25.     public Game(int rows, int cols, int size, int margin) {
    
26.         Board.init(rows, cols, size, margin);
    
27.         chess = new Chess(rows, cols);
    
28.     }
    
29. 
    
30.     public static void main(String[] args) {
    
31.         Game game = new Game(19, 19, 30, 20);
    
32. 
    
33.         //初始化窗体
    
34.         int width = Board.getWidth();
    
35.         int height = Board.getHeight() + 100;
    
36.         frame = new Frame("我的五子棋");
    
37.         frame.setSize(width, height);
    
38.         frame.setLayout(new FlowLayout());
    
39.         //关闭窗口
    
40.         frame.addWindowListener(new WindowAdapter(){
    
41.             public void windowClosing(WindowEvent e) {
    
42.                 System.exit(0);//退出
    
43.             }});
    
44.         //准备画布
    
45.         canvas = new Canvas();
    
46.         canvas.setSize(width, height);
    
47.         frame.add(canvas);
    
48. 
    
49.         button = new Button("Start");
    
50.         button.setSize(100, 40);
    
51.         frame.add(button);
    
52. 
    
53. 
    
54.         button.addMouseListener(new MouseAdapter() {
    
55.             @Override
    
56.             public void mouseClicked(MouseEvent mouseEvent) {
    
57.                 graphics = canvas.getGraphics();
    
58.                 drawBoard();
    
59.                 super.mouseClicked(mouseEvent);
    
60.             }
    
61.         });
    
62. 
    
63.         //鼠标响应事件
    
64.         canvas.addMouseListener(new MouseAdapter() {
    
65.             @Override
    
66.             public void mouseClicked(MouseEvent e) {
    
67.                 CoordinatePhysical c = new CoordinatePhysical(e.getX(), e.getY());
    
68.                 int result = handle(c);
    
69.                 if (result != Chess.NONE) {
    
70.                     String actor = result==Chess.BLACK?"黑方":"白方";
    
71.                     String msg = String.format("恭喜%s获胜",actor);
    
72.                     JOptionPane.showMessageDialog(null, msg, "游戏结束", JOptionPane.OK_CANCEL_OPTION, null);
    
73.                     //System.exit(1);
    
74.                     graphics = canvas.getGraphics();
    
75.                     drawBoard();
    
76.                 }
    
77. 
    
78.                 super.mouseClicked(e);
    
79.             }
    
80.         });
    
81. 
    
82.         frame.setVisible(true);//显示窗体
    
83. 
    
84.     }
    
85. 
    
86. 
    
87.     /**
    
88.      * 画棋盘
    
89.      */
    
90.     public static void drawBoard(){
    
91. 
    
92.         graphics.setColor(Color.ORANGE);
    
93.         graphics.fillRect(0,0,Board.getWidth(),Board.getHeight());
    
94.         //绘制纬线
    
95.         graphics.setColor(Color.BLACK);
    
96.         int x1 = Board.margin;
    
97.         int y1 = Board.margin;
    
98.         int x2 = x1+Board.size*(Board.cols-1);
    
99.         int y2 = y1;
    
100.         for (int i = 0; i < Board.rows; i++) {
     
101.             graphics.drawLine(x1,y1,x2,y2);
     
102.             y1 += Board.size;
     
103.             y2 += Board.size;
     
104.         }
     
105. 
     
106.         //绘制经线
     
107.         x1 = Board.margin;
     
108.         y1 = Board.margin;
     
109.         x2 = x1;
     
110.         y2 = y1+Board.size*(Board.rows-1);
     
111.         for (int i = 0; i < Board.rows; i++) {
     
112.             graphics.drawLine(x1,y1,x2,y2);
     
113.             x1 += Board.size;
     
114.             x2 += Board.size;
     
115.         }
     
116. 
     
117.     }
     
118. 
     
119.     /**
     
120.      * 画棋子
     
121.      * @param c 坐标
     
122.      * @param color 颜色
     
123.      */
     
124.     public static void drawChess(CoordinateLogical c,int color){
     
125.         int r = (int)(Board.size*0.3);
     
126. 
     
127.         CoordinatePhysical c1 = Board.convert(c);
     
128.         int x = c1.x - r;
     
129.         int y = c1.y - r;
     
130.         int width = 2*r;
     
131.         int height = 2*r;
     
132.         graphics.setColor(color==-1?Color.BLACK:Color.WHITE);
     
133.         graphics.fillArc(x,y,width,height,0,360);
     
134.         graphics.drawArc(x,y,width,height,0,360);
     
135.     }
     
136. 
     
137.     /**
     
138.      * 在棋盘上单击的逻辑处理
     
139.      * @param c 单击的位置
     
140.      * @return 输赢结果
     
141.      */
     
142.     public static int handle(CoordinatePhysical c){
     
143.         int result;
     
144.         CoordinateLogical c1 = Board.convert(c);
     
145. 
     
146.         //如果该位置已经有棋子，则直接忽略本次操作
     
147.         if(chess.exist(c1)){
     
148.             return Chess.NONE;
     
149.         }
     
150. 
     
151. 
     
152.         int color = chess.add(c1);
     
153.         drawChess(c1,color);
     
154.         result = chess.isWin1(c1);
     
155. 
     
156. 
     
157.         return result;
     
158.     }
     
159. }
     

复制代码