目录
实现思路
- 1.完成棋盘的绘制(棋盘线,重绘问题)
- 2.完成棋子的绘制(棋子3D效果如何实现,如何保证棋子落点在线与线的交叉点上)
- 3.判断输赢问题
- 4.功能按钮的实现(开始，悔棋，复盘的实现)
- 5.人机对战的算法详解(权值算法—枚举思想)
- 6.原码展示( 棋盘类,监听器类,棋子类)
棋盘绘制
窗体初始化及布局
GUI编程的实现都离不开容器和组件，容器是我们想要实现内容的载体，只有有了容器，才能把内容展示出来，所以在画一个棋盘之前，我们需要一个容器-----定义一个窗体容器.
JFrame jf=new JFrame();
jf.setTitle("五子棋");//设置标题
jf.setSize(700,800);//设置窗体大小
jf.setLocationRelativeTo(null);//设置是否居中显示
jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//是否关闭后结束进程在有了内容载体之后，我们还要考虑内容的布局，我是将北面设置为功能按钮实现区，其余部分作为棋盘.效果图如下:
代码如下：
JPanel northPanel = new JPanel(); //控制面板
northPanel.setBackground(Color.LIGHT_GRAY);
northPanel.setPreferredSize(new Dimension(0,60));
jf.add(northPanel,BorderLayout.NORTH);
String[] name={"开始","悔棋","复盘","人机对战"};
for(int i=0;i<name.length;i++){
JButton btn=new JButton(name[i]);
btn.setPreferredSize(new Dimension(90,50));
northPanel.add(btn);
btn.addActionListener(mouse);
}//控制面板按钮
this.setBackground(Color.WHITE);//棋盘绘制区
jf.add(this,BorderLayout.CENTER);棋盘线绘制
棋盘线就是等间距的多个竖线和横线相交的效果,所以要保证等间距，多个横线和竖线相交，横线和竖线条数相等.很容易想到用for循环去控制条数，等间距只要在画线的时候，通过for循环里面的变量来增加间距,实现代码如下:
15是总条数,40 600是起始点和终点，间距是40
for (int i=0; i<15;i++) {
gr.drawLine(40, 40+i*40, 600, 40+i*40);
gr.drawLine(40+i*40, 40, 40+i*40, 600);
}注解(硬编码问题，因为一开始没注意，所以有些常量最好用变量去表示，这样在修改的时候也更加方便，这也是需要优化的地方);
重绘问题
提到画图就不得不提到重绘问题，因为当我们在改变窗体的时候，比如改变大小，窗体最小化，窗体会默认调用paint方法，而paint方法默认会清空我们所画的图，所以我们需要重写paint方法，把我们画出来的结果保留在paint方法中.其次当我们运行这个程序的时候，我们也希望棋盘能够直接展示出来，而窗体被调用的时候也会调用一次paint方法，所以我们只需要在paint方法中画好棋盘就能在程序初始化的时候展示出来.
public void paint(Graphics gr){
super.paint(gr);//调用父类的paint方法
//绘制棋盘
for (int i=0; i<15;i++) {
gr.drawLine(40, 40+i*40, 600, 40+i*40);
gr.drawLine(40+i*40, 40, 40+i*40, 600);
}
//绘制棋子,arr数组保存的是棋子信息
for (int i=0; i<arr.length;i++) {
for (int j=0; j<arr[0].length; j++) {
if (arr[i][j]!=0) {
if (arr[i][j]==1) {
for (int a=0; a<30;a++) {
gr.setColor(new Color(5*a,5*a,5*a));
gr.fillOval((j + 1)*40-15+a/2, (i+1)*40-15+a/2, 30-a, 30-a);
}
} else {
for (int a=0; a<30;a++) {
gr.setColor(new Color(155+3*a,155+3*a,155+3*a));
gr.fillOval((j + 1) * 40 - 15+a/2, (i + 1) * 40 - 15+a/2, 30-a, 30-a);
}
}
}
}
}
}棋子绘制
3D效果实现
棋子的3D效果如上图所示，可以很清楚的看到，一个棋子想要有立体的感觉，就必须要反射不同的光线，在图中就是有很明显的渐变感觉，这种渐变的感觉就是外层颜色和里层颜色不一样产生的视觉效果，所以我们想要实现3D效果，就必须画多个圆，圆的半径在变小，其次颜色也在变化.
for (int a=0; a<30;a++) {
gr.setColor(new Color(5*a,5*a,5*a));
gr.fillOval((j + 1)*40-15+a/2, (i+1)*40-15+a/2, 30-a, 30-a);
}//黑棋 for (int a=0; a<30;a++) {
gr.setColor(new Color(155+3*a,155+3*a,155+3*a));
gr.fillOval((j + 1) * 40 - 15+a/2, (i + 1) * 40 - 15+a/2, 30-a, 30-a);
}//白棋棋盘落点问题
当我们随意点击时，他的落点不一定会在棋盘线的交界处，那我们需要怎么处理呢.我们知道一个棋子的落点坐标，我们也知道棋线交点的坐标，因为在绘制棋盘的时候我们指定了起始点终点，间距，条数，由此可以推断出这个交点坐标就是40（间距）的倍数，这样我们可以拿落点坐标/40，看有多少个40，就是第几条线，但是在做除法的时候永远是向下取整，这也就导致了明明靠近x=120的交点，却画在了x=80的点上，为了拒绝这个错误，我们要先判断他到底是四舍还是五入.
if ((x1-40)%40>20) {
gridx=(x1-40)/40+1;
} else
gridx=(x1-40)/40;
if ((y1-40)%40>20) {
gridy=(y1-40)/40+1;
}
else
gridy=(y1-40)/40;输赢判断问题
我们在判断输赢前，需要保存棋盘结果，那么拿何种结构保存呢?一开始我选的是集合，但是我想取出一个棋子的横坐标纵坐标就非常不方便，后来我想到了用二维数组的结构，二维数组更像是一个棋盘，并且他的row，col就是x，y坐标。所以我们采用二维数组来保存棋盘。在每次下棋后，我们把棋子添加到二维数组中，在遍历这个二维数组，如果这个二维棋子数组[x][y]不为空，就是有棋子，那我们就去遍历这个位置的八个方向，例如向左，我们遇到一个同色棋子就把一个变量++，直到遇到一个不一样的或者为空我们就break.
//水平方向
public int check(int gridx,int gridy){
int chess=1;
for(int i=gridx+1;i<chessArr.length;i++){
if(chessArr[gridy][gridx]==chessArr[gridy][i])
chess++;
else
break;
}
for(int i=gridx-1;i>=0;i--){
if(chessArr[gridy][gridx]==chessArr[gridy][i])
chess++;
else
break;
}
return chess;
}
//竖直方向
public int check1(int gridx,int gridy){
int chess1=1;
for(int i=gridy+1;i<chessArr.length;i++){
if(chessArr[gridy][gridx]==chessArr[i][gridx])
chess1++;
else
break;
}
for(int i=gridy-1;i>=0;i--){
if(chessArr[gridy][gridx]==chessArr[i][gridx])
chess1++;
else
break;
}
return chess1;
}
//右下左上
public int check2(int gridx,int gridy){
int chess3=1;
for(int i=gridx+1,j=gridy+1;i<chessArr.length&&j<chessArr.length;i++,j++){
if(chessArr[gridy][gridx]==chessArr[j][i])
chess3++;
else
break;
}
for(int i=gridx-1,j=gridy-1;i>=0&&j>=0;i--,j--){
if(chessArr[gridy][gridx]==chessArr[j][i])
chess3++;
else
break;
}
return chess3;
}
//右上左下
public int check3(int gridx,int gridy){
int chess4=1;
for(int i=gridx+1,j=gridy-1;i<chessArr.length&&j>=0;i++,j--){
if(chessArr[gridy][gridx]==chessArr[j][i])
chess4++;
else
break;
}
for(int i=gridx-1,j=gridy+1;i>=0&&j<chessArr.length;i--,j++){
if(chessArr[gridy][gridx]==chessArr[j][i])
chess4++;
else
break;
}
return chess4;
}
public int CheckRow(int gridx,int gridy){
if(check(gridx,gridy)>=5||check1(gridx,gridy)>=5||check2(gridx,gridy)>=5||check3(gridx,gridy)>=5){
if(chessArr[gridy][gridx]==1)
return 1;
if(chessArr[gridy][gridx]==2)
return 2;
}
return 0;
}
int result=CheckRow(gridx,gridy);
if(result==1){
jd.add(text1);
jd.setVisible(true);
}
if(result==2){
jd.add(text2);
jd.setVisible(true);
}功能按钮的实现
开始按钮
开始游戏的实现很简单，我们只需要定义一个statue一开始让他为false,当我们点击开始游戏，让他的状态变为true，在我们下棋的时候判断是否为true，如果为true就可以下棋.
如何实现一黑一白下棋，而不是一直黑棋或者一直白棋呢,实现思路和开始按钮其实差不多，我们可以定义一个flag，如果是true就是黑棋，false就是白棋，当黑棋下完，true变false，当白棋下完false变true就可以实现一黑一白的效果.
悔棋按钮
要实现悔棋，我们肯定要知道下棋的顺序，一般悔棋是最后一个棋子，但是我们前面定义的棋盘数组是不能知道顺序的，它最多知道我们在哪些地方下棋，以及下棋的颜色.所以我们需要重新定义一个结构保存这些棋子的顺序，我定义的是一个集合，自己模拟实现了一个集合，并增添了一个getLast（）方法，来取出最后一个棋子，取出最后一个棋子我们就要删除这个棋子，并且让棋盘二维数组这个位置为0。在拿出这个棋子的颜色，判断下一次谁先手.
point=arr.getLast();
arr.removes(point);
chessArr[point.getY()][point.getX()]=0;
//重绘删除点后的棋盘
jPanel.paint(gr);
//判断下一次谁先手
if(point.getColor()==1)
flag=true;
else
flag=false;复盘按钮
复盘的实现像悔棋按钮，只不过是他要取出所有棋子，这也用到了我们前面保存棋子顺序的集合，我们只需要拿出棋子，拿出棋子的坐标和颜色，在通过paint方法调用，重绘一次棋盘就可以实现。但这样复盘的时候往往是一秒钟就出现了所有结果，我们希望的是下一个黑子，过1s在下白子，这些动作是有间隔的，所以我们采用线程的sleep方法，下一次调用一次，就可以实现短暂间隔.
for(int i=0;i<arr.size();i++){
//取出棋子
point=arr.get(i);
//设置时间间隔
try {
Thread.sleep(2000);
} catch (InterruptedException ex) {
ex.printStackTrace();
}
//偶数黑棋，单数白棋
if(i%2==0)
chessArr[point.getY()][point.getX()]=1;
else
chessArr[point.getY()][point.getX()]=2;
jPanel.paint(gr);
}人机对战
人机对战的实现，我采用的是权值算法，也就是枚举的思想，把所有可能的情况权值保存下来，在下棋的时候判断棋子权值，下在权值较为大的地方。那么选择何种结构去保存呢？经过分析我们需要保存两个数据，一个是棋子情况，一个是位置的权值，所以选择哈希表较为合适。
关于棋子情况，有活连，眠连，死连的情况。下面列举的只是一些情况，权值也可以自己更改。
private HashMap<String, Integer> weightMap = new HashMap<String, Integer>();
public void putMap(){
weightMap.put("11110", 11000);
weightMap.put("1111", 15000);
weightMap.put("10111",16000);
weightMap.put("11112", 16000);
weightMap.put("1110", 7000);
weightMap.put("111", 5550);
weightMap.put("1112", 600);
weightMap.put("110", 500);
weightMap.put("11", 200);
weightMap.put("112", 220);
weightMap.put("10", 100);
weightMap.put("12", 40);
weightMap.put("1", 25);
weightMap.put("22220", 20000);
weightMap.put("2222", 17000);
weightMap.put("22221", 18000);
weightMap.put("2220", 10000);
weightMap.put("2221", 650);
weightMap.put("222", 600);
weightMap.put("220", 400);
weightMap.put("221", 270);
weightMap.put("22", 250);
weightMap.put("20", 200);
weightMap.put("21", 120);
weightMap.put("2", 40);
weightMap.put("", 0);
weightMap.put("0", 0);
}枚举好所有的情况后，我们需要去遍历这个棋盘，也就是之前的棋盘二维数组，在没有下棋的地方计算权值较大处。在一个空棋处，我们需要计算这个地方的八个方向的权值并把它累加。我们需要定义两个变量，一个code来保存棋子情况，一个color来保存棋子的颜色，比如向左遍历，这时候又分为两种情况，一种是又为空，另一种是有棋子。又为空我们只需要令color=0,code+这个位置的棋子,如果有棋子，我们就用color来保存这些棋子的第一个棋子，然后继续遍历，如果颜色一样就++，颜色不一样就break.例如
for(int k=j-1;k>=0;k--){
if(chessArr[i][k]==0){
if(chessArr[i][k]==chessArr[i][k+1])
break;
else
code+=chessArr[i][k];
color=0;
}
else if(chessArr[i][k]!=0){
if(color==0){
color=chessArr[i][k];
code+=chessArr[i][k];
}else if(chessArr[i][k]==color){
code+=chessArr[i][k];
}
else if(chessArr[i][k]!=color){
color=chessArr[i][k];
code+=chessArr[i][k];
}
}
}
if(weightMap.get(code)!=null){
chessValue[i][j]+=weightMap.get(code);
}源码
棋盘类
package Game;
import javax.swing.*;
import java.awt.*;
public class DrawUI extends JPanel {
private int[][] arr = new int[15][15];
int x,y;
Color color;
public void showUI(){
JFrame jf=new JFrame();
jf.setTitle("五子棋");
jf.setSize(700,800);
jf.setLocationRelativeTo(null);
jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
JPanel northPanel = new JPanel();
northPanel.setBackground(Color.LIGHT_GRAY);
northPanel.setPreferredSize(new Dimension(0,60));
jf.add(northPanel,BorderLayout.NORTH);
GameMouse mouse=new GameMouse();
String[] name={"开始","悔棋","复盘","人机对战"};
for(int i=0;i<name.length;i++){
JButton btn=new JButton(name[i]);
btn.setPreferredSize(new Dimension(90,50));
northPanel.add(btn);
btn.addActionListener(mouse);
}
this.setBackground(Color.WHITE);
jf.add(this,BorderLayout.CENTER);
jf.setVisible(true);
Graphics gr=this.getGraphics();
JDialog jd=new JDialog(jf,"输赢结果",true);
jd.setLocationRelativeTo(null);
jd.setSize(new Dimension(150,150));
this.addMouseListener(mouse);
mouse.setGr(gr);
mouse.setPanel(this);
mouse.setJd(jd);
arr=mouse.returnArr();
}
public void paint(Graphics gr){
super.paint(gr);
for (int i=0; i<15;i++) {
gr.drawLine(40, 40+i*40, 600, 40+i*40);
gr.drawLine(40+i*40, 40, 40+i*40, 600);
}
for (int i=0; i<arr.length;i++) {
for (int j=0; j<arr[0].length; j++) {
if (arr[i][j]!=0) {
if (arr[i][j]==1) {
for (int a=0; a<30;a++) {
gr.setColor(new Color(5*a,5*a,5*a));
gr.fillOval((j + 1)*40-15+a/2, (i+1)*40-15+a/2, 30-a, 30-a);
}
} else {
for (int a=0; a<30;a++) {
gr.setColor(new Color(155+3*a,155+3*a,155+3*a));
gr.fillOval((j + 1) * 40 - 15+a/2, (i + 1) * 40 - 15+a/2, 30-a, 30-a);
}
}
}
}
}
}
public static void main(String[] args) {
DrawUI ui=new DrawUI();
ui.showUI();
}
}
棋子类
package Game;
public class Point {
private int x,y;
private int color;
private int order;
public Point(int x,int y,int color ,int order){
this.x=x;
this.y=y;
this.color=color;
this.order=order;
}
public Point() {
}
public int getX() {
return x;
}
public void setX(int x) {
this.x = x;
}
public int getY() {
return y;
}
public void setY(int y) {
this.y = y;
}
public int getColor() {
return color;
}
public void setColor(int color) {
this.color = color;
}
public int getOrder() {
return order;
}
public void setOrder(int order) {
this.order = order;
}
public String toString() {
return "Point{x = " + x + ", y = " + y + ", color = " + color + ", order = " + order + "}";
}
}
监听器类
package Game;
import Draw.ArrList;
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.util.HashMap;
public class GameMouse extends MouseAdapter implements ActionListener{
private Graphics gr;
private JPanel jPanel;
private JLabel text1=new JLabel(" 黑方赢");
private JLabel text2=new JLabel(" 白方赢");
private JDialog jd;
private String name;
private boolean statue1=false;
private int[][] weight = new int[15][15];
private int[] re=new int[2];
Point point=new Point();
boolean flag=true;
boolean statue=false;
private int order=0;
int gridx,gridy;
private int[][] chessArr = new int[15][15];
private ArrList<Point> arr=new ArrList<>();
private HashMap<String, Integer> weightMap = new HashMap<String, Integer>();
public void putMap(){
weightMap.put("11110", 11000);
weightMap.put("1111", 15000);
weightMap.put("10111",16000);
weightMap.put("11112", 16000);
weightMap.put("1110", 7000);
weightMap.put("111", 5550);
weightMap.put("1112", 600);
weightMap.put("110", 500);
weightMap.put("11", 200);
weightMap.put("112", 220);
weightMap.put("10", 100);
weightMap.put("12", 40);
weightMap.put("1", 25);
weightMap.put("22220", 20000);
weightMap.put("2222", 17000);
weightMap.put("22221", 18000);
weightMap.put("2220", 10000);
weightMap.put("2221", 650);
weightMap.put("222", 600);
weightMap.put("220", 400);
weightMap.put("221", 270);
weightMap.put("22", 250);
weightMap.put("20", 200);
weightMap.put("21", 120);
weightMap.put("2", 40);
weightMap.put("", 0);
weightMap.put("0", 0);
}
public int[][] ai(){
putMap();
int[][] chessValue=new int[15][15];
for(int i=0;i<chessArr.length;i++){
for(int j=0;j<chessArr[i].length;j++){
if(chessArr[i][j]==0){
String code="";
int color=0;
//左权值
for(int k=j-1;k>=0;k--){
if(chessArr[i][k]==0){
if(chessArr[i][k]==chessArr[i][k+1])
break;
else
code+=chessArr[i][k];
color=0;
}
else if(chessArr[i][k]!=0){
if(color==0){
color=chessArr[i][k];
code+=chessArr[i][k];
}else if(chessArr[i][k]==color){
code+=chessArr[i][k];
}
else if(chessArr[i][k]!=color){
color=chessArr[i][k];
code+=chessArr[i][k];
}
}
}
if(weightMap.get(code)!=null){
chessValue[i][j]+=weightMap.get(code);
}
color=0;
code="";
//右权值
for(int k=j+1;k<chessArr.length;k++){
if(chessArr[i][k]==0){
if(chessArr[i][k]==chessArr[i][k-1])
break;
else
code+=chessArr[i][k];
color=0;
}
else if(chessArr[i][k]!=0){
if(color==0){
color=chessArr[i][k];
code+=chessArr[i][k];
}
else if(chessArr[i][k]==color)
code+=chessArr[i][k];
else if(chessArr[i][k]!=color){
color = chessArr[i][k];
code += chessArr[i][k];
break;
}
}
}
if(weightMap.get(code)!=null)
chessValue[i][j]+=weightMap.get(code);
code="";
color=0;
for(int k=i-1;k>=0;k--){
if(chessArr[k][j]==0){
if(chessArr[k][j]==chessArr[k+1][j])
break;
else
code+=chessArr[k][j];
color=0;
}
else if(chessArr[k][j]!=0){
if(color==0){
color=chessArr[k][j];
code+=chessArr[k][j];
}
else if(chessArr[k][j]==color)
code+=chessArr[k][j];
else if(chessArr[k][j]!=color){
color = chessArr[k][j];
code += chessArr[k][j];
break;
}
}
}
if(weightMap.get(code)!=null)
chessValue[i][j]+=weightMap.get(code);
code="";
color=0;
//下权值
for(int k=i+1;k<chessArr.length;k++){
if(chessArr[k][j]==0){
if(chessArr[k][j]==chessArr[k-1][j])
break;
else
code+=chessArr[k][j];
color=0;
}
else if(chessArr[k][j]!=0){
if(color==0){
color=chessArr[k][j];
code+=chessArr[k][j];
}
else if(chessArr[k][j]==color)
code+=chessArr[k][j];
else if(chessArr[k][j]!=color){
code+=chessArr[k][j];
color=chessArr[k][j];
break;
}
}
}
if(weightMap.get(code)!=null)
chessArr[i][j]+=weightMap.get(code);
color=0;
code="";
for(int k=i-1,m=j-1;k>=0&&m>=0;k--,m--){
if(chessArr[k][m]==0){
if(chessArr[k][m]==chessArr[k+1][m+1])
break;
else
code+=chessArr[k][m];
color=0;
}
else if(chessArr[k][m]!=0){
if(color==0){
color=chessArr[k][m];
code+=chessArr[k][m];
}
else if(chessArr[k][m]==color)
code+=chessArr[k][m];
else if(chessArr[k][m]!=color){
code+=chessArr[k][m];
color=chessArr[k][m];
break;
}
}
}
if(weightMap.get(code)!=null)
chessValue[i][j]+=weightMap.get(code);
color=0;
code="";
for(int k=i+1,m=j+1;k<chessArr.length&&m<chessArr.length;k++,m++){
if(chessArr[k][m]==0){
if(chessArr[k][m]==chessArr[k-1][m-1])
break;
else
code+=chessArr[k][m];
color=0;
}
else if(chessArr[k][m]!=0){
if(color==0){
color=chessArr[k][m];
code+=chessArr[k][m];
}
else if(chessArr[k][m]==color)
code+=chessArr[k][m];
else if(chessArr[k][m]!=color){
code+=chessArr[k][m];
color=chessArr[k][m];
break;
}
}
}
if(weightMap.get(code)!=null)
chessValue[i][j]+=weightMap.get(code);
color=0;
code="";
for(int k=i-1,m=j+1;k>=0&&m<chessArr.length;k--,m++){
if(chessArr[k][m]==0){
if(chessArr[k][m]==chessArr[k+1][m-1])
break;
else
code+=chessArr[k][m];
color=0;
}
else if(chessArr[k][m]!=0){
if(color==0){
color=chessArr[k][m];
code+=chessArr[k][m];
}
else if(chessArr[k][m]==color)
code+=chessArr[k][m];
else if(chessArr[k][m]!=color){
color=chessArr[k][m];
code+=chessArr[k][m];
break;
}
}
}
if(weightMap.get(code)!=null)
chessValue[i][j]+=weightMap.get(code);
color=0;
code="";
for(int k=i+1,m=j-1; k<chessArr.length&&m>=0;k++,m--){
if(chessArr[k][m]==0){
if(chessArr[k][m]==chessArr[k-1][m+1])
break;
else
code+=chessArr[k][m];
color=0;
}
else if(chessArr[k][m]!=0){
if(color==0){
color=chessArr[k][m];
code+=chessArr[k][m];
}
else if(chessArr[k][m]==color)
code+=chessArr[k][m];
else if(chessArr[k][m]!=color){
code+=chessArr[k][m];
color=chessArr[k][m];
break;
}
}
}
if(weightMap.get(code)!=null)
chessValue[i][j]+=weightMap.get(code);
}
}
}
return chessValue;
}
public GameMouse(){
}
public GameMouse(Graphics gr){
this.gr=gr;
}
public void setGr(Graphics gr){
this.gr=gr;
}
public void setPanel(JPanel jPanel){
this.jPanel=jPanel;
}
public void setJd(JDialog jd){
this.jd=jd;
}
public int[][] returnArr(){
return chessArr;
}
public void actionPerformed(ActionEvent e) {
JButton jbu = (JButton)e.getSource();
name=jbu.getText();
if(name.equals("开始")){
statue=true;
clearChess();
}
if(name.equals("悔棋")){
//得到最后一个点并删除
point=arr.getLast();
arr.removes(point);
chessArr[point.getY()][point.getX()]=0;
//重绘删除点后的棋盘
jPanel.paint(gr);
//判断下一次谁先手
if(point.getColor()==1)
flag=true;
else
flag=false;
}
if(name.equals("复盘")){
//清除棋盘
clearChess();
for(int i=0;i<arr.size();i++){
//取出棋子
point=arr.get(i);
//设置时间间隔
try {
Thread.sleep(2000);
} catch (InterruptedException ex) {
ex.printStackTrace();
}
//偶数黑棋，单数白棋
if(i%2==0)
chessArr[point.getY()][point.getX()]=1;
else
chessArr[point.getY()][point.getX()]=2;
jPanel.paint(gr);
}
}
if(name.equals("人机对战")){
clearChess();
statue1=true;
statue=true;
}
}
public void clearChess(){
for(int i=0;i<chessArr.length;i++)
for(int j=0;j<chessArr[i].length;j++)
chessArr[j][i]=0;
jPanel.paint(gr);
}
public int check(int gridx,int gridy){
int chess=1;
for(int i=gridx+1;i<chessArr.length;i++){
if(chessArr[gridy][gridx]==chessArr[gridy][i])
chess++;
else
break;
}
for(int i=gridx-1;i>=0;i--){
if(chessArr[gridy][gridx]==chessArr[gridy][i])
chess++;
else
break;
}
return chess;
}
public int check1(int gridx,int gridy){
int chess1=1;
for(int i=gridy+1;i<chessArr.length;i++){
if(chessArr[gridy][gridx]==chessArr[i][gridx])
chess1++;
else
break;
}
for(int i=gridy-1;i>=0;i--){
if(chessArr[gridy][gridx]==chessArr[i][gridx])
chess1++;
else
break;
}
return chess1;
}
public int check2(int gridx,int gridy){
int chess2=1;
for(int i=gridy+1;i<chessArr.length;i++){
if(chessArr[gridy][gridx]==chessArr[i][gridx])
chess2++;
else
break;
}
for(int i=gridy-1;i>=0;i--){
if(chessArr[gridy][gridx]==chessArr[i][gridx])
chess2++;
else
break;
}
return chess2;
}
public int check3(int gridx,int gridy){
int chess3=1;
for(int i=gridx+1,j=gridy+1;i<chessArr.length&&j<chessArr.length;i++,j++){
if(chessArr[gridy][gridx]==chessArr[j][i])
chess3++;
else
break;
}
for(int i=gridx-1,j=gridy-1;i>=0&&j>=0;i--,j--){
if(chessArr[gridy][gridx]==chessArr[j][i])
chess3++;
else
break;
}
return chess3;
}
public int check4(int gridx,int gridy){
int chess4=1;
for(int i=gridx+1,j=gridy-1;i<chessArr.length&&j>=0;i++,j--){
if(chessArr[gridy][gridx]==chessArr[j][i])
chess4++;
else
break;
}
for(int i=gridx-1,j=gridy+1;i>=0&&j<chessArr.length;i--,j++){
if(chessArr[gridy][gridx]==chessArr[j][i])
chess4++;
else
break;
}
return chess4;
}
public int CheckRow(int gridx,int gridy){
if(check(gridx,gridy)>=5||check1(gridx,gridy)>=5||check2(gridx,gridy)>=5||check3(gridx,gridy)>=5||check4(gridx,gridy)>=5){
if(chessArr[gridy][gridx]==1)
return 1;
if(chessArr[gridy][gridx]==2)
return 2;
}
return 0;
}
public void aichess(){
try {
Thread.sleep(1000);
} catch (InterruptedException ex) {
ex.printStackTrace();
}
int x = 0,y=0;
if(flag==false){
weight=null;
weight=ai();
for(int i=0;i<weight.length;i++){
for(int j=0;j<weight[i].length;j++){
if(weight[j][i]>=weight[y][x]){
y=j;
x=i;
}
System.out.print(weight[i][j]+" ");
}
}
System.out.println();
for(int i=0;i<30;i++){
gr.setColor(new Color(155+3*i,155+3*i,155+3*i));
gr.fillOval((x + 1) * 40 - 15+i/2, (y + 1) * 40 - 15+i/2, 30-i, 30-i);
}
chessArr[y][x] = 2;
Point po=new Point(x,y,2,order++);
arr.add(po);
flag=true;
re[0]=y;
re[1]=x;
}
}
public void mouseClicked(MouseEvent e) {
int x1=e.getX();
int y1=e.getY();
if ((x1-40)%40>20) {
gridx=(x1-40)/40+1;
} else
gridx=(x1-40)/40;
if ((y1-40)%40>20) {
gridy=(y1-40)/40+1;
}
else
gridy=(y1-40)/40;
if(statue==true){
if (0<=gridx && gridx<= 14 && 0<=gridy && gridy<= 14 &&chessArr[gridy][gridx]!=1&&chessArr[gridy][gridx]!=-1)
{
if(flag==true) {
for(int i=0;i<30;i++){
gr.setColor(new Color(5*i,5*i,5*i));
gr.fillOval((gridx + 1) * 40 - 15+i/2, (gridy + 1) * 40 - 15+i/2, 30-i, 30-i);
}
chessArr[gridy][gridx] = 1;
Point po=new Point(gridx,gridy,1,order++);
arr.add(po);
flag=false;
if(statue1==true)
aichess();
}
else {
for(int i=0;i<30;i++){
gr.setColor(new Color(155+3*i,155+3*i,155+3*i));
gr.fillOval((gridx + 1) * 40 - 15+i/2, (gridy + 1) * 40 - 15+i/2, 30-i, 30-i);
}
chessArr[gridy][gridx] = 2;
Point po=new Point(gridx,gridy,2,order++);
arr.add(po);
flag=true;
}
int result=CheckRow(gridx,gridy);
if(result==1){
jd.add(text1);
jd.setVisible(true);
}
if(result==2){
jd.add(text2);
jd.setVisible(true);
}
if(statue1==true){
int result1=CheckRow(re[1],re[0]);
if(result1==1){
jd.add(text1);
jd.setVisible(true);
}
if(result1==2){
jd.add(text2);
jd.setVisible(true);
}
}
}
}
}
}
扫一扫
617
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
