精华内容
下载资源
问答
  • HTML5中国象棋游戏 自定义象棋难度 D
  • html5中国象棋游戏自定义象棋难度:有新手水平,中级水平,悔棋,换肤功能
  • 棋类游戏在桌面游戏中已经非常成熟,中国象棋的版本也非常多。今天这款基于HTML5技术的中国象棋游戏非常有特色,我们不仅可以选择中国象棋的游戏难度,而且可以切换棋盘的样式。程序写累了,喝上一杯咖啡,和电脑...
    棋类游戏在桌面游戏中已经非常成熟,中国象棋的版本也非常多。今天这款基于HTML5技术的中国象棋游戏非常有特色,我们不仅可以选择中国象棋的游戏难度,而且可以切换棋盘的样式。程序写累了,喝上一杯咖啡,和电脑对弈几把吧,相信这HTML5中国象棋游戏的实现算法你比较清楚,可以打开源码来研究一下这款HTML5中国象棋游戏。
    
    1488941107-7443-html5-zgxq

    查看原文:http://www.51xyyx.com/3063.html
    展开全文
  • Android自定义中国象棋

    2019-11-04 17:25:40
    Android自定义中国象棋,原创-------转载注明出处; Android自定义中国象棋,原创-------转载注明出处; Android自定义中国象棋,原创-------转载注明出处; Android自定义中国象棋,原创-------转载注明出处; ...
  • Android 自定义控件实现基本象棋游戏

    千次阅读 2018-08-28 22:29:19
    周末闲来没事, 以自定义控件的方式写了一象棋游戏, 实现了象棋基本走子吃子规则, 红黑双方轮流走棋. 先贴上apk下载地址, 感兴趣的可以下载下来玩玩(虽然不能一个人玩~[滑稽]~) github项目地址: ...

    #####周末闲来没事, 以自定义控件的方式写了一象棋游戏, 实现了象棋基本走子吃子规则, 红黑双方轮流走棋. 先贴上apk下载地址, 感兴趣的可以下载下来玩玩(虽然不能一个人玩[滑稽])

    github项目地址: https://github.com/EshelGuo/Chess

    先贴一运行效果图(棋子棋盘图素在百度上找的, 所以不是很清晰):

    这里写图片描述

    实际上写这个象棋也就是写来玩玩, 但既然写到博客上那就不能随便贴个图贴个代码草草了事, 我就大致说下我的基本思路.

    最初的设想其实很简单, 就是继承View通过 canvas.drawBitmap 这个api 分别将棋盘棋子画到画布上, 通过计算棋盘边界宽度和格子宽度, 来将Android中的坐标(左上为0,0)转化为象棋中的坐标(左下为0,0 x轴1到9, y轴1到10)来计算走子吃子, 反过来转换来进行绘制.
    这里写图片描述

    上图是整个象棋游戏的结构 ChessView即整个象棋游戏的自定义控件, 枚举类Color来代表红黑阵营,Type来代表 车马炮 等棋子种类 Pieces 则代表棋子 Location类来将棋子坐标和像素点坐标进行互相转换, PiecesFactory 用来初始化开局游戏棋子位置, Style类用来控制棋子棋盘样式, ResCache则对Bitmap进行了缓存, Rule类用与控制能否吃子走子逻辑以及一些样式配置, Game类代表一盘游戏, 并担当了ChessView与Rule调用的桥梁, Game类负责容纳32个棋子以及3个空位置(空位置用来标志上次走动的轨迹), Rule类种通过切换阵营来实现红黑双方轮流走子.

    感兴趣的可以到github把代码拉下来看看

    展开全文
  • 从Chess.com数据获取视觉反馈,以改善国际象棋。 一种有趣而有效的方式来改善计算/可视化。 学习React。 改进/探索javascript和函数式编程。 特征 从Chess.com api导入游戏。 创建不同种类的图表,以可视化从...
  • #!/bin/bash PS3="please choice the first color :" select color1 in hong lv huang lan zi qianlan bai hei ;do [[ $REPLY =~ ^[1-8]$ ]] || { echo must 1-8;continue; } case $color1 in ...
    #!/bin/bash
    PS3="please choice the first color :"
    select color1 in hong lv huang lan zi qianlan bai hei ;do
    	[[ $REPLY =~ ^[1-8]$ ]] || { echo must 1-8;continue; }
    	case $color1 in
    	hong)
    		echo -e the first color is "\033[1;41m    \033[0m"
    		break
    		;;
    	lv)
    		echo -e the first color is "\033[1;42m    \033[0m"
    		break
    		;;
    	huang)
    		echo -e the first color is "\033[1;43m    \033[0m"
    		break
    		;;
    	lan)
    		echo -e the first color is "\033[1;44m    \033[0m"
    		break
    		;;
    	zi)
    		echo -e the first color is "\033[1;45m    \033[0m"
    		break
    		;;
    	qianlan)
    		echo -e the first color is "\033[1;46m    \033[0m"
    		break
    		;;
    	bai)
    		echo -e the first color is "\033[1;47m    \033[0m"
    		break
    		;;
    	hei)
    		echo -e the first color is "\033[1;48m    \033[0m"
    		break
    		;;
    	esac
    done
    
    PS3="please choice the second color :"
    select color2 in hong lv huang lan zi qianlan bai hei ;do
    	[[ $REPLY =~ ^[1-8]$ ]] || { echo must 1-8;continue; }
    	case $color2 in
    	hong)
    		echo -e the first color is "\033[1;41m    \033[0m"
    		break
    		;;
    	lv)
    		echo -e the first color is "\033[1;42m    \033[0m"
    		break
    		;;
    	huang)
    		echo -e the first color is "\033[1;43m    \033[0m"
    		break
    		;;
    	lan)
    		echo -e the first color is "\033[1;44m    \033[0m"
    		break
    		;;
    	zi)
    		echo -e the first color is "\033[1;45m    \033[0m"
    		break
    		;;
    	qianlan)
    		echo -e the first color is "\033[1;46m    \033[0m"
    		break
    		;;
    	bai)
    		echo -e the first color is "\033[1;47m    \033[0m"
    		break
    		;;
    	hei)
    		echo -e the first color is "\033[1;48m    \033[0m"
    		break
    		;;
    	esac
    done
    
    read -p "please input the number of space: " n
    until [[ $n =~ ^[[:digit:]]+$ ]];do
    	echo "must be a number"
    	unset n
    	read -p "please input the number of space: " n
    done
    	
    hong () {
    for a in `seq $n`;do
    echo -e "\033[1;41m \033[0m\c"
    done
    }
    lv () {
    for b in `seq $n`;do
    echo -e "\033[1;42m \033[0m\c"
    done
    }
    huang () {
    for c in `seq $n`;do
    echo -e "\033[1;43m \033[0m\c"
    done
    }
    lan () {
    for d in `seq $n`;do
    echo -e "\033[1;44m \033[0m\c"
    done
    }
    zi () {
    for e in `seq $n`;do
    echo -e "\033[1;45m \033[0m\c"
    done
    }
    qianlan () {
    for f in `seq $n`;do
    echo -e "\033[1;46m \033[0m\c"
    done
    }
    bai () {
    for g in `seq $n`;do
    echo -e "\033[1;47m \033[0m\c"
    done
    }
    hei () {
    for h in `seq $n`;do
    echo -e "\033[1;48m \033[0m\c"
    done
    }
    
    
    declare -i i=1
    while [ $i -le 8 ];do
            if [ $[i%2] -eq 0 ];then
                    declare -i j=1
                    while [ $j -le 8 ];do
                            if [ $j -eq 4 ];then
    				`echo $color1`;`echo $color2`
                                    echo
                                    let ++j
                                    continue
                            fi
                            `echo $color1`;`echo $color2`
                            let ++j
                    done
                    echo
            else
                    declare -i k=1
                    while [ $k -le 8 ];do
                            if [ $k -eq 4 ];then
                                    `echo $color2`;`echo $color1`
                                    echo
                                    let ++k
                                    continue
                            fi
                            `echo $color2`;`echo $color1`
                            let ++k
                    done
                    echo
            fi
    let ++i
    done
    
    
    展开全文
  • 今天我们来讲解国际象棋的最后一个部分,判断赢棋与和棋,并实现自定义棋盘的功能。 在国际象棋比赛中,判断赢棋的方式有三种:将杀,认输和超时。在这里认输属于主观判断,而我这次也没有把计时功能写进去,所以就...

    Hello!大家好!今天我们来讲解国际象棋的最后一个部分,判断赢棋与和棋,并实现自定义棋盘的功能。

    在国际象棋比赛中,判断赢棋的方式有三种:将杀,认输和超时。在这里认输属于主观判断,而我这次也没有把计时功能写进去,所以就只写了一个判断将死的函数。

    当然了,写这一个就已经很费事了。大家还记得我们在上一期当中是如何应对将军等一系列问题的吗?我采取的方法是不直接在走棋之前处理这些问题,而是在走完棋之后对这个棋盘进行将军的判断,如果走棋一方仍然处于被将军的状态,则自动悔棋。虽然这个方法在当时确实帮我避免了很多复杂的逻辑处理,但是现在在判断将杀的时候我意识到之前悔棋方法的局限性。因为我们不能简单地判断被将军的一方是否有合法走棋,按照我们的逻辑只要不违背最基本的走子规则都不算违例,因此即使被将杀他还是有很多“合法”的棋可以走。即使应用我之前的方法,也只是不停地被悔棋,电脑是不会知道你已经没棋可走了,让电脑自动执行move()函数更是天方夜谭,因为move()函数本身就是建立在鼠标监听器下的。

    在这种情况下我们有什么样的解决办法呢?我在这里还是会用到我处理将军的方法。只不过方式大有不同,要写的辅助函数也有很多。

    在国际象棋规则中,当一方被将军时,它有三种应对的方法:
    1.吃掉对方将军的棋子
    2.在对方的棋子和自己的王中间点上自己的棋子
    3.移走自己的王
    如果以上三种方式都避免不了将军的话,那他就算是被将死了。

    这样,我的思路也随之出来了。那就是在将军的时候对以上三种方法分别判断,然后取一个并集。
    在进入主体代码之前,先介绍两个实现自动走棋和悔棋的函数。

    这是实现自动走棋的函数
    private static MyLabel[][] trymove(MyLabel a,MyLabel b,MyLabel[][] c) {
      MyLabel[][] answer=c;我在这里做了一个浅拷贝,不过好像并没有什么用
      MyIcon icon=(MyIcon) a.getIcon();
      capturedpiece2=(MyIcon) b.getIcon();————capturedpiece2是一个新的全局变量,
      作用相当于手动走棋当中的capturedpiece
      answer[b.row][b.col].setIcon(icon);把目标格子设置上起始格子的图标
      answer[a.row][a.col].setIcon(null);把起始格子的图标取消
      return answer;
     }
    

    在这里我没有考虑到吃过路兵的情况,不过我是真的不想考虑这种情况,太极端了,几乎不会出现。王车移位的情况不需要考虑,因为之前的逻辑已经限制住了(被将军的时候不能移位)。

    这是手动悔棋函数,要注意它的参数多了一个MyIcon
    private static MyLabel[][] undo2(MyLabel a,MyLabel b,MyLabel[][] c,MyIcon piece){
      MyIcon icon=(MyIcon) b.getIcon();
      c[b.row][b.col].setIcon(piece);把原目标格子设置上原来棋子的图标,
      在这里就是指capturedpiece2
      c[a.row][a.col].setIcon(icon);把原起始格子设置上走动的棋子
      return c;  
     }
    

    写完这两个函数,我们就开始判断被将军的一方是否可以移走他的王

    private static boolean canrun() {
      if(ischecking2(labels)) {首先这个函数只适用于被将军的时候,而且是判断走棋之前被将军,
      因此要用到ischecking2
       for(int i=1;i<rows+1;i++) {
        for(int j=1;j<cols+1;j++) {
         MyIcon icon=(MyIcon) labels[i][j].getIcon();
         if(icon!=null&&getside(icon)==sidetomove&&getname(icon)=="king") {找到被将军的王
          for(int x=1;x<rows+1;x++) {
           for(int y=1;y<cols+1;y++) {
            if(islegalmove(labels[i][j],labels[x][y])) {判断走棋是否合法
             MyLabel[][] resultboard=trymove(labels[i][j],labels[x][y],labels);  
              这时候我们会用到我们自动走棋的函数trymove,试着把王走到那一个格子中
    
            if(!ischecking2(resultboard)) {然后判断走完棋之后是否被仍然将军,
            注意,自动走棋的函数并没有转换sidetomove,所以还是要用ischecking2来检查
              resultboard=undo2(labels[i][j],labels[x][y],labels,capturedpiece2);
              在检查完了之后,不管判断的结果如何,一定要手动悔棋,还原棋盘。
              return true;
             }
             resultboard=undo2(labels[i][j],labels[x][y],labels,capturedpiece2);
            }
           }
          }
         }
        }
       }
       return false;
      }
      return true;
     }
    

    然后是判断吃和垫两个方法,与直接把王逃走的方法不同,如果对方将军的棋子有两个的话,这两种方法都是行不通的。所以我们还要引入一个判断有几个子将军的函数

    private static ArrayList<MyLabel> checkingpieces(MyLabel[][] a) { 
      ArrayList<MyLabel> answer=new ArrayList<>();
      for(int i=1;i<rows+1;i++) {
       for(int j=0;j<cols+1;j++) {
        MyIcon icon=(MyIcon) a[i][j].getIcon();
        if(icon!=null&&getname(icon)=="king") {找到被将军的王
         for(int x=1;x<rows+1;x++) {
          for(int y=1;y<cols+1;y++) {
           MyIcon icon1=(MyIcon) a[x][y].getIcon();                
           if(icon1!=null&&getside(icon1)!=getside(icon)
              &&getside(icon1)!=sidetomove
              &&islegalmove(a[x][y],a[i][j])) {找到对方威胁到王的棋子
            answer.add(a[x][y]);
            if(answer.size()==2) {最多有两个棋子将军
             return answer;
            }
           }  
          }
         }        
        }
       }    
      }
      return answer;
     }
    

    找出将军的棋子之后我们就可以开始判断吃了

    private static boolean cantake() {
      int k=checkingpieces(labels).size();
      if(k==2) {如果有两个棋子将军,则不能吃
       return false;
      }
      if(k==1) {
       MyLabel label=(MyLabel) checkingpieces(labels).get(0);这是唯一的将军的棋子
       MyIcon icon=(MyIcon) label.getIcon();
       for(int i=1;i<rows+1;i++) {
        for(int j=1;j<cols+1;j++) {
         MyIcon icon1=(MyIcon) labels[i][j].getIcon();
         if(icon1!=null&&getside(icon1)!=getside(icon)&&getname(icon1)!="king") {
         找出己方可以吃掉对方将军棋子的棋子,在这里我们不包括王,因为在写canrun()的时候已经考虑到了
          if(islegalmove(labels[i][j],label)) {如果是合法走棋,证明可以吃掉棋子
           return true;
          }
         }
        }
       }
       return false;
      }
      return true;
     }
    

    最后一个,也是最复杂的是判断能不能把自己的棋子垫到王和对方棋子中间。因为国际象棋没有蹩马腿,这要求对方将军的棋子只能是车,象或后。所以我们要检查对方将军棋子和王是在同一直线上还是斜线上。然后分情况分析

    判断是否在同一直线上
    private static boolean sameline(MyLabel a,MyLabel b) {
      return((a.row==b.row&&a.col!=b.col)||(a.col==b.col&&a.row!=b.row));    
     }
    
    private static boolean canblock() {
      int k=checkingpieces(labels).size();
      if(k==2) {如果有两个棋子将军,同样不能垫
       return false;
      }
      if(k==1) {
       MyLabel label=(MyLabel) checkingpieces(labels).get(0);
       MyIcon icon=(MyIcon) label.getIcon();
       if(getname(icon)=="knight"||getname(icon)=="pawn") {如果是马或兵将军,也不能垫
        return false;
       }
       for(int i=1;i<rows+1;i++) {
        for(int j=1;j<cols+1;j++) {
         MyIcon icon1=(MyIcon) labels[i][j].getIcon();
         if(icon1!=null&&getside(icon1)!=getside(icon)&&getname(icon1)=="king"
          &&(Math.abs(i-label.row)!=1||(Math.abs(j-label.col)==1))) {最后一项要求行与列的相对距离不能为一,至少是二
          if(sameline(labels[i][j],label)) {   考虑同一直线的情况 
           if(label.row==i) {考虑同一列的情况
            int c1=Math.max(label.col, j);
            int c2=Math.min(label.col, j);
            for(int x1=1;x1<rows+1;x1++) {
             for(int y1=1;y1<cols+1;y1++) {
              MyIcon icon2=(MyIcon) labels[x1][y1].getIcon();
              if(icon2!=null&&getside(icon2)==getside(icon1)&&getside(icon2)!="king") {对己方的棋子进行循环
               for(int m=c2+1;m<=c1-1;m++) {在直线上循环如果有棋子能到直线中间的一个格子去,
               就说明能够垫上
                if(islegalmove(labels[x1][y1],labels[i][m])) {
                 return true;
                }
               }
              }
             }
            }                  
           }
           if(label.col==j) {考虑同一行的情况,逻辑同上
            int r1=Math.max(label.row,i);
            int r2=Math.min(label.row,i);
            for(int x2=1;x2<rows+1;x2++) {
             for(int y2=1;y2<cols+1;y2++) {
              MyIcon icon3=(MyIcon) labels[x2][y2].getIcon();
              if(icon3!=null&&getside(icon3)==getside(icon1)
                  &&getname(icon3)!="king") {
               for(int m=r2+1;m<=r1-1;m++) {
                if(islegalmove(labels[x2][y2],labels[i][m])) {
                 return true;
                }
               }
              }
             }
            }   
           }
          }
          if(samediagonal(labels[i][j],label)) {考虑同一斜线的情况,基本方法跟判断象的走棋规则相似
           int r1=Math.max(label.row,i);
           int r2=Math.min(label.row,i);
           int c1=Math.max(label.col, j);
           int c2=Math.min(label.col, j);
           for(int x3=1;x3<rows+1;x3++) {
            for(int y3=1;y3<cols+1;y3++) {
             MyIcon icon4=(MyIcon) labels[x3][y3].getIcon();
             if(icon4!=null&&getside(icon4)==getside(icon1)
                 &&getname(icon4)!="king") {
              for(int n1=r2+1;n1<+r1-1;n1++) {
               for(int n2=c2+1;n2<c1-1;n2++) {也是在一个长方形里面进行循环
                if(samediagonal(label,labels[n1][n2])
                 &&islegalmove(labels[x3][y3],labels[n1][n2])) {
                 被循环到的格子必须和王在同一直线上,然后查看能否垫上
                 return true;
                }
               }
              }
             }
            }
           }
          }
          return false;
         }
        }   
       }
      }
      return true;
     }
    

    这样一来,我们完成了吃,垫,逃三个部分的判断。再去判断是否将杀就非常简单了。因为我之前写的三个函数都是判断被将军的一方能不能应对,所以在取完并集之后还要取一下补集。

    private static boolean ischeckmate() {
      if(ischecking2(labels)) {必须被将军才会触发判断
       return !(canrun()||cantake()||canblock());
      }
      return false;  
     }
    

    现在要判断和棋了,国际象棋当中和棋的可能性有以下几种:
    1.无子可动
    2.子力不足
    3.三次重复局面
    4.五十回合
    5.长将
    6.双方议和
    很遗憾我在这里只写出了无子可动的判断

    private static boolean isstalemate() {
            for(int i=1;i<rows+1;i++) {
             for(int j=1;j<cols+1;j++) {
              MyIcon icon=(MyIcon) labels[i][j].getIcon();
              if(icon!=null&&getside(icon)==sidetomove) {
               for(int x=1;x<rows+1;x++) {
                for(int y=1;y<cols+1;y++) {
                 if(islegalmove(labels[i][j],labels[x][y])) {
                  trymove(labels[i][j],labels[x][y],labels);在这里也是进行自动走棋
                  if(!ischecking2(labels)) {然后自动悔棋
                   undo2(labels[i][j],labels[x][y],labels,capturedpiece2);
                   如果有一种走法是合法的并且不会触发将军,就不算无子可动
                   return false;
                  }
                  undo2(labels[i][j],labels[x][y],labels,capturedpiece2);
                 }
                }
               }
              }
             }
            }
      return true;
     }
    

    最后我们就是要加入自定义棋盘功能
    既然要自定义棋盘,清空棋盘这个步骤是必不可少的。因此我们需要先写一个清空棋盘的函数

    private static void clearboard() {
      for(int i=1;i<rows+1;i++) {
       for(int j=1;j<cols+1;j++) {
        labels[i][j].setIcon(null);
       }
      }
     }
    
    private static JFrame setboard() {
      JFrame f=new JFrame();
      Dimension d=new Dimension(50,50);
      Dimension d2=new Dimension(80,50);
      f.setLayout(new FlowLayout());
      f.setSize(350,300);
      ArrayList<JButton> buttons=new ArrayList<>();
      为了方便起见,我在这里建了一个Arraylist,把所有的JButton都放进去,然后对它们进行相同的操作
      JButton whitepawn=new JButton();
      whitepawn.setIcon(new MyIcon(paths[1]));
      JButton whiteknight=new JButton();
      whiteknight.setIcon(new MyIcon(paths[8]));
      JButton whitebishop=new JButton();
      whitebishop.setIcon(new MyIcon(paths[9]));
      JButton whiterook=new JButton();
      whiterook.setIcon(new MyIcon(paths[7]));
      JButton whitequeen=new JButton();
      whitequeen.setIcon(new MyIcon(paths[10]));
      JButton whiteking=new JButton();
      whiteking.setIcon(new MyIcon(paths[11]));
      JButton blackpawn=new JButton();
      blackpawn.setIcon(new MyIcon(paths[0]));
      JButton blackknight=new JButton();
      blackknight.setIcon(new MyIcon(paths[3]));
      JButton blackbishop=new JButton();
      blackbishop.setIcon(new MyIcon(paths[4]));
      JButton blackrook=new JButton();
      blackrook.setIcon(new MyIcon(paths[2]));
      JButton blackqueen=new JButton();
      blackqueen.setIcon(new MyIcon(paths[5]));
      JButton blackking=new JButton();
      blackking.setIcon(new MyIcon(paths[6]));
      buttons.add(whitepawn);
      buttons.add(whiteknight);
      buttons.add(whitebishop);
      buttons.add(whiterook);
      buttons.add(whitequeen);
      buttons.add(whiteking);
      buttons.add(blackpawn);
      buttons.add(blackknight);
      buttons.add(blackbishop);
      buttons.add(blackrook);
      buttons.add(blackqueen);
      buttons.add(blackking);
      
      for(int i=0;i<12;i++) {
       JButton b=buttons.get(i);
       b.setPreferredSize(d);设置大小
       b.addActionListener(new ActionListener(){增加监听器
        @Override
        public void actionPerformed(ActionEvent e) {
         selectedpiece=(MyIcon) b.getIcon();
         在这里selectedpiece使我们又一个全局变量,它代表的是选中的棋子,选中之后我们就可以把它放在我们想要的位置
        }   
       });
       f.add(b);
      }
      JButton clearboard=new JButton("clear");这是一个清空棋盘的按钮,有清空棋盘的功能
      clearboard.setPreferredSize(d2);
      clearboard.addActionListener(new ActionListener() {
       @Override
       public void actionPerformed(ActionEvent e) {
        clearboard();
       }    
      });
      JButton confirm=new JButton("确定");在设置玩棋盘之后,点击确定就可以关闭自定义的JFrame
      confirm.setPreferredSize(d2);
      confirm.addActionListener(new ActionListener() {
       @Override
       public void actionPerformed(ActionEvent e) {
        settingmode=false;在这里settingmode也是一个全局变量,代表是否开启了自定义模式,以后会用到
        f.dispose();
       }  
      });
    再接下来就是设定轮到哪一方先走棋
      JButton white=new JButton("white");
      white.setPreferredSize(d2);
      white.addActionListener(new ActionListener() {
       @Override
       public void actionPerformed(ActionEvent e) {
        sidetomove="white";    
       }  
      });
      JButton black=new JButton("black");
      black.setPreferredSize(d2);
      black.addActionListener(new ActionListener() {
       @Override
       public void actionPerformed(ActionEvent e) {
        sidetomove="black";    
       }  
      });
      f.add(white);
      f.add(black);
      f.add(clearboard);
      f.add(confirm);
      f.setVisible(true);
      return f;
     }
    

    当然只有这单独的一个函数是不足以实现自定义棋盘的功能的
    我们还需要一个最后的函数,把整个国际象棋这个类加到一个JFrame里面。

    private static JFrame constructmenu1() { 
      国际象棋 game=new 国际象棋();
      int[] a=game.Returnsize();  
      JFrame frame=new JFrame();
      JMenuBar menuBar = new JMenuBar();设置一个菜单栏
      frame.setJMenuBar(menuBar);
      final JMenu menu = new JMenu("菜单");
      menuBar.add(menu);
    
    在菜单里面加入下面几个选项
      final JMenuItem starter = new JMenuItem("新游戏");
      final JMenuItem undo=new JMenuItem("悔棋");
      final JMenuItem customise=new JMenuItem("自定义");
      menu.add(starter);
      menu.add(undo);
      menu.add(customise);
      starter.addActionListener(new ActionListener() {选择新游戏,就在呈现一个新的棋盘
       @Override
       public void actionPerformed(ActionEvent e) {
        JFrame f=constructmenu1();
       }  
      });
      undo.addActionListener(new ActionListener() {
       @Override
       public void actionPerformed(ActionEvent e) {这是涉及到手动悔棋的监听器
        MyLabel a=recordedmove.get(recordedmove.size()-1)[1];我们需要找到上一步的终止点,然后分情况判断
        if(justcastled) {如果上一步进行了王车移位,就要用到王车移位特有的悔棋函数
         uncastle(a);
        }    
        else {此外用一般的悔棋函数
         undo(); 
        }       
       }   
      });
      customise.addActionListener(new ActionListener() {这是自定义棋盘选项的监听器
       @Override
       public void actionPerformed(ActionEvent e) {
        settingmode=true;把自定义模式设为正确
        setboard();执行setboard()函数
       }  
      });
      frame.setSize(a[1], a[0]);
      frame.setTitle("国际象棋");
      frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
      Container c=frame.getContentPane();
      c.add(game);
      frame.setVisible(true);
      return frame;
     }
    

    写完这个函数之后我们还要找到我们最初最初initlabels()这个函数,对他原来的监听器进行修改

    jl.addMouseListener(new MouseAdapter() {     
         public void mouseClicked(MouseEvent e) {
          if(e.getButton()==MouseEvent.BUTTON1){ 
           if(!settingmode) {第一步要判断是不是出于自定义模式
            if(jl.row!=0&&jl.col!=0) {不是的话,还要检查不要点击到边上
             move(jl);       执行move()函数
             if(clickcount%2==0) { 当点击计数器为偶数的时候,
             也就是通常走完一步棋的时候,要对局面进行赢棋和和棋的判断
              if(ischeckmate()) {
               System.out.println("Congratulations!");   
              }  
              if(isstalemate()) {
               System.out.println("Draw by stalemate!");
              }
             } 
            } 
           }
           else {如果进入了自定义模式,就把这个格子设置上选好的棋子
            jl.setIcon(selectedpiece);
           }
          }      
         }
        });   
    

    到这里我们就大功告成了,如果大家想看我的全部代码的话可以在评论区告诉我一声。
    我不知道以后还可以编哪些小游戏,不知道大家有什么建议吗?

    展开全文
  • RSG-Chess-mobile:跨平台的移动国际象棋应用程序,由React Native构建并基于自定义API
  • 国际象棋引擎 待办事项:在此处写说明 安装 将依赖项添加到您的shard.yml : dependencies : chess_engine : github : your-github-user/chess_engine 运行分shards install 用法 require " chess_engine " 待...
  • 它可以从任何来源以pgn的形式下载国际象棋游戏,应用指定的过滤器并构造一个opentree。 该树在棋盘上可视化。 它还显示获胜百分比和其他具有不同动作的统计数据 架构图 这与代码模块没有一对一的关联,但是准确地...
  • Protochess是一个在线国际象棋网站,旨在让您定制自己的国际象棋棋盘/棋子。 想要一块可以像骑士+皇后一样移动的棋子吗? 当然。 是否想在16x16尺寸的板上玩游戏? 不切实际,但您可以做到! 内置 后端/棋盘逻辑/...
  • 机器学习象棋 这是Google Deepmind的AlpahZero的Python实现。 该项目使用基于我的上一个的GUI和国际象棋引擎。 入门 依存关系 pip install -r requirements.txt 训练 要继续训练模型,请执行以下操作: python ...
  •  虽然我也承认这两棵树已经被人刨根问底的掘了N次,但对于自定义控件来说这树可不是说舍弃就舍弃的(要充分合理利用资源嘛)。  逻辑树(Logical Tree)当然是逻辑意义上的,如果把Visual 可以比作汽车的一部分...
  • 接口可用于实现自定义格式: #load(字节[],化ChessBoard)用来装入一个字节[](第一个参数)成棋盘(第二个参数)。 #save(器ChessBoard)用来序列棋盘的当前状态为一个字节[]。 为了使自己的实现没有显示在...
  • 象棋场 Chessground是为开发的免费/自由开源国际象棋UI。 它针对现代浏览器以及使用Cordova进行移动开发。 执照 Chessground是根据GPL-3.0许可(或您选择的... 使用自定义DOM差异算法将DOM写操作减少到绝对最小值。
  • 自定义View

    2016-06-06 20:26:19
    前面一种适合处理量比较小,帧率比较小的动画,比如说象棋游戏之类的;而后一种主要用在游戏,高品质动画方面的画图。 下面是 Canvas 类常用的方法: drawRect(RectFrect, Paint paint) // 绘制区域,参数一为...
  • Android中国象棋自绘简单实现

    千次阅读 2019-11-04 14:22:23
    中国象棋(引用自百度百科) 中国象棋是起源于中国的一种棋戏,属于二人对抗性游戏的一种,在中国有着悠久的历史。由于用具简单,趣味性强,成为流行极为广泛的棋艺活动。中国象棋是中国棋文化也是中华民族的文化瑰宝...
  • CANVAS应用-中国象棋body{margin: 0;padding: 0;}#div1{width:620px;height:620px;margin: 0 auto;margin-top: 50px;border: 2px solid #f00;}#div2{width:605px;height:120px;margin:0 auto;margin-top:10px;border...
  • 象棋中残局演练谱

    2019-05-20 16:57:13
    这里写自定义目录标题欢迎使用Markdown编辑器设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能,丰富你的文章UML 图表FLowchart流程图导出与...
  • 国际象棋 ChessUp是一个基于Web的应用程序,用于教授和研究国际象棋棋盘游戏。 特征 允许用户创建自定义曲目以进行训练。 然后,他可以共享,评论和扩展他的开口和变化的集合。
  • 自定义View总结

    2016-10-14 12:28:13
    在开发中对自定义View的使用非常的普遍,对Android的深入理解这也是必须了解的知识点。以下总结了一些常用的知识点,更多内容待补充。。。 一、 View的生命周期 onFinishInflate() 当View中所有的子控件均...
  • 这是一个带有自定义着色器的 3D 棋盘。 ExcaliLux = Excalibur Luxurious ,其中Excalibur是我的 AI 国际象棋引擎的名称。 回购是独立的。 JMonkeyEngine 库包含在“/lib”中。 该项目在 Ubuntu 上编译并成功运行。...
  • Qt开发人机象棋

    万次阅读 2021-01-04 22:21:48
    文章目录Qt开发人机象棋1. 类关系图2. 用到的技术手段2.1 界面计算分离2.2 线程2.3 定时器3. Qt开发象棋过程问题记录3.1 问题 1. 在初次开发中存在内存泄漏问题3.2 问题 2. 类设计糟糕,使得计算和界面未分离3.3 ...
  • 用java编写国际象棋

    千次阅读 多人点赞 2019-08-18 21:54:32
    我又做出来了一个国际象棋游戏,跟之前的斗兽棋比起来国际象棋无异要更大众化一些,所以还是希望各位编程爱好者和国际象棋爱好者支持一下啊! 其实看过我之前写的五子棋和斗兽棋的朋友们应该已经了解到,写棋类游戏...
  • 象棋军师app已经上线

    千次阅读 2016-11-11 13:59:27
    如果你象棋下的不好,可以试试这个APP。首先在电脑上打开在线象棋例如QQ新中国象棋或者途游象棋,然后在APP中打开手机摄像头拍摄棋局,APP就会给你指出一步好棋,小朋友们要不要试试看。在Apple app store搜索“象棋...
  • 3. 新增微博分享自定义URL功能,默认分享当前网址 4. 新增直播间观众模式触发式刷新功能,适用于WebSocket等模式 5. 优化手机中的效果,走子动画更加流畅 6. 优化组件路径,程序可自动识别图片、默认PHP接口等...
  • 中国象棋控件

    2006-03-16 00:00:00
    5、棋盘和棋子可以自定义,控件提供换肤方法; 6、可以控制红方或绿方先行,由属性进行设置; 7、控件输出着法的中文描述,如马2进3; 8、提供悔棋功能,控件提供悔棋方法; 9、可以任意缩放; 10、...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,311
精华内容 924
关键字:

自定义象棋